servo_limrun.h

Go to the documentation of this file.

 
#pragma once
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#include "servo_limit.h"
#include "servo_test.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* ---------------------------------------------------------- the method */

#define SERVO_LIMRUN_WRITES_MAX   8u
#define SERVO_LIMRUN_OVERSET_PCT  3u
#define SERVO_LIMRUN_STD_LOWER_DUS 10000u
#define SERVO_LIMRUN_STD_UPPER_DUS 20000u
#define SERVO_LIMRUN_MOVED_US     20u
#define SERVO_LIMRUN_SEARCH_MS    40000u
#define SERVO_LIMRUN_RETURN_MS    1000u
#define SERVO_LIMRUN_PROG_MS      150000u
#define SERVO_LIMRUN_BENCH_MS     3000u
#define SERVO_LIMRUN_HARD_MA      3000
#define SERVO_LIMRUN_STALL_MA     1000
#define SERVO_LIMRUN_STALL_MS     400u
#define SERVO_LIMRUN_WIN_STALE_MS SERVO_TEST_WIN_STALE_MS
#define SERVO_LIMRUN_RAIL_DV_MV   1000
#define SERVO_LIMRUN_RAIL_MIN_MV  3000
 
/* ------------------------------------------------------ what it is told */

enum { SERVO_LIMRUN_LO = 0, SERVO_LIMRUN_HI = 1 };
enum { SERVO_LIMRUN_LEFT = 0, SERVO_LIMRUN_RIGHT = 1 };
enum {
    SERVO_LIMRUN_P_NEUTRAL = 0,
    SERVO_LIMRUN_P_LOWER = 1,
    SERVO_LIMRUN_P_UPPER = 2,
};
 
typedef struct {
    uint16_t centre_us, min_us, max_us;   
    bool     read;
    bool     program;     
    bool     set_pulses;  
 
    /* For the report only. */
    char     dut[24];
    char     type[20];
    uint16_t frame_hz;
    char     output[28];  
    uint16_t shunt_dmohm; 
    char     meter[20];   
    bool     enc_on;      
    char     firmware[16];
    const char *const *text;
} servo_limrun_cfg_t;

typedef struct {
    bool     ok;          
    uint16_t angle[2];    
    uint16_t lo_raw;      
    uint16_t hi_raw;                    
    bool     reversion;   
    unsigned type;        
    uint16_t pulse_dus[3];
    char     backup[16];
} servo_limrun_servo_t;

typedef struct {
    bool  live;           
    bool  safe;           
    bool  enc_valid;      
    float enc_deg;        
} servo_limrun_in_t;

typedef struct {
    bool     command;     
    uint16_t cmd_us;                    
    bool     release;     
    bool     off;         
    bool     disarm;      
    bool     arm;         
    bool     connect;     
    bool     write;       
    uint16_t angle[2];                  
    bool     pulses;      
    uint16_t pulse_dus[2]; 
    bool     leave;       
} servo_limrun_do_t;
 
/* ------------------------------------------------------ what it reports */
 
typedef enum {
    SERVO_LIMRUN_IDLE = 0,
    SERVO_LIMRUN_RUNNING,
    SERVO_LIMRUN_DONE,
} servo_limrun_state_t;
 
typedef enum {
    SERVO_LIMRUN_PH_NONE = 0,
    SERVO_LIMRUN_PH_SEARCH,     
    SERVO_LIMRUN_PH_SAFE,       
    SERVO_LIMRUN_PH_CONNECT,
    SERVO_LIMRUN_PH_WRITE,
    SERVO_LIMRUN_PH_LEAVE,
    SERVO_LIMRUN_PH_ARM,        
    SERVO_LIMRUN_PH_PROBE,      
    SERVO_LIMRUN_PH_CHECK,      
} servo_limrun_phase_t;
 
typedef enum {
    SERVO_LIMRUN_FOUND = 0,     
    SERVO_LIMRUN_FREE,          
    SERVO_LIMRUN_PASS,          
    SERVO_LIMRUN_FAIL,
    SERVO_LIMRUN_ABORTED,
} servo_limrun_verdict_t;

typedef enum {
    SERVO_LIMRUN_WHY_NONE = 0,
    SERVO_LIMRUN_WHY_TEST,          
    SERVO_LIMRUN_WHY_HARD,          
    SERVO_LIMRUN_WHY_CLIPPED,       
    SERVO_LIMRUN_WHY_STALL,         
    SERVO_LIMRUN_WHY_SEARCH_LONG,   
    SERVO_LIMRUN_WHY_SUPPLY_CHANGED,
    SERVO_LIMRUN_WHY_BENCH,         
    SERVO_LIMRUN_WHY_NOT_KST,       
    SERVO_LIMRUN_WHY_PROG,          
    SERVO_LIMRUN_WHY_WRITE,         
    SERVO_LIMRUN_WHY_OTHER_VALUES,  
    SERVO_LIMRUN_WHY_MAPPING,       
    SERVO_LIMRUN_WHY_SMALLEST,      
    SERVO_LIMRUN_WHY_WRITE_CAP,     
    SERVO_LIMRUN_WHY_STILL_BINDS,   
    SERVO_LIMRUN_WHY_NO_VOLTAGE,    
    SERVO_LIMRUN_WHY_NO_STOP,       
    SERVO_LIMRUN_WHY_BEFORE_NEUTRAL,
    SERVO_LIMRUN_WHY_NEUTRAL,       
    SERVO_LIMRUN_WHY_RANGE,         
    SERVO_LIMRUN_WHY_COUNT
} servo_limrun_why_t;

typedef struct {
    bool     done;
    bool     bound;         
    uint16_t limit_us;      
    uint16_t bind_us;       
    uint16_t free_us;       
    float baseline_a,                       
          knee_a;                           
    bool     enc;           
    float    enc_deg;
} servo_limrun_side_t;
 
#define SERVO_LIMRUN_OUTBOX 2u
 
typedef struct {
    servo_limrun_cfg_t   cfg;
    servo_limrun_state_t state;
    servo_limrun_phase_t phase;
    servo_limrun_verdict_t verdict;
    servo_limrun_why_t   why;
    servo_test_abort_t   test_why;
    uint32_t start_ms, end_ms, phase_ms;
    bool     safe_asked;    
 
    /* The search under way: from ctr_us out to end_us of its side. */
    uint16_t ctr_us;
    uint16_t end_us[2];
    servo_limit_t lf;
    uint8_t  side;          
    uint32_t search_ms;     
    uint16_t cmd_us;        
    bool     cmd_due;
    bool     enc_valid;
    float    enc_deg;
 
    servo_limrun_side_t first[2];   
    servo_limrun_side_t after[2];   
    servo_limrun_side_t probe;      
 
    /* The programming. */
    bool     read_once;
    bool     dry;           
    servo_limrun_servo_t servo;     
    uint16_t cur[2];        
    uint16_t pulse_now[3];  
    bool     pulse_op;      
    bool     searched;      
    uint16_t want[2];       
    int8_t   reg_side[2];   
    bool     need[2];       
    bool     mapped;
    uint8_t  map_side;      
    uint8_t  map_reg;       
    uint8_t  map_tries;     
    /* By side. */
    uint8_t  stage[2];      
    uint16_t v0[2];         
    uint16_t v1[2];         
    uint16_t v2[2];         
    int32_t  d0_dus[2];     
    int32_t  db_dus[2];     
    int32_t  d1_dus[2];     
    int8_t   probe_side;    
    unsigned writes;        
    unsigned write_ops;     
    unsigned sessions;
    bool     pulses_landed; 
    bool     programmed;    
 
    /* The meter. */
    bool     have_win;
    uint32_t last_win_ms;
    uint32_t windows;
    bool     have_rail;
    uint16_t rail_mv;
    bool     elevated;
    uint32_t elevated_ms;
 
    /* The supply as at its first reading, when one answered. */
    bool     sup_watch;
    bool     sup_online;    
    bool     sup_out;       
 
    float    sup_v, sup_i;
 
    /* The outbox: OPEN_TXT, the report's lines, END. */
    unsigned out_line;      
    bool     out_open, out_end, out_done;
    char     scratch[SERVO_TEST_LINE_MAX];
 
    servo_limrun_do_t pend;
} servo_limrun_t;

void servo_limrun_init(servo_limrun_t *r);

bool servo_limrun_start(servo_limrun_t *r, const servo_limrun_cfg_t *cfg,
                        uint32_t now_ms);

void servo_limrun_window(servo_limrun_t *r, const servo_test_win_t *w);

void servo_limrun_supply(servo_limrun_t *r, const servo_test_reading_t *s,
                         uint32_t now_ms);

void servo_limrun_connected(servo_limrun_t *r, const servo_limrun_servo_t *sv,
                       uint32_t now_ms);
void servo_limrun_written(servo_limrun_t *r, bool ok, const uint16_t *angle,
                          uint32_t now_ms);
void servo_limrun_pulsed(servo_limrun_t *r, bool ok,
                         const uint16_t *pulse_dus, uint32_t now_ms);
void servo_limrun_left(servo_limrun_t *r, bool ok, uint32_t now_ms);

void servo_limrun_supply_refused(servo_limrun_t *r, bool output_on,
                                 uint32_t now_ms);

void servo_limrun_backup(servo_limrun_t *r, const char *name);

void servo_limrun_refused(servo_limrun_t *r, uint32_t now_ms);

void servo_limrun_no_servo(servo_limrun_t *r, uint32_t now_ms);

void servo_limrun_step(servo_limrun_t *r, uint32_t now_ms,
                       const servo_limrun_in_t *in, servo_limrun_do_t *out);

void servo_limrun_abort(servo_limrun_t *r, servo_test_abort_t why,
                        uint32_t now_ms);

bool servo_limrun_running(const servo_limrun_t *r);
bool servo_limrun_switching(const servo_limrun_t *r);
bool servo_limrun_programming(const servo_limrun_t *r);
bool servo_limrun_wrote(const servo_limrun_t *r);
bool servo_limrun_restore(const servo_limrun_t *r);
bool servo_limrun_original(const servo_limrun_t *r, uint16_t *left,
                           uint16_t *right);

servo_test_out_t servo_limrun_peek(servo_limrun_t *r, const char **text);
void servo_limrun_pop(servo_limrun_t *r);
bool servo_limrun_drained(const servo_limrun_t *r);

bool servo_limrun_report_line(const servo_limrun_t *r, unsigned idx,
                              char *buf, size_t n);

servo_str_t servo_limrun_verdict_str(servo_limrun_verdict_t v);
servo_str_t servo_limrun_why_str(const servo_limrun_t *r);
servo_str_t servo_limrun_phase_str(servo_limrun_phase_t ph);

int32_t servo_limrun_dist(const servo_limrun_servo_t *sv, uint8_t side,
                          uint16_t p_us);
int32_t servo_limrun_span(const servo_limrun_servo_t *sv, uint8_t side);
uint16_t servo_limrun_overset(uint16_t v0, int32_t d, int32_t span,
                              uint16_t lo_raw);
uint16_t servo_limrun_scaled(uint16_t v, int32_t d, int32_t span,
                             uint16_t lo_raw);
 
#ifdef __cplusplus
}
#endif