From 5b46f647f66b05426b9133200e70c21b9bf9eccb Mon Sep 17 00:00:00 2001 From: Lars Nolden Date: Mon, 31 Aug 2026 22:16:35 +0200 Subject: [PATCH] firmware: SX1262 GFSK wM-Bus C1 repeater, dev tooling, discovery scripts --- .gitignore | 6 + firmware/CMakeLists.txt | 3 + firmware/main/CMakeLists.txt | 9 + firmware/main/board.h | 36 +++ firmware/main/console.c | 112 +++++++++ firmware/main/main.c | 17 ++ firmware/main/repeater.c | 437 +++++++++++++++++++++++++++++++++ firmware/main/repeater.h | 41 ++++ firmware/main/sx126x.c | 454 +++++++++++++++++++++++++++++++++++ firmware/main/sx126x.h | 59 +++++ firmware/main/wmbus.c | 135 +++++++++++ firmware/main/wmbus.h | 37 +++ firmware/sdkconfig.defaults | 21 ++ flake.lock | 97 ++++++++ flake.nix | 3 +- tools/discover_devices.sh | 44 ++++ tools/flash.sh | 11 + tools/reset_dut.sh | 7 + 18 files changed, 1528 insertions(+), 1 deletion(-) create mode 100644 .gitignore create mode 100644 firmware/CMakeLists.txt create mode 100644 firmware/main/CMakeLists.txt create mode 100644 firmware/main/board.h create mode 100644 firmware/main/console.c create mode 100644 firmware/main/main.c create mode 100644 firmware/main/repeater.c create mode 100644 firmware/main/repeater.h create mode 100644 firmware/main/sx126x.c create mode 100644 firmware/main/sx126x.h create mode 100644 firmware/main/wmbus.c create mode 100644 firmware/main/wmbus.h create mode 100644 firmware/sdkconfig.defaults create mode 100644 flake.lock create mode 100755 tools/discover_devices.sh create mode 100755 tools/flash.sh create mode 100755 tools/reset_dut.sh diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..6e6cccf --- /dev/null +++ b/.gitignore @@ -0,0 +1,6 @@ +captures/ +logs/ +result* +firmware/build/ +firmware/sdkconfig +__pycache__/ diff --git a/firmware/CMakeLists.txt b/firmware/CMakeLists.txt new file mode 100644 index 0000000..fac6415 --- /dev/null +++ b/firmware/CMakeLists.txt @@ -0,0 +1,3 @@ +cmake_minimum_required(VERSION 3.16) +include($ENV{IDF_PATH}/tools/cmake/project.cmake) +project(wmbus_repeater) diff --git a/firmware/main/CMakeLists.txt b/firmware/main/CMakeLists.txt new file mode 100644 index 0000000..f6e9daf --- /dev/null +++ b/firmware/main/CMakeLists.txt @@ -0,0 +1,9 @@ +idf_component_register( + SRCS + "main.c" + "sx126x.c" + "wmbus.c" + "repeater.c" + "console.c" + INCLUDE_DIRS "." +) diff --git a/firmware/main/board.h b/firmware/main/board.h new file mode 100644 index 0000000..a448ce3 --- /dev/null +++ b/firmware/main/board.h @@ -0,0 +1,36 @@ +// Heltec WiFi LoRa 32 V4.3 (HTIT-WB32LAF) board definition. +// +// Sources: +// - Heltec wiki "WiFi LoRa 32 V4" product page (USE_KCT8103L_PA for V4.3) +// - Heltec schematic HTIT-WB32LAF_V4.3.pdf +// - RNode_Firmware 1.86 / RTNode-HeltecV4 Boards.h + sx126x.cpp +// (experimentally proven working configuration for this exact board) +// +// See docs/HARDWARE.md for the full evidence trail. +#pragma once + +// SX1262 SPI + control +#define BOARD_LORA_NSS 8 +#define BOARD_LORA_SCK 9 +#define BOARD_LORA_MOSI 10 +#define BOARD_LORA_MISO 11 +#define BOARD_LORA_RESET 12 +#define BOARD_LORA_BUSY 13 +#define BOARD_LORA_DIO1 14 + +// KCT8103L RF front-end (V4.3) +// PWR_EN : FEM supply enable, drive HIGH +// CSD : chip enable, drive HIGH (has internal pull-up on KCT8103L, +// which is how RNode 1.86 auto-detects V4.3 vs V4.2/GC1109) +// CTX : path select, LOW = RX/LNA, HIGH = TX/PA +// CPS : wired to SX1262 DIO2 (DIO2-as-RF-switch must be enabled) +#define BOARD_FEM_PWR_EN 7 +#define BOARD_FEM_CSD 2 +#define BOARD_FEM_CTX 5 + +// SX1262 TCXO: DIO3-controlled, 1.8 V (RNode 1.86 value for this board) +#define BOARD_TCXO_VOLTAGE_CODE 0x02 // MODE_TCXO_1_8V +#define BOARD_TCXO_DELAY_STEPS 0xFF // x 15.625 us ~= 4 ms + +// Overcurrent protection value from RNode 1.86 ("OCP_TUNED 0x28") +#define BOARD_SX1262_OCP 0x28 diff --git a/firmware/main/console.c b/firmware/main/console.c new file mode 100644 index 0000000..be5cd0c --- /dev/null +++ b/firmware/main/console.c @@ -0,0 +1,112 @@ +// Line-based scriptable serial console on USB-Serial-JTAG. +// Commands (one per line): +// status | stats | clear_stats | radio_status | radio_reset | test_tx +// set repeat_delay_ms N | set tx_power N | set repeat_enabled 0|1 +// set verbose 0|1 | set whitelist ID[,ID...] | set whitelist clear +// reboot +#include +#include +#include +#include "freertos/FreeRTOS.h" +#include "freertos/task.h" +#include "esp_system.h" +#include "driver/usb_serial_jtag.h" +#include "driver/usb_serial_jtag_vfs.h" + +#include "repeater.h" + +static void ack(const char *cmd, bool ok, const char *detail) +{ + printf("{\"event\":\"cmd_ack\",\"cmd\":\"%s\",\"ok\":%s%s%s%s}\n", + cmd, ok ? "true" : "false", + detail ? ",\"detail\":\"" : "", detail ? detail : "", detail ? "\"" : ""); + fflush(stdout); +} + +static void handle_set(char *args) +{ + char *key = strtok(args, " "); + char *val = strtok(NULL, " "); + if (!key || !val) { ack("set", false, "usage"); return; } + + if (strcmp(key, "repeat_delay_ms") == 0) { + long v = strtol(val, NULL, 10); + if (v < 20 || v > 200) { ack("set", false, "range 20..200"); return; } + g_cfg.repeat_delay_ms = (uint32_t)v; + ack("set repeat_delay_ms", true, NULL); + } else if (strcmp(key, "tx_power") == 0) { + long v = strtol(val, NULL, 10); + if (v < -9 || v > 14) { ack("set", false, "range -9..14"); return; } + g_cfg.tx_power_dbm = (int8_t)v; + repeater_request_radio_reset(); + ack("set tx_power", true, "radio reinit queued"); + } else if (strcmp(key, "repeat_enabled") == 0) { + g_cfg.repeat_enabled = (val[0] == '1'); + ack("set repeat_enabled", true, NULL); + } else if (strcmp(key, "verbose") == 0) { + g_cfg.verbose = (val[0] == '1'); + ack("set verbose", true, NULL); + } else if (strcmp(key, "whitelist") == 0) { + if (strcmp(val, "clear") == 0) { + g_cfg.whitelist_len = 0; + ack("set whitelist", true, "cleared"); + return; + } + int n = 0; + for (char *tok = strtok(val, ","); tok && n < 8; tok = strtok(NULL, ",")) { + // meter ID as printed (BCD hex digits) -> stored LE uint32 + uint32_t id = (uint32_t)strtoul(tok, NULL, 16); + g_cfg.whitelist[n++] = id; + } + g_cfg.whitelist_len = n; + ack("set whitelist", true, NULL); + } else { + ack("set", false, "unknown key"); + } +} + +static void console_task(void *arg) +{ + (void)arg; + char line[256]; + for (;;) { + if (!fgets(line, sizeof(line), stdin)) { + vTaskDelay(pdMS_TO_TICKS(50)); + continue; + } + line[strcspn(line, "\r\n")] = 0; + if (line[0] == 0) continue; + + if (strcmp(line, "status") == 0) repeater_print_status(); + else if (strcmp(line, "stats") == 0) repeater_print_stats(); + else if (strcmp(line, "clear_stats") == 0) { + memset(&g_stats, 0, sizeof(g_stats)); + ack("clear_stats", true, NULL); + } + else if (strcmp(line, "radio_status") == 0) repeater_print_radio_status(); + else if (strcmp(line, "radio_reset") == 0) { + repeater_request_radio_reset(); + ack("radio_reset", true, "queued"); + } + else if (strcmp(line, "test_tx") == 0) { + repeater_request_test_tx(); + ack("test_tx", true, "queued"); + } + else if (strncmp(line, "set ", 4) == 0) handle_set(line + 4); + else if (strcmp(line, "reboot") == 0) { + ack("reboot", true, NULL); + vTaskDelay(pdMS_TO_TICKS(100)); + esp_restart(); + } + else ack(line, false, "unknown command"); + } +} + +void console_start(void) +{ + // Blocking stdin via USB-Serial-JTAG driver + usb_serial_jtag_driver_config_t cfg = USB_SERIAL_JTAG_DRIVER_CONFIG_DEFAULT(); + usb_serial_jtag_driver_install(&cfg); + usb_serial_jtag_vfs_use_driver(); + xTaskCreate(console_task, "console", 4096, NULL, 5, NULL); +} diff --git a/firmware/main/main.c b/firmware/main/main.c new file mode 100644 index 0000000..1b03a47 --- /dev/null +++ b/firmware/main/main.c @@ -0,0 +1,17 @@ +// Experimental Wireless M-Bus C1 repeater for Heltec WiFi LoRa 32 V4.3. +// See docs/ for hardware evidence, RF configuration, and standards gaps. +#include +#include "esp_system.h" +#include "esp_timer.h" +#include "repeater.h" + +void console_start(void); + +void app_main(void) +{ + printf("{\"event\":\"boot\",\"fw\":\"wmbus-repeater\",\"version\":\"%s %s\"," + "\"reset_reason\":%d}\n", __DATE__, __TIME__, (int)esp_reset_reason()); + fflush(stdout); + console_start(); + repeater_start(); +} diff --git a/firmware/main/repeater.c b/firmware/main/repeater.c new file mode 100644 index 0000000..6804bc3 --- /dev/null +++ b/firmware/main/repeater.c @@ -0,0 +1,437 @@ +#include "repeater.h" +#include "sx126x.h" +#include "wmbus.h" +#include "board.h" + +#include +#include +#include +#include "freertos/FreeRTOS.h" +#include "freertos/task.h" +#include "esp_timer.h" +#include "esp_task_wdt.h" +#include "esp_system.h" + +#define RX_PAYLOAD_LEN 255 // fixed radio capture length; truncated in software +#define US_PER_BYTE 80 // 100 kbps -> 80 us per byte +#define DUP_WINDOW_US 2500000LL +#define DUP_RING 8 + +repeater_cfg_t g_cfg = { + .repeat_delay_ms = 50, + .tx_power_dbm = -9, + .repeat_enabled = true, + .verbose = false, + .whitelist = {0}, + .whitelist_len = 0, +}; +repeater_stats_t g_stats; + +static TaskHandle_t s_task; +static volatile int64_t s_irq_ts; +static volatile bool s_want_radio_reset; +static volatile bool s_want_test_tx; +static uint8_t s_test_access_nr; +static uint32_t s_seq; + +static struct { uint32_t hash; int64_t ts; } s_dup[DUP_RING]; +static int s_dup_idx; + +// ------------------------------------------------------------------ logging + +static void print_hex(const uint8_t *d, int n) +{ + for (int i = 0; i < n; i++) printf("%02X", d[i]); +} + +#define LOGJ(fmt, ...) do { \ + printf("{\"seq\":%" PRIu32 "," fmt "}\n", s_seq++, ##__VA_ARGS__); \ + fflush(stdout); \ + } while (0) + +// ------------------------------------------------------------------ radio + +static void irq_cb(int64_t ts) +{ + s_irq_ts = ts; + BaseType_t hp = pdFALSE; + if (s_task) vTaskNotifyGiveFromISR(s_task, &hp); + portYIELD_FROM_ISR(hp); +} + +static bool radio_full_init(void) +{ + sx126x_diag_t diag; + bool ok = sx126x_init(&diag); + bool cfg_ok = ok && sx126x_config_wmbus_c1(868950000u, RX_PAYLOAD_LEN) + && sx126x_set_tx_power(g_cfg.tx_power_dbm); + LOGJ("\"event\":\"radio_init\",\"spi\":%s,\"reset\":%s,\"busy_low\":%s," + "\"tcxo\":%s,\"device_errors\":%u,\"chip_mode\":%u," + "\"fem_power\":true,\"fem_mode\":\"rx\",\"frequency_hz\":868950000," + "\"configured_tx_dbm\":%d,\"result\":\"%s\"", + diag.spi_ok ? "true" : "false", + diag.reset_ok ? "true" : "false", + diag.busy_ok ? "true" : "false", + diag.tcxo_ok ? "true" : "false", + diag.device_errors, diag.chip_mode, + (int)g_cfg.tx_power_dbm, + cfg_ok ? "ok" : "fail"); + return cfg_ok; +} + +// Recovery ladder: 1 clear/restart RX, 2 radio reinit, 3 FEM+radio reinit, +// 4 reboot. Returns true if RX was restored. +static bool recover(const char *reason, int level) +{ + g_stats.recoveries++; + bool ok = false; + switch (level) { + case 1: + sx126x_clear_irq(SX126X_IRQ_ALL); + sx126x_standby(); + sx126x_restore_rx_payload_len(); + ok = sx126x_set_rx(); + break; + case 2: + g_stats.radio_reinit++; + ok = radio_full_init() && sx126x_set_rx(); + break; + case 3: + g_stats.fem_reinit++; + fem_power(false); + vTaskDelay(pdMS_TO_TICKS(20)); + ok = radio_full_init() && sx126x_set_rx(); + break; + default: + LOGJ("\"event\":\"radio_recovery\",\"reason\":\"%s\",\"level\":%d," + "\"result\":\"mcu_reset\"", reason, level); + fflush(stdout); + vTaskDelay(pdMS_TO_TICKS(100)); + esp_restart(); + } + LOGJ("\"event\":\"radio_recovery\",\"reason\":\"%s\",\"level\":%d," + "\"result\":\"%s\"", reason, level, ok ? "rx_restored" : "failed"); + return ok; +} + +static void recover_ladder(const char *reason) +{ + for (int level = 1; level <= 4; level++) { + if (recover(reason, level)) return; + } +} + +// ------------------------------------------------------------------ helpers + +static bool is_dup(uint32_t hash, int64_t now) +{ + for (int i = 0; i < DUP_RING; i++) { + if (s_dup[i].hash == hash && now - s_dup[i].ts < DUP_WINDOW_US) return true; + } + return false; +} + +static void remember_dup(uint32_t hash, int64_t now) +{ + s_dup[s_dup_idx].hash = hash; + s_dup[s_dup_idx].ts = now; + s_dup_idx = (s_dup_idx + 1) % DUP_RING; +} + +static bool whitelist_pass(const uint8_t *frame) +{ + if (g_cfg.whitelist_len == 0) return true; + // A-field ID: frame bytes 4..7 (after L, C, M) little endian + uint32_t id = (uint32_t)frame[4] | ((uint32_t)frame[5] << 8) | + ((uint32_t)frame[6] << 16) | ((uint32_t)frame[7] << 24); + for (int i = 0; i < g_cfg.whitelist_len; i++) { + if (g_cfg.whitelist[i] == id) return true; + } + return false; +} + +// Wait for DIO1 with timeout; returns IRQ mask (0 on timeout). +static uint16_t wait_irq(uint32_t timeout_ms) +{ + if (ulTaskNotifyTake(pdTRUE, pdMS_TO_TICKS(timeout_ms)) == 0) return 0; + uint16_t irq = sx126x_get_irq(); + sx126x_clear_irq(irq); + return irq; +} + +static void precise_delay_until(int64_t target_us) +{ + int64_t now = esp_timer_get_time(); + int64_t remaining = target_us - now; + if (remaining > 2000) vTaskDelay(pdMS_TO_TICKS((remaining - 1000) / 1000)); + while (esp_timer_get_time() < target_us) { /* spin <=~1ms */ } +} + +// ------------------------------------------------------------------ TX + +// Transmit mode bytes + frame. Returns result string for logging. +static const char *do_tx(const uint8_t *payload, int payload_len, + int64_t *tx_start_us, int64_t *tx_done_us) +{ + g_stats.tx_attempts++; + *tx_start_us = esp_timer_get_time(); + if (!sx126x_start_tx(payload, (uint8_t)payload_len)) { + g_stats.tx_failures++; + return "start_failed"; + } + // airtime: 48 bit preamble + 16 bit sync + payload -> ~80us/byte + 640 + uint32_t airtime_ms = (payload_len * US_PER_BYTE + 640) / 1000; + uint16_t irq = wait_irq(airtime_ms + 200); + *tx_done_us = s_irq_ts; + fem_set_tx(false); + if (irq & SX126X_IRQ_TX_DONE) { + g_stats.tx_success++; + return "ok"; + } + if (irq & SX126X_IRQ_TIMEOUT) { + g_stats.tx_timeout++; + return "radio_timeout"; + } + g_stats.tx_timeout++; + return "irq_timeout"; +} + +static void log_tx(const char *result, uint32_t hash, int len, + int64_t rx_ts, int64_t tx_start, int64_t tx_done) +{ + LOGJ("\"event\":\"wmbus_tx\",\"timestamp_us\":%lld," + "\"source_rx_timestamp_us\":%lld,\"delay_us\":%lld," + "\"length\":%d,\"hash\":\"%08" PRIx32 "\"," + "\"configured_tx_dbm\":%d,\"airtime_us\":%lld,\"result\":\"%s\"", + (long long)tx_start, (long long)rx_ts, + (long long)(tx_start - rx_ts), len, hash, + (int)g_cfg.tx_power_dbm, + (long long)(tx_done > tx_start ? tx_done - tx_start : 0), result); +} + +static void run_test_tx(void) +{ + uint8_t frame[64]; + int n = wmbus_build_test_frame(frame, sizeof(frame) - 2, s_test_access_nr++); + if (n < 0) return; + uint8_t payload[66]; + payload[0] = WMBUS_MODE_BYTE_A_HI; + payload[1] = WMBUS_MODE_BYTE_A_LO; + memcpy(payload + 2, frame, n); + uint32_t hash = wmbus_hash(frame, n); + + int64_t t0, t1; + const char *res = do_tx(payload, n + 2, &t0, &t1); + log_tx(res, hash, n, t0, t0, t1); + printf("{\"seq\":%" PRIu32 ",\"event\":\"test_tx_frame\",\"raw\":\"", s_seq++); + print_hex(frame, n); + printf("\"}\n"); + fflush(stdout); + + sx126x_restore_rx_payload_len(); + if (!sx126x_set_rx()) recover_ladder("test_tx_rx_restore"); +} + +// ------------------------------------------------------------------ RX path + +static void handle_rx(int64_t rxdone_ts) +{ + static uint8_t buf[RX_PAYLOAD_LEN]; + int8_t rssi = 0; + int n = sx126x_read_rx(buf, sizeof(buf), &rssi); + if (n < 3) { + recover_ladder("rx_read_failed"); + return; + } + g_stats.rx_candidates++; + g_stats.rx_bytes += n; + + wmbus_frame_fmt_t fmt = wmbus_frame_format(buf[0], buf[1]); + if (fmt == WMBUS_FRAME_UNKNOWN) { + g_stats.rx_not_c1++; + if (g_cfg.verbose) { + LOGJ("\"event\":\"wmbus_rx_drop\",\"reason\":\"not_c1\"," + "\"mode_bytes\":\"%02X%02X\",\"rssi_dbm\":%d", buf[0], buf[1], rssi); + } + return; + } + + int total = wmbus_frame_total_len(fmt, buf[2]); + if (total < 0 || total + 2 > n) { + g_stats.rx_len_invalid++; + if (g_cfg.verbose) { + LOGJ("\"event\":\"wmbus_rx_drop\",\"reason\":\"bad_length\"," + "\"lfield\":%u,\"rssi_dbm\":%d", buf[2], rssi); + } + return; + } + + const uint8_t *frame = buf + 2; + bool crc_ok = wmbus_check_crc(fmt, frame, total); + if (crc_ok) g_stats.rx_valid++; else g_stats.rx_crc_fail++; + + uint32_t hash = wmbus_hash(frame, total); + // RxDone fires after the fixed 255-byte capture; the frame actually + // ended earlier. Reconstruct the real end-of-frame time. + int64_t frame_end_ts = rxdone_ts - (int64_t)(RX_PAYLOAD_LEN - (total + 2)) * US_PER_BYTE; + + printf("{\"seq\":%" PRIu32 ",\"event\":\"wmbus_rx\",\"timestamp_us\":%lld," + "\"rxdone_us\":%lld,\"frequency_hz\":868950000,\"format\":\"%c\"," + "\"length\":%d,\"rssi_dbm\":%d,\"crc_ok\":%s," + "\"hash\":\"%08" PRIx32 "\",\"raw\":\"", + s_seq++, (long long)frame_end_ts, (long long)rxdone_ts, + fmt == WMBUS_FRAME_A ? 'A' : 'B', total, rssi, + crc_ok ? "true" : "false", hash); + print_hex(frame, total); + printf("\"}\n"); + fflush(stdout); + + if (!g_cfg.repeat_enabled || !crc_ok) return; + if (!whitelist_pass(frame)) { + g_stats.tx_suppressed_whitelist++; + return; + } + int64_t now = esp_timer_get_time(); + if (is_dup(hash, now)) { + g_stats.tx_suppressed_dup++; + if (g_cfg.verbose) { + LOGJ("\"event\":\"tx_suppressed\",\"reason\":\"dup\",\"hash\":\"%08" PRIx32 "\"", hash); + } + return; + } + + // ---- repeat ---- + static uint8_t txbuf[RX_PAYLOAD_LEN + 2]; + txbuf[0] = buf[0]; + txbuf[1] = buf[1]; + memcpy(txbuf + 2, frame, total); + + precise_delay_until(frame_end_ts + (int64_t)g_cfg.repeat_delay_ms * 1000); + + int64_t t0, t1; + const char *res = do_tx(txbuf, total + 2, &t0, &t1); + remember_dup(hash, esp_timer_get_time()); + log_tx(res, hash, total, frame_end_ts, t0, t1); + + // Always return to RX + sx126x_restore_rx_payload_len(); + if (!sx126x_set_rx()) { + recover_ladder("post_tx_rx_restore"); + } else { + int64_t rx_ready = esp_timer_get_time(); + if (g_cfg.verbose) { + LOGJ("\"event\":\"rx_ready\",\"timestamp_us\":%lld," + "\"deaf_time_us\":%lld", + (long long)rx_ready, (long long)(rx_ready - frame_end_ts)); + } + } +} + +// ------------------------------------------------------------------ task + +static void repeater_task(void *arg) +{ + (void)arg; + s_task = xTaskGetCurrentTaskHandle(); + esp_task_wdt_add(NULL); + + if (!radio_full_init()) { + // keep retrying with full ladder rather than dying + recover_ladder("boot_init_failed"); + } + if (!sx126x_set_rx()) recover_ladder("boot_rx_failed"); + + int64_t last_heartbeat = 0; + for (;;) { + esp_task_wdt_reset(); + + if (s_want_radio_reset) { + s_want_radio_reset = false; + g_stats.radio_reinit++; + if (!radio_full_init() || !sx126x_set_rx()) recover_ladder("manual_reset"); + } + if (s_want_test_tx) { + s_want_test_tx = false; + run_test_tx(); + } + + if (ulTaskNotifyTake(pdTRUE, pdMS_TO_TICKS(1000)) > 0) { + uint16_t irq = sx126x_get_irq(); + sx126x_clear_irq(irq); + if (irq & SX126X_IRQ_RX_DONE) handle_rx(s_irq_ts); + // TIMEOUT in RX continuous should not happen; TX_DONE is consumed + // by do_tx's wait_irq. Anything unexpected: just note it. + if (g_cfg.verbose && (irq & ~(SX126X_IRQ_RX_DONE))) { + LOGJ("\"event\":\"irq_other\",\"mask\":%u", irq); + } + } + + int64_t now = esp_timer_get_time(); + if (now - last_heartbeat > 10000000LL) { + last_heartbeat = now; + // consistency probe: chip should be in RX (0x5) + uint8_t st = sx126x_get_status(); + uint8_t mode = (st >> 4) & 0x7; + LOGJ("\"event\":\"heartbeat\",\"uptime_us\":%lld,\"chip_mode\":%u," + "\"rssi_dbm\":%d", (long long)now, mode, sx126x_get_rssi_inst()); + if (mode != 0x5) { + recover_ladder("not_in_rx"); + } + } + } +} + +void repeater_start(void) +{ + xTaskCreatePinnedToCore(repeater_task, "repeater", 8192, NULL, 10, NULL, 1); +} + +void repeater_request_radio_reset(void) { s_want_radio_reset = true; } +void repeater_request_test_tx(void) { s_want_test_tx = true; } + +// ------------------------------------------------------------------ status + +void repeater_print_status(void) +{ + LOGJ("\"event\":\"status\",\"uptime_us\":%lld," + "\"repeat_delay_ms\":%" PRIu32 ",\"configured_tx_dbm\":%d," + "\"repeat_enabled\":%s,\"verbose\":%s,\"whitelist_len\":%d," + "\"reset_reason\":%d", + (long long)esp_timer_get_time(), + g_cfg.repeat_delay_ms, (int)g_cfg.tx_power_dbm, + g_cfg.repeat_enabled ? "true" : "false", + g_cfg.verbose ? "true" : "false", + g_cfg.whitelist_len, + (int)esp_reset_reason()); +} + +void repeater_print_stats(void) +{ + LOGJ("\"event\":\"stats\",\"uptime_us\":%lld," + "\"rx_candidates\":%" PRIu32 ",\"rx_valid\":%" PRIu32 "," + "\"rx_crc_fail\":%" PRIu32 ",\"rx_not_c1\":%" PRIu32 "," + "\"rx_len_invalid\":%" PRIu32 ",\"rx_bytes\":%" PRIu32 "," + "\"tx_attempts\":%" PRIu32 ",\"tx_success\":%" PRIu32 "," + "\"tx_timeout\":%" PRIu32 ",\"tx_failures\":%" PRIu32 "," + "\"tx_suppressed_dup\":%" PRIu32 ",\"tx_suppressed_whitelist\":%" PRIu32 "," + "\"radio_reinit\":%" PRIu32 ",\"fem_reinit\":%" PRIu32 "," + "\"recoveries\":%" PRIu32, + (long long)esp_timer_get_time(), + g_stats.rx_candidates, g_stats.rx_valid, g_stats.rx_crc_fail, + g_stats.rx_not_c1, g_stats.rx_len_invalid, g_stats.rx_bytes, + g_stats.tx_attempts, g_stats.tx_success, g_stats.tx_timeout, + g_stats.tx_failures, g_stats.tx_suppressed_dup, + g_stats.tx_suppressed_whitelist, g_stats.radio_reinit, + g_stats.fem_reinit, g_stats.recoveries); +} + +void repeater_print_radio_status(void) +{ + uint8_t st = sx126x_get_status(); + LOGJ("\"event\":\"radio_status\",\"status_byte\":%u,\"chip_mode\":%u," + "\"cmd_status\":%u,\"device_errors\":%u,\"rssi_dbm\":%d," + "\"busy\":%s", + st, (st >> 4) & 0x7, (st >> 1) & 0x7, + sx126x_get_device_errors(), sx126x_get_rssi_inst(), + "false"); +} diff --git a/firmware/main/repeater.h b/firmware/main/repeater.h new file mode 100644 index 0000000..78b7d7c --- /dev/null +++ b/firmware/main/repeater.h @@ -0,0 +1,41 @@ +#pragma once + +#include +#include + +typedef struct { + uint32_t rx_candidates; // sync matches handed to us by the radio + uint32_t rx_valid; // CRC-valid C1 frames + uint32_t rx_crc_fail; + uint32_t rx_not_c1; // sync matched but not C-mode (e.g. T1) + uint32_t rx_len_invalid; + uint32_t rx_bytes; + uint32_t tx_attempts; + uint32_t tx_success; + uint32_t tx_timeout; + uint32_t tx_failures; + uint32_t tx_suppressed_dup; + uint32_t tx_suppressed_whitelist; + uint32_t radio_reinit; + uint32_t fem_reinit; + uint32_t recoveries; +} repeater_stats_t; + +typedef struct { + uint32_t repeat_delay_ms; // 20..200 + int8_t tx_power_dbm; // configured SX1262 level, not radiated power + bool repeat_enabled; + bool verbose; + uint32_t whitelist[8]; // A-field ID (4 bytes LE as uint32), 0 = empty slot + int whitelist_len; +} repeater_cfg_t; + +extern repeater_cfg_t g_cfg; +extern repeater_stats_t g_stats; + +void repeater_start(void); +void repeater_request_radio_reset(void); +void repeater_request_test_tx(void); +void repeater_print_status(void); +void repeater_print_stats(void); +void repeater_print_radio_status(void); diff --git a/firmware/main/sx126x.c b/firmware/main/sx126x.c new file mode 100644 index 0000000..493b647 --- /dev/null +++ b/firmware/main/sx126x.c @@ -0,0 +1,454 @@ +#include "sx126x.h" +#include "board.h" + +#include +#include "freertos/FreeRTOS.h" +#include "freertos/task.h" +#include "freertos/semphr.h" +#include "driver/spi_master.h" +#include "driver/gpio.h" +#include "esp_timer.h" +#include "esp_rom_sys.h" + +// ---- opcodes ---- +#define OP_SET_SLEEP 0x84 +#define OP_SET_STANDBY 0x80 +#define OP_SET_FS 0xC1 +#define OP_SET_TX 0x83 +#define OP_SET_RX 0x82 +#define OP_SET_PACKET_TYPE 0x8A +#define OP_GET_PACKET_TYPE 0x11 +#define OP_SET_RF_FREQUENCY 0x86 +#define OP_SET_PA_CONFIG 0x95 +#define OP_SET_TX_PARAMS 0x8E +#define OP_SET_MODULATION 0x8B +#define OP_SET_PACKET_PARAMS 0x8C +#define OP_SET_BUFFER_BASE 0x8F +#define OP_WRITE_BUFFER 0x0E +#define OP_READ_BUFFER 0x1E +#define OP_WRITE_REGISTER 0x0D +#define OP_READ_REGISTER 0x1D +#define OP_SET_DIO_IRQ_PARAMS 0x08 +#define OP_GET_IRQ_STATUS 0x12 +#define OP_CLEAR_IRQ_STATUS 0x02 +#define OP_SET_DIO2_RF_SWITCH 0x9D +#define OP_SET_DIO3_TCXO_CTRL 0x97 +#define OP_CALIBRATE 0x89 +#define OP_CALIBRATE_IMAGE 0x98 +#define OP_GET_STATUS 0xC0 +#define OP_GET_RX_BUFFER_STATUS 0x13 +#define OP_GET_PACKET_STATUS 0x14 +#define OP_GET_RSSI_INST 0x15 +#define OP_GET_DEVICE_ERRORS 0x17 +#define OP_CLEAR_DEVICE_ERRORS 0x07 +#define OP_SET_REGULATOR_MODE 0x96 +#define OP_SET_RXTX_FALLBACK 0x93 + +// ---- registers ---- +#define REG_SYNCWORD_0 0x06C0 +#define REG_OCP 0x08E7 +#define REG_RX_GAIN 0x08AC + +#define BUSY_TIMEOUT_US 20000 + +static spi_device_handle_t s_spi; +static sx126x_irq_cb_t s_irq_cb; +static uint8_t s_rx_payload_len = 255; +static int8_t s_tx_dbm = -9; +static SemaphoreHandle_t s_lock; // serializes SPI access across tasks + +// ---------------------------------------------------------------- low level + +static bool busy_wait(void) +{ + int64_t t0 = esp_timer_get_time(); + while (gpio_get_level(BOARD_LORA_BUSY)) { + if (esp_timer_get_time() - t0 > BUSY_TIMEOUT_US) return false; + esp_rom_delay_us(5); + } + return true; +} + +static bool xfer(const uint8_t *tx, uint8_t *rx, size_t len) +{ + if (s_lock) xSemaphoreTake(s_lock, portMAX_DELAY); + bool ok = false; + if (busy_wait()) { + spi_transaction_t t = { + .length = len * 8, + .tx_buffer = tx, + .rx_buffer = rx, + }; + ok = spi_device_polling_transmit(s_spi, &t) == ESP_OK; + } + if (s_lock) xSemaphoreGive(s_lock); + return ok; +} + +static bool cmd(uint8_t op, const uint8_t *args, size_t n) +{ + uint8_t buf[16]; + if (n + 1 > sizeof(buf)) return false; + buf[0] = op; + if (n) memcpy(buf + 1, args, n); + return xfer(buf, NULL, n + 1); +} + +static bool cmd_read(uint8_t op, uint8_t *out, size_t n) +{ + // op + status byte + n data + uint8_t tx[20] = {0}, rx[20] = {0}; + if (n + 2 > sizeof(tx)) return false; + tx[0] = op; + if (!xfer(tx, rx, n + 2)) return false; + memcpy(out, rx + 2, n); + return true; +} + +static bool write_regs(uint16_t addr, const uint8_t *data, size_t n) +{ + uint8_t buf[16]; + if (n + 3 > sizeof(buf)) return false; + buf[0] = OP_WRITE_REGISTER; + buf[1] = addr >> 8; + buf[2] = addr & 0xFF; + memcpy(buf + 3, data, n); + return xfer(buf, NULL, n + 3); +} + +static bool read_regs(uint16_t addr, uint8_t *out, size_t n) +{ + uint8_t tx[20] = {0}, rx[20] = {0}; + if (n + 4 > sizeof(tx)) return false; + tx[0] = OP_READ_REGISTER; + tx[1] = addr >> 8; + tx[2] = addr & 0xFF; + // byte 3 is a NOP/status byte before data + if (!xfer(tx, rx, n + 4)) return false; + memcpy(out, rx + 4, n); + return true; +} + +// ---------------------------------------------------------------- FEM + +void fem_power(bool on) +{ + gpio_set_level(BOARD_FEM_PWR_EN, on); + gpio_set_level(BOARD_FEM_CSD, on); + if (!on) gpio_set_level(BOARD_FEM_CTX, 0); +} + +void fem_set_tx(bool tx) +{ + // KCT8103L: CTX HIGH = TX/PA path, LOW = RX/LNA path. CPS is driven by + // SX1262 DIO2 (DIO2-as-RF-switch), which the radio raises during TX. + gpio_set_level(BOARD_FEM_CTX, tx); +} + +// ---------------------------------------------------------------- IRQ + +static void IRAM_ATTR dio1_isr(void *arg) +{ + (void)arg; + if (s_irq_cb) s_irq_cb(esp_timer_get_time()); +} + +void sx126x_set_irq_callback(sx126x_irq_cb_t cb) { s_irq_cb = cb; } + +// ---------------------------------------------------------------- init + +static bool radio_reset(void) +{ + gpio_set_level(BOARD_LORA_RESET, 0); + vTaskDelay(pdMS_TO_TICKS(2)); + gpio_set_level(BOARD_LORA_RESET, 1); + vTaskDelay(pdMS_TO_TICKS(5)); + return busy_wait(); +} + +bool sx126x_init(sx126x_diag_t *diag) +{ + memset(diag, 0, sizeof(*diag)); + + // GPIO setup + gpio_config_t out_cfg = { + .pin_bit_mask = (1ULL << BOARD_LORA_RESET) | (1ULL << BOARD_FEM_PWR_EN) | + (1ULL << BOARD_FEM_CSD) | (1ULL << BOARD_FEM_CTX), + .mode = GPIO_MODE_OUTPUT, + }; + gpio_config(&out_cfg); + gpio_config_t in_cfg = { + .pin_bit_mask = (1ULL << BOARD_LORA_BUSY), + .mode = GPIO_MODE_INPUT, + }; + gpio_config(&in_cfg); + gpio_config_t irq_cfg = { + .pin_bit_mask = (1ULL << BOARD_LORA_DIO1), + .mode = GPIO_MODE_INPUT, + .intr_type = GPIO_INTR_POSEDGE, + }; + gpio_config(&irq_cfg); + gpio_install_isr_service(0); + gpio_isr_handler_add(BOARD_LORA_DIO1, dio1_isr, NULL); + + // FEM: power up, enable, RX path + gpio_set_level(BOARD_LORA_RESET, 1); + fem_power(true); + fem_set_tx(false); + vTaskDelay(pdMS_TO_TICKS(5)); + + // SPI + if (!s_lock) s_lock = xSemaphoreCreateMutex(); + if (!s_spi) { + spi_bus_config_t bus = { + .sclk_io_num = BOARD_LORA_SCK, + .mosi_io_num = BOARD_LORA_MOSI, + .miso_io_num = BOARD_LORA_MISO, + .quadwp_io_num = -1, + .quadhd_io_num = -1, + .max_transfer_sz = 300, + }; + if (spi_bus_initialize(SPI2_HOST, &bus, SPI_DMA_CH_AUTO) != ESP_OK) return false; + spi_device_interface_config_t dev = { + .clock_speed_hz = 8 * 1000 * 1000, + .mode = 0, + .spics_io_num = BOARD_LORA_NSS, + .queue_size = 2, + }; + if (spi_bus_add_device(SPI2_HOST, &dev, &s_spi) != ESP_OK) return false; + } + + diag->reset_ok = radio_reset(); + diag->busy_ok = (gpio_get_level(BOARD_LORA_BUSY) == 0); + + // standby RC + uint8_t stdby = 0x00; + cmd(OP_SET_STANDBY, &stdby, 1); + + // SPI sanity: write + readback sync word registers + uint8_t probe[2] = {0x54, 0x3D}, verify[2] = {0, 0}; + write_regs(REG_SYNCWORD_0, probe, 2); + read_regs(REG_SYNCWORD_0, verify, 2); + diag->spi_ok = (verify[0] == 0x54 && verify[1] == 0x3D); + + // TCXO on DIO3 (1.8 V, ~4 ms), then recalibrate everything because + // enabling the TCXO invalidates the RC-based calibration. + uint8_t tcxo[4] = {BOARD_TCXO_VOLTAGE_CODE, 0x00, 0x00, BOARD_TCXO_DELAY_STEPS}; + cmd(OP_SET_DIO3_TCXO_CTRL, tcxo, 4); + uint8_t calib = 0x7F; + cmd(OP_CALIBRATE, &calib, 1); + vTaskDelay(pdMS_TO_TICKS(10)); + busy_wait(); + + uint16_t errs = sx126x_get_device_errors(); + diag->device_errors = errs; + // XOSC_START_ERR (bit 5) would indicate TCXO trouble + diag->tcxo_ok = ((errs & 0x20) == 0); + if (errs) cmd(OP_CLEAR_DEVICE_ERRORS, (uint8_t[]){0, 0}, 2); + + // DC-DC regulator (Heltec module has the inductor; RNode uses default LDO, + // but SX1262 modules from Heltec are DCDC-capable. Use DCDC for lower + // current; fall back to LDO if instability is ever observed.) + uint8_t reg = 0x01; + cmd(OP_SET_REGULATOR_MODE, ®, 1); + + // DIO2 drives the FEM CPS pin + uint8_t dio2 = 0x01; + cmd(OP_SET_DIO2_RF_SWITCH, &dio2, 1); + + // fallback to STDBY_RC after TX/RX + uint8_t fb = 0x20; + cmd(OP_SET_RXTX_FALLBACK, &fb, 1); + + diag->chip_mode = (sx126x_get_status() >> 4) & 0x7; + return diag->spi_ok && diag->reset_ok && diag->tcxo_ok; +} + +// ------------------------------------------------------------- wM-Bus C1 + +bool sx126x_config_wmbus_c1(uint32_t freq_hz, uint8_t rx_payload_len) +{ + s_rx_payload_len = rx_payload_len; + bool ok = true; + + uint8_t pkt_type = 0x00; // GFSK + ok &= cmd(OP_SET_PACKET_TYPE, &pkt_type, 1); + + // image calibration for 863-870 MHz band + ok &= cmd(OP_CALIBRATE_IMAGE, (uint8_t[]){0xD7, 0xDB}, 2); + + uint32_t frf = (uint32_t)(((uint64_t)freq_hz << 25) / 32000000ULL); + uint8_t f[4] = {frf >> 24, frf >> 16, frf >> 8, frf}; + ok &= cmd(OP_SET_RF_FREQUENCY, f, 4); + + // PA config for SX1262, +14 dBm optimal table (we run far below that) + ok &= cmd(OP_SET_PA_CONFIG, (uint8_t[]){0x02, 0x02, 0x00, 0x01}, 4); + ok &= sx126x_set_tx_power(s_tx_dbm); + + // OCP + uint8_t ocp = BOARD_SX1262_OCP; + ok &= write_regs(REG_OCP, &ocp, 1); + + // Boosted RX gain + uint8_t gain = 0x96; + ok &= write_regs(REG_RX_GAIN, &gain, 1); + + // Modulation: 100 kbps, no shaping (wM-Bus C is plain FSK), + // RX BW 234.3 kHz, fdev 45 kHz + // br = 32 * 32e6 / 100e3 = 10240 = 0x002800 + // fdev = 45e3 * 2^25 / 32e6 = 47186 = 0x00B852 + uint8_t mod[8] = { + 0x00, 0x28, 0x00, // bitrate + 0x00, // no pulse shaping + 0x0A, // RX BW 234.3 kHz + 0x00, 0xB8, 0x52, // fdev + }; + ok &= cmd(OP_SET_MODULATION, mod, 8); + + // Sync word = wM-Bus T/C access code 0x543D. The two C-mode "mode bytes" + // (54CD = frame A, 543D = frame B) are received/sent as payload so that + // RX and TX can share one radio configuration. + ok &= write_regs(REG_SYNCWORD_0, (uint8_t[]){0x54, 0x3D}, 2); + + ok &= cmd(OP_SET_BUFFER_BASE, (uint8_t[]){0x00, 0x00}, 2); + + // IRQs on DIO1 + uint16_t irqs = SX126X_IRQ_TX_DONE | SX126X_IRQ_RX_DONE | SX126X_IRQ_TIMEOUT; + uint8_t di[8] = { + irqs >> 8, irqs & 0xFF, // IRQ mask + irqs >> 8, irqs & 0xFF, // DIO1 + 0x00, 0x00, // DIO2 (RF switch) + 0x00, 0x00, // DIO3 (TCXO) + }; + ok &= cmd(OP_SET_DIO_IRQ_PARAMS, di, 8); + + ok &= sx126x_restore_rx_payload_len(); + return ok; +} + +static bool set_packet_params(uint8_t payload_len) +{ + // preamble 48 bits TX, detector 8 bits, sync 16 bits, fixed length, no + // radio CRC (wM-Bus CRC is per-block, validated in software), no whitening + uint8_t pp[9] = { + 0x00, 0x30, // TX preamble length: 48 bits + 0x04, // preamble detector: 8 bits + 16, // sync word length in bits + 0x00, // no address filtering + 0x00, // fixed length packet + payload_len, + 0x01, // CRC off + 0x00, // no whitening + }; + return cmd(OP_SET_PACKET_PARAMS, pp, 9); +} + +bool sx126x_restore_rx_payload_len(void) +{ + return set_packet_params(s_rx_payload_len); +} + +bool sx126x_set_tx_power(int8_t dbm) +{ + if (dbm < -9) dbm = -9; + if (dbm > 14) dbm = 14; // deliberately capped: external FEM adds gain + s_tx_dbm = dbm; + uint8_t tp[2] = {(uint8_t)dbm, 0x02}; // ramp 40 us + return cmd(OP_SET_TX_PARAMS, tp, 2); +} + +bool sx126x_standby(void) +{ + uint8_t stdby = 0x00; + return cmd(OP_SET_STANDBY, &stdby, 1); +} + +bool sx126x_set_rx(void) +{ + fem_set_tx(false); + sx126x_clear_irq(SX126X_IRQ_ALL); + // RX continuous + return cmd(OP_SET_RX, (uint8_t[]){0xFF, 0xFF, 0xFF}, 3); +} + +bool sx126x_start_tx(const uint8_t *buf, uint8_t len) +{ + if (!sx126x_standby()) return false; + sx126x_clear_irq(SX126X_IRQ_ALL); + if (!set_packet_params(len)) return false; + + // WriteBuffer needs op + offset + payload in one transaction + static uint8_t txbuf[258]; + txbuf[0] = OP_WRITE_BUFFER; + txbuf[1] = 0x00; + memcpy(txbuf + 2, buf, len); + if (!xfer(txbuf, NULL, (size_t)len + 2)) return false; + + fem_set_tx(true); + // TX timeout ~500 ms = 32000 * 15.625 us -> 0x007D00 + if (!cmd(OP_SET_TX, (uint8_t[]){0x00, 0x7D, 0x00}, 3)) { + fem_set_tx(false); + return false; + } + return true; +} + +uint16_t sx126x_get_irq(void) +{ + uint8_t st[2] = {0, 0}; + if (!cmd_read(OP_GET_IRQ_STATUS, st, 2)) return 0; + return ((uint16_t)st[0] << 8) | st[1]; +} + +bool sx126x_clear_irq(uint16_t mask) +{ + return cmd(OP_CLEAR_IRQ_STATUS, (uint8_t[]){mask >> 8, mask & 0xFF}, 2); +} + +int sx126x_read_rx(uint8_t *out, size_t maxlen, int8_t *rssi_dbm) +{ + uint8_t st[2]; + if (!cmd_read(OP_GET_RX_BUFFER_STATUS, st, 2)) return -1; + uint8_t n = st[0], off = st[1]; + if (n > maxlen) n = maxlen; + + if (rssi_dbm) { + uint8_t ps[3] = {0}; + if (cmd_read(OP_GET_PACKET_STATUS, ps, 3)) { + *rssi_dbm = (int8_t)(-(int)ps[1] / 2); // RssiSync + } else { + *rssi_dbm = 0; + } + } + + static uint8_t rdbuf_tx[259]; + static uint8_t rdbuf_rx[259]; + memset(rdbuf_tx, 0, (size_t)n + 3); + rdbuf_tx[0] = OP_READ_BUFFER; + rdbuf_tx[1] = off; + // byte 2 is status/NOP, data starts at byte 3 + if (!xfer(rdbuf_tx, rdbuf_rx, (size_t)n + 3)) return -1; + memcpy(out, rdbuf_rx + 3, n); + return n; +} + +int8_t sx126x_get_rssi_inst(void) +{ + uint8_t v = 0; + cmd_read(OP_GET_RSSI_INST, &v, 1); + return (int8_t)(-(int)v / 2); +} + +uint16_t sx126x_get_device_errors(void) +{ + uint8_t e[2] = {0, 0}; + if (!cmd_read(OP_GET_DEVICE_ERRORS, e, 2)) return 0xFFFF; + return ((uint16_t)e[0] << 8) | e[1]; +} + +uint8_t sx126x_get_status(void) +{ + uint8_t tx[2] = {OP_GET_STATUS, 0}, rx[2] = {0, 0}; + if (!xfer(tx, rx, 2)) return 0; + return rx[1]; +} diff --git a/firmware/main/sx126x.h b/firmware/main/sx126x.h new file mode 100644 index 0000000..217febc --- /dev/null +++ b/firmware/main/sx126x.h @@ -0,0 +1,59 @@ +// Minimal SX1262 driver for wM-Bus C1 on Heltec WiFi LoRa 32 V4.3. +// GFSK packet mode only. No LoRa support. +#pragma once + +#include +#include +#include + +// IRQ bits (SX126x datasheet 13.3.1) +#define SX126X_IRQ_TX_DONE (1u << 0) +#define SX126X_IRQ_RX_DONE (1u << 1) +#define SX126X_IRQ_PREAMBLE_DETECTED (1u << 2) +#define SX126X_IRQ_SYNCWORD_VALID (1u << 3) +#define SX126X_IRQ_CRC_ERR (1u << 6) +#define SX126X_IRQ_TIMEOUT (1u << 9) +#define SX126X_IRQ_ALL 0x03FFu + +typedef struct { + bool spi_ok; // sync-word register readback matched + bool reset_ok; // BUSY went low after reset + bool busy_ok; // BUSY currently low + bool tcxo_ok; // XOSC start + calibrate succeeded (no device errors) + uint16_t device_errors; + uint8_t chip_mode; // from GetStatus, 3-bit chip mode field +} sx126x_diag_t; + +// Fills diag during bring-up. Returns true if the radio is usable. +bool sx126x_init(sx126x_diag_t *diag); + +// Configure GFSK modem for wM-Bus C1: 100 kbps, +/-45 kHz, sync 0x543D. +// rx_payload_len is the fixed RX capture length (we truncate in software). +bool sx126x_config_wmbus_c1(uint32_t freq_hz, uint8_t rx_payload_len); + +bool sx126x_set_tx_power(int8_t dbm); // -9 .. +14 (PA config capped) +bool sx126x_set_rx(void); // continuous RX, FEM to RX path +bool sx126x_standby(void); + +// Transmit buf as GFSK payload (sync word prepended by radio). +// Handles FEM CTX switching. Blocking until commands issued; TX-done is +// signalled via DIO1/IRQ. timeout handled by caller. +bool sx126x_start_tx(const uint8_t *buf, uint8_t len); +// Restore fixed RX payload length after a TX (packet params are shared). +bool sx126x_restore_rx_payload_len(void); + +uint16_t sx126x_get_irq(void); +bool sx126x_clear_irq(uint16_t mask); +// Read last received packet. Returns actual bytes copied (<= maxlen). +int sx126x_read_rx(uint8_t *out, size_t maxlen, int8_t *rssi_dbm); +int8_t sx126x_get_rssi_inst(void); +uint16_t sx126x_get_device_errors(void); +uint8_t sx126x_get_status(void); + +// FEM control (exposed for diagnostics) +void fem_set_tx(bool tx); +void fem_power(bool on); + +// Registered by caller before init; invoked from DIO1 GPIO ISR. +typedef void (*sx126x_irq_cb_t)(int64_t timestamp_us); +void sx126x_set_irq_callback(sx126x_irq_cb_t cb); diff --git a/firmware/main/wmbus.c b/firmware/main/wmbus.c new file mode 100644 index 0000000..cacff8f --- /dev/null +++ b/firmware/main/wmbus.c @@ -0,0 +1,135 @@ +#include "wmbus.h" + +uint16_t wmbus_crc16(const uint8_t *data, size_t len) +{ + // EN 13757-4: poly 0x3D65, init 0x0000, MSB first, final complement + uint16_t crc = 0; + for (size_t i = 0; i < len; i++) { + crc ^= (uint16_t)data[i] << 8; + for (int b = 0; b < 8; b++) { + crc = (crc & 0x8000) ? (crc << 1) ^ 0x3D65 : (crc << 1); + } + } + return ~crc; +} + +wmbus_frame_fmt_t wmbus_frame_format(uint8_t b0, uint8_t b1) +{ + if (b0 != WMBUS_MODE_BYTE_A_HI) return WMBUS_FRAME_UNKNOWN; + if (b1 == WMBUS_MODE_BYTE_A_LO) return WMBUS_FRAME_A; + if (b1 == WMBUS_MODE_BYTE_B_LO) return WMBUS_FRAME_B; + return WMBUS_FRAME_UNKNOWN; +} + +int wmbus_frame_total_len(wmbus_frame_fmt_t fmt, uint8_t lfield) +{ + int total; + switch (fmt) { + case WMBUS_FRAME_A: + // L counts C,M,A,CI,data without CRCs. Block 1 holds 9 payload + // bytes; every further block holds up to 16, each with 2 CRC bytes. + if (lfield < 9) return -1; + total = 1 + lfield + 2 * (((lfield - 10 + 15) / 16) + 1); + break; + case WMBUS_FRAME_B: + // L counts everything after itself including CRC bytes. + if (lfield < 11) return -1; + total = 1 + lfield; + break; + default: + return -1; + } + if (total > 253) return -1; // must fit SX1262 payload with 2 mode bytes + return total; +} + +bool wmbus_check_crc(wmbus_frame_fmt_t fmt, const uint8_t *frame, int total_len) +{ + if (total_len < 12) return false; + + if (fmt == WMBUS_FRAME_A) { + // Block 1: 10 bytes + CRC + if (wmbus_crc16(frame, 10) != + (((uint16_t)frame[10] << 8) | frame[11])) return false; + int pos = 12; + while (pos < total_len) { + int n = total_len - pos - 2; + if (n > 16) n = 16; + if (n <= 0) return false; + if (wmbus_crc16(frame + pos, n) != + (((uint16_t)frame[pos + n] << 8) | frame[pos + n + 1])) return false; + pos += n + 2; + } + return pos == total_len; + } + + if (fmt == WMBUS_FRAME_B) { + // Blocks 1+2 share one CRC over their concatenation. Frames longer + // than 128 bytes carry further 128-byte chunks, each CRCed over its + // first 126 bytes (mirrors rtl-wmbus check_calc_crc_wmbus_b_frame_type). + const uint8_t *p = frame; + int rem = total_len; + while (rem) { + if (rem >= 128) { + if (wmbus_crc16(p, 126) != + (((uint16_t)p[126] << 8) | p[127])) return false; + p += 128; rem -= 128; + } else { + if (rem < 3) return false; + if (wmbus_crc16(p, rem - 2) != + (((uint16_t)p[rem - 2] << 8) | p[rem - 1])) return false; + rem = 0; + } + } + return true; + } + + return false; +} + +uint32_t wmbus_hash(const uint8_t *data, size_t len) +{ + uint32_t h = 2166136261u; + for (size_t i = 0; i < len; i++) { + h ^= data[i]; + h *= 16777619u; + } + return h; +} + +int wmbus_build_test_frame(uint8_t *out, size_t maxlen, uint8_t access_nr) +{ + // Format A frame: L C M(2) A(6) | CRC | CI ...data... | CRC + // Manufacturer "SLN" = ((19)<<10)|(12<<5)|(14) = 0x4D8E (Solenos test) + // ID 0x00000001 (BCD 00000001), version 0x01, device type 0x07 (water) + uint8_t body[26]; + int L = 19; // C M A CI + 10 data bytes = 1+2+6+1+9... keep L=19: C(1)+M(2)+A(6)+CI(1)+data(9) + body[0] = (uint8_t)L; + body[1] = 0x44; // SND_NR + body[2] = 0x8E; body[3] = 0x4D; // manufacturer, little endian + body[4] = 0x01; body[5] = 0x00; body[6] = 0x00; body[7] = 0x00; // ID BCD LE + body[8] = 0x01; // version + body[9] = 0x07; // device type + body[10] = 0x78; // CI: response, no header + // 9 data bytes: marker + access counter + body[11] = 0x53; body[12] = 0x4F; body[13] = 0x4C; body[14] = 0x54; // "SOLT" + body[15] = 0x58; // "X" + body[16] = access_nr; + body[17] = 0xA5; body[18] = 0x5A; body[19] = access_nr ^ 0xFF; + + // assemble with block CRCs + int total = wmbus_frame_total_len(WMBUS_FRAME_A, (uint8_t)L); + if (total < 0 || (size_t)total > maxlen) return -1; + + // block 1: bytes 0..9 + crc + for (int i = 0; i < 10; i++) out[i] = body[i]; + uint16_t c1 = wmbus_crc16(out, 10); + out[10] = c1 >> 8; out[11] = c1 & 0xFF; + // block 2: bytes 10..(L) of body (CI + data = L-9 bytes) + crc + int n2 = L - 9; + for (int i = 0; i < n2; i++) out[12 + i] = body[10 + i]; + uint16_t c2 = wmbus_crc16(out + 12, n2); + out[12 + n2] = c2 >> 8; out[13 + n2] = c2 & 0xFF; + + return total; +} diff --git a/firmware/main/wmbus.h b/firmware/main/wmbus.h new file mode 100644 index 0000000..396f67b --- /dev/null +++ b/firmware/main/wmbus.h @@ -0,0 +1,37 @@ +// Wireless M-Bus C-mode frame helpers (EN 13757-4). +#pragma once + +#include +#include +#include + +#define WMBUS_MODE_BYTE_A_HI 0x54 +#define WMBUS_MODE_BYTE_A_LO 0xCD // C-mode frame format A: sync 543D 54CD +#define WMBUS_MODE_BYTE_B_LO 0x3D // C-mode frame format B: sync 543D 543D + +typedef enum { + WMBUS_FRAME_A, + WMBUS_FRAME_B, + WMBUS_FRAME_UNKNOWN, // not C-mode (e.g. T-mode 3-of-6 stream) +} wmbus_frame_fmt_t; + +// Identify frame format from the two payload "mode bytes". +wmbus_frame_fmt_t wmbus_frame_format(uint8_t b0, uint8_t b1); + +// Total over-the-air frame length (including L-field and all CRC bytes) +// for a given L-field. Returns -1 if invalid/oversized. +int wmbus_frame_total_len(wmbus_frame_fmt_t fmt, uint8_t lfield); + +// Validate all block CRCs of a complete raw frame. frame[0] is the L-field. +bool wmbus_check_crc(wmbus_frame_fmt_t fmt, const uint8_t *frame, int total_len); + +// CRC-16 EN 13757 (poly 0x3D65, init 0, complemented result). +uint16_t wmbus_crc16(const uint8_t *data, size_t len); + +// Build a valid C-mode format A test frame with our test manufacturer/ID. +// Returns total frame length written to out (>= 12), or -1 if payload_len +// does not fit. out[0] = L-field. +int wmbus_build_test_frame(uint8_t *out, size_t maxlen, uint8_t access_nr); + +// 32-bit FNV-1a hash used to correlate RX/TX events in the logs. +uint32_t wmbus_hash(const uint8_t *data, size_t len); diff --git a/firmware/sdkconfig.defaults b/firmware/sdkconfig.defaults new file mode 100644 index 0000000..de5f150 --- /dev/null +++ b/firmware/sdkconfig.defaults @@ -0,0 +1,21 @@ +CONFIG_IDF_TARGET="esp32s3" + +# Heltec WiFi LoRa 32 V4.3: 16 MB flash, QIO 80 MHz (matches vendor images) +CONFIG_ESPTOOLPY_FLASHSIZE_16MB=y +CONFIG_ESPTOOLPY_FLASHMODE_QIO=y +CONFIG_ESPTOOLPY_FLASHFREQ_80M=y + +# Console on ESP32-S3 native USB (USB-Serial-JTAG) +CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG=y + +# 1 kHz tick for finer repeat-delay granularity +CONFIG_FREERTOS_HZ=1000 + +# Task watchdog: catastrophic-deadlock catcher only +CONFIG_ESP_TASK_WDT_EN=y +CONFIG_ESP_TASK_WDT_TIMEOUT_S=15 +CONFIG_ESP_TASK_WDT_PANIC=y + +# Keep bootloader/app log noise low; all HIL-relevant output is JSON lines +CONFIG_LOG_DEFAULT_LEVEL_WARN=y +CONFIG_BOOTLOADER_LOG_LEVEL_WARN=y diff --git a/flake.lock b/flake.lock new file mode 100644 index 0000000..2e9da79 --- /dev/null +++ b/flake.lock @@ -0,0 +1,97 @@ +{ + "nodes": { + "esp-dev": { + "inputs": { + "flake-utils": "flake-utils", + "nixpkgs": "nixpkgs" + }, + "locked": { + "lastModified": 1767865407, + "narHash": "sha256-QWF1rZYd+HvNzLIeRS+OEBX7HF0EhWCGeLbMkgtbsIo=", + "owner": "mirrexagon", + "repo": "nixpkgs-esp-dev", + "rev": "5287d6e1ca9e15ebd5113c41b9590c468e1e001b", + "type": "github" + }, + "original": { + "owner": "mirrexagon", + "repo": "nixpkgs-esp-dev", + "rev": "5287d6e1ca9e15ebd5113c41b9590c468e1e001b", + "type": "github" + } + }, + "flake-utils": { + "inputs": { + "systems": "systems" + }, + "locked": { + "lastModified": 1731533236, + "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=", + "owner": "numtide", + "repo": "flake-utils", + "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b", + "type": "github" + }, + "original": { + "owner": "numtide", + "repo": "flake-utils", + "type": "github" + } + }, + "nixpkgs": { + "locked": { + "lastModified": 1767799921, + "narHash": "sha256-r4GVX+FToWVE2My8VVZH4V0pTIpnu2ZE8/Z4uxGEMBE=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "d351d0653aeb7877273920cd3e823994e7579b0b", + "type": "github" + }, + "original": { + "owner": "NixOS", + "ref": "nixos-25.11", + "repo": "nixpkgs", + "type": "github" + } + }, + "nixpkgs_2": { + "locked": { + "lastModified": 1782847189, + "narHash": "sha256-twXPFqFsrrY5r28Zh7Homgcp2gUMBgQ6WDS98Q/3xFI=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "b6018f87da91d19d0ab4cf979885689b469cdd41", + "type": "github" + }, + "original": { + "owner": "NixOS", + "ref": "nixos-25.11", + "repo": "nixpkgs", + "type": "github" + } + }, + "root": { + "inputs": { + "esp-dev": "esp-dev", + "nixpkgs": "nixpkgs_2" + } + }, + "systems": { + "locked": { + "lastModified": 1681028828, + "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=", + "owner": "nix-systems", + "repo": "default", + "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e", + "type": "github" + }, + "original": { + "owner": "nix-systems", + "repo": "default", + "type": "github" + } + } + }, + "root": "root", + "version": 7 +} diff --git a/flake.nix b/flake.nix index 7294027..19ba96e 100644 --- a/flake.nix +++ b/flake.nix @@ -43,8 +43,9 @@ rev = "85532d91fd1e2bfa25b01705dd6aa574287649f7"; hash = "sha256-rOeeeYVXxGTXdKQMHr/bkODoi6rlE4i3r7ItGhyimjI="; }; + postPatch = "patchShebangs scripts"; nativeBuildInputs = [ pkgs.pkg-config ]; - buildInputs = [ pkgs.rtl-sdr ]; + buildInputs = [ pkgs.rtl-sdr pkgs.libxml2 ]; makeFlags = [ "PREFIX=$(out)" ]; # skip install of systemd units etc. installPhase = '' diff --git a/tools/discover_devices.sh b/tools/discover_devices.sh new file mode 100755 index 0000000..c4081a3 --- /dev/null +++ b/tools/discover_devices.sh @@ -0,0 +1,44 @@ +#!/usr/bin/env bash +# Deterministic discovery of DUT (Heltec V4.3) and SDR (Nooelec NESDR SMArt v5). +# Prints selected devices; exits nonzero on ambiguity or absence. +# +# Output (eval-able): +# DUT_PORT=/dev/serial/by-id/... +# SDR_INDEX=0 +# SDR_SERIAL=33999948 +set -euo pipefail + +fail() { echo "DISCOVER_ERROR: $*" >&2; exit 1; } + +# --- DUT: Heltec WiFi LoRa 32 V4 (ESP32-S3 native USB CDC) --- +shopt -s nullglob +dut_candidates=(/dev/serial/by-id/*heltec_wifi_lora_32_v4*) +if [ ${#dut_candidates[@]} -eq 0 ]; then + # fall back to any Espressif device, but require uniqueness + dut_candidates=(/dev/serial/by-id/usb-Espressif*) +fi +[ ${#dut_candidates[@]} -eq 0 ] && fail "no Heltec/Espressif serial device found in /dev/serial/by-id/" +[ ${#dut_candidates[@]} -gt 1 ] && fail "ambiguous DUT: ${dut_candidates[*]}" +DUT_PORT="${dut_candidates[0]}" +[ -e "$DUT_PORT" ] || fail "DUT path vanished: $DUT_PORT" + +# --- SDR: Nooelec NESDR SMArt v5 (RTL2832U) --- +# rtl_test -t enumerates devices without streaming. +sdr_list=$(timeout 10 rtl_test -t 2>&1 | grep -E '^\s+[0-9]+:' || true) +[ -z "$sdr_list" ] && fail "no RTL-SDR device found (rtl_test)" +sdr_matches=$(echo "$sdr_list" | grep -i "Nooelec" || true) +[ -z "$sdr_matches" ] && fail "RTL-SDR present but not a Nooelec: $sdr_list" +[ "$(echo "$sdr_matches" | wc -l)" -gt 1 ] && fail "ambiguous SDR: $sdr_matches" +SDR_INDEX=$(echo "$sdr_matches" | sed -E 's/^\s*([0-9]+):.*/\1/') +SDR_SERIAL=$(echo "$sdr_matches" | sed -E 's/.*SN: ([^ ]+).*/\1/') + +echo "DUT_PORT=$DUT_PORT" +echo "SDR_INDEX=$SDR_INDEX" +echo "SDR_SERIAL=$SDR_SERIAL" + +if [ "${1:-}" = "-v" ]; then + echo "---" >&2 + echo "DUT: $DUT_PORT -> $(readlink -f "$DUT_PORT")" >&2 + echo "SDR: index $SDR_INDEX, serial $SDR_SERIAL" >&2 + echo "$sdr_matches" >&2 +fi diff --git a/tools/flash.sh b/tools/flash.sh new file mode 100755 index 0000000..082da33 --- /dev/null +++ b/tools/flash.sh @@ -0,0 +1,11 @@ +#!/usr/bin/env bash +# Build + flash the firmware to the discovered DUT. Refuses ambiguous devices. +set -euo pipefail +cd "$(dirname "$0")/.." + +eval "$(./tools/discover_devices.sh)" +echo "Flashing DUT: $DUT_PORT" >&2 + +cd firmware +idf.py build +idf.py -p "$DUT_PORT" flash diff --git a/tools/reset_dut.sh b/tools/reset_dut.sh new file mode 100755 index 0000000..54ae417 --- /dev/null +++ b/tools/reset_dut.sh @@ -0,0 +1,7 @@ +#!/usr/bin/env bash +# Hard-reset the DUT via esptool (RTS/DTR toggle), leaving flash intact. +set -euo pipefail +cd "$(dirname "$0")/.." +eval "$(./tools/discover_devices.sh)" +esptool.py --port "$DUT_PORT" --before default_reset --after hard_reset chip_id >/dev/null 2>&1 || true +echo "DUT reset: $DUT_PORT"