From 697e10e8cf08d66cfb58d80fe878016ee3e4e751 Mon Sep 17 00:00:00 2001 From: Lars Nolden Date: Tue, 1 Sep 2026 11:30:00 +0200 Subject: [PATCH] firmware: runtime preamble-detector length; generalized single-variable A/B harness --- firmware/main/console.c | 14 ++++++ firmware/main/repeater.c | 3 +- firmware/main/sx126x.c | 9 +++- firmware/main/sx126x.h | 2 + hil/param_ab.sh | 39 +++++++++++++++++ hil/param_ab_report.py | 95 ++++++++++++++++++++++++++++++++++++++++ 6 files changed, 160 insertions(+), 2 deletions(-) create mode 100755 hil/param_ab.sh create mode 100755 hil/param_ab_report.py diff --git a/firmware/main/console.c b/firmware/main/console.c index 7dca3a1..35ff31e 100644 --- a/firmware/main/console.c +++ b/firmware/main/console.c @@ -44,6 +44,20 @@ static void handle_set(char *args) } else if (strcmp(key, "repeat_enabled") == 0) { g_cfg.repeat_enabled = (val[0] == '1'); ack("set repeat_enabled", true, NULL); + } else if (strcmp(key, "preamble_bits") == 0) { + long v = strtol(val, NULL, 10); + uint8_t code; + switch (v) { + case 0: code = 0x00; break; + case 8: code = 0x04; break; + case 16: code = 0x05; break; + case 24: code = 0x06; break; + case 32: code = 0x07; break; + default: ack("set", false, "use 0|8|16|24|32"); return; + } + sx126x_set_preamble_detect(code); + repeater_request_radio_reset(); + ack("set preamble_bits", true, "radio reinit queued"); } else if (strcmp(key, "pa_low") == 0) { sx126x_set_pa_low(val[0] == '1'); repeater_request_radio_reset(); diff --git a/firmware/main/repeater.c b/firmware/main/repeater.c index 5646d29..d9d1dac 100644 --- a/firmware/main/repeater.c +++ b/firmware/main/repeater.c @@ -593,12 +593,13 @@ 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", + "\"preamble_detect_code\":%u,\"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, + sx126x_get_preamble_detect(), (int)esp_reset_reason()); } diff --git a/firmware/main/sx126x.c b/firmware/main/sx126x.c index 8c5f81b..67a47bd 100644 --- a/firmware/main/sx126x.c +++ b/firmware/main/sx126x.c @@ -57,6 +57,10 @@ 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 static bool s_pa_low = true; // true = +10 dBm-optimal PA row (lowest output) +// Preamble detector length. Shorter = more sensitive but more false syncs, +// and every false sync costs one fixed-255-byte RX window (~12 ms). +// SX126x codes: 0x00 off, 0x04 = 8 bits, 0x05 = 16, 0x06 = 24, 0x07 = 32. +static uint8_t s_preamble_det = 0x04; // ---------------------------------------------------------------- low level @@ -361,7 +365,7 @@ static bool set_packet_params(uint8_t payload_len) // 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 + s_preamble_det, // preamble detector length (see s_preamble_det) 16, // sync word length in bits 0x00, // no address filtering 0x00, // fixed length packet @@ -516,3 +520,6 @@ uint8_t sx126x_get_status(void) } void sx126x_set_pa_low(bool low) { s_pa_low = low; } + +void sx126x_set_preamble_detect(uint8_t code) { s_preamble_det = code; } +uint8_t sx126x_get_preamble_detect(void) { return s_preamble_det; } diff --git a/firmware/main/sx126x.h b/firmware/main/sx126x.h index 86e1efb..d3a279f 100644 --- a/firmware/main/sx126x.h +++ b/firmware/main/sx126x.h @@ -61,6 +61,8 @@ void fem_set_tx(bool tx); void fem_power(bool on); void fem_set_rx_csd(bool en); // LNA experiment: FEM CSD level in RX void sx126x_set_pa_low(bool low); // PA table: true = lowest documented output +void sx126x_set_preamble_detect(uint8_t code); // 0x00 off, 0x04=8b, 0x05=16b, 0x06=24b, 0x07=32b +uint8_t sx126x_get_preamble_detect(void); // Registered by caller before init; invoked from DIO1 GPIO ISR. typedef void (*sx126x_irq_cb_t)(int64_t timestamp_us); diff --git a/hil/param_ab.sh b/hil/param_ab.sh new file mode 100755 index 0000000..2b30fa9 --- /dev/null +++ b/hil/param_ab.sh @@ -0,0 +1,39 @@ +#!/usr/bin/env bash +# Controlled A/B of one runtime RF parameter, receiver-only (no SDR). +# +# Changes exactly one variable between two equal-length arms on the same +# meter population, with retransmission disabled so the receiver is measured +# in isolation. Meter traffic varies, so only large differences mean +# anything -- the report says so explicitly. +# +# Usage: param_ab.sh KEY VALUE_A VALUE_B [SECONDS_PER_ARM] +# e.g. param_ab.sh preamble_bits 8 16 900 +# param_ab.sh fem_rx_csd 1 0 600 +set -euo pipefail +cd "$(dirname "$0")/.." +KEY=$1; VA=$2; VB=$3; DUR=${4:-900} +PY=./result-py/bin/python3 + +eval "$(./tools/discover_devices.sh)" +OUT="captures/$(date +%Y-%m-%dT%H-%M-%S)-ab-$KEY" +mkdir -p "$OUT" +echo "DUT: $DUT_PORT" +echo "variable: $KEY arms: $VA vs $VB ${DUR}s each" + +for V in "$VA" "$VB"; do + label="${KEY}_${V}" + echo "--- arm: $label" + $PY hil/dut_cmd.py "$DUT_PORT" --listen 4 \ + "set repeat_enabled 0" "set $KEY $V" "clear_stats" \ + > "$OUT/$label.setup.log" 2>&1 + sleep 4 + $PY hil/dut_cmd.py "$DUT_PORT" --listen "$DUR" status > "$OUT/$label.log" 2>&1 + $PY hil/dut_cmd.py "$DUT_PORT" --listen 5 stats >> "$OUT/$label.log" 2>&1 +done + +# restore +$PY hil/dut_cmd.py "$DUT_PORT" --listen 4 \ + "set $KEY $VA" "set repeat_enabled 1" > "$OUT/restore.log" 2>&1 + +$PY hil/param_ab_report.py "$OUT" "$KEY" "$VA" "$VB" | tee "$OUT/report.txt" +echo "artifacts: $OUT" diff --git a/hil/param_ab_report.py b/hil/param_ab_report.py new file mode 100755 index 0000000..f75fba6 --- /dev/null +++ b/hil/param_ab_report.py @@ -0,0 +1,95 @@ +#!/usr/bin/env python3 +"""Summarise a single-variable receiver A/B experiment (hil/param_ab.sh).""" +import json +import sys +from collections import Counter + +d, key, va, vb = sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4] + +print("=" * 60) +print(f"RECEIVER A/B: {key} ({va} vs {vb})") +print("=" * 60) + +summary = {} +for v in (va, vb): + label = f"{key}_{v}" + rx, stats = [], None + try: + fh = open(f"{d}/{label}.log", errors="replace") + except OSError: + print(f"\n{key}={v}: no data") + continue + for line in fh: + line = line.strip() + if not line.startswith("{"): + continue + try: + ev = json.loads(line) + except json.JSONDecodeError: + continue + if ev.get("event") == "wmbus_rx": + rx.append(ev) + elif ev.get("event") == "stats": + stats = ev + + ok = [r for r in rx if r.get("crc_ok")] + meters = Counter(r["raw"][8:16].lower() for r in ok + if len(r.get("raw", "")) >= 16) + rssi_ok = sorted(r["rssi_dbm"] for r in ok if "rssi_dbm" in r) + st = stats or {} + cand = st.get("rx_candidates") + notc1 = st.get("rx_not_c1") + summary[v] = { + "logged_frames": len(rx), + "crc_ok": len(ok), + "unique_meters": len(meters), + "median_rssi_crcok": rssi_ok[len(rssi_ok) // 2] if rssi_ok else None, + "weakest_crcok": rssi_ok[0] if rssi_ok else None, + "fw_candidates": cand, + "fw_valid": st.get("rx_valid"), + "fw_crc_fail": st.get("rx_crc_fail"), + "fw_not_c1": notc1, + "false_sync_pct": (round(100.0 * notc1 / cand, 1) + if cand and notc1 is not None else None), + } + + s = summary[v] + print(f""" +{key} = {v} + CRC-valid frames: {s['crc_ok']} + unique meters: {s['unique_meters']} + median RSSI (CRC ok): {s['median_rssi_crcok']} dBm + weakest CRC-ok frame: {s['weakest_crcok']} dBm + firmware candidates: {s['fw_candidates']} + firmware valid: {s['fw_valid']} + firmware CRC failures: {s['fw_crc_fail']} + not C-mode (false sync + T1): {s['fw_not_c1']} ({s['false_sync_pct']} % of candidates)""") + +a, b = summary.get(va), summary.get(vb) +if a and b: + print(f"\nCOMPARISON ({va} vs {vb})") + print(f" CRC-valid frames: {a['crc_ok']} vs {b['crc_ok']}") + print(f" unique meters: {a['unique_meters']} vs {b['unique_meters']}") + print(f" false-sync share: {a['false_sync_pct']} % vs {b['false_sync_pct']} %") + print(f" weakest CRC-ok: {a['weakest_crcok']} vs {b['weakest_crcok']} dBm") + + # A useful change reduces false syncs without losing weak frames. + def verdict(): + if a["crc_ok"] == 0 and b["crc_ok"] == 0: + return "no traffic in either arm - inconclusive" + big = max(3, min(a["crc_ok"], b["crc_ok"]) * 0.3) + if abs(a["crc_ok"] - b["crc_ok"]) < big: + fa, fb = a["false_sync_pct"], b["false_sync_pct"] + if fa is not None and fb is not None and abs(fa - fb) >= 10: + better = va if fa < fb else vb + return (f"comparable frame yield; {key}={better} has the lower " + f"false-sync share") + return "no clear difference at this sample size" + better = va if a["crc_ok"] > b["crc_ok"] else vb + return f"{key}={better} yielded clearly more CRC-valid frames" + + print(f" verdict: {verdict()}") + print("\nCaveat: arms run sequentially, so meter traffic differs between") + print("them. Treat differences below ~30 % of frame count as noise.") + +json.dump(summary, open(f"{d}/summary.json", "w"), indent=2, default=str)