motor_live_int.h

Go to the documentation of this file.

#pragma once
 
#include <stdbool.h>
#include <stdint.h>
 
#include "gfx.h"
#include "motor_screen.h"
#include "touch_types.h"
#include "ui_plot.h"
#include "ui_slider.h"
#include "ui_tabs.h"
#include "ui_text.h"
#include "ui_value_gate.h"
#include "ui_widgets.h"
 
#include "motor_screen_int.h"
 
/*
 * Inside the telemetry card: the title line, PLOT | TABLE with the poll
 * rate beside them, the legend, then the plot.  The table takes the
 * legend's and the plot's place.
 */
#define SUB_Y     (UP_Y + TITLE_H + 6)    
#define SUB_H     40                      
#define SUB_W     200                     
#define LEG_Y     (SUB_Y + SUB_H + 4)     
#define LEG_H     20                      
#define PLOT_X    (LEFT_X + INNER)        
#define PLOT_W    (LEFT_W - 2 * INNER)    
#define PLOT_Y    (LEG_Y + LEG_H + 4)     
#define PLOT_H    (UP_Y + UP_H - INNER - PLOT_Y) 
#define RATE_X    (PLOT_X + SUB_W + 14)
 
/*
 * Inside the THROTTLE card: the readout on the title line's right, then
 * the track with a step key at each end, then the hint, which ends above
 * the alert band.
 */
#define ROW_Y     (LO_Y + 4)              
#define READOUT_W 260                     
#define READOUT_H 46                      
#define READOUT_X (LEFT_X + LEFT_W - INNER - READOUT_W) 
#define NUDGE_W   72                      
#define NUDGE_H   56                      
#define CTRL_Y    (ROW_Y + READOUT_H + 4) 
#define TRACK_H   48                      
#define TRACK_Y   (CTRL_Y + (NUDGE_H - TRACK_H) / 2) 
#define TRACK_X   (LEFT_X + INNER + NUDGE_W + 8) 
#define THR_R     (RC_X - UI_TAP_MIN)
#define TRACK_W   (THR_R - NUDGE_W - 8 - TRACK_X)
#define HINT_Y    (CTRL_Y + NUDGE_H + 8)  
#define HINT_X    (LEFT_X + INNER)
_Static_assert(TRACK_X + TRACK_W + 8 + NUDGE_W + UI_TAP_MIN <= RC_X,
               "+1 ends a finger's width left of DISARM");
_Static_assert(HINT_Y + 20 <= STOP_FLOOR,
               "the throttle's hint ends above the alert band");
_Static_assert(ROW_Y + READOUT_H <= CTRL_Y,
               "the readout ends above the step keys");

#define ARM_HOLD_S    UI_HOLD_S
 
enum { S_VOLT = 0, S_CURR, S_POWER, S_RPM, S_COUNT };
 
/*
 * The panel polls at 20Hz, one sample per plot column, so the time base is
 * the plot width in samples: PLOT_W / 20s.
 */
#define SAMPLE_HZ 20.0f
typedef struct {
    ui_plot_t     plot;                 
    ui_slider_t   slider;               
    ui_tabs_t     tabs;                 
    bench_state_t bench;                
    /* Whether the throttle follows its controls (ui_value_gate.h): the
     * bench's report, an ARM the hold has asked for and a DISARM or STOP not
     * yet answered.  gate.armed is what the ARM button reads. */
    ui_value_gate_t gate;
    motor_cmd_t   pending;              
    /* The knob's throttle command waiting in `pending`, and what to put back
     * if it is withdrawn: the slider's value before the knob moved it, and
     * whether a throttle was pending before it. */
    bool          knob_pending;
    bool          knob_had_cmd;
    float         knob_prev;            
    /* A finger owned the slider at some point since knob_frame(). */
    bool          knob_finger;
    unsigned      drawn_mask;
    /* The arm state of the bench itself, which is what bounds a run.  Kept
     * apart from the gate: leave() reads the bench as disarmed for a disarm
     * it has only asked for. */
    bool          bench_armed;          
    /* The push count last painted into each framebuffer; UINT32_MAX
     * means "no paint recorded", which is not a count push can reach. */
    uint32_t      drawn_push[2];
    /* And the plot revision, which moves for fewer reasons: a stopped plot
     * takes no samples, so a disarmed bench repaints its readouts and leaves
     * the trace alone. */
    uint32_t      drawn_plot[2];        
    /* The telemetry tag last painted, 0xFF for none.  It changes on an arm
     * edge rather than with the numbers, so it cannot ride drawn_push. */
    uint8_t       drawn_title[2];
    /* Bumped by anything that changes a button's or the tab row's
     * appearance.  The throttle carries its own, because a drag moves it on
     * every frame and repainting the buttons with it costs the row's full
     * 800 x 90px rather than the readout's 396 x 30. */
    uint32_t      ctrl_rev;             
    uint32_t      drawn_ctrl[2];        
    uint32_t      thr_rev;              
    uint32_t      drawn_thr[2];         
    /* ARM animates, so it gets a third counter and repaints its own rect. */
    uint32_t      arm_rev;              
    uint32_t      drawn_arm[2];         
    int           esc_kv;        
    /* The GPIOs bound as throttle (bit n is GPIO n) and whether a binding
     * was read: what the throttle panel names as its target. */
    uint64_t      thr_pins;             
    bool          thr_pins_known;       
    /* The protocol they are bound as: an outbind_protos() index, 0 for
     * none known, MOTOR_PROTO_MIXED for several. */
    uint8_t       thr_proto;
    /* port_view_revision() when the TARGET row last named the DShot
     * programming ports. */
    uint32_t      thr_ports_rev;
    /* The strip's and SETTINGS' page's revisions last painted into each
     * framebuffer, and whether the TARGET row was drawn locked. */
    uint32_t      drawn_strip[2];       
    uint32_t      drawn_page[2];
    bool          target_locked;        
    /* PROGRAM's session as each framebuffer last had it: whether it was
     * shown, its revision, and the output strip's text (a signature). */
    bool          drawn_sess_shown[2];
    uint32_t      drawn_sess[2];        
    uint32_t      drawn_ostrip[2];
    /* Whether each channel's peak is a measurement: a valid live reading
     * has arrived since the run started.  Kept apart from the live flags,
     * which a source that stops answering mid-run clears while the run's
     * peaks it measured stand. */
    bool          pk_ok[S_COUNT];       
    ui_hold_t     arm;           
    bool          kst_held;      
    bool          no_pin;        
    gfx_rect_t    arm_rect;             
    gfx_rect_t    reset_rect;           
    gfx_rect_t    down_rect;    
    gfx_rect_t    up_rect;      
    int           pressed;      
    uint8_t       press_id;             
    bool          have_press;           
} mo_state_t;
 
/* Defined in motor_screen.c. */
extern mo_state_t mo_s;
#define s mo_s
 
/* --- motor_screen.c: the channels, the state's rules and the commands --- */

extern const ui_plot_series_t mo_series[S_COUNT];
extern const uint16_t mo_ok[S_COUNT];
extern const ui_text_id_t mo_names[S_COUNT];

void mo_bind_colours(void);
bool mo_value_live(void);
void mo_end_drag(void);
void mo_post(motor_cmd_kind_t kind, float value);
bool mo_arm_locked(void);
bool mo_no_motor_pin(void);
void mo_throttle_from_zero(void);
bool mo_bench_safe(void);
bool mo_endpoints_free(void);
bool mo_target_locked(void);
 
/* --- motor_events.c ----------------------------------------------------- */

bool mo_safe_at(int x, int y);
void mo_event(const touch_event_t *evt);
void mo_tick(float dt_s);
 
/* --- motor_draw.c ------------------------------------------------------- */

void mo_render(gfx_canvas_t *c, int buffer_index);