www.pudn.com > uCOS-III.zip > os_q.c, change:2011-08-02,size:39966b


/* 
************************************************************************************************************************ 
*                                                      uC/OS-III 
*                                                 The Real-Time Kernel 
* 
*                                  (c) Copyright 2009-2011; Micrium, Inc.; Weston, FL 
*                           All rights reserved.  Protected by international copyright laws. 
* 
*                                               MESSAGE QUEUE MANAGEMENT 
* 
* File    : OS_Q.C 
* By      : JJL 
* Version : V3.02.00 
* 
* LICENSING TERMS: 
* --------------- 
*           uC/OS-III is provided in source form for FREE short-term evaluation, for educational use or  
*           for peaceful research.  If you plan or intend to use uC/OS-III in a commercial application/ 
*           product then, you need to contact Micrium to properly license uC/OS-III for its use in your  
*           application/product.   We provide ALL the source code for your convenience and to help you  
*           experience uC/OS-III.  The fact that the source is provided does NOT mean that you can use  
*           it commercially without paying a licensing fee. 
* 
*           Knowledge of the source code may NOT be used to develop a similar product. 
* 
*           Please help us continue to provide the embedded community with the finest software available. 
*           Your honesty is greatly appreciated. 
* 
*           You can contact us at www.micrium.com, or by phone at +1 (954) 217-2036. 
************************************************************************************************************************ 
*/ 
 
#include <os.h> 
 
#ifdef VSC_INCLUDE_SOURCE_FILE_NAMES 
const  CPU_CHAR  *os_q__c = "$Id: $"; 
#endif 
 
 
#if OS_CFG_Q_EN > 0u 
/* 
************************************************************************************************************************ 
*                                               CREATE A MESSAGE QUEUE 
* 
* Description: This function is called by your application to create a message queue.  Message queues MUST be created 
*              before they can be used. 
* 
* Arguments  : p_q         is a pointer to the message queue 
* 
*              p_name      is a pointer to an ASCII string that will be used to name the message queue 
* 
*              max_qty     indicates the maximum size of the message queue (must be non-zero).  Note that it's also not 
*                          possible to have a size higher than the maximum number of OS_MSGs available. 
* 
*              p_err       is a pointer to a variable that will contain an error code returned by this function. 
* 
*                              OS_ERR_NONE                    the call was successful 
*                              OS_ERR_CREATE_ISR              can't create from an ISR 
*                              OS_ERR_ILLEGAL_CREATE_RUN_TIME if you are trying to create the Queue after you called 
*                                                               OSSafetyCriticalStart(). 
*                              OS_ERR_NAME                    if 'p_name' is a NULL pointer 
*                              OS_ERR_OBJ_CREATED             if the message queue has already been created 
*                              OS_ERR_OBJ_PTR_NULL            if you passed a NULL pointer for 'p_q' 
*                              OS_ERR_Q_SIZE                  if the size you specified is 0 
* 
* Returns    : none 
************************************************************************************************************************ 
*/ 
 
void  OSQCreate (OS_Q        *p_q, 
                 CPU_CHAR    *p_name, 
                 OS_MSG_QTY   max_qty, 
                 OS_ERR      *p_err) 
 
{ 
    CPU_SR_ALLOC(); 
 
 
 
#ifdef OS_SAFETY_CRITICAL 
    if (p_err == (OS_ERR *)0) { 
        OS_SAFETY_CRITICAL_EXCEPTION(); 
        return; 
    } 
#endif 
 
#ifdef OS_SAFETY_CRITICAL_IEC61508 
    if (OSSafetyCriticalStartFlag == DEF_TRUE) { 
       *p_err = OS_ERR_ILLEGAL_CREATE_RUN_TIME; 
        return; 
    } 
#endif 
 
#if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0u 
    if (OSIntNestingCtr > (OS_NESTING_CTR)0) {              /* Not allowed to be called from an ISR                   */ 
        *p_err = OS_ERR_CREATE_ISR; 
        return; 
    } 
#endif 
 
#if OS_CFG_ARG_CHK_EN > 0u 
    if (p_q == (OS_Q *)0) {                                 /* Validate arguments                                     */ 
        *p_err = OS_ERR_OBJ_PTR_NULL; 
        return; 
    } 
    if (max_qty == (OS_MSG_QTY)0) {                         /* Cannot specify a zero size queue                       */ 
        *p_err = OS_ERR_Q_SIZE; 
        return; 
    } 
#endif 
 
    OS_CRITICAL_ENTER(); 
    p_q->Type    = OS_OBJ_TYPE_Q;                           /* Mark the data structure as a message queue             */ 
    p_q->NamePtr = p_name; 
    OS_MsgQInit(&p_q->MsgQ,                                 /* Initialize the queue                                   */ 
                max_qty); 
    OS_PendListInit(&p_q->PendList);                        /* Initialize the waiting list                            */ 
 
#if OS_CFG_DBG_EN > 0u 
    OS_QDbgListAdd(p_q); 
#endif 
    OSQQty++;                                               /* One more queue created                                 */ 
 
    OS_CRITICAL_EXIT(); 
    *p_err = OS_ERR_NONE; 
} 
 
/*$PAGE*/ 
/* 
************************************************************************************************************************ 
*                                               DELETE A MESSAGE QUEUE 
* 
* Description: This function deletes a message queue and readies all tasks pending on the queue. 
* 
* Arguments  : p_q       is a pointer to the message queue you want to delete 
* 
*              opt       determines delete options as follows: 
* 
*                            OS_OPT_DEL_NO_PEND          Delete the queue ONLY if no task pending 
*                            OS_OPT_DEL_ALWAYS           Deletes the queue even if tasks are waiting. 
*                                                        In this case, all the tasks pending will be readied. 
* 
*              p_err     is a pointer to a variable that will contain an error code returned by this function. 
* 
*                            OS_ERR_NONE                 The call was successful and the queue was deleted 
*                            OS_ERR_DEL_ISR              If you tried to delete the queue from an ISR 
*                            OS_ERR_OBJ_PTR_NULL         if you pass a NULL pointer for 'p_q' 
*                            OS_ERR_OBJ_TYPE             if the message queue was not created 
*                            OS_ERR_OPT_INVALID          An invalid option was specified 
*                            OS_ERR_TASK_WAITING         One or more tasks were waiting on the queue 
* 
* Returns    : == 0          if no tasks were waiting on the queue, or upon error. 
*              >  0          if one or more tasks waiting on the queue are now readied and informed. 
* 
* Note(s)    : 1) This function must be used with care.  Tasks that would normally expect the presence of the queue MUST 
*                 check the return code of OSQPend(). 
* 
*              2) OSQAccept() callers will not know that the intended queue has been deleted. 
* 
*              3) Because ALL tasks pending on the queue will be readied, you MUST be careful in applications where the 
*                 queue is used for mutual exclusion because the resource(s) will no longer be guarded by the queue. 
************************************************************************************************************************ 
*/ 
 
#if OS_CFG_Q_DEL_EN > 0u 
OS_OBJ_QTY  OSQDel (OS_Q    *p_q, 
                    OS_OPT   opt, 
                    OS_ERR  *p_err) 
{ 
    OS_OBJ_QTY     cnt; 
    OS_OBJ_QTY     nbr_tasks; 
    OS_PEND_DATA  *p_pend_data; 
    OS_PEND_LIST  *p_pend_list; 
    OS_TCB        *p_tcb; 
    CPU_TS         ts; 
    CPU_SR_ALLOC(); 
 
 
 
#ifdef OS_SAFETY_CRITICAL 
    if (p_err == (OS_ERR *)0) { 
        OS_SAFETY_CRITICAL_EXCEPTION(); 
        return ((OS_OBJ_QTY)0); 
    } 
#endif 
 
#if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0u 
    if (OSIntNestingCtr > (OS_NESTING_CTR)0) {              /* Can't delete a message queue from an ISR               */ 
       *p_err = OS_ERR_DEL_ISR; 
        return ((OS_OBJ_QTY)0); 
    } 
#endif 
 
#if OS_CFG_ARG_CHK_EN > 0u 
    if (p_q == (OS_Q *)0) {                                 /* Validate arguments                                     */ 
        *p_err = OS_ERR_OBJ_PTR_NULL; 
        return ((OS_OBJ_QTY)0); 
    } 
#endif 
 
#if OS_CFG_OBJ_TYPE_CHK_EN > 0u 
    if (p_q->Type != OS_OBJ_TYPE_Q) {                       /* Make sure message queue was created                    */ 
        *p_err = OS_ERR_OBJ_TYPE; 
        return ((OS_OBJ_QTY)0); 
    } 
#endif 
 
    CPU_CRITICAL_ENTER(); 
    p_pend_list = &p_q->PendList; 
    cnt         = p_pend_list->NbrEntries; 
    nbr_tasks   = cnt; 
    switch (opt) { 
        case OS_OPT_DEL_NO_PEND:                            /* Delete message queue only if no task waiting           */ 
             if (nbr_tasks == (OS_OBJ_QTY)0) { 
#if OS_CFG_DBG_EN > 0u 
                 OS_QDbgListRemove(p_q); 
#endif 
                 OSQQty--; 
                 OS_QClr(p_q); 
                 CPU_CRITICAL_EXIT(); 
                 *p_err = OS_ERR_NONE; 
             } else { 
                 CPU_CRITICAL_EXIT(); 
                 *p_err = OS_ERR_TASK_WAITING; 
             } 
             break; 
 
        case OS_OPT_DEL_ALWAYS:                             /* Always delete the message queue                        */ 
             OS_CRITICAL_ENTER_CPU_CRITICAL_EXIT(); 
             ts = OS_TS_GET();                              /* Get local time stamp so all tasks get the same time    */ 
             while (cnt > 0u) {                             /* Remove all tasks from the pend list                    */ 
                 p_pend_data = p_pend_list->HeadPtr; 
                 p_tcb       = p_pend_data->TCBPtr; 
                 OS_PendObjDel((OS_PEND_OBJ *)((void *)p_q), 
                               p_tcb, 
                               ts); 
                 cnt--; 
             } 
#if OS_CFG_DBG_EN > 0u 
             OS_QDbgListRemove(p_q); 
#endif 
             OSQQty--; 
             OS_QClr(p_q); 
             OS_CRITICAL_EXIT_NO_SCHED(); 
             OSSched();                                     /* Find highest priority task ready to run                */ 
             *p_err = OS_ERR_NONE; 
             break; 
 
        default: 
             CPU_CRITICAL_EXIT(); 
             *p_err = OS_ERR_OPT_INVALID; 
             break; 
    } 
    return (nbr_tasks); 
} 
#endif 
 
/*$PAGE*/ 
/* 
************************************************************************************************************************ 
*                                                     FLUSH QUEUE 
* 
* Description : This function is used to flush the contents of the message queue. 
* 
* Arguments   : p_q        is a pointer to the message queue to flush 
* 
*               p_err      is a pointer to a variable that will contain an error code returned by this function. 
* 
*                              OS_ERR_NONE           upon success 
*                              OS_ERR_FLUSH_ISR      if you called this function from an ISR 
*                              OS_ERR_OBJ_PTR_NULL   If you passed a NULL pointer for 'p_q' 
*                              OS_ERR_OBJ_TYPE       If you didn't create the message queue 
* 
* Returns     : The number of entries freed from the queue 
* 
* Note(s)     : 1) You should use this function with great care because, when to flush the queue, you LOOSE the 
*                  references to what the queue entries are pointing to and thus, you could cause 'memory leaks'.  In 
*                  other words, the data you are pointing to that's being referenced by the queue entries should, most 
*                  likely, need to be de-allocated (i.e. freed). 
************************************************************************************************************************ 
*/ 
 
#if OS_CFG_Q_FLUSH_EN > 0u 
OS_MSG_QTY  OSQFlush (OS_Q    *p_q, 
                      OS_ERR  *p_err) 
{ 
    OS_MSG_QTY  entries; 
    CPU_SR_ALLOC(); 
 
 
 
#ifdef OS_SAFETY_CRITICAL 
    if (p_err == (OS_ERR *)0) { 
        OS_SAFETY_CRITICAL_EXCEPTION(); 
        return ((OS_MSG_QTY)0); 
    } 
#endif 
 
#if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0u 
    if (OSIntNestingCtr > (OS_NESTING_CTR)0) {              /* Can't flush a message queue from an ISR                */ 
       *p_err = OS_ERR_FLUSH_ISR; 
        return ((OS_MSG_QTY)0); 
    } 
#endif 
 
#if OS_CFG_ARG_CHK_EN > 0u 
    if (p_q == (OS_Q *)0) {                                 /* Validate arguments                                     */ 
        *p_err = OS_ERR_OBJ_PTR_NULL; 
        return ((OS_MSG_QTY)0); 
    } 
#endif 
 
#if OS_CFG_OBJ_TYPE_CHK_EN > 0u 
    if (p_q->Type != OS_OBJ_TYPE_Q) {                       /* Make sure message queue was created                    */ 
        *p_err = OS_ERR_OBJ_TYPE; 
        return ((OS_MSG_QTY)0); 
    } 
#endif 
 
    OS_CRITICAL_ENTER(); 
    entries = OS_MsgQFreeAll(&p_q->MsgQ);                   /* Return all OS_MSGs to the OS_MSG pool                  */ 
    OS_CRITICAL_EXIT(); 
    *p_err  = OS_ERR_NONE; 
    return ((OS_MSG_QTY)entries); 
} 
#endif 
 
/*$PAGE*/ 
/* 
************************************************************************************************************************ 
*                                            PEND ON A QUEUE FOR A MESSAGE 
* 
* Description: This function waits for a message to be sent to a queue 
* 
* Arguments  : p_q           is a pointer to the message queue 
* 
*              timeout       is an optional timeout period (in clock ticks).  If non-zero, your task will wait for a 
*                            message to arrive at the queue up to the amount of time specified by this argument.  If you 
*                            specify 0, however, your task will wait forever at the specified queue or, until a message 
*                            arrives. 
* 
*              opt           determines whether the user wants to block if the queue is empty or not: 
* 
*                                OS_OPT_PEND_BLOCKING 
*                                OS_OPT_PEND_NON_BLOCKING 
* 
*              p_msg_size    is a pointer to a variable that will receive the size of the message 
* 
*              p_ts          is a pointer to a variable that will receive the timestamp of when the message was 
*                            received, pend aborted or the message queue deleted,  If you pass a NULL pointer (i.e. 
*                            (CPU_TS *)0) then you will not get the timestamp.  In other words, passing a NULL pointer 
*                            is valid and indicates that you don't need the timestamp. 
* 
*              p_err         is a pointer to a variable that will contain an error code returned by this function. 
* 
*                                OS_ERR_NONE               The call was successful and your task received a message. 
*                                OS_ERR_OBJ_PTR_NULL       if you pass a NULL pointer for 'p_q' 
*                                OS_ERR_OBJ_TYPE           if the message queue was not created 
*                                OS_ERR_PEND_ABORT         the pend was aborted 
*                                OS_ERR_PEND_ISR           if you called this function from an ISR 
*                                OS_ERR_PEND_WOULD_BLOCK   If you specified non-blocking but the queue was not empty 
*                                OS_ERR_SCHED_LOCKED       the scheduler is locked 
*                                OS_ERR_TIMEOUT            A message was not received within the specified timeout 
*                                                          would lead to a suspension. 
* 
* Returns    : != (void *)0  is a pointer to the message received 
*              == (void *)0  if you received a NULL pointer message or, 
*                            if no message was received or, 
*                            if 'p_q' is a NULL pointer or, 
*                            if you didn't pass a pointer to a queue. 
************************************************************************************************************************ 
*/ 
 
void  *OSQPend (OS_Q         *p_q, 
                OS_TICK       timeout, 
                OS_OPT        opt, 
                OS_MSG_SIZE  *p_msg_size, 
                CPU_TS       *p_ts, 
                OS_ERR       *p_err) 
{ 
    OS_PEND_DATA  pend_data; 
    void         *p_void; 
    CPU_SR_ALLOC(); 
 
 
 
#ifdef OS_SAFETY_CRITICAL 
    if (p_err == (OS_ERR *)0) { 
        OS_SAFETY_CRITICAL_EXCEPTION(); 
        return ((void *)0); 
    } 
#endif 
 
#if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0u 
    if (OSIntNestingCtr > (OS_NESTING_CTR)0) {              /* Not allowed to call from an ISR                        */ 
       *p_err = OS_ERR_PEND_ISR; 
        return ((void *)0); 
    } 
#endif 
 
#if OS_CFG_ARG_CHK_EN > 0u 
    if (p_q == (OS_Q *)0) {                                 /* Validate arguments                                     */ 
        *p_err = OS_ERR_OBJ_PTR_NULL; 
        return ((void *)0); 
    } 
    if (p_msg_size == (OS_MSG_SIZE *)0) { 
        *p_err = OS_ERR_PTR_INVALID; 
        return ((void *)0); 
    } 
    switch (opt) { 
        case OS_OPT_PEND_BLOCKING: 
        case OS_OPT_PEND_NON_BLOCKING: 
             break; 
 
        default: 
             *p_err = OS_ERR_OPT_INVALID; 
             return ((void *)0); 
    } 
#endif 
 
#if OS_CFG_OBJ_TYPE_CHK_EN > 0u 
    if (p_q->Type != OS_OBJ_TYPE_Q) {                       /* Make sure message queue was created                    */ 
        *p_err = OS_ERR_OBJ_TYPE; 
        return ((void *)0); 
    } 
#endif 
 
    if (p_ts != (CPU_TS *)0) { 
       *p_ts  = (CPU_TS  )0;                                /* Initialize the returned timestamp                      */ 
    } 
 
    CPU_CRITICAL_ENTER(); 
    p_void = OS_MsgQGet(&p_q->MsgQ,                         /* Any message waiting in the message queue?              */ 
                        p_msg_size, 
                        p_ts, 
                        p_err); 
    if (*p_err == OS_ERR_NONE) { 
        CPU_CRITICAL_EXIT(); 
        return (p_void);                                    /* Yes, Return message received                           */ 
    } 
 
    if ((opt & OS_OPT_PEND_NON_BLOCKING) != (OS_OPT)0) {    /* Caller wants to block if not available?                */ 
        CPU_CRITICAL_EXIT(); 
        *p_err = OS_ERR_PEND_WOULD_BLOCK;                   /* No                                                     */ 
        return ((void *)0); 
    } else { 
        if (OSSchedLockNestingCtr > (OS_NESTING_CTR)0) {    /* Can't pend when the scheduler is locked                */ 
            CPU_CRITICAL_EXIT(); 
            *p_err = OS_ERR_SCHED_LOCKED; 
            return ((void *)0); 
        } 
    } 
 
    OS_CRITICAL_ENTER_CPU_CRITICAL_EXIT();                  /* Lock the scheduler/re-enable interrupts                */ 
    OS_Pend(&pend_data,                                     /* Block task pending on Message Queue                    */ 
            (OS_PEND_OBJ *)((void *)p_q), 
            OS_TASK_PEND_ON_Q, 
            timeout); 
    OS_CRITICAL_EXIT_NO_SCHED(); 
 
    OSSched();                                              /* Find the next highest priority task ready to run       */ 
 
    CPU_CRITICAL_ENTER(); 
    switch (OSTCBCurPtr->PendStatus) { 
        case OS_STATUS_PEND_OK:                             /* Extract message from TCB (Put there by Post)           */ 
             p_void      = OSTCBCurPtr->MsgPtr; 
             *p_msg_size = OSTCBCurPtr->MsgSize; 
             if (p_ts != (CPU_TS *)0) { 
                *p_ts  =  OSTCBCurPtr->TS; 
             } 
             *p_err      = OS_ERR_NONE; 
             break; 
 
        case OS_STATUS_PEND_ABORT:                          /* Indicate that we aborted                               */ 
             p_void      = (void      *)0; 
             *p_msg_size = (OS_MSG_SIZE)0; 
             if (p_ts != (CPU_TS *)0) { 
                *p_ts  =  OSTCBCurPtr->TS; 
             } 
             *p_err      = OS_ERR_PEND_ABORT; 
             break; 
 
        case OS_STATUS_PEND_TIMEOUT:                        /* Indicate that we didn't get event within TO            */ 
             p_void      = (void      *)0; 
             *p_msg_size = (OS_MSG_SIZE)0; 
             if (p_ts != (CPU_TS *)0) { 
                *p_ts  = (CPU_TS  )0; 
             } 
             *p_err      = OS_ERR_TIMEOUT; 
             break; 
 
        case OS_STATUS_PEND_DEL:                            /* Indicate that object pended on has been deleted        */ 
             p_void      = (void      *)0; 
             *p_msg_size = (OS_MSG_SIZE)0; 
             if (p_ts != (CPU_TS *)0) { 
                *p_ts  =  OSTCBCurPtr->TS; 
             } 
             *p_err      = OS_ERR_OBJ_DEL; 
             break; 
 
        default: 
             p_void      = (void      *)0; 
             *p_msg_size = (OS_MSG_SIZE)0; 
             *p_err      = OS_ERR_STATUS_INVALID; 
             break; 
    } 
    CPU_CRITICAL_EXIT(); 
    return (p_void); 
} 
 
 
/*$PAGE*/ 
/* 
************************************************************************************************************************ 
*                                             ABORT WAITING ON A MESSAGE QUEUE 
* 
* Description: This function aborts & readies any tasks currently waiting on a queue.  This function should be used to 
*              fault-abort the wait on the queue, rather than to normally signal the queue via OSQPost(). 
* 
* Arguments  : p_q       is a pointer to the message queue 
* 
*              opt       determines the type of ABORT performed: 
* 
*                            OS_OPT_PEND_ABORT_1          ABORT wait for a single task (HPT) waiting on the queue 
*                            OS_OPT_PEND_ABORT_ALL        ABORT wait for ALL tasks that are  waiting on the queue 
*                            OS_OPT_POST_NO_SCHED         Do not call the scheduler 
* 
*              p_err     is a pointer to a variable that will contain an error code returned by this function. 
* 
*                            OS_ERR_NONE                  At least one task waiting on the queue was readied and 
*                                                         informed of the aborted wait; check return value for the 
*                                                         number of tasks whose wait on the queue was aborted. 
*                            OS_ERR_OPT_INVALID           if you specified an invalid option 
*                            OS_ERR_OBJ_PTR_NULL          if you pass a NULL pointer for 'p_q' 
*                            OS_ERR_OBJ_TYPE              if the message queue was not created 
*                            OS_ERR_PEND_ABORT_ISR        If this function was called from an ISR 
*                            OS_ERR_PEND_ABORT_NONE       No task were pending 
* 
* Returns    : == 0          if no tasks were waiting on the queue, or upon error. 
*              >  0          if one or more tasks waiting on the queue are now readied and informed. 
************************************************************************************************************************ 
*/ 
 
#if OS_CFG_Q_PEND_ABORT_EN > 0u 
OS_OBJ_QTY  OSQPendAbort (OS_Q    *p_q, 
                          OS_OPT   opt, 
                          OS_ERR  *p_err) 
{ 
    OS_PEND_LIST  *p_pend_list; 
    OS_TCB        *p_tcb; 
    CPU_TS         ts; 
    OS_OBJ_QTY     nbr_tasks; 
    CPU_SR_ALLOC(); 
 
 
 
#ifdef OS_SAFETY_CRITICAL 
    if (p_err == (OS_ERR *)0) { 
        OS_SAFETY_CRITICAL_EXCEPTION(); 
        return ((OS_OBJ_QTY)0u); 
    } 
#endif 
 
#if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0u 
    if (OSIntNestingCtr > (OS_NESTING_CTR)0u) {             /* Not allowed to Pend Abort from an ISR                  */ 
       *p_err =  OS_ERR_PEND_ABORT_ISR; 
        return ((OS_OBJ_QTY)0u); 
    } 
#endif 
 
#if OS_CFG_ARG_CHK_EN > 0u 
    if (p_q == (OS_Q *)0) {                                 /* Validate 'p_q'                                         */ 
       *p_err =  OS_ERR_OBJ_PTR_NULL; 
        return ((OS_OBJ_QTY)0u); 
    } 
    switch (opt) {                                          /* Validate 'opt'                                         */ 
        case OS_OPT_PEND_ABORT_1: 
        case OS_OPT_PEND_ABORT_ALL: 
             break; 
 
        default: 
            *p_err =  OS_ERR_OPT_INVALID; 
             return ((OS_OBJ_QTY)0u); 
    } 
#endif 
 
#if OS_CFG_OBJ_TYPE_CHK_EN > 0u 
    if (p_q->Type != OS_OBJ_TYPE_Q) {                       /* Make sure queue was created                            */ 
       *p_err =  OS_ERR_OBJ_TYPE; 
        return ((OS_OBJ_QTY)0u); 
    } 
#endif 
 
    CPU_CRITICAL_ENTER(); 
    p_pend_list = &p_q->PendList; 
    if (p_pend_list->NbrEntries == (OS_OBJ_QTY)0u) {        /* Any task waiting on queue?                             */ 
        CPU_CRITICAL_EXIT();                                /* No                                                     */ 
       *p_err =  OS_ERR_PEND_ABORT_NONE; 
        return ((OS_OBJ_QTY)0u); 
    } 
 
    OS_CRITICAL_ENTER_CPU_CRITICAL_EXIT(); 
    nbr_tasks = 0u; 
    ts        = OS_TS_GET();                                /* Get local time stamp so all tasks get the same time    */ 
    while (p_pend_list->NbrEntries > (OS_OBJ_QTY)0u) { 
        p_tcb = p_pend_list->HeadPtr->TCBPtr; 
        OS_PendAbort((OS_PEND_OBJ *)((void *)p_q), 
                     p_tcb, 
                     ts); 
        nbr_tasks++; 
        if (opt != OS_OPT_PEND_ABORT_ALL) {                 /* Pend abort all tasks waiting?                          */ 
            break;                                          /* No                                                     */ 
        } 
    } 
    OS_CRITICAL_EXIT_NO_SCHED(); 
 
    if ((opt & OS_OPT_POST_NO_SCHED) == (OS_OPT)0u) { 
        OSSched();                                          /* Run the scheduler                                      */ 
    } 
 
   *p_err = OS_ERR_NONE; 
    return (nbr_tasks); 
} 
#endif 
 
/*$PAGE*/ 
/* 
************************************************************************************************************************ 
*                                               POST MESSAGE TO A QUEUE 
* 
* Description: This function sends a message to a queue.  With the 'opt' argument, you can specify whether the message 
*              is broadcast to all waiting tasks and/or whether you post the message to the front of the queue (LIFO) 
*              or normally (FIFO) at the end of the queue. 
* 
* Arguments  : p_q           is a pointer to a message queue that must have been created by OSQCreate(). 
* 
*              p_void        is a pointer to the message to send. 
* 
*              msg_size      specifies the size of the message (in bytes) 
* 
*              opt           determines the type of POST performed: 
* 
*                                OS_OPT_POST_ALL          POST to ALL tasks that are waiting on the queue.  This option 
*                                                         can be added to either OS_OPT_POST_FIFO or OS_OPT_POST_LIFO 
*                                OS_OPT_POST_FIFO         POST message to end of queue (FIFO) and wake up a single 
*                                                         waiting task. 
*                                OS_OPT_POST_LIFO         POST message to the front of the queue (LIFO) and wake up 
*                                                         a single waiting task. 
*                                OS_OPT_POST_NO_SCHED     Do not call the scheduler 
* 
*                            Note(s): 1) OS_OPT_POST_NO_SCHED can be added (or OR'd) with one of the other options. 
*                                     2) OS_OPT_POST_ALL      can be added (or OR'd) with one of the other options. 
*                                     3) Possible combination of options are: 
* 
*                                        OS_OPT_POST_FIFO 
*                                        OS_OPT_POST_LIFO 
*                                        OS_OPT_POST_FIFO + OS_OPT_POST_ALL 
*                                        OS_OPT_POST_LIFO + OS_OPT_POST_ALL 
*                                        OS_OPT_POST_FIFO + OS_OPT_POST_NO_SCHED 
*                                        OS_OPT_POST_LIFO + OS_OPT_POST_NO_SCHED 
*                                        OS_OPT_POST_FIFO + OS_OPT_POST_ALL + OS_OPT_POST_NO_SCHED 
*                                        OS_OPT_POST_LIFO + OS_OPT_POST_ALL + OS_OPT_POST_NO_SCHED 
* 
*              p_err         is a pointer to a variable that will contain an error code returned by this function. 
* 
*                                OS_ERR_NONE            The call was successful and the message was sent 
*                                OS_ERR_MSG_POOL_EMPTY  If there are no more OS_MSGs to use to place the message into 
*                                OS_ERR_OBJ_PTR_NULL    If 'p_q' is a NULL pointer 
*                                OS_ERR_OBJ_TYPE        If the message queue was not initialized 
*                                OS_ERR_Q_MAX           If the queue is full 
* 
* Returns    : None 
************************************************************************************************************************ 
*/ 
 
void  OSQPost (OS_Q        *p_q, 
               void        *p_void, 
               OS_MSG_SIZE  msg_size, 
               OS_OPT       opt, 
               OS_ERR      *p_err) 
{ 
    CPU_TS  ts; 
 
 
 
#ifdef OS_SAFETY_CRITICAL 
    if (p_err == (OS_ERR *)0) { 
        OS_SAFETY_CRITICAL_EXCEPTION(); 
        return; 
    } 
#endif 
 
#if OS_CFG_ARG_CHK_EN > 0u 
    if (p_q == (OS_Q *)0) {                                 /* Validate arguments                                     */ 
       *p_err = OS_ERR_OBJ_PTR_NULL; 
        return; 
    } 
#endif 
 
#if OS_CFG_OBJ_TYPE_CHK_EN > 0u 
    if (p_q->Type != OS_OBJ_TYPE_Q) {                       /* Make sure message queue was created                    */ 
        *p_err = OS_ERR_OBJ_TYPE; 
        return; 
    } 
#endif 
 
    ts = OS_TS_GET();                                       /* Get timestamp                                          */ 
 
#if OS_CFG_ISR_POST_DEFERRED_EN > 0u 
    if (OSIntNestingCtr > (OS_NESTING_CTR)0) { 
        OS_IntQPost((OS_OBJ_TYPE)OS_OBJ_TYPE_Q,             /* Post to ISR queue                                      */ 
                    (void      *)p_q, 
                    (void      *)p_void, 
                    (OS_MSG_SIZE)msg_size, 
                    (OS_FLAGS   )0, 
                    (OS_OPT     )opt, 
                    (CPU_TS     )ts, 
                    (OS_ERR    *)p_err); 
        return; 
    } 
#endif 
 
    OS_QPost(p_q, 
             p_void, 
             msg_size, 
             opt, 
             ts, 
             p_err); 
} 
 
/*$PAGE*/ 
/* 
************************************************************************************************************************ 
*                                        CLEAR THE CONTENTS OF A MESSAGE QUEUE 
* 
* Description: This function is called by OSQDel() to clear the contents of a message queue 
* 
 
* Argument(s): p_q      is a pointer to the queue to clear 
*              --- 
* 
* Returns    : none 
* 
* Note(s)    : 1) This function is INTERNAL to uC/OS-III and your application MUST NOT call it. 
************************************************************************************************************************ 
*/ 
 
void  OS_QClr (OS_Q *p_q) 
{ 
    (void)OS_MsgQFreeAll(&p_q->MsgQ);                       /* Return all OS_MSGs to the free list                    */ 
    p_q->Type    =  OS_OBJ_TYPE_NONE;                       /* Mark the data structure as a NONE                      */ 
    p_q->NamePtr = (CPU_CHAR *)((void *)"?Q"); 
    OS_MsgQInit(&p_q->MsgQ,                                 /* Initialize the list of OS_MSGs                         */ 
                0u); 
    OS_PendListInit(&p_q->PendList);                        /* Initialize the waiting list                            */ 
} 
 
/*$PAGE*/ 
/* 
************************************************************************************************************************ 
*                                      ADD/REMOVE MESSAGE QUEUE TO/FROM DEBUG LIST 
* 
* Description: These functions are called by uC/OS-III to add or remove a message queue to/from a message queue debug 
*              list. 
* 
* Arguments  : p_q     is a pointer to the message queue to add/remove 
* 
* Returns    : none 
* 
* Note(s)    : These functions are INTERNAL to uC/OS-III and your application should not call it. 
************************************************************************************************************************ 
*/ 
 
 
#if OS_CFG_DBG_EN > 0u 
void  OS_QDbgListAdd (OS_Q  *p_q) 
{ 
    p_q->DbgNamePtr               = (CPU_CHAR *)((void *)" "); 
    p_q->DbgPrevPtr               = (OS_Q     *)0; 
    if (OSQDbgListPtr == (OS_Q *)0) { 
        p_q->DbgNextPtr           = (OS_Q     *)0; 
    } else { 
        p_q->DbgNextPtr           =  OSQDbgListPtr; 
        OSQDbgListPtr->DbgPrevPtr =  p_q; 
    } 
    OSQDbgListPtr                 =  p_q; 
} 
 
 
 
void  OS_QDbgListRemove (OS_Q  *p_q) 
{ 
    OS_Q  *p_q_next; 
    OS_Q  *p_q_prev; 
 
 
    p_q_prev = p_q->DbgPrevPtr; 
    p_q_next = p_q->DbgNextPtr; 
 
    if (p_q_prev == (OS_Q *)0) { 
        OSQDbgListPtr = p_q_next; 
        if (p_q_next != (OS_Q *)0) { 
            p_q_next->DbgPrevPtr = (OS_Q *)0; 
        } 
        p_q->DbgNextPtr = (OS_Q *)0; 
 
    } else if (p_q_next == (OS_Q *)0) { 
        p_q_prev->DbgNextPtr = (OS_Q *)0; 
        p_q->DbgPrevPtr      = (OS_Q *)0; 
 
    } else { 
        p_q_prev->DbgNextPtr =  p_q_next; 
        p_q_next->DbgPrevPtr =  p_q_prev; 
        p_q->DbgNextPtr      = (OS_Q *)0; 
        p_q->DbgPrevPtr      = (OS_Q *)0; 
    } 
} 
#endif 
 
/*$PAGE*/ 
/* 
************************************************************************************************************************ 
*                                              MESSAGE QUEUE INITIALIZATION 
* 
* Description: This function is called by OSInit() to initialize the message queue management. 
* 
 
* Arguments  : p_err         is a pointer to a variable that will receive an error code. 
* 
*                                OS_ERR_NONE     the call was successful 
* 
* Returns    : none 
* 
* Note(s)    : 1) This function is INTERNAL to uC/OS-III and your application MUST NOT call it. 
************************************************************************************************************************ 
*/ 
 
void  OS_QInit (OS_ERR *p_err) 
{ 
#ifdef OS_SAFETY_CRITICAL 
    if (p_err == (OS_ERR *)0) { 
        OS_SAFETY_CRITICAL_EXCEPTION(); 
        return; 
    } 
#endif 
 
#if OS_CFG_DBG_EN > 0u 
    OSQDbgListPtr = (OS_Q *)0; 
#endif 
 
    OSQQty        = (OS_OBJ_QTY)0; 
    *p_err        = OS_ERR_NONE; 
} 
 
/*$PAGE*/ 
/* 
************************************************************************************************************************ 
*                                               POST MESSAGE TO A QUEUE 
* 
* Description: This function sends a message to a queue.  With the 'opt' argument, you can specify whether the message 
*              is broadcast to all waiting tasks and/or whether you post the message to the front of the queue (LIFO) 
*              or normally (FIFO) at the end of the queue. 
* 
* Arguments  : p_q           is a pointer to a message queue that must have been created by OSQCreate(). 
* 
*              p_void        is a pointer to the message to send. 
* 
*              msg_size      specifies the size of the message (in bytes) 
* 
*              opt           determines the type of POST performed: 
* 
*                                OS_OPT_POST_ALL          POST to ALL tasks that are waiting on the queue 
* 
*                                OS_OPT_POST_FIFO         POST as FIFO and wake up single waiting task 
*                                OS_OPT_POST_LIFO         POST as LIFO and wake up single waiting task 
* 
*                                OS_OPT_POST_NO_SCHED     Do not call the scheduler 
* 
*              ts            is the timestamp of the post 
* 
*              p_err         is a pointer to a variable that will contain an error code returned by this function. 
* 
*                                OS_ERR_NONE            The call was successful and the message was sent 
*                                OS_ERR_MSG_POOL_EMPTY  If there are no more OS_MSGs to use to place the message into 
*                                OS_ERR_OBJ_PTR_NULL    If 'p_q' is a NULL pointer 
*                                OS_ERR_OBJ_TYPE        If the message queue was not initialized 
*                                OS_ERR_Q_MAX           If the queue is full 
* 
* Returns    : None 
* 
* Note(s)    : This function is INTERNAL to uC/OS-III and your application should not call it. 
************************************************************************************************************************ 
*/ 
 
void  OS_QPost (OS_Q        *p_q, 
                void        *p_void, 
                OS_MSG_SIZE  msg_size, 
                OS_OPT       opt, 
                CPU_TS       ts, 
                OS_ERR      *p_err) 
{ 
    OS_OBJ_QTY     cnt; 
    OS_OPT         post_type; 
    OS_PEND_LIST  *p_pend_list; 
    OS_PEND_DATA  *p_pend_data; 
    OS_PEND_DATA  *p_pend_data_next; 
    OS_TCB        *p_tcb; 
    CPU_SR_ALLOC(); 
 
 
 
    OS_CRITICAL_ENTER(); 
    p_pend_list = &p_q->PendList; 
    if (p_pend_list->NbrEntries == (OS_OBJ_QTY)0) {         /* Any task waiting on message queue?                     */ 
        if ((opt & OS_OPT_POST_LIFO) == (OS_OPT)0) {        /* Determine whether we post FIFO or LIFO                 */ 
            post_type = OS_OPT_POST_FIFO; 
        } else { 
            post_type = OS_OPT_POST_LIFO; 
        } 
        OS_MsgQPut(&p_q->MsgQ,                              /* Place message in the message queue                     */ 
                   p_void, 
                   msg_size, 
                   post_type, 
                   ts, 
                   p_err); 
        OS_CRITICAL_EXIT(); 
        return; 
    } 
 
    if ((opt & OS_OPT_POST_ALL) != (OS_OPT)0) {             /* Post message to all tasks waiting?                     */ 
        cnt = p_pend_list->NbrEntries;                      /* Yes                                                    */ 
    } else { 
        cnt = (OS_OBJ_QTY)1;                                /* No                                                     */ 
    } 
    p_pend_data = p_pend_list->HeadPtr; 
    while (cnt > 0u) { 
        p_tcb            = p_pend_data->TCBPtr; 
        p_pend_data_next = p_pend_data->NextPtr; 
        OS_Post((OS_PEND_OBJ *)((void *)p_q), 
                p_tcb, 
                p_void, 
                msg_size, 
                ts); 
        p_pend_data = p_pend_data_next; 
        cnt--; 
    } 
    OS_CRITICAL_EXIT_NO_SCHED(); 
    if ((opt & OS_OPT_POST_NO_SCHED) == (OS_OPT)0) { 
        OSSched();                                          /* Run the scheduler                                      */ 
    } 
    *p_err = OS_ERR_NONE; 
} 
 
#endif