text: /*
   * FreeRTOS Kernel V10.4.6
   * Copyright (C) 2021 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
   *
   * SPDX-License-Identifier: MIT
   *
   * Permission is hereby granted, free of charge, to any person obtaining a copy of
   * this software and associated documentation files (the "Software"), to deal in
   * the Software without restriction, including without limitation the rights to
   * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
   * the Software, and to permit persons to whom the Software is furnished to do so,
   * subject to the following conditions:
   *
   * The above copyright notice and this permission notice shall be included in all
   * copies or substantial portions of the Software.
   *
   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
   * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
   * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
   * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
   * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
   *
   * https://www.FreeRTOS.org
   * https://github.com/FreeRTOS
   *
   */
  
  /* Standard includes. */
  #include <stdlib.h>
  
  /* Defining MPU_WRAPPERS_INCLUDED_FROM_API_FILE prevents task.h from redefining
   * all the API functions to use the MPU wrappers.  That should only be done when
   * task.h is included from an application file. */
  #define MPU_WRAPPERS_INCLUDED_FROM_API_FILE
  
  /* FreeRTOS includes. */
  #include "Arduino_FreeRTOS.h"
  #include "task.h"
  #include "timers.h"
  #include "event_groups.h"
  
  /* Lint e961, e750 and e9021 are suppressed as a MISRA exception justified
   * because the MPU ports require MPU_WRAPPERS_INCLUDED_FROM_API_FILE to be defined
   * for the header files above, but not in this file, in order to generate the
   * correct privileged Vs unprivileged linkage and placement. */
  #undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE /*lint !e961 !e750 !e9021 See comment above. */
  
  /* The following bit fields convey control information in a task's event list
   * item value.  It is important they don't clash with the
   * taskEVENT_LIST_ITEM_VALUE_IN_USE definition. */
  #if configUSE_16_BIT_TICKS == 1
      #define eventCLEAR_EVENTS_ON_EXIT_BIT    0x0100U
      #define eventUNBLOCKED_DUE_TO_BIT_SET    0x0200U
      #define eventWAIT_FOR_ALL_BITS           0x0400U
      #define eventEVENT_BITS_CONTROL_BYTES    0xff00U
  #else
      #define eventCLEAR_EVENTS_ON_EXIT_BIT    0x01000000UL
      #define eventUNBLOCKED_DUE_TO_BIT_SET    0x02000000UL
      #define eventWAIT_FOR_ALL_BITS           0x04000000UL
      #define eventEVENT_BITS_CONTROL_BYTES    0xff000000UL
  #endif
  
  typedef struct EventGroupDef_t
  {
      EventBits_t uxEventBits;
      List_t xTasksWaitingForBits; /*< List of tasks waiting for a bit to be set. */
  
      #if ( configUSE_TRACE_FACILITY == 1 )
          UBaseType_t uxEventGroupNumber;
      #endif
  
      #if ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
          uint8_t ucStaticallyAllocated; /*< Set to pdTRUE if the event group is statically allocated to ensure no attempt is made to free the memory. */
      #endif
  } EventGroup_t;
  
  /*-----------------------------------------------------------*/
  
  /*
   * Test the bits set in uxCurrentEventBits to see if the wait condition is met.
   * The wait condition is defined by xWaitForAllBits.  If xWaitForAllBits is
   * pdTRUE then the wait condition is met if all the bits set in uxBitsToWaitFor
   * are also set in uxCurrentEventBits.  If xWaitForAllBits is pdFALSE then the
   * wait condition is met if any of the bits set in uxBitsToWait for are also set
   * in uxCurrentEventBits.
   */
  static BaseType_t prvTestWaitCondition( const EventBits_t uxCurrentEventBits,
                                          const EventBits_t uxBitsToWaitFor,
                                          const BaseType_t xWaitForAllBits ) PRIVILEGED_FUNCTION;
  
  /*-----------------------------------------------------------*/
  
  #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
  
      EventGroupHandle_t xEventGroupCreateStatic( StaticEventGroup_t * pxEventGroupBuffer )
      {
          EventGroup_t * pxEventBits;
  
          /* A StaticEventGroup_t object must be provided. */
          configASSERT( pxEventGroupBuffer );
  
          #if ( configASSERT_DEFINED == 1 )
              {
                  /* Sanity check that the size of the structure used to declare a
                   * variable of type StaticEventGroup_t equals the size of the real
                   * event group structure. */
                  volatile size_t xSize = sizeof( StaticEventGroup_t );
                  configASSERT( xSize == sizeof( EventGroup_t ) );
              } /*lint !e529 xSize is referenced if configASSERT() is defined. */
          #endif /* configASSERT_DEFINED */
  
          /* The user has provided a statically allocated event group - use it. */
          pxEventBits = ( EventGroup_t * ) pxEventGroupBuffer; /*lint !e740 !e9087 EventGroup_t and StaticEventGroup_t are deliberately aliased for data hiding purposes and guaranteed to have the same size and alignment requirement - checked by configASSERT(). */
  
          if( pxEventBits != NULL )
          {
              pxEventBits->uxEventBits = 0;
              vListInitialise( &( pxEventBits->xTasksWaitingForBits ) );
  
              #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
                  {
                      /* Both static and dynamic allocation can be used, so note that
                       * this event group was created statically in case the event group
                       * is later deleted. */
                      pxEventBits->ucStaticallyAllocated = pdTRUE;
                  }
              #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
  
              traceEVENT_GROUP_CREATE( pxEventBits );
          }
          else
          {
              /* xEventGroupCreateStatic should only ever be called with
               * pxEventGroupBuffer pointing to a pre-allocated (compile time
               * allocated) StaticEventGroup_t variable. */
              traceEVENT_GROUP_CREATE_FAILED();
          }
  
          return pxEventBits;
      }
  
  #endif /* configSUPPORT_STATIC_ALLOCATION */
  /*-----------------------------------------------------------*/
  
  #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
  
      EventGroupHandle_t xEventGroupCreate( void )
      {
          EventGroup_t * pxEventBits;
  
          /* Allocate the event group.  Justification for MISRA deviation as
           * follows:  pvPortMalloc() always ensures returned memory blocks are
           * aligned per the requirements of the MCU stack.  In this case
           * pvPortMalloc() must return a pointer that is guaranteed to meet the
           * alignment requirements of the EventGroup_t structure - which (if you
           * follow it through) is the alignment requirements of the TickType_t type
           * (EventBits_t being of TickType_t itself).  Therefore, whenever the
           * stack alignment requirements are greater than or equal to the
           * TickType_t alignment requirements the cast is safe.  In other cases,
           * where the natural word size of the architecture is less than
           * sizeof( TickType_t ), the TickType_t variables will be accessed in two
           * or more reads operations, and the alignment requirements is only that
           * of each individual read. */
          pxEventBits = ( EventGroup_t * ) pvPortMalloc( sizeof( EventGroup_t ) ); /*lint !e9087 !e9079 see comment above. */
  
          if( pxEventBits != NULL )
          {
              pxEventBits->uxEventBits = 0;
              vListInitialise( &( pxEventBits->xTasksWaitingForBits ) );
  
              #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
                  {
                      /* Both static and dynamic allocation can be used, so note this
                       * event group was allocated statically in case the event group is
                       * later deleted. */
                      pxEventBits->ucStaticallyAllocated = pdFALSE;
                  }
              #endif /* configSUPPORT_STATIC_ALLOCATION */
  
              traceEVENT_GROUP_CREATE( pxEventBits );
          }
          else
          {
              traceEVENT_GROUP_CREATE_FAILED(); /*lint !e9063 Else branch only exists to allow tracing and does not generate code if trace macros are not defined. */
          }
  
          return pxEventBits;
      }
  
  #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
  /*-----------------------------------------------------------*/
  
  EventBits_t xEventGroupSync( EventGroupHandle_t xEventGroup,
                               const EventBits_t uxBitsToSet,
                               const EventBits_t uxBitsToWaitFor,
                               TickType_t xTicksToWait )
  {
      EventBits_t uxOriginalBitValue, uxReturn;
      EventGroup_t * pxEventBits = xEventGroup;
      BaseType_t xAlreadyYielded;
      BaseType_t xTimeoutOccurred = pdFALSE;
  
      configASSERT( ( uxBitsToWaitFor & eventEVENT_BITS_CONTROL_BYTES ) == 0 );
      configASSERT( uxBitsToWaitFor != 0 );
      #if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
          {
              configASSERT( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) );
          }
      #endif
  
      vTaskSuspendAll();
      {
          uxOriginalBitValue = pxEventBits->uxEventBits;
  
          ( void ) xEventGroupSetBits( xEventGroup, uxBitsToSet );
  
          if( ( ( uxOriginalBitValue | uxBitsToSet ) & uxBitsToWaitFor ) == uxBitsToWaitFor )
          {
              /* All the rendezvous bits are now set - no need to block. */
              uxReturn = ( uxOriginalBitValue | uxBitsToSet );
  
              /* Rendezvous always clear the bits.  They will have been cleared
               * already unless this is the only task in the rendezvous. */
              pxEventBits->uxEventBits &= ~uxBitsToWaitFor;
  
              xTicksToWait = 0;
          }
          else
          {
              if( xTicksToWait != ( TickType_t ) 0 )
              {
                  traceEVENT_GROUP_SYNC_BLOCK( xEventGroup, uxBitsToSet, uxBitsToWaitFor );
  
                  /* Store the bits that the calling task is waiting for in the
                   * task's event list item so the kernel knows when a match is
                   * found.  Then enter the blocked state. */
                  vTaskPlaceOnUnorderedEventList( &( pxEventBits->xTasksWaitingForBits ), ( uxBitsToWaitFor | eventCLEAR_EVENTS_ON_EXIT_BIT | eventWAIT_FOR_ALL_BITS ), xTicksToWait );
  
                  /* This assignment is obsolete as uxReturn will get set after
                   * the task unblocks, but some compilers mistakenly generate a
                   * warning about uxReturn being returned without being set if the
                   * assignment is omitted. */
                  uxReturn = 0;
              }
              else
              {
                  /* The rendezvous bits were not set, but no block time was
                   * specified - just return the current event bit value. */
                  uxReturn = pxEventBits->uxEventBits;
                  xTimeoutOccurred = pdTRUE;
              }
          }
      }
      xAlreadyYielded = xTaskResumeAll();
  
      if( xTicksToWait != ( TickType_t ) 0 )
      {
          if( xAlreadyYielded == pdFALSE )
          {
              portYIELD_WITHIN_API();
          }
          else
          {
              mtCOVERAGE_TEST_MARKER();
          }
  
          /* The task blocked to wait for its required bits to be set - at this
           * point either the required bits were set or the block time expired.  If
           * the required bits were set they will have been stored in the task's
           * event list item, and they should now be retrieved then cleared. */
          uxReturn = uxTaskResetEventItemValue();
  
          if( ( uxReturn & eventUNBLOCKED_DUE_TO_BIT_SET ) == ( EventBits_t ) 0 )
          {
              /* The task timed out, just return the current event bit value. */
              taskENTER_CRITICAL();
              {
                  uxReturn = pxEventBits->uxEventBits;
  
                  /* Although the task got here because it timed out before the
                   * bits it was waiting for were set, it is possible that since it
                   * unblocked another task has set the bits.  If this is the case
                   * then it needs to clear the bits before exiting. */
                  if( ( uxReturn & uxBitsToWaitFor ) == uxBitsToWaitFor )
                  {
                      pxEventBits->uxEventBits &= ~uxBitsToWaitFor;
                  }
                  else
                  {
                      mtCOVERAGE_TEST_MARKER();
                  }
              }
              taskEXIT_CRITICAL();
  
              xTimeoutOccurred = pdTRUE;
          }
          else
          {
              /* The task unblocked because the bits were set. */
          }
  
          /* Control bits might be set as the task had blocked should not be
           * returned. */
          uxReturn &= ~eventEVENT_BITS_CONTROL_BYTES;
      }
  
      traceEVENT_GROUP_SYNC_END( xEventGroup, uxBitsToSet, uxBitsToWaitFor, xTimeoutOccurred );
  
      /* Prevent compiler warnings when trace macros are not used. */
      ( void ) xTimeoutOccurred;
  
      return uxReturn;
  }
  /*-----------------------------------------------------------*/
  
  EventBits_t xEventGroupWaitBits( EventGroupHandle_t xEventGroup,
                                   const EventBits_t uxBitsToWaitFor,
                                   const BaseType_t xClearOnExit,
                                   const BaseType_t xWaitForAllBits,
                                   TickType_t xTicksToWait )
  {
      EventGroup_t * pxEventBits = xEventGroup;
      EventBits_t uxReturn, uxControlBits = 0;
      BaseType_t xWaitConditionMet, xAlreadyYielded;
      BaseType_t xTimeoutOccurred = pdFALSE;
  
      /* Check the user is not attempting to wait on the bits used by the kernel
       * itself, and that at least one bit is being requested. */
      configASSERT( xEventGroup );
      configASSERT( ( uxBitsToWaitFor & eventEVENT_BITS_CONTROL_BYTES ) == 0 );
      configASSERT( uxBitsToWaitFor != 0 );
      #if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
          {
              configASSERT( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) );
          }
      #endif
  
      vTaskSuspendAll();
      {
          const EventBits_t uxCurrentEventBits = pxEventBits->uxEventBits;
  
          /* Check to see if the wait condition is already met or not. */
          xWaitConditionMet = prvTestWaitCondition( uxCurrentEventBits, uxBitsToWaitFor, xWaitForAllBits );
  
          if( xWaitConditionMet != pdFALSE )
          {
              /* The wait condition has already been met so there is no need to
               * block. */
              uxReturn = uxCurrentEventBits;
              xTicksToWait = ( TickType_t ) 0;
  
              /* Clear the wait bits if requested to do so. */
              if( xClearOnExit != pdFALSE )
              {
                  pxEventBits->uxEventBits &= ~uxBitsToWaitFor;
              }
              else
              {
                  mtCOVERAGE_TEST_MARKER();
              }
          }
          else if( xTicksToWait == ( TickType_t ) 0 )
          {
              /* The wait condition has not been met, but no block time was
               * specified, so just return the current value. */
              uxReturn = uxCurrentEventBits;
              xTimeoutOccurred = pdTRUE;
          }
          else
          {
              /* The task is going to block to wait for its required bits to be
               * set.  uxControlBits are used to remember the specified behaviour of
               * this call to xEventGroupWaitBits() - for use when the event bits
               * unblock the task. */
              if( xClearOnExit != pdFALSE )
              {
                  uxControlBits |= eventCLEAR_EVENTS_ON_EXIT_BIT;
              }
              else
              {
                  mtCOVERAGE_TEST_MARKER();
              }
  
              if( xWaitForAllBits != pdFALSE )
              {
                  uxControlBits |= eventWAIT_FOR_ALL_BITS;
              }
              else
              {
                  mtCOVERAGE_TEST_MARKER();
              }
  
              /* Store the bits that the calling task is waiting for in the
               * task's event list item so the kernel knows when a match is
               * found.  Then enter the blocked state. */
              vTaskPlaceOnUnorderedEventList( &( pxEventBits->xTasksWaitingForBits ), ( uxBitsToWaitFor | uxControlBits ), xTicksToWait );
  
              /* This is obsolete as it will get set after the task unblocks, but
               * some compilers mistakenly generate a warning about the variable
               * being returned without being set if it is not done. */
              uxReturn = 0;
  
              traceEVENT_GROUP_WAIT_BITS_BLOCK( xEventGroup, uxBitsToWaitFor );
          }
      }
      xAlreadyYielded = xTaskResumeAll();
  
      if( xTicksToWait != ( TickType_t ) 0 )
      {
          if( xAlreadyYielded == pdFALSE )
          {
              portYIELD_WITHIN_API();
          }
          else
          {
              mtCOVERAGE_TEST_MARKER();
          }
  
          /* The task blocked to wait for its required bits to be set - at this
           * point either the required bits were set or the block time expired.  If
           * the required bits were set they will have been stored in the task's
           * event list item, and they should now be retrieved then cleared. */
          uxReturn = uxTaskResetEventItemValue();
  
          if( ( uxReturn & eventUNBLOCKED_DUE_TO_BIT_SET ) == ( EventBits_t ) 0 )
          {
              taskENTER_CRITICAL();
              {
                  /* The task timed out, just return the current event bit value. */
                  uxReturn = pxEventBits->uxEventBits;
  
                  /* It is possible that the event bits were updated between this
                   * task leaving the Blocked state and running again. */
                  if( prvTestWaitCondition( uxReturn, uxBitsToWaitFor, xWaitForAllBits ) != pdFALSE )
                  {
                      if( xClearOnExit != pdFALSE )
                      {
                          pxEventBits->uxEventBits &= ~uxBitsToWaitFor;
                      }
                      else
                      {
                          mtCOVERAGE_TEST_MARKER();
                      }
                  }
                  else
                  {
                      mtCOVERAGE_TEST_MARKER();
                  }
  
                  xTimeoutOccurred = pdTRUE;
              }
              taskEXIT_CRITICAL();
          }
          else
          {
              /* The task unblocked because the bits were set. */
          }
  
          /* The task blocked so control bits may have been set. */
          uxReturn &= ~eventEVENT_BITS_CONTROL_BYTES;
      }
  
      traceEVENT_GROUP_WAIT_BITS_END( xEventGroup, uxBitsToWaitFor, xTimeoutOccurred );
  
      /* Prevent compiler warnings when trace macros are not used. */
      ( void ) xTimeoutOccurred;
  
      return uxReturn;
  }
  /*-----------------------------------------------------------*/
  
  EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup,
                                    const EventBits_t uxBitsToClear )
  {
      EventGroup_t * pxEventBits = xEventGroup;
      EventBits_t uxReturn;
  
      /* Check the user is not attempting to clear the bits used by the kernel
       * itself. */
      configASSERT( xEventGroup );
      configASSERT( ( uxBitsToClear & eventEVENT_BITS_CONTROL_BYTES ) == 0 );
  
      taskENTER_CRITICAL();
      {
          traceEVENT_GROUP_CLEAR_BITS( xEventGroup, uxBitsToClear );
  
          /* The value returned is the event group value prior to the bits being
           * cleared. */
          uxReturn = pxEventBits->uxEventBits;
  
          /* Clear the bits. */
          pxEventBits->uxEventBits &= ~uxBitsToClear;
      }
      taskEXIT_CRITICAL();
  
      return uxReturn;
  }
  /*-----------------------------------------------------------*/
  
  #if ( ( configUSE_TRACE_FACILITY == 1 ) && ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) )
  
      BaseType_t xEventGroupClearBitsFromISR( EventGroupHandle_t xEventGroup,
                                              const EventBits_t uxBitsToClear )
      {
          BaseType_t xReturn;
  
          traceEVENT_GROUP_CLEAR_BITS_FROM_ISR( xEventGroup, uxBitsToClear );
          xReturn = xTimerPendFunctionCallFromISR( vEventGroupClearBitsCallback, ( void * ) xEventGroup, ( uint32_t ) uxBitsToClear, NULL ); /*lint !e9087 Can't avoid cast to void* as a generic callback function not specific to this use case. Callback casts back to original type so safe. */
  
          return xReturn;
      }
  
  #endif /* if ( ( configUSE_TRACE_FACILITY == 1 ) && ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) ) */
  /*-----------------------------------------------------------*/
  
  EventBits_t xEventGroupGetBitsFromISR( EventGroupHandle_t xEventGroup )
  {
      UBaseType_t uxSavedInterruptStatus;
      EventGroup_t const * const pxEventBits = xEventGroup;
      EventBits_t uxReturn;
  
      uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
      {
          uxReturn = pxEventBits->uxEventBits;
      }
      portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );
  
      return uxReturn;
  } /*lint !e818 EventGroupHandle_t is a typedef used in other functions to so can't be pointer to const. */
  /*-----------------------------------------------------------*/
  
  EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup,
                                  const EventBits_t uxBitsToSet )
  {
      ListItem_t * pxListItem, * pxNext;
      ListItem_t const * pxListEnd;
      List_t const * pxList;
      EventBits_t uxBitsToClear = 0, uxBitsWaitedFor, uxControlBits;
      EventGroup_t * pxEventBits = xEventGroup;
      BaseType_t xMatchFound = pdFALSE;
  
      /* Check the user is not attempting to set the bits used by the kernel
       * itself. */
      configASSERT( xEventGroup );
      configASSERT( ( uxBitsToSet & eventEVENT_BITS_CONTROL_BYTES ) == 0 );
  
      pxList = &( pxEventBits->xTasksWaitingForBits );
      pxListEnd = listGET_END_MARKER( pxList ); /*lint !e826 !e740 !e9087 The mini list structure is used as the list end to save RAM.  This is checked and valid. */
      vTaskSuspendAll();
      {
          traceEVENT_GROUP_SET_BITS( xEventGroup, uxBitsToSet );
  
          pxListItem = listGET_HEAD_ENTRY( pxList );
  
          /* Set the bits. */
          pxEventBits->uxEventBits |= uxBitsToSet;
  
          /* See if the new bit value should unblock any tasks. */
          while( pxListItem != pxListEnd )
          {
              pxNext = listGET_NEXT( pxListItem );
              uxBitsWaitedFor = listGET_LIST_ITEM_VALUE( pxListItem );
              xMatchFound = pdFALSE;
  
              /* Split the bits waited for from the control bits. */
              uxControlBits = uxBitsWaitedFor & eventEVENT_BITS_CONTROL_BYTES;
              uxBitsWaitedFor &= ~eventEVENT_BITS_CONTROL_BYTES;
  
              if( ( uxControlBits & eventWAIT_FOR_ALL_BITS ) == ( EventBits_t ) 0 )
              {
                  /* Just looking for single bit being set. */
                  if( ( uxBitsWaitedFor & pxEventBits->uxEventBits ) != ( EventBits_t ) 0 )
                  {
                      xMatchFound = pdTRUE;
                  }
                  else
                  {
                      mtCOVERAGE_TEST_MARKER();
                  }
              }
              else if( ( uxBitsWaitedFor & pxEventBits->uxEventBits ) == uxBitsWaitedFor )
              {
                  /* All bits are set. */
                  xMatchFound = pdTRUE;
              }
              else
              {
                  /* Need all bits to be set, but not all the bits were set. */
              }
  
              if( xMatchFound != pdFALSE )
              {
                  /* The bits match.  Should the bits be cleared on exit? */
                  if( ( uxControlBits & eventCLEAR_EVENTS_ON_EXIT_BIT ) != ( EventBits_t ) 0 )
                  {
                      uxBitsToClear |= uxBitsWaitedFor;
                  }
                  else
                  {
                      mtCOVERAGE_TEST_MARKER();
                  }
  
                  /* Store the actual event flag value in the task's event list
                   * item before removing the task from the event list.  The
                   * eventUNBLOCKED_DUE_TO_BIT_SET bit is set so the task knows
                   * that is was unblocked due to its required bits matching, rather
                   * than because it timed out. */
                  vTaskRemoveFromUnorderedEventList( pxListItem, pxEventBits->uxEventBits | eventUNBLOCKED_DUE_TO_BIT_SET );
              }
  
              /* Move onto the next list item.  Note pxListItem->pxNext is not
               * used here as the list item may have been removed from the event list
               * and inserted into the ready/pending reading list. */
              pxListItem = pxNext;
          }
  
          /* Clear any bits that matched when the eventCLEAR_EVENTS_ON_EXIT_BIT
           * bit was set in the control word. */
          pxEventBits->uxEventBits &= ~uxBitsToClear;
      }
      ( void ) xTaskResumeAll();
  
      return pxEventBits->uxEventBits;
  }
  /*-----------------------------------------------------------*/
  
  void vEventGroupDelete( EventGroupHandle_t xEventGroup )
  {
      EventGroup_t * pxEventBits = xEventGroup;
      const List_t * pxTasksWaitingForBits;
  
      configASSERT( pxEventBits );
  
      pxTasksWaitingForBits = &( pxEventBits->xTasksWaitingForBits );
  
      vTaskSuspendAll();
      {
          traceEVENT_GROUP_DELETE( xEventGroup );
  
          while( listCURRENT_LIST_LENGTH( pxTasksWaitingForBits ) > ( UBaseType_t ) 0 )
          {
              /* Unblock the task, returning 0 as the event list is being deleted
               * and cannot therefore have any bits set. */
              configASSERT( pxTasksWaitingForBits->xListEnd.pxNext != ( const ListItem_t * ) &( pxTasksWaitingForBits->xListEnd ) );
              vTaskRemoveFromUnorderedEventList( pxTasksWaitingForBits->xListEnd.pxNext, eventUNBLOCKED_DUE_TO_BIT_SET );
          }
  
          #if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 0 ) )
              {
                  /* The event group can only have been allocated dynamically - free
                   * it again. */
                  vPortFree( pxEventBits );
              }
          #elif ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
              {
                  /* The event group could have been allocated statically or
                   * dynamically, so check before attempting to free the memory. */
                  if( pxEventBits->ucStaticallyAllocated == ( uint8_t ) pdFALSE )
                  {
                      vPortFree( pxEventBits );
                  }
                  else
                  {
                      mtCOVERAGE_TEST_MARKER();
                  }
              }
          #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
      }
      ( void ) xTaskResumeAll();
  }
  /*-----------------------------------------------------------*/
  
  /* For internal use only - execute a 'set bits' command that was pended from
   * an interrupt. */
  void vEventGroupSetBitsCallback( void * pvEventGroup,
                                   const uint32_t ulBitsToSet )
  {
      ( void ) xEventGroupSetBits( pvEventGroup, ( EventBits_t ) ulBitsToSet ); /*lint !e9079 Can't avoid cast to void* as a generic timer callback prototype. Callback casts back to original type so safe. */
  }
  /*-----------------------------------------------------------*/
  
  /* For internal use only - execute a 'clear bits' command that was pended from
   * an interrupt. */
  void vEventGroupClearBitsCallback( void * pvEventGroup,
                                     const uint32_t ulBitsToClear )
  {
      ( void ) xEventGroupClearBits( pvEventGroup, ( EventBits_t ) ulBitsToClear ); /*lint !e9079 Can't avoid cast to void* as a generic timer callback prototype. Callback casts back to original type so safe. */
  }
  /*-----------------------------------------------------------*/
  
  static BaseType_t prvTestWaitCondition( const EventBits_t uxCurrentEventBits,
                                          const EventBits_t uxBitsToWaitFor,
                                          const BaseType_t xWaitForAllBits )
  {
      BaseType_t xWaitConditionMet = pdFALSE;
  
      if( xWaitForAllBits == pdFALSE )
      {
          /* Task only has to wait for one bit within uxBitsToWaitFor to be
           * set.  Is one already set? */
          if( ( uxCurrentEventBits & uxBitsToWaitFor ) != ( EventBits_t ) 0 )
          {
              xWaitConditionMet = pdTRUE;
          }
          else
          {
              mtCOVERAGE_TEST_MARKER();
          }
      }
      else
      {
          /* Task has to wait for all the bits in uxBitsToWaitFor to be set.
           * Are they set already? */
          if( ( uxCurrentEventBits & uxBitsToWaitFor ) == uxBitsToWaitFor )
          {
              xWaitConditionMet = pdTRUE;
          }
          else
          {
              mtCOVERAGE_TEST_MARKER();
          }
      }
  
      return xWaitConditionMet;
  }
  /*-----------------------------------------------------------*/
  
  #if ( ( configUSE_TRACE_FACILITY == 1 ) && ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) )
  
      BaseType_t xEventGroupSetBitsFromISR( EventGroupHandle_t xEventGroup,
                                            const EventBits_t uxBitsToSet,
                                            BaseType_t * pxHigherPriorityTaskWoken )
      {
          BaseType_t xReturn;
  
          traceEVENT_GROUP_SET_BITS_FROM_ISR( xEventGroup, uxBitsToSet );
          xReturn = xTimerPendFunctionCallFromISR( vEventGroupSetBitsCallback, ( void * ) xEventGroup, ( uint32_t ) uxBitsToSet, pxHigherPriorityTaskWoken ); /*lint !e9087 Can't avoid cast to void* as a generic callback function not specific to this use case. Callback casts back to original type so safe. */
  
          return xReturn;
      }
  
  #endif /* if ( ( configUSE_TRACE_FACILITY == 1 ) && ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) ) */
  /*-----------------------------------------------------------*/
  
  #if ( configUSE_TRACE_FACILITY == 1 )
  
      UBaseType_t uxEventGroupGetNumber( void * xEventGroup )
      {
          UBaseType_t xReturn;
          EventGroup_t const * pxEventBits = ( EventGroup_t * ) xEventGroup; /*lint !e9087 !e9079 EventGroupHandle_t is a pointer to an EventGroup_t, but EventGroupHandle_t is kept opaque outside of this file for data hiding purposes. */
  
          if( xEventGroup == NULL )
          {
              xReturn = 0;
          }
          else
          {
              xReturn = pxEventBits->uxEventGroupNumber;
          }
  
          return xReturn;
      }
  
  #endif /* configUSE_TRACE_FACILITY */
  /*-----------------------------------------------------------*/
  
  #if ( configUSE_TRACE_FACILITY == 1 )
  
      void vEventGroupSetNumber( void * xEventGroup,
                                 UBaseType_t uxEventGroupNumber )
      {
          ( ( EventGroup_t * ) xEventGroup )->uxEventGroupNumber = uxEventGroupNumber; /*lint !e9087 !e9079 EventGroupHandle_t is a pointer to an EventGroup_t, but EventGroupHandle_t is kept opaque outside of this file for data hiding purposes. */
      }
  
  #endif /* configUSE_TRACE_FACILITY */
  /*-----------------------------------------------------------*/
  