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