UCOSIII 软件定时器

最新推荐文章于 2024-08-27 08:59:17 发布

原创最新推荐文章于 2024-08-27 08:59:17 发布 · 357 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#UCOSIII

stm32 UCOSIII 专栏收录该内容

9 篇文章

订阅专栏

本文详细介绍RTOS中定时器的配置与使用，包括定时器分辨率的设定、定时器的创建与控制函数，以及通过示例代码展示如何在RTOS环境下进行多任务管理与定时操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、相关理论

1、使用定时器需开启宏 OS_CFG_TMR_DEL_EN 1u

2、定时器分辨率由定义的系统节拍频率 OS_CFG_TICK_RATE_HZ 决定

如 OS_CFG_TMR_TASK_RATE_HZ = 100，系统时钟周期为 10ms 1000/100=10ms

OS_CFG_TICK_RATE_HZ =200，系统时钟周期为 5ms，定时器的最小分辨率 5ms

二、相关API函数

1、创建定时器函数 OSTmrCreate()

	OSTmrCreate (  (OS_TMR*)	&tmr1,
                   (CPU_CHAR*)	    "tmr1",
                   (OS_TICK )        20,				//初始化延时20*10=200ms
                   (OS_TICK)         100,				// 100*10=1000ms
                   (OS_OPT)          OS_OPT_TMR_PERIODIC,
                   (OS_TMR_CALLBACK_PTR)  tmr1_callback,
                   (void*)			0,
                   (OS_ERR*)		&err);

void OSTmrCreate (  OS_TMR *p_tmr,            //指向定时器
                    CPU_CHAR *p_name,         //定时器名称
                    OS_TICK dly,              //初始延时
                    OS_TICK period,            //定时时间
                    OS_OPT opt,                //运行选项
                    OS_TMR_CALLBACK_PTR p_callback,    //回调函数名称
                    void *p_callback_arg,       //回调函数的参数
                    OS_ERR *p_err)               //错误码

OS_OPT opt： OS_OPT_TMR_ONE_SHOT 单次定时器
             OS_OPT_TMR_PERIODIC 周期定时器

2、开启与关闭定时器函数

1、开启定时器
OSTmrStart(&tmr1,&err);

CPU_BOOLEAN  OSTmrStart (OS_TMR  *p_tmr,    //指向定时器
                         OS_ERR  *p_err)    //错误码
2、关闭定时器
OSTmrStop(&tmr1,OS_OPT_TMR_NONE,0,&err);     //关闭定时器 1

CPU_BOOLEAN  OSTmrStop (OS_TMR  *p_tmr,    //指向定时器
                        OS_OPT   opt,      //选项
                        void    *p_callback_arg,    //传入新的回调参数
                        OS_ERR  *p_err)

OS_OPT   opt：  OS_OPT_TMR_NONE            //除了停止计时什么都不做
                OS_OPT_TMR_CALLBACK        //执行回调参数
                OS_OPT_TMR_CALLBACK_ARG    //

三、模式图解

四、程序源码

#include "led.h"
#include "delay.h"
#include "sys.h"
#include "bsp_key.h"  
#include "usart.h"
#include "includes.h"

//任务优先级
#define START_TASK_PRIO		3
//任务堆栈大小	
#define START_STK_SIZE 		512
//任务控制块
OS_TCB StartTaskTCB;
//任务堆栈	
CPU_STK START_TASK_STK[START_STK_SIZE];
//任务函数
void start_task(void *p_arg);

//任务优先级
#define TASK1_TASK_PRIO		4
//任务堆栈大小	
#define TASK1_STK_SIZE 		128
//任务控制块
OS_TCB Task1TaskTCB;
//任务堆栈	
CPU_STK TASK1_TASK_STK[TASK1_STK_SIZE];
//任务函数
void task1_task(void *p_arg);

//任务优先级
#define TASK2_TASK_PRIO		5
//任务堆栈大小	
#define TASK2_STK_SIZE 		128
//任务控制块
OS_TCB Task2TaskTCB;
//任务堆栈	
CPU_STK TASK2_TASK_STK[TASK2_STK_SIZE];
//任务函数
void task2_task(void *p_arg);

//任务优先级
#define TASK3_TASK_PRIO		6
//任务堆栈大小	
#define TASK3_STK_SIZE 		128
//任务控制块
OS_TCB Task3TaskTCB;
//任务堆栈	
CPU_STK TASK3_TASK_STK[TASK3_STK_SIZE];
//任务函数
void task3_task(void *p_arg);

OS_MUTEX	TEST_MUTEX;		//定义一个互斥信号量


int main(void)
{
	OS_ERR err;
	CPU_SR_ALLOC();
	
	delay_init ();
	NVIC_PriorityGroupConfig (NVIC_PriorityGroup_2);  //设置中断优先级
	uart_init (115200);				//初始化串口
	printf("串口初始化完成\r\n");
	LED_Init();
	Key_GPIO_Config();
	
	OSInit(&err);
	OS_CRITICAL_ENTER();	//进入临界区
	OSTaskCreate(	(OS_TCB*)		&StartTaskTCB,			//任务控制块
                    (CPU_CHAR*)		"start_task ",		    //任务名称
                    (OS_TASK_PTR)   start_task,				//任务函数
                    (void*)          0,						//参数
                    (OS_PRIO)       START_TASK_PRIO,		//任务优先级
                    (CPU_STK*)      &START_TASK_STK[0],	    //任务堆栈基地址
                    (CPU_STK_SIZE)  START_STK_SIZE/10,	    //任务堆栈深度限位
                    (CPU_STK_SIZE)  START_STK_SIZE,			//任务堆栈大小
                    (OS_MSG_QTY)    0,						//任务内部消息队列能够接收的最大消息数目,为0时禁止接收消息		
                    (OS_TICK)       0,						//当使能时间片轮转时的时间片长度，为0时为默认长度
                    (void*)        	0,						//用户补充的存储区
                    (OS_OPT)        OS_OPT_TASK_STK_CHK|OS_OPT_TASK_STK_CLR,	//任务选项
                    (OS_ERR*)				&err);			//存放该函数错误时的返回值	
	
	OS_CRITICAL_EXIT();	//退出临界区
	OSStart(&err);
	
}

//开始任务函数
void start_task(void *p_arg)
{
	OS_ERR err;
	CPU_SR_ALLOC();
	p_arg = p_arg;

	CPU_Init();
#if OS_CFG_STAT_TASK_EN > 0u
   OSStatTaskCPUUsageInit(&err);  	//统计任务                
#endif
	
#ifdef CPU_CFG_INT_DIS_MEAS_EN		//如果使能了测量中断关闭时间
    CPU_IntDisMeasMaxCurReset();	
#endif
	
#if	OS_CFG_SCHED_ROUND_ROBIN_EN      //当使用时间片轮转的时候
	 //使能时间片轮转调度功能,时间片长度为1个系统时钟节拍，既1*5=5ms
	OSSchedRoundRobinCfg(DEF_ENABLED,1,&err);  
#endif		
	
	OS_CRITICAL_ENTER();	//进入临界区
	
	OSMutexCreate(	 (OS_MUTEX*)		&TEST_MUTEX,
                   (CPU_CHAR*)	"TEST_MUTEX",
                   (OS_ERR*)		&err);
									 
	OSTaskCreate(	(OS_TCB*)	&Task1TaskTCB,			    //任务控制块
                    (CPU_CHAR*)			"task1_task ",		//任务名称
                    (OS_TASK_PTR)   task1_task,				//任务函数
                    (void*)          0,						//参数
                    (OS_PRIO)       TASK1_TASK_PRIO,		//任务优先级
                    (CPU_STK*)      &TASK1_TASK_STK[0],
                    (CPU_STK_SIZE)  TASK1_STK_SIZE/10,
                    (CPU_STK_SIZE)  TASK1_STK_SIZE,
                    (OS_MSG_QTY)    0,
                    (OS_TICK)       0,
                    (void*)        	0,
                    (OS_OPT)        OS_OPT_TASK_STK_CHK|OS_OPT_TASK_STK_CLR,
                    (OS_ERR*)		&err);
										
	OSTaskCreate(	(OS_TCB*)		&Task2TaskTCB,		//任务控制块
                    (CPU_CHAR*)		"task2_task ",		//任务名称
                    (OS_TASK_PTR)   task2_task,			//任务函数
                    (void*)          0,		    		//参数
                    (OS_PRIO)       TASK2_TASK_PRIO,	//任务优先级
                    (CPU_STK*)      &TASK2_TASK_STK[0],
                    (CPU_STK_SIZE)  TASK2_STK_SIZE/10,
                    (CPU_STK_SIZE)  TASK2_STK_SIZE,
                    (OS_MSG_QTY)    0,
                    (OS_TICK)       0,
                    (void*)         0,
                    (OS_OPT)        OS_OPT_TASK_STK_CHK|OS_OPT_TASK_STK_CLR,
                    (OS_ERR*)		&err);

	OSTaskCreate(	(OS_TCB*)		&Task3TaskTCB,			//任务控制块
                    (CPU_CHAR*)		"task3_task ",			//任务名称
                    (OS_TASK_PTR)   task3_task,				//任务函数
                    (void*)          0,						//参数
                    (OS_PRIO)       TASK3_TASK_PRIO,		//任务优先级
                    (CPU_STK*)      &TASK3_TASK_STK[0],
                    (CPU_STK_SIZE)  TASK3_STK_SIZE/10,
                    (CPU_STK_SIZE)  TASK3_STK_SIZE,
                    (OS_MSG_QTY)    0,
                    (OS_TICK)       0,
                    (void*)        	0,
                    (OS_OPT)        OS_OPT_TASK_STK_CHK|OS_OPT_TASK_STK_CLR,
                    (OS_ERR*)		&err);
	OS_CRITICAL_EXIT();	                        //退出临界区
	OSTaskDel ((OS_TCB*)&StartTaskTCB,&err);	//删除任务自身
}

void task1_task(void *p_arg)
{
	u8 task1_num=0;
	OS_ERR err;
	CPU_SR_ALLOC();
	p_arg = p_arg;
	

	while(1)
	{
				OSTimeDlyHMSM(0,0,0,500,OS_OPT_TIME_HMSM_STRICT,&err); //延时500MS
				printf("任务1请求信号量\r\n");
				OSMutexPend(  &TEST_MUTEX, 0, OS_OPT_PEND_BLOCKING , 0,  &err);
				printf("任务1运行\r\n");
				OSMutexPost(  &TEST_MUTEX,OS_ERR_NONE, &err );
				OSTimeDlyHMSM(0,0,0,500,OS_OPT_TIME_HMSM_STRICT,&err); //延时500MS
	}

}

void task2_task(void *p_arg)
{
	u8 task2_num=0;
	OS_ERR err;
	CPU_SR_ALLOC();
	p_arg = p_arg;
	
	while(1)
	{
		printf("任务2运行\r\n");

		LED1=~LED1;
		OSTimeDlyHMSM(0,0,1,0,OS_OPT_TIME_HMSM_STRICT,&err); //延时1s
	
	}

}

void task3_task(void *p_arg)
{
	static u32 i;
	OS_ERR err;
	CPU_SR_ALLOC();
	p_arg = p_arg;
	
	while(1)
	{
		
		OSMutexPend(  &TEST_MUTEX, 0, OS_OPT_PEND_BLOCKING , 0,  &err);
		printf("任务3运行中\r\n");
		
		for(i=0;i<5000000;i++)
		{
			OSSched();		
		}

		OSMutexPost(  &TEST_MUTEX,OS_ERR_NONE, &err );
		OSTimeDlyHMSM(0,0,1,0,OS_ERR_NONE,&err); //延时1s
	
	}
}