UCOSIII系统学习-STM32

矫情吗；* 2021-11-17 12:14 415阅读 0赞

硬件 STM32F103C8T6  
软件 正点原子STM32F103 裸机程序+UCOSIII系统程序

本文主要是描述UCOSIII系统的优点和特点  
有嵌入式经验的同胞们都知道,多任务处理时,最好的方法就是创建进程和线程,我个人拙见,  
UCOS系统就是因为STM32无法跑gcc,而且单片机都是单核单线程,从前我们想做更多任务的时候,都是建立定时器,将不同的任务放到各个定时器里面跑,这样就实现了类似多线程并行奔跑的场景,虽然定时器很多; 而UCOS系统就是类似定时器,类似线程,只需要将需要的任务,创建好,  
按照优先级不同设定,系统就会定时进行任务执行,可谓是脚踏实地的执行各种并行任务.

## 一. 移植UCOSIII系统 ##

这个了解STM32的都知道,直接移植就好了

## 二. 任务的创建(进程的创建) ##

**(1) 开始进程**  
该进程是必须的进程,犹如父进程,整个系统的爸爸

**定义开始进程**

#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);   //任务函数

创建开始任务函数

//开始任务函数
    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();	//进入临界区
        
        
    	//创建LED0任务
    	OSTaskCreate((OS_TCB 	* )&TIME_TaskTCB,		
    				 (CPU_CHAR	* )"TIME_ task", 		
                     (OS_TASK_PTR )TIME_task, 			
                     (void		* )0,					
                     (OS_PRIO	  )TIME_TASK_PRIO,     
                     (CPU_STK   * )&TIME_TASK_STK[0],	
                     (CPU_STK_SIZE)TIME_STK_SIZE/10,	
                     (CPU_STK_SIZE)TIME_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);				
        
    	//创建LED0任务
    	OSTaskCreate((OS_TCB 	* )&Led0TaskTCB,		
    				 (CPU_CHAR	* )"led0 task", 		
                     (OS_TASK_PTR )led0_task, 			
                     (void		* )0,					
                     (OS_PRIO	  )LED0_TASK_PRIO,     
                     (CPU_STK   * )&LED0_TASK_STK[0],	
                     (CPU_STK_SIZE)LED0_STK_SIZE/10,	
                     (CPU_STK_SIZE)LED0_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);				
    				 
    	//创建LED1任务
    	OSTaskCreate((OS_TCB 	* )&Led1TaskTCB,		
    				 (CPU_CHAR	* )"led1 task", 		
                     (OS_TASK_PTR )led1_task, 			
                     (void		* )0,					
                     (OS_PRIO	  )LED1_TASK_PRIO,     	
                     (CPU_STK   * )&LED1_TASK_STK[0],	
                     (CPU_STK_SIZE)LED1_STK_SIZE/10,	
                     (CPU_STK_SIZE)LED1_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 	* )&FloatTaskTCB,		
    				 (CPU_CHAR	* )"float test task", 		
                     (OS_TASK_PTR )float_task, 			
                     (void		* )0,					
                     (OS_PRIO	  )FLOAT_TASK_PRIO,     	
                     (CPU_STK   * )&FLOAT_TASK_STK[0],	
                     (CPU_STK_SIZE)FLOAT_STK_SIZE/10,	
                     (CPU_STK_SIZE)FLOAT_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_TaskSuspend((OS_TCB*)&StartTaskTCB,&err);		//挂起开始任务			 
    	OS_CRITICAL_EXIT();	//退出临界区	 
    }

**主函数来来挂载开始进程**

int main(void)
    {
    	OS_ERR err;
    	CPU_SR_ALLOC();
        //初始化部分
    	Sys_Init(115200);    //串口波特率设置
    	LED_GPIO_init();         //LED初始化
    	OSInit(&err);		//初始化UCOSIII
    	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);  //开启UCOSIII
    	while(1) ;
    }

**(2) 时间统计进程-用于记录每次系统启动时间**  
//用于记录每次系统启动时间  
\#define TIME\_TASK\_PRIO 4 //任务优先级  
\#define TIME\_STK\_SIZE 128 //任务堆栈大小  
OS\_TCB TIME\_TaskTCB; //任务控制块  
CPU\_STK TIME\_TASK\_STK\[TIME\_STK\_SIZE\]; //任务堆栈  
void TIME\_task(void \*p\_arg);

**任务实现**  
//time计时任务函数  
void TIME\_task(void \*p\_arg)\{  
u8 task\_num=0;  
OS\_ERR err;  
p\_arg = p\_arg;  
while(1)  
\{  
printf(“time = %ds \\r\\n”,task\_num);  
OSTimeDlyHMSM(0,0,1,0,OS\_OPT\_TIME\_HMSM\_STRICT,&err); //延时1s  
task\_num++;  
if(task\_num==60)\{ //10s之后,删除led1任务  
task\_num=0;  
\}  
\}  
\}

**挂载到系统中,在start\_task()函数中**

OS_CRITICAL_ENTER();	//进入临界区
    OSTaskCreate((OS_TCB 	* )&TIME_TaskTCB,		
    			 (CPU_CHAR	* )"TIME_ task", 		
                 (OS_TASK_PTR )TIME_task, 			
                 (void		* )0,					
                 (OS_PRIO	  )TIME_TASK_PRIO,     
                 (CPU_STK   * )&TIME_TASK_STK[0],	
                 (CPU_STK_SIZE)TIME_STK_SIZE/10,	
                 (CPU_STK_SIZE)TIME_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_TaskSuspend((OS_TCB*)&StartTaskTCB,&err);		//挂起开始任务			 
    OS_CRITICAL_EXIT();	//退出临界区

## 三. 任务的删除 ##

OSTaskDel((OS\_TCB\*)&Led1TaskTCB, &err);

## 四. 任务的挂起和启动 ##

OS\_TaskSuspend((OS\_TCB\*)&FloatTaskTCB,&err);//挂起任务  
OS\_TaskResume((OS\_TCB\*)&FloatTaskTCB,&err);//重新启动任务

void led0_task(void *p_arg)
        {
            u8 task_num=0;
        	OS_ERR err;
        	p_arg = p_arg;
        	while(1)
        	{
        		LED0=~LED0;
        		OSTimeDlyHMSM(0,0,1,0,OS_OPT_TIME_HMSM_STRICT,&err); //延时500ms
                task_num++;
                if(task_num == 15){     //任务挂起测试
                    OS_TaskSuspend((OS_TCB*)&FloatTaskTCB,&err);//挂起任务
                    printf("任务float_task 被挂起!!!\r\n");
                }
                
                if(task_num == 20){     //任务挂起测试
                    OS_TaskResume((OS_TCB*)&FloatTaskTCB,&err);//重新启动任务
                    printf("任务float_task 重启!!!\r\n");
                }
                
                if(task_num == 25){     //任务挂起测试
                    OS_TaskSuspend((OS_TCB*)&FloatTaskTCB,&err);//重新启动任务
                    printf("任务float_task 重启!!!\r\n");
                }
        
        	}
        }

## 五. 时间片轮转(同一优先级) ##

**(1)定义两个任务向量**  
//优先级都为8,用于测试时间片  
\#define TASK1\_TASK\_PRIO 8 //任务优先级  
\#define TASK1\_STK\_SIZE 128 //任务堆栈大小  
OS\_TCB TASK1\_TaskTCB; //任务控制块  
CPU\_STK TASK1\_TASK\_STK\[TASK1\_STK\_SIZE\]; //任务堆栈  
void TASK1\_task(void \*p\_arg); //任务函数

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

(2) void start\_task(void \*p\_arg)**中加入上面两个任务**  
注意这里就用到了时间片 (OS\_TICK )X,  
X设置的大一点就不会出现任务相互干扰了,不然一个任务还没有结束,时间片却用完了,这样会造成下一个时间片的时候还在继续上一个任务

//创建task1测试任务
    	OSTaskCreate((OS_TCB 	* )&TASK1_TaskTCB,		
    				 (CPU_CHAR	* )"TASK1_T 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	  )2,	    //时间片长度2*5 = 10ms				
                     (void   	* )0,				
                     (OS_OPT      )OS_OPT_TASK_STK_CHK|OS_OPT_TASK_STK_CLR, 
                     (OS_ERR 	* )&err);								 
    
    	//创建task1测试任务
    	OSTaskCreate((OS_TCB 	* )&TASK2_TaskTCB,		
    				 (CPU_CHAR	* )"TASK2_T 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	  )2,	    //时间片长度2*5 = 10ms				
                     (void   	* )0,				
                     (OS_OPT      )OS_OPT_TASK_STK_CHK|OS_OPT_TASK_STK_CLR, 
                     (OS_ERR 	* )&err);