// 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 #include #include #include #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); }