servo_test.h

Go to the documentation of this file.

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

#define SERVO_TEST_STEPS_MAX         4u
#define SERVO_TEST_HV_ABOVE_V        6.0f

#define SERVO_TEST_BROWNOUT_START_V  5.0f
#define SERVO_TEST_BROWNOUT_STEP_V   0.2f
#define SERVO_TEST_BROWNOUT_FLOOR_V  3.0f
#define SERVO_TEST_BROWNOUT_MAX      11u
#define SERVO_TEST_BROWNOUT_MOVES    2u

#define SERVO_TEST_MOVE_MIN_A        SERVO_MOVE_MIN_A
#define SERVO_TEST_NOISE_K           SERVO_MOVE_NOISE_K
#define SERVO_TEST_BAND_A            SERVO_MOVE_BAND_A
 
#define SERVO_TEST_IDLE_MS           1000u
#define SERVO_TEST_HOLD_MIN_MS       600u
#define SERVO_TEST_TRAVEL_TIMEOUT_MS SERVO_MOVE_TIMEOUT_MS
#define SERVO_TEST_SET_TOL_V         0.05f
#define SERVO_TEST_SET_TIMEOUT_MS    3000u
#define SERVO_TEST_STALE_MS          1500u
#define SERVO_TEST_STALL_ABORT_MS    1000u
#define SERVO_TEST_CC_ABORT_MS       1000u
#define SERVO_TEST_WIN_STALE_MS      200u
#define SERVO_TEST_WIN_MS            50u
#define SERVO_TEST_NEG_IDLE_A        0.020f
#define SERVO_TEST_INA3221_END_UV    163800u
#define SERVO_TEST_MOVES_MAX         1000u
 
/* The output encoder's constants.  The tolerance is the IOmcu's
 * SENSE_ENC_STILL_TOL, test_as5600 holds the two equal. */
#define SERVO_TEST_ENC_TOL_COUNTS    12u
#define SERVO_TEST_ENC_TOL_DEG       1.0547f
#define SERVO_TEST_ENC_HOLD_MS       100u
#define SERVO_TEST_ENC_MOVED_DEG     2.0f
#define SERVO_TEST_ENC_STALE_MS      500u
 
/* ------------------------------------------------------ what it is told */

typedef enum {
    SERVO_TEST_METER_PDMINI = 0,    
    SERVO_TEST_METER_INA3221,       
    SERVO_TEST_METER_MODEL,         
} servo_test_meter_kind_t;

typedef enum {
    SERVO_TEST_INA_NONE = 0,    
    SERVO_TEST_INA_OLD,         
    SERVO_TEST_INA_NOT_HELD,    
    SERVO_TEST_INA_SILENT,      
    SERVO_TEST_INA_NO_WINDOW,   
    SERVO_TEST_INA_RESET,       
    SERVO_TEST_INA_SETTLING,    
    SERVO_TEST_INA_MODEL,       
    SERVO_TEST_INA_COUNT
} servo_test_ina_t;

typedef struct {
    uint8_t  kind;          
    uint16_t span_ms;       
    uint16_t shunt_dmohm;   
    uint16_t range_ma;      
    char     name[20];
    uint16_t lag_ms;        
    bool     repeats;       
    bool     upper_bound;   
} servo_test_meter_t;

#define SERVO_TEST_PDMINI_LAG_MS     300u

void servo_test_meter_pdmini(servo_test_meter_t *m);

void servo_test_meter_model(servo_test_meter_t *m);

void servo_test_meter_ina3221(servo_test_meter_t *m, uint16_t shunt_dmohm);

bool servo_test_over_a(float a, float limit_a);

typedef struct {
    /* What runs. */
    float    steps_v[SERVO_TEST_STEPS_MAX];
    uint8_t  step_count;
    bool     brownout;
    float    i_limit;       
 
    /* The servo: its centre and the two ends the moves go between. */
    uint16_t centre_us, end_lo_us, end_hi_us;
 
    /* The TEST page. */
    uint16_t settle_ms, dwell_ms;
    bool     by_moves;      
    uint16_t moves;
    uint16_t time_s;

    float idle_max_a,                       
          hold_max_a;                       
    uint16_t travel_max_ms;             
    float    stall_a;
 
    bool     report;        
 
    /* The output encoder: off leaves the run, the CSV and the report as
     * they are without one. */
    bool     enc_on;
    uint16_t enc_centre;    
    float    enc_cmd_deg[2];
 
    /* For the report only: the settings in force. */
    char     dut[24];
    char     type[20];
    char     danger[40];    
    bool     hv;            
    uint16_t min_us, max_us, frame_hz;
    int16_t  trim_us;
    bool     reverse;
    uint8_t  travel_deg, range_pct;
    bool     model;         
    servo_test_meter_t meter;
    uint32_t meter_changes; 
    uint8_t  ina_why;       
    char     firmware[16];
    const char *const *text;
} servo_test_cfg_t;
 
/* ------------------------------------------------------ what it reports */
 
typedef enum {
    SERVO_TEST_IDLE = 0,    
    SERVO_TEST_RUNNING,
    SERVO_TEST_DONE,        
} servo_test_state_t;
 
typedef enum {
    SERVO_TEST_PH_NONE = 0,
    SERVO_TEST_PH_SET,
    SERVO_TEST_PH_SETTLE,
    SERVO_TEST_PH_IDLE,
    SERVO_TEST_PH_MOVE,
    SERVO_TEST_PH_HOLD,
} servo_test_phase_t;
 
typedef enum {
    SERVO_TEST_AB_NONE = 0,
    SERVO_TEST_AB_STOP,
    SERVO_TEST_AB_DISARMED,
    SERVO_TEST_AB_LINK,
    SERVO_TEST_AB_LEFT,
    SERVO_TEST_AB_OPERATOR,
    SERVO_TEST_AB_SETTINGS,
    SERVO_TEST_AB_TOUCH,
    SERVO_TEST_AB_SUPPLY_LOST,
    SERVO_TEST_AB_TRIPPED,
    SERVO_TEST_AB_SUPPLY_OFF,
    SERVO_TEST_AB_STALE,
    SERVO_TEST_AB_NOT_ON,
    SERVO_TEST_AB_SET_NOT_TAKEN,
    SERVO_TEST_AB_CAP,
    SERVO_TEST_AB_STALL,
    SERVO_TEST_AB_CC,           
    /* A run on the INA3221. */
    SERVO_TEST_AB_WIN_STALE,    
    SERVO_TEST_AB_INA_RESET,    
    SERVO_TEST_AB_INA_SILENT,   
    SERVO_TEST_AB_INA_NO_WINDOW,
    SERVO_TEST_AB_INA_SETUP,    
    SERVO_TEST_AB_INA_METER,    
    SERVO_TEST_AB_COUNT
} servo_test_abort_t;
 
typedef enum {
    SERVO_TEST_PASS = 0,
    SERVO_TEST_FAIL,
    SERVO_TEST_ABORTED,
    SERVO_TEST_NOT_MEASURABLE,
} servo_test_verdict_t;

typedef enum {
    SERVO_TEST_START_OK = 0,
    SERVO_TEST_START_NO_STEPS,   
    SERVO_TEST_START_ABOVE_CAP,  
    SERVO_TEST_START_NO_SUPPLY,  
    SERVO_TEST_START_BAD_ENDS,   
} servo_test_start_t;

typedef struct {
    float    sum;
    uint32_t n;
} servo_test_mean_t;

typedef struct {
    float    set_v;
    bool     brownout;
    bool     begun;         
    bool     done;          
    servo_test_mean_t v;    
    float    v_min;         
    servo_test_mean_t idle;             
    float    idle_sq;       
    float    noise_a;       
    float    move_a;        
    servo_test_mean_t move; 
    servo_test_mean_t hold[2];   
    float    move_peak_a;   
    float    peak_a;        
    uint32_t travel_max_ms; 
    uint32_t travel_sum_ms; 
    uint16_t travels;       
    uint16_t moves;         
    uint16_t no_rise;       
    uint16_t timeouts;      
    bool     moved;         
 
    /* The angle, with the encoder on. */
    uint16_t enc_moves;     
    uint16_t enc_travels;   
    uint16_t enc_unmoved;   
    uint16_t enc_late;      
    uint32_t enc_travel_sum_ms, enc_travel_max_ms;
    /* The settled end angles at the low and the high end: the count of
     * the first, and every one's offset from it in degrees, the shortest
     * way round.  servo_test_enc_end() gives the mean. */
    uint16_t enc_end_ref[2];
    servo_test_mean_t enc_end_off[2];
} servo_test_step_t;
 
#define SERVO_TEST_STEP_SLOTS (SERVO_TEST_STEPS_MAX + SERVO_TEST_BROWNOUT_MAX)
 
/* --------------------------------------------------------- the outbox */

#define SERVO_TEST_OUTBOX   16u
 
typedef struct {
    servo_test_cfg_t   cfg;
    servo_test_state_t state;
    servo_test_phase_t phase;
    servo_test_abort_t why;
    uint32_t start_ms, end_ms;
    uint32_t phase_ms;      
    float    v_max;         
    float    floor_v;       
    float    bo_start_v;                
 
    servo_test_step_t steps[SERVO_TEST_STEP_SLOTS];
    uint8_t  step;          
    uint8_t  step_count;    
    bool     on_seen;       
 
    /* The servo. */
    uint16_t cmd_us;
    uint8_t  end;           
    uint32_t cmd_ms;
    bool     counted;       
    servo_move_t move;      
    float    hold_ref[2];
    bool     hold_known[2];
    uint32_t hold_from_ms;
    servo_test_mean_t hold_now;
    uint32_t moves_from_ms;
    uint16_t moves_done;
    uint8_t  placed;        
    uint32_t travel_now_ms; 
 
    /* The encoder. */
    /* The last SERVO_TEST_ENC_HIST readings, oldest overwritten, each with
     * the time it was taken: a log row takes the newest not later than
     * itself (servo_test_enc_at()). */
    servo_test_enc_sample_t enc_hist[SERVO_TEST_ENC_HIST];
    uint8_t  enc_hist_n, enc_hist_next;
    uint32_t enc_reads;     
    uint32_t enc_no_magnet; 
    uint32_t enc_weak;      
    uint32_t enc_strong;    
    bool     enc_open;      
    bool     enc_counted;
    bool     enc_ok;        
    uint8_t  enc_end;
    uint32_t enc_cmd_ms;
    uint16_t enc_start_raw; 
    uint16_t enc_last_raw;  
    bool     enc_moved, enc_settled;
    uint32_t enc_travel_ms;
    uint32_t enc_travel_now_ms;     
    uint32_t enc_travel_at_ms;      
 
    /* The meter's readings: the supply's, or the INA3221's windows. */
    bool     have_reading;
    uint16_t samples;
    uint32_t first_ms, last_ms;   
    uint32_t readings;      
    uint32_t module_samples;
    uint32_t skipped;       
    uint32_t clipped;       
    bool     stalling;
    uint32_t stall_since_ms;
    bool     stalled;       
    float    stall_peak_a;  
    float    move_peak_now; 
 
    /* The supply's state, on either meter. */
    bool     sup_have;      
    uint16_t sup_samples;
    uint32_t sup_ms;        
    uint8_t  sup_mode;      
    bool     cc_on;         
    uint32_t cc_since_ms;
    uint32_t cc_readings;   
    uint32_t cc_longest_ms; 
 
    /* The outbox. */
    char     box[SERVO_TEST_OUTBOX][SERVO_TEST_LINE_MAX];
    uint8_t  box_kind[SERVO_TEST_OUTBOX];
    uint8_t  box_head, box_n;
    uint32_t rows, rows_lost;
    unsigned report_line;
    bool     ended;         
    char     scratch[SERVO_TEST_LINE_MAX];
 
    servo_test_do_t pend;
} servo_test_t;

void servo_test_init(servo_test_t *t);

servo_test_start_t servo_test_start(servo_test_t *t,
                                    const servo_test_cfg_t *cfg,
                                    uint32_t now_ms,
                                    const servo_test_reading_t *last,
                                    float v_min, float v_max);

void servo_test_reading(servo_test_t *t, const servo_test_reading_t *r,
                        uint16_t position_us);

void servo_test_window(servo_test_t *t, const servo_test_win_t *w,
                       uint16_t position_us);

typedef struct {
    bool     ina3221;       
    uint32_t changes;       
    servo_test_abort_t dropped;
    uint32_t dropped_at;
} servo_test_meter_now_t;

void servo_test_meter_now(servo_test_t *t, const servo_test_meter_now_t *m,
                          uint32_t now_ms);

void servo_test_encoder(servo_test_t *t, const servo_test_enc_t *e);

bool servo_test_enc_at(const servo_test_t *t, uint32_t at_ms, float *deg);

bool servo_test_enc_end(const servo_test_t *t, const servo_test_step_t *s,
                        unsigned end, float *deg, float *err);

void servo_test_step(servo_test_t *t, uint32_t now_ms,
                     const servo_test_in_t *in, servo_test_do_t *out);

void servo_test_abort(servo_test_t *t, servo_test_abort_t why,
                      uint32_t now_ms);

bool servo_test_running(const servo_test_t *t);

uint32_t servo_test_travel_window_ms(const servo_test_t *t);

servo_test_verdict_t servo_test_verdict(const servo_test_t *t);

unsigned servo_test_steps_planned(const servo_test_t *t);
unsigned servo_test_step_now(const servo_test_t *t);

bool servo_test_max_idle(const servo_test_t *t, float *a);
bool servo_test_max_hold(const servo_test_t *t, float *a);
bool servo_test_max_travel(const servo_test_t *t, uint32_t *ms);
bool servo_test_brownout(const servo_test_t *t, float *moved_v,
                         bool *stopped);

bool servo_test_negative_at_rest(const servo_test_t *t);

bool servo_test_stall_unreachable(const servo_test_cfg_t *cfg,
                                  bool *by_limit, bool *by_range);

bool servo_test_rates(const servo_test_t *t, float *per_s,
                      float *module_per_s, uint32_t *interval_ms);

servo_test_out_t servo_test_peek(servo_test_t *t, const char **text);

void servo_test_pop(servo_test_t *t);

bool servo_test_drained(const servo_test_t *t);
 
/* ------------------------------------------------------ words (servo_str.c) */

servo_str_t servo_test_phase_str(servo_test_phase_t ph);
servo_str_t servo_test_abort_str(servo_test_abort_t why);
servo_str_t servo_test_verdict_str(servo_test_verdict_t v);

const char *servo_test_phase_name(servo_test_phase_t ph);
const char *servo_test_abort_name(servo_test_abort_t why);
const char *servo_test_verdict_name(servo_test_verdict_t v);
const char *servo_test_start_name(servo_test_start_t why);

const char *servo_test_csv_header(void);
const char *servo_test_csv_header_enc(void);

const char *servo_test_meter_word(uint8_t kind);
 
/* ------------------------------------------------- report (servo_report.c) */

bool servo_test_stall_note(const servo_test_cfg_t *cfg, char *buf, size_t n);

bool servo_report_line(const servo_test_t *t, unsigned idx, char *buf,
                       size_t n);
 
#ifdef __cplusplus
}
#endif