| /******************************************************************************* | |
| * Trace Recorder Library for Tracealyzer v3.0.2 | |
| * Percepio AB, www.percepio.com | |
| * | |
| * trcKernelPort.h | |
| * | |
| * The kernel-specific definitions for FreeRTOS. | |
| * | |
| * Terms of Use | |
| * This software (the "Tracealyzer Recorder Library") is the intellectual | |
| * property of Percepio AB and may not be sold or in other ways commercially | |
| * redistributed without explicit written permission by Percepio AB. | |
| * | |
| * Separate conditions applies for the SEGGER branded source code included. | |
| * | |
| * The recorder library is free for use together with Percepio products. | |
| * You may distribute the recorder library in its original form, but public | |
| * distribution of modified versions require approval by Percepio AB. | |
| * | |
| * Disclaimer | |
| * The trace tool and recorder library is being delivered to you AS IS and | |
| * Percepio AB makes no warranty as to its use or performance. Percepio AB does | |
| * not and cannot warrant the performance or results you may obtain by using the | |
| * software or documentation. Percepio AB 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 AB, 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 AB 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. | |
| * | |
| * Tabs are used for indent in this file (1 tab = 4 spaces) | |
| * | |
| * Copyright Percepio AB, 2015. | |
| * www.percepio.com | |
| ******************************************************************************/ | |
| #ifndef TRC_KERNEL_PORT_H | |
| #define TRC_KERNEL_PORT_H | |
| #ifdef __cplusplus | |
| extern C { | |
| #endif | |
| #include "FreeRTOS.h" /* Defines configUSE_TRACE_FACILITY */ | |
| #include "trcConfig.h" | |
| #include "trcHardwarePort.h" | |
| extern int uiInEventGroupSetBitsFromISR; | |
| #define USE_TRACEALYZER_RECORDER configUSE_TRACE_FACILITY | |
| #if (USE_TRACEALYZER_RECORDER == 1) | |
| /******************************************************************************* | |
| * Trace_Init | |
| * | |
| * The main initalization routine for the embOS-Trace recorder. Configures RTT, | |
| * activates the PTRACE instrumentation in embOS and the TzCtrl task. | |
| * Also sets up the diagnostic User Event channels used by TzCtrl task. | |
| * | |
| * Settings used by the trace recorder are found in these header files: | |
| * - SEGGER_RTT_Conf.h: settings for SEGGER Real-Time Terminal (RTT) which is | |
| * used for the trace streaming. | |
| * - trcKernelPort.h: RTT related settings for the trace streaming. | |
| * - trcRecorder.h - settings for allocation of internal recorder tables. | |
| * - trcHardwarePort.h - hardware-specific configuration (timestamping). | |
| ******************************************************************************/ | |
| void Trace_Init(void); | |
| /******************************************************************************* | |
| * vTraceOnTraceBegin | |
| * | |
| * Called on trace begin. | |
| ******************************************************************************/ | |
| void vTraceOnTraceBegin(void); | |
| /******************************************************************************* | |
| * vTraceOnTraceEnd | |
| * | |
| * Called on trace end. | |
| ******************************************************************************/ | |
| void vTraceOnTraceEnd(void); | |
| #include "trcRecorder.h" | |
| /* Defines that must be set for the recorder to work properly */ | |
| #define KERNEL_ID 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" */ | |
| #if (TRC_RECORDER_HARDWARE_PORT == TRC_PORT_ARM_Cortex_M) | |
| /* Uses CMSIS API. Must be #included in trcConfig.h. */ | |
| #define TRACE_ALLOC_CRITICAL_SECTION() int __irq_status; | |
| #define TRACE_ENTER_CRITICAL_SECTION() {__irq_status = __get_PRIMASK(); __set_PRIMASK(1);} | |
| #define TRACE_EXIT_CRITICAL_SECTION() {__set_PRIMASK(__irq_status);} | |
| #endif | |
| #if ((TRC_RECORDER_HARDWARE_PORT == TRC_PORT_ARM_CORTEX_A9) || (TRC_RECORDER_HARDWARE_PORT == TRC_PORT_Renesas_RX600)) | |
| #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 | |
| #ifndef TRACE_ENTER_CRITICAL_SECTION | |
| #error "This port has no valid definition for critical sections! See http://percepio.com/2014/10/27/how-to-define-critical-sections-for-the-recorder/" | |
| #endif | |
| void* prvTraceGetCurrentTaskHandle(void); | |
| uint32_t prvIsNewTCB(void* pNewTCB); | |
| #define OS_IS_SWITCH_FROM_INT_REQUIRED() 0 | |
| #define TRACE_GET_CURRENT_TASK() prvTraceGetCurrentTaskHandle() | |
| /*************************************************************************/ | |
| /* KERNEL SPECIFIC OBJECT CONFIGURATION */ | |
| /*************************************************************************/ | |
| /******************************************************************************* | |
| * The event codes - should match the offline config file. | |
| * | |
| * Some sections below are encoded to allow for constructions like: | |
| * | |
| * vTraceStoreKernelCall(EVENTGROUP_CREATE + objectclass, ... | |
| * | |
| * The object class ID is given by the three LSB bits, in such cases. Since each | |
| * object class has a separate object property table, the class ID is needed to | |
| * know what section in the object table to use for getting an object name from | |
| * an object handle. | |
| ******************************************************************************/ | |
| #define PSF_EVENT_NULL_EVENT 0x00 | |
| /* PSF event codes */ | |
| #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_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_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_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 /* Will never be used */ | |
| #define PSF_EVENT_MUTEX_PEEK 0x72 /* Will never be used */ | |
| #define PSF_EVENT_QUEUE_PEEK_FAILED 0x73 | |
| #define PSF_EVENT_SEMAPHORE_PEEK_FAILED 0x74 /* Will never be used */ | |
| #define PSF_EVENT_MUTEX_PEEK_FAILED 0x75 /* Will never be used */ | |
| #define PSF_EVENT_QUEUE_PEEK_BLOCK 0x76 | |
| #define PSF_EVENT_SEMAPHORE_PEEK_BLOCK 0x77 /* Will never be used */ | |
| #define PSF_EVENT_MUTEX_PEEK_BLOCK 0x78 /* Will never be used */ | |
| #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 TRACE_GET_OS_TICKS() (uiTraceTickCount) | |
| /************************************************************************/ | |
| /* KERNEL SPECIFIC DATA AND FUNCTIONS NEEDED TO PROVIDE THE */ | |
| /* FUNCTIONALITY REQUESTED BY THE TRACE RECORDER */ | |
| /************************************************************************/ | |
| #if (configUSE_TIMERS == 1) | |
| #undef INCLUDE_xTimerGetTimerDaemonTaskHandle | |
| #define INCLUDE_xTimerGetTimerDaemonTaskHandle 1 | |
| #endif | |
| /************************************************************************/ | |
| /* KERNEL SPECIFIC MACROS USED BY THE TRACE RECORDER */ | |
| /************************************************************************/ | |
| #define TRACE_MALLOC(size) pvPortMalloc(size) | |
| /************************************************************************/ | |
| /* KERNEL SPECIFIC WRAPPERS THAT SHOULD BE CALLED BY THE KERNEL */ | |
| /************************************************************************/ | |
| #if (configUSE_TICKLESS_IDLE != 0) | |
| #undef traceLOW_POWER_IDLE_BEGIN | |
| #define traceLOW_POWER_IDLE_BEGIN() \ | |
| { \ | |
| vTraceStoreEvent0(PSF_EVENT_LOWPOWER_BEGIN); \ | |
| } | |
| #undef traceLOW_POWER_IDLE_END | |
| #define traceLOW_POWER_IDLE_END() \ | |
| { \ | |
| vTraceStoreEvent0(PSF_EVENT_LOWPOWER_END); \ | |
| } | |
| #endif | |
| /* 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 ) | |
| /* Called for each task that becomes ready */ | |
| #undef traceMOVED_TASK_TO_READY_STATE | |
| #define traceMOVED_TASK_TO_READY_STATE( pxTCB ) \ | |
| vTraceStoreEvent1(PSF_EVENT_TASK_READY, (uint32_t)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_FREERTOS_VERSION == TRC_FREERTOS_VERSION_7_3_OR_7_4) | |
| #define traceTASK_INCREMENT_TICK( xTickCount ) \ | |
| if (uxSchedulerSuspended == ( unsigned portBASE_TYPE ) pdTRUE || uxMissedTicks == 0) { extern uint32_t uiTraceTickCount; uiTraceTickCount++; } \ | |
| if (uxSchedulerSuspended == ( unsigned portBASE_TYPE ) pdFALSE) { vTraceStoreEvent1(PSF_EVENT_NEW_TIME, (xTickCount + 1)); } | |
| #else | |
| #define traceTASK_INCREMENT_TICK( xTickCount ) \ | |
| if (uxSchedulerSuspended == ( unsigned portBASE_TYPE ) pdTRUE || uxPendedTicks == 0) { extern uint32_t uiTraceTickCount; uiTraceTickCount++; } \ | |
| if (uxSchedulerSuspended == ( unsigned portBASE_TYPE ) pdFALSE) { vTraceStoreEvent1(PSF_EVENT_NEW_TIME, (xTickCount + 1)); } | |
| #endif | |
| /* Called on each task-switch */ | |
| #undef traceTASK_SWITCHED_IN | |
| #define traceTASK_SWITCHED_IN() \ | |
| if (prvIsNewTCB(pxCurrentTCB)) \ | |
| { \ | |
| vTraceStoreEvent2(PSF_EVENT_TASK_ACTIVATE, (uint32_t)pxCurrentTCB, pxCurrentTCB->uxPriority); \ | |
| } | |
| /* Called on vTaskSuspend */ | |
| #undef traceTASK_SUSPEND | |
| #define traceTASK_SUSPEND( pxTaskToSuspend ) \ | |
| vTraceStoreEvent1(PSF_EVENT_TASK_SUSPEND, (uint32_t)pxTaskToSuspend); | |
| /* Called on vTaskDelay - note the use of FreeRTOS variable xTicksToDelay */ | |
| #undef traceTASK_DELAY | |
| #define traceTASK_DELAY() \ | |
| vTraceStoreEvent1(PSF_EVENT_TASK_DELAY, xTicksToDelay); | |
| /* Called on vTaskDelayUntil - note the use of FreeRTOS variable xTimeToWake */ | |
| #undef traceTASK_DELAY_UNTIL | |
| #define traceTASK_DELAY_UNTIL() \ | |
| vTraceStoreEvent1(PSF_EVENT_TASK_DELAY_UNTIL, xTimeToWake); | |
| /* Called on vTaskDelete */ | |
| #undef traceTASK_DELETE | |
| #define traceTASK_DELETE( pxTaskToDelete ) \ | |
| vTraceStoreEvent2(PSF_EVENT_TASK_DELETE, (uint32_t)pxTaskToDelete, (pxTaskToDelete != NULL) ? (pxTaskToDelete->uxPriority) : 0); | |
| /* Called on vQueueDelete */ | |
| #undef traceQUEUE_DELETE | |
| #define traceQUEUE_DELETE( pxQueue ) \ | |
| switch (pxQueue->ucQueueType) \ | |
| { \ | |
| case queueQUEUE_TYPE_BASE: \ | |
| vTraceStoreEvent2(PSF_EVENT_QUEUE_DELETE, (uint32_t)pxQueue, (pxQueue != NULL) ? (pxQueue->uxMessagesWaiting) : 0); \ | |
| break; \ | |
| case queueQUEUE_TYPE_MUTEX: \ | |
| case queueQUEUE_TYPE_RECURSIVE_MUTEX: \ | |
| vTraceStoreEvent2(PSF_EVENT_MUTEX_DELETE, (uint32_t)pxQueue, (pxQueue != NULL) ? (pxQueue->uxMessagesWaiting) : 0); \ | |
| break; \ | |
| case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \ | |
| case queueQUEUE_TYPE_BINARY_SEMAPHORE: \ | |
| vTraceStoreEvent2(PSF_EVENT_SEMAPHORE_DELETE, (uint32_t)pxQueue, (pxQueue != NULL) ? (pxQueue->uxMessagesWaiting) : 0); \ | |
| break; \ | |
| } | |
| /* Called on vTaskCreate */ | |
| #undef traceTASK_CREATE | |
| #define traceTASK_CREATE(pxNewTCB) \ | |
| if (pxNewTCB != NULL) \ | |
| { \ | |
| vTraceSaveSymbol(pxNewTCB, (const char*)pcName); \ | |
| vTraceSaveObjectData(pxNewTCB, uxPriority); \ | |
| vTraceStoreStringEvent(1, PSF_EVENT_OBJ_NAME, pcName, pxNewTCB); \ | |
| vTraceStoreEvent2(PSF_EVENT_TASK_CREATE, (uint32_t)pxNewTCB, uxPriority); \ | |
| } | |
| /* Called in vTaskCreate, if it fails (typically if the stack can not be allocated) */ | |
| #undef traceTASK_CREATE_FAILED | |
| #define traceTASK_CREATE_FAILED() \ | |
| vTraceStoreEvent0(PSF_EVENT_TASK_CREATE_FAILED); | |
| /* Called in xQueueCreate, and thereby for all other object based on queues, such as semaphores. */ | |
| #undef traceQUEUE_CREATE | |
| #define traceQUEUE_CREATE( pxNewQueue )\ | |
| switch (pxNewQueue->ucQueueType) \ | |
| { \ | |
| case queueQUEUE_TYPE_BASE: \ | |
| vTraceStoreEvent2(PSF_EVENT_QUEUE_CREATE, (uint32_t)pxNewQueue, pxNewQueue->uxLength); \ | |
| break; \ | |
| case queueQUEUE_TYPE_BINARY_SEMAPHORE: \ | |
| vTraceStoreEvent1(PSF_EVENT_SEMAPHORE_BINARY_CREATE, (uint32_t)pxNewQueue); \ | |
| break; \ | |
| } | |
| /* Called in xQueueCreate, if the queue creation fails */ | |
| #undef traceQUEUE_CREATE_FAILED | |
| #define traceQUEUE_CREATE_FAILED( queueType ) \ | |
| switch (queueType) \ | |
| { \ | |
| case queueQUEUE_TYPE_BASE: \ | |
| vTraceStoreEvent0(PSF_EVENT_QUEUE_CREATE_FAILED); \ | |
| break; \ | |
| case queueQUEUE_TYPE_BINARY_SEMAPHORE: \ | |
| vTraceStoreEvent0(PSF_EVENT_SEMAPHORE_BINARY_CREATE_FAILED); \ | |
| break; \ | |
| } | |
| /* Called in xQueueCreateCountingSemaphore, if the queue creation fails */ | |
| #undef traceCREATE_COUNTING_SEMAPHORE | |
| #if TRC_FREERTOS_VERSION == TRC_FREERTOS_VERSION_8_0_OR_LATER | |
| #define traceCREATE_COUNTING_SEMAPHORE() \ | |
| vTraceStoreEvent2(PSF_EVENT_SEMAPHORE_COUNTING_CREATE, (uint32_t)xHandle, ((Queue_t *) xHandle)->uxMessagesWaiting); | |
| #else | |
| #define traceCREATE_COUNTING_SEMAPHORE() \ | |
| vTraceStoreEvent2(PSF_EVENT_SEMAPHORE_COUNTING_CREATE, (uint32_t)pxHandle, pxHandle->uxMessagesWaiting); | |
| #endif | |
| #undef traceCREATE_COUNTING_SEMAPHORE_FAILED | |
| #define traceCREATE_COUNTING_SEMAPHORE_FAILED() \ | |
| vTraceStoreEvent0(PSF_EVENT_SEMAPHORE_COUNTING_CREATE_FAILED); | |
| /* Called in xQueueCreateMutex, and thereby also from xSemaphoreCreateMutex and xSemaphoreCreateRecursiveMutex */ | |
| #undef traceCREATE_MUTEX | |
| #define traceCREATE_MUTEX( pxNewQueue ) \ | |
| switch (ucQueueType) \ | |
| { \ | |
| case queueQUEUE_TYPE_MUTEX: \ | |
| vTraceStoreEvent1(PSF_EVENT_MUTEX_CREATE, (uint32_t)pxNewQueue); \ | |
| break; \ | |
| case queueQUEUE_TYPE_RECURSIVE_MUTEX: \ | |
| vTraceStoreEvent1(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() \ | |
| switch (ucQueueType) \ | |
| { \ | |
| case queueQUEUE_TYPE_MUTEX: \ | |
| vTraceStoreEvent0(PSF_EVENT_MUTEX_CREATE_FAILED); \ | |
| break; \ | |
| case queueQUEUE_TYPE_RECURSIVE_MUTEX: \ | |
| vTraceStoreEvent0(PSF_EVENT_MUTEX_CREATE_FAILED); \ | |
| break; \ | |
| } | |
| /* Called when a message is sent to a queue */ /* CS IS NEW ! */ | |
| #undef traceQUEUE_SEND | |
| #define traceQUEUE_SEND( pxQueue ) \ | |
| switch (pxQueue->ucQueueType) \ | |
| { \ | |
| case queueQUEUE_TYPE_BASE: \ | |
| vTraceStoreEvent2(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: \ | |
| vTraceStoreEvent2(PSF_EVENT_SEMAPHORE_GIVE, (uint32_t)pxQueue, pxQueue->uxMessagesWaiting + 1); \ | |
| break; \ | |
| case queueQUEUE_TYPE_MUTEX: \ | |
| case queueQUEUE_TYPE_RECURSIVE_MUTEX: \ | |
| vTraceStoreEvent1(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 ) \ | |
| switch (pxQueue->ucQueueType) \ | |
| { \ | |
| case queueQUEUE_TYPE_BASE: \ | |
| vTraceStoreEvent2(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: \ | |
| vTraceStoreEvent2(PSF_EVENT_SEMAPHORE_GIVE_FAILED, (uint32_t)pxQueue, pxQueue->uxMessagesWaiting); \ | |
| break; \ | |
| case queueQUEUE_TYPE_MUTEX: \ | |
| case queueQUEUE_TYPE_RECURSIVE_MUTEX: \ | |
| vTraceStoreEvent1(PSF_EVENT_MUTEX_GIVE_FAILED, (uint32_t)pxQueue); \ | |
| break; \ | |
| } | |
| /*trcKERNEL_HOOKS_KERNEL_SERVICE(SEND, FAILED, UNUSED, 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 ) \ | |
| switch (pxQueue->ucQueueType) \ | |
| { \ | |
| case queueQUEUE_TYPE_BASE: \ | |
| vTraceStoreEvent2(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: \ | |
| vTraceStoreEvent2(PSF_EVENT_SEMAPHORE_GIVE_BLOCK, (uint32_t)pxQueue, pxQueue->uxMessagesWaiting); \ | |
| break; \ | |
| case queueQUEUE_TYPE_MUTEX: \ | |
| case queueQUEUE_TYPE_RECURSIVE_MUTEX: \ | |
| vTraceStoreEvent1(PSF_EVENT_MUTEX_GIVE_BLOCK, (uint32_t)pxQueue); \ | |
| break; \ | |
| } | |
| /* Called for Recursive Mutex */ | |
| #undef traceGIVE_MUTEX_RECURSIVE | |
| #define traceGIVE_MUTEX_RECURSIVE( pxMutex ) \ | |
| vTraceStoreEvent1(PSF_EVENT_MUTEX_GIVE_RECURSIVE, (uint32_t)pxMutex); | |
| /* Called for Recursive Mutex */ | |
| #undef traceGIVE_MUTEX_RECURSIVE_FAILED | |
| #define traceGIVE_MUTEX_RECURSIVE_FAILED( pxMutex ) \ | |
| vTraceStoreEvent1(PSF_EVENT_MUTEX_GIVE_RECURSIVE_FAILED, (uint32_t)pxMutex); | |
| /**************************************************************************/ | |
| /* Hack to make 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 hack */ | |
| /**************************************************************************/ | |
| /* Called when a message is sent from interrupt context, e.g., using xQueueSendFromISR */ | |
| #undef traceQUEUE_SEND_FROM_ISR | |
| #define traceQUEUE_SEND_FROM_ISR( pxQueue ) \ | |
| switch (pxQueue->ucQueueType) \ | |
| { \ | |
| case queueQUEUE_TYPE_BASE: \ | |
| vTraceStoreEvent2(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: \ | |
| vTraceStoreEvent2(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 ) \ | |
| switch (pxQueue->ucQueueType) \ | |
| { \ | |
| case queueQUEUE_TYPE_BASE: \ | |
| vTraceStoreEvent2(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: \ | |
| vTraceStoreEvent2(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 ) \ | |
| switch (pxQueue->ucQueueType) \ | |
| { \ | |
| case queueQUEUE_TYPE_BASE: \ | |
| vTraceStoreEvent3(PSF_EVENT_QUEUE_RECEIVE, (uint32_t)pxQueue, xTicksToWait, pxQueue->uxMessagesWaiting - 1); \ | |
| break; \ | |
| case queueQUEUE_TYPE_BINARY_SEMAPHORE: \ | |
| case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \ | |
| vTraceStoreEvent3(PSF_EVENT_SEMAPHORE_TAKE, (uint32_t)pxQueue, xTicksToWait, pxQueue->uxMessagesWaiting - 1); \ | |
| break; \ | |
| case queueQUEUE_TYPE_MUTEX: \ | |
| case queueQUEUE_TYPE_RECURSIVE_MUTEX: \ | |
| vTraceStoreEvent2(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 ) \ | |
| switch (pxQueue->ucQueueType) \ | |
| { \ | |
| case queueQUEUE_TYPE_BASE: \ | |
| vTraceStoreEvent3(xJustPeeking == pdFALSE ? PSF_EVENT_QUEUE_RECEIVE_FAILED : PSF_EVENT_QUEUE_PEEK_FAILED, (uint32_t)pxQueue, xTicksToWait, pxQueue->uxMessagesWaiting); \ | |
| break; \ | |
| case queueQUEUE_TYPE_BINARY_SEMAPHORE: \ | |
| case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \ | |
| vTraceStoreEvent3(xJustPeeking == pdFALSE ? PSF_EVENT_SEMAPHORE_TAKE_FAILED : PSF_EVENT_SEMAPHORE_PEEK_FAILED, (uint32_t)pxQueue, xTicksToWait, pxQueue->uxMessagesWaiting); \ | |
| break; \ | |
| case queueQUEUE_TYPE_MUTEX: \ | |
| case queueQUEUE_TYPE_RECURSIVE_MUTEX: \ | |
| vTraceStoreEvent2(xJustPeeking == pdFALSE ? PSF_EVENT_MUTEX_TAKE_FAILED : PSF_EVENT_MUTEX_PEEK_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 ) \ | |
| switch (pxQueue->ucQueueType) \ | |
| { \ | |
| case queueQUEUE_TYPE_BASE: \ | |
| vTraceStoreEvent3(xJustPeeking == pdFALSE ? PSF_EVENT_QUEUE_RECEIVE_BLOCK : PSF_EVENT_QUEUE_PEEK_BLOCK, (uint32_t)pxQueue, xTicksToWait, pxQueue->uxMessagesWaiting); \ | |
| break; \ | |
| case queueQUEUE_TYPE_BINARY_SEMAPHORE: \ | |
| case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \ | |
| vTraceStoreEvent3(xJustPeeking == pdFALSE ? PSF_EVENT_SEMAPHORE_TAKE_BLOCK : PSF_EVENT_SEMAPHORE_PEEK_BLOCK, (uint32_t)pxQueue, xTicksToWait, pxQueue->uxMessagesWaiting); \ | |
| break; \ | |
| case queueQUEUE_TYPE_MUTEX: \ | |
| case queueQUEUE_TYPE_RECURSIVE_MUTEX: \ | |
| vTraceStoreEvent2(xJustPeeking == pdFALSE ? PSF_EVENT_MUTEX_TAKE_BLOCK : PSF_EVENT_MUTEX_PEEK_BLOCK, (uint32_t)pxQueue, xTicksToWait); \ | |
| break; \ | |
| } | |
| #undef traceTAKE_MUTEX_RECURSIVE | |
| #if TRC_FREERTOS_VERSION == TRC_FREERTOS_VERSION_8_0_OR_LATER | |
| #define traceTAKE_MUTEX_RECURSIVE( pxQueue ) \ | |
| vTraceStoreEvent2(PSF_EVENT_MUTEX_TAKE_RECURSIVE, (uint32_t)pxQueue, xTicksToWait); | |
| #else | |
| #define traceTAKE_MUTEX_RECURSIVE( pxQueue ) \ | |
| vTraceStoreEvent2(PSF_EVENT_MUTEX_TAKE_RECURSIVE, (uint32_t)pxQueue, xBlockTime); | |
| #endif | |
| #undef traceTAKE_MUTEX_RECURSIVE_FAILED | |
| #if TRC_FREERTOS_VERSION == TRC_FREERTOS_VERSION_8_0_OR_LATER | |
| #define traceTAKE_MUTEX_RECURSIVE_FAILED( pxQueue ) \ | |
| vTraceStoreEvent2(PSF_EVENT_MUTEX_TAKE_RECURSIVE_FAILED, (uint32_t)pxQueue, xTicksToWait); | |
| #else | |
| #define traceTAKE_MUTEX_RECURSIVE_FAILED( pxQueue ) \ | |
| vTraceStoreEvent2(PSF_EVENT_MUTEX_TAKE_RECURSIVE_FAILED, (uint32_t)pxQueue, xBlockTime); | |
| #endif | |
| /* Called when a message is received in interrupt context, e.g., using xQueueReceiveFromISR */ | |
| #undef traceQUEUE_RECEIVE_FROM_ISR | |
| #define traceQUEUE_RECEIVE_FROM_ISR( pxQueue ) \ | |
| switch (pxQueue->ucQueueType) \ | |
| { \ | |
| case queueQUEUE_TYPE_BASE: \ | |
| vTraceStoreEvent2(PSF_EVENT_QUEUE_RECEIVE_FROMISR, (uint32_t)pxQueue, pxQueue->uxMessagesWaiting - 1); \ | |
| break; \ | |
| case queueQUEUE_TYPE_BINARY_SEMAPHORE: \ | |
| case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \ | |
| vTraceStoreEvent2(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 ) \ | |
| switch (pxQueue->ucQueueType) \ | |
| { \ | |
| case queueQUEUE_TYPE_BASE: \ | |
| vTraceStoreEvent2(PSF_EVENT_QUEUE_RECEIVE_FROMISR_FAILED, (uint32_t)pxQueue, pxQueue->uxMessagesWaiting); \ | |
| break; \ | |
| case queueQUEUE_TYPE_BINARY_SEMAPHORE: \ | |
| case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \ | |
| vTraceStoreEvent2(PSF_EVENT_SEMAPHORE_TAKE_FROMISR_FAILED, (uint32_t)pxQueue, pxQueue->uxMessagesWaiting); \ | |
| break; \ | |
| } | |
| /* Called on xQueuePeek */ | |
| #undef traceQUEUE_PEEK | |
| #define traceQUEUE_PEEK( pxQueue ) \ | |
| switch (pxQueue->ucQueueType) \ | |
| { \ | |
| case queueQUEUE_TYPE_BASE: \ | |
| vTraceStoreEvent3(PSF_EVENT_QUEUE_PEEK, (uint32_t)pxQueue, xTicksToWait, pxQueue->uxMessagesWaiting); \ | |
| break; \ | |
| case queueQUEUE_TYPE_BINARY_SEMAPHORE: \ | |
| case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \ | |
| vTraceStoreEvent3(PSF_EVENT_SEMAPHORE_PEEK, (uint32_t)pxQueue, xTicksToWait, pxQueue->uxMessagesWaiting); \ | |
| break; \ | |
| case queueQUEUE_TYPE_MUTEX: \ | |
| case queueQUEUE_TYPE_RECURSIVE_MUTEX: \ | |
| vTraceStoreEvent1(PSF_EVENT_MUTEX_PEEK, (uint32_t)pxQueue); \ | |
| break; \ | |
| } | |
| /* Called in vTaskPrioritySet */ | |
| #undef traceTASK_PRIORITY_SET | |
| #define traceTASK_PRIORITY_SET( pxTask, uxNewPriority ) \ | |
| vTraceStoreEvent2(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 ) \ | |
| vTraceStoreEvent2(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 ) \ | |
| vTraceStoreEvent2(PSF_EVENT_TASK_PRIO_DISINHERIT, (uint32_t)pxTask, uxNewPriority); | |
| /* Called in vTaskResume */ | |
| #undef traceTASK_RESUME | |
| #define traceTASK_RESUME( pxTaskToResume ) \ | |
| vTraceStoreEvent1(PSF_EVENT_TASK_RESUME, (uint32_t)pxTaskToResume); | |
| /* Called in vTaskResumeFromISR */ | |
| #undef traceTASK_RESUME_FROM_ISR | |
| #define traceTASK_RESUME_FROM_ISR( pxTaskToResume ) \ | |
| vTraceStoreEvent1(PSF_EVENT_TASK_RESUME_FROMISR, (uint32_t)pxTaskToResume); | |
| #undef traceMALLOC | |
| #define traceMALLOC( pvAddress, uiSize ) \ | |
| vTraceStoreEvent2(PSF_EVENT_MALLOC, (uint32_t)pvAddress, (int32_t)uiSize); | |
| #undef traceFREE | |
| #define traceFREE( pvAddress, uiSize ) \ | |
| vTraceStoreEvent2(PSF_EVENT_FREE, (uint32_t)pvAddress, (int32_t)(-uiSize)); | |
| /* Called in timer.c - xTimerCreate */ | |
| #undef traceTIMER_CREATE | |
| #define traceTIMER_CREATE(tmr) \ | |
| vTraceStoreEvent2(PSF_EVENT_TIMER_CREATE, (uint32_t)tmr, tmr->xTimerPeriodInTicks); | |
| #undef traceTIMER_CREATE_FAILED | |
| #define traceTIMER_CREATE_FAILED() \ | |
| vTraceStoreEvent0(PSF_EVENT_TIMER_CREATE_FAILED); | |
| #if TRC_FREERTOS_VERSION == TRC_FREERTOS_VERSION_8_0_OR_LATER | |
| #define traceTIMER_COMMAND_SEND_8_0_CASES(tmr) \ | |
| case tmrCOMMAND_RESET: \ | |
| vTraceStoreEvent2((xReturn == pdPASS) ? PSF_EVENT_TIMER_RESET : PSF_EVENT_TIMER_RESET_FAILED, (uint32_t)tmr, xOptionalValue); \ | |
| break; \ | |
| case tmrCOMMAND_START_FROM_ISR: \ | |
| vTraceStoreEvent2((xReturn == pdPASS) ? PSF_EVENT_TIMER_START_FROMISR : PSF_EVENT_TIMER_START_FROMISR_FAILED, (uint32_t)tmr, xOptionalValue); \ | |
| break; \ | |
| case tmrCOMMAND_RESET_FROM_ISR: \ | |
| vTraceStoreEvent2((xReturn == pdPASS) ? PSF_EVENT_TIMER_RESET_FROMISR : PSF_EVENT_TIMER_RESET_FROMISR_FAILED, (uint32_t)tmr, xOptionalValue); \ | |
| break; \ | |
| case tmrCOMMAND_STOP_FROM_ISR: \ | |
| vTraceStoreEvent2((xReturn == pdPASS) ? PSF_EVENT_TIMER_STOP_FROMISR : PSF_EVENT_TIMER_STOP_FROMISR_FAILED, (uint32_t)tmr, xOptionalValue); \ | |
| break; \ | |
| case tmrCOMMAND_CHANGE_PERIOD_FROM_ISR: \ | |
| vTraceStoreEvent2((xReturn == pdPASS) ? PSF_EVENT_TIMER_CHANGEPERIOD_FROMISR : PSF_EVENT_TIMER_CHANGEPERIOD_FROMISR_FAILED, (uint32_t)tmr, xOptionalValue); \ | |
| break; | |
| #else | |
| #define traceTIMER_COMMAND_SEND_8_0_CASES(tmr) | |
| #endif | |
| /* Note that xCommandID can never be tmrCOMMAND_EXECUTE_CALLBACK (-1) since the trace macro is not called in that case */ | |
| #undef traceTIMER_COMMAND_SEND | |
| #define traceTIMER_COMMAND_SEND(tmr, xCommandID, xOptionalValue, xReturn) \ | |
| switch(xCommandID) \ | |
| { \ | |
| case tmrCOMMAND_START: \ | |
| break; \ | |
| case tmrCOMMAND_STOP: \ | |
| break; \ | |
| case tmrCOMMAND_CHANGE_PERIOD: \ | |
| vTraceStoreEvent2((xReturn == pdPASS) ? PSF_EVENT_TIMER_CHANGEPERIOD : PSF_EVENT_TIMER_CHANGEPERIOD_FAILED, (uint32_t)tmr, xOptionalValue); \ | |
| break; \ | |
| case tmrCOMMAND_DELETE: \ | |
| vTraceStoreEvent1((xReturn == pdPASS) ? PSF_EVENT_TIMER_DELETE : PSF_EVENT_TIMER_DELETE_FAILED, (uint32_t)tmr); \ | |
| break; \ | |
| traceTIMER_COMMAND_SEND_8_0_CASES(tmr) \ | |
| } | |
| #undef tracePEND_FUNC_CALL | |
| #define tracePEND_FUNC_CALL(func, arg1, arg2, ret) \ | |
| vTraceStoreEvent1((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) \ | |
| vTraceStoreEvent1((ret == pdPASS) ? PSF_EVENT_TIMER_PENDFUNCCALL_FROMISR : PSF_EVENT_TIMER_PENDFUNCCALL_FROMISR_FAILED, (uint32_t)func); | |
| #undef traceEVENT_GROUP_CREATE | |
| #define traceEVENT_GROUP_CREATE(eg) \ | |
| vTraceStoreEvent1(PSF_EVENT_EVENTGROUP_CREATE, (uint32_t)eg); | |
| #undef traceEVENT_GROUP_DELETE | |
| #define traceEVENT_GROUP_DELETE(eg) \ | |
| vTraceStoreEvent1(PSF_EVENT_EVENTGROUP_DELETE, (uint32_t)eg); | |
| #undef traceEVENT_GROUP_CREATE_FAILED | |
| #define traceEVENT_GROUP_CREATE_FAILED() \ | |
| vTraceStoreEvent0(PSF_EVENT_EVENTGROUP_CREATE_FAILED); | |
| #undef traceEVENT_GROUP_SYNC_BLOCK | |
| #define traceEVENT_GROUP_SYNC_BLOCK(eg, bitsToSet, bitsToWaitFor) \ | |
| vTraceStoreEvent2(PSF_EVENT_EVENTGROUP_SYNC_BLOCK, (uint32_t)eg, bitsToWaitFor); | |
| #undef traceEVENT_GROUP_SYNC_END | |
| #define traceEVENT_GROUP_SYNC_END(eg, bitsToSet, bitsToWaitFor, wasTimeout) \ | |
| vTraceStoreEvent2((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) \ | |
| vTraceStoreEvent2(PSF_EVENT_EVENTGROUP_WAITBITS_BLOCK, (uint32_t)eg, bitsToWaitFor); | |
| #undef traceEVENT_GROUP_WAIT_BITS_END | |
| #define traceEVENT_GROUP_WAIT_BITS_END(eg, bitsToWaitFor, wasTimeout) \ | |
| vTraceStoreEvent2((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) \ | |
| vTraceStoreEvent2(PSF_EVENT_EVENTGROUP_CLEARBITS, (uint32_t)eg, bitsToClear); | |
| #undef traceEVENT_GROUP_CLEAR_BITS_FROM_ISR | |
| #define traceEVENT_GROUP_CLEAR_BITS_FROM_ISR(eg, bitsToClear) \ | |
| vTraceStoreEvent2(PSF_EVENT_EVENTGROUP_CLEARBITS_FROMISR, (uint32_t)eg, bitsToClear); | |
| #undef traceEVENT_GROUP_SET_BITS | |
| #define traceEVENT_GROUP_SET_BITS(eg, bitsToSet) \ | |
| vTraceStoreEvent2(PSF_EVENT_EVENTGROUP_SETBITS, (uint32_t)eg, bitsToSet); | |
| #undef traceEVENT_GROUP_SET_BITS_FROM_ISR | |
| #define traceEVENT_GROUP_SET_BITS_FROM_ISR(eg, bitsToSet) \ | |
| vTraceStoreEvent2(PSF_EVENT_EVENTGROUP_SETBITS_FROMISR, (uint32_t)eg, bitsToSet); | |
| #undef traceTASK_NOTIFY_TAKE | |
| #define traceTASK_NOTIFY_TAKE() \ | |
| if (pxCurrentTCB->eNotifyState == eNotified) \ | |
| vTraceStoreEvent2(PSF_EVENT_TASK_NOTIFY_TAKE, (uint32_t)pxCurrentTCB, xTicksToWait); \ | |
| else \ | |
| vTraceStoreEvent2(PSF_EVENT_TASK_NOTIFY_TAKE_FAILED, (uint32_t)pxCurrentTCB, xTicksToWait); | |
| #undef traceTASK_NOTIFY_TAKE_BLOCK | |
| #define traceTASK_NOTIFY_TAKE_BLOCK() \ | |
| vTraceStoreEvent2(PSF_EVENT_TASK_NOTIFY_TAKE_BLOCK, (uint32_t)pxCurrentTCB, xTicksToWait); | |
| #undef traceTASK_NOTIFY_WAIT | |
| #define traceTASK_NOTIFY_WAIT() \ | |
| if (pxCurrentTCB->eNotifyState == eNotified) \ | |
| vTraceStoreEvent2(PSF_EVENT_TASK_NOTIFY_WAIT, (uint32_t)pxCurrentTCB, xTicksToWait); \ | |
| else \ | |
| vTraceStoreEvent2(PSF_EVENT_TASK_NOTIFY_WAIT_FAILED, (uint32_t)pxCurrentTCB, xTicksToWait); | |
| #undef traceTASK_NOTIFY_WAIT_BLOCK | |
| #define traceTASK_NOTIFY_WAIT_BLOCK() \ | |
| vTraceStoreEvent2(PSF_EVENT_TASK_NOTIFY_WAIT_BLOCK, (uint32_t)pxCurrentTCB, xTicksToWait); | |
| #undef traceTASK_NOTIFY | |
| #define traceTASK_NOTIFY() \ | |
| vTraceStoreEvent1(PSF_EVENT_TASK_NOTIFY, (uint32_t)xTaskToNotify); | |
| #undef traceTASK_NOTIFY_FROM_ISR | |
| #define traceTASK_NOTIFY_FROM_ISR() \ | |
| vTraceStoreEvent1(PSF_EVENT_TASK_NOTIFY_FROM_ISR, (uint32_t)xTaskToNotify); | |
| #undef traceTASK_NOTIFY_GIVE_FROM_ISR | |
| #define traceTASK_NOTIFY_GIVE_FROM_ISR() \ | |
| vTraceStoreEvent1(PSF_EVENT_TASK_NOTIFY_GIVE_FROM_ISR, (uint32_t)xTaskToNotify); | |
| /************************************************************************/ | |
| /* KERNEL SPECIFIC MACROS TO NAME OBJECTS, IF NECESSARY */ | |
| /************************************************************************/ | |
| #define vTraceSetQueueName(object, name) \ | |
| vTraceStoreKernelObjectName(object, name); | |
| #define vTraceSetSemaphoreName(object, name) \ | |
| vTraceStoreKernelObjectName(object, name); | |
| #define vTraceSetMutexName(object, name) \ | |
| vTraceStoreKernelObjectName(object, name); | |
| #define vTraceSetEventGroupName(object, name) \ | |
| vTraceStoreKernelObjectName(object, name); | |
| #else /*(USE_TRACEALYZER_RECORDER == 1)*/ | |
| #define vTraceSetQueueName(object, name) | |
| #define vTraceSetSemaphoreName(object, name) | |
| #define vTraceSetMutexName(object, name) | |
| #define vTraceSetEventGroupName(object, name) | |
| #define Trace_Init() | |
| #endif /*(USE_TRACEALYZER_RECORDER == 1)*/ | |
| #ifdef __cplusplus | |
| } | |
| #endif | |
| #endif /* TRC_KERNEL_PORT_H */ |