trcKernelPort.h

/*
 * Trace Recorder for Tracealyzer v4.11.0
 * Copyright 2025 Percepio AB
 * www.percepio.com
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * FreeRTOS specific definitions needed by the trace recorder
 */
 
#ifndef TRC_KERNEL_PORT_H
#define TRC_KERNEL_PORT_H
 
#include <freertos/FreeRTOS.h>
#include <freertos/portmacro.h>
#include <trcDefines.h>
#include <esp_idf_version.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#ifdef CONFIG_PERCEPIO_TRACERECORDER_ENABLED
#define TRC_USE_TRACEALYZER_RECORDER 1
#else
#define TRC_USE_TRACEALYZER_RECORDER 0
#endif
 
/*** FreeRTOS version codes **************************************************/
#define TRC_ESP_IDF_VERSION_NOT_SET             0
#define TRC_ESP_IDF_VERSION_4_2_0               420
#define TRC_ESP_IDF_VERSION_4_3_0               430
#define TRC_ESP_IDF_VERSION_4_4_0               440
#define TRC_ESP_IDF_VERSION_4_5_0               450
#define TRC_ESP_IDF_VERSION_5_0_0               500
#define TRC_ESP_IDF_VERSION_5_1_0               510
#define TRC_ESP_IDF_VERSION_5_2_0               520
#define TRC_ESP_IDF_VERSION_5_3_0               530
#define TRC_ESP_IDF_VERSION_5_4_0               540
 
#if ESP_IDF_VERSION_MAJOR == 4 && ESP_IDF_VERSION_MINOR == 0
#define TRC_CFG_ESP_IDF_VERSION TRC_ESP_IDF_VERSION_4_0_0
#elif ESP_IDF_VERSION_MAJOR == 4 && ESP_IDF_VERSION_MINOR == 1
#define TRC_CFG_ESP_IDF_VERSION TRC_ESP_IDF_VERSION_4_1_0
#elif ESP_IDF_VERSION_MAJOR == 4 && ESP_IDF_VERSION_MINOR == 2
#define TRC_CFG_ESP_IDF_VERSION TRC_ESP_IDF_VERSION_4_2_0
#elif ESP_IDF_VERSION_MAJOR == 4 && ESP_IDF_VERSION_MINOR == 3
#define TRC_CFG_ESP_IDF_VERSION TRC_ESP_IDF_VERSION_4_3_0
#elif ESP_IDF_VERSION_MAJOR == 4 && ESP_IDF_VERSION_MINOR == 4
#define TRC_CFG_ESP_IDF_VERSION TRC_ESP_IDF_VERSION_4_4_0
#elif ESP_IDF_VERSION_MAJOR == 4 && ESP_IDF_VERSION_MINOR == 5
#define TRC_CFG_ESP_IDF_VERSION TRC_ESP_IDF_VERSION_4_5_0
#elif ESP_IDF_VERSION_MAJOR == 5 && ESP_IDF_VERSION_MINOR == 0
#define TRC_CFG_ESP_IDF_VERSION TRC_ESP_IDF_VERSION_5_0_0
#elif ESP_IDF_VERSION_MAJOR == 5 && ESP_IDF_VERSION_MINOR == 1
#define TRC_CFG_ESP_IDF_VERSION TRC_ESP_IDF_VERSION_5_1_0
#elif ESP_IDF_VERSION_MAJOR == 5 && ESP_IDF_VERSION_MINOR == 2
#define TRC_CFG_ESP_IDF_VERSION TRC_ESP_IDF_VERSION_5_2_0
#elif ESP_IDF_VERSION_MAJOR == 5 && ESP_IDF_VERSION_MINOR == 3
#define TRC_CFG_ESP_IDF_VERSION TRC_ESP_IDF_VERSION_5_3_0
#elif ESP_IDF_VERSION_MAJOR == 5 && ESP_IDF_VERSION_MINOR == 4
#define TRC_CFG_ESP_IDF_VERSION TRC_ESP_IDF_VERSION_5_4_0
#elif ESP_IDF_VERSION_MAJOR == 5 && ESP_IDF_VERSION_MINOR >= 5
/* Attempt at supporting future 5.X versions */
#define TRC_CFG_ESP_IDF_VERSION TRC_ESP_IDF_VERSION_5_4_0
#else
#define TRC_CFG_ESP_IDF_VERSION TRC_ESP_IDF_VERSION_NOT_SET
#endif
 
#if (TRC_CFG_ESP_IDF_VERSION >= TRC_ESP_IDF_VERSION_4_3_0)
#define prvGetStreamBufferType(x) ((( StreamBuffer_t * )x )->ucFlags & sbFLAGS_IS_MESSAGE_BUFFER)
#else
#define prvGetStreamBufferType(x) 0
#endif
 
#define STRING_CAST(x) x
#define TraceKernelPortTickType_t TickType_t
#define TraceKernelPortTaskHandle_t TaskHandle_t
 
#if !CONFIG_FREERTOS_UNICORE
#undef TRC_CFG_GET_CURRENT_CORE
#define TRC_CFG_GET_CURRENT_CORE() (xPortGetCoreID())
#endif
 
#if !CONFIG_FREERTOS_UNICORE
extern portMUX_TYPE xTraceMutex;
 
#define TRC_KERNEL_PORT_ALLOC_CRITICAL_SECTION() TraceUnsignedBaseType_t TRACE_ALLOC_CRITICAL_SECTION_NAME;
#define TRC_KERNEL_PORT_ENTER_CRITICAL_SECTION() TRACE_ALLOC_CRITICAL_SECTION_NAME = 0UL; portENTER_CRITICAL_SAFE(&xTraceMutex);
#define TRC_KERNEL_PORT_EXIT_CRITICAL_SECTION() (void)TRACE_ALLOC_CRITICAL_SECTION_NAME; portEXIT_CRITICAL_SAFE(&xTraceMutex);
#else
/* These are never used since trcHardwarePort.h will define the critical sections if CONFIG_FREERTOS_UNICORE */
#define TRC_KERNEL_PORT_ALLOC_CRITICAL_SECTION() 
#define TRC_KERNEL_PORT_ENTER_CRITICAL_SECTION() 
#define TRC_KERNEL_PORT_EXIT_CRITICAL_SECTION() 
#endif
 
#if (defined(TRC_USE_TRACEALYZER_RECORDER)) && (TRC_USE_TRACEALYZER_RECORDER == 1)

#define TRC_PLATFORM_CFG "FreeRTOS"

#define TRC_PLATFORM_CFG_MAJOR 1

#define TRC_PLATFORM_CFG_MINOR 2

#define TRC_PLATFORM_CFG_PATCH 0

__attribute__((constructor)) void vTraceInit();
 
#if defined(TRC_CFG_ENABLE_STACK_MONITOR) && (TRC_CFG_ENABLE_STACK_MONITOR == 1) && (TRC_CFG_SCHEDULING_ONLY == 0)

#define TRC_CFG_ALLOW_TASK_DELETE INCLUDE_vTaskDelete
 
/* Required for stack monitoring */
#undef INCLUDE_uxTaskGetStackHighWaterMark
#define INCLUDE_uxTaskGetStackHighWaterMark 1
 
#endif
 
/* INCLUDE_xTaskGetCurrentTaskHandle must be set to 1 for tracing to work properly */
#undef INCLUDE_xTaskGetCurrentTaskHandle
#define INCLUDE_xTaskGetCurrentTaskHandle 1
 
#define TRC_KERNEL_PORT_KERNEL_CAN_SWITCH_TO_SAME_TASK 0
 
#include <trcHeap.h>
 
#define TRC_KERNEL_PORT_BUFFER_SIZE (sizeof(TraceHeapHandle_t) + sizeof(void*))

typedef struct TraceKernelPortDataBuffer
{
    uint8_t buffer[TRC_KERNEL_PORT_BUFFER_SIZE];
} TraceKernelPortDataBuffer_t;

traceResult xTraceKernelPortInitialize(TraceKernelPortDataBuffer_t* pxBuffer);

traceResult xTraceKernelPortEnable(void);

traceResult xTraceKernelPortDelay(uint32_t uiTicks);

unsigned char xTraceKernelPortIsSchedulerSuspended(void);

#define TRC_KERNEL_PORT_SET_INTERRUPT_MASK() ((TraceBaseType_t)portSET_INTERRUPT_MASK_FROM_ISR())
 
#if (TRC_CFG_SCHEDULING_ONLY == 0)

void vTraceSetQueueName(void* pvQueue, const char* szName);

void vTraceSetSemaphoreName(void* pvSemaphore, const char* szName);

void vTraceSetMutexName(void* pvMutex, const char* szName);
 
#if (TRC_CFG_INCLUDE_EVENT_GROUP_EVENTS == 1)

void vTraceSetEventGroupName(void* pvEventGroup, const char* szName);
 
#else

#define vTraceSetEventGroupName(__pvEventGroup, __szName) ((void)(__pvEventGroup), (void)(__szName))
 
#endif
 
#if (TRC_CFG_INCLUDE_STREAM_BUFFER_EVENTS == 1)

void vTraceSetStreamBufferName(void* pvStreamBuffer, const char* szName);

void vTraceSetMessageBufferName(void* pvMessageBuffer, const char* szName);
 
#else

#define vTraceSetStreamBufferName(__pvStreamBuffer, __szName) ((void)(__pvStreamBuffer), (void)(__szName))

#define vTraceSetMessageBufferName(__pvMessageBuffer, __szName) ((void)(__pvMessageBuffer), (void)(__szName))
 
#endif
 
#if defined(TRC_CFG_ENABLE_STACK_MONITOR) && (TRC_CFG_ENABLE_STACK_MONITOR == 1)

traceResult xTraceKernelPortGetUnusedStack(void* pvTask, TraceUnsignedBaseType_t *puxUnusedStack);
 
#endif
 
#else

#define vTraceSetQueueName(__pvQueue, __szName) ((void)(__pvQueue), (void)(__szName))

#define vTraceSetSemaphoreName(__pvSemaphore, __szName) ((void)(__pvSemaphore), (void)(__szName))

#define vTraceSetMutexName(__pvMutex, __szName) ((void)(__pvMutex), (void)(__szName))

#define vTraceSetEventGroupName(__pvEventGroup, __szName) ((void)(__pvEventGroup), (void)(__szName))

#define vTraceSetStreamBufferName(__pvStreamBuffer, __szName) ((void)(__pvStreamBuffer), (void)(__szName))

#define vTraceSetMessageBufferName(__pvMessageBuffer, __szName) ((void)(__pvMessageBuffer), (void)(__szName))

#define xTraceKernelPortGetUnusedStack(pvTask, puxUnusedStack) ((void)(pvTask), (void)(puxUnusedStack))
 
#endif
 
/* Required for ISR tracing and Streaming */
#undef INCLUDE_xTaskGetSchedulerState
#define INCLUDE_xTaskGetSchedulerState 1

#define TRACE_KERNEL_VERSION 0x1AA1

#define TRC_TICK_RATE_HZ configTICK_RATE_HZ /* Defined in "FreeRTOS.h" */

#define TRACE_CPU_CLOCK_HZ configCPU_CLOCK_HZ /* Defined in "FreeRTOSConfig.h" */
 
#if (TRC_CFG_RECORDER_BUFFER_ALLOCATION == TRC_RECORDER_BUFFER_ALLOCATION_DYNAMIC)
#define TRC_KERNEL_PORT_HEAP_INIT(size)

#define TRC_KERNEL_PORT_HEAP_MALLOC(size) pvPortMalloc(size)
#endif /* (TRC_CFG_RECORDER_BUFFER_ALLOCATION == TRC_RECORDER_BUFFER_ALLOCATION_DYNAMIC) */
 
#if defined(configUSE_TIMERS)
#if (configUSE_TIMERS == 1)
#undef INCLUDE_xTimerGetTimerDaemonTaskHandle
#define INCLUDE_xTimerGetTimerDaemonTaskHandle 1
#endif /* configUSE_TIMERS == 1*/
#endif /* configUSE_TIMERS */
 
#if (TRC_CFG_ESP_IDF_VERSION <= TRC_ESP_IDF_VERSION_4_2_0)
    #define isQueueReceiveHookActuallyPeek xJustPeeking
#elif (TRC_CFG_ESP_IDF_VERSION > TRC_ESP_IDF_VERSION_4_2_0)
    #define isQueueReceiveHookActuallyPeek (__LINE__ < 0) /* instead of pdFALSE to fix a warning of "constant condition" */
#endif
 
/* Helpers needed to correctly expand names */
#define TZ__CAT2(a,b) a ## b
#define TZ__CAT(a,b) TZ__CAT2(a, b)
 
/*
 * The following xQueueGiveFromISR macro hacks make sure xQueueGiveFromISR also has a xCopyPosition parameter
 */
 
/* Expands name if this header is included... uxQueueType must be a macro that only exists in queue.c or whatever, and it must expand to nothing or to something that's valid in identifiers */
#define xQueueGiveFromISR(a,b) TZ__CAT(xQueueGiveFromISR__, uxQueueType) (a,b)
 
/* If in queue.c, the "uxQueueType" macro expands to "pcHead". queueSEND_TO_BACK is the value we need to send in */
#define xQueueGiveFromISR__pcHead(__a, __b) MyWrapper_xQueueGiveFromISR(__a, __b, const BaseType_t xCopyPosition); \
BaseType_t xQueueGiveFromISR(__a, __b) { return MyWrapper_xQueueGiveFromISR(xQueue, pxHigherPriorityTaskWoken, queueSEND_TO_BACK); } \
BaseType_t MyWrapper_xQueueGiveFromISR(__a, __b, const BaseType_t xCopyPosition)
 
/* If not in queue.c, "uxQueueType" isn't expanded */
#define xQueueGiveFromISR__uxQueueType(__a, __b) xQueueGiveFromISR(__a,__b)
 
TraceHeapHandle_t xTraceKernelPortGetSystemHeapHandle(void);
 
/*************************************************************************/
/* KERNEL SPECIFIC OBJECT CONFIGURATION                                  */
/*************************************************************************/
 
/*******************************************************************************
 * The event codes - should match the offline config file.
 ******************************************************************************/
 
/*** Event codes for streaming - should match the Tracealyzer config file *****/
#define PSF_EVENT_NULL_EVENT                                0x00
 
#define PSF_EVENT_TRACE_START                               0x01
#define PSF_EVENT_TS_CONFIG                                 0x02
#define PSF_EVENT_OBJ_NAME                                  0x03
#define PSF_EVENT_TASK_PRIORITY                             0x04
#define PSF_EVENT_TASK_PRIO_INHERIT                         0x05
#define PSF_EVENT_TASK_PRIO_DISINHERIT                      0x06
#define PSF_EVENT_DEFINE_ISR                                0x07
 
#define PSF_EVENT_TASK_CREATE                               0x10
#define PSF_EVENT_QUEUE_CREATE                              0x11
#define PSF_EVENT_SEMAPHORE_BINARY_CREATE                   0x12
#define PSF_EVENT_MUTEX_CREATE                              0x13
#define PSF_EVENT_TIMER_CREATE                              0x14
#define PSF_EVENT_EVENTGROUP_CREATE                         0x15
#define PSF_EVENT_SEMAPHORE_COUNTING_CREATE                 0x16
#define PSF_EVENT_MUTEX_RECURSIVE_CREATE                    0x17
#define PSF_EVENT_STREAMBUFFER_CREATE                       0x18
#define PSF_EVENT_MESSAGEBUFFER_CREATE                      0x19
 
#define PSF_EVENT_TASK_DELETE                               0x20
#define PSF_EVENT_QUEUE_DELETE                              0x21
#define PSF_EVENT_SEMAPHORE_DELETE                          0x22
#define PSF_EVENT_MUTEX_DELETE                              0x23
#define PSF_EVENT_TIMER_DELETE                              0x24
#define PSF_EVENT_EVENTGROUP_DELETE                         0x25
#define PSF_EVENT_STREAMBUFFER_DELETE                       0x28
#define PSF_EVENT_MESSAGEBUFFER_DELETE                      0x29
 
#define PSF_EVENT_TASK_READY                                0x30
#define PSF_EVENT_NEW_TIME                                  0x31
#define PSF_EVENT_NEW_TIME_SCHEDULER_SUSPENDED              0x32
#define PSF_EVENT_ISR_BEGIN                                 0x33
#define PSF_EVENT_ISR_RESUME                                0x34
#define PSF_EVENT_TS_BEGIN                                  0x35
#define PSF_EVENT_TS_RESUME                                 0x36
#define PSF_EVENT_TASK_ACTIVATE                             0x37
 
#define PSF_EVENT_MALLOC                                    0x38
#define PSF_EVENT_FREE                                      0x39
 
#define PSF_EVENT_LOWPOWER_BEGIN                            0x3A
#define PSF_EVENT_LOWPOWER_END                              0x3B
 
#define PSF_EVENT_IFE_NEXT                                  0x3C
#define PSF_EVENT_IFE_DIRECT                                0x3D
 
#define PSF_EVENT_TASK_CREATE_FAILED                        0x40
#define PSF_EVENT_QUEUE_CREATE_FAILED                       0x41
#define PSF_EVENT_SEMAPHORE_BINARY_CREATE_FAILED            0x42
#define PSF_EVENT_MUTEX_CREATE_FAILED                       0x43
#define PSF_EVENT_TIMER_CREATE_FAILED                       0x44
#define PSF_EVENT_EVENTGROUP_CREATE_FAILED                  0x45
#define PSF_EVENT_SEMAPHORE_COUNTING_CREATE_FAILED          0x46
#define PSF_EVENT_MUTEX_RECURSIVE_CREATE_FAILED             0x47
#define PSF_EVENT_STREAMBUFFER_CREATE_FAILED                0x49
#define PSF_EVENT_MESSAGEBUFFER_CREATE_FAILED               0x4A
 
#define PSF_EVENT_TIMER_DELETE_FAILED                       0x48
 
#define PSF_EVENT_QUEUE_SEND                                0x50
#define PSF_EVENT_SEMAPHORE_GIVE                            0x51
#define PSF_EVENT_MUTEX_GIVE                                0x52
 
#define PSF_EVENT_QUEUE_SEND_FAILED                         0x53
#define PSF_EVENT_SEMAPHORE_GIVE_FAILED                     0x54
#define PSF_EVENT_MUTEX_GIVE_FAILED                         0x55
 
#define PSF_EVENT_QUEUE_SEND_BLOCK                          0x56
#define PSF_EVENT_SEMAPHORE_GIVE_BLOCK                      0x57
#define PSF_EVENT_MUTEX_GIVE_BLOCK                          0x58
 
#define PSF_EVENT_QUEUE_SEND_FROMISR                        0x59
#define PSF_EVENT_SEMAPHORE_GIVE_FROMISR                    0x5A
 
#define PSF_EVENT_QUEUE_SEND_FROMISR_FAILED                 0x5C
#define PSF_EVENT_SEMAPHORE_GIVE_FROMISR_FAILED             0x5D
 
#define PSF_EVENT_QUEUE_RECEIVE                             0x60
#define PSF_EVENT_SEMAPHORE_TAKE                            0x61
#define PSF_EVENT_MUTEX_TAKE                                0x62
 
#define PSF_EVENT_QUEUE_RECEIVE_FAILED                      0x63
#define PSF_EVENT_SEMAPHORE_TAKE_FAILED                     0x64
#define PSF_EVENT_MUTEX_TAKE_FAILED                         0x65
 
#define PSF_EVENT_QUEUE_RECEIVE_BLOCK                       0x66
#define PSF_EVENT_SEMAPHORE_TAKE_BLOCK                      0x67
#define PSF_EVENT_MUTEX_TAKE_BLOCK                          0x68
 
#define PSF_EVENT_QUEUE_RECEIVE_FROMISR                     0x69
#define PSF_EVENT_SEMAPHORE_TAKE_FROMISR                    0x6A
 
#define PSF_EVENT_QUEUE_RECEIVE_FROMISR_FAILED              0x6C
#define PSF_EVENT_SEMAPHORE_TAKE_FROMISR_FAILED             0x6D
 
#define PSF_EVENT_QUEUE_PEEK                                0x70
#define PSF_EVENT_SEMAPHORE_PEEK                            0x71
#define PSF_EVENT_MUTEX_PEEK                                0x72
 
#define PSF_EVENT_QUEUE_PEEK_FAILED                         0x73
#define PSF_EVENT_SEMAPHORE_PEEK_FAILED                     0x74    
#define PSF_EVENT_MUTEX_PEEK_FAILED                         0x75
 
#define PSF_EVENT_QUEUE_PEEK_BLOCK                          0x76
#define PSF_EVENT_SEMAPHORE_PEEK_BLOCK                      0x77
#define PSF_EVENT_MUTEX_PEEK_BLOCK                          0x78
 
#define PSF_EVENT_TASK_DELAY_UNTIL                          0x79
#define PSF_EVENT_TASK_DELAY                                0x7A
#define PSF_EVENT_TASK_SUSPEND                              0x7B
#define PSF_EVENT_TASK_RESUME                               0x7C
#define PSF_EVENT_TASK_RESUME_FROMISR                       0x7D
 
#define PSF_EVENT_TIMER_PENDFUNCCALL                        0x80
#define PSF_EVENT_TIMER_PENDFUNCCALL_FROMISR                0x81
#define PSF_EVENT_TIMER_PENDFUNCCALL_FAILED                 0x82
#define PSF_EVENT_TIMER_PENDFUNCCALL_FROMISR_FAILED         0x83
 
/* We reserve 0x08 slots for this */
#define PSF_EVENT_USER_EVENT                                0x90
 
/* We reserve 0x08 slots for this */
#define PSF_EVENT_USER_EVENT_FIXED                          0x98
 
#define PSF_EVENT_TIMER_START                               0xA0
#define PSF_EVENT_TIMER_RESET                               0xA1
#define PSF_EVENT_TIMER_STOP                                0xA2
#define PSF_EVENT_TIMER_CHANGEPERIOD                        0xA3
#define PSF_EVENT_TIMER_START_FROMISR                       0xA4
#define PSF_EVENT_TIMER_RESET_FROMISR                       0xA5
#define PSF_EVENT_TIMER_STOP_FROMISR                        0xA6
#define PSF_EVENT_TIMER_CHANGEPERIOD_FROMISR                0xA7
#define PSF_EVENT_TIMER_START_FAILED                        0xA8
#define PSF_EVENT_TIMER_RESET_FAILED                        0xA9
#define PSF_EVENT_TIMER_STOP_FAILED                         0xAA
#define PSF_EVENT_TIMER_CHANGEPERIOD_FAILED                 0xAB
#define PSF_EVENT_TIMER_START_FROMISR_FAILED                0xAC
#define PSF_EVENT_TIMER_RESET_FROMISR_FAILED                0xAD
#define PSF_EVENT_TIMER_STOP_FROMISR_FAILED                 0xAE
#define PSF_EVENT_TIMER_CHANGEPERIOD_FROMISR_FAILED         0xAF
 
#define PSF_EVENT_EVENTGROUP_SYNC                           0xB0
#define PSF_EVENT_EVENTGROUP_WAITBITS                       0xB1
#define PSF_EVENT_EVENTGROUP_CLEARBITS                      0xB2
#define PSF_EVENT_EVENTGROUP_CLEARBITS_FROMISR              0xB3
#define PSF_EVENT_EVENTGROUP_SETBITS                        0xB4
#define PSF_EVENT_EVENTGROUP_SETBITS_FROMISR                0xB5
#define PSF_EVENT_EVENTGROUP_SYNC_BLOCK                     0xB6
#define PSF_EVENT_EVENTGROUP_WAITBITS_BLOCK                 0xB7
#define PSF_EVENT_EVENTGROUP_SYNC_FAILED                    0xB8
#define PSF_EVENT_EVENTGROUP_WAITBITS_FAILED                0xB9
 
#define PSF_EVENT_QUEUE_SEND_FRONT                          0xC0
#define PSF_EVENT_QUEUE_SEND_FRONT_FAILED                   0xC1
#define PSF_EVENT_QUEUE_SEND_FRONT_BLOCK                    0xC2
#define PSF_EVENT_QUEUE_SEND_FRONT_FROMISR                  0xC3
#define PSF_EVENT_QUEUE_SEND_FRONT_FROMISR_FAILED           0xC4
#define PSF_EVENT_MUTEX_GIVE_RECURSIVE                      0xC5
#define PSF_EVENT_MUTEX_GIVE_RECURSIVE_FAILED               0xC6
#define PSF_EVENT_MUTEX_TAKE_RECURSIVE                      0xC7
#define PSF_EVENT_MUTEX_TAKE_RECURSIVE_FAILED               0xC8
 
#define PSF_EVENT_TASK_NOTIFY                               0xC9
#define PSF_EVENT_TASK_NOTIFY_WAIT                          0xCA
#define PSF_EVENT_TASK_NOTIFY_WAIT_BLOCK                    0xCB
#define PSF_EVENT_TASK_NOTIFY_WAIT_FAILED                   0xCC
#define PSF_EVENT_TASK_NOTIFY_FROM_ISR                      0xCD
 
#define PSF_EVENT_TIMER_EXPIRED                             0xD2
 
#define PSF_EVENT_STREAMBUFFER_SEND                         0xD3
#define PSF_EVENT_STREAMBUFFER_SEND_BLOCK                   0xD4
#define PSF_EVENT_STREAMBUFFER_SEND_FAILED                  0xD5
#define PSF_EVENT_STREAMBUFFER_RECEIVE                      0xD6
#define PSF_EVENT_STREAMBUFFER_RECEIVE_BLOCK                0xD7
#define PSF_EVENT_STREAMBUFFER_RECEIVE_FAILED               0xD8
#define PSF_EVENT_STREAMBUFFER_SEND_FROM_ISR                0xD9
#define PSF_EVENT_STREAMBUFFER_SEND_FROM_ISR_FAILED         0xDA
#define PSF_EVENT_STREAMBUFFER_RECEIVE_FROM_ISR             0xDB
#define PSF_EVENT_STREAMBUFFER_RECEIVE_FROM_ISR_FAILED      0xDC
#define PSF_EVENT_STREAMBUFFER_RESET                        0xDD
 
#define PSF_EVENT_MESSAGEBUFFER_SEND                        0xDE
#define PSF_EVENT_MESSAGEBUFFER_SEND_BLOCK                  0xDF
#define PSF_EVENT_MESSAGEBUFFER_SEND_FAILED                 0xE0
#define PSF_EVENT_MESSAGEBUFFER_RECEIVE                     0xE1
#define PSF_EVENT_MESSAGEBUFFER_RECEIVE_BLOCK               0xE2
#define PSF_EVENT_MESSAGEBUFFER_RECEIVE_FAILED              0xE3
#define PSF_EVENT_MESSAGEBUFFER_SEND_FROM_ISR               0xE4
#define PSF_EVENT_MESSAGEBUFFER_SEND_FROM_ISR_FAILED        0xE5
#define PSF_EVENT_MESSAGEBUFFER_RECEIVE_FROM_ISR            0xE6
#define PSF_EVENT_MESSAGEBUFFER_RECEIVE_FROM_ISR_FAILED     0xE7
#define PSF_EVENT_MESSAGEBUFFER_RESET                       0xE8
 
#define PSF_EVENT_MALLOC_FAILED                             0xE9
#define PSF_EVENT_FREE_FAILED                               0xEA
 
#define PSF_EVENT_UNUSED_STACK                              0xEB
 
#define PSF_EVENT_STATEMACHINE_STATE_CREATE                 0xEC
#define PSF_EVENT_STATEMACHINE_CREATE                       0xED
#define PSF_EVENT_STATEMACHINE_STATECHANGE                  0xEE
 
#define PSF_EVENT_INTERVAL_CHANNEL_CREATE                   0xEF
#define PSF_EVENT_INTERVAL_START                            0xF0
 
#define PSF_EVENT_EXTENSION_CREATE                          0xF1
 
#define PSF_EVENT_HEAP_CREATE                               0xF2
 
#define PSF_EVENT_COUNTER_CREATE                            0xF3
#define PSF_EVENT_COUNTER_CHANGE                            0xF4
#define PSF_EVENT_COUNTER_LIMIT_EXCEEDED                    0xF5
 
#define PSF_EVENT_MUTEX_TAKE_RECURSIVE_BLOCK                0xF6
 
#define PSF_EVENT_INTERVAL_STOP                             0xF7
#define PSF_EVENT_INTERVAL_CHANNEL_SET_CREATE               0xF8
 
#define PSF_EVENT_RUNNABLE_REGISTER                         0xF9
#define PSF_EVENT_RUNNABLE_START                            0xFA
#define PSF_EVENT_RUNNABLE_STOP                             0xFB
 
#define PSF_EVENT_DEPENDENCY_REGISTER                       0xFC
 
#define TRC_EVENT_LAST_ID                                   (PSF_EVENT_DEPENDENCY_REGISTER)
 
 
/*** The trace macros for streaming ******************************************/
 
/* A macro that will update the tick count when returning from tickless idle */
#undef traceINCREASE_TICK_COUNT
/* Note: This can handle time adjustments of max 2^32 ticks, i.e., 35 seconds at 120 MHz. Thus, tick-less idle periods longer than 2^32 ticks will appear "compressed" on the time line.*/
#define traceINCREASE_TICK_COUNT( xCount ) { uint32_t uiTraceTickCount; xTraceTimestampGetOsTickCount(&uiTraceTickCount); xTraceTimestampSetOsTickCount(uiTraceTickCount + (xCount)); }
 
#if (TRC_CFG_INCLUDE_OSTICK_EVENTS == 1)
 
#define OS_TICK_EVENT(uxSchedulerSuspended, xTickCount) if ((uxSchedulerSuspended) == (unsigned portBASE_TYPE) pdFALSE) { prvTraceEventCreate1(PSF_EVENT_NEW_TIME, xTickCount); }
 
#else
 
#define OS_TICK_EVENT(uxSchedulerSuspended, xTickCount)
 
#endif
 
/* Called on each OS tick. Will call uiPortGetTimestamp to make sure it is called at least once every OS tick. */
#undef traceTASK_INCREMENT_TICK
#if TRC_CFG_ESP_IDF_VERSION >= TRC_ESP_IDF_VERSION_4_3_0
 
#define traceTASK_INCREMENT_TICK( xTickCount ) \
    if (uxSchedulerSuspended[xPortGetCoreID()] == ( unsigned portBASE_TYPE ) pdTRUE || xPendedTicks == 0) { (void)xTraceTimestampSetOsTickCount((xTickCount) + 1); } \
    OS_TICK_EVENT(uxSchedulerSuspended[xPortGetCoreID()], xTickCount + 1)
 
#elif TRC_CFG_ESP_IDF_VERSION >= TRC_ESP_IDF_VERSION_4_0_0
 
#define traceTASK_INCREMENT_TICK( xTickCount ) \
    if (uxSchedulerSuspended[xPortGetCoreID()] == ( unsigned portBASE_TYPE ) pdTRUE || uxPendedTicks == 0) { (void)xTraceTimestampSetOsTickCount((xTickCount) + 1); } \
    OS_TICK_EVENT(uxSchedulerSuspended[xPortGetCoreID()], xTickCount + 1)
 
#else
 
#define traceTASK_INCREMENT_TICK( xTickCount ) \
    if (uxSchedulerSuspended[xPortGetCoreID()] == ( unsigned portBASE_TYPE ) pdTRUE || uxMissedTicks == 0) { (void)xTraceTimestampSetOsTickCount((xTickCount) + 1); } \
    OS_TICK_EVENT(uxSchedulerSuspended[xPortGetCoreID()], xTickCount + 1)
 
#endif
 
/* Called on each task-switch */
#undef traceTASK_SWITCHED_IN
#if (TRC_CFG_ESP_IDF_VERSION >= TRC_ESP_IDF_VERSION_5_2_0)
#define traceTASK_SWITCHED_IN() \
    xTraceTaskSwitch(pxCurrentTCBs[xPortGetCoreID()], pxCurrentTCBs[xPortGetCoreID()]->uxPriority)
#else
#define traceTASK_SWITCHED_IN() \
    xTraceTaskSwitch(pxCurrentTCB[xPortGetCoreID()], pxCurrentTCB[xPortGetCoreID()]->uxPriority)
#endif
 
/* Called for each task that becomes ready */
#if (TRC_CFG_INCLUDE_READY_EVENTS == 1)
#undef traceMOVED_TASK_TO_READY_STATE
#define traceMOVED_TASK_TO_READY_STATE( pxTCB ) \
    xTraceTaskReady(pxTCB);
#endif
 
#undef traceTASK_CREATE
#if TRC_CFG_ESP_IDF_VERSION >= TRC_ESP_IDF_VERSION_4_2_0
 
#define traceTASK_CREATE(pxNewTCB) \
    if ((pxNewTCB) != 0) \
    { \
        xTraceTaskRegisterWithoutHandle((void*)(pxNewTCB), (pxNewTCB)->pcTaskName, (pxNewTCB)->uxPriority); \
    }
#else /* TRC_CFG_ESP_IDF_VERSION >= TRC_ESP_IDF_VERSION_4_2_0 */
 
#define traceTASK_CREATE(pxNewTCB) \
    if (pxNewTCB != 0) \
    { \
        xTraceTaskRegisterWithoutHandle((void*)pxNewTCB, (const char*)pcName, (uint32_t)uxPriority); \
    }
#endif /* TRC_CFG_ESP_IDF_VERSION >= TRC_ESP_IDF_VERSION_4_2_0 */
 
/* Called in vTaskCreate, if it fails (typically if the stack can not be allocated) */
#undef traceTASK_CREATE_FAILED
#define traceTASK_CREATE_FAILED() \
    prvTraceEventCreate0(PSF_EVENT_TASK_CREATE_FAILED)
 
/* Called on vTaskDelete */
#undef traceTASK_DELETE             // We don't allow for filtering out "delete" events. They are important and not very frequent. Moreover, we can't exclude create events, so this should be symmetrical.
#define traceTASK_DELETE( pxTaskToDelete ) \
    xTraceTaskUnregisterWithoutHandle(pxTaskToDelete, (pxTaskToDelete)->uxPriority)
 
#if (TRC_CFG_SCHEDULING_ONLY == 0)
 
#if (defined(configUSE_TICKLESS_IDLE) && configUSE_TICKLESS_IDLE != 0)
 
#undef traceLOW_POWER_IDLE_BEGIN
#define traceLOW_POWER_IDLE_BEGIN() \
    prvTraceEventCreate1(PSF_EVENT_LOWPOWER_BEGIN, xExpectedIdleTime)
 
#undef traceLOW_POWER_IDLE_END
#define traceLOW_POWER_IDLE_END() \
    prvTraceEventCreate0(PSF_EVENT_LOWPOWER_END)
 
#endif /* (defined(configUSE_TICKLESS_IDLE) && configUSE_TICKLESS_IDLE != 0) */
 
/* Called on vTaskSuspend */
#undef traceTASK_SUSPEND
#define traceTASK_SUSPEND( pxTaskToSuspend ) \
    prvTraceEventCreate1(PSF_EVENT_TASK_SUSPEND, pxTaskToSuspend)
 
/* Called on vTaskDelay - note the use of FreeRTOS variable xTicksToDelay */
#undef traceTASK_DELAY
#define traceTASK_DELAY() \
    prvTraceEventCreate1(PSF_EVENT_TASK_DELAY, xTicksToDelay)
 
/* Called on vTaskDelayUntil - note the use of FreeRTOS variable xTimeToWake */
#undef traceTASK_DELAY_UNTIL
#if TRC_CFG_ESP_IDF_VERSION < TRC_ESP_IDF_VERSION_5_1_0
    #define traceTASK_DELAY_UNTIL() \
        prvTraceEventCreate1(PSF_EVENT_TASK_DELAY_UNTIL, 0)
#else
    #define traceTASK_DELAY_UNTIL(xTimeToDelay) \
            prvTraceEventCreate1(PSF_EVENT_TASK_DELAY_UNTIL, xTimeToDelay)
#endif
 
#if (TRC_CFG_ESP_IDF_VERSION >= TRC_ESP_IDF_VERSION_4_3_0)
 
#define traceQUEUE_CREATE_HELPER() \
        case queueQUEUE_TYPE_MUTEX: \
            xTraceObjectRegisterWithoutHandle(PSF_EVENT_MUTEX_CREATE, (void*)pxNewQueue, "", 0); \
            break; \
        case queueQUEUE_TYPE_RECURSIVE_MUTEX: \
            xTraceObjectRegisterWithoutHandle(PSF_EVENT_MUTEX_RECURSIVE_CREATE, (void*)pxNewQueue, "", 0); \
            break;
 
#else
#define traceQUEUE_CREATE_HELPER()
 
#endif /* (TRC_CFG_ESP_IDF_VERSION < TRC_ESP_IDF_VERSION_4_3_0) */
 
/* Called in xQueueCreate, and thereby for all other object based on queues, such as semaphores. */
#undef traceQUEUE_CREATE
#define traceQUEUE_CREATE( pxNewQueue )\
    switch ((pxNewQueue)->ucQueueType) \
    { \
        case queueQUEUE_TYPE_BASE: \
            xTraceObjectRegisterWithoutHandle(PSF_EVENT_QUEUE_CREATE, (void*)(pxNewQueue), "", (uint32_t)uxQueueLength); \
            break; \
        case queueQUEUE_TYPE_BINARY_SEMAPHORE: \
            xTraceObjectRegisterWithoutHandle(PSF_EVENT_SEMAPHORE_BINARY_CREATE, (void*)(pxNewQueue), "", 0); \
            break; \
        traceQUEUE_CREATE_HELPER() \
    }
 
#if (TRC_CFG_ESP_IDF_VERSION >= TRC_ESP_IDF_VERSION_4_3_0)
 
#define traceQUEUE_CREATE_FAILED_HELPER() \
        case queueQUEUE_TYPE_MUTEX: \
            prvTraceEventCreate2(PSF_EVENT_MUTEX_CREATE_FAILED, 0, 0); \
            break; \
        case queueQUEUE_TYPE_RECURSIVE_MUTEX: \
            prvTraceEventCreate2(PSF_EVENT_MUTEX_RECURSIVE_CREATE_FAILED, 0, 0); \
            break;
 
#else
 
#define traceQUEUE_CREATE_FAILED_HELPER()
 
#endif /* (TRC_CFG_ESP_IDF_VERSION >= TRC_ESP_IDF_VERSION_4_3_0) */
 
/* Called in xQueueCreate, if the queue creation fails */
#undef traceQUEUE_CREATE_FAILED
#define traceQUEUE_CREATE_FAILED( queueType ) \
    switch (queueType) \
    { \
        case queueQUEUE_TYPE_BASE: \
            prvTraceEventCreate2(PSF_EVENT_QUEUE_CREATE_FAILED, 0, uxQueueLength); \
            break; \
        case queueQUEUE_TYPE_BINARY_SEMAPHORE: \
            prvTraceEventCreate2(PSF_EVENT_SEMAPHORE_BINARY_CREATE_FAILED, 0, 0); \
            break; \
        traceQUEUE_CREATE_FAILED_HELPER() \
    }
 
#undef traceQUEUE_DELETE            // We don't allow for filtering out "delete" events. They are important and not very frequent. Moreover, we can't exclude create events, so this should be symmetrical.
#define traceQUEUE_DELETE( pxQueue ) \
    switch ((pxQueue)->ucQueueType) \
    { \
        case queueQUEUE_TYPE_BASE: \
            xTraceObjectUnregisterWithoutHandle(PSF_EVENT_QUEUE_DELETE, (void*)(pxQueue), (pxQueue)->uxMessagesWaiting); \
            break; \
        case queueQUEUE_TYPE_MUTEX: \
        case queueQUEUE_TYPE_RECURSIVE_MUTEX: \
            xTraceObjectUnregisterWithoutHandle(PSF_EVENT_MUTEX_DELETE, (void*)(pxQueue), (pxQueue)->uxMessagesWaiting); \
            break; \
        case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \
        case queueQUEUE_TYPE_BINARY_SEMAPHORE: \
            xTraceObjectUnregisterWithoutHandle(PSF_EVENT_SEMAPHORE_DELETE, (void*)(pxQueue), (pxQueue)->uxMessagesWaiting); \
            break; \
    }
 
/* Called in xQueueCreateCountingSemaphore, if the queue creation fails */
#undef traceCREATE_COUNTING_SEMAPHORE
#define traceCREATE_COUNTING_SEMAPHORE() \
    xTraceObjectRegisterWithoutHandle(PSF_EVENT_SEMAPHORE_COUNTING_CREATE, (void*)xHandle, "", (uint32_t)uxMaxCount)
 
#undef traceCREATE_COUNTING_SEMAPHORE_FAILED
#define traceCREATE_COUNTING_SEMAPHORE_FAILED() \
    prvTraceEventCreate2(PSF_EVENT_SEMAPHORE_COUNTING_CREATE_FAILED, 0, uxMaxCount);
 
 
/* This macro is not necessary as of FreeRTOS v9.0.0 */
#if (TRC_CFG_ESP_IDF_VERSION < TRC_ESP_IDF_VERSION_4_3_0)
 
/* Called in xQueueCreateMutex, and thereby also from xSemaphoreCreateMutex and xSemaphoreCreateRecursiveMutex */
#undef traceCREATE_MUTEX
#define traceCREATE_MUTEX( pxNewQueue ) \
    switch (pxNewQueue->ucQueueType) \
    { \
        case queueQUEUE_TYPE_MUTEX: \
            xTraceObjectRegisterWithoutHandle(PSF_EVENT_MUTEX_CREATE, (void*)(pxNewQueue), "", 0); \
            break; \
        case queueQUEUE_TYPE_RECURSIVE_MUTEX: \
            xTraceObjectRegisterWithoutHandle(PSF_EVENT_MUTEX_RECURSIVE_CREATE, (void*)(pxNewQueue), "", 0); \
            break; \
    }
 
/* Called in xQueueCreateMutex when the operation fails (when memory allocation fails) */
#undef traceCREATE_MUTEX_FAILED
#define traceCREATE_MUTEX_FAILED() \
    prvTraceEventCreate2(PSF_EVENT_MUTEX_CREATE_FAILED, 0, 0)
#endif /* (TRC_CFG_ESP_IDF_VERSION < TRC_ESP_IDF_VERSION_4_3_0) */
 
/* Called when the Mutex can not be given, since not holder */
#undef traceGIVE_MUTEX_RECURSIVE_FAILED
#define traceGIVE_MUTEX_RECURSIVE_FAILED( pxMutex ) \
    prvTraceEventCreate1(PSF_EVENT_MUTEX_GIVE_RECURSIVE_FAILED, (void*)(pxMutex))
 
/* Called when a message is sent to a queue */  /* CS IS NEW ! */
#undef traceQUEUE_SEND
#define traceQUEUE_SEND( pxQueue ) \
    switch ((pxQueue)->ucQueueType) \
    { \
        case queueQUEUE_TYPE_BASE: \
            prvTraceEventCreate2(xCopyPosition == queueSEND_TO_BACK ? PSF_EVENT_QUEUE_SEND : PSF_EVENT_QUEUE_SEND_FRONT, (void*)(pxQueue), (pxQueue)->uxMessagesWaiting + 1); \
            break; \
        case queueQUEUE_TYPE_BINARY_SEMAPHORE: \
        case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \
            prvTraceEventCreate2(PSF_EVENT_SEMAPHORE_GIVE, (void*)(pxQueue), (pxQueue)->uxMessagesWaiting + 1); \
            break; \
        case queueQUEUE_TYPE_MUTEX: \
            prvTraceEventCreate1(PSF_EVENT_MUTEX_GIVE, (void*)(pxQueue)); \
            break; \
        case queueQUEUE_TYPE_RECURSIVE_MUTEX: \
            prvTraceEventCreate1(PSF_EVENT_MUTEX_GIVE_RECURSIVE, (void*)(pxQueue)); \
            break; \
    }
            
#undef traceQUEUE_SET_SEND
#define traceQUEUE_SET_SEND( pxQueue ) \
    prvTraceEventCreate2(PSF_EVENT_QUEUE_SEND, (void*)(pxQueue), (pxQueue)->uxMessagesWaiting + 1)
 
/* Called when a message failed to be sent to a queue (timeout) */
#undef traceQUEUE_SEND_FAILED
#define traceQUEUE_SEND_FAILED( pxQueue ) \
    switch ((pxQueue)->ucQueueType) \
    { \
        case queueQUEUE_TYPE_BASE: \
            prvTraceEventCreate2(xCopyPosition == queueSEND_TO_BACK ? PSF_EVENT_QUEUE_SEND_FAILED : PSF_EVENT_QUEUE_SEND_FRONT_FAILED, (void*)(pxQueue), (pxQueue)->uxMessagesWaiting); \
            break; \
        case queueQUEUE_TYPE_BINARY_SEMAPHORE: \
        case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \
            prvTraceEventCreate2(PSF_EVENT_SEMAPHORE_GIVE_FAILED, (void*)(pxQueue), (pxQueue)->uxMessagesWaiting); \
            break; \
        case queueQUEUE_TYPE_MUTEX: \
        case queueQUEUE_TYPE_RECURSIVE_MUTEX: \
            prvTraceEventCreate1(PSF_EVENT_MUTEX_GIVE_FAILED, (void*)(pxQueue)); \
            break; \
    }
 
/* Called when the task is blocked due to a send operation on a full queue */
#undef traceBLOCKING_ON_QUEUE_SEND
#define traceBLOCKING_ON_QUEUE_SEND( pxQueue ) \
    switch ((pxQueue)->ucQueueType) \
    { \
        case queueQUEUE_TYPE_BASE: \
            prvTraceEventCreate2(xCopyPosition == queueSEND_TO_BACK ? PSF_EVENT_QUEUE_SEND_BLOCK : PSF_EVENT_QUEUE_SEND_FRONT_BLOCK, (void*)(pxQueue), (pxQueue)->uxMessagesWaiting); \
            break; \
        case queueQUEUE_TYPE_BINARY_SEMAPHORE: \
        case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \
            prvTraceEventCreate2(PSF_EVENT_SEMAPHORE_GIVE_BLOCK, (void*)(pxQueue), (pxQueue)->uxMessagesWaiting); \
            break; \
        case queueQUEUE_TYPE_MUTEX: \
        case queueQUEUE_TYPE_RECURSIVE_MUTEX: \
            prvTraceEventCreate1(PSF_EVENT_MUTEX_GIVE_BLOCK, (void*)(pxQueue)); \
            break; \
    }
 
/* Called when a message is sent from interrupt context, e.g., using xQueueSendFromISR */
#undef traceQUEUE_SEND_FROM_ISR
#define traceQUEUE_SEND_FROM_ISR( pxQueue ) \
    switch ((pxQueue)->ucQueueType) \
    { \
        case queueQUEUE_TYPE_BASE: \
            prvTraceEventCreate2(xCopyPosition == queueSEND_TO_BACK ? PSF_EVENT_QUEUE_SEND_FROMISR : PSF_EVENT_QUEUE_SEND_FRONT_FROMISR, (void*)(pxQueue), (pxQueue)->uxMessagesWaiting + 1); \
            break; \
        case queueQUEUE_TYPE_BINARY_SEMAPHORE: \
        case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \
            prvTraceEventCreate2(PSF_EVENT_SEMAPHORE_GIVE_FROMISR, (void*)(pxQueue), (pxQueue)->uxMessagesWaiting + 1); \
            break; \
    }
#undef traceQUEUE_GIVE_FROM_ISR
#define traceQUEUE_GIVE_FROM_ISR( pxQueue ) traceQUEUE_SEND_FROM_ISR(pxQueue)
 
/* Called when a message send from interrupt context fails (since the queue was full) */
#undef traceQUEUE_SEND_FROM_ISR_FAILED
#define traceQUEUE_SEND_FROM_ISR_FAILED( pxQueue ) \
    switch ((pxQueue)->ucQueueType) \
    { \
        case queueQUEUE_TYPE_BASE: \
            prvTraceEventCreate2(xCopyPosition == queueSEND_TO_BACK ? PSF_EVENT_QUEUE_SEND_FROMISR_FAILED : PSF_EVENT_QUEUE_SEND_FRONT_FROMISR_FAILED, (void*)(pxQueue), (pxQueue)->uxMessagesWaiting); \
            break; \
        case queueQUEUE_TYPE_BINARY_SEMAPHORE: \
        case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \
            prvTraceEventCreate2(PSF_EVENT_SEMAPHORE_GIVE_FROMISR_FAILED, (void*)(pxQueue), (pxQueue)->uxMessagesWaiting); \
            break; \
        }
#undef traceQUEUE_GIVE_FROM_ISR_FAILED
#define traceQUEUE_GIVE_FROM_ISR_FAILED( pxQueue ) traceQUEUE_SEND_FROM_ISR_FAILED(pxQueue)
 
/* Called when a message is received from a queue */
#undef traceQUEUE_RECEIVE
#define traceQUEUE_RECEIVE( pxQueue ) \
    switch ((pxQueue)->ucQueueType) \
    { \
        case queueQUEUE_TYPE_BASE: \
            if (isQueueReceiveHookActuallyPeek) \
            { \
                prvTraceEventCreate3(PSF_EVENT_QUEUE_PEEK, (void*)(pxQueue), xTicksToWait, (pxQueue)->uxMessagesWaiting - 1); \
            } \
            else\
            { \
                prvTraceEventCreate3(PSF_EVENT_QUEUE_RECEIVE, (void*)(pxQueue), xTicksToWait, (pxQueue)->uxMessagesWaiting - 1); \
            } \
            break; \
        case queueQUEUE_TYPE_BINARY_SEMAPHORE: \
        case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \
            if (isQueueReceiveHookActuallyPeek) \
            { \
                prvTraceEventCreate3(PSF_EVENT_SEMAPHORE_PEEK, (void*)(pxQueue), xTicksToWait, (pxQueue)->uxMessagesWaiting - 1); \
            } \
            else \
            { \
                prvTraceEventCreate3(PSF_EVENT_SEMAPHORE_TAKE, (void*)(pxQueue), xTicksToWait, (pxQueue)->uxMessagesWaiting - 1); \
            } \
            break; \
        case queueQUEUE_TYPE_MUTEX: \
            prvTraceEventCreate2(isQueueReceiveHookActuallyPeek ? PSF_EVENT_MUTEX_PEEK : PSF_EVENT_MUTEX_TAKE, (void*)(pxQueue), xTicksToWait); \
            break; \
        case queueQUEUE_TYPE_RECURSIVE_MUTEX: \
            prvTraceEventCreate2(isQueueReceiveHookActuallyPeek ? PSF_EVENT_MUTEX_PEEK : PSF_EVENT_MUTEX_TAKE_RECURSIVE, (void*)(pxQueue), xTicksToWait); \
                    break; \
            }
#undef traceQUEUE_SEMAPHORE_RECEIVE
#define traceQUEUE_SEMAPHORE_RECEIVE( pxQueue ) traceQUEUE_RECEIVE( pxQueue )
 
/* Called when a receive operation on a queue fails (timeout) */
#undef traceQUEUE_RECEIVE_FAILED
#define traceQUEUE_RECEIVE_FAILED( pxQueue ) \
    switch ((pxQueue)->ucQueueType) \
    { \
        case queueQUEUE_TYPE_BASE: \
            prvTraceEventCreate3(isQueueReceiveHookActuallyPeek ? PSF_EVENT_QUEUE_PEEK_FAILED : PSF_EVENT_QUEUE_RECEIVE_FAILED, (void*)(pxQueue), xTicksToWait, (pxQueue)->uxMessagesWaiting); \
            break; \
        case queueQUEUE_TYPE_BINARY_SEMAPHORE: \
        case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \
            prvTraceEventCreate3(isQueueReceiveHookActuallyPeek ? PSF_EVENT_SEMAPHORE_PEEK_FAILED : PSF_EVENT_SEMAPHORE_TAKE_FAILED, (void*)(pxQueue), xTicksToWait, (pxQueue)->uxMessagesWaiting); \
            break; \
        case queueQUEUE_TYPE_MUTEX: \
            prvTraceEventCreate2(isQueueReceiveHookActuallyPeek ? PSF_EVENT_MUTEX_PEEK_FAILED : PSF_EVENT_MUTEX_TAKE_FAILED, (void*)(pxQueue), xTicksToWait); \
            break; \
        case queueQUEUE_TYPE_RECURSIVE_MUTEX: \
            prvTraceEventCreate2(isQueueReceiveHookActuallyPeek ? PSF_EVENT_MUTEX_PEEK_FAILED : PSF_EVENT_MUTEX_TAKE_RECURSIVE_FAILED, (void*)(pxQueue), xTicksToWait); \
            break; \
    }
 
/* Called when the task is blocked due to a receive operation on an empty queue */
#undef traceBLOCKING_ON_QUEUE_RECEIVE
#define traceBLOCKING_ON_QUEUE_RECEIVE( pxQueue ) \
    switch ((pxQueue)->ucQueueType) \
    { \
        case queueQUEUE_TYPE_BASE: \
            prvTraceEventCreate3(isQueueReceiveHookActuallyPeek ? PSF_EVENT_QUEUE_PEEK_BLOCK : PSF_EVENT_QUEUE_RECEIVE_BLOCK, (void*)(pxQueue), xTicksToWait, (pxQueue)->uxMessagesWaiting); \
            break; \
        case queueQUEUE_TYPE_BINARY_SEMAPHORE: \
        case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \
            prvTraceEventCreate3(isQueueReceiveHookActuallyPeek ? PSF_EVENT_SEMAPHORE_PEEK_BLOCK : PSF_EVENT_SEMAPHORE_TAKE_BLOCK, (void*)(pxQueue), xTicksToWait, (pxQueue)->uxMessagesWaiting); \
            break; \
        case queueQUEUE_TYPE_MUTEX: \
            prvTraceEventCreate2(isQueueReceiveHookActuallyPeek ? PSF_EVENT_MUTEX_PEEK_BLOCK : PSF_EVENT_MUTEX_TAKE_BLOCK, (void*)(pxQueue), xTicksToWait); \
            break; \
        case queueQUEUE_TYPE_RECURSIVE_MUTEX: \
            prvTraceEventCreate2(isQueueReceiveHookActuallyPeek ? PSF_EVENT_MUTEX_PEEK_BLOCK : PSF_EVENT_MUTEX_TAKE_RECURSIVE_BLOCK, (void*)(pxQueue), xTicksToWait); \
            break; \
            }
 
#if (TRC_CFG_ESP_IDF_VERSION > TRC_ESP_IDF_VERSION_4_3_0)
 
/* Called when a peek operation on a queue fails (timeout) */
#undef traceQUEUE_PEEK_FAILED
#define traceQUEUE_PEEK_FAILED( pxQueue ) \
    switch ((pxQueue)->ucQueueType) \
    { \
        case queueQUEUE_TYPE_BASE: \
            prvTraceEventCreate3(PSF_EVENT_QUEUE_PEEK_FAILED, (void*)(pxQueue), xTicksToWait, (pxQueue)->uxMessagesWaiting); \
            break; \
        case queueQUEUE_TYPE_BINARY_SEMAPHORE: \
        case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \
            prvTraceEventCreate3(PSF_EVENT_SEMAPHORE_PEEK_FAILED, (void*)(pxQueue), xTicksToWait, (pxQueue)->uxMessagesWaiting); \
            break; \
        case queueQUEUE_TYPE_MUTEX: \
        case queueQUEUE_TYPE_RECURSIVE_MUTEX: \
            prvTraceEventCreate2(PSF_EVENT_MUTEX_PEEK_FAILED, (void*)(pxQueue), xTicksToWait); \
            break; \
    }
 
/* Called when the task is blocked due to a peek operation on an empty queue */
#undef traceBLOCKING_ON_QUEUE_PEEK
#define traceBLOCKING_ON_QUEUE_PEEK( pxQueue ) \
    switch ((pxQueue)->ucQueueType) \
    { \
        case queueQUEUE_TYPE_BASE: \
            prvTraceEventCreate3(PSF_EVENT_QUEUE_PEEK_BLOCK, (void*)(pxQueue), xTicksToWait, (pxQueue)->uxMessagesWaiting); \
            break; \
        case queueQUEUE_TYPE_BINARY_SEMAPHORE: \
        case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \
            prvTraceEventCreate3(PSF_EVENT_SEMAPHORE_PEEK_BLOCK, (void*)(pxQueue), xTicksToWait, (pxQueue)->uxMessagesWaiting); \
            break; \
        case queueQUEUE_TYPE_MUTEX: \
        case queueQUEUE_TYPE_RECURSIVE_MUTEX: \
            prvTraceEventCreate2(PSF_EVENT_MUTEX_PEEK_BLOCK, (void*)(pxQueue), xTicksToWait); \
            break; \
    }
 
#endif
 
/* Called when a message is received in interrupt context, e.g., using xQueueReceiveFromISR */
#undef traceQUEUE_RECEIVE_FROM_ISR
#define traceQUEUE_RECEIVE_FROM_ISR( pxQueue ) \
    switch ((pxQueue)->ucQueueType) \
    { \
        case queueQUEUE_TYPE_BASE: \
            prvTraceEventCreate2(PSF_EVENT_QUEUE_RECEIVE_FROMISR, (void*)(pxQueue), (pxQueue)->uxMessagesWaiting - 1); \
            break; \
        case queueQUEUE_TYPE_BINARY_SEMAPHORE: \
        case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \
            prvTraceEventCreate2(PSF_EVENT_SEMAPHORE_TAKE_FROMISR, (void*)(pxQueue), (pxQueue)->uxMessagesWaiting - 1); \
            break; \
    }
 
/* Called when a message receive from interrupt context fails (since the queue was empty) */
#undef traceQUEUE_RECEIVE_FROM_ISR_FAILED
#define traceQUEUE_RECEIVE_FROM_ISR_FAILED( pxQueue ) \
    switch ((pxQueue)->ucQueueType) \
    { \
        case queueQUEUE_TYPE_BASE: \
            prvTraceEventCreate2(PSF_EVENT_QUEUE_RECEIVE_FROMISR_FAILED, (void*)(pxQueue), (pxQueue)->uxMessagesWaiting); \
            break; \
        case queueQUEUE_TYPE_BINARY_SEMAPHORE: \
        case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \
            prvTraceEventCreate2(PSF_EVENT_SEMAPHORE_TAKE_FROMISR_FAILED, (void*)(pxQueue), (pxQueue)->uxMessagesWaiting); \
            break; \
        }
 
/* Called on xQueuePeek */
#undef traceQUEUE_PEEK
#define traceQUEUE_PEEK( pxQueue ) \
    switch ((pxQueue)->ucQueueType) \
    { \
        case queueQUEUE_TYPE_BASE: \
            prvTraceEventCreate3(PSF_EVENT_QUEUE_PEEK, (void*)(pxQueue), xTicksToWait, (pxQueue)->uxMessagesWaiting); \
            break; \
        case queueQUEUE_TYPE_BINARY_SEMAPHORE: \
        case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \
            prvTraceEventCreate3(PSF_EVENT_SEMAPHORE_PEEK, (void*)(pxQueue), xTicksToWait, (pxQueue)->uxMessagesWaiting); \
            break; \
        case queueQUEUE_TYPE_MUTEX: \
        case queueQUEUE_TYPE_RECURSIVE_MUTEX: \
            prvTraceEventCreate2(PSF_EVENT_MUTEX_PEEK, (void*)(pxQueue), xTicksToWait); \
            break; \
            }
 
/* Called in vTaskPrioritySet */
#undef traceTASK_PRIORITY_SET
#define traceTASK_PRIORITY_SET( pxTask, uxNewPriority ) \
    xTraceTaskSetPriorityWithoutHandle(pxTask, uxNewPriority)
    
/* Called in vTaskPriorityInherit, which is called by Mutex operations */
#undef traceTASK_PRIORITY_INHERIT
#define traceTASK_PRIORITY_INHERIT( pxTask, uxNewPriority ) \
    prvTraceEventCreate2(PSF_EVENT_TASK_PRIO_INHERIT, (void*)(pxTask), uxNewPriority)
 
/* Called in vTaskPriorityDisinherit, which is called by Mutex operations */
#undef traceTASK_PRIORITY_DISINHERIT
#define traceTASK_PRIORITY_DISINHERIT( pxTask, uxNewPriority ) \
    prvTraceEventCreate2(PSF_EVENT_TASK_PRIO_DISINHERIT, (void*)(pxTask), uxNewPriority)
 
/* Called in vTaskResume */
#undef traceTASK_RESUME
#define traceTASK_RESUME( pxTaskToResume ) \
    prvTraceEventCreate1(PSF_EVENT_TASK_RESUME, (void*)(pxTaskToResume))
 
/* Called in vTaskResumeFromISR */
#undef traceTASK_RESUME_FROM_ISR
#define traceTASK_RESUME_FROM_ISR( pxTaskToResume ) \
    prvTraceEventCreate1(PSF_EVENT_TASK_RESUME_FROMISR, (void*)(pxTaskToResume))
 
#if (TRC_CFG_INCLUDE_MEMMANG_EVENTS == 1)
 
#undef traceMALLOC
#define traceMALLOC( pvAddress, uiSize ) \
    if (xTraceIsRecorderEnabled()) \
    { \
        xTraceHeapAlloc(xTraceKernelPortGetSystemHeapHandle(), pvAddress, uiSize); \
    }
 
#undef traceFREE
#define traceFREE( pvAddress, uiSize ) \
    if (xTraceIsRecorderEnabled()) \
    { \
        xTraceHeapFree(xTraceKernelPortGetSystemHeapHandle(), pvAddress, uiSize); \
    }
 
#endif
 
#if (TRC_CFG_INCLUDE_TIMER_EVENTS == 1)
 
/* Called in timer.c - xTimerCreate */
#undef traceTIMER_CREATE
#define traceTIMER_CREATE(tmr) \
    xTraceObjectRegisterWithoutHandle(PSF_EVENT_TIMER_CREATE, (void*)(tmr), (const char*)(tmr)->pcTimerName, (uint32_t)(tmr)->xTimerPeriodInTicks)
 
#undef traceTIMER_CREATE_FAILED
#define traceTIMER_CREATE_FAILED() \
    prvTraceEventCreate0(PSF_EVENT_TIMER_CREATE_FAILED);
 
#if (TRC_CFG_ESP_IDF_VERSION >= TRC_ESP_IDF_VERSION_4_0_0)
 
#define traceTIMER_COMMAND_SEND_8_0_CASES(tmr) \
        case tmrCOMMAND_RESET: \
            prvTraceEventCreate2((xReturn == pdPASS) ? PSF_EVENT_TIMER_RESET : PSF_EVENT_TIMER_RESET_FAILED, (void*)(tmr), xOptionalValue); \
            break; \
        case tmrCOMMAND_START_FROM_ISR: \
            prvTraceEventCreate2((xReturn == pdPASS) ? PSF_EVENT_TIMER_START_FROMISR : PSF_EVENT_TIMER_START_FROMISR_FAILED, (void*)(tmr), xOptionalValue); \
            break; \
        case tmrCOMMAND_RESET_FROM_ISR: \
            prvTraceEventCreate2((xReturn == pdPASS) ? PSF_EVENT_TIMER_RESET_FROMISR : PSF_EVENT_TIMER_RESET_FROMISR_FAILED, (void*)(tmr), xOptionalValue); \
            break; \
        case tmrCOMMAND_STOP_FROM_ISR: \
            prvTraceEventCreate2((xReturn == pdPASS) ? PSF_EVENT_TIMER_STOP_FROMISR : PSF_EVENT_TIMER_STOP_FROMISR_FAILED, (void*)(tmr), xOptionalValue); \
            break; \
        case tmrCOMMAND_CHANGE_PERIOD_FROM_ISR: \
            prvTraceEventCreate2((xReturn == pdPASS) ? PSF_EVENT_TIMER_CHANGEPERIOD_FROMISR : PSF_EVENT_TIMER_CHANGEPERIOD_FROMISR_FAILED, (void*)(tmr), xOptionalValue); \
            break;
#else
 
#define traceTIMER_COMMAND_SEND_8_0_CASES(tmr)
 
#endif
 
/* Note that xCommandID can never be tmrCOMMAND_EXECUTE_CALLBACK (-1) since the trace macro is not called in that case */
#undef traceTIMER_COMMAND_SEND
#define traceTIMER_COMMAND_SEND(tmr, xCommandID, xOptionalValue, xReturn) \
            switch(xCommandID) \
            { \
                case tmrCOMMAND_START: \
            prvTraceEventCreate1(((xReturn) == pdPASS) ? PSF_EVENT_TIMER_START : PSF_EVENT_TIMER_START_FAILED, (void*)(tmr)); \
            break; \
        case tmrCOMMAND_STOP: \
            prvTraceEventCreate1(((xReturn) == pdPASS) ? PSF_EVENT_TIMER_STOP : PSF_EVENT_TIMER_STOP_FAILED, (void*)(tmr)); \
            break; \
        case tmrCOMMAND_CHANGE_PERIOD: \
            prvTraceEventCreate2(((xReturn) == pdPASS) ? PSF_EVENT_TIMER_CHANGEPERIOD : PSF_EVENT_TIMER_CHANGEPERIOD_FAILED, (void*)(tmr), xOptionalValue); \
            break; \
        case tmrCOMMAND_DELETE: \
            xTraceObjectUnregisterWithoutHandle(((xReturn) == pdPASS) ? PSF_EVENT_TIMER_DELETE : PSF_EVENT_TIMER_DELETE_FAILED, (void*)(tmr), 0); \
                    break; \
                traceTIMER_COMMAND_SEND_8_0_CASES(tmr) \
            }
 
#undef traceTIMER_EXPIRED
#define traceTIMER_EXPIRED(tmr) \
    prvTraceEventCreate2(PSF_EVENT_TIMER_EXPIRED, (void*)(tmr), (uint32_t)((tmr)->pxCallbackFunction))
 
#endif
 
 
#if (TRC_CFG_INCLUDE_PEND_FUNC_CALL_EVENTS == 1)
 
#undef tracePEND_FUNC_CALL
#define tracePEND_FUNC_CALL(func, arg1, arg2, ret) \
    prvTraceEventCreate1(((ret) == pdPASS) ? PSF_EVENT_TIMER_PENDFUNCCALL : PSF_EVENT_TIMER_PENDFUNCCALL_FAILED, (uint32_t)(func))
 
#undef tracePEND_FUNC_CALL_FROM_ISR
#define tracePEND_FUNC_CALL_FROM_ISR(func, arg1, arg2, ret) \
    prvTraceEventCreate1(((ret) == pdPASS) ? PSF_EVENT_TIMER_PENDFUNCCALL_FROMISR : PSF_EVENT_TIMER_PENDFUNCCALL_FROMISR_FAILED, (uint32_t)(func))
 
#endif
 
#if (TRC_CFG_INCLUDE_EVENT_GROUP_EVENTS == 1)
 
#undef traceEVENT_GROUP_CREATE
#define traceEVENT_GROUP_CREATE(eg) \
    xTraceObjectRegisterWithoutHandle(PSF_EVENT_EVENTGROUP_CREATE, (void*)(eg), 0, (uint32_t)(eg)->uxEventBits)
 
#undef traceEVENT_GROUP_DELETE
#define traceEVENT_GROUP_DELETE(eg) \
    xTraceObjectUnregisterWithoutHandle(PSF_EVENT_EVENTGROUP_DELETE, (void*)(eg), (uint32_t)(eg)->uxEventBits)
 
#undef traceEVENT_GROUP_CREATE_FAILED
#define traceEVENT_GROUP_CREATE_FAILED() \
    prvTraceEventCreate0(PSF_EVENT_EVENTGROUP_CREATE_FAILED)
 
#undef traceEVENT_GROUP_SYNC_BLOCK
#define traceEVENT_GROUP_SYNC_BLOCK(eg, bitsToSet, bitsToWaitFor) \
    prvTraceEventCreate2(PSF_EVENT_EVENTGROUP_SYNC_BLOCK, (void*)(eg), bitsToWaitFor)
 
#undef traceEVENT_GROUP_SYNC_END
#define traceEVENT_GROUP_SYNC_END(eg, bitsToSet, bitsToWaitFor, wasTimeout) \
    prvTraceEventCreate2(((wasTimeout) != pdTRUE) ? PSF_EVENT_EVENTGROUP_SYNC : PSF_EVENT_EVENTGROUP_SYNC_FAILED, (void*)(eg), bitsToWaitFor)
 
#undef traceEVENT_GROUP_WAIT_BITS_BLOCK
#define traceEVENT_GROUP_WAIT_BITS_BLOCK(eg, bitsToWaitFor) \
    prvTraceEventCreate2(PSF_EVENT_EVENTGROUP_WAITBITS_BLOCK, (void*)(eg), bitsToWaitFor)
 
#undef traceEVENT_GROUP_WAIT_BITS_END
#define traceEVENT_GROUP_WAIT_BITS_END(eg, bitsToWaitFor, wasTimeout) \
    prvTraceEventCreate2(((wasTimeout) != pdTRUE) ? PSF_EVENT_EVENTGROUP_WAITBITS : PSF_EVENT_EVENTGROUP_WAITBITS_FAILED, (void*)(eg), bitsToWaitFor)
 
#undef traceEVENT_GROUP_CLEAR_BITS
#define traceEVENT_GROUP_CLEAR_BITS(eg, bitsToClear) \
    prvTraceEventCreate2(PSF_EVENT_EVENTGROUP_CLEARBITS, (void*)(eg), bitsToClear)
 
#undef traceEVENT_GROUP_CLEAR_BITS_FROM_ISR
#define traceEVENT_GROUP_CLEAR_BITS_FROM_ISR(eg, bitsToClear) \
    prvTraceEventCreate2(PSF_EVENT_EVENTGROUP_CLEARBITS_FROMISR, (void*)(eg), bitsToClear)
 
#undef traceEVENT_GROUP_SET_BITS
#define traceEVENT_GROUP_SET_BITS(eg, bitsToSet) \
    prvTraceEventCreate2(PSF_EVENT_EVENTGROUP_SETBITS, (void*)(eg), bitsToSet)
 
#undef traceEVENT_GROUP_SET_BITS_FROM_ISR
#define traceEVENT_GROUP_SET_BITS_FROM_ISR(eg, bitsToSet) \
    prvTraceEventCreate2(PSF_EVENT_EVENTGROUP_SETBITS_FROMISR, (void*)(eg), bitsToSet)
 
#endif
 
#undef traceTASK_NOTIFY
#if (TRC_CFG_ESP_IDF_VERSION > TRC_ESP_IDF_VERSION_4_3_0)
 
#define traceTASK_NOTIFY(index) \
    prvTraceEventCreate1(PSF_EVENT_TASK_NOTIFY, (void*)xTaskToNotify)
 
#else
 
#define traceTASK_NOTIFY() \
    prvTraceEventCreate1(PSF_EVENT_TASK_NOTIFY, (void*)xTaskToNotify)
 
#endif
 
#undef traceTASK_NOTIFY_FROM_ISR
#if (TRC_CFG_ESP_IDF_VERSION > TRC_ESP_IDF_VERSION_4_3_0)
 
#define traceTASK_NOTIFY_FROM_ISR(index) \
    prvTraceEventCreate1(PSF_EVENT_TASK_NOTIFY_FROM_ISR, (void*)xTaskToNotify)
 
#else
 
#define traceTASK_NOTIFY_FROM_ISR() \
    prvTraceEventCreate1(PSF_EVENT_TASK_NOTIFY_FROM_ISR, (void*)xTaskToNotify)
 
#endif
 
/* NOTIFY and NOTIFY_GIVE will be handled identically */
#undef traceTASK_NOTIFY_GIVE_FROM_ISR
#define traceTASK_NOTIFY_GIVE_FROM_ISR traceTASK_NOTIFY_FROM_ISR
 
#undef traceTASK_NOTIFY_WAIT
#if (TRC_CFG_ESP_IDF_VERSION >= TRC_ESP_IDF_VERSION_5_2_0)
 
#define traceTASK_NOTIFY_WAIT(index) \
    prvTraceEventCreate2(pxCurrentTCBs[xPortGetCoreID()]->ucNotifyState[index] == taskNOTIFICATION_RECEIVED ? PSF_EVENT_TASK_NOTIFY_WAIT : PSF_EVENT_TASK_NOTIFY_WAIT_FAILED, (void*)pxCurrentTCBs[xPortGetCoreID()], xTicksToWait)
 
#elif (TRC_CFG_ESP_IDF_VERSION > TRC_ESP_IDF_VERSION_4_3_0)
 
#define traceTASK_NOTIFY_WAIT(index) \
    prvTraceEventCreate2(pxCurrentTCB[xPortGetCoreID()]->ucNotifyState[index] == taskNOTIFICATION_RECEIVED ? PSF_EVENT_TASK_NOTIFY_WAIT : PSF_EVENT_TASK_NOTIFY_WAIT_FAILED, (void*)pxCurrentTCB[xPortGetCoreID()], xTicksToWait)
 
#elif (TRC_CFG_ESP_IDF_VERSION == TRC_ESP_IDF_VERSION_4_3_0)
 
#define traceTASK_NOTIFY_WAIT() \
    prvTraceEventCreate2(pxCurrentTCB[xPortGetCoreID()]->ucNotifyState == taskNOTIFICATION_RECEIVED ? PSF_EVENT_TASK_NOTIFY_WAIT : PSF_EVENT_TASK_NOTIFY_WAIT_FAILED, (void*)pxCurrentTCB, xTicksToWait)
 
#else
 
#define traceTASK_NOTIFY_WAIT() \
    prvTraceEventCreate2(pxCurrentTCB[xPortGetCoreID()]->eNotifyState == eNotified ? PSF_EVENT_TASK_NOTIFY_WAIT : PSF_EVENT_TASK_NOTIFY_WAIT_FAILED, (void*)pxCurrentTCB, xTicksToWait)
 
#endif
 
/* WAIT and TAKE will be handled identically */
#undef traceTASK_NOTIFY_TAKE
#define traceTASK_NOTIFY_TAKE traceTASK_NOTIFY_WAIT
 
#undef traceTASK_NOTIFY_WAIT_BLOCK
#if (TRC_CFG_ESP_IDF_VERSION >= TRC_ESP_IDF_VERSION_5_2_0)
#define traceTASK_NOTIFY_WAIT_BLOCK(index) \
    prvTraceEventCreate2(PSF_EVENT_TASK_NOTIFY_WAIT_BLOCK, (void*)pxCurrentTCBs[xPortGetCoreID()], xTicksToWait)
 
#elif (TRC_CFG_ESP_IDF_VERSION > TRC_ESP_IDF_VERSION_4_3_0)
 
#define traceTASK_NOTIFY_WAIT_BLOCK(index) \
    prvTraceEventCreate2(PSF_EVENT_TASK_NOTIFY_WAIT_BLOCK, (void*)pxCurrentTCB[xPortGetCoreID()], xTicksToWait)
 
#else /* TRC_CFG_ESP_IDF_VERSION > TRC_ESP_IDF_VERSION_4_3_0 */
 
#define traceTASK_NOTIFY_WAIT_BLOCK() \
    prvTraceEventCreate2(PSF_EVENT_TASK_NOTIFY_WAIT_BLOCK, (void*)pxCurrentTCB[xPortGetCoreID()], xTicksToWait)
 
#endif /* TRC_CFG_ESP_IDF_VERSION > TRC_ESP_IDF_VERSION_4_3_0 */
 
/* WAIT_BLOCK and TAKE_BLOCK will be handled identically */
#undef traceTASK_NOTIFY_TAKE_BLOCK
#define traceTASK_NOTIFY_TAKE_BLOCK traceTASK_NOTIFY_WAIT_BLOCK
 
#undef traceQUEUE_REGISTRY_ADD
#define traceQUEUE_REGISTRY_ADD(object, name) \
    xTraceObjectSetNameWithoutHandle(object, (const char*)(name));
 
#if (TRC_CFG_INCLUDE_STREAM_BUFFER_EVENTS == 1)
 
#undef traceSTREAM_BUFFER_CREATE
#define traceSTREAM_BUFFER_CREATE( pxStreamBuffer, xIsMessageBuffer ) \
    xTraceObjectRegisterWithoutHandle((xIsMessageBuffer) == 1 ? PSF_EVENT_MESSAGEBUFFER_CREATE : PSF_EVENT_STREAMBUFFER_CREATE, (void*)(pxStreamBuffer), "", (uint32_t)xBufferSizeBytes)
 
#undef traceSTREAM_BUFFER_CREATE_FAILED
#define traceSTREAM_BUFFER_CREATE_FAILED( xIsMessageBuffer ) \
    prvTraceEventCreate2((xIsMessageBuffer) == 1 ? PSF_EVENT_MESSAGEBUFFER_CREATE_FAILED : PSF_EVENT_STREAMBUFFER_CREATE_FAILED, 0 , xBufferSizeBytes)
 
#undef traceSTREAM_BUFFER_CREATE_STATIC_FAILED
#define traceSTREAM_BUFFER_CREATE_STATIC_FAILED( xReturn, xIsMessageBuffer ) \
    traceSTREAM_BUFFER_CREATE_FAILED( xIsMessageBuffer )
 
#undef traceSTREAM_BUFFER_DELETE
#define traceSTREAM_BUFFER_DELETE( xStreamBuffer ) \
    xTraceObjectUnregisterWithoutHandle(prvGetStreamBufferType(xStreamBuffer) > 0 ? PSF_EVENT_MESSAGEBUFFER_DELETE : PSF_EVENT_STREAMBUFFER_DELETE, (void*)(xStreamBuffer), prvBytesInBuffer(xStreamBuffer));
 
#undef traceSTREAM_BUFFER_RESET
#define traceSTREAM_BUFFER_RESET( xStreamBuffer ) \
    prvTraceEventCreate2(prvGetStreamBufferType(xStreamBuffer) > 0 ? PSF_EVENT_MESSAGEBUFFER_RESET : PSF_EVENT_STREAMBUFFER_RESET, (void*)(xStreamBuffer), 0)
 
#undef traceSTREAM_BUFFER_SEND
#define traceSTREAM_BUFFER_SEND( xStreamBuffer, xReturn ) \
    prvTraceEventCreate2(prvGetStreamBufferType(xStreamBuffer) > 0 ? PSF_EVENT_MESSAGEBUFFER_SEND : PSF_EVENT_STREAMBUFFER_SEND, (void*)(xStreamBuffer), prvBytesInBuffer(xStreamBuffer))
 
#undef traceBLOCKING_ON_STREAM_BUFFER_SEND
#define traceBLOCKING_ON_STREAM_BUFFER_SEND( xStreamBuffer ) \
    prvTraceEventCreate1(prvGetStreamBufferType(xStreamBuffer) > 0 ? PSF_EVENT_MESSAGEBUFFER_SEND_BLOCK : PSF_EVENT_STREAMBUFFER_SEND_BLOCK, (void*)(xStreamBuffer))
 
#undef traceSTREAM_BUFFER_SEND_FAILED
#define traceSTREAM_BUFFER_SEND_FAILED( xStreamBuffer ) \
    prvTraceEventCreate1(prvGetStreamBufferType(xStreamBuffer) > 0 ? PSF_EVENT_MESSAGEBUFFER_SEND_FAILED : PSF_EVENT_STREAMBUFFER_SEND_FAILED, (void*)(xStreamBuffer))
 
#undef traceSTREAM_BUFFER_RECEIVE
#define traceSTREAM_BUFFER_RECEIVE( xStreamBuffer, xReceivedLength ) \
    prvTraceEventCreate2(prvGetStreamBufferType(xStreamBuffer) > 0 ? PSF_EVENT_MESSAGEBUFFER_RECEIVE: PSF_EVENT_STREAMBUFFER_RECEIVE, (void*)(xStreamBuffer), prvBytesInBuffer(xStreamBuffer))
 
#undef traceBLOCKING_ON_STREAM_BUFFER_RECEIVE
#define traceBLOCKING_ON_STREAM_BUFFER_RECEIVE( xStreamBuffer ) \
    prvTraceEventCreate1(prvGetStreamBufferType(xStreamBuffer) > 0 ? PSF_EVENT_MESSAGEBUFFER_RECEIVE_BLOCK: PSF_EVENT_STREAMBUFFER_RECEIVE_BLOCK, (void*)(xStreamBuffer))
 
#undef traceSTREAM_BUFFER_RECEIVE_FAILED
#define traceSTREAM_BUFFER_RECEIVE_FAILED( xStreamBuffer ) \
    prvTraceEventCreate1(prvGetStreamBufferType(xStreamBuffer) > 0 ? PSF_EVENT_MESSAGEBUFFER_RECEIVE_FAILED: PSF_EVENT_STREAMBUFFER_RECEIVE_FAILED, (void*)(xStreamBuffer))
 
#undef traceSTREAM_BUFFER_SEND_FROM_ISR
#define traceSTREAM_BUFFER_SEND_FROM_ISR( xStreamBuffer, xReturn ) \
    if ( (xReturn) > ( size_t ) 0 ) \
    { \
        prvTraceEventCreate2(prvGetStreamBufferType(xStreamBuffer) > 0 ? PSF_EVENT_MESSAGEBUFFER_SEND_FROM_ISR : PSF_EVENT_STREAMBUFFER_SEND_FROM_ISR, (void*)(xStreamBuffer), prvBytesInBuffer(xStreamBuffer)); \
    } \
    else \
    { \
        prvTraceEventCreate1(prvGetStreamBufferType(xStreamBuffer) > 0 ? PSF_EVENT_MESSAGEBUFFER_SEND_FROM_ISR_FAILED : PSF_EVENT_STREAMBUFFER_SEND_FROM_ISR_FAILED, (void*)(xStreamBuffer)); \
    }
 
#undef traceSTREAM_BUFFER_RECEIVE_FROM_ISR
#define traceSTREAM_BUFFER_RECEIVE_FROM_ISR( xStreamBuffer, xReceivedLength ) \
    if ( (xReceivedLength) > ( size_t ) 0 ) \
    { \
        prvTraceEventCreate2(prvGetStreamBufferType(xStreamBuffer) > 0 ? PSF_EVENT_MESSAGEBUFFER_RECEIVE_FROM_ISR : PSF_EVENT_STREAMBUFFER_RECEIVE_FROM_ISR, (void*)(xStreamBuffer), prvBytesInBuffer(xStreamBuffer)); \
    } \
    else \
    { \
        prvTraceEventCreate1(prvGetStreamBufferType(xStreamBuffer) > 0 ? PSF_EVENT_MESSAGEBUFFER_RECEIVE_FROM_ISR_FAILED : PSF_EVENT_STREAMBUFFER_RECEIVE_FROM_ISR_FAILED, (void*)(xStreamBuffer)); \
    }
 
#endif
 
#endif
 
#else
    
/* When recorder is disabled */
#define vTraceSetQueueName(object, name)
#define vTraceSetSemaphoreName(object, name)
#define vTraceSetMutexName(object, name)
#define vTraceSetEventGroupName(object, name)
#define vTraceSetStreamBufferName(object, name)
#define vTraceSetMessageBufferName(object, name)
    
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif