out_bind.h

Go to the documentation of this file.

 
#ifndef RCBENCH_OUT_BIND_H
#define RCBENCH_OUT_BIND_H
 
#include <stdbool.h>
#include <stdint.h>
 
#include "outputs.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* ------------------------------------------------------------ the boards */

typedef enum {
    OUTBIND_BOARD_UNKNOWN = 0,  
    OUTBIND_BOARD_PICO_HEADER = 1,  
} outbind_board_id_t;

#define OUTBIND_PINS  26u

typedef struct {
    uint8_t     gpio;       
    uint8_t     pad;        
    bool        reserved;   
    const char *held_by;    
} outbind_pin_t;

typedef struct {
    uint16_t width_cmm;   
    uint16_t height_cmm;  
    uint16_t pitch_cmm;   
    uint16_t inset_cmm;   
    uint8_t  per_side;    
    uint8_t  corner;      
} outbind_shape_t;

typedef struct {
    uint8_t pad;        
    uint8_t kind;       
    uint8_t decivolts;
} outbind_pad_t;

typedef struct {
    uint16_t             id;      
    const char          *name;    
    const outbind_pin_t *pins;    
    uint8_t              count;   
    bool                 fixed;
    const outbind_shape_t *shape;
    const outbind_pad_t *pads;
    uint8_t              pad_count;   
} outbind_board_t;

const outbind_board_t *outbind_board(uint16_t id);
 
/* ------------------------------------------------ a board that describes itself */

void outbind_board_to_regs(const outbind_board_t *board, uint16_t *regs);

bool outbind_learn_board(uint16_t id, const uint16_t *regs);

void outbind_shape_to_regs(const outbind_board_t *board, uint16_t *regs);

bool outbind_learn_shape(uint16_t id, const uint16_t *regs);

bool outbind_pad_xy(const outbind_shape_t *shape, uint8_t pad,
                    uint16_t *x_cmm, uint16_t *y_cmm);

const outbind_pad_t *outbind_pads(uint16_t board);

uint8_t outbind_pad_count(uint16_t board);

void outbind_pads_to_regs(const outbind_board_t *board, uint16_t *regs);

bool outbind_learn_pads(uint16_t id, const uint16_t *regs);

void outbind_forget_learned(void);

uint8_t outbind_board_count(void);

const outbind_board_t *outbind_board_at(uint8_t index);

bool outbind_pin_selectable(const outbind_board_t *board, uint8_t index);

const outbind_pin_t *outbind_pins(uint16_t board);

uint8_t outbind_pin_count(uint16_t board);

uint8_t outbind_index_of(uint16_t board, uint8_t gpio);

uint64_t outbind_reserved_mask(uint16_t board);
 
/* ------------------------------------------------------------- protocols */

typedef struct {
    const char *name;          
    out_driver_t driver;       
    uint16_t     rate;      
    uint8_t      max_pins;  
    uint8_t      channels;  
    out_role_t   role;
} outbind_proto_t;

#define OUTBIND_PROTOS 8u

const outbind_proto_t *outbind_protos(void);
 
/* --------------------------------------------------------- the selection */

typedef struct {
    uint16_t board;         
    uint8_t  proto;         
    uint32_t pins[OUTBIND_PROTOS];
} outbind_t;

void outbind_init(outbind_t *b);

uint8_t outbind_group_of(const outbind_t *b, uint8_t index);

uint8_t outbind_chosen_total(const outbind_t *b);

uint8_t outbind_channels_used(const outbind_t *b);

void outbind_trim(outbind_t *b);

void outbind_set_board(outbind_t *b, uint16_t board);

uint8_t outbind_chosen(const outbind_t *b);

uint8_t outbind_wire_proto(const outbind_t *b);

bool outbind_toggle(outbind_t *b, uint8_t index);

void outbind_set_proto(outbind_t *b, uint8_t proto);

bool outbind_can_add(const outbind_t *b, uint8_t index);

#define OUTBIND_NO_GPIO 0xFFu

typedef enum {
    OUTBIND_CLASH_NONE = 0,
    OUTBIND_CLASH_PROG_SLICE,
    OUTBIND_CLASH_COMPARE,
} outbind_clash_t;

outbind_clash_t outbind_pwm_clash(const outbind_t *b, uint8_t index,
                                  uint8_t prog_gpio, uint8_t *with);

outbind_clash_t outbind_pwm_clash_ports(const outbind_t *b, uint8_t index,
                                        const uint8_t *ports, uint8_t count,
                                        uint8_t *with);
 
/* ------------------------------------------------------------- the pages */

uint8_t outbind_to_slots(const outbind_t *b, uint16_t *regs);

bool outbind_from_slots(outbind_t *b, uint16_t board,
                        const uint16_t *regs, const uint16_t *chan_cfg);

#define OUTBIND_PROTO_MIXED 0xFFu

uint8_t outbind_role_proto(const uint16_t *regs, const uint16_t *chan_cfg,
                           out_role_t role);

void outbind_to_chan_cfg(const outbind_t *b, uint16_t *regs,
                         uint16_t min_us, uint16_t max_us);
 
#ifdef __cplusplus
}
#endif
 
#endif /* RCBENCH_OUT_BIND_H */