os_mbox.lst

sst51单片机

                  } else {
                      tasks_waiting = FALSE;                             /* No                                       */
                  }
                  switch (opt) {
                      case OS_DEL_NO_PEND:                               /* Delete mailbox only if no task waiting   */
                           if (tasks_waiting == FALSE) {
                               pevent->OSEventType = OS_EVENT_TYPE_UNUSED;
                               pevent->OSEventPtr  = OSEventFreeList;    /* Return Event Control Block to free list  */
                               OSEventFreeList     = pevent;             /* Get next free event control block        */
                               OS_EXIT_CRITICAL();
                               *err = OS_NO_ERR;
                               return ((OS_EVENT *)0);                   /* Mailbox has been deleted                 */
                           } else {
C51 COMPILER V7.20   OS_MBOX                                                               11/29/2008 18:58:56 PAGE 4   

                               OS_EXIT_CRITICAL();
                               *err = OS_ERR_TASK_WAITING;
                               return (pevent);
                           }
              
                      case OS_DEL_ALWAYS:                                /* Always delete the mailbox                */
                           while (pevent->OSEventGrp != 0x00) {          /* Ready ALL tasks waiting for mailbox      */
                               OS_EventTaskRdy(pevent, (void *)0, OS_STAT_MBOX);
                           }
                           pevent->OSEventType = OS_EVENT_TYPE_UNUSED;
                           pevent->OSEventPtr  = OSEventFreeList;        /* Return Event Control Block to free list  */
                           OSEventFreeList     = pevent;                 /* Get next free event control block        */
                           OS_EXIT_CRITICAL();
                           if (tasks_waiting == TRUE) {                  /* Reschedule only if task(s) were waiting  */
                               OS_Sched();                               /* Find highest priority task ready to run  */
                           }
                           *err = OS_NO_ERR;
                           return ((OS_EVENT *)0);                       /* Mailbox has been deleted                 */
              
                      default:
                           OS_EXIT_CRITICAL();
                           *err = OS_ERR_INVALID_OPT;
                           return (pevent);
                  }
              }
              #endif
              
              /*$PAGE*/
              /*
              *********************************************************************************************************
              *                                      PEND ON MAILBOX FOR A MESSAGE
              *
              * Description: This function waits for a message to be sent to a mailbox
              *
              * Arguments  : pevent        is a pointer to the event control block associated with the desired mailbox
              *
              *              timeout       is an optional timeout period (in clock ticks).  If non-zero, your task will
              *                            wait for a message to arrive at the mailbox up to the amount of time
              *                            specified by this argument.  If you specify 0, however, your task will wait
              *                            forever at the specified mailbox or, until a message arrives.
              *
              *              err           is a pointer to where an error message will be deposited.  Possible error
              *                            messages are:
              *
              *                            OS_NO_ERR           The call was successful and your task received a
              *                                                message.
              *                            OS_TIMEOUT          A message was not received within the specified timeout
              *                            OS_ERR_EVENT_TYPE   Invalid event type
              *                            OS_ERR_PEND_ISR     If you called this function from an ISR and the result
              *                                                would lead to a suspension.
              *                            OS_ERR_PEVENT_NULL  If 'pevent' is a NULL pointer
              *
              * Returns    : != (void *)0  is a pointer to the message received
              *              == (void *)0  if no message was received or,
              *                            if 'pevent' is a NULL pointer or,
              *                            if you didn't pass the proper pointer to the event control block.
              *********************************************************************************************************
              */
              
              void  *OSMboxPend (OS_EVENT *pevent, INT16U timeout, INT8U *err) reentrant
              {
              #if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
C51 COMPILER V7.20   OS_MBOX                                                               11/29/2008 18:58:56 PAGE 5   

                  OS_CPU_SR  cpu_sr;
              #endif    
                  void      *msg;
              
              
                  if (OSIntNesting > 0) {                           /* See if called from ISR ...                    */
                      *err = OS_ERR_PEND_ISR;                       /* ... can't PEND from an ISR                    */
                      return ((void *)0);
                  }
              #if OS_ARG_CHK_EN > 0
                  if (pevent == (OS_EVENT *)0) {                    /* Validate 'pevent'                             */
                      *err = OS_ERR_PEVENT_NULL;
                      return ((void *)0);
                  }
                  if (pevent->OSEventType != OS_EVENT_TYPE_MBOX) {  /* Validate event block type                     */
                      *err = OS_ERR_EVENT_TYPE;
                      return ((void *)0);
                  }
              #endif
                  OS_ENTER_CRITICAL();
                  msg = pevent->OSEventPtr;
                  if (msg != (void *)0) {                           /* See if there is already a message             */
                      pevent->OSEventPtr = (void *)0;               /* Clear the mailbox                             */
                      OS_EXIT_CRITICAL();
                      *err = OS_NO_ERR;
                      return (msg);                                 /* Return the message received (or NULL)         */
                  }
                  OSTCBCur->OSTCBStat |= OS_STAT_MBOX;              /* Message not available, task will pend         */
                  OSTCBCur->OSTCBDly   = timeout;                   /* Load timeout in TCB                           */
                  OS_EventTaskWait(pevent);                         /* Suspend task until event or timeout occurs    */
                  OS_EXIT_CRITICAL();
                  OS_Sched();                                       /* Find next highest priority task ready to run  */
                  OS_ENTER_CRITICAL();
                  msg = OSTCBCur->OSTCBMsg;
                  if (msg != (void *)0) {                           /* See if we were given the message              */
                      OSTCBCur->OSTCBMsg      = (void *)0;          /* Yes, clear message received                   */
                      OSTCBCur->OSTCBStat     = OS_STAT_RDY;
                      OSTCBCur->OSTCBEventPtr = (OS_EVENT *)0;      /* No longer waiting for event                   */
                      OS_EXIT_CRITICAL();
                      *err                    = OS_NO_ERR;
                      return (msg);                                 /* Return the message received                   */
                  }
                  OS_EventTO(pevent);                               /* Timed out, Make task ready                    */
                  OS_EXIT_CRITICAL();
                  *err = OS_TIMEOUT;                                /* Indicate that a timeout occured               */
                  return ((void *)0);                               /* Return a NULL message                         */
              }
              /*$PAGE*/
              /*
              *********************************************************************************************************
              *                                       POST MESSAGE TO A MAILBOX
              *
              * Description: This function sends a message to a mailbox
              *
              * Arguments  : pevent        is a pointer to the event control block associated with the desired mailbox
              *
              *              msg           is a pointer to the message to send.  You MUST NOT send a NULL pointer.
              *
              * Returns    : OS_NO_ERR            The call was successful and the message was sent
              *              OS_MBOX_FULL         If the mailbox already contains a message.  You can can only send one
              *                                   message at a time and thus, the message MUST be consumed before you
              *                                   are allowed to send another one.
C51 COMPILER V7.20   OS_MBOX                                                               11/29/2008 18:58:56 PAGE 6   

              *              OS_ERR_EVENT_TYPE    If you are attempting to post to a non mailbox.
              *              OS_ERR_PEVENT_NULL   If 'pevent' is a NULL pointer
              *              OS_ERR_POST_NULL_PTR If you are attempting to post a NULL pointer
              *********************************************************************************************************
              */
              
              #if OS_MBOX_POST_EN > 0
              INT8U  OSMboxPost (OS_EVENT *pevent, void *msg) reentrant
              {
              #if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
                  OS_CPU_SR  cpu_sr;
              #endif    
                  
                  
              #if OS_ARG_CHK_EN > 0
                  if (pevent == (OS_EVENT *)0) {                    /* Validate 'pevent'                             */
                      return (OS_ERR_PEVENT_NULL);
                  }
                  if (msg == (void *)0) {                           /* Make sure we are not posting a NULL pointer   */
                      return (OS_ERR_POST_NULL_PTR);
                  }
                  if (pevent->OSEventType != OS_EVENT_TYPE_MBOX) {  /* Validate event block type                     */
                      return (OS_ERR_EVENT_TYPE);
                  }
              #endif
                  OS_ENTER_CRITICAL();
                  if (pevent->OSEventGrp != 0x00) {                 /* See if any task pending on mailbox            */
                      OS_EventTaskRdy(pevent, msg, OS_STAT_MBOX);   /* Ready highest priority task waiting on event  */
                      OS_EXIT_CRITICAL();
                      OS_Sched();                                   /* Find highest priority task ready to run       */
                      return (OS_NO_ERR);
                  }
                  if (pevent->OSEventPtr != (void *)0) {            /* Make sure mailbox doesn't already have a msg  */
                      OS_EXIT_CRITICAL();
                      return (OS_MBOX_FULL);
                  }