settings.h

Go to the documentation of this file.

 
#pragma once
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef enum {
    SET_CAT_APP = 0,     
    SET_CAT_IFACE,       
    SET_CAT_CARD,        
    SET_CAT_SENSORS,     
    SET_CAT_ESC,         
    SET_CAT_SUPPLY,      
    SET_CAT_SERVO,       
    SET_CAT_STICK,       
    SET_CAT_UPDATE,      
    SET_CAT_COUNT
} setting_cat_t;

#define SET_CAT_SETUP_COUNT SET_CAT_ESC
 
typedef enum {
    SET_TYPE_INT = 0,
    SET_TYPE_FLOAT,
    SET_TYPE_BOOL,
    SET_TYPE_ENUM,
} setting_type_t;

#define SET_INA_PARTS    4   
#define SET_INA_CHANNELS 12  
#define SET_INA_CH_ROWS  3   

typedef enum {
    /* --- pack, motor, telemetry, output ------------------------------- */
    SET_PACK_CELLS = 0,
    SET_PACK_MAH,
    SET_PACK_MOHM,
    SET_MOTOR_POLES,
    SET_MOTOR_KV,
    SET_OUT_MIN_US,
    SET_OUT_MAX_US,
    SET_OUT_RAMP,
    /* --- application --------------------------------------------------- */
    SET_THEME,
    SET_BRIGHTNESS,
    SET_CONTRAST,
    SET_SCREEN_ROT,
    SET_LANGUAGE,
    SET_UNITS,
    SET_TIME_ZONE,
    SET_DIM_AFTER,
    SET_PLOT_PAN,
    SET_KNOB_EN,
    SET_KNOB_SCALE,
    /* --- interfaces ---------------------------------------------------- */
    SET_INA228_EN,
    SET_INA228_ADDR,
    SET_INA228_UOHM,
    SET_INA228_MAX_A,
    /* The one INA3221 of 0.21: in no category and on no screen, loaded
     * and saved as stored, and read once to seed SENSORS
     * (settings_sensors.h). */
    SET_INA3221_EN,
    SET_INA3221_ADDR,
    SET_INA3221_MOHM,
    SET_INA3221_CH,
    SET_SENSE_SDA,
    SET_SENSE_SCL,
    SET_ENC_EN,
    SET_ENC_CENTRE,
    SET_TONE_EN,
    SET_TONE_PIN,
    SET_TONE_F_MIN,
    SET_TONE_F_MAX,
    SET_TONE_SPLIT,
    SET_TONE_GAP,
    SET_TONE_PERIODS,
    SET_VIBE_EN,
    SET_OPTICAL_EN,
    SET_OPTICAL_PIN,
    SET_PDMINI_EN,
    SET_PDMINI_TX,
    SET_PDMINI_RX,
    SET_PDMINI_BAUD,
    /* --- the programming port ------------------------------------------ */
    SET_HITEC_RX,
    /* --- the INA3221 parts, on SETUP > SENSORS (settings_sensors.h) ----- */
    /* Part a's FITTED, then channel by channel (part a's CHn) WATCHES,
     * SHUNT and LIMIT, SET_INA_W_<a><n> for part a's CHn:
     * settings_sensors.h names them by channel number. */
    SET_INA_FIT_0, SET_INA_FIT_1, SET_INA_FIT_2, SET_INA_FIT_3,
    SET_INA_W_01, SET_INA_SH_01, SET_INA_LIM_01,
    SET_INA_W_02, SET_INA_SH_02, SET_INA_LIM_02,
    SET_INA_W_03, SET_INA_SH_03, SET_INA_LIM_03,
    SET_INA_W_11, SET_INA_SH_11, SET_INA_LIM_11,
    SET_INA_W_12, SET_INA_SH_12, SET_INA_LIM_12,
    SET_INA_W_13, SET_INA_SH_13, SET_INA_LIM_13,
    SET_INA_W_21, SET_INA_SH_21, SET_INA_LIM_21,
    SET_INA_W_22, SET_INA_SH_22, SET_INA_LIM_22,
    SET_INA_W_23, SET_INA_SH_23, SET_INA_LIM_23,
    SET_INA_W_31, SET_INA_SH_31, SET_INA_LIM_31,
    SET_INA_W_32, SET_INA_SH_32, SET_INA_LIM_32,
    SET_INA_W_33, SET_INA_SH_33, SET_INA_LIM_33,
    SET_INA_FIT_LAST = SET_INA_FIT_3,
    SET_INA_CH_0     = SET_INA_W_01,       
    SET_INA_CH_LAST  = SET_INA_LIM_33,
    /* --- the programmable supply --------------------------------------- */
    SET_SUPPLY_V_MAX,
    SET_SUPPLY_I_MAX,
    SET_SUPPLY_V_START,
    SET_SUPPLY_I_START,
    SET_SUPPLY_TRIP_I,
    SET_SUPPLY_TRIP_V,
    SET_SUPPLY_TRIP_MS,
    SET_SUPPLY_CONFIRM_SLIDE,
    SET_SUPPLY_CONFIRM_KEYS,
    /* --- the servo test ------------------------------------------------- */
    SET_SERVO_CURVE,
    SET_SERVO_TEST_HZ,
    SET_SERVO_TEST_RANGE,
    SET_SERVO_LEN_BY,
    SET_SERVO_LEN_S,
    SET_SERVO_LEN_MOVES,
    SET_SERVO_DWELL_MS,
    SET_SERVO_SETTLE_MS,
    SET_SERVO_STEP_48,
    SET_SERVO_STEP_60,
    SET_SERVO_STEP_74,
    SET_SERVO_STEP_84,
    SET_SERVO_BROWNOUT,
    SET_SERVO_IDLE_MAX,
    SET_SERVO_HOLD_MAX,
    SET_SERVO_TRAVEL_MAX_MS,
    SET_SERVO_STALL_A,
    SET_SERVO_REPORT,
    SET_SERVO_PROG_V,
    SET_SERVO_PROG_I,
    SET_SERVO_PROG_WAIT,
    SET_SERVO_TARGET,
    SET_SERVO_PORT_PWM,
    SET_HITEC_SERIES,
    /* --- stick programming ---------------------------------------------- */
    SET_STICK_V,
    SET_STICK_I,
    SET_STICK_BEEP_MIN,
    SET_STICK_GAP_MIN,
    SET_STICK_LONG,
    SET_STICK_LONG_MAX,
    SET_STICK_GROUP_GAP,
    SET_STICK_ENTRY,
    SET_STICK_STORE,
    SET_STICK_OFF,
    SET_STICK_SILENCE,
    SET_STICK_TIMEOUT,
    SET_STICK_THRESHOLD,
    SET_STICK_HYST,
    /* --- updates --------------------------------------------------------- */
    SET_UPD_REMIND,
    SET_UPD_CHANNEL,
    /* --- the SD card ----------------------------------------------------- */
    SET_LOG_AUTO,
    SET_LOG_USER,
 
    SETTING_COUNT
} setting_id_t;

typedef struct {
    const char        *key;      
    const char        *unit;     
    setting_cat_t      cat;             
    setting_type_t     type;            
    float              min;             
    float              max;             
    float              step;            
    float              def;             
    const char *const *options;  
    uint8_t            option_count;    
    float              off_below;
} setting_def_t;

typedef void (*settings_observer_fn)(setting_id_t id);
 
/*
 * A few short strings beside the numbers, kept by the same store and saved
 * by the same request.  A string holds up to SETTINGS_TEXT_MAX - 1
 * characters.
 */
typedef enum {
    SET_TEXT_DUT_NAME = 0,   
    SET_TEXT_LOG_AUTO_DIR,   
    SET_TEXT_LOG_USER_DIR,   
    SETTING_TEXT_COUNT
} setting_text_id_t;
 
#define SETTINGS_TEXT_MAX 24

typedef void (*settings_text_observer_fn)(setting_text_id_t id);
 
typedef struct {
    bool (*load)(float *values, int count);
    /*
     * True only if every value reached the medium.  A store that cannot
     * say so cannot be believed: the model keeps the edit and the screen
     * goes on offering the write, rather than reporting a save that did
     * not happen and refusing the retry that would notice.
     */
    bool (*save)(const float *values, int count);
    /* The strings, under the same rules; NULL in a store that keeps none,
     * which then keeps them for the session only. */
    bool (*load_text)(char (*texts)[SETTINGS_TEXT_MAX], int count);
    bool (*save_text)(const char (*texts)[SETTINGS_TEXT_MAX], int count);
} settings_store_t;

void settings_init(void);
 
void settings_set_store(const settings_store_t *store);
void settings_set_observer(settings_observer_fn fn);
void settings_set_text_observer(settings_text_observer_fn fn);

typedef bool (*settings_hold_fn)(setting_id_t id);
void settings_set_hold(settings_hold_fn fn);
bool settings_held(setting_id_t id);

typedef bool (*settings_armed_fn)(void);

void settings_set_armed(settings_armed_fn fn);

bool settings_safe_only(setting_id_t id);
 
const setting_def_t *settings_def(setting_id_t id);

bool settings_derived(setting_id_t id);
const char *settings_category_name(setting_cat_t cat);
const char *settings_label(setting_id_t id);
const char *settings_help(setting_id_t id);
int settings_option_list(setting_id_t id);
 
float settings_get(setting_id_t id);
int   settings_get_int(setting_id_t id);
bool  settings_get_bool(setting_id_t id);

void settings_set(setting_id_t id, float value);
void settings_adjust(setting_id_t id, int steps);

bool settings_cycles(setting_id_t id);

bool settings_sense_sda_valid(int gpio);

bool settings_tap_pin_valid(int gpio);

bool settings_pdmini_same_pin(void);

void settings_reset(setting_cat_t cat);
void settings_reset_all(void);

int settings_in_category(setting_cat_t cat, setting_id_t *out, int max);

int settings_decimals(setting_id_t id);

const char *settings_value_text(setting_id_t id, char *buf, size_t n);
const char *settings_value_text_of(setting_id_t id, float value, char *buf,
                                   size_t n);

setting_cat_t settings_text_category(setting_text_id_t id);
int settings_texts_in_category(setting_cat_t cat, setting_text_id_t *out,
                               int max);

const char *settings_text(setting_text_id_t id);
const char *settings_text_key(setting_text_id_t id);
void settings_set_text(setting_text_id_t id, const char *text);
 
#ifdef ESP_PLATFORM
const settings_store_t *settings_nvs_store(void);
#endif

bool settings_dirty(void);
 
/* ------------------------------------------------------ the stored copy */
 
/*
 * The values and strings the medium holds, as far as the panel knows: the
 * ones settings_init() loaded (the defaults where the store had none), or
 * the ones the last successful settings_save() wrote.  A refused save leaves
 * the copy as it was.
 */

float settings_stored(setting_id_t id);
const char *settings_stored_text(setting_text_id_t id);
bool settings_differs(setting_id_t id);
bool settings_text_differs(setting_text_id_t id);
int settings_changes(void);

int settings_discard(void);

/*
 * Write the values through the store.  True if the store took them.  False
 * if there is no store, or the store refused: the values stay dirty, the
 * request is answered so the button offers the write again, and
 * settings_save_failed() stands until the next successful save or the next
 * edit.
 */
bool settings_save(void);

bool settings_save_failed(void);
 
/* ------------------------------------------------------- asking to save */

void settings_request_save(void);

bool settings_save_asked(void);

bool settings_save_tick(bool safe);

void settings_cancel_save(void);
 
#ifdef __cplusplus
}
#endif