esc_stick.h

Go to the documentation of this file.

 
#ifndef RCBENCH_ESC_STICK_H
#define RCBENCH_ESC_STICK_H
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#include "esc_profile.h"
 
#ifdef __cplusplus
extern "C" {
#endif

#define ESC_STICK_MAX_CHANGES 16u

#define ESC_STICK_SIGNAL_MS 1000u
#define ESC_STICK_ARM_WAIT_MS   3000u
#define ESC_STICK_POWER_WAIT_MS 3000u
#define ESC_STICK_STALE_MS 1000u
#define ESC_STICK_SETTLE_MS 500u
#define ESC_STICK_LATE_RUN 3u
#define ESC_STICK_HAND_WAIT_MS 60000u
#define ESC_STICK_HAND_MIN_MS 1000u
#define ESC_STICK_OFF_MA        20
#define ESC_STICK_OFF_SETTLE_MS 200u

#define ESC_STICK_PCT_MIN 0.0f
#define ESC_STICK_PCT_MID 50.0f
#define ESC_STICK_PCT_MAX 100.0f

typedef struct {
    uint32_t beep_min_ms;    
    uint32_t gap_min_ms;     
    uint32_t long_ms;        
    uint32_t long_max_ms;    
    uint32_t group_gap_ms;   
    uint32_t entry_ms;       
    uint32_t store_ms;       
    uint32_t off_ms;         
    uint32_t silence_ms;     
    uint32_t timeout_ms;     
    uint32_t threshold_ma;   
    uint32_t hysteresis_ma;  
} esc_stick_timing_t;

void esc_stick_timing_defaults(esc_stick_timing_t *t);

uint32_t esc_stick_read_max_ms(const esc_stick_timing_t *t);
 
/* ------------------------------------------------------- what can run */

typedef enum {
    ESC_STICK_KIND_NONE = 0,  
    ESC_STICK_KIND_TWO_STAGE, 
    ESC_STICK_KIND_ONE_STAGE, 
} esc_stick_kind_t;

esc_stick_kind_t esc_stick_kind(const esc_profile_t *p, const char **why);

esc_throttle_t esc_stick_listen(const esc_profile_t *p);

float esc_stick_pct(esc_throttle_t pos);

uint32_t esc_stick_profile_mv(const esc_profile_t *p);

uint32_t esc_stick_model_mv(const esc_profile_t *p, int model);

uint32_t esc_stick_model_v_max(const esc_profile_t *p, int model);

uint32_t esc_stick_model_ma_max(const esc_profile_t *p, int model);

uint32_t esc_stick_model_v_min(const esc_profile_t *p, int model);

typedef enum {
    ESC_STICK_RATING_OK = 0,
    ESC_STICK_RATING_V_OVER,     
    ESC_STICK_RATING_V_UNDER,    
    ESC_STICK_RATING_I_OVER,     
} esc_stick_rating_t;

esc_stick_rating_t esc_stick_rating(const esc_profile_t *p, int model,
                                    uint32_t mv, uint32_t ma, bool by_hand);

bool esc_stick_rating_unknown(const esc_profile_t *p, int model, uint32_t mv,
                              bool by_hand);

bool esc_stick_is_action(const esc_item_t *it);

const char *esc_stick_not_offered(const esc_item_t *it);

typedef struct {
    uint8_t item;    
    uint8_t value;   
} esc_stick_change_t;

esc_throttle_t esc_stick_change_entry(const esc_profile_t *p,
                                      const esc_stick_change_t *c);

bool esc_stick_check(const esc_profile_t *p, const esc_stick_change_t *ch,
                     size_t n, const esc_stick_timing_t *t, const char **why);
 
/* ---------------------------------------------------------- the beeps */

typedef enum {
    ESC_DET_NONE = 0,
    ESC_DET_PULSE,     
    ESC_DET_GROUP,     
    ESC_DET_STUCK,     
} esc_det_event_t;

typedef struct {
    esc_stick_timing_t t;
    uint8_t  long_equals_short;  
 
    bool     counting;           
    bool     seeded;                    
    int32_t  floor_x16;          
    bool     have_prev;                 
    uint32_t prev_ms;                   
    uint32_t iv_max_ms;          
 
    bool     high;
    uint32_t rise_ms, last_high_ms, before_rise_ms;
    uint32_t n_high;
    bool     stuck_told;
    bool     wait_quiet;         
    bool     quiet_known;               
    uint32_t quiet_from;         
    bool     busy;               
    uint32_t busy_from;                 
    bool     fell;               
    uint32_t fall_ms;            
    uint32_t n_low;                     
 
    bool     group_open, group_bad;
    uint8_t  shorts, longs;
 
    /* The last group that ended. */
    uint8_t  count;
    bool     valid;
} esc_det_t;

void esc_det_init(esc_det_t *d, const esc_stick_timing_t *t,
                  uint8_t long_equals_short);

void esc_det_count(esc_det_t *d);

esc_det_event_t esc_det_reading(esc_det_t *d, uint32_t t_ms, int32_t ma,
                                bool late);

int32_t esc_det_floor_ma(const esc_det_t *d);
 
/* ------------------------------------------------------------ the run */

typedef enum {
    ESC_STICK_IDLE = 0,
    ESC_STICK_ARMING,     
    ESC_STICK_SIGNAL,     
    ESC_STICK_POWER,      
    ESC_STICK_ENTRY,      
    ESC_STICK_ITEMS,      
    ESC_STICK_VALUES,     
    ESC_STICK_STORE,      
    ESC_STICK_CYCLE,      
    ESC_STICK_HAND_OFF,   
    ESC_STICK_HAND_ON,    
    ESC_STICK_HAND_END,   
    ESC_STICK_OFF,        
    ESC_STICK_DONE,
    ESC_STICK_ABORTED,
} esc_stick_phase_t;

typedef enum {
    ESC_STICK_R_NONE = 0,
    ESC_STICK_R_STOP,         
    ESC_STICK_R_BENCH_STOP,   
    ESC_STICK_R_DISARMED,     
    ESC_STICK_R_LINK,         
    ESC_STICK_R_SUPPLY_OFF,   
    ESC_STICK_R_SUPPLY_LOST,  
    ESC_STICK_R_STALE,        
    ESC_STICK_R_RATE,         
    ESC_STICK_R_NOT_ARMED,    
    ESC_STICK_R_NO_POWER,     
    ESC_STICK_R_SUPPLY_ON,    
    ESC_STICK_R_NO_BEEPS,     
    ESC_STICK_R_HIGH,         
    ESC_STICK_R_TIMEOUT,      
    ESC_STICK_R_HAND,         
    ESC_STICK_R_TOUCH,        
    ESC_STICK_R_USER,         
    ESC_STICK_R_LEFT,         
} esc_stick_reason_t;

const char *esc_stick_reason_text(esc_stick_reason_t r);

esc_stick_reason_t esc_stick_stop_reason(uint32_t stops, uint32_t pressed);

bool esc_stick_reason_is_fault(esc_stick_reason_t r);

const char *esc_stick_phase_text(esc_stick_phase_t ph);

typedef struct {
    uint32_t now_ms;         
    bool     armed;          
    uint32_t stops;          
    bool     link_up;        
    uint32_t pressed;        
} esc_stick_bench_t;

typedef struct {
    uint32_t seq;
    uint32_t at_ms;          
    int32_t  ma;             
    bool     current_ok;     
    bool     output;         
    bool     reported_on;    
    bool     online;         
} esc_stick_sample_t;

typedef struct {
    bool     arm;            
    float    throttle_pct;   
    bool     supply_on;      
    uint32_t supply_mv;      
    uint32_t supply_ma;      
} esc_stick_out_t;

typedef struct {
    const esc_profile_t *p;
    esc_stick_kind_t     kind;
    esc_stick_timing_t   t;
    esc_stick_change_t   ch[ESC_STICK_MAX_CHANGES];
    uint8_t              n;
    bool                 done[ESC_STICK_MAX_CHANGES];
    uint8_t              active;        
 
    esc_stick_phase_t    phase;
    esc_stick_reason_t   reason;
    uint32_t             phase_ms;      
    uint32_t             now_ms;        
 
    uint32_t             stops0;
    uint32_t             pressed0;
    bool                 link0;
    bool                 link_seen;     
    bool                 off_seen;      
    bool                 reported_on;   
    uint32_t             off_asked_ms;  
    uint32_t             off_seq;       
    uint32_t             off_since_ms;  
    bool                 off_since_known;  
    uint8_t              store_step;    
    bool                 cycle_moved;   
    bool                 sig_moved;     
    bool                 armed_seen;    
 
    esc_stick_out_t      out;
 
    /* The supply as the newest sample had it. */
    bool                 have_sample;
    uint32_t             seq;
    uint32_t             read_ms;       
    bool                 have_reading;  
    bool                 output;
    bool                 online;
    bool                 current_ok;
    int32_t              ma;
    uint32_t             on_ms;         
    uint32_t             late_run;
    uint32_t             iv_ms;         
 
    esc_det_t            det;
    uint32_t             heard_ms;      
    /* The groups of this phase, for the sequence check. */
    uint8_t              prev;          
    bool                 prev_trusted;  
    uint8_t              run;           
    uint8_t              lo, hi;        
    uint32_t             groups;        
    uint8_t              last_count;
    bool                 last_valid;
    bool                 last_in_order; 
    bool                 last_trusted;  
    uint8_t              entries;       
    esc_throttle_t       entry;         
    uint32_t             entry_wait;    
    uint8_t              hand;          
    bool                 hand_done;     
    bool                 hand_menu;     
    uint32_t             hand_ms;       
    bool                 end_open;      
    uint32_t             pulses;        
} esc_stick_t;

bool esc_stick_start(esc_stick_t *e, const esc_profile_t *p,
                     const esc_stick_change_t *ch, size_t n,
                     const esc_stick_timing_t *t, uint32_t mv, uint32_t ma,
                     const esc_stick_bench_t *b, const char **why);

void esc_stick_sample(esc_stick_t *e, const esc_stick_sample_t *s);

void esc_stick_step(esc_stick_t *e, const esc_stick_bench_t *b);

void esc_stick_abort(esc_stick_t *e, esc_stick_reason_t why);

bool esc_stick_running(const esc_stick_t *e);

const esc_stick_out_t *esc_stick_out(const esc_stick_t *e);

const esc_manual_t *esc_stick_hand(const esc_stick_t *e);

uint32_t esc_stick_change_entry_ms(const esc_profile_t *p,
                                   const esc_stick_change_t *c,
                                   const esc_stick_timing_t *t);

uint32_t esc_stick_entry_ms(const esc_stick_t *e);

bool esc_stick_cut_short(const esc_stick_t *e);

bool esc_stick_end_locks(const esc_stick_t *e);

bool esc_stick_lock_risk(const esc_stick_t *e);

bool esc_stick_hand_ready(const esc_stick_t *e);

uint32_t esc_stick_hand_left_ms(const esc_stick_t *e);

bool esc_stick_confirm(esc_stick_t *e);

esc_throttle_t esc_stick_store_move(const esc_stick_t *e, unsigned k);

unsigned esc_stick_done_count(const esc_stick_t *e);

bool esc_stick_unsure(const esc_stick_t *e, unsigned i);

unsigned esc_stick_made_count(const esc_stick_t *e);

unsigned esc_stick_beeps(const esc_stick_t *e);

#define ESC_STICK_BEEP_LIGHT_MS 150u

typedef struct {
    uint32_t pulses;    
    uint32_t from_ms;   
    bool     held;      
} esc_stick_light_t;

void esc_stick_light_reset(esc_stick_light_t *l, const esc_stick_t *e);

bool esc_stick_light_green(esc_stick_light_t *l, const esc_stick_t *e,
                           uint32_t now_ms);
 
#ifdef __cplusplus
}
#endif
 
#endif /* RCBENCH_ESC_STICK_H */