freertos.h

Go to the documentation of this file.

#ifndef NEXUS_OS_FREERTOS_H
#define NEXUS_OS_FREERTOS_H
#include "FreeRTOS.h"
#include "nexus/core/time.h"
#include "nexus/os/wait.h"
#include "queue.h"
#include "semphr.h"
#include "task.h"
 
#ifdef __cplusplus
extern "C" {
#endif

typedef struct {
    StaticSemaphore_t storage;
    SemaphoreHandle_t handle;
    uint32_t sequence;
    uint32_t waiting;
} nx_freertos_notify_t;

typedef struct {
    StaticTask_t control;
    StaticSemaphore_t finished_storage;
    SemaphoreHandle_t finished;
    TaskHandle_t handle;
    void (*entry)(void*);
    void* context;
} nx_freertos_task_t;

typedef struct {
    StaticQueue_t control;
    QueueHandle_t handle;
    uint32_t users;
} nx_freertos_queue_t;

typedef struct {
    TaskHandle_t receiver;
    UBaseType_t index;
    uint32_t sequence;
    uint32_t waiting;
} nx_freertos_direct_notify_t;

typedef struct {
    StaticTask_t control;
    TaskHandle_t handle;
} nx_freertos_permanent_task_t;

typedef struct nx_freertos_queue_waiter {
    StaticSemaphore_t storage;
    SemaphoreHandle_t handle;
    struct nx_freertos_queue_waiter* next;
    uint32_t active;
} nx_freertos_queue_waiter_t;

typedef struct {
    nx_freertos_queue_t queue;
    nx_freertos_queue_waiter_t* send_waiters;
    nx_freertos_queue_waiter_t* receive_waiters;
    uint32_t maximum_waiters;
    bool closed;
} nx_freertos_closable_queue_t;

bool nx_freertos_isr_allowed(void);
nx_result_t nx_freertos_notify_init(nx_freertos_notify_t* notification);
nx_wait_port_t nx_freertos_notify_port(nx_freertos_notify_t* notification);
nx_result_t nx_freertos_notify_destroy(nx_freertos_notify_t* notification);
nx_result_t nx_freertos_task_start(nx_freertos_task_t* task, const char* name,
                                   StackType_t* stack, size_t stack_words,
                                   UBaseType_t priority, void (*entry)(void*),
                                   void* context);
nx_result_t nx_freertos_task_discard_before_scheduler(nx_freertos_task_t* task);
nx_result_t nx_freertos_task_join(nx_freertos_task_t* task,
                                  nx_time_us_t deadline);
nx_result_t nx_freertos_queue_init(nx_freertos_queue_t* queue, uint8_t* storage,
                                   size_t storage_bytes, size_t depth,
                                   size_t item_size);
nx_result_t nx_freertos_queue_send(nx_freertos_queue_t* queue, const void* item,
                                   TickType_t wait_ticks);
nx_result_t nx_freertos_queue_receive(nx_freertos_queue_t* queue, void* item,
                                      TickType_t wait_ticks);
nx_result_t nx_freertos_queue_destroy(nx_freertos_queue_t* queue);

nx_result_t nx_freertos_queue_send_until(nx_freertos_queue_t* queue,
                                         const void* item,
                                         nx_time_us_t deadline);
nx_result_t nx_freertos_queue_receive_until(nx_freertos_queue_t* queue,
                                            void* item, nx_time_us_t deadline);
nx_result_t
nx_freertos_direct_notify_init(nx_freertos_direct_notify_t* notification,
                               TaskHandle_t receiver, UBaseType_t index);
nx_wait_port_t
nx_freertos_direct_notify_port(nx_freertos_direct_notify_t* notification);
nx_result_t
nx_freertos_direct_notify_destroy(nx_freertos_direct_notify_t* notification);
nx_result_t
nx_freertos_permanent_task_start(nx_freertos_permanent_task_t* task,
                                 const char* name, StackType_t* stack,
                                 size_t stack_words, UBaseType_t priority,
                                 void (*entry)(void*), void* context);
nx_result_t nx_freertos_queue_waiter_init(nx_freertos_queue_waiter_t* waiter);
nx_result_t
nx_freertos_queue_waiter_destroy(nx_freertos_queue_waiter_t* waiter);
nx_result_t nx_freertos_closable_queue_init(nx_freertos_closable_queue_t* queue,
                                            uint8_t* storage,
                                            size_t storage_bytes, size_t depth,
                                            size_t item_size,
                                            size_t maximum_waiters);
nx_result_t
nx_freertos_closable_queue_send_until(nx_freertos_closable_queue_t* queue,
                                      const void* item, nx_time_us_t deadline,
                                      nx_freertos_queue_waiter_t* waiter);
nx_result_t
nx_freertos_closable_queue_receive_until(nx_freertos_closable_queue_t* queue,
                                         void* item, nx_time_us_t deadline,
                                         nx_freertos_queue_waiter_t* waiter);
nx_result_t
nx_freertos_closable_queue_close(nx_freertos_closable_queue_t* queue);
nx_result_t
nx_freertos_closable_queue_destroy(nx_freertos_closable_queue_t* queue);
 
#ifdef __cplusplus
}
#endif
 
#endif /* NEXUS_OS_FREERTOS_H */