367 lines
8.6 KiB
C
367 lines
8.6 KiB
C
/*
|
|
* Copyright (c) 2013-2017 ARM Limited. All rights reserved.
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the License); you may
|
|
* not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an AS IS BASIS, WITHOUT
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
* ----------------------------------------------------------------------
|
|
*
|
|
* $Date: 10. January 2017
|
|
* $Revision: V1.2
|
|
*
|
|
* Project: CMSIS-RTOS API V1
|
|
* Title: cmsis_os_v1.c V1 module file
|
|
*---------------------------------------------------------------------------*/
|
|
|
|
#include <string.h>
|
|
#include "cmsis_os.h"
|
|
#include "rtx_os.h"
|
|
|
|
#if (osCMSIS >= 0x20000U)
|
|
|
|
|
|
// Thread
|
|
osThreadId osThreadCreate (const osThreadDef_t *thread_def, void *argument) {
|
|
|
|
if (thread_def == NULL) {
|
|
return (osThreadId)NULL;
|
|
}
|
|
return osThreadNew((osThreadFunc_t)thread_def->pthread, argument, &thread_def->attr);
|
|
}
|
|
|
|
|
|
// Signals
|
|
|
|
#define SignalMask ((1U<<osFeature_Signals)-1U)
|
|
|
|
int32_t osSignalSet (osThreadId thread_id, int32_t signals) {
|
|
uint32_t flags;
|
|
|
|
flags = osThreadFlagsSet(thread_id, (uint32_t)signals);
|
|
if ((flags & 0x80000000U) != 0U) {
|
|
return ((int32_t)0x80000000U);
|
|
}
|
|
return ((int32_t)(flags & ~((uint32_t)signals)));
|
|
}
|
|
|
|
int32_t osSignalClear (osThreadId thread_id, int32_t signals) {
|
|
uint32_t flags;
|
|
|
|
if (thread_id != osThreadGetId()) {
|
|
return ((int32_t)0x80000000U);
|
|
}
|
|
flags = osThreadFlagsClear((uint32_t)signals);
|
|
if ((flags & 0x80000000U) != 0U) {
|
|
return ((int32_t)0x80000000U);
|
|
}
|
|
return ((int32_t)flags);
|
|
}
|
|
|
|
osEvent osSignalWait (int32_t signals, uint32_t millisec) {
|
|
osEvent event;
|
|
uint32_t flags;
|
|
|
|
if (signals != 0) {
|
|
flags = osThreadFlagsWait((uint32_t)signals, osFlagsWaitAll, millisec);
|
|
} else {
|
|
flags = osThreadFlagsWait(SignalMask, osFlagsWaitAny, millisec);
|
|
}
|
|
if ((flags > 0U) && (flags < 0x80000000U)) {
|
|
event.status = osEventSignal;
|
|
event.value.signals = (int32_t)flags;
|
|
} else {
|
|
switch ((int32_t)flags) {
|
|
case osErrorResource:
|
|
event.status = osOK;
|
|
break;
|
|
case osErrorTimeout:
|
|
event.status = osEventTimeout;
|
|
break;
|
|
case osErrorParameter:
|
|
event.status = osErrorValue;
|
|
break;
|
|
default:
|
|
event.status = (osStatus)flags;
|
|
break;
|
|
}
|
|
}
|
|
return event;
|
|
}
|
|
|
|
|
|
// Timer
|
|
osTimerId osTimerCreate (const osTimerDef_t *timer_def, os_timer_type type, void *argument) {
|
|
|
|
if (timer_def == NULL) {
|
|
return (osTimerId)NULL;
|
|
}
|
|
return osTimerNew((osTimerFunc_t)timer_def->ptimer, type, argument, &timer_def->attr);
|
|
}
|
|
|
|
|
|
// Mutex
|
|
osMutexId osMutexCreate (const osMutexDef_t *mutex_def) {
|
|
|
|
if (mutex_def == NULL) {
|
|
return (osMutexId)NULL;
|
|
}
|
|
return osMutexNew(mutex_def);
|
|
}
|
|
|
|
|
|
// Semaphore
|
|
|
|
#if (defined (osFeature_Semaphore) && (osFeature_Semaphore != 0U))
|
|
|
|
osSemaphoreId osSemaphoreCreate (const osSemaphoreDef_t *semaphore_def, int32_t count) {
|
|
|
|
if (semaphore_def == NULL) {
|
|
return (osSemaphoreId)NULL;
|
|
}
|
|
return osSemaphoreNew(osRtxSemaphoreTokenLimit, (uint32_t)count, semaphore_def);
|
|
}
|
|
|
|
int32_t osSemaphoreWait (osSemaphoreId semaphore_id, uint32_t millisec) {
|
|
osStatus_t status;
|
|
uint32_t count;
|
|
|
|
status = osSemaphoreAcquire(semaphore_id, millisec);
|
|
switch (status) {
|
|
case osOK:
|
|
count = osSemaphoreGetCount(semaphore_id);
|
|
return ((int32_t)count + 1);
|
|
case osErrorResource:
|
|
case osErrorTimeout:
|
|
return 0;
|
|
default:
|
|
break;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
#endif // Semaphore
|
|
|
|
|
|
// Memory Pool
|
|
|
|
#if (defined(osFeature_Pool) && (osFeature_Pool != 0))
|
|
|
|
osPoolId osPoolCreate (const osPoolDef_t *pool_def) {
|
|
|
|
if (pool_def == NULL) {
|
|
return (osPoolId)NULL;
|
|
}
|
|
return ((osPoolId)(osMemoryPoolNew(pool_def->pool_sz, pool_def->item_sz, &pool_def->attr)));
|
|
}
|
|
|
|
void *osPoolAlloc (osPoolId pool_id) {
|
|
return osMemoryPoolAlloc((osMemoryPoolId_t)pool_id, 0U);
|
|
}
|
|
|
|
void *osPoolCAlloc (osPoolId pool_id) {
|
|
void *block;
|
|
uint32_t block_size;
|
|
|
|
block_size = osMemoryPoolGetBlockSize((osMemoryPoolId_t)pool_id);
|
|
if (block_size == 0U) {
|
|
return NULL;
|
|
}
|
|
block = osMemoryPoolAlloc((osMemoryPoolId_t)pool_id, 0U);
|
|
if (block != NULL) {
|
|
memset(block, 0, block_size);
|
|
}
|
|
return block;
|
|
}
|
|
|
|
osStatus osPoolFree (osPoolId pool_id, void *block) {
|
|
return osMemoryPoolFree((osMemoryPoolId_t)pool_id, block);
|
|
}
|
|
|
|
#endif // Memory Pool
|
|
|
|
|
|
// Message Queue
|
|
|
|
#if (defined(osFeature_MessageQ) && (osFeature_MessageQ != 0))
|
|
|
|
osMessageQId osMessageCreate (const osMessageQDef_t *queue_def, osThreadId thread_id) {
|
|
(void)thread_id;
|
|
|
|
if (queue_def == NULL) {
|
|
return (osMessageQId)NULL;
|
|
}
|
|
return ((osMessageQId)(osMessageQueueNew(queue_def->queue_sz, sizeof(uint32_t), &queue_def->attr)));
|
|
}
|
|
|
|
osStatus osMessagePut (osMessageQId queue_id, uint32_t info, uint32_t millisec) {
|
|
return osMessageQueuePut((osMessageQueueId_t)queue_id, &info, 0U, millisec);
|
|
}
|
|
|
|
osEvent osMessageGet (osMessageQId queue_id, uint32_t millisec) {
|
|
osStatus_t status;
|
|
osEvent event;
|
|
uint32_t message;
|
|
|
|
status = osMessageQueueGet((osMessageQueueId_t)queue_id, &message, NULL, millisec);
|
|
switch (status) {
|
|
case osOK:
|
|
event.status = osEventMessage;
|
|
event.value.v = message;
|
|
break;
|
|
case osErrorResource:
|
|
event.status = osOK;
|
|
break;
|
|
case osErrorTimeout:
|
|
event.status = osEventTimeout;
|
|
break;
|
|
default:
|
|
event.status = status;
|
|
break;
|
|
}
|
|
return event;
|
|
}
|
|
|
|
uint32_t osMessageGetSpace (osMessageQId queue_id)
|
|
{
|
|
return osMessageQueueGetSpace(queue_id);
|
|
}
|
|
|
|
#endif // Message Queue
|
|
|
|
|
|
// Mail Queue
|
|
|
|
#if (defined(osFeature_MailQ) && (osFeature_MailQ != 0))
|
|
|
|
typedef struct os_mail_queue_s {
|
|
osMemoryPoolId_t mp_id;
|
|
osMessageQueueId_t mq_id;
|
|
} os_mail_queue_t;
|
|
|
|
osMailQId osMailCreate (const osMailQDef_t *queue_def, osThreadId thread_id) {
|
|
os_mail_queue_t *ptr;
|
|
(void)thread_id;
|
|
|
|
if (queue_def == NULL) {
|
|
return (osMailQId)NULL;
|
|
}
|
|
|
|
ptr = queue_def->mail;
|
|
if (ptr == NULL) {
|
|
return (osMailQId)NULL;
|
|
}
|
|
|
|
ptr->mp_id = osMemoryPoolNew (queue_def->queue_sz, queue_def->item_sz, &queue_def->mp_attr);
|
|
ptr->mq_id = osMessageQueueNew(queue_def->queue_sz, sizeof(void *), &queue_def->mq_attr);
|
|
if ((ptr->mp_id == (osMemoryPoolId_t)NULL) || (ptr->mq_id == (osMessageQueueId_t)NULL)) {
|
|
if (ptr->mp_id != (osMemoryPoolId_t)NULL) {
|
|
osMemoryPoolDelete(ptr->mp_id);
|
|
}
|
|
if (ptr->mq_id != (osMessageQueueId_t)NULL) {
|
|
osMessageQueueDelete(ptr->mq_id);
|
|
}
|
|
return (osMailQId)NULL;
|
|
}
|
|
|
|
return (osMailQId)ptr;
|
|
}
|
|
|
|
void *osMailAlloc (osMailQId queue_id, uint32_t millisec) {
|
|
os_mail_queue_t *ptr = (os_mail_queue_t *)queue_id;
|
|
|
|
if (ptr == NULL) {
|
|
return NULL;
|
|
}
|
|
return osMemoryPoolAlloc(ptr->mp_id, millisec);
|
|
}
|
|
|
|
void *osMailCAlloc (osMailQId queue_id, uint32_t millisec) {
|
|
os_mail_queue_t *ptr = (os_mail_queue_t *)queue_id;
|
|
void *block;
|
|
uint32_t block_size;
|
|
|
|
if (ptr == NULL) {
|
|
return NULL;
|
|
}
|
|
block_size = osMemoryPoolGetBlockSize(ptr->mp_id);
|
|
if (block_size == 0U) {
|
|
return NULL;
|
|
}
|
|
block = osMemoryPoolAlloc(ptr->mp_id, millisec);
|
|
if (block != NULL) {
|
|
memset(block, 0, block_size);
|
|
}
|
|
|
|
return block;
|
|
|
|
}
|
|
|
|
osStatus osMailPut (osMailQId queue_id, const void *mail) {
|
|
os_mail_queue_t *ptr = (os_mail_queue_t *)queue_id;
|
|
|
|
if (ptr == NULL) {
|
|
return osErrorParameter;
|
|
}
|
|
if (mail == NULL) {
|
|
return osErrorValue;
|
|
}
|
|
return osMessageQueuePut(ptr->mq_id, &mail, 0U, 0U);
|
|
}
|
|
|
|
osEvent osMailGet (osMailQId queue_id, uint32_t millisec) {
|
|
os_mail_queue_t *ptr = (os_mail_queue_t *)queue_id;
|
|
osStatus_t status;
|
|
osEvent event;
|
|
void *mail;
|
|
|
|
if (ptr == NULL) {
|
|
event.status = osErrorParameter;
|
|
return event;
|
|
}
|
|
|
|
status = osMessageQueueGet(ptr->mq_id, &mail, NULL, millisec);
|
|
switch (status) {
|
|
case osOK:
|
|
event.status = osEventMail;
|
|
event.value.p = mail;
|
|
break;
|
|
case osErrorResource:
|
|
event.status = osOK;
|
|
break;
|
|
case osErrorTimeout:
|
|
event.status = osEventTimeout;
|
|
break;
|
|
default:
|
|
event.status = status;
|
|
break;
|
|
}
|
|
return event;
|
|
}
|
|
|
|
osStatus osMailFree (osMailQId queue_id, void *mail) {
|
|
os_mail_queue_t *ptr = (os_mail_queue_t *)queue_id;
|
|
|
|
if (ptr == NULL) {
|
|
return osErrorParameter;
|
|
}
|
|
if (mail == NULL) {
|
|
return osErrorValue;
|
|
}
|
|
return osMemoryPoolFree(ptr->mp_id, mail);
|
|
}
|
|
|
|
#endif // Mail Queue
|
|
|
|
#endif // osCMSIS
|