rtos.h

Go to the documentation of this file.

#ifndef RTOS_H
#define RTOS_H
 
#include "FreeRTOS.h"
#include "list.h"
#include "queue.h"
#include "semphr.h"
#include "task.h"
#include "timers.h"
 
#include <stdint.h>
 
typedef enum : size_t {
    STACK_256  = 256,
    STACK_512  = 512,
    STACK_1024 = 1024,
    STACK_2048 = 2048,
    STACK_4096 = 4096,
} RTOS_stack_size_t;
 
typedef enum : UBaseType_t {
    TASK_PRIORITY_LOW     = 8,
    TASK_PRIORITY_NORMAL  = 24,
    TASK_PRIORITY_HIGH    = 40,
} RTOS_task_priority_t;
 
 
[[gnu::always_inline]]
static inline void RTOS_delay_ms(uint32_t ms) {
    vTaskDelay(pdMS_TO_TICKS(ms));
}
 
typedef struct {
    void (*taskFunction)(void);
    uint32_t period_ms;
    UBaseType_t priority;
} RTOS_periodic_task_params_t;
 
// This is the function actually scheduled by freertos
// Arg is of type RTOS_periodic_task_params_t*
void RTOS_periodic_task_runner(void* arg);
 
 
#define RTOS_DEFINE_TASK(NAME, PERIOD_MS, PRIORITY, STACK_SIZE)            \
    static_assert(                                                             \
        (STACK_SIZE) % sizeof(StackType_t) == 0,                               \
        "Stack size must be a multiple of StackType_t"                         \
    );                                                                         \
                                                                               \
    static StaticTask_t NAME##_tcb;                                            \
    static StackType_t NAME##_stack[(STACK_SIZE) / sizeof(StackType_t)];       \
                                                                               \
    static RTOS_periodic_task_params_t NAME##_params = {                            \
        .taskFunction = (void (*)(void))NAME,                                  \
        .period_ms    = (PERIOD_MS),                                           \
        .priority     = (PRIORITY),                                            \
    };                                                                         \
                                                                               \
    TaskHandle_t NAME##_handle
 
#define RTOS_START_TASK(NAME)                                              \
    (NAME##_handle = xTaskCreateStatic(                                        \
        RTOS_periodic_task_runner,                                         \
        #NAME,                                                                 \
        sizeof(NAME##_stack) / sizeof(StackType_t),                            \
        &NAME##_params,                                                        \
        NAME##_params.priority,                                                \
        NAME##_stack,                                                          \
        &NAME##_tcb))
 
 
#define RTOS_HANDLE_OF(NAME) (NAME##_handle)
 
 
typedef struct {
    size_t item_size;
    size_t item_count;
} RTOS_queue_params_t;
 
#define RTOS_DEFINE_QUEUE(NAME, ITEM, COUNT)                               \
    static_assert(COUNT > 0, "Queue count must be greater than 0");            \
                                                                               \
    static StaticQueue_t NAME##_cb;                                            \
    static uint8_t       NAME##_data[sizeof(ITEM) * (COUNT)];                  \
                                                                               \
    static RTOS_queue_params_t NAME##_params = {                                    \
        .item_size  = sizeof(ITEM),                                            \
        .item_count = (COUNT),                                                 \
    };                                                                         \
                                                                               \
    QueueHandle_t NAME;                                                        \
 
#define RTOS_INIT_QUEUE(NAME)                                              \
    (NAME = xQueueCreateStatic(                                                \
        NAME##_params.item_count,                                              \
        NAME##_params.item_size,                                               \
        NAME##_data,                                                           \
        &NAME##_cb))
 
#define RTOS_DEFINE_SEMAPHORE(NAME)                                        \
    SemaphoreHandle_t NAME;                                                    \
    static StaticSemaphore_t NAME##_cb;
 
// Aliases for clarity
#define RTOS_DEFINE_MUTEX(NAME) RTOS_DEFINE_SEMAPHORE(NAME)
#define RTOS_DEFINE_COUNTING_SEMAPHORE(NAME) RTOS_DEFINE_SEMAPHORE(NAME)
#define RTOS_DEFINE_BINARY_SEMAPHORE(NAME) RTOS_DEFINE_SEMAPHORE(NAME)
 
#define RTOS_INIT_MUTEX(NAME)                                              \
    (NAME = xSemaphoreCreateMutexStatic(&(NAME##_cb)))
 
#define RTOS_INIT_COUNTING_SEMAPHORE(NAME, MAX_COUNT)                      \
    (NAME = xSemaphoreCreateCountingStatic((MAX_COUNT), 0, &(NAME##_cb)))
    
#define RTOS_INIT_BINARY_SEMAPHORE(NAME)                                   \
    (NAME = xSemaphoreCreateBinaryStatic(&(NAME##_cb)))
 
#endif // RTOS_H