iomcu.h

Go to the documentation of this file.

#ifndef IOMCU_H
#define IOMCU_H
 
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
 
#include "hardware/gpio.h"
 
#include "heartbeat.h"
#include "hitec_line.h"
#include "hitec_port.h"
#include "iomcu_pins.h"
#include "kst_line.h"
#include "kst_port.h"
#include "link_dev.h"
#include "link_pages.h"
#include "out_stage.h"
#include "out_store.h"
#include "outputs.h"
#include "outputs_hw.h"
#include "pdmini.h"
#include "prog_port.h"
#include "safety_gate.h"
#include "sense_core1.h"
#include "sense_page.h"
#include "servo_page.h"
#include "supply_page.h"
#include "tone_page.h"
 
/* ------------------------------------------------------------- the pages */

typedef struct {
    uint16_t identity[LINK_ID_COUNT];
    uint16_t control[LINK_CT_COUNT];
    uint16_t status[LINK_ST_COUNT];
    uint16_t bench[LINK_BN_COUNT];
    uint16_t channels[LINK_CH_COUNT];   /* what each output is asked for   */
    uint16_t chan_cfg[LINK_CC_COUNT];   
    uint16_t slots[LINK_OS_COUNT];      
} iomcu_state_t;

extern iomcu_state_t s_state;

#define IOMCU_CAPABILITIES \
    ((uint16_t)(LINK_CAP_SERVO_PWM | LINK_CAP_ESC_DRIVE | LINK_CAP_ESC_TELEM))

extern servo_page_t s_servo;
extern supply_page_t s_supply;
extern pdmini_t      s_pd;
extern bool          s_pd_open;      /* the UART claimed for its pins */
extern uint8_t       s_pd_rate;         
extern bool          s_supply_unsaved;
extern bool          s_supply_attach;
extern sense_page_t  s_sense;
extern tone_page_t   s_tone;
extern sense_snap_t  s_sense_snap;
extern sense_cmd_t   s_sense_cmd;    /* core 1's order as last built */
extern uint16_t      s_run_gen;
extern bool          s_edge_set;
extern uint16_t      s_edge_gen;
extern uint64_t      s_edge_us;
extern uint64_t      s_base_reserved;
extern prog_port_t   s_prog;
#define IOMCU_PROG_PORTS 4u
extern kst_port_t    s_kst;
extern kst_line_t    s_kst_line;
extern hitec_port_t  s_hitec;
extern hitec_line_t  s_hitec_line;
extern link_dev_t    s_dev;

extern outputs_t s_outputs;
 
#define CH_THROTTLE  LINK_OUT_CHANNELS   /* bank channel 8, off the page */

extern heartbeat_mon_t s_beat;

extern uint32_t s_frames;

extern uint32_t s_refused;

extern uint32_t s_now_ms;

extern bool s_beat_level;

extern bool     s_can_up;
extern uint32_t s_can_echoes;
extern uint32_t s_can_overflows;

extern uint32_t s_last_rx_ms;

extern out_stage_t s_stage;
 
/* ------------------------------------------------------- the page handlers */
 
/* iomcu_pages.c */
void identity_read(void *ctx, uint8_t off, uint8_t n, uint16_t *out);
void control_read(void *ctx, uint8_t off, uint8_t n, uint16_t *out);
uint8_t control_write(void *ctx, uint8_t off, uint8_t n, const uint16_t *in);
void status_read(void *ctx, uint8_t off, uint8_t n, uint16_t *out);
void bench_read(void *ctx, uint8_t off, uint8_t n, uint16_t *out);
void channels_read(void *ctx, uint8_t off, uint8_t n, uint16_t *out);
uint8_t channels_write(void *ctx, uint8_t off, uint8_t n,
                       const uint16_t *in);
void chan_cfg_read(void *ctx, uint8_t off, uint8_t n, uint16_t *out);
uint8_t chan_cfg_write(void *ctx, uint8_t off, uint8_t n,
                       const uint16_t *in);
void slots_read(void *ctx, uint8_t off, uint8_t n, uint16_t *out);
uint8_t slots_write(void *ctx, uint8_t off, uint8_t n, const uint16_t *in);
void servo_read(void *ctx, uint8_t off, uint8_t n, uint16_t *out);
uint8_t servo_write(void *ctx, uint8_t off, uint8_t n, const uint16_t *in);
void prog_read(void *ctx, uint8_t off, uint8_t n, uint16_t *out);
uint8_t prog_write(void *ctx, uint8_t off, uint8_t n, const uint16_t *in);
 
/* iomcu_kst.c */
void kst_read(void *ctx, uint8_t off, uint8_t n, uint16_t *out);
uint8_t kst_write(void *ctx, uint8_t off, uint8_t n, const uint16_t *in);
 
/* iomcu_hitec.c */
void hitec_read(void *ctx, uint8_t off, uint8_t n, uint16_t *out);
uint8_t hitec_write(void *ctx, uint8_t off, uint8_t n, const uint16_t *in);
 
/* iomcu_sense.c */
void supply_read(void *ctx, uint8_t off, uint8_t n, uint16_t *out);
uint8_t supply_write(void *ctx, uint8_t off, uint8_t n, const uint16_t *in);
void sense_read(void *ctx, uint8_t off, uint8_t n, uint16_t *out);
uint8_t sense_write(void *ctx, uint8_t off, uint8_t n, const uint16_t *in);
void servo_sense_read(void *ctx, uint8_t off, uint8_t n, uint16_t *out);
uint8_t servo_sense_write(void *ctx, uint8_t off, uint8_t n,
                          const uint16_t *in);
void servo_win_read(void *ctx, uint8_t off, uint8_t n, uint16_t *out);
void sense_map_rd(void *ctx, uint8_t off, uint8_t n, uint16_t *out);
uint8_t sense_map_wr(void *ctx, uint8_t off, uint8_t n, const uint16_t *in);
void sense_win_a_read(void *ctx, uint8_t off, uint8_t n, uint16_t *out);
void sense_win_b_read(void *ctx, uint8_t off, uint8_t n, uint16_t *out);
void sense_limit_rd(void *ctx, uint8_t off, uint8_t n, uint16_t *out);
uint8_t sense_limit_wr(void *ctx, uint8_t off, uint8_t n,
                       const uint16_t *in);
 
/* iomcu_tone.c */
void tone_read(void *ctx, uint8_t off, uint8_t n, uint16_t *out);
uint8_t tone_write(void *ctx, uint8_t off, uint8_t n, const uint16_t *in);
 
/* iomcu_bind.c */
void bind_cfg_read(void *ctx, uint8_t off, uint8_t n, uint16_t *out);
uint8_t bind_cfg_write(void *ctx, uint8_t off, uint8_t n,
                       const uint16_t *in);
void bind_out_read(void *ctx, uint8_t off, uint8_t n, uint16_t *out);
uint8_t bind_out_write(void *ctx, uint8_t off, uint8_t n,
                       const uint16_t *in);
void bind_read(void *ctx, uint8_t off, uint8_t n, uint16_t *out);
uint8_t bind_write(void *ctx, uint8_t off, uint8_t n, const uint16_t *in);
void catalogue_read(void *ctx, uint8_t off, uint8_t n, uint16_t *out);
void shape_read(void *ctx, uint8_t off, uint8_t n, uint16_t *out);
void artwork_read(void *ctx, uint8_t off, uint8_t n, uint16_t *out);
void art_data_read(void *ctx, uint8_t off, uint8_t n, uint16_t *out);
uint8_t art_data_write(void *ctx, uint8_t off, uint8_t n,
                       const uint16_t *in);
void pads_read(void *ctx, uint8_t off, uint8_t n, uint16_t *out);
 
/* ---------------------------------------------- shared between the files */
 
/* iomcu_pages.c */
void save_outputs(const iomcu_state_t *s);
void ports_apply(void);
void hw_apply_only(uint8_t may_bind);
void hw_apply(void);
uint8_t chan_cfg_take(iomcu_state_t *s, const uint16_t *next,
                      const uint16_t *slots, bool save);
uint8_t slots_take(iomcu_state_t *s, const uint16_t *next, bool save);
 
/* iomcu_kst.c: the port's hardware, which main() hands to kst_port_init() */
uint8_t kst_hw_pin(void *ctx, uint8_t port);
bool kst_hw_take(void *ctx, uint8_t port, uint8_t pin);
void kst_hw_give(void *ctx);
void kst_hw_supply(void *ctx, supply_port_view_t *out);
bool kst_hw_supply_set(void *ctx, bool on, uint16_t mv, uint16_t ma);
 
/* iomcu_hitec.c: the port's hardware, which main() hands to
 * hitec_port_init() beside kst_hw_pin() and the supply's two */
bool hitec_hw_take(void *ctx, uint8_t port, uint8_t pin, uint8_t family,
                   uint8_t drive, uint8_t rx);
void hitec_hw_give(void *ctx);
void hitec_hw_abort(void *ctx);
void hitec_hw_run(void *ctx, hitec_port_run_t *out);
 
/* iomcu_sense.c */
void capabilities_update(void);
bool supply_rewire(void);
uint8_t supply_take(uint8_t off, uint8_t n, const uint16_t *in,
                    bool checked);
 
/* iomcu_tone.c */
uint64_t tone_taken(void);
bool tone_rewire(void);
 
/* iomcu_can.c */
void heartbeat_init(void);
void can_start(void);
void can_service(uint32_t now);
 
/* iomcu_report.c: every 3s at most, from the main loop */
void can_report(uint32_t now);

void reset_start(void);
 
/* ------------------------------------------------------ the inline helpers */

static inline void status_gate(iomcu_state_t *s)
{
    uint16_t faults = 0;
    safety_gate_status(&s_beat, &s_dev, s->control,
                       &s->status[LINK_ST_STATE], &faults);
    if (out_store_is_off()) {
        faults |= (uint16_t)LINK_FAULT_STORE_OFF;
    }
    s->status[LINK_ST_FAULTS] = faults;
}

static inline uint8_t bound_slots(void)
{
    uint8_t bound = 0u;
    for (uint8_t i = 0; i < OUT_MAX_SLOTS; ++i) {
        if (outputs_hw_bound(i)) {
            bound |= (uint8_t)(1u << i);
        }
    }
    return bound;
}

static inline bool heartbeat_edge(void)
{
    const bool level = gpio_get(IOMCU_HEARTBEAT_PIN);
    if (level == s_beat_level) {
        return false;
    }
    s_beat_level = level;
    return true;
}

static inline uint8_t ports_quiet(void)
{
    return (uint8_t)(kst_port_quiet_mask(&s_kst)
                     | hitec_port_quiet_mask(&s_hitec));
}

static inline uint8_t ports_wire(void)
{
    return (uint8_t)(kst_port_pin_mask(&s_kst)
                     | hitec_port_pin_mask(&s_hitec));
}

static inline void ports_exclusive(void)
{
    kst_port_other_mask(&s_kst, hitec_port_quiet_mask(&s_hitec));
    hitec_port_other_mask(&s_hitec, kst_port_quiet_mask(&s_kst));
}

static inline bool ports_hold_supply(void)
{
    return kst_port_state(&s_kst) != LINK_KST_PWM
           || hitec_port_supply_hold(&s_hitec);
}

static inline uint8_t ports_pulsing(void)
{
    return (uint8_t)(prog_port_pwm(&s_prog) & outputs_hw_ports_bound()
                     & ~ports_quiet());
}

static inline void reserve_held(void)
{
    outputs_reserve_pins(&s_outputs, s_base_reserved
                                     | supply_page_pins(&s_supply)
                                     | sense_page_held(&s_sense)
                                     | tone_page_pins(&s_tone)
                                     | prog_port_pins(&s_prog));
}

static inline void sense_build(sense_cmd_t *cmd)
{
    memset(cmd, 0, sizeof(*cmd));
    sense_page_cmd(&s_sense, cmd);
    cmd->run_gen  = s_run_gen;
    cmd->edge_set = s_edge_set && s_edge_gen == s_sense.cap_gen;
    cmd->edge_us  = s_edge_us;
}

static inline void sense_order(void)
{
    sense_build(&s_sense_cmd);
    sense_core1_order(&s_sense_cmd);
}

static inline void sense_sync(void)
{
    if (!sense_core1_snapshot(&s_sense_snap)) {
        return;
    }
    const uint64_t was = s_sense.held;
    sense_page_publish(&s_sense, &s_sense_snap, s_run_gen);
    if (s_sense.held != was) {
        reserve_held();
    }
}
 
#endif /* IOMCU_H */