#ifndef __CMSIS_OS_H__
#define __CMSIS_OS_H__
#include <stdint.h>
#include <stddef.h>
#include "RTOS.h"
// API version (main [31:16] .sub [15:0])
#define osCMSIS 0x10002
// RTOS identification and version (main [31:16] .sub [15:0])
#define osCMSIS_RTX ((4<<16)|00)
// RTOS identification string
#define osKernelSystemId "EMBOS V4.00"
//
// main thread 1=main can be thread, 0=not available
#define osFeature_MainThread 1
//
// Memory Pools: 1=available, 0=not available
#define osFeature_Pool 1
//
// Mail Queues: 1=available, 0=not available
#define osFeature_MailQ 1
//
// Message Queues: 1=available, 0=not available
#define osFeature_MessageQ 1
//
// maximum number of Signal Flags available per thread
// bit31 = 0x80000000 : incorrect parameters
#define osFeature_Signals 31
//
// maximum count for osSemaphoreCreate function
#define osFeature_Semaphore 0xFFFFFFFF
//
// osWait function: 1=available, 0=not available
#define osFeature_Wait 0
//
// osKernelSysTick functions: 1=available, 0=not available
#define osFeature_SysTick 1
//
//
//
#ifdef __cplusplus
extern "C"
{
#endif
// ==== Enumeration, structures, defines =======================================
//
// Priority used for thread control.
// MUST REMAIN UNCHANGED: osPriority shall be consistent in every CMSIS-RTOS.
//
typedef
enum
{
osPriorityIdle = -
3,
// priority: idle (lowest)
osPriorityLow = -
2,
// priority: low
osPriorityBelowNormal = -
1,
// priority: below normal
osPriorityNormal =
0,
// priority: normal (default)
osPriorityAboveNormal = +
1,
// priority: above normal
osPriorityHigh = +
2,
// priority: high
osPriorityRealtime = +
3,
// priority: realtime (highest)
osPriorityError =
0x84 // system cannot determine priority
} osPriority;
// or thread has illegal priority
// Timeout value.
// MUST REMAIN UNCHANGED: osWaitForever shall be consistent in every CMSIS-RTOS.
//
#define osWaitForever 0xFFFFFFFF
// wait forever timeout value
// Status code values returned by CMSIS-RTOS functions.
// MUST REMAIN UNCHANGED: osStatus shall be consistent in every CMSIS-RTOS.
//
typedef
enum
{
// function completed; no error or event occurred.
osOK =
0,
//
// function completed; signal event occurred.
osEventSignal =
0x08,
// function completed; message event occurred.
osEventMessage =
0x10,
// function completed; mail event occurred.
osEventMail =
0x20,
//
// function completed; timeout occurred.
osEventTimeout =
0x40,
//
// parameter error: a mandatory parameter was missing or specified an incorrect object.
osErrorParameter =
0x80,
//
// resource not available: a specified resource was not available.
osErrorResource =
0x81,
// resource not available within given time: a specified resource was not available within the timeout period.
osErrorTimeoutResource =
0xC1,
// not allowed in ISR context: the function cannot be called from interrupt service routines.
osErrorISR =
0x82,
// function called multiple times from ISR with same object.
osErrorISRRecursive =
0x83,
// system cannot determine priority or thread has illegal priority.
osErrorPriority =
0x84,
// system is out of memory: it was impossible to allocate or reserve memory for the operation.
osErrorNoMemory =
0x85,
// value of a parameter is out of range.
osErrorValue =
0x86,
// unspecified RTOS error: run-time error but no other error message fits.
osErrorOS =
0xFF,
//
os_status_reserved =
0x7FFFFFFF
// prevent from enum down-size compiler optimization.
// 32 bits for osStatus
} osStatus;
// Timer type value for the timer definition.
// MUST REMAIN UNCHANGED: os_timer_type shall be consistent in every CMSIS-RTOS.
//
typedef
enum
{
osTimerOnce =
0,
// one-shot timer
osTimerPeriodic =
1 // repeating timer --- EMBOS can not support !
} os_timer_type;
typedef struct _CMSIS_OS_GLOBAL
{
uint32_t dummy;
} CMSIS_OS_GLOBAL;
extern CMSIS_OS_GLOBAL os_global;
// Entry point of a thread.
// MUST REMAIN UNCHANGED: os_pthread shall be consistent in every CMSIS-RTOS.
//
typedef
void (*os_pthread)(
void *
argument );
// Entry point of a timer call back function.
// MUST REMAIN UNCHANGED: os_ptimer shall be consistent in every CMSIS-RTOS.
//
typedef
void (*os_ptimer)(
void *
argument );
// >>> the following data type definitions may shall adapted towards a specific RTOS
// Thread ID identifies the thread (pointer to a thread control block).
// CAN BE CHANGED: os_thread_cb is implementation specific in every CMSIS-RTOS.
//
typedef OS_TASK osThreadType;
typedef osThreadType *
osThreadId;
// Timer ID identifies the timer (pointer to a timer control block).
// CAN BE CHANGED: os_timer_cb is implementation specific in every CMSIS-RTOS.
//
typedef OS_TIMER_EX osTimerType;
typedef osTimerType *
osTimerId;
// Mutex ID identifies the mutex (pointer to a mutex control block).
// CAN BE CHANGED: os_mutex_cb is implementation specific in every CMSIS-RTOS.
//
typedef OS_RSEMA osMutexType;
typedef osMutexType *
osMutexId;
// Semaphore ID identifies the semaphore (pointer to a semaphore control block).
// CAN BE CHANGED: os_semaphore_cb is implementation specific in every CMSIS-RTOS.
//
typedef OS_CSEMA osSemaphoreType;
typedef osSemaphoreType *
osSemaphoreId;
// Pool ID identifies the memory pool (pointer to a memory pool control block).
// CAN BE CHANGED: os_pool_cb is implementation specific in every CMSIS-RTOS.
//
typedef OS_MEMF osPoolType;
typedef osPoolType *
osPoolId;
// Message ID identifies the message queue (pointer to a message queue control block).
// CAN BE CHANGED: os_messageQ_cb is implementation specific in every CMSIS-RTOS.
//
// OS_MAILBOX : Messages of fixed size
// CMSIS_OS : Messages of fixed size : 4 Bytes for Value or Pointer
//
typedef OS_MAILBOX osMessageQType;
typedef osMessageQType *
osMessageQId;
// Mail ID identifies the mail queue (pointer to a mail queue control block).
// CAN BE CHANGED: os_mailQ_cb is implementation specific in every CMSIS-RTOS.
//
// OS_MAILBOX : Messages of fixed size
// CMSIS_OS : Messages of fixed size : 1..32767 Bytes for Buffer
//
typedef
struct _osMailQ_cb
{
osMessageQId messageId;
osPoolId poolId;
} osMailQType;
typedef osMailQType *
osMailQId;
// Thread Definition structure contains startup information of a thread.
// CAN BE CHANGED: os_thread_def is implementation specific in every CMSIS-RTOS.
//
typedef
struct os_thread_def
{
osThreadId threadId;
uint8_t *
name;
os_pthread pthread; // start address of thread function
osPriority tpriority;
// initial thread priority
uint32_t stacksize;
// stack size requirements in bytes;
uint32_t * stack;
//
} osThreadDef_t;
// Timer Definition structure contains timer parameters.
// CAN BE CHANGED: os_timer_def is implementation specific in every CMSIS-RTOS.
//
typedef
const struct os_timer_def
{
osTimerId timerId;
os_ptimer ptimer;
} osTimerDef_t;
// Mutex Definition structure contains setup information for a mutex.
// CAN BE CHANGED: os_mutex_def is implementation specific in every CMSIS-RTOS.
//
typedef
struct os_mutex_def
{
osMutexId mutexId;
} osMutexDef_t;
// Semaphore Definition structure contains setup information for a semaphore.
// CAN BE CHANGED: os_semaphore_def is implementation specific in every CMSIS-RTOS.
//
typedef
struct os_semaphore_def
{
osSemaphoreId semaphoreId;
} osSemaphoreDef_t;
// Definition structure for memory block allocation.
// CAN BE CHANGED: os_pool_def is implementation specific in every CMSIS-RTOS.
//
typedef
struct os_pool_def
{
osPoolId poolId;
uint32_t pool_sz; // number of items (elements) in the pool
uint32_t item_sz;
// size of an item
void * pool;
// pointer to memory for pool
} osPoolDef_t;
// Definition structure for message queue.
// CAN BE CHANGED: os_messageQ_def is implementation specific in every CMSIS-RTOS.
//
typedef
struct os_messageQ_def
{
osMessageQId messageQId;
uint32_t queue_sz; // number of elements in the queue
void * pool;
// memory array for messages
} osMessageQDef_t;
// Definition structure for mail queue.
// CAN BE CHANGED: os_mailQ_def is implementation specific in every CMSIS-RTOS.
//
typedef
struct os_mailQ_def
{
osMailQId mailId;
osMessageQDef_t *
messageQDef;
osPoolDef_t *
poolDef;
uint32_t queue_sz; // number of elements in the queue
uint32_t item_sz;
// size of an item
} osMailQDef_t;
// Event structure contains detailed information about an event.
// MUST REMAIN UNCHANGED: os_event shall be consistent in every CMSIS-RTOS.
// However the struct may be extended at the end.
//
typedef
struct
{
osStatus status; // status code: event or error information
union
{
uint32_t v; // message as 32-bit value
void * p;
// message or mail as void pointer
int32_t signals;
// signal flags
} value;
// event value
union
{
osMailQId mail_id; // mail id obtained by osMailCreate
osMessageQId message_id;
// message id obtained by osMessageCreate
} def;
// event definition
} osEvent;
// ======= Kernel Control Functions ============================================
// The RTOS kernel system timer frequency in Hz.
// Reflects the system timer setting and is typically defined in a configuration file.
#define osKernelSysTickFrequency ( OS_FSYS )
// The RTOS kernel frequency in Hz.
// Reflects the system timer setting and is typically defined in a configuration file.
#define osKernelTickFrequency ( OS_TICK_FREQ )
//
#define osKernelTickPeriod ( 1 / osKernelTickFrequency )
#define osKernelTicksPerSecond ( osKernelTickFrequency )
#if ( osKernelTickFrequency == 1000 )
#define osKernelTicksPerMilliSec ( 1 )
#else
#define osKernelTicksPerMilliSec ( osKernelTickFrequency / 1000 )
#endif
//
// Convert timeout in millisec to system ticks
#if ( osKernelTickFrequency == 1000 )
#define osKernelTicksByMilliSec( millisec ) ( millisec )
#else
#define osKernelTicksByMilliSec( millisec ) ( ( millisec ) * osKernelTicksPerMilliSec )
#endif
// Convert timeout in second to system ticks
#define osKernelTicksBySecond( second ) ( ( second ) * osKernelTicksPerSecond )
// Convert kernel ticks to millisec
#if ( osKernelTickFrequency == 1000 )
#define osKernelTicks2MilliSec( ticks ) ( ticks )
#else
#define osKernelTicks2MilliSec( ticks ) ( ( ticks ) / osKernelTicksPerMilliSec )
#endif
// Convert kernel ticks to second
#define osKernelTicks2Second( ticks ) ( ( ticks ) / osKernelTicksPerSecond )
//
//
#define osKernelSysTicksPerSecond ( osKernelSysTickFrequency )
#define osKernelSysTicksPerMilliSec ( osKernelSysTickFrequency / 1000 )
//
// Convert timeout in millisec to system ticks
#define osKernelSysTicksByMilliSec( millisec ) ( ( millisec ) * osKernelSysTicksPerMilliSec )
// Convert timeout in second to system ticks
#define osKernelSysTicksBySecond( second ) ( ( second ) * osKernelSysTicksPerSecond )
// Convert system ticks to millisec
#define osKernelSysTicks2MilliSec( ticks ) ( ( ticks ) / osKernelSysTicksPerMilliSec )
// Convert system ticks to second
#define osKernelSysTicks2Second( ticks ) ( ( ticks ) / osKernelSysTicksPerSecond )
//
#define osKernelSysTickMicroSec_i \
( osKernelSysTickFrequency /
1000000 )
//
#define osKernelSysTickMicroSec_f \
( ( ( (uint64_t)( osKernelSysTickFrequency -
1000000 * ( osKernelSysTickFrequency /
1000000 ) ) ) <<
16 ) /
1000000 )
//
// Convert a microseconds value to a RTOS kernel system timer value.
#define osKernelSysTickMicroSec(microsec) \
( ( microsec * osKernelSysTickMicroSec_i ) + ( ( microsec * osKernelSysTickMicroSec_f ) >>
16 ) )
//
#define osKernelSysTickMilliSec(millisec) \
osKernelSysTicksByMilliSec(millisec)
// return RTOS kernel time as 32-bit value in milli second
//
//#include "rt_Time.h"
//#define osKernelTickTime ( os_time / osKernelTicksPerMilliSec )
//
#define osKernelTickTime ( OS_Time / osKernelTicksPerMilliSec )
#define osKernelTickCount() OS_GetTime32()
#define osKernelSysTick() OS_GetTime_Cycles()
osStatus osKernelInitialize( void );
osStatus osKernelStart( void );
int32_t osKernelRunning( void );
// ======= Thread Management ===================================================
//
// Create a Thread Definition with function, priority, and stack requirements.
// param name name of the thread function.
// param priority initial priority of the thread function.
// param instances number of possible thread instances.
// param stacksz stack size (in bytes) requirements for the thread function.
// CAN BE CHANGED: The parameters to osThreadDef shall be consistent but the
// macro body is implementation specific in every CMSIS-RTOS.
//
#if defined (osObjectsExternal)
#define osThreadDef(name, thread, priority, instances, stacksz) \
extern osThreadDef_t os_thread_def_##name
#else
#define osThreadDef(name, thread, priority, instances, stacksz) \
OS_TASK os_thread_id_##name; \
uint32_t os_thread_stack_##name[ ( (stacksz ? stacksz : OS_STKSIZE ) +
3 ) /
4]; \
osThreadDef_t os_thread_def_##name =
\
{ &
os_thread_id_##name, #name, (os_pthread)(thread), (priority),\
(( ( (stacksz ? stacksz : OS_STKSIZE ) +
3 ) /
4) <<
2 ), \
os_thread_stack_##name }
#endif
#define osThread(name) \
&
os_thread_def_##name
osThreadId osThreadCreate( osThreadDef_t * thread_def,
void *
argument );
osThreadId osThreadGetId( void );
osStatus osThreadTerminate( osThreadId thread_id );
osStatus osThreadYield( void );
osStatus osThreadSetPriority( osThreadId thread_id, osPriority priority );
osPriority osThreadGetPriority( osThreadId thread_id );
// ======= Generic Wait Functions ==============================================
//
// Wait for Timeout (Time Delay).
// param[in] millisec time delay value
// return status code that indicates the execution status of the function.
//
osStatus osDelay( uint32_t millisec );
#if (defined (osFeature_Wait) && (osFeature_Wait != 0))
osEvent osWait( uint32_t millisec );
#endif
// ======= Timer Management Functions ==========================================
//
// Define a Timer object.
// param name name of the timer object.
// param function name of the timer call back function.
// CAN BE CHANGED: The parameter to osTimerDef shall be consistent but the
// macro body is implementation specific in every CMSIS-RTOS.
#if defined (osObjectsExternal)
#define osTimerDef(name, function) \
extern osTimerDef_t os_timer_def_##name
#else
#define osTimerDef(name, function) \
OS_TIMER_EX os_timer_id_##name; \
osTimerDef_t os_timer_def_##name =
\
{&
os_timer_id_##name, (function) }
#endif
#define osTimer(name) \
&
os_timer_def_##name
osTimerId osTimerCreate( osTimerDef_t *
timer_def, os_timer_type type,
void *
argument );
osStatus osTimerStart( osTimerId timer_id, uint32_t millisec );
osStatus osTimerStop( osTimerId timer_id );
osStatus osTimerDelete( osTimerId timer_id );
// ======= Signal Management ===================================================
//
int32_t osSignalSet( osThreadId thread_id, int32_t signals );
int32_t osSignalClear( osThreadId thread_id, int32_t signals );
osEvent osSignalWait( int32_t signals, uint32_t millisec );
// ======= Mutex Management ====================================================
#if defined (osObjectsExternal)
#define osMutexDef(name) \
extern osMutexDef_t os_mutex_def_##name
#else
#define osMutexDef(name) \
OS_RSEMA os_mutex_id_##name; \
osMutexDef_t os_mutex_def_##name = { &
os_mutex_id_##name }
#endif
#define osMutex(name) \
&
os_mutex_def_##name
osMutexId osMutexCreate( osMutexDef_t *
mutex_def );
osStatus osMutexWait( osMutexId mutex_id, uint32_t millisec );
osStatus osMutexRelease( osMutexId mutex_id );
osStatus osMutexDelete( osMutexId mutex_id );
// ======= Semaphore Management Functions ======================================
#if (defined (osFeature_Semaphore) && (osFeature_Semaphore != 0))
//
// Define a Semaphore object.
// param name name of the semaphore object.
// CAN BE CHANGED: The parameter to osSemaphoreDef shall be consistent but the
// macro body is implementation specific in every CMSIS-RTOS.
//
#if defined (osObjectsExternal)
#define osSemaphoreDef(name) \
extern osSemaphoreDef_t os_semaphore_def_##name
#else
#define osSemaphoreDef(name) \
OS_CSEMA os_semaphore_id_##name; \
osSemaphoreDef_t os_semaphore_def_##name = { &
os_semaphore_id_##name }
#endif
#define osSemaphore(name) \
&
os_semaphore_def_##name
osSemaphoreId osSemaphoreCreate( osSemaphoreDef_t *
semaphore_def,
int32_t count );
int32_t osSemaphoreWait( osSemaphoreId semaphore_id, uint32_t millisec );
osStatus osSemaphoreRelease( osSemaphoreId semaphore_id );
osStatus osSemaphoreDelete( osSemaphoreId semaphore_id );
#endif
// ============= Memory Pool Management Functions ==============================
//
#if (defined (osFeature_Pool) && (osFeature_Pool != 0))
//
// \brief Define a Memory Pool.
// param name name of the memory pool.
// param no maximum number of blocks (objects) in the memory pool.
// param type data type of a single block (object).
// CAN BE CHANGED: The parameter to osPoolDef shall be consistent but the
// macro body is implementation specific in every CMSIS-RTOS.
#if defined (osObjectsExternal)
#define osPoolDef(name, no, type) \
extern osPoolDef_t os_pool_def_##name
#else
#define osPoolDef(name, no, type) \
OS_MEMF os_pool_id_##name; \
uint32_t \
os_pool_m_##name[ ( ( OS_MEMF_SIZEOF_BLOCKCONTROL +
sizeof(type) +
3 ) /
4) *
(no) ]; \
osPoolDef_t \
os_pool_def_##name =
\
{ &
os_pool_id_##name, (no), \
( ( ( OS_MEMF_SIZEOF_BLOCKCONTROL +
sizeof(type) +
3 ) /
4) <<
2 ), \
(os_pool_m_##name) }
#endif
#define osPool(name) \
&
os_pool_def_##name
osPoolId osPoolCreate( osPoolDef_t *
pool_def );
void *
osPoolAlloc( osPoolId pool_id );
void *
osPoolCAlloc( osPoolId pool_id );
osStatus osPoolFree( osPoolId pool_id, void *
block );
#endif
// ======= Message Queue Management Functions ==================================
#if (defined (osFeature_MessageQ) && (osFeature_MessageQ != 0))
//
// \brief Create a Message Queue Definition.
// param name name of the queue.
// param queue_sz maximum number of messages in the queue.
// param type data type of a single message element (for debugger).
// CAN BE CHANGED: The parameter to osMessageQDef shall be consistent but the
// macro body is implementation specific in every CMSIS-RTOS.
//
#if defined (osObjectsExternal)
#define osMessageQDef(name, queue_sz, type) \
extern osMessageQDef_t os_messageQ_def_##name
#else
#define osMessageQDef(name, queue_sz, type) \
OS_MAILBOX os_messageQ_id_##name;\
uint32_t os_messageQ_q_##name[ (queue_sz) ] = {
0 }; \
osMessageQDef_t os_messageQ_def_##name =
\
{ &os_messageQ_id_##name, (queue_sz <<
2 ) , (os_messageQ_q_##name) }
#endif
#define osMessageQ(name) \
&
os_messageQ_def_##name
osMessageQId osMessageCreate( osMessageQDef_t *
queue_def,
osThreadId thread_id );
osStatus osMessagePut( osMessageQId queue_id, uint32_t info, uint32_t millisec );
osEvent osMessageGet( osMessageQId queue_id, uint32_t millisec );
osStatus osMessageDelete( osMessageQId queue_id );
#endif
// ======= Mail Queue Management Functions =====================================
#if (defined (osFeature_MailQ) && (osFeature_MailQ != 0))
//
// \brief Create a Mail Queue Definition.
// param name name of the queue
// param queue_sz maximum number of messages in queue
// param type data type of a single message element
// CAN BE CHANGED: The parameter to osMailQDef shall be consistent but the
// macro body is implementation specific in every CMSIS-RTOS.
//
#if defined (osObjectsExternal)
#define osMailQDef(name, queue_sz, type) \
extern osMailQDef_t os_mailQ_def_##name
#else
#define osMailQDef(name, queue_sz, type) \
osMailQ_cb os_MailQ_id_##name;\
osPoolDef(mail_##name, queue_sz, type); \
osMessageQDef(mail_##name, queue_sz); \
osMailQDef_t os_mailQ_def_##name =
\
{ &
os_MailQ_id_##name, osMessageQ(mail_##name), osPool(mail_##name), \
queue_sz, ( ( (sizeof(type) +
3) >>
2 ) <<
2 ) }
#endif
#define osMailQ(name) \
&
os_mailQ_def_##name
osMailQId osMailCreate( osMailQDef_t *
queue_def, osThreadId thread_id );
void *
osMailAlloc( osMailQId queue_id, uint32_t millisec );
void *
osMailCAlloc( osMailQId queue_id, uint32_t millisec );
osStatus osMailPut( osMailQId queue_id, void *
mail );
osEvent osMailGet( osMailQId queue_id, uint32_t millisec );
osStatus osMailFree( osMailQId queue_id, void *
mail );
#endif
// ============= Memory Management Functions ===================================
osStatus osMemoryLock( uint32_t timeout );
void osMemoryUnlock(
void );
/*
* ANSI C offers some basic dynamic memory management functions.
* These are malloc, free, and realloc. Unfortunately, these routines are
* not thread-safe, unless a special thread-safe implementation exists
* in the compiler specific runtime libraries; they can only be used from
* one task or by multiple tasks if they are called sequentially.
*
* Therefore, embOS offer task-safe variants of these routines.
* These variants have the same names as their ANSI counterparts,
* but are prefixed OS_; they are called OS_malloc(), OS_free(), OS_realloc().
*
* The thread-safe variants that embOS offers use the standard ANSI routines,
* but they guarantee that the calls are serialized using a resource semaphore.
*
* If heap memory management is not supported by the standard C-libraries
* for a specific CPU, embOS heap memory management is not implemented.
*
* Heap type memory management is part of the embOS libraries.
* It does not use any resources if it is not referenced by the application
* (that is, if the application does not use any memory management API function).
*
* Note that another aspect of these routines may still be a problem:
* the memory used for the functions (known as heap) may fragment.
*
* This can lead to a situation where the total amount of memory is sufficient,
* but there is not enough memory available in a single block
* to satisfy an allocation request.
*
*/
/* Allocates a block of size bytes of memory, returning a pointer
* to the beginning of the block. The content of the newly allocated block of
* memory is not initialized, remaining with indeterminate values.
*
* On success, a pointer to the memory block allocated by the function.
* The type of this pointer is always void*, which can be cast to the desired
* type of data pointer in order to be dereferenceable.
*
* If the function failed to allocate the requested block of memory,
* a null pointer is returned.
*
*/
void *
osMalloc( size_t size, uint32_t timeout );
/* Allocates a block of memory for an array of num elements,
* each of them size bytes long, and initializes all its bits to zero.
*
* The effective result is the allocation of a zero-initialized memory block
* of (num*size) bytes.
*
* On success, a pointer to the memory block allocated by the function.
* The type of this pointer is always void*, which can be cast to the desired
* type of data pointer in order to be dereferenceable.
*
* If the function failed to allocate the requested block of memory,
* a null pointer is returned.
*
*/
void *
osCalloc( size_t nelem, size_t elsize, uint32_t timeout );
/* Changes the size of the memory block pointed to by ptr.
* The function may move the memory block to a new location (whose address is
* returned by the function).
*
* The content of the memory block is preserved up to the lesser of the new
* and old sizes, even if the block is moved to a new location.
*
* If the new size is larger, the value of the newly allocated portion
* is indeterminate.
*
* In case that ptr is a null pointer, the function behaves like malloc,
* assigning a new block of size bytes and returning a pointer to its beginning.
*
* If the function fails to allocate the requested block of memory,
* a null pointer is returned, and the memory block pointed to by argument ptr
* is not deallocated (it is still valid, and with its contents unchanged).
*
* A pointer to the reallocated memory block, which may be either the same
* as ptr or a new location. The type of this pointer is void*, which can be
* cast to the desired type of data pointer in order to be dereferenceable.
*/
void * osRealloc(
void *
ptr, size_t size, uint32_t timeout );
/* A block of memory previously allocated by a call to malloc, calloc or realloc
* is deallocated, making it available again for further allocations.
*
* If ptr does not point to a block of memory allocated with the above functions
* it causes undefined behavior.
* If ptr is a null pointer, the function does nothing.
*
* Notice that this function does not change the value of ptr itself,
* hence it still points to the same (now invalid) location.
*
*/
void osFree(
void *
ptr );
/*
* Informs RTOS that interrupt code is executing.
*
* If osEnterInterrupt() is used, it should be the first function to be called
* in the interrupt handler. It must be used with osLeaveInterrupt() as the last
* function called. The use of this function has the following effects, it:
*
* disables task switches
* keeps interrupts in internal routines disabled.
*/
void osEnterInterrupt(
void );
/*
* Informs RTOS that the end of the interrupt routine has been reached;
* executes task switching within ISR.
*
* If osLeaveInterrupt()is used, it should be the last function to be called
* in the interrupt handler. If the interrupt has caused a task switch, it will
* be executed (unless the program which was interrupted was in a critical region).
*
*/
void osLeaveInterrupt(
void );
uint32_t osDisableInterrupt( void );
void osRestoreInterrupt( uint32_t val );
#ifdef __cplusplus
}
#endif
#endif // __CMSIS_OS_H__
#include
"cmsis_os.h"
#include <stdlib.h>
#define CMSIS2EMBOS(x) ((x)+3)
#define EMBOS2CMSIS(x) ( (osPriority)( (x) -3) )
CMSIS_OS_GLOBAL os_global;
//
// System Timer available
//
// Get the RTOS kernel system timer counter.
// MUST REMAIN UNCHANGED: osKernelSysTick shall be consistent in every CMSIS-RTOS.
// return : RTOS kernel system timer as 32-bit value
uint32_t osKernelSysTick0(
void )
{
// returns the system time in timer clock cycles
return OS_GetTime_Cycles( );
}
// ============= Kernel Control Functions ======================================
//
// Initialize the RTOS Kernel for creating objects.
// return : status code that indicates the execution status of the function.
// MUST REMAIN UNCHANGED: osKernelInitialize shall be consistent in every CMSIS-RTOS.
//
osStatus osKernelInitialize(
void )
{
OS_IncDI();
OS_InitKern( );
OS_InitHW( );
return osOK;
}
// Start the RTOS Kernel.
// return : status code that indicates the execution status of the function.
// MUST REMAIN UNCHANGED: osKernelStart shall be consistent in every CMSIS-RTOS.
//
osStatus osKernelStart(
void )
{
/* This function starts the embOS scheduler and schould be the last function
* called from main().
*
* It will activate and start the task with the highest priority.
* automatically enables interrupts, and never return
*/
OS_Running =
1u;
OS_StartASM( );
return osOK;
}
osStatus osKernelStartThread( osThreadDef_t * thread_def,
void *
argument )
{
osThreadCreate( thread_def, argument );
return osKernelStart( );
}
// Check if the RTOS kernel is already started.
// MUST REMAIN UNCHANGED: osKernelRunning shall be consistent in every CMSIS-RTOS.
// return : 0 RTOS is not started, 1 RTOS is started.
//
int32_t osKernelRunning(
void )
{
return OS_IsRunning();
// OS_Running;
}
// ============= Thread Management =============================================
//
// Create a thread and add it to Active Threads and set it to state READY.
// param[in] thread_def thread definition referenced with osThread.
// param[in] argument pointer that is passed to the thread function as start argument.
// return : thread ID for reference by other functions or NULL in case of error.
// MUST REMAIN UNCHANGED: osThreadCreate shall be consistent in every CMSIS-RTOS.
//
osThreadId osThreadCreate( osThreadDef_t * thread_def,
void *
argument )
{
OS_CreateTaskEx( thread_def->threadId, (
char *) thread_def->
name,
CMSIS2EMBOS( thread_def->
tpriority ),
(void (*)(
void * )) ( thread_def->pthread ), thread_def->
stack,
thread_def->stacksize,
2, argument );
return thread_def->
threadId;
}
// Return the thread ID of the current running thread.
// return : thread ID for reference by other functions or NULL in case of error.
// MUST REMAIN UNCHANGED: osThreadGetId shall be consistent in every CMSIS-RTOS.
//
osThreadId osThreadGetId(
void )
{
return OS_GetTaskID();
}
// Terminate execution of a thread and remove it from Active Threads.
// param[in] thread_id thread ID obtained by osThreadCreate or osThreadGetId.
// return : status code that indicates the execution status of the function.
// MUST REMAIN UNCHANGED: osThreadTerminate shall be consistent in every CMSIS-RTOS.
//
osStatus osThreadTerminate( osThreadId thread_id )
{
// If pTaskis the NULLpointer, the current task terminates.
// The specified task will terminate immediately.
// The memory used for stack and task control block can be reassigned.
OS_TerminateTask( thread_id );
return osOK;
}
// Pass control to next thread that is in state READY.
// return : status code that indicates the execution status of the function.
// MUST REMAIN UNCHANGED: osThreadYield shall be consistent in every CMSIS-RTOS.
//
osStatus osThreadYield(
void )
{
// Calls the scheduler to force a task switch.
OS_Yield( );
return osOK;
}
// Change priority of an active thread.
// param[in] thread_id thread ID obtained by osThreadCreate or osThreadGetId.
// param[in] priority new priority value for the thread function.
// return : status code that indicates the execution status of the function.
// MUST REMAIN UNCHANGED: osThreadSetPriority shall be consistent in every CMSIS-RTOS.
//
osStatus osThreadSetPriority( osThreadId thread_id, osPriority priority )
{
OS_SetPriority( thread_id, CMSIS2EMBOS( priority ) );
return osOK;
}
// Get current priority of an active thread.
// param[in] thread_id thread ID obtained by osThreadCreate or osThreadGetId.
// return : current priority value of the thread function.
// MUST REMAIN UNCHANGED: osThreadGetPriority shall be consistent in every CMSIS-RTOS.
//
osPriority osThreadGetPriority( osThreadId thread_id )
{
return EMBOS2CMSIS( OS_GetPriority( thread_id ) );
}
// ============= Generic Wait Functions ========================================
//
// Wait for Timeout (Time Delay).
// param[in] millisec time delay value
// return : status code that indicates the execution status of the function.
//
osStatus osDelay( uint32_t millisec )
{
OS_Delay( osKernelTicksByMilliSec( millisec ) );
return osOK;
}
// Generic Wait available
//
// Wait for Signal, Message, Mail, or Timeout.
// param[in] millisec timeout value or 0 in case of no time-out
// return : event that contains signal, message, or mail information or error code.
// MUST REMAIN UNCHANGED: osWait shall be consistent in every CMSIS-RTOS.
//
osEvent osWait( uint32_t millisec )
{
osEvent event;
event.status =
osOK;
return event;
}
// ============= Timer Management Functions ====================================
//
// Create a timer.
// param[in] timer_def timer object referenced with osTimer.
// param[in] type osTimerOnce for one-shot or osTimerPeriodic for periodic behavior.
// param[in] argument argument to the timer call back function.
// return : timer ID for reference by other functions or NULL in case of error.
// MUST REMAIN UNCHANGED: osTimerCreate shall be consistent in every CMSIS-RTOS.
//
osTimerId osTimerCreate( osTimerDef_t *
timer_def, os_timer_type type,
void *
argument )
{
OS_CreateTimerEx( timer_def->
timerId,
(OS_TIMER_EX_ROUTINE *) ( timer_def->ptimer ), -
1, argument );
return timer_def->
timerId;
}
// Start or restart a timer.
// param[in] timer_id timer ID obtained by osTimerCreate.
// param[in] millisec time delay value of the timer.
// return : status code that indicates the execution status of the function.
// MUST REMAIN UNCHANGED: osTimerStart shall be consistent in every CMSIS-RTOS.
//
osStatus osTimerStart( osTimerId timer_id, uint32_t millisec )
{
OS_SetTimerPeriodEx( timer_id, osKernelTicksByMilliSec( millisec ) );
OS_RetriggerTimerEx( timer_id );
return osOK;
}
// Stop the timer.
// param[in] timer_id timer ID obtained by osTimerCreate.
// return : status code that indicates the execution status of the function.
// MUST REMAIN UNCHANGED: osTimerStop shall be consistent in every CMSIS-RTOS.
//
osStatus osTimerStop( osTimerId timer_id )
{
OS_StopTimerEx( timer_id );
return osOK;
}
// Delete a timer that was created by osTimerCreate.
// param[in] timer_id timer ID obtained by osTimerCreate.
// return : status code that indicates the execution status of the function.
// MUST REMAIN UNCHANGED: osTimerDelete shall be consistent in every CMSIS-RTOS.
//
osStatus osTimerDelete( osTimerId timer_id )
{
OS_DeleteTimerEx( timer_id );
return osOK;
}
// ============= Signal Management =============================================
//
// Set the specified Signal Flags of an active thread.
// param[in] thread_id thread ID obtained by osThreadCreate or osThreadGetId.
// param[in] signals specifies the signal flags of the thread that should be set.
// return : previous signal flags of the specified thread
// or 0x80000000 in case of incorrect parameters.
// MUST REMAIN UNCHANGED: osSignalSet shall be consistent in every CMSIS-RTOS.
//
int32_t osSignalSet( osThreadId thread_id, int32_t signals )
{
// Returns a list of events that have occurred for a specified task.
// The event mask of the events that have actually occurred
// the actual events remain signaled
//
int32_t result =
OS_GetEventsOccurred( thread_id );
OS_SignalEvent( signals, thread_id );
return result;
}
int32_t OS_ClearEvent( osThreadId thread_id, int32_t signals )
{
if ( thread_id ==
0 )
thread_id =
osThreadGetId( );
int32_t result =
thread_id.Events;
// uint32_t val = osDisableInterrupt( );
OS_DisableInt( );
// MOV.W R1, #0x80 MSR.W BASEPRI, R1
thread_id.Events &= ~
signals;
if ( OS_Global.Counters.Cnt.DI ==
0 )
OS_EnableInt( ); // MOV.W R1, #0x00 MSR.W BASEPRI, R1
// osRestoreInterrupt( val );
return result;
}
// Clear the specified Signal Flags of an active thread.
// param[in] thread_id thread ID obtained by osThreadCreate or osThreadGetId.
// param[in] signals specifies the signal flags of the thread that shall be cleared.
// return : previous signal flags of the specified thread
// or 0x80000000 in case of incorrect parameters.
// MUST REMAIN UNCHANGED: osSignalClear shall be consistent in every CMSIS-RTOS.
//
int32_t osSignalClear( osThreadId thread_id, int32_t signals )
{
// Returns the actual state of events
// and then clears the events of a specified task.
// Returns the actual state of events and then
// clears ** the ALL events ** of a specified task.
//
// return OS_ClearEvents( thread_id );
//
return OS_ClearEvent( thread_id );
}
// Wait for one or more Signal Flags to become signaled for the current RUNNING thread.
// param[in] signals wait until all specified signal flags set or 0 for any single signal flag.
// param[in] millisec timeout value or 0 in case of no time-out.
// return : event flag information or error code.
// MUST REMAIN UNCHANGED: osSignalWait shall be consistent in every CMSIS-RTOS.
//
osEvent osSignalWait( int32_t signals, uint32_t millisec )
{
osEvent event;
event.status =
osEventSignal;
// Not allowed in ISR ?
// event.status = osErrorISR
//
// The task is not suspended even if no events are signaled.
if ( millisec ==
0 )
{
// Returns a list of events that have occurred for a specified task.
// The event mask of the events that have actually occurred.
event.value.signals = OS_GetEventsOccurred(
0 );
}
else if ( millisec ==
osWaitForever )
{
if ( signals ==
0 )
// Wait forever until any single signal flag
{
// Waits for one of the events specified in the bitmask and
// clears the event memory after an event occurs
event.value.signals = OS_WaitEvent(
0xFFFFFFFF );
}
else // Wait forever until all specified signal flags set
{
// Waits for one or more of the events specified by the Eventmask
// and clears only those events that were specified in the eventmask.
event.value.signals =
OS_WaitSingleEvent( signals );
}
}
else
{
if ( signals ==
0 )
// Wait millisec until any single signal flag
{
// Waits for the specified events for a given time, and clears
// ** the event memory ** after one of the requsted events occurs,
// or after the timeout expired.
event.value.signals = OS_WaitEventTimed(
0xFFFFFFFF,
osKernelTicksByMilliSec( millisec ) );
}
else // Wait millisec until all specified signal flags set
{
// Waits for the specified events for a given time; after an event occurs,
// only ** the requested events ** are cleared.
event.value.signals =
OS_WaitSingleEventTimed( signals,
osKernelTicksByMilliSec( millisec ) );
}
}
if (
event.value.signals ==
0 )
{
event.status = ( millisec >
0 ) ?
osEventTimeout : osOK;
}
return event;
}
// ============= Mutex Management ==============================================
//
/* Resource semaphores are used for managingresources by avoiding conflicts
* caused by simultaneous use of a resource. The resource managed can be of
* any kind: a part of the program that is not reentrant, a piece of hardware
* like the display, a flash prom that can only be written to by a single task
* at a time, a motor in a CNC control that can only be controlled by one task
* at a time, and a lot more.
*
* The basic procedure is as follows:
* Any task that uses a resource first claims it calling the OS_Use() or
* OS_Request() routines of embOS. If the resource is available, the program
* execution of the task continues, but the resource is blocked for other tasks.
*
* If a second task now tries to use the same resource while it is in use
* by the first task, this second task is suspended until the first task releases
* the resource. However, if the first task that uses the resource calls
* OS_Use() again for that resource, it is not suspended because the resource
* is blocked only for other tasks.
*
* A resource semaphore contains a counter that keeps track of how many times
* the resource has been claimed by calling OS_Request() or OS_Use()
* by a particular task. It is released when that counter reaches 0,
* which means the OS_Unuse() routine has to be called exactly the same number
* of times as OS_Use() or OS_Request(). If it is not, the resource remains
* blocked for other tasks.
*
* On the other hand, a task cannot release a resource that it does not own
* by calling OS_Unuse().
*
* counter = 0 after OS_CreateRSema()
* counter++ : OS_Use() or OS_Request()
* counter-- : OS_Unuse()
*
* A programmer can prefer mutex rather than creating a semaphore with count 1.
*/
// Create and Initialize a Mutex object.
// param[in] mutex_def mutex definition referenced with osMutex.
// return : mutex ID for reference by other functions or NULL in case of error.
// MUST REMAIN UNCHANGED: osMutexCreate shall be consistent in every CMSIS-RTOS.
//
osMutexId osMutexCreate( osMutexDef_t *
mutex_def )
{
OS_CreateRSema( mutex_def->
mutexId );
return mutex_def->
mutexId;
}
// Wait until a Mutex becomes available.
// param[in] mutex_id mutex ID obtained by osMutexCreate.
// param[in] millisec timeout value or 0 in case of no time-out.
// return : status code that indicates the execution status of the function.
// MUST REMAIN UNCHANGED: osMutexWait shall be consistent in every CMSIS-RTOS.
//
osStatus osMutexWait( osMutexId mutex_id, uint32_t millisec )
{
osStatus status =
osOK;
if ( millisec ==
0 )
{
if ( OS_Request( mutex_id ) ==
0 )
{
status =
osErrorResource;
}
}
else if ( millisec ==
osWaitForever )
{
OS_Use( mutex_id );
}
else if (
0 ==
OS_UseTimed( mutex_id, osKernelTicksByMilliSec( millisec ) ) )
{
status =
osErrorTimeoutResource;
}
return status;
}
// Release a Mutex that was obtained by osMutexWait.
// param[in] mutex_id mutex ID obtained by osMutexCreate.
// return : status code that indicates the execution status of the function.
// MUST REMAIN UNCHANGED: osMutexRelease shall be consistent in every CMSIS-RTOS.
//
osStatus osMutexRelease( osMutexId mutex_id )
{
OS_Unuse( mutex_id );
return osOK;
}
// Delete a Mutex that was created by osMutexCreate.
// param[in] mutex_id mutex ID obtained by osMutexCreate.
// return : status code that indicates the execution status of the function.
// MUST REMAIN UNCHANGED: osMutexDelete shall be consistent in every CMSIS-RTOS.
//
osStatus osMutexDelete( osMutexId mutex_id )
{
OS_DeleteRSema( mutex_id );
return osOK;
}
// ============= Semaphore Management Functions ================================
/* Counting semaphores are counters that are managed by embOS.
* They are not as widely used as resource semaphores, events or mailboxes,
* but they can be very useful sometimes.
*
* They are used in situations where a task needs to wait for something
* that can be signaled one or more times.
*
* The semaphores can be accessed from any point, any task,
* or any interrupt in any way.
*
* OS_CreateCSema()
* Creates a counting semaphore with a specified initial count value
*
* OS_SignalCSema()
* Increments the counter of a semaphore.
* If one or more tasks are waiting for an event to be signaled to this
* semaphore, the task that has the highest priority will become the running task
*
* OS_WaitCSema()
* Decrements the counter of a semaphore.
* If the counter of the semaphore is not 0, the counter is decremented
* and program execution continues.
* If the counter is 0, WaitCSema()waits until the counter is incremented by
* another task, a timer or an interrupt handler via a call to OS_SignalCSema().
* The counter is then decremented and program execution continues.
*
* OS_WaitCSemaTimed()
* Decrements a semaphore counter if the semaphore is available
* within a specified time.
* If the semaphore was not signaled within the specified time, the program
* execution continues but returns a value of 0.
*
* OS_CSemaRequest()
* Decrements the counter of a semaphore, if it is signaled.
* If the counter is 0, OS_CSemaRequest() does not wait and does not modify
* the semaphore counter. The function returns with error state.
*
*/
// Create and Initialize a Semaphore object used for managing resources.
// param[in] semaphore_def semaphore definition referenced with osSemaphore.
// param[in] count number of available resources.
// return : semaphore ID for reference by other functions or NULL in case of error.
// MUST REMAIN UNCHANGED: osSemaphoreCreate shall be consistent in every CMSIS-RTOS.
//
osSemaphoreId osSemaphoreCreate( osSemaphoreDef_t *
semaphore_def,
int32_t count )
{
// Creates a counting semaphore with a specified initial count value.
OS_CreateCSema( semaphore_def->
semaphoreId, count );
return semaphore_def->
semaphoreId;
}
// Wait until a Semaphore token becomes available.
// param[in] semaphore_id semaphore object referenced with osSemaphoreCreate.
// param[in] millisec timeout value or 0 in case of no time-out.
// return : number of available tokens : (tokens after wait) + 1
// or -1 in case of incorrect parameters.
// MUST REMAIN UNCHANGED: osSemaphoreWait shall be consistent in every CMSIS-RTOS.
//
int32_t osSemaphoreWait( osSemaphoreId semaphore_id, uint32_t millisec )
{
int32_t result = -
1;
// OS_WaitCSemaTimed() timeout
if ( millisec ==
0 )
{
// Decrements the counter of a semaphore, if it is signaled
if ( OS_CSemaRequest( semaphore_id ) )
{
// Returns the counter value of a specified semaphore
result =
OS_GetCSemaValue( semaphore_id );
}
}
else if ( millisec ==
osWaitForever )
{
// Decrements the counter of a semaphore
// If the counter of the semaphore is not 0, the counter is decremented
// and program execution continues.
// If the counter is 0, WaitCSema() waits until the counter is incremented
// by another task, a timer or an interrupt handler
// via a call to OS_SignalCSema().
OS_WaitCSema( semaphore_id );
// Returns the counter value of a specified semaphore
result =
OS_GetCSemaValue( semaphore_id );
}
// Decrements a semaphore counter if the semaphore is available
// within a specified time.
else if ( OS_WaitCSemaTimed( semaphore_id,
osKernelTicksByMilliSec( millisec ) ) )
{
result =
OS_GetCSemaValue( semaphore_id );
}
return result +
1;
}
/**
* @brief Release a Semaphore token
* @param semaphore_id semaphore object referenced with osSemaphore.
* @retval status code that indicates the execution status of the function.
* @note MUST REMAIN UNCHANGED: osSemaphoreRelease shall be consistent in every CMSIS-RTOS.
*/
osStatus osSemaphoreRelease( osSemaphoreId semaphore_id )
{
// Increments the counter of a semaphore
// If one or more tasks are waiting for an event to be signaled to
// this semaphore, the task that has the highest priority will
// become the running task.
OS_SignalCSema( semaphore_id );
return osOK;
}
// Release a Semaphore token.
// param[in] semaphore_id semaphore object referenced with osSemaphoreCreate.
// return : status code that indicates the execution status of the function.
// MUST REMAIN UNCHANGED: osSemaphoreRelease shall be consistent in every CMSIS-RTOS.
//
osStatus osSemaphoreDelete( osSemaphoreId semaphore_id )
{
// Deletes a specified semaphore.
// Before deleting a semaphore, make sure that no task is waiting for it
// and that notask will signal that semaphore at a later point.
OS_DeleteCSema( semaphore_id );
return osOK;
}
// ============= Memory Pool Management Functions ==============================
// Create and Initialize a memory pool.
// param[in] pool_def memory pool definition referenced with osPool.
// return : memory pool ID for reference by other functions or NULL in case of error.
// MUST REMAIN UNCHANGED: osPoolCreate shall be consistent in every CMSIS-RTOS.
//
osPoolId osPoolCreate( osPoolDef_t *
pool_def )
{
// void OS_MEMF_Create (OS_MEMF* pMEMF, void* pPool, OS_UINT NumBlocks, OS_UINT BlockSize);
// BlockSize is aligment at 4 Bytes !!!
//
OS_MEMF_Create( pool_def->poolId, pool_def->pool, pool_def->
pool_sz,
pool_def->
item_sz );
return pool_def->
poolId;
}
// Allocate a memory block from a memory pool.
// param[in] pool_id memory pool ID obtain referenced with osPoolCreate.
// return : address of the allocated memory block or NULL in case of no memory available.
// MUST REMAIN UNCHANGED: osPoolAlloc shall be consistent in every CMSIS-RTOS.
//
// Requests allocation of a memory block.
// Waits until a block of memory is available
// If there is no free memory block in the pool, the calling task is suspended
// until a memory block becomes available.
//
void *
osPoolAlloc( osPoolId pool_id )
{
return OS_MEMF_Alloc( pool_id,
0 );
}
// Requests allocation of a memory block. Waits until a block of memory
// is available or the timeout has expired.
//
void *
osPoolAllocTimed( osPoolId pool_id, uint32_t millisec )
{
return OS_MEMF_AllocTimed( pool_id, osKernelTicksByMilliSec( millisec ),
0 );
}
// Requests allocation of a memory block. Continues execution in any case.
// The calling task is never suspended by calling OS_MEMF_Request()
//
void *
osPoolRequest( osPoolId pool_id )
{
return OS_MEMF_Request( pool_id,
0 );
}
// Allocate a memory block from a memory pool and set memory block to zero.
// param[in] pool_id memory pool ID obtain referenced with osPoolCreate.
// return : address of the allocated memory block or NULL in case of no memory available.
// MUST REMAIN UNCHANGED: osPoolCAlloc shall be consistent in every CMSIS-RTOS.
void *
osPoolCAlloc( osPoolId pool_id )
{
void * p =
osPoolAlloc( pool_id );
if ( p )
{
memset( p, 0, pool_id->
BlockSize );
}
return p;
}
// Return an allocated memory block back to a specific memory pool.
// param[in] pool_id memory pool ID obtain referenced with osPoolCreate.
// param[in] block address of the allocated memory block that is returned to the memory pool.
// return : status code that indicates the execution status of the function.
// MUST REMAIN UNCHANGED: osPoolFree shall be consistent in every CMSIS-RTOS.
osStatus osPoolFree( osPoolId pool_id,
void *
block )
{
OS_MEMF_Release( pool_id, block );
return osOK;
}
// ============= Message Queue Management Functions =============================
// Create and Initialize a Message Queue.
// param[in] queue_def queue definition referenced with osMessageQ.
// param[in] thread_id thread ID (obtained by osThreadCreate or osThreadGetId) or NULL.
// return : message queue ID for reference by other functions or NULL in case of error.
// MUST REMAIN UNCHANGED: osMessageCreate shall be consistent in every CMSIS-RTOS.
//
osMessageQId osMessageCreate( osMessageQDef_t *
queue_def,
osThreadId thread_id )
{
OS_CreateMB( queue_def->messageQId,
4, queue_def->queue_sz, queue_def->
pool );
return queue_def->
messageQId;
}
// Put a Message to a Queue.
// param[in] queue_id message queue ID obtained with osMessageCreate.
// param[in] info message information.
// param[in] millisec timeout value or 0 in case of no time-out.
// return : status code that indicates the execution status of the function.
// MUST REMAIN UNCHANGED: osMessagePut shall be consistent in every CMSIS-RTOS.
//
osStatus osMessagePut( osMessageQId queue_id, uint32_t info, uint32_t millisec )
{
osStatus status =
osOK;
if ( millisec ==
0 )
{
if ( OS_PutMailCond( queue_id, (
const void *) &info ) >
0 )
{
status =
osErrorResource;
}
}
else if ( millisec ==
osWaitForever )
{
OS_PutMail( queue_id, (const void *) &
info );
}
else
{
OS_TIME osKernelTickCountPrev =
osKernelTickCount();
while (
1 )
{
if ( OS_PutMailCond( queue_id, (
const void *) &info ) ==
0 )
return status;
osDelay( 1 );
if ( ( osKernelTickCount() -
osKernelTickCountPrev )
>
osKernelTicksByMilliSec( millisec ) )
return osErrorTimeoutResource;
}
}
return status;
}
// Get a Message or Wait for a Message from a Queue.
// param[in] queue_id message queue ID obtained with osMessageCreate.
// param[in] millisec timeout value or 0 in case of no time-out.
// return : event information that includes status code.
// MUST REMAIN UNCHANGED: osMessageGet shall be consistent in every CMSIS-RTOS.
//
osEvent osMessageGet( osMessageQId queue_id, uint32_t millisec )
{
osEvent event;
event.status =
osEventMessage;
// The task is not suspended even if no events are signaled.
if ( millisec ==
0 )
{
if ( OS_GetMailCond( queue_id, &
event.value.v ) >
0 )
{
event.status =
osOK;
}
}
else if ( millisec ==
osWaitForever )
{
OS_GetMail( queue_id, &
event.value.v );
}
else if ( OS_GetMailTimed( queue_id, &
event.value.v,
osKernelTicksByMilliSec( millisec ) ) >
0 )
{
event.status =
osEventTimeout;
}
return event;
}
osStatus osMessageDelete( osMessageQId queue_id )
{
OS_DeleteMB( queue_id );
return osOK;
}
// ============= Mail Queue Management Functions ===============================
// Mail Queues available
// Create and Initialize mail queue.
// param[in] queue_def reference to the mail queue definition obtain with osMailQ
// param[in] thread_id thread ID (obtained by osThreadCreate or osThreadGetId) or NULL.
// return : mail queue ID for reference by other functions or NULL in case of error.
// MUST REMAIN UNCHANGED: osMailCreate shall be consistent in every CMSIS-RTOS.
//
osMailQId osMailCreate( osMailQDef_t *
queue_def, osThreadId thread_id )
{
queue_def->mailId->messageId = osMessageCreate( queue_def->
messageQDef,
thread_id );
queue_def->mailId->poolId = osPoolCreate( queue_def->
poolDef );
return queue_def->
mailId;
}
// Allocate a memory block from a mail.
// param[in] queue_id mail queue ID obtained with osMailCreate.
// param[in] millisec timeout value or 0 in case of no time-out
// return : pointer to memory block that can be filled with mail or NULL in case of error.
// MUST REMAIN UNCHANGED: osMailAlloc shall be consistent in every CMSIS-RTOS.
//
void *
osMailAlloc( osMailQId queue_id, uint32_t millisec )
{
void *
p;
if ( millisec ==
0 )
{
p = osPoolRequest( queue_id->
poolId );
}
else if ( millisec ==
osWaitForever )
{
p = osPoolAlloc( queue_id->
poolId );
}
else
{
p = osPoolAllocTimed( queue_id->
poolId, millisec );
}
return p;
}
// Allocate a memory block from a mail and set memory block to zero.
// param[in] queue_id mail queue ID obtained with osMailCreate.
// param[in] millisec timeout value or 0 in case of no time-out
// return : pointer to memory block that can be filled with mail or NULL in case of error.
// MUST REMAIN UNCHANGED: osMailCAlloc shall be consistent in every CMSIS-RTOS.
//
void *
osMailCAlloc( osMailQId queue_id, uint32_t millisec )
{
void * p =
osMailAlloc( queue_id, millisec );
if ( p )
{
memset( p, 0, queue_id->poolId->
BlockSize );
}
return p;
}
// Put a mail to a queue.
// param[in] queue_id mail queue ID obtained with osMailCreate.
// param[in] mail memory block previously allocated with osMailAlloc or osMailCAlloc.
// return : status code that indicates the execution status of the function.
// MUST REMAIN UNCHANGED: osMailPut shall be consistent in every CMSIS-RTOS.
//
osStatus osMailPut( osMailQId queue_id,
void *
mail )
{
return osMessagePut( queue_id->
messageId, (uint32_t) mail, osWaitForever );
}
// Get a mail from a queue.
// param[in] queue_id mail queue ID obtained with osMailCreate.
// param[in] millisec timeout value or 0 in case of no time-out
// return : event that contains mail information or error code.
// MUST REMAIN UNCHANGED: osMailGet shall be consistent in every CMSIS-RTOS.
//
osEvent osMailGet( osMailQId queue_id, uint32_t millisec )
{
osEvent event = osMessageGet( queue_id->
messageId, millisec );
if (
event.status ==
osEventMessage )
{
event.status =
osEventMail;
}
return event;
}
// Free a memory block from a mail.
// param[in] queue_id mail queue ID obtained with osMailCreate.
// param[in] mail pointer to the memory block that was obtained with osMailGet.
// return : status code that indicates the execution status of the function.
// MUST REMAIN UNCHANGED: osMailFree shall be consistent in every CMSIS-RTOS.
//
osStatus osMailFree( osMailQId queue_id,
void *
mail )
{
return osPoolFree( queue_id->
poolId, mail );
}
// ============= Memory Management Functions ===================================
static osMutexDef( cmsis_memory )
;
static osMutexId cmsis_memory;
osStatus osMemoryLock( uint32_t timeout )
{
if ( cmsis_memory ==
0 )
cmsis_memory =
osMutexCreate( osMutex( cmsis_memory ) );
return osMutexWait( cmsis_memory, timeout );
}
void osMemoryUnlock(
void )
{
osMutexRelease( cmsis_memory );
}
/* Allocates a block of size bytes of memory, returning a pointer
* to the beginning of the block. The content of the newly allocated block of
* memory is not initialized, remaining with indeterminate values.
*
* On success, a pointer to the memory block allocated by the function.
* The type of this pointer is always void*, which can be cast to the desired
* type of data pointer in order to be dereferenceable.
*
* If the function failed to allocate the requested block of memory,
* a null pointer is returned.
*
*/
void *
osMalloc( size_t size, uint32_t timeout )
{
void * p =
0;
osStatus status =
osMemoryLock( timeout );
if ( status ==
osOK )
{
p =
malloc( size );
osMemoryUnlock( );
}
return p;
}
/* Allocates a block of memory for an array of num elements,
* each of them size bytes long, and initializes all its bits to zero.
*
* The effective result is the allocation of a zero-initialized memory block
* of (num*size) bytes.
*
* On success, a pointer to the memory block allocated by the function.
* The type of this pointer is always void*, which can be cast to the desired
* type of data pointer in order to be dereferenceable.
*
* If the function failed to allocate the requested block of memory,
* a null pointer is returned.
*
*/
void *
osCalloc( size_t nelem, size_t elsize, uint32_t timeout )
{
void * p = osMalloc( nelem *
elsize, timeout );
if ( p )
{
memset( p, 0, nelem *
elsize );
}
return p;
}
/* Changes the size of the memory block pointed to by ptr.
* The function may move the memory block to a new location (whose address is
* returned by the function).
*
* The content of the memory block is preserved up to the lesser of the new
* and old sizes, even if the block is moved to a new location.
*
* If the new size is larger, the value of the newly allocated portion
* is indeterminate.
*
* In case that ptr is a null pointer, the function behaves like malloc,
* assigning a new block of size bytes and returning a pointer to its beginning.
*
* If the function fails to allocate the requested block of memory,
* a null pointer is returned, and the memory block pointed to by argument ptr
* is not deallocated (it is still valid, and with its contents unchanged).
*
* A pointer to the reallocated memory block, which may be either the same
* as ptr or a new location. The type of this pointer is void*, which can be
* cast to the desired type of data pointer in order to be dereferenceable.
*/
void * osRealloc(
void *
ptr, size_t size, uint32_t timeout )
{
void * p =
0;
osStatus status =
osMemoryLock( timeout );
if ( status ==
osOK )
{
p =
realloc( ptr, size );
osMemoryUnlock( );
}
return p;
}
/* A block of memory previously allocated by a call to malloc, calloc or realloc
* is deallocated, making it available again for further allocations.
*
* If ptr does not point to a block of memory allocated with the above functions
* it causes undefined behavior.
* If ptr is a null pointer, the function does nothing.
*
* Notice that this function does not change the value of ptr itself,
* hence it still points to the same (now invalid) location.
*
*/
void osFree(
void *
ptr )
{
osMemoryLock( osWaitForever );
free( ptr );
osMemoryUnlock( );
}
/*
* Informs RTOS that interrupt code is executing.
*
* If osEnterInterrupt() is used, it should be the first function to be called
* in the interrupt handler. It must be used with osLeaveInterrupt() as the last
* function called. The use of this function has the following effects, it:
*
* disables task switches
* keeps interrupts in internal routines disabled.
*/
void osEnterInterrupt(
void )
{
OS_EnterInterrupt()
;
}
/*
* Informs RTOS that the end of the interrupt routine has been reached;
* executes task switching within ISR.
*
* If osLeaveInterrupt()is used, it should be the last function to be called
* in the interrupt handler. If the interrupt has caused a task switch, it will
* be executed (unless the program which was interrupted was in a critical region).
*
*/
void osLeaveInterrupt(
void )
{
OS_LeaveInterrupt()
;
}
uint32_t osDisableInterrupt( void )
{
__istate_t s =
__get_interrupt_state( );
__disable_interrupt( );
return (uint32_t) s;
}
void osRestoreInterrupt( uint32_t val )
{
__set_interrupt_state( (__istate_t ) val );
}
#include
"cmsis_os.h"
#if defined(osFeature_MainThread) && (osFeature_MainThread > 0 )
/*----------------------------------------------------------------------------
* RTX Startup
*---------------------------------------------------------------------------*/
/* Main Thread definition */
extern int main (
void);
osThreadDef( main, main, osPriorityNormal, 1, OS_MAINSTKSIZE );
extern int __low_level_init(
void);
extern void __iar_data_init3(
void);
extern void exit(
int arg);
__noreturn __stackless void __cmain(
void) {
int a;
if (__low_level_init() !=
0) {
__iar_data_init3();
}
osKernelInitialize();
osThreadCreate(&
os_thread_def_main, NULL);
a =
osKernelStart();
exit(a);
}
#endif
转载于:https://www.cnblogs.com/shangdawei/p/3921473.html
