diff --git a/CMSIS/RTOS2/RTX/Config/RTX_Config.h b/CMSIS/RTOS2/RTX/Config/RTX_Config.h
index 0bb374c..669476d 100644
--- a/CMSIS/RTOS2/RTX/Config/RTX_Config.h
+++ b/CMSIS/RTOS2/RTX/Config/RTX_Config.h
@@ -54,6 +54,46 @@
  
 //   </e>
  
+//   <h>Event Recording
+ 
+//     <q>Memory Management
+//     <i> Enables Memory Management events recording.
+#define OS_EVR_MEMORY               1
+ 
+//     <q>Kernel
+//     <i> Enables Kernel events recording.
+#define OS_EVR_KERNEL               1
+ 
+//     <q>Thread
+//     <i> Enables Thread events recording.
+#define OS_EVR_THREAD               1
+ 
+//     <q>Timer
+//     <i> Enables Timer events recording.
+#define OS_EVR_TIMER                1
+ 
+//     <q>Event Flags
+//     <i> Enables Event Flags events recording.
+#define OS_EVR_EVFLAGS              1
+ 
+//     <q>Mutex
+//     <i> Enables Mutex events recording.
+#define OS_EVR_MUTEX                1
+ 
+//     <q>Semaphore
+//     <i> Enables Semaphore events recording.
+#define OS_EVR_SEMAPHORE            1
+ 
+//     <q>Memory Pool
+//     <i> Enables Memory Pool events recording.
+#define OS_EVR_MEMPOOL              1
+ 
+//     <q>Message Queue
+//     <i> Enables Message Queue events recording.
+#define OS_EVR_MSGQUEUE             1
+ 
+//   </h>
+ 
 //   <o>ISR FIFO Queue 
 //      <4=>  4 entries    <8=>   8 entries   <12=>  12 entries   <16=>  16 entries
 //     <24=> 24 entries   <32=>  32 entries   <48=>  48 entries   <64=>  64 entries
diff --git a/CMSIS/RTOS2/RTX/Include/rtx_evr.h b/CMSIS/RTOS2/RTX/Include/rtx_evr.h
new file mode 100644
index 0000000..3ccb60e
--- /dev/null
+++ b/CMSIS/RTOS2/RTX/Include/rtx_evr.h
@@ -0,0 +1,1765 @@
+/*
+ * Copyright (c) 2013-2016 ARM Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * -----------------------------------------------------------------------------
+ *
+ * Project:     CMSIS-RTOS RTX
+ * Title:       RTX Event Recorder definitions
+ *
+ * -----------------------------------------------------------------------------
+ */
+
+#ifndef RTX_EVR_H_
+#define RTX_EVR_H_
+
+#include "cmsis_os2.h"                  // CMSIS RTOS API
+#include "rtx_os.h"                     // RTX OS definitions
+#include "RTX_Config.h"
+
+
+/// Extended Status codes
+#define osRtxErrorKernelNotReady        (-7)
+#define osRtxErrorKernelNotRunning      (-8)
+#define osRtxErrorInvalidControlBlock   (-9)
+#define osRtxErrorInvalidDataMemory     (-10)
+#define osRtxErrorInvalidThreadStack    (-11)
+#define osRtxErrorInvalidPriority       (-12)
+#define osRtxErrorThreadNotJoinable     (-13)
+#define osRtxErrorMutexNotOwned         (-14)
+#define osRtxErrorMutexNotLocked        (-15)
+#define osRtxErrorMutexLockLimit        (-16)
+#define osRtxErrorSemaphoreCountLimit   (-17)
+#define osRtxErrorTZ_InitContext_S      (-18)
+#define osRtxErrorTZ_AllocContext_S     (-19)
+#define osRtxErrorTZ_FreeContext_S      (-20)
+#define osRtxErrorTZ_LoadContext_S      (-21)
+#define osRtxErrorTZ_SaveContext_S      (-22)
+
+
+//  ==== Memory Events ====
+
+/**
+  \brief  Event on memory initialization (Op)
+  \param[in]  mem           pointer to memory pool.
+  \param[in]  size          size of a memory pool in bytes.
+  \param[in]  result        execution status: 1 - success, 0 - failure.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMORY != 0) && !defined(EVR_RTX_MEMORY_INIT_DISABLE))
+extern void EvrRtxMemoryInit (void *mem, uint32_t size, uint32_t result);
+#else
+#define EvrRtxMemoryInit(mem, size, result)
+#endif
+
+/**
+  \brief  Event on memory allocate (Op)
+  \param[in]  mem           pointer to memory pool.
+  \param[in]  size          size of a memory block in bytes.
+  \param[in]  type          memory block type: 0 - generic, 1 - control block
+  \param[in]  block         pointer to allocated memory block or NULL in case of no memory is available.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMORY != 0) && !defined(EVR_RTX_MEMORY_ALLOC_DISABLE))
+extern void EvrRtxMemoryAlloc (void *mem, uint32_t size, uint32_t type, void *block);
+#else
+#define EvrRtxMemoryAlloc(mem, size, type, block)
+#endif
+
+/**
+  \brief  Event on memory free (Op)
+  \param[in]  mem           pointer to memory pool.
+  \param[in]  block         memory block to be returned to the memory pool.
+  \param[in]  result        execution status: 1 - success, 0 - failure.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMORY != 0) && !defined(EVR_RTX_MEMORY_FREE_DISABLE))
+extern void EvrRtxMemoryFree (void *mem, void *block, uint32_t result);
+#else
+#define EvrRtxMemoryFree(mem, block, result)
+#endif
+
+/**
+  \brief  Event on memory block initialization (Op)
+  \param[in]  mp_info       memory pool info.
+  \param[in]  block_count   maximum number of memory blocks in memory pool.
+  \param[in]  block_size    size of a memory block in bytes.
+  \param[in]  block_mem     pointer to memory for block storage.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMORY != 0) && !defined(EVR_RTX_MEMORY_BLOCK_INIT_DISABLE))
+extern void EvrRtxMemoryBlockInit (osRtxMpInfo_t *mp_info, uint32_t block_count, uint32_t block_size, void *block_mem);
+#else
+#define EvrRtxMemoryBlockInit(mp_info, block_count, block_size, block_mem)
+#endif
+
+/**
+  \brief  Event on memory block alloc (Op)
+  \param[in]  mp_info       memory pool info.
+  \param[in]  block         address of the allocated memory block or NULL in case of no memory is available.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMORY != 0) && !defined(EVR_RTX_MEMORY_BLOCK_ALLOC_DISABLE))
+extern void EvrRtxMemoryBlockAlloc (osRtxMpInfo_t *mp_info, void *block);
+#else
+#define EvrRtxMemoryBlockAlloc(mp_info, block)
+#endif
+
+/**
+  \brief  Event on memory block free (Op)
+  \param[in]  mp_info       memory pool info.
+  \param[in]  block         address of the allocated memory block to be returned to the memory pool.
+  \param[in]  status        extended execution status.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMORY != 0) && !defined(EVR_RTX_MEMORY_BLOCK_FREE_DISABLE))
+extern void EvrRtxMemoryBlockFree (osRtxMpInfo_t *mp_info, void *block, int32_t status);
+#else
+#define EvrRtxMemoryBlockFree(mp_info, block, status)
+#endif
+
+
+//  ==== Kernel Events ====
+
+/**
+  \brief  Event on RTOS kernel error (Error)
+  \param[in]  status        extended execution status.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_ERROR_DISABLE))
+extern void EvrRtxKernelError (int32_t status);
+#else
+#define EvrRtxKernelError(status)
+#endif
+
+/**
+  \brief  Event on RTOS kernel initialize (API)
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_INITIALIZE_DISABLE))
+extern void EvrRtxKernelInitialize (void);
+#else
+#define EvrRtxKernelInitialize()
+#endif
+
+/**
+  \brief  Event on successful RTOS kernel initialize (Op)
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_INITIALIZE_COMPLETED_DISABLE))
+extern void EvrRtxKernelInitializeCompleted (void);
+#else
+#define EvrRtxKernelInitializeCompleted()
+#endif
+
+/**
+  \brief  Event on RTOS kernel information retrieve (API)
+  \param[in]  version       pointer to buffer for retrieving version information.
+  \param[in]  id_buf        pointer to buffer for retrieving kernel identification string.
+  \param[in]  id_size       size of buffer for kernel identification string.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_GET_INFO_DISABLE))
+extern void EvrRtxKernelGetInfo (osVersion_t *version, char *id_buf, uint32_t id_size);
+#else
+#define EvrRtxKernelGetInfo(version, id_buf, id_size)
+#endif
+
+/**
+  \brief  Event on successful RTOS kernel information retrieve (Op)
+  \param[in]  version       pointer to buffer for retrieving version information.
+  \param[in]  id_buf        pointer to buffer for retrieving kernel identification string.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_INFO_RETRIEVED_DISABLE))
+extern void EvrRtxKernelInfoRetrieved (osVersion_t *version, char *id_buf);
+#else
+#define EvrRtxKernelInfoRetrieved(version, id_buf)
+#endif
+
+/**
+  \brief  Event on current RTOS Kernel state retrieve (API)
+  \param[in]  state         current RTOS Kernel state.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_GET_STATE_DISABLE))
+extern void EvrRtxKernelGetState (osKernelState_t state);
+#else
+#define EvrRtxKernelGetState(state)
+#endif
+
+/**
+  \brief  Event on RTOS Kernel scheduler start (API)
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_START_DISABLE))
+extern void EvrRtxKernelStart (void);
+#else
+#define EvrRtxKernelStart()
+#endif
+
+/**
+  \brief  Event on successful RTOS Kernel scheduler start (Op)
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_STARTED_DISABLE))
+extern void EvrRtxKernelStarted (void);
+#else
+#define EvrRtxKernelStarted()
+#endif
+
+/**
+  \brief  Event on RTOS Kernel scheduler lock (API)
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_LOCK_DISABLE))
+extern void EvrRtxKernelLock (void);
+#else
+#define EvrRtxKernelLock()
+#endif
+
+/**
+  \brief  Event on successful RTOS Kernel scheduler lock (Op)
+  \param[in]  lock          previous lock state (1 - locked, 0 - not locked, error code if negative).
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_LOCKED_DISABLE))
+extern void EvrRtxKernelLocked (int32_t lock);
+#else
+#define EvrRtxKernelLocked(lock)
+#endif
+
+/**
+  \brief  Event on RTOS Kernel scheduler unlock (API)
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_UNLOCK_DISABLE))
+extern void EvrRtxKernelUnlock (void);
+#else
+#define EvrRtxKernelUnlock()
+#endif
+
+/**
+  \brief  Event on successful RTOS Kernel scheduler unlock (Op)
+  \param[in]  lock          previous lock state (1 - locked, 0 - not locked, error code if negative).
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_UNLOCKED_DISABLE))
+extern void EvrRtxKernelUnlocked (int32_t lock);
+#else
+#define EvrRtxKernelUnlocked(lock)
+#endif
+
+/**
+  \brief  Event on RTOS Kernel scheduler lock state restore (API)
+  \param[in]  lock          lock state obtained by \ref osKernelLock or \ref osKernelUnlock.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_RESTORE_LOCK_DISABLE))
+extern void EvrRtxKernelRestoreLock (int32_t lock);
+#else
+#define EvrRtxKernelRestoreLock(lock)
+#endif
+
+/**
+  \brief  Event on successful RTOS Kernel scheduler lock state restore (Op)
+  \param[in]  lock          new lock state (1 - locked, 0 - not locked, error code if negative).
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_LOCK_RESTORED_DISABLE))
+extern void EvrRtxKernelLockRestored (int32_t lock);
+#else
+#define EvrRtxKernelLockRestored(lock)
+#endif
+
+/**
+  \brief  Event on RTOS Kernel scheduler suspend (API)
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_SUSPEND_DISABLE))
+extern void EvrRtxKernelSuspend (void);
+#else
+#define EvrRtxKernelSuspend()
+#endif
+
+/**
+  \brief  Event on successful RTOS Kernel scheduler suspend (Op)
+  \param[in]  sleep_ticks   time in ticks, for how long the system can sleep or power-down.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_SUSPENDED_DISABLE))
+extern void EvrRtxKernelSuspended (uint32_t sleep_ticks);
+#else
+#define EvrRtxKernelSuspended(sleep_ticks)
+#endif
+
+/**
+  \brief  Event on RTOS Kernel scheduler resume (API)
+  \param[in]  sleep_ticks   time in ticks for how long the system was in sleep or power-down mode.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_RESUME_DISABLE))
+extern void EvrRtxKernelResume (uint32_t sleep_ticks);
+#else
+#define EvrRtxKernelResume(sleep_ticks)
+#endif
+
+/**
+  \brief  Event on successful RTOS Kernel scheduler resume (Op)
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_RESUMED_DISABLE))
+extern void EvrRtxKernelResumed (void);
+#else
+#define EvrRtxKernelResumed()
+#endif
+
+/**
+  \brief  Event on RTOS kernel tick count retrieve (API)
+  \param[in]  count         RTOS kernel current tick count.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_GET_TICK_COUNT_DISABLE))
+extern void EvrRtxKernelGetTickCount (uint64_t count);
+#else
+#define EvrRtxKernelGetTickCount(count)
+#endif
+
+/**
+  \brief  Event on RTOS kernel tick frequency retrieve (API)
+  \param[in]  freq          frequency of the kernel tick.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_GET_TICK_FREQ_DISABLE))
+extern void EvrRtxKernelGetTickFreq (uint32_t freq);
+#else
+#define EvrRtxKernelGetTickFreq(freq)
+#endif
+
+/**
+  \brief  Event on RTOS kernel system timer count retrieve (API)
+  \param[in]  count         RTOS kernel current system timer count as 32-bit value.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_GET_SYS_TIMER_COUNT_DISABLE))
+extern void EvrRtxKernelGetSysTimerCount (uint32_t count);
+#else
+#define EvrRtxKernelGetSysTimerCount(count)
+#endif
+
+/**
+  \brief  Event on RTOS kernel system timer frequency retrieve (API)
+  \param[in]  freq          frequency of the system timer.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_GET_SYS_TIMER_FREQ_DISABLE))
+extern void EvrRtxKernelGetSysTimerFreq (uint32_t freq);
+#else
+#define EvrRtxKernelGetSysTimerFreq(freq)
+#endif
+
+
+//  ==== Thread Events ====
+
+/**
+  \brief  Event on thread error (Error)
+  \param[in]  thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId or NULL when ID is unknown.
+  \param[in]  status        extended execution status.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_ERROR_DISABLE))
+extern void EvrRtxThreadError (osThreadId_t thread_id, int32_t status);
+#else
+#define EvrRtxThreadError(thread_id, status)
+#endif
+
+/**
+  \brief  Event on thread create and intialize (API)
+  \param[in]  func          thread function.
+  \param[in]  argument      pointer that is passed to the thread function as start argument.
+  \param[in]  attr          thread attributes.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_NEW_DISABLE))
+extern void EvrRtxThreadNew (osThreadFunc_t func, void *argument, const osThreadAttr_t *attr);
+#else
+#define EvrRtxThreadNew(func, argument, attr)
+#endif
+
+/**
+  \brief  Event on successful thread create (Op)
+  \param[in]  thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_CREATED_DISABLE))
+extern void EvrRtxThreadCreated (osThreadId_t thread_id);
+#else
+#define EvrRtxThreadCreated(thread_id)
+#endif
+
+/**
+  \brief  Event on thread name retrieve (API)
+  \param[in]  thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
+  \param[in]  name          pointer to thread object name
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_GET_NAME_DISABLE))
+extern void EvrRtxThreadGetName (osThreadId_t thread_id, const char *name);
+#else
+#define EvrRtxThreadGetName(thread_id, name)
+#endif
+
+/**
+  \brief  Event on current running thread ID retrieve (API)
+  \param[in]  thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_GET_ID_DISABLE))
+extern void EvrRtxThreadGetId (osThreadId_t thread_id);
+#else
+#define EvrRtxThreadGetId(thread_id)
+#endif
+
+/**
+  \brief  Event on thread state retrieve (API)
+  \param[in]  thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
+  \param[in]  state         current thread state of the specified thread.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_GET_STATE_DISABLE))
+extern void EvrRtxThreadGetState (osThreadId_t thread_id, osThreadState_t state);
+#else
+#define EvrRtxThreadGetState(thread_id, state)
+#endif
+
+/**
+  \brief  Event on thread stack size retrieve (API)
+  \param[in]  thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
+  \param[in]  stack_size    stack size in bytes.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_GET_STACK_SIZE_DISABLE))
+extern void EvrRtxThreadGetStackSize (osThreadId_t thread_id, uint32_t stack_size);
+#else
+#define EvrRtxThreadGetStackSize(thread_id, stack_size)
+#endif
+
+/**
+  \brief  Event on available stack space retrieve (API)
+  \param[in]  thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
+  \param[in]  stack_space   remaining stack space in bytes.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_GET_STACK_SPACE_DISABLE))
+extern void EvrRtxThreadGetStackSpace (osThreadId_t thread_id, uint32_t stack_space);
+#else
+#define EvrRtxThreadGetStackSpace(thread_id, stack_space)
+#endif
+
+/**
+  \brief  Event on thread priority set (API)
+  \param[in]  thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
+  \param[in]  priority      new priority value for the thread function.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_SET_PRIORITY_DISABLE))
+extern void EvrRtxThreadSetPriority (osThreadId_t thread_id, osPriority_t priority);
+#else
+#define EvrRtxThreadSetPriority(thread_id, priority)
+#endif
+
+/**
+  \brief  Event on thread priority retrieve (API)
+  \param[in]  thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
+  \param[in]  priority      current priority value of the specified thread.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_GET_PRIORITY_DISABLE))
+extern void EvrRtxThreadGetPriority (osThreadId_t thread_id, osPriority_t priority);
+#else
+#define EvrRtxThreadGetPriority(thread_id, priority)
+#endif
+
+/**
+  \brief  Event on thread yield (API)
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_YIELD_DISABLE))
+extern void EvrRtxThreadYield (void);
+#else
+#define EvrRtxThreadYield()
+#endif
+
+/**
+  \brief  Event on thread suspend (API)
+  \param[in]  thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_SUSPEND_DISABLE))
+extern void EvrRtxThreadSuspend (osThreadId_t thread_id);
+#else
+#define EvrRtxThreadSuspend(thread_id)
+#endif
+
+/**
+  \brief  Event on successful thread suspend (Op)
+  \param[in]  thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_SUSPENDED_DISABLE))
+extern void EvrRtxThreadSuspended (osThreadId_t thread_id);
+#else
+#define EvrRtxThreadSuspended(thread_id)
+#endif
+
+/**
+  \brief  Event on thread resume (API)
+  \param[in]  thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_RESUME_DISABLE))
+extern void EvrRtxThreadResume (osThreadId_t thread_id);
+#else
+#define EvrRtxThreadResume(thread_id)
+#endif
+
+/**
+  \brief  Event on successful thread resume (Op)
+  \param[in]  thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_RESUMED_DISABLE))
+extern void EvrRtxThreadResumed (osThreadId_t thread_id);
+#else
+#define EvrRtxThreadResumed(thread_id)
+#endif
+
+/**
+  \brief  Event on thread detach (API)
+  \param[in]  thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_DETACH_DISABLE))
+extern void EvrRtxThreadDetach (osThreadId_t thread_id);
+#else
+#define EvrRtxThreadDetach(thread_id)
+#endif
+
+/**
+  \brief  Event on successful thread detach (Op)
+  \param[in]  thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_DETACHED_DISABLE))
+extern void EvrRtxThreadDetached (osThreadId_t thread_id);
+#else
+#define EvrRtxThreadDetached(thread_id)
+#endif
+
+/**
+  \brief  Event on thread join (API)
+  \param[in]  thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_JOIN_DISABLE))
+extern void EvrRtxThreadJoin (osThreadId_t thread_id);
+#else
+#define EvrRtxThreadJoin(thread_id)
+#endif
+
+/**
+  \brief  Event on pending thread join (Op)
+  \param[in]  thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_JOIN_PENDING_DISABLE))
+extern void EvrRtxThreadJoinPending (osThreadId_t thread_id);
+#else
+#define EvrRtxThreadJoinPending(thread_id)
+#endif
+
+/**
+  \brief  Event on successful thread join (Op)
+  \param[in]  thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_JOINED_DISABLE))
+extern void EvrRtxThreadJoined (osThreadId_t thread_id);
+#else
+#define EvrRtxThreadJoined(thread_id)
+#endif
+
+/**
+  \brief  Event on thread execution block (Op)
+  \param[in]  thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
+  \param[in]  timeout       \ref CMSIS_RTOS_TimeOutValue or 0 in case of no time-out.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_BLOCKED_DISABLE))
+extern void EvrRtxThreadBlocked (osThreadId_t thread_id, uint32_t timeout);
+#else
+#define EvrRtxThreadBlocked(thread, timeout)
+#endif
+
+/**
+  \brief  Event on blocked thread release (Op)
+  \param[in]  thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
+  \param[in]  ret_val       extended execution status of the thread.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_UNBLOCKED_DISABLE))
+extern void EvrRtxThreadUnblocked (osThreadId_t thread_id, uint32_t ret_val);
+#else
+#define EvrRtxThreadUnblocked(thread, ret_val)
+#endif
+
+/**
+  \brief  Event on current running thread switch (Op)
+  \param[in]  thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_SWITCH_DISABLE))
+extern void EvrRtxThreadSwitch (osThreadId_t thread_id);
+#else
+#define EvrRtxThreadSwitch(thread)
+#endif
+
+/**
+  \brief  Event on thread exit (API)
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_EXIT_DISABLE))
+extern void EvrRtxThreadExit (void);
+#else
+#define EvrRtxThreadExit()
+#endif
+
+/**
+  \brief  Event on thread terminate (API)
+  \param[in]  thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_TERMINATE_DISABLE))
+extern void EvrRtxThreadTerminate (osThreadId_t thread_id);
+#else
+#define EvrRtxThreadTerminate(thread_id)
+#endif
+
+/**
+  \brief  Event on successful thread terminate (Op)
+  \param[in]  thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_DESTROYED_DISABLE))
+extern void EvrRtxThreadDestroyed (osThreadId_t thread_id);
+#else
+#define EvrRtxThreadDestroyed(thread_id)
+#endif
+
+/**
+  \brief  Event on active thread count retrieve (API)
+  \param[in]  count         number of active threads.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_GET_COUNT_DISABLE))
+extern void EvrRtxThreadGetCount (uint32_t count);
+#else
+#define EvrRtxThreadGetCount(count)
+#endif
+
+/**
+  \brief  Event on active threads enumerate (API)
+  \param[in]  thread_array  pointer to array for retrieving thread IDs.
+  \param[in]  array_items   maximum number of items in array for retrieving thread IDs.
+  \count[in]  count         number of enumerated threads.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_ENUMERATE_DISABLE))
+extern void EvrRtxThreadEnumerate (osThreadId_t *thread_array, uint32_t array_items, uint32_t count);
+#else
+#define EvrRtxThreadEnumerate(thread_array, array_items, count)
+#endif
+
+/**
+  \brief  Event on thread flags set (API)
+  \param[in]   thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
+  \param[in]   flags         flags of the thread that shall be set.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_FLAGS_SET_DISABLE))
+extern void EvrRtxThreadFlagsSet (osThreadId_t thread_id, int32_t flags);
+#else
+#define EvrRtxThreadFlagsSet(thread_id, flags)
+#endif
+
+/**
+  \brief  Event on successful thread flags set (Op)
+  \param[in]  thread_id     thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
+  \param[in]  thread_flags  thread flags after setting or error code if negative.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_FLAGS_SET_DONE_DISABLE))
+extern void EvrRtxThreadFlagsSetDone (osThreadId_t thread_id, int32_t thread_flags);
+#else
+#define EvrRtxThreadFlagsSetDone(thread_id, thread_flags)
+#endif
+
+/**
+  \brief  Event on thread flags clear (API)
+  \param[in]  flags         flags of the thread that shall be cleared.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_FLAGS_CLEAR_DISABLE))
+extern void EvrRtxThreadFlagsClear (int32_t flags);
+#else
+#define EvrRtxThreadFlagsClear(flags)
+#endif
+
+/**
+  \brief  Event on successful thread flags clear (Op)
+  \param[in]  thread_flags  thread flags before clearing or error code if negative.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_FLAGS_CLEAR_DONE_DISABLE))
+extern void EvrRtxThreadFlagsClearDone (int32_t thread_flags);
+#else
+#define EvrRtxThreadFlagsClearDone(thread_flags)
+#endif
+
+/**
+  \brief  Event on thread flags retrieve (API)
+  \param[in]  thread_flags  current thread flags.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_FLAGS_GET_DISABLE))
+extern void EvrRtxThreadFlagsGet (int32_t thread_flags);
+#else
+#define EvrRtxThreadFlagsGet(thread_flags)
+#endif
+
+/**
+  \brief  Event on wait for thread flags (API)
+  \param[in]  flags         flags to wait for.
+  \param[in]  options       flags options (osFlagsXxxx).
+  \param[in]  timeout       \ref CMSIS_RTOS_TimeOutValue or 0 in case of no time-out.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_FLAGS_WAIT_DISABLE))
+extern void EvrRtxThreadFlagsWait (int32_t flags, uint32_t options, uint32_t timeout);
+#else
+#define EvrRtxThreadFlagsWait(flags, options, timeout)
+#endif
+
+/**
+  \brief  Event on pending wait for thread flags (Op)
+  \param[in]  flags         flags to wait for.
+  \param[in]  options       flags options (osFlagsXxxx).
+  \param[in]  timeout       \ref CMSIS_RTOS_TimeOutValue or 0 in case of no time-out.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_FLAGS_WAIT_PENDING_DISABLE))
+extern void EvrRtxThreadFlagsWaitPending (int32_t flags, uint32_t options, uint32_t timeout);
+#else
+#define EvrRtxThreadFlagsWaitPending(flags, options, timeout)
+#endif
+
+/**
+  \brief  Event on successful wait for thread flags (Op)
+  \param[in]  flags         flags to wait for.
+  \param[in]  options       flags options (osFlagsXxxx).
+  \param[in]  thread_flags  thread flags before clearing
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_FLAGS_WAIT_COMPLETED_DISABLE))
+extern void EvrRtxThreadFlagsWaitCompleted (int32_t flags, uint32_t options, int32_t thread_flags);
+#else
+#define EvrRtxThreadFlagsWaitCompleted(flags, options, thread_flags)
+#endif
+
+/**
+  \brief  Event on unsuccessful wait for thread flags (Op)
+  \param[in]  flags         flags to wait for.
+  \param[in]  options       flags options (osFlagsXxxx).
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_FLAGS_WAIT_NOT_COMPLETED_DISABLE))
+extern void EvrRtxThreadFlagsWaitNotCompleted (int32_t flags, uint32_t options);
+#else
+#define EvrRtxThreadFlagsWaitNotCompleted(flags, options)
+#endif
+
+/**
+  \brief  Event on wait for timeout (API)
+  \param[in]  ticks         \ref CMSIS_RTOS_TimeOutValue "time ticks" value
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_DELAY_DISABLE))
+extern void EvrRtxThreadDelay (uint32_t ticks);
+#else
+#define EvrRtxThreadDelay(ticks)
+#endif
+
+/**
+  \brief  Event on wait until specified time (API)
+  \param[in]  ticks         absolute time in ticks
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_DELAY_UNTIL_DISABLE))
+extern void EvrRtxThreadDelayUntil (uint64_t ticks);
+#else
+#define EvrRtxThreadDelayUntil(ticks)
+#endif
+
+
+//  ==== Timer Events ====
+
+/**
+  \brief  Event on timer error (Error)
+  \param[in]  timer_id      timer ID obtained by \ref osTimerNew or NULL when ID is unknown.
+  \param[in]  status        extended execution status.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_TIMER != 0) && !defined(EVR_RTX_TIMER_ERROR_DISABLE))
+extern void EvrRtxTimerError (osTimerId_t timer_id, int32_t status);
+#else
+#define EvrRtxTimerError(timer_id, status);
+#endif
+
+/**
+  \brief  Event on timer callback call (Op)
+  \param[in]  func          start address of a timer call back function.
+  \param[in]  argument      argument to the timer call back function.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_TIMER != 0) && !defined(EVR_RTX_TIMER_CALLBACK_DISABLE))
+extern void EvrRtxTimerCallback (osTimerFunc_t func, void *argument);
+#else
+#define EvrRtxTimerCallback(func, argument);
+#endif
+
+/**
+  \brief  Event on timer create and initialize (API)
+  \param[in]  func          start address of a timer call back function.
+  \param[in]  type          osTimerOnce for one-shot or osTimerPeriodic for periodic behavior.
+  \param[in]  argument      argument to the timer call back function.
+  \param[in]  attr          timer attributes.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_TIMER != 0) && !defined(EVR_RTX_TIMER_NEW_DISABLE))
+extern void EvrRtxTimerNew (osTimerFunc_t func, osTimerType_t type, void *argument, const osTimerAttr_t *attr);
+#else
+#define EvrRtxTimerNew(func, type, argument, attr);
+#endif
+
+/**
+  \brief  Event on successful timer create (Op)
+  \param[in]  timer_id      timer ID obtained by \ref osTimerNew
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_TIMER != 0) && !defined(EVR_RTX_TIMER_CREATED_DISABLE))
+extern void EvrRtxTimerCreated (osTimerId_t timer_id);
+#else
+#define EvrRtxTimerCreated(timer_id);
+#endif
+
+/**
+  \brief  Event on timer name retrieve (API)
+  \param[in]  timer_id      timer ID obtained by \ref osTimerNew
+  \param[in]  name          pointer to timer object name.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_TIMER != 0) && !defined(EVR_RTX_TIMER_GET_NAME_DISABLE))
+extern void EvrRtxTimerGetName (osTimerId_t timer_id, const char *name);
+#else
+#define EvrRtxTimerGetName(timer_id, name);
+#endif
+
+/**
+  \brief  Event on timer start (API)
+  \param[in]  timer_id      timer ID obtained by \ref osTimerNew
+  \param[in]  ticks         \ref CMSIS_RTOS_TimeOutValue "time ticks" value of the timer.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_TIMER != 0) && !defined(EVR_RTX_TIMER_START_DISABLE))
+extern void EvrRtxTimerStart (osTimerId_t timer_id, uint32_t ticks);
+#else
+#define EvrRtxTimerStart(timer_id, ticks);
+#endif
+
+/**
+  \brief  Event on successful timer start (Op)
+  \param[in]  timer_id      timer ID obtained by \ref osTimerNew
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_TIMER != 0) && !defined(EVR_RTX_TIMER_STARTED_DISABLE))
+extern void EvrRtxTimerStarted (osTimerId_t timer_id);
+#else
+#define EvrRtxTimerStarted(timer_id);
+#endif
+
+/**
+  \brief  Event on timer stop (API)
+  \param[in]  timer_id      timer ID obtained by \ref osTimerNew
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_TIMER != 0) && !defined(EVR_RTX_TIMER_STOP_DISABLE))
+extern void EvrRtxTimerStop (osTimerId_t timer_id);
+#else
+#define EvrRtxTimerStop(timer_id);
+#endif
+
+/**
+  \brief  Event on successful timer stop (Op)
+  \param[in]  timer_id      timer ID obtained by \ref osTimerNew
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_TIMER != 0) && !defined(EVR_RTX_TIMER_STOPPED_DISABLE))
+extern void EvrRtxTimerStopped (osTimerId_t timer_id);
+#else
+#define EvrRtxTimerStopped(timer_id);
+#endif
+
+/**
+  \brief  Event on timer running state check (API)
+  \param[in]  timer_id      timer ID obtained by \ref osTimerNew
+  \param[in]  running       running state: 0 not running, 1 running
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_TIMER != 0) && !defined(EVR_RTX_TIMER_IS_RUNNING_DISABLE))
+extern void EvrRtxTimerIsRunning (osTimerId_t timer_id, uint32_t running);
+#else
+#define EvrRtxTimerIsRunning(timer_id, running);
+#endif
+
+/**
+  \brief  Event on timer delete (API)
+  \param[in]  timer_id      timer ID obtained by \ref osTimerNew
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_TIMER != 0) && !defined(EVR_RTX_TIMER_DELETE_DISABLE))
+extern void EvrRtxTimerDelete (osTimerId_t timer_id);
+#else
+#define EvrRtxTimerDelete(timer_id);
+#endif
+
+/**
+  \brief  Event on successful timer delete (Op)
+  \param[in]  timer_id      timer ID obtained by \ref osTimerNew
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_TIMER != 0) && !defined(EVR_RTX_TIMER_DESTROYED_DISABLE))
+extern void EvrRtxTimerDestroyed (osTimerId_t timer_id);
+#else
+#define EvrRtxTimerDestroyed(timer_id);
+#endif
+
+
+//  ==== Event Flags Events ====
+
+/**
+  \brief  Event on event flags error (Error)
+  \param[in]  ef_id         event flags ID obtained by \ref osEventFlagsNew or NULL when ID is unknown.
+  \param[in]  status        extended execution status.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_EVFLAGS != 0) && !defined(EVR_RTX_EVENT_FLAGS_ERROR_DISABLE))
+extern void EvrRtxEventFlagsError (osEventFlagsId_t ef_id, int32_t status);
+#else
+#define EvrRtxEventFlagsError(ef_id, status)
+#endif
+
+/**
+  \brief  Event on event flags create and initialize (API)
+  \param[in]  attr          event flags attributes
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_EVFLAGS != 0) && !defined(EVR_RTX_EVENT_FLAGS_NEW_DISABLE))
+extern void EvrRtxEventFlagsNew (const osEventFlagsAttr_t *attr);
+#else
+#define EvrRtxEventFlagsNew(attr)
+#endif
+
+/**
+  \brief  Event on successful event flags create (Op)
+  \param[in]  ef_id         event flags ID obtained by \ref osEventFlagsNew.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_EVFLAGS != 0) && !defined(EVR_RTX_EVENT_FLAGS_CREATED_DISABLE))
+extern void EvrRtxEventFlagsCreated (osEventFlagsId_t ef_id);
+#else
+#define EvrRtxEventFlagsCreated(ef_id)
+#endif
+
+/**
+  \brief  Event on event flags name retrieve (API)
+  \param[in]  ef_id         event flags ID obtained by \ref osEventFlagsNew.
+  \param[in]  name          pointer to event flags object name.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_EVFLAGS != 0) && !defined(EVR_RTX_EVENT_FLAGS_GET_NAME_DISABLE))
+extern void EvrRtxEventFlagsGetName (osEventFlagsId_t ef_id, const char *name);
+#else
+#define EvrRtxEventFlagsGetName(ef_id, name)
+#endif
+
+/**
+  \brief  Event on event flags set (API)
+  \param[in]  ef_id         event flags ID obtained by \ref osEventFlagsNew.
+  \param[in]  flags         flags that shall be set.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_EVFLAGS != 0) && !defined(EVR_RTX_EVENT_FLAGS_SET_DISABLE))
+extern void EvrRtxEventFlagsSet (osEventFlagsId_t ef_id, int32_t flags);
+#else
+#define EvrRtxEventFlagsSet(ef_id, flags)
+#endif
+
+/**
+  \brief  Event on successful event flags set (Op)
+  \param[in]  ef_id         event flags ID obtained by \ref osEventFlagsNew.
+  \param[in]  event_flags   event flags after setting or error code if negative.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_EVFLAGS != 0) && !defined(EVR_RTX_EVENT_FLAGS_SET_DONE_DISABLE))
+extern void EvrRtxEventFlagsSetDone (osEventFlagsId_t ef_id, int32_t event_flags);
+#else
+#define EvrRtxEventFlagsSetDone(ef_id, event_flags)
+#endif
+
+/**
+  \brief  Event on event flags clear (API)
+  \param[in]  ef_id         event flags ID obtained by \ref osEventFlagsNew.
+  \param[in]  flags         flags that shall be cleared.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_EVFLAGS != 0) && !defined(EVR_RTX_EVENT_FLAGS_CLEAR_DISABLE))
+extern void EvrRtxEventFlagsClear (osEventFlagsId_t ef_id, int32_t flags);
+#else
+#define EvrRtxEventFlagsClear(ef_id, flags)
+#endif
+
+/**
+  \brief  Event on successful event flags clear (Op)
+  \param[in]  ef_id         event flags ID obtained by \ref osEventFlagsNew.
+  \param[in]  event_flags   event flags before clearing or error code if negative.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_EVFLAGS != 0) && !defined(EVR_RTX_EVENT_FLAGS_CLEAR_DONE_DISABLE))
+extern void EvrRtxEventFlagsClearDone (osEventFlagsId_t ef_id, int32_t event_flags);
+#else
+#define EvrRtxEventFlagsClearDone(ef_id, event_flags)
+#endif
+
+/**
+  \brief  Event on event flags retrieve (API)
+  \param[in]  ef_id         event flags ID obtained by \ref osEventFlagsNew.
+  \param[in]  event_flags   current event flags.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_EVFLAGS != 0) && !defined(EVR_RTX_EVENT_FLAGS_GET_DISABLE))
+extern void EvrRtxEventFlagsGet (osEventFlagsId_t ef_id, int32_t event_flags);
+#else
+#define EvrRtxEventFlagsGet(ef_id, event_flags)
+#endif
+
+/**
+  \brief  Event on wait for event flags (API)
+  \param[in]  ef_id         event flags ID obtained by \ref osEventFlagsNew.
+  \param[in]  flags         flags to wait for.
+  \param[in]  options       flags options (osFlagsXxxx).
+  \param[in]  timeout       \ref CMSIS_RTOS_TimeOutValue or 0 in case of no time-out.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_EVFLAGS != 0) && !defined(EVR_RTX_EVENT_FLAGS_WAIT_DISABLE))
+extern void EvrRtxEventFlagsWait (osEventFlagsId_t ef_id, int32_t flags, uint32_t options, uint32_t timeout);
+#else
+#define EvrRtxEventFlagsWait(ef_id, flags, options, timeout)
+#endif
+
+/**
+  \brief  Event on pending wait for event flags (Op)
+  \param[in]  ef_id         event flags ID obtained by \ref osEventFlagsNew.
+  \param[in]  flags         flags to wait for.
+  \param[in]  options       flags options (osFlagsXxxx).
+  \param[in]  timeout       \ref CMSIS_RTOS_TimeOutValue or 0 in case of no time-out.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_EVFLAGS != 0) && !defined(EVR_RTX_EVENT_FLAGS_WAIT_PENDING_DISABLE))
+extern void EvrRtxEventFlagsWaitPending (osEventFlagsId_t ef_id, int32_t flags, uint32_t options, uint32_t timeout);
+#else
+#define EvrRtxEventFlagsWaitPending(ef_id, flags, options, timeout)
+#endif
+
+/**
+  \brief  Event on successful wait for event flags (Op)
+  \param[in]  ef_id         event flags ID obtained by \ref osEventFlagsNew.
+  \param[in]  flags         flags to wait for.
+  \param[in]  options       flags options (osFlagsXxxx).
+  \param[in]  event_flags   event flags before clearing or 0 if specified flags have not been set.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_EVFLAGS != 0) && !defined(EVR_RTX_EVENT_FLAGS_WAIT_COMPLETED_DISABLE))
+extern void EvrRtxEventFlagsWaitCompleted (osEventFlagsId_t ef_id, int32_t flags, uint32_t options, int32_t event_flags);
+#else
+#define EvrRtxEventFlagsWaitCompleted(ef_id, flags, options, event_flags)
+#endif
+
+/**
+  \brief  Event on unsuccessful wait for event flags (Op)
+  \param[in]  ef_id         event flags ID obtained by \ref osEventFlagsNew.
+  \param[in]  flags         flags to wait for.
+  \param[in]  options       flags options (osFlagsXxxx).
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_EVFLAGS != 0) && !defined(EVR_RTX_EVENT_FLAGS_WAIT_NOT_COMPLETED_DISABLE))
+extern void EvrRtxEventFlagsWaitNotCompleted (osEventFlagsId_t ef_id, int32_t flags, uint32_t options);
+#else
+#define EvrRtxEventFlagsWaitNotCompleted(ef_id, flags, options)
+#endif
+
+/**
+  \brief  Event on event flags delete (API)
+  \param[in]  ef_id         event flags ID obtained by \ref osEventFlagsNew.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_EVFLAGS != 0) && !defined(EVR_RTX_EVENT_FLAGS_DELETE_DISABLE))
+extern void EvrRtxEventFlagsDelete (osEventFlagsId_t ef_id);
+#else
+#define EvrRtxEventFlagsDelete(ef_id)
+#endif
+
+/**
+  \brief  Event on successful event flags delete (Op)
+  \param[in]  ef_id         event flags ID obtained by \ref osEventFlagsNew.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_EVFLAGS != 0) && !defined(EVR_RTX_EVENT_FLAGS_DESTROYED_DISABLE))
+extern void EvrRtxEventFlagsDestroyed (osEventFlagsId_t ef_id);
+#else
+#define EvrRtxEventFlagsDestroyed(ef_id)
+#endif
+
+
+//  ==== Mutex Events ====
+
+/**
+  \brief  Event on mutex error (Error)
+  \param[in]  mutex_id  mutex ID obtained by \ref osMutexNew or NULL when ID is unknown.
+  \param[in]  status    extended execution status.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MUTEX != 0) && !defined(EVR_RTX_MUTEX_ERROR_DISABLE))
+extern void EvrRtxMutexError (osMutexId_t mutex_id, int32_t status);
+#else
+#define EvrRtxMutexError(mutex_id, status)
+#endif
+
+/**
+  \brief  Event on mutex create and initialize (API)
+  \param[in]  attr      mutex attributes
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MUTEX != 0) && !defined(EVR_RTX_MUTEX_NEW_DISABLE))
+extern void EvrRtxMutexNew (const osMutexAttr_t *attr);
+#else
+#define EvrRtxMutexNew(attr)
+#endif
+
+/**
+  \brief  Event on successful mutex create (Op)
+  \param[in]  mutex_id  mutex ID obtained by \ref osMutexNew.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MUTEX != 0) && !defined(EVR_RTX_MUTEX_CREATED_DISABLE))
+extern void EvrRtxMutexCreated (osMutexId_t mutex_id);
+#else
+#define EvrRtxMutexCreated(mutex_id)
+#endif
+
+/**
+  \brief  Event on mutex name retrieve (API)
+  \param[in]  mutex_id  mutex ID obtained by \ref osMutexNew.
+  \param[in]  name      pointer to mutex object name
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MUTEX != 0) && !defined(EVR_RTX_MUTEX_GET_NAME_DISABLE))
+extern void EvrRtxMutexGetName (osMutexId_t mutex_id, const char *name);
+#else
+#define EvrRtxMutexGetName(mutex_id, name)
+#endif
+
+/**
+  \brief  Event on mutex acquire (API)
+  \param[in]  mutex_id  mutex ID obtained by \ref osMutexNew.
+  \param[in]  timeout   \ref CMSIS_RTOS_TimeOutValue or 0 in case of no time-out.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MUTEX != 0) && !defined(EVR_RTX_MUTEX_ACQUIRE_DISABLE))
+extern void EvrRtxMutexAcquire (osMutexId_t mutex_id, uint32_t timeout);
+#else
+#define EvrRtxMutexAcquire(mutex_id, timeout)
+#endif
+
+/**
+  \brief  Event on pending mutex acquire (Op)
+  \param[in]  mutex_id  mutex ID obtained by \ref osMutexNew.
+  \param[in]  timeout   \ref CMSIS_RTOS_TimeOutValue or 0 in case of no time-out.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MUTEX != 0) && !defined(EVR_RTX_MUTEX_ACQUIRE_PENDING_DISABLE))
+extern void EvrRtxMutexAcquirePending (osMutexId_t mutex_id, uint32_t timeout);
+#else
+#define EvrRtxMutexAcquirePending(mutex_id, timeout);
+#endif
+
+/**
+  \brief  Event on successful mutex acquire (Op)
+  \param[in]  mutex_id  mutex ID obtained by \ref osMutexNew.
+  \param[in]  lock      current number of times mutex object is locked
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MUTEX != 0) && !defined(EVR_RTX_MUTEX_ACQUIRED_DISABLE))
+extern void EvrRtxMutexAcquired (osMutexId_t mutex_id, uint32_t lock);
+#else
+#define EvrRtxMutexAcquired(mutex_id, lock)
+#endif
+
+/**
+  \brief  Event on unsuccessful mutex acquire (Op)
+  \param[in]  mutex_id  mutex ID obtained by \ref osMutexNew.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MUTEX != 0) && !defined(EVR_RTX_MUTEX_NOT_ACQUIRED_DISABLE))
+extern void EvrRtxMutexNotAcquired (osMutexId_t mutex_id);
+#else
+#define EvrRtxMutexNotAcquired(mutex_id)
+#endif
+
+/**
+  \brief  Event on mutex release (API)
+  \param[in]  mutex_id  mutex ID obtained by \ref osMutexNew.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MUTEX != 0) && !defined(EVR_RTX_MUTEX_RELEASE_DISABLE))
+extern void EvrRtxMutexRelease (osMutexId_t mutex_id);
+#else
+#define EvrRtxMutexRelease(mutex_id)
+#endif
+
+/**
+  \brief  Event on successful mutex release (Op)
+  \param[in]  mutex_id  mutex ID obtained by \ref osMutexNew.
+  \param[in]  lock      current number of times mutex object is locked
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MUTEX != 0) && !defined(EVR_RTX_MUTEX_RELEASED_DISABLE))
+extern void EvrRtxMutexReleased (osMutexId_t mutex_id, uint32_t lock);
+#else
+#define EvrRtxMutexReleased(mutex_id, lock)
+#endif
+
+/**
+  \brief  Event on mutex owner retrieve (API)
+  \param[in]  mutex_id  mutex ID obtained by \ref osMutexNew.
+  \param[in]  thread_id thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MUTEX != 0) && !defined(EVR_RTX_MUTEX_GET_OWNER_DISABLE))
+extern void EvrRtxMutexGetOwner (osMutexId_t mutex_id, osThreadId_t thread_id);
+#else
+#define EvrRtxMutexGetOwner(mutex_id, thread_id)
+#endif
+
+/**
+  \brief  Event on mutex delete (API)
+  \param[in]  mutex_id  mutex ID obtained by \ref osMutexNew.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MUTEX != 0) && !defined(EVR_RTX_MUTEX_DELETE_DISABLE))
+extern void EvrRtxMutexDelete (osMutexId_t mutex_id);
+#else
+#define EvrRtxMutexDelete(mutex_id)
+#endif
+
+/**
+  \brief  Event on successful mutex delete (Op)
+  \param[in]  mutex_id  mutex ID obtained by \ref osMutexNew.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MUTEX != 0) && !defined(EVR_RTX_MUTEX_DESTROYED_DISABLE))
+extern void EvrRtxMutexDestroyed (osMutexId_t mutex_id);
+#else
+#define EvrRtxMutexDestroyed(mutex_id)
+#endif
+
+
+//  ==== Semaphore Events ====
+
+/**
+  \brief  Event on semaphore error (Error)
+  \param[in]  semaphore_id  semaphore ID obtained by \ref osSemaphoreNew or NULL when ID is unknown.
+  \param[in]  status        extended execution status.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_SEMAPHORE != 0) && !defined(EVR_RTX_SEMAPHORE_ERROR_DISABLE))
+extern void EvrRtxSemaphoreError (osSemaphoreId_t semaphore_id, int32_t status);
+#else
+#define EvrRtxSemaphoreError(semaphore_id, status)
+#endif
+
+/**
+  \brief  Event on semaphore create and initialize (API)
+  \param[in]  max_count     maximum number of available tokens.
+  \param[in]  initial_count initial number of available tokens.
+  \param[in]  attr          semaphore attributes.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_SEMAPHORE != 0) && !defined(EVR_RTX_SEMAPHORE_NEW_DISABLE))
+extern void EvrRtxSemaphoreNew (uint32_t max_count, uint32_t initial_count, const osSemaphoreAttr_t *attr);
+#else
+#define EvrRtxSemaphoreNew(max_count, initial_count, attr)
+#endif
+
+/**
+  \brief  Event on successful semaphore create (Op)
+  \param[in]  semaphore_id  semaphore ID obtained by \ref osSemaphoreNew.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_SEMAPHORE != 0) && !defined(EVR_RTX_SEMAPHORE_CREATED_DISABLE))
+extern void EvrRtxSemaphoreCreated (osSemaphoreId_t semaphore_id);
+#else
+#define EvrRtxSemaphoreCreated(semaphore_id)
+#endif
+
+/**
+  \brief  Event on semaphore name retrieve (API)
+  \param[in]  semaphore_id  semaphore ID obtained by \ref osSemaphoreNew.
+  \param[in]  name          pointer to semaphore object name.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_SEMAPHORE != 0) && !defined(EVR_RTX_SEMAPHORE_GET_NAME_DISABLE))
+extern void EvrRtxSemaphoreGetName (osSemaphoreId_t semaphore_id, const char *name);
+#else
+#define EvrRtxSemaphoreGetName(semaphore_id, name)
+#endif
+
+/**
+  \brief  Event on semaphore acquire (API)
+  \param[in]  semaphore_id  semaphore ID obtained by \ref osSemaphoreNew.
+  \param[in]  timeout       \ref CMSIS_RTOS_TimeOutValue or 0 in case of no time-out.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_SEMAPHORE != 0) && !defined(EVR_RTX_SEMAPHORE_ACQUIRE_DISABLE))
+extern void EvrRtxSemaphoreAcquire (osSemaphoreId_t semaphore_id, uint32_t timeout);
+#else
+#define EvrRtxSemaphoreAcquire(semaphore_id, timeout)
+#endif
+
+/**
+  \brief  Event on pending semaphore acquire (Op)
+  \param[in]  semaphore_id  semaphore ID obtained by \ref osSemaphoreNew.
+  \param[in]  timeout       \ref CMSIS_RTOS_TimeOutValue or 0 in case of no time-out.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_SEMAPHORE != 0) && !defined(EVR_RTX_SEMAPHORE_ACQUIRE_PENDING_DISABLE))
+extern void EvrRtxSemaphoreAcquirePending (osSemaphoreId_t semaphore_id, uint32_t timeout);
+#else
+#define EvrRtxSemaphoreAcquirePending(semaphore_id, timeout);
+#endif
+
+/**
+  \brief  Event on successful semaphore acquire (Op)
+  \param[in]  semaphore_id  semaphore ID obtained by \ref osSemaphoreNew.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_SEMAPHORE != 0) && !defined(EVR_RTX_SEMAPHORE_ACQUIRED_DISABLE))
+extern void EvrRtxSemaphoreAcquired (osSemaphoreId_t semaphore_id);
+#else
+#define EvrRtxSemaphoreAcquired(semaphore_id)
+#endif
+
+/**
+  \brief  Event on unsuccessful semaphore acquire (Op)
+  \param[in]  semaphore_id  semaphore ID obtained by \ref osSemaphoreNew.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_SEMAPHORE != 0) && !defined(EVR_RTX_SEMAPHORE_NOT_ACQUIRED_DISABLE))
+extern void EvrRtxSemaphoreNotAcquired (osSemaphoreId_t semaphore_id);
+#else
+#define EvrRtxSemaphoreNotAcquired(semaphore_id)
+#endif
+
+/**
+  \brief  Event on semaphore release (API)
+  \param[in]  semaphore_id  semaphore ID obtained by \ref osSemaphoreNew.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_SEMAPHORE != 0) && !defined(EVR_RTX_SEMAPHORE_RELEASE_DISABLE))
+extern void EvrRtxSemaphoreRelease (osSemaphoreId_t semaphore_id);
+#else
+#define EvrRtxSemaphoreRelease(semaphore_id)
+#endif
+
+/**
+  \brief  Event on successful semaphore release (Op)
+  \param[in]  semaphore_id  semaphore ID obtained by \ref osSemaphoreNew.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_SEMAPHORE != 0) && !defined(EVR_RTX_SEMAPHORE_RELEASED_DISABLE))
+extern void EvrRtxSemaphoreReleased (osSemaphoreId_t semaphore_id);
+#else
+#define EvrRtxSemaphoreReleased(semaphore_id)
+#endif
+
+/**
+  \brief  Event on semaphore token count retrieval (API)
+  \param[in]  semaphore_id  semaphore ID obtained by \ref osSemaphoreNew.
+  \param[in]  count         current number of available tokens.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_SEMAPHORE != 0) && !defined(EVR_RTX_SEMAPHORE_GET_COUNT_DISABLE))
+extern void EvrRtxSemaphoreGetCount (osSemaphoreId_t semaphore_id, uint32_t count);
+#else
+#define EvrRtxSemaphoreGetCount(semaphore_id, count)
+#endif
+
+/**
+  \brief  Event on semaphore delete (API)
+  \param[in]  semaphore_id  semaphore ID obtained by \ref osSemaphoreNew.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_SEMAPHORE != 0) && !defined(EVR_RTX_SEMAPHORE_DELETE_DISABLE))
+extern void EvrRtxSemaphoreDelete (osSemaphoreId_t semaphore_id);
+#else
+#define EvrRtxSemaphoreDelete(semaphore_id)
+#endif
+
+/**
+  \brief  Event on successful semaphore delete (Op)
+  \param[in]  semaphore_id  semaphore ID obtained by \ref osSemaphoreNew.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_SEMAPHORE != 0) && !defined(EVR_RTX_SEMAPHORE_DESTROYED_DISABLE))
+extern void EvrRtxSemaphoreDestroyed (osSemaphoreId_t semaphore_id);
+#else
+#define EvrRtxSemaphoreDestroyed(semaphore_id)
+#endif
+
+
+//  ==== Memory Pool Events ====
+
+/**
+  \brief  Event on memory pool error (Error)
+  \param[in]  mp_id         memory pool ID obtained by \ref osMemoryPoolNew or NULL when ID is unknown.
+  \param[in]  status        extended execution status.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMPOOL != 0) && !defined(EVR_RTX_MEMORY_POOL_ERROR_DISABLE))
+extern void EvrRtxMemoryPoolError (osMemoryPoolId_t mp_id, int32_t status);
+#else
+#define EvrRtxMemoryPoolError(mp_id, status)
+#endif
+
+/**
+  \brief  Event on memory pool create and initialize (API)
+  \param[in]  block_count   maximum number of memory blocks in memory pool.
+  \param[in]  block_size    memory block size in bytes.
+  \param[in]  attr          memory pool attributes; NULL: default values.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMPOOL != 0) && !defined(EVR_RTX_MEMORY_POOL_NEW_DISABLE))
+extern void EvrRtxMemoryPoolNew (uint32_t block_count, uint32_t block_size, const osMemoryPoolAttr_t *attr);
+#else
+#define EvrRtxMemoryPoolNew(block_count, block_size, attr)
+#endif
+
+/**
+  \brief  Event on successful memory pool create (Op)
+  \param[in]  mp_id         memory pool ID obtained by \ref osMemoryPoolNew.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMPOOL != 0) && !defined(EVR_RTX_MEMORY_POOL_CREATED_DISABLE))
+extern void EvrRtxMemoryPoolCreated (osMemoryPoolId_t mp_id);
+#else
+#define EvrRtxMemoryPoolCreated(mp_id)
+#endif
+
+/**
+  \brief  Event on memory pool name retrieve (API)
+  \param[in]  mp_id         memory pool ID obtained by \ref osMemoryPoolNew.
+  \param[in]  name          pointer to memory pool object name.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMPOOL != 0) && !defined(EVR_RTX_MEMORY_POOL_GET_NAME_DISABLE))
+extern void EvrRtxMemoryPoolGetName (osMemoryPoolId_t mp_id, const char *name);
+#else
+#define EvrRtxMemoryPoolGetName(mp_id, name)
+#endif
+
+/**
+  \brief  Event on memory pool allocation (API)
+  \param[in]  mp_id         memory pool ID obtained by \ref osMemoryPoolNew.
+  \param[in]  timeout       \ref CMSIS_RTOS_TimeOutValue or 0 in case of no time-out.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMPOOL != 0) && !defined(EVR_RTX_MEMORY_POOL_ALLOC_DISABLE))
+extern void EvrRtxMemoryPoolAlloc (osMemoryPoolId_t mp_id, uint32_t timeout);
+#else
+#define EvrRtxMemoryPoolAlloc(mp_id, timeout)
+#endif
+
+/**
+  \brief  Event on pending memory pool allocation (Op)
+  \param[in]  mp_id         memory pool ID obtained by \ref osMemoryPoolNew.
+  \param[in]  timeout       \ref CMSIS_RTOS_TimeOutValue or 0 in case of no time-out.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMPOOL != 0) && !defined(EVR_RTX_MEMORY_POOL_ALLOC_PENDING_DISABLE))
+extern void EvrRtxMemoryPoolAllocPending (osMemoryPoolId_t mp_id, uint32_t timeout);
+#else
+#define EvrRtxMemoryPoolAllocPending(mp_id, timeout)
+#endif
+
+/**
+  \brief  Event on successful memory pool allocation (Op)
+  \param[in]  mp_id         memory pool ID obtained by \ref osMemoryPoolNew.
+  \param[in]  block         address of the allocated memory block.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMPOOL != 0) && !defined(EVR_RTX_MEMORY_POOL_ALLOCATED_DISABLE))
+extern void EvrRtxMemoryPoolAllocated (osMemoryPoolId_t mp_id, void *block);
+#else
+#define EvrRtxMemoryPoolAllocated(mp_id, block)
+#endif
+
+/**
+  \brief  Event on unsuccessful memory pool allocation (Op)
+  \param[in]  mp_id         memory pool ID obtained by \ref osMemoryPoolNew.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMPOOL != 0) && !defined(EVR_RTX_MEMORY_POOL_ALLOC_FAILED_DISABLE))
+extern void EvrRtxMemoryPoolAllocFailed (osMemoryPoolId_t mp_id);
+#else
+#define EvrRtxMemoryPoolAllocFailed(mp_id)
+#endif
+
+/**
+  \brief  Event on memory pool free (API)
+  \param[in]  mp_id         memory pool ID obtained by \ref osMemoryPoolNew.
+  \param[in]  block         address of the allocated memory block to be returned to the memory pool.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMPOOL != 0) && !defined(EVR_RTX_MEMORY_POOL_FREE_DISABLE))
+extern void EvrRtxMemoryPoolFree (osMemoryPoolId_t mp_id, void *block);
+#else
+#define EvrRtxMemoryPoolFree(mp_id, block)
+#endif
+
+/**
+  \brief  Event on successful memory pool free (Op)
+  \param[in]  mp_id         memory pool ID obtained by \ref osMemoryPoolNew.
+  \param[in]  block         address of the allocated memory block to be returned to the memory pool.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMPOOL != 0) && !defined(EVR_RTX_MEMORY_POOL_DEALLOCATED_DISABLE))
+extern void EvrRtxMemoryPoolDeallocated (osMemoryPoolId_t mp_id, void *block);
+#else
+#define EvrRtxMemoryPoolDeallocated(mp_id, block)
+#endif
+
+/**
+  \brief  Event on unsuccessful memory pool free (Op)
+  \param[in]  mp_id         memory pool ID obtained by \ref osMemoryPoolNew.
+  \param[in]  block         address of the allocated memory block to be returned to the memory pool.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMPOOL != 0) && !defined(EVR_RTX_MEMORY_POOL_FREE_FAILED_DISABLE))
+extern void EvrRtxMemoryPoolFreeFailed (osMemoryPoolId_t mp_id, void *block);
+#else
+#define EvrRtxMemoryPoolFreeFailed(mp_id, block)
+#endif
+
+/**
+  \brief  Event on memory pool capacity retrieve (API)
+  \param[in]  mp_id         memory pool ID obtained by \ref osMemoryPoolNew.
+  \param[in]  capacity      maximum number of memory blocks.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMPOOL != 0) && !defined(EVR_RTX_MEMORY_POOL_GET_CAPACITY_DISABLE))
+extern void EvrRtxMemoryPoolGetCapacity (osMemoryPoolId_t mp_id, uint32_t capacity);
+#else
+#define EvrRtxMemoryPoolGetCapacity(mp_id, capacity)
+#endif
+
+/**
+  \brief  Event on memory pool block size retrieve (API)
+  \param[in]  mp_id         memory pool ID obtained by \ref osMemoryPoolNew.
+  \param[in]  block_size    memory block size in bytes.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMPOOL != 0) && !defined(EVR_RTX_MEMORY_POOL_GET_BLOCK_SZIE_DISABLE))
+extern void EvrRtxMemoryPoolGetBlockSize (osMemoryPoolId_t mp_id, uint32_t block_size);
+#else
+#define EvrRtxMemoryPoolGetBlockSize(mp_id, block_size)
+#endif
+
+/**
+  \brief  Event on used memory pool blocks retrieve (API)
+  \param[in]  mp_id         memory pool ID obtained by \ref osMemoryPoolNew.
+  \param[in]  count         number of memory blocks used.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMPOOL != 0) && !defined(EVR_RTX_MEMORY_POOL_GET_COUNT_DISABLE))
+extern void EvrRtxMemoryPoolGetCount (osMemoryPoolId_t mp_id, uint32_t count);
+#else
+#define EvrRtxMemoryPoolGetCount(mp_id, count)
+#endif
+
+/**
+  \brief  Event on available memory pool blocks retrieve (API)
+  \param[in]  mp_id         memory pool ID obtained by \ref osMemoryPoolNew.
+  \param[in]  space         number of memory blocks available.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMPOOL != 0) && !defined(EVR_RTX_MEMORY_POOL_GET_SPACE_DISABLE))
+extern void EvrRtxMemoryPoolGetSpace (osMemoryPoolId_t mp_id, uint32_t space);
+#else
+#define EvrRtxMemoryPoolGetSpace(mp_id, space)
+#endif
+
+/**
+  \brief  Event on memory pool delete (API)
+  \param[in]  mp_id         memory pool ID obtained by \ref osMemoryPoolNew.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMPOOL != 0) && !defined(EVR_RTX_MEMORY_POOL_DELETE_DISABLE))
+extern void EvrRtxMemoryPoolDelete (osMemoryPoolId_t mp_id);
+#else
+#define EvrRtxMemoryPoolDelete(mp_id)
+#endif
+
+/**
+  \brief  Event on successful memory pool delete (Op)
+  \param[in]  mp_id         memory pool ID obtained by \ref osMemoryPoolNew.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMPOOL != 0) && !defined(EVR_RTX_MEMORY_POOL_DESTROYED_DISABLE))
+extern void EvrRtxMemoryPoolDestroyed (osMemoryPoolId_t mp_id);
+#else
+#define EvrRtxMemoryPoolDestroyed(mp_id)
+#endif
+
+
+//  ==== Message Queue Events ====
+
+/**
+  \brief  Event on message queue error (Error)
+  \param[in]  mq_id         message queue ID obtained by \ref osMessageQueueNew or NULL when ID is unknown.
+  \param[in]  status        extended execution status.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_ERROR_DISABLE))
+extern void EvrRtxMessageQueueError (osMessageQueueId_t mq_id, int32_t status);
+#else
+#define EvrRtxMessageQueueError(mq_id, status)
+#endif
+
+/**
+  \brief  Event on message queue create and initialization (API)
+  \param[in]  msg_count     maximum number of messages in queue.
+  \param[in]  msg_size      maximum message size in bytes.
+  \param[in]  attr          message queue attributes; NULL: default values.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_NEW_DISABLE))
+extern void EvrRtxMessageQueueNew (uint32_t msg_count, uint32_t msg_size, const osMessageQueueAttr_t *attr);
+#else
+#define EvrRtxMessageQueueNew(msg_count, msg_size, attr)
+#endif
+
+/**
+  \brief  Event on successful message queue create (Op)
+  \param[in]  mq_id         message queue ID obtained by \ref osMessageQueueNew.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_CREATED_DISABLE))
+extern void EvrRtxMessageQueueCreated (osMessageQueueId_t mq_id);
+#else
+#define EvrRtxMessageQueueCreated(mq_id)
+#endif
+
+/**
+  \brief  Event on message queue name retrieve(API)
+  \param[in]  mq_id         message queue ID obtained by \ref osMessageQueueNew.
+  \param[in]  name          pointer to message queue object name.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_GET_NAME_DISABLE))
+extern void EvrRtxMessageQueueGetName (osMessageQueueId_t mq_id, const char *name);
+#else
+#define EvrRtxMessageQueueGetName(mq_id, name)
+#endif
+
+/**
+  \brief  Event on message put (API)
+  \param[in]  mq_id         message queue ID obtained by \ref osMessageQueueNew.
+  \param[in]  msg_ptr       pointer to buffer with message to put into a queue.
+  \param[in]  msg_prio      message priority.
+  \param[in]  timeout       \ref CMSIS_RTOS_TimeOutValue or 0 in case of no time-out.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_PUT_DISABLE))
+extern void EvrRtxMessageQueuePut (osMessageQueueId_t mq_id, const void *msg_ptr, uint8_t msg_prio, uint32_t timeout);
+#else
+#define EvrRtxMessageQueuePut(mq_id, msg_ptr, msg_prio, timeout)
+#endif
+
+/**
+  \brief  Event on pending message put (Op)
+  \param[in]  mq_id         message queue ID obtained by \ref osMessageQueueNew.
+  \param[in]  msg_ptr       pointer to buffer with message to put into a queue.
+  \param[in]  timeout       \ref CMSIS_RTOS_TimeOutValue or 0 in case of no time-out.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_PUT_PENDING_DISABLE))
+extern void EvrRtxMessageQueuePutPending (osMessageQueueId_t mq_id, const void *msg_ptr, uint32_t timeout);
+#else
+#define EvrRtxMessageQueuePutPending(mq_id, msg_ptr, timeout)
+#endif
+
+/**
+  \brief  Event on pending message insert (Op)
+  \param[in]  mq_id         message queue ID obtained by \ref osMessageQueueNew.
+  \param[in]  msg_ptr       pointer to buffer with message to put into a queue.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_INSERT_PENDING_DISABLE))
+extern void EvrRtxMessageQueueInsertPending (osMessageQueueId_t mq_id, const void *msg_ptr);
+#else
+#define EvrRtxMessageQueueInsertPending(mq_id, msg_ptr)
+#endif
+
+/**
+  \brief  Event on successful message insert (Op)
+  \param[in]  mq_id         message queue ID obtained by \ref osMessageQueueNew.
+  \param[in]  msg_ptr       pointer to buffer with message to put into a queue.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_INSERTED_DISABLE))
+extern void EvrRtxMessageQueueInserted (osMessageQueueId_t mq_id, const void *msg_ptr);
+#else
+#define EvrRtxMessageQueueInserted(mq_id, msg_ptr)
+#endif
+
+/**
+  \brief  Event on unsuccessful message insert (Op)
+  \param[in]  mq_id         message queue ID obtained by \ref osMessageQueueNew.
+  \param[in]  msg_ptr       pointer to buffer with message to put into a queue.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_NOT_INSERTED_DISABLE))
+extern void EvrRtxMessageQueueNotInserted (osMessageQueueId_t mq_id, const void *msg_ptr);
+#else
+#define EvrRtxMessageQueueNotInserted(mq_id, msg_ptr)
+#endif
+
+/**
+  \brief  Event on message get (API)
+  \param[in]  mq_id         message queue ID obtained by \ref osMessageQueueNew.
+  \param[in]  msg_ptr       pointer to buffer for message to get from a queue.
+  \param[in]  msg_prio      message priority.
+  \param[in]  timeout       \ref CMSIS_RTOS_TimeOutValue or 0 in case of no time-out.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_GET_DISABLE))
+extern void EvrRtxMessageQueueGet (osMessageQueueId_t mq_id, void *msg_ptr, uint8_t *msg_prio, uint32_t timeout);
+#else
+#define EvrRtxMessageQueueGet(mq_id, msg_ptr, msg_prio, timeout)
+#endif
+
+/**
+  \brief  Event on pending message get (Op)
+  \param[in]  mq_id         message queue ID obtained by \ref osMessageQueueNew.
+  \param[in]  msg_ptr       pointer to buffer for message to get from a queue.
+  \param[in]  timeout       \ref CMSIS_RTOS_TimeOutValue or 0 in case of no time-out.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_GET_PENDING_DISABLE))
+extern void EvrRtxMessageQueueGetPending (osMessageQueueId_t mq_id, void *msg_ptr, uint32_t timeout);
+#else
+#define EvrRtxMessageQueueGetPending(mq_id, msg_ptr, timeout)
+#endif
+
+/**
+  \brief  Event on successful message get (Op)
+  \param[in]  mq_id         message queue ID obtained by \ref osMessageQueueNew.
+  \param[in]  msg_ptr       pointer to buffer for message to get from a queue.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_RETRIEVED_DISABLE))
+extern void EvrRtxMessageQueueRetrieved (osMessageQueueId_t mq_id, void *msg_ptr);
+#else
+#define EvrRtxMessageQueueRetrieved(mq_id, msg_ptr)
+#endif
+
+/**
+  \brief  Event on unsuccessful message get (Op)
+  \param[in]  mq_id         message queue ID obtained by \ref osMessageQueueNew.
+  \param[in]  msg_ptr       pointer to buffer for message to get from a queue.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_NOT_RETRIEVED_DISABLE))
+extern void EvrRtxMessageQueueNotRetrieved (osMessageQueueId_t mq_id, void *msg_ptr);
+#else
+#define EvrRtxMessageQueueNotRetrieved(mq_id, msg_ptr)
+#endif
+
+/**
+  \brief  Event on message queue capacity retrieve (API)
+  \param[in]  mq_id         message queue ID obtained by \ref osMessageQueueNew.
+  \param[in]  capacity      maximum number of messages.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_GET_CAPACITY_DISABLE))
+extern void EvrRtxMessageQueueGetCapacity (osMessageQueueId_t mq_id, uint32_t capacity);
+#else
+#define EvrRtxMessageQueueGetCapacity(mq_id, capacity)
+#endif
+
+/**
+  \brief  Event on message queue message size retrieve (API)
+  \param[in]  mq_id         message queue ID obtained by \ref osMessageQueueNew.
+  \param[in]  msg_size      maximum message size in bytes.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_GET_MSG_SIZE_DISABLE))
+extern void EvrRtxMessageQueueGetMsgSize (osMessageQueueId_t mq_id, uint32_t msg_size);
+#else
+#define EvrRtxMessageQueueGetMsgSize(mq_id, msg_size)
+#endif
+
+/**
+  \brief  Event on message queue message count retrieve (API)
+  \param[in]  mq_id         message queue ID obtained by \ref osMessageQueueNew.
+  \param[in]  count         number of queued messages.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_GET_COUNT_DISABLE))
+extern void EvrRtxMessageQueueGetCount (osMessageQueueId_t mq_id, uint32_t count);
+#else
+#define EvrRtxMessageQueueGetCount(mq_id, count)
+#endif
+
+/**
+  \brief  Event on message queue message slots retrieve (API)
+  \param[in]  mq_id         message queue ID obtained by \ref osMessageQueueNew.
+  \param[in]  space         number of available slots for messages.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_GET_SPACE_DISABLE))
+extern void EvrRtxMessageQueueGetSpace (osMessageQueueId_t mq_id, uint32_t space);
+#else
+#define EvrRtxMessageQueueGetSpace(mq_id, space)
+#endif
+
+/**
+  \brief  Event on message queue reset (API)
+  \param[in]  mq_id         message queue ID obtained by \ref osMessageQueueNew.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_RESET_DISABLE))
+extern void EvrRtxMessageQueueReset (osMessageQueueId_t mq_id);
+#else
+#define EvrRtxMessageQueueReset(mq_id)
+#endif
+
+/**
+  \brief  Event on successful message queue reset (Op)
+  \param[in]  mq_id         message queue ID obtained by \ref osMessageQueueNew.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_RESET_DONE_DISABLE))
+extern void EvrRtxMessageQueueResetDone (osMessageQueueId_t mq_id);
+#else
+#define EvrRtxMessageQueueResetDone(mq_id)
+#endif
+
+/**
+  \brief  Event on message queue delete (API)
+  \param[in]  mq_id         message queue ID obtained by \ref osMessageQueueNew.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_DELETE_DISABLE))
+extern void EvrRtxMessageQueueDelete (osMessageQueueId_t mq_id);
+#else
+#define EvrRtxMessageQueueDelete(mq_id)
+#endif
+
+/**
+  \brief  Event on successful message queue delete (Op)
+  \param[in]  mq_id         message queue ID obtained by \ref osMessageQueueNew.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_DESTROYED_DISABLE))
+extern void EvrRtxMessageQueueDestroyed (osMessageQueueId_t mq_id);
+#else
+#define EvrRtxMessageQueueDestroyed(mq_id)
+#endif
+
+
+#endif  // RTX_EVR_H_
diff --git a/CMSIS/RTOS2/RTX/RTX5.scvd b/CMSIS/RTOS2/RTX/RTX5.scvd
index 449bc6c..92455b0 100644
--- a/CMSIS/RTOS2/RTX/RTX5.scvd
+++ b/CMSIS/RTOS2/RTX/RTX5.scvd
@@ -3,10 +3,75 @@
   <component name="RTOS" version="5.0.0"/>    <!-- name and version of the component  -->
 
   <typedefs>
+    <!-- Attributes structure for thread -->
+    <typedef name="osThreadAttr_t" info="" size="36">
+      <member name="name"       type="uint32_t" offset="0"  info="name of the thread (type is const char *)"/>
+      <member name="attr_bits"  type="uint32_t" offset="4"  info="attribute bits"/>
+      <member name="cb_mem"     type="uint32_t" offset="8"  info="memory for control block (type is void *)"/>
+      <member name="cb_size"    type="uint32_t" offset="12" info="size of provided memory for control block"/>
+      <member name="stack_mem"  type="uint32_t" offset="16" info="memory for stack (type is void *)"/>
+      <member name="stack_size" type="uint32_t" offset="20" info="size of stack"/>
+      <member name="priority"   type="uint32_t" offset="24" info="initial thread priority (type is osPriority_t)"/>
+      <member name="tz_module"  type="uint32_t" offset="28" info="TrustZone module identifier (type is TZ_ModuleId_t)"/>
+      <member name="reserved"   type="uint32_t" offset="32" info="reserved (must be 0)"/>
+    </typedef>
+
+    <!-- Attributes structure for timer -->
+    <typedef name="osTimerAttr_t" info="" size="16">
+      <member name="name"      type="uint32_t" offset="0"  info="name of the timer (type is const char *)"/>
+      <member name="attr_bits" type="uint32_t" offset="4"  info="attribute bits"/>
+      <member name="cb_mem"    type="uint32_t" offset="8"  info="memory for control block (type is void *)"/>
+      <member name="cb_size"   type="uint32_t" offset="12" info="size of provided memory for control block"/>
+    </typedef>
+
+    <!-- Attributes structure for event flags -->
+    <typedef name="osEventFlagsAttr_t" info="" size="16">
+      <member name="name"      type="uint32_t" offset="0"  info="name of the event flags (type is const char *)"/>
+      <member name="attr_bits" type="uint32_t" offset="4"  info="attribute bits"/>
+      <member name="cb_mem"    type="uint32_t" offset="8"  info="memory for control block (type is void *)"/>
+      <member name="cb_size"   type="uint32_t" offset="12" info="size of provided memory for control block"/>
+    </typedef>
+
+    <!-- Attributes structure for mutex -->
+    <typedef name="osMutexAttr_t" info="" size="16">
+      <member name="name"      type="uint32_t" offset="0"  info="name of the mutex (type is const char *)"/>
+      <member name="attr_bits" type="uint32_t" offset="4"  info="attribute bits"/>
+      <member name="cb_mem"    type="uint32_t" offset="8"  info="memory for control block (type is void *)"/>
+      <member name="cb_size"   type="uint32_t" offset="12" info="size of provided memory for control block"/>
+    </typedef>
+
+    <!-- Attributes structure for semaphore -->
+    <typedef name="osSemaphoreAttr_t" info="" size="16">
+      <member name="name"      type="uint32_t" offset="0"  info="name of the semaphore (type is const char *)"/>
+      <member name="attr_bits" type="uint32_t" offset="4"  info="attribute bits"/>
+      <member name="cb_mem"    type="uint32_t" offset="8"  info="memory for control block (type is void *)"/>
+      <member name="cb_size"   type="uint32_t" offset="12" info="size of provided memory for control block"/>
+    </typedef>
+
+    <!-- Attributes structure for memory pool -->
+    <typedef name="osMemoryPoolAttr_t" info="" size="24">
+      <member name="name"      type="uint32_t" offset="0"  info="name of the semaphore (type is const char *)"/>
+      <member name="attr_bits" type="uint32_t" offset="4"  info="attribute bits"/>
+      <member name="cb_mem"    type="uint32_t" offset="8"  info="memory for control block (type is void *)"/>
+      <member name="cb_size"   type="uint32_t" offset="12" info="size of provided memory for control block"/>
+      <member name="mp_mem"    type="uint32_t" offset="16" info="memory for data storage (type is void *)"/>
+      <member name="mp_size"   type="uint32_t" offset="20" info="size of provided memory for data storage"/>
+    </typedef>
+
+    <!-- Attributes structure for message queue -->
+    <typedef name="osMessageQueueAttr_t" info="" size="24">
+      <member name="name"      type="uint32_t" offset="0"  info="name of the semaphore (type is const char *)"/>
+      <member name="attr_bits" type="uint32_t" offset="4"  info="attribute bits"/>
+      <member name="cb_mem"    type="uint32_t" offset="8"  info="memory for control block (type is void *)"/>
+      <member name="cb_size"   type="uint32_t" offset="12" info="size of provided memory for control block"/>
+      <member name="mq_mem"    type="uint32_t" offset="16" info="memory for data storage (type is void *)"/>
+      <member name="mq_size"   type="uint32_t" offset="20" info="size of provided memory for data storage"/>
+    </typedef>
+
     <!-- Thread Control Block -->
-    <typedef name="os_thread_t" info="" size="64">
-      <member name="id"            type="uint8_t"      offset="0" info="Object Identifier"/>
-      <member name="state"         type="uint8_t"      offset="1" info="Object State">
+    <typedef name="osRtxThread_t" info="" size="68">
+      <member name="id"            type="uint8_t"        offset="0" info="Object Identifier"/>
+      <member name="state"         type="uint8_t"        offset="1" info="Object State">
         <enum name="osThreadInactive"    value="0"  info=""/>
         <enum name="osThreadReady"       value="1"  info=""/>
         <enum name="osThreadRunning"     value="2"  info=""/>
@@ -24,21 +89,19 @@
         <enum name="Message Get"  value="0x83"  info=""/>
         <enum name="Message Put"  value="0x93"  info=""/>
       </member>
-      <member name="flags"         type="uint8_t"      offset="2" info="Object Flags"/>
-      <member name="attr"          type="uint8_t"      offset="3" info="Object Attributes">
+      <member name="flags"         type="uint8_t"        offset="2" info="Object Flags"/>
+      <member name="attr"          type="uint8_t"        offset="3" info="Object Attributes">
         <enum name="osThreadDetached" value="0x00" info="Thread created in detached state"/>
         <enum name="osThreadJoinable" value="0x01" info="Thread created in joinable state"/>
       </member>
-      <member name="name"          type="uint32_t"     offset="4" info="Object name (type is *uint8_t)"/>
-
-      <member name="thread_next"   type="*os_thread_t" offset="8" info="Link pointer to next Thread in Object list"/>
-      <member name="thread_prev"   type="*os_thread_t" offset="12" info="Link pointer to previous Thread in Object list"/>
-      <member name="delay_next"    type="*os_thread_t" offset="16" info="Link pointer to next Thread in Delay list"/>
-      <member name="delay_prev"    type="*os_thread_t" offset="20" info="Link pointer to previous Thread in Delay list"/>
-      <member name="thread_join"   type="*os_thread_t" offset="24" info="Thread waiting to Join"/>
-
-      <member name="delay"         type="uint32_t"     offset="28" info="Delay time"/>
-      <member name="priority"      type="int8_t"       offset="32" info="Thread priority">
+      <member name="name"          type="uint32_t"       offset="4"  info="Object name (type is *uint8_t)"/>
+      <member name="thread_next"   type="*osRtxThread_t" offset="8"  info="Link pointer to next Thread in Object list"/>
+      <member name="thread_prev"   type="*osRtxThread_t" offset="12" info="Link pointer to previous Thread in Object list"/>
+      <member name="delay_next"    type="*osRtxThread_t" offset="16" info="Link pointer to next Thread in Delay list"/>
+      <member name="delay_prev"    type="*osRtxThread_t" offset="20" info="Link pointer to previous Thread in Delay list"/>
+      <member name="thread_join"   type="*osRtxThread_t" offset="24" info="Thread waiting to Join"/>
+      <member name="delay"         type="uint32_t"       offset="28" info="Delay time"/>
+      <member name="priority"      type="int8_t"         offset="32" info="Thread priority">
         <enum name="osPriorityNone"         value="0"    info=""/>
         <enum name="osPriorityIdle"         value="1"    info=""/>
         <enum name="osPriorityLow"          value="8"    info=""/>
@@ -92,20 +155,21 @@
         <enum name="osPriorityISR"          value="56"   info=""/>
         <enum name="osPriorityError"        value="-1"   info=""/>
       </member>
-      <member name="priority_base" type="int8_t"       offset="33" info="Base priority"/>
-      <member name="stack_frame"   type="uint8_t"      offset="34" info="Stack frame"/>
-      <member name="flags_options" type="uint8_t"      offset="35" info="Thread/Event flags options">
+      <member name="priority_base" type="int8_t"         offset="33" info="Base priority"/>
+      <member name="stack_frame"   type="uint8_t"        offset="34" info="Stack frame"/>
+      <member name="flags_options" type="uint8_t"        offset="35" info="Thread/Event flags options">
         <enum name="osFlagsWaitAny"   value="0x00" info="Wait for any flag."/>
         <enum name="osFlagsWaitAll"   value="0x01" info="Wait for all flags."/>
         <enum name="osFlagsAutoClear" value="0x02" info="Clear flags which have been specified to wait for."/>
       </member>
-      <member name="wait_flags"    type="int32_t"      offset="36" info="Waiting Thread/Event flags"/>
-      <member name="thread_flags"  type="int32_t"      offset="40" info="Thread flags"/>
-      <member name="mutex_list"    type="*os_mutex_t"  offset="44" info="Link pointer to list of owned mutexes"/>
-      <member name="stack_mem"     type="uint32_t"     offset="48" info="Stack memory (type is void *)"/>
-      <member name="stack_size"    type="uint32_t"     offset="52" info="Stack size"/>
-      <member name="sp"            type="uint32_t"     offset="56" info="Current stack pointer"/>
-      <member name="tz_memory"     type="uint32_t"     offset="60" info="TrustZone Memory Identifier"/>
+      <member name="wait_flags"    type="int32_t"        offset="36" info="Waiting Thread/Event flags"/>
+      <member name="thread_flags"  type="int32_t"        offset="40" info="Thread flags"/>
+      <member name="mutex_list"    type="*osRtxMutex_t"  offset="44" info="Link pointer to list of owned mutexes"/>
+      <member name="stack_mem"     type="uint32_t"       offset="48" info="Stack memory (type is void *)"/>
+      <member name="stack_size"    type="uint32_t"       offset="52" info="Stack size"/>
+      <member name="sp"            type="uint32_t"       offset="56" info="Current stack pointer"/>
+      <member name="thread_addr"   type="uint32_t"       offset="60" info="Thread entry address"/>
+      <member name="tz_memory"     type="uint32_t"       offset="64" info="TrustZone Memory Identifier"/>
 
       <var name="obj_name"   type="uint8_t"  info="Object name string" size="66" />
       <var name="cb_valid"   type="uint32_t" info="Control Block validation status (valid=1, invalid=0)"/>
@@ -122,26 +186,26 @@
     </typedef>
 
     <!-- Timer Control Block -->
-    <typedef name="os_timer_t" info="" size="32">
-      <member name="id"          type="uint8_t"     offset="0" info="Object Identifier"/>
-      <member name="state"       type="uint8_t"     offset="1" info="Object State">
+    <typedef name="osRtxTimer_t" info="" size="32">
+      <member name="id"          type="uint8_t"       offset="0" info="Object Identifier"/>
+      <member name="state"       type="uint8_t"       offset="1" info="Object State">
         <enum name="Inactive" value="0" info="Timer is not active"/>
         <enum name="Stopped"  value="1" info="Timer is stopped"/>
         <enum name="Running"  value="2" info="Timer is running"/>
       </member>
-      <member name="flags"       type="uint8_t"     offset="2" info="Object Flags"/>
-      <member name="type"        type="uint8_t"     offset="3" info="Timer Type">
+      <member name="flags"       type="uint8_t"       offset="2" info="Object Flags"/>
+      <member name="type"        type="uint8_t"       offset="3" info="Timer Type">
         <enum name="osTimerOnce"     value="0" info="One-shot timer"/>
         <enum name="osTimerPeriodic" value="1" info="Periodic timer"/>
       </member>
-      <member name="name"        type="uint32_t"    offset="4" info="Object name (type is *uint8_t)"/>
-      <member name="prev"        type="*os_timer_t" offset="8" info="Pointer to previous active timer"/>
-      <member name="next"        type="*os_timer_t" offset="12" info="Pointer to next active timer"/>
-      <member name="tick"        type="uint32_t"    offset="16" info="Timer current tick"/>
-      <member name="load"        type="uint32_t"    offset="20" info="Timer load value"/>
+      <member name="name"        type="uint32_t"      offset="4"  info="Object name (type is *uint8_t)"/>
+      <member name="prev"        type="*osRtxTimer_t" offset="8"  info="Pointer to previous active timer"/>
+      <member name="next"        type="*osRtxTimer_t" offset="12" info="Pointer to next active timer"/>
+      <member name="tick"        type="uint32_t"      offset="16" info="Timer current tick"/>
+      <member name="load"        type="uint32_t"      offset="20" info="Timer load value"/>
       <!-- Inlined "os_timer_finfo_t" structure -->
-      <member name="finfo_fp"    type="uint32_t"    offset="24" info="Timer function pointer (type is void *)"/>
-      <member name="finfo_arg"   type="uint32_t"    offset="28" info="Timer function argument (type is void *)"/>
+      <member name="finfo_fp"    type="uint32_t"      offset="24" info="Timer function pointer (type is void *)"/>
+      <member name="finfo_arg"   type="uint32_t"      offset="28" info="Timer function argument (type is void *)"/>
 
       <var name="obj_name" type="uint8_t"  info="Object name string" size="66" />
       <var name="cb_valid" type="uint32_t" info="Control Block validation status (valid=1, invalid=0)"/>
@@ -149,14 +213,14 @@
     </typedef>
 
     <!-- Event Flags Control Block -->
-    <typedef name="os_event_flags_t" info="" size="16">
-      <member name="id"          type="uint8_t"      offset="0" info="Object Identifier"/>
-      <member name="state"       type="uint8_t"      offset="1" info="Object State"/>
-      <member name="flags"       type="uint8_t"      offset="2" info="Object Flags"/>
-      <member name="reserved"    type="uint8_t"      offset="3" info=""/>
-      <member name="name"        type="uint32_t"     offset="4" info="Object name (type is *uint8_t)"/>
-      <member name="thread_list" type="*os_thread_t" offset="8" info="Waiting threads list"/>
-      <member name="event_flags" type="int32_t"      offset="12" info="Event flags"/>
+    <typedef name="osRtxEventFlags_t" info="" size="16">
+      <member name="id"          type="uint8_t"        offset="0"  info="Object Identifier"/>
+      <member name="state"       type="uint8_t"        offset="1"  info="Object State"/>
+      <member name="flags"       type="uint8_t"        offset="2"  info="Object Flags"/>
+      <member name="reserved"    type="uint8_t"        offset="3"  info=""/>
+      <member name="name"        type="uint32_t"       offset="4"  info="Object name (type is *uint8_t)"/>
+      <member name="thread_list" type="*osRtxThread_t" offset="8"  info="Waiting threads list"/>
+      <member name="event_flags" type="int32_t"        offset="12" info="Event flags"/>
 
       <var name="obj_name" type="uint8_t"  info="Object name string" size="66" />
       <var name="cb_valid" type="uint32_t" info="Control Block validation status (valid=1, invalid=0)"/>
@@ -165,21 +229,21 @@
     </typedef>
 
     <!-- Mutex Control Block -->
-    <typedef name="os_mutex_t" info="" size="28">
-      <member name="id"           type="uint8_t"      offset="0" info="Object Identifier"/>
-      <member name="state"        type="uint8_t"      offset="1" info="Object State"/>
-      <member name="flags"        type="uint8_t"      offset="2" info="Object Flags"/>
-      <member name="attr"         type="uint8_t"      offset="3" info="Object Attributes">
+    <typedef name="osRtxMutex_t" info="" size="28">
+      <member name="id"           type="uint8_t"        offset="0" info="Object Identifier"/>
+      <member name="state"        type="uint8_t"        offset="1" info="Object State"/>
+      <member name="flags"        type="uint8_t"        offset="2" info="Object Flags"/>
+      <member name="attr"         type="uint8_t"        offset="3" info="Object Attributes">
         <enum name="osMutexRecursive"   value="0x01" info="Recursive mutex."/>
         <enum name="osMutexPrioInherit" value="0x02" info="Priority inherit protocol."/>
         <enum name="osMutexRobust"      value="0x08" info="Robust mutex."/>
       </member>
-      <member name="name"         type="uint32_t"     offset="4" info="Object name (type is *uint8_t)"/>
-      <member name="thread_list"  type="*os_thread_t" offset="8" info="Waiting threads list"/>
-      <member name="owner_thread" type="*os_thread_t" offset="12" info="Owner thread"/>
-      <member name="owner_prev"   type="*os_mutex_t"  offset="16" info="Pointer to previous owned mutex"/>
-      <member name="owner_next"   type="*os_mutex_t"  offset="20" info="Pointer to next owned mutex"/>
-      <member name="lock"         type="uint8_t"      offset="24" info="Lock counter"/>
+      <member name="name"         type="uint32_t"       offset="4"  info="Object name (type is *uint8_t)"/>
+      <member name="thread_list"  type="*osRtxThread_t" offset="8"  info="Waiting threads list"/>
+      <member name="owner_thread" type="*osRtxThread_t" offset="12" info="Owner thread"/>
+      <member name="owner_prev"   type="*osRtxMutex_t"  offset="16" info="Pointer to previous owned mutex"/>
+      <member name="owner_next"   type="*osRtxMutex_t"  offset="20" info="Pointer to next owned mutex"/>
+      <member name="lock"         type="uint8_t"        offset="24" info="Lock counter"/>
 
       <var name="obj_name" type="uint8_t"  info="Object name string" size="66" />
       <var name="cb_valid" type="uint32_t" info="Control Block validation status (valid=1, invalid=0)"/>
@@ -188,15 +252,15 @@
     </typedef>
 
     <!-- Semaphore Control Block -->
-    <typedef name="os_semaphore_t" info="" size="16">
-      <member name="id"          type="uint8_t"      offset="0" info="Object Identifier"/>
-      <member name="state"       type="uint8_t"      offset="1" info="Object State"/>
-      <member name="flags"       type="uint8_t"      offset="2" info="Object Flags"/>
-      <member name="reserved"    type="uint8_t"      offset="3" info=""/>
-      <member name="name"        type="uint32_t"     offset="4" info="Object name (type is *uint8_t)"/>
-      <member name="thread_list" type="*os_thread_t" offset="8" info="Waiting threads list"/>
-      <member name="tokens"      type="uint16_t"     offset="12" info="Current number of tokens"/>
-      <member name="max_tokens"  type="uint16_t"     offset="14" info="Maximum number of tokens"/>
+    <typedef name="osRtxSemaphore_t" info="" size="16">
+      <member name="id"          type="uint8_t"        offset="0"  info="Object Identifier"/>
+      <member name="state"       type="uint8_t"        offset="1"  info="Object State"/>
+      <member name="flags"       type="uint8_t"        offset="2"  info="Object Flags"/>
+      <member name="reserved"    type="uint8_t"        offset="3"  info=""/>
+      <member name="name"        type="uint32_t"       offset="4"  info="Object name (type is *uint8_t)"/>
+      <member name="thread_list" type="*osRtxThread_t" offset="8"  info="Waiting threads list"/>
+      <member name="tokens"      type="uint16_t"       offset="12" info="Current number of tokens"/>
+      <member name="max_tokens"  type="uint16_t"       offset="14" info="Maximum number of tokens"/>
 
       <var name="obj_name" type="uint8_t"  info="Object name string" size="66" />
       <var name="cb_valid" type="uint32_t" info="Control Block validation status (valid=1, invalid=0)"/>
@@ -205,7 +269,7 @@
     </typedef>
 
     <!-- Memory Pool Information -->
-    <typedef name="os_mp_info_t" info="Memory pool information" size="24">
+    <typedef name="osRtxMpInfo_t" info="Memory pool information" size="24">
       <member name="max_blocks"  type="uint32_t" offset="0" info="Maximum number of blocks"/>
       <member name="used_blocks" type="uint32_t" offset="4" info="Number of used blocks"/>
       <member name="block_size"  type="uint32_t" offset="8" info="Block size"/>
@@ -215,21 +279,21 @@
     </typedef>
 
     <!-- Memory Pool Control Block -->
-    <typedef name="os_memory_pool_t" info="" size="36">
-      <member name="id"          type="uint8_t"      offset="0" info="Object Identifier"/>
-      <member name="state"       type="uint8_t"      offset="1" info="Object State"/>
-      <member name="flags"       type="uint8_t"      offset="2" info="Object Flags"/>
-      <member name="reserved"    type="uint8_t"      offset="3" info=""/>
-      <member name="name"        type="uint32_t"     offset="4" info="Object name (type is *uint8_t)"/>
-      <member name="thread_list" type="*os_thread_t" offset="8" info="Waiting threads list"/>
+    <typedef name="osRtxMemoryPool_t" info="" size="36">
+      <member name="id"          type="uint8_t"        offset="0" info="Object Identifier"/>
+      <member name="state"       type="uint8_t"        offset="1" info="Object State"/>
+      <member name="flags"       type="uint8_t"        offset="2" info="Object Flags"/>
+      <member name="reserved"    type="uint8_t"        offset="3" info=""/>
+      <member name="name"        type="uint32_t"       offset="4" info="Object name (type is *uint8_t)"/>
+      <member name="thread_list" type="*osRtxThread_t" offset="8" info="Waiting threads list"/>
 
-      <!-- Inlined "os_mp_info_t" structure -->
-      <member name="max_blocks"  type="uint32_t" offset="12+0" info="Maximum number of blocks"/>
-      <member name="used_blocks" type="uint32_t" offset="12+4" info="Number of used blocks"/>
-      <member name="block_size"  type="uint32_t" offset="12+8" info="Block size"/>
-      <member name="block_base"  type="uint32_t" offset="12+12" info="Block memory base address (type is void *)"/>
-      <member name="block_lim"   type="uint32_t" offset="12+16" info="Block memory limit address (type is void *)"/>
-      <member name="block_free"  type="uint32_t" offset="12+20" info="First free block address (type is void *)"/>
+      <!-- Inlined "osRtxMpInfo_t" structure -->
+      <member name="max_blocks"  type="uint32_t"       offset="12+0"  info="Maximum number of blocks"/>
+      <member name="used_blocks" type="uint32_t"       offset="12+4"  info="Number of used blocks"/>
+      <member name="block_size"  type="uint32_t"       offset="12+8"  info="Block size"/>
+      <member name="block_base"  type="uint32_t"       offset="12+12" info="Block memory base address (type is void *)"/>
+      <member name="block_lim"   type="uint32_t"       offset="12+16" info="Block memory limit address (type is void *)"/>
+      <member name="block_free"  type="uint32_t"       offset="12+20" info="First free block address (type is void *)"/>
 
       <var name="obj_name" type="uint8_t"  info="Object name string" size="66" />
       <var name="cb_valid" type="uint32_t" info="Control Block validation status (valid=1, invalid=0)"/>
@@ -238,38 +302,38 @@
     </typedef>
 
     <!-- Message Control Block -->
-    <typedef name="os_message_t" info="" size="12">
-      <member name="id"       type="uint8_t"       offset="0" info="Object Identifier"/>
-      <member name="state"    type="uint8_t"       offset="1" info="Object State"/>
-      <member name="flags"    type="uint8_t"       offset="2" info="Object Flags"/>
-      <member name="priority" type="uint8_t"       offset="3" info="Message priority"/>
-      <member name="prev"     type="*os_message_t" offset="4" info="Pointer to previous message"/>
-      <member name="next"     type="*os_message_t" offset="8" info="Pointer to next message"/>
+    <typedef name="osRtxMessage_t" info="" size="12">
+      <member name="id"       type="uint8_t"         offset="0" info="Object Identifier"/>
+      <member name="state"    type="uint8_t"         offset="1" info="Object State"/>
+      <member name="flags"    type="uint8_t"         offset="2" info="Object Flags"/>
+      <member name="priority" type="uint8_t"         offset="3" info="Message priority"/>
+      <member name="prev"     type="*osRtxMessage_t" offset="4" info="Pointer to previous message"/>
+      <member name="next"     type="*osRtxMessage_t" offset="8" info="Pointer to next message"/>
 
       <var name="addr" type="uint32_t" info="Message location address" />
     </typedef>
 
     <!-- Message Queue Control Block -->
-    <typedef name="os_message_queue_t" info="" size="52">
-      <member name="id"          type="uint8_t"       offset="0" info="Object Identifier"/>
-      <member name="state"       type="uint8_t"       offset="1" info="Object State"/>
-      <member name="flags"       type="uint8_t"       offset="2" info="Object Flags"/>
-      <member name="reserved"    type="uint8_t"       offset="3" info=""/>
-      <member name="name"        type="uint32_t"      offset="4" info="Object name (type is *uint8_t)"/>
-      <member name="thread_list" type="*os_thread_t"  offset="8" info="Waiting threads list"/>
+    <typedef name="osRtxMessageQueue_t" info="" size="52">
+      <member name="id"          type="uint8_t"         offset="0" info="Object Identifier"/>
+      <member name="state"       type="uint8_t"         offset="1" info="Object State"/>
+      <member name="flags"       type="uint8_t"         offset="2" info="Object Flags"/>
+      <member name="reserved"    type="uint8_t"         offset="3" info=""/>
+      <member name="name"        type="uint32_t"        offset="4" info="Object name (type is *uint8_t)"/>
+      <member name="thread_list" type="*osRtxThread_t"  offset="8" info="Waiting threads list"/>
 
-      <!-- Inlined "os_mp_info_t" structure -->
-      <member name="max_blocks"  type="uint32_t"      offset="12+0" info="Maximum number of blocks"/>
-      <member name="used_blocks" type="uint32_t"      offset="12+4" info="Number of used blocks"/>
-      <member name="block_size"  type="uint32_t"      offset="12+8" info="Block size"/>
-      <member name="block_base"  type="uint32_t"      offset="12+12" info="Block memory base address (type is void *)"/>
-      <member name="block_lim"   type="uint32_t"      offset="12+16" info="Block memory limit address (type is void *)"/>
-      <member name="block_free"  type="uint32_t"      offset="12+20" info="First free block address (type is void *)"/>
+      <!-- Inlined "osRtxMpInfo_t" structure -->
+      <member name="max_blocks"  type="uint32_t"        offset="12+0"  info="Maximum number of blocks"/>
+      <member name="used_blocks" type="uint32_t"        offset="12+4"  info="Number of used blocks"/>
+      <member name="block_size"  type="uint32_t"        offset="12+8"  info="Block size"/>
+      <member name="block_base"  type="uint32_t"        offset="12+12" info="Block memory base address (type is void *)"/>
+      <member name="block_lim"   type="uint32_t"        offset="12+16" info="Block memory limit address (type is void *)"/>
+      <member name="block_free"  type="uint32_t"        offset="12+20" info="First free block address (type is void *)"/>
 
-      <member name="msg_size"    type="uint32_t"      offset="36" info="Message size"/>
-      <member name="msg_count"   type="uint32_t"      offset="40" info="Number of queued messages"/>
-      <member name="msg_first"   type="*os_message_t" offset="44" info="Pointer to first message"/>
-      <member name="msg_last"    type="*os_message_t" offset="48" info="Pointer to last message"/>
+      <member name="msg_size"    type="uint32_t"        offset="36" info="Message size"/>
+      <member name="msg_count"   type="uint32_t"        offset="40" info="Number of queued messages"/>
+      <member name="msg_first"   type="*osRtxMessage_t" offset="44" info="Pointer to first message"/>
+      <member name="msg_last"    type="*osRtxMessage_t" offset="48" info="Pointer to last message"/>
 
       <var name="obj_name" type="uint8_t"  info="Object name string" size="66" />
       <var name="cb_valid" type="uint32_t" info="Control Block validation status (valid=1, invalid=0)"/>
@@ -281,19 +345,19 @@
 
     <!-- Generic Object Control Block -->
     <typedef name="os_object_t" info="" size="12">
-      <member name="id"          type="uint8_t"      offset="0" info="Object Identifier"/>
-      <member name="state"       type="uint8_t"      offset="1" info="Object State"/>
-      <member name="flags"       type="uint8_t"      offset="2" info="Object Flags"/>
-      <member name="reserved"    type="uint8_t"      offset="3" info=""/>
-      <member name="name"        type="uint32_t"     offset="4" info="Object name (type is *uint8_t)"/>
-      <member name="thread_list" type="*os_thread_t" offset="8" info="Threads list"/>
+      <member name="id"          type="uint8_t"        offset="0" info="Object Identifier"/>
+      <member name="state"       type="uint8_t"        offset="1" info="Object State"/>
+      <member name="flags"       type="uint8_t"        offset="2" info="Object Flags"/>
+      <member name="reserved"    type="uint8_t"        offset="3" info=""/>
+      <member name="name"        type="uint32_t"       offset="4" info="Object name (type is *uint8_t)"/>
+      <member name="thread_list" type="*osRtxThread_t" offset="8" info="Threads list"/>
     </typedef>
 
     <!-- OS Runtime Information structure -->
-    <typedef name="os_info_t" info="OS Runtime Information" size="168">
-      <member name="os_id"                      type="uint32_t"      offset="0" info="OS Identification (type is *uint8_t)"/>
-      <member name="version"                    type="uint32_t"      offset="4" info="OS Version"/>
-      <member name="kernel_state"               type="uint8_t"       offset="8" info="Kernel state">
+    <typedef name="osRtxInfo_t" info="OS Runtime Information" size="168">
+      <member name="os_id"                      type="uint32_t"             offset="0" info="OS Identification (type is *uint8_t)"/>
+      <member name="version"                    type="uint32_t"             offset="4" info="OS Version"/>
+      <member name="kernel_state"               type="uint8_t"              offset="8" info="Kernel state">
         <enum name="osKernelInactive"  value="0"  info="Inactive"/>
         <enum name="osKernelReady"     value="1"  info="Ready"/>
         <enum name="osKernelRunning"   value="2"  info="Running"/>
@@ -301,72 +365,69 @@
         <enum name="osKernelSuspended" value="4"  info="Suspended"/>
         <enum name="osKernelError"     value="5"  info="Error"/>
       </member>
-      <member name="kernel_blocked"             type="uint8_t"       offset="9" info="Kernel blocked"/>
-      <member name="kernel_pendISR"             type="uint8_t"       offset="10" info="Kernel pending ISR"/>
-      <member name="kernel_pendSV"              type="uint8_t"       offset="11" info="Kernel pending SV"/>
-      <member name="kernel_sys_freq"            type="uint32_t"      offset="12" info="Kernel system frequency"/>
-      <member name="kernel_tick"                type="uint64_t"      offset="16" info="Kernel tick counter"/>
-
-      <member name="tick_irqn"                  type="int32_t"       offset="24" info="Tick timer IRQ number"/>
-
-      <member name="thread_run_curr"            type="*os_thread_t"  offset="28" info="Current running thread"/>
-      <member name="thread_run_next"            type="*os_thread_t"  offset="32" info="Next thread to run"/>
+      <member name="kernel_blocked"             type="uint8_t"              offset="9"  info="Kernel blocked"/>
+      <member name="kernel_pendISR"             type="uint8_t"              offset="10" info="Kernel pending ISR"/>
+      <member name="kernel_pendSV"              type="uint8_t"              offset="11" info="Kernel pending SV"/>
+      <member name="kernel_sys_freq"            type="uint32_t"             offset="12" info="Kernel system frequency"/>
+      <member name="kernel_tick"                type="uint64_t"             offset="16" info="Kernel tick counter"/>
+      <member name="tick_irqn"                  type="int32_t"              offset="24" info="Tick timer IRQ number"/>
+      <member name="thread_run_curr"            type="*osRtxThread_t"       offset="28" info="Current running thread"/>
+      <member name="thread_run_next"            type="*osRtxThread_t"       offset="32" info="Next thread to run"/>
 
       <!-- Inlined "os_object_t" structure at offset: 36 -->
-      <!-- <member name="thread_ready"          type="os_object_t"  offset="36" info="Ready list object"/>-->
-      <member name="thread_ready_id"            type="uint8_t"       offset="36+0" info="Object Identifier" />
-      <member name="thread_ready_state"         type="uint8_t"       offset="36+1" info="Object State" />
-      <member name="thread_ready_flags"         type="uint8_t"       offset="36+2" info="Object Flags" />
-      <member name="thread_ready_rsvd"          type="uint8_t"       offset="36+3" info="Reserved" />
-      <member name="thread_ready_name"          type="uint32_t"      offset="36+4" info="Object Name (type is *uint8_t)" />
-      <member name="thread_ready_thread_list"   type="*os_thread_t"  offset="36+8" info="Threads List" />
+      <member name="thread_ready_id"            type="uint8_t"              offset="36+0" info="Object Identifier" />
+      <member name="thread_ready_state"         type="uint8_t"              offset="36+1" info="Object State" />
+      <member name="thread_ready_flags"         type="uint8_t"              offset="36+2" info="Object Flags" />
+      <member name="thread_ready_rsvd"          type="uint8_t"              offset="36+3" info="Reserved" />
+      <member name="thread_ready_name"          type="uint32_t"             offset="36+4" info="Object Name (type is *uint8_t)" />
+      <member name="thread_ready_thread_list"   type="*osRtxThread_t"       offset="36+8" info="Threads List" />
 
-      <member name="thread_idle"                type="*os_thread_t"  offset="48" info="Idle thread"/>
-      <member name="thread_delay_list"          type="*os_thread_t"  offset="52" info="Delay list"/>
-      <member name="thread_wait_list"           type="*os_thread_t"  offset="56" info="Wait list (no timeout)"/>
-      <member name="thread_terminate_list"      type="*os_thread_t"  offset="60" info="Terminate list"/>
+      <member name="thread_idle"                type="*osRtxThread_t"       offset="48"  info="Idle thread"/>
+      <member name="thread_delay_list"          type="*osRtxThread_t"       offset="52"  info="Delay list"/>
+      <member name="thread_wait_list"           type="*osRtxThread_t"       offset="56"  info="Wait list (no timeout)"/>
+      <member name="thread_terminate_list"      type="*osRtxThread_t"       offset="60"  info="Terminate list"/>
 
-      <member name="thread_robin_thread"        type="*os_thread_t"  offset="64" info="Round Robin thread"/>
-      <member name="thread_robin_tick"          type="uint32_t"      offset="68" info="Round Robin time tick"/>
-      <member name="thread_timeout"             type="uint32_t"      offset="72" info="Round Robin timeout"/>
+      <member name="thread_robin_thread"        type="*osRtxThread_t"       offset="64"  info="Round Robin thread"/>
+      <member name="thread_robin_tick"          type="uint32_t"             offset="68"  info="Round Robin time tick"/>
+      <member name="thread_timeout"             type="uint32_t"             offset="72"  info="Round Robin timeout"/>
 
-      <member name="timer_list"                 type="*os_timer_t"   offset="76" info="Active timer list"/>
-      <member name="timer_thread"               type="*os_thread_t"  offset="80" info="Timer thread"/>
-      <member name="timer_mq"                   type="*os_message_queue_t" offset="84" info="Timer message queue"/>
+      <member name="timer_list"                 type="*osRtxTimer_t"        offset="76"  info="Active timer list"/>
+      <member name="timer_thread"               type="*osRtxThread_t"       offset="80"  info="Timer thread"/>
+      <member name="timer_mq"                   type="*osRtxMessageQueue_t" offset="84"  info="Timer message queue"/>
 
-      <member name="isr_queue_max"              type="uint16_t"      offset="88" info="Maximum items"/>
-      <member name="isr_queue_cnt"              type="uint16_t"      offset="90" info="Item count"/>
-      <member name="isr_queue_in"               type="uint16_t"      offset="92" info="Incoming item index"/>
-      <member name="isr_queue_out"              type="uint16_t"      offset="94" info="Outgoing item index"/>
-      <member name="isr_queue_data"             type="uint32_t"      offset="96" info="Queue data (value is void **)"/>
+      <member name="isr_queue_max"              type="uint16_t"             offset="88"  info="Maximum items"/>
+      <member name="isr_queue_cnt"              type="uint16_t"             offset="90"  info="Item count"/>
+      <member name="isr_queue_in"               type="uint16_t"             offset="92"  info="Incoming item index"/>
+      <member name="isr_queue_out"              type="uint16_t"             offset="94"  info="Outgoing item index"/>
+      <member name="isr_queue_data"             type="uint32_t"             offset="96"  info="Queue data (value is void **)"/>
 
-      <member name="post_process_thread"        type="uint32_t"      offset="100" info="Thread post processing function (value is func *)"/>
-      <member name="post_process_event_flags"   type="uint32_t"      offset="104" info="Event flags post processing function (value is func *)"/>
-      <member name="post_process_semaphore"     type="uint32_t"      offset="108" info="Semaphore post processing function (value is func *)"/>
-      <member name="post_process_memory_pool"   type="uint32_t"      offset="112" info="Memory pool post processing function (value is func *)"/>
-      <member name="post_process_message_queue" type="uint32_t"      offset="116" info="Message queue post processing function (value is func *)"/>
+      <member name="post_process_thread"        type="uint32_t"             offset="100" info="Thread post processing function (value is func *)"/>
+      <member name="post_process_event_flags"   type="uint32_t"             offset="104" info="Event flags post processing function (value is func *)"/>
+      <member name="post_process_semaphore"     type="uint32_t"             offset="108" info="Semaphore post processing function (value is func *)"/>
+      <member name="post_process_memory_pool"   type="uint32_t"             offset="112" info="Memory pool post processing function (value is func *)"/>
+      <member name="post_process_message_queue" type="uint32_t"             offset="116" info="Message queue post processing function (value is func *)"/>
 
-      <member name="mem_stack"                  type="uint32_t"      offset="120" info="Stack memory (value is void *)"/>
-      <member name="mem_mp_data"                type="uint32_t"      offset="124" info="Memory pool data memory (value is void *)"/>
-      <member name="mem_mq_data"                type="uint32_t"      offset="128" info="Message queue Data memory (value is void *)"/>
-      <member name="mem_common"                 type="uint32_t"      offset="132" info="Common memory address (value is void *)"/>
+      <member name="mem_stack"                  type="uint32_t"             offset="120" info="Stack memory (value is void *)"/>
+      <member name="mem_mp_data"                type="uint32_t"             offset="124" info="Memory pool data memory (value is void *)"/>
+      <member name="mem_mq_data"                type="uint32_t"             offset="128" info="Message queue Data memory (value is void *)"/>
+      <member name="mem_common"                 type="uint32_t"             offset="132" info="Common memory address (value is void *)"/>
 
-      <member name="mpi_stack"                  type="*os_mp_info_t" offset="136" info="Stack for threads"/>
-      <member name="mpi_thread"                 type="*os_mp_info_t" offset="140" info="Thread control blocks"/>
-      <member name="mpi_timer"                  type="*os_mp_info_t" offset="144" info="Timer control blocks"/>
-      <member name="mpi_event_flags"            type="*os_mp_info_t" offset="148" info="Event flags control blocks"/>
-      <member name="mpi_mutex"                  type="*os_mp_info_t" offset="152" info="Mutex control blocks"/>
-      <member name="mpi_semaphore"              type="*os_mp_info_t" offset="156" info="Semaphore control blocks"/>
-      <member name="mpi_memory_pool"            type="*os_mp_info_t" offset="160" info="Memory pool control blocks"/>
-      <member name="mpi_message_queue"          type="*os_mp_info_t" offset="164" info="Message queue control blocks"/>
+      <member name="mpi_stack"                  type="*osRtxMpInfo_t"       offset="136" info="Stack for threads"/>
+      <member name="mpi_thread"                 type="*osRtxMpInfo_t"       offset="140" info="Thread control blocks"/>
+      <member name="mpi_timer"                  type="*osRtxMpInfo_t"       offset="144" info="Timer control blocks"/>
+      <member name="mpi_event_flags"            type="*osRtxMpInfo_t"       offset="148" info="Event flags control blocks"/>
+      <member name="mpi_mutex"                  type="*osRtxMpInfo_t"       offset="152" info="Mutex control blocks"/>
+      <member name="mpi_semaphore"              type="*osRtxMpInfo_t"       offset="156" info="Semaphore control blocks"/>
+      <member name="mpi_memory_pool"            type="*osRtxMpInfo_t"       offset="160" info="Memory pool control blocks"/>
+      <member name="mpi_message_queue"          type="*osRtxMpInfo_t"       offset="164" info="Message queue control blocks"/>
     </typedef>
 
     <!-- OS Configuration structure -->
-    <typedef name="os_config_t" const="1" info="OS Configuration Structure" size="100">
+    <typedef name="osRtxConfig_t" const="1" info="OS Configuration Structure" size="100">
       <member name="flags"                 type="uint32_t" offset="0" info="OS configuration flags"/>
       <member name="tick_freq"             type="uint32_t" offset="4" info="Kernel tick frequency"/>
 
-      <member name="robin_timeout"         type="uint32_t" offset="8" info="Round Robim timeout tick"/>
+      <member name="robin_timeout"         type="uint32_t" offset="8"  info="Round Robim timeout tick"/>
       <member name="isr_queue_data"        type="uint32_t" offset="12" info="ISR post processing queue (value is void **)"/>
       <member name="isr_queue_max"         type="uint16_t" offset="14" info="Maximum data"/>
       <member name="isr_queue_padding"     type="uint16_t" offset="16" info="Padding bytes"/>
@@ -380,14 +441,14 @@
       <member name="mem_common_addr"       type="uint32_t" offset="44" info="Common memory address"/>
       <member name="mem_common_size"       type="uint32_t" offset="48" info="Common memory size"/>
 
-      <member name="mpi_stack"             type="*os_mp_info_t" offset="52" info="Stack for threads"/>
-      <member name="mpi_thread"            type="*os_mp_info_t" offset="56" info="Thread control blocks"/>
-      <member name="mpi_timer"             type="*os_mp_info_t" offset="60" info="Timer control blocks"/>
-      <member name="mpi_event_flags"       type="*os_mp_info_t" offset="64" info="Event flags control blocks"/>
-      <member name="mpi_mutex"             type="*os_mp_info_t" offset="68" info="Mutex control blocks"/>
-      <member name="mpi_semaphore"         type="*os_mp_info_t" offset="72" info="Semaphore control blocks"/>
-      <member name="mpi_memory_pool"       type="*os_mp_info_t" offset="76" info="Memory pool control blocks"/>
-      <member name="mpi_message_queue"     type="*os_mp_info_t" offset="80" info="Message queue control blocks"/>
+      <member name="mpi_stack"             type="*osRtxMpInfo_t" offset="52" info="Stack for threads"/>
+      <member name="mpi_thread"            type="*osRtxMpInfo_t" offset="56" info="Thread control blocks"/>
+      <member name="mpi_timer"             type="*osRtxMpInfo_t" offset="60" info="Timer control blocks"/>
+      <member name="mpi_event_flags"       type="*osRtxMpInfo_t" offset="64" info="Event flags control blocks"/>
+      <member name="mpi_mutex"             type="*osRtxMpInfo_t" offset="68" info="Mutex control blocks"/>
+      <member name="mpi_semaphore"         type="*osRtxMpInfo_t" offset="72" info="Semaphore control blocks"/>
+      <member name="mpi_memory_pool"       type="*osRtxMpInfo_t" offset="76" info="Memory pool control blocks"/>
+      <member name="mpi_message_queue"     type="*osRtxMpInfo_t" offset="80" info="Message queue control blocks"/>
 
       <member name="thread_stack_size"     type="uint32_t" offset="84"  info="Default thread stack size"/>
       <member name="idle_thread_attr"      type="uint32_t" offset="88"  info="Idle thread attributes (value is osThreadAttr_s *)"/>
@@ -409,6 +470,52 @@
       <member name="id"       type="uint8_t"      offset="8"  info="Object Identifier"/>
     </typedef>
 
+    <!-- Helper typedefs -->
+    <typedef name="rtx_t" info="Various RTX Definitions" size="8">
+      <member name="status" type="int32_t" offset="0" info="RTX5 operations status">
+        <enum name="osOK"                          value="0"   info="Operation completed successfully"/>
+        <enum name="osError"                       value="-1"  info="Unspecified RTOS error: run-time error but no other error message fits."/>
+        <enum name="osErrorTimeout"                value="-2"  info="Operation not completed within the timeout period."/>
+        <enum name="osErrorResource"               value="-3"  info="Resource not available"/>
+        <enum name="osErrorParameter"              value="-4"  info="Parameter error"/>
+        <enum name="osErrorNoMemory"               value="-5"  info="System is out of memory: it was impossible to allocate or reserve memory for the operation"/>
+        <enum name="osErrorISR"                    value="-6"  info="Not allowed in ISR context: the function cannot be called from interrupt service routines"/>
+        <enum name="osRtxErrorKernelNotReady"      value="-7"  info="RTOS Kernel scheduler is not ready"/>
+        <enum name="osRtxErrorKernelNotRunning"    value="-8"  info="RTOS Kernel scheduler is not running"/>
+        <enum name="osRtxErrorInvalidControlBlock" value="-9"  info="Object control block is not properly aligned or has an invalid size"/>
+        <enum name="osRtxErrorInvalidDataMemory"   value="-10" info="Data memory is not is not properly aligned or has an invalid size"/>
+        <enum name="osRtxErrorInvalidThreadStack"  value="-11" info="Thread stack is invalid"/>
+        <enum name="osRtxErrorInvalidPriority"     value="-12" info="Thread priority is invalid"/>
+        <enum name="osRtxErrorThreadNotJoinable"   value="-13" info="Thread is not joinable"/>
+        <enum name="osRtxErrorMutexNotOwned"       value="-14" info="Mutex is not owned by the current running thread"/>
+        <enum name="osRtxErrorMutexNotLocked"      value="-15" info="Mutex is not locked"/>
+        <enum name="osRtxErrorMutexLockLimit"      value="-16" info="Maximum number of recursive mutex locks reached"/>
+        <enum name="osRtxErrorSemaphoreCountLimit" value="-17" info="Semaphore count limit reached"/>
+        <enum name="osRtxErrorTZ_InitContext_S"    value="-18" info=""/>
+        <enum name="osRtxErrorTZ_AllocContext_S"   value="-19" info=""/>
+        <enum name="osRtxErrorTZ_FreeContext_S"    value="-20" info=""/>
+        <enum name="osRtxErrorTZ_LoadContext_S"    value="-21" info=""/>
+        <enum name="osRtxErrorTZ_SaveContext_S"    value="-22" info=""/>
+      </member>
+
+      <member name="thread_state" type="int32_t" offset="0" info="RTX5 thread state">
+        <enum name="os_ThreadInactive"           value="0x00"   info=""/>
+        <enum name="os_ThreadReady"              value="0x01"   info=""/>
+        <enum name="os_ThreadRunning"            value="0x02"   info=""/>
+        <enum name="os_ThreadBlocked"            value="0x03"   info=""/>
+        <enum name="os_ThreadTerminated"         value="0x04"   info=""/>
+        <enum name="os_ThreadWaitingDelay"       value="0x13"   info=""/>
+        <enum name="os_ThreadWaitingJoin"        value="0x23"   info=""/>
+        <enum name="os_ThreadWaitingThreadFlags" value="0x33"   info=""/>
+        <enum name="os_ThreadWaitingEventFlags"  value="0x43"   info=""/>
+        <enum name="os_ThreadWaitingMutex"       value="0x53"   info=""/>
+        <enum name="os_ThreadWaitingSemaphore"   value="0x63"   info=""/>
+        <enum name="os_ThreadWaitingMemoryPool"  value="0x73"   info=""/>
+        <enum name="os_ThreadWaitingMessageGet"  value="0x83"   info=""/>
+        <enum name="os_ThreadWaitingMessagePut"  value="0x93"   info=""/>
+      </member>
+    </typedef>
+
   </typedefs>
 
   <objects>
@@ -432,17 +539,17 @@
       <var name="StaticMp_En" type="uint8_t" value="0" />
 
       <!-- Read main OS information and configuration structures -->
-      <readlist name="os_Info"   type="os_info_t"   symbol="os_Info"   count="1" init="1"/>
-      <readlist name="os_Config" type="os_config_t" symbol="os_Config" count="1" init="1"/>
+      <readlist name="os_Info"   type="osRtxInfo_t"   symbol="osRtxInfo"   count="1" init="1"/>
+      <readlist name="os_Config" type="osRtxConfig_t" symbol="osRtxConfig" count="1" init="1"/>
 
       <!-- Read statically allocated control blocks -->
-      <readlist name="cfg_mp_thread"    cond="os_Config.mpi_thread"        type="os_mp_info_t" offset="os_Config.mpi_thread"        const="1" count="1" init="1"/>
-      <readlist name="cfg_mp_timer"     cond="os_Config.mpi_timer"         type="os_mp_info_t" offset="os_Config.mpi_timer"         const="1" count="1" init="1"/>
-      <readlist name="cfg_mp_events"    cond="os_Config.mpi_event_flags"   type="os_mp_info_t" offset="os_Config.mpi_event_flags"   const="1" count="1" init="1"/>
-      <readlist name="cfg_mp_mutex"     cond="os_Config.mpi_mutex"         type="os_mp_info_t" offset="os_Config.mpi_mutex"         const="1" count="1" init="1"/>
-      <readlist name="cfg_mp_semaphore" cond="os_Config.mpi_semaphore"     type="os_mp_info_t" offset="os_Config.mpi_semaphore"     const="1" count="1" init="1"/>
-      <readlist name="cfg_mp_mpool"     cond="os_Config.mpi_memory_pool"   type="os_mp_info_t" offset="os_Config.mpi_memory_pool"   const="1" count="1" init="1"/>
-      <readlist name="cfg_mp_mqueue"    cond="os_Config.mpi_message_queue" type="os_mp_info_t" offset="os_Config.mpi_message_queue" const="1" count="1" init="1"/>
+      <readlist name="cfg_mp_thread"    cond="os_Config.mpi_thread"        type="osRtxMpInfo_t" offset="os_Config.mpi_thread"        const="1" count="1" init="1"/>
+      <readlist name="cfg_mp_timer"     cond="os_Config.mpi_timer"         type="osRtxMpInfo_t" offset="os_Config.mpi_timer"         const="1" count="1" init="1"/>
+      <readlist name="cfg_mp_events"    cond="os_Config.mpi_event_flags"   type="osRtxMpInfo_t" offset="os_Config.mpi_event_flags"   const="1" count="1" init="1"/>
+      <readlist name="cfg_mp_mutex"     cond="os_Config.mpi_mutex"         type="osRtxMpInfo_t" offset="os_Config.mpi_mutex"         const="1" count="1" init="1"/>
+      <readlist name="cfg_mp_semaphore" cond="os_Config.mpi_semaphore"     type="osRtxMpInfo_t" offset="os_Config.mpi_semaphore"     const="1" count="1" init="1"/>
+      <readlist name="cfg_mp_mpool"     cond="os_Config.mpi_memory_pool"   type="osRtxMpInfo_t" offset="os_Config.mpi_memory_pool"   const="1" count="1" init="1"/>
+      <readlist name="cfg_mp_mqueue"    cond="os_Config.mpi_message_queue" type="osRtxMpInfo_t" offset="os_Config.mpi_message_queue" const="1" count="1" init="1"/>
 
       <calc cond="((os_Info.version / 10000000) == 5) &amp;&amp; (os_Info.kernel_state &gt; 0) &amp;&amp; (os_Info.kernel_state &lt; 5)">
         RTX_En = 1;
@@ -459,36 +566,36 @@
       <read name="ISR_FIFO" cond="RTX_En" type="uint32_t" offset="os_Config.isr_queue_data" size="os_Config.isr_queue_max"/>
 
       <!-- Read idle and timer thread control blocks -->
-      <readlist name="TCB" cond="RTX_En &amp;&amp; os_Info.thread_idle"  type="os_thread_t" offset="os_Info.thread_idle"  count="1" />
-      <readlist name="TCB" cond="RTX_En &amp;&amp; os_Info.timer_thread" type="os_thread_t" offset="os_Info.timer_thread" count="1" />
+      <readlist name="TCB" cond="RTX_En &amp;&amp; os_Info.thread_idle"  type="osRtxThread_t" offset="os_Info.thread_idle"  count="1" />
+      <readlist name="TCB" cond="RTX_En &amp;&amp; os_Info.timer_thread" type="osRtxThread_t" offset="os_Info.timer_thread" count="1" />
 
       <!-- Read thread control blocks (MPI) -->
-      <readlist name="mp_thread" cond="RTX_En &amp;&amp; os_Info.mpi_thread" type="os_mp_info_t" offset="os_Info.mpi_thread"   count="1" init="1"/>
-      <readlist name="TCB"       cond="RTX_En &amp;&amp; os_Info.mpi_thread" type="os_thread_t"  offset="mp_thread.block_base" count="mp_thread.max_blocks" />
+      <readlist name="mp_thread" cond="RTX_En &amp;&amp; os_Info.mpi_thread" type="osRtxMpInfo_t" offset="os_Info.mpi_thread"   count="1" init="1"/>
+      <readlist name="TCB"       cond="RTX_En &amp;&amp; os_Info.mpi_thread" type="osRtxThread_t" offset="mp_thread.block_base" count="mp_thread.max_blocks" />
 
       <!-- Read timer control blocks (MPI) -->
-      <readlist name="mp_timer" cond="RTX_En &amp;&amp; os_Info.mpi_timer" type="os_mp_info_t" offset="os_Info.mpi_timer"   count="1" init="1"/>
-      <readlist name="CCB"      cond="RTX_En &amp;&amp; os_Info.mpi_timer" type="os_timer_t"   offset="mp_timer.block_base" count="mp_timer.max_blocks" />
+      <readlist name="mp_timer" cond="RTX_En &amp;&amp; os_Info.mpi_timer" type="osRtxMpInfo_t" offset="os_Info.mpi_timer"   count="1" init="1"/>
+      <readlist name="CCB"      cond="RTX_En &amp;&amp; os_Info.mpi_timer" type="osRtxTimer_t"  offset="mp_timer.block_base" count="mp_timer.max_blocks" />
 
       <!-- Read event flags control blocks (MPI) -->
-      <readlist name="mp_events" cond="RTX_En &amp;&amp; os_Info.mpi_event_flags" type="os_mp_info_t"     offset="os_Info.mpi_event_flags" count="1" init="1"/>
-      <readlist name="ECB"       cond="RTX_En &amp;&amp; os_Info.mpi_event_flags" type="os_event_flags_t" offset="mp_events.block_base"    count="mp_events.max_blocks" />
+      <readlist name="mp_events" cond="RTX_En &amp;&amp; os_Info.mpi_event_flags" type="osRtxMpInfo_t"     offset="os_Info.mpi_event_flags" count="1" init="1"/>
+      <readlist name="ECB"       cond="RTX_En &amp;&amp; os_Info.mpi_event_flags" type="osRtxEventFlags_t" offset="mp_events.block_base"    count="mp_events.max_blocks" />
 
       <!-- Read mutex control blocks (MPI) -->
-      <readlist name="mp_mutex" cond="RTX_En &amp;&amp; os_Info.mpi_mutex" type="os_mp_info_t" offset="os_Info.mpi_mutex"   count="1" init="1"/>
-      <readlist name="MCB"      cond="RTX_En &amp;&amp; os_Info.mpi_mutex" type="os_mutex_t"   offset="mp_mutex.block_base" count="mp_mutex.max_blocks" />
+      <readlist name="mp_mutex" cond="RTX_En &amp;&amp; os_Info.mpi_mutex" type="osRtxMpInfo_t" offset="os_Info.mpi_mutex"   count="1" init="1"/>
+      <readlist name="MCB"      cond="RTX_En &amp;&amp; os_Info.mpi_mutex" type="osRtxMutex_t"  offset="mp_mutex.block_base" count="mp_mutex.max_blocks" />
 
       <!-- Read semaphore control blocks (MPI) -->
-      <readlist name="mp_semaphore" cond="RTX_En &amp;&amp; os_Info.mpi_semaphore" type="os_mp_info_t"   offset="os_Info.mpi_semaphore"   count="1" init="1"/>
-      <readlist name="SCB"          cond="RTX_En &amp;&amp; os_Info.mpi_semaphore" type="os_semaphore_t" offset="mp_semaphore.block_base" count="mp_semaphore.max_blocks" />
+      <readlist name="mp_semaphore" cond="RTX_En &amp;&amp; os_Info.mpi_semaphore" type="osRtxMpInfo_t"    offset="os_Info.mpi_semaphore"   count="1" init="1"/>
+      <readlist name="SCB"          cond="RTX_En &amp;&amp; os_Info.mpi_semaphore" type="osRtxSemaphore_t" offset="mp_semaphore.block_base" count="mp_semaphore.max_blocks" />
 
       <!-- Read memory pool control blocks (MPI) -->
-      <readlist name="mp_mpool" cond="RTX_En &amp;&amp; os_Info.mpi_memory_pool" type="os_mp_info_t"     offset="os_Info.mpi_memory_pool" count="1" init="1"/>
-      <readlist name="PCB"      cond="RTX_En &amp;&amp; os_Info.mpi_memory_pool" type="os_memory_pool_t" offset="mp_mpool.block_base"     count="mp_mpool.max_blocks" />
+      <readlist name="mp_mpool" cond="RTX_En &amp;&amp; os_Info.mpi_memory_pool" type="osRtxMpInfo_t"     offset="os_Info.mpi_memory_pool" count="1" init="1"/>
+      <readlist name="PCB"      cond="RTX_En &amp;&amp; os_Info.mpi_memory_pool" type="osRtxMemoryPool_t" offset="mp_mpool.block_base"     count="mp_mpool.max_blocks" />
 
       <!-- Read message queue control blocks (MPI) -->
-      <readlist name="mp_mqueue" cond="RTX_En &amp;&amp; os_Info.mpi_message_queue" type="os_mp_info_t"       offset="os_Info.mpi_message_queue" count="1" init="1"/>
-      <readlist name="QCB"       cond="RTX_En &amp;&amp; os_Info.mpi_message_queue" type="os_message_queue_t" offset="mp_mqueue.block_base"      count="mp_mqueue.max_blocks" />
+      <readlist name="mp_mqueue" cond="RTX_En &amp;&amp; os_Info.mpi_message_queue" type="osRtxMpInfo_t"       offset="os_Info.mpi_message_queue" count="1" init="1"/>
+      <readlist name="QCB"       cond="RTX_En &amp;&amp; os_Info.mpi_message_queue" type="osRtxMessageQueue_t" offset="mp_mqueue.block_base"      count="mp_mqueue.max_blocks" />
 
       <!-- Read common memory pool block info (MEM) -->
       <readlist name="mem_bl" cond="RTX_En &amp;&amp; os_Info.mem_common" type="mem_block_t" offset="os_Info.mem_common + 8" next="next"/>
@@ -500,29 +607,29 @@
         </calc>
 
         <!-- Read Thread Control Block -->
-        <readlist cond="(mem_bl[i].len &amp; 1) &amp;&amp; (mem_bl[i].id == 1)" name="TCB" type="os_thread_t" offset="addr" count="1" />
+        <readlist cond="(mem_bl[i].len &amp; 1) &amp;&amp; (mem_bl[i].id == 1)" name="TCB" type="osRtxThread_t" offset="addr" count="1" />
 
         <!-- Read Timer Control Block -->
-        <readlist cond="(mem_bl[i].len &amp; 1) &amp;&amp; (mem_bl[i].id == 2)" name="CCB" type="os_timer_t" offset="addr" count="1" />
+        <readlist cond="(mem_bl[i].len &amp; 1) &amp;&amp; (mem_bl[i].id == 2)" name="CCB" type="osRtxTimer_t" offset="addr" count="1" />
 
         <!-- Read EventFlags Control Block -->
-        <readlist cond="(mem_bl[i].len &amp; 1) &amp;&amp; (mem_bl[i].id == 3)" name="ECB" type="os_event_flags_t" offset="addr" count="1" />
+        <readlist cond="(mem_bl[i].len &amp; 1) &amp;&amp; (mem_bl[i].id == 3)" name="ECB" type="osRtxEventFlags_t" offset="addr" count="1" />
 
         <!-- Read Mutex Control Block -->
-        <readlist cond="(mem_bl[i].len &amp; 1) &amp;&amp; (mem_bl[i].id == 4)" name="MCB" type="os_mutex_t" offset="addr" count="1" />
+        <readlist cond="(mem_bl[i].len &amp; 1) &amp;&amp; (mem_bl[i].id == 4)" name="MCB" type="osRtxMutex_t" offset="addr" count="1" />
 
         <!-- Read Semaphore Control Block -->
-        <readlist cond="(mem_bl[i].len &amp; 1) &amp;&amp; (mem_bl[i].id == 5)" name="SCB" type="os_semaphore_t" offset="addr" count="1" />
+        <readlist cond="(mem_bl[i].len &amp; 1) &amp;&amp; (mem_bl[i].id == 5)" name="SCB" type="osRtxSemaphore_t" offset="addr" count="1" />
 
         <!-- Read MemoryPool Control Block -->
-        <readlist cond="(mem_bl[i].len &amp; 1) &amp;&amp; (mem_bl[i].id == 6)" name="PCB" type="os_memory_pool_t" offset="addr" count="1" />
+        <readlist cond="(mem_bl[i].len &amp; 1) &amp;&amp; (mem_bl[i].id == 6)" name="PCB" type="osRtxMemoryPool_t" offset="addr" count="1" />
 
         <!-- Read MessageQueue Control Block -->
-        <readlist cond="(mem_bl[i].len &amp; 1) &amp;&amp; (mem_bl[i].id == 8)" name="QCB" type="os_message_queue_t" offset="addr" count="1" />
+        <readlist cond="(mem_bl[i].len &amp; 1) &amp;&amp; (mem_bl[i].id == 8)" name="QCB" type="osRtxMessageQueue_t" offset="addr" count="1" />
       </list>
 
       <!-- Read thread wait list -->
-      <readlist name="TWL" cond="RTX_En &amp;&amp; os_Info.thread_wait_list" type="os_thread_t" offset="os_Info.thread_wait_list" next="delay_next"/>
+      <readlist name="TWL" cond="RTX_En &amp;&amp; os_Info.thread_wait_list" type="osRtxThread_t" offset="os_Info.thread_wait_list" next="delay_next"/>
 
       <!-- Validate and process Thread control blocks -->
       <list name="i" start="0" limit="TCB._count">
@@ -600,7 +707,7 @@
         </calc>
 
         <!-- Create Thread Delay List (TDL) -->
-        <readlist cond="TCB[i].delay != -1" name="TDL" type="os_thread_t" offset="TCB[i].delay_prev" next="delay_prev" init="1"/>
+        <readlist cond="TCB[i].delay != -1" name="TDL" type="osRtxThread_t" offset="TCB[i].delay_prev" next="delay_prev" init="1"/>
 
         <list cond="TCB[i].delay != -1" name="j" start="0" limit="TDL._count">
           <calc>
@@ -635,7 +742,7 @@
         </calc>
 
         <!-- Create Timer Execution List (TEL) -->
-        <readlist name="TEL" type="os_timer_t" offset="CCB[i].prev" next="prev" init="1"/>
+        <readlist name="TEL" type="osRtxTimer_t" offset="CCB[i].prev" next="prev" init="1"/>
 
         <list name="j" start="0" limit="TEL._count">
           <calc>
@@ -671,7 +778,7 @@
         </calc>
 
         <!-- Create a list of threads waiting for event flags -->
-        <readlist name="EWL" type="os_thread_t" offset="ECB[i].thread_list" next="thread_next" />
+        <readlist name="EWL" type="osRtxThread_t" offset="ECB[i].thread_list" next="thread_next" />
 
         <calc>
           ECB[i].wl_cnt = (EWL._count - k);
@@ -706,7 +813,7 @@
         </calc>
 
         <!-- Create a list of threads waiting for mutex -->
-        <readlist name="MWL" type="os_thread_t" offset="MCB[i].thread_list" next="thread_next" />
+        <readlist name="MWL" type="osRtxThread_t" offset="MCB[i].thread_list" next="thread_next" />
 
         <calc>
           MCB[i].wl_cnt = (MWL._count - k);
@@ -742,7 +849,7 @@
         </calc>
 
         <!-- Create a list of threads waiting for semaphore -->
-        <readlist name="SWL" type="os_thread_t" offset="SCB[i].thread_list" next="thread_next" />
+        <readlist name="SWL" type="osRtxThread_t" offset="SCB[i].thread_list" next="thread_next" />
 
         <calc>
           SCB[i].wl_cnt = (SWL._count - k);
@@ -777,7 +884,7 @@
         </calc>
 
         <!-- Create a list of threads waiting for memory pool -->
-        <readlist name="PWL" type="os_thread_t" offset="PCB[i].thread_list" next="thread_next" />
+        <readlist name="PWL" type="osRtxThread_t" offset="PCB[i].thread_list" next="thread_next" />
 
         <calc>
           PCB[i].wl_cnt = (PWL._count - k);
@@ -813,7 +920,7 @@
         </calc>
 
         <!-- Create a list of threads waiting for message queue -->
-        <readlist name="QWL" type="os_thread_t" offset="QCB[i].thread_list" next="thread_next" />
+        <readlist name="QWL" type="osRtxThread_t" offset="QCB[i].thread_list" next="thread_next" />
 
         <calc>
           QCB[i].wl_cnt = (QWL._count - k);
@@ -838,7 +945,7 @@
         </list>
 
         <!-- Create a list of enqueued messages -->
-        <readlist name="QML" type="os_message_t" offset="QCB[i].msg_first" next="next" />
+        <readlist name="QML" type="osRtxMessage_t" offset="QCB[i].msg_first" next="next" />
 
         <calc>
           QCB[i].ml_idx = j;
@@ -1148,4 +1255,202 @@
       </out>
     </object>
   </objects>
+
+  <events>
+
+    <group name="RTX5 RTOS">
+      <component name="Memory Events"       brief="RTX Memory"    no="0xF0" prefix="EvrRtx" info="RTX5 RTOS Memory Management Events" />
+      <component name="Kernel Events"       brief="RTX Kernel"    no="0xF1" prefix="EvrRtx" info="RTX5 RTOS Kernel Events" />
+      <component name="Thread Events"       brief="RTX Thread"    no="0xF2" prefix="EvrRtx" info="RTX5 RTOS Thread Events" />
+      <component name="Timer Events"        brief="RTX Timer"     no="0xF3" prefix="EvrRtx" info="RTX5 RTOS Timer Events" />
+      <component name="EventFlags Events"   brief="RTX EvFlags"   no="0xF4" prefix="EvrRtx" info="RTX5 RTOS EventFlags Events" />
+      <component name="Mutex Events"        brief="RTX Mutex"     no="0xF5" prefix="EvrRtx" info="RTX5 RTOS Mutex Events" />
+      <component name="Semaphore Events"    brief="RTX Semaphore" no="0xF6" prefix="EvrRtx" info="RTX5 RTOS Semaphore Events" />
+      <component name="MemoryPool Events"   brief="RTX MemPool"   no="0xF7" prefix="EvrRtx" info="RTX5 RTOS MemoryPool Events" />
+      <component name="MessageQueue Events" brief="RTX MsgQueue"  no="0xF8" prefix="EvrRtx" info="RTX5 RTOS MessageQueue Events" />
+    </group>
+
+    <event id="0xF000 + 0x00" level="Op" property="MemoryInit"       value="mem=%x[val1], size=%d[val2], result=%d[val3]" info=""/>
+    <event id="0xF000 + 0x01" level="Op" property="MemoryAlloc"      value="mem=%x[val1], size=%d[val2], type=%d[val3], block=%x[val4]" info=""/>
+    <event id="0xF000 + 0x02" level="Op" property="MemoryFree"       value="mem=%x[val1], block=%x[val2], result=%d[val3]" info=""/>
+    <event id="0xF000 + 0x03" level="Op" property="MemoryBlockInit"  value="mp_info=%x[val1], block_count=%d[val2], block_size=%d[val3], block_mem=%x[val4]" info=""/>
+    <event id="0xF000 + 0x04" level="Op" property="MemoryBlockAlloc" value="mp_info=%x[val1], block=%x[val2]" info=""/>
+    <event id="0xF000 + 0x05" level="Op" property="MemoryBlockFree"  value="mp_info=%x[val1], block=%x[val2], status=%E[val3, rtx_t:status]" info=""/>
+
+    <event id="0xF100 + 0x00" level="Error"  property="KernelError"               value="status=%E[val1, rtx_t:status]" info="Kernel error occurred."/>
+    <event id="0xF100 + 0x01" level="API"    property="KernelInitialize"          value="" info="osKernelInitialize function was called."/>
+    <event id="0xF100 + 0x02" level="Op"     property="KernelInitializeCompleted" value="" info="Kernel was initialized."/>
+    <event id="0xF100 + 0x03" level="API"    property="KernelGetInfo"             value="version=%x[val1], id_buf=%x[val2], id_size=%d[val3]" info="osKernelGetInfo function was called."/>
+    <event id="0xF100 + 0x04" level="Op"     property="KernelInfoRetrieved"       value="version=%x[val1], id_buf=%x[val2]" info="Kernel information was retrieved."/>
+    <event id="0xF100 + 0x05" level="Detail" property="KernelInfoRetrieved"       value="id_buf=%t[val1]" info="Kernel ID as ASCII string."/>
+    <event id="0xF100 + 0x06" level="API"    property="KernelGetState"            value="state=%E[val1, os_Info:kernel_state]" info="osKernelGetState function was called and state was retrieved."/>
+    <event id="0xF100 + 0x07" level="API"    property="KernelStart"               value="" info="osKernelStart function was called."/>
+    <event id="0xF100 + 0x08" level="Op"     property="KernelStarted"             value="" info="Kernel execution was started."/>
+    <event id="0xF100 + 0x09" level="API"    property="KernelLock"                value="" info="osKernelLock function was called."/>
+    <event id="0xF100 + 0x0A" level="Op"     property="KernelLocked"              value="lock=%d[val1]" info="Kernel was locked."/>
+    <event id="0xF100 + 0x0B" level="API"    property="KernelUnlock"              value="" info="osKernelUnlock function was called."/>
+    <event id="0xF100 + 0x0C" level="Op"     property="KernelUnlocked"            value="lock=%d[val1]" info="Kernel was unlocked."/>
+    <event id="0xF100 + 0x0D" level="API"    property="KernelRestoreLock"         value="lock=%d[val1]" info="osKernelRestoreLock function was called."/>
+    <event id="0xF100 + 0x0E" level="Op"     property="KernelLockRestored"        value="lock=%d[val1]" info="Kernel lock was restored."/>
+    <event id="0xF100 + 0x0F" level="API"    property="KernelSuspend"             value="" info="osKernelSuspend function was called."/>
+    <event id="0xF100 + 0x10" level="Op"     property="KernelSuspended"           value="sleep_ticks=%d[val1]" info="Kernel execution was suspended."/>
+    <event id="0xF100 + 0x11" level="API"    property="KernelResume"              value="sleep_ticks=%d[val1]" info="osKernelResume function was called."/>
+    <event id="0xF100 + 0x12" level="Op"     property="KernelResumed"             value="" info="Kernel execution was resumed."/>
+    <event id="0xF100 + 0x13" level="API"    property="KernelGetTickCount"        value="count=%d[((uint64)val2 &lt;&lt; 32) | val1]" info="osKernelGetTickCount function was called."/>
+    <event id="0xF100 + 0x14" level="API"    property="KernelGetTickFreq"         value="freq=%d[val1]" info="osKernelGetTickFreq function was called."/>
+    <event id="0xF100 + 0x15" level="API"    property="KernelGetSysTimerCount"    value="count=%d[val1]" info="osKernelGetSysTimerCount function was called."/>
+    <event id="0xF100 + 0x16" level="API"    property="KernelGetSysTimerFreq"     value="freq=%d[va1]" info="osKernelGetSysTimerFreq function was called."/>
+
+    <event id="0xF200 + 0x00" level="Error"  property="ThreadError"                 value="thread_id=%x[val1], status=%E[val2, rtx_t:status]" info="Thread error occurred."/>
+    <event id="0xF200 + 0x01" level="API"    property="ThreadNew"                   value="func=%S[val1], argument=%x[val2], attr=%x[val3]" info="osThreadNew function was called."/>
+    <event id="0xF200 + 0x02" level="Detail" property="ThreadNew"                   value="name=%x[val1.name], attr_bits=%x[val1.attr_bits], cb_mem=%x[val1.cb_mem], cb_size=%d[val1.cb_size], stack_mem=%x[val1.stack_mem], stack_size=%d[val1.stack_size], priority=%E[val1.priority, osRtxThread_t:priority]" val1="osThreadAttr_t" info="Attributes structure for thread object."/>
+    <event id="0xF200 + 0x03" level="Op"     property="ThreadCreated"               value="thread_id=%x[val1]" info="Thread object was created."/>
+    <event id="0xF200 + 0x04" level="API"    property="ThreadGetName"               value="thread_id=%x[val1], name=%x[val2]" info="osThreadGetName function was called and object name was retrieved."/>
+    <event id="0xF200 + 0x05" level="Detail" property="ThreadGetName"               value="name=%t[val1]" info="Thread object name as ASCII string."/>
+    <event id="0xF200 + 0x06" level="API"    property="ThreadGetId"                 value="thread_id=%x[val1]" info="osThreadGetId function was called and current running thread id was retrieved."/>
+    <event id="0xF200 + 0x07" level="API"    property="ThreadGetState"              value="thread_id=%x[val1], state=%E[val2, rtx_t:thread_state]" info="osThreadGetState function was called and thread state was retrieved."/>
+    <event id="0xF200 + 0x08" level="API"    property="ThreadGetStackSize"          value="thread_id=%x[val1], stack_size=%d[val2]" info="osThreadGetStackSize function was called and thread stack size was retrieved."/>
+    <event id="0xF200 + 0x09" level="API"    property="ThreadGetStackSpace"         value="thread_id=%x[val1], stack_space=%d[val2]" info="osThreadGetStackSpace function was called and thread stack space was retrieved."/>
+    <event id="0xF200 + 0x0A" level="API"    property="ThreadSetPriority"           value="thread_id=%x[val1], priority=%E[val1, osRtxThread_t:priority]" info="osThreadSetPriority function was called."/>
+    <event id="0xF200 + 0x0B" level="API"    property="ThreadGetPriority"           value="thread_id=%x[val1], priority=%E[val1, osRtxThread_t:priority]" info="osThreadGetPriority function was called and thread priority was retrieved."/>
+    <event id="0xF200 + 0x0C" level="API"    property="ThreadYield"                 value="" info="osThreadYield function was called."/>
+    <event id="0xF200 + 0x0D" level="API"    property="ThreadSuspend"               value="thread_id=%x[val1]" info="osThreadSuspend function was called."/>
+    <event id="0xF200 + 0x0E" level="Op"     property="ThreadSuspended"             value="thread_id=%x[val1]" info="Thread execution was suspended."/>
+    <event id="0xF200 + 0x0F" level="API"    property="ThreadResume"                value="thread_id=%x[val1]" info="osThreadResume function was called."/>
+    <event id="0xF200 + 0x10" level="Op"     property="ThreadResumed"               value="thread_id=%x[val1]" info="Thread execution was resumed."/>
+    <event id="0xF200 + 0x11" level="API"    property="ThreadDetach"                value="thread_id=%x[val1]" info="osThreadDetach function was called."/>
+    <event id="0xF200 + 0x12" level="Op"     property="ThreadDetached"              value="thread_id=%x[val1]" info="Thread was detached."/>
+    <event id="0xF200 + 0x13" level="API"    property="ThreadJoin"                  value="thread_id=%x[val1]" info="osThreadJoin function was called."/>
+    <event id="0xF200 + 0x14" level="Op"     property="ThreadJoinPending"           value="thread_id=%x[val1]" info="Thread join is pending."/>
+    <event id="0xF200 + 0x15" level="Op"     property="ThreadJoined"                value="thread_id=%x[val1]" info="Thread joined."/>
+    <event id="0xF200 + 0x16" level="Op"     property="ThreadBlocked"               value="thread=%x[val1], timeout=%d[val2]" info="Current running thread execution was blocked."/>
+    <event id="0xF200 + 0x17" level="Op"     property="ThreadUnblocked"             value="thread=%x[val1], ret_val=%E[val2, rtx_t:status]" info="Thread execution was unblocked."/>
+    <event id="0xF200 + 0x18" level="Op"     property="ThreadSwitch"                value="thread=%x[val1]" info="Switched execution of the current running thread."/>
+    <event id="0xF200 + 0x19" level="API"    property="ThreadExit"                  value="" info="osThreadExit function was called."/>
+    <event id="0xF200 + 0x1A" level="API"    property="ThreadTerminate"             value="thread_id=%x[val1]" info="osThreadTerminate function was called."/>
+    <event id="0xF200 + 0x1B" level="Op"     property="ThreadDestroyed"             value="thread_id=%x[val1]" info="Thread execution was terminated."/>
+    <event id="0xF200 + 0x1C" level="API"    property="ThreadGetCount"              value="count=%d[val1]" info="osThreadGetCount function was called and number of active threads was retrieved."/>
+    <event id="0xF200 + 0x1D" level="API"    property="ThreadEnumerate"             value="thread_array=%x[val1], array_items=%d[val2], count=%d[val3]" info="osThreadEnumerate function was called and active threads were enumerated."/>
+    <event id="0xF200 + 0x1E" level="API"    property="ThreadFlagsSet"              value="thread_id=%x[val1], flags=%x[val2]" info="osThreadFlagsSet function was called."/>
+    <event id="0xF200 + 0x1F" level="Op"     property="ThreadFlagsSetDone"          value="thread_id=%x[val1], thread_flags=%x[val2]" info="Thread flags were set."/>
+    <event id="0xF200 + 0x20" level="API"    property="ThreadFlagsClear"            value="flags=%x[val1]" info="osThreadFlagsClear function was called."/>
+    <event id="0xF200 + 0x21" level="Op"     property="ThreadFlagsClearDone"        value="thread_flags=%x[val1]" info="Thread flags were cleared."/>
+    <event id="0xF200 + 0x22" level="API"    property="ThreadFlagsGet"              value="thread_flags=%x[val1]" info="osThreadFlagsGet function was called and thread flags were retrieved."/>
+    <event id="0xF200 + 0x23" level="API"    property="ThreadFlagsWait"             value="flags=%x[val1], options=%x[val2], timeout=%d[val3]" info="osThreadFlagsWait function was called."/>
+    <event id="0xF200 + 0x24" level="Op"     property="ThreadFlagsWaitPending"      value="flags=%x[val1], options=%x[val2], timeout=%d[val3]" info="Waiting for thread flags to become signaled."/>
+    <event id="0xF200 + 0x25" level="Op"     property="ThreadFlagsWaitCompleted"    value="flags=%x[val1], options=%x[val2], thread_flags=%x[val3]" info="Wait for thread flags completed."/>
+    <event id="0xF200 + 0x26" level="Op"     property="ThreadFlagsWaitNotCompleted" value="flags=%x[val1], options=%x[val2]" info="Wait for thread flags not completed."/>
+    <event id="0xF200 + 0x27" level="API"    property="Delay"                       value="ticks=%d[val1]" info="osDelay function was called."/>
+    <event id="0xF200 + 0x28" level="API"    property="DelayUntil"                  value="ticks=%d[((uint64)val2 &lt;&lt; 32) | val1]" info="osDelayUntil function was called."/>
+
+    <event id="0xF300 + 0x00" level="Error"  property="TimerError"     value="timer_id=%x[val1], status=%E[val2, rtx_t:status]" info="Timer error occurred."/>
+    <event id="0xF300 + 0x01" level="Op"     property="TimerCallback"  value="func=%S[val1], argument=%x[val2]" info="Timer callback function was called."/>
+    <event id="0xF300 + 0x02" level="API"    property="TimerNew"       value="func=%S[val1], type=%E[val2, osRtxTimer_t:type], argument=%x[val3], attr=%x[val4]" info="osTimerNew function was called."/>
+    <event id="0xF300 + 0x03" level="Detail" property="TimerNew"       value="name=%x[val1.name], attr_bits=%x[val1.attr_bits], cb_mem=%x[val1.cb_mem], cb_size=%d[val1.cb_size]" val1="osTimerAttr_t" info="Attributes structure for timer object."/>
+    <event id="0xF300 + 0x04" level="Op"     property="TimerCreated"   value="timer_id=%x[val1]" info="Timer object was created."/>
+    <event id="0xF300 + 0x05" level="API"    property="TimerGetName"   value="timer_id=%x[val1], name=%x[val2]" info="osTimerGetName function was called and object name was retrieved."/>
+    <event id="0xF300 + 0x06" level="Detail" property="TimerGetName"   value="name=%t[val1]" info="Timer object name as ASCII string."/>
+    <event id="0xF300 + 0x07" level="API"    property="TimerStart"     value="timer_id=%x[val1], ticks=%d[val2]" info="osTimerStart function was called."/>
+    <event id="0xF300 + 0x08" level="Op"     property="TimerStarted"   value="timer_id=%x[val1]" info="Timer execution was started."/>
+    <event id="0xF300 + 0x09" level="API"    property="TimerStop"      value="timer_id=%x[val1]" info="osTimerStop function was called."/>
+    <event id="0xF300 + 0x0A" level="Op"     property="TimerStopped"   value="timer_id=%x[val1]" info="Timer execution was stopped."/>
+    <event id="0xF300 + 0x0B" level="API"    property="TimerIsRunning" value="timer_id=%x[val1], running=%d[val2]" info="osTimerIsRunning function was called and timer running state was retrieved."/>
+    <event id="0xF300 + 0x0C" level="API"    property="TimerDelete"    value="timer_id=%x[val1]" info="osTimerDelete function was called."/>
+    <event id="0xF300 + 0x0D" level="Op"     property="TimerDestroyed" value="timer_id=%x[val1]" info="Timer object was deleted."/>
+
+    <event id="0xF400 + 0x00" level="Error"  property="EventFlagsError"            value="ef_id=%x[val1], status=%E[val2, rtx_t:status]" info="Event flags error occurred."/>
+    <event id="0xF400 + 0x01" level="API"    property="EventFlagsNew"              value="attr=%x[val1]" info="osEventFlagsNew function was called."/>
+    <event id="0xF400 + 0x02" level="Detail" property="EventFlagsNew"              value="name=%x[val1.name], attr_bits=%x[val1.attr_bits], cb_mem=%x[val1.cb_mem], cb_size=%d[val1.cb_size]" val1="osEventFlagsAttr_t" info="Attributes structure for event flags object."/>
+    <event id="0xF400 + 0x03" level="Op"     property="EventFlagsCreated"          value="ef_id=%x[val1]" info="Event flags object was created."/>
+    <event id="0xF400 + 0x04" level="API"    property="EventFlagsGetName"          value="ef_id=%x[val1], name=%x[val2]" info="osEventFlagsGetName function was called and object name was retrieved."/>
+    <event id="0xF400 + 0x05" level="Detail" property="EventFlagsGetName"          value="name=%t[val1]" info="Event flags object name as ASCII string."/>
+    <event id="0xF400 + 0x06" level="API"    property="EventFlagsSet"              value="ef_id=%x[val1], flags=%x[val2]" info="osEventFlagsSet function was called."/>
+    <event id="0xF400 + 0x07" level="Op"     property="EventFlagsSetDone"          value="ef_id=%x[val1], event_flags=%x[val2]" info="Event flags were set."/>
+    <event id="0xF400 + 0x08" level="API"    property="EventFlagsClear"            value="ef_id=%x[val1], flags=%x[val2]" info="osEventFlagsClear function was called."/>
+    <event id="0xF400 + 0x09" level="Op"     property="EventFlagsClearDone"        value="ef_id=%x[val1], event_flags=%x[val2]" info="Event flags were cleared."/>
+    <event id="0xF400 + 0x0A" level="API"    property="EventFlagsGet"              value="ef_id=%x[val1], event_flags=%x[val2]" info="osEventFlagsGet function was called and current event flags were retrieved."/>
+    <event id="0xF400 + 0x0B" level="API"    property="EventFlagsWait"             value="ef_id=%x[val1], flags=%x[val2], options=%x[val3], timeout=%d[val4]" info="osEventFlagsWait function was called."/>
+    <event id="0xF400 + 0x0C" level="Op"     property="EventFlagsWaitPending"      value="ef_id=%x[val1], flags=%x[val2], options=%x[val3], timeout=%d[val4]" info="Event flags wait is pending."/>
+    <event id="0xF400 + 0x0D" level="Op"     property="EventFlagsWaitCompleted"    value="ef_id=%x[val1], flags=%x[val2], options=%x[val3], event_flags=%x[val4]" info="Event flags wait completed."/>
+    <event id="0xF400 + 0x0E" level="Op"     property="EventFlagsWaitNotCompleted" value="ef_id=%x[val1], flags=%x[val2], options=%x[val3]" info="Event flags wait not completed."/>
+    <event id="0xF400 + 0x0F" level="API"    property="EventFlagsDelete"           value="ef_id=%x[val1]" info="osEventFlagsDelete function was called."/>
+    <event id="0xF400 + 0x10" level="Op"     property="EventFlagsDestroyed"        value="ef_id=%x[val1]" info="Event flags object was deleted."/>
+
+    <event id="0xF500 + 0x00" level="Error"  property="MutexError"          value="mutex_id=%x[val1], status=%E[val2, rtx_t:status]" info="Mutex error occurred."/>
+    <event id="0xF500 + 0x01" level="API"    property="MutexNew"            value="attr=%x[val1]" info="osMutexNew function was called"/>
+    <event id="0xF500 + 0x02" level="Detail" property="MutexNew"            value="name=%x[val1.name], attr_bits=%x[val1.attr_bits], cb_mem=%x[val1.cb_mem], cb_size=%d[val1.cb_size]" val1="osMutexAttr_t" info="Attributes structure for mutex object."/>
+    <event id="0xF500 + 0x03" level="Op"     property="MutexCreated"        value="mutex_id=%x[val1]" info="Mutex object was created"/>
+    <event id="0xF500 + 0x04" level="API"    property="MutexGetName"        value="mutex_id=%x[val1], name=%x[val2]" info="osMutexGetName function was called and object name was retrieved."/>
+    <event id="0xF500 + 0x05" level="Detail" property="MutexGetName"        value="name=%t[val1]" info="Mutex object name as ASCII string."/>
+    <event id="0xF500 + 0x06" level="API"    property="MutexAcquire"        value="mutex_id=%x[val1], timeout=%d[val2]" info="osMutexAcquire function was called."/>
+    <event id="0xF500 + 0x07" level="Op"     property="MutexAcquirePending" value="mutex_id=%x[val1], timeout=%d[val2]" info="Mutex object acquire is pending."/>
+    <event id="0xF500 + 0x08" level="Op"     property="MutexAcquired"       value="mutex_id=%x[val1], lock=%d[val2]" info="Mutex object was acquired."/>
+    <event id="0xF500 + 0x09" level="Op"     property="MutexNotAcquired"    value="mutex_id=%x[val1]" info="Mutex object was not acquired."/>
+    <event id="0xF500 + 0x0A" level="API"    property="MutexRelease"        value="mutex_id=%x[val1]" info="osMutexRelease function was called."/>
+    <event id="0xF500 + 0x0B" level="Op"     property="MutexReleased"       value="mutex_id=%x[val1], lock=%d[val2]" info="Mutex object was released."/>
+    <event id="0xF500 + 0x0C" level="API"    property="MutexGetOwner"       value="mutex_id=%x[val1], thread_id=%x[val2]" info="osMutexGetOwner function was called and mutex owner thread was retrieved."/>
+    <event id="0xF500 + 0x0D" level="API"    property="MutexDelete"         value="mutex_id=%x[val1]" info="osMutexDelete function was called."/>
+    <event id="0xF500 + 0x0E" level="Op"     property="MutexDestroyed"      value="mutex_id=%x[val1]" info="Mutex object was deleted."/>
+
+    <event id="0xF600 + 0x00" level="Error"  property="SemaphoreError"          value="semaphore_id=%x[val1], status=%E[val2, rtx_t:status]" info="Semaphore error occurred."/>
+    <event id="0xF600 + 0x01" level="API"    property="SemaphoreNew"            value="max_count=%d[val1], initial_count=%d[val2], attr=%x[val3]" info="osSemaphoreNew function was called."/>
+    <event id="0xF600 + 0x02" level="Detail" property="SemaphoreNew"            value="name=%x[val1.name], attr_bits=%x[val1.attr_bits], cb_mem=%x[val1.cb_mem], cb_size=%d[val1.cb_size]" val1="osSemaphoreAttr_t" info="Attributes structure for semaphore object."/>
+    <event id="0xF600 + 0x03" level="Op"     property="SemaphoreCreated"        value="semaphore_id=%x[val1]" info="Semaphore object was created."/>
+    <event id="0xF600 + 0x04" level="API"    property="SemaphoreGetName"        value="semaphore_id=%x[val1], name=%x[val2]" info="osSemaphoreGetName function was called and object name was retrieved."/>
+    <event id="0xF600 + 0x05" level="Detail" property="SemaphoreGetName"        value="name=%t[val1]" info="Semaphore object name as ASCII string."/>
+    <event id="0xF600 + 0x06" level="API"    property="SemaphoreAcquire"        value="semaphore_id=%x[val1], timeout=%d[val2]" info="osSemaphoreAcquire function was called."/>
+    <event id="0xF600 + 0x07" level="Op"     property="SemaphoreAcquirePending" value="semaphore_id=%x[val1], timeout=%d[val2]" info="Semaphore object acquire is pending."/>
+    <event id="0xF600 + 0x08" level="Op"     property="SemaphoreAcquired"       value="semaphore_id=%x[val1]" info="Semaphore object was acquired."/>
+    <event id="0xF600 + 0x09" level="Op"     property="SemaphoreNotAcquired"    value="semaphore_id=%x[val1]" info="Semaphore object was not acquired."/>
+    <event id="0xF600 + 0x0A" level="API"    property="SemaphoreRelease"        value="semaphore_id=%x[val1]" info="osSemaphoreRelease function was called."/>
+    <event id="0xF600 + 0x0B" level="Op"     property="SemaphoreReleased"       value="semaphore_id=%x[val1]" info="Semaphore object was released."/>
+    <event id="0xF600 + 0x0C" level="API"    property="SemaphoreGetCount"       value="semaphore_id=%x[val1], count=%d[val2]" info="osSemaphoreGetCount function was called and current number of available tokens was retrieved."/>
+    <event id="0xF600 + 0x0D" level="API"    property="SemaphoreDelete"         value="semaphore_id=%x[val1]" info="osSemaphoreDelete function was called."/>
+    <event id="0xF600 + 0x0E" level="Op"     property="SemaphoreDestroyed"      value="semaphore_id=%x[val1]" info="Semaphore object was deleted."/>
+
+    <event id="0xF700 + 0x00" level="Error"  property="MemoryPoolError"        value="mp_id=%x[val1], status=%E[val2, rtx_t:status]" info="Memory pool error occurred."/>
+    <event id="0xF700 + 0x01" level="API"    property="MemoryPoolNew"          value="block_count=%d[val1], block_size=%d[val2], attr=%x[val3]" info="osMemoryPoolNew function was called."/>
+    <event id="0xF700 + 0x02" level="Detail" property="MemoryPoolNew"          value="name=%x[val1.name], attr_bits=%x[val1.attr_bits], cb_mem=%x[val1.cb_mem], cb_size=%d[val1.cb_size], mp_mem=%x[val1.mp_mem], mp_size=%d[val1.mp_size]" val1="osMemoryPoolAttr_t" info="Attributes structure for memory pool object."/>
+    <event id="0xF700 + 0x03" level="Op"     property="MemoryPoolCreated"      value="mp_id=%x[val1]" info="Memory Pool object was created"/>
+    <event id="0xF700 + 0x04" level="API"    property="MemoryPoolGetName"      value="mp_id=%x[val1], name=%x[val2]" info="osMemoryPoolGetName function was called and object name was retrieved."/>"/>
+    <event id="0xF700 + 0x05" level="Detail" property="MemoryPoolGetName"      value="name=%t[val1]" info="Memory pool object name as ASCII string."/>
+    <event id="0xF700 + 0x06" level="API"    property="MemoryPoolAlloc"        value="mp_id=%x[val1], timeout=%d[val2]" info="osMemoryPoolAlloc function was called."/>
+    <event id="0xF700 + 0x07" level="Op"     property="MemoryPoolAllocPending" value="mp_id=%x[val1], timeout=%d[val2]" info="Memory pool allocation is pending."/>
+    <event id="0xF700 + 0x08" level="Op"     property="MemoryPoolAllocated"    value="mp_id=%x[val1], block=%x[val2]" info="Memory pool was allocated."/>
+    <event id="0xF700 + 0x09" level="Op"     property="MemoryPoolAllocFailed"  value="mp_id=%x[val1]" info="Memory pool was not allocated."/>
+    <event id="0xF700 + 0x0A" level="API"    property="MemoryPoolFree"         value="mp_id=%x[val1], block=%x[val2]" info="osMemoryPoolFree function was called."/>
+    <event id="0xF700 + 0x0B" level="Op"     property="MemoryPoolDeallocated"  value="mp_id=%x[val1], block=%x[val2]" info="Memory pool was deallocated."/>
+    <event id="0xF700 + 0x0C" level="Op"     property="MemoryPoolFreeFailed"   value="mp_id=%x[val1], block=%x[val2]" info="Memory pool was not deallocated."/>
+    <event id="0xF700 + 0x0D" level="API"    property="MemoryPoolGetCapacity"  value="mp_id=%x[val1], capacity=%d[val2]" info="osMemoryPoolGetCapacity function was called and maximum number of memory blocks was retrieved."/>
+    <event id="0xF700 + 0x0E" level="API"    property="MemoryPoolGetBlockSize" value="mp_id=%x[val1], block_size=%d[val2]" info="osMemoryPoolGetBlockSize function was called and memory block size was retrieved."/>
+    <event id="0xF700 + 0x0F" level="API"    property="MemoryPoolGetCount"     value="mp_id=%x[val1], count=%d[val2]" info="osMemoryPoolGetCount function was called and number of used memory blocks was retrieved."/>
+    <event id="0xF700 + 0x10" level="API"    property="MemoryPoolGetSpace"     value="mp_id=%x[val1], space=%d[val2]" info="osMemoryPoolGetSpace function was called and number of available memory blocks was retrieved."/>
+    <event id="0xF700 + 0x11" level="API"    property="MemoryPoolDelete"       value="mp_id=%x[val1]" info="osMemoryPoolDelete function was called."/>
+    <event id="0xF700 + 0x12" level="Op"     property="MemoryPoolDestroyed"    value="mp_id=%x[val1]" info="Memory pool object was deleted."/>
+
+    <event id="0xF800 + 0x00" level="Error"  property="MessageQueueError"         value="mq_id=%x[val1], status=%E[val2, rtx_t:status]" info="Message queue error occurred."/>
+    <event id="0xF800 + 0x01" level="API"    property="MessageQueueNew"           value="msg_count=%d[val1], msg_size=%d[val2], attr=%x[val3]" info="osMessageQueueNew function was called."/>
+    <event id="0xF800 + 0x02" level="Detail" property="MessageQueueNew"           value="name=%x[val1.name], attr_bits=%x[val1.attr_bits], cb_mem=%x[val1.cb_mem], cb_size=%d[val1.cb_size], mq_mem=%x[val1.mq_mem], mq_size=%d[val1.mq_size]" val1="osMessageQueueAttr_t" info="Attributes structure for message queue object."/>
+    <event id="0xF800 + 0x03" level="Op"     property="MessageQueueCreated"       value="mq_id=%x[val1]" info="Message Queue object was created"/>
+    <event id="0xF800 + 0x04" level="API"    property="MessageQueueGetName"       value="mq_id=%x[val1], name=%x[val2]" info="osMessageQueueGetName function was called and object name was retrieved."/>
+    <event id="0xF800 + 0x05" level="Detail" property="MessageQueueGetName"       value="name=%t[val1]" info="Message queue object name as ASCII string."/>
+    <event id="0xF800 + 0x06" level="API"    property="MessageQueuePut"           value="mq_id=%x[val1], msg_ptr=%x[val2], msg_prio=%d[val3], timeout=%d[val4]" info="osMessageQueuePut function was called."/>
+    <event id="0xF800 + 0x07" level="Op"     property="MessageQueuePutPending"    value="mq_id=%x[val1], msg_ptr=%x[val2], timeout=%d[val3]" info="Message put is pending."/>
+    <event id="0xF800 + 0x08" level="Op"     property="MessageQueueInsertPending" value="mq_id=%x[val1], msg_ptr=%x[val2]" info="Message insert is pending."/>
+    <event id="0xF800 + 0x09" level="Op"     property="MessageQueueInserted"      value="mq_id=%x[val1], msg_ptr=%x[val2]" info="Message was inserted."/>
+    <event id="0xF800 + 0x0A" level="Op"     property="MessageQueueNotInserted"   value="mq_id=%x[val1], msg_ptr=%x[val2]" info="Message was not inserted"/>
+    <event id="0xF800 + 0x0B" level="API"    property="MessageQueueGet"           value="mq_id=%x[val1], msg_ptr=%x[val2], msg_prio=%d[val3], timeout=%d[val4]" info="osMessageQueueGet function was called."/>
+    <event id="0xF800 + 0x0C" level="Op"     property="MessageQueueGetPending"    value="mq_id=%x[val1], msg_ptr=%x[val2], timeout=%d[val3]" info="Message get is pending."/>
+    <event id="0xF800 + 0x0D" level="Op"     property="MessageQueueRetrieved"     value="mq_id=%x[val1], msg_ptr=%x[val2]" info="Message was retrieved."/>
+    <event id="0xF800 + 0x0E" level="Op"     property="MessageQueueNotRetrieved"  value="mq_id=%x[val1], msg_ptr=%x[val2]" info="Message was not retrieved."/>
+    <event id="0xF800 + 0x0F" level="API"    property="MessageQueueGetCapacity"   value="mq_id=%x[val1], capacity=%d[val2]" info="osMessageQueueGetCapacity function was called and maximum number of messages was retrieved."/>
+    <event id="0xF800 + 0x10" level="API"    property="MessageQueueGetMsgSize"    value="mq_id=%x[val1], msg_size=%d[val2]" info="osMessageQueueGetMsgSize function was called and maximum message size was retrieved."/>
+    <event id="0xF800 + 0x11" level="API"    property="MessageQueueGetCount"      value="mq_id=%x[val1], count=%d[val2]" info="osMessageQueueGetCount function was called and number of queued messages was retrieved."/>
+    <event id="0xF800 + 0x12" level="API"    property="MessageQueueGetSpace"      value="mq_id=%x[val1], space=%d[val2]" info="osMessageQueueGetSpace function was called and number of available message slots was retrieved."/>
+    <event id="0xF800 + 0x13" level="API"    property="MessageQueueReset"         value="mq_id=%x[val1]" info="osMessageQueueReset function was called."/>
+    <event id="0xF800 + 0x14" level="Op"     property="MessageQueueResetDone"     value="mq_id=%x[val1]" info="Message queue was reset."/>
+    <event id="0xF800 + 0x15" level="API"    property="MessageQueueDelete"        value="mq_id=%x[val1]" info="osMessageQueueDelete function was called."/>
+    <event id="0xF800 + 0x16" level="Op"     property="MessageQueueDestroyed"     value="mq_id=%x[val1]" info="Message queue object was deleted."/>
+
+  </events>
 </component_viewer>
diff --git a/CMSIS/RTOS2/RTX/Source/rtx_delay.c b/CMSIS/RTOS2/RTX/Source/rtx_delay.c
index 9edfadc..287e129 100644
--- a/CMSIS/RTOS2/RTX/Source/rtx_delay.c
+++ b/CMSIS/RTOS2/RTX/Source/rtx_delay.c
@@ -52,6 +52,7 @@
 
   ticks -= osRtxInfo.kernel.tick;
   if (ticks >= 0xFFFFFFFFU) {
+    EvrRtxThreadError(NULL, osErrorParameter);
     return osErrorParameter;
   }
   if (ticks == 0U) {
@@ -68,7 +69,9 @@
 
 /// Wait for Timeout (Time Delay).
 osStatus_t osDelay (uint32_t ticks) {
+  EvrRtxThreadDelay(ticks);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxThreadError(NULL, osErrorISR);
     return osErrorISR;
   }
   return __svcDelay(ticks);
@@ -76,7 +79,9 @@
 
 /// Wait until specified time.
 osStatus_t osDelayUntil (uint64_t ticks) {
+  EvrRtxThreadDelayUntil(ticks);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxThreadError(NULL, osErrorISR);
     return osErrorISR;
   }
   return __svcDelayUntil((uint32_t)ticks, (uint32_t)(ticks >> 32));
diff --git a/CMSIS/RTOS2/RTX/Source/rtx_evflags.c b/CMSIS/RTOS2/RTX/Source/rtx_evflags.c
index 4956976..013bf20 100644
--- a/CMSIS/RTOS2/RTX/Source/rtx_evflags.c
+++ b/CMSIS/RTOS2/RTX/Source/rtx_evflags.c
@@ -147,6 +147,7 @@
     if (event_flags > 0) {
       osRtxThreadListRemove(thread);
       osRtxThreadWaitExit(thread, (uint32_t)event_flags, false);
+      EvrRtxEventFlagsWaitCompleted(ef, thread->wait_flags, thread->flags_options, event_flags);
     }
     thread = thread_next;
   }
@@ -177,10 +178,12 @@
     ef   = attr->cb_mem;
     if (ef != NULL) {
       if (((uint32_t)ef & 3U) || (attr->cb_size < sizeof(os_event_flags_t))) {
+        EvrRtxEventFlagsError(NULL, osRtxErrorInvalidControlBlock);
         return NULL;
       }
     } else {
       if (attr->cb_size != 0U) {
+        EvrRtxEventFlagsError(NULL, osRtxErrorInvalidControlBlock);
         return NULL;
       }
     }
@@ -197,6 +200,7 @@
       ef = osRtxMemoryAlloc(osRtxInfo.mem.common, sizeof(os_event_flags_t), 1U);
     }
     if (ef == NULL) {
+      EvrRtxEventFlagsError(NULL, osErrorNoMemory);
       return NULL;
     }
     flags = osRtxFlagSystemObject;
@@ -215,6 +219,8 @@
   // Register post ISR processing function
   osRtxInfo.post_process.event_flags = osRtxEventFlagsPostProcess;
 
+  EvrRtxEventFlagsCreated(ef);
+
   return ef;
 }
 
@@ -225,14 +231,18 @@
 
   // Check parameters
   if ((ef == NULL) || (ef->id != osRtxIdEventFlags)) {
+    EvrRtxEventFlagsGetName(ef, NULL);
     return NULL;
   }
 
   // Check object state
   if (ef->state == osRtxObjectInactive) {
+    EvrRtxEventFlagsGetName(ef, NULL);
     return NULL;
   }
 
+  EvrRtxEventFlagsGetName(ef, ef->name);
+
   return ef->name;
 }
 
@@ -248,11 +258,13 @@
   // Check parameters
   if ((ef == NULL) || (ef->id != osRtxIdEventFlags) ||
       ((uint32_t)flags & ~((1U << osRtxEventFlagsLimit) - 1U))) {
+    EvrRtxEventFlagsError(ef, osErrorParameter);
     return osErrorParameter;
   }
 
   // Check object state
   if (ef->state == osRtxObjectInactive) {
+    EvrRtxEventFlagsError(ef, osErrorResource);
     return osErrorResource;
   }
 
@@ -272,11 +284,14 @@
       }
       osRtxThreadListRemove(thread);
       osRtxThreadWaitExit(thread, (uint32_t)event_flags0, false);
+      EvrRtxEventFlagsWaitCompleted(ef, thread->wait_flags, thread->flags_options, event_flags0);
     }
     thread = thread_next;
   }
   osRtxThreadDispatch(NULL);
 
+  EvrRtxEventFlagsSetDone(ef, event_flags);
+
   return event_flags;
 }
 
@@ -289,17 +304,21 @@
   // Check parameters
   if ((ef == NULL) || (ef->id != osRtxIdEventFlags) ||
       ((uint32_t)flags & ~((1U << osRtxEventFlagsLimit) - 1U))) {
+    EvrRtxEventFlagsError(ef, osErrorParameter);
     return osErrorParameter;
   }
 
   // Check object state
   if (ef->state == osRtxObjectInactive) {
+    EvrRtxEventFlagsError(ef, osErrorResource);
     return osErrorResource;
   }
 
   // Clear Event Flags
   event_flags = EventFlagsClear(ef, flags);
 
+  EvrRtxEventFlagsClearDone(ef, event_flags);
+  
   return event_flags;
 }
 
@@ -310,14 +329,18 @@
 
   // Check parameters
   if ((ef == NULL) || (ef->id != osRtxIdEventFlags)) {
+    EvrRtxEventFlagsGet(ef, 0);
     return 0;
   }
 
   // Check object state
   if (ef->state == osRtxObjectInactive) {
+    EvrRtxEventFlagsGet(ef, 0);
     return 0;
   }
 
+  EvrRtxEventFlagsGet(ef, ef->event_flags);
+
   return ef->event_flags;
 }
 
@@ -330,23 +353,27 @@
 
   running_thread = osRtxThreadGetRunning();
   if (running_thread == NULL) {
+    EvrRtxEventFlagsError(ef, osRtxErrorKernelNotRunning);
     return osError;
   }
 
   // Check parameters
   if ((ef == NULL) || (ef->id != osRtxIdEventFlags) ||
       ((uint32_t)flags & ~((1U << osRtxEventFlagsLimit) - 1U))) {
+    EvrRtxEventFlagsError(ef, osErrorParameter);
     return osErrorParameter;
   }
 
   // Check object state
   if (ef->state == osRtxObjectInactive) {
+    EvrRtxEventFlagsError(ef, osErrorResource);
     return osErrorResource;
   }
 
   // Check Event Flags
   event_flags = EventFlagsCheck(ef, flags, options);
   if (event_flags > 0) {
+    EvrRtxEventFlagsWaitCompleted(ef, flags, options, event_flags);
     return event_flags;
   }
 
@@ -358,9 +385,12 @@
     // Suspend current Thread
     osRtxThreadListPut((os_object_t*)ef, running_thread);
     osRtxThreadWaitEnter(osRtxThreadWaitingEventFlags, timeout);
+    EvrRtxEventFlagsWaitPending(ef, flags, options, timeout);
     return osErrorTimeout;
   }
 
+  EvrRtxEventFlagsWaitNotCompleted(ef, flags, options);
+
   return osErrorResource;
 }
 
@@ -372,11 +402,13 @@
 
   // Check parameters
   if ((ef == NULL) || (ef->id != osRtxIdEventFlags)) {
+    EvrRtxEventFlagsError(ef, osErrorParameter);
     return osErrorParameter;
   }
 
   // Check object state
   if (ef->state == osRtxObjectInactive) {
+    EvrRtxEventFlagsError(ef, osErrorResource);
     return osErrorResource;
   }
 
@@ -401,6 +433,8 @@
     }
   }
 
+  EvrRtxEventFlagsDestroyed(ef);
+
   return osOK;
 }
 
@@ -417,11 +451,13 @@
   // Check parameters
   if ((ef == NULL) || (ef->id != osRtxIdEventFlags) ||
       ((uint32_t)flags & ~((1U << osRtxEventFlagsLimit) - 1U))) {
+    EvrRtxEventFlagsError(ef, osErrorParameter);
     return osErrorParameter;
   }
 
   // Check object state
   if (ef->state == osRtxObjectInactive) {
+    EvrRtxEventFlagsError(ef, osErrorResource);
     return osErrorResource;
   }
 
@@ -431,6 +467,8 @@
   // Register post ISR processing
   osRtxPostProcess((os_object_t *)ef);
 
+  EvrRtxEventFlagsSetDone(ef, event_flags);
+
   return event_flags;
 }
 
@@ -444,20 +482,25 @@
   // Check parameters
   if ((ef == NULL) || (ef->id != osRtxIdEventFlags) || (timeout != 0U) ||
       ((uint32_t)flags & ~((1U << osRtxEventFlagsLimit) - 1U))) {
+    EvrRtxEventFlagsError(ef, osErrorParameter);
     return osErrorParameter;
   }
 
   // Check object state
   if (ef->state == osRtxObjectInactive) {
+    EvrRtxEventFlagsError(ef, osErrorResource);
     return osErrorResource;
   }
 
   // Check Event Flags
   event_flags = EventFlagsCheck(ef, flags, options);
   if (event_flags > 0) {
+    EvrRtxEventFlagsWaitCompleted(ef, flags, options, event_flags);
     return event_flags;
   }
 
+  EvrRtxEventFlagsWaitNotCompleted(ef, flags, options);
+
   return osErrorResource;
 }
 
@@ -466,7 +509,9 @@
 
 /// Create and Initialize an Event Flags object.
 osEventFlagsId_t osEventFlagsNew (const osEventFlagsAttr_t *attr) {
+  EvrRtxEventFlagsNew(attr);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxEventFlagsError(NULL, osErrorISR);
     return NULL;
   }
   return __svcEventFlagsNew(attr);
@@ -475,6 +520,7 @@
 /// Get name of an Event Flags object.
 const char *osEventFlagsGetName (osEventFlagsId_t ef_id) {
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxEventFlagsGetName(ef_id, NULL);
     return NULL;
   }
   return __svcEventFlagsGetName(ef_id);
@@ -482,6 +528,7 @@
 
 /// Set the specified Event Flags.
 int32_t osEventFlagsSet (osEventFlagsId_t ef_id, int32_t flags) {
+  EvrRtxEventFlagsSet(ef_id, flags);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
     return isrRtxEventFlagsSet(ef_id, flags);
   } else {
@@ -491,6 +538,7 @@
 
 /// Clear the specified Event Flags.
 int32_t osEventFlagsClear (osEventFlagsId_t ef_id, int32_t flags) {
+  EvrRtxEventFlagsClear(ef_id, flags);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
     return svcRtxEventFlagsClear(ef_id, flags);
   } else {
@@ -509,6 +557,7 @@
 
 /// Wait for one or more Event Flags to become signaled.
 int32_t osEventFlagsWait (osEventFlagsId_t ef_id, int32_t flags, uint32_t options, uint32_t timeout) {
+  EvrRtxEventFlagsWait(ef_id, flags, options, timeout);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
     return isrRtxEventFlagsWait(ef_id, flags, options, timeout);
   } else {
@@ -518,7 +567,9 @@
 
 /// Delete an Event Flags object.
 osStatus_t osEventFlagsDelete (osEventFlagsId_t ef_id) {
+  EvrRtxEventFlagsDelete(ef_id);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxEventFlagsError(ef_id, osErrorISR);
     return osErrorISR;
   }
   return __svcEventFlagsDelete(ef_id);
diff --git a/CMSIS/RTOS2/RTX/Source/rtx_evr.c b/CMSIS/RTOS2/RTX/Source/rtx_evr.c
new file mode 100644
index 0000000..fde408e
--- /dev/null
+++ b/CMSIS/RTOS2/RTX/Source/rtx_evr.c
@@ -0,0 +1,1995 @@
+/*
+ * Copyright (c) 2013-2016 ARM Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * -----------------------------------------------------------------------------
+ *
+ * Project:     CMSIS-RTOS RTX
+ * Title:       RTX Event Recorder
+ *
+ * -----------------------------------------------------------------------------
+ */
+
+#include <string.h>
+#include "cmsis_compiler.h"
+#include "rtx_evr.h"                    // RTX Event Recorder definitions
+
+#include "RTE_Components.h"
+
+#ifdef RTE_Compiler_EventRecorder
+
+#include "EventRecorder.h"              // Keil::Compiler:Event Recorder
+
+/// RTOS component number
+#define EvtRtxMemoryNo                  (0xF0U)
+#define EvtRtxKernelNo                  (0xF1U)
+#define EvtRtxThreadNo                  (0xF2U)
+#define EvtRtxTimerNo                   (0xF3U)
+#define EvtRtxEventFlagsNo              (0xF4U)
+#define EvtRtxMutexNo                   (0xF5U)
+#define EvtRtxSemaphoreNo               (0xF6U)
+#define EvtRtxMemoryPoolNo              (0xF7U)
+#define EvtRtxMessageQueueNo            (0xF8U)
+
+/// Event IDs for "RTX Memory Management"
+#define EvtRtxMemoryInit                    EventID(EventLevelOp,     EvtRtxMemoryNo, 0x00U)
+#define EvtRtxMemoryAlloc                   EventID(EventLevelOp,     EvtRtxMemoryNo, 0x01U)
+#define EvtRtxMemoryFree                    EventID(EventLevelOp,     EvtRtxMemoryNo, 0x02U)
+#define EvtRtxMemoryBlockInit               EventID(EventLevelOp,     EvtRtxMemoryNo, 0x03U)
+#define EvtRtxMemoryBlockAlloc              EventID(EventLevelOp,     EvtRtxMemoryNo, 0x04U)
+#define EvtRtxMemoryBlockFree               EventID(EventLevelOp,     EvtRtxMemoryNo, 0x05U)
+
+/// Event IDs for "RTX Kernel"
+#define EvtRtxKernelError                   EventID(EventLevelError,  EvtRtxKernelNo, 0x00U)
+#define EvtRtxKernelInitialize              EventID(EventLevelAPI,    EvtRtxKernelNo, 0x01U)
+#define EvtRtxKernelInitializeCompleted     EventID(EventLevelOp,     EvtRtxKernelNo, 0x02U)
+#define EvtRtxKernelGetInfo                 EventID(EventLevelAPI,    EvtRtxKernelNo, 0x03U)
+#define EvtRtxKernelInfoRetrieved           EventID(EventLevelOp,     EvtRtxKernelNo, 0x04U)
+#define EvtRtxKernelInfoRetrieved_Detail    EventID(EventLevelDetail, EvtRtxKernelNo, 0x05U)
+#define EvtRtxKernelGetState                EventID(EventLevelAPI,    EvtRtxKernelNo, 0x06U)
+#define EvtRtxKernelStart                   EventID(EventLevelAPI,    EvtRtxKernelNo, 0x07U)
+#define EvtRtxKernelStarted                 EventID(EventLevelOp,     EvtRtxKernelNo, 0x08U)
+#define EvtRtxKernelLock                    EventID(EventLevelAPI,    EvtRtxKernelNo, 0x09U)
+#define EvtRtxKernelLocked                  EventID(EventLevelOp,     EvtRtxKernelNo, 0x0AU)
+#define EvtRtxKernelUnlock                  EventID(EventLevelAPI,    EvtRtxKernelNo, 0x0BU)
+#define EvtRtxKernelUnlocked                EventID(EventLevelOp,     EvtRtxKernelNo, 0x0CU)
+#define EvtRtxKernelRestoreLock             EventID(EventLevelAPI,    EvtRtxKernelNo, 0x0DU)
+#define EvtRtxKernelLockRestored            EventID(EventLevelOp,     EvtRtxKernelNo, 0x0EU)
+#define EvtRtxKernelSuspend                 EventID(EventLevelAPI,    EvtRtxKernelNo, 0x0FU)
+#define EvtRtxKernelSuspended               EventID(EventLevelOp,     EvtRtxKernelNo, 0x10U)
+#define EvtRtxKernelResume                  EventID(EventLevelAPI,    EvtRtxKernelNo, 0x11U)
+#define EvtRtxKernelResumed                 EventID(EventLevelOp,     EvtRtxKernelNo, 0x12U)
+#define EvtRtxKernelGetTickCount            EventID(EventLevelAPI,    EvtRtxKernelNo, 0x13U)
+#define EvtRtxKernelGetTickFreq             EventID(EventLevelAPI,    EvtRtxKernelNo, 0x14U)
+#define EvtRtxKernelGetSysTimerCount        EventID(EventLevelAPI,    EvtRtxKernelNo, 0x15U)
+#define EvtRtxKernelGetSysTimerFreq         EventID(EventLevelAPI,    EvtRtxKernelNo, 0x16U)
+
+/// Event IDs for "RTX Thread"
+#define EvtRtxThreadError                   EventID(EventLevelError,  EvtRtxThreadNo, 0x00U)
+#define EvtRtxThreadNew                     EventID(EventLevelAPI,    EvtRtxThreadNo, 0x01U)
+#define EvtRtxThreadNew_Detail              EventID(EventLevelDetail, EvtRtxThreadNo, 0x02U)
+#define EvtRtxThreadCreated                 EventID(EventLevelOp,     EvtRtxThreadNo, 0x03U)
+#define EvtRtxThreadGetName                 EventID(EventLevelAPI,    EvtRtxThreadNo, 0x04U)
+#define EvtRtxThreadGetName_Detail          EventID(EventLevelDetail, EvtRtxThreadNo, 0x05U)
+#define EvtRtxThreadGetId                   EventID(EventLevelAPI,    EvtRtxThreadNo, 0x06U)
+#define EvtRtxThreadGetState                EventID(EventLevelAPI,    EvtRtxThreadNo, 0x07U)
+#define EvtRtxThreadGetStackSize            EventID(EventLevelAPI,    EvtRtxThreadNo, 0x08U)
+#define EvtRtxThreadGetStackSpace           EventID(EventLevelAPI,    EvtRtxThreadNo, 0x09U)
+#define EvtRtxThreadSetPriority             EventID(EventLevelAPI,    EvtRtxThreadNo, 0x0AU)
+#define EvtRtxThreadGetPriority             EventID(EventLevelAPI,    EvtRtxThreadNo, 0x0BU)
+#define EvtRtxThreadYield                   EventID(EventLevelAPI,    EvtRtxThreadNo, 0x0CU)
+#define EvtRtxThreadSuspend                 EventID(EventLevelAPI,    EvtRtxThreadNo, 0x0DU)
+#define EvtRtxThreadSuspended               EventID(EventLevelOp,     EvtRtxThreadNo, 0x0EU)
+#define EvtRtxThreadResume                  EventID(EventLevelAPI,    EvtRtxThreadNo, 0x0FU)
+#define EvtRtxThreadResumed                 EventID(EventLevelOp,     EvtRtxThreadNo, 0x10U)
+#define EvtRtxThreadDetach                  EventID(EventLevelAPI,    EvtRtxThreadNo, 0x11U)
+#define EvtRtxThreadDetached                EventID(EventLevelOp,     EvtRtxThreadNo, 0x12U)
+#define EvtRtxThreadJoin                    EventID(EventLevelAPI,    EvtRtxThreadNo, 0x13U)
+#define EvtRtxThreadJoinPending             EventID(EventLevelOp,     EvtRtxThreadNo, 0x14U)
+#define EvtRtxThreadJoined                  EventID(EventLevelOp,     EvtRtxThreadNo, 0x15U)
+#define EvtRtxThreadBlocked                 EventID(EventLevelOp,     EvtRtxThreadNo, 0x16U)
+#define EvtRtxThreadUnblocked               EventID(EventLevelOp,     EvtRtxThreadNo, 0x17U)
+#define EvtRtxThreadSwitch                  EventID(EventLevelOp,     EvtRtxThreadNo, 0x18U)
+#define EvtRtxThreadExit                    EventID(EventLevelAPI,    EvtRtxThreadNo, 0x19U)
+#define EvtRtxThreadTerminate               EventID(EventLevelAPI,    EvtRtxThreadNo, 0x1AU)
+#define EvtRtxThreadDestroyed               EventID(EventLevelOp,     EvtRtxThreadNo, 0x1BU)
+#define EvtRtxThreadGetCount                EventID(EventLevelAPI,    EvtRtxThreadNo, 0x1CU)
+#define EvtRtxThreadEnumerate               EventID(EventLevelAPI,    EvtRtxThreadNo, 0x1DU)
+#define EvtRtxThreadFlagsSet                EventID(EventLevelAPI,    EvtRtxThreadNo, 0x1EU)
+#define EvtRtxThreadFlagsSetDone            EventID(EventLevelOp,     EvtRtxThreadNo, 0x1FU)
+#define EvtRtxThreadFlagsClear              EventID(EventLevelAPI,    EvtRtxThreadNo, 0x20U)
+#define EvtRtxThreadFlagsClearDone          EventID(EventLevelOp,     EvtRtxThreadNo, 0x21U)
+#define EvtRtxThreadFlagsGet                EventID(EventLevelAPI,    EvtRtxThreadNo, 0x22U)
+#define EvtRtxThreadFlagsWait               EventID(EventLevelAPI,    EvtRtxThreadNo, 0x23U)
+#define EvtRtxThreadFlagsWaitPending        EventID(EventLevelOp,     EvtRtxThreadNo, 0x24U)
+#define EvtRtxThreadFlagsWaitCompleted      EventID(EventLevelOp,     EvtRtxThreadNo, 0x25U)
+#define EvtRtxThreadFlagsWaitNotCompleted   EventID(EventLevelOp,     EvtRtxThreadNo, 0x26U)
+#define EvtRtxThreadDelay                   EventID(EventLevelAPI,    EvtRtxThreadNo, 0x27U)
+#define EvtRtxThreadDelayUntil              EventID(EventLevelAPI,    EvtRtxThreadNo, 0x28U)
+
+/// Event IDs for "RTX Timer"
+#define EvtRtxTimerError                    EventID(EventLevelError,  EvtRtxTimerNo, 0x00U)
+#define EvtRtxTimerCallback                 EventID(EventLevelOp,     EvtRtxTimerNo, 0x01U)
+#define EvtRtxTimerNew                      EventID(EventLevelAPI,    EvtRtxTimerNo, 0x02U)
+#define EvtRtxTimerNew_Detail               EventID(EventLevelDetail, EvtRtxTimerNo, 0x03U)
+#define EvtRtxTimerCreated                  EventID(EventLevelOp,     EvtRtxTimerNo, 0x04U)
+#define EvtRtxTimerGetName                  EventID(EventLevelAPI,    EvtRtxTimerNo, 0x05U)
+#define EvtRtxTimerGetName_Detail           EventID(EventLevelDetail, EvtRtxTimerNo, 0x06U)
+#define EvtRtxTimerStart                    EventID(EventLevelAPI,    EvtRtxTimerNo, 0x07U)
+#define EvtRtxTimerStarted                  EventID(EventLevelOp,     EvtRtxTimerNo, 0x08U)
+#define EvtRtxTimerStop                     EventID(EventLevelAPI,    EvtRtxTimerNo, 0x09U)
+#define EvtRtxTimerStopped                  EventID(EventLevelOp,     EvtRtxTimerNo, 0x0AU)
+#define EvtRtxTimerIsRunning                EventID(EventLevelAPI,    EvtRtxTimerNo, 0x0BU)
+#define EvtRtxTimerDelete                   EventID(EventLevelAPI,    EvtRtxTimerNo, 0x0CU)
+#define EvtRtxTimerDestroyed                EventID(EventLevelOp,     EvtRtxTimerNo, 0x0DU)
+
+/// Event IDs for "RTX Event Flags"
+#define EvtRtxEventFlagsError               EventID(EventLevelError,  EvtRtxEventFlagsNo, 0x00U)
+#define EvtRtxEventFlagsNew                 EventID(EventLevelAPI,    EvtRtxEventFlagsNo, 0x01U)
+#define EvtRtxEventFlagsNew_Detail          EventID(EventLevelDetail, EvtRtxEventFlagsNo, 0x02U)
+#define EvtRtxEventFlagsCreated             EventID(EventLevelOp,     EvtRtxEventFlagsNo, 0x03U)
+#define EvtRtxEventFlagsGetName             EventID(EventLevelAPI,    EvtRtxEventFlagsNo, 0x04U)
+#define EvtRtxEventFlagsGetName_Detail      EventID(EventLevelDetail, EvtRtxEventFlagsNo, 0x05U)
+#define EvtRtxEventFlagsSet                 EventID(EventLevelAPI,    EvtRtxEventFlagsNo, 0x06U)
+#define EvtRtxEventFlagsSetDone             EventID(EventLevelOp,     EvtRtxEventFlagsNo, 0x07U)
+#define EvtRtxEventFlagsClear               EventID(EventLevelAPI,    EvtRtxEventFlagsNo, 0x08U)
+#define EvtRtxEventFlagsClearDone           EventID(EventLevelOp,     EvtRtxEventFlagsNo, 0x09U)
+#define EvtRtxEventFlagsGet                 EventID(EventLevelAPI,    EvtRtxEventFlagsNo, 0x0AU)
+#define EvtRtxEventFlagsWait                EventID(EventLevelAPI,    EvtRtxEventFlagsNo, 0x0BU)
+#define EvtRtxEventFlagsWaitPending         EventID(EventLevelOp,     EvtRtxEventFlagsNo, 0x0CU)
+#define EvtRtxEventFlagsWaitCompleted       EventID(EventLevelOp,     EvtRtxEventFlagsNo, 0x0DU)
+#define EvtRtxEventFlagsWaitNotCompleted    EventID(EventLevelOp,     EvtRtxEventFlagsNo, 0x0EU)
+#define EvtRtxEventFlagsDelete              EventID(EventLevelAPI,    EvtRtxEventFlagsNo, 0x0FU)
+#define EvtRtxEventFlagsDestroyed           EventID(EventLevelOp,     EvtRtxEventFlagsNo, 0x10U)
+
+/// Event IDs for "RTX Mutex"
+#define EvtRtxMutexError                    EventID(EventLevelError,  EvtRtxMutexNo, 0x00U)
+#define EvtRtxMutexNew                      EventID(EventLevelAPI,    EvtRtxMutexNo, 0x01U)
+#define EvtRtxMutexNew_Detail               EventID(EventLevelDetail, EvtRtxMutexNo, 0x02U)
+#define EvtRtxMutexCreated                  EventID(EventLevelOp,     EvtRtxMutexNo, 0x03U)
+#define EvtRtxMutexGetName                  EventID(EventLevelAPI,    EvtRtxMutexNo, 0x04U)
+#define EvtRtxMutexGetName_Detail           EventID(EventLevelDetail, EvtRtxMutexNo, 0x05U)
+#define EvtRtxMutexAcquire                  EventID(EventLevelAPI,    EvtRtxMutexNo, 0x06U)
+#define EvtRtxMutexAcquirePending           EventID(EventLevelError,  EvtRtxMutexNo, 0x07U)
+#define EvtRtxMutexAcquired                 EventID(EventLevelOp,     EvtRtxMutexNo, 0x08U)
+#define EvtRtxMutexNotAcquired              EventID(EventLevelOp,     EvtRtxMutexNo, 0x09U)
+#define EvtRtxMutexRelease                  EventID(EventLevelAPI,    EvtRtxMutexNo, 0x0AU)
+#define EvtRtxMutexReleased                 EventID(EventLevelOp,     EvtRtxMutexNo, 0x0BU)
+#define EvtRtxMutexGetOwner                 EventID(EventLevelAPI,    EvtRtxMutexNo, 0x0CU)
+#define EvtRtxMutexDelete                   EventID(EventLevelAPI,    EvtRtxMutexNo, 0x0DU)
+#define EvtRtxMutexDestroyed                EventID(EventLevelOp,     EvtRtxMutexNo, 0x0EU)
+
+/// Event IDs for "RTX Semaphore"
+#define EvtRtxSemaphoreError                EventID(EventLevelError,  EvtRtxSemaphoreNo, 0x00U)
+#define EvtRtxSemaphoreNew                  EventID(EventLevelAPI,    EvtRtxSemaphoreNo, 0x01U)
+#define EvtRtxSemaphoreNew_Detail           EventID(EventLevelDetail, EvtRtxSemaphoreNo, 0x02U)
+#define EvtRtxSemaphoreCreated              EventID(EventLevelOp,     EvtRtxSemaphoreNo, 0x03U)
+#define EvtRtxSemaphoreGetName              EventID(EventLevelAPI,    EvtRtxSemaphoreNo, 0x04U)
+#define EvtRtxSemaphoreGetName_Detail       EventID(EventLevelDetail, EvtRtxSemaphoreNo, 0x05U)
+#define EvtRtxSemaphoreAcquire              EventID(EventLevelAPI,    EvtRtxSemaphoreNo, 0x06U)
+#define EvtRtxSemaphoreAcquirePending       EventID(EventLevelOp,     EvtRtxSemaphoreNo, 0x07U)
+#define EvtRtxSemaphoreAcquired             EventID(EventLevelOp,     EvtRtxSemaphoreNo, 0x08U)
+#define EvtRtxSemaphoreNotAcquired          EventID(EventLevelOp,     EvtRtxSemaphoreNo, 0x09U)
+#define EvtRtxSemaphoreRelease              EventID(EventLevelAPI,    EvtRtxSemaphoreNo, 0x0AU)
+#define EvtRtxSemaphoreReleased             EventID(EventLevelOp,     EvtRtxSemaphoreNo, 0x0BU)
+#define EvtRtxSemaphoreGetCount             EventID(EventLevelAPI,    EvtRtxSemaphoreNo, 0x0CU)
+#define EvtRtxSemaphoreDelete               EventID(EventLevelAPI,    EvtRtxSemaphoreNo, 0x0DU)
+#define EvtRtxSemaphoreDestroyed            EventID(EventLevelOp,     EvtRtxSemaphoreNo, 0x0EU)
+
+/// Event IDs for "RTX Memory Pool"
+#define EvtRtxMemoryPoolError               EventID(EventLevelError,  EvtRtxMemoryPoolNo, 0x00U)
+#define EvtRtxMemoryPoolNew                 EventID(EventLevelAPI,    EvtRtxMemoryPoolNo, 0x01U)
+#define EvtRtxMemoryPoolNew_Detail          EventID(EventLevelDetail, EvtRtxMemoryPoolNo, 0x02U)
+#define EvtRtxMemoryPoolCreated             EventID(EventLevelOp,     EvtRtxMemoryPoolNo, 0x03U)
+#define EvtRtxMemoryPoolGetName             EventID(EventLevelAPI,    EvtRtxMemoryPoolNo, 0x04U)
+#define EvtRtxMemoryPoolGetName_Detail      EventID(EventLevelDetail, EvtRtxMemoryPoolNo, 0x05U)
+#define EvtRtxMemoryPoolAlloc               EventID(EventLevelAPI,    EvtRtxMemoryPoolNo, 0x06U)
+#define EvtRtxMemoryPoolAllocPending        EventID(EventLevelOp,     EvtRtxMemoryPoolNo, 0x07U)
+#define EvtRtxMemoryPoolAllocated           EventID(EventLevelOp,     EvtRtxMemoryPoolNo, 0x08U)
+#define EvtRtxMemoryPoolAllocFailed         EventID(EventLevelOp,     EvtRtxMemoryPoolNo, 0x09U)
+#define EvtRtxMemoryPoolFree                EventID(EventLevelAPI,    EvtRtxMemoryPoolNo, 0x0AU)
+#define EvtRtxMemoryPoolDeallocated         EventID(EventLevelOp,     EvtRtxMemoryPoolNo, 0x0BU)
+#define EvtRtxMemoryPoolFreeFailed          EventID(EventLevelOp,     EvtRtxMemoryPoolNo, 0x0CU)
+#define EvtRtxMemoryPoolGetCapacity         EventID(EventLevelAPI,    EvtRtxMemoryPoolNo, 0x0DU)
+#define EvtRtxMemoryPoolGetBlockSize        EventID(EventLevelAPI,    EvtRtxMemoryPoolNo, 0x0EU)
+#define EvtRtxMemoryPoolGetCount            EventID(EventLevelAPI,    EvtRtxMemoryPoolNo, 0x0FU)
+#define EvtRtxMemoryPoolGetSpace            EventID(EventLevelAPI,    EvtRtxMemoryPoolNo, 0x10U)
+#define EvtRtxMemoryPoolDelete              EventID(EventLevelAPI,    EvtRtxMemoryPoolNo, 0x11U)
+#define EvtRtxMemoryPoolDestroyed           EventID(EventLevelOp,     EvtRtxMemoryPoolNo, 0x12U)
+
+/// Event IDs for "RTX Message Queue"
+#define EvtRtxMessageQueueError             EventID(EventLevelError,  EvtRtxMessageQueueNo, 0x00U)
+#define EvtRtxMessageQueueNew               EventID(EventLevelAPI,    EvtRtxMessageQueueNo, 0x01U)
+#define EvtRtxMessageQueueNew_Detail        EventID(EventLevelDetail, EvtRtxMessageQueueNo, 0x02U)
+#define EvtRtxMessageQueueCreated           EventID(EventLevelOp,     EvtRtxMessageQueueNo, 0x03U)
+#define EvtRtxMessageQueueGetName           EventID(EventLevelAPI,    EvtRtxMessageQueueNo, 0x04U)
+#define EvtRtxMessageQueueGetName_Detail    EventID(EventLevelDetail, EvtRtxMessageQueueNo, 0x05U)
+#define EvtRtxMessageQueuePut               EventID(EventLevelAPI,    EvtRtxMessageQueueNo, 0x06U)
+#define EvtRtxMessageQueuePutPending        EventID(EventLevelOp,     EvtRtxMessageQueueNo, 0x07U)
+#define EvtRtxMessageQueueInsertPending     EventID(EventLevelOp,     EvtRtxMessageQueueNo, 0x08U)
+#define EvtRtxMessageQueueInserted          EventID(EventLevelOp,     EvtRtxMessageQueueNo, 0x09U)
+#define EvtRtxMessageQueueNotInserted       EventID(EventLevelOp,     EvtRtxMessageQueueNo, 0x0AU)
+#define EvtRtxMessageQueueGet               EventID(EventLevelAPI,    EvtRtxMessageQueueNo, 0x0BU)
+#define EvtRtxMessageQueueGetPending        EventID(EventLevelOp,     EvtRtxMessageQueueNo, 0x0CU)
+#define EvtRtxMessageQueueRetrieved         EventID(EventLevelOp,     EvtRtxMessageQueueNo, 0x0DU)
+#define EvtRtxMessageQueueNotRetrieved      EventID(EventLevelOp,     EvtRtxMessageQueueNo, 0x0EU)
+#define EvtRtxMessageQueueGetCapacity       EventID(EventLevelAPI,    EvtRtxMessageQueueNo, 0x0FU)
+#define EvtRtxMessageQueueGetMsgSize        EventID(EventLevelAPI,    EvtRtxMessageQueueNo, 0x10U)
+#define EvtRtxMessageQueueGetCount          EventID(EventLevelAPI,    EvtRtxMessageQueueNo, 0x11U)
+#define EvtRtxMessageQueueGetSpace          EventID(EventLevelAPI,    EvtRtxMessageQueueNo, 0x12U)
+#define EvtRtxMessageQueueReset             EventID(EventLevelAPI,    EvtRtxMessageQueueNo, 0x13U)
+#define EvtRtxMessageQueueResetDone         EventID(EventLevelOp,     EvtRtxMessageQueueNo, 0x14U)
+#define EvtRtxMessageQueueDelete            EventID(EventLevelAPI,    EvtRtxMessageQueueNo, 0x15U)
+#define EvtRtxMessageQueueDestroyed         EventID(EventLevelOp,     EvtRtxMessageQueueNo, 0x16U)
+
+#endif  // RTE_Compiler_EventRecorder
+
+
+//  ==== Memory Events ====
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMORY != 0) && !defined(EVR_RTX_MEMORY_INIT_DISABLE))
+__WEAK void EvrRtxMemoryInit (void *mem, uint32_t size, uint32_t result) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord4(EvtRtxMemoryInit, (uint32_t)mem, size, result, 0U);
+#else
+  (void)mem;
+  (void)size;
+  (void)result;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMORY != 0) && !defined(EVR_RTX_MEMORY_ALLOC_DISABLE))
+__WEAK void EvrRtxMemoryAlloc (void *mem, uint32_t size, uint32_t type, void *block) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord4(EvtRtxMemoryAlloc, (uint32_t)mem, size, type, (uint32_t)block);
+#else
+  (void)mem;
+  (void)size;
+  (void)type;
+  (void)block;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMORY != 0) && !defined(EVR_RTX_MEMORY_FREE_DISABLE))
+__WEAK void EvrRtxMemoryFree (void *mem, void *block, uint32_t result) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord4(EvtRtxMemoryFree, (uint32_t)mem, (uint32_t)block, result, 0U);
+#else
+  (void)mem;
+  (void)block;
+  (void)result;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMORY != 0) && !defined(EVR_RTX_MEMORY_BLOCK_INIT_DISABLE))
+__WEAK void EvrRtxMemoryBlockInit (osRtxMpInfo_t *mp_info, uint32_t block_count, uint32_t block_size, void *block_mem) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord4(EvtRtxMemoryBlockInit, (uint32_t)mp_info, block_count, block_size, (uint32_t)block_mem);
+#else
+  (void)mp_info;
+  (void)block_count;
+  (void)block_size;
+  (void)block_mem;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMORY != 0) && !defined(EVR_RTX_MEMORY_BLOCK_ALLOC_DISABLE))
+__WEAK void EvrRtxMemoryBlockAlloc (osRtxMpInfo_t *mp_info, void *block) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMemoryBlockAlloc, (uint32_t)mp_info, (uint32_t)block);
+#else
+  (void)mp_info;
+  (void)block;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMORY != 0) && !defined(EVR_RTX_MEMORY_BLOCK_FREE_DISABLE))
+__WEAK void EvrRtxMemoryBlockFree (osRtxMpInfo_t *mp_info, void *block, int32_t status) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord4(EvtRtxMemoryBlockFree, (uint32_t)mp_info, (uint32_t)block, (uint32_t)status, 0U);
+#else
+  (void)mp_info;
+  (void)block;
+  (void)status;
+#endif
+}
+#endif
+
+
+//  ==== Kernel Events ====
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_ERROR_DISABLE))
+__WEAK void EvrRtxKernelError (int32_t status) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxKernelError, (uint32_t)status, 0U); 
+#else
+  (void)status;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_INITIALIZE_DISABLE))
+__WEAK void EvrRtxKernelInitialize (void) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxKernelInitialize, 0U, 0U);
+#else
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_INITIALIZE_COMPLETED_DISABLE))
+__WEAK void EvrRtxKernelInitializeCompleted (void) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxKernelInitializeCompleted, 0U, 0U);
+#else
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_GET_INFO_DISABLE))
+__WEAK void EvrRtxKernelGetInfo (osVersion_t *version, char *id_buf, uint32_t id_size) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord4(EvtRtxKernelGetInfo, (uint32_t)version, (uint32_t)id_buf, id_size, 0U);
+#else
+  (void)version;
+  (void)id_buf;
+  (void)id_size;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_INFO_RETRIEVED_DISABLE))
+__WEAK void EvrRtxKernelInfoRetrieved (osVersion_t *version, char *id_buf) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxKernelInfoRetrieved, (uint32_t)version, (uint32_t)id_buf);
+  if (id_buf != NULL) {
+    EventRecordData(EvtRtxKernelInfoRetrieved_Detail, id_buf, strlen(id_buf));
+  }
+#else
+  (void)version;
+  (void)id_buf;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_GET_STATE_DISABLE))
+__WEAK void EvrRtxKernelGetState (osKernelState_t state) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxKernelGetState, (uint32_t)state, 0U);
+#else
+  (void)state;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_START_DISABLE))
+__WEAK void EvrRtxKernelStart (void) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxKernelStart, 0U, 0U);
+#else
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_STARTED_DISABLE))
+__WEAK void EvrRtxKernelStarted (void) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxKernelStarted, 0U, 0U);
+#else
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_LOCK_DISABLE))
+__WEAK void EvrRtxKernelLock (void) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxKernelLock, 0U, 0U);
+#else
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_LOCKED_DISABLE))
+__WEAK void EvrRtxKernelLocked (int32_t lock) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxKernelLocked, (uint32_t)lock, 0U);
+#else
+  (void)lock;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_UNLOCK_DISABLE))
+__WEAK void EvrRtxKernelUnlock (void) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxKernelUnlock, 0U, 0U);
+#else
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_UNLOCKED_DISABLE))
+__WEAK void EvrRtxKernelUnlocked (int32_t lock) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxKernelUnlocked, (uint32_t)lock, 0U);
+#else
+  (void)lock;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_RESTORE_LOCK_DISABLE))
+__WEAK void EvrRtxKernelRestoreLock (int32_t lock) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxKernelRestoreLock, (uint32_t)lock, 0U);
+#else
+  (void)lock;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_LOCK_RESTORED_DISABLE))
+__WEAK void EvrRtxKernelLockRestored (int32_t lock) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxKernelLockRestored, (uint32_t)lock, 0U);
+#else
+  (void)lock;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_SUSPEND_DISABLE))
+__WEAK void EvrRtxKernelSuspend (void) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxKernelSuspend, 0U, 0U);
+#else
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_SUSPENDED_DISABLE))
+__WEAK void EvrRtxKernelSuspended (uint32_t sleep_ticks) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxKernelSuspended, sleep_ticks, 0U);
+#else
+  (void)sleep_ticks;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_RESUME_DISABLE))
+__WEAK void EvrRtxKernelResume (uint32_t sleep_ticks) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxKernelResume, sleep_ticks, 0U);
+#else
+  (void)sleep_ticks;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_RESUMED_DISABLE))
+__WEAK void EvrRtxKernelResumed (void) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxKernelResumed, 0U, 0U);
+#else
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_GET_TICK_COUNT_DISABLE))
+__WEAK void EvrRtxKernelGetTickCount (uint64_t count) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxKernelGetTickCount, (uint32_t)count, (uint32_t)(count>>32));
+#else
+  (void)count;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_GET_TICK_FREQ_DISABLE))
+__WEAK void EvrRtxKernelGetTickFreq (uint32_t freq) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxKernelGetTickFreq, freq, 0U);
+#else
+  (void)freq;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_GET_SYS_TIMER_COUNT_DISABLE))
+__WEAK void EvrRtxKernelGetSysTimerCount (uint32_t count) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxKernelGetSysTimerCount, count, 0U);
+#else
+  (void)count;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_GET_SYS_TIMER_FREQ_DISABLE))
+__WEAK void EvrRtxKernelGetSysTimerFreq (uint32_t freq) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxKernelGetSysTimerFreq, freq, 0U);
+#else
+  (void)freq;
+#endif
+}
+#endif
+
+
+//  ==== Thread Events ====
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_ERROR_DISABLE))
+__WEAK void EvrRtxThreadError (osThreadId_t thread_id, int32_t status) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxThreadError, (uint32_t)thread_id, (uint32_t)status);
+#else
+  (void)thread_id;
+  (void)status;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_NEW_DISABLE))
+__WEAK void EvrRtxThreadNew (osThreadFunc_t func, void *argument, const osThreadAttr_t *attr) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord4(EvtRtxThreadNew, (uint32_t)func, (uint32_t)argument, (uint32_t)attr, 0U);
+  if (attr != NULL) {
+    EventRecordData(EvtRtxThreadNew_Detail, attr, sizeof (osThreadAttr_t));
+  }
+#else
+  (void)func;
+  (void)argument;
+  (void)attr;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_CREATED_DISABLE))
+__WEAK void EvrRtxThreadCreated (osThreadId_t thread_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxThreadCreated, (uint32_t)thread_id, 0U);
+#else
+  (void)thread_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_GET_NAME_DISABLE))
+__WEAK void EvrRtxThreadGetName (osThreadId_t thread_id, const char *name) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxThreadGetName, (uint32_t)thread_id, (uint32_t)name);
+  if (name != NULL) {
+    EventRecordData(EvtRtxThreadGetName_Detail, name, strlen(name));
+  }
+#else
+  (void)thread_id;
+  (void)name;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_GET_ID_DISABLE))
+__WEAK void EvrRtxThreadGetId (osThreadId_t thread_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxThreadGetId, (uint32_t)thread_id, 0U);
+#else
+  (void)thread_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_GET_STATE_DISABLE))
+__WEAK void EvrRtxThreadGetState (osThreadId_t thread_id, osThreadState_t state) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxThreadGetState, (uint32_t)thread_id, (uint32_t)state);
+#else
+  (void)thread_id;
+  (void)state;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_GET_STACK_SIZE_DISABLE))
+__WEAK void EvrRtxThreadGetStackSize (osThreadId_t thread_id, uint32_t stack_size) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxThreadGetStackSize, (uint32_t)thread_id, stack_size);
+#else
+  (void)thread_id;
+  (void)stack_size;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_GET_STACK_SPACE_DISABLE))
+__WEAK void EvrRtxThreadGetStackSpace (osThreadId_t thread_id, uint32_t stack_space) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxThreadGetStackSpace, (uint32_t)thread_id, stack_space);
+#else
+  (void)thread_id;
+  (void)stack_space;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_SET_PRIORITY_DISABLE))
+__WEAK void EvrRtxThreadSetPriority (osThreadId_t thread_id, osPriority_t priority) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxThreadSetPriority, (uint32_t)thread_id, (uint32_t)priority);
+#else
+  (void)thread_id;
+  (void)priority;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_GET_PRIORITY_DISABLE))
+__WEAK void EvrRtxThreadGetPriority (osThreadId_t thread_id, osPriority_t priority) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxThreadGetPriority, (uint32_t)thread_id, (uint32_t)priority);
+#else
+  (void)thread_id;
+  (void)priority;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_YIELD_DISABLE))
+__WEAK void EvrRtxThreadYield (void) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxThreadYield, 0U, 0U);
+#else
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_SUSPEND_DISABLE))
+__WEAK void EvrRtxThreadSuspend (osThreadId_t thread_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxThreadSuspend, (uint32_t)thread_id, 0U);
+#else
+  (void)thread_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_SUSPENDED_DISABLE))
+__WEAK void EvrRtxThreadSuspended (osThreadId_t thread_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxThreadSuspended, (uint32_t)thread_id, 0U);
+#else
+  (void)thread_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_RESUME_DISABLE))
+__WEAK void EvrRtxThreadResume (osThreadId_t thread_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxThreadResume, (uint32_t)thread_id, 0U);
+#else
+  (void)thread_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_RESUMED_DISABLE))
+__WEAK void EvrRtxThreadResumed (osThreadId_t thread_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxThreadResumed, (uint32_t)thread_id, 0U);
+#else
+  (void)thread_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_DETACH_DISABLE))
+__WEAK void EvrRtxThreadDetach (osThreadId_t thread_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxThreadDetach, (uint32_t)thread_id, 0U);
+#else
+  (void)thread_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_DETACHED_DISABLE))
+__WEAK void EvrRtxThreadDetached (osThreadId_t thread_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxThreadDetached, (uint32_t)thread_id, 0U);
+#else
+  (void)thread_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_JOIN_DISABLE))
+__WEAK void EvrRtxThreadJoin (osThreadId_t thread_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxThreadJoin, (uint32_t)thread_id, 0U);
+#else
+  (void)thread_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_JOIN_PENDING_DISABLE))
+__WEAK void EvrRtxThreadJoinPending (osThreadId_t thread_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxThreadJoinPending, (uint32_t)thread_id, 0U);
+#else
+  (void)thread_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_JOINED_DISABLE))
+__WEAK void EvrRtxThreadJoined (osThreadId_t thread_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxThreadJoined, (uint32_t)thread_id, 0U);
+#else
+  (void)thread_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_BLOCKED_DISABLE))
+__WEAK void EvrRtxThreadBlocked (osThreadId_t thread_id, uint32_t timeout) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxThreadBlocked, (uint32_t)thread_id, timeout);
+#else
+  (void)thread_id;
+  (void)timeout;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_UNBLOCKED_DISABLE))
+__WEAK void EvrRtxThreadUnblocked (osThreadId_t thread_id, uint32_t ret_val) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxThreadUnblocked, (uint32_t)thread_id, ret_val);
+#else
+  (void)thread_id;
+  (void)ret_val;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_SWITCH_DISABLE))
+__WEAK void EvrRtxThreadSwitch (osThreadId_t thread_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxThreadSwitch, (uint32_t)thread_id, 0U);
+#else
+  (void)thread_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_EXIT_DISABLE))
+__WEAK void EvrRtxThreadExit (void) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxThreadExit, 0U, 0U);
+#else
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_TERMINATE_DISABLE))
+__WEAK void EvrRtxThreadTerminate (osThreadId_t thread_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxThreadTerminate, (uint32_t)thread_id, 0U);
+#else
+  (void)thread_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_DESTROYED_DISABLE))
+__WEAK void EvrRtxThreadDestroyed (osThreadId_t thread_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxThreadDestroyed, (uint32_t)thread_id, 0U);
+#else
+  (void)thread_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_GET_COUNT_DISABLE))
+__WEAK void EvrRtxThreadGetCount (uint32_t count) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxThreadGetCount, count, 0U);
+#else
+  (void)count;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_ENUMERATE_DISABLE))
+__WEAK void EvrRtxThreadEnumerate (osThreadId_t *thread_array, uint32_t array_items, uint32_t count) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord4(EvtRtxThreadEnumerate, (uint32_t)thread_array, array_items, count, 0U);
+#else
+  (void)thread_array;
+  (void)array_items;
+  (void)count;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_FLAGS_SET_DISABLE))
+__WEAK void EvrRtxThreadFlagsSet (osThreadId_t thread_id, int32_t flags) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxThreadFlagsSet, (uint32_t)thread_id, (uint32_t)flags);
+#else
+  (void)thread_id;
+  (void)flags;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_FLAGS_SET_DONE_DISABLE))
+__WEAK void EvrRtxThreadFlagsSetDone (osThreadId_t thread_id, int32_t thread_flags) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxThreadFlagsSetDone, (uint32_t)thread_id, (uint32_t)thread_flags);
+#else
+  (void)thread_id;
+  (void)thread_flags;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_FLAGS_CLEAR_DISABLE))
+__WEAK void EvrRtxThreadFlagsClear (int32_t flags) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxThreadFlagsClear, (uint32_t)flags, 0U);
+#else
+  (void)flags;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_FLAGS_CLEAR_DONE_DISABLE))
+__WEAK void EvrRtxThreadFlagsClearDone (int32_t thread_flags) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxThreadFlagsClearDone, (uint32_t)thread_flags, 0U);
+#else
+  (void)thread_flags;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_FLAGS_GET_DISABLE))
+__WEAK void EvrRtxThreadFlagsGet (int32_t thread_flags) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxThreadFlagsGet, (uint32_t)thread_flags, 0U);
+#else
+  (void)thread_flags;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_FLAGS_WAIT_DISABLE))
+__WEAK void EvrRtxThreadFlagsWait (int32_t flags, uint32_t options, uint32_t timeout) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord4(EvtRtxThreadFlagsWait, (uint32_t)flags, options, timeout, 0U);
+#else
+  (void)flags;
+  (void)options;
+  (void)timeout;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_FLAGS_WAIT_PENDING_DISABLE))
+__WEAK void EvrRtxThreadFlagsWaitPending (int32_t flags, uint32_t options, uint32_t timeout) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord4(EvtRtxThreadFlagsWaitPending, (uint32_t)flags, options, timeout, 0U);
+#else
+  (void)flags;
+  (void)options;
+  (void)timeout;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_FLAGS_WAIT_COMPLETED_DISABLE))
+__WEAK void EvrRtxThreadFlagsWaitCompleted (int32_t flags, uint32_t options, int32_t thread_flags) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord4(EvtRtxThreadFlagsWaitCompleted, (uint32_t)flags, options, (uint32_t)thread_flags, 0U);
+#else
+  (void)flags;
+  (void)options;
+  (void)thread_flags;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_FLAGS_WAIT_NOT_COMPLETED_DISABLE))
+__WEAK void EvrRtxThreadFlagsWaitNotCompleted (int32_t flags, uint32_t options) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxThreadFlagsWaitNotCompleted, (uint32_t)flags, options);
+#else
+  (void)flags;
+  (void)options;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_DELAY_DISABLE))
+__WEAK void EvrRtxThreadDelay (uint32_t ticks) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxThreadDelay, ticks, 0U);
+#else
+  (void)ticks;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_DELAY_UNTIL_DISABLE))
+__WEAK void EvrRtxThreadDelayUntil (uint64_t ticks) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxThreadDelayUntil, (uint32_t)ticks, (uint32_t)(ticks >> 32));
+#else
+  (void)ticks;
+#endif
+}
+#endif
+
+
+//  ==== Timer Events ====
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_TIMER != 0) && !defined(EVR_RTX_TIMER_ERROR_DISABLE))
+__WEAK void EvrRtxTimerError (osTimerId_t timer_id, int32_t status) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxTimerError, (uint32_t)timer_id, (uint32_t)status);
+#else
+  (void)timer_id;
+  (void)status;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_TIMER != 0) && !defined(EVR_RTX_TIMER_CALLBACK_DISABLE))
+__WEAK void EvrRtxTimerCallback (osTimerFunc_t func, void *argument) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxTimerCallback, (uint32_t)func, (uint32_t)argument);
+#else
+  (void)func;
+  (void)argument;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_TIMER != 0) && !defined(EVR_RTX_TIMER_NEW_DISABLE))
+__WEAK void EvrRtxTimerNew (osTimerFunc_t func, osTimerType_t type, void *argument, const osTimerAttr_t *attr) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord4(EvtRtxTimerNew, (uint32_t)func, (uint32_t)type, (uint32_t)argument, (uint32_t)attr);
+  if (attr != NULL) {
+    EventRecordData(EvtRtxTimerNew_Detail, attr, sizeof (osTimerAttr_t));
+  }
+#else
+  (void)func;
+  (void)type;
+  (void)argument;
+  (void)attr;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_TIMER != 0) && !defined(EVR_RTX_TIMER_CREATED_DISABLE))
+__WEAK void EvrRtxTimerCreated (osTimerId_t timer_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxTimerCreated, (uint32_t)timer_id, 0U);
+#else
+  (void)timer_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_TIMER != 0) && !defined(EVR_RTX_TIMER_GET_NAME_DISABLE))
+__WEAK void EvrRtxTimerGetName (osTimerId_t timer_id, const char *name) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxTimerGetName, (uint32_t)timer_id, (uint32_t)name);
+  if (name != NULL) {
+    EventRecordData(EvtRtxTimerGetName_Detail, name, strlen(name));
+  }
+#else
+  (void)timer_id;
+  (void)name;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_TIMER != 0) && !defined(EVR_RTX_TIMER_START_DISABLE))
+__WEAK void EvrRtxTimerStart (osTimerId_t timer_id, uint32_t ticks) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxTimerStart, (uint32_t)timer_id, ticks);
+#else
+  (void)timer_id;
+  (void)ticks;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_TIMER != 0) && !defined(EVR_RTX_TIMER_STARTED_DISABLE))
+__WEAK void EvrRtxTimerStarted (osTimerId_t timer_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxTimerStarted, (uint32_t)timer_id, 0U);
+#else
+  (void)timer_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_TIMER != 0) && !defined(EVR_RTX_TIMER_STOP_DISABLE))
+__WEAK void EvrRtxTimerStop (osTimerId_t timer_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxTimerStop, (uint32_t)timer_id, 0U);
+#else
+  (void)timer_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_TIMER != 0) && !defined(EVR_RTX_TIMER_STOPPED_DISABLE))
+__WEAK void EvrRtxTimerStopped (osTimerId_t timer_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxTimerStopped, (uint32_t)timer_id, 0U);
+#else
+  (void)timer_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_TIMER != 0) && !defined(EVR_RTX_TIMER_IS_RUNNING_DISABLE))
+__WEAK void EvrRtxTimerIsRunning (osTimerId_t timer_id, uint32_t running) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxTimerIsRunning, (uint32_t)timer_id, running);
+#else
+  (void)timer_id;
+  (void)running;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_TIMER != 0) && !defined(EVR_RTX_TIMER_DELETE_DISABLE))
+__WEAK void EvrRtxTimerDelete (osTimerId_t timer_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxTimerDelete, (uint32_t)timer_id, 0U);
+#else
+  (void)timer_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_TIMER != 0) && !defined(EVR_RTX_TIMER_DESTROYED_DISABLE))
+__WEAK void EvrRtxTimerDestroyed (osTimerId_t timer_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxTimerDestroyed, (uint32_t)timer_id, 0U);
+#else
+  (void)timer_id;
+#endif
+}
+#endif
+
+
+//  ==== Event Flags Events ====
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_EVFLAGS != 0) && !defined(EVR_RTX_EVENT_FLAGS_ERROR_DISABLE))
+__WEAK void EvrRtxEventFlagsError (osEventFlagsId_t ef_id, int32_t status) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxEventFlagsError, (uint32_t)ef_id, (uint32_t)status);
+#else
+  (void)ef_id;
+  (void)status;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_EVFLAGS != 0) && !defined(EVR_RTX_EVENT_FLAGS_NEW_DISABLE))
+__WEAK void EvrRtxEventFlagsNew (const osEventFlagsAttr_t *attr) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxEventFlagsNew, (uint32_t)attr, 0U);
+  if (attr != NULL) {
+    EventRecordData(EvtRtxEventFlagsNew_Detail, attr, sizeof (osEventFlagsAttr_t));
+  }
+#else
+  (void)attr;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_EVFLAGS != 0) && !defined(EVR_RTX_EVENT_FLAGS_CREATED_DISABLE))
+__WEAK void EvrRtxEventFlagsCreated (osEventFlagsId_t ef_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxEventFlagsCreated, (uint32_t)ef_id, 0U);
+#else
+  (void)ef_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_EVFLAGS != 0) && !defined(EVR_RTX_EVENT_FLAGS_GET_NAME_DISABLE))
+__WEAK void EvrRtxEventFlagsGetName (osEventFlagsId_t ef_id, const char *name) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxEventFlagsGetName, (uint32_t)ef_id, (uint32_t)name);
+  if (name != NULL) {
+    EventRecordData(EvtRtxEventFlagsGetName_Detail, name, strlen(name));
+  }
+#else
+  (void)ef_id;
+  (void)name;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_EVFLAGS != 0) && !defined(EVR_RTX_EVENT_FLAGS_SET_DISABLE))
+__WEAK void EvrRtxEventFlagsSet (osEventFlagsId_t ef_id, int32_t flags) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxEventFlagsSet, (uint32_t)ef_id, (uint32_t)flags);
+#else
+  (void)ef_id;
+  (void)flags;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_EVFLAGS != 0) && !defined(EVR_RTX_EVENT_FLAGS_SET_DONE_DISABLE))
+__WEAK void EvrRtxEventFlagsSetDone (osEventFlagsId_t ef_id, int32_t event_flags) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxEventFlagsSetDone, (uint32_t)ef_id, (uint32_t)event_flags);
+#else
+  (void)ef_id;
+  (void)event_flags;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_EVFLAGS != 0) && !defined(EVR_RTX_EVENT_FLAGS_CLEAR_DISABLE))
+__WEAK void EvrRtxEventFlagsClear (osEventFlagsId_t ef_id, int32_t flags) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxEventFlagsClear, (uint32_t)ef_id, (uint32_t)flags);
+#else
+  (void)ef_id;
+  (void)flags;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_EVFLAGS != 0) && !defined(EVR_RTX_EVENT_FLAGS_CLEAR_DONE_DISABLE))
+__WEAK void EvrRtxEventFlagsClearDone (osEventFlagsId_t ef_id, int32_t event_flags) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxEventFlagsClearDone, (uint32_t)ef_id, (uint32_t)event_flags);
+#else
+  (void)ef_id;
+  (void)event_flags;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_EVFLAGS != 0) && !defined(EVR_RTX_EVENT_FLAGS_GET_DISABLE))
+__WEAK void EvrRtxEventFlagsGet (osEventFlagsId_t ef_id, int32_t event_flags) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxEventFlagsGet, (uint32_t)ef_id, (uint32_t)event_flags);
+#else
+  (void)ef_id;
+  (void)event_flags;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_EVFLAGS != 0) && !defined(EVR_RTX_EVENT_FLAGS_WAIT_DISABLE))
+__WEAK void EvrRtxEventFlagsWait (osEventFlagsId_t ef_id, int32_t flags, uint32_t options, uint32_t timeout) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord4(EvtRtxEventFlagsWait, (uint32_t)ef_id, (uint32_t)flags, options, timeout);
+#else
+  (void)ef_id;
+  (void)flags;
+  (void)options;
+  (void)timeout;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_EVFLAGS != 0) && !defined(EVR_RTX_EVENT_FLAGS_WAIT_PENDING_DISABLE))
+__WEAK void EvrRtxEventFlagsWaitPending (osEventFlagsId_t ef_id, int32_t flags, uint32_t options, uint32_t timeout) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord4(EvtRtxEventFlagsWaitPending, (uint32_t)ef_id, (uint32_t)flags, options, timeout);
+#else
+  (void)ef_id;
+  (void)flags;
+  (void)options;
+  (void)timeout;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_EVFLAGS != 0) && !defined(EVR_RTX_EVENT_FLAGS_WAIT_COMPLETED_DISABLE))
+__WEAK void EvrRtxEventFlagsWaitCompleted (osEventFlagsId_t ef_id, int32_t flags, uint32_t options, int32_t event_flags) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord4(EvtRtxEventFlagsWaitCompleted, (uint32_t)ef_id, (uint32_t)flags, options, (uint32_t)event_flags);
+#else
+  (void)ef_id;
+  (void)flags;
+  (void)options;
+  (void)event_flags;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_EVFLAGS != 0) && !defined(EVR_RTX_EVENT_FLAGS_WAIT_NOT_COMPLETED_DISABLE))
+__WEAK void EvrRtxEventFlagsWaitNotCompleted (osEventFlagsId_t ef_id, int32_t flags, uint32_t options) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord4(EvtRtxEventFlagsWaitNotCompleted, (uint32_t)ef_id, (uint32_t)flags, options, 0U);
+#else
+  (void)ef_id;
+  (void)flags;
+  (void)options;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_EVFLAGS != 0) && !defined(EVR_RTX_EVENT_FLAGS_DELETE_DISABLE))
+__WEAK void EvrRtxEventFlagsDelete (osEventFlagsId_t ef_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxEventFlagsDelete, (uint32_t)ef_id, 0U);
+#else
+  (void)ef_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_EVFLAGS != 0) && !defined(EVR_RTX_EVENT_FLAGS_DESTROYED_DISABLE))
+__WEAK void EvrRtxEventFlagsDestroyed (osEventFlagsId_t ef_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxEventFlagsDestroyed, (uint32_t)ef_id, 0U);
+#else
+  (void)ef_id;
+#endif
+}
+#endif
+
+
+//  ==== Mutex Events ====
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MUTEX != 0) && !defined(EVR_RTX_MUTEX_ERROR_DISABLE))
+__WEAK void EvrRtxMutexError (osMutexId_t mutex_id, int32_t status) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMutexError, (uint32_t)mutex_id, (uint32_t)status);
+#else
+  (void)mutex_id;
+  (void)status;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MUTEX != 0) && !defined(EVR_RTX_MUTEX_NEW_DISABLE))
+__WEAK void EvrRtxMutexNew (const osMutexAttr_t *attr) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMutexNew, (uint32_t)attr, 0U);
+  if (attr != NULL) {
+    EventRecordData(EvtRtxMutexNew_Detail, attr, sizeof (osMutexAttr_t));
+  }
+#else
+  (void)attr;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MUTEX != 0) && !defined(EVR_RTX_MUTEX_CREATED_DISABLE))
+__WEAK void EvrRtxMutexCreated (osMutexId_t mutex_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMutexCreated, (uint32_t)mutex_id, 0U);
+#else
+  (void)mutex_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MUTEX != 0) && !defined(EVR_RTX_MUTEX_GET_NAME_DISABLE))
+__WEAK void EvrRtxMutexGetName (osMutexId_t mutex_id, const char *name) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMutexGetName, (uint32_t)mutex_id, (uint32_t)name);
+  if (name != NULL) {
+    EventRecordData(EvtRtxMutexGetName_Detail, name, strlen(name));
+  }
+#else
+  (void)mutex_id;
+  (void)name;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MUTEX != 0) && !defined(EVR_RTX_MUTEX_ACQUIRE_DISABLE))
+__WEAK void EvrRtxMutexAcquire (osMutexId_t mutex_id, uint32_t timeout) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMutexAcquire, (uint32_t)mutex_id, timeout);
+#else
+  (void)mutex_id;
+  (void)timeout;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MUTEX != 0) && !defined(EVR_RTX_MUTEX_ACQUIRE_PENDING_DISABLE))
+__WEAK void EvrRtxMutexAcquirePending (osMutexId_t mutex_id, uint32_t timeout) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMutexAcquirePending, (uint32_t)mutex_id, timeout);
+#else
+  (void)mutex_id;
+  (void)timeout;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MUTEX != 0) && !defined(EVR_RTX_MUTEX_ACQUIRED_DISABLE))
+__WEAK void EvrRtxMutexAcquired (osMutexId_t mutex_id, uint32_t lock) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMutexAcquired, (uint32_t)mutex_id, lock);
+#else
+  (void)mutex_id;
+  (void)lock;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MUTEX != 0) && !defined(EVR_RTX_MUTEX_NOT_ACQUIRED_DISABLE))
+__WEAK void EvrRtxMutexNotAcquired (osMutexId_t mutex_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMutexNotAcquired, (uint32_t)mutex_id, 0U);
+#else
+  (void)mutex_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MUTEX != 0) && !defined(EVR_RTX_MUTEX_RELEASE_DISABLE))
+__WEAK void EvrRtxMutexRelease (osMutexId_t mutex_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMutexRelease, (uint32_t)mutex_id, 0U);
+#else
+  (void)mutex_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MUTEX != 0) && !defined(EVR_RTX_MUTEX_RELEASED_DISABLE))
+__WEAK void EvrRtxMutexReleased (osMutexId_t mutex_id, uint32_t lock) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMutexReleased, (uint32_t)mutex_id, lock);
+#else
+  (void)mutex_id;
+  (void)lock;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MUTEX != 0) && !defined(EVR_RTX_MUTEX_GET_OWNER_DISABLE))
+__WEAK void EvrRtxMutexGetOwner (osMutexId_t mutex_id, osThreadId_t thread_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMutexGetOwner, (uint32_t)mutex_id, (uint32_t)thread_id);
+#else
+  (void)mutex_id;
+  (void)thread_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MUTEX != 0) && !defined(EVR_RTX_MUTEX_DELETE_DISABLE))
+__WEAK void EvrRtxMutexDelete (osMutexId_t mutex_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMutexDelete, (uint32_t)mutex_id, 0U);
+#else
+  (void)mutex_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MUTEX != 0) && !defined(EVR_RTX_MUTEX_DESTROYED_DISABLE))
+__WEAK void EvrRtxMutexDestroyed (osMutexId_t mutex_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMutexDestroyed, (uint32_t)mutex_id, 0U);
+#else
+  (void)mutex_id;
+#endif
+}
+#endif
+
+
+//  ==== Semaphore Events ====
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_SEMAPHORE != 0) && !defined(EVR_RTX_SEMAPHORE_ERROR_DISABLE))
+__WEAK void EvrRtxSemaphoreError (osSemaphoreId_t semaphore_id, int32_t status) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxSemaphoreError, (uint32_t)semaphore_id, (uint32_t)status);
+#else
+  (void)semaphore_id;
+  (void)status;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_SEMAPHORE != 0) && !defined(EVR_RTX_SEMAPHORE_NEW_DISABLE))
+__WEAK void EvrRtxSemaphoreNew (uint32_t max_count, uint32_t initial_count, const osSemaphoreAttr_t *attr) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord4(EvtRtxSemaphoreNew, max_count, initial_count, (uint32_t)attr, 0U);
+  if (attr != NULL) {
+    EventRecordData(EvtRtxSemaphoreNew_Detail, attr, sizeof (osSemaphoreAttr_t));
+  }
+#else
+  (void)max_count;
+  (void)initial_count;
+  (void)attr;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_SEMAPHORE != 0) && !defined(EVR_RTX_SEMAPHORE_CREATED_DISABLE))
+__WEAK void EvrRtxSemaphoreCreated (osSemaphoreId_t semaphore_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxSemaphoreCreated, (uint32_t)semaphore_id, 0U);
+#else
+  (void)semaphore_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_SEMAPHORE != 0) && !defined(EVR_RTX_SEMAPHORE_GET_NAME_DISABLE))
+__WEAK void EvrRtxSemaphoreGetName (osSemaphoreId_t semaphore_id, const char *name) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxSemaphoreGetName, (uint32_t)semaphore_id, (uint32_t)name);
+  if (name != NULL) {
+    EventRecordData(EvtRtxSemaphoreGetName_Detail, name, strlen(name));
+  }
+#else
+#endif
+  (void)semaphore_id;
+  (void)name;
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_SEMAPHORE != 0) && !defined(EVR_RTX_SEMAPHORE_ACQUIRE_DISABLE))
+__WEAK void EvrRtxSemaphoreAcquire (osSemaphoreId_t semaphore_id, uint32_t timeout) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxSemaphoreAcquire, (uint32_t)semaphore_id, timeout);
+#else
+  (void)semaphore_id;
+  (void)timeout;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_SEMAPHORE != 0) && !defined(EVR_RTX_SEMAPHORE_ACQUIRE_PENDING_DISABLE))
+__WEAK void EvrRtxSemaphoreAcquirePending (osSemaphoreId_t semaphore_id, uint32_t timeout) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxSemaphoreAcquirePending, (uint32_t)semaphore_id, (uint32_t)timeout);
+#else
+  (void)semaphore_id;
+  (void)timeout;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_SEMAPHORE != 0) && !defined(EVR_RTX_SEMAPHORE_ACQUIRED_DISABLE))
+__WEAK void EvrRtxSemaphoreAcquired (osSemaphoreId_t semaphore_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxSemaphoreAcquired, (uint32_t)semaphore_id, 0U);
+#else
+  (void)semaphore_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_SEMAPHORE != 0) && !defined(EVR_RTX_SEMAPHORE_NOT_ACQUIRED_DISABLE))
+__WEAK void EvrRtxSemaphoreNotAcquired (osSemaphoreId_t semaphore_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxSemaphoreNotAcquired, (uint32_t)semaphore_id, 0U);
+#else
+  (void)semaphore_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_SEMAPHORE != 0) && !defined(EVR_RTX_SEMAPHORE_RELEASE_DISABLE))
+__WEAK void EvrRtxSemaphoreRelease (osSemaphoreId_t semaphore_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxSemaphoreRelease, (uint32_t)semaphore_id, 0U);
+#else
+  (void)semaphore_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_SEMAPHORE != 0) && !defined(EVR_RTX_SEMAPHORE_RELEASED_DISABLE))
+__WEAK void EvrRtxSemaphoreReleased (osSemaphoreId_t semaphore_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxSemaphoreReleased, (uint32_t)semaphore_id, 0U);
+#else
+  (void)semaphore_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_SEMAPHORE != 0) && !defined(EVR_RTX_SEMAPHORE_GET_COUNT_DISABLE))
+__WEAK void EvrRtxSemaphoreGetCount (osSemaphoreId_t semaphore_id, uint32_t count) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxSemaphoreGetCount, (uint32_t)semaphore_id, count);
+#else
+  (void)semaphore_id;
+  (void)count;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_SEMAPHORE != 0) && !defined(EVR_RTX_SEMAPHORE_DELETE_DISABLE))
+__WEAK void EvrRtxSemaphoreDelete (osSemaphoreId_t semaphore_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxSemaphoreDelete, (uint32_t)semaphore_id, 0U);
+#else
+  (void)semaphore_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_SEMAPHORE != 0) && !defined(EVR_RTX_SEMAPHORE_DESTROYED_DISABLE))
+__WEAK void EvrRtxSemaphoreDestroyed (osSemaphoreId_t semaphore_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxSemaphoreDestroyed, (uint32_t)semaphore_id, 0U);
+#else
+  (void)semaphore_id;
+#endif
+}
+#endif
+
+
+//  ==== Memory Pool Events ====
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMPOOL != 0) && !defined(EVR_RTX_MEMORY_POOL_ERROR_DISABLE))
+__WEAK void EvrRtxMemoryPoolError (osMemoryPoolId_t mp_id, int32_t status) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMemoryPoolError, (uint32_t)mp_id, (uint32_t)status);
+#else
+  (void)mp_id;
+  (void)status;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMPOOL != 0) && !defined(EVR_RTX_MEMORY_POOL_NEW_DISABLE))
+__WEAK void EvrRtxMemoryPoolNew (uint32_t block_count, uint32_t block_size, const osMemoryPoolAttr_t *attr) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord4(EvtRtxMemoryPoolNew, block_count, block_size, (uint32_t)attr, 0U);
+  if (attr != NULL) {
+    EventRecordData(EvtRtxMemoryPoolNew, attr, sizeof (osMemoryPoolAttr_t));
+  }
+#else
+  (void)block_count;
+  (void)block_size;
+  (void)attr;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMPOOL != 0) && !defined(EVR_RTX_MEMORY_POOL_CREATED_DISABLE))
+__WEAK void EvrRtxMemoryPoolCreated (osMemoryPoolId_t mp_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMemoryPoolCreated, (uint32_t)mp_id, 0U);
+#else
+  (void)mp_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMPOOL != 0) && !defined(EVR_RTX_MEMORY_POOL_GET_NAME_DISABLE))
+__WEAK void EvrRtxMemoryPoolGetName (osMemoryPoolId_t mp_id, const char *name) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMemoryPoolGetName, (uint32_t)mp_id, (uint32_t)name);
+  if (name != NULL) {
+    EventRecordData(EvtRtxMemoryPoolGetName_Detail, name, strlen(name));
+  }
+#else
+  (void)mp_id;
+  (void)name;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMPOOL != 0) && !defined(EVR_RTX_MEMORY_POOL_ALLOC_DISABLE))
+__WEAK void EvrRtxMemoryPoolAlloc (osMemoryPoolId_t mp_id, uint32_t timeout) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMemoryPoolAlloc, (uint32_t)mp_id, timeout);
+#else
+  (void)mp_id;
+  (void)timeout;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMPOOL != 0) && !defined(EVR_RTX_MEMORY_POOL_ALLOC_PENDING_DISABLE))
+__WEAK void EvrRtxMemoryPoolAllocPending (osMemoryPoolId_t mp_id, uint32_t timeout) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMemoryPoolAllocPending, (uint32_t)mp_id, timeout);
+#else
+  (void)mp_id;
+  (void)timeout;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMPOOL != 0) && !defined(EVR_RTX_MEMORY_POOL_ALLOCATED_DISABLE))
+__WEAK void EvrRtxMemoryPoolAllocated (osMemoryPoolId_t mp_id, void *block) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMemoryPoolAllocated, (uint32_t)mp_id, (uint32_t)block);
+#else
+  (void)mp_id;
+  (void)block;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMPOOL != 0) && !defined(EVR_RTX_MEMORY_POOL_ALLOC_FAILED_DISABLE))
+__WEAK void EvrRtxMemoryPoolAllocFailed (osMemoryPoolId_t mp_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMemoryPoolAllocFailed, (uint32_t)mp_id, 0U);
+#else
+  (void)mp_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMPOOL != 0) && !defined(EVR_RTX_MEMORY_POOL_FREE_DISABLE))
+__WEAK void EvrRtxMemoryPoolFree (osMemoryPoolId_t mp_id, void *block) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMemoryPoolFree, (uint32_t)mp_id, (uint32_t)block);
+#else
+  (void)mp_id;
+  (void)block;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMPOOL != 0) && !defined(EVR_RTX_MEMORY_POOL_DEALLOCATED_DISABLE))
+__WEAK void EvrRtxMemoryPoolDeallocated (osMemoryPoolId_t mp_id, void *block) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMemoryPoolDeallocated, (uint32_t)mp_id, (uint32_t)block);
+#else
+  (void)mp_id;
+  (void)block;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMPOOL != 0) && !defined(EVR_RTX_MEMORY_POOL_FREE_FAILED_DISABLE))
+__WEAK void EvrRtxMemoryPoolFreeFailed (osMemoryPoolId_t mp_id, void *block) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMemoryPoolFreeFailed, (uint32_t)mp_id, (uint32_t)block);
+#else
+  (void)mp_id;
+  (void)block;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMPOOL != 0) && !defined(EVR_RTX_MEMORY_POOL_GET_CAPACITY_DISABLE))
+__WEAK void EvrRtxMemoryPoolGetCapacity (osMemoryPoolId_t mp_id, uint32_t capacity) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMemoryPoolGetCapacity, (uint32_t)mp_id, capacity);
+#else
+  (void)mp_id;
+  (void)capacity;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMPOOL != 0) && !defined(EVR_RTX_MEMORY_POOL_GET_BLOCK_SZIE_DISABLE))
+__WEAK void EvrRtxMemoryPoolGetBlockSize (osMemoryPoolId_t mp_id, uint32_t block_size) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMemoryPoolGetBlockSize, (uint32_t)mp_id, block_size);
+#else
+  (void)mp_id;
+  (void)block_size;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMPOOL != 0) && !defined(EVR_RTX_MEMORY_POOL_GET_COUNT_DISABLE))
+__WEAK void EvrRtxMemoryPoolGetCount (osMemoryPoolId_t mp_id, uint32_t count) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMemoryPoolGetCount, (uint32_t)mp_id, count);
+#else
+  (void)mp_id;
+  (void)count;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMPOOL != 0) && !defined(EVR_RTX_MEMORY_POOL_GET_SPACE_DISABLE))
+__WEAK void EvrRtxMemoryPoolGetSpace (osMemoryPoolId_t mp_id, uint32_t space) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMemoryPoolGetSpace, (uint32_t)mp_id, space);
+#else
+  (void)mp_id;
+  (void)space;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMPOOL != 0) && !defined(EVR_RTX_MEMORY_POOL_DELETE_DISABLE))
+__WEAK void EvrRtxMemoryPoolDelete (osMemoryPoolId_t mp_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMemoryPoolDelete, (uint32_t)mp_id, 0U);
+#else
+  (void)mp_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMPOOL != 0) && !defined(EVR_RTX_MEMORY_POOL_DESTROYED_DISABLE))
+__WEAK void EvrRtxMemoryPoolDestroyed (osMemoryPoolId_t mp_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMemoryPoolDestroyed, (uint32_t)mp_id, 0U);
+#else
+  (void)mp_id;
+#endif
+}
+#endif
+
+
+//  ==== Message Queue Events ====
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_ERROR_DISABLE))
+__WEAK void EvrRtxMessageQueueError (osMessageQueueId_t mq_id, int32_t status) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2 (EvtRtxMessageQueueError, (uint32_t)mq_id, (uint32_t)status);
+#else
+  (void)mq_id;
+  (void)status;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_NEW_DISABLE))
+__WEAK void EvrRtxMessageQueueNew (uint32_t msg_count, uint32_t msg_size, const osMessageQueueAttr_t *attr) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord4(EvtRtxMessageQueueNew, msg_count, msg_size, (uint32_t)attr, 0U);
+  if (attr != NULL) {
+    EventRecordData(EvtRtxMessageQueueNew_Detail, attr, sizeof (osMemoryPoolAttr_t));
+  }
+#else
+  (void)msg_count;
+  (void)msg_size;
+  (void)attr;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_CREATED_DISABLE))
+__WEAK void EvrRtxMessageQueueCreated (osMessageQueueId_t mq_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMessageQueueCreated, (uint32_t)mq_id, 0U);
+#else
+  (void)mq_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_GET_NAME_DISABLE))
+__WEAK void EvrRtxMessageQueueGetName (osMessageQueueId_t mq_id, const char *name) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMessageQueueGetName, (uint32_t)mq_id, (uint32_t)name);
+  if (name != NULL) {
+    EventRecordData(EvtRtxMessageQueueGetName_Detail, name, strlen(name));
+  }
+#else
+  (void)mq_id;
+  (void)name;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_PUT_DISABLE))
+__WEAK void EvrRtxMessageQueuePut (osMessageQueueId_t mq_id, const void *msg_ptr, uint8_t msg_prio, uint32_t timeout) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord4(EvtRtxMessageQueuePut, (uint32_t)mq_id, (uint32_t)msg_ptr, (uint32_t)msg_prio, timeout);
+#else
+  (void)mq_id;
+  (void)msg_ptr;
+  (void)msg_prio;
+  (void)timeout;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_PUT_PENDING_DISABLE))
+__WEAK void EvrRtxMessageQueuePutPending (osMessageQueueId_t mq_id, const void *msg_ptr, uint32_t timeout) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord4(EvtRtxMessageQueuePutPending, (uint32_t)mq_id, (uint32_t)msg_ptr, timeout, 0U);
+#else
+  (void)mq_id;
+  (void)msg_ptr;
+  (void)timeout;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_INSERT_PENDING_DISABLE))
+__WEAK void EvrRtxMessageQueueInsertPending (osMessageQueueId_t mq_id, const void *msg_ptr) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMessageQueueInsertPending, (uint32_t)mq_id, (uint32_t)msg_ptr);
+#else
+  (void)mq_id;
+  (void)msg_ptr;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_INSERTED_DISABLE))
+__WEAK void EvrRtxMessageQueueInserted (osMessageQueueId_t mq_id, const void *msg_ptr) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMessageQueueInserted, (uint32_t)mq_id, (uint32_t)msg_ptr);
+#else
+  (void)mq_id;
+  (void)msg_ptr;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_NOT_INSERTED_DISABLE))
+__WEAK void EvrRtxMessageQueueNotInserted (osMessageQueueId_t mq_id, const void *msg_ptr) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMessageQueueNotInserted, (uint32_t)mq_id, (uint32_t)msg_ptr);
+#else
+  (void)mq_id;
+  (void)msg_ptr;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_GET_DISABLE))
+__WEAK void EvrRtxMessageQueueGet (osMessageQueueId_t mq_id, void *msg_ptr, uint8_t *msg_prio, uint32_t timeout) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord4(EvtRtxMessageQueueGet, (uint32_t)mq_id, (uint32_t)msg_ptr, (uint32_t)msg_prio, timeout);
+#else
+  (void)mq_id;
+  (void)msg_ptr;
+  (void)msg_prio;
+  (void)timeout;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_GET_PENDING_DISABLE))
+__WEAK void EvrRtxMessageQueueGetPending (osMessageQueueId_t mq_id, void *msg_ptr, uint32_t timeout) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord4(EvtRtxMessageQueueGetPending, (uint32_t)mq_id, (uint32_t)msg_ptr, timeout, 0U);
+#else
+  (void)mq_id;
+  (void)msg_ptr;
+  (void)timeout;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_RETRIEVED_DISABLE))
+__WEAK void EvrRtxMessageQueueRetrieved (osMessageQueueId_t mq_id, void *msg_ptr) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMessageQueueRetrieved, (uint32_t)mq_id, (uint32_t)msg_ptr);
+#else
+  (void)mq_id;
+  (void)msg_ptr;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_NOT_RETRIEVED_DISABLE))
+__WEAK void EvrRtxMessageQueueNotRetrieved (osMessageQueueId_t mq_id, void *msg_ptr) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMessageQueueNotRetrieved, (uint32_t)mq_id, (uint32_t)msg_ptr);
+#else
+  (void)mq_id;
+  (void)msg_ptr;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_GET_CAPACITY_DISABLE))
+__WEAK void EvrRtxMessageQueueGetCapacity (osMessageQueueId_t mq_id, uint32_t capacity) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMessageQueueGetCapacity, (uint32_t)mq_id, capacity);
+#else
+  (void)mq_id;
+  (void)capacity;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_GET_MSG_SIZE_DISABLE))
+__WEAK void EvrRtxMessageQueueGetMsgSize (osMessageQueueId_t mq_id, uint32_t msg_size) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMessageQueueGetMsgSize, (uint32_t)mq_id, msg_size);
+#else
+  (void)mq_id;
+  (void)msg_size;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_GET_COUNT_DISABLE))
+__WEAK void EvrRtxMessageQueueGetCount (osMessageQueueId_t mq_id, uint32_t count) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMessageQueueGetCount, (uint32_t)mq_id, count);
+#else
+  (void)mq_id;
+  (void)count;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_GET_SPACE_DISABLE))
+__WEAK void EvrRtxMessageQueueGetSpace (osMessageQueueId_t mq_id, uint32_t space) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMessageQueueGetSpace, (uint32_t)mq_id, space);
+#else
+  (void)mq_id;
+  (void)space;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_RESET_DISABLE))
+__WEAK void EvrRtxMessageQueueReset (osMessageQueueId_t mq_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMessageQueueReset, (uint32_t)mq_id, 0U);
+#else
+  (void)mq_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_RESET_DONE_DISABLE))
+__WEAK void EvrRtxMessageQueueResetDone (osMessageQueueId_t mq_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMessageQueueResetDone, (uint32_t)mq_id, 0U);
+#else
+  (void)mq_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_DELETE_DISABLE))
+__WEAK void EvrRtxMessageQueueDelete (osMessageQueueId_t mq_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMessageQueueDelete, (uint32_t)mq_id, 0U);
+#else
+  (void)mq_id;
+#endif
+}
+#endif
+
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_DESTROYED_DISABLE))
+__WEAK void EvrRtxMessageQueueDestroyed (osMessageQueueId_t mq_id) {
+#if defined(RTE_Compiler_EventRecorder)
+  EventRecord2(EvtRtxMessageQueueDestroyed, (uint32_t)mq_id, 0U);
+#else
+  (void)mq_id;
+#endif
+}
+#endif
diff --git a/CMSIS/RTOS2/RTX/Source/rtx_kernel.c b/CMSIS/RTOS2/RTX/Source/rtx_kernel.c
index eb8e21c..e2c205c 100644
--- a/CMSIS/RTOS2/RTX/Source/rtx_kernel.c
+++ b/CMSIS/RTOS2/RTX/Source/rtx_kernel.c
@@ -97,9 +97,11 @@
 osStatus_t svcRtxKernelInitialize (void) {
 
   if (osRtxInfo.kernel.state == osRtxKernelReady) {
+    EvrRtxKernelInitializeCompleted();
     return osOK;
   }
   if (osRtxInfo.kernel.state != osKernelInactive) {
+    EvrRtxKernelError(osError);
     return osError;
   }
 
@@ -107,10 +109,12 @@
   memset(&osRtxInfo.kernel, 0, sizeof(osRtxInfo) - offsetof(osRtxInfo_t, kernel));
 
   if (osRtxConfig.thread_stack_size < (64U + 8U)) {
+    EvrRtxKernelError(osRtxErrorInvalidThreadStack);
     return osError;
   }
 
   if ((osRtxConfig.isr_queue.data == NULL) || (osRtxConfig.isr_queue.max == 0U)) {
+    EvrRtxKernelError(osError);
     return osError;
   }
   osRtxInfo.isr_queue.data = osRtxConfig.isr_queue.data;
@@ -199,6 +203,7 @@
 #if (__DOMAIN_NS == 1U)
   // Initialize Secure Process Stack
   if (TZ_InitContextSystem_S() == 0U) {
+    EvrRtxKernelError(osRtxErrorTZ_InitContext_S);
     return osError;
   }
 #endif
@@ -208,6 +213,8 @@
 
   osRtxInfo.kernel.state = osRtxKernelReady;
 
+  EvrRtxKernelInitializeCompleted();
+
   return osOK;
 }
 
@@ -227,12 +234,15 @@
     memcpy(id_buf, osRtxKernelId, id_size);
   }
 
+  EvrRtxKernelInfoRetrieved(version, id_buf);
+
   return osOK;
 }
 
 /// Get the current RTOS Kernel state.
 /// \note API identical to osKernelGetState
 osKernelState_t svcRtxKernelGetState (void) {
+  EvrRtxKernelGetState((osKernelState_t)(osRtxInfo.kernel.state));
   return ((osKernelState_t)(osRtxInfo.kernel.state));
 }
 
@@ -242,6 +252,7 @@
   os_thread_t *thread;
 
   if (osRtxInfo.kernel.state != osRtxKernelReady) {
+    EvrRtxKernelError(osRtxErrorKernelNotReady);
     return osError;
   }
 
@@ -249,6 +260,7 @@
   if (osRtxInfo.thread.idle == NULL) {
     osRtxInfo.thread.idle = svcRtxThreadNew(osRtxIdleThread, NULL, osRtxConfig.idle_thread_attr);
     if (osRtxInfo.thread.idle == NULL) {
+      EvrRtxKernelError(osError);
       return osError;
     }
   }
@@ -256,6 +268,7 @@
   // Switch to Ready Thread with highest Priority
   thread = osRtxThreadListGet(&osRtxInfo.thread.ready);
   if (thread == NULL) {
+    EvrRtxKernelError(osError);
     return osError;
   }
   osRtxThreadSwitch(thread);
@@ -279,6 +292,8 @@
 
   osRtxInfo.kernel.state = osRtxKernelRunning;
 
+  EvrRtxKernelStarted();
+
   return osOK;
 }
 
@@ -287,13 +302,16 @@
 int32_t svcRtxKernelLock (void) {
 
   if (osRtxInfo.kernel.state == osRtxKernelLocked) {
+    EvrRtxKernelLocked(1);
     return 1;
   }
   if (osRtxInfo.kernel.state == osRtxKernelRunning) {
     osRtxInfo.kernel.state = osRtxKernelLocked;
+    EvrRtxKernelLocked(0);
     return 0;
   }
 
+  EvrRtxKernelError(osError);
   return osError;
 }
  
@@ -303,12 +321,15 @@
 
   if (osRtxInfo.kernel.state == osRtxKernelLocked) {
     osRtxInfo.kernel.state = osRtxKernelRunning;
+    EvrRtxKernelUnlocked(1);
     return 1;
   }
   if (osRtxInfo.kernel.state == osRtxKernelRunning) {
+    EvrRtxKernelUnlocked(0);
     return 0;
   }
 
+  EvrRtxKernelError(osError);
   return osError;
 }
 
@@ -321,15 +342,18 @@
     switch (lock) {
       case 1:
         osRtxInfo.kernel.state = osRtxKernelLocked;
+        EvrRtxKernelLockRestored(1);
         return 1;
       case 0:
         osRtxInfo.kernel.state = osRtxKernelRunning;
+        EvrRtxKernelLockRestored(0);
         return 0;
       default:
         break;
     }
   }
 
+  EvrRtxKernelError(osError);
   return osError;
 }
 
@@ -341,6 +365,7 @@
   uint32_t     delay;
 
   if (osRtxInfo.kernel.state != osRtxKernelRunning) {
+    EvrRtxKernelError(osRtxErrorKernelNotRunning);
     return 0U;
   }
 
@@ -364,6 +389,8 @@
 
   osRtxInfo.kernel.state = osRtxKernelSuspended;
 
+  EvrRtxKernelSuspended(delay);
+
   return delay;
 }
 
@@ -375,6 +402,7 @@
   uint32_t     delay;
 
   if (osRtxInfo.kernel.state != osRtxKernelSuspended) {
+    EvrRtxKernelResumed();
     return;
   }
 
@@ -426,17 +454,20 @@
 
   KernelUnblock();
 
+  EvrRtxKernelResumed();
 }
 
 /// Get the RTOS kernel tick count.
 /// \note API identical to osKernelGetTickCount
 uint64_t svcRtxKernelGetTickCount (void) {
+  EvrRtxKernelGetTickCount(osRtxInfo.kernel.tick);
   return osRtxInfo.kernel.tick;
 }
 
 /// Get the RTOS kernel tick frequency.
 /// \note API identical to osKernelGetTickFreq
 uint32_t svcRtxKernelGetTickFreq (void) {
+  EvrRtxKernelGetTickFreq(osRtxConfig.tick_freq);
   return osRtxConfig.tick_freq;
 }
 
@@ -444,6 +475,7 @@
 /// \note API identical to osKernelGetSysTimerCount
 uint32_t svcRtxKernelGetSysTimerCount (void) {
   uint32_t count = osRtxSysTimerGetCount();
+  EvrRtxKernelGetSysTimerCount(count);
   return count;
 }
 
@@ -451,6 +483,7 @@
 /// \note API identical to osKernelGetSysTimerFreq
 uint32_t svcRtxKernelGetSysTimerFreq (void) {
   uint32_t freq = osRtxSysTimerGetFreq();
+  EvrRtxKernelGetSysTimerFreq(freq);
   return freq;
 }
 
@@ -459,7 +492,9 @@
 
 /// Initialize the RTOS Kernel.
 osStatus_t osKernelInitialize (void) {
+  EvrRtxKernelInitialize();
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxKernelError(osErrorISR);
     return osErrorISR;
   }
   return __svcKernelInitialize();
@@ -467,7 +502,9 @@
 
 ///  Get RTOS Kernel Information.
 osStatus_t osKernelGetInfo (osVersion_t *version, char *id_buf, uint32_t id_size) {
+  EvrRtxKernelGetInfo(version, id_buf, id_size);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxKernelError(osErrorISR);
     return osErrorISR;
   }
   if (IS_PRIVILEGED()) {
@@ -480,6 +517,7 @@
 /// Get the current RTOS Kernel state.
 osKernelState_t osKernelGetState (void) {
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxKernelGetState(osKernelError);
     return osKernelError;
   }
   if (IS_PRIVILEGED()) {
@@ -491,7 +529,9 @@
 
 /// Start the RTOS Kernel scheduler.
 osStatus_t osKernelStart (void) {
+  EvrRtxKernelStart();
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxKernelError(osErrorISR);
     return osErrorISR;
   }
   return __svcKernelStart();
@@ -499,7 +539,9 @@
 
 /// Lock the RTOS Kernel scheduler.
 int32_t osKernelLock (void) {
+  EvrRtxKernelLock();
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxKernelError(osErrorISR);
     return osErrorISR;
   }
   return __svcKernelLock();
@@ -507,7 +549,9 @@
  
 /// Unlock the RTOS Kernel scheduler.
 int32_t osKernelUnlock (void) {
+  EvrRtxKernelUnlock();
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxKernelError(osErrorISR);
     return osErrorISR;
   }
   return __svcKernelUnlock();
@@ -515,7 +559,9 @@
 
 /// Restore the RTOS Kernel scheduler lock state.
 int32_t osKernelRestoreLock (int32_t lock) {
+  EvrRtxKernelRestoreLock(lock);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxKernelError(osErrorISR);
     return osErrorISR;
   }
   return __svcKernelRestoreLock(lock);
@@ -523,7 +569,9 @@
 
 /// Suspend the RTOS Kernel scheduler.
 uint32_t osKernelSuspend (void) {
+  EvrRtxKernelSuspend();
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxKernelError(osErrorISR);
     return 0U;
   }
   return __svcKernelSuspend();
@@ -531,7 +579,9 @@
 
 /// Resume the RTOS Kernel scheduler.
 void osKernelResume (uint32_t sleep_ticks) {
+  EvrRtxKernelResume(sleep_ticks);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxKernelError(osErrorISR);
     return;
   }
   __svcKernelResume(sleep_ticks);
@@ -540,6 +590,7 @@
 /// Get the RTOS kernel tick count.
 uint64_t osKernelGetTickCount (void) {
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxKernelGetTickCount(0U);
     return  0U;
   } else {
     return  __svcKernelGetTickCount();
@@ -549,6 +600,7 @@
 /// Get the RTOS kernel tick frequency.
 uint32_t osKernelGetTickFreq (void) {
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxKernelGetTickFreq(0U);
     return  0U;
   } else {
     return  __svcKernelGetTickFreq();
diff --git a/CMSIS/RTOS2/RTX/Source/rtx_lib.h b/CMSIS/RTOS2/RTX/Source/rtx_lib.h
index b4bff73..607916f 100644
--- a/CMSIS/RTOS2/RTX/Source/rtx_lib.h
+++ b/CMSIS/RTOS2/RTX/Source/rtx_lib.h
@@ -32,6 +32,7 @@
 #include "tz_context.h"                 // TrustZone Context API
 #include "cmsis_os2.h"                  // CMSIS RTOS API
 #include "rtx_os.h"                     // RTX OS definitions
+#include "rtx_evr.h"                    // RTX Event Recorder definitions
 
 
 //  ==== Library defines ====
diff --git a/CMSIS/RTOS2/RTX/Source/rtx_memory.c b/CMSIS/RTOS2/RTX/Source/rtx_memory.c
index 8e75cf3..793b603 100644
--- a/CMSIS/RTOS2/RTX/Source/rtx_memory.c
+++ b/CMSIS/RTOS2/RTX/Source/rtx_memory.c
@@ -54,6 +54,7 @@
 
   if ((mem == NULL) || ((uint32_t)mem & 7U) || (size & 7U) ||
       (size < (sizeof(mem_head_t) + 2*sizeof(mem_block_t)))) {
+    EvrRtxMemoryInit(mem, size, 0U);
     return 0U;
   }
 
@@ -66,6 +67,8 @@
   ptr->next->next = NULL;
   ptr->info = 0U;
 
+  EvrRtxMemoryInit(mem, size, 1U);
+
   return 1U;
 }
 
@@ -79,6 +82,7 @@
   uint32_t     hole_size;
 
   if ((mem == NULL) || (size == 0U) || (type & ~MB_INFO_TYPE_MASK)) {
+    EvrRtxMemoryAlloc(mem, size, type, NULL);
     return NULL;
   }
 
@@ -99,6 +103,7 @@
     p = p->next;
     if (p->next == NULL) {
       // Failed (end of list)
+      EvrRtxMemoryAlloc(mem, size, type, NULL);
       return NULL;
     }
   }
@@ -118,6 +123,8 @@
     ptr = (mem_block_t *)((uint32_t)p_new + sizeof(mem_block_t));
   }
 
+  EvrRtxMemoryAlloc(mem, size, type, ptr);
+
   return ptr;
 }
 
@@ -129,6 +136,7 @@
   mem_block_t *p, *p_prev, *ptr;
 
   if ((mem == NULL) || (block == NULL)) {
+    EvrRtxMemoryFree(mem, block, 0U);
     return 0U;
   }
 
@@ -142,6 +150,7 @@
     p = p->next;
     if (p == NULL) {
       // Not found
+      EvrRtxMemoryFree(mem, block, 0U);
       return 0U;
     }
   }
@@ -156,5 +165,7 @@
     p_prev->next = p->next;
   }
 
+  EvrRtxMemoryFree(mem, block, 1U);
+
   return 1U;
 }
diff --git a/CMSIS/RTOS2/RTX/Source/rtx_mempool.c b/CMSIS/RTOS2/RTX/Source/rtx_mempool.c
index bd00306..1bcd976 100644
--- a/CMSIS/RTOS2/RTX/Source/rtx_mempool.c
+++ b/CMSIS/RTOS2/RTX/Source/rtx_mempool.c
@@ -58,6 +58,8 @@
   }
   *((void **)block_mem) = NULL;
 
+  EvrRtxMemoryBlockInit(mp_info, block_count, block_size, block_mem);
+
   return 1U;
 }
 
@@ -71,6 +73,7 @@
   void *block;
 
   if (mp_info == NULL) {
+    EvrRtxMemoryBlockAlloc(NULL, NULL);
     return NULL;
   }
 
@@ -98,6 +101,8 @@
   }
 #endif
 
+  EvrRtxMemoryBlockAlloc(mp_info, block);
+
   return block;
 }
 
@@ -112,6 +117,7 @@
   osStatus_t status;
 
   if ((mp_info == NULL) || (block < mp_info->block_base) || (block >= mp_info->block_lim)) {
+    EvrRtxMemoryBlockFree(mp_info, block, osErrorParameter);
     return osErrorParameter;
   }
 
@@ -139,6 +145,8 @@
   }
 #endif
 
+  EvrRtxMemoryBlockFree(mp_info, block, status);
+
   return status;
 }
 
@@ -160,6 +168,7 @@
       // Wakeup waiting Thread with highest Priority
       thread = osRtxThreadListGet((os_object_t*)mp);
       osRtxThreadWaitExit(thread, (uint32_t)block, false);
+      EvrRtxMemoryPoolAllocated(mp, block);
     }
   }
 }
@@ -190,10 +199,12 @@
 
   // Check parameters
   if ((block_count == 0U) || (block_size  == 0U)) {
+    EvrRtxMemoryPoolError(NULL, osErrorParameter);
     return NULL;
   }
   block_size = (block_size + 3U) & ~3UL;
   if ((__CLZ(block_count) + __CLZ(block_size)) < 32) {
+    EvrRtxMemoryPoolError(NULL, osErrorParameter);
     return NULL;
   }
 
@@ -207,19 +218,23 @@
     mp_size = attr->mp_size;
     if (mp != NULL) {
       if (((uint32_t)mp & 3U) || (attr->cb_size < sizeof(os_memory_pool_t))) {
+        EvrRtxMemoryPoolError(NULL, osRtxErrorInvalidControlBlock);
         return NULL;
       }
     } else {
       if (attr->cb_size != 0U) {
+        EvrRtxMemoryPoolError(NULL, osRtxErrorInvalidControlBlock);
         return NULL;
       }
     }
     if (mp_mem != NULL) {
       if (((uint32_t)mp_mem & 3U) || (mp_size < size)) {
+        EvrRtxMemoryPoolError(NULL, osRtxErrorInvalidDataMemory);
         return NULL;
       }
     } else {
       if (mp_size != 0U) {
+        EvrRtxMemoryPoolError(NULL, osRtxErrorInvalidDataMemory);
         return NULL;
       }
     }
@@ -237,6 +252,7 @@
       mp = osRtxMemoryAlloc(osRtxInfo.mem.common, sizeof(os_memory_pool_t), 1U);
     }
     if (mp == NULL) {
+      EvrRtxMemoryPoolError(NULL, osErrorNoMemory);
       return NULL;
     }
     flags = osRtxFlagSystemObject;
@@ -248,6 +264,7 @@
   if (mp_mem == NULL) {
     mp_mem = osRtxMemoryAlloc(osRtxInfo.mem.mp_data, size, 0U);
     if (mp_mem == NULL) {
+      EvrRtxMemoryPoolError(NULL, osErrorNoMemory);
       if (flags & osRtxFlagSystemObject) {
         if (osRtxInfo.mpi.memory_pool != NULL) {
           osRtxMemoryPoolFree(osRtxInfo.mpi.memory_pool, mp);
@@ -272,6 +289,8 @@
   // Register post ISR processing function
   osRtxInfo.post_process.memory_pool = osRtxMemoryPoolPostProcess;
 
+  EvrRtxMemoryPoolCreated(mp);
+
   return mp;
 }
 
@@ -282,14 +301,18 @@
 
   // Check parameters
   if ((mp == NULL) || (mp->id != osRtxIdMemoryPool)) {
+    EvrRtxMemoryPoolGetName(mp, NULL);
     return NULL;
   }
 
   // Check object state
   if (mp->state == osRtxObjectInactive) {
+    EvrRtxMemoryPoolGetName(mp, NULL);
     return NULL;
   }
 
+  EvrRtxMemoryPoolGetName(mp, mp->name);
+
   return mp->name;
 }
 
@@ -301,11 +324,13 @@
 
   // Check parameters
   if ((mp == NULL) || (mp->id != osRtxIdMemoryPool)) {
+    EvrRtxMemoryPoolError(mp, osErrorParameter);
     return NULL;
   }
 
   // Check object state
   if (mp->state == osRtxObjectInactive) {
+    EvrRtxMemoryPoolError(mp, osErrorResource);
     return NULL;
   }
 
@@ -317,7 +342,12 @@
       // Suspend current Thread
       osRtxThreadListPut((os_object_t*)mp, osRtxThreadGetRunning());
       osRtxThreadWaitEnter(osRtxThreadWaitingMemoryPool, timeout);
+      EvrRtxMemoryPoolAllocPending(mp, timeout);
+    } else {
+      EvrRtxMemoryPoolAllocFailed(mp);
     }
+  } else {
+    EvrRtxMemoryPoolAllocated(mp, block);
   }
 
   return block;
@@ -332,17 +362,20 @@
 
   // Check parameters
   if ((mp == NULL) || (mp->id != osRtxIdMemoryPool)) {
+    EvrRtxMemoryPoolError(mp, osErrorParameter);
     return osErrorParameter;
   }
 
   // Check object state
   if (mp->state == osRtxObjectInactive) {
+    EvrRtxMemoryPoolError(mp, osErrorResource);
     return osErrorResource;
   }
 
   // Free memory
   status = osRtxMemoryPoolFree(&mp->mp_info, block);
   if (status == osOK) {
+    EvrRtxMemoryPoolDeallocated(mp, block);
     // Check if Thread is waiting to allocate memory
     if (mp->thread_list != NULL) {
       // Allocate memory
@@ -351,8 +384,11 @@
         // Wakeup waiting Thread with highest Priority
         thread = osRtxThreadListGet((os_object_t*)mp);
         osRtxThreadWaitExit(thread, (uint32_t)block, true);
+        EvrRtxMemoryPoolAllocated(mp, block);
       }
     }
+  } else {
+    EvrRtxMemoryPoolFreeFailed(mp, block);
   }
 
   return status;
@@ -365,14 +401,18 @@
 
   // Check parameters
   if ((mp == NULL) || (mp->id != osRtxIdMemoryPool)) {
+    EvrRtxMemoryPoolGetCapacity(mp, 0U);
     return 0U;
   }
 
   // Check object state
   if (mp->state == osRtxObjectInactive) {
+    EvrRtxMemoryPoolGetCapacity(mp, 0U);
     return 0U;
   }
 
+  EvrRtxMemoryPoolGetCapacity(mp, mp->mp_info.max_blocks);
+
   return mp->mp_info.max_blocks;
 }
 
@@ -383,14 +423,18 @@
 
   // Check parameters
   if ((mp == NULL) || (mp->id != osRtxIdMemoryPool)) {
+    EvrRtxMemoryPoolGetBlockSize(mp, 0U);
     return 0U;
   }
 
   // Check object state
   if (mp->state == osRtxObjectInactive) {
+    EvrRtxMemoryPoolGetBlockSize(mp, 0U);
     return 0U;
   }
 
+  EvrRtxMemoryPoolGetBlockSize(mp, mp->mp_info.block_size);
+
   return mp->mp_info.block_size;
 }
 
@@ -401,14 +445,18 @@
 
   // Check parameters
   if ((mp == NULL) || (mp->id != osRtxIdMemoryPool)) {
+    EvrRtxMemoryPoolGetCount(mp, 0U);
     return 0U;
   }
 
   // Check object state
   if (mp->state == osRtxObjectInactive) {
+    EvrRtxMemoryPoolGetCount(mp, 0U);
     return 0U;
   }
 
+  EvrRtxMemoryPoolGetCount(mp, mp->mp_info.used_blocks);
+
   return mp->mp_info.used_blocks;
 }
 
@@ -419,14 +467,18 @@
 
   // Check parameters
   if ((mp == NULL) || (mp->id != osRtxIdMemoryPool)) {
+    EvrRtxMemoryPoolGetSpace(mp, 0U);
     return 0U;
   }
 
   // Check object state
   if (mp->state == osRtxObjectInactive) {
+    EvrRtxMemoryPoolGetSpace(mp, 0U);
     return 0U;
   }
 
+  EvrRtxMemoryPoolGetSpace(mp, mp->mp_info.max_blocks - mp->mp_info.used_blocks);
+
   return (mp->mp_info.max_blocks - mp->mp_info.used_blocks);
 }
 
@@ -438,11 +490,13 @@
 
   // Check parameters
   if ((mp == NULL) || (mp->id != osRtxIdMemoryPool)) {
+    EvrRtxMemoryPoolError(mp, osErrorParameter);
     return osErrorParameter;
   }
 
   // Check object state
   if (mp->state == osRtxObjectInactive) {
+    EvrRtxMemoryPoolError(mp, osErrorResource);
     return osErrorResource;
   }
 
@@ -472,6 +526,8 @@
     }
   }
 
+  EvrRtxMemoryPoolDestroyed(mp);
+
   return osOK;
 }
 
@@ -487,16 +543,23 @@
 
   // Check parameters
   if ((mp == NULL) || (mp->id != osRtxIdMemoryPool) || (timeout != 0U)) {
+    EvrRtxMemoryPoolError(mp, osErrorParameter);
     return NULL;
   }
 
   // Check object state
   if (mp->state == osRtxObjectInactive) {
+    EvrRtxMemoryPoolError(mp, osErrorResource);
     return NULL;
   }
 
   // Allocate memory
   block = osRtxMemoryPoolAlloc(&mp->mp_info);
+  if (block == NULL) {
+    EvrRtxMemoryPoolAllocFailed(mp);
+  } else {
+    EvrRtxMemoryPoolAllocated(mp, block);
+  }
 
   return block;
 }
@@ -510,11 +573,13 @@
 
   // Check parameters
   if ((mp == NULL) || (mp->id != osRtxIdMemoryPool)) {
+    EvrRtxMemoryPoolError(mp, osErrorParameter);
     return osErrorParameter;
   }
 
   // Check object state
   if (mp->state == osRtxObjectInactive) {
+    EvrRtxMemoryPoolError(mp, osErrorResource);
     return osErrorResource;
   }
 
@@ -523,6 +588,9 @@
   if (status == osOK) {
     // Register post ISR processing
     osRtxPostProcess((os_object_t *)mp);
+    EvrRtxMemoryPoolDeallocated(mp, block);
+  } else {
+    EvrRtxMemoryPoolFreeFailed(mp, block);
   }
 
   return status;
@@ -533,7 +601,9 @@
 
 /// Create and Initialize a Memory Pool object.
 osMemoryPoolId_t osMemoryPoolNew (uint32_t block_count, uint32_t block_size, const osMemoryPoolAttr_t *attr) {
+  EvrRtxMemoryPoolNew(block_count, block_size, attr);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxMemoryPoolError(NULL, osErrorISR);
     return NULL;
   }
   return __svcMemoryPoolNew(block_count, block_size, attr);
@@ -542,6 +612,7 @@
 /// Get name of a Memory Pool object.
 const char *osMemoryPoolGetName (osMemoryPoolId_t mp_id) {
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxMemoryPoolGetName(mp_id, NULL);
     return NULL;
   }
   return __svcMemoryPoolGetName(mp_id);
@@ -549,6 +620,7 @@
 
 /// Allocate a memory block from a Memory Pool.
 void *osMemoryPoolAlloc (osMemoryPoolId_t mp_id, uint32_t timeout) {
+  EvrRtxMemoryPoolAlloc(mp_id, timeout);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
     return isrRtxMemoryPoolAlloc(mp_id, timeout);
   } else {
@@ -558,6 +630,7 @@
 
 /// Return an allocated memory block back to a Memory Pool.
 osStatus_t osMemoryPoolFree (osMemoryPoolId_t mp_id, void *block) {
+  EvrRtxMemoryPoolFree(mp_id, block);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
     return isrRtxMemoryPoolFree(mp_id, block);
   } else {
@@ -603,7 +676,9 @@
 
 /// Delete a Memory Pool object.
 osStatus_t osMemoryPoolDelete (osMemoryPoolId_t mp_id) {
+  EvrRtxMemoryPoolDelete(mp_id);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxMemoryPoolError(mp_id, osErrorISR);
     return osErrorISR;
   }
   return __svcMemoryPoolDelete(mp_id);
diff --git a/CMSIS/RTOS2/RTX/Source/rtx_msgqueue.c b/CMSIS/RTOS2/RTX/Source/rtx_msgqueue.c
index 81e928b..3574b3b 100644
--- a/CMSIS/RTOS2/RTX/Source/rtx_msgqueue.c
+++ b/CMSIS/RTOS2/RTX/Source/rtx_msgqueue.c
@@ -190,6 +190,7 @@
         msg->flags    = 0U;
         msg->priority = (uint8_t)reg[3];
         MessageQueuePut(mq, msg);
+        EvrRtxMessageQueueInserted(mq, (void *)reg[2]);
       }
     }
   } else {
@@ -201,6 +202,7 @@
     }
     // Check if Thread is waiting to receive a Message
     if ((mq->thread_list != NULL) && (mq->thread_list->state == osRtxThreadWaitingMessageGet)) {
+      EvrRtxMessageQueueInserted(mq, (uint8_t *)msg + sizeof(os_message_t));
       // Wakeup waiting Thread with highest Priority
       thread = osRtxThreadListGet((os_object_t*)mq);
       osRtxThreadWaitExit(thread, (uint32_t)osOK, false);
@@ -210,11 +212,13 @@
       if (reg[3] != 0U) {
         *((uint8_t *)reg[3]) = msg->priority;
       }
+      EvrRtxMessageQueueRetrieved(mq, (void *)reg[2]);
       // Free memory
       msg->state = osRtxObjectInactive;
       osRtxMemoryPoolFree(&mq->mp_info, msg);
     } else {
       MessageQueuePut(mq, msg);
+      EvrRtxMessageQueueInserted(mq, (uint8_t *)msg + sizeof(os_message_t));
     }
   }
 }
@@ -246,11 +250,13 @@
 
   // Check parameters
   if ((msg_count == 0U) || (msg_size  == 0U)) {
+    EvrRtxMessageQueueError(NULL, osErrorParameter);
     return NULL;
   }
   msg_size = (msg_size + 3U) & ~3UL;
   block_size = msg_size + sizeof(os_message_t);
   if ((__CLZ(msg_count) + __CLZ(block_size)) < 32) {
+    EvrRtxMessageQueueError(NULL, osErrorParameter);
     return NULL;
   }
 
@@ -264,19 +270,23 @@
     mq_size = attr->mq_size;
     if (mq != NULL) {
       if (((uint32_t)mq & 3U) || (attr->cb_size < sizeof(os_message_queue_t))) {
+        EvrRtxMessageQueueError(NULL, osRtxErrorInvalidControlBlock);
         return NULL;
       }
     } else {
       if (attr->cb_size != 0U) {
+        EvrRtxMessageQueueError(NULL, osRtxErrorInvalidControlBlock);
         return NULL;
       }
     }
     if (mq_mem != NULL) {
       if (((uint32_t)mq_mem & 3U) || (mq_size < size)) {
+        EvrRtxMessageQueueError(NULL, osRtxErrorInvalidDataMemory);
         return NULL;
       }
     } else {
       if (mq_size != 0U) {
+        EvrRtxMessageQueueError(NULL, osRtxErrorInvalidDataMemory);
         return NULL;
       }
     }
@@ -294,6 +304,7 @@
       mq = osRtxMemoryAlloc(osRtxInfo.mem.common, sizeof(os_message_queue_t), 1U);
     }
     if (mq == NULL) {
+      EvrRtxMessageQueueError(NULL, osErrorNoMemory);
       return NULL;
     }
     flags = osRtxFlagSystemObject;
@@ -305,6 +316,7 @@
   if (mq_mem == NULL) {
     mq_mem = osRtxMemoryAlloc(osRtxInfo.mem.mq_data, size, 0U);
     if (mq_mem == NULL) {
+      EvrRtxMessageQueueError(NULL, osErrorNoMemory);
       if (flags & osRtxFlagSystemObject) {
         if (osRtxInfo.mpi.message_queue != NULL) {
           osRtxMemoryPoolFree(osRtxInfo.mpi.message_queue, mq);
@@ -333,6 +345,8 @@
   // Register post ISR processing function
   osRtxInfo.post_process.message_queue = osRtxMessageQueuePostProcess;
 
+  EvrRtxMessageQueueCreated(mq);
+
   return mq;
 }
 
@@ -343,14 +357,18 @@
 
   // Check parameters
   if ((mq == NULL) || (mq->id != osRtxIdMessageQueue)) {
+    EvrRtxMessageQueueGetName(mq, NULL);
     return NULL;
   }
 
   // Check object state
   if (mq->state == osRtxObjectInactive) {
+    EvrRtxMessageQueueGetName(mq, NULL);
     return NULL;
   }
 
+  EvrRtxMessageQueueGetName(mq, mq->name);
+
   return mq->name;
 }
 
@@ -364,16 +382,19 @@
 
   // Check parameters
   if ((mq == NULL) || (mq->id != osRtxIdMessageQueue) || (msg_ptr == NULL)) {
+    EvrRtxMessageQueueError(mq, osErrorParameter);
     return osErrorParameter;
   }
 
   // Check object state
   if (mq->state == osRtxObjectInactive) {
+    EvrRtxMessageQueueError(mq, osErrorResource);
     return osErrorResource;
   }
 
   // Check if Thread is waiting to receive a Message
   if ((mq->thread_list != NULL) && (mq->thread_list->state == osRtxThreadWaitingMessageGet)) {
+    EvrRtxMessageQueueInserted(mq, msg_ptr);
     // Wakeup waiting Thread with highest Priority
     thread = osRtxThreadListGet((os_object_t*)mq);
     osRtxThreadWaitExit(thread, (uint32_t)osOK, true);
@@ -383,6 +404,7 @@
     if (reg[3] != 0U) {
       *((uint8_t *)reg[3]) = msg_prio;
     }
+    EvrRtxMessageQueueRetrieved(mq, (void *)reg[2]);
     return osOK;
   }
 
@@ -407,12 +429,16 @@
       reg = (uint32_t *)(__get_PSP());
       reg[2] = (uint32_t)msg_ptr;
       reg[3] = (uint32_t)msg_prio;
+      EvrRtxMessageQueuePutPending(mq, msg_ptr, timeout);
       return osErrorTimeout;
     } else {
+      EvrRtxMessageQueueNotInserted(mq, msg_ptr);
       return osErrorResource;
     }
   }
 
+  EvrRtxMessageQueueInserted(mq, msg_ptr);
+
   return osOK;
 }
 
@@ -426,11 +452,13 @@
 
   // Check parameters
   if ((mq == NULL) || (mq->id != osRtxIdMessageQueue) || (msg_ptr == NULL)) {
+    EvrRtxMessageQueueError(mq, osErrorParameter);
     return osErrorParameter;
   }
 
   // Check object state
   if (mq->state == osRtxObjectInactive) {
+    EvrRtxMessageQueueError(mq, osErrorResource);
     return osErrorResource;
   }
 
@@ -443,6 +471,7 @@
     if (msg_prio != NULL) {
       *msg_prio = msg->priority;
     }
+    EvrRtxMessageQueueRetrieved(mq, msg_ptr);
     // Free memory
     msg->state = osRtxObjectInactive;
     osRtxMemoryPoolFree(&mq->mp_info, msg);
@@ -456,8 +485,10 @@
       reg = (uint32_t *)(__get_PSP());
       reg[2] = (uint32_t)msg_ptr;
       reg[3] = (uint32_t)msg_prio;
+      EvrRtxMessageQueueGetPending(mq, msg_ptr, timeout);
       return osErrorTimeout;
     } else {
+      EvrRtxMessageQueueNotRetrieved(mq, msg_ptr);
       return osErrorResource;
     }
   }
@@ -479,6 +510,7 @@
       msg->flags    = 0U;
       msg->priority = (uint8_t)reg[3];
       MessageQueuePut(mq, msg);
+      EvrRtxMessageQueueInserted(mq, (void *)reg[2]);
     }
   }
 
@@ -492,14 +524,18 @@
 
   // Check parameters
   if ((mq == NULL) || (mq->id != osRtxIdMessageQueue)) {
+    EvrRtxMessageQueueGetCapacity(mq, 0U);
     return 0U;
   }
 
   // Check object state
   if (mq->state == osRtxObjectInactive) {
+    EvrRtxMessageQueueGetCapacity(mq, 0U);
     return 0U;
   }
 
+  EvrRtxMessageQueueGetCapacity(mq, mq->mp_info.max_blocks);
+
   return mq->mp_info.max_blocks;
 }
 
@@ -510,14 +546,18 @@
 
   // Check parameters
   if ((mq == NULL) || (mq->id != osRtxIdMessageQueue)) {
+    EvrRtxMessageQueueGetCapacity(mq, 0U);
     return 0U;
   }
 
   // Check object state
   if (mq->state == osRtxObjectInactive) {
+    EvrRtxMessageQueueGetCapacity(mq, 0U);
     return 0U;
   }
 
+  EvrRtxMessageQueueGetCapacity(mq, mq->msg_size);
+
   return mq->msg_size;
 }
 
@@ -528,14 +568,18 @@
 
   // Check parameters
   if ((mq == NULL) || (mq->id != osRtxIdMessageQueue)) {
+    EvrRtxMessageQueueGetCount(mq, 0U);
     return 0U;
   }
 
   // Check object state
   if (mq->state == osRtxObjectInactive) {
+    EvrRtxMessageQueueGetCount(mq, 0U);
     return 0U;
   }
 
+  EvrRtxMessageQueueGetCount(mq, mq->msg_count);
+
   return mq->msg_count;
 }
 
@@ -546,14 +590,18 @@
 
   // Check parameters
   if ((mq == NULL) || (mq->id != osRtxIdMessageQueue)) {
+    EvrRtxMessageQueueGetSpace(mq, 0U);
     return 0U;
   }
 
   // Check object state
   if (mq->state == osRtxObjectInactive) {
+    EvrRtxMessageQueueGetSpace(mq, 0U);
     return 0U;
   }
 
+  EvrRtxMessageQueueGetSpace(mq, mq->mp_info.max_blocks - mq->msg_count);
+
   return (mq->mp_info.max_blocks - mq->msg_count);
 }
 
@@ -567,11 +615,13 @@
 
   // Check parameters
   if ((mq == NULL) || (mq->id != osRtxIdMessageQueue)) {
+    EvrRtxMessageQueueError(mq, osErrorParameter);
     return osErrorParameter;
   }
 
   // Check object state
   if (mq->state == osRtxObjectInactive) {
+    EvrRtxMessageQueueError(mq, osErrorResource);
     return osErrorResource;
   }
 
@@ -583,6 +633,7 @@
       break;
     }
     MessageQueueRemove(mq, msg);
+    EvrRtxMessageQueueRetrieved(mq, NULL);
     // Free memory
     msg->state = osRtxObjectInactive;
     osRtxMemoryPoolFree(&mq->mp_info, msg);
@@ -606,11 +657,14 @@
         msg->flags    = 0U;
         msg->priority = (uint8_t)reg[3];
         MessageQueuePut(mq, msg);
+        EvrRtxMessageQueueInserted(mq, (void *)reg[2]);
       }
     } while ((msg != NULL) && (mq->thread_list != NULL));
     osRtxThreadDispatch(NULL);
   }
 
+  EvrRtxMessageQueueResetDone(mq);
+
   return osOK;
 }
 
@@ -622,11 +676,13 @@
 
   // Check parameters
   if ((mq == NULL) || (mq->id != osRtxIdMessageQueue)) {
+    EvrRtxMessageQueueError(mq, osErrorParameter);
     return osErrorParameter;
   }
 
   // Check object state
   if (mq->state == osRtxObjectInactive) {
+    EvrRtxMessageQueueError(mq, osErrorResource);
     return osErrorResource;
   }
 
@@ -656,6 +712,8 @@
     }
   }
 
+  EvrRtxMessageQueueDestroyed(mq);
+
   return osOK;
 }
 
@@ -672,11 +730,13 @@
 
   // Check parameters
   if ((mq == NULL) || (mq->id != osRtxIdMessageQueue) || (msg_ptr == NULL) || (timeout != 0U)) {
+    EvrRtxMessageQueueError(mq, osErrorParameter);
     return osErrorParameter;
   }
 
   // Check object state
   if (mq->state == osRtxObjectInactive) {
+    EvrRtxMessageQueueError(mq, osErrorResource);
     return osErrorResource;
   }
 
@@ -695,9 +755,12 @@
     osRtxPostProcess((os_object_t *)msg);
   } else {
     // No memory available
+    EvrRtxMessageQueueNotInserted(mq, msg_ptr);
     return osErrorResource;
   }
 
+  EvrRtxMessageQueueInsertPending(mq, msg_ptr);
+
   return osOK;
 }
 
@@ -711,11 +774,13 @@
 
   // Check parameters
   if ((mq == NULL) || (mq->id != osRtxIdMessageQueue) || (msg_ptr == NULL) || (timeout != 0U)) {
+    EvrRtxMessageQueueError(mq, osErrorParameter);
     return osErrorParameter;
   }
 
   // Check object state
   if (mq->state == osRtxObjectInactive) {
+    EvrRtxMessageQueueError(mq, osErrorResource);
     return osErrorResource;
   }
 
@@ -727,12 +792,14 @@
     if (msg_prio != NULL) {
       *msg_prio = msg->priority;
     }
+    EvrRtxMessageQueueRetrieved(mq, msg_ptr);
     // Register post ISR processing
      ptr = (void *)((uint8_t *)msg + sizeof(os_message_t));
     *ptr = mq;
     osRtxPostProcess((os_object_t *)msg);
   } else {
     // No Message available
+    EvrRtxMessageQueueNotRetrieved(mq, msg_ptr);
     return osErrorResource;
   }
 
@@ -744,7 +811,9 @@
 
 /// Create and Initialize a Message Queue object.
 osMessageQueueId_t osMessageQueueNew (uint32_t msg_count, uint32_t msg_size, const osMessageQueueAttr_t *attr) {
+  EvrRtxMessageQueueNew(msg_count, msg_size, attr);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxMessageQueueError(NULL, osErrorISR);
     return NULL;
   }
   return __svcMessageQueueNew(msg_count, msg_size, attr);
@@ -753,6 +822,7 @@
 /// Get name of a Message Queue object.
 const char *osMessageQueueGetName (osMessageQueueId_t mq_id) {
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxMessageQueueGetName(mq_id, NULL);
     return NULL;
   }
   return __svcMessageQueueGetName(mq_id);
@@ -760,6 +830,7 @@
 
 /// Put a Message into a Queue or timeout if Queue is full.
 osStatus_t osMessageQueuePut (osMessageQueueId_t mq_id, const void *msg_ptr, uint8_t msg_prio, uint32_t timeout) {
+  EvrRtxMessageQueuePut(mq_id, msg_ptr, msg_prio, timeout);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
     return isrRtxMessageQueuePut(mq_id, msg_ptr, msg_prio, timeout);
   } else {
@@ -769,6 +840,7 @@
 
 /// Get a Message from a Queue or timeout if Queue is empty.
 osStatus_t osMessageQueueGet (osMessageQueueId_t mq_id, void *msg_ptr, uint8_t *msg_prio, uint32_t timeout) {
+  EvrRtxMessageQueueGet(mq_id, msg_ptr, msg_prio, timeout);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
     return isrRtxMessageQueueGet(mq_id, msg_ptr, msg_prio, timeout);
   } else {
@@ -814,7 +886,9 @@
 
 /// Reset a Message Queue to initial empty state.
 osStatus_t osMessageQueueReset (osMessageQueueId_t mq_id) {
+  EvrRtxMessageQueueReset(mq_id);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxMessageQueueError(mq_id, osErrorISR);
     return osErrorISR;
   }
   return __svcMessageQueueReset(mq_id);
@@ -822,7 +896,9 @@
 
 /// Delete a Message Queue object.
 osStatus_t osMessageQueueDelete (osMessageQueueId_t mq_id) {
+  EvrRtxMessageQueueDelete(mq_id);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxMessageQueueError(mq_id, osErrorISR);
     return osErrorISR;
   }
   return __svcMessageQueueDelete(mq_id);
diff --git a/CMSIS/RTOS2/RTX/Source/rtx_mutex.c b/CMSIS/RTOS2/RTX/Source/rtx_mutex.c
index 4804a00..8288a39 100644
--- a/CMSIS/RTOS2/RTX/Source/rtx_mutex.c
+++ b/CMSIS/RTOS2/RTX/Source/rtx_mutex.c
@@ -42,6 +42,7 @@
     if (mutex->attr & osMutexRobust) {
       // Clear Lock counter
       mutex->lock = 0U;
+      EvrRtxMutexReleased(mutex, 0U);
       // Check if Thread is waiting for a Mutex
       if (mutex->thread_list != NULL) {
         // Wakeup waiting Thread with highest Priority
@@ -53,6 +54,7 @@
         mutex->owner_prev   = NULL;
         thread->mutex_list  = mutex;
         mutex->lock = 1U;
+        EvrRtxMutexAcquired(mutex, 1U);
       }
     }
     mutex = mutex_list;
@@ -85,10 +87,12 @@
     mutex     = attr->cb_mem;
     if (mutex != NULL) {
       if (((uint32_t)mutex & 3U) || (attr->cb_size < sizeof(os_mutex_t))) {
+        EvrRtxMutexError(NULL, osRtxErrorInvalidControlBlock);
         return NULL;
       }
     } else {
       if (attr->cb_size != 0U) {
+        EvrRtxMutexError(NULL, osRtxErrorInvalidControlBlock);
         return NULL;
       }
     }
@@ -106,6 +110,7 @@
       mutex = osRtxMemoryAlloc(osRtxInfo.mem.common, sizeof(os_mutex_t), 1U);
     }
     if (mutex == NULL) {
+      EvrRtxMutexError(NULL, osErrorNoMemory);
       return NULL;
     }
     flags = osRtxFlagSystemObject;
@@ -125,6 +130,8 @@
   mutex->owner_next   = NULL;
   mutex->lock         = 0U;
 
+  EvrRtxMutexCreated(mutex);
+
   return mutex;
 }
 
@@ -135,14 +142,18 @@
 
   // Check parameters
   if ((mutex == NULL) || (mutex->id != osRtxIdMutex)) {
+    EvrRtxMutexGetName(mutex, NULL);
     return NULL;
   }
 
   // Check object state
   if (mutex->state == osRtxObjectInactive) {
+    EvrRtxMutexGetName(mutex, NULL);
     return NULL;
   }
 
+  EvrRtxMutexGetName(mutex, mutex->name);
+
   return mutex->name;
 }
 
@@ -154,16 +165,19 @@
 
   runnig_thread = osRtxThreadGetRunning();
   if (runnig_thread == NULL) {
+    EvrRtxMutexError(mutex, osRtxErrorKernelNotRunning);
     return osError;
   }
 
   // Check parameters
   if ((mutex == NULL) || (mutex->id != osRtxIdMutex)) {
+    EvrRtxMutexError(mutex, osErrorParameter);
     return osErrorParameter;
   }
 
   // Check object state
   if (mutex->state == osRtxObjectInactive) {
+    EvrRtxMutexError(mutex, osErrorResource);
     return osErrorResource;
   }
 
@@ -175,6 +189,7 @@
     mutex->owner_prev   = NULL;
     runnig_thread->mutex_list = mutex;
     mutex->lock = 1U;
+    EvrRtxMutexAcquired(mutex, mutex->lock);
     return osOK;
   }
 
@@ -182,9 +197,11 @@
   if ((mutex->attr & osMutexRecursive) && (mutex->owner_thread == runnig_thread)) {
     // Increment lock counter
     if (mutex->lock == osRtxMutexLockLimit) {
+      EvrRtxMutexError(mutex, osRtxErrorMutexLockLimit);
       return osErrorResource;
     }
     mutex->lock++;
+    EvrRtxMutexAcquired(mutex, mutex->lock);
     return osOK;
   }
 
@@ -201,10 +218,13 @@
     // Suspend current Thread
     osRtxThreadListPut((os_object_t*)mutex, runnig_thread);
     osRtxThreadWaitEnter(osRtxThreadWaitingMutex, timeout);
+    EvrRtxMutexAcquirePending(mutex, timeout);
     return osErrorTimeout;
   }
 
   // Mutex was not acquired
+  EvrRtxMutexNotAcquired(mutex);
+
   return osErrorResource;
 }
 
@@ -219,31 +239,37 @@
 
   runnig_thread = osRtxThreadGetRunning();
   if (runnig_thread == NULL) {
+    EvrRtxMutexError(mutex, osRtxErrorKernelNotRunning);
     return osError;
   }
 
   // Check parameters
   if ((mutex == NULL) || (mutex->id != osRtxIdMutex)) {
+    EvrRtxMutexError(mutex, osErrorParameter);
     return osErrorParameter;
   }
 
   // Check object state
   if (mutex->state == osRtxObjectInactive) {
+    EvrRtxMutexError(mutex, osErrorResource);
     return osErrorResource;
   }
 
   // Check if running Thread is not the owner
   if (mutex->owner_thread != runnig_thread) {
+    EvrRtxMutexError(mutex, osRtxErrorMutexNotOwned);
     return osErrorResource;
   }
 
   // Check if Mutex is not locked
   if (mutex->lock == 0U) {
+    EvrRtxMutexError(mutex, osRtxErrorMutexNotLocked);
     return osErrorResource;
   }
 
   // Decrement Lock counter
   mutex->lock--;
+  EvrRtxMutexReleased(mutex, mutex->lock);
 
   // Check Lock counter
   if (mutex->lock != 0U) {
@@ -286,6 +312,7 @@
     mutex->owner_prev   = NULL;
     thread->mutex_list  = mutex;
     mutex->lock = 1U;
+    EvrRtxMutexAcquired(mutex, 1U);
   }
 
   osRtxThreadDispatch(NULL);
@@ -300,19 +327,24 @@
 
   // Check parameters
   if ((mutex == NULL) || (mutex->id != osRtxIdMutex)) {
+    EvrRtxMutexGetOwner(mutex, NULL);
     return NULL;
   }
 
   // Check object state
   if (mutex->state == osRtxObjectInactive) {
+    EvrRtxMutexGetOwner(mutex, NULL);
     return NULL;
   }
 
   // Check if Mutex is not locked
   if (mutex->lock == 0U) {
+    EvrRtxMutexGetOwner(mutex, NULL);
     return NULL;
   }
 
+  EvrRtxMutexGetOwner(mutex, mutex->owner_thread);
+
   return mutex->owner_thread;
 }
 
@@ -326,11 +358,13 @@
 
   // Check parameters
   if ((mutex == NULL) || (mutex->id != osRtxIdMutex)) {
+    EvrRtxMutexError(mutex, osErrorParameter);
     return osErrorParameter;
   }
 
   // Check object state
   if (mutex->state == osRtxObjectInactive) {
+    EvrRtxMutexError(mutex, osErrorResource);
     return osErrorResource;
   }
 
@@ -390,6 +424,8 @@
     }
   }
 
+  EvrRtxMutexDestroyed(mutex);
+
   return osOK;
 }
 
@@ -398,7 +434,9 @@
 
 /// Create and Initialize a Mutex object.
 osMutexId_t osMutexNew (const osMutexAttr_t *attr) {
+  EvrRtxMutexNew(attr);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxMutexError(NULL, osErrorISR);
     return NULL;
   }
   return __svcMutexNew(attr);
@@ -407,6 +445,7 @@
 /// Get name of a Mutex object.
 const char *osMutexGetName (osMutexId_t mutex_id) {
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxMutexGetName(mutex_id, NULL);
     return NULL;
   }
   return __svcMutexGetName(mutex_id);
@@ -414,7 +453,9 @@
 
 /// Acquire a Mutex or timeout if it is locked.
 osStatus_t osMutexAcquire (osMutexId_t mutex_id, uint32_t timeout) {
+  EvrRtxMutexAcquire(mutex_id, timeout);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxMutexError(mutex_id, osErrorISR);
     return osErrorISR;
   }
   return __svcMutexAcquire(mutex_id, timeout);
@@ -422,7 +463,9 @@
 
 /// Release a Mutex that was acquired by \ref osMutexAcquire.
 osStatus_t osMutexRelease (osMutexId_t mutex_id) {
+  EvrRtxMutexRelease(mutex_id);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxMutexError(mutex_id, osErrorISR);
     return osErrorISR;
   }
   return __svcMutexRelease(mutex_id);
@@ -431,6 +474,7 @@
 /// Get Thread which owns a Mutex object.
 osThreadId_t osMutexGetOwner (osMutexId_t mutex_id) {
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxMutexGetOwner(mutex_id, NULL);
     return NULL;
   }
   return __svcMutexGetOwner(mutex_id);
@@ -438,7 +482,9 @@
 
 /// Delete a Mutex object.
 osStatus_t osMutexDelete (osMutexId_t mutex_id) {
+  EvrRtxMutexDelete(mutex_id);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxMutexError(mutex_id, osErrorISR);
     return osErrorISR;
   }
   return __svcMutexDelete(mutex_id);
diff --git a/CMSIS/RTOS2/RTX/Source/rtx_semaphore.c b/CMSIS/RTOS2/RTX/Source/rtx_semaphore.c
index 186a14d..44fbe89 100644
--- a/CMSIS/RTOS2/RTX/Source/rtx_semaphore.c
+++ b/CMSIS/RTOS2/RTX/Source/rtx_semaphore.c
@@ -113,6 +113,7 @@
       // Wakeup waiting Thread with highest Priority
       thread = osRtxThreadListGet((os_object_t*)semaphore);
       osRtxThreadWaitExit(thread, (uint32_t)osOK, false);
+      EvrRtxSemaphoreAcquired(semaphore);
     }
   }
 }
@@ -137,6 +138,7 @@
 
   // Check parameters
   if ((max_count == 0U) || (max_count > osRtxSemaphoreTokenLimit) || (initial_count > max_count)) {
+    EvrRtxSemaphoreError(NULL, osErrorParameter);
     return NULL;
   }
 
@@ -146,10 +148,12 @@
     semaphore = attr->cb_mem;
     if (semaphore != NULL) {
       if (((uint32_t)semaphore & 3U) || (attr->cb_size < sizeof(os_semaphore_t))) {
+        EvrRtxSemaphoreError(NULL, osRtxErrorInvalidControlBlock);
         return NULL;
       }
     } else {
       if (attr->cb_size != 0U) {
+        EvrRtxSemaphoreError(NULL, osRtxErrorInvalidControlBlock);
         return NULL;
       }
     }
@@ -166,6 +170,7 @@
       semaphore = osRtxMemoryAlloc(osRtxInfo.mem.common, sizeof(os_semaphore_t), 1U);
     }
     if (semaphore == NULL) {
+      EvrRtxSemaphoreError(NULL, osErrorNoMemory);
       return NULL;
     }
     flags = osRtxFlagSystemObject;
@@ -185,6 +190,8 @@
   // Register post ISR processing function
   osRtxInfo.post_process.semaphore = osRtxSemaphorePostProcess;
 
+  EvrRtxSemaphoreCreated(semaphore);
+
   return semaphore;
 }
 
@@ -195,14 +202,18 @@
 
   // Check parameters
   if ((semaphore == NULL) || (semaphore->id != osRtxIdSemaphore)) {
+    EvrRtxSemaphoreGetName(semaphore, NULL);
     return NULL;
   }
 
   // Check object state
   if (semaphore->state == osRtxObjectInactive) {
+    EvrRtxSemaphoreGetName(semaphore, NULL);
     return NULL;
   }
 
+  EvrRtxSemaphoreGetName(semaphore, semaphore->name);
+
   return semaphore->name;
 }
 
@@ -213,11 +224,13 @@
 
   // Check parameters
   if ((semaphore == NULL) || (semaphore->id != osRtxIdSemaphore)) {
+    EvrRtxSemaphoreError(semaphore, osErrorParameter);
     return osErrorParameter;
   }
 
   // Check object state
   if (semaphore->state == osRtxObjectInactive) {
+    EvrRtxSemaphoreError(semaphore, osErrorResource);
     return osErrorResource;
   }
 
@@ -228,12 +241,16 @@
       // Suspend current Thread
       osRtxThreadListPut((os_object_t*)semaphore, osRtxThreadGetRunning());
       osRtxThreadWaitEnter(osRtxThreadWaitingSemaphore, timeout);
+      EvrRtxSemaphoreAcquirePending(semaphore, timeout);
       return osErrorTimeout;
     } else {
+      EvrRtxSemaphoreNotAcquired(semaphore);
       return osErrorResource;
     }
   }
 
+  EvrRtxSemaphoreAcquired(semaphore);
+
   return osOK;
 }
 
@@ -245,24 +262,30 @@
 
   // Check parameters
   if ((semaphore == NULL) || (semaphore->id != osRtxIdSemaphore)) {
+    EvrRtxSemaphoreError(semaphore, osErrorParameter);
     return osErrorParameter;
   }
 
   // Check object state
   if (semaphore->state == osRtxObjectInactive) {
+    EvrRtxSemaphoreError(semaphore, osErrorResource);
     return osErrorResource;
   }
 
   // Check if Thread is waiting for a token
   if (semaphore->thread_list != NULL) {
+    EvrRtxSemaphoreReleased(semaphore);
     // Wakeup waiting Thread with highest Priority
     thread = osRtxThreadListGet((os_object_t*)semaphore);
     osRtxThreadWaitExit(thread, (uint32_t)osOK, true);
+    EvrRtxSemaphoreAcquired(semaphore);
   } else {
     // Try to release token
     if (SemaphoreTokenIncrement(semaphore) == 0U) {
+      EvrRtxSemaphoreError(semaphore, osRtxErrorSemaphoreCountLimit);
       return osErrorResource;
     }
+    EvrRtxSemaphoreReleased(semaphore);
   }
 
   return osOK;
@@ -275,14 +298,18 @@
 
   // Check parameters
   if ((semaphore == NULL) || (semaphore->id != osRtxIdSemaphore)) {
+    EvrRtxSemaphoreGetCount(semaphore, 0U);
     return 0U;
   }
 
   // Check object state
   if (semaphore->state == osRtxObjectInactive) {
+    EvrRtxSemaphoreGetCount(semaphore, 0U);
     return 0U;
   }
 
+  EvrRtxSemaphoreGetCount(semaphore, semaphore->tokens);
+
   return semaphore->tokens;
 }
 
@@ -294,11 +321,13 @@
 
   // Check parameters
   if ((semaphore == NULL) || (semaphore->id != osRtxIdSemaphore)) {
+    EvrRtxSemaphoreError(semaphore, osErrorParameter);
     return osErrorParameter;
   }
 
   // Check object state
   if (semaphore->state == osRtxObjectInactive) {
+    EvrRtxSemaphoreError(semaphore, osErrorResource);
     return osErrorResource;
   }
 
@@ -323,6 +352,8 @@
     }
   }
 
+  EvrRtxSemaphoreDestroyed(semaphore);
+
   return osOK;
 }
 
@@ -337,20 +368,25 @@
 
   // Check parameters
   if ((semaphore == NULL) || (semaphore->id != osRtxIdSemaphore) || (timeout != 0U)) {
+    EvrRtxSemaphoreError(semaphore, osErrorParameter);
     return osErrorParameter;
   }
 
   // Check object state
   if (semaphore->state == osRtxObjectInactive) {
+    EvrRtxSemaphoreError(semaphore, osErrorResource);
     return osErrorResource;
   }
 
   // Try to acquire token
   if (SemaphoreTokenDecrement(semaphore) == 0U) {
     // No token available
+    EvrRtxSemaphoreNotAcquired(semaphore);
     return osErrorResource;
   }
 
+  EvrRtxSemaphoreAcquired(semaphore);
+
   return osOK;
 }
 
@@ -362,11 +398,13 @@
 
   // Check parameters
   if ((semaphore == NULL) || (semaphore->id != osRtxIdSemaphore)) {
+    EvrRtxSemaphoreError(semaphore, osErrorParameter);
     return osErrorParameter;
   }
 
   // Check object state
   if (semaphore->state == osRtxObjectInactive) {
+    EvrRtxSemaphoreError(semaphore, osErrorResource);
     return osErrorResource;
   }
 
@@ -375,9 +413,12 @@
     // Register post ISR processing
     osRtxPostProcess((os_object_t *)semaphore);
   } else {
+    EvrRtxSemaphoreError(semaphore, osRtxErrorSemaphoreCountLimit);
     return osErrorResource;
   }
 
+  EvrRtxSemaphoreReleased(semaphore);
+
   return osOK;
 }
 
@@ -386,7 +427,9 @@
 
 /// Create and Initialize a Semaphore object.
 osSemaphoreId_t osSemaphoreNew (uint32_t max_count, uint32_t initial_count, const osSemaphoreAttr_t *attr) {
+  EvrRtxSemaphoreNew(max_count, initial_count, attr);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxSemaphoreError(NULL, osErrorISR);
     return NULL;
   }
   return __svcSemaphoreNew(max_count, initial_count, attr);
@@ -395,6 +438,7 @@
 /// Get name of a Semaphore object.
 const char *osSemaphoreGetName (osSemaphoreId_t semaphore_id) {
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxSemaphoreGetName(semaphore_id, NULL);
     return NULL;
   }
   return __svcSemaphoreGetName(semaphore_id);
@@ -402,6 +446,7 @@
 
 /// Acquire a Semaphore token or timeout if no tokens are available.
 osStatus_t osSemaphoreAcquire (osSemaphoreId_t semaphore_id, uint32_t timeout) {
+  EvrRtxSemaphoreAcquire(semaphore_id, timeout);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
     return isrRtxSemaphoreAcquire(semaphore_id, timeout);
   } else {
@@ -411,6 +456,7 @@
 
 /// Release a Semaphore token that was acquired by osSemaphoreAcquire.
 osStatus_t osSemaphoreRelease (osSemaphoreId_t semaphore_id) {
+  EvrRtxSemaphoreRelease(semaphore_id);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
     return isrRtxSemaphoreRelease(semaphore_id);
   } else {
@@ -429,7 +475,9 @@
 
 /// Delete a Semaphore object.
 osStatus_t osSemaphoreDelete (osSemaphoreId_t semaphore_id) {
+  EvrRtxSemaphoreDelete(semaphore_id);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxSemaphoreError(semaphore_id, osErrorISR);
     return osErrorISR;
   }
   return __svcSemaphoreDelete(semaphore_id);
diff --git a/CMSIS/RTOS2/RTX/Source/rtx_thread.c b/CMSIS/RTOS2/RTX/Source/rtx_thread.c
index ad5eb75..380ab09 100644
--- a/CMSIS/RTOS2/RTX/Source/rtx_thread.c
+++ b/CMSIS/RTOS2/RTX/Source/rtx_thread.c
@@ -385,6 +385,7 @@
   thread->state = osRtxThreadRunning;
   osRtxInfo.thread.run.next = thread;
   osRtxThreadStackCheck();
+  EvrRtxThreadSwitch(thread);
 }
 
 /// Dispatch specified Thread or Ready Thread with Highest Priority.
@@ -436,6 +437,8 @@
   } else {
     osRtxThreadReadyPut(thread);
   }
+
+  EvrRtxThreadUnblocked(thread, ret_val);
 }
 
 /// Enter Thread wait state.
@@ -464,6 +467,8 @@
   thread = osRtxThreadListGet(&osRtxInfo.thread.ready);
   osRtxThreadSwitch(thread);
 
+  EvrRtxThreadBlocked(thread, timeout);
+
   return true;
 }
 
@@ -495,6 +500,7 @@
     thread_flags = ThreadFlagsCheck(thread, thread->wait_flags, thread->flags_options);
     if (thread_flags > 0) {
       osRtxThreadWaitExit(thread, (uint32_t)thread_flags, false);
+      EvrRtxThreadFlagsWaitCompleted(thread->wait_flags, thread->flags_options, thread_flags);
     }
   }
 }
@@ -544,6 +550,7 @@
 
   // Check parameters
   if (func == NULL) {
+    EvrRtxThreadError(NULL, osErrorParameter);
     return NULL;
   }
 
@@ -560,15 +567,18 @@
 #endif
     if (thread != NULL) {
       if (((uint32_t)thread & 3U) || (attr->cb_size < sizeof(os_thread_t))) {
+        EvrRtxThreadError(NULL, osRtxErrorInvalidControlBlock);
         return NULL;
       }
     } else {
       if (attr->cb_size != 0U) {
+        EvrRtxThreadError(NULL, osRtxErrorInvalidControlBlock);
         return NULL;
       }
     }
     if (stack_mem != NULL) {
       if (((uint32_t)stack_mem & 7U) || (stack_size == 0U)) {
+        EvrRtxThreadError(NULL, osRtxErrorInvalidThreadStack);
         return NULL;
       }
     }
@@ -576,6 +586,7 @@
       priority = osPriorityNormal;
     } else {
       if ((priority < osPriorityIdle) || (priority > osPriorityISR)) {
+        EvrRtxThreadError(NULL, osRtxErrorInvalidPriority);
         return NULL;
       }
     }
@@ -593,6 +604,7 @@
 
   // Check stack size
   if ((stack_size != 0U) && ((stack_size & 7U) || (stack_size < (64U + 8U)))) {
+    EvrRtxThreadError(NULL, osRtxErrorInvalidThreadStack);
     return NULL;
   }
 
@@ -604,6 +616,7 @@
       thread = osRtxMemoryAlloc(osRtxInfo.mem.common, sizeof(os_thread_t), 1U);
     }
     if (thread == NULL) {
+      EvrRtxThreadError(NULL, osErrorNoMemory);
       return NULL;
     }
     flags = osRtxFlagSystemObject;
@@ -626,6 +639,7 @@
       stack_mem = osRtxMemoryAlloc(osRtxInfo.mem.stack, stack_size, 0U);
     }
     if (stack_mem == NULL) {
+      EvrRtxThreadError(NULL, osErrorNoMemory);
       if (flags & osRtxFlagSystemObject) {
         if (osRtxInfo.mpi.thread != NULL) {
           osRtxMemoryPoolFree(osRtxInfo.mpi.thread, thread);
@@ -643,6 +657,7 @@
   if (tz_module != 0U) {
     tz_memory = TZ_AllocModuleContext_S(tz_module);
     if (tz_memory == 0U) {
+      EvrRtxThreadError(NULL, osRtxErrorTZ_AllocContext_S);
       if (flags & osRtxFlagSystemMemory) {
         if (flags & osRtxThreadFlagDefStack) {
           osRtxMemoryPoolFree(osRtxInfo.mpi.stack, thread->stack_mem);
@@ -712,6 +727,8 @@
   // Register post ISR processing function
   osRtxInfo.post_process.thread = osRtxThreadPostProcess;
 
+  EvrRtxThreadCreated(thread);
+
   osRtxThreadDispatch(thread);
 
   return thread;
@@ -724,14 +741,18 @@
 
   // Check parameters
   if ((thread == NULL) || (thread->id != osRtxIdThread)) {
+    EvrRtxThreadGetName(thread, NULL);
     return NULL;
   }
 
   // Check object state
   if (thread->state == osRtxObjectInactive) {
+    EvrRtxThreadGetName(thread, NULL);
     return NULL;
   }
 
+  EvrRtxThreadGetName(thread, thread->name);
+
   return thread->name;
 }
 
@@ -741,6 +762,7 @@
   os_thread_t *thread;
 
   thread = osRtxThreadGetRunning();
+  EvrRtxThreadGetId(thread);
   return thread;
 }
 
@@ -751,9 +773,12 @@
 
   // Check parameters
   if ((thread == NULL) || (thread->id != osRtxIdThread)) {
+    EvrRtxThreadGetState(thread, osThreadError);
     return osThreadError;
   }
 
+  EvrRtxThreadGetState(thread, (osThreadState_t)(thread->state & osRtxThreadStateMask));
+
   return ((osThreadState_t)(thread->state & osRtxThreadStateMask));
 }
 
@@ -764,14 +789,18 @@
 
   // Check parameters
   if ((thread == NULL) || (thread->id != osRtxIdThread)) {
+    EvrRtxThreadGetStackSize(thread, 0U);
     return 0U;
   }
 
   // Check object state
   if (thread->state == osRtxObjectInactive) {
+    EvrRtxThreadGetStackSize(thread, 0U);
     return 0U;
   }
 
+  EvrRtxThreadGetStackSize(thread, thread->stack_size);
+
   return thread->stack_size;
 }
 
@@ -784,20 +813,24 @@
 
   // Check parameters
   if ((thread == NULL) || (thread->id != osRtxIdThread)) {
+    EvrRtxThreadGetStackSpace(thread, 0U);
     return 0U;
   }
 
   // Check object state
   if (thread->state == osRtxObjectInactive) {
+    EvrRtxThreadGetStackSpace(thread, 0U);
     return 0U;
   }
 
   if ((osRtxConfig.flags & osRtxConfigStackWatermark) == 0U) {
+    EvrRtxThreadGetStackSpace(thread, 0U);
     return 0U;
   }
 
   stack = thread->stack_mem;
   if (*stack++ != osRtxStackMagicWord) {
+    EvrRtxThreadGetStackSpace(thread, 0U);
     return 0U;
   }
   for (space = 4U; space < thread->stack_size; space += 4U) {
@@ -806,6 +839,8 @@
     }
   }
 
+  EvrRtxThreadGetStackSpace(thread, space);
+
   return space;
 }
 
@@ -817,12 +852,14 @@
   // Check parameters
   if ((thread == NULL) || (thread->id != osRtxIdThread) ||
       (priority < osPriorityIdle) || (priority > osPriorityISR)) {
+    EvrRtxThreadError(thread, osErrorParameter);
     return osErrorParameter;
   }
 
   // Check object state
   if ((thread->state == osRtxThreadInactive) ||
       (thread->state == osRtxThreadTerminated)) {
+    EvrRtxThreadError(thread, osErrorResource);
     return osErrorResource;
   }
 
@@ -843,15 +880,19 @@
 
   // Check parameters
   if ((thread == NULL) || (thread->id != osRtxIdThread)) {
+    EvrRtxThreadGetPriority(thread, osPriorityError);
     return osPriorityError;
   }
 
   // Check object state
   if ((thread->state == osRtxThreadInactive) ||
       (thread->state == osRtxThreadTerminated)) {
+    EvrRtxThreadGetPriority(thread, osPriorityError);
     return osPriorityError;
   }
 
+  EvrRtxThreadGetPriority(thread, (osPriority_t)thread->priority);
+
   return ((osPriority_t)thread->priority);
 }
 
@@ -883,6 +924,7 @@
 
   // Check parameters
   if ((thread == NULL) || (thread->id != osRtxIdThread)) {
+    EvrRtxThreadError(thread, osErrorParameter);
     return osErrorParameter;
   }
 
@@ -891,6 +933,7 @@
     case osRtxThreadRunning:
       if ((osRtxKernelGetState() != osRtxKernelRunning) ||
           (osRtxInfo.thread.ready.thread_list == NULL)) {
+        EvrRtxThreadError(thread, osErrorResource);
         return osErrorResource;
       }
       osRtxThreadSwitch(osRtxThreadListGet(&osRtxInfo.thread.ready));
@@ -905,6 +948,7 @@
     case osRtxThreadInactive:
     case osRtxThreadTerminated:
     default:
+      EvrRtxThreadError(thread, osErrorResource);
       return osErrorResource;
   }
 
@@ -914,6 +958,8 @@
   thread->thread_next = NULL;
   osRtxThreadDelayInsert(thread, osWaitForever);
 
+  EvrRtxThreadSuspended(thread);
+
   return osOK;
 }
 
@@ -924,11 +970,13 @@
 
   // Check parameters
   if ((thread == NULL) || (thread->id != osRtxIdThread)) {
+    EvrRtxThreadError(thread, osErrorParameter);
     return osErrorParameter;
   }
 
   // Check object state
   if ((thread->state & osRtxThreadStateMask) != osRtxThreadBlocked) {
+    EvrRtxThreadError(thread, osErrorResource);
     return osErrorResource;
   }
 
@@ -937,6 +985,8 @@
   osRtxThreadDelayRemove(thread);
   osRtxThreadDispatch(thread);
 
+  EvrRtxThreadResumed(thread);
+
   return osOK;
 }
 
@@ -980,16 +1030,19 @@
 
   // Check parameters
   if ((thread == NULL) || (thread->id != osRtxIdThread)) {
+    EvrRtxThreadError(thread, osErrorParameter);
     return osErrorParameter;
   }
 
   // Check object attributes
   if ((thread->attr & osThreadJoinable) == 0U) {
+    EvrRtxThreadError(thread, osRtxErrorThreadNotJoinable);
     return osErrorResource;
   }
 
   // Check object state
   if (thread->state == osRtxThreadInactive) {
+    EvrRtxThreadError(thread, osErrorResource);
     return osErrorResource;
   }
 
@@ -1000,6 +1053,8 @@
     thread->attr &= ~osThreadJoinable;
   }
 
+  EvrRtxThreadDetached(thread);
+
   return osOK;
 }
 
@@ -1010,17 +1065,20 @@
 
   // Check parameters
   if ((thread == NULL) || (thread->id != osRtxIdThread)) {
+    EvrRtxThreadError(thread, osErrorParameter);
     return osErrorParameter;
   }
 
   // Check object attributes
   if ((thread->attr & osThreadJoinable) == 0U) {
+    EvrRtxThreadError(thread, osRtxErrorThreadNotJoinable);
     return osErrorResource;
   }
 
   // Check object state
   if ((thread->state == osRtxThreadInactive) ||
       (thread->state == osRtxThreadRunning)) {
+    EvrRtxThreadError(thread, osErrorResource);
     return osErrorResource;
   }
 
@@ -1032,9 +1090,12 @@
     if (osRtxThreadWaitEnter(osRtxThreadWaitingJoin, osWaitForever)) {
       thread->thread_join = osRtxThreadGetRunning();
     }
+    EvrRtxThreadJoinPending(thread);
     return osErrorResource;
   }
 
+  EvrRtxThreadJoined(thread);
+
   return osOK;
 }
 
@@ -1054,6 +1115,7 @@
   // Wakeup Thread waiting to Join
   if (thread->thread_join != NULL) {
     osRtxThreadWaitExit(thread->thread_join, (uint32_t)osOK, false);
+    EvrRtxThreadJoined(thread->thread_join);
   }
 
   // Switch to next Ready Thread
@@ -1074,6 +1136,8 @@
     thread->thread_next = osRtxInfo.thread.terminate_list;
     osRtxInfo.thread.terminate_list = thread;
   }
+
+  EvrRtxThreadDestroyed(thread);
 }
 
 /// Terminate execution of a thread.
@@ -1083,6 +1147,7 @@
 
   // Check parameters
   if ((thread == NULL) || (thread->id != osRtxIdThread)) {
+    EvrRtxThreadError(thread, osErrorParameter);
     return osErrorParameter;
   }
 
@@ -1100,6 +1165,7 @@
     case osRtxThreadInactive:
     case osRtxThreadTerminated:
     default:
+      EvrRtxThreadError(thread, osErrorResource);
       return osErrorResource;
   }
 
@@ -1109,12 +1175,14 @@
   // Wakeup Thread waiting to Join
   if (thread->thread_join != NULL) {
     osRtxThreadWaitExit(thread->thread_join, (uint32_t)osOK, false);
+    EvrRtxThreadJoined(thread->thread_join);
   }
 
   // Switch to next Ready Thread when terminating running Thread
   if (thread->state == osRtxThreadRunning) {
     if ((osRtxKernelGetState() != osRtxKernelRunning) ||
         (osRtxInfo.thread.ready.thread_list == NULL)) {
+      EvrRtxThreadError(thread, osErrorResource);
       return osErrorResource;
     }
     thread->sp = __get_PSP();
@@ -1134,6 +1202,8 @@
     osRtxInfo.thread.terminate_list = thread;
   }
 
+  EvrRtxThreadDestroyed(thread);
+
   return osOK;
 }
 
@@ -1158,6 +1228,8 @@
   for (thread = osRtxInfo.thread.wait_list;
        (thread != NULL); thread = thread->delay_next,  count++) {};
 
+  EvrRtxThreadGetCount(count);
+
   return count;
 }
 
@@ -1169,6 +1241,7 @@
 
   // Check parameters
   if ((thread_array == NULL) || (array_items == 0U)) {
+    EvrRtxThreadEnumerate(thread_array, array_items, 0U);
     return 0U;
   }
 
@@ -1194,6 +1267,8 @@
     *thread_array++ = thread;
   }
 
+  EvrRtxThreadEnumerate(thread_array, array_items, count);
+
   return count;
 }
 
@@ -1207,12 +1282,14 @@
   // Check parameters
   if ((thread == NULL) || (thread->id != osRtxIdThread) ||
       ((uint32_t)flags & ~((1U << osRtxThreadFlagsLimit) - 1U))) {
+    EvrRtxThreadError(thread, osErrorParameter);
     return osErrorParameter;
   }
 
   // Check object state
   if ((thread->state == osRtxThreadInactive) ||
       (thread->state == osRtxThreadTerminated)) {
+    EvrRtxThreadError(thread, osErrorResource);
     return osErrorResource;
   }
 
@@ -1229,9 +1306,12 @@
         thread_flags = thread_flags0;
       }
       osRtxThreadWaitExit(thread, (uint32_t)thread_flags0, true);
+      EvrRtxThreadFlagsWaitCompleted(thread->wait_flags, thread->flags_options, thread_flags0);
     }
   }
 
+  EvrRtxThreadFlagsSetDone(thread, thread_flags);
+
   return thread_flags;
 }
 
@@ -1243,23 +1323,28 @@
 
   thread = osRtxThreadGetRunning();
   if (thread == NULL) {
+    EvrRtxThreadError(NULL, osRtxErrorKernelNotRunning);
     return osError;
   }
 
   // Check parameters
   if ((uint32_t)flags & ~((1U << osRtxThreadFlagsLimit) - 1U)) {
+    EvrRtxThreadError(thread, osErrorParameter);
     return osErrorParameter;
   }
 
   // Check object state
   if ((thread->state == osRtxThreadInactive) ||
       (thread->state == osRtxThreadTerminated)) {
+    EvrRtxThreadError(thread, osErrorResource);
     return osErrorResource;
   }
 
   // Clear Thread Flags
   thread_flags = ThreadFlagsClear(thread, flags);
 
+  EvrRtxThreadFlagsClearDone(thread_flags);
+
   return thread_flags;
 }
 
@@ -1270,15 +1355,19 @@
 
   thread = osRtxThreadGetRunning();
   if (thread == NULL) {
+    EvrRtxThreadFlagsGet(0);
     return 0;
   }
 
   // Check object state
   if ((thread->state == osRtxThreadInactive) ||
       (thread->state == osRtxThreadTerminated)) {
+    EvrRtxThreadFlagsGet(0);
     return 0;
   }
 
+  EvrRtxThreadFlagsGet(thread->thread_flags);
+
   return thread->thread_flags;
 }
 
@@ -1290,17 +1379,20 @@
 
   thread = osRtxThreadGetRunning();
   if (thread == NULL) {
+    EvrRtxThreadError(NULL, osRtxErrorKernelNotRunning);
     return osError;
   }
 
   // Check parameters
   if ((uint32_t)flags & ~((1U << osRtxThreadFlagsLimit) - 1U)) {
+    EvrRtxThreadError(thread, osErrorParameter);
     return osErrorParameter;
   }
 
   // Check Thread Flags
   thread_flags = ThreadFlagsCheck(thread, flags, options);
   if (thread_flags > 0) {
+    EvrRtxThreadFlagsWaitCompleted(flags, options, thread_flags);
     return thread_flags;
   }
 
@@ -1311,9 +1403,12 @@
     thread->flags_options = (uint8_t)options;
     // Suspend current Thread
     osRtxThreadWaitEnter(osRtxThreadWaitingThreadFlags, timeout);
+    EvrRtxThreadFlagsWaitPending(flags, options, timeout);
     return osErrorTimeout;
   }
 
+  EvrRtxThreadFlagsWaitNotCompleted(flags, options);
+
   return osErrorResource;
 }
 
@@ -1330,12 +1425,14 @@
   // Check parameters
   if ((thread == NULL) || (thread->id != osRtxIdThread) ||
       ((uint32_t)flags & ~((1U << osRtxThreadFlagsLimit) - 1U))) {
+    EvrRtxThreadError(thread, osErrorParameter);
     return osErrorParameter;
   }
 
   // Check object state
   if ((thread->state == osRtxThreadInactive) ||
       (thread->state == osRtxThreadTerminated)) {
+    EvrRtxThreadError(thread, osErrorResource);
     return osErrorResource;
   }
 
@@ -1345,6 +1442,8 @@
   // Register post ISR processing
   osRtxPostProcess((os_object_t *)thread);
 
+  EvrRtxThreadFlagsSetDone(thread, thread_flags);
+
   return thread_flags;
 }
 
@@ -1353,7 +1452,9 @@
 
 /// Create a thread and add it to Active Threads.
 osThreadId_t osThreadNew (osThreadFunc_t func, void *argument, const osThreadAttr_t *attr) {
+  EvrRtxThreadNew(func, argument, attr);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxThreadError(NULL, osErrorISR);
     return NULL;
   }
   return __svcThreadNew(func, argument, attr);
@@ -1362,6 +1463,7 @@
 /// Get name of a thread.
 const char *osThreadGetName (osThreadId_t thread_id) {
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxThreadGetName(thread_id, NULL);
     return NULL;
   }
   return __svcThreadGetName(thread_id);
@@ -1370,6 +1472,7 @@
 /// Return the thread ID of the current running thread.
 osThreadId_t osThreadGetId (void) {
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxThreadGetId(NULL);
     return NULL;
   }
   return __svcThreadGetId();
@@ -1378,6 +1481,7 @@
 /// Get current thread state of a thread.
 osThreadState_t osThreadGetState (osThreadId_t thread_id) {
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxThreadGetState(thread_id, osThreadError);
     return osThreadError;
   }
   return __svcThreadGetState(thread_id);
@@ -1386,6 +1490,7 @@
 /// Get stack size of a thread.
 uint32_t osThreadGetStackSize (osThreadId_t thread_id) {
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxThreadGetStackSize(thread_id, 0U);
     return 0U;
   }
   return __svcThreadGetStackSize(thread_id);
@@ -1394,6 +1499,7 @@
 /// Get available stack space of a thread based on stack watermark recording during execution.
 uint32_t osThreadGetStackSpace (osThreadId_t thread_id) {
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxThreadGetStackSpace(thread_id, 0U);
     return 0U;
   }
   return __svcThreadGetStackSpace(thread_id);
@@ -1401,7 +1507,9 @@
 
 /// Change priority of a thread.
 osStatus_t osThreadSetPriority (osThreadId_t thread_id, osPriority_t priority) {
+  EvrRtxThreadSetPriority(thread_id, priority);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxThreadError(thread_id, osErrorISR);
     return osErrorISR;
   }
   return __svcThreadSetPriority(thread_id, priority);
@@ -1410,6 +1518,7 @@
 /// Get current priority of a thread.
 osPriority_t osThreadGetPriority (osThreadId_t thread_id) {
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxThreadGetPriority(thread_id, osPriorityError);
     return osPriorityError;
   }
   return __svcThreadGetPriority(thread_id);
@@ -1417,7 +1526,9 @@
 
 /// Pass control to next thread that is in state READY.
 osStatus_t osThreadYield (void) {
+  EvrRtxThreadYield();
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxThreadError(NULL, osErrorISR);
     return osErrorISR;
   }
   return __svcThreadYield();
@@ -1425,7 +1536,9 @@
 
 /// Suspend execution of a thread.
 osStatus_t osThreadSuspend (osThreadId_t thread_id) {
+  EvrRtxThreadSuspend(thread_id);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxThreadError(thread_id, osErrorISR);
     return osErrorISR;
   }
   return __svcThreadSuspend(thread_id);
@@ -1433,7 +1546,9 @@
 
 /// Resume execution of a thread.
 osStatus_t osThreadResume (osThreadId_t thread_id) {
+  EvrRtxThreadResume(thread_id);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxThreadError(thread_id, osErrorISR);
     return osErrorISR;
   }
   return __svcThreadResume(thread_id);
@@ -1441,7 +1556,9 @@
 
 /// Detach a thread (thread storage can be reclaimed when thread terminates).
 osStatus_t osThreadDetach (osThreadId_t thread_id) {
+  EvrRtxThreadDetach(thread_id);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxThreadError(thread_id, osErrorISR);
     return osErrorISR;
   }
   return __svcThreadDetach(thread_id);
@@ -1449,7 +1566,9 @@
 
 /// Wait for specified thread to terminate.
 osStatus_t osThreadJoin (osThreadId_t thread_id) {
+  EvrRtxThreadJoin(thread_id);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxThreadError(thread_id, osErrorISR);
     return osErrorISR;
   }
   return __svcThreadJoin(thread_id);
@@ -1457,13 +1576,17 @@
 
 /// Terminate execution of current running thread.
 __NO_RETURN void osThreadExit (void) {
+  EvrRtxThreadExit();
   __svcThreadExit();
+  EvrRtxThreadError(NULL, osError);
   for (;;);
 }
 
 /// Terminate execution of a thread.
 osStatus_t osThreadTerminate (osThreadId_t thread_id) {
+  EvrRtxThreadTerminate(thread_id);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxThreadError(thread_id, osErrorISR);
     return osErrorISR;
   }
   return __svcThreadTerminate(thread_id);
@@ -1472,7 +1595,8 @@
 /// Get number of active threads.
 uint32_t osThreadGetCount (void) {
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
-    return 0U;                                  // Not allowed in ISR
+    EvrRtxThreadGetCount(0U);
+    return 0U;
   }
   return __svcThreadGetCount();
 }
@@ -1480,13 +1604,15 @@
 /// Enumerate active threads.
 uint32_t osThreadEnumerate (osThreadId_t *thread_array, uint32_t array_items) {
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
-    return 0U;                                  // Not allowed in ISR
+    EvrRtxThreadEnumerate(thread_array, array_items, 0U);
+    return 0U;
   }
   return __svcThreadEnumerate(thread_array, array_items);
 }
 
 /// Set the specified Thread Flags of a thread.
 int32_t osThreadFlagsSet (osThreadId_t thread_id, int32_t flags) {
+  EvrRtxThreadFlagsSet(thread_id, flags);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
     return isrRtxThreadFlagsSet(thread_id, flags);
   } else {
@@ -1496,7 +1622,9 @@
 
 /// Clear the specified Thread Flags of current running thread.
 int32_t osThreadFlagsClear (int32_t flags) {
+  EvrRtxThreadFlagsClear(flags);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxThreadError(NULL, osErrorISR);
     return osErrorISR;
   }
   return __svcThreadFlagsClear(flags);
@@ -1505,14 +1633,17 @@
 /// Get the current Thread Flags of current running thread.
 int32_t osThreadFlagsGet (void) {
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxThreadFlagsGet(0);
     return 0;
-  }                               
+  }
   return __svcThreadFlagsGet();
 }
 
 /// Wait for one or more Thread Flags of the current running thread to become signaled.
 int32_t osThreadFlagsWait (int32_t flags, uint32_t options, uint32_t timeout) {
+  EvrRtxThreadFlagsWait(flags, options, timeout);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxThreadError(NULL, osErrorISR);
     return osErrorISR;
   }
   return __svcThreadFlagsWait(flags, options, timeout);
diff --git a/CMSIS/RTOS2/RTX/Source/rtx_timer.c b/CMSIS/RTOS2/RTX/Source/rtx_timer.c
index 622b518..23552b2 100644
--- a/CMSIS/RTOS2/RTX/Source/rtx_timer.c
+++ b/CMSIS/RTOS2/RTX/Source/rtx_timer.c
@@ -118,6 +118,7 @@
   for (;;) {
     status = osMessageQueueGet(osRtxInfo.timer.mq, &finfo, NULL, osWaitForever);
     if (status == osOK) {
+      EvrRtxTimerCallback(*(osTimerFunc_t)finfo.fp, finfo.arg);
       (*(osTimerFunc_t)finfo.fp)(finfo.arg);
     }
   }
@@ -144,6 +145,7 @@
   if (osRtxInfo.timer.mq == NULL) {
     osRtxInfo.timer.mq = svcRtxMessageQueueNew(osRtxConfig.timer_mq_mcnt, sizeof(os_timer_finfo_t), osRtxConfig.timer_mq_attr);
     if (osRtxInfo.timer.mq == NULL) {
+      EvrRtxTimerError(NULL, osErrorResource);
       return NULL;
     }
   }
@@ -152,12 +154,14 @@
   if (osRtxInfo.timer.thread == NULL) {
     osRtxInfo.timer.thread = svcRtxThreadNew(osRtxTimerThread, NULL, osRtxConfig.timer_thread_attr);
     if (osRtxInfo.timer.thread == NULL) {
+      EvrRtxTimerError(NULL, osErrorResource);
       return NULL;
     }
   }
 
   // Check parameters
   if ((func == NULL) || ((type != osTimerOnce) && (type != osTimerPeriodic))) {
+    EvrRtxTimerError(NULL, osErrorParameter);
     return NULL;
   }
 
@@ -167,10 +171,12 @@
     timer = attr->cb_mem;
     if (timer != NULL) {
       if (((uint32_t)timer & 3U) || (attr->cb_size < sizeof(os_timer_t))) {
+        EvrRtxTimerError(NULL, osRtxErrorInvalidControlBlock);
         return NULL;
       }
     } else {
       if (attr->cb_size != 0U) {
+        EvrRtxTimerError(NULL, osRtxErrorInvalidControlBlock);
         return NULL;
       }
     }
@@ -187,6 +193,7 @@
       timer = osRtxMemoryAlloc(osRtxInfo.mem.common, sizeof(os_timer_t), 1U);
     }
     if (timer == NULL) {
+      EvrRtxTimerError(NULL, osErrorNoMemory);
       return NULL;
     }
     flags = osRtxFlagSystemObject;
@@ -207,6 +214,8 @@
   timer->finfo.fp  = (void *)func;
   timer->finfo.arg = argument;
 
+  EvrRtxTimerCreated(timer);
+
   return timer;
 }
 
@@ -217,14 +226,18 @@
 
   // Check parameters
   if ((timer == NULL) || (timer->id != osRtxIdTimer)) {
+    EvrRtxTimerGetName(timer, NULL);
     return NULL;
   }
 
   // Check object state
   if (timer->state == osRtxObjectInactive) {
+    EvrRtxTimerGetName(timer, NULL);
     return NULL;
   }
 
+  EvrRtxTimerGetName(timer, timer->name);
+
   return timer->name;
 }
 
@@ -235,6 +248,7 @@
 
   // Check parameters
   if ((timer == NULL) || (timer->id != osRtxIdTimer) || (ticks == 0U)) {
+    EvrRtxTimerError(timer, osErrorParameter);
     return osErrorParameter;
   }
 
@@ -249,11 +263,14 @@
       break;
     case osRtxTimerInactive:
     default:
+      EvrRtxTimerError(timer, osErrorResource);
       return osErrorResource;
   }
 
   TimerInsert(timer, ticks);
 
+  EvrRtxTimerStarted(timer);
+
   return osOK;
 }
 
@@ -264,11 +281,13 @@
 
   // Check parameters
   if ((timer == NULL) || (timer->id != osRtxIdTimer)) {
+    EvrRtxTimerError(timer, osErrorParameter);
     return osErrorParameter;
   }
 
   // Check object state
   if (timer->state != osRtxTimerRunning) {
+    EvrRtxTimerError(timer, osErrorResource);
     return osErrorResource;
   }
 
@@ -276,6 +295,8 @@
 
   TimerRemove(timer);
 
+  EvrRtxTimerStopped(timer);
+
   return osOK;
 }
 
@@ -286,14 +307,17 @@
 
   // Check parameters
   if ((timer == NULL) || (timer->id != osRtxIdTimer)) {
+    EvrRtxTimerIsRunning(timer, 0U);
     return 0U;
   }
 
   // Check object state
   if (timer->state == osRtxTimerRunning) {
+    EvrRtxTimerIsRunning(timer, 1U);
     return 1U;
   }
 
+  EvrRtxTimerIsRunning(timer, 0U);
   return 0U;
 }
 
@@ -304,6 +328,7 @@
 
   // Check parameters
   if ((timer == NULL) || (timer->id != osRtxIdTimer)) {
+    EvrRtxTimerError(timer, osErrorParameter);
     return osErrorParameter;
   }
 
@@ -316,6 +341,7 @@
       break;
     case osRtxTimerInactive:
     default:
+      EvrRtxTimerError(timer, osErrorResource);
       return osErrorResource;
   }
 
@@ -331,6 +357,8 @@
     }
   }
 
+  EvrRtxTimerDestroyed(timer);
+
   return osOK;
 }
 
@@ -339,7 +367,9 @@
 
 /// Create and Initialize a timer.
 osTimerId_t osTimerNew (osTimerFunc_t func, osTimerType_t type, void *argument, const osTimerAttr_t *attr) {
+  EvrRtxTimerNew(func, type, argument, attr);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxTimerError(NULL, osErrorISR);
     return NULL;
   }
   return __svcTimerNew(func, type, argument, attr);
@@ -348,6 +378,7 @@
 /// Get name of a timer.
 const char *osTimerGetName (osTimerId_t timer_id) {
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxTimerGetName(timer_id, NULL);
     return NULL;
   }
   return __svcTimerGetName(timer_id);
@@ -355,7 +386,9 @@
 
 /// Start or restart a timer.
 osStatus_t osTimerStart (osTimerId_t timer_id, uint32_t ticks) {
+  EvrRtxTimerStart(timer_id, ticks);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxTimerError(timer_id, osErrorISR);
     return osErrorISR;
   }
   return __svcTimerStart(timer_id, ticks);
@@ -363,7 +396,9 @@
 
 /// Stop a timer.
 osStatus_t osTimerStop (osTimerId_t timer_id) {
+  EvrRtxTimerStop(timer_id);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxTimerError(timer_id, osErrorISR);
     return osErrorISR;
   }
   return __svcTimerStop(timer_id);
@@ -372,6 +407,7 @@
 /// Check if a timer is running.
 uint32_t osTimerIsRunning (osTimerId_t timer_id) {
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxTimerIsRunning(timer_id, 0U);
     return 0U;
   }
   return __svcTimerIsRunning(timer_id);
@@ -379,7 +415,9 @@
 
 /// Delete a timer.
 osStatus_t osTimerDelete (osTimerId_t timer_id) {
+  EvrRtxTimerDelete(timer_id);
   if (IS_IRQ_MODE() || IS_IRQ_MASKED()) {
+    EvrRtxTimerError(timer_id, osErrorISR);
     return osErrorISR;
   }
   return __svcTimerDelete(timer_id);