首页 > 代码库 > 嵌入式:UCOSIII的使用

嵌入式:UCOSIII的使用

0、一些移植、系统相关 

OS_CFG_APP.H

                                                            /* --------------------- MISCELLANEOUS ------------------ */
#define  OS_CFG_MSG_POOL_SIZE            100u               /* 消息池 大小                                       */
#define  OS_CFG_ISR_STK_SIZE             128u               /* Stack size of ISR stack (number of CPU_STK elements)   */
#define  OS_CFG_TASK_STK_LIMIT_PCT_EMPTY  10u               /* Stack limit position in percentage to empty            */


                                                            /* ---------------------- IDLE TASK --------------------- */
#define  OS_CFG_IDLE_TASK_STK_SIZE       128u               /* 空闲任务 堆栈空间大小   (一般不做修改)                 */


                                                            /* ------------------ ISR HANDLER TASK ------------------ */
#define  OS_CFG_INT_Q_SIZE                10u               /* 中断服务队列 大小                                  */
#define  OS_CFG_INT_Q_TASK_STK_SIZE      128u               /* 中断服务队列 堆栈空间大小(一般不做修改)                  */

                                                            /* ------------------- STATISTIC TASK ------------------- */
#define  OS_CFG_STAT_TASK_PRIO    (OS_CFG_PRIO_MAX-2u)   /* 统计任务 优先级         (一般不做修改)                 */
#define  OS_CFG_STAT_TASK_RATE_HZ         10u               /* 统计任务频率 (1 to 10 Hz)                             */
#define  OS_CFG_STAT_TASK_STK_SIZE       128u               /* 统计任务 堆栈空间大小    (一般不做修改)                 */


                                                            /* ------------------------ TICKS ----------------------- */
#define  OS_CFG_TICK_RATE_HZ            200u                /* 时钟节拍频率 200HZ = 5ms  (10 to 1000 Hz)                */
#define  OS_CFG_TICK_TASK_PRIO             1u               /* 时钟节拍优先级,一般设置一个相对较高的优先级             */
#define  OS_CFG_TICK_TASK_STK_SIZE       128u               /* 时钟节拍堆栈空间大小    (一般不做修改)                 */
#define  OS_CFG_TICK_WHEEL_SIZE           17u               /* Number of ‘spokes‘ in tick  wheel; SHOULD be prime     */


                                                            /* ----------------------- TIMERS ----------------------- */
#define  OS_CFG_TMR_TASK_PRIO              2u               /* 软件定时器优先级				          */
#define  OS_CFG_TMR_TASK_RATE_HZ         100u               /* 软件定时器频率 100HZ = 10ms,不能小于心跳时钟节拍        */
#define  OS_CFG_TMR_TASK_STK_SIZE        128u               /* 软件定时器堆栈空间大小   (一般不做修改)                  */
#define  OS_CFG_TMR_WHEEL_SIZE            17u               /* Number of ‘spokes‘ in timer wheel; SHOULD be prime     */

 

OS_CFG.H:功能性裁剪

OS_APP_HOOKS.C:钩子函数

OS_CPU_A.ASM:PendSV中断、任务切换

OS_CPU_C.C: OSTaskStkInit函数,任务创建时,对堆栈初始化,寄存器地址要参照手册

 

 

1、框架写法(个人习惯相关)

1-1、main 函数里创建一个开始任务

int main(void)
{
	OS_ERR err;
	CPU_SR_ALLOC();
	
	初始化外设
	
	OSInit(&err);	      //初始化UCOSIII

	OS_CRITICAL_ENTER();    //进入临界区

	OSTaskCreate();       //创建开始任务 

	OS_CRITICAL_EXIT();    //退出临界区
 
	OSStart(&err);       //开启UCOSIII

        while(1);
}   

1-2、开始任务里,创建我们要运行的多个任务

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   //时间片轮转
	OSSchedRoundRobinCfg(DEF_ENABLED,1,&err);       //时间片长度为1个系统时钟节拍,既1*5=5ms
#endif		
	
	OS_CRITICAL_ENTER();	    //进入临界区
	
	OSTaskCreate(); 	    //创建任务	1		
	OSTaskCreate(); 	    //创建任务	2		 
	OSTaskCreate(); 	    //创建任务	3
	 
	OS_CRITICAL_EXIT();	     //进入临界区
	
	OSTaskDel((OS_TCB*)0,&err);  //删除start_task任务自身
}    

  

2、任务创建、挂起、删除

2-1、任务创建

//==================任务创建宏定义,便于修改==================

#define START_TASK_PRIO		3		//任务优先级
#define START_STK_SIZE 		128		//任务堆栈大小

OS_TCB StartTaskTCB;				//任务控制块
CPU_STK START_TASK_STK[START_STK_SIZE];	     //任务堆栈	

void start_task(void *p_arg);			//任务函数

//==================任务创建函数==================

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);		//任务 创建成功与否

2-2、任务挂起

OSTaskSuspend((OS_TCB*)&Task1TaskTCB,&err);		//挂起开始任务

2-3、任务解挂

OSTaskResume((OS_TCB*)&Task1TaskTCB,&err);    //任务解挂

2-4、任务删除

OSTaskDel((OS_TCB*)0,&err);	//删除start_task任务自身

 

3、时间片轮转

3-1、两个任务优先级相等

#define Task0_Task_Prio		4                //优先级4
#define Task0_Stk_Size		128
OS_TCB Task0TaskTCB;
CPU_STK Task0_Task_Stk[Task0_Stk_Size];
void Task0Task(void *p_arg);

#define Task1_Task_Prio		4                //优先级4
#define Task1_Stk_Size		128
OS_TCB Task1TaskTCB;
CPU_STK Task1_Task_Stk[Task1_Stk_Size];
void Task1Task(void *p_arg); 

3-2、使能轮转调度,调用API,设置单位时间

#if	OS_CFG_SCHED_ROUND_ROBIN_EN      //使用时间片轮转

	OSSchedRoundRobinCfg(DEF_ENABLED,1,&err);  //时间片长度为1个系统时钟节拍,既1*5=5ms
	
#endif	

3-3、创建任务时,设置任务的时间片大小

OSTaskCreate((OS_TCB 	* )&Task1TaskTCB,		
			 (CPU_CHAR	* )"Task1 task", 		
			 (OS_TASK_PTR )Task1Task, 			
			 (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	  )2,						//时间片长度为2*5=10ms					
			 (void   	* )0,				
			 (OS_OPT      )OS_OPT_TASK_STK_CHK|OS_OPT_TASK_STK_CLR, 
			 (OS_ERR 	* )&err);	

 

4、钩子函数。函数指针,UCOS不希望我们去修改他的文件,弄了钩子函数,比如 App_OS_IdleTaskHook ,在空闲时运行这个函数,功能自己填写。

4-1、使能钩子函数功能,并设置所有函数指针

#if OS_CFG_APP_HOOKS_EN > 0u	  //使能钩子函数
	App_OS_SetAllHooks();			
#endif

4-2、在 os_app_hooks.c 里的 App_OS_*Hook,里面填写你要的功能。

void  App_OS_IdleTaskHook (void)
{
	static int num ;
	num++;                //计算运行了多少次空闲任务
}

 

5、软件定时器

5-1、软件定时器创建

//==============定时器结构体、函数声明==============

OS_TMR Timer0;
void timer0CallBack(void *p_tmr, void *p_arg);

//==============定时器创建==============

//创建定时器0任务
OSTmrCreate (  (OS_TMR			*)&Timer0,		//定时器 结构体
		(CPU_CHAR		*)"time0",		//定时器 名字
		(OS_TICK		 )10,			//定时器 初次延时节拍 10*10 = 100ms
		(OS_TICK		 )100,			//定时器 以后延时节拍 100*10 = 1000ms = 1s
		(OS_OPT			 )OS_OPT_TMR_PERIODIC,	//定时器 选项 : 单次 或 周期。
		(OS_TMR_CALLBACK_PTR	 )timer0CallBack,	//定时器 回调函数,伪中断服务函数
		(void			*)0,			//定时器 中断服务函数的参数
		(OS_ERR			*)&err);		//定时器 创建成功与否

5-2、定时器“中断服务函数”,回调函数

void timer0CallBack(void *p_tmr, void *p_arg)
{
	//do something
}

 

6、信号量

6-1、信号量创建

OSSemCreate (   (OS_SEM      *)&mySem,		//信号量 结构体
		(CPU_CHAR    *)"semtest",	//信号量 名字
		(OS_SEM_CTR   )1,		//信号量 初始值,
		(OS_ERR      *)&err);		//信号量 创建成功是否

6-2、信号量等待

OSSemPend ((OS_SEM   *)&mySem,			//信号量 结构体
	  (OS_TICK   )0,			//信号量 等待超时时间
	  (OS_OPT    )OS_OPT_PEND_BLOCKING,	//信号量 阻塞 或 不阻塞
	  (CPU_TS   *)0,			//信号量 时间戳
	  (OS_ERR   *)&err);			//信号量 等待错误

6-3、信号量发送

OSSemPost ((OS_SEM  *)&mySem,		//信号量 结构体
	  (OS_OPT   )OS_OPT_POST_1,	//信号量 给就绪最高优先级
	  (OS_ERR  *)&err);		//信号量 等待错误

 

用途:   1、访问共享资源。

    2、中断发送信号,让处理在任务。

 

7、任务内建信号量

7-1、等待自身的信号量

OSTaskSemPend ( (OS_TICK   )0,				//内建信号量 超时时间
		(OS_OPT    )OS_OPT_PEND_BLOCKING,	//内建信号量 阻塞 或 不阻塞	
		(CPU_TS   *)0,				//内建信号量 时间戳
		(OS_ERR   *)&err);			//内建信号量 等待错误

7-2、其他任务,给等待内建信号量的任务发送信号量

OSTaskSemPost ( (OS_TCB  *)&Task0TaskTCB,	//内建信号量 等待的任务
		(OS_OPT   )OS_OPT_POST_NONE,	//内建信号量 调度 或 不调度
		(OS_ERR  *)&err);		//内建信号量 等待错误

 

8、互斥信号量

8-1、互斥信号量创建

OSMutexCreate ( (OS_MUTEX  	*)&myMutex,	//互斥信号量 结构体
		(CPU_CHAR	*)"Mutextest",	//互斥信号量 名字
		(OS_ERR      *)err);		//互斥信号量 创建错误

8-2、互斥信号量等待

OSMutexPend (  (OS_MUTEX	*)&myMutex,		//互斥信号量 结构体
		(OS_TICK    )0,				//互斥信号量 等待超时时间
		(OS_OPT     )OS_OPT_PEND_BLOCKING,	//互斥信号量 阻塞 或 不阻塞
		(CPU_TS   	*)0,			//互斥信号量 时间戳
		(OS_ERR   	*)&err);		//互斥信号量 等待错误

8-3、互斥信号量发送

OSMutexPost ( (OS_MUTEX  *)&myMutex,		//互斥信号量 结构体
	    (OS_OPT   )OS_OPT_POST_NONE,	//互斥信号量 调度 或 不调度
	    (OS_ERR  *)&err);		//互斥信号量 发送错误

  

用途:防止优先级反转,如:2个任务共享一个资源,而,两者的优先级,中间隔着多个优先级(任务)。高优先级 等待 低优先级 释放,而,低优先级 此时又被 中等优先级 打断,变成 高优先级 要等 中等优先级。

用互斥信号的话,此时 低优先级 ,会暂时提高到共享资源的 高优先级 级别。不会被中等优先级打算。处理完,降回 低优先级 ,高优先级接着访问。再 中等优先级。

 

发现:1、高优先级 等待时, 低优先级用OSSched(); 此时达到预计效果,不会被 中等优先级抢占。

     2、高优先级 等待时,低优先级用OSTimeDlyHMSM();延时指令,此时,会被中等优先级抢占。

 

9、消息队列

9-1、消息队列创建

//================消息队列宏定义================

OS_Q my_MSG_Q;
#define my_MSG_QTY	(OS_MSG_QTY)5

//================消息队列创建================

OSQCreate ( (OS_Q        *)&my_MSG_Q,	     //消息队列 结构体
	  (CPU_CHAR    *)"MSG_Q_Test",  	//消息队列 名字
	  (OS_MSG_QTY   )my_MSG_QTY,		//消息队列 大小
	  (OS_ERR      *)&err);		//消息队列 创建错误

9-2、消息发送

u8 *MSG = (u8 *)"testtet";
	
OSQPost (  (OS_Q         *)&my_MSG_Q,		//消息队列 结构体
	  (void         *)MSG,			//消息队列 发送的消息
	  (OS_MSG_SIZE   )8,			//消息队列 发送的消息大小
	  (OS_OPT        )OS_OPT_POST_FIFO,	//消息队列 发送方式,普通FIFO,紧急LIFO,及发送给所有等待该消息、发送调度与否
	  (OS_ERR       *)&err);		//消息队列 发送错误

9-3、消息接收

u8 *MSG;	
u8 Q_size;	
		
MSG = OSQPend ( (OS_Q         *)&my_MSG_Q,		//消息队列 结构体
		(OS_TICK       )0,			//消息队列 等待超时
		(OS_OPT        )OS_OPT_PEND_BLOCKING,	//消息队列 阻塞 或 不阻塞
		(OS_MSG_SIZE  *)&Q_size,		//消息队列 收到的大小
		(CPU_TS       *)0,			//消息队列 时间戳
		(OS_ERR       *)&err);			//消息队列 接收错误

 

10、任务内建消息队列

10-1、内建消息队列发送

u8 *MSG = (u8 *)"testtet";

OSTaskQPost (  (OS_TCB       *)&MSG_Q_TaskTCB,	  //内建消息队列 接收的任务				
		(void         *)MSG,		  //内建消息队列 发送的消息
		(OS_MSG_SIZE   )8,		  //内建消息队列 发送的消息大小
		(OS_OPT        )OS_OPT_POST_FIFO,  //内建消息队列 发送方式,普通FIFO,紧急LIFO,及发送给所有等待该消息、发送调度与否
		(OS_ERR       *)&err);		  //内建消息队列 发送错误

10-2、内建消息队列接收

u8 *MSG;
u8 Q_size;
		
MSG = OSTaskQPend (	(OS_TICK		)0,		//内建消息队列 等待超时
			(OS_OPT        )OS_OPT_PEND_BLOCKING,	//内建消息队列 阻塞 或 不阻塞
			(OS_MSG_SIZE  *)&Q_size,		//内建消息队列 收到的大小
			(CPU_TS       *)0,			//内建消息队列 时间戳
			(OS_ERR       *)&err);			//内建消息队列 接收错误	

  

11、标记位组

11-1、标记位组创建

OS_FLAG_GRP my_FLAG;

#define FLAG_INIT	0x00
#define FLAG_BIT0	0x01
#define FLAG_BIT1	0x02

OSFlagCreate (	(OS_FLAG_GRP  *)&my_FLAG,	//标记位组 结构体
		(CPU_CHAR     *)"Flag test",	//标记位组 名字
		(OS_FLAGS      )FLAG_INIT,	//标记位组 标记初始值
		(OS_ERR       *)&err);		//标记位组 创建成功与否

11-2、标记位组发送

OSFlagPost ((OS_FLAG_GRP  *)&my_FLAG,			//标记位组 结构体
	   (OS_FLAGS      )FLAG_BIT0,			//标记位组 bit0
	   (OS_OPT        )OS_OPT_POST_FLAG_SET,	//标记位组 置1
	   (OS_ERR       *)&err);			//标记位组 bit0 置 1 成功与否

11-3、标记为组等待

OS_FLAGS index;
		
index = OSFlagPend ((OS_FLAG_GRP  *)&my_FLAG,		  //标记位组 结构体
		    (OS_FLAGS      )FLAG_BIT0 | FLAG_BIT1, //标记位组 等待的BIT位
		    (OS_TICK       )0,			  //标记位组 等待超时时间
		    (OS_OPT        )OS_OPT_PEND_FLAG_SET_ANY | OS_OPT_PEND_FLAG_CONSUME | OS_OPT_PEND_BLOCKING,	  //标记位组 任意1个Bit置1,接收后清0,阻塞
		    (CPU_TS       *)0,			  //标记位组 时间戳
		    (OS_ERR       *)&err);		  //标记位组 等待错误

  

12、多个内核对象

12-1、多个内核对象 创建

//=================多个内核对象 结构体=================

OS_SEM my_Sem1;

OS_SEM my_Sem2;

OS_Q  my_Q1;
#define my_Q1_SIZE	5
	
//=================多个内核对象 创建=================

OSSemCreate (	(OS_SEM      *)&my_Sem1,
		(CPU_CHAR    *)"sem1 test",
		(OS_SEM_CTR   )0,
		(OS_ERR      *)&err);

OSSemCreate (	(OS_SEM      *)&my_Sem2,
		(CPU_CHAR    *)"sem2 test",
		(OS_SEM_CTR   )0,
		(OS_ERR      *)&err);			
					
OSQCreate (	(OS_Q        *)&my_Q1,
                (CPU_CHAR    *)"my_Q1",
                (OS_MSG_QTY   )my_Q1_SIZE,
                (OS_ERR      *)&err);

12-2、等待多个内核对象

//===============多个内核对象 宏定义===============

#define MY_OBJ_NUM 3					//多个内核对象 等待数量
	
//===============多个内核对象 等待===============

OS_PEND_DATA my_OBJ_data[MY_OBJ_NUM];	//多个内核对象 数组
	
my_OBJ_data[0].PendObjPtr = (OS_PEND_OBJ *)&my_Sem1;	//多个内核对象 对象0
my_OBJ_data[1].PendObjPtr = (OS_PEND_OBJ *)&my_Sem2;	//多个内核对象 对象1
my_OBJ_data[2].PendObjPtr = (OS_PEND_OBJ *)&my_Q1;	//多个内核对象 对象2
	
my_return_data = http://www.mamicode.com/OSPendMulti (	(OS_PEND_DATA  *)my_OBJ_data,	    //多个内核对象 对象数组>

 

12-3、多个内核对象 发送

任意对象 post ,都会结束等待

 

13、内存管理

13-1、内存创建

//==================内存 宏定义==================

OS_MEM IN_MEM;
#define IN_MEM_Block	5			//必须大于2
#define IN_MEM_Zone		25 * 4		//必须大于4,且为4的倍数,存放下一块的地址内容,4字节
CPU_INT08U IN_MEM_DATA[IN_MEM_Block][IN_MEM_Zone];

//==================内存 创建==================

OSMemCreate (  (OS_MEM       *)&IN_MEM,			//内存 结构体
               (CPU_CHAR     *)"IN_MEM",		//内存 名字
               (void         *)&IN_MEM_DATA[0][0],	//内存 基地址
               (OS_MEM_QTY    )IN_MEM_Block,		//内存 几个块,一维数组
               (OS_MEM_SIZE   )IN_MEM_Zone,		//内存 每个块大小,二维数组
               (OS_ERR       *)&error);			//内存 创建成功与否

13-2、内存申请

u8 *p;

p = OSMemGet (	(OS_MEM  *)&IN_MEM,	//内存 结构体
		(OS_ERR  *)&err);	//内存 申请成功与否

13-3、内存释放

OSMemPut ( (OS_MEM  *)&IN_MEM,	  //内存 结构体
	  (void    *)p,	  //内存 要释放的地址
	  (OS_ERR  *)&err);	  //内存 释放成功与否

 

备注:内存有申请,必释放,如果申请后,不释放,再申请,那之前申请的地址就找不到了,因为你的指针地址变了。

    所以,如果要多次申请的话,1、还要弄个指针数组,2、或者普通数组来存放当前申请的地址,3、或者知道UCOS的内存管理机制,直接去内存数组里找到地址。

 

 

暂时就这样,以后再检查修改,手酸。

 

嵌入式:UCOSIII的使用