From 48026bb824fd2d9cfb00ecd040db6ef3a416bae9 Mon Sep 17 00:00:00 2001 From: Clyne Sullivan Date: Fri, 22 Jan 2021 21:43:36 -0500 Subject: upload initial port --- .../os/common/abstractions/cmsis_os/cmsis_os.c | 557 +++++++++++++++++++++ .../os/common/abstractions/cmsis_os/cmsis_os.h | 522 +++++++++++++++++++ .../os/common/abstractions/cmsis_os/cmsis_os.mk | 8 + 3 files changed, 1087 insertions(+) create mode 100644 ChibiOS_20.3.2/os/common/abstractions/cmsis_os/cmsis_os.c create mode 100644 ChibiOS_20.3.2/os/common/abstractions/cmsis_os/cmsis_os.h create mode 100644 ChibiOS_20.3.2/os/common/abstractions/cmsis_os/cmsis_os.mk (limited to 'ChibiOS_20.3.2/os/common/abstractions/cmsis_os') diff --git a/ChibiOS_20.3.2/os/common/abstractions/cmsis_os/cmsis_os.c b/ChibiOS_20.3.2/os/common/abstractions/cmsis_os/cmsis_os.c new file mode 100644 index 0000000..af1c85f --- /dev/null +++ b/ChibiOS_20.3.2/os/common/abstractions/cmsis_os/cmsis_os.c @@ -0,0 +1,557 @@ +/* + ChibiOS - Copyright (C) 2006..2018 Giovanni Di Sirio. + + This file is part of ChibiOS. + + ChibiOS is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + ChibiOS is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ +/* + Concepts and parts of this file have been contributed by Andre R. + */ + +/** + * @file cmsis_os.c + * @brief CMSIS RTOS module code. + * + * @addtogroup CMSIS_OS + * @{ + */ + +#include "cmsis_os.h" +#include + +/*===========================================================================*/ +/* Module local definitions. */ +/*===========================================================================*/ + +/*===========================================================================*/ +/* Module exported variables. */ +/*===========================================================================*/ + +int32_t cmsis_os_started; + +/*===========================================================================*/ +/* Module local types. */ +/*===========================================================================*/ + +/*===========================================================================*/ +/* Module local variables. */ +/*===========================================================================*/ + +static memory_pool_t sempool; +static semaphore_t semaphores[CMSIS_CFG_NUM_SEMAPHORES]; + +static memory_pool_t timpool; +static struct os_timer_cb timers[CMSIS_CFG_NUM_TIMERS]; + +/*===========================================================================*/ +/* Module local functions. */ +/*===========================================================================*/ + +/** + * @brief Virtual timers common callback. + */ +static void timer_cb(void const *arg) { + + osTimerId timer_id = (osTimerId)arg; + timer_id->ptimer(timer_id->argument); + if (timer_id->type == osTimerPeriodic) { + chSysLockFromISR(); + chVTDoSetI(&timer_id->vt, TIME_MS2I(timer_id->millisec), + (vtfunc_t)timer_cb, timer_id); + chSysUnlockFromISR(); + } +} + +/*===========================================================================*/ +/* Module exported functions. */ +/*===========================================================================*/ + +/** + * @brief Kernel initialization. + */ +osStatus osKernelInitialize(void) { + + cmsis_os_started = 0; + + chSysInit(); + chThdSetPriority(HIGHPRIO); + + chPoolObjectInit(&sempool, sizeof(semaphore_t), chCoreAllocAlignedI); + chPoolLoadArray(&sempool, semaphores, CMSIS_CFG_NUM_SEMAPHORES); + + chPoolObjectInit(&timpool, sizeof(struct os_timer_cb), chCoreAllocAlignedI); + chPoolLoadArray(&timpool, timers, CMSIS_CFG_NUM_TIMERS); + + return osOK; +} + +/** + * @brief Kernel start. + */ +osStatus osKernelStart(void) { + + cmsis_os_started = 1; + + chThdSetPriority(NORMALPRIO); + + return osOK; +} + +/** + * @brief Creates a thread. + */ +osThreadId osThreadCreate(const osThreadDef_t *thread_def, void *argument) { + size_t size; + + size = thread_def->stacksize == 0 ? CMSIS_CFG_DEFAULT_STACK : + thread_def->stacksize; + return (osThreadId)chThdCreateFromHeap(0, + THD_WORKING_AREA_SIZE(size), + thread_def->name, + NORMALPRIO+thread_def->tpriority, + (tfunc_t)thread_def->pthread, + argument); +} + +/** + * @brief Thread termination. + * @note The thread is not really terminated but asked to terminate which + * is not compliant. + */ +osStatus osThreadTerminate(osThreadId thread_id) { + + if (thread_id == osThreadGetId()) { + /* Note, no memory will be recovered unless a cleaner thread is + implemented using the registry.*/ + chThdExit(0); + } + chThdTerminate(thread_id); + chThdWait((thread_t *)thread_id); + + return osOK; +} + +/** + * @brief Change thread priority. + * @note This can interfere with the priority inheritance mechanism. + */ +osStatus osThreadSetPriority(osThreadId thread_id, osPriority newprio) { + thread_t * tp = (thread_t *)thread_id; + + chSysLock(); + + /* Changing priority.*/ +#if CH_CFG_USE_MUTEXES + if ((tp->prio == tp->realprio) || ((tprio_t)newprio > tp->prio)) + tp->prio = (tprio_t)newprio; + tp->realprio = (tprio_t)newprio; +#else + tp->prio = (tprio_t)newprio; +#endif + + /* The following states need priority queues reordering.*/ + switch (tp->state) { +#if CH_CFG_USE_MUTEXES | \ + CH_CFG_USE_CONDVARS | \ + (CH_CFG_USE_SEMAPHORES && CH_CFG_USE_SEMAPHORES_PRIORITY) | \ + (CH_CFG_USE_MESSAGES && CH_CFG_USE_MESSAGES_PRIORITY) +#if CH_CFG_USE_MUTEXES + case CH_STATE_WTMTX: +#endif +#if CH_CFG_USE_CONDVARS + case CH_STATE_WTCOND: +#endif +#if CH_CFG_USE_SEMAPHORES && CH_CFG_USE_SEMAPHORES_PRIORITY + case CH_STATE_WTSEM: +#endif +#if CH_CFG_USE_MESSAGES && CH_CFG_USE_MESSAGES_PRIORITY + case CH_STATE_SNDMSGQ: +#endif + /* Re-enqueues tp with its new priority on the queue.*/ + queue_prio_insert(queue_dequeue(tp), + (threads_queue_t *)tp->u.wtobjp); + break; +#endif + case CH_STATE_READY: +#if CH_DBG_ENABLE_ASSERTS + /* Prevents an assertion in chSchReadyI().*/ + tp->state = CH_STATE_CURRENT; +#endif + /* Re-enqueues tp with its new priority on the ready list.*/ + chSchReadyI(queue_dequeue(tp)); + break; + } + + /* Rescheduling.*/ + chSchRescheduleS(); + + chSysUnlock(); + + return osOK; +} + +/** + * @brief Create a timer. + */ +osTimerId osTimerCreate(const osTimerDef_t *timer_def, + os_timer_type type, + void *argument) { + + osTimerId timer = chPoolAlloc(&timpool); + chVTObjectInit(&timer->vt); + timer->ptimer = timer_def->ptimer; + timer->type = type; + timer->argument = argument; + return timer; +} + +/** + * @brief Start a timer. + */ +osStatus osTimerStart(osTimerId timer_id, uint32_t millisec) { + + if ((millisec == 0) || (millisec == osWaitForever)) + return osErrorValue; + + timer_id->millisec = millisec; + chVTSet(&timer_id->vt, TIME_MS2I(millisec), (vtfunc_t)timer_cb, timer_id); + + return osOK; +} + +/** + * @brief Stop a timer. + */ +osStatus osTimerStop(osTimerId timer_id) { + + chVTReset(&timer_id->vt); + + return osOK; +} + +/** + * @brief Delete a timer. + */ +osStatus osTimerDelete(osTimerId timer_id) { + + chVTReset(&timer_id->vt); + chPoolFree(&timpool, (void *)timer_id); + + return osOK; +} + +/** + * @brief Send signals. + */ +int32_t osSignalSet(osThreadId thread_id, int32_t signals) { + int32_t oldsignals; + + syssts_t sts = chSysGetStatusAndLockX(); + oldsignals = (int32_t)thread_id->epending; + chEvtSignalI((thread_t *)thread_id, (eventmask_t)signals); + chSysRestoreStatusX(sts); + + return oldsignals; +} + +/** + * @brief Clear signals. + */ +int32_t osSignalClear(osThreadId thread_id, int32_t signals) { + eventmask_t m; + + chSysLock(); + + m = thread_id->epending & (eventmask_t)signals; + thread_id->epending &= ~(eventmask_t)signals; + + chSysUnlock(); + + return (int32_t)m; +} + +/** + * @brief Wait for signals. + */ +osEvent osSignalWait(int32_t signals, uint32_t millisec) { + osEvent event; + sysinterval_t timeout = (millisec == osWaitForever ? + TIME_INFINITE : (millisec == 0 ? TIME_IMMEDIATE : + TIME_MS2I(millisec))); + + if (signals == 0) + event.value.signals = (uint32_t)chEvtWaitAnyTimeout(ALL_EVENTS, timeout); + else + event.value.signals = (uint32_t)chEvtWaitAllTimeout((eventmask_t)signals, + timeout); + + /* Type of event.*/ + if (event.value.signals == 0) + event.status = osEventTimeout; + else + event.status = osEventSignal; + + return event; +} + +/** + * @brief Create a semaphore. + * @note @p semaphore_def is not used. + * @note Can involve memory allocation. + */ +osSemaphoreId osSemaphoreCreate(const osSemaphoreDef_t *semaphore_def, + int32_t count) { + + (void)semaphore_def; + + semaphore_t *sem = chPoolAlloc(&sempool); + chSemObjectInit(sem, (cnt_t)count); + return sem; +} + +/** + * @brief Wait on a semaphore. + */ +int32_t osSemaphoreWait(osSemaphoreId semaphore_id, uint32_t millisec) { + sysinterval_t timeout = (millisec == osWaitForever ? + TIME_INFINITE : (millisec == 0 ? TIME_IMMEDIATE : + TIME_MS2I(millisec))); + + msg_t msg = chSemWaitTimeout((semaphore_t *)semaphore_id, timeout); + switch (msg) { + case MSG_OK: + return osOK; + case MSG_TIMEOUT: + return osErrorTimeoutResource; + } + return osErrorResource; +} + +/** + * @brief Release a semaphore. + */ +osStatus osSemaphoreRelease(osSemaphoreId semaphore_id) { + + syssts_t sts = chSysGetStatusAndLockX(); + chSemSignalI((semaphore_t *)semaphore_id); + chSysRestoreStatusX(sts); + + return osOK; +} + +/** + * @brief Deletes a semaphore. + * @note After deletion there could be references in the system to a + * non-existent semaphore. + */ +osStatus osSemaphoreDelete(osSemaphoreId semaphore_id) { + + chSemReset((semaphore_t *)semaphore_id, 0); + chPoolFree(&sempool, (void *)semaphore_id); + + return osOK; +} + +/** + * @brief Create a mutex. + * @note @p mutex_def is not used. + * @note Can involve memory allocation. + */ +osMutexId osMutexCreate(const osMutexDef_t *mutex_def) { + + (void)mutex_def; + + binary_semaphore_t *mtx = chPoolAlloc(&sempool); + chBSemObjectInit(mtx, false); + return mtx; +} + +/** + * @brief Wait on a mutex. + */ +osStatus osMutexWait(osMutexId mutex_id, uint32_t millisec) { + sysinterval_t timeout = (millisec == osWaitForever ? + TIME_INFINITE : (millisec == 0 ? TIME_IMMEDIATE : + TIME_MS2I(millisec))); + + msg_t msg = chBSemWaitTimeout((binary_semaphore_t *)mutex_id, timeout); + switch (msg) { + case MSG_OK: + return osOK; + case MSG_TIMEOUT: + return osErrorTimeoutResource; + } + return osErrorResource; +} + +/** + * @brief Release a mutex. + */ +osStatus osMutexRelease(osMutexId mutex_id) { + + syssts_t sts = chSysGetStatusAndLockX(); + chBSemSignalI((binary_semaphore_t *)mutex_id); + chSysRestoreStatusX(sts); + + return osOK; +} + +/** + * @brief Deletes a mutex. + * @note After deletion there could be references in the system to a + * non-existent semaphore. + */ +osStatus osMutexDelete(osMutexId mutex_id) { + + chSemReset((semaphore_t *)mutex_id, 0); + chPoolFree(&sempool, (void *)mutex_id); + + return osOK; +} + +/** + * @brief Create a memory pool. + * @note The pool is not really created because it is allocated statically, + * this function just re-initializes it. + */ +osPoolId osPoolCreate(const osPoolDef_t *pool_def) { + + chPoolObjectInit(pool_def->pool, (size_t)pool_def->item_sz, NULL); + chPoolLoadArray(pool_def->pool, pool_def->items, (size_t)pool_def->pool_sz); + + return (osPoolId)pool_def->pool; +} + +/** + * @brief Allocate an object. + */ +void *osPoolAlloc(osPoolId pool_id) { + void *object; + + syssts_t sts = chSysGetStatusAndLockX(); + object = chPoolAllocI((memory_pool_t *)pool_id); + chSysRestoreStatusX(sts); + + return object; +} + +/** + * @brief Allocate an object clearing it. + */ +void *osPoolCAlloc(osPoolId pool_id) { + void *object; + + object = chPoolAllocI((memory_pool_t *)pool_id); + memset(object, 0, pool_id->object_size); + return object; +} + +/** + * @brief Free an object. + */ +osStatus osPoolFree(osPoolId pool_id, void *block) { + + syssts_t sts = chSysGetStatusAndLockX(); + chPoolFreeI((memory_pool_t *)pool_id, block); + chSysRestoreStatusX(sts); + + return osOK; +} + +/** + * @brief Create a message queue. + * @note The queue is not really created because it is allocated statically, + * this function just re-initializes it. + */ +osMessageQId osMessageCreate(const osMessageQDef_t *queue_def, + osThreadId thread_id) { + + /* Ignoring this parameter for now.*/ + (void)thread_id; + + if (queue_def->item_sz > sizeof (msg_t)) + return NULL; + + chMBObjectInit(queue_def->mailbox, + queue_def->items, + (size_t)queue_def->queue_sz); + + return (osMessageQId) queue_def->mailbox; +} + +/** + * @brief Put a message in the queue. + */ +osStatus osMessagePut(osMessageQId queue_id, + uint32_t info, + uint32_t millisec) { + msg_t msg; + sysinterval_t timeout = (millisec == osWaitForever ? + TIME_INFINITE : (millisec == 0 ? TIME_IMMEDIATE : + TIME_MS2I(millisec))); + + if (port_is_isr_context()) { + + /* Waiting makes no sense in ISRs so any value except "immediate" + makes no sense.*/ + if (millisec != 0) + return osErrorValue; + + chSysLockFromISR(); + msg = chMBPostI((mailbox_t *)queue_id, (msg_t)info); + chSysUnlockFromISR(); + } + else + msg = chMBPostTimeout((mailbox_t *)queue_id, (msg_t)info, timeout); + + return msg == MSG_OK ? osOK : osEventTimeout; +} + +/** + * @brief Get a message from the queue. + */ +osEvent osMessageGet(osMessageQId queue_id, + uint32_t millisec) { + msg_t msg; + osEvent event; + sysinterval_t timeout = (millisec == osWaitForever ? + TIME_INFINITE : (millisec == 0 ? TIME_IMMEDIATE : + TIME_MS2I(millisec))); + + event.def.message_id = queue_id; + + if (port_is_isr_context()) { + + /* Waiting makes no sense in ISRs so any value except "immediate" + makes no sense.*/ + if (millisec != 0) { + event.status = osErrorValue; + return event; + } + + chSysLockFromISR(); + msg = chMBFetchI((mailbox_t *)queue_id, (msg_t*)&event.value.v); + chSysUnlockFromISR(); + } + else { + msg = chMBFetchTimeout((mailbox_t *)queue_id, (msg_t*)&event.value.v, timeout); + } + + /* Returned event type.*/ + event.status = msg == MSG_OK ? osEventMessage : osEventTimeout; + return event; +} + +/** @} */ diff --git a/ChibiOS_20.3.2/os/common/abstractions/cmsis_os/cmsis_os.h b/ChibiOS_20.3.2/os/common/abstractions/cmsis_os/cmsis_os.h new file mode 100644 index 0000000..1b41318 --- /dev/null +++ b/ChibiOS_20.3.2/os/common/abstractions/cmsis_os/cmsis_os.h @@ -0,0 +1,522 @@ +/* + ChibiOS - Copyright (C) 2006..2018 Giovanni Di Sirio. + + This file is part of ChibiOS. + + ChibiOS is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + ChibiOS is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ +/* + Concepts and parts of this file have been contributed by Andre R. + */ + +/** + * @file cmsis_os.h + * @brief CMSIS RTOS module macros and structures. + * + * @addtogroup CMSIS_OS + * @{ + */ + +#ifndef CMSIS_OS_H +#define CMSIS_OS_H + +#include "ch.h" + +/*===========================================================================*/ +/* Module constants. */ +/*===========================================================================*/ + +/** + * @brief API version. + */ +#define osCMSIS 0x10002 + +/** + * @brief Kernel version. + */ +#define osKernelSystemId "KERNEL V1.00" + +/** + * @brief ChibiOS/RT version encoded for CMSIS. + */ +#define osCMSIS_KERNEL ((CH_KERNEL_MAJOR << 16) | \ + (CH_KERNEL_MINOR << 8) | \ + (CH_KERNEL_PATCH)) + +/** + * @name CMSIS Capabilities + * @{ + */ +#define osFeature_MainThread 1 +#define osFeature_Pool 1 +#define osFeature_MailQ 0 +#define osFeature_MessageQ 1 +#define osFeature_Signals 24 +#define osFeature_Semaphore ((1U << 31) - 1U) +#define osFeature_Wait 0 +#define osFeature_SysTick 1 +/**< @} */ + +/** + * @brief Wait forever specification for timeouts. + */ +#define osWaitForever ((uint32_t)-1) + +/** + * @brief System tick frequency. + */ +#define osKernelSysTickFrequency CH_CFG_ST_FREQUENCY + +/*===========================================================================*/ +/* Module pre-compile time settings. */ +/*===========================================================================*/ + +/** + * @brief Number of pre-allocated static semaphores/mutexes. + */ +#if !defined(CMSIS_CFG_DEFAULT_STACK) +#define CMSIS_CFG_DEFAULT_STACK 256 +#endif + +/** + * @brief Number of pre-allocated static semaphores/mutexes. + */ +#if !defined(CMSIS_CFG_NUM_SEMAPHORES) +#define CMSIS_CFG_NUM_SEMAPHORES 4 +#endif + +/** + * @brief Number of pre-allocated static timers. + */ +#if !defined(CMSIS_CFG_NUM_TIMERS) +#define CMSIS_CFG_NUM_TIMERS 4 +#endif + +/*===========================================================================*/ +/* Derived constants and error checks. */ +/*===========================================================================*/ + +#if !CH_CFG_USE_MEMPOOLS +#error "CMSIS RTOS requires CH_CFG_USE_MEMPOOLS" +#endif + +#if !CH_CFG_USE_EVENTS +#error "CMSIS RTOS requires CH_CFG_USE_EVENTS" +#endif + +#if !CH_CFG_USE_EVENTS_TIMEOUT +#error "CMSIS RTOS requires CH_CFG_USE_EVENTS_TIMEOUT" +#endif + +#if !CH_CFG_USE_SEMAPHORES +#error "CMSIS RTOS requires CH_CFG_USE_SEMAPHORES" +#endif + +#if !CH_CFG_USE_DYNAMIC +#error "CMSIS RTOS requires CH_CFG_USE_DYNAMIC" +#endif + +/*===========================================================================*/ +/* Module data structures and types. */ +/*===========================================================================*/ + +/** + * @brief Type of priority levels. + */ +typedef enum { + osPriorityIdle = -3, + osPriorityLow = -2, + osPriorityBelowNormal = -1, + osPriorityNormal = 0, + osPriorityAboveNormal = +1, + osPriorityHigh = +2, + osPriorityRealtime = +3, + osPriorityError = 0x84 +} osPriority; + +/** + * @brief Type of error codes. + */ +typedef enum { + osOK = 0, + osEventSignal = 0x08, + osEventMessage = 0x10, + osEventMail = 0x20, + osEventTimeout = 0x40, + osErrorParameter = 0x80, + osErrorResource = 0x81, + osErrorTimeoutResource = 0xC1, + osErrorISR = 0x82, + osErrorISRRecursive = 0x83, + osErrorPriority = 0x84, + osErrorNoMemory = 0x85, + osErrorValue = 0x86, + osErrorOS = 0xFF, + os_status_reserved = 0x7FFFFFFF +} osStatus; + +/** + * @brief Type of a timer mode. + */ +typedef enum { + osTimerOnce = 0, + osTimerPeriodic = 1 +} os_timer_type; + +/** + * @brief Type of thread functions. + */ +typedef void (*os_pthread) (void const *argument); + +/** + * @brief Type of timer callback. + */ +typedef void (*os_ptimer) (void const *argument); + +/** + * @brief Type of pointer to thread control block. + */ +typedef thread_t *osThreadId; + +/** + * @brief Type of pointer to timer control block. + */ +typedef struct os_timer_cb { + virtual_timer_t vt; + os_timer_type type; + os_ptimer ptimer; + void *argument; + uint32_t millisec; +} *osTimerId; + +/** + * @brief Type of pointer to mutex control block. + */ +typedef binary_semaphore_t *osMutexId; + +/** + * @brief Type of pointer to semaphore control block. + */ +typedef semaphore_t *osSemaphoreId; + +/** + * @brief Type of pointer to memory pool control block. + */ +typedef memory_pool_t *osPoolId; + +/** + * @brief Type of pointer to message queue control block. + */ +typedef struct mailbox *osMessageQId; + +/** + * @brief Type of an event. + */ +typedef struct { + osStatus status; + union { + uint32_t v; + void *p; + int32_t signals; + } value; + union { +/* osMailQId mail_id;*/ + osMessageQId message_id; + } def; +} osEvent; + +/** + * @brief Type of a thread definition block. + */ +typedef struct os_thread_def { + os_pthread pthread; + osPriority tpriority; + uint32_t stacksize; + const char *name; +} osThreadDef_t; + +/** + * @brief Type of a timer definition block. + */ +typedef struct os_timer_def { + os_ptimer ptimer; +} osTimerDef_t; + +/** + * @brief Type of a mutex definition block. + */ +typedef struct os_mutex_def { + uint32_t dummy; +} osMutexDef_t; + +/** + * @brief Type of a semaphore definition block. + */ +typedef struct os_semaphore_def { + uint32_t dummy; +} osSemaphoreDef_t; + +/** + * @brief Type of a memory pool definition block. + */ +typedef struct os_pool_def { + uint32_t pool_sz; + uint32_t item_sz; + memory_pool_t *pool; + void *items; +} osPoolDef_t; + +/** + * @brief Type of a message queue definition block. + */ +typedef struct os_messageQ_def { + uint32_t queue_sz; + uint32_t item_sz; + mailbox_t *mailbox; + void *items; +} osMessageQDef_t; + +/*===========================================================================*/ +/* Module macros. */ +/*===========================================================================*/ + +/** + * @brief Convert a microseconds value to a RTOS kernel system timer value. + */ +#define osKernelSysTickMicroSec(microsec) (((uint64_t)microsec * \ + (osKernelSysTickFrequency)) / \ + 1000000) + +/** + * @brief Create a Thread definition. + */ +#if defined(osObjectsExternal) +#define osThreadDef(thd, priority, stacksz, name) \ + extern const osThreadDef_t os_thread_def_##thd +#else +#define osThreadDef(thd, priority, stacksz, name) \ +const osThreadDef_t os_thread_def_##thd = { \ + (thd), \ + (priority), \ + (stacksz), \ + (name) \ +} +#endif + +/** + * @brief Access a Thread definition. + */ +#define osThread(name) &os_thread_def_##name + +/** + * @brief Define a Timer object. + */ +#if defined(osObjectsExternal) +#define osTimerDef(name, function) \ + extern const osTimerDef_t os_timer_def_##name +#else +#define osTimerDef(name, function) \ +const osTimerDef_t os_timer_def_##name = { \ + (function) \ +} +#endif + +/** + * @brief Access a Timer definition. + */ +#define osTimer(name) &os_timer_def_##name + +/** + * @brief Define a Mutex. + */ +#if defined(osObjectsExternal) +#define osMutexDef(name) extern const osMutexDef_t os_mutex_def_##name +#else +#define osMutexDef(name) const osMutexDef_t os_mutex_def_##name = {0} +#endif + +/** + * @brief Access a Mutex definition. + */ +#define osMutex(name) &os_mutex_def_##name + +/** + * @brief Define a Semaphore. + */ +#if defined(osObjectsExternal) +#define osSemaphoreDef(name) \ + extern const osSemaphoreDef_t os_semaphore_def_##name +#else // define the object +#define osSemaphoreDef(name) \ + const osSemaphoreDef_t os_semaphore_def_##name = {0} +#endif + +/** + * @brief Access a Semaphore definition. + */ +#define osSemaphore(name) &os_semaphore_def_##name + +/** + * @brief Define a Memory Pool. + */ +#if defined(osObjectsExternal) +#define osPoolDef(name, no, type) \ + extern const osPoolDef_t os_pool_def_##name +#else +#define osPoolDef(name, no, type) \ +static const type os_pool_buf_##name[no]; \ +static memory_pool_t os_pool_obj_##name; \ +const osPoolDef_t os_pool_def_##name = { \ + (no), \ + sizeof (type), \ + (void *)&os_pool_obj_##name, \ + (void *)&os_pool_buf_##name[0] \ +} +#endif + +/** + * @brief Access a Memory Pool definition. + */ +#define osPool(name) &os_pool_def_##name + +/** + * @brief Define a Message Queue. + */ +#if defined(osObjectsExternal) +#define osMessageQDef(name, queue_sz, type) \ + extern const osMessageQDef_t os_messageQ_def_##name +#else +#define osMessageQDef(name, queue_sz, type) \ +static const msg_t os_messageQ_buf_##name[queue_sz]; \ +static mailbox_t os_messageQ_obj_##name; \ +const osMessageQDef_t os_messageQ_def_##name = { \ + (queue_sz), \ + sizeof (type), \ + (void *)&os_messageQ_obj_##name, \ + (void *)&os_messageQ_buf_##name[0] \ +} +#endif + +/** + * @brief Access a Message Queue definition. + */ +#define osMessageQ(name) &os_messageQ_def_##name + +/*===========================================================================*/ +/* External declarations. */ +/*===========================================================================*/ + +extern int32_t cmsis_os_started; + +#ifdef __cplusplus +extern "C" { +#endif + osStatus osKernelInitialize(void); + osStatus osKernelStart(void); + osThreadId osThreadCreate(const osThreadDef_t *thread_def, void *argument); + osStatus osThreadTerminate(osThreadId thread_id); + osStatus osThreadSetPriority(osThreadId thread_id, osPriority newprio); + /*osEvent osWait(uint32_t millisec);*/ + osTimerId osTimerCreate(const 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); + 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); + osSemaphoreId osSemaphoreCreate(const 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); + osMutexId osMutexCreate(const osMutexDef_t *mutex_def); + osStatus osMutexWait(osMutexId mutex_id, uint32_t millisec); + osStatus osMutexRelease(osMutexId mutex_id); + osStatus osMutexDelete(osMutexId mutex_id); + osPoolId osPoolCreate(const osPoolDef_t *pool_def); + void *osPoolAlloc(osPoolId pool_id); + void *osPoolCAlloc(osPoolId pool_id); + osStatus osPoolFree(osPoolId pool_id, void *block); + osMessageQId osMessageCreate(const 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); +#ifdef __cplusplus +} +#endif + +/*===========================================================================*/ +/* Module inline functions. */ +/*===========================================================================*/ + +/** + * @brief To be or not to be. + */ +static inline int32_t osKernelRunning(void) { + + return cmsis_os_started; +} + +/** + * @brief System ticks since start. + */ +static inline uint32_t osKernelSysTick(void) { + + return (uint32_t)chVTGetSystemTimeX(); +} + +/** + * @brief Returns the current thread. + */ +static inline osThreadId osThreadGetId(void) { + + return (osThreadId)chThdGetSelfX(); +} + +/** + * @brief Thread time slice yield. + */ +static inline osStatus osThreadYield(void) { + + chThdYield(); + + return osOK; +} + +/** + * @brief Returns priority of a thread. + */ +static inline osPriority osThreadGetPriority(osThreadId thread_id) { + + return (osPriority)(NORMALPRIO - thread_id->prio); +} + +/** + * @brief Thread delay in milliseconds. + */ +static inline osStatus osDelay(uint32_t millisec) { + + chThdSleepMilliseconds(millisec); + + return osOK; +} + +#endif /* CMSIS_OS_H */ + +/** @} */ diff --git a/ChibiOS_20.3.2/os/common/abstractions/cmsis_os/cmsis_os.mk b/ChibiOS_20.3.2/os/common/abstractions/cmsis_os/cmsis_os.mk new file mode 100644 index 0000000..530a479 --- /dev/null +++ b/ChibiOS_20.3.2/os/common/abstractions/cmsis_os/cmsis_os.mk @@ -0,0 +1,8 @@ +# List of the ChibiOS/RT CMSIS RTOS wrapper. +CMSISRTOSSRC = ${CHIBIOS}/os/common/abstractions/cmsis_os/cmsis_os.c + +CMSISRTOSINC = ${CHIBIOS}/os/common/abstractions/cmsis_os + +# Shared variables +ALLCSRC += $(CMSISRTOSSRC) +ALLINC += $(CMSISRTOSINC) -- cgit v1.2.3