servo_screen.h

Go to the documentation of this file.

 
#pragma once
 
#include <stddef.h>
#include <stdint.h>
 
#include "sense_link.h"
#include "servo_cmd.h"
#include "servo_source.h"
#include "servo_test_io.h"
#include "supply.h"
#include "ui_keypad.h"
#include "ui_screen.h"

void servo_invalidate(void);
 
const ui_screen_t *servo_screen(void);

void servo_screen_knob(float span_fraction);

void servo_screen_knob_frame(void);

void servo_screen_knob_cancel(void);

bool servo_screen_take(servo_cmd_t *out);

void servo_screen_encoder(const servo_test_enc_t *e);

void servo_screen_feedback(uint16_t position_us, float current_a, bool valid);

void servo_screen_set_armed(bool armed);

void servo_screen_set_bench_armed(bool armed);

void servo_screen_cancel_arm(void);

uint16_t servo_screen_commanded(void);

bool servo_screen_log_pulse(uint16_t *us);

bool servo_screen_log_angle(float *deg);

const ui_keypad_t *servo_screen_keypad(void);
const char *servo_screen_commanded_text(void);

uint16_t servo_screen_drawn(void);

uint16_t servo_screen_frame_hz(void);
const char *servo_screen_type_name(void);

void servo_screen_supply(const supply_state_t *s);

void servo_screen_supply_at(const supply_state_t *s, servo_source_id_t id,
                            uint32_t changes);

void servo_screen_source(servo_source_id_t id, uint32_t changes);

void servo_screen_on_testing(void (*told)(bool running));

void servo_screen_source_why(servo_source_why_t why);

void servo_screen_source_dropped(servo_source_why_t why, uint32_t at);

void servo_screen_window(const sense_link_win_t *w, servo_source_id_t id,
                         uint32_t changes);

int   servo_screen_power_points(void);
float servo_screen_power_sample(int series, int back);

bool servo_in_force_note(char *l1, char *l2, size_t size, uint16_t hz,
                         uint8_t target, uint8_t gpio, bool pwm, int setting);

void servo_screen_rate(servo_rate_state_t st, uint16_t hz);

void servo_screen_set_sweep(bool able);

void servo_screen_set_surfaces(bool any);

void servo_screen_set_enc_held(bool held);

#define SERVO_SCREEN_NO_PIN 0xFFu
#define SERVO_SCREEN_TARGET_UNKNOWN 0xFEu
#define SERVO_SCREEN_TARGET_NO_LINK 0xFFu

void servo_screen_set_drive(uint8_t target, uint8_t gpio, bool pwm);

void servo_screen_set_pins(uint64_t gpio_mask, bool known);

bool servo_target_line(char *out, size_t size, uint8_t target, uint8_t gpio,
                       bool pwm, uint64_t pins, bool known);

int servo_screen_task(void);

int servo_screen_settings_page(void);

int servo_screen_run_settings(void);

bool servo_screen_target_locked(void);

bool servo_screen_tester_target_locked(void);

bool servo_screen_port_pwm_locked(void);

void servo_screen_sweep_refused(void);

bool servo_screen_sweeping(void);

bool servo_screen_paused(void);

void servo_screen_released(uint16_t pause_seq);

void servo_screen_sweep_started(uint16_t start_seq, uint32_t age_ms,
                                servo_sweep_from_t from, uint32_t since_ms);

void servo_screen_sweep_held(uint16_t pause_seq, uint32_t kept_ms);

uint32_t servo_screen_curve_ms(void);

void servo_screen_set_commanded(float deg);
 
/* ------------------------------------------------- the automatic test */
 
/*
 * START TEST on TEST's AUTOMATIC TEST card runs servo_test.h's automatic
 * test from this screen: a two-second hold, or HV SERVOS ONLY held for two
 * seconds when a step is above 6.0V.  It needs an armed bench and a supply that answers,
 * and it commands the servo and SUPPLY's set points and output itself.
 * Progress and the result are shown on its card and in LIVE's box.
 */

void servo_screen_clock(uint32_t now_ms);

void servo_screen_set_link(bool up);

bool servo_screen_testing(void);

bool servo_screen_limit_running(void);
int servo_screen_limit_phase(void);

servo_test_out_t servo_screen_test_peek(const char **text);
void servo_screen_test_pop(void);

void servo_screen_test_files(int number, bool report);
void servo_screen_test_logger_busy(bool busy);

void servo_screen_service(void);