RTX5: Updated Event Recorder configuration (also addresses #457)

CMSIS/DoxyGen/RTOS2/src/cmsis_os2.txt

@@ -903,7 +903,7 @@ annotations. The usage requires the source variant of RTX5; refer to \ref cre_rt
 \subsection evtrecConfigGlobIni Global Configuration
 Initialize Event Recorder during the \ref osKernelInitialize and optionally start event recording.
 
-\image html config_wizard_evtrecGlobIni.png "RTX_Config.h: Initialization and filter setup configuration"
+\image html config_wizard_evtrecGlobIni.png "RTX_Config.h: Global Configuration"
 
 <br/>
 
@@ -952,17 +952,17 @@ The generation of events must be enabled as explained under \ref evtrecConfigEvt
 
 Name              | \#define                   | Description
 ------------------|----------------------------|----------------------------------------------------------------
-Memory Management | \c OS_EVR_MEMORY_FILTER    | Filter enable for Memory Management events.
-Kernel            | \c OS_EVR_KERNEL_FILTER    | Filter enable for Kernel events.
-Thread            | \c OS_EVR_THREAD_FILTER    | Filter enable for Thread events.
-Generic Wait      | \c OS_EVR_WAIT_FILTER      | Filter enable for Generic Wait events.
-Thread Flags      | \c OS_EVR_THFLAGS_FILTER   | Filter enable for Thread Flags events.
-Event Flags       | \c OS_EVR_EVFLAGS_FILTER   | Filter enable for Event Flags events.
-Timer             | \c OS_EVR_TIMER_FILTER     | Filter enable for Timer events.
-Mutex             | \c OS_EVR_MUTEX_FILTER     | Filter enable for Mutex events.
-Semaphore         | \c OS_EVR_SEMAPHORE_FILTER | Filter enable for Semaphore events.
-Memory Pool       | \c OS_EVR_MEMPOOL_FILTER   | Filter enable for Memory Pool events.
-Message Queue     | \c OS_EVR_MSGQUEUE_FILTER  | Filter enable for Message Queue events.
+Memory Management | \c OS_EVR_MEMORY_LEVEL     | Recording level for Memory Management events.
+Kernel            | \c OS_EVR_KERNEL_LEVEL     | Recording level for Kernel events.
+Thread            | \c OS_EVR_THREAD_LEVEL     | Recording level for Thread events.
+Generic Wait      | \c OS_EVR_WAIT_LEVEL       | Recording level for Generic Wait events.
+Thread Flags      | \c OS_EVR_THFLAGS_LEVEL    | Recording level for Thread Flags events.
+Event Flags       | \c OS_EVR_EVFLAGS_LEVEL    | Recording level for Event Flags events.
+Timer             | \c OS_EVR_TIMER_LEVEL      | Recording level for Timer events.
+Mutex             | \c OS_EVR_MUTEX_LEVEL      | Recording level for Mutex events.
+Semaphore         | \c OS_EVR_SEMAPHORE_LEVEL  | Recording level for Semaphore events.
+Memory Pool       | \c OS_EVR_MEMPOOL_LEVEL    | Recording level for Memory Pool events.
+Message Queue     | \c OS_EVR_MSGQUEUE_LEVEL   | Recording level for Message Queue events.
  
 
 \subsection evtrecConfigEvtGen RTOS Event Generation

CMSIS/RTOS2/RTX/Config/RTX_Config.h

@@ -353,7 +353,7 @@
 #endif
  
 //     <h>Global Event Filter Setup
-//     <i> Initial event filter settings applied to all components.
+//     <i> Initial recording level applied to all components.
 //       <o.0>Error events
 //       <o.1>API function call events
 //       <o.2>Operation events
@@ -364,128 +364,128 @@
 #endif
  
 //     <h>RTOS Event Filter Setup
-//     <i> Event filter settings for RTX components.
+//     <i> Recording levels for RTX components.
 //     <i> Only applicable if events for the respective component are generated.
  
-//       <e.7>Memory Management
-//       <i> Filter enable settings for Memory Management events.
+//       <h>Memory Management
+//       <i> Recording level for Memory Management events.
 //         <o.0>Error events
 //         <o.1>API function call events
 //         <o.2>Operation events
 //         <o.3>Detailed operation events
-//       </e>
-#ifndef OS_EVR_MEMORY_FILTER
-#define OS_EVR_MEMORY_FILTER        0x81U
+//       </h>
+#ifndef OS_EVR_MEMORY_LEVEL 
+#define OS_EVR_MEMORY_LEVEL         0x01U
 #endif
  
-//       <e.7>Kernel
-//       <i> Filter enable settings for Kernel events.
+//       <h>Kernel
+//       <i> Recording level for Kernel events.
 //         <o.0>Error events
 //         <o.1>API function call events
 //         <o.2>Operation events
 //         <o.3>Detailed operation events
-//       </e>
-#ifndef OS_EVR_KERNEL_FILTER
-#define OS_EVR_KERNEL_FILTER        0x81U
+//       </h>
+#ifndef OS_EVR_KERNEL_LEVEL 
+#define OS_EVR_KERNEL_LEVEL         0x01U
 #endif
  
-//       <e.7>Thread
-//       <i> Filter enable settings for Thread events.
+//       <h>Thread
+//       <i> Recording level for Thread events.
 //         <o.0>Error events
 //         <o.1>API function call events
 //         <o.2>Operation events
 //         <o.3>Detailed operation events
-//       </e>
-#ifndef OS_EVR_THREAD_FILTER
-#define OS_EVR_THREAD_FILTER        0x85U
+//       </h>
+#ifndef OS_EVR_THREAD_LEVEL 
+#define OS_EVR_THREAD_LEVEL         0x05U
 #endif
  
-//       <e.7>Generic Wait
-//       <i> Filter enable settings for Generic Wait events.
+//       <h>Generic Wait
+//       <i> Recording level for Generic Wait events.
 //         <o.0>Error events
 //         <o.1>API function call events
 //         <o.2>Operation events
 //         <o.3>Detailed operation events
-//       </e>
-#ifndef OS_EVR_WAIT_FILTER
-#define OS_EVR_WAIT_FILTER          0x81U
+//       </h>
+#ifndef OS_EVR_WAIT_LEVEL 
+#define OS_EVR_WAIT_LEVEL           0x01U
 #endif
  
-//       <e.7>Thread Flags
-//       <i> Filter enable settings for Thread Flags events.
+//       <h>Thread Flags
+//       <i> Recording level for Thread Flags events.
 //         <o.0>Error events
 //         <o.1>API function call events
 //         <o.2>Operation events
 //         <o.3>Detailed operation events
-//       </e>
-#ifndef OS_EVR_THFLAGS_FILTER
-#define OS_EVR_THFLAGS_FILTER       0x81U
+//       </h>
+#ifndef OS_EVR_THFLAGS_LEVEL 
+#define OS_EVR_THFLAGS_LEVEL        0x01U
 #endif
  
-//       <e.7>Event Flags
-//       <i> Filter enable settings for Event Flags events.
+//       <h>Event Flags
+//       <i> Recording level for Event Flags events.
 //         <o.0>Error events
 //         <o.1>API function call events
 //         <o.2>Operation events
 //         <o.3>Detailed operation events
-//       </e>
-#ifndef OS_EVR_EVFLAGS_FILTER
-#define OS_EVR_EVFLAGS_FILTER       0x81U
+//       </h>
+#ifndef OS_EVR_EVFLAGS_LEVEL 
+#define OS_EVR_EVFLAGS_LEVEL        0x01U
 #endif
  
-//       <e.7>Timer
-//       <i> Filter enable settings for Timer events.
+//       <h>Timer
+//       <i> Recording level for Timer events.
 //         <o.0>Error events
 //         <o.1>API function call events
 //         <o.2>Operation events
 //         <o.3>Detailed operation events
-//       </e>
-#ifndef OS_EVR_TIMER_FILTER
-#define OS_EVR_TIMER_FILTER         0x81U
+//       </h>
+#ifndef OS_EVR_TIMER_LEVEL 
+#define OS_EVR_TIMER_LEVEL          0x01U
 #endif
  
-//       <e.7>Mutex
-//       <i> Filter enable settings for Mutex events.
+//       <h>Mutex
+//       <i> Recording level for Mutex events.
 //         <o.0>Error events
 //         <o.1>API function call events
 //         <o.2>Operation events
 //         <o.3>Detailed operation events
-//       </e>
-#ifndef OS_EVR_MUTEX_FILTER
-#define OS_EVR_MUTEX_FILTER         0x81U
+//       </h>
+#ifndef OS_EVR_MUTEX_LEVEL 
+#define OS_EVR_MUTEX_LEVEL          0x01U
 #endif
  
-//       <e.7>Semaphore
-//       <i> Filter enable settings for Semaphore events.
+//       <h>Semaphore
+//       <i> Recording level for Semaphore events.
 //         <o.0>Error events
 //         <o.1>API function call events
 //         <o.2>Operation events
 //         <o.3>Detailed operation events
-//       </e>
-#ifndef OS_EVR_SEMAPHORE_FILTER
-#define OS_EVR_SEMAPHORE_FILTER     0x81U
+//       </h>
+#ifndef OS_EVR_SEMAPHORE_LEVEL 
+#define OS_EVR_SEMAPHORE_LEVEL      0x01U
 #endif
  
-//       <e.7>Memory Pool
-//       <i> Filter enable settings for Memory Pool events.
+//       <h>Memory Pool
+//       <i> Recording level for Memory Pool events.
 //         <o.0>Error events
 //         <o.1>API function call events
 //         <o.2>Operation events
 //         <o.3>Detailed operation events
-//       </e>
-#ifndef OS_EVR_MEMPOOL_FILTER
-#define OS_EVR_MEMPOOL_FILTER       0x81U
+//       </h>
+#ifndef OS_EVR_MEMPOOL_LEVEL 
+#define OS_EVR_MEMPOOL_LEVEL        0x01U
 #endif
  
-//       <e.7>Message Queue
-//       <i> Filter enable settings for Message Queue events.
+//       <h>Message Queue
+//       <i> Recording level for Message Queue events.
 //         <o.0>Error events
 //         <o.1>API function call events
 //         <o.2>Operation events
 //         <o.3>Detailed operation events
-//       </e>
-#ifndef OS_EVR_MSGQUEUE_FILTER
-#define OS_EVR_MSGQUEUE_FILTER      0x81U
+//       </h>
+#ifndef OS_EVR_MSGQUEUE_LEVEL 
+#define OS_EVR_MSGQUEUE_LEVEL       0x01U
 #endif
  
 //     </h>

CMSIS/RTOS2/RTX/Include/rtx_evr.h

@@ -34,15 +34,9 @@
 #ifndef   OS_EVR_THFLAGS
 #define   OS_EVR_THFLAGS        OS_EVR_THREAD
 #endif
-#ifndef   OS_EVR_THFLAGS_FILTER
-#define   OS_EVR_THFLAGS_FILTER OS_EVR_THREAD_FILTER
-#endif
 #ifndef   OS_EVR_WAIT
 #define   OS_EVR_WAIT           OS_EVR_THREAD
 #endif
-#ifndef   OS_EVR_WAIT_FILTER
-#define   OS_EVR_WAIT_FILTER    OS_EVR_THREAD_FILTER
-#endif
 
 #include "RTE_Components.h"
 

CMSIS/RTOS2/RTX/Source/rtx_lib.c

@@ -361,46 +361,71 @@ __attribute__((section(".bss.os.msgqueue.mem")));
 
 #if (defined(OS_EVR_INIT) && (OS_EVR_INIT != 0))
 
-#if  defined(RTE_Compiler_EventRecorder)
-
-// Event Recorder Initialize
-__STATIC_INLINE void evr_initialize (void) {
-
-  (void)EventRecorderInitialize(OS_EVR_LEVEL, (uint32_t)OS_EVR_START);
+// Initial Thread configuration covered also Thread Flags and Generic Wait
+#if  defined(OS_EVR_THREAD_FILTER)
+#if !defined(OS_EVR_THFLAGS_FILTER)
+#define OS_EVR_THFLAGS_FILTER   OS_EVR_THREAD_FILTER
+#endif
+#if !defined(OS_EVR_WAIT_FILTER)
+#define OS_EVR_WAIT_FILTER      OS_EVR_THREAD_FILTER
+#endif
+#endif
 
-#if ((OS_EVR_MEMORY_FILTER    & 0x80U) != 0U)
-  (void)EventRecorderEnable(OS_EVR_MEMORY_FILTER    & 0x0FU, EvtRtxMemoryNo,       EvtRtxMemoryNo);
+// Migrate initial filter configuration
+#if  defined(OS_EVR_MEMORY_FILTER)
+#define OS_EVR_MEMORY_LEVEL     (((OS_EVR_MEMORY_FILTER    & 0x80U) != 0U) ? (OS_EVR_MEMORY_FILTER    & 0x0FU) : 0U)
 #endif
-#if ((OS_EVR_KERNEL_FILTER    & 0x80U) != 0U)
-  (void)EventRecorderEnable(OS_EVR_KERNEL_FILTER    & 0x0FU, EvtRtxKernelNo,       EvtRtxKernelNo);
+#if  defined(OS_EVR_KERNEL_FILTER)
+#define OS_EVR_KERNEL_LEVEL     (((OS_EVR_KERNEL_FILTER    & 0x80U) != 0U) ? (OS_EVR_KERNEL_FILTER    & 0x0FU) : 0U)
 #endif
-#if ((OS_EVR_THREAD_FILTER    & 0x80U) != 0U)
-  (void)EventRecorderEnable(OS_EVR_THREAD_FILTER    & 0x0FU, EvtRtxThreadNo,       EvtRtxThreadNo);
+#if  defined(OS_EVR_THREAD_FILTER)
+#define OS_EVR_THREAD_LEVEL     (((OS_EVR_THREAD_FILTER    & 0x80U) != 0U) ? (OS_EVR_THREAD_FILTER    & 0x0FU) : 0U)
 #endif
-#if ((OS_EVR_WAIT_FILTER      & 0x80U) != 0U)
-  (void)EventRecorderEnable(OS_EVR_WAIT_FILTER      & 0x0FU, EvtRtxWaitNo,         EvtRtxWaitNo);
+#if  defined(OS_EVR_WAIT_FILTER)
+#define OS_EVR_WAIT_LEVEL       (((OS_EVR_WAIT_FILTER      & 0x80U) != 0U) ? (OS_EVR_WAIT_FILTER      & 0x0FU) : 0U)
 #endif
-#if ((OS_EVR_THFLAGS_FILTER   & 0x80U) != 0U)
-  (void)EventRecorderEnable(OS_EVR_THFLAGS_FILTER   & 0x0FU, EvtRtxThreadFlagsNo,  EvtRtxThreadFlagsNo);
+#if  defined(OS_EVR_THFLAGS_FILTER)
+#define OS_EVR_THFLAGS_LEVEL    (((OS_EVR_THFLAGS_FILTER   & 0x80U) != 0U) ? (OS_EVR_THFLAGS_FILTER   & 0x0FU) : 0U)
 #endif
-#if ((OS_EVR_EVFLAGS_FILTER   & 0x80U) != 0U)
-  (void)EventRecorderEnable(OS_EVR_EVFLAGS_FILTER   & 0x0FU, EvtRtxEventFlagsNo,   EvtRtxEventFlagsNo);
+#if  defined(OS_EVR_EVFLAGS_FILTER)
+#define OS_EVR_EVFLAGS_LEVEL    (((OS_EVR_EVFLAGS_FILTER   & 0x80U) != 0U) ? (OS_EVR_EVFLAGS_FILTER   & 0x0FU) : 0U)
 #endif
-#if ((OS_EVR_TIMER_FILTER     & 0x80U) != 0U)
-  (void)EventRecorderEnable(OS_EVR_TIMER_FILTER     & 0x0FU, EvtRtxTimerNo,        EvtRtxTimerNo);
+#if  defined(OS_EVR_TIMER_FILTER)
+#define OS_EVR_TIMER_LEVEL      (((OS_EVR_TIMER_FILTER     & 0x80U) != 0U) ? (OS_EVR_TIMER_FILTER     & 0x0FU) : 0U)
 #endif
-#if ((OS_EVR_MUTEX_FILTER     & 0x80U) != 0U)
-  (void)EventRecorderEnable(OS_EVR_MUTEX_FILTER     & 0x0FU, EvtRtxMutexNo,        EvtRtxMutexNo);
+#if  defined(OS_EVR_MUTEX_FILTER)
+#define OS_EVR_MUTEX_LEVEL      (((OS_EVR_MUTEX_FILTER     & 0x80U) != 0U) ? (OS_EVR_MUTEX_FILTER     & 0x0FU) : 0U)
 #endif
-#if ((OS_EVR_SEMAPHORE_FILTER & 0x80U) != 0U)
-  (void)EventRecorderEnable(OS_EVR_SEMAPHORE_FILTER & 0x0FU, EvtRtxSemaphoreNo,    EvtRtxSemaphoreNo);
+#if  defined(OS_EVR_SEMAPHORE_FILTER)
+#define OS_EVR_SEMAPHORE_LEVEL  (((OS_EVR_SEMAPHORE_FILTER & 0x80U) != 0U) ? (OS_EVR_SEMAPHORE_FILTER & 0x0FU) : 0U)
 #endif
-#if ((OS_EVR_MEMPOOL_FILTER   & 0x80U) != 0U)
-  (void)EventRecorderEnable(OS_EVR_MEMPOOL_FILTER   & 0x0FU, EvtRtxMemoryPoolNo,   EvtRtxMemoryPoolNo);
+#if  defined(OS_EVR_MEMPOOL_FILTER)
+#define OS_EVR_MEMPOOL_LEVEL    (((OS_EVR_MEMPOOL_FILTER   & 0x80U) != 0U) ? (OS_EVR_MEMPOOL_FILTER   & 0x0FU) : 0U)
 #endif
-#if ((OS_EVR_MSGQUEUE_FILTER  & 0x80U) != 0U)
-  (void)EventRecorderEnable(OS_EVR_MSGQUEUE_FILTER  & 0x0FU, EvtRtxMessageQueueNo, EvtRtxMessageQueueNo);
+#if  defined(OS_EVR_MSGQUEUE_FILTER)
+#define OS_EVR_MSGQUEUE_LEVEL   (((OS_EVR_MSGQUEUE_FILTER  & 0x80U) != 0U) ? (OS_EVR_MSGQUEUE_FILTER  & 0x0FU) : 0U)
 #endif
+
+#if  defined(RTE_Compiler_EventRecorder)
+
+// Event Recorder Initialize
+__STATIC_INLINE void evr_initialize (void) {
+
+  (void)EventRecorderInitialize(OS_EVR_LEVEL, (uint32_t)OS_EVR_START);
+
+  (void)EventRecorderDisable(EventRecordAll,        EvtRtxMemoryNo,       EvtRtxMessageQueueNo);
+
+  (void)EventRecorderEnable(OS_EVR_MEMORY_LEVEL,    EvtRtxMemoryNo,       EvtRtxMemoryNo);
+  (void)EventRecorderEnable(OS_EVR_KERNEL_LEVEL,    EvtRtxKernelNo,       EvtRtxKernelNo);
+  (void)EventRecorderEnable(OS_EVR_THREAD_LEVEL,    EvtRtxThreadNo,       EvtRtxThreadNo);
+  (void)EventRecorderEnable(OS_EVR_WAIT_LEVEL,      EvtRtxWaitNo,         EvtRtxWaitNo);
+  (void)EventRecorderEnable(OS_EVR_THFLAGS_LEVEL,   EvtRtxThreadFlagsNo,  EvtRtxThreadFlagsNo);
+  (void)EventRecorderEnable(OS_EVR_EVFLAGS_LEVEL,   EvtRtxEventFlagsNo,   EvtRtxEventFlagsNo);
+  (void)EventRecorderEnable(OS_EVR_TIMER_LEVEL,     EvtRtxTimerNo,        EvtRtxTimerNo);
+  (void)EventRecorderEnable(OS_EVR_MUTEX_LEVEL,     EvtRtxMutexNo,        EvtRtxMutexNo);
+  (void)EventRecorderEnable(OS_EVR_SEMAPHORE_LEVEL, EvtRtxSemaphoreNo,    EvtRtxSemaphoreNo);
+  (void)EventRecorderEnable(OS_EVR_MEMPOOL_LEVEL,   EvtRtxMemoryPoolNo,   EvtRtxMemoryPoolNo);
+  (void)EventRecorderEnable(OS_EVR_MSGQUEUE_LEVEL,  EvtRtxMessageQueueNo, EvtRtxMessageQueueNo);
 }
 
 #else