30 #define TRACE_LEVEL TRACE_LEVEL_OFF
83 osThreadId_t threadId;
84 osThreadAttr_t threadAttr;
87 memset(&threadAttr, 0,
sizeof(threadAttr));
90 threadAttr.name =
name;
91 threadAttr.attr_bits = 0;
92 threadAttr.stack_mem = params->
stack;
93 threadAttr.stack_size = params->
stackSize *
sizeof(uint32_t);
94 threadAttr.priority = (osPriority_t) params->
priority;
95 threadAttr.tz_module = 0;
96 threadAttr.reserved = 0;
99 if(params->cb != NULL)
101 #if defined(os_CMSIS_RTX)
102 threadAttr.cb_mem = params->cb;
103 threadAttr.cb_size =
sizeof(os_thread_t);
104 #elif defined(osRtxVersionKernel)
105 threadAttr.cb_mem = params->cb;
106 threadAttr.cb_size =
sizeof(osRtxThread_t);
107 #elif defined(configSUPPORT_STATIC_ALLOCATION)
108 threadAttr.cb_mem = params->cb;
109 threadAttr.cb_size =
sizeof(StaticTask_t);
111 threadAttr.cb_mem = NULL;
112 threadAttr.cb_size = 0;
117 threadId = osThreadNew(taskCode, arg, &threadAttr);
138 osThreadTerminate((osThreadId_t) taskId);
173 if(osKernelGetState() != osKernelInactive)
188 if(osKernelGetState() != osKernelInactive)
205 osEventFlagsAttr_t eventFlagsAttr;
208 eventFlagsAttr.name = NULL;
209 eventFlagsAttr.attr_bits = 0;
211 #if defined(os_CMSIS_RTX)
212 eventFlagsAttr.cb_mem = &
event->cb;
213 eventFlagsAttr.cb_size =
sizeof(os_event_flags_t);
214 #elif defined(osRtxVersionKernel)
215 eventFlagsAttr.cb_mem = &
event->cb;
216 eventFlagsAttr.cb_size =
sizeof(osRtxEventFlags_t);
218 eventFlagsAttr.cb_mem = NULL;
219 eventFlagsAttr.cb_size = 0;
223 event->id = osEventFlagsNew(&eventFlagsAttr);
226 if(event->
id != NULL)
245 if(event->
id != NULL)
248 osEventFlagsDelete(event->
id);
261 osEventFlagsSet(event->
id, 1);
273 osEventFlagsClear(event->
id, 1);
294 flags = osEventFlagsWait(event->
id, 1, osFlagsWaitAny, osWaitForever);
299 flags = osEventFlagsWait(event->
id, 1, osFlagsWaitAny,
325 osEventFlagsSet(event->
id, 1);
343 osSemaphoreAttr_t semaphoreAttr;
346 semaphoreAttr.name = NULL;
347 semaphoreAttr.attr_bits = 0;
349 #if defined(os_CMSIS_RTX)
350 semaphoreAttr.cb_mem = &semaphore->cb;
351 semaphoreAttr.cb_size =
sizeof(os_semaphore_t);
352 #elif defined(osRtxVersionKernel)
353 semaphoreAttr.cb_mem = &semaphore->cb;
354 semaphoreAttr.cb_size =
sizeof(osRtxSemaphore_t);
356 semaphoreAttr.cb_mem = NULL;
357 semaphoreAttr.cb_size = 0;
361 semaphore->
id = osSemaphoreNew(count, count, &semaphoreAttr);
364 if(semaphore->
id != NULL)
383 if(semaphore->
id != NULL)
386 osSemaphoreDelete(semaphore->
id);
407 status = osSemaphoreAcquire(semaphore->
id, osWaitForever);
435 osSemaphoreRelease(semaphore->
id);
448 osMutexAttr_t mutexAttr;
451 mutexAttr.name = NULL;
452 mutexAttr.attr_bits = 0;
454 #if defined(os_CMSIS_RTX)
455 mutexAttr.cb_mem = &mutex->cb;
456 mutexAttr.cb_size =
sizeof(os_mutex_t);
457 #elif defined(osRtxVersionKernel)
458 mutexAttr.cb_mem = &mutex->cb;
459 mutexAttr.cb_size =
sizeof(osRtxMutex_t);
461 mutexAttr.cb_mem = NULL;
462 mutexAttr.cb_size = 0;
466 mutex->
id = osMutexNew(&mutexAttr);
469 if(mutex->
id != NULL)
488 if(mutex->
id != NULL)
491 osMutexDelete(mutex->
id);
504 osMutexAcquire(mutex->
id, osWaitForever);
516 osMutexRelease(mutex->
id);
530 time = osKernelGetTickCount();
557 size, (uintptr_t)
p);
575 TRACE_DEBUG(
"Freeing memory at 0x%08" PRIXPTR
"\r\n", (uintptr_t)
p);
void(* OsTaskCode)(void *arg)
Task routine.
#define OS_SYSTICKS_TO_MS(n)
#define OS_MS_TO_SYSTICKS(n)
uint32_t systime_t
System time.
thread_t * OsTaskId
Task identifier.
void osSwitchTask(void)
Yield control to the next task.
void osResumeAllTasks(void)
Resume scheduler activity.
bool_t osCreateMutex(OsMutex *mutex)
Create a mutex object.
bool_t osWaitForEvent(OsEvent *event, systime_t timeout)
Wait until the specified event is in the signaled state.
void osDeleteEvent(OsEvent *event)
Delete an event object.
void osDeleteMutex(OsMutex *mutex)
Delete a mutex object.
void osReleaseSemaphore(OsSemaphore *semaphore)
Release the specified semaphore object.
const OsTaskParameters OS_TASK_DEFAULT_PARAMS
__weak_func void * osAllocMem(size_t size)
Allocate a memory block.
void osDeleteSemaphore(OsSemaphore *semaphore)
Delete a semaphore object.
void osAcquireMutex(OsMutex *mutex)
Acquire ownership of the specified mutex object.
void osDelayTask(systime_t delay)
Delay routine.
__weak_func void osFreeMem(void *p)
Release a previously allocated memory block.
bool_t osWaitForSemaphore(OsSemaphore *semaphore, systime_t timeout)
Wait for the specified semaphore to be available.
OsTaskId osCreateTask(const char_t *name, OsTaskCode taskCode, void *arg, const OsTaskParameters *params)
Create a task.
void osReleaseMutex(OsMutex *mutex)
Release ownership of the specified mutex object.
void osResetEvent(OsEvent *event)
Set the specified event object to the nonsignaled state.
bool_t osSetEventFromIsr(OsEvent *event)
Set an event object to the signaled state from an interrupt service routine.
void osDeleteTask(OsTaskId taskId)
Delete a task.
bool_t osCreateSemaphore(OsSemaphore *semaphore, uint_t count)
Create a semaphore object.
systime_t osGetSystemTime(void)
Retrieve system time.
void osSuspendAllTasks(void)
Suspend scheduler activity.
bool_t osCreateEvent(OsEvent *event)
Create an event object.
void osStartKernel(void)
Start kernel.
void osInitKernel(void)
Kernel initialization.
void osSetEvent(OsEvent *event)
Set the specified event object to the signaled state.
RTOS abstraction layer (CMSIS-RTOS 2 / RTX v5)