sense_link.h

Go to the documentation of this file.

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

#define SENSE_LINK_MINOR 7u
#define SENSE_LINK_ENC_MINOR 9u
#define SENSE_LINK_WIN_MINOR LINK_MINOR_SERVO_WIN

#define SENSE_LINK_SETTLE_MS 500u

#define SENSE_LINK_READ_MS 40u

#define SENSE_LINK_TOTALS_MS 100u

#define SENSE_LINK_SERVO_MS 40u

#define SENSE_LINK_WIN_MS 40u

#define SENSE_LINK_WIN_HEAD ((unsigned)LINK_SW_ENTRY(2, 0))
#define SENSE_LINK_WIN_HEAD_WINDOWS 2u

#define SENSE_LINK_WIN_ALL_MS 100u

#define SENSE_LINK_GRACE_MS 2500u

#define SENSE_LINK_BUS_RETRY_MS 5000u

#define SENSE_LINK_STALE_MS 500u

#define SENSE_LINK_STATUS_COUNT ((unsigned)LINK_SN_COUNT - (unsigned)LINK_SN_FLAGS)
#define SENSE_LINK_STATUS_COUNT_V48 \
    ((unsigned)LINK_SN_COUNT_V48 - (unsigned)LINK_SN_FLAGS)
#define SENSE_LINK_SERVO_COUNT ((unsigned)LINK_SS_CH_FLAGS + 1u)

#define SENSE_LINK_NO_ANSWER (-1)
#define SENSE_LINK_ACK       0

typedef enum {
    SENSE_LINK_INA228 = 0,
    SENSE_LINK_INA3221 = 1,
} sense_link_part_t;

typedef struct {
    bool     i228, i3221;     
    bool     as5600;          
    int8_t sda,                             
           scl;                             
    uint8_t  i228_addr;       
    uint16_t i228_uohm;       
    uint16_t i228_max_da;     
    uint8_t  i3221_addr;      
    uint16_t i3221_dmohm;     
    uint8_t  i3221_ch;        
    uint8_t  i3221_parts;
    bool     i3221_unwatched;
    bool     i3221_fast_off_ch1;
} sense_setup_t;

enum {
    SENSE_LINK_EV_NO_PAGE       = 0x0001,
    SENSE_LINK_EV_PINS_UNSET    = 0x0002,
    SENSE_LINK_EV_SAME_ADDR     = 0x0004,
    SENSE_LINK_EV_BUS_REFUSED   = 0x0008,
    SENSE_LINK_EV_I228_REFUSED  = 0x0010,
    SENSE_LINK_EV_I3221_REFUSED = 0x0020,
    SENSE_LINK_EV_I228_SILENT   = 0x0040,
    SENSE_LINK_EV_I3221_SILENT  = 0x0080,
    SENSE_LINK_EV_I228_WRONG    = 0x0100,
    SENSE_LINK_EV_I3221_WRONG   = 0x0200,
    SENSE_LINK_EV_STUCK         = 0x0400,
    SENSE_LINK_EV_I228_CLIPPED  = 0x0800,
    SENSE_LINK_EV_I3221_CLIPPED = 0x1000,
    SENSE_LINK_EV_STORE_OFF     = 0x2000,
    SENSE_LINK_EV_ENC_OLD       = 0x4000,
    SENSE_LINK_EV_ENC_SILENT    = 0x8000,
    SENSE_LINK_EV_ENC_MAGNET    = 0x10000,
};

#define SENSE_LINK_EV_SETUP ((uint32_t)(SENSE_LINK_EV_PINS_UNSET        \
                                        | SENSE_LINK_EV_SAME_ADDR       \
                                        | SENSE_LINK_EV_BUS_REFUSED     \
                                        | SENSE_LINK_EV_I228_REFUSED    \
                                        | SENSE_LINK_EV_I3221_REFUSED))

typedef enum {
    SENSE_LINK_OP_NONE = 0,
    SENSE_LINK_OP_READ_SETUP,   
    SENSE_LINK_OP_OFF,          
    SENSE_LINK_OP_I228,         
    SENSE_LINK_OP_I3221,        
    SENSE_LINK_OP_BUS,          
    SENSE_LINK_OP_IDENTITY,     
    SENSE_LINK_OP_STATUS,       
    SENSE_LINK_OP_SERVO,        
    SENSE_LINK_OP_WIN,          
    SENSE_LINK_OP_WIN_ALL,      
} sense_link_op_kind_t;

typedef struct {
    sense_link_op_kind_t kind;
    bool     write;           
    uint8_t  page;            
    uint8_t off,                            
            n;                              
    uint16_t regs[4];         
} sense_link_op_t;

#define SENSE_LINK_WINDOW_MS 50u

typedef struct {
    uint16_t number;      
    bool     current;     
    bool     voltage;     
    bool     clip_hi;     
    bool     clip_lo;     
    uint8_t  clipped;     
    int16_t  mean_ma;     
    int16_t  max_ma;      
    int16_t  min_ma;      
    uint16_t mean_mv;     
    uint16_t min_mv;      
    uint32_t taken_ms;
    bool     stamped;     
} sense_link_win_t;

typedef struct {
    bool     page;        
    bool     wanted;
    bool     held;
    uint16_t setups;      
    bool     status;      
    uint32_t status_ms;   
    uint16_t flags;       
    bool     resets_read; 
    uint8_t  resets;      
    bool     win;
    bool     win_valid;   
    uint32_t win_ms;      
} sense_link_meter_t;

typedef struct {
    bool     up;              
    bool     page;            
    bool     enc_page;        
    bool     win_page;        
    bool     map;
    bool     map_held;
 
    /* What is asked, as the page is to hold it. */
    bool     want_set;
    bool     want_i228, want_i3221;   
    bool     want_enc;                
    int8_t   want_sda, want_scl;      
    uint8_t  want_parts;              
    bool     want_unwatched;          
    bool     want_off_ch1;            
    uint16_t want[LINK_SN_CONFIG_COUNT];
    uint32_t want_ms;         
 
    /* What the page holds, as read or written since the link came up. */
    bool     known;
    uint16_t held[LINK_SN_CONFIG_COUNT];
    uint32_t setup_ms;        
    bool     refused_bus, refused_i228, refused_i3221;
    bool     bus_told;        
    bool     bus_retry;       
    uint32_t bus_refused_ms;
    bool     caps_owed;       
 
    /* The exchange in flight. */
    sense_link_op_kind_t pending;
    uint16_t out[4];
 
    /* The reads. */
    bool     asked_status, asked_servo;
    uint32_t status_asked_ms, servo_asked_ms;
    bool     have_status, have_servo;
    uint16_t status[SENSE_LINK_STATUS_COUNT];
    uint16_t servo[SENSE_LINK_SERVO_COUNT];
    uint32_t status_ms;
    uint32_t status_reads;    
    bool     window_taken;    
    uint16_t window_last;     
 
    /* The window ring. */
    bool     asked_win;
    uint32_t win_asked_ms;
    bool     win_all;         
    bool     win_synced;      
    bool     win_restart;     
    uint16_t win_next;
    uint32_t win_sync_ms;     
    uint32_t win_lost;        
    bool     win_have;        
    bool     win_valid;       
    uint16_t win_newest;
    uint32_t win_moved_ms;    
    bool     win_stands;      
    uint8_t  winq_n;          
    sense_link_win_t winq[LINK_SW_RING];
    uint16_t setups;          
    bool     caps_new;
    uint16_t caps;
 
    /* What has been said. */
    uint16_t was_flags;       
    uint16_t was_clipped;     
    bool     silent_told[2];
    bool     online_seen[2];
    bool     enc_silent_told, enc_online_seen;
    bool     enc_magnet_told;       
    uint16_t enc_magnet;            
    uint16_t was_faults;
    uint8_t  clipped_ch;
    uint8_t  clip_pending;    
    uint16_t ev_id[2];        
    uint8_t  ev_found[2];     
    uint32_t events;
    bool     event_given;     
    uint32_t event_ms;        
} sense_link_t;

void sense_link_init(sense_link_t *s);

void sense_link_lost(sense_link_t *s);

void sense_link_came_up(sense_link_t *s, uint16_t minor, uint32_t now_ms);

void sense_link_want(sense_link_t *s, const sense_setup_t *w,
                     uint32_t now_ms);

bool sense_link_next(sense_link_t *s, uint32_t now_ms, bool idle,
                     sense_link_op_t *op);

void sense_link_done(sense_link_t *s, int result, const uint16_t *regs,
                     uint32_t now_ms);

void sense_link_faults(sense_link_t *s, uint16_t faults);

uint32_t sense_link_events(sense_link_t *s);

#define SENSE_LINK_EVENT_GAP_MS 5000u

uint32_t sense_link_event(sense_link_t *s, uint32_t now_ms);

bool sense_link_event_stands(const sense_link_t *s, uint32_t ev);

void sense_link_event_back(sense_link_t *s, uint32_t ev);

bool sense_link_settled(const sense_link_t *s);

enum {
    SENSE_LINK_ROW_I228        = 0x0001,  
    SENSE_LINK_ROW_I3221       = 0x0002,  
    SENSE_LINK_ROW_ENC         = 0x0004,  
    SENSE_LINK_ROW_PINS        = 0x0008,  
    SENSE_LINK_ROW_I228_ADDR   = 0x0010,
    SENSE_LINK_ROW_I228_SHUNT  = 0x0020,
    SENSE_LINK_ROW_I228_MAX    = 0x0040,
    SENSE_LINK_ROW_I3221_ADDR  = 0x0080,
    SENSE_LINK_ROW_I3221_SHUNT = 0x0100,
    SENSE_LINK_ROW_I3221_CH    = 0x0200,
};

uint16_t sense_link_unheld(const sense_link_t *s);

void sense_link_set_map(sense_link_t *s, bool map);

void sense_link_set_map_held(sense_link_t *s, bool held);

void sense_link_reread(sense_link_t *s);

bool sense_link_take_caps(sense_link_t *s, uint16_t *caps);

uint16_t sense_link_flags(const sense_link_t *s);

bool sense_link_win_on(const sense_link_t *s);

bool sense_link_take_win(sense_link_t *s, sense_link_win_t *out);

uint32_t sense_link_win_lost(const sense_link_t *s);

unsigned sense_link_windows(const sense_link_t *s);

void sense_link_win_bench(const sense_link_t *s, const sense_link_win_t *w,
                          bench_state_t *b);

bool sense_link_take_window(sense_link_t *s, bench_state_t *b);

void sense_link_meter(const sense_link_t *s, sense_link_meter_t *out);

uint32_t sense_link_reads(const sense_link_t *s);

bool sense_link_esc(const sense_link_t *s, uint32_t now_ms, bool *v_ok,
                    float *volts, bool *i_ok, float *amps);

bool sense_link_totals(const sense_link_t *s, uint32_t now_ms,
                       int32_t *charge_cmah, uint32_t *energy_cwh);

typedef struct {
    uint16_t raw;         
    uint16_t samples;     
    uint16_t still_ms;    
    uint32_t taken_ms;    
    bool weak,                              
         strong;                            
} sense_link_enc_t;

bool sense_link_enc(const sense_link_t *s, uint32_t now_ms,
                    sense_link_enc_t *out);

bool sense_link_enc_no_magnet(const sense_link_t *s, uint32_t now_ms);

uint16_t sense_link_enc_magnet(const sense_link_t *s);

bool sense_link_enc_on(const sense_link_t *s);

uint8_t sense_link_addr(const sense_link_t *s, sense_link_part_t part);

uint16_t sense_link_id(const sense_link_t *s, sense_link_part_t part);

uint8_t sense_link_found(const sense_link_t *s, sense_link_part_t part);

uint8_t sense_link_clipped_channel(const sense_link_t *s);

uint16_t sense_link_event_id(const sense_link_t *s, sense_link_part_t part);
uint8_t  sense_link_event_found(const sense_link_t *s, sense_link_part_t part);

uint16_t sense_link_i3221_dmohm(const sense_link_t *s);

uint8_t sense_link_i3221_addr(const sense_link_t *s);

int sense_link_sda(const sense_link_t *s);
int sense_link_scl(const sense_link_t *s);

bool sense_link_held_pins(const sense_link_t *s, int *sda, int *scl);
 
#ifdef __cplusplus
}
#endif