2 FreeRTOS V8.2.3 - Copyright (C) 2015 Real Time Engineers Ltd.
\r
5 VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
\r
7 This file is part of the FreeRTOS distribution.
\r
9 FreeRTOS is free software; you can redistribute it and/or modify it under
\r
10 the terms of the GNU General Public License (version 2) as published by the
\r
11 Free Software Foundation >>>> AND MODIFIED BY <<<< the FreeRTOS exception.
\r
13 ***************************************************************************
\r
14 >>! NOTE: The modification to the GPL is included to allow you to !<<
\r
15 >>! distribute a combined work that includes FreeRTOS without being !<<
\r
16 >>! obliged to provide the source code for proprietary components !<<
\r
17 >>! outside of the FreeRTOS kernel. !<<
\r
18 ***************************************************************************
\r
20 FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY
\r
21 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
\r
22 FOR A PARTICULAR PURPOSE. Full license text is available on the following
\r
23 link: http://www.freertos.org/a00114.html
\r
25 ***************************************************************************
\r
27 * FreeRTOS provides completely free yet professionally developed, *
\r
28 * robust, strictly quality controlled, supported, and cross *
\r
29 * platform software that is more than just the market leader, it *
\r
30 * is the industry's de facto standard. *
\r
32 * Help yourself get started quickly while simultaneously helping *
\r
33 * to support the FreeRTOS project by purchasing a FreeRTOS *
\r
34 * tutorial book, reference manual, or both: *
\r
35 * http://www.FreeRTOS.org/Documentation *
\r
37 ***************************************************************************
\r
39 http://www.FreeRTOS.org/FAQHelp.html - Having a problem? Start by reading
\r
40 the FAQ page "My application does not run, what could be wrong?". Have you
\r
41 defined configASSERT()?
\r
43 http://www.FreeRTOS.org/support - In return for receiving this top quality
\r
44 embedded software for free we request you assist our global community by
\r
45 participating in the support forum.
\r
47 http://www.FreeRTOS.org/training - Investing in training allows your team to
\r
48 be as productive as possible as early as possible. Now you can receive
\r
49 FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers
\r
50 Ltd, and the world's leading authority on the world's leading RTOS.
\r
52 http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,
\r
53 including FreeRTOS+Trace - an indispensable productivity tool, a DOS
\r
54 compatible FAT file system, and our tiny thread aware UDP/IP stack.
\r
56 http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.
\r
57 Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.
\r
59 http://www.OpenRTOS.com - Real Time Engineers ltd. license FreeRTOS to High
\r
60 Integrity Systems ltd. to sell under the OpenRTOS brand. Low cost OpenRTOS
\r
61 licenses offer ticketed support, indemnification and commercial middleware.
\r
63 http://www.SafeRTOS.com - High Integrity Systems also provide a safety
\r
64 engineered and independently SIL3 certified version for use in safety and
\r
65 mission critical applications that require provable dependability.
\r
73 /* Defining MPU_WRAPPERS_INCLUDED_FROM_API_FILE prevents task.h from redefining
\r
74 all the API functions to use the MPU wrappers. That should only be done when
\r
75 task.h is included from an application file. */
\r
76 #define MPU_WRAPPERS_INCLUDED_FROM_API_FILE
\r
78 #include "FreeRTOS.h"
\r
82 #if ( configUSE_CO_ROUTINES == 1 )
\r
83 #include "croutine.h"
\r
86 /* Lint e961 and e750 are suppressed as a MISRA exception justified because the
\r
87 MPU ports require MPU_WRAPPERS_INCLUDED_FROM_API_FILE to be defined for the
\r
88 header files above, but not in this file, in order to generate the correct
\r
89 privileged Vs unprivileged linkage and placement. */
\r
90 #undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE /*lint !e961 !e750. */
\r
93 /* Constants used with the xRxLock and xTxLock structure members. */
\r
94 #define queueUNLOCKED ( ( BaseType_t ) -1 )
\r
95 #define queueLOCKED_UNMODIFIED ( ( BaseType_t ) 0 )
\r
97 /* When the Queue_t structure is used to represent a base queue its pcHead and
\r
98 pcTail members are used as pointers into the queue storage area. When the
\r
99 Queue_t structure is used to represent a mutex pcHead and pcTail pointers are
\r
100 not necessary, and the pcHead pointer is set to NULL to indicate that the
\r
101 pcTail pointer actually points to the mutex holder (if any). Map alternative
\r
102 names to the pcHead and pcTail structure members to ensure the readability of
\r
103 the code is maintained despite this dual use of two structure members. An
\r
104 alternative implementation would be to use a union, but use of a union is
\r
105 against the coding standard (although an exception to the standard has been
\r
106 permitted where the dual use also significantly changes the type of the
\r
107 structure member). */
\r
108 #define pxMutexHolder pcTail
\r
109 #define uxQueueType pcHead
\r
110 #define queueQUEUE_IS_MUTEX NULL
\r
112 /* Semaphores do not actually store or copy data, so have an item size of
\r
114 #define queueSEMAPHORE_QUEUE_ITEM_LENGTH ( ( UBaseType_t ) 0 )
\r
115 #define queueMUTEX_GIVE_BLOCK_TIME ( ( TickType_t ) 0U )
\r
117 /* Bits that can be set in xQUEUE->ucStaticAllocationFlags to indicate that the
\r
118 queue storage area and queue structure were statically allocated respectively.
\r
119 When these are statically allocated they won't be freed if the queue gets
\r
121 #define queueSTATICALLY_ALLOCATED_STORAGE ( ( uint8_t ) 0x01 )
\r
122 #define queueSTATICALLY_ALLOCATED_QUEUE_STRUCT ( ( uint8_t ) 0x02 )
\r
124 #if( configUSE_PREEMPTION == 0 )
\r
125 /* If the cooperative scheduler is being used then a yield should not be
\r
126 performed just because a higher priority task has been woken. */
\r
127 #define queueYIELD_IF_USING_PREEMPTION()
\r
129 #define queueYIELD_IF_USING_PREEMPTION() portYIELD_WITHIN_API()
\r
133 * Definition of the queue used by the scheduler.
\r
134 * Items are queued by copy, not reference. See the following link for the
\r
135 * rationale: http://www.freertos.org/Embedded-RTOS-Queues.html
\r
137 typedef struct QueueDefinition
\r
139 int8_t *pcHead; /*< Points to the beginning of the queue storage area. */
\r
140 int8_t *pcTail; /*< Points to the byte at the end of the queue storage area. Once more byte is allocated than necessary to store the queue items, this is used as a marker. */
\r
141 int8_t *pcWriteTo; /*< Points to the free next place in the storage area. */
\r
143 union /* Use of a union is an exception to the coding standard to ensure two mutually exclusive structure members don't appear simultaneously (wasting RAM). */
\r
145 int8_t *pcReadFrom; /*< Points to the last place that a queued item was read from when the structure is used as a queue. */
\r
146 UBaseType_t uxRecursiveCallCount;/*< Maintains a count of the number of times a recursive mutex has been recursively 'taken' when the structure is used as a mutex. */
\r
149 List_t xTasksWaitingToSend; /*< List of tasks that are blocked waiting to post onto this queue. Stored in priority order. */
\r
150 List_t xTasksWaitingToReceive; /*< List of tasks that are blocked waiting to read from this queue. Stored in priority order. */
\r
152 volatile UBaseType_t uxMessagesWaiting;/*< The number of items currently in the queue. */
\r
153 UBaseType_t uxLength; /*< The length of the queue defined as the number of items it will hold, not the number of bytes. */
\r
154 UBaseType_t uxItemSize; /*< The size of each items that the queue will hold. */
\r
156 volatile BaseType_t xRxLock; /*< Stores the number of items received from the queue (removed from the queue) while the queue was locked. Set to queueUNLOCKED when the queue is not locked. */
\r
157 volatile BaseType_t xTxLock; /*< Stores the number of items transmitted to the queue (added to the queue) while the queue was locked. Set to queueUNLOCKED when the queue is not locked. */
\r
159 #if ( configUSE_QUEUE_SETS == 1 )
\r
160 struct QueueDefinition *pxQueueSetContainer;
\r
163 #if ( configUSE_TRACE_FACILITY == 1 )
\r
164 UBaseType_t uxQueueNumber;
\r
165 uint8_t ucQueueType;
\r
168 #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
\r
169 uint8_t ucStaticAllocationFlags;
\r
174 /* The old xQUEUE name is maintained above then typedefed to the new Queue_t
\r
175 name below to enable the use of older kernel aware debuggers. */
\r
176 typedef xQUEUE Queue_t;
\r
178 /*-----------------------------------------------------------*/
\r
181 * The queue registry is just a means for kernel aware debuggers to locate
\r
182 * queue structures. It has no other purpose so is an optional component.
\r
184 #if ( configQUEUE_REGISTRY_SIZE > 0 )
\r
186 /* The type stored within the queue registry array. This allows a name
\r
187 to be assigned to each queue making kernel aware debugging a little
\r
188 more user friendly. */
\r
189 typedef struct QUEUE_REGISTRY_ITEM
\r
191 const char *pcQueueName; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
\r
192 QueueHandle_t xHandle;
\r
193 } xQueueRegistryItem;
\r
195 /* The old xQueueRegistryItem name is maintained above then typedefed to the
\r
196 new xQueueRegistryItem name below to enable the use of older kernel aware
\r
198 typedef xQueueRegistryItem QueueRegistryItem_t;
\r
200 /* The queue registry is simply an array of QueueRegistryItem_t structures.
\r
201 The pcQueueName member of a structure being NULL is indicative of the
\r
202 array position being vacant. */
\r
203 PRIVILEGED_DATA QueueRegistryItem_t xQueueRegistry[ configQUEUE_REGISTRY_SIZE ];
\r
205 #endif /* configQUEUE_REGISTRY_SIZE */
\r
208 * Unlocks a queue locked by a call to prvLockQueue. Locking a queue does not
\r
209 * prevent an ISR from adding or removing items to the queue, but does prevent
\r
210 * an ISR from removing tasks from the queue event lists. If an ISR finds a
\r
211 * queue is locked it will instead increment the appropriate queue lock count
\r
212 * to indicate that a task may require unblocking. When the queue in unlocked
\r
213 * these lock counts are inspected, and the appropriate action taken.
\r
215 static void prvUnlockQueue( Queue_t * const pxQueue ) PRIVILEGED_FUNCTION;
\r
218 * Uses a critical section to determine if there is any data in a queue.
\r
220 * @return pdTRUE if the queue contains no items, otherwise pdFALSE.
\r
222 static BaseType_t prvIsQueueEmpty( const Queue_t *pxQueue ) PRIVILEGED_FUNCTION;
\r
225 * Uses a critical section to determine if there is any space in a queue.
\r
227 * @return pdTRUE if there is no space, otherwise pdFALSE;
\r
229 static BaseType_t prvIsQueueFull( const Queue_t *pxQueue ) PRIVILEGED_FUNCTION;
\r
232 * Copies an item into the queue, either at the front of the queue or the
\r
233 * back of the queue.
\r
235 static BaseType_t prvCopyDataToQueue( Queue_t * const pxQueue, const void *pvItemToQueue, const BaseType_t xPosition ) PRIVILEGED_FUNCTION;
\r
238 * Copies an item out of a queue.
\r
240 static void prvCopyDataFromQueue( Queue_t * const pxQueue, void * const pvBuffer ) PRIVILEGED_FUNCTION;
\r
242 #if ( configUSE_QUEUE_SETS == 1 )
\r
244 * Checks to see if a queue is a member of a queue set, and if so, notifies
\r
245 * the queue set that the queue contains data.
\r
247 static BaseType_t prvNotifyQueueSetContainer( const Queue_t * const pxQueue, const BaseType_t xCopyPosition ) PRIVILEGED_FUNCTION;
\r
250 /*-----------------------------------------------------------*/
\r
253 * Macro to mark a queue as locked. Locking a queue prevents an ISR from
\r
254 * accessing the queue event lists.
\r
256 #define prvLockQueue( pxQueue ) \
\r
257 taskENTER_CRITICAL(); \
\r
259 if( ( pxQueue )->xRxLock == queueUNLOCKED ) \
\r
261 ( pxQueue )->xRxLock = queueLOCKED_UNMODIFIED; \
\r
263 if( ( pxQueue )->xTxLock == queueUNLOCKED ) \
\r
265 ( pxQueue )->xTxLock = queueLOCKED_UNMODIFIED; \
\r
268 taskEXIT_CRITICAL()
\r
269 /*-----------------------------------------------------------*/
\r
271 BaseType_t xQueueGenericReset( QueueHandle_t xQueue, BaseType_t xNewQueue )
\r
273 Queue_t * const pxQueue = ( Queue_t * ) xQueue;
\r
275 configASSERT( pxQueue );
\r
277 taskENTER_CRITICAL();
\r
279 pxQueue->pcTail = pxQueue->pcHead + ( pxQueue->uxLength * pxQueue->uxItemSize );
\r
280 pxQueue->uxMessagesWaiting = ( UBaseType_t ) 0U;
\r
281 pxQueue->pcWriteTo = pxQueue->pcHead;
\r
282 pxQueue->u.pcReadFrom = pxQueue->pcHead + ( ( pxQueue->uxLength - ( UBaseType_t ) 1U ) * pxQueue->uxItemSize );
\r
283 pxQueue->xRxLock = queueUNLOCKED;
\r
284 pxQueue->xTxLock = queueUNLOCKED;
\r
286 if( xNewQueue == pdFALSE )
\r
288 /* If there are tasks blocked waiting to read from the queue, then
\r
289 the tasks will remain blocked as after this function exits the queue
\r
290 will still be empty. If there are tasks blocked waiting to write to
\r
291 the queue, then one should be unblocked as after this function exits
\r
292 it will be possible to write to it. */
\r
293 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) == pdFALSE )
\r
295 if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) == pdTRUE )
\r
297 queueYIELD_IF_USING_PREEMPTION();
\r
301 mtCOVERAGE_TEST_MARKER();
\r
306 mtCOVERAGE_TEST_MARKER();
\r
311 /* Ensure the event queues start in the correct state. */
\r
312 vListInitialise( &( pxQueue->xTasksWaitingToSend ) );
\r
313 vListInitialise( &( pxQueue->xTasksWaitingToReceive ) );
\r
316 taskEXIT_CRITICAL();
\r
318 /* A value is returned for calling semantic consistency with previous
\r
322 /*-----------------------------------------------------------*/
\r
324 static Queue_t *prvAllocateQueueMemory( const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, uint8_t **ppucQueueStorage, StaticQueue_t *pxStaticQueue )
\r
326 Queue_t *pxNewQueue;
\r
327 size_t xQueueSizeInBytes;
\r
329 configASSERT( uxQueueLength > ( UBaseType_t ) 0 );
\r
331 #if( ( configASSERT_DEFINED == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
\r
333 /* Sanity check that the size of the structure used to declare a
\r
334 variable of type DummyQueue_t or DummySemaphore_t equals the size of the
\r
335 real queue and semaphore structures. */
\r
336 volatile size_t xSize = sizeof( StaticQueue_t );
\r
337 configASSERT( xSize == sizeof( Queue_t ) );
\r
339 #endif /* configASSERT_DEFINED */
\r
341 if( uxItemSize == ( UBaseType_t ) 0 )
\r
343 /* There is not going to be a queue storage area. */
\r
344 xQueueSizeInBytes = ( size_t ) 0;
\r
348 /* The queue is one byte longer than asked for to make wrap checking
\r
350 xQueueSizeInBytes = ( size_t ) ( uxQueueLength * uxItemSize ) + ( size_t ) 1; /*lint !e961 MISRA exception as the casts are only redundant for some ports. */
\r
353 #if( configSUPPORT_STATIC_ALLOCATION == 0 )
\r
355 /* Allocate the new queue structure and storage area. */
\r
356 pxNewQueue = ( Queue_t * ) pvPortMalloc( sizeof( Queue_t ) + xQueueSizeInBytes );
\r
358 if( pxNewQueue != NULL )
\r
360 /* Jump past the queue structure to find the location of the queue
\r
362 *ppucQueueStorage = ( ( uint8_t * ) pxNewQueue ) + sizeof( Queue_t );
\r
365 /* The pxStaticQueue parameter is not used. Remove compiler warnings. */
\r
366 ( void ) pxStaticQueue;
\r
370 if( pxStaticQueue == NULL )
\r
372 /* A statically allocated queue was not passed in, so create one
\r
374 pxNewQueue = ( Queue_t * ) pvPortMalloc( sizeof( Queue_t ) );
\r
375 pxNewQueue->ucStaticAllocationFlags = 0;
\r
379 /* The address of a statically allocated queue was passed in, use
\r
380 it and note that the queue was not dynamically allocated so there is
\r
381 no attempt to free it again should the queue be deleted. */
\r
382 pxNewQueue = ( Queue_t * ) pxStaticQueue;
\r
383 pxNewQueue->ucStaticAllocationFlags = queueSTATICALLY_ALLOCATED_QUEUE_STRUCT;
\r
386 if( pxNewQueue != NULL )
\r
388 if( ( *ppucQueueStorage == NULL ) && ( xQueueSizeInBytes > 0 ) )
\r
390 /* A statically allocated queue storage area was not passed in,
\r
391 so allocate the queue storage area dynamically. */
\r
392 *ppucQueueStorage = ( uint8_t * ) pvPortMalloc( xQueueSizeInBytes );
\r
394 if( *ppucQueueStorage == NULL )
\r
396 /* The queue storage area could not be created, so free the
\r
397 queue structure also. */
\r
398 if( ( pxNewQueue->ucStaticAllocationFlags & queueSTATICALLY_ALLOCATED_QUEUE_STRUCT ) == 0 )
\r
400 vPortFree( ( void * ) pxNewQueue );
\r
407 /* Note the fact that either the queue storage area was passed
\r
408 into this function, or the size requirement for the queue
\r
409 storage area was zero - either way no attempt should be made to
\r
410 free the queue storage area if the queue is deleted. */
\r
411 pxNewQueue->ucStaticAllocationFlags |= queueSTATICALLY_ALLOCATED_STORAGE;
\r
419 /*-----------------------------------------------------------*/
\r
421 QueueHandle_t xQueueGenericCreate( const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, uint8_t *pucQueueStorage, StaticQueue_t *pxStaticQueue, const uint8_t ucQueueType )
\r
423 Queue_t *pxNewQueue;
\r
425 /* Remove compiler warnings about unused parameters should
\r
426 configUSE_TRACE_FACILITY not be set to 1. */
\r
427 ( void ) ucQueueType;
\r
429 /* A queue requires a queue structure and a queue storage area. These may
\r
430 be allocated statically or dynamically, depending on the parameter
\r
432 pxNewQueue = prvAllocateQueueMemory( uxQueueLength, uxItemSize, &pucQueueStorage, pxStaticQueue );
\r
434 if( pxNewQueue != NULL )
\r
436 if( uxItemSize == ( UBaseType_t ) 0 )
\r
438 /* No RAM was allocated for the queue storage area, but PC head
\r
439 cannot be set to NULL because NULL is used as a key to say the queue
\r
440 is used as a mutex. Therefore just set pcHead to point to the queue
\r
441 as a benign value that is known to be within the memory map. */
\r
442 pxNewQueue->pcHead = ( int8_t * ) pxNewQueue;
\r
446 /* Set the head to the start of the queue storage area. */
\r
447 pxNewQueue->pcHead = ( int8_t * ) pucQueueStorage;
\r
450 /* Initialise the queue members as described where the queue type is
\r
452 pxNewQueue->uxLength = uxQueueLength;
\r
453 pxNewQueue->uxItemSize = uxItemSize;
\r
454 ( void ) xQueueGenericReset( pxNewQueue, pdTRUE );
\r
456 #if ( configUSE_TRACE_FACILITY == 1 )
\r
458 pxNewQueue->ucQueueType = ucQueueType;
\r
460 #endif /* configUSE_TRACE_FACILITY */
\r
462 #if( configUSE_QUEUE_SETS == 1 )
\r
464 pxNewQueue->pxQueueSetContainer = NULL;
\r
466 #endif /* configUSE_QUEUE_SETS */
\r
468 traceQUEUE_CREATE( pxNewQueue );
\r
472 mtCOVERAGE_TEST_MARKER();
\r
475 configASSERT( pxNewQueue );
\r
477 return ( QueueHandle_t ) pxNewQueue;
\r
479 /*-----------------------------------------------------------*/
\r
481 #if ( configUSE_MUTEXES == 1 )
\r
483 QueueHandle_t xQueueCreateMutex( const uint8_t ucQueueType )
\r
485 Queue_t *pxNewQueue;
\r
487 /* Prevent compiler warnings about unused parameters if
\r
488 configUSE_TRACE_FACILITY does not equal 1. */
\r
489 ( void ) ucQueueType;
\r
491 /* Allocate the new queue structure. */
\r
492 pxNewQueue = ( Queue_t * ) pvPortMalloc( sizeof( Queue_t ) );
\r
493 if( pxNewQueue != NULL )
\r
495 /* Information required for priority inheritance. */
\r
496 pxNewQueue->pxMutexHolder = NULL;
\r
497 pxNewQueue->uxQueueType = queueQUEUE_IS_MUTEX;
\r
499 /* Queues used as a mutex no data is actually copied into or out
\r
501 pxNewQueue->pcWriteTo = NULL;
\r
502 pxNewQueue->u.pcReadFrom = NULL;
\r
504 /* Each mutex has a length of 1 (like a binary semaphore) and
\r
505 an item size of 0 as nothing is actually copied into or out
\r
507 pxNewQueue->uxMessagesWaiting = ( UBaseType_t ) 0U;
\r
508 pxNewQueue->uxLength = ( UBaseType_t ) 1U;
\r
509 pxNewQueue->uxItemSize = ( UBaseType_t ) 0U;
\r
510 pxNewQueue->xRxLock = queueUNLOCKED;
\r
511 pxNewQueue->xTxLock = queueUNLOCKED;
\r
513 #if ( configUSE_TRACE_FACILITY == 1 )
\r
515 pxNewQueue->ucQueueType = ucQueueType;
\r
519 #if ( configUSE_QUEUE_SETS == 1 )
\r
521 pxNewQueue->pxQueueSetContainer = NULL;
\r
525 /* Ensure the event queues start with the correct state. */
\r
526 vListInitialise( &( pxNewQueue->xTasksWaitingToSend ) );
\r
527 vListInitialise( &( pxNewQueue->xTasksWaitingToReceive ) );
\r
529 traceCREATE_MUTEX( pxNewQueue );
\r
531 /* Start with the semaphore in the expected state. */
\r
532 ( void ) xQueueGenericSend( pxNewQueue, NULL, ( TickType_t ) 0U, queueSEND_TO_BACK );
\r
536 traceCREATE_MUTEX_FAILED();
\r
542 #endif /* configUSE_MUTEXES */
\r
543 /*-----------------------------------------------------------*/
\r
545 #if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) )
\r
547 void* xQueueGetMutexHolder( QueueHandle_t xSemaphore )
\r
551 /* This function is called by xSemaphoreGetMutexHolder(), and should not
\r
552 be called directly. Note: This is a good way of determining if the
\r
553 calling task is the mutex holder, but not a good way of determining the
\r
554 identity of the mutex holder, as the holder may change between the
\r
555 following critical section exiting and the function returning. */
\r
556 taskENTER_CRITICAL();
\r
558 if( ( ( Queue_t * ) xSemaphore )->uxQueueType == queueQUEUE_IS_MUTEX )
\r
560 pxReturn = ( void * ) ( ( Queue_t * ) xSemaphore )->pxMutexHolder;
\r
567 taskEXIT_CRITICAL();
\r
570 } /*lint !e818 xSemaphore cannot be a pointer to const because it is a typedef. */
\r
573 /*-----------------------------------------------------------*/
\r
575 #if ( configUSE_RECURSIVE_MUTEXES == 1 )
\r
577 BaseType_t xQueueGiveMutexRecursive( QueueHandle_t xMutex )
\r
579 BaseType_t xReturn;
\r
580 Queue_t * const pxMutex = ( Queue_t * ) xMutex;
\r
582 configASSERT( pxMutex );
\r
584 /* If this is the task that holds the mutex then pxMutexHolder will not
\r
585 change outside of this task. If this task does not hold the mutex then
\r
586 pxMutexHolder can never coincidentally equal the tasks handle, and as
\r
587 this is the only condition we are interested in it does not matter if
\r
588 pxMutexHolder is accessed simultaneously by another task. Therefore no
\r
589 mutual exclusion is required to test the pxMutexHolder variable. */
\r
590 if( pxMutex->pxMutexHolder == ( void * ) xTaskGetCurrentTaskHandle() ) /*lint !e961 Not a redundant cast as TaskHandle_t is a typedef. */
\r
592 traceGIVE_MUTEX_RECURSIVE( pxMutex );
\r
594 /* uxRecursiveCallCount cannot be zero if pxMutexHolder is equal to
\r
595 the task handle, therefore no underflow check is required. Also,
\r
596 uxRecursiveCallCount is only modified by the mutex holder, and as
\r
597 there can only be one, no mutual exclusion is required to modify the
\r
598 uxRecursiveCallCount member. */
\r
599 ( pxMutex->u.uxRecursiveCallCount )--;
\r
601 /* Have we unwound the call count? */
\r
602 if( pxMutex->u.uxRecursiveCallCount == ( UBaseType_t ) 0 )
\r
604 /* Return the mutex. This will automatically unblock any other
\r
605 task that might be waiting to access the mutex. */
\r
606 ( void ) xQueueGenericSend( pxMutex, NULL, queueMUTEX_GIVE_BLOCK_TIME, queueSEND_TO_BACK );
\r
610 mtCOVERAGE_TEST_MARKER();
\r
617 /* The mutex cannot be given because the calling task is not the
\r
621 traceGIVE_MUTEX_RECURSIVE_FAILED( pxMutex );
\r
627 #endif /* configUSE_RECURSIVE_MUTEXES */
\r
628 /*-----------------------------------------------------------*/
\r
630 #if ( configUSE_RECURSIVE_MUTEXES == 1 )
\r
632 BaseType_t xQueueTakeMutexRecursive( QueueHandle_t xMutex, TickType_t xTicksToWait )
\r
634 BaseType_t xReturn;
\r
635 Queue_t * const pxMutex = ( Queue_t * ) xMutex;
\r
637 configASSERT( pxMutex );
\r
639 /* Comments regarding mutual exclusion as per those within
\r
640 xQueueGiveMutexRecursive(). */
\r
642 traceTAKE_MUTEX_RECURSIVE( pxMutex );
\r
644 if( pxMutex->pxMutexHolder == ( void * ) xTaskGetCurrentTaskHandle() ) /*lint !e961 Cast is not redundant as TaskHandle_t is a typedef. */
\r
646 ( pxMutex->u.uxRecursiveCallCount )++;
\r
651 xReturn = xQueueGenericReceive( pxMutex, NULL, xTicksToWait, pdFALSE );
\r
653 /* pdPASS will only be returned if the mutex was successfully
\r
654 obtained. The calling task may have entered the Blocked state
\r
655 before reaching here. */
\r
656 if( xReturn == pdPASS )
\r
658 ( pxMutex->u.uxRecursiveCallCount )++;
\r
662 traceTAKE_MUTEX_RECURSIVE_FAILED( pxMutex );
\r
669 #endif /* configUSE_RECURSIVE_MUTEXES */
\r
670 /*-----------------------------------------------------------*/
\r
672 #if ( configUSE_COUNTING_SEMAPHORES == 1 )
\r
674 QueueHandle_t xQueueCreateCountingSemaphore( const UBaseType_t uxMaxCount, const UBaseType_t uxInitialCount )
\r
676 QueueHandle_t xHandle;
\r
678 configASSERT( uxMaxCount != 0 );
\r
679 configASSERT( uxInitialCount <= uxMaxCount );
\r
681 xHandle = xQueueGenericCreate( uxMaxCount, queueSEMAPHORE_QUEUE_ITEM_LENGTH, NULL, NULL, queueQUEUE_TYPE_COUNTING_SEMAPHORE );
\r
683 if( xHandle != NULL )
\r
685 ( ( Queue_t * ) xHandle )->uxMessagesWaiting = uxInitialCount;
\r
687 traceCREATE_COUNTING_SEMAPHORE();
\r
691 traceCREATE_COUNTING_SEMAPHORE_FAILED();
\r
694 configASSERT( xHandle );
\r
698 #endif /* configUSE_COUNTING_SEMAPHORES */
\r
699 /*-----------------------------------------------------------*/
\r
701 BaseType_t xQueueGenericSend( QueueHandle_t xQueue, const void * const pvItemToQueue, TickType_t xTicksToWait, const BaseType_t xCopyPosition )
\r
703 BaseType_t xEntryTimeSet = pdFALSE, xYieldRequired;
\r
704 TimeOut_t xTimeOut;
\r
705 Queue_t * const pxQueue = ( Queue_t * ) xQueue;
\r
707 configASSERT( pxQueue );
\r
708 configASSERT( !( ( pvItemToQueue == NULL ) && ( pxQueue->uxItemSize != ( UBaseType_t ) 0U ) ) );
\r
709 configASSERT( !( ( xCopyPosition == queueOVERWRITE ) && ( pxQueue->uxLength != 1 ) ) );
\r
710 #if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
\r
712 configASSERT( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) );
\r
717 /* This function relaxes the coding standard somewhat to allow return
\r
718 statements within the function itself. This is done in the interest
\r
719 of execution time efficiency. */
\r
722 taskENTER_CRITICAL();
\r
724 /* Is there room on the queue now? The running task must be the
\r
725 highest priority task wanting to access the queue. If the head item
\r
726 in the queue is to be overwritten then it does not matter if the
\r
728 if( ( pxQueue->uxMessagesWaiting < pxQueue->uxLength ) || ( xCopyPosition == queueOVERWRITE ) )
\r
730 traceQUEUE_SEND( pxQueue );
\r
731 xYieldRequired = prvCopyDataToQueue( pxQueue, pvItemToQueue, xCopyPosition );
\r
733 #if ( configUSE_QUEUE_SETS == 1 )
\r
735 if( pxQueue->pxQueueSetContainer != NULL )
\r
737 if( prvNotifyQueueSetContainer( pxQueue, xCopyPosition ) == pdTRUE )
\r
739 /* The queue is a member of a queue set, and posting
\r
740 to the queue set caused a higher priority task to
\r
741 unblock. A context switch is required. */
\r
742 queueYIELD_IF_USING_PREEMPTION();
\r
746 mtCOVERAGE_TEST_MARKER();
\r
751 /* If there was a task waiting for data to arrive on the
\r
752 queue then unblock it now. */
\r
753 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
\r
755 if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) == pdTRUE )
\r
757 /* The unblocked task has a priority higher than
\r
758 our own so yield immediately. Yes it is ok to
\r
759 do this from within the critical section - the
\r
760 kernel takes care of that. */
\r
761 queueYIELD_IF_USING_PREEMPTION();
\r
765 mtCOVERAGE_TEST_MARKER();
\r
768 else if( xYieldRequired != pdFALSE )
\r
770 /* This path is a special case that will only get
\r
771 executed if the task was holding multiple mutexes
\r
772 and the mutexes were given back in an order that is
\r
773 different to that in which they were taken. */
\r
774 queueYIELD_IF_USING_PREEMPTION();
\r
778 mtCOVERAGE_TEST_MARKER();
\r
782 #else /* configUSE_QUEUE_SETS */
\r
784 /* If there was a task waiting for data to arrive on the
\r
785 queue then unblock it now. */
\r
786 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
\r
788 if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) == pdTRUE )
\r
790 /* The unblocked task has a priority higher than
\r
791 our own so yield immediately. Yes it is ok to do
\r
792 this from within the critical section - the kernel
\r
793 takes care of that. */
\r
794 queueYIELD_IF_USING_PREEMPTION();
\r
798 mtCOVERAGE_TEST_MARKER();
\r
801 else if( xYieldRequired != pdFALSE )
\r
803 /* This path is a special case that will only get
\r
804 executed if the task was holding multiple mutexes and
\r
805 the mutexes were given back in an order that is
\r
806 different to that in which they were taken. */
\r
807 queueYIELD_IF_USING_PREEMPTION();
\r
811 mtCOVERAGE_TEST_MARKER();
\r
814 #endif /* configUSE_QUEUE_SETS */
\r
816 taskEXIT_CRITICAL();
\r
821 if( xTicksToWait == ( TickType_t ) 0 )
\r
823 /* The queue was full and no block time is specified (or
\r
824 the block time has expired) so leave now. */
\r
825 taskEXIT_CRITICAL();
\r
827 /* Return to the original privilege level before exiting
\r
829 traceQUEUE_SEND_FAILED( pxQueue );
\r
830 return errQUEUE_FULL;
\r
832 else if( xEntryTimeSet == pdFALSE )
\r
834 /* The queue was full and a block time was specified so
\r
835 configure the timeout structure. */
\r
836 vTaskSetTimeOutState( &xTimeOut );
\r
837 xEntryTimeSet = pdTRUE;
\r
841 /* Entry time was already set. */
\r
842 mtCOVERAGE_TEST_MARKER();
\r
846 taskEXIT_CRITICAL();
\r
848 /* Interrupts and other tasks can send to and receive from the queue
\r
849 now the critical section has been exited. */
\r
852 prvLockQueue( pxQueue );
\r
854 /* Update the timeout state to see if it has expired yet. */
\r
855 if( xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) == pdFALSE )
\r
857 if( prvIsQueueFull( pxQueue ) != pdFALSE )
\r
859 traceBLOCKING_ON_QUEUE_SEND( pxQueue );
\r
860 vTaskPlaceOnEventList( &( pxQueue->xTasksWaitingToSend ), xTicksToWait );
\r
862 /* Unlocking the queue means queue events can effect the
\r
863 event list. It is possible that interrupts occurring now
\r
864 remove this task from the event list again - but as the
\r
865 scheduler is suspended the task will go onto the pending
\r
866 ready last instead of the actual ready list. */
\r
867 prvUnlockQueue( pxQueue );
\r
869 /* Resuming the scheduler will move tasks from the pending
\r
870 ready list into the ready list - so it is feasible that this
\r
871 task is already in a ready list before it yields - in which
\r
872 case the yield will not cause a context switch unless there
\r
873 is also a higher priority task in the pending ready list. */
\r
874 if( xTaskResumeAll() == pdFALSE )
\r
876 portYIELD_WITHIN_API();
\r
882 prvUnlockQueue( pxQueue );
\r
883 ( void ) xTaskResumeAll();
\r
888 /* The timeout has expired. */
\r
889 prvUnlockQueue( pxQueue );
\r
890 ( void ) xTaskResumeAll();
\r
892 traceQUEUE_SEND_FAILED( pxQueue );
\r
893 return errQUEUE_FULL;
\r
897 /*-----------------------------------------------------------*/
\r
899 #if ( configUSE_ALTERNATIVE_API == 1 )
\r
901 BaseType_t xQueueAltGenericSend( QueueHandle_t xQueue, const void * const pvItemToQueue, TickType_t xTicksToWait, BaseType_t xCopyPosition )
\r
903 BaseType_t xEntryTimeSet = pdFALSE;
\r
904 TimeOut_t xTimeOut;
\r
905 Queue_t * const pxQueue = ( Queue_t * ) xQueue;
\r
907 configASSERT( pxQueue );
\r
908 configASSERT( !( ( pvItemToQueue == NULL ) && ( pxQueue->uxItemSize != ( UBaseType_t ) 0U ) ) );
\r
912 taskENTER_CRITICAL();
\r
914 /* Is there room on the queue now? To be running we must be
\r
915 the highest priority task wanting to access the queue. */
\r
916 if( pxQueue->uxMessagesWaiting < pxQueue->uxLength )
\r
918 traceQUEUE_SEND( pxQueue );
\r
919 prvCopyDataToQueue( pxQueue, pvItemToQueue, xCopyPosition );
\r
921 /* If there was a task waiting for data to arrive on the
\r
922 queue then unblock it now. */
\r
923 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
\r
925 if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) == pdTRUE )
\r
927 /* The unblocked task has a priority higher than
\r
928 our own so yield immediately. */
\r
929 portYIELD_WITHIN_API();
\r
933 mtCOVERAGE_TEST_MARKER();
\r
938 mtCOVERAGE_TEST_MARKER();
\r
941 taskEXIT_CRITICAL();
\r
946 if( xTicksToWait == ( TickType_t ) 0 )
\r
948 taskEXIT_CRITICAL();
\r
949 return errQUEUE_FULL;
\r
951 else if( xEntryTimeSet == pdFALSE )
\r
953 vTaskSetTimeOutState( &xTimeOut );
\r
954 xEntryTimeSet = pdTRUE;
\r
958 taskEXIT_CRITICAL();
\r
960 taskENTER_CRITICAL();
\r
962 if( xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) == pdFALSE )
\r
964 if( prvIsQueueFull( pxQueue ) != pdFALSE )
\r
966 traceBLOCKING_ON_QUEUE_SEND( pxQueue );
\r
967 vTaskPlaceOnEventList( &( pxQueue->xTasksWaitingToSend ), xTicksToWait );
\r
968 portYIELD_WITHIN_API();
\r
972 mtCOVERAGE_TEST_MARKER();
\r
977 taskEXIT_CRITICAL();
\r
978 traceQUEUE_SEND_FAILED( pxQueue );
\r
979 return errQUEUE_FULL;
\r
982 taskEXIT_CRITICAL();
\r
986 #endif /* configUSE_ALTERNATIVE_API */
\r
987 /*-----------------------------------------------------------*/
\r
989 #if ( configUSE_ALTERNATIVE_API == 1 )
\r
991 BaseType_t xQueueAltGenericReceive( QueueHandle_t xQueue, void * const pvBuffer, TickType_t xTicksToWait, BaseType_t xJustPeeking )
\r
993 BaseType_t xEntryTimeSet = pdFALSE;
\r
994 TimeOut_t xTimeOut;
\r
995 int8_t *pcOriginalReadPosition;
\r
996 Queue_t * const pxQueue = ( Queue_t * ) xQueue;
\r
998 configASSERT( pxQueue );
\r
999 configASSERT( !( ( pvBuffer == NULL ) && ( pxQueue->uxItemSize != ( UBaseType_t ) 0U ) ) );
\r
1003 taskENTER_CRITICAL();
\r
1005 if( pxQueue->uxMessagesWaiting > ( UBaseType_t ) 0 )
\r
1007 /* Remember our read position in case we are just peeking. */
\r
1008 pcOriginalReadPosition = pxQueue->u.pcReadFrom;
\r
1010 prvCopyDataFromQueue( pxQueue, pvBuffer );
\r
1012 if( xJustPeeking == pdFALSE )
\r
1014 traceQUEUE_RECEIVE( pxQueue );
\r
1016 /* Data is actually being removed (not just peeked). */
\r
1017 --( pxQueue->uxMessagesWaiting );
\r
1019 #if ( configUSE_MUTEXES == 1 )
\r
1021 if( pxQueue->uxQueueType == queueQUEUE_IS_MUTEX )
\r
1023 /* Record the information required to implement
\r
1024 priority inheritance should it become necessary. */
\r
1025 pxQueue->pxMutexHolder = ( int8_t * ) xTaskGetCurrentTaskHandle();
\r
1029 mtCOVERAGE_TEST_MARKER();
\r
1034 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) == pdFALSE )
\r
1036 if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) == pdTRUE )
\r
1038 portYIELD_WITHIN_API();
\r
1042 mtCOVERAGE_TEST_MARKER();
\r
1048 traceQUEUE_PEEK( pxQueue );
\r
1050 /* The data is not being removed, so reset our read
\r
1052 pxQueue->u.pcReadFrom = pcOriginalReadPosition;
\r
1054 /* The data is being left in the queue, so see if there are
\r
1055 any other tasks waiting for the data. */
\r
1056 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
\r
1058 /* Tasks that are removed from the event list will get added to
\r
1059 the pending ready list as the scheduler is still suspended. */
\r
1060 if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )
\r
1062 /* The task waiting has a higher priority than this task. */
\r
1063 portYIELD_WITHIN_API();
\r
1067 mtCOVERAGE_TEST_MARKER();
\r
1072 mtCOVERAGE_TEST_MARKER();
\r
1076 taskEXIT_CRITICAL();
\r
1081 if( xTicksToWait == ( TickType_t ) 0 )
\r
1083 taskEXIT_CRITICAL();
\r
1084 traceQUEUE_RECEIVE_FAILED( pxQueue );
\r
1085 return errQUEUE_EMPTY;
\r
1087 else if( xEntryTimeSet == pdFALSE )
\r
1089 vTaskSetTimeOutState( &xTimeOut );
\r
1090 xEntryTimeSet = pdTRUE;
\r
1094 taskEXIT_CRITICAL();
\r
1096 taskENTER_CRITICAL();
\r
1098 if( xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) == pdFALSE )
\r
1100 if( prvIsQueueEmpty( pxQueue ) != pdFALSE )
\r
1102 traceBLOCKING_ON_QUEUE_RECEIVE( pxQueue );
\r
1104 #if ( configUSE_MUTEXES == 1 )
\r
1106 if( pxQueue->uxQueueType == queueQUEUE_IS_MUTEX )
\r
1108 taskENTER_CRITICAL();
\r
1110 vTaskPriorityInherit( ( void * ) pxQueue->pxMutexHolder );
\r
1112 taskEXIT_CRITICAL();
\r
1116 mtCOVERAGE_TEST_MARKER();
\r
1121 vTaskPlaceOnEventList( &( pxQueue->xTasksWaitingToReceive ), xTicksToWait );
\r
1122 portYIELD_WITHIN_API();
\r
1126 mtCOVERAGE_TEST_MARKER();
\r
1131 taskEXIT_CRITICAL();
\r
1132 traceQUEUE_RECEIVE_FAILED( pxQueue );
\r
1133 return errQUEUE_EMPTY;
\r
1136 taskEXIT_CRITICAL();
\r
1141 #endif /* configUSE_ALTERNATIVE_API */
\r
1142 /*-----------------------------------------------------------*/
\r
1144 BaseType_t xQueueGenericSendFromISR( QueueHandle_t xQueue, const void * const pvItemToQueue, BaseType_t * const pxHigherPriorityTaskWoken, const BaseType_t xCopyPosition )
\r
1146 BaseType_t xReturn;
\r
1147 UBaseType_t uxSavedInterruptStatus;
\r
1148 Queue_t * const pxQueue = ( Queue_t * ) xQueue;
\r
1150 configASSERT( pxQueue );
\r
1151 configASSERT( !( ( pvItemToQueue == NULL ) && ( pxQueue->uxItemSize != ( UBaseType_t ) 0U ) ) );
\r
1152 configASSERT( !( ( xCopyPosition == queueOVERWRITE ) && ( pxQueue->uxLength != 1 ) ) );
\r
1154 /* RTOS ports that support interrupt nesting have the concept of a maximum
\r
1155 system call (or maximum API call) interrupt priority. Interrupts that are
\r
1156 above the maximum system call priority are kept permanently enabled, even
\r
1157 when the RTOS kernel is in a critical section, but cannot make any calls to
\r
1158 FreeRTOS API functions. If configASSERT() is defined in FreeRTOSConfig.h
\r
1159 then portASSERT_IF_INTERRUPT_PRIORITY_INVALID() will result in an assertion
\r
1160 failure if a FreeRTOS API function is called from an interrupt that has been
\r
1161 assigned a priority above the configured maximum system call priority.
\r
1162 Only FreeRTOS functions that end in FromISR can be called from interrupts
\r
1163 that have been assigned a priority at or (logically) below the maximum
\r
1164 system call interrupt priority. FreeRTOS maintains a separate interrupt
\r
1165 safe API to ensure interrupt entry is as fast and as simple as possible.
\r
1166 More information (albeit Cortex-M specific) is provided on the following
\r
1167 link: http://www.freertos.org/RTOS-Cortex-M3-M4.html */
\r
1168 portASSERT_IF_INTERRUPT_PRIORITY_INVALID();
\r
1170 /* Similar to xQueueGenericSend, except without blocking if there is no room
\r
1171 in the queue. Also don't directly wake a task that was blocked on a queue
\r
1172 read, instead return a flag to say whether a context switch is required or
\r
1173 not (i.e. has a task with a higher priority than us been woken by this
\r
1175 uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
\r
1177 if( ( pxQueue->uxMessagesWaiting < pxQueue->uxLength ) || ( xCopyPosition == queueOVERWRITE ) )
\r
1179 traceQUEUE_SEND_FROM_ISR( pxQueue );
\r
1181 /* Semaphores use xQueueGiveFromISR(), so pxQueue will not be a
\r
1182 semaphore or mutex. That means prvCopyDataToQueue() cannot result
\r
1183 in a task disinheriting a priority and prvCopyDataToQueue() can be
\r
1184 called here even though the disinherit function does not check if
\r
1185 the scheduler is suspended before accessing the ready lists. */
\r
1186 ( void ) prvCopyDataToQueue( pxQueue, pvItemToQueue, xCopyPosition );
\r
1188 /* The event list is not altered if the queue is locked. This will
\r
1189 be done when the queue is unlocked later. */
\r
1190 if( pxQueue->xTxLock == queueUNLOCKED )
\r
1192 #if ( configUSE_QUEUE_SETS == 1 )
\r
1194 if( pxQueue->pxQueueSetContainer != NULL )
\r
1196 if( prvNotifyQueueSetContainer( pxQueue, xCopyPosition ) == pdTRUE )
\r
1198 /* The queue is a member of a queue set, and posting
\r
1199 to the queue set caused a higher priority task to
\r
1200 unblock. A context switch is required. */
\r
1201 if( pxHigherPriorityTaskWoken != NULL )
\r
1203 *pxHigherPriorityTaskWoken = pdTRUE;
\r
1207 mtCOVERAGE_TEST_MARKER();
\r
1212 mtCOVERAGE_TEST_MARKER();
\r
1217 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
\r
1219 if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )
\r
1221 /* The task waiting has a higher priority so
\r
1222 record that a context switch is required. */
\r
1223 if( pxHigherPriorityTaskWoken != NULL )
\r
1225 *pxHigherPriorityTaskWoken = pdTRUE;
\r
1229 mtCOVERAGE_TEST_MARKER();
\r
1234 mtCOVERAGE_TEST_MARKER();
\r
1239 mtCOVERAGE_TEST_MARKER();
\r
1243 #else /* configUSE_QUEUE_SETS */
\r
1245 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
\r
1247 if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )
\r
1249 /* The task waiting has a higher priority so record that a
\r
1250 context switch is required. */
\r
1251 if( pxHigherPriorityTaskWoken != NULL )
\r
1253 *pxHigherPriorityTaskWoken = pdTRUE;
\r
1257 mtCOVERAGE_TEST_MARKER();
\r
1262 mtCOVERAGE_TEST_MARKER();
\r
1267 mtCOVERAGE_TEST_MARKER();
\r
1270 #endif /* configUSE_QUEUE_SETS */
\r
1274 /* Increment the lock count so the task that unlocks the queue
\r
1275 knows that data was posted while it was locked. */
\r
1276 ++( pxQueue->xTxLock );
\r
1283 traceQUEUE_SEND_FROM_ISR_FAILED( pxQueue );
\r
1284 xReturn = errQUEUE_FULL;
\r
1287 portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );
\r
1291 /*-----------------------------------------------------------*/
\r
1293 BaseType_t xQueueGiveFromISR( QueueHandle_t xQueue, BaseType_t * const pxHigherPriorityTaskWoken )
\r
1295 BaseType_t xReturn;
\r
1296 UBaseType_t uxSavedInterruptStatus;
\r
1297 Queue_t * const pxQueue = ( Queue_t * ) xQueue;
\r
1299 /* Similar to xQueueGenericSendFromISR() but used with semaphores where the
\r
1300 item size is 0. Don't directly wake a task that was blocked on a queue
\r
1301 read, instead return a flag to say whether a context switch is required or
\r
1302 not (i.e. has a task with a higher priority than us been woken by this
\r
1305 configASSERT( pxQueue );
\r
1307 /* xQueueGenericSendFromISR() should be used instead of xQueueGiveFromISR()
\r
1308 if the item size is not 0. */
\r
1309 configASSERT( pxQueue->uxItemSize == 0 );
\r
1311 /* Normally a mutex would not be given from an interrupt, especially if
\r
1312 there is a mutex holder, as priority inheritance makes no sense for an
\r
1313 interrupts, only tasks. */
\r
1314 configASSERT( !( ( pxQueue->uxQueueType == queueQUEUE_IS_MUTEX ) && ( pxQueue->pxMutexHolder != NULL ) ) );
\r
1316 /* RTOS ports that support interrupt nesting have the concept of a maximum
\r
1317 system call (or maximum API call) interrupt priority. Interrupts that are
\r
1318 above the maximum system call priority are kept permanently enabled, even
\r
1319 when the RTOS kernel is in a critical section, but cannot make any calls to
\r
1320 FreeRTOS API functions. If configASSERT() is defined in FreeRTOSConfig.h
\r
1321 then portASSERT_IF_INTERRUPT_PRIORITY_INVALID() will result in an assertion
\r
1322 failure if a FreeRTOS API function is called from an interrupt that has been
\r
1323 assigned a priority above the configured maximum system call priority.
\r
1324 Only FreeRTOS functions that end in FromISR can be called from interrupts
\r
1325 that have been assigned a priority at or (logically) below the maximum
\r
1326 system call interrupt priority. FreeRTOS maintains a separate interrupt
\r
1327 safe API to ensure interrupt entry is as fast and as simple as possible.
\r
1328 More information (albeit Cortex-M specific) is provided on the following
\r
1329 link: http://www.freertos.org/RTOS-Cortex-M3-M4.html */
\r
1330 portASSERT_IF_INTERRUPT_PRIORITY_INVALID();
\r
1332 uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
\r
1334 /* When the queue is used to implement a semaphore no data is ever
\r
1335 moved through the queue but it is still valid to see if the queue 'has
\r
1337 if( pxQueue->uxMessagesWaiting < pxQueue->uxLength )
\r
1339 traceQUEUE_SEND_FROM_ISR( pxQueue );
\r
1341 /* A task can only have an inherited priority if it is a mutex
\r
1342 holder - and if there is a mutex holder then the mutex cannot be
\r
1343 given from an ISR. As this is the ISR version of the function it
\r
1344 can be assumed there is no mutex holder and no need to determine if
\r
1345 priority disinheritance is needed. Simply increase the count of
\r
1346 messages (semaphores) available. */
\r
1347 ++( pxQueue->uxMessagesWaiting );
\r
1349 /* The event list is not altered if the queue is locked. This will
\r
1350 be done when the queue is unlocked later. */
\r
1351 if( pxQueue->xTxLock == queueUNLOCKED )
\r
1353 #if ( configUSE_QUEUE_SETS == 1 )
\r
1355 if( pxQueue->pxQueueSetContainer != NULL )
\r
1357 if( prvNotifyQueueSetContainer( pxQueue, queueSEND_TO_BACK ) == pdTRUE )
\r
1359 /* The semaphore is a member of a queue set, and
\r
1360 posting to the queue set caused a higher priority
\r
1361 task to unblock. A context switch is required. */
\r
1362 if( pxHigherPriorityTaskWoken != NULL )
\r
1364 *pxHigherPriorityTaskWoken = pdTRUE;
\r
1368 mtCOVERAGE_TEST_MARKER();
\r
1373 mtCOVERAGE_TEST_MARKER();
\r
1378 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
\r
1380 if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )
\r
1382 /* The task waiting has a higher priority so
\r
1383 record that a context switch is required. */
\r
1384 if( pxHigherPriorityTaskWoken != NULL )
\r
1386 *pxHigherPriorityTaskWoken = pdTRUE;
\r
1390 mtCOVERAGE_TEST_MARKER();
\r
1395 mtCOVERAGE_TEST_MARKER();
\r
1400 mtCOVERAGE_TEST_MARKER();
\r
1404 #else /* configUSE_QUEUE_SETS */
\r
1406 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
\r
1408 if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )
\r
1410 /* The task waiting has a higher priority so record that a
\r
1411 context switch is required. */
\r
1412 if( pxHigherPriorityTaskWoken != NULL )
\r
1414 *pxHigherPriorityTaskWoken = pdTRUE;
\r
1418 mtCOVERAGE_TEST_MARKER();
\r
1423 mtCOVERAGE_TEST_MARKER();
\r
1428 mtCOVERAGE_TEST_MARKER();
\r
1431 #endif /* configUSE_QUEUE_SETS */
\r
1435 /* Increment the lock count so the task that unlocks the queue
\r
1436 knows that data was posted while it was locked. */
\r
1437 ++( pxQueue->xTxLock );
\r
1444 traceQUEUE_SEND_FROM_ISR_FAILED( pxQueue );
\r
1445 xReturn = errQUEUE_FULL;
\r
1448 portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );
\r
1452 /*-----------------------------------------------------------*/
\r
1454 BaseType_t xQueueGenericReceive( QueueHandle_t xQueue, void * const pvBuffer, TickType_t xTicksToWait, const BaseType_t xJustPeeking )
\r
1456 BaseType_t xEntryTimeSet = pdFALSE;
\r
1457 TimeOut_t xTimeOut;
\r
1458 int8_t *pcOriginalReadPosition;
\r
1459 Queue_t * const pxQueue = ( Queue_t * ) xQueue;
\r
1461 configASSERT( pxQueue );
\r
1462 configASSERT( !( ( pvBuffer == NULL ) && ( pxQueue->uxItemSize != ( UBaseType_t ) 0U ) ) );
\r
1463 #if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
\r
1465 configASSERT( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) );
\r
1469 /* This function relaxes the coding standard somewhat to allow return
\r
1470 statements within the function itself. This is done in the interest
\r
1471 of execution time efficiency. */
\r
1475 taskENTER_CRITICAL();
\r
1477 /* Is there data in the queue now? To be running the calling task
\r
1478 must be the highest priority task wanting to access the queue. */
\r
1479 if( pxQueue->uxMessagesWaiting > ( UBaseType_t ) 0 )
\r
1481 /* Remember the read position in case the queue is only being
\r
1483 pcOriginalReadPosition = pxQueue->u.pcReadFrom;
\r
1485 prvCopyDataFromQueue( pxQueue, pvBuffer );
\r
1487 if( xJustPeeking == pdFALSE )
\r
1489 traceQUEUE_RECEIVE( pxQueue );
\r
1491 /* Actually removing data, not just peeking. */
\r
1492 --( pxQueue->uxMessagesWaiting );
\r
1494 #if ( configUSE_MUTEXES == 1 )
\r
1496 if( pxQueue->uxQueueType == queueQUEUE_IS_MUTEX )
\r
1498 /* Record the information required to implement
\r
1499 priority inheritance should it become necessary. */
\r
1500 pxQueue->pxMutexHolder = ( int8_t * ) pvTaskIncrementMutexHeldCount(); /*lint !e961 Cast is not redundant as TaskHandle_t is a typedef. */
\r
1504 mtCOVERAGE_TEST_MARKER();
\r
1507 #endif /* configUSE_MUTEXES */
\r
1509 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) == pdFALSE )
\r
1511 if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) == pdTRUE )
\r
1513 queueYIELD_IF_USING_PREEMPTION();
\r
1517 mtCOVERAGE_TEST_MARKER();
\r
1522 mtCOVERAGE_TEST_MARKER();
\r
1527 traceQUEUE_PEEK( pxQueue );
\r
1529 /* The data is not being removed, so reset the read
\r
1531 pxQueue->u.pcReadFrom = pcOriginalReadPosition;
\r
1533 /* The data is being left in the queue, so see if there are
\r
1534 any other tasks waiting for the data. */
\r
1535 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
\r
1537 if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )
\r
1539 /* The task waiting has a higher priority than this task. */
\r
1540 queueYIELD_IF_USING_PREEMPTION();
\r
1544 mtCOVERAGE_TEST_MARKER();
\r
1549 mtCOVERAGE_TEST_MARKER();
\r
1553 taskEXIT_CRITICAL();
\r
1558 if( xTicksToWait == ( TickType_t ) 0 )
\r
1560 /* The queue was empty and no block time is specified (or
\r
1561 the block time has expired) so leave now. */
\r
1562 taskEXIT_CRITICAL();
\r
1563 traceQUEUE_RECEIVE_FAILED( pxQueue );
\r
1564 return errQUEUE_EMPTY;
\r
1566 else if( xEntryTimeSet == pdFALSE )
\r
1568 /* The queue was empty and a block time was specified so
\r
1569 configure the timeout structure. */
\r
1570 vTaskSetTimeOutState( &xTimeOut );
\r
1571 xEntryTimeSet = pdTRUE;
\r
1575 /* Entry time was already set. */
\r
1576 mtCOVERAGE_TEST_MARKER();
\r
1580 taskEXIT_CRITICAL();
\r
1582 /* Interrupts and other tasks can send to and receive from the queue
\r
1583 now the critical section has been exited. */
\r
1585 vTaskSuspendAll();
\r
1586 prvLockQueue( pxQueue );
\r
1588 /* Update the timeout state to see if it has expired yet. */
\r
1589 if( xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) == pdFALSE )
\r
1591 if( prvIsQueueEmpty( pxQueue ) != pdFALSE )
\r
1593 traceBLOCKING_ON_QUEUE_RECEIVE( pxQueue );
\r
1595 #if ( configUSE_MUTEXES == 1 )
\r
1597 if( pxQueue->uxQueueType == queueQUEUE_IS_MUTEX )
\r
1599 taskENTER_CRITICAL();
\r
1601 vTaskPriorityInherit( ( void * ) pxQueue->pxMutexHolder );
\r
1603 taskEXIT_CRITICAL();
\r
1607 mtCOVERAGE_TEST_MARKER();
\r
1612 vTaskPlaceOnEventList( &( pxQueue->xTasksWaitingToReceive ), xTicksToWait );
\r
1613 prvUnlockQueue( pxQueue );
\r
1614 if( xTaskResumeAll() == pdFALSE )
\r
1616 portYIELD_WITHIN_API();
\r
1620 mtCOVERAGE_TEST_MARKER();
\r
1626 prvUnlockQueue( pxQueue );
\r
1627 ( void ) xTaskResumeAll();
\r
1632 prvUnlockQueue( pxQueue );
\r
1633 ( void ) xTaskResumeAll();
\r
1635 if( prvIsQueueEmpty( pxQueue ) != pdFALSE )
\r
1637 traceQUEUE_RECEIVE_FAILED( pxQueue );
\r
1638 return errQUEUE_EMPTY;
\r
1642 mtCOVERAGE_TEST_MARKER();
\r
1647 /*-----------------------------------------------------------*/
\r
1649 BaseType_t xQueueReceiveFromISR( QueueHandle_t xQueue, void * const pvBuffer, BaseType_t * const pxHigherPriorityTaskWoken )
\r
1651 BaseType_t xReturn;
\r
1652 UBaseType_t uxSavedInterruptStatus;
\r
1653 Queue_t * const pxQueue = ( Queue_t * ) xQueue;
\r
1655 configASSERT( pxQueue );
\r
1656 configASSERT( !( ( pvBuffer == NULL ) && ( pxQueue->uxItemSize != ( UBaseType_t ) 0U ) ) );
\r
1658 /* RTOS ports that support interrupt nesting have the concept of a maximum
\r
1659 system call (or maximum API call) interrupt priority. Interrupts that are
\r
1660 above the maximum system call priority are kept permanently enabled, even
\r
1661 when the RTOS kernel is in a critical section, but cannot make any calls to
\r
1662 FreeRTOS API functions. If configASSERT() is defined in FreeRTOSConfig.h
\r
1663 then portASSERT_IF_INTERRUPT_PRIORITY_INVALID() will result in an assertion
\r
1664 failure if a FreeRTOS API function is called from an interrupt that has been
\r
1665 assigned a priority above the configured maximum system call priority.
\r
1666 Only FreeRTOS functions that end in FromISR can be called from interrupts
\r
1667 that have been assigned a priority at or (logically) below the maximum
\r
1668 system call interrupt priority. FreeRTOS maintains a separate interrupt
\r
1669 safe API to ensure interrupt entry is as fast and as simple as possible.
\r
1670 More information (albeit Cortex-M specific) is provided on the following
\r
1671 link: http://www.freertos.org/RTOS-Cortex-M3-M4.html */
\r
1672 portASSERT_IF_INTERRUPT_PRIORITY_INVALID();
\r
1674 uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
\r
1676 /* Cannot block in an ISR, so check there is data available. */
\r
1677 if( pxQueue->uxMessagesWaiting > ( UBaseType_t ) 0 )
\r
1679 traceQUEUE_RECEIVE_FROM_ISR( pxQueue );
\r
1681 prvCopyDataFromQueue( pxQueue, pvBuffer );
\r
1682 --( pxQueue->uxMessagesWaiting );
\r
1684 /* If the queue is locked the event list will not be modified.
\r
1685 Instead update the lock count so the task that unlocks the queue
\r
1686 will know that an ISR has removed data while the queue was
\r
1688 if( pxQueue->xRxLock == queueUNLOCKED )
\r
1690 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) == pdFALSE )
\r
1692 if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) != pdFALSE )
\r
1694 /* The task waiting has a higher priority than us so
\r
1695 force a context switch. */
\r
1696 if( pxHigherPriorityTaskWoken != NULL )
\r
1698 *pxHigherPriorityTaskWoken = pdTRUE;
\r
1702 mtCOVERAGE_TEST_MARKER();
\r
1707 mtCOVERAGE_TEST_MARKER();
\r
1712 mtCOVERAGE_TEST_MARKER();
\r
1717 /* Increment the lock count so the task that unlocks the queue
\r
1718 knows that data was removed while it was locked. */
\r
1719 ++( pxQueue->xRxLock );
\r
1727 traceQUEUE_RECEIVE_FROM_ISR_FAILED( pxQueue );
\r
1730 portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );
\r
1734 /*-----------------------------------------------------------*/
\r
1736 BaseType_t xQueuePeekFromISR( QueueHandle_t xQueue, void * const pvBuffer )
\r
1738 BaseType_t xReturn;
\r
1739 UBaseType_t uxSavedInterruptStatus;
\r
1740 int8_t *pcOriginalReadPosition;
\r
1741 Queue_t * const pxQueue = ( Queue_t * ) xQueue;
\r
1743 configASSERT( pxQueue );
\r
1744 configASSERT( !( ( pvBuffer == NULL ) && ( pxQueue->uxItemSize != ( UBaseType_t ) 0U ) ) );
\r
1745 configASSERT( pxQueue->uxItemSize != 0 ); /* Can't peek a semaphore. */
\r
1747 /* RTOS ports that support interrupt nesting have the concept of a maximum
\r
1748 system call (or maximum API call) interrupt priority. Interrupts that are
\r
1749 above the maximum system call priority are kept permanently enabled, even
\r
1750 when the RTOS kernel is in a critical section, but cannot make any calls to
\r
1751 FreeRTOS API functions. If configASSERT() is defined in FreeRTOSConfig.h
\r
1752 then portASSERT_IF_INTERRUPT_PRIORITY_INVALID() will result in an assertion
\r
1753 failure if a FreeRTOS API function is called from an interrupt that has been
\r
1754 assigned a priority above the configured maximum system call priority.
\r
1755 Only FreeRTOS functions that end in FromISR can be called from interrupts
\r
1756 that have been assigned a priority at or (logically) below the maximum
\r
1757 system call interrupt priority. FreeRTOS maintains a separate interrupt
\r
1758 safe API to ensure interrupt entry is as fast and as simple as possible.
\r
1759 More information (albeit Cortex-M specific) is provided on the following
\r
1760 link: http://www.freertos.org/RTOS-Cortex-M3-M4.html */
\r
1761 portASSERT_IF_INTERRUPT_PRIORITY_INVALID();
\r
1763 uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
\r
1765 /* Cannot block in an ISR, so check there is data available. */
\r
1766 if( pxQueue->uxMessagesWaiting > ( UBaseType_t ) 0 )
\r
1768 traceQUEUE_PEEK_FROM_ISR( pxQueue );
\r
1770 /* Remember the read position so it can be reset as nothing is
\r
1771 actually being removed from the queue. */
\r
1772 pcOriginalReadPosition = pxQueue->u.pcReadFrom;
\r
1773 prvCopyDataFromQueue( pxQueue, pvBuffer );
\r
1774 pxQueue->u.pcReadFrom = pcOriginalReadPosition;
\r
1781 traceQUEUE_PEEK_FROM_ISR_FAILED( pxQueue );
\r
1784 portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );
\r
1788 /*-----------------------------------------------------------*/
\r
1790 UBaseType_t uxQueueMessagesWaiting( const QueueHandle_t xQueue )
\r
1792 UBaseType_t uxReturn;
\r
1794 configASSERT( xQueue );
\r
1796 taskENTER_CRITICAL();
\r
1798 uxReturn = ( ( Queue_t * ) xQueue )->uxMessagesWaiting;
\r
1800 taskEXIT_CRITICAL();
\r
1803 } /*lint !e818 Pointer cannot be declared const as xQueue is a typedef not pointer. */
\r
1804 /*-----------------------------------------------------------*/
\r
1806 UBaseType_t uxQueueSpacesAvailable( const QueueHandle_t xQueue )
\r
1808 UBaseType_t uxReturn;
\r
1811 pxQueue = ( Queue_t * ) xQueue;
\r
1812 configASSERT( pxQueue );
\r
1814 taskENTER_CRITICAL();
\r
1816 uxReturn = pxQueue->uxLength - pxQueue->uxMessagesWaiting;
\r
1818 taskEXIT_CRITICAL();
\r
1821 } /*lint !e818 Pointer cannot be declared const as xQueue is a typedef not pointer. */
\r
1822 /*-----------------------------------------------------------*/
\r
1824 UBaseType_t uxQueueMessagesWaitingFromISR( const QueueHandle_t xQueue )
\r
1826 UBaseType_t uxReturn;
\r
1828 configASSERT( xQueue );
\r
1830 uxReturn = ( ( Queue_t * ) xQueue )->uxMessagesWaiting;
\r
1833 } /*lint !e818 Pointer cannot be declared const as xQueue is a typedef not pointer. */
\r
1834 /*-----------------------------------------------------------*/
\r
1836 void vQueueDelete( QueueHandle_t xQueue )
\r
1838 Queue_t * const pxQueue = ( Queue_t * ) xQueue;
\r
1840 configASSERT( pxQueue );
\r
1842 traceQUEUE_DELETE( pxQueue );
\r
1843 #if ( configQUEUE_REGISTRY_SIZE > 0 )
\r
1845 vQueueUnregisterQueue( pxQueue );
\r
1849 #if( configSUPPORT_STATIC_ALLOCATION == 0 )
\r
1851 /* The queue and the queue storage area will have been dynamically
\r
1852 allocated in one go. */
\r
1853 vPortFree( pxQueue );
\r
1857 if( ( pxQueue->ucStaticAllocationFlags & queueSTATICALLY_ALLOCATED_STORAGE ) == 0 )
\r
1859 /* The queue storage area was dynamically allocated, so must be
\r
1861 vPortFree( pxQueue->pcHead );
\r
1864 if( ( pxQueue->ucStaticAllocationFlags & queueSTATICALLY_ALLOCATED_QUEUE_STRUCT ) == 0 )
\r
1866 /* The queue structure was dynamically allocated, so must be
\r
1868 vPortFree( pxQueue );
\r
1873 /*-----------------------------------------------------------*/
\r
1875 #if ( configUSE_TRACE_FACILITY == 1 )
\r
1877 UBaseType_t uxQueueGetQueueNumber( QueueHandle_t xQueue )
\r
1879 return ( ( Queue_t * ) xQueue )->uxQueueNumber;
\r
1882 #endif /* configUSE_TRACE_FACILITY */
\r
1883 /*-----------------------------------------------------------*/
\r
1885 #if ( configUSE_TRACE_FACILITY == 1 )
\r
1887 void vQueueSetQueueNumber( QueueHandle_t xQueue, UBaseType_t uxQueueNumber )
\r
1889 ( ( Queue_t * ) xQueue )->uxQueueNumber = uxQueueNumber;
\r
1892 #endif /* configUSE_TRACE_FACILITY */
\r
1893 /*-----------------------------------------------------------*/
\r
1895 #if ( configUSE_TRACE_FACILITY == 1 )
\r
1897 uint8_t ucQueueGetQueueType( QueueHandle_t xQueue )
\r
1899 return ( ( Queue_t * ) xQueue )->ucQueueType;
\r
1902 #endif /* configUSE_TRACE_FACILITY */
\r
1903 /*-----------------------------------------------------------*/
\r
1905 static BaseType_t prvCopyDataToQueue( Queue_t * const pxQueue, const void *pvItemToQueue, const BaseType_t xPosition )
\r
1907 BaseType_t xReturn = pdFALSE;
\r
1909 if( pxQueue->uxItemSize == ( UBaseType_t ) 0 )
\r
1911 #if ( configUSE_MUTEXES == 1 )
\r
1913 if( pxQueue->uxQueueType == queueQUEUE_IS_MUTEX )
\r
1915 /* The mutex is no longer being held. */
\r
1916 xReturn = xTaskPriorityDisinherit( ( void * ) pxQueue->pxMutexHolder );
\r
1917 pxQueue->pxMutexHolder = NULL;
\r
1921 mtCOVERAGE_TEST_MARKER();
\r
1924 #endif /* configUSE_MUTEXES */
\r
1926 else if( xPosition == queueSEND_TO_BACK )
\r
1928 ( void ) memcpy( ( void * ) pxQueue->pcWriteTo, pvItemToQueue, ( size_t ) pxQueue->uxItemSize ); /*lint !e961 !e418 MISRA exception as the casts are only redundant for some ports, plus previous logic ensures a null pointer can only be passed to memcpy() if the copy size is 0. */
\r
1929 pxQueue->pcWriteTo += pxQueue->uxItemSize;
\r
1930 if( pxQueue->pcWriteTo >= pxQueue->pcTail ) /*lint !e946 MISRA exception justified as comparison of pointers is the cleanest solution. */
\r
1932 pxQueue->pcWriteTo = pxQueue->pcHead;
\r
1936 mtCOVERAGE_TEST_MARKER();
\r
1941 ( void ) memcpy( ( void * ) pxQueue->u.pcReadFrom, pvItemToQueue, ( size_t ) pxQueue->uxItemSize ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */
\r
1942 pxQueue->u.pcReadFrom -= pxQueue->uxItemSize;
\r
1943 if( pxQueue->u.pcReadFrom < pxQueue->pcHead ) /*lint !e946 MISRA exception justified as comparison of pointers is the cleanest solution. */
\r
1945 pxQueue->u.pcReadFrom = ( pxQueue->pcTail - pxQueue->uxItemSize );
\r
1949 mtCOVERAGE_TEST_MARKER();
\r
1952 if( xPosition == queueOVERWRITE )
\r
1954 if( pxQueue->uxMessagesWaiting > ( UBaseType_t ) 0 )
\r
1956 /* An item is not being added but overwritten, so subtract
\r
1957 one from the recorded number of items in the queue so when
\r
1958 one is added again below the number of recorded items remains
\r
1960 --( pxQueue->uxMessagesWaiting );
\r
1964 mtCOVERAGE_TEST_MARKER();
\r
1969 mtCOVERAGE_TEST_MARKER();
\r
1973 ++( pxQueue->uxMessagesWaiting );
\r
1977 /*-----------------------------------------------------------*/
\r
1979 static void prvCopyDataFromQueue( Queue_t * const pxQueue, void * const pvBuffer )
\r
1981 if( pxQueue->uxItemSize != ( UBaseType_t ) 0 )
\r
1983 pxQueue->u.pcReadFrom += pxQueue->uxItemSize;
\r
1984 if( pxQueue->u.pcReadFrom >= pxQueue->pcTail ) /*lint !e946 MISRA exception justified as use of the relational operator is the cleanest solutions. */
\r
1986 pxQueue->u.pcReadFrom = pxQueue->pcHead;
\r
1990 mtCOVERAGE_TEST_MARKER();
\r
1992 ( void ) memcpy( ( void * ) pvBuffer, ( void * ) pxQueue->u.pcReadFrom, ( size_t ) pxQueue->uxItemSize ); /*lint !e961 !e418 MISRA exception as the casts are only redundant for some ports. Also previous logic ensures a null pointer can only be passed to memcpy() when the count is 0. */
\r
1995 /*-----------------------------------------------------------*/
\r
1997 static void prvUnlockQueue( Queue_t * const pxQueue )
\r
1999 /* THIS FUNCTION MUST BE CALLED WITH THE SCHEDULER SUSPENDED. */
\r
2001 /* The lock counts contains the number of extra data items placed or
\r
2002 removed from the queue while the queue was locked. When a queue is
\r
2003 locked items can be added or removed, but the event lists cannot be
\r
2005 taskENTER_CRITICAL();
\r
2007 /* See if data was added to the queue while it was locked. */
\r
2008 while( pxQueue->xTxLock > queueLOCKED_UNMODIFIED )
\r
2010 /* Data was posted while the queue was locked. Are any tasks
\r
2011 blocked waiting for data to become available? */
\r
2012 #if ( configUSE_QUEUE_SETS == 1 )
\r
2014 if( pxQueue->pxQueueSetContainer != NULL )
\r
2016 if( prvNotifyQueueSetContainer( pxQueue, queueSEND_TO_BACK ) == pdTRUE )
\r
2018 /* The queue is a member of a queue set, and posting to
\r
2019 the queue set caused a higher priority task to unblock.
\r
2020 A context switch is required. */
\r
2021 vTaskMissedYield();
\r
2025 mtCOVERAGE_TEST_MARKER();
\r
2030 /* Tasks that are removed from the event list will get added to
\r
2031 the pending ready list as the scheduler is still suspended. */
\r
2032 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
\r
2034 if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )
\r
2036 /* The task waiting has a higher priority so record that a
\r
2037 context switch is required. */
\r
2038 vTaskMissedYield();
\r
2042 mtCOVERAGE_TEST_MARKER();
\r
2051 #else /* configUSE_QUEUE_SETS */
\r
2053 /* Tasks that are removed from the event list will get added to
\r
2054 the pending ready list as the scheduler is still suspended. */
\r
2055 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
\r
2057 if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )
\r
2059 /* The task waiting has a higher priority so record that
\r
2060 a context switch is required. */
\r
2061 vTaskMissedYield();
\r
2065 mtCOVERAGE_TEST_MARKER();
\r
2073 #endif /* configUSE_QUEUE_SETS */
\r
2075 --( pxQueue->xTxLock );
\r
2078 pxQueue->xTxLock = queueUNLOCKED;
\r
2080 taskEXIT_CRITICAL();
\r
2082 /* Do the same for the Rx lock. */
\r
2083 taskENTER_CRITICAL();
\r
2085 while( pxQueue->xRxLock > queueLOCKED_UNMODIFIED )
\r
2087 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) == pdFALSE )
\r
2089 if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) != pdFALSE )
\r
2091 vTaskMissedYield();
\r
2095 mtCOVERAGE_TEST_MARKER();
\r
2098 --( pxQueue->xRxLock );
\r
2106 pxQueue->xRxLock = queueUNLOCKED;
\r
2108 taskEXIT_CRITICAL();
\r
2110 /*-----------------------------------------------------------*/
\r
2112 static BaseType_t prvIsQueueEmpty( const Queue_t *pxQueue )
\r
2114 BaseType_t xReturn;
\r
2116 taskENTER_CRITICAL();
\r
2118 if( pxQueue->uxMessagesWaiting == ( UBaseType_t ) 0 )
\r
2124 xReturn = pdFALSE;
\r
2127 taskEXIT_CRITICAL();
\r
2131 /*-----------------------------------------------------------*/
\r
2133 BaseType_t xQueueIsQueueEmptyFromISR( const QueueHandle_t xQueue )
\r
2135 BaseType_t xReturn;
\r
2137 configASSERT( xQueue );
\r
2138 if( ( ( Queue_t * ) xQueue )->uxMessagesWaiting == ( UBaseType_t ) 0 )
\r
2144 xReturn = pdFALSE;
\r
2148 } /*lint !e818 xQueue could not be pointer to const because it is a typedef. */
\r
2149 /*-----------------------------------------------------------*/
\r
2151 static BaseType_t prvIsQueueFull( const Queue_t *pxQueue )
\r
2153 BaseType_t xReturn;
\r
2155 taskENTER_CRITICAL();
\r
2157 if( pxQueue->uxMessagesWaiting == pxQueue->uxLength )
\r
2163 xReturn = pdFALSE;
\r
2166 taskEXIT_CRITICAL();
\r
2170 /*-----------------------------------------------------------*/
\r
2172 BaseType_t xQueueIsQueueFullFromISR( const QueueHandle_t xQueue )
\r
2174 BaseType_t xReturn;
\r
2176 configASSERT( xQueue );
\r
2177 if( ( ( Queue_t * ) xQueue )->uxMessagesWaiting == ( ( Queue_t * ) xQueue )->uxLength )
\r
2183 xReturn = pdFALSE;
\r
2187 } /*lint !e818 xQueue could not be pointer to const because it is a typedef. */
\r
2188 /*-----------------------------------------------------------*/
\r
2190 #if ( configUSE_CO_ROUTINES == 1 )
\r
2192 BaseType_t xQueueCRSend( QueueHandle_t xQueue, const void *pvItemToQueue, TickType_t xTicksToWait )
\r
2194 BaseType_t xReturn;
\r
2195 Queue_t * const pxQueue = ( Queue_t * ) xQueue;
\r
2197 /* If the queue is already full we may have to block. A critical section
\r
2198 is required to prevent an interrupt removing something from the queue
\r
2199 between the check to see if the queue is full and blocking on the queue. */
\r
2200 portDISABLE_INTERRUPTS();
\r
2202 if( prvIsQueueFull( pxQueue ) != pdFALSE )
\r
2204 /* The queue is full - do we want to block or just leave without
\r
2206 if( xTicksToWait > ( TickType_t ) 0 )
\r
2208 /* As this is called from a coroutine we cannot block directly, but
\r
2209 return indicating that we need to block. */
\r
2210 vCoRoutineAddToDelayedList( xTicksToWait, &( pxQueue->xTasksWaitingToSend ) );
\r
2211 portENABLE_INTERRUPTS();
\r
2212 return errQUEUE_BLOCKED;
\r
2216 portENABLE_INTERRUPTS();
\r
2217 return errQUEUE_FULL;
\r
2221 portENABLE_INTERRUPTS();
\r
2223 portDISABLE_INTERRUPTS();
\r
2225 if( pxQueue->uxMessagesWaiting < pxQueue->uxLength )
\r
2227 /* There is room in the queue, copy the data into the queue. */
\r
2228 prvCopyDataToQueue( pxQueue, pvItemToQueue, queueSEND_TO_BACK );
\r
2231 /* Were any co-routines waiting for data to become available? */
\r
2232 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
\r
2234 /* In this instance the co-routine could be placed directly
\r
2235 into the ready list as we are within a critical section.
\r
2236 Instead the same pending ready list mechanism is used as if
\r
2237 the event were caused from within an interrupt. */
\r
2238 if( xCoRoutineRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )
\r
2240 /* The co-routine waiting has a higher priority so record
\r
2241 that a yield might be appropriate. */
\r
2242 xReturn = errQUEUE_YIELD;
\r
2246 mtCOVERAGE_TEST_MARKER();
\r
2251 mtCOVERAGE_TEST_MARKER();
\r
2256 xReturn = errQUEUE_FULL;
\r
2259 portENABLE_INTERRUPTS();
\r
2264 #endif /* configUSE_CO_ROUTINES */
\r
2265 /*-----------------------------------------------------------*/
\r
2267 #if ( configUSE_CO_ROUTINES == 1 )
\r
2269 BaseType_t xQueueCRReceive( QueueHandle_t xQueue, void *pvBuffer, TickType_t xTicksToWait )
\r
2271 BaseType_t xReturn;
\r
2272 Queue_t * const pxQueue = ( Queue_t * ) xQueue;
\r
2274 /* If the queue is already empty we may have to block. A critical section
\r
2275 is required to prevent an interrupt adding something to the queue
\r
2276 between the check to see if the queue is empty and blocking on the queue. */
\r
2277 portDISABLE_INTERRUPTS();
\r
2279 if( pxQueue->uxMessagesWaiting == ( UBaseType_t ) 0 )
\r
2281 /* There are no messages in the queue, do we want to block or just
\r
2282 leave with nothing? */
\r
2283 if( xTicksToWait > ( TickType_t ) 0 )
\r
2285 /* As this is a co-routine we cannot block directly, but return
\r
2286 indicating that we need to block. */
\r
2287 vCoRoutineAddToDelayedList( xTicksToWait, &( pxQueue->xTasksWaitingToReceive ) );
\r
2288 portENABLE_INTERRUPTS();
\r
2289 return errQUEUE_BLOCKED;
\r
2293 portENABLE_INTERRUPTS();
\r
2294 return errQUEUE_FULL;
\r
2299 mtCOVERAGE_TEST_MARKER();
\r
2302 portENABLE_INTERRUPTS();
\r
2304 portDISABLE_INTERRUPTS();
\r
2306 if( pxQueue->uxMessagesWaiting > ( UBaseType_t ) 0 )
\r
2308 /* Data is available from the queue. */
\r
2309 pxQueue->u.pcReadFrom += pxQueue->uxItemSize;
\r
2310 if( pxQueue->u.pcReadFrom >= pxQueue->pcTail )
\r
2312 pxQueue->u.pcReadFrom = pxQueue->pcHead;
\r
2316 mtCOVERAGE_TEST_MARKER();
\r
2318 --( pxQueue->uxMessagesWaiting );
\r
2319 ( void ) memcpy( ( void * ) pvBuffer, ( void * ) pxQueue->u.pcReadFrom, ( unsigned ) pxQueue->uxItemSize );
\r
2323 /* Were any co-routines waiting for space to become available? */
\r
2324 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) == pdFALSE )
\r
2326 /* In this instance the co-routine could be placed directly
\r
2327 into the ready list as we are within a critical section.
\r
2328 Instead the same pending ready list mechanism is used as if
\r
2329 the event were caused from within an interrupt. */
\r
2330 if( xCoRoutineRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) != pdFALSE )
\r
2332 xReturn = errQUEUE_YIELD;
\r
2336 mtCOVERAGE_TEST_MARKER();
\r
2341 mtCOVERAGE_TEST_MARKER();
\r
2349 portENABLE_INTERRUPTS();
\r
2354 #endif /* configUSE_CO_ROUTINES */
\r
2355 /*-----------------------------------------------------------*/
\r
2357 #if ( configUSE_CO_ROUTINES == 1 )
\r
2359 BaseType_t xQueueCRSendFromISR( QueueHandle_t xQueue, const void *pvItemToQueue, BaseType_t xCoRoutinePreviouslyWoken )
\r
2361 Queue_t * const pxQueue = ( Queue_t * ) xQueue;
\r
2363 /* Cannot block within an ISR so if there is no space on the queue then
\r
2364 exit without doing anything. */
\r
2365 if( pxQueue->uxMessagesWaiting < pxQueue->uxLength )
\r
2367 prvCopyDataToQueue( pxQueue, pvItemToQueue, queueSEND_TO_BACK );
\r
2369 /* We only want to wake one co-routine per ISR, so check that a
\r
2370 co-routine has not already been woken. */
\r
2371 if( xCoRoutinePreviouslyWoken == pdFALSE )
\r
2373 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
\r
2375 if( xCoRoutineRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )
\r
2381 mtCOVERAGE_TEST_MARKER();
\r
2386 mtCOVERAGE_TEST_MARKER();
\r
2391 mtCOVERAGE_TEST_MARKER();
\r
2396 mtCOVERAGE_TEST_MARKER();
\r
2399 return xCoRoutinePreviouslyWoken;
\r
2402 #endif /* configUSE_CO_ROUTINES */
\r
2403 /*-----------------------------------------------------------*/
\r
2405 #if ( configUSE_CO_ROUTINES == 1 )
\r
2407 BaseType_t xQueueCRReceiveFromISR( QueueHandle_t xQueue, void *pvBuffer, BaseType_t *pxCoRoutineWoken )
\r
2409 BaseType_t xReturn;
\r
2410 Queue_t * const pxQueue = ( Queue_t * ) xQueue;
\r
2412 /* We cannot block from an ISR, so check there is data available. If
\r
2413 not then just leave without doing anything. */
\r
2414 if( pxQueue->uxMessagesWaiting > ( UBaseType_t ) 0 )
\r
2416 /* Copy the data from the queue. */
\r
2417 pxQueue->u.pcReadFrom += pxQueue->uxItemSize;
\r
2418 if( pxQueue->u.pcReadFrom >= pxQueue->pcTail )
\r
2420 pxQueue->u.pcReadFrom = pxQueue->pcHead;
\r
2424 mtCOVERAGE_TEST_MARKER();
\r
2426 --( pxQueue->uxMessagesWaiting );
\r
2427 ( void ) memcpy( ( void * ) pvBuffer, ( void * ) pxQueue->u.pcReadFrom, ( unsigned ) pxQueue->uxItemSize );
\r
2429 if( ( *pxCoRoutineWoken ) == pdFALSE )
\r
2431 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) == pdFALSE )
\r
2433 if( xCoRoutineRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) != pdFALSE )
\r
2435 *pxCoRoutineWoken = pdTRUE;
\r
2439 mtCOVERAGE_TEST_MARKER();
\r
2444 mtCOVERAGE_TEST_MARKER();
\r
2449 mtCOVERAGE_TEST_MARKER();
\r
2462 #endif /* configUSE_CO_ROUTINES */
\r
2463 /*-----------------------------------------------------------*/
\r
2465 #if ( configQUEUE_REGISTRY_SIZE > 0 )
\r
2467 void vQueueAddToRegistry( QueueHandle_t xQueue, const char *pcQueueName ) /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
\r
2471 /* See if there is an empty space in the registry. A NULL name denotes
\r
2473 for( ux = ( UBaseType_t ) 0U; ux < ( UBaseType_t ) configQUEUE_REGISTRY_SIZE; ux++ )
\r
2475 if( xQueueRegistry[ ux ].pcQueueName == NULL )
\r
2477 /* Store the information on this queue. */
\r
2478 xQueueRegistry[ ux ].pcQueueName = pcQueueName;
\r
2479 xQueueRegistry[ ux ].xHandle = xQueue;
\r
2481 traceQUEUE_REGISTRY_ADD( xQueue, pcQueueName );
\r
2486 mtCOVERAGE_TEST_MARKER();
\r
2491 #endif /* configQUEUE_REGISTRY_SIZE */
\r
2492 /*-----------------------------------------------------------*/
\r
2494 #if ( configQUEUE_REGISTRY_SIZE > 0 )
\r
2496 const char *pcQueueGetQueueName( QueueHandle_t xQueue )
\r
2499 const char *pcReturn = NULL;
\r
2501 /* Note there is nothing here to protect against another task adding or
\r
2502 removing entries from the registry while it is being searched. */
\r
2503 for( ux = ( UBaseType_t ) 0U; ux < ( UBaseType_t ) configQUEUE_REGISTRY_SIZE; ux++ )
\r
2505 if( xQueueRegistry[ ux ].xHandle == xQueue )
\r
2507 pcReturn = xQueueRegistry[ ux ].pcQueueName;
\r
2512 mtCOVERAGE_TEST_MARKER();
\r
2519 #endif /* configQUEUE_REGISTRY_SIZE */
\r
2520 /*-----------------------------------------------------------*/
\r
2522 #if ( configQUEUE_REGISTRY_SIZE > 0 )
\r
2524 void vQueueUnregisterQueue( QueueHandle_t xQueue )
\r
2528 /* See if the handle of the queue being unregistered in actually in the
\r
2530 for( ux = ( UBaseType_t ) 0U; ux < ( UBaseType_t ) configQUEUE_REGISTRY_SIZE; ux++ )
\r
2532 if( xQueueRegistry[ ux ].xHandle == xQueue )
\r
2534 /* Set the name to NULL to show that this slot if free again. */
\r
2535 xQueueRegistry[ ux ].pcQueueName = NULL;
\r
2537 /* Set the handle to NULL to ensure the same queue handle cannot
\r
2538 appear in the registry twice if it is added, removed, then
\r
2540 xQueueRegistry[ ux ].xHandle = ( QueueHandle_t ) 0;
\r
2545 mtCOVERAGE_TEST_MARKER();
\r
2549 } /*lint !e818 xQueue could not be pointer to const because it is a typedef. */
\r
2551 #endif /* configQUEUE_REGISTRY_SIZE */
\r
2552 /*-----------------------------------------------------------*/
\r
2554 #if ( configUSE_TIMERS == 1 )
\r
2556 void vQueueWaitForMessageRestricted( QueueHandle_t xQueue, TickType_t xTicksToWait, const BaseType_t xWaitIndefinitely )
\r
2558 Queue_t * const pxQueue = ( Queue_t * ) xQueue;
\r
2560 /* This function should not be called by application code hence the
\r
2561 'Restricted' in its name. It is not part of the public API. It is
\r
2562 designed for use by kernel code, and has special calling requirements.
\r
2563 It can result in vListInsert() being called on a list that can only
\r
2564 possibly ever have one item in it, so the list will be fast, but even
\r
2565 so it should be called with the scheduler locked and not from a critical
\r
2568 /* Only do anything if there are no messages in the queue. This function
\r
2569 will not actually cause the task to block, just place it on a blocked
\r
2570 list. It will not block until the scheduler is unlocked - at which
\r
2571 time a yield will be performed. If an item is added to the queue while
\r
2572 the queue is locked, and the calling task blocks on the queue, then the
\r
2573 calling task will be immediately unblocked when the queue is unlocked. */
\r
2574 prvLockQueue( pxQueue );
\r
2575 if( pxQueue->uxMessagesWaiting == ( UBaseType_t ) 0U )
\r
2577 /* There is nothing in the queue, block for the specified period. */
\r
2578 vTaskPlaceOnEventListRestricted( &( pxQueue->xTasksWaitingToReceive ), xTicksToWait, xWaitIndefinitely );
\r
2582 mtCOVERAGE_TEST_MARKER();
\r
2584 prvUnlockQueue( pxQueue );
\r
2587 #endif /* configUSE_TIMERS */
\r
2588 /*-----------------------------------------------------------*/
\r
2590 #if ( configUSE_QUEUE_SETS == 1 )
\r
2592 QueueSetHandle_t xQueueCreateSet( const UBaseType_t uxEventQueueLength )
\r
2594 QueueSetHandle_t pxQueue;
\r
2596 pxQueue = xQueueGenericCreate( uxEventQueueLength, sizeof( Queue_t * ), NULL, NULL, queueQUEUE_TYPE_SET );
\r
2601 #endif /* configUSE_QUEUE_SETS */
\r
2602 /*-----------------------------------------------------------*/
\r
2604 #if ( configUSE_QUEUE_SETS == 1 )
\r
2606 BaseType_t xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore, QueueSetHandle_t xQueueSet )
\r
2608 BaseType_t xReturn;
\r
2610 taskENTER_CRITICAL();
\r
2612 if( ( ( Queue_t * ) xQueueOrSemaphore )->pxQueueSetContainer != NULL )
\r
2614 /* Cannot add a queue/semaphore to more than one queue set. */
\r
2617 else if( ( ( Queue_t * ) xQueueOrSemaphore )->uxMessagesWaiting != ( UBaseType_t ) 0 )
\r
2619 /* Cannot add a queue/semaphore to a queue set if there are already
\r
2620 items in the queue/semaphore. */
\r
2625 ( ( Queue_t * ) xQueueOrSemaphore )->pxQueueSetContainer = xQueueSet;
\r
2629 taskEXIT_CRITICAL();
\r
2634 #endif /* configUSE_QUEUE_SETS */
\r
2635 /*-----------------------------------------------------------*/
\r
2637 #if ( configUSE_QUEUE_SETS == 1 )
\r
2639 BaseType_t xQueueRemoveFromSet( QueueSetMemberHandle_t xQueueOrSemaphore, QueueSetHandle_t xQueueSet )
\r
2641 BaseType_t xReturn;
\r
2642 Queue_t * const pxQueueOrSemaphore = ( Queue_t * ) xQueueOrSemaphore;
\r
2644 if( pxQueueOrSemaphore->pxQueueSetContainer != xQueueSet )
\r
2646 /* The queue was not a member of the set. */
\r
2649 else if( pxQueueOrSemaphore->uxMessagesWaiting != ( UBaseType_t ) 0 )
\r
2651 /* It is dangerous to remove a queue from a set when the queue is
\r
2652 not empty because the queue set will still hold pending events for
\r
2658 taskENTER_CRITICAL();
\r
2660 /* The queue is no longer contained in the set. */
\r
2661 pxQueueOrSemaphore->pxQueueSetContainer = NULL;
\r
2663 taskEXIT_CRITICAL();
\r
2668 } /*lint !e818 xQueueSet could not be declared as pointing to const as it is a typedef. */
\r
2670 #endif /* configUSE_QUEUE_SETS */
\r
2671 /*-----------------------------------------------------------*/
\r
2673 #if ( configUSE_QUEUE_SETS == 1 )
\r
2675 QueueSetMemberHandle_t xQueueSelectFromSet( QueueSetHandle_t xQueueSet, TickType_t const xTicksToWait )
\r
2677 QueueSetMemberHandle_t xReturn = NULL;
\r
2679 ( void ) xQueueGenericReceive( ( QueueHandle_t ) xQueueSet, &xReturn, xTicksToWait, pdFALSE ); /*lint !e961 Casting from one typedef to another is not redundant. */
\r
2683 #endif /* configUSE_QUEUE_SETS */
\r
2684 /*-----------------------------------------------------------*/
\r
2686 #if ( configUSE_QUEUE_SETS == 1 )
\r
2688 QueueSetMemberHandle_t xQueueSelectFromSetFromISR( QueueSetHandle_t xQueueSet )
\r
2690 QueueSetMemberHandle_t xReturn = NULL;
\r
2692 ( void ) xQueueReceiveFromISR( ( QueueHandle_t ) xQueueSet, &xReturn, NULL ); /*lint !e961 Casting from one typedef to another is not redundant. */
\r
2696 #endif /* configUSE_QUEUE_SETS */
\r
2697 /*-----------------------------------------------------------*/
\r
2699 #if ( configUSE_QUEUE_SETS == 1 )
\r
2701 static BaseType_t prvNotifyQueueSetContainer( const Queue_t * const pxQueue, const BaseType_t xCopyPosition )
\r
2703 Queue_t *pxQueueSetContainer = pxQueue->pxQueueSetContainer;
\r
2704 BaseType_t xReturn = pdFALSE;
\r
2706 /* This function must be called form a critical section. */
\r
2708 configASSERT( pxQueueSetContainer );
\r
2709 configASSERT( pxQueueSetContainer->uxMessagesWaiting < pxQueueSetContainer->uxLength );
\r
2711 if( pxQueueSetContainer->uxMessagesWaiting < pxQueueSetContainer->uxLength )
\r
2713 traceQUEUE_SEND( pxQueueSetContainer );
\r
2715 /* The data copied is the handle of the queue that contains data. */
\r
2716 xReturn = prvCopyDataToQueue( pxQueueSetContainer, &pxQueue, xCopyPosition );
\r
2718 if( pxQueueSetContainer->xTxLock == queueUNLOCKED )
\r
2720 if( listLIST_IS_EMPTY( &( pxQueueSetContainer->xTasksWaitingToReceive ) ) == pdFALSE )
\r
2722 if( xTaskRemoveFromEventList( &( pxQueueSetContainer->xTasksWaitingToReceive ) ) != pdFALSE )
\r
2724 /* The task waiting has a higher priority. */
\r
2729 mtCOVERAGE_TEST_MARKER();
\r
2734 mtCOVERAGE_TEST_MARKER();
\r
2739 ( pxQueueSetContainer->xTxLock )++;
\r
2744 mtCOVERAGE_TEST_MARKER();
\r
2750 #endif /* configUSE_QUEUE_SETS */
\r
projects / freertos / blob