Files
heltec-repeater/firmware/main/ui.c
T

486 lines
16 KiB
C

// Local status UI: SSD1306 128x64 over I2C + PRG button.
// Implements docs/FUTURE_UI.md within its constraints:
// - separate low-priority task on core 0 (radio task is pinned to core 1);
// rendering can be starved without consequence
// - never touches the SX1262: reads g_stats / g_cfg / g_ui snapshots only
// - GPIO0 (BOOT strap) is sampled only after boot, debounced
// - Vext is driven once at init and never toggled; blanking uses the
// panel's display-off command
// - every button action that changes behaviour emits a JSON event so the
// serial log stays the source of truth
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <inttypes.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_timer.h"
#include "driver/gpio.h"
#include "driver/i2c_master.h"
#include "esp_lcd_panel_io.h"
#include "esp_lcd_panel_ops.h"
#include "esp_lcd_panel_vendor.h"
#include "board.h"
#include "repeater.h"
#include "settings.h"
#include "duty_ledger.h"
#include "wifi_debug.h"
#include "wifi_qr.h"
#include "font5x7.h"
#define UI_W 128
#define UI_H 64
#define UI_COLS 21 // 128 / 6px cell
#define UI_ROWS 8 // 64 / 8px cell
#define UI_PAGES 6
#define UI_TICK_MS 20
#define UI_RENDER_TICKS 25 // 500 ms refresh
#define UI_DEBOUNCE_TICKS 2 // 40 ms
#define UI_LONG_PRESS_MS 1500
#define UI_SLEEP_US (180 * 1000000LL)
#define UI_BEACON_PERIOD_MS 3000 // long-press toggle value; 907 ppm at L=19
static esp_lcd_panel_handle_t s_panel;
static uint8_t s_fb[UI_W * UI_H / 8];
static char s_text[UI_ROWS][UI_COLS + 1];
static int s_page;
static bool s_on = true;
static int64_t s_last_activity;
static uint8_t s_wifi_qr[WIFI_QR_BYTES];
static bool s_qr_ready;
static bool s_show_qr;
static const char *s_settings_error;
static int64_t s_settings_error_until;
static void ui_log(const char *cmd, uint32_t value)
{
printf("{\"event\":\"ui_action\",\"cmd\":\"%s\",\"value\":%" PRIu32 "}\n",
cmd, value);
fflush(stdout);
}
// ------------------------------------------------------------- rendering
static void put(int row, const char *fmt, ...)
{
if (row < 0 || row >= UI_ROWS) return;
char buf[UI_COLS + 1];
va_list ap;
va_start(ap, fmt);
vsnprintf(buf, sizeof(buf), fmt, ap);
va_end(ap);
snprintf(s_text[row], sizeof(s_text[row]), "%s", buf);
}
static void blit(void)
{
memset(s_fb, 0, sizeof(s_fb));
for (int row = 0; row < UI_ROWS; row++) {
for (int col = 0; s_text[row][col] && col < UI_COLS; col++) {
unsigned c = (unsigned char)s_text[row][col];
if (c < FONT5X7_FIRST || c > FONT5X7_LAST) c = '?';
const uint8_t *g = font5x7[c - FONT5X7_FIRST];
uint8_t *dst = &s_fb[row * UI_W + col * 6];
for (int x = 0; x < FONT5X7_W; x++) dst[x] = g[x];
}
}
if (s_show_qr) {
for (int page = 0; page < WIFI_QR_SIDE / 8; page++)
memcpy(&s_fb[page * UI_W], &s_wifi_qr[page * WIFI_QR_SIDE], WIFI_QR_SIDE);
}
esp_lcd_panel_draw_bitmap(s_panel, 0, 0, UI_W, UI_H, s_fb);
}
static void fmt_age(int64_t ts_us, char *out, size_t n)
{
if (ts_us <= 0) {
snprintf(out, n, "--");
return;
}
int64_t s64 = (esp_timer_get_time() - ts_us) / 1000000LL;
unsigned s = s64 < 0 ? 0
: (s64 > 359999 ? 359999u : (unsigned)s64); // cap 99h
if (s < 100) snprintf(out, n, "%us", s);
else if (s < 6000) snprintf(out, n, "%um", s / 60);
else snprintf(out, n, "%uh", s / 3600);
}
static void fmt_uptime(char *out, size_t n)
{
int64_t s64 = esp_timer_get_time() / 1000000LL;
unsigned s = s64 > 3599999 ? 3599999u : (unsigned)s64; // cap 999h
if (s < 3600) snprintf(out, n, "%um%02us", s / 60, s % 60);
else snprintf(out, n, "%uh%02um", s / 3600, (s % 3600) / 60);
}
static const char *tx_result_text(const char *result)
{
if (strcmp(result, "ok") == 0) return "OK";
if (strcmp(result, "ok_polled") == 0) return "OK Abfrage";
if (strcmp(result, "start_failed") == 0) return "Startfehler";
if (strcmp(result, "radio_timeout") == 0) return "Zeitlimit";
if (strcmp(result, "irq_timeout") == 0) return "Kein Ende";
return "Unbekannt";
}
static void page_status(void)
{
char up[12], rx_age[8], tx_age[8];
fmt_uptime(up, sizeof(up));
fmt_age(g_ui.rx_ts_us, rx_age, sizeof(rx_age));
fmt_age(g_ui.tx_ts_us, tx_age, sizeof(tx_age));
put(0, "wM-Bus 868.95 MHz");
put(1, "Seit %-7s Wdh %s", up, g_cfg.repeat_enabled ? "EIN" : "AUS");
put(2, "RX %-5" PRIu32 " GUT %" PRIu32,
g_stats.rx_candidates, g_stats.rx_valid);
put(3, "TX %" PRIu32 "/%" PRIu32 " Test %" PRIu32,
g_stats.tx_success, g_stats.tx_attempts, g_cfg.beacon_period_ms);
if (g_ui.rx_ts_us) {
put(4, "Empf. %ddBm %s", (int)g_ui.rx_rssi_dbm, rx_age);
} else {
put(4, "Empf. --");
}
if (g_ui.tx_ts_us) {
put(5, "TX %s %s", tx_result_text(g_ui.tx_result), tx_age);
} else {
put(5, "TX --");
}
uint64_t budget = (uint64_t)g_cfg.duty_budget_ppm
* DUTY_LEDGER_WINDOW_US / 1000000ULL;
if (budget) {
uint64_t used = repeater_duty_used_us();
unsigned pct = (unsigned)(used * 100 / budget);
if (pct > 100) pct = 100;
char bar[10];
unsigned fill = pct * 9 / 100;
for (unsigned i = 0; i < 9; i++) bar[i] = i < fill ? '#' : ' ';
bar[9] = 0;
put(6, "Sende%3u%% [%s]", pct, bar);
} else {
put(6, "Sendelimit AUS");
}
if (g_ui.hb_ts_us) {
put(7, "Funk %s Konfig %s",
g_ui.chip_mode == 5 ? "RX" : "!!", g_ui.config_intact ? "OK" : "!!");
} else {
put(7, "Funk --");
}
}
static void page_health(void)
{
put(0, "FUNKZUSTAND");
put(1, "Erholt %" PRIu32 " Neu %" PRIu32,
g_stats.recoveries, g_stats.radio_reinit + g_stats.fem_reinit);
put(2, "CRC-Fehl %" PRIu32 " Lng %" PRIu32,
g_stats.rx_crc_fail, g_stats.rx_len_invalid);
put(3, "T1 %" PRIu32 " Kein-C1 %" PRIu32,
g_stats.rx_t1, g_stats.rx_not_c1);
put(4, "Doppelt %" PRIu32 " Limit %" PRIu32,
g_stats.tx_suppressed_dup, g_stats.tx_suppressed_duty);
put(5, "TX-Frist %" PRIu32 " Fehl %" PRIu32,
g_stats.tx_timeout, g_stats.tx_failures);
if (g_ui.hb_ts_us) put(6, "Pegel %ddBm", (int)g_ui.rssi_dbm);
else put(6, "Pegel --");
put(7, "Halten: Zaehler null");
}
static void page_last(void)
{
put(0, "LETZTES TELEGRAMM");
if (!g_ui.rx_ts_us) {
put(1, "Noch kein Empfang");
for (int i = 2; i < UI_ROWS; i++) put(i, "%s", "");
return;
}
char age[8];
fmt_age(g_ui.rx_ts_us, age, sizeof(age));
put(1, "Zaehler %08" PRIX32, g_ui.rx_meter_id);
put(2, "Laenge %d Format %c", (int)g_ui.rx_len, g_ui.rx_format);
put(3, "CRC %s %ddBm",
g_ui.rx_crc_ok ? "OK" : "FALSCH", (int)g_ui.rx_rssi_dbm);
put(4, "Kennwert %08" PRIx32, g_ui.rx_hash);
put(5, "Alter %s", age);
put(6, "TX: %s", g_ui.tx_ts_us ? tx_result_text(g_ui.tx_result) : "--");
put(7, "%s", "");
}
static void page_config(void)
{
put(0, "EINSTELLUNGEN");
put(1, "Warte %" PRIu32 "ms TX %d",
g_cfg.repeat_delay_ms, (int)g_cfg.tx_power_dbm);
put(2, "Funklimit %" PRIu32 "ppm", g_cfg.duty_budget_ppm);
if (g_cfg.beacon_period_ms) put(3, "Testsignal %" PRIu32 "ms", g_cfg.beacon_period_ms);
else put(3, "Testsignal AUS");
put(4, "Wiederholen %s", g_cfg.repeat_enabled ? "EIN" : "AUS");
put(5, "Erlaubte IDs %d", g_cfg.whitelist_len);
put(6, "%s", "");
put(7, "Halten: Test ein/aus");
}
static void page_wifi(void)
{
wifi_debug_status_t wifi;
wifi_debug_status(&wifi);
for (int i = 0; i < UI_ROWS; i++) put(i, "%s", "");
put(0, "WLAN-DIAGNOSE");
switch (wifi.state) {
case WIFI_DEBUG_ON:
put(1, "EIN - kein Internet");
put(2, "%s", wifi.ssid);
put(3, "Passwort %s", wifi.password);
put(4, "http://192.168.4.1");
put(6, "Weiter: WLAN-QR-Code");
put(7, "Halten: WLAN aus");
break;
case WIFI_DEBUG_STARTING:
put(2, "Startet...");
break;
case WIFI_DEBUG_STOPPING:
put(2, "Wird beendet...");
break;
case WIFI_DEBUG_ERROR:
put(2, "Fehler 0x%" PRIX32, (uint32_t)wifi.error);
put(7, "Halten: Neu versuchen");
break;
default:
put(2, "AUS");
put(4, "Diagnose per Handy");
put(7, "Halten: WLAN ein");
break;
}
}
static void page_wifi_qr(void)
{
wifi_debug_status_t wifi;
wifi_debug_status(&wifi);
if (wifi.state != WIFI_DEBUG_ON) {
page_wifi();
return;
}
// Credentials are generated once and cannot change through the UI/API.
if (!s_qr_ready) s_qr_ready = wifi_qr_bitmap(wifi.ssid, wifi.password, s_wifi_qr);
if (!s_qr_ready) {
page_wifi();
put(6, "QR defekt: Passwort");
return;
}
for (int i = 0; i < UI_ROWS; i++) put(i, "%s", "");
put(0, " WLAN: QR");
put(1, " scannen");
put(3, " Oeffnen:");
put(4, " 192.168.");
put(5, " 4.1");
put(7, " Halten:AUS");
s_show_qr = true;
}
static void render(void)
{
s_show_qr = false;
switch (s_page) {
case 0: page_status(); break;
case 1: page_health(); break;
case 2: page_last(); break;
case 3: page_config(); break;
case 4: page_wifi(); break;
default: page_wifi_qr(); break;
}
if (s_settings_error && esp_timer_get_time() < s_settings_error_until)
put(6, "%s", s_settings_error);
blit();
}
// --------------------------------------------------------------- actions
static void toggle_setting(settings_key_t key)
{
settings_result_t result = SETTINGS_CONFLICT;
settings_change_t change = {.key = key};
// Toggle the accepted state, not g_cfg (which may still be pending).
// Revision CAS prevents an intervening web/USB edit from being overwritten.
for (unsigned attempt = 0; attempt < 3; attempt++) {
settings_snapshot_t snapshot;
settings_get_snapshot(&snapshot);
change.value = key == SETTINGS_REPEAT_ENABLED
? !snapshot.values.repeat_enabled
: (snapshot.values.beacon_period_ms ? 0 : UI_BEACON_PERIOD_MS);
result = settings_update(&change, snapshot.revision, NULL);
if (result != SETTINGS_CONFLICT) break;
}
const char *command = key == SETTINGS_REPEAT_ENABLED
? "set repeat_enabled" : "set beacon_period_ms";
if (result == SETTINGS_OK) {
s_settings_error = NULL;
ui_log(command, (uint32_t)change.value);
return;
}
switch (result) {
case SETTINGS_CONFLICT: s_settings_error = "Geaendert: neu halten"; break;
case SETTINGS_STORAGE_ERROR: s_settings_error = "Speichern gescheitert"; break;
case SETTINGS_INVALID: s_settings_error = "Wert ungueltig"; break;
default: s_settings_error = "Belegt: neu halten"; break;
}
s_settings_error_until = esp_timer_get_time() + 5000000LL;
printf("{\"event\":\"ui_action\",\"cmd\":\"%s\",\"ok\":false,\"error\":\"%s\"}\n",
command, s_settings_error);
fflush(stdout);
}
static void long_action(void)
{
switch (s_page) {
case 0:
toggle_setting(SETTINGS_REPEAT_ENABLED);
break;
case 1:
memset(&g_stats, 0, sizeof(g_stats));
ui_log("clear_stats", 1);
break;
case 3:
toggle_setting(SETTINGS_BEACON_PERIOD_MS);
break;
case 4:
case 5:
ui_log("wifi_debug_toggle", 1);
wifi_debug_toggle();
break;
default:
break;
}
}
static void set_display(bool on)
{
if (on == s_on) return;
s_on = on;
esp_lcd_panel_disp_on_off(s_panel, on);
}
// ------------------------------------------------------------ bring-up
static bool hw_init(void)
{
// External rail on (active low), then let it settle before touching
// the panel. Never toggled again (docs/FUTURE_UI.md constraint 4).
gpio_config_t vext = {
.pin_bit_mask = 1ULL << BOARD_VEXT,
.mode = GPIO_MODE_OUTPUT,
};
if (gpio_config(&vext) != ESP_OK) return false;
gpio_set_level(BOARD_VEXT, 0);
vTaskDelay(pdMS_TO_TICKS(100));
gpio_config_t btn = {
.pin_bit_mask = 1ULL << BOARD_BTN_PRG,
.mode = GPIO_MODE_INPUT,
.pull_up_en = GPIO_PULLUP_ENABLE,
};
if (gpio_config(&btn) != ESP_OK) return false;
i2c_master_bus_config_t bus_cfg = {
.i2c_port = I2C_NUM_0,
.sda_io_num = BOARD_OLED_SDA,
.scl_io_num = BOARD_OLED_SCL,
.clk_source = I2C_CLK_SRC_DEFAULT,
.glitch_ignore_cnt = 7,
.flags.enable_internal_pullup = true,
};
i2c_master_bus_handle_t bus;
if (i2c_new_master_bus(&bus_cfg, &bus) != ESP_OK) return false;
esp_lcd_panel_io_i2c_config_t io_cfg = {
.dev_addr = 0x3C,
.scl_speed_hz = 400000,
.control_phase_bytes = 1,
.lcd_cmd_bits = 8,
.lcd_param_bits = 8,
.dc_bit_offset = 6,
};
esp_lcd_panel_io_handle_t io;
if (esp_lcd_new_panel_io_i2c(bus, &io_cfg, &io) != ESP_OK) return false;
esp_lcd_panel_ssd1306_config_t ssd_cfg = { .height = UI_H };
esp_lcd_panel_dev_config_t panel_cfg = {
.bits_per_pixel = 1,
.reset_gpio_num = BOARD_OLED_RST,
.vendor_config = &ssd_cfg,
};
if (esp_lcd_new_panel_ssd1306(io, &panel_cfg, &s_panel) != ESP_OK) return false;
if (esp_lcd_panel_reset(s_panel) != ESP_OK) return false;
if (esp_lcd_panel_init(s_panel) != ESP_OK) return false;
// Heltec mounts the module rotated 180 degrees; matches the vendor
// examples' flipScreenVertically().
esp_lcd_panel_mirror(s_panel, true, true);
return esp_lcd_panel_disp_on_off(s_panel, true) == ESP_OK;
}
// ---------------------------------------------------------------- task
static void ui_task(void *arg)
{
(void)arg;
// The radio task owns boot; give it time to bring the RF path up
// before the I2C bus starts drawing current and printing.
vTaskDelay(pdMS_TO_TICKS(500));
bool ok = hw_init();
printf("{\"event\":\"ui_init\",\"ok\":%s}\n", ok ? "true" : "false");
fflush(stdout);
if (!ok) vTaskDelete(NULL);
s_last_activity = esp_timer_get_time();
int render_div = 0;
int held_ticks = 0;
bool long_fired = false;
bool was_off_at_press = false;
render();
for (;;) {
vTaskDelay(pdMS_TO_TICKS(UI_TICK_MS));
bool pressed = gpio_get_level(BOARD_BTN_PRG) == 0;
if (pressed) {
if (held_ticks == 0) was_off_at_press = !s_on;
held_ticks++;
if (!long_fired
&& held_ticks * UI_TICK_MS >= UI_LONG_PRESS_MS) {
long_fired = true;
s_last_activity = esp_timer_get_time();
set_display(true);
if (!was_off_at_press) long_action();
render();
}
} else {
if (held_ticks >= UI_DEBOUNCE_TICKS && !long_fired) {
s_last_activity = esp_timer_get_time();
if (s_on && !was_off_at_press) {
s_page = (s_page + 1) % UI_PAGES;
}
set_display(true);
render();
}
held_ticks = 0;
long_fired = false;
}
if (s_on && esp_timer_get_time() - s_last_activity > UI_SLEEP_US) {
set_display(false);
}
if (s_on && ++render_div >= UI_RENDER_TICKS) {
render_div = 0;
render();
}
}
}
void ui_start(void)
{
xTaskCreatePinnedToCore(ui_task, "ui", 4096, NULL, 3, NULL, 0);
}