| /******************************************************************************* | |
| * Trace Recorder Library for Tracealyzer v4.1.5 | |
| * Percepio AB, www.percepio.com | |
| * | |
| * Terms of Use | |
| * This file is part of the trace recorder library (RECORDER), which is the | |
| * intellectual property of Percepio AB (PERCEPIO) and provided under a | |
| * license as follows. | |
| * The RECORDER may be used free of charge for the purpose of recording data | |
| * intended for analysis in PERCEPIO products. It may not be used or modified | |
| * for other purposes without explicit permission from PERCEPIO. | |
| * You may distribute the RECORDER in its original source code form, assuming | |
| * this text (terms of use, disclaimer, copyright notice) is unchanged. You are | |
| * allowed to distribute the RECORDER with minor modifications intended for | |
| * configuration or porting of the RECORDER, e.g., to allow using it on a | |
| * specific processor, processor family or with a specific communication | |
| * interface. Any such modifications should be documented directly below | |
| * this comment block. | |
| * | |
| * Disclaimer | |
| * The RECORDER is being delivered to you AS IS and PERCEPIO makes no warranty | |
| * as to its use or performance. PERCEPIO does not and cannot warrant the | |
| * performance or results you may obtain by using the RECORDER or documentation. | |
| * PERCEPIO make no warranties, express or implied, as to noninfringement of | |
| * third party rights, merchantability, or fitness for any particular purpose. | |
| * In no event will PERCEPIO, its technology partners, or distributors be liable | |
| * to you for any consequential, incidental or special damages, including any | |
| * lost profits or lost savings, even if a representative of PERCEPIO has been | |
| * advised of the possibility of such damages, or for any claim by any third | |
| * party. Some jurisdictions do not allow the exclusion or limitation of | |
| * incidental, consequential or special damages, or the exclusion of implied | |
| * warranties or limitations on how long an implied warranty may last, so the | |
| * above limitations may not apply to you. | |
| * | |
| * FreeRTOS-specific definitions needed by the trace recorder | |
| * | |
| * <LICENSE INFO> | |
| * | |
| * Tabs are used for indent in this file (1 tab = 4 spaces) | |
| * | |
| * Copyright Percepio AB, 2018. | |
| * www.percepio.com | |
| ******************************************************************************/ | |
| #ifndef TRC_KERNEL_PORT_H | |
| #define TRC_KERNEL_PORT_H | |
| #include "FreeRTOS.h" /* Defines configUSE_TRACE_FACILITY */ | |
| #include "trcPortDefines.h" | |
| #ifdef __cplusplus | |
| extern "C" { | |
| #endif | |
| #define TRC_USE_TRACEALYZER_RECORDER configUSE_TRACE_FACILITY | |
| /*** FreeRTOS version codes **************************************************/ | |
| #define FREERTOS_VERSION_NOT_SET 0 | |
| #define TRC_FREERTOS_VERSION_7_3 1 /* v7.3 is earliest supported.*/ | |
| #define TRC_FREERTOS_VERSION_7_4 2 | |
| #define TRC_FREERTOS_VERSION_7_5_OR_7_6 3 | |
| #define TRC_FREERTOS_VERSION_8_X 4 /* Any v8.x.x*/ | |
| #define TRC_FREERTOS_VERSION_9_0_0 5 | |
| #define TRC_FREERTOS_VERSION_9_0_1 6 | |
| #define TRC_FREERTOS_VERSION_9_0_2 7 | |
| #define TRC_FREERTOS_VERSION_10_0_0 8 /* If using FreeRTOS v10.0.0 or later version */ | |
| #define TRC_FREERTOS_VERSION_9_X 42 /* Not allowed anymore */ | |
| #if (TRC_CFG_FREERTOS_VERSION == TRC_FREERTOS_VERSION_9_X) | |
| /* This setting for TRC_CFG_FREERTOS_VERSION is no longer allowed as v9.0.1 needs special handling. */ | |
| #error "Please specify your exact FreeRTOS version in trcConfig.h, from the options listed above." | |
| #endif | |
| #if (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_10_0_0) | |
| #define prvGetStreamBufferType(x) ((( StreamBuffer_t * )x )->ucFlags & sbFLAGS_IS_MESSAGE_BUFFER) | |
| #else | |
| #define prvGetStreamBufferType(x) 0 | |
| #endif | |
| /* Added mainly for our internal testing. This makes it easier to create test applications that | |
| runs on multiple FreeRTOS versions. */ | |
| #if (TRC_CFG_FREERTOS_VERSION < TRC_FREERTOS_VERSION_8_X) | |
| /* FreeRTOS v7.0 and later */ | |
| #define STRING_CAST(x) ( (signed char*) x ) | |
| #define TickType portTickType | |
| #else | |
| /* FreeRTOS v8.0 and later */ | |
| #define STRING_CAST(x) x | |
| #define TickType TickType_t | |
| #endif | |
| #if (defined(TRC_USE_TRACEALYZER_RECORDER)) && (TRC_USE_TRACEALYZER_RECORDER == 1) | |
| /******************************************************************************* | |
| * INCLUDE_xTaskGetCurrentTaskHandle must be set to 1 for tracing to work properly | |
| ******************************************************************************/ | |
| #undef INCLUDE_xTaskGetCurrentTaskHandle | |
| #define INCLUDE_xTaskGetCurrentTaskHandle 1 | |
| #if (TRC_CFG_SCHEDULING_ONLY == 0) | |
| /******************************************************************************* | |
| * vTraceSetQueueName(void* object, const char* name) | |
| * | |
| * Parameter object: pointer to the Queue that shall be named | |
| * Parameter name: the name to set (const string literal) | |
| * | |
| * Sets a name for Queue objects for display in Tracealyzer. | |
| ******************************************************************************/ | |
| void vTraceSetQueueName(void* object, const char* name); | |
| /******************************************************************************* | |
| * vTraceSetSemaphoreName(void* object, const char* name) | |
| * | |
| * Parameter object: pointer to the Semaphore that shall be named | |
| * Parameter name: the name to set (const string literal) | |
| * | |
| * Sets a name for Semaphore objects for display in Tracealyzer. | |
| ******************************************************************************/ | |
| void vTraceSetSemaphoreName(void* object, const char* name); | |
| /******************************************************************************* | |
| * vTraceSetMutexName(void* object, const char* name) | |
| * | |
| * Parameter object: pointer to the Mutex that shall be named | |
| * Parameter name: the name to set (const string literal) | |
| * | |
| * Sets a name for Semaphore objects for display in Tracealyzer. | |
| ******************************************************************************/ | |
| void vTraceSetMutexName(void* object, const char* name); | |
| #if (TRC_CFG_INCLUDE_EVENT_GROUP_EVENTS == 1) | |
| /******************************************************************************* | |
| * vTraceSetEventGroupName(void* object, const char* name) | |
| * | |
| * Parameter object: pointer to the EventGroup that shall be named | |
| * Parameter name: the name to set (const string literal) | |
| * | |
| * Sets a name for EventGroup objects for display in Tracealyzer. | |
| ******************************************************************************/ | |
| void vTraceSetEventGroupName(void* object, const char* name); | |
| #else /* (TRC_CFG_INCLUDE_EVENT_GROUP_EVENTS == 1) */ | |
| #define vTraceSetEventGroupName(object, name) /* Do nothing */ | |
| #endif /* (TRC_CFG_INCLUDE_EVENT_GROUP_EVENTS == 1) */ | |
| #if (TRC_CFG_INCLUDE_STREAM_BUFFER_EVENTS == 1) | |
| /******************************************************************************* | |
| * vTraceSetStreamBufferName(void* object, const char* name) | |
| * | |
| * Parameter object: pointer to the StreamBuffer that shall be named | |
| * Parameter name: the name to set (const string literal) | |
| * | |
| * Sets a name for StreamBuffer objects for display in Tracealyzer. | |
| ******************************************************************************/ | |
| void vTraceSetStreamBufferName(void* object, const char* name); | |
| #else /* (TRC_CFG_INCLUDE_STREAM_BUFFER_EVENTS == 1) */ | |
| #define vTraceSetStreamBufferName(object, name) /* Do nothing */ | |
| #endif /* (TRC_CFG_INCLUDE_STREAM_BUFFER_EVENTS == 1) */ | |
| #if (TRC_CFG_INCLUDE_STREAM_BUFFER_EVENTS == 1) | |
| /******************************************************************************* | |
| * vTraceSetMessageBufferName(void* object, const char* name) | |
| * | |
| * Parameter object: pointer to the MessageBuffer that shall be named | |
| * Parameter name: the name to set (const string literal) | |
| * | |
| * Sets a name for MessageBuffer objects for display in Tracealyzer. | |
| ******************************************************************************/ | |
| void vTraceSetMessageBufferName(void* object, const char* name); | |
| #else /* (TRC_CFG_INCLUDE_STREAM_BUFFER_EVENTS == 1) */ | |
| #define vTraceSetMessageBufferName(object, name) /* Do nothing */ | |
| #endif /* (TRC_CFG_INCLUDE_STREAM_BUFFER_EVENTS == 1) */ | |
| #else /* (TRC_CFG_SCHEDULING_ONLY == 0) */ | |
| #define vTraceSetQueueName(object, name) /* Do nothing */ | |
| #define vTraceSetSemaphoreName(object, name) /* Do nothing */ | |
| #define vTraceSetMutexName(object, name) /* Do nothing */ | |
| #define vTraceSetEventGroupName(object, name) /* Do nothing */ | |
| #define vTraceSetStreamBufferName(object, name) /* Do nothing */ | |
| #define vTraceSetMessageBufferName(object, name) /* Do nothing */ | |
| #endif /* (TRC_CFG_SCHEDULING_ONLY == 0) */ | |
| /******************************************************************************* | |
| * Note: Setting names for event groups is difficult to support, this has been | |
| * excluded intentionally. This since we don't know if event_groups.c is | |
| * included in the build, so referencing it from the recorder may cause errors. | |
| ******************************************************************************/ | |
| /* Gives the currently executing task (wrapper for RTOS-specific function) */ | |
| void* prvTraceGetCurrentTaskHandle(void); | |
| #if (((TRC_CFG_RECORDER_MODE == TRC_RECORDER_MODE_SNAPSHOT) && (TRC_CFG_INCLUDE_ISR_TRACING == 1)) || (TRC_CFG_RECORDER_MODE == TRC_RECORDER_MODE_STREAMING)) | |
| /* Tells if the scheduler currently is suspended (task-switches can't occur) */ | |
| unsigned char prvTraceIsSchedulerSuspended(void); | |
| /******************************************************************************* | |
| * INCLUDE_xTaskGetSchedulerState must be set to 1 for tracing to work properly | |
| ******************************************************************************/ | |
| #undef INCLUDE_xTaskGetSchedulerState | |
| #define INCLUDE_xTaskGetSchedulerState 1 | |
| #endif /* (((TRC_CFG_RECORDER_MODE == TRC_RECORDER_MODE_SNAPSHOT) && (TRC_CFG_INCLUDE_ISR_TRACING == 1)) || (TRC_CFG_RECORDER_MODE == TRC_RECORDER_MODE_STREAMING)) */ | |
| #define TRACE_KERNEL_VERSION 0x1AA1 | |
| #define TRACE_TICK_RATE_HZ configTICK_RATE_HZ /* Defined in "FreeRTOS.h" */ | |
| #define TRACE_CPU_CLOCK_HZ configCPU_CLOCK_HZ /* Defined in "FreeRTOSConfig.h" */ | |
| #define TRACE_GET_CURRENT_TASK() prvTraceGetCurrentTaskHandle() | |
| #define TRACE_GET_OS_TICKS() (uiTraceTickCount) /* Streaming only */ | |
| /* If using dynamic allocation of snapshot trace buffer... */ | |
| #define TRACE_MALLOC(size) pvPortMalloc(size) | |
| #if defined(configUSE_TIMERS) | |
| #if (configUSE_TIMERS == 1) | |
| #undef INCLUDE_xTimerGetTimerDaemonTaskHandle | |
| #define INCLUDE_xTimerGetTimerDaemonTaskHandle 1 | |
| #endif /* configUSE_TIMERS == 1*/ | |
| #endif /* configUSE_TIMERS */ | |
| /* For ARM Cortex-M devices - assumes the ARM CMSIS API is available */ | |
| #if (defined (__CORTEX_M)) | |
| #define TRACE_ALLOC_CRITICAL_SECTION() uint32_t __irq_status; | |
| #define TRACE_ENTER_CRITICAL_SECTION() {__irq_status = __get_PRIMASK(); __set_PRIMASK(1);} /* PRIMASK disables ALL interrupts - allows for tracing in any ISR */ | |
| #define TRACE_EXIT_CRITICAL_SECTION() {__set_PRIMASK(__irq_status);} | |
| #endif | |
| #if ((TRC_CFG_HARDWARE_PORT == TRC_HARDWARE_PORT_ARM_CORTEX_A9) || (TRC_CFG_HARDWARE_PORT == TRC_HARDWARE_PORT_Renesas_RX600) || (TRC_CFG_HARDWARE_PORT == TRC_HARDWARE_PORT_MICROCHIP_PIC24_PIC32) || (TRC_CFG_HARDWARE_PORT == TRC_HARDWARE_PORT_Altera_NiosII)) | |
| #define TRACE_ALLOC_CRITICAL_SECTION() int __irq_status; | |
| #define TRACE_ENTER_CRITICAL_SECTION() {__irq_status = portSET_INTERRUPT_MASK_FROM_ISR();} | |
| #define TRACE_EXIT_CRITICAL_SECTION() {portCLEAR_INTERRUPT_MASK_FROM_ISR(__irq_status);} | |
| #endif | |
| #if (TRC_CFG_HARDWARE_PORT == TRC_HARDWARE_PORT_Win32) | |
| /* In the Win32 port, there are no real interrupts, so we can use the normal critical sections */ | |
| #define TRACE_ALLOC_CRITICAL_SECTION() | |
| #define TRACE_ENTER_CRITICAL_SECTION() portENTER_CRITICAL() | |
| #define TRACE_EXIT_CRITICAL_SECTION() portEXIT_CRITICAL() | |
| #endif | |
| #if (TRC_CFG_HARDWARE_PORT == TRC_HARDWARE_PORT_POWERPC_Z4) | |
| #if (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_8_X) | |
| /* FreeRTOS v8.0 or later */ | |
| #define TRACE_ALLOC_CRITICAL_SECTION() UBaseType_t __irq_status; | |
| #define TRACE_ENTER_CRITICAL_SECTION() {__irq_status = portSET_INTERRUPT_MASK_FROM_ISR();} | |
| #define TRACE_EXIT_CRITICAL_SECTION() {portCLEAR_INTERRUPT_MASK_FROM_ISR(__irq_status);} | |
| #else | |
| /* FreeRTOS v7.x */ | |
| #define TRACE_ALLOC_CRITICAL_SECTION() unsigned portBASE_TYPE __irq_status; | |
| #define TRACE_ENTER_CRITICAL_SECTION() {__irq_status = portSET_INTERRUPT_MASK_FROM_ISR();} | |
| #define TRACE_EXIT_CRITICAL_SECTION() {portCLEAR_INTERRUPT_MASK_FROM_ISR(__irq_status);} | |
| #endif | |
| #endif | |
| #ifndef TRACE_ENTER_CRITICAL_SECTION | |
| #error "This hardware port has no definition for critical sections! See http://percepio.com/2014/10/27/how-to-define-critical-sections-for-the-recorder/" | |
| #endif | |
| #if (TRC_CFG_FREERTOS_VERSION == TRC_FREERTOS_VERSION_9_0_1) | |
| /****************************************************************************** | |
| * Fix for FreeRTOS v9.0.1 to correctly identify xQueuePeek events. | |
| * | |
| * In FreeRTOS v9.0.1, the below trace hooks are incorrectly used from three | |
| * different functions. This as the earlier function xQueueGenericReceive | |
| * has been replaced by xQueuePeek, xQueueSemaphoreTake and xQueueReceive. | |
| * | |
| * xQueueGenericReceive had a parameter "xJustPeeking", used by the trace hooks | |
| * to tell between xQueuePeek events and others. This is no longer present, so | |
| * we need another way to correctly identify peek events. Since all three | |
| * functions call the same trace macros, the context of these macro is unknown. | |
| * | |
| * We therefore check the __LINE__ macro inside of the trace macros. This gives | |
| * the line number of queue.c, where the macros are used. This can be used to | |
| * tell if the context is xQueuePeek or another function. | |
| * __LINE__ is a standard compiler feature since ancient times, so it should | |
| * work on all common compilers. | |
| * | |
| * This might seem as a quite brittle and unusual solution, but works in this | |
| * particular case and is only for FreeRTOS v9.0.1. | |
| * Future versions of FreeRTOS should not need this fix, as we have submitted | |
| * a correction of queue.c with individual trace macros for each function. | |
| ******************************************************************************/ | |
| #define isQueueReceiveHookActuallyPeek (__LINE__ > 1674) /* Half way between the closes trace points */ | |
| #elif (TRC_CFG_FREERTOS_VERSION <= TRC_FREERTOS_VERSION_9_0_0) | |
| #define isQueueReceiveHookActuallyPeek xJustPeeking | |
| #elif (TRC_CFG_FREERTOS_VERSION > TRC_FREERTOS_VERSION_9_0_1) | |
| #define isQueueReceiveHookActuallyPeek (__LINE__ < 0) /* instead of pdFALSE to fix a warning of "constant condition" */ | |
| #endif | |
| extern uint16_t CurrentFilterMask; | |
| extern uint16_t CurrentFilterGroup; | |
| uint8_t prvTraceGetQueueType(void* handle); | |
| uint16_t prvTraceGetTaskNumberLow16(void* handle); | |
| uint16_t prvTraceGetTaskNumberHigh16(void* handle); | |
| void prvTraceSetTaskNumberLow16(void* handle, uint16_t value); | |
| void prvTraceSetTaskNumberHigh16(void* handle, uint16_t value); | |
| uint16_t prvTraceGetQueueNumberLow16(void* handle); | |
| uint16_t prvTraceGetQueueNumberHigh16(void* handle); | |
| void prvTraceSetQueueNumberLow16(void* handle, uint16_t value); | |
| void prvTraceSetQueueNumberHigh16(void* handle, uint16_t value); | |
| #if (TRC_CFG_INCLUDE_TIMER_EVENTS == 1 && TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_10_0_0) | |
| uint16_t prvTraceGetTimerNumberLow16(void* handle); | |
| uint16_t prvTraceGetTimerNumberHigh16(void* handle); | |
| void prvTraceSetTimerNumberLow16(void* handle, uint16_t value); | |
| void prvTraceSetTimerNumberHigh16(void* handle, uint16_t value); | |
| #endif /* (TRC_CFG_INCLUDE_TIMER_EVENTS == 1 && TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_10_0_0) */ | |
| #if (TRC_CFG_INCLUDE_EVENT_GROUP_EVENTS == 1 && TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_10_0_0) | |
| uint16_t prvTraceGetEventGroupNumberLow16(void* handle); | |
| uint16_t prvTraceGetEventGroupNumberHigh16(void* handle); | |
| void prvTraceSetEventGroupNumberLow16(void* handle, uint16_t value); | |
| void prvTraceSetEventGroupNumberHigh16(void* handle, uint16_t value); | |
| #endif /* (TRC_CFG_INCLUDE_EVENT_GROUP_EVENTS == 1 && TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_10_0_0) */ | |
| #if (TRC_CFG_INCLUDE_STREAM_BUFFER_EVENTS == 1 && TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_10_0_0) | |
| uint16_t prvTraceGetStreamBufferNumberLow16(void* handle); | |
| uint16_t prvTraceGetStreamBufferNumberHigh16(void* handle); | |
| void prvTraceSetStreamBufferNumberLow16(void* handle, uint16_t value); | |
| void prvTraceSetStreamBufferNumberHigh16(void* handle, uint16_t value); | |
| #endif /* (TRC_CFG_INCLUDE_STREAM_BUFFER_EVENTS == 1 && TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_10_0_0) */ | |
| #define TRACE_GET_TASK_FILTER(pxTask) prvTraceGetTaskNumberHigh16((void*)pxTask) | |
| #define TRACE_SET_TASK_FILTER(pxTask, group) prvTraceSetTaskNumberHigh16((void*)pxTask, group) | |
| #define TRACE_GET_QUEUE_FILTER(pxObject) prvTraceGetQueueNumberHigh16((void*)pxObject) | |
| #define TRACE_SET_QUEUE_FILTER(pxObject, group) prvTraceSetQueueNumberHigh16((void*)pxObject, group) | |
| #if (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_10_0_0) | |
| #define TRACE_GET_EVENTGROUP_FILTER(pxObject) prvTraceGetEventGroupNumberHigh16((void*)pxObject) | |
| #define TRACE_SET_EVENTGROUP_FILTER(pxObject, group) prvTraceSetEventGroupNumberHigh16((void*)pxObject, group) | |
| #else /* (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_10_0_0) */ | |
| /* FreeRTOS versions before v10.0 does not support filtering for event groups */ | |
| #define TRACE_GET_EVENTGROUP_FILTER(pxObject) 1 | |
| #define TRACE_SET_EVENTGROUP_FILTER(pxObject, group) | |
| #endif /* (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_10_0_0) */ | |
| #if (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_10_0_0) | |
| #define TRACE_GET_TIMER_FILTER(pxObject) prvTraceGetTimerNumberHigh16((void*)pxObject) | |
| #define TRACE_SET_TIMER_FILTER(pxObject, group) prvTraceSetTimerNumberHigh16((void*)pxObject, group) | |
| #else /* (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_10_0_0) */ | |
| /* FreeRTOS versions before v10.0 does not support filtering for timers */ | |
| #define TRACE_GET_TIMER_FILTER(pxObject) 1 | |
| #define TRACE_SET_TIMER_FILTER(pxObject, group) | |
| #endif /* (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_10_0_0) */ | |
| #define TRACE_GET_STREAMBUFFER_FILTER(pxObject) prvTraceGetStreamBufferNumberHigh16((void*)pxObject) | |
| #define TRACE_SET_STREAMBUFFER_FILTER(pxObject, group) prvTraceSetStreamBufferNumberHigh16((void*)pxObject, group) | |
| /* We can only support filtering if FreeRTOS is at least v7.4 */ | |
| #if (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_7_4) | |
| #define TRACE_GET_OBJECT_FILTER(CLASS, pxObject) TRACE_GET_##CLASS##_FILTER(pxObject) | |
| #define TRACE_SET_OBJECT_FILTER(CLASS, pxObject, group) TRACE_SET_##CLASS##_FILTER(pxObject, group) | |
| #else /* (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_7_4) */ | |
| #define TRACE_GET_OBJECT_FILTER(CLASS, pxObject) 1 | |
| #define TRACE_SET_OBJECT_FILTER(CLASS, pxObject, group) | |
| #endif /* (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_7_4) */ | |
| /******************************************************************************/ | |
| /*** Definitions for Snapshot mode ********************************************/ | |
| /******************************************************************************/ | |
| #if (TRC_CFG_RECORDER_MODE == TRC_RECORDER_MODE_SNAPSHOT) | |
| /*** The object classes *******************************************************/ | |
| #define TRACE_NCLASSES 9 | |
| #define TRACE_CLASS_QUEUE ((traceObjectClass)0) | |
| #define TRACE_CLASS_SEMAPHORE ((traceObjectClass)1) | |
| #define TRACE_CLASS_MUTEX ((traceObjectClass)2) | |
| #define TRACE_CLASS_TASK ((traceObjectClass)3) | |
| #define TRACE_CLASS_ISR ((traceObjectClass)4) | |
| #define TRACE_CLASS_TIMER ((traceObjectClass)5) | |
| #define TRACE_CLASS_EVENTGROUP ((traceObjectClass)6) | |
| #define TRACE_CLASS_STREAMBUFFER ((traceObjectClass)7) | |
| #define TRACE_CLASS_MESSAGEBUFFER ((traceObjectClass)8) | |
| /*** Definitions for Object Table ********************************************/ | |
| #define TRACE_KERNEL_OBJECT_COUNT ((TRC_CFG_NQUEUE) + (TRC_CFG_NSEMAPHORE) + (TRC_CFG_NMUTEX) + (TRC_CFG_NTASK) + (TRC_CFG_NISR) + (TRC_CFG_NTIMER) + (TRC_CFG_NEVENTGROUP) + (TRC_CFG_NSTREAMBUFFER) + (TRC_CFG_NMESSAGEBUFFER)) | |
| /* Queue properties (except name): current number of message in queue */ | |
| #define PropertyTableSizeQueue ((TRC_CFG_NAME_LEN_QUEUE) + 1) | |
| /* Semaphore properties (except name): state (signaled = 1, cleared = 0) */ | |
| #define PropertyTableSizeSemaphore ((TRC_CFG_NAME_LEN_SEMAPHORE) + 1) | |
| /* Mutex properties (except name): owner (task handle, 0 = free) */ | |
| #define PropertyTableSizeMutex ((TRC_CFG_NAME_LEN_MUTEX) + 1) | |
| /* Task properties (except name): Byte 0: Current priority | |
| Byte 1: state (if already active) | |
| Byte 2: legacy, not used | |
| Byte 3: legacy, not used */ | |
| #define PropertyTableSizeTask ((TRC_CFG_NAME_LEN_TASK) + 4) | |
| /* ISR properties: Byte 0: priority | |
| Byte 1: state (if already active) */ | |
| #define PropertyTableSizeISR ((TRC_CFG_NAME_LEN_ISR) + 2) | |
| /* TRC_CFG_NTIMER properties: Byte 0: state (unused for now) */ | |
| #define PropertyTableSizeTimer ((TRC_CFG_NAME_LEN_TIMER) + 1) | |
| /* TRC_CFG_NEVENTGROUP properties: Byte 0-3: state (unused for now)*/ | |
| #define PropertyTableSizeEventGroup ((TRC_CFG_NAME_LEN_EVENTGROUP) + 4) | |
| /* TRC_CFG_NSTREAMBUFFER properties: Byte 0-3: state (unused for now)*/ | |
| #define PropertyTableSizeStreamBuffer ((TRC_CFG_NAME_LEN_STREAMBUFFER) + 4) | |
| /* TRC_CFG_NMESSAGEBUFFER properties: Byte 0-3: state (unused for now)*/ | |
| #define PropertyTableSizeMessageBuffer ((TRC_CFG_NAME_LEN_MESSAGEBUFFER) + 4) | |
| /* The layout of the byte array representing the Object Property Table */ | |
| #define StartIndexQueue (0) | |
| #define StartIndexSemaphore (StartIndexQueue + (TRC_CFG_NQUEUE) * PropertyTableSizeQueue) | |
| #define StartIndexMutex (StartIndexSemaphore + (TRC_CFG_NSEMAPHORE) * PropertyTableSizeSemaphore) | |
| #define StartIndexTask (StartIndexMutex + (TRC_CFG_NMUTEX) * PropertyTableSizeMutex) | |
| #define StartIndexISR (StartIndexTask + (TRC_CFG_NTASK) * PropertyTableSizeTask) | |
| #define StartIndexTimer (StartIndexISR + (TRC_CFG_NISR) * PropertyTableSizeISR) | |
| #define StartIndexEventGroup (StartIndexTimer + (TRC_CFG_NTIMER) * PropertyTableSizeTimer) | |
| #define StartIndexStreamBuffer (StartIndexEventGroup + (TRC_CFG_NEVENTGROUP) * PropertyTableSizeEventGroup) | |
| #define StartIndexMessageBuffer (StartIndexStreamBuffer + (TRC_CFG_NSTREAMBUFFER) * PropertyTableSizeStreamBuffer) | |
| /* Number of bytes used by the object table */ | |
| #define TRACE_OBJECT_TABLE_SIZE (StartIndexMessageBuffer + (TRC_CFG_NMESSAGEBUFFER) * PropertyTableSizeMessageBuffer) | |
| /* Flag to tell the context of tracePEND_FUNC_CALL_FROM_ISR */ | |
| extern int uiInEventGroupSetBitsFromISR; | |
| /* Initialization of the object property table */ | |
| void vTraceInitObjectPropertyTable(void); | |
| /* Initialization of the handle mechanism, see e.g, prvTraceGetObjectHandle */ | |
| void vTraceInitObjectHandleStack(void); | |
| /* Returns the "Not enough handles" error message for the specified object class */ | |
| const char* pszTraceGetErrorNotEnoughHandles(traceObjectClass objectclass); | |
| void* prvTraceGetCurrentTaskHandle(void); | |
| /****************************************************************************** | |
| * TraceQueueClassTable | |
| * Translates a FreeRTOS QueueType into trace objects classes (TRACE_CLASS_). | |
| * Has one entry for each QueueType, gives TRACE_CLASS ID. | |
| ******************************************************************************/ | |
| extern traceObjectClass TraceQueueClassTable[5]; | |
| /*** Event codes for snapshot mode - must match Tracealyzer config files ******/ | |
| #define NULL_EVENT (0x00UL) | |
| /******************************************************************************* | |
| * EVENTGROUP_DIV | |
| * | |
| * Miscellaneous events. | |
| ******************************************************************************/ | |
| #define EVENTGROUP_DIV (NULL_EVENT + 1UL) /*0x01*/ | |
| #define DIV_XPS (EVENTGROUP_DIV + 0UL) /*0x01*/ | |
| #define DIV_TASK_READY (EVENTGROUP_DIV + 1UL) /*0x02*/ | |
| #define DIV_NEW_TIME (EVENTGROUP_DIV + 2UL) /*0x03*/ | |
| /******************************************************************************* | |
| * EVENTGROUP_TS | |
| * | |
| * Events for storing task-switches and interrupts. The RESUME events are | |
| * generated if the task/interrupt is already marked active. | |
| ******************************************************************************/ | |
| #define EVENTGROUP_TS (EVENTGROUP_DIV + 3UL) /*0x04*/ | |
| #define TS_ISR_BEGIN (EVENTGROUP_TS + 0UL) /*0x04*/ | |
| #define TS_ISR_RESUME (EVENTGROUP_TS + 1UL) /*0x05*/ | |
| #define TS_TASK_BEGIN (EVENTGROUP_TS + 2UL) /*0x06*/ | |
| #define TS_TASK_RESUME (EVENTGROUP_TS + 3UL) /*0x07*/ | |
| /******************************************************************************* | |
| * EVENTGROUP_OBJCLOSE_NAME | |
| * | |
| * About Close Events | |
| * When an object is evicted from the object property table (object close), two | |
| * internal events are stored (EVENTGROUP_OBJCLOSE_NAME and | |
| * EVENTGROUP_OBJCLOSE_PROP), containing the handle-name mapping and object | |
| * properties valid up to this point. | |
| ******************************************************************************/ | |
| #define EVENTGROUP_OBJCLOSE_NAME_TRCSUCCESS (EVENTGROUP_TS + 4UL) /*0x08*/ | |
| /******************************************************************************* | |
| * EVENTGROUP_OBJCLOSE_PROP | |
| * | |
| * The internal event carrying properties of deleted objects | |
| * The handle and object class of the closed object is not stored in this event, | |
| * but is assumed to be the same as in the preceding CLOSE event. Thus, these | |
| * two events must be generated from within a critical section. | |
| * When queues are closed, arg1 is the "state" property (i.e., number of | |
| * buffered messages/signals). | |
| * When actors are closed, arg1 is priority, arg2 is handle of the "instance | |
| * finish" event, and arg3 is event code of the "instance finish" event. | |
| * In this case, the lower three bits is the object class of the instance finish | |
| * handle. The lower three bits are not used (always zero) when queues are | |
| * closed since the queue type is given in the previous OBJCLOSE_NAME event. | |
| ******************************************************************************/ | |
| #define EVENTGROUP_OBJCLOSE_PROP_TRCSUCCESS (EVENTGROUP_OBJCLOSE_NAME_TRCSUCCESS + 8UL) /*0x10*/ | |
| /******************************************************************************* | |
| * EVENTGROUP_CREATE | |
| * | |
| * The events in this group are used to log Kernel object creations. | |
| * The lower three bits in the event code gives the object class, i.e., type of | |
| * create operation (task, queue, semaphore, etc). | |
| ******************************************************************************/ | |
| #define EVENTGROUP_CREATE_OBJ_TRCSUCCESS (EVENTGROUP_OBJCLOSE_PROP_TRCSUCCESS + 8UL) /*0x18*/ | |
| /******************************************************************************* | |
| * EVENTGROUP_SEND | |
| * | |
| * The events in this group are used to log Send/Give events on queues, | |
| * semaphores and mutexes The lower three bits in the event code gives the | |
| * object class, i.e., what type of object that is operated on (queue, semaphore | |
| * or mutex). | |
| ******************************************************************************/ | |
| #define EVENTGROUP_SEND_TRCSUCCESS (EVENTGROUP_CREATE_OBJ_TRCSUCCESS + 8UL) /*0x20*/ | |
| /******************************************************************************* | |
| * EVENTGROUP_RECEIVE | |
| * | |
| * The events in this group are used to log Receive/Take events on queues, | |
| * semaphores and mutexes. The lower three bits in the event code gives the | |
| * object class, i.e., what type of object that is operated on (queue, semaphore | |
| * or mutex). | |
| ******************************************************************************/ | |
| #define EVENTGROUP_RECEIVE_TRCSUCCESS (EVENTGROUP_SEND_TRCSUCCESS + 8UL) /*0x28*/ | |
| /* Send/Give operations, from ISR */ | |
| #define EVENTGROUP_SEND_FROM_ISR_TRCSUCCESS \ | |
| (EVENTGROUP_RECEIVE_TRCSUCCESS + 8UL) /*0x30*/ | |
| /* Receive/Take operations, from ISR */ | |
| #define EVENTGROUP_RECEIVE_FROM_ISR_TRCSUCCESS \ | |
| (EVENTGROUP_SEND_FROM_ISR_TRCSUCCESS + 8UL) /*0x38*/ | |
| /* "Failed" event type versions of above (timeout, failed allocation, etc) */ | |
| #define EVENTGROUP_KSE_TRCFAILED \ | |
| (EVENTGROUP_RECEIVE_FROM_ISR_TRCSUCCESS + 8UL) /*0x40*/ | |
| /* Failed create calls - memory allocation failed */ | |
| #define EVENTGROUP_CREATE_OBJ_TRCFAILED (EVENTGROUP_KSE_TRCFAILED) /*0x40*/ | |
| /* Failed send/give - timeout! */ | |
| #define EVENTGROUP_SEND_TRCFAILED (EVENTGROUP_CREATE_OBJ_TRCFAILED + 8UL) /*0x48*/ | |
| /* Failed receive/take - timeout! */ | |
| #define EVENTGROUP_RECEIVE_TRCFAILED (EVENTGROUP_SEND_TRCFAILED + 8UL) /*0x50*/ | |
| /* Failed non-blocking send/give - queue full */ | |
| #define EVENTGROUP_SEND_FROM_ISR_TRCFAILED (EVENTGROUP_RECEIVE_TRCFAILED + 8UL) /*0x58*/ | |
| /* Failed non-blocking receive/take - queue empty */ | |
| #define EVENTGROUP_RECEIVE_FROM_ISR_TRCFAILED \ | |
| (EVENTGROUP_SEND_FROM_ISR_TRCFAILED + 8UL) /*0x60*/ | |
| /* Events when blocking on receive/take */ | |
| #define EVENTGROUP_RECEIVE_TRCBLOCK \ | |
| (EVENTGROUP_RECEIVE_FROM_ISR_TRCFAILED + 8UL) /*0x68*/ | |
| /* Events when blocking on send/give */ | |
| #define EVENTGROUP_SEND_TRCBLOCK (EVENTGROUP_RECEIVE_TRCBLOCK + 8UL) /*0x70*/ | |
| /* Events on queue peek (receive) */ | |
| #define EVENTGROUP_PEEK_TRCSUCCESS (EVENTGROUP_SEND_TRCBLOCK + 8UL) /*0x78*/ | |
| /* Events on object delete (vTaskDelete or vQueueDelete) */ | |
| #define EVENTGROUP_DELETE_OBJ_TRCSUCCESS (EVENTGROUP_PEEK_TRCSUCCESS + 8UL) /*0x80*/ | |
| /* Other events - object class is implied: TASK */ | |
| #define EVENTGROUP_OTHERS (EVENTGROUP_DELETE_OBJ_TRCSUCCESS + 8UL) /*0x88*/ | |
| #define TASK_DELAY_UNTIL (EVENTGROUP_OTHERS + 0UL) /*0x88*/ | |
| #define TASK_DELAY (EVENTGROUP_OTHERS + 1UL) /*0x89*/ | |
| #define TASK_SUSPEND (EVENTGROUP_OTHERS + 2UL) /*0x8A*/ | |
| #define TASK_RESUME (EVENTGROUP_OTHERS + 3UL) /*0x8B*/ | |
| #define TASK_RESUME_FROM_ISR (EVENTGROUP_OTHERS + 4UL) /*0x8C*/ | |
| #define TASK_PRIORITY_SET (EVENTGROUP_OTHERS + 5UL) /*0x8D*/ | |
| #define TASK_PRIORITY_INHERIT (EVENTGROUP_OTHERS + 6UL) /*0x8E*/ | |
| #define TASK_PRIORITY_DISINHERIT (EVENTGROUP_OTHERS + 7UL) /*0x8F*/ | |
| #define EVENTGROUP_MISC_PLACEHOLDER (EVENTGROUP_OTHERS + 8UL) /*0x90*/ | |
| #define PEND_FUNC_CALL (EVENTGROUP_MISC_PLACEHOLDER+0UL) /*0x90*/ | |
| #define PEND_FUNC_CALL_FROM_ISR (EVENTGROUP_MISC_PLACEHOLDER+1UL) /*0x91*/ | |
| #define PEND_FUNC_CALL_TRCFAILED (EVENTGROUP_MISC_PLACEHOLDER+2UL) /*0x92*/ | |
| #define PEND_FUNC_CALL_FROM_ISR_TRCFAILED (EVENTGROUP_MISC_PLACEHOLDER+3UL) /*0x93*/ | |
| #define MEM_MALLOC_SIZE (EVENTGROUP_MISC_PLACEHOLDER+4UL) /*0x94*/ | |
| #define MEM_MALLOC_ADDR (EVENTGROUP_MISC_PLACEHOLDER+5UL) /*0x95*/ | |
| #define MEM_FREE_SIZE (EVENTGROUP_MISC_PLACEHOLDER+6UL) /*0x96*/ | |
| #define MEM_FREE_ADDR (EVENTGROUP_MISC_PLACEHOLDER+7UL) /*0x97*/ | |
| /* User events */ | |
| #define EVENTGROUP_USEREVENT (EVENTGROUP_MISC_PLACEHOLDER + 8UL) /*0x98*/ | |
| #define USER_EVENT (EVENTGROUP_USEREVENT + 0UL) | |
| /* Allow for 0-15 arguments (the number of args is added to event code) */ | |
| #define USER_EVENT_LAST (EVENTGROUP_USEREVENT + 15UL) /*0xA7*/ | |
| /******************************************************************************* | |
| * XTS Event - eXtended TimeStamp events | |
| * The timestamps used in the recorder are "differential timestamps" (DTS), i.e. | |
| * the time since the last stored event. The DTS fields are either 1 or 2 bytes | |
| * in the other events, depending on the bytes available in the event struct. | |
| * If the time since the last event (the DTS) is larger than allowed for by | |
| * the DTS field of the current event, an XTS event is inserted immediately | |
| * before the original event. The XTS event contains up to 3 additional bytes | |
| * of the DTS value - the higher bytes of the true DTS value. The lower 1-2 | |
| * bytes are stored in the normal DTS field. | |
| * There are two types of XTS events, XTS8 and XTS16. An XTS8 event is stored | |
| * when there is only room for 1 byte (8 bit) DTS data in the original event, | |
| * which means a limit of 0xFF (255UL). The XTS16 is used when the original event | |
| * has a 16 bit DTS field and thereby can handle values up to 0xFFFF (65535UL). | |
| * | |
| * Using a very high frequency time base can result in many XTS events. | |
| * Preferably, the time between two OS ticks should fit in 16 bits, i.e., | |
| * at most 65535. If your time base has a higher frequency, you can define | |
| * the TRACE | |
| ******************************************************************************/ | |
| #define EVENTGROUP_SYS (EVENTGROUP_USEREVENT + 16UL) /*0xA8*/ | |
| #define XTS8 (EVENTGROUP_SYS + 0UL) /*0xA8*/ | |
| #define XTS16 (EVENTGROUP_SYS + 1UL) /*0xA9*/ | |
| #define EVENT_BEING_WRITTEN (EVENTGROUP_SYS + 2UL) /*0xAA*/ | |
| #define RESERVED_DUMMY_CODE (EVENTGROUP_SYS + 3UL) /*0xAB*/ | |
| #define LOW_POWER_BEGIN (EVENTGROUP_SYS + 4UL) /*0xAC*/ | |
| #define LOW_POWER_END (EVENTGROUP_SYS + 5UL) /*0xAD*/ | |
| #define XID (EVENTGROUP_SYS + 6UL) /*0xAE*/ | |
| #define XTS16L (EVENTGROUP_SYS + 7UL) /*0xAF*/ | |
| #define EVENTGROUP_TIMER (EVENTGROUP_SYS + 8UL) /*0xB0*/ | |
| #define TIMER_CREATE (EVENTGROUP_TIMER + 0UL) /*0xB0*/ | |
| #define TIMER_START (EVENTGROUP_TIMER + 1UL) /*0xB1*/ | |
| #define TIMER_RST (EVENTGROUP_TIMER + 2UL) /*0xB2*/ | |
| #define TIMER_STOP (EVENTGROUP_TIMER + 3UL) /*0xB3*/ | |
| #define TIMER_CHANGE_PERIOD (EVENTGROUP_TIMER + 4UL) /*0xB4*/ | |
| #define TIMER_DELETE_OBJ (EVENTGROUP_TIMER + 5UL) /*0xB5*/ | |
| #define TIMER_START_FROM_ISR (EVENTGROUP_TIMER + 6UL) /*0xB6*/ | |
| #define TIMER_RESET_FROM_ISR (EVENTGROUP_TIMER + 7UL) /*0xB7*/ | |
| #define TIMER_STOP_FROM_ISR (EVENTGROUP_TIMER + 8UL) /*0xB8*/ | |
| #define TIMER_CREATE_TRCFAILED (EVENTGROUP_TIMER + 9UL) /*0xB9*/ | |
| #define TIMER_START_TRCFAILED (EVENTGROUP_TIMER + 10UL) /*0xBA*/ | |
| #define TIMER_RESET_TRCFAILED (EVENTGROUP_TIMER + 11UL) /*0xBB*/ | |
| #define TIMER_STOP_TRCFAILED (EVENTGROUP_TIMER + 12UL) /*0xBC*/ | |
| #define TIMER_CHANGE_PERIOD_TRCFAILED (EVENTGROUP_TIMER + 13UL) /*0xBD*/ | |
| #define TIMER_DELETE_TRCFAILED (EVENTGROUP_TIMER + 14UL) /*0xBE*/ | |
| #define TIMER_START_FROM_ISR_TRCFAILED (EVENTGROUP_TIMER + 15UL) /*0xBF*/ | |
| #define TIMER_RESET_FROM_ISR_TRCFAILED (EVENTGROUP_TIMER + 16UL) /*0xC0*/ | |
| #define TIMER_STOP_FROM_ISR_TRCFAILED (EVENTGROUP_TIMER + 17UL) /*0xC1*/ | |
| #define EVENTGROUP_EG (EVENTGROUP_TIMER + 18UL) /*0xC2*/ | |
| #define EVENT_GROUP_CREATE (EVENTGROUP_EG + 0UL) /*0xC2*/ | |
| #define EVENT_GROUP_CREATE_TRCFAILED (EVENTGROUP_EG + 1UL) /*0xC3*/ | |
| #define EVENT_GROUP_SYNC_TRCBLOCK (EVENTGROUP_EG + 2UL) /*0xC4*/ | |
| #define EVENT_GROUP_SYNC_END (EVENTGROUP_EG + 3UL) /*0xC5*/ | |
| #define EVENT_GROUP_WAIT_BITS_TRCBLOCK (EVENTGROUP_EG + 4UL) /*0xC6*/ | |
| #define EVENT_GROUP_WAIT_BITS_END (EVENTGROUP_EG + 5UL) /*0xC7*/ | |
| #define EVENT_GROUP_CLEAR_BITS (EVENTGROUP_EG + 6UL) /*0xC8*/ | |
| #define EVENT_GROUP_CLEAR_BITS_FROM_ISR (EVENTGROUP_EG + 7UL) /*0xC9*/ | |
| #define EVENT_GROUP_SET_BITS (EVENTGROUP_EG + 8UL) /*0xCA*/ | |
| #define EVENT_GROUP_DELETE_OBJ (EVENTGROUP_EG + 9UL) /*0xCB*/ | |
| #define EVENT_GROUP_SYNC_END_TRCFAILED (EVENTGROUP_EG + 10UL) /*0xCC*/ | |
| #define EVENT_GROUP_WAIT_BITS_END_TRCFAILED (EVENTGROUP_EG + 11UL) /*0xCD*/ | |
| #define EVENT_GROUP_SET_BITS_FROM_ISR (EVENTGROUP_EG + 12UL) /*0xCE*/ | |
| #define EVENT_GROUP_SET_BITS_FROM_ISR_TRCFAILED (EVENTGROUP_EG + 13UL) /*0xCF*/ | |
| #define TASK_INSTANCE_FINISHED_NEXT_KSE (EVENTGROUP_EG + 14UL) /*0xD0*/ | |
| #define TASK_INSTANCE_FINISHED_DIRECT (EVENTGROUP_EG + 15UL) /*0xD1*/ | |
| #define TRACE_TASK_NOTIFY_GROUP (EVENTGROUP_EG + 16UL) /*0xD2*/ | |
| #define TRACE_TASK_NOTIFY (TRACE_TASK_NOTIFY_GROUP + 0UL) /*0xD2*/ | |
| #define TRACE_TASK_NOTIFY_TAKE (TRACE_TASK_NOTIFY_GROUP + 1UL) /*0xD3*/ | |
| #define TRACE_TASK_NOTIFY_TAKE_TRCBLOCK (TRACE_TASK_NOTIFY_GROUP + 2UL) /*0xD4*/ | |
| #define TRACE_TASK_NOTIFY_TAKE_TRCFAILED (TRACE_TASK_NOTIFY_GROUP + 3UL) /*0xD5*/ | |
| #define TRACE_TASK_NOTIFY_WAIT (TRACE_TASK_NOTIFY_GROUP + 4UL) /*0xD6*/ | |
| #define TRACE_TASK_NOTIFY_WAIT_TRCBLOCK (TRACE_TASK_NOTIFY_GROUP + 5UL) /*0xD7*/ | |
| #define TRACE_TASK_NOTIFY_WAIT_TRCFAILED (TRACE_TASK_NOTIFY_GROUP + 6UL) /*0xD8*/ | |
| #define TRACE_TASK_NOTIFY_FROM_ISR (TRACE_TASK_NOTIFY_GROUP + 7UL) /*0xD9*/ | |
| #define TRACE_TASK_NOTIFY_GIVE_FROM_ISR (TRACE_TASK_NOTIFY_GROUP + 8UL) /*0xDA*/ | |
| #define TIMER_EXPIRED (TRACE_TASK_NOTIFY_GROUP + 9UL) /* 0xDB */ | |
| /* Events on queue peek (receive) */ | |
| #define EVENTGROUP_PEEK_TRCBLOCK (TRACE_TASK_NOTIFY_GROUP + 10UL) /*0xDC*/ | |
| /* peek block on queue: 0xDC */ | |
| /* peek block on semaphore: 0xDD */ | |
| /* peek block on mutex: 0xDE */ | |
| /* Events on queue peek (receive) */ | |
| #define EVENTGROUP_PEEK_TRCFAILED (EVENTGROUP_PEEK_TRCBLOCK + 3UL) /*0xDF*/ | |
| /* peek failed on queue: 0xDF */ | |
| /* peek failed on semaphore: 0xE0 */ | |
| /* peek failed on mutex: 0xE1 */ | |
| #define EVENTGROUP_STREAMBUFFER_DIV (EVENTGROUP_PEEK_TRCFAILED + 3UL) /*0xE2*/ | |
| #define TRACE_STREAMBUFFER_RESET (EVENTGROUP_STREAMBUFFER_DIV + 0) /*0xE2*/ | |
| #define TRACE_MESSAGEBUFFER_RESET (EVENTGROUP_STREAMBUFFER_DIV + 1UL) /*0xE3*/ | |
| #define TRACE_STREAMBUFFER_OBJCLOSE_NAME_TRCSUCCESS (EVENTGROUP_STREAMBUFFER_DIV + 2UL) /*0xE4*/ | |
| #define TRACE_MESSAGEBUFFER_OBJCLOSE_NAME_TRCSUCCESS (EVENTGROUP_STREAMBUFFER_DIV + 3UL) /*0xE5*/ | |
| #define TRACE_STREAMBUFFER_OBJCLOSE_PROP_TRCSUCCESS (EVENTGROUP_STREAMBUFFER_DIV + 4UL) /*0xE6*/ | |
| #define TRACE_MESSAGEBUFFER_OBJCLOSE_PROP_TRCSUCCESS (EVENTGROUP_STREAMBUFFER_DIV + 5UL) /*0xE7*/ | |
| /* The following are using previously "lost" event codes */ | |
| #define TRACE_STREAMBUFFER_CREATE_OBJ_TRCSUCCESS (EVENTGROUP_CREATE_OBJ_TRCSUCCESS + 4UL) /*0x1C*/ | |
| #define TRACE_STREAMBUFFER_CREATE_OBJ_TRCFAILED (EVENTGROUP_CREATE_OBJ_TRCFAILED + 4UL) /*0x44*/ | |
| #define TRACE_STREAMBUFFER_DELETE_OBJ_TRCSUCCESS (EVENTGROUP_DELETE_OBJ_TRCSUCCESS + 4UL) /*0x84*/ | |
| #define TRACE_STREAMBUFFER_SEND_TRCSUCCESS (EVENTGROUP_SEND_TRCSUCCESS + 3UL) /*0x23*/ | |
| #define TRACE_STREAMBUFFER_SEND_TRCBLOCK (EVENTGROUP_SEND_TRCBLOCK + 3UL) /*0x73*/ | |
| #define TRACE_STREAMBUFFER_SEND_TRCFAILED (EVENTGROUP_SEND_TRCFAILED + 3UL) /*0x4B*/ | |
| #define TRACE_STREAMBUFFER_RECEIVE_TRCSUCCESS (EVENTGROUP_RECEIVE_TRCSUCCESS + 3UL) /*0x2B*/ | |
| #define TRACE_STREAMBUFFER_RECEIVE_TRCBLOCK (EVENTGROUP_RECEIVE_TRCBLOCK + 3UL) /*0x6B*/ | |
| #define TRACE_STREAMBUFFER_RECEIVE_TRCFAILED (EVENTGROUP_RECEIVE_TRCFAILED + 3UL) /*0x53*/ | |
| #define TRACE_STREAMBUFFER_SEND_FROM_ISR_TRCSUCCESS (EVENTGROUP_SEND_FROM_ISR_TRCSUCCESS + 3UL) /*0x33*/ | |
| #define TRACE_STREAMBUFFER_SEND_FROM_ISR_TRCFAILED (EVENTGROUP_SEND_FROM_ISR_TRCFAILED + 3UL) /*0x5B*/ | |
| #define TRACE_STREAMBUFFER_RECEIVE_FROM_ISR_TRCSUCCESS (EVENTGROUP_RECEIVE_FROM_ISR_TRCSUCCESS + 3UL) /*0x3B*/ | |
| #define TRACE_STREAMBUFFER_RECEIVE_FROM_ISR_TRCFAILED (EVENTGROUP_RECEIVE_FROM_ISR_TRCFAILED + 3UL) /*0x63*/ | |
| /* The following are using previously "lost" event codes. These macros aren't even directly referenced, instead we do (equivalent STREAMBUFFER code) + 1. */ | |
| #define TRACE_MESSAGEBUFFER_CREATE_OBJ_TRCSUCCESS (EVENTGROUP_CREATE_OBJ_TRCSUCCESS + 5UL) /*0x1D*/ | |
| #define TRACE_MESSAGEBUFFER_CREATE_OBJ_TRCFAILED (EVENTGROUP_CREATE_OBJ_TRCFAILED + 5UL) /*0x45*/ | |
| #define TRACE_MESSAGEBUFFER_DELETE_OBJ_TRCSUCCESS (EVENTGROUP_DELETE_OBJ_TRCSUCCESS + 5UL) /*0x85*/ | |
| #define TRACE_MESSAGEBUFFER_SEND_TRCSUCCESS (EVENTGROUP_SEND_TRCSUCCESS + 4UL) /*0x24*/ | |
| #define TRACE_MESSAGEBUFFER_SEND_TRCBLOCK (EVENTGROUP_SEND_TRCBLOCK + 4UL) /*0x74*/ | |
| #define TRACE_MESSAGEBUFFER_SEND_TRCFAILED (EVENTGROUP_SEND_TRCFAILED + 4UL) /*0x4C*/ | |
| #define TRACE_MESSAGEBUFFER_RECEIVE_TRCSUCCESS (EVENTGROUP_RECEIVE_TRCSUCCESS + 4UL) /*0x2C*/ | |
| #define TRACE_MESSAGEBUFFER_RECEIVE_TRCBLOCK (EVENTGROUP_RECEIVE_TRCBLOCK + 4UL) /*0x6C*/ | |
| #define TRACE_MESSAGEBUFFER_RECEIVE_TRCFAILED (EVENTGROUP_RECEIVE_TRCFAILED + 4UL) /*0x54*/ | |
| #define TRACE_MESSAGEBUFFER_SEND_FROM_ISR_TRCSUCCESS (EVENTGROUP_SEND_FROM_ISR_TRCSUCCESS + 4UL) /*0x34*/ | |
| #define TRACE_MESSAGEBUFFER_SEND_FROM_ISR_TRCFAILED (EVENTGROUP_SEND_FROM_ISR_TRCFAILED + 4UL) /*0x5C*/ | |
| #define TRACE_MESSAGEBUFFER_RECEIVE_FROM_ISR_TRCSUCCESS (EVENTGROUP_RECEIVE_FROM_ISR_TRCSUCCESS + 4UL) /*0x3C*/ | |
| #define TRACE_MESSAGEBUFFER_RECEIVE_FROM_ISR_TRCFAILED (EVENTGROUP_RECEIVE_FROM_ISR_TRCFAILED + 4UL) /*0x64*/ | |
| /* LAST EVENT (0xE7) */ | |
| /**************************** | |
| * MACROS TO GET TRACE CLASS * | |
| ****************************/ | |
| #define TRACE_GET_TRACE_CLASS_FROM_TASK_CLASS(kernelClass) (TRACE_CLASS_TASK) | |
| #define TRACE_GET_TRACE_CLASS_FROM_TASK_OBJECT(pxObject) (TRACE_CLASS_TASK) | |
| #define TRACE_GET_TRACE_CLASS_FROM_QUEUE_CLASS(kernelClass) TraceQueueClassTable[kernelClass] | |
| #define TRACE_GET_TRACE_CLASS_FROM_QUEUE_OBJECT(pxObject) TRACE_GET_TRACE_CLASS_FROM_QUEUE_CLASS(prvTraceGetQueueType(pxObject)) | |
| #define TRACE_GET_TRACE_CLASS_FROM_TIMER_CLASS(kernelClass) (TRACE_CLASS_TIMER) | |
| #define TRACE_GET_TRACE_CLASS_FROM_TIMER_OBJECT(pxObject) (TRACE_CLASS_TIMER) | |
| #define TRACE_GET_TRACE_CLASS_FROM_EVENTGROUP_CLASS(kernelClass) (TRACE_CLASS_EVENTGROUP) | |
| #define TRACE_GET_TRACE_CLASS_FROM_EVENTGROUP_OBJECT(pxObject) (TRACE_CLASS_EVENTGROUP) | |
| /* TRACE_GET_TRACE_CLASS_FROM_STREAMBUFFER_CLASS can only be accessed with a parameter indicating if it is a MessageBuffer */ | |
| #define TRACE_GET_TRACE_CLASS_FROM_STREAMBUFFER_CLASS(xIsMessageBuffer) (xIsMessageBuffer == 1 ? TRACE_CLASS_MESSAGEBUFFER : TRACE_CLASS_STREAMBUFFER) | |
| #define TRACE_GET_TRACE_CLASS_FROM_STREAMBUFFER_OBJECT(pxObject) (prvGetStreamBufferType(pxObject) == 1 ? TRACE_CLASS_MESSAGEBUFFER : TRACE_CLASS_STREAMBUFFER) | |
| /* Generic versions */ | |
| #define TRACE_GET_CLASS_TRACE_CLASS(CLASS, kernelClass) TRACE_GET_TRACE_CLASS_FROM_##CLASS##_CLASS(kernelClass) | |
| #define TRACE_GET_OBJECT_TRACE_CLASS(CLASS, pxObject) TRACE_GET_TRACE_CLASS_FROM_##CLASS##_OBJECT(pxObject) | |
| /****************************** | |
| * MACROS TO GET OBJECT NUMBER * | |
| ******************************/ | |
| #define TRACE_GET_TASK_NUMBER(pxTCB) (traceHandle)(prvTraceGetTaskNumberLow16(pxTCB)) | |
| #define TRACE_SET_TASK_NUMBER(pxTCB) prvTraceSetTaskNumberLow16(pxTCB, prvTraceGetObjectHandle(TRACE_GET_OBJECT_TRACE_CLASS(TASK, pxTCB))); | |
| #define TRACE_GET_QUEUE_NUMBER(queue) ( ( traceHandle ) prvTraceGetQueueNumberLow16(queue) ) | |
| #define TRACE_SET_QUEUE_NUMBER(queue) prvTraceSetQueueNumberLow16(queue, (uint16_t)prvTraceGetObjectHandle(TRACE_GET_OBJECT_TRACE_CLASS(QUEUE, queue))); | |
| #if (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_10_0_0) | |
| #define TRACE_GET_TIMER_NUMBER(tmr) ( ( traceHandle ) prvTraceGetTimerNumberLow16(tmr) ) | |
| #define TRACE_SET_TIMER_NUMBER(tmr) prvTraceSetTimerNumberLow16(tmr, (uint16_t)prvTraceGetObjectHandle(TRACE_GET_OBJECT_TRACE_CLASS(TIMER, tmr))); | |
| #else /* (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_10_0_0) */ | |
| #define TRACE_GET_TIMER_NUMBER(tmr) ( ( traceHandle ) ((Timer_t*)tmr)->uxTimerNumber ) | |
| #define TRACE_SET_TIMER_NUMBER(tmr) ((Timer_t*)tmr)->uxTimerNumber = prvTraceGetObjectHandle(TRACE_GET_OBJECT_TRACE_CLASS(TIMER, tmr)); | |
| #endif /* (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_10_0_0) */ | |
| #if (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_10_0_0) | |
| #define TRACE_GET_EVENTGROUP_NUMBER(eg) ( ( traceHandle ) prvTraceGetEventGroupNumberLow16(eg) ) | |
| #define TRACE_SET_EVENTGROUP_NUMBER(eg) prvTraceSetEventGroupNumberLow16(eg, (uint16_t)prvTraceGetObjectHandle(TRACE_GET_OBJECT_TRACE_CLASS(EVENTGROUP, eg))); | |
| #else /* (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_10_0_0) */ | |
| #define TRACE_GET_EVENTGROUP_NUMBER(eg) ( ( traceHandle ) uxEventGroupGetNumber(eg) ) | |
| #define TRACE_SET_EVENTGROUP_NUMBER(eg) ((EventGroup_t*)eg)->uxEventGroupNumber = prvTraceGetObjectHandle(TRACE_GET_OBJECT_TRACE_CLASS(EVENTGROUP, eg)); | |
| #endif /* (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_10_0_0) */ | |
| #define TRACE_GET_STREAMBUFFER_NUMBER(sb) ( ( traceHandle ) prvTraceGetStreamBufferNumberLow16(sb) ) | |
| #define TRACE_SET_STREAMBUFFER_NUMBER(sb) prvTraceSetStreamBufferNumberLow16(sb, (uint16_t)prvTraceGetObjectHandle(TRACE_GET_OBJECT_TRACE_CLASS(STREAMBUFFER, sb))); | |
| /* Generic versions */ | |
| #define TRACE_GET_OBJECT_NUMBER(CLASS, pxObject) TRACE_GET_##CLASS##_NUMBER(pxObject) | |
| #define TRACE_SET_OBJECT_NUMBER(CLASS, pxObject) TRACE_SET_##CLASS##_NUMBER(pxObject) | |
| /****************************** | |
| * MACROS TO GET EVENT CODES * | |
| ******************************/ | |
| #define TRACE_GET_TASK_CLASS_EVENT_CODE(SERVICE, RESULT, kernelClass) (uint8_t)(EVENTGROUP_##SERVICE##_##RESULT + TRACE_GET_CLASS_TRACE_CLASS(TASK, kernelClass)) | |
| #define TRACE_GET_QUEUE_CLASS_EVENT_CODE(SERVICE, RESULT, kernelClass) (uint8_t)(EVENTGROUP_##SERVICE##_##RESULT + TRACE_GET_CLASS_TRACE_CLASS(QUEUE, kernelClass)) | |
| #define TRACE_GET_TIMER_CLASS_EVENT_CODE(SERVICE, RESULT, kernelClass) -- THIS IS NOT USED -- | |
| #define TRACE_GET_EVENTGROUP_CLASS_EVENT_CODE(SERVICE, RESULT, kernelClass) -- THIS IS NOT USED -- | |
| #define TRACE_GET_STREAMBUFFER_CLASS_EVENT_CODE(SERVICE, RESULT, isMessageBuffer) (uint8_t)(TRACE_STREAMBUFFER_##SERVICE##_##RESULT + (uint8_t)isMessageBuffer) | |
| #define TRACE_GET_TASK_OBJECT_EVENT_CODE(SERVICE, RESULT, pxTCB) (uint8_t)(EVENTGROUP_##SERVICE##_##RESULT + TRACE_CLASS_TASK) | |
| #define TRACE_GET_QUEUE_OBJECT_EVENT_CODE(SERVICE, RESULT, pxObject) (uint8_t)(EVENTGROUP_##SERVICE##_##RESULT + TRACE_GET_OBJECT_TRACE_CLASS(QUEUE, pxObject)) | |
| #define TRACE_GET_TIMER_OBJECT_EVENT_CODE(SERVICE, RESULT, UNUSED) -- THIS IS NOT USED -- | |
| #define TRACE_GET_EVENTGROUP_OBJECT_EVENT_CODE(SERVICE, RESULT, UNUSED) -- THIS IS NOT USED -- | |
| #define TRACE_GET_STREAMBUFFER_OBJECT_EVENT_CODE(SERVICE, RESULT, pxObject) (uint8_t)(TRACE_STREAMBUFFER_##SERVICE##_##RESULT + prvGetStreamBufferType(pxObject)) | |
| /* Generic versions */ | |
| #define TRACE_GET_CLASS_EVENT_CODE(SERVICE, RESULT, CLASS, kernelClass) TRACE_GET_##CLASS##_CLASS_EVENT_CODE(SERVICE, RESULT, kernelClass) | |
| #define TRACE_GET_OBJECT_EVENT_CODE(SERVICE, RESULT, CLASS, pxObject) TRACE_GET_##CLASS##_OBJECT_EVENT_CODE(SERVICE, RESULT, pxObject) | |
| /****************************** | |
| * SPECIAL MACROS FOR TASKS * | |
| ******************************/ | |
| #define TRACE_GET_TASK_PRIORITY(pxTCB) ((uint8_t)pxTCB->uxPriority) | |
| #define TRACE_GET_TASK_NAME(pxTCB) ((char*)pxTCB->pcTaskName) | |
| /*** The trace macros for snapshot mode **************************************/ | |
| /* A macro that will update the tick count when returning from tickless idle */ | |
| #undef traceINCREASE_TICK_COUNT | |
| #define traceINCREASE_TICK_COUNT( xCount ) | |
| /* Called for each task that becomes ready */ | |
| #undef traceMOVED_TASK_TO_READY_STATE | |
| #define traceMOVED_TASK_TO_READY_STATE( pxTCB ) \ | |
| trcKERNEL_HOOKS_MOVED_TASK_TO_READY_STATE(pxTCB); | |
| /* 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_FREERTOS_VERSION <= TRC_FREERTOS_VERSION_7_4) | |
| #define traceTASK_INCREMENT_TICK( xTickCount ) \ | |
| if (uxSchedulerSuspended == ( unsigned portBASE_TYPE ) pdTRUE || uxMissedTicks == 0) { trcKERNEL_HOOKS_INCREMENT_TICK(); } \ | |
| if (uxSchedulerSuspended == ( unsigned portBASE_TYPE ) pdFALSE) { trcKERNEL_HOOKS_NEW_TIME(DIV_NEW_TIME, xTickCount + 1); } | |
| #else | |
| #define traceTASK_INCREMENT_TICK( xTickCount ) \ | |
| if (uxSchedulerSuspended == ( unsigned portBASE_TYPE ) pdTRUE || xPendedTicks == 0) { trcKERNEL_HOOKS_INCREMENT_TICK(); } \ | |
| if (uxSchedulerSuspended == ( unsigned portBASE_TYPE ) pdFALSE) { trcKERNEL_HOOKS_NEW_TIME(DIV_NEW_TIME, xTickCount + 1); } | |
| #endif | |
| /* Called on each task-switch */ | |
| #undef traceTASK_SWITCHED_IN | |
| #define traceTASK_SWITCHED_IN() \ | |
| trcKERNEL_HOOKS_TASK_SWITCH(TRACE_GET_CURRENT_TASK()); | |
| /* Called on vTaskCreate */ | |
| #undef traceTASK_CREATE | |
| #define traceTASK_CREATE(pxNewTCB) \ | |
| if (pxNewTCB != NULL) \ | |
| { \ | |
| trcKERNEL_HOOKS_TASK_CREATE(TRACE_GET_OBJECT_EVENT_CODE(CREATE_OBJ, TRCSUCCESS, TASK, pxNewTCB), TASK, pxNewTCB); \ | |
| } | |
| /* Called in vTaskCreate, if it fails (typically if the stack can not be allocated) */ | |
| #undef traceTASK_CREATE_FAILED | |
| #define traceTASK_CREATE_FAILED() \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_NUMERIC_PARAM_ONLY(TRACE_GET_CLASS_EVENT_CODE(CREATE_OBJ, TRCFAILED, TASK, NOT_USED), 0); | |
| /* Called on vTaskDelete */ | |
| #undef traceTASK_DELETE | |
| #define traceTASK_DELETE( pxTaskToDelete ) \ | |
| { TRACE_ALLOC_CRITICAL_SECTION(); \ | |
| TRACE_ENTER_CRITICAL_SECTION(); \ | |
| trcKERNEL_HOOKS_TASK_DELETE(TRACE_GET_OBJECT_EVENT_CODE(DELETE_OBJ, TRCSUCCESS, TASK, pxTaskToDelete), TRACE_GET_OBJECT_EVENT_CODE(OBJCLOSE_NAME, TRCSUCCESS, TASK, pxTaskToDelete), TRACE_GET_OBJECT_EVENT_CODE(OBJCLOSE_PROP, TRCSUCCESS, TASK, pxTaskToDelete), pxTaskToDelete); \ | |
| TRACE_EXIT_CRITICAL_SECTION(); } | |
| #if (TRC_CFG_SCHEDULING_ONLY == 0) | |
| #if defined(configUSE_TICKLESS_IDLE) | |
| #if (configUSE_TICKLESS_IDLE != 0) | |
| #undef traceLOW_POWER_IDLE_BEGIN | |
| #define traceLOW_POWER_IDLE_BEGIN() \ | |
| { \ | |
| extern uint32_t trace_disable_timestamp; \ | |
| prvTraceStoreLowPower(0); \ | |
| trace_disable_timestamp = 1; \ | |
| } | |
| #undef traceLOW_POWER_IDLE_END | |
| #define traceLOW_POWER_IDLE_END() \ | |
| { \ | |
| extern uint32_t trace_disable_timestamp; \ | |
| trace_disable_timestamp = 0; \ | |
| prvTraceStoreLowPower(1); \ | |
| } | |
| #endif /* (configUSE_TICKLESS_IDLE != 0) */ | |
| #endif /* defined(configUSE_TICKLESS_IDLE) */ | |
| /* Called on vTaskSuspend */ | |
| #undef traceTASK_SUSPEND | |
| #define traceTASK_SUSPEND( pxTaskToSuspend ) \ | |
| trcKERNEL_HOOKS_TASK_SUSPEND(TASK_SUSPEND, pxTaskToSuspend); | |
| /* Called from special case with timer only */ | |
| #undef traceTASK_DELAY_SUSPEND | |
| #define traceTASK_DELAY_SUSPEND( pxTaskToSuspend ) \ | |
| trcKERNEL_HOOKS_TASK_SUSPEND(TASK_SUSPEND, pxTaskToSuspend); \ | |
| trcKERNEL_HOOKS_SET_TASK_INSTANCE_FINISHED(); | |
| /* Called on vTaskDelay - note the use of FreeRTOS variable xTicksToDelay */ | |
| #undef traceTASK_DELAY | |
| #define traceTASK_DELAY() \ | |
| trcKERNEL_HOOKS_TASK_DELAY(TASK_DELAY, pxCurrentTCB, xTicksToDelay); \ | |
| trcKERNEL_HOOKS_SET_TASK_INSTANCE_FINISHED(); | |
| /* Called on vTaskDelayUntil - note the use of FreeRTOS variable xTimeToWake */ | |
| #undef traceTASK_DELAY_UNTIL | |
| #if TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_9_0_0 | |
| #define traceTASK_DELAY_UNTIL(xTimeToWake) \ | |
| trcKERNEL_HOOKS_TASK_DELAY(TASK_DELAY_UNTIL, pxCurrentTCB, xTimeToWake); \ | |
| trcKERNEL_HOOKS_SET_TASK_INSTANCE_FINISHED(); | |
| #else /* TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_9_0_0 */ | |
| #define traceTASK_DELAY_UNTIL() \ | |
| trcKERNEL_HOOKS_TASK_DELAY(TASK_DELAY_UNTIL, pxCurrentTCB, xTimeToWake); \ | |
| trcKERNEL_HOOKS_SET_TASK_INSTANCE_FINISHED(); | |
| #endif /* TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_9_0_0 */ | |
| /* Called in xQueueCreate, and thereby for all other object based on queues, such as semaphores. */ | |
| #undef traceQUEUE_CREATE | |
| #define traceQUEUE_CREATE( pxNewQueue ) \ | |
| trcKERNEL_HOOKS_OBJECT_CREATE(TRACE_GET_OBJECT_EVENT_CODE(CREATE_OBJ, TRCSUCCESS, QUEUE, pxNewQueue), QUEUE, pxNewQueue); | |
| /* Called in xQueueCreate, if the queue creation fails */ | |
| #undef traceQUEUE_CREATE_FAILED | |
| #define traceQUEUE_CREATE_FAILED( queueType ) \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_NUMERIC_PARAM_ONLY(TRACE_GET_CLASS_EVENT_CODE(CREATE_OBJ, TRCFAILED, QUEUE, queueType), 0); | |
| /* Called on vQueueDelete */ | |
| #undef traceQUEUE_DELETE | |
| #define traceQUEUE_DELETE( pxQueue ) \ | |
| { TRACE_ALLOC_CRITICAL_SECTION(); \ | |
| TRACE_ENTER_CRITICAL_SECTION(); \ | |
| trcKERNEL_HOOKS_OBJECT_DELETE(TRACE_GET_OBJECT_EVENT_CODE(DELETE_OBJ, TRCSUCCESS, QUEUE, pxQueue), TRACE_GET_OBJECT_EVENT_CODE(OBJCLOSE_NAME, TRCSUCCESS, QUEUE, pxQueue), TRACE_GET_OBJECT_EVENT_CODE(OBJCLOSE_PROP, TRCSUCCESS, QUEUE, pxQueue), QUEUE, pxQueue); \ | |
| TRACE_EXIT_CRITICAL_SECTION(); } | |
| /* This macro is not necessary as of FreeRTOS v9.0.0 */ | |
| #if (TRC_CFG_FREERTOS_VERSION < TRC_FREERTOS_VERSION_9_0_0) | |
| /* Called in xQueueCreateMutex, and thereby also from xSemaphoreCreateMutex and xSemaphoreCreateRecursiveMutex */ | |
| #undef traceCREATE_MUTEX | |
| #define traceCREATE_MUTEX( pxNewQueue ) \ | |
| trcKERNEL_HOOKS_OBJECT_CREATE(TRACE_GET_OBJECT_EVENT_CODE(CREATE_OBJ, TRCSUCCESS, QUEUE, pxNewQueue), QUEUE, pxNewQueue); | |
| /* Called in xQueueCreateMutex when the operation fails (when memory allocation fails) */ | |
| #undef traceCREATE_MUTEX_FAILED | |
| #define traceCREATE_MUTEX_FAILED() \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_NUMERIC_PARAM_ONLY(TRACE_GET_CLASS_EVENT_CODE(CREATE_OBJ, TRCFAILED, QUEUE, queueQUEUE_TYPE_MUTEX), 0); | |
| #endif /* (TRC_CFG_FREERTOS_VERSION < TRC_FREERTOS_VERSION_9_0_0) */ | |
| /* Called when the Mutex can not be given, since not holder */ | |
| #undef traceGIVE_MUTEX_RECURSIVE_FAILED | |
| #define traceGIVE_MUTEX_RECURSIVE_FAILED( pxMutex ) \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE(TRACE_GET_OBJECT_EVENT_CODE(SEND, TRCFAILED, QUEUE, pxMutex), QUEUE, pxMutex); | |
| /* Called when a message is sent to a queue */ /* CS IS NEW ! */ | |
| #undef traceQUEUE_SEND | |
| #define traceQUEUE_SEND( pxQueue ) \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE(TRACE_GET_OBJECT_EVENT_CODE(SEND, TRCSUCCESS, QUEUE, pxQueue), QUEUE, pxQueue); \ | |
| trcKERNEL_HOOKS_SET_OBJECT_STATE(QUEUE, pxQueue, TRACE_GET_OBJECT_TRACE_CLASS(QUEUE, pxQueue) == TRACE_CLASS_MUTEX ? (uint8_t)0 : (uint8_t)(pxQueue->uxMessagesWaiting + 1)); | |
| /* Called when a message failed to be sent to a queue (timeout) */ | |
| #undef traceQUEUE_SEND_FAILED | |
| #define traceQUEUE_SEND_FAILED( pxQueue ) \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE(TRACE_GET_OBJECT_EVENT_CODE(SEND, TRCFAILED, QUEUE, pxQueue), QUEUE, pxQueue); | |
| /* 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 ) \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE(TRACE_GET_OBJECT_EVENT_CODE(SEND, TRCBLOCK, QUEUE, pxQueue), QUEUE, pxQueue); | |
| /* Called when a message is received from a queue */ | |
| #undef traceQUEUE_RECEIVE | |
| #define traceQUEUE_RECEIVE( pxQueue ) \ | |
| if (isQueueReceiveHookActuallyPeek) \ | |
| { \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE(TRACE_GET_OBJECT_EVENT_CODE(PEEK, TRCSUCCESS, QUEUE, pxQueue), QUEUE, pxQueue); \ | |
| } \ | |
| else \ | |
| { \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE(TRACE_GET_OBJECT_EVENT_CODE(RECEIVE, TRCSUCCESS, QUEUE, pxQueue), QUEUE, pxQueue); \ | |
| } \ | |
| trcKERNEL_HOOKS_SET_OBJECT_STATE(QUEUE, pxQueue, TRACE_GET_OBJECT_TRACE_CLASS(QUEUE, pxQueue) == TRACE_CLASS_MUTEX ? (uint8_t)TRACE_GET_TASK_NUMBER(TRACE_GET_CURRENT_TASK()) : (uint8_t)(pxQueue->uxMessagesWaiting - 1)); | |
| /* Called when a receive operation on a queue fails (timeout) */ | |
| #undef traceQUEUE_RECEIVE_FAILED | |
| #define traceQUEUE_RECEIVE_FAILED( pxQueue ) \ | |
| if (isQueueReceiveHookActuallyPeek) \ | |
| { \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE(TRACE_GET_OBJECT_EVENT_CODE(PEEK, TRCFAILED, QUEUE, pxQueue), QUEUE, pxQueue); \ | |
| } \ | |
| else \ | |
| { \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE(TRACE_GET_OBJECT_EVENT_CODE(RECEIVE, TRCFAILED, QUEUE, pxQueue), QUEUE, pxQueue); \ | |
| } | |
| /* 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 ) \ | |
| if (isQueueReceiveHookActuallyPeek) \ | |
| { \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE(TRACE_GET_OBJECT_EVENT_CODE(PEEK, TRCBLOCK, QUEUE, pxQueue), QUEUE, pxQueue); \ | |
| } \ | |
| else \ | |
| { \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE(TRACE_GET_OBJECT_EVENT_CODE(RECEIVE, TRCBLOCK, QUEUE, pxQueue), QUEUE, pxQueue); \ | |
| } \ | |
| if (TRACE_GET_OBJECT_TRACE_CLASS(QUEUE, pxQueue) != TRACE_CLASS_MUTEX) \ | |
| { \ | |
| trcKERNEL_HOOKS_SET_TASK_INSTANCE_FINISHED(); \ | |
| } | |
| /* Called on xQueuePeek */ | |
| #undef traceQUEUE_PEEK | |
| #define traceQUEUE_PEEK( pxQueue ) \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE(TRACE_GET_OBJECT_EVENT_CODE(PEEK, TRCSUCCESS, QUEUE, pxQueue), QUEUE, pxQueue); | |
| /* Called on xQueuePeek fail/timeout (added in FreeRTOS v9.0.2) */ | |
| #undef traceQUEUE_PEEK_FAILED | |
| #define traceQUEUE_PEEK_FAILED( pxQueue ) \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE(TRACE_GET_OBJECT_EVENT_CODE(PEEK, TRCFAILED, QUEUE, pxQueue), QUEUE, pxQueue); | |
| /* Called on xQueuePeek blocking (added in FreeRTOS v9.0.2) */ | |
| #undef traceBLOCKING_ON_QUEUE_PEEK | |
| #define traceBLOCKING_ON_QUEUE_PEEK( pxQueue ) \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE(TRACE_GET_OBJECT_EVENT_CODE(PEEK, TRCBLOCK, QUEUE, pxQueue), QUEUE, pxQueue); \ | |
| if (TRACE_GET_OBJECT_TRACE_CLASS(QUEUE, pxQueue) != TRACE_CLASS_MUTEX) \ | |
| { \ | |
| trcKERNEL_HOOKS_SET_TASK_INSTANCE_FINISHED(); \ | |
| } | |
| /* Called when a message is sent from interrupt context, e.g., using xQueueSendFromISR */ | |
| #undef traceQUEUE_SEND_FROM_ISR | |
| #define traceQUEUE_SEND_FROM_ISR( pxQueue ) \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE_FROM_ISR(TRACE_GET_OBJECT_EVENT_CODE(SEND_FROM_ISR, TRCSUCCESS, QUEUE, pxQueue), QUEUE, pxQueue); \ | |
| trcKERNEL_HOOKS_SET_OBJECT_STATE(QUEUE, pxQueue, (uint8_t)(pxQueue->uxMessagesWaiting + 1)); | |
| /* 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 ) \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE_FROM_ISR(TRACE_GET_OBJECT_EVENT_CODE(SEND_FROM_ISR, TRCFAILED, QUEUE, pxQueue), QUEUE, pxQueue); | |
| /* Called when a message is received in interrupt context, e.g., using xQueueReceiveFromISR */ | |
| #undef traceQUEUE_RECEIVE_FROM_ISR | |
| #define traceQUEUE_RECEIVE_FROM_ISR( pxQueue ) \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE_FROM_ISR(TRACE_GET_OBJECT_EVENT_CODE(RECEIVE_FROM_ISR, TRCSUCCESS, QUEUE, pxQueue), QUEUE, pxQueue); \ | |
| trcKERNEL_HOOKS_SET_OBJECT_STATE(QUEUE, pxQueue, (uint8_t)(pxQueue->uxMessagesWaiting - 1)); | |
| /* 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 ) \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE_FROM_ISR(TRACE_GET_OBJECT_EVENT_CODE(RECEIVE_FROM_ISR, TRCFAILED, QUEUE, pxQueue), QUEUE, pxQueue); | |
| #undef traceQUEUE_REGISTRY_ADD | |
| #define traceQUEUE_REGISTRY_ADD(object, name) prvTraceSetObjectName(TRACE_GET_OBJECT_TRACE_CLASS(QUEUE, object), TRACE_GET_OBJECT_NUMBER(QUEUE, object), name); | |
| /* Called in vTaskPrioritySet */ | |
| #undef traceTASK_PRIORITY_SET | |
| #define traceTASK_PRIORITY_SET( pxTask, uxNewPriority ) \ | |
| trcKERNEL_HOOKS_TASK_PRIORITY_CHANGE(TASK_PRIORITY_SET, pxTask, uxNewPriority); | |
| /* Called in vTaskPriorityInherit, which is called by Mutex operations */ | |
| #undef traceTASK_PRIORITY_INHERIT | |
| #define traceTASK_PRIORITY_INHERIT( pxTask, uxNewPriority ) \ | |
| trcKERNEL_HOOKS_TASK_PRIORITY_CHANGE(TASK_PRIORITY_INHERIT, pxTask, uxNewPriority); | |
| /* Called in vTaskPriorityDisinherit, which is called by Mutex operations */ | |
| #undef traceTASK_PRIORITY_DISINHERIT | |
| #define traceTASK_PRIORITY_DISINHERIT( pxTask, uxNewPriority ) \ | |
| trcKERNEL_HOOKS_TASK_PRIORITY_CHANGE(TASK_PRIORITY_DISINHERIT, pxTask, uxNewPriority); | |
| /* Called in vTaskResume */ | |
| #undef traceTASK_RESUME | |
| #define traceTASK_RESUME( pxTaskToResume ) \ | |
| trcKERNEL_HOOKS_TASK_RESUME(TASK_RESUME, pxTaskToResume); | |
| /* Called in vTaskResumeFromISR */ | |
| #undef traceTASK_RESUME_FROM_ISR | |
| #define traceTASK_RESUME_FROM_ISR( pxTaskToResume ) \ | |
| trcKERNEL_HOOKS_TASK_RESUME_FROM_ISR(TASK_RESUME_FROM_ISR, pxTaskToResume); | |
| #if (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_8_X) | |
| #if (TRC_CFG_INCLUDE_MEMMANG_EVENTS == 1) | |
| extern void vTraceStoreMemMangEvent(uint32_t ecode, uint32_t address, int32_t size); | |
| /* MALLOC and FREE are always stored, no matter if they happen inside filtered task */ | |
| #undef traceMALLOC | |
| #define traceMALLOC( pvAddress, uiSize ) \ | |
| if (pvAddress != 0) \ | |
| vTraceStoreMemMangEvent(MEM_MALLOC_SIZE, ( uint32_t ) pvAddress, (int32_t)uiSize); | |
| #undef traceFREE | |
| #define traceFREE( pvAddress, uiSize ) \ | |
| vTraceStoreMemMangEvent(MEM_FREE_SIZE, ( uint32_t ) pvAddress, -((int32_t)uiSize)); | |
| #endif /* (TRC_CFG_INCLUDE_MEMMANG_EVENTS == 1) */ | |
| #if (TRC_CFG_INCLUDE_TIMER_EVENTS == 1) | |
| /* Called in timer.c - xTimerCreate */ | |
| #undef traceTIMER_CREATE | |
| #define traceTIMER_CREATE(tmr) \ | |
| trcKERNEL_HOOKS_OBJECT_CREATE(TIMER_CREATE, TIMER, tmr); | |
| #undef traceTIMER_CREATE_FAILED | |
| #define traceTIMER_CREATE_FAILED() \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_NUMERIC_PARAM_ONLY(TIMER_CREATE_TRCFAILED, 0); | |
| /* 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) \ | |
| if (xCommandID > tmrCOMMAND_START_DONT_TRACE) \ | |
| { \ | |
| if (xCommandID == tmrCOMMAND_CHANGE_PERIOD) \ | |
| { \ | |
| if (xReturn == pdPASS) { \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_PARAM(TIMER_CHANGE_PERIOD, TIMER, tmr, xOptionalValue); \ | |
| } \ | |
| else \ | |
| { \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_PARAM(TIMER_CHANGE_PERIOD_TRCFAILED, TIMER, tmr, xOptionalValue); \ | |
| } \ | |
| } \ | |
| else if ((xCommandID == tmrCOMMAND_DELETE) && (xReturn == pdPASS)) \ | |
| { \ | |
| trcKERNEL_HOOKS_OBJECT_DELETE(TIMER_DELETE_OBJ, EVENTGROUP_OBJCLOSE_NAME_TRCSUCCESS + TRACE_GET_OBJECT_TRACE_CLASS(TIMER, tmr), EVENTGROUP_OBJCLOSE_PROP_TRCSUCCESS + TRACE_GET_OBJECT_TRACE_CLASS(TIMER, tmr), TIMER, tmr); \ | |
| } \ | |
| else \ | |
| { \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_PARAM(EVENTGROUP_TIMER + (uint32_t)xCommandID + ((xReturn == pdPASS) ? 0 : (TIMER_CREATE_TRCFAILED - TIMER_CREATE)), TIMER, tmr, xOptionalValue); \ | |
| }\ | |
| } | |
| #undef traceTIMER_EXPIRED | |
| #define traceTIMER_EXPIRED(tmr) \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE(TIMER_EXPIRED, TIMER, tmr); | |
| #endif /* (TRC_CFG_INCLUDE_TIMER_EVENTS == 1) */ | |
| #if (TRC_CFG_INCLUDE_PEND_FUNC_CALL_EVENTS == 1) | |
| #undef tracePEND_FUNC_CALL | |
| #define tracePEND_FUNC_CALL(func, arg1, arg2, ret) \ | |
| if (ret == pdPASS){ \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE(PEND_FUNC_CALL, TASK, xTimerGetTimerDaemonTaskHandle() ); \ | |
| } \ | |
| else \ | |
| { \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE(PEND_FUNC_CALL_TRCFAILED, TASK, xTimerGetTimerDaemonTaskHandle() ); \ | |
| } | |
| #undef tracePEND_FUNC_CALL_FROM_ISR | |
| #define tracePEND_FUNC_CALL_FROM_ISR(func, arg1, arg2, ret) \ | |
| if (! uiInEventGroupSetBitsFromISR) \ | |
| prvTraceStoreKernelCall(PEND_FUNC_CALL_FROM_ISR, TRACE_CLASS_TASK, TRACE_GET_TASK_NUMBER(xTimerGetTimerDaemonTaskHandle()) ); \ | |
| uiInEventGroupSetBitsFromISR = 0; | |
| #endif /* (TRC_CFG_INCLUDE_PEND_FUNC_CALL_EVENTS == 1) */ | |
| #endif /* (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_8_X) */ | |
| #if (TRC_CFG_INCLUDE_EVENT_GROUP_EVENTS == 1) | |
| #undef traceEVENT_GROUP_CREATE | |
| #define traceEVENT_GROUP_CREATE(eg) \ | |
| trcKERNEL_HOOKS_OBJECT_CREATE(EVENT_GROUP_CREATE, EVENTGROUP, eg); | |
| #undef traceEVENT_GROUP_CREATE_FAILED | |
| #define traceEVENT_GROUP_CREATE_FAILED() \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_NUMERIC_PARAM_ONLY(EVENT_GROUP_CREATE_TRCFAILED, 0); | |
| #undef traceEVENT_GROUP_DELETE | |
| #define traceEVENT_GROUP_DELETE(eg) \ | |
| { TRACE_ALLOC_CRITICAL_SECTION(); \ | |
| TRACE_ENTER_CRITICAL_SECTION(); \ | |
| trcKERNEL_HOOKS_OBJECT_DELETE(EVENT_GROUP_DELETE_OBJ, EVENTGROUP_OBJCLOSE_NAME_TRCSUCCESS + TRACE_GET_OBJECT_TRACE_CLASS(EVENTGROUP, eg), EVENTGROUP_OBJCLOSE_NAME_TRCSUCCESS + TRACE_GET_OBJECT_TRACE_CLASS(EVENTGROUP, eg), EVENTGROUP, eg); \ | |
| TRACE_EXIT_CRITICAL_SECTION(); } | |
| #undef traceEVENT_GROUP_SYNC_BLOCK | |
| #define traceEVENT_GROUP_SYNC_BLOCK(eg, bitsToSet, bitsToWaitFor) \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_PARAM(EVENT_GROUP_SYNC_TRCBLOCK, EVENTGROUP, eg, bitsToWaitFor); | |
| #undef traceEVENT_GROUP_SYNC_END | |
| #define traceEVENT_GROUP_SYNC_END(eg, bitsToSet, bitsToWaitFor, wasTimeout) \ | |
| if (wasTimeout) \ | |
| { \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_PARAM(EVENT_GROUP_SYNC_END_TRCFAILED, EVENTGROUP, eg, bitsToWaitFor); \ | |
| } \ | |
| else \ | |
| { \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_PARAM(EVENT_GROUP_SYNC_END, EVENTGROUP, eg, bitsToWaitFor); \ | |
| } | |
| #undef traceEVENT_GROUP_WAIT_BITS_BLOCK | |
| #define traceEVENT_GROUP_WAIT_BITS_BLOCK(eg, bitsToWaitFor) \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_PARAM(EVENT_GROUP_WAIT_BITS_TRCBLOCK, EVENTGROUP, eg, bitsToWaitFor); \ | |
| trcKERNEL_HOOKS_SET_TASK_INSTANCE_FINISHED(); | |
| #undef traceEVENT_GROUP_WAIT_BITS_END | |
| #define traceEVENT_GROUP_WAIT_BITS_END(eg, bitsToWaitFor, wasTimeout) \ | |
| if (wasTimeout) \ | |
| { \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_PARAM(EVENT_GROUP_WAIT_BITS_END_TRCFAILED, EVENTGROUP, eg, bitsToWaitFor); \ | |
| } \ | |
| else \ | |
| { \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_PARAM(EVENT_GROUP_WAIT_BITS_END, EVENTGROUP, eg, bitsToWaitFor); \ | |
| } | |
| #undef traceEVENT_GROUP_CLEAR_BITS | |
| #define traceEVENT_GROUP_CLEAR_BITS(eg, bitsToClear) \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_PARAM(EVENT_GROUP_CLEAR_BITS, EVENTGROUP, eg, bitsToClear); | |
| #undef traceEVENT_GROUP_CLEAR_BITS_FROM_ISR | |
| #define traceEVENT_GROUP_CLEAR_BITS_FROM_ISR(eg, bitsToClear) \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_PARAM_FROM_ISR(EVENT_GROUP_CLEAR_BITS_FROM_ISR, EVENTGROUP, eg, bitsToClear); | |
| #undef traceEVENT_GROUP_SET_BITS | |
| #define traceEVENT_GROUP_SET_BITS(eg, bitsToSet) \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_PARAM(EVENT_GROUP_SET_BITS, EVENTGROUP, eg, bitsToSet); | |
| #undef traceEVENT_GROUP_SET_BITS_FROM_ISR | |
| #define traceEVENT_GROUP_SET_BITS_FROM_ISR(eg, bitsToSet) \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_PARAM_FROM_ISR(EVENT_GROUP_SET_BITS_FROM_ISR, EVENTGROUP, eg, bitsToSet); \ | |
| uiInEventGroupSetBitsFromISR = 1; | |
| #endif /* (TRC_CFG_INCLUDE_EVENT_GROUP_EVENTS == 1) */ | |
| #undef traceTASK_NOTIFY_TAKE | |
| #if (TRC_CFG_FREERTOS_VERSION < TRC_FREERTOS_VERSION_9_0_0) | |
| #define traceTASK_NOTIFY_TAKE() \ | |
| if (pxCurrentTCB->eNotifyState == eNotified){ \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_PARAM(TRACE_TASK_NOTIFY_TAKE, TASK, pxCurrentTCB, xTicksToWait); \ | |
| } \ | |
| else{ \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_PARAM(TRACE_TASK_NOTIFY_TAKE_TRCFAILED, TASK, pxCurrentTCB, xTicksToWait); \ | |
| } | |
| #else /* TRC_CFG_FREERTOS_VERSION < TRC_FREERTOS_VERSION_9_0_0 */ | |
| #define traceTASK_NOTIFY_TAKE() \ | |
| if (pxCurrentTCB->ucNotifyState == taskNOTIFICATION_RECEIVED){ \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_PARAM(TRACE_TASK_NOTIFY_TAKE, TASK, pxCurrentTCB, xTicksToWait); \ | |
| }else{ \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_PARAM(TRACE_TASK_NOTIFY_TAKE_TRCFAILED, TASK, pxCurrentTCB, xTicksToWait);} | |
| #endif /* TRC_CFG_FREERTOS_VERSION < TRC_FREERTOS_VERSION_9_0_0 */ | |
| #undef traceTASK_NOTIFY_TAKE_BLOCK | |
| #define traceTASK_NOTIFY_TAKE_BLOCK() \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_PARAM(TRACE_TASK_NOTIFY_TAKE_TRCBLOCK, TASK, pxCurrentTCB, xTicksToWait); \ | |
| trcKERNEL_HOOKS_SET_TASK_INSTANCE_FINISHED(); | |
| #undef traceTASK_NOTIFY_WAIT | |
| #if (TRC_CFG_FREERTOS_VERSION < TRC_FREERTOS_VERSION_9_0_0) | |
| #define traceTASK_NOTIFY_WAIT() \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, pxCurrentTCB) & CurrentFilterMask) \ | |
| { \ | |
| if (pxCurrentTCB->eNotifyState == eNotified) \ | |
| prvTraceStoreKernelCallWithParam(TRACE_TASK_NOTIFY_WAIT, TRACE_CLASS_TASK, TRACE_GET_TASK_NUMBER(pxCurrentTCB), xTicksToWait); \ | |
| else \ | |
| prvTraceStoreKernelCallWithParam(TRACE_TASK_NOTIFY_WAIT_TRCFAILED, TRACE_CLASS_TASK, TRACE_GET_TASK_NUMBER(pxCurrentTCB), xTicksToWait); \ | |
| } | |
| #else /* TRC_CFG_FREERTOS_VERSION < TRC_FREERTOS_VERSION_9_0_0 */ | |
| #define traceTASK_NOTIFY_WAIT() \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, pxCurrentTCB) & CurrentFilterMask) \ | |
| { \ | |
| if (pxCurrentTCB->ucNotifyState == taskNOTIFICATION_RECEIVED) \ | |
| prvTraceStoreKernelCallWithParam(TRACE_TASK_NOTIFY_WAIT, TRACE_CLASS_TASK, TRACE_GET_TASK_NUMBER(pxCurrentTCB), xTicksToWait); \ | |
| else \ | |
| prvTraceStoreKernelCallWithParam(TRACE_TASK_NOTIFY_WAIT_TRCFAILED, TRACE_CLASS_TASK, TRACE_GET_TASK_NUMBER(pxCurrentTCB), xTicksToWait); \ | |
| } | |
| #endif /* TRC_CFG_FREERTOS_VERSION < TRC_FREERTOS_VERSION_9_0_0 */ | |
| #undef traceTASK_NOTIFY_WAIT_BLOCK | |
| #define traceTASK_NOTIFY_WAIT_BLOCK() \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, pxCurrentTCB) & CurrentFilterMask) \ | |
| prvTraceStoreKernelCallWithParam(TRACE_TASK_NOTIFY_WAIT_TRCBLOCK, TRACE_CLASS_TASK, TRACE_GET_TASK_NUMBER(pxCurrentTCB), xTicksToWait); \ | |
| trcKERNEL_HOOKS_SET_TASK_INSTANCE_FINISHED(); | |
| #undef traceTASK_NOTIFY | |
| #define traceTASK_NOTIFY() \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, xTaskToNotify) & CurrentFilterMask) \ | |
| prvTraceStoreKernelCall(TRACE_TASK_NOTIFY, TRACE_CLASS_TASK, TRACE_GET_TASK_NUMBER(xTaskToNotify)); | |
| #undef traceTASK_NOTIFY_FROM_ISR | |
| #define traceTASK_NOTIFY_FROM_ISR() \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, xTaskToNotify) & CurrentFilterMask) \ | |
| prvTraceStoreKernelCall(TRACE_TASK_NOTIFY_FROM_ISR, TRACE_CLASS_TASK, TRACE_GET_TASK_NUMBER(xTaskToNotify)); | |
| #undef traceTASK_NOTIFY_GIVE_FROM_ISR | |
| #define traceTASK_NOTIFY_GIVE_FROM_ISR() \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, xTaskToNotify) & CurrentFilterMask) \ | |
| prvTraceStoreKernelCall(TRACE_TASK_NOTIFY_GIVE_FROM_ISR, TRACE_CLASS_TASK, TRACE_GET_TASK_NUMBER(xTaskToNotify)); | |
| #if (TRC_CFG_INCLUDE_STREAM_BUFFER_EVENTS == 1) | |
| #undef traceSTREAM_BUFFER_CREATE | |
| #define traceSTREAM_BUFFER_CREATE( pxStreamBuffer, xIsMessageBuffer ) \ | |
| trcKERNEL_HOOKS_OBJECT_CREATE(TRACE_GET_OBJECT_EVENT_CODE(CREATE_OBJ, TRCSUCCESS, STREAMBUFFER, pxStreamBuffer), STREAMBUFFER, pxStreamBuffer); | |
| #undef traceSTREAM_BUFFER_CREATE_FAILED | |
| #define traceSTREAM_BUFFER_CREATE_FAILED( xIsMessageBuffer ) \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_NUMERIC_PARAM_ONLY(TRACE_GET_CLASS_EVENT_CODE(CREATE_OBJ, TRCFAILED, STREAMBUFFER, xIsMessageBuffer), 0); | |
| #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 ) \ | |
| trcKERNEL_HOOKS_OBJECT_DELETE(TRACE_GET_OBJECT_EVENT_CODE(DELETE_OBJ, TRCSUCCESS, STREAMBUFFER, xStreamBuffer), TRACE_GET_OBJECT_EVENT_CODE(OBJCLOSE_NAME, TRCSUCCESS, STREAMBUFFER, xStreamBuffer), TRACE_GET_OBJECT_EVENT_CODE(OBJCLOSE_PROP, TRCSUCCESS, STREAMBUFFER, xStreamBuffer), STREAMBUFFER, xStreamBuffer); | |
| #undef traceSTREAM_BUFFER_RESET | |
| #define traceSTREAM_BUFFER_RESET( xStreamBuffer ) \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE(prvGetStreamBufferType(xStreamBuffer) > 0 ? TRACE_MESSAGEBUFFER_RESET : TRACE_STREAMBUFFER_RESET, STREAMBUFFER, xStreamBuffer); \ | |
| trcKERNEL_HOOKS_SET_OBJECT_STATE(STREAMBUFFER, xStreamBuffer, 0); | |
| #undef traceSTREAM_BUFFER_SEND | |
| #define traceSTREAM_BUFFER_SEND( xStreamBuffer, xReturn ) \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE(TRACE_GET_OBJECT_EVENT_CODE(SEND, TRCSUCCESS, STREAMBUFFER, xStreamBuffer), STREAMBUFFER, xStreamBuffer); \ | |
| trcKERNEL_HOOKS_SET_OBJECT_STATE(STREAMBUFFER, xStreamBuffer, prvBytesInBuffer(xStreamBuffer)); | |
| #undef traceBLOCKING_ON_STREAM_BUFFER_SEND | |
| #define traceBLOCKING_ON_STREAM_BUFFER_SEND( xStreamBuffer ) \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE(TRACE_GET_OBJECT_EVENT_CODE(SEND, TRCBLOCK, STREAMBUFFER, xStreamBuffer), STREAMBUFFER, xStreamBuffer); | |
| #undef traceSTREAM_BUFFER_SEND_FAILED | |
| #define traceSTREAM_BUFFER_SEND_FAILED( xStreamBuffer ) \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE(TRACE_GET_OBJECT_EVENT_CODE(SEND, TRCFAILED, STREAMBUFFER, xStreamBuffer), STREAMBUFFER, xStreamBuffer); | |
| #undef traceSTREAM_BUFFER_RECEIVE | |
| #define traceSTREAM_BUFFER_RECEIVE( xStreamBuffer, xReceivedLength ) \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE(TRACE_GET_OBJECT_EVENT_CODE(RECEIVE, TRCSUCCESS, STREAMBUFFER, xStreamBuffer), STREAMBUFFER, xStreamBuffer); \ | |
| trcKERNEL_HOOKS_SET_OBJECT_STATE(STREAMBUFFER, xStreamBuffer, prvBytesInBuffer(xStreamBuffer)); | |
| #undef traceBLOCKING_ON_STREAM_BUFFER_RECEIVE | |
| #define traceBLOCKING_ON_STREAM_BUFFER_RECEIVE( xStreamBuffer ) \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE(TRACE_GET_OBJECT_EVENT_CODE(RECEIVE, TRCBLOCK, STREAMBUFFER, xStreamBuffer), STREAMBUFFER, xStreamBuffer); | |
| #undef traceSTREAM_BUFFER_RECEIVE_FAILED | |
| #define traceSTREAM_BUFFER_RECEIVE_FAILED( xStreamBuffer ) \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE(TRACE_GET_OBJECT_EVENT_CODE(RECEIVE, TRCFAILED, STREAMBUFFER, xStreamBuffer), STREAMBUFFER, xStreamBuffer); | |
| #undef traceSTREAM_BUFFER_SEND_FROM_ISR | |
| #define traceSTREAM_BUFFER_SEND_FROM_ISR( xStreamBuffer, xReturn ) \ | |
| if( xReturn > ( size_t ) 0 ) \ | |
| { \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE_FROM_ISR(TRACE_GET_OBJECT_EVENT_CODE(SEND_FROM_ISR, TRCSUCCESS, STREAMBUFFER, xStreamBuffer), STREAMBUFFER, xStreamBuffer); \ | |
| trcKERNEL_HOOKS_SET_OBJECT_STATE(STREAMBUFFER, xStreamBuffer, prvBytesInBuffer(xStreamBuffer)); \ | |
| } \ | |
| else \ | |
| { \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE_FROM_ISR(TRACE_GET_OBJECT_EVENT_CODE(SEND_FROM_ISR, TRCFAILED, STREAMBUFFER, xStreamBuffer), STREAMBUFFER, xStreamBuffer); \ | |
| } | |
| #undef traceSTREAM_BUFFER_RECEIVE_FROM_ISR | |
| #define traceSTREAM_BUFFER_RECEIVE_FROM_ISR( xStreamBuffer, xReceivedLength ) \ | |
| if( xReceivedLength > ( size_t ) 0 ) \ | |
| { \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE_FROM_ISR(TRACE_GET_OBJECT_EVENT_CODE(RECEIVE_FROM_ISR, TRCSUCCESS, STREAMBUFFER, xStreamBuffer), STREAMBUFFER, xStreamBuffer); \ | |
| trcKERNEL_HOOKS_SET_OBJECT_STATE(STREAMBUFFER, xStreamBuffer, prvBytesInBuffer(xStreamBuffer)); \ | |
| } \ | |
| else \ | |
| { \ | |
| trcKERNEL_HOOKS_KERNEL_SERVICE_FROM_ISR(TRACE_GET_OBJECT_EVENT_CODE(RECEIVE_FROM_ISR, TRCFAILED, STREAMBUFFER, xStreamBuffer), STREAMBUFFER, xStreamBuffer); \ | |
| } | |
| #endif /* (TRC_CFG_INCLUDE_STREAM_BUFFER_EVENTS == 1) */ | |
| #endif /* (TRC_CFG_SCHEDULING_ONLY == 0) */ | |
| #endif /*#if TRC_CFG_RECORDER_MODE == TRC_RECORDER_MODE_SNAPSHOT */ | |
| /******************************************************************************/ | |
| /*** Definitions for Streaming mode *******************************************/ | |
| /******************************************************************************/ | |
| #if (TRC_CFG_RECORDER_MODE == TRC_RECORDER_MODE_STREAMING) | |
| /******************************************************************************* | |
| * vTraceStoreKernelObjectName | |
| * | |
| * Set the name for a kernel object (defined by its address). | |
| ******************************************************************************/ | |
| void vTraceStoreKernelObjectName(void* object, const char* name); | |
| /******************************************************************************* | |
| * prvIsNewTCB | |
| * | |
| * Tells if this task is already executing, or if there has been a task-switch. | |
| * Assumed to be called within a trace hook in kernel context. | |
| *******************************************************************************/ | |
| uint32_t prvIsNewTCB(void* pNewTCB); | |
| #define TRACE_GET_CURRENT_TASK() prvTraceGetCurrentTaskHandle() | |
| /*************************************************************************/ | |
| /* 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 | |
| #define PSF_EVENT_USER_EVENT 0x90 | |
| #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_TAKE 0xCA | |
| #define PSF_EVENT_TASK_NOTIFY_TAKE_BLOCK 0xCB | |
| #define PSF_EVENT_TASK_NOTIFY_TAKE_FAILED 0xCC | |
| #define PSF_EVENT_TASK_NOTIFY_WAIT 0xCD | |
| #define PSF_EVENT_TASK_NOTIFY_WAIT_BLOCK 0xCE | |
| #define PSF_EVENT_TASK_NOTIFY_WAIT_FAILED 0xCF | |
| #define PSF_EVENT_TASK_NOTIFY_FROM_ISR 0xD0 | |
| #define PSF_EVENT_TASK_NOTIFY_GIVE_FROM_ISR 0xD1 | |
| #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 | |
| /*** 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 ) { extern uint32_t uiTraceTickCount; uiTraceTickCount += xCount; } | |
| #if (TRC_CFG_INCLUDE_OSTICK_EVENTS == 1) | |
| #define OS_TICK_EVENT(uxSchedulerSuspended, xTickCount) if (uxSchedulerSuspended == (unsigned portBASE_TYPE) pdFALSE) { prvTraceStoreEvent1(PSF_EVENT_NEW_TIME, (uint32_t)(xTickCount + 1)); } | |
| #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_FREERTOS_VERSION <= TRC_FREERTOS_VERSION_7_4 | |
| #define traceTASK_INCREMENT_TICK( xTickCount ) \ | |
| if (uxSchedulerSuspended == ( unsigned portBASE_TYPE ) pdTRUE || uxMissedTicks == 0) { extern uint32_t uiTraceTickCount; uiTraceTickCount++; } \ | |
| OS_TICK_EVENT(uxSchedulerSuspended, xTickCount) | |
| #else | |
| #define traceTASK_INCREMENT_TICK( xTickCount ) \ | |
| if (uxSchedulerSuspended == ( unsigned portBASE_TYPE ) pdTRUE || uxPendedTicks == 0) { extern uint32_t uiTraceTickCount; uiTraceTickCount++; } \ | |
| OS_TICK_EVENT(uxSchedulerSuspended, xTickCount) | |
| #endif /* TRC_CFG_FREERTOS_VERSION <= TRC_FREERTOS_VERSION_7_4 */ | |
| /* Called on each task-switch */ | |
| #undef traceTASK_SWITCHED_IN | |
| #define traceTASK_SWITCHED_IN() \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| { \ | |
| if (prvIsNewTCB(pxCurrentTCB)) \ | |
| { \ | |
| prvTraceStoreEvent2(PSF_EVENT_TASK_ACTIVATE, (uint32_t)pxCurrentTCB, pxCurrentTCB->uxPriority); \ | |
| } \ | |
| } | |
| /* 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 ) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, pxTCB) & CurrentFilterMask) \ | |
| prvTraceStoreEvent1(PSF_EVENT_TASK_READY, (uint32_t)pxTCB); | |
| #endif | |
| #undef traceTASK_CREATE | |
| #if TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_9_0_0 | |
| #define traceTASK_CREATE(pxNewTCB) \ | |
| if (pxNewTCB != NULL) \ | |
| { \ | |
| prvTraceSaveSymbol(pxNewTCB, pxNewTCB->pcTaskName); \ | |
| prvTraceSaveObjectData(pxNewTCB, pxNewTCB->uxPriority); \ | |
| prvTraceStoreStringEvent(1, PSF_EVENT_OBJ_NAME, pxNewTCB->pcTaskName, pxNewTCB); \ | |
| TRACE_SET_OBJECT_FILTER(TASK, pxNewTCB, CurrentFilterGroup); \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, pxNewTCB) & CurrentFilterMask) \ | |
| prvTraceStoreEvent2(PSF_EVENT_TASK_CREATE, (uint32_t)pxNewTCB, pxNewTCB->uxPriority); \ | |
| } | |
| #else /* TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_9_0_0 */ | |
| #define traceTASK_CREATE(pxNewTCB) \ | |
| if (pxNewTCB != NULL) \ | |
| { \ | |
| prvTraceSaveSymbol(pxNewTCB, (const char*)pcName); \ | |
| prvTraceSaveObjectData(pxNewTCB, uxPriority); \ | |
| prvTraceStoreStringEvent(1, PSF_EVENT_OBJ_NAME, (const char*)pcName, pxNewTCB); \ | |
| TRACE_SET_OBJECT_FILTER(TASK, pxNewTCB, CurrentFilterGroup); \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, pxNewTCB) & CurrentFilterMask) \ | |
| prvTraceStoreEvent2(PSF_EVENT_TASK_CREATE, (uint32_t)pxNewTCB, uxPriority); \ | |
| } | |
| #endif /* TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_9_0_0 */ | |
| /* Called in vTaskCreate, if it fails (typically if the stack can not be allocated) */ | |
| #undef traceTASK_CREATE_FAILED | |
| #define traceTASK_CREATE_FAILED() \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| prvTraceStoreEvent0(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 ) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, pxTaskToDelete) & CurrentFilterMask) \ | |
| prvTraceStoreEvent2(PSF_EVENT_TASK_DELETE, (uint32_t)pxTaskToDelete, (pxTaskToDelete != NULL) ? (pxTaskToDelete->uxPriority) : 0); \ | |
| prvTraceDeleteSymbol(pxTaskToDelete); \ | |
| prvTraceDeleteObjectData(pxTaskToDelete); | |
| #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() \ | |
| { \ | |
| prvTraceStoreEvent1(PSF_EVENT_LOWPOWER_BEGIN, xExpectedIdleTime); \ | |
| } | |
| #undef traceLOW_POWER_IDLE_END | |
| #define traceLOW_POWER_IDLE_END() \ | |
| { \ | |
| prvTraceStoreEvent0(PSF_EVENT_LOWPOWER_END); \ | |
| } | |
| #endif /* (defined(configUSE_TICKLESS_IDLE) && configUSE_TICKLESS_IDLE != 0) */ | |
| /* Called on vTaskSuspend */ | |
| #undef traceTASK_SUSPEND | |
| #define traceTASK_SUSPEND( pxTaskToSuspend ) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, pxTaskToSuspend) & CurrentFilterMask) \ | |
| prvTraceStoreEvent1(PSF_EVENT_TASK_SUSPEND, (uint32_t)pxTaskToSuspend); | |
| /* Called on vTaskDelay - note the use of FreeRTOS variable xTicksToDelay */ | |
| #undef traceTASK_DELAY | |
| #define traceTASK_DELAY() \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| prvTraceStoreEvent1(PSF_EVENT_TASK_DELAY, xTicksToDelay); | |
| /* Called on vTaskDelayUntil - note the use of FreeRTOS variable xTimeToWake */ | |
| #undef traceTASK_DELAY_UNTIL | |
| #if TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_9_0_0 | |
| #define traceTASK_DELAY_UNTIL(xTimeToWake) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| prvTraceStoreEvent1(PSF_EVENT_TASK_DELAY_UNTIL, (uint32_t)xTimeToWake); | |
| #else /* TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_9_0_0 */ | |
| #define traceTASK_DELAY_UNTIL() \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| prvTraceStoreEvent1(PSF_EVENT_TASK_DELAY_UNTIL, (uint32_t)xTimeToWake); | |
| #endif /* TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_9_0_0 */ | |
| #if (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_9_0_0) | |
| #define traceQUEUE_CREATE_HELPER() \ | |
| case queueQUEUE_TYPE_MUTEX: \ | |
| prvTraceStoreEvent1(PSF_EVENT_MUTEX_CREATE, (uint32_t)pxNewQueue); \ | |
| break; \ | |
| case queueQUEUE_TYPE_RECURSIVE_MUTEX: \ | |
| prvTraceStoreEvent1(PSF_EVENT_MUTEX_RECURSIVE_CREATE, (uint32_t)pxNewQueue); \ | |
| break; | |
| #else | |
| #define traceQUEUE_CREATE_HELPER() | |
| #endif /* (TRC_CFG_FREERTOS_VERSION < TRC_FREERTOS_VERSION_9_0_0) */ | |
| /* Called in xQueueCreate, and thereby for all other object based on queues, such as semaphores. */ | |
| #undef traceQUEUE_CREATE | |
| #define traceQUEUE_CREATE( pxNewQueue )\ | |
| TRACE_SET_OBJECT_FILTER(QUEUE, pxNewQueue, CurrentFilterGroup); \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| { \ | |
| if (TRACE_GET_OBJECT_FILTER(QUEUE, pxNewQueue) & CurrentFilterMask) \ | |
| { \ | |
| switch (pxNewQueue->ucQueueType) \ | |
| { \ | |
| case queueQUEUE_TYPE_BASE: \ | |
| prvTraceStoreEvent2(PSF_EVENT_QUEUE_CREATE, (uint32_t)pxNewQueue, uxQueueLength); \ | |
| break; \ | |
| case queueQUEUE_TYPE_BINARY_SEMAPHORE: \ | |
| prvTraceStoreEvent1(PSF_EVENT_SEMAPHORE_BINARY_CREATE, (uint32_t)pxNewQueue); \ | |
| break; \ | |
| traceQUEUE_CREATE_HELPER() \ | |
| } \ | |
| } \ | |
| } | |
| #if (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_9_0_0) | |
| #define traceQUEUE_CREATE_FAILED_HELPER() \ | |
| case queueQUEUE_TYPE_MUTEX: \ | |
| prvTraceStoreEvent1(PSF_EVENT_MUTEX_CREATE_FAILED, 0); \ | |
| break; \ | |
| case queueQUEUE_TYPE_RECURSIVE_MUTEX: \ | |
| prvTraceStoreEvent1(PSF_EVENT_MUTEX_RECURSIVE_CREATE_FAILED, 0); \ | |
| break; | |
| #else | |
| #define traceQUEUE_CREATE_FAILED_HELPER() | |
| #endif /* (TRC_CFG_FREERTOS_VERSION < TRC_FREERTOS_VERSION_9_0_0) */ | |
| /* Called in xQueueCreate, if the queue creation fails */ | |
| #undef traceQUEUE_CREATE_FAILED | |
| #define traceQUEUE_CREATE_FAILED( queueType ) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| { \ | |
| switch (queueType) \ | |
| { \ | |
| case queueQUEUE_TYPE_BASE: \ | |
| prvTraceStoreEvent2(PSF_EVENT_QUEUE_CREATE_FAILED, 0, uxQueueLength); \ | |
| break; \ | |
| case queueQUEUE_TYPE_BINARY_SEMAPHORE: \ | |
| prvTraceStoreEvent1(PSF_EVENT_SEMAPHORE_BINARY_CREATE_FAILED, 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 ) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| { \ | |
| if (TRACE_GET_OBJECT_FILTER(QUEUE, pxQueue) & CurrentFilterMask) \ | |
| { \ | |
| switch (pxQueue->ucQueueType) \ | |
| { \ | |
| case queueQUEUE_TYPE_BASE: \ | |
| prvTraceStoreEvent2(PSF_EVENT_QUEUE_DELETE, (uint32_t)pxQueue, (pxQueue != NULL) ? (pxQueue->uxMessagesWaiting) : 0); \ | |
| break; \ | |
| case queueQUEUE_TYPE_MUTEX: \ | |
| case queueQUEUE_TYPE_RECURSIVE_MUTEX: \ | |
| prvTraceStoreEvent2(PSF_EVENT_MUTEX_DELETE, (uint32_t)pxQueue, (pxQueue != NULL) ? (pxQueue->uxMessagesWaiting) : 0); \ | |
| break; \ | |
| case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \ | |
| case queueQUEUE_TYPE_BINARY_SEMAPHORE: \ | |
| prvTraceStoreEvent2(PSF_EVENT_SEMAPHORE_DELETE, (uint32_t)pxQueue, (pxQueue != NULL) ? (pxQueue->uxMessagesWaiting) : 0); \ | |
| break; \ | |
| } \ | |
| } \ | |
| } \ | |
| prvTraceDeleteSymbol(pxQueue); | |
| /* Called in xQueueCreateCountingSemaphore, if the queue creation fails */ | |
| #undef traceCREATE_COUNTING_SEMAPHORE | |
| #if (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_8_X) | |
| #define traceCREATE_COUNTING_SEMAPHORE() \ | |
| TRACE_SET_OBJECT_FILTER(QUEUE, xHandle, CurrentFilterGroup); \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(QUEUE, xHandle) & CurrentFilterMask) \ | |
| prvTraceStoreEvent2(PSF_EVENT_SEMAPHORE_COUNTING_CREATE, (uint32_t)xHandle, uxMaxCount) | |
| #elif (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_7_5_OR_7_6) | |
| #define traceCREATE_COUNTING_SEMAPHORE() \ | |
| TRACE_SET_OBJECT_FILTER(QUEUE, xHandle, CurrentFilterGroup); \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(QUEUE, xHandle) & CurrentFilterMask) \ | |
| prvTraceStoreEvent2(PSF_EVENT_SEMAPHORE_COUNTING_CREATE, (uint32_t)xHandle, uxInitialCount); | |
| #elif (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_7_4) | |
| #define traceCREATE_COUNTING_SEMAPHORE() \ | |
| TRACE_SET_OBJECT_FILTER(QUEUE, xHandle, CurrentFilterGroup); \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(QUEUE, xHandle) & CurrentFilterMask) \ | |
| prvTraceStoreEvent2(PSF_EVENT_SEMAPHORE_COUNTING_CREATE, (uint32_t)xHandle, uxCountValue); | |
| #else | |
| #define traceCREATE_COUNTING_SEMAPHORE() \ | |
| TRACE_SET_OBJECT_FILTER(QUEUE, pxHandle, CurrentFilterGroup); \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(QUEUE, pxHandle) & CurrentFilterMask) \ | |
| prvTraceStoreEvent2(PSF_EVENT_SEMAPHORE_COUNTING_CREATE, (uint32_t)pxHandle, uxCountValue); | |
| #endif /* TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_8_X */ | |
| #undef traceCREATE_COUNTING_SEMAPHORE_FAILED | |
| #if (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_8_X) | |
| #define traceCREATE_COUNTING_SEMAPHORE_FAILED() \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| prvTraceStoreEvent2(PSF_EVENT_SEMAPHORE_COUNTING_CREATE_FAILED, 0, uxMaxCount); | |
| #elif (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_7_5_OR_7_6) | |
| #define traceCREATE_COUNTING_SEMAPHORE_FAILED() \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| prvTraceStoreEvent2(PSF_EVENT_SEMAPHORE_COUNTING_CREATE_FAILED, 0, uxInitialCount); | |
| #elif (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_7_4) | |
| #define traceCREATE_COUNTING_SEMAPHORE_FAILED() \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| prvTraceStoreEvent2(PSF_EVENT_SEMAPHORE_COUNTING_CREATE_FAILED, 0, uxCountValue); | |
| #else | |
| #define traceCREATE_COUNTING_SEMAPHORE_FAILED() \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| prvTraceStoreEvent2(PSF_EVENT_SEMAPHORE_COUNTING_CREATE_FAILED, 0, uxCountValue); | |
| #endif /* TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_8_X */ | |
| /* This macro is not necessary as of FreeRTOS v9.0.0 */ | |
| #if (TRC_CFG_FREERTOS_VERSION < TRC_FREERTOS_VERSION_9_0_0) | |
| /* Called in xQueueCreateMutex, and thereby also from xSemaphoreCreateMutex and xSemaphoreCreateRecursiveMutex */ | |
| #undef traceCREATE_MUTEX | |
| #define traceCREATE_MUTEX( pxNewQueue ) \ | |
| TRACE_SET_OBJECT_FILTER(QUEUE, pxNewQueue, CurrentFilterGroup); \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| { \ | |
| if (TRACE_GET_OBJECT_FILTER(QUEUE, pxNewQueue) & CurrentFilterMask) \ | |
| { \ | |
| switch (pxNewQueue->ucQueueType) \ | |
| { \ | |
| case queueQUEUE_TYPE_MUTEX: \ | |
| prvTraceStoreEvent1(PSF_EVENT_MUTEX_CREATE, (uint32_t)pxNewQueue); \ | |
| break; \ | |
| case queueQUEUE_TYPE_RECURSIVE_MUTEX: \ | |
| prvTraceStoreEvent1(PSF_EVENT_MUTEX_RECURSIVE_CREATE, (uint32_t)pxNewQueue); \ | |
| break; \ | |
| } \ | |
| }\ | |
| } | |
| /* Called in xQueueCreateMutex when the operation fails (when memory allocation fails) */ | |
| #undef traceCREATE_MUTEX_FAILED | |
| #define traceCREATE_MUTEX_FAILED() \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| prvTraceStoreEvent1(PSF_EVENT_MUTEX_CREATE_FAILED, 0); | |
| #endif /* (TRC_CFG_FREERTOS_VERSION < TRC_FREERTOS_VERSION_9_0_0) */ | |
| /* Called when a message is sent to a queue */ /* CS IS NEW ! */ | |
| #undef traceQUEUE_SEND | |
| #define traceQUEUE_SEND( pxQueue ) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(QUEUE, pxQueue) & CurrentFilterMask) \ | |
| switch (pxQueue->ucQueueType) \ | |
| { \ | |
| case queueQUEUE_TYPE_BASE: \ | |
| prvTraceStoreEvent2(xCopyPosition == queueSEND_TO_BACK ? PSF_EVENT_QUEUE_SEND : PSF_EVENT_QUEUE_SEND_FRONT, (uint32_t)pxQueue, pxQueue->uxMessagesWaiting + 1); \ | |
| break; \ | |
| case queueQUEUE_TYPE_BINARY_SEMAPHORE: \ | |
| case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \ | |
| prvTraceStoreEvent2(PSF_EVENT_SEMAPHORE_GIVE, (uint32_t)pxQueue, pxQueue->uxMessagesWaiting + 1); \ | |
| break; \ | |
| case queueQUEUE_TYPE_MUTEX: \ | |
| case queueQUEUE_TYPE_RECURSIVE_MUTEX: \ | |
| prvTraceStoreEvent1(PSF_EVENT_MUTEX_GIVE, (uint32_t)pxQueue); \ | |
| break; \ | |
| } | |
| /* Called when a message failed to be sent to a queue (timeout) */ | |
| #undef traceQUEUE_SEND_FAILED | |
| #define traceQUEUE_SEND_FAILED( pxQueue ) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(QUEUE, pxQueue) & CurrentFilterMask) \ | |
| switch (pxQueue->ucQueueType) \ | |
| { \ | |
| case queueQUEUE_TYPE_BASE: \ | |
| prvTraceStoreEvent2(xCopyPosition == queueSEND_TO_BACK ? PSF_EVENT_QUEUE_SEND_FAILED : PSF_EVENT_QUEUE_SEND_FRONT_FAILED, (uint32_t)pxQueue, pxQueue->uxMessagesWaiting); \ | |
| break; \ | |
| case queueQUEUE_TYPE_BINARY_SEMAPHORE: \ | |
| case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \ | |
| prvTraceStoreEvent2(PSF_EVENT_SEMAPHORE_GIVE_FAILED, (uint32_t)pxQueue, pxQueue->uxMessagesWaiting); \ | |
| break; \ | |
| case queueQUEUE_TYPE_MUTEX: \ | |
| case queueQUEUE_TYPE_RECURSIVE_MUTEX: \ | |
| prvTraceStoreEvent1(PSF_EVENT_MUTEX_GIVE_FAILED, (uint32_t)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 ) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(QUEUE, pxQueue) & CurrentFilterMask) \ | |
| switch (pxQueue->ucQueueType) \ | |
| { \ | |
| case queueQUEUE_TYPE_BASE: \ | |
| prvTraceStoreEvent2(xCopyPosition == queueSEND_TO_BACK ? PSF_EVENT_QUEUE_SEND_BLOCK : PSF_EVENT_QUEUE_SEND_FRONT_BLOCK, (uint32_t)pxQueue, pxQueue->uxMessagesWaiting); \ | |
| break; \ | |
| case queueQUEUE_TYPE_BINARY_SEMAPHORE: \ | |
| case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \ | |
| prvTraceStoreEvent2(PSF_EVENT_SEMAPHORE_GIVE_BLOCK, (uint32_t)pxQueue, pxQueue->uxMessagesWaiting); \ | |
| break; \ | |
| case queueQUEUE_TYPE_MUTEX: \ | |
| case queueQUEUE_TYPE_RECURSIVE_MUTEX: \ | |
| prvTraceStoreEvent1(PSF_EVENT_MUTEX_GIVE_BLOCK, (uint32_t)pxQueue); \ | |
| break; \ | |
| } | |
| /**************************************************************************/ | |
| /* Makes sure xQueueGiveFromISR also has a xCopyPosition parameter */ | |
| /**************************************************************************/ | |
| /* Helpers needed to correctly expand names */ | |
| #define TZ__CAT2(a,b) a ## b | |
| #define TZ__CAT(a,b) TZ__CAT2(a, b) | |
| /* 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(__a, __b, const BaseType_t xCopyPosition); \ | |
| BaseType_t xQueueGiveFromISR(__a, __b) { return MyWrapper(xQueue, pxHigherPriorityTaskWoken, queueSEND_TO_BACK); } \ | |
| BaseType_t MyWrapper(__a, __b, const BaseType_t xCopyPosition) | |
| /* If not in queue.c, "uxQueueType" isn't expanded */ | |
| #define xQueueGiveFromISR__uxQueueType(__a, __b) xQueueGiveFromISR(__a,__b) | |
| /**************************************************************************/ | |
| /* End of xQueueGiveFromISR fix */ | |
| /**************************************************************************/ | |
| /* Called when a message is sent from interrupt context, e.g., using xQueueSendFromISR */ | |
| #undef traceQUEUE_SEND_FROM_ISR | |
| #define traceQUEUE_SEND_FROM_ISR( pxQueue ) \ | |
| if (TRACE_GET_OBJECT_FILTER(QUEUE, pxQueue) & CurrentFilterMask) \ | |
| switch (pxQueue->ucQueueType) \ | |
| { \ | |
| case queueQUEUE_TYPE_BASE: \ | |
| prvTraceStoreEvent2(xCopyPosition == queueSEND_TO_BACK ? PSF_EVENT_QUEUE_SEND_FROMISR : PSF_EVENT_QUEUE_SEND_FRONT_FROMISR, (uint32_t)pxQueue, pxQueue->uxMessagesWaiting + 1); \ | |
| break; \ | |
| case queueQUEUE_TYPE_BINARY_SEMAPHORE: \ | |
| case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \ | |
| prvTraceStoreEvent2(PSF_EVENT_SEMAPHORE_GIVE_FROMISR, (uint32_t)pxQueue, pxQueue->uxMessagesWaiting + 1); \ | |
| break; \ | |
| } | |
| /* 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 ) \ | |
| if (TRACE_GET_OBJECT_FILTER(QUEUE, pxQueue) & CurrentFilterMask) \ | |
| switch (pxQueue->ucQueueType) \ | |
| { \ | |
| case queueQUEUE_TYPE_BASE: \ | |
| prvTraceStoreEvent2(xCopyPosition == queueSEND_TO_BACK ? PSF_EVENT_QUEUE_SEND_FROMISR_FAILED : PSF_EVENT_QUEUE_SEND_FRONT_FROMISR_FAILED, (uint32_t)pxQueue, pxQueue->uxMessagesWaiting); \ | |
| break; \ | |
| case queueQUEUE_TYPE_BINARY_SEMAPHORE: \ | |
| case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \ | |
| prvTraceStoreEvent2(PSF_EVENT_SEMAPHORE_GIVE_FROMISR_FAILED, (uint32_t)pxQueue, pxQueue->uxMessagesWaiting); \ | |
| break; \ | |
| } | |
| /* Called when a message is received from a queue */ | |
| #undef traceQUEUE_RECEIVE | |
| #define traceQUEUE_RECEIVE( pxQueue ) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(QUEUE, pxQueue) & CurrentFilterMask) \ | |
| switch (pxQueue->ucQueueType) \ | |
| { \ | |
| case queueQUEUE_TYPE_BASE: \ | |
| if (isQueueReceiveHookActuallyPeek) \ | |
| prvTraceStoreEvent3(PSF_EVENT_QUEUE_PEEK, (uint32_t)pxQueue, xTicksToWait, pxQueue->uxMessagesWaiting - 1); \ | |
| else\ | |
| prvTraceStoreEvent3(PSF_EVENT_QUEUE_RECEIVE, (uint32_t)pxQueue, xTicksToWait, pxQueue->uxMessagesWaiting - 1); \ | |
| break; \ | |
| case queueQUEUE_TYPE_BINARY_SEMAPHORE: \ | |
| case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \ | |
| if (isQueueReceiveHookActuallyPeek) \ | |
| prvTraceStoreEvent3(PSF_EVENT_SEMAPHORE_PEEK, (uint32_t)pxQueue, xTicksToWait, pxQueue->uxMessagesWaiting - 1); \ | |
| else \ | |
| prvTraceStoreEvent3(PSF_EVENT_SEMAPHORE_TAKE, (uint32_t)pxQueue, xTicksToWait, pxQueue->uxMessagesWaiting - 1); \ | |
| break; \ | |
| case queueQUEUE_TYPE_MUTEX: \ | |
| case queueQUEUE_TYPE_RECURSIVE_MUTEX: \ | |
| if (isQueueReceiveHookActuallyPeek) \ | |
| prvTraceStoreEvent2(PSF_EVENT_MUTEX_PEEK, (uint32_t)pxQueue, xTicksToWait); \ | |
| else \ | |
| prvTraceStoreEvent2(PSF_EVENT_MUTEX_TAKE, (uint32_t)pxQueue, xTicksToWait); \ | |
| break; \ | |
| } | |
| /* Called when a receive operation on a queue fails (timeout) */ | |
| #undef traceQUEUE_RECEIVE_FAILED | |
| #define traceQUEUE_RECEIVE_FAILED( pxQueue ) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(QUEUE, pxQueue) & CurrentFilterMask) \ | |
| switch (pxQueue->ucQueueType) \ | |
| { \ | |
| case queueQUEUE_TYPE_BASE: \ | |
| prvTraceStoreEvent3(isQueueReceiveHookActuallyPeek ? PSF_EVENT_QUEUE_PEEK_FAILED : PSF_EVENT_QUEUE_RECEIVE_FAILED, (uint32_t)pxQueue, xTicksToWait, pxQueue->uxMessagesWaiting); \ | |
| break; \ | |
| case queueQUEUE_TYPE_BINARY_SEMAPHORE: \ | |
| case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \ | |
| prvTraceStoreEvent3(isQueueReceiveHookActuallyPeek ? PSF_EVENT_SEMAPHORE_PEEK_FAILED : PSF_EVENT_SEMAPHORE_TAKE_FAILED, (uint32_t)pxQueue, xTicksToWait, pxQueue->uxMessagesWaiting); \ | |
| break; \ | |
| case queueQUEUE_TYPE_MUTEX: \ | |
| case queueQUEUE_TYPE_RECURSIVE_MUTEX: \ | |
| prvTraceStoreEvent2(isQueueReceiveHookActuallyPeek ? PSF_EVENT_MUTEX_PEEK_FAILED : PSF_EVENT_MUTEX_TAKE_FAILED, (uint32_t)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 ) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(QUEUE, pxQueue) & CurrentFilterMask) \ | |
| switch (pxQueue->ucQueueType) \ | |
| { \ | |
| case queueQUEUE_TYPE_BASE: \ | |
| prvTraceStoreEvent3(isQueueReceiveHookActuallyPeek ? PSF_EVENT_QUEUE_PEEK_BLOCK : PSF_EVENT_QUEUE_RECEIVE_BLOCK, (uint32_t)pxQueue, xTicksToWait, pxQueue->uxMessagesWaiting); \ | |
| break; \ | |
| case queueQUEUE_TYPE_BINARY_SEMAPHORE: \ | |
| case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \ | |
| prvTraceStoreEvent3(isQueueReceiveHookActuallyPeek ? PSF_EVENT_SEMAPHORE_PEEK_BLOCK : PSF_EVENT_SEMAPHORE_TAKE_BLOCK, (uint32_t)pxQueue, xTicksToWait, pxQueue->uxMessagesWaiting); \ | |
| break; \ | |
| case queueQUEUE_TYPE_MUTEX: \ | |
| case queueQUEUE_TYPE_RECURSIVE_MUTEX: \ | |
| prvTraceStoreEvent2(isQueueReceiveHookActuallyPeek ? PSF_EVENT_MUTEX_PEEK_BLOCK : PSF_EVENT_MUTEX_TAKE_BLOCK, (uint32_t)pxQueue, xTicksToWait); \ | |
| break; \ | |
| } | |
| #if (TRC_CFG_FREERTOS_VERSION > TRC_FREERTOS_VERSION_9_0_1) | |
| /* Called when a peek operation on a queue fails (timeout) */ | |
| #undef traceQUEUE_PEEK_FAILED | |
| #define traceQUEUE_PEEK_FAILED( pxQueue ) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(QUEUE, pxQueue) & CurrentFilterMask) \ | |
| switch (pxQueue->ucQueueType) \ | |
| { \ | |
| case queueQUEUE_TYPE_BASE: \ | |
| prvTraceStoreEvent3(PSF_EVENT_QUEUE_PEEK_FAILED, (uint32_t)pxQueue, xTicksToWait, pxQueue->uxMessagesWaiting); \ | |
| break; \ | |
| case queueQUEUE_TYPE_BINARY_SEMAPHORE: \ | |
| case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \ | |
| prvTraceStoreEvent3(PSF_EVENT_SEMAPHORE_PEEK_FAILED, (uint32_t)pxQueue, xTicksToWait, pxQueue->uxMessagesWaiting); \ | |
| break; \ | |
| case queueQUEUE_TYPE_MUTEX: \ | |
| case queueQUEUE_TYPE_RECURSIVE_MUTEX: \ | |
| prvTraceStoreEvent2(PSF_EVENT_MUTEX_PEEK_FAILED, (uint32_t)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 ) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(QUEUE, pxQueue) & CurrentFilterMask) \ | |
| switch (pxQueue->ucQueueType) \ | |
| { \ | |
| case queueQUEUE_TYPE_BASE: \ | |
| prvTraceStoreEvent3(PSF_EVENT_QUEUE_PEEK_BLOCK, (uint32_t)pxQueue, xTicksToWait, pxQueue->uxMessagesWaiting); \ | |
| break; \ | |
| case queueQUEUE_TYPE_BINARY_SEMAPHORE: \ | |
| case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \ | |
| prvTraceStoreEvent3(PSF_EVENT_SEMAPHORE_PEEK_BLOCK, (uint32_t)pxQueue, xTicksToWait, pxQueue->uxMessagesWaiting); \ | |
| break; \ | |
| case queueQUEUE_TYPE_MUTEX: \ | |
| case queueQUEUE_TYPE_RECURSIVE_MUTEX: \ | |
| prvTraceStoreEvent2(PSF_EVENT_MUTEX_PEEK_BLOCK, (uint32_t)pxQueue, xTicksToWait); \ | |
| break; \ | |
| } | |
| #endif /* (TRC_CFG_FREERTOS_VERSION > TRC_FREERTOS_VERSION_9_0_1) */ | |
| /* Called when a message is received in interrupt context, e.g., using xQueueReceiveFromISR */ | |
| #undef traceQUEUE_RECEIVE_FROM_ISR | |
| #define traceQUEUE_RECEIVE_FROM_ISR( pxQueue ) \ | |
| if (TRACE_GET_OBJECT_FILTER(QUEUE, pxQueue) & CurrentFilterMask) \ | |
| switch (pxQueue->ucQueueType) \ | |
| { \ | |
| case queueQUEUE_TYPE_BASE: \ | |
| prvTraceStoreEvent2(PSF_EVENT_QUEUE_RECEIVE_FROMISR, (uint32_t)pxQueue, pxQueue->uxMessagesWaiting - 1); \ | |
| break; \ | |
| case queueQUEUE_TYPE_BINARY_SEMAPHORE: \ | |
| case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \ | |
| prvTraceStoreEvent2(PSF_EVENT_SEMAPHORE_TAKE_FROMISR, (uint32_t)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 ) \ | |
| if (TRACE_GET_OBJECT_FILTER(QUEUE, pxQueue) & CurrentFilterMask) \ | |
| switch (pxQueue->ucQueueType) \ | |
| { \ | |
| case queueQUEUE_TYPE_BASE: \ | |
| prvTraceStoreEvent2(PSF_EVENT_QUEUE_RECEIVE_FROMISR_FAILED, (uint32_t)pxQueue, pxQueue->uxMessagesWaiting); \ | |
| break; \ | |
| case queueQUEUE_TYPE_BINARY_SEMAPHORE: \ | |
| case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \ | |
| prvTraceStoreEvent2(PSF_EVENT_SEMAPHORE_TAKE_FROMISR_FAILED, (uint32_t)pxQueue, pxQueue->uxMessagesWaiting); \ | |
| break; \ | |
| } | |
| /* Called on xQueuePeek */ | |
| #undef traceQUEUE_PEEK | |
| #define traceQUEUE_PEEK( pxQueue ) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(QUEUE, pxQueue) & CurrentFilterMask) \ | |
| switch (pxQueue->ucQueueType) \ | |
| { \ | |
| case queueQUEUE_TYPE_BASE: \ | |
| prvTraceStoreEvent3(PSF_EVENT_QUEUE_PEEK, (uint32_t)pxQueue, xTicksToWait, pxQueue->uxMessagesWaiting); \ | |
| break; \ | |
| case queueQUEUE_TYPE_BINARY_SEMAPHORE: \ | |
| case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \ | |
| prvTraceStoreEvent3(PSF_EVENT_SEMAPHORE_PEEK, (uint32_t)pxQueue, xTicksToWait, pxQueue->uxMessagesWaiting); \ | |
| break; \ | |
| case queueQUEUE_TYPE_MUTEX: \ | |
| case queueQUEUE_TYPE_RECURSIVE_MUTEX: \ | |
| prvTraceStoreEvent1(PSF_EVENT_MUTEX_PEEK, (uint32_t)pxQueue); \ | |
| break; \ | |
| } | |
| /* Called in vTaskPrioritySet */ | |
| #undef traceTASK_PRIORITY_SET | |
| #define traceTASK_PRIORITY_SET( pxTask, uxNewPriority ) \ | |
| prvTraceSaveObjectData(pxTask, uxNewPriority); \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, pxTask) & CurrentFilterMask) \ | |
| prvTraceStoreEvent2(PSF_EVENT_TASK_PRIORITY, (uint32_t)pxTask, uxNewPriority); | |
| /* Called in vTaskPriorityInherit, which is called by Mutex operations */ | |
| #undef traceTASK_PRIORITY_INHERIT | |
| #define traceTASK_PRIORITY_INHERIT( pxTask, uxNewPriority ) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, pxTask) & CurrentFilterMask) \ | |
| prvTraceStoreEvent2(PSF_EVENT_TASK_PRIO_INHERIT, (uint32_t)pxTask, uxNewPriority); | |
| /* Called in vTaskPriorityDisinherit, which is called by Mutex operations */ | |
| #undef traceTASK_PRIORITY_DISINHERIT | |
| #define traceTASK_PRIORITY_DISINHERIT( pxTask, uxNewPriority ) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, pxTask) & CurrentFilterMask) \ | |
| prvTraceStoreEvent2(PSF_EVENT_TASK_PRIO_DISINHERIT, (uint32_t)pxTask, uxNewPriority); | |
| /* Called in vTaskResume */ | |
| #undef traceTASK_RESUME | |
| #define traceTASK_RESUME( pxTaskToResume ) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, pxTaskToResume) & CurrentFilterMask) \ | |
| prvTraceStoreEvent1(PSF_EVENT_TASK_RESUME, (uint32_t)pxTaskToResume); | |
| /* Called in vTaskResumeFromISR */ | |
| #undef traceTASK_RESUME_FROM_ISR | |
| #define traceTASK_RESUME_FROM_ISR( pxTaskToResume ) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, pxTaskToResume) & CurrentFilterMask) \ | |
| prvTraceStoreEvent1(PSF_EVENT_TASK_RESUME_FROMISR, (uint32_t)pxTaskToResume); | |
| #if (TRC_CFG_INCLUDE_MEMMANG_EVENTS == 1) | |
| #undef traceMALLOC | |
| #define traceMALLOC( pvAddress, uiSize ) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| prvTraceStoreEvent2(PSF_EVENT_MALLOC, (uint32_t)pvAddress, uiSize); | |
| #undef traceFREE | |
| #define traceFREE( pvAddress, uiSize ) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| prvTraceStoreEvent2(PSF_EVENT_FREE, (uint32_t)pvAddress, (uint32_t)(0 - uiSize)); /* "0 -" instead of just "-" to get rid of a warning... */ | |
| #endif /* (TRC_CFG_INCLUDE_MEMMANG_EVENTS == 1) */ | |
| #if (TRC_CFG_INCLUDE_TIMER_EVENTS == 1) | |
| /* Called in timer.c - xTimerCreate */ | |
| #undef traceTIMER_CREATE | |
| #define traceTIMER_CREATE(tmr) \ | |
| TRACE_SET_OBJECT_FILTER(TIMER, tmr, CurrentFilterGroup); \ | |
| prvTraceSaveSymbol(tmr, tmr->pcTimerName); \ | |
| prvTraceStoreStringEvent(1, PSF_EVENT_OBJ_NAME, tmr->pcTimerName, tmr); \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(TIMER, tmr) & CurrentFilterMask) \ | |
| prvTraceStoreEvent2(PSF_EVENT_TIMER_CREATE, (uint32_t)tmr, tmr->xTimerPeriodInTicks); | |
| #undef traceTIMER_CREATE_FAILED | |
| #define traceTIMER_CREATE_FAILED() \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| prvTraceStoreEvent0(PSF_EVENT_TIMER_CREATE_FAILED); | |
| #if (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_8_X) | |
| #define traceTIMER_COMMAND_SEND_8_0_CASES(tmr) \ | |
| case tmrCOMMAND_RESET: \ | |
| prvTraceStoreEvent2((xReturn == pdPASS) ? PSF_EVENT_TIMER_RESET : PSF_EVENT_TIMER_RESET_FAILED, (uint32_t)tmr, xOptionalValue); \ | |
| break; \ | |
| case tmrCOMMAND_START_FROM_ISR: \ | |
| prvTraceStoreEvent2((xReturn == pdPASS) ? PSF_EVENT_TIMER_START_FROMISR : PSF_EVENT_TIMER_START_FROMISR_FAILED, (uint32_t)tmr, xOptionalValue); \ | |
| break; \ | |
| case tmrCOMMAND_RESET_FROM_ISR: \ | |
| prvTraceStoreEvent2((xReturn == pdPASS) ? PSF_EVENT_TIMER_RESET_FROMISR : PSF_EVENT_TIMER_RESET_FROMISR_FAILED, (uint32_t)tmr, xOptionalValue); \ | |
| break; \ | |
| case tmrCOMMAND_STOP_FROM_ISR: \ | |
| prvTraceStoreEvent2((xReturn == pdPASS) ? PSF_EVENT_TIMER_STOP_FROMISR : PSF_EVENT_TIMER_STOP_FROMISR_FAILED, (uint32_t)tmr, xOptionalValue); \ | |
| break; \ | |
| case tmrCOMMAND_CHANGE_PERIOD_FROM_ISR: \ | |
| prvTraceStoreEvent2((xReturn == pdPASS) ? PSF_EVENT_TIMER_CHANGEPERIOD_FROMISR : PSF_EVENT_TIMER_CHANGEPERIOD_FROMISR_FAILED, (uint32_t)tmr, xOptionalValue); \ | |
| break; | |
| #else /* TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_8_X */ | |
| #define traceTIMER_COMMAND_SEND_8_0_CASES(tmr) | |
| #endif /* TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_8_X */ | |
| /* 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) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(TIMER, tmr) & CurrentFilterMask) \ | |
| switch(xCommandID) \ | |
| { \ | |
| case tmrCOMMAND_START: \ | |
| prvTraceStoreEvent1((xReturn == pdPASS) ? PSF_EVENT_TIMER_START : PSF_EVENT_TIMER_START_FAILED, (uint32_t)tmr); \ | |
| break; \ | |
| case tmrCOMMAND_STOP: \ | |
| prvTraceStoreEvent1((xReturn == pdPASS) ? PSF_EVENT_TIMER_STOP : PSF_EVENT_TIMER_STOP_FAILED, (uint32_t)tmr); \ | |
| break; \ | |
| case tmrCOMMAND_CHANGE_PERIOD: \ | |
| prvTraceStoreEvent2((xReturn == pdPASS) ? PSF_EVENT_TIMER_CHANGEPERIOD : PSF_EVENT_TIMER_CHANGEPERIOD_FAILED, (uint32_t)tmr, xOptionalValue); \ | |
| break; \ | |
| case tmrCOMMAND_DELETE: \ | |
| prvTraceStoreEvent1((xReturn == pdPASS) ? PSF_EVENT_TIMER_DELETE : PSF_EVENT_TIMER_DELETE_FAILED, (uint32_t)tmr); \ | |
| break; \ | |
| traceTIMER_COMMAND_SEND_8_0_CASES(tmr) \ | |
| } | |
| #undef traceTIMER_EXPIRED | |
| #define traceTIMER_EXPIRED(tmr) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(TIMER, tmr) & CurrentFilterMask) \ | |
| prvTraceStoreEvent2(PSF_EVENT_TIMER_EXPIRED, (uint32_t)tmr->pxCallbackFunction, (uint32_t)tmr->pvTimerID); | |
| #endif /* #if (TRC_CFG_INCLUDE_TIMER_EVENTS == 1) */ | |
| #if (TRC_CFG_INCLUDE_PEND_FUNC_CALL_EVENTS == 1) | |
| #undef tracePEND_FUNC_CALL | |
| #define tracePEND_FUNC_CALL(func, arg1, arg2, ret) \ | |
| prvTraceStoreEvent1((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) \ | |
| prvTraceStoreEvent1((ret == pdPASS) ? PSF_EVENT_TIMER_PENDFUNCCALL_FROMISR : PSF_EVENT_TIMER_PENDFUNCCALL_FROMISR_FAILED, (uint32_t)func); | |
| #endif /* (TRC_CFG_INCLUDE_PEND_FUNC_CALL_EVENTS == 1) */ | |
| #if (TRC_CFG_INCLUDE_EVENT_GROUP_EVENTS == 1) | |
| #undef traceEVENT_GROUP_CREATE | |
| #define traceEVENT_GROUP_CREATE(eg) \ | |
| TRACE_SET_OBJECT_FILTER(EVENTGROUP, eg, CurrentFilterGroup); \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(EVENTGROUP, eg) & CurrentFilterMask) \ | |
| prvTraceStoreEvent1(PSF_EVENT_EVENTGROUP_CREATE, (uint32_t)eg); | |
| #undef traceEVENT_GROUP_DELETE | |
| #define traceEVENT_GROUP_DELETE(eg) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(EVENTGROUP, eg) & CurrentFilterMask) \ | |
| prvTraceStoreEvent1(PSF_EVENT_EVENTGROUP_DELETE, (uint32_t)eg); \ | |
| prvTraceDeleteSymbol(eg); | |
| #undef traceEVENT_GROUP_CREATE_FAILED | |
| #define traceEVENT_GROUP_CREATE_FAILED() \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| prvTraceStoreEvent0(PSF_EVENT_EVENTGROUP_CREATE_FAILED); | |
| #undef traceEVENT_GROUP_SYNC_BLOCK | |
| #define traceEVENT_GROUP_SYNC_BLOCK(eg, bitsToSet, bitsToWaitFor) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(EVENTGROUP, eg) & CurrentFilterMask) \ | |
| prvTraceStoreEvent2(PSF_EVENT_EVENTGROUP_SYNC_BLOCK, (uint32_t)eg, bitsToWaitFor); | |
| #undef traceEVENT_GROUP_SYNC_END | |
| #define traceEVENT_GROUP_SYNC_END(eg, bitsToSet, bitsToWaitFor, wasTimeout) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(EVENTGROUP, eg) & CurrentFilterMask) \ | |
| prvTraceStoreEvent2((wasTimeout != pdTRUE) ? PSF_EVENT_EVENTGROUP_SYNC : PSF_EVENT_EVENTGROUP_SYNC_FAILED, (uint32_t)eg, bitsToWaitFor); | |
| #undef traceEVENT_GROUP_WAIT_BITS_BLOCK | |
| #define traceEVENT_GROUP_WAIT_BITS_BLOCK(eg, bitsToWaitFor) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(EVENTGROUP, eg) & CurrentFilterMask) \ | |
| prvTraceStoreEvent2(PSF_EVENT_EVENTGROUP_WAITBITS_BLOCK, (uint32_t)eg, bitsToWaitFor); | |
| #undef traceEVENT_GROUP_WAIT_BITS_END | |
| #define traceEVENT_GROUP_WAIT_BITS_END(eg, bitsToWaitFor, wasTimeout) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(EVENTGROUP, eg) & CurrentFilterMask) \ | |
| prvTraceStoreEvent2((wasTimeout != pdTRUE) ? PSF_EVENT_EVENTGROUP_WAITBITS : PSF_EVENT_EVENTGROUP_WAITBITS_FAILED, (uint32_t)eg, bitsToWaitFor); | |
| #undef traceEVENT_GROUP_CLEAR_BITS | |
| #define traceEVENT_GROUP_CLEAR_BITS(eg, bitsToClear) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(EVENTGROUP, eg) & CurrentFilterMask) \ | |
| prvTraceStoreEvent2(PSF_EVENT_EVENTGROUP_CLEARBITS, (uint32_t)eg, bitsToClear); | |
| #undef traceEVENT_GROUP_CLEAR_BITS_FROM_ISR | |
| #define traceEVENT_GROUP_CLEAR_BITS_FROM_ISR(eg, bitsToClear) \ | |
| if (TRACE_GET_OBJECT_FILTER(EVENTGROUP, eg) & CurrentFilterMask) \ | |
| prvTraceStoreEvent2(PSF_EVENT_EVENTGROUP_CLEARBITS_FROMISR, (uint32_t)eg, bitsToClear); | |
| #undef traceEVENT_GROUP_SET_BITS | |
| #define traceEVENT_GROUP_SET_BITS(eg, bitsToSet) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(EVENTGROUP, eg) & CurrentFilterMask) \ | |
| prvTraceStoreEvent2(PSF_EVENT_EVENTGROUP_SETBITS, (uint32_t)eg, bitsToSet); | |
| #undef traceEVENT_GROUP_SET_BITS_FROM_ISR | |
| #define traceEVENT_GROUP_SET_BITS_FROM_ISR(eg, bitsToSet) \ | |
| if (TRACE_GET_OBJECT_FILTER(EVENTGROUP, eg) & CurrentFilterMask) \ | |
| prvTraceStoreEvent2(PSF_EVENT_EVENTGROUP_SETBITS_FROMISR, (uint32_t)eg, bitsToSet); | |
| #endif /* (TRC_CFG_INCLUDE_EVENT_GROUP_EVENTS == 1) */ | |
| #undef traceTASK_NOTIFY_TAKE | |
| #if (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_9_0_0) | |
| #define traceTASK_NOTIFY_TAKE() \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask){ \ | |
| if (pxCurrentTCB->ucNotifyState == taskNOTIFICATION_RECEIVED) \ | |
| prvTraceStoreEvent2(PSF_EVENT_TASK_NOTIFY_TAKE, (uint32_t)pxCurrentTCB, xTicksToWait); \ | |
| else \ | |
| prvTraceStoreEvent2(PSF_EVENT_TASK_NOTIFY_TAKE_FAILED, (uint32_t)pxCurrentTCB, xTicksToWait);} | |
| #else /* TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_9_0_0 */ | |
| #define traceTASK_NOTIFY_TAKE() \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask){ \ | |
| if (pxCurrentTCB->eNotifyState == eNotified) \ | |
| prvTraceStoreEvent2(PSF_EVENT_TASK_NOTIFY_TAKE, (uint32_t)pxCurrentTCB, xTicksToWait); \ | |
| else \ | |
| prvTraceStoreEvent2(PSF_EVENT_TASK_NOTIFY_TAKE_FAILED, (uint32_t)pxCurrentTCB, xTicksToWait);} | |
| #endif /* TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_9_0_0 */ | |
| #undef traceTASK_NOTIFY_TAKE_BLOCK | |
| #define traceTASK_NOTIFY_TAKE_BLOCK() \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| prvTraceStoreEvent2(PSF_EVENT_TASK_NOTIFY_TAKE_BLOCK, (uint32_t)pxCurrentTCB, xTicksToWait); | |
| #undef traceTASK_NOTIFY_WAIT | |
| #if (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_9_0_0) | |
| #define traceTASK_NOTIFY_WAIT() \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask){ \ | |
| if (pxCurrentTCB->ucNotifyState == taskNOTIFICATION_RECEIVED) \ | |
| prvTraceStoreEvent2(PSF_EVENT_TASK_NOTIFY_WAIT, (uint32_t)pxCurrentTCB, xTicksToWait); \ | |
| else \ | |
| prvTraceStoreEvent2(PSF_EVENT_TASK_NOTIFY_WAIT_FAILED, (uint32_t)pxCurrentTCB, xTicksToWait);} | |
| #else /* TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_9_0_0 */ | |
| #define traceTASK_NOTIFY_WAIT() \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask){ \ | |
| if (pxCurrentTCB->eNotifyState == eNotified) \ | |
| prvTraceStoreEvent2(PSF_EVENT_TASK_NOTIFY_WAIT, (uint32_t)pxCurrentTCB, xTicksToWait); \ | |
| else \ | |
| prvTraceStoreEvent2(PSF_EVENT_TASK_NOTIFY_WAIT_FAILED, (uint32_t)pxCurrentTCB, xTicksToWait);} | |
| #endif /* TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_9_0_0 */ | |
| #undef traceTASK_NOTIFY_WAIT_BLOCK | |
| #define traceTASK_NOTIFY_WAIT_BLOCK() \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| prvTraceStoreEvent2(PSF_EVENT_TASK_NOTIFY_WAIT_BLOCK, (uint32_t)pxCurrentTCB, xTicksToWait); | |
| #undef traceTASK_NOTIFY | |
| #define traceTASK_NOTIFY() \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, xTaskToNotify) & CurrentFilterMask) \ | |
| prvTraceStoreEvent1(PSF_EVENT_TASK_NOTIFY, (uint32_t)xTaskToNotify); | |
| #undef traceTASK_NOTIFY_FROM_ISR | |
| #define traceTASK_NOTIFY_FROM_ISR() \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, xTaskToNotify) & CurrentFilterMask) \ | |
| prvTraceStoreEvent1(PSF_EVENT_TASK_NOTIFY_FROM_ISR, (uint32_t)xTaskToNotify); | |
| #undef traceTASK_NOTIFY_GIVE_FROM_ISR | |
| #define traceTASK_NOTIFY_GIVE_FROM_ISR() \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, xTaskToNotify) & CurrentFilterMask) \ | |
| prvTraceStoreEvent1(PSF_EVENT_TASK_NOTIFY_GIVE_FROM_ISR, (uint32_t)xTaskToNotify); | |
| #undef traceQUEUE_REGISTRY_ADD | |
| #define traceQUEUE_REGISTRY_ADD(object, name) \ | |
| prvTraceSaveSymbol(object, (const char*)name); \ | |
| prvTraceStoreStringEvent(1, PSF_EVENT_OBJ_NAME, name, object); | |
| #if (TRC_CFG_INCLUDE_STREAM_BUFFER_EVENTS == 1) | |
| #undef traceSTREAM_BUFFER_CREATE | |
| #define traceSTREAM_BUFFER_CREATE( pxStreamBuffer, xIsMessageBuffer ) \ | |
| TRACE_SET_OBJECT_FILTER(STREAMBUFFER, pxStreamBuffer, CurrentFilterGroup); \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(STREAMBUFFER, pxStreamBuffer) & CurrentFilterMask) \ | |
| prvTraceStoreEvent2(xIsMessageBuffer == 1 ? PSF_EVENT_MESSAGEBUFFER_CREATE : PSF_EVENT_STREAMBUFFER_CREATE, (uint32_t)pxStreamBuffer, xBufferSizeBytes); | |
| #undef traceSTREAM_BUFFER_CREATE_FAILED | |
| #define traceSTREAM_BUFFER_CREATE_FAILED( xIsMessageBuffer ) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| prvTraceStoreEvent2(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 ) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(STREAMBUFFER, pxStreamBuffer) & CurrentFilterMask) \ | |
| prvTraceStoreEvent2(prvGetStreamBufferType(xStreamBuffer) > 0 ? PSF_EVENT_MESSAGEBUFFER_DELETE : PSF_EVENT_STREAMBUFFER_DELETE, (uint32_t)xStreamBuffer, prvBytesInBuffer(xStreamBuffer)); \ | |
| prvTraceDeleteSymbol(xStreamBuffer); | |
| #undef traceSTREAM_BUFFER_RESET | |
| #define traceSTREAM_BUFFER_RESET( xStreamBuffer ) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(STREAMBUFFER, xStreamBuffer) & CurrentFilterMask) \ | |
| prvTraceStoreEvent2(prvGetStreamBufferType(xStreamBuffer) > 0 ? PSF_EVENT_MESSAGEBUFFER_RESET : PSF_EVENT_STREAMBUFFER_RESET, (uint32_t)xStreamBuffer, 0); | |
| #undef traceSTREAM_BUFFER_SEND | |
| #define traceSTREAM_BUFFER_SEND( xStreamBuffer, xReturn ) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(STREAMBUFFER, xStreamBuffer) & CurrentFilterMask) \ | |
| prvTraceStoreEvent2(prvGetStreamBufferType(xStreamBuffer) > 0 ? PSF_EVENT_MESSAGEBUFFER_SEND : PSF_EVENT_STREAMBUFFER_SEND, (uint32_t)xStreamBuffer, prvBytesInBuffer(xStreamBuffer)); | |
| #undef traceBLOCKING_ON_STREAM_BUFFER_SEND | |
| #define traceBLOCKING_ON_STREAM_BUFFER_SEND( xStreamBuffer ) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(STREAMBUFFER, xStreamBuffer) & CurrentFilterMask) \ | |
| prvTraceStoreEvent1(prvGetStreamBufferType(xStreamBuffer) > 0 ? PSF_EVENT_MESSAGEBUFFER_SEND_BLOCK : PSF_EVENT_STREAMBUFFER_SEND_BLOCK, (uint32_t)xStreamBuffer); | |
| #undef traceSTREAM_BUFFER_SEND_FAILED | |
| #define traceSTREAM_BUFFER_SEND_FAILED( xStreamBuffer ) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(STREAMBUFFER, xStreamBuffer) & CurrentFilterMask) \ | |
| prvTraceStoreEvent1(prvGetStreamBufferType(xStreamBuffer) > 0 ? PSF_EVENT_MESSAGEBUFFER_SEND_FAILED : PSF_EVENT_STREAMBUFFER_SEND_FAILED, (uint32_t)xStreamBuffer); | |
| #undef traceSTREAM_BUFFER_RECEIVE | |
| #define traceSTREAM_BUFFER_RECEIVE( xStreamBuffer, xReceivedLength ) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(STREAMBUFFER, xStreamBuffer) & CurrentFilterMask) \ | |
| prvTraceStoreEvent2(prvGetStreamBufferType(xStreamBuffer) > 0 ? PSF_EVENT_MESSAGEBUFFER_RECEIVE: PSF_EVENT_STREAMBUFFER_RECEIVE, (uint32_t)xStreamBuffer, prvBytesInBuffer(xStreamBuffer)); | |
| #undef traceBLOCKING_ON_STREAM_BUFFER_RECEIVE | |
| #define traceBLOCKING_ON_STREAM_BUFFER_RECEIVE( xStreamBuffer ) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(STREAMBUFFER, xStreamBuffer) & CurrentFilterMask) \ | |
| prvTraceStoreEvent1(prvGetStreamBufferType(xStreamBuffer) > 0 ? PSF_EVENT_MESSAGEBUFFER_RECEIVE_BLOCK: PSF_EVENT_STREAMBUFFER_RECEIVE_BLOCK, (uint32_t)xStreamBuffer); | |
| #undef traceSTREAM_BUFFER_RECEIVE_FAILED | |
| #define traceSTREAM_BUFFER_RECEIVE_FAILED( xStreamBuffer ) \ | |
| if (TRACE_GET_OBJECT_FILTER(TASK, TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) \ | |
| if (TRACE_GET_OBJECT_FILTER(STREAMBUFFER, xStreamBuffer) & CurrentFilterMask) \ | |
| prvTraceStoreEvent1(prvGetStreamBufferType(xStreamBuffer) > 0 ? PSF_EVENT_MESSAGEBUFFER_RECEIVE_FAILED: PSF_EVENT_STREAMBUFFER_RECEIVE_FAILED, (uint32_t)xStreamBuffer); | |
| #undef traceSTREAM_BUFFER_SEND_FROM_ISR | |
| #define traceSTREAM_BUFFER_SEND_FROM_ISR( xStreamBuffer, xReturn ) \ | |
| if (TRACE_GET_OBJECT_FILTER(STREAMBUFFER, xStreamBuffer) & CurrentFilterMask) \ | |
| { \ | |
| if ( xReturn > ( size_t ) 0 ) \ | |
| { \ | |
| prvTraceStoreEvent2(prvGetStreamBufferType(xStreamBuffer) > 0 ? PSF_EVENT_MESSAGEBUFFER_SEND_FROM_ISR : PSF_EVENT_STREAMBUFFER_SEND_FROM_ISR, (uint32_t)xStreamBuffer, prvBytesInBuffer(xStreamBuffer)); \ | |
| } \ | |
| else \ | |
| { \ | |
| prvTraceStoreEvent1(prvGetStreamBufferType(xStreamBuffer) > 0 ? PSF_EVENT_MESSAGEBUFFER_SEND_FROM_ISR_FAILED : PSF_EVENT_STREAMBUFFER_SEND_FROM_ISR_FAILED, (uint32_t)xStreamBuffer); \ | |
| } \ | |
| } | |
| #undef traceSTREAM_BUFFER_RECEIVE_FROM_ISR | |
| #define traceSTREAM_BUFFER_RECEIVE_FROM_ISR( xStreamBuffer, xReceivedLength ) \ | |
| if (TRACE_GET_OBJECT_FILTER(STREAMBUFFER, xStreamBuffer) & CurrentFilterMask) \ | |
| { \ | |
| if ( xReceivedLength > ( size_t ) 0 ) \ | |
| { \ | |
| prvTraceStoreEvent2(prvGetStreamBufferType(xStreamBuffer) > 0 ? PSF_EVENT_MESSAGEBUFFER_RECEIVE_FROM_ISR : PSF_EVENT_STREAMBUFFER_RECEIVE_FROM_ISR, (uint32_t)xStreamBuffer, prvBytesInBuffer(xStreamBuffer)); \ | |
| } \ | |
| else \ | |
| { \ | |
| prvTraceStoreEvent1(prvGetStreamBufferType(xStreamBuffer) > 0 ? PSF_EVENT_MESSAGEBUFFER_RECEIVE_FROM_ISR_FAILED : PSF_EVENT_STREAMBUFFER_RECEIVE_FROM_ISR_FAILED, (uint32_t)xStreamBuffer); \ | |
| } \ | |
| } | |
| #endif /* (TRC_CFG_INCLUDE_STREAM_BUFFER_EVENTS == 1) */ | |
| #endif /* (TRC_CFG_SCHEDULING_ONLY == 0) */ | |
| #endif /* (TRC_CFG_RECORDER_MODE == TRC_RECORDER_MODE_STREAMING) */ | |
| #else /* (TRC_USE_TRACEALYZER_RECORDER == 1) */ | |
| /* 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 /* (TRC_USE_TRACEALYZER_RECORDER == 1) */ | |
| #ifdef __cplusplus | |
| } | |
| #endif | |
| #endif /* TRC_KERNEL_PORT_H */ |