#include "FreeRTOS.h"
uint8_t freertos_rs_sizeof(uint8_t _type) {
switch (_type) {
case 0:
return sizeof(void*);
break;
case 1:
return sizeof(char*);
break;
case 2:
return sizeof(char);
break;
case 10:
return sizeof(BaseType_t);
break;
case 11:
return sizeof(UBaseType_t);
break;
case 12:
return sizeof(TickType_t);
break;
case 20:
return sizeof(TaskHandle_t);
break;
case 21:
return sizeof(QueueHandle_t);
break;
case 22:
return sizeof(SemaphoreHandle_t);
break;
case 23:
return sizeof(TaskFunction_t);
break;
case 24:
return sizeof(TimerHandle_t);
break;
case 25:
return sizeof(TimerCallbackFunction_t);
break;
case 30:
return sizeof(TaskStatus_t);
break;
case 31:
return sizeof(eTaskState);
break;
case 32:
return sizeof(unsigned long);
break;
case 33:
return sizeof(unsigned short);
break;
break;
default:
return 0;
}
}
#if (INCLUDE_vTaskDelayUntil == 1)
void freertos_rs_vTaskDelayUntil(TickType_t *pxPreviousWakeTime, TickType_t xTimeIncrement) {
vTaskDelayUntil(pxPreviousWakeTime, xTimeIncrement);
}
#endif
#if (INCLUDE_vTaskDelay == 1)
void freertos_rs_vTaskDelay(TickType_t xTicksToDelay) {
vTaskDelay(xTicksToDelay);
}
#endif
TickType_t freertos_rs_xTaskGetTickCount() {
return xTaskGetTickCount();
}
#if (configUSE_TRACE_FACILITY == 1)
UBaseType_t freertos_rs_get_system_state(TaskStatus_t * const pxTaskStatusArray, const UBaseType_t uxArraySize, uint32_t * const pulTotalRunTime) {
return uxTaskGetSystemState(pxTaskStatusArray, uxArraySize, pulTotalRunTime);
}
#endif
TickType_t freertos_rs_get_portTICK_PERIOD_MS() {
return portTICK_PERIOD_MS;
}
UBaseType_t freertos_rs_get_number_of_tasks() {
return uxTaskGetNumberOfTasks();
}
#if (configUSE_RECURSIVE_MUTEXES == 1)
QueueHandle_t freertos_rs_create_recursive_mutex() {
return xSemaphoreCreateRecursiveMutex();
}
UBaseType_t freertos_rs_take_recursive_mutex(QueueHandle_t mutex, UBaseType_t max) {
if (xSemaphoreTakeRecursive(mutex, max) == pdTRUE) {
return 0;
}
return 1;
}
UBaseType_t freertos_rs_give_recursive_mutex(QueueHandle_t mutex) {
if (xSemaphoreGiveRecursive(mutex) == pdTRUE) {
return 0;
} else {
return 1;
}
}
#endif
QueueHandle_t freertos_rs_create_mutex() {
return xSemaphoreCreateMutex();
}
QueueHandle_t freertos_rs_create_binary_semaphore() {
return xSemaphoreCreateBinary();
}
QueueHandle_t freertos_rs_create_counting_semaphore(UBaseType_t max, UBaseType_t initial) {
return xSemaphoreCreateCounting(max, initial);
}
void freertos_rs_delete_semaphore(QueueHandle_t semaphore) {
vSemaphoreDelete(semaphore);
}
UBaseType_t freertos_rs_take_mutex(QueueHandle_t mutex, UBaseType_t max) {
if (xSemaphoreTake(mutex, max) == pdTRUE) {
return 0;
}
return 1;
}
UBaseType_t freertos_rs_give_mutex(QueueHandle_t mutex) {
if (xSemaphoreGive(mutex) == pdTRUE) {
return 0;
}
return 1;
}
UBaseType_t freertos_rs_take_semaphore_isr(QueueHandle_t semaphore, BaseType_t* xHigherPriorityTaskWoken) {
if (xSemaphoreTakeFromISR(semaphore, xHigherPriorityTaskWoken) == pdTRUE) {
return 0;
}
return 1;
}
UBaseType_t freertos_rs_give_semaphore_isr(QueueHandle_t semaphore, BaseType_t* xHigherPriorityTaskWoken) {
if (xSemaphoreGiveFromISR(semaphore, xHigherPriorityTaskWoken) == pdTRUE) {
return 0;
}
return 1;
}
UBaseType_t freertos_rs_spawn_task(TaskFunction_t entry_point, void* pvParameters, const char * const name, uint8_t name_len, uint16_t stack_size, UBaseType_t priority, TaskHandle_t* task_handle) {
char c_name[configMAX_TASK_NAME_LEN] = {0};
for (int i = 0; i < name_len; i++) {
c_name[i] = name[i];
if (i == configMAX_TASK_NAME_LEN - 1) {
break;
}
}
BaseType_t ret = xTaskCreate(entry_point, c_name, stack_size, pvParameters, priority, task_handle);
if (ret != pdPASS) {
return 1;
}
configASSERT(task_handle);
return 0;
}
#if (INCLUDE_vTaskDelete == 1)
void freertos_rs_delete_task(TaskHandle_t task) {
vTaskDelete(task);
}
#endif
UBaseType_t freertos_rs_get_stack_high_water_mark(TaskHandle_t task) {
#if (INCLUDE_uxTaskGetStackHighWaterMark == 1)
return uxTaskGetStackHighWaterMark(task);
#else
return 0;
#endif
}
QueueHandle_t freertos_rs_queue_create(UBaseType_t queue_length, UBaseType_t item_size) {
return xQueueCreate(queue_length, item_size);
}
void freertos_rs_queue_delete(QueueHandle_t queue) {
vQueueDelete(queue);
}
UBaseType_t freertos_rs_queue_send(QueueHandle_t queue, void* item, TickType_t max_wait) {
if (xQueueSend(queue, item, max_wait ) != pdTRUE)
{
return 1;
}
return 0;
}
UBaseType_t freertos_rs_queue_send_isr(QueueHandle_t queue, void* item, BaseType_t* xHigherPriorityTaskWoken) {
if (xQueueSendFromISR(queue, item, xHigherPriorityTaskWoken) == pdTRUE) {
return 0;
}
return 1;
}
UBaseType_t freertos_rs_queue_receive(QueueHandle_t queue, void* item, TickType_t max_wait) {
if ( xQueueReceive( queue, item, max_wait ) != pdTRUE )
{
return 1;
}
return 0;
}
void freertos_rs_isr_yield() {
portYIELD();
}
TickType_t freertos_rs_max_wait() {
return portMAX_DELAY;
}
#if (INCLUDE_pcTaskGetTaskName == 1)
char* freertos_rs_task_get_name(TaskHandle_t task) {
return pcTaskGetTaskName(task);
}
#endif
uint32_t freertos_rs_task_notify_take(uint8_t clear_count, TickType_t wait) {
return ulTaskNotifyTake(clear_count == 1 ? pdTRUE : pdFALSE, wait);
}
BaseType_t freertos_rs_task_notify_wait(uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait) {
if (xTaskNotifyWait(ulBitsToClearOnEntry, ulBitsToClearOnExit, pulNotificationValue, xTicksToWait) == pdTRUE) {
return 0;
}
return 1;
}
eNotifyAction freertos_rs_task_notify_action(uint8_t action) {
switch (action) {
case 1:
return eSetBits;
case 2:
return eIncrement;
case 3:
return eSetValueWithOverwrite;
case 4:
return eSetValueWithoutOverwrite;
default:
return eNoAction;
}
}
BaseType_t freertos_rs_task_notify(void* task, uint32_t value, uint8_t action) {
eNotifyAction eAction = freertos_rs_task_notify_action(action);
BaseType_t v = xTaskNotify(task, value, eAction);
if (v != pdPASS) {
return 1;
}
return 0;
}
BaseType_t freertos_rs_task_notify_isr(void* task, uint32_t value, uint8_t action, BaseType_t* xHigherPriorityTaskWoken) {
eNotifyAction eAction = freertos_rs_task_notify_action(action);
BaseType_t v = xTaskNotifyFromISR(task, value, eAction, xHigherPriorityTaskWoken);
if (v != pdPASS) {
return 1;
}
return 0;
}
#if ( ( INCLUDE_xTaskGetCurrentTaskHandle == 1 ) || ( configUSE_MUTEXES == 1 ) )
TaskHandle_t freertos_rs_get_current_task() {
return xTaskGetCurrentTaskHandle();
}
#endif
#if (configUSE_TIMERS == 1)
TimerHandle_t freertos_rs_timer_create(const char * const name, uint8_t name_len, const TickType_t period,
uint8_t auto_reload, void * const timer_id, TimerCallbackFunction_t callback)
{
char c_name[configMAX_TASK_NAME_LEN] = {0};
for (int i = 0; i < name_len; i++) {
c_name[i] = name[i];
if (i == configMAX_TASK_NAME_LEN - 1) {
break;
}
}
UBaseType_t timer_auto_reload = pdFALSE;
if (auto_reload == 1) {
timer_auto_reload = pdTRUE;
}
TimerHandle_t handle = xTimerCreate(c_name, period, timer_auto_reload, timer_id, callback);
return handle;
}
BaseType_t freertos_rs_timer_start(TimerHandle_t timer, TickType_t block_time) {
if (xTimerStart(timer, block_time) != pdPASS) {
return 1;
}
return 0;
}
BaseType_t freertos_rs_timer_stop(TimerHandle_t timer, TickType_t block_time) {
if (xTimerStop(timer, block_time) != pdPASS) {
return 1;
}
return 0;
}
BaseType_t freertos_rs_timer_delete(TimerHandle_t timer, TickType_t block_time) {
if (xTimerDelete(timer, block_time) != pdPASS) {
return 1;
}
return 0;
}
BaseType_t freertos_rs_timer_change_period(TimerHandle_t timer, TickType_t block_time, TickType_t new_period) {
if (xTimerChangePeriod(timer, new_period, block_time) != pdPASS) {
return 1;
}
return 0;
}
void* freertos_rs_timer_get_id(TimerHandle_t timer) {
return pvTimerGetTimerID(timer);
}
#endif
void freertos_rs_enter_critical() {
taskENTER_CRITICAL();
}
void freertos_rs_exit_critical() {
taskEXIT_CRITICAL();
}