任务消息对列

任务信号量和信号量有什么区别：

参见任务信号量

OSTaskQPost()

为指定任务发布消息

void  OSTaskQPost( OS_TCB       *p_tcb,		// 指定发布的任务控制块
                   void         *p_void,	// 消息
                   OS_MSG_SIZE   msg_size,	// 消息大小
                   OS_OPT        opt,		// 先进先出还是先进后出，是否直接调度可以或上
                   OS_ERR       *p_err)

OSTaskQPend()

与OSTaskQPost()相对应，函数返回一个空类型的指针，等待消息的到达

void  *OSTaskQPend( OS_TICK       timeout,		// 等待消息时间
                    OS_OPT        opt,			// 没接收到挂起，还是返回
                    OS_MSG_SIZE  *p_msg_size,	// 消息大小
                    CPU_TS       *p_ts,			// 获取信号量被发布的时间戳
                    OS_ERR       *p_err)

OSTaskQPendAbort ()

中断等待消息

CPU_BOOLEAN  OSTaskQPendAbort( OS_TCB  *p_tcb,		// 指定的发布任务
                               OS_OPT   opt,		// 是否调度任务
                               OS_ERR  *p_err)

使用

#include "system.h"
#include "usart.h"
#include "led.h"
#include "key.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 LED1_TASK_PRIO		4
//任务堆栈大小	
#define LED1_STK_SIZE 		128
//任务控制块
OS_TCB Led1TaskTCB;
//任务堆栈	
CPU_STK LED1_TASK_STK[LED1_STK_SIZE];
void led1_task(void *p_arg);


//任务优先级
#define TASKQPOST_TASK_PRIO		6
//任务堆栈大小	
#define TASKQPOST_STK_SIZE 		128
//任务控制块
OS_TCB TASKQPOSTTaskTCB;
//任务堆栈	
CPU_STK TASKQPOST_TASK_STK[TASKQPOST_STK_SIZE];
void TaskQPost_task(void *p_arg);


//任务优先级
#define TASKQPEND_TASK_PRIO		7
//任务堆栈大小	
#define TASKQPEND_STK_SIZE 		128
//任务控制块
OS_TCB TASKQPENDTaskTCB;
//任务堆栈	
CPU_STK TASKQPEND_TASK_STK[TASKQPEND_STK_SIZE];
void TaskQPend_task(void *p_arg);

int main()
{  	
	OS_ERR err;
	
	LED_Init();
	KEY_Init();
	USART1_Init(9600);
	
	OSInit(&err);		//初始化UCOSIII
	//创建开始任务
	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);				//存放该函数错误时的返回值 
	OSStart(&err);  //开启UCOSIII
	while(1);
}

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

	CPU_Init();
	
	cpu_clk_freq = BSP_CPU_ClkFreq();                           /* Determine SysTick reference freq.                    */
    cnts = cpu_clk_freq / (CPU_INT32U)OSCfg_TickRate_Hz;        /* Determine nbr SysTick increments                     */
    OS_CPU_SysTickInit(cnts);                                   /* Init uC/OS periodic time src (SysTick).              */

    Mem_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();	//进入临界区
	
	//创建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 	* )&TASKQPOSTTaskTCB,		
				 (CPU_CHAR	* )"TaskQPost_task", 		
                 (OS_TASK_PTR )TaskQPost_task, 			
                 (void		* )0,					
                 (OS_PRIO	  )TASKQPOST_TASK_PRIO,     
                 (CPU_STK   * )&TASKQPOST_TASK_STK[0],	
                 (CPU_STK_SIZE)TASKQPOST_STK_SIZE/10,	
                 (CPU_STK_SIZE)TASKQPOST_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 	* )&TASKQPENDTaskTCB,		
				 (CPU_CHAR	* )"TaskQPend_task", 		
                 (OS_TASK_PTR )TaskQPend_task, 			
                 (void		* )0,					
                 (OS_PRIO	  )TASKQPEND_TASK_PRIO,     
                 (CPU_STK   * )&TASKQPEND_TASK_STK[0],	
                 (CPU_STK_SIZE)TASKQPEND_STK_SIZE/10,	
                 (CPU_STK_SIZE)TASKQPEND_STK_SIZE,		
                 (OS_MSG_QTY  )50,			//任务可接收的最大消息数		
                 (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();	//退出临界区
}

//led1任务函数
void led1_task(void *p_arg)
{
	OS_ERR err;
	p_arg = p_arg;
	while(1)
	{
		led1=!led1;
		OSTimeDlyHMSM(0,0,0,200,OS_OPT_TIME_DLY,&err); //延时200ms
	}
}

//任务处理函数
void TaskQPost_task(void *p_arg)
{
	OS_ERR err;

	p_arg = p_arg;

			
	while(1)
	{
		
		//发布消息到任务 TASKQPENDTaskTCB
		OSTaskQPost ((OS_TCB      *)&TASKQPENDTaskTCB,           //目标任务的控制块
					(void        *)"www.prechin.cn",             //消息内容
					(OS_MSG_SIZE  )sizeof ( "www.prechin.cn" ),  //消息长度
					(OS_OPT       )OS_OPT_POST_FIFO,        //发布到任务消息队列的入口端
					(OS_ERR      *)&err);                           //返回错误类型
		
		OSTimeDlyHMSM(0,0,1,0,OS_OPT_TIME_DLY,&err);
		
	}
}


//任务处理函数
void TaskQPend_task(void *p_arg)
{
	OS_ERR err;
	OS_MSG_SIZE    msg_size;
	CPU_TS         ts;
	CPU_INT32U     cpu_clk_freq;
	char * pMsg;
	
	CPU_SR_ALLOC();
	p_arg = p_arg;
	
	cpu_clk_freq = BSP_CPU_ClkFreq();        //获取CPU时钟，时间戳是以该时钟计数
				
	while(1)
	{
		//阻塞任务，等待任务消息
		pMsg = OSTaskQPend ((OS_TICK        )0,                    //无期限等待
							(OS_OPT         )OS_OPT_PEND_BLOCKING, //没有消息就阻塞任务
							(OS_MSG_SIZE   *)&msg_size,            //返回消息长度
							(CPU_TS        *)&ts,                  //返回消息被发布的时间戳
							(OS_ERR        *)&err);                //返回错误类型

		ts = OS_TS_GET() - ts;                //计算信号量从发布到接收的时间差
		led2=!led2;
		
		OS_CRITICAL_ENTER();	//进入临界区
		printf("接收到的消息的内容为：%s，长度是：%d字节\r\n",pMsg,msg_size);
		printf("任务消息从被发布到被接收的时间差是：%d us\r\n",ts/(cpu_clk_freq / 1000000));
		OS_CRITICAL_EXIT();	//退出临界区
	
	}
}

TaskQPost_task()任务函数发布任务信号量，TaskQPend_task()任务函数，接收等待任务信号量，然后翻转led2，且打印接收到的消息以及发布和接收之间的时间差