}#endif/*$PAGE*//***********************************************************************************************************                                  PEND ON MUTUAL EXCLUSION SEMAPHORE** Description: This function waits for a mutual exclusion semaphore.** Arguments  : pevent        is a pointer to the event control block associated with the desired*                            mutex.**              timeout       is an optional timeout period (in clock ticks).  If non-zero, your task will*                            wait for the resource up to the amount of time specified by this argument.*                            If you specify 0, however, your task will wait forever at the specified*                            mutex or, until the resource becomes available.**              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 owns the mutex*                               OS_TIMEOUT         The mutex was not available within the specified time.*                               OS_ERR_EVENT_TYPE  If you didn't pass a pointer to a mutex*                               OS_ERR_PEVENT_NULL 'pevent' is a NULL pointer*                               OS_ERR_PEND_ISR    If you called this function from an ISR and the result*                                                  would lead to a suspension.** Returns    : none** Note(s)    : 1) The task that owns the Mutex MUST NOT pend on any other event while it owns the mutex.*              2) You MUST NOT change the priority of the task that owns the mutex**********************************************************************************************************/void  OSMutexPend (OS_EVENT *pevent, INT16U timeout, INT8U *err){#if OS_CRITICAL_METHOD == 3                                /* Allocate storage for CPU status register */    OS_CPU_SR  cpu_sr;#endif        INT8U      pip;                                        /* Priority Inheritance Priority (PIP)      */    INT8U      mprio;                                      /* Mutex owner priority                     */    BOOLEAN    rdy;                                        /* Flag indicating task was ready           */    OS_TCB    *ptcb;    if (OSIntNesting > 0) {                                /* See if called from ISR ...               */        *err = OS_ERR_PEND_ISR;                            /* ... can't PEND from an ISR               */        return;    }#if OS_ARG_CHK_EN > 0    if (pevent == (OS_EVENT *)0) {                         /* Validate 'pevent'                        */        *err = OS_ERR_PEVENT_NULL;        return;    }    if (pevent->OSEventType != OS_EVENT_TYPE_MUTEX) {      /* Validate event block type                */        *err = OS_ERR_EVENT_TYPE;        return;    }#endif    OS_ENTER_CRITICAL();								   /* Is Mutex available?                      */    if ((INT8U)(pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8) == OS_MUTEX_AVAILABLE) {        pevent->OSEventCnt &= OS_MUTEX_KEEP_UPPER_8;       /* Yes, Acquire the resource                */        pevent->OSEventCnt |= OSTCBCur->OSTCBPrio;         /*      Save priority of owning task        */        pevent->OSEventPtr  = (void *)OSTCBCur;            /*      Point to owning task's OS_TCB       */        OS_EXIT_CRITICAL();        *err  = OS_NO_ERR;        return;    }    pip   = (INT8U)(pevent->OSEventCnt >> 8);                     /* No, Get PIP from mutex            */    mprio = (INT8U)(pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8);  /*     Get priority of mutex owner   */    ptcb  = (OS_TCB *)(pevent->OSEventPtr);                       /*     Point to TCB of mutex owner   */    if (ptcb->OSTCBPrio != pip && mprio > OSTCBCur->OSTCBPrio) {  /*     Need to promote prio of owner?*/        if ((OSRdyTbl[ptcb->OSTCBY] & ptcb->OSTCBBitX) != 0x00) { /*     See if mutex owner is ready   */                                                                  /*     Yes, Remove owner from Rdy ...*/                                                                  /*          ... list at current prio */            if ((OSRdyTbl[ptcb->OSTCBY] &= ~ptcb->OSTCBBitX) == 0x00) {                OSRdyGrp &= ~ptcb->OSTCBBitY;            }            rdy = TRUE;        } else {            rdy = FALSE;                                          /* No                                */        }        ptcb->OSTCBPrio         = pip;                     /* Change owner task prio to PIP            */        ptcb->OSTCBY            = ptcb->OSTCBPrio >> 3;        ptcb->OSTCBBitY         = OSMapTbl[ptcb->OSTCBY];        ptcb->OSTCBX            = ptcb->OSTCBPrio & 0x07;        ptcb->OSTCBBitX         = OSMapTbl[ptcb->OSTCBX];        if (rdy == TRUE) {                                 /* If task was ready at owner's priority ...*/            OSRdyGrp               |= ptcb->OSTCBBitY;     /* ... make it ready at new priority.       */            OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;        }        OSTCBPrioTbl[pip]       = (OS_TCB *)ptcb;    }    OSTCBCur->OSTCBStat |= OS_STAT_MUTEX;             /* Mutex not available, pend current task        */    OSTCBCur->OSTCBDly   = timeout;                   /* Store timeout in current task's TCB           */    OS_EventTaskWait(pevent);                         /* Suspend task until event or timeout occurs    */    OS_EXIT_CRITICAL();    OS_Sched();                                       /* Find next highest priority task ready         */    OS_ENTER_CRITICAL();    if (OSTCBCur->OSTCBStat & OS_STAT_MUTEX) {        /* Must have timed out if still waiting for event*/        OS_EventTO(pevent);        OS_EXIT_CRITICAL();        *err = OS_TIMEOUT;                            /* Indicate that we didn't get mutex within TO   */        return;    }    OSTCBCur->OSTCBEventPtr = (OS_EVENT *)0;    OS_EXIT_CRITICAL();    *err = OS_NO_ERR;}/*$PAGE*//***********************************************************************************************************                                  POST TO A MUTUAL EXCLUSION SEMAPHORE** Description: This function signals a mutual exclusion semaphore** Arguments  : pevent              is a pointer to the event control block associated with the desired*                                  mutex.** Returns    : OS_NO_ERR               The call was successful and the mutex was signaled.*              OS_ERR_EVENT_TYPE       If you didn't pass a pointer to a mutex*              OS_ERR_PEVENT_NULL      'pevent' is a NULL pointer*              OS_ERR_POST_ISR         Attempted to post from an ISR (not valid for MUTEXes)*              OS_ERR_NOT_MUTEX_OWNER  The task that did the post is NOT the owner of the MUTEX.**********************************************************************************************************/INT8U  OSMutexPost (OS_EVENT *pevent){#if OS_CRITICAL_METHOD == 3                           /* Allocate storage for CPU status register      */    OS_CPU_SR  cpu_sr;#endif        INT8U      pip;                                   /* Priority inheritance priority                 */    INT8U      prio;    if (OSIntNesting > 0) {                           /* See if called from ISR ...                    */        return (OS_ERR_POST_ISR);                     /* ... can't POST mutex from an ISR              */    }#if OS_ARG_CHK_EN > 0    if (pevent == (OS_EVENT *)0) {                    /* Validate 'pevent'                             */        return (OS_ERR_PEVENT_NULL);    }    if (pevent->OSEventType != OS_EVENT_TYPE_MUTEX) { /* Validate event block type                     */        return (OS_ERR_EVENT_TYPE);    }                                                 #endif    OS_ENTER_CRITICAL();    pip  = (INT8U)(pevent->OSEventCnt >> 8);          /* Get priority inheritance priority of mutex    */    prio = (INT8U)(pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8);  /* Get owner's original priority      */    if (OSTCBCur->OSTCBPrio != pip &&         OSTCBCur->OSTCBPrio != prio) {                /* See if posting task owns the MUTEX            */        OS_EXIT_CRITICAL();        return (OS_ERR_NOT_MUTEX_OWNER);    }    if (OSTCBCur->OSTCBPrio == pip) {                 /* Did we have to raise current task's priority? */                                                      /* Yes, Return to original priority              */                                                      /*      Remove owner from ready list at 'pip'    */        if ((OSRdyTbl[OSTCBCur->OSTCBY] &= ~OSTCBCur->OSTCBBitX) == 0) {            OSRdyGrp &= ~OSTCBCur->OSTCBBitY;        }        OSTCBCur->OSTCBPrio         = prio;        OSTCBCur->OSTCBY            = prio >> 3;        OSTCBCur->OSTCBBitY         = OSMapTbl[OSTCBCur->OSTCBY];        OSTCBCur->OSTCBX            = prio & 0x07;        OSTCBCur->OSTCBBitX         = OSMapTbl[OSTCBCur->OSTCBX];        OSRdyGrp                   |= OSTCBCur->OSTCBBitY;        OSRdyTbl[OSTCBCur->OSTCBY] |= OSTCBCur->OSTCBBitX;        OSTCBPrioTbl[prio]          = (OS_TCB *)OSTCBCur;    }    OSTCBPrioTbl[pip] = (OS_TCB *)1;                  /* Reserve table entry                           */    if (pevent->OSEventGrp != 0x00) {                 /* Any task waiting for the mutex?               */                                                      /* Yes, Make HPT waiting for mutex ready         */        prio                = OS_EventTaskRdy(pevent, (void *)0, OS_STAT_MUTEX);        pevent->OSEventCnt &= OS_MUTEX_KEEP_UPPER_8;  /*      Save priority of mutex's new owner       */        pevent->OSEventCnt |= prio;        pevent->OSEventPtr  = OSTCBPrioTbl[prio];     /*      Link to mutex owner's OS_TCB             */        OS_EXIT_CRITICAL();        OS_Sched();                                   /*      Find highest priority task ready to run  */        return (OS_NO_ERR);    }    pevent->OSEventCnt |= OS_MUTEX_AVAILABLE;         /* No,  Mutex is now available                   */    pevent->OSEventPtr  = (void *)0;    OS_EXIT_CRITICAL();    return (OS_NO_ERR);}/*$PAGE*//***********************************************************************************************************                                     QUERY A MUTUAL EXCLUSION SEMAPHORE** Description: This function obtains information about a mutex** Arguments  : pevent        is a pointer to the event control block associated with the desired mutex**              pdata         is a pointer to a structure that will contain information about the mutex** Returns    : OS_NO_ERR            The call was successful and the message was sent*              OS_ERR_QUERY_ISR     If you called this function from an ISR*              OS_ERR_PEVENT_NULL   'pevent' is a NULL pointer*              OS_ERR_EVENT_TYPE    If you are attempting to obtain data from a non mutex.**********************************************************************************************************/#if OS_MUTEX_QUERY_EN > 0INT8U  OSMutexQuery (OS_EVENT *pevent, OS_MUTEX_DATA *pdata){#if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */    OS_CPU_SR  cpu_sr;#endif        INT8U     *psrc;    INT8U     *pdest;    if (OSIntNesting > 0) {                                /* See if called from ISR ...               */        return (OS_ERR_QUERY_ISR);                         /* ... can't QUERY mutex from an ISR        */    }#if OS_ARG_CHK_EN > 0    if (pevent == (OS_EVENT *)0) {                         /* Validate 'pevent'                        */        return (OS_ERR_PEVENT_NULL);    }    if (pevent->OSEventType != OS_EVENT_TYPE_MUTEX) {      /* Validate event block type                */        return (OS_ERR_EVENT_TYPE);    }#endif    OS_ENTER_CRITICAL();    pdata->OSMutexPIP  = (INT8U)(pevent->OSEventCnt >> 8);    pdata->OSOwnerPrio = (INT8U)(pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8);    if (pdata->OSOwnerPrio == 0xFF) {        pdata->OSValue = 1;    } else {        pdata->OSValue = 0;    }    pdata->OSEventGrp  = pevent->OSEventGrp;               /* Copy wait list                           */    psrc               = &pevent->OSEventTbl[0];    pdest              = &pdata->OSEventTbl[0];#if OS_EVENT_TBL_SIZE > 0    *pdest++           = *psrc++;#endif#if OS_EVENT_TBL_SIZE > 1    *pdest++           = *psrc++;#endif#if OS_EVENT_TBL_SIZE > 2    *pdest++           = *psrc++;#endif#if OS_EVENT_TBL_SIZE > 3    *pdest++           = *psrc++;#endif#if OS_EVENT_TBL_SIZE > 4    *pdest++           = *psrc++;#endif#if OS_EVENT_TBL_SIZE > 5    *pdest++           = *psrc++;#endif#if OS_EVENT_TBL_SIZE > 6    *pdest++           = *psrc++;#endif#if OS_EVENT_TBL_SIZE > 7    *pdest             = *psrc;#endif    OS_EXIT_CRITICAL();    return (OS_NO_ERR);}#endif                                                     /* OS_MUTEX_QUERY_EN                        */#endif                                                     /* OS_MUTEX_EN                              */