queue.h File Reference

#include "mpu_wrappers.h"

Go to the source code of this file.

Defines
#define	queueSEND_TO_BACK   ( 0 )
#define	queueSEND_TO_FRONT   ( 1 )
#define	xQueueAltPeek(xQueue, pvBuffer, xTicksToWait)   xQueueAltGenericReceive( xQueue, pvBuffer, xTicksToWait, pdTRUE )
#define	xQueueAltReceive(xQueue, pvBuffer, xTicksToWait)   xQueueAltGenericReceive( xQueue, pvBuffer, xTicksToWait, pdFALSE )
#define	xQueueAltSendToBack(xQueue, pvItemToQueue, xTicksToWait)   xQueueAltGenericSend( xQueue, pvItemToQueue, xTicksToWait, queueSEND_TO_BACK )
#define	xQueueAltSendToFront(xQueue, pvItemToQueue, xTicksToWait)   xQueueAltGenericSend( xQueue, pvItemToQueue, xTicksToWait, queueSEND_TO_FRONT )
#define	xQueuePeek(xQueue, pvBuffer, xTicksToWait)   xQueueGenericReceive( xQueue, pvBuffer, xTicksToWait, pdTRUE )
#define	xQueueReceive(xQueue, pvBuffer, xTicksToWait)   xQueueGenericReceive( xQueue, pvBuffer, xTicksToWait, pdFALSE )
#define	xQueueSend(xQueue, pvItemToQueue, xTicksToWait)   xQueueGenericSend( xQueue, pvItemToQueue, xTicksToWait, queueSEND_TO_BACK )
#define	xQueueSendFromISR(pxQueue, pvItemToQueue, pxHigherPriorityTaskWoken)   xQueueGenericSendFromISR( pxQueue, pvItemToQueue, pxHigherPriorityTaskWoken, queueSEND_TO_BACK )
#define	xQueueSendToBack(xQueue, pvItemToQueue, xTicksToWait)   xQueueGenericSend( xQueue, pvItemToQueue, xTicksToWait, queueSEND_TO_BACK )
#define	xQueueSendToBackFromISR(pxQueue, pvItemToQueue, pxHigherPriorityTaskWoken)   xQueueGenericSendFromISR( pxQueue, pvItemToQueue, pxHigherPriorityTaskWoken, queueSEND_TO_BACK )
#define	xQueueSendToFront(xQueue, pvItemToQueue, xTicksToWait)   xQueueGenericSend( xQueue, pvItemToQueue, xTicksToWait, queueSEND_TO_FRONT )
#define	xQueueSendToFrontFromISR(pxQueue, pvItemToQueue, pxHigherPriorityTaskWoken)   xQueueGenericSendFromISR( pxQueue, pvItemToQueue, pxHigherPriorityTaskWoken, queueSEND_TO_FRONT )
Typedefs
typedef void *	xQueueHandle
Functions
unsigned portBASE_TYPE	uxQueueMessagesWaiting (const xQueueHandle xQueue)
unsigned portBASE_TYPE	uxQueueMessagesWaitingFromISR (const xQueueHandle pxQueue)
void	vQueueDelete (xQueueHandle xQueue)
signed portBASE_TYPE	xQueueAltGenericReceive (xQueueHandle pxQueue, void *const pvBuffer, portTickType xTicksToWait, portBASE_TYPE xJustPeeking)
signed portBASE_TYPE	xQueueAltGenericSend (xQueueHandle pxQueue, const void *const pvItemToQueue, portTickType xTicksToWait, portBASE_TYPE xCopyPosition)
xQueueHandle	xQueueCreate (unsigned portBASE_TYPE uxQueueLength, unsigned portBASE_TYPE uxItemSize)
xQueueHandle	xQueueCreateCountingSemaphore (unsigned portBASE_TYPE uxCountValue, unsigned portBASE_TYPE uxInitialCount)
xQueueHandle	xQueueCreateMutex (void)
signed portBASE_TYPE	xQueueCRReceive (xQueueHandle pxQueue, void *pvBuffer, portTickType xTicksToWait)
signed portBASE_TYPE	xQueueCRReceiveFromISR (xQueueHandle pxQueue, void *pvBuffer, signed portBASE_TYPE *pxTaskWoken)
signed portBASE_TYPE	xQueueCRSend (xQueueHandle pxQueue, const void *pvItemToQueue, portTickType xTicksToWait)
signed portBASE_TYPE	xQueueCRSendFromISR (xQueueHandle pxQueue, const void *pvItemToQueue, signed portBASE_TYPE xCoRoutinePreviouslyWoken)
signed portBASE_TYPE	xQueueGenericReceive (xQueueHandle xQueue, void *const pvBuffer, portTickType xTicksToWait, portBASE_TYPE xJustPeek)
signed portBASE_TYPE	xQueueGenericSend (xQueueHandle xQueue, const void *const pvItemToQueue, portTickType xTicksToWait, portBASE_TYPE xCopyPosition)
signed portBASE_TYPE	xQueueGenericSendFromISR (xQueueHandle pxQueue, const void *const pvItemToQueue, signed portBASE_TYPE *pxHigherPriorityTaskWoken, portBASE_TYPE xCopyPosition)
portBASE_TYPE	xQueueGiveMutexRecursive (xQueueHandle xMutex)
signed portBASE_TYPE	xQueueIsQueueEmptyFromISR (const xQueueHandle pxQueue)
signed portBASE_TYPE	xQueueIsQueueFullFromISR (const xQueueHandle pxQueue)
signed portBASE_TYPE	xQueueReceiveFromISR (xQueueHandle pxQueue, void *const pvBuffer, signed portBASE_TYPE *pxTaskWoken)
portBASE_TYPE	xQueueTakeMutexRecursive (xQueueHandle xMutex, portTickType xBlockTime)

---

Define Documentation

#define queueSEND_TO_BACK   ( 0 )

Definition at line 76 of file queue.h.

Referenced by prvCopyDataToQueue().

#define queueSEND_TO_FRONT   ( 1 )

Definition at line 77 of file queue.h.

#define xQueueAltPeek	(	xQueue,
		pvBuffer,
		xTicksToWait		)	xQueueAltGenericReceive( xQueue, pvBuffer, xTicksToWait, pdTRUE )

Definition at line 1199 of file queue.h.

Referenced by prvSendFrontAndBackTest().

#define xQueueAltReceive	(	xQueue,
		pvBuffer,
		xTicksToWait		)	xQueueAltGenericReceive( xQueue, pvBuffer, xTicksToWait, pdFALSE )

Definition at line 1198 of file queue.h.

Referenced by portTASK_FUNCTION(), prvSendFrontAndBackTest(), vPrimaryBlockTimeTestTask(), and vSecondaryBlockTimeTestTask().

#define xQueueAltSendToBack	(	xQueue,
		pvItemToQueue,
		xTicksToWait		)	xQueueAltGenericSend( xQueue, pvItemToQueue, xTicksToWait, queueSEND_TO_BACK )

Definition at line 1197 of file queue.h.

Referenced by portTASK_FUNCTION(), prvSendFrontAndBackTest(), vPrimaryBlockTimeTestTask(), and vSecondaryBlockTimeTestTask().

#define xQueueAltSendToFront	(	xQueue,
		pvItemToQueue,
		xTicksToWait		)	xQueueAltGenericSend( xQueue, pvItemToQueue, xTicksToWait, queueSEND_TO_FRONT )

Definition at line 1196 of file queue.h.

Referenced by prvSendFrontAndBackTest().

#define xQueuePeek	(	xQueue,
		pvBuffer,
		xTicksToWait		)	xQueueGenericReceive( xQueue, pvBuffer, xTicksToWait, pdTRUE )

Definition at line 566 of file queue.h.

Referenced by prvHighestPriorityPeekTask(), prvHighPriorityPeekTask(), prvLowPriorityPeekTask(), prvMediumPriorityPeekTask(), and prvSendFrontAndBackTest().

#define xQueueReceive	(	xQueue,
		pvBuffer,
		xTicksToWait		)	xQueueGenericReceive( xQueue, pvBuffer, xTicksToWait, pdFALSE )

Definition at line 659 of file queue.h.

Referenced by portTASK_FUNCTION(), prvHigherPriorityNormallyEmptyTask(), prvHighestPriorityPeekTask(), prvHighPriorityPeekTask(), prvLowerPriorityNormallyEmptyTask(), prvLowerPriorityNormallyFullTask(), prvLowPriorityPeekTask(), prvSendFrontAndBackTest(), vPrimaryBlockTimeTestTask(), vSecondaryBlockTimeTestTask(), and xSerialGetChar().

#define xQueueSend	(	xQueue,
		pvItemToQueue,
		xTicksToWait		)	xQueueGenericSend( xQueue, pvItemToQueue, xTicksToWait, queueSEND_TO_BACK )

Definition at line 384 of file queue.h.

Referenced by portTASK_FUNCTION(), prv1stHigherPriorityNormallyFullTask(), prv2ndHigherPriorityNormallyFullTask(), prvLowerPriorityNormallyEmptyTask(), prvLowerPriorityNormallyFullTask(), prvSendFrontAndBackTest(), vPrimaryBlockTimeTestTask(), vSecondaryBlockTimeTestTask(), vStartHookCoRoutines(), and xSerialPutChar().

#define xQueueSendFromISR	(	pxQueue,
		pvItemToQueue,
		pxHigherPriorityTaskWoken		)	xQueueGenericSendFromISR( pxQueue, pvItemToQueue, pxHigherPriorityTaskWoken, queueSEND_TO_BACK )

Definition at line 1002 of file queue.h.

Referenced by prvUSART_ISR_NonNakedBehaviour().

#define xQueueSendToBack	(	xQueue,
		pvItemToQueue,
		xTicksToWait		)	xQueueGenericSend( xQueue, pvItemToQueue, xTicksToWait, queueSEND_TO_BACK )

Definition at line 300 of file queue.h.

Referenced by prvLowPriorityPeekTask(), and prvSendFrontAndBackTest().

#define xQueueSendToBackFromISR	(	pxQueue,
		pvItemToQueue,
		pxHigherPriorityTaskWoken		)	xQueueGenericSendFromISR( pxQueue, pvItemToQueue, pxHigherPriorityTaskWoken, queueSEND_TO_BACK )

Definition at line 928 of file queue.h.

#define xQueueSendToFront	(	xQueue,
		pvItemToQueue,
		xTicksToWait		)	xQueueGenericSend( xQueue, pvItemToQueue, xTicksToWait, queueSEND_TO_FRONT )

Definition at line 218 of file queue.h.

Referenced by prvLowPriorityPeekTask(), and prvSendFrontAndBackTest().

#define xQueueSendToFrontFromISR	(	pxQueue,
		pvItemToQueue,
		pxHigherPriorityTaskWoken		)	xQueueGenericSendFromISR( pxQueue, pvItemToQueue, pxHigherPriorityTaskWoken, queueSEND_TO_FRONT )

Definition at line 857 of file queue.h.

---

Typedef Documentation

typedef void* xQueueHandle

Definition at line 72 of file queue.h.

---

Function Documentation

unsigned portBASE_TYPE uxQueueMessagesWaiting

(

const xQueueHandle

xQueue

)

Definition at line 1019 of file queue.c.

References taskENTER_CRITICAL, and taskEXIT_CRITICAL.

Referenced by portTASK_FUNCTION(), prvHighestPriorityPeekTask(), prvHighPriorityPeekTask(), prvLowPriorityPeekTask(), prvMediumPriorityPeekTask(), and prvSendFrontAndBackTest().

{
unsigned portBASE_TYPE uxReturn;

    taskENTER_CRITICAL();
        uxReturn = pxQueue->uxMessagesWaiting;
    taskEXIT_CRITICAL();

    return uxReturn;
}
/*-----------------------------------------------------------*/

unsigned portBASE_TYPE uxQueueMessagesWaitingFromISR

(

const xQueueHandle

pxQueue

)

Definition at line 1031 of file queue.c.

{
unsigned portBASE_TYPE uxReturn;

    uxReturn = pxQueue->uxMessagesWaiting;

    return uxReturn;
}
/*-----------------------------------------------------------*/

void vQueueDelete

(

xQueueHandle

xQueue

)

Definition at line 1041 of file queue.c.

References traceQUEUE_DELETE, vPortFree(), and vQueueUnregisterQueue.

{
    traceQUEUE_DELETE( pxQueue );
    vQueueUnregisterQueue( pxQueue );
    vPortFree( pxQueue->pcHead );
    vPortFree( pxQueue );
}
/*-----------------------------------------------------------*/

signed portBASE_TYPE xQueueAltGenericReceive	(	xQueueHandle	pxQueue,
		void *const	pvBuffer,
		portTickType	xTicksToWait,
		portBASE_TYPE	xJustPeeking
	)

signed portBASE_TYPE xQueueAltGenericSend	(	xQueueHandle	pxQueue,
		const void *const	pvItemToQueue,
		portTickType	xTicksToWait,
		portBASE_TYPE	xCopyPosition
	)

xQueueHandle xQueueCreate	(	unsigned portBASE_TYPE	uxQueueLength,
		unsigned portBASE_TYPE	uxItemSize
	)

Referenced by vCreateAltBlockTimeTasks(), vCreateBlockTimeTasks(), vprvSerialCreateQueues(), vStartAltBlockingQueueTasks(), vStartAltGenericQueueTasks(), vStartAltPolledQueueTasks(), vStartBlockingQueueTasks(), vStartDynamicPriorityTasks(), vStartFlashCoRoutines(), vStartGenericQueueTasks(), vStartHookCoRoutines(), vStartInterruptQueueTasks(), vStartPolledQueueTasks(), and vStartQueuePeekTasks().

xQueueHandle xQueueCreateCountingSemaphore	(	unsigned portBASE_TYPE	uxCountValue,
		unsigned portBASE_TYPE	uxInitialCount
	)

xQueueHandle xQueueCreateMutex

(

void

)

Definition at line 138 of file queue.c.

    {
        signed char *pcQueueName;
        xQueueHandle xHandle;
    } xQueueRegistryItem;

    /* The queue registry is simply an array of xQueueRegistryItem structures.
    The pcQueueName member of a structure being NULL is indicative of the
    array position being vacant. */
    xQueueRegistryItem xQueueRegistry[ configQUEUE_REGISTRY_SIZE ];

    /* Removes a queue from the registry by simply setting the pcQueueName
    member to NULL. */
    static void vQueueUnregisterQueue( xQueueHandle xQueue ) PRIVILEGED_FUNCTION;
    void vQueueAddToRegistry( xQueueHandle xQueue, signed char *pcQueueName ) PRIVILEGED_FUNCTION;
#endif

/*
 * Unlocks a queue locked by a call to prvLockQueue.  Locking a queue does not
 * prevent an ISR from adding or removing items to the queue, but does prevent
 * an ISR from removing tasks from the queue event lists.  If an ISR finds a
 * queue is locked it will instead increment the appropriate queue lock count
 * to indicate that a task may require unblocking.  When the queue in unlocked
 * these lock counts are inspected, and the appropriate action taken.
 */
static void prvUnlockQueue( xQueueHandle pxQueue ) PRIVILEGED_FUNCTION;

/*
 * Uses a critical section to determine if there is any data in a queue.
 *
 * @return pdTRUE if the queue contains no items, otherwise pdFALSE.
 */
static signed portBASE_TYPE prvIsQueueEmpty( const xQueueHandle pxQueue ) PRIVILEGED_FUNCTION;

/*
 * Uses a critical section to determine if there is any space in a queue.
 *
 * @return pdTRUE if there is no space, otherwise pdFALSE;
 */
static signed portBASE_TYPE prvIsQueueFull( const xQueueHandle pxQueue ) PRIVILEGED_FUNCTION;

/*
 * Copies an item into the queue, either at the front of the queue or the
 * back of the queue.
 */
static void prvCopyDataToQueue( xQUEUE *pxQueue, const void *pvItemToQueue, portBASE_TYPE xPosition ) PRIVILEGED_FUNCTION;

/*
 * Copies an item out of a queue.
 */
static void prvCopyDataFromQueue( xQUEUE * const pxQueue, const void *pvBuffer ) PRIVILEGED_FUNCTION;
/*-----------------------------------------------------------*/

/*
 * Macro to mark a queue as locked.  Locking a queue prevents an ISR from
 * accessing the queue event lists.
 */
#define prvLockQueue( pxQueue )                         \
{                                                       \
    taskENTER_CRITICAL();                               \
    {                                                   \
        if( pxQueue->xRxLock == queueUNLOCKED )         \
        {                                               \
            pxQueue->xRxLock = queueLOCKED_UNMODIFIED;  \
        }                                               \
        if( pxQueue->xTxLock == queueUNLOCKED )         \
        {                                               \
            pxQueue->xTxLock = queueLOCKED_UNMODIFIED;  \
        }                                               \
    }                                                   \
    taskEXIT_CRITICAL();                                \
}
/*-----------------------------------------------------------*/


/*-----------------------------------------------------------
 * PUBLIC QUEUE MANAGEMENT API documented in queue.h
 *----------------------------------------------------------*/

xQueueHandle xQueueCreate( unsigned portBASE_TYPE uxQueueLength, unsigned portBASE_TYPE uxItemSize )
{
xQUEUE *pxNewQueue;
size_t xQueueSizeInBytes;

    /* Allocate the new queue structure. */
    if( uxQueueLength > ( unsigned portBASE_TYPE ) 0 )
    {
        pxNewQueue = ( xQUEUE * ) pvPortMalloc( sizeof( xQUEUE ) );
        if( pxNewQueue != NULL )
        {
            /* Create the list of pointers to queue items.  The queue is one byte
            longer than asked for to make wrap checking easier/faster. */
            xQueueSizeInBytes = ( size_t ) ( uxQueueLength * uxItemSize ) + ( size_t ) 1;

            pxNewQueue->pcHead = ( signed char * ) pvPortMalloc( xQueueSizeInBytes );
            if( pxNewQueue->pcHead != NULL )
            {
                /* Initialise the queue members as described above where the
                queue type is defined. */
                pxNewQueue->pcTail = pxNewQueue->pcHead + ( uxQueueLength * uxItemSize );
                pxNewQueue->uxMessagesWaiting = 0;
                pxNewQueue->pcWriteTo = pxNewQueue->pcHead;
                pxNewQueue->pcReadFrom = pxNewQueue->pcHead + ( ( uxQueueLength - 1 ) * uxItemSize );
                pxNewQueue->uxLength = uxQueueLength;
                pxNewQueue->uxItemSize = uxItemSize;
                pxNewQueue->xRxLock = queueUNLOCKED;
                pxNewQueue->xTxLock = queueUNLOCKED;

                /* Likewise ensure the event queues start with the correct state. */
                vListInitialise( &( pxNewQueue->xTasksWaitingToSend ) );
                vListInitialise( &( pxNewQueue->xTasksWaitingToReceive ) );

                traceQUEUE_CREATE( pxNewQueue );
                return  pxNewQueue;
            }
            else
            {
                traceQUEUE_CREATE_FAILED();
                vPortFree( pxNewQueue );
            }
        }
    }

    /* Will only reach here if we could not allocate enough memory or no memory
    was required. */
    return NULL;
}

signed portBASE_TYPE xQueueCRReceive	(	xQueueHandle	pxQueue,
		void *	pvBuffer,
		portTickType	xTicksToWait
	)

signed portBASE_TYPE xQueueCRReceiveFromISR	(	xQueueHandle	pxQueue,
		void *	pvBuffer,
		signed portBASE_TYPE *	pxTaskWoken
	)

signed portBASE_TYPE xQueueCRSend	(	xQueueHandle	pxQueue,
		const void *	pvItemToQueue,
		portTickType	xTicksToWait
	)

signed portBASE_TYPE xQueueCRSendFromISR	(	xQueueHandle	pxQueue,
		const void *	pvItemToQueue,
		signed portBASE_TYPE	xCoRoutinePreviouslyWoken
	)

signed portBASE_TYPE xQueueGenericReceive	(	xQueueHandle	xQueue,
		void *const	pvBuffer,
		portTickType	xTicksToWait,
		portBASE_TYPE	xJustPeek
	)

Definition at line 821 of file queue.c.

References errQUEUE_EMPTY, listLIST_IS_EMPTY, pdFALSE, pdPASS, pdTRUE, portENTER_CRITICAL, portEXIT_CRITICAL, portYIELD_WITHIN_API, prvCopyDataFromQueue(), prvIsQueueEmpty(), prvLockQueue, prvUnlockQueue(), queueQUEUE_IS_MUTEX, taskENTER_CRITICAL, taskEXIT_CRITICAL, traceBLOCKING_ON_QUEUE_RECEIVE, traceQUEUE_PEEK, traceQUEUE_RECEIVE, traceQUEUE_RECEIVE_FAILED, vTaskPlaceOnEventList(), vTaskPriorityInherit(), vTaskSetTimeOutState(), vTaskSuspendAll(), xTaskCheckForTimeOut(), xTaskGetCurrentTaskHandle(), xTaskRemoveFromEventList(), and xTaskResumeAll().

{
signed portBASE_TYPE xEntryTimeSet = pdFALSE;
xTimeOutType xTimeOut;
signed char *pcOriginalReadPosition;

    /* This function relaxes the coding standard somewhat to allow return
    statements within the function itself.  This is done in the interest
    of execution time efficiency. */

    for( ;; )
    {
        taskENTER_CRITICAL();
        {
            /* Is there data in the queue now?  To be running we must be
            the highest priority task wanting to access the queue. */
            if( pxQueue->uxMessagesWaiting > ( unsigned portBASE_TYPE ) 0 )
            {
                /* Remember our read position in case we are just peeking. */
                pcOriginalReadPosition = pxQueue->pcReadFrom;

                prvCopyDataFromQueue( pxQueue, pvBuffer );

                if( xJustPeeking == pdFALSE )
                {
                    traceQUEUE_RECEIVE( pxQueue );

                    /* We are actually removing data. */
                    --( pxQueue->uxMessagesWaiting );

                    #if ( configUSE_MUTEXES == 1 )
                    {
                        if( pxQueue->uxQueueType == queueQUEUE_IS_MUTEX )
                        {
                            /* Record the information required to implement
                            priority inheritance should it become necessary. */
                            pxQueue->pxMutexHolder = xTaskGetCurrentTaskHandle();
                        }
                    }
                    #endif

                    if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) == pdFALSE )
                    {
                        if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) == pdTRUE )
                        {
                            portYIELD_WITHIN_API();
                        }
                    }
                }
                else
                {
                    traceQUEUE_PEEK( pxQueue );

                    /* We are not removing the data, so reset our read
                    pointer. */
                    pxQueue->pcReadFrom = pcOriginalReadPosition;

                    /* The data is being left in the queue, so see if there are
                    any other tasks waiting for the data. */
                    if( !listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) )
                    {
                        /* Tasks that are removed from the event list will get added to
                        the pending ready list as the scheduler is still suspended. */
                        if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )
                        {
                            /* The task waiting has a higher priority than this task. */
                            portYIELD_WITHIN_API();
                        }
                    }

                }

                taskEXIT_CRITICAL();
                return pdPASS;
            }
            else
            {
                if( xTicksToWait == ( portTickType ) 0 )
                {
                    /* The queue was empty and no block time is specified (or
                    the block time has expired) so leave now. */
                    taskEXIT_CRITICAL();
                    traceQUEUE_RECEIVE_FAILED( pxQueue );
                    return errQUEUE_EMPTY;
                }
                else if( xEntryTimeSet == pdFALSE )
                {
                    /* The queue was empty and a block time was specified so
                    configure the timeout structure. */
                    vTaskSetTimeOutState( &xTimeOut );
                    xEntryTimeSet = pdTRUE;
                }
            }
        }
        taskEXIT_CRITICAL();

        /* Interrupts and other tasks can send to and receive from the queue
        now the critical section has been exited. */

        vTaskSuspendAll();
        prvLockQueue( pxQueue );

        /* Update the timeout state to see if it has expired yet. */
        if( xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) == pdFALSE )
        {
            if( prvIsQueueEmpty( pxQueue ) )
            {
                traceBLOCKING_ON_QUEUE_RECEIVE( pxQueue );

                #if ( configUSE_MUTEXES == 1 )
                {
                    if( pxQueue->uxQueueType == queueQUEUE_IS_MUTEX )
                    {
                        portENTER_CRITICAL();
                        {
                            vTaskPriorityInherit( ( void * ) pxQueue->pxMutexHolder );
                        }
                        portEXIT_CRITICAL();
                    }
                }
                #endif

                vTaskPlaceOnEventList( &( pxQueue->xTasksWaitingToReceive ), xTicksToWait );
                prvUnlockQueue( pxQueue );
                if( !xTaskResumeAll() )
                {
                    portYIELD_WITHIN_API();
                }
            }
            else
            {
                /* Try again. */
                prvUnlockQueue( pxQueue );
                ( void ) xTaskResumeAll();
            }
        }
        else
        {
            prvUnlockQueue( pxQueue );
            ( void ) xTaskResumeAll();
            traceQUEUE_RECEIVE_FAILED( pxQueue );
            return errQUEUE_EMPTY;
        }
    }
}
/*-----------------------------------------------------------*/

signed portBASE_TYPE xQueueGenericSend	(	xQueueHandle	xQueue,
		const void *const	pvItemToQueue,
		portTickType	xTicksToWait,
		portBASE_TYPE	xCopyPosition
	)

Definition at line 452 of file queue.c.

References errQUEUE_FULL, listLIST_IS_EMPTY, pdFALSE, pdPASS, pdTRUE, portYIELD_WITHIN_API, prvCopyDataToQueue(), prvIsQueueFull(), prvLockQueue, prvUnlockQueue(), taskENTER_CRITICAL, taskEXIT_CRITICAL, traceBLOCKING_ON_QUEUE_SEND, traceQUEUE_SEND, traceQUEUE_SEND_FAILED, vTaskPlaceOnEventList(), vTaskSetTimeOutState(), vTaskSuspendAll(), xTaskCheckForTimeOut(), xTaskRemoveFromEventList(), and xTaskResumeAll().

{
signed portBASE_TYPE xEntryTimeSet = pdFALSE;
xTimeOutType xTimeOut;

    /* This function relaxes the coding standard somewhat to allow return
    statements within the function itself.  This is done in the interest
    of execution time efficiency. */
    for( ;; )
    {
        taskENTER_CRITICAL();
        {
            /* Is there room on the queue now?  To be running we must be
            the highest priority task wanting to access the queue. */
            if( pxQueue->uxMessagesWaiting < pxQueue->uxLength )
            {
                traceQUEUE_SEND( pxQueue );
                prvCopyDataToQueue( pxQueue, pvItemToQueue, xCopyPosition );

                /* If there was a task waiting for data to arrive on the
                queue then unblock it now. */
                if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
                {
                    if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) == pdTRUE )
                    {
                        /* The unblocked task has a priority higher than
                        our own so yield immediately.  Yes it is ok to do
                        this from within the critical section - the kernel
                        takes care of that. */
                        portYIELD_WITHIN_API();
                    }
                }

                taskEXIT_CRITICAL();

                /* Return to the original privilege level before exiting the
                function. */
                return pdPASS;
            }
            else
            {
                if( xTicksToWait == ( portTickType ) 0 )
                {
                    /* The queue was full and no block time is specified (or
                    the block time has expired) so leave now. */
                    taskEXIT_CRITICAL();

                    /* Return to the original privilege level before exiting
                    the function. */
                    traceQUEUE_SEND_FAILED( pxQueue );
                    return errQUEUE_FULL;
                }
                else if( xEntryTimeSet == pdFALSE )
                {
                    /* The queue was full and a block time was specified so
                    configure the timeout structure. */
                    vTaskSetTimeOutState( &xTimeOut );
                    xEntryTimeSet = pdTRUE;
                }
            }
        }
        taskEXIT_CRITICAL();

        /* Interrupts and other tasks can send to and receive from the queue
        now the critical section has been exited. */

        vTaskSuspendAll();
        prvLockQueue( pxQueue );

        /* Update the timeout state to see if it has expired yet. */
        if( xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) == pdFALSE )
        {
            if( prvIsQueueFull( pxQueue ) )
            {
                traceBLOCKING_ON_QUEUE_SEND( pxQueue );
                vTaskPlaceOnEventList( &( pxQueue->xTasksWaitingToSend ), xTicksToWait );

                /* Unlocking the queue means queue events can effect the
                event list.  It is possible that interrupts occurring now
                remove this task from the event list again - but as the
                scheduler is suspended the task will go onto the pending
                ready last instead of the actual ready list. */
                prvUnlockQueue( pxQueue );

                /* Resuming the scheduler will move tasks from the pending
                ready list into the ready list - so it is feasible that this
                task is already in a ready list before it yields - in which
                case the yield will not cause a context switch unless there
                is also a higher priority task in the pending ready list. */
                if( !xTaskResumeAll() )
                {
                    portYIELD_WITHIN_API();
                }
            }
            else
            {
                /* Try again. */
                prvUnlockQueue( pxQueue );
                ( void ) xTaskResumeAll();
            }
        }
        else
        {
            /* The timeout has expired. */
            prvUnlockQueue( pxQueue );
            ( void ) xTaskResumeAll();

            /* Return to the original privilege level before exiting the
            function. */
            traceQUEUE_SEND_FAILED( pxQueue );
            return errQUEUE_FULL;
        }
    }
}
/*-----------------------------------------------------------*/

signed portBASE_TYPE xQueueGenericSendFromISR	(	xQueueHandle	pxQueue,
		const void *const	pvItemToQueue,
		signed portBASE_TYPE *	pxHigherPriorityTaskWoken,
		portBASE_TYPE	xCopyPosition
	)

Definition at line 768 of file queue.c.

References errQUEUE_FULL, listLIST_IS_EMPTY, pdFALSE, pdPASS, pdTRUE, portCLEAR_INTERRUPT_MASK_FROM_ISR, portSET_INTERRUPT_MASK_FROM_ISR, prvCopyDataToQueue(), queueUNLOCKED, traceQUEUE_SEND_FROM_ISR, traceQUEUE_SEND_FROM_ISR_FAILED, and xTaskRemoveFromEventList().

{
signed portBASE_TYPE xReturn;
unsigned portBASE_TYPE uxSavedInterruptStatus;

    /* Similar to xQueueGenericSend, except we don't block if there is no room
    in the queue.  Also we don't directly wake a task that was blocked on a
    queue read, instead we return a flag to say whether a context switch is
    required or not (i.e. has a task with a higher priority than us been woken
    by this post). */
    uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
    {
        if( pxQueue->uxMessagesWaiting < pxQueue->uxLength )
        {
            traceQUEUE_SEND_FROM_ISR( pxQueue );

            prvCopyDataToQueue( pxQueue, pvItemToQueue, xCopyPosition );

            /* If the queue is locked we do not alter the event list.  This will
            be done when the queue is unlocked later. */
            if( pxQueue->xTxLock == queueUNLOCKED )
            {
                if( !listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) )
                {
                    if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )
                    {
                        /* The task waiting has a higher priority so record that a
                        context switch is required. */
                        *pxHigherPriorityTaskWoken = pdTRUE;
                    }
                }
            }
            else
            {
                /* Increment the lock count so the task that unlocks the queue
                knows that data was posted while it was locked. */
                ++( pxQueue->xTxLock );
            }

            xReturn = pdPASS;
        }
        else
        {
            traceQUEUE_SEND_FROM_ISR_FAILED( pxQueue );
            xReturn = errQUEUE_FULL;
        }
    }
    portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );

    return xReturn;
}
/*-----------------------------------------------------------*/

portBASE_TYPE xQueueGiveMutexRecursive

(

xQueueHandle

xMutex

)

signed portBASE_TYPE xQueueIsQueueEmptyFromISR

(

const xQueueHandle

pxQueue

)

Definition at line 1178 of file queue.c.

{
signed portBASE_TYPE xReturn;

    xReturn = ( pxQueue->uxMessagesWaiting == ( unsigned portBASE_TYPE ) 0 );

    return xReturn;
}
/*-----------------------------------------------------------*/

signed portBASE_TYPE xQueueIsQueueFullFromISR

(

const xQueueHandle

pxQueue

)

Definition at line 1200 of file queue.c.

{
signed portBASE_TYPE xReturn;

    xReturn = ( pxQueue->uxMessagesWaiting == pxQueue->uxLength );

    return xReturn;
}
/*-----------------------------------------------------------*/

signed portBASE_TYPE xQueueReceiveFromISR	(	xQueueHandle	pxQueue,
		void *const	pvBuffer,
		signed portBASE_TYPE *	pxTaskWoken
	)

Definition at line 968 of file queue.c.

References listLIST_IS_EMPTY, pdFAIL, pdFALSE, pdPASS, pdTRUE, portCLEAR_INTERRUPT_MASK_FROM_ISR, portSET_INTERRUPT_MASK_FROM_ISR, prvCopyDataFromQueue(), queueUNLOCKED, traceQUEUE_RECEIVE_FROM_ISR, traceQUEUE_RECEIVE_FROM_ISR_FAILED, and xTaskRemoveFromEventList().

Referenced by prvUSART_ISR_NonNakedBehaviour().

{
signed portBASE_TYPE xReturn;
unsigned portBASE_TYPE uxSavedInterruptStatus;

    uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
    {
        /* We cannot block from an ISR, so check there is data available. */
        if( pxQueue->uxMessagesWaiting > ( unsigned portBASE_TYPE ) 0 )
        {
            traceQUEUE_RECEIVE_FROM_ISR( pxQueue );

            prvCopyDataFromQueue( pxQueue, pvBuffer );
            --( pxQueue->uxMessagesWaiting );

            /* If the queue is locked we will not modify the event list.  Instead
            we update the lock count so the task that unlocks the queue will know
            that an ISR has removed data while the queue was locked. */
            if( pxQueue->xRxLock == queueUNLOCKED )
            {
                if( !listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) )
                {
                    if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) != pdFALSE )
                    {
                        /* The task waiting has a higher priority than us so
                        force a context switch. */
                        *pxTaskWoken = pdTRUE;
                    }
                }
            }
            else
            {
                /* Increment the lock count so the task that unlocks the queue
                knows that data was removed while it was locked. */
                ++( pxQueue->xRxLock );
            }

            xReturn = pdPASS;
        }
        else
        {
            xReturn = pdFAIL;
            traceQUEUE_RECEIVE_FROM_ISR_FAILED( pxQueue );
        }
    }
    portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );

    return xReturn;
}
/*-----------------------------------------------------------*/

portBASE_TYPE xQueueTakeMutexRecursive	(	xQueueHandle	xMutex,
		portTickType	xBlockTime
	)