μC/OSIII——任务通信（消息传递）



使用情况

　　一个任务或者中断服务程序与另一个任务交流信息

使用方法

　　消息队列服务函数的实现代码在os_q.c文件中，在编译时，将os_cfg.h文件中的配置常数OS_CFG_Q_EN设为1就可启用这些服务函数。

　　常用消息队列的服务函数有：

• OSQCreate()       创建消息队列
• OSQPend()          等待消息队列中的信息
• OSQPost()           向消息队列中发送消息

void  OSQCreate (OS_Q        *p_q,                    指向消息队列控制块的指针
                          CPU_CHAR    *p_name,           指向字符串的指针——消息队列的名字
                          OS_MSG_QTY   max_qty,        指定消息队列的最大长度（必须为非零）
                          OS_ERR      *p_err)                该函数返回的错误码

 

void  *OSQPend (OS_Q         *p_q,                    指向消息队列控制块的指针
                         OS_TICK       timeout,              指定等待消息的超时时间（时钟节拍数）
                         OS_OPT        opt,                    
                         OS_MSG_SIZE  *p_msg_size,   接受的消息的大小（字节数，可用sizeof获取）
                         CPU_TS       *p_ts,                   指向一个时间戳的指针
                         OS_ERR       *p_err)                 该函数返回的错误码

opt  OS_OPT_PEND_BLOCKING  阻塞模式（任务挂起等待该对象）

       OS_OPT_PEND_NON_BLOCKING  非阻塞模式（没有任何消息存在时，任务直接返回）

 

void  OSQPost (OS_Q         *p_q,                        指向消息队列控制块的指针  
                       void         *p_void,                      实际发送的消息内容
                       OS_MSG_SIZE   msg_size,           设定消息的大小（字节数）
                       OS_OPT        opt,                  
                       OS_ERR       *p_err)                    该函数返回的错误码

opt  OS_OPT_POST_FIFO   待发送的消息保存在消息队列的末尾（FIFO）

       OS_OPT_POST_LIFO   待发送的消息保存在消息队列的开头（LIFO）

       +OS_OPT_POST_ALL  向所有等待该消息队列的任务发送消息（否则只发送到最高级）

       +OS_OPT_POST_NO_SCHED 禁止在本函数内执行任务调度操作

使用实例

#define  APP_TASK_START_PRIO                               4u
#define  APP_TASK_1_PRIO                                   6u
#define  APP_TASK_2_PRIO                                   5u

#define  APP_TASK_START_STK_SIZE                         256u
#define  APP_TASK_1_STK_SIZE                             256u
#define  APP_TASK_2_STK_SIZE                             256u

static  OS_TCB   AppTaskStartTCB;
static  OS_TCB   AppTask1TCB;
static  OS_TCB   AppTask2TCB;

static  OS_Q   MY_Q;

static  CPU_STK  AppTaskStartStk[APP_TASK_START_STK_SIZE];
static  CPU_STK  AppTask1Stk[APP_TASK_1_STK_SIZE];
static  CPU_STK  AppTask2Stk[APP_TASK_2_STK_SIZE];

static  void  AppTaskStart(void  *p_arg);
void AppTask1(void *p_arg);
void AppTask2(void *p_arg);

void *BLOCK1 = "Task1 is comunicating with Task2";
void *BLOCK2;


int  main (void)
{
    OS_ERR  err;


    OSInit(&err);                                               

	OSQCreate((OS_Q     *)&MY_Q,
			  (CPU_CHAR *)"MY_Q",
			  (OS_MSG_QTY)10,
			  (OS_ERR   *)&err);

    OSTaskCreate((OS_TCB     *)&AppTaskStartTCB,                
                 (CPU_CHAR   *)"App Task Start",
                 (OS_TASK_PTR ) AppTaskStart,
                 (void       *) 0,
                 (OS_PRIO     ) APP_TASK_START_PRIO,
                 (CPU_STK    *)&AppTaskStartStk[0],
                 (CPU_STK_SIZE) APP_TASK_START_STK_SIZE / 10u,
                 (CPU_STK_SIZE) APP_TASK_START_STK_SIZE,
                 (OS_MSG_QTY  ) 0u,
                 (OS_TICK     ) 0u,
                 (void       *) 0,
                 (OS_OPT      )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
                 (OS_ERR     *)&err);

    OSStart(&err);                                              
}

static  void  AppTaskStart (void *p_arg)
{
    OS_ERR  err;


   (void)p_arg;

    CPU_Init();                                                

	OSTaskCreate((OS_TCB     *)&AppTask1TCB,               
				(CPU_CHAR   *)"AppTask1",
				(OS_TASK_PTR)AppTask1,
				(void       *)0,
				(OS_PRIO)APP_TASK_1_PRIO,
				(CPU_STK    *)&AppTask1Stk[0],
				(CPU_STK_SIZE)APP_TASK_1_STK_SIZE / 10u,
				(CPU_STK_SIZE)APP_TASK_1_STK_SIZE,
				(OS_MSG_QTY)0u,
				(OS_TICK)0u,
				(void       *)0,
				(OS_OPT)(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
				(OS_ERR     *)&err);
	OSTaskCreate((OS_TCB     *)&AppTask2TCB,
				(CPU_CHAR   *)"AppTask2",
				(OS_TASK_PTR)AppTask2,
				(void       *)0,
				(OS_PRIO)APP_TASK_2_PRIO,
				(CPU_STK    *)&AppTask2Stk[0],
				(CPU_STK_SIZE)APP_TASK_2_STK_SIZE / 10u,
				(CPU_STK_SIZE)APP_TASK_2_STK_SIZE,
				(OS_MSG_QTY)0u,
				(OS_TICK)0u,
				(void       *)0,
				(OS_OPT)(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
				(OS_ERR     *)&err);
}

void AppTask1(void *p_arg)
{
	OS_ERR  err;

	(void)p_arg;

	while (DEF_ON){
		APP_TRACE_DBG(("Task1 is running...\n\r"));
		OSQPost((OS_Q      *)&MY_Q,
				(void      *)BLOCK1,
				(OS_MSG_SIZE)sizeof(BLOCK1),
				(OS_OPT     )OS_OPT_POST_FIFO,
				(OS_ERR    *)&err);
		OSTimeDlyHMSM(0, 0, 1, 0, OS_OPT_TIME_DLY, &err);
	}
}

void AppTask2(void *p_arg)
{
	OS_ERR  err;

	OS_MSG_SIZE size;
	CPU_TS ts;

	(void)p_arg;

	while (DEF_ON){
		BLOCK2=OSQPend((OS_Q       *)&MY_Q,
					   (OS_TICK     )0,
					   (OS_OPT      )OS_OPT_PEND_BLOCKING,
					   (OS_MSG_SIZE*)&size,
					   (CPU_TS      )&ts,
					   (OS_ERR     *)&err);
		APP_TRACE_DBG(("Task2 is running...\n\r"));
		APP_TRACE_DBG(("%s...\n\r",BLOCK2));
		OSTimeDlyHMSM(0, 0, 1, 0, OS_OPT_TIME_DLY, &err);
	}
}

实验结果