1 /*******************************************************************************
\r
2 * Trace Recorder Library for Tracealyzer v3.0.2
\r
3 * Percepio AB, www.percepio.com
\r
7 * The kernel-specific definitions for FreeRTOS.
\r
10 * This software (the "Tracealyzer Recorder Library") is the intellectual
\r
11 * property of Percepio AB and may not be sold or in other ways commercially
\r
12 * redistributed without explicit written permission by Percepio AB.
\r
14 * Separate conditions applies for the SEGGER branded source code included.
\r
16 * The recorder library is free for use together with Percepio products.
\r
17 * You may distribute the recorder library in its original form, but public
\r
18 * distribution of modified versions require approval by Percepio AB.
\r
21 * The trace tool and recorder library is being delivered to you AS IS and
\r
22 * Percepio AB makes no warranty as to its use or performance. Percepio AB does
\r
23 * not and cannot warrant the performance or results you may obtain by using the
\r
24 * software or documentation. Percepio AB make no warranties, express or
\r
25 * implied, as to noninfringement of third party rights, merchantability, or
\r
26 * fitness for any particular purpose. In no event will Percepio AB, its
\r
27 * technology partners, or distributors be liable to you for any consequential,
\r
28 * incidental or special damages, including any lost profits or lost savings,
\r
29 * even if a representative of Percepio AB has been advised of the possibility
\r
30 * of such damages, or for any claim by any third party. Some jurisdictions do
\r
31 * not allow the exclusion or limitation of incidental, consequential or special
\r
32 * damages, or the exclusion of implied warranties or limitations on how long an
\r
33 * implied warranty may last, so the above limitations may not apply to you.
\r
35 * Tabs are used for indent in this file (1 tab = 4 spaces)
\r
37 * Copyright Percepio AB, 2015.
\r
39 ******************************************************************************/
\r
42 #ifndef TRC_KERNEL_PORT_H
\r
43 #define TRC_KERNEL_PORT_H
\r
49 #include "FreeRTOS.h" /* Defines configUSE_TRACE_FACILITY */
\r
50 #include "trcConfig.h"
\r
51 #include "trcHardwarePort.h"
\r
53 extern int uiInEventGroupSetBitsFromISR;
\r
55 #define USE_TRACEALYZER_RECORDER configUSE_TRACE_FACILITY
\r
57 #if (USE_TRACEALYZER_RECORDER == 1)
\r
59 /*******************************************************************************
\r
62 * The main initalization routine for the embOS-Trace recorder. Configures RTT,
\r
63 * activates the PTRACE instrumentation in embOS and the TzCtrl task.
\r
64 * Also sets up the diagnostic User Event channels used by TzCtrl task.
\r
66 * Settings used by the trace recorder are found in these header files:
\r
67 * - SEGGER_RTT_Conf.h: settings for SEGGER Real-Time Terminal (RTT) which is
\r
68 * used for the trace streaming.
\r
69 * - trcKernelPort.h: RTT related settings for the trace streaming.
\r
70 * - trcRecorder.h - settings for allocation of internal recorder tables.
\r
71 * - trcHardwarePort.h - hardware-specific configuration (timestamping).
\r
72 ******************************************************************************/
\r
73 void Trace_Init(void);
\r
75 /*******************************************************************************
\r
76 * vTraceOnTraceBegin
\r
78 * Called on trace begin.
\r
79 ******************************************************************************/
\r
80 void vTraceOnTraceBegin(void);
\r
82 /*******************************************************************************
\r
85 * Called on trace end.
\r
86 ******************************************************************************/
\r
87 void vTraceOnTraceEnd(void);
\r
89 #include "trcRecorder.h"
\r
91 /* Defines that must be set for the recorder to work properly */
\r
92 #define KERNEL_ID 0x1AA1
\r
93 #define TRACE_TICK_RATE_HZ configTICK_RATE_HZ /* Defined in "FreeRTOS.h" */
\r
94 #define TRACE_CPU_CLOCK_HZ configCPU_CLOCK_HZ /* Defined in "FreeRTOSConfig.h" */
\r
96 #if (TRC_RECORDER_HARDWARE_PORT == TRC_PORT_ARM_Cortex_M)
\r
98 /* Uses CMSIS API. Must be #included in trcConfig.h. */
\r
99 #define TRACE_ALLOC_CRITICAL_SECTION() int __irq_status;
\r
100 #define TRACE_ENTER_CRITICAL_SECTION() {__irq_status = __get_PRIMASK(); __set_PRIMASK(1);}
\r
101 #define TRACE_EXIT_CRITICAL_SECTION() {__set_PRIMASK(__irq_status);}
\r
105 #if ((TRC_RECORDER_HARDWARE_PORT == TRC_PORT_ARM_CORTEX_A9) || (TRC_RECORDER_HARDWARE_PORT == TRC_PORT_Renesas_RX600))
\r
106 #define TRACE_ALLOC_CRITICAL_SECTION() int __irq_status;
\r
107 #define TRACE_ENTER_CRITICAL_SECTION() {__irq_status = portSET_INTERRUPT_MASK_FROM_ISR();}
\r
108 #define TRACE_EXIT_CRITICAL_SECTION() {portCLEAR_INTERRUPT_MASK_FROM_ISR(__irq_status);}
\r
111 #ifndef TRACE_ENTER_CRITICAL_SECTION
\r
112 #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/"
\r
115 void* prvTraceGetCurrentTaskHandle(void);
\r
116 uint32_t prvIsNewTCB(void* pNewTCB);
\r
118 #define OS_IS_SWITCH_FROM_INT_REQUIRED() 0
\r
119 #define TRACE_GET_CURRENT_TASK() prvTraceGetCurrentTaskHandle()
\r
121 /*************************************************************************/
\r
122 /* KERNEL SPECIFIC OBJECT CONFIGURATION */
\r
123 /*************************************************************************/
\r
125 /*******************************************************************************
\r
126 * The event codes - should match the offline config file.
\r
128 * Some sections below are encoded to allow for constructions like:
\r
130 * vTraceStoreKernelCall(EVENTGROUP_CREATE + objectclass, ...
\r
132 * The object class ID is given by the three LSB bits, in such cases. Since each
\r
133 * object class has a separate object property table, the class ID is needed to
\r
134 * know what section in the object table to use for getting an object name from
\r
135 * an object handle.
\r
136 ******************************************************************************/
\r
138 #define PSF_EVENT_NULL_EVENT 0x00
\r
140 /* PSF event codes */
\r
141 #define PSF_EVENT_TRACE_START 0x01
\r
142 #define PSF_EVENT_TS_CONFIG 0x02
\r
143 #define PSF_EVENT_OBJ_NAME 0x03
\r
144 #define PSF_EVENT_TASK_PRIORITY 0x04
\r
145 #define PSF_EVENT_TASK_PRIO_INHERIT 0x05
\r
146 #define PSF_EVENT_TASK_PRIO_DISINHERIT 0x06
\r
147 #define PSF_EVENT_DEFINE_ISR 0x07
\r
149 #define PSF_EVENT_TASK_CREATE 0x10
\r
150 #define PSF_EVENT_QUEUE_CREATE 0x11
\r
151 #define PSF_EVENT_SEMAPHORE_BINARY_CREATE 0x12
\r
152 #define PSF_EVENT_MUTEX_CREATE 0x13
\r
153 #define PSF_EVENT_TIMER_CREATE 0x14
\r
154 #define PSF_EVENT_EVENTGROUP_CREATE 0x15
\r
155 #define PSF_EVENT_SEMAPHORE_COUNTING_CREATE 0x16
\r
156 #define PSF_EVENT_MUTEX_RECURSIVE_CREATE 0x17
\r
158 #define PSF_EVENT_TASK_DELETE 0x20
\r
159 #define PSF_EVENT_QUEUE_DELETE 0x21
\r
160 #define PSF_EVENT_SEMAPHORE_DELETE 0x22
\r
161 #define PSF_EVENT_MUTEX_DELETE 0x23
\r
162 #define PSF_EVENT_TIMER_DELETE 0x24
\r
163 #define PSF_EVENT_EVENTGROUP_DELETE 0x25
\r
165 #define PSF_EVENT_TASK_READY 0x30
\r
166 #define PSF_EVENT_NEW_TIME 0x31
\r
167 #define PSF_EVENT_NEW_TIME_SCHEDULER_SUSPENDED 0x32
\r
168 #define PSF_EVENT_ISR_BEGIN 0x33
\r
169 #define PSF_EVENT_ISR_RESUME 0x34
\r
170 #define PSF_EVENT_TS_BEGIN 0x35
\r
171 #define PSF_EVENT_TS_RESUME 0x36
\r
172 #define PSF_EVENT_TASK_ACTIVATE 0x37
\r
174 #define PSF_EVENT_MALLOC 0x38
\r
175 #define PSF_EVENT_FREE 0x39
\r
177 #define PSF_EVENT_LOWPOWER_BEGIN 0x3A
\r
178 #define PSF_EVENT_LOWPOWER_END 0x3B
\r
180 #define PSF_EVENT_IFE_NEXT 0x3C
\r
181 #define PSF_EVENT_IFE_DIRECT 0x3D
\r
183 #define PSF_EVENT_TASK_CREATE_FAILED 0x40
\r
184 #define PSF_EVENT_QUEUE_CREATE_FAILED 0x41
\r
185 #define PSF_EVENT_SEMAPHORE_BINARY_CREATE_FAILED 0x42
\r
186 #define PSF_EVENT_MUTEX_CREATE_FAILED 0x43
\r
187 #define PSF_EVENT_TIMER_CREATE_FAILED 0x44
\r
188 #define PSF_EVENT_EVENTGROUP_CREATE_FAILED 0x45
\r
189 #define PSF_EVENT_SEMAPHORE_COUNTING_CREATE_FAILED 0x46
\r
190 #define PSF_EVENT_MUTEX_RECURSIVE_CREATE_FAILED 0x47
\r
192 #define PSF_EVENT_TIMER_DELETE_FAILED 0x48
\r
194 #define PSF_EVENT_QUEUE_SEND 0x50
\r
195 #define PSF_EVENT_SEMAPHORE_GIVE 0x51
\r
196 #define PSF_EVENT_MUTEX_GIVE 0x52
\r
198 #define PSF_EVENT_QUEUE_SEND_FAILED 0x53
\r
199 #define PSF_EVENT_SEMAPHORE_GIVE_FAILED 0x54
\r
200 #define PSF_EVENT_MUTEX_GIVE_FAILED 0x55
\r
202 #define PSF_EVENT_QUEUE_SEND_BLOCK 0x56
\r
203 #define PSF_EVENT_SEMAPHORE_GIVE_BLOCK 0x57
\r
204 #define PSF_EVENT_MUTEX_GIVE_BLOCK 0x58
\r
206 #define PSF_EVENT_QUEUE_SEND_FROMISR 0x59
\r
207 #define PSF_EVENT_SEMAPHORE_GIVE_FROMISR 0x5A
\r
209 #define PSF_EVENT_QUEUE_SEND_FROMISR_FAILED 0x5C
\r
210 #define PSF_EVENT_SEMAPHORE_GIVE_FROMISR_FAILED 0x5D
\r
212 #define PSF_EVENT_QUEUE_RECEIVE 0x60
\r
213 #define PSF_EVENT_SEMAPHORE_TAKE 0x61
\r
214 #define PSF_EVENT_MUTEX_TAKE 0x62
\r
216 #define PSF_EVENT_QUEUE_RECEIVE_FAILED 0x63
\r
217 #define PSF_EVENT_SEMAPHORE_TAKE_FAILED 0x64
\r
218 #define PSF_EVENT_MUTEX_TAKE_FAILED 0x65
\r
220 #define PSF_EVENT_QUEUE_RECEIVE_BLOCK 0x66
\r
221 #define PSF_EVENT_SEMAPHORE_TAKE_BLOCK 0x67
\r
222 #define PSF_EVENT_MUTEX_TAKE_BLOCK 0x68
\r
224 #define PSF_EVENT_QUEUE_RECEIVE_FROMISR 0x69
\r
225 #define PSF_EVENT_SEMAPHORE_TAKE_FROMISR 0x6A
\r
227 #define PSF_EVENT_QUEUE_RECEIVE_FROMISR_FAILED 0x6C
\r
228 #define PSF_EVENT_SEMAPHORE_TAKE_FROMISR_FAILED 0x6D
\r
230 #define PSF_EVENT_QUEUE_PEEK 0x70
\r
231 #define PSF_EVENT_SEMAPHORE_PEEK 0x71 /* Will never be used */
\r
232 #define PSF_EVENT_MUTEX_PEEK 0x72 /* Will never be used */
\r
234 #define PSF_EVENT_QUEUE_PEEK_FAILED 0x73
\r
235 #define PSF_EVENT_SEMAPHORE_PEEK_FAILED 0x74 /* Will never be used */
\r
236 #define PSF_EVENT_MUTEX_PEEK_FAILED 0x75 /* Will never be used */
\r
238 #define PSF_EVENT_QUEUE_PEEK_BLOCK 0x76
\r
239 #define PSF_EVENT_SEMAPHORE_PEEK_BLOCK 0x77 /* Will never be used */
\r
240 #define PSF_EVENT_MUTEX_PEEK_BLOCK 0x78 /* Will never be used */
\r
242 #define PSF_EVENT_TASK_DELAY_UNTIL 0x79
\r
243 #define PSF_EVENT_TASK_DELAY 0x7A
\r
244 #define PSF_EVENT_TASK_SUSPEND 0x7B
\r
245 #define PSF_EVENT_TASK_RESUME 0x7C
\r
246 #define PSF_EVENT_TASK_RESUME_FROMISR 0x7D
\r
248 #define PSF_EVENT_TIMER_PENDFUNCCALL 0x80
\r
249 #define PSF_EVENT_TIMER_PENDFUNCCALL_FROMISR 0x81
\r
250 #define PSF_EVENT_TIMER_PENDFUNCCALL_FAILED 0x82
\r
251 #define PSF_EVENT_TIMER_PENDFUNCCALL_FROMISR_FAILED 0x83
\r
253 #define PSF_EVENT_USER_EVENT 0x90
\r
255 #define PSF_EVENT_TIMER_START 0xA0
\r
256 #define PSF_EVENT_TIMER_RESET 0xA1
\r
257 #define PSF_EVENT_TIMER_STOP 0xA2
\r
258 #define PSF_EVENT_TIMER_CHANGEPERIOD 0xA3
\r
259 #define PSF_EVENT_TIMER_START_FROMISR 0xA4
\r
260 #define PSF_EVENT_TIMER_RESET_FROMISR 0xA5
\r
261 #define PSF_EVENT_TIMER_STOP_FROMISR 0xA6
\r
262 #define PSF_EVENT_TIMER_CHANGEPERIOD_FROMISR 0xA7
\r
263 #define PSF_EVENT_TIMER_START_FAILED 0xA8
\r
264 #define PSF_EVENT_TIMER_RESET_FAILED 0xA9
\r
265 #define PSF_EVENT_TIMER_STOP_FAILED 0xAA
\r
266 #define PSF_EVENT_TIMER_CHANGEPERIOD_FAILED 0xAB
\r
267 #define PSF_EVENT_TIMER_START_FROMISR_FAILED 0xAC
\r
268 #define PSF_EVENT_TIMER_RESET_FROMISR_FAILED 0xAD
\r
269 #define PSF_EVENT_TIMER_STOP_FROMISR_FAILED 0xAE
\r
270 #define PSF_EVENT_TIMER_CHANGEPERIOD_FROMISR_FAILED 0xAF
\r
272 #define PSF_EVENT_EVENTGROUP_SYNC 0xB0
\r
273 #define PSF_EVENT_EVENTGROUP_WAITBITS 0xB1
\r
274 #define PSF_EVENT_EVENTGROUP_CLEARBITS 0xB2
\r
275 #define PSF_EVENT_EVENTGROUP_CLEARBITS_FROMISR 0xB3
\r
276 #define PSF_EVENT_EVENTGROUP_SETBITS 0xB4
\r
277 #define PSF_EVENT_EVENTGROUP_SETBITS_FROMISR 0xB5
\r
278 #define PSF_EVENT_EVENTGROUP_SYNC_BLOCK 0xB6
\r
279 #define PSF_EVENT_EVENTGROUP_WAITBITS_BLOCK 0xB7
\r
280 #define PSF_EVENT_EVENTGROUP_SYNC_FAILED 0xB8
\r
281 #define PSF_EVENT_EVENTGROUP_WAITBITS_FAILED 0xB9
\r
283 #define PSF_EVENT_QUEUE_SEND_FRONT 0xC0
\r
284 #define PSF_EVENT_QUEUE_SEND_FRONT_FAILED 0xC1
\r
285 #define PSF_EVENT_QUEUE_SEND_FRONT_BLOCK 0xC2
\r
286 #define PSF_EVENT_QUEUE_SEND_FRONT_FROMISR 0xC3
\r
287 #define PSF_EVENT_QUEUE_SEND_FRONT_FROMISR_FAILED 0xC4
\r
288 #define PSF_EVENT_MUTEX_GIVE_RECURSIVE 0xC5
\r
289 #define PSF_EVENT_MUTEX_GIVE_RECURSIVE_FAILED 0xC6
\r
290 #define PSF_EVENT_MUTEX_TAKE_RECURSIVE 0xC7
\r
291 #define PSF_EVENT_MUTEX_TAKE_RECURSIVE_FAILED 0xC8
\r
293 #define PSF_EVENT_TASK_NOTIFY 0xC9
\r
294 #define PSF_EVENT_TASK_NOTIFY_TAKE 0xCA
\r
295 #define PSF_EVENT_TASK_NOTIFY_TAKE_BLOCK 0xCB
\r
296 #define PSF_EVENT_TASK_NOTIFY_TAKE_FAILED 0xCC
\r
297 #define PSF_EVENT_TASK_NOTIFY_WAIT 0xCD
\r
298 #define PSF_EVENT_TASK_NOTIFY_WAIT_BLOCK 0xCE
\r
299 #define PSF_EVENT_TASK_NOTIFY_WAIT_FAILED 0xCF
\r
300 #define PSF_EVENT_TASK_NOTIFY_FROM_ISR 0xD0
\r
301 #define PSF_EVENT_TASK_NOTIFY_GIVE_FROM_ISR 0xD1
\r
303 #define TRACE_GET_OS_TICKS() (uiTraceTickCount)
\r
305 /************************************************************************/
\r
306 /* KERNEL SPECIFIC DATA AND FUNCTIONS NEEDED TO PROVIDE THE */
\r
307 /* FUNCTIONALITY REQUESTED BY THE TRACE RECORDER */
\r
308 /************************************************************************/
\r
310 #if (configUSE_TIMERS == 1)
\r
311 #undef INCLUDE_xTimerGetTimerDaemonTaskHandle
\r
312 #define INCLUDE_xTimerGetTimerDaemonTaskHandle 1
\r
315 /************************************************************************/
\r
316 /* KERNEL SPECIFIC MACROS USED BY THE TRACE RECORDER */
\r
317 /************************************************************************/
\r
319 #define TRACE_MALLOC(size) pvPortMalloc(size)
\r
321 /************************************************************************/
\r
322 /* KERNEL SPECIFIC WRAPPERS THAT SHOULD BE CALLED BY THE KERNEL */
\r
323 /************************************************************************/
\r
325 #if (configUSE_TICKLESS_IDLE != 0)
\r
327 #undef traceLOW_POWER_IDLE_BEGIN
\r
328 #define traceLOW_POWER_IDLE_BEGIN() \
\r
330 vTraceStoreEvent0(PSF_EVENT_LOWPOWER_BEGIN); \
\r
333 #undef traceLOW_POWER_IDLE_END
\r
334 #define traceLOW_POWER_IDLE_END() \
\r
336 vTraceStoreEvent0(PSF_EVENT_LOWPOWER_END); \
\r
341 /* A macro that will update the tick count when returning from tickless idle */
\r
342 #undef traceINCREASE_TICK_COUNT
\r
343 /* 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.*/
\r
344 #define traceINCREASE_TICK_COUNT( xCount )
\r
346 /* Called for each task that becomes ready */
\r
347 #undef traceMOVED_TASK_TO_READY_STATE
\r
348 #define traceMOVED_TASK_TO_READY_STATE( pxTCB ) \
\r
349 vTraceStoreEvent1(PSF_EVENT_TASK_READY, (uint32_t)pxTCB);
\r
351 /* Called on each OS tick. Will call uiPortGetTimestamp to make sure it is called at least once every OS tick. */
\r
352 #undef traceTASK_INCREMENT_TICK
\r
353 #if (TRC_FREERTOS_VERSION == TRC_FREERTOS_VERSION_7_3_OR_7_4)
\r
355 #define traceTASK_INCREMENT_TICK( xTickCount ) \
\r
356 if (uxSchedulerSuspended == ( unsigned portBASE_TYPE ) pdTRUE || uxMissedTicks == 0) { extern uint32_t uiTraceTickCount; uiTraceTickCount++; } \
\r
357 if (uxSchedulerSuspended == ( unsigned portBASE_TYPE ) pdFALSE) { vTraceStoreEvent1(PSF_EVENT_NEW_TIME, (xTickCount + 1)); }
\r
361 #define traceTASK_INCREMENT_TICK( xTickCount ) \
\r
362 if (uxSchedulerSuspended == ( unsigned portBASE_TYPE ) pdTRUE || uxPendedTicks == 0) { extern uint32_t uiTraceTickCount; uiTraceTickCount++; } \
\r
363 if (uxSchedulerSuspended == ( unsigned portBASE_TYPE ) pdFALSE) { vTraceStoreEvent1(PSF_EVENT_NEW_TIME, (xTickCount + 1)); }
\r
367 /* Called on each task-switch */
\r
368 #undef traceTASK_SWITCHED_IN
\r
369 #define traceTASK_SWITCHED_IN() \
\r
370 if (prvIsNewTCB(pxCurrentTCB)) \
\r
372 vTraceStoreEvent2(PSF_EVENT_TASK_ACTIVATE, (uint32_t)pxCurrentTCB, pxCurrentTCB->uxPriority); \
\r
375 /* Called on vTaskSuspend */
\r
376 #undef traceTASK_SUSPEND
\r
377 #define traceTASK_SUSPEND( pxTaskToSuspend ) \
\r
378 vTraceStoreEvent1(PSF_EVENT_TASK_SUSPEND, (uint32_t)pxTaskToSuspend);
\r
380 /* Called on vTaskDelay - note the use of FreeRTOS variable xTicksToDelay */
\r
381 #undef traceTASK_DELAY
\r
382 #define traceTASK_DELAY() \
\r
383 vTraceStoreEvent1(PSF_EVENT_TASK_DELAY, xTicksToDelay);
\r
385 /* Called on vTaskDelayUntil - note the use of FreeRTOS variable xTimeToWake */
\r
386 #undef traceTASK_DELAY_UNTIL
\r
387 #define traceTASK_DELAY_UNTIL() \
\r
388 vTraceStoreEvent1(PSF_EVENT_TASK_DELAY_UNTIL, xTimeToWake);
\r
390 /* Called on vTaskDelete */
\r
391 #undef traceTASK_DELETE
\r
392 #define traceTASK_DELETE( pxTaskToDelete ) \
\r
393 vTraceStoreEvent2(PSF_EVENT_TASK_DELETE, (uint32_t)pxTaskToDelete, (pxTaskToDelete != NULL) ? (pxTaskToDelete->uxPriority) : 0);
\r
395 /* Called on vQueueDelete */
\r
396 #undef traceQUEUE_DELETE
\r
397 #define traceQUEUE_DELETE( pxQueue ) \
\r
398 switch (pxQueue->ucQueueType) \
\r
400 case queueQUEUE_TYPE_BASE: \
\r
401 vTraceStoreEvent2(PSF_EVENT_QUEUE_DELETE, (uint32_t)pxQueue, (pxQueue != NULL) ? (pxQueue->uxMessagesWaiting) : 0); \
\r
403 case queueQUEUE_TYPE_MUTEX: \
\r
404 case queueQUEUE_TYPE_RECURSIVE_MUTEX: \
\r
405 vTraceStoreEvent2(PSF_EVENT_MUTEX_DELETE, (uint32_t)pxQueue, (pxQueue != NULL) ? (pxQueue->uxMessagesWaiting) : 0); \
\r
407 case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \
\r
408 case queueQUEUE_TYPE_BINARY_SEMAPHORE: \
\r
409 vTraceStoreEvent2(PSF_EVENT_SEMAPHORE_DELETE, (uint32_t)pxQueue, (pxQueue != NULL) ? (pxQueue->uxMessagesWaiting) : 0); \
\r
413 /* Called on vTaskCreate */
\r
414 #undef traceTASK_CREATE
\r
415 #define traceTASK_CREATE(pxNewTCB) \
\r
416 if (pxNewTCB != NULL) \
\r
418 vTraceSaveSymbol(pxNewTCB, (const char*)pcName); \
\r
419 vTraceSaveObjectData(pxNewTCB, uxPriority); \
\r
420 vTraceStoreStringEvent(1, PSF_EVENT_OBJ_NAME, pcName, pxNewTCB); \
\r
421 vTraceStoreEvent2(PSF_EVENT_TASK_CREATE, (uint32_t)pxNewTCB, uxPriority); \
\r
424 /* Called in vTaskCreate, if it fails (typically if the stack can not be allocated) */
\r
425 #undef traceTASK_CREATE_FAILED
\r
426 #define traceTASK_CREATE_FAILED() \
\r
427 vTraceStoreEvent0(PSF_EVENT_TASK_CREATE_FAILED);
\r
429 /* Called in xQueueCreate, and thereby for all other object based on queues, such as semaphores. */
\r
430 #undef traceQUEUE_CREATE
\r
431 #define traceQUEUE_CREATE( pxNewQueue )\
\r
432 switch (pxNewQueue->ucQueueType) \
\r
434 case queueQUEUE_TYPE_BASE: \
\r
435 vTraceStoreEvent2(PSF_EVENT_QUEUE_CREATE, (uint32_t)pxNewQueue, pxNewQueue->uxLength); \
\r
437 case queueQUEUE_TYPE_BINARY_SEMAPHORE: \
\r
438 vTraceStoreEvent1(PSF_EVENT_SEMAPHORE_BINARY_CREATE, (uint32_t)pxNewQueue); \
\r
442 /* Called in xQueueCreate, if the queue creation fails */
\r
443 #undef traceQUEUE_CREATE_FAILED
\r
444 #define traceQUEUE_CREATE_FAILED( queueType ) \
\r
445 switch (queueType) \
\r
447 case queueQUEUE_TYPE_BASE: \
\r
448 vTraceStoreEvent0(PSF_EVENT_QUEUE_CREATE_FAILED); \
\r
450 case queueQUEUE_TYPE_BINARY_SEMAPHORE: \
\r
451 vTraceStoreEvent0(PSF_EVENT_SEMAPHORE_BINARY_CREATE_FAILED); \
\r
455 /* Called in xQueueCreateCountingSemaphore, if the queue creation fails */
\r
456 #undef traceCREATE_COUNTING_SEMAPHORE
\r
457 #if TRC_FREERTOS_VERSION == TRC_FREERTOS_VERSION_8_0_OR_LATER
\r
458 #define traceCREATE_COUNTING_SEMAPHORE() \
\r
459 vTraceStoreEvent2(PSF_EVENT_SEMAPHORE_COUNTING_CREATE, (uint32_t)xHandle, ((Queue_t *) xHandle)->uxMessagesWaiting);
\r
461 #define traceCREATE_COUNTING_SEMAPHORE() \
\r
462 vTraceStoreEvent2(PSF_EVENT_SEMAPHORE_COUNTING_CREATE, (uint32_t)pxHandle, pxHandle->uxMessagesWaiting);
\r
465 #undef traceCREATE_COUNTING_SEMAPHORE_FAILED
\r
466 #define traceCREATE_COUNTING_SEMAPHORE_FAILED() \
\r
467 vTraceStoreEvent0(PSF_EVENT_SEMAPHORE_COUNTING_CREATE_FAILED);
\r
469 /* Called in xQueueCreateMutex, and thereby also from xSemaphoreCreateMutex and xSemaphoreCreateRecursiveMutex */
\r
470 #undef traceCREATE_MUTEX
\r
471 #define traceCREATE_MUTEX( pxNewQueue ) \
\r
472 switch (ucQueueType) \
\r
474 case queueQUEUE_TYPE_MUTEX: \
\r
475 vTraceStoreEvent1(PSF_EVENT_MUTEX_CREATE, (uint32_t)pxNewQueue); \
\r
477 case queueQUEUE_TYPE_RECURSIVE_MUTEX: \
\r
478 vTraceStoreEvent1(PSF_EVENT_MUTEX_RECURSIVE_CREATE, (uint32_t)pxNewQueue); \
\r
482 /* Called in xQueueCreateMutex when the operation fails (when memory allocation fails) */
\r
483 #undef traceCREATE_MUTEX_FAILED
\r
484 #define traceCREATE_MUTEX_FAILED() \
\r
485 switch (ucQueueType) \
\r
487 case queueQUEUE_TYPE_MUTEX: \
\r
488 vTraceStoreEvent0(PSF_EVENT_MUTEX_CREATE_FAILED); \
\r
490 case queueQUEUE_TYPE_RECURSIVE_MUTEX: \
\r
491 vTraceStoreEvent0(PSF_EVENT_MUTEX_CREATE_FAILED); \
\r
495 /* Called when a message is sent to a queue */ /* CS IS NEW ! */
\r
496 #undef traceQUEUE_SEND
\r
497 #define traceQUEUE_SEND( pxQueue ) \
\r
498 switch (pxQueue->ucQueueType) \
\r
500 case queueQUEUE_TYPE_BASE: \
\r
501 vTraceStoreEvent2(xCopyPosition == queueSEND_TO_BACK ? PSF_EVENT_QUEUE_SEND : PSF_EVENT_QUEUE_SEND_FRONT, (uint32_t)pxQueue, pxQueue->uxMessagesWaiting + 1); \
\r
503 case queueQUEUE_TYPE_BINARY_SEMAPHORE: \
\r
504 case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \
\r
505 vTraceStoreEvent2(PSF_EVENT_SEMAPHORE_GIVE, (uint32_t)pxQueue, pxQueue->uxMessagesWaiting + 1); \
\r
507 case queueQUEUE_TYPE_MUTEX: \
\r
508 case queueQUEUE_TYPE_RECURSIVE_MUTEX: \
\r
509 vTraceStoreEvent1(PSF_EVENT_MUTEX_GIVE, (uint32_t)pxQueue); \
\r
513 /* Called when a message failed to be sent to a queue (timeout) */
\r
514 #undef traceQUEUE_SEND_FAILED
\r
515 #define traceQUEUE_SEND_FAILED( pxQueue ) \
\r
516 switch (pxQueue->ucQueueType) \
\r
518 case queueQUEUE_TYPE_BASE: \
\r
519 vTraceStoreEvent2(xCopyPosition == queueSEND_TO_BACK ? PSF_EVENT_QUEUE_SEND_FAILED : PSF_EVENT_QUEUE_SEND_FRONT_FAILED, (uint32_t)pxQueue, pxQueue->uxMessagesWaiting); \
\r
521 case queueQUEUE_TYPE_BINARY_SEMAPHORE: \
\r
522 case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \
\r
523 vTraceStoreEvent2(PSF_EVENT_SEMAPHORE_GIVE_FAILED, (uint32_t)pxQueue, pxQueue->uxMessagesWaiting); \
\r
525 case queueQUEUE_TYPE_MUTEX: \
\r
526 case queueQUEUE_TYPE_RECURSIVE_MUTEX: \
\r
527 vTraceStoreEvent1(PSF_EVENT_MUTEX_GIVE_FAILED, (uint32_t)pxQueue); \
\r
531 /*trcKERNEL_HOOKS_KERNEL_SERVICE(SEND, FAILED, UNUSED, pxQueue);*/
\r
533 /* Called when the task is blocked due to a send operation on a full queue */
\r
534 #undef traceBLOCKING_ON_QUEUE_SEND
\r
535 #define traceBLOCKING_ON_QUEUE_SEND( pxQueue ) \
\r
536 switch (pxQueue->ucQueueType) \
\r
538 case queueQUEUE_TYPE_BASE: \
\r
539 vTraceStoreEvent2(xCopyPosition == queueSEND_TO_BACK ? PSF_EVENT_QUEUE_SEND_BLOCK : PSF_EVENT_QUEUE_SEND_FRONT_BLOCK, (uint32_t)pxQueue, pxQueue->uxMessagesWaiting); \
\r
541 case queueQUEUE_TYPE_BINARY_SEMAPHORE: \
\r
542 case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \
\r
543 vTraceStoreEvent2(PSF_EVENT_SEMAPHORE_GIVE_BLOCK, (uint32_t)pxQueue, pxQueue->uxMessagesWaiting); \
\r
545 case queueQUEUE_TYPE_MUTEX: \
\r
546 case queueQUEUE_TYPE_RECURSIVE_MUTEX: \
\r
547 vTraceStoreEvent1(PSF_EVENT_MUTEX_GIVE_BLOCK, (uint32_t)pxQueue); \
\r
551 /* Called for Recursive Mutex */
\r
552 #undef traceGIVE_MUTEX_RECURSIVE
\r
553 #define traceGIVE_MUTEX_RECURSIVE( pxMutex ) \
\r
554 vTraceStoreEvent1(PSF_EVENT_MUTEX_GIVE_RECURSIVE, (uint32_t)pxMutex);
\r
556 /* Called for Recursive Mutex */
\r
557 #undef traceGIVE_MUTEX_RECURSIVE_FAILED
\r
558 #define traceGIVE_MUTEX_RECURSIVE_FAILED( pxMutex ) \
\r
559 vTraceStoreEvent1(PSF_EVENT_MUTEX_GIVE_RECURSIVE_FAILED, (uint32_t)pxMutex);
\r
561 /**************************************************************************/
\r
562 /* Hack to make sure xQueueGiveFromISR also has a xCopyPosition parameter */
\r
563 /**************************************************************************/
\r
564 /* Helpers needed to correctly expand names */
\r
565 #define TZ__CAT2(a,b) a ## b
\r
566 #define TZ__CAT(a,b) TZ__CAT2(a, b)
\r
568 /* 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 */
\r
569 #define xQueueGiveFromISR(a,b) TZ__CAT(xQueueGiveFromISR__, uxQueueType) (a,b)
\r
571 /* If in queue.c, the "uxQueueType" macro expands to "pcHead". queueSEND_TO_BACK is the value we need to send in */
\r
572 #define xQueueGiveFromISR__pcHead(__a, __b) MyWrapper(__a, __b, const BaseType_t xCopyPosition); \
\r
573 BaseType_t xQueueGiveFromISR(__a, __b) { return MyWrapper(xQueue, pxHigherPriorityTaskWoken, queueSEND_TO_BACK); } \
\r
574 BaseType_t MyWrapper(__a, __b, const BaseType_t xCopyPosition)
\r
576 /* If not in queue.c, "uxQueueType" isn't expanded */
\r
577 #define xQueueGiveFromISR__uxQueueType(__a, __b) xQueueGiveFromISR(__a,__b)
\r
579 /**************************************************************************/
\r
580 /* End of xQueueGiveFromISR hack */
\r
581 /**************************************************************************/
\r
583 /* Called when a message is sent from interrupt context, e.g., using xQueueSendFromISR */
\r
584 #undef traceQUEUE_SEND_FROM_ISR
\r
585 #define traceQUEUE_SEND_FROM_ISR( pxQueue ) \
\r
586 switch (pxQueue->ucQueueType) \
\r
588 case queueQUEUE_TYPE_BASE: \
\r
589 vTraceStoreEvent2(xCopyPosition == queueSEND_TO_BACK ? PSF_EVENT_QUEUE_SEND_FROMISR : PSF_EVENT_QUEUE_SEND_FRONT_FROMISR, (uint32_t)pxQueue, pxQueue->uxMessagesWaiting + 1); \
\r
591 case queueQUEUE_TYPE_BINARY_SEMAPHORE: \
\r
592 case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \
\r
593 vTraceStoreEvent2(PSF_EVENT_SEMAPHORE_GIVE_FROMISR, (uint32_t)pxQueue, pxQueue->uxMessagesWaiting + 1); \
\r
597 /* Called when a message send from interrupt context fails (since the queue was full) */
\r
598 #undef traceQUEUE_SEND_FROM_ISR_FAILED
\r
599 #define traceQUEUE_SEND_FROM_ISR_FAILED( pxQueue ) \
\r
600 switch (pxQueue->ucQueueType) \
\r
602 case queueQUEUE_TYPE_BASE: \
\r
603 vTraceStoreEvent2(xCopyPosition == queueSEND_TO_BACK ? PSF_EVENT_QUEUE_SEND_FROMISR_FAILED : PSF_EVENT_QUEUE_SEND_FRONT_FROMISR_FAILED, (uint32_t)pxQueue, pxQueue->uxMessagesWaiting); \
\r
605 case queueQUEUE_TYPE_BINARY_SEMAPHORE: \
\r
606 case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \
\r
607 vTraceStoreEvent2(PSF_EVENT_SEMAPHORE_GIVE_FROMISR_FAILED, (uint32_t)pxQueue, pxQueue->uxMessagesWaiting); \
\r
611 /* Called when a message is received from a queue */
\r
612 #undef traceQUEUE_RECEIVE
\r
613 #define traceQUEUE_RECEIVE( pxQueue ) \
\r
614 switch (pxQueue->ucQueueType) \
\r
616 case queueQUEUE_TYPE_BASE: \
\r
617 vTraceStoreEvent3(PSF_EVENT_QUEUE_RECEIVE, (uint32_t)pxQueue, xTicksToWait, pxQueue->uxMessagesWaiting - 1); \
\r
619 case queueQUEUE_TYPE_BINARY_SEMAPHORE: \
\r
620 case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \
\r
621 vTraceStoreEvent3(PSF_EVENT_SEMAPHORE_TAKE, (uint32_t)pxQueue, xTicksToWait, pxQueue->uxMessagesWaiting - 1); \
\r
623 case queueQUEUE_TYPE_MUTEX: \
\r
624 case queueQUEUE_TYPE_RECURSIVE_MUTEX: \
\r
625 vTraceStoreEvent2(PSF_EVENT_MUTEX_TAKE, (uint32_t)pxQueue, xTicksToWait); \
\r
629 /* Called when a receive operation on a queue fails (timeout) */
\r
630 #undef traceQUEUE_RECEIVE_FAILED
\r
631 #define traceQUEUE_RECEIVE_FAILED( pxQueue ) \
\r
632 switch (pxQueue->ucQueueType) \
\r
634 case queueQUEUE_TYPE_BASE: \
\r
635 vTraceStoreEvent3(xJustPeeking == pdFALSE ? PSF_EVENT_QUEUE_RECEIVE_FAILED : PSF_EVENT_QUEUE_PEEK_FAILED, (uint32_t)pxQueue, xTicksToWait, pxQueue->uxMessagesWaiting); \
\r
637 case queueQUEUE_TYPE_BINARY_SEMAPHORE: \
\r
638 case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \
\r
639 vTraceStoreEvent3(xJustPeeking == pdFALSE ? PSF_EVENT_SEMAPHORE_TAKE_FAILED : PSF_EVENT_SEMAPHORE_PEEK_FAILED, (uint32_t)pxQueue, xTicksToWait, pxQueue->uxMessagesWaiting); \
\r
641 case queueQUEUE_TYPE_MUTEX: \
\r
642 case queueQUEUE_TYPE_RECURSIVE_MUTEX: \
\r
643 vTraceStoreEvent2(xJustPeeking == pdFALSE ? PSF_EVENT_MUTEX_TAKE_FAILED : PSF_EVENT_MUTEX_PEEK_FAILED, (uint32_t)pxQueue, xTicksToWait); \
\r
647 /* Called when the task is blocked due to a receive operation on an empty queue */
\r
648 #undef traceBLOCKING_ON_QUEUE_RECEIVE
\r
649 #define traceBLOCKING_ON_QUEUE_RECEIVE( pxQueue ) \
\r
650 switch (pxQueue->ucQueueType) \
\r
652 case queueQUEUE_TYPE_BASE: \
\r
653 vTraceStoreEvent3(xJustPeeking == pdFALSE ? PSF_EVENT_QUEUE_RECEIVE_BLOCK : PSF_EVENT_QUEUE_PEEK_BLOCK, (uint32_t)pxQueue, xTicksToWait, pxQueue->uxMessagesWaiting); \
\r
655 case queueQUEUE_TYPE_BINARY_SEMAPHORE: \
\r
656 case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \
\r
657 vTraceStoreEvent3(xJustPeeking == pdFALSE ? PSF_EVENT_SEMAPHORE_TAKE_BLOCK : PSF_EVENT_SEMAPHORE_PEEK_BLOCK, (uint32_t)pxQueue, xTicksToWait, pxQueue->uxMessagesWaiting); \
\r
659 case queueQUEUE_TYPE_MUTEX: \
\r
660 case queueQUEUE_TYPE_RECURSIVE_MUTEX: \
\r
661 vTraceStoreEvent2(xJustPeeking == pdFALSE ? PSF_EVENT_MUTEX_TAKE_BLOCK : PSF_EVENT_MUTEX_PEEK_BLOCK, (uint32_t)pxQueue, xTicksToWait); \
\r
665 #undef traceTAKE_MUTEX_RECURSIVE
\r
666 #if TRC_FREERTOS_VERSION == TRC_FREERTOS_VERSION_8_0_OR_LATER
\r
667 #define traceTAKE_MUTEX_RECURSIVE( pxQueue ) \
\r
668 vTraceStoreEvent2(PSF_EVENT_MUTEX_TAKE_RECURSIVE, (uint32_t)pxQueue, xTicksToWait);
\r
670 #define traceTAKE_MUTEX_RECURSIVE( pxQueue ) \
\r
671 vTraceStoreEvent2(PSF_EVENT_MUTEX_TAKE_RECURSIVE, (uint32_t)pxQueue, xBlockTime);
\r
674 #undef traceTAKE_MUTEX_RECURSIVE_FAILED
\r
675 #if TRC_FREERTOS_VERSION == TRC_FREERTOS_VERSION_8_0_OR_LATER
\r
676 #define traceTAKE_MUTEX_RECURSIVE_FAILED( pxQueue ) \
\r
677 vTraceStoreEvent2(PSF_EVENT_MUTEX_TAKE_RECURSIVE_FAILED, (uint32_t)pxQueue, xTicksToWait);
\r
679 #define traceTAKE_MUTEX_RECURSIVE_FAILED( pxQueue ) \
\r
680 vTraceStoreEvent2(PSF_EVENT_MUTEX_TAKE_RECURSIVE_FAILED, (uint32_t)pxQueue, xBlockTime);
\r
683 /* Called when a message is received in interrupt context, e.g., using xQueueReceiveFromISR */
\r
684 #undef traceQUEUE_RECEIVE_FROM_ISR
\r
685 #define traceQUEUE_RECEIVE_FROM_ISR( pxQueue ) \
\r
686 switch (pxQueue->ucQueueType) \
\r
688 case queueQUEUE_TYPE_BASE: \
\r
689 vTraceStoreEvent2(PSF_EVENT_QUEUE_RECEIVE_FROMISR, (uint32_t)pxQueue, pxQueue->uxMessagesWaiting - 1); \
\r
691 case queueQUEUE_TYPE_BINARY_SEMAPHORE: \
\r
692 case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \
\r
693 vTraceStoreEvent2(PSF_EVENT_SEMAPHORE_TAKE_FROMISR, (uint32_t)pxQueue, pxQueue->uxMessagesWaiting - 1); \
\r
697 /* Called when a message receive from interrupt context fails (since the queue was empty) */
\r
698 #undef traceQUEUE_RECEIVE_FROM_ISR_FAILED
\r
699 #define traceQUEUE_RECEIVE_FROM_ISR_FAILED( pxQueue ) \
\r
700 switch (pxQueue->ucQueueType) \
\r
702 case queueQUEUE_TYPE_BASE: \
\r
703 vTraceStoreEvent2(PSF_EVENT_QUEUE_RECEIVE_FROMISR_FAILED, (uint32_t)pxQueue, pxQueue->uxMessagesWaiting); \
\r
705 case queueQUEUE_TYPE_BINARY_SEMAPHORE: \
\r
706 case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \
\r
707 vTraceStoreEvent2(PSF_EVENT_SEMAPHORE_TAKE_FROMISR_FAILED, (uint32_t)pxQueue, pxQueue->uxMessagesWaiting); \
\r
711 /* Called on xQueuePeek */
\r
712 #undef traceQUEUE_PEEK
\r
713 #define traceQUEUE_PEEK( pxQueue ) \
\r
714 switch (pxQueue->ucQueueType) \
\r
716 case queueQUEUE_TYPE_BASE: \
\r
717 vTraceStoreEvent3(PSF_EVENT_QUEUE_PEEK, (uint32_t)pxQueue, xTicksToWait, pxQueue->uxMessagesWaiting); \
\r
719 case queueQUEUE_TYPE_BINARY_SEMAPHORE: \
\r
720 case queueQUEUE_TYPE_COUNTING_SEMAPHORE: \
\r
721 vTraceStoreEvent3(PSF_EVENT_SEMAPHORE_PEEK, (uint32_t)pxQueue, xTicksToWait, pxQueue->uxMessagesWaiting); \
\r
723 case queueQUEUE_TYPE_MUTEX: \
\r
724 case queueQUEUE_TYPE_RECURSIVE_MUTEX: \
\r
725 vTraceStoreEvent1(PSF_EVENT_MUTEX_PEEK, (uint32_t)pxQueue); \
\r
729 /* Called in vTaskPrioritySet */
\r
730 #undef traceTASK_PRIORITY_SET
\r
731 #define traceTASK_PRIORITY_SET( pxTask, uxNewPriority ) \
\r
732 vTraceStoreEvent2(PSF_EVENT_TASK_PRIORITY, (uint32_t)pxTask, uxNewPriority);
\r
734 /* Called in vTaskPriorityInherit, which is called by Mutex operations */
\r
735 #undef traceTASK_PRIORITY_INHERIT
\r
736 #define traceTASK_PRIORITY_INHERIT( pxTask, uxNewPriority ) \
\r
737 vTraceStoreEvent2(PSF_EVENT_TASK_PRIO_INHERIT, (uint32_t)pxTask, uxNewPriority);
\r
739 /* Called in vTaskPriorityDisinherit, which is called by Mutex operations */
\r
740 #undef traceTASK_PRIORITY_DISINHERIT
\r
741 #define traceTASK_PRIORITY_DISINHERIT( pxTask, uxNewPriority ) \
\r
742 vTraceStoreEvent2(PSF_EVENT_TASK_PRIO_DISINHERIT, (uint32_t)pxTask, uxNewPriority);
\r
744 /* Called in vTaskResume */
\r
745 #undef traceTASK_RESUME
\r
746 #define traceTASK_RESUME( pxTaskToResume ) \
\r
747 vTraceStoreEvent1(PSF_EVENT_TASK_RESUME, (uint32_t)pxTaskToResume);
\r
749 /* Called in vTaskResumeFromISR */
\r
750 #undef traceTASK_RESUME_FROM_ISR
\r
751 #define traceTASK_RESUME_FROM_ISR( pxTaskToResume ) \
\r
752 vTraceStoreEvent1(PSF_EVENT_TASK_RESUME_FROMISR, (uint32_t)pxTaskToResume);
\r
755 #define traceMALLOC( pvAddress, uiSize ) \
\r
756 vTraceStoreEvent2(PSF_EVENT_MALLOC, (uint32_t)pvAddress, (int32_t)uiSize);
\r
759 #define traceFREE( pvAddress, uiSize ) \
\r
760 vTraceStoreEvent2(PSF_EVENT_FREE, (uint32_t)pvAddress, (int32_t)(-uiSize));
\r
762 /* Called in timer.c - xTimerCreate */
\r
763 #undef traceTIMER_CREATE
\r
764 #define traceTIMER_CREATE(tmr) \
\r
765 vTraceStoreEvent2(PSF_EVENT_TIMER_CREATE, (uint32_t)tmr, tmr->xTimerPeriodInTicks);
\r
767 #undef traceTIMER_CREATE_FAILED
\r
768 #define traceTIMER_CREATE_FAILED() \
\r
769 vTraceStoreEvent0(PSF_EVENT_TIMER_CREATE_FAILED);
\r
771 #if TRC_FREERTOS_VERSION == TRC_FREERTOS_VERSION_8_0_OR_LATER
\r
772 #define traceTIMER_COMMAND_SEND_8_0_CASES(tmr) \
\r
773 case tmrCOMMAND_RESET: \
\r
774 vTraceStoreEvent2((xReturn == pdPASS) ? PSF_EVENT_TIMER_RESET : PSF_EVENT_TIMER_RESET_FAILED, (uint32_t)tmr, xOptionalValue); \
\r
776 case tmrCOMMAND_START_FROM_ISR: \
\r
777 vTraceStoreEvent2((xReturn == pdPASS) ? PSF_EVENT_TIMER_START_FROMISR : PSF_EVENT_TIMER_START_FROMISR_FAILED, (uint32_t)tmr, xOptionalValue); \
\r
779 case tmrCOMMAND_RESET_FROM_ISR: \
\r
780 vTraceStoreEvent2((xReturn == pdPASS) ? PSF_EVENT_TIMER_RESET_FROMISR : PSF_EVENT_TIMER_RESET_FROMISR_FAILED, (uint32_t)tmr, xOptionalValue); \
\r
782 case tmrCOMMAND_STOP_FROM_ISR: \
\r
783 vTraceStoreEvent2((xReturn == pdPASS) ? PSF_EVENT_TIMER_STOP_FROMISR : PSF_EVENT_TIMER_STOP_FROMISR_FAILED, (uint32_t)tmr, xOptionalValue); \
\r
785 case tmrCOMMAND_CHANGE_PERIOD_FROM_ISR: \
\r
786 vTraceStoreEvent2((xReturn == pdPASS) ? PSF_EVENT_TIMER_CHANGEPERIOD_FROMISR : PSF_EVENT_TIMER_CHANGEPERIOD_FROMISR_FAILED, (uint32_t)tmr, xOptionalValue); \
\r
789 #define traceTIMER_COMMAND_SEND_8_0_CASES(tmr)
\r
792 /* Note that xCommandID can never be tmrCOMMAND_EXECUTE_CALLBACK (-1) since the trace macro is not called in that case */
\r
793 #undef traceTIMER_COMMAND_SEND
\r
794 #define traceTIMER_COMMAND_SEND(tmr, xCommandID, xOptionalValue, xReturn) \
\r
795 switch(xCommandID) \
\r
797 case tmrCOMMAND_START: \
\r
799 case tmrCOMMAND_STOP: \
\r
801 case tmrCOMMAND_CHANGE_PERIOD: \
\r
802 vTraceStoreEvent2((xReturn == pdPASS) ? PSF_EVENT_TIMER_CHANGEPERIOD : PSF_EVENT_TIMER_CHANGEPERIOD_FAILED, (uint32_t)tmr, xOptionalValue); \
\r
804 case tmrCOMMAND_DELETE: \
\r
805 vTraceStoreEvent1((xReturn == pdPASS) ? PSF_EVENT_TIMER_DELETE : PSF_EVENT_TIMER_DELETE_FAILED, (uint32_t)tmr); \
\r
807 traceTIMER_COMMAND_SEND_8_0_CASES(tmr) \
\r
810 #undef tracePEND_FUNC_CALL
\r
811 #define tracePEND_FUNC_CALL(func, arg1, arg2, ret) \
\r
812 vTraceStoreEvent1((ret == pdPASS) ? PSF_EVENT_TIMER_PENDFUNCCALL : PSF_EVENT_TIMER_PENDFUNCCALL_FAILED, (uint32_t)func);
\r
814 #undef tracePEND_FUNC_CALL_FROM_ISR
\r
815 #define tracePEND_FUNC_CALL_FROM_ISR(func, arg1, arg2, ret) \
\r
816 vTraceStoreEvent1((ret == pdPASS) ? PSF_EVENT_TIMER_PENDFUNCCALL_FROMISR : PSF_EVENT_TIMER_PENDFUNCCALL_FROMISR_FAILED, (uint32_t)func);
\r
818 #undef traceEVENT_GROUP_CREATE
\r
819 #define traceEVENT_GROUP_CREATE(eg) \
\r
820 vTraceStoreEvent1(PSF_EVENT_EVENTGROUP_CREATE, (uint32_t)eg);
\r
822 #undef traceEVENT_GROUP_DELETE
\r
823 #define traceEVENT_GROUP_DELETE(eg) \
\r
824 vTraceStoreEvent1(PSF_EVENT_EVENTGROUP_DELETE, (uint32_t)eg);
\r
826 #undef traceEVENT_GROUP_CREATE_FAILED
\r
827 #define traceEVENT_GROUP_CREATE_FAILED() \
\r
828 vTraceStoreEvent0(PSF_EVENT_EVENTGROUP_CREATE_FAILED);
\r
830 #undef traceEVENT_GROUP_SYNC_BLOCK
\r
831 #define traceEVENT_GROUP_SYNC_BLOCK(eg, bitsToSet, bitsToWaitFor) \
\r
832 vTraceStoreEvent2(PSF_EVENT_EVENTGROUP_SYNC_BLOCK, (uint32_t)eg, bitsToWaitFor);
\r
834 #undef traceEVENT_GROUP_SYNC_END
\r
835 #define traceEVENT_GROUP_SYNC_END(eg, bitsToSet, bitsToWaitFor, wasTimeout) \
\r
836 vTraceStoreEvent2((wasTimeout != pdTRUE) ? PSF_EVENT_EVENTGROUP_SYNC : PSF_EVENT_EVENTGROUP_SYNC_FAILED, (uint32_t)eg, bitsToWaitFor);
\r
838 #undef traceEVENT_GROUP_WAIT_BITS_BLOCK
\r
839 #define traceEVENT_GROUP_WAIT_BITS_BLOCK(eg, bitsToWaitFor) \
\r
840 vTraceStoreEvent2(PSF_EVENT_EVENTGROUP_WAITBITS_BLOCK, (uint32_t)eg, bitsToWaitFor);
\r
842 #undef traceEVENT_GROUP_WAIT_BITS_END
\r
843 #define traceEVENT_GROUP_WAIT_BITS_END(eg, bitsToWaitFor, wasTimeout) \
\r
844 vTraceStoreEvent2((wasTimeout != pdTRUE) ? PSF_EVENT_EVENTGROUP_WAITBITS : PSF_EVENT_EVENTGROUP_WAITBITS_FAILED, (uint32_t)eg, bitsToWaitFor);
\r
846 #undef traceEVENT_GROUP_CLEAR_BITS
\r
847 #define traceEVENT_GROUP_CLEAR_BITS(eg, bitsToClear) \
\r
848 vTraceStoreEvent2(PSF_EVENT_EVENTGROUP_CLEARBITS, (uint32_t)eg, bitsToClear);
\r
850 #undef traceEVENT_GROUP_CLEAR_BITS_FROM_ISR
\r
851 #define traceEVENT_GROUP_CLEAR_BITS_FROM_ISR(eg, bitsToClear) \
\r
852 vTraceStoreEvent2(PSF_EVENT_EVENTGROUP_CLEARBITS_FROMISR, (uint32_t)eg, bitsToClear);
\r
854 #undef traceEVENT_GROUP_SET_BITS
\r
855 #define traceEVENT_GROUP_SET_BITS(eg, bitsToSet) \
\r
856 vTraceStoreEvent2(PSF_EVENT_EVENTGROUP_SETBITS, (uint32_t)eg, bitsToSet);
\r
858 #undef traceEVENT_GROUP_SET_BITS_FROM_ISR
\r
859 #define traceEVENT_GROUP_SET_BITS_FROM_ISR(eg, bitsToSet) \
\r
860 vTraceStoreEvent2(PSF_EVENT_EVENTGROUP_SETBITS_FROMISR, (uint32_t)eg, bitsToSet);
\r
862 #undef traceTASK_NOTIFY_TAKE
\r
863 #define traceTASK_NOTIFY_TAKE() \
\r
864 if (pxCurrentTCB->eNotifyState == eNotified) \
\r
865 vTraceStoreEvent2(PSF_EVENT_TASK_NOTIFY_TAKE, (uint32_t)pxCurrentTCB, xTicksToWait); \
\r
867 vTraceStoreEvent2(PSF_EVENT_TASK_NOTIFY_TAKE_FAILED, (uint32_t)pxCurrentTCB, xTicksToWait);
\r
869 #undef traceTASK_NOTIFY_TAKE_BLOCK
\r
870 #define traceTASK_NOTIFY_TAKE_BLOCK() \
\r
871 vTraceStoreEvent2(PSF_EVENT_TASK_NOTIFY_TAKE_BLOCK, (uint32_t)pxCurrentTCB, xTicksToWait);
\r
873 #undef traceTASK_NOTIFY_WAIT
\r
874 #define traceTASK_NOTIFY_WAIT() \
\r
875 if (pxCurrentTCB->eNotifyState == eNotified) \
\r
876 vTraceStoreEvent2(PSF_EVENT_TASK_NOTIFY_WAIT, (uint32_t)pxCurrentTCB, xTicksToWait); \
\r
878 vTraceStoreEvent2(PSF_EVENT_TASK_NOTIFY_WAIT_FAILED, (uint32_t)pxCurrentTCB, xTicksToWait);
\r
880 #undef traceTASK_NOTIFY_WAIT_BLOCK
\r
881 #define traceTASK_NOTIFY_WAIT_BLOCK() \
\r
882 vTraceStoreEvent2(PSF_EVENT_TASK_NOTIFY_WAIT_BLOCK, (uint32_t)pxCurrentTCB, xTicksToWait);
\r
884 #undef traceTASK_NOTIFY
\r
885 #define traceTASK_NOTIFY() \
\r
886 vTraceStoreEvent1(PSF_EVENT_TASK_NOTIFY, (uint32_t)xTaskToNotify);
\r
888 #undef traceTASK_NOTIFY_FROM_ISR
\r
889 #define traceTASK_NOTIFY_FROM_ISR() \
\r
890 vTraceStoreEvent1(PSF_EVENT_TASK_NOTIFY_FROM_ISR, (uint32_t)xTaskToNotify);
\r
892 #undef traceTASK_NOTIFY_GIVE_FROM_ISR
\r
893 #define traceTASK_NOTIFY_GIVE_FROM_ISR() \
\r
894 vTraceStoreEvent1(PSF_EVENT_TASK_NOTIFY_GIVE_FROM_ISR, (uint32_t)xTaskToNotify);
\r
896 /************************************************************************/
\r
897 /* KERNEL SPECIFIC MACROS TO NAME OBJECTS, IF NECESSARY */
\r
898 /************************************************************************/
\r
899 #define vTraceSetQueueName(object, name) \
\r
900 vTraceStoreKernelObjectName(object, name);
\r
902 #define vTraceSetSemaphoreName(object, name) \
\r
903 vTraceStoreKernelObjectName(object, name);
\r
905 #define vTraceSetMutexName(object, name) \
\r
906 vTraceStoreKernelObjectName(object, name);
\r
908 #define vTraceSetEventGroupName(object, name) \
\r
909 vTraceStoreKernelObjectName(object, name);
\r
911 #else /*(USE_TRACEALYZER_RECORDER == 1)*/
\r
913 #define vTraceSetQueueName(object, name)
\r
915 #define vTraceSetSemaphoreName(object, name)
\r
917 #define vTraceSetMutexName(object, name)
\r
919 #define vTraceSetEventGroupName(object, name)
\r
921 #define Trace_Init()
\r
923 #endif /*(USE_TRACEALYZER_RECORDER == 1)*/
\r
929 #endif /* TRC_KERNEL_PORT_H */
\r
projects / freertos / blob