/** 
\defgroup rtx_evr Event functions
\ingroup rtx5_specific 
\brief RTX5 Event Recorder functions
\details
RTX5 interfaces to the <a href="https://www.keil.com/pack/doc/compiler/EventRecorder/html/index.html" target="_blank"><b>Event Recorder</b></a> 
to provide event information which helps you to understand and analyze the operation.

To use the Event Recorder together with RTX5, it is required to create an image that generates event information. 
The steps are described under \ref cre_rtx_proj_er.

@{
*/

/**
\defgroup rtx_evr_memory Memory Functions
\brief Events generated memory functions 
\details
@{
*/

/**
\fn void EvrRtxMemoryInit (void *mem, uint32_t size, uint32_t result)
\details
The event \b MemoryInit is generated when initialization of a variable size memory block completes.

\b Value in the Event Recorder shows:
  - \b mem : memory address of memory pool.
  - \b size : size of a memory pool in bytes.
  - \b result : execution status: 1 - success, 0 - failure.
*/

/**
\fn void EvrRtxMemoryAlloc (void *mem, uint32_t size, uint32_t type, void *block)
\details
The event \b MemoryAlloc is generated when allocation of a variable size memory block completes.

\b Value in the Event Recorder shows:
  - \b mem : memory address of memory pool.
  - \b size : size of a memory block in bytes.
  - \b type : memory block type: 0 - generic, 1 - control block
  - \b block : memory address of allocated memory block or 0 in case of no memory is available.
*/

/**
\fn void EvrRtxMemoryFree (void *mem, void *block, uint32_t result)
\details
The event \b MemoryFree is generated when deallocation of a variable size memory block completes.

\b Value in the Event Recorder shows:
  - \b mem : memory address of memory pool.
  - \b block : memory address of block to be returned to the memory pool.
  - \b result : execution status: 1 - success, 0 - failure.
*/

/**
\fn void EvrRtxMemoryBlockInit (osRtxMpInfo_t *mp_info, uint32_t block_count, uint32_t block_size, void *block_mem)
\details
The event \b MemoryBlockInit is generated when initialization of a fixed size memory block completes.

\b Value in the Event Recorder shows:
  - \b mp_info : memory address of memory pool info.
  - \b block_count : maximum number of memory blocks in memory pool.
  - \b block_size : size of a memory block in bytes.
  - \b block_mem : memory address of memory for block storage.
*/

/**
\fn void EvrRtxMemoryBlockAlloc (osRtxMpInfo_t *mp_info, void *block)
\details
The event \b MemoryBlockAlloc is generated when allocation of a fixed size memory block completes.

\b Value in the Event Recorder shows:
  - \b mp_info : memory address of memory pool info.
  - \b block : memory address of the allocated memory block or 0 in case of no memory is available.
*/

/**
\fn void EvrRtxMemoryBlockFree (osRtxMpInfo_t *mp_info, void *block, int32_t status)
\details
The event \b MemoryBlockFree is generated when deallocation of a fixed size memory block completes.

\b Value in the Event Recorder shows:
  - \b mp_info : memory address of memory pool info.
  - \b block : memory address of the allocated memory block to be returned to the memory pool.
  - \b status : execution status \ref osStatus_t
*/

/**
@}
*/

/**
\defgroup rtx_evr_kernel Kernel Functions
\brief Events generated by kernel functions 
\details
@{
*/

/**
\fn void EvrRtxKernelError (int32_t status)
\details
The event \b KernelError is generated when \ref CMSIS_RTOS_KernelCtrl routines complete their execution due to an error.

The status parameter indicates the execution status and can be one of the \ref osStatus_t "osStatus_t codes" or one
of the extended execution status codes which are summarized in the table below.

|      Extended Status Code     | Description |
|:------------------------------|:------------|
| osRtxErrorKernelNotReady      | Kernel scheduler is not in Ready state. |
| osRtxErrorKernelNotRunning    | Kernel scheduler is not executing - there is no running thread. |
| osRtxErrorInvalidControlBlock | Object control block with invalid alignment or size was specified. |
| osRtxErrorInvalidDataMemory   | Object data memory with invalid alignment or size was specified. |
| osRtxErrorInvalidThreadStack  | Thread stack memory with invalid alignment or size was specified. |
| osRtxErrorInvalidPriority     | Invalid thread priority was specified. |
| osRtxErrorThreadNotJoinable   | Specified thread is not joinable. |
| osRtxErrorMutexNotOwned       | Specified mutex is not owned by the current running thread. |
| osRtxErrorMutexNotLocked      | Specified mutex is not locked. |
| osRtxErrorMutexLockLimit      | Maximum number of recursive mutex locks reached. |
| osRtxErrorSemaphoreCountLimit | Semaphore count limit reached. |
| osRtxErrorTZ_InitContext_S    | Secure context memory system initialization failed. |
| osRtxErrorTZ_AllocContext_S   | Secure context memory allocation failed. |
| osRtxErrorTZ_FreeContext_S    | Secure context memory deallocation failed. |
| osRtxErrorTZ_LoadContext_S    | Secure context load failed. |
| osRtxErrorTZ_SaveContext_S    | Secure context save failed. |

\b Value in the Event Recorder shows:
  - \b status : execution status code.
*/

/**
\fn void EvrRtxKernelInitialize (void)
\details
The event \b KernelInitialize is generated when the function \ref osKernelInitialize is called.
*/

/**
\fn void EvrRtxKernelInitialized (void)
\details
The event \b KernelInitialized is generated when the function \ref osKernelInitialize successfully initializes the RTOS kernel.
*/

/**
\fn void EvrRtxKernelGetInfo (osVersion_t *version, char *id_buf, uint32_t id_size)
\details
The event \b KernelGetInfo is generated when the function \ref osKernelGetInfo is called.

\b Value in the Event Recorder shows:
  - \b version : memory address of buffer for retrieving version information.
  - \b id_buf : memory address of buffer for retrieving kernel identification string.
  - \b id_size : size of id_buf in bytes.
*/

/**
\fn void EvrRtxKernelInfoRetrieved (const osVersion_t *version, const char *id_buf, uint32_t id_size)
\details
The event \b KernelInfoRetrieved is generated when the function \ref osKernelGetInfo successfully retrieves kernel information.

\b Value in the Event Recorder shows:
  - \b ver_api : API version.
  - \b ver_kernel : kernel version.
  - \b id : kernel identification string (Detail).
*/

/**
\fn void EvrRtxKernelGetState (osKernelState_t state)
\details
The event \b KernelGetState is generated when the function \ref osKernelGetState is called and its execution result is known.

\b Value in the Event Recorder shows:
  - \b state : retrieved current \ref osKernelState_t "RTOS Kernel state".
*/

/**
\fn void EvrRtxKernelStart (void)
\details
The event \b KernelStart is generated when the function \ref osKernelStart is called.
*/

/**
\fn void EvrRtxKernelStarted (void)
\details
The event \b KernelStarted is generated when the function \ref osKernelStart successfully starts the RTOS kernel execution.
*/

/**
\fn void EvrRtxKernelLock (void)
\details
The event \b KernelLock is generated when the function \ref osKernelLock is called.
*/

/**
\fn void EvrRtxKernelLocked (int32_t lock)
\details
The event \b KernelLocked is generated when the functions \ref osKernelLock successfully completes its execution.

\b Value in the Event Recorder shows:
  - \b lock : previous lock state (1 - locked, 0 - not locked).
*/

/**
\fn void EvrRtxKernelUnlock (void)
\details
The event \b KernelUnlock is generated when the function \ref osKernelUnlock is called.
*/

/**
\fn void EvrRtxKernelUnlocked (int32_t lock)
\details
The event \b KernelUnlocked is generated when the function \ref osKernelUnlock successfully completes its execution.

\b Value in the Event Recorder shows:
  - \b lock : previous lock state (1 - locked, 0 - not locked).
*/

/**
\fn void EvrRtxKernelRestoreLock (int32_t lock)
\details
The event \b KernelRestoreLock is generated when the function \ref osKernelRestoreLock is called.

\b Value in the Event Recorder shows:
  - \b lock : lock state obtained by \ref osKernelLock or \ref osKernelUnlock.
*/

/**
\fn void EvrRtxKernelLockRestored (int32_t lock)
\details
The event \b KernelLockRestored is generated when the function \ref osKernelRestoreLock successfully completes its execution.

\b Value in the Event Recorder shows:
  - \b lock : new lock state (1 - locked, 0 - not locked).
*/

/**
\fn void EvrRtxKernelSuspend (void)
\details
The event \b KernelSuspend is generated when the function \ref osKernelSuspend is called.
*/

/**
\fn void EvrRtxKernelSuspended (uint32_t sleep_ticks)
\details
The event \b KernelSuspended is generated when the function \ref osKernelSuspend successfully suspends RTOS kernel execution.

\b Value in the Event Recorder shows:
  - \b sleep_ticks : time in ticks, for how long the system can sleep or power-down.
*/

/**
\fn void EvrRtxKernelResume (uint32_t sleep_ticks)
\details
The event \b KernelResume is generated when the function \ref osKernelResume is called.

\b Value in the Event Recorder shows:
  - \b sleep_ticks : time in ticks, for how long the system was in sleep or power-down mode.
*/

/**
\fn void EvrRtxKernelResumed (void)
\details
The event \b KernelResumed is generated when the function \ref osKernelResume successfully resumes RTOS kernel execution.
*/

/**
\fn void EvrRtxKernelGetTickCount (uint32_t count)
\details
The event \b KernelGetTickCount is generated when the function \ref osKernelGetTickCount is called.

\b Value in the Event Recorder shows:
  - \b count : retrieved kernel current tick count.
*/

/**
\fn void EvrRtxKernelGetTickFreq (uint32_t freq)
\details
The event \b KernelGetTickFreq is generated when the function \ref osKernelGetTickFreq called.

\b Value in the Event Recorder shows:
  - \b freq : retrieved frequency of the kernel tick in Hz.
*/

/**
\fn void EvrRtxKernelGetSysTimerCount (uint32_t count)
\details
The event \b KernelGetSysTimerCount is generated when the function \ref osKernelGetSysTimerCount is called.

\b Value in the Event Recorder shows:
  - \b count : retrieved kernel current system timer count as 32-bit value.
*/

/**
\fn void EvrRtxKernelGetSysTimerFreq (uint32_t freq)
\details
The event \b KernelGetSysTimerFreq is generated when the function \ref osKernelGetSysTimerFreq is called.

\b Value in the Event Recorder shows:
  - \b freq : retrieved frequency of the system timer in Hz.
*/

/**
@}
*/

/**
\defgroup rtx_evr_thread Thread Functions
\brief Events generated by thread functions 
\details
@{
*/

/**
\fn void EvrRtxThreadError (osThreadId_t thread_id, int32_t status)
\details
The event \b ThreadError is generated when \ref CMSIS_RTOS_ThreadMgmt routines complete their execution due to an error.

The status parameter indicates the execution status and can be one of the \ref osStatus_t "osStatus_t codes" or one
of the extended execution status codes which are summarized in the table below.

|      Extended Status Code     | Description |
|:------------------------------|:------------|
| osRtxErrorKernelNotReady      | Kernel scheduler is not in Ready state. |
| osRtxErrorKernelNotRunning    | Kernel scheduler is not executing - there is no running thread. |
| osRtxErrorInvalidControlBlock | Object control block with invalid alignment or size was specified. |
| osRtxErrorInvalidDataMemory   | Object data memory with invalid alignment or size was specified. |
| osRtxErrorInvalidThreadStack  | Thread stack memory with invalid alignment or size was specified. |
| osRtxErrorInvalidPriority     | Invalid thread priority was specified. |
| osRtxErrorThreadNotJoinable   | Specified thread is not joinable. |
| osRtxErrorMutexNotOwned       | Specified mutex is not owned by the current running thread. |
| osRtxErrorMutexNotLocked      | Specified mutex is not locked. |
| osRtxErrorMutexLockLimit      | Maximum number of recursive mutex locks reached. |
| osRtxErrorSemaphoreCountLimit | Semaphore count limit reached. |
| osRtxErrorTZ_InitContext_S    | Secure context memory system initialization failed. |
| osRtxErrorTZ_AllocContext_S   | Secure context memory allocation failed. |
| osRtxErrorTZ_FreeContext_S    | Secure context memory deallocation failed. |
| osRtxErrorTZ_LoadContext_S    | Secure context load failed. |
| osRtxErrorTZ_SaveContext_S    | Secure context save failed. |

\b Value in the Event Recorder shows:
  - \b thread_id : thread ID.
  - \b status : execution status code.
*/

/**
\fn void EvrRtxThreadNew (osThreadFunc_t func, void *argument, const osThreadAttr_t *attr)
\details
The event \b ThreadNew is generated when the function \ref osThreadNew is called.

\b Value in the Event Recorder shows:
  - \b func : memory address of thread function. 
  - \b argument : memory address of thread function start argument.
  - \b attr : memory address of Thread attributes or 0 when they are not specified.
*/

/**
\fn void EvrRtxThreadCreated (osThreadId_t thread_id, uint32_t thread_addr, const char *name)
\details
The event \b ThreadCreated is generated when the function \ref osThreadNew successfully creates a thread object.

\b Value in the Event Recorder shows:
  - \b thread_id : thread ID.
*/

/**
\fn void EvrRtxThreadGetName (osThreadId_t thread_id, const char *name)
\details
The event \b ThreadGetName is generated when the function \ref osThreadGetName is called and its execution result is known.

\b Value in the Event Recorder shows:
  - \b thread_id : thread ID.
  - \b name : retrieved memory address of name string (0 in case of a failure).
*/

/**
\fn void EvrRtxThreadGetId (osThreadId_t thread_id)
\details
The event \b ThreadGetId is generated when the function \ref osThreadGetId is called and its execution result is known.

\b Value in the Event Recorder shows:
  - \b thread_id : retrieved thread (0 in case of a failure).
*/

/**
\fn void EvrRtxThreadGetState (osThreadId_t thread_id, osThreadState_t state)
\details
The event \b ThreadGetState is generated when the function \ref osThreadGetState is called and its execution result is known.

\b Value in the Event Recorder shows:
  - \b thread_id : thread ID.
  - \b state : retrieved current thread state.
*/

/**
\fn void EvrRtxThreadGetStackSize (osThreadId_t thread_id, uint32_t stack_size)
\details
The event \b ThreadGetStackSize is generated when the function \ref osThreadGetStackSize is called and its execution result is known.

\b Value in the Event Recorder shows:
  - \b thread_id : thread ID.
  - \b stack_size : retrieved remaining stack space in bytes (0 in case of a failure). 
*/

/**
\fn void EvrRtxThreadGetStackSpace (osThreadId_t thread_id, uint32_t stack_space)
\details
The event \b ThreadGetStackSpace is generated when the function \ref osThreadGetStackSpace is called and its execution result is known.

\b Value in the Event Recorder shows:
  - \b thread_id : thread ID.
  - \b stack_space : retrieved remaining stack space in bytes (0 in case of a failure).
*/

/**
\fn void EvrRtxThreadSetPriority (osThreadId_t thread_id, osPriority_t priority)
\details
The event \b ThreadSetPriority is generated when the function \ref osThreadSetPriority is called.

\b Value in the Event Recorder shows:
  - \b thread_id : thread ID.
  - \b priority : new priority value for the thread function. 
*/

/**
\fn void EvrRtxThreadPriorityUpdated (osThreadId_t thread_id, osPriority_t priority)
\details
The event \b ThreadPriorityUpdated is generated when the function \ref osThreadSetPriority successfully updated the specified thread priority.

\b Value in the Event Recorder shows:
  - \b thread_id : thread ID.
  - \b priority : new priority value for the thread function. 
*/

/**
\fn void EvrRtxThreadGetPriority (osThreadId_t thread_id, osPriority_t priority)
\details
The event \b ThreadGetPriority is generated when the function \ref osThreadGetPriority is called and its execution result is known.

\b Value in the Event Recorder shows:
  - \b thread_id : thread ID.
  - \b priority : current priority value of the specified thread.
*/

/**
\fn void EvrRtxThreadYield (void)
\details
The event \b ThreadYield is generated when the function \ref osThreadYield is called.
*/

/**
\fn void EvrRtxThreadSuspend (osThreadId_t thread_id)
\details
The event \b ThreadSuspend is generated when the function \ref osThreadSuspend is called.

\b Value in the Event Recorder shows:
  - \b thread_id : thread ID.
*/

/**
\fn void EvrRtxThreadSuspended (osThreadId_t thread_id)
\details
The event \b ThreadSuspended is generated when the function \ref osThreadSuspend successfully suspends the specified thread.

\b Value in the Event Recorder shows:
  - \b thread_id : thread ID.
*/

/**
\fn void EvrRtxThreadResume (osThreadId_t thread_id)
\details
The event \b ThreadResume is generated when the function \ref osThreadResume is called.

\b Value in the Event Recorder shows:
  - \b thread_id : thread ID.
*/

/**
\fn void EvrRtxThreadResumed (osThreadId_t thread_id)
\details
The event \b ThreadResumed is generated when the function \ref osThreadResume successfully resumes the specified thread.

\b Value in the Event Recorder shows:
  - \b thread_id : thread ID.
*/

/**
\fn void EvrRtxThreadDetach (osThreadId_t thread_id)
\details
The event \b ThreadDetach is generated when the function \ref osThreadDetach is called.

\b Value in the Event Recorder shows:
  - \b thread_id : thread ID.
*/

/**
\fn void EvrRtxThreadDetached (osThreadId_t thread_id)
\details
The event \b ThreadDetached is generated when the function \ref osThreadDetach successfully detaches the specified thread.

\b Value in the Event Recorder shows:
  - \b thread_id : thread ID.
*/

/**
\fn void EvrRtxThreadJoin (osThreadId_t thread_id)
\details
The event \b ThreadJoin is generated when the function \ref osThreadJoin is called.

\b Value in the Event Recorder shows:
  - \b thread_id : thread ID.
*/

/**
\fn void EvrRtxThreadJoinPending (osThreadId_t thread_id)
\details
The event \b ThreadJoinPending is generated when the function \ref osThreadJoin suspends current running thread until the specified thread terminates.

\b Value in the Event Recorder shows:
  - \b thread_id : thread ID.
*/

/**
\fn void EvrRtxThreadJoined (osThreadId_t thread_id)
\details
The event \b ThreadJoined is generated when the function \ref osThreadJoin successfully joins the specified thread.

\b Value in the Event Recorder shows:
  - \b thread_id : thread ID.
*/

/**
\fn void EvrRtxThreadBlocked (osThreadId_t thread_id, uint32_t timeout)
\details
The event \b ThreadBlocked is generated when the current running thread execution is blocked.

\b Value in the Event Recorder shows:
  - \b thread_id : thread ID.
  - \b timeout : \ref CMSIS_RTOS_TimeOutValue.
*/

/**
\fn void EvrRtxThreadUnblocked (osThreadId_t thread_id, uint32_t ret_val)
\details
The event \b ThreadUnblocked is generated when the blocked thread execution is unblocked.

\b Value in the Event Recorder shows:
  - \b thread_id : thread ID.
  - \b ret_val : 
*/

/**
\fn void EvrRtxThreadPreempted (osThreadId_t thread_id)
\details
The event \b ThreadPreempted is generated when current running thread execution is preempted.

\b Value in the Event Recorder shows:
  - \b thread_id : thread ID.
*/

/**
\fn void EvrRtxThreadSwitched (osThreadId_t thread_id)
\details
The event \b ThreadSwitched is generated when current running thread execution switches.

\b Value in the Event Recorder shows:
  - \b thread_id : thread ID.
*/

/**
\fn void EvrRtxThreadExit (void)
\details
The event \b ThreadExit is generated when the function \ref osThreadExit is called.
*/

/**
\fn void EvrRtxThreadTerminate (osThreadId_t thread_id)
\details
The event \b ThreadTerminate is generated when the function \ref osThreadTerminate is called.

\b Value in the Event Recorder shows:
  - \b thread_id : thread ID.
*/

/**
\fn void EvrRtxThreadDestroyed (osThreadId_t thread_id)
\details
The event \b ThreadDestroyed is generated when the function \ref osThreadExit or \ref osThreadTerminate successfully terminates the thread.

\b Value in the Event Recorder shows:
  - \b thread_id : thread ID.
*/

/**
\fn void EvrRtxThreadGetCount (uint32_t count)
\details
The event \b ThreadGetCount is generated when the function \ref osThreadGetCount is called and its execution result is known.

\b Value in the Event Recorder shows:
  - \b count : retrieved number of active threads (0 in case of a failure).
*/

/**
\fn void EvrRtxThreadEnumerate (osThreadId_t *thread_array, uint32_t array_items, uint32_t count)
\details
The event \b ThreadEnumerate is generated when the function \ref osThreadEnumerate is called and its execution result is known.

\b Value in the Event Recorder shows:
  - \b thread_array : memory address of array for retrieving thread IDs.
  - \b array_items : maximum number of items in thread_array.
  - \b count : number of enumerated threads (0 in case of a failure).
*/

/**
@}
*/

/**
\defgroup rtx_evr_wait Generic Wait Functions
\brief Events generated by generic wait functions 
\details
@{
*/

/**
\fn void EvrRtxDelayError (int32_t status)
\details
The event \b DelayError is generated when \ref CMSIS_RTOS_Wait routines complete their execution due to an error.

The status parameter indicates the execution status and can be one of the \ref osStatus_t "osStatus_t codes" or one
of the extended execution status codes which are summarized in the table below.

|      Extended Status Code     | Description |
|:------------------------------|:------------|
| osRtxErrorKernelNotReady      | Kernel scheduler is not in Ready state. |
| osRtxErrorKernelNotRunning    | Kernel scheduler is not executing - there is no running thread. |
| osRtxErrorInvalidControlBlock | Object control block with invalid alignment or size was specified. |
| osRtxErrorInvalidDataMemory   | Object data memory with invalid alignment or size was specified. |
| osRtxErrorInvalidThreadStack  | Thread stack memory with invalid alignment or size was specified. |
| osRtxErrorInvalidPriority     | Invalid thread priority was specified. |
| osRtxErrorThreadNotJoinable   | Specified thread is not joinable. |
| osRtxErrorMutexNotOwned       | Specified mutex is not owned by the current running thread. |
| osRtxErrorMutexNotLocked      | Specified mutex is not locked. |
| osRtxErrorMutexLockLimit      | Maximum number of recursive mutex locks reached. |
| osRtxErrorSemaphoreCountLimit | Semaphore count limit reached. |
| osRtxErrorTZ_InitContext_S    | Secure context memory system initialization failed. |
| osRtxErrorTZ_AllocContext_S   | Secure context memory allocation failed. |
| osRtxErrorTZ_FreeContext_S    | Secure context memory deallocation failed. |
| osRtxErrorTZ_LoadContext_S    | Secure context load failed. |
| osRtxErrorTZ_SaveContext_S    | Secure context save failed. |

\b Value in the Event Recorder shows:
  - \b status : execution status code.
*/

/**
\fn void EvrRtxDelay (uint32_t ticks)
\details
The event \b Delay is generated when the function \ref osDelay is called.

\b Value in the Event Recorder shows:
  - \b ticks : \ref CMSIS_RTOS_TimeOutValue "time ticks" value. 
*/

/**
\fn void EvrRtxDelayUntil (uint32_t ticks)
\details
The event \b DelayUntil is generated when the function \ref osDelayUntil is called.

\b Value in the Event Recorder shows:
  - \b ticks : absolute delay time in ticks.
*/

/**
\fn void EvrRtxDelayStarted (uint32_t ticks)
\details
The event \b DelayStarted is generated when \ref osDelay delay starts.

\b Value in the Event Recorder shows:
  - \b ticks : \ref CMSIS_RTOS_TimeOutValue "time ticks" value. 
*/

/**
\fn void EvrRtxDelayUntilStarted (uint32_t ticks)
\details
The event \b DelayUntilStarted is generated when \ref osDelayUntil delay starts.

\b Value in the Event Recorder shows:
  - \b ticks : \ref CMSIS_RTOS_TimeOutValue "time ticks" value. 
*/

/**
\fn void EvrRtxDelayCompleted (osThreadId_t thread_id)
\details
The event \b DelayCompleted is generated when \ref osDelay or \ref osDelayUntil delay expires.

\b Value in the Event Recorder shows:
  - \b thread_id : thread ID.
*/

/**
@}
*/

/**
\defgroup rtx_evr_thread_flags Thread Flags Functions
\brief Events generated by thread flags functions 
\details
@{
*/

/**
\fn void EvrRtxThreadFlagsError (osThreadId_t thread_id, int32_t status)
\details
The event \b ThreadFlagsError is generated when \ref CMSIS_RTOS_ThreadFlagsMgmt routines complete their execution due to an error.

The status parameter indicates the execution status and can be one of the \ref osStatus_t "osStatus_t codes" or one
of the extended execution status codes which are summarized in the table below.

|      Extended Status Code     | Description |
|:------------------------------|:------------|
| osRtxErrorKernelNotReady      | Kernel scheduler is not in Ready state. |
| osRtxErrorKernelNotRunning    | Kernel scheduler is not executing - there is no running thread. |
| osRtxErrorInvalidControlBlock | Object control block with invalid alignment or size was specified. |
| osRtxErrorInvalidDataMemory   | Object data memory with invalid alignment or size was specified. |
| osRtxErrorInvalidThreadStack  | Thread stack memory with invalid alignment or size was specified. |
| osRtxErrorInvalidPriority     | Invalid thread priority was specified. |
| osRtxErrorThreadNotJoinable   | Specified thread is not joinable. |
| osRtxErrorMutexNotOwned       | Specified mutex is not owned by the current running thread. |
| osRtxErrorMutexNotLocked      | Specified mutex is not locked. |
| osRtxErrorMutexLockLimit      | Maximum number of recursive mutex locks reached. |
| osRtxErrorSemaphoreCountLimit | Semaphore count limit reached. |
| osRtxErrorTZ_InitContext_S    | Secure context memory system initialization failed. |
| osRtxErrorTZ_AllocContext_S   | Secure context memory allocation failed. |
| osRtxErrorTZ_FreeContext_S    | Secure context memory deallocation failed. |
| osRtxErrorTZ_LoadContext_S    | Secure context load failed. |
| osRtxErrorTZ_SaveContext_S    | Secure context save failed. |

\b Value in the Event Recorder shows:
  - \b thread_id : thread ID.
  - \b status : execution status code.
*/

/**
\fn void EvrRtxThreadFlagsSet (osThreadId_t thread_id, uint32_t flags)
\details
The event \b ThreadFlagsSet is generated when the function \ref osThreadFlagsSet is called.

\b Value in the Event Recorder shows:
  - \b thread_id : thread ID.
  - \b flags : flags that shall be set.
*/

/**
\fn void EvrRtxThreadFlagsSetDone (osThreadId_t thread_id, uint32_t thread_flags)
\details
The event \b ThreadFlagsSetDone is generated when thread flags are successfully set.

\b Value in the Event Recorder shows:
  - \b thread_id : thread ID.
  - \b thread_flags : thread flags after setting.
*/

/**
\fn void EvrRtxThreadFlagsClear (uint32_t flags)
\details
The event \b ThreadFlagsClear is generated when the function \ref osThreadFlagsClear is called.

\b Value in the Event Recorder shows:
  - \b flags : flags that shall be cleared. 
*/

/**
\fn void EvrRtxThreadFlagsClearDone (uint32_t thread_flags)
\details
The event \b ThreadFlagsClearDone is generated when the function \ref osThreadFlagsClear successfully clears thread flags.

\b Value in the Event Recorder shows:
  - \b thread_flags : thread flags before clearing.
*/

/**
\fn void EvrRtxThreadFlagsGet (uint32_t thread_flags)
\details
The event \b ThreadFlagsGet is generated when the function \ref osThreadFlagsGet is called and its execution result is known.

\b Value in the Event Recorder shows:
  - \b thread_flags : current thread flags.
*/

/**
\fn void EvrRtxThreadFlagsWait (uint32_t flags, uint32_t options, uint32_t timeout)
\details
The event \b ThreadFlagsWait is generated when the function \ref osThreadFlagsWait is called.

\b Value in the Event Recorder shows:
  - \b flags : flags to wait for.
  - \b options : flags options (refer to \ref osThreadFlagsWait "thread flags options").
  - \b timeout : \ref CMSIS_RTOS_TimeOutValue.
*/

/**
\fn void EvrRtxThreadFlagsWaitPending (uint32_t flags, uint32_t options, uint32_t timeout)
\details
The event \b ThreadFlagsWaitPending is generated when the function \ref osThreadFlagsWait starts waiting for thread flags to become signaled.

\b Value in the Event Recorder shows:
  - \b flags : flags to wait for.
  - \b options : flags options (refer to \ref osThreadFlagsWait "thread flags options").
  - \b timeout : \ref CMSIS_RTOS_TimeOutValue.
*/

/**
\fn void EvrRtxThreadFlagsWaitTimeout (osThreadId_t thread_id)
\details
The event \b ThreadFlagsWaitTimeout is generated when wait for thread flags to become signaled is aborted due to expired wait timeout.

\b Value in the Event Recorder shows:
  - \b thread_id : thread ID.
*/

/**
\fn void EvrRtxThreadFlagsWaitCompleted (uint32_t flags, uint32_t options, uint32_t thread_flags, osThreadId_t thread_id)
\details
The event \b ThreadFlagsWaitCompleted is generated when waiting for thread flags ends because requested flags were signaled.

\b Value in the Event Recorder shows:
  - \b flags : flags thread was waiting for.
  - \b option : flags options (refer to \ref osThreadFlagsWait "thread flags options").
  - \b thread_flags : thread flags before clearing.
  - \b thread_id : thread ID.
*/

/**
\fn void EvrRtxThreadFlagsWaitNotCompleted (uint32_t flags, uint32_t options)
\details
The event \b ThreadFlagsWaitNotCompleted is generated when the function \ref osThreadFlagsWait returns without timeout and specified thread flags were not signaled.

\b Value in the Event Recorder shows:
  - \b flags : flags thread was waiting for.
  - \b options : flags options (refer to \ref osThreadFlagsWait "thread flags options").
*/

/**
@}
*/

/**
\defgroup rtx_evr_event_flags Event Flags Functions
\brief Events generated by event flag functions 
\details
@{
*/

/**
\fn void EvrRtxEventFlagsError (osEventFlagsId_t ef_id, int32_t status)
\details
The event \b EventFlagsError is generated when \ref CMSIS_RTOS_EventFlags routines complete their execution due to an error.

The status parameter indicates the execution status and can be one of the \ref osStatus_t "osStatus_t codes" or one
of the extended execution status codes which are summarized in the table below.

|      Extended Status Code     | Description |
|:------------------------------|:------------|
| osRtxErrorKernelNotReady      | Kernel scheduler is not in Ready state. |
| osRtxErrorKernelNotRunning    | Kernel scheduler is not executing - there is no running thread. |
| osRtxErrorInvalidControlBlock | Object control block with invalid alignment or size was specified. |
| osRtxErrorInvalidDataMemory   | Object data memory with invalid alignment or size was specified. |
| osRtxErrorInvalidThreadStack  | Thread stack memory with invalid alignment or size was specified. |
| osRtxErrorInvalidPriority     | Invalid thread priority was specified. |
| osRtxErrorThreadNotJoinable   | Specified thread is not joinable. |
| osRtxErrorMutexNotOwned       | Specified mutex is not owned by the current running thread. |
| osRtxErrorMutexNotLocked      | Specified mutex is not locked. |
| osRtxErrorMutexLockLimit      | Maximum number of recursive mutex locks reached. |
| osRtxErrorSemaphoreCountLimit | Semaphore count limit reached. |
| osRtxErrorTZ_InitContext_S    | Secure context memory system initialization failed. |
| osRtxErrorTZ_AllocContext_S   | Secure context memory allocation failed. |
| osRtxErrorTZ_FreeContext_S    | Secure context memory deallocation failed. |
| osRtxErrorTZ_LoadContext_S    | Secure context load failed. |
| osRtxErrorTZ_SaveContext_S    | Secure context save failed. |

\b Value in the Event Recorder shows:
  - \b ef_id : event flags ID.
  - \b status : execution status code.
*/

/**
\fn void EvrRtxEventFlagsNew (const osEventFlagsAttr_t *attr)
\details
The event \b EventFlagsNew is generated when the function \ref osEventFlagsNew is called.

\b Value in the Event Recorder shows:
  - \b attr : memory address of Event Flags attributes or 0 when they are not specified.
*/

/**
\fn void EvrRtxEventFlagsCreated (osEventFlagsId_t ef_id, const char *name)
\details
The event \b EventFlagsCreated is generated when the function \ref osEventFlagsNew successfully creates a event flags object.

\b Value in the Event Recorder shows:
  - \b ef_id : event flags ID.
*/

/**
\fn void EvrRtxEventFlagsGetName (osEventFlagsId_t ef_id, const char *name)
\details
The event \b EventFlagsGetName is generated when the function \ref osEventFlagsGetName is called and its execution result is known.

\b Value in the Event Recorder shows:
  - \b ef_id : event flags ID.
  - \b name : retrieved memory address of name string (0 in case of a failure).
*/

/**
\fn void EvrRtxEventFlagsSet (osEventFlagsId_t ef_id, uint32_t flags)
\details
The event \b EventFlagsSet is generated when the function \ref osEventFlagsSet is called.

\b Value in the Event Recorder shows:
  - \b ef_id : event flags ID.
  - \b flags : flags that shall be set.
*/

/**
\fn void EvrRtxEventFlagsSetDone (osEventFlagsId_t ef_id, uint32_t event_flags)
\details
The event \b EventFlagsSetDone is generated when event flags are successfully set.

\b Value in the Event Recorder shows:
  - \b ef_id : event flags ID.
  - \b event_flags : event flags after setting.
*/

/**
\fn void EvrRtxEventFlagsClear (osEventFlagsId_t ef_id, uint32_t flags)
\details
The event \b EventFlagsClear is generated when the function \ref osEventFlagsClear is called.

\b Value in the Event Recorder shows:
  - \b ef_id : event flags ID.
  - \b flags : flags that shall be cleared.
*/

/**
\fn void EvrRtxEventFlagsClearDone (osEventFlagsId_t ef_id, uint32_t event_flags)
\details
The event \b EventFlagsClearDone is generated when the function \ref osEventFlagsClear successfully clears the event flags.

\b Value in the Event Recorder shows:
  - \b ef_id : event flags ID.
  - \b event_flags : event flags before clearing.
*/

/**
\fn void EvrRtxEventFlagsGet (osEventFlagsId_t ef_id, uint32_t event_flags)
\details
The event \b EventFlagsGet is generated when the function \ref osEventFlagsGet is called and its execution result is known.

\b Value in the Event Recorder shows:
  - \b ef_id : event flags ID.
  - \b event_flags : retrieved current event flags.
*/

/**
\fn void EvrRtxEventFlagsWait (osEventFlagsId_t ef_id, uint32_t flags, uint32_t options, uint32_t timeout)
\details
The event \b EventFlagsWait is generated when the function \ref osEventFlagsWait is called.

\b Value in the Event Recorder shows:
  - \b ef_id : event flags ID.
  - \b flags : flags to wait for. 
  - \b options : flags options (refer to \ref osEventFlagsWait "event flags options").
  - \b timeout : \ref CMSIS_RTOS_TimeOutValue.
*/

/**
\fn void EvrRtxEventFlagsWaitPending (osEventFlagsId_t ef_id, uint32_t flags, uint32_t options, uint32_t timeout)
\details
The event \b EventFlagsWaitPending is generated when the function \ref osEventFlagsWait starts waiting for event flags to become signaled.

\b Value in the Event Recorder shows:
  - \b ef_id : event flags ID.
  - \b flags : flags to wait for.
  - \b options : flags options (refer to \ref osEventFlagsWait "event flags options").
  - \b timeout : \ref CMSIS_RTOS_TimeOutValue.
*/

/**
\fn void EvrRtxEventFlagsWaitTimeout (osEventFlagsId_t ef_id)
\details
The event \b EventFlagsWaitTimeout is generated when wait for event flags to become signaled is aborted due to expired wait timeout.

\b Value in the Event Recorder shows:
  - \b ef_id : event flags ID.
*/

/**
\fn void EvrRtxEventFlagsWaitCompleted (osEventFlagsId_t ef_id, uint32_t flags, uint32_t options, uint32_t event_flags)
\details
The event \b EventFlagsWaitCompleted is generated when waiting for event flags ends because requested flags were signaled.

\b Value in the Event Recorder shows:
  - \b ef_id : event flags ID.
  - \b flags : flags to wait for.
  - \b options : flags option (refer to \ref osEventFlagsWait "event flags options").
  - \b event_flags : event flags before clearing or 0 if specified flags have not been set.
*/

/**
\fn void EvrRtxEventFlagsWaitNotCompleted (osEventFlagsId_t ef_id, uint32_t flags, uint32_t options)
\details
The event \b EventFlagsWaitNotCompleted is generated when the function \ref osEventFlagsWait returns without timeout and specified event flags were not signaled.

\b Value in the Event Recorder shows:
  - \b ef_id : event flags ID.
  - \b flags : flags to wait for.
  - \b options : flags options (refer to \ref osEventFlagsWait "event flags options").
*/

/**
\fn void EvrRtxEventFlagsDelete (osEventFlagsId_t ef_id)
\details
The event \b EventFlagsDelete is generated when the function \ref osEventFlagsDelete is called.

\b Value in the Event Recorder shows:
  - \b ef_id : event flags ID.
*/

/**
\fn void EvrRtxEventFlagsDestroyed (osEventFlagsId_t ef_id)
\details
The event \b EventFlagsDestroyed is generated when the function \ref osEventFlagsDelete successfully deletes the event flags object.

\b Value in the Event Recorder shows:
  - \b ef_id : event flags ID.
*/

/**
@}
*/

/**
\defgroup rtx_evr_timer Timer Functions
\brief Events generated by timer functions 
\details
@{
*/

/**
\fn void EvrRtxTimerError (osTimerId_t timer_id, int32_t status)
\details
The event \b TimerError is generated when \ref CMSIS_RTOS_TimerMgmt routines complete their execution due to an error.

The status parameter indicates the execution status and can be one of the \ref osStatus_t "osStatus_t codes" or one
of the extended execution status codes which are summarized in the table below.

| Extended Status Code          | Description |
|:------------------------------|:------------|
| osRtxErrorKernelNotReady      | Kernel scheduler is not in Ready state. |
| osRtxErrorKernelNotRunning    | Kernel scheduler is not executing - there is no running thread. |
| osRtxErrorInvalidControlBlock | Object control block with invalid alignment or size was specified. |
| osRtxErrorInvalidDataMemory   | Object data memory with invalid alignment or size was specified. |
| osRtxErrorInvalidThreadStack  | Thread stack memory with invalid alignment or size was specified. |
| osRtxErrorInvalidPriority     | Invalid thread priority was specified. |
| osRtxErrorThreadNotJoinable   | Specified thread is not joinable. |
| osRtxErrorMutexNotOwned       | Specified mutex is not owned by the current running thread. |
| osRtxErrorMutexNotLocked      | Specified mutex is not locked. |
| osRtxErrorMutexLockLimit      | Maximum number of recursive mutex locks reached. |
| osRtxErrorSemaphoreCountLimit | Semaphore count limit reached. |
| osRtxErrorTZ_InitContext_S    | Secure context memory system initialization failed. |
| osRtxErrorTZ_AllocContext_S   | Secure context memory allocation failed. |
| osRtxErrorTZ_FreeContext_S    | Secure context memory deallocation failed. |
| osRtxErrorTZ_LoadContext_S    | Secure context load failed. |
| osRtxErrorTZ_SaveContext_S    | Secure context save failed. |

\b Value in the Event Recorder shows:
  - \b timer_id : timer ID.
  - \b status : execution status code.
*/

/**
\fn void EvrRtxTimerCallback (osTimerFunc_t func, void *argument)
\details
The event \b TimerCallback is generated when the timer callback function is called.

\b Value in the Event Recorder shows:
  - \b func : start address of a timer call back function. 
  - \b argument : memory address of argument to the timer call back function.
*/

/**
\fn void EvrRtxTimerNew (osTimerFunc_t func, osTimerType_t type, void *argument, const osTimerAttr_t *attr)
\details
The event \b TimerNew is generated when the function \ref osTimerNew is called.

\b Value in the Event Recorder shows:
  - \b func : start address of a timer call back function.
  - \b type : timer type: osTimerOnce for one-shot or osTimerPeriodic for periodic behavior.
  - \b argument : memory address of argument to the timer call back function.
  - \b attr : memory address of Timer attributes or 0 when they are not specified.
*/

/**
\fn void EvrRtxTimerCreated (osTimerId_t timer_id, const char *name)
\details
The event \b TimerCreated is generated when the function \ref osTimerNew successfully creates a timer object.

\b Value in the Event Recorder shows:
  - \b timer_id : timer ID.
*/

/**
\fn void EvrRtxTimerGetName (osTimerId_t timer_id, const char *name)
\details
The event \b TimerGetName is generated when the function \ref osTimerGetName is called and its execution result is known.

\b Value in the Event Recorder shows:
  - \b timer_id : timer ID.
  - \b name : retrieved memory address of name string (0 in case of a failure).
*/

/**
\fn void EvrRtxTimerStart (osTimerId_t timer_id, uint32_t ticks)
\details
The event \b TimerStart is generated when the function \ref osTimerStart is called.

\b Value in the Event Recorder shows:
  - \b timer_id : timer ID.
  - \b ticks : \ref CMSIS_RTOS_TimeOutValue "time ticks" value of the timer.
*/

/**
\fn void EvrRtxTimerStarted (osTimerId_t timer_id)
\details
The event \b TimerStarted is generated when the function \ref osTimerStart successfully starts or restarts the timer operation.

\b Value in the Event Recorder shows:
  - \b timer_id : timer ID.
*/

/**
\fn void EvrRtxTimerStop (osTimerId_t timer_id)
\details
The event \b TimerStop is generated when the function \ref osTimerStop is called.

\b Value in the Event Recorder shows:
  - \b timer_id : timer ID.
*/

/**
\fn void EvrRtxTimerStopped (osTimerId_t timer_id)
\details
The event \b TimerStopped is generated when the function \ref osTimerStop successfully stops the timer operation.

\b Value in the Event Recorder shows:
  - \b timer_id : timer ID.
*/

/**
\fn void EvrRtxTimerIsRunning (osTimerId_t timer_id, uint32_t running)
\details
The event \b TimerIsRunning is generated when the function \ref osTimerIsRunning is called and its execution result is known.

\b Value in the Event Recorder shows:
  - \b timer_id : timer ID.
  - \b running : timer running state: 0 not running, 1 running.
*/

/**
\fn void EvrRtxTimerDelete (osTimerId_t timer_id)
\details
The event \b TimerDelete is generated when the function \ref osTimerDelete is called.

\b Value in the Event Recorder shows:
  - \b timer_id : timer ID.
*/

/**
\fn void EvrRtxTimerDestroyed (osTimerId_t timer_id)
\details
The event \b TimerDestroyed is generated when the function \ref osTimerDelete successfully deletes the timer object.

\b Value in the Event Recorder shows:
  - \b timer_id : timer ID.
*/

/**
@}
*/

/**
\defgroup rtx_evr_mutex Mutex Functions
\brief Events generated by mutex functions 
\details
@{
*/

/**
\fn void EvrRtxMutexError (osMutexId_t mutex_id, int32_t status)
\details
The event \b MutexError is generated when \ref CMSIS_RTOS_MutexMgmt routines complete their execution due to an error.

The status parameter indicates the execution status and can be one of the \ref osStatus_t "osStatus_t codes" or one
of the extended execution status codes which are summarized in the table below.

|      Extended Status Code     | Description |
|:------------------------------|:------------|
| osRtxErrorKernelNotReady      | Kernel scheduler is not in Ready state. |
| osRtxErrorKernelNotRunning    | Kernel scheduler is not executing - there is no running thread. |
| osRtxErrorInvalidControlBlock | Object control block with invalid alignment or size was specified. |
| osRtxErrorInvalidDataMemory   | Object data memory with invalid alignment or size was specified. |
| osRtxErrorInvalidThreadStack  | Thread stack memory with invalid alignment or size was specified. |
| osRtxErrorInvalidPriority     | Invalid thread priority was specified. |
| osRtxErrorThreadNotJoinable   | Specified thread is not joinable. |
| osRtxErrorMutexNotOwned       | Specified mutex is not owned by the current running thread. |
| osRtxErrorMutexNotLocked      | Specified mutex is not locked. |
| osRtxErrorMutexLockLimit      | Maximum number of recursive mutex locks reached. |
| osRtxErrorSemaphoreCountLimit | Semaphore count limit reached. |
| osRtxErrorTZ_InitContext_S    | Secure context memory system initialization failed. |
| osRtxErrorTZ_AllocContext_S   | Secure context memory allocation failed. |
| osRtxErrorTZ_FreeContext_S    | Secure context memory deallocation failed. |
| osRtxErrorTZ_LoadContext_S    | Secure context load failed. |
| osRtxErrorTZ_SaveContext_S    | Secure context save failed. |

\b Value in the Event Recorder shows:
  - \b mutex_id : mutex ID.
  - \b status : execution status code.
*/

/**
\fn void EvrRtxMutexNew (const osMutexAttr_t *attr)
\details
The event \b MutexNew is generated when the function \ref osMutexNew is called.

\b Value in the Event Recorder shows:
  - \b attr : memory address of Mutex attributes or 0 when they are not specified.
*/

/**
\fn void EvrRtxMutexCreated (osMutexId_t mutex_id, const char *name)
\details
The event \b MutexCreated is generated when the function \ref osMutexNew successfully creates a mutex object.

\b Value in the Event Recorder shows:
  - \b mutex_id : mutex ID.
*/

/**
\fn void EvrRtxMutexGetName (osMutexId_t mutex_id, const char *name)
\details
The event \b MutexGetName is generated when the function \ref osMutexGetName is called and its execution result is known.

\b Value in the Event Recorder shows:
  - \b mutex_id : mutex ID.
  - \b name : retrieved memory address of name string (0 in case of a failure).
*/

/**
\fn void EvrRtxMutexAcquire (osMutexId_t mutex_id, uint32_t timeout)
\details
The event \b MutexAcquire is generated when the function \ref osMutexAcquire is called.

\b Value in the Event Recorder shows:
  - \b mutex_id : mutex ID.
  - \b timeout : \ref CMSIS_RTOS_TimeOutValue.
*/

/**
\fn void EvrRtxMutexAcquirePending (osMutexId_t mutex_id, uint32_t timeout)
\details
The event \b MutexAcquirePending is generated when the function \ref osMutexAcquire blocks current running thread and waits for mutex to become available.

\b Value in the Event Recorder shows:
  - \b mutex_id : mutex ID.
  - \b timeout : \ref CMSIS_RTOS_TimeOutValue.
*/

/**
\fn void EvrRtxMutexAcquireTimeout (osMutexId_t mutex_id)
\details
The event \b MutexAcquireTimeout is generated when wait for mutex to become available is aborted due to expired wait timeout.

\b Value in the Event Recorder shows:
  - \b mutex_id : mutex ID.
*/

/**
\fn void EvrRtxMutexAcquired (osMutexId_t mutex_id, uint32_t lock)
\details
The event \b MutexAcquired is generated when the function \ref osMutexAcquire successfully acquires a mutex.

\b Value in the Event Recorder shows:
  - \b mutex_id : mutex ID.
  - \b lock : current lock counter state.
*/

/**
\fn void EvrRtxMutexNotAcquired (osMutexId_t mutex_id)
\details
The event \b MutexNotAcquired is generated when the function \ref osMutexAcquire returns without timeout and mutex was not acquired.

\b Value in the Event Recorder shows:
  - \b mutex_id : mutex ID.
*/

/**
\fn void EvrRtxMutexRelease (osMutexId_t mutex_id)
\details
The event \b MutexRelease is generated when the function \ref osMutexRelease is called.

\b Value in the Event Recorder shows:
  - \b mutex_id : mutex ID.
*/

/**
\fn void EvrRtxMutexReleased (osMutexId_t mutex_id, uint32_t lock)
\details
The event \b MutexReleased is generated when the function \ref osMutexRelease successfully releases a mutex.

\b Value in the Event Recorder shows:
  - \b mutex_id : mutex ID.
  - \b lock : current lock counter state.
*/

/**
\fn void EvrRtxMutexGetOwner (osMutexId_t mutex_id, osThreadId_t thread_id)
\details
The event \b MutexGetOwner is generated when the function \ref osMutexGetOwner is called and its execution result is known.

\b Value in the Event Recorder shows:
  - \b mutex_id : mutex ID.
  - \b thread_id : retrieved owner thread ID (0 in case of a failure or when mutex is not locked)
*/

/**
\fn void EvrRtxMutexDelete (osMutexId_t mutex_id)
\details
The event \b MutexDelete is generated when the function \ref osMutexDelete is called.

\b Value in the Event Recorder shows:
  - \b mutex_id : mutex ID.
*/

/**
\fn void EvrRtxMutexDestroyed (osMutexId_t mutex_id)
\details
The event \b MutexDestroyed is generated when the function \ref osMutexDelete successfully deletes the mutex object.

\b Value in the Event Recorder shows:
  - \b mutex_id : mutex ID.
*/

/**
@}
*/

/**
\defgroup rtx_evr_semaphore Semaphore Functions
\brief Events generated by semaphore functions 
\details
@{
*/

/**
\fn void EvrRtxSemaphoreError (osSemaphoreId_t semaphore_id, int32_t status)
\details
The event \b SemaphoreError is generated when \ref CMSIS_RTOS_SemaphoreMgmt routines complete their execution due to an error.

The status parameter indicates the execution status and can be one of the \ref osStatus_t "osStatus_t codes" or one
of the extended execution status codes which are summarized in the table below.

|      Extended Status Code     | Description |
|:------------------------------|:------------|
| osRtxErrorKernelNotReady      | Kernel scheduler is not in Ready state. |
| osRtxErrorKernelNotRunning    | Kernel scheduler is not executing - there is no running thread. |
| osRtxErrorInvalidControlBlock | Object control block with invalid alignment or size was specified. |
| osRtxErrorInvalidDataMemory   | Object data memory with invalid alignment or size was specified. |
| osRtxErrorInvalidThreadStack  | Thread stack memory with invalid alignment or size was specified. |
| osRtxErrorInvalidPriority     | Invalid thread priority was specified. |
| osRtxErrorThreadNotJoinable   | Specified thread is not joinable. |
| osRtxErrorMutexNotOwned       | Specified mutex is not owned by the current running thread. |
| osRtxErrorMutexNotLocked      | Specified mutex is not locked. |
| osRtxErrorMutexLockLimit      | Maximum number of recursive mutex locks reached. |
| osRtxErrorSemaphoreCountLimit | Semaphore count limit reached. |
| osRtxErrorTZ_InitContext_S    | Secure context memory system initialization failed. |
| osRtxErrorTZ_AllocContext_S   | Secure context memory allocation failed. |
| osRtxErrorTZ_FreeContext_S    | Secure context memory deallocation failed. |
| osRtxErrorTZ_LoadContext_S    | Secure context load failed. |
| osRtxErrorTZ_SaveContext_S    | Secure context save failed. |

\b Value in the Event Recorder shows:
  - \b semaphore_id : semaphore ID.
  - \b status : execution status code.
*/

/**
\fn void EvrRtxSemaphoreNew (uint32_t max_count, uint32_t initial_count, const osSemaphoreAttr_t *attr)
\details
The event \b SemaphoreNew is generated when the function \ref osSemaphoreNew is called.

\b Value in the Event Recorder shows:
  - \b max_count : maximum number of available tokens. 
  - \b initial_count : initial number of available tokens.
  - \b attr : memory address of Semaphore attributes or 0 when they are not specified.
*/

/**
\fn void EvrRtxSemaphoreCreated (osSemaphoreId_t semaphore_id, const char *name)
\details
The event \b SemaphoreCreated is generated when the function \ref osSemaphoreNew successfully creates a semaphore object.

\b Value in the Event Recorder shows:
  - \b semaphore_id : semaphore ID.
*/

/**
\fn void EvrRtxSemaphoreGetName (osSemaphoreId_t semaphore_id, const char *name)
\details
The event \b SemaphoreGetName is generated when the function \ref osSemaphoreGetName is called and its execution result is known.

\b Value in the Event Recorder shows:
  - \b semaphore_id : semaphore ID.
  - \b name : retrieved memory address of name string (0 in case of a failure).
*/

/**
\fn void EvrRtxSemaphoreAcquire (osSemaphoreId_t semaphore_id, uint32_t timeout)
\details
The event \b SemaphoreAcquire is generated when the function \ref osSemaphoreAcquire is called.

\b Value in the Event Recorder shows:
  - \b semaphore_id : semaphore ID.
  - \b timeout : \ref CMSIS_RTOS_TimeOutValue.
*/

/**
\fn void EvrRtxSemaphoreAcquirePending (osSemaphoreId_t semaphore_id, uint32_t timeout)
\details
The event \b SemaphoreAcquirePending is generated when the function \ref osSemaphoreAcquire blocks current running thread and waits for semaphore token to become available.

\b Value in the Event Recorder shows:
  - \b semaphore_id : semaphore ID.
  - \b timeout : \ref CMSIS_RTOS_TimeOutValue.
*/

/**
\fn void EvrRtxSemaphoreAcquireTimeout (osSemaphoreId_t semaphore_id)
\details
The event \b SemaphoreAcquireTimeout is generated when wait for semaphore to become available is aborted due to expired wait timeout.

\b Value in the Event Recorder shows:
  - \b semaphore_id : semaphore ID.
*/

/**
\fn void EvrRtxSemaphoreAcquired (osSemaphoreId_t semaphore_id, uint32_t tokens)
\details
The event \b SemaphoreAcquired is generated when the function \ref osSemaphoreAcquire successfully acquires the semaphore token.

\b Value in the Event Recorder shows:
  - \b semaphore_id : semaphore ID.
  - \b tokens : available tokens.
*/

/**
\fn void EvrRtxSemaphoreNotAcquired (osSemaphoreId_t semaphore_id)
\details
The event \b SemaphoreNotAcquired is generated when the function \ref osMutexAcquire returns without timeout and semaphore token was not acquired.

\b Value in the Event Recorder shows:
  - \b semaphore_id : semaphore ID.
*/

/**
\fn void EvrRtxSemaphoreRelease (osSemaphoreId_t semaphore_id)
\details
The event \b SemaphoreRelease is generated when the function \ref osSemaphoreRelease is called.

\b Value in the Event Recorder shows:
  - \b semaphore_id : semaphore ID.
*/

/**
\fn void EvrRtxSemaphoreReleased (osSemaphoreId_t semaphore_id, uint32_t tokens)
\details
The event \b SemaphoreReleased is generated when the function \ref osSemaphoreRelease successfully releases the semaphore token.

\b Value in the Event Recorder shows:
  - \b semaphore_id : semaphore ID.
  - \b tokens : available tokens.
*/

/**
\fn void EvrRtxSemaphoreGetCount (osSemaphoreId_t semaphore_id, uint32_t count)
\details
The event \b SemaphoreGetCount is generated when the function \ref osSemaphoreGetCount is called and its execution result is known.

\b Value in the Event Recorder shows:
  - \b semaphore_id : semaphore ID.
  - \b count : retrieved current number of available tokens. 
*/

/**
\fn void EvrRtxSemaphoreDelete (osSemaphoreId_t semaphore_id)
\details
The event \b SemaphoreDelete is generated when the function \ref osSemaphoreDelete is called.

\b Value in the Event Recorder shows:
  - \b semaphore_id : semaphore ID.
*/

/**
\fn void EvrRtxSemaphoreDestroyed (osSemaphoreId_t semaphore_id)
\details
The event \b SemaphoreDestroyed is generated when the function \ref osSemaphoreDelete successfully deletes the semaphore object.

\b Value in the Event Recorder shows:
  - \b semaphore_id : semaphore ID.
*/

/**
@}
*/

/**
\defgroup rtx_evr_memory_pool Memory Pool Functions
\brief Events generated by memory pool functions 
\details
@{
*/

/**
\fn void EvrRtxMemoryPoolError (osMemoryPoolId_t mp_id, int32_t status)
\details
The event \b MemoryPoolError is generated when \ref CMSIS_RTOS_PoolMgmt routines complete their execution due to an error.

The status parameter indicates the execution status and can be one of the \ref osStatus_t "osStatus_t codes" or one
of the extended execution status codes which are summarized in the table below.

|      Extended Status Code     | Description |
|:------------------------------|:------------|
| osRtxErrorKernelNotReady      | Kernel scheduler is not in Ready state. |
| osRtxErrorKernelNotRunning    | Kernel scheduler is not executing - there is no running thread. |
| osRtxErrorInvalidControlBlock | Object control block with invalid alignment or size was specified. |
| osRtxErrorInvalidDataMemory   | Object data memory with invalid alignment or size was specified. |
| osRtxErrorInvalidThreadStack  | Thread stack memory with invalid alignment or size was specified. |
| osRtxErrorInvalidPriority     | Invalid thread priority was specified. |
| osRtxErrorThreadNotJoinable   | Specified thread is not joinable. |
| osRtxErrorMutexNotOwned       | Specified mutex is not owned by the current running thread. |
| osRtxErrorMutexNotLocked      | Specified mutex is not locked. |
| osRtxErrorMutexLockLimit      | Maximum number of recursive mutex locks reached. |
| osRtxErrorSemaphoreCountLimit | Semaphore count limit reached. |
| osRtxErrorTZ_InitContext_S    | Secure context memory system initialization failed. |
| osRtxErrorTZ_AllocContext_S   | Secure context memory allocation failed. |
| osRtxErrorTZ_FreeContext_S    | Secure context memory deallocation failed. |
| osRtxErrorTZ_LoadContext_S    | Secure context load failed. |
| osRtxErrorTZ_SaveContext_S    | Secure context save failed. |

\b Value in the Event Recorder shows:
  - \b mp_id : memory pool ID.
  - \b status : execution status code.
*/

/**
\fn void EvrRtxMemoryPoolNew (uint32_t block_count, uint32_t block_size, const osMemoryPoolAttr_t *attr)
\details
The event \b MemoryPoolNew is generated when the function \ref osMemoryPoolNew is called.

\b Value in the Event Recorder shows:
  - \b block_count : maximum number of memory blocks in memory pool.
  - \b block_size : memory block size in bytes.
  - \b attr : memory address of Memory Pool attributes or 0 when they are not specified.
*/

/**
\fn void EvrRtxMemoryPoolCreated (osMemoryPoolId_t mp_id, const char *name)
\details
The event \b MemoryPoolCreated is generated when the function \ref osMemoryPoolNew successfully creates a memory pool object.

\b Value in the Event Recorder shows:
  - \b mp_id : memory pool ID.
*/

/**
\fn void EvrRtxMemoryPoolGetName (osMemoryPoolId_t mp_id, const char *name)
\details
The event \b MemoryPoolGetName is generated when the function \ref osMemoryPoolGetName is called and its execution result is known.

\b Value in the Event Recorder shows:
  - \b mp_id : memory pool ID.
  - \b name : retrieved memory address of name string (0 in case of a failure).
*/

/**
\fn void EvrRtxMemoryPoolAlloc (osMemoryPoolId_t mp_id, uint32_t timeout)
\details
The event \b MemoryPoolAlloc is generated when the function \ref osMemoryPoolAlloc is called.

\b Value in the Event Recorder shows:
  - \b mp_id : memory pool ID.
  - \b timeout : \ref CMSIS_RTOS_TimeOutValue.
*/

/**
\fn void EvrRtxMemoryPoolAllocPending (osMemoryPoolId_t mp_id, uint32_t timeout)
\details
The event \b MemoryPoolAllocPending is generated when the function \ref osMemoryPoolAlloc blocks current running thread and waits for memory block to become available.

\b Value in the Event Recorder shows:
  - \b mp_id : memory pool ID.
  - \b timeout : \ref CMSIS_RTOS_TimeOutValue.
*/

/**
\fn void EvrRtxMemoryPoolAllocTimeout (osMemoryPoolId_t mp_id)
\details
The event \b MemoryPoolAllocTimeout is generated when wait for memory pool to become available is aborted due to expired wait timeout.

\b Value in the Event Recorder shows:
  - \b mp_id : memory pool ID.
*/

/**
\fn void EvrRtxMemoryPoolAllocated (osMemoryPoolId_t mp_id, void *block)
\details
The event \b MemoryPoolAllocated is generated when the function \ref osMemoryPoolAlloc successfully allocates the memory block.

\b Value in the Event Recorder shows:
  - \b mp_id : memory pool ID.
  - \b block : memory address of the allocated memory block.
*/

/**
\fn void EvrRtxMemoryPoolAllocFailed (osMemoryPoolId_t mp_id)
\details
The event \b MemoryPoolAllocFailed is generated when the function \ref osMemoryPoolAlloc fails to allocate the memory block due to out of available memory.

\b Value in the Event Recorder shows:
  - \b mp_id : memory pool ID.
*/

/**
\fn void EvrRtxMemoryPoolFree (osMemoryPoolId_t mp_id, void *block)
\details
The event \b MemoryPoolFree is generated when the function \ref osMemoryPoolFree is called.

\b Value in the Event Recorder shows:
  - \b mp_id : memory pool ID.
  - \b block : memory address of the memory block to be returned to the memory pool.
*/

/**
\fn void EvrRtxMemoryPoolDeallocated (osMemoryPoolId_t mp_id, void *block)
\details
The event \b MemoryPoolDeallocated is generated when the function \ref osMemoryPoolFree successfully deallocates the memory block.

\b Value in the Event Recorder shows:
  - \b mp_id : memory pool ID.
  - \b block : memory address of the memory block returned to the memory pool. 
*/

/**
\fn void EvrRtxMemoryPoolFreeFailed (osMemoryPoolId_t mp_id, void *block)
\details
The event \b MemoryPoolFreeFailed is generated when the function \ref osMemoryPoolFree fails to deallocate the memory block.

\b Value in the Event Recorder shows:
  - \b mp_id : memory pool ID.
  - \b block : memory address of the memory block to be returned to the memory pool.
*/

/**
\fn void EvrRtxMemoryPoolGetCapacity (osMemoryPoolId_t mp_id, uint32_t capacity)
\details
The event \b MemoryPoolGetCapacity is generated when the function \ref osMemoryPoolGetCapacity is called and its execution result is known.

\b Value in the Event Recorder shows:
  - \b mp_id : memory pool ID.
  - \b capacity : retrieved maximum number of memory blocks (0 in case of a failure). 
*/

/**
\fn void EvrRtxMemoryPoolGetBlockSize (osMemoryPoolId_t mp_id, uint32_t block_size)
\details
The event \b MemoryPoolGetBlockSize is generated when the function \ref osMemoryPoolGetBlockSize is called and its execution result is known.

\b Value in the Event Recorder shows:
  - \b mp_id : memory pool ID.
  - \b block_size : retrieved memory block size in bytes (0 in case of a failure).
*/

/**
\fn void EvrRtxMemoryPoolGetCount (osMemoryPoolId_t mp_id, uint32_t count)
\details
The event \b MemoryPoolGetCount is generated when the function \ref osMemoryPoolGetCount is called and its execution result is known.

\b Value in the Event Recorder shows:
  - \b mp_id : memory pool ID.
  - \b count : retrieved number of memory block used (0 in case of a failure).
*/

/**
\fn void EvrRtxMemoryPoolGetSpace (osMemoryPoolId_t mp_id, uint32_t space)
\details
The event \b MemoryPoolGetSpace is generated when the function \ref osMemoryPoolGetSpace is called and its execution result is known.

\b Value in the Event Recorder shows:
  - \b mp_id : memory pool ID.
  - \b space : retrieved number of memory blocks available (0 in case of a failure).
*/

/**
\fn void EvrRtxMemoryPoolDelete (osMemoryPoolId_t mp_id)
\details
The event \b MemoryPoolDelete is generated when the function \ref osMemoryPoolDelete is called.

\b Value in the Event Recorder shows:
  - \b mp_id : memory pool ID.
*/

/**
\fn void EvrRtxMemoryPoolDestroyed (osMemoryPoolId_t mp_id)
\details
The event \b MemoryPoolDestroyed is generated when the function \ref osMemoryPoolDelete successfully deletes the memory pool object.

\b Value in the Event Recorder shows:
  - \b mp_id : memory pool ID.
*/

/**
@}
*/

/**
\defgroup rtx_evr_message_queue Message Queue Functions
\brief Events generated by message queue functions 
\details
@{
*/

/**
\fn void EvrRtxMessageQueueError (osMessageQueueId_t mq_id, int32_t status)
\details
The event \b MessageQueueError is generated when \ref CMSIS_RTOS_Message routines complete their execution due to an error.

The status parameter indicates the execution status and can be one of the \ref osStatus_t "osStatus_t codes" or one
of the extended execution status codes which are summarized in the table below.

|      Extended Status Code     | Description |
|:------------------------------|:------------|
| osRtxErrorKernelNotReady      | Kernel scheduler is not in Ready state. |
| osRtxErrorKernelNotRunning    | Kernel scheduler is not executing - there is no running thread. |
| osRtxErrorInvalidControlBlock | Object control block with invalid alignment or size was specified. |
| osRtxErrorInvalidDataMemory   | Object data memory with invalid alignment or size was specified. |
| osRtxErrorInvalidThreadStack  | Thread stack memory with invalid alignment or size was specified. |
| osRtxErrorInvalidPriority     | Invalid thread priority was specified. |
| osRtxErrorThreadNotJoinable   | Specified thread is not joinable. |
| osRtxErrorMutexNotOwned       | Specified mutex is not owned by the current running thread. |
| osRtxErrorMutexNotLocked      | Specified mutex is not locked. |
| osRtxErrorMutexLockLimit      | Maximum number of recursive mutex locks reached. |
| osRtxErrorSemaphoreCountLimit | Semaphore count limit reached. |
| osRtxErrorTZ_InitContext_S    | Secure context memory system initialization failed. |
| osRtxErrorTZ_AllocContext_S   | Secure context memory allocation failed. |
| osRtxErrorTZ_FreeContext_S    | Secure context memory deallocation failed. |
| osRtxErrorTZ_LoadContext_S    | Secure context load failed. |
| osRtxErrorTZ_SaveContext_S    | Secure context save failed. |

\b Value in the Event Recorder shows:
  - \b mq_id : message queue ID.
  - \b status : execution status code.
*/

/**
\fn void EvrRtxMessageQueueNew (uint32_t msg_count, uint32_t msg_size, const osMessageQueueAttr_t *attr)
\details
The event \b MessageQueueNew is generated when the function \ref osMessageQueueNew is called.

\b Value in the Event Recorder shows:
  - \b msg_count : maximum number of messages in queue.
  - \b msg_size : maximum message size in bytes.
  - \b attr : memory address of Message Queue attributes or 0 when they are not specified.
*/

/**
\fn void EvrRtxMessageQueueCreated (osMessageQueueId_t mq_id, const char *name)
\details
The event \b MessageQueueCreated is generated when the function \ref osMessageQueueNew successfully creates a message queue object.

\b Value in the Event Recorder shows:
  - \b mq_id : message queue ID.
*/

/**
\fn void EvrRtxMessageQueueGetName (osMessageQueueId_t mq_id, const char *name)
\details
The event \b MessageQueueGetName is generated when the function \ref osMessageQueueGetName is called and its execution result is known.

\b Value in the Event Recorder shows:
  - \b mq_id : message queue ID.
  - \b name : retrieved memory address of name string (0 in case of a failure).
*/

/**
\fn void EvrRtxMessageQueuePut (osMessageQueueId_t mq_id, const void *msg_ptr, uint8_t msg_prio, uint32_t timeout)
\details
The event \b MessageQueuePut is generated when the function \ref osMessageQueuePut is called.

\b Value in the Event Recorder shows:
  - \b mq_id : message queue ID.
  - \b msg_ptr : memory address of message buffer.
  - \b msg_prio : message priority.
  - \b timeout : \ref CMSIS_RTOS_TimeOutValue.
*/

/**
\fn void EvrRtxMessageQueuePutPending (osMessageQueueId_t mq_id, const void *msg_ptr, uint32_t timeout)
\details
The event \b MessageQueuePutPending is generated when the function \ref osMessageQueuePut starts waiting to put message into the queue.

\b Value in the Event Recorder shows:
  - \b mq_id : message queue ID.
  - \b msg_ptr : memory address of message buffer.
  - \b timeout : \ref CMSIS_RTOS_TimeOutValue.
*/

/**
\fn void EvrRtxMessageQueuePutTimeout (osMessageQueueId_t mq_id)
\details
The event \b MessageQueuePutTimeout is generated when the function \ref osMessageQueuePut fails to insert a message into the queue until timeout expires.

\b Value in the Event Recorder shows:
  - \b mq_id : message queue ID.
*/

/**
\fn void EvrRtxMessageQueueInsertPending (osMessageQueueId_t mq_id, const void *msg_ptr)
\details
The event \b MessageQueueInsertPending is generated when the function \ref osMessageQueuePut is called from ISR and message is registered to be put into the queue. 

\b Value in the Event Recorder shows:
  - \b mq_id : message queue ID.
  - \b msg_ptr : memory address of message buffer.
*/

/**
\fn void EvrRtxMessageQueueInserted (osMessageQueueId_t mq_id, const void *msg_ptr)
\details
The event \b MessageQueueInserted is generated when a message is successfully inserted into the queue.

\b Value in the Event Recorder shows:
  - \b mq_id : message queue ID.
  - \b msg_ptr : memory address of message buffer.
*/

/**
\fn void EvrRtxMessageQueueNotInserted (osMessageQueueId_t mq_id, const void *msg_ptr)
\details
The event \b MessageQueueNotInserted is generated when the function \ref osMessageQueuePut fails to insert a message into the queue.
Usually this happens when queue is out of memory.

\b Value in the Event Recorder shows:
  - \b mq_id : message queue ID.
  - \b msg_ptr : memory address of message buffer.
*/

/**
\fn void EvrRtxMessageQueueGet (osMessageQueueId_t mq_id, void *msg_ptr, uint8_t *msg_prio, uint32_t timeout)
\details
The event \b MessageQueueGet is generated when the function \ref osMessageQueueGet is called.

\b Value in the Event Recorder shows:
  - \b mq_id : message queue ID.
  - \b msg_ptr : memory address of buffer for message.
  - \b msg_prio : memory address of buffer for message priority.
  - \b timeout : \ref CMSIS_RTOS_TimeOutValue.
*/

/**
\fn void EvrRtxMessageQueueGetPending (osMessageQueueId_t mq_id, void *msg_ptr, uint32_t timeout)
\details
The event \b MessageQueueGetPending is generated when the function \ref osMessageQueueGet starts waiting for message to be retrieved from the queue.

\b Value in the Event Recorder shows:
  - \b mq_id : message queue ID.
  - \b msg_ptr : memory address of buffer for message.
  - \b timeout : \ref CMSIS_RTOS_TimeOutValue.
*/

/**
\fn void EvrRtxMessageQueueGetTimeout (osMessageQueueId_t mq_id)
\details
The event \b MessageQueueGetTimeout is generated when the function \ref osMessageQueueGet is called and there is no message available in queue until timeout expires.

\b Value in the Event Recorder shows:
  - \b mq_id : message queue ID.
*/

/**
\fn void EvrRtxMessageQueueRetrieved (osMessageQueueId_t mq_id, void *msg_ptr)
\details
The event \b MessageQueueRetrieved is generated when message is retrieved from the message queue.

\b Value in the Event Recorder shows:
  - \b mq_id : message queue ID.
  - \b msg_ptr : memory address of buffer for message.
*/

/**
\fn void EvrRtxMessageQueueNotRetrieved (osMessageQueueId_t mq_id, void *msg_ptr)
\details
The event \b MessageQueueNotRetrieved is generated when the function \ref osMessageQueueGet is called without the wait timeout and there is no message available in queue.

\b Value in the Event Recorder shows:
  - \b mq_id : message queue ID.
  - \b msg_ptr : memory address of buffer for message.
*/

/**
\fn void EvrRtxMessageQueueGetCapacity (osMessageQueueId_t mq_id, uint32_t capacity)
\details
The event \b MessageQueueGetCapacity is generated when the function \ref osMessageQueueGetCapacity is called and its execution result is known.

\b Value in the Event Recorder shows:
  - \b mq_id : message queue ID.
  - \b capacity : retrieved maximum number of messages (0 in case of a failure).
*/

/**
\fn void EvrRtxMessageQueueGetMsgSize (osMessageQueueId_t mq_id, uint32_t msg_size)
\details
The event \b MessageQueueGetMsgSize is generated when the function \ref osMessageQueueGetMsgSize is called and its execution result is known.

\b Value in the Event Recorder shows:
  - \b mq_id : message queue ID.
  - \b msg_size : retrieved maximum message size in bytes (0 in case of a failure).
*/

/**
\fn void EvrRtxMessageQueueGetCount (osMessageQueueId_t mq_id, uint32_t count)
\details
The event \b MessageQueueGetCount is generated when the function \ref osMessageQueueGetCount is called and its execution result is known.

\b Value in the Event Recorder shows:
  - \b mq_id : message queue ID.
  - \b count : retrieved number of queued messages (0 in case of a failure).
*/

/**
\fn void EvrRtxMessageQueueGetSpace (osMessageQueueId_t mq_id, uint32_t space)
\details
The event \b MessageQueueGetSpace is generated when the function \ref osMessageQueueGetSpace is called and its execution result is known.

\b Value in the Event Recorder shows:
  - \b mq_id : message queue ID.
  - \b space : retrieved number of available slots for messages (0 in case of a failure).
*/

/**
\fn void EvrRtxMessageQueueReset (osMessageQueueId_t mq_id)
\details
The event \b MessageQueueReset is generated when the function \ref osMessageQueueReset is called.

\b Value in the Event Recorder shows:
  - \b mq_id : message queue ID.
*/

/**
\fn void EvrRtxMessageQueueResetDone (osMessageQueueId_t mq_id)
\details
The event \b MessageQueueResetDone is generated when the function \ref osMessageQueueReset successfully completes message queue reset.

\b Value in the Event Recorder shows:
  - \b mq_id : message queue ID.
*/

/**
\fn void EvrRtxMessageQueueDelete (osMessageQueueId_t mq_id)
\details
The event \b MessageQueueDelete is generated when the function \ref osMessageQueueDelete is called.

\b Value in the Event Recorder shows:
  - \b mq_id : message queue ID.
*/

/**
\fn void EvrRtxMessageQueueDestroyed (osMessageQueueId_t mq_id)
\details
The event \b MessageQueueDestroyed is generated when the function \ref osMessageQueueDelete successfully deletes the message queue object.

\b Value in the Event Recorder shows:
  - \b mq_id : message queue ID.
*/

/**
@}
*/

/**
@} 
*/
// end group Event Recorder