Add CMSIS RTOS2 RTX
Change-Id: Ib5a73249809a8ffc91f8624684de07d90c801b87
Signed-off-by: Kevin Peng <kevin.peng@arm.com>
diff --git a/CMSIS/RTOS2/RTX/Include/rtx_evr.h b/CMSIS/RTOS2/RTX/Include/rtx_evr.h
new file mode 100644
index 0000000..bcc82a6
--- /dev/null
+++ b/CMSIS/RTOS2/RTX/Include/rtx_evr.h
@@ -0,0 +1,1974 @@
+/*
+ * Copyright (c) 2013-2019 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_Config.h" // RTX Configuration
+#include "rtx_os.h" // RTX OS definitions
+
+// Initial Thread configuration covered also Thread Flags and Generic Wait
+#ifndef OS_EVR_THFLAGS
+#define OS_EVR_THFLAGS OS_EVR_THREAD
+#endif
+#ifndef OS_EVR_WAIT
+#define OS_EVR_WAIT OS_EVR_THREAD
+#endif
+
+#ifdef _RTE_
+#include "RTE_Components.h"
+#endif
+
+#ifdef RTE_Compiler_EventRecorder
+
+//lint -emacro((835,845),EventID) [MISRA Note 13]
+
+#include "EventRecorder.h"
+#include "EventRecorderConf.h"
+
+#if ((defined(OS_EVR_INIT) && (OS_EVR_INIT != 0)) || (EVENT_TIMESTAMP_SOURCE == 2))
+#ifndef EVR_RTX_KERNEL_GET_STATE_DISABLE
+#define EVR_RTX_KERNEL_GET_STATE_DISABLE
+#endif
+#endif
+
+#if (EVENT_TIMESTAMP_SOURCE == 2)
+#ifndef EVR_RTX_KERNEL_GET_SYS_TIMER_COUNT_DISABLE
+#define EVR_RTX_KERNEL_GET_SYS_TIMER_COUNT_DISABLE
+#endif
+#ifndef EVR_RTX_KERNEL_GET_SYS_TIMER_FREQ_DISABLE
+#define EVR_RTX_KERNEL_GET_SYS_TIMER_FREQ_DISABLE
+#endif
+#endif
+
+/// RTOS component number
+#define EvtRtxMemoryNo (0xF0U)
+#define EvtRtxKernelNo (0xF1U)
+#define EvtRtxThreadNo (0xF2U)
+#define EvtRtxThreadFlagsNo (0xF4U)
+#define EvtRtxWaitNo (0xF3U)
+#define EvtRtxTimerNo (0xF6U)
+#define EvtRtxEventFlagsNo (0xF5U)
+#define EvtRtxMutexNo (0xF7U)
+#define EvtRtxSemaphoreNo (0xF8U)
+#define EvtRtxMemoryPoolNo (0xF9U)
+#define EvtRtxMessageQueueNo (0xFAU)
+
+#endif // RTE_Compiler_EventRecorder
+
+
+/// 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_INITIALIZED_DISABLE))
+extern void EvrRtxKernelInitialized (void);
+#else
+#define EvrRtxKernelInitialized()
+#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.
+ \param[in] id_size size of buffer for kernel identification string.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_KERNEL != 0) && !defined(EVR_RTX_KERNEL_INFO_RETRIEVED_DISABLE))
+extern void EvrRtxKernelInfoRetrieved (const osVersion_t *version, const char *id_buf, uint32_t id_size);
+#else
+#define EvrRtxKernelInfoRetrieved(version, id_buf, id_size)
+#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).
+*/
+#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).
+*/
+#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).
+*/
+#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 (uint32_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.
+ \param[in] thread_addr thread entry address.
+ \param[in] name pointer to thread object name.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THREAD != 0) && !defined(EVR_RTX_THREAD_CREATED_DISABLE))
+extern void EvrRtxThreadCreated (osThreadId_t thread_id, uint32_t thread_addr, const char *name);
+#else
+#define EvrRtxThreadCreated(thread_id, thread_addr, name)
+#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 updated (Op)
+ \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_PRIORITY_UPDATED_DISABLE))
+extern void EvrRtxThreadPriorityUpdated (osThreadId_t thread_id, osPriority_t priority);
+#else
+#define EvrRtxThreadPriorityUpdated(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 (Detail)
+ \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_id, timeout)
+#endif
+
+/**
+ \brief Event on thread execution unblock (Detail)
+ \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_id, ret_val)
+#endif
+
+/**
+ \brief Event on running thread pre-emption (Detail)
+ \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_PREEMPTED_DISABLE))
+extern void EvrRtxThreadPreempted (osThreadId_t thread_id);
+#else
+#define EvrRtxThreadPreempted(thread_id)
+#endif
+
+/**
+ \brief Event on 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_SWITCHED_DISABLE))
+extern void EvrRtxThreadSwitched (osThreadId_t thread_id);
+#else
+#define EvrRtxThreadSwitched(thread_id)
+#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.
+ \param[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
+
+
+// ==== Thread Flags Events ====
+
+/**
+ \brief Event on thread flags 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_THFLAGS != 0) && !defined(EVR_RTX_THREAD_FLAGS_ERROR_DISABLE))
+extern void EvrRtxThreadFlagsError (osThreadId_t thread_id, int32_t status);
+#else
+#define EvrRtxThreadFlagsError(thread_id, status)
+#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_THFLAGS != 0) && !defined(EVR_RTX_THREAD_FLAGS_SET_DISABLE))
+extern void EvrRtxThreadFlagsSet (osThreadId_t thread_id, uint32_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.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THFLAGS != 0) && !defined(EVR_RTX_THREAD_FLAGS_SET_DONE_DISABLE))
+extern void EvrRtxThreadFlagsSetDone (osThreadId_t thread_id, uint32_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_THFLAGS != 0) && !defined(EVR_RTX_THREAD_FLAGS_CLEAR_DISABLE))
+extern void EvrRtxThreadFlagsClear (uint32_t flags);
+#else
+#define EvrRtxThreadFlagsClear(flags)
+#endif
+
+/**
+ \brief Event on successful thread flags clear (Op)
+ \param[in] thread_flags thread flags before clearing.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THFLAGS != 0) && !defined(EVR_RTX_THREAD_FLAGS_CLEAR_DONE_DISABLE))
+extern void EvrRtxThreadFlagsClearDone (uint32_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_THFLAGS != 0) && !defined(EVR_RTX_THREAD_FLAGS_GET_DISABLE))
+extern void EvrRtxThreadFlagsGet (uint32_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_THFLAGS != 0) && !defined(EVR_RTX_THREAD_FLAGS_WAIT_DISABLE))
+extern void EvrRtxThreadFlagsWait (uint32_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_THFLAGS != 0) && !defined(EVR_RTX_THREAD_FLAGS_WAIT_PENDING_DISABLE))
+extern void EvrRtxThreadFlagsWaitPending (uint32_t flags, uint32_t options, uint32_t timeout);
+#else
+#define EvrRtxThreadFlagsWaitPending(flags, options, timeout)
+#endif
+
+/**
+ \brief Event on wait timeout for thread flags (Op)
+ \param[in] thread_id thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THFLAGS != 0) && !defined(EVR_RTX_THREAD_FLAGS_WAIT_TIMEOUT_DISABLE))
+extern void EvrRtxThreadFlagsWaitTimeout (osThreadId_t thread_id);
+#else
+#define EvrRtxThreadFlagsWaitTimeout(thread_id)
+#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.
+ \param[in] thread_id thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_THFLAGS != 0) && !defined(EVR_RTX_THREAD_FLAGS_WAIT_COMPLETED_DISABLE))
+extern void EvrRtxThreadFlagsWaitCompleted (uint32_t flags, uint32_t options, uint32_t thread_flags, osThreadId_t thread_id);
+#else
+#define EvrRtxThreadFlagsWaitCompleted(flags, options, thread_flags, thread_id)
+#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_THFLAGS != 0) && !defined(EVR_RTX_THREAD_FLAGS_WAIT_NOT_COMPLETED_DISABLE))
+extern void EvrRtxThreadFlagsWaitNotCompleted (uint32_t flags, uint32_t options);
+#else
+#define EvrRtxThreadFlagsWaitNotCompleted(flags, options)
+#endif
+
+
+// ==== Generic Wait Events ====
+
+/**
+ \brief Event on delay error (Error)
+ \param[in] status extended execution status.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_WAIT != 0) && !defined(EVR_RTX_DELAY_ERROR_DISABLE))
+extern void EvrRtxDelayError (int32_t status);
+#else
+#define EvrRtxDelayError(status)
+#endif
+
+/**
+ \brief Event on delay for specified time (API)
+ \param[in] ticks \ref CMSIS_RTOS_TimeOutValue "time ticks" value.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_WAIT != 0) && !defined(EVR_RTX_DELAY_DISABLE))
+extern void EvrRtxDelay (uint32_t ticks);
+#else
+#define EvrRtxDelay(ticks)
+#endif
+
+/**
+ \brief Event on delay until specified time (API)
+ \param[in] ticks absolute time in ticks.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_WAIT != 0) && !defined(EVR_RTX_DELAY_UNTIL_DISABLE))
+extern void EvrRtxDelayUntil (uint32_t ticks);
+#else
+#define EvrRtxDelayUntil(ticks)
+#endif
+
+/**
+ \brief Event on delay started (Op)
+ \param[in] ticks \ref CMSIS_RTOS_TimeOutValue "time ticks" value.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_WAIT != 0) && !defined(EVR_RTX_DELAY_STARTED_DISABLE))
+extern void EvrRtxDelayStarted (uint32_t ticks);
+#else
+#define EvrRtxDelayStarted(ticks)
+#endif
+
+/**
+ \brief Event on delay until specified time started (Op)
+ \param[in] ticks \ref CMSIS_RTOS_TimeOutValue "time ticks" value.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_WAIT != 0) && !defined(EVR_RTX_DELAY_UNTIL_STARTED_DISABLE))
+extern void EvrRtxDelayUntilStarted (uint32_t ticks);
+#else
+#define EvrRtxDelayUntilStarted(ticks)
+#endif
+
+/**
+ \brief Event on delay completed (Op)
+ \param[in] thread_id thread ID obtained by \ref osThreadNew or \ref osThreadGetId.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_WAIT != 0) && !defined(EVR_RTX_DELAY_COMPLETED_DISABLE))
+extern void EvrRtxDelayCompleted (osThreadId_t thread_id);
+#else
+#define EvrRtxDelayCompleted(thread_id)
+#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.
+ \param[in] name pointer to timer object name.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_TIMER != 0) && !defined(EVR_RTX_TIMER_CREATED_DISABLE))
+extern void EvrRtxTimerCreated (osTimerId_t timer_id, const char *name);
+#else
+#define EvrRtxTimerCreated(timer_id, name)
+#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.
+ \param[in] name pointer to event flags object name.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_EVFLAGS != 0) && !defined(EVR_RTX_EVENT_FLAGS_CREATED_DISABLE))
+extern void EvrRtxEventFlagsCreated (osEventFlagsId_t ef_id, const char *name);
+#else
+#define EvrRtxEventFlagsCreated(ef_id, name)
+#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, uint32_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.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_EVFLAGS != 0) && !defined(EVR_RTX_EVENT_FLAGS_SET_DONE_DISABLE))
+extern void EvrRtxEventFlagsSetDone (osEventFlagsId_t ef_id, uint32_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, uint32_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.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_EVFLAGS != 0) && !defined(EVR_RTX_EVENT_FLAGS_CLEAR_DONE_DISABLE))
+extern void EvrRtxEventFlagsClearDone (osEventFlagsId_t ef_id, uint32_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, uint32_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, uint32_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, uint32_t flags, uint32_t options, uint32_t timeout);
+#else
+#define EvrRtxEventFlagsWaitPending(ef_id, flags, options, timeout)
+#endif
+
+/**
+ \brief Event on wait timeout for event flags (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_WAIT_TIMEOUT_DISABLE))
+extern void EvrRtxEventFlagsWaitTimeout (osEventFlagsId_t ef_id);
+#else
+#define EvrRtxEventFlagsWaitTimeout(ef_id)
+#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, uint32_t flags, uint32_t options, uint32_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, uint32_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.
+ \param[in] name pointer to mutex object name.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MUTEX != 0) && !defined(EVR_RTX_MUTEX_CREATED_DISABLE))
+extern void EvrRtxMutexCreated (osMutexId_t mutex_id, const char *name);
+#else
+#define EvrRtxMutexCreated(mutex_id, name)
+#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 mutex acquire timeout (Op)
+ \param[in] mutex_id mutex ID obtained by \ref osMutexNew.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MUTEX != 0) && !defined(EVR_RTX_MUTEX_ACQUIRE_TIMEOUT_DISABLE))
+extern void EvrRtxMutexAcquireTimeout (osMutexId_t mutex_id);
+#else
+#define EvrRtxMutexAcquireTimeout(mutex_id)
+#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.
+ \param[in] name pointer to semaphore object name.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_SEMAPHORE != 0) && !defined(EVR_RTX_SEMAPHORE_CREATED_DISABLE))
+extern void EvrRtxSemaphoreCreated (osSemaphoreId_t semaphore_id, const char *name);
+#else
+#define EvrRtxSemaphoreCreated(semaphore_id, name)
+#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 semaphore acquire timeout (Op)
+ \param[in] semaphore_id semaphore ID obtained by \ref osSemaphoreNew.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_SEMAPHORE != 0) && !defined(EVR_RTX_SEMAPHORE_ACQUIRE_TIMEOUT_DISABLE))
+extern void EvrRtxSemaphoreAcquireTimeout (osSemaphoreId_t semaphore_id);
+#else
+#define EvrRtxSemaphoreAcquireTimeout(semaphore_id)
+#endif
+
+/**
+ \brief Event on successful semaphore acquire (Op)
+ \param[in] semaphore_id semaphore ID obtained by \ref osSemaphoreNew.
+ \param[in] tokens number of available tokens.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_SEMAPHORE != 0) && !defined(EVR_RTX_SEMAPHORE_ACQUIRED_DISABLE))
+extern void EvrRtxSemaphoreAcquired (osSemaphoreId_t semaphore_id, uint32_t tokens);
+#else
+#define EvrRtxSemaphoreAcquired(semaphore_id, tokens)
+#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.
+ \param[in] tokens number of available tokens.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_SEMAPHORE != 0) && !defined(EVR_RTX_SEMAPHORE_RELEASED_DISABLE))
+extern void EvrRtxSemaphoreReleased (osSemaphoreId_t semaphore_id, uint32_t tokens);
+#else
+#define EvrRtxSemaphoreReleased(semaphore_id, tokens)
+#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.
+ \param[in] name pointer to memory pool object name.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MEMPOOL != 0) && !defined(EVR_RTX_MEMORY_POOL_CREATED_DISABLE))
+extern void EvrRtxMemoryPoolCreated (osMemoryPoolId_t mp_id, const char *name);
+#else
+#define EvrRtxMemoryPoolCreated(mp_id, name)
+#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 memory pool allocation timeout (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_TIMEOUT_DISABLE))
+extern void EvrRtxMemoryPoolAllocTimeout (osMemoryPoolId_t mp_id);
+#else
+#define EvrRtxMemoryPoolAllocTimeout(mp_id)
+#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.
+ \param[in] name pointer to message queue object name.
+*/
+#if (!defined(EVR_RTX_DISABLE) && (OS_EVR_MSGQUEUE != 0) && !defined(EVR_RTX_MESSAGE_QUEUE_CREATED_DISABLE))
+extern void EvrRtxMessageQueueCreated (osMessageQueueId_t mq_id, const char *name);
+#else
+#define EvrRtxMessageQueueCreated(mq_id, name)
+#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 message put timeout (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_PUT_TIMEOUT_DISABLE))
+extern void EvrRtxMessageQueuePutTimeout (osMessageQueueId_t mq_id);
+#else
+#define EvrRtxMessageQueuePutTimeout(mq_id)
+#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 message get timeout (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_GET_TIMEOUT_DISABLE))
+extern void EvrRtxMessageQueueGetTimeout (osMessageQueueId_t mq_id);
+#else
+#define EvrRtxMessageQueueGetTimeout(mq_id)
+#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/Include/rtx_os.h b/CMSIS/RTOS2/RTX/Include/rtx_os.h
new file mode 100644
index 0000000..2b348cc
--- /dev/null
+++ b/CMSIS/RTOS2/RTX/Include/rtx_os.h
@@ -0,0 +1,472 @@
+/*
+ * Copyright (c) 2013-2019 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 OS definitions
+ *
+ * -----------------------------------------------------------------------------
+ */
+
+#ifndef RTX_OS_H_
+#define RTX_OS_H_
+
+#include <stdint.h>
+#include <stddef.h>
+#include "cmsis_os2.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+
+/// Kernel Information
+#define osRtxVersionAPI 20010003 ///< API version (2.1.3)
+#define osRtxVersionKernel 50050000 ///< Kernel version (5.5.0)
+#define osRtxKernelId "RTX V5.5.0" ///< Kernel identification string
+
+
+// ==== Common definitions ====
+
+/// Object Identifier definitions
+#define osRtxIdInvalid 0x00U
+#define osRtxIdThread 0xF1U
+#define osRtxIdTimer 0xF2U
+#define osRtxIdEventFlags 0xF3U
+#define osRtxIdMutex 0xF5U
+#define osRtxIdSemaphore 0xF6U
+#define osRtxIdMemoryPool 0xF7U
+#define osRtxIdMessage 0xF9U
+#define osRtxIdMessageQueue 0xFAU
+
+/// Object Flags definitions
+#define osRtxFlagSystemObject 0x01U
+#define osRtxFlagSystemMemory 0x02U
+
+
+// ==== Kernel definitions ====
+
+/// Kernel State definitions
+#define osRtxKernelInactive ((uint8_t)osKernelInactive)
+#define osRtxKernelReady ((uint8_t)osKernelReady)
+#define osRtxKernelRunning ((uint8_t)osKernelRunning)
+#define osRtxKernelLocked ((uint8_t)osKernelLocked)
+#define osRtxKernelSuspended ((uint8_t)osKernelSuspended)
+
+
+// ==== Thread definitions ====
+
+/// Thread State definitions (extending osThreadState)
+#define osRtxThreadStateMask 0x0FU
+
+#define osRtxThreadInactive ((uint8_t)osThreadInactive)
+#define osRtxThreadReady ((uint8_t)osThreadReady)
+#define osRtxThreadRunning ((uint8_t)osThreadRunning)
+#define osRtxThreadBlocked ((uint8_t)osThreadBlocked)
+#define osRtxThreadTerminated ((uint8_t)osThreadTerminated)
+
+#define osRtxThreadWaitingDelay ((uint8_t)(osRtxThreadBlocked | 0x10U))
+#define osRtxThreadWaitingJoin ((uint8_t)(osRtxThreadBlocked | 0x20U))
+#define osRtxThreadWaitingThreadFlags ((uint8_t)(osRtxThreadBlocked | 0x30U))
+#define osRtxThreadWaitingEventFlags ((uint8_t)(osRtxThreadBlocked | 0x40U))
+#define osRtxThreadWaitingMutex ((uint8_t)(osRtxThreadBlocked | 0x50U))
+#define osRtxThreadWaitingSemaphore ((uint8_t)(osRtxThreadBlocked | 0x60U))
+#define osRtxThreadWaitingMemoryPool ((uint8_t)(osRtxThreadBlocked | 0x70U))
+#define osRtxThreadWaitingMessageGet ((uint8_t)(osRtxThreadBlocked | 0x80U))
+#define osRtxThreadWaitingMessagePut ((uint8_t)(osRtxThreadBlocked | 0x90U))
+
+/// Thread Flags definitions
+#define osRtxThreadFlagDefStack 0x10U ///< Default Stack flag
+
+/// Stack Marker definitions
+#define osRtxStackMagicWord 0xE25A2EA5U ///< Stack Magic Word (Stack Base)
+#define osRtxStackFillPattern 0xCCCCCCCCU ///< Stack Fill Pattern
+
+/// Thread Control Block
+typedef struct osRtxThread_s {
+ uint8_t id; ///< Object Identifier
+ uint8_t state; ///< Object State
+ uint8_t flags; ///< Object Flags
+ uint8_t attr; ///< Object Attributes
+ const char *name; ///< Object Name
+ struct osRtxThread_s *thread_next; ///< Link pointer to next Thread in Object list
+ struct osRtxThread_s *thread_prev; ///< Link pointer to previous Thread in Object list
+ struct osRtxThread_s *delay_next; ///< Link pointer to next Thread in Delay list
+ struct osRtxThread_s *delay_prev; ///< Link pointer to previous Thread in Delay list
+ struct osRtxThread_s *thread_join; ///< Thread waiting to Join
+ uint32_t delay; ///< Delay Time
+ int8_t priority; ///< Thread Priority
+ int8_t priority_base; ///< Base Priority
+ uint8_t stack_frame; ///< Stack Frame (EXC_RETURN[7..0])
+ uint8_t flags_options; ///< Thread/Event Flags Options
+ uint32_t wait_flags; ///< Waiting Thread/Event Flags
+ uint32_t thread_flags; ///< Thread Flags
+ struct osRtxMutex_s *mutex_list; ///< Link pointer to list of owned Mutexes
+ void *stack_mem; ///< Stack Memory
+ uint32_t stack_size; ///< Stack Size
+ uint32_t sp; ///< Current Stack Pointer
+ uint32_t thread_addr; ///< Thread entry address
+ uint32_t tz_memory; ///< TrustZone Memory Identifier
+#ifdef RTX_TF_M_EXTENSION
+ uint32_t tz_module; ///< TrustZone Module Identifier
+#endif
+} osRtxThread_t;
+
+
+// ==== Timer definitions ====
+
+/// Timer State definitions
+#define osRtxTimerInactive 0x00U ///< Timer Inactive
+#define osRtxTimerStopped 0x01U ///< Timer Stopped
+#define osRtxTimerRunning 0x02U ///< Timer Running
+
+/// Timer Type definitions
+#define osRtxTimerPeriodic ((uint8_t)osTimerPeriodic)
+
+/// Timer Function Information
+typedef struct {
+ osTimerFunc_t func; ///< Function Pointer
+ void *arg; ///< Function Argument
+} osRtxTimerFinfo_t;
+
+/// Timer Control Block
+typedef struct osRtxTimer_s {
+ uint8_t id; ///< Object Identifier
+ uint8_t state; ///< Object State
+ uint8_t flags; ///< Object Flags
+ uint8_t type; ///< Timer Type (Periodic/One-shot)
+ const char *name; ///< Object Name
+ struct osRtxTimer_s *prev; ///< Pointer to previous active Timer
+ struct osRtxTimer_s *next; ///< Pointer to next active Timer
+ uint32_t tick; ///< Timer current Tick
+ uint32_t load; ///< Timer Load value
+ osRtxTimerFinfo_t finfo; ///< Timer Function Info
+} osRtxTimer_t;
+
+
+// ==== Event Flags definitions ====
+
+/// Event Flags Control Block
+typedef struct {
+ uint8_t id; ///< Object Identifier
+ uint8_t reserved_state; ///< Object State (not used)
+ uint8_t flags; ///< Object Flags
+ uint8_t reserved;
+ const char *name; ///< Object Name
+ osRtxThread_t *thread_list; ///< Waiting Threads List
+ uint32_t event_flags; ///< Event Flags
+} osRtxEventFlags_t;
+
+
+// ==== Mutex definitions ====
+
+/// Mutex Control Block
+typedef struct osRtxMutex_s {
+ uint8_t id; ///< Object Identifier
+ uint8_t reserved_state; ///< Object State (not used)
+ uint8_t flags; ///< Object Flags
+ uint8_t attr; ///< Object Attributes
+ const char *name; ///< Object Name
+ osRtxThread_t *thread_list; ///< Waiting Threads List
+ osRtxThread_t *owner_thread; ///< Owner Thread
+ struct osRtxMutex_s *owner_prev; ///< Pointer to previous owned Mutex
+ struct osRtxMutex_s *owner_next; ///< Pointer to next owned Mutex
+ uint8_t lock; ///< Lock counter
+ uint8_t padding[3];
+} osRtxMutex_t;
+
+
+// ==== Semaphore definitions ====
+
+/// Semaphore Control Block
+typedef struct {
+ uint8_t id; ///< Object Identifier
+ uint8_t reserved_state; ///< Object State (not used)
+ uint8_t flags; ///< Object Flags
+ uint8_t reserved;
+ const char *name; ///< Object Name
+ osRtxThread_t *thread_list; ///< Waiting Threads List
+ uint16_t tokens; ///< Current number of tokens
+ uint16_t max_tokens; ///< Maximum number of tokens
+} osRtxSemaphore_t;
+
+
+// ==== Memory Pool definitions ====
+
+/// Memory Pool Information
+typedef struct {
+ uint32_t max_blocks; ///< Maximum number of Blocks
+ uint32_t used_blocks; ///< Number of used Blocks
+ uint32_t block_size; ///< Block Size
+ void *block_base; ///< Block Memory Base Address
+ void *block_lim; ///< Block Memory Limit Address
+ void *block_free; ///< First free Block Address
+} osRtxMpInfo_t;
+
+/// Memory Pool Control Block
+typedef struct {
+ uint8_t id; ///< Object Identifier
+ uint8_t reserved_state; ///< Object State (not used)
+ uint8_t flags; ///< Object Flags
+ uint8_t reserved;
+ const char *name; ///< Object Name
+ osRtxThread_t *thread_list; ///< Waiting Threads List
+ osRtxMpInfo_t mp_info; ///< Memory Pool Info
+} osRtxMemoryPool_t;
+
+
+// ==== Message Queue definitions ====
+
+/// Message Control Block
+typedef struct osRtxMessage_s {
+ uint8_t id; ///< Object Identifier
+ uint8_t reserved_state; ///< Object State (not used)
+ uint8_t flags; ///< Object Flags
+ uint8_t priority; ///< Message Priority
+ struct osRtxMessage_s *prev; ///< Pointer to previous Message
+ struct osRtxMessage_s *next; ///< Pointer to next Message
+} osRtxMessage_t;
+
+/// Message Queue Control Block
+typedef struct {
+ uint8_t id; ///< Object Identifier
+ uint8_t reserved_state; ///< Object State (not used)
+ uint8_t flags; ///< Object Flags
+ uint8_t reserved;
+ const char *name; ///< Object Name
+ osRtxThread_t *thread_list; ///< Waiting Threads List
+ osRtxMpInfo_t mp_info; ///< Memory Pool Info
+ uint32_t msg_size; ///< Message Size
+ uint32_t msg_count; ///< Number of queued Messages
+ osRtxMessage_t *msg_first; ///< Pointer to first Message
+ osRtxMessage_t *msg_last; ///< Pointer to last Message
+} osRtxMessageQueue_t;
+
+
+// ==== Generic Object definitions ====
+
+/// Generic Object Control Block
+typedef struct {
+ uint8_t id; ///< Object Identifier
+ uint8_t state; ///< Object State
+ uint8_t flags; ///< Object Flags
+ uint8_t reserved;
+ const char *name; ///< Object Name
+ osRtxThread_t *thread_list; ///< Threads List
+} osRtxObject_t;
+
+
+// ==== OS Runtime Information definitions ====
+
+/// OS Runtime Information structure
+typedef struct {
+ const char *os_id; ///< OS Identification
+ uint32_t version; ///< OS Version
+ struct { ///< Kernel Info
+ uint8_t state; ///< State
+ volatile uint8_t blocked; ///< Blocked
+ uint8_t pendSV; ///< Pending SV
+ uint8_t reserved;
+ uint32_t tick; ///< Tick counter
+ } kernel;
+ int32_t tick_irqn; ///< Tick Timer IRQ Number
+ struct { ///< Thread Info
+ struct { ///< Thread Run Info
+ osRtxThread_t *curr; ///< Current running Thread
+ osRtxThread_t *next; ///< Next Thread to Run
+ } run;
+ osRtxObject_t ready; ///< Ready List Object
+ osRtxThread_t *idle; ///< Idle Thread
+ osRtxThread_t *delay_list; ///< Delay List
+ osRtxThread_t *wait_list; ///< Wait List (no Timeout)
+ osRtxThread_t *terminate_list; ///< Terminate Thread List
+ struct { ///< Thread Round Robin Info
+ osRtxThread_t *thread; ///< Round Robin Thread
+ uint32_t tick; ///< Round Robin Time Tick
+ uint32_t timeout; ///< Round Robin Timeout
+ } robin;
+ } thread;
+ struct { ///< Timer Info
+ osRtxTimer_t *list; ///< Active Timer List
+ osRtxThread_t *thread; ///< Timer Thread
+ osRtxMessageQueue_t *mq; ///< Timer Message Queue
+ void (*tick)(void); ///< Timer Tick Function
+ } timer;
+ struct { ///< ISR Post Processing Queue
+ uint16_t max; ///< Maximum Items
+ uint16_t cnt; ///< Item Count
+ uint16_t in; ///< Incoming Item Index
+ uint16_t out; ///< Outgoing Item Index
+ void **data; ///< Queue Data
+ } isr_queue;
+ struct { ///< ISR Post Processing functions
+ void (*thread)(osRtxThread_t*); ///< Thread Post Processing function
+ void (*event_flags)(osRtxEventFlags_t*); ///< Event Flags Post Processing function
+ void (*semaphore)(osRtxSemaphore_t*); ///< Semaphore Post Processing function
+ void (*memory_pool)(osRtxMemoryPool_t*); ///< Memory Pool Post Processing function
+ void (*message)(osRtxMessage_t*); ///< Message Post Processing function
+ } post_process;
+ struct { ///< Memory Pools (Variable Block Size)
+ void *stack; ///< Stack Memory
+ void *mp_data; ///< Memory Pool Data Memory
+ void *mq_data; ///< Message Queue Data Memory
+ void *common; ///< Common Memory
+ } mem;
+ struct { ///< Memory Pools (Fixed Block Size)
+ osRtxMpInfo_t *stack; ///< Stack for Threads
+ osRtxMpInfo_t *thread; ///< Thread Control Blocks
+ osRtxMpInfo_t *timer; ///< Timer Control Blocks
+ osRtxMpInfo_t *event_flags; ///< Event Flags Control Blocks
+ osRtxMpInfo_t *mutex; ///< Mutex Control Blocks
+ osRtxMpInfo_t *semaphore; ///< Semaphore Control Blocks
+ osRtxMpInfo_t *memory_pool; ///< Memory Pool Control Blocks
+ osRtxMpInfo_t *message_queue; ///< Message Queue Control Blocks
+ } mpi;
+} osRtxInfo_t;
+
+extern osRtxInfo_t osRtxInfo; ///< OS Runtime Information
+
+/// OS Runtime Object Memory Usage structure
+typedef struct {
+ uint32_t cnt_alloc; ///< Counter for alloc
+ uint32_t cnt_free; ///< Counter for free
+ uint32_t max_used; ///< Maximum used
+} osRtxObjectMemUsage_t;
+
+/// OS Runtime Object Memory Usage variables
+extern osRtxObjectMemUsage_t osRtxThreadMemUsage;
+extern osRtxObjectMemUsage_t osRtxTimerMemUsage;
+extern osRtxObjectMemUsage_t osRtxEventFlagsMemUsage;
+extern osRtxObjectMemUsage_t osRtxMutexMemUsage;
+extern osRtxObjectMemUsage_t osRtxSemaphoreMemUsage;
+extern osRtxObjectMemUsage_t osRtxMemoryPoolMemUsage;
+extern osRtxObjectMemUsage_t osRtxMessageQueueMemUsage;
+
+
+// ==== OS API definitions ====
+
+// Object Limits definitions
+#define osRtxThreadFlagsLimit 31U ///< number of Thread Flags available per thread
+#define osRtxEventFlagsLimit 31U ///< number of Event Flags available per object
+#define osRtxMutexLockLimit 255U ///< maximum number of recursive mutex locks
+#define osRtxSemaphoreTokenLimit 65535U ///< maximum number of tokens per semaphore
+
+// Control Block sizes
+#define osRtxThreadCbSize sizeof(osRtxThread_t)
+#define osRtxTimerCbSize sizeof(osRtxTimer_t)
+#define osRtxEventFlagsCbSize sizeof(osRtxEventFlags_t)
+#define osRtxMutexCbSize sizeof(osRtxMutex_t)
+#define osRtxSemaphoreCbSize sizeof(osRtxSemaphore_t)
+#define osRtxMemoryPoolCbSize sizeof(osRtxMemoryPool_t)
+#define osRtxMessageQueueCbSize sizeof(osRtxMessageQueue_t)
+
+/// Memory size in bytes for Memory Pool storage.
+/// \param block_count maximum number of memory blocks in memory pool.
+/// \param block_size memory block size in bytes.
+#define osRtxMemoryPoolMemSize(block_count, block_size) \
+ (4*(block_count)*(((block_size)+3)/4))
+
+/// Memory size in bytes for Message Queue storage.
+/// \param msg_count maximum number of messages in queue.
+/// \param msg_size maximum message size in bytes.
+#define osRtxMessageQueueMemSize(msg_count, msg_size) \
+ (4*(msg_count)*(3+(((msg_size)+3)/4)))
+
+
+// ==== OS External Functions ====
+
+// OS Error Codes
+#define osRtxErrorStackUnderflow 1U ///< Stack overflow, i.e. stack pointer below its lower memory limit for descending stacks.
+#define osRtxErrorISRQueueOverflow 2U ///< ISR Queue overflow detected when inserting object.
+#define osRtxErrorTimerQueueOverflow 3U ///< User Timer Callback Queue overflow detected for timer.
+#define osRtxErrorClibSpace 4U ///< Standard C/C++ library libspace not available: increase \c OS_THREAD_LIBSPACE_NUM.
+#define osRtxErrorClibMutex 5U ///< Standard C/C++ library mutex initialization failed.
+
+/// OS Error Callback function
+extern uint32_t osRtxErrorNotify (uint32_t code, void *object_id);
+
+/// OS Idle Thread
+extern void osRtxIdleThread (void *argument);
+
+/// OS Exception handlers
+extern void SVC_Handler (void);
+extern void PendSV_Handler (void);
+extern void SysTick_Handler (void);
+
+/// OS Trusted Firmware M Extension
+#ifdef RTX_TF_M_EXTENSION
+extern uint32_t osRtxTzGetModuleId (void);
+#endif
+
+
+// ==== OS External Configuration ====
+
+/// OS Configuration flags
+#define osRtxConfigPrivilegedMode (1UL<<0) ///< Threads in Privileged mode
+#define osRtxConfigStackCheck (1UL<<1) ///< Stack overrun checking
+#define osRtxConfigStackWatermark (1UL<<2) ///< Stack usage Watermark
+
+/// OS Configuration structure
+typedef struct {
+ uint32_t flags; ///< OS Configuration Flags
+ uint32_t tick_freq; ///< Kernel Tick Frequency
+ uint32_t robin_timeout; ///< Round Robin Timeout Tick
+ struct { ///< ISR Post Processing Queue
+ void **data; ///< Queue Data
+ uint16_t max; ///< Maximum Items
+ uint16_t padding;
+ } isr_queue;
+ struct { ///< Memory Pools (Variable Block Size)
+ void *stack_addr; ///< Stack Memory Address
+ uint32_t stack_size; ///< Stack Memory Size
+ void *mp_data_addr; ///< Memory Pool Memory Address
+ uint32_t mp_data_size; ///< Memory Pool Memory Size
+ void *mq_data_addr; ///< Message Queue Data Memory Address
+ uint32_t mq_data_size; ///< Message Queue Data Memory Size
+ void *common_addr; ///< Common Memory Address
+ uint32_t common_size; ///< Common Memory Size
+ } mem;
+ struct { ///< Memory Pools (Fixed Block Size)
+ osRtxMpInfo_t *stack; ///< Stack for Threads
+ osRtxMpInfo_t *thread; ///< Thread Control Blocks
+ osRtxMpInfo_t *timer; ///< Timer Control Blocks
+ osRtxMpInfo_t *event_flags; ///< Event Flags Control Blocks
+ osRtxMpInfo_t *mutex; ///< Mutex Control Blocks
+ osRtxMpInfo_t *semaphore; ///< Semaphore Control Blocks
+ osRtxMpInfo_t *memory_pool; ///< Memory Pool Control Blocks
+ osRtxMpInfo_t *message_queue; ///< Message Queue Control Blocks
+ } mpi;
+ uint32_t thread_stack_size; ///< Default Thread Stack Size
+ const
+ osThreadAttr_t *idle_thread_attr; ///< Idle Thread Attributes
+ const
+ osThreadAttr_t *timer_thread_attr; ///< Timer Thread Attributes
+ const
+ osMessageQueueAttr_t *timer_mq_attr; ///< Timer Message Queue Attributes
+ uint32_t timer_mq_mcnt; ///< Timer Message Queue maximum Messages
+} osRtxConfig_t;
+
+extern const osRtxConfig_t osRtxConfig; ///< OS Configuration
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // RTX_OS_H_