mirror of
https://github.com/ruvnet/RuView
synced 2026-06-23 12:33:18 +00:00
ADR-081: Layer 3 mesh plane + Rust mirror trait — all 5 layers landed
Fully implements the remaining deferred pieces of the adaptive CSI mesh
firmware kernel. All 5 layers (Radio Abstraction, Adaptive Controller,
Mesh Sensing Plane, On-device Feature Extraction, Rust handoff) are
now implemented and host-tested end-to-end.
Layer 3 — Mesh Sensing Plane (firmware/esp32-csi-node/main/rv_mesh.{h,c}):
* 4 node roles: Unassigned / Anchor / Observer / FusionRelay / Coordinator
* 7 message types: TIME_SYNC, ROLE_ASSIGN, CHANNEL_PLAN,
CALIBRATION_START, FEATURE_DELTA, HEALTH, ANOMALY_ALERT
* 3 auth classes: None / HMAC-SHA256-session / Ed25519-batch
* Payload types: rv_node_status_t (28 B), rv_anomaly_alert_t (28 B),
rv_time_sync_t (16 B), rv_role_assign_t (16 B),
rv_channel_plan_t (24 B), rv_calibration_start_t (20 B)
* 16-byte envelope + payload + IEEE CRC32 trailer
* Pure rv_mesh_encode()/rv_mesh_decode() plus typed convenience encoders
* rv_mesh_send_health() + rv_mesh_send_anomaly() helpers
Controller wiring (adaptive_controller.c):
* Slow loop (30 s default) now emits HEALTH
* apply_decision() emits ANOMALY_ALERT on transitions to ALERT /
DEGRADED
* Role + mesh epoch tracked in module state; epoch bumps on role
change
Layer 5 — Rust mirror (crates/wifi-densepose-hardware/src/radio_ops.rs):
* RadioOps trait mirrors rv_radio_ops_t vtable
* MockRadio backend for offline tests
* MeshHeader / NodeStatus / AnomalyAlert types mirror rv_mesh.h
* Byte-identical IEEE CRC32 (poly 0xEDB88320) verified against
firmware test vectors (0xCBF43926 for "123456789")
* decode_mesh / decode_node_status / decode_anomaly_alert / encode_health
* 8 unit tests, including mesh_constants_match_firmware which asserts
MESH_MAGIC/VERSION/HEADER_SIZE/MAX_PAYLOAD match rv_mesh.h
byte-for-byte
* Exported from lib.rs
* signal/ruvector/train/mat crates untouched — satisfies ADR-081
portability acceptance test
Tests (all passing):
test_adaptive_controller: 18/18 (C, decide() 3.2 ns/call)
test_rv_feature_state: 15/15 (C, CRC32 87 MB/s)
test_rv_mesh: 27/27 (C, roundtrip 1.0 µs)
radio_ops::tests (Rust): 8/8
--- total: 68/68 assertions green ---
Docs:
* ADR-081 status flipped to Accepted
* Implementation-status matrix updated; L3 + Rust mirror both
marked Implemented
* Benchmarks table extended with rv_mesh encode+decode roundtrip
* Verification section updated with cargo test invocation
* CHANGELOG: two new entries for L3 mesh plane + Rust mirror
Remaining follow-ups (Phase 3.5 polish, not blocking):
* Mesh RX path (UDP listener + dispatch) on the firmware
* Ed25519 signing for CHANNEL_PLAN / CALIBRATION_START
* Hardware validation on COM7
This commit is contained in:
Claude
@@ -7,6 +7,7 @@ set(SRCS
|
||||
# ADR-081 — adaptive CSI mesh firmware kernel
|
||||
"rv_radio_ops_esp32.c"
|
||||
"rv_feature_state.c"
|
||||
"rv_mesh.c"
|
||||
"adaptive_controller.c"
|
||||
)
|
||||
|
||||
|
||||
@@ -15,6 +15,7 @@
|
||||
#include "adaptive_controller.h"
|
||||
#include "rv_radio_ops.h"
|
||||
#include "rv_feature_state.h"
|
||||
#include "rv_mesh.h"
|
||||
#include "edge_processing.h"
|
||||
#include "stream_sender.h"
|
||||
#include "csi_collector.h"
|
||||
@@ -131,14 +132,57 @@ static void collect_observation(adapt_observation_t *out)
|
||||
|
||||
/* ---- Decision application ---- */
|
||||
|
||||
/* ADR-081 L3: epoch monotonically advances per mesh session. Seeded at
|
||||
* init; every major state transition or role change bumps it so
|
||||
* receivers can order events. */
|
||||
static uint32_t s_mesh_epoch = 1;
|
||||
|
||||
/* ADR-081 L3: current node role. Updated by ROLE_ASSIGN receipt (future
|
||||
* mesh-plane RX path) or forced by tests. Default Observer. */
|
||||
static uint8_t s_role = RV_ROLE_OBSERVER;
|
||||
|
||||
/* 8-byte node id. Upper 7 bytes are zero by default; byte 0 is the
|
||||
* legacy CSI node id for compatibility with the ADR-018 header. */
|
||||
static void node_id_bytes(uint8_t out[8])
|
||||
{
|
||||
memset(out, 0, 8);
|
||||
out[0] = csi_collector_get_node_id();
|
||||
}
|
||||
|
||||
static void apply_decision(const adapt_decision_t *dec)
|
||||
{
|
||||
const rv_radio_ops_t *ops = rv_radio_ops_get();
|
||||
adapt_state_t prev = s_state;
|
||||
|
||||
if (dec->change_state) {
|
||||
ESP_LOGI(TAG, "state %u → %u",
|
||||
(unsigned)s_state, (unsigned)dec->new_state);
|
||||
s_state = (adapt_state_t)dec->new_state;
|
||||
|
||||
/* ADR-081 L3: on transition to ALERT, emit ANOMALY_ALERT on the
|
||||
* mesh plane. On any role-relevant transition, bump the epoch. */
|
||||
if (s_state == ADAPT_STATE_ALERT && prev != ADAPT_STATE_ALERT) {
|
||||
uint8_t nid[8];
|
||||
node_id_bytes(nid);
|
||||
adapt_observation_t obs;
|
||||
float motion = 0.0f, anomaly = 0.0f;
|
||||
portENTER_CRITICAL(&s_obs_lock);
|
||||
if (s_obs_valid) { obs = s_last_obs; motion = obs.motion_score;
|
||||
anomaly = obs.anomaly_score; }
|
||||
portEXIT_CRITICAL(&s_obs_lock);
|
||||
uint8_t severity = (uint8_t)(anomaly * 255.0f);
|
||||
rv_mesh_send_anomaly(s_role, s_mesh_epoch, nid,
|
||||
RV_ANOMALY_COHERENCE_LOSS, severity,
|
||||
anomaly, motion);
|
||||
}
|
||||
if (s_state == ADAPT_STATE_DEGRADED && prev != ADAPT_STATE_DEGRADED) {
|
||||
uint8_t nid[8];
|
||||
node_id_bytes(nid);
|
||||
rv_mesh_send_anomaly(s_role, s_mesh_epoch, nid,
|
||||
RV_ANOMALY_PKT_YIELD_COLLAPSE,
|
||||
200, 1.0f, 0.0f);
|
||||
}
|
||||
s_mesh_epoch++;
|
||||
}
|
||||
|
||||
if (dec->change_profile && ops != NULL && ops->set_capture_profile != NULL) {
|
||||
@@ -272,10 +316,16 @@ static void emit_feature_state(void)
|
||||
static void slow_loop_cb(TimerHandle_t t)
|
||||
{
|
||||
(void)t;
|
||||
/* Slow loop: log a heartbeat and (future Phase 3) publish HEALTH
|
||||
* messages + request CALIBRATION_START on sustained drift. */
|
||||
ESP_LOGI(TAG, "slow tick (state=%u, feature_state_seq=%u)",
|
||||
(unsigned)s_state, (unsigned)s_feature_state_seq);
|
||||
/* ADR-081 L3: publish a HEALTH mesh message every slow tick
|
||||
* (default 30 s). The coordinator uses these to track liveness and
|
||||
* detect sync-error drift. */
|
||||
uint8_t nid[8];
|
||||
node_id_bytes(nid);
|
||||
rv_mesh_send_health(s_role, s_mesh_epoch, nid);
|
||||
|
||||
ESP_LOGI(TAG, "slow tick (state=%u, feature_state_seq=%u, role=%u, epoch=%u) HEALTH sent",
|
||||
(unsigned)s_state, (unsigned)s_feature_state_seq,
|
||||
(unsigned)s_role, (unsigned)s_mesh_epoch);
|
||||
}
|
||||
|
||||
/* ---- Public API ---- */
|
||||
|
||||
@@ -0,0 +1,251 @@
|
||||
/**
|
||||
* @file rv_mesh.c
|
||||
* @brief ADR-081 Layer 3 — Mesh Sensing Plane implementation.
|
||||
*
|
||||
* Encoder/decoder are pure functions (no ESP-IDF deps) and therefore
|
||||
* host-unit-testable. The send helpers wrap stream_sender so the
|
||||
* firmware can use a single upstream socket for all payload types.
|
||||
*/
|
||||
|
||||
#include "rv_mesh.h"
|
||||
#include "rv_feature_state.h"
|
||||
#include "rv_radio_ops.h"
|
||||
|
||||
#include <string.h>
|
||||
|
||||
#ifndef RV_MESH_HOST_TEST
|
||||
#include "esp_log.h"
|
||||
#include "esp_timer.h"
|
||||
#include "stream_sender.h"
|
||||
#include "csi_collector.h"
|
||||
#include "adaptive_controller.h"
|
||||
static const char *TAG = "rv_mesh";
|
||||
#endif
|
||||
|
||||
/* ---- Encoder ---- */
|
||||
|
||||
size_t rv_mesh_encode(uint8_t type,
|
||||
uint8_t sender_role,
|
||||
uint8_t auth_class,
|
||||
uint32_t epoch,
|
||||
const void *payload,
|
||||
uint16_t payload_len,
|
||||
uint8_t *buf,
|
||||
size_t buf_cap)
|
||||
{
|
||||
if (buf == NULL) return 0;
|
||||
if (payload == NULL && payload_len != 0) return 0;
|
||||
if (payload_len > RV_MESH_MAX_PAYLOAD) return 0;
|
||||
|
||||
size_t total = sizeof(rv_mesh_header_t) + (size_t)payload_len + 4u;
|
||||
if (buf_cap < total) return 0;
|
||||
|
||||
rv_mesh_header_t hdr;
|
||||
hdr.magic = RV_MESH_MAGIC;
|
||||
hdr.version = (uint8_t)RV_MESH_VERSION;
|
||||
hdr.type = type;
|
||||
hdr.sender_role = sender_role;
|
||||
hdr.auth_class = auth_class;
|
||||
hdr.epoch = epoch;
|
||||
hdr.payload_len = payload_len;
|
||||
hdr.reserved = 0;
|
||||
|
||||
memcpy(buf, &hdr, sizeof(hdr));
|
||||
if (payload_len > 0) {
|
||||
memcpy(buf + sizeof(hdr), payload, payload_len);
|
||||
}
|
||||
|
||||
/* IEEE CRC32 over header + payload. Reuses the CRC32 from
|
||||
* rv_feature_state.c so there is exactly one implementation. */
|
||||
uint32_t crc = rv_feature_state_crc32(buf, sizeof(hdr) + payload_len);
|
||||
memcpy(buf + sizeof(hdr) + payload_len, &crc, 4);
|
||||
|
||||
return total;
|
||||
}
|
||||
|
||||
esp_err_t rv_mesh_decode(const uint8_t *buf, size_t buf_len,
|
||||
rv_mesh_header_t *out_hdr,
|
||||
const uint8_t **out_payload,
|
||||
uint16_t *out_payload_len)
|
||||
{
|
||||
if (buf == NULL || out_hdr == NULL ||
|
||||
out_payload == NULL || out_payload_len == NULL) {
|
||||
return ESP_ERR_INVALID_ARG;
|
||||
}
|
||||
if (buf_len < sizeof(rv_mesh_header_t) + 4u) {
|
||||
return ESP_ERR_INVALID_SIZE;
|
||||
}
|
||||
|
||||
rv_mesh_header_t hdr;
|
||||
memcpy(&hdr, buf, sizeof(hdr));
|
||||
|
||||
if (hdr.magic != RV_MESH_MAGIC) {
|
||||
return ESP_ERR_INVALID_VERSION; /* repurpose: wrong magic */
|
||||
}
|
||||
if (hdr.version != RV_MESH_VERSION) {
|
||||
return ESP_ERR_INVALID_VERSION;
|
||||
}
|
||||
if (hdr.payload_len > RV_MESH_MAX_PAYLOAD) {
|
||||
return ESP_ERR_INVALID_SIZE;
|
||||
}
|
||||
|
||||
size_t needed = sizeof(hdr) + (size_t)hdr.payload_len + 4u;
|
||||
if (buf_len < needed) {
|
||||
return ESP_ERR_INVALID_SIZE;
|
||||
}
|
||||
|
||||
uint32_t got_crc;
|
||||
memcpy(&got_crc, buf + sizeof(hdr) + hdr.payload_len, 4);
|
||||
uint32_t want_crc = rv_feature_state_crc32(buf,
|
||||
sizeof(hdr) + hdr.payload_len);
|
||||
if (got_crc != want_crc) {
|
||||
return ESP_ERR_INVALID_CRC;
|
||||
}
|
||||
|
||||
*out_hdr = hdr;
|
||||
*out_payload = (hdr.payload_len > 0) ? buf + sizeof(hdr) : NULL;
|
||||
*out_payload_len = hdr.payload_len;
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
/* ---- Typed convenience encoders ---- */
|
||||
|
||||
size_t rv_mesh_encode_health(uint8_t sender_role,
|
||||
uint32_t epoch,
|
||||
const rv_node_status_t *status,
|
||||
uint8_t *buf, size_t buf_cap)
|
||||
{
|
||||
if (status == NULL) return 0;
|
||||
return rv_mesh_encode(RV_MSG_HEALTH, sender_role, RV_AUTH_NONE,
|
||||
epoch, status, sizeof(*status), buf, buf_cap);
|
||||
}
|
||||
|
||||
size_t rv_mesh_encode_anomaly_alert(uint8_t sender_role,
|
||||
uint32_t epoch,
|
||||
const rv_anomaly_alert_t *alert,
|
||||
uint8_t *buf, size_t buf_cap)
|
||||
{
|
||||
if (alert == NULL) return 0;
|
||||
return rv_mesh_encode(RV_MSG_ANOMALY_ALERT, sender_role, RV_AUTH_NONE,
|
||||
epoch, alert, sizeof(*alert), buf, buf_cap);
|
||||
}
|
||||
|
||||
size_t rv_mesh_encode_feature_delta(uint8_t sender_role,
|
||||
uint32_t epoch,
|
||||
const rv_feature_state_t *fs,
|
||||
uint8_t *buf, size_t buf_cap)
|
||||
{
|
||||
if (fs == NULL) return 0;
|
||||
return rv_mesh_encode(RV_MSG_FEATURE_DELTA, sender_role, RV_AUTH_NONE,
|
||||
epoch, fs, sizeof(*fs), buf, buf_cap);
|
||||
}
|
||||
|
||||
size_t rv_mesh_encode_time_sync(uint8_t sender_role,
|
||||
uint32_t epoch,
|
||||
const rv_time_sync_t *ts,
|
||||
uint8_t *buf, size_t buf_cap)
|
||||
{
|
||||
if (ts == NULL) return 0;
|
||||
return rv_mesh_encode(RV_MSG_TIME_SYNC, sender_role, RV_AUTH_HMAC_SESSION,
|
||||
epoch, ts, sizeof(*ts), buf, buf_cap);
|
||||
}
|
||||
|
||||
size_t rv_mesh_encode_role_assign(uint8_t sender_role,
|
||||
uint32_t epoch,
|
||||
const rv_role_assign_t *ra,
|
||||
uint8_t *buf, size_t buf_cap)
|
||||
{
|
||||
if (ra == NULL) return 0;
|
||||
return rv_mesh_encode(RV_MSG_ROLE_ASSIGN, sender_role, RV_AUTH_HMAC_SESSION,
|
||||
epoch, ra, sizeof(*ra), buf, buf_cap);
|
||||
}
|
||||
|
||||
size_t rv_mesh_encode_channel_plan(uint8_t sender_role,
|
||||
uint32_t epoch,
|
||||
const rv_channel_plan_t *cp,
|
||||
uint8_t *buf, size_t buf_cap)
|
||||
{
|
||||
if (cp == NULL) return 0;
|
||||
return rv_mesh_encode(RV_MSG_CHANNEL_PLAN, sender_role, RV_AUTH_ED25519_BATCH,
|
||||
epoch, cp, sizeof(*cp), buf, buf_cap);
|
||||
}
|
||||
|
||||
size_t rv_mesh_encode_calibration_start(uint8_t sender_role,
|
||||
uint32_t epoch,
|
||||
const rv_calibration_start_t *cs,
|
||||
uint8_t *buf, size_t buf_cap)
|
||||
{
|
||||
if (cs == NULL) return 0;
|
||||
return rv_mesh_encode(RV_MSG_CALIBRATION_START, sender_role,
|
||||
RV_AUTH_ED25519_BATCH, epoch, cs, sizeof(*cs),
|
||||
buf, buf_cap);
|
||||
}
|
||||
|
||||
/* ---- Send helpers (firmware-only; hidden from host tests) ---- */
|
||||
|
||||
#ifndef RV_MESH_HOST_TEST
|
||||
|
||||
esp_err_t rv_mesh_send(const uint8_t *frame, size_t len)
|
||||
{
|
||||
if (frame == NULL || len == 0) return ESP_ERR_INVALID_ARG;
|
||||
int sent = stream_sender_send(frame, len);
|
||||
if (sent < 0) {
|
||||
ESP_LOGW(TAG, "rv_mesh_send: stream_sender failed (len=%u)",
|
||||
(unsigned)len);
|
||||
return ESP_FAIL;
|
||||
}
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
esp_err_t rv_mesh_send_health(uint8_t role, uint32_t epoch,
|
||||
const uint8_t node_id[8])
|
||||
{
|
||||
if (node_id == NULL) return ESP_ERR_INVALID_ARG;
|
||||
|
||||
rv_node_status_t st;
|
||||
memset(&st, 0, sizeof(st));
|
||||
memcpy(st.node_id, node_id, 8);
|
||||
st.local_time_us = (uint64_t)esp_timer_get_time();
|
||||
st.role = role;
|
||||
|
||||
const rv_radio_ops_t *ops = rv_radio_ops_get();
|
||||
if (ops != NULL && ops->get_health != NULL) {
|
||||
rv_radio_health_t h;
|
||||
if (ops->get_health(&h) == ESP_OK) {
|
||||
st.current_channel = h.current_channel;
|
||||
st.current_bw = h.current_bw_mhz;
|
||||
st.noise_floor_dbm = h.noise_floor_dbm;
|
||||
st.pkt_yield = h.pkt_yield_per_sec;
|
||||
}
|
||||
}
|
||||
|
||||
uint8_t buf[RV_MESH_MAX_FRAME_BYTES];
|
||||
size_t n = rv_mesh_encode_health(role, epoch, &st, buf, sizeof(buf));
|
||||
if (n == 0) return ESP_FAIL;
|
||||
return rv_mesh_send(buf, n);
|
||||
}
|
||||
|
||||
esp_err_t rv_mesh_send_anomaly(uint8_t role, uint32_t epoch,
|
||||
const uint8_t node_id[8],
|
||||
uint8_t reason,
|
||||
uint8_t severity,
|
||||
float anomaly_score,
|
||||
float motion_score)
|
||||
{
|
||||
if (node_id == NULL) return ESP_ERR_INVALID_ARG;
|
||||
rv_anomaly_alert_t a;
|
||||
memset(&a, 0, sizeof(a));
|
||||
memcpy(a.node_id, node_id, 8);
|
||||
a.ts_us = (uint64_t)esp_timer_get_time();
|
||||
a.reason = reason;
|
||||
a.severity = severity;
|
||||
a.anomaly_score = anomaly_score;
|
||||
a.motion_score = motion_score;
|
||||
|
||||
uint8_t buf[RV_MESH_MAX_FRAME_BYTES];
|
||||
size_t n = rv_mesh_encode_anomaly_alert(role, epoch, &a, buf, sizeof(buf));
|
||||
if (n == 0) return ESP_FAIL;
|
||||
return rv_mesh_send(buf, n);
|
||||
}
|
||||
|
||||
#endif /* !RV_MESH_HOST_TEST */
|
||||
@@ -0,0 +1,296 @@
|
||||
/**
|
||||
* @file rv_mesh.h
|
||||
* @brief ADR-081 Layer 3 — Mesh Sensing Plane.
|
||||
*
|
||||
* Defines node roles, the 7 on-wire message types, and the
|
||||
* rv_node_status_t health payload that nodes exchange to behave as a
|
||||
* distributed sensor rather than a collection of independent radios.
|
||||
*
|
||||
* Framing: every mesh message starts with rv_mesh_header_t (magic,
|
||||
* version, type, sender_role, epoch, length) so a receiver can dispatch
|
||||
* without reading the whole body. The trailing 4 bytes of every message
|
||||
* are an IEEE CRC32 over the preceding bytes. Authentication
|
||||
* (HMAC-SHA256 + replay window) is layered on top by
|
||||
* wifi-densepose-hardware/src/esp32/secure_tdm.rs (ADR-032) for control
|
||||
* messages that cross the swarm; FEATURE_DELTA uses the integrity
|
||||
* protection already present in rv_feature_state_t (CRC + monotonic seq).
|
||||
*/
|
||||
|
||||
#ifndef RV_MESH_H
|
||||
#define RV_MESH_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include <stddef.h>
|
||||
#include "esp_err.h"
|
||||
#include "rv_feature_state.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* ---- Magic + version ---- */
|
||||
|
||||
/** ADR-081 mesh envelope magic. Distinct from the ADR-018 CSI magic. */
|
||||
#define RV_MESH_MAGIC 0xC5118100u
|
||||
|
||||
/** Protocol version. Bumped on any wire-format change. */
|
||||
#define RV_MESH_VERSION 1u
|
||||
|
||||
/** Maximum mesh payload size (excluding header + CRC). */
|
||||
#define RV_MESH_MAX_PAYLOAD 256u
|
||||
|
||||
/* ---- Node roles (ADR-081 Layer 3) ---- */
|
||||
|
||||
typedef enum {
|
||||
RV_ROLE_UNASSIGNED = 0,
|
||||
RV_ROLE_ANCHOR = 1, /**< Emits timed probes + global time beacons. */
|
||||
RV_ROLE_OBSERVER = 2, /**< Captures CSI + local metadata. */
|
||||
RV_ROLE_FUSION_RELAY = 3, /**< Aggregates summaries, forwards deltas. */
|
||||
RV_ROLE_COORDINATOR = 4, /**< Elects channels, assigns roles. */
|
||||
RV_ROLE_COUNT
|
||||
} rv_mesh_role_t;
|
||||
|
||||
/* ---- Authorization classes for control messages ---- */
|
||||
|
||||
typedef enum {
|
||||
RV_AUTH_NONE = 0, /**< Telemetry; integrity via CRC only. */
|
||||
RV_AUTH_HMAC_SESSION = 1, /**< HMAC-SHA256 with session key (ADR-032). */
|
||||
RV_AUTH_ED25519_BATCH = 2, /**< Ed25519 signature at batch/session. */
|
||||
} rv_mesh_auth_class_t;
|
||||
|
||||
/* ---- Message types ---- */
|
||||
|
||||
typedef enum {
|
||||
RV_MSG_TIME_SYNC = 0x01,
|
||||
RV_MSG_ROLE_ASSIGN = 0x02,
|
||||
RV_MSG_CHANNEL_PLAN = 0x03,
|
||||
RV_MSG_CALIBRATION_START = 0x04,
|
||||
RV_MSG_FEATURE_DELTA = 0x05, /**< Carries rv_feature_state_t. */
|
||||
RV_MSG_HEALTH = 0x06,
|
||||
RV_MSG_ANOMALY_ALERT = 0x07,
|
||||
} rv_mesh_msg_type_t;
|
||||
|
||||
/* ---- Common envelope header (16 bytes) ---- */
|
||||
|
||||
typedef struct __attribute__((packed)) {
|
||||
uint32_t magic; /**< RV_MESH_MAGIC. */
|
||||
uint8_t version; /**< RV_MESH_VERSION. */
|
||||
uint8_t type; /**< rv_mesh_msg_type_t. */
|
||||
uint8_t sender_role; /**< rv_mesh_role_t of the sender at send time. */
|
||||
uint8_t auth_class; /**< rv_mesh_auth_class_t. */
|
||||
uint32_t epoch; /**< Monotonic epoch or session counter. */
|
||||
uint16_t payload_len; /**< Body length excluding header + trailing CRC. */
|
||||
uint16_t reserved;
|
||||
} rv_mesh_header_t;
|
||||
|
||||
_Static_assert(sizeof(rv_mesh_header_t) == 16,
|
||||
"rv_mesh_header_t must be 16 bytes");
|
||||
|
||||
/* ---- Node health payload (RV_MSG_HEALTH) ---- */
|
||||
|
||||
typedef struct __attribute__((packed)) {
|
||||
uint8_t node_id[8]; /**< 8-byte node identity. */
|
||||
uint64_t local_time_us; /**< Sender-local microseconds. */
|
||||
uint8_t role; /**< rv_mesh_role_t. */
|
||||
uint8_t current_channel;
|
||||
uint8_t current_bw; /**< MHz (20, 40). */
|
||||
int8_t noise_floor_dbm;
|
||||
uint16_t pkt_yield; /**< CSI callbacks/sec over the last window. */
|
||||
uint16_t sync_error_us; /**< Absolute drift vs. anchor. */
|
||||
uint16_t health_flags;
|
||||
uint16_t reserved;
|
||||
} rv_node_status_t;
|
||||
|
||||
_Static_assert(sizeof(rv_node_status_t) == 28,
|
||||
"rv_node_status_t must be 28 bytes");
|
||||
|
||||
/* ---- TIME_SYNC payload ---- */
|
||||
|
||||
typedef struct __attribute__((packed)) {
|
||||
uint64_t anchor_time_us; /**< Anchor's local µs at emit. */
|
||||
uint32_t cycle_id;
|
||||
uint32_t cycle_period_us;
|
||||
} rv_time_sync_t;
|
||||
|
||||
_Static_assert(sizeof(rv_time_sync_t) == 16,
|
||||
"rv_time_sync_t must be 16 bytes");
|
||||
|
||||
/* ---- ROLE_ASSIGN payload ---- */
|
||||
|
||||
typedef struct __attribute__((packed)) {
|
||||
uint8_t target_node_id[8];
|
||||
uint8_t new_role; /**< rv_mesh_role_t. */
|
||||
uint8_t reserved[3];
|
||||
uint32_t effective_epoch;
|
||||
} rv_role_assign_t;
|
||||
|
||||
_Static_assert(sizeof(rv_role_assign_t) == 16,
|
||||
"rv_role_assign_t must be 16 bytes");
|
||||
|
||||
/* ---- CHANNEL_PLAN payload ---- */
|
||||
|
||||
#define RV_CHANNEL_PLAN_MAX 8
|
||||
|
||||
typedef struct __attribute__((packed)) {
|
||||
uint8_t target_node_id[8];
|
||||
uint8_t channel_count;
|
||||
uint8_t dwell_ms_hi; /**< dwell_ms, big-endian to fit u16 in two bytes */
|
||||
uint8_t dwell_ms_lo;
|
||||
uint8_t debug_raw_csi; /**< 1 = enable raw ADR-018 stream; 0 = feature_state only. */
|
||||
uint8_t channels[RV_CHANNEL_PLAN_MAX];
|
||||
uint32_t effective_epoch;
|
||||
} rv_channel_plan_t;
|
||||
|
||||
_Static_assert(sizeof(rv_channel_plan_t) == 24,
|
||||
"rv_channel_plan_t must be 24 bytes");
|
||||
|
||||
/* ---- CALIBRATION_START payload ---- */
|
||||
|
||||
typedef struct __attribute__((packed)) {
|
||||
uint64_t t0_anchor_us; /**< Start time on anchor clock. */
|
||||
uint32_t duration_ms;
|
||||
uint32_t effective_epoch;
|
||||
uint8_t calibration_profile; /**< rv_capture_profile_t (usually CALIBRATION). */
|
||||
uint8_t reserved[3];
|
||||
} rv_calibration_start_t;
|
||||
|
||||
_Static_assert(sizeof(rv_calibration_start_t) == 20,
|
||||
"rv_calibration_start_t must be 20 bytes");
|
||||
|
||||
/* ---- ANOMALY_ALERT payload ---- */
|
||||
|
||||
typedef struct __attribute__((packed)) {
|
||||
uint8_t node_id[8];
|
||||
uint64_t ts_us;
|
||||
uint8_t severity; /**< 0..255 scaled anomaly. */
|
||||
uint8_t reason; /**< rv_anomaly_reason_t. */
|
||||
uint16_t reserved;
|
||||
float anomaly_score;
|
||||
float motion_score;
|
||||
} rv_anomaly_alert_t;
|
||||
|
||||
_Static_assert(sizeof(rv_anomaly_alert_t) == 28,
|
||||
"rv_anomaly_alert_t must be 28 bytes");
|
||||
|
||||
typedef enum {
|
||||
RV_ANOMALY_NONE = 0,
|
||||
RV_ANOMALY_PHYSICS_VIOLATION = 1,
|
||||
RV_ANOMALY_MULTI_LINK_MISMATCH = 2,
|
||||
RV_ANOMALY_PKT_YIELD_COLLAPSE = 3,
|
||||
RV_ANOMALY_FALL = 4,
|
||||
RV_ANOMALY_COHERENCE_LOSS = 5,
|
||||
} rv_anomaly_reason_t;
|
||||
|
||||
/* ---- Encoder / decoder API ---- */
|
||||
|
||||
/** Maximum on-wire mesh frame: header + max payload + crc. */
|
||||
#define RV_MESH_MAX_FRAME_BYTES (sizeof(rv_mesh_header_t) + RV_MESH_MAX_PAYLOAD + 4u)
|
||||
|
||||
/**
|
||||
* Encode a typed mesh message into a contiguous buffer.
|
||||
*
|
||||
* Writes header(16) + payload(payload_len) + crc32(4). The caller owns
|
||||
* the buffer; buf_cap must be at least sizeof(rv_mesh_header_t) +
|
||||
* payload_len + 4. The payload pointer may be NULL iff payload_len == 0.
|
||||
*
|
||||
* @return bytes written on success, or 0 on error (bad args / overflow).
|
||||
*/
|
||||
size_t rv_mesh_encode(uint8_t type,
|
||||
uint8_t sender_role,
|
||||
uint8_t auth_class,
|
||||
uint32_t epoch,
|
||||
const void *payload,
|
||||
uint16_t payload_len,
|
||||
uint8_t *buf,
|
||||
size_t buf_cap);
|
||||
|
||||
/**
|
||||
* Validate + parse a mesh frame received from the wire.
|
||||
*
|
||||
* Checks magic, version, sizeof(rv_mesh_header_t) bounds, payload_len
|
||||
* bounds, and CRC32. On success, fills *out_hdr with the header and sets
|
||||
* *out_payload to point at the payload inside buf (aliasing, not copied)
|
||||
* plus *out_payload_len to the payload byte count.
|
||||
*
|
||||
* @return ESP_OK on success, or an ESP_ERR_* code on failure.
|
||||
*/
|
||||
esp_err_t rv_mesh_decode(const uint8_t *buf, size_t buf_len,
|
||||
rv_mesh_header_t *out_hdr,
|
||||
const uint8_t **out_payload,
|
||||
uint16_t *out_payload_len);
|
||||
|
||||
/**
|
||||
* Convenience helpers — encode a specific message type into buf.
|
||||
* Each returns the number of bytes written, 0 on error.
|
||||
*/
|
||||
size_t rv_mesh_encode_health(uint8_t sender_role,
|
||||
uint32_t epoch,
|
||||
const rv_node_status_t *status,
|
||||
uint8_t *buf, size_t buf_cap);
|
||||
|
||||
size_t rv_mesh_encode_anomaly_alert(uint8_t sender_role,
|
||||
uint32_t epoch,
|
||||
const rv_anomaly_alert_t *alert,
|
||||
uint8_t *buf, size_t buf_cap);
|
||||
|
||||
size_t rv_mesh_encode_feature_delta(uint8_t sender_role,
|
||||
uint32_t epoch,
|
||||
const rv_feature_state_t *fs,
|
||||
uint8_t *buf, size_t buf_cap);
|
||||
|
||||
size_t rv_mesh_encode_time_sync(uint8_t sender_role,
|
||||
uint32_t epoch,
|
||||
const rv_time_sync_t *ts,
|
||||
uint8_t *buf, size_t buf_cap);
|
||||
|
||||
size_t rv_mesh_encode_role_assign(uint8_t sender_role,
|
||||
uint32_t epoch,
|
||||
const rv_role_assign_t *ra,
|
||||
uint8_t *buf, size_t buf_cap);
|
||||
|
||||
size_t rv_mesh_encode_channel_plan(uint8_t sender_role,
|
||||
uint32_t epoch,
|
||||
const rv_channel_plan_t *cp,
|
||||
uint8_t *buf, size_t buf_cap);
|
||||
|
||||
size_t rv_mesh_encode_calibration_start(uint8_t sender_role,
|
||||
uint32_t epoch,
|
||||
const rv_calibration_start_t *cs,
|
||||
uint8_t *buf, size_t buf_cap);
|
||||
|
||||
/* ---- Send API ---- */
|
||||
|
||||
/**
|
||||
* Send a pre-encoded mesh frame over the primary upstream UDP socket
|
||||
* (the same one stream_sender uses for ADR-018 and rv_feature_state_t).
|
||||
*
|
||||
* @return ESP_OK on success.
|
||||
*/
|
||||
esp_err_t rv_mesh_send(const uint8_t *frame, size_t len);
|
||||
|
||||
/**
|
||||
* Convenience: build + send a HEALTH message for this node.
|
||||
*
|
||||
* Fills the rv_node_status_t from the live radio ops + controller
|
||||
* observation, then encodes and sends in one call. Safe to call from a
|
||||
* FreeRTOS timer.
|
||||
*/
|
||||
esp_err_t rv_mesh_send_health(uint8_t role, uint32_t epoch,
|
||||
const uint8_t node_id[8]);
|
||||
|
||||
/**
|
||||
* Convenience: build + send an ANOMALY_ALERT.
|
||||
*/
|
||||
esp_err_t rv_mesh_send_anomaly(uint8_t role, uint32_t epoch,
|
||||
const uint8_t node_id[8],
|
||||
uint8_t reason,
|
||||
uint8_t severity,
|
||||
float anomaly_score,
|
||||
float motion_score);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* RV_MESH_H */
|
||||
@@ -29,7 +29,7 @@ FEATURE_STATE_SRCS := $(MAIN_DIR)/rv_feature_state.c
|
||||
# before including the .c. The decide() body itself has no ESP-IDF deps.
|
||||
# Simpler: just recompile decide() here via a small shim.
|
||||
|
||||
TESTS := test_adaptive_controller test_rv_feature_state
|
||||
TESTS := test_adaptive_controller test_rv_feature_state test_rv_mesh
|
||||
|
||||
all: $(TESTS)
|
||||
|
||||
@@ -39,10 +39,19 @@ test_adaptive_controller: test_adaptive_controller.c $(MAIN_DIR)/adaptive_contro
|
||||
test_rv_feature_state: test_rv_feature_state.c $(FEATURE_STATE_SRCS) $(MAIN_DIR)/rv_feature_state.h $(MAIN_DIR)/rv_radio_ops.h
|
||||
$(CC) $(CFLAGS) test_rv_feature_state.c $(FEATURE_STATE_SRCS) -o $@ $(LDLIBS)
|
||||
|
||||
# Mesh plane encoder/decoder: compile rv_mesh.c with RV_MESH_HOST_TEST
|
||||
# so the firmware-only send helpers (stream_sender, esp_log) are hidden.
|
||||
test_rv_mesh: test_rv_mesh.c $(MAIN_DIR)/rv_mesh.c $(MAIN_DIR)/rv_mesh.h $(FEATURE_STATE_SRCS) $(MAIN_DIR)/rv_radio_ops.h
|
||||
$(CC) $(CFLAGS) -DRV_MESH_HOST_TEST=1 \
|
||||
test_rv_mesh.c $(MAIN_DIR)/rv_mesh.c $(FEATURE_STATE_SRCS) \
|
||||
-o $@ $(LDLIBS)
|
||||
|
||||
check: all
|
||||
./test_adaptive_controller
|
||||
@echo ""
|
||||
./test_rv_feature_state
|
||||
@echo ""
|
||||
./test_rv_mesh
|
||||
|
||||
clean:
|
||||
rm -f $(TESTS) *.o
|
||||
|
||||
@@ -8,9 +8,12 @@
|
||||
|
||||
typedef int esp_err_t;
|
||||
|
||||
#define ESP_OK 0
|
||||
#define ESP_FAIL -1
|
||||
#define ESP_ERR_NO_MEM 0x101
|
||||
#define ESP_ERR_INVALID_ARG 0x102
|
||||
#define ESP_OK 0
|
||||
#define ESP_FAIL -1
|
||||
#define ESP_ERR_NO_MEM 0x101
|
||||
#define ESP_ERR_INVALID_ARG 0x102
|
||||
#define ESP_ERR_INVALID_SIZE 0x104
|
||||
#define ESP_ERR_INVALID_VERSION 0x10A
|
||||
#define ESP_ERR_INVALID_CRC 0x10B
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,219 @@
|
||||
/*
|
||||
* Host unit test for ADR-081 Layer 3 mesh plane encode/decode.
|
||||
*
|
||||
* rv_mesh_encode() and rv_mesh_decode() are the pure halves of the
|
||||
* mesh plane — no ESP-IDF, no sockets — so we exercise them with the
|
||||
* RV_MESH_HOST_TEST flag that disables the send helpers.
|
||||
*/
|
||||
|
||||
#include <assert.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
|
||||
#include "rv_mesh.h"
|
||||
#include "rv_feature_state.h"
|
||||
#include "rv_radio_ops.h" /* for RV_PROFILE_* enum values */
|
||||
|
||||
static int g_pass = 0, g_fail = 0;
|
||||
#define CHECK(cond, msg) do { \
|
||||
if (cond) { g_pass++; } \
|
||||
else { g_fail++; printf(" FAIL: %s (line %d)\n", msg, __LINE__); } \
|
||||
} while (0)
|
||||
|
||||
static void test_header_size(void) {
|
||||
printf("test: rv_mesh_header_t is 16 bytes\n");
|
||||
CHECK(sizeof(rv_mesh_header_t) == 16, "sizeof(header) == 16");
|
||||
}
|
||||
|
||||
static void test_encode_health_roundtrip(void) {
|
||||
printf("test: HEALTH roundtrip\n");
|
||||
rv_node_status_t st;
|
||||
memset(&st, 0, sizeof(st));
|
||||
st.node_id[0] = 7;
|
||||
st.local_time_us = 1234567890ULL;
|
||||
st.role = RV_ROLE_OBSERVER;
|
||||
st.current_channel = 6;
|
||||
st.current_bw = 20;
|
||||
st.noise_floor_dbm = -93;
|
||||
st.pkt_yield = 42;
|
||||
st.sync_error_us = 12;
|
||||
|
||||
uint8_t buf[RV_MESH_MAX_FRAME_BYTES];
|
||||
size_t n = rv_mesh_encode_health(RV_ROLE_OBSERVER, /*epoch*/ 100,
|
||||
&st, buf, sizeof(buf));
|
||||
CHECK(n > 0, "encode returns non-zero");
|
||||
CHECK(n == sizeof(rv_mesh_header_t) + sizeof(st) + 4,
|
||||
"encoded size = hdr+payload+crc");
|
||||
|
||||
rv_mesh_header_t hdr;
|
||||
const uint8_t *payload = NULL;
|
||||
uint16_t payload_len = 0;
|
||||
esp_err_t rc = rv_mesh_decode(buf, n, &hdr, &payload, &payload_len);
|
||||
CHECK(rc == ESP_OK, "decode OK");
|
||||
CHECK(hdr.type == RV_MSG_HEALTH, "type == HEALTH");
|
||||
CHECK(hdr.epoch == 100, "epoch survives");
|
||||
CHECK(hdr.payload_len == sizeof(st), "payload_len matches");
|
||||
CHECK(payload != NULL, "payload pointer set");
|
||||
CHECK(memcmp(payload, &st, sizeof(st)) == 0, "payload bytes match");
|
||||
}
|
||||
|
||||
static void test_encode_anomaly_roundtrip(void) {
|
||||
printf("test: ANOMALY_ALERT roundtrip\n");
|
||||
rv_anomaly_alert_t a;
|
||||
memset(&a, 0, sizeof(a));
|
||||
a.node_id[0] = 3;
|
||||
a.ts_us = 999999ULL;
|
||||
a.reason = RV_ANOMALY_FALL;
|
||||
a.severity = 200;
|
||||
a.anomaly_score = 0.85f;
|
||||
a.motion_score = 0.9f;
|
||||
|
||||
uint8_t buf[RV_MESH_MAX_FRAME_BYTES];
|
||||
size_t n = rv_mesh_encode_anomaly_alert(RV_ROLE_OBSERVER, 7, &a,
|
||||
buf, sizeof(buf));
|
||||
CHECK(n > 0, "encoded");
|
||||
|
||||
rv_mesh_header_t hdr;
|
||||
const uint8_t *payload = NULL;
|
||||
uint16_t payload_len = 0;
|
||||
esp_err_t rc = rv_mesh_decode(buf, n, &hdr, &payload, &payload_len);
|
||||
CHECK(rc == ESP_OK, "decoded");
|
||||
CHECK(hdr.type == RV_MSG_ANOMALY_ALERT, "type ok");
|
||||
rv_anomaly_alert_t got;
|
||||
memcpy(&got, payload, sizeof(got));
|
||||
CHECK(got.reason == RV_ANOMALY_FALL, "reason survived");
|
||||
CHECK(got.severity == 200, "severity survived");
|
||||
}
|
||||
|
||||
static void test_encode_feature_delta_wraps_feature_state(void) {
|
||||
printf("test: FEATURE_DELTA wraps rv_feature_state_t\n");
|
||||
rv_feature_state_t fs;
|
||||
memset(&fs, 0, sizeof(fs));
|
||||
fs.motion_score = 0.5f;
|
||||
rv_feature_state_finalize(&fs, /*node*/ 9, /*seq*/ 17,
|
||||
/*ts*/ 111ULL, RV_PROFILE_FAST_MOTION);
|
||||
|
||||
uint8_t buf[RV_MESH_MAX_FRAME_BYTES];
|
||||
size_t n = rv_mesh_encode_feature_delta(RV_ROLE_OBSERVER, 2, &fs,
|
||||
buf, sizeof(buf));
|
||||
CHECK(n == sizeof(rv_mesh_header_t) + sizeof(fs) + 4, "size check");
|
||||
|
||||
rv_mesh_header_t hdr;
|
||||
const uint8_t *payload = NULL;
|
||||
uint16_t len = 0;
|
||||
CHECK(rv_mesh_decode(buf, n, &hdr, &payload, &len) == ESP_OK,
|
||||
"decode OK");
|
||||
rv_feature_state_t got;
|
||||
memcpy(&got, payload, sizeof(got));
|
||||
CHECK(got.magic == RV_FEATURE_STATE_MAGIC, "inner magic preserved");
|
||||
CHECK(got.node_id == 9, "inner node_id preserved");
|
||||
CHECK(got.seq == 17, "inner seq preserved");
|
||||
/* Inner CRC is end-to-end even though the mesh frame has its own
|
||||
* CRC too — two checks for two failure modes. */
|
||||
uint32_t inner_crc = rv_feature_state_crc32(
|
||||
(const uint8_t *)&got, sizeof(got) - sizeof(uint32_t));
|
||||
CHECK(inner_crc == got.crc32, "inner feature_state CRC still valid");
|
||||
}
|
||||
|
||||
static void test_decode_rejects_bad_magic(void) {
|
||||
printf("test: decode rejects bad magic\n");
|
||||
uint8_t buf[sizeof(rv_mesh_header_t) + 4];
|
||||
memset(buf, 0xFF, sizeof(buf));
|
||||
|
||||
rv_mesh_header_t hdr;
|
||||
const uint8_t *p = NULL;
|
||||
uint16_t plen = 0;
|
||||
esp_err_t rc = rv_mesh_decode(buf, sizeof(buf), &hdr, &p, &plen);
|
||||
CHECK(rc != ESP_OK, "bad magic rejected");
|
||||
}
|
||||
|
||||
static void test_decode_rejects_truncated(void) {
|
||||
printf("test: decode rejects truncated frame\n");
|
||||
uint8_t buf[sizeof(rv_mesh_header_t) - 1];
|
||||
memset(buf, 0, sizeof(buf));
|
||||
rv_mesh_header_t hdr;
|
||||
const uint8_t *p = NULL;
|
||||
uint16_t plen = 0;
|
||||
esp_err_t rc = rv_mesh_decode(buf, sizeof(buf), &hdr, &p, &plen);
|
||||
CHECK(rc != ESP_OK, "truncated rejected");
|
||||
}
|
||||
|
||||
static void test_decode_rejects_bad_crc(void) {
|
||||
printf("test: decode rejects CRC mismatch\n");
|
||||
rv_node_status_t st;
|
||||
memset(&st, 0, sizeof(st));
|
||||
st.role = RV_ROLE_OBSERVER;
|
||||
uint8_t buf[RV_MESH_MAX_FRAME_BYTES];
|
||||
size_t n = rv_mesh_encode_health(RV_ROLE_OBSERVER, 1, &st,
|
||||
buf, sizeof(buf));
|
||||
CHECK(n > 0, "encoded");
|
||||
|
||||
/* Flip a byte in the payload — CRC must now mismatch. */
|
||||
buf[sizeof(rv_mesh_header_t) + 4] ^= 0x10;
|
||||
|
||||
rv_mesh_header_t hdr;
|
||||
const uint8_t *p = NULL;
|
||||
uint16_t plen = 0;
|
||||
esp_err_t rc = rv_mesh_decode(buf, n, &hdr, &p, &plen);
|
||||
CHECK(rc != ESP_OK, "CRC mismatch rejected");
|
||||
}
|
||||
|
||||
static void test_encode_rejects_oversize_payload(void) {
|
||||
printf("test: encode rejects oversize payload\n");
|
||||
uint8_t junk[RV_MESH_MAX_PAYLOAD + 1] = {0};
|
||||
uint8_t buf[RV_MESH_MAX_FRAME_BYTES + 8];
|
||||
size_t n = rv_mesh_encode(RV_MSG_HEALTH, RV_ROLE_OBSERVER, RV_AUTH_NONE,
|
||||
0, junk, sizeof(junk), buf, sizeof(buf));
|
||||
CHECK(n == 0, "oversize payload → 0");
|
||||
}
|
||||
|
||||
static void test_encode_rejects_small_buf(void) {
|
||||
printf("test: encode rejects too-small buffer\n");
|
||||
rv_node_status_t st = {0};
|
||||
uint8_t buf[16]; /* header fits but not payload */
|
||||
size_t n = rv_mesh_encode_health(RV_ROLE_OBSERVER, 0, &st,
|
||||
buf, sizeof(buf));
|
||||
CHECK(n == 0, "small buf → 0");
|
||||
}
|
||||
|
||||
static void benchmark_encode(void) {
|
||||
printf("bench: encode+decode HEALTH roundtrip\n");
|
||||
rv_node_status_t st;
|
||||
memset(&st, 0x33, sizeof(st));
|
||||
uint8_t buf[RV_MESH_MAX_FRAME_BYTES];
|
||||
|
||||
const int N = 2000000;
|
||||
struct timespec a, b;
|
||||
clock_gettime(CLOCK_MONOTONIC, &a);
|
||||
for (int i = 0; i < N; i++) {
|
||||
st.pkt_yield = (uint16_t)i;
|
||||
size_t n = rv_mesh_encode_health(RV_ROLE_OBSERVER, (uint32_t)i,
|
||||
&st, buf, sizeof(buf));
|
||||
rv_mesh_header_t hdr;
|
||||
const uint8_t *p = NULL;
|
||||
uint16_t plen = 0;
|
||||
(void)rv_mesh_decode(buf, n, &hdr, &p, &plen);
|
||||
}
|
||||
clock_gettime(CLOCK_MONOTONIC, &b);
|
||||
double ns = ((b.tv_sec - a.tv_sec) * 1e9 +
|
||||
(b.tv_nsec - a.tv_nsec)) / (double)N;
|
||||
printf(" %d roundtrips, %.1f ns/call\n", N, ns);
|
||||
CHECK(ns < 20000.0, "encode+decode must be under 20us/roundtrip");
|
||||
}
|
||||
|
||||
int main(void) {
|
||||
printf("=== rv_mesh encode/decode host tests ===\n\n");
|
||||
test_header_size();
|
||||
test_encode_health_roundtrip();
|
||||
test_encode_anomaly_roundtrip();
|
||||
test_encode_feature_delta_wraps_feature_state();
|
||||
test_decode_rejects_bad_magic();
|
||||
test_decode_rejects_truncated();
|
||||
test_decode_rejects_bad_crc();
|
||||
test_encode_rejects_oversize_payload();
|
||||
test_encode_rejects_small_buf();
|
||||
benchmark_encode();
|
||||
printf("\n=== result: %d pass, %d fail ===\n", g_pass, g_fail);
|
||||
return g_fail > 0 ? 1 : 0;
|
||||
}
|
||||
Reference in New Issue
Block a user