File List

Here is a list of all documented files with brief descriptions:

firmware
iomcu
include
iomcu_pins.h	IOmcu pin map for the module build: a Waveshare RP2350-CAN (RP2350A, 4 MB flash) with its XL2515 CAN (Controller Area Network) controller
src
console_hw.c	The IOMCU_CONSOLE build's console; see console_hw.h
console_hw.h	The IOMCU_CONSOLE build: the bench console (shared/outputs/page_console.h) on the USB (Universal Serial Bus) serial port
iomcu.h	The IOmcu application's own state, shared by the files it is cut into
iomcu_bind.c	The binding prepared and taken whole (BIND, BIND_CFG, BIND_OUT), and the board's own pages: CATALOGUE, SHAPE, ARTWORK, ART_DATA and PADS; see iomcu.h for the other files
iomcu_can.c	The panel's heartbeat input and the CAN bus: the controller and the receive loop that answers the link's requests; see iomcu.h for the other files
iomcu_hitec.c	The HITEC page and the programming port's hardware it drives; see iomcu.h for the other files
iomcu_kst.c	The KST page and the programming port's hardware it drives; see iomcu.h for the other files
iomcu_pages.c	The IOmcu's own pages and the output pages: IDENTITY, STATUS, CONTROL, BENCH, CHANNELS, CHAN_CFG, OUTPUTS, SERVO and PROG, and the glue that makes the silicon agree with the bank
iomcu_report.c	The console report every 3s: the flash store, the running slot and why this start happened, the CAN bus and the current monitors as the pages show them
iomcu_sense.c	The SUPPLY page and the PD mini behind it, and the current monitors' pages SENSE, SERVO_SENSE and SERVO_WIN, which core 1 reads the parts for; see iomcu.h for the other files
iomcu_tone.c	The TONE page and the phase tap's capture behind it; see iomcu.h for the other files
main.c	The IOmcu application
out_pwm.c	Hardware PWM (pulse-width modulation) servo outputs
out_pwm.h	Servo pulses from the RP2350's hardware PWM (pulse-width modulation)
out_store.c	The output configuration in flash
out_store.h	The output configuration, kept in the IOmcu's own flash
outputs_hw.c	The bank rendered onto pins
outputs_hw.h	The seam between the output bank and the pins
port_park.c	A programming port's pin held with no driver. See port_park.h
port_park.h	A programming port's pin held with no driver (FUNC NONE): an input with its pull-down, so a lead on it reads low rather than floating
sense_core1.c	Core 1: the sensor bus and the hand-over
sense_core1.h	Core 1: the sensor bus, read on a 1ms tick, and the hand-over to core 0
sense_i2c.c	The sensor bus on the RP2350's I2C block
sense_i2c.h	The sensor bus on the RP2350's I2C (Inter-Integrated Circuit) block: the wire under shared/sense, as sense_svc_io_t asks for it
sense_trace_hw.c	The SENSE_TRACE build's ring, console and frame time
sense_trace_hw.h	The SENSE_TRACE build: CH1's 1ms samples on the USB console
tone_core1.c	Core 1's half of the phase tap
tone_core1.h	Core 1's half of the phase tap, and the hand-over to core 0
update_hw.c	The firmware update on this board
update_hw.h	The IOmcu's firmware update over the link: link_update_dev on this board's flash and boot ROM
xl2515.c	The XL2515 over SPI: the part of the CAN driver that touches hardware
xl2515.h	The XL2515 over SPI (Serial Peripheral Interface): the part of the CAN (Controller Area Network) driver that touches hardware
panel
components
art_flash
include
art_flash_esp.h
art_flash_esp.c	The board-drawing partition, as an art_flash_t. See art_flash_esp.h
board
include
board.h	Board bring-up for the 7-inch ESP32-P4 display board: the touch I2C (Inter-Integrated Circuit) bus, the backlight's PWM (pulse-width modulation) and the touch controller's reset
board_pins.h	Pin map for the 7-inch ESP32-P4 display board from Waveshare (ESP32-P4-WIFI6-Touch-LCD-7B)
board.c	Board bring-up for the 7-inch ESP32-P4 display board: touch I2C bus, backlight PWM and the GT911 reset
can_twai
include
can_twai.h	The panel's CAN (Controller Area Network) driver
can_twai.c	The panel's TWAI controller on the link: start, stop, send and receive
display
include
display.h	Double-buffered display driver for the 7-inch ESP32-P4 display board
display.c	The EK79007 panel on the ESP32-P4's DSI host, written from the EK79007 datasheet and ESP-IDF's esp_lcd headers
fw_ota
include
fw_ota.h	The application slots, as the installer and the start-up need them
fw_ota.c	The application slots over esp_ota_ops
gt911
include
gt911.h	GT911 capacitive touch controller driver over I2C (Inter-Integrated Circuit)
touch.h	Touch input for the 7-inch ESP32-P4 display board
touch_inject.h	The touch injector's side of the touch task, in a build with RCBENCH_TOUCH_INJECTOR, the default (idf.py -D RCBENCH_TOUCH_INJECTOR=OFF build leaves it out)
touch.c	The GT911 polling task: reads contacts, maps them into the panel's coordinates, crops them to the UI's area and publishes snapshots and events
touch_inject.c	The touch injector at 0x14, read beside the glass (touch_inject.h)
storage
include
storage.h	The SD (Secure Digital) card: mounting it, and listing what is on it
storage.c	The SD card on SDMMC slot 0: mount, unmount, holds, and the look at a card that does not mount
storage_list.c	Listing the mounted card: storage_walk(), storage_walk_counted(), storage_stat(), storage_dir_open() and its reads, and storage_path()
storage_priv.h
wifi_access
include
wifi_access.h	The panel's Wi-Fi: the radio, the page's HTTP (hypertext transfer protocol) server, the mDNS (multicast domain name system) name and the NVS (non-volatile storage) entry of the home network
wifi_access.c	The panel's Wi-Fi over esp_wifi, esp_http_server, esp_http_client and a UDP (user datagram protocol) socket for the mDNS name
wifi_dns.c	The name servers a join gave, on the console. See wifi_dns.h
wifi_dns.h	The name servers a join of the home network gave, on the console
wifi_ntp.c	The clock set from the home network. See wifi_ntp.h
wifi_ntp.h	The clock set from the home network: one SNTP (Simple Network Time Protocol) request a join, through ESP-IDF's esp_netif_sntp
wifi_radio.c	The radio under esp_wifi: the board's ESP32-C6, reached over SDIO (Secure Digital input/output) through esp_wifi_remote and esp_hosted
wifi_radio.h	The radio under esp_wifi, as wifi_access.c sees it
wifi_req.c	The page server's request headers. See wifi_req.h
wifi_req.h	The page server's request headers, as the guard (wa_guard.h) and the access code check read them
wifi_sock.h
main
hitec_record.c	The Hitec programmer's record on the card: HITEC.TXT in the folder BENCH/HITEC/CONF, the values before a write (hitec_card.h)
knob_task.c	The knob's I2C bus, its sensor's registration and the task that polls it
knob_task.h	The rotary knob's reader: an MT6701 at 0x06 on an I2C (Inter-Integrated Circuit) bus of its own (BOARD_KNOB_PIN_SDA, BOARD_KNOB_PIN_SCL), polled from a task of its own
kst_files.c	The card as the servo programmer's files see it. See kst_files.h
kst_files.h
main.c	The panel application: app_main, the console report and the main loop's hardware glue
panel.h	What the panel's files share: firmware/panel/main/main.c and the files cut from it. One section per file, each holding what that file defines and another file uses. A file's own state stays static in that file
panel_arm.c	The bench's arm on the control task: the state the loop starts from, the watch on an arm until the render side has seen it, the run's totals, the latched stop and the act the arming policy asks for, the OUTPUTS screen's binding onto the IOmcu's output pages, disarming wherever it was asked for, one motor command, and the screens' commands in their order
panel_art.c	The board's drawing: fetched from the IOmcu a slice of a poll at a time on the control task, kept in flash a sector a pass on a safe bench, and published for the picker on the UI task
panel_boot.c	The panel's start-up: the board, the settings, the display, touch, the card, the link and the IOmcu, each reported to the splash as it happens
panel_card.c	The card's files outside the run log: the ESC profiles read at start-up, the log viewer's list, open and delete, and the servo programmer's record and file requests, which the logger task serves (panel_log.c)
panel_control.c	The control task: touch, STOP, arming, the outputs, the link and the heartbeat
panel_files.c	FILES' card task: the file manager's card (fm_io.h) over the storage component, the task cardjob that runs the screen's requests (fm_req.h), and the screen's way to it (files_io_t)
panel_frame.c	The render loop, from app_main once the tasks are running
panel_hitec.c	The control task's half of the programmer for servos by Hitec: the HITEC page's link module (hitec_link.h), the commands of the programmer's model and what the model is fed
panel_limit.c	The INA3221 channels' current limits on their way to the IOmcu's SENSE_LIMIT page
panel_link.c	The link to the IOmcu: exchange(), through which every request to the far end goes, and the control page, which carries ARM, THROTTLE, the pole count, CLEAR and the throttle's endpoints. The link report is here too. Control task only, and app_main before that task exists
panel_log.c	The logger: the runlog task, which makes every card call of a run, a servo test and the fault log. A run is written to AUTO LOG FOLDER, a test to USER LOG FOLDER (SETUP > SD CARD; CARD_AUTO_LOGS and CARD_USER_LOGS by default, card_tree.h), each under its folder's next number (log_take.h). The control task's side, which numbers the runs and posts the rows, is in main.c
panel_main.h	What main.c shares with the four files split from it
panel_perf.c	The PSRAM probe at start-up, the frame times, and the lows of every stack and of the internal heap (panel_perf.h)
panel_perf.h	The console's measurements of the panel itself: PSRAM (pseudo-static RAM) speed at start-up, the frame times, and every task's stack and the internal heap at their lowest
panel_poll.c	The poll of the far end, once a control pass: the bench page and the services while the IOmcu answers, its identity while it does not, the link-up and link-lost edges, the model and the log while nothing answers, and the snapshot the screen reads
panel_render.c	The render side's services, once a frame on app_main: the programmer's model, the supply's levels, the servo test's lines, the rotary knob, the touch drain and the screens' commands on their way to the control task
panel_sense.c	The current monitors' set-up on its way to the IOmcu: SETUP INTERFACES' INA228, bus and encoder rows and SETUP > SENSORS' INA3221 parts, published by the settings observer on app_main and taken by the control task; and the SENSE_MAP page's service there (sense_map_link.h), with what it tells the operator
panel_services.c	The link modules' services, one page of the IOmcu each: the current monitors (SENSE and SERVO_SENSE), the phase tap (TONE), the programmer for KST and Chaservo servos (KST) and the programming ports (PROG). Each runs from the poll (panel_poll.c), on the control task
panel_settings.c	The settings the control task follows, handed across from app_main
panel_supply.c	The programmable supply, on the control task: the PD (USB Power Delivery) mini over the IOmcu's SUPPLY page, or the panel's model, its steps at the sample cadence, its run's rows for the log, and its page
panel_trial.c	A new build's first start, kept once the panel works as a whole: see panel_trial.h and shared/fwupdate/fw_trial.h
panel_trial.h	A new build's first start, kept once the panel works as a whole
panel_update.c	The updates: the IOmcu's over CAN (Controller Area Network) from the image this panel carries, the panel's own from WI-FI or from GitHub, and the IOmcu update's screen on the render side. cu_service() runs on the control task; the rest runs on app_main
selftest.h
protocols
dshot
include
dshot.h	DShot: sixteen bits per frame to an ESC (electronic speed controller), and the GCR (group-coded recording) burst that comes back
rp2350
out_dshot.c	DShot out and the reply back
out_dshot.h	DShot out, and the reply back on the same wire
dshot_edt.c	When to ask an ESC (electronic speed controller) for extended telemetry
dshot_frame.c	The outbound half of DShot: sixteen bits and the map from travel onto them
dshot_telem.c	The inbound half of DShot: the GCR (group-coded recording) burst an ESC (electronic speed controller) sends back on the signal line
hitec
include
hitec_pio.h	The numbers and words a PIO pin driver for the Hitec wire works with
hitec_pre.h	Receive a D series answer by precharge and sample: the cycle arithmetic, the sampler's PIO program, the decoder and the run
hitec_reg.h	Hitec servo programming protocols: the register models, the parameter table and the write plans
hitec_session.h	Hitec servo programming protocols: the session with one servo, as a state machine that hands out steps and takes their results
hitec_wire.h	Hitec servo programming protocols: frames, transactions, the reply decoders and the driver interface
rp2350
hitec_line.c	The Hitec wire on one RP2350 pin
hitec_line.h	The Hitec wire on one RP2350 pin: a hitec_driver_t made of one PIO (programmable input/output) state machine (hitec_line.pio) and two DMA (direct memory access) channels, one for the words of a transaction and one for the received bytes
hitec_pio.c	The arithmetic of the Hitec PIO pin driver
hitec_pre.c	Receive a D series answer by precharge and sample
hitec_reg.c	The register models of Hitec servos: images, the parameter table, encodings, model identification and write plans
hitec_session.c	Hitec session: entry, reads, write plans and leave, handed out as steps
hitec_wire.c	Hitec servo programming protocols: frames, transactions and the reply decoders
kst
include
kst_file.h	KST servo programming protocol: a servo configuration as a text file
kst_limits.h	KST servo programming protocol: limits on an edited image
kst_pio.h	The numbers and words a PIO pin driver for the KST wire works with
kst_plan.h	KST servo programming protocol: the order of the writes for a change
kst_reg.h	KST servo programming protocol: the register image and its fields
kst_session.h	KST servo programming protocol: the session with one servo
kst_wire.h	KST servo programming protocol: frames and the reply decoder
rp2350
kst_line.c	The KST wire on one RP2350 pin
kst_line.h	The KST wire on one RP2350 pin: a kst_driver_t made of one PIO (programmable input/output) state machine (kst_line.pio) and two DMA (direct memory access) channels, one for the words of a frame and one for the stamps of its reply window
kst_file.c	KST servo configuration as a text file: write and read
kst_limits.c	Limit checks of an edited register image against the servo's limits
kst_pio.c	Cycle counts and divider of the PIO pin driver for the KST wire
kst_plan.c	Search for the order of the register writes that changes an image
kst_reg.c	Register image conversions and the field table
kst_session.c	KST session: the operations on one servo, run step by step
kst_wire.c	Frame building and reply decoding for the KST wire
openyge
include
openyge.h	The OpenYGE ESC (electronic speed controller) protocol: framing, telemetry, status and parameters
openyge_frame.c	SPDX-License-Identifier: MIT
openyge_params.c	SPDX-License-Identifier: MIT
openyge_status.c	SPDX-License-Identifier: MIT
pdmini
include
pdmini.h	The WeAct PD Power Mini V1 Buck on its UART: the codec and a driver that talks to it one transaction at a time
rp2350
pd_uart.c	The PD mini's PIO UART
pd_uart.h	The PD mini's UART on two PIO (programmable input/output) state machines, on whichever two pins the caller names
pdmini.c	The PD mini
pdmini_codec.c	The PD mini's codec: the CRC8 (cyclic redundancy check, 8 bits) of a frame and the framing of a reply
pdmini_int.h	The PD mini driver's private functions, shared by pdmini.c and pdmini_jobs.c
pdmini_jobs.c	The PD mini's jobs: which transaction goes next, and the step that runs the phases of one
phase_tap
include
edge_ring.h	The words the tap's PIO (programmable input/output) program pushes, and the ring a DMA (direct memory access) channel collects them in
tone.h	ESC (electronic speed controller) tones from the edges of one motor phase
tone_svc.h	The tone service: what core 1 runs for the phase tap each 1ms tick
rp2350
tone_cap.c	The phase tap's capture
tone_cap.h	The phase tap's capture: one PIO (programmable input/output) state machine on one input pin (tone_cap.pio) and a DMA (direct memory access) channel that collects its words in a ring of TONE_RING_WORDS words, endlessly, with the write address wrapping on the ring
edge_ring.c	The tap's edge words and their ring
tone.c	ESC tones from the edges of one motor phase
tone_svc.c	The tone service
ppm
include
ppm.h	PPM (pulse-position modulation): several channels multiplexed onto one pin
rp2350
out_ppm.c	PPM out: a PIO state machine and a self-restarting pair of DMA channels
out_ppm.h	PPM (pulse-position modulation) out: one pin, several channels, driven by a PIO (programmable input/output) state machine fed by a pair of DMA (direct memory access) channels that restart each other
ppm.c	PPM frame layout
sbus
include
sbus.h	Futaba S.BUS: sixteen channels in twenty-five bytes
sbus.c	S.BUS frame decoder: framing on the byte gap, footer check and channel unpacking
shared
artwork
include
art_fetch.h	Fetching a board's drawing: the order of the transactions, without the link underneath them
art_store.h	Keeping a board's drawing, so it is fetched once and not every time the link comes up
art_fetch.c	Fetching a board's drawing
art_store.c	Keeping a board's drawing
bench
include
bench_state.h	The bench readings, in the units a person reads: V, A, W, rpm (revolutions per minute), degrees Celsius, mAh and Wh
endpoints_link.h	The panel's half of the throttle's pulse endpoints, Idle pulse and Full pulse, on the CHAN_CFG (0x23) link page: when a debt is paid, what each outcome of paying it leaves, and whether a switch to ARMED may go on
hitec_card.h	The card's side of the programmer for servos by Hitec: the text of the record of a write, which survives a restart of the panel, and its parse
hitec_link.h	The panel's half of the HITEC (0x34) link page, protocol 4.23 on: one step of a session with a servo by Hitec turned into page frames, and the page's answer turned back into its result
hitec_prog.h	The programmer for servos by Hitec as the SERVO screen runs it: the session with one servo, driven step by step through the panel's half of the HITEC link page, read only
hitec_rx_link.h	The panel's half of the Hitec receive mode: SETUP > INTERFACES > Hitec D receive (SET_HITEC_RX) written to the HITEC page's register 23 (LINK_HT_W_RX_MODE, protocol 4.24), and what SETUP marks on the row
knob.h	The rotary knob: an MT6701 magnetic angle sensor on the panel's I2C (Inter-Integrated Circuit) bus, read as relative motion
kst_card.h	The card's side of the servo programmer's files: a save, a list and a load of kst_prog.h carried out on the card
kst_link.h	The panel's half of the KST (0x32) link page, protocol 4.13 to 4.15: the programming ports for KST and Chaservo servos
kst_prog.h	The programmer for KST and Chaservo servos as the SERVO screen runs it: what is read from a servo, what the operator has changed, and what may be written
log_cadence.h	The run log's cadence: which pass of the control loop writes a row, and the time that row carries
log_cols.h	The bench log's INA3221 columns with SENSE_MAP in force (protocol 4.25): one group of three per channel that watches something, named after what it watches: FAST's channel first, then the others in channel order, at most LOG_COLS_GROUPS of them
log_writer.h	Writes a run as CSV (comma-separated values) in the format shared/logfile reads
panel_i2c.h	The I2C (Inter-Integrated Circuit) addresses taken on the 7-inch ESP32-P4 display board's buses, which a device added there must stay clear of
perf_watch.h	What the panel's console reports about its own frame times, stacks and heap: the statistics behind each line and the frame each line is due on, without the clock, the tasks or the log
prog_link.h	The panel's side of the programming ports' page (0x33)
sense_limit_link.h	The panel's half of SENSE_LIMIT (0x36, protocol 4.27): a current limit per INA3221 channel, and the channels whose 50ms window passed it
sense_link.h	The panel's half of the SENSE (0x2B), SERVO_SENSE (0x2C) and SERVO_WIN (0x31) link pages: what is written to SENSE, in what order, what is read from the three pages and how often, and what a read means for the operator
sense_map_link.h	The panel's half of the SENSE_MAP page (0x35, protocol 4.25): up to four INA3221 parts as SETUP > SENSORS has them, written to the IOmcu, and what each part is doing, for SENSORS and the alert band
sense_win_link.h	The panel's half of SENSE_WIN_A and SENSE_WIN_B (0x37, 0x38, protocol 4.25): every INA3221 channel's last complete 50ms window, for the log's columns per watched target
servo_source.h	Which meter measures the servo rail: the INA3221's CH1, the PD mini (the WeAct PD Power Mini supply) or the panel's model
supply.h	A programmable supply: what it can be set to, what it was set to, and what it delivers
supply_link.h	The panel's half of the SUPPLY link page (0x2A, protocol 4.3 to 4.13): what is written to it, in what order, and what a read of it means for the supply the screen shows
telemetry_sim.h	A pack, a motor and a propeller, modelled, so every screen runs without a measurement front end
tone_link.h	The panel's half of the TONE (0x2D) link page, protocol 4.8: what is written to it, in what order, what is read from it and how often, and what a read means for the operator
bench_state.c	The decoding, peaks and totals of the bench readings, see bench_state.h
endpoints_link.c	The panel's half of the throttle's pulse endpoints
hitec_card.c	The text of the Hitec programmer's record of a write, and its parse. See hitec_card.h
hitec_link.c	The panel's half of the HITEC link page
hitec_prog.c	The programmer for servos by Hitec: the session driven through the link's task, the state the overlay draws and the messages it says. See hitec_prog.h
hitec_prog_int.h	The seam between hitec_prog.c, the session's driving, and hitec_prog_write.c, the edits, writes and the record
hitec_prog_write.c	The write side of the programmer for servos by Hitec: the draft and its edits, the soft rules and their confirmations, the write switch, the writes, and the record of a write. See hitec_prog.h
hitec_rx_link.c	The panel's half of the Hitec receive mode
knob.c	The poll transactions and the angle steps of the rotary knob, see knob.h
kst_card.c	The card's side of the servo programmer's files
kst_link.c	The panel's half of the KST link page
kst_prog.c	The state of the programmer for KST and Chaservo servos: see kst_prog.h
kst_prog_card.c	The programmer's files on the card: the save, the list and the load of kst_prog.h as the state sends them and takes their answers back
kst_prog_file.c	The programmer's journal file: the text of a write to the servo that survives a restart of the panel, and the parse of it
kst_prog_int.h	The programmer's private seam between kst_prog.c, kst_prog_card.c and kst_prog_file.c: the wait and file-write kinds the state holds, and the helpers of kst_prog.c that the card part and the journal file part call
log_cadence.c	The run log's cadence: which pass writes a row, see log_cadence.h
log_cols.c	The bench log's columns per watched target
log_writer.c	Writes a run as CSV rows to a sink, see log_writer.h
panel_i2c.c	The table of I2C addresses taken on the panel board's buses (panel_i2c.h)
perf_watch.c	The frame window, the table of lows and the line schedule behind the panel's console lines (perf_watch.h)
prog_link.c	The panel's side of the programming ports' page
sense_limit_link.c	SENSE_LIMIT, the panel's half. See sense_limit_link.h
sense_link.c	The panel's half of the SENSE, SERVO_SENSE and SERVO_WIN link pages
sense_link_int.h	What sense_link.c and sense_link_view.c share and nobody else sees: the set-up's frame layout, the status register index, and three names the two files cross
sense_link_view.c	The panel's half of the SENSE, SERVO_SENSE and SERVO_WIN link pages: what the last reads hold, handed to the screens, the log and the band – the servo windows, the meter, the ESC figures and totals, the encoder and the parts' addresses and identities – and the rows of SETUP the page does not hold
sense_map_link.c	The panel's half of the SENSE_MAP page
sense_win_link.c	SENSE_WIN_A and SENSE_WIN_B, read for the log
servo_source.c	Which meter measures the servo rail
supply.c	A programmable supply and its model
supply_link.c	The panel's half of the SUPPLY link page
telemetry_sim.c	The modelled pack, motor and propeller, see telemetry_sim.h
tone_link.c	The panel's half of the TONE link page
can
include
can_selftest.h
can_timing.h	CAN (Controller Area Network) bit timing: a wanted bit rate turned into segment counts
mcp2515.h
can_timing.c	CAN (Controller Area Network) bit timing: the segment counts for a bit rate, and the limits of each controller. See can_timing.h
clock
include
wall_clock.h	The panel's wall clock: whether it holds a real date, whether a file's stamp says anything, the time zones SETUP offers, the one NTP (Network Time Protocol) request a join makes, and the slow clock's console line
wall_clock.c	The panel's wall clock rules. See wall_clock.h
esc
include
esc_profile.h	ESC (electronic speed controller) programming profiles: how to enter an ESC's throttle-stick programming menu, how it sounds a number, and what the menu holds
esc_sim.h	Simulated ESC in its throttle-stick menu, with its supply current
esc_stick.h	Stick programming: an ESC (electronic speed controller) programmed through its throttle-stick menu, with the beeps counted in the supply current
esc_det.c	Stick programming: the beep detector
esc_json.c	Read one ESC profile from JSON
esc_json_int.h	The tokens of esc_json_lex.c and the functions esc_json.c reads them with
esc_json_lex.c	The first stage of reading an ESC profile from JSON: the text cut into tokens
esc_registry.c	The profiles the bench offers: built in, with the card's in front
esc_sim.c	A simulated ESC in its stick menu
esc_stick.c	Stick programming: the run
esc_stick_int.h	Stick programming: what esc_stick.c, esc_stick_rules.c and esc_det.c share and esc_stick.h does not publish
esc_stick_read.c	Stick programming: the readouts of a run
esc_stick_rules.c	Stick programming: what can run
files
include
fm_io.h	The card as the file manager's core sees it: a table of functions the caller supplies, and the answers every part of the core gives
fm_name.h	The file manager's names and paths: which name a person may give a file or a folder, and the paths built from names
fm_ops.h	The file manager's jobs on the card: copy, move, rename, delete, make a folder, make an empty file, save a text and load a file, one step at a time
fm_req.h	One request of the FILES screen to the card's task, and the runner that answers it: a page of a pane, a folder entered or left, the facts of one entry for INFO, or a job run to its end
fm_rules.h	What the file manager may do to a name: the places the bench keeps, the files the logger writes, and the write gate of the bench's state
fm_select.h	One page of a folder held while the folder is read: which entries a bounded list keeps, in an order the caller names
fm_tree.h	One pane of the file manager: a folder of the card, the page of its entries on show, and the row selected
text_buf.h	A text file in memory for the viewer and the editor: a gap buffer over the caller's bytes and an index of its lines
text_hl.h	Syntax highlighting of one line of text: the spans of a line and the class of each, for the viewer to colour
fm_name.c	The file manager's names and paths (fm_name.h)
fm_ops.c	The file manager's jobs, one step at a time (fm_ops.h)
fm_req.c	The runner of the FILES screen's requests on the card's task (fm_req.h)
fm_rules.c	The places the bench keeps, the write gate and the kinds of entries (fm_rules.h)
fm_select.c	Keeping the page a bounded list shows while a folder is read, in the caller's order (fm_select.h)
fm_tree.c	One pane of the file manager: its folder, its page and its selection (fm_tree.h)
text_buf.c	A text file in memory: the gap buffer, the line index, the units and the cells (text_buf.h)
text_hl.c	Syntax highlighting of one line of text (text_hl.h): the rules of a bench text, JSON and CSV
fwupdate
include
fw_boot.h
fw_image.h	The panel's application image, read from memory: what it is, whether it is whole, and whether it is one this panel should run
fw_install.h	Writing a new panel application into the slot that is not running
fw_release.h	What GitHub says about the panel's releases, read strictly
fw_sha256.h	SHA-256 (Secure Hash Algorithm, 256 bit), FIPS 180-4, in portable C
fw_trial.h	When a new build's first start is kept: the steps the start waits for, and the bound on the wait
fw_upload.h	Receiving a panel image into memory, as a source hands it over
fw_image.c	The panel's application image. See fw_image.h
fw_release.c	Fw_release.h says what is read and how strictly
fw_trial.c	When a new build's first start is kept: see fw_trial.h
fw_upload.c	Receiving an image. See fw_upload.h
gfx
include
gfx.h	Gfx: an RGB565 (16-bit red, green, blue) rasteriser with no dependencies
gfx_damage.h	Damage: the part of one frame buffer the rasteriser wrote since the last reset, kept as 16-row bands with one x-span each
gfx_sprite.h	A sprite: an image with alpha, run-length encoded, blended onto a canvas
gfx_subpixel.h	Gfx's anti-aliased disc, capsule and ring placed in fractions of a pixel
gfx_turn.h	Screen rotation 180° in the flush: the UI draws its picture as it always does, and each flip copies what changed into the frame buffer the panel scans, turned, through a copy engine (on the ESP32-P4 the PPA, pixel-processing accelerator)
gfx_work.h	The pixels the rasteriser's loops visit, counted for the host suite
gfx.c	Gfx: the RGB565 (16-bit red, green, blue) rasteriser. See include/gfx.h
gfx_damage.c	Damage: the part of one frame buffer the rasteriser wrote, as 16-row bands. See include/gfx_damage.h
gfx_int.h	Gfx internals shared by gfx.c and gfx_text.c. Not part of the public interface (include/gfx.h); nothing outside shared/gfx includes it
gfx_seg.c	Seven-segment numerals, drawn rather than stored
gfx_sprite.c	Gfx_sprite_draw(): a run-length encoded image with 4-bit alpha, blended onto a canvas. See include/gfx_sprite.h
gfx_text.c	Gfx text: UTF-8 (Unicode Transformation Format, 8-bit) decoding, glyph drawing, string measuring and the rotated dither stencil. See include/gfx.h and gfx_int.h
gfx_turn.c	Screen rotation 180° in the flush. See include/gfx_turn.h
link
include
link_artxfer.h	Assembling a board drawing out of the blocks the link carries it in
link_bringup.h	Both ends' link counters turned into one diagnosis
link_can.h	The page protocol over CAN (Controller Area Network)
link_control.h	The CONTROL page as the IOmcu stores it: what a write may carry, and the one side effect a write has
link_crc.h	CRC-16 (cyclic redundancy check): polynomial 0x1021, no reflection, no final XOR, seed passed by the caller
link_dev.h	The IOmcu's half of the link: answer polls, and fail safe when they stop
link_drawing.h	Reading a board drawing (LINK_ART_DRAWING): the layout link_pages.h gives under LINK_DRAW_*
link_host.h	The panel's half of the link: poll, match the reply to the question, and escalate when the answers stop
link_msg.h	What crosses the link, independent of the transport: an op, a page, an offset, a count and up to a page of registers
link_pages.h	The page map: what the panel can ask the IOmcu for, and set
link_port.h	A write of any width, one frame in flight at a time
link_sha256.h	SHA-256 (Secure Hash Algorithm, 256-bit digest), as FIPS (Federal Information Processing Standard) 180-4 section 6.2 states it
link_update_dev.h	The IOmcu's half of the firmware update: the UPDATE_CTL and UPDATE_DATA pages (link_pages.h) and what they write
link_update_host.h	The panel's half of the IOmcu update: finding out whether the IOmcu runs the image the panel carries, sending it, and buying it once it has started
link_update_image.h	What both ends of the IOmcu update need to know about an RP2350 image: where its TBYB (try before you buy) flag is, and the hash that names a build whatever that flag says
rcbench_version.h	The firmware version, as one number both images and the host suite agree on
link_artxfer.c	Assembling a board drawing
link_bringup.c	Bring-up of the link: status replies, round-trip times and the diagnosis
link_can.c	Maps link messages onto CAN frames and back; see link_can.h
link_control.c	The CONTROL page's rules
link_crc.c	CRC-16, polynomial 0x1021, computed bit by bit; see link_crc.h
link_dev.c	The IOmcu end of the link: page dispatch, the arm latch and the failsafe tick
link_drawing.c	Reading a board drawing
link_host.c	The host end of the link: starting transactions, accepting replies and timeouts
link_port.c	Acknowledged write and read sequences over a link port; see link_port.h
link_sha256.c	SHA-256, written from FIPS 180-4: the constants of section 4.2.2, the initial hash value of section 5.3.3, the padding of section 5.1.1 and the computation of section 6.2.2
link_update_dev.c	The IOmcu's half of the firmware update
link_update_host.c	The panel's half of the IOmcu update
link_update_image.c	The picobin block loop, as the RP2350 datasheet sections 5.1.5 and 5.9.1 describe it: a block opens with PICOBIN_BLOCK_MARKER_START (0xffffded3), holds items, closes its item list with a LAST item that counts their words, then a word with the signed byte offset of the next block and the marker 0xab123579
logfile
include
card_state.h	What the panel's SD (Secure Digital) card slot holds, as the last mount found it: no card, a mounted volume, a card with no FAT (File Allocation Table) volume on it, or a card that does not mount for another reason
card_tree.h	The folders of the panel's SD (Secure Digital) card, and the files in them with a fixed name
fault_log.h	The fault log, BENCH/RCBENCH.LOG: one line every 5s while the link to the IOmcu is down, written whatever SETUP > SD CARD says
kst_store.h	Servo configuration files on the card: names, saving, listing, loading
log_csv.h	CSV (comma-separated values) and TSV (tab-separated values) import for a board that cannot hold the file it is reading
log_fields.h	Blackbox field naming: which group a channel belongs to, and what it is measured in
log_name.h	Run log names on the card, and which entries a bounded list keeps
log_numbers.h	Locale-tolerant numeric parsing with unit suffixes
log_take.h	Taking a run's number in a folder of the card, and which open file keeps a listed name out of reach
card_tree.c	Making a folder of the card one level at a time, and checking a log folder
fault_log.c	The fault log under its cap
kst_store.c	SPDX-License-Identifier: MIT
log_csv.c	Reading a CSV log without knowing, in advance, what wrote it
log_csv_int.h	Shared by log_csv.c and log_reader.c only; not part of the module's interface (log_csv.h is)
log_fields.c	What a column means, from what it is called
log_name.c	Run log names, and the order a bounded listing keeps them in
log_numbers.c	Turning a text cell into a number, when "1,024" might be either
log_reader.c	The CSV reader's byte layer: the sources behind the read/rewind function pointers, the row splitter that handles quoting and line endings, and the delimiter sniffer
log_take.c	Taking a run's number in a folder of the card
outputs
include
bind_link.h	The panel's half of a binding on the link: writing the two output pages and reading them back
hitec_port.h	Raw transactions of the Hitec servo wire on a programming port, and their link page (0x34)
kst_port.h	The KST programming protocol on a programming port, and its link page (0x32)
out_bind.h	Binding a protocol to pins: what the operator chooses, and the OUTPUTS page that comes out of it
out_pwm_map.h	Which PWM (pulse-width modulation) register drives which pin on the RP2350
out_stage.h	A binding prepared beside the one in force, and taken whole
out_store_map.h	Where the next copy of the output binding goes in the IOmcu's flash
out_store_rec.h	What a record in the IOmcu's output store carries, and how a record an earlier build wrote is read
outputs.h	The intermediary every output goes through: one set of rules for arming, clamping, slew and the silence timeout, with a protocol as a driver behind them
outputs_pages.h	The link's three output pages (CHAN_CFG, OUTPUTS, CHANNELS), expressed as bank operations
page_console.h	A bench console: link pages read and written from command lines, through the page handlers the link uses
prog_port.h	The programming ports and their link page (0x33)
sense_limit.h	The SENSE_LIMIT link page at the IOmcu (protocol 4.27): a current limit for each of SENSE_MAP's 12 channels, and the channels whose window passed its limit
sense_map.h	The SENSE_MAP, SENSE_WIN_A and SENSE_WIN_B link pages at the IOmcu (protocol 4.25): up to four INA3221 at 0x40 to 0x43, a shunt and a watch target for each of their 12 channels, the FAST channel, and every channel's last 50ms window
sense_page.h	The SENSE, SERVO_SENSE and SERVO_WIN link pages at the IOmcu: the I2C bus of the two current monitors and the output encoder, its set-up and what they last read, the servo rail's channels with a move capture, and CH1's last four windows
servo_cmd.h	A command of the SERVO screen as the panel's servo link takes it (servo_link.h), and what the link reports back: the frame rate's state, a pause let go of and where a sweep started
servo_link.h	The panel's half of the SERVO screen on the link: a command onto the IOmcu's CHAN_CFG, CHANNELS, SERVO and PROG pages, the position said again every SERVO_HOLD_MS (100ms), the release owed while a surface holds a position, the frame rate and the sweep
servo_page.h	The SERVO link page at the IOmcu: the frame rate of the tester's target and the sweep that drives it through a curve
supply_page.h	The SUPPLY link page at the IOmcu: a PD mini on a PIO UART, its wiring, what it is to do and what it last said
tone_page.h	The TONE link page at the IOmcu: the phase tap that hears an ESC's (electronic speed controller) beeps on one motor phase
bind_link.c	A binding on the link, from the panel's side
hitec_port.c	The Hitec servo wire on a programming port: the OPEN, transaction, POWER and CLOSE states
kst_port.c	The KST programming session on a programming port: the way into and out of PWM
out_bind.c	Binding a protocol to pins
out_pwm_map.c	The RP2350's GPIO-to-PWM fold
out_stage.c	A binding prepared beside the one in force
out_store_map.c	Where the next copy of the output binding goes
out_store_rec.c	A store record's configuration by version
outputs.c	The output bank
outputs_pages.c	The link's output pages, expressed as bank operations
page_console.c	The bench console: command lines read and written as link page requests and replies
prog_port.c	The programming ports and the PROG link page
sense_limit.c	The SENSE_LIMIT page: see sense_limit.h
sense_map.c	The SENSE_MAP, SENSE_WIN_A and SENSE_WIN_B link pages
sense_page.c	The SENSE, SERVO_SENSE and SERVO_WIN link pages
sense_page_int.h	What sense_page.c and sense_map.c share: the SENSE set-up's checks and its taking, and the map's own helpers the SENSE page calls
servo_cmd.c	The SERVO screen's command and the link's reports on it: the state an acknowledged frame rate is shown in, and the rules a kept command and a pause follow (servo_cmd.h)
servo_link.c	The panel's half of the SERVO screen on the link (servo_link.h)
servo_page.c	The SERVO link page
supply_page.c	The SUPPLY link page
tone_page.c	The TONE link page
safety
include
arming.h	When the bench is allowed to be armed, and what the panel must tell the IOmcu about it
flash_gate.h	When the panel may write its own flash, and when the IOmcu may not write its own
frame_watch.h	The render loop's watchdog: when a render loop that stopped making progress stops the bench
heartbeat.h	The safety heartbeat: the panel's signal that it is running, and the IOmcu's judgement of whether to believe it
reset_cause.h	Why the IOmcu last started, named from the registers its boot leaves behind
safety_gate.h	The IOmcu's decision to arm, once a pass and at every CONTROL write
touch_loss.h	Touch events that never arrived, and an arm that must not outlive one
arming.c	SPDX-License-Identifier: MIT
flash_gate.c	When the panel may write its own flash, and when the IOmcu may not write its own
frame_watch.c	The render loop's watchdog
heartbeat.c	SPDX-License-Identifier: MIT
reset_cause.c	Why the IOmcu last started: see reset_cause.h
safety_gate.c	SPDX-License-Identifier: MIT
touch_loss.c	Touch events that never arrived, and an arm that must not outlive one
sense
include
as5600.h	The ams OSRAM AS5600: a 12-bit magnetic rotary position sensor on I2C (Inter-Integrated Circuit)
ina228.h	The TI INA228: 85V, 20-bit current, voltage, power, energy and charge monitor on I2C (Inter-Integrated Circuit)
ina3221.h	The TI INA3221: three channels of 13-bit shunt and bus voltage, 0 to 26V, on I2C (Inter-Integrated Circuit)
sense_bus.h	The sensor bus: one I2C (Inter-Integrated Circuit) bus with current monitors on it, as the drivers see it
sense_sched.h	The IOmcu's sampling schedule for the sensor bus: what is read on each 1ms tick, the 50ms windows made from it, the run's peaks and totals, and the servo move capture on the FAST channel
sense_svc.h	The IOmcu's sensor service: what core 1 does each 1ms tick with the orders core 0 gives it, and the snapshot of what it read that core 0 publishes on the link
sense_trace.h	A trace of INA3221 CH1's 1ms samples as text lines, for a debug build of the IOmcu (its SENSE_TRACE build option)
as5600.c	The AS5600 codec and driver
ina228.c	The INA228
ina3221.c	The INA3221
sense_bus.c	The sensor bus
sense_i3221_cfg.c	The INA3221 map's helpers
sense_sched.c	The sensor bus's sampling schedule
sense_sched_cap.c	The schedule's move capture on the FAST channel, and FAST's history the level before a command is taken from
sense_sched_int.h	The schedule's parts shared between its two files: sense_sched.c reads the bus, sense_sched_cap.c runs the move capture and FAST's history on what it read
sense_svc.c	The IOmcu's sensor service
sense_trace.c	CH1's 1ms samples as text lines: core 0's side
sense_trace_feed.c	Core 1's side of the trace of the FAST channel's 1ms samples: each tick's records into the ring, and the count of those it dropped
servo
include
servo_limit.h	Finding a servo's installed mechanical limit by current
servo_limrun.h	The limit run: the limit search (servo_limit.h) run on the SERVO screen against the INA3221's windows, and for a KST or Chaservo servo on the programming port, the servo's own travel limits lowered until neither end binds
servo_move.h	One servo move judged from the servo's current, sample by sample: when it started moving and when it arrived, from a step command to one end
servo_sim.h	A servo on a control surface, modelled for the limit search
servo_str.h	The automatic servo test's words by id: every string the run writes or the SERVO screen shows about it is an entry of one table (UI_SERVO_TEXT in shared/text/include/ui_text.def). A caller that names an entry and nothing else of the run includes this alone, as ui_text.h does; the engine is servo_test.h
servo_sweep.h	A servo swept through a curve: square, sine or triangle about its centre
servo_sync.h	Synchronising two servos that drive one control surface
servo_test.h	The automatic servo test: a servo stepped through supply voltages, its current measured at rest, moving and holding, its travel timed from the supply's current, then the voltage walked down until it no longer moves
servo_test_io.h	What the automatic servo test reads and what it hands out: the supply's readings, the INA3221's windows and the encoder's readings it is fed, what it wants done, and the items of its outbox. A caller that feeds a run or carries its files to the card, and steps none, includes this alone, as servo_screen.h does; the engine is servo_test.h
servo_limit.c	Search for a servo mechanical limit by current: the state machine
servo_limrun.c	The limit run: see servo_limrun.h
servo_limrun_int.h	What servo_limrun.c and servo_limrun_report.c share and nothing else reads: where a side stands, a side's span, and whether RESTORE is offered. The two predicates are inline here so that the report, in its own file, inlines them; the public servo_limrun_span() and servo_limrun_restore() wrap them
servo_limrun_report.c	The limit run's outbox and report, and the words the screen and the report name a verdict, a reason and a phase by: see servo_limrun.h
servo_move.c	One servo move judged from its current. See servo_move.h for the rules
servo_report.c	The automatic servo test's TXT report, line by line
servo_sim.c	Single-servo and two-servo models of a control surface
servo_str.c	The automatic servo test's words: the CSV header, the phase and abort names, and the line formats of the TXT report (servo_report.c)
servo_sweep.c	The sweep. See servo_sweep.h
servo_sync.c	Search that synchronises two servos on one surface by total current
servo_test.c	The automatic servo test. See servo_test.h for the method
settings
include
settings.h	Device settings: a typed schema, a value per entry, and a persistence seam
settings_sensors.h	SETUP > SENSORS: up to four INA3221 parts on the sensor bus, at 0x40 to 0x43, and per channel its shunt and what it watches
settings.c	The settings, as a schema the screen draws rather than a screen per setting
settings_opts.h	The option lists of the enum settings, in English
settings_sensors.c	SETUP > SENSORS: the INA3221 parts' rows of the schema, their migration from the one INA3221 of 0.21, and the map they make. See settings_sensors.h
settings_text.c	The schema's words in English: the settings' labels, help lines and option lists, from the one text table, ui_text.def (shared/text)
touch
include
touch_map.h	Coordinate mapping and press/move/release tracking. Pure C; the unit tests are in test/host
touch_merge.h	Two touch controllers, one contact set: the glass's GT911 at 0x5D and a touch injector at 0x14 (testbench/touch-injector), merged into the frame the tracker sees. Pure C; the panel compiles the I/O around it in a build with RCBENCH_TOUCH_INJECTOR (the default), and the host suite tests it
touch_types.h	Plain data types shared by the touch controller driver, the coordinate mapper and the event tracker. No ESP-IDF dependencies, so the pure logic can be unit-tested on the host
touch_map.c	Turning frames of touch points into down/up events, and the coordinate maps before them
touch_merge.c	The glass's contacts and a touch injector's, merged (touch_merge.h)
ui
include
analyser_screen.h	The RECEIVER screen: what a receiver is actually sending. The code keeps the name analyser; the screen's title and tile are RECEIVER
balance_screen.h	The balance screen: sensor placement guides and the correction readout
battery_screen.h	The pack: what each cell is doing relative to the others
board_drawing.h	The IOmcu's drawing of its own board, on a screen: whether it describes the board the panel knows, and drawing it into a box
busfault_screen.h
coproc_update_screen.h	The IOmcu's firmware update, as the panel offers and shows it
esc_stick_panel.h	ESC STICK: an ESC (electronic speed controller) programmed through its throttle-stick menu, the session MOTOR & ESC > PROGRAM opens from the STICK MENU row of its list (prog_registry.h)
files_screen.h	FILES: the SD (Secure Digital) card in two panes, commander style, and the operations on its files and folders
hitec_panel.h	The overlay of the programmer for servos by Hitec on SERVO: its interface
kst_panel.h	The KST and Chaservo programmer's overlay on SERVO: its interface
log_select.h	Which of a card's entries a bounded list keeps, and the order it draws them in
log_text.h	A text file as LOGS shows it: read whole, broken into rows
log_viewer_screen.h	Log viewer: browse the card, review the import, plot the file
motor_screen.h	The motor and ESC (electronic speed controller) bench screen
outputs_screen.h	The outputs screen: choose a protocol, then tick the pins it drives
overview_screen.h
picker_screen.h	The pin picker: the board itself, with a button on every pin an output may have
port_mail.h
port_view.h
prog_models.h	The modelled ESC (electronic speed controller) protocols: BLHeli_S, AM32, ESCape32 and VESC, each a table of parameters
prog_registry.h	The registry of programmers and runs: one static table that the PROGRAM (and later TEST) lists of a workbench are built from
sensors_rows.h	SETUP > SENSORS' list: which SENSORS rows show, the headings over them, and what each fitted part is doing. The list is SETUP's own list renderer (settings_draw.c); this file decides its rows
servo_screen.h	The servo bench: the outputs the binding marks as surfaces, commanded together by dragging one horn
settings_screen.h	Settings: a hub of tiles, one per category and one per screen SETUP opens, and a category's entries in a list across the screen. The rows are rendered from the schema in shared/settings, so adding a setting is a table row and not a screen change; adding a tile is a row of the screen's tile table
splash_screen.h	The splash: the self-test report
supply_screen.h	The SUPPLY screen: a programmable supply set, switched and watched
ui_alert_slot.h
ui_band.h	The status band: the bench state on every screen, and the STOP control that works from every screen
ui_card_text.h
ui_cats.h	Cat drawings on the screens: the poses, the spots a screen offers them, the random pick of one and the source of the random number
ui_cats_art.h	The number of cat poses and the spots they take: the part of ui_cats.h tools/gen_cats.py writes
ui_hero.h
ui_icons.h	Icons drawn with primitives rather than stored as bitmaps
ui_keypad.h	A numeric keypad over part of a screen, for a value a slider is too coarse to place
ui_layout.h	The panel's geometry, in one place
ui_pinlist.h	A pin's name and a set of pins as text for a screen label or a report: "GPIO 13", "GPIO 2 GPIO 4 +2"
ui_plot.h	A multi-series plot on one time base, with a scale per series
ui_screen.h	Screen router
ui_setting_keypad.h	The numeric keypad (ui_keypad.h) for a number of the settings schema: opened with the setting's label, unit, range and the decimals of its step, and its OK set through settings_set(), the call the - and + keys end in
ui_slider.h	A draggable value with presets: the throttle, and any other control that needs coarse reach and fine adjustment in one place
ui_tabs.h	The pane selector: one bench, several views of it
ui_target_row.h	The TARGET row of a workbench's output card: what the screen drives now, read as protocol pins ("SERVO PWM GPIO 2 GPIO 4", "PROG PORT 1 GPIO 13"), and the control that picks it
ui_text.h	The interface's words, one table per language
ui_textkey.h	An on-screen keyboard for a short name: capitals, digits, space and the marks a name or a file needs, "-", "_" and "."
ui_theme.h	The visual language of the bench, resolved at runtime
ui_value_gate.h
ui_watermark.h	The SIMULATION watermark: the mark that the numbers behind it are modelled
ui_widgets.h	Stateless drawing helpers shared by every screen
ui_workbench.h	A workbench's task strip: one device, its tasks as tabs under the band
upd_screen.h	Panel updates from GitHub: SETUP's UPDATES screen and the reminder
wifi_screen.h	WI-FI: the panel's Wi-Fi, for two jobs in a browser – every file on the card to download, and a panel firmware image to upload – and the screen that writes an uploaded image (PANEL UPDATE)
analyser_screen.c	The RECEIVER screen (analyser_*: the code's name for it)
balance_screen.c	The balance screen: sensor placement guides and the correction readout
battery_screen.c	The battery screen: each cell's departure from the pack's mean
busfault_screen.c	Busfault_screen.h says what this screen is for
coproc_update_screen.c	Coproc_update_screen.h says what this screen is for
esc_stick_draw.c	ESC STICK's pages drawn
esc_stick_draw_run.c	A run of ESC STICK drawn
esc_stick_int.h	ESC STICK's private seam between esc_stick_pages.c, the page set MOTOR & ESC opens from PROGRAM's list (the session's state, its tap walk and its hooks), and esc_stick_panel.c, the stick programmer's pages: the layout both draw on, the state both read and write, the tap walk, the text helpers both draw with, and the panel's side the page set calls. Nothing outside shared/ui includes this header; the interface is esc_stick_panel.h
esc_stick_list.c	ESC STICK's profile list
esc_stick_pages.c	ESC STICK as a page set (prog_registry.h): the session's frame
esc_stick_panel.c	ESC STICK, the session MOTOR & ESC > PROGRAM opens: an ESC (electronic speed controller) with no wire to talk on, programmed through its throttle-stick menu. Its list is the ESC profiles (esc_profile.h), its parameters are the profile's menu items, and its write is a run of the stick programmer (esc_stick.h): the bench arms, holds the throttle at the entry position, switches the supply on and counts the beeps in the supply current. A run starts only from a red warning held for two seconds, as ARM and the servo's HV warning are, and every move it makes goes out as the MOTOR & ESC screen's commands do, through the arming policy and the output bank
esc_stick_panel_int.h	The seam between the files of ESC STICK's pages
esc_stick_touch.c	The presses on ESC STICK's pages
files_draw.c	FILES' drawing: the two panes with their headers, rows and scroll bars, the message line and the footer, NEW's choice, the DELETE question, the INFO box, the progress box and the keyboard. files_screen.c holds the state; files_int.h is what the screen's three files share
files_events.c	FILES' touch events: the rows, the scroll bars, the headers and the footer of the panes, NEW's choice, the DELETE question, the INFO box, the progress box and the keyboard. files_screen.c holds the state; files_int.h is what the screen's three files share
files_int.h	FILES' private seam between files_screen.c, the state, the requests to the card's task and the screen's interface, files_draw.c, the drawing, and files_events.c, the touch events: the layout the three work on, the state and the functions one calls in another. Nothing outside shared/ui includes this header; the screen's interface is files_screen.h
files_screen.c	FILES: the state, the requests to the card's task, the footer's operations and the screen's interface (files_screen.h). files_draw.c draws the screen, files_events.c takes its touch events, and files_int.h is what the three share
hitec_panel.c	The overlay of the programmer for servos by Hitec: its state, rows, geometry and the caller's side. See hitec_panel.h
hitec_panel_draw.c	The drawing of the Hitec programmer's overlay: the tabs, the rows of the tab shown, its notes and the last message, the list of choices and the hold pages
hitec_panel_edit.c	The actions and editors of the Hitec programmer's overlay: the SERVO tab's buttons, the lists (SERIES, MORE, RESTORE, a value's choices), the keypad of the supply and of a value, and the options kept in the settings. The hold pages are hitec_panel_page.c's
hitec_panel_int.h	The seam between the files of the Hitec programmer's overlay
hitec_panel_page.c	The hold pages of the Hitec programmer's overlay: LEAVE, RELEASE PORT, ENABLE WRITE TO SERVO, WRITE n VALUES, CHECK THIS CHANGE, REPAIR CHECKSUM and RESTORE, what each says before it acts, and what its hold does
hitec_panel_text.c	The texts of the Hitec programmer's overlay: the rows' labels, the values as read, the PORT row, the state line and the messages
hitec_panel_touch.c	The presses on the Hitec programmer's overlay: a DOWN, its moves and its release, CLOSE and the home tag, each frame's hold, and the supply's lock while a port is held
kst_panel.c	The overlay of the programmer for KST and Chaservo servos: its state, rows, shared helpers, geometry and the caller's side
kst_panel_draw.c	The drawing of the programmer's overlay
kst_panel_edit.c	The editors of the programmer's overlay
kst_panel_int.h	The seam between the files of the KST and Chaservo programmer's overlay
kst_panel_run.c	The limit run's sessions on the programmer
kst_panel_text.c	The texts of the programmer's overlay
kst_panel_touch.c	The presses on the programmer's overlay
kst_panel_warn.c	The warning pages of the programmer's overlay
log_select.c	Keeping the entries a bounded list can show, and ordering them for it: LOGS' order over the file manager's page keeping (fm_select.h)
log_text.c	A text file as LOGS shows it. See log_text.h
log_viewer_draw.c	The log viewer's drawing: the browse view with its tabs, list, scroll bar and DELETE question, the import view, and the plot. log_viewer_screen.c holds the state, the card's listing and paging and the screen's interface (log_viewer_screen.h); log_viewer_int.h is what the screen's four files share
log_viewer_events.c	The log viewer's touch events: taps, drags and the scroll bar on the browse view, the DELETE question, the import view's columns and overrides, and the plot's cursor, pinch zoom and pan. log_viewer_screen.c holds the state, the card's listing and paging and the screen's interface (log_viewer_screen.h); log_viewer_int.h is what the screen's four files share
log_viewer_int.h	The log viewer's private seam between log_viewer_screen.c, the state, the card's listing and paging and the screen's interface, log_viewer_load.c, a file's analysis, data and plot traces, log_viewer_draw.c, the drawing, and log_viewer_events.c, the touch events: the layout the four work on, the state, the plot's traces and the functions one calls in another. Nothing outside shared/ui includes this header; the screen's interface is log_viewer_screen.h
log_viewer_load.c	The log viewer's loading: a file the browse view opens is analysed (its delimiter, decimal convention and time column, see shared/logfile), its chosen columns are read, and lv_compute_spans() turns them into the plot's scaled traces; a report is read whole into the TEXT view. log_viewer_screen.c holds the state, the card's listing and paging and the screen's interface (log_viewer_screen.h); log_viewer_int.h is what the screen's four files share
log_viewer_screen.c	The log viewer: browse the card, review the import, plot the file
motor_draw.c	The MOTOR & ESC screen's drawing: the strip row, the rail with the readouts and the CONTROL card, LIVE's plot or table and the throttle, and the page of the task shown. motor_screen.c holds the state, the commands and the screen's interface (motor_screen.h); motor_live_int.h is what it shares with this file and motor_events.c
motor_events.c	The MOTOR & ESC screen's events: a touch on the strip, the rail, LIVE's page and the pages of the other tasks, and the frame's tick. motor_screen.c holds the state, the commands and the screen's interface (motor_screen.h); motor_live_int.h is what it shares with this file and motor_draw.c
motor_live_int.h	The private seam between motor_screen.c, the MOTOR & ESC screen's state, commands and interface, motor_events.c, its touch events and frames, and motor_draw.c, its drawing: LIVE's layout inside motor_screen_int.h's, the channels, the state and the functions one calls in another. The other files of the screen (motor_workbench.c, motor_program_page.c, motor_settings_page.c) keep their own state and do not include this header. Nothing outside shared/ui includes it
motor_program_page.c	MOTOR & ESC's PROGRAM: the registry's list and the output strip over a full-width session
motor_screen.c	The motor and ESC (electronic speed controller) bench screen, a workbench (ui_workbench.h) with the tasks LIVE, PROGRAM and SETTINGS
motor_screen_int.h	The MOTOR & ESC screen's private seam between motor_screen.c, the screen and LIVE's page (with motor_events.c and motor_draw.c, which share its state through motor_live_int.h), motor_workbench.c, its task strip and the CONTROL card's TARGET row, motor_program_page.c, PROGRAM's list and its sessions, and motor_settings_page.c, SETTINGS' page: the layout they draw on and the functions each calls of the others. Nothing outside shared/ui includes this header; the screen's interface is motor_screen.h
motor_settings_page.c	MOTOR & ESC > SETTINGS: the ESC / BENCH category's 8 rows (SET_CAT_ESC), under PACK, MOTOR and THROTTLE OUTPUT. The rows are the settings SETUP listed before they moved here: one home each, the same label, help and value text
motor_workbench.c	MOTOR & ESC as a workbench (ui_workbench.h): the task strip at the top, and the CONTROL card's TARGET row
outputs_port_entry.c	The OUTPUTS screen's PROG PORT entry: the left column under the list when a programming port is picked. See outputs_screen.h
outputs_screen.c	Protocol on the left, pins on the right. See outputs_screen.h
outputs_screen_int.h	What the OUTPUTS screen (outputs_screen.c) and its PROG PORT entry (outputs_port_entry.c, outputs_port.c) share: the left column's layout, the faces they draw in and the entry's hooks
overview_screen.c	The feature menu: a grid of tiles under the band
picker_cat.c	PICK A PIN's cat: the two spots it offers, what keeps a spot clear, the pick on the first frame of a visit, and the drawing with the screen's static parts
picker_draw.c	PICK A PIN's drawing: the board, its buttons and marks, the head with the protocol list's face, the PINS and IN USE tables and the open list. picker_screen.c holds the state, the touch handling and the screen's interface (picker_screen.h); picker_geometry.c says where things sit; picker_screen_int.h is what the three share
picker_geometry.c	PICK A PIN's geometry: the box the board takes, where each pad sits, the buttons above and below the board, the marks inside it, and the protocol list's rows. picker_screen.c holds the state, the touch handling and the screen's interface (picker_screen.h); picker_draw.c draws; picker_screen_int.h is what the three share
picker_port.h
picker_screen.c	PICK A PIN's state, touch handling and interface: the board, with a button on every pin an output may have. See picker_screen.h
picker_screen_int.h	PICK A PIN's private seam between picker_screen.c, the state, the touch handling and the screen's interface, picker_geometry.c, where the board, its pads, buttons and marks and the protocol list sit, and picker_draw.c, the drawing: the layout they work on, the state and the functions one calls in another. Nothing outside shared/ui includes this header; the screen's interface is picker_screen.h
prog_models.c	The modelled ESC (electronic speed controller) and servo protocols: their parameters as data
prog_registry.c	The programmers' registry: the rows of SERVO's and MOTOR & ESC's PROGRAM lists, the list built from them and the view that draws it
sensors_rows.c	SETUP > SENSORS' list. See sensors_rows.h
servo_limit_panel.c	The SERVO screen's limit run: its checks, its steps, the programmer's sessions it asks for, and its box, card and note
servo_screen.c	The servo bench screen
servo_screen_core_int.h	The SERVO screen's seam between its own five files
servo_screen_draw.c	The SERVO screen's drawing
servo_screen_int.h	The SERVO screen's private seam between servo_screen*.c, the screen, servo_workbench.c, its task strip, TEST page and TARGET row (servo_workbench_int.h), servo_settings_panel.c, its settings pages and the panels they open, servo_test_panel.c, its automatic test, and servo_limit_panel.c, its limit run: the layout they draw on, the profiles, the pages' rows and presses, the state they read and write, the functions each calls of the others, and the small helpers they inline. Nothing outside shared/ui includes this header; the screen's interface is servo_screen.h
servo_screen_link.c	What the panel tells the SERVO screen and takes from it
servo_screen_sweep.c	The SERVO screen's sweep core and frame step
servo_screen_touch.c	The SERVO screen's presses, dial and knob
servo_settings_draw.c	The drawing of the SERVO screen's pages of rows and the panels they open: SETTINGS' pages and a run's settings with their notes and the save line, the list, the profile warning, the HV warning and SUPPLY's question about a live output
servo_settings_panel.c	The SERVO screen's pages of rows and the panels they open. SETTINGS, a task of the strip, holds three pages under its own tabs – OUTPUT, SWEEP and DUT: the servo's type, frame rate and pulse widths, the sweep's curve, and the device under test. Each run card on TEST opens its run's settings as one more page, one level down: the automatic test's steps, length, timing and pass/fail limits, and the limit run's mode. The rows open the keypad, the keyboard, the list, the profile warning, the HV warning and SUPPLY's question about a live output, all over the left column. The right card stays where it is and works
servo_test_panel.c	The SERVO screen's automatic test: START TEST, on TEST's AUTOMATIC TEST card, runs it (servo_test.h). This file hands the run the steps, the servo's profile and ends, the meter and the supply's caps; does what the run asks – the servo's position, SUPPLY's set points and output – through the same paths a finger uses; puts SUPPLY's set points back after it; and draws its box on LIVE's card and its button and lines on the AUTOMATIC TEST card. It also serves the card writer the outbox of both runs, the automatic test's first, then the limit run's
servo_workbench.c	The SERVO screen as a workbench (ui_workbench.h): the task strip under the band, TEST's page of run cards, and the output card's TARGET row
servo_workbench_int.h	The SERVO workbench's internals, which servo_screen_int.h takes in at its end: which task and which panel hold the left column, servo_workbench.c's side (the strip, the TARGET row, TEST's page), and the page area and the run cards' geometry. It reads the screen's one state s and the layout of servo_screen_int.h and is not to be included alone
settings_draw.c	SETUP's drawing: the hub's tiles, a category's list and its rows, the SAVE strip under both, and the warning that holds the way out. settings_screen.c holds the state, the touch handling and the screen's interface (settings_screen.h); settings_screen_int.h is what the two share
settings_rows.c	SETUP's list rows: a category's settings in schema order, a heading above each section, a part's heading above its rows on SENSORS, and the category's strings after its settings. SENSORS lists the channel rows of a fitted part only (sensors_rows.h)
settings_rows_int.h	SETUP's list rows: what settings_rows.c, settings_screen.c and settings_draw.c share and nobody else sees. A row is a setting, a heading above the next one, a part's heading on SENSORS (sensors_rows.h), or a string
settings_screen.c	The settings screen: a hub of tiles, and one renderer over the whole schema
settings_screen_int.h	SETUP's private seam between settings_screen.c, the state, the touch handling and the screen's interface, and settings_draw.c, its drawing: the layout both work on, the hub's tiles, the state and the functions one calls in the other. Nothing outside shared/ui includes this header; the screen's interface is settings_screen.h
splash_screen.c	Splash_screen.h says what this screen is for
supply_draw.c	The SUPPLY screen's drawing: the strip row, the rail with the readings and the CONTROL card, LIVE's plot or table and set points, SETTINGS' page and the question. supply_screen.c holds the state, the commands and the screen's interface (supply_screen.h); supply_screen_int.h is what it shares with this file and supply_events.c
supply_events.c	The SUPPLY screen's events: a touch on the strip, the set points, the rail and OUTPUT, SETTINGS' page, the keypad and the question, and the frame's tick. supply_screen.c holds the state, the commands and the screen's interface (supply_screen.h); supply_screen_int.h is what it shares with this file and supply_draw.c
supply_screen.c	The SUPPLY screen. See supply_screen.h. This file holds the state, the commands and the screen's interface; supply_events.c takes the touch events and frames, supply_draw.c draws, and supply_screen_int.h is what the three share
supply_screen_int.h	The SUPPLY screen's private seam between supply_screen.c, the state, the commands and the screen's interface, supply_events.c, its touch events and frames, and supply_draw.c, its drawing: the layout the three work on, the rows of SETTINGS' page, the state and the functions one calls in another. Nothing outside shared/ui includes this header; the screen's interface is supply_screen.h
ui_band.c	The status band: its chips, STOP and the chips' help boxes
ui_cats.c	The pick of a cat among the poses that fit a screen's spots, its drawing, and the random source. See include/ui_cats.h
ui_cats_art.c	The cats' drawings, run-length encoded premultiplied RGB565 with 4-bit alpha (gfx_sprite.h)
ui_icons.c	The menu icons, drawn from primitives rather than stored as bitmaps
ui_keypad.c	The numeric keypad. See ui_keypad.h
ui_pinlist.c	A pin's name and a set of pins as text: see ui_pinlist.h
ui_plot.c	The multi-series plot on one time base. See ui_plot.h
ui_router.c	The screen router: the band, the alert band, and the touches between them and the screens
ui_setting_keypad.c	The numeric keypad for a number of the settings schema. See ui_setting_keypad.h
ui_slider.c	The draggable value with presets. See ui_slider.h
ui_tabs.c	The pane selector: rows of tabs, their touch and their look. See ui_tabs.h
ui_target_row.c	The TARGET row: its box, its touch, its look and its text. See ui_target_row.h
ui_text.c	The string tables and the lookup. See include/ui_text.h
ui_textkey.c	The text keyboard. See ui_textkey.h
ui_watermark.c	The SIMULATION watermark along the canvas diagonal
ui_widgets.c	The shared widgets every screen draws with: panels, cards, buttons, pills
upd_screen.c	Upd_screen.h says what these two screens are for
update_screen.c	PANEL UPDATE, the screen that writes an uploaded or downloaded image: wifi_screen.h says what it is for and declares its interface
wifi_screen.c	WI-FI: wifi_screen.h says what the screen is for. PANEL UPDATE, the screen the same header declares, is update_screen.c
webaccess
include
wa_fetch.h	The panel asking GitHub for its newest release, and fetching it
wa_guard.h	Which requests the Wi-Fi page answers at all: the Host header, the Origin or Referer of a write, the upload's own header and the size of a body
wa_mdns.h	The panel's name on the home network: an mDNS (multicast Domain Name System, RFC 6762) answer for "rcbench-1A2B.local"
wa_page.h	The Wi-Fi page: one HTML (hypertext markup language) page with no scripts or styles from elsewhere, so it works on a phone with no other connection
wa_send.h
wa_session.h	Wi-Fi access: when the panel's radio runs, under which name, and who the page answers
wa_text.h
wa_walk.h	Every file and folder on the card, one at a time
wa_zip.h	The whole card as one ZIP archive, written as it is sent
wa_fetch.c	Wa_fetch.h says what the jobs do; fw_release.h how strictly answers are read
wa_guard.c	Which requests the Wi-Fi page answers. See wa_guard.h
wa_page.c	The Wi-Fi page: the code form, the card listing and the upload answers in English and German. See wa_page.h
wa_session.c	Wi-Fi access. See wa_session.h
wa_walk.c	Walking the card. See wa_walk.h
wa_zip.c	The card as a ZIP archive. See wa_zip.h
testbench
touch-injector
core
include
gt911_emu.h	The register file of a GT911 touch controller as an I2C (Inter-Integrated Circuit) target sees it: the bytes a master writes and reads, one at a time, and the frame handshake. Pure C. The RP2350 build calls the three byte functions from the I2C interrupt; the host suite calls them as a master would
inj_line_id.h	Which of two wires carries SCL, read from I2C (Inter-Integrated Circuit) traffic the injector only listens to. Pure C: the RP2350 build feeds it the edges core 1 recorded on GP4 and GP5, the host suite feeds it synthetic ones
injector.h	The touch injector: a GT911 emulator at 0x14 that presses where a USB (Universal Serial Bus) command line tells it to. Pure C; the RP2350 build (../rp2350) wires it to the I2C (Inter-Integrated Circuit) target, the USB serial port and the status LED, and the host suite drives it as a panel and a host would
gt911_emu.c	The GT911 register file as an I2C target sees it (gt911_emu.h)
injector.c	The touch injector's commands and gestures (injector.h): the line parser, up to INJ_CONTACTS contacts at once, and the frames that carry them to the panel