From 2b9b3cfbf841e6db0b50b2c4780c41d6475a1316 Mon Sep 17 00:00:00 2001 From: Dragan Spiridonov Date: Wed, 11 Nov 2026 16:26:58 +0100 Subject: [PATCH 1/4] fix(firmware): expire radar observations before fused output --- firmware/esp32-csi-node/main/mmwave_sensor.c | 133 +++++++++++------- firmware/esp32-csi-node/main/mmwave_sensor.h | 5 +- firmware/esp32-csi-node/test/Makefile | 8 ++ .../test/test_mmwave_freshness.c | 65 +++++++++ 4 files changed, 163 insertions(+), 48 deletions(-) create mode 100644 firmware/esp32-csi-node/test/test_mmwave_freshness.c diff --git a/firmware/esp32-csi-node/main/mmwave_sensor.c b/firmware/esp32-csi-node/main/mmwave_sensor.c index 97713e8911..28e9126c3e 100644 --- a/firmware/esp32-csi-node/main/mmwave_sensor.c +++ b/firmware/esp32-csi-node/main/mmwave_sensor.c @@ -71,6 +71,18 @@ static const char *TAG = "mmwave"; /* ---- Shared state ---- */ static mmwave_state_t s_state; static volatile bool s_running; +static portMUX_TYPE s_state_lock = portMUX_INITIALIZER_UNLOCKED; +/* Transport expiry only; this is not a clinical or occupancy qualification. */ +#define MMWAVE_DATA_MAX_AGE_US INT64_C(5000000) +typedef struct { + int64_t presence_us, heart_us, breathing_us, distance_us; +} mmwave_field_times_t; +static mmwave_field_times_t s_field_times; + +static bool mmwave_time_fresh(int64_t observed, int64_t now) +{ + return observed > 0 && now >= observed && now - observed <= MMWAVE_DATA_MAX_AGE_US; +} /* ====================================================================== * MR60BHA2 Parser (corrected protocol from Seeed Arduino library) @@ -106,63 +118,59 @@ static mr60_parser_t s_mr60; static void mr60_process_frame(uint16_t type, const uint8_t *data, uint16_t len) { + const int64_t now = esp_timer_get_time(); + bool accepted = false; + portENTER_CRITICAL(&s_state_lock); s_state.frame_count++; - s_state.last_update_us = esp_timer_get_time(); - switch (type) { - case MR60_TYPE_BREATHING: - if (len >= sizeof(float)) { - /* Breathing rate as float32 (little-endian in payload). */ - float br; - memcpy(&br, data, sizeof(float)); - if (br >= 0.0f && br <= 60.0f) { - s_state.breathing_rate = br; - } - } + case MR60_TYPE_BREATHING: { + float value = NAN; + if (len >= sizeof(value)) memcpy(&value, data, sizeof(value)); + const bool valid = isfinite(value) && value >= 0.0f && value <= 60.0f; + s_state.breathing_rate = valid ? value : 0.0f; + s_field_times.breathing_us = valid ? now : 0; + accepted = valid; break; - - case MR60_TYPE_HEARTRATE: - if (len >= sizeof(float)) { - float hr; - memcpy(&hr, data, sizeof(float)); - if (hr >= 0.0f && hr <= 250.0f) { - s_state.heart_rate_bpm = hr; - } - } + } + case MR60_TYPE_HEARTRATE: { + float value = NAN; + if (len >= sizeof(value)) memcpy(&value, data, sizeof(value)); + const bool valid = isfinite(value) && value >= 0.0f && value <= 250.0f; + s_state.heart_rate_bpm = valid ? value : 0.0f; + s_field_times.heart_us = valid ? now : 0; + accepted = valid; break; - - case MR60_TYPE_DISTANCE: - if (len >= sizeof(uint32_t) + sizeof(float)) { - /* Bytes 0-3: range flag (uint32 LE). 0 = no valid distance. */ - uint32_t range_flag; - memcpy(&range_flag, data, sizeof(uint32_t)); - if (range_flag != 0) { - float dist; - memcpy(&dist, &data[sizeof(uint32_t)], sizeof(float)); - s_state.distance_cm = dist; - } + } + case MR60_TYPE_DISTANCE: { + uint32_t range_flag = 0; + float value = NAN; + if (len >= sizeof(range_flag) + sizeof(value)) { + memcpy(&range_flag, data, sizeof(range_flag)); + memcpy(&value, data + sizeof(range_flag), sizeof(value)); } + const bool valid = range_flag != 0 && isfinite(value) && value >= 0.0f; + s_state.distance_cm = valid ? value : 0.0f; + s_field_times.distance_us = valid ? now : 0; + accepted = valid; break; - + } case MR60_TYPE_PRESENCE: if (len >= 1) { - s_state.person_present = (data[0] != 0); - /* MR60BHA2 exposes a single-target vital-sign presence flag rather - * than a reliable people-count frame. Keep the public count in - * lockstep with that authoritative flag so downstream clients do - * not report zero targets while fresh radar vitals are arriving. */ + s_state.person_present = data[0] != 0; s_state.target_count = mmwave_mr60_target_count(s_state.person_present); + s_field_times.presence_us = now; + accepted = true; if (!s_state.person_present) { - s_state.heart_rate_bpm = 0.0f; - s_state.breathing_rate = 0.0f; - s_state.distance_cm = 0.0f; + s_state.heart_rate_bpm = s_state.breathing_rate = s_state.distance_cm = 0.0f; + s_field_times.heart_us = s_field_times.breathing_us = s_field_times.distance_us = 0; } } break; - default: break; } + if (accepted) s_state.last_update_us = now; + portEXIT_CRITICAL(&s_state_lock); } static void mr60_feed_byte(uint8_t b) @@ -249,15 +257,12 @@ static ld2410_parser_t s_ld; static void ld2410_process_frame(const uint8_t *data, uint16_t len) { - s_state.frame_count++; - s_state.last_update_us = esp_timer_get_time(); - if (len < 12) return; uint8_t data_type = data[0]; /* 0x02 = normal, 0x01 = engineering */ uint8_t head_marker = data[1]; /* Must be 0xAA */ - if (head_marker != LD2410_REPORT_HEAD) return; + if (head_marker != LD2410_REPORT_HEAD || (data_type != 1 && data_type != 2) || data[2] > 3) return; /* Normal mode target report (data_type 0x02 or 0x01) */ uint8_t target_state = data[2]; @@ -271,6 +276,11 @@ static void ld2410_process_frame(const uint8_t *data, uint16_t len) (void)static_energy; (void)detect_dist; + const int64_t now = esp_timer_get_time(); + portENTER_CRITICAL(&s_state_lock); + s_state.frame_count++; + s_state.last_update_us = now; + s_field_times.presence_us = s_field_times.distance_us = now; s_state.person_present = (target_state != 0); s_state.target_count = (target_state != 0) ? 1 : 0; @@ -281,6 +291,7 @@ static void ld2410_process_frame(const uint8_t *data, uint16_t len) } else { s_state.distance_cm = 0.0f; } + portEXIT_CRITICAL(&s_state_lock); } static void ld2410_feed_byte(uint8_t b) @@ -346,6 +357,7 @@ static void mock_mmwave_task(void *arg) float hr_noise = 2.0f * sinf((float)tick * 0.1f) + 0.5f * sinf((float)tick * 0.37f); float br_noise = 1.0f * sinf((float)tick * 0.07f) + 0.3f * sinf((float)tick * 0.23f); + portENTER_CRITICAL(&s_state_lock); s_state.heart_rate_bpm = hr_base + hr_noise; s_state.breathing_rate = br_base + br_noise; s_state.person_present = true; @@ -353,6 +365,8 @@ static void mock_mmwave_task(void *arg) s_state.target_count = 1; s_state.frame_count++; s_state.last_update_us = esp_timer_get_time(); + s_field_times = (mmwave_field_times_t){s_state.last_update_us, s_state.last_update_us, + s_state.last_update_us, s_state.last_update_us}; /* Simulate person leaving at tick 200-250 (for scenario testing). */ if (tick >= 200 && tick <= 250) { @@ -363,6 +377,7 @@ static void mock_mmwave_task(void *arg) s_state.target_count = 0; } + portEXIT_CRITICAL(&s_state_lock); /* ~1 Hz update rate (matches real MR60BHA2). */ vTaskDelay(pdMS_TO_TICKS(1000)); } @@ -496,6 +511,7 @@ const char *mmwave_type_name(mmwave_type_t type) esp_err_t mmwave_sensor_init(int uart_tx_pin, int uart_rx_pin) { memset(&s_state, 0, sizeof(s_state)); + memset(&s_field_times, 0, sizeof(s_field_times)); memset(&s_mr60, 0, sizeof(s_mr60)); memset(&s_ld, 0, sizeof(s_ld)); s_running = true; @@ -641,7 +657,30 @@ esp_err_t mmwave_sensor_init(int uart_tx_pin, int uart_rx_pin) bool mmwave_sensor_get_state(mmwave_state_t *state) { - if (!s_state.detected || state == NULL) return false; - memcpy(state, &s_state, sizeof(mmwave_state_t)); + if (state == NULL) return false; + mmwave_field_times_t times; + portENTER_CRITICAL(&s_state_lock); + memcpy(state, &s_state, sizeof(*state)); + times = s_field_times; + portEXIT_CRITICAL(&s_state_lock); + const int64_t now = esp_timer_get_time(); + /* Missing presence is unavailable, never a new empty-room observation. + * The existing wire format cannot represent unknown range while present: + * mobile treats zero as a measured distance. Withhold that whole snapshot. */ + if (!state->detected || !mmwave_time_fresh(times.presence_us, now) || + (state->person_present && !mmwave_time_fresh(times.distance_us, now))) { + state->detected = false; + state->person_present = false; + state->target_count = 0; + state->heart_rate_bpm = state->breathing_rate = state->distance_cm = 0.0f; + return false; + } + if (!state->person_present) { + state->heart_rate_bpm = state->breathing_rate = state->distance_cm = 0.0f; + } else { + /* Zero is the existing unavailable encoding for numeric vital rates. */ + if (!mmwave_time_fresh(times.heart_us, now)) state->heart_rate_bpm = 0.0f; + if (!mmwave_time_fresh(times.breathing_us, now)) state->breathing_rate = 0.0f; + } return true; } diff --git a/firmware/esp32-csi-node/main/mmwave_sensor.h b/firmware/esp32-csi-node/main/mmwave_sensor.h index b1b4d78d97..ea8e2c95b8 100644 --- a/firmware/esp32-csi-node/main/mmwave_sensor.h +++ b/firmware/esp32-csi-node/main/mmwave_sensor.h @@ -71,7 +71,10 @@ esp_err_t mmwave_sensor_init(int uart_tx_pin, int uart_rx_pin); * Get a snapshot of the current mmWave state (thread-safe copy). * * @param state Output state struct. - * @return true if valid data is available (sensor detected and running). + * Expired/unseen presence and present-without-fresh-range withhold the snapshot. + * Optional expired vital rates use zero (unavailable). False means unavailable, + * not an observed empty room; sensor identity is retained for fresh recovery. + * @return true if a representable, fresh radar observation is available. */ bool mmwave_sensor_get_state(mmwave_state_t *state); diff --git a/firmware/esp32-csi-node/test/Makefile b/firmware/esp32-csi-node/test/Makefile index 292fca5499..9afbee80c9 100644 --- a/firmware/esp32-csi-node/test/Makefile +++ b/firmware/esp32-csi-node/test/Makefile @@ -263,3 +263,11 @@ clean: test_thermal test_csi_sanitize test_c6_antenna test_serial_onboarding \ test_ota_health test_onboarding_identity test_config_rules test_edge_stbc test_edge_current_grid test_csi_he_gate test_node_mdns test_self_ping test_config_recovery rm -rf corpus_serialize/ corpus_edge/ corpus_nvs/ + +# Production parser/snapshot: stale UART and independent measurement expiry. +.PHONY: test_mmwave_freshness run_mmwave_freshness +test_mmwave_freshness: test_mmwave_freshness.c $(MAIN_DIR)/mmwave_sensor.c $(MAIN_DIR)/mmwave_sensor.h + cc -std=c99 -Wall -Wextra -Wno-unused-function -Wno-unused-parameter -Istubs -I$(MAIN_DIR) -ffunction-sections $< $(DEAD_STRIP_LDFLAGS) -lm -o $@ +run_mmwave_freshness: test_mmwave_freshness + ./test_mmwave_freshness +host_tests: run_mmwave_freshness diff --git a/firmware/esp32-csi-node/test/test_mmwave_freshness.c b/firmware/esp32-csi-node/test/test_mmwave_freshness.c new file mode 100644 index 0000000000..779f406b38 --- /dev/null +++ b/firmware/esp32-csi-node/test/test_mmwave_freshness.c @@ -0,0 +1,65 @@ +/* Exercises the production parser/snapshot with a fake clock and host task stubs. */ +#include +#include +#include +#define CONFIG_CSI_MOCK_ENABLED 1 +typedef int portMUX_TYPE; +#define portMUX_INITIALIZER_UNLOCKED 0 +#define portENTER_CRITICAL(lock) ((void)(lock)) +#define portEXIT_CRITICAL(lock) ((void)(lock)) +static int64_t test_now; +static inline void vTaskDelete(void *task) { (void)task; } +#include "../main/mmwave_sensor.c" +int64_t esp_timer_get_time(void) { return test_now; } +static void reset(void) { + memset(&s_state, 0, sizeof(s_state)); memset(&s_field_times, 0, sizeof(s_field_times)); + memset(&s_mr60, 0, sizeof(s_mr60)); s_state.type = MMWAVE_TYPE_MR60BHA2; + s_state.detected = true; test_now = 1000000; +} +static void frame(uint16_t type, const void *data, uint16_t length) { + uint8_t h[] = {1,0,1,(uint8_t)(length>>8),(uint8_t)length,(uint8_t)(type>>8),(uint8_t)type,0}; + h[7] = mr60_calc_checksum(h, 7); + for (unsigned i=0;i Date: Wed, 11 Nov 2026 16:30:12 +0100 Subject: [PATCH 2/4] test(firmware): retain upstream radar presence byte semantics --- firmware/esp32-csi-node/test/test_mmwave_freshness.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/firmware/esp32-csi-node/test/test_mmwave_freshness.c b/firmware/esp32-csi-node/test/test_mmwave_freshness.c index 779f406b38..0ffda92b75 100644 --- a/firmware/esp32-csi-node/test/test_mmwave_freshness.c +++ b/firmware/esp32-csi-node/test/test_mmwave_freshness.c @@ -35,6 +35,8 @@ int main(void) { test_now=1000000; complete(); assert(mmwave_sensor_get_state(&out)); assert(out.person_present && out.target_count==1 && out.heart_rate_bpm==72); + uint8_t nonzero_presence=255; frame(MR60_TYPE_PRESENCE,&nonzero_presence,1); + assert(mmwave_sensor_get_state(&out) && out.person_present); /* Upstream bool conversion. */ test_now+=MMWAVE_DATA_MAX_AGE_US; assert(mmwave_sensor_get_state(&out)); ++test_now; assert(!mmwave_sensor_get_state(&out) && !out.detected && s_state.detected); presence(false); assert(mmwave_sensor_get_state(&out) && !out.person_present); From 372d68e89f07899d994ddec7b94f45859ee91d21 Mon Sep 17 00:00:00 2001 From: Dragan Spiridonov Date: Wed, 11 Nov 2026 17:07:32 +0100 Subject: [PATCH 3/4] fix(firmware): split opt-in MR60 delivery from raw CSI --- firmware/esp32-csi-node/README.md | 23 +++++++ .../esp32-csi-node/main/edge_processing.c | 2 +- firmware/esp32-csi-node/main/main.c | 4 ++ firmware/esp32-csi-node/main/nvs_config.c | 22 +++++- firmware/esp32-csi-node/main/nvs_config.h | 1 + .../esp32-csi-node/main/radar_fused_route.h | 26 +++++++ firmware/esp32-csi-node/main/stream_sender.c | 43 ++++++++++++ firmware/esp32-csi-node/main/stream_sender.h | 10 +++ firmware/esp32-csi-node/test/Makefile | 14 ++++ .../esp32-csi-node/test/stubs/esp_stubs.c | 11 +++ .../esp32-csi-node/test/stubs/esp_stubs.h | 3 + .../esp32-csi-node/test/stubs/lwip/netdb.h | 2 + .../esp32-csi-node/test/stubs/lwip/sockets.h | 7 ++ .../test/test_radar_fused_route.c | 68 +++++++++++++++++++ firmware/esp32-csi-node/test/test_radar_nvs.c | 44 ++++++++++++ 15 files changed, 278 insertions(+), 2 deletions(-) create mode 100644 firmware/esp32-csi-node/main/radar_fused_route.h create mode 100644 firmware/esp32-csi-node/test/stubs/lwip/netdb.h create mode 100644 firmware/esp32-csi-node/test/stubs/lwip/sockets.h create mode 100644 firmware/esp32-csi-node/test/test_radar_fused_route.c create mode 100644 firmware/esp32-csi-node/test/test_radar_nvs.c diff --git a/firmware/esp32-csi-node/README.md b/firmware/esp32-csi-node/README.md index 81a359be56..87f2791054 100644 --- a/firmware/esp32-csi-node/README.md +++ b/firmware/esp32-csi-node/README.md @@ -323,6 +323,27 @@ The boot log must identify `MR60BHA2` and the server must receive fresh `edge_fused_vitals` packets before the radar is considered connected. Radar reported heart and breathing values remain unvalidated, nonmedical evidence. +##### Optional split destination for MR60 fused radar + +The default remains one target for every stream. An explicit `csi_cfg` +NVS `u16` key `radar_port` opts the fresh MR60 fused-vitals branch into another +UDP port on the **same configured `target_ip`**. Absent/zero means legacy; +nonzero must be at least1024 and differ from `target_port`. For example, keep +raw CSI and ordinary edge/sync/feature packets on a private receiver port and +route only the existing48-byte `0xC5110004` MR60 packet to a radar-aware server. +The configured node ID, MR60 type, finite/range bounds and presence/count +consistency are checked, and the split path is capped at two packets/second. +Invalid explicit configuration, invalid packets or a split send failure never +fall back to the bulk destination. A wrong-type/unreadable NVS key blocks the +split rather than silently resuming legacy routing. + +Provision this opt-in using an existing private NVS workflow which preserves +network settings and the other namespace entries; it is not a new HTTP or +serial configuration field. Confirm the receiving server handles fused radar +without inserting it into RF learner ingress. Keep CSI acquisition enabled: +the current edge processing cadence drives fused delivery. Firmware routing +changes neither server output/privacy gates nor sensing qualification. + ### 3. Provision WiFi credentials (no reflash needed) ```bash @@ -649,6 +670,8 @@ python config_push.py --fleet nodes.txt --set edge_tier=1 --no-reboot Config is read only at boot, so a change does nothing until the node restarts. `config_push.py` therefore restarts it by default; `--no-reboot` stages instead. + + #### Why some parameters reboot-and-prove Most settings are recoverable: a wrong `target_ip` sends CSI nowhere, but the diff --git a/firmware/esp32-csi-node/main/edge_processing.c b/firmware/esp32-csi-node/main/edge_processing.c index 23620f05e3..63e9f15b36 100644 --- a/firmware/esp32-csi-node/main/edge_processing.c +++ b/firmware/esp32-csi-node/main/edge_processing.c @@ -984,7 +984,7 @@ static void send_vitals_packet(void) fpkt.mmwave_targets = mw.target_count; fpkt.mmwave_confidence = (mw.frame_count > 10) ? 80 : 40; - stream_sender_send((const uint8_t *)&fpkt, sizeof(fpkt)); + stream_sender_send_radar_fused((const uint8_t *)&fpkt, sizeof(fpkt)); } else { /* No mmWave — send standard 32-byte packet. */ stream_sender_send((const uint8_t *)&pkt, sizeof(pkt)); diff --git a/firmware/esp32-csi-node/main/main.c b/firmware/esp32-csi-node/main/main.c index 328c3aae28..244a0d23aa 100644 --- a/firmware/esp32-csi-node/main/main.c +++ b/firmware/esp32-csi-node/main/main.c @@ -481,6 +481,10 @@ void app_main(void) ESP_LOGE(TAG, "Failed to initialize UDP sender"); return; } + if (stream_sender_configure_radar(g_nvs_config.radar_fused_port, g_nvs_config.node_id) != 0) { + ESP_LOGW(TAG, "Split radar destination unavailable; check explicit radar_port configuration"); + } + #endif /* Initialize CSI collection */ diff --git a/firmware/esp32-csi-node/main/nvs_config.c b/firmware/esp32-csi-node/main/nvs_config.c index 88d7c06891..fa1a0d6fd8 100644 --- a/firmware/esp32-csi-node/main/nvs_config.c +++ b/firmware/esp32-csi-node/main/nvs_config.c @@ -47,6 +47,7 @@ void nvs_config_load(nvs_config_t *cfg) strlcpy(cfg->target_ip, CONFIG_CSI_TARGET_IP, sizeof(cfg->target_ip)); cfg->target_port = (uint16_t)CONFIG_CSI_TARGET_PORT; + cfg->radar_fused_port = 0; /* Only absent NVS or explicit zero selects legacy routing. */ cfg->node_id = (uint8_t)CONFIG_CSI_NODE_ID; /* ADR-029: Defaults for channel hopping and TDM. @@ -109,7 +110,12 @@ void nvs_config_load(nvs_config_t *cfg) nvs_handle_t handle; esp_err_t err = nvs_open("csi_cfg", NVS_READONLY, &handle); if (err != ESP_OK) { - ESP_LOGI(TAG, "No NVS config found, using compiled defaults"); + if (err == ESP_ERR_NVS_NOT_FOUND) { + ESP_LOGI(TAG, "No NVS config found, using compiled defaults"); + } else { + cfg->radar_fused_port = 1; /* Unknown opt-in state must not select bulk. */ + ESP_LOGW(TAG, "NVS config unreadable; split radar routing blocked"); + } return; } @@ -144,6 +150,20 @@ void nvs_config_load(nvs_config_t *cfg) ESP_LOGI(TAG, "NVS override: target_port=%u", cfg->target_port); } + /* Explicit opt-in split route. Preserve invalid intent as a blocked port + * so a bad nonzero/wrong-type value cannot silently resume legacy routing. */ + uint16_t radar_port; + const esp_err_t radar_result = nvs_get_u16(handle, "radar_port", &radar_port); + if (radar_result == ESP_OK) { + cfg->radar_fused_port = radar_port; + if (radar_port != 0 && (radar_port < 1024 || radar_port == cfg->target_port)) { + ESP_LOGW(TAG, "Refusing invalid split radar port"); + } + } else if (radar_result != ESP_ERR_NVS_NOT_FOUND) { + cfg->radar_fused_port = 1; /* Invalid reserved sentinel: fail closed. */ + ESP_LOGW(TAG, "Refusing unreadable split radar port"); + } + /* Node ID */ uint8_t node_val; if (nvs_get_u8(handle, "node_id", &node_val) == ESP_OK) { diff --git a/firmware/esp32-csi-node/main/nvs_config.h b/firmware/esp32-csi-node/main/nvs_config.h index 536e586acb..14c0a17d00 100644 --- a/firmware/esp32-csi-node/main/nvs_config.h +++ b/firmware/esp32-csi-node/main/nvs_config.h @@ -31,6 +31,7 @@ typedef struct { char wifi_password[NVS_CFG_PASS_MAX]; char target_ip[NVS_CFG_IP_MAX]; uint16_t target_port; + uint16_t radar_fused_port; /**< Optional same-IP MR60 fused-only port; 0 = legacy routing. */ uint8_t node_id; /* ADR-029: Channel hopping and TDM configuration */ diff --git a/firmware/esp32-csi-node/main/radar_fused_route.h b/firmware/esp32-csi-node/main/radar_fused_route.h new file mode 100644 index 0000000000..51c7758a0c --- /dev/null +++ b/firmware/esp32-csi-node/main/radar_fused_route.h @@ -0,0 +1,26 @@ +#ifndef RUVIEW_RADAR_FUSED_ROUTE_H +#define RUVIEW_RADAR_FUSED_ROUTE_H +#include +#include +#include +#include +#include + +/* Existing ADR-063 little-endian 48-byte MR60 fused packet; never raw CSI. */ +static inline bool ruview_mr60_fused_packet(const uint8_t *data, size_t len, uint8_t node_id) +{ + if (data == NULL || len != 48 || data[0] != 4 || data[1] != 0 || + data[2] != 0x11 || data[3] != 0xC5 || data[4] != node_id || data[14] != 1) + return false; + float motion, score, hr, br, range; + memcpy(&motion, data + 16, 4); memcpy(&score, data + 20, 4); + memcpy(&hr, data + 28, 4); memcpy(&br, data + 32, 4); memcpy(&range, data + 36, 4); + return isfinite(motion) && motion >= 0 && motion <= 1e6f && + isfinite(score) && score >= 0 && score <= 1e6f && + isfinite(hr) && hr >= 0 && hr <= 250 && + isfinite(br) && br >= 0 && br <= 60 && + isfinite(range) && range >= 0 && range <= 3000 && + data[15] <= 100 && data[41] <= 100 && data[40] <= 1 && + ((data[5] & 8) != 0) == (data[40] == 1); +} +#endif diff --git a/firmware/esp32-csi-node/main/stream_sender.c b/firmware/esp32-csi-node/main/stream_sender.c index b766aff52e..dd4aca9cb3 100644 --- a/firmware/esp32-csi-node/main/stream_sender.c +++ b/firmware/esp32-csi-node/main/stream_sender.c @@ -6,6 +6,7 @@ */ #include "stream_sender.h" +#include "radar_fused_route.h" #include #include "esp_log.h" @@ -18,6 +19,11 @@ static const char *TAG = "stream_sender"; static int s_sock = -1; static struct sockaddr_in s_dest_addr; +static struct sockaddr_in s_radar_addr; +static bool s_radar_enabled; +static bool s_radar_requested; +static uint8_t s_radar_node_id; +static int64_t s_radar_last_send_us = -1; /** * ENOMEM backoff state. @@ -45,6 +51,9 @@ static int64_t s_last_success_us = 0; static int sender_init_internal(const char *ip, uint16_t port) { + s_radar_enabled = false; + s_radar_requested = false; + s_radar_last_send_us = -1; s_sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); if (s_sock < 0) { ESP_LOGE(TAG, "Failed to create socket: errno %d", errno); @@ -76,6 +85,37 @@ int stream_sender_init_with(const char *ip, uint16_t port) return sender_init_internal(ip, port); } +int stream_sender_configure_radar(uint16_t port, uint8_t node_id) +{ + s_radar_requested = port != 0; + s_radar_enabled = false; + s_radar_last_send_us = -1; + if (port == 0) return 0; + if (s_sock < 0 || port < 1024 || port == ntohs(s_dest_addr.sin_port)) return -1; + s_radar_addr = s_dest_addr; + s_radar_addr.sin_port = htons(port); + s_radar_node_id = node_id; + s_radar_enabled = true; + ESP_LOGI(TAG, "MR60 fused-only split destination enabled on port %u", port); + return 0; +} + +int stream_sender_send_radar_fused(const uint8_t *data, size_t len) +{ + if (!s_radar_requested) return stream_sender_send(data, len); + if (!s_radar_enabled || s_sock < 0 || !ruview_mr60_fused_packet(data, len, s_radar_node_id)) return -1; + const int64_t now = esp_timer_get_time(); + /* At most two radar datagrams/second, independent of CSI sampling rate. */ + if (s_radar_last_send_us >= 0 && + (now < s_radar_last_send_us || now - s_radar_last_send_us < 500000)) return -1; + const int sent = sendto(s_sock, data, len, 0, + (const struct sockaddr *)&s_radar_addr, sizeof(s_radar_addr)); + if (sent != (int)len) return -1; /* No bulk fallback on failure. */ + s_radar_last_send_us = now; + s_last_success_us = now; + return sent; +} + int stream_sender_send(const uint8_t *data, size_t len) { if (s_sock < 0) { @@ -167,6 +207,9 @@ int64_t stream_sender_last_success_us(void) void stream_sender_deinit(void) { + s_radar_enabled = false; + s_radar_requested = false; + s_radar_last_send_us = -1; if (s_sock >= 0) { close(s_sock); s_sock = -1; diff --git a/firmware/esp32-csi-node/main/stream_sender.h b/firmware/esp32-csi-node/main/stream_sender.h index 8dedca4313..a48452b92b 100644 --- a/firmware/esp32-csi-node/main/stream_sender.h +++ b/firmware/esp32-csi-node/main/stream_sender.h @@ -36,6 +36,16 @@ int stream_sender_init_with(const char *ip, uint16_t port); */ int stream_sender_send(const uint8_t *data, size_t len); +/** Opt into MR60 fused-only delivery on another port of the same target IP. + * Zero disables it (legacy behavior). Nonzero ports must be >=1024 and differ + * from the bulk target. The configured node identity is part of the filter. */ +int stream_sender_configure_radar(uint16_t port, uint8_t node_id); + +/** Only the fresh MR60 branch of edge_processing calls this. With a split + * route enabled, invalid frames and send failures are dropped, never retried + * through the bulk destination. With it disabled, the legacy send path applies. */ +int stream_sender_send_radar_fused(const uint8_t *data, size_t len); + /** * Send a low-rate control packet, bypassing the ENOMEM backoff gate (#1183). * diff --git a/firmware/esp32-csi-node/test/Makefile b/firmware/esp32-csi-node/test/Makefile index 9afbee80c9..ed6ed409ac 100644 --- a/firmware/esp32-csi-node/test/Makefile +++ b/firmware/esp32-csi-node/test/Makefile @@ -271,3 +271,17 @@ test_mmwave_freshness: test_mmwave_freshness.c $(MAIN_DIR)/mmwave_sensor.c $(MAI run_mmwave_freshness: test_mmwave_freshness ./test_mmwave_freshness host_tests: run_mmwave_freshness + +.PHONY: test_radar_fused_route run_radar_fused_route +test_radar_fused_route: test_radar_fused_route.c $(MAIN_DIR)/stream_sender.c $(MAIN_DIR)/radar_fused_route.h + cc -std=c99 -Wall -Wextra -Istubs -I$(MAIN_DIR) $< -lm -o $@ +run_radar_fused_route: test_radar_fused_route + ./test_radar_fused_route +host_tests: run_radar_fused_route + +.PHONY: test_radar_nvs run_radar_nvs +test_radar_nvs: test_radar_nvs.c $(MAIN_DIR)/nvs_config.c $(STUBS_SRC) + cc -std=c99 -Wall -Wextra -Istubs -I$(MAIN_DIR) $< $(STUBS_SRC) -lm -o $@ +run_radar_nvs: test_radar_nvs + ./test_radar_nvs +host_tests: run_radar_nvs diff --git a/firmware/esp32-csi-node/test/stubs/esp_stubs.c b/firmware/esp32-csi-node/test/stubs/esp_stubs.c index e6c2b4ba69..eb70d41661 100644 --- a/firmware/esp32-csi-node/test/stubs/esp_stubs.c +++ b/firmware/esp32-csi-node/test/stubs/esp_stubs.c @@ -30,6 +30,17 @@ int stream_sender_send(const uint8_t *data, size_t len) return (int)len; } +int stream_sender_send_radar_fused(const uint8_t *data, size_t len) +{ + return stream_sender_send(data, len); +} + +int stream_sender_configure_radar(uint16_t port, uint8_t node_id) +{ + (void)port; (void)node_id; + return 0; +} + int stream_sender_init(void) { return 0; diff --git a/firmware/esp32-csi-node/test/stubs/esp_stubs.h b/firmware/esp32-csi-node/test/stubs/esp_stubs.h index e2dc08abc2..365e533919 100644 --- a/firmware/esp32-csi-node/test/stubs/esp_stubs.h +++ b/firmware/esp32-csi-node/test/stubs/esp_stubs.h @@ -19,6 +19,7 @@ /* ---- esp_err.h ---- */ typedef int esp_err_t; #define ESP_OK 0 +#define ESP_ERR_NVS_NOT_FOUND 0x1102 #define ESP_FAIL (-1) #define ESP_ERR_NO_MEM 0x101 #define ESP_ERR_INVALID_ARG 0x102 @@ -199,6 +200,8 @@ static inline esp_err_t nvs_get_blob(nvs_handle_t h, const char *k, void *v, siz /* ---- stream_sender stubs (defined in esp_stubs.c) ---- */ int stream_sender_send(const uint8_t *data, size_t len); +int stream_sender_send_radar_fused(const uint8_t *data, size_t len); +int stream_sender_configure_radar(uint16_t port, uint8_t node_id); int stream_sender_init(void); int stream_sender_init_with(const char *ip, uint16_t port); void stream_sender_deinit(void); diff --git a/firmware/esp32-csi-node/test/stubs/lwip/netdb.h b/firmware/esp32-csi-node/test/stubs/lwip/netdb.h new file mode 100644 index 0000000000..9b4fda5285 --- /dev/null +++ b/firmware/esp32-csi-node/test/stubs/lwip/netdb.h @@ -0,0 +1,2 @@ +#pragma once +#include diff --git a/firmware/esp32-csi-node/test/stubs/lwip/sockets.h b/firmware/esp32-csi-node/test/stubs/lwip/sockets.h new file mode 100644 index 0000000000..313b4faea1 --- /dev/null +++ b/firmware/esp32-csi-node/test/stubs/lwip/sockets.h @@ -0,0 +1,7 @@ +#pragma once +/* Host-only adapter for executing the production UDP sender with test sockets. */ +#include +#include +#include +#include +#include diff --git a/firmware/esp32-csi-node/test/test_radar_fused_route.c b/firmware/esp32-csi-node/test/test_radar_fused_route.c new file mode 100644 index 0000000000..6f8ba0ce5f --- /dev/null +++ b/firmware/esp32-csi-node/test/test_radar_fused_route.c @@ -0,0 +1,68 @@ +/* Actual production sender with captured socket calls; no network traffic. */ +#include +#include +#include +#include +#include +#define socket route_test_socket +#define sendto route_test_sendto +#define close route_test_close +#include "../main/stream_sender.c" +static int sends, error_mode; +static int64_t test_now; +static uint16_t observed_port; +static uint32_t observed_ip; +static uint8_t observed[512]; +static size_t observed_len; +int route_test_socket(int domain, int type, int protocol) { + assert(domain==AF_INET && type==SOCK_DGRAM && protocol==IPPROTO_UDP); return 7; +} +int route_test_close(int fd) { assert(fd==7); return 0; } +ssize_t route_test_sendto(int fd, const void *data, size_t len, int flags, + const struct sockaddr *destination, socklen_t address_len) { + assert(fd==7 && flags==0 && address_len==sizeof(struct sockaddr_in)); + sends++; const struct sockaddr_in *a=(const struct sockaddr_in *)destination; + observed_port=ntohs(a->sin_port); observed_ip=a->sin_addr.s_addr; + assert(len<=sizeof(observed)); memcpy(observed,data,len); observed_len=len; + if(error_mode) { errno=ENOMEM; return -1; } return (ssize_t)len; +} +int64_t esp_timer_get_time(void) { return test_now; } +static void fresh_tick(void) { test_now+=500000; } +int main(void) { + uint8_t packet[48]={4,0,0x11,0xC5,60}; packet[14]=1; + uint8_t raw[64]={1,0,0x11,0xC5,60}; + assert(stream_sender_init_with("192.168.1.3",55063)==0); + assert(stream_sender_configure_radar(0,60)==0); + assert(stream_sender_send_radar_fused(packet,48)==48 && observed_port==55063); + int blocked_before=sends; + assert(stream_sender_configure_radar(1023,60)==-1); + assert(stream_sender_send_radar_fused(packet,48)==-1 && sends==blocked_before); + assert(stream_sender_configure_radar(55063,60)==-1); + assert(stream_sender_send_radar_fused(packet,48)==-1 && sends==blocked_before); + assert(stream_sender_configure_radar(5005,60)==0); + fresh_tick(); assert(stream_sender_send_radar_fused(packet,48)==48); + assert(observed_port==5005 && observed_len==48 && memcmp(observed,packet,48)==0); + struct in_addr expected; assert(inet_pton(AF_INET,"192.168.1.3",&expected)==1); + assert(observed_ip==expected.s_addr); int before=sends; + assert(stream_sender_send_radar_fused(packet,48)==-1 && sends==before); /* <=2Hz. */ + fresh_tick(); assert(stream_sender_send(raw,sizeof(raw))==(int)sizeof(raw) && observed_port==55063); + assert(stream_sender_send_priority(raw,sizeof(raw))==(int)sizeof(raw) && observed_port==55063); + before=sends; + assert(stream_sender_send_radar_fused(raw,48)==-1 && sends==before); + assert(stream_sender_send_radar_fused(packet,32)==-1 && sends==before); + assert(stream_sender_send_radar_fused(NULL,48)==-1 && sends==before); + packet[4]=21; assert(stream_sender_send_radar_fused(packet,48)==-1 && sends==before);packet[4]=60; + packet[14]=2; assert(stream_sender_send_radar_fused(packet,48)==-1 && sends==before);packet[14]=1; + float bad=NAN;memcpy(packet+28,&bad,4);assert(stream_sender_send_radar_fused(packet,48)==-1 && sends==before); + bad=251;memcpy(packet+28,&bad,4);assert(stream_sender_send_radar_fused(packet,48)==-1 && sends==before); + bad=0;memcpy(packet+28,&bad,4);packet[5]=8;assert(stream_sender_send_radar_fused(packet,48)==-1 && sends==before);packet[5]=0; + error_mode=1;assert(stream_sender_send_radar_fused(packet,48)==-1 && sends==before+1); + assert(observed_port==5005); /* Failed send does NOT fall back to bulk. */ + error_mode=0;assert(stream_sender_send_radar_fused(packet,48)==48 && observed_port==5005); + fresh_tick(); assert(stream_sender_configure_radar(0,60)==0); + assert(stream_sender_send_radar_fused(packet,48)==48 && observed_port==55063); + stream_sender_deinit(); assert(stream_sender_send_radar_fused(packet,48)==-1); + before=sends; assert(stream_sender_configure_radar(5005,60)==-1); + assert(stream_sender_send_radar_fused(packet,48)==-1 && sends==before); + puts("PASS: explicit MR60 split route, byte identity, legacy defaults, source identity, bounds, rate and no failure fallback"); +} diff --git a/firmware/esp32-csi-node/test/test_radar_nvs.c b/firmware/esp32-csi-node/test/test_radar_nvs.c new file mode 100644 index 0000000000..33b2032be3 --- /dev/null +++ b/firmware/esp32-csi-node/test/test_radar_nvs.c @@ -0,0 +1,44 @@ +/* Production NVS loader with only key reads controlled by the host. */ +#include +#include +#include +/* The device libc supplies strlcpy; keep the host probe portable to libcs + * which do not expose that BSD helper under strict C99. */ +static size_t radar_test_strlcpy(char *dst, const char *src, size_t size) { + size_t len=strlen(src); + if(size) { size_t count=len Date: Wed, 11 Nov 2026 18:05:56 +0100 Subject: [PATCH 4/4] fix(ci): use SDK QEMU and hosted Clang without APT bootstrap --- .github/workflows/firmware-qemu.yml | 79 +++++++++++++---------------- 1 file changed, 34 insertions(+), 45 deletions(-) diff --git a/.github/workflows/firmware-qemu.yml b/.github/workflows/firmware-qemu.yml index 015304a5f4..bf441404e1 100644 --- a/.github/workflows/firmware-qemu.yml +++ b/.github/workflows/firmware-qemu.yml @@ -22,50 +22,32 @@ on: - 'scripts/swarm_presets/**' - '.github/workflows/firmware-qemu.yml' +defaults: + run: + shell: bash + env: IDF_VERSION: "v5.4" - QEMU_REPO: "https://github.com/espressif/qemu.git" - QEMU_BRANCH: "esp-develop" jobs: build-qemu: name: Build Espressif QEMU - # QEMU's bundled dtc fails with GCC 15 on Ubuntu 26.04. Keep the - # Ubuntu 24.04 / GCC 13 build environment until that dependency is updated. runs-on: ubuntu-24.04 + # This SDK image installs Espressif's checksum-verified QEMU package and + # its runtime libraries. Match the image used by both consumers below. + # Avoid APT DNS and an unpinned floating QEMU source build on cold caches. + container: + image: espressif/idf:v5.4@sha256:f1e9f69dc052b9afc7801ca884e0ef40c17e014bb05ce73d9c09d29290bd17fb steps: - - name: Cache QEMU build - id: cache-qemu - uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 - with: - path: /opt/qemu-esp32 - # Scope native binaries to the build image; bump v1 when refreshing - # the floating upstream branch. Do not restore an unqualified cache. - key: qemu-esp32s3-ubuntu-24.04-${{ env.QEMU_BRANCH }}-v1 - - - name: Install QEMU build dependencies - if: steps.cache-qemu.outputs.cache-hit != 'true' + - name: Prepare SDK-provided Espressif QEMU run: | - sudo apt-get update - sudo apt-get install -y \ - git build-essential ninja-build pkg-config \ - libglib2.0-dev libpixman-1-dev libslirp-dev \ - libgcrypt20-dev \ - python3 python3-venv - - - name: Clone and build Espressif QEMU - if: steps.cache-qemu.outputs.cache-hit != 'true' - run: | - git clone --depth 1 -b "$QEMU_BRANCH" "$QEMU_REPO" /tmp/qemu-esp - cd /tmp/qemu-esp - mkdir build && cd build - ../configure \ - --target-list=xtensa-softmmu \ - --prefix=/opt/qemu-esp32 \ - --enable-slirp \ - --disable-werror - ninja -j$(nproc) - ninja install + . "$IDF_PATH/export.sh" + QEMU_BIN="$(command -v qemu-system-xtensa)" + QEMU_ROOT="$(dirname "$(dirname "$QEMU_BIN")")" + "$QEMU_BIN" --version + "$QEMU_BIN" -machine help | grep -E '^esp32s3[[:space:]]' + mkdir -p /opt/qemu-esp32 + cp -a "$QEMU_ROOT/." /opt/qemu-esp32/ - name: Verify QEMU binary run: | @@ -85,7 +67,7 @@ jobs: needs: build-qemu runs-on: ubuntu-latest container: - image: espressif/idf:v5.4 + image: espressif/idf:v5.4@sha256:f1e9f69dc052b9afc7801ca884e0ef40c17e014bb05ce73d9c09d29290bd17fb strategy: fail-fast: false @@ -214,32 +196,39 @@ jobs: fuzz-test: name: Fuzz Testing (ADR-061 Layer 6) - runs-on: ubuntu-latest + runs-on: ubuntu-24.04 + env: + CC: clang-18 steps: - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 with: submodules: recursive - - name: Install clang + - name: Verify hosted Clang + # Ubuntu 24.04 hosted runners already contain Clang 18 and libFuzzer. + # Do not fetch the redundant distro meta-package before testing. run: | - sudo apt-get update - sudo apt-get install -y clang + "$CC" --version - name: Build fuzz targets working-directory: firmware/esp32-csi-node/test - run: make all CC=clang + run: make all CC="$CC" + + - name: Run radar parser, routing and NVS regressions + working-directory: firmware/esp32-csi-node/test + run: make run_mmwave_freshness run_radar_fused_route run_radar_nvs CC="$CC" - name: Run serialize fuzzer (60s) working-directory: firmware/esp32-csi-node/test - run: make run_serialize FUZZ_DURATION=60 || echo "FUZZER_CRASH=serialize" >> "$GITHUB_ENV" + run: make run_serialize CC="$CC" FUZZ_DURATION=60 || echo "FUZZER_CRASH=serialize" >> "$GITHUB_ENV" - name: Run edge enqueue fuzzer (60s) working-directory: firmware/esp32-csi-node/test - run: make run_edge FUZZ_DURATION=60 || echo "FUZZER_CRASH=edge" >> "$GITHUB_ENV" + run: make run_edge CC="$CC" FUZZ_DURATION=60 || echo "FUZZER_CRASH=edge" >> "$GITHUB_ENV" - name: Run NVS config fuzzer (60s) working-directory: firmware/esp32-csi-node/test - run: make run_nvs FUZZ_DURATION=60 || echo "FUZZER_CRASH=nvs" >> "$GITHUB_ENV" + run: make run_nvs CC="$CC" FUZZ_DURATION=60 || echo "FUZZER_CRASH=nvs" >> "$GITHUB_ENV" - name: Check for crashes working-directory: firmware/esp32-csi-node/test @@ -320,7 +309,7 @@ jobs: needs: [build-qemu] runs-on: ubuntu-latest container: - image: espressif/idf:v5.4 + image: espressif/idf:v5.4@sha256:f1e9f69dc052b9afc7801ca884e0ef40c17e014bb05ce73d9c09d29290bd17fb steps: - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262