threadx.h

Go to the documentation of this file.

#ifndef NEXUS_OS_THREADX_H
#define NEXUS_OS_THREADX_H
#include "nexus/core/time.h"
#include "nexus/os/wait.h"
#include "tx_api.h"
#ifdef __cplusplus
extern "C" {
#endif

typedef struct {
    TX_SEMAPHORE control;
    uint32_t sequence;
    uint32_t waiting;
    bool live;
} nx_threadx_notify_t;

typedef struct {
    TX_THREAD control;
    TX_SEMAPHORE finished;
    void (*entry)(void*);
    void* context;
    uint32_t entered;
    uint32_t returned;
    bool live;
} nx_threadx_task_t;

typedef struct {
    TX_THREAD control;
    void (*entry)(void*);
    void* context;
    bool live;
} nx_threadx_permanent_task_t;

typedef struct {
    TX_SEMAPHORE readable;
    TX_SEMAPHORE writable;
    uint8_t* storage;
    size_t depth;
    size_t item_size;
    size_t head;
    size_t tail;
    size_t count;
    uint32_t users;
    bool live;
} nx_threadx_queue_t;

typedef struct nx_threadx_queue_waiter {
    nx_threadx_notify_t notification;
    struct nx_threadx_queue_waiter* next;
    uint32_t active;
} nx_threadx_queue_waiter_t;

typedef struct {
    nx_threadx_queue_t queue;
    nx_threadx_queue_waiter_t* send_waiters;
    nx_threadx_queue_waiter_t* receive_waiters;
    size_t maximum_waiters;
    bool closed;
} nx_threadx_closable_queue_t;

nx_result_t nx_threadx_kernel_enter(void (*startup)(void*), void* context);

void nx_threadx_fail_stop(nx_result_t reason);

nx_result_t nx_threadx_external_tick_setup(uint32_t tick_hz);

bool nx_threadx_isr_allowed(void);

nx_result_t nx_threadx_notify_init(nx_threadx_notify_t* notification);
nx_wait_port_t nx_threadx_notify_port(nx_threadx_notify_t* notification);
nx_result_t nx_threadx_notify_destroy(nx_threadx_notify_t* notification);

nx_result_t nx_threadx_task_start(nx_threadx_task_t* task, const char* name,
                                  void* stack, size_t stack_bytes,
                                  UINT priority, void (*entry)(void*),
                                  void* context);
nx_result_t nx_threadx_task_join(nx_threadx_task_t* task,
                                 nx_time_us_t deadline);
nx_result_t nx_threadx_task_discard_before_scheduler(nx_threadx_task_t* task);
nx_result_t nx_threadx_permanent_task_start(nx_threadx_permanent_task_t* task,
                                            const char* name, void* stack,
                                            size_t stack_bytes, UINT priority,
                                            void (*entry)(void*),
                                            void* context);

nx_result_t nx_threadx_queue_init(nx_threadx_queue_t* queue, uint8_t* storage,
                                  size_t storage_bytes, size_t depth,
                                  size_t item_size);
nx_result_t nx_threadx_queue_send_until(nx_threadx_queue_t* queue,
                                        const void* item,
                                        nx_time_us_t deadline);
nx_result_t nx_threadx_queue_receive_until(nx_threadx_queue_t* queue,
                                           void* item, nx_time_us_t deadline);
nx_result_t nx_threadx_queue_destroy(nx_threadx_queue_t* queue);
nx_result_t nx_threadx_queue_waiter_init(nx_threadx_queue_waiter_t* waiter);
nx_result_t nx_threadx_queue_waiter_destroy(nx_threadx_queue_waiter_t* waiter);
nx_result_t nx_threadx_closable_queue_init(nx_threadx_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_threadx_closable_queue_close(nx_threadx_closable_queue_t* queue);
nx_result_t
nx_threadx_closable_queue_send_until(nx_threadx_closable_queue_t* queue,
                                     const void* item, nx_time_us_t deadline,
                                     nx_threadx_queue_waiter_t* waiter);
nx_result_t
nx_threadx_closable_queue_receive_until(nx_threadx_closable_queue_t* queue,
                                        void* item, nx_time_us_t deadline,
                                        nx_threadx_queue_waiter_t* waiter);
nx_result_t
nx_threadx_closable_queue_destroy(nx_threadx_closable_queue_t* queue);
#ifdef __cplusplus
}
#endif
#endif /* NEXUS_OS_THREADX_H */