μ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 禁止在本函数内执行任务调度操作

 

使用实例

  1 #define  APP_TASK_START_PRIO                               4u
  2 #define  APP_TASK_1_PRIO                                   6u
  3 #define  APP_TASK_2_PRIO                                   5u
  4 
  5 
  6 #define  APP_TASK_START_STK_SIZE                         256u
  7 #define  APP_TASK_1_STK_SIZE                             256u
  8 #define  APP_TASK_2_STK_SIZE                             256u
  9 
 10 
 11 static  OS_TCB   AppTaskStartTCB;
 12 static  OS_TCB   AppTask1TCB;
 13 static  OS_TCB   AppTask2TCB;
 14 
 15 
 16 static  OS_Q   MY_Q;
 17 
 18 
 19 static  CPU_STK  AppTaskStartStk[APP_TASK_START_STK_SIZE];
 20 static  CPU_STK  AppTask1Stk[APP_TASK_1_STK_SIZE];
 21 static  CPU_STK  AppTask2Stk[APP_TASK_2_STK_SIZE];
 22 
 23 
 24 static  void  AppTaskStart(void  *p_arg);
 25 void AppTask1(void *p_arg);
 26 void AppTask2(void *p_arg);
 27 
 28 
 29 void *BLOCK1 = "Task1 is comunicating with Task2";
 30 void *BLOCK2;
 31 
 32 
 33 
 34 
 35 int  main (void)
 36 {
 37     OS_ERR  err;
 38 
 39 
 40 
 41 
 42     OSInit(&err);                                               
 43 
 44 
 45     OSQCreate((OS_Q     *)&MY_Q,
 46               (CPU_CHAR *)"MY_Q",
 47               (OS_MSG_QTY)10,
 48               (OS_ERR   *)&err);
 49 
 50 
 51     OSTaskCreate((OS_TCB     *)&AppTaskStartTCB,                
 52                  (CPU_CHAR   *)"App Task Start",
 53                  (OS_TASK_PTR ) AppTaskStart,
 54                  (void       *) 0,
 55                  (OS_PRIO     ) APP_TASK_START_PRIO,
 56                  (CPU_STK    *)&AppTaskStartStk[0],
 57                  (CPU_STK_SIZE) APP_TASK_START_STK_SIZE / 10u,
 58                  (CPU_STK_SIZE) APP_TASK_START_STK_SIZE,
 59                  (OS_MSG_QTY  ) 0u,
 60                  (OS_TICK     ) 0u,
 61                  (void       *) 0,
 62                  (OS_OPT      )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
 63                  (OS_ERR     *)&err);
 64 
 65 
 66     OSStart(&err);                                              
 67 }
 68 
 69 
 70 static  void  AppTaskStart (void *p_arg)
 71 {
 72     OS_ERR  err;
 73 
 74 
 75 
 76 
 77    (void)p_arg;
 78 
 79 
 80     CPU_Init();                                                
 81 
 82 
 83     OSTaskCreate((OS_TCB     *)&AppTask1TCB,               
 84                 (CPU_CHAR   *)"AppTask1",
 85                 (OS_TASK_PTR)AppTask1,
 86                 (void       *)0,
 87                 (OS_PRIO)APP_TASK_1_PRIO,
 88                 (CPU_STK    *)&AppTask1Stk[0],
 89                 (CPU_STK_SIZE)APP_TASK_1_STK_SIZE / 10u,
 90                 (CPU_STK_SIZE)APP_TASK_1_STK_SIZE,
 91                 (OS_MSG_QTY)0u,
 92                 (OS_TICK)0u,
 93                 (void       *)0,
 94                 (OS_OPT)(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
 95                 (OS_ERR     *)&err);
 96     OSTaskCreate((OS_TCB     *)&AppTask2TCB,
 97                 (CPU_CHAR   *)"AppTask2",
 98                 (OS_TASK_PTR)AppTask2,
 99                 (void       *)0,
100                 (OS_PRIO)APP_TASK_2_PRIO,
101                 (CPU_STK    *)&AppTask2Stk[0],
102                 (CPU_STK_SIZE)APP_TASK_2_STK_SIZE / 10u,
103                 (CPU_STK_SIZE)APP_TASK_2_STK_SIZE,
104                 (OS_MSG_QTY)0u,
105                 (OS_TICK)0u,
106                 (void       *)0,
107                 (OS_OPT)(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
108                 (OS_ERR     *)&err);
109 }
110 
111 
112 void AppTask1(void *p_arg)
113 {
114     OS_ERR  err;
115 
116 
117     (void)p_arg;
118 
119 
120     while (DEF_ON){
121         APP_TRACE_DBG(("Task1 is running...\n\r"));
122         OSQPost((OS_Q      *)&MY_Q,
123                 (void      *)BLOCK1,
124                 (OS_MSG_SIZE)sizeof(BLOCK1),
125                 (OS_OPT     )OS_OPT_POST_FIFO,
126                 (OS_ERR    *)&err);
127         OSTimeDlyHMSM(0, 0, 1, 0, OS_OPT_TIME_DLY, &err);
128     }
129 }
130 
131 
132 void AppTask2(void *p_arg)
133 {
134     OS_ERR  err;
135 
136 
137     OS_MSG_SIZE size;
138     CPU_TS ts;
139 
140 
141     (void)p_arg;
142 
143 
144     while (DEF_ON){
145         BLOCK2=OSQPend((OS_Q       *)&MY_Q,
146                        (OS_TICK     )0,
147                        (OS_OPT      )OS_OPT_PEND_BLOCKING,
148                        (OS_MSG_SIZE*)&size,
149                        (CPU_TS      )&ts,
150                        (OS_ERR     *)&err);
151         APP_TRACE_DBG(("Task2 is running...\n\r"));
152         APP_TRACE_DBG(("%s...\n\r",BLOCK2));
153         OSTimeDlyHMSM(0, 0, 1, 0, OS_OPT_TIME_DLY, &err);
154     }
155 }

实验结果

转载于:https://www.cnblogs.com/chenliang826380678/p/chenliang2.html