/*\r
- FreeRTOS V8.2.3 - Copyright (C) 2015 Real Time Engineers Ltd.\r
+ FreeRTOS V9.0.0 - Copyright (C) 2016 Real Time Engineers Ltd.\r
All rights reserved\r
\r
VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.\r
* Creates a new queue instance, and returns a handle by which the new queue\r
* can be referenced.\r
*\r
- * Internally, within the FreeRTOS implementation, queue's use two blocks of\r
+ * Internally, within the FreeRTOS implementation, queues use two blocks of\r
* memory. The first block is used to hold the queue's data structures. The\r
* second block is used to hold items placed into the queue. If a queue is\r
* created using xQueueCreate() then both blocks of memory are automatically\r
* dynamically allocated inside the xQueueCreate() function. (see\r
* http://www.freertos.org/a00111.html). If a queue is created using\r
- * xQueueCreateStatic() then the application writer can instead optionally\r
- * provide the memory that will get used by the queue. xQueueCreateStatic()\r
- * therefore allows a queue to be created without using any dynamic memory\r
- * allocation.\r
+ * xQueueCreateStatic() then the application writer must provide the memory that\r
+ * will get used by the queue. xQueueCreateStatic() therefore allows a queue to\r
+ * be created without using any dynamic memory allocation.\r
+ *\r
+ * http://www.FreeRTOS.org/Embedded-RTOS-Queues.html\r
*\r
* @param uxQueueLength The maximum number of items that the queue can contain.\r
*\r
* \defgroup xQueueCreate xQueueCreate\r
* \ingroup QueueManagement\r
*/\r
-#define xQueueCreate( uxQueueLength, uxItemSize ) xQueueGenericCreate( uxQueueLength, uxItemSize, NULL, NULL, queueQUEUE_TYPE_BASE )\r
+#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
+ #define xQueueCreate( uxQueueLength, uxItemSize ) xQueueGenericCreate( ( uxQueueLength ), ( uxItemSize ), ( queueQUEUE_TYPE_BASE ) )\r
+#endif\r
\r
/**\r
* queue. h\r
* Creates a new queue instance, and returns a handle by which the new queue\r
* can be referenced.\r
*\r
- * Internally, within the FreeRTOS implementation, queue's use two blocks of\r
+ * Internally, within the FreeRTOS implementation, queues use two blocks of\r
* memory. The first block is used to hold the queue's data structures. The\r
* second block is used to hold items placed into the queue. If a queue is\r
* created using xQueueCreate() then both blocks of memory are automatically\r
* dynamically allocated inside the xQueueCreate() function. (see\r
* http://www.freertos.org/a00111.html). If a queue is created using\r
- * xQueueCreateStatic() then the application writer can instead optionally\r
- * provide the memory that will get used by the queue. xQueueCreateStatic()\r
- * therefore allows a queue to be created without using any dynamic memory\r
- * allocation.\r
+ * xQueueCreateStatic() then the application writer must provide the memory that\r
+ * will get used by the queue. xQueueCreateStatic() therefore allows a queue to\r
+ * be created without using any dynamic memory allocation.\r
+ *\r
+ * http://www.FreeRTOS.org/Embedded-RTOS-Queues.html\r
*\r
* @param uxQueueLength The maximum number of items that the queue can contain.\r
*\r
* that will be copied for each posted item. Each item on the queue must be\r
* the same size.\r
*\r
- * @param pucQueueStorageBuffer If pucQueueStorageBuffer is NULL then the memory\r
- * used to hold items stored in the queue will be allocated dynamically, just as\r
- * when a queue is created using xQueueCreate(). If pxQueueStorageBuffer is not\r
- * NULL then it must point to a uint8_t array that is at least large enough to\r
- * hold the maximum number of items that can be in the queue at any one time -\r
- * which is ( uxQueueLength * uxItemsSize ) bytes.\r
- *\r
- * @param pxQueueBuffer If pxQueueBuffer is NULL then the memory required to\r
- * hold the queue's data structures will be allocated dynamically, just as when\r
- * a queue is created using xQueueCreate(). If pxQueueBuffer is not NULL then\r
- * it must point to a variable of type StaticQueue_t, which will then be used to\r
- * hold the queue's data structure, removing the need for the memory to be\r
- * allocated dynamically.\r
- *\r
- * @return If neither pucQueueStorageBuffer or pxQueueBuffer are NULL, then the\r
- * function will not attempt any dynamic memory allocation, and a handle to the\r
- * created queue will always be returned. If pucQueueStorageBuffer or\r
- * pxQueueBuffer is NULL then the function will attempt to dynamically allocate\r
- * one of both buffers. In this case, if the allocation succeeds then a handle\r
- * to the created queue will be returned, and if one of the the allocation fails\r
- * NULL will be returned.\r
+ * @param pucQueueStorageBuffer If uxItemSize is not zero then\r
+ * pucQueueStorageBuffer must point to a uint8_t array that is at least large\r
+ * enough to hold the maximum number of items that can be in the queue at any\r
+ * one time - which is ( uxQueueLength * uxItemsSize ) bytes. If uxItemSize is\r
+ * zero then pucQueueStorageBuffer can be NULL.\r
+ *\r
+ * @param pxQueueBuffer Must point to a variable of type StaticQueue_t, which\r
+ * will be used to hold the queue's data structure.\r
+ *\r
+ * @return If the queue is created then a handle to the created queue is\r
+ * returned. If pxQueueBuffer is NULL then NULL is returned.\r
*\r
* Example usage:\r
<pre>\r
&xQueueBuffer ); // The buffer that will hold the queue structure.\r
\r
// The queue is guaranteed to be created successfully as no dynamic memory\r
- // allocation was used. Therefore xQueue1 is now a handle to a valid queue.\r
+ // allocation is used. Therefore xQueue1 is now a handle to a valid queue.\r
\r
// ... Rest of task code.\r
}\r
* \ingroup QueueManagement\r
*/\r
#if( configSUPPORT_STATIC_ALLOCATION == 1 )\r
- #define xQueueCreateStatic( uxQueueLength, uxItemSize, pucQueueStorage, pxQueueBuffer ) xQueueGenericCreate( ( uxQueueLength ), ( uxItemSize ), ( pucQueueStorage ), ( pxQueueBuffer ), ( queueQUEUE_TYPE_BASE ) )\r
+ #define xQueueCreateStatic( uxQueueLength, uxItemSize, pucQueueStorage, pxQueueBuffer ) xQueueGenericCreateStatic( ( uxQueueLength ), ( uxItemSize ), ( pucQueueStorage ), ( pxQueueBuffer ), ( queueQUEUE_TYPE_BASE ) )\r
#endif /* configSUPPORT_STATIC_ALLOCATION */\r
\r
/**\r
BaseType_t xQueueIsQueueFullFromISR( const QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;\r
UBaseType_t uxQueueMessagesWaitingFromISR( const QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;\r
\r
-\r
-/*\r
- * xQueueAltGenericSend() is an alternative version of xQueueGenericSend().\r
- * Likewise xQueueAltGenericReceive() is an alternative version of\r
- * xQueueGenericReceive().\r
- *\r
- * The source code that implements the alternative (Alt) API is much\r
- * simpler because it executes everything from within a critical section.\r
- * This is the approach taken by many other RTOSes, but FreeRTOS.org has the\r
- * preferred fully featured API too. The fully featured API has more\r
- * complex code that takes longer to execute, but makes much less use of\r
- * critical sections. Therefore the alternative API sacrifices interrupt\r
- * responsiveness to gain execution speed, whereas the fully featured API\r
- * sacrifices execution speed to ensure better interrupt responsiveness.\r
- */\r
-BaseType_t xQueueAltGenericSend( QueueHandle_t xQueue, const void * const pvItemToQueue, TickType_t xTicksToWait, BaseType_t xCopyPosition ) PRIVILEGED_FUNCTION;\r
-BaseType_t xQueueAltGenericReceive( QueueHandle_t xQueue, void * const pvBuffer, TickType_t xTicksToWait, BaseType_t xJustPeeking ) PRIVILEGED_FUNCTION;\r
-#define xQueueAltSendToFront( xQueue, pvItemToQueue, xTicksToWait ) xQueueAltGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_FRONT )\r
-#define xQueueAltSendToBack( xQueue, pvItemToQueue, xTicksToWait ) xQueueAltGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_BACK )\r
-#define xQueueAltReceive( xQueue, pvBuffer, xTicksToWait ) xQueueAltGenericReceive( ( xQueue ), ( pvBuffer ), ( xTicksToWait ), pdFALSE )\r
-#define xQueueAltPeek( xQueue, pvBuffer, xTicksToWait ) xQueueAltGenericReceive( ( xQueue ), ( pvBuffer ), ( xTicksToWait ), pdTRUE )\r
-\r
/*\r
* The functions defined above are for passing data to and from tasks. The\r
* functions below are the equivalents for passing data to and from\r
* xSemaphoreCreateCounting() or xSemaphoreGetMutexHolder() instead of calling\r
* these functions directly.\r
*/\r
-QueueHandle_t xQueueCreateMutex( const uint8_t ucQueueType, StaticQueue_t *pxStaticQueue ) PRIVILEGED_FUNCTION;\r
-QueueHandle_t xQueueCreateCountingSemaphore( const UBaseType_t uxMaxCount, const UBaseType_t uxInitialCount, StaticQueue_t *pxStaticQueue ) PRIVILEGED_FUNCTION;\r
+QueueHandle_t xQueueCreateMutex( const uint8_t ucQueueType ) PRIVILEGED_FUNCTION;\r
+QueueHandle_t xQueueCreateMutexStatic( const uint8_t ucQueueType, StaticQueue_t *pxStaticQueue ) PRIVILEGED_FUNCTION;\r
+QueueHandle_t xQueueCreateCountingSemaphore( const UBaseType_t uxMaxCount, const UBaseType_t uxInitialCount ) PRIVILEGED_FUNCTION;\r
+QueueHandle_t xQueueCreateCountingSemaphoreStatic( const UBaseType_t uxMaxCount, const UBaseType_t uxInitialCount, StaticQueue_t *pxStaticQueue ) PRIVILEGED_FUNCTION;\r
void* xQueueGetMutexHolder( QueueHandle_t xSemaphore ) PRIVILEGED_FUNCTION;\r
+void* xQueueGetMutexHolderFromISR( QueueHandle_t xSemaphore ) PRIVILEGED_FUNCTION;\r
\r
/*\r
* For internal use only. Use xSemaphoreTakeMutexRecursive() or\r
#endif\r
\r
/*\r
- * The registry is provided as a means for kernel aware debuggers to\r
- * locate queues, semaphores and mutexes. Call pcQueueGetQueueName() to look\r
+ * The queue registry is provided as a means for kernel aware debuggers to\r
+ * locate queues, semaphores and mutexes. Call pcQueueGetName() to look\r
* up and return the name of a queue in the queue registry from the queue's\r
* handle.\r
*\r
* returned.\r
*/\r
#if( configQUEUE_REGISTRY_SIZE > 0 )\r
- const char *pcQueueGetQueueName( QueueHandle_t xQueue ); /*lint !e971 Unqualified char types are allowed for strings and single characters only. */\r
+ const char *pcQueueGetName( QueueHandle_t xQueue ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */\r
+#endif\r
+\r
+/*\r
+ * Generic version of the function used to creaet a queue using dynamic memory\r
+ * allocation. This is called by other functions and macros that create other\r
+ * RTOS objects that use the queue structure as their base.\r
+ */\r
+#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
+ QueueHandle_t xQueueGenericCreate( const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, const uint8_t ucQueueType ) PRIVILEGED_FUNCTION;\r
#endif\r
\r
/*\r
- * Generic version of the queue creation function, which is in turn called by\r
- * any queue, semaphore or mutex creation function or macro.\r
+ * Generic version of the function used to creaet a queue using dynamic memory\r
+ * allocation. This is called by other functions and macros that create other\r
+ * RTOS objects that use the queue structure as their base.\r
*/\r
-QueueHandle_t xQueueGenericCreate( const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, uint8_t *pucQueueStorage, StaticQueue_t *pxStaticQueue, const uint8_t ucQueueType ) PRIVILEGED_FUNCTION;\r
+#if( configSUPPORT_STATIC_ALLOCATION == 1 )\r
+ QueueHandle_t xQueueGenericCreateStatic( const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, uint8_t *pucQueueStorage, StaticQueue_t *pxStaticQueue, const uint8_t ucQueueType ) PRIVILEGED_FUNCTION;\r
+#endif\r
\r
/*\r
* Queue sets provide a mechanism to allow a task to block (pend) on a read\r
projects / freertos / blobdiff