/*\r
- FreeRTOS V7.6.0 - Copyright (C) 2013 Real Time Engineers Ltd.\r
+ FreeRTOS V8.0.0:rc1 - Copyright (C) 2014 Real Time Engineers Ltd.\r
All rights reserved\r
\r
VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.\r
#error configUSE_TIMERS must be set to 1 to make the xEventGroupSetBitFromISR() function available.\r
#endif\r
\r
-#if ( INCLUDE_xEventGroupSetBitFromISR == 1 ) && ( INCLUDE_xTimerPendCallbackFromISR == 0 )\r
- #error INCLUDE_xTimerPendCallbackFromISR must also be set to one to make the xEventGroupSetBitFromISR() function available.\r
+#if ( INCLUDE_xEventGroupSetBitFromISR == 1 ) && ( INCLUDE_xTimerPendFunctionCall == 0 )\r
+ #error INCLUDE_xTimerPendFunctionCall must also be set to one to make the xEventGroupSetBitFromISR() function available.\r
#endif\r
\r
/* The following bit fields convey control information in a task's event list\r
#define eventEVENT_BITS_CONTROL_BYTES 0xff000000UL\r
#endif\r
\r
-typedef struct EventBitsDefinition\r
+typedef struct xEventGroupDefinition\r
{\r
- xEventBitsType uxEventBits;\r
- xList xTasksWaitingForBits; /*< List of tasks waiting for a bit to be set. */\r
-} xEVENT_BITS;\r
+ EventBits_t uxEventBits;\r
+ List_t xTasksWaitingForBits; /*< List of tasks waiting for a bit to be set. */\r
\r
-/* Used internally only. */\r
-typedef struct EVENT_GROUP_CALLBACK_PARAMTERS\r
-{\r
- xEventGroupHandle xTargetEventGroup;\r
- xEventBitsType xBitsToSet;\r
-} xEventGroupCallbackParameters;\r
+ #if( configUSE_TRACE_FACILITY == 1 )\r
+ UBaseType_t uxEventGroupNumber;\r
+ #endif\r
+\r
+} EventGroup_t;\r
\r
/*-----------------------------------------------------------*/\r
\r
* wait condition is met if any of the bits set in uxBitsToWait for are also set\r
* in uxCurrentEventBits.\r
*/\r
-static portBASE_TYPE prvTestWaitCondition( const xEventBitsType uxCurrentEventBits, const xEventBitsType uxBitsToWaitFor, const portBASE_TYPE xWaitForAllBits );\r
+static BaseType_t prvTestWaitCondition( const EventBits_t uxCurrentEventBits, const EventBits_t uxBitsToWaitFor, const BaseType_t xWaitForAllBits );\r
\r
/*-----------------------------------------------------------*/\r
\r
-xEventGroupHandle xEventGroupCreate( void )\r
+EventGroupHandle_t xEventGroupCreate( void )\r
{\r
-xEVENT_BITS *pxEventBits;\r
+EventGroup_t *pxEventBits;\r
\r
- pxEventBits = pvPortMalloc( sizeof( xEVENT_BITS ) );\r
+ pxEventBits = pvPortMalloc( sizeof( EventGroup_t ) );\r
if( pxEventBits != NULL )\r
{\r
pxEventBits->uxEventBits = 0;\r
traceEVENT_GROUP_CREATE_FAILED();\r
}\r
\r
- return ( xEventGroupHandle ) pxEventBits;\r
+ return ( EventGroupHandle_t ) pxEventBits;\r
}\r
/*-----------------------------------------------------------*/\r
\r
-xEventBitsType xEventGroupSync( xEventGroupHandle xEventGroup, const xEventBitsType uxBitsToSet, const xEventBitsType uxBitsToWaitFor, portTickType xTicksToWait )\r
+EventBits_t xEventGroupSync( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet, const EventBits_t uxBitsToWaitFor, TickType_t xTicksToWait )\r
{\r
-xEventBitsType uxOriginalBitValue, uxReturn;\r
-xEVENT_BITS *pxEventBits = ( xEVENT_BITS * ) xEventGroup;\r
-portBASE_TYPE xAlreadyYielded;\r
+EventBits_t uxOriginalBitValue, uxReturn;\r
+EventGroup_t *pxEventBits = ( EventGroup_t * ) xEventGroup;\r
+BaseType_t xAlreadyYielded;\r
+BaseType_t xTimeoutOccurred = pdFALSE;\r
\r
configASSERT( ( uxBitsToWaitFor & eventEVENT_BITS_CONTROL_BYTES ) == 0 );\r
configASSERT( uxBitsToWaitFor != 0 );\r
\r
vTaskSuspendAll();\r
{\r
- traceEVENT_GROUP_SYNC_START( xEventGroup, uxBitsToSet );\r
-\r
uxOriginalBitValue = pxEventBits->uxEventBits;\r
\r
( void ) xEventGroupSetBits( xEventGroup, uxBitsToSet );\r
}\r
else\r
{\r
- if( xTicksToWait != ( portTickType ) 0 )\r
+ if( xTicksToWait != ( TickType_t ) 0 )\r
{\r
+ traceEVENT_GROUP_SYNC_BLOCK( xEventGroup, uxBitsToSet, uxBitsToWaitFor );\r
+\r
/* Store the bits that the calling task is waiting for in the\r
task's event list item so the kernel knows when a match is\r
found. Then enter the blocked state. */\r
}\r
xAlreadyYielded = xTaskResumeAll();\r
\r
- if( xTicksToWait != ( portTickType ) 0 )\r
+ if( xTicksToWait != ( TickType_t ) 0 )\r
{\r
if( xAlreadyYielded == pdFALSE )\r
{\r
}\r
else\r
{\r
- mtBRANCH_TEST_INSTRUCTION();\r
+ mtCOVERAGE_TEST_MARKER();\r
}\r
\r
/* The task blocked to wait for its required bits to be set - at this\r
event list item, and they should now be retrieved then cleared. */\r
uxReturn = uxTaskResetEventItemValue();\r
\r
- if( ( uxReturn & eventUNBLOCKED_DUE_TO_BIT_SET ) == ( xEventBitsType ) 0 )\r
+ if( ( uxReturn & eventUNBLOCKED_DUE_TO_BIT_SET ) == ( EventBits_t ) 0 )\r
{\r
/* The task timed out, just return the current event bit value. */\r
taskENTER_CRITICAL();\r
}\r
else\r
{\r
- mtBRANCH_TEST_INSTRUCTION();\r
+ mtCOVERAGE_TEST_MARKER();\r
}\r
}\r
taskEXIT_CRITICAL();\r
+\r
+ xTimeoutOccurred = pdTRUE;\r
}\r
else\r
{\r
}\r
}\r
\r
- traceEVENT_GROUP_SYNC_END( xEventGroup, uxReturn );\r
+ traceEVENT_GROUP_SYNC_END( xEventGroup, uxBitsToSet, uxBitsToWaitFor, xTimeoutOccurred );\r
return uxReturn;\r
}\r
/*-----------------------------------------------------------*/\r
\r
-xEventBitsType xEventGroupWaitBits( xEventGroupHandle xEventGroup, const xEventBitsType uxBitsToWaitFor, const portBASE_TYPE xClearOnExit, const portBASE_TYPE xWaitForAllBits, portTickType xTicksToWait )\r
+EventBits_t xEventGroupWaitBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToWaitFor, const BaseType_t xClearOnExit, const BaseType_t xWaitForAllBits, TickType_t xTicksToWait )\r
{\r
-xEVENT_BITS *pxEventBits = ( xEVENT_BITS * ) xEventGroup;\r
-xEventBitsType uxReturn, uxControlBits = 0;\r
-portBASE_TYPE xWaitConditionMet, xAlreadyYielded;\r
+EventGroup_t *pxEventBits = ( EventGroup_t * ) xEventGroup;\r
+EventBits_t uxReturn, uxControlBits = 0;\r
+BaseType_t xWaitConditionMet, xAlreadyYielded;\r
+BaseType_t xTimeoutOccurred = pdFALSE;\r
\r
/* Check the user is not attempting to wait on the bits used by the kernel\r
itself, and that at least one bit is being requested. */\r
\r
vTaskSuspendAll();\r
{\r
- const xEventBitsType uxCurrentEventBits = pxEventBits->uxEventBits;\r
-\r
- traceEVENT_GROUP_WAIT_BITS_START( xEventGroup, uxBitsToWaitFor );\r
+ const EventBits_t uxCurrentEventBits = pxEventBits->uxEventBits;\r
\r
/* Check to see if the wait condition is already met or not. */\r
xWaitConditionMet = prvTestWaitCondition( uxCurrentEventBits, uxBitsToWaitFor, xWaitForAllBits );\r
/* The wait condition has already been met so there is no need to\r
block. */\r
uxReturn = uxCurrentEventBits;\r
- xTicksToWait = ( portTickType ) 0;\r
+ xTicksToWait = ( TickType_t ) 0;\r
\r
/* Clear the wait bits if requested to do so. */\r
if( xClearOnExit != pdFALSE )\r
}\r
else\r
{\r
- mtBRANCH_TEST_INSTRUCTION();\r
+ mtCOVERAGE_TEST_MARKER();\r
}\r
}\r
- else if( xTicksToWait == ( portTickType ) 0 )\r
+ else if( xTicksToWait == ( TickType_t ) 0 )\r
{\r
/* The wait condition has not been met, but no block time was\r
specified, so just return the current value. */\r
}\r
else\r
{\r
- mtBRANCH_TEST_INSTRUCTION();\r
+ mtCOVERAGE_TEST_MARKER();\r
}\r
\r
if( xWaitForAllBits != pdFALSE )\r
}\r
else\r
{\r
- mtBRANCH_TEST_INSTRUCTION();\r
+ mtCOVERAGE_TEST_MARKER();\r
}\r
\r
/* Store the bits that the calling task is waiting for in the\r
some compilers mistakenly generate a warning about the variable\r
being returned without being set if it is not done. */\r
uxReturn = 0;\r
+\r
+ traceEVENT_GROUP_WAIT_BITS_BLOCK( xEventGroup, uxBitsToWaitFor );\r
}\r
}\r
xAlreadyYielded = xTaskResumeAll();\r
\r
- if( xTicksToWait != ( portTickType ) 0 )\r
+ if( xTicksToWait != ( TickType_t ) 0 )\r
{\r
if( xAlreadyYielded == pdFALSE )\r
{\r
}\r
else\r
{\r
- mtBRANCH_TEST_INSTRUCTION();\r
+ mtCOVERAGE_TEST_MARKER();\r
}\r
\r
/* The task blocked to wait for its required bits to be set - at this\r
event list item, and they should now be retrieved then cleared. */\r
uxReturn = uxTaskResetEventItemValue();\r
\r
- if( ( uxReturn & eventUNBLOCKED_DUE_TO_BIT_SET ) == ( xEventBitsType ) 0 )\r
+ if( ( uxReturn & eventUNBLOCKED_DUE_TO_BIT_SET ) == ( EventBits_t ) 0 )\r
{\r
taskENTER_CRITICAL();\r
{\r
}\r
else\r
{\r
- mtBRANCH_TEST_INSTRUCTION();\r
+ mtCOVERAGE_TEST_MARKER();\r
}\r
}\r
else\r
{\r
- mtBRANCH_TEST_INSTRUCTION();\r
+ mtCOVERAGE_TEST_MARKER();\r
}\r
}\r
taskEXIT_CRITICAL();\r
+\r
+ xTimeoutOccurred = pdFALSE;\r
}\r
else\r
{\r
uxReturn &= ~eventEVENT_BITS_CONTROL_BYTES;\r
}\r
}\r
-\r
- traceEVENT_GROUP_WAIT_BITS_END( xEventGroup, uxReturn );\r
+ traceEVENT_GROUP_WAIT_BITS_END( xEventGroup, uxBitsToWaitFor, xTimeoutOccurred );\r
return uxReturn;\r
}\r
/*-----------------------------------------------------------*/\r
\r
-xEventBitsType xEventGroupClearBits( xEventGroupHandle xEventGroup, const xEventBitsType uxBitsToClear )\r
+EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear )\r
{\r
-xEVENT_BITS *pxEventBits = ( xEVENT_BITS * ) xEventGroup;\r
-xEventBitsType uxReturn;\r
+EventGroup_t *pxEventBits = ( EventGroup_t * ) xEventGroup;\r
+EventBits_t uxReturn;\r
\r
/* Check the user is not attempting to clear the bits used by the kernel\r
itself. */\r
}\r
/*-----------------------------------------------------------*/\r
\r
-xEventBitsType xEventGroupSetBits( xEventGroupHandle xEventGroup, const xEventBitsType uxBitsToSet )\r
+EventBits_t xEventGroupClearBitsFromISR( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear )\r
+{\r
+UBaseType_t uxSavedInterruptStatus;\r
+EventGroup_t *pxEventBits = ( EventGroup_t * ) xEventGroup;\r
+EventBits_t uxReturn;\r
+\r
+ /* Check the user is not attempting to clear the bits used by the kernel\r
+ itself. */\r
+ configASSERT( ( uxBitsToClear & eventEVENT_BITS_CONTROL_BYTES ) == 0 );\r
+\r
+ uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();\r
+ {\r
+ traceEVENT_GROUP_CLEAR_BITS_FROM_ISR( xEventGroup, uxBitsToClear );\r
+\r
+ /* The value returned is the event group value prior to the bits being\r
+ cleared. */\r
+ uxReturn = pxEventBits->uxEventBits;\r
+\r
+ /* Clear the bits. */\r
+ pxEventBits->uxEventBits &= ~uxBitsToClear;\r
+ }\r
+ portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );\r
+\r
+ return uxReturn;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet )\r
{\r
-xListItem *pxListItem, *pxNext;\r
-xListItem const *pxListEnd;\r
-xList *pxList;\r
-xEventBitsType uxBitsToClear = 0, uxBitsWaitedFor, uxControlBits;\r
-xEVENT_BITS *pxEventBits = ( xEVENT_BITS * ) xEventGroup;\r
-portBASE_TYPE xMatchFound = pdFALSE;\r
+ListItem_t *pxListItem, *pxNext;\r
+ListItem_t const *pxListEnd;\r
+List_t *pxList;\r
+EventBits_t uxBitsToClear = 0, uxBitsWaitedFor, uxControlBits;\r
+EventGroup_t *pxEventBits = ( EventGroup_t * ) xEventGroup;\r
+BaseType_t xMatchFound = pdFALSE;\r
\r
/* Check the user is not attempting to set the bits used by the kernel\r
itself. */\r
uxControlBits = uxBitsWaitedFor & eventEVENT_BITS_CONTROL_BYTES;\r
uxBitsWaitedFor &= ~eventEVENT_BITS_CONTROL_BYTES;\r
\r
- if( ( uxControlBits & eventWAIT_FOR_ALL_BITS ) == ( xEventBitsType ) 0 )\r
+ if( ( uxControlBits & eventWAIT_FOR_ALL_BITS ) == ( EventBits_t ) 0 )\r
{\r
/* Just looking for single bit being set. */\r
- if( ( uxBitsWaitedFor & pxEventBits->uxEventBits ) != ( xEventBitsType ) 0 )\r
+ if( ( uxBitsWaitedFor & pxEventBits->uxEventBits ) != ( EventBits_t ) 0 )\r
{\r
xMatchFound = pdTRUE;\r
}\r
else\r
{\r
- mtBRANCH_TEST_INSTRUCTION();\r
+ mtCOVERAGE_TEST_MARKER();\r
}\r
}\r
else if( ( uxBitsWaitedFor & pxEventBits->uxEventBits ) == uxBitsWaitedFor )\r
if( xMatchFound != pdFALSE )\r
{\r
/* The bits match. Should the bits be cleared on exit? */\r
- if( ( uxControlBits & eventCLEAR_EVENTS_ON_EXIT_BIT ) != ( xEventBitsType ) 0 )\r
+ if( ( uxControlBits & eventCLEAR_EVENTS_ON_EXIT_BIT ) != ( EventBits_t ) 0 )\r
{\r
uxBitsToClear |= uxBitsWaitedFor;\r
}\r
else\r
{\r
- mtBRANCH_TEST_INSTRUCTION();\r
+ mtCOVERAGE_TEST_MARKER();\r
}\r
\r
/* Store the actual event flag value in the task's event list\r
}\r
/*-----------------------------------------------------------*/\r
\r
-void vEventGroupDelete( xEventGroupHandle xEventGroup )\r
+void vEventGroupDelete( EventGroupHandle_t xEventGroup )\r
{\r
-xEVENT_BITS *pxEventBits = ( xEVENT_BITS * ) xEventGroup;\r
-const xList *pxTasksWaitingForBits = &( pxEventBits->xTasksWaitingForBits );\r
+EventGroup_t *pxEventBits = ( EventGroup_t * ) xEventGroup;\r
+const List_t *pxTasksWaitingForBits = &( pxEventBits->xTasksWaitingForBits );\r
\r
vTaskSuspendAll();\r
{\r
traceEVENT_GROUP_DELETE( xEventGroup );\r
\r
- while( listCURRENT_LIST_LENGTH( pxTasksWaitingForBits ) > ( unsigned portBASE_TYPE ) 0 )\r
+ while( listCURRENT_LIST_LENGTH( pxTasksWaitingForBits ) > ( UBaseType_t ) 0 )\r
{\r
/* Unblock the task, returning 0 as the event list is being deleted\r
and cannot therefore have any bits set. */\r
- configASSERT( pxTasksWaitingForBits->xListEnd.pxNext != ( xListItem * ) &( pxTasksWaitingForBits->xListEnd ) );\r
- ( void ) xTaskRemoveFromUnorderedEventList( pxTasksWaitingForBits->xListEnd.pxNext, ( portTickType ) eventUNBLOCKED_DUE_TO_BIT_SET );\r
+ configASSERT( pxTasksWaitingForBits->xListEnd.pxNext != ( ListItem_t * ) &( pxTasksWaitingForBits->xListEnd ) );\r
+ ( void ) xTaskRemoveFromUnorderedEventList( pxTasksWaitingForBits->xListEnd.pxNext, eventUNBLOCKED_DUE_TO_BIT_SET );\r
}\r
\r
vPortFree( pxEventBits );\r
\r
/* For internal use only - execute a 'set bits' command that was pended from\r
an interrupt. */\r
-void vEventGroupSetBitsCallback( void *pvEventGroup, const unsigned long ulBitsToSet )\r
+void vEventGroupSetBitsCallback( void *pvEventGroup, const uint32_t ulBitsToSet )\r
{\r
- ( void ) xEventGroupSetBits( pvEventGroup, ( xEventBitsType ) ulBitsToSet );\r
+ ( void ) xEventGroupSetBits( pvEventGroup, ( EventBits_t ) ulBitsToSet );\r
}\r
/*-----------------------------------------------------------*/\r
\r
-static portBASE_TYPE prvTestWaitCondition( const xEventBitsType uxCurrentEventBits, const xEventBitsType uxBitsToWaitFor, const portBASE_TYPE xWaitForAllBits )\r
+static BaseType_t prvTestWaitCondition( const EventBits_t uxCurrentEventBits, const EventBits_t uxBitsToWaitFor, const BaseType_t xWaitForAllBits )\r
{\r
-portBASE_TYPE xWaitConditionMet = pdFALSE;\r
+BaseType_t xWaitConditionMet = pdFALSE;\r
\r
if( xWaitForAllBits == pdFALSE )\r
{\r
/* Task only has to wait for one bit within uxBitsToWaitFor to be\r
set. Is one already set? */\r
- if( ( uxCurrentEventBits & uxBitsToWaitFor ) != ( xEventBitsType ) 0 )\r
+ if( ( uxCurrentEventBits & uxBitsToWaitFor ) != ( EventBits_t ) 0 )\r
{\r
xWaitConditionMet = pdTRUE;\r
}\r
else\r
{\r
- mtBRANCH_TEST_INSTRUCTION();\r
+ mtCOVERAGE_TEST_MARKER();\r
}\r
}\r
else\r
}\r
else\r
{\r
- mtBRANCH_TEST_INSTRUCTION();\r
+ mtCOVERAGE_TEST_MARKER();\r
}\r
}\r
\r
return xWaitConditionMet;\r
}\r
+/*-----------------------------------------------------------*/\r
+\r
+#if ( ( configUSE_TRACE_FACILITY == 1 ) && ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) )\r
+ BaseType_t xEventGroupSetBitsFromISR( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet, BaseType_t *pxHigherPriorityTaskWoken )\r
+ {\r
+ BaseType_t xReturn;\r
+\r
+ traceEVENT_GROUP_SET_BITS_FROM_ISR( xEventGroup, uxBitsToSet );\r
+ xReturn = xTimerPendFunctionCallFromISR( vEventGroupSetBitsCallback, ( void * ) xEventGroup, ( uint32_t ) uxBitsToSet, pxHigherPriorityTaskWoken );\r
+\r
+ return xReturn;\r
+ }\r
+#endif\r
+/*-----------------------------------------------------------*/\r
+\r
+#if (configUSE_TRACE_FACILITY == 1)\r
+ UBaseType_t uxEventGroupGetNumber( void* xEventGroup )\r
+ {\r
+ UBaseType_t xReturn;\r
+ EventGroup_t *pxEventBits = ( EventGroup_t * ) xEventGroup;\r
+\r
+ if( xEventGroup == NULL )\r
+ {\r
+ xReturn = 0;\r
+ }\r
+ else\r
+ {\r
+ xReturn = pxEventBits->uxEventGroupNumber;\r
+ }\r
\r
+ return xReturn;\r
+ }\r
+#endif\r
\r
projects / freertos / blobdiff