μ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);
}
}

实验结果