在一个任务等待多个内核对象在之前，信号量和消息队列的发布过程中都有等待多个内核对象判断的函数，所谓任务等待多个内核对象顾名思义就是一任务同时等待多个内核对象而被挂起，在USOC—III中一个任务等待多个内核对象时只能是信号量和消息队列的组合。数据类型是OS_PEND_DATA的数组。
　　在使任务等待多个内核对象时，先定义一个OS_PEND_DATA 类型的等待数据数组，数组的长度等于等待对象的个数，然后初始化数组元素内的Array[n].PendobjPtr=（OS_PEND_OBJ）某个内核对象，进行初始化后就可以调用对应的函数进行设置了。
任务等待多个内核对象函数：

  1. OS_OBJ_QTY  OSPendMulti (OS_PEND_DATA  *p_pend_data_tbl,
  2.                          OS_OBJ_QTY     tbl_size,
  3.                          OS_TICK        timeout,
  4.                          OS_OPT         opt,
  5.                          OS_ERR        *p_err)
  6. {
  7.     CPU_BOOLEAN   valid;
  8.     OS_OBJ_QTY    nbr_obj_rdy;
  9.     CPU_SR_ALLOC();
  10.  
  11. #ifdef OS_SAFETY_CRITICAL
  12.     if (p_err == (OS_ERR *)0) {
  13.         OS_SAFETY_CRITICAL_EXCEPTION();
  14.         return ((OS_OBJ_QTY)0);
  15.     }
  16. #endif
  17.  
  18. #if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0u
  19.     if (OSIntNestingCtr > (OS_NESTING_CTR)0) {              /* Can't pend from an ISR                                 */
  20.        *p_err = OS_ERR_PEND_ISR;
  21.         return ((OS_OBJ_QTY)0);
  22.     }
  23. #endif
  24.  
  25. #if OS_CFG_ARG_CHK_EN > 0u
  26.     if (p_pend_data_tbl == (OS_PEND_DATA *)0) {             /* Validate 'p_pend_data_tbl'                             */
  27.        *p_err = OS_ERR_PTR_INVALID;
  28.         return ((OS_OBJ_QTY)0);
  29.     }
  30.     if (tbl_size == (OS_OBJ_QTY)0) {                        /* Array size must be > 0                                 */
  31.        *p_err = OS_ERR_PTR_INVALID;
  32.         return ((OS_OBJ_QTY)0);
  33.     }
  34.     //请求不到时阻塞？
  35.     switch (opt) {
  36.         case OS_OPT_PEND_BLOCKING:
  37.         case OS_OPT_PEND_NON_BLOCKING:
  38.              break;
  39.  
  40.         default:
  41.             *p_err = OS_ERR_OPT_INVALID;
  42.              return ((OS_OBJ_QTY)0);
  43.     }
  44. #endif
  45.     //多个内核对象检查，只能是信号量或者是消息
  46.     valid = OS_PendMultiValidate(p_pend_data_tbl,           /* -------- Validate objects to be OS_SEM or OS_Q ------- */
  47.                                  tbl_size);
  48.     if (valid == DEF_FALSE) {
  49.        *p_err = OS_ERR_OBJ_TYPE;                            /* Invalid, not OS_SEM or OS_Q                            */
  50.         return ((OS_OBJ_QTY)0);
  51.     }
  52.  
  53. /*$PAGE*/
  54.     CPU_CRITICAL_ENTER();
  55.     //检查是否有内核对象已经提交
  56.     nbr_obj_rdy = OS_PendMultiGetRdy(p_pend_data_tbl,       /* --------- SEE IF OBJECT(s) HAVE BEEN POSTED ---------- */
  57.                                      tbl_size);
  58.     //有对象就绪，返回
  59.     if (nbr_obj_rdy > (OS_OBJ_QTY)0) {
  60.         CPU_CRITICAL_EXIT();
  61.        *p_err = OS_ERR_NONE;
  62.         return ((OS_OBJ_QTY)nbr_obj_rdy);
  63.     }
  64.  
  65.     if ((opt & OS_OPT_PEND_NON_BLOCKING) != (OS_OPT)0) {    /* Caller wants to block if not available?                */
  66.         CPU_CRITICAL_EXIT();
  67.        *p_err = OS_ERR_PEND_WOULD_BLOCK;                    /* No                                                     */
  68.         return ((OS_OBJ_QTY)0);
  69.     } else {
  70.         if (OSSchedLockNestingCtr > (OS_NESTING_CTR)0) {    /* Can't pend when the scheduler is locked                */
  71.             CPU_CRITICAL_EXIT();
  72.            *p_err = OS_ERR_SCHED_LOCKED;
  73.             return ((OS_OBJ_QTY)0);
  74.         }
  75.     }
  76.                                                             /* Lock the scheduler/re-enable interrupts                */
  77.     OS_CRITICAL_ENTER_CPU_EXIT();
  78.                                                             /* ------ NO OBJECT READY, PEND ON MULTIPLE OBJECTS ----- */
  79.     //插入等待队列，和单独一个内核对象相似
  80.     OS_PendMultiWait(p_pend_data_tbl,                       /* Suspend task until object posted or timeout occurs     */
  81.                      tbl_size,
  82.                      timeout);
  83.  
  84.     OS_CRITICAL_EXIT_NO_SCHED();
  85.     //挂起当前任务，之后任务能恢复就在于信号发布或消息队列的发布是将任务加入就绪列表
  86.     OSSched();                                              /* Find next highest priority task ready                  */
  87.  
  88.     CPU_CRITICAL_ENTER();
  89.     switch (OSTCBCurPtr->PendStatus) {
  90.         case OS_STATUS_PEND_OK:                             /* We got one of the objects posted to                    */
  91.             *p_err = OS_ERR_NONE;
  92.              break;
  93.  
  94.         case OS_STATUS_PEND_ABORT:                          /* Indicate that the multi-pend was aborted               */
  95.             *p_err = OS_ERR_PEND_ABORT;
  96.              break;
  97.  
  98.         case OS_STATUS_PEND_TIMEOUT:                        /* Indicate that we didn't get semaphore within timeout   */
  99.             *p_err = OS_ERR_TIMEOUT;
  100.              break;
  101.  
  102.         case OS_STATUS_PEND_DEL:                            /* Indicate that an object pended on has been deleted     */
  103.             *p_err = OS_ERR_OBJ_DEL;
  104.             break;
  105.  
  106.         default:
  107.             *p_err = OS_ERR_STATUS_INVALID;
  108.              break;
  109.     }
  110.  
  111.     OSTCBCurPtr->PendStatus = OS_STATUS_PEND_OK;
  112.     CPU_CRITICAL_EXIT();
  113.  
  114.     return ((OS_OBJ_QTY)1);
  115. }

OSPendMulti ()

其中调用的相关函数也是比较简单全部在OS_Pend_Multi.c文件里。等待多个内和对象实际就是前面的消息队列与多值信号量的组合，原理很简单具体的使用结合前面的相关操作就可以了。

任务内建信号量与消息队列
　　任务内建的信号量与消息队列是UCOS作者为了方便使用而设计的数据结构放在每一个任务的任务控制块里这样操作更简单更省时，在实践的任务通信中，一个任务发送信号量或者消息给另一个任务是比较常见的，但是多个任务发送给一个任务的情况是比较少见的，而任务内建信号或消息队列不仅在数据结构的设计上更加简单，功能也是有区别的任务内建的对象不会有多个等待任务，等待任务有且仅有一个，他们是任务控制块里的所以不可以被单独删除，任务消息队列或信号量在任务创建时就要配置，在以往我们不使用内建对象时，这些选项都是被设置为0的，创建任务是函数传入参数OS_MSG_QTY就是消息队列的最大长度。任务控制块里的OS_SEM_CTR SemCtr;就是任务内建的多值信号量变量。

内建消息队列和消息对列相同，在任务控制块内有一个MsgQ的变量如图结构：

OSTaskSemPost函数 同样是对opt进行检查，然后选择是否延迟发布，延迟发布最后也是进行相同的发布过程因此可以直接看OS_TaskSemPost函数，此函数的第一个入口参数就是任务控制块地址，如果为0 就默认为当前执行的任务，然后判断任务状态进行操作具体见源码注释。

  1. ************************************************************************************************************************
  2. *                                                    SIGNAL A TASK
  3. *
  4. * Description: This function is called to signal a task waiting for a signal.
  5. *
  6. * Arguments  : p_tcb     is the pointer to the TCB of the task to signal.  A NULL pointer indicates that you are sending
  7. *                        a signal to yourself.
  8. *
  9. *              opt       determines the type of POST performed:
  10. *
  11. *                             OS_OPT_POST_NONE         No option
  12. *                             OS_OPT_POST_NO_SCHED     Do not call the scheduler
  13. *
  14. *              p_err     is a pointer to an error code returned by this function:
  15. *
  16. *                            OS_ERR_NONE              If the requested task is signaled
  17. *                            OS_ERR_SEM_OVF           If the post would cause the semaphore count to overflow.
  18. *
  19. * Returns    : The current value of the task's signal counter or 0 if called from an ISR
  20. ************************************************************************************************************************
  21. */
  22.  
  23. OS_SEM_CTR  OSTaskSemPost (OS_TCB  *p_tcb,
  24.                            OS_OPT   opt,
  25.                            OS_ERR  *p_err)
  26. {
  27.     OS_SEM_CTR  ctr;
  28.     CPU_TS      ts;
  29.  
  30. #ifdef OS_SAFETY_CRITICAL
  31.     if (p_err == (OS_ERR *)0) {
  32.         OS_SAFETY_CRITICAL_EXCEPTION();
  33.         return ((OS_SEM_CTR)0);
  34.     }
  35. #endif
  36.  
  37. #if OS_CFG_ARG_CHK_EN > 0u
  38.     switch (opt) {                                          /* Validate 'opt'                                         */
  39.         case OS_OPT_POST_NONE:
  40.         case OS_OPT_POST_NO_SCHED:
  41.              break;
  42.  
  43.         default:
  44.             *p_err =  OS_ERR_OPT_INVALID;
  45.              return ((OS_SEM_CTR)0u);
  46.     }
  47. #endif
  48.  
  49.     ts = OS_TS_GET();                                       /* Get timestamp                                          */
  50.  
  51. #if OS_CFG_ISR_POST_DEFERRED_EN > 0u
  52.     if (OSIntNestingCtr > (OS_NESTING_CTR)0) {              /* See if called from an ISR                              */
  53.         OS_IntQPost((OS_OBJ_TYPE)OS_OBJ_TYPE_TASK_SIGNAL,   /* Post to ISR queue                                      */
  54.                     (void      *)p_tcb,
  55.                     (void      *)0,
  56.                     (OS_MSG_SIZE)0,
  57.                     (OS_FLAGS   )0,
  58.                     (OS_OPT     )0,
  59.                     (CPU_TS     )ts,
  60.                     (OS_ERR    *)p_err);
  61.         return ((OS_SEM_CTR)0);
  62.     }
  63. #endif
  64.  
  65.     ctr = OS_TaskSemPost(p_tcb,
  66.                          opt,
  67.                          ts,
  68.                          p_err);
  69.  
  70.     return (ctr);
  71. }

OSTaskSemPost ()

OSTaskSemPend 函数 先检查选项，然后直接if (OSTCBCurPtr->SemCtr > (OS_SEM_CTR)0)判断任务控制块内的信号量是否可用，可用后进行相关的处理后返回可用值（数量），否则调用OS_Pend直接将当前任务阻塞，阻塞选项是任务内建信号量。

  1. ************************************************************************************************************************
  2. *                                              WAIT FOR A TASK SEMAPHORE
  3. *
  4. * Description: This function is called to block the current task until a signal is sent by another task or ISR.
  5. *
  6. * Arguments  : timeout       is the amount of time you are will to wait for the signal
  7. *
  8. *              opt           determines whether the user wants to block if a semaphore post was not received:
  9. *
  10. *                                OS_OPT_PEND_BLOCKING
  11. *                                OS_OPT_PEND_NON_BLOCKING
  12. *
  13. *              p_ts          is a pointer to a variable that will receive the timestamp of when the semaphore was posted
  14. *                            or pend aborted.  If you pass a NULL pointer (i.e. (CPU_TS *)0) then you will not get the
  15. *                            timestamp.  In other words, passing a NULL pointer is valid and indicates that you don't
  16. *                            need the timestamp.
  17. *
  18. *              p_err         is a pointer to an error code that will be set by this function
  19. *
  20. *                                OS_ERR_NONE               The call was successful and your task received a message.
  21. *                                OS_ERR_PEND_ABORT
  22. *                                OS_ERR_PEND_ISR           If you called this function from an ISR and the result
  23. *                                OS_ERR_PEND_WOULD_BLOCK   If you specified non-blocking but no signal was received
  24. *                                OS_ERR_SCHED_LOCKED       If the scheduler is locked
  25. *                                OS_ERR_STATUS_INVALID     If the pend status is invalid
  26. *                                OS_ERR_TIMEOUT            A message was not received within the specified timeout
  27. *                                                          would lead to a suspension.
  28. *
  29. * Returns    : The current count of signals the task received, 0 if none.
  30. ************************************************************************************************************************
  31. */
  32.  
  33. OS_SEM_CTR  OSTaskSemPend (OS_TICK   timeout,
  34.                            OS_OPT    opt,
  35.                            CPU_TS   *p_ts,
  36.                            OS_ERR   *p_err)
  37. {
  38.     OS_SEM_CTR    ctr;
  39.     CPU_SR_ALLOC();
  40.  
  41. #ifdef OS_SAFETY_CRITICAL
  42.     if (p_err == (OS_ERR *)0) {
  43.         OS_SAFETY_CRITICAL_EXCEPTION();
  44.         return ((OS_SEM_CTR)0);
  45.     }
  46. #endif
  47.  
  48. #if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0u
  49.     if (OSIntNestingCtr > (OS_NESTING_CTR)0) {              /* Not allowed to call from an ISR                        */
  50.        *p_err = OS_ERR_PEND_ISR;
  51.         return ((OS_SEM_CTR)0);
  52.     }
  53. #endif
  54.  
  55. #if OS_CFG_ARG_CHK_EN > 0u
  56.     switch (opt) {                                          /* Validate 'opt'                                         */
  57.         case OS_OPT_PEND_BLOCKING:
  58.         case OS_OPT_PEND_NON_BLOCKING:
  59.              break;
  60.  
  61.         default:
  62.             *p_err = OS_ERR_OPT_INVALID;
  63.              return ((OS_SEM_CTR)0);
  64.     }
  65. #endif
  66.  
  67.     if (p_ts != (CPU_TS *)0) {
  68.        *p_ts  = (CPU_TS  )0;                                /* Initialize the returned timestamp                      */
  69.     }
  70.  
  71.     CPU_CRITICAL_ENTER();
  72.     if (OSTCBCurPtr->SemCtr > (OS_SEM_CTR)0) {              /* See if task already been signaled                      */
  73.         OSTCBCurPtr->SemCtr--;
  74.         ctr    = OSTCBCurPtr->SemCtr;
  75.         if (p_ts != (CPU_TS *)0) {
  76.            *p_ts  = OSTCBCurPtr->TS;
  77.         }
  78. #if OS_CFG_TASK_PROFILE_EN > 0u
  79.         OSTCBCurPtr->SemPendTime = OS_TS_GET() - OSTCBCurPtr->TS;
  80.         if (OSTCBCurPtr->SemPendTimeMax < OSTCBCurPtr->SemPendTime) {
  81.             OSTCBCurPtr->SemPendTimeMax = OSTCBCurPtr->SemPendTime;
  82.         }
  83. #endif
  84.         CPU_CRITICAL_EXIT();
  85.        *p_err = OS_ERR_NONE;
  86.         return (ctr);
  87.     }
  88.  
  89.     if ((opt & OS_OPT_PEND_NON_BLOCKING) != (OS_OPT)0) {    /* Caller wants to block if not available?                */
  90.         CPU_CRITICAL_EXIT();
  91.        *p_err = OS_ERR_PEND_WOULD_BLOCK;                    /* No                                                     */
  92.         return ((OS_SEM_CTR)0);
  93.     } else {                                                /* Yes                                                    */
  94.         if (OSSchedLockNestingCtr > (OS_NESTING_CTR)0) {    /* Can't pend when the scheduler is locked                */
  95.             CPU_CRITICAL_EXIT();
  96.            *p_err = OS_ERR_SCHED_LOCKED;
  97.             return ((OS_SEM_CTR)0);
  98.         }
  99.     }
  100.                                                             /* Lock the scheduler/re-enable interrupts                */
  101.     OS_CRITICAL_ENTER_CPU_EXIT();
  102.     OS_Pend((OS_PEND_DATA *)0,                              /* Block task pending on Signal                           */
  103.             (OS_PEND_OBJ  *)0,
  104.             (OS_STATE      )OS_TASK_PEND_ON_TASK_SEM,
  105.             (OS_TICK       )timeout);
  106.     OS_CRITICAL_EXIT_NO_SCHED();
  107.  
  108.     OSSched();                                              /* Find next highest priority task ready to run           */
  109.  
  110.     CPU_CRITICAL_ENTER();
  111.     switch (OSTCBCurPtr->PendStatus) {                      /* See if we timed-out or aborted                         */
  112.         case OS_STATUS_PEND_OK:
  113.              if (p_ts != (CPU_TS *)0) {
  114.                 *p_ts                    =  OSTCBCurPtr->TS;
  115. #if OS_CFG_TASK_PROFILE_EN > 0u
  116.                 OSTCBCurPtr->SemPendTime = OS_TS_GET() - OSTCBCurPtr->TS;
  117.                 if (OSTCBCurPtr->SemPendTimeMax < OSTCBCurPtr->SemPendTime) {
  118.                     OSTCBCurPtr->SemPendTimeMax = OSTCBCurPtr->SemPendTime;
  119.                 }
  120. #endif
  121.              }
  122.             *p_err = OS_ERR_NONE;
  123.              break;
  124.  
  125.         case OS_STATUS_PEND_ABORT:
  126.              if (p_ts != (CPU_TS *)0) {
  127.                 *p_ts  =  OSTCBCurPtr->TS;
  128.              }
  129.             *p_err = OS_ERR_PEND_ABORT;                     /* Indicate that we aborted                               */
  130.              break;
  131.  
  132.         case OS_STATUS_PEND_TIMEOUT:
  133.              if (p_ts != (CPU_TS *)0) {
  134.                 *p_ts  = (CPU_TS  )0;
  135.              }
  136.             *p_err = OS_ERR_TIMEOUT;                        /* Indicate that we didn't get event within TO            */
  137.              break;
  138.  
  139.         default:
  140.             *p_err = OS_ERR_STATUS_INVALID;
  141.              break;
  142.     }
  143.     ctr = OSTCBCurPtr->SemCtr;
  144.     CPU_CRITICAL_EXIT();
  145.     return (ctr);
  146. }

OSTaskSemPend()

OSTaskQPost函数第一个参数就是要给发布的任务控制块，然后根据消息对列的模式FIFO或者LIFO，下来就是与消息对列相同的提交操作。

任务内建消息队列发布：

  1. #if OS_CFG_TASK_Q_EN > 0u
  2. void  OS_TaskQPost (OS_TCB       *p_tcb,
  3.                     void         *p_void,
  4.                     OS_MSG_SIZE   msg_size,
  5.                     OS_OPT        opt,
  6.                     CPU_TS        ts,
  7.                     OS_ERR       *p_err)
  8. {
  9.     CPU_SR_ALLOC();
  10.  
  11.     OS_CRITICAL_ENTER();
  12.     if (p_tcb == (OS_TCB *)0) {                             /* Post msg to 'self'?                                    */
  13.         p_tcb = OSTCBCurPtr;
  14.     }
  15.    *p_err  = OS_ERR_NONE;                                   /* Assume we won't have any errors                        */
  16.     switch (p_tcb->TaskState) {
  17.         case OS_TASK_STATE_RDY:
  18.         case OS_TASK_STATE_DLY:
  19.         case OS_TASK_STATE_SUSPENDED:
  20.         case OS_TASK_STATE_DLY_SUSPENDED:
  21.              OS_MsgQPut(&p_tcb->MsgQ,                       /* Deposit the message in the queue                       */
  22.                         p_void,
  23.                         msg_size,
  24.                         opt,
  25.                         ts,
  26.                         p_err);
  27.              OS_CRITICAL_EXIT();
  28.              break;
  29.  
  30.         case OS_TASK_STATE_PEND:
  31.         case OS_TASK_STATE_PEND_TIMEOUT:
  32.         case OS_TASK_STATE_PEND_SUSPENDED:
  33.         case OS_TASK_STATE_PEND_TIMEOUT_SUSPENDED:
  34.              if (p_tcb->PendOn == OS_TASK_PEND_ON_TASK_Q) { /* Is task waiting for a message to be sent to it?        */
  35.                  OS_Post((OS_PEND_OBJ *)0,
  36.                          p_tcb,
  37.                          p_void,
  38.                          msg_size,
  39.                          ts);
  40.                  OS_CRITICAL_EXIT_NO_SCHED();
  41.                  if ((opt & OS_OPT_POST_NO_SCHED) == (OS_OPT)0u) {
  42.                      OSSched();                             /* Run the scheduler                                      */
  43.                  }
  44.              } else {
  45.                  OS_MsgQPut(&p_tcb->MsgQ,                   /* No,  Task is pending on something else ...             */
  46.                             p_void,                         /*      ... Deposit the message in the task's queue       */
  47.                             msg_size,
  48.                             opt,
  49.                             ts,
  50.                             p_err);
  51.                  OS_CRITICAL_EXIT();
  52.              }
  53.              break;
  54.  
  55.         default:
  56.              OS_CRITICAL_EXIT();
  57.             *p_err = OS_ERR_STATE_INVALID;
  58.              break;
  59.     }
  60. }
  61. #endif

OS_TaskQPost ()

总的来说任务内建的信号量或消息对列被创建出来就是有其特点使用简单方便，且管理方便。

任务内建消息队列等待：

  1. #if OS_CFG_TASK_Q_EN > 0u
  2. void  *OSTaskQPend (OS_TICK       timeout,
  3.                     OS_OPT        opt,
  4.                     OS_MSG_SIZE  *p_msg_size,
  5.                     CPU_TS       *p_ts,
  6.                     OS_ERR       *p_err)
  7. {
  8.     OS_MSG_Q     *p_msg_q;
  9.     void         *p_void;
  10.     CPU_SR_ALLOC();
  11.  
  12. #ifdef OS_SAFETY_CRITICAL
  13.     if (p_err == (OS_ERR *)0) {
  14.         OS_SAFETY_CRITICAL_EXCEPTION();
  15.         return ((void *)0);
  16.     }
  17. #endif
  18.  
  19. #if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0u
  20.     if (OSIntNestingCtr > (OS_NESTING_CTR)0) {              /* Can't Pend from an ISR                                 */
  21.        *p_err = OS_ERR_PEND_ISR;
  22.         return ((void *)0);
  23.     }
  24. #endif
  25.  
  26. #if OS_CFG_ARG_CHK_EN > 0u                                  /* ---------------- VALIDATE ARGUMENTS ------------------ */
  27.     if (p_msg_size == (OS_MSG_SIZE *)0) {                   /* User must supply a valid destination for msg size      */
  28.        *p_err = OS_ERR_PTR_INVALID;
  29.         return ((void *)0);
  30.     }
  31.     switch (opt) {                                          /* User must supply a valid option                        */
  32.         case OS_OPT_PEND_BLOCKING:
  33.         case OS_OPT_PEND_NON_BLOCKING:
  34.              break;
  35.  
  36.         default:
  37.             *p_err = OS_ERR_OPT_INVALID;
  38.              return ((void *)0);
  39.     }
  40. #endif
  41.  
  42.     if (p_ts != (CPU_TS *)0) {
  43.        *p_ts  = (CPU_TS  )0;                                /* Initialize the returned timestamp                      */
  44.     }
  45.  
  46.     CPU_CRITICAL_ENTER();
  47.     //取出任务内建消息队列
  48.     p_msg_q = &OSTCBCurPtr->MsgQ;                           /* Any message waiting in the message queue?              */
  49.     //获取消息的地址
  50.     p_void  = OS_MsgQGet(p_msg_q,
  51.                          p_msg_size,
  52.                          p_ts,
  53.                          p_err);
  54.     //如果获取到了消息
  55.     if (*p_err == OS_ERR_NONE) {
  56. #if OS_CFG_TASK_PROFILE_EN > 0u
  57.         if (p_ts != (CPU_TS *)0) {
  58.             OSTCBCurPtr->MsgQPendTime = OS_TS_GET() - *p_ts;
  59.             if (OSTCBCurPtr->MsgQPendTimeMax < OSTCBCurPtr->MsgQPendTime) {
  60.                 OSTCBCurPtr->MsgQPendTimeMax = OSTCBCurPtr->MsgQPendTime;
  61.             }
  62.         }
  63. #endif
  64.         CPU_CRITICAL_EXIT();
  65.         //返回消息地址，同时指针形式的传入p_msg_size将消息长度传回
  66.         return (p_void);                                    /* Yes, Return oldest message received                    */
  67.     }
  68.  
  69.     if ((opt & OS_OPT_PEND_NON_BLOCKING) != (OS_OPT)0) {    /* Caller wants to block if not available?                */
  70.        *p_err = OS_ERR_PEND_WOULD_BLOCK;                    /* No                                                     */
  71.         CPU_CRITICAL_EXIT();
  72.         return ((void *)0);
  73.     } else {                                                /* Yes                                                    */
  74.         if (OSSchedLockNestingCtr > (OS_NESTING_CTR)0) {    /*     Can't block when the scheduler is locked           */
  75.             CPU_CRITICAL_EXIT();
  76.            *p_err = OS_ERR_SCHED_LOCKED;
  77.             return ((void *)0);
  78.         }
  79.     }
  80.                                                             /* Lock the scheduler/re-enable interrupts                */
  81.     OS_CRITICAL_ENTER_CPU_EXIT();
  82.     //没有请求到消息阻塞任务
  83.     OS_Pend((OS_PEND_DATA *)0,                              /* Block task pending on Message                          */
  84.             (OS_PEND_OBJ  *)0,
  85.             (OS_STATE      )OS_TASK_PEND_ON_TASK_Q,
  86.             (OS_TICK       )timeout);
  87.     OS_CRITICAL_EXIT_NO_SCHED();
  88.     OSSched();                                              /* Find the next highest priority task ready to run       */
  89.  
  90.     CPU_CRITICAL_ENTER();
  91.     switch (OSTCBCurPtr->PendStatus) {
  92.         case OS_STATUS_PEND_OK:                             /* Extract message from TCB (Put there by Post)           */
  93.              p_void      = OSTCBCurPtr->MsgPtr;
  94.             *p_msg_size  = OSTCBCurPtr->MsgSize;
  95.              if (p_ts != (CPU_TS *)0) {
  96.                 *p_ts  = OSTCBCurPtr->TS;
  97. #if OS_CFG_TASK_PROFILE_EN > 0u
  98.                 OSTCBCurPtr->MsgQPendTime = OS_TS_GET() - OSTCBCurPtr->TS;
  99.                 if (OSTCBCurPtr->MsgQPendTimeMax < OSTCBCurPtr->MsgQPendTime) {
  100.                     OSTCBCurPtr->MsgQPendTimeMax = OSTCBCurPtr->MsgQPendTime;
  101.                 }
  102. #endif
  103.              }
  104.             *p_err = OS_ERR_NONE;
  105.              break;
  106.  
  107.         case OS_STATUS_PEND_ABORT:                          /* Indicate that we aborted                               */
  108.              p_void     = (void      *)0;
  109.             *p_msg_size = (OS_MSG_SIZE)0;
  110.              if (p_ts  != (CPU_TS *)0) {
  111.                 *p_ts   = (CPU_TS  )0;
  112.              }
  113.             *p_err      =  OS_ERR_PEND_ABORT;
  114.              break;
  115.  
  116.         case OS_STATUS_PEND_TIMEOUT:                        /* Indicate that we didn't get event within TO            */
  117.         default:
  118.              p_void     = (void      *)0;
  119.             *p_msg_size = (OS_MSG_SIZE)0;
  120.              if (p_ts  != (CPU_TS *)0) {
  121.                 *p_ts   =  OSTCBCurPtr->TS;
  122.              }
  123.             *p_err      =  OS_ERR_TIMEOUT;
  124.              break;
  125.     }
  126.     CPU_CRITICAL_EXIT();
  127.     return (p_void);                                        /* Return received message                                */
  128. }
  129. #endif

OSTaskQPend ()

μC/OS-III---I笔记9---任务等待多个内核对象和任务内建信号量与消息队列的更多相关文章

  1. 18.1-uC/OS-III等待多个内核对象

    等待的多个内核对象是指多值信号量和消息队列的任意组合 . 如果想要使用“等待多个内核对象”,就必须事先使能“等待多个内核对象”.“等待多个内核对象” 的使能位于“os_cfg.h”. 1.OSPend ...

  2. UCOSIII等待多个内核对象

    内核对象 内核对象包括信号量.互斥信号量.消息队列和事件标志组 UCOSIII中允许任务同时等待多个信号量和多个消息队列 主结构体 typedef struct os_pend_data OS_PEN ...

  3. [原创]java WEB学习笔记71：Struts2 学习之路-- struts2常见的内建验证程序及注意点，短路验证，非字段验证，错误消息的重用

    本博客的目的:①总结自己的学习过程,相当于学习笔记 ②将自己的经验分享给大家,相互学习,互相交流,不可商用 内容难免出现问题,欢迎指正,交流,探讨,可以留言,也可以通过以下方式联系. 本人互联网技术爱 ...

  4. 第9章 用内核对象进行线程同步（2）_可等待计时器（WaitableTimer）

    9.4 可等待的计时器内核对象——某个指定的时间或每隔一段时间触发一次 (1)创建可等待计时器:CreateWaitableTimer(使用时应把常量_WIN32_WINNT定义为0x0400) 参数 ...

  5. 基于μC／OS—III的CC1120驱动程序设计

    基于μC/OS—III的CC1120驱动程序设计 时间:2014-01-21 来源:电子设计工程 作者:张绍游,张贻雄,石江宏 关键字:CC1120   嵌入式操作系统   STM32F103ZE   ...

  6. Python3+Selenium3+webdriver学习笔记14（等待判断 鼠标事件 ）

    !/usr/bin/env python -*- coding:utf-8 -*-'''Selenium3+webdriver学习笔记14(等待判断 鼠标事件 )'''from selenium im ...

  7. uc/os iii移植到STM32F4---IAR开发环境

    也许是先入为主的原因,时钟用不惯Keil环境,大多数的教程都是拿keil写的,尝试将官方的uc/os iii 移植到IAR环境. 1.首先尝试从官网上下载的官方移植的代码,编译通过,但是执行会报堆栈溢 ...

  8. python笔记9 线程进程 threading多线程模块 GIL锁 multiprocessing多进程模块 同步锁Lock 队列queue IO模型

    线程与进程 进程 进程就是一个程序在一个数据集上的一次动态执行过程.进程一般由程序.数据集.进程控制块三部分组成.我们编写的程序用来描述进程要完成哪些功能以及如何完成:数据集则是程序在执行过程中所需要 ...

  9. 消息队列 NSQ 源码学习笔记 (一)

    nsqlookupd 用于Topic, Channel, Node 三类信息的一致性分发 概要 nsqlookup 知识点总结 功能定位 为node 节点和客户端节点提供一致的topic, chann ...

随机推荐

  1. 求得二叉搜索树的第k小的元素

    求得二叉搜索树的第k小的元素 给定一个二叉搜索树,编写一个函数 kthSmallest 来查找其中第 k 个最小的元素. 须知:二叉搜索树,又叫二叉排序树,二叉查找树.特点是:左子树的所有元素都小于等 ...

  2. vue中computed/method/watch的区别

    摘要:本文通过官方文档结合源码来分析computed/method/watch的区别. Tips:本文分析的源码版本是v2.6.11,文章中牵涉到vue响应式系统原理部分,如果不是很了解,建议先阅读上 ...

  3. 理解js闭包9大使用场景

    1.返回值(最常用) //1.返回值 最常用的 function fn(){ var name="hello"; return function(){ return name; } ...

  4. 在vSphere中为不同服务器配置IPMI功能

    在vSphere HA中如果要配置并启用DPM功能,需要记录服务器远程管理接口的IP地址(不是ESXi的IP地址,而是另一个独立的IP地址,是与ESXi服务器同一网段的另一个IP地址)与MAC地址.远 ...

  5. C#高级编程第11版 - 第三章 索引

    [1]3.1 创建及使用类 1.构造函数:构造函数的名字与类名相同: 使用 new 表达式创建类的对象或者结构(例如int)时,会调用其构造函数.并且通常初始化新对象的数据成员. 除非类是静态的,否则 ...

  6. ShardingSphere内核原理 原创 鸽子 架构漫谈 2021-01-09

    ShardingSphere内核原理 原创 鸽子 架构漫谈 2021-01-09

  7. SpringBoot配置文件 application.properties，yaml配置

    SpringBoot配置文件 application.properties,yaml配置 1.Spring Boot 的配置文件 application.properties 1.1 位置问题 1.2 ...

  8. Spark Dataset DataFrame空值null,NaN判断和处理

    Spark Dataset DataFrame空值null,NaN判断和处理 import org.apache.spark.sql.SparkSession import org.apache.sp ...

  9. svn 启动项目报错，项目被lock

    问题描述 问题解决 (一)Eclipse SVN 插件处理 (二)SVN 客户端处理 (三)删除lock文件 问题描述 在使用开发工具开发项目时(如Eclipse),在做项目的中途,有时候Eclips ...

  10. Scala安装后，在IDEA中配置

    IDEA中配置Scala 一.设置Module 二.添加Scala的SDK 三.寻找本地scala安装路径 四.测试是否可以新建有Scala Class 五.踩坑填坑记录 5.1:Error:(4, ...