From 92f4016b20a13b3d8ddb9290b8430d0e0a7cb803 Mon Sep 17 00:00:00 2001 From: Vladimir Umek Date: Wed, 20 Mar 2024 13:56:49 +0100 Subject: [PATCH] Connect traceENTER and traceRETURN trace events to Event Recorder events --- .../FreeRTOS/Config/ARMCM/FreeRTOSConfig.h | 28 +- CMSIS/RTOS2/FreeRTOS/FreeRTOS.scvd | 304 +- CMSIS/RTOS2/FreeRTOS/Include/freertos_evr.h | 3273 ++++++++++++++-- CMSIS/RTOS2/FreeRTOS/Source/freertos_evr.c | 3413 +++++++++++++++-- DoxyGen/src/freertos_evr.txt | 2756 ++++++++++++- 5 files changed, 9040 insertions(+), 734 deletions(-) diff --git a/CMSIS/RTOS2/FreeRTOS/Config/ARMCM/FreeRTOSConfig.h b/CMSIS/RTOS2/FreeRTOS/Config/ARMCM/FreeRTOSConfig.h index 7eb3de4b..e7d6064f 100644 --- a/CMSIS/RTOS2/FreeRTOS/Config/ARMCM/FreeRTOSConfig.h +++ b/CMSIS/RTOS2/FreeRTOS/Config/ARMCM/FreeRTOSConfig.h @@ -186,48 +186,48 @@ // Initialize Event Recorder // Initialize Event Recorder before FreeRTOS kernel start. // Default: 1 -#define configEVR_INITIALIZE 1 +#define configEVR_INITIALIZE 1 // Setup recording level filter // Enable configuration of FreeRTOS events recording level // Default: 1 -#define configEVR_SETUP_LEVEL 1 +#define configEVR_SETUP_LEVEL 1 // Tasks functions // Define event recording level bitmask for events generated from Tasks functions. // Default: 0x05 -// <0x00=>Off <0x01=>Errors <0x05=>Errors + Operation <0x0F=>All -#define configEVR_LEVEL_TASKS 0x05 +// <0x00=>Off <0x01=>Errors <0x03=>Errors + API <0x05=>Errors + Operation <0x07=>Errors + API + Operation <0x0F=>All +#define configEVR_LEVEL_TASKS 0x05 // Queue functions // Define event recording level bitmask for events generated from Queue functions. // Default: 0x05 -// <0x00=>Off <0x01=>Errors <0x05=>Errors + Operation <0x0F=>All -#define configEVR_LEVEL_QUEUE 0x05 +// <0x00=>Off <0x01=>Errors <0x03=>Errors + API <0x05=>Errors + Operation <0x07=>Errors + API + Operation <0x0F=>All +#define configEVR_LEVEL_QUEUE 0x05 // Timer functions // Define event recording level bitmask for events generated from Timer functions. // Default: 0x05 -// <0x00=>Off <0x01=>Errors <0x05=>Errors + Operation <0x0F=>All -#define configEVR_LEVEL_TIMERS 0x05 +// <0x00=>Off <0x01=>Errors <0x03=>Errors + API <0x05=>Errors + Operation <0x07=>Errors + API + Operation <0x0F=>All +#define configEVR_LEVEL_TIMERS 0x05 // Event Groups functions // Define event recording level bitmask for events generated from Event Groups functions. // Default: 0x05 -// <0x00=>Off <0x01=>Errors <0x05=>Errors + Operation <0x0F=>All -#define configEVR_LEVEL_EVENTGROUPS 0x05 +// <0x00=>Off <0x01=>Errors <0x03=>Errors + API <0x05=>Errors + Operation <0x07=>Errors + API + Operation <0x0F=>All +#define configEVR_LEVEL_EVENTGROUPS 0x05 // Heap functions // Define event recording level bitmask for events generated from Heap functions. // Default: 0x05 -// <0x00=>Off <0x01=>Errors <0x05=>Errors + Operation <0x0F=>All -#define configEVR_LEVEL_HEAP 0x05 +// <0x00=>Off <0x01=>Errors <0x03=>Errors + API <0x05=>Errors + Operation <0x07=>Errors + API + Operation <0x0F=>All +#define configEVR_LEVEL_HEAP 0x05 // Stream Buffer functions // Define event recording level bitmask for events generated from Stream Buffer functions. // Default: 0x05 -// <0x00=>Off <0x01=>Errors <0x05=>Errors + Operation <0x0F=>All -#define configEVR_LEVEL_STREAMBUFFER 0x05 +// <0x00=>Off <0x01=>Errors <0x03=>Errors + API <0x05=>Errors + Operation <0x07=>Errors + API + Operation <0x0F=>All +#define configEVR_LEVEL_STREAMBUFFER 0x05 // // diff --git a/CMSIS/RTOS2/FreeRTOS/FreeRTOS.scvd b/CMSIS/RTOS2/FreeRTOS/FreeRTOS.scvd index a6a46600..46562942 100644 --- a/CMSIS/RTOS2/FreeRTOS/FreeRTOS.scvd +++ b/CMSIS/RTOS2/FreeRTOS/FreeRTOS.scvd @@ -1,6 +1,6 @@ - + @@ -178,14 +178,14 @@ - + - + @@ -776,7 +776,200 @@ - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -804,6 +997,7 @@ + @@ -811,22 +1005,102 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - + diff --git a/CMSIS/RTOS2/FreeRTOS/Include/freertos_evr.h b/CMSIS/RTOS2/FreeRTOS/Include/freertos_evr.h index 8aff8a19..42d08915 100644 --- a/CMSIS/RTOS2/FreeRTOS/Include/freertos_evr.h +++ b/CMSIS/RTOS2/FreeRTOS/Include/freertos_evr.h @@ -1,5 +1,5 @@ /* -------------------------------------------------------------------------- - * Copyright (c) 2013-2023 Arm Limited. All rights reserved. + * Copyright (c) 2013-2024 Arm Limited. All rights reserved. * * SPDX-License-Identifier: Apache-2.0 * @@ -23,8 +23,8 @@ #ifndef FREERTOS_EVR_H_ #define FREERTOS_EVR_H_ -#include #include +#include #include "RTE_Components.h" @@ -36,12 +36,38 @@ #endif /* Temporarily define FreeRTOS object types */ -#define TCB_t void* -#define Queue_t void* -#define Timer_t void* -#define PendedFunction_t void* -#define EventGroup_t void* -#define StreamBuffer_t void* +#define TCB_t void* +#define Queue_t void* +#define Timer_t void* +#define PendedFunction_t void* +#define EventGroup_t void* +#define StreamBuffer_t void* + +#define TaskHandle_t void* +#define TimerHandle_t void* +#define ConstTaskHandle_t void* +#define EventGroupHandle_t void* +#define TaskHookFunction_t void* +#define TimerCallbackFunction_t void* + +#define StaticTask_t void +#define StaticTimer_t void +#define StaticEventGroup_t void +#define TaskParameters_t void +#define TaskStatus_t void +#define List_t void +#define ListItem_t void +#define TimeOut_t void +#define MemoryRegion_t void + +#define BaseType_t long +#define UBaseType_t uint32_t +#define eTaskState uint32_t +#define StackType_t uint32_t +#define TickType_t uint32_t +#define EventBits_t uint32_t +#define eSleepModeStatus uint32_t +#define eNotifyAction uint32_t /** \brief Setup Event Recorder configuration @@ -220,492 +246,2867 @@ extern void EvrFreeRTOSTasks_TaskNotifyFromIsr (TCB_t xTaskToNotify, uint32_t ux extern void EvrFreeRTOSTasks_TaskNotifyGiveFromIsr (TCB_t xTaskToNotify, uint32_t uxIndexToWait, uint32_t ulNotifiedValue); /** - \brief Event on successful queue create (Op) - \param[in] pxQueue pointer to mutex object handle. + \brief Event sent before moving a task into the Delayed list (Op) + \param[in] pxTCB pointer to running task handle. */ -extern void EvrFreeRTOSQueue_QueueCreate (Queue_t pxQueue); +extern void EvrFreeRTOSTasks_MovedTaskToDelayedList (TCB_t pxTCB); /** - \brief Event on unsuccessful queue create (Error) - \param[in] ucQueueType queue type + \brief Event sent before moving a task into the Overflow Delayed list (Op) + \param[in] pxTCB pointer to running task handle. */ -extern void EvrFreeRTOSQueue_QueueCreateFailed (uint32_t ucQueueType); +extern void EvrFreeRTOSTasks_MovedTaskToOverflowDelayedList (TCB_t pxTCB); /** - \brief Event on successful mutex create (Op) - \param[in] pxNewQueue pointer to queue object handle. + \brief Event sent when function xTaskCreateStatic is called (API). + \param[in] pxTaskCode pointer to task function. + \param[in] pcName pointer to task name string. + \param[in] ulStackDepth stack depth. + \param[in] pvParameters pointer to parameter(s) passed to task funtion. + \param[in] uxPriority task priority. + \param[in] puxStackBuffer pointer to buffer to be used for task stack. + \param[in] pxTaskBuffer pointer to buffer to be used for task control block. */ -extern void EvrFreeRTOSQueue_CreateMutex (Queue_t pxNewQueue); +extern void EvrFreeRTOSTasks_xTaskCreateStatic (void *pxTaskCode, + const char *pcName, + const uint32_t ulStackDepth, + void *pvParameters, + uint32_t uxPriority, + void *puxStackBuffer, + void *pxTaskBuffer); /** - \brief Event on unsuccessful mutex create (Error) + \brief Event sent before function xTaskCreateStatic returns (Op). + \param[in] xReturn pointer to created task handle. */ -extern void EvrFreeRTOSQueue_CreateMutexFailed (void); +extern void EvrFreeRTOSTasks_xTaskCreateStatic_Return (TCB_t xReturn); /** - \brief Event on successful recursive mutex give (Op) - \param[in] pxMutex pointer to mutex object handle. + \brief Event sent when function xTaskCreateStaticAffinitySet is called (API). + \param[in] pxTaskCode pointer to task function. + \param[in] pcName pointer to task name string. + \param[in] ulStackDepth stack depth. + \param[in] pvParameters pointer to parameter(s) passed to task funtion. + \param[in] uxPriority task priority. + \param[in] puxStackBuffer pointer to buffer to be used for task stack. + \param[in] pxTaskBuffer pointer to buffer to be used for task control block. + \param[in] uxCoreAffinityMask task affinity mask. */ -extern void EvrFreeRTOSQueue_GiveMutexRecursive (Queue_t pxMutex); +extern void EvrFreeRTOSTasks_xTaskCreateStaticAffinitySet (void *pxTaskCode, + const char *pcName, + const uint32_t ulStackDepth, + void *pvParameters, + uint32_t uxPriority, + void *puxStackBuffer, + void *pxTaskBuffer, + uint32_t uxCoreAffinityMask); /** - \brief Event on unsuccessful recursive mutex give (Error) - \param[in] pxMutex pointer to mutex object handle. + \brief Event sent before function xTaskCreateStaticAffinitySet returns (Op). + \param[in] xReturn pointer to created task handle. */ -extern void EvrFreeRTOSQueue_GiveMutexRecursiveFailed (Queue_t pxMutex); +extern void EvrFreeRTOSTasks_xTaskCreateStaticAffinitySet_Return (TCB_t xReturn); /** - \brief Event on successful recursive mutex take (Op) - \param[in] pxMutex pointer to mutex object handle. + \brief Event sent when function xTaskCreateRestrictedStatic is called (API). + \param[in] pxTaskDefinition pointer to parameters required to create an MPU protected task. + \param[in] pxCreatedTask pointer to where the created task handle is stored. */ -extern void EvrFreeRTOSQueue_TakeMutexRecursive (Queue_t pxMutex); +extern void EvrFreeRTOSTasks_xTaskCreateRestrictedStatic (const TaskParameters_t *pxTaskDefinition, TaskHandle_t *pxCreatedTask); /** - \brief Event on unsuccessful recursive mutex take (Error) - \param[in] pxMutex pointer to mutex object handle. + \brief Event sent before function xTaskCreateRestrictedStatic returns (Op). + \param[in] xReturn return status. */ -extern void EvrFreeRTOSQueue_TakeMutexRecursiveFailed (Queue_t pxMutex); +extern void EvrFreeRTOSTasks_xTaskCreateRestrictedStatic_Return (uint32_t xReturn); /** - \brief Event on successful counting semaphore create (Op) - \param[in] xHandle pointer to semaphore object handle. + \brief Event sent when function xTaskCreateRestrictedStaticAffinitySet is called (API). + \param[in] pxTaskDefinition pointer to parameters required to create an MPU protected task. + \param[in] uxCoreAffinityMask affinity mask + \param[in] pxCreatedTask pointer to where the created task handle is stored. */ -extern void EvrFreeRTOSQueue_CreateCountingSemaphore (Queue_t xHandle); +extern void EvrFreeRTOSTasks_xTaskCreateRestrictedStaticAffinitySet (const TaskParameters_t * pxTaskDefinition, UBaseType_t uxCoreAffinityMask, TaskHandle_t *pxCreatedTask); /** - \brief Event on unsuccessful counting semaphore create (Error) + \brief Event sent before function xTaskCreateRestrictedStaticAffinitySet returns (Op). + \param[in] xReturn return status. */ -extern void EvrFreeRTOSQueue_CreateCountingSemaphoreFailed (void); +extern void EvrFreeRTOSTasks_xTaskCreateRestrictedStaticAffinitySet_Return (uint32_t xReturn); /** - \brief Event on queue write (Op) - \param[in] pxQueue pointer to queue object handle. + \brief Event sent when function xTaskCreateRestricted is called (API). + \param[in] pxTaskDefinition pointer to parameters required to create an MPU protected task. + \param[in] pxCreatedTask pointer to where the created task handle is stored. */ -extern void EvrFreeRTOSQueue_QueueSend (Queue_t pxQueue); +extern void EvrFreeRTOSTasks_xTaskCreateRestricted (const TaskParameters_t *pxTaskDefinition, TaskHandle_t *pxCreatedTask); /** - \brief Event on write to the full queue (Error) - \param[in] pxQueue pointer to queue object handle. + \brief Event sent before function xTaskCreateRestricted returns (Op). + \param[in] xReturn return status. */ -extern void EvrFreeRTOSQueue_QueueSendFailed (Queue_t pxQueue); +extern void EvrFreeRTOSTasks_xTaskCreateRestricted_Return (uint32_t xReturn); /** - \brief Event on queue read (Op) - \param[in] pxQueue pointer to queue object handle. + \brief Event sent when function xTaskCreateRestrictedAffinitySet is called (API). + \param[in] pxTaskDefinition pointer to parameters required to create an MPU protected task. + \param[in] uxCoreAffinityMask affinity mask. + \param[in] pxCreatedTask pointer to where the created task handle is stored. */ -extern void EvrFreeRTOSQueue_QueueReceive (Queue_t pxQueue); +extern void EvrFreeRTOSTasks_xTaskCreateRestrictedAffinitySet (TaskParameters_t *pxTaskDefinition, uint32_t uxCoreAffinityMask, /*TCB_t*/void *pxCreatedTask); /** - \brief Event on queue peek (Op) - \param[in] pxQueue pointer to queue object handle. + \brief Event sent before function xTaskCreateRestrictedAffinitySet returns (Op). + \param[in] xReturn return status. */ -extern void EvrFreeRTOSQueue_QueuePeek (Queue_t pxQueue); +extern void EvrFreeRTOSTasks_xTaskCreateRestrictedAffinitySet_Return (uint32_t xReturn); /** - \brief Event on queue peek when queue is empty and no block time was specified (Error) - \param[in] pxQueue pointer to queue object handle. + \brief Event sent when function xTaskCreate is called (API). + \param[in] pxTaskCode pointer to task function. + \param[in] pcName pointer to task name string. + \param[in] usStackDepth stack depth. + \param[in] pvParameters pointer to parameter(s) passed to task funtion. + \param[in] uxPriority task priority. + \param[in] pxCreatedTask pointer to where the created task handle is stored. */ -extern void EvrFreeRTOSQueue_QueuePeekFailed (Queue_t pxQueue); +extern void EvrFreeRTOSTasks_xTaskCreate (void *pxTaskCode, const char *pcName, uint32_t usStackDepth, void *pvParameters, uint32_t uxPriority, /*TCB_t*/void *pxCreatedTask); /** - \brief Event on queue peek from ISR (Op) - \param[in] pxQueue pointer to queue object handle. + \brief Event sent before function xTaskCreate returns (Op). + \param[in] xReturn return status. */ -extern void EvrFreeRTOSQueue_QueuePeekFromIsr (Queue_t pxQueue); +extern void EvrFreeRTOSTasks_xTaskCreate_Return (uint32_t xReturn); /** - \brief Event on read from the empty queue (Error) - \param[in] pxQueue pointer to queue object handle. + \brief Event sent when function xTaskCreateAffinitySet is called (API). + \param[in] pxTaskCode pointer to task function. + \param[in] pcName pointer to task name string. + \param[in] usStackDepth stack depth. + \param[in] pvParameters pointer to parameter(s) passed to task funtion. + \param[in] uxPriority task priority. + \param[in] uxCoreAffinityMask task affinity mask + \param[in] pxCreatedTask pointer to where the created task handle is stored. */ -extern void EvrFreeRTOSQueue_QueueReceiveFailed (Queue_t pxQueue); +extern void EvrFreeRTOSTasks_xTaskCreateAffinitySet (void *pxTaskCode, + const char *pcName, + const uint32_t usStackDepth, + void *pvParameters, + uint32_t uxPriority, + uint32_t uxCoreAffinityMask, + void *pxCreatedTask); /** - \brief Event on write to the queue from ISR (Op) - \param[in] pxQueue pointer to queue object handle. + \brief Event sent before function xTaskCreateAffinitySet returns (Op). + \param[in] xReturn return status. */ -extern void EvrFreeRTOSQueue_QueueSendFromIsr (Queue_t pxQueue); +extern void EvrFreeRTOSTasks_xTaskCreateAffinitySet_Return (uint32_t xReturn); /** - \brief Event on write to the full queue from ISR (Error) - \param[in] pxQueue pointer to queue object handle. + \brief Event sent when function vTaskDelete is called (API). + \param[in] xTaskToDelete handle to the task to delete. */ -extern void EvrFreeRTOSQueue_QueueSendFromIsrFailed (Queue_t pxQueue); +extern void EvrFreeRTOSTasks_vTaskDelete (void *xTaskToDelete); /** - \brief Event on queue read from ISR (Op) - \param[in] pxQueue pointer to queue object handle. + \brief Event sent before function vTaskDelete returns (Op). */ -extern void EvrFreeRTOSQueue_QueueReceiveFromIsr (Queue_t pxQueue); +extern void EvrFreeRTOSTasks_vTaskDelete_Return (void); /** - \brief Event on empty queue read from ISR (Error) - \param[in] pxQueue pointer to queue object handle. + \brief Event sent when function xTaskDelayUntil is called (API). + \param[in] pxPreviousWakeTime pointer to variable that holds the task last unblock time. + \param[in] xTimeIncrement the cycle time period. */ -extern void EvrFreeRTOSQueue_QueueReceiveFromIsrFailed (Queue_t pxQueue); +extern void EvrFreeRTOSTasks_xTaskDelayUntil (uint32_t *pxPreviousWakeTime, const uint32_t xTimeIncrement); /** - \brief Event on empty queue peek from ISR (Error) - \param[in] pxQueue pointer to queue object handle. + \brief Event sent before function xTaskDelayUntil returns (Op). + \param[in] xShouldDelay return status. */ -extern void EvrFreeRTOSQueue_QueuePeekFromIsrFailed (Queue_t pxQueue); +extern void EvrFreeRTOSTasks_xTaskDelayUntil_Return (uint32_t xShouldDelay); /** - \brief Event on queue delete (Op) - \param[in] pxQueue pointer to queue object handle. + \brief Event sent when function vTaskDelay is called (API). + \param[in] xTicksToDelay the number of ticks that the calling task should block. */ -extern void EvrFreeRTOSQueue_QueueDelete (Queue_t pxQueue); +extern void EvrFreeRTOSTasks_vTaskDelay (const uint32_t xTicksToDelay); /** - \brief Event on assignment of a human readable name to a queue (Op) - \param[in] pxQueue pointer to queue object handle. - \param[in] pcQueueName pointer to queue object name. + \brief Event sent before function vTaskDelay returns (Op). */ -extern void EvrFreeRTOSQueue_QueueRegistryAdd (Queue_t pxQueue, const char *pcQueueName); +extern void EvrFreeRTOSTasks_vTaskDelay_Return (void); /** - \brief Event indicating the current running task is about to block while reading from an empty queue (Op) - \param[in] pxQueue pointer to queue object handle. + \brief Event sent when function eTaskGetState is called (API). + \param[in] xTask task handle. */ -extern void EvrFreeRTOSQueue_BlockingOnQueueReceive (Queue_t pxQueue); +extern void EvrFreeRTOSTasks_eTaskGetState (TaskHandle_t xTask); /** - \brief Event indicating the current running task is about to block while writting to a full queue (Op) - \param[in] pxQueue pointer to queue object handle. + \brief Event sent before function eTaskGetState returns (Op). + \param[in] eReturn task state. */ -extern void EvrFreeRTOSQueue_BlockingOnQueueSend (Queue_t pxQueue); +extern void EvrFreeRTOSTasks_eTaskGetState_Return (eTaskState eReturn); /** - \brief Event on successful timer object create (Op) - \param[in] pxNewTimer pointer to timer object handle. + \brief Event sent when function uxTaskPriorityGet is called (API). + \param[in] xTask task handle. */ -extern void EvrFreeRTOSTimers_TimerCreate (Timer_t pxNewTimer); +extern void EvrFreeRTOSTasks_uxTaskPriorityGet (TaskHandle_t xTask); /** - \brief Event on unsuccessful timer object create (Error) + \brief Event sent before function uxTaskPriorityGet returns (Op). + \param[in] uxReturn task priority. */ -extern void EvrFreeRTOSTimers_TimerCreateFailed (void); +extern void EvrFreeRTOSTasks_uxTaskPriorityGet_Return (uint32_t uxReturn); /** - \brief Event on timer queue command send (Op) - \param[in] pxTimer pointer to timer object handle. - \param[in] xCommandID timer command ID. - \param[in] xOptionalValue optional command value. - \param[in] xReturn return value. + \brief Event sent when function uxTaskPriorityGetFromISR is called (API). + \param[in] xTask task handle. */ -extern void EvrFreeRTOSTimers_TimerCommandSend (Timer_t pxTimer, uint32_t xCommandID, uint32_t xOptionalValue, uint32_t xReturn); +extern void EvrFreeRTOSTasks_uxTaskPriorityGetFromISR (TaskHandle_t xTask); /** - \brief Event on timer queue command receive (Op) - \param[in] pxTimer pointer to timer object handle. - \param[in] xCommandID timer command ID. - \param[in] xOptionalValue optional command value. + \brief Event sent before function uxTaskPriorityGetFromISR returns (Op). + \param[in] uxReturn task priority. */ -extern void EvrFreeRTOSTimers_TimerCommandReceived (Timer_t pxTimer, uint32_t xCommandID, uint32_t xOptionalValue); +extern void EvrFreeRTOSTasks_uxTaskPriorityGetFromISR_Return (uint32_t uxReturn); /** - \brief Event on timer expire (Op) - \param[in] pxTimer pointer to timer object handle. + \brief Event sent when function uxTaskBasePriorityGet is called (API). + \param[in] xTask task handle. */ -extern void EvrFreeRTOSTimers_TimerExpired (Timer_t pxTimer); +extern void EvrFreeRTOSTasks_uxTaskBasePriorityGet (TaskHandle_t xTask); /** - \brief Event on pass of the function execution to the timer service task (Op) - \param[in] pxFunctionToPend pointer to callback function - \param[in] pvParameter1 function parameter 1. - \param[in] ulParameter2 function parameter 2. - \param[in] xReturn return value. + \brief Event sent before function uxTaskBasePriorityGet returns (Op). + \param[in] uxReturn task priority. */ -extern void EvrFreeRTOSTimers_PendFuncCall (PendedFunction_t pxFunctionToPend, void *pvParameter1, uint32_t ulParameter2, uint32_t xReturn); +extern void EvrFreeRTOSTasks_uxTaskBasePriorityGet_Return (uint32_t uxReturn); /** - \brief Event on pass of the function execution to the timer service task from the ISR (Op) - \param[in] pxFunctionToPend pointer to callback function - \param[in] pvParameter1 function parameter 1. - \param[in] ulParameter2 function parameter 2. - \param[in] xReturn return value. + \brief Event sent when function uxTaskBasePriorityGetFromISR is called (API). + \param[in] xTask task handle. */ -extern void EvrFreeRTOSTimers_PendFuncCallFromIsr (PendedFunction_t pxFunctionToPend, void *pvParameter1, uint32_t ulParameter2, uint32_t xReturn); +extern void EvrFreeRTOSTasks_uxTaskBasePriorityGetFromISR (TaskHandle_t xTask); /** - \brief Event on successful event groups object create (Op) - \param[in] pxEventGroup pointer to Event Groups object handle. + \brief Event sent before function uxTaskBasePriorityGetFromISR returns (Op). + \param[in] uxReturn task priority. */ -extern void EvrFreeRTOSEventGroups_EventGroupCreate (EventGroup_t pxEventGroup); +extern void EvrFreeRTOSTasks_uxTaskBasePriorityGetFromISR_Return (uint32_t uxReturn); /** - \brief Event on unsuccessful event groups object create (Error) + \brief Event sent when function vTaskPrioritySet is called (API). + \param[in] xTask task handle. + \param[in] uxNewPriority task priority to set. */ -extern void EvrFreeRTOSEventGroups_EventGroupCreateFailed (void); +extern void EvrFreeRTOSTasks_vTaskPrioritySet (TaskHandle_t xTask, uint32_t uxNewPriority); /** - \brief Event on event groups sync wait start (Op) - \param[in] pxEventGroup pointer to Event Groups object handle. - \param[in] uxBitsToSet event bits that shall be set. - \param[in] uxBitsToWaitFor event bits to wait for. + \brief Event sent before function vTaskPrioritySet returns (Op). */ -extern void EvrFreeRTOSEventGroups_EventGroupSyncBlock (EventGroup_t pxEventGroup, uint32_t uxBitsToSet, uint32_t uxBitsToWaitFor); +extern void EvrFreeRTOSTasks_vTaskPrioritySet_Return (void); /** - \brief Event on event groups sync completed (Op) - \param[in] pxEventGroup pointer to Event Groups object handle. - \param[in] uxBitsToSet event bits that shall be set. - \param[in] uxBitsToWaitFor event bits to wait for. - \param[in] xTimeoutOccurred timeout value. + \brief Event sent when function vTaskCoreAffinitySet is called (API). + \param[in] xTask task handle. + \param[in] uxCoreAffinityMask core affinity to set. */ -extern void EvrFreeRTOSEventGroups_EventGroupSyncEnd (EventGroup_t pxEventGroup, uint32_t uxBitsToSet, uint32_t uxBitsToWaitFor, uint32_t xTimeoutOccurred); +extern void EvrFreeRTOSTasks_vTaskCoreAffinitySet (TaskHandle_t xTask, uint32_t uxCoreAffinityMask); /** - \brief Event on event groups bit wait start (Op) - \param[in] pxEventGroup pointer to Event Groups object handle. - \param[in] uxBitsToWaitFor event bits to wait for. + \brief Event sent before function vTaskCoreAffinitySet returns (Op). */ -extern void EvrFreeRTOSEventGroups_EventGroupWaitBitsBlock (EventGroup_t pxEventGroup, uint32_t uxBitsToWaitFor); +extern void EvrFreeRTOSTasks_vTaskCoreAffinitySet_Return (void); /** - \brief Event on event groups bit wait completed (Op) - \param[in] pxEventGroup pointer to Event Groups object handle. - \param[in] uxBitsToWaitFor event bits to wait for. - \param[in] xTimeoutOccurred timeout value. + \brief Event sent when function vTaskCoreAffinityGet is called (API). + \param[in] xTask task handle. */ -extern void EvrFreeRTOSEventGroups_EventGroupWaitBitsEnd (EventGroup_t pxEventGroup, uint32_t uxBitsToWaitFor, uint32_t xTimeoutOccurred); +extern void EvrFreeRTOSTasks_vTaskCoreAffinityGet (ConstTaskHandle_t xTask); /** - \brief Event on event groups bit clear (Op) - \param[in] pxEventGroup pointer to Event Groups object handle. - \param[in] uxBitsToClear event bits that shall be cleared. + \brief Event sent before function vTaskCoreAffinityGet returns (Op). + \param[in] uxCoreAffinityMask core affinity of a task. */ -extern void EvrFreeRTOSEventGroups_EventGroupClearBits (EventGroup_t pxEventGroup, uint32_t uxBitsToClear); +extern void EvrFreeRTOSTasks_vTaskCoreAffinityGet_Return (uint32_t uxCoreAffinityMask); /** - \brief Event on event groups bit clear call from ISR (Op) - \param[in] pxEventGroup pointer to Event Groups object handle. - \param[in] uxBitsToClear event bits that shall be cleared. + \brief Event sent when function vTaskPreemptionDisable is called (API). + \param[in] xTask task handle. */ -extern void EvrFreeRTOSEventGroups_EventGroupClearBitsFromIsr (EventGroup_t pxEventGroup, uint32_t uxBitsToClear); +extern void EvrFreeRTOSTasks_vTaskPreemptionDisable (TaskHandle_t xTask); /** - \brief Event on event groups bit set (Op) - \param[in] pxEventGroup pointer to Event Groups object handle. - \param[in] uxBitsToSet event bits that shall be set. + \brief Event sent before function vTaskPreemptionDisable returns (Op). */ -extern void EvrFreeRTOSEventGroups_EventGroupSetBits (EventGroup_t pxEventGroup, uint32_t uxBitsToSet); +extern void EvrFreeRTOSTasks_vTaskPreemptionDisable_Return (void); /** - \brief Event on event groups bit set call from ISR (Op) - \param[in] pxEventGroup pointer to Event Groups object handle. - \param[in] uxBitsToSet event bits that shall be set. + \brief Event sent when function vTaskPreemptionEnable is called (API). + \param[in] xTask task handle. */ -extern void EvrFreeRTOSEventGroups_EventGroupSetBitsFromIsr (EventGroup_t pxEventGroup, uint32_t uxBitsToSet); +extern void EvrFreeRTOSTasks_vTaskPreemptionEnable (TaskHandle_t xTask); /** - \brief Event on event groups object delete (Op) - \param[in] pxEventGroup pointer to Event Groups object handle. + \brief Event sent before function vTaskPreemptionEnable returns (Op). */ -extern void EvrFreeRTOSEventGroups_EventGroupDelete (EventGroup_t pxEventGroup); +extern void EvrFreeRTOSTasks_vTaskPreemptionEnable_Return (void); /** - \brief Event on unsuccessful stream buffer object create (Error) - \param[in] uxIsMessageBuffer buffer type designator (0:stream, 1:message). + \brief Event sent when function vTaskSuspend is called (API). + \param[in] xTaskToSuspend task handle. */ -extern void EvrFreeRTOSStreamBuf_StreamBufferCreateFailed (uint32_t uxIsMessageBuffer); +extern void EvrFreeRTOSTasks_vTaskSuspend (TaskHandle_t xTaskToSuspend); /** - \brief Event on unsuccessful stream buffer object create (Error) - \param[in] pxStreamBuffer pointer to Stream Buffer object handle. - \param[in] uxIsMessageBuffer buffer type designator (0:stream, 1:message). + \brief Event sent before function vTaskSuspend returns (Op). */ -extern void EvrFreeRTOSStreamBuf_StreamBufferCreateStaticFailed (StreamBuffer_t pxStreamBuffer, uint32_t uxIsMessageBuffer); +extern void EvrFreeRTOSTasks_vTaskSuspend_Return (void); /** - \brief Event on successful stream buffer object create (Op) - \param[in] pxStreamBuffer pointer to Stream Buffer object handle. - \param[in] uxIsMessageBuffer buffer type designator (0:stream, 1:message). + \brief Event sent when function vTaskResume is called (API). + \param[in] xTaskToResume task handle. */ -extern void EvrFreeRTOSStreamBuf_StreamBufferCreate (StreamBuffer_t pxStreamBuffer, uint32_t uxIsMessageBuffer); +extern void EvrFreeRTOSTasks_vTaskResume (TaskHandle_t xTaskToResume); /** - \brief Event on stream buffer object delete (Op) - \param[in] pxStreamBuffer pointer to Stream Buffer object handle. + \brief Event sent before function vTaskResume returns (Op). */ -extern void EvrFreeRTOSStreamBuf_StreamBufferDelete (StreamBuffer_t pxStreamBuffer); +extern void EvrFreeRTOSTasks_vTaskResume_Return (void); /** - \brief Event on stream buffer object reset (Op) - \param[in] pxStreamBuffer pointer to Stream Buffer object handle. + \brief Event sent when function is called (API). + \param[in] xTaskToResume task handle. */ -extern void EvrFreeRTOSStreamBuf_StreamBufferReset (StreamBuffer_t pxStreamBuffer); +extern void EvrFreeRTOSTasks_xTaskResumeFromISR (TaskHandle_t xTaskToResume); /** - \brief Event on stream buffer send when buffer is full and sending task is blocked (Op) - \param[in] pxStreamBuffer pointer to Stream Buffer object handle. + \brief Event sent before function returns (Op). + \param[in] xYieldRequired info if resuming a task results in a context switch */ -extern void EvrFreeRTOSStreamBuf_StreamBufferBlockingOnSend (StreamBuffer_t pxStreamBuffer); +extern void EvrFreeRTOSTasks_xTaskResumeFromISR_Return (uint32_t xYieldRequired); /** - \brief Event on stream buffer send when data is successfully copied into the buffer (Op) - \param[in] pxStreamBuffer pointer to Stream Buffer object handle. - \param[in] xBytesSent number of bytes copied into the buffer + \brief Event sent when function vTaskStartScheduler is called (API). */ -extern void EvrFreeRTOSStreamBuf_StreamBufferSend (StreamBuffer_t pxStreamBuffer, uint32_t xBytesSent); +extern void EvrFreeRTOSTasks_vTaskStartScheduler (void); + +/** + \brief Event sent before function vTaskStartScheduler returns (Op). +*/ +extern void EvrFreeRTOSTasks_vTaskStartScheduler_Return (void); + +/** + \brief Event sent when function vTaskEndScheduler is called (API). +*/ +extern void EvrFreeRTOSTasks_vTaskEndScheduler (void); + +/** + \brief Event sent before function vTaskEndScheduler returns (Op). +*/ +extern void EvrFreeRTOSTasks_vTaskEndScheduler_Return (void); + +/** + \brief Event sent when function vTaskSuspendAll is called (API). +*/ +extern void EvrFreeRTOSTasks_vTaskSuspendAll (void); + +/** + \brief Event sent before function vTaskSuspendAll returns (Op). +*/ +extern void EvrFreeRTOSTasks_vTaskSuspendAll_Return (void); + +/** + \brief Event sent when function xTaskResumeAll is called (API). +*/ +extern void EvrFreeRTOSTasks_xTaskResumeAll (void); + +/** + \brief Event sent before function xTaskResumeAll returns (Op). + \param[in] xAlreadyYielded info if resuming the scheduler caused a context switch. +*/ +extern void EvrFreeRTOSTasks_xTaskResumeAll_Return (uint32_t xAlreadyYielded); + +/** + \brief Event sent when function xTaskGetTickCount is called (API). +*/ +extern void EvrFreeRTOSTasks_xTaskGetTickCount (void); + +/** + \brief Event sent before function xTaskGetTickCount returns (Op). + \param[in] xTicks count of ticks since scheduler was called. +*/ +extern void EvrFreeRTOSTasks_xTaskGetTickCount_Return (uint32_t xTicks); + +/** + \brief Event sent when function xTaskGetTickCountFromISR is called (API). +*/ +extern void EvrFreeRTOSTasks_xTaskGetTickCountFromISR (void); + +/** + \brief Event sent before function xTaskGetTickCountFromISR returns (Op). + \param[in] xTicks count of ticks since scheduler was called. +*/ +extern void EvrFreeRTOSTasks_xTaskGetTickCountFromISR_Return (uint32_t xTicks); + +/** + \brief Event sent when function uxTaskGetNumberOfTasks is called (API). +*/ +extern void EvrFreeRTOSTasks_uxTaskGetNumberOfTasks (void); + +/** + \brief Event sent before function uxTaskGetNumberOfTasks returns (Op). + \param[in] uxCurrentNumberOfTasks current number of tasks. +*/ +extern void EvrFreeRTOSTasks_uxTaskGetNumberOfTasks_Return (uint32_t uxCurrentNumberOfTasks); + +/** + \brief Event sent when function pcTaskGetName is called (API). + \param[in] xTaskToQuery task handle. +*/ +extern void EvrFreeRTOSTasks_pcTaskGetName (TaskHandle_t xTaskToQuery); + +/** + \brief Event sent before function pcTaskGetName returns (Op). + \param[in] pcTaskName pointer to task name. +*/ +extern void EvrFreeRTOSTasks_pcTaskGetName_Return (char *pcTaskName); + +/** + \brief Event sent when function xTaskGetHandle is called (API). + \param[in] pcNameToQuery task name. +*/ +extern void EvrFreeRTOSTasks_xTaskGetHandle (const char *pcNameToQuery); + +/** + \brief Event sent before function xTaskGetHandle returns (Op). + \param[in] pxTCB pointer to task task handle. +*/ +extern void EvrFreeRTOSTasks_xTaskGetHandle_Return (/*TCB_t*/void *pxTCB); + +/** + \brief Event sent when function xTaskGetStaticBuffers is called (API). + \param[in] xTask task handle. + \param[in] ppuxStackBuffer pointer to location where pointer to task stack buffer is stored. + \param[in] ppxTaskBuffer pointer to location where pointer to task data structure is stored. +*/ +extern void EvrFreeRTOSTasks_xTaskGetStaticBuffers (TaskHandle_t xTask, StackType_t **ppuxStackBuffer, /*StaticTask_t** */uint32_t ppxTaskBuffer); + +/** + \brief Event sent before function xTaskGetStaticBuffers returns (Op). + \param[in] xReturn return status. +*/ +extern void EvrFreeRTOSTasks_xTaskGetStaticBuffers_Return (uint32_t xReturn); + +/** + \brief Event sent when function uxTaskGetSystemState is called (API). + \param[in] pxTaskStatusArray pointer to an array of TaskStatus_t structures. + \param[in] uxArraySize array size. + \param[in] pulTotalRunTime total run time since the target booted. +*/ +extern void EvrFreeRTOSTasks_uxTaskGetSystemState (TaskStatus_t *pxTaskStatusArray, const uint32_t uxArraySize, uint32_t *pulTotalRunTime); + +/** + \brief Event sent before function uxTaskGetSystemState returns (Op). + \param[in] uxTask the number of TaskStatus_t structures populated. +*/ +extern void EvrFreeRTOSTasks_uxTaskGetSystemState_Return (uint32_t uxTask); + +/** + \brief Event sent when function xTaskGetIdleTaskHandle is called (API). +*/ +extern void EvrFreeRTOSTasks_xTaskGetIdleTaskHandle (void); + +/** + \brief Event sent before function xTaskGetIdleTaskHandle returns (Op). + \param[in] xTask task handle. +*/ +extern void EvrFreeRTOSTasks_xTaskGetIdleTaskHandle_Return (TaskHandle_t xTask); + +/** + \brief Event sent when function xTaskGetIdleTaskHandleForCore is called (API). + \param[in] xCoreID core id. +*/ +extern void EvrFreeRTOSTasks_xTaskGetIdleTaskHandleForCore (uint32_t xCoreID); + +/** + \brief Event sent before function xTaskGetIdleTaskHandleForCore returns (Op). + \param[in] xTask task handle. +*/ +extern void EvrFreeRTOSTasks_xTaskGetIdleTaskHandleForCore_Return (TaskHandle_t xTask); + +/** + \brief Event sent when function vTaskStepTick is called (API). + \param[in] xTicksToJump number of ticks to add to the tick count. +*/ +extern void EvrFreeRTOSTasks_vTaskStepTick (uint32_t xTicksToJump); + +/** + \brief Event sent before function vTaskStepTick returns (Op). +*/ +extern void EvrFreeRTOSTasks_vTaskStepTick_Return (void); + +/** + \brief Event sent when function xTaskCatchUpTicks is called (API). + \param[in] xTicksToCatchUp number of tick interrupts that have been missed. +*/ +extern void EvrFreeRTOSTasks_xTaskCatchUpTicks (uint32_t xTicksToCatchUp); + +/** + \brief Event sent before function xTaskCatchUpTicks returns (Op). + \param[in] xYieldOccurred info if any task was unblocked. +*/ +extern void EvrFreeRTOSTasks_xTaskCatchUpTicks_Return (uint32_t xYieldOccurred); + +/** + \brief Event sent when function is called (API). + \param[in] xTask task handle. +*/ +extern void EvrFreeRTOSTasks_xTaskAbortDelay (TaskHandle_t xTask); + +/** + \brief Event sent before function returns (Op). + \param[in] xReturn execution status. +*/ +extern void EvrFreeRTOSTasks_xTaskAbortDelay_Return (uint32_t xReturn); + +/** + \brief Event sent when function xTaskIncrementTick is called (API). +*/ +extern void EvrFreeRTOSTasks_xTaskIncrementTick (void); + +/** + \brief Event sent before function xTaskIncrementTick returns (Op). + \param[in] xSwitchRequired info if task switch is required. +*/ +extern void EvrFreeRTOSTasks_xTaskIncrementTick_Return (uint32_t xSwitchRequired); + +/** + \brief Event sent when function is called (API). + \param[in] xTask task handle. + \param[in] pxHookFunction hook function used by the task xTask. +*/ +extern void EvrFreeRTOSTasks_vTaskSetApplicationTaskTag (TaskHandle_t xTask, TaskHookFunction_t pxHookFunction); + +/** + \brief Event sent before function returns (Op). +*/ +extern void EvrFreeRTOSTasks_vTaskSetApplicationTaskTag_Return (void); + +/** + \brief Event sent when function xTaskGetApplicationTaskTag is called (API). + \param[in] xTask task handle. +*/ +extern void EvrFreeRTOSTasks_xTaskGetApplicationTaskTag (TaskHandle_t xTask); + +/** + \brief Event sent before function xTaskGetApplicationTaskTag returns (Op). + \param[in] xReturn hook function used by the task xTask. +*/ +extern void EvrFreeRTOSTasks_xTaskGetApplicationTaskTag_Return (TaskHookFunction_t xReturn); + +/** + \brief Event sent when function xTaskGetApplicationTaskTagFromISR is called (API). + \param[in] xTask task handle. +*/ +extern void EvrFreeRTOSTasks_xTaskGetApplicationTaskTagFromISR (TaskHandle_t xTask); + +/** + \brief Event sent before function xTaskGetApplicationTaskTagFromISR returns (Op). + \param[in] xReturn hook function used by the task xTask. +*/ +extern void EvrFreeRTOSTasks_xTaskGetApplicationTaskTagFromISR_Return (TaskHookFunction_t xReturn); + +/** + \brief Event sent when function xTaskCallApplicationTaskHook is called (API). + \param[in] xTask task handle. + \param[in] pvParameter pointer to parameters passed to the hook function. +*/ +extern void EvrFreeRTOSTasks_xTaskCallApplicationTaskHook (TaskHandle_t xTask, void *pvParameter); + +/** + \brief Event sent before function xTaskCallApplicationTaskHook returns (Op). + \param[in] xReturn hook function execution status. +*/ +extern void EvrFreeRTOSTasks_xTaskCallApplicationTaskHook_Return (uint32_t xReturn); + +/** + \brief Event sent when function is called (API). +*/ +extern void EvrFreeRTOSTasks_vTaskSwitchContext (void); + +/** + \brief Event sent before function returns (Op). +*/ +extern void EvrFreeRTOSTasks_vTaskSwitchContext_Return (void); + +/** + \brief Event sent when function vTaskPlaceOnEventList is called (API). + \param[in] pxEventList pointer to the blocked task list waiting for event. + \param[in] xTicksToWait amount of time to wait for an event. +*/ +extern void EvrFreeRTOSTasks_vTaskPlaceOnEventList (List_t *pxEventList, const TickType_t xTicksToWait); + +/** + \brief Event sent before function vTaskPlaceOnEventList returns (Op). +*/ +extern void EvrFreeRTOSTasks_vTaskPlaceOnEventList_Return (void); + +/** + \brief Event sent when function vTaskPlaceOnUnorderedEventList is called (API). + \param[in] pxEventList pointer to the blocked task list waiting for event. + \param[in] xItemValue value to use when event list is not ordered by priority. + \param[in] xTicksToWait amount of time to wait for an event. +*/ +extern void EvrFreeRTOSTasks_vTaskPlaceOnUnorderedEventList (List_t *pxEventList, const TickType_t xItemValue, const TickType_t xTicksToWait); + +/** + \brief Event sent before function vTaskPlaceOnUnorderedEventList returns (Op). +*/ +extern void EvrFreeRTOSTasks_vTaskPlaceOnUnorderedEventList_Return (void); + +/** + \brief Event sent when function vTaskPlaceOnEventListRestricted is called (API). + \param[in] pxEventList pointer to the blocked task list waiting for event. + \param[in] xTicksToWait amount of time to wait for an event. + \param[in] xWaitIndefinitely whether the task should block indefinitely. +*/ +extern void EvrFreeRTOSTasks_vTaskPlaceOnEventListRestricted (List_t *pxEventList, TickType_t xTicksToWait, const uint32_t xWaitIndefinitely); + +/** + \brief Event sent before function vTaskPlaceOnEventListRestricted returns (Op). +*/ +extern void EvrFreeRTOSTasks_vTaskPlaceOnEventListRestricted_Return (void); + +/** + \brief Event sent when function xTaskRemoveFromEventList is called (API). + \param[in] pxEventList pointer to the event list. +*/ +extern void EvrFreeRTOSTasks_xTaskRemoveFromEventList (const List_t *pxEventList); + +/** + \brief Event sent before function xTaskRemoveFromEventList returns (Op). + \param[in] xReturn execution status +*/ +extern void EvrFreeRTOSTasks_xTaskRemoveFromEventList_Return (uint32_t xReturn); + +/** + \brief Event sent when function vTaskRemoveFromUnorderedEventList is called (API). + \param[in] pxEventListItem pointer to the event list. + \param[in] xItemValue event list item value. +*/ +extern void EvrFreeRTOSTasks_vTaskRemoveFromUnorderedEventList (ListItem_t *pxEventListItem, const TickType_t xItemValue); + +/** + \brief Event sent before function vTaskRemoveFromUnorderedEventList returns (Op). +*/ +extern void EvrFreeRTOSTasks_vTaskRemoveFromUnorderedEventList_Return (void); + +/** + \brief Event sent when function vTaskSetTimeOutState is called (API). + \param[in] pxTimeOut pointer to the timeout object. +*/ +extern void EvrFreeRTOSTasks_vTaskSetTimeOutState (TimeOut_t *pxTimeOut); + +/** + \brief Event sent before function vTaskSetTimeOutState returns (Op). +*/ +extern void EvrFreeRTOSTasks_vTaskSetTimeOutState_Return (void); + +/** + \brief Event sent when function vTaskInternalSetTimeOutState is called (API). + \param[in] pxTimeOut pointer to the timeout object. +*/ +extern void EvrFreeRTOSTasks_vTaskInternalSetTimeOutState (TimeOut_t *pxTimeOut); + +/** + \brief Event sent before function vTaskInternalSetTimeOutState returns (Op). +*/ +extern void EvrFreeRTOSTasks_vTaskInternalSetTimeOutState_Return (void); + +/** + \brief Event sent when function xTaskCheckForTimeOut is called (API). + \param[in] pxTimeOut pointer to the timeout object. + \param[in] pxTicksToWait pointer to object holding number of ticks to check for timeout. +*/ +extern void EvrFreeRTOSTasks_xTaskCheckForTimeOut (TimeOut_t *pxTimeOut, TickType_t *pxTicksToWait); + +/** + \brief Event sent before function xTaskCheckForTimeOut returns (Op). + \param[in] xReturn execution status. +*/ +extern void EvrFreeRTOSTasks_xTaskCheckForTimeOut_Return (uint32_t xReturn); + +/** + \brief Event sent when function vTaskMissedYield is called (API). +*/ +extern void EvrFreeRTOSTasks_vTaskMissedYield (void); + +/** + \brief Event sent before function vTaskMissedYield returns (Op). +*/ +extern void EvrFreeRTOSTasks_vTaskMissedYield_Return (void); + +/** + \brief Event sent when function is called (API). + \param[in] xTask task handle. +*/ +extern void EvrFreeRTOSTasks_uxTaskGetTaskNumber (TaskHandle_t xTask); + +/** + \brief Event sent before function returns (Op). + \param[in] uxReturn number assigned to the task +*/ +extern void EvrFreeRTOSTasks_uxTaskGetTaskNumber_Return (uint32_t uxReturn); + +/** + \brief Event sent when function vTaskSetTaskNumber is called (API). + \param[in] xTask task handle. + \param[in] uxHandle the number to assign to the task. +*/ +extern void EvrFreeRTOSTasks_vTaskSetTaskNumber (TaskHandle_t xTask, const uint32_t uxHandle); + +/** + \brief Event sent before function vTaskSetTaskNumber returns (Op). +*/ +extern void EvrFreeRTOSTasks_vTaskSetTaskNumber_Return (void); + +/** + \brief Event sent when function eTaskConfirmSleepModeStatus is called (API). +*/ +extern void EvrFreeRTOSTasks_eTaskConfirmSleepModeStatus (void); + +/** + \brief Event sent before function eTaskConfirmSleepModeStatus returns (Op). + \param[in] eReturn sleep mode status. +*/ +extern void EvrFreeRTOSTasks_eTaskConfirmSleepModeStatus_Return (eSleepModeStatus eReturn); + +/** + \brief Event sent when function vTaskSetThreadLocalStoragePointer is called (API). + \param[in] xTaskToSet task handle. + \param[in] xIndex array index. + \param[in] pvValue value to set. +*/ +extern void EvrFreeRTOSTasks_vTaskSetThreadLocalStoragePointer (TaskHandle_t xTaskToSet, uint32_t xIndex, void * pvValue); + +/** + \brief Event sent before function vTaskSetThreadLocalStoragePointer returns (Op). +*/ +extern void EvrFreeRTOSTasks_vTaskSetThreadLocalStoragePointer_Return (void); + +/** + \brief Event sent when function pvTaskGetThreadLocalStoragePointer is called (API). + \param[in] xTaskToQuery task handle. + \param[in] xIndex array index. +*/ +extern void EvrFreeRTOSTasks_pvTaskGetThreadLocalStoragePointer (TaskHandle_t xTaskToQuery, uint32_t xIndex); + +/** + \brief Event sent before function pvTaskGetThreadLocalStoragePointer returns (Op). + \param[in] pvReturn retrieved value. +*/ +extern void EvrFreeRTOSTasks_pvTaskGetThreadLocalStoragePointer_Return (void *pvReturn); + +/** + \brief Event sent when function vTaskAllocateMPURegions is called (API). + \param[in] xTaskToModify task handle. + \param[in] pxRegions pointer to a structure that contains memory region definitions. +*/ +extern void EvrFreeRTOSTasks_vTaskAllocateMPURegions (TaskHandle_t xTaskToModify, const MemoryRegion_t *pxRegions); + +/** + \brief Event sent before function vTaskAllocateMPURegions returns (Op). +*/ +extern void EvrFreeRTOSTasks_vTaskAllocateMPURegions_Return (void); + +/** + \brief Event sent when function vTaskGetInfo is called (API). + \param[in] xTask task handle. + \param[in] pxTaskStatus pointer to the structure that will be filled with info. + \param[in] xGetFreeStackSpace parameter that allows the high water mark checking to be skipped. + \param[in] eState parameter that allows the state information to be omitted. +*/ +extern void EvrFreeRTOSTasks_vTaskGetInfo (TaskHandle_t xTask, TaskStatus_t *pxTaskStatus, uint32_t xGetFreeStackSpace, eTaskState eState); + +/** + \brief Event sent before function vTaskGetInfo returns (Op). +*/ +extern void EvrFreeRTOSTasks_vTaskGetInfo_Return (void); + +/** + \brief Event sent when function uxTaskGetStackHighWaterMark2 is called (API). + \param[in] xTask task handle. +*/ +extern void EvrFreeRTOSTasks_uxTaskGetStackHighWaterMark2 (TaskHandle_t xTask); + +/** + \brief Event sent before function uxTaskGetStackHighWaterMark2 returns (Op). + \param[in] uxReturn the smallest amount (in words) of free stack space there has been. +*/ +extern void EvrFreeRTOSTasks_uxTaskGetStackHighWaterMark2_Return (uint32_t uxReturn); + +/** + \brief Event sent when function uxTaskGetStackHighWaterMark is called (API). + \param[in] xTask task handle. +*/ +extern void EvrFreeRTOSTasks_uxTaskGetStackHighWaterMark (TaskHandle_t xTask); + +/** + \brief Event sent before function uxTaskGetStackHighWaterMark returns (Op). + \param[in] uxReturn the smallest amount (in words) of free stack space there has been. +*/ +extern void EvrFreeRTOSTasks_uxTaskGetStackHighWaterMark_Return (uint32_t uxReturn); + +/** + \brief Event sent when function xTaskGetCurrentTaskHandle is called (API). +*/ +extern void EvrFreeRTOSTasks_xTaskGetCurrentTaskHandle (void); + +/** + \brief Event sent before function xTaskGetCurrentTaskHandle returns (Op). + \param[in] xReturn task handle. +*/ +extern void EvrFreeRTOSTasks_xTaskGetCurrentTaskHandle_Return (TaskHandle_t xReturn); + +/** + \brief Event sent when function xTaskGetCurrentTaskHandleForCore is called (API). + \param[in] xCoreID processor core ID. +*/ +extern void EvrFreeRTOSTasks_xTaskGetCurrentTaskHandleForCore (uint32_t xCoreID); + +/** + \brief Event sent before function xTaskGetCurrentTaskHandleForCore returns (Op). + \param[in] xReturn task handle. +*/ +extern void EvrFreeRTOSTasks_xTaskGetCurrentTaskHandleForCore_Return (TaskHandle_t xReturn); + +/** + \brief Event sent when function xTaskGetSchedulerState is called (API). +*/ +extern void EvrFreeRTOSTasks_xTaskGetSchedulerState (void); + +/** + \brief Event sent before function xTaskGetSchedulerState returns (Op). + \param[in] xReturn scheduler state. +*/ +extern void EvrFreeRTOSTasks_xTaskGetSchedulerState_Return (uint32_t xReturn); + +/** + \brief Event sent when function xTaskPriorityInherit is called (API). + \param[in] pxMutexHolder task handle. +*/ +extern void EvrFreeRTOSTasks_xTaskPriorityInherit (TaskHandle_t pxMutexHolder); + +/** + \brief Event sent before function xTaskPriorityInherit returns (Op). + \param[in] xReturn execution status. +*/ +extern void EvrFreeRTOSTasks_xTaskPriorityInherit_Return (uint32_t xReturn); + +/** + \brief Event sent when function xTaskPriorityDisinherit is called (API). + \param[in] pxMutexHolder task handle. +*/ +extern void EvrFreeRTOSTasks_xTaskPriorityDisinherit (TaskHandle_t pxMutexHolder); + +/** + \brief Event sent before function xTaskPriorityDisinherit returns (Op). + \param[in] xReturn execution status. +*/ +extern void EvrFreeRTOSTasks_xTaskPriorityDisinherit_Return (uint32_t xReturn); + +/** + \brief Event sent when function vTaskPriorityDisinheritAfterTimeout is called (API). + \param[in] pxMutexHolder task handle. + \param[in] uxHighestPriorityWaitingTask the priority of the highest priority task that is waiting for mutex. +*/ +extern void EvrFreeRTOSTasks_vTaskPriorityDisinheritAfterTimeout (TaskHandle_t pxMutexHolder, uint32_t uxHighestPriorityWaitingTask); + +/** + \brief Event sent before function vTaskPriorityDisinheritAfterTimeout returns (Op). +*/ +extern void EvrFreeRTOSTasks_vTaskPriorityDisinheritAfterTimeout_Return (void); + +/** + \brief Event sent when function vTaskYieldWithinAPI is called (API). +*/ +extern void EvrFreeRTOSTasks_vTaskYieldWithinAPI (void); + +/** + \brief Event sent before function vTaskYieldWithinAPI returns (Op). +*/ +extern void EvrFreeRTOSTasks_vTaskYieldWithinAPI_Return (void); + +/** + \brief Event sent when function vTaskEnterCritical is called (API). +*/ +extern void EvrFreeRTOSTasks_vTaskEnterCritical (void); + +/** + \brief Event sent before function vTaskEnterCritical returns (Op). +*/ +extern void EvrFreeRTOSTasks_vTaskEnterCritical_Return (void); + +/** + \brief Event sent when function vTaskEnterCriticalFromISR is called (API). +*/ +extern void EvrFreeRTOSTasks_vTaskEnterCriticalFromISR (void); + +/** + \brief Event sent before function vTaskEnterCriticalFromISR returns (Op). + \param[in] uxSavedInterruptStatus saved interrupt status. +*/ +extern void EvrFreeRTOSTasks_vTaskEnterCriticalFromISR_Return (uint32_t uxSavedInterruptStatus); + +/** + \brief Event sent when function vTaskExitCritical is called (API). +*/ +extern void EvrFreeRTOSTasks_vTaskExitCritical (void); + +/** + \brief Event sent before function vTaskExitCritical returns (Op). +*/ +extern void EvrFreeRTOSTasks_vTaskExitCritical_Return (void); + +/** + \brief Event sent when function vTaskExitCriticalFromISR is called (API). + \param[in] uxSavedInterruptStatus saved interrupt status. +*/ +extern void EvrFreeRTOSTasks_vTaskExitCriticalFromISR (uint32_t uxSavedInterruptStatus); + +/** + \brief Event sent before function vTaskExitCriticalFromISR returns (Op). +*/ +extern void EvrFreeRTOSTasks_vTaskExitCriticalFromISR_Return (void); + +/** + \brief Event sent when function vTaskListTasks is called (API). + \param[in] pcWriteBuffer pointer to buffer. + \param[in] uxBufferLength length of the pcWriteBuffer. +*/ +extern void EvrFreeRTOSTasks_vTaskListTasks (char *pcWriteBuffer, size_t uxBufferLength); + +/** + \brief Event sent before function vTaskListTasks returns (Op). +*/ +extern void EvrFreeRTOSTasks_vTaskListTasks_Return (void); + +/** + \brief Event sent when function vTaskGetRunTimeStatistics is called (API). + \param[in] pcWriteBuffer pointer to buffer. + \param[in] uxBufferLength length of the pcWriteBuffer. +*/ +extern void EvrFreeRTOSTasks_vTaskGetRunTimeStatistics (char *pcWriteBuffer, size_t uxBufferLength); + +/** + \brief Event sent before function vTaskGetRunTimeStatistics returns (Op). +*/ +extern void EvrFreeRTOSTasks_vTaskGetRunTimeStatistics_Return (void); + +/** + \brief Event sent when function uxTaskResetEventItemValue is called (API). +*/ +extern void EvrFreeRTOSTasks_uxTaskResetEventItemValue (void); + +/** + \brief Event sent before function uxTaskResetEventItemValue returns (Op). + \param[in] uxReturn event list item value. +*/ +extern void EvrFreeRTOSTasks_uxTaskResetEventItemValue_Return (TickType_t uxReturn); + +/** + \brief Event sent when function pvTaskIncrementMutexHeldCount is called (API). +*/ +extern void EvrFreeRTOSTasks_pvTaskIncrementMutexHeldCount (void); + +/** + \brief Event sent before function pvTaskIncrementMutexHeldCount returns (Op). + \param[in] pxTCB running task handle. +*/ +extern void EvrFreeRTOSTasks_pvTaskIncrementMutexHeldCount_Return (/*TCB_t*/void *pxTCB); + +/** + \brief Event sent when function ulTaskGenericNotifyTake is called (API). + \param[in] uxIndexToWaitOn index within the tasks array of notification values. + \param[in] xClearCountOnExit indication whether to clear notification value. + \param[in] xTicksToWait amount of time to wait. +*/ +extern void EvrFreeRTOSTasks_ulTaskGenericNotifyTake (UBaseType_t uxIndexToWaitOn, BaseType_t xClearCountOnExit, TickType_t xTicksToWait); + +/** + \brief Event sent before function ulTaskGenericNotifyTake returns (Op). + \param[in] ulReturn task notification value before modification. +*/ +extern void EvrFreeRTOSTasks_ulTaskGenericNotifyTake_Return (uint32_t ulReturn); + +/** + \brief Event sent when function xTaskGenericNotifyWait is called (API). + \param[in] uxIndexToWaitOn index within the tasks array of notification values. + \param[in] ulBitsToClearOnEntry bits that shall be cleared before reading notification value. + \param[in] ulBitsToClearOnExit bits that shall be cleared before returning. + \param[in] pulNotificationValue pointer to variable where notification value will be stored. + \param[in] xTicksToWait amount of time to wait. +*/ +extern void EvrFreeRTOSTasks_xTaskGenericNotifyWait (UBaseType_t uxIndexToWaitOn, + uint32_t ulBitsToClearOnEntry, + uint32_t ulBitsToClearOnExit, + uint32_t *pulNotificationValue, + TickType_t xTicksToWait); + +/** + \brief Event sent before function xTaskGenericNotifyWait returns (Op). + \param[in] xReturn notification receive status. +*/ +extern void EvrFreeRTOSTasks_xTaskGenericNotifyWait_Return (BaseType_t xReturn); + +/** + \brief Event sent when function xTaskGenericNotify is called (API). + \param[in] xTaskToNotify task handle. + \param[in] uxIndexToNotify index within the tasks array of notification values. + \param[in] ulValue notification data value. + \param[in] eAction specifies how is the task notification value updated. + \param[in] pulPreviousNotificationValue pointer to variable where notification value will be stored. +*/ +extern void EvrFreeRTOSTasks_xTaskGenericNotify (TaskHandle_t xTaskToNotify, + UBaseType_t uxIndexToNotify, + uint32_t ulValue, + eNotifyAction eAction, + uint32_t *pulPreviousNotificationValue); + +/** + \brief Event sent before function xTaskGenericNotify returns (Op). + \param[in] xReturn context dependent return value. +*/ +extern void EvrFreeRTOSTasks_xTaskGenericNotify_Return (BaseType_t xReturn); + +/** + \brief Event sent when function xTaskGenericNotifyFromISR is called (API). + \param[in] xTaskToNotify task handle. + \param[in] uxIndexToNotify index within the tasks array of notification values. + \param[in] ulValue notification data value. + \param[in] eAction specifies how is the task notification value updated. + \param[in] pulPreviousNotificationValue pointer to variable where notification value will be stored. + \param[in] pxHigherPriorityTaskWoken pointer to variable where information if any task was woken will be stored. +*/ +extern void EvrFreeRTOSTasks_xTaskGenericNotifyFromISR (TaskHandle_t xTaskToNotify, + UBaseType_t uxIndexToNotify, + uint32_t ulValue, + eNotifyAction eAction, + uint32_t *pulPreviousNotificationValue, + BaseType_t *pxHigherPriorityTaskWoken); + +/** + \brief Event sent before function xTaskGenericNotifyFromISR returns (Op). + \param[in] xReturn context dependent return value. +*/ +extern void EvrFreeRTOSTasks_xTaskGenericNotifyFromISR_Return (BaseType_t xReturn); + +/** + \brief Event sent when function vTaskGenericNotifyGiveFromISR is called (API). + \param[in] xTaskToNotify task handle. + \param[in] uxIndexToNotify index within the tasks array of notification values. + \param[in] pxHigherPriorityTaskWoken pointer to variable where information if any task was woken will be stored. +*/ +extern void EvrFreeRTOSTasks_vTaskGenericNotifyGiveFromISR (TaskHandle_t xTaskToNotify, UBaseType_t uxIndexToNotify, BaseType_t *pxHigherPriorityTaskWoken); + +/** + \brief Event sent before function vTaskGenericNotifyGiveFromISR returns (Op). +*/ +extern void EvrFreeRTOSTasks_vTaskGenericNotifyGiveFromISR_Return (void); + +/** + \brief Event sent when function xTaskGenericNotifyStateClear is called (API). + \param[in] xTask task handle. + \param[in] uxIndexToClear index within the tasks array of notification values. +*/ +extern void EvrFreeRTOSTasks_xTaskGenericNotifyStateClear (TaskHandle_t xTask, UBaseType_t uxIndexToClear); + +/** + \brief Event sent before function xTaskGenericNotifyStateClear returns (Op). + \param[in] xReturn execution status. +*/ +extern void EvrFreeRTOSTasks_xTaskGenericNotifyStateClear_Return (BaseType_t xReturn); + +/** + \brief Event sent when function ulTaskGenericNotifyValueClear is called (API). + \param[in] xTask task handle. + \param[in] uxIndexToClear index within the tasks array of notification values. + \param[in] ulBitsToClear bits to clear in notification value. +*/ +extern void EvrFreeRTOSTasks_ulTaskGenericNotifyValueClear (TaskHandle_t xTask, UBaseType_t uxIndexToClear, uint32_t ulBitsToClear); + +/** + \brief Event sent before function ulTaskGenericNotifyValueClear returns (Op). + \param[in] ulReturn notification value before clearing. +*/ +extern void EvrFreeRTOSTasks_ulTaskGenericNotifyValueClear_Return (uint32_t ulReturn); + +/** + \brief Event sent when function ulTaskGetRunTimeCounter is called (API). + \param[in] xTask task handle. +*/ +extern void EvrFreeRTOSTasks_ulTaskGetRunTimeCounter (const TaskHandle_t xTask); + +/** + \brief Event sent before function ulTaskGetRunTimeCounter returns (Op). + \param[in] ulRunTimeCounter total run time of the given task. +*/ +extern void EvrFreeRTOSTasks_ulTaskGetRunTimeCounter_Return (uint32_t ulRunTimeCounter); + +/** + \brief Event sent when function ulTaskGetRunTimePercent is called (API). + \param[in] xTask task handle. +*/ +extern void EvrFreeRTOSTasks_ulTaskGetRunTimePercent (const TaskHandle_t xTask); + +/** + \brief Event sent before function ulTaskGetRunTimePercent returns (Op). + \param[in] ulReturn the percentage of the total run time consumed by the given task. +*/ +extern void EvrFreeRTOSTasks_ulTaskGetRunTimePercent_Return (uint32_t ulReturn); + +/** + \brief Event sent when function ulTaskGetIdleRunTimeCounter is called (API). +*/ +extern void EvrFreeRTOSTasks_ulTaskGetIdleRunTimeCounter (void); + +/** + \brief Event sent before function ulTaskGetIdleRunTimeCounter returns (Op). + \param[in] ulReturn total run time of the idle task. +*/ +extern void EvrFreeRTOSTasks_ulTaskGetIdleRunTimeCounter_Return (uint32_t ulReturn); + +/** + \brief Event sent when function ulTaskGetIdleRunTimePercent is called (API). +*/ +extern void EvrFreeRTOSTasks_ulTaskGetIdleRunTimePercent (void); + +/** + \brief Event sent before function ulTaskGetIdleRunTimePercent returns (Op). + \param[in] ulReturn the percentage of the total run time consumed by the idle task. +*/ +extern void EvrFreeRTOSTasks_ulTaskGetIdleRunTimePercent_Return (uint32_t ulReturn); + +/** + \brief Event sent when function xTaskGetMPUSettings is called (API). + \param[in] xTask task handle. +*/ +extern void EvrFreeRTOSTasks_xTaskGetMPUSettings (TaskHandle_t xTask); + +/** + \brief Event sent before function xTaskGetMPUSettings returns (Op). + \param[in] xMPUSettings pointer to MPU settings associated with a task. +*/ +extern void EvrFreeRTOSTasks_xTaskGetMPUSettings_Return (void *xMPUSettings); + +/* --------------------------------------------------------------------------------------------- */ + +/** + \brief Event on successful queue create (Op) + \param[in] pxQueue pointer to mutex object handle. +*/ +extern void EvrFreeRTOSQueue_QueueCreate (Queue_t pxQueue); + +/** + \brief Event on unsuccessful queue create (Error) + \param[in] ucQueueType queue type +*/ +extern void EvrFreeRTOSQueue_QueueCreateFailed (uint32_t ucQueueType); + +/** + \brief Event on successful mutex create (Op) + \param[in] pxNewQueue pointer to queue object handle. +*/ +extern void EvrFreeRTOSQueue_CreateMutex (Queue_t pxNewQueue); + +/** + \brief Event on unsuccessful mutex create (Error) +*/ +extern void EvrFreeRTOSQueue_CreateMutexFailed (void); + +/** + \brief Event on successful recursive mutex give (Op) + \param[in] pxMutex pointer to mutex object handle. +*/ +extern void EvrFreeRTOSQueue_GiveMutexRecursive (Queue_t pxMutex); + +/** + \brief Event on unsuccessful recursive mutex give (Error) + \param[in] pxMutex pointer to mutex object handle. +*/ +extern void EvrFreeRTOSQueue_GiveMutexRecursiveFailed (Queue_t pxMutex); + +/** + \brief Event on successful recursive mutex take (Op) + \param[in] pxMutex pointer to mutex object handle. +*/ +extern void EvrFreeRTOSQueue_TakeMutexRecursive (Queue_t pxMutex); + +/** + \brief Event on unsuccessful recursive mutex take (Error) + \param[in] pxMutex pointer to mutex object handle. +*/ +extern void EvrFreeRTOSQueue_TakeMutexRecursiveFailed (Queue_t pxMutex); + +/** + \brief Event on successful counting semaphore create (Op) + \param[in] xHandle pointer to semaphore object handle. +*/ +extern void EvrFreeRTOSQueue_CreateCountingSemaphore (Queue_t xHandle); + +/** + \brief Event on unsuccessful counting semaphore create (Error) +*/ +extern void EvrFreeRTOSQueue_CreateCountingSemaphoreFailed (void); + +/** + \brief Event on queue write (Op) + \param[in] pxQueue pointer to queue object handle. +*/ +extern void EvrFreeRTOSQueue_QueueSend (Queue_t pxQueue); + +/** + \brief Event on write to the full queue (Error) + \param[in] pxQueue pointer to queue object handle. +*/ +extern void EvrFreeRTOSQueue_QueueSendFailed (Queue_t pxQueue); + +/** + \brief Event on queue read (Op) + \param[in] pxQueue pointer to queue object handle. +*/ +extern void EvrFreeRTOSQueue_QueueReceive (Queue_t pxQueue); + +/** + \brief Event on queue peek (Op) + \param[in] pxQueue pointer to queue object handle. +*/ +extern void EvrFreeRTOSQueue_QueuePeek (Queue_t pxQueue); + +/** + \brief Event on queue peek when queue is empty and no block time was specified (Error) + \param[in] pxQueue pointer to queue object handle. +*/ +extern void EvrFreeRTOSQueue_QueuePeekFailed (Queue_t pxQueue); + +/** + \brief Event on queue peek from ISR (Op) + \param[in] pxQueue pointer to queue object handle. +*/ +extern void EvrFreeRTOSQueue_QueuePeekFromIsr (Queue_t pxQueue); + +/** + \brief Event on read from the empty queue (Error) + \param[in] pxQueue pointer to queue object handle. +*/ +extern void EvrFreeRTOSQueue_QueueReceiveFailed (Queue_t pxQueue); + +/** + \brief Event on write to the queue from ISR (Op) + \param[in] pxQueue pointer to queue object handle. +*/ +extern void EvrFreeRTOSQueue_QueueSendFromIsr (Queue_t pxQueue); + +/** + \brief Event on write to the full queue from ISR (Error) + \param[in] pxQueue pointer to queue object handle. +*/ +extern void EvrFreeRTOSQueue_QueueSendFromIsrFailed (Queue_t pxQueue); + +/** + \brief Event on queue read from ISR (Op) + \param[in] pxQueue pointer to queue object handle. +*/ +extern void EvrFreeRTOSQueue_QueueReceiveFromIsr (Queue_t pxQueue); + +/** + \brief Event on empty queue read from ISR (Error) + \param[in] pxQueue pointer to queue object handle. +*/ +extern void EvrFreeRTOSQueue_QueueReceiveFromIsrFailed (Queue_t pxQueue); + +/** + \brief Event on empty queue peek from ISR (Error) + \param[in] pxQueue pointer to queue object handle. +*/ +extern void EvrFreeRTOSQueue_QueuePeekFromIsrFailed (Queue_t pxQueue); + +/** + \brief Event on queue delete (Op) + \param[in] pxQueue pointer to queue object handle. +*/ +extern void EvrFreeRTOSQueue_QueueDelete (Queue_t pxQueue); + +/** + \brief Event on assignment of a human readable name to a queue (Op) + \param[in] pxQueue pointer to queue object handle. + \param[in] pcQueueName pointer to queue object name. +*/ +extern void EvrFreeRTOSQueue_QueueRegistryAdd (Queue_t pxQueue, const char *pcQueueName); + +/** + \brief Event indicating the current running task is about to block while reading from an empty queue (Op) + \param[in] pxQueue pointer to queue object handle. +*/ +extern void EvrFreeRTOSQueue_BlockingOnQueueReceive (Queue_t pxQueue); + +/** + \brief Event indicating the current running task is about to block while writting to a full queue (Op) + \param[in] pxQueue pointer to queue object handle. +*/ +extern void EvrFreeRTOSQueue_BlockingOnQueueSend (Queue_t pxQueue); + +/** + \brief Event on successful timer object create (Op) + \param[in] pxNewTimer pointer to timer object handle. +*/ +extern void EvrFreeRTOSTimers_TimerCreate (Timer_t pxNewTimer); + +/** + \brief Event on unsuccessful timer object create (Error) +*/ +extern void EvrFreeRTOSTimers_TimerCreateFailed (void); + +/** + \brief Event on timer queue command send (Op) + \param[in] pxTimer pointer to timer object handle. + \param[in] xCommandID timer command ID. + \param[in] xOptionalValue optional command value. + \param[in] xReturn return value. +*/ +extern void EvrFreeRTOSTimers_TimerCommandSend (Timer_t pxTimer, uint32_t xCommandID, uint32_t xOptionalValue, uint32_t xReturn); + +/** + \brief Event on timer queue command receive (Op) + \param[in] pxTimer pointer to timer object handle. + \param[in] xCommandID timer command ID. + \param[in] xOptionalValue optional command value. +*/ +extern void EvrFreeRTOSTimers_TimerCommandReceived (Timer_t pxTimer, uint32_t xCommandID, uint32_t xOptionalValue); + +/** + \brief Event on timer expire (Op) + \param[in] pxTimer pointer to timer object handle. +*/ +extern void EvrFreeRTOSTimers_TimerExpired (Timer_t pxTimer); + +/** + \brief Event on pass of the function execution to the timer service task (Op) + \param[in] pxFunctionToPend pointer to callback function + \param[in] pvParameter1 function parameter 1. + \param[in] ulParameter2 function parameter 2. + \param[in] xReturn return value. +*/ +extern void EvrFreeRTOSTimers_PendFuncCall (PendedFunction_t pxFunctionToPend, void *pvParameter1, uint32_t ulParameter2, uint32_t xReturn); + +/** + \brief Event on pass of the function execution to the timer service task from the ISR (Op) + \param[in] pxFunctionToPend pointer to callback function + \param[in] pvParameter1 function parameter 1. + \param[in] ulParameter2 function parameter 2. + \param[in] xReturn return value. +*/ +extern void EvrFreeRTOSTimers_PendFuncCallFromIsr (PendedFunction_t pxFunctionToPend, void *pvParameter1, uint32_t ulParameter2, uint32_t xReturn); + +/** + \brief Event sent when function xTimerCreateTimerTask is called (API). +*/ +extern void EvrFreeRTOSTimers_xTimerCreateTimerTask (void); + +/** + \brief Event sent before function xTimerCreateTimerTask returns (Op). + \param[in] xReturn execution status. +*/ +extern void EvrFreeRTOSTimers_xTimerCreateTimerTask_Return (BaseType_t xReturn); + +/** + \brief Event sent when function xTimerCreate is called (API). + \param[in] pcTimerName human readable timer name. + \param[in] xTimerPeriodInTicks the period of the timer in ticks. + \param[in] xAutoReload auto reload flag. + \param[in] pvTimerID identifier assigned to the timer being created. + \param[in] pxCallbackFunction function to call when the timer expired. +*/ +extern void EvrFreeRTOSTimers_xTimerCreate (const char *pcTimerName, + const TickType_t xTimerPeriodInTicks, + const BaseType_t xAutoReload, + void *pvTimerID, + TimerCallbackFunction_t pxCallbackFunction); + +/** + \brief Event sent before function xTimerCreate returns (Op). + \param[in] pxNewTimer Timer object handle. +*/ +extern void EvrFreeRTOSTimers_xTimerCreate_Return (TimerHandle_t pxNewTimer); + +/** + \brief Event sent when function xTimerCreateStatic is called (API). + \param[in] pcTimerName human readable timer name. + \param[in] xTimerPeriodInTicks the period of the timer in ticks. + \param[in] xAutoReload auto reload flag. + \param[in] pvTimerID identifier assigned to the timer being created. + \param[in] pxCallbackFunction function to call when the timer expired. + \param[in] pxTimerBuffer pointer to Timer object memory buffer. +*/ +extern void EvrFreeRTOSTimers_xTimerCreateStatic (const char *pcTimerName, + const TickType_t xTimerPeriodInTicks, + const BaseType_t xAutoReload, + void *pvTimerID, + TimerCallbackFunction_t pxCallbackFunction, + StaticTimer_t *pxTimerBuffer); + +/** + \brief Event sent before function xTimerCreateStatic returns (Op). + \param[in] pxNewTimer Timer object handle. +*/ +extern void EvrFreeRTOSTimers_xTimerCreateStatic_Return (TimerHandle_t pxNewTimer); + +/** + \brief Event sent when function xTimerGenericCommandFromTask is called (API). + \param[in] xTimer Timer object handle. + \param[in] xCommandID timer command identification. + \param[in] xOptionalValue optional command value. + \param[in] pxHigherPriorityTaskWoken pointer to variable where information if any task was woken will be stored. + \param[in] xTicksToWait number of ticks to wait. +*/ +extern void EvrFreeRTOSTimers_xTimerGenericCommandFromTask (TimerHandle_t xTimer, + const BaseType_t xCommandID, + const TickType_t xOptionalValue, + BaseType_t *pxHigherPriorityTaskWoken, + const TickType_t xTicksToWait); + +/** + \brief Event sent before function xTimerGenericCommandFromTask returns (Op). + \param[in] xReturn execution status. +*/ +extern void EvrFreeRTOSTimers_xTimerGenericCommandFromTask_Return (BaseType_t xReturn); + +/** + \brief Event sent when function xTimerGenericCommandFromISR is called (API). + \param[in] xTimer Timer object handle. + \param[in] xCommandID timer command identification. + \param[in] xOptionalValue optional command value. + \param[in] pxHigherPriorityTaskWoken pointer to variable where information if any task was woken will be stored. + \param[in] xTicksToWait number of ticks to wait. +*/ +extern void EvrFreeRTOSTimers_xTimerGenericCommandFromISR (TimerHandle_t xTimer, + const BaseType_t xCommandID, + const TickType_t xOptionalValue, + BaseType_t *pxHigherPriorityTaskWoken, + const TickType_t xTicksToWait); + +/** + \brief Event sent before function xTimerGenericCommandFromISR returns (Op). + \param[in] xReturn execution status. +*/ +extern void EvrFreeRTOSTimers_xTimerGenericCommandFromISR_Return (BaseType_t xReturn); + +/** + \brief Event sent when function xTimerGetTimerDaemonTaskHandle is called (API). +*/ +extern void EvrFreeRTOSTimers_xTimerGetTimerDaemonTaskHandle (void); + +/** + \brief Event sent before function xTimerGetTimerDaemonTaskHandle returns (Op). + \param[in] xTimerTaskHandle Timer task handle. +*/ +extern void EvrFreeRTOSTimers_xTimerGetTimerDaemonTaskHandle_Return (TaskHandle_t xTimerTaskHandle); + +/** + \brief Event sent when function xTimerGetPeriod is called (API). + \param[in] xTimer Timer object handle. +*/ +extern void EvrFreeRTOSTimers_xTimerGetPeriod (TimerHandle_t xTimer); + +/** + \brief Event sent before function xTimerGetPeriod returns (Op). + \param[in] xReturn timer period in ticks. +*/ +extern void EvrFreeRTOSTimers_xTimerGetPeriod_Return (uint32_t xReturn); + +/** + \brief Event sent when function vTimerSetReloadMode is called (API). + \param[in] xTimer Timer object handle. + \param[in] xAutoReload auto reload mode. +*/ +extern void EvrFreeRTOSTimers_vTimerSetReloadMode (TimerHandle_t xTimer, const BaseType_t xAutoReload); + +/** + \brief Event sent before function vTimerSetReloadMode returns (Op). +*/ +extern void EvrFreeRTOSTimers_vTimerSetReloadMode_Return (void); + +/** + \brief Event sent when function xTimerGetReloadMode is called (API). + \param[in] xTimer Timer object handle. +*/ +extern void EvrFreeRTOSTimers_xTimerGetReloadMode (TimerHandle_t xTimer); + +/** + \brief Event sent before function xTimerGetReloadMode returns (Op). + \param[in] xReturn timer auto-reload mode. +*/ +extern void EvrFreeRTOSTimers_xTimerGetReloadMode_Return (BaseType_t xReturn); + +/** + \brief Event sent when function is called (API). + \param[in] xTimer Timer object handle. +*/ +extern void EvrFreeRTOSTimers_uxTimerGetReloadMode (TimerHandle_t xTimer); + +/** + \brief Event sent before function returns (Op). + \param[in] uxReturn timer auto-reload mode. +*/ +extern void EvrFreeRTOSTimers_uxTimerGetReloadMode_Return (UBaseType_t uxReturn); + +/** + \brief Event sent when function xTimerGetExpiryTime is called (API). + \param[in] xTimer Timer object handle. +*/ +extern void EvrFreeRTOSTimers_xTimerGetExpiryTime (TimerHandle_t xTimer); + +/** + \brief Event sent before function xTimerGetExpiryTime returns (Op). + \param[in] xReturn the time at which the timer will expire. +*/ +extern void EvrFreeRTOSTimers_xTimerGetExpiryTime_Return (TickType_t xReturn); + +/** + \brief Event sent when function xTimerGetStaticBuffer is called (API). + \param[in] xTimer Timer object handle. + \param[in] ppxTimerBuffer pointer to memory where object buffer location is stored. +*/ +extern void EvrFreeRTOSTimers_xTimerGetStaticBuffer (TimerHandle_t xTimer, /*StaticTimer_t** */uint32_t ppxTimerBuffer); + +/** + \brief Event sent before function xTimerGetStaticBuffer returns (Op). + \param[in] xReturn execution status. +*/ +extern void EvrFreeRTOSTimers_xTimerGetStaticBuffer_Return (BaseType_t xReturn); + +/** + \brief Event sent when function pcTimerGetName is called (API). + \param[in] xTimer Timer object handle. +*/ +extern void EvrFreeRTOSTimers_pcTimerGetName (TimerHandle_t xTimer); + +/** + \brief Event sent before function pcTimerGetName returns (Op). + \param[in] pcTimerName the name assigned to the Timer object. +*/ +extern void EvrFreeRTOSTimers_pcTimerGetName_Return (const char *pcTimerName); + +/** + \brief Event sent when function xTimerIsTimerActive is called (API). + \param[in] xTimer Timer object handle. +*/ +extern void EvrFreeRTOSTimers_xTimerIsTimerActive (TimerHandle_t xTimer); + +/** + \brief Event sent before function xTimerIsTimerActive returns (Op). + \param[in] xReturn indication whether the timer is active or dormant. +*/ +extern void EvrFreeRTOSTimers_xTimerIsTimerActive_Return (BaseType_t xReturn); + +/** + \brief Event sent when function pvTimerGetTimerID is called (API). + \param[in] xTimer Timer object handle. +*/ +extern void EvrFreeRTOSTimers_pvTimerGetTimerID (const TimerHandle_t xTimer); + +/** + \brief Event sent before function pvTimerGetTimerID returns (Op). + \param[in] pvReturn ID assigned to the timer being queried. +*/ +extern void EvrFreeRTOSTimers_pvTimerGetTimerID_Return (void *pvReturn); + +/** + \brief Event sent when function vTimerSetTimerID is called (API). + \param[in] xTimer Timer object handle. + \param[in] pvNewID ID to assign to the timer. +*/ +extern void EvrFreeRTOSTimers_vTimerSetTimerID (TimerHandle_t xTimer, void *pvNewID); + +/** + \brief Event sent before function vTimerSetTimerID returns (Op). +*/ +extern void EvrFreeRTOSTimers_vTimerSetTimerID_Return (void); + +/** + \brief Event sent when function xTimerPendFunctionCallFromISR is called (API). + \param[in] xFunctionToPend the callback function to execute from the timer daemon task. + \param[in] pvParameter1 the callback function first argument. + \param[in] ulParameter2 the callback function second argument. + \param[in] pxHigherPriorityTaskWoken pointer to variable where information if any task was woken will be stored. +*/ +extern void EvrFreeRTOSTimers_xTimerPendFunctionCallFromISR (PendedFunction_t xFunctionToPend, void *pvParameter1, uint32_t ulParameter2, BaseType_t *pxHigherPriorityTaskWoken); + +/** + \brief Event sent before function xTimerPendFunctionCallFromISR returns (Op). + \param[in] xReturn execution status. +*/ +extern void EvrFreeRTOSTimers_xTimerPendFunctionCallFromISR_Return (BaseType_t xReturn); + +/** + \brief Event sent when function is called (API). + \param[in] xFunctionToPend the callback function to execute from the timer daemon task. + \param[in] pvParameter1 the callback function first argument. + \param[in] ulParameter2 the callback function second argument. + \param[in] xTicksToWait the amount of time to wait until timer queue is free. +*/ +extern void EvrFreeRTOSTimers_xTimerPendFunctionCall (PendedFunction_t xFunctionToPend, void *pvParameter1, uint32_t ulParameter2, TickType_t xTicksToWait); + +/** + \brief Event sent before function returns (Op). + \param[in] xReturn execution status. +*/ +extern void EvrFreeRTOSTimers_xTimerPendFunctionCall_Return (BaseType_t xReturn); + +/** + \brief Event sent when function uxTimerGetTimerNumber is called (API). + \param[in] xTimer Timer object handle. +*/ +extern void EvrFreeRTOSTimers_uxTimerGetTimerNumber (TimerHandle_t xTimer); + +/** + \brief Event sent before function uxTimerGetTimerNumber returns (Op). + \param[in] uxReturn the number assigned to the Timer object. +*/ +extern void EvrFreeRTOSTimers_uxTimerGetTimerNumber_Return (UBaseType_t uxReturn); + +/** + \brief Event sent when function vTimerSetTimerNumber is called (API). + \param[in] xTimer Timer object handle. + \param[in] uxTimerNumber the number to assign to the Timer object. +*/ +extern void EvrFreeRTOSTimers_vTimerSetTimerNumber (TimerHandle_t xTimer, UBaseType_t uxTimerNumber); + +/** + \brief Event sent before function vTimerSetTimerNumber returns (Op). +*/ +extern void EvrFreeRTOSTimers_vTimerSetTimerNumber_Return (void); + + +/** + \brief Event on successful event groups object create (Op) + \param[in] pxEventGroup pointer to Event Groups object handle. +*/ +extern void EvrFreeRTOSEventGroups_EventGroupCreate (EventGroup_t pxEventGroup); + +/** + \brief Event on unsuccessful event groups object create (Error) +*/ +extern void EvrFreeRTOSEventGroups_EventGroupCreateFailed (void); + +/** + \brief Event on event groups sync wait start (Op) + \param[in] pxEventGroup pointer to Event Groups object handle. + \param[in] uxBitsToSet event bits that shall be set. + \param[in] uxBitsToWaitFor event bits to wait for. +*/ +extern void EvrFreeRTOSEventGroups_EventGroupSyncBlock (EventGroup_t pxEventGroup, uint32_t uxBitsToSet, uint32_t uxBitsToWaitFor); + +/** + \brief Event on event groups sync completed (Op) + \param[in] pxEventGroup pointer to Event Groups object handle. + \param[in] uxBitsToSet event bits that shall be set. + \param[in] uxBitsToWaitFor event bits to wait for. + \param[in] xTimeoutOccurred timeout value. +*/ +extern void EvrFreeRTOSEventGroups_EventGroupSyncEnd (EventGroup_t pxEventGroup, uint32_t uxBitsToSet, uint32_t uxBitsToWaitFor, uint32_t xTimeoutOccurred); + +/** + \brief Event on event groups bit wait start (Op) + \param[in] pxEventGroup pointer to Event Groups object handle. + \param[in] uxBitsToWaitFor event bits to wait for. +*/ +extern void EvrFreeRTOSEventGroups_EventGroupWaitBitsBlock (EventGroup_t pxEventGroup, uint32_t uxBitsToWaitFor); + +/** + \brief Event on event groups bit wait completed (Op) + \param[in] pxEventGroup pointer to Event Groups object handle. + \param[in] uxBitsToWaitFor event bits to wait for. + \param[in] xTimeoutOccurred timeout value. +*/ +extern void EvrFreeRTOSEventGroups_EventGroupWaitBitsEnd (EventGroup_t pxEventGroup, uint32_t uxBitsToWaitFor, uint32_t xTimeoutOccurred); + +/** + \brief Event on event groups bit clear (Op) + \param[in] pxEventGroup pointer to Event Groups object handle. + \param[in] uxBitsToClear event bits that shall be cleared. +*/ +extern void EvrFreeRTOSEventGroups_EventGroupClearBits (EventGroup_t pxEventGroup, uint32_t uxBitsToClear); + +/** + \brief Event on event groups bit clear call from ISR (Op) + \param[in] pxEventGroup pointer to Event Groups object handle. + \param[in] uxBitsToClear event bits that shall be cleared. +*/ +extern void EvrFreeRTOSEventGroups_EventGroupClearBitsFromIsr (EventGroup_t pxEventGroup, uint32_t uxBitsToClear); + +/** + \brief Event on event groups bit set (Op) + \param[in] pxEventGroup pointer to Event Groups object handle. + \param[in] uxBitsToSet event bits that shall be set. +*/ +extern void EvrFreeRTOSEventGroups_EventGroupSetBits (EventGroup_t pxEventGroup, uint32_t uxBitsToSet); + +/** + \brief Event on event groups bit set call from ISR (Op) + \param[in] pxEventGroup pointer to Event Groups object handle. + \param[in] uxBitsToSet event bits that shall be set. +*/ +extern void EvrFreeRTOSEventGroups_EventGroupSetBitsFromIsr (EventGroup_t pxEventGroup, uint32_t uxBitsToSet); + +/** + \brief Event on event groups object delete (Op) + \param[in] pxEventGroup pointer to Event Groups object handle. +*/ +extern void EvrFreeRTOSEventGroups_EventGroupDelete (EventGroup_t pxEventGroup); + +/** + \brief Event sent when function xEventGroupCreateStatic is called (API). + \param[in] pxEventGroupBuffer pointer to Event Groups data structure. +*/ +extern void EvrFreeRTOSEventGroups_xEventGroupCreateStatic (StaticEventGroup_t *pxEventGroupBuffer); + +/** + \brief Event sent before function xEventGroupCreateStatic returns (Op). + \param[in] xEventGroup pointer to Event Groups object handle. +*/ +extern void EvrFreeRTOSEventGroups_xEventGroupCreateStatic_Return (EventGroupHandle_t xEventGroup); + +/** + \brief Event sent when function xEventGroupCreate is called (API). +*/ +extern void EvrFreeRTOSEventGroups_xEventGroupCreate (void); + +/** + \brief Event sent before function xEventGroupCreate returns (Op). + \param[in] xEventGroup pointer to Event Groups object handle. +*/ +extern void EvrFreeRTOSEventGroups_xEventGroupCreate_Return (EventGroupHandle_t xEventGroup); + +/** + \brief Event sent when function xEventGroupSync is called (API). + \param[in] xEventGroup pointer to Event Groups object handle. + \param[in] uxBitsToSet bits to set in the Event Group before waiting. + \param[in] uxBitsToWaitFor bits to wait for. + \param[in] xTicksToWait amount of time to wait for. +*/ +extern void EvrFreeRTOSEventGroups_xEventGroupSync (EventGroupHandle_t xEventGroup, + const EventBits_t uxBitsToSet, + const EventBits_t uxBitsToWaitFor, + TickType_t xTicksToWait); + +/** + \brief Event sent before function xEventGroupSync returns (Op). + \param[in] uxReturn the bits after wait or when block time expired. +*/ +extern void EvrFreeRTOSEventGroups_xEventGroupSync_Return (EventBits_t uxReturn); + +/** + \brief Event sent when function xEventGroupWaitBits is called (API). + \param[in] xEventGroup pointer to Event Groups object handle. + \param[in] uxBitsToWaitFor the bits to wait for. + \param[in] xClearOnExit specifies if the bits are cleared on exit. + \param[in] xWaitForAllBits specified if function waits until all bits are set. + \param[in] xTicksToWait amount of time to wait for. +*/ +extern void EvrFreeRTOSEventGroups_xEventGroupWaitBits (EventGroupHandle_t xEventGroup, + const EventBits_t uxBitsToWaitFor, + const BaseType_t xClearOnExit, + const BaseType_t xWaitForAllBits, + TickType_t xTicksToWait); + +/** + \brief Event sent before function xEventGroupWaitBits returns (Op). + \param[in] uxReturn the bits after wait or when block time expired. +*/ +extern void EvrFreeRTOSEventGroups_xEventGroupWaitBits_Return (EventBits_t uxReturn); + +/** + \brief Event sent when function xEventGroupClearBits is called (API). + \param[in] xEventGroup pointer to Event Groups object handle. + \param[in] uxBitsToClear the bits to clear. +*/ +extern void EvrFreeRTOSEventGroups_xEventGroupClearBits (EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear); + +/** + \brief Event sent before function xEventGroupClearBits returns (Op). + \param[in] uxReturn the bits before clearing. +*/ +extern void EvrFreeRTOSEventGroups_xEventGroupClearBits_Return (EventBits_t uxReturn); + +/** + \brief Event sent when function xEventGroupClearBitsFromISR is called (API). + \param[in] xEventGroup pointer to Event Groups object handle. + \param[in] uxBitsToClear the bits to clear. +*/ +extern void EvrFreeRTOSEventGroups_xEventGroupClearBitsFromISR (EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear); + +/** + \brief Event sent before function xEventGroupClearBitsFromISR returns (Op). + \param[in] xReturn execution status. +*/ +extern void EvrFreeRTOSEventGroups_xEventGroupClearBitsFromISR_Return (BaseType_t xReturn); + +/** + \brief Event sent when function xEventGroupGetBitsFromISR is called (API). + \param[in] xEventGroup pointer to Event Groups object handle. +*/ +extern void EvrFreeRTOSEventGroups_xEventGroupGetBitsFromISR (EventGroupHandle_t xEventGroup); + +/** + \brief Event sent before function xEventGroupGetBitsFromISR returns (Op). + \param[in] uxReturn the set bits. +*/ +extern void EvrFreeRTOSEventGroups_xEventGroupGetBitsFromISR_Return (EventBits_t uxReturn); + +/** + \brief Event sent when function xEventGroupSetBits is called (API). + \param[in] xEventGroup pointer to Event Groups object handle. + \param[in] uxBitsToSet the bits to set. +*/ +extern void EvrFreeRTOSEventGroups_xEventGroupSetBits (EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet); + +/** + \brief Event sent before function xEventGroupSetBits returns (Op). + \param[in] uxReturn the bits set at the time function returns. +*/ +extern void EvrFreeRTOSEventGroups_xEventGroupSetBits_Return (EventBits_t uxReturn); + +/** + \brief Event sent when function vEventGroupDelete is called (API). + \param[in] xEventGroup pointer to Event Groups object handle. +*/ +extern void EvrFreeRTOSEventGroups_vEventGroupDelete (EventGroupHandle_t xEventGroup); + +/** + \brief Event sent before function vEventGroupDelete returns (Op). +*/ +extern void EvrFreeRTOSEventGroups_vEventGroupDelete_Return (void); + +/** + \brief Event sent when function xEventGroupGetStaticBuffer is called (API). + \param[in] xEventGroup pointer to Event Groups object handle. + \param[in] ppxEventGroupBuffer pointer to memory where pointer to Event Groups object data buffer is stored. +*/ +extern void EvrFreeRTOSEventGroups_xEventGroupGetStaticBuffer (EventGroupHandle_t xEventGroup, /*StaticEventGroup_t** */uint32_t ppxEventGroupBuffer); + +/** + \brief Event sent before function xEventGroupGetStaticBuffer returns (Op). + \param[in] xReturn execution status. +*/ +extern void EvrFreeRTOSEventGroups_xEventGroupGetStaticBuffer_Return (BaseType_t xReturn); + +/** + \brief Event sent when function vEventGroupSetBitsCallback is called (API). + \param[in] pvEventGroup pointer to Event Groups object handle. + \param[in] ulBitsToSet bits to set. +*/ +extern void EvrFreeRTOSEventGroups_vEventGroupSetBitsCallback (void *pvEventGroup, uint32_t ulBitsToSet); + +/** + \brief Event sent before function vEventGroupSetBitsCallback returns (Op). +*/ +extern void EvrFreeRTOSEventGroups_vEventGroupSetBitsCallback_Return (void); + +/** + \brief Event sent when function vEventGroupClearBitsCallback is called (API). + \param[in] pvEventGroup pointer to Event Groups object handle. + \param[in] ulBitsToClear bits to clear. +*/ +extern void EvrFreeRTOSEventGroups_vEventGroupClearBitsCallback (void *pvEventGroup, uint32_t ulBitsToClear); + +/** + \brief Event sent before function vEventGroupClearBitsCallback returns (Op). +*/ +extern void EvrFreeRTOSEventGroups_vEventGroupClearBitsCallback_Return (void); + +/** + \brief Event sent when function xEventGroupSetBitsFromISR is called (API). + \param[in] xEventGroup pointer to Event Groups object handle. + \param[in] uxBitsToSet bits to set + \param[in] pxHigherPriorityTaskWoken pointer to variable where information if any task was woken will be stored. +*/ +extern void EvrFreeRTOSEventGroups_xEventGroupSetBitsFromISR (EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet, BaseType_t * pxHigherPriorityTaskWoken); + +/** + \brief Event sent before function xEventGroupSetBitsFromISR returns (Op). + \param[in] xReturn execution status. +*/ +extern void EvrFreeRTOSEventGroups_xEventGroupSetBitsFromISR_Return (BaseType_t xReturn); + +/** + \brief Event sent when function uxEventGroupGetNumber is called (API). + \param[in] xEventGroup pointer to Event Groups object handle. +*/ +extern void EvrFreeRTOSEventGroups_uxEventGroupGetNumber (void *xEventGroup); + +/** + \brief Event sent before function uxEventGroupGetNumber returns (Op). + \param[in] xReturn Event Groups object number. +*/ +extern void EvrFreeRTOSEventGroups_uxEventGroupGetNumber_Return (UBaseType_t xReturn); + +/** + \brief Event sent when function vEventGroupSetNumber is called (API). + \param[in] xEventGroup pointer to Event Groups object handle. + \param[in] uxEventGroupNumber number to assign to the Event Groups object. +*/ +extern void EvrFreeRTOSEventGroups_vEventGroupSetNumber (void *xEventGroup, UBaseType_t uxEventGroupNumber); + +/** + \brief Event sent before function vEventGroupSetNumber returns (Op). +*/ +extern void EvrFreeRTOSEventGroups_vEventGroupSetNumber_Return (void); + + +/** + \brief Event on unsuccessful stream buffer object create (Error) + \param[in] uxIsMessageBuffer buffer type designator (0:stream, 1:message). +*/ +extern void EvrFreeRTOSStreamBuf_StreamBufferCreateFailed (uint32_t uxIsMessageBuffer); + +/** + \brief Event on unsuccessful stream buffer object create (Error) + \param[in] pxStreamBuffer pointer to Stream Buffer object handle. + \param[in] uxIsMessageBuffer buffer type designator (0:stream, 1:message). +*/ +extern void EvrFreeRTOSStreamBuf_StreamBufferCreateStaticFailed (StreamBuffer_t pxStreamBuffer, uint32_t uxIsMessageBuffer); + +/** + \brief Event on successful stream buffer object create (Op) + \param[in] pxStreamBuffer pointer to Stream Buffer object handle. + \param[in] uxIsMessageBuffer buffer type designator (0:stream, 1:message). +*/ +extern void EvrFreeRTOSStreamBuf_StreamBufferCreate (StreamBuffer_t pxStreamBuffer, uint32_t uxIsMessageBuffer); + +/** + \brief Event on stream buffer object delete (Op) + \param[in] pxStreamBuffer pointer to Stream Buffer object handle. +*/ +extern void EvrFreeRTOSStreamBuf_StreamBufferDelete (StreamBuffer_t pxStreamBuffer); + +/** + \brief Event on stream buffer object reset (Op) + \param[in] pxStreamBuffer pointer to Stream Buffer object handle. +*/ +extern void EvrFreeRTOSStreamBuf_StreamBufferReset (StreamBuffer_t pxStreamBuffer); + +/** + \brief Event on stream buffer send when buffer is full and sending task is blocked (Op) + \param[in] pxStreamBuffer pointer to Stream Buffer object handle. +*/ +extern void EvrFreeRTOSStreamBuf_StreamBufferBlockingOnSend (StreamBuffer_t pxStreamBuffer); + +/** + \brief Event on stream buffer send when data is successfully copied into the buffer (Op) + \param[in] pxStreamBuffer pointer to Stream Buffer object handle. + \param[in] xBytesSent number of bytes copied into the buffer +*/ +extern void EvrFreeRTOSStreamBuf_StreamBufferSend (StreamBuffer_t pxStreamBuffer, uint32_t xBytesSent); + +/** + \brief Event on stream buffer send when data is not copied into the buffer (Error) + \param[in] pxStreamBuffer pointer to Stream Buffer object handle. +*/ +extern void EvrFreeRTOSStreamBuf_StreamBufferSendFailed (StreamBuffer_t pxStreamBuffer); + +/** + \brief Event on stream buffer send from ISR when data is successfully copied into the buffer (Op) + \param[in] pxStreamBuffer pointer to Stream Buffer object handle. + \param[in] xBytesSent number of bytes copied into the buffer +*/ +extern void EvrFreeRTOSStreamBuf_StreamBufferSendFromIsr (StreamBuffer_t pxStreamBuffer, uint32_t xBytesSent); + +/** + \brief Event on stream buffer receive when buffer is empty and receiving task is blocked (Op) + \param[in] pxStreamBuffer pointer to Stream Buffer object handle. +*/ +extern void EvrFreeRTOSStreamBuf_StreamBufferBlockingOnReceive (StreamBuffer_t pxStreamBuffer); + +/** + \brief Event on stream buffer receive when data is successfully copied from the buffer (Op) + \param[in] pxStreamBuffer pointer to Stream Buffer object handle. + \param[in] xReceivedLength number of bytes copied from the buffer +*/ +extern void EvrFreeRTOSStreamBuf_StreamBufferReceive (StreamBuffer_t pxStreamBuffer, uint32_t xReceivedLength); + +/** + \brief Event on stream buffer receive when data is not copied from the buffer (Error) + \param[in] pxStreamBuffer pointer to Stream Buffer object handle. +*/ +extern void EvrFreeRTOSStreamBuf_StreamBufferReceiveFailed (StreamBuffer_t pxStreamBuffer); + +/** + \brief Event on stream buffer receive from ISR when data is successfully copied from the buffer (Op) + \param[in] pxStreamBuffer pointer to Stream Buffer object handle. + \param[in] xReceivedLength number of bytes copied from the buffer +*/ +extern void EvrFreeRTOSStreamBuf_StreamBufferReceiveFromIsr (StreamBuffer_t pxStreamBuffer, uint32_t xReceivedLength); + +/** + \brief Event on heap memory block allocation (Op) + \param[in] pvAddress pointer to memory block. + \param[in] uiSize memory block size. +*/ +extern void EvrFreeRTOSHeap_Malloc (void *pvAddress, uint32_t uiSize); + +/** + \brief Event on heap memory block free (Op) + \param[in] pvAddress pointer to memory block. + \param[in] uiSize memory block size. +*/ +extern void EvrFreeRTOSHeap_Free (void *pvAddress, uint32_t uiSize); + + +/* Tasks */ + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_CREATE_DISABLE)) + #define traceTASK_CREATE(px) EvrFreeRTOSTasks_TaskCreate(px) +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_CREATE_FAILED_DISABLE)) + #define traceTASK_CREATE_FAILED() EvrFreeRTOSTasks_TaskCreateFailed() +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_DELETE_DISABLE)) + #define traceTASK_DELETE(px) EvrFreeRTOSTasks_TaskDelete(px) +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_DELAY_UNTIL_DISABLE)) + #define traceTASK_DELAY_UNTIL(x) EvrFreeRTOSTasks_TaskDelayUntil(x) +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_DELAY_DISABLE)) + #define traceTASK_DELAY() EvrFreeRTOSTasks_TaskDelay(xTicksToDelay) +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_PRIORITY_SET_DISABLE)) + #define traceTASK_PRIORITY_SET(px,ux) EvrFreeRTOSTasks_TaskPrioritySet(px,ux) +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_SUSPEND_DISABLE)) + #define traceTASK_SUSPEND(px) EvrFreeRTOSTasks_TaskSuspend(px) +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_RESUME_DISABLE)) + #define traceTASK_RESUME(px) EvrFreeRTOSTasks_TaskResume(px) +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_RESUME_FROM_ISR_DISABLE)) + #define traceTASK_RESUME_FROM_ISR(px) EvrFreeRTOSTasks_TaskResumeFromIsr(px) +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_INCREMENT_TICK_DISABLE)) + #define traceTASK_INCREMENT_TICK(x) EvrFreeRTOSTasks_TaskIncrementTick(x) +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceINCREASE_TICK_COUNT_DISABLE)) + #define traceINCREASE_TICK_COUNT(x) EvrFreeRTOSTasks_IncreaseTickCount(x) +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_SWITCHED_OUT_DISABLE)) + #define traceTASK_SWITCHED_OUT() EvrFreeRTOSTasks_TaskSwitchedOut(pxCurrentTCB) +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_SWITCHED_IN_DISABLE)) + #define traceTASK_SWITCHED_IN() EvrFreeRTOSTasks_TaskSwitchedIn(pxCurrentTCB, uxTopReadyPriority) +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_PRIORITY_INHERIT_DISABLE)) + #define traceTASK_PRIORITY_INHERIT(px,ux) EvrFreeRTOSTasks_TaskPriorityInherit(px,ux) +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_PRIORITY_DISINHERIT_DISABLE)) + #define traceTASK_PRIORITY_DISINHERIT(px,ux) EvrFreeRTOSTasks_TaskPriorityDisinherit(px,ux) +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceMOVED_TASK_TO_READY_STATE_DISABLE)) + #define traceMOVED_TASK_TO_READY_STATE(px) EvrFreeRTOSTasks_MovedTaskToReadyState(px) +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(tracePOST_MOVED_TASK_TO_READY_STATE_DISABLE)) + #define tracePOST_MOVED_TASK_TO_READY_STATE(px) EvrFreeRTOSTasks_PostMovedTaskToReadyState(px) +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceLOW_POWER_IDLE_BEGIN_DISABLE)) + #define traceLOW_POWER_IDLE_BEGIN() EvrFreeRTOSTasks_LowPowerIdleBegin(xExpectedIdleTime) +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceLOW_POWER_IDLE_END_DISABLE)) + #define traceLOW_POWER_IDLE_END() EvrFreeRTOSTasks_LowPowerIdleEnd() +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_NOTIFY_TAKE_BLOCK_DISABLE)) + #define traceTASK_NOTIFY_TAKE_BLOCK(ux) EvrFreeRTOSTasks_TaskNotifyTakeBlock(ux, xTicksToWait) +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_NOTIFY_TAKE_DISABLE)) + #define traceTASK_NOTIFY_TAKE(ux) EvrFreeRTOSTasks_TaskNotifyTake(ux, pxCurrentTCB->ulNotifiedValue[ux]) +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_NOTIFY_WAIT_BLOCK_DISABLE)) + #define traceTASK_NOTIFY_WAIT_BLOCK(ux) EvrFreeRTOSTasks_TaskNotifyWaitBlock(ux, xTicksToWait) +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_NOTIFY_WAIT_DISABLE)) + #define traceTASK_NOTIFY_WAIT(ux) EvrFreeRTOSTasks_TaskNotifyWait(ux, pxCurrentTCB->ulNotifiedValue[ux]) +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_NOTIFY_DISABLE)) + #define traceTASK_NOTIFY(ux) EvrFreeRTOSTasks_TaskNotify(pxTCB, ux, eAction, pxTCB->ulNotifiedValue[ux]) +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_NOTIFY_FROM_ISR_DISABLE)) + #define traceTASK_NOTIFY_FROM_ISR(ux) EvrFreeRTOSTasks_TaskNotifyFromIsr(pxTCB, ux, eAction, pxTCB->ulNotifiedValue[ux]) +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_NOTIFY_GIVE_FROM_ISR_DISABLE)) + #define traceTASK_NOTIFY_GIVE_FROM_ISR(ux) EvrFreeRTOSTasks_TaskNotifyGiveFromIsr(pxTCB, ux, pxTCB->ulNotifiedValue[ux]) +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceMOVED_TASK_TO_DELAYED_LIST_DISABLE)) + #define traceMOVED_TASK_TO_DELAYED_LIST() EvrFreeRTOSTasks_MovedTaskToDelayedList(pxCurrentTCB) +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceMOVED_TASK_TO_OVERFLOW_DELAYED_LIST_DISABLE)) + #define traceMOVED_TASK_TO_OVERFLOW_DELAYED_LIST() EvrFreeRTOSTasks_MovedTaskToOverflowDelayedList(pxCurrentTCB) +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskCreateStatic_DISABLE)) + #define traceENTER_xTaskCreateStatic EvrFreeRTOSTasks_xTaskCreateStatic +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskCreateStatic_DISABLE)) + #define traceRETURN_xTaskCreateStatic EvrFreeRTOSTasks_xTaskCreateStatic_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskCreateStaticAffinitySet_DISABLE)) + #define traceENTER_xTaskCreateStaticAffinitySet EvrFreeRTOSTasks_xTaskCreateStaticAffinitySet +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskCreateStaticAffinitySet_DISABLE)) + #define traceRETURN_xTaskCreateStaticAffinitySet EvrFreeRTOSTasks_xTaskCreateStaticAffinitySet_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskCreateRestrictedStatic_DISABLE)) + #define traceENTER_xTaskCreateRestrictedStatic EvrFreeRTOSTasks_xTaskCreateRestrictedStatic +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskCreateRestrictedStatic_DISABLE)) + #define traceRETURN_xTaskCreateRestrictedStatic EvrFreeRTOSTasks_xTaskCreateRestrictedStatic_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskCreateRestrictedStaticAffinitySet_DISABLE)) + #define traceENTER_xTaskCreateRestrictedStaticAffinitySet EvrFreeRTOSTasks_xTaskCreateRestrictedStaticAffinitySet +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskCreateRestrictedStaticAffinitySet_DISABLE)) + #define traceRETURN_xTaskCreateRestrictedStaticAffinitySet EvrFreeRTOSTasks_xTaskCreateRestrictedStaticAffinitySet_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskCreateRestricted_DISABLE)) + #define traceENTER_xTaskCreateRestricted EvrFreeRTOSTasks_xTaskCreateRestricted +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskCreateRestricted_DISABLE)) + #define traceRETURN_xTaskCreateRestricted EvrFreeRTOSTasks_xTaskCreateRestricted_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskCreateRestrictedAffinitySet_DISABLE)) + #define traceENTER_xTaskCreateRestrictedAffinitySet EvrFreeRTOSTasks_xTaskCreateRestrictedAffinitySet +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskCreateRestrictedAffinitySet_DISABLE)) + #define traceRETURN_xTaskCreateRestrictedAffinitySet EvrFreeRTOSTasks_xTaskCreateRestrictedAffinitySet_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskCreate_DISABLE)) + #define traceENTER_xTaskCreate EvrFreeRTOSTasks_xTaskCreate +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskCreate_DISABLE)) + #define traceRETURN_xTaskCreate EvrFreeRTOSTasks_xTaskCreate_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskCreateAffinitySet_DISABLE)) + #define traceENTER_xTaskCreateAffinitySet EvrFreeRTOSTasks_xTaskCreateAffinitySet +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskCreateAffinitySet_DISABLE)) + #define traceRETURN_xTaskCreateAffinitySet EvrFreeRTOSTasks_xTaskCreateAffinitySet_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskDelete_DISABLE)) + #define traceENTER_vTaskDelete EvrFreeRTOSTasks_vTaskDelete +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskDelete_DISABLE)) + #define traceRETURN_vTaskDelete EvrFreeRTOSTasks_vTaskDelete_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskDelayUntil_DISABLE)) + #define traceENTER_xTaskDelayUntil EvrFreeRTOSTasks_xTaskDelayUntil +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskDelayUntil_DISABLE)) + #define traceRETURN_xTaskDelayUntil EvrFreeRTOSTasks_xTaskDelayUntil_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskDelay_DISABLE)) + #define traceENTER_vTaskDelay EvrFreeRTOSTasks_vTaskDelay +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskDelay_DISABLE)) + #define traceRETURN_vTaskDelay EvrFreeRTOSTasks_vTaskDelay_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_eTaskGetState_DISABLE)) + #define traceENTER_eTaskGetState EvrFreeRTOSTasks_eTaskGetState +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_eTaskGetState_DISABLE)) + #define traceRETURN_eTaskGetState EvrFreeRTOSTasks_eTaskGetState_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_uxTaskPriorityGet_DISABLE)) + #define traceENTER_uxTaskPriorityGet EvrFreeRTOSTasks_uxTaskPriorityGet +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_uxTaskPriorityGet_DISABLE)) + #define traceRETURN_uxTaskPriorityGet EvrFreeRTOSTasks_uxTaskPriorityGet_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_uxTaskPriorityGetFromISR_DISABLE)) + #define traceENTER_uxTaskPriorityGetFromISR EvrFreeRTOSTasks_uxTaskPriorityGetFromISR +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_uxTaskPriorityGetFromISR_DISABLE)) + #define traceRETURN_uxTaskPriorityGetFromISR EvrFreeRTOSTasks_uxTaskPriorityGetFromISR_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_uxTaskBasePriorityGet_DISABLE)) + #define traceENTER_uxTaskBasePriorityGet EvrFreeRTOSTasks_uxTaskBasePriorityGet +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_uxTaskBasePriorityGet_DISABLE)) + #define traceRETURN_uxTaskBasePriorityGet EvrFreeRTOSTasks_uxTaskBasePriorityGet_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_uxTaskBasePriorityGetFromISR_DISABLE)) + #define traceENTER_uxTaskBasePriorityGetFromISR EvrFreeRTOSTasks_uxTaskBasePriorityGetFromISR +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_uxTaskBasePriorityGetFromISR_DISABLE)) + #define traceRETURN_uxTaskBasePriorityGetFromISR EvrFreeRTOSTasks_uxTaskBasePriorityGetFromISR_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskPrioritySet_DISABLE)) + #define traceENTER_vTaskPrioritySet EvrFreeRTOSTasks_vTaskPrioritySet +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskPrioritySet_DISABLE)) + #define traceRETURN_vTaskPrioritySet EvrFreeRTOSTasks_vTaskPrioritySet_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskCoreAffinitySet_DISABLE)) + #define traceENTER_vTaskCoreAffinitySet EvrFreeRTOSTasks_vTaskCoreAffinitySet +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskCoreAffinitySet_DISABLE)) + #define traceRETURN_vTaskCoreAffinitySet EvrFreeRTOSTasks_vTaskCoreAffinitySet_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskCoreAffinityGet_DISABLE)) + #define traceENTER_vTaskCoreAffinityGet EvrFreeRTOSTasks_vTaskCoreAffinityGet +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskCoreAffinityGet_DISABLE)) + #define traceRETURN_vTaskCoreAffinityGet EvrFreeRTOSTasks_vTaskCoreAffinityGet_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskPreemptionDisable_DISABLE)) + #define traceENTER_vTaskPreemptionDisable EvrFreeRTOSTasks_vTaskPreemptionDisable +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskPreemptionDisable_DISABLE)) + #define traceRETURN_vTaskPreemptionDisable EvrFreeRTOSTasks_vTaskPreemptionDisable_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskPreemptionEnable_DISABLE)) + #define traceENTER_vTaskPreemptionEnable EvrFreeRTOSTasks_vTaskPreemptionEnable +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskPreemptionEnable_DISABLE)) + #define traceRETURN_vTaskPreemptionEnable EvrFreeRTOSTasks_vTaskPreemptionEnable_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskSuspend_DISABLE)) + #define traceENTER_vTaskSuspend EvrFreeRTOSTasks_vTaskSuspend +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskSuspend_DISABLE)) + #define traceRETURN_vTaskSuspend EvrFreeRTOSTasks_vTaskSuspend_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskResume_DISABLE)) + #define traceENTER_vTaskResume EvrFreeRTOSTasks_vTaskResume +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskResume_DISABLE)) + #define traceRETURN_vTaskResume EvrFreeRTOSTasks_vTaskResume_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskResumeFromISR_DISABLE)) + #define traceENTER_xTaskResumeFromISR EvrFreeRTOSTasks_xTaskResumeFromISR +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskResumeFromISR_DISABLE)) + #define traceRETURN_xTaskResumeFromISR EvrFreeRTOSTasks_xTaskResumeFromISR_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskStartScheduler_DISABLE)) + #define traceENTER_vTaskStartScheduler EvrFreeRTOSTasks_vTaskStartScheduler +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskStartScheduler_DISABLE)) + #define traceRETURN_vTaskStartScheduler EvrFreeRTOSTasks_vTaskStartScheduler_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskEndScheduler_DISABLE)) + #define traceENTER_vTaskEndScheduler EvrFreeRTOSTasks_vTaskEndScheduler +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskEndScheduler_DISABLE)) + #define traceRETURN_vTaskEndScheduler EvrFreeRTOSTasks_vTaskEndScheduler_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskSuspendAll_DISABLE)) + #define traceENTER_vTaskSuspendAll EvrFreeRTOSTasks_vTaskSuspendAll +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskSuspendAll_DISABLE)) + #define traceRETURN_vTaskSuspendAll EvrFreeRTOSTasks_vTaskSuspendAll_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskResumeAll_DISABLE)) + #define traceENTER_xTaskResumeAll EvrFreeRTOSTasks_xTaskResumeAll +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskResumeAll_DISABLE)) + #define traceRETURN_xTaskResumeAll EvrFreeRTOSTasks_xTaskResumeAll_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskGetTickCount_DISABLE)) + #define traceENTER_xTaskGetTickCount EvrFreeRTOSTasks_xTaskGetTickCount +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskGetTickCount_DISABLE)) + #define traceRETURN_xTaskGetTickCount EvrFreeRTOSTasks_xTaskGetTickCount_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskGetTickCountFromISR_DISABLE)) + #define traceENTER_xTaskGetTickCountFromISR EvrFreeRTOSTasks_xTaskGetTickCountFromISR +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskGetTickCountFromISR_DISABLE)) + #define traceRETURN_xTaskGetTickCountFromISR EvrFreeRTOSTasks_xTaskGetTickCountFromISR_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_uxTaskGetNumberOfTasks_DISABLE)) + #define traceENTER_uxTaskGetNumberOfTasks EvrFreeRTOSTasks_uxTaskGetNumberOfTasks +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_uxTaskGetNumberOfTasks_DISABLE)) + #define traceRETURN_uxTaskGetNumberOfTasks EvrFreeRTOSTasks_uxTaskGetNumberOfTasks_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_pcTaskGetName_DISABLE)) + #define traceENTER_pcTaskGetName EvrFreeRTOSTasks_pcTaskGetName +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_pcTaskGetName_DISABLE)) + #define traceRETURN_pcTaskGetName EvrFreeRTOSTasks_pcTaskGetName_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskGetHandle_DISABLE)) + #define traceENTER_xTaskGetHandle EvrFreeRTOSTasks_xTaskGetHandle +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskGetHandle_DISABLE)) + #define traceRETURN_xTaskGetHandle EvrFreeRTOSTasks_xTaskGetHandle_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskGetStaticBuffers_DISABLE)) + #define traceENTER_xTaskGetStaticBuffers(x,ppux,ppx) EvrFreeRTOSTasks_xTaskGetStaticBuffers(x,ppux,(uint32_t)ppx) +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskGetStaticBuffers_DISABLE)) + #define traceRETURN_xTaskGetStaticBuffers EvrFreeRTOSTasks_xTaskGetStaticBuffers_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_uxTaskGetSystemState_DISABLE)) + #define traceENTER_uxTaskGetSystemState EvrFreeRTOSTasks_uxTaskGetSystemState +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_uxTaskGetSystemState_DISABLE)) + #define traceRETURN_uxTaskGetSystemState EvrFreeRTOSTasks_uxTaskGetSystemState_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskGetIdleTaskHandle_DISABLE)) + #define traceENTER_xTaskGetIdleTaskHandle EvrFreeRTOSTasks_xTaskGetIdleTaskHandle +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskGetIdleTaskHandle_DISABLE)) + #define traceRETURN_xTaskGetIdleTaskHandle EvrFreeRTOSTasks_xTaskGetIdleTaskHandle_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskGetIdleTaskHandleForCore_DISABLE)) + #define traceENTER_xTaskGetIdleTaskHandleForCore EvrFreeRTOSTasks_xTaskGetIdleTaskHandleForCore +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskGetIdleTaskHandleForCore_DISABLE)) + #define traceRETURN_xTaskGetIdleTaskHandleForCore EvrFreeRTOSTasks_xTaskGetIdleTaskHandleForCore_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskStepTick_DISABLE)) + #define traceENTER_vTaskStepTick EvrFreeRTOSTasks_vTaskStepTick +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskStepTick_DISABLE)) + #define traceRETURN_vTaskStepTick EvrFreeRTOSTasks_vTaskStepTick_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskCatchUpTicks_DISABLE)) + #define traceENTER_xTaskCatchUpTicks EvrFreeRTOSTasks_xTaskCatchUpTicks +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskCatchUpTicks_DISABLE)) + #define traceRETURN_xTaskCatchUpTicks EvrFreeRTOSTasks_xTaskCatchUpTicks_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskAbortDelay_DISABLE)) + #define traceENTER_xTaskAbortDelay EvrFreeRTOSTasks_xTaskAbortDelay +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskAbortDelay_DISABLE)) + #define traceRETURN_xTaskAbortDelay EvrFreeRTOSTasks_xTaskAbortDelay_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskIncrementTick_DISABLE)) + #define traceENTER_xTaskIncrementTick EvrFreeRTOSTasks_xTaskIncrementTick +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskIncrementTick_DISABLE)) + #define traceRETURN_xTaskIncrementTick EvrFreeRTOSTasks_xTaskIncrementTick_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskSetApplicationTaskTag_DISABLE)) + #define traceENTER_vTaskSetApplicationTaskTag EvrFreeRTOSTasks_vTaskSetApplicationTaskTag +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskSetApplicationTaskTag_DISABLE)) + #define traceRETURN_vTaskSetApplicationTaskTag EvrFreeRTOSTasks_vTaskSetApplicationTaskTag_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskGetApplicationTaskTag_DISABLE)) + #define traceENTER_xTaskGetApplicationTaskTag EvrFreeRTOSTasks_xTaskGetApplicationTaskTag +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskGetApplicationTaskTag_DISABLE)) + #define traceRETURN_xTaskGetApplicationTaskTag EvrFreeRTOSTasks_xTaskGetApplicationTaskTag_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskGetApplicationTaskTagFromISR_DISABLE)) + #define traceENTER_xTaskGetApplicationTaskTagFromISR EvrFreeRTOSTasks_xTaskGetApplicationTaskTagFromISR +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskGetApplicationTaskTagFromISR_DISABLE)) + #define traceRETURN_xTaskGetApplicationTaskTagFromISR EvrFreeRTOSTasks_xTaskGetApplicationTaskTagFromISR_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskCallApplicationTaskHook_DISABLE)) + #define traceENTER_xTaskCallApplicationTaskHook EvrFreeRTOSTasks_xTaskCallApplicationTaskHook +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskCallApplicationTaskHook_DISABLE)) + #define traceRETURN_xTaskCallApplicationTaskHook EvrFreeRTOSTasks_xTaskCallApplicationTaskHook_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskSwitchContext_DISABLE)) + #define traceENTER_vTaskSwitchContext EvrFreeRTOSTasks_vTaskSwitchContext +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskSwitchContext_DISABLE)) + #define traceRETURN_vTaskSwitchContext EvrFreeRTOSTasks_vTaskSwitchContext_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskPlaceOnEventList_DISABLE)) + #define traceENTER_vTaskPlaceOnEventList EvrFreeRTOSTasks_vTaskPlaceOnEventList +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskPlaceOnEventList_DISABLE)) + #define traceRETURN_vTaskPlaceOnEventList EvrFreeRTOSTasks_vTaskPlaceOnEventList_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskPlaceOnUnorderedEventList_DISABLE)) + #define traceENTER_vTaskPlaceOnUnorderedEventList EvrFreeRTOSTasks_vTaskPlaceOnUnorderedEventList +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskPlaceOnUnorderedEventList_DISABLE)) + #define traceRETURN_vTaskPlaceOnUnorderedEventList EvrFreeRTOSTasks_vTaskPlaceOnUnorderedEventList_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskPlaceOnEventListRestricted_DISABLE)) + #define traceENTER_vTaskPlaceOnEventListRestricted EvrFreeRTOSTasks_vTaskPlaceOnEventListRestricted +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskPlaceOnEventListRestricted_DISABLE)) + #define traceRETURN_vTaskPlaceOnEventListRestricted EvrFreeRTOSTasks_vTaskPlaceOnEventListRestricted_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskRemoveFromEventList_DISABLE)) + #define traceENTER_xTaskRemoveFromEventList EvrFreeRTOSTasks_xTaskRemoveFromEventList +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskRemoveFromEventList_DISABLE)) + #define traceRETURN_xTaskRemoveFromEventList EvrFreeRTOSTasks_xTaskRemoveFromEventList_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskRemoveFromUnorderedEventList_DISABLE)) + #define traceENTER_vTaskRemoveFromUnorderedEventList EvrFreeRTOSTasks_vTaskRemoveFromUnorderedEventList +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskRemoveFromUnorderedEventList_DISABLE)) + #define traceRETURN_vTaskRemoveFromUnorderedEventList EvrFreeRTOSTasks_vTaskRemoveFromUnorderedEventList_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskSetTimeOutState_DISABLE)) + #define traceENTER_vTaskSetTimeOutState EvrFreeRTOSTasks_vTaskSetTimeOutState +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskSetTimeOutState_DISABLE)) + #define traceRETURN_vTaskSetTimeOutState EvrFreeRTOSTasks_vTaskSetTimeOutState_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskInternalSetTimeOutState_DISABLE)) + #define traceENTER_vTaskInternalSetTimeOutState EvrFreeRTOSTasks_vTaskInternalSetTimeOutState +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskInternalSetTimeOutState_DISABLE)) + #define traceRETURN_vTaskInternalSetTimeOutState EvrFreeRTOSTasks_vTaskInternalSetTimeOutState_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskCheckForTimeOut_DISABLE)) + #define traceENTER_xTaskCheckForTimeOut EvrFreeRTOSTasks_xTaskCheckForTimeOut +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskCheckForTimeOut_DISABLE)) + #define traceRETURN_xTaskCheckForTimeOut EvrFreeRTOSTasks_xTaskCheckForTimeOut_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskMissedYield_DISABLE)) + #define traceENTER_vTaskMissedYield EvrFreeRTOSTasks_vTaskMissedYield +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskMissedYield_DISABLE)) + #define traceRETURN_vTaskMissedYield EvrFreeRTOSTasks_vTaskMissedYield_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_uxTaskGetTaskNumber_DISABLE)) + #define traceENTER_uxTaskGetTaskNumber EvrFreeRTOSTasks_uxTaskGetTaskNumber +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_uxTaskGetTaskNumber_DISABLE)) + #define traceRETURN_uxTaskGetTaskNumber EvrFreeRTOSTasks_uxTaskGetTaskNumber_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskSetTaskNumber_DISABLE)) + #define traceENTER_vTaskSetTaskNumber EvrFreeRTOSTasks_vTaskSetTaskNumber +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskSetTaskNumber_DISABLE)) + #define traceRETURN_vTaskSetTaskNumber EvrFreeRTOSTasks_vTaskSetTaskNumber_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_eTaskConfirmSleepModeStatus_DISABLE)) + #define traceENTER_eTaskConfirmSleepModeStatus EvrFreeRTOSTasks_eTaskConfirmSleepModeStatus +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_eTaskConfirmSleepModeStatus_DISABLE)) + #define traceRETURN_eTaskConfirmSleepModeStatus EvrFreeRTOSTasks_eTaskConfirmSleepModeStatus_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskSetThreadLocalStoragePointer_DISABLE)) + #define traceENTER_vTaskSetThreadLocalStoragePointer EvrFreeRTOSTasks_vTaskSetThreadLocalStoragePointer +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskSetThreadLocalStoragePointer_DISABLE)) + #define traceRETURN_vTaskSetThreadLocalStoragePointer EvrFreeRTOSTasks_vTaskSetThreadLocalStoragePointer_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_pvTaskGetThreadLocalStoragePointer_DISABLE)) + #define traceENTER_pvTaskGetThreadLocalStoragePointer EvrFreeRTOSTasks_pvTaskGetThreadLocalStoragePointer +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_pvTaskGetThreadLocalStoragePointer_DISABLE)) + #define traceRETURN_pvTaskGetThreadLocalStoragePointer EvrFreeRTOSTasks_pvTaskGetThreadLocalStoragePointer_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskAllocateMPURegions_DISABLE)) + #define traceENTER_vTaskAllocateMPURegions EvrFreeRTOSTasks_vTaskAllocateMPURegions +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskAllocateMPURegions_DISABLE)) + #define traceRETURN_vTaskAllocateMPURegions EvrFreeRTOSTasks_vTaskAllocateMPURegions_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskGetInfo_DISABLE)) + #define traceENTER_vTaskGetInfo EvrFreeRTOSTasks_vTaskGetInfo +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskGetInfo_DISABLE)) + #define traceRETURN_vTaskGetInfo EvrFreeRTOSTasks_vTaskGetInfo_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_uxTaskGetStackHighWaterMark2_DISABLE)) + #define traceENTER_uxTaskGetStackHighWaterMark2 EvrFreeRTOSTasks_uxTaskGetStackHighWaterMark2 +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_uxTaskGetStackHighWaterMark2_DISABLE)) + #define traceRETURN_uxTaskGetStackHighWaterMark2 EvrFreeRTOSTasks_uxTaskGetStackHighWaterMark2_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_uxTaskGetStackHighWaterMark_DISABLE)) + #define traceENTER_uxTaskGetStackHighWaterMark EvrFreeRTOSTasks_uxTaskGetStackHighWaterMark +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_uxTaskGetStackHighWaterMark_DISABLE)) + #define traceRETURN_uxTaskGetStackHighWaterMark EvrFreeRTOSTasks_uxTaskGetStackHighWaterMark_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskGetCurrentTaskHandle_DISABLE)) + #define traceENTER_xTaskGetCurrentTaskHandle EvrFreeRTOSTasks_xTaskGetCurrentTaskHandle +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskGetCurrentTaskHandle_DISABLE)) + #define traceRETURN_xTaskGetCurrentTaskHandle EvrFreeRTOSTasks_xTaskGetCurrentTaskHandle_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskGetCurrentTaskHandleForCore_DISABLE)) + #define traceENTER_xTaskGetCurrentTaskHandleForCore EvrFreeRTOSTasks_xTaskGetCurrentTaskHandleForCore +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskGetCurrentTaskHandleForCore_DISABLE)) + #define traceRETURN_xTaskGetCurrentTaskHandleForCore EvrFreeRTOSTasks_xTaskGetCurrentTaskHandleForCore_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskGetSchedulerState_DISABLE)) + #define traceENTER_xTaskGetSchedulerState EvrFreeRTOSTasks_xTaskGetSchedulerState +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskGetSchedulerState_DISABLE)) + #define traceRETURN_xTaskGetSchedulerState EvrFreeRTOSTasks_xTaskGetSchedulerState_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskPriorityInherit_DISABLE)) + #define traceENTER_xTaskPriorityInherit EvrFreeRTOSTasks_xTaskPriorityInherit +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskPriorityInherit_DISABLE)) + #define traceRETURN_xTaskPriorityInherit EvrFreeRTOSTasks_xTaskPriorityInherit_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskPriorityDisinherit_DISABLE)) + #define traceENTER_xTaskPriorityDisinherit EvrFreeRTOSTasks_xTaskPriorityDisinherit +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskPriorityDisinherit_DISABLE)) + #define traceRETURN_xTaskPriorityDisinherit EvrFreeRTOSTasks_xTaskPriorityDisinherit_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskPriorityDisinheritAfterTimeout_DISABLE)) + #define traceENTER_vTaskPriorityDisinheritAfterTimeout EvrFreeRTOSTasks_vTaskPriorityDisinheritAfterTimeout +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskPriorityDisinheritAfterTimeout_DISABLE)) + #define traceRETURN_vTaskPriorityDisinheritAfterTimeout EvrFreeRTOSTasks_vTaskPriorityDisinheritAfterTimeout_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskYieldWithinAPI_DISABLE)) + #define traceENTER_vTaskYieldWithinAPI EvrFreeRTOSTasks_vTaskYieldWithinAPI +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskYieldWithinAPI_DISABLE)) + #define traceRETURN_vTaskYieldWithinAPI EvrFreeRTOSTasks_vTaskYieldWithinAPI_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskEnterCritical_DISABLE)) + #define traceENTER_vTaskEnterCritical EvrFreeRTOSTasks_vTaskEnterCritical +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskEnterCritical_DISABLE)) + #define traceRETURN_vTaskEnterCritical EvrFreeRTOSTasks_vTaskEnterCritical_Return +#endif -/** - \brief Event on stream buffer send when data is not copied into the buffer (Error) - \param[in] pxStreamBuffer pointer to Stream Buffer object handle. -*/ -extern void EvrFreeRTOSStreamBuf_StreamBufferSendFailed (StreamBuffer_t pxStreamBuffer); +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskEnterCriticalFromISR_DISABLE)) + #define traceENTER_vTaskEnterCriticalFromISR EvrFreeRTOSTasks_vTaskEnterCriticalFromISR +#endif -/** - \brief Event on stream buffer send from ISR when data is successfully copied into the buffer (Op) - \param[in] pxStreamBuffer pointer to Stream Buffer object handle. - \param[in] xBytesSent number of bytes copied into the buffer -*/ -extern void EvrFreeRTOSStreamBuf_StreamBufferSendFromIsr (StreamBuffer_t pxStreamBuffer, uint32_t xBytesSent); +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskEnterCriticalFromISR_DISABLE)) + #define traceRETURN_vTaskEnterCriticalFromISR EvrFreeRTOSTasks_vTaskEnterCriticalFromISR_Return +#endif -/** - \brief Event on stream buffer receive when buffer is empty and receiving task is blocked (Op) - \param[in] pxStreamBuffer pointer to Stream Buffer object handle. -*/ -extern void EvrFreeRTOSStreamBuf_StreamBufferBlockingOnReceive (StreamBuffer_t pxStreamBuffer); +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskExitCritical_DISABLE)) + #define traceENTER_vTaskExitCritical EvrFreeRTOSTasks_vTaskExitCritical +#endif -/** - \brief Event on stream buffer receive when data is successfully copied from the buffer (Op) - \param[in] pxStreamBuffer pointer to Stream Buffer object handle. - \param[in] xReceivedLength number of bytes copied from the buffer -*/ -extern void EvrFreeRTOSStreamBuf_StreamBufferReceive (StreamBuffer_t pxStreamBuffer, uint32_t xReceivedLength); +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskExitCritical_DISABLE)) + #define traceRETURN_vTaskExitCritical EvrFreeRTOSTasks_vTaskExitCritical_Return +#endif -/** - \brief Event on stream buffer receive when data is not copied from the buffer (Error) - \param[in] pxStreamBuffer pointer to Stream Buffer object handle. -*/ -extern void EvrFreeRTOSStreamBuf_StreamBufferReceiveFailed (StreamBuffer_t pxStreamBuffer); +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskExitCriticalFromISR_DISABLE)) + #define traceENTER_vTaskExitCriticalFromISR EvrFreeRTOSTasks_vTaskExitCriticalFromISR +#endif -/** - \brief Event on stream buffer receive from ISR when data is successfully copied from the buffer (Op) - \param[in] pxStreamBuffer pointer to Stream Buffer object handle. - \param[in] xReceivedLength number of bytes copied from the buffer -*/ -extern void EvrFreeRTOSStreamBuf_StreamBufferReceiveFromIsr (StreamBuffer_t pxStreamBuffer, uint32_t xReceivedLength); +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskExitCriticalFromISR_DISABLE)) + #define traceRETURN_vTaskExitCriticalFromISR EvrFreeRTOSTasks_vTaskExitCriticalFromISR_Return +#endif -/** - \brief Event on heap memory block allocation (Op) - \param[in] pvAddress pointer to memory block. - \param[in] uiSize memory block size. -*/ -extern void EvrFreeRTOSHeap_Malloc (void *pvAddress, uint32_t uiSize); +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskListTasks_DISABLE)) + #define traceENTER_vTaskListTasks EvrFreeRTOSTasks_vTaskListTasks +#endif -/** - \brief Event on heap memory block free (Op) - \param[in] pvAddress pointer to memory block. - \param[in] uiSize memory block size. -*/ -extern void EvrFreeRTOSHeap_Free (void *pvAddress, uint32_t uiSize); +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskListTasks_DISABLE)) + #define traceRETURN_vTaskListTasks EvrFreeRTOSTasks_vTaskListTasks_Return +#endif +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskGetRunTimeStatistics_DISABLE)) + #define traceENTER_vTaskGetRunTimeStatistics EvrFreeRTOSTasks_vTaskGetRunTimeStatistics +#endif -/* Tasks */ +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskGetRunTimeStatistics_DISABLE)) + #define traceRETURN_vTaskGetRunTimeStatistics EvrFreeRTOSTasks_vTaskGetRunTimeStatistics_Return +#endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_CREATE_DISABLE)) - #define traceTASK_CREATE(px) EvrFreeRTOSTasks_TaskCreate(px) +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_uxTaskResetEventItemValue_DISABLE)) + #define traceENTER_uxTaskResetEventItemValue EvrFreeRTOSTasks_uxTaskResetEventItemValue #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_CREATE_FAILED_DISABLE)) - #define traceTASK_CREATE_FAILED() EvrFreeRTOSTasks_TaskCreateFailed() +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_uxTaskResetEventItemValue_DISABLE)) + #define traceRETURN_uxTaskResetEventItemValue EvrFreeRTOSTasks_uxTaskResetEventItemValue_Return #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_DELETE_DISABLE)) - #define traceTASK_DELETE(px) EvrFreeRTOSTasks_TaskDelete(px) +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_pvTaskIncrementMutexHeldCount_DISABLE)) + #define traceENTER_pvTaskIncrementMutexHeldCount EvrFreeRTOSTasks_pvTaskIncrementMutexHeldCount #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_DELAY_UNTIL_DISABLE)) - #define traceTASK_DELAY_UNTIL(x) EvrFreeRTOSTasks_TaskDelayUntil(x) +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_pvTaskIncrementMutexHeldCount_DISABLE)) + #define traceRETURN_pvTaskIncrementMutexHeldCount EvrFreeRTOSTasks_pvTaskIncrementMutexHeldCount_Return #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_DELAY_DISABLE)) - #define traceTASK_DELAY() EvrFreeRTOSTasks_TaskDelay(xTicksToDelay) +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_ulTaskGenericNotifyTake_DISABLE)) + #define traceENTER_ulTaskGenericNotifyTake EvrFreeRTOSTasks_ulTaskGenericNotifyTake #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_PRIORITY_SET_DISABLE)) - #define traceTASK_PRIORITY_SET(px,ux) EvrFreeRTOSTasks_TaskPrioritySet(px,ux) +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_ulTaskGenericNotifyTake_DISABLE)) + #define traceRETURN_ulTaskGenericNotifyTake EvrFreeRTOSTasks_ulTaskGenericNotifyTake_Return #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_SUSPEND_DISABLE)) - #define traceTASK_SUSPEND(px) EvrFreeRTOSTasks_TaskSuspend(px) +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskGenericNotifyWait_DISABLE)) + #define traceENTER_xTaskGenericNotifyWait EvrFreeRTOSTasks_xTaskGenericNotifyWait #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_RESUME_DISABLE)) - #define traceTASK_RESUME(px) EvrFreeRTOSTasks_TaskResume(px) +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskGenericNotifyWait_DISABLE)) + #define traceRETURN_xTaskGenericNotifyWait EvrFreeRTOSTasks_xTaskGenericNotifyWait_Return #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_RESUME_FROM_ISR_DISABLE)) - #define traceTASK_RESUME_FROM_ISR(px) EvrFreeRTOSTasks_TaskResumeFromIsr(px) +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskGenericNotify_DISABLE)) + #define traceENTER_xTaskGenericNotify EvrFreeRTOSTasks_xTaskGenericNotify #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_INCREMENT_TICK_DISABLE)) - #define traceTASK_INCREMENT_TICK(x) EvrFreeRTOSTasks_TaskIncrementTick(x) +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskGenericNotify_DISABLE)) + #define traceRETURN_xTaskGenericNotify EvrFreeRTOSTasks_xTaskGenericNotify_Return #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceINCREASE_TICK_COUNT_DISABLE)) - #define traceINCREASE_TICK_COUNT(x) EvrFreeRTOSTasks_IncreaseTickCount(x) +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskGenericNotifyFromISR_DISABLE)) + #define traceENTER_xTaskGenericNotifyFromISR EvrFreeRTOSTasks_xTaskGenericNotifyFromISR #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_SWITCHED_OUT_DISABLE)) - #define traceTASK_SWITCHED_OUT() EvrFreeRTOSTasks_TaskSwitchedOut(pxCurrentTCB) +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskGenericNotifyFromISR_DISABLE)) + #define traceRETURN_xTaskGenericNotifyFromISR EvrFreeRTOSTasks_xTaskGenericNotifyFromISR_Return #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_SWITCHED_IN_DISABLE)) - #define traceTASK_SWITCHED_IN() EvrFreeRTOSTasks_TaskSwitchedIn(pxCurrentTCB, uxTopReadyPriority) +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskGenericNotifyGiveFromISR_DISABLE)) + #define traceENTER_vTaskGenericNotifyGiveFromISR EvrFreeRTOSTasks_vTaskGenericNotifyGiveFromISR #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_PRIORITY_INHERIT_DISABLE)) - #define traceTASK_PRIORITY_INHERIT(px,ux) EvrFreeRTOSTasks_TaskPriorityInherit(px,ux) +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskGenericNotifyGiveFromISR_DISABLE)) + #define traceRETURN_vTaskGenericNotifyGiveFromISR EvrFreeRTOSTasks_vTaskGenericNotifyGiveFromISR_Return #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_PRIORITY_DISINHERIT_DISABLE)) - #define traceTASK_PRIORITY_DISINHERIT(px,ux) EvrFreeRTOSTasks_TaskPriorityDisinherit(px,ux) +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskGenericNotifyStateClear_DISABLE)) + #define traceENTER_xTaskGenericNotifyStateClear EvrFreeRTOSTasks_xTaskGenericNotifyStateClear #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceMOVED_TASK_TO_READY_STATE_DISABLE)) - #define traceMOVED_TASK_TO_READY_STATE(px) EvrFreeRTOSTasks_MovedTaskToReadyState(px) +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskGenericNotifyStateClear_DISABLE)) + #define traceRETURN_xTaskGenericNotifyStateClear EvrFreeRTOSTasks_xTaskGenericNotifyStateClear_Return #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(tracePOST_MOVED_TASK_TO_READY_STATE_DISABLE)) - #define tracePOST_MOVED_TASK_TO_READY_STATE(px) EvrFreeRTOSTasks_PostMovedTaskToReadyState(px) +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_ulTaskGenericNotifyValueClear_DISABLE)) + #define traceENTER_ulTaskGenericNotifyValueClear EvrFreeRTOSTasks_ulTaskGenericNotifyValueClear #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceLOW_POWER_IDLE_BEGIN_DISABLE)) - #define traceLOW_POWER_IDLE_BEGIN() EvrFreeRTOSTasks_LowPowerIdleBegin(xExpectedIdleTime) +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_ulTaskGenericNotifyValueClear_DISABLE)) + #define traceRETURN_ulTaskGenericNotifyValueClear EvrFreeRTOSTasks_ulTaskGenericNotifyValueClear_Return #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceLOW_POWER_IDLE_END_DISABLE)) - #define traceLOW_POWER_IDLE_END() EvrFreeRTOSTasks_LowPowerIdleEnd() +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_ulTaskGetRunTimeCounter_DISABLE)) + #define traceENTER_ulTaskGetRunTimeCounter EvrFreeRTOSTasks_ulTaskGetRunTimeCounter #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_NOTIFY_TAKE_BLOCK_DISABLE)) - #define traceTASK_NOTIFY_TAKE_BLOCK(ux) EvrFreeRTOSTasks_TaskNotifyTakeBlock(ux, xTicksToWait) +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_ulTaskGetRunTimeCounter_DISABLE)) + #define traceRETURN_ulTaskGetRunTimeCounter EvrFreeRTOSTasks_ulTaskGetRunTimeCounter_Return #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_NOTIFY_TAKE_DISABLE)) - #define traceTASK_NOTIFY_TAKE(ux) EvrFreeRTOSTasks_TaskNotifyTake(ux, pxCurrentTCB->ulNotifiedValue[ux]) +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_ulTaskGetRunTimePercent_DISABLE)) + #define traceENTER_ulTaskGetRunTimePercent EvrFreeRTOSTasks_ulTaskGetRunTimePercent #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_NOTIFY_WAIT_BLOCK_DISABLE)) - #define traceTASK_NOTIFY_WAIT_BLOCK(ux) EvrFreeRTOSTasks_TaskNotifyWaitBlock(ux, xTicksToWait) +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_ulTaskGetRunTimePercent_DISABLE)) + #define traceRETURN_ulTaskGetRunTimePercent EvrFreeRTOSTasks_ulTaskGetRunTimePercent_Return #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_NOTIFY_WAIT_DISABLE)) - #define traceTASK_NOTIFY_WAIT(ux) EvrFreeRTOSTasks_TaskNotifyWait(ux, pxCurrentTCB->ulNotifiedValue[ux]) +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_ulTaskGetIdleRunTimeCounter_DISABLE)) + #define traceENTER_ulTaskGetIdleRunTimeCounter EvrFreeRTOSTasks_ulTaskGetIdleRunTimeCounter #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_NOTIFY_DISABLE)) - #define traceTASK_NOTIFY(ux) EvrFreeRTOSTasks_TaskNotify(pxTCB, ux, eAction, pxTCB->ulNotifiedValue[ux]) +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_ulTaskGetIdleRunTimeCounter_DISABLE)) + #define traceRETURN_ulTaskGetIdleRunTimeCounter EvrFreeRTOSTasks_ulTaskGetIdleRunTimeCounter_Return #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_NOTIFY_FROM_ISR_DISABLE)) - #define traceTASK_NOTIFY_FROM_ISR(ux) EvrFreeRTOSTasks_TaskNotifyFromIsr(pxTCB, ux, eAction, pxTCB->ulNotifiedValue[ux]) +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_ulTaskGetIdleRunTimePercent_DISABLE)) + #define traceENTER_ulTaskGetIdleRunTimePercent EvrFreeRTOSTasks_ulTaskGetIdleRunTimePercent #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_NOTIFY_GIVE_FROM_ISR_DISABLE)) - #define traceTASK_NOTIFY_GIVE_FROM_ISR(ux) EvrFreeRTOSTasks_TaskNotifyGiveFromIsr(pxTCB, ux, pxTCB->ulNotifiedValue[ux]) +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_ulTaskGetIdleRunTimePercent_DISABLE)) + #define traceRETURN_ulTaskGetIdleRunTimePercent EvrFreeRTOSTasks_ulTaskGetIdleRunTimePercent_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskGetMPUSettings_DISABLE)) + #define traceENTER_xTaskGetMPUSettings EvrFreeRTOSTasks_xTaskGetMPUSettings +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskGetMPUSettings_DISABLE)) + #define traceRETURN_xTaskGetMPUSettings EvrFreeRTOSTasks_xTaskGetMPUSettings_Return #endif @@ -847,6 +3248,167 @@ extern void EvrFreeRTOSHeap_Free (void *pvAddress, uint32_t uiSize); #endif +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTimerCreateTimerTask_DISABLE)) + #define traceENTER_xTimerCreateTimerTask EvrFreeRTOSTimers_xTimerCreateTimerTask +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTimerCreateTimerTask_DISABLE)) + #define traceRETURN_xTimerCreateTimerTask EvrFreeRTOSTimers_xTimerCreateTimerTask_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTimerCreate_DISABLE)) + #define traceENTER_xTimerCreate EvrFreeRTOSTimers_xTimerCreate +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTimerCreate_DISABLE)) + #define traceRETURN_xTimerCreate EvrFreeRTOSTimers_xTimerCreate_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTimerCreateStatic_DISABLE)) + #define traceENTER_xTimerCreateStatic EvrFreeRTOSTimers_xTimerCreateStatic +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTimerCreateStatic_DISABLE)) + #define traceRETURN_xTimerCreateStatic EvrFreeRTOSTimers_xTimerCreateStatic_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTimerGenericCommandFromTask_DISABLE)) + #define traceENTER_xTimerGenericCommandFromTask EvrFreeRTOSTimers_xTimerGenericCommandFromTask +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTimerGenericCommandFromTask_DISABLE)) + #define traceRETURN_xTimerGenericCommandFromTask EvrFreeRTOSTimers_xTimerGenericCommandFromTask_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTimerGenericCommandFromISR_DISABLE)) + #define traceENTER_xTimerGenericCommandFromISR EvrFreeRTOSTimers_xTimerGenericCommandFromISR +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTimerGenericCommandFromISR_DISABLE)) + #define traceRETURN_xTimerGenericCommandFromISR EvrFreeRTOSTimers_xTimerGenericCommandFromISR_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTimerGetTimerDaemonTaskHandle_DISABLE)) + #define traceENTER_xTimerGetTimerDaemonTaskHandle EvrFreeRTOSTimers_xTimerGetTimerDaemonTaskHandle +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTimerGetTimerDaemonTaskHandle_DISABLE)) + #define traceRETURN_xTimerGetTimerDaemonTaskHandle EvrFreeRTOSTimers_xTimerGetTimerDaemonTaskHandle_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTimerGetPeriod_DISABLE)) + #define traceENTER_xTimerGetPeriod EvrFreeRTOSTimers_xTimerGetPeriod +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTimerGetPeriod_DISABLE)) + #define traceRETURN_xTimerGetPeriod EvrFreeRTOSTimers_xTimerGetPeriod_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTimerSetReloadMode_DISABLE)) + #define traceENTER_vTimerSetReloadMode EvrFreeRTOSTimers_vTimerSetReloadMode +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTimerSetReloadMode_DISABLE)) + #define traceRETURN_vTimerSetReloadMode EvrFreeRTOSTimers_vTimerSetReloadMode_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTimerGetReloadMode_DISABLE)) + #define traceENTER_xTimerGetReloadMode EvrFreeRTOSTimers_xTimerGetReloadMode +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTimerGetReloadMode_DISABLE)) + #define traceRETURN_xTimerGetReloadMode EvrFreeRTOSTimers_xTimerGetReloadMode_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_uxTimerGetReloadMode_DISABLE)) + #define traceENTER_uxTimerGetReloadMode EvrFreeRTOSTimers_uxTimerGetReloadMode +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_uxTimerGetReloadMode_DISABLE)) + #define traceRETURN_uxTimerGetReloadMode EvrFreeRTOSTimers_uxTimerGetReloadMode_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTimerGetExpiryTime_DISABLE)) + #define traceENTER_xTimerGetExpiryTime EvrFreeRTOSTimers_xTimerGetExpiryTime +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTimerGetExpiryTime_DISABLE)) + #define traceRETURN_xTimerGetExpiryTime EvrFreeRTOSTimers_xTimerGetExpiryTime_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTimerGetStaticBuffer_DISABLE)) + #define traceENTER_xTimerGetStaticBuffer(x,ppx) EvrFreeRTOSTimers_xTimerGetStaticBuffer(x,(uint32_t)ppx) +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTimerGetStaticBuffer_DISABLE)) + #define traceRETURN_xTimerGetStaticBuffer EvrFreeRTOSTimers_xTimerGetStaticBuffer_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_pcTimerGetName_DISABLE)) + #define traceENTER_pcTimerGetName EvrFreeRTOSTimers_pcTimerGetName +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_pcTimerGetName_DISABLE)) + #define traceRETURN_pcTimerGetName EvrFreeRTOSTimers_pcTimerGetName_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTimerIsTimerActive_DISABLE)) + #define traceENTER_xTimerIsTimerActive EvrFreeRTOSTimers_xTimerIsTimerActive +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTimerIsTimerActive_DISABLE)) + #define traceRETURN_xTimerIsTimerActive EvrFreeRTOSTimers_xTimerIsTimerActive_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_pvTimerGetTimerID_DISABLE)) + #define traceENTER_pvTimerGetTimerID EvrFreeRTOSTimers_pvTimerGetTimerID +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_pvTimerGetTimerID_DISABLE)) + #define traceRETURN_pvTimerGetTimerID EvrFreeRTOSTimers_pvTimerGetTimerID_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTimerSetTimerID_DISABLE)) + #define traceENTER_vTimerSetTimerID EvrFreeRTOSTimers_vTimerSetTimerID +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTimerSetTimerID_DISABLE)) + #define traceRETURN_vTimerSetTimerID EvrFreeRTOSTimers_vTimerSetTimerID_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTimerPendFunctionCallFromISR_DISABLE)) + #define traceENTER_xTimerPendFunctionCallFromISR EvrFreeRTOSTimers_xTimerPendFunctionCallFromISR +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTimerPendFunctionCallFromISR_DISABLE)) + #define traceRETURN_xTimerPendFunctionCallFromISR EvrFreeRTOSTimers_xTimerPendFunctionCallFromISR_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTimerPendFunctionCall_DISABLE)) + #define traceENTER_xTimerPendFunctionCall EvrFreeRTOSTimers_xTimerPendFunctionCall +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTimerPendFunctionCall_DISABLE)) + #define traceRETURN_xTimerPendFunctionCall EvrFreeRTOSTimers_xTimerPendFunctionCall_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_uxTimerGetTimerNumber_DISABLE)) + #define traceENTER_uxTimerGetTimerNumber EvrFreeRTOSTimers_uxTimerGetTimerNumber +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_uxTimerGetTimerNumber_DISABLE)) + #define traceRETURN_uxTimerGetTimerNumber EvrFreeRTOSTimers_uxTimerGetTimerNumber_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTimerSetTimerNumber_DISABLE)) + #define traceENTER_vTimerSetTimerNumber EvrFreeRTOSTimers_vTimerSetTimerNumber +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTimerSetTimerNumber_DISABLE)) + #define traceRETURN_vTimerSetTimerNumber EvrFreeRTOSTimers_vTimerSetTimerNumber_Return +#endif + + /* Event Groups */ #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceEVENT_GROUP_CREATE_DISABLE)) @@ -894,6 +3456,127 @@ extern void EvrFreeRTOSHeap_Free (void *pvAddress, uint32_t uiSize); #endif +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xEventGroupCreateStatic_DISABLE)) + #define traceENTER_xEventGroupCreateStatic EvrFreeRTOSEventGroups_xEventGroupCreateStatic +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xEventGroupCreateStatic_DISABLE)) + #define traceRETURN_xEventGroupCreateStatic EvrFreeRTOSEventGroups_xEventGroupCreateStatic_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xEventGroupCreate_DISABLE)) + #define traceENTER_xEventGroupCreate EvrFreeRTOSEventGroups_xEventGroupCreate +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xEventGroupCreate_DISABLE)) + #define traceRETURN_xEventGroupCreate EvrFreeRTOSEventGroups_xEventGroupCreate_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xEventGroupSync_DISABLE)) + #define traceENTER_xEventGroupSync EvrFreeRTOSEventGroups_xEventGroupSync +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xEventGroupSync_DISABLE)) + #define traceRETURN_xEventGroupSync EvrFreeRTOSEventGroups_xEventGroupSync_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xEventGroupWaitBits_DISABLE)) + #define traceENTER_xEventGroupWaitBits EvrFreeRTOSEventGroups_xEventGroupWaitBits +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xEventGroupWaitBits_DISABLE)) + #define traceRETURN_xEventGroupWaitBits EvrFreeRTOSEventGroups_xEventGroupWaitBits_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xEventGroupClearBits_DISABLE)) + #define traceENTER_xEventGroupClearBits EvrFreeRTOSEventGroups_xEventGroupClearBits +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xEventGroupClearBits_DISABLE)) + #define traceRETURN_xEventGroupClearBits EvrFreeRTOSEventGroups_xEventGroupClearBits_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xEventGroupClearBitsFromISR_DISABLE)) + #define traceENTER_xEventGroupClearBitsFromISR EvrFreeRTOSEventGroups_xEventGroupClearBitsFromISR +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xEventGroupClearBitsFromISR_DISABLE)) + #define traceRETURN_xEventGroupClearBitsFromISR EvrFreeRTOSEventGroups_xEventGroupClearBitsFromISR_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xEventGroupGetBitsFromISR_DISABLE)) + #define traceENTER_xEventGroupGetBitsFromISR EvrFreeRTOSEventGroups_xEventGroupGetBitsFromISR +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xEventGroupGetBitsFromISR_DISABLE)) + #define traceRETURN_xEventGroupGetBitsFromISR EvrFreeRTOSEventGroups_xEventGroupGetBitsFromISR_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xEventGroupSetBits_DISABLE)) + #define traceENTER_xEventGroupSetBits EvrFreeRTOSEventGroups_xEventGroupSetBits +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xEventGroupSetBits_DISABLE)) + #define traceRETURN_xEventGroupSetBits EvrFreeRTOSEventGroups_xEventGroupSetBits_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vEventGroupDelete_DISABLE)) + #define traceENTER_vEventGroupDelete EvrFreeRTOSEventGroups_vEventGroupDelete +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vEventGroupDelete_DISABLE)) + #define traceRETURN_vEventGroupDelete EvrFreeRTOSEventGroups_vEventGroupDelete_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xEventGroupGetStaticBuffer_DISABLE)) + #define traceENTER_xEventGroupGetStaticBuffer(x,ppx) EvrFreeRTOSEventGroups_xEventGroupGetStaticBuffer(x,(uint32_t)ppx) +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xEventGroupGetStaticBuffer_DISABLE)) + #define traceRETURN_xEventGroupGetStaticBuffer EvrFreeRTOSEventGroups_xEventGroupGetStaticBuffer_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vEventGroupSetBitsCallback_DISABLE)) + #define traceENTER_vEventGroupSetBitsCallback EvrFreeRTOSEventGroups_vEventGroupSetBitsCallback +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vEventGroupSetBitsCallback_DISABLE)) + #define traceRETURN_vEventGroupSetBitsCallback EvrFreeRTOSEventGroups_vEventGroupSetBitsCallback_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vEventGroupClearBitsCallback_DISABLE)) + #define traceENTER_vEventGroupClearBitsCallback EvrFreeRTOSEventGroups_vEventGroupClearBitsCallback +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vEventGroupClearBitsCallback_DISABLE)) + #define traceRETURN_vEventGroupClearBitsCallback EvrFreeRTOSEventGroups_vEventGroupClearBitsCallback_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xEventGroupSetBitsFromISR_DISABLE)) + #define traceENTER_xEventGroupSetBitsFromISR EvrFreeRTOSEventGroups_xEventGroupSetBitsFromISR +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xEventGroupSetBitsFromISR_DISABLE)) + #define traceRETURN_xEventGroupSetBitsFromISR EvrFreeRTOSEventGroups_xEventGroupSetBitsFromISR_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_uxEventGroupGetNumber_DISABLE)) + #define traceENTER_uxEventGroupGetNumber EvrFreeRTOSEventGroups_uxEventGroupGetNumber +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_uxEventGroupGetNumber_DISABLE)) + #define traceRETURN_uxEventGroupGetNumber EvrFreeRTOSEventGroups_uxEventGroupGetNumber_Return +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vEventGroupSetNumber_DISABLE)) + #define traceENTER_vEventGroupSetNumber EvrFreeRTOSEventGroups_vEventGroupSetNumber +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vEventGroupSetNumber_DISABLE)) + #define traceRETURN_vEventGroupSetNumber EvrFreeRTOSEventGroups_vEventGroupSetNumber_Return +#endif + + /* Stream Buffer */ #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceSTREAM_BUFFER_CREATE_FAILED_DISABLE)) @@ -968,4 +3651,30 @@ extern void EvrFreeRTOSHeap_Free (void *pvAddress, uint32_t uiSize); #undef EventGroup_t #undef StreamBuffer_t +#undef TaskHandle_t +#undef TimerHandle_t +#undef ConstTaskHandle_t +#undef EventGroupHandle_t +#undef TaskHookFunction_t +#undef TimerCallbackFunction_t + +#undef StaticTask_t +#undef StaticTimer_t +#undef StaticEventGroup_t +#undef TaskParameters_t +#undef TaskStatus_t +#undef List_t +#undef ListItem_t +#undef TimeOut_t +#undef MemoryRegion_t + +#undef BaseType_t +#undef UBaseType_t +#undef eTaskState +#undef StackType_t +#undef TickType_t +#undef EventBits_t +#undef eSleepModeStatus +#undef eNotifyAction + #endif /* FREERTOS_EVR_H_ */ diff --git a/CMSIS/RTOS2/FreeRTOS/Source/freertos_evr.c b/CMSIS/RTOS2/FreeRTOS/Source/freertos_evr.c index afc803ee..4004e556 100644 --- a/CMSIS/RTOS2/FreeRTOS/Source/freertos_evr.c +++ b/CMSIS/RTOS2/FreeRTOS/Source/freertos_evr.c @@ -19,12 +19,44 @@ * Purpose: FreeRTOS Event Recorder implementation * *---------------------------------------------------------------------------*/ - -#include "FreeRTOS.h" // ARM.FreeRTOS::RTOS:Core -#include "task.h" // ARM.FreeRTOS::RTOS:Core -#include "semphr.h" // ARM.FreeRTOS::RTOS:Core -#include "event_groups.h" // ARM.FreeRTOS::RTOS:Event Groups -#include "stream_buffer.h" // ARM.FreeRTOS::RTOS:Stream Buffer +#include +#include + +#include "FreeRTOSConfig.h" + +/* Temporarily define FreeRTOS object types */ +#define TCB_t void* +#define Queue_t void* +#define Timer_t void* +#define PendedFunction_t void* +#define EventGroup_t void* +#define StreamBuffer_t void* + +#define TaskHandle_t void* +#define TimerHandle_t void* +#define ConstTaskHandle_t void* +#define EventGroupHandle_t void* +#define TaskHookFunction_t void* +#define TimerCallbackFunction_t void* + +#define StaticTask_t void +#define StaticTimer_t void +#define StaticEventGroup_t void +#define TaskParameters_t void +#define TaskStatus_t void +#define List_t void +#define ListItem_t void +#define TimeOut_t void +#define MemoryRegion_t void + +#define BaseType_t long +#define UBaseType_t uint32_t +#define eTaskState uint32_t +#define StackType_t uint32_t +#define TickType_t uint32_t +#define EventBits_t uint32_t +#define eSleepModeStatus uint32_t +#define eNotifyAction uint32_t /* FreeRTOS component number */ #define EvtFreeRTOSTasksNo (0xF0U) @@ -99,33 +131,225 @@ #endif /* !defined(EVR_FREERTOS_DISABLE) */ /* Event IDs for "FreeRTOS Tasks" */ -#define EvtFreeRTOSTasks_TaskTrackingReset EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0xFFU) -#define EvtFreeRTOSTasks_TaskCreate EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x00U) -#define EvtFreeRTOSTasks_TaskCreateFailed EventID(EventLevelError, EvtFreeRTOSTasksNo, 0x01U) -#define EvtFreeRTOSTasks_TaskDelete EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x02U) -#define EvtFreeRTOSTasks_TaskDelayUntil EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x03U) -#define EvtFreeRTOSTasks_TaskDelay EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x04U) -#define EvtFreeRTOSTasks_TaskPrioritySet EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x05U) -#define EvtFreeRTOSTasks_TaskSuspend EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x06U) -#define EvtFreeRTOSTasks_TaskResume EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x07U) -#define EvtFreeRTOSTasks_TaskResumeFromIsr EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x08U) -#define EvtFreeRTOSTasks_TaskIncrementTick EventID(EventLevelDetail, EvtFreeRTOSTasksNo, 0x09U) -#define EvtFreeRTOSTasks_IncreaseTickCount EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x0AU) -#define EvtFreeRTOSTasks_TaskSwitchedOut EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x0BU) -#define EvtFreeRTOSTasks_TaskSwitchedIn EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x0CU) -#define EvtFreeRTOSTasks_TaskPriorityInherit EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x0DU) -#define EvtFreeRTOSTasks_TaskPriorityDisinherit EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x0EU) -#define EvtFreeRTOSTasks_MovedTaskToReadyState EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x0FU) -#define EvtFreeRTOSTasks_PostMovedTaskToReadyState EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x10U) -#define EvtFreeRTOSTasks_LowPowerIdleBegin EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x11U) -#define EvtFreeRTOSTasks_LowPowerIdleEnd EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x12U) -#define EvtFreeRTOSTasks_TaskNotifyTakeBlock EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x13U) -#define EvtFreeRTOSTasks_TaskNotifyTake EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x14U) -#define EvtFreeRTOSTasks_TaskNotifyWaitBlock EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x15U) -#define EvtFreeRTOSTasks_TaskNotifyWait EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x16U) -#define EvtFreeRTOSTasks_TaskNotify EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x17U) -#define EvtFreeRTOSTasks_TaskNotifyFromIsr EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x18U) -#define EvtFreeRTOSTasks_TaskNotifyGiveFromIsr EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x19U) +#define EvtFreeRTOSTasks_TaskTrackingReset EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0xFFU) +#define EvtFreeRTOSTasks_TaskCreate EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x00U) +#define EvtFreeRTOSTasks_TaskCreateFailed EventID(EventLevelError, EvtFreeRTOSTasksNo, 0x01U) +#define EvtFreeRTOSTasks_TaskDelete EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x02U) +#define EvtFreeRTOSTasks_TaskDelayUntil EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x03U) +#define EvtFreeRTOSTasks_TaskDelay EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x04U) +#define EvtFreeRTOSTasks_TaskPrioritySet EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x05U) +#define EvtFreeRTOSTasks_TaskSuspend EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x06U) +#define EvtFreeRTOSTasks_TaskResume EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x07U) +#define EvtFreeRTOSTasks_TaskResumeFromIsr EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x08U) +#define EvtFreeRTOSTasks_TaskIncrementTick EventID(EventLevelDetail, EvtFreeRTOSTasksNo, 0x09U) +#define EvtFreeRTOSTasks_IncreaseTickCount EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x0AU) +#define EvtFreeRTOSTasks_TaskSwitchedOut EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x0BU) +#define EvtFreeRTOSTasks_TaskSwitchedIn EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x0CU) +#define EvtFreeRTOSTasks_TaskPriorityInherit EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x0DU) +#define EvtFreeRTOSTasks_TaskPriorityDisinherit EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x0EU) +#define EvtFreeRTOSTasks_MovedTaskToReadyState EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x0FU) +#define EvtFreeRTOSTasks_PostMovedTaskToReadyState EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x10U) +#define EvtFreeRTOSTasks_LowPowerIdleBegin EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x11U) +#define EvtFreeRTOSTasks_LowPowerIdleEnd EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x12U) +#define EvtFreeRTOSTasks_TaskNotifyTakeBlock EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x13U) +#define EvtFreeRTOSTasks_TaskNotifyTake EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x14U) +#define EvtFreeRTOSTasks_TaskNotifyWaitBlock EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x15U) +#define EvtFreeRTOSTasks_TaskNotifyWait EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x16U) +#define EvtFreeRTOSTasks_TaskNotify EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x17U) +#define EvtFreeRTOSTasks_TaskNotifyFromIsr EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x18U) +#define EvtFreeRTOSTasks_TaskNotifyGiveFromIsr EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x19U) +#define EvtFreeRTOSTasks_MovedTaskToDelayedList EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x1AU) +#define EvtFreeRTOSTasks_MovedTaskToOverflowDelayedList EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x1BU) + +#define EvtFreeRTOSTasks_xTaskCreateStatic_0 EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x20U) +#define EvtFreeRTOSTasks_xTaskCreateStatic_1 EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x21U) +#define EvtFreeRTOSTasks_xTaskCreateStatic_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x22U) +#define EvtFreeRTOSTasks_xTaskCreateStaticAffinitySet_0 EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x23U) +#define EvtFreeRTOSTasks_xTaskCreateStaticAffinitySet_1 EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x24U) +#define EvtFreeRTOSTasks_xTaskCreateStaticAffinitySet_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x25U) +#define EvtFreeRTOSTasks_xTaskCreateRestrictedStatic EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x26U) +#define EvtFreeRTOSTasks_xTaskCreateRestrictedStatic_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x27U) +#define EvtFreeRTOSTasks_xTaskCreateRestrictedStaticAffinitySet EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x28U) +#define EvtFreeRTOSTasks_xTaskCreateRestrictedStaticAffinitySet_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x29U) +#define EvtFreeRTOSTasks_xTaskCreateRestricted EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x2AU) +#define EvtFreeRTOSTasks_xTaskCreateRestricted_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x2BU) +#define EvtFreeRTOSTasks_xTaskCreateRestrictedAffinitySet EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x2CU) +#define EvtFreeRTOSTasks_xTaskCreateRestrictedAffinitySet_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x2DU) +#define EvtFreeRTOSTasks_xTaskCreate_0 EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x2EU) +#define EvtFreeRTOSTasks_xTaskCreate_1 EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x2FU) +#define EvtFreeRTOSTasks_xTaskCreate_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x30U) +#define EvtFreeRTOSTasks_xTaskCreateAffinitySet_0 EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x31U) +#define EvtFreeRTOSTasks_xTaskCreateAffinitySet_1 EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x32U) +#define EvtFreeRTOSTasks_xTaskCreateAffinitySet_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x33U) +#define EvtFreeRTOSTasks_vTaskDelete EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x34U) +#define EvtFreeRTOSTasks_vTaskDelete_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x35U) +#define EvtFreeRTOSTasks_xTaskDelayUntil EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x36U) +#define EvtFreeRTOSTasks_xTaskDelayUntil_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x37U) +#define EvtFreeRTOSTasks_vTaskDelay EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x38U) +#define EvtFreeRTOSTasks_vTaskDelay_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x39U) +#define EvtFreeRTOSTasks_eTaskGetState EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x3AU) +#define EvtFreeRTOSTasks_eTaskGetState_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x3BU) +#define EvtFreeRTOSTasks_uxTaskPriorityGet EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x3CU) +#define EvtFreeRTOSTasks_uxTaskPriorityGet_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x3DU) +#define EvtFreeRTOSTasks_uxTaskPriorityGetFromISR EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x3EU) +#define EvtFreeRTOSTasks_uxTaskPriorityGetFromISR_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x3FU) +#define EvtFreeRTOSTasks_uxTaskBasePriorityGet EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x40U) +#define EvtFreeRTOSTasks_uxTaskBasePriorityGet_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x41U) +#define EvtFreeRTOSTasks_uxTaskBasePriorityGetFromISR EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x42U) +#define EvtFreeRTOSTasks_uxTaskBasePriorityGetFromISR_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x43U) +#define EvtFreeRTOSTasks_vTaskPrioritySet EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x44U) +#define EvtFreeRTOSTasks_vTaskPrioritySet_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x45U) +#define EvtFreeRTOSTasks_vTaskCoreAffinitySet EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x46U) +#define EvtFreeRTOSTasks_vTaskCoreAffinitySet_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x47U) +#define EvtFreeRTOSTasks_vTaskCoreAffinityGet EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x48U) +#define EvtFreeRTOSTasks_vTaskCoreAffinityGet_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x49U) +#define EvtFreeRTOSTasks_vTaskPreemptionDisable EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x4AU) +#define EvtFreeRTOSTasks_vTaskPreemptionDisable_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x4BU) +#define EvtFreeRTOSTasks_vTaskPreemptionEnable EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x4CU) +#define EvtFreeRTOSTasks_vTaskPreemptionEnable_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x4DU) +#define EvtFreeRTOSTasks_vTaskSuspend EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x4EU) +#define EvtFreeRTOSTasks_vTaskSuspend_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x4FU) +#define EvtFreeRTOSTasks_vTaskResume EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x50U) +#define EvtFreeRTOSTasks_vTaskResume_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x51U) +#define EvtFreeRTOSTasks_xTaskResumeFromISR EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x52U) +#define EvtFreeRTOSTasks_xTaskResumeFromISR_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x53U) +#define EvtFreeRTOSTasks_vTaskStartScheduler EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x54U) +#define EvtFreeRTOSTasks_vTaskStartScheduler_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x55U) +#define EvtFreeRTOSTasks_vTaskEndScheduler EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x56U) +#define EvtFreeRTOSTasks_vTaskEndScheduler_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x57U) +#define EvtFreeRTOSTasks_vTaskSuspendAll EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x58U) +#define EvtFreeRTOSTasks_vTaskSuspendAll_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x59U) +#define EvtFreeRTOSTasks_xTaskResumeAll EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x5AU) +#define EvtFreeRTOSTasks_xTaskResumeAll_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x5BU) +#define EvtFreeRTOSTasks_xTaskGetTickCount EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x5CU) +#define EvtFreeRTOSTasks_xTaskGetTickCount_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x5DU) +#define EvtFreeRTOSTasks_xTaskGetTickCountFromISR EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x5EU) +#define EvtFreeRTOSTasks_xTaskGetTickCountFromISR_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x5FU) +#define EvtFreeRTOSTasks_uxTaskGetNumberOfTasks EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x60U) +#define EvtFreeRTOSTasks_uxTaskGetNumberOfTasks_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x61U) +#define EvtFreeRTOSTasks_pcTaskGetName EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x62U) +#define EvtFreeRTOSTasks_pcTaskGetName_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x63U) +#define EvtFreeRTOSTasks_xTaskGetHandle EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x64U) +#define EvtFreeRTOSTasks_xTaskGetHandle_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x65U) +#define EvtFreeRTOSTasks_xTaskGetStaticBuffers EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x66U) +#define EvtFreeRTOSTasks_xTaskGetStaticBuffers_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x67U) +#define EvtFreeRTOSTasks_uxTaskGetSystemState EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x68U) +#define EvtFreeRTOSTasks_uxTaskGetSystemState_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x69U) +#define EvtFreeRTOSTasks_xTaskGetIdleTaskHandle EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x6AU) +#define EvtFreeRTOSTasks_xTaskGetIdleTaskHandle_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x6BU) +#define EvtFreeRTOSTasks_xTaskGetIdleTaskHandleForCore EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x6CU) +#define EvtFreeRTOSTasks_xTaskGetIdleTaskHandleForCore_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x6DU) +#define EvtFreeRTOSTasks_vTaskStepTick EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x6EU) +#define EvtFreeRTOSTasks_vTaskStepTick_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x6FU) +#define EvtFreeRTOSTasks_xTaskCatchUpTicks EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x70U) +#define EvtFreeRTOSTasks_xTaskCatchUpTicks_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x71U) +#define EvtFreeRTOSTasks_xTaskAbortDelay EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x72U) +#define EvtFreeRTOSTasks_xTaskAbortDelay_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x73U) +#define EvtFreeRTOSTasks_xTaskIncrementTick EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x74U) +#define EvtFreeRTOSTasks_xTaskIncrementTick_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x75U) +#define EvtFreeRTOSTasks_vTaskSetApplicationTaskTag EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x76U) +#define EvtFreeRTOSTasks_vTaskSetApplicationTaskTag_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x77U) +#define EvtFreeRTOSTasks_xTaskGetApplicationTaskTag EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x78U) +#define EvtFreeRTOSTasks_xTaskGetApplicationTaskTag_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x79U) +#define EvtFreeRTOSTasks_xTaskGetApplicationTaskTagFromISR EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x7AU) +#define EvtFreeRTOSTasks_xTaskGetApplicationTaskTagFromISR_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x7BU) +#define EvtFreeRTOSTasks_xTaskCallApplicationTaskHook EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x7CU) +#define EvtFreeRTOSTasks_xTaskCallApplicationTaskHook_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x7DU) +#define EvtFreeRTOSTasks_vTaskSwitchContext EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x7EU) +#define EvtFreeRTOSTasks_vTaskSwitchContext_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x7FU) +#define EvtFreeRTOSTasks_vTaskPlaceOnEventList EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x80U) +#define EvtFreeRTOSTasks_vTaskPlaceOnEventList_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x81U) +#define EvtFreeRTOSTasks_vTaskPlaceOnUnorderedEventList EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x82U) +#define EvtFreeRTOSTasks_vTaskPlaceOnUnorderedEventList_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x83U) +#define EvtFreeRTOSTasks_vTaskPlaceOnEventListRestricted EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x84U) +#define EvtFreeRTOSTasks_vTaskPlaceOnEventListRestricted_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x85U) +#define EvtFreeRTOSTasks_xTaskRemoveFromEventList EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x86U) +#define EvtFreeRTOSTasks_xTaskRemoveFromEventList_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x87U) +#define EvtFreeRTOSTasks_vTaskRemoveFromUnorderedEventList EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x88U) +#define EvtFreeRTOSTasks_vTaskRemoveFromUnorderedEventList_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x89U) +#define EvtFreeRTOSTasks_vTaskSetTimeOutState EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x8AU) +#define EvtFreeRTOSTasks_vTaskSetTimeOutState_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x8BU) +#define EvtFreeRTOSTasks_vTaskInternalSetTimeOutState EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x8CU) +#define EvtFreeRTOSTasks_vTaskInternalSetTimeOutState_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x8DU) +#define EvtFreeRTOSTasks_xTaskCheckForTimeOut EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x8EU) +#define EvtFreeRTOSTasks_xTaskCheckForTimeOut_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x8FU) +#define EvtFreeRTOSTasks_vTaskMissedYield EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x90U) +#define EvtFreeRTOSTasks_vTaskMissedYield_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x91U) +#define EvtFreeRTOSTasks_uxTaskGetTaskNumber EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x92U) +#define EvtFreeRTOSTasks_uxTaskGetTaskNumber_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x93U) +#define EvtFreeRTOSTasks_vTaskSetTaskNumber EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x94U) +#define EvtFreeRTOSTasks_vTaskSetTaskNumber_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x95U) +#define EvtFreeRTOSTasks_eTaskConfirmSleepModeStatus EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x96U) +#define EvtFreeRTOSTasks_eTaskConfirmSleepModeStatus_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x97U) +#define EvtFreeRTOSTasks_vTaskSetThreadLocalStoragePointer EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x98U) +#define EvtFreeRTOSTasks_vTaskSetThreadLocalStoragePointer_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x99U) +#define EvtFreeRTOSTasks_pvTaskGetThreadLocalStoragePointer EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x9AU) +#define EvtFreeRTOSTasks_pvTaskGetThreadLocalStoragePointer_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x9BU) +#define EvtFreeRTOSTasks_vTaskAllocateMPURegions EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x9CU) +#define EvtFreeRTOSTasks_vTaskAllocateMPURegions_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x9DU) +#define EvtFreeRTOSTasks_vTaskGetInfo EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0x9EU) +#define EvtFreeRTOSTasks_vTaskGetInfo_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x9FU) +#define EvtFreeRTOSTasks_uxTaskGetStackHighWaterMark2 EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0xA0U) +#define EvtFreeRTOSTasks_uxTaskGetStackHighWaterMark2_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0xA1U) +#define EvtFreeRTOSTasks_uxTaskGetStackHighWaterMark EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0xA2U) +#define EvtFreeRTOSTasks_uxTaskGetStackHighWaterMark_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0xA3U) +#define EvtFreeRTOSTasks_xTaskGetCurrentTaskHandle EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0xA4U) +#define EvtFreeRTOSTasks_xTaskGetCurrentTaskHandle_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0xA5U) +#define EvtFreeRTOSTasks_xTaskGetCurrentTaskHandleForCore EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0xA6U) +#define EvtFreeRTOSTasks_xTaskGetCurrentTaskHandleForCore_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0xA7U) +#define EvtFreeRTOSTasks_xTaskGetSchedulerState EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0xA8U) +#define EvtFreeRTOSTasks_xTaskGetSchedulerState_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0xA9U) +#define EvtFreeRTOSTasks_xTaskPriorityInherit EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0xAAU) +#define EvtFreeRTOSTasks_xTaskPriorityInherit_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0xABU) +#define EvtFreeRTOSTasks_xTaskPriorityDisinherit EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0xACU) +#define EvtFreeRTOSTasks_xTaskPriorityDisinherit_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0xADU) +#define EvtFreeRTOSTasks_vTaskPriorityDisinheritAfterTimeout EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0xAEU) +#define EvtFreeRTOSTasks_vTaskPriorityDisinheritAfterTimeout_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0xAFU) +#define EvtFreeRTOSTasks_vTaskYieldWithinAPI EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0xB0U) +#define EvtFreeRTOSTasks_vTaskYieldWithinAPI_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0xB1U) +#define EvtFreeRTOSTasks_vTaskEnterCritical EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0xB2U) +#define EvtFreeRTOSTasks_vTaskEnterCritical_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0xB3U) +#define EvtFreeRTOSTasks_vTaskEnterCriticalFromISR EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0xB4U) +#define EvtFreeRTOSTasks_vTaskEnterCriticalFromISR_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0xB5U) +#define EvtFreeRTOSTasks_vTaskExitCritical EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0xB6U) +#define EvtFreeRTOSTasks_vTaskExitCritical_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0xB7U) +#define EvtFreeRTOSTasks_vTaskExitCriticalFromISR EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0xB8U) +#define EvtFreeRTOSTasks_vTaskExitCriticalFromISR_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0xB9U) +#define EvtFreeRTOSTasks_vTaskListTasks EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0xBAU) +#define EvtFreeRTOSTasks_vTaskListTasks_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0xBBU) +#define EvtFreeRTOSTasks_vTaskGetRunTimeStatistics EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0xBCU) +#define EvtFreeRTOSTasks_vTaskGetRunTimeStatistics_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0xBDU) +#define EvtFreeRTOSTasks_uxTaskResetEventItemValue EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0xBEU) +#define EvtFreeRTOSTasks_uxTaskResetEventItemValue_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0xBFU) +#define EvtFreeRTOSTasks_pvTaskIncrementMutexHeldCount EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0xC0U) +#define EvtFreeRTOSTasks_pvTaskIncrementMutexHeldCount_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0xC1U) +#define EvtFreeRTOSTasks_ulTaskGenericNotifyTake EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0xC2U) +#define EvtFreeRTOSTasks_ulTaskGenericNotifyTake_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0xC3U) +#define EvtFreeRTOSTasks_xTaskGenericNotifyWait_0 EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0xC4U) +#define EvtFreeRTOSTasks_xTaskGenericNotifyWait_1 EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0xC5U) +#define EvtFreeRTOSTasks_xTaskGenericNotifyWait_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0xC6U) +#define EvtFreeRTOSTasks_xTaskGenericNotify_0 EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0xC7U) +#define EvtFreeRTOSTasks_xTaskGenericNotify_1 EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0xC8U) +#define EvtFreeRTOSTasks_xTaskGenericNotify_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0xC9U) +#define EvtFreeRTOSTasks_xTaskGenericNotifyFromISR_0 EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0xCAU) +#define EvtFreeRTOSTasks_xTaskGenericNotifyFromISR_1 EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0xCBU) +#define EvtFreeRTOSTasks_xTaskGenericNotifyFromISR_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0xCCU) +#define EvtFreeRTOSTasks_vTaskGenericNotifyGiveFromISR EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0xCDU) +#define EvtFreeRTOSTasks_vTaskGenericNotifyGiveFromISR_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0xCEU) +#define EvtFreeRTOSTasks_xTaskGenericNotifyStateClear EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0xCFU) +#define EvtFreeRTOSTasks_xTaskGenericNotifyStateClear_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0xD0U) +#define EvtFreeRTOSTasks_ulTaskGenericNotifyValueClear EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0xD1U) +#define EvtFreeRTOSTasks_ulTaskGenericNotifyValueClear_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0xD2U) +#define EvtFreeRTOSTasks_ulTaskGetRunTimeCounter EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0xD3U) +#define EvtFreeRTOSTasks_ulTaskGetRunTimeCounter_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0xD4U) +#define EvtFreeRTOSTasks_ulTaskGetRunTimePercent EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0xD5U) +#define EvtFreeRTOSTasks_ulTaskGetRunTimePercent_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0xD6U) +#define EvtFreeRTOSTasks_ulTaskGetIdleRunTimeCounter EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0xD7U) +#define EvtFreeRTOSTasks_ulTaskGetIdleRunTimeCounter_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0xD8U) +#define EvtFreeRTOSTasks_ulTaskGetIdleRunTimePercent EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0xD9U) +#define EvtFreeRTOSTasks_ulTaskGetIdleRunTimePercent_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0xDAU) +#define EvtFreeRTOSTasks_xTaskGetMPUSettings EventID(EventLevelAPI, EvtFreeRTOSTasksNo, 0xDBU) +#define EvtFreeRTOSTasks_xTaskGetMPUSettings_Return EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0xDCU) /* Event IDs for "FreeRTOS Queue" */ #define EvtFreeRTOSQueue_QueueCreate EventID(EventLevelOp, EvtFreeRTOSQueueNo, 0x00U) @@ -156,26 +380,104 @@ #define EvtFreeRTOSQueue_QueuePeekFailed EventID(EventLevelError, EvtFreeRTOSQueueNo, 0x19U) /* Event IDs for "FreeRTOS Timers" */ -#define EvtFreeRTOSTimers_TimerCreate EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x00U) -#define EvtFreeRTOSTimers_TimerCreateFailed EventID(EventLevelError, EvtFreeRTOSTimersNo, 0x01U) -#define EvtFreeRTOSTimers_TimerCommandSend EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x02U) -#define EvtFreeRTOSTimers_TimerCommandReceived EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x03U) -#define EvtFreeRTOSTimers_TimerExpired EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x04U) -#define EvtFreeRTOSTimers_PendFuncCall EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x05U) -#define EvtFreeRTOSTimers_PendFuncCallFromIsr EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x06U) +#define EvtFreeRTOSTimers_TimerCreate EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x00U) +#define EvtFreeRTOSTimers_TimerCreateFailed EventID(EventLevelError, EvtFreeRTOSTimersNo, 0x01U) +#define EvtFreeRTOSTimers_TimerCommandSend EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x02U) +#define EvtFreeRTOSTimers_TimerCommandReceived EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x03U) +#define EvtFreeRTOSTimers_TimerExpired EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x04U) +#define EvtFreeRTOSTimers_PendFuncCall EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x05U) +#define EvtFreeRTOSTimers_PendFuncCallFromIsr EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x06U) + +#define EvtFreeRTOSTimers_xTimerCreateTimerTask EventID(EventLevelAPI, EvtFreeRTOSTimersNo, 0x10U) +#define EvtFreeRTOSTimers_xTimerCreateTimerTask_Return EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x11U) +#define EvtFreeRTOSTimers_xTimerCreate_0 EventID(EventLevelAPI, EvtFreeRTOSTimersNo, 0x12U) +#define EvtFreeRTOSTimers_xTimerCreate_1 EventID(EventLevelAPI, EvtFreeRTOSTimersNo, 0x13U) +#define EvtFreeRTOSTimers_xTimerCreate_Return EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x14U) +#define EvtFreeRTOSTimers_xTimerCreateStatic_0 EventID(EventLevelAPI, EvtFreeRTOSTimersNo, 0x15U) +#define EvtFreeRTOSTimers_xTimerCreateStatic_1 EventID(EventLevelAPI, EvtFreeRTOSTimersNo, 0x16U) +#define EvtFreeRTOSTimers_xTimerCreateStatic_Return EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x17U) +#define EvtFreeRTOSTimers_xTimerGenericCommandFromTask_0 EventID(EventLevelAPI, EvtFreeRTOSTimersNo, 0x18U) +#define EvtFreeRTOSTimers_xTimerGenericCommandFromTask_1 EventID(EventLevelAPI, EvtFreeRTOSTimersNo, 0x19U) +#define EvtFreeRTOSTimers_xTimerGenericCommandFromTask_Return EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x1AU) +#define EvtFreeRTOSTimers_xTimerGenericCommandFromISR_0 EventID(EventLevelAPI, EvtFreeRTOSTimersNo, 0x1BU) +#define EvtFreeRTOSTimers_xTimerGenericCommandFromISR_1 EventID(EventLevelAPI, EvtFreeRTOSTimersNo, 0x1CU) +#define EvtFreeRTOSTimers_xTimerGenericCommandFromISR_Return EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x1DU) +#define EvtFreeRTOSTimers_xTimerGetTimerDaemonTaskHandle EventID(EventLevelAPI, EvtFreeRTOSTimersNo, 0x1EU) +#define EvtFreeRTOSTimers_xTimerGetTimerDaemonTaskHandle_Return EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x1FU) +#define EvtFreeRTOSTimers_xTimerGetPeriod EventID(EventLevelAPI, EvtFreeRTOSTimersNo, 0x20U) +#define EvtFreeRTOSTimers_xTimerGetPeriod_Return EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x21U) +#define EvtFreeRTOSTimers_vTimerSetReloadMode EventID(EventLevelAPI, EvtFreeRTOSTimersNo, 0x22U) +#define EvtFreeRTOSTimers_vTimerSetReloadMode_Return EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x23U) +#define EvtFreeRTOSTimers_xTimerGetReloadMode EventID(EventLevelAPI, EvtFreeRTOSTimersNo, 0x24U) +#define EvtFreeRTOSTimers_xTimerGetReloadMode_Return EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x25U) +#define EvtFreeRTOSTimers_uxTimerGetReloadMode EventID(EventLevelAPI, EvtFreeRTOSTimersNo, 0x26U) +#define EvtFreeRTOSTimers_uxTimerGetReloadMode_Return EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x27U) +#define EvtFreeRTOSTimers_xTimerGetExpiryTime EventID(EventLevelAPI, EvtFreeRTOSTimersNo, 0x28U) +#define EvtFreeRTOSTimers_xTimerGetExpiryTime_Return EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x29U) +#define EvtFreeRTOSTimers_xTimerGetStaticBuffer EventID(EventLevelAPI, EvtFreeRTOSTimersNo, 0x2AU) +#define EvtFreeRTOSTimers_xTimerGetStaticBuffer_Return EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x2BU) +#define EvtFreeRTOSTimers_pcTimerGetName EventID(EventLevelAPI, EvtFreeRTOSTimersNo, 0x2CU) +#define EvtFreeRTOSTimers_pcTimerGetName_Return EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x2DU) +#define EvtFreeRTOSTimers_xTimerIsTimerActive EventID(EventLevelAPI, EvtFreeRTOSTimersNo, 0x2EU) +#define EvtFreeRTOSTimers_xTimerIsTimerActive_Return EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x2FU) +#define EvtFreeRTOSTimers_pvTimerGetTimerID EventID(EventLevelAPI, EvtFreeRTOSTimersNo, 0x30U) +#define EvtFreeRTOSTimers_pvTimerGetTimerID_Return EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x31U) +#define EvtFreeRTOSTimers_vTimerSetTimerID EventID(EventLevelAPI, EvtFreeRTOSTimersNo, 0x32U) +#define EvtFreeRTOSTimers_vTimerSetTimerID_Return EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x33U) +#define EvtFreeRTOSTimers_xTimerPendFunctionCallFromISR EventID(EventLevelAPI, EvtFreeRTOSTimersNo, 0x34U) +#define EvtFreeRTOSTimers_xTimerPendFunctionCallFromISR_Return EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x35U) +#define EvtFreeRTOSTimers_xTimerPendFunctionCall EventID(EventLevelAPI, EvtFreeRTOSTimersNo, 0x36U) +#define EvtFreeRTOSTimers_xTimerPendFunctionCall_Return EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x37U) +#define EvtFreeRTOSTimers_uxTimerGetTimerNumber EventID(EventLevelAPI, EvtFreeRTOSTimersNo, 0x38U) +#define EvtFreeRTOSTimers_uxTimerGetTimerNumber_Return EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x39U) +#define EvtFreeRTOSTimers_vTimerSetTimerNumber EventID(EventLevelAPI, EvtFreeRTOSTimersNo, 0x3AU) +#define EvtFreeRTOSTimers_vTimerSetTimerNumber_Return EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x3BU) /* Event IDs for "FreeRTOS EventGroups" */ -#define EvtFreeRTOSEventGroups_EventGroupCreate EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x00U) -#define EvtFreeRTOSEventGroups_EventGroupCreateFailed EventID(EventLevelError, EvtFreeRTOSEventGroupsNo, 0x01U) -#define EvtFreeRTOSEventGroups_EventGroupSyncBlock EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x02U) -#define EvtFreeRTOSEventGroups_EventGroupSyncEnd EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x03U) -#define EvtFreeRTOSEventGroups_EventGroupWaitBitsBlock EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x04U) -#define EvtFreeRTOSEventGroups_EventGroupWaitBitsEnd EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x05U) -#define EvtFreeRTOSEventGroups_EventGroupClearBits EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x06U) -#define EvtFreeRTOSEventGroups_EventGroupClearBitsFromIsr EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x07U) -#define EvtFreeRTOSEventGroups_EventGroupSetBits EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x08U) -#define EvtFreeRTOSEventGroups_EventGroupSetBitsFromIsr EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x09U) -#define EvtFreeRTOSEventGroups_EventGroupDelete EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x0AU) +#define EvtFreeRTOSEventGroups_EventGroupCreate EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x00U) +#define EvtFreeRTOSEventGroups_EventGroupCreateFailed EventID(EventLevelError, EvtFreeRTOSEventGroupsNo, 0x01U) +#define EvtFreeRTOSEventGroups_EventGroupSyncBlock EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x02U) +#define EvtFreeRTOSEventGroups_EventGroupSyncEnd EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x03U) +#define EvtFreeRTOSEventGroups_EventGroupWaitBitsBlock EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x04U) +#define EvtFreeRTOSEventGroups_EventGroupWaitBitsEnd EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x05U) +#define EvtFreeRTOSEventGroups_EventGroupClearBits EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x06U) +#define EvtFreeRTOSEventGroups_EventGroupClearBitsFromIsr EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x07U) +#define EvtFreeRTOSEventGroups_EventGroupSetBits EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x08U) +#define EvtFreeRTOSEventGroups_EventGroupSetBitsFromIsr EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x09U) +#define EvtFreeRTOSEventGroups_EventGroupDelete EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x0AU) + +#define EvtFreeRTOSEventGroups_xEventGroupCreateStatic EventID(EventLevelAPI, EvtFreeRTOSEventGroupsNo, 0x10U) +#define EvtFreeRTOSEventGroups_xEventGroupCreateStatic_Return EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x11U) +#define EvtFreeRTOSEventGroups_xEventGroupCreate EventID(EventLevelAPI, EvtFreeRTOSEventGroupsNo, 0x12U) +#define EvtFreeRTOSEventGroups_xEventGroupCreate_Return EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x13U) +#define EvtFreeRTOSEventGroups_xEventGroupSync EventID(EventLevelAPI, EvtFreeRTOSEventGroupsNo, 0x14U) +#define EvtFreeRTOSEventGroups_xEventGroupSync_Return EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x15U) +#define EvtFreeRTOSEventGroups_xEventGroupWaitBits_0 EventID(EventLevelAPI, EvtFreeRTOSEventGroupsNo, 0x16U) +#define EvtFreeRTOSEventGroups_xEventGroupWaitBits_1 EventID(EventLevelAPI, EvtFreeRTOSEventGroupsNo, 0x17U) +#define EvtFreeRTOSEventGroups_xEventGroupWaitBits_Return EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x18U) +#define EvtFreeRTOSEventGroups_xEventGroupClearBits EventID(EventLevelAPI, EvtFreeRTOSEventGroupsNo, 0x19U) +#define EvtFreeRTOSEventGroups_xEventGroupClearBits_Return EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x1AU) +#define EvtFreeRTOSEventGroups_xEventGroupClearBitsFromISR EventID(EventLevelAPI, EvtFreeRTOSEventGroupsNo, 0x1BU) +#define EvtFreeRTOSEventGroups_xEventGroupClearBitsFromISR_Return EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x1CU) +#define EvtFreeRTOSEventGroups_xEventGroupGetBitsFromISR EventID(EventLevelAPI, EvtFreeRTOSEventGroupsNo, 0x1DU) +#define EvtFreeRTOSEventGroups_xEventGroupGetBitsFromISR_Return EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x1EU) +#define EvtFreeRTOSEventGroups_xEventGroupSetBits EventID(EventLevelAPI, EvtFreeRTOSEventGroupsNo, 0x1FU) +#define EvtFreeRTOSEventGroups_xEventGroupSetBits_Return EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x20U) +#define EvtFreeRTOSEventGroups_vEventGroupDelete EventID(EventLevelAPI, EvtFreeRTOSEventGroupsNo, 0x21U) +#define EvtFreeRTOSEventGroups_vEventGroupDelete_Return EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x22U) +#define EvtFreeRTOSEventGroups_xEventGroupGetStaticBuffer EventID(EventLevelAPI, EvtFreeRTOSEventGroupsNo, 0x23U) +#define EvtFreeRTOSEventGroups_xEventGroupGetStaticBuffer_Return EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x24U) +#define EvtFreeRTOSEventGroups_vEventGroupSetBitsCallback EventID(EventLevelAPI, EvtFreeRTOSEventGroupsNo, 0x25U) +#define EvtFreeRTOSEventGroups_vEventGroupSetBitsCallback_Return EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x26U) +#define EvtFreeRTOSEventGroups_vEventGroupClearBitsCallback EventID(EventLevelAPI, EvtFreeRTOSEventGroupsNo, 0x27U) +#define EvtFreeRTOSEventGroups_vEventGroupClearBitsCallback_Return EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x28U) +#define EvtFreeRTOSEventGroups_xEventGroupSetBitsFromISR EventID(EventLevelAPI, EvtFreeRTOSEventGroupsNo, 0x29U) +#define EvtFreeRTOSEventGroups_xEventGroupSetBitsFromISR_Return EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x2AU) +#define EvtFreeRTOSEventGroups_uxEventGroupGetNumber EventID(EventLevelAPI, EvtFreeRTOSEventGroupsNo, 0x2BU) +#define EvtFreeRTOSEventGroups_uxEventGroupGetNumber_Return EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x2CU) +#define EvtFreeRTOSEventGroups_vEventGroupSetNumber EventID(EventLevelAPI, EvtFreeRTOSEventGroupsNo, 0x2DU) +#define EvtFreeRTOSEventGroups_vEventGroupSetNumber_Return EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x2EU) + /* Event IDs for "FreeRTOS Heap" */ #define EvtFreeRTOSHeap_Malloc EventID(EventLevelOp, EvtFreeRTOSHeapNo, 0x00U) @@ -503,471 +805,3070 @@ void EvrFreeRTOSTasks_TaskNotifyGiveFromIsr (/*TCB_t*/void *xTaskToNotify, uint3 } #endif - -/* Queue */ - -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_CREATE_DISABLE)) -void EvrFreeRTOSQueue_QueueCreate (/*Queue_t*/void *pxQueue) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceMOVED_TASK_TO_DELAYED_LIST_DISABLE)) +void EvrFreeRTOSTasks_MovedTaskToDelayedList (/*TCB_t*/void *pxTCB) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSQueue_QueueCreate, (uint32_t)pxQueue, 0U); + EventRecord2(EvtFreeRTOSTasks_MovedTaskToDelayedList, (uint32_t)pxTCB, 0U); #else - (void)pxQueue; + (void)pxTCB; #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_CREATE_FAILED_DISABLE)) -void EvrFreeRTOSQueue_QueueCreateFailed (uint32_t ucQueueType) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceMOVED_TASK_TO_OVERFLOW_DELAYED_LIST_DISABLE)) +void EvrFreeRTOSTasks_MovedTaskToOverflowDelayedList (/*TCB_t*/void *pxTCB) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSQueue_QueueCreateFailed, ucQueueType, 0U); + EventRecord2(EvtFreeRTOSTasks_MovedTaskToOverflowDelayedList, (uint32_t)pxTCB, 0U); #else - (void)ucQueueType; + (void)pxTCB; #endif } #endif +/* -------------------------------------------------------------------------------------------------------------- */ -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceCREATE_MUTEX_DISABLE)) -void EvrFreeRTOSQueue_CreateMutex (/*Queue_t*/void *pxNewQueue) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskCreateStatic_DISABLE)) +void EvrFreeRTOSTasks_xTaskCreateStatic (void *pxTaskCode, + const char *pcName, + const uint32_t ulStackDepth, + void *pvParameters, + uint32_t uxPriority, + void *puxStackBuffer, + void *pxTaskBuffer) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSQueue_CreateMutex, (uint32_t)pxNewQueue, 0U); + EventRecord4(EvtFreeRTOSTasks_xTaskCreateStatic_0, (uint32_t)pxTaskCode, (uint32_t)pcName, ulStackDepth, (uint32_t)pvParameters); + EventRecord4(EvtFreeRTOSTasks_xTaskCreateStatic_1, uxPriority, (uint32_t)puxStackBuffer, (uint32_t)pxTaskBuffer, 0U); #else - (void)pxNewQueue; + (void)pxTaskCode; + (void)pcName; + (void)ulStackDepth; + (void)pvParameters; + (void)uxPriority; + (void)puxStackBuffer; + (void)pxTaskBuffer; #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceCREATE_MUTEX_FAILED_DISABLE)) -void EvrFreeRTOSQueue_CreateMutexFailed (void) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskCreateStatic_DISABLE)) +void EvrFreeRTOSTasks_xTaskCreateStatic_Return (/*TCB_t*/void *xReturn) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSQueue_CreateMutexFailed, 0U, 0U); + EventRecord2(EvtFreeRTOSTasks_xTaskCreateStatic_Return, (uint32_t)xReturn, 0U); +#else + (void)xReturn; #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceGIVE_MUTEX_RECURSIVE_DISABLE)) -void EvrFreeRTOSQueue_GiveMutexRecursive (/*Queue_t*/void *pxMutex) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskCreateStaticAffinitySet_DISABLE)) +void EvrFreeRTOSTasks_xTaskCreateStaticAffinitySet (void *pxTaskCode, + const char *pcName, + const uint32_t ulStackDepth, + void *pvParameters, + uint32_t uxPriority, + void *puxStackBuffer, + void *pxTaskBuffer, + uint32_t uxCoreAffinityMask) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSQueue_GiveMutexRecursive, (uint32_t)pxMutex, 0U); + EventRecord4(EvtFreeRTOSTasks_xTaskCreateStaticAffinitySet_0, (uint32_t)pxTaskCode, (uint32_t)pcName, (uint32_t)ulStackDepth, (uint32_t)pvParameters); + EventRecord4(EvtFreeRTOSTasks_xTaskCreateStaticAffinitySet_1, uxPriority, (uint32_t)puxStackBuffer, (uint32_t)pxTaskBuffer, uxCoreAffinityMask); #else - (void)pxMutex; + (void)pxTaskCode; + (void)pcName; + (void)ulStackDepth; + (void)pvParameters; + (void)uxPriority; + (void)puxStackBuffer; + (void)pxTaskBuffer; + (void)uxCoreAffinityMask; #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceGIVE_MUTEX_RECURSIVE_FAILED_DISABLE)) -void EvrFreeRTOSQueue_GiveMutexRecursiveFailed (/*Queue_t*/void *pxMutex) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskCreateStaticAffinitySet_DISABLE)) +void EvrFreeRTOSTasks_xTaskCreateStaticAffinitySet_Return (/*TCB_t*/void *xReturn) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSQueue_GiveMutexRecursiveFailed, (uint32_t)pxMutex, 0U); + EventRecord2(EvtFreeRTOSTasks_xTaskCreateStaticAffinitySet_Return, (uint32_t)xReturn, 0U); #else - (void)pxMutex; + (void)xReturn; #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTAKE_MUTEX_RECURSIVE_DISABLE)) -void EvrFreeRTOSQueue_TakeMutexRecursive (/*Queue_t*/void *pxMutex) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskCreateRestrictedStatic_DISABLE)) +void EvrFreeRTOSTasks_xTaskCreateRestrictedStatic (const TaskParameters_t *pxTaskDefinition, TaskHandle_t *pxCreatedTask) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSQueue_TakeMutexRecursive, (uint32_t)pxMutex, 0U); + EventRecord2(EvtFreeRTOSTasks_xTaskCreateRestrictedStatic, (uint32_t)pxTaskDefinition, (uint32_t)pxCreatedTask); #else - (void)pxMutex; + (void)pxTaskDefinition; + (void)pxCreatedTask; #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTAKE_MUTEX_RECURSIVE_FAILED_DISABLE)) -void EvrFreeRTOSQueue_TakeMutexRecursiveFailed (/*Queue_t*/void *pxMutex) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskCreateRestrictedStatic_DISABLE)) +void EvrFreeRTOSTasks_xTaskCreateRestrictedStatic_Return (uint32_t xReturn) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSQueue_TakeMutexRecursiveFailed, (uint32_t)pxMutex, 0U); + EventRecord2(EvtFreeRTOSTasks_xTaskCreateRestrictedStatic_Return, xReturn, 0U); #else - (void)pxMutex; + (void)xReturn; #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceCREATE_COUNTING_SEMAPHORE_DISABLE)) -void EvrFreeRTOSQueue_CreateCountingSemaphore (/*Queue_t*/void *xHandle) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskCreateRestrictedStaticAffinitySet_DISABLE)) +void EvrFreeRTOSTasks_xTaskCreateRestrictedStaticAffinitySet (const TaskParameters_t *pxTaskDefinition, UBaseType_t uxCoreAffinityMask, TaskHandle_t *pxCreatedTask) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSQueue_CreateCountingSemaphore, (uint32_t)xHandle, 0U); + EventRecord4(EvtFreeRTOSTasks_xTaskCreateRestrictedStaticAffinitySet, (uint32_t)pxTaskDefinition, uxCoreAffinityMask, (uint32_t)pxCreatedTask, 0U); #else - (void)xHandle; + (void)pxTaskDefinition; + (void)uxCoreAffinityMask; + (void)pxCreatedTask; #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceCREATE_COUNTING_SEMAPHORE_FAILED_DISABLE)) -void EvrFreeRTOSQueue_CreateCountingSemaphoreFailed (void) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskCreateRestrictedStaticAffinitySet_DISABLE)) +void EvrFreeRTOSTasks_xTaskCreateRestrictedStaticAffinitySet_Return (uint32_t xReturn) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSQueue_CreateCountingSemaphoreFailed, 0U, 0U); + EventRecord2(EvtFreeRTOSTasks_xTaskCreateRestrictedStaticAffinitySet_Return, xReturn, 0U); +#else + (void)xReturn; #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_SEND_DISABLE)) -void EvrFreeRTOSQueue_QueueSend (/*Queue_t*/void *pxQueue) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskCreateRestricted_DISABLE)) +void EvrFreeRTOSTasks_xTaskCreateRestricted (const TaskParameters_t *pxTaskDefinition, TaskHandle_t *pxCreatedTask) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSQueue_QueueSend, (uint32_t)pxQueue, 0U); + EventRecord2(EvtFreeRTOSTasks_xTaskCreateRestricted, (uint32_t)pxTaskDefinition, (uint32_t)pxCreatedTask); #else - (void)pxQueue; + (void)pxTaskDefinition; + (void)pxCreatedTask; #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_SEND_FAILED_DISABLE)) -void EvrFreeRTOSQueue_QueueSendFailed (/*Queue_t*/void *pxQueue) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskCreateRestricted_DISABLE)) +void EvrFreeRTOSTasks_xTaskCreateRestricted_Return (uint32_t xReturn) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSQueue_QueueSendFailed, (uint32_t)pxQueue, 0U); + EventRecord2(EvtFreeRTOSTasks_xTaskCreateRestricted_Return, xReturn, 0U); #else - (void)pxQueue; + (void)xReturn; #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_RECEIVE_DISABLE)) -void EvrFreeRTOSQueue_QueueReceive (/*Queue_t*/void *pxQueue) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskCreateRestrictedAffinitySet_DISABLE)) +void EvrFreeRTOSTasks_xTaskCreateRestrictedAffinitySet (TaskParameters_t *pxTaskDefinition, uint32_t uxCoreAffinityMask, /*TCB_t*/void *pxCreatedTask) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSQueue_QueueReceive, (uint32_t)pxQueue, 0U); + EventRecord4(EvtFreeRTOSTasks_xTaskCreateRestrictedAffinitySet, (uint32_t)pxTaskDefinition, uxCoreAffinityMask, (uint32_t)pxCreatedTask, 0U); #else - (void)pxQueue; + (void)pxTaskDefinition; + (void)uxCoreAffinityMask; + (void)pxCreatedTask; #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_PEEK_DISABLE)) -void EvrFreeRTOSQueue_QueuePeek (/*Queue_t*/void *pxQueue) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskCreateRestrictedAffinitySet_DISABLE)) +void EvrFreeRTOSTasks_xTaskCreateRestrictedAffinitySet_Return (uint32_t xReturn) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSQueue_QueuePeek, (uint32_t)pxQueue, 0U); + EventRecord2(EvtFreeRTOSTasks_xTaskCreateRestrictedAffinitySet_Return, xReturn, 0U); #else - (void)pxQueue; + (void)xReturn; #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_PEEK_FAILED_DISABLE)) -void EvrFreeRTOSQueue_QueuePeekFailed (/*Queue_t*/void *pxQueue) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskCreate_DISABLE)) +void EvrFreeRTOSTasks_xTaskCreate (void *pxTaskCode, const char *pcName, uint32_t usStackDepth, void *pvParameters, uint32_t uxPriority, /*TCB_t*/void *pxCreatedTask) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSQueue_QueuePeekFailed, (uint32_t)pxQueue, 0U); + EventRecord4(EvtFreeRTOSTasks_xTaskCreate_0, (uint32_t)pxTaskCode, (uint32_t)pcName, usStackDepth, (uint32_t)pvParameters); + EventRecord2(EvtFreeRTOSTasks_xTaskCreate_1, uxPriority, (uint32_t)pxCreatedTask); #else - (void)pxQueue; + (void)pxTaskCode; + (void)pcName; + (void)usStackDepth; + (void)pvParameters; + (void)uxPriority; + (void)pxCreatedTask; #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_PEEK_FROM_ISR_DISABLE)) -void EvrFreeRTOSQueue_QueuePeekFromIsr (/*Queue_t*/void *pxQueue) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskCreate_DISABLE)) +void EvrFreeRTOSTasks_xTaskCreate_Return (uint32_t xReturn) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSQueue_QueuePeekFromIsr, (uint32_t)pxQueue, 0U); + EventRecord2(EvtFreeRTOSTasks_xTaskCreate_Return, xReturn, 0U); #else - (void)pxQueue; + (void)xReturn; #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_RECEIVE_FAILED_DISABLE)) -void EvrFreeRTOSQueue_QueueReceiveFailed (/*Queue_t*/void *pxQueue) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskCreateAffinitySet_DISABLE)) +void EvrFreeRTOSTasks_xTaskCreateAffinitySet (void *pxTaskCode, + const char *pcName, + const uint32_t usStackDepth, + void *pvParameters, + uint32_t uxPriority, + uint32_t uxCoreAffinityMask, + void *pxCreatedTask) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSQueue_QueueReceiveFailed, (uint32_t)pxQueue, 0U); + EventRecord4(EvtFreeRTOSTasks_xTaskCreateAffinitySet_0, (uint32_t)pxTaskCode, (uint32_t)pcName, usStackDepth, (uint32_t)pvParameters); + EventRecord4(EvtFreeRTOSTasks_xTaskCreateAffinitySet_1, uxPriority, uxCoreAffinityMask, (uint32_t)pxCreatedTask, 0U); #else - (void)pxQueue; + (void)pxTaskCode; + (void)pcName; + (void)usStackDepth; + (void)pvParameters; + (void)uxPriority; + (void)uxCoreAffinityMask; + (void)pxCreatedTask; #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_SEND_FROM_ISR_DISABLE)) -void EvrFreeRTOSQueue_QueueSendFromIsr (/*Queue_t*/void *pxQueue) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskCreateAffinitySet_DISABLE)) +void EvrFreeRTOSTasks_xTaskCreateAffinitySet_Return (uint32_t xReturn) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSQueue_QueueSendFromIsr, (uint32_t)pxQueue, 0U); + EventRecord2(EvtFreeRTOSTasks_xTaskCreateAffinitySet_Return, xReturn, 0U); #else - (void)pxQueue; + (void)xReturn; #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_SEND_FROM_ISR_FAILED_DISABLE)) -void EvrFreeRTOSQueue_QueueSendFromIsrFailed (/*Queue_t*/void *pxQueue) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskDelete_DISABLE)) +void EvrFreeRTOSTasks_vTaskDelete (void *xTaskToDelete) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSQueue_QueueSendFromIsrFailed, (uint32_t)pxQueue, 0U); + EventRecord2(EvtFreeRTOSTasks_vTaskDelete, (uint32_t)xTaskToDelete, 0U); #else - (void)pxQueue; + (void)xTaskToDelete; #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_RECEIVE_FROM_ISR_DISABLE)) -void EvrFreeRTOSQueue_QueueReceiveFromIsr (/*Queue_t*/void *pxQueue) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskDelete_DISABLE)) +void EvrFreeRTOSTasks_vTaskDelete_Return (void) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSQueue_QueueReceiveFromIsr, (uint32_t)pxQueue, 0U); -#else - (void)pxQueue; + EventRecord2(EvtFreeRTOSTasks_vTaskDelete_Return, 0U, 0U); #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_RECEIVE_FROM_ISR_FAILED_DISABLE)) -void EvrFreeRTOSQueue_QueueReceiveFromIsrFailed (/*Queue_t*/void *pxQueue) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskDelayUntil_DISABLE)) +void EvrFreeRTOSTasks_xTaskDelayUntil (uint32_t *pxPreviousWakeTime, const uint32_t xTimeIncrement) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSQueue_QueueReceiveFromIsrFailed, (uint32_t)pxQueue, 0U); + EventRecord2(EvtFreeRTOSTasks_xTaskDelayUntil, (uint32_t)pxPreviousWakeTime, xTimeIncrement); #else - (void)pxQueue; + (void)pxPreviousWakeTime; + (void)xTimeIncrement; #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_PEEK_FROM_ISR_FAILED_DISABLE)) -void EvrFreeRTOSQueue_QueuePeekFromIsrFailed (/*Queue_t*/void *pxQueue) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskDelayUntil_DISABLE)) +void EvrFreeRTOSTasks_xTaskDelayUntil_Return (uint32_t xShouldDelay) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSQueue_QueuePeekFromIsrFailed, (uint32_t)pxQueue, 0U); + EventRecord2(EvtFreeRTOSTasks_xTaskDelayUntil_Return, xShouldDelay, 0U); #else - (void)pxQueue; + (void)xShouldDelay; #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_DELETE_DISABLE)) -void EvrFreeRTOSQueue_QueueDelete (/*Queue_t*/void *pxQueue) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskDelay_DISABLE)) +void EvrFreeRTOSTasks_vTaskDelay (const uint32_t xTicksToDelay) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSQueue_QueueDelete, (uint32_t)pxQueue, 0U); + EventRecord2(EvtFreeRTOSTasks_vTaskDelay, xTicksToDelay, 0U); #else - (void)pxQueue; + (void)xTicksToDelay; #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_REGISTRY_ADD_DISABLE)) -void EvrFreeRTOSQueue_QueueRegistryAdd (/*Queue_t*/void *pxQueue, const char *pcQueueName) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskDelay_DISABLE)) +void EvrFreeRTOSTasks_vTaskDelay_Return (void) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSQueue_QueueRegistryAdd, (uint32_t)pxQueue, (uint32_t)pcQueueName); -#else - (void)pxQueue; - (void)pcQueueName; + EventRecord2(EvtFreeRTOSTasks_vTaskDelay_Return, 0U, 0U); #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceBLOCKING_ON_QUEUE_RECEIVE_DISABLE)) -void EvrFreeRTOSQueue_BlockingOnQueueReceive (/*Queue_t*/void *pxQueue) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_eTaskGetState_DISABLE)) +void EvrFreeRTOSTasks_eTaskGetState (TaskHandle_t xTask) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSQueue_BlockingOnQueueReceive, (uint32_t)pxQueue, 0U); + EventRecord2(EvtFreeRTOSTasks_eTaskGetState, (uint32_t)xTask, 0U); #else - (void)pxQueue; + (void)xTask; #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceBLOCKING_ON_QUEUE_SEND_DISABLE)) -void EvrFreeRTOSQueue_BlockingOnQueueSend (/*Queue_t*/void *pxQueue) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_eTaskGetState_DISABLE)) +void EvrFreeRTOSTasks_eTaskGetState_Return (eTaskState eReturn) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSQueue_BlockingOnQueueSend, (uint32_t)pxQueue, 0U); + EventRecord2(EvtFreeRTOSTasks_eTaskGetState_Return, (uint32_t)eReturn, 0U); #else - (void)pxQueue; + (void)eReturn; #endif } #endif +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_uxTaskPriorityGet_DISABLE)) +void EvrFreeRTOSTasks_uxTaskPriorityGet (TaskHandle_t xTask) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_uxTaskPriorityGet, (uint32_t)xTask, 0U); +#else + (void)xTask; +#endif +} +#endif -/* Timers */ - -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTIMER_CREATE_DISABLE)) -void EvrFreeRTOSTimers_TimerCreate (/*Timer_t*/void *pxNewTimer) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_uxTaskPriorityGet_DISABLE)) +void EvrFreeRTOSTasks_uxTaskPriorityGet_Return (uint32_t uxReturn) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSTimers_TimerCreate, (uint32_t)pxNewTimer, 0U); + EventRecord2(EvtFreeRTOSTasks_uxTaskPriorityGet_Return, uxReturn, 0U); #else - (void)pxNewTimer; + (void)uxReturn; #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTIMER_CREATE_FAILED_DISABLE)) -void EvrFreeRTOSTimers_TimerCreateFailed (void) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_uxTaskPriorityGetFromISR_DISABLE)) +void EvrFreeRTOSTasks_uxTaskPriorityGetFromISR (TaskHandle_t xTask) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSTimers_TimerCreateFailed, 0U, 0U); + EventRecord2(EvtFreeRTOSTasks_uxTaskPriorityGetFromISR, (uint32_t)xTask, 0U); +#else + (void)xTask; #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTIMER_COMMAND_SEND_DISABLE)) -void EvrFreeRTOSTimers_TimerCommandSend (/*Timer_t*/void *pxTimer, uint32_t xCommandID, uint32_t xOptionalValue, uint32_t xReturn) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_uxTaskPriorityGetFromISR_DISABLE)) +void EvrFreeRTOSTasks_uxTaskPriorityGetFromISR_Return (uint32_t uxReturn) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord4(EvtFreeRTOSTimers_TimerCommandSend, (uint32_t)pxTimer, xCommandID, xOptionalValue, xReturn); + EventRecord2(EvtFreeRTOSTasks_uxTaskPriorityGetFromISR_Return, uxReturn, 0U); #else - (void)pxTimer; - (void)xCommandID; - (void)xOptionalValue; - (void)xReturn; + (void)uxReturn; #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTIMER_COMMAND_RECEIVED_DISABLE)) -void EvrFreeRTOSTimers_TimerCommandReceived (/*Timer_t*/void *pxTimer, uint32_t xCommandID, uint32_t xOptionalValue) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_uxTaskBasePriorityGet_DISABLE)) +void EvrFreeRTOSTasks_uxTaskBasePriorityGet (TaskHandle_t xTask) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord4(EvtFreeRTOSTimers_TimerCommandReceived, (uint32_t)pxTimer, xCommandID, xOptionalValue, 0U); + EventRecord2(EvtFreeRTOSTasks_uxTaskBasePriorityGet, (uint32_t)xTask, 0U); #else - (void)pxTimer; - (void)xCommandID; - (void)xOptionalValue; + (void)xTask; #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTIMER_EXPIRED_DISABLE)) -void EvrFreeRTOSTimers_TimerExpired (/*Timer_t*/void *pxTimer) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_uxTaskBasePriorityGet_DISABLE)) +void EvrFreeRTOSTasks_uxTaskBasePriorityGet_Return (uint32_t uxReturn) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSTimers_TimerExpired, (uint32_t)pxTimer, 0U); + EventRecord2(EvtFreeRTOSTasks_uxTaskBasePriorityGet_Return, uxReturn, 0U); #else - (void)pxTimer; + (void)uxReturn; #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(tracePEND_FUNC_CALL_DISABLE)) -void EvrFreeRTOSTimers_PendFuncCall (/*PendedFunction_t*/void *pxFunctionToPend, void *pvParameter1, uint32_t ulParameter2, uint32_t xReturn) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_uxTaskBasePriorityGetFromISR_DISABLE)) +void EvrFreeRTOSTasks_uxTaskBasePriorityGetFromISR (TaskHandle_t xTask) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord4(EvtFreeRTOSTimers_PendFuncCall, (uint32_t)pxFunctionToPend, (uint32_t)pvParameter1, ulParameter2, xReturn); + EventRecord2(EvtFreeRTOSTasks_uxTaskBasePriorityGetFromISR, (uint32_t)xTask, 0U); #else - (void)pxFunctionToPend; - (void)pvParameter1; - (void)ulParameter2; - (void)xReturn; + (void)xTask; #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(tracePEND_FUNC_CALL_FROM_ISR_DISABLE)) -void EvrFreeRTOSTimers_PendFuncCallFromIsr (/*PendedFunction_t*/void *pxFunctionToPend, void *pvParameter1, uint32_t ulParameter2, uint32_t xReturn) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_uxTaskBasePriorityGetFromISR_DISABLE)) +void EvrFreeRTOSTasks_uxTaskBasePriorityGetFromISR_Return (uint32_t uxReturn) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord4(EvtFreeRTOSTimers_PendFuncCallFromIsr, (uint32_t)pxFunctionToPend, (uint32_t)pvParameter1, ulParameter2, xReturn); + EventRecord2(EvtFreeRTOSTasks_uxTaskBasePriorityGetFromISR_Return, uxReturn, 0U); #else - (void)pxFunctionToPend; - (void)pvParameter1; - (void)ulParameter2; - (void)xReturn; + (void)uxReturn; #endif } #endif +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskPrioritySet_DISABLE)) +void EvrFreeRTOSTasks_vTaskPrioritySet (TaskHandle_t xTask, uint32_t uxNewPriority) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskPrioritySet, (uint32_t)xTask, uxNewPriority); +#else + (void)xTask; + (void)uxNewPriority; +#endif +} +#endif -/* Event Groups */ +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskPrioritySet_DISABLE)) +void EvrFreeRTOSTasks_vTaskPrioritySet_Return (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskPrioritySet_Return, 0U, 0U); +#endif +} +#endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceEVENT_GROUP_CREATE_DISABLE)) -void EvrFreeRTOSEventGroups_EventGroupCreate (/*EventGroup_t*/void *pxEventGroup) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskCoreAffinitySet_DISABLE)) +void EvrFreeRTOSTasks_vTaskCoreAffinitySet (TaskHandle_t xTask, uint32_t uxCoreAffinityMask) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSEventGroups_EventGroupCreate, (uint32_t)pxEventGroup, 0U); + EventRecord2(EvtFreeRTOSTasks_vTaskCoreAffinitySet, (uint32_t)xTask, uxCoreAffinityMask); #else - (void)pxEventGroup; + (void)xTask; + (void)uxCoreAffinityMask; #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceEVENT_GROUP_CREATE_FAILED_DISABLE)) -void EvrFreeRTOSEventGroups_EventGroupCreateFailed (void) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskCoreAffinitySet_DISABLE)) +void EvrFreeRTOSTasks_vTaskCoreAffinitySet_Return (void) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSEventGroups_EventGroupCreateFailed, 0U, 0U); + EventRecord2(EvtFreeRTOSTasks_vTaskCoreAffinitySet_Return, 0U, 0U); #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceEVENT_GROUP_SYNC_BLOCK_DISABLE)) -void EvrFreeRTOSEventGroups_EventGroupSyncBlock (/*EventGroup_t*/void *pxEventGroup, uint32_t uxBitsToSet, uint32_t uxBitsToWaitFor) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskCoreAffinityGet_DISABLE)) +void EvrFreeRTOSTasks_vTaskCoreAffinityGet (ConstTaskHandle_t xTask) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord4(EvtFreeRTOSEventGroups_EventGroupSyncBlock, (uint32_t)pxEventGroup, uxBitsToSet, uxBitsToWaitFor, 0U); + EventRecord2(EvtFreeRTOSTasks_vTaskCoreAffinityGet, (uint32_t)xTask, 0U); #else - (void)pxEventGroup; - (void)uxBitsToSet; - (void)uxBitsToWaitFor; + (void)xTask; #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceEVENT_GROUP_SYNC_END_DISABLE)) -void EvrFreeRTOSEventGroups_EventGroupSyncEnd (/*EventGroup_t*/void *pxEventGroup, uint32_t uxBitsToSet, uint32_t uxBitsToWaitFor, uint32_t xTimeoutOccurred) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskCoreAffinityGet_DISABLE)) +void EvrFreeRTOSTasks_vTaskCoreAffinityGet_Return (uint32_t uxCoreAffinityMask) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord4(EvtFreeRTOSEventGroups_EventGroupSyncEnd, (uint32_t)pxEventGroup, uxBitsToSet, uxBitsToWaitFor, xTimeoutOccurred); + EventRecord2(EvtFreeRTOSTasks_vTaskCoreAffinityGet_Return, uxCoreAffinityMask, 0U); #else - (void)pxEventGroup; - (void)uxBitsToSet; - (void)uxBitsToWaitFor; - (void)xTimeoutOccurred; + (void)uxCoreAffinityMask; #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceEVENT_GROUP_WAIT_BITS_BLOCK_DISABLE)) -void EvrFreeRTOSEventGroups_EventGroupWaitBitsBlock (/*EventGroup_t*/void *pxEventGroup, uint32_t uxBitsToWaitFor) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskPreemptionDisable_DISABLE)) +void EvrFreeRTOSTasks_vTaskPreemptionDisable (TaskHandle_t xTask) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSEventGroups_EventGroupWaitBitsBlock, (uint32_t)pxEventGroup, uxBitsToWaitFor); + EventRecord2(EvtFreeRTOSTasks_vTaskPreemptionDisable, (uint32_t)xTask, 0U); #else - (void)pxEventGroup; - (void)uxBitsToWaitFor; + (void)xTask; #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceEVENT_GROUP_WAIT_BITS_END_DISABLE)) -void EvrFreeRTOSEventGroups_EventGroupWaitBitsEnd (/*EventGroup_t*/void *pxEventGroup, uint32_t uxBitsToWaitFor, uint32_t xTimeoutOccurred) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskPreemptionDisable_DISABLE)) +void EvrFreeRTOSTasks_vTaskPreemptionDisable_Return (void) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord4(EvtFreeRTOSEventGroups_EventGroupWaitBitsEnd, (uint32_t)pxEventGroup, uxBitsToWaitFor, xTimeoutOccurred, 0U); -#else - (void)pxEventGroup; - (void)uxBitsToWaitFor; - (void)xTimeoutOccurred; + EventRecord2(EvtFreeRTOSTasks_vTaskPreemptionDisable_Return, 0U, 0U); #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceEVENT_GROUP_CLEAR_BITS_DISABLE)) -void EvrFreeRTOSEventGroups_EventGroupClearBits (/*EventGroup_t*/void *pxEventGroup, uint32_t uxBitsToClear) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskPreemptionEnable_DISABLE)) +void EvrFreeRTOSTasks_vTaskPreemptionEnable (TaskHandle_t xTask) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSEventGroups_EventGroupClearBits, (uint32_t)pxEventGroup, uxBitsToClear); + EventRecord2(EvtFreeRTOSTasks_vTaskPreemptionEnable, (uint32_t)xTask, 0U); #else - (void)pxEventGroup; - (void)uxBitsToClear; + (void)xTask; #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceEVENT_GROUP_CLEAR_BITS_FROM_ISR_DISABLE)) -void EvrFreeRTOSEventGroups_EventGroupClearBitsFromIsr (/*EventGroup_t*/void *pxEventGroup, uint32_t uxBitsToClear) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskPreemptionEnable_DISABLE)) +void EvrFreeRTOSTasks_vTaskPreemptionEnable_Return (void) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSEventGroups_EventGroupClearBitsFromIsr, (uint32_t)pxEventGroup, uxBitsToClear); + EventRecord2(EvtFreeRTOSTasks_vTaskPreemptionEnable_Return, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskSuspend_DISABLE)) +void EvrFreeRTOSTasks_vTaskSuspend (TaskHandle_t xTaskToSuspend) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskSuspend, (uint32_t)xTaskToSuspend, 0U); #else - (void)pxEventGroup; - (void)uxBitsToClear; + (void)xTaskToSuspend; #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceEVENT_GROUP_SET_BITS_DISABLE)) -void EvrFreeRTOSEventGroups_EventGroupSetBits (/*EventGroup_t*/void *pxEventGroup, uint32_t uxBitsToSet) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskSuspend_DISABLE)) +void EvrFreeRTOSTasks_vTaskSuspend_Return (void) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSEventGroups_EventGroupSetBits, (uint32_t)pxEventGroup, uxBitsToSet); + EventRecord2(EvtFreeRTOSTasks_vTaskSuspend_Return, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskResume_DISABLE)) +void EvrFreeRTOSTasks_vTaskResume (TaskHandle_t xTaskToResume) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskResume, (uint32_t)xTaskToResume, 0U); #else - (void)pxEventGroup; - (void)uxBitsToSet; + (void)xTaskToResume; #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceEVENT_GROUP_SET_BITS_FROM_ISR_DISABLE)) -void EvrFreeRTOSEventGroups_EventGroupSetBitsFromIsr (/*EventGroup_t*/void *pxEventGroup, uint32_t uxBitsToSet) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskResume_DISABLE)) +void EvrFreeRTOSTasks_vTaskResume_Return (void) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSEventGroups_EventGroupSetBitsFromIsr, (uint32_t)pxEventGroup, uxBitsToSet); + EventRecord2(EvtFreeRTOSTasks_vTaskResume_Return, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskResumeFromISR_DISABLE)) +void EvrFreeRTOSTasks_xTaskResumeFromISR (TaskHandle_t xTaskToResume) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskResumeFromISR, (uint32_t)xTaskToResume, 0U); #else - (void)pxEventGroup; - (void)uxBitsToSet; + (void)xTaskToResume; #endif } #endif -#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceEVENT_GROUP_DELETE_DISABLE)) -void EvrFreeRTOSEventGroups_EventGroupDelete (/*EventGroup_t*/void *pxEventGroup) { +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskResumeFromISR_DISABLE)) +void EvrFreeRTOSTasks_xTaskResumeFromISR_Return (uint32_t xYieldRequired) { #if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) - EventRecord2(EvtFreeRTOSEventGroups_EventGroupDelete, (uint32_t)pxEventGroup, 0U); + EventRecord2(EvtFreeRTOSTasks_xTaskResumeFromISR_Return, xYieldRequired, 0U); #else - (void)pxEventGroup; + (void)xYieldRequired; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskStartScheduler_DISABLE)) +void EvrFreeRTOSTasks_vTaskStartScheduler (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskStartScheduler, 0U, 0U); #endif } #endif +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskStartScheduler_DISABLE)) +void EvrFreeRTOSTasks_vTaskStartScheduler_Return (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskStartScheduler_Return, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskEndScheduler_DISABLE)) +void EvrFreeRTOSTasks_vTaskEndScheduler (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskEndScheduler, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskEndScheduler_DISABLE)) +void EvrFreeRTOSTasks_vTaskEndScheduler_Return (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskEndScheduler_Return, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskSuspendAll_DISABLE)) +void EvrFreeRTOSTasks_vTaskSuspendAll (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskSuspendAll, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskSuspendAll_DISABLE)) +void EvrFreeRTOSTasks_vTaskSuspendAll_Return (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskSuspendAll_Return, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskResumeAll_DISABLE)) +void EvrFreeRTOSTasks_xTaskResumeAll (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskResumeAll, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskResumeAll_DISABLE)) +void EvrFreeRTOSTasks_xTaskResumeAll_Return (uint32_t xAlreadyYielded) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskResumeAll_Return, xAlreadyYielded, 0U); +#else + (void)xAlreadyYielded; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskGetTickCount_DISABLE)) +void EvrFreeRTOSTasks_xTaskGetTickCount (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskGetTickCount, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskGetTickCount_DISABLE)) +void EvrFreeRTOSTasks_xTaskGetTickCount_Return (uint32_t xTicks) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskGetTickCount_Return, xTicks, 0U); +#else + (void)xTicks; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskGetTickCountFromISR_DISABLE)) +void EvrFreeRTOSTasks_xTaskGetTickCountFromISR (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskGetTickCountFromISR, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskGetTickCountFromISR_DISABLE)) +void EvrFreeRTOSTasks_xTaskGetTickCountFromISR_Return (uint32_t xTicks) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskGetTickCountFromISR_Return, xTicks, 0U); +#else + (void)xTicks; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_uxTaskGetNumberOfTasks_DISABLE)) +void EvrFreeRTOSTasks_uxTaskGetNumberOfTasks (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_uxTaskGetNumberOfTasks, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_uxTaskGetNumberOfTasks_DISABLE)) +void EvrFreeRTOSTasks_uxTaskGetNumberOfTasks_Return (uint32_t uxCurrentNumberOfTasks) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_uxTaskGetNumberOfTasks_Return, uxCurrentNumberOfTasks, 0U); +#else + (void)uxCurrentNumberOfTasks; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_pcTaskGetName_DISABLE)) +void EvrFreeRTOSTasks_pcTaskGetName (TaskHandle_t xTaskToQuery) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_pcTaskGetName, (uint32_t)xTaskToQuery, 0U); +#else + (void)xTaskToQuery; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_pcTaskGetName_DISABLE)) +void EvrFreeRTOSTasks_pcTaskGetName_Return (char *pcTaskName) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_pcTaskGetName_Return, (uint32_t)pcTaskName, 0U); +#else + (void)pcTaskName; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskGetHandle_DISABLE)) +void EvrFreeRTOSTasks_xTaskGetHandle (const char *pcNameToQuery) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskGetHandle, (uint32_t)pcNameToQuery, 0U); +#else + (void)pcNameToQuery; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskGetHandle_DISABLE)) +void EvrFreeRTOSTasks_xTaskGetHandle_Return (/*TCB_t*/void *pxTCB) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskGetHandle_Return, (uint32_t)pxTCB, 0U); +#else + (void)pxTCB; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskGetStaticBuffers_DISABLE)) +void EvrFreeRTOSTasks_xTaskGetStaticBuffers (TaskHandle_t xTask, StackType_t **ppuxStackBuffer, /*StaticTask_t** */uint32_t ppxTaskBuffer) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord4(EvtFreeRTOSTasks_xTaskGetStaticBuffers, (uint32_t)xTask, (uint32_t)ppuxStackBuffer, (uint32_t)ppxTaskBuffer, 0U); +#else + (void)xTask; + (void)ppuxStackBuffer; + (void)ppxTaskBuffer; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskGetStaticBuffers_DISABLE)) +void EvrFreeRTOSTasks_xTaskGetStaticBuffers_Return (uint32_t xReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskGetStaticBuffers_Return, xReturn, 0U); +#else + (void)xReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_uxTaskGetSystemState_DISABLE)) +void EvrFreeRTOSTasks_uxTaskGetSystemState (TaskStatus_t *pxTaskStatusArray, const uint32_t uxArraySize, uint32_t *pulTotalRunTime) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord4(EvtFreeRTOSTasks_uxTaskGetSystemState, (uint32_t)pxTaskStatusArray, uxArraySize, (uint32_t)pulTotalRunTime, 0U); +#else + (void)pxTaskStatusArray; + (void)uxArraySize; + (void)pulTotalRunTime; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_uxTaskGetSystemState_DISABLE)) +void EvrFreeRTOSTasks_uxTaskGetSystemState_Return (uint32_t uxTask) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_uxTaskGetSystemState_Return, uxTask, 0U); +#else + (void)uxTask; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskGetIdleTaskHandle_DISABLE)) +void EvrFreeRTOSTasks_xTaskGetIdleTaskHandle (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskGetIdleTaskHandle, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskGetIdleTaskHandle_DISABLE)) +void EvrFreeRTOSTasks_xTaskGetIdleTaskHandle_Return (TaskHandle_t xTask) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskGetIdleTaskHandle_Return, (uint32_t)xTask, 0U); +#else + (void)xTask; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskGetIdleTaskHandleForCore_DISABLE)) +void EvrFreeRTOSTasks_xTaskGetIdleTaskHandleForCore (uint32_t xCoreID) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskGetIdleTaskHandleForCore, xCoreID, 0U); +#else + (void)xCoreID; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskGetIdleTaskHandleForCore_DISABLE)) +void EvrFreeRTOSTasks_xTaskGetIdleTaskHandleForCore_Return (TaskHandle_t xTask) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskGetIdleTaskHandleForCore_Return, (uint32_t)xTask, 0U); +#else + (void)xTask; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskStepTick_DISABLE)) +void EvrFreeRTOSTasks_vTaskStepTick (uint32_t xTicksToJump) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskStepTick, xTicksToJump, 0U); +#else + (void)xTicksToJump; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskStepTick_DISABLE)) +void EvrFreeRTOSTasks_vTaskStepTick_Return (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskStepTick_Return, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskCatchUpTicks_DISABLE)) +void EvrFreeRTOSTasks_xTaskCatchUpTicks (uint32_t xTicksToCatchUp) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskCatchUpTicks, xTicksToCatchUp, 0U); +#else + (void)xTicksToCatchUp; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskCatchUpTicks_DISABLE)) +void EvrFreeRTOSTasks_xTaskCatchUpTicks_Return (uint32_t xYieldOccurred) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskCatchUpTicks_Return, xYieldOccurred, 0U); +#else + (void)xYieldOccurred; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskAbortDelay_DISABLE)) +void EvrFreeRTOSTasks_xTaskAbortDelay (TaskHandle_t xTask) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskAbortDelay, (uint32_t)xTask, 0U); +#else + (void)xTask; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskAbortDelay_DISABLE)) +void EvrFreeRTOSTasks_xTaskAbortDelay_Return (uint32_t xReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskAbortDelay_Return, xReturn, 0U); +#else + (void)xReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskIncrementTick_DISABLE)) +void EvrFreeRTOSTasks_xTaskIncrementTick (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskIncrementTick, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskIncrementTick_DISABLE)) +void EvrFreeRTOSTasks_xTaskIncrementTick_Return (uint32_t xSwitchRequired) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskIncrementTick_Return, xSwitchRequired, 0U); +#else + (void)xSwitchRequired; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskSetApplicationTaskTag_DISABLE)) +void EvrFreeRTOSTasks_vTaskSetApplicationTaskTag (TaskHandle_t xTask, TaskHookFunction_t pxHookFunction) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskSetApplicationTaskTag, (uint32_t)xTask, (uint32_t)pxHookFunction); +#else + (void)xTask; + (void)pxHookFunction; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskSetApplicationTaskTag_DISABLE)) +void EvrFreeRTOSTasks_vTaskSetApplicationTaskTag_Return (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskSetApplicationTaskTag_Return, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskGetApplicationTaskTag_DISABLE)) +void EvrFreeRTOSTasks_xTaskGetApplicationTaskTag (TaskHandle_t xTask) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskGetApplicationTaskTag, (uint32_t)xTask, 0U); +#else + (void)xTask; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskGetApplicationTaskTag_DISABLE)) +void EvrFreeRTOSTasks_xTaskGetApplicationTaskTag_Return (TaskHookFunction_t xReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskGetApplicationTaskTag_Return, (uint32_t)xReturn, 0U); +#else + (void)xReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskGetApplicationTaskTagFromISR_DISABLE)) +void EvrFreeRTOSTasks_xTaskGetApplicationTaskTagFromISR (TaskHandle_t xTask) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskGetApplicationTaskTagFromISR, (uint32_t)xTask, 0U); +#else + (void)xTask; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskGetApplicationTaskTagFromISR_DISABLE)) +void EvrFreeRTOSTasks_xTaskGetApplicationTaskTagFromISR_Return (TaskHookFunction_t xReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskGetApplicationTaskTagFromISR_Return, (uint32_t)xReturn, 0U); +#else + (void)xReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskCallApplicationTaskHook_DISABLE)) +void EvrFreeRTOSTasks_xTaskCallApplicationTaskHook (TaskHandle_t xTask, void *pvParameter) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskCallApplicationTaskHook, (uint32_t)xTask, (uint32_t)pvParameter); +#else + (void)xTask; + (void)pvParameter; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskCallApplicationTaskHook_DISABLE)) +void EvrFreeRTOSTasks_xTaskCallApplicationTaskHook_Return (uint32_t xReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskCallApplicationTaskHook_Return, xReturn, 0U); +#else + (void)xReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskSwitchContext_DISABLE)) +void EvrFreeRTOSTasks_vTaskSwitchContext (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskSwitchContext, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskSwitchContext_DISABLE)) +void EvrFreeRTOSTasks_vTaskSwitchContext_Return (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskSwitchContext_Return, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskPlaceOnEventList_DISABLE)) +void EvrFreeRTOSTasks_vTaskPlaceOnEventList (List_t *pxEventList, const TickType_t xTicksToWait) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskPlaceOnEventList, (uint32_t)pxEventList, (uint32_t)xTicksToWait); +#else + (void)pxEventList; + (void)xTicksToWait; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskPlaceOnEventList_DISABLE)) +void EvrFreeRTOSTasks_vTaskPlaceOnEventList_Return (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskPlaceOnEventList_Return, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskPlaceOnUnorderedEventList_DISABLE)) +void EvrFreeRTOSTasks_vTaskPlaceOnUnorderedEventList (List_t *pxEventList, const TickType_t xItemValue, const TickType_t xTicksToWait) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord4(EvtFreeRTOSTasks_vTaskPlaceOnUnorderedEventList, (uint32_t)pxEventList, (uint32_t)xItemValue, (uint32_t)xTicksToWait, 0U); +#else + (void)pxEventList; + (void)xItemValue; + (void)xTicksToWait; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskPlaceOnUnorderedEventList_DISABLE)) +void EvrFreeRTOSTasks_vTaskPlaceOnUnorderedEventList_Return (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskPlaceOnUnorderedEventList_Return, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskPlaceOnEventListRestricted_DISABLE)) +void EvrFreeRTOSTasks_vTaskPlaceOnEventListRestricted (List_t *pxEventList, TickType_t xTicksToWait, const uint32_t xWaitIndefinitely) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord4(EvtFreeRTOSTasks_vTaskPlaceOnEventListRestricted, (uint32_t)pxEventList, (uint32_t)xTicksToWait, (uint32_t)xWaitIndefinitely, 0U); +#else + (void)pxEventList; + (void)xTicksToWait; + (void)xWaitIndefinitely; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskPlaceOnEventListRestricted_DISABLE)) +void EvrFreeRTOSTasks_vTaskPlaceOnEventListRestricted_Return (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskPlaceOnEventListRestricted_Return, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskRemoveFromEventList_DISABLE)) +void EvrFreeRTOSTasks_xTaskRemoveFromEventList (const List_t *pxEventList) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskRemoveFromEventList, (uint32_t)pxEventList, 0U); +#else + (void)pxEventList; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskRemoveFromEventList_DISABLE)) +void EvrFreeRTOSTasks_xTaskRemoveFromEventList_Return (uint32_t xReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskRemoveFromEventList_Return, xReturn, 0U); +#else + (void)xReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskRemoveFromUnorderedEventList_DISABLE)) +void EvrFreeRTOSTasks_vTaskRemoveFromUnorderedEventList (ListItem_t *pxEventListItem, const TickType_t xItemValue) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskRemoveFromUnorderedEventList, (uint32_t)pxEventListItem, (uint32_t)xItemValue); +#else + (void)pxEventListItem; + (void)xItemValue; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskRemoveFromUnorderedEventList_DISABLE)) +void EvrFreeRTOSTasks_vTaskRemoveFromUnorderedEventList_Return (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskRemoveFromUnorderedEventList_Return, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskSetTimeOutState_DISABLE)) +void EvrFreeRTOSTasks_vTaskSetTimeOutState (TimeOut_t *pxTimeOut) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskSetTimeOutState, (uint32_t)pxTimeOut, 0U); +#else + (void)pxTimeOut; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskSetTimeOutState_DISABLE)) +void EvrFreeRTOSTasks_vTaskSetTimeOutState_Return (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskSetTimeOutState_Return, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskInternalSetTimeOutState_DISABLE)) +void EvrFreeRTOSTasks_vTaskInternalSetTimeOutState (TimeOut_t *pxTimeOut) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskInternalSetTimeOutState, (uint32_t)pxTimeOut, 0U); +#else + (void)pxTimeOut; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskInternalSetTimeOutState_DISABLE)) +void EvrFreeRTOSTasks_vTaskInternalSetTimeOutState_Return (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskInternalSetTimeOutState_Return, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskCheckForTimeOut_DISABLE)) +void EvrFreeRTOSTasks_xTaskCheckForTimeOut (TimeOut_t *pxTimeOut, TickType_t *pxTicksToWait) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskCheckForTimeOut, (uint32_t)pxTimeOut, (uint32_t)pxTicksToWait); +#else + (void)pxTimeOut; + (void)pxTicksToWait; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskCheckForTimeOut_DISABLE)) +void EvrFreeRTOSTasks_xTaskCheckForTimeOut_Return (uint32_t xReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskCheckForTimeOut_Return, xReturn, 0U); +#else + (void)xReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskMissedYield_DISABLE)) +void EvrFreeRTOSTasks_vTaskMissedYield (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskMissedYield, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskMissedYield_DISABLE)) +void EvrFreeRTOSTasks_vTaskMissedYield_Return (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskMissedYield_Return, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_uxTaskGetTaskNumber_DISABLE)) +void EvrFreeRTOSTasks_uxTaskGetTaskNumber (TaskHandle_t xTask) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_uxTaskGetTaskNumber, (uint32_t)xTask, 0U); +#else + (void)xTask; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_uxTaskGetTaskNumber_DISABLE)) +void EvrFreeRTOSTasks_uxTaskGetTaskNumber_Return (uint32_t uxReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_uxTaskGetTaskNumber_Return, uxReturn, 0U); +#else + (void)uxReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskSetTaskNumber_DISABLE)) +void EvrFreeRTOSTasks_vTaskSetTaskNumber (TaskHandle_t xTask, const uint32_t uxHandle) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskSetTaskNumber, (uint32_t)xTask, (uint32_t)uxHandle); +#else + (void)xTask; + (void)uxHandle; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskSetTaskNumber_DISABLE)) +void EvrFreeRTOSTasks_vTaskSetTaskNumber_Return (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskSetTaskNumber_Return, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_eTaskConfirmSleepModeStatus_DISABLE)) +void EvrFreeRTOSTasks_eTaskConfirmSleepModeStatus (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_eTaskConfirmSleepModeStatus, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_eTaskConfirmSleepModeStatus_DISABLE)) +void EvrFreeRTOSTasks_eTaskConfirmSleepModeStatus_Return (eSleepModeStatus eReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_eTaskConfirmSleepModeStatus_Return, (uint32_t)eReturn, 0U); +#else + (void)eReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskSetThreadLocalStoragePointer_DISABLE)) +void EvrFreeRTOSTasks_vTaskSetThreadLocalStoragePointer (TaskHandle_t xTaskToSet, uint32_t xIndex, void *pvValue) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord4(EvtFreeRTOSTasks_vTaskSetThreadLocalStoragePointer, (uint32_t)xTaskToSet, (uint32_t)xIndex, (uint32_t)pvValue, 0U); +#else + (void)xTaskToSet; + (void)xIndex; + (void)pvValue; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskSetThreadLocalStoragePointer_DISABLE)) +void EvrFreeRTOSTasks_vTaskSetThreadLocalStoragePointer_Return (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskSetThreadLocalStoragePointer_Return, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_pvTaskGetThreadLocalStoragePointer_DISABLE)) +void EvrFreeRTOSTasks_pvTaskGetThreadLocalStoragePointer (TaskHandle_t xTaskToQuery, uint32_t xIndex) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_pvTaskGetThreadLocalStoragePointer, (uint32_t)xTaskToQuery, xIndex); +#else + (void)xTaskToQuery; + (void)xIndex; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_pvTaskGetThreadLocalStoragePointer_DISABLE)) +void EvrFreeRTOSTasks_pvTaskGetThreadLocalStoragePointer_Return (void *pvReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_pvTaskGetThreadLocalStoragePointer_Return, (uint32_t)pvReturn, 0U); +#else + (void)pvReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskAllocateMPURegions_DISABLE)) +void EvrFreeRTOSTasks_vTaskAllocateMPURegions (TaskHandle_t xTaskToModify, const MemoryRegion_t *pxRegions) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskAllocateMPURegions, (uint32_t)xTaskToModify, (uint32_t)pxRegions); +#else + (void)xTaskToModify; + (void)pxRegions; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskAllocateMPURegions_DISABLE)) +void EvrFreeRTOSTasks_vTaskAllocateMPURegions_Return (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskAllocateMPURegions_Return, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskGetInfo_DISABLE)) +void EvrFreeRTOSTasks_vTaskGetInfo (TaskHandle_t xTask, TaskStatus_t *pxTaskStatus, uint32_t xGetFreeStackSpace, eTaskState eState) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord4(EvtFreeRTOSTasks_vTaskGetInfo, (uint32_t)xTask, (uint32_t)pxTaskStatus, (uint32_t)xGetFreeStackSpace, (uint32_t)eState); +#else + (void)xTask; + (void)pxTaskStatus; + (void)xGetFreeStackSpace; + (void)eState; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskGetInfo_DISABLE)) +void EvrFreeRTOSTasks_vTaskGetInfo_Return (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskGetInfo_Return, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_uxTaskGetStackHighWaterMark2_DISABLE)) +void EvrFreeRTOSTasks_uxTaskGetStackHighWaterMark2 (TaskHandle_t xTask) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_uxTaskGetStackHighWaterMark2, (uint32_t)xTask, 0U); +#else + (void)xTask; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_uxTaskGetStackHighWaterMark2_DISABLE)) +void EvrFreeRTOSTasks_uxTaskGetStackHighWaterMark2_Return (uint32_t uxReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_uxTaskGetStackHighWaterMark2_Return, uxReturn, 0U); +#else + (void)uxReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_uxTaskGetStackHighWaterMark_DISABLE)) +void EvrFreeRTOSTasks_uxTaskGetStackHighWaterMark (TaskHandle_t xTask) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_uxTaskGetStackHighWaterMark, (uint32_t)xTask, 0U); +#else + (void)xTask; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_uxTaskGetStackHighWaterMark_DISABLE)) +void EvrFreeRTOSTasks_uxTaskGetStackHighWaterMark_Return (uint32_t uxReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_uxTaskGetStackHighWaterMark_Return, uxReturn, 0U); +#else + (void)uxReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskGetCurrentTaskHandle_DISABLE)) +void EvrFreeRTOSTasks_xTaskGetCurrentTaskHandle (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskGetCurrentTaskHandle, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskGetCurrentTaskHandle_DISABLE)) +void EvrFreeRTOSTasks_xTaskGetCurrentTaskHandle_Return (TaskHandle_t xReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskGetCurrentTaskHandle_Return, (uint32_t)xReturn, 0U); +#else + (void)xReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskGetCurrentTaskHandleForCore_DISABLE)) +void EvrFreeRTOSTasks_xTaskGetCurrentTaskHandleForCore (uint32_t xCoreID) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskGetCurrentTaskHandleForCore, xCoreID, 0U); +#else + (void)xCoreID; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskGetCurrentTaskHandleForCore_DISABLE)) +void EvrFreeRTOSTasks_xTaskGetCurrentTaskHandleForCore_Return (TaskHandle_t xReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskGetCurrentTaskHandleForCore_Return, (uint32_t)xReturn, 0U); +#else + (void)xReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskGetSchedulerState_DISABLE)) +void EvrFreeRTOSTasks_xTaskGetSchedulerState (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskGetSchedulerState, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskGetSchedulerState_DISABLE)) +void EvrFreeRTOSTasks_xTaskGetSchedulerState_Return (uint32_t xReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskGetSchedulerState_Return, (uint32_t)xReturn, 0U); +#else + (void)xReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskPriorityInherit_DISABLE)) +void EvrFreeRTOSTasks_xTaskPriorityInherit (TaskHandle_t pxMutexHolder) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskPriorityInherit, (uint32_t)pxMutexHolder, 0U); +#else + (void)pxMutexHolder; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskPriorityInherit_DISABLE)) +void EvrFreeRTOSTasks_xTaskPriorityInherit_Return (uint32_t xReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskPriorityInherit_Return, xReturn, 0U); +#else + (void)xReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskPriorityDisinherit_DISABLE)) +void EvrFreeRTOSTasks_xTaskPriorityDisinherit (TaskHandle_t pxMutexHolder) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskPriorityDisinherit, (uint32_t)pxMutexHolder, 0U); +#else + (void)pxMutexHolder; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskPriorityDisinherit_DISABLE)) +void EvrFreeRTOSTasks_xTaskPriorityDisinherit_Return (uint32_t xReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskPriorityDisinherit_Return, xReturn, 0U); +#else + (void)xReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskPriorityDisinheritAfterTimeout_DISABLE)) +void EvrFreeRTOSTasks_vTaskPriorityDisinheritAfterTimeout (TaskHandle_t pxMutexHolder, uint32_t uxHighestPriorityWaitingTask) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskPriorityDisinheritAfterTimeout, (uint32_t)pxMutexHolder, uxHighestPriorityWaitingTask); +#else + (void)pxMutexHolder; + (void)uxHighestPriorityWaitingTask; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskPriorityDisinheritAfterTimeout_DISABLE)) +void EvrFreeRTOSTasks_vTaskPriorityDisinheritAfterTimeout_Return (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskPriorityDisinheritAfterTimeout_Return, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskYieldWithinAPI_DISABLE)) +void EvrFreeRTOSTasks_vTaskYieldWithinAPI (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskYieldWithinAPI, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskYieldWithinAPI_DISABLE)) +void EvrFreeRTOSTasks_vTaskYieldWithinAPI_Return (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskYieldWithinAPI_Return, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskEnterCritical_DISABLE)) +void EvrFreeRTOSTasks_vTaskEnterCritical (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskEnterCritical, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskEnterCritical_DISABLE)) +void EvrFreeRTOSTasks_vTaskEnterCritical_Return (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskEnterCritical_Return, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskEnterCriticalFromISR_DISABLE)) +void EvrFreeRTOSTasks_vTaskEnterCriticalFromISR (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskEnterCriticalFromISR, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskEnterCriticalFromISR_DISABLE)) +void EvrFreeRTOSTasks_vTaskEnterCriticalFromISR_Return (uint32_t uxSavedInterruptStatus) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskEnterCriticalFromISR_Return, uxSavedInterruptStatus, 0U); +#else + (void)uxSavedInterruptStatus; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskExitCritical_DISABLE)) +void EvrFreeRTOSTasks_vTaskExitCritical (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskExitCritical, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskExitCritical_DISABLE)) +void EvrFreeRTOSTasks_vTaskExitCritical_Return (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskExitCritical_Return, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskExitCriticalFromISR_DISABLE)) +void EvrFreeRTOSTasks_vTaskExitCriticalFromISR (uint32_t uxSavedInterruptStatus) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskExitCriticalFromISR, uxSavedInterruptStatus, 0U); +#else + (void)uxSavedInterruptStatus; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskExitCriticalFromISR_DISABLE)) +void EvrFreeRTOSTasks_vTaskExitCriticalFromISR_Return (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskExitCriticalFromISR_Return, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskListTasks_DISABLE)) +void EvrFreeRTOSTasks_vTaskListTasks (char *pcWriteBuffer, size_t uxBufferLength) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskListTasks, (uint32_t)pcWriteBuffer, (uint32_t)uxBufferLength); +#else + (void)pcWriteBuffer; + (void)uxBufferLength; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskListTasks_DISABLE)) +void EvrFreeRTOSTasks_vTaskListTasks_Return (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskListTasks_Return, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskGetRunTimeStatistics_DISABLE)) +void EvrFreeRTOSTasks_vTaskGetRunTimeStatistics (char *pcWriteBuffer, size_t uxBufferLength) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskGetRunTimeStatistics, (uint32_t)pcWriteBuffer, (uint32_t)uxBufferLength); +#else + (void)pcWriteBuffer; + (void)uxBufferLength; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskGetRunTimeStatistics_DISABLE)) +void EvrFreeRTOSTasks_vTaskGetRunTimeStatistics_Return (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskGetRunTimeStatistics_Return, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_uxTaskResetEventItemValue_DISABLE)) +void EvrFreeRTOSTasks_uxTaskResetEventItemValue (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_uxTaskResetEventItemValue, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_uxTaskResetEventItemValue_DISABLE)) +void EvrFreeRTOSTasks_uxTaskResetEventItemValue_Return (TickType_t uxReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_uxTaskResetEventItemValue_Return, (uint32_t)uxReturn, 0U); +#else + (void)uxReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_pvTaskIncrementMutexHeldCount_DISABLE)) +void EvrFreeRTOSTasks_pvTaskIncrementMutexHeldCount (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_pvTaskIncrementMutexHeldCount, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_pvTaskIncrementMutexHeldCount_DISABLE)) +void EvrFreeRTOSTasks_pvTaskIncrementMutexHeldCount_Return (/*TCB_t*/void *pxTCB) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_pvTaskIncrementMutexHeldCount_Return, (uint32_t)pxTCB, 0U); +#else + (void)pxTCB; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_ulTaskGenericNotifyTake_DISABLE)) +void EvrFreeRTOSTasks_ulTaskGenericNotifyTake (UBaseType_t uxIndexToWaitOn, BaseType_t xClearCountOnExit, TickType_t xTicksToWait) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord4(EvtFreeRTOSTasks_ulTaskGenericNotifyTake, uxIndexToWaitOn, (uint32_t)xClearCountOnExit, xTicksToWait, 0U); +#else + (void)uxIndexToWaitOn; + (void)xClearCountOnExit; + (void)xTicksToWait; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_ulTaskGenericNotifyTake_DISABLE)) +void EvrFreeRTOSTasks_ulTaskGenericNotifyTake_Return (uint32_t ulReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_ulTaskGenericNotifyTake_Return, ulReturn, 0U); +#else + (void)ulReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskGenericNotifyWait_DISABLE)) +void EvrFreeRTOSTasks_xTaskGenericNotifyWait (UBaseType_t uxIndexToWaitOn, + uint32_t ulBitsToClearOnEntry, + uint32_t ulBitsToClearOnExit, + uint32_t *pulNotificationValue, + TickType_t xTicksToWait) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord4(EvtFreeRTOSTasks_xTaskGenericNotifyWait_0, uxIndexToWaitOn, ulBitsToClearOnEntry, ulBitsToClearOnExit, 0U); + EventRecord2(EvtFreeRTOSTasks_xTaskGenericNotifyWait_1, (uint32_t)pulNotificationValue, xTicksToWait); +#else + (void)uxIndexToWaitOn; + (void)ulBitsToClearOnEntry; + (void)ulBitsToClearOnExit; + (void)pulNotificationValue; + (void)xTicksToWait; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskGenericNotifyWait_DISABLE)) +void EvrFreeRTOSTasks_xTaskGenericNotifyWait_Return (BaseType_t xReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskGenericNotifyWait_Return, (uint32_t) xReturn, 0U); +#else + (void)xReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskGenericNotify_DISABLE)) +void EvrFreeRTOSTasks_xTaskGenericNotify (TaskHandle_t xTaskToNotify, + UBaseType_t uxIndexToNotify, + uint32_t ulValue, + eNotifyAction eAction, + uint32_t *pulPreviousNotificationValue) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord4(EvtFreeRTOSTasks_xTaskGenericNotify_0, (uint32_t)xTaskToNotify, uxIndexToNotify, ulValue, 0U); + EventRecord2(EvtFreeRTOSTasks_xTaskGenericNotify_1, (uint32_t)eAction, (uint32_t)pulPreviousNotificationValue); +#else + (void)xTaskToNotify; + (void)uxIndexToNotify; + (void)ulValue; + (void)eAction; + (void)pulPreviousNotificationValue; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskGenericNotify_DISABLE)) +void EvrFreeRTOSTasks_xTaskGenericNotify_Return (BaseType_t xReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskGenericNotify_Return, (uint32_t)xReturn, 0U); +#else + (void)xReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskGenericNotifyFromISR_DISABLE)) +void EvrFreeRTOSTasks_xTaskGenericNotifyFromISR (TaskHandle_t xTaskToNotify, + UBaseType_t uxIndexToNotify, + uint32_t ulValue, + eNotifyAction eAction, + uint32_t *pulPreviousNotificationValue, + BaseType_t *pxHigherPriorityTaskWoken) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord4(EvtFreeRTOSTasks_xTaskGenericNotifyFromISR_0, (uint32_t)xTaskToNotify, uxIndexToNotify, ulValue, 0U); + EventRecord4(EvtFreeRTOSTasks_xTaskGenericNotifyFromISR_1, (uint32_t)eAction, (uint32_t)pulPreviousNotificationValue, (uint32_t)pxHigherPriorityTaskWoken, 0U); +#else + (void)xTaskToNotify; + (void)uxIndexToNotify; + (void)ulValue; + (void)eAction; + (void)pulPreviousNotificationValue; + (void)pxHigherPriorityTaskWoken; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskGenericNotifyFromISR_DISABLE)) +void EvrFreeRTOSTasks_xTaskGenericNotifyFromISR_Return (BaseType_t xReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskGenericNotifyFromISR_Return, (uint32_t)xReturn, 0U); +#else + (void)xReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTaskGenericNotifyGiveFromISR_DISABLE)) +void EvrFreeRTOSTasks_vTaskGenericNotifyGiveFromISR (TaskHandle_t xTaskToNotify, UBaseType_t uxIndexToNotify, BaseType_t *pxHigherPriorityTaskWoken) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord4(EvtFreeRTOSTasks_vTaskGenericNotifyGiveFromISR, (uint32_t)xTaskToNotify, uxIndexToNotify, (uint32_t)pxHigherPriorityTaskWoken, 0U); +#else + (void)xTaskToNotify; + (void)uxIndexToNotify; + (void)pxHigherPriorityTaskWoken; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTaskGenericNotifyGiveFromISR_DISABLE)) +void EvrFreeRTOSTasks_vTaskGenericNotifyGiveFromISR_Return (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_vTaskGenericNotifyGiveFromISR_Return, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskGenericNotifyStateClear_DISABLE)) +void EvrFreeRTOSTasks_xTaskGenericNotifyStateClear (TaskHandle_t xTask, UBaseType_t uxIndexToClear) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskGenericNotifyStateClear, (uint32_t)xTask, (uint32_t)uxIndexToClear); +#else + (void)xTask; + (void)uxIndexToClear; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskGenericNotifyStateClear_DISABLE)) +void EvrFreeRTOSTasks_xTaskGenericNotifyStateClear_Return (BaseType_t xReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskGenericNotifyStateClear_Return, (uint32_t)xReturn, 0U); +#else + (void)xReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_ulTaskGenericNotifyValueClear_DISABLE)) +void EvrFreeRTOSTasks_ulTaskGenericNotifyValueClear (TaskHandle_t xTask, UBaseType_t uxIndexToClear, uint32_t ulBitsToClear) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord4(EvtFreeRTOSTasks_ulTaskGenericNotifyValueClear, (uint32_t)xTask, uxIndexToClear, ulBitsToClear, 0U); +#else + (void)xTask; + (void)uxIndexToClear; + (void)ulBitsToClear; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_ulTaskGenericNotifyValueClear_DISABLE)) +void EvrFreeRTOSTasks_ulTaskGenericNotifyValueClear_Return (uint32_t ulReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_ulTaskGenericNotifyValueClear_Return, ulReturn, 0U); +#else + (void)ulReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_ulTaskGetRunTimeCounter_DISABLE)) +void EvrFreeRTOSTasks_ulTaskGetRunTimeCounter (const TaskHandle_t xTask) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_ulTaskGetRunTimeCounter, (uint32_t)xTask, 0U); +#else + (void)xTask; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_ulTaskGetRunTimeCounter_DISABLE)) +void EvrFreeRTOSTasks_ulTaskGetRunTimeCounter_Return (uint32_t ulRunTimeCounter) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_ulTaskGetRunTimeCounter_Return, ulRunTimeCounter, 0U); +#else + (void)ulRunTimeCounter; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_ulTaskGetRunTimePercent_DISABLE)) +void EvrFreeRTOSTasks_ulTaskGetRunTimePercent (const TaskHandle_t xTask) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_ulTaskGetRunTimePercent, (uint32_t)xTask, 0U); +#else + (void)xTask; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_ulTaskGetRunTimePercent_DISABLE)) +void EvrFreeRTOSTasks_ulTaskGetRunTimePercent_Return (uint32_t ulReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_ulTaskGetRunTimePercent_Return, ulReturn, 0U); +#else + (void)ulReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_ulTaskGetIdleRunTimeCounter_DISABLE)) +void EvrFreeRTOSTasks_ulTaskGetIdleRunTimeCounter (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_ulTaskGetIdleRunTimeCounter, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_ulTaskGetIdleRunTimeCounter_DISABLE)) +void EvrFreeRTOSTasks_ulTaskGetIdleRunTimeCounter_Return (uint32_t ulReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_ulTaskGetIdleRunTimeCounter_Return, ulReturn, 0U); +#else + (void)ulReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_ulTaskGetIdleRunTimePercent_DISABLE)) +void EvrFreeRTOSTasks_ulTaskGetIdleRunTimePercent (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_ulTaskGetIdleRunTimePercent, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_ulTaskGetIdleRunTimePercent_DISABLE)) +void EvrFreeRTOSTasks_ulTaskGetIdleRunTimePercent_Return (uint32_t ulReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_ulTaskGetIdleRunTimePercent_Return, ulReturn, 0U); +#else + (void)ulReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTaskGetMPUSettings_DISABLE)) +void EvrFreeRTOSTasks_xTaskGetMPUSettings (TaskHandle_t xTask) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskGetMPUSettings, (uint32_t)xTask, 0U); +#else + (void)xTask; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTaskGetMPUSettings_DISABLE)) +void EvrFreeRTOSTasks_xTaskGetMPUSettings_Return (void *xMPUSettings) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTasks_xTaskGetMPUSettings_Return, (uint32_t)xMPUSettings, 0U); +#else + (void)xMPUSettings; +#endif +} +#endif + + +/* Queue */ + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_CREATE_DISABLE)) +void EvrFreeRTOSQueue_QueueCreate (/*Queue_t*/void *pxQueue) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSQueue_QueueCreate, (uint32_t)pxQueue, 0U); +#else + (void)pxQueue; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_CREATE_FAILED_DISABLE)) +void EvrFreeRTOSQueue_QueueCreateFailed (uint32_t ucQueueType) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSQueue_QueueCreateFailed, ucQueueType, 0U); +#else + (void)ucQueueType; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceCREATE_MUTEX_DISABLE)) +void EvrFreeRTOSQueue_CreateMutex (/*Queue_t*/void *pxNewQueue) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSQueue_CreateMutex, (uint32_t)pxNewQueue, 0U); +#else + (void)pxNewQueue; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceCREATE_MUTEX_FAILED_DISABLE)) +void EvrFreeRTOSQueue_CreateMutexFailed (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSQueue_CreateMutexFailed, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceGIVE_MUTEX_RECURSIVE_DISABLE)) +void EvrFreeRTOSQueue_GiveMutexRecursive (/*Queue_t*/void *pxMutex) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSQueue_GiveMutexRecursive, (uint32_t)pxMutex, 0U); +#else + (void)pxMutex; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceGIVE_MUTEX_RECURSIVE_FAILED_DISABLE)) +void EvrFreeRTOSQueue_GiveMutexRecursiveFailed (/*Queue_t*/void *pxMutex) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSQueue_GiveMutexRecursiveFailed, (uint32_t)pxMutex, 0U); +#else + (void)pxMutex; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTAKE_MUTEX_RECURSIVE_DISABLE)) +void EvrFreeRTOSQueue_TakeMutexRecursive (/*Queue_t*/void *pxMutex) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSQueue_TakeMutexRecursive, (uint32_t)pxMutex, 0U); +#else + (void)pxMutex; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTAKE_MUTEX_RECURSIVE_FAILED_DISABLE)) +void EvrFreeRTOSQueue_TakeMutexRecursiveFailed (/*Queue_t*/void *pxMutex) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSQueue_TakeMutexRecursiveFailed, (uint32_t)pxMutex, 0U); +#else + (void)pxMutex; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceCREATE_COUNTING_SEMAPHORE_DISABLE)) +void EvrFreeRTOSQueue_CreateCountingSemaphore (/*Queue_t*/void *xHandle) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSQueue_CreateCountingSemaphore, (uint32_t)xHandle, 0U); +#else + (void)xHandle; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceCREATE_COUNTING_SEMAPHORE_FAILED_DISABLE)) +void EvrFreeRTOSQueue_CreateCountingSemaphoreFailed (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSQueue_CreateCountingSemaphoreFailed, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_SEND_DISABLE)) +void EvrFreeRTOSQueue_QueueSend (/*Queue_t*/void *pxQueue) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSQueue_QueueSend, (uint32_t)pxQueue, 0U); +#else + (void)pxQueue; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_SEND_FAILED_DISABLE)) +void EvrFreeRTOSQueue_QueueSendFailed (/*Queue_t*/void *pxQueue) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSQueue_QueueSendFailed, (uint32_t)pxQueue, 0U); +#else + (void)pxQueue; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_RECEIVE_DISABLE)) +void EvrFreeRTOSQueue_QueueReceive (/*Queue_t*/void *pxQueue) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSQueue_QueueReceive, (uint32_t)pxQueue, 0U); +#else + (void)pxQueue; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_PEEK_DISABLE)) +void EvrFreeRTOSQueue_QueuePeek (/*Queue_t*/void *pxQueue) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSQueue_QueuePeek, (uint32_t)pxQueue, 0U); +#else + (void)pxQueue; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_PEEK_FAILED_DISABLE)) +void EvrFreeRTOSQueue_QueuePeekFailed (/*Queue_t*/void *pxQueue) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSQueue_QueuePeekFailed, (uint32_t)pxQueue, 0U); +#else + (void)pxQueue; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_PEEK_FROM_ISR_DISABLE)) +void EvrFreeRTOSQueue_QueuePeekFromIsr (/*Queue_t*/void *pxQueue) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSQueue_QueuePeekFromIsr, (uint32_t)pxQueue, 0U); +#else + (void)pxQueue; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_RECEIVE_FAILED_DISABLE)) +void EvrFreeRTOSQueue_QueueReceiveFailed (/*Queue_t*/void *pxQueue) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSQueue_QueueReceiveFailed, (uint32_t)pxQueue, 0U); +#else + (void)pxQueue; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_SEND_FROM_ISR_DISABLE)) +void EvrFreeRTOSQueue_QueueSendFromIsr (/*Queue_t*/void *pxQueue) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSQueue_QueueSendFromIsr, (uint32_t)pxQueue, 0U); +#else + (void)pxQueue; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_SEND_FROM_ISR_FAILED_DISABLE)) +void EvrFreeRTOSQueue_QueueSendFromIsrFailed (/*Queue_t*/void *pxQueue) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSQueue_QueueSendFromIsrFailed, (uint32_t)pxQueue, 0U); +#else + (void)pxQueue; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_RECEIVE_FROM_ISR_DISABLE)) +void EvrFreeRTOSQueue_QueueReceiveFromIsr (/*Queue_t*/void *pxQueue) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSQueue_QueueReceiveFromIsr, (uint32_t)pxQueue, 0U); +#else + (void)pxQueue; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_RECEIVE_FROM_ISR_FAILED_DISABLE)) +void EvrFreeRTOSQueue_QueueReceiveFromIsrFailed (/*Queue_t*/void *pxQueue) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSQueue_QueueReceiveFromIsrFailed, (uint32_t)pxQueue, 0U); +#else + (void)pxQueue; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_PEEK_FROM_ISR_FAILED_DISABLE)) +void EvrFreeRTOSQueue_QueuePeekFromIsrFailed (/*Queue_t*/void *pxQueue) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSQueue_QueuePeekFromIsrFailed, (uint32_t)pxQueue, 0U); +#else + (void)pxQueue; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_DELETE_DISABLE)) +void EvrFreeRTOSQueue_QueueDelete (/*Queue_t*/void *pxQueue) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSQueue_QueueDelete, (uint32_t)pxQueue, 0U); +#else + (void)pxQueue; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_REGISTRY_ADD_DISABLE)) +void EvrFreeRTOSQueue_QueueRegistryAdd (/*Queue_t*/void *pxQueue, const char *pcQueueName) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSQueue_QueueRegistryAdd, (uint32_t)pxQueue, (uint32_t)pcQueueName); +#else + (void)pxQueue; + (void)pcQueueName; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceBLOCKING_ON_QUEUE_RECEIVE_DISABLE)) +void EvrFreeRTOSQueue_BlockingOnQueueReceive (/*Queue_t*/void *pxQueue) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSQueue_BlockingOnQueueReceive, (uint32_t)pxQueue, 0U); +#else + (void)pxQueue; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceBLOCKING_ON_QUEUE_SEND_DISABLE)) +void EvrFreeRTOSQueue_BlockingOnQueueSend (/*Queue_t*/void *pxQueue) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSQueue_BlockingOnQueueSend, (uint32_t)pxQueue, 0U); +#else + (void)pxQueue; +#endif +} +#endif + + +/* Timers */ + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTIMER_CREATE_DISABLE)) +void EvrFreeRTOSTimers_TimerCreate (/*Timer_t*/void *pxNewTimer) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_TimerCreate, (uint32_t)pxNewTimer, 0U); +#else + (void)pxNewTimer; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTIMER_CREATE_FAILED_DISABLE)) +void EvrFreeRTOSTimers_TimerCreateFailed (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_TimerCreateFailed, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTIMER_COMMAND_SEND_DISABLE)) +void EvrFreeRTOSTimers_TimerCommandSend (/*Timer_t*/void *pxTimer, uint32_t xCommandID, uint32_t xOptionalValue, uint32_t xReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord4(EvtFreeRTOSTimers_TimerCommandSend, (uint32_t)pxTimer, xCommandID, xOptionalValue, xReturn); +#else + (void)pxTimer; + (void)xCommandID; + (void)xOptionalValue; + (void)xReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTIMER_COMMAND_RECEIVED_DISABLE)) +void EvrFreeRTOSTimers_TimerCommandReceived (/*Timer_t*/void *pxTimer, uint32_t xCommandID, uint32_t xOptionalValue) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord4(EvtFreeRTOSTimers_TimerCommandReceived, (uint32_t)pxTimer, xCommandID, xOptionalValue, 0U); +#else + (void)pxTimer; + (void)xCommandID; + (void)xOptionalValue; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTIMER_EXPIRED_DISABLE)) +void EvrFreeRTOSTimers_TimerExpired (/*Timer_t*/void *pxTimer) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_TimerExpired, (uint32_t)pxTimer, 0U); +#else + (void)pxTimer; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(tracePEND_FUNC_CALL_DISABLE)) +void EvrFreeRTOSTimers_PendFuncCall (/*PendedFunction_t*/void *pxFunctionToPend, void *pvParameter1, uint32_t ulParameter2, uint32_t xReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord4(EvtFreeRTOSTimers_PendFuncCall, (uint32_t)pxFunctionToPend, (uint32_t)pvParameter1, ulParameter2, xReturn); +#else + (void)pxFunctionToPend; + (void)pvParameter1; + (void)ulParameter2; + (void)xReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(tracePEND_FUNC_CALL_FROM_ISR_DISABLE)) +void EvrFreeRTOSTimers_PendFuncCallFromIsr (/*PendedFunction_t*/void *pxFunctionToPend, void *pvParameter1, uint32_t ulParameter2, uint32_t xReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord4(EvtFreeRTOSTimers_PendFuncCallFromIsr, (uint32_t)pxFunctionToPend, (uint32_t)pvParameter1, ulParameter2, xReturn); +#else + (void)pxFunctionToPend; + (void)pvParameter1; + (void)ulParameter2; + (void)xReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTimerCreateTimerTask_DISABLE)) +void EvrFreeRTOSTimers_xTimerCreateTimerTask (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_xTimerCreateTimerTask, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTimerCreateTimerTask_DISABLE)) +void EvrFreeRTOSTimers_xTimerCreateTimerTask_Return (BaseType_t xReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_xTimerCreateTimerTask_Return, (uint32_t)xReturn, 0U); +#else + (void)xReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTimerCreate_DISABLE)) +void EvrFreeRTOSTimers_xTimerCreate (const char *pcTimerName, + const TickType_t xTimerPeriodInTicks, + const BaseType_t xAutoReload, + void *pvTimerID, + TimerCallbackFunction_t pxCallbackFunction) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord4(EvtFreeRTOSTimers_xTimerCreate_0, (uint32_t)pcTimerName, (uint32_t)xTimerPeriodInTicks, (uint32_t)xAutoReload, 0U); + EventRecord2(EvtFreeRTOSTimers_xTimerCreate_1, (uint32_t)pvTimerID, (uint32_t)pxCallbackFunction); +#else + (void)pcTimerName; + (void)xTimerPeriodInTicks; + (void)xAutoReload; + (void)pvTimerID; + (void)pxCallbackFunction; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTimerCreate_DISABLE)) +void EvrFreeRTOSTimers_xTimerCreate_Return (TimerHandle_t pxNewTimer) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_xTimerCreate_Return, (uint32_t)pxNewTimer, 0U); +#else + (void)pxNewTimer; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTimerCreateStatic_DISABLE)) +void EvrFreeRTOSTimers_xTimerCreateStatic (const char *pcTimerName, + const TickType_t xTimerPeriodInTicks, + const BaseType_t xAutoReload, + void *pvTimerID, + TimerCallbackFunction_t pxCallbackFunction, + StaticTimer_t *pxTimerBuffer) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord4(EvtFreeRTOSTimers_xTimerCreateStatic_0, (uint32_t)pcTimerName, (uint32_t)xTimerPeriodInTicks, (uint32_t)xAutoReload, 0U); + EventRecord4(EvtFreeRTOSTimers_xTimerCreateStatic_1, (uint32_t)pvTimerID, (uint32_t)pxCallbackFunction, (uint32_t)pxTimerBuffer, 0U); +#else + (void)pcTimerName; + (void)xTimerPeriodInTicks; + (void)xAutoReload; + (void)pvTimerID; + (void)pxCallbackFunction; + (void)pxTimerBuffer; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTimerCreateStatic_DISABLE)) +void EvrFreeRTOSTimers_xTimerCreateStatic_Return (TimerHandle_t pxNewTimer) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_xTimerCreateStatic_Return, (uint32_t)pxNewTimer, 0U); +#else + (void)pxNewTimer; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTimerGenericCommandFromTask_DISABLE)) +void EvrFreeRTOSTimers_xTimerGenericCommandFromTask (TimerHandle_t xTimer, + const BaseType_t xCommandID, + const TickType_t xOptionalValue, + BaseType_t *pxHigherPriorityTaskWoken, + const TickType_t xTicksToWait) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord4(EvtFreeRTOSTimers_xTimerGenericCommandFromTask_0, (uint32_t)xTimer, (uint32_t)xCommandID, (uint32_t)xOptionalValue, 0U); + EventRecord2(EvtFreeRTOSTimers_xTimerGenericCommandFromTask_1, (uint32_t)pxHigherPriorityTaskWoken, (uint32_t)xTicksToWait); +#else + (void)xTimer; + (void)xCommandID; + (void)xOptionalValue; + (void)pxHigherPriorityTaskWoken; + (void)xTicksToWait; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTimerGenericCommandFromTask_DISABLE)) +void EvrFreeRTOSTimers_xTimerGenericCommandFromTask_Return (BaseType_t xReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_xTimerGenericCommandFromTask_Return, (uint32_t)xReturn, 0U); +#else + (void)xReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTimerGenericCommandFromISR_DISABLE)) +void EvrFreeRTOSTimers_xTimerGenericCommandFromISR (TimerHandle_t xTimer, + const BaseType_t xCommandID, + const TickType_t xOptionalValue, + BaseType_t *pxHigherPriorityTaskWoken, + const TickType_t xTicksToWait) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord4(EvtFreeRTOSTimers_xTimerGenericCommandFromISR_0, (uint32_t)xTimer, (uint32_t)xCommandID, (uint32_t)xOptionalValue, 0U); + EventRecord2(EvtFreeRTOSTimers_xTimerGenericCommandFromISR_1, (uint32_t)pxHigherPriorityTaskWoken, (uint32_t)xTicksToWait); +#else + (void)xTimer; + (void)xCommandID; + (void)xOptionalValue; + (void)pxHigherPriorityTaskWoken; + (void)xTicksToWait; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTimerGenericCommandFromISR_DISABLE)) +void EvrFreeRTOSTimers_xTimerGenericCommandFromISR_Return (BaseType_t xReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_xTimerGenericCommandFromISR_Return, (uint32_t)xReturn, 0U); +#else + (void)xReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTimerGetTimerDaemonTaskHandle_DISABLE)) +void EvrFreeRTOSTimers_xTimerGetTimerDaemonTaskHandle (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_xTimerGetTimerDaemonTaskHandle, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTimerGetTimerDaemonTaskHandle_DISABLE)) +void EvrFreeRTOSTimers_xTimerGetTimerDaemonTaskHandle_Return (TaskHandle_t xTimerTaskHandle) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_xTimerGetTimerDaemonTaskHandle_Return, (uint32_t)xTimerTaskHandle, 0U); +#else + (void)xTimerTaskHandle; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTimerGetPeriod_DISABLE)) +void EvrFreeRTOSTimers_xTimerGetPeriod (TimerHandle_t xTimer) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_xTimerGetPeriod, (uint32_t)xTimer, 0U); +#else + (void)xTimer; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTimerGetPeriod_DISABLE)) +void EvrFreeRTOSTimers_xTimerGetPeriod_Return (uint32_t xReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_xTimerGetPeriod_Return, (uint32_t)xReturn, 0U); +#else + (void)xReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTimerSetReloadMode_DISABLE)) +void EvrFreeRTOSTimers_vTimerSetReloadMode (TimerHandle_t xTimer, const BaseType_t xAutoReload) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_vTimerSetReloadMode, (uint32_t)xTimer, (uint32_t)xAutoReload); +#else + (void)xTimer; + (void)xAutoReload; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTimerSetReloadMode_DISABLE)) +void EvrFreeRTOSTimers_vTimerSetReloadMode_Return (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_vTimerSetReloadMode_Return, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTimerGetReloadMode_DISABLE)) +void EvrFreeRTOSTimers_xTimerGetReloadMode (TimerHandle_t xTimer) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_xTimerGetReloadMode, (uint32_t)xTimer, 0U); +#else + (void)xTimer; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTimerGetReloadMode_DISABLE)) +void EvrFreeRTOSTimers_xTimerGetReloadMode_Return (BaseType_t xReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_xTimerGetReloadMode_Return, (uint32_t)xReturn, 0U); +#else + (void)xReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_uxTimerGetReloadMode_DISABLE)) +void EvrFreeRTOSTimers_uxTimerGetReloadMode (TimerHandle_t xTimer) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_uxTimerGetReloadMode, (uint32_t)xTimer, 0U); +#else + (void)xTimer; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_uxTimerGetReloadMode_DISABLE)) +void EvrFreeRTOSTimers_uxTimerGetReloadMode_Return (UBaseType_t uxReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_uxTimerGetReloadMode_Return, (uint32_t)uxReturn, 0U); +#else + (void)uxReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTimerGetExpiryTime_DISABLE)) +void EvrFreeRTOSTimers_xTimerGetExpiryTime (TimerHandle_t xTimer) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_xTimerGetExpiryTime, (uint32_t)xTimer, 0U); +#else + (void)xTimer; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTimerGetExpiryTime_DISABLE)) +void EvrFreeRTOSTimers_xTimerGetExpiryTime_Return (TickType_t xReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_xTimerGetExpiryTime_Return, (uint32_t)xReturn, 0U); +#else + (void)xReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTimerGetStaticBuffer_DISABLE)) +void EvrFreeRTOSTimers_xTimerGetStaticBuffer (TimerHandle_t xTimer, /*StaticTimer_t** */uint32_t ppxTimerBuffer) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_xTimerGetStaticBuffer, (uint32_t)xTimer, (uint32_t)ppxTimerBuffer); +#else + (void)xTimer; + (void)ppxTimerBuffer; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTimerGetStaticBuffer_DISABLE)) +void EvrFreeRTOSTimers_xTimerGetStaticBuffer_Return (BaseType_t xReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_xTimerGetStaticBuffer_Return, (uint32_t)xReturn, 0U); +#else + (void)xReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_pcTimerGetName_DISABLE)) +void EvrFreeRTOSTimers_pcTimerGetName (TimerHandle_t xTimer) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_pcTimerGetName, (uint32_t)xTimer, 0U); +#else + (void)xTimer; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_pcTimerGetName_DISABLE)) +void EvrFreeRTOSTimers_pcTimerGetName_Return (const char *pcTimerName) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_pcTimerGetName_Return, (uint32_t)pcTimerName, 0U); +#else + (void)pcTimerName; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTimerIsTimerActive_DISABLE)) +void EvrFreeRTOSTimers_xTimerIsTimerActive (TimerHandle_t xTimer) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_xTimerIsTimerActive, (uint32_t)xTimer, 0U); +#else + (void)xTimer; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTimerIsTimerActive_DISABLE)) +void EvrFreeRTOSTimers_xTimerIsTimerActive_Return (BaseType_t xReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_xTimerIsTimerActive_Return, (uint32_t)xReturn, 0U); +#else + (void)xReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_pvTimerGetTimerID_DISABLE)) +void EvrFreeRTOSTimers_pvTimerGetTimerID (const TimerHandle_t xTimer) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_pvTimerGetTimerID, (uint32_t)xTimer, 0U); +#else + (void)xTimer; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_pvTimerGetTimerID_DISABLE)) +void EvrFreeRTOSTimers_pvTimerGetTimerID_Return (void *pvReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_pvTimerGetTimerID_Return, (uint32_t)pvReturn, 0U); +#else + (void)pvReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTimerSetTimerID_DISABLE)) +void EvrFreeRTOSTimers_vTimerSetTimerID (TimerHandle_t xTimer, void *pvNewID) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_vTimerSetTimerID, (uint32_t)xTimer, (uint32_t)pvNewID); +#else + (void)xTimer; + (void)pvNewID; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTimerSetTimerID_DISABLE)) +void EvrFreeRTOSTimers_vTimerSetTimerID_Return (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_vTimerSetTimerID_Return, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTimerPendFunctionCallFromISR_DISABLE)) +void EvrFreeRTOSTimers_xTimerPendFunctionCallFromISR (PendedFunction_t xFunctionToPend, void *pvParameter1, uint32_t ulParameter2, BaseType_t *pxHigherPriorityTaskWoken) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord4(EvtFreeRTOSTimers_xTimerPendFunctionCallFromISR, (uint32_t)xFunctionToPend, (uint32_t)pvParameter1, (uint32_t)ulParameter2, (uint32_t)pxHigherPriorityTaskWoken); +#else + (void)xFunctionToPend; + (void)pvParameter1; + (void)ulParameter2; + (void)pxHigherPriorityTaskWoken; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTimerPendFunctionCallFromISR_DISABLE)) +void EvrFreeRTOSTimers_xTimerPendFunctionCallFromISR_Return (BaseType_t xReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_xTimerPendFunctionCallFromISR_Return, (uint32_t)xReturn, 0U); +#else + (void)xReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xTimerPendFunctionCall_DISABLE)) +void EvrFreeRTOSTimers_xTimerPendFunctionCall (PendedFunction_t xFunctionToPend, void *pvParameter1, uint32_t ulParameter2, TickType_t xTicksToWait) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord4(EvtFreeRTOSTimers_xTimerPendFunctionCall, (uint32_t)xFunctionToPend, (uint32_t)pvParameter1, (uint32_t)ulParameter2, (uint32_t)xTicksToWait); +#else + (void)xFunctionToPend; + (void)pvParameter1; + (void)ulParameter2; + (void)xTicksToWait; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xTimerPendFunctionCall_DISABLE)) +void EvrFreeRTOSTimers_xTimerPendFunctionCall_Return (BaseType_t xReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_xTimerPendFunctionCall_Return, (uint32_t)xReturn, 0U); +#else + (void)xReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_uxTimerGetTimerNumber_DISABLE)) +void EvrFreeRTOSTimers_uxTimerGetTimerNumber (TimerHandle_t xTimer) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_uxTimerGetTimerNumber, (uint32_t)xTimer, 0U); +#else + (void)xTimer; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_uxTimerGetTimerNumber_DISABLE)) +void EvrFreeRTOSTimers_uxTimerGetTimerNumber_Return (UBaseType_t uxReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_uxTimerGetTimerNumber_Return, (uint32_t)uxReturn, 0U); +#else + (void)uxReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vTimerSetTimerNumber_DISABLE)) +void EvrFreeRTOSTimers_vTimerSetTimerNumber (TimerHandle_t xTimer, UBaseType_t uxTimerNumber) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_vTimerSetTimerNumber, (uint32_t)xTimer, (uint32_t)uxTimerNumber); +#else + (void)xTimer; + (void)uxTimerNumber; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vTimerSetTimerNumber_DISABLE)) +void EvrFreeRTOSTimers_vTimerSetTimerNumber_Return (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSTimers_vTimerSetTimerNumber_Return, 0U, 0U); +#endif +} +#endif + + + +/* Event Groups */ + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceEVENT_GROUP_CREATE_DISABLE)) +void EvrFreeRTOSEventGroups_EventGroupCreate (/*EventGroup_t*/void *pxEventGroup) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSEventGroups_EventGroupCreate, (uint32_t)pxEventGroup, 0U); +#else + (void)pxEventGroup; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceEVENT_GROUP_CREATE_FAILED_DISABLE)) +void EvrFreeRTOSEventGroups_EventGroupCreateFailed (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSEventGroups_EventGroupCreateFailed, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceEVENT_GROUP_SYNC_BLOCK_DISABLE)) +void EvrFreeRTOSEventGroups_EventGroupSyncBlock (/*EventGroup_t*/void *pxEventGroup, uint32_t uxBitsToSet, uint32_t uxBitsToWaitFor) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord4(EvtFreeRTOSEventGroups_EventGroupSyncBlock, (uint32_t)pxEventGroup, uxBitsToSet, uxBitsToWaitFor, 0U); +#else + (void)pxEventGroup; + (void)uxBitsToSet; + (void)uxBitsToWaitFor; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceEVENT_GROUP_SYNC_END_DISABLE)) +void EvrFreeRTOSEventGroups_EventGroupSyncEnd (/*EventGroup_t*/void *pxEventGroup, uint32_t uxBitsToSet, uint32_t uxBitsToWaitFor, uint32_t xTimeoutOccurred) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord4(EvtFreeRTOSEventGroups_EventGroupSyncEnd, (uint32_t)pxEventGroup, uxBitsToSet, uxBitsToWaitFor, xTimeoutOccurred); +#else + (void)pxEventGroup; + (void)uxBitsToSet; + (void)uxBitsToWaitFor; + (void)xTimeoutOccurred; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceEVENT_GROUP_WAIT_BITS_BLOCK_DISABLE)) +void EvrFreeRTOSEventGroups_EventGroupWaitBitsBlock (/*EventGroup_t*/void *pxEventGroup, uint32_t uxBitsToWaitFor) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSEventGroups_EventGroupWaitBitsBlock, (uint32_t)pxEventGroup, uxBitsToWaitFor); +#else + (void)pxEventGroup; + (void)uxBitsToWaitFor; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceEVENT_GROUP_WAIT_BITS_END_DISABLE)) +void EvrFreeRTOSEventGroups_EventGroupWaitBitsEnd (/*EventGroup_t*/void *pxEventGroup, uint32_t uxBitsToWaitFor, uint32_t xTimeoutOccurred) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord4(EvtFreeRTOSEventGroups_EventGroupWaitBitsEnd, (uint32_t)pxEventGroup, uxBitsToWaitFor, xTimeoutOccurred, 0U); +#else + (void)pxEventGroup; + (void)uxBitsToWaitFor; + (void)xTimeoutOccurred; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceEVENT_GROUP_CLEAR_BITS_DISABLE)) +void EvrFreeRTOSEventGroups_EventGroupClearBits (/*EventGroup_t*/void *pxEventGroup, uint32_t uxBitsToClear) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSEventGroups_EventGroupClearBits, (uint32_t)pxEventGroup, uxBitsToClear); +#else + (void)pxEventGroup; + (void)uxBitsToClear; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceEVENT_GROUP_CLEAR_BITS_FROM_ISR_DISABLE)) +void EvrFreeRTOSEventGroups_EventGroupClearBitsFromIsr (/*EventGroup_t*/void *pxEventGroup, uint32_t uxBitsToClear) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSEventGroups_EventGroupClearBitsFromIsr, (uint32_t)pxEventGroup, uxBitsToClear); +#else + (void)pxEventGroup; + (void)uxBitsToClear; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceEVENT_GROUP_SET_BITS_DISABLE)) +void EvrFreeRTOSEventGroups_EventGroupSetBits (/*EventGroup_t*/void *pxEventGroup, uint32_t uxBitsToSet) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSEventGroups_EventGroupSetBits, (uint32_t)pxEventGroup, uxBitsToSet); +#else + (void)pxEventGroup; + (void)uxBitsToSet; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceEVENT_GROUP_SET_BITS_FROM_ISR_DISABLE)) +void EvrFreeRTOSEventGroups_EventGroupSetBitsFromIsr (/*EventGroup_t*/void *pxEventGroup, uint32_t uxBitsToSet) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSEventGroups_EventGroupSetBitsFromIsr, (uint32_t)pxEventGroup, uxBitsToSet); +#else + (void)pxEventGroup; + (void)uxBitsToSet; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceEVENT_GROUP_DELETE_DISABLE)) +void EvrFreeRTOSEventGroups_EventGroupDelete (/*EventGroup_t*/void *pxEventGroup) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSEventGroups_EventGroupDelete, (uint32_t)pxEventGroup, 0U); +#else + (void)pxEventGroup; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xEventGroupCreateStatic_DISABLE)) +void EvrFreeRTOSEventGroups_xEventGroupCreateStatic (StaticEventGroup_t *pxEventGroupBuffer) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSEventGroups_xEventGroupCreateStatic, (uint32_t)pxEventGroupBuffer, 0U); +#else + (void)pxEventGroupBuffer; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xEventGroupCreateStatic_DISABLE)) +void EvrFreeRTOSEventGroups_xEventGroupCreateStatic_Return (EventGroupHandle_t xEventGroup) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSEventGroups_xEventGroupCreateStatic_Return, (uint32_t)xEventGroup, 0U); +#else + (void)xEventGroup; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xEventGroupCreate_DISABLE)) +void EvrFreeRTOSEventGroups_xEventGroupCreate (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSEventGroups_xEventGroupCreate, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xEventGroupCreate_DISABLE)) +void EvrFreeRTOSEventGroups_xEventGroupCreate_Return (EventGroupHandle_t xEventGroup) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSEventGroups_xEventGroupCreate_Return, (uint32_t)xEventGroup, 0U); +#else + (void)xEventGroup; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xEventGroupSync_DISABLE)) +void EvrFreeRTOSEventGroups_xEventGroupSync (EventGroupHandle_t xEventGroup, + const EventBits_t uxBitsToSet, + const EventBits_t uxBitsToWaitFor, + TickType_t xTicksToWait) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord4(EvtFreeRTOSEventGroups_xEventGroupSync, (uint32_t)xEventGroup, (uint32_t)uxBitsToSet, (uint32_t)uxBitsToWaitFor, (uint32_t)xTicksToWait); +#else + (void)xEventGroup; + (void)uxBitsToSet; + (void)uxBitsToWaitFor; + (void)xTicksToWait; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xEventGroupSync_DISABLE)) +void EvrFreeRTOSEventGroups_xEventGroupSync_Return (EventBits_t uxReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSEventGroups_xEventGroupSync_Return, (uint32_t)uxReturn, 0U); +#else + (void)uxReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xEventGroupWaitBits_DISABLE)) +void EvrFreeRTOSEventGroups_xEventGroupWaitBits (EventGroupHandle_t xEventGroup, + const EventBits_t uxBitsToWaitFor, + const BaseType_t xClearOnExit, + const BaseType_t xWaitForAllBits, + TickType_t xTicksToWait) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord4(EvtFreeRTOSEventGroups_xEventGroupWaitBits_0, (uint32_t)xEventGroup, (uint32_t)uxBitsToWaitFor, (uint32_t)xClearOnExit, 0U); + EventRecord2(EvtFreeRTOSEventGroups_xEventGroupWaitBits_1, (uint32_t)xWaitForAllBits, (uint32_t)xTicksToWait); +#else + (void)xEventGroup; + (void)uxBitsToWaitFor; + (void)xClearOnExit; + (void)xWaitForAllBits; + (void)xTicksToWait; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xEventGroupWaitBits_DISABLE)) +void EvrFreeRTOSEventGroups_xEventGroupWaitBits_Return (EventBits_t uxReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSEventGroups_xEventGroupWaitBits_Return, (uint32_t)uxReturn, 0U); +#else + (void)uxReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xEventGroupClearBits_DISABLE)) +void EvrFreeRTOSEventGroups_xEventGroupClearBits (EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSEventGroups_xEventGroupClearBits, (uint32_t)xEventGroup, (uint32_t)uxBitsToClear); +#else + (void)xEventGroup; + (void)uxBitsToClear; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xEventGroupClearBits_DISABLE)) +void EvrFreeRTOSEventGroups_xEventGroupClearBits_Return (EventBits_t uxReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSEventGroups_xEventGroupClearBits_Return, (uint32_t)uxReturn, 0U); +#else + (void)uxReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xEventGroupClearBitsFromISR_DISABLE)) +void EvrFreeRTOSEventGroups_xEventGroupClearBitsFromISR (EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSEventGroups_xEventGroupClearBitsFromISR, (uint32_t)xEventGroup, (uint32_t)uxBitsToClear); +#else + (void)xEventGroup; + (void)uxBitsToClear; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xEventGroupClearBitsFromISR_DISABLE)) +void EvrFreeRTOSEventGroups_xEventGroupClearBitsFromISR_Return (BaseType_t xReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSEventGroups_xEventGroupClearBitsFromISR_Return, (uint32_t)xReturn, 0U); +#else + (void)xReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xEventGroupGetBitsFromISR_DISABLE)) +void EvrFreeRTOSEventGroups_xEventGroupGetBitsFromISR (EventGroupHandle_t xEventGroup) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSEventGroups_xEventGroupGetBitsFromISR, (uint32_t)xEventGroup, 0U); +#else + (void)xEventGroup; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xEventGroupGetBitsFromISR_DISABLE)) +void EvrFreeRTOSEventGroups_xEventGroupGetBitsFromISR_Return (EventBits_t uxReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSEventGroups_xEventGroupGetBitsFromISR_Return, (uint32_t)uxReturn, 0U); +#else + (void)uxReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xEventGroupSetBits_DISABLE)) +void EvrFreeRTOSEventGroups_xEventGroupSetBits (EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSEventGroups_xEventGroupSetBits, (uint32_t)xEventGroup, (uint32_t)uxBitsToSet); +#else + (void)xEventGroup; + (void)uxBitsToSet; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xEventGroupSetBits_DISABLE)) +void EvrFreeRTOSEventGroups_xEventGroupSetBits_Return (EventBits_t uxReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSEventGroups_xEventGroupSetBits_Return, (uint32_t)uxReturn, 0U); +#else + (void)uxReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vEventGroupDelete_DISABLE)) +void EvrFreeRTOSEventGroups_vEventGroupDelete (EventGroupHandle_t xEventGroup) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSEventGroups_vEventGroupDelete, (uint32_t)xEventGroup, 0U); +#else + (void)xEventGroup; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vEventGroupDelete_DISABLE)) +void EvrFreeRTOSEventGroups_vEventGroupDelete_Return (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSEventGroups_vEventGroupDelete_Return, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xEventGroupGetStaticBuffer_DISABLE)) +void EvrFreeRTOSEventGroups_xEventGroupGetStaticBuffer (EventGroupHandle_t xEventGroup, /*StaticEventGroup_t** */uint32_t ppxEventGroupBuffer) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSEventGroups_xEventGroupGetStaticBuffer, (uint32_t)xEventGroup, (uint32_t)ppxEventGroupBuffer); +#else + (void)xEventGroup; + (void)ppxEventGroupBuffer; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xEventGroupGetStaticBuffer_DISABLE)) +void EvrFreeRTOSEventGroups_xEventGroupGetStaticBuffer_Return (BaseType_t xReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSEventGroups_xEventGroupGetStaticBuffer_Return, (uint32_t)xReturn, 0U); +#else + (void)xReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vEventGroupSetBitsCallback_DISABLE)) +void EvrFreeRTOSEventGroups_vEventGroupSetBitsCallback (void *pvEventGroup, uint32_t ulBitsToSet) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSEventGroups_vEventGroupSetBitsCallback, (uint32_t)pvEventGroup, ulBitsToSet); +#else + (void)pvEventGroup; + (void)ulBitsToSet; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vEventGroupSetBitsCallback_DISABLE)) +void EvrFreeRTOSEventGroups_vEventGroupSetBitsCallback_Return (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSEventGroups_vEventGroupSetBitsCallback_Return, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vEventGroupClearBitsCallback_DISABLE)) +void EvrFreeRTOSEventGroups_vEventGroupClearBitsCallback (void *pvEventGroup, uint32_t ulBitsToClear) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSEventGroups_vEventGroupClearBitsCallback, (uint32_t)pvEventGroup, ulBitsToClear); +#else + (void)pvEventGroup; + (void)ulBitsToClear; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vEventGroupClearBitsCallback_DISABLE)) +void EvrFreeRTOSEventGroups_vEventGroupClearBitsCallback_Return (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSEventGroups_vEventGroupClearBitsCallback_Return, 0U, 0U); +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_xEventGroupSetBitsFromISR_DISABLE)) +void EvrFreeRTOSEventGroups_xEventGroupSetBitsFromISR (EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet, BaseType_t * pxHigherPriorityTaskWoken) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord4(EvtFreeRTOSEventGroups_xEventGroupSetBitsFromISR, (uint32_t)xEventGroup, (uint32_t)uxBitsToSet, (uint32_t)pxHigherPriorityTaskWoken, 0U); +#else + (void)xEventGroup; + (void)uxBitsToSet; + (void)pxHigherPriorityTaskWoken; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_xEventGroupSetBitsFromISR_DISABLE)) +void EvrFreeRTOSEventGroups_xEventGroupSetBitsFromISR_Return (BaseType_t xReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSEventGroups_xEventGroupSetBitsFromISR_Return, (uint32_t)xReturn, 0U); +#else + (void)xReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_uxEventGroupGetNumber_DISABLE)) +void EvrFreeRTOSEventGroups_uxEventGroupGetNumber (void *xEventGroup) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSEventGroups_uxEventGroupGetNumber, (uint32_t)xEventGroup, 0U); +#else + (void)xEventGroup; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_uxEventGroupGetNumber_DISABLE)) +void EvrFreeRTOSEventGroups_uxEventGroupGetNumber_Return (UBaseType_t xReturn) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSEventGroups_uxEventGroupGetNumber_Return, (uint32_t)xReturn, 0U); +#else + (void)xReturn; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceENTER_vEventGroupSetNumber_DISABLE)) +void EvrFreeRTOSEventGroups_vEventGroupSetNumber (void *xEventGroup, UBaseType_t uxEventGroupNumber) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSEventGroups_vEventGroupSetNumber, (uint32_t)xEventGroup, (uint32_t)uxEventGroupNumber); +#else + (void)xEventGroup; + (void)uxEventGroupNumber; +#endif +} +#endif + +#if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceRETURN_vEventGroupSetNumber_DISABLE)) +void EvrFreeRTOSEventGroups_vEventGroupSetNumber_Return (void) { +#if defined(RTE_Compiler_EventRecorder) || defined(RTE_CMSIS_View_EventRecorder) + EventRecord2(EvtFreeRTOSEventGroups_vEventGroupSetNumber_Return, 0U, 0U); +#endif +} +#endif /* Stream Buffer */ diff --git a/DoxyGen/src/freertos_evr.txt b/DoxyGen/src/freertos_evr.txt index 8641b9c4..b2562874 100644 --- a/DoxyGen/src/freertos_evr.txt +++ b/DoxyGen/src/freertos_evr.txt @@ -24,9 +24,6 @@ Behavior of this function execution is defined with Event Recorder Configuration no effect when Event Recorder component is not selected. \note \b EvrFreeRTOSSetup is called by function \b osKernelInitialize when CMSIS-RTOS2 API is in use and should not be called explicitly. - - - */ /** @@ -49,7 +46,6 @@ The steps are: - Build the application code and download it to the debug hardware. Once the target application generates event information, it can be viewed in the µVision debugger using the Event Recorder. - @{ */ @@ -305,440 +301,2866 @@ The event \b TaskNotifyGiveFromIsr is generated when task notify give from ISR i */ /** -@} +\fn void EvrFreeRTOSTasks_MovedTaskToDelayedList (TCB_t pxTCB) +\details +The event \b MovedTaskToDelayedList is generated when the wake time has not overflowed and a task is moved into the Delayed list. + +\b Value in the Event Recorder shows: + - \b pxTCB : pointer to running task handle (control block address). */ +/** +\fn void EvrFreeRTOSTasks_MovedTaskToOverflowDelayedList (TCB_t pxTCB) +\details +The event \b MovedTaskToOverflowDelayedList is generated when the wake time has overflowed and a task is moved into the Overflow Delayed list. + +\b Value in the Event Recorder shows: + - \b pxTCB : pointer to running task handle (control block address). +*/ /** -\defgroup freertos_evr_queue Message Queue Functions -\brief Events generated by message queue functions +\fn void EvrFreeRTOSTasks_xTaskCreateStatic (void *pxTaskCode, const char *pcName, const uint32_t ulStackDepth, void *pvParameters, uint32_t uxPriority, void *puxStackBuffer, void *pxTaskBuffer) \details -@{ +The event \b xTaskCreateStatic is generated when function xTaskCreateStatic is called. + +\b Value in the Event Recorder shows: + - \b pxTaskCode : pointer to task function. + - \b pcName : pointer to task name string. + - \b usStackDepth : stack depth. + - \b pvParameters : pointer to parameter(s) passed to task funtion. + - \b uxPriority : task priority. + - \b puxStackBuffer : pointer to buffer to be used for task stack. + - \b pxTaskBuffer : pointer to buffer to be used for task control block. */ /** -\fn void EvrFreeRTOSQueue_QueueCreate (Queue_t pxQueue) +\fn void EvrFreeRTOSTasks_xTaskCreateStatic_Return (TCB_t xReturn) \details -The event \b QueueCreate is generated when queue object is successfully created. +The event \b xTaskCreateStatic_Return is generated before function xTaskCreateStatic returns. \b Value in the Event Recorder shows: - - \b pxQueue : pointer to queue object handle (control block address). + - \b xReturn : pointer to created task handle. */ /** -\fn void EvrFreeRTOSQueue_QueueCreateFailed (uint32_t ucQueueType) +\fn void EvrFreeRTOSTasks_xTaskCreateStaticAffinitySet (void *pxTaskCode, const char *pcName, const uint32_t ulStackDepth, void *pvParameters, uint32_t uxPriority, void *puxStackBuffer, void *pxTaskBuffer, uint32_t uxCoreAffinityMask) \details -The event \b QueueCreateFailed is generated when queue object create fails due to insufficient heap memory. +The event \b xTaskCreateStaticAffinitySet is generated when function xTaskCreateStaticAffinitySet is called. \b Value in the Event Recorder shows: - - \b ucQueueType : x + - \b pxTaskCode : pointer to task function. + - \b pcName : pointer to task name string. + - \b usStackDepth : stack depth. + - \b pvParameters : pointer to parameter(s) passed to task funtion. + - \b uxPriority : task priority. + - \b puxStackBuffer : pointer to buffer to be used for task stack. + - \b pxTaskBuffer : pointer to buffer to be used for task control block. + - \b uxCoreAffinityMask : task affinity mask. */ /** -\fn void EvrFreeRTOSQueue_CreateMutex (Queue_t pxNewQueue) +\fn void EvrFreeRTOSTasks_xTaskCreateStaticAffinitySet_Return (TCB_t xReturn) \details -The event \b CreateMutex is generated when mutex object is successfully created. +The event \b is generated before function xTaskCreateStaticAffinitySet_Return returns. \b Value in the Event Recorder shows: - - \b pxNewQueue : pointer to mutex (queue) object handle (control block address). + - \b xReturn : pointer to created task handle. */ /** -\fn void EvrFreeRTOSQueue_CreateMutexFailed (void) +\fn void EvrFreeRTOSTasks_xTaskCreateRestrictedStatic (const TaskParameters_t *pxTaskDefinition, TaskHandle_t *pxCreatedTask) \details -The event \b CreateMutexFailed is generated when mutex object create fails due to insufficient heap memory. +The event \b xTaskCreateRestrictedStatic is generated when function xTaskCreateRestrictedStatic is called. + +\b Value in the Event Recorder shows: + - \b pxTaskDefinition : pointer to parameters required to create an MPU protected task. + - \b pxCreatedTask : pointer to where the created task handle is stored. */ /** -\fn void EvrFreeRTOSQueue_GiveMutexRecursive (Queue_t pxMutex) +\fn void EvrFreeRTOSTasks_xTaskCreateRestrictedStatic_Return (uint32_t xReturn) \details -The event \b GiveMutexRecursive is generated when mutex give operation is successfully executed. +The event \b xTaskCreateRestrictedStatic_Return is generated before function xTaskCreateRestrictedStatic returns. \b Value in the Event Recorder shows: - - \b pxMutex : pointer to mutex (queue) object handle (control block address). + - \b xReturn : return status. */ /** -\fn void EvrFreeRTOSQueue_GiveMutexRecursiveFailed (Queue_t pxMutex) +\fn void EvrFreeRTOSTasks_xTaskCreateRestrictedStaticAffinitySet (const TaskParameters_t * pxTaskDefinition, UBaseType_t uxCoreAffinityMask, TaskHandle_t *pxCreatedTask) \details -The event \b GiveMutexRecursiveFailed is generated when recursive mutex give operation was not successful. +The event \b xTaskCreateRestrictedStaticAffinitySet is generated when function xTaskCreateRestrictedStaticAffinitySet is called. \b Value in the Event Recorder shows: - - \b pxMutex : pointer to mutex (queue) object handle (control block address). + - \b pxTaskDefinition : pointer to parameters required to create an MPU protected task. + - \b uxCoreAffinityMask : affinity mask + - \b pxCreatedTask : pointer to where the created task handle is stored. */ /** -\fn void EvrFreeRTOSQueue_TakeMutexRecursive (Queue_t pxMutex) +\fn void EvrFreeRTOSTasks_xTaskCreateRestrictedStaticAffinitySet_Return (uint32_t xReturn) \details -The event \b TakeMutexRecursive is generated when recursive mutex take operation is successfully executed. +The event \b xTaskCreateRestrictedStaticAffinitySet_Return is generated before function xTaskCreateRestrictedStaticAffinitySet returns. \b Value in the Event Recorder shows: - - \b pxMutex : pointer to mutex (queue) object handle (control block address). + - \b xReturn : return status. */ /** -\fn void EvrFreeRTOSQueue_TakeMutexRecursiveFailed (Queue_t pxMutex) +\fn void EvrFreeRTOSTasks_xTaskCreateRestricted (const TaskParameters_t *pxTaskDefinition, TaskHandle_t *pxCreatedTask) \details -The event \b TakeMutexRecursiveFailed is generated when recursive mutex take operation is not successful. +The event \b xTaskCreateRestricted is generated when function xTaskCreateRestricted is called. \b Value in the Event Recorder shows: - - \b pxMutex : pointer to mutex (queue) object handle (control block address). + - \b pxTaskDefinition : pointer to parameters required to create an MPU protected task. + - \b pxCreatedTask : pointer to where the created task handle is stored. */ /** -\fn void EvrFreeRTOSQueue_CreateCountingSemaphore (Queue_t xHandle) +\fn void EvrFreeRTOSTasks_xTaskCreateRestricted_Return (uint32_t xReturn) \details -The event \b CreateCountingSemaphore is generated when counting semaphore object is successfully created. +The event \b xTaskCreateRestricted_Return is generated before function xTaskCreateRestricted returns. \b Value in the Event Recorder shows: - - \b xHandle : pointer to semaphore (queue) object handle (control block address). + - \b xReturn : return status. */ /** -\fn void EvrFreeRTOSQueue_CreateCountingSemaphoreFailed (void) +\fn void EvrFreeRTOSTasks_xTaskCreateRestrictedAffinitySet (TaskParameters_t *pxTaskDefinition, uint32_t uxCoreAffinityMask, void *pxCreatedTask) \details -The event \b CreateCountingSemaphoreFailed is generated when semaphore object create fails due to insufficient heap memory. +The event \b xTaskCreateRestrictedAffinitySet is generated when function xTaskCreateRestrictedAffinitySet is called. + +\b Value in the Event Recorder shows: + - \b pxTaskDefinition : pointer to parameters required to create an MPU protected task. + - \b uxCoreAffinityMask : affinity mask. + - \b pxCreatedTask : pointer to where the created task handle is stored. + */ /** -\fn void EvrFreeRTOSQueue_QueueSend (Queue_t pxQueue) +\fn void EvrFreeRTOSTasks_xTaskCreateRestrictedAffinitySet_Return (uint32_t xReturn) \details -The event \b QueueSend is generated when the queue send operation was successful. +The event \b xTaskCreateRestrictedAffinitySet_Return is generated before function xTaskCreateRestrictedAffinitySet returns. \b Value in the Event Recorder shows: - - \b pxQueue : pointer to queue object handle (control block address). + - \b xReturn : return status. */ /** -\fn void EvrFreeRTOSQueue_QueueSendFailed (Queue_t pxQueue) +\fn void EvrFreeRTOSTasks_xTaskCreate (void *pxTaskCode, const char *pcName, uint32_t usStackDepth, void *pvParameters, uint32_t uxPriority, void *pxCreatedTask) \details -The event \b QueueSendFailed is generated when the queue send operation fails due to the queue being full. +The event \b xTaskCreate is generated when function xTaskCreate is called. \b Value in the Event Recorder shows: - - \b pxQueue : pointer to queue object handle (control block address). + - \b pxTaskCode : pointer to task function. + - \b pcName : pointer to task name string. + - \b usStackDepth : stack depth. + - \b pvParameters : pointer to parameter(s) passed to task funtion. + - \b uxPriority : task priority. + - \b pxCreatedTask : pointer to where the created task handle is stored. */ /** -\fn void EvrFreeRTOSQueue_QueueReceive (Queue_t pxQueue) +\fn void EvrFreeRTOSTasks_xTaskCreate_Return (uint32_t xReturn) \details -The event \b QueueReceive is generated when the queue receive operation was successful. +The event \b xTaskCreate_Return is generated before function xTaskCreate returns. \b Value in the Event Recorder shows: - - \b pxQueue : pointer to queue object handle (control block address). + - \b xReturn : return status. */ /** -\fn void EvrFreeRTOSQueue_QueuePeek (Queue_t pxQueue) +\fn void EvrFreeRTOSTasks_xTaskCreateAffinitySet (void *pxTaskCode, const char *pcName, const uint32_t usStackDepth, void *pvParameters, uint32_t uxPriority, uint32_t uxCoreAffinityMask, void *pxCreatedTask) \details -The event \b QueuePeek is generated when the queue peek operation was successful. +The event \b xTaskCreateAffinitySet is generated when function xTaskCreateAffinitySet is called. \b Value in the Event Recorder shows: - - \b pxQueue : pointer to queue object handle (control block address). + - \b pxTaskCode : pointer to task function. + - \b pcName : pointer to task name string. + - \b usStackDepth : stack depth. + - \b pvParameters : pointer to parameter(s) passed to task funtion. + - \b uxPriority : task priority. + - \b uxCoreAffinityMask : task affinity mask + - \b pxCreatedTask : pointer to where the created task handle is stored. */ /** -\fn void EvrFreeRTOSQueue_QueuePeekFromIsr (Queue_t pxQueue) +\fn void EvrFreeRTOSTasks_xTaskCreateAffinitySet_Return (uint32_t xReturn) \details -The event \b QueuePeekFromIsr is generated when the queue peek from ISR operation was successful. +The event \b xTaskCreateAffinitySet_Return is generated before function xTaskCreateAffinitySet returns. \b Value in the Event Recorder shows: - - \b pxQueue : pointer to queue object handle (control block address). + - \b xReturn : return status. */ /** -\fn void EvrFreeRTOSQueue_QueueReceiveFailed (Queue_t pxQueue) +\fn void EvrFreeRTOSTasks_vTaskDelete (void *xTaskToDelete) \details -The event \b QueueReceiveFailed is generated when the queue receive operation failed because the queue was empty. +The event \b vTaskDelete is generated when function vTaskDelete is called. \b Value in the Event Recorder shows: - - \b pxQueue : pointer to queue object handle (control block address). + - \b xTaskToDelete : handle to the task to delete */ /** -\fn void EvrFreeRTOSQueue_QueueSendFromIsr (Queue_t pxQueue) +\fn void EvrFreeRTOSTasks_vTaskDelete_Return (void) \details -The event \b QueueSendFromIsr is generated when the queue send from ISR operation was successful. +The event \b vTaskDelete_Return is generated before function vTaskDelete returns. \b Value in the Event Recorder shows: - - \b pxQueue : pointer to queue object handle (control block address). + - \b no value shown */ /** -\fn void EvrFreeRTOSQueue_QueueSendFromIsrFailed (Queue_t pxQueue) +\fn void EvrFreeRTOSTasks_xTaskDelayUntil (uint32_t *pxPreviousWakeTime, const uint32_t xTimeIncrement) \details -The event \b QueueSendFromIsrFailed is generated when the queue send operation fails due to the queue already being full. +The event \b xTaskDelayUntil is generated when function xTaskDelayUntil is called. \b Value in the Event Recorder shows: - - \b pxQueue : pointer to queue object handle (control block address). + - \b pxPreviousWakeTime : pointer to variable that holds the task last unblock time. + - \b xTimeIncrement : the cycle time period. */ /** -\fn void EvrFreeRTOSQueue_QueueReceiveFromIsr (Queue_t pxQueue) +\fn void EvrFreeRTOSTasks_xTaskDelayUntil_Return (uint32_t xShouldDelay) \details -The event \b QueueReceiveFromIsr is generated when the queue receive from ISR operation was successful. +The event \b xTaskDelayUntil_Return is generated before function xTaskDelayUntil returns. \b Value in the Event Recorder shows: - - \b pxQueue : pointer to queue object handle (control block address). + - \b xShouldDelay : return status. */ /** -\fn void EvrFreeRTOSQueue_QueueReceiveFromIsrFailed (Queue_t pxQueue) +\fn void EvrFreeRTOSTasks_vTaskDelay (const uint32_t xTicksToDelay) \details -The event \b QueueReceiveFromIsrFailed is generated when the queue receive operation fails due to the queue already being empty. +The event \b vTaskDelay is generated when function vTaskDelay is called. \b Value in the Event Recorder shows: - - \b pxQueue : pointer to queue object handle (control block address). + - \b xTicksToDelay : the number of ticks that the calling task should block. */ /** -\fn void EvrFreeRTOSQueue_QueuePeekFromIsrFailed (Queue_t pxQueue) +\fn void EvrFreeRTOSTasks_vTaskDelay_Return (void) \details -The event \b QueuePeekFromIsrFailed is generated when queue peek operation is executed from an ISR and the queue is empty. +The event \b vTaskDelay_Return is generated before function vTaskDelay returns. \b Value in the Event Recorder shows: - - \b pxQueue : pointer to queue object handle (control block address). + - \b no value shown */ /** -\fn void EvrFreeRTOSQueue_QueueDelete (Queue_t pxQueue) +\fn void EvrFreeRTOSTasks_eTaskGetState (TaskHandle_t xTask) \details -The event \b QueueDelete is generated when the function vQueueDelete is called. +The event \b eTaskGetState is generated when function eTaskGetState is called. \b Value in the Event Recorder shows: - - \b pxQueue : pointer to queue object handle (control block address). + - \b xTask : handle to the task */ /** -\fn void EvrFreeRTOSQueue_QueueRegistryAdd (Queue_t pxQueue, const char *pcQueueName) +\fn void EvrFreeRTOSTasks_eTaskGetState_Return (eTaskState eReturn) \details -The event \b QueueRegistryAdd is generated when a human readable name is registered to the specified queue. +The event \b eTaskGetState_Return is generated before function eTaskGetState returns. \b Value in the Event Recorder shows: - - \b pxQueue : pointer to queue object handle (control block address). - - \b pcQueueName : pointer to the ASCII string. + - \b eReturn : returned task state */ /** -\fn void EvrFreeRTOSQueue_BlockingOnQueueReceive (Queue_t pxQueue) +\fn void EvrFreeRTOSTasks_uxTaskPriorityGet (TaskHandle_t xTask) \details -The event \b BlockingOnQueueReceive is generated when the currently executing task is about to block following -an attempt to read from an empty queue, or an attempt to 'take' an empty semaphore or mutex. +The event \b uxTaskPriorityGet is generated when function uxTaskPriorityGet is called. \b Value in the Event Recorder shows: - - \b pxQueue : pointer to queue object handle (control block address). + - \b xTask : task handle. */ /** -\fn void EvrFreeRTOSQueue_BlockingOnQueueSend (Queue_t pxQueue) +\fn void EvrFreeRTOSTasks_uxTaskPriorityGet_Return (uint32_t uxReturn) \details -The event \b BlockingOnQueueSend is generated when the currently executing task is about to block following -an attempt to write to a full queue. +The event \b uxTaskPriorityGet_Return is generated before function uxTaskPriorityGet returns. \b Value in the Event Recorder shows: - - \b pxQueue : pointer to queue object handle (control block address). + - \b uxReturn : task priority. */ /** -@} +\fn void EvrFreeRTOSTasks_uxTaskPriorityGetFromISR (TaskHandle_t xTask) +\details +The event \b uxTaskPriorityGetFromISR is generated when function uxTaskPriorityGetFromISR is called. + +\b Value in the Event Recorder shows: + - \b xTask : task handle. */ +/** +\fn void EvrFreeRTOSTasks_uxTaskPriorityGetFromISR_Return (uint32_t uxReturn) +\details +The event \b uxTaskPriorityGetFromISR_Return is generated before function uxTaskPriorityGetFromISR returns. + +\b Value in the Event Recorder shows: + - \b uxReturn : task priority. +*/ /** -\defgroup freertos_evr_timers Timer Functions -\brief Events generated by timer functions +\fn void EvrFreeRTOSTasks_uxTaskBasePriorityGet (TaskHandle_t xTask) \details -@{ +The event \b uxTaskBasePriorityGet is generated when function uxTaskBasePriorityGet is called. + +\b Value in the Event Recorder shows: + - \b xTask : task handle. */ /** -\fn void EvrFreeRTOSTimers_TimerCreate (Timer_t pxNewTimer) +\fn void EvrFreeRTOSTasks_uxTaskBasePriorityGet_Return (uint32_t uxReturn) \details -The event \b TimerCreate is generated when timer object is successfully created. +The event \b uxTaskBasePriorityGet_Return is generated before function uxTaskBasePriorityGet returns. \b Value in the Event Recorder shows: - - \b pxNewTimer : pointer to timer object handle (control block address). + - \b uxReturn : task priority. */ /** -\fn void EvrFreeRTOSTimers_TimerCreateFailed (void) +\fn void EvrFreeRTOSTasks_uxTaskBasePriorityGetFromISR (TaskHandle_t xTask) \details -The event \b TimerCreateFailed is generated when timer object create fails due to insufficient heap memory. +The event \b uxTaskBasePriorityGetFromISR is generated when function uxTaskBasePriorityGetFromISR is called. + +\b Value in the Event Recorder shows: + - \b xTask : task handle. */ /** -\fn void EvrFreeRTOSTimers_TimerCommandSend (Timer_t pxTimer, uint32_t xCommandID, uint32_t xOptionalValue, uint32_t xReturn) +\fn void EvrFreeRTOSTasks_uxTaskBasePriorityGetFromISR_Return (uint32_t uxReturn) \details -The event \b TimerCommandSend is generated when a command is sent to the timer service task, +The event \b uxTaskBasePriorityGetFromISR_Return is generated before function uxTaskBasePriorityGetFromISR returns. \b Value in the Event Recorder shows: - - \b pxTimer : pointer to timer object handle (control block address). - - \b xCommandID : timer command ID. - - \b xOptionalValue : optional command value. - - \b xReturn : execution status (0: failed, command was not sent to the timer command queue, 1: passed, command sent) + - \b uxReturn : task priority. */ /** -\fn void EvrFreeRTOSTimers_TimerCommandReceived (Timer_t pxTimer, uint32_t xCommandID, uint32_t xOptionalValue) +\fn void EvrFreeRTOSTasks_vTaskPrioritySet (TaskHandle_t xTask, uint32_t uxNewPriority) \details -The event \b TimerCommandReceived is generated when the timer service task receives a command and before the command is actually processed. +The event \b vTaskPrioritySet is generated when function vTaskPrioritySet is called. \b Value in the Event Recorder shows: - - \b pxTimer : pointer to timer object handle (control block address). - - \b xCommandID : timer command ID. - - \b xOptionalValue : optional command value. + - \b xTask : task handle. + - \b uxNewPriority : task priority to set. */ /** -\fn void EvrFreeRTOSTimers_TimerExpired (Timer_t pxTimer) +\fn void EvrFreeRTOSTasks_vTaskPrioritySet_Return (void) \details -The event \b TimerExpired is generated when a software timer expires and before the timer callback is executed. +The event \b vTaskPrioritySet_Return is generated before function vTaskPrioritySet returns. \b Value in the Event Recorder shows: - - \b pxTimer : pointer to timer object handle (control block address). + - \b no value shown */ /** -\fn void EvrFreeRTOSTimers_PendFuncCall (PendedFunction_t pxFunctionToPend, void *pvParameter1, uint32_t ulParameter2, uint32_t xReturn) +\fn void EvrFreeRTOSTasks_vTaskCoreAffinitySet (TaskHandle_t xTask, uint32_t uxCoreAffinityMask) \details -The event \b PendFuncCall is generated before the function xTimerPendFunctionCall returns. +The event \b vTaskCoreAffinitySet is generated when function vTaskCoreAffinitySet is called. \b Value in the Event Recorder shows: - - \b pxFunctionToPend : callback function to execute from the timer service/deamon task. - - \b pvParameter1 : the value passed into the callback function as the first parameter. - - \b ulParameter2 : the value passed into the callback function as the second parameter. - - \b xReturn : execution status (1=callback passed to the timer sevice task, any other value: queue full, failed to register the callback execution) + - \b xTask : task handle. + - \b uxCoreAffinityMask : core affinity to set. */ /** -\fn void EvrFreeRTOSTimers_PendFuncCallFromIsr (PendedFunction_t pxFunctionToPend, void *pvParameter1, uint32_t ulParameter2, uint32_t xReturn) +\fn void EvrFreeRTOSTasks_vTaskCoreAffinitySet_Return (void) \details -The event \b PendFuncCallFromIsr is generated before the function xTimerPendFunctionCallFromISR returns. +The event \b vTaskCoreAffinitySet_Return is generated before function vTaskCoreAffinitySet returns. \b Value in the Event Recorder shows: - - \b pxFunctionToPend : callback function to execute from the timer service/deamon task. - - \b pvParameter1 : the value passed into the callback function as the first parameter. - - \b ulParameter2 : the value passed into the callback function as the second parameter. - - \b xReturn : execution status (1=callback passed to the timer sevice task, any other value: queue full, failed to register the callback execution) + - \b no value shown */ /** -@} +\fn void EvrFreeRTOSTasks_vTaskCoreAffinityGet (ConstTaskHandle_t xTask) +\details +The event \b vTaskCoreAffinityGet is generated when function vTaskCoreAffinityGet is called. + +\b Value in the Event Recorder shows: + - \b xTask : task handle. */ +/** +\fn void EvrFreeRTOSTasks_vTaskCoreAffinityGet_Return (uint32_t uxCoreAffinityMask) +\details +The event \b vTaskCoreAffinityGet_Return is generated before function vTaskCoreAffinityGet returns. + +\b Value in the Event Recorder shows: +- \b uxCoreAffinityMask : core affinity of a task. +*/ /** -\defgroup freertos_evr_event_groups Event Groups Functions -\brief Events generated by event groups functions +\fn void EvrFreeRTOSTasks_vTaskPreemptionDisable (TaskHandle_t xTask) \details -@{ +The event \b vTaskPreemptionDisable is generated when function vTaskPreemptionDisable is called. + +\b Value in the Event Recorder shows: + - \b xTask : task handle. */ /** -\fn void EvrFreeRTOSEventGroups_EventGroupCreate (EventGroup_t pxEventGroup) +\fn void EvrFreeRTOSTasks_vTaskPreemptionDisable_Return (void) \details -The event \b EventGroupCreate is generated when Event Groups object is successfully created. +The event \b vTaskPreemptionDisable_Return is generated before function vTaskPreemptionDisable returns. \b Value in the Event Recorder shows: - - \b pxEventGroup : pointer to Event Groups object handle (control block address) + - \b no value shown */ /** -\fn void EvrFreeRTOSEventGroups_EventGroupCreateFailed (void) +\fn void EvrFreeRTOSTasks_vTaskPreemptionEnable (TaskHandle_t xTask) \details -The event \b EventGroupCreateFailed is generated when Event Groups object create fails due to insufficient heap memory. +The event \b vTaskPreemptionEnable is generated when function vTaskPreemptionEnable is called. + +\b Value in the Event Recorder shows: + - \b xTask : task handle. */ /** -\fn void EvrFreeRTOSEventGroups_EventGroupSyncBlock (EventGroup_t pxEventGroup, uint32_t uxBitsToSet, uint32_t uxBitsToWaitFor) +\fn void EvrFreeRTOSTasks_vTaskPreemptionEnable_Return (void) \details -The event \b EventGroupSyncBlock is generated before the function xEventGroupSync enters blocked state. +The event \b vTaskPreemptionEnable_Return is generated before function vTaskPreemptionEnable returns. \b Value in the Event Recorder shows: - - \b pxEventGroup : pointer to Event Groups object handle (control block address) - - \b uxBitsToSet : event bits that shall be set. - - \b uxBitsToWaitFor : event bits to wait for. + - \b no value shown */ /** -\fn void EvrFreeRTOSEventGroups_EventGroupSyncEnd (EventGroup_t pxEventGroup, uint32_t uxBitsToSet, uint32_t uxBitsToWaitFor, uint32_t xTimeoutOccurred) +\fn void EvrFreeRTOSTasks_vTaskSuspend (TaskHandle_t xTaskToSuspend) \details -The event \b EventGroupSyncEnd is generated before the function xEventGroupSync returns. +The event \b vTaskSuspend is generated when function vTaskSuspend is called. \b Value in the Event Recorder shows: - - \b pxEventGroup : pointer to Event Groups object handle (control block address) - - \b uxBitsToSet : event bits that shall be set. - - \b uxBitsToWaitFor : event bits to wait for. - - \b xTimeoutOccurred : timeout value (0=timeout occurred, 1=no timeout) + - \b xTaskToSuspend : task handle. */ /** -\fn void EvrFreeRTOSEventGroups_EventGroupWaitBitsBlock (EventGroup_t pxEventGroup, uint32_t uxBitsToWaitFor) +\fn void EvrFreeRTOSTasks_vTaskSuspend_Return (void) \details -The event \b EventGroupWaitBitsBlock is generated before the function xEventGroupWaitBits enters blocked state. +The event \b vTaskSuspend_Return is generated before function vTaskSuspend returns. \b Value in the Event Recorder shows: - - \b pxEventGroup : pointer to Event Groups object handle (control block address) - - \b uxBitsToWaitFor : event bits to wait for. + - \b no value shown */ /** -\fn void EvrFreeRTOSEventGroups_EventGroupWaitBitsEnd (EventGroup_t pxEventGroup, uint32_t uxBitsToWaitFor, uint32_t xTimeoutOccurred) +\fn void EvrFreeRTOSTasks_vTaskResume (TaskHandle_t xTaskToResume) \details -The event \b EventGroupWaitBitsEnd is generated before the function xEventGroupWaitBits returns. +The event \b vTaskResume is generated when function vTaskResume is called. \b Value in the Event Recorder shows: - - \b pxEventGroup : pointer to Event Groups object handle (control block address) - - \b uxBitsToWaitFor : event bits to wait for. - - \b xTimeoutOccurred : timeout value (0=timeout occurred, 1=no timeout) + - \b xTaskToResume : task handle. */ /** -\fn void EvrFreeRTOSEventGroups_EventGroupClearBits (EventGroup_t pxEventGroup, uint32_t uxBitsToClear) +\fn void EvrFreeRTOSTasks_vTaskResume_Return (void) \details -The event \b EventGroupClearBits is generated when the function xEventGroupClearBits is called. +The event \b vTaskResume_Return is generated before function vTaskResume returns. \b Value in the Event Recorder shows: - - \b pxEventGroup : pointer to Event Groups object handle (control block address) - - \b uxBitsToClear : event bits that shall be cleared. + - \b no value shown */ /** -\fn void EvrFreeRTOSEventGroups_EventGroupClearBitsFromIsr (EventGroup_t pxEventGroup, uint32_t uxBitsToClear) +\fn void EvrFreeRTOSTasks_xTaskResumeFromISR (TaskHandle_t xTaskToResume) \details -The event \b EventGroupClearBitsFromIsr is generated when the function xEventGroupClearBitsFromISR is called. +The event \b xTaskResumeFromISR is generated when function xTaskResumeFromISR is called. \b Value in the Event Recorder shows: - - \b pxEventGroup : pointer to Event Groups object handle (control block address) - - \b uxBitsToClear : event bits that shall be cleared. + - \b xTaskToResume : task handle. */ /** -\fn void EvrFreeRTOSEventGroups_EventGroupSetBits (EventGroup_t pxEventGroup, uint32_t uxBitsToSet) +\fn void EvrFreeRTOSTasks_xTaskResumeFromISR_Return (uint32_t xYieldRequired) \details -The event \b EventGroupSetBits is generated when the function xEventGroupSetBits is called. +The event \b xTaskResumeFromISR_Return is generated before function xTaskResumeFromISR returns. \b Value in the Event Recorder shows: - - \b pxEventGroup : pointer to Event Groups object handle (control block address) - - \b uxBitsToSet : event bits that shall be set. + - \b xYieldRequired : info if resuming a task results in a context switch */ /** -\fn void EvrFreeRTOSEventGroups_EventGroupSetBitsFromIsr (EventGroup_t pxEventGroup, uint32_t uxBitsToSet) +\fn void EvrFreeRTOSTasks_vTaskStartScheduler (void) \details -The event \b EventGroupSetBitsFromIsr is generated when the function xEventGroupSetBitsFromISR is called. +The event \b vTaskStartScheduler is generated when function vTaskStartScheduler is called. \b Value in the Event Recorder shows: - - \b pxEventGroup : pointer to Event Groups object handle (control block address) - - \b uxBitsToSet : event bits that shall be set. + - \b no value shown */ /** -\fn void EvrFreeRTOSEventGroups_EventGroupDelete (EventGroup_t pxEventGroup) +\fn void EvrFreeRTOSTasks_vTaskStartScheduler_Return (void) \details -The event \b EventGroupDelete is generated when Event Group object is successfully added to object delete queue. +The event \b vTaskStartScheduler_Return is generated before function vTaskStartScheduler returns. \b Value in the Event Recorder shows: - - \b pxEventGroup : pointer to Event Groups object handle (control block address) + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskEndScheduler (void) +\details +The event \b vTaskEndScheduler is generated when function vTaskEndScheduler is called. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskEndScheduler_Return (void) +\details +The event \b vTaskEndScheduler_Return is generated before function vTaskEndScheduler returns. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskSuspendAll (void) +\details +The event \b vTaskSuspendAll is generated when function vTaskSuspendAll is called. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskSuspendAll_Return (void) +\details +The event \b vTaskSuspendAll_Return is generated before function vTaskSuspendAll returns. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskResumeAll (void) +\details +The event \b xTaskResumeAll is generated when function xTaskResumeAll is called. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskResumeAll_Return (uint32_t xAlreadyYielded) +\details +The event \b xTaskResumeAll_Return is generated before function xTaskResumeAll returns. + +\b Value in the Event Recorder shows: + - \b xAlreadyYielded : info if resuming the scheduler caused a context switch. +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskGetTickCount (void) +\details +The event \b xTaskGetTickCount is generated when function xTaskGetTickCount is called. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskGetTickCount_Return (uint32_t xTicks) +\details +The event \b xTaskGetTickCount_Return is generated before function xTaskGetTickCount returns. + +\b Value in the Event Recorder shows: + - \b xTicks : count of ticks since scheduler was called. +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskGetTickCountFromISR (void) +\details +The event \b xTaskGetTickCountFromISR is generated when function xTaskGetTickCountFromISR is called. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskGetTickCountFromISR_Return (uint32_t xTicks) +\details +The event \b xTaskGetTickCountFromISR_Return is generated before function xTaskGetTickCountFromISR returns. + +\b Value in the Event Recorder shows: + - \b xTicks : count of ticks since scheduler was called. +*/ + +/** +\fn void EvrFreeRTOSTasks_uxTaskGetNumberOfTasks (void) +\details +The event \b uxTaskGetNumberOfTasks is generated when function uxTaskGetNumberOfTasks is called. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_uxTaskGetNumberOfTasks_Return (uint32_t uxCurrentNumberOfTasks) +\details +The event \b uxTaskGetNumberOfTasks_Return is generated before function uxTaskGetNumberOfTasks returns. + +\b Value in the Event Recorder shows: + - \b uxCurrentNumberOfTasks : current number of tasks. +*/ + +/** +\fn void EvrFreeRTOSTasks_pcTaskGetName (TaskHandle_t xTaskToQuery) +\details +The event \b pcTaskGetName is generated when function pcTaskGetName is called. + +\b Value in the Event Recorder shows: + - \b xTaskToQuery : task handle. +*/ + +/** +\fn void EvrFreeRTOSTasks_pcTaskGetName_Return (char *pcTaskName) +\details +The event \b pcTaskGetName_Return is generated before function pcTaskGetName returns. + +\b Value in the Event Recorder shows: + - \b pcTaskName : task name. +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskGetHandle (const char *pcNameToQuery) +\details +The event \b xTaskGetHandle is generated when function xTaskGetHandle is called. + +\b Value in the Event Recorder shows: + - \b pcNameToQuery : task name. +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskGetHandle_Return (void *pxTCB) +\details +The event \b xTaskGetHandle_Return is generated before function xTaskGetHandle returns. + +\b Value in the Event Recorder shows: + - \b pxTCB : pointer to task task handle. +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskGetStaticBuffers (TaskHandle_t xTask, StackType_t **ppuxStackBuffer, StaticTask_t **ppxTaskBuffer) +\details +The event \b xTaskGetStaticBuffers is generated when function xTaskGetStaticBuffers is called. + +\b Value in the Event Recorder shows: + - \b xTask : task handle. + - \b ppuxStackBuffer : pointer to location where pointer to task stack buffer is stored. + - \b ppxTaskBuffer : pointer to location where pointer to task data structure is stored. +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskGetStaticBuffers_Return (uint32_t xReturn) +\details +The event \b xTaskGetStaticBuffers_Return is generated before function xTaskGetStaticBuffers returns. + +\b Value in the Event Recorder shows: + - \b xReturn : return status. +*/ + +/** +\fn void EvrFreeRTOSTasks_uxTaskGetSystemState (TaskStatus_t *pxTaskStatusArray, const uint32_t uxArraySize, uint32_t *pulTotalRunTime) +\details +The event \b uxTaskGetSystemState is generated before function uxTaskGetSystemState returns. + +\b Value in the Event Recorder shows: + - \b pxTaskStatusArray : pointer to an array of TaskStatus_t structures. + - \b uxArraySize : array size. + - \b pulTotalRunTime : total run time since the target booted. +*/ + +/** +\fn void EvrFreeRTOSTasks_uxTaskGetSystemState_Return (uint32_t uxTask) +\details +The event \b uxTaskGetSystemState_Return is generated when function uxTaskGetSystemState is called. + +\b Value in the Event Recorder shows: + - \b uxTask : the number of TaskStatus_t structures populated. +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskGetIdleTaskHandle (void) +\details +The event \b xTaskGetIdleTaskHandle is generated when function xTaskGetIdleTaskHandle is called. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskGetIdleTaskHandle_Return (TaskHandle_t xTask) +\details +The event \b xTaskGetIdleTaskHandle_Return is generated before function xTaskGetIdleTaskHandle returns. + +\b Value in the Event Recorder shows: + - \b xTask : task handle. +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskGetIdleTaskHandleForCore (uint32_t xCoreID) +\details +The event \b xTaskGetIdleTaskHandleForCore is generated when function xTaskGetIdleTaskHandleForCore is called. + +\b Value in the Event Recorder shows: + - \b xCoreID : core id. +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskGetIdleTaskHandleForCore_Return (TaskHandle_t xTask) +\details +The event \b xTaskGetIdleTaskHandleForCore_Return is generated before function xTaskGetIdleTaskHandleForCore returns. + +\b Value in the Event Recorder shows: + - \b xTask : task handle. +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskStepTick (uint32_t xTicksToJump) +\details +The event \b vTaskStepTick is generated when function vTaskStepTick is called. + +\b Value in the Event Recorder shows: + - \b xTicksToJump : number of ticks to add to the tick count. +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskStepTick_Return (void) +\details +The event \b vTaskStepTick_Return is generated before function vTaskStepTick returns. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskCatchUpTicks (uint32_t xTicksToCatchUp) +\details +The event \b xTaskCatchUpTicks is generated when function xTaskCatchUpTicks is called. + +\b Value in the Event Recorder shows: + - \b xTicksToCatchUp : number of tick interrupts that have been missed. +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskCatchUpTicks_Return (uint32_t xYieldOccurred) +\details +The event \b xTaskCatchUpTicks_Return is generated before function xTaskCatchUpTicks returns. + +\b Value in the Event Recorder shows: + - \b xYieldOccurred : info if any task was unblocked. +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskAbortDelay (TaskHandle_t xTask) +\details +The event \b xTaskAbortDelay is generated when function xTaskAbortDelay is called. + +\b Value in the Event Recorder shows: + - \b xTask : task handle. +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskAbortDelay_Return (uint32_t xReturn) +\details +The event \b xTaskAbortDelay_Return is generated before function xTaskAbortDelay returns. + +\b Value in the Event Recorder shows: + - \b xReturn : execution status. +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskIncrementTick (void) +\details +The event \b xTaskIncrementTick is generated when function xTaskIncrementTick is called. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskIncrementTick_Return (uint32_t xSwitchRequired) +\details +The event \b xTaskIncrementTick_Return is generated before function xTaskIncrementTick returns. + +\b Value in the Event Recorder shows: + - \b xSwitchRequired : info if task switch is required. +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskSetApplicationTaskTag (TaskHandle_t xTask, TaskHookFunction_t pxHookFunction) +\details +The event \b vTaskSetApplicationTaskTag is generated when function vTaskSetApplicationTaskTag is called. + +\b Value in the Event Recorder shows: + - \b xTask : task handle. + - \b pxHookFunction : hook function used by the task xTask. +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskSetApplicationTaskTag_Return (void) +\details +The event \b vTaskSetApplicationTaskTag_Return is generated before function vTaskSetApplicationTaskTag returns. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskGetApplicationTaskTag (TaskHandle_t xTask) +\details +The event \b xTaskGetApplicationTaskTag is generated when function xTaskGetApplicationTaskTag is called. + +\b Value in the Event Recorder shows: + - \b xTask : task handle. +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskGetApplicationTaskTag_Return (TaskHookFunction_t xReturn) +\details +The event \b xTaskGetApplicationTaskTag_Return is generated before function xTaskGetApplicationTaskTag returns. + +\b Value in the Event Recorder shows: + - \b xReturn : hook function used by the task xTask. +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskGetApplicationTaskTagFromISR (TaskHandle_t xTask) +\details +The event \b xTaskGetApplicationTaskTagFromISR is generated when function xTaskGetApplicationTaskTagFromISR is called. + +\b Value in the Event Recorder shows: + - \b xTask : task handle. +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskGetApplicationTaskTagFromISR_Return (TaskHookFunction_t xReturn) +\details +The event \b xTaskGetApplicationTaskTagFromISR_Return is generated before function xTaskGetApplicationTaskTagFromISR returns. + +\b Value in the Event Recorder shows: + - \b xReturn : hook function used by the task xTask. +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskCallApplicationTaskHook (TaskHandle_t xTask, void *pvParameter) +\details +The event \b xTaskCallApplicationTaskHook is generated when function xTaskCallApplicationTaskHook is called. + +\b Value in the Event Recorder shows: + - \b xTask : task handle. + - \b pvParameter : pointer to parameters passed to the hook function +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskCallApplicationTaskHook_Return (uint32_t xReturn) +\details +The event \b xTaskCallApplicationTaskHook_Return is generated before function xTaskCallApplicationTaskHook returns. + +\b Value in the Event Recorder shows: + - \b xReturn : hook function execution status. +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskSwitchContext (void) +\details +The event \b vTaskSwitchContext is generated before function vTaskSwitchContext returns. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskSwitchContext_Return (void) +\details +The event \b vTaskSwitchContext_Return is generated when function vTaskSwitchContext is called. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskPlaceOnEventList (List_t *pxEventList, const TickType_t xTicksToWait) +\details +The event \b vTaskPlaceOnEventList is generated when function vTaskPlaceOnEventList is called. + +\b Value in the Event Recorder shows: + - \b pxEventList : pointer to the blocked task list waiting for event. + - \b xTicksToWait : amount of time to wait for an event. +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskPlaceOnEventList_Return (void) +\details +The event \b vTaskPlaceOnEventList_Return is generated before function vTaskPlaceOnEventList returns. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskPlaceOnUnorderedEventList (List_t *pxEventList, const TickType_t xItemValue, const TickType_t xTicksToWait) +\details +The event \b vTaskPlaceOnUnorderedEventList is generated when function vTaskPlaceOnUnorderedEventList is called. + +\b Value in the Event Recorder shows: + - \b pxEventList : pointer to the blocked task list waiting for event. + - \b xItemValue : value to use when event list is not ordered by priority. + - \b xTicksToWait : amount of time to wait for an event. +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskPlaceOnUnorderedEventList_Return (void) +\details +The event \b vTaskPlaceOnUnorderedEventList is generated before function vTaskPlaceOnUnorderedEventList returns. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskPlaceOnEventListRestricted (List_t *pxEventList, TickType_t xTicksToWait, const uint32_t xWaitIndefinitely) +\details +The event \b vTaskPlaceOnEventListRestricted is generated when function vTaskPlaceOnEventListRestricted is called. + +\b Value in the Event Recorder shows: + - \b pxEventList : pointer to the blocked task list waiting for event. + - \b xTicksToWait : amount of time to wait for an event. + - \b xWaitIndefinitely : whether the task should block indefinitely. +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskPlaceOnEventListRestricted_Return (void) +\details +The event \b vTaskPlaceOnEventListRestricted_Return is generated before function vTaskPlaceOnEventListRestricted returns. + +\b Value in the Event Recorder shows: + - \b xReturn : execution status +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskRemoveFromUnorderedEventList (ListItem_t *pxEventListItem, const TickType_t xItemValue) +\details +The event \b vTaskRemoveFromUnorderedEventList is generated when function vTaskRemoveFromUnorderedEventList is called. + +\b Value in the Event Recorder shows: + - \b pxEventListItem : pointer to the event list. + - \b xItemValue : event list item value. +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskRemoveFromUnorderedEventList_Return (void) +\details +The event \b vTaskRemoveFromUnorderedEventList_Return is generated before function vTaskRemoveFromUnorderedEventList returns. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskSetTimeOutState (TimeOut_t *pxTimeOut) +\details +The event \b vTaskSetTimeOutState is generated when function vTaskSetTimeOutState is called. + +\b Value in the Event Recorder shows: + - \b pxTimeOut : pointer to the timeout object. +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskSetTimeOutState_Return (void) +\details +The event \b vTaskSetTimeOutState_Return is generated before function vTaskSetTimeOutState returns. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskInternalSetTimeOutState (TimeOut_t *pxTimeOut) +\details +The event \b vTaskSetTimeOutState is generated when function vTaskSetTimeOutState is called. + +\b Value in the Event Recorder shows: + - \b pxTimeOut : pointer to the timeout object. +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskInternalSetTimeOutState_Return (void) +\details +The event \b vTaskSetTimeOutState_Return is generated before function vTaskSetTimeOutState returns. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskCheckForTimeOut (TimeOut_t *pxTimeOut, TickType_t *pxTicksToWait) +\details +The event \b xTaskCheckForTimeOut is generated when function xTaskCheckForTimeOut is called. + +\b Value in the Event Recorder shows: + - \b pxTimeOut : pointer to the timeout object. + - \b pxTicksToWait : pointer to object holding number of ticks to check for timeout. +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskCheckForTimeOut_Return (uint32_t xReturn) +\details +The event \b xTaskCheckForTimeOut_Return is generated before function xTaskCheckForTimeOut returns. + +\b Value in the Event Recorder shows: + - \b xReturn : execution status. +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskMissedYield (void) +\details +The event \b vTaskMissedYield is generated when function vTaskMissedYield is called. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskMissedYield_Return (void) +\details +The event \b vTaskMissedYield_Return is generated before function vTaskMissedYield returns. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_uxTaskGetTaskNumber (TaskHandle_t xTask) +\details +The event \b uxTaskGetTaskNumber is generated when function uxTaskGetTaskNumber is called. + +\b Value in the Event Recorder shows: + - \b xTask : task handle. +*/ + +/** +\fn void EvrFreeRTOSTasks_uxTaskGetTaskNumber_Return (uint32_t uxReturn) +\details +The event \b uxTaskGetTaskNumber_Return is generated before function uxTaskGetTaskNumber returns. + +\b Value in the Event Recorder shows: + - \b uxReturn : number assigned to the task +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskSetTaskNumber (TaskHandle_t xTask, const uint32_t uxHandle) +\details +The event \b vTaskSetTaskNumber is generated when function vTaskSetTaskNumber is called. + +\b Value in the Event Recorder shows: + - \b xTask : task handle. + - \b uxHandle : the number to assign to the task. +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskSetTaskNumber_Return (void) +\details +The event \b vTaskSetTaskNumber_Return is generated before function vTaskSetTaskNumber returns. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_eTaskConfirmSleepModeStatus (void) +\details +The event \b eTaskConfirmSleepModeStatus is generated when function eTaskConfirmSleepModeStatus is called. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_eTaskConfirmSleepModeStatus_Return (eSleepModeStatus eReturn) +\details +The event \b eTaskConfirmSleepModeStatus_Return is generated before function eTaskConfirmSleepModeStatus returns. + +\b Value in the Event Recorder shows: + - \b eReturn : sleep mode status. +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskSetThreadLocalStoragePointer (TaskHandle_t xTaskToSet, uint32_t xIndex, void * pvValue) +\details +The event \b vTaskSetThreadLocalStoragePointer is generated when function vTaskSetThreadLocalStoragePointer is called. + +\b Value in the Event Recorder shows: + - \b xTaskToSet : task handle. + - \b xIndex : array index. + - \b pvValue : value to set. +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskSetThreadLocalStoragePointer_Return (void) +\details +The event \b vTaskSetThreadLocalStoragePointer_Return is generated before function vTaskSetThreadLocalStoragePointer returns. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_pvTaskGetThreadLocalStoragePointer (TaskHandle_t xTaskToQuery, uint32_t xIndex) +\details +The event \b pvTaskGetThreadLocalStoragePointer is generated when function pvTaskGetThreadLocalStoragePointer is called. + +\b Value in the Event Recorder shows: + - \b xTaskToQuery : task handle. + - \b xIndex : array index. +*/ + +/** +\fn void EvrFreeRTOSTasks_pvTaskGetThreadLocalStoragePointer_Return (void *pvReturn) +\details +The event \b pvTaskGetThreadLocalStoragePointer_Return is generated before function pvTaskGetThreadLocalStoragePointer returns. + +\b Value in the Event Recorder shows: + - \b pvReturn : retrieved value. +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskAllocateMPURegions (TaskHandle_t xTaskToModify, const MemoryRegion_t *pxRegions) +\details +The event \b vTaskAllocateMPURegions is generated when function vTaskAllocateMPURegions is called. + +\b Value in the Event Recorder shows: + - \b xTaskToModify : task handle. + - \b pxRegions : pointer to a structure that contains memory region definitions. +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskAllocateMPURegions_Return (void) +\details +The event \b vTaskAllocateMPURegions_Return is generated before function vTaskAllocateMPURegions returns. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskGetInfo (TaskHandle_t xTask, TaskStatus_t *pxTaskStatus, uint32_t xGetFreeStackSpace, eTaskState eState) +\details +The event \b vTaskGetInfo is generated when function vTaskGetInfo is called. + +\b Value in the Event Recorder shows: + - \b xTask : task handle. + - \b pxTaskStatus : pointer to the structure that will be filled with info. + - \b xGetFreeStackSpace : parameter that allows the high water mark checking to be skipped. + - \b eState : parameter that allows the state information to be omitted. +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskGetInfo_Return (void) +\details +The event \b vTaskGetInfo_Return is generated before function vTaskGetInfo returns. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_uxTaskGetStackHighWaterMark2 (TaskHandle_t xTask) +\details +The event \b uxTaskGetStackHighWaterMark2 is generated when function uxTaskGetStackHighWaterMark2 is called. + +\b Value in the Event Recorder shows: + - \b xTask : task handle. +*/ + +/** +\fn void EvrFreeRTOSTasks_uxTaskGetStackHighWaterMark2_Return (uint32_t uxReturn) +\details +The event \b uxTaskGetStackHighWaterMark2_Return is generated before function uxTaskGetStackHighWaterMark2 returns. + +\b Value in the Event Recorder shows: + - \b uxReturn : the smallest amount (in words) of free stack space there has been. +*/ + +/** +\fn void EvrFreeRTOSTasks_uxTaskGetStackHighWaterMark (TaskHandle_t xTask) +\details +The event \b uxTaskGetStackHighWaterMark is generated when function uxTaskGetStackHighWaterMark is called. + +\b Value in the Event Recorder shows: + - \b xTask : task handle. +*/ + +/** +\fn void EvrFreeRTOSTasks_uxTaskGetStackHighWaterMark_Return (uint32_t uxReturn) +\details +The event \b uxTaskGetStackHighWaterMark_Return is generated before function uxTaskGetStackHighWaterMark returns. + +\b Value in the Event Recorder shows: + - \b uxReturn : the smallest amount (in words) of free stack space there has been. +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskGetCurrentTaskHandle (void) +\details +The event \b xTaskGetCurrentTaskHandle is generated when function xTaskGetCurrentTaskHandle is called. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskGetCurrentTaskHandle_Return (TaskHandle_t xReturn) +\details +The event \b xTaskGetCurrentTaskHandle_Return is generated before function xTaskGetCurrentTaskHandle returns. + +\b Value in the Event Recorder shows: + - \b xReturn : task handle. +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskGetCurrentTaskHandleForCore (uint32_t xCoreID) +\details +The event \b xTaskGetCurrentTaskHandleForCore is generated when function xTaskGetCurrentTaskHandleForCore is called. + +\b Value in the Event Recorder shows: + - \b xCoreID : processor core ID. +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskGetCurrentTaskHandleForCore_Return (TaskHandle_t xReturn) +\details +The event \b xTaskGetCurrentTaskHandleForCore_Return is generated before function xTaskGetCurrentTaskHandleForCore returns. + +\b Value in the Event Recorder shows: + - \b xReturn : task handle. +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskGetSchedulerState (void) +\details +The event \b xTaskGetSchedulerState is generated when function xTaskGetSchedulerState is called. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskGetSchedulerState_Return (uint32_t xReturn) +\details +The event \b xTaskGetSchedulerState_Return is generated before function xTaskGetSchedulerState returns. + +\b Value in the Event Recorder shows: + - \b xReturn : scheduler state. +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskPriorityInherit (TaskHandle_t pxMutexHolder) +\details +The event \b xTaskPriorityInherit is generated when function xTaskPriorityInherit is called. + +\b Value in the Event Recorder shows: + - \b pxMutexHolder : task handle. +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskPriorityInherit_Return (uint32_t xReturn) +\details +The event \b xTaskPriorityInherit_Return is generated before function xTaskPriorityInherit returns. + +\b Value in the Event Recorder shows: + - \b xReturn : execution status. +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskPriorityDisinherit (TaskHandle_t pxMutexHolder) +\details +The event \b xTaskPriorityDisinherit is generated when function xTaskPriorityDisinherit is called. + +\b Value in the Event Recorder shows: + - \b pxMutexHolder : task handle. +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskPriorityDisinherit_Return (uint32_t xReturn) +\details +The event \b xTaskPriorityDisinherit_Return is generated before function xTaskPriorityDisinherit returns. + +\b Value in the Event Recorder shows: + - \b xReturn : execution status. +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskPriorityDisinheritAfterTimeout (TaskHandle_t pxMutexHolder, uint32_t uxHighestPriorityWaitingTask) +\details +The event \b vTaskPriorityDisinheritAfterTimeout is generated when function vTaskPriorityDisinheritAfterTimeout is called. + +\b Value in the Event Recorder shows: + - \b pxMutexHolder : task handle. + - \b uxHighestPriorityWaitingTask : the priority of the highest priority task that is waiting for mutex. +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskPriorityDisinheritAfterTimeout_Return (void) +\details +The event \b vTaskPriorityDisinheritAfterTimeout_Return is generated before function vTaskPriorityDisinheritAfterTimeout returns. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskYieldWithinAPI (void) +\details +The event \b vTaskYieldWithinAPI is generated when function vTaskYieldWithinAPI is called. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskYieldWithinAPI_Return (void) +\details +The event \b vTaskYieldWithinAPI_Return is generated before function vTaskYieldWithinAPI returns. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskEnterCritical (void) +\details +The event \b vTaskEnterCritical is generated when function vTaskEnterCritical is called. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskEnterCritical_Return (void) +\details +The event \b vTaskEnterCritical_Return is generated before function vTaskEnterCritical returns. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskEnterCriticalFromISR (void) +\details +The event \b vTaskEnterCriticalFromISR is generated when function vTaskEnterCriticalFromISR is called. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskEnterCriticalFromISR_Return (uint32_t uxSavedInterruptStatus) +\details +The event \b vTaskEnterCriticalFromISR_Return is generated before function vTaskEnterCriticalFromISR returns. + +\b Value in the Event Recorder shows: + - \b uxSavedInterruptStatus : saved interrupt status. +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskExitCritical (void) +\details +The event \b vTaskExitCritical is generated when function vTaskExitCritical is called. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskExitCritical_Return (void) +\details +The event \b vTaskExitCritical_Return is generated before function vTaskExitCritical returns. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskExitCriticalFromISR (uint32_t uxSavedInterruptStatus) +\details +The event \b vTaskExitCriticalFromISR is generated when function vTaskExitCriticalFromISR is called. + +\b Value in the Event Recorder shows: + - \b uxSavedInterruptStatus : saved interrupt status. +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskExitCriticalFromISR_Return (void) +\details +The event \b vTaskExitCriticalFromISR_Return is generated before function vTaskExitCriticalFromISR returns. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskListTasks (char *pcWriteBuffer, size_t uxBufferLength) +\details +The event \b vTaskListTasks is generated when function vTaskListTasks is called. + +\b Value in the Event Recorder shows: + - \b pcWriteBuffer : pointer to buffer. + - \b uxBufferLength : length of the pcWriteBuffer. +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskListTasks_Return (void) +\details +The event \b vTaskListTasks_Return is generated before function vTaskListTasks returns. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskGetRunTimeStatistics (char *pcWriteBuffer, size_t uxBufferLength) +\details +The event \b vTaskGetRunTimeStatistics is generated when function vTaskGetRunTimeStatistics is called. + +\b Value in the Event Recorder shows: + - \b pcWriteBuffer : pointer to buffer. + - \b uxBufferLength : length of the pcWriteBuffer. +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskGetRunTimeStatistics_Return (void) +\details +The event \b vTaskGetRunTimeStatistics_Return is generated before function vTaskGetRunTimeStatistics returns. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_uxTaskResetEventItemValue (void) +\details +The event \b uxTaskResetEventItemValue is generated when function uxTaskResetEventItemValue is called. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_uxTaskResetEventItemValue_Return (TickType_t uxReturn) +\details +The event \b uxTaskResetEventItemValue_Return is generated before function uxTaskResetEventItemValue returns. + +\b Value in the Event Recorder shows: + - \b uxReturn : event list item value. +*/ + +/** +\fn void EvrFreeRTOSTasks_pvTaskIncrementMutexHeldCount (void) +\details +The event \b pvTaskIncrementMutexHeldCount is generated when function pvTaskIncrementMutexHeldCount is called. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_pvTaskIncrementMutexHeldCount_Return (void *pxTCB) +\details +The event \b pvTaskIncrementMutexHeldCount_Return is generated before function pvTaskIncrementMutexHeldCount returns. + +\b Value in the Event Recorder shows: + - \b pxTCB : running task handle +*/ + +/** +\fn void EvrFreeRTOSTasks_ulTaskGenericNotifyTake (UBaseType_t uxIndexToWaitOn, BaseType_t xClearCountOnExit, TickType_t xTicksToWait) +\details +The event \b ulTaskGenericNotifyTake is generated when function ulTaskGenericNotifyTake is called. + +\b Value in the Event Recorder shows: + - \b uxIndexToWaitOn index within the tasks array of notification values. + - \b xClearCountOnExit indication whether to clear notification value. + - \b xTicksToWait amount of time to wait. +*/ + +/** +\fn void EvrFreeRTOSTasks_ulTaskGenericNotifyTake_Return (uint32_t ulReturn) +\details +The event \b ulTaskGenericNotifyTake_Return is generated before function ulTaskGenericNotifyTake returns. + +\b Value in the Event Recorder shows: + - \b ulReturn : task notification value before modification. +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskGenericNotifyWait (UBaseType_t uxIndexToWaitOn, + uint32_t ulBitsToClearOnEntry, + uint32_t ulBitsToClearOnExit, + uint32_t *pulNotificationValue, + TickType_t xTicksToWait) +\details +The event \b xTaskGenericNotifyWait is generated when function xTaskGenericNotifyWait is called. + +\b Value in the Event Recorder shows: + - \b uxIndexToWaitOn : index within the tasks array of notification values. + - \b ulBitsToClearOnEntry : bits that shall be cleared before reading notification value. + - \b ulBitsToClearOnExit : bits that shall be cleared before returning. + - \b pulNotificationValue : pointer to variable where notification value will be stored. + - \b xTicksToWait : amount of time to wait. +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskGenericNotifyWait_Return (BaseType_t xReturn) +\details +The event \b xTaskGenericNotifyWait_Return is generated before function xTaskGenericNotifyWait returns. + +\b Value in the Event Recorder shows: + - \b xReturn : notification receive status. +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskGenericNotify (TaskHandle_t xTaskToNotify, + UBaseType_t uxIndexToNotify, + uint32_t ulValue, + eNotifyAction eAction, + uint32_t *pulPreviousNotificationValue) +\details +The event \b xTaskGenericNotify is generated when function xTaskGenericNotify is called. + +\b Value in the Event Recorder shows: + - \b xTaskToNotify : task handle. + - \b uxIndexToNotify : index within the tasks array of notification values. + - \b ulValue : notification data value. + - \b eAction : specifies how is the task notification value updated. + - \b pulPreviousNotificationValue : pointer to variable where notification value will be stored. +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskGenericNotify_Return (BaseType_t xReturn) +\details +The event \b xTaskGenericNotify_Return is generated before function xTaskGenericNotify returns. + +\b Value in the Event Recorder shows: + - \b xReturn : context dependent return value. +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskGenericNotifyFromISR (TaskHandle_t xTaskToNotify, + UBaseType_t uxIndexToNotify, + uint32_t ulValue, + eNotifyAction eAction, + uint32_t *pulPreviousNotificationValue, + BaseType_t *pxHigherPriorityTaskWoken) +\details +The event \b xTaskGenericNotifyFromISR is generated when function xTaskGenericNotifyFromISR is called. + +\b Value in the Event Recorder shows: + - \b xTaskToNotify : task handle. + - \b uxIndexToNotify : index within the tasks array of notification values. + - \b ulValue : notification data value. + - \b eAction : specifies how is the task notification value updated. + - \b pulPreviousNotificationValue : pointer to variable where notification value will be stored. + - \b pxHigherPriorityTaskWoken : pointer to variable where information if any task was woken will be stored. +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskGenericNotifyFromISR_Return (BaseType_t xReturn) +\details +The event \b xTaskGenericNotifyFromISR_Return is generated before function xTaskGenericNotifyFromISR returns. + +\b Value in the Event Recorder shows: + - \b xReturn : context dependent return value. +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskGenericNotifyGiveFromISR (TaskHandle_t xTaskToNotify, UBaseType_t uxIndexToNotify, BaseType_t *pxHigherPriorityTaskWoken) +\details +The event \b vTaskGenericNotifyGiveFromISR is generated when function vTaskGenericNotifyGiveFromISR is called. + +\b Value in the Event Recorder shows: + - \b xTaskToNotify : task handle. + - \b uxIndexToNotify : index within the tasks array of notification values. + - \b pxHigherPriorityTaskWoken : pointer to variable where information if any task was woken will be stored. +*/ + +/** +\fn void EvrFreeRTOSTasks_vTaskGenericNotifyGiveFromISR_Return (void) +\details +The event \b vTaskGenericNotifyGiveFromISR_Return is generated before function vTaskGenericNotifyGiveFromISR returns. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskGenericNotifyStateClear (TaskHandle_t xTask, UBaseType_t uxIndexToClear) +\details +The event \b xTaskGenericNotifyStateClear is generated when function xTaskGenericNotifyStateClear is called. + +\b Value in the Event Recorder shows: + - \b xTask : task handle. + - \b uxIndexToClear : index within the tasks array of notification values. +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskGenericNotifyStateClear_Return (BaseType_t xReturn) +\details +The event \b xTaskGenericNotifyStateClear_Return is generated before function xTaskGenericNotifyStateClear returns. + +\b Value in the Event Recorder shows: + - \b xReturn : execution status. +*/ + +/** +\fn void EvrFreeRTOSTasks_ulTaskGenericNotifyValueClear (TaskHandle_t xTask, UBaseType_t uxIndexToClear, uint32_t ulBitsToClear) +\details +The event \b ulTaskGenericNotifyValueClear is generated when function ulTaskGenericNotifyValueClear is called. + +\b Value in the Event Recorder shows: + - \b xTask : task handle. + - \b uxIndexToClear : index within the tasks array of notification values. + - \b ulBitsToClear : bits to clear in notification value. +*/ + +/** +\fn void EvrFreeRTOSTasks_ulTaskGenericNotifyValueClear_Return (uint32_t ulReturn) +\details +The event \b ulTaskGenericNotifyValueClear_Return is generated before function ulTaskGenericNotifyValueClear returns. + +\b Value in the Event Recorder shows: + - \b ulReturn : notification value before clearing. +*/ + +/** +\fn void EvrFreeRTOSTasks_ulTaskGetRunTimeCounter (const TaskHandle_t xTask) +\details +The event \b ulTaskGetRunTimeCounter is generated when function ulTaskGetRunTimeCounter is called. + +\b Value in the Event Recorder shows: + - \b xTask : task handle. +*/ + +/** +\fn void EvrFreeRTOSTasks_ulTaskGetRunTimeCounter_Return (uint32_t ulRunTimeCounter) +\details +The event \b ulTaskGetRunTimeCounter_Return is generated before function ulTaskGetRunTimeCounter returns. + +\b Value in the Event Recorder shows: + - \b ulRunTimeCounter : total run time of the given task. +*/ + +/** +\fn void EvrFreeRTOSTasks_ulTaskGetRunTimePercent (const TaskHandle_t xTask) +\details +The event \b ulTaskGetRunTimePercent is generated when function ulTaskGetRunTimePercent is called. + +\b Value in the Event Recorder shows: + - \b xTask : task handle. +*/ + +/** +\fn void EvrFreeRTOSTasks_ulTaskGetRunTimePercent_Return (uint32_t ulReturn) +\details +The event \b ulTaskGetRunTimePercent_Return is generated before function ulTaskGetRunTimePercent returns. + +\b Value in the Event Recorder shows: + - \b ulReturn : the percentage of the total run time consumed by the given task. +*/ + +/** +\fn void EvrFreeRTOSTasks_ulTaskGetIdleRunTimeCounter (void) +\details +The event \b ulTaskGetIdleRunTimeCounter is generated when function ulTaskGetIdleRunTimeCounter is called. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_ulTaskGetIdleRunTimeCounter_Return (uint32_t ulReturn) +\details +The event \b ulTaskGetIdleRunTimeCounter_Return is generated before function ulTaskGetIdleRunTimeCounter returns. + +\b Value in the Event Recorder shows: + - \b ulReturn : total run time of the idle task. +*/ + +/** +\fn void EvrFreeRTOSTasks_ulTaskGetIdleRunTimePercent (void) +\details +The event \b ulTaskGetIdleRunTimePercent is generated when function ulTaskGetIdleRunTimePercent is called. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTasks_ulTaskGetIdleRunTimePercent_Return (uint32_t ulReturn) +\details +The event \b ulTaskGetIdleRunTimePercent_Return is generated before function ulTaskGetIdleRunTimePercent returns. + +\b Value in the Event Recorder shows: + - \b ulReturn : the percentage of the total run time consumed by the idle task. +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskGetMPUSettings (TaskHandle_t xTask) +\details +The event \b xTaskGetMPUSettings is generated when function xTaskGetMPUSettings is called. + +\b Value in the Event Recorder shows: + - \b xTask : task handle. +*/ + +/** +\fn void EvrFreeRTOSTasks_xTaskGetMPUSettings_Return (void *xMPUSettings) +\details +The event \b xTaskGetMPUSettings_Return is generated before function xTaskGetMPUSettings returns. + +\b Value in the Event Recorder shows: + - \b xMPUSettings : pointer to MPU settings associated with a task. +*/ + +/** +@} +*/ + + +/** +\defgroup freertos_evr_queue Message Queue Functions +\brief Events generated by message queue functions +\details +@{ +*/ + +/** +\fn void EvrFreeRTOSQueue_QueueCreate (Queue_t pxQueue) +\details +The event \b QueueCreate is generated when queue object is successfully created. + +\b Value in the Event Recorder shows: + - \b pxQueue : pointer to queue object handle (control block address). +*/ + +/** +\fn void EvrFreeRTOSQueue_QueueCreateFailed (uint32_t ucQueueType) +\details +The event \b QueueCreateFailed is generated when queue object create fails due to insufficient heap memory. + +\b Value in the Event Recorder shows: + - \b ucQueueType : x +*/ + +/** +\fn void EvrFreeRTOSQueue_CreateMutex (Queue_t pxNewQueue) +\details +The event \b CreateMutex is generated when mutex object is successfully created. + +\b Value in the Event Recorder shows: + - \b pxNewQueue : pointer to mutex (queue) object handle (control block address). +*/ + +/** +\fn void EvrFreeRTOSQueue_CreateMutexFailed (void) +\details +The event \b CreateMutexFailed is generated when mutex object create fails due to insufficient heap memory. +*/ + +/** +\fn void EvrFreeRTOSQueue_GiveMutexRecursive (Queue_t pxMutex) +\details +The event \b GiveMutexRecursive is generated when mutex give operation is successfully executed. + +\b Value in the Event Recorder shows: + - \b pxMutex : pointer to mutex (queue) object handle (control block address). +*/ + +/** +\fn void EvrFreeRTOSQueue_GiveMutexRecursiveFailed (Queue_t pxMutex) +\details +The event \b GiveMutexRecursiveFailed is generated when recursive mutex give operation was not successful. + +\b Value in the Event Recorder shows: + - \b pxMutex : pointer to mutex (queue) object handle (control block address). +*/ + +/** +\fn void EvrFreeRTOSQueue_TakeMutexRecursive (Queue_t pxMutex) +\details +The event \b TakeMutexRecursive is generated when recursive mutex take operation is successfully executed. + +\b Value in the Event Recorder shows: + - \b pxMutex : pointer to mutex (queue) object handle (control block address). +*/ + +/** +\fn void EvrFreeRTOSQueue_TakeMutexRecursiveFailed (Queue_t pxMutex) +\details +The event \b TakeMutexRecursiveFailed is generated when recursive mutex take operation is not successful. + +\b Value in the Event Recorder shows: + - \b pxMutex : pointer to mutex (queue) object handle (control block address). +*/ + +/** +\fn void EvrFreeRTOSQueue_CreateCountingSemaphore (Queue_t xHandle) +\details +The event \b CreateCountingSemaphore is generated when counting semaphore object is successfully created. + +\b Value in the Event Recorder shows: + - \b xHandle : pointer to semaphore (queue) object handle (control block address). +*/ + +/** +\fn void EvrFreeRTOSQueue_CreateCountingSemaphoreFailed (void) +\details +The event \b CreateCountingSemaphoreFailed is generated when semaphore object create fails due to insufficient heap memory. +*/ + +/** +\fn void EvrFreeRTOSQueue_QueueSend (Queue_t pxQueue) +\details +The event \b QueueSend is generated when the queue send operation was successful. + +\b Value in the Event Recorder shows: + - \b pxQueue : pointer to queue object handle (control block address). +*/ + +/** +\fn void EvrFreeRTOSQueue_QueueSendFailed (Queue_t pxQueue) +\details +The event \b QueueSendFailed is generated when the queue send operation fails due to the queue being full. + +\b Value in the Event Recorder shows: + - \b pxQueue : pointer to queue object handle (control block address). +*/ + +/** +\fn void EvrFreeRTOSQueue_QueueReceive (Queue_t pxQueue) +\details +The event \b QueueReceive is generated when the queue receive operation was successful. + +\b Value in the Event Recorder shows: + - \b pxQueue : pointer to queue object handle (control block address). +*/ + +/** +\fn void EvrFreeRTOSQueue_QueuePeek (Queue_t pxQueue) +\details +The event \b QueuePeek is generated when the queue peek operation was successful. + +\b Value in the Event Recorder shows: + - \b pxQueue : pointer to queue object handle (control block address). +*/ + +/** +\fn void EvrFreeRTOSQueue_QueuePeekFromIsr (Queue_t pxQueue) +\details +The event \b QueuePeekFromIsr is generated when the queue peek from ISR operation was successful. + +\b Value in the Event Recorder shows: + - \b pxQueue : pointer to queue object handle (control block address). +*/ + +/** +\fn void EvrFreeRTOSQueue_QueueReceiveFailed (Queue_t pxQueue) +\details +The event \b QueueReceiveFailed is generated when the queue receive operation failed because the queue was empty. + +\b Value in the Event Recorder shows: + - \b pxQueue : pointer to queue object handle (control block address). +*/ + +/** +\fn void EvrFreeRTOSQueue_QueueSendFromIsr (Queue_t pxQueue) +\details +The event \b QueueSendFromIsr is generated when the queue send from ISR operation was successful. + +\b Value in the Event Recorder shows: + - \b pxQueue : pointer to queue object handle (control block address). +*/ + +/** +\fn void EvrFreeRTOSQueue_QueueSendFromIsrFailed (Queue_t pxQueue) +\details +The event \b QueueSendFromIsrFailed is generated when the queue send operation fails due to the queue already being full. + +\b Value in the Event Recorder shows: + - \b pxQueue : pointer to queue object handle (control block address). +*/ + +/** +\fn void EvrFreeRTOSQueue_QueueReceiveFromIsr (Queue_t pxQueue) +\details +The event \b QueueReceiveFromIsr is generated when the queue receive from ISR operation was successful. + +\b Value in the Event Recorder shows: + - \b pxQueue : pointer to queue object handle (control block address). +*/ + +/** +\fn void EvrFreeRTOSQueue_QueueReceiveFromIsrFailed (Queue_t pxQueue) +\details +The event \b QueueReceiveFromIsrFailed is generated when the queue receive operation fails due to the queue already being empty. + +\b Value in the Event Recorder shows: + - \b pxQueue : pointer to queue object handle (control block address). +*/ + +/** +\fn void EvrFreeRTOSQueue_QueuePeekFromIsrFailed (Queue_t pxQueue) +\details +The event \b QueuePeekFromIsrFailed is generated when queue peek operation is executed from an ISR and the queue is empty. + +\b Value in the Event Recorder shows: + - \b pxQueue : pointer to queue object handle (control block address). +*/ + +/** +\fn void EvrFreeRTOSQueue_QueueDelete (Queue_t pxQueue) +\details +The event \b QueueDelete is generated when the function vQueueDelete is called. + +\b Value in the Event Recorder shows: + - \b pxQueue : pointer to queue object handle (control block address). +*/ + +/** +\fn void EvrFreeRTOSQueue_QueueRegistryAdd (Queue_t pxQueue, const char *pcQueueName) +\details +The event \b QueueRegistryAdd is generated when a human readable name is registered to the specified queue. + +\b Value in the Event Recorder shows: + - \b pxQueue : pointer to queue object handle (control block address). + - \b pcQueueName : pointer to the ASCII string. +*/ + +/** +\fn void EvrFreeRTOSQueue_BlockingOnQueueReceive (Queue_t pxQueue) +\details +The event \b BlockingOnQueueReceive is generated when the currently executing task is about to block following +an attempt to read from an empty queue, or an attempt to 'take' an empty semaphore or mutex. + +\b Value in the Event Recorder shows: + - \b pxQueue : pointer to queue object handle (control block address). +*/ + +/** +\fn void EvrFreeRTOSQueue_BlockingOnQueueSend (Queue_t pxQueue) +\details +The event \b BlockingOnQueueSend is generated when the currently executing task is about to block following +an attempt to write to a full queue. + +\b Value in the Event Recorder shows: + - \b pxQueue : pointer to queue object handle (control block address). +*/ + +/** +@} +*/ + + +/** +\defgroup freertos_evr_timers Timer Functions +\brief Events generated by timer functions +\details +@{ +*/ + +/** +\fn void EvrFreeRTOSTimers_TimerCreate (Timer_t pxNewTimer) +\details +The event \b TimerCreate is generated when timer object is successfully created. + +\b Value in the Event Recorder shows: + - \b pxNewTimer : pointer to timer object handle (control block address). +*/ + +/** +\fn void EvrFreeRTOSTimers_TimerCreateFailed (void) +\details +The event \b TimerCreateFailed is generated when timer object create fails due to insufficient heap memory. +*/ + +/** +\fn void EvrFreeRTOSTimers_TimerCommandSend (Timer_t pxTimer, uint32_t xCommandID, uint32_t xOptionalValue, uint32_t xReturn) +\details +The event \b TimerCommandSend is generated when a command is sent to the timer service task, + +\b Value in the Event Recorder shows: + - \b pxTimer : pointer to timer object handle (control block address). + - \b xCommandID : timer command ID. + - \b xOptionalValue : optional command value. + - \b xReturn : execution status (0: failed, command was not sent to the timer command queue, 1: passed, command sent) +*/ + +/** +\fn void EvrFreeRTOSTimers_TimerCommandReceived (Timer_t pxTimer, uint32_t xCommandID, uint32_t xOptionalValue) +\details +The event \b TimerCommandReceived is generated when the timer service task receives a command and before the command is actually processed. + +\b Value in the Event Recorder shows: + - \b pxTimer : pointer to timer object handle (control block address). + - \b xCommandID : timer command ID. + - \b xOptionalValue : optional command value. +*/ + +/** +\fn void EvrFreeRTOSTimers_TimerExpired (Timer_t pxTimer) +\details +The event \b TimerExpired is generated when a software timer expires and before the timer callback is executed. + +\b Value in the Event Recorder shows: + - \b pxTimer : pointer to timer object handle (control block address). +*/ + +/** +\fn void EvrFreeRTOSTimers_PendFuncCall (PendedFunction_t pxFunctionToPend, void *pvParameter1, uint32_t ulParameter2, uint32_t xReturn) +\details +The event \b PendFuncCall is generated before the function xTimerPendFunctionCall returns. + +\b Value in the Event Recorder shows: + - \b pxFunctionToPend : callback function to execute from the timer service/deamon task. + - \b pvParameter1 : the value passed into the callback function as the first parameter. + - \b ulParameter2 : the value passed into the callback function as the second parameter. + - \b xReturn : execution status (1=callback passed to the timer sevice task, any other value: queue full, failed to register the callback execution) +*/ + +/** +\fn void EvrFreeRTOSTimers_PendFuncCallFromIsr (PendedFunction_t pxFunctionToPend, void *pvParameter1, uint32_t ulParameter2, uint32_t xReturn) +\details +The event \b PendFuncCallFromIsr is generated before the function xTimerPendFunctionCallFromISR returns. + +\b Value in the Event Recorder shows: + - \b pxFunctionToPend : callback function to execute from the timer service/deamon task. + - \b pvParameter1 : the value passed into the callback function as the first parameter. + - \b ulParameter2 : the value passed into the callback function as the second parameter. + - \b xReturn : execution status (1=callback passed to the timer sevice task, any other value: queue full, failed to register the callback execution) +*/ + +/** +\fn void EvrFreeRTOSTimers_xTimerCreateTimerTask (void) +\details +The event \b xTimerCreateTimerTask is generated when function xTimerCreateTimerTask is called. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTimers_xTimerCreateTimerTask_Return (BaseType_t xReturn) +\details +The event \b xTimerCreateTimerTask_Return is generated before the function xTimerCreateTimerTask returns. + +\b Value in the Event Recorder shows: + - \b xReturn : execution status. +*/ + +/** +\fn void EvrFreeRTOSTimers_xTimerCreate (const char *pcTimerName, + const TickType_t xTimerPeriodInTicks, + const BaseType_t xAutoReload, + void *pvTimerID, + TimerCallbackFunction_t pxCallbackFunction) +\details +The event \b xTimerCreate is generated when function xTimerCreate is called. + +\b Value in the Event Recorder shows: + - \b pcTimerName : human readable timer name. + - \b xTimerPeriodInTicks : the period of the timer in ticks. + - \b xAutoReload : auto reload flag. + - \b pvTimerID : identifier assigned to the timer being created. + - \b pxCallbackFunction : function to call when the timer expired. +*/ + +/** +\fn void EvrFreeRTOSTimers_xTimerCreate_Return (TimerHandle_t pxNewTimer) +\details +The event \b xTimerCreate_Return is generated before the function xTimerCreate returns. + +\b Value in the Event Recorder shows: + - \b pxNewTimer : Timer object handle. +*/ + +/** +\fn void EvrFreeRTOSTimers_xTimerCreateStatic (const char *pcTimerName, + const TickType_t xTimerPeriodInTicks, + const BaseType_t xAutoReload, + void *pvTimerID, + TimerCallbackFunction_t pxCallbackFunction, + StaticTimer_t *pxTimerBuffer) +\details +The event \b xTimerCreateStatic is generated when function xTimerCreateStatic is called. + +\b Value in the Event Recorder shows: + - \b pcTimerName : human readable timer name. + - \b xTimerPeriodInTicks : the period of the timer in ticks. + - \b xAutoReload : auto reload flag. + - \b pvTimerID : identifier assigned to the timer being created. + - \b pxCallbackFunction : function to call when the timer expired. + - \b pxTimerBuffer : pointer to Timer object memory buffer. +*/ + +/** +\fn void EvrFreeRTOSTimers_xTimerCreateStatic_Return (TimerHandle_t pxNewTimer) +\details +The event \b xTimerCreateStatic_Return is generated before the function xTimerCreateStatic returns. + +\b Value in the Event Recorder shows: + - \b pxNewTimer : Timer object handle. +*/ + +/** +\fn void EvrFreeRTOSTimers_xTimerGenericCommandFromTask (TimerHandle_t xTimer, + const BaseType_t xCommandID, + const TickType_t xOptionalValue, + BaseType_t *pxHigherPriorityTaskWoken, + const TickType_t xTicksToWait) +\details +The event \b xTimerGenericCommandFromTask is generated when function xTimerGenericCommandFromTask is called. + +\b Value in the Event Recorder shows: + - \b xTimer : Timer object handle. + - \b xCommandID : timer command identification. + - \b xOptionalValue : optional command value. + - \b pxHigherPriorityTaskWoken : pointer to variable where information if any task was woken will be stored. + - \b xTicksToWait : number of ticks to wait. +*/ + +/** +\fn void EvrFreeRTOSTimers_xTimerGenericCommandFromTask_Return (BaseType_t xReturn) +\details +The event \b xTimerGenericCommandFromTask_Return is generated before the function xTimerGenericCommandFromTask returns. + +\b Value in the Event Recorder shows: + - \b xReturn : execution status. +*/ + +/** +\fn void EvrFreeRTOSTimers_xTimerGenericCommandFromISR (TimerHandle_t xTimer, + const BaseType_t xCommandID, + const TickType_t xOptionalValue, + BaseType_t *pxHigherPriorityTaskWoken, + const TickType_t xTicksToWait) +\details +The event \b xTimerGenericCommandFromISR is generated when function xTimerGenericCommandFromISR is called. + +\b Value in the Event Recorder shows: + - \b xTimer : Timer object handle. + - \b xCommandID : timer command identification. + - \b xOptionalValue : optional command value. + - \b pxHigherPriorityTaskWoken : pointer to variable where information if any task was woken will be stored. + - \b xTicksToWait : number of ticks to wait. +*/ + +/** +\fn void EvrFreeRTOSTimers_xTimerGenericCommandFromISR_Return (BaseType_t xReturn) +\details +The event \b xTimerGenericCommandFromISR_Return is generated before the function xTimerGenericCommandFromISR returns. + +\b Value in the Event Recorder shows: + - \b xReturn : execution status. +*/ + +/** +\fn void EvrFreeRTOSTimers_xTimerGetTimerDaemonTaskHandle (void) +\details +The event \b xTimerGetTimerDaemonTaskHandle is generated when function xTimerGetTimerDaemonTaskHandle is called. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTimers_xTimerGetTimerDaemonTaskHandle_Return (TaskHandle_t xTimerTaskHandle) +\details +The event \b _Return is generated before the function xTimerGetTimerDaemonTaskHandle returns. + +\b Value in the Event Recorder shows: + - \b xTimerTaskHandle : Timer task handle. +*/ + +/** +\fn void EvrFreeRTOSTimers_xTimerGetPeriod (TimerHandle_t xTimer) +\details +The event \b xTimerGetPeriod is generated when function xTimerGetPeriod is called. + +\b Value in the Event Recorder shows: + - \b xTimer : Timer object handle. +*/ + +/** +\fn void EvrFreeRTOSTimers_xTimerGetPeriod_Return (uint32_t xReturn) +\details +The event \b xTimerGetPeriod_Return is generated before the function xTimerGetPeriod returns. + +\b Value in the Event Recorder shows: + - \b xReturn : timer period in ticks. +*/ + +/** +\fn void EvrFreeRTOSTimers_vTimerSetReloadMode (TimerHandle_t xTimer, const BaseType_t xAutoReload) +\details +The event \b vTimerSetReloadMode is generated when function vTimerSetReloadMode is called. + +\b Value in the Event Recorder shows: + - \b xTimer : Timer object handle. + - \b xAutoReload : auto reload mode. +*/ + +/** +\fn void EvrFreeRTOSTimers_vTimerSetReloadMode_Return (void) +\details +The event \b vTimerSetReloadMode_Return is generated before the function vTimerSetReloadMode returns. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTimers_xTimerGetReloadMode (TimerHandle_t xTimer) +\details +The event \b xTimerGetReloadMode is generated when function xTimerGetReloadMode is called. + +\b Value in the Event Recorder shows: + - \b xTimer : Timer object handle. +*/ + +/** +\fn void EvrFreeRTOSTimers_xTimerGetReloadMode_Return (BaseType_t xReturn) +\details +The event \b xTimerGetReloadMode_Return is generated before the function xTimerGetReloadMode returns. + +\b Value in the Event Recorder shows: + - \b xReturn : timer auto-reload mode. +*/ + +/** +\fn void EvrFreeRTOSTimers_uxTimerGetReloadMode (TimerHandle_t xTimer) +\details +The event \b uxTimerGetReloadMode is generated when function uxTimerGetReloadMode is called. + +\b Value in the Event Recorder shows: + - \b xTimer : Timer object handle. +*/ + +/** +\fn void EvrFreeRTOSTimers_uxTimerGetReloadMode_Return (UBaseType_t uxReturn) +\details +The event \b uxTimerGetReloadMode_Return is generated before the function uxTimerGetReloadMode returns. + +\b Value in the Event Recorder shows: + - \b uxReturn : timer auto-reload mode. +*/ + +/** +\fn void EvrFreeRTOSTimers_xTimerGetExpiryTime (TimerHandle_t xTimer) +\details +The event \b xTimerGetExpiryTime is generated when function xTimerGetExpiryTime is called. + +\b Value in the Event Recorder shows: + - \b xTimer : Timer object handle. +*/ + +/** +\fn void EvrFreeRTOSTimers_xTimerGetExpiryTime_Return (TickType_t xReturn) +\details +The event \b xTimerGetExpiryTime_Return is generated before the function xTimerGetExpiryTime returns. + +\b Value in the Event Recorder shows: + - \b xReturn : the time at which the timer will expire. +*/ + +/** +\fn void EvrFreeRTOSTimers_xTimerGetStaticBuffer (TimerHandle_t xTimer, uint32_t ppxTimerBuffer) +\details +The event \b xTimerGetStaticBuffer is generated when function xTimerGetStaticBuffer is called. + +\b Value in the Event Recorder shows: + - \b xTimer : Timer object handle. + - \b ppxTimerBuffer : pointer to memory where object buffer location is stored. +*/ + +/** +\fn void EvrFreeRTOSTimers_xTimerGetStaticBuffer_Return (BaseType_t xReturn) +\details +The event \b xTimerGetStaticBuffer_Return is generated before the function xTimerGetStaticBuffer returns. + +\b Value in the Event Recorder shows: + - \b xReturn : execution status. +*/ + +/** +\fn void EvrFreeRTOSTimers_pcTimerGetName (TimerHandle_t xTimer) +\details +The event \b pcTimerGetName is generated when function pcTimerGetName is called. + +\b Value in the Event Recorder shows: + - \b xTimer : Timer object handle. +*/ + +/** +\fn void EvrFreeRTOSTimers_pcTimerGetName_Return (const char *pcTimerName) +\details +The event \b pcTimerGetName_Return is generated before the function pcTimerGetName returns. + +\b Value in the Event Recorder shows: + - \b pcTimerName : the name assigned to the Timer object. +*/ + +/** +\fn void EvrFreeRTOSTimers_xTimerIsTimerActive (TimerHandle_t xTimer) +\details +The event \b xTimerIsTimerActive is generated when function xTimerIsTimerActive is called. + +\b Value in the Event Recorder shows: + - \b xTimer : Timer object handle. +*/ + +/** +\fn void EvrFreeRTOSTimers_xTimerIsTimerActive_Return (BaseType_t xReturn) +\details +The event \b xTimerIsTimerActive_Return is generated before the function xTimerIsTimerActive returns. + +\b Value in the Event Recorder shows: + - \b xReturn : indication whether the timer is active or dormant. +*/ + +/** +\fn void EvrFreeRTOSTimers_pvTimerGetTimerID (const TimerHandle_t xTimer) +\details +The event \b pvTimerGetTimerID is generated when function pvTimerGetTimerID is called. + +\b Value in the Event Recorder shows: + - \b xTimer : Timer object handle. +*/ + +/** +\fn void EvrFreeRTOSTimers_pvTimerGetTimerID_Return (void *pvReturn) +\details +The event \b pvTimerGetTimerID_Return is generated before the function pvTimerGetTimerID returns. + +\b Value in the Event Recorder shows: + - \b pvReturn : ID assigned to the timer being queried. +*/ + +/** +\fn void EvrFreeRTOSTimers_vTimerSetTimerID (TimerHandle_t xTimer, void *pvNewID) +\details +The event \b vTimerSetTimerID is generated when function vTimerSetTimerID is called. + +\b Value in the Event Recorder shows: + - \b xTimer : Timer object handle. + - \b pvNewID : ID to assign to the timer. +*/ + +/** +\fn void EvrFreeRTOSTimers_vTimerSetTimerID_Return (void) +\details +The event \b vTimerSetTimerID_Return is generated before the function vTimerSetTimerID returns. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSTimers_xTimerPendFunctionCallFromISR (PendedFunction_t xFunctionToPend, void *pvParameter1, uint32_t ulParameter2, BaseType_t *pxHigherPriorityTaskWoken) +\details +The event \b xTimerPendFunctionCallFromISR is generated when function xTimerPendFunctionCallFromISR is called. + +\b Value in the Event Recorder shows: + - \b xFunctionToPend : the callback function to execute from the timer daemon task. + - \b pvParameter1 : the callback function first argument. + - \b ulParameter2 : the callback function second argument. + - \b pxHigherPriorityTaskWoken : pointer to variable where information if any task was woken will be stored. +*/ + +/** +\fn void EvrFreeRTOSTimers_xTimerPendFunctionCallFromISR_Return (BaseType_t xReturn) +\details +The event \b xTimerPendFunctionCallFromISR_Return is generated before the function xTimerPendFunctionCallFromISR returns. + +\b Value in the Event Recorder shows: + - \b xReturn : execution status. +*/ + +/** +\fn void EvrFreeRTOSTimers_xTimerPendFunctionCall (PendedFunction_t xFunctionToPend, void *pvParameter1, uint32_t ulParameter2, TickType_t xTicksToWait) +\details +The event \b xTimerPendFunctionCall is generated when function xTimerPendFunctionCall is called. + +\b Value in the Event Recorder shows: + - \b xFunctionToPend : the callback function to execute from the timer daemon task. + - \b pvParameter1 : the callback function first argument. + - \b ulParameter2 : the callback function second argument. + - \b xTicksToWait : the amount of time to wait until timer queue is free. +*/ + +/** +\fn void EvrFreeRTOSTimers_xTimerPendFunctionCall_Return (BaseType_t xReturn) +\details +The event \b xTimerPendFunctionCall_Return is generated before the function xTimerPendFunctionCall returns. + +\b Value in the Event Recorder shows: + - \b xReturn : execution status. +*/ + +/** +\fn void EvrFreeRTOSTimers_uxTimerGetTimerNumber (TimerHandle_t xTimer) +\details +The event \b uxTimerGetTimerNumber is generated when function uxTimerGetTimerNumber is called. + +\b Value in the Event Recorder shows: + - \b xTimer : Timer object handle. +*/ + +/** +\fn void EvrFreeRTOSTimers_uxTimerGetTimerNumber_Return (UBaseType_t uxReturn) +\details +The event \b uxTimerGetTimerNumber_Return is generated before the function uxTimerGetTimerNumber returns. + +\b Value in the Event Recorder shows: + - \b uxReturn : the number assigned to the Timer object. +*/ + +/** +\fn void EvrFreeRTOSTimers_vTimerSetTimerNumber (TimerHandle_t xTimer, UBaseType_t uxTimerNumber) +\details +The event \b vTimerSetTimerNumber is generated when function vTimerSetTimerNumber is called. + +\b Value in the Event Recorder shows: + - \b xTimer : Timer object handle. + - \b uxTimerNumber : the number to assign to the Timer object. +*/ + +/** +\fn void EvrFreeRTOSTimers_vTimerSetTimerNumber_Return (void) +\details +The event \b vTimerSetTimerNumber_Return is generated before the function vTimerSetTimerNumber returns. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +@} +*/ + + +/** +\defgroup freertos_evr_event_groups Event Groups Functions +\brief Events generated by event groups functions +\details +@{ +*/ + +/** +\fn void EvrFreeRTOSEventGroups_EventGroupCreate (EventGroup_t pxEventGroup) +\details +The event \b EventGroupCreate is generated when Event Groups object is successfully created. + +\b Value in the Event Recorder shows: + - \b pxEventGroup : pointer to Event Groups object handle (control block address) +*/ + +/** +\fn void EvrFreeRTOSEventGroups_EventGroupCreateFailed (void) +\details +The event \b EventGroupCreateFailed is generated when Event Groups object create fails due to insufficient heap memory. +*/ + +/** +\fn void EvrFreeRTOSEventGroups_EventGroupSyncBlock (EventGroup_t pxEventGroup, uint32_t uxBitsToSet, uint32_t uxBitsToWaitFor) +\details +The event \b EventGroupSyncBlock is generated before the function xEventGroupSync enters blocked state. + +\b Value in the Event Recorder shows: + - \b pxEventGroup : pointer to Event Groups object handle (control block address) + - \b uxBitsToSet : event bits that shall be set. + - \b uxBitsToWaitFor : event bits to wait for. +*/ + +/** +\fn void EvrFreeRTOSEventGroups_EventGroupSyncEnd (EventGroup_t pxEventGroup, uint32_t uxBitsToSet, uint32_t uxBitsToWaitFor, uint32_t xTimeoutOccurred) +\details +The event \b EventGroupSyncEnd is generated before the function xEventGroupSync returns. + +\b Value in the Event Recorder shows: + - \b pxEventGroup : pointer to Event Groups object handle (control block address) + - \b uxBitsToSet : event bits that shall be set. + - \b uxBitsToWaitFor : event bits to wait for. + - \b xTimeoutOccurred : timeout value (0=timeout occurred, 1=no timeout) +*/ + +/** +\fn void EvrFreeRTOSEventGroups_EventGroupWaitBitsBlock (EventGroup_t pxEventGroup, uint32_t uxBitsToWaitFor) +\details +The event \b EventGroupWaitBitsBlock is generated before the function xEventGroupWaitBits enters blocked state. + +\b Value in the Event Recorder shows: + - \b pxEventGroup : pointer to Event Groups object handle (control block address) + - \b uxBitsToWaitFor : event bits to wait for. +*/ + +/** +\fn void EvrFreeRTOSEventGroups_EventGroupWaitBitsEnd (EventGroup_t pxEventGroup, uint32_t uxBitsToWaitFor, uint32_t xTimeoutOccurred) +\details +The event \b EventGroupWaitBitsEnd is generated before the function xEventGroupWaitBits returns. + +\b Value in the Event Recorder shows: + - \b pxEventGroup : pointer to Event Groups object handle (control block address) + - \b uxBitsToWaitFor : event bits to wait for. + - \b xTimeoutOccurred : timeout value (0=timeout occurred, 1=no timeout) +*/ + +/** +\fn void EvrFreeRTOSEventGroups_EventGroupClearBits (EventGroup_t pxEventGroup, uint32_t uxBitsToClear) +\details +The event \b EventGroupClearBits is generated when the function xEventGroupClearBits is called. + +\b Value in the Event Recorder shows: + - \b pxEventGroup : pointer to Event Groups object handle (control block address) + - \b uxBitsToClear : event bits that shall be cleared. +*/ + +/** +\fn void EvrFreeRTOSEventGroups_EventGroupClearBitsFromIsr (EventGroup_t pxEventGroup, uint32_t uxBitsToClear) +\details +The event \b EventGroupClearBitsFromIsr is generated when the function xEventGroupClearBitsFromISR is called. + +\b Value in the Event Recorder shows: + - \b pxEventGroup : pointer to Event Groups object handle (control block address) + - \b uxBitsToClear : event bits that shall be cleared. +*/ + +/** +\fn void EvrFreeRTOSEventGroups_EventGroupSetBits (EventGroup_t pxEventGroup, uint32_t uxBitsToSet) +\details +The event \b EventGroupSetBits is generated when the function xEventGroupSetBits is called. + +\b Value in the Event Recorder shows: + - \b pxEventGroup : pointer to Event Groups object handle (control block address) + - \b uxBitsToSet : event bits that shall be set. +*/ + +/** +\fn void EvrFreeRTOSEventGroups_EventGroupSetBitsFromIsr (EventGroup_t pxEventGroup, uint32_t uxBitsToSet) +\details +The event \b EventGroupSetBitsFromIsr is generated when the function xEventGroupSetBitsFromISR is called. + +\b Value in the Event Recorder shows: + - \b pxEventGroup : pointer to Event Groups object handle (control block address) + - \b uxBitsToSet : event bits that shall be set. +*/ + +/** +\fn void EvrFreeRTOSEventGroups_EventGroupDelete (EventGroup_t pxEventGroup) +\details +The event \b EventGroupDelete is generated when Event Group object is successfully added to object delete queue. + +\b Value in the Event Recorder shows: + - \b pxEventGroup : pointer to Event Groups object handle (control block address) +*/ + +/** +\fn void EvrFreeRTOSEventGroups_xEventGroupCreateStatic (StaticEventGroup_t *pxEventGroupBuffer) +\details +The event \b xEventGroupCreateStatic is generated when function xEventGroupCreateStatic is called. + +\b Value in the Event Recorder shows: + - \b pxEventGroupBuffer : pointer to Event Groups data structure. +*/ + +/** +\fn void EvrFreeRTOSEventGroups_xEventGroupCreateStatic_Return (EventGroupHandle_t xEventGroup) +\details +The event \b xEventGroupCreateStatic_Return is generated before function xEventGroupCreateStatic returns. + +\b Value in the Event Recorder shows: + - \b xEventGroup : pointer to Event Groups object handle. +*/ + +/** +\fn void EvrFreeRTOSEventGroups_xEventGroupCreate (void) +\details +The event \b is generated when function xEventGroupCreate is called. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSEventGroups_xEventGroupCreate_Return (EventGroupHandle_t xEventGroup) +\details +The event \b xEventGroupCreate_Return is generated before function xEventGroupCreate returns. + +\b Value in the Event Recorder shows: + - \b xEventGroup : pointer to Event Groups object handle. +*/ + +/** +\fn void EvrFreeRTOSEventGroups_xEventGroupSync (EventGroupHandle_t xEventGroup, + const EventBits_t uxBitsToSet, + const EventBits_t uxBitsToWaitFor, + TickType_t xTicksToWait) +\details +The event \b xEventGroupSync is generated when function xEventGroupSync is called. + +\b Value in the Event Recorder shows: + - \b xEventGroup : pointer to Event Groups object handle. + - \b uxBitsToSet : bits to set in the Event Group before waiting. + - \b uxBitsToWaitFor : bits to wait for. + - \b xTicksToWait : amount of time to wait for. +*/ + +/** +\fn void EvrFreeRTOSEventGroups_xEventGroupSync_Return (EventBits_t uxReturn) +\details +The event \b xEventGroupSync_Return is generated before function xEventGroupSync returns. + +\b Value in the Event Recorder shows: + - \b uxReturn : the bits after wait or when block time expired. +*/ + +/** +\fn void EvrFreeRTOSEventGroups_xEventGroupWaitBits (EventGroupHandle_t xEventGroup, + const EventBits_t uxBitsToWaitFor, + const BaseType_t xClearOnExit, + const BaseType_t xWaitForAllBits, + TickType_t xTicksToWait) +\details +The event \b xEventGroupWaitBits is generated when function xEventGroupWaitBits is called. + +\b Value in the Event Recorder shows: + - \b xEventGroup : pointer to Event Groups object handle. + - \b uxBitsToWaitFor : the bits to wait for. + - \b xClearOnExit : specifies if the bits are cleared on exit. + - \b xWaitForAllBits : specified if function waits until all bits are set. + - \b xTicksToWait : amount of time to wait for. +*/ + +/** +\fn void EvrFreeRTOSEventGroups_xEventGroupWaitBits_Return (EventBits_t uxReturn) +\details +The event \b xEventGroupWaitBits is generated before function xEventGroupWaitBits returns. + +\b Value in the Event Recorder shows: + - \b uxReturn : the bits after wait or when block time expired. +*/ + +/** +\fn void EvrFreeRTOSEventGroups_xEventGroupClearBits (EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear) +\details +The event \b xEventGroupClearBits is generated when function xEventGroupClearBits is called. + +\b Value in the Event Recorder shows: + - \b xEventGroup : pointer to Event Groups object handle. + - \b uxBitsToClear : the bits to clear. +*/ + +/** +\fn void EvrFreeRTOSEventGroups_xEventGroupClearBits_Return (EventBits_t uxReturn) +\details +The event \b xEventGroupClearBits_Return is generated before function xEventGroupClearBits returns. + +\b Value in the Event Recorder shows: + - \b uxReturn : the bits before clearing. +*/ + +/** +\fn void EvrFreeRTOSEventGroups_xEventGroupClearBitsFromISR (EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear) +\details +The event \b xEventGroupClearBitsFromISR is generated when function xEventGroupClearBitsFromISR is called. + +\b Value in the Event Recorder shows: + - \b xEventGroup : pointer to Event Groups object handle. + - \b uxBitsToClear : the bits to clear. +*/ + +/** +\fn void EvrFreeRTOSEventGroups_xEventGroupClearBitsFromISR_Return (BaseType_t xReturn) +\details +The event \b xEventGroupClearBitsFromISR_Return is generated before function xEventGroupClearBitsFromISR returns. + +\b Value in the Event Recorder shows: + - \b xReturn : execution status. +*/ + +/** +\fn void EvrFreeRTOSEventGroups_xEventGroupGetBitsFromISR (EventGroupHandle_t xEventGroup) +\details +The event \b xEventGroupGetBitsFromISR is generated when function xEventGroupGetBitsFromISR is called. + +\b Value in the Event Recorder shows: + - \b xEventGroup : pointer to Event Groups object handle. +*/ + +/** +\fn void EvrFreeRTOSEventGroups_xEventGroupGetBitsFromISR_Return (EventBits_t uxReturn) +\details +The event \b xEventGroupGetBitsFromISR_Return is generated before function xEventGroupGetBitsFromISR returns. + +\b Value in the Event Recorder shows: + - \b uxReturn : the set bits. +*/ + +/** +\fn void EvrFreeRTOSEventGroups_xEventGroupSetBits (EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet) +\details +The event \b xEventGroupSetBits is generated when function xEventGroupSetBits is called. + +\b Value in the Event Recorder shows: + - \b xEventGroup : pointer to Event Groups object handle. + - \b uxBitsToSet : the bits to set. +*/ + +/** +\fn void EvrFreeRTOSEventGroups_xEventGroupSetBits_Return (EventBits_t uxReturn) +\details +The event \b xEventGroupSetBits_Return is generated before function xEventGroupSetBits returns. + +\b Value in the Event Recorder shows: + - \b uxReturn : the bits set at the time function returns. +*/ + +/** +\fn void EvrFreeRTOSEventGroups_vEventGroupDelete (EventGroupHandle_t xEventGroup) +\details +The event \b vEventGroupDelete is generated when function vEventGroupDelete is called. + +\b Value in the Event Recorder shows: + - \b xEventGroup : pointer to Event Groups object handle. +*/ + +/** +\fn void EvrFreeRTOSEventGroups_vEventGroupDelete_Return (void) +\details +The event \b vEventGroupDelete_Return is generated before function vEventGroupDelete returns. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSEventGroups_xEventGroupGetStaticBuffer (EventGroupHandle_t xEventGroup, StaticEventGroup_t **ppxEventGroupBuffer) +\details +The event \b xEventGroupGetStaticBuffer is generated when function xEventGroupGetStaticBuffer is called. + +\b Value in the Event Recorder shows: + - \b xEventGroup : pointer to Event Groups object handle. + - \b ppxEventGroupBuffer : pointer to memory where pointer to Event Groups object data buffer is stored. +*/ + +/** +\fn void EvrFreeRTOSEventGroups_xEventGroupGetStaticBuffer_Return (BaseType_t xReturn) +\details +The event \b xEventGroupGetStaticBuffer_Return is generated before function xEventGroupGetStaticBuffer returns. + +\b Value in the Event Recorder shows: + - \b xReturn : execution status. +*/ + +/** +\fn void EvrFreeRTOSEventGroups_vEventGroupSetBitsCallback (void *pvEventGroup, uint32_t ulBitsToSet) +\details +The event \b vEventGroupSetBitsCallback is generated when function vEventGroupSetBitsCallback is called. + +\b Value in the Event Recorder shows: + - \b pvEventGroup : pointer to Event Groups object handle. + - \b ulBitsToSet : bits to set. +*/ + +/** +\fn void EvrFreeRTOSEventGroups_vEventGroupSetBitsCallback_Return (void) +\details +The event \b vEventGroupSetBitsCallback_Return is generated before function vEventGroupSetBitsCallback returns. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSEventGroups_vEventGroupClearBitsCallback (void *pvEventGroup, uint32_t ulBitsToClear) +\details +The event \b vEventGroupClearBitsCallback is generated when function vEventGroupClearBitsCallback is called. + +\b Value in the Event Recorder shows: + - \b pvEventGroup : pointer to Event Groups object handle. + - \b ulBitsToClear : bits to clear. +*/ + +/** +\fn void EvrFreeRTOSEventGroups_vEventGroupClearBitsCallback_Return (void) +\details +The event \b vEventGroupClearBitsCallback_Return is generated before function vEventGroupClearBitsCallback returns. + +\b Value in the Event Recorder shows: + - \b no value shown +*/ + +/** +\fn void EvrFreeRTOSEventGroups_xEventGroupSetBitsFromISR (EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet, BaseType_t * pxHigherPriorityTaskWoken) +\details +The event \b xEventGroupSetBitsFromISR is generated when function xEventGroupSetBitsFromISR is called. + +\b Value in the Event Recorder shows: + - \b xEventGroup : pointer to Event Groups object handle. + - \b uxBitsToSet : bits to set + - \b pxHigherPriorityTaskWoken : pointer to variable where information if any task was woken will be stored. +*/ + +/** +\fn void EvrFreeRTOSEventGroups_xEventGroupSetBitsFromISR_Return (BaseType_t xReturn) +\details +The event \b xEventGroupSetBitsFromISR_Return is generated before function xEventGroupSetBitsFromISR returns. + +\b Value in the Event Recorder shows: + - \b xReturn : execution status. +*/ + +/** +\fn void EvrFreeRTOSEventGroups_uxEventGroupGetNumber (void *xEventGroup) +\details +The event \b uxEventGroupGetNumber is generated when function uxEventGroupGetNumber is called. + +\b Value in the Event Recorder shows: + - \b xEventGroup : pointer to Event Groups object handle. +*/ + +/** +\fn void EvrFreeRTOSEventGroups_uxEventGroupGetNumber_Return (UBaseType_t xReturn) +\details +The event \b uxEventGroupGetNumber_Return is generated before function uxEventGroupGetNumber returns. + +\b Value in the Event Recorder shows: + - \b xReturn : Event Groups object number. +*/ + +/** +\fn void EvrFreeRTOSEventGroups_vEventGroupSetNumber (void *xEventGroup, UBaseType_t uxEventGroupNumber) +\details +The event \b vEventGroupSetNumber is generated when function vEventGroupSetNumber is called. + +\b Value in the Event Recorder shows: + - \b xEventGroup : pointer to Event Groups object handle. + - \b uxEventGroupNumber : number to assign to the Event Groups object. +*/ + +/** +\fn void EvrFreeRTOSEventGroups_vEventGroupSetNumber_Return (void) +\details +The event \b vEventGroupSetNumber_Return is generated before function vEventGroupSetNumber returns. + +\b Value in the Event Recorder shows: + - \b no value shown */ /**