model.h

Go to the documentation of this file.

#ifndef NEXUS_MODEL_H
#define NEXUS_MODEL_H
 
#include "nexus/io/adc.h"
#include "nexus/io/exti.h"
#include "nexus/io/flash.h"
#include "nexus/io/gpio.h"
#include "nexus/io/i2c.h"
#include "nexus/io/spi.h"
#include "nexus/io/timer.h"
#include "nexus/io/uart.h"
#include "nexus/io/watchdog.h"
#ifdef __cplusplus
extern "C" {
#endif
extern const nx_gpio_port_t* const nx_native_gpio;
extern const nx_uart_port_t* const nx_native_uart;
extern const nx_spi_endpoint_t* const nx_native_spi;
extern const nx_spi_port_t* const nx_native_spi_port;
extern const nx_i2c_port_t* const nx_native_i2c_port;
extern const nx_i2c_endpoint_t* const nx_native_i2c;
extern const nx_flash_port_t* const nx_native_flash;
extern const nx_watchdog_port_t* const nx_native_watchdog;
extern const nx_exti_port_t* const nx_native_exti;
extern const nx_pwm_port_t* const nx_native_pwm;
extern const nx_adc_port_t* const nx_native_adc;
nx_result_t nx_native_clock_configure(bool enabled, nx_time_us_t now);
nx_result_t nx_native_clock_advance(uint64_t duration_us);
nx_result_t nx_native_gpio_configure(uint32_t mask, uint32_t initial);
void nx_native_gpio_input(uint32_t value);
uint32_t nx_native_gpio_output(void);
typedef struct {
    nx_uart_rx_profile_t profile;
    void* rx_storage;
    size_t rx_capacity;
    uint8_t* tx_log;
    size_t tx_capacity;
    bool automatic_irq;
} nx_native_uart_config_t;

nx_result_t nx_native_uart_configure(const nx_native_uart_config_t* config);
nx_result_t nx_native_uart_tx_validate(void* context,
                                       const nx_uart_tx_request_t* request);

nx_result_t nx_native_uart_model_irq_configure(const nx_uart_port_t* binding,
                                               const nx_irq_policy_t* policy,
                                               const nx_irq_source_t* source);

void nx_native_uart_irq_step(void);
nx_result_t nx_native_uart_receive(uint8_t byte, uint32_t flags);
void nx_native_uart_fault(bool start_failure, bool hold_drain);
size_t nx_native_uart_transmitted(void);
nx_result_t nx_native_spi_configure(uint8_t* registers, size_t length);
void nx_native_spi_fault(size_t fail_after, bool busy);
bool nx_native_spi_cs_active(void);
nx_result_t nx_native_i2c_configure(uint8_t* memory, size_t length,
                                    uint8_t address);
void nx_native_i2c_fault(nx_result_t result, bool stuck);
nx_result_t nx_native_flash_configure(uint8_t* memory,
                                      const nx_flash_geometry_t* geometry);
void nx_native_flash_fault(size_t pulse_count);
void nx_native_watchdog_boot(uint32_t causes);
bool nx_native_watchdog_expired(void);
nx_result_t nx_native_exti_configure(uint8_t line, nx_exti_edge_t edge,
                                     nx_exti_event_t* events, size_t capacity);
nx_result_t nx_native_exti_emit(uint8_t line, nx_exti_edge_t edge);
nx_result_t nx_native_pwm_configure(uint32_t tick_hz, uint32_t period_ticks);
nx_result_t nx_native_adc_configure(const uint16_t* samples, size_t count,
                                    uint8_t resolution_bits,
                                    uint32_t reference_mv);
void nx_native_adc_fault(size_t sample_count);
void nx_native_gpio_model_input(const nx_gpio_port_t* binding, uint32_t value);
uint32_t nx_native_gpio_model_output(const nx_gpio_port_t* binding);
nx_result_t
nx_native_uart_model_configure(const nx_uart_port_t* binding,
                               const nx_native_uart_config_t* config);
void nx_native_uart_model_irq_step(const nx_uart_port_t* binding);
nx_result_t nx_native_uart_model_receive(const nx_uart_port_t* binding,
                                         uint8_t byte, uint32_t flags);
void nx_native_uart_model_fault(const nx_uart_port_t* binding,
                                bool start_failure, bool hold_drain);
size_t nx_native_uart_model_transmitted(const nx_uart_port_t* binding);
nx_result_t nx_native_spi_model_configure(const nx_spi_endpoint_t* binding,
                                          uint8_t* registers, size_t length);
void nx_native_spi_model_fault(const nx_spi_port_t* binding, size_t fail_after,
                               bool busy);
bool nx_native_spi_model_cs_active(const nx_spi_endpoint_t* binding);
nx_result_t nx_native_i2c_model_configure(const nx_i2c_endpoint_t* binding,
                                          uint8_t* memory, size_t length,
                                          uint8_t address);
void nx_native_i2c_model_fault(const nx_i2c_port_t* binding, nx_result_t result,
                               bool stuck);
nx_result_t
nx_native_flash_model_configure(const nx_flash_port_t* binding, uint8_t* memory,
                                const nx_flash_geometry_t* geometry);
void nx_native_flash_model_fault(const nx_flash_port_t* binding,
                                 size_t pulse_count);
void nx_native_watchdog_model_boot(const nx_watchdog_port_t* binding,
                                   uint32_t causes);
bool nx_native_watchdog_model_expired(const nx_watchdog_port_t* binding);
nx_result_t nx_native_exti_model_configure(const nx_exti_port_t* binding,
                                           uint8_t line, nx_exti_edge_t edge,
                                           nx_exti_event_t* events,
                                           size_t capacity);
nx_result_t nx_native_exti_model_emit(const nx_exti_port_t* binding,
                                      uint8_t line, nx_exti_edge_t edge);
nx_result_t nx_native_pwm_model_configure(const nx_pwm_port_t* binding,
                                          uint32_t tick_hz,
                                          uint32_t period_ticks);
nx_result_t nx_native_adc_model_configure(const nx_adc_port_t* binding,
                                          const uint16_t* samples, size_t count,
                                          uint8_t resolution_bits,
                                          uint32_t reference_mv);
void nx_native_adc_model_fault(const nx_adc_port_t* binding,
                               size_t sample_count);

void nx_native_spi_model_async_configure(const nx_spi_port_t* binding,
                                         bool automatic_irq);

void nx_native_spi_model_irq_step(const nx_spi_port_t* binding);

void nx_native_spi_model_drain_hold(const nx_spi_port_t* binding, bool hold);

nx_result_t nx_native_uart_model_idle(const nx_uart_port_t* binding);

nx_result_t nx_native_adc_model_trigger(const nx_adc_port_t* binding);
#ifdef __cplusplus
}
#endif
 
#endif