diff --git a/FreeRTOS/Source/croutine.c b/FreeRTOS/Source/croutine.c
index d428dccca..c2fdc50fe 100644
--- a/FreeRTOS/Source/croutine.c
+++ b/FreeRTOS/Source/croutine.c
@@ -1,7 +1,7 @@
/*
FreeRTOS V7.3.0 - Copyright (C) 2012 Real Time Engineers Ltd.
- FEATURES AND PORTS ARE ADDED TO FREERTOS ALL THE TIME. PLEASE VISIT
+ FEATURES AND PORTS ARE ADDED TO FREERTOS ALL THE TIME. PLEASE VISIT
http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
***************************************************************************
@@ -42,7 +42,7 @@
FreeRTOS WEB site.
1 tab == 4 spaces!
-
+
***************************************************************************
* *
* Having a problem? Start by reading the FAQ "My application does *
@@ -52,17 +52,17 @@
* *
***************************************************************************
-
- http://www.FreeRTOS.org - Documentation, training, latest versions, license
- and contact details.
-
+
+ http://www.FreeRTOS.org - Documentation, training, latest versions, license
+ and contact details.
+
http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,
including FreeRTOS+Trace - an indispensable productivity tool.
- Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell
- the code with commercial support, indemnification, and middleware, under
+ Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell
+ the code with commercial support, indemnification, and middleware, under
the OpenRTOS brand: http://www.OpenRTOS.com. High Integrity Systems also
- provide a safety engineered and independently SIL3 certified version under
+ provide a safety engineered and independently SIL3 certified version under
the SafeRTOS brand: http://www.SafeRTOS.com.
*/
@@ -85,7 +85,7 @@ static xList xDelayedCoRoutineList1; /*< Delayed co-routines. */
static xList xDelayedCoRoutineList2; /*< Delayed co-routines (two lists are used - one for delays that have overflowed the current tick count. */
static xList * pxDelayedCoRoutineList; /*< Points to the delayed co-routine list currently being used. */
static xList * pxOverflowDelayedCoRoutineList; /*< Points to the delayed co-routine list currently being used to hold co-routines that have overflowed the current tick count. */
-static xList xPendingReadyCoRoutineList; /*< Holds co-routines that have been readied by an external event. They cannot be added directly to the ready lists as the ready lists cannot be accessed by interrupts. */
+static xList xPendingReadyCoRoutineList; /*< Holds co-routines that have been readied by an external event. They cannot be added directly to the ready lists as the ready lists cannot be accessed by interrupts. */
/* Other file private variables. --------------------------------*/
corCRCB * pxCurrentCoRoutine = NULL;
@@ -109,7 +109,7 @@ static portTickType xCoRoutineTickCount = 0, xLastTickCount = 0, xPassedTicks =
uxTopCoRoutineReadyPriority = pxCRCB->uxPriority; \
} \
vListInsertEnd( ( xList * ) &( pxReadyCoRoutineLists[ pxCRCB->uxPriority ] ), &( pxCRCB->xGenericListItem ) ); \
-}
+}
/*
* Utility to ready all the lists used by the scheduler. This is called
@@ -175,10 +175,10 @@ corCRCB *pxCoRoutine;
in a list. */
listSET_LIST_ITEM_OWNER( &( pxCoRoutine->xGenericListItem ), pxCoRoutine );
listSET_LIST_ITEM_OWNER( &( pxCoRoutine->xEventListItem ), pxCoRoutine );
-
+
/* Event lists are always in priority order. */
listSET_LIST_ITEM_VALUE( &( pxCoRoutine->xEventListItem ), configMAX_PRIORITIES - ( portTickType ) uxPriority );
-
+
/* Now the co-routine has been initialised it can be added to the ready
list at the correct priority. */
prvAddCoRoutineToReadyQueue( pxCoRoutine );
@@ -186,11 +186,11 @@ corCRCB *pxCoRoutine;
xReturn = pdPASS;
}
else
- {
+ {
xReturn = errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY;
}
-
- return xReturn;
+
+ return xReturn;
}
/*-----------------------------------------------------------*/
@@ -243,14 +243,14 @@ static void prvCheckPendingReadyList( void )
/* The pending ready list can be accessed by an ISR. */
portDISABLE_INTERRUPTS();
- {
- pxUnblockedCRCB = ( corCRCB * ) listGET_OWNER_OF_HEAD_ENTRY( (&xPendingReadyCoRoutineList) );
+ {
+ pxUnblockedCRCB = ( corCRCB * ) listGET_OWNER_OF_HEAD_ENTRY( (&xPendingReadyCoRoutineList) );
uxListRemove( &( pxUnblockedCRCB->xEventListItem ) );
}
portENABLE_INTERRUPTS();
uxListRemove( &( pxUnblockedCRCB->xGenericListItem ) );
- prvAddCoRoutineToReadyQueue( pxUnblockedCRCB );
+ prvAddCoRoutineToReadyQueue( pxUnblockedCRCB );
}
}
/*-----------------------------------------------------------*/
@@ -282,11 +282,11 @@ corCRCB *pxCRCB;
{
pxCRCB = ( corCRCB * ) listGET_OWNER_OF_HEAD_ENTRY( pxDelayedCoRoutineList );
- if( xCoRoutineTickCount < listGET_LIST_ITEM_VALUE( &( pxCRCB->xGenericListItem ) ) )
- {
- /* Timeout not yet expired. */
- break;
- }
+ if( xCoRoutineTickCount < listGET_LIST_ITEM_VALUE( &( pxCRCB->xGenericListItem ) ) )
+ {
+ /* Timeout not yet expired. */
+ break;
+ }
portDISABLE_INTERRUPTS();
{
@@ -295,18 +295,18 @@ corCRCB *pxCRCB;
have been moved to the pending ready list and the following
line is still valid. Also the pvContainer parameter will have
been set to NULL so the following lines are also valid. */
- uxListRemove( &( pxCRCB->xGenericListItem ) );
+ uxListRemove( &( pxCRCB->xGenericListItem ) );
- /* Is the co-routine waiting on an event also? */
- if( pxCRCB->xEventListItem.pvContainer )
- {
- uxListRemove( &( pxCRCB->xEventListItem ) );
+ /* Is the co-routine waiting on an event also? */
+ if( pxCRCB->xEventListItem.pvContainer )
+ {
+ uxListRemove( &( pxCRCB->xEventListItem ) );
}
}
portENABLE_INTERRUPTS();
- prvAddCoRoutineToReadyQueue( pxCRCB );
- }
+ prvAddCoRoutineToReadyQueue( pxCRCB );
+ }
}
xLastTickCount = xCoRoutineTickCount;
diff --git a/FreeRTOS/Source/include/queue.h b/FreeRTOS/Source/include/queue.h
index 9118bb766..3e5d4026c 100644
--- a/FreeRTOS/Source/include/queue.h
+++ b/FreeRTOS/Source/include/queue.h
@@ -96,18 +96,19 @@ typedef void * xQueueHandle;
typedef void * xQueueSetHandle;
/**
- * Queue sets can contain both queues and semaphores, so the
+ * Queue sets can contain both queues and semaphores, so the
* xQueueSetMemberHandle is defined as a type to be used where a parameter or
* return value can be either an xQueueHandle or an xSemaphoreHandle.
*/
typedef void * xQueueSetMemberHandle;
-
+
/* For internal use only. */
#define queueSEND_TO_BACK ( 0 )
#define queueSEND_TO_FRONT ( 1 )
/* For internal use only. These definitions *must* match those in queue.c. */
#define queueQUEUE_TYPE_BASE ( 0U )
+#define queueQUEUE_TYPE_SET ( 0U )
#define queueQUEUE_TYPE_MUTEX ( 1U )
#define queueQUEUE_TYPE_COUNTING_SEMAPHORE ( 2U )
#define queueQUEUE_TYPE_BINARY_SEMAPHORE ( 3U )
@@ -505,7 +506,7 @@ typedef void * xQueueSetMemberHandle;
* \defgroup xQueueSend xQueueSend
* \ingroup QueueManagement
*/
-signed portBASE_TYPE xQueueGenericSend( xQueueHandle pxQueue, const void * const pvItemToQueue, portTickType xTicksToWait, portBASE_TYPE xCopyPosition );
+signed portBASE_TYPE xQueueGenericSend( xQueueHandle xQueue, const void * const pvItemToQueue, portTickType xTicksToWait, portBASE_TYPE xCopyPosition );
/**
* queue. h
@@ -528,7 +529,7 @@ signed portBASE_TYPE xQueueGenericSend( xQueueHandle pxQueue, const void * const
*
* This macro must not be used in an interrupt service routine.
*
- * @param pxQueue The handle to the queue from which the item is to be
+ * @param xQueue The handle to the queue from which the item is to be
* received.
*
* @param pvBuffer Pointer to the buffer into which the received item will
@@ -621,7 +622,7 @@ signed portBASE_TYPE xQueueGenericSend( xQueueHandle pxQueue, const void * const
* This function must not be used in an interrupt service routine. See
* xQueueReceiveFromISR for an alternative that can.
*
- * @param pxQueue The handle to the queue from which the item is to be
+ * @param xQueue The handle to the queue from which the item is to be
* received.
*
* @param pvBuffer Pointer to the buffer into which the received item will
@@ -715,7 +716,7 @@ signed portBASE_TYPE xQueueGenericSend( xQueueHandle pxQueue, const void * const
* This function must not be used in an interrupt service routine. See
* xQueueReceiveFromISR for an alternative that can.
*
- * @param pxQueue The handle to the queue from which the item is to be
+ * @param xQueue The handle to the queue from which the item is to be
* received.
*
* @param pvBuffer Pointer to the buffer into which the received item will
@@ -820,13 +821,13 @@ unsigned portBASE_TYPE uxQueueMessagesWaiting( const xQueueHandle xQueue );
* \page vQueueDelete vQueueDelete
* \ingroup QueueManagement
*/
-void vQueueDelete( xQueueHandle pxQueue );
+void vQueueDelete( xQueueHandle xQueue );
/**
* queue. h
*
portBASE_TYPE xQueueSendToFrontFromISR(
- xQueueHandle pxQueue,
+ xQueueHandle xQueue,
const void *pvItemToQueue,
portBASE_TYPE *pxHigherPriorityTaskWoken
);
@@ -890,14 +891,14 @@ void vQueueDelete( xQueueHandle pxQueue );
* \defgroup xQueueSendFromISR xQueueSendFromISR
* \ingroup QueueManagement
*/
-#define xQueueSendToFrontFromISR( pxQueue, pvItemToQueue, pxHigherPriorityTaskWoken ) xQueueGenericSendFromISR( ( pxQueue ), ( pvItemToQueue ), ( pxHigherPriorityTaskWoken ), queueSEND_TO_FRONT )
+#define xQueueSendToFrontFromISR( xQueue, pvItemToQueue, pxHigherPriorityTaskWoken ) xQueueGenericSendFromISR( ( xQueue ), ( pvItemToQueue ), ( pxHigherPriorityTaskWoken ), queueSEND_TO_FRONT )
/**
* queue. h
*
portBASE_TYPE xQueueSendToBackFromISR(
- xQueueHandle pxQueue,
+ xQueueHandle xQueue,
const void *pvItemToQueue,
portBASE_TYPE *pxHigherPriorityTaskWoken
);
@@ -961,13 +962,13 @@ void vQueueDelete( xQueueHandle pxQueue );
* \defgroup xQueueSendFromISR xQueueSendFromISR
* \ingroup QueueManagement
*/
-#define xQueueSendToBackFromISR( pxQueue, pvItemToQueue, pxHigherPriorityTaskWoken ) xQueueGenericSendFromISR( ( pxQueue ), ( pvItemToQueue ), ( pxHigherPriorityTaskWoken ), queueSEND_TO_BACK )
+#define xQueueSendToBackFromISR( xQueue, pvItemToQueue, pxHigherPriorityTaskWoken ) xQueueGenericSendFromISR( ( xQueue ), ( pvItemToQueue ), ( pxHigherPriorityTaskWoken ), queueSEND_TO_BACK )
/**
* queue. h
*
portBASE_TYPE xQueueSendFromISR(
- xQueueHandle pxQueue,
+ xQueueHandle xQueue,
const void *pvItemToQueue,
portBASE_TYPE *pxHigherPriorityTaskWoken
);
@@ -1035,13 +1036,13 @@ void vQueueDelete( xQueueHandle pxQueue );
* \defgroup xQueueSendFromISR xQueueSendFromISR
* \ingroup QueueManagement
*/
-#define xQueueSendFromISR( pxQueue, pvItemToQueue, pxHigherPriorityTaskWoken ) xQueueGenericSendFromISR( ( pxQueue ), ( pvItemToQueue ), ( pxHigherPriorityTaskWoken ), queueSEND_TO_BACK )
+#define xQueueSendFromISR( xQueue, pvItemToQueue, pxHigherPriorityTaskWoken ) xQueueGenericSendFromISR( ( xQueue ), ( pvItemToQueue ), ( pxHigherPriorityTaskWoken ), queueSEND_TO_BACK )
/**
* queue. h
*
portBASE_TYPE xQueueGenericSendFromISR(
- xQueueHandle pxQueue,
+ xQueueHandle xQueue,
const void *pvItemToQueue,
portBASE_TYPE *pxHigherPriorityTaskWoken,
portBASE_TYPE xCopyPosition
@@ -1113,22 +1114,22 @@ void vQueueDelete( xQueueHandle pxQueue );
* \defgroup xQueueSendFromISR xQueueSendFromISR
* \ingroup QueueManagement
*/
-signed portBASE_TYPE xQueueGenericSendFromISR( xQueueHandle pxQueue, const void * const pvItemToQueue, signed portBASE_TYPE *pxHigherPriorityTaskWoken, portBASE_TYPE xCopyPosition );
+signed portBASE_TYPE xQueueGenericSendFromISR( xQueueHandle xQueue, const void * const pvItemToQueue, signed portBASE_TYPE *pxHigherPriorityTaskWoken, portBASE_TYPE xCopyPosition );
/**
* queue. h
*
portBASE_TYPE xQueueReceiveFromISR(
- xQueueHandle pxQueue,
+ xQueueHandle xQueue,
void *pvBuffer,
- portBASE_TYPE *pxTaskWoken
+ portBASE_TYPE *pxTaskWoken
);
*
*
* Receive an item from a queue. It is safe to use this function from within an
* interrupt service routine.
*
- * @param pxQueue The handle to the queue from which the item is to be
+ * @param xQueue The handle to the queue from which the item is to be
* received.
*
* @param pvBuffer Pointer to the buffer into which the received item will
@@ -1202,15 +1203,15 @@ signed portBASE_TYPE xQueueGenericSendFromISR( xQueueHandle pxQueue, const void
* \defgroup xQueueReceiveFromISR xQueueReceiveFromISR
* \ingroup QueueManagement
*/
-signed portBASE_TYPE xQueueReceiveFromISR( xQueueHandle pxQueue, void * const pvBuffer, signed portBASE_TYPE *pxHigherPriorityTaskWoken );
+signed portBASE_TYPE xQueueReceiveFromISR( xQueueHandle xQueue, void * const pvBuffer, signed portBASE_TYPE *pxHigherPriorityTaskWoken );
/*
* Utilities to query queues that are safe to use from an ISR. These utilities
* should be used only from witin an ISR, or within a critical section.
*/
-signed portBASE_TYPE xQueueIsQueueEmptyFromISR( const xQueueHandle pxQueue );
-signed portBASE_TYPE xQueueIsQueueFullFromISR( const xQueueHandle pxQueue );
-unsigned portBASE_TYPE uxQueueMessagesWaitingFromISR( const xQueueHandle pxQueue );
+signed portBASE_TYPE xQueueIsQueueEmptyFromISR( const xQueueHandle xQueue );
+signed portBASE_TYPE xQueueIsQueueFullFromISR( const xQueueHandle xQueue );
+unsigned portBASE_TYPE uxQueueMessagesWaitingFromISR( const xQueueHandle xQueue );
/*
@@ -1227,8 +1228,8 @@ unsigned portBASE_TYPE uxQueueMessagesWaitingFromISR( const xQueueHandle pxQueue
* responsiveness to gain execution speed, whereas the fully featured API
* sacrifices execution speed to ensure better interrupt responsiveness.
*/
-signed portBASE_TYPE xQueueAltGenericSend( xQueueHandle pxQueue, const void * const pvItemToQueue, portTickType xTicksToWait, portBASE_TYPE xCopyPosition );
-signed portBASE_TYPE xQueueAltGenericReceive( xQueueHandle pxQueue, void * const pvBuffer, portTickType xTicksToWait, portBASE_TYPE xJustPeeking );
+signed portBASE_TYPE xQueueAltGenericSend( xQueueHandle xQueue, const void * const pvItemToQueue, portTickType xTicksToWait, portBASE_TYPE xCopyPosition );
+signed portBASE_TYPE xQueueAltGenericReceive( xQueueHandle xQueue, void * const pvBuffer, portTickType xTicksToWait, portBASE_TYPE xJustPeeking );
#define xQueueAltSendToFront( xQueue, pvItemToQueue, xTicksToWait ) xQueueAltGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_FRONT )
#define xQueueAltSendToBack( xQueue, pvItemToQueue, xTicksToWait ) xQueueAltGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_BACK )
#define xQueueAltReceive( xQueue, pvBuffer, xTicksToWait ) xQueueAltGenericReceive( ( xQueue ), ( pvBuffer ), ( xTicksToWait ), pdFALSE )
@@ -1243,10 +1244,10 @@ signed portBASE_TYPE xQueueAltGenericReceive( xQueueHandle pxQueue, void * const
* should not be called directly from application code. Instead use the macro
* wrappers defined within croutine.h.
*/
-signed portBASE_TYPE xQueueCRSendFromISR( xQueueHandle pxQueue, const void *pvItemToQueue, signed portBASE_TYPE xCoRoutinePreviouslyWoken );
-signed portBASE_TYPE xQueueCRReceiveFromISR( xQueueHandle pxQueue, void *pvBuffer, signed portBASE_TYPE *pxTaskWoken );
-signed portBASE_TYPE xQueueCRSend( xQueueHandle pxQueue, const void *pvItemToQueue, portTickType xTicksToWait );
-signed portBASE_TYPE xQueueCRReceive( xQueueHandle pxQueue, void *pvBuffer, portTickType xTicksToWait );
+signed portBASE_TYPE xQueueCRSendFromISR( xQueueHandle xQueue, const void *pvItemToQueue, signed portBASE_TYPE xCoRoutinePreviouslyWoken );
+signed portBASE_TYPE xQueueCRReceiveFromISR( xQueueHandle xQueue, void *pvBuffer, signed portBASE_TYPE *pxTaskWoken );
+signed portBASE_TYPE xQueueCRSend( xQueueHandle xQueue, const void *pvItemToQueue, portTickType xTicksToWait );
+signed portBASE_TYPE xQueueCRReceive( xQueueHandle xQueue, void *pvBuffer, portTickType xTicksToWait );
/*
* For internal use only. Use xSemaphoreCreateMutex(),
@@ -1261,7 +1262,7 @@ void* xQueueGetMutexHolder( xQueueHandle xSemaphore );
* For internal use only. Use xSemaphoreTakeMutexRecursive() or
* xSemaphoreGiveMutexRecursive() instead of calling these functions directly.
*/
-portBASE_TYPE xQueueTakeMutexRecursive( xQueueHandle pxMutex, portTickType xBlockTime );
+portBASE_TYPE xQueueTakeMutexRecursive( xQueueHandle xMutex, portTickType xBlockTime );
portBASE_TYPE xQueueGiveMutexRecursive( xQueueHandle pxMutex );
/*
@@ -1270,7 +1271,7 @@ portBASE_TYPE xQueueGiveMutexRecursive( xQueueHandle pxMutex );
* reset because there are tasks blocked on the queue waiting to either
* receive from the queue or send to the queue.
*/
-#define xQueueReset( pxQueue ) xQueueGenericReset( pxQueue, pdFALSE )
+#define xQueueReset( xQueue ) xQueueGenericReset( xQueue, pdFALSE )
/*
* The registry is provided as a means for kernel aware debuggers to
@@ -1328,8 +1329,8 @@ xQueueHandle xQueueGenericCreate( unsigned portBASE_TYPE uxQueueLength, unsigned
* queue added to a queue set. Therefore counting semaphores with large maximum
* counts should not be added to queue sets.
*
- * Note 4: A received (in the case of a queue) or take (in the case of a
- * semaphore) operation must not be performed on a member of a queue set unless
+ * Note 4: A received (in the case of a queue) or take (in the case of a
+ * semaphore) operation must not be performed on a member of a queue set unless
* a call to xQueueSelect() has first returned a handle to that set member.
*
* @param uxEventQueueLength Queue sets themselves queue events that occur on
@@ -1360,19 +1361,19 @@ xQueueSetHandle xQueueCreateSet( unsigned portBASE_TYPE uxEventQueueLength );
* See FreeRTOS/Source/Demo/Common/Minimal/QueueSet.c for an example using this
* function.
*
- * Note 1: A received (in the case of a queue) or take (in the case of a
- * semaphore) operation must not be performed on a member of a queue set unless
+ * Note 1: A received (in the case of a queue) or take (in the case of a
+ * semaphore) operation must not be performed on a member of a queue set unless
* a call to xQueueSelect() has first returned a handle to that set member.
*
- * @param xQueueOrSemaphore The handle of the queue or semaphore being added to
+ * @param xQueueOrSemaphore The handle of the queue or semaphore being added to
* the queue set (cast to an xQueueSetMemberHandle type).
*
* @param xQueueSet The handle of the queue set to which the queue or semaphore
* is being added.
*
- * @return If the queue or semaphore was successfully added to the queue set
- * then pdPASS is returned. If the queue could not be successfully added to the
- * queue set because it is already a member of a different queue set then pdFAIL
+ * @return If the queue or semaphore was successfully added to the queue set
+ * then pdPASS is returned. If the queue could not be successfully added to the
+ * queue set because it is already a member of a different queue set then pdFAIL
* is returned.
*/
portBASE_TYPE xQueueAddToSet( xQueueSetMemberHandle xQueueOrSemaphore, xQueueSetHandle xQueueSet );
@@ -1384,23 +1385,23 @@ portBASE_TYPE xQueueAddToSet( xQueueSetMemberHandle xQueueOrSemaphore, xQueueSet
* See FreeRTOS/Source/Demo/Common/Minimal/QueueSet.c for an example using this
* function.
*
- * @param xQueueOrSemaphore The handle of the queue or semaphore being removed
+ * @param xQueueOrSemaphore The handle of the queue or semaphore being removed
* from the queue set (cast to an xQueueSetMemberHandle type).
*
* @param xQueueSet The handle of the queue set in which the queue or semaphore
* is included.
*
- * @return If the queue or semaphore was successfully removed from the queue set
+ * @return If the queue or semaphore was successfully removed from the queue set
* then pdPASS is returned. If the queue was not in the queue set then pdFAIL
* is returned.
*/
portBASE_TYPE xQueueRemoveFromSet( xQueueSetMemberHandle xQueueOrSemaphore, xQueueSetHandle xQueueSet );
/*
- * xQueueSelectFromSet() selects from the members of a queue set a queue or
+ * xQueueSelectFromSet() selects from the members of a queue set a queue or
* semaphore that either contains data (in the case of a queue) or is available
- * to take (in the case of a semaphore). xQueueSelectFromSet() effectively
- * allows a task to block (pend) on a read operation on all the queues and
+ * to take (in the case of a semaphore). xQueueSelectFromSet() effectively
+ * allows a task to block (pend) on a read operation on all the queues and
* semaphores in a queue set simultaneously.
*
* See FreeRTOS/Source/Demo/Common/Minimal/QueueSet.c for an example using this
@@ -1414,8 +1415,8 @@ portBASE_TYPE xQueueRemoveFromSet( xQueueSetMemberHandle xQueueOrSemaphore, xQue
* Note 2: Blocking on a queue set that contains a mutex will not cause the
* mutex holder to inherit the priority of the blocked task.
*
- * Note 3: A received (in the case of a queue) or take (in the case of a
- * semaphore) operation must not be performed on a member of a queue set unless
+ * Note 3: A received (in the case of a queue) or take (in the case of a
+ * semaphore) operation must not be performed on a member of a queue set unless
* a call to xQueueSelect() has first returned a handle to that set member.
*
* @param xQueueSet The queue set on which the task will (potentially) block.
@@ -1426,9 +1427,9 @@ portBASE_TYPE xQueueRemoveFromSet( xQueueSetMemberHandle xQueueOrSemaphore, xQue
* operation.
*
* @return xQueueSelectFromSet() will return the handle of a queue (cast to
- * a xQueueSetMemberHandle type) contained in the queue set that contains data,
+ * a xQueueSetMemberHandle type) contained in the queue set that contains data,
* or the handle of a semaphore (cast to a xQueueSetMemberHandle type) contained
- * in the queue set that is available, or NULL if no such queue or semaphore
+ * in the queue set that is available, or NULL if no such queue or semaphore
* exists before before the specified block time expires.
*/
xQueueSetMemberHandle xQueueSelectFromSet( xQueueSetHandle xQueueSet, portTickType xBlockTimeTicks );
@@ -1439,8 +1440,10 @@ xQueueSetMemberHandle xQueueSelectFromSet( xQueueSetHandle xQueueSet, portTickTy
xQueueSetMemberHandle xQueueSelectFromSetFromISR( xQueueSetHandle xQueueSet );
/* Not public API functions. */
-void vQueueWaitForMessageRestricted( xQueueHandle pxQueue, portTickType xTicksToWait );
-portBASE_TYPE xQueueGenericReset( xQueueHandle pxQueue, portBASE_TYPE xNewQueue );
+void vQueueWaitForMessageRestricted( xQueueHandle xQueue, portTickType xTicksToWait );
+portBASE_TYPE xQueueGenericReset( xQueueHandle xQueue, portBASE_TYPE xNewQueue );
+void vQueueSetQueueNumber( xQueueHandle xQueue, unsigned char ucQueueNumber ) PRIVILEGED_FUNCTION;
+unsigned char ucQueueGetQueueType( xQueueHandle xQueue ) PRIVILEGED_FUNCTION;
#ifdef __cplusplus
diff --git a/FreeRTOS/Source/include/task.h b/FreeRTOS/Source/include/task.h
index b4d359cdd..b54d21e3b 100644
--- a/FreeRTOS/Source/include/task.h
+++ b/FreeRTOS/Source/include/task.h
@@ -412,7 +412,7 @@ void vTaskAllocateMPURegions( xTaskHandle xTask, const xMemoryRegion * const pxR
/**
* task. h
- * void vTaskDelete( xTaskHandle pxTask );
+ * void vTaskDelete( xTaskHandle xTask );
*
* INCLUDE_vTaskDelete must be defined as 1 for this function to be available.
* See the configuration section for more information.
@@ -430,7 +430,7 @@ void vTaskAllocateMPURegions( xTaskHandle xTask, const xMemoryRegion * const pxR
* See the demo application file death.c for sample code that utilises
* vTaskDelete ().
*
- * @param pxTask The handle of the task to be deleted. Passing NULL will
+ * @param xTask The handle of the task to be deleted. Passing NULL will
* cause the calling task to be deleted.
*
* Example usage:
@@ -449,7 +449,7 @@ void vTaskAllocateMPURegions( xTaskHandle xTask, const xMemoryRegion * const pxR
* \defgroup vTaskDelete vTaskDelete
* \ingroup Tasks
*/
-void vTaskDelete( xTaskHandle pxTaskToDelete ) PRIVILEGED_FUNCTION;
+void vTaskDelete( xTaskHandle xTaskToDelete ) PRIVILEGED_FUNCTION;
/*-----------------------------------------------------------
* TASK CONTROL API
@@ -566,17 +566,17 @@ void vTaskDelayUntil( portTickType * const pxPreviousWakeTime, portTickType xTim
/**
* task. h
- * unsigned portBASE_TYPE uxTaskPriorityGet( xTaskHandle pxTask );
+ * unsigned portBASE_TYPE uxTaskPriorityGet( xTaskHandle xTask );
*
* INCLUDE_xTaskPriorityGet must be defined as 1 for this function to be available.
* See the configuration section for more information.
*
* Obtain the priority of any task.
*
- * @param pxTask Handle of the task to be queried. Passing a NULL
+ * @param xTask Handle of the task to be queried. Passing a NULL
* handle results in the priority of the calling task being returned.
*
- * @return The priority of pxTask.
+ * @return The priority of xTask.
*
* Example usage:
@@ -609,11 +609,11 @@ void vTaskDelayUntil( portTickType * const pxPreviousWakeTime, portTickType xTim
* \defgroup uxTaskPriorityGet uxTaskPriorityGet
* \ingroup TaskCtrl
*/
-unsigned portBASE_TYPE uxTaskPriorityGet( xTaskHandle pxTask ) PRIVILEGED_FUNCTION;
+unsigned portBASE_TYPE uxTaskPriorityGet( xTaskHandle xTask ) PRIVILEGED_FUNCTION;
/**
* task. h
- * eTaskState eTaskGetState( xTaskHandle pxTask );
+ * eTaskState eTaskGetState( xTaskHandle xTask );
*
* INCLUDE_eTaskGetState must be defined as 1 for this function to be available.
* See the configuration section for more information.
@@ -621,17 +621,17 @@ unsigned portBASE_TYPE uxTaskPriorityGet( xTaskHandle pxTask ) PRIVILEGED_FUNCTI
* Obtain the state of any task. States are encoded by the eTaskState
* enumerated type.
*
- * @param pxTask Handle of the task to be queried.
+ * @param xTask Handle of the task to be queried.
*
- * @return The state of pxTask at the time the function was called. Note the
+ * @return The state of xTask at the time the function was called. Note the
* state of the task might change between the function being called, and the
* functions return value being tested by the calling task.
*/
-eTaskState eTaskGetState( xTaskHandle pxTask ) PRIVILEGED_FUNCTION;
+eTaskState eTaskGetState( xTaskHandle xTask ) PRIVILEGED_FUNCTION;
/**
* task. h
- * void vTaskPrioritySet( xTaskHandle pxTask, unsigned portBASE_TYPE uxNewPriority );
+ * void vTaskPrioritySet( xTaskHandle xTask, unsigned portBASE_TYPE uxNewPriority );
*
* INCLUDE_vTaskPrioritySet must be defined as 1 for this function to be available.
* See the configuration section for more information.
@@ -641,7 +641,7 @@ eTaskState eTaskGetState( xTaskHandle pxTask ) PRIVILEGED_FUNCTION;
* A context switch will occur before the function returns if the priority
* being set is higher than the currently executing task.
*
- * @param pxTask Handle to the task for which the priority is being set.
+ * @param xTask Handle to the task for which the priority is being set.
* Passing a NULL handle results in the priority of the calling task being set.
*
* @param uxNewPriority The priority to which the task will be set.
@@ -669,11 +669,11 @@ eTaskState eTaskGetState( xTaskHandle pxTask ) PRIVILEGED_FUNCTION;
* \defgroup vTaskPrioritySet vTaskPrioritySet
* \ingroup TaskCtrl
*/
-void vTaskPrioritySet( xTaskHandle pxTask, unsigned portBASE_TYPE uxNewPriority ) PRIVILEGED_FUNCTION;
+void vTaskPrioritySet( xTaskHandle xTask, unsigned portBASE_TYPE uxNewPriority ) PRIVILEGED_FUNCTION;
/**
* task. h
- * void vTaskSuspend( xTaskHandle pxTaskToSuspend );
+ * void vTaskSuspend( xTaskHandle xTaskToSuspend );
*
* INCLUDE_vTaskSuspend must be defined as 1 for this function to be available.
* See the configuration section for more information.
@@ -685,7 +685,7 @@ void vTaskPrioritySet( xTaskHandle pxTask, unsigned portBASE_TYPE uxNewPriority
* i.e. calling vTaskSuspend () twice on the same task still only requires one
* call to vTaskResume () to ready the suspended task.
*
- * @param pxTaskToSuspend Handle to the task being suspended. Passing a NULL
+ * @param xTaskToSuspend Handle to the task being suspended. Passing a NULL
* handle will cause the calling task to be suspended.
*
* Example usage:
@@ -720,11 +720,11 @@ void vTaskPrioritySet( xTaskHandle pxTask, unsigned portBASE_TYPE uxNewPriority
* \defgroup vTaskSuspend vTaskSuspend
* \ingroup TaskCtrl
*/
-void vTaskSuspend( xTaskHandle pxTaskToSuspend ) PRIVILEGED_FUNCTION;
+void vTaskSuspend( xTaskHandle xTaskToSuspend ) PRIVILEGED_FUNCTION;
/**
* task. h
- * void vTaskResume( xTaskHandle pxTaskToResume );
+ * void vTaskResume( xTaskHandle xTaskToResume );
*
* INCLUDE_vTaskSuspend must be defined as 1 for this function to be available.
* See the configuration section for more information.
@@ -735,7 +735,7 @@ void vTaskSuspend( xTaskHandle pxTaskToSuspend ) PRIVILEGED_FUNCTION;
* will be made available for running again by a single call to
* vTaskResume ().
*
- * @param pxTaskToResume Handle to the task being readied.
+ * @param xTaskToResume Handle to the task being readied.
*
* Example usage:
@@ -769,11 +769,11 @@ void vTaskSuspend( xTaskHandle pxTaskToSuspend ) PRIVILEGED_FUNCTION;
* \defgroup vTaskResume vTaskResume
* \ingroup TaskCtrl
*/
-void vTaskResume( xTaskHandle pxTaskToResume ) PRIVILEGED_FUNCTION;
+void vTaskResume( xTaskHandle xTaskToResume ) PRIVILEGED_FUNCTION;
/**
* task. h
- * void xTaskResumeFromISR( xTaskHandle pxTaskToResume );
+ * void xTaskResumeFromISR( xTaskHandle xTaskToResume );
*
* INCLUDE_xTaskResumeFromISR must be defined as 1 for this function to be
* available. See the configuration section for more information.
@@ -784,12 +784,12 @@ void vTaskResume( xTaskHandle pxTaskToResume ) PRIVILEGED_FUNCTION;
* will be made available for running again by a single call to
* xTaskResumeFromISR ().
*
- * @param pxTaskToResume Handle to the task being readied.
+ * @param xTaskToResume Handle to the task being readied.
*
* \defgroup vTaskResumeFromISR vTaskResumeFromISR
* \ingroup TaskCtrl
*/
-portBASE_TYPE xTaskResumeFromISR( xTaskHandle pxTaskToResume ) PRIVILEGED_FUNCTION;
+portBASE_TYPE xTaskResumeFromISR( xTaskHandle xTaskToResume ) PRIVILEGED_FUNCTION;
/*-----------------------------------------------------------
* SCHEDULER CONTROL
diff --git a/FreeRTOS/Source/portable/MemMang/heap_1.c b/FreeRTOS/Source/portable/MemMang/heap_1.c
index 65e2cd782..f3190dac9 100644
--- a/FreeRTOS/Source/portable/MemMang/heap_1.c
+++ b/FreeRTOS/Source/portable/MemMang/heap_1.c
@@ -86,24 +86,19 @@ task.h is included from an application file. */
#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE
-/* Allocate the memory for the heap. The struct is used to force byte
-alignment without using any non-portable code. */
-static union xRTOS_HEAP
-{
- #if portBYTE_ALIGNMENT == 8
- volatile portDOUBLE dDummy;
- #else
- volatile unsigned long ulDummy;
- #endif
- unsigned char ucHeap[ configTOTAL_HEAP_SIZE ];
-} xHeap;
+/* A few bytes might be lost to byte aligning the heap start address. */
+#define configADJUSTED_HEAP_SIZE ( configTOTAL_HEAP_SIZE - portBYTE_ALIGNMENT )
+/* Allocate the memory for the heap. */
+static unsigned char ucHeap[ configTOTAL_HEAP_SIZE ];
static size_t xNextFreeByte = ( size_t ) 0;
+
/*-----------------------------------------------------------*/
void *pvPortMalloc( size_t xWantedSize )
{
void *pvReturn = NULL;
+static unsigned char *pucAlignedHeap = NULL;
/* Ensure that blocks are always aligned to the required number of bytes. */
#if portBYTE_ALIGNMENT != 1
@@ -116,13 +111,19 @@ void *pvReturn = NULL;
vTaskSuspendAll();
{
+ if( pucAlignedHeap == NULL )
+ {
+ /* Ensure the heap starts on a correctly aligned boundary. */
+ pucAlignedHeap = ( unsigned char * ) ( ( ( portPOINTER_SIZE_TYPE ) &ucHeap[ portBYTE_ALIGNMENT ] ) & ( ( portPOINTER_SIZE_TYPE ) ~portBYTE_ALIGNMENT_MASK ) );
+ }
+
/* Check there is enough room left for the allocation. */
- if( ( ( xNextFreeByte + xWantedSize ) < configTOTAL_HEAP_SIZE ) &&
+ if( ( ( xNextFreeByte + xWantedSize ) < configADJUSTED_HEAP_SIZE ) &&
( ( xNextFreeByte + xWantedSize ) > xNextFreeByte ) )/* Check for overflow. */
{
/* Return the next free byte then increment the index past this
block. */
- pvReturn = &( xHeap.ucHeap[ xNextFreeByte ] );
+ pvReturn = pucAlignedHeap + xNextFreeByte;
xNextFreeByte += xWantedSize;
}
}
@@ -163,7 +164,7 @@ void vPortInitialiseBlocks( void )
size_t xPortGetFreeHeapSize( void )
{
- return ( configTOTAL_HEAP_SIZE - xNextFreeByte );
+ return ( configADJUSTED_HEAP_SIZE - xNextFreeByte );
}
diff --git a/FreeRTOS/Source/portable/MemMang/heap_2.c b/FreeRTOS/Source/portable/MemMang/heap_2.c
index bd827a941..bd07401ab 100644
--- a/FreeRTOS/Source/portable/MemMang/heap_2.c
+++ b/FreeRTOS/Source/portable/MemMang/heap_2.c
@@ -1,7 +1,7 @@
/*
FreeRTOS V7.3.0 - Copyright (C) 2012 Real Time Engineers Ltd.
- FEATURES AND PORTS ARE ADDED TO FREERTOS ALL THE TIME. PLEASE VISIT
+ FEATURES AND PORTS ARE ADDED TO FREERTOS ALL THE TIME. PLEASE VISIT
http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
***************************************************************************
@@ -42,7 +42,7 @@
FreeRTOS WEB site.
1 tab == 4 spaces!
-
+
***************************************************************************
* *
* Having a problem? Start by reading the FAQ "My application does *
@@ -52,27 +52,27 @@
* *
***************************************************************************
-
- http://www.FreeRTOS.org - Documentation, training, latest versions, license
- and contact details.
-
+
+ http://www.FreeRTOS.org - Documentation, training, latest versions, license
+ and contact details.
+
http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,
including FreeRTOS+Trace - an indispensable productivity tool.
- Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell
- the code with commercial support, indemnification, and middleware, under
+ Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell
+ the code with commercial support, indemnification, and middleware, under
the OpenRTOS brand: http://www.OpenRTOS.com. High Integrity Systems also
- provide a safety engineered and independently SIL3 certified version under
+ provide a safety engineered and independently SIL3 certified version under
the SafeRTOS brand: http://www.SafeRTOS.com.
*/
/*
* A sample implementation of pvPortMalloc() and vPortFree() that permits
* allocated blocks to be freed, but does not combine adjacent free blocks
- * into a single larger block (and so will fragment memory). See heap_4.c for
+ * into a single larger block (and so will fragment memory). See heap_4.c for
* an aquivalent that does combine adjacent blocks into single larger blocks.
*
- * See heap_1.c, heap_3.c and heap_4.c for alternative implementations, and the
+ * See heap_1.c, heap_3.c and heap_4.c for alternative implementations, and the
* memory management pages of http://www.FreeRTOS.org for more information.
*/
#include
@@ -87,17 +87,16 @@ task.h is included from an application file. */
#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE
-/* Allocate the memory for the heap. The struct is used to force byte
-alignment without using any non-portable code. */
-static union xRTOS_HEAP
-{
- #if portBYTE_ALIGNMENT == 8
- volatile portDOUBLE dDummy;
- #else
- volatile unsigned long ulDummy;
- #endif
- unsigned char ucHeap[ configTOTAL_HEAP_SIZE ];
-} xHeap;
+/* A few bytes might be lost to byte aligning the heap start address. */
+#define configADJUSTED_HEAP_SIZE ( configTOTAL_HEAP_SIZE - portBYTE_ALIGNMENT )
+
+/*
+ * Initialises the heap structures into their start condition.
+ */
+static void prvHeapInit( void );
+
+/* Allocate the memory for the heap. */
+static unsigned char ucHeap[ configTOTAL_HEAP_SIZE ];
/* Define the linked list structure. This is used to link free blocks in order
of their size. */
@@ -116,7 +115,7 @@ static xBlockLink xStart, xEnd;
/* Keeps track of the number of free bytes remaining, but says nothing about
fragmentation. */
-static size_t xFreeBytesRemaining = configTOTAL_HEAP_SIZE;
+static size_t xFreeBytesRemaining = configADJUSTED_HEAP_SIZE;
/* STATIC FUNCTIONS ARE DEFINED AS MACROS TO MINIMIZE THE FUNCTION CALL DEPTH. */
@@ -146,27 +145,6 @@ size_t xBlockSize; \
}
/*-----------------------------------------------------------*/
-#define prvHeapInit() \
-{ \
-xBlockLink *pxFirstFreeBlock; \
- \
- /* xStart is used to hold a pointer to the first item in the list of free */ \
- /* blocks. The void cast is used to prevent compiler warnings. */ \
- xStart.pxNextFreeBlock = ( void * ) xHeap.ucHeap; \
- xStart.xBlockSize = ( size_t ) 0; \
- \
- /* xEnd is used to mark the end of the list of free blocks. */ \
- xEnd.xBlockSize = configTOTAL_HEAP_SIZE; \
- xEnd.pxNextFreeBlock = NULL; \
- \
- /* To start with there is a single free block that is sized to take up the \
- entire heap space. */ \
- pxFirstFreeBlock = ( void * ) xHeap.ucHeap; \
- pxFirstFreeBlock->xBlockSize = configTOTAL_HEAP_SIZE; \
- pxFirstFreeBlock->pxNextFreeBlock = &xEnd; \
-}
-/*-----------------------------------------------------------*/
-
void *pvPortMalloc( size_t xWantedSize )
{
xBlockLink *pxBlock, *pxPreviousBlock, *pxNewBlockLink;
@@ -197,7 +175,7 @@ void *pvReturn = NULL;
}
}
- if( ( xWantedSize > 0 ) && ( xWantedSize < configTOTAL_HEAP_SIZE ) )
+ if( ( xWantedSize > 0 ) && ( xWantedSize < configADJUSTED_HEAP_SIZE ) )
{
/* Blocks are stored in byte order - traverse the list from the start
(smallest) block until one of adequate size is found. */
@@ -236,7 +214,7 @@ void *pvReturn = NULL;
/* Insert the new block into the list of free blocks. */
prvInsertBlockIntoFreeList( ( pxNewBlockLink ) );
}
-
+
xFreeBytesRemaining -= pxBlock->xBlockSize;
}
}
@@ -268,7 +246,8 @@ xBlockLink *pxLink;
before it. */
puc -= heapSTRUCT_SIZE;
- /* This casting is to keep the compiler from issuing warnings. */
+ /* This unexpected casting is to keep some compilers from issuing
+ byte alignment warnings. */
pxLink = ( void * ) puc;
vTaskSuspendAll();
@@ -292,3 +271,29 @@ void vPortInitialiseBlocks( void )
{
/* This just exists to keep the linker quiet. */
}
+/*-----------------------------------------------------------*/
+
+static void prvHeapInit( void )
+{
+xBlockLink *pxFirstFreeBlock;
+unsigned char *pucAlignedHeap;
+
+ /* Ensure the heap starts on a correctly aligned boundary. */
+ pucAlignedHeap = ( unsigned char * ) ( ( ( portPOINTER_SIZE_TYPE ) &ucHeap[ portBYTE_ALIGNMENT ] ) & ( ( portPOINTER_SIZE_TYPE ) ~portBYTE_ALIGNMENT_MASK ) );
+
+ /* xStart is used to hold a pointer to the first item in the list of free
+ blocks. The void cast is used to prevent compiler warnings. */
+ xStart.pxNextFreeBlock = ( void * ) pucAlignedHeap;
+ xStart.xBlockSize = ( size_t ) 0;
+
+ /* xEnd is used to mark the end of the list of free blocks. */
+ xEnd.xBlockSize = configADJUSTED_HEAP_SIZE;
+ xEnd.pxNextFreeBlock = NULL;
+
+ /* To start with there is a single free block that is sized to take up the
+ entire heap space. */
+ pxFirstFreeBlock = ( void * ) pucAlignedHeap;
+ pxFirstFreeBlock->xBlockSize = configADJUSTED_HEAP_SIZE;
+ pxFirstFreeBlock->pxNextFreeBlock = &xEnd;
+}
+/*-----------------------------------------------------------*/
diff --git a/FreeRTOS/Source/portable/MemMang/heap_4.c b/FreeRTOS/Source/portable/MemMang/heap_4.c
index d40fea1ec..1dc7c659e 100644
--- a/FreeRTOS/Source/portable/MemMang/heap_4.c
+++ b/FreeRTOS/Source/portable/MemMang/heap_4.c
@@ -89,17 +89,11 @@ task.h is included from an application file. */
/* Block sizes must not get too small. */
#define heapMINIMUM_BLOCK_SIZE ( ( size_t ) ( heapSTRUCT_SIZE * 2 ) )
-/* Allocate the memory for the heap. The struct is used to force byte
-alignment without using any non-portable code. */
-static union xRTOS_HEAP
-{
- #if portBYTE_ALIGNMENT == 8
- volatile portDOUBLE dDummy;
- #else
- volatile unsigned long ulDummy;
- #endif
- unsigned char ucHeap[ configTOTAL_HEAP_SIZE ];
-} xHeap;
+/* A few bytes might be lost to byte aligning the heap start address. */
+#define configADJUSTED_HEAP_SIZE ( configTOTAL_HEAP_SIZE - portBYTE_ALIGNMENT )
+
+/* Allocate the memory for the heap. */
+static unsigned char ucHeap[ configTOTAL_HEAP_SIZE ];
/* Define the linked list structure. This is used to link free blocks in order
of their memory address. */
@@ -132,14 +126,14 @@ block must by correctly byte aligned. */
static const unsigned short heapSTRUCT_SIZE = ( sizeof( xBlockLink ) + portBYTE_ALIGNMENT - ( sizeof( xBlockLink ) % portBYTE_ALIGNMENT ) );
/* Ensure the pxEnd pointer will end up on the correct byte alignment. */
-static const size_t xTotalHeapSize = ( ( size_t ) configTOTAL_HEAP_SIZE ) & ( ( size_t ) ~portBYTE_ALIGNMENT_MASK );
+static const size_t xTotalHeapSize = ( ( size_t ) configADJUSTED_HEAP_SIZE ) & ( ( size_t ) ~portBYTE_ALIGNMENT_MASK );
/* Create a couple of list links to mark the start and end of the list. */
static xBlockLink xStart, *pxEnd = NULL;
/* Keeps track of the number of free bytes remaining, but says nothing about
fragmentation. */
-static size_t xFreeBytesRemaining = ( ( size_t ) configTOTAL_HEAP_SIZE ) & ( ( size_t ) ~portBYTE_ALIGNMENT_MASK );
+static size_t xFreeBytesRemaining = ( ( size_t ) configADJUSTED_HEAP_SIZE ) & ( ( size_t ) ~portBYTE_ALIGNMENT_MASK );
/* STATIC FUNCTIONS ARE DEFINED AS MACROS TO MINIMIZE THE FUNCTION CALL DEPTH. */
@@ -275,19 +269,19 @@ void vPortInitialiseBlocks( void )
static void prvHeapInit( void )
{
xBlockLink *pxFirstFreeBlock;
-unsigned char *pucHeapEnd;
+unsigned char *pucHeapEnd, *pucAlignedHeap;
- /* Ensure the start of the heap is aligned. */
- configASSERT( ( ( ( unsigned long ) xHeap.ucHeap ) & ( ( unsigned long ) portBYTE_ALIGNMENT_MASK ) ) == 0UL );
+ /* Ensure the heap starts on a correctly aligned boundary. */
+ pucAlignedHeap = ( unsigned char * ) ( ( ( portPOINTER_SIZE_TYPE ) &ucHeap[ portBYTE_ALIGNMENT ] ) & ( ( portPOINTER_SIZE_TYPE ) ~portBYTE_ALIGNMENT_MASK ) );
/* xStart is used to hold a pointer to the first item in the list of free
blocks. The void cast is used to prevent compiler warnings. */
- xStart.pxNextFreeBlock = ( void * ) xHeap.ucHeap;
+ xStart.pxNextFreeBlock = ( void * ) pucAlignedHeap;
xStart.xBlockSize = ( size_t ) 0;
/* pxEnd is used to mark the end of the list of free blocks and is inserted
at the end of the heap space. */
- pucHeapEnd = xHeap.ucHeap + xTotalHeapSize;
+ pucHeapEnd = pucAlignedHeap + xTotalHeapSize;
pucHeapEnd -= heapSTRUCT_SIZE;
pxEnd = ( void * ) pucHeapEnd;
configASSERT( ( ( ( unsigned long ) pxEnd ) & ( ( unsigned long ) portBYTE_ALIGNMENT_MASK ) ) == 0UL );
@@ -296,7 +290,7 @@ unsigned char *pucHeapEnd;
/* To start with there is a single free block that is sized to take up the
entire heap space, minus the space taken by pxEnd. */
- pxFirstFreeBlock = ( void * ) xHeap.ucHeap;
+ pxFirstFreeBlock = ( void * ) pucAlignedHeap;
pxFirstFreeBlock->xBlockSize = xTotalHeapSize - heapSTRUCT_SIZE;
pxFirstFreeBlock->pxNextFreeBlock = pxEnd;
diff --git a/FreeRTOS/Source/queue.c b/FreeRTOS/Source/queue.c
index f78591ad1..a97f868c1 100644
--- a/FreeRTOS/Source/queue.c
+++ b/FreeRTOS/Source/queue.c
@@ -76,6 +76,7 @@ task.h is included from an application file. */
#include "FreeRTOS.h"
#include "task.h"
+#include "queue.h"
#if ( configUSE_CO_ROUTINES == 1 )
#include "croutine.h"
@@ -89,10 +90,6 @@ task.h is included from an application file. */
#define queueERRONEOUS_UNBLOCK ( -1 )
-/* For internal use only. */
-#define queueSEND_TO_BACK ( 0 )
-#define queueSEND_TO_FRONT ( 1 )
-
/* Effectively make a union out of the xQUEUE structure. */
#define pxMutexHolder pcTail
#define uxQueueType pcHead
@@ -105,13 +102,6 @@ zero. */
#define queueDONT_BLOCK ( ( portTickType ) 0U )
#define queueMUTEX_GIVE_BLOCK_TIME ( ( portTickType ) 0U )
-/* These definitions *must* match those in queue.h. */
-#define queueQUEUE_TYPE_BASE ( 0U )
-#define queueQUEUE_TYPE_MUTEX ( 1U )
-#define queueQUEUE_TYPE_COUNTING_SEMAPHORE ( 2U )
-#define queueQUEUE_TYPE_BINARY_SEMAPHORE ( 3U )
-#define queueQUEUE_TYPE_RECURSIVE_MUTEX ( 4U )
-#define queueQUEUE_TYPE_SET ( 0U )
/*
* Definition of the queue used by the scheduler.
@@ -147,66 +137,6 @@ typedef struct QueueDefinition
} xQUEUE;
/*-----------------------------------------------------------*/
-/*
- * Inside this file xQueueHandle and xQueueSetHandle are both pointers to xQUEUE
- * structures. To keep the definition private the API header file defines both
- * as pointers to void.
- */
-typedef xQUEUE * xQueueHandle;
-typedef xQUEUE * xQueueSetHandle;
-
-/**
- * Queue sets can contain both queues and semaphores, so the
- * xQueueSetMemberHandle is defined as a type to be used where a parameter or
- * return value can be either an xQueueHandle or an xSemaphoreHandle.
- */
-typedef xQUEUE * xQueueSetMemberHandle;
-
-/*
- * In order to implement strict data hiding, the queue.h header file defines
- * xQueueHandle and xQueueSetHandle as pointers to void. In this file
- * xQueueHandle and xQueueSetHandle are defined as pointers to xQUEUE objects.
- * Therefore the queue.h header file cannot be included in this source file,
- * and the function prototypes are provided directly.
- */
-xQueueHandle xQueueGenericCreate( unsigned portBASE_TYPE uxQueueLength, unsigned portBASE_TYPE uxItemSize, unsigned char ucQueueType ) PRIVILEGED_FUNCTION;
-signed portBASE_TYPE xQueueGenericSend( xQueueHandle pxQueue, const void * const pvItemToQueue, portTickType xTicksToWait, portBASE_TYPE xCopyPosition ) PRIVILEGED_FUNCTION;
-unsigned portBASE_TYPE uxQueueMessagesWaiting( const xQueueHandle pxQueue ) PRIVILEGED_FUNCTION;
-void vQueueDelete( xQueueHandle xQueue ) PRIVILEGED_FUNCTION;
-signed portBASE_TYPE xQueueGenericSendFromISR( xQueueHandle pxQueue, const void * const pvItemToQueue, signed portBASE_TYPE *pxHigherPriorityTaskWoken, portBASE_TYPE xCopyPosition ) PRIVILEGED_FUNCTION;
-signed portBASE_TYPE xQueueGenericReceive( xQueueHandle pxQueue, void * const pvBuffer, portTickType xTicksToWait, portBASE_TYPE xJustPeeking ) PRIVILEGED_FUNCTION;
-signed portBASE_TYPE xQueueReceiveFromISR( xQueueHandle pxQueue, void * const pvBuffer, signed portBASE_TYPE *pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;
-xQueueHandle xQueueCreateMutex( unsigned char ucQueueType ) PRIVILEGED_FUNCTION;
-xQueueHandle xQueueCreateCountingSemaphore( unsigned portBASE_TYPE uxCountValue, unsigned portBASE_TYPE uxInitialCount ) PRIVILEGED_FUNCTION;
-portBASE_TYPE xQueueTakeMutexRecursive( xQueueHandle xMutex, portTickType xBlockTime ) PRIVILEGED_FUNCTION;
-portBASE_TYPE xQueueGiveMutexRecursive( xQueueHandle xMutex ) PRIVILEGED_FUNCTION;
-signed portBASE_TYPE xQueueAltGenericSend( xQueueHandle pxQueue, const void * const pvItemToQueue, portTickType xTicksToWait, portBASE_TYPE xCopyPosition ) PRIVILEGED_FUNCTION;
-signed portBASE_TYPE xQueueAltGenericReceive( xQueueHandle pxQueue, void * const pvBuffer, portTickType xTicksToWait, portBASE_TYPE xJustPeeking ) PRIVILEGED_FUNCTION;
-signed portBASE_TYPE xQueueIsQueueEmptyFromISR( const xQueueHandle pxQueue ) PRIVILEGED_FUNCTION;
-signed portBASE_TYPE xQueueIsQueueFullFromISR( const xQueueHandle pxQueue ) PRIVILEGED_FUNCTION;
-unsigned portBASE_TYPE uxQueueMessagesWaitingFromISR( const xQueueHandle pxQueue ) PRIVILEGED_FUNCTION;
-void vQueueWaitForMessageRestricted( xQueueHandle pxQueue, portTickType xTicksToWait ) PRIVILEGED_FUNCTION;
-unsigned char ucQueueGetQueueNumber( xQueueHandle pxQueue ) PRIVILEGED_FUNCTION;
-void vQueueSetQueueNumber( xQueueHandle pxQueue, unsigned char ucQueueNumber ) PRIVILEGED_FUNCTION;
-unsigned char ucQueueGetQueueType( xQueueHandle pxQueue ) PRIVILEGED_FUNCTION;
-portBASE_TYPE xQueueGenericReset( xQueueHandle pxQueue, portBASE_TYPE xNewQueue ) PRIVILEGED_FUNCTION;
-xTaskHandle xQueueGetMutexHolder( xQueueHandle xSemaphore ) PRIVILEGED_FUNCTION;
-xQueueSetHandle xQueueCreateSet( unsigned portBASE_TYPE uxEventQueueLength ) PRIVILEGED_FUNCTION;
-xQueueSetMemberHandle xQueueSelectFromSet( xQueueSetHandle xQueueSet, portTickType xBlockTimeTicks ) PRIVILEGED_FUNCTION;
-portBASE_TYPE xQueueAddToSet( xQueueSetMemberHandle xQueueOrSemaphore, xQueueSetHandle xQueueSet ) PRIVILEGED_FUNCTION;
-portBASE_TYPE xQueueRemoveFromSet( xQueueSetMemberHandle xQueueOrSemaphore, xQueueSetHandle xQueueSet ) PRIVILEGED_FUNCTION;
-
-/*
- * Co-routine queue functions differ from task queue functions. Co-routines are
- * an optional component.
- */
-#if ( configUSE_CO_ROUTINES == 1 )
- signed portBASE_TYPE xQueueCRSendFromISR( xQueueHandle pxQueue, const void *pvItemToQueue, signed portBASE_TYPE xCoRoutinePreviouslyWoken ) PRIVILEGED_FUNCTION;
- signed portBASE_TYPE xQueueCRReceiveFromISR( xQueueHandle pxQueue, void *pvBuffer, signed portBASE_TYPE *pxTaskWoken ) PRIVILEGED_FUNCTION;
- signed portBASE_TYPE xQueueCRSend( xQueueHandle pxQueue, const void *pvItemToQueue, portTickType xTicksToWait ) PRIVILEGED_FUNCTION;
- signed portBASE_TYPE xQueueCRReceive( xQueueHandle pxQueue, void *pvBuffer, portTickType xTicksToWait ) PRIVILEGED_FUNCTION;
-#endif
-
/*
* The queue registry is just a means for kernel aware debuggers to locate
* queue structures. It has no other purpose so is an optional component.
@@ -229,9 +159,9 @@ portBASE_TYPE xQueueRemoveFromSet( xQueueSetMemberHandle xQueueOrSemaphore, xQue
/* Removes a queue from the registry by simply setting the pcQueueName
member to NULL. */
- static void vQueueUnregisterQueue( xQueueHandle xQueue ) PRIVILEGED_FUNCTION;
- void vQueueAddToRegistry( xQueueHandle xQueue, signed char *pcQueueName ) PRIVILEGED_FUNCTION;
-#endif
+ static void prvQueueUnregisterQueue( xQueueHandle xQueue ) PRIVILEGED_FUNCTION;
+
+#endif /* configQUEUE_REGISTRY_SIZE */
/*
* Unlocks a queue locked by a call to prvLockQueue. Locking a queue does not
@@ -241,21 +171,21 @@ portBASE_TYPE xQueueRemoveFromSet( xQueueSetMemberHandle xQueueOrSemaphore, xQue
* to indicate that a task may require unblocking. When the queue in unlocked
* these lock counts are inspected, and the appropriate action taken.
*/
-static void prvUnlockQueue( xQueueHandle pxQueue ) PRIVILEGED_FUNCTION;
+static void prvUnlockQueue( xQUEUE *pxQueue ) PRIVILEGED_FUNCTION;
/*
* Uses a critical section to determine if there is any data in a queue.
*
* @return pdTRUE if the queue contains no items, otherwise pdFALSE.
*/
-static signed portBASE_TYPE prvIsQueueEmpty( const xQueueHandle pxQueue ) PRIVILEGED_FUNCTION;
+static signed portBASE_TYPE prvIsQueueEmpty( const xQUEUE *pxQueue ) PRIVILEGED_FUNCTION;
/*
* Uses a critical section to determine if there is any space in a queue.
*
* @return pdTRUE if there is no space, otherwise pdFALSE;
*/
-static signed portBASE_TYPE prvIsQueueFull( const xQueueHandle pxQueue ) PRIVILEGED_FUNCTION;
+static signed portBASE_TYPE prvIsQueueFull( const xQUEUE *pxQueue ) PRIVILEGED_FUNCTION;
/*
* Copies an item into the queue, either at the front of the queue or the
@@ -297,8 +227,11 @@ static void prvCopyDataFromQueue( xQUEUE * const pxQueue, const void *pvBuffer )
taskEXIT_CRITICAL()
/*-----------------------------------------------------------*/
-portBASE_TYPE xQueueGenericReset( xQueueHandle pxQueue, portBASE_TYPE xNewQueue )
+portBASE_TYPE xQueueGenericReset( xQueueHandle xQueue, portBASE_TYPE xNewQueue )
{
+xQUEUE *pxQueue;
+
+ pxQueue = ( xQUEUE * ) xQueue;
configASSERT( pxQueue );
taskENTER_CRITICAL();
@@ -476,9 +409,9 @@ xQueueHandle xReturn = NULL;
following critical section exiting and the function returning. */
taskENTER_CRITICAL();
{
- if( xSemaphore->uxQueueType == queueQUEUE_IS_MUTEX )
+ if( ( ( xQUEUE * ) xSemaphore )->uxQueueType == queueQUEUE_IS_MUTEX )
{
- pxReturn = ( void * ) xSemaphore->pxMutexHolder;
+ pxReturn = ( void * ) ( ( xQUEUE * ) xSemaphore )->pxMutexHolder;
}
else
{
@@ -495,10 +428,12 @@ xQueueHandle xReturn = NULL;
#if ( configUSE_RECURSIVE_MUTEXES == 1 )
- portBASE_TYPE xQueueGiveMutexRecursive( xQueueHandle pxMutex )
+ portBASE_TYPE xQueueGiveMutexRecursive( xQueueHandle xMutex )
{
portBASE_TYPE xReturn;
+ xQUEUE *pxMutex;
+ pxMutex = ( xQUEUE * ) xMutex;
configASSERT( pxMutex );
/* If this is the task that holds the mutex then pxMutexHolder will not
@@ -544,10 +479,12 @@ xQueueHandle xReturn = NULL;
#if ( configUSE_RECURSIVE_MUTEXES == 1 )
- portBASE_TYPE xQueueTakeMutexRecursive( xQueueHandle pxMutex, portTickType xBlockTime )
+ portBASE_TYPE xQueueTakeMutexRecursive( xQueueHandle xMutex, portTickType xBlockTime )
{
portBASE_TYPE xReturn;
+ xQUEUE *pxMutex;
+ pxMutex = ( xQUEUE * ) xMutex;
configASSERT( pxMutex );
/* Comments regarding mutual exclusion as per those within
@@ -586,13 +523,13 @@ xQueueHandle xReturn = NULL;
xQueueHandle xQueueCreateCountingSemaphore( unsigned portBASE_TYPE uxCountValue, unsigned portBASE_TYPE uxInitialCount )
{
- xQueueHandle pxHandle;
+ xQueueHandle xHandle;
- pxHandle = xQueueGenericCreate( ( unsigned portBASE_TYPE ) uxCountValue, queueSEMAPHORE_QUEUE_ITEM_LENGTH, queueQUEUE_TYPE_COUNTING_SEMAPHORE );
+ xHandle = xQueueGenericCreate( ( unsigned portBASE_TYPE ) uxCountValue, queueSEMAPHORE_QUEUE_ITEM_LENGTH, queueQUEUE_TYPE_COUNTING_SEMAPHORE );
- if( pxHandle != NULL )
+ if( xHandle != NULL )
{
- pxHandle->uxMessagesWaiting = uxInitialCount;
+ ( ( xQUEUE * ) xHandle )->uxMessagesWaiting = uxInitialCount;
traceCREATE_COUNTING_SEMAPHORE();
}
@@ -601,18 +538,20 @@ xQueueHandle xReturn = NULL;
traceCREATE_COUNTING_SEMAPHORE_FAILED();
}
- configASSERT( pxHandle );
- return pxHandle;
+ configASSERT( xHandle );
+ return xHandle;
}
#endif /* configUSE_COUNTING_SEMAPHORES */
/*-----------------------------------------------------------*/
-signed portBASE_TYPE xQueueGenericSend( xQueueHandle pxQueue, const void * const pvItemToQueue, portTickType xTicksToWait, portBASE_TYPE xCopyPosition )
+signed portBASE_TYPE xQueueGenericSend( xQueueHandle xQueue, const void * const pvItemToQueue, portTickType xTicksToWait, portBASE_TYPE xCopyPosition )
{
signed portBASE_TYPE xEntryTimeSet = pdFALSE;
xTimeOutType xTimeOut;
+xQUEUE *pxQueue;
+ pxQueue = ( xQUEUE * ) xQueue;
configASSERT( pxQueue );
configASSERT( !( ( pvItemToQueue == NULL ) && ( pxQueue->uxItemSize != ( unsigned portBASE_TYPE ) 0U ) ) );
@@ -762,11 +701,13 @@ xTimeOutType xTimeOut;
#if ( configUSE_ALTERNATIVE_API == 1 )
- signed portBASE_TYPE xQueueAltGenericSend( xQueueHandle pxQueue, const void * const pvItemToQueue, portTickType xTicksToWait, portBASE_TYPE xCopyPosition )
+ signed portBASE_TYPE xQueueAltGenericSend( xQueueHandle xQueue, const void * const pvItemToQueue, portTickType xTicksToWait, portBASE_TYPE xCopyPosition )
{
signed portBASE_TYPE xEntryTimeSet = pdFALSE;
xTimeOutType xTimeOut;
+ xQUEUE *pxQueue;
+ pxQueue = ( xQUEUE * ) xQueue;
configASSERT( pxQueue );
configASSERT( !( ( pvItemToQueue == NULL ) && ( pxQueue->uxItemSize != ( unsigned portBASE_TYPE ) 0U ) ) );
@@ -839,12 +780,14 @@ xTimeOutType xTimeOut;
#if ( configUSE_ALTERNATIVE_API == 1 )
- signed portBASE_TYPE xQueueAltGenericReceive( xQueueHandle pxQueue, void * const pvBuffer, portTickType xTicksToWait, portBASE_TYPE xJustPeeking )
+ signed portBASE_TYPE xQueueAltGenericReceive( xQueueHandle xQueue, void * const pvBuffer, portTickType xTicksToWait, portBASE_TYPE xJustPeeking )
{
signed portBASE_TYPE xEntryTimeSet = pdFALSE;
xTimeOutType xTimeOut;
signed char *pcOriginalReadPosition;
+ xQUEUE *pxQueue;
+ pxQueue = ( xQUEUE * ) xQueue;
configASSERT( pxQueue );
configASSERT( !( ( pvBuffer == NULL ) && ( pxQueue->uxItemSize != ( unsigned portBASE_TYPE ) 0U ) ) );
@@ -968,11 +911,13 @@ xTimeOutType xTimeOut;
#endif /* configUSE_ALTERNATIVE_API */
/*-----------------------------------------------------------*/
-signed portBASE_TYPE xQueueGenericSendFromISR( xQueueHandle pxQueue, const void * const pvItemToQueue, signed portBASE_TYPE *pxHigherPriorityTaskWoken, portBASE_TYPE xCopyPosition )
+signed portBASE_TYPE xQueueGenericSendFromISR( xQueueHandle xQueue, const void * const pvItemToQueue, signed portBASE_TYPE *pxHigherPriorityTaskWoken, portBASE_TYPE xCopyPosition )
{
signed portBASE_TYPE xReturn;
unsigned portBASE_TYPE uxSavedInterruptStatus;
+xQUEUE *pxQueue;
+ pxQueue = ( xQUEUE * ) xQueue;
configASSERT( pxQueue );
configASSERT( !( ( pvItemToQueue == NULL ) && ( pxQueue->uxItemSize != ( unsigned portBASE_TYPE ) 0U ) ) );
@@ -1062,12 +1007,14 @@ unsigned portBASE_TYPE uxSavedInterruptStatus;
}
/*-----------------------------------------------------------*/
-signed portBASE_TYPE xQueueGenericReceive( xQueueHandle pxQueue, void * const pvBuffer, portTickType xTicksToWait, portBASE_TYPE xJustPeeking )
+signed portBASE_TYPE xQueueGenericReceive( xQueueHandle xQueue, void * const pvBuffer, portTickType xTicksToWait, portBASE_TYPE xJustPeeking )
{
signed portBASE_TYPE xEntryTimeSet = pdFALSE;
xTimeOutType xTimeOut;
signed char *pcOriginalReadPosition;
+xQUEUE *pxQueue;
+ pxQueue = ( xQUEUE * ) xQueue;
configASSERT( pxQueue );
configASSERT( !( ( pvBuffer == NULL ) && ( pxQueue->uxItemSize != ( unsigned portBASE_TYPE ) 0U ) ) );
@@ -1211,11 +1158,13 @@ signed char *pcOriginalReadPosition;
}
/*-----------------------------------------------------------*/
-signed portBASE_TYPE xQueueReceiveFromISR( xQueueHandle pxQueue, void * const pvBuffer, signed portBASE_TYPE *pxHigherPriorityTaskWoken )
+signed portBASE_TYPE xQueueReceiveFromISR( xQueueHandle xQueue, void * const pvBuffer, signed portBASE_TYPE *pxHigherPriorityTaskWoken )
{
signed portBASE_TYPE xReturn;
unsigned portBASE_TYPE uxSavedInterruptStatus;
+xQUEUE *pxQueue;
+ pxQueue = ( xQUEUE * ) xQueue;
configASSERT( pxQueue );
configASSERT( !( ( pvBuffer == NULL ) && ( pxQueue->uxItemSize != ( unsigned portBASE_TYPE ) 0U ) ) );
@@ -1268,38 +1217,41 @@ unsigned portBASE_TYPE uxSavedInterruptStatus;
}
/*-----------------------------------------------------------*/
-unsigned portBASE_TYPE uxQueueMessagesWaiting( const xQueueHandle pxQueue )
+unsigned portBASE_TYPE uxQueueMessagesWaiting( const xQueueHandle xQueue )
{
unsigned portBASE_TYPE uxReturn;
- configASSERT( pxQueue );
+ configASSERT( xQueue );
taskENTER_CRITICAL();
- uxReturn = pxQueue->uxMessagesWaiting;
+ uxReturn = ( ( xQUEUE * ) xQueue )->uxMessagesWaiting;
taskEXIT_CRITICAL();
return uxReturn;
}
/*-----------------------------------------------------------*/
-unsigned portBASE_TYPE uxQueueMessagesWaitingFromISR( const xQueueHandle pxQueue )
+unsigned portBASE_TYPE uxQueueMessagesWaitingFromISR( const xQueueHandle xQueue )
{
unsigned portBASE_TYPE uxReturn;
- configASSERT( pxQueue );
+ configASSERT( xQueue );
- uxReturn = pxQueue->uxMessagesWaiting;
+ uxReturn = ( ( xQUEUE * ) xQueue )->uxMessagesWaiting;
return uxReturn;
}
/*-----------------------------------------------------------*/
-void vQueueDelete( xQueueHandle pxQueue )
+void vQueueDelete( xQueueHandle xQueue )
{
+xQUEUE *pxQueue;
+
+ pxQueue = ( xQUEUE * ) xQueue;
configASSERT( pxQueue );
traceQUEUE_DELETE( pxQueue );
- vQueueUnregisterQueue( pxQueue );
+ prvQueueUnregisterQueue( pxQueue );
vPortFree( pxQueue->pcHead );
vPortFree( pxQueue );
}
@@ -1307,9 +1259,9 @@ void vQueueDelete( xQueueHandle pxQueue )
#if ( configUSE_TRACE_FACILITY == 1 )
- unsigned char ucQueueGetQueueNumber( xQueueHandle pxQueue )
+ unsigned char ucQueueGetQueueNumber( xQueueHandle xQueue )
{
- return pxQueue->ucQueueNumber;
+ return ( ( xQUEUE * ) xQueue )->ucQueueNumber;
}
#endif /* configUSE_TRACE_FACILITY */
@@ -1317,9 +1269,9 @@ void vQueueDelete( xQueueHandle pxQueue )
#if ( configUSE_TRACE_FACILITY == 1 )
- void vQueueSetQueueNumber( xQueueHandle pxQueue, unsigned char ucQueueNumber )
+ void vQueueSetQueueNumber( xQueueHandle xQueue, unsigned char ucQueueNumber )
{
- pxQueue->ucQueueNumber = ucQueueNumber;
+ ( ( xQUEUE * ) xQueue )->ucQueueNumber = ucQueueNumber;
}
#endif /* configUSE_TRACE_FACILITY */
@@ -1327,9 +1279,9 @@ void vQueueDelete( xQueueHandle pxQueue )
#if ( configUSE_TRACE_FACILITY == 1 )
- unsigned char ucQueueGetQueueType( xQueueHandle pxQueue )
+ unsigned char ucQueueGetQueueType( xQueueHandle xQueue )
{
- return pxQueue->ucQueueType;
+ return ( ( xQUEUE * ) xQueue )->ucQueueType;
}
#endif /* configUSE_TRACE_FACILITY */
@@ -1387,7 +1339,7 @@ static void prvCopyDataFromQueue( xQUEUE * const pxQueue, const void *pvBuffer )
}
/*-----------------------------------------------------------*/
-static void prvUnlockQueue( xQueueHandle pxQueue )
+static void prvUnlockQueue( xQUEUE *pxQueue )
{
/* THIS FUNCTION MUST BE CALLED WITH THE SCHEDULER SUSPENDED. */
@@ -1486,47 +1438,79 @@ static void prvUnlockQueue( xQueueHandle pxQueue )
}
/*-----------------------------------------------------------*/
-static signed portBASE_TYPE prvIsQueueEmpty( const xQueueHandle pxQueue )
+static signed portBASE_TYPE prvIsQueueEmpty( const xQUEUE *pxQueue )
{
signed portBASE_TYPE xReturn;
taskENTER_CRITICAL();
- xReturn = ( pxQueue->uxMessagesWaiting == ( unsigned portBASE_TYPE ) 0 );
+ {
+ if( pxQueue->uxMessagesWaiting == 0 )
+ {
+ xReturn = pdTRUE;
+ }
+ else
+ {
+ xReturn = pdFALSE;
+ }
+ }
taskEXIT_CRITICAL();
return xReturn;
}
/*-----------------------------------------------------------*/
-signed portBASE_TYPE xQueueIsQueueEmptyFromISR( const xQueueHandle pxQueue )
+signed portBASE_TYPE xQueueIsQueueEmptyFromISR( const xQueueHandle xQueue )
{
signed portBASE_TYPE xReturn;
- configASSERT( pxQueue );
- xReturn = ( pxQueue->uxMessagesWaiting == ( unsigned portBASE_TYPE ) 0 );
+ configASSERT( xQueue );
+ if( ( ( xQUEUE * ) xQueue )->uxMessagesWaiting == 0 )
+ {
+ xReturn = pdTRUE;
+ }
+ else
+ {
+ xReturn = pdFALSE;
+ }
return xReturn;
}
/*-----------------------------------------------------------*/
-static signed portBASE_TYPE prvIsQueueFull( const xQueueHandle pxQueue )
+static signed portBASE_TYPE prvIsQueueFull( const xQUEUE *pxQueue )
{
signed portBASE_TYPE xReturn;
taskENTER_CRITICAL();
- xReturn = ( pxQueue->uxMessagesWaiting == pxQueue->uxLength );
+ {
+ if( pxQueue->uxMessagesWaiting == pxQueue->uxLength )
+ {
+ xReturn = pdTRUE;
+ }
+ else
+ {
+ xReturn = pdFALSE;
+ }
+ }
taskEXIT_CRITICAL();
return xReturn;
}
/*-----------------------------------------------------------*/
-signed portBASE_TYPE xQueueIsQueueFullFromISR( const xQueueHandle pxQueue )
+signed portBASE_TYPE xQueueIsQueueFullFromISR( const xQueueHandle xQueue )
{
signed portBASE_TYPE xReturn;
- configASSERT( pxQueue );
- xReturn = ( pxQueue->uxMessagesWaiting == pxQueue->uxLength );
+ configASSERT( xQueue );
+ if( ( ( xQUEUE * ) xQueue )->uxMessagesWaiting == ( ( xQUEUE * ) xQueue )->uxLength )
+ {
+ xReturn = pdTRUE;
+ }
+ else
+ {
+ xReturn = pdFALSE;
+ }
return xReturn;
}
@@ -1534,9 +1518,12 @@ signed portBASE_TYPE xReturn;
#if ( configUSE_CO_ROUTINES == 1 )
- signed portBASE_TYPE xQueueCRSend( xQueueHandle pxQueue, const void *pvItemToQueue, portTickType xTicksToWait )
+ signed portBASE_TYPE xQueueCRSend( xQueueHandle xQueue, const void *pvItemToQueue, portTickType xTicksToWait )
{
signed portBASE_TYPE xReturn;
+ xQUEUE *pxQueue;
+
+ pxQueue = ( xQUEUE * ) xQueue;
/* If the queue is already full we may have to block. A critical section
is required to prevent an interrupt removing something from the queue
@@ -1564,8 +1551,6 @@ signed portBASE_TYPE xReturn;
}
portENABLE_INTERRUPTS();
- portNOP();
-
portDISABLE_INTERRUPTS();
{
if( pxQueue->uxMessagesWaiting < pxQueue->uxLength )
@@ -1604,9 +1589,12 @@ signed portBASE_TYPE xReturn;
#if ( configUSE_CO_ROUTINES == 1 )
- signed portBASE_TYPE xQueueCRReceive( xQueueHandle pxQueue, void *pvBuffer, portTickType xTicksToWait )
+ signed portBASE_TYPE xQueueCRReceive( xQueueHandle xQueue, void *pvBuffer, portTickType xTicksToWait )
{
signed portBASE_TYPE xReturn;
+ xQUEUE *pxQueue;
+
+ pxQueue = ( xQUEUE * ) xQueue;
/* If the queue is already empty we may have to block. A critical section
is required to prevent an interrupt adding something to the queue
@@ -1634,8 +1622,6 @@ signed portBASE_TYPE xReturn;
}
portENABLE_INTERRUPTS();
- portNOP();
-
portDISABLE_INTERRUPTS();
{
if( pxQueue->uxMessagesWaiting > ( unsigned portBASE_TYPE ) 0 )
@@ -1679,8 +1665,12 @@ signed portBASE_TYPE xReturn;
#if ( configUSE_CO_ROUTINES == 1 )
- signed portBASE_TYPE xQueueCRSendFromISR( xQueueHandle pxQueue, const void *pvItemToQueue, signed portBASE_TYPE xCoRoutinePreviouslyWoken )
+ signed portBASE_TYPE xQueueCRSendFromISR( xQueueHandle xQueue, const void *pvItemToQueue, signed portBASE_TYPE xCoRoutinePreviouslyWoken )
{
+ xQUEUE *pxQueue;
+
+ pxQueue = ( xQUEUE * ) xQueue;
+
/* Cannot block within an ISR so if there is no space on the queue then
exit without doing anything. */
if( pxQueue->uxMessagesWaiting < pxQueue->uxLength )
@@ -1709,9 +1699,12 @@ signed portBASE_TYPE xReturn;
#if ( configUSE_CO_ROUTINES == 1 )
- signed portBASE_TYPE xQueueCRReceiveFromISR( xQueueHandle pxQueue, void *pvBuffer, signed portBASE_TYPE *pxCoRoutineWoken )
+ signed portBASE_TYPE xQueueCRReceiveFromISR( xQueueHandle xQueue, void *pvBuffer, signed portBASE_TYPE *pxCoRoutineWoken )
{
signed portBASE_TYPE xReturn;
+ xQUEUE * pxQueue;
+
+ pxQueue = ( xQUEUE * ) xQueue;
/* We cannot block from an ISR, so check there is data available. If
not then just leave without doing anything. */
@@ -1775,7 +1768,7 @@ signed portBASE_TYPE xReturn;
#if ( configQUEUE_REGISTRY_SIZE > 0 )
- static void vQueueUnregisterQueue( xQueueHandle xQueue )
+ static void prvQueueUnregisterQueue( xQueueHandle xQueue )
{
unsigned portBASE_TYPE ux;
@@ -1798,8 +1791,12 @@ signed portBASE_TYPE xReturn;
#if ( configUSE_TIMERS == 1 )
- void vQueueWaitForMessageRestricted( xQueueHandle pxQueue, portTickType xTicksToWait )
+ void vQueueWaitForMessageRestricted( xQueueHandle xQueue, portTickType xTicksToWait )
{
+ xQUEUE *pxQueue;
+
+ pxQueue = ( xQUEUE * ) xQueue;
+
/* This function should not be called by application code hence the
'Restricted' in its name. It is not part of the public API. It is
designed for use by kernel code, and has special calling requirements.
@@ -1830,11 +1827,11 @@ signed portBASE_TYPE xReturn;
xQueueSetHandle xQueueCreateSet( unsigned portBASE_TYPE uxEventQueueLength )
{
- xQUEUE *pxQueue;
+ xQueueSetHandle pxQueue;
pxQueue = xQueueGenericCreate( uxEventQueueLength, sizeof( xQUEUE * ), queueQUEUE_TYPE_SET );
- return ( xQueueSetHandle ) pxQueue;
+ return pxQueue;
}
#endif /* configUSE_QUEUE_SETS */
@@ -1846,7 +1843,7 @@ signed portBASE_TYPE xReturn;
{
portBASE_TYPE xReturn;
- if( xQueueOrSemaphore->pxQueueSetContainer != NULL )
+ if( ( ( xQUEUE * ) xQueueOrSemaphore )->pxQueueSetContainer != NULL )
{
xReturn = pdFAIL;
}
@@ -1854,7 +1851,7 @@ signed portBASE_TYPE xReturn;
{
taskENTER_CRITICAL();
{
- xQueueOrSemaphore->pxQueueSetContainer = xQueueSet;
+ ( ( xQUEUE * ) xQueueOrSemaphore )->pxQueueSetContainer = xQueueSet;
}
taskEXIT_CRITICAL();
xReturn = pdPASS;
@@ -1871,13 +1868,16 @@ signed portBASE_TYPE xReturn;
portBASE_TYPE xQueueRemoveFromSet( xQueueSetMemberHandle xQueueOrSemaphore, xQueueSetHandle xQueueSet )
{
portBASE_TYPE xReturn;
+ xQUEUE *pxQueueOrSemaphore;
+
+ pxQueueOrSemaphore = ( xQUEUE * ) xQueueOrSemaphore;
- if( xQueueOrSemaphore->pxQueueSetContainer != xQueueSet )
+ if( pxQueueOrSemaphore->pxQueueSetContainer != xQueueSet )
{
/* The queue was not a member of the set. */
xReturn = pdFAIL;
}
- else if( xQueueOrSemaphore->uxMessagesWaiting != 0 )
+ else if( pxQueueOrSemaphore->uxMessagesWaiting != 0 )
{
/* It is dangerous to remove a queue from a set when the queue is
not empty because the queue set will still hold pending events for
@@ -1889,7 +1889,7 @@ signed portBASE_TYPE xReturn;
taskENTER_CRITICAL();
{
/* The queue is no longer contained in the set. */
- xQueueOrSemaphore->pxQueueSetContainer = NULL;
+ pxQueueOrSemaphore->pxQueueSetContainer = NULL;
}
taskEXIT_CRITICAL();
xReturn = pdPASS;
diff --git a/FreeRTOS/Source/tasks.c b/FreeRTOS/Source/tasks.c
index ba7d37dcf..854251261 100644
--- a/FreeRTOS/Source/tasks.c
+++ b/FreeRTOS/Source/tasks.c
@@ -373,7 +373,7 @@ portTickType xItemValue; \
#define prvGetTCBFromHandle( pxHandle ) ( ( ( pxHandle ) == NULL ) ? ( tskTCB * ) pxCurrentTCB : ( tskTCB * ) ( pxHandle ) )
/* Callback function prototypes. --------------------------*/
-extern void vApplicationStackOverflowHook( xTaskHandle pxTask, signed char *pcTaskName );
+extern void vApplicationStackOverflowHook( xTaskHandle xTask, signed char *pcTaskName );
extern void vApplicationTickHook( void );
/* File private functions. --------------------------------*/
@@ -643,7 +643,7 @@ tskTCB * pxNewTCB;
#if ( INCLUDE_vTaskDelete == 1 )
- void vTaskDelete( xTaskHandle pxTaskToDelete )
+ void vTaskDelete( xTaskHandle xTaskToDelete )
{
tskTCB *pxTCB;
@@ -651,13 +651,13 @@ tskTCB * pxNewTCB;
{
/* Ensure a yield is performed if the current task is being
deleted. */
- if( pxTaskToDelete == pxCurrentTCB )
+ if( xTaskToDelete == pxCurrentTCB )
{
- pxTaskToDelete = NULL;
+ xTaskToDelete = NULL;
}
/* If null is passed in here then we are deleting ourselves. */
- pxTCB = prvGetTCBFromHandle( pxTaskToDelete );
+ pxTCB = prvGetTCBFromHandle( xTaskToDelete );
/* Remove task from the ready list and place in the termination list.
This will stop the task from be scheduled. The idle task will check
@@ -692,7 +692,7 @@ tskTCB * pxNewTCB;
/* Force a reschedule if we have just deleted the current task. */
if( xSchedulerRunning != pdFALSE )
{
- if( ( void * ) pxTaskToDelete == NULL )
+ if( ( void * ) xTaskToDelete == NULL )
{
portYIELD_WITHIN_API();
}
@@ -828,13 +828,13 @@ tskTCB * pxNewTCB;
#if ( INCLUDE_eTaskGetState == 1 )
- eTaskState eTaskGetState( xTaskHandle pxTask )
+ eTaskState eTaskGetState( xTaskHandle xTask )
{
eTaskState eReturn;
xList *pxStateList;
tskTCB *pxTCB;
- pxTCB = ( tskTCB * ) pxTask;
+ pxTCB = ( tskTCB * ) xTask;
if( pxTCB == pxCurrentTCB )
{
@@ -890,7 +890,7 @@ tskTCB * pxNewTCB;
#if ( INCLUDE_uxTaskPriorityGet == 1 )
- unsigned portBASE_TYPE uxTaskPriorityGet( xTaskHandle pxTask )
+ unsigned portBASE_TYPE uxTaskPriorityGet( xTaskHandle xTask )
{
tskTCB *pxTCB;
unsigned portBASE_TYPE uxReturn;
@@ -899,7 +899,7 @@ tskTCB * pxNewTCB;
{
/* If null is passed in here then we are changing the
priority of the calling function. */
- pxTCB = prvGetTCBFromHandle( pxTask );
+ pxTCB = prvGetTCBFromHandle( xTask );
uxReturn = pxTCB->uxPriority;
}
taskEXIT_CRITICAL();
@@ -912,7 +912,7 @@ tskTCB * pxNewTCB;
#if ( INCLUDE_vTaskPrioritySet == 1 )
- void vTaskPrioritySet( xTaskHandle pxTask, unsigned portBASE_TYPE uxNewPriority )
+ void vTaskPrioritySet( xTaskHandle xTask, unsigned portBASE_TYPE uxNewPriority )
{
tskTCB *pxTCB;
unsigned portBASE_TYPE uxCurrentPriority, uxPriorityUsedOnEntry;
@@ -928,14 +928,14 @@ tskTCB * pxNewTCB;
taskENTER_CRITICAL();
{
- if( pxTask == pxCurrentTCB )
+ if( xTask == pxCurrentTCB )
{
- pxTask = NULL;
+ xTask = NULL;
}
/* If null is passed in here then we are changing the
priority of the calling function. */
- pxTCB = prvGetTCBFromHandle( pxTask );
+ pxTCB = prvGetTCBFromHandle( xTask );
traceTASK_PRIORITY_SET( pxTCB, uxNewPriority );
@@ -955,7 +955,7 @@ tskTCB * pxNewTCB;
priority than the calling task. */
if( uxNewPriority > uxCurrentPriority )
{
- if( pxTask != NULL )
+ if( xTask != NULL )
{
/* The priority of another task is being raised. If we
were raising the priority of the currently running task
@@ -964,7 +964,7 @@ tskTCB * pxNewTCB;
xYieldRequired = pdTRUE;
}
}
- else if( pxTask == NULL )
+ else if( xTask == NULL )
{
/* Setting our own priority down means there may now be another
task of higher priority that is ready to execute. */
@@ -1034,7 +1034,7 @@ tskTCB * pxNewTCB;
#if ( INCLUDE_vTaskSuspend == 1 )
- void vTaskSuspend( xTaskHandle pxTaskToSuspend )
+ void vTaskSuspend( xTaskHandle xTaskToSuspend )
{
tskTCB *pxTCB;
@@ -1042,13 +1042,13 @@ tskTCB * pxNewTCB;
{
/* Ensure a yield is performed if the current task is being
suspended. */
- if( pxTaskToSuspend == pxCurrentTCB )
+ if( xTaskToSuspend == pxCurrentTCB )
{
- pxTaskToSuspend = NULL;
+ xTaskToSuspend = NULL;
}
/* If null is passed in here then we are suspending ourselves. */
- pxTCB = prvGetTCBFromHandle( pxTaskToSuspend );
+ pxTCB = prvGetTCBFromHandle( xTaskToSuspend );
traceTASK_SUSPEND( pxTCB );
@@ -1068,7 +1068,7 @@ tskTCB * pxNewTCB;
}
taskEXIT_CRITICAL();
- if( ( void * ) pxTaskToSuspend == NULL )
+ if( ( void * ) xTaskToSuspend == NULL )
{
if( xSchedulerRunning != pdFALSE )
{
@@ -1135,16 +1135,16 @@ tskTCB * pxNewTCB;
#if ( INCLUDE_vTaskSuspend == 1 )
- void vTaskResume( xTaskHandle pxTaskToResume )
+ void vTaskResume( xTaskHandle xTaskToResume )
{
tskTCB *pxTCB;
/* It does not make sense to resume the calling task. */
- configASSERT( pxTaskToResume );
+ configASSERT( xTaskToResume );
/* Remove the task from whichever list it is currently in, and place
it in the ready list. */
- pxTCB = ( tskTCB * ) pxTaskToResume;
+ pxTCB = ( tskTCB * ) xTaskToResume;
/* The parameter cannot be NULL as it is impossible to resume the
currently executing task. */
@@ -1180,15 +1180,15 @@ tskTCB * pxNewTCB;
#if ( ( INCLUDE_xTaskResumeFromISR == 1 ) && ( INCLUDE_vTaskSuspend == 1 ) )
- portBASE_TYPE xTaskResumeFromISR( xTaskHandle pxTaskToResume )
+ portBASE_TYPE xTaskResumeFromISR( xTaskHandle xTaskToResume )
{
portBASE_TYPE xYieldRequired = pdFALSE;
tskTCB *pxTCB;
unsigned portBASE_TYPE uxSavedInterruptStatus;
- configASSERT( pxTaskToResume );
+ configASSERT( xTaskToResume );
- pxTCB = ( tskTCB * ) pxTaskToResume;
+ pxTCB = ( tskTCB * ) xTaskToResume;
uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
{