2 FreeRTOS V7.6.0 - Copyright (C) 2013 Real Time Engineers Ltd.
\r
5 VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
\r
7 ***************************************************************************
\r
9 * FreeRTOS provides completely free yet professionally developed, *
\r
10 * robust, strictly quality controlled, supported, and cross *
\r
11 * platform software that has become a de facto standard. *
\r
13 * Help yourself get started quickly and support the FreeRTOS *
\r
14 * project by purchasing a FreeRTOS tutorial book, reference *
\r
15 * manual, or both from: http://www.FreeRTOS.org/Documentation *
\r
19 ***************************************************************************
\r
21 This file is part of the FreeRTOS distribution.
\r
23 FreeRTOS is free software; you can redistribute it and/or modify it under
\r
24 the terms of the GNU General Public License (version 2) as published by the
\r
25 Free Software Foundation >>!AND MODIFIED BY!<< the FreeRTOS exception.
\r
27 >>! NOTE: The modification to the GPL is included to allow you to distribute
\r
28 >>! a combined work that includes FreeRTOS without being obliged to provide
\r
29 >>! the source code for proprietary components outside of the FreeRTOS
\r
32 FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY
\r
33 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
\r
34 FOR A PARTICULAR PURPOSE. Full license text is available from the following
\r
35 link: http://www.freertos.org/a00114.html
\r
39 ***************************************************************************
\r
41 * Having a problem? Start by reading the FAQ "My application does *
\r
42 * not run, what could be wrong?" *
\r
44 * http://www.FreeRTOS.org/FAQHelp.html *
\r
46 ***************************************************************************
\r
48 http://www.FreeRTOS.org - Documentation, books, training, latest versions,
\r
49 license and Real Time Engineers Ltd. contact details.
\r
51 http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,
\r
52 including FreeRTOS+Trace - an indispensable productivity tool, a DOS
\r
53 compatible FAT file system, and our tiny thread aware UDP/IP stack.
\r
55 http://www.OpenRTOS.com - Real Time Engineers ltd license FreeRTOS to High
\r
56 Integrity Systems to sell under the OpenRTOS brand. Low cost OpenRTOS
\r
57 licenses offer ticketed support, indemnification and middleware.
\r
59 http://www.SafeRTOS.com - High Integrity Systems also provide a safety
\r
60 engineered and independently SIL3 certified version for use in safety and
\r
61 mission critical applications that require provable dependability.
\r
66 /* Standard includes. */
\r
69 /* Defining MPU_WRAPPERS_INCLUDED_FROM_API_FILE prevents task.h from redefining
\r
70 all the API functions to use the MPU wrappers. That should only be done when
\r
71 task.h is included from an application file. */
\r
72 #define MPU_WRAPPERS_INCLUDED_FROM_API_FILE
\r
74 /* FreeRTOS includes. */
\r
75 #include "FreeRTOS.h"
\r
78 #include "event_groups.h"
\r
80 /* Lint e961 and e750 are suppressed as a MISRA exception justified because the
\r
81 MPU ports require MPU_WRAPPERS_INCLUDED_FROM_API_FILE to be defined for the
\r
82 header files above, but not in this file, in order to generate the correct
\r
83 privileged Vs unprivileged linkage and placement. */
\r
84 #undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE /*lint !e961 !e750. */
\r
86 #if ( INCLUDE_xEventGroupSetBitFromISR == 1 ) && ( configUSE_TIMERS == 0 )
\r
87 #error configUSE_TIMERS must be set to 1 to make the xEventGroupSetBitFromISR() function available.
\r
90 #if ( INCLUDE_xEventGroupSetBitFromISR == 1 ) && ( INCLUDE_xTimerPendCallbackFromISR == 0 )
\r
91 #error INCLUDE_xTimerPendCallbackFromISR must also be set to one to make the xEventGroupSetBitFromISR() function available.
\r
94 /* The following bit fields convey control information in a task's event list
\r
95 item value. It is important they don't clash with the
\r
96 taskEVENT_LIST_ITEM_VALUE_IN_USE definition. */
\r
97 #if configUSE_16_BIT_TICKS == 1
\r
98 #define eventCLEAR_EVENTS_ON_EXIT_BIT 0x0100U
\r
99 #define eventUNBLOCKED_DUE_TO_BIT_SET 0x0200U
\r
100 #define eventWAIT_FOR_ALL_BITS 0x0400U
\r
101 #define eventEVENT_BITS_CONTROL_BYTES 0xff00U
\r
103 #define eventCLEAR_EVENTS_ON_EXIT_BIT 0x01000000UL
\r
104 #define eventUNBLOCKED_DUE_TO_BIT_SET 0x02000000UL
\r
105 #define eventWAIT_FOR_ALL_BITS 0x04000000UL
\r
106 #define eventEVENT_BITS_CONTROL_BYTES 0xff000000UL
\r
109 typedef struct EventBitsDefinition
\r
111 xEventBitsType uxEventBits;
\r
112 xList xTasksWaitingForBits; /*< List of tasks waiting for a bit to be set. */
\r
115 /* Used internally only. */
\r
116 typedef struct EVENT_GROUP_CALLBACK_PARAMTERS
\r
118 xEventGroupHandle xTargetEventGroup;
\r
119 xEventBitsType xBitsToSet;
\r
120 } xEventGroupCallbackParameters;
\r
122 /*-----------------------------------------------------------*/
\r
125 * Test the bits set in uxCurrentEventBits to see if the wait condition is met.
\r
126 * The wait condition is defined by xWaitForAllBits. If xWaitForAllBits is
\r
127 * pdTRUE then the wait condition is met if all the bits set in uxBitsToWaitFor
\r
128 * are also set in uxCurrentEventBits. If xWaitForAllBits is pdFALSE then the
\r
129 * wait condition is met if any of the bits set in uxBitsToWait for are also set
\r
130 * in uxCurrentEventBits.
\r
132 static portBASE_TYPE prvTestWaitCondition( const xEventBitsType uxCurrentEventBits, const xEventBitsType uxBitsToWaitFor, const portBASE_TYPE xWaitForAllBits );
\r
134 /*-----------------------------------------------------------*/
\r
136 xEventGroupHandle xEventGroupCreate( void )
\r
138 xEVENT_BITS *pxEventBits;
\r
140 pxEventBits = pvPortMalloc( sizeof( xEVENT_BITS ) );
\r
141 if( pxEventBits != NULL )
\r
143 pxEventBits->uxEventBits = 0;
\r
144 vListInitialise( &( pxEventBits->xTasksWaitingForBits ) );
\r
145 traceEVENT_GROUP_CREATE( pxEventBits );
\r
149 traceEVENT_GROUP_CREATE_FAILED();
\r
152 return ( xEventGroupHandle ) pxEventBits;
\r
154 /*-----------------------------------------------------------*/
\r
156 xEventBitsType xEventGroupSync( xEventGroupHandle xEventGroup, const xEventBitsType uxBitsToSet, const xEventBitsType uxBitsToWaitFor, portTickType xTicksToWait )
\r
158 xEventBitsType uxOriginalBitValue, uxReturn;
\r
159 xEVENT_BITS *pxEventBits = ( xEVENT_BITS * ) xEventGroup;
\r
160 portBASE_TYPE xAlreadyYielded;
\r
162 configASSERT( ( uxBitsToWaitFor & eventEVENT_BITS_CONTROL_BYTES ) == 0 );
\r
163 configASSERT( uxBitsToWaitFor != 0 );
\r
164 #if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
\r
166 configASSERT( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) );
\r
172 traceEVENT_GROUP_SYNC_START( xEventGroup, uxBitsToSet );
\r
174 uxOriginalBitValue = pxEventBits->uxEventBits;
\r
176 ( void ) xEventGroupSetBits( xEventGroup, uxBitsToSet );
\r
178 if( ( ( uxOriginalBitValue | uxBitsToSet ) & uxBitsToWaitFor ) == uxBitsToWaitFor )
\r
180 /* All the rendezvous bits are now set - no need to block. */
\r
181 uxReturn = ( uxOriginalBitValue | uxBitsToSet );
\r
183 /* Rendezvous always clear the bits. They will have been cleared
\r
184 already unless this is the only task in the rendezvous. */
\r
185 pxEventBits->uxEventBits &= uxBitsToWaitFor;
\r
191 if( xTicksToWait != ( portTickType ) 0 )
\r
193 /* Store the bits that the calling task is waiting for in the
\r
194 task's event list item so the kernel knows when a match is
\r
195 found. Then enter the blocked state. */
\r
196 vTaskPlaceOnUnorderedEventList( &( pxEventBits->xTasksWaitingForBits ), ( uxBitsToWaitFor | eventCLEAR_EVENTS_ON_EXIT_BIT | eventWAIT_FOR_ALL_BITS ), xTicksToWait );
\r
198 /* This assignment is obsolete as uxReturn will get set after
\r
199 the task unblocks, but some compilers mistakenly generate a
\r
200 warning about uxReturn being returned without being set if the
\r
201 assignment is omitted. */
\r
206 /* The rendezvous bits were not set, but no block time was
\r
207 specified - just return the current event bit value. */
\r
208 uxReturn = pxEventBits->uxEventBits;
\r
212 xAlreadyYielded = xTaskResumeAll();
\r
214 if( xTicksToWait != ( portTickType ) 0 )
\r
216 if( xAlreadyYielded == pdFALSE )
\r
218 portYIELD_WITHIN_API();
\r
222 mtBRANCH_TEST_INSTRUCTION();
\r
225 /* The task blocked to wait for its required bits to be set - at this
\r
226 point either the required bits were set or the block time expired. If
\r
227 the required bits were set they will have been stored in the task's
\r
228 event list item, and they should now be retrieved then cleared. */
\r
229 uxReturn = uxTaskResetEventItemValue();
\r
231 if( ( uxReturn & eventUNBLOCKED_DUE_TO_BIT_SET ) == ( xEventBitsType ) 0 )
\r
233 /* The task timed out, just return the current event bit value. */
\r
234 taskENTER_CRITICAL();
\r
236 uxReturn = pxEventBits->uxEventBits;
\r
238 /* Although the task got here because it timed out before the
\r
239 bits it was waiting for were set, it is possible that since it
\r
240 unblocked another task has set the bits. If this is the case
\r
241 then it may be required to clear the bits before exiting. */
\r
242 if( ( uxReturn & uxBitsToWaitFor ) == uxBitsToWaitFor )
\r
244 pxEventBits->uxEventBits &= ~uxBitsToWaitFor;
\r
248 mtBRANCH_TEST_INSTRUCTION();
\r
251 taskEXIT_CRITICAL();
\r
255 /* The task unblocked because the bits were set. Clear the control
\r
256 bits before returning the value. */
\r
257 uxReturn &= ~eventEVENT_BITS_CONTROL_BYTES;
\r
261 traceEVENT_GROUP_SYNC_END( xEventGroup, uxReturn );
\r
264 /*-----------------------------------------------------------*/
\r
266 xEventBitsType xEventGroupWaitBits( xEventGroupHandle xEventGroup, const xEventBitsType uxBitsToWaitFor, const portBASE_TYPE xClearOnExit, const portBASE_TYPE xWaitForAllBits, portTickType xTicksToWait )
\r
268 xEVENT_BITS *pxEventBits = ( xEVENT_BITS * ) xEventGroup;
\r
269 xEventBitsType uxReturn, uxControlBits = 0;
\r
270 portBASE_TYPE xWaitConditionMet, xAlreadyYielded;
\r
272 /* Check the user is not attempting to wait on the bits used by the kernel
\r
273 itself, and that at least one bit is being requested. */
\r
274 configASSERT( ( uxBitsToWaitFor & eventEVENT_BITS_CONTROL_BYTES ) == 0 );
\r
275 configASSERT( uxBitsToWaitFor != 0 );
\r
276 #if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
\r
278 configASSERT( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) );
\r
284 const xEventBitsType uxCurrentEventBits = pxEventBits->uxEventBits;
\r
286 traceEVENT_GROUP_WAIT_BITS_START( xEventGroup, uxBitsToWaitFor );
\r
288 /* Check to see if the wait condition is already met or not. */
\r
289 xWaitConditionMet = prvTestWaitCondition( uxCurrentEventBits, uxBitsToWaitFor, xWaitForAllBits );
\r
291 if( xWaitConditionMet != pdFALSE )
\r
293 /* The wait condition has already been met so there is no need to
\r
295 uxReturn = uxCurrentEventBits;
\r
296 xTicksToWait = ( portTickType ) 0;
\r
298 /* Clear the wait bits if requested to do so. */
\r
299 if( xClearOnExit != pdFALSE )
\r
301 pxEventBits->uxEventBits &= ~uxBitsToWaitFor;
\r
305 mtBRANCH_TEST_INSTRUCTION();
\r
308 else if( xTicksToWait == ( portTickType ) 0 )
\r
310 /* The wait condition has not been met, but no block time was
\r
311 specified, so just return the current value. */
\r
312 uxReturn = uxCurrentEventBits;
\r
316 /* The task is going to block to wait for its required bits to be
\r
317 set. uxControlBits are used to remember the specified behaviour of
\r
318 this call to xEventGroupWaitBits() - for use when the event bits
\r
319 unblock the task. */
\r
320 if( xClearOnExit != pdFALSE )
\r
322 uxControlBits |= eventCLEAR_EVENTS_ON_EXIT_BIT;
\r
326 mtBRANCH_TEST_INSTRUCTION();
\r
329 if( xWaitForAllBits != pdFALSE )
\r
331 uxControlBits |= eventWAIT_FOR_ALL_BITS;
\r
335 mtBRANCH_TEST_INSTRUCTION();
\r
338 /* Store the bits that the calling task is waiting for in the
\r
339 task's event list item so the kernel knows when a match is
\r
340 found. Then enter the blocked state. */
\r
341 vTaskPlaceOnUnorderedEventList( &( pxEventBits->xTasksWaitingForBits ), ( uxBitsToWaitFor | uxControlBits ), xTicksToWait );
\r
343 /* This is obsolete as it will get set after the task unblocks, but
\r
344 some compilers mistakenly generate a warning about the variable
\r
345 being returned without being set if it is not done. */
\r
349 xAlreadyYielded = xTaskResumeAll();
\r
351 if( xTicksToWait != ( portTickType ) 0 )
\r
353 if( xAlreadyYielded == pdFALSE )
\r
355 portYIELD_WITHIN_API();
\r
359 mtBRANCH_TEST_INSTRUCTION();
\r
362 /* The task blocked to wait for its required bits to be set - at this
\r
363 point either the required bits were set or the block time expired. If
\r
364 the required bits were set they will have been stored in the task's
\r
365 event list item, and they should now be retrieved then cleared. */
\r
366 uxReturn = uxTaskResetEventItemValue();
\r
368 if( ( uxReturn & eventUNBLOCKED_DUE_TO_BIT_SET ) == ( xEventBitsType ) 0 )
\r
370 taskENTER_CRITICAL();
\r
372 /* The task timed out, just return the current event bit value. */
\r
373 uxReturn = pxEventBits->uxEventBits;
\r
375 /* It is possible that the event bits were updated between this
\r
376 task leaving the Blocked state and running again. */
\r
377 if( prvTestWaitCondition( uxReturn, uxBitsToWaitFor, xWaitForAllBits ) != pdFALSE )
\r
379 if( xClearOnExit != pdFALSE )
\r
381 pxEventBits->uxEventBits &= ~uxBitsToWaitFor;
\r
385 mtBRANCH_TEST_INSTRUCTION();
\r
390 mtBRANCH_TEST_INSTRUCTION();
\r
393 taskEXIT_CRITICAL();
\r
397 /* The task unblocked because the bits were set. Clear the control
\r
398 bits before returning the value. */
\r
399 uxReturn &= ~eventEVENT_BITS_CONTROL_BYTES;
\r
403 traceEVENT_GROUP_WAIT_BITS_END( xEventGroup, uxReturn );
\r
406 /*-----------------------------------------------------------*/
\r
408 xEventBitsType xEventGroupClearBits( xEventGroupHandle xEventGroup, const xEventBitsType uxBitsToClear )
\r
410 xEVENT_BITS *pxEventBits = ( xEVENT_BITS * ) xEventGroup;
\r
411 xEventBitsType uxReturn;
\r
413 /* Check the user is not attempting to clear the bits used by the kernel
\r
415 configASSERT( ( uxBitsToClear & eventEVENT_BITS_CONTROL_BYTES ) == 0 );
\r
417 taskENTER_CRITICAL();
\r
419 traceEVENT_GROUP_CLEAR_BITS( xEventGroup, uxBitsToClear );
\r
421 /* The value returned is the event group value prior to the bits being
\r
423 uxReturn = pxEventBits->uxEventBits;
\r
425 /* Clear the bits. */
\r
426 pxEventBits->uxEventBits &= ~uxBitsToClear;
\r
428 taskEXIT_CRITICAL();
\r
432 /*-----------------------------------------------------------*/
\r
434 xEventBitsType xEventGroupSetBits( xEventGroupHandle xEventGroup, const xEventBitsType uxBitsToSet )
\r
436 xListItem *pxListItem, *pxNext;
\r
437 xListItem const *pxListEnd;
\r
439 xEventBitsType uxBitsToClear = 0, uxBitsWaitedFor, uxControlBits;
\r
440 xEVENT_BITS *pxEventBits = ( xEVENT_BITS * ) xEventGroup;
\r
441 portBASE_TYPE xMatchFound = pdFALSE;
\r
443 /* Check the user is not attempting to set the bits used by the kernel
\r
445 configASSERT( ( uxBitsToSet & eventEVENT_BITS_CONTROL_BYTES ) == 0 );
\r
447 pxList = &( pxEventBits->xTasksWaitingForBits );
\r
448 pxListEnd = listGET_END_MARKER( pxList ); /*lint !e826 !e740 The mini list structure is used as the list end to save RAM. This is checked and valid. */
\r
451 traceEVENT_GROUP_SET_BITS( xEventGroup, uxBitsToSet );
\r
453 pxListItem = listGET_HEAD_ENTRY( pxList );
\r
455 /* Set the bits. */
\r
456 pxEventBits->uxEventBits |= uxBitsToSet;
\r
458 /* See if the new bit value should unblock any tasks. */
\r
459 while( pxListItem != pxListEnd )
\r
461 pxNext = listGET_NEXT( pxListItem );
\r
462 uxBitsWaitedFor = listGET_LIST_ITEM_VALUE( pxListItem );
\r
463 xMatchFound = pdFALSE;
\r
465 /* Split the bits waited for from the control bits. */
\r
466 uxControlBits = uxBitsWaitedFor & eventEVENT_BITS_CONTROL_BYTES;
\r
467 uxBitsWaitedFor &= ~eventEVENT_BITS_CONTROL_BYTES;
\r
469 if( ( uxControlBits & eventWAIT_FOR_ALL_BITS ) == ( xEventBitsType ) 0 )
\r
471 /* Just looking for single bit being set. */
\r
472 if( ( uxBitsWaitedFor & pxEventBits->uxEventBits ) != ( xEventBitsType ) 0 )
\r
474 xMatchFound = pdTRUE;
\r
478 mtBRANCH_TEST_INSTRUCTION();
\r
481 else if( ( uxBitsWaitedFor & pxEventBits->uxEventBits ) == uxBitsWaitedFor )
\r
483 /* All bits are set. */
\r
484 xMatchFound = pdTRUE;
\r
488 /* Need all bits to be set, but not all the bits were set. */
\r
491 if( xMatchFound != pdFALSE )
\r
493 /* The bits match. Should the bits be cleared on exit? */
\r
494 if( ( uxControlBits & eventCLEAR_EVENTS_ON_EXIT_BIT ) != ( xEventBitsType ) 0 )
\r
496 uxBitsToClear |= uxBitsWaitedFor;
\r
500 mtBRANCH_TEST_INSTRUCTION();
\r
503 /* Store the actual event flag value in the task's event list
\r
504 item before removing the task from the event list. The
\r
505 eventUNBLOCKED_DUE_TO_BIT_SET bit is set so the task knows
\r
506 that is was unblocked due to its required bits matching, rather
\r
507 than because it timed out. */
\r
508 ( void ) xTaskRemoveFromUnorderedEventList( pxListItem, pxEventBits->uxEventBits | eventUNBLOCKED_DUE_TO_BIT_SET );
\r
511 /* Move onto the next list item. Note pxListItem->pxNext is not
\r
512 used here as the list item may have been removed from the event list
\r
513 and inserted into the ready/pending reading list. */
\r
514 pxListItem = pxNext;
\r
517 /* Clear any bits that matched when the eventCLEAR_EVENTS_ON_EXIT_BIT
\r
518 bit was set in the control word. */
\r
519 pxEventBits->uxEventBits &= ~uxBitsToClear;
\r
521 ( void ) xTaskResumeAll();
\r
523 return pxEventBits->uxEventBits;
\r
525 /*-----------------------------------------------------------*/
\r
527 void vEventGroupDelete( xEventGroupHandle xEventGroup )
\r
529 xEVENT_BITS *pxEventBits = ( xEVENT_BITS * ) xEventGroup;
\r
530 const xList *pxTasksWaitingForBits = &( pxEventBits->xTasksWaitingForBits );
\r
534 traceEVENT_GROUP_DELETE( xEventGroup );
\r
536 while( listCURRENT_LIST_LENGTH( pxTasksWaitingForBits ) > ( unsigned portBASE_TYPE ) 0 )
\r
538 /* Unblock the task, returning 0 as the event list is being deleted
\r
539 and cannot therefore have any bits set. */
\r
540 configASSERT( pxTasksWaitingForBits->xListEnd.pxNext != ( xListItem * ) &( pxTasksWaitingForBits->xListEnd ) );
\r
541 ( void ) xTaskRemoveFromUnorderedEventList( pxTasksWaitingForBits->xListEnd.pxNext, ( portTickType ) eventUNBLOCKED_DUE_TO_BIT_SET );
\r
544 vPortFree( pxEventBits );
\r
546 ( void ) xTaskResumeAll();
\r
548 /*-----------------------------------------------------------*/
\r
550 /* For internal use only - execute a 'set bits' command that was pended from
\r
552 void vEventGroupSetBitsCallback( void *pvEventGroup, const unsigned long ulBitsToSet )
\r
554 ( void ) xEventGroupSetBits( pvEventGroup, ( xEventBitsType ) ulBitsToSet );
\r
556 /*-----------------------------------------------------------*/
\r
558 static portBASE_TYPE prvTestWaitCondition( const xEventBitsType uxCurrentEventBits, const xEventBitsType uxBitsToWaitFor, const portBASE_TYPE xWaitForAllBits )
\r
560 portBASE_TYPE xWaitConditionMet = pdFALSE;
\r
562 if( xWaitForAllBits == pdFALSE )
\r
564 /* Task only has to wait for one bit within uxBitsToWaitFor to be
\r
565 set. Is one already set? */
\r
566 if( ( uxCurrentEventBits & uxBitsToWaitFor ) != ( xEventBitsType ) 0 )
\r
568 xWaitConditionMet = pdTRUE;
\r
572 mtBRANCH_TEST_INSTRUCTION();
\r
577 /* Task has to wait for all the bits in uxBitsToWaitFor to be set.
\r
578 Are they set already? */
\r
579 if( ( uxCurrentEventBits & uxBitsToWaitFor ) == uxBitsToWaitFor )
\r
581 xWaitConditionMet = pdTRUE;
\r
585 mtBRANCH_TEST_INSTRUCTION();
\r
589 return xWaitConditionMet;
\r