esc_stick_panel_int.h

Go to the documentation of this file.

#pragma once
 
#include <stdbool.h>
#include <stdint.h>
 
#include "esc_profile.h"
#include "esc_stick.h"
#include "settings.h"
#include "ui_keypad.h"
#include "ui_textkey.h"
 
#include "esc_stick_int.h"
 
/* ------------------------------------------------------- the stick class */

#define SP_MAX     (128)
#define SP_ROWS    7                          
#define SP_ROW_Y0  CARD_Y                     
#define SP_ROW_H   UI_TAP_MIN                 
#define SP_ROW_P   56                         
#define SP_ROW_X   (PAD + 12)                 
#define SP_ROW_TY  ((SP_ROW_H - 20) / 2)      
#define SP_QUEUE   8                          
#define SP_NOTE    160                        

#define SP_NAME_CELLS 30    
#define SP_AMPS_X   320     
#define SP_VOLTS_X  384     
#define SP_FAMILY_X 460     
#define SP_WHY_CELLS ((W - 2 * PAD - 24 - 12 - SP_FAMILY_X) / SP_CELL)
#define SP_MAKER_RIGHT_W 370

#define SP_FIND_MAX 16
#define SP_KEY_W    56                        
#define SP_LIST_DN_X (W - PAD - 12 - SP_KEY_W)     
#define SP_LIST_UP_X (SP_LIST_DN_X - 8 - SP_KEY_W) 
#define SP_FIND_W   260                           
#define SP_FIND_X   (SP_LIST_UP_X - 8 - SP_FIND_W) 
#define SP_CLR_W    UI_TAP_MIN                
#define SP_DOCK_X   352                       
#define SP_TRAIL_CELLS ((SP_FIND_X - 8 - (PAD + 12 + BACK_W + 16)) \
                        / SP_CRUMB_CELL)

#define SP_FOOT_Y   (SP_ROW_Y0 + (SP_ROWS - 1) * SP_ROW_P + SP_ROW_H + 4)
#define SP_COUNT_W  360                 
_Static_assert(SP_FOOT_Y + 20 <= SP_FOOT, "the list's footer ends above "
               "the alert band");
/* The most models one maker's list holds: as many as the registry lets a
 * maker have, so the count and the rows always agree. */
#define SP_MODELS   ((int)ESC_MAKER_MODELS_MAX)
 
/* The stack light at the right of the run's card: a cap, the red and the
 * green lens, each with a collar under it, and the base, px. */
#define SP_TOWER_W     44               
#define SP_TOWER_X     (W - PAD - 16 - SP_TOWER_W)  
#define SP_TOWER_Y     (RUN_Y + 14)   
#define SP_TOWER_CAP   8                
#define SP_TOWER_LENS  58               
#define SP_TOWER_RING  3                
#define SP_TOWER_BASE  26               
#define SP_LINE_CELLS  ((SP_TOWER_X - 12 - (PAD + 12)) / SP_CELL)
#define SP_WIDE_CELLS  ((W - 2 * PAD - 24) / SP_CELL)
_Static_assert(SP_TOWER_Y + SP_TOWER_CAP + 2 * (SP_TOWER_LENS + SP_TOWER_RING)
                   + SP_TOWER_BASE + 4 <= RUN_L0 + 6 * LINE_P,
               "a result's lines from its seventh pass under the stack "
               "light");

#define SP_SETTINGS 14
extern const setting_id_t sp_settings_list[SP_SETTINGS];

typedef struct {
    const char *name;                   
    uint16_t models,                        
             found,                         
             runs;                          
    bool        manual;                 
} sp_maker_t;

typedef struct {
    uint16_t prof,                          
             model;                         
} sp_row_t;

typedef struct {
    /* The list in two levels.  Level 0 the makers, alphabetical; level 1
     * the models of one maker, by current, voltage and name.  count,
     * runnable and scroll are the level's showing; bscroll is the makers'
     * kept while a maker is open. */
    int        level;                   
    sp_maker_t makers[SP_MAX];          
    sp_row_t   rows_m[SP_MODELS];
    const char *maker;                  
    int count,                              
        runnable,                           
        scroll,                             
        bscroll;                            
    int        model;                   
 
    /* The profile picked, and what is to change: per item, -1 to keep it,
     * else the index of the value to store. */
    const esc_profile_t *p;             
    int  pick[256];
    int iscroll,                            
        picked;                             
    char note[SP_NOTE];                 
    bool could;                         
 
    /* The warning, and its hold. */
    bool warn,                              
         warn_down;                         
    uint8_t   warn_id;                  
    ui_hold_t hold;                     
 
    bool timing;                        
    int tscroll,                            
        tpicked;                            
    /* TIMING's keypad, the row of sp_settings_list it types, and its
     * revision as the page last followed it. */
    ui_keypad_t kp;             
    int         kp_idx;         
    uint32_t    kp_rev;         
 
    /* The run, and whether its result is still on screen. */
    esc_stick_t run;                    
    bool        shown;                  
    uint32_t    runs;                   
    uint32_t    sig;
    uint32_t    built_key;              
    uint32_t    builds;                 
 
    /* The bench, as the application last said. */
    uint32_t now_ms,                        
             stops,                         
             pressed;                       
    bool armed,                             
         link_up;                           
    /* The output binding, as the application last said: whether one is
     * read, and the channels it binds as a throttle (one bit each). */
    bool     bind_read;                 
    uint8_t  throttle_mask;             
 
    /* The search: the pattern the list shows, what it was when the
     * keyboard opened (CANCEL goes back to it), and the keyboard. */
    char         find[SP_FIND_MAX + 1];  
    char         find_was[SP_FIND_MAX + 1];
    ui_textkey_t tk;                    
    uint32_t     tk_rev;                
    gfx_rect_t find_box,                    
               find_clr;                    
 
    /* The stack light's green, as the last tick had it. */
    esc_stick_light_t light;            
    bool              green;            
 
    /* What the run has asked for, and what is still to be taken. */
    motor_cmd_t q[SP_QUEUE];
    int         qn;                     
    bool sent_arm,                          
         sent_supply;                       
    float       sent_pct;               
 
    /* The manual steps' pop-up and the profile it shows: the page's, or a
     * row's that does not run.  It opens by itself the first time a
     * profile with manual steps is opened, one bit a profile by its index
     * in the registry. */
    bool                 hand_open;     
    const esc_profile_t *hand_p;        
    int                  hand_model;    /* the model it was opened for, or
                                           -1: the family's lowest      */
    bool                 was_running;   
    bool                 warn_read;     
 
    /* The supply as its newest reading had it, run or no run: whether its
     * output is live, and since when it has read off. */
    bool sup_have,                          
         sup_live,                          
         sup_off_known,                     
         sup_gate;                          
    bool                 sup_off_drawn;
    uint32_t sup_at,                        
             sup_off_since;                 
    uint8_t              hand_seen[SP_MAX / 8];
 
    gfx_rect_t rows[SP_ROWS],               
               list_up,                     
               list_dn;                     
    gfx_rect_t hold_btn,                    
               cancel_btn,                  
               hand_btn,                    
               steps_btn,                   
               timing_btn;                  
    gfx_rect_t hand_res;
} stick_t;

typedef struct {
    stick_t  st;                        
 
    /* The phase tap, as the control task last read it. */
    tone_readout_t tone;                
} sp_state_t;

extern sp_state_t esc_stick_s;
#define s esc_stick_s
 
/* --- the functions one file calls of another ---------------------------- */
 
/* esc_stick_panel.c */

size_t sp_changes(esc_stick_change_t *ch, size_t *picked);
void sp_timing(esc_stick_timing_t *t);
void sp_supply(uint32_t *mv, uint32_t *ma);
bool sp_supply_reads_off(void);
bool sp_warn_gated(void);
bool sp_warn_steps_fit(const esc_profile_t *p);
unsigned sp_later_steps(const esc_profile_t *p);
bool sp_hold_blocked(void);
bool sp_can_run(void);
void sp_follow(void);
void sp_end_hold(void);
void sp_end_run(esc_stick_reason_t why);
 
/* esc_stick_list.c */

void sp_text(gfx_canvas_t *c, int x, int y, const char *text, int max_chars,
             gfx_color_t ink);
const char *sp_action(const esc_manual_t *m);
const char *sp_when_text(const esc_manual_t *m);
const char *sp_why_text(const char *why);
const char *sp_rating_why(const esc_profile_t *p, int model, uint32_t mv,
                          uint32_t ma, bool by_hand, bool longer, char *buf,
                          size_t n);
const char *sp_rating_warn(const esc_profile_t *p, int model, uint32_t mv,
                           bool by_hand, bool longer, char *buf, size_t n);
const char *sp_model_warn(const esc_profile_t *p, int model, char *buf,
                          size_t n);
const char *sp_model_why(const esc_profile_t *p, int model, char *buf,
                         size_t n);
uint32_t sp_list_key(void);
bool sp_model_runs(const esc_profile_t *p, int model);
void sp_build_list(bool keep_scroll);
void sp_pick_profile(const esc_profile_t *p);
int sp_items(void);
int sp_item_at(int at);
void sp_pick_shown(void);
 
/* esc_stick_touch.c */

int sp_rows_shown(int total, int scroll);
gfx_rect_t sp_row(int i);
void sp_find_close(void);
void sp_kp_close(void);
 
/* esc_stick_draw.c */

uint32_t sp_entry_shown(void);
 
/* esc_stick_draw_run.c */

bool sp_red(void);
void sp_result_head(const esc_stick_t *e, char *buf, size_t n);
void sp_result_more(const esc_stick_t *e, unsigned shown, char *buf,
                    size_t n);
const char *sp_left_text(const esc_stick_t *e);
void sp_draw_progress(gfx_canvas_t *c);
void sp_draw_result(gfx_canvas_t *c);
void sp_draw_warning(gfx_canvas_t *c);
void sp_draw_hand(gfx_canvas_t *c);
void sp_draw_prompt(gfx_canvas_t *c);