hitec_prog.h

Go to the documentation of this file.

#pragma once
 
#include <stdatomic.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#include "hitec_card.h"
#include "hitec_link.h"
#include "hitec_reg.h"
#include "hitec_session.h"
#include "link_pages.h"
 
#ifdef __cplusplus
extern "C" {
#endif

#define HITEC_PROG_SUPPLY_MV 5000u
#define HITEC_PROG_SUPPLY_MA 1000u
#define HITEC_PROG_MV_MIN LINK_HITEC_SUPPLY_MIN_MV
#define HITEC_PROG_MV_MAX LINK_HITEC_SUPPLY_MAX_MV
#define HITEC_PROG_MA_MIN 50u
#define HITEC_PROG_MA_MAX 3000u
#define HITEC_PROG_PIN_LAST 47u
#define HITEC_PROG_NO_PIN   0xFFu
#define HITEC_PROG_START_MS 2000u
#define HITEC_PROG_RUN_MS (HITEC_LINK_RUN_MAX_MS + 5000u)
#define HITEC_PROG_CARD_MS 3000u

typedef enum {
    HITEC_PROG_DOWN = 0,   
    HITEC_PROG_NO_PAGE,    
    HITEC_PROG_SYNC,       
    HITEC_PROG_PWM,        
    HITEC_PROG_OTHER,      
    HITEC_PROG_OPENING,    
    HITEC_PROG_ENTERING,   
    HITEC_PROG_HELD,       
    HITEC_PROG_READING,    
    HITEC_PROG_CLEARING,   
    HITEC_PROG_LEAVING,    
    HITEC_PROG_RELEASING,  
    HITEC_PROG_RECORDING,  
    HITEC_PROG_WRITING,    
} hitec_prog_state_t;

typedef enum {
    HITEC_PROG_MSG_NONE = 0,
    HITEC_PROG_MSG_READ,          
    HITEC_PROG_MSG_DOWN,          
    HITEC_PROG_MSG_NO_PAGE,       
    HITEC_PROG_MSG_BUSY,          
    HITEC_PROG_MSG_NEED_DISARM,   
    HITEC_PROG_MSG_STOP_LATCHED,  
    HITEC_PROG_MSG_NEED_TARGET,   
    HITEC_PROG_MSG_NO_PIN,        
    HITEC_PROG_MSG_RX_PENDING,    
    HITEC_PROG_MSG_NEED_PD_C,     
    HITEC_PROG_MSG_SUPPLY_CAPS,   
    HITEC_PROG_MSG_HELD_KST,      
    HITEC_PROG_MSG_HELD_OTHER,    
    HITEC_PROG_MSG_NO_C,          
    HITEC_PROG_MSG_NO_D,          
    HITEC_PROG_MSG_ENTRY_BAD,     
    HITEC_PROG_MSG_READ_FAIL,     
    HITEC_PROG_MSG_NOT_IN_MODE,   
    HITEC_PROG_MSG_STOPPED,       
    HITEC_PROG_MSG_ABORTED,       
    HITEC_PROG_MSG_CLEARED,       
    HITEC_PROG_MSG_UNSAFE,        
    HITEC_PROG_MSG_LEFT,          
    HITEC_PROG_MSG_RELEASED,      
    HITEC_PROG_MSG_SESSION_ENDED, 
    HITEC_PROG_MSG_TIMEOUT,       
    HITEC_PROG_MSG_NO_ANSWER,     
    HITEC_PROG_MSG_RESTARTED,     
    HITEC_PROG_MSG_NACK,          
    HITEC_PROG_MSG_REFUSED,       
    HITEC_PROG_MSG_NO_LINE,       
    HITEC_PROG_MSG_SUPPLY,        
    HITEC_PROG_MSG_UNKNOWN,       
    HITEC_PROG_MSG_WRITTEN,       
    HITEC_PROG_MSG_REPAIRED,      
    HITEC_PROG_MSG_RESTORED,      
    HITEC_PROG_MSG_WRITE_OFF,     
    HITEC_PROG_MSG_NOT_READ,      
    HITEC_PROG_MSG_MUST_READ,     
    HITEC_PROG_MSG_NO_CHANGES,    
    HITEC_PROG_MSG_EDITS_PENDING, 
    HITEC_PROG_MSG_EDIT_REFUSED,  
    HITEC_PROG_MSG_RECORD_FAILED, 
    HITEC_PROG_MSG_WRITE_CUT,     
    HITEC_PROG_MSG_VERIFY_FAIL,   
    HITEC_PROG_MSG_RECORD,        
    HITEC_PROG_MSG_REC_SAME,      
    HITEC_PROG_MSG_REC_DONE,      
    HITEC_PROG_MSG_REC_MIX,       
    HITEC_PROG_MSG_REC_OTHER,     
    HITEC_PROG_MSG_RECORD_HELD,   
    HITEC_PROG_MSG_FORGOTTEN,     
    HITEC_PROG_MSG_RECORD_BAD,    
    HITEC_PROG_MSG_SUM_OK,        
    HITEC_PROG_MSG_COUNT
} hitec_prog_msg_id_t;

typedef enum {
    HITEC_PROG_INFO = 0,
    HITEC_PROG_WARN,
    HITEC_PROG_DANGER,
} hitec_prog_level_t;

typedef struct {
    uint8_t  id;     
    uint8_t  level;  
    uint16_t reg;    
    uint16_t arg;    
    uint32_t seq;    
} hitec_prog_msg_t;

typedef enum {
    HITEC_PROG_CMD_OPEN = 0,  
    HITEC_PROG_CMD_STEP,      
    HITEC_PROG_CMD_CLEAR,     
    HITEC_PROG_CMD_CLOSE,     
    HITEC_PROG_CMD_ABORT,     
} hitec_prog_cmd_kind_t;

typedef struct {
    uint8_t  kind;            
    uint8_t  port;            
    uint8_t  family;          
    uint8_t  drive;           
    uint16_t mv;              
    uint16_t ma;              
    uint32_t id;              
    hitec_ses_step_t step;    
} hitec_prog_cmd_t;

typedef struct {
    _Atomic uint32_t pass;    
} hitec_prog_gate_t;

void hitec_prog_gate_init(hitec_prog_gate_t *g);
void hitec_prog_gate_offer(hitec_prog_gate_t *g, uint32_t id);
bool hitec_prog_gate_claim(hitec_prog_gate_t *g, uint32_t id);
bool hitec_prog_gate_revoke(hitec_prog_gate_t *g, uint32_t id);

typedef struct {
    uint32_t now_ms;          
    hitec_link_readout_t rd;  
    uint32_t answer_id;       
    uint8_t  answer;          
    uint32_t outcomes;        
    hitec_link_outcome_t outcome;  
    bool     stopped;         
    bool     armed;           
    uint8_t  target;          
    uint8_t  port_pin[LINK_PG_PORTS_MAX]; 
    uint8_t  port_pin_known;  
    uint8_t  rx_mark;         
    bool     supply_read;     
    uint16_t out_mv;          
    uint16_t out_ma;          
    bool     supply_held;     
    bool     card;            
} hitec_prog_feed_t;

typedef enum {
    HITEC_RULE_SPEED = 0,  
    HITEC_RULE_DEAD_BAND,  
    HITEC_RULE_OVERLOAD,   
    HITEC_RULE_END,        
    HITEC_RULE_CENTRE,     
    HITEC_RULE_DIRECTION,  
    HITEC_RULE_FS_FAR,     
    HITEC_RULE_COUNT
} hitec_prog_rule_t;

#define HITEC_RULE_BIT(r) ((uint16_t)(1u << (r)))

#define HITEC_PROG_CUT_CHECK 0xFFu

#define HITEC_PROG_SLOW_PCT 30
#define HITEC_PROG_FS_FAR_US 300

typedef enum {
    HITEC_PROG_EDIT_OK = 0,   
    HITEC_PROG_EDIT_CHECK,    
    HITEC_PROG_EDIT_REFUSED,  
} hitec_prog_edit_t;

typedef enum {
    HITEC_PROG_REC_NONE = 0,  
    HITEC_PROG_REC_SAME,      
    HITEC_PROG_REC_DONE,      
    HITEC_PROG_REC_MIX,       
    HITEC_PROG_REC_OTHER,     
} hitec_prog_rec_t;

typedef enum {
    HITEC_PROG_WR_EDITS = 0,  
    HITEC_PROG_WR_REPAIR,     
    HITEC_PROG_WR_RESTORE,    
} hitec_prog_wr_t;

typedef struct {
    hitec_prog_feed_t f;      
    bool     fed;             
    uint32_t outcomes_seen;   
    uint32_t next_id;         
 
    hitec_session_t ses;      
    uint8_t  series;          
    uint8_t  port;            
    uint8_t  st;              
    uint8_t  op;              
    bool     owned;           
    bool     lost;            
    bool     armed;           
    bool     reenter;         
    uint16_t supply_mv;       
    uint16_t supply_ma;       
    uint16_t caps_mv;         
    uint16_t caps_ma;         
    uint16_t mv_open;         
    uint16_t ma_open;         
 
    bool     have_servo;      
    hitec_image_t servo;      
    hitec_model_t model;      
 
    uint8_t  wait;            
    uint32_t wait_id;         
    uint32_t wait_ms;         
    bool     cmd_ready;       
    hitec_prog_cmd_t cmd;     
    bool     abort_ready;     
    hitec_link_outcome_t last; 
    bool     have_last;       
    hitec_prog_gate_t *gate;  
    hitec_prog_msg_t msg;     
 
    /* --- the write side, hitec_prog_write.c --------------------------- */
    hitec_image_t draft;      
    hitec_image_t wr_target;  
    bool     write_on;        
    bool     must_read;       
    bool     wrote;           
    uint8_t  wr_kind;         
    uint8_t  wr_values;       
    uint64_t soft_has;        
    int32_t  soft_val[HITEC_P_COUNT]; 
    bool     pend;            
    uint8_t  pend_id;         
    int32_t  pend_value;      
    uint16_t pend_rules;      
    bool     rec;             
    bool     rec_open;        
    uint8_t  rec_verdict;     
    hitec_card_record_t rec_r; 
    bool     file_wanted;     
    bool     file_busy;       
    bool     file_rec;
    uint32_t file_ms;         
} hitec_prog_t;

void hitec_prog_init(hitec_prog_t *p);

void hitec_prog_gate_set(hitec_prog_t *p, hitec_prog_gate_t *g);

void hitec_prog_feed(hitec_prog_t *p, const hitec_prog_feed_t *f);

bool hitec_prog_take(hitec_prog_t *p, hitec_prog_cmd_t *out);

hitec_prog_state_t hitec_prog_state(const hitec_prog_t *p);

void hitec_prog_bench_armed(hitec_prog_t *p, bool armed);

bool hitec_prog_series_set(hitec_prog_t *p, uint8_t series);

uint8_t hitec_prog_series(const hitec_prog_t *p);

void hitec_prog_supply_set(hitec_prog_t *p, uint16_t mv, uint16_t ma);

void hitec_prog_supply_caps(hitec_prog_t *p, uint16_t max_mv,
                            uint16_t max_ma);

uint16_t hitec_prog_mv(const hitec_prog_t *p);

uint16_t hitec_prog_ma(const hitec_prog_t *p);

bool hitec_prog_mv_capped(const hitec_prog_t *p);

hitec_prog_msg_id_t hitec_prog_connect(hitec_prog_t *p);

hitec_prog_msg_id_t hitec_prog_read(hitec_prog_t *p);

hitec_prog_msg_id_t hitec_prog_leave(hitec_prog_t *p);

hitec_prog_msg_id_t hitec_prog_clear(hitec_prog_t *p);

void hitec_prog_abort(hitec_prog_t *p);

hitec_prog_msg_id_t hitec_prog_release(hitec_prog_t *p);

const hitec_prog_msg_t *hitec_prog_message(const hitec_prog_t *p);

hitec_prog_level_t hitec_prog_level(unsigned id);

uint8_t hitec_prog_port(const hitec_prog_t *p);

uint8_t hitec_prog_pin(const hitec_prog_t *p);

bool hitec_prog_precharge(const hitec_prog_t *p);

bool hitec_prog_on_port(const hitec_prog_t *p);

bool hitec_prog_holds_port(const hitec_prog_t *p);

bool hitec_prog_port_taken(const hitec_link_readout_t *rd);

bool hitec_prog_in_mode(const hitec_prog_t *p);

bool hitec_prog_stopped(const hitec_prog_t *p);

bool hitec_prog_rail(const hitec_prog_t *p);

const hitec_image_t *hitec_prog_servo(const hitec_prog_t *p);

const hitec_model_t *hitec_prog_model(const hitec_prog_t *p);

uint8_t hitec_prog_layout(const hitec_prog_t *p);

bool hitec_prog_progress(const hitec_prog_t *p, unsigned *done,
                         unsigned *total);

unsigned hitec_prog_retry_code(const hitec_prog_t *p);
 
/* --- the write side (hitec_prog_write.c) ---------------------------------- */

const hitec_image_t *hitec_prog_draft(const hitec_prog_t *p);

bool hitec_prog_can_edit(const hitec_prog_t *p);

bool hitec_prog_editable(const hitec_prog_t *p, uint8_t id);

hitec_prog_edit_t hitec_prog_edit(hitec_prog_t *p, uint8_t id,
                                  int32_t value);

uint16_t hitec_prog_pending(const hitec_prog_t *p, uint8_t *id,
                            int32_t *value);

hitec_prog_edit_t hitec_prog_confirm(hitec_prog_t *p);

void hitec_prog_cancel(hitec_prog_t *p);

uint16_t hitec_prog_rules(const hitec_prog_t *p, uint8_t id, int32_t value);

bool hitec_prog_differs(const hitec_prog_t *p, const hitec_image_t *img,
                        uint8_t id);

unsigned hitec_prog_changes(const hitec_prog_t *p);

void hitec_prog_discard(hitec_prog_t *p);

hitec_prog_msg_id_t hitec_prog_write_enable(hitec_prog_t *p, bool on);

bool hitec_prog_write_on(const hitec_prog_t *p);

hitec_prog_msg_id_t hitec_prog_write_gate(const hitec_prog_t *p,
                                          uint8_t kind);

hitec_prog_msg_id_t hitec_prog_write(hitec_prog_t *p);

bool hitec_prog_sum_bad(const hitec_prog_t *p);

hitec_prog_msg_id_t hitec_prog_repair(hitec_prog_t *p);

bool hitec_prog_first_done(const hitec_prog_t *p);

bool hitec_prog_write_progress(const hitec_prog_t *p, unsigned *done,
                               unsigned *total, uint8_t *kind);

bool hitec_prog_record(const hitec_prog_t *p);

hitec_prog_rec_t hitec_prog_record_verdict(const hitec_prog_t *p);

hitec_prog_msg_id_t hitec_prog_restore(hitec_prog_t *p);

bool hitec_prog_restore_image(const hitec_prog_t *p, hitec_image_t *out);

hitec_prog_msg_id_t hitec_prog_forget(hitec_prog_t *p);

bool hitec_prog_file_due(const hitec_prog_t *p);

size_t hitec_prog_file_take(hitec_prog_t *p, char *out, size_t n);

void hitec_prog_file_done(hitec_prog_t *p, bool ok);

bool hitec_prog_file_load(hitec_prog_t *p, const char *text, size_t len);
 
#ifdef __cplusplus
}
#endif