kst_prog.h

Go to the documentation of this file.

#pragma once
 
#include <stdatomic.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#include "kst_limits.h"
#include "kst_link.h"
#include "kst_plan.h"
#include "kst_reg.h"
 
#ifdef __cplusplus
extern "C" {
#endif

#define KST_PROG_SUPPLY_MV 5000u
#define KST_PROG_SUPPLY_MA 1000u
#define KST_PROG_WAIT_MS     100u
#define KST_PROG_WAIT_MAX_MS 10000u
#define KST_PROG_FILE_MAX 400u
#define KST_PROG_PIN_LAST 47u
#define KST_PROG_NO_PIN   0xFFu
#define KST_PROG_START_MS 2000u
#define KST_PROG_RUN_MS 30000u
#define KST_PROG_RUN_MAX_MS 120000u
#define KST_PROG_STORE_MS 3000u
#define KST_PROG_FETCH_MS 1000u
#define KST_PROG_FILE_RETRY_MS 5000u
#define KST_PROG_CARD_MS 5000u
#define KST_PROG_FILES_MAX 5u
#define KST_PROG_NAME_MAX 33u

typedef enum {
    KST_PROG_DOWN = 0,     
    KST_PROG_NO_PAGE,      
    KST_PROG_SYNC,         
    KST_PROG_PWM,          
    KST_PROG_ENTERING,     
    KST_PROG_PROGRAMMING,  
    KST_PROG_WORKING,      
    KST_PROG_LEAVING,      
} kst_prog_state_t;

typedef unsigned kst_prog_msg_id_t;

enum {
    KST_PROG_MSG_NONE = 0,
    KST_PROG_MSG_READ,            
    KST_PROG_MSG_READ_ONLY,       
    KST_PROG_MSG_WRITTEN,         
    KST_PROG_MSG_VERIFIED,        
    KST_PROG_MSG_VERIFY_DIFF,     
    KST_PROG_MSG_RESTORED,
    KST_PROG_MSG_RELEASED,
    KST_PROG_MSG_LEFT,            
    KST_PROG_MSG_SAVED,           
    KST_PROG_MSG_CARD_NONE,       
    KST_PROG_MSG_STORE_FAILED,    
    KST_PROG_MSG_FILE_BAD,        
    KST_PROG_MSG_JOURNAL,         
    KST_PROG_MSG_JOURNAL_SAME,    
    KST_PROG_MSG_JOURNAL_DONE,    
    KST_PROG_MSG_JOURNAL_DIFF,    
    KST_PROG_MSG_FORGOTTEN,       
    KST_PROG_MSG_EDIT_HARD,       
    KST_PROG_MSG_EDIT_LOCKED,     
    KST_PROG_MSG_NO_CHANGES,
    KST_PROG_MSG_NEED_ENABLE,     
    KST_PROG_MSG_NEED_READ,       
    KST_PROG_MSG_NEED_PORT,       
    KST_PROG_MSG_NO_RESTORE,      
    KST_PROG_MSG_RESTORE_REFUSED, 
    KST_PROG_MSG_STOPPED,         
    KST_PROG_MSG_TIMEOUT,         
    KST_PROG_MSG_JOURNAL_OTHER,   
    KST_PROG_MSG_CARD_FULL,      
    KST_PROG_MSG_CARD_WRITE,      
    KST_PROG_MSG_CARD_READ,       
    KST_PROG_MSG_NO_FILES,        
    KST_PROG_MSG_NAME_BAD,        
    KST_PROG_MSG_NAME_EXISTS,     
    KST_PROG_MSG_LOAD_BAD,        
    KST_PROG_MSG_LOAD_CHECKSUM,   
    KST_PROG_MSG_LOAD_NEWER,      
    KST_PROG_MSG_LOAD_TYPE,       
    KST_PROG_MSG_LOAD_VALUE,      
    KST_PROG_MSG_LOAD_REFUSED,    
    KST_PROG_MSG_LOAD_SAME,       
    KST_PROG_MSG_LOAD_SOFT,       
    KST_PROG_MSG_LOADED,          
    KST_PROG_MSG_LOADED_EDITED,   
    KST_PROG_MSG_LOADED_UNTYPED,  
    KST_PROG_MSG_NEED_TARGET,     
    KST_PROG_MSG_LEAVE_SUPPLY,    
    KST_PROG_MSG_LEFT_NO_WAIT,    
    KST_PROG_MSG_LEFT_DOUBT,      
    KST_PROG_MSG_LEAVE_CUT,       
    KST_PROG_MSG_NEED_DISARM,     
    KST_PROG_MSG_BACKUP_OTHER,    
    KST_PROG_MSG_SESSION_ENDED,   
    KST_PROG_MSG_UNKNOWN,         
    KST_PROG_MSG_SUPPLY_CAPS,     
    KST_PROG_MSG_CARD_DENIED,     
    KST_PROG_MSG_START = 0x40,
    KST_PROG_MSG_OUT   = 0x50,
    KST_PROG_MSG_REF   = 0x60,
    KST_PROG_MSG_SES   = 0x80,
    KST_PROG_MSG_END   = 0xB0
};

typedef enum {
    KST_PROG_INFO = 0,
    KST_PROG_WARN,
    KST_PROG_DANGER,
} kst_prog_level_t;

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

typedef enum {
    KST_PROG_EDIT_OK = 0,   
    KST_PROG_EDIT_SOFT,     
    KST_PROG_EDIT_REFUSED,  
} kst_prog_edit_t;

typedef enum {
    KST_PROG_FROM_NONE = 0,
    KST_PROG_FROM_SESSION,  
    KST_PROG_FROM_JOURNAL,  
    KST_PROG_FROM_RUN,      
    KST_PROG_FROM_COUNT
} kst_prog_from_t;

typedef struct {
    uint8_t from;       
    uint8_t writes;     
    uint8_t stay;       
    kst_rules_t soft;   
    bool    unchecked;  
} kst_prog_restore_t;

typedef enum {
    KST_PROG_CARD_IDLE = 0,
    KST_PROG_CARD_SAVE,   
    KST_PROG_CARD_LIST,   
    KST_PROG_CARD_LOAD,   
} kst_prog_card_op_t;

typedef enum {
    KST_PROG_CARD_OK = 0,
    KST_PROG_CARD_NO_CARD,
    KST_PROG_CARD_FULL,       
    KST_PROG_CARD_WRITE_ERR,
    KST_PROG_CARD_READ_ERR,   
    KST_PROG_CARD_NAME,       
    KST_PROG_CARD_EXISTS,     
    KST_PROG_CARD_BAD,        
    KST_PROG_CARD_CHECKSUM,   
    KST_PROG_CARD_NEWER,      
    KST_PROG_CARD_TYPE,       
    KST_PROG_CARD_VALUE,      
    KST_PROG_CARD_LIMIT,      
    KST_PROG_CARD_DENIED,     
    KST_PROG_CARD_RESULTS
} kst_prog_card_result_t;

typedef enum {
    KST_PROG_FILE_VERIFIED = 0,  
    KST_PROG_FILE_EDITED,        
    KST_PROG_FILE_UNTYPED,       
    KST_PROG_FILE_KINDS
} kst_prog_file_kind_t;

typedef struct {
    uint8_t op;          
    bool preset;         
    uint32_t id;         
    char name[KST_PROG_NAME_MAX];  
    uint16_t first;      
    kst_image_t image;   
} kst_prog_card_req_t;

typedef struct {
    uint32_t id;
    uint8_t result;      
    char name[KST_PROG_NAME_MAX];  
    /* KST_PROG_CARD_LOAD */
    uint8_t kind;        
    uint8_t type;        
    uint8_t servo_type;  
    kst_field_set_t skipped;  
    uint8_t named;       
    uint8_t fields;      
    uint8_t field;       
    uint16_t line;       
    uint8_t rule;        
    kst_image_t image;   
    /* KST_PROG_CARD_LIST */
    uint8_t count;       
    uint16_t total;      
    uint8_t types[KST_PROG_FILES_MAX];  
    char names[KST_PROG_FILES_MAX][KST_PROG_NAME_MAX];
} kst_prog_card_done_t;

typedef enum {
    KST_PROG_CMD_START = 0,   
    KST_PROG_CMD_ABORT,       
    KST_PROG_CMD_FETCH,       
} kst_prog_cmd_kind_t;

typedef struct {
    kst_prog_cmd_kind_t kind;
    uint32_t id;               
    kst_link_request_t req;             
} kst_prog_cmd_t;

typedef struct {
    _Atomic uint32_t pass;     
} kst_prog_gate_t;

void kst_prog_gate_init(kst_prog_gate_t *g);
void kst_prog_gate_offer(kst_prog_gate_t *g, uint32_t id);
bool kst_prog_gate_claim(kst_prog_gate_t *g, uint32_t id);
bool kst_prog_gate_revoke(kst_prog_gate_t *g, uint32_t id);

typedef enum {
    KST_PROG_RES_OK = 0,   
    KST_PROG_RES_CLEAN,    
    KST_PROG_RES_DOUBT,    
} kst_prog_res_t;

kst_prog_res_t kst_prog_result_class(unsigned result);

typedef struct {
    uint32_t now_ms;
    kst_link_readout_t rd;
    bool have_image;
    kst_image_t image;
    bool have_backup;
    kst_image_t backup;
    uint32_t answer_id;        
    kst_link_start_t answer;   
    uint32_t outcomes;         
    kst_link_outcome_t outcome;         
    bool     supply_read;      
    uint16_t out_mv;           
    uint16_t out_ma;           
    uint16_t set_mv;           
    bool stopped;              
    bool armed;                
    bool card;                 
    uint8_t card_state;        
    uint8_t target;            
    uint8_t port_pin[LINK_PG_PORTS_MAX]; 
    uint8_t port_pin_known;             
} kst_prog_feed_t;

typedef struct {
    kst_prog_feed_t f;
    bool fed;
    uint32_t outcomes_seen;
    uint32_t next_id;
 
    bool have_servo;
    bool fp_ok;
    kst_image_t servo;        
    kst_image_t draft;        
    bool journal;             
    bool journal_open;        
    bool journal_other;       
    bool need_read;           
    uint8_t journal_port;
    uint8_t journal_pin;      
    kst_image_t journal_img;     
    kst_image_t journal_target;  
 
    bool write_enabled;
    bool written;             
    bool backed_up;           
    bool no_file;             
    bool held_no_file;        
    uint8_t port;                       
    uint16_t supply_mv;       
    uint16_t supply_ma;                 
    uint16_t caps_mv;         
    uint16_t caps_ma;                   
    uint16_t floor_mv;        
    uint16_t pwm_wait_ms;     
 
    uint8_t wait;             
    uint8_t op;               
    uint8_t writes;           
    uint8_t restoring;        
    bool chain_read;          
    bool armed;               
    kst_field_set_t wrote;    
    kst_field_set_t held_wrote;  
    kst_field_set_t wrote_before; 
    bool wrote_known;         
    bool leave_doubt;         
    uint32_t wait_ms;                   
    uint32_t run_ms;          
    uint32_t fetch_ms;                  
    bool fetched;                       
    bool cmd_fetch;                     
    uint32_t wait_id;                   
    bool cmd_ready;                     
    kst_prog_cmd_t cmd;                 
    kst_link_request_t held;  
    kst_image_t held_target;  
    bool held_journal;        
    bool held_over;           
    kst_image_t held_before;            
    kst_prog_gate_t *gate;    
    bool cmd_out;             
    bool cmd_run;             
    bool keep;                
    bool keep_soft;                     
    bool keep_soft_load;                
    kst_image_t keep_draft;             
 
    uint8_t card_op;          
    bool card_ready;          
    bool card_auto;           
    bool soft_load;           
    kst_field_set_t load_skipped;       
    kst_field_set_t soft_skipped;   
    uint8_t file_types[KST_PROG_FILES_MAX];  
    uint8_t load_kind;        
    uint8_t load_named;       
    uint8_t load_fields;      
    char card_name[KST_PROG_NAME_MAX];  
    char preset[KST_PROG_NAME_MAX];     
    char backup[KST_PROG_NAME_MAX];     
    uint32_t card_id;
    uint32_t card_ms;                   
    uint32_t late_id;         
    kst_image_t late_img;     
    uint8_t files_n;                    
    uint16_t files_total;               
    uint16_t files_first;     
    uint16_t card_first;      
    uint32_t files_seq;       
    char files[KST_PROG_FILES_MAX][KST_PROG_NAME_MAX];  
 
    bool soft;
    kst_image_t soft_img;
    kst_rules_t soft_rules;
    kst_field_set_t conf_set;       
    uint16_t conf_raw[KST_F_COUNT]; 
    uint8_t plan_n;           
 
    bool file_wanted;
    bool file_busy;
    bool file_stale;          
    bool file_retry;          
    uint32_t file_retry_ms;             
    uint8_t file_next;        
    uint8_t file_for;         
 
    /* The limit run (servo_limrun.h): the servo as its first session read
     * it, kept across its sessions and after it, until the next run. */
    bool run_hold;
    bool run_own;             
    bool run_written;         
    kst_image_t run_img;
    char run_backup[KST_PROG_NAME_MAX];  
 
    kst_prog_msg_t msg;
    kst_plan_t plan;          
} kst_prog_t;

void kst_prog_init(kst_prog_t *p);

void kst_prog_gate_set(kst_prog_t *p, kst_prog_gate_t *g);

void kst_prog_feed(kst_prog_t *p, const kst_prog_feed_t *f);

bool kst_prog_take(kst_prog_t *p, kst_prog_cmd_t *out);

void kst_prog_screen_entry(kst_prog_t *p);

kst_prog_state_t kst_prog_state(const kst_prog_t *p);
link_kst_op_t kst_prog_op(const kst_prog_t *p);
bool kst_prog_writing(const kst_prog_t *p);
unsigned kst_prog_write_steps(const kst_prog_t *p);
bool kst_prog_planning(const kst_prog_t *p);
const kst_prog_msg_t *kst_prog_message(const kst_prog_t *p);
 
/* --- what is held --------------------------------------------------------- */

bool kst_prog_have_servo(const kst_prog_t *p);
bool kst_prog_editable(const kst_prog_t *p);
const kst_image_t *kst_prog_servo(const kst_prog_t *p);
const kst_image_t *kst_prog_draft(const kst_prog_t *p);
bool kst_prog_write_enabled(const kst_prog_t *p);
uint8_t kst_prog_port(const kst_prog_t *p);
bool kst_prog_journal(const kst_prog_t *p);
bool kst_prog_journal_held(const kst_prog_t *p);
bool kst_prog_journal_other(const kst_prog_t *p);
kst_prog_msg_id_t kst_prog_journal_asks(const kst_prog_t *p);
bool kst_prog_backup_other(const kst_prog_t *p);
uint8_t kst_prog_journal_port(const kst_prog_t *p);
uint8_t kst_prog_journal_pin(const kst_prog_t *p);
unsigned kst_prog_journal_arg(const kst_prog_t *p);
bool kst_prog_in_doubt(const kst_prog_t *p);
bool kst_prog_first_write(const kst_prog_t *p);
bool kst_prog_backed_up(const kst_prog_t *p);
const char *kst_prog_backup_name(const kst_prog_t *p);
bool kst_prog_no_file(const kst_prog_t *p);
bool kst_prog_save_first(const kst_prog_t *p);
bool kst_prog_save_none(const kst_prog_t *p);

kst_field_set_t kst_prog_changed(const kst_prog_t *p);
unsigned kst_prog_changes(const kst_prog_t *p);
kst_rules_t kst_prog_rules(const kst_prog_t *p);
 
/* --- editing ---------------------------------------------------------------- */

bool kst_prog_range(const kst_prog_t *p, kst_field_id_t id, uint16_t *lo,
                    uint16_t *hi);

kst_prog_edit_t kst_prog_edit(kst_prog_t *p, kst_field_id_t id, uint16_t raw);
kst_prog_edit_t kst_prog_step(kst_prog_t *p, kst_field_id_t id, int dir);
kst_rules_t kst_prog_soft_rules(const kst_prog_t *p);
const kst_image_t *kst_prog_soft_base(const kst_prog_t *p);
kst_field_set_t kst_prog_soft_fields(const kst_prog_t *p,
                                     const kst_image_t *img);
const kst_image_t *kst_prog_soft_image(const kst_prog_t *p);
void kst_prog_soft_confirm(kst_prog_t *p);
void kst_prog_soft_cancel(kst_prog_t *p);
void kst_prog_discard(kst_prog_t *p);
 
/* --- operations: KST_PROG_MSG_NONE when taken, else the message set ------- */

kst_prog_msg_id_t kst_prog_connect(kst_prog_t *p, uint8_t port);
void kst_prog_bench_armed(kst_prog_t *p, bool armed);
bool kst_prog_port_taken(const kst_link_readout_t *rd);
bool kst_prog_holds_port(const kst_prog_t *p);
void kst_prog_supply_set(kst_prog_t *p, uint16_t mv, uint16_t ma);
void kst_prog_supply_caps(kst_prog_t *p, uint16_t max_mv, uint16_t max_ma);
void kst_prog_supply_floor(kst_prog_t *p, uint16_t min_mv);
uint16_t kst_prog_supply_mv(const kst_prog_t *p);
uint16_t kst_prog_supply_ma(const kst_prog_t *p);
kst_prog_msg_id_t kst_prog_read(kst_prog_t *p);
kst_prog_msg_id_t kst_prog_verify(kst_prog_t *p);
kst_prog_msg_id_t kst_prog_enable(kst_prog_t *p, bool on);
kst_prog_msg_id_t kst_prog_enable_check(const kst_prog_t *p);
bool kst_prog_restore_only(const kst_prog_t *p);
kst_prog_msg_id_t kst_prog_write_check(kst_prog_t *p);
kst_prog_msg_id_t kst_prog_write(kst_prog_t *p);
kst_prog_msg_id_t kst_prog_release_check(kst_prog_t *p);
kst_prog_msg_id_t kst_prog_release(kst_prog_t *p);
bool kst_prog_restore_offered(const kst_prog_t *p, kst_prog_from_t from);
kst_prog_msg_id_t kst_prog_restore_plan(kst_prog_t *p, kst_prog_from_t from,
                                        kst_prog_restore_t *out);
kst_prog_msg_id_t kst_prog_restore(kst_prog_t *p,
                                   const kst_prog_restore_t *plan);
void kst_prog_forget(kst_prog_t *p);
/* --- the limit run ----------------------------------------------------------- */
 
/*
 * A limit run (servo_limrun.h) programs LEFT ANGLE and RIGHT ANGLE, and
 * PULSE LOWER and PULSE UPPER where its SERVO PULSES setting is 1000-2000,
 * over many sessions: a session per write.  These four are the run's
 * fields.  The run keeps the servo as its first session read it:
 *
 *   - RESTORE offers it (KST_PROG_FROM_RUN) while the servo read differs
 *     from it in the run's fields and in no other: an ordinary write of
 *     those fields, checked as every write is.
 *   - A later session of the run whose servo differs from it in the run's
 *     fields at most saves no file before its write: the file of the
 *     first write holds the servo as the run found it.
 *
 * The hold is in memory: a start of the panel forgets it.
 */

bool kst_prog_run_hold(kst_prog_t *p);
void kst_prog_run_written(kst_prog_t *p);
void kst_prog_run_close(kst_prog_t *p);
void kst_prog_run_drop(kst_prog_t *p);
const kst_image_t *kst_prog_run_image(const kst_prog_t *p);
const char *kst_prog_run_backup(const kst_prog_t *p);
bool kst_prog_run_matches(const kst_prog_t *p);

kst_prog_msg_id_t kst_prog_leave(kst_prog_t *p);
bool kst_prog_wait_set(kst_prog_t *p, uint32_t ms);
uint16_t kst_prog_wait_ms(const kst_prog_t *p);
void kst_prog_abort(kst_prog_t *p);
 
/* --- servo files ------------------------------------------------------------- */

kst_prog_msg_id_t kst_prog_save(kst_prog_t *p, const char *name);
kst_prog_msg_id_t kst_prog_files(kst_prog_t *p, unsigned first);
unsigned kst_prog_files_first(const kst_prog_t *p);
kst_prog_msg_id_t kst_prog_load(kst_prog_t *p, const char *name);
bool kst_prog_card_busy(const kst_prog_t *p);
uint32_t kst_prog_files_seq(const kst_prog_t *p);
const char *kst_prog_file_name(const kst_prog_t *p, unsigned i);
unsigned kst_prog_file_type(const kst_prog_t *p, unsigned i);
unsigned kst_prog_file_count(const kst_prog_t *p, unsigned *total);
const char *kst_prog_preset_name(const kst_prog_t *p);
const char *kst_prog_card_name(const kst_prog_t *p);
kst_prog_file_kind_t kst_prog_load_kind(const kst_prog_t *p);
unsigned kst_prog_load_named(const kst_prog_t *p, unsigned *fields);
kst_field_set_t kst_prog_load_skipped(const kst_prog_t *p);
bool kst_prog_soft_is_load(const kst_prog_t *p);

bool kst_prog_card_take(kst_prog_t *p, kst_prog_card_req_t *out);
void kst_prog_card_done(kst_prog_t *p, const kst_prog_card_done_t *done);
 
/* --- the journal's file ------------------------------------------------------ */

size_t kst_prog_file_take(kst_prog_t *p, char *out, size_t n);
void kst_prog_file_done(kst_prog_t *p, bool ok);
bool kst_prog_file_whole(const char *text, size_t len);
bool kst_prog_file_load(kst_prog_t *p, const char *text, size_t len);
size_t kst_prog_file_text(const kst_prog_t *p, char *out, size_t n);
 
#ifdef __cplusplus
}
#endif