outputs.h

Go to the documentation of this file.

 
#pragma once
 
#include <stdbool.h>
#include <stdint.h>
 
#ifdef __cplusplus
extern "C" {
#endif

#define OUT_SPAN            1000u

#define OUT_MAX_CHANNELS    16u

#define OUT_MAX_SLOTS        8u

#define OUT_FLOOR_US       400u
#define OUT_CEILING_US    2500u

typedef enum {
    OUT_ROLE_THROTTLE = 0,   
    OUT_ROLE_SURFACE  = 1,   
} out_role_t;

#define OUT_ROLE_BIT(r)  ((uint8_t)(1u << (unsigned)(r)))

#define OUT_ROLES_ALL    ((uint8_t)(OUT_ROLE_BIT(OUT_ROLE_THROTTLE) \
                                    | OUT_ROLE_BIT(OUT_ROLE_SURFACE)))

typedef enum {
    OUT_DRIVER_NONE = 0,             
    OUT_DRIVER_PWM,      
    OUT_DRIVER_PPM,      
    OUT_DRIVER_DSHOT,    
    OUT_DRIVER_DSHOT_BIDIR, 
    OUT_DRIVER_COUNT                 
} out_driver_t;

typedef struct {
    const char *name;            
    uint8_t     channels_min;    
    uint8_t     channels_max;    
    uint8_t     pins;            
    bool        reads_back;   
    bool        pulsed;       
    uint16_t    rate_min_hz;     
    uint16_t    rate_max_hz;     
} out_driver_def_t;

const out_driver_def_t *out_driver(out_driver_t d);

typedef struct {
    out_role_t role;         
    uint16_t   command;      
    uint16_t   actual;       
    uint16_t   rest;         
    uint16_t   slew_per_s;   
    uint16_t   slew_rem;     
    uint16_t   min_us;       
    uint16_t   max_us;       
    uint32_t   last_command_ms;  
} out_channel_t;

typedef struct {
    out_driver_t driver;         
    uint8_t      first_channel;  
    uint8_t      channels;       
    uint8_t      pin;            
    uint16_t     rate_hz;        
} out_slot_t;

#define OUT_MAX_PIN     63u

typedef struct {
    out_channel_t channel[OUT_MAX_CHANNELS];  
    out_slot_t    slot[OUT_MAX_SLOTS];        
    bool          armed;                
    uint8_t       roles;        
    uint32_t      timeout_ms;   
    uint32_t      last_step_ms;   
    uint64_t      reserved;     
} outputs_t;

#define OUT_DEFAULT_TIMEOUT_MS  500u

uint16_t outputs_role_rest(out_role_t role);

void outputs_init(outputs_t *o, uint32_t now_ms);

bool outputs_configure(outputs_t *o, uint8_t slot, const out_slot_t *cfg);

void outputs_reserve_pins(outputs_t *o, uint64_t mask);

bool outputs_pin_available(const outputs_t *o, uint8_t pin);

bool outputs_set_endpoints(outputs_t *o, uint8_t ch, uint16_t min_us,
                           uint16_t max_us);

bool outputs_set_role(outputs_t *o, uint8_t ch, out_role_t role);

bool outputs_set_slew(outputs_t *o, uint8_t ch, uint16_t per_s);

void outputs_channels_apply_n(outputs_t *o, const uint16_t *regs,
                              uint8_t first, uint8_t count, uint32_t now_ms);

bool outputs_set(outputs_t *o, uint8_t ch, uint16_t command, uint32_t now_ms);

unsigned outputs_set_role_channels(outputs_t *o, out_role_t role,
                                   uint8_t limit, uint16_t command,
                                   uint32_t now_ms);

void outputs_arm(outputs_t *o, bool armed, uint32_t now_ms);

void outputs_arm_roles(outputs_t *o, uint8_t roles, uint32_t now_ms);

uint8_t outputs_armed_roles(const outputs_t *o);

bool outputs_role_armed(const outputs_t *o, out_role_t role);

bool outputs_channel_driving(const outputs_t *o, uint8_t ch);

bool outputs_slot_driving(const outputs_t *o, uint8_t slot);

bool outputs_overdue(const outputs_t *o, uint8_t ch, uint32_t now_ms);

bool outputs_keepalive(outputs_t *o, uint8_t ch, uint32_t now_ms);

bool outputs_armed(const outputs_t *o);

void outputs_step(outputs_t *o, uint32_t now_ms);

void outputs_all_off(outputs_t *o);

uint16_t outputs_actual(const outputs_t *o, uint8_t ch);

uint16_t outputs_command(const outputs_t *o, uint8_t ch);

uint16_t outputs_pulse_us(const outputs_t *o, uint8_t ch);

bool outputs_driving(const outputs_t *o);
 
#ifdef __cplusplus
}
#endif