μC/OSIII——任务同步和通信（一）

使用情况

任务间通常涉及发送和接收，但是发送速度和接收速度要匹配，不然就出问题了，为了解决这个问题在通信的同时加上流量控制（同步）

使用方法

用一个信号量和消息队列，模型如下：

通信发送：

等待接收完成信号；

发送消息；

通信接收：

等待发送消息；

发送接收完成信号；

使用实例

#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  OS_SEM MY_SEM;

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);
OSSemCreate((OS_SEM    *)&MY_SEM,
(CPU_CHAR  *)"MY_SEM",
(OS_SEM_CTR )1,                                  //信号量初始值为1
(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;
CPU_TS ts;

(void)p_arg;

while (DEF_ON){
OSSemPend((OS_SEM   *)&MY_SEM,
(OS_TICK   )0,
(OS_OPT    )OS_OPT_PEND_BLOCKING,
(CPU_TS   *)&ts,
(OS_ERR   *)&err);
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));
OSSemPost((OS_SEM  *)&MY_SEM,
(OS_OPT   )OS_OPT_POST_1,
(OS_ERR  *)&err);
OSTimeDlyHMSM(0, 0, 1, 0, OS_OPT_TIME_DLY, &err);
}
}

实验结果

信号量初始值为1



信号量初始值为0



锁死状态