2 * FreeRTOS Kernel V10.3.1
\r
3 * Copyright (C) 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
\r
5 * Permission is hereby granted, free of charge, to any person obtaining a copy of
\r
6 * this software and associated documentation files (the "Software"), to deal in
\r
7 * the Software without restriction, including without limitation the rights to
\r
8 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
\r
9 * the Software, and to permit persons to whom the Software is furnished to do so,
\r
10 * subject to the following conditions:
\r
12 * The above copyright notice and this permission notice shall be included in all
\r
13 * copies or substantial portions of the Software.
\r
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
\r
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
\r
17 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
\r
18 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
\r
19 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
\r
20 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
\r
22 * http://www.FreeRTOS.org
\r
23 * http://aws.amazon.com/freertos
\r
25 * 1 tab == 4 spaces!
\r
31 /* Defining MPU_WRAPPERS_INCLUDED_FROM_API_FILE prevents task.h from redefining
\r
32 * all the API functions to use the MPU wrappers. That should only be done when
\r
33 * task.h is included from an application file. */
\r
34 #define MPU_WRAPPERS_INCLUDED_FROM_API_FILE
\r
36 #include "FreeRTOS.h"
\r
40 #if ( configUSE_CO_ROUTINES == 1 )
\r
41 #include "croutine.h"
\r
44 /* Lint e9021, e961 and e750 are suppressed as a MISRA exception justified
\r
45 * because the MPU ports require MPU_WRAPPERS_INCLUDED_FROM_API_FILE to be defined
\r
46 * for the header files above, but not in this file, in order to generate the
\r
47 * correct privileged Vs unprivileged linkage and placement. */
\r
48 #undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE /*lint !e961 !e750 !e9021. */
\r
51 /* Constants used with the cRxLock and cTxLock structure members. */
\r
52 #define queueUNLOCKED ( ( int8_t ) -1 )
\r
53 #define queueLOCKED_UNMODIFIED ( ( int8_t ) 0 )
\r
54 #define queueINT8_MAX ( ( int8_t ) 127 )
\r
56 /* When the Queue_t structure is used to represent a base queue its pcHead and
\r
57 * pcTail members are used as pointers into the queue storage area. When the
\r
58 * Queue_t structure is used to represent a mutex pcHead and pcTail pointers are
\r
59 * not necessary, and the pcHead pointer is set to NULL to indicate that the
\r
60 * structure instead holds a pointer to the mutex holder (if any). Map alternative
\r
61 * names to the pcHead and structure member to ensure the readability of the code
\r
62 * is maintained. The QueuePointers_t and SemaphoreData_t types are used to form
\r
63 * a union as their usage is mutually exclusive dependent on what the queue is
\r
64 * being used for. */
\r
65 #define uxQueueType pcHead
\r
66 #define queueQUEUE_IS_MUTEX NULL
\r
68 typedef struct QueuePointers
\r
70 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
71 int8_t * pcReadFrom; /*< Points to the last place that a queued item was read from when the structure is used as a queue. */
\r
74 typedef struct SemaphoreData
\r
76 TaskHandle_t xMutexHolder; /*< The handle of the task that holds the mutex. */
\r
77 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
80 /* Semaphores do not actually store or copy data, so have an item size of
\r
82 #define queueSEMAPHORE_QUEUE_ITEM_LENGTH ( ( UBaseType_t ) 0 )
\r
83 #define queueMUTEX_GIVE_BLOCK_TIME ( ( TickType_t ) 0U )
\r
85 #if ( configUSE_PREEMPTION == 0 )
\r
87 /* If the cooperative scheduler is being used then a yield should not be
\r
88 * performed just because a higher priority task has been woken. */
\r
89 #define queueYIELD_IF_USING_PREEMPTION()
\r
91 #define queueYIELD_IF_USING_PREEMPTION() portYIELD_WITHIN_API()
\r
95 * Definition of the queue used by the scheduler.
\r
96 * Items are queued by copy, not reference. See the following link for the
\r
97 * rationale: https://www.freertos.org/Embedded-RTOS-Queues.html
\r
99 typedef struct QueueDefinition /* The old naming convention is used to prevent breaking kernel aware debuggers. */
\r
101 int8_t * pcHead; /*< Points to the beginning of the queue storage area. */
\r
102 int8_t * pcWriteTo; /*< Points to the free next place in the storage area. */
\r
106 QueuePointers_t xQueue; /*< Data required exclusively when this structure is used as a queue. */
\r
107 SemaphoreData_t xSemaphore; /*< Data required exclusively when this structure is used as a semaphore. */
\r
110 List_t xTasksWaitingToSend; /*< List of tasks that are blocked waiting to post onto this queue. Stored in priority order. */
\r
111 List_t xTasksWaitingToReceive; /*< List of tasks that are blocked waiting to read from this queue. Stored in priority order. */
\r
113 volatile UBaseType_t uxMessagesWaiting; /*< The number of items currently in the queue. */
\r
114 UBaseType_t uxLength; /*< The length of the queue defined as the number of items it will hold, not the number of bytes. */
\r
115 UBaseType_t uxItemSize; /*< The size of each items that the queue will hold. */
\r
117 volatile int8_t cRxLock; /*< 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
118 volatile int8_t cTxLock; /*< 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
120 #if ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
\r
121 uint8_t ucStaticallyAllocated; /*< Set to pdTRUE if the memory used by the queue was statically allocated to ensure no attempt is made to free the memory. */
\r
124 #if ( configUSE_QUEUE_SETS == 1 )
\r
125 struct QueueDefinition * pxQueueSetContainer;
\r
128 #if ( configUSE_TRACE_FACILITY == 1 )
\r
129 UBaseType_t uxQueueNumber;
\r
130 uint8_t ucQueueType;
\r
134 /* The old xQUEUE name is maintained above then typedefed to the new Queue_t
\r
135 * name below to enable the use of older kernel aware debuggers. */
\r
136 typedef xQUEUE Queue_t;
\r
138 /*-----------------------------------------------------------*/
\r
141 * The queue registry is just a means for kernel aware debuggers to locate
\r
142 * queue structures. It has no other purpose so is an optional component.
\r
144 #if ( configQUEUE_REGISTRY_SIZE > 0 )
\r
146 /* The type stored within the queue registry array. This allows a name
\r
147 * to be assigned to each queue making kernel aware debugging a little
\r
148 * more user friendly. */
\r
149 typedef struct QUEUE_REGISTRY_ITEM
\r
151 const char * pcQueueName; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
\r
152 QueueHandle_t xHandle;
\r
153 } xQueueRegistryItem;
\r
155 /* The old xQueueRegistryItem name is maintained above then typedefed to the
\r
156 * new xQueueRegistryItem name below to enable the use of older kernel aware
\r
158 typedef xQueueRegistryItem QueueRegistryItem_t;
\r
160 /* The queue registry is simply an array of QueueRegistryItem_t structures.
\r
161 * The pcQueueName member of a structure being NULL is indicative of the
\r
162 * array position being vacant. */
\r
163 PRIVILEGED_DATA QueueRegistryItem_t xQueueRegistry[ configQUEUE_REGISTRY_SIZE ];
\r
165 #endif /* configQUEUE_REGISTRY_SIZE */
\r
168 * Unlocks a queue locked by a call to prvLockQueue. Locking a queue does not
\r
169 * prevent an ISR from adding or removing items to the queue, but does prevent
\r
170 * an ISR from removing tasks from the queue event lists. If an ISR finds a
\r
171 * queue is locked it will instead increment the appropriate queue lock count
\r
172 * to indicate that a task may require unblocking. When the queue in unlocked
\r
173 * these lock counts are inspected, and the appropriate action taken.
\r
175 static void prvUnlockQueue( Queue_t * const pxQueue ) PRIVILEGED_FUNCTION;
\r
178 * Uses a critical section to determine if there is any data in a queue.
\r
180 * @return pdTRUE if the queue contains no items, otherwise pdFALSE.
\r
182 static BaseType_t prvIsQueueEmpty( const Queue_t * pxQueue ) PRIVILEGED_FUNCTION;
\r
185 * Uses a critical section to determine if there is any space in a queue.
\r
187 * @return pdTRUE if there is no space, otherwise pdFALSE;
\r
189 static BaseType_t prvIsQueueFull( const Queue_t * pxQueue ) PRIVILEGED_FUNCTION;
\r
192 * Copies an item into the queue, either at the front of the queue or the
\r
193 * back of the queue.
\r
195 static BaseType_t prvCopyDataToQueue( Queue_t * const pxQueue,
\r
196 const void * pvItemToQueue,
\r
197 const BaseType_t xPosition ) PRIVILEGED_FUNCTION;
\r
200 * Copies an item out of a queue.
\r
202 static void prvCopyDataFromQueue( Queue_t * const pxQueue,
\r
203 void * const pvBuffer ) PRIVILEGED_FUNCTION;
\r
205 #if ( configUSE_QUEUE_SETS == 1 )
\r
208 * Checks to see if a queue is a member of a queue set, and if so, notifies
\r
209 * the queue set that the queue contains data.
\r
211 static BaseType_t prvNotifyQueueSetContainer( const Queue_t * const pxQueue ) PRIVILEGED_FUNCTION;
\r
215 * Called after a Queue_t structure has been allocated either statically or
\r
216 * dynamically to fill in the structure's members.
\r
218 static void prvInitialiseNewQueue( const UBaseType_t uxQueueLength,
\r
219 const UBaseType_t uxItemSize,
\r
220 uint8_t * pucQueueStorage,
\r
221 const uint8_t ucQueueType,
\r
222 Queue_t * pxNewQueue ) PRIVILEGED_FUNCTION;
\r
225 * Mutexes are a special type of queue. When a mutex is created, first the
\r
226 * queue is created, then prvInitialiseMutex() is called to configure the queue
\r
229 #if ( configUSE_MUTEXES == 1 )
\r
230 static void prvInitialiseMutex( Queue_t * pxNewQueue ) PRIVILEGED_FUNCTION;
\r
233 #if ( configUSE_MUTEXES == 1 )
\r
236 * If a task waiting for a mutex causes the mutex holder to inherit a
\r
237 * priority, but the waiting task times out, then the holder should
\r
238 * disinherit the priority - but only down to the highest priority of any
\r
239 * other tasks that are waiting for the same mutex. This function returns
\r
242 static UBaseType_t prvGetDisinheritPriorityAfterTimeout( const Queue_t * const pxQueue ) PRIVILEGED_FUNCTION;
\r
244 /*-----------------------------------------------------------*/
\r
247 * Macro to mark a queue as locked. Locking a queue prevents an ISR from
\r
248 * accessing the queue event lists.
\r
250 #define prvLockQueue( pxQueue ) \
\r
251 taskENTER_CRITICAL(); \
\r
253 if( ( pxQueue )->cRxLock == queueUNLOCKED ) \
\r
255 ( pxQueue )->cRxLock = queueLOCKED_UNMODIFIED; \
\r
257 if( ( pxQueue )->cTxLock == queueUNLOCKED ) \
\r
259 ( pxQueue )->cTxLock = queueLOCKED_UNMODIFIED; \
\r
262 taskEXIT_CRITICAL()
\r
263 /*-----------------------------------------------------------*/
\r
265 BaseType_t xQueueGenericReset( QueueHandle_t xQueue,
\r
266 BaseType_t xNewQueue )
\r
268 Queue_t * const pxQueue = xQueue;
\r
270 configASSERT( pxQueue );
\r
272 taskENTER_CRITICAL();
\r
274 pxQueue->u.xQueue.pcTail = pxQueue->pcHead + ( pxQueue->uxLength * pxQueue->uxItemSize ); /*lint !e9016 Pointer arithmetic allowed on char types, especially when it assists conveying intent. */
\r
275 pxQueue->uxMessagesWaiting = ( UBaseType_t ) 0U;
\r
276 pxQueue->pcWriteTo = pxQueue->pcHead;
\r
277 pxQueue->u.xQueue.pcReadFrom = pxQueue->pcHead + ( ( pxQueue->uxLength - 1U ) * pxQueue->uxItemSize ); /*lint !e9016 Pointer arithmetic allowed on char types, especially when it assists conveying intent. */
\r
278 pxQueue->cRxLock = queueUNLOCKED;
\r
279 pxQueue->cTxLock = queueUNLOCKED;
\r
281 if( xNewQueue == pdFALSE )
\r
283 /* If there are tasks blocked waiting to read from the queue, then
\r
284 * the tasks will remain blocked as after this function exits the queue
\r
285 * will still be empty. If there are tasks blocked waiting to write to
\r
286 * the queue, then one should be unblocked as after this function exits
\r
287 * it will be possible to write to it. */
\r
288 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) == pdFALSE )
\r
290 if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) != pdFALSE )
\r
292 queueYIELD_IF_USING_PREEMPTION();
\r
296 mtCOVERAGE_TEST_MARKER();
\r
301 mtCOVERAGE_TEST_MARKER();
\r
306 /* Ensure the event queues start in the correct state. */
\r
307 vListInitialise( &( pxQueue->xTasksWaitingToSend ) );
\r
308 vListInitialise( &( pxQueue->xTasksWaitingToReceive ) );
\r
311 taskEXIT_CRITICAL();
\r
313 /* A value is returned for calling semantic consistency with previous
\r
317 /*-----------------------------------------------------------*/
\r
319 #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
\r
321 QueueHandle_t xQueueGenericCreateStatic( const UBaseType_t uxQueueLength,
\r
322 const UBaseType_t uxItemSize,
\r
323 uint8_t * pucQueueStorage,
\r
324 StaticQueue_t * pxStaticQueue,
\r
325 const uint8_t ucQueueType )
\r
327 Queue_t * pxNewQueue;
\r
329 configASSERT( uxQueueLength > ( UBaseType_t ) 0 );
\r
331 /* The StaticQueue_t structure and the queue storage area must be
\r
333 configASSERT( pxStaticQueue != NULL );
\r
335 /* A queue storage area should be provided if the item size is not 0, and
\r
336 * should not be provided if the item size is 0. */
\r
337 configASSERT( !( ( pucQueueStorage != NULL ) && ( uxItemSize == 0 ) ) );
\r
338 configASSERT( !( ( pucQueueStorage == NULL ) && ( uxItemSize != 0 ) ) );
\r
340 #if ( configASSERT_DEFINED == 1 )
\r
342 /* Sanity check that the size of the structure used to declare a
\r
343 * variable of type StaticQueue_t or StaticSemaphore_t equals the size of
\r
344 * the real queue and semaphore structures. */
\r
345 volatile size_t xSize = sizeof( StaticQueue_t );
\r
346 configASSERT( xSize == sizeof( Queue_t ) );
\r
347 ( void ) xSize; /* Keeps lint quiet when configASSERT() is not defined. */
\r
349 #endif /* configASSERT_DEFINED */
\r
351 /* The address of a statically allocated queue was passed in, use it.
\r
352 * The address of a statically allocated storage area was also passed in
\r
353 * but is already set. */
\r
354 pxNewQueue = ( Queue_t * ) pxStaticQueue; /*lint !e740 !e9087 Unusual cast is ok as the structures are designed to have the same alignment, and the size is checked by an assert. */
\r
356 if( pxNewQueue != NULL )
\r
358 #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
\r
360 /* Queues can be allocated wither statically or dynamically, so
\r
361 * note this queue was allocated statically in case the queue is
\r
362 * later deleted. */
\r
363 pxNewQueue->ucStaticallyAllocated = pdTRUE;
\r
365 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
\r
367 prvInitialiseNewQueue( uxQueueLength, uxItemSize, pucQueueStorage, ucQueueType, pxNewQueue );
\r
371 traceQUEUE_CREATE_FAILED( ucQueueType );
\r
372 mtCOVERAGE_TEST_MARKER();
\r
378 #endif /* configSUPPORT_STATIC_ALLOCATION */
\r
379 /*-----------------------------------------------------------*/
\r
381 #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
\r
383 QueueHandle_t xQueueGenericCreate( const UBaseType_t uxQueueLength,
\r
384 const UBaseType_t uxItemSize,
\r
385 const uint8_t ucQueueType )
\r
387 Queue_t * pxNewQueue;
\r
388 size_t xQueueSizeInBytes;
\r
389 uint8_t * pucQueueStorage;
\r
391 configASSERT( uxQueueLength > ( UBaseType_t ) 0 );
\r
393 /* Allocate enough space to hold the maximum number of items that
\r
394 * can be in the queue at any time. It is valid for uxItemSize to be
\r
395 * zero in the case the queue is used as a semaphore. */
\r
396 xQueueSizeInBytes = ( size_t ) ( uxQueueLength * uxItemSize ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */
\r
398 /* Check for multiplication overflow. */
\r
399 configASSERT( ( uxItemSize == 0 ) || ( uxQueueLength == ( xQueueSizeInBytes / uxItemSize ) ) );
\r
401 /* Allocate the queue and storage area. Justification for MISRA
\r
402 * deviation as follows: pvPortMalloc() always ensures returned memory
\r
403 * blocks are aligned per the requirements of the MCU stack. In this case
\r
404 * pvPortMalloc() must return a pointer that is guaranteed to meet the
\r
405 * alignment requirements of the Queue_t structure - which in this case
\r
406 * is an int8_t *. Therefore, whenever the stack alignment requirements
\r
407 * are greater than or equal to the pointer to char requirements the cast
\r
408 * is safe. In other cases alignment requirements are not strict (one or
\r
410 pxNewQueue = ( Queue_t * ) pvPortMalloc( sizeof( Queue_t ) + xQueueSizeInBytes ); /*lint !e9087 !e9079 see comment above. */
\r
412 if( pxNewQueue != NULL )
\r
414 /* Jump past the queue structure to find the location of the queue
\r
416 pucQueueStorage = ( uint8_t * ) pxNewQueue;
\r
417 pucQueueStorage += sizeof( Queue_t ); /*lint !e9016 Pointer arithmetic allowed on char types, especially when it assists conveying intent. */
\r
419 #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
\r
421 /* Queues can be created either statically or dynamically, so
\r
422 * note this task was created dynamically in case it is later
\r
424 pxNewQueue->ucStaticallyAllocated = pdFALSE;
\r
426 #endif /* configSUPPORT_STATIC_ALLOCATION */
\r
428 prvInitialiseNewQueue( uxQueueLength, uxItemSize, pucQueueStorage, ucQueueType, pxNewQueue );
\r
432 traceQUEUE_CREATE_FAILED( ucQueueType );
\r
433 mtCOVERAGE_TEST_MARKER();
\r
439 #endif /* configSUPPORT_STATIC_ALLOCATION */
\r
440 /*-----------------------------------------------------------*/
\r
442 static void prvInitialiseNewQueue( const UBaseType_t uxQueueLength,
\r
443 const UBaseType_t uxItemSize,
\r
444 uint8_t * pucQueueStorage,
\r
445 const uint8_t ucQueueType,
\r
446 Queue_t * pxNewQueue )
\r
448 /* Remove compiler warnings about unused parameters should
\r
449 * configUSE_TRACE_FACILITY not be set to 1. */
\r
450 ( void ) ucQueueType;
\r
452 if( uxItemSize == ( UBaseType_t ) 0 )
\r
454 /* No RAM was allocated for the queue storage area, but PC head cannot
\r
455 * be set to NULL because NULL is used as a key to say the queue is used as
\r
456 * a mutex. Therefore just set pcHead to point to the queue as a benign
\r
457 * value that is known to be within the memory map. */
\r
458 pxNewQueue->pcHead = ( int8_t * ) pxNewQueue;
\r
462 /* Set the head to the start of the queue storage area. */
\r
463 pxNewQueue->pcHead = ( int8_t * ) pucQueueStorage;
\r
466 /* Initialise the queue members as described where the queue type is
\r
468 pxNewQueue->uxLength = uxQueueLength;
\r
469 pxNewQueue->uxItemSize = uxItemSize;
\r
470 ( void ) xQueueGenericReset( pxNewQueue, pdTRUE );
\r
472 #if ( configUSE_TRACE_FACILITY == 1 )
\r
474 pxNewQueue->ucQueueType = ucQueueType;
\r
476 #endif /* configUSE_TRACE_FACILITY */
\r
478 #if ( configUSE_QUEUE_SETS == 1 )
\r
480 pxNewQueue->pxQueueSetContainer = NULL;
\r
482 #endif /* configUSE_QUEUE_SETS */
\r
484 traceQUEUE_CREATE( pxNewQueue );
\r
486 /*-----------------------------------------------------------*/
\r
488 #if ( configUSE_MUTEXES == 1 )
\r
490 static void prvInitialiseMutex( Queue_t * pxNewQueue )
\r
492 if( pxNewQueue != NULL )
\r
494 /* The queue create function will set all the queue structure members
\r
495 * correctly for a generic queue, but this function is creating a
\r
496 * mutex. Overwrite those members that need to be set differently -
\r
497 * in particular the information required for priority inheritance. */
\r
498 pxNewQueue->u.xSemaphore.xMutexHolder = NULL;
\r
499 pxNewQueue->uxQueueType = queueQUEUE_IS_MUTEX;
\r
501 /* In case this is a recursive mutex. */
\r
502 pxNewQueue->u.xSemaphore.uxRecursiveCallCount = 0;
\r
504 traceCREATE_MUTEX( pxNewQueue );
\r
506 /* Start with the semaphore in the expected state. */
\r
507 ( void ) xQueueGenericSend( pxNewQueue, NULL, ( TickType_t ) 0U, queueSEND_TO_BACK );
\r
511 traceCREATE_MUTEX_FAILED();
\r
515 #endif /* configUSE_MUTEXES */
\r
516 /*-----------------------------------------------------------*/
\r
518 #if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
\r
520 QueueHandle_t xQueueCreateMutex( const uint8_t ucQueueType )
\r
522 QueueHandle_t xNewQueue;
\r
523 const UBaseType_t uxMutexLength = ( UBaseType_t ) 1, uxMutexSize = ( UBaseType_t ) 0;
\r
525 xNewQueue = xQueueGenericCreate( uxMutexLength, uxMutexSize, ucQueueType );
\r
526 prvInitialiseMutex( ( Queue_t * ) xNewQueue );
\r
531 #endif /* configUSE_MUTEXES */
\r
532 /*-----------------------------------------------------------*/
\r
534 #if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
\r
536 QueueHandle_t xQueueCreateMutexStatic( const uint8_t ucQueueType,
\r
537 StaticQueue_t * pxStaticQueue )
\r
539 QueueHandle_t xNewQueue;
\r
540 const UBaseType_t uxMutexLength = ( UBaseType_t ) 1, uxMutexSize = ( UBaseType_t ) 0;
\r
542 /* Prevent compiler warnings about unused parameters if
\r
543 * configUSE_TRACE_FACILITY does not equal 1. */
\r
544 ( void ) ucQueueType;
\r
546 xNewQueue = xQueueGenericCreateStatic( uxMutexLength, uxMutexSize, NULL, pxStaticQueue, ucQueueType );
\r
547 prvInitialiseMutex( ( Queue_t * ) xNewQueue );
\r
552 #endif /* configUSE_MUTEXES */
\r
553 /*-----------------------------------------------------------*/
\r
555 #if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) )
\r
557 TaskHandle_t xQueueGetMutexHolder( QueueHandle_t xSemaphore )
\r
559 TaskHandle_t pxReturn;
\r
560 Queue_t * const pxSemaphore = ( Queue_t * ) xSemaphore;
\r
562 /* This function is called by xSemaphoreGetMutexHolder(), and should not
\r
563 * be called directly. Note: This is a good way of determining if the
\r
564 * calling task is the mutex holder, but not a good way of determining the
\r
565 * identity of the mutex holder, as the holder may change between the
\r
566 * following critical section exiting and the function returning. */
\r
567 taskENTER_CRITICAL();
\r
569 if( pxSemaphore->uxQueueType == queueQUEUE_IS_MUTEX )
\r
571 pxReturn = pxSemaphore->u.xSemaphore.xMutexHolder;
\r
578 taskEXIT_CRITICAL();
\r
581 } /*lint !e818 xSemaphore cannot be a pointer to const because it is a typedef. */
\r
583 #endif /* if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) ) */
\r
584 /*-----------------------------------------------------------*/
\r
586 #if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) )
\r
588 TaskHandle_t xQueueGetMutexHolderFromISR( QueueHandle_t xSemaphore )
\r
590 TaskHandle_t pxReturn;
\r
592 configASSERT( xSemaphore );
\r
594 /* Mutexes cannot be used in interrupt service routines, so the mutex
\r
595 * holder should not change in an ISR, and therefore a critical section is
\r
596 * not required here. */
\r
597 if( ( ( Queue_t * ) xSemaphore )->uxQueueType == queueQUEUE_IS_MUTEX )
\r
599 pxReturn = ( ( Queue_t * ) xSemaphore )->u.xSemaphore.xMutexHolder;
\r
607 } /*lint !e818 xSemaphore cannot be a pointer to const because it is a typedef. */
\r
609 #endif /* if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) ) */
\r
610 /*-----------------------------------------------------------*/
\r
612 #if ( configUSE_RECURSIVE_MUTEXES == 1 )
\r
614 BaseType_t xQueueGiveMutexRecursive( QueueHandle_t xMutex )
\r
616 BaseType_t xReturn;
\r
617 Queue_t * const pxMutex = ( Queue_t * ) xMutex;
\r
619 configASSERT( pxMutex );
\r
621 /* If this is the task that holds the mutex then xMutexHolder will not
\r
622 * change outside of this task. If this task does not hold the mutex then
\r
623 * pxMutexHolder can never coincidentally equal the tasks handle, and as
\r
624 * this is the only condition we are interested in it does not matter if
\r
625 * pxMutexHolder is accessed simultaneously by another task. Therefore no
\r
626 * mutual exclusion is required to test the pxMutexHolder variable. */
\r
627 if( pxMutex->u.xSemaphore.xMutexHolder == xTaskGetCurrentTaskHandle() )
\r
629 traceGIVE_MUTEX_RECURSIVE( pxMutex );
\r
631 /* uxRecursiveCallCount cannot be zero if xMutexHolder is equal to
\r
632 * the task handle, therefore no underflow check is required. Also,
\r
633 * uxRecursiveCallCount is only modified by the mutex holder, and as
\r
634 * there can only be one, no mutual exclusion is required to modify the
\r
635 * uxRecursiveCallCount member. */
\r
636 ( pxMutex->u.xSemaphore.uxRecursiveCallCount )--;
\r
638 /* Has the recursive call count unwound to 0? */
\r
639 if( pxMutex->u.xSemaphore.uxRecursiveCallCount == ( UBaseType_t ) 0 )
\r
641 /* Return the mutex. This will automatically unblock any other
\r
642 * task that might be waiting to access the mutex. */
\r
643 ( void ) xQueueGenericSend( pxMutex, NULL, queueMUTEX_GIVE_BLOCK_TIME, queueSEND_TO_BACK );
\r
647 mtCOVERAGE_TEST_MARKER();
\r
654 /* The mutex cannot be given because the calling task is not the
\r
658 traceGIVE_MUTEX_RECURSIVE_FAILED( pxMutex );
\r
664 #endif /* configUSE_RECURSIVE_MUTEXES */
\r
665 /*-----------------------------------------------------------*/
\r
667 #if ( configUSE_RECURSIVE_MUTEXES == 1 )
\r
669 BaseType_t xQueueTakeMutexRecursive( QueueHandle_t xMutex,
\r
670 TickType_t xTicksToWait )
\r
672 BaseType_t xReturn;
\r
673 Queue_t * const pxMutex = ( Queue_t * ) xMutex;
\r
675 configASSERT( pxMutex );
\r
677 /* Comments regarding mutual exclusion as per those within
\r
678 * xQueueGiveMutexRecursive(). */
\r
680 traceTAKE_MUTEX_RECURSIVE( pxMutex );
\r
682 if( pxMutex->u.xSemaphore.xMutexHolder == xTaskGetCurrentTaskHandle() )
\r
684 ( pxMutex->u.xSemaphore.uxRecursiveCallCount )++;
\r
689 xReturn = xQueueSemaphoreTake( pxMutex, xTicksToWait );
\r
691 /* pdPASS will only be returned if the mutex was successfully
\r
692 * obtained. The calling task may have entered the Blocked state
\r
693 * before reaching here. */
\r
694 if( xReturn != pdFAIL )
\r
696 ( pxMutex->u.xSemaphore.uxRecursiveCallCount )++;
\r
700 traceTAKE_MUTEX_RECURSIVE_FAILED( pxMutex );
\r
707 #endif /* configUSE_RECURSIVE_MUTEXES */
\r
708 /*-----------------------------------------------------------*/
\r
710 #if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
\r
712 QueueHandle_t xQueueCreateCountingSemaphoreStatic( const UBaseType_t uxMaxCount,
\r
713 const UBaseType_t uxInitialCount,
\r
714 StaticQueue_t * pxStaticQueue )
\r
716 QueueHandle_t xHandle;
\r
718 configASSERT( uxMaxCount != 0 );
\r
719 configASSERT( uxInitialCount <= uxMaxCount );
\r
721 xHandle = xQueueGenericCreateStatic( uxMaxCount, queueSEMAPHORE_QUEUE_ITEM_LENGTH, NULL, pxStaticQueue, queueQUEUE_TYPE_COUNTING_SEMAPHORE );
\r
723 if( xHandle != NULL )
\r
725 ( ( Queue_t * ) xHandle )->uxMessagesWaiting = uxInitialCount;
\r
727 traceCREATE_COUNTING_SEMAPHORE();
\r
731 traceCREATE_COUNTING_SEMAPHORE_FAILED();
\r
737 #endif /* ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */
\r
738 /*-----------------------------------------------------------*/
\r
740 #if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
\r
742 QueueHandle_t xQueueCreateCountingSemaphore( const UBaseType_t uxMaxCount,
\r
743 const UBaseType_t uxInitialCount )
\r
745 QueueHandle_t xHandle;
\r
747 configASSERT( uxMaxCount != 0 );
\r
748 configASSERT( uxInitialCount <= uxMaxCount );
\r
750 xHandle = xQueueGenericCreate( uxMaxCount, queueSEMAPHORE_QUEUE_ITEM_LENGTH, queueQUEUE_TYPE_COUNTING_SEMAPHORE );
\r
752 if( xHandle != NULL )
\r
754 ( ( Queue_t * ) xHandle )->uxMessagesWaiting = uxInitialCount;
\r
756 traceCREATE_COUNTING_SEMAPHORE();
\r
760 traceCREATE_COUNTING_SEMAPHORE_FAILED();
\r
766 #endif /* ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */
\r
767 /*-----------------------------------------------------------*/
\r
769 BaseType_t xQueueGenericSend( QueueHandle_t xQueue,
\r
770 const void * const pvItemToQueue,
\r
771 TickType_t xTicksToWait,
\r
772 const BaseType_t xCopyPosition )
\r
774 BaseType_t xEntryTimeSet = pdFALSE, xYieldRequired;
\r
775 TimeOut_t xTimeOut;
\r
776 Queue_t * const pxQueue = xQueue;
\r
778 configASSERT( pxQueue );
\r
779 configASSERT( !( ( pvItemToQueue == NULL ) && ( pxQueue->uxItemSize != ( UBaseType_t ) 0U ) ) );
\r
780 configASSERT( !( ( xCopyPosition == queueOVERWRITE ) && ( pxQueue->uxLength != 1 ) ) );
\r
781 #if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
\r
783 configASSERT( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) );
\r
787 /*lint -save -e904 This function relaxes the coding standard somewhat to
\r
788 * allow return statements within the function itself. This is done in the
\r
789 * interest of execution time efficiency. */
\r
792 taskENTER_CRITICAL();
\r
794 /* Is there room on the queue now? The running task must be the
\r
795 * highest priority task wanting to access the queue. If the head item
\r
796 * in the queue is to be overwritten then it does not matter if the
\r
797 * queue is full. */
\r
798 if( ( pxQueue->uxMessagesWaiting < pxQueue->uxLength ) || ( xCopyPosition == queueOVERWRITE ) )
\r
800 traceQUEUE_SEND( pxQueue );
\r
802 #if ( configUSE_QUEUE_SETS == 1 )
\r
804 const UBaseType_t uxPreviousMessagesWaiting = pxQueue->uxMessagesWaiting;
\r
806 xYieldRequired = prvCopyDataToQueue( pxQueue, pvItemToQueue, xCopyPosition );
\r
808 if( pxQueue->pxQueueSetContainer != NULL )
\r
810 if( ( xCopyPosition == queueOVERWRITE ) && ( uxPreviousMessagesWaiting != ( UBaseType_t ) 0 ) )
\r
812 /* Do not notify the queue set as an existing item
\r
813 * was overwritten in the queue so the number of items
\r
814 * in the queue has not changed. */
\r
815 mtCOVERAGE_TEST_MARKER();
\r
817 else if( prvNotifyQueueSetContainer( pxQueue ) != pdFALSE )
\r
819 /* The queue is a member of a queue set, and posting
\r
820 * to the queue set caused a higher priority task to
\r
821 * unblock. A context switch is required. */
\r
822 queueYIELD_IF_USING_PREEMPTION();
\r
826 mtCOVERAGE_TEST_MARKER();
\r
831 /* If there was a task waiting for data to arrive on the
\r
832 * queue then unblock it now. */
\r
833 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
\r
835 if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )
\r
837 /* The unblocked task has a priority higher than
\r
838 * our own so yield immediately. Yes it is ok to
\r
839 * do this from within the critical section - the
\r
840 * kernel takes care of that. */
\r
841 queueYIELD_IF_USING_PREEMPTION();
\r
845 mtCOVERAGE_TEST_MARKER();
\r
848 else if( xYieldRequired != pdFALSE )
\r
850 /* This path is a special case that will only get
\r
851 * executed if the task was holding multiple mutexes
\r
852 * and the mutexes were given back in an order that is
\r
853 * different to that in which they were taken. */
\r
854 queueYIELD_IF_USING_PREEMPTION();
\r
858 mtCOVERAGE_TEST_MARKER();
\r
862 #else /* configUSE_QUEUE_SETS */
\r
864 xYieldRequired = prvCopyDataToQueue( pxQueue, pvItemToQueue, xCopyPosition );
\r
866 /* If there was a task waiting for data to arrive on the
\r
867 * queue then unblock it now. */
\r
868 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
\r
870 if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )
\r
872 /* The unblocked task has a priority higher than
\r
873 * our own so yield immediately. Yes it is ok to do
\r
874 * this from within the critical section - the kernel
\r
875 * takes care of that. */
\r
876 queueYIELD_IF_USING_PREEMPTION();
\r
880 mtCOVERAGE_TEST_MARKER();
\r
883 else if( xYieldRequired != pdFALSE )
\r
885 /* This path is a special case that will only get
\r
886 * executed if the task was holding multiple mutexes and
\r
887 * the mutexes were given back in an order that is
\r
888 * different to that in which they were taken. */
\r
889 queueYIELD_IF_USING_PREEMPTION();
\r
893 mtCOVERAGE_TEST_MARKER();
\r
896 #endif /* configUSE_QUEUE_SETS */
\r
898 taskEXIT_CRITICAL();
\r
903 if( xTicksToWait == ( TickType_t ) 0 )
\r
905 /* The queue was full and no block time is specified (or
\r
906 * the block time has expired) so leave now. */
\r
907 taskEXIT_CRITICAL();
\r
909 /* Return to the original privilege level before exiting
\r
911 traceQUEUE_SEND_FAILED( pxQueue );
\r
912 return errQUEUE_FULL;
\r
914 else if( xEntryTimeSet == pdFALSE )
\r
916 /* The queue was full and a block time was specified so
\r
917 * configure the timeout structure. */
\r
918 vTaskInternalSetTimeOutState( &xTimeOut );
\r
919 xEntryTimeSet = pdTRUE;
\r
923 /* Entry time was already set. */
\r
924 mtCOVERAGE_TEST_MARKER();
\r
928 taskEXIT_CRITICAL();
\r
930 /* Interrupts and other tasks can send to and receive from the queue
\r
931 * now the critical section has been exited. */
\r
934 prvLockQueue( pxQueue );
\r
936 /* Update the timeout state to see if it has expired yet. */
\r
937 if( xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) == pdFALSE )
\r
939 if( prvIsQueueFull( pxQueue ) != pdFALSE )
\r
941 traceBLOCKING_ON_QUEUE_SEND( pxQueue );
\r
942 vTaskPlaceOnEventList( &( pxQueue->xTasksWaitingToSend ), xTicksToWait );
\r
944 /* Unlocking the queue means queue events can effect the
\r
945 * event list. It is possible that interrupts occurring now
\r
946 * remove this task from the event list again - but as the
\r
947 * scheduler is suspended the task will go onto the pending
\r
948 * ready last instead of the actual ready list. */
\r
949 prvUnlockQueue( pxQueue );
\r
951 /* Resuming the scheduler will move tasks from the pending
\r
952 * ready list into the ready list - so it is feasible that this
\r
953 * task is already in a ready list before it yields - in which
\r
954 * case the yield will not cause a context switch unless there
\r
955 * is also a higher priority task in the pending ready list. */
\r
956 if( xTaskResumeAll() == pdFALSE )
\r
958 portYIELD_WITHIN_API();
\r
964 prvUnlockQueue( pxQueue );
\r
965 ( void ) xTaskResumeAll();
\r
970 /* The timeout has expired. */
\r
971 prvUnlockQueue( pxQueue );
\r
972 ( void ) xTaskResumeAll();
\r
974 traceQUEUE_SEND_FAILED( pxQueue );
\r
975 return errQUEUE_FULL;
\r
977 } /*lint -restore */
\r
979 /*-----------------------------------------------------------*/
\r
981 BaseType_t xQueueGenericSendFromISR( QueueHandle_t xQueue,
\r
982 const void * const pvItemToQueue,
\r
983 BaseType_t * const pxHigherPriorityTaskWoken,
\r
984 const BaseType_t xCopyPosition )
\r
986 BaseType_t xReturn;
\r
987 UBaseType_t uxSavedInterruptStatus;
\r
988 Queue_t * const pxQueue = xQueue;
\r
990 configASSERT( pxQueue );
\r
991 configASSERT( !( ( pvItemToQueue == NULL ) && ( pxQueue->uxItemSize != ( UBaseType_t ) 0U ) ) );
\r
992 configASSERT( !( ( xCopyPosition == queueOVERWRITE ) && ( pxQueue->uxLength != 1 ) ) );
\r
994 /* RTOS ports that support interrupt nesting have the concept of a maximum
\r
995 * system call (or maximum API call) interrupt priority. Interrupts that are
\r
996 * above the maximum system call priority are kept permanently enabled, even
\r
997 * when the RTOS kernel is in a critical section, but cannot make any calls to
\r
998 * FreeRTOS API functions. If configASSERT() is defined in FreeRTOSConfig.h
\r
999 * then portASSERT_IF_INTERRUPT_PRIORITY_INVALID() will result in an assertion
\r
1000 * failure if a FreeRTOS API function is called from an interrupt that has been
\r
1001 * assigned a priority above the configured maximum system call priority.
\r
1002 * Only FreeRTOS functions that end in FromISR can be called from interrupts
\r
1003 * that have been assigned a priority at or (logically) below the maximum
\r
1004 * system call interrupt priority. FreeRTOS maintains a separate interrupt
\r
1005 * safe API to ensure interrupt entry is as fast and as simple as possible.
\r
1006 * More information (albeit Cortex-M specific) is provided on the following
\r
1007 * link: http://www.freertos.org/RTOS-Cortex-M3-M4.html */
\r
1008 portASSERT_IF_INTERRUPT_PRIORITY_INVALID();
\r
1010 /* Similar to xQueueGenericSend, except without blocking if there is no room
\r
1011 * in the queue. Also don't directly wake a task that was blocked on a queue
\r
1012 * read, instead return a flag to say whether a context switch is required or
\r
1013 * not (i.e. has a task with a higher priority than us been woken by this
\r
1015 uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
\r
1017 if( ( pxQueue->uxMessagesWaiting < pxQueue->uxLength ) || ( xCopyPosition == queueOVERWRITE ) )
\r
1019 const int8_t cTxLock = pxQueue->cTxLock;
\r
1020 const UBaseType_t uxPreviousMessagesWaiting = pxQueue->uxMessagesWaiting;
\r
1022 traceQUEUE_SEND_FROM_ISR( pxQueue );
\r
1024 /* Semaphores use xQueueGiveFromISR(), so pxQueue will not be a
\r
1025 * semaphore or mutex. That means prvCopyDataToQueue() cannot result
\r
1026 * in a task disinheriting a priority and prvCopyDataToQueue() can be
\r
1027 * called here even though the disinherit function does not check if
\r
1028 * the scheduler is suspended before accessing the ready lists. */
\r
1029 ( void ) prvCopyDataToQueue( pxQueue, pvItemToQueue, xCopyPosition );
\r
1031 /* The event list is not altered if the queue is locked. This will
\r
1032 * be done when the queue is unlocked later. */
\r
1033 if( cTxLock == queueUNLOCKED )
\r
1035 #if ( configUSE_QUEUE_SETS == 1 )
\r
1037 if( pxQueue->pxQueueSetContainer != NULL )
\r
1039 if( ( xCopyPosition == queueOVERWRITE ) && ( uxPreviousMessagesWaiting != ( UBaseType_t ) 0 ) )
\r
1041 /* Do not notify the queue set as an existing item
\r
1042 * was overwritten in the queue so the number of items
\r
1043 * in the queue has not changed. */
\r
1044 mtCOVERAGE_TEST_MARKER();
\r
1046 else if( prvNotifyQueueSetContainer( pxQueue ) != pdFALSE )
\r
1048 /* The queue is a member of a queue set, and posting
\r
1049 * to the queue set caused a higher priority task to
\r
1050 * unblock. A context switch is required. */
\r
1051 if( pxHigherPriorityTaskWoken != NULL )
\r
1053 *pxHigherPriorityTaskWoken = pdTRUE;
\r
1057 mtCOVERAGE_TEST_MARKER();
\r
1062 mtCOVERAGE_TEST_MARKER();
\r
1067 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
\r
1069 if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )
\r
1071 /* The task waiting has a higher priority so
\r
1072 * record that a context switch is required. */
\r
1073 if( pxHigherPriorityTaskWoken != NULL )
\r
1075 *pxHigherPriorityTaskWoken = pdTRUE;
\r
1079 mtCOVERAGE_TEST_MARKER();
\r
1084 mtCOVERAGE_TEST_MARKER();
\r
1089 mtCOVERAGE_TEST_MARKER();
\r
1093 #else /* configUSE_QUEUE_SETS */
\r
1095 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
\r
1097 if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )
\r
1099 /* The task waiting has a higher priority so record that a
\r
1100 * context switch is required. */
\r
1101 if( pxHigherPriorityTaskWoken != NULL )
\r
1103 *pxHigherPriorityTaskWoken = pdTRUE;
\r
1107 mtCOVERAGE_TEST_MARKER();
\r
1112 mtCOVERAGE_TEST_MARKER();
\r
1117 mtCOVERAGE_TEST_MARKER();
\r
1120 /* Not used in this path. */
\r
1121 ( void ) uxPreviousMessagesWaiting;
\r
1123 #endif /* configUSE_QUEUE_SETS */
\r
1127 /* Increment the lock count so the task that unlocks the queue
\r
1128 * knows that data was posted while it was locked. */
\r
1129 configASSERT( cTxLock != queueINT8_MAX );
\r
1131 pxQueue->cTxLock = ( int8_t ) ( cTxLock + 1 );
\r
1138 traceQUEUE_SEND_FROM_ISR_FAILED( pxQueue );
\r
1139 xReturn = errQUEUE_FULL;
\r
1142 portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );
\r
1146 /*-----------------------------------------------------------*/
\r
1148 BaseType_t xQueueGiveFromISR( QueueHandle_t xQueue,
\r
1149 BaseType_t * const pxHigherPriorityTaskWoken )
\r
1151 BaseType_t xReturn;
\r
1152 UBaseType_t uxSavedInterruptStatus;
\r
1153 Queue_t * const pxQueue = xQueue;
\r
1155 /* Similar to xQueueGenericSendFromISR() but used with semaphores where the
\r
1156 * item size is 0. Don't directly wake a task that was blocked on a queue
\r
1157 * read, instead return a flag to say whether a context switch is required or
\r
1158 * not (i.e. has a task with a higher priority than us been woken by this
\r
1161 configASSERT( pxQueue );
\r
1163 /* xQueueGenericSendFromISR() should be used instead of xQueueGiveFromISR()
\r
1164 * if the item size is not 0. */
\r
1165 configASSERT( pxQueue->uxItemSize == 0 );
\r
1167 /* Normally a mutex would not be given from an interrupt, especially if
\r
1168 * there is a mutex holder, as priority inheritance makes no sense for an
\r
1169 * interrupts, only tasks. */
\r
1170 configASSERT( !( ( pxQueue->uxQueueType == queueQUEUE_IS_MUTEX ) && ( pxQueue->u.xSemaphore.xMutexHolder != NULL ) ) );
\r
1172 /* RTOS ports that support interrupt nesting have the concept of a maximum
\r
1173 * system call (or maximum API call) interrupt priority. Interrupts that are
\r
1174 * above the maximum system call priority are kept permanently enabled, even
\r
1175 * when the RTOS kernel is in a critical section, but cannot make any calls to
\r
1176 * FreeRTOS API functions. If configASSERT() is defined in FreeRTOSConfig.h
\r
1177 * then portASSERT_IF_INTERRUPT_PRIORITY_INVALID() will result in an assertion
\r
1178 * failure if a FreeRTOS API function is called from an interrupt that has been
\r
1179 * assigned a priority above the configured maximum system call priority.
\r
1180 * Only FreeRTOS functions that end in FromISR can be called from interrupts
\r
1181 * that have been assigned a priority at or (logically) below the maximum
\r
1182 * system call interrupt priority. FreeRTOS maintains a separate interrupt
\r
1183 * safe API to ensure interrupt entry is as fast and as simple as possible.
\r
1184 * More information (albeit Cortex-M specific) is provided on the following
\r
1185 * link: http://www.freertos.org/RTOS-Cortex-M3-M4.html */
\r
1186 portASSERT_IF_INTERRUPT_PRIORITY_INVALID();
\r
1188 uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
\r
1190 const UBaseType_t uxMessagesWaiting = pxQueue->uxMessagesWaiting;
\r
1192 /* When the queue is used to implement a semaphore no data is ever
\r
1193 * moved through the queue but it is still valid to see if the queue 'has
\r
1195 if( uxMessagesWaiting < pxQueue->uxLength )
\r
1197 const int8_t cTxLock = pxQueue->cTxLock;
\r
1199 traceQUEUE_SEND_FROM_ISR( pxQueue );
\r
1201 /* A task can only have an inherited priority if it is a mutex
\r
1202 * holder - and if there is a mutex holder then the mutex cannot be
\r
1203 * given from an ISR. As this is the ISR version of the function it
\r
1204 * can be assumed there is no mutex holder and no need to determine if
\r
1205 * priority disinheritance is needed. Simply increase the count of
\r
1206 * messages (semaphores) available. */
\r
1207 pxQueue->uxMessagesWaiting = uxMessagesWaiting + ( UBaseType_t ) 1;
\r
1209 /* The event list is not altered if the queue is locked. This will
\r
1210 * be done when the queue is unlocked later. */
\r
1211 if( cTxLock == queueUNLOCKED )
\r
1213 #if ( configUSE_QUEUE_SETS == 1 )
\r
1215 if( pxQueue->pxQueueSetContainer != NULL )
\r
1217 if( prvNotifyQueueSetContainer( pxQueue ) != pdFALSE )
\r
1219 /* The semaphore is a member of a queue set, and
\r
1220 * posting to the queue set caused a higher priority
\r
1221 * task to unblock. A context switch is required. */
\r
1222 if( pxHigherPriorityTaskWoken != NULL )
\r
1224 *pxHigherPriorityTaskWoken = pdTRUE;
\r
1228 mtCOVERAGE_TEST_MARKER();
\r
1233 mtCOVERAGE_TEST_MARKER();
\r
1238 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
\r
1240 if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )
\r
1242 /* The task waiting has a higher priority so
\r
1243 * record that a context switch is required. */
\r
1244 if( pxHigherPriorityTaskWoken != NULL )
\r
1246 *pxHigherPriorityTaskWoken = pdTRUE;
\r
1250 mtCOVERAGE_TEST_MARKER();
\r
1255 mtCOVERAGE_TEST_MARKER();
\r
1260 mtCOVERAGE_TEST_MARKER();
\r
1264 #else /* configUSE_QUEUE_SETS */
\r
1266 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
\r
1268 if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )
\r
1270 /* The task waiting has a higher priority so record that a
\r
1271 * context switch is required. */
\r
1272 if( pxHigherPriorityTaskWoken != NULL )
\r
1274 *pxHigherPriorityTaskWoken = pdTRUE;
\r
1278 mtCOVERAGE_TEST_MARKER();
\r
1283 mtCOVERAGE_TEST_MARKER();
\r
1288 mtCOVERAGE_TEST_MARKER();
\r
1291 #endif /* configUSE_QUEUE_SETS */
\r
1295 /* Increment the lock count so the task that unlocks the queue
\r
1296 * knows that data was posted while it was locked. */
\r
1297 configASSERT( cTxLock != queueINT8_MAX );
\r
1299 pxQueue->cTxLock = ( int8_t ) ( cTxLock + 1 );
\r
1306 traceQUEUE_SEND_FROM_ISR_FAILED( pxQueue );
\r
1307 xReturn = errQUEUE_FULL;
\r
1310 portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );
\r
1314 /*-----------------------------------------------------------*/
\r
1316 BaseType_t xQueueReceive( QueueHandle_t xQueue,
\r
1317 void * const pvBuffer,
\r
1318 TickType_t xTicksToWait )
\r
1320 BaseType_t xEntryTimeSet = pdFALSE;
\r
1321 TimeOut_t xTimeOut;
\r
1322 Queue_t * const pxQueue = xQueue;
\r
1324 /* Check the pointer is not NULL. */
\r
1325 configASSERT( ( pxQueue ) );
\r
1327 /* The buffer into which data is received can only be NULL if the data size
\r
1328 * is zero (so no data is copied into the buffer). */
\r
1329 configASSERT( !( ( ( pvBuffer ) == NULL ) && ( ( pxQueue )->uxItemSize != ( UBaseType_t ) 0U ) ) );
\r
1331 /* Cannot block if the scheduler is suspended. */
\r
1332 #if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
\r
1334 configASSERT( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) );
\r
1338 /*lint -save -e904 This function relaxes the coding standard somewhat to
\r
1339 * allow return statements within the function itself. This is done in the
\r
1340 * interest of execution time efficiency. */
\r
1343 taskENTER_CRITICAL();
\r
1345 const UBaseType_t uxMessagesWaiting = pxQueue->uxMessagesWaiting;
\r
1347 /* Is there data in the queue now? To be running the calling task
\r
1348 * must be the highest priority task wanting to access the queue. */
\r
1349 if( uxMessagesWaiting > ( UBaseType_t ) 0 )
\r
1351 /* Data available, remove one item. */
\r
1352 prvCopyDataFromQueue( pxQueue, pvBuffer );
\r
1353 traceQUEUE_RECEIVE( pxQueue );
\r
1354 pxQueue->uxMessagesWaiting = uxMessagesWaiting - ( UBaseType_t ) 1;
\r
1356 /* There is now space in the queue, were any tasks waiting to
\r
1357 * post to the queue? If so, unblock the highest priority waiting
\r
1359 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) == pdFALSE )
\r
1361 if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) != pdFALSE )
\r
1363 queueYIELD_IF_USING_PREEMPTION();
\r
1367 mtCOVERAGE_TEST_MARKER();
\r
1372 mtCOVERAGE_TEST_MARKER();
\r
1375 taskEXIT_CRITICAL();
\r
1380 if( xTicksToWait == ( TickType_t ) 0 )
\r
1382 /* The queue was empty and no block time is specified (or
\r
1383 * the block time has expired) so leave now. */
\r
1384 taskEXIT_CRITICAL();
\r
1385 traceQUEUE_RECEIVE_FAILED( pxQueue );
\r
1386 return errQUEUE_EMPTY;
\r
1388 else if( xEntryTimeSet == pdFALSE )
\r
1390 /* The queue was empty and a block time was specified so
\r
1391 * configure the timeout structure. */
\r
1392 vTaskInternalSetTimeOutState( &xTimeOut );
\r
1393 xEntryTimeSet = pdTRUE;
\r
1397 /* Entry time was already set. */
\r
1398 mtCOVERAGE_TEST_MARKER();
\r
1402 taskEXIT_CRITICAL();
\r
1404 /* Interrupts and other tasks can send to and receive from the queue
\r
1405 * now the critical section has been exited. */
\r
1407 vTaskSuspendAll();
\r
1408 prvLockQueue( pxQueue );
\r
1410 /* Update the timeout state to see if it has expired yet. */
\r
1411 if( xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) == pdFALSE )
\r
1413 /* The timeout has not expired. If the queue is still empty place
\r
1414 * the task on the list of tasks waiting to receive from the queue. */
\r
1415 if( prvIsQueueEmpty( pxQueue ) != pdFALSE )
\r
1417 traceBLOCKING_ON_QUEUE_RECEIVE( pxQueue );
\r
1418 vTaskPlaceOnEventList( &( pxQueue->xTasksWaitingToReceive ), xTicksToWait );
\r
1419 prvUnlockQueue( pxQueue );
\r
1421 if( xTaskResumeAll() == pdFALSE )
\r
1423 portYIELD_WITHIN_API();
\r
1427 mtCOVERAGE_TEST_MARKER();
\r
1432 /* The queue contains data again. Loop back to try and read the
\r
1434 prvUnlockQueue( pxQueue );
\r
1435 ( void ) xTaskResumeAll();
\r
1440 /* Timed out. If there is no data in the queue exit, otherwise loop
\r
1441 * back and attempt to read the data. */
\r
1442 prvUnlockQueue( pxQueue );
\r
1443 ( void ) xTaskResumeAll();
\r
1445 if( prvIsQueueEmpty( pxQueue ) != pdFALSE )
\r
1447 traceQUEUE_RECEIVE_FAILED( pxQueue );
\r
1448 return errQUEUE_EMPTY;
\r
1452 mtCOVERAGE_TEST_MARKER();
\r
1455 } /*lint -restore */
\r
1457 /*-----------------------------------------------------------*/
\r
1459 BaseType_t xQueueSemaphoreTake( QueueHandle_t xQueue,
\r
1460 TickType_t xTicksToWait )
\r
1462 BaseType_t xEntryTimeSet = pdFALSE;
\r
1463 TimeOut_t xTimeOut;
\r
1464 Queue_t * const pxQueue = xQueue;
\r
1466 #if ( configUSE_MUTEXES == 1 )
\r
1467 BaseType_t xInheritanceOccurred = pdFALSE;
\r
1470 /* Check the queue pointer is not NULL. */
\r
1471 configASSERT( ( pxQueue ) );
\r
1473 /* Check this really is a semaphore, in which case the item size will be
\r
1475 configASSERT( pxQueue->uxItemSize == 0 );
\r
1477 /* Cannot block if the scheduler is suspended. */
\r
1478 #if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
\r
1480 configASSERT( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) );
\r
1484 /*lint -save -e904 This function relaxes the coding standard somewhat to allow return
\r
1485 * statements within the function itself. This is done in the interest
\r
1486 * of execution time efficiency. */
\r
1489 taskENTER_CRITICAL();
\r
1491 /* Semaphores are queues with an item size of 0, and where the
\r
1492 * number of messages in the queue is the semaphore's count value. */
\r
1493 const UBaseType_t uxSemaphoreCount = pxQueue->uxMessagesWaiting;
\r
1495 /* Is there data in the queue now? To be running the calling task
\r
1496 * must be the highest priority task wanting to access the queue. */
\r
1497 if( uxSemaphoreCount > ( UBaseType_t ) 0 )
\r
1499 traceQUEUE_RECEIVE( pxQueue );
\r
1501 /* Semaphores are queues with a data size of zero and where the
\r
1502 * messages waiting is the semaphore's count. Reduce the count. */
\r
1503 pxQueue->uxMessagesWaiting = uxSemaphoreCount - ( UBaseType_t ) 1;
\r
1505 #if ( configUSE_MUTEXES == 1 )
\r
1507 if( pxQueue->uxQueueType == queueQUEUE_IS_MUTEX )
\r
1509 /* Record the information required to implement
\r
1510 * priority inheritance should it become necessary. */
\r
1511 pxQueue->u.xSemaphore.xMutexHolder = pvTaskIncrementMutexHeldCount();
\r
1515 mtCOVERAGE_TEST_MARKER();
\r
1518 #endif /* configUSE_MUTEXES */
\r
1520 /* Check to see if other tasks are blocked waiting to give the
\r
1521 * semaphore, and if so, unblock the highest priority such task. */
\r
1522 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) == pdFALSE )
\r
1524 if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) != pdFALSE )
\r
1526 queueYIELD_IF_USING_PREEMPTION();
\r
1530 mtCOVERAGE_TEST_MARKER();
\r
1535 mtCOVERAGE_TEST_MARKER();
\r
1538 taskEXIT_CRITICAL();
\r
1543 if( xTicksToWait == ( TickType_t ) 0 )
\r
1545 /* For inheritance to have occurred there must have been an
\r
1546 * initial timeout, and an adjusted timeout cannot become 0, as
\r
1547 * if it were 0 the function would have exited. */
\r
1548 #if ( configUSE_MUTEXES == 1 )
\r
1550 configASSERT( xInheritanceOccurred == pdFALSE );
\r
1552 #endif /* configUSE_MUTEXES */
\r
1554 /* The semaphore count was 0 and no block time is specified
\r
1555 * (or the block time has expired) so exit now. */
\r
1556 taskEXIT_CRITICAL();
\r
1557 traceQUEUE_RECEIVE_FAILED( pxQueue );
\r
1558 return errQUEUE_EMPTY;
\r
1560 else if( xEntryTimeSet == pdFALSE )
\r
1562 /* The semaphore count was 0 and a block time was specified
\r
1563 * so configure the timeout structure ready to block. */
\r
1564 vTaskInternalSetTimeOutState( &xTimeOut );
\r
1565 xEntryTimeSet = pdTRUE;
\r
1569 /* Entry time was already set. */
\r
1570 mtCOVERAGE_TEST_MARKER();
\r
1574 taskEXIT_CRITICAL();
\r
1576 /* Interrupts and other tasks can give to and take from the semaphore
\r
1577 * now the critical section has been exited. */
\r
1579 vTaskSuspendAll();
\r
1580 prvLockQueue( pxQueue );
\r
1582 /* Update the timeout state to see if it has expired yet. */
\r
1583 if( xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) == pdFALSE )
\r
1585 /* A block time is specified and not expired. If the semaphore
\r
1586 * count is 0 then enter the Blocked state to wait for a semaphore to
\r
1587 * become available. As semaphores are implemented with queues the
\r
1588 * queue being empty is equivalent to the semaphore count being 0. */
\r
1589 if( prvIsQueueEmpty( pxQueue ) != pdFALSE )
\r
1591 traceBLOCKING_ON_QUEUE_RECEIVE( pxQueue );
\r
1593 #if ( configUSE_MUTEXES == 1 )
\r
1595 if( pxQueue->uxQueueType == queueQUEUE_IS_MUTEX )
\r
1597 taskENTER_CRITICAL();
\r
1599 xInheritanceOccurred = xTaskPriorityInherit( pxQueue->u.xSemaphore.xMutexHolder );
\r
1601 taskEXIT_CRITICAL();
\r
1605 mtCOVERAGE_TEST_MARKER();
\r
1608 #endif /* if ( configUSE_MUTEXES == 1 ) */
\r
1610 vTaskPlaceOnEventList( &( pxQueue->xTasksWaitingToReceive ), xTicksToWait );
\r
1611 prvUnlockQueue( pxQueue );
\r
1613 if( xTaskResumeAll() == pdFALSE )
\r
1615 portYIELD_WITHIN_API();
\r
1619 mtCOVERAGE_TEST_MARKER();
\r
1624 /* There was no timeout and the semaphore count was not 0, so
\r
1625 * attempt to take the semaphore again. */
\r
1626 prvUnlockQueue( pxQueue );
\r
1627 ( void ) xTaskResumeAll();
\r
1633 prvUnlockQueue( pxQueue );
\r
1634 ( void ) xTaskResumeAll();
\r
1636 /* If the semaphore count is 0 exit now as the timeout has
\r
1637 * expired. Otherwise return to attempt to take the semaphore that is
\r
1638 * known to be available. As semaphores are implemented by queues the
\r
1639 * queue being empty is equivalent to the semaphore count being 0. */
\r
1640 if( prvIsQueueEmpty( pxQueue ) != pdFALSE )
\r
1642 #if ( configUSE_MUTEXES == 1 )
\r
1644 /* xInheritanceOccurred could only have be set if
\r
1645 * pxQueue->uxQueueType == queueQUEUE_IS_MUTEX so no need to
\r
1646 * test the mutex type again to check it is actually a mutex. */
\r
1647 if( xInheritanceOccurred != pdFALSE )
\r
1649 taskENTER_CRITICAL();
\r
1651 UBaseType_t uxHighestWaitingPriority;
\r
1653 /* This task blocking on the mutex caused another
\r
1654 * task to inherit this task's priority. Now this task
\r
1655 * has timed out the priority should be disinherited
\r
1656 * again, but only as low as the next highest priority
\r
1657 * task that is waiting for the same mutex. */
\r
1658 uxHighestWaitingPriority = prvGetDisinheritPriorityAfterTimeout( pxQueue );
\r
1659 vTaskPriorityDisinheritAfterTimeout( pxQueue->u.xSemaphore.xMutexHolder, uxHighestWaitingPriority );
\r
1661 taskEXIT_CRITICAL();
\r
1664 #endif /* configUSE_MUTEXES */
\r
1666 traceQUEUE_RECEIVE_FAILED( pxQueue );
\r
1667 return errQUEUE_EMPTY;
\r
1671 mtCOVERAGE_TEST_MARKER();
\r
1674 } /*lint -restore */
\r
1676 /*-----------------------------------------------------------*/
\r
1678 BaseType_t xQueuePeek( QueueHandle_t xQueue,
\r
1679 void * const pvBuffer,
\r
1680 TickType_t xTicksToWait )
\r
1682 BaseType_t xEntryTimeSet = pdFALSE;
\r
1683 TimeOut_t xTimeOut;
\r
1684 int8_t * pcOriginalReadPosition;
\r
1685 Queue_t * const pxQueue = xQueue;
\r
1687 /* Check the pointer is not NULL. */
\r
1688 configASSERT( ( pxQueue ) );
\r
1690 /* The buffer into which data is received can only be NULL if the data size
\r
1691 * is zero (so no data is copied into the buffer. */
\r
1692 configASSERT( !( ( ( pvBuffer ) == NULL ) && ( ( pxQueue )->uxItemSize != ( UBaseType_t ) 0U ) ) );
\r
1694 /* Cannot block if the scheduler is suspended. */
\r
1695 #if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
\r
1697 configASSERT( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) );
\r
1701 /*lint -save -e904 This function relaxes the coding standard somewhat to
\r
1702 * allow return statements within the function itself. This is done in the
\r
1703 * interest of execution time efficiency. */
\r
1706 taskENTER_CRITICAL();
\r
1708 const UBaseType_t uxMessagesWaiting = pxQueue->uxMessagesWaiting;
\r
1710 /* Is there data in the queue now? To be running the calling task
\r
1711 * must be the highest priority task wanting to access the queue. */
\r
1712 if( uxMessagesWaiting > ( UBaseType_t ) 0 )
\r
1714 /* Remember the read position so it can be reset after the data
\r
1715 * is read from the queue as this function is only peeking the
\r
1716 * data, not removing it. */
\r
1717 pcOriginalReadPosition = pxQueue->u.xQueue.pcReadFrom;
\r
1719 prvCopyDataFromQueue( pxQueue, pvBuffer );
\r
1720 traceQUEUE_PEEK( pxQueue );
\r
1722 /* The data is not being removed, so reset the read pointer. */
\r
1723 pxQueue->u.xQueue.pcReadFrom = pcOriginalReadPosition;
\r
1725 /* The data is being left in the queue, so see if there are
\r
1726 * any other tasks waiting for the data. */
\r
1727 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
\r
1729 if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )
\r
1731 /* The task waiting has a higher priority than this task. */
\r
1732 queueYIELD_IF_USING_PREEMPTION();
\r
1736 mtCOVERAGE_TEST_MARKER();
\r
1741 mtCOVERAGE_TEST_MARKER();
\r
1744 taskEXIT_CRITICAL();
\r
1749 if( xTicksToWait == ( TickType_t ) 0 )
\r
1751 /* The queue was empty and no block time is specified (or
\r
1752 * the block time has expired) so leave now. */
\r
1753 taskEXIT_CRITICAL();
\r
1754 traceQUEUE_PEEK_FAILED( pxQueue );
\r
1755 return errQUEUE_EMPTY;
\r
1757 else if( xEntryTimeSet == pdFALSE )
\r
1759 /* The queue was empty and a block time was specified so
\r
1760 * configure the timeout structure ready to enter the blocked
\r
1762 vTaskInternalSetTimeOutState( &xTimeOut );
\r
1763 xEntryTimeSet = pdTRUE;
\r
1767 /* Entry time was already set. */
\r
1768 mtCOVERAGE_TEST_MARKER();
\r
1772 taskEXIT_CRITICAL();
\r
1774 /* Interrupts and other tasks can send to and receive from the queue
\r
1775 * now the critical section has been exited. */
\r
1777 vTaskSuspendAll();
\r
1778 prvLockQueue( pxQueue );
\r
1780 /* Update the timeout state to see if it has expired yet. */
\r
1781 if( xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) == pdFALSE )
\r
1783 /* Timeout has not expired yet, check to see if there is data in the
\r
1784 * queue now, and if not enter the Blocked state to wait for data. */
\r
1785 if( prvIsQueueEmpty( pxQueue ) != pdFALSE )
\r
1787 traceBLOCKING_ON_QUEUE_PEEK( pxQueue );
\r
1788 vTaskPlaceOnEventList( &( pxQueue->xTasksWaitingToReceive ), xTicksToWait );
\r
1789 prvUnlockQueue( pxQueue );
\r
1791 if( xTaskResumeAll() == pdFALSE )
\r
1793 portYIELD_WITHIN_API();
\r
1797 mtCOVERAGE_TEST_MARKER();
\r
1802 /* There is data in the queue now, so don't enter the blocked
\r
1803 * state, instead return to try and obtain the data. */
\r
1804 prvUnlockQueue( pxQueue );
\r
1805 ( void ) xTaskResumeAll();
\r
1810 /* The timeout has expired. If there is still no data in the queue
\r
1811 * exit, otherwise go back and try to read the data again. */
\r
1812 prvUnlockQueue( pxQueue );
\r
1813 ( void ) xTaskResumeAll();
\r
1815 if( prvIsQueueEmpty( pxQueue ) != pdFALSE )
\r
1817 traceQUEUE_PEEK_FAILED( pxQueue );
\r
1818 return errQUEUE_EMPTY;
\r
1822 mtCOVERAGE_TEST_MARKER();
\r
1825 } /*lint -restore */
\r
1827 /*-----------------------------------------------------------*/
\r
1829 BaseType_t xQueueReceiveFromISR( QueueHandle_t xQueue,
\r
1830 void * const pvBuffer,
\r
1831 BaseType_t * const pxHigherPriorityTaskWoken )
\r
1833 BaseType_t xReturn;
\r
1834 UBaseType_t uxSavedInterruptStatus;
\r
1835 Queue_t * const pxQueue = xQueue;
\r
1837 configASSERT( pxQueue );
\r
1838 configASSERT( !( ( pvBuffer == NULL ) && ( pxQueue->uxItemSize != ( UBaseType_t ) 0U ) ) );
\r
1840 /* RTOS ports that support interrupt nesting have the concept of a maximum
\r
1841 * system call (or maximum API call) interrupt priority. Interrupts that are
\r
1842 * above the maximum system call priority are kept permanently enabled, even
\r
1843 * when the RTOS kernel is in a critical section, but cannot make any calls to
\r
1844 * FreeRTOS API functions. If configASSERT() is defined in FreeRTOSConfig.h
\r
1845 * then portASSERT_IF_INTERRUPT_PRIORITY_INVALID() will result in an assertion
\r
1846 * failure if a FreeRTOS API function is called from an interrupt that has been
\r
1847 * assigned a priority above the configured maximum system call priority.
\r
1848 * Only FreeRTOS functions that end in FromISR can be called from interrupts
\r
1849 * that have been assigned a priority at or (logically) below the maximum
\r
1850 * system call interrupt priority. FreeRTOS maintains a separate interrupt
\r
1851 * safe API to ensure interrupt entry is as fast and as simple as possible.
\r
1852 * More information (albeit Cortex-M specific) is provided on the following
\r
1853 * link: http://www.freertos.org/RTOS-Cortex-M3-M4.html */
\r
1854 portASSERT_IF_INTERRUPT_PRIORITY_INVALID();
\r
1856 uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
\r
1858 const UBaseType_t uxMessagesWaiting = pxQueue->uxMessagesWaiting;
\r
1860 /* Cannot block in an ISR, so check there is data available. */
\r
1861 if( uxMessagesWaiting > ( UBaseType_t ) 0 )
\r
1863 const int8_t cRxLock = pxQueue->cRxLock;
\r
1865 traceQUEUE_RECEIVE_FROM_ISR( pxQueue );
\r
1867 prvCopyDataFromQueue( pxQueue, pvBuffer );
\r
1868 pxQueue->uxMessagesWaiting = uxMessagesWaiting - ( UBaseType_t ) 1;
\r
1870 /* If the queue is locked the event list will not be modified.
\r
1871 * Instead update the lock count so the task that unlocks the queue
\r
1872 * will know that an ISR has removed data while the queue was
\r
1874 if( cRxLock == queueUNLOCKED )
\r
1876 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) == pdFALSE )
\r
1878 if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) != pdFALSE )
\r
1880 /* The task waiting has a higher priority than us so
\r
1881 * force a context switch. */
\r
1882 if( pxHigherPriorityTaskWoken != NULL )
\r
1884 *pxHigherPriorityTaskWoken = pdTRUE;
\r
1888 mtCOVERAGE_TEST_MARKER();
\r
1893 mtCOVERAGE_TEST_MARKER();
\r
1898 mtCOVERAGE_TEST_MARKER();
\r
1903 /* Increment the lock count so the task that unlocks the queue
\r
1904 * knows that data was removed while it was locked. */
\r
1905 configASSERT( cRxLock != queueINT8_MAX );
\r
1907 pxQueue->cRxLock = ( int8_t ) ( cRxLock + 1 );
\r
1915 traceQUEUE_RECEIVE_FROM_ISR_FAILED( pxQueue );
\r
1918 portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );
\r
1922 /*-----------------------------------------------------------*/
\r
1924 BaseType_t xQueuePeekFromISR( QueueHandle_t xQueue,
\r
1925 void * const pvBuffer )
\r
1927 BaseType_t xReturn;
\r
1928 UBaseType_t uxSavedInterruptStatus;
\r
1929 int8_t * pcOriginalReadPosition;
\r
1930 Queue_t * const pxQueue = xQueue;
\r
1932 configASSERT( pxQueue );
\r
1933 configASSERT( !( ( pvBuffer == NULL ) && ( pxQueue->uxItemSize != ( UBaseType_t ) 0U ) ) );
\r
1934 configASSERT( pxQueue->uxItemSize != 0 ); /* Can't peek a semaphore. */
\r
1936 /* RTOS ports that support interrupt nesting have the concept of a maximum
\r
1937 * system call (or maximum API call) interrupt priority. Interrupts that are
\r
1938 * above the maximum system call priority are kept permanently enabled, even
\r
1939 * when the RTOS kernel is in a critical section, but cannot make any calls to
\r
1940 * FreeRTOS API functions. If configASSERT() is defined in FreeRTOSConfig.h
\r
1941 * then portASSERT_IF_INTERRUPT_PRIORITY_INVALID() will result in an assertion
\r
1942 * failure if a FreeRTOS API function is called from an interrupt that has been
\r
1943 * assigned a priority above the configured maximum system call priority.
\r
1944 * Only FreeRTOS functions that end in FromISR can be called from interrupts
\r
1945 * that have been assigned a priority at or (logically) below the maximum
\r
1946 * system call interrupt priority. FreeRTOS maintains a separate interrupt
\r
1947 * safe API to ensure interrupt entry is as fast and as simple as possible.
\r
1948 * More information (albeit Cortex-M specific) is provided on the following
\r
1949 * link: http://www.freertos.org/RTOS-Cortex-M3-M4.html */
\r
1950 portASSERT_IF_INTERRUPT_PRIORITY_INVALID();
\r
1952 uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
\r
1954 /* Cannot block in an ISR, so check there is data available. */
\r
1955 if( pxQueue->uxMessagesWaiting > ( UBaseType_t ) 0 )
\r
1957 traceQUEUE_PEEK_FROM_ISR( pxQueue );
\r
1959 /* Remember the read position so it can be reset as nothing is
\r
1960 * actually being removed from the queue. */
\r
1961 pcOriginalReadPosition = pxQueue->u.xQueue.pcReadFrom;
\r
1962 prvCopyDataFromQueue( pxQueue, pvBuffer );
\r
1963 pxQueue->u.xQueue.pcReadFrom = pcOriginalReadPosition;
\r
1970 traceQUEUE_PEEK_FROM_ISR_FAILED( pxQueue );
\r
1973 portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );
\r
1977 /*-----------------------------------------------------------*/
\r
1979 UBaseType_t uxQueueMessagesWaiting( const QueueHandle_t xQueue )
\r
1981 UBaseType_t uxReturn;
\r
1983 configASSERT( xQueue );
\r
1985 taskENTER_CRITICAL();
\r
1987 uxReturn = ( ( Queue_t * ) xQueue )->uxMessagesWaiting;
\r
1989 taskEXIT_CRITICAL();
\r
1992 } /*lint !e818 Pointer cannot be declared const as xQueue is a typedef not pointer. */
\r
1993 /*-----------------------------------------------------------*/
\r
1995 UBaseType_t uxQueueSpacesAvailable( const QueueHandle_t xQueue )
\r
1997 UBaseType_t uxReturn;
\r
1998 Queue_t * const pxQueue = xQueue;
\r
2000 configASSERT( pxQueue );
\r
2002 taskENTER_CRITICAL();
\r
2004 uxReturn = pxQueue->uxLength - pxQueue->uxMessagesWaiting;
\r
2006 taskEXIT_CRITICAL();
\r
2009 } /*lint !e818 Pointer cannot be declared const as xQueue is a typedef not pointer. */
\r
2010 /*-----------------------------------------------------------*/
\r
2012 UBaseType_t uxQueueMessagesWaitingFromISR( const QueueHandle_t xQueue )
\r
2014 UBaseType_t uxReturn;
\r
2015 Queue_t * const pxQueue = xQueue;
\r
2017 configASSERT( pxQueue );
\r
2018 uxReturn = pxQueue->uxMessagesWaiting;
\r
2021 } /*lint !e818 Pointer cannot be declared const as xQueue is a typedef not pointer. */
\r
2022 /*-----------------------------------------------------------*/
\r
2024 void vQueueDelete( QueueHandle_t xQueue )
\r
2026 Queue_t * const pxQueue = xQueue;
\r
2028 configASSERT( pxQueue );
\r
2029 traceQUEUE_DELETE( pxQueue );
\r
2031 #if ( configQUEUE_REGISTRY_SIZE > 0 )
\r
2033 vQueueUnregisterQueue( pxQueue );
\r
2037 #if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 0 ) )
\r
2039 /* The queue can only have been allocated dynamically - free it
\r
2041 vPortFree( pxQueue );
\r
2043 #elif ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
\r
2045 /* The queue could have been allocated statically or dynamically, so
\r
2046 * check before attempting to free the memory. */
\r
2047 if( pxQueue->ucStaticallyAllocated == ( uint8_t ) pdFALSE )
\r
2049 vPortFree( pxQueue );
\r
2053 mtCOVERAGE_TEST_MARKER();
\r
2056 #else /* if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 0 ) ) */
\r
2058 /* The queue must have been statically allocated, so is not going to be
\r
2059 * deleted. Avoid compiler warnings about the unused parameter. */
\r
2062 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
\r
2064 /*-----------------------------------------------------------*/
\r
2066 #if ( configUSE_TRACE_FACILITY == 1 )
\r
2068 UBaseType_t uxQueueGetQueueNumber( QueueHandle_t xQueue )
\r
2070 return ( ( Queue_t * ) xQueue )->uxQueueNumber;
\r
2073 #endif /* configUSE_TRACE_FACILITY */
\r
2074 /*-----------------------------------------------------------*/
\r
2076 #if ( configUSE_TRACE_FACILITY == 1 )
\r
2078 void vQueueSetQueueNumber( QueueHandle_t xQueue,
\r
2079 UBaseType_t uxQueueNumber )
\r
2081 ( ( Queue_t * ) xQueue )->uxQueueNumber = uxQueueNumber;
\r
2084 #endif /* configUSE_TRACE_FACILITY */
\r
2085 /*-----------------------------------------------------------*/
\r
2087 #if ( configUSE_TRACE_FACILITY == 1 )
\r
2089 uint8_t ucQueueGetQueueType( QueueHandle_t xQueue )
\r
2091 return ( ( Queue_t * ) xQueue )->ucQueueType;
\r
2094 #endif /* configUSE_TRACE_FACILITY */
\r
2095 /*-----------------------------------------------------------*/
\r
2097 #if ( configUSE_MUTEXES == 1 )
\r
2099 static UBaseType_t prvGetDisinheritPriorityAfterTimeout( const Queue_t * const pxQueue )
\r
2101 UBaseType_t uxHighestPriorityOfWaitingTasks;
\r
2103 /* If a task waiting for a mutex causes the mutex holder to inherit a
\r
2104 * priority, but the waiting task times out, then the holder should
\r
2105 * disinherit the priority - but only down to the highest priority of any
\r
2106 * other tasks that are waiting for the same mutex. For this purpose,
\r
2107 * return the priority of the highest priority task that is waiting for the
\r
2109 if( listCURRENT_LIST_LENGTH( &( pxQueue->xTasksWaitingToReceive ) ) > 0U )
\r
2111 uxHighestPriorityOfWaitingTasks = ( UBaseType_t ) configMAX_PRIORITIES - ( UBaseType_t ) listGET_ITEM_VALUE_OF_HEAD_ENTRY( &( pxQueue->xTasksWaitingToReceive ) );
\r
2115 uxHighestPriorityOfWaitingTasks = tskIDLE_PRIORITY;
\r
2118 return uxHighestPriorityOfWaitingTasks;
\r
2121 #endif /* configUSE_MUTEXES */
\r
2122 /*-----------------------------------------------------------*/
\r
2124 static BaseType_t prvCopyDataToQueue( Queue_t * const pxQueue,
\r
2125 const void * pvItemToQueue,
\r
2126 const BaseType_t xPosition )
\r
2128 BaseType_t xReturn = pdFALSE;
\r
2129 UBaseType_t uxMessagesWaiting;
\r
2131 /* This function is called from a critical section. */
\r
2133 uxMessagesWaiting = pxQueue->uxMessagesWaiting;
\r
2135 if( pxQueue->uxItemSize == ( UBaseType_t ) 0 )
\r
2137 #if ( configUSE_MUTEXES == 1 )
\r
2139 if( pxQueue->uxQueueType == queueQUEUE_IS_MUTEX )
\r
2141 /* The mutex is no longer being held. */
\r
2142 xReturn = xTaskPriorityDisinherit( pxQueue->u.xSemaphore.xMutexHolder );
\r
2143 pxQueue->u.xSemaphore.xMutexHolder = NULL;
\r
2147 mtCOVERAGE_TEST_MARKER();
\r
2150 #endif /* configUSE_MUTEXES */
\r
2152 else if( xPosition == queueSEND_TO_BACK )
\r
2154 ( void ) memcpy( ( void * ) pxQueue->pcWriteTo, pvItemToQueue, ( size_t ) pxQueue->uxItemSize ); /*lint !e961 !e418 !e9087 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. Cast to void required by function signature and safe as no alignment requirement and copy length specified in bytes. */
\r
2155 pxQueue->pcWriteTo += pxQueue->uxItemSize; /*lint !e9016 Pointer arithmetic on char types ok, especially in this use case where it is the clearest way of conveying intent. */
\r
2157 if( pxQueue->pcWriteTo >= pxQueue->u.xQueue.pcTail ) /*lint !e946 MISRA exception justified as comparison of pointers is the cleanest solution. */
\r
2159 pxQueue->pcWriteTo = pxQueue->pcHead;
\r
2163 mtCOVERAGE_TEST_MARKER();
\r
2168 ( void ) memcpy( ( void * ) pxQueue->u.xQueue.pcReadFrom, pvItemToQueue, ( size_t ) pxQueue->uxItemSize ); /*lint !e961 !e9087 !e418 MISRA exception as the casts are only redundant for some ports. Cast to void required by function signature and safe as no alignment requirement and copy length specified in bytes. Assert checks null pointer only used when length is 0. */
\r
2169 pxQueue->u.xQueue.pcReadFrom -= pxQueue->uxItemSize;
\r
2171 if( pxQueue->u.xQueue.pcReadFrom < pxQueue->pcHead ) /*lint !e946 MISRA exception justified as comparison of pointers is the cleanest solution. */
\r
2173 pxQueue->u.xQueue.pcReadFrom = ( pxQueue->u.xQueue.pcTail - pxQueue->uxItemSize );
\r
2177 mtCOVERAGE_TEST_MARKER();
\r
2180 if( xPosition == queueOVERWRITE )
\r
2182 if( uxMessagesWaiting > ( UBaseType_t ) 0 )
\r
2184 /* An item is not being added but overwritten, so subtract
\r
2185 * one from the recorded number of items in the queue so when
\r
2186 * one is added again below the number of recorded items remains
\r
2188 --uxMessagesWaiting;
\r
2192 mtCOVERAGE_TEST_MARKER();
\r
2197 mtCOVERAGE_TEST_MARKER();
\r
2201 pxQueue->uxMessagesWaiting = uxMessagesWaiting + ( UBaseType_t ) 1;
\r
2205 /*-----------------------------------------------------------*/
\r
2207 static void prvCopyDataFromQueue( Queue_t * const pxQueue,
\r
2208 void * const pvBuffer )
\r
2210 if( pxQueue->uxItemSize != ( UBaseType_t ) 0 )
\r
2212 pxQueue->u.xQueue.pcReadFrom += pxQueue->uxItemSize; /*lint !e9016 Pointer arithmetic on char types ok, especially in this use case where it is the clearest way of conveying intent. */
\r
2214 if( pxQueue->u.xQueue.pcReadFrom >= pxQueue->u.xQueue.pcTail ) /*lint !e946 MISRA exception justified as use of the relational operator is the cleanest solutions. */
\r
2216 pxQueue->u.xQueue.pcReadFrom = pxQueue->pcHead;
\r
2220 mtCOVERAGE_TEST_MARKER();
\r
2223 ( void ) memcpy( ( void * ) pvBuffer, ( void * ) pxQueue->u.xQueue.pcReadFrom, ( size_t ) pxQueue->uxItemSize ); /*lint !e961 !e418 !e9087 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. Cast to void required by function signature and safe as no alignment requirement and copy length specified in bytes. */
\r
2226 /*-----------------------------------------------------------*/
\r
2228 static void prvUnlockQueue( Queue_t * const pxQueue )
\r
2230 /* THIS FUNCTION MUST BE CALLED WITH THE SCHEDULER SUSPENDED. */
\r
2232 /* The lock counts contains the number of extra data items placed or
\r
2233 * removed from the queue while the queue was locked. When a queue is
\r
2234 * locked items can be added or removed, but the event lists cannot be
\r
2236 taskENTER_CRITICAL();
\r
2238 int8_t cTxLock = pxQueue->cTxLock;
\r
2240 /* See if data was added to the queue while it was locked. */
\r
2241 while( cTxLock > queueLOCKED_UNMODIFIED )
\r
2243 /* Data was posted while the queue was locked. Are any tasks
\r
2244 * blocked waiting for data to become available? */
\r
2245 #if ( configUSE_QUEUE_SETS == 1 )
\r
2247 if( pxQueue->pxQueueSetContainer != NULL )
\r
2249 if( prvNotifyQueueSetContainer( pxQueue ) != pdFALSE )
\r
2251 /* The queue is a member of a queue set, and posting to
\r
2252 * the queue set caused a higher priority task to unblock.
\r
2253 * A context switch is required. */
\r
2254 vTaskMissedYield();
\r
2258 mtCOVERAGE_TEST_MARKER();
\r
2263 /* Tasks that are removed from the event list will get
\r
2264 * added to the pending ready list as the scheduler is still
\r
2266 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
\r
2268 if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )
\r
2270 /* The task waiting has a higher priority so record that a
\r
2271 * context switch is required. */
\r
2272 vTaskMissedYield();
\r
2276 mtCOVERAGE_TEST_MARKER();
\r
2285 #else /* configUSE_QUEUE_SETS */
\r
2287 /* Tasks that are removed from the event list will get added to
\r
2288 * the pending ready list as the scheduler is still suspended. */
\r
2289 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
\r
2291 if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )
\r
2293 /* The task waiting has a higher priority so record that
\r
2294 * a context switch is required. */
\r
2295 vTaskMissedYield();
\r
2299 mtCOVERAGE_TEST_MARKER();
\r
2307 #endif /* configUSE_QUEUE_SETS */
\r
2312 pxQueue->cTxLock = queueUNLOCKED;
\r
2314 taskEXIT_CRITICAL();
\r
2316 /* Do the same for the Rx lock. */
\r
2317 taskENTER_CRITICAL();
\r
2319 int8_t cRxLock = pxQueue->cRxLock;
\r
2321 while( cRxLock > queueLOCKED_UNMODIFIED )
\r
2323 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) == pdFALSE )
\r
2325 if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) != pdFALSE )
\r
2327 vTaskMissedYield();
\r
2331 mtCOVERAGE_TEST_MARKER();
\r
2342 pxQueue->cRxLock = queueUNLOCKED;
\r
2344 taskEXIT_CRITICAL();
\r
2346 /*-----------------------------------------------------------*/
\r
2348 static BaseType_t prvIsQueueEmpty( const Queue_t * pxQueue )
\r
2350 BaseType_t xReturn;
\r
2352 taskENTER_CRITICAL();
\r
2354 if( pxQueue->uxMessagesWaiting == ( UBaseType_t ) 0 )
\r
2360 xReturn = pdFALSE;
\r
2363 taskEXIT_CRITICAL();
\r
2367 /*-----------------------------------------------------------*/
\r
2369 BaseType_t xQueueIsQueueEmptyFromISR( const QueueHandle_t xQueue )
\r
2371 BaseType_t xReturn;
\r
2372 Queue_t * const pxQueue = xQueue;
\r
2374 configASSERT( pxQueue );
\r
2376 if( pxQueue->uxMessagesWaiting == ( UBaseType_t ) 0 )
\r
2382 xReturn = pdFALSE;
\r
2386 } /*lint !e818 xQueue could not be pointer to const because it is a typedef. */
\r
2387 /*-----------------------------------------------------------*/
\r
2389 static BaseType_t prvIsQueueFull( const Queue_t * pxQueue )
\r
2391 BaseType_t xReturn;
\r
2393 taskENTER_CRITICAL();
\r
2395 if( pxQueue->uxMessagesWaiting == pxQueue->uxLength )
\r
2401 xReturn = pdFALSE;
\r
2404 taskEXIT_CRITICAL();
\r
2408 /*-----------------------------------------------------------*/
\r
2410 BaseType_t xQueueIsQueueFullFromISR( const QueueHandle_t xQueue )
\r
2412 BaseType_t xReturn;
\r
2413 Queue_t * const pxQueue = xQueue;
\r
2415 configASSERT( pxQueue );
\r
2417 if( pxQueue->uxMessagesWaiting == pxQueue->uxLength )
\r
2423 xReturn = pdFALSE;
\r
2427 } /*lint !e818 xQueue could not be pointer to const because it is a typedef. */
\r
2428 /*-----------------------------------------------------------*/
\r
2430 #if ( configUSE_CO_ROUTINES == 1 )
\r
2432 BaseType_t xQueueCRSend( QueueHandle_t xQueue,
\r
2433 const void * pvItemToQueue,
\r
2434 TickType_t xTicksToWait )
\r
2436 BaseType_t xReturn;
\r
2437 Queue_t * const pxQueue = xQueue;
\r
2439 /* If the queue is already full we may have to block. A critical section
\r
2440 * is required to prevent an interrupt removing something from the queue
\r
2441 * between the check to see if the queue is full and blocking on the queue. */
\r
2442 portDISABLE_INTERRUPTS();
\r
2444 if( prvIsQueueFull( pxQueue ) != pdFALSE )
\r
2446 /* The queue is full - do we want to block or just leave without
\r
2448 if( xTicksToWait > ( TickType_t ) 0 )
\r
2450 /* As this is called from a coroutine we cannot block directly, but
\r
2451 * return indicating that we need to block. */
\r
2452 vCoRoutineAddToDelayedList( xTicksToWait, &( pxQueue->xTasksWaitingToSend ) );
\r
2453 portENABLE_INTERRUPTS();
\r
2454 return errQUEUE_BLOCKED;
\r
2458 portENABLE_INTERRUPTS();
\r
2459 return errQUEUE_FULL;
\r
2463 portENABLE_INTERRUPTS();
\r
2465 portDISABLE_INTERRUPTS();
\r
2467 if( pxQueue->uxMessagesWaiting < pxQueue->uxLength )
\r
2469 /* There is room in the queue, copy the data into the queue. */
\r
2470 prvCopyDataToQueue( pxQueue, pvItemToQueue, queueSEND_TO_BACK );
\r
2473 /* Were any co-routines waiting for data to become available? */
\r
2474 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
\r
2476 /* In this instance the co-routine could be placed directly
\r
2477 * into the ready list as we are within a critical section.
\r
2478 * Instead the same pending ready list mechanism is used as if
\r
2479 * the event were caused from within an interrupt. */
\r
2480 if( xCoRoutineRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )
\r
2482 /* The co-routine waiting has a higher priority so record
\r
2483 * that a yield might be appropriate. */
\r
2484 xReturn = errQUEUE_YIELD;
\r
2488 mtCOVERAGE_TEST_MARKER();
\r
2493 mtCOVERAGE_TEST_MARKER();
\r
2498 xReturn = errQUEUE_FULL;
\r
2501 portENABLE_INTERRUPTS();
\r
2506 #endif /* configUSE_CO_ROUTINES */
\r
2507 /*-----------------------------------------------------------*/
\r
2509 #if ( configUSE_CO_ROUTINES == 1 )
\r
2511 BaseType_t xQueueCRReceive( QueueHandle_t xQueue,
\r
2513 TickType_t xTicksToWait )
\r
2515 BaseType_t xReturn;
\r
2516 Queue_t * const pxQueue = xQueue;
\r
2518 /* If the queue is already empty we may have to block. A critical section
\r
2519 * is required to prevent an interrupt adding something to the queue
\r
2520 * between the check to see if the queue is empty and blocking on the queue. */
\r
2521 portDISABLE_INTERRUPTS();
\r
2523 if( pxQueue->uxMessagesWaiting == ( UBaseType_t ) 0 )
\r
2525 /* There are no messages in the queue, do we want to block or just
\r
2526 * leave with nothing? */
\r
2527 if( xTicksToWait > ( TickType_t ) 0 )
\r
2529 /* As this is a co-routine we cannot block directly, but return
\r
2530 * indicating that we need to block. */
\r
2531 vCoRoutineAddToDelayedList( xTicksToWait, &( pxQueue->xTasksWaitingToReceive ) );
\r
2532 portENABLE_INTERRUPTS();
\r
2533 return errQUEUE_BLOCKED;
\r
2537 portENABLE_INTERRUPTS();
\r
2538 return errQUEUE_FULL;
\r
2543 mtCOVERAGE_TEST_MARKER();
\r
2546 portENABLE_INTERRUPTS();
\r
2548 portDISABLE_INTERRUPTS();
\r
2550 if( pxQueue->uxMessagesWaiting > ( UBaseType_t ) 0 )
\r
2552 /* Data is available from the queue. */
\r
2553 pxQueue->u.xQueue.pcReadFrom += pxQueue->uxItemSize;
\r
2555 if( pxQueue->u.xQueue.pcReadFrom >= pxQueue->u.xQueue.pcTail )
\r
2557 pxQueue->u.xQueue.pcReadFrom = pxQueue->pcHead;
\r
2561 mtCOVERAGE_TEST_MARKER();
\r
2564 --( pxQueue->uxMessagesWaiting );
\r
2565 ( void ) memcpy( ( void * ) pvBuffer, ( void * ) pxQueue->u.xQueue.pcReadFrom, ( unsigned ) pxQueue->uxItemSize );
\r
2569 /* Were any co-routines waiting for space to become available? */
\r
2570 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) == pdFALSE )
\r
2572 /* In this instance the co-routine could be placed directly
\r
2573 * into the ready list as we are within a critical section.
\r
2574 * Instead the same pending ready list mechanism is used as if
\r
2575 * the event were caused from within an interrupt. */
\r
2576 if( xCoRoutineRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) != pdFALSE )
\r
2578 xReturn = errQUEUE_YIELD;
\r
2582 mtCOVERAGE_TEST_MARKER();
\r
2587 mtCOVERAGE_TEST_MARKER();
\r
2595 portENABLE_INTERRUPTS();
\r
2600 #endif /* configUSE_CO_ROUTINES */
\r
2601 /*-----------------------------------------------------------*/
\r
2603 #if ( configUSE_CO_ROUTINES == 1 )
\r
2605 BaseType_t xQueueCRSendFromISR( QueueHandle_t xQueue,
\r
2606 const void * pvItemToQueue,
\r
2607 BaseType_t xCoRoutinePreviouslyWoken )
\r
2609 Queue_t * const pxQueue = xQueue;
\r
2611 /* Cannot block within an ISR so if there is no space on the queue then
\r
2612 * exit without doing anything. */
\r
2613 if( pxQueue->uxMessagesWaiting < pxQueue->uxLength )
\r
2615 prvCopyDataToQueue( pxQueue, pvItemToQueue, queueSEND_TO_BACK );
\r
2617 /* We only want to wake one co-routine per ISR, so check that a
\r
2618 * co-routine has not already been woken. */
\r
2619 if( xCoRoutinePreviouslyWoken == pdFALSE )
\r
2621 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
\r
2623 if( xCoRoutineRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )
\r
2629 mtCOVERAGE_TEST_MARKER();
\r
2634 mtCOVERAGE_TEST_MARKER();
\r
2639 mtCOVERAGE_TEST_MARKER();
\r
2644 mtCOVERAGE_TEST_MARKER();
\r
2647 return xCoRoutinePreviouslyWoken;
\r
2650 #endif /* configUSE_CO_ROUTINES */
\r
2651 /*-----------------------------------------------------------*/
\r
2653 #if ( configUSE_CO_ROUTINES == 1 )
\r
2655 BaseType_t xQueueCRReceiveFromISR( QueueHandle_t xQueue,
\r
2657 BaseType_t * pxCoRoutineWoken )
\r
2659 BaseType_t xReturn;
\r
2660 Queue_t * const pxQueue = xQueue;
\r
2662 /* We cannot block from an ISR, so check there is data available. If
\r
2663 * not then just leave without doing anything. */
\r
2664 if( pxQueue->uxMessagesWaiting > ( UBaseType_t ) 0 )
\r
2666 /* Copy the data from the queue. */
\r
2667 pxQueue->u.xQueue.pcReadFrom += pxQueue->uxItemSize;
\r
2669 if( pxQueue->u.xQueue.pcReadFrom >= pxQueue->u.xQueue.pcTail )
\r
2671 pxQueue->u.xQueue.pcReadFrom = pxQueue->pcHead;
\r
2675 mtCOVERAGE_TEST_MARKER();
\r
2678 --( pxQueue->uxMessagesWaiting );
\r
2679 ( void ) memcpy( ( void * ) pvBuffer, ( void * ) pxQueue->u.xQueue.pcReadFrom, ( unsigned ) pxQueue->uxItemSize );
\r
2681 if( ( *pxCoRoutineWoken ) == pdFALSE )
\r
2683 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) == pdFALSE )
\r
2685 if( xCoRoutineRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) != pdFALSE )
\r
2687 *pxCoRoutineWoken = pdTRUE;
\r
2691 mtCOVERAGE_TEST_MARKER();
\r
2696 mtCOVERAGE_TEST_MARKER();
\r
2701 mtCOVERAGE_TEST_MARKER();
\r
2714 #endif /* configUSE_CO_ROUTINES */
\r
2715 /*-----------------------------------------------------------*/
\r
2717 #if ( configQUEUE_REGISTRY_SIZE > 0 )
\r
2719 void vQueueAddToRegistry( QueueHandle_t xQueue,
\r
2720 const char * pcQueueName ) /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
\r
2724 /* See if there is an empty space in the registry. A NULL name denotes
\r
2726 for( ux = ( UBaseType_t ) 0U; ux < ( UBaseType_t ) configQUEUE_REGISTRY_SIZE; ux++ )
\r
2728 if( xQueueRegistry[ ux ].pcQueueName == NULL )
\r
2730 /* Store the information on this queue. */
\r
2731 xQueueRegistry[ ux ].pcQueueName = pcQueueName;
\r
2732 xQueueRegistry[ ux ].xHandle = xQueue;
\r
2734 traceQUEUE_REGISTRY_ADD( xQueue, pcQueueName );
\r
2739 mtCOVERAGE_TEST_MARKER();
\r
2744 #endif /* configQUEUE_REGISTRY_SIZE */
\r
2745 /*-----------------------------------------------------------*/
\r
2747 #if ( configQUEUE_REGISTRY_SIZE > 0 )
\r
2749 const char * pcQueueGetName( QueueHandle_t xQueue ) /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
\r
2752 const char * pcReturn = NULL; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
\r
2754 /* Note there is nothing here to protect against another task adding or
\r
2755 * removing entries from the registry while it is being searched. */
\r
2757 for( ux = ( UBaseType_t ) 0U; ux < ( UBaseType_t ) configQUEUE_REGISTRY_SIZE; ux++ )
\r
2759 if( xQueueRegistry[ ux ].xHandle == xQueue )
\r
2761 pcReturn = xQueueRegistry[ ux ].pcQueueName;
\r
2766 mtCOVERAGE_TEST_MARKER();
\r
2771 } /*lint !e818 xQueue cannot be a pointer to const because it is a typedef. */
\r
2773 #endif /* configQUEUE_REGISTRY_SIZE */
\r
2774 /*-----------------------------------------------------------*/
\r
2776 #if ( configQUEUE_REGISTRY_SIZE > 0 )
\r
2778 void vQueueUnregisterQueue( QueueHandle_t xQueue )
\r
2782 /* See if the handle of the queue being unregistered in actually in the
\r
2784 for( ux = ( UBaseType_t ) 0U; ux < ( UBaseType_t ) configQUEUE_REGISTRY_SIZE; ux++ )
\r
2786 if( xQueueRegistry[ ux ].xHandle == xQueue )
\r
2788 /* Set the name to NULL to show that this slot if free again. */
\r
2789 xQueueRegistry[ ux ].pcQueueName = NULL;
\r
2791 /* Set the handle to NULL to ensure the same queue handle cannot
\r
2792 * appear in the registry twice if it is added, removed, then
\r
2794 xQueueRegistry[ ux ].xHandle = ( QueueHandle_t ) 0;
\r
2799 mtCOVERAGE_TEST_MARKER();
\r
2802 } /*lint !e818 xQueue could not be pointer to const because it is a typedef. */
\r
2804 #endif /* configQUEUE_REGISTRY_SIZE */
\r
2805 /*-----------------------------------------------------------*/
\r
2807 #if ( configUSE_TIMERS == 1 )
\r
2809 void vQueueWaitForMessageRestricted( QueueHandle_t xQueue,
\r
2810 TickType_t xTicksToWait,
\r
2811 const BaseType_t xWaitIndefinitely )
\r
2813 Queue_t * const pxQueue = xQueue;
\r
2815 /* This function should not be called by application code hence the
\r
2816 * 'Restricted' in its name. It is not part of the public API. It is
\r
2817 * designed for use by kernel code, and has special calling requirements.
\r
2818 * It can result in vListInsert() being called on a list that can only
\r
2819 * possibly ever have one item in it, so the list will be fast, but even
\r
2820 * so it should be called with the scheduler locked and not from a critical
\r
2823 /* Only do anything if there are no messages in the queue. This function
\r
2824 * will not actually cause the task to block, just place it on a blocked
\r
2825 * list. It will not block until the scheduler is unlocked - at which
\r
2826 * time a yield will be performed. If an item is added to the queue while
\r
2827 * the queue is locked, and the calling task blocks on the queue, then the
\r
2828 * calling task will be immediately unblocked when the queue is unlocked. */
\r
2829 prvLockQueue( pxQueue );
\r
2831 if( pxQueue->uxMessagesWaiting == ( UBaseType_t ) 0U )
\r
2833 /* There is nothing in the queue, block for the specified period. */
\r
2834 vTaskPlaceOnEventListRestricted( &( pxQueue->xTasksWaitingToReceive ), xTicksToWait, xWaitIndefinitely );
\r
2838 mtCOVERAGE_TEST_MARKER();
\r
2841 prvUnlockQueue( pxQueue );
\r
2844 #endif /* configUSE_TIMERS */
\r
2845 /*-----------------------------------------------------------*/
\r
2847 #if ( ( configUSE_QUEUE_SETS == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
\r
2849 QueueSetHandle_t xQueueCreateSet( const UBaseType_t uxEventQueueLength )
\r
2851 QueueSetHandle_t pxQueue;
\r
2853 pxQueue = xQueueGenericCreate( uxEventQueueLength, ( UBaseType_t ) sizeof( Queue_t * ), queueQUEUE_TYPE_SET );
\r
2858 #endif /* configUSE_QUEUE_SETS */
\r
2859 /*-----------------------------------------------------------*/
\r
2861 #if ( configUSE_QUEUE_SETS == 1 )
\r
2863 BaseType_t xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore,
\r
2864 QueueSetHandle_t xQueueSet )
\r
2866 BaseType_t xReturn;
\r
2868 taskENTER_CRITICAL();
\r
2870 if( ( ( Queue_t * ) xQueueOrSemaphore )->pxQueueSetContainer != NULL )
\r
2872 /* Cannot add a queue/semaphore to more than one queue set. */
\r
2875 else if( ( ( Queue_t * ) xQueueOrSemaphore )->uxMessagesWaiting != ( UBaseType_t ) 0 )
\r
2877 /* Cannot add a queue/semaphore to a queue set if there are already
\r
2878 * items in the queue/semaphore. */
\r
2883 ( ( Queue_t * ) xQueueOrSemaphore )->pxQueueSetContainer = xQueueSet;
\r
2887 taskEXIT_CRITICAL();
\r
2892 #endif /* configUSE_QUEUE_SETS */
\r
2893 /*-----------------------------------------------------------*/
\r
2895 #if ( configUSE_QUEUE_SETS == 1 )
\r
2897 BaseType_t xQueueRemoveFromSet( QueueSetMemberHandle_t xQueueOrSemaphore,
\r
2898 QueueSetHandle_t xQueueSet )
\r
2900 BaseType_t xReturn;
\r
2901 Queue_t * const pxQueueOrSemaphore = ( Queue_t * ) xQueueOrSemaphore;
\r
2903 if( pxQueueOrSemaphore->pxQueueSetContainer != xQueueSet )
\r
2905 /* The queue was not a member of the set. */
\r
2908 else if( pxQueueOrSemaphore->uxMessagesWaiting != ( UBaseType_t ) 0 )
\r
2910 /* It is dangerous to remove a queue from a set when the queue is
\r
2911 * not empty because the queue set will still hold pending events for
\r
2917 taskENTER_CRITICAL();
\r
2919 /* The queue is no longer contained in the set. */
\r
2920 pxQueueOrSemaphore->pxQueueSetContainer = NULL;
\r
2922 taskEXIT_CRITICAL();
\r
2927 } /*lint !e818 xQueueSet could not be declared as pointing to const as it is a typedef. */
\r
2929 #endif /* configUSE_QUEUE_SETS */
\r
2930 /*-----------------------------------------------------------*/
\r
2932 #if ( configUSE_QUEUE_SETS == 1 )
\r
2934 QueueSetMemberHandle_t xQueueSelectFromSet( QueueSetHandle_t xQueueSet,
\r
2935 TickType_t const xTicksToWait )
\r
2937 QueueSetMemberHandle_t xReturn = NULL;
\r
2939 ( void ) xQueueReceive( ( QueueHandle_t ) xQueueSet, &xReturn, xTicksToWait ); /*lint !e961 Casting from one typedef to another is not redundant. */
\r
2943 #endif /* configUSE_QUEUE_SETS */
\r
2944 /*-----------------------------------------------------------*/
\r
2946 #if ( configUSE_QUEUE_SETS == 1 )
\r
2948 QueueSetMemberHandle_t xQueueSelectFromSetFromISR( QueueSetHandle_t xQueueSet )
\r
2950 QueueSetMemberHandle_t xReturn = NULL;
\r
2952 ( void ) xQueueReceiveFromISR( ( QueueHandle_t ) xQueueSet, &xReturn, NULL ); /*lint !e961 Casting from one typedef to another is not redundant. */
\r
2956 #endif /* configUSE_QUEUE_SETS */
\r
2957 /*-----------------------------------------------------------*/
\r
2959 #if ( configUSE_QUEUE_SETS == 1 )
\r
2961 static BaseType_t prvNotifyQueueSetContainer( const Queue_t * const pxQueue )
\r
2963 Queue_t * pxQueueSetContainer = pxQueue->pxQueueSetContainer;
\r
2964 BaseType_t xReturn = pdFALSE;
\r
2966 /* This function must be called form a critical section. */
\r
2968 configASSERT( pxQueueSetContainer );
\r
2969 configASSERT( pxQueueSetContainer->uxMessagesWaiting < pxQueueSetContainer->uxLength );
\r
2971 if( pxQueueSetContainer->uxMessagesWaiting < pxQueueSetContainer->uxLength )
\r
2973 const int8_t cTxLock = pxQueueSetContainer->cTxLock;
\r
2975 traceQUEUE_SET_SEND( pxQueueSetContainer );
\r
2977 /* The data copied is the handle of the queue that contains data. */
\r
2978 xReturn = prvCopyDataToQueue( pxQueueSetContainer, &pxQueue, queueSEND_TO_BACK );
\r
2980 if( cTxLock == queueUNLOCKED )
\r
2982 if( listLIST_IS_EMPTY( &( pxQueueSetContainer->xTasksWaitingToReceive ) ) == pdFALSE )
\r
2984 if( xTaskRemoveFromEventList( &( pxQueueSetContainer->xTasksWaitingToReceive ) ) != pdFALSE )
\r
2986 /* The task waiting has a higher priority. */
\r
2991 mtCOVERAGE_TEST_MARKER();
\r
2996 mtCOVERAGE_TEST_MARKER();
\r
3001 configASSERT( cTxLock != queueINT8_MAX );
\r
3003 pxQueueSetContainer->cTxLock = ( int8_t ) ( cTxLock + 1 );
\r
3008 mtCOVERAGE_TEST_MARKER();
\r
3014 #endif /* configUSE_QUEUE_SETS */
\r
begriffs.com / projects / freertos / blob