Add runtime ESP-NOW bridge diagnostics and link probes
This commit is contained in:
1 parent
00ff933543
commit
14682de00e
22 files changed
+1947
-68
No files matched your search
@@ -862,6 +862,8 @@ jobs:
|
||||
python3 -B test/test_espnow_radio_lifecycle.py -v
|
||||
python3 -B test/test_wifi_ap_lr_safety.py -v
|
||||
python3 -B test/test_espnow_runtime.py -v
|
||||
python3 -B test/test_espnow_bridge_diagnostics.py -v
|
||||
python3 -B test/test_espnow_diagnostic_cli.py -v
|
||||
python3 -B test/test_wifi_ota_lifecycle.py -v
|
||||
|
||||
- name: Verify message reader buttons, touch targets, and footer layouts
|
||||
|
||||
@@ -5576,6 +5576,87 @@ For a complete two-repeater setup with each option explained, see the
|
||||
|
||||
---
|
||||
|
||||
#### Diagnose the ESP-NOW bridge
|
||||
|
||||
Available when the optional ESP-NOW bridge is compiled in. These are runtime
|
||||
diagnostics; no `BRIDGE_DEBUG` build flag is required.
|
||||
|
||||
**Read-only commands:**
|
||||
|
||||
```text
|
||||
get espnow.status
|
||||
get espnow.stats
|
||||
get espnow.stats rx
|
||||
get espnow.stats tx
|
||||
get espnow.stats drops
|
||||
get espnow.stats test
|
||||
```
|
||||
|
||||
Status reports local state (`off`, `teardown-error`, `driver-error`,
|
||||
`channel-mismatch` or `ready`), then these compact fields:
|
||||
|
||||
| Field | Meaning |
|
||||
| --- | --- |
|
||||
| `ch` | Configured/actual 2.4 GHz channel; actual `0` means unavailable. |
|
||||
| `fmt`, `src` | Packet format and configured LoRa packet source (`rx` or `tx`). |
|
||||
| `wifi` | Shared WiFi enable setting, not proof of WiFi association. |
|
||||
| `mode`, `ps`, `proto` | WiFi SDK mode and power-save integers, and protocol bitmask in hexadecimal. An unavailable mode or power-save query returns `-1`. |
|
||||
| `q` | Current receive/transmit queue depths. |
|
||||
| `last` | Last recorded SDK error stage/code, which may remain after recovery. |
|
||||
|
||||
`espnow.running on` means the local bridge initialized; it does not prove a
|
||||
peer is reachable. The statistics pages use these keys:
|
||||
|
||||
| Page | Keys and meaning |
|
||||
| --- | --- |
|
||||
| Default | `rx`: received callback frames; `mesh`: inbound MeshCore packets queued; `tx`: outbound MeshCore packets queued; `sent`: successful frame callbacks. |
|
||||
| `rx` | `frames`: received callback frames; `decoded`: parsed MeshCore packets; `mesh`: queued for mesh processing; `crc`: checksum failures; `bad`: malformed frames; `parse`: packet parse failures. |
|
||||
| `tx` | `req`: mesh TX requests; `queued`: mesh packets queued; `start`: SDK-accepted frames; `ok`: successful frame callbacks; `err`: SDK start failures; `cbfail`: failed frame callbacks; `timeout`: callback timeouts. |
|
||||
| `drops` | `rxq`: RX queue drops; `foreign`: foreign-group packets; `filter`/`dupe`: inbound filter/duplicate drops; `txq`: total mesh TX drops; `txfilter`/`txdupe`: outbound filter/duplicate drops; `big`: oversize TX drops. |
|
||||
| `test` | `queued`, `start`, `ok`, `fail`, `timeout`: probe TX stages; `rx`, `bad`: valid/invalid probes received; `txid`, `rxid`: last queued/received IDs in hexadecimal. |
|
||||
|
||||
Mesh admission means queued for normal processing, not confirmed LoRa
|
||||
forwarding or end-to-end delivery. Packet and frame counters have different
|
||||
units: fragmentation can produce several frames for one mesh packet. Counters
|
||||
survive bridge stop/start; reboot or the explicit reset starts a new window.
|
||||
|
||||
**Local-only actions:**
|
||||
|
||||
```text
|
||||
espnow test
|
||||
espnow test A1B2C3D4
|
||||
espnow resetstats
|
||||
```
|
||||
|
||||
The optional test ID is exactly eight hexadecimal digits, case-insensitive,
|
||||
without `0x`, spaces or trailing arguments. Omitting it uses uptime in
|
||||
milliseconds. The reply `OK - test queued id=...; confirm on peer` confirms
|
||||
local queueing only. Read the other updated board's `get espnow.stats test`
|
||||
and match `rxid`, with an increased `rx`, to establish one-way probe receipt. Send a
|
||||
different ID from the other board to test the reverse direction.
|
||||
|
||||
A probe is unencrypted, CRC-checked transport diagnostic data, not a MeshCore
|
||||
packet or a security token. It does not verify packet-format compatibility or
|
||||
`bridge.secret`, authenticate the peer or establish normal packet delivery.
|
||||
There is no automatic echo,
|
||||
retry or LoRa forwarding; older firmware ignores it. Resetting statistics
|
||||
does not restart the bridge or write preferences. Test/reset commands are
|
||||
rejected over LoRa; use a local console. Every reply fits the bounded CLI
|
||||
frame, and diagnostics do not print from WiFi callbacks.
|
||||
|
||||
For a short USB debug capture, record both `get usb.logging` and
|
||||
`get usb.debug`, then enable both `set usb.logging on` and `set usb.debug on`.
|
||||
Run the test and restore both original settings. The ordinary image emits
|
||||
bounded `ESPNOW:` updates from its main loop at most once per second when
|
||||
diagnostic state changes, even with `BRIDGE_DEBUG=0`. Updates can be skipped
|
||||
when USB is busy; read the counter pages for exact values. The CLI counter
|
||||
pages and probes do not require either logging gate.
|
||||
|
||||
See the [two-board diagnostic flow](espnow_bridge_setup.md#test-the-24-ghz-path-without-lora-forwarding).
|
||||
Do not include `get bridge.secret` or WiFi credentials in shared debug logs.
|
||||
|
||||
---
|
||||
|
||||
#### View or change the bridge enabled flag
|
||||
|
||||
**Search terms:** enable bridge, disable bridge, serial bridge, RS232 bridge.
|
||||
|
||||
+101
-3
@@ -112,17 +112,23 @@ Run on both boards:
|
||||
```text
|
||||
get espnow.enabled
|
||||
get espnow.running
|
||||
get espnow.status
|
||||
get bridge.channel
|
||||
get bridge.format
|
||||
get bridge.secret
|
||||
get bridge.source
|
||||
get bridge.delay
|
||||
get repeat
|
||||
get radio
|
||||
```
|
||||
|
||||
Expected: enabled and running `on`, matching channel/format/secret, source
|
||||
`tx`, delay `500`, repeat `on`, and the intended LoRa settings on each side.
|
||||
For the example above, expect enabled and running `on`, matching channel and
|
||||
format, source `tx`, delay `500`, repeat `on`, and the intended LoRa settings
|
||||
on each side. An existing `bridge.source rx` setup is also valid; diagnose
|
||||
the selected source rather than changing it just to match this example.
|
||||
Compare the shared secret privately; omit `get bridge.secret` from logs you
|
||||
share. `get espnow.status` distinguishes the configured channel from the actual
|
||||
2.4 GHz channel. Its `last` error stage/code is historical and may remain after
|
||||
recovery. A running bridge is not proof that the other board received anything.
|
||||
|
||||
Send a message from a Companion on network A to one on network B, then reply
|
||||
from B to A. Check both directions; configuration readback alone does not test
|
||||
@@ -137,6 +143,98 @@ If it does not work:
|
||||
and secret; confirm each board's LoRa settings were applied with a reboot,
|
||||
and check the networks' forwarding and scope rules.
|
||||
|
||||
If those saved settings already match, use the bounded test below before
|
||||
changing them again.
|
||||
|
||||
### Test the 2.4 GHz path without LoRa forwarding
|
||||
|
||||
Updated ESP-NOW bridge firmware includes runtime diagnostics in the ordinary
|
||||
image. No `BRIDGE_DEBUG` build flag or continuous USB logging is needed. Use
|
||||
the USB console so a WiFi change cannot disconnect your diagnostic session.
|
||||
|
||||
On both boards, start a fresh observation window:
|
||||
|
||||
```text
|
||||
espnow resetstats
|
||||
get espnow.status
|
||||
get espnow.stats test
|
||||
```
|
||||
|
||||
On A, send one probe:
|
||||
|
||||
```text
|
||||
espnow test A1B2C3D4
|
||||
```
|
||||
|
||||
`OK - test queued id=A1B2C3D4; confirm on peer` means queued locally. On B, run
|
||||
`get espnow.stats test`: `rx` must increase and `rxid` must be `A1B2C3D4`.
|
||||
Then send `espnow test B1C2D3E4` on B and confirm that ID on A. The two
|
||||
commands are two one-way tests; there is no
|
||||
automatic reply or retry. Sender completion alone does not prove peer receipt.
|
||||
The optional ID is exactly eight hexadecimal digits, without `0x`; omitting
|
||||
it uses the current uptime in milliseconds as a correlation ID.
|
||||
|
||||
These small, unencrypted CRC-checked probes test transport reachability only.
|
||||
They do not validate packet-format compatibility or the wrapped shared secret,
|
||||
authenticate the peer or prove MeshCore packet delivery. They are never
|
||||
injected into the mesh or forwarded
|
||||
onto LoRa. Older firmware ignores them and cannot report the received ID;
|
||||
use an updated peer for confirmation. Sending a probe and resetting
|
||||
statistics require a local connection; neither changes saved preferences.
|
||||
|
||||
### Locate a mesh forwarding failure
|
||||
|
||||
If both probe directions work, send one fresh identifiable message from a
|
||||
Companion on A's LoRa network and read these pages on both bridge boards:
|
||||
|
||||
```text
|
||||
get espnow.stats
|
||||
get espnow.stats rx
|
||||
get espnow.stats tx
|
||||
get espnow.stats drops
|
||||
```
|
||||
|
||||
Repeat in the opposite direction with a new message. Counters accumulate until
|
||||
`espnow resetstats` or reboot and survive an ESP-NOW stop/start. Inspect changes
|
||||
across the one message, rather than assuming old totals describe the current
|
||||
attempt.
|
||||
|
||||
- **No source-side bridge TX request:** check the configured source.
|
||||
`bridge.source rx` exports LoRa receptions; confirm the board heard the
|
||||
fresh message. `bridge.source tx` exports LoRa transmissions; confirm it
|
||||
forwards the message with repeat on and the intended routing, scope and
|
||||
flood-filter settings. Either source is valid.
|
||||
- **TX requested but not sent:** the TX/drops pages separate queued traffic,
|
||||
filtering, duplicates, size/queue drops and SDK start/completion failures.
|
||||
Check the configured/live 2.4 GHz channel and last error stage/code.
|
||||
- **Peer sees frames but accepts no MeshCore packet:** inspect RX rejection
|
||||
counters, format and the privately compared wrapped secret. A successful
|
||||
diagnostic probe does not rule out a packet-format or secret mismatch.
|
||||
- **Peer admits the packet but no LoRa delivery follows:** admission means
|
||||
queued for normal mesh processing, not a completed LoRa transmission. Check
|
||||
repeat, scope, filters, duplicate suppression and the destination network.
|
||||
|
||||
An absent counter change narrows a stage; these checks do not assume a cause
|
||||
for a particular pair of boards.
|
||||
|
||||
If both bridge boards also hear the same message directly on LoRa, normal
|
||||
duplicate suppression can discard its later bridged copy. That alone does
|
||||
not show a broken ESP-NOW link. This is a possibility to check with the
|
||||
counters, not an established cause of a reported delivery failure.
|
||||
|
||||
### Optional short USB debug capture
|
||||
|
||||
For a brief observation window, run `get usb.logging` and `get usb.debug`
|
||||
and record both original settings. Enable both gates with `set usb.logging on`
|
||||
and `set usb.debug on`. The bridge emits bounded `ESPNOW:` status/counter
|
||||
updates from its main loop, at most once per second when diagnostic state
|
||||
changes. No `BRIDGE_DEBUG` build flag is required, and WiFi callbacks do not
|
||||
print to USB. Send the two probes or one fresh message, then restore both
|
||||
original settings. The CLI counter pages and probes do not require either
|
||||
logging gate. Use the counter pages for exact values; a busy USB console can
|
||||
skip a debug update. Do not include secrets or WiFi credentials in a shared
|
||||
capture.
|
||||
|
||||
A running bridge keeps the device awake, even with device power saving enabled.
|
||||
ESP-NOW shares the WiFi radio: use the connected WiFi network's channel when
|
||||
WiFi is active. Browser OTA pauses ESP-NOW on ordinary non-MQTT repeaters,
|
||||
|
||||
@@ -651,6 +651,27 @@ class MyMesh : public mesh::Mesh, public CommonCLICallbacks
|
||||
#endif
|
||||
|
||||
#if defined(WITH_ESPNOW_BRIDGE)
|
||||
ESPNowBridge& diagnosticEspNowBridge() {
|
||||
#if defined(WITH_MQTT_BRIDGE) || defined(WITH_RS232_BRIDGE)
|
||||
return espnow_bridge;
|
||||
#else
|
||||
return bridge;
|
||||
#endif
|
||||
}
|
||||
void formatEspNowStatus(char* reply, size_t capacity) override {
|
||||
diagnosticEspNowBridge().formatStatus(reply, capacity);
|
||||
}
|
||||
void formatEspNowStats(const char* page, char* reply, size_t capacity) override {
|
||||
diagnosticEspNowBridge().formatStats(page, reply, capacity);
|
||||
}
|
||||
bool sendEspNowTest(uint32_t nonce) override {
|
||||
return diagnosticEspNowBridge().sendTest(nonce);
|
||||
}
|
||||
bool resetEspNowStats() override {
|
||||
diagnosticEspNowBridge().resetStats();
|
||||
return true;
|
||||
}
|
||||
|
||||
// Retry ESP-NOW without taking over an active OTA session. MQTT creates its
|
||||
// WiFi task asynchronously, so it must first associate on the shared channel.
|
||||
bool startSharedEspNowBridgeIfReady() {
|
||||
|
||||
@@ -669,6 +669,22 @@ public:
|
||||
|
||||
|
||||
#if defined(WITH_BRIDGE)
|
||||
#if defined(WITH_MQTT_BRIDGE) && defined(WITH_ESPNOW_BRIDGE)
|
||||
void formatEspNowStatus(char* reply, size_t capacity) override {
|
||||
espnow_bridge.formatStatus(reply, capacity);
|
||||
}
|
||||
void formatEspNowStats(const char* page, char* reply, size_t capacity) override {
|
||||
espnow_bridge.formatStats(page, reply, capacity);
|
||||
}
|
||||
bool sendEspNowTest(uint32_t nonce) override {
|
||||
return espnow_bridge.sendTest(nonce);
|
||||
}
|
||||
bool resetEspNowStats() override {
|
||||
espnow_bridge.resetStats();
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(WITH_MQTT_BRIDGE) && defined(WITH_ESPNOW_BRIDGE)
|
||||
// MQTT's WiFi task associates asynchronously. ESP-NOW must wait for that
|
||||
// station interface so it can share the AP-selected channel safely.
|
||||
|
||||
+2
-1
@@ -34,7 +34,8 @@
|
||||
(defined(NRF52_PLATFORM) || MESH_ESP32_USB_CONSOLE_COOPERATIVE) && \
|
||||
((defined(MESH_DEBUG) && MESH_DEBUG) || \
|
||||
(defined(BRIDGE_DEBUG) && BRIDGE_DEBUG) || \
|
||||
(defined(POWERSAVING_DEBUG) && POWERSAVING_DEBUG))
|
||||
(defined(POWERSAVING_DEBUG) && POWERSAVING_DEBUG) || \
|
||||
defined(WITH_ESPNOW_BRIDGE))
|
||||
#include <Arduino.h>
|
||||
#include <atomic>
|
||||
#include <stdarg.h>
|
||||
|
||||
@@ -33,6 +33,9 @@
|
||||
#ifdef WITH_RS232_BRIDGE
|
||||
#include "bridges/RS232PowerSettings.h"
|
||||
#endif
|
||||
#if defined(WITH_ESPNOW_BRIDGE)
|
||||
#include "bridges/ESPNowBridgeDiagnostics.h"
|
||||
#endif
|
||||
#include "GpsPowerPolicy.h"
|
||||
#include "FloodAdvertCLI.h"
|
||||
#include "StorageLayout.h"
|
||||
@@ -3048,9 +3051,65 @@ uint8_t CommonCLI::buildAdvertData(uint8_t node_type, uint8_t* app_data) {
|
||||
}
|
||||
}
|
||||
|
||||
#if defined(WITH_ESPNOW_BRIDGE)
|
||||
bool CommonCLI::handleEspNowDiagnosticCommand(uint32_t sender_timestamp,
|
||||
const char* command, char* reply) {
|
||||
constexpr size_t capacity = 157; // Leave room for an infrastructure reply prefix.
|
||||
if (strncmp(command, "get espnow.status", 17) == 0) {
|
||||
if (strcmp(command, "get espnow.status") != 0) {
|
||||
snprintf(reply, capacity, "Error: use get espnow.status");
|
||||
} else {
|
||||
_callbacks->formatEspNowStatus(reply, capacity);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
if (strncmp(command, "get espnow.stats", 16) == 0) {
|
||||
const char* page = command + 16;
|
||||
if (*page == 0) {
|
||||
_callbacks->formatEspNowStats("", reply, capacity);
|
||||
} else if (strcmp(page, " rx") == 0 || strcmp(page, " tx") == 0
|
||||
|| strcmp(page, " drops") == 0 || strcmp(page, " test") == 0) {
|
||||
_callbacks->formatEspNowStats(page + 1, reply, capacity);
|
||||
} else {
|
||||
snprintf(reply, capacity, "Error: use get espnow.stats [rx|tx|drops|test]");
|
||||
}
|
||||
return true;
|
||||
}
|
||||
if (strncmp(command, "espnow", 6) != 0
|
||||
|| (command[6] != 0 && command[6] != ' ')) return false;
|
||||
if (sender_timestamp != 0) {
|
||||
snprintf(reply, capacity, "Error: ESP-NOW test/reset requires a local connection");
|
||||
return true;
|
||||
}
|
||||
if (strcmp(command, "espnow resetstats") == 0) {
|
||||
snprintf(reply, capacity, "%s", _callbacks->resetEspNowStats()
|
||||
? "OK - ESP-NOW statistics reset" : "Error: ESP-NOW diagnostics unavailable");
|
||||
return true;
|
||||
}
|
||||
uint32_t nonce = 0;
|
||||
if (strcmp(command, "espnow test") == 0) {
|
||||
nonce = millis(); // Correlation only; this is not a security token.
|
||||
} else if (strncmp(command, "espnow test ", 12) != 0
|
||||
|| !mesh::bridge::diag::parseNonce(command + 12, nonce)) {
|
||||
snprintf(reply, capacity, "Error: use espnow test [8 hex digits] or espnow resetstats");
|
||||
return true;
|
||||
}
|
||||
if (_callbacks->sendEspNowTest(nonce)) {
|
||||
snprintf(reply, capacity, "OK - test queued id=%08lX; confirm on peer",
|
||||
static_cast<unsigned long>(nonce));
|
||||
} else {
|
||||
snprintf(reply, capacity, "Error: ESP-NOW test not queued; check status/stats");
|
||||
}
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
|
||||
void CommonCLI::handleCommand(uint32_t sender_timestamp, char* command, char* reply) {
|
||||
PrefsSaveReplyGuard save_reply(_prefs_save_failures, reply);
|
||||
mesh::cli::normalizeCommandVerb(command);
|
||||
#if defined(WITH_ESPNOW_BRIDGE)
|
||||
if (handleEspNowDiagnosticCommand(sender_timestamp, command, reply)) return;
|
||||
#endif
|
||||
#if MESH_ENABLE_FLEET_CONTROL
|
||||
if (handleFleetCommand(command, reply)) return;
|
||||
#endif
|
||||
|
||||
@@ -646,6 +646,17 @@ public:
|
||||
virtual bool isEspNowBridgeRunning() { return isBridgeRunning(); }
|
||||
virtual bool isRs232BridgeRunning() const { return isBridgeRunning(); }
|
||||
virtual void formatRs232Status(char* reply) { strcpy(reply, "RS232 unavailable"); }
|
||||
#if defined(WITH_ESPNOW_BRIDGE)
|
||||
virtual void formatEspNowStatus(char* reply, size_t capacity) {
|
||||
snprintf(reply, capacity, "Error: ESP-NOW diagnostics unavailable");
|
||||
}
|
||||
virtual void formatEspNowStats(const char* page, char* reply, size_t capacity) {
|
||||
(void)page;
|
||||
snprintf(reply, capacity, "Error: ESP-NOW diagnostics unavailable");
|
||||
}
|
||||
virtual bool sendEspNowTest(uint32_t nonce) { (void)nonce; return false; }
|
||||
virtual bool resetEspNowStats() { return false; }
|
||||
#endif
|
||||
|
||||
virtual void restartBridgeSlot(int slot) {
|
||||
// Default: fall back to full restart
|
||||
@@ -897,6 +908,9 @@ class CommonCLI {
|
||||
void handleRegionCmd(char* command, char* reply);
|
||||
void handleGetCmd(uint32_t sender_timestamp, char* command, char* reply);
|
||||
void handleSetCmd(uint32_t sender_timestamp, char* command, char* reply);
|
||||
#if defined(WITH_ESPNOW_BRIDGE)
|
||||
bool handleEspNowDiagnosticCommand(uint32_t sender_timestamp, const char* command, char* reply);
|
||||
#endif
|
||||
void handleDelCmd(char* command, char* reply);
|
||||
#if defined(NRF52_PLATFORM) && defined(OTA_SD_STORE)
|
||||
bool handleSdCardGetCmd(const char* config, char* reply);
|
||||
|
||||
@@ -36,11 +36,17 @@ void BridgeBase::handleReceivedPacket(mesh::Packet *packet) {
|
||||
if (_initialized == false) {
|
||||
BRIDGE_DEBUG_PRINTLN("RX packet received before initialization\n");
|
||||
_mgr->free(packet);
|
||||
#if defined(WITH_ESPNOW_BRIDGE)
|
||||
onIngressResult(IngressResult::Stopped);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
if (!preparePacketIngress(packet) || !allowsPacket(packet)) {
|
||||
_mgr->free(packet);
|
||||
#if defined(WITH_ESPNOW_BRIDGE)
|
||||
onIngressResult(IngressResult::Filtered);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -52,7 +58,13 @@ void BridgeBase::handleReceivedPacket(mesh::Packet *packet) {
|
||||
if (!ota) _seen_packets.markSeen(packet);
|
||||
// bridge_delay provides a buffer to prevent immediate processing conflicts in the mesh network.
|
||||
_mgr->queueInbound(packet, millis() + _prefs->bridge_delay);
|
||||
#if defined(WITH_ESPNOW_BRIDGE)
|
||||
onIngressResult(IngressResult::Queued);
|
||||
#endif
|
||||
} else {
|
||||
_mgr->free(packet);
|
||||
#if defined(WITH_ESPNOW_BRIDGE)
|
||||
onIngressResult(IngressResult::Duplicate);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
@@ -50,6 +50,12 @@ public:
|
||||
static constexpr uint16_t BRIDGE_CHECKSUM_SIZE = sizeof(uint16_t);
|
||||
|
||||
protected:
|
||||
#if defined(WITH_ESPNOW_BRIDGE)
|
||||
// Observe the existing admission decision without evaluating filters twice.
|
||||
enum class IngressResult : uint8_t { Stopped, Filtered, Duplicate, Queued };
|
||||
virtual void onIngressResult(IngressResult) {}
|
||||
#endif
|
||||
|
||||
/** Tracks bridge state */
|
||||
bool _initialized = false;
|
||||
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
|
||||
#include <esp_wifi.h>
|
||||
#include <helpers/esp32/WiFiRadioPolicy.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#ifdef WITH_ESPNOW_BRIDGE
|
||||
#include <WiFi.h>
|
||||
@@ -73,7 +74,12 @@ ESPNowBridge::ESPNowBridge(NodePrefs *prefs, mesh::PacketManager *mgr, mesh::RTC
|
||||
}
|
||||
|
||||
void ESPNowBridge::begin() {
|
||||
if (mesh::wireless::control().blocked(mesh::wireless::EspNow)) return;
|
||||
using mesh::bridge::diag::Stage;
|
||||
if (mesh::wireless::control().blocked(mesh::wireless::EspNow)) {
|
||||
recordError(Stage::Policy, ESP_ERR_INVALID_STATE);
|
||||
emitDebug();
|
||||
return;
|
||||
}
|
||||
BRIDGE_DEBUG_PRINTLN("Initializing...\n");
|
||||
|
||||
if (_initialized) return;
|
||||
@@ -86,6 +92,8 @@ void ESPNowBridge::begin() {
|
||||
? _prefs->bridge_format : mesh::bridge::ESPNOW_FORMAT_WRAPPED;
|
||||
const bool raw_format = _active_format == mesh::bridge::ESPNOW_FORMAT_RAW;
|
||||
if (raw_format && mesh::wifi::checkLongRangeRadioStart() != ESP_OK) {
|
||||
recordError(Stage::WiFiProtocol, ESP_ERR_INVALID_STATE);
|
||||
emitDebug();
|
||||
BRIDGE_DEBUG_PRINTLN("ESP-NOW LR start deferred while a WiFi AP is active\n");
|
||||
return;
|
||||
}
|
||||
@@ -111,6 +119,8 @@ void ESPNowBridge::begin() {
|
||||
|
||||
if (!mesh::bridge::isValidEspNowBridgeChannel(
|
||||
_prefs->bridge_channel, _active_format)) {
|
||||
recordError(Stage::Channel, ESP_ERR_INVALID_ARG);
|
||||
emitDebug();
|
||||
BRIDGE_DEBUG_PRINTLN("ESP-NOW channel must be 1-13\n");
|
||||
return;
|
||||
}
|
||||
@@ -122,18 +132,28 @@ void ESPNowBridge::begin() {
|
||||
if (shared_wifi) {
|
||||
uint8_t channel = 0;
|
||||
wifi_second_chan_t secondary = WIFI_SECOND_CHAN_NONE;
|
||||
if (esp_wifi_get_channel(&channel, &secondary) != ESP_OK || channel != _prefs->bridge_channel) {
|
||||
const esp_err_t result = esp_wifi_get_channel(&channel, &secondary);
|
||||
if (result != ESP_OK || channel != _prefs->bridge_channel) {
|
||||
recordError(Stage::ChannelConflict,
|
||||
result != ESP_OK ? result : ESP_ERR_INVALID_STATE);
|
||||
emitDebug();
|
||||
BRIDGE_DEBUG_PRINTLN("ESP-NOW bridge channel must match the active WiFi channel\n");
|
||||
return;
|
||||
}
|
||||
}
|
||||
wifi_init_config_t wifi_config = WIFI_INIT_CONFIG_DEFAULT();
|
||||
if (!shared_wifi && (esp_wifi_init(&wifi_config) != ESP_OK ||
|
||||
esp_wifi_set_storage(WIFI_STORAGE_RAM) != ESP_OK ||
|
||||
esp_wifi_set_mode(WIFI_MODE_STA) != ESP_OK ||
|
||||
esp_wifi_start() != ESP_OK)) {
|
||||
auto failed = [this](esp_err_t result, Stage stage) {
|
||||
if (result == ESP_OK) return false;
|
||||
recordError(stage, result);
|
||||
stopBridgeWiFiIfUnused();
|
||||
return;
|
||||
emitDebug();
|
||||
return true;
|
||||
};
|
||||
if (!shared_wifi) {
|
||||
if (failed(esp_wifi_init(&wifi_config), Stage::WiFiInit)
|
||||
|| failed(esp_wifi_set_storage(WIFI_STORAGE_RAM), Stage::WiFiStorage)
|
||||
|| failed(esp_wifi_set_mode(WIFI_MODE_STA), Stage::WiFiMode)
|
||||
|| failed(esp_wifi_start(), Stage::WiFiStart)) return;
|
||||
}
|
||||
|
||||
if (raw_format) {
|
||||
@@ -141,7 +161,10 @@ void ESPNowBridge::begin() {
|
||||
// support as well, but force this peer's outgoing frames to LR below.
|
||||
const uint8_t protocols = WIFI_PROTOCOL_11B | WIFI_PROTOCOL_11G
|
||||
| WIFI_PROTOCOL_11N | WIFI_PROTOCOL_LR;
|
||||
if (mesh::wifi::applyStationProtocolMask(protocols, true) != ESP_OK) {
|
||||
const esp_err_t result = mesh::wifi::applyStationProtocolMask(protocols, true);
|
||||
if (result != ESP_OK) {
|
||||
recordError(Stage::WiFiProtocol, result);
|
||||
emitDebug();
|
||||
BRIDGE_DEBUG_PRINTLN("Error enabling ESP-NOW LR protocol\n");
|
||||
stopBridgeWiFiIfUnused();
|
||||
return;
|
||||
@@ -149,21 +172,34 @@ void ESPNowBridge::begin() {
|
||||
}
|
||||
|
||||
// Set Wi-Fi channel
|
||||
if (!shared_wifi && esp_wifi_set_channel(_prefs->bridge_channel, WIFI_SECOND_CHAN_NONE) != ESP_OK) {
|
||||
const esp_err_t channel_result = shared_wifi ? ESP_OK
|
||||
: esp_wifi_set_channel(_prefs->bridge_channel, WIFI_SECOND_CHAN_NONE);
|
||||
if (channel_result != ESP_OK) {
|
||||
recordError(Stage::WiFiChannel, channel_result);
|
||||
emitDebug();
|
||||
BRIDGE_DEBUG_PRINTLN("Error setting WIFI channel to %d\n", _prefs->bridge_channel);
|
||||
stopBridgeWiFiIfUnused();
|
||||
return;
|
||||
}
|
||||
|
||||
// Initialize ESP-NOW
|
||||
if (esp_now_init() != ESP_OK) {
|
||||
const esp_err_t init_result = esp_now_init();
|
||||
if (init_result != ESP_OK) {
|
||||
recordError(Stage::EspNowInit, init_result);
|
||||
emitDebug();
|
||||
BRIDGE_DEBUG_PRINTLN("Error initializing ESP-NOW\n");
|
||||
stopBridgeWiFiIfUnused();
|
||||
return;
|
||||
}
|
||||
|
||||
// Register callbacks
|
||||
if (esp_now_register_recv_cb(recv_cb) != ESP_OK || esp_now_register_send_cb(send_cb) != ESP_OK) {
|
||||
const esp_err_t recv_result = esp_now_register_recv_cb(recv_cb);
|
||||
const esp_err_t send_result = recv_result == ESP_OK
|
||||
? esp_now_register_send_cb(send_cb) : ESP_OK;
|
||||
if (recv_result != ESP_OK || send_result != ESP_OK) {
|
||||
recordError(recv_result != ESP_OK ? Stage::RecvCallback : Stage::SendCallback,
|
||||
recv_result != ESP_OK ? recv_result : send_result);
|
||||
emitDebug();
|
||||
BRIDGE_DEBUG_PRINTLN("Error registering ESP-NOW callbacks\n");
|
||||
esp_now_register_recv_cb(nullptr);
|
||||
esp_now_register_send_cb(nullptr);
|
||||
@@ -180,7 +216,10 @@ void ESPNowBridge::begin() {
|
||||
peerInfo.ifidx = WIFI_IF_STA;
|
||||
peerInfo.encrypt = false;
|
||||
|
||||
if (esp_now_add_peer(&peerInfo) != ESP_OK) {
|
||||
const esp_err_t peer_result = esp_now_add_peer(&peerInfo);
|
||||
if (peer_result != ESP_OK) {
|
||||
recordError(Stage::PeerAdd, peer_result);
|
||||
emitDebug();
|
||||
BRIDGE_DEBUG_PRINTLN("Failed to add broadcast peer\n");
|
||||
esp_now_register_recv_cb(nullptr);
|
||||
esp_now_register_send_cb(nullptr);
|
||||
@@ -203,6 +242,8 @@ void ESPNowBridge::begin() {
|
||||
WIFI_IF_STA, WIFI_PHY_RATE_LORA_250K);
|
||||
#endif
|
||||
if (rate_result != ESP_OK) {
|
||||
recordError(Stage::PeerRate, rate_result);
|
||||
emitDebug();
|
||||
BRIDGE_DEBUG_PRINTLN("Error configuring ESP-NOW LR peer rate\n");
|
||||
esp_now_del_peer(peerInfo.peer_addr);
|
||||
esp_now_register_recv_cb(nullptr);
|
||||
@@ -217,6 +258,8 @@ void ESPNowBridge::begin() {
|
||||
_initialized = true;
|
||||
mesh::wifi::setLongRangeOwner(mesh::wifi::kLongRangeBridgeOwner, raw_format);
|
||||
mesh::wifi::bridgeEspNowChannel().store(_prefs->bridge_channel);
|
||||
_debug_dirty.store(true, std::memory_order_relaxed);
|
||||
emitDebug();
|
||||
}
|
||||
|
||||
void ESPNowBridge::end() {
|
||||
@@ -225,7 +268,9 @@ void ESPNowBridge::end() {
|
||||
|
||||
// Remove broadcast peer
|
||||
uint8_t broadcastAddress[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
|
||||
if (esp_now_del_peer(broadcastAddress) != ESP_OK) {
|
||||
const esp_err_t remove_result = esp_now_del_peer(broadcastAddress);
|
||||
if (remove_result != ESP_OK) {
|
||||
recordError(mesh::bridge::diag::Stage::PeerRemove, remove_result);
|
||||
BRIDGE_DEBUG_PRINTLN("Error removing broadcast peer\n");
|
||||
}
|
||||
|
||||
@@ -234,8 +279,10 @@ void ESPNowBridge::end() {
|
||||
esp_now_register_send_cb(nullptr);
|
||||
|
||||
// Deinitialize ESP-NOW
|
||||
_sdk_teardown_failed = esp_now_deinit() != ESP_OK;
|
||||
const esp_err_t deinit_result = esp_now_deinit();
|
||||
_sdk_teardown_failed = deinit_result != ESP_OK;
|
||||
if (_sdk_teardown_failed) {
|
||||
recordError(mesh::bridge::diag::Stage::EspNowDeinit, deinit_result);
|
||||
BRIDGE_DEBUG_PRINTLN("Error deinitializing ESP-NOW\n");
|
||||
}
|
||||
|
||||
@@ -257,7 +304,7 @@ void ESPNowBridge::end() {
|
||||
uint8_t tx_index = _tx_tail;
|
||||
for (uint8_t i = 0; i < _tx_count; ++i) {
|
||||
const QueuedTransmit& queued_tx = _tx_queue[tx_index];
|
||||
if (!queued_tx.started) _seen_packets.clear(&queued_tx.packet);
|
||||
if (!queued_tx.started && !queued_tx.diagnostic) _seen_packets.clear(&queued_tx.packet);
|
||||
tx_index = static_cast<uint8_t>((tx_index + 1) % TX_QUEUE_DEPTH);
|
||||
}
|
||||
portENTER_CRITICAL(&_tx_mux);
|
||||
@@ -270,25 +317,20 @@ void ESPNowBridge::end() {
|
||||
|
||||
// Update bridge state
|
||||
_initialized = false;
|
||||
_debug_dirty.store(true, std::memory_order_relaxed);
|
||||
emitDebug();
|
||||
}
|
||||
|
||||
void ESPNowBridge::loop() {
|
||||
if (!_initialized) return;
|
||||
if (!_initialized) { emitDebug(); return; }
|
||||
pumpTransmitQueue();
|
||||
if (!_initialized) return;
|
||||
if (!_initialized) { emitDebug(); return; }
|
||||
|
||||
uint8_t frame[MAX_ESPNOW_PACKET_SIZE];
|
||||
uint8_t source[mesh::espnow::ESPNOW_RAW_SOURCE_MAC_SIZE];
|
||||
for (uint8_t processed = 0; processed < RX_QUEUE_DEPTH; ++processed) {
|
||||
// Reserve a mesh slot before removing a callback frame. Even a completing
|
||||
// raw fragment must remain queued until the reconstructed packet can live.
|
||||
mesh::Packet* packet = _mgr->allocNew();
|
||||
if (packet == nullptr) break;
|
||||
size_t frame_len = 0;
|
||||
uint32_t dropped = 0;
|
||||
|
||||
portENTER_CRITICAL(&_rx_mux);
|
||||
dropped = _rx_dropped;
|
||||
if (_rx_count > 0) {
|
||||
frame_len = _rx_lengths[_rx_tail];
|
||||
if (frame_len > 0 && frame_len <= sizeof(frame)) {
|
||||
@@ -297,26 +339,42 @@ void ESPNowBridge::loop() {
|
||||
} else {
|
||||
frame_len = 0;
|
||||
}
|
||||
_rx_tail = static_cast<uint8_t>((_rx_tail + 1) % RX_QUEUE_DEPTH);
|
||||
_rx_count--;
|
||||
}
|
||||
portEXIT_CRITICAL(&_rx_mux);
|
||||
if (frame_len == 0) break;
|
||||
|
||||
if (dropped != _rx_dropped_reported) {
|
||||
BRIDGE_DEBUG_PRINTLN("RX queue full, dropped=%lu\n",
|
||||
(unsigned long)dropped);
|
||||
_rx_dropped_reported = dropped;
|
||||
}
|
||||
if (frame_len == 0) { _mgr->free(packet); break; }
|
||||
if (!processReceivedFrame(packet, source, frame, frame_len)) {
|
||||
_mgr->free(packet);
|
||||
const bool diagnostic = mesh::bridge::diag::isProbeCandidate(frame, frame_len);
|
||||
// Diagnostic frames never consume a mesh slot, even under pool pressure.
|
||||
// Ordinary frames remain queued until an allocation succeeds.
|
||||
mesh::Packet* packet = diagnostic ? nullptr : _mgr->allocNew();
|
||||
if (!diagnostic && packet == nullptr) break;
|
||||
portENTER_CRITICAL(&_rx_mux);
|
||||
_rx_tail = static_cast<uint8_t>((_rx_tail + 1) % RX_QUEUE_DEPTH);
|
||||
_rx_count--;
|
||||
portEXIT_CRITICAL(&_rx_mux);
|
||||
|
||||
if (diagnostic) {
|
||||
mesh::bridge::diag::Probe probe;
|
||||
const bool valid = mesh::bridge::diag::decodeProbe(frame, frame_len, probe);
|
||||
portENTER_CRITICAL(&_rx_mux);
|
||||
if (valid) {
|
||||
mesh::bridge::diag::increment(_stats.probe.rx_ok);
|
||||
_stats.probe.last_rx_nonce = probe.nonce;
|
||||
} else {
|
||||
mesh::bridge::diag::increment(_stats.probe.rx_bad);
|
||||
}
|
||||
portEXIT_CRITICAL(&_rx_mux);
|
||||
_debug_dirty.store(true, std::memory_order_relaxed);
|
||||
continue; // Never decode, echo, deduplicate, or relay a probe as MeshCore.
|
||||
}
|
||||
if (!processReceivedFrame(packet, source, frame, frame_len)) _mgr->free(packet);
|
||||
}
|
||||
emitDebug();
|
||||
}
|
||||
|
||||
bool ESPNowBridge::queueTransmitFrames(
|
||||
const mesh::espnow::ESPNowRawFrames& frames,
|
||||
const mesh::Packet& packet) {
|
||||
const mesh::Packet& packet, bool diagnostic) {
|
||||
if (frames.count == 0 || frames.count > mesh::espnow::ESPNOW_RAW_FRAGMENT_COUNT) {
|
||||
return false;
|
||||
}
|
||||
@@ -332,15 +390,22 @@ bool ESPNowBridge::queueTransmitFrames(
|
||||
if (_tx_count < TX_QUEUE_DEPTH) {
|
||||
QueuedTransmit& queued_tx = _tx_queue[_tx_head];
|
||||
queued_tx.frames = frames;
|
||||
queued_tx.packet = packet;
|
||||
if (!diagnostic) queued_tx.packet = packet;
|
||||
queued_tx.next_frame = 0;
|
||||
queued_tx.started = false;
|
||||
queued_tx.start_retries = 0;
|
||||
queued_tx.diagnostic = diagnostic;
|
||||
if (diagnostic) mesh::bridge::diag::increment(_stats.probe.tx_queued);
|
||||
else mesh::bridge::diag::increment(_stats.tx.queued);
|
||||
_debug_dirty.store(true, std::memory_order_relaxed);
|
||||
_tx_head = static_cast<uint8_t>((_tx_head + 1) % TX_QUEUE_DEPTH);
|
||||
_tx_count++;
|
||||
queued = true;
|
||||
} else {
|
||||
_tx_dropped++;
|
||||
if (diagnostic) mesh::bridge::diag::increment(_stats.probe.tx_fail);
|
||||
else mesh::bridge::diag::increment(_stats.tx.drops);
|
||||
_debug_dirty.store(true, std::memory_order_relaxed);
|
||||
}
|
||||
portEXIT_CRITICAL(&_tx_mux);
|
||||
return queued;
|
||||
@@ -360,8 +425,14 @@ void ESPNowBridge::pumpTransmitQueue() {
|
||||
portENTER_CRITICAL(&_tx_mux);
|
||||
timed_out = _tx_waiting && !_tx_callback_done
|
||||
&& static_cast<uint32_t>(now - _tx_started_at) >= TX_CALLBACK_TIMEOUT_MS;
|
||||
if (timed_out) {
|
||||
if (_tx_count > 0 && _tx_queue[_tx_tail].diagnostic)
|
||||
mesh::bridge::diag::increment(_stats.probe.tx_timeout);
|
||||
else mesh::bridge::diag::increment(_stats.tx.callback_timeout);
|
||||
}
|
||||
portEXIT_CRITICAL(&_tx_mux);
|
||||
if (timed_out) {
|
||||
recordError(mesh::bridge::diag::Stage::TxTimeout, ESP_ERR_TIMEOUT);
|
||||
// A completion carries no frame identity. Continuing after timeout could
|
||||
// mistake a late callback for the next fragment. Tear down that SDK session
|
||||
// before accepting another frame; never transmit an orphan sibling.
|
||||
@@ -391,13 +462,14 @@ void ESPNowBridge::pumpTransmitQueue() {
|
||||
(_tx_tail + 1) % TX_QUEUE_DEPTH);
|
||||
_tx_count--;
|
||||
}
|
||||
} else if (queued_tx.start_retries < TX_MAX_START_RETRIES) {
|
||||
} else if (!queued_tx.diagnostic && queued_tx.start_retries < TX_MAX_START_RETRIES) {
|
||||
// This completion is definite, unlike a missing callback. Retry the
|
||||
// same frame within the shared start/callback budget; its sibling
|
||||
// cannot be submitted until this frame succeeds.
|
||||
++queued_tx.start_retries;
|
||||
_tx_retry_at = now + TX_RETRY_DELAY_MS;
|
||||
} else {
|
||||
if (!queued_tx.diagnostic) mesh::bridge::diag::increment(_stats.tx.drops);
|
||||
_tx_tail = static_cast<uint8_t>((_tx_tail + 1) % TX_QUEUE_DEPTH);
|
||||
_tx_count--;
|
||||
}
|
||||
@@ -430,6 +502,7 @@ void ESPNowBridge::pumpTransmitQueue() {
|
||||
_tx_dropped_reported = dropped;
|
||||
}
|
||||
if (completed && completed_status != ESP_NOW_SEND_SUCCESS) {
|
||||
recordError(mesh::bridge::diag::Stage::TxCallback, completed_status);
|
||||
BRIDGE_DEBUG_PRINTLN("TX callback failed, status=%d\n",
|
||||
completed_status);
|
||||
}
|
||||
@@ -440,23 +513,27 @@ void ESPNowBridge::pumpTransmitQueue() {
|
||||
const esp_err_t result = esp_now_send(
|
||||
broadcast_address, frame, frame_len);
|
||||
if (result != ESP_OK) {
|
||||
recordError(mesh::bridge::diag::Stage::TxStart, result);
|
||||
portENTER_CRITICAL(&_tx_mux);
|
||||
_tx_waiting = false;
|
||||
_tx_callback_done = false;
|
||||
if (_tx_count > 0) {
|
||||
QueuedTransmit& queued_tx = _tx_queue[_tx_tail];
|
||||
if (result == ESP_ERR_ESPNOW_NO_MEM
|
||||
if (queued_tx.diagnostic) mesh::bridge::diag::increment(_stats.probe.tx_fail);
|
||||
else mesh::bridge::diag::increment(_stats.tx.start_fail);
|
||||
if (!queued_tx.diagnostic && result == ESP_ERR_ESPNOW_NO_MEM
|
||||
&& queued_tx.start_retries < TX_MAX_START_RETRIES) {
|
||||
++queued_tx.start_retries;
|
||||
_tx_retry_at = now + TX_RETRY_DELAY_MS;
|
||||
} else {
|
||||
if (!queued_tx.started) {
|
||||
if (!queued_tx.started && !queued_tx.diagnostic) {
|
||||
unsent_packet = queued_tx.packet;
|
||||
clear_unsent_seen = true;
|
||||
}
|
||||
_tx_tail = static_cast<uint8_t>((_tx_tail + 1) % TX_QUEUE_DEPTH);
|
||||
_tx_count--;
|
||||
_tx_retry_at = 0;
|
||||
if (!queued_tx.diagnostic) mesh::bridge::diag::increment(_stats.tx.drops);
|
||||
}
|
||||
}
|
||||
portEXIT_CRITICAL(&_tx_mux);
|
||||
@@ -466,15 +543,21 @@ void ESPNowBridge::pumpTransmitQueue() {
|
||||
BRIDGE_DEBUG_PRINTLN("TX failed to start, error=%d\n", (int)result);
|
||||
} else {
|
||||
portENTER_CRITICAL(&_tx_mux);
|
||||
if (_tx_count > 0) _tx_queue[_tx_tail].started = true;
|
||||
if (_tx_count > 0) {
|
||||
_tx_queue[_tx_tail].started = true;
|
||||
if (_tx_queue[_tx_tail].diagnostic) mesh::bridge::diag::increment(_stats.probe.tx_start);
|
||||
else mesh::bridge::diag::increment(_stats.tx.start_ok);
|
||||
}
|
||||
portEXIT_CRITICAL(&_tx_mux);
|
||||
}
|
||||
_debug_dirty.store(true, std::memory_order_relaxed);
|
||||
}
|
||||
|
||||
bool ESPNowBridge::xorCrypt(uint8_t *data, size_t len) {
|
||||
size_t keyLen = 0;
|
||||
while (keyLen < sizeof(_prefs->bridge_secret) && _prefs->bridge_secret[keyLen] != 0) keyLen++;
|
||||
if (keyLen == 0 || keyLen == sizeof(_prefs->bridge_secret)) {
|
||||
recordError(mesh::bridge::diag::Stage::Secret, ESP_ERR_INVALID_ARG);
|
||||
BRIDGE_DEBUG_PRINTLN("Invalid empty or unterminated bridge secret\n");
|
||||
return false;
|
||||
}
|
||||
@@ -487,28 +570,37 @@ bool ESPNowBridge::xorCrypt(uint8_t *data, size_t len) {
|
||||
void ESPNowBridge::receiveMeshPacket(mesh::Packet* pkt, const uint8_t *data, size_t len) {
|
||||
|
||||
if (pkt->readFrom(data, len)) {
|
||||
noteRx(&mesh::bridge::diag::RxStats::packet_ok);
|
||||
onPacketReceived(pkt);
|
||||
} else {
|
||||
noteRx(&mesh::bridge::diag::RxStats::packet_bad);
|
||||
_mgr->free(pkt);
|
||||
}
|
||||
}
|
||||
|
||||
void ESPNowBridge::queueReceivedFrame(const uint8_t *mac, const uint8_t *data,
|
||||
int len) {
|
||||
portENTER_CRITICAL(&_rx_mux);
|
||||
mesh::bridge::diag::increment(_stats.rx.frames);
|
||||
_debug_dirty.store(true, std::memory_order_relaxed);
|
||||
if (data == nullptr || len <= 0 || len > MAX_ESPNOW_PACKET_SIZE) {
|
||||
mesh::bridge::diag::increment(_stats.rx.badframe);
|
||||
portEXIT_CRITICAL(&_rx_mux);
|
||||
return;
|
||||
}
|
||||
|
||||
// Wrapped deployments share the WiFi channel with unrelated ESP-NOW users.
|
||||
// Reject obvious foreign traffic before it can occupy a queue slot.
|
||||
if (_active_format == mesh::bridge::ESPNOW_FORMAT_WRAPPED
|
||||
if (!mesh::bridge::diag::isProbeCandidate(data, static_cast<size_t>(len))
|
||||
&& _active_format == mesh::bridge::ESPNOW_FORMAT_WRAPPED
|
||||
&& (len < BRIDGE_MAGIC_SIZE
|
||||
|| data[0] != static_cast<uint8_t>(BRIDGE_PACKET_MAGIC >> 8)
|
||||
|| data[1] != static_cast<uint8_t>(BRIDGE_PACKET_MAGIC & 0xFF))) {
|
||||
mesh::bridge::diag::increment(_stats.rx.foreign);
|
||||
portEXIT_CRITICAL(&_rx_mux);
|
||||
return;
|
||||
}
|
||||
|
||||
portENTER_CRITICAL(&_rx_mux);
|
||||
if (_rx_count < RX_QUEUE_DEPTH) {
|
||||
memcpy(_rx_buffers[_rx_head], data, static_cast<size_t>(len));
|
||||
_rx_lengths[_rx_head] = static_cast<uint16_t>(len);
|
||||
@@ -523,6 +615,7 @@ void ESPNowBridge::queueReceivedFrame(const uint8_t *mac, const uint8_t *data,
|
||||
_rx_count++;
|
||||
} else {
|
||||
_rx_dropped++;
|
||||
mesh::bridge::diag::increment(_stats.rx.queue_drop);
|
||||
}
|
||||
portEXIT_CRITICAL(&_rx_mux);
|
||||
}
|
||||
@@ -530,6 +623,7 @@ void ESPNowBridge::queueReceivedFrame(const uint8_t *mac, const uint8_t *data,
|
||||
bool ESPNowBridge::processReceivedFrame(mesh::Packet* packet_slot, const uint8_t *mac,
|
||||
const uint8_t *data, size_t len) {
|
||||
if (data == nullptr || len == 0 || len > MAX_ESPNOW_PACKET_SIZE) {
|
||||
noteRx(&mesh::bridge::diag::RxStats::badframe);
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -551,6 +645,7 @@ bool ESPNowBridge::processReceivedFrame(mesh::Packet* packet_slot, const uint8_t
|
||||
} else if (result == mesh::espnow::ESPNowRawReassemblyResult::REJECTED
|
||||
|| result ==
|
||||
mesh::espnow::ESPNowRawReassemblyResult::OUTPUT_TOO_SMALL) {
|
||||
noteRx(&mesh::bridge::diag::RxStats::badframe);
|
||||
BRIDGE_DEBUG_PRINTLN("RX raw fragment rejected, result=%u len=%u\n",
|
||||
(unsigned)result, (unsigned)len);
|
||||
}
|
||||
@@ -560,6 +655,7 @@ bool ESPNowBridge::processReceivedFrame(mesh::Packet* packet_slot, const uint8_t
|
||||
// Wrapped mode is strict: ignore packets too small to contain its header
|
||||
// and checksum rather than trying to auto-detect raw MeshCore traffic.
|
||||
if (len < (BRIDGE_MAGIC_SIZE + BRIDGE_CHECKSUM_SIZE)) {
|
||||
noteRx(&mesh::bridge::diag::RxStats::badframe);
|
||||
BRIDGE_DEBUG_PRINTLN("RX packet too small, len=%u\n", (unsigned)len);
|
||||
return false;
|
||||
}
|
||||
@@ -567,6 +663,7 @@ bool ESPNowBridge::processReceivedFrame(mesh::Packet* packet_slot, const uint8_t
|
||||
// Check packet header magic
|
||||
uint16_t received_magic = (data[0] << 8) | data[1];
|
||||
if (received_magic != BRIDGE_PACKET_MAGIC) {
|
||||
noteRx(&mesh::bridge::diag::RxStats::foreign);
|
||||
BRIDGE_DEBUG_PRINTLN("RX invalid magic 0x%04X\n", received_magic);
|
||||
return false;
|
||||
}
|
||||
@@ -584,6 +681,7 @@ bool ESPNowBridge::processReceivedFrame(mesh::Packet* packet_slot, const uint8_t
|
||||
const size_t payloadLen = encryptedDataLen - BRIDGE_CHECKSUM_SIZE;
|
||||
|
||||
if (!validateChecksum(decrypted + BRIDGE_CHECKSUM_SIZE, payloadLen, received_checksum)) {
|
||||
noteRx(&mesh::bridge::diag::RxStats::checksum_bad);
|
||||
// Failed to decrypt - likely from a different network
|
||||
BRIDGE_DEBUG_PRINTLN("RX checksum mismatch, rcv=0x%04X\n", received_checksum);
|
||||
return false;
|
||||
@@ -597,26 +695,38 @@ bool ESPNowBridge::processReceivedFrame(mesh::Packet* packet_slot, const uint8_t
|
||||
void ESPNowBridge::onDataSent(const uint8_t *mac_addr, esp_now_send_status_t status) {
|
||||
(void)mac_addr;
|
||||
portENTER_CRITICAL(&_tx_mux);
|
||||
if (_tx_waiting) {
|
||||
if (_tx_waiting && !_tx_callback_done) {
|
||||
_tx_callback_status = static_cast<int>(status);
|
||||
_tx_callback_done = true;
|
||||
if (_tx_count > 0 && _tx_queue[_tx_tail].diagnostic) {
|
||||
if (status == ESP_NOW_SEND_SUCCESS) mesh::bridge::diag::increment(_stats.probe.tx_ok);
|
||||
else mesh::bridge::diag::increment(_stats.probe.tx_fail);
|
||||
} else {
|
||||
if (status == ESP_NOW_SEND_SUCCESS) mesh::bridge::diag::increment(_stats.tx.callback_ok);
|
||||
else mesh::bridge::diag::increment(_stats.tx.callback_fail);
|
||||
}
|
||||
_debug_dirty.store(true, std::memory_order_relaxed);
|
||||
}
|
||||
portEXIT_CRITICAL(&_tx_mux);
|
||||
}
|
||||
|
||||
void ESPNowBridge::sendPacket(mesh::Packet *packet) {
|
||||
using mesh::bridge::diag::TxStats;
|
||||
noteTx(&TxStats::requested);
|
||||
// Guard against uninitialized state
|
||||
if (_initialized == false) {
|
||||
noteTx(&TxStats::drops);
|
||||
return;
|
||||
}
|
||||
|
||||
// First validate the packet pointer
|
||||
if (!packet) {
|
||||
noteTx(&TxStats::drops);
|
||||
BRIDGE_DEBUG_PRINTLN("TX invalid packet pointer\n");
|
||||
return;
|
||||
}
|
||||
|
||||
if (!allowsPacket(packet)) return;
|
||||
if (!allowsPacket(packet)) { noteTx(&TxStats::filtered); return; }
|
||||
|
||||
// Core OTA forwarding already bounds repeated requests and rejects longer
|
||||
// downstream echoes. Do not permanently suppress its byte-identical retry.
|
||||
@@ -628,6 +738,7 @@ void ESPNowBridge::sendPacket(mesh::Packet *packet) {
|
||||
mesh::bridge::espNowMaxMeshPacketSize(_active_format);
|
||||
if (expectedMeshPacketLen < 0
|
||||
|| (size_t)expectedMeshPacketLen > maxPayload) {
|
||||
noteTx(&TxStats::oversize);
|
||||
BRIDGE_DEBUG_PRINTLN("TX packet too large (payload=%d, max=%u)\n",
|
||||
expectedMeshPacketLen, (unsigned)maxPayload);
|
||||
return;
|
||||
@@ -636,6 +747,7 @@ void ESPNowBridge::sendPacket(mesh::Packet *packet) {
|
||||
uint8_t buffer[MAX_TRANS_UNIT];
|
||||
uint16_t meshPacketLen = packet->writeTo(buffer);
|
||||
if (meshPacketLen != (uint16_t)expectedMeshPacketLen) {
|
||||
noteTx(&TxStats::drops);
|
||||
BRIDGE_DEBUG_PRINTLN("TX packet length mismatch (actual=%d, expected=%d)\n", meshPacketLen,
|
||||
expectedMeshPacketLen);
|
||||
return;
|
||||
@@ -655,6 +767,7 @@ void ESPNowBridge::sendPacket(mesh::Packet *packet) {
|
||||
buffer[3] = checksum & 0xFF;
|
||||
if (!xorCrypt(buffer + BRIDGE_MAGIC_SIZE,
|
||||
meshPacketLen + BRIDGE_CHECKSUM_SIZE)) {
|
||||
noteTx(&TxStats::drops);
|
||||
return;
|
||||
}
|
||||
totalPacketSize = packetOffset + meshPacketLen;
|
||||
@@ -678,8 +791,11 @@ void ESPNowBridge::sendPacket(mesh::Packet *packet) {
|
||||
mesh::bridge::espNowFormatName(_active_format),
|
||||
meshPacketLen, (unsigned)frames.count);
|
||||
} else {
|
||||
if (!encoded) noteTx(&TxStats::drops);
|
||||
BRIDGE_DEBUG_PRINTLN("TX queue/encode failed!\n");
|
||||
}
|
||||
} else {
|
||||
noteTx(&TxStats::duplicate);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -687,4 +803,177 @@ void ESPNowBridge::onPacketReceived(mesh::Packet *packet) {
|
||||
handleReceivedPacket(packet);
|
||||
}
|
||||
|
||||
void ESPNowBridge::noteRx(uint32_t mesh::bridge::diag::RxStats::* field) {
|
||||
portENTER_CRITICAL(&_rx_mux);
|
||||
mesh::bridge::diag::increment(_stats.rx.*field);
|
||||
portEXIT_CRITICAL(&_rx_mux);
|
||||
_debug_dirty.store(true, std::memory_order_relaxed);
|
||||
}
|
||||
|
||||
void ESPNowBridge::noteTx(uint32_t mesh::bridge::diag::TxStats::* field) {
|
||||
portENTER_CRITICAL(&_tx_mux);
|
||||
mesh::bridge::diag::increment(_stats.tx.*field);
|
||||
portEXIT_CRITICAL(&_tx_mux);
|
||||
_debug_dirty.store(true, std::memory_order_relaxed);
|
||||
}
|
||||
|
||||
void ESPNowBridge::onIngressResult(IngressResult result) {
|
||||
using mesh::bridge::diag::RxStats;
|
||||
if (result == IngressResult::Queued) noteRx(&RxStats::delivered);
|
||||
else if (result == IngressResult::Duplicate) noteRx(&RxStats::duplicate);
|
||||
else noteRx(&RxStats::filtered);
|
||||
}
|
||||
|
||||
mesh::bridge::diag::Stats ESPNowBridge::snapshotStats() {
|
||||
portENTER_CRITICAL(&_rx_mux);
|
||||
portENTER_CRITICAL(&_tx_mux);
|
||||
const mesh::bridge::diag::Stats snapshot = _stats;
|
||||
portEXIT_CRITICAL(&_tx_mux);
|
||||
portEXIT_CRITICAL(&_rx_mux);
|
||||
return snapshot;
|
||||
}
|
||||
|
||||
void ESPNowBridge::recordError(mesh::bridge::diag::Stage stage, int32_t code) {
|
||||
portENTER_CRITICAL(&_tx_mux);
|
||||
_stats.error.stage = stage;
|
||||
_stats.error.code = code;
|
||||
_stats.error.at_ms = millis();
|
||||
portEXIT_CRITICAL(&_tx_mux);
|
||||
_debug_dirty.store(true, std::memory_order_relaxed);
|
||||
}
|
||||
|
||||
void ESPNowBridge::resetStats() {
|
||||
portENTER_CRITICAL(&_rx_mux);
|
||||
portENTER_CRITICAL(&_tx_mux);
|
||||
_stats = mesh::bridge::diag::Stats{};
|
||||
_rx_dropped = _rx_dropped_reported = 0;
|
||||
_tx_dropped = _tx_dropped_reported = 0;
|
||||
portEXIT_CRITICAL(&_tx_mux);
|
||||
portEXIT_CRITICAL(&_rx_mux);
|
||||
_debug_dirty.store(true, std::memory_order_relaxed);
|
||||
}
|
||||
|
||||
bool ESPNowBridge::sendTest(uint32_t nonce) {
|
||||
using namespace mesh::bridge::diag;
|
||||
if (!_initialized) {
|
||||
recordError(Stage::TestQueue, ESP_ERR_INVALID_STATE);
|
||||
return false;
|
||||
}
|
||||
mesh::espnow::ESPNowRawFrames frames;
|
||||
Probe probe;
|
||||
probe.nonce = nonce;
|
||||
probe.format = _active_format;
|
||||
probe.channel = _prefs->bridge_channel;
|
||||
if (!encodeProbe(frames.data[0], sizeof(frames.data[0]), probe)) {
|
||||
recordError(Stage::TestQueue, ESP_ERR_INVALID_ARG);
|
||||
return false;
|
||||
}
|
||||
frames.count = 1;
|
||||
frames.lengths[0] = ProbeSize;
|
||||
const mesh::Packet unused_packet;
|
||||
if (!queueTransmitFrames(frames, unused_packet, true)) {
|
||||
recordError(Stage::TestQueue, ESP_ERR_ESPNOW_NO_MEM);
|
||||
return false;
|
||||
}
|
||||
portENTER_CRITICAL(&_tx_mux);
|
||||
_stats.probe.last_tx_nonce = nonce;
|
||||
portEXIT_CRITICAL(&_tx_mux);
|
||||
return true;
|
||||
}
|
||||
|
||||
void ESPNowBridge::formatStatus(char* reply, size_t reply_size) {
|
||||
uint8_t channel = 0, protocols = 0;
|
||||
wifi_second_chan_t secondary = WIFI_SECOND_CHAN_NONE;
|
||||
wifi_mode_t mode = WIFI_MODE_NULL;
|
||||
wifi_ps_type_t power_save = WIFI_PS_NONE;
|
||||
const bool channel_ok = esp_wifi_get_channel(&channel, &secondary) == ESP_OK;
|
||||
const bool mode_ok = esp_wifi_get_mode(&mode) == ESP_OK;
|
||||
const bool ps_ok = esp_wifi_get_ps(&power_save) == ESP_OK;
|
||||
(void)esp_wifi_get_protocol(WIFI_IF_STA, &protocols);
|
||||
uint8_t rx_depth, tx_depth;
|
||||
portENTER_CRITICAL(&_rx_mux); rx_depth = _rx_count; portEXIT_CRITICAL(&_rx_mux);
|
||||
portENTER_CRITICAL(&_tx_mux); tx_depth = _tx_count; portEXIT_CRITICAL(&_tx_mux);
|
||||
const auto stats = snapshotStats();
|
||||
const char* state = !_initialized ? (_sdk_teardown_failed ? "teardown-error" : "off")
|
||||
: (!channel_ok || !mode_ok || !(mode & WIFI_MODE_STA)) ? "driver-error"
|
||||
: (channel != _prefs->bridge_channel) ? "channel-mismatch" : "ready";
|
||||
snprintf(reply, reply_size,
|
||||
"> %s ch=%u/%u fmt=%s src=%s wifi=%s mode=%d ps=%d proto=%02X q=%u/%u last=%s/%ld",
|
||||
state, (unsigned)_prefs->bridge_channel, (unsigned)(channel_ok ? channel : 0),
|
||||
mesh::bridge::espNowFormatName(_initialized ? _active_format : _prefs->bridge_format),
|
||||
_prefs->bridge_pkt_src ? "rx" : "tx",
|
||||
(mesh::wireless::control().enabled() & mesh::wireless::WiFi) ? "on" : "off",
|
||||
mode_ok ? static_cast<int>(mode) : -1, ps_ok ? static_cast<int>(power_save) : -1,
|
||||
(unsigned)protocols, (unsigned)rx_depth, (unsigned)tx_depth,
|
||||
mesh::bridge::diag::stageName(stats.error.stage), (long)stats.error.code);
|
||||
}
|
||||
|
||||
void ESPNowBridge::formatStats(const char* page, char* reply, size_t reply_size) {
|
||||
const auto s = snapshotStats();
|
||||
if (page == nullptr || page[0] == 0) {
|
||||
snprintf(reply, reply_size, "> rx=%lu mesh=%lu tx=%lu sent=%lu; pages: rx tx drops test",
|
||||
(unsigned long)s.rx.frames, (unsigned long)s.rx.delivered,
|
||||
(unsigned long)s.tx.queued, (unsigned long)s.tx.callback_ok);
|
||||
} else if (strcmp(page, "rx") == 0) {
|
||||
snprintf(reply, reply_size, "> frames=%lu decoded=%lu mesh=%lu crc=%lu bad=%lu parse=%lu",
|
||||
(unsigned long)s.rx.frames, (unsigned long)s.rx.packet_ok,
|
||||
(unsigned long)s.rx.delivered, (unsigned long)s.rx.checksum_bad,
|
||||
(unsigned long)s.rx.badframe, (unsigned long)s.rx.packet_bad);
|
||||
} else if (strcmp(page, "tx") == 0) {
|
||||
snprintf(reply, reply_size, "> req=%lu queued=%lu start=%lu ok=%lu err=%lu cbfail=%lu timeout=%lu",
|
||||
(unsigned long)s.tx.requested, (unsigned long)s.tx.queued,
|
||||
(unsigned long)s.tx.start_ok, (unsigned long)s.tx.callback_ok,
|
||||
(unsigned long)s.tx.start_fail, (unsigned long)s.tx.callback_fail,
|
||||
(unsigned long)s.tx.callback_timeout);
|
||||
} else if (strcmp(page, "drops") == 0) {
|
||||
snprintf(reply, reply_size, "> rxq=%lu foreign=%lu filter=%lu dupe=%lu txq=%lu txfilter=%lu txdupe=%lu big=%lu",
|
||||
(unsigned long)s.rx.queue_drop, (unsigned long)s.rx.foreign,
|
||||
(unsigned long)s.rx.filtered, (unsigned long)s.rx.duplicate,
|
||||
(unsigned long)s.tx.drops, (unsigned long)s.tx.filtered,
|
||||
(unsigned long)s.tx.duplicate, (unsigned long)s.tx.oversize);
|
||||
} else if (strcmp(page, "test") == 0) {
|
||||
snprintf(reply, reply_size, "> queued=%lu start=%lu ok=%lu fail=%lu timeout=%lu rx=%lu bad=%lu txid=%08lX rxid=%08lX",
|
||||
(unsigned long)s.probe.tx_queued, (unsigned long)s.probe.tx_start,
|
||||
(unsigned long)s.probe.tx_ok, (unsigned long)s.probe.tx_fail,
|
||||
(unsigned long)s.probe.tx_timeout, (unsigned long)s.probe.rx_ok,
|
||||
(unsigned long)s.probe.rx_bad, (unsigned long)s.probe.last_tx_nonce,
|
||||
(unsigned long)s.probe.last_rx_nonce);
|
||||
} else {
|
||||
snprintf(reply, reply_size, "Error: use get espnow.stats [rx|tx|drops|test]");
|
||||
}
|
||||
}
|
||||
|
||||
void ESPNowBridge::emitDebug() {
|
||||
#if defined(ARDUINO)
|
||||
if (!mesh::isUsbDebugLoggingEnabled()) { _debug_was_enabled = false; return; }
|
||||
if (!_debug_was_enabled) _debug_dirty.store(true, std::memory_order_relaxed);
|
||||
_debug_was_enabled = true;
|
||||
const uint32_t now = millis();
|
||||
if (static_cast<uint32_t>(now - _debug_last_at) < 1000
|
||||
|| !_debug_dirty.exchange(false, std::memory_order_relaxed)) return;
|
||||
_debug_last_at = now;
|
||||
char status[157];
|
||||
formatStatus(status, sizeof(status));
|
||||
const auto s = snapshotStats();
|
||||
#if MESH_ESP32_USB_CONSOLE_COOPERATIVE
|
||||
mesh::nrf52DebugPrintf("ESPNOW: %s rx=%lu mesh=%lu crc=%lu dup=%lu tx=%lu ok=%lu test.rx=%08lX\n",
|
||||
status + 2, (unsigned long)s.rx.frames, (unsigned long)s.rx.delivered,
|
||||
(unsigned long)s.rx.checksum_bad, (unsigned long)s.rx.duplicate,
|
||||
(unsigned long)s.tx.queued, (unsigned long)s.tx.callback_ok,
|
||||
(unsigned long)s.probe.last_rx_nonce);
|
||||
#else
|
||||
char line[256];
|
||||
const int size = snprintf(line, sizeof(line),
|
||||
"ESPNOW: %s rx=%lu mesh=%lu crc=%lu dup=%lu tx=%lu ok=%lu test.rx=%08lX\n",
|
||||
status + 2, (unsigned long)s.rx.frames, (unsigned long)s.rx.delivered,
|
||||
(unsigned long)s.rx.checksum_bad, (unsigned long)s.rx.duplicate,
|
||||
(unsigned long)s.tx.queued, (unsigned long)s.tx.callback_ok,
|
||||
(unsigned long)s.probe.last_rx_nonce);
|
||||
if (size > 0 && static_cast<size_t>(size) < sizeof(line)
|
||||
&& mesh::usbLoggingPort().availableForWrite() >= size)
|
||||
mesh::usbLoggingPort().write(reinterpret_cast<const uint8_t*>(line), size);
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -7,6 +7,8 @@
|
||||
#include "helpers/ESPNowRawFragmentation.h"
|
||||
#include "helpers/bridges/BridgeBase.h"
|
||||
#include "helpers/bridges/ESPNowBridgeFormat.h"
|
||||
#include "helpers/bridges/ESPNowBridgeDiagnostics.h"
|
||||
#include <atomic>
|
||||
|
||||
#ifdef WITH_ESPNOW_BRIDGE
|
||||
|
||||
@@ -106,6 +108,7 @@ private:
|
||||
uint8_t next_frame;
|
||||
bool started;
|
||||
uint8_t start_retries;
|
||||
bool diagnostic;
|
||||
};
|
||||
QueuedTransmit _tx_queue[TX_QUEUE_DEPTH];
|
||||
portMUX_TYPE _tx_mux = portMUX_INITIALIZER_UNLOCKED;
|
||||
@@ -129,6 +132,17 @@ private:
|
||||
// Snapshotted by begin() and immutable until end(), so callbacks and sends
|
||||
// never observe a partially applied preference change.
|
||||
uint8_t _active_format;
|
||||
mesh::bridge::diag::Stats _stats;
|
||||
std::atomic<bool> _debug_dirty{true};
|
||||
uint32_t _debug_last_at = 0;
|
||||
bool _debug_was_enabled = false;
|
||||
|
||||
mesh::bridge::diag::Stats snapshotStats();
|
||||
void noteRx(uint32_t mesh::bridge::diag::RxStats::* field);
|
||||
void noteTx(uint32_t mesh::bridge::diag::TxStats::* field);
|
||||
void recordError(mesh::bridge::diag::Stage stage, int32_t code);
|
||||
void emitDebug();
|
||||
void onIngressResult(IngressResult result) override;
|
||||
|
||||
/**
|
||||
* Performs XOR encryption/decryption of data
|
||||
@@ -162,7 +176,7 @@ private:
|
||||
|
||||
/** Atomically append one logical packet's one or two transport frames. */
|
||||
bool queueTransmitFrames(const mesh::espnow::ESPNowRawFrames& frames,
|
||||
const mesh::Packet& packet);
|
||||
const mesh::Packet& packet, bool diagnostic = false);
|
||||
|
||||
/** Submit at most one queued frame after the previous send callback. */
|
||||
void pumpTransmitQueue();
|
||||
@@ -227,6 +241,13 @@ public:
|
||||
* @param packet The mesh packet to transmit
|
||||
*/
|
||||
void sendPacket(mesh::Packet *packet) override;
|
||||
|
||||
// Runtime diagnostics work in ordinary firmware, without BRIDGE_DEBUG.
|
||||
// All output is bounded and generated on the main loop, never a callback.
|
||||
void formatStatus(char* reply, size_t reply_size);
|
||||
void formatStats(const char* page, char* reply, size_t reply_size);
|
||||
bool sendTest(uint32_t nonce);
|
||||
void resetStats();
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,173 @@
|
||||
#pragma once
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <helpers/ESPNowRawFragmentation.h>
|
||||
|
||||
namespace mesh {
|
||||
namespace bridge {
|
||||
namespace diag {
|
||||
|
||||
// These records have fixed storage and no synchronization or I/O. The bridge
|
||||
// owns their callback/loop locking. Counters survive bridge stop/start; an
|
||||
// explicit local reset or reboot starts a new observation window.
|
||||
struct RxStats {
|
||||
uint32_t frames = 0, foreign = 0, badframe = 0, queue_drop = 0;
|
||||
uint32_t checksum_bad = 0, packet_bad = 0, packet_ok = 0;
|
||||
uint32_t filtered = 0, duplicate = 0, delivered = 0;
|
||||
};
|
||||
|
||||
struct TxStats {
|
||||
uint32_t requested = 0, filtered = 0, duplicate = 0, oversize = 0;
|
||||
uint32_t queued = 0, start_ok = 0, start_fail = 0;
|
||||
uint32_t callback_ok = 0, callback_fail = 0, callback_timeout = 0, drops = 0;
|
||||
};
|
||||
|
||||
struct ProbeStats {
|
||||
uint32_t tx_queued = 0, tx_start = 0, tx_ok = 0, tx_fail = 0, tx_timeout = 0;
|
||||
uint32_t rx_ok = 0, rx_bad = 0, last_tx_nonce = 0, last_rx_nonce = 0;
|
||||
};
|
||||
|
||||
enum class Stage : uint8_t {
|
||||
None, Policy, Channel, ChannelConflict, WiFiInit, WiFiStorage, WiFiMode,
|
||||
WiFiStart, WiFiProtocol, WiFiChannel, EspNowInit, RecvCallback, SendCallback,
|
||||
PeerAdd, PeerRate, PeerRemove, EspNowDeinit, TxStart, TxCallback, TxTimeout,
|
||||
Secret, TestQueue
|
||||
};
|
||||
|
||||
inline const char* stageName(Stage stage) {
|
||||
switch (stage) {
|
||||
case Stage::None: return "none";
|
||||
case Stage::Policy: return "policy";
|
||||
case Stage::Channel: return "channel";
|
||||
case Stage::ChannelConflict: return "channel.conflict";
|
||||
case Stage::WiFiInit: return "wifi.init";
|
||||
case Stage::WiFiStorage: return "wifi.storage";
|
||||
case Stage::WiFiMode: return "wifi.mode";
|
||||
case Stage::WiFiStart: return "wifi.start";
|
||||
case Stage::WiFiProtocol: return "wifi.protocol";
|
||||
case Stage::WiFiChannel: return "wifi.channel";
|
||||
case Stage::EspNowInit: return "espnow.init";
|
||||
case Stage::RecvCallback: return "callback.rx";
|
||||
case Stage::SendCallback: return "callback.tx";
|
||||
case Stage::PeerAdd: return "peer.add";
|
||||
case Stage::PeerRate: return "peer.rate";
|
||||
case Stage::PeerRemove: return "peer.remove";
|
||||
case Stage::EspNowDeinit: return "espnow.deinit";
|
||||
case Stage::TxStart: return "tx.start";
|
||||
case Stage::TxCallback: return "tx.callback";
|
||||
case Stage::TxTimeout: return "tx.timeout";
|
||||
case Stage::Secret: return "secret";
|
||||
case Stage::TestQueue: return "test.queue";
|
||||
}
|
||||
return "unknown";
|
||||
}
|
||||
|
||||
struct Error {
|
||||
Stage stage = Stage::None;
|
||||
int32_t code = 0;
|
||||
uint32_t at_ms = 0;
|
||||
};
|
||||
|
||||
struct Stats {
|
||||
RxStats rx;
|
||||
TxStats tx;
|
||||
ProbeStats probe;
|
||||
Error error;
|
||||
};
|
||||
|
||||
static_assert(sizeof(Stats) <= 160,
|
||||
"ESP-NOW diagnostics must keep bounded counter storage");
|
||||
|
||||
// Saturation keeps a long-running observation from looking newly empty after
|
||||
// integer wrap. Call only while the bridge owns the corresponding counter.
|
||||
inline void increment(uint32_t& value) {
|
||||
if (value != UINT32_MAX) ++value;
|
||||
}
|
||||
|
||||
// Reachability-only probe, not a MeshCore packet and not a secret/key test.
|
||||
// No authentication is implied by the CRC or nonce. Never echo, relay onto
|
||||
// LoRa, admit to PacketManager, or automatically retry a diagnostic probe.
|
||||
//
|
||||
// 0xFE has unsupported MeshCore payload-version bits. Existing raw receivers
|
||||
// reserve the entire 0xFE prefix and reject this distinct MCD magic; existing
|
||||
// wrapped receivers reject it because their magic is C0 3E.
|
||||
// Wire: magic[4], version[1], kind[1], format[1], channel[1], nonce[4], crc[4].
|
||||
// Both integers use network byte order; CRC32 covers exactly the first12 bytes.
|
||||
static constexpr uint8_t ProbeMagic[] = {0xFE, 'M', 'C', 'D'};
|
||||
static constexpr uint8_t ProbeVersion = 1;
|
||||
static constexpr uint8_t ProbeKind = 1;
|
||||
static constexpr size_t ProbeSize = 16;
|
||||
|
||||
struct Probe {
|
||||
uint32_t nonce = 0;
|
||||
uint8_t format = 0;
|
||||
uint8_t channel = 0;
|
||||
};
|
||||
|
||||
inline bool validProbeMetadata(const Probe& probe) {
|
||||
return probe.format <= 1 && probe.channel >= 1 && probe.channel <= 13;
|
||||
}
|
||||
|
||||
// Candidate detection is intentionally broader than decoding. Consume a full
|
||||
// MCD prefix even when its version, length, metadata or CRC is malformed.
|
||||
inline bool isProbeCandidate(const uint8_t* frame, size_t len) {
|
||||
return frame != nullptr && len >= sizeof(ProbeMagic)
|
||||
&& memcmp(frame, ProbeMagic, sizeof(ProbeMagic)) == 0;
|
||||
}
|
||||
|
||||
// No output byte is changed when validation fails. Larger output buffers are
|
||||
// accepted, but only the fixed16-byte frame is written.
|
||||
inline bool encodeProbe(uint8_t* output, size_t capacity, const Probe& probe) {
|
||||
if (output == nullptr || capacity < ProbeSize || !validProbeMetadata(probe)) {
|
||||
return false;
|
||||
}
|
||||
memcpy(output, ProbeMagic, sizeof(ProbeMagic));
|
||||
output[4] = ProbeVersion;
|
||||
output[5] = ProbeKind;
|
||||
output[6] = probe.format;
|
||||
output[7] = probe.channel;
|
||||
mesh::espnow::writeEspNowRawUint32(output + 8, probe.nonce);
|
||||
mesh::espnow::writeEspNowRawUint32(
|
||||
output + 12, mesh::espnow::espNowRawCrc32(output, 12));
|
||||
return true;
|
||||
}
|
||||
|
||||
// No output field is changed on rejection, including truncated/oversize input.
|
||||
inline bool decodeProbe(const uint8_t* frame, size_t len, Probe& output) {
|
||||
if (len != ProbeSize || !isProbeCandidate(frame, len)
|
||||
|| frame[4] != ProbeVersion || frame[5] != ProbeKind) return false;
|
||||
Probe decoded;
|
||||
decoded.format = frame[6];
|
||||
decoded.channel = frame[7];
|
||||
decoded.nonce = mesh::espnow::readEspNowRawUint32(frame + 8);
|
||||
if (!validProbeMetadata(decoded)
|
||||
|| mesh::espnow::readEspNowRawUint32(frame + 12)
|
||||
!= mesh::espnow::espNowRawCrc32(frame, 12)) return false;
|
||||
output = decoded;
|
||||
return true;
|
||||
}
|
||||
|
||||
// Exact8 hexadecimal digits; no signs, whitespace, 0x prefix or trailing text.
|
||||
// Zero is valid. As with the wire decoder, failure preserves the caller's value.
|
||||
inline bool parseNonce(const char* text, uint32_t& output) {
|
||||
if (text == nullptr) return false;
|
||||
uint32_t parsed = 0;
|
||||
for (size_t i = 0; i < 8; ++i) {
|
||||
const char c = text[i];
|
||||
uint8_t digit;
|
||||
if (c >= '0' && c <= '9') digit = static_cast<uint8_t>(c - '0');
|
||||
else if (c >= 'a' && c <= 'f') digit = static_cast<uint8_t>(c - 'a' + 10);
|
||||
else if (c >= 'A' && c <= 'F') digit = static_cast<uint8_t>(c - 'A' + 10);
|
||||
else return false;
|
||||
parsed = (parsed << 4) | digit;
|
||||
}
|
||||
if (text[8] != '\0') return false;
|
||||
output = parsed;
|
||||
return true;
|
||||
}
|
||||
|
||||
} // namespace diag
|
||||
} // namespace bridge
|
||||
} // namespace mesh
|
||||
+369
@@ -0,0 +1,369 @@
|
||||
// Appended to the real bridge source by test_bridge_recovery.code(). Only
|
||||
// SDK APIs, clocks, Packet allocation and the bounded debug sink are mocked.
|
||||
namespace diag = mesh::bridge::diag;
|
||||
|
||||
static void startBackend(Backend& backend) {
|
||||
backend.wifi = true;
|
||||
mesh::wireless::control().begin(backend);
|
||||
sdk_initialized = sdk_started = true;
|
||||
sdk_mode = WIFI_STA;
|
||||
}
|
||||
|
||||
static void deliver(ESPNowBridge& bridge, const uint8_t* bytes, int len) {
|
||||
const uint8_t mac[6] = {1, 2, 3, 4, 5, 6};
|
||||
mesh::in_sdk_callback = true;
|
||||
#if ESP_IDF_VERSION_MAJOR >= 5
|
||||
const esp_now_recv_info_t info{mac};
|
||||
ESPNowBridge::recv_cb(&info, bytes, len);
|
||||
#else
|
||||
ESPNowBridge::recv_cb(mac, bytes, len);
|
||||
#endif
|
||||
mesh::in_sdk_callback = false;
|
||||
(void)bridge;
|
||||
}
|
||||
|
||||
static void deliverCompletion(ESPNowBridge& bridge, int status) {
|
||||
mesh::in_sdk_callback = true;
|
||||
#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 5, 0)
|
||||
const uint8_t mac[6] = {255, 255, 255, 255, 255, 255};
|
||||
const esp_now_send_info_t info{mac};
|
||||
ESPNowBridge::send_cb(&info, static_cast<esp_now_send_status_t>(status));
|
||||
#else
|
||||
ESPNowBridge::send_cb(nullptr, static_cast<esp_now_send_status_t>(status));
|
||||
#endif
|
||||
mesh::in_sdk_callback = false;
|
||||
(void)bridge;
|
||||
}
|
||||
|
||||
static void receiveProbes() {
|
||||
Backend backend;
|
||||
startBackend(backend);
|
||||
NodePrefs prefs;
|
||||
mesh::PacketManager mgr;
|
||||
mesh::RTCClock rtc;
|
||||
ESPNowBridge bridge(&prefs, &mgr, &rtc);
|
||||
uint8_t bytes[16];
|
||||
assert(diag::encodeProbe(bytes, sizeof(bytes), {0x12345678U, 0, 6}));
|
||||
mgr.exhausted = true;
|
||||
for (uint8_t format : {uint8_t(0), uint8_t(1)}) {
|
||||
prefs.bridge_format = format;
|
||||
bridge.begin();
|
||||
assert(bridge._initialized);
|
||||
const auto allocations = mgr.allocs;
|
||||
const auto received = bridge._stats.probe.rx_ok;
|
||||
deliver(bridge, bytes, sizeof(bytes));
|
||||
assert(bridge._stats.probe.rx_ok == received); // callback only copies
|
||||
bridge.loop();
|
||||
assert(bridge._stats.probe.rx_ok == received + 1);
|
||||
assert(bridge._stats.probe.last_rx_nonce == 0x12345678U);
|
||||
assert(bridge._rx_count == 0 && mgr.allocs == allocations);
|
||||
assert(mgr.received.empty() && bridge._seen_packets.ids.empty());
|
||||
assert(send_calls == 0 && sent.empty()); // no echo or LoRa admission
|
||||
bytes[15] ^= 1;
|
||||
deliver(bridge, bytes, sizeof(bytes));
|
||||
bridge.loop();
|
||||
bytes[15] ^= 1;
|
||||
assert(bridge._stats.probe.rx_bad == uint32_t(format + 1));
|
||||
assert(bridge._rx_count == 0 && mgr.allocs == allocations);
|
||||
bridge.end();
|
||||
}
|
||||
assert(bridge._stats.probe.rx_ok == 2 && bridge._stats.probe.rx_bad == 2);
|
||||
}
|
||||
|
||||
static void probeOneShot() {
|
||||
Backend backend;
|
||||
startBackend(backend);
|
||||
NodePrefs prefs;
|
||||
mesh::PacketManager mgr;
|
||||
mesh::RTCClock rtc;
|
||||
ESPNowBridge bridge(&prefs, &mgr, &rtc);
|
||||
assert(!bridge.sendTest(1) && send_calls == 0);
|
||||
bridge.begin();
|
||||
assert(bridge.sendTest(0x01020304U));
|
||||
assert(send_calls == 0 && mgr.allocs == 0);
|
||||
bridge.loop();
|
||||
assert(send_calls == 1 && sent.size() == 1);
|
||||
diag::Probe parsed;
|
||||
assert(diag::decodeProbe(sent[0].data(), sent[0].size(), parsed));
|
||||
assert(parsed.nonce == 0x01020304U && parsed.channel == 6 && parsed.format == 1);
|
||||
deliverCompletion(bridge, ESP_NOW_SEND_FAIL);
|
||||
bridge.loop();
|
||||
assert(bridge._tx_count == 0 && bridge._stats.probe.tx_fail == 1);
|
||||
for (unsigned i = 0; i < 4; ++i) { now_ms += 20; bridge.loop(); }
|
||||
assert(send_calls == 1); // callback failure never retries a probe
|
||||
|
||||
send_result = ESP_ERR_ESPNOW_NO_MEM;
|
||||
assert(bridge.sendTest(2));
|
||||
bridge.loop();
|
||||
assert(send_calls == 2 && bridge._tx_count == 0);
|
||||
assert(bridge._stats.probe.tx_fail == 2);
|
||||
for (unsigned i = 0; i < 4; ++i) { now_ms += 20; bridge.loop(); }
|
||||
assert(send_calls == 2); // ordinary data retry policy does not apply
|
||||
|
||||
send_result = ESP_OK;
|
||||
assert(bridge.sendTest(3));
|
||||
bridge.loop();
|
||||
assert(send_calls == 3 && bridge._tx_waiting);
|
||||
now_ms += 1000;
|
||||
bridge.loop();
|
||||
assert(bridge._initialized && bridge._tx_count == 0);
|
||||
assert(send_calls == 3 && bridge._stats.probe.tx_timeout == 1);
|
||||
assert(bridge._stats.tx.callback_timeout == 0); // probes have separate counters
|
||||
deliverCompletion(bridge, ESP_NOW_SEND_SUCCESS);
|
||||
bridge.loop();
|
||||
assert(send_calls == 3 && bridge._stats.probe.tx_ok == 0);
|
||||
assert(bridge._seen_packets.ids.empty() && mgr.allocs == 0);
|
||||
assert(bridge.sendTest(3)); // a new explicit command may reuse its nonce
|
||||
bridge.loop();
|
||||
deliverCompletion(bridge, ESP_NOW_SEND_SUCCESS);
|
||||
bridge.loop();
|
||||
assert(send_calls == 4 && bridge._stats.probe.tx_ok == 1);
|
||||
bridge.end();
|
||||
}
|
||||
|
||||
static void queueOwnership() {
|
||||
Backend backend;
|
||||
startBackend(backend);
|
||||
NodePrefs prefs;
|
||||
mesh::PacketManager mgr;
|
||||
mesh::RTCClock rtc;
|
||||
ESPNowBridge bridge(&prefs, &mgr, &rtc);
|
||||
bridge.begin();
|
||||
auto normal = packet(1);
|
||||
bridge.sendPacket(&normal);
|
||||
assert(bridge.sendTest(0xABCDEF01U));
|
||||
bridge.loop();
|
||||
assert(send_calls == 1 && sent[0][0] == normal.data[0]);
|
||||
bridge.loop();
|
||||
assert(send_calls == 1);
|
||||
deliverCompletion(bridge, ESP_NOW_SEND_SUCCESS);
|
||||
bridge.loop();
|
||||
assert(send_calls == 2 && diag::isProbeCandidate(sent[1].data(), sent[1].size()));
|
||||
deliverCompletion(bridge, ESP_NOW_SEND_SUCCESS);
|
||||
bridge.loop();
|
||||
assert(bridge._tx_count == 0 && bridge._stats.probe.tx_ok == 1);
|
||||
assert(bridge._seen_packets.ids == std::vector<uint8_t>{1});
|
||||
assert(mgr.allocs == 0 && mgr.received.empty());
|
||||
|
||||
auto zero = packet(0);
|
||||
bridge._seen_packets.markSeen(&zero);
|
||||
assert(bridge.sendTest(9));
|
||||
bridge.end();
|
||||
assert(bridge._seen_packets.wasSeen(&zero)); // no fake-packet dedup clear
|
||||
bridge.begin();
|
||||
for (uint8_t id = 10; id < 16; ++id) {
|
||||
auto p = packet(id);
|
||||
bridge.sendPacket(&p);
|
||||
}
|
||||
assert(bridge._tx_count == 6);
|
||||
const auto seen = bridge._seen_packets.ids;
|
||||
assert(!bridge.sendTest(10));
|
||||
assert(bridge._tx_count == 6 && bridge._seen_packets.ids == seen);
|
||||
bridge.end();
|
||||
}
|
||||
|
||||
static void admissionCounters() {
|
||||
Backend backend;
|
||||
startBackend(backend);
|
||||
NodePrefs prefs;
|
||||
mesh::PacketManager mgr;
|
||||
mesh::RTCClock rtc;
|
||||
ESPNowBridge bridge(&prefs, &mgr, &rtc);
|
||||
bridge.begin();
|
||||
auto good = packet(1), filtered = packet(2), invalid = packet(0xEE);
|
||||
deliver(bridge, good.data, good.length);
|
||||
bridge.loop();
|
||||
deliver(bridge, good.data, good.length);
|
||||
bridge.loop();
|
||||
bridge.allowed = false;
|
||||
deliver(bridge, filtered.data, filtered.length);
|
||||
bridge.loop();
|
||||
bridge.allowed = true;
|
||||
deliver(bridge, invalid.data, invalid.length);
|
||||
bridge.loop();
|
||||
assert(bridge._stats.rx.delivered == 1 && bridge._stats.rx.duplicate == 1);
|
||||
assert(bridge._stats.rx.filtered == 1 && bridge._stats.rx.packet_bad == 1);
|
||||
assert(bridge._stats.rx.packet_ok == 3);
|
||||
assert(mgr.received == std::vector<uint8_t>{1} && mgr.allocs == mgr.frees);
|
||||
bridge.resetStats();
|
||||
auto tx = packet(3), oversize = packet(4, 256);
|
||||
bridge.sendPacket(&tx);
|
||||
bridge.sendPacket(&tx);
|
||||
bridge.allowed = false;
|
||||
bridge.sendPacket(&filtered);
|
||||
bridge.allowed = true;
|
||||
bridge.sendPacket(&oversize);
|
||||
assert(bridge._stats.tx.requested == 4 && bridge._stats.tx.queued == 1);
|
||||
assert(bridge._stats.tx.duplicate == 1 && bridge._stats.tx.filtered == 1);
|
||||
assert(bridge._stats.tx.oversize == 1);
|
||||
bridge.loop();
|
||||
deliverCompletion(bridge, ESP_NOW_SEND_SUCCESS);
|
||||
bridge.loop();
|
||||
assert(bridge._stats.tx.start_ok == 1 && bridge._stats.tx.callback_ok == 1);
|
||||
bridge.end();
|
||||
}
|
||||
|
||||
static void overflowAndReset() {
|
||||
Backend backend;
|
||||
startBackend(backend);
|
||||
NodePrefs prefs;
|
||||
mesh::PacketManager mgr;
|
||||
mesh::RTCClock rtc;
|
||||
ESPNowBridge bridge(&prefs, &mgr, &rtc);
|
||||
bridge.begin();
|
||||
uint8_t probe[16];
|
||||
assert(diag::encodeProbe(probe, sizeof(probe), {7, 1, 6}));
|
||||
for (unsigned i = 0; i < 5; ++i) deliver(bridge, probe, sizeof(probe));
|
||||
assert(bridge._rx_count == 4 && bridge._stats.rx.queue_drop == 1);
|
||||
bridge.loop();
|
||||
assert(bridge._stats.probe.rx_ok == 4 && bridge._rx_count == 0);
|
||||
bridge.end();
|
||||
bridge.begin();
|
||||
assert(bridge._stats.probe.rx_ok == 4 && bridge._stats.rx.queue_drop == 1);
|
||||
assert(bridge.sendTest(8));
|
||||
bridge.loop();
|
||||
assert(bridge._tx_count == 1 && bridge._tx_waiting);
|
||||
const int writes = send_calls;
|
||||
bridge.resetStats();
|
||||
assert(bridge._initialized && bridge._tx_count == 1 && bridge._tx_waiting);
|
||||
assert(send_calls == writes && prefs.bridge_channel == 6 && prefs.bridge_format == 1);
|
||||
assert(bridge._stats.rx.frames == 0 && bridge._stats.probe.rx_ok == 0);
|
||||
deliverCompletion(bridge, ESP_NOW_SEND_SUCCESS);
|
||||
bridge.loop();
|
||||
assert(bridge._tx_count == 0 && bridge._stats.probe.tx_ok == 1);
|
||||
bridge.end();
|
||||
}
|
||||
|
||||
static void startupErrors() {
|
||||
Backend backend;
|
||||
startBackend(backend);
|
||||
NodePrefs prefs;
|
||||
mesh::PacketManager mgr;
|
||||
mesh::RTCClock rtc;
|
||||
ESPNowBridge bridge(&prefs, &mgr, &rtc);
|
||||
struct Expected { int failure; diag::Stage stage; };
|
||||
for (const auto& row : {
|
||||
Expected{2, diag::Stage::WiFiProtocol}, {4, diag::Stage::EspNowInit},
|
||||
{8, diag::Stage::RecvCallback}, {7, diag::Stage::SendCallback},
|
||||
{9, diag::Stage::PeerAdd}, {10, diag::Stage::PeerRate}}) {
|
||||
failure = row.failure;
|
||||
bridge.begin();
|
||||
assert(!bridge._initialized && bridge._stats.error.stage == row.stage);
|
||||
assert(bridge._stats.error.code == -1 && !espnow_active);
|
||||
}
|
||||
failure = 0;
|
||||
wifi_channel = 3;
|
||||
bridge.begin();
|
||||
assert(!bridge._initialized && bridge._stats.error.stage == diag::Stage::ChannelConflict);
|
||||
assert(sdk_started); // failed bridge setup cannot shut down shared WiFi
|
||||
wifi_channel = 6;
|
||||
bridge.begin();
|
||||
assert(bridge._initialized);
|
||||
bridge.end();
|
||||
}
|
||||
|
||||
static void boundedReplies() {
|
||||
Backend backend;
|
||||
startBackend(backend);
|
||||
NodePrefs prefs;
|
||||
mesh::PacketManager mgr;
|
||||
mesh::RTCClock rtc;
|
||||
ESPNowBridge bridge(&prefs, &mgr, &rtc);
|
||||
bridge.begin();
|
||||
memset(&bridge._stats.rx, 0xFF, sizeof(bridge._stats.rx));
|
||||
memset(&bridge._stats.tx, 0xFF, sizeof(bridge._stats.tx));
|
||||
memset(&bridge._stats.probe, 0xFF, sizeof(bridge._stats.probe));
|
||||
bridge._stats.error = {diag::Stage::ChannelConflict, INT32_MIN, UINT32_MAX};
|
||||
for (const char* page : {"rx", "tx", "drops", "test"}) {
|
||||
char reply[160];
|
||||
memset(reply, 0xA5, sizeof(reply));
|
||||
bridge.formatStats(page, reply, 157);
|
||||
assert(memchr(reply, 0, 157) != nullptr);
|
||||
assert(static_cast<uint8_t>(reply[157]) == 0xA5);
|
||||
assert(strlen(reply) < 157);
|
||||
printf("%s: %s\n", page, reply);
|
||||
}
|
||||
char status[160];
|
||||
memset(status, 0xA5, sizeof(status));
|
||||
bridge.formatStatus(status, 157);
|
||||
assert(memchr(status, 0, 157) != nullptr && strlen(status) < 157);
|
||||
assert(static_cast<uint8_t>(status[157]) == 0xA5);
|
||||
printf("status: %s\n", status);
|
||||
for (wifi_mode_t mode : {WIFI_AP, WIFI_OFF}) {
|
||||
sdk_mode = mode;
|
||||
bridge.formatStatus(status, 157);
|
||||
assert(strstr(status, "> driver-error ") == status);
|
||||
assert(strstr(status, "ch=6/6") != nullptr); // matching channel is insufficient
|
||||
}
|
||||
sdk_mode = WIFI_AP_STA;
|
||||
bridge.formatStatus(status, 157);
|
||||
assert(strstr(status, "> ready ") == status);
|
||||
sdk_mode = WIFI_STA;
|
||||
for (size_t capacity : {size_t(0), size_t(1), size_t(2), size_t(10)}) {
|
||||
char reply[160];
|
||||
memset(reply, 0xA5, sizeof(reply));
|
||||
bridge.formatStats("tx", reply, capacity);
|
||||
assert(static_cast<uint8_t>(reply[capacity]) == 0xA5);
|
||||
if (capacity) assert(memchr(reply, 0, capacity) != nullptr);
|
||||
}
|
||||
bridge.end();
|
||||
}
|
||||
|
||||
static void ownerOnlyLogging() {
|
||||
Backend backend;
|
||||
startBackend(backend);
|
||||
NodePrefs prefs;
|
||||
mesh::PacketManager mgr;
|
||||
mesh::RTCClock rtc;
|
||||
ESPNowBridge bridge(&prefs, &mgr, &rtc);
|
||||
bridge.begin();
|
||||
uint8_t probe[16];
|
||||
assert(diag::encodeProbe(probe, sizeof(probe), {1, 1, 6}));
|
||||
mesh::master_logging = true;
|
||||
mesh::verbose_logging = false;
|
||||
deliver(bridge, probe, sizeof(probe));
|
||||
bridge.loop();
|
||||
assert(mesh::debug_output.empty());
|
||||
mesh::master_logging = false;
|
||||
mesh::verbose_logging = true;
|
||||
deliver(bridge, probe, sizeof(probe));
|
||||
bridge.loop();
|
||||
assert(mesh::debug_output.empty());
|
||||
mesh::master_logging = mesh::verbose_logging = true;
|
||||
const auto before = mesh::debug_output.size();
|
||||
#if !MESH_ESP32_USB_CONSOLE_COOPERATIVE
|
||||
mesh::debug_port.capacity = 0;
|
||||
deliver(bridge, probe, sizeof(probe));
|
||||
now_ms += 2000;
|
||||
bridge.loop();
|
||||
assert(mesh::debug_output.size() == before); // full UART never blocks/writes
|
||||
mesh::debug_port.capacity = 1024;
|
||||
#endif
|
||||
deliver(bridge, probe, sizeof(probe));
|
||||
assert(mesh::debug_output.size() == before);
|
||||
now_ms += 2000;
|
||||
bridge.loop();
|
||||
assert(mesh::debug_output.size() > before);
|
||||
assert(bridge.sendTest(2));
|
||||
bridge.loop();
|
||||
const auto after_start = mesh::debug_output.size();
|
||||
deliverCompletion(bridge, ESP_NOW_SEND_SUCCESS);
|
||||
assert(mesh::debug_output.size() == after_start);
|
||||
now_ms += 2000;
|
||||
bridge.loop();
|
||||
assert(mesh::debug_output.size() > after_start);
|
||||
bridge.end();
|
||||
}
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
assert(argc == 2);
|
||||
if (!strcmp(argv[1], "rx-probes")) receiveProbes();
|
||||
else if (!strcmp(argv[1], "one-shot")) probeOneShot();
|
||||
else if (!strcmp(argv[1], "ownership")) queueOwnership();
|
||||
else if (!strcmp(argv[1], "admission")) admissionCounters();
|
||||
else if (!strcmp(argv[1], "overflow-reset")) overflowAndReset();
|
||||
else if (!strcmp(argv[1], "startup")) startupErrors();
|
||||
else if (!strcmp(argv[1], "replies")) boundedReplies();
|
||||
else if (!strcmp(argv[1], "logging")) ownerOnlyLogging();
|
||||
else assert(false);
|
||||
}
|
||||
+242
@@ -0,0 +1,242 @@
|
||||
#include <helpers/bridges/ESPNowBridgeDiagnostics.h>
|
||||
#include <Packet.h>
|
||||
|
||||
#include <cassert>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <initializer_list>
|
||||
#include <type_traits>
|
||||
|
||||
namespace diag = mesh::bridge::diag;
|
||||
|
||||
static diag::Probe sentinel() {
|
||||
return {0x76543210U, 0, 6};
|
||||
}
|
||||
|
||||
static void unchanged(const diag::Probe& value) {
|
||||
assert(value.nonce == 0x76543210U && value.format == 0 && value.channel == 6);
|
||||
}
|
||||
|
||||
static void makeProbe(uint8_t* bytes) {
|
||||
assert(diag::encodeProbe(bytes, diag::ProbeSize, {0x01234567U, 1, 13}));
|
||||
}
|
||||
|
||||
static void checksum(uint8_t* bytes) {
|
||||
mesh::espnow::writeEspNowRawUint32(
|
||||
bytes + 12, mesh::espnow::espNowRawCrc32(bytes, 12));
|
||||
}
|
||||
|
||||
static void roundtrip() {
|
||||
const uint32_t nonces[] = {0, 1, 0x80000000U, UINT32_MAX, 0x01234567U};
|
||||
for (uint8_t format = 0; format <= 1; ++format) {
|
||||
for (uint8_t channel = 1; channel <= 13; ++channel) {
|
||||
for (uint32_t nonce : nonces) {
|
||||
uint8_t bytes[18];
|
||||
memset(bytes, 0xA5, sizeof(bytes));
|
||||
assert(diag::encodeProbe(bytes + 1, 16, {nonce, format, channel}));
|
||||
assert(bytes[0] == 0xA5 && bytes[17] == 0xA5);
|
||||
diag::Probe parsed = sentinel();
|
||||
assert(diag::isProbeCandidate(bytes + 1, 16));
|
||||
assert(diag::decodeProbe(bytes + 1, 16, parsed));
|
||||
assert(parsed.nonce == nonce && parsed.format == format
|
||||
&& parsed.channel == channel);
|
||||
}
|
||||
}
|
||||
}
|
||||
uint8_t bytes[diag::ProbeSize];
|
||||
makeProbe(bytes);
|
||||
for (uint8_t byte : bytes) printf("%02X", byte);
|
||||
puts("");
|
||||
}
|
||||
|
||||
static void bounds() {
|
||||
uint8_t bytes[250];
|
||||
memset(bytes, 0xA5, sizeof(bytes));
|
||||
makeProbe(bytes);
|
||||
for (size_t length = 0; length <= sizeof(bytes); ++length) {
|
||||
if (length == diag::ProbeSize) continue;
|
||||
diag::Probe parsed = sentinel();
|
||||
assert(!diag::decodeProbe(bytes, length, parsed));
|
||||
unchanged(parsed);
|
||||
}
|
||||
diag::Probe parsed = sentinel();
|
||||
assert(!diag::decodeProbe(nullptr, diag::ProbeSize, parsed));
|
||||
unchanged(parsed);
|
||||
assert(!diag::isProbeCandidate(nullptr, diag::ProbeSize));
|
||||
for (size_t length = 0; length < diag::ProbeSize; ++length) {
|
||||
memset(bytes, 0xA5, sizeof(bytes));
|
||||
assert(!diag::encodeProbe(bytes, length, {1, 1, 1}));
|
||||
for (uint8_t byte : bytes) assert(byte == 0xA5);
|
||||
}
|
||||
assert(!diag::encodeProbe(nullptr, diag::ProbeSize, {1, 1, 1}));
|
||||
}
|
||||
|
||||
static void metadata() {
|
||||
const uint8_t invalid_formats[] = {2, 127, 255};
|
||||
const uint8_t invalid_channels[] = {0, 14, 127, 255};
|
||||
for (uint8_t format : invalid_formats) {
|
||||
uint8_t bytes[16];
|
||||
memset(bytes, 0xA5, sizeof(bytes));
|
||||
assert(!diag::encodeProbe(bytes, sizeof(bytes), {0, format, 6}));
|
||||
for (uint8_t byte : bytes) assert(byte == 0xA5);
|
||||
makeProbe(bytes);
|
||||
bytes[6] = format;
|
||||
checksum(bytes);
|
||||
diag::Probe parsed = sentinel();
|
||||
assert(!diag::decodeProbe(bytes, sizeof(bytes), parsed));
|
||||
unchanged(parsed);
|
||||
}
|
||||
for (uint8_t channel : invalid_channels) {
|
||||
uint8_t bytes[16];
|
||||
memset(bytes, 0xA5, sizeof(bytes));
|
||||
assert(!diag::encodeProbe(bytes, sizeof(bytes), {0, 0, channel}));
|
||||
for (uint8_t byte : bytes) assert(byte == 0xA5);
|
||||
makeProbe(bytes);
|
||||
bytes[7] = channel;
|
||||
checksum(bytes);
|
||||
diag::Probe parsed = sentinel();
|
||||
assert(!diag::decodeProbe(bytes, sizeof(bytes), parsed));
|
||||
unchanged(parsed);
|
||||
}
|
||||
for (size_t field : {size_t(4), size_t(5)}) {
|
||||
for (uint8_t value : {uint8_t(0), uint8_t(2), uint8_t(255)}) {
|
||||
uint8_t bytes[16];
|
||||
makeProbe(bytes);
|
||||
bytes[field] = value;
|
||||
checksum(bytes);
|
||||
diag::Probe parsed = sentinel();
|
||||
assert(diag::isProbeCandidate(bytes, sizeof(bytes)));
|
||||
assert(!diag::decodeProbe(bytes, sizeof(bytes), parsed));
|
||||
unchanged(parsed);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void corruption() {
|
||||
uint8_t original[16];
|
||||
makeProbe(original);
|
||||
for (size_t byte = 0; byte < sizeof(original); ++byte) {
|
||||
for (uint8_t bit = 0; bit < 8; ++bit) {
|
||||
uint8_t bytes[16];
|
||||
memcpy(bytes, original, sizeof(bytes));
|
||||
bytes[byte] ^= uint8_t(1U << bit);
|
||||
diag::Probe parsed = sentinel();
|
||||
assert(!diag::decodeProbe(bytes, sizeof(bytes), parsed));
|
||||
unchanged(parsed);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void candidate() {
|
||||
uint8_t bytes[250];
|
||||
memset(bytes, 0, sizeof(bytes));
|
||||
makeProbe(bytes);
|
||||
for (size_t length = 0; length < 4; ++length) {
|
||||
assert(!diag::isProbeCandidate(bytes, length));
|
||||
}
|
||||
for (size_t length = 4; length <= sizeof(bytes); ++length) {
|
||||
assert(diag::isProbeCandidate(bytes, length));
|
||||
}
|
||||
bytes[3] = 'F';
|
||||
assert(!diag::isProbeCandidate(bytes, 16));
|
||||
assert(memcmp(bytes, mesh::espnow::ESPNOW_RAW_FRAGMENT_MAGIC, 4) == 0);
|
||||
}
|
||||
|
||||
static void nonce() {
|
||||
struct Valid { const char* text; uint32_t expected; };
|
||||
for (const Valid& valid : {Valid{"00000000", 0}, Valid{"00000001", 1},
|
||||
Valid{"ffffffff", UINT32_MAX}, Valid{"ABCDef01", 0xABCDEF01U},
|
||||
Valid{"01234567", 0x01234567U}}) {
|
||||
uint32_t value = 7;
|
||||
assert(diag::parseNonce(valid.text, value) && value == valid.expected);
|
||||
}
|
||||
const char* invalid[] = {nullptr, "", "0", "1234567", "123456789",
|
||||
"0x123456", " 1234567", "1234567 ", "+1234567", "-1234567",
|
||||
"1234567g", "12345678x", "12345678\n", "1234 678", "\t1234567"};
|
||||
for (const char* text : invalid) {
|
||||
uint32_t value = 0x89ABCDEFU;
|
||||
assert(!diag::parseNonce(text, value) && value == 0x89ABCDEFU);
|
||||
}
|
||||
}
|
||||
|
||||
static void legacy() {
|
||||
// These are actual production Packet and raw reassembler implementations.
|
||||
uint8_t probe[16];
|
||||
makeProbe(probe);
|
||||
mesh::Packet parsed;
|
||||
assert(!parsed.readFrom(probe, sizeof(probe)));
|
||||
assert((probe[0] >> PH_VER_SHIFT) > PAYLOAD_VER_1);
|
||||
assert((uint16_t(probe[0]) << 8 | probe[1]) != WRAPPED_BRIDGE_MAGIC);
|
||||
mesh::espnow::ESPNowRawReassemblerT<1> raw;
|
||||
uint8_t output[255];
|
||||
uint8_t source[] = {1, 2, 3, 4, 5, 6};
|
||||
size_t output_len = 999;
|
||||
assert(raw.acceptFrame(source, probe, sizeof(probe), 0, output,
|
||||
sizeof(output), output_len)
|
||||
== mesh::espnow::ESPNowRawReassemblyResult::REJECTED);
|
||||
assert(output_len == 0);
|
||||
|
||||
// Rejecting a probe must not disturb a real in-progress raw packet.
|
||||
mesh::Packet packet;
|
||||
packet.header = (PAYLOAD_TYPE_RAW_CUSTOM << PH_TYPE_SHIFT)
|
||||
| ROUTE_TYPE_TRANSPORT_DIRECT;
|
||||
packet.setPathHashSizeAndCount(2, 32);
|
||||
packet.payload_len = MAX_PACKET_PAYLOAD;
|
||||
memset(packet.path, 0x23, sizeof(packet.path));
|
||||
memset(packet.payload, 0x42, sizeof(packet.payload));
|
||||
uint8_t wire[255];
|
||||
const size_t wire_len = packet.writeTo(wire);
|
||||
assert(wire_len == 254);
|
||||
mesh::espnow::ESPNowRawFrames frames;
|
||||
assert(mesh::espnow::encodeEspNowRawFrames(wire, wire_len, frames));
|
||||
assert(frames.count == 2);
|
||||
assert(raw.acceptFrame(source, frames.data[0], frames.lengths[0], 1,
|
||||
output, sizeof(output), output_len)
|
||||
== mesh::espnow::ESPNowRawReassemblyResult::FRAGMENT_STORED);
|
||||
assert(raw.acceptFrame(source, probe, sizeof(probe), 2,
|
||||
output, sizeof(output), output_len)
|
||||
== mesh::espnow::ESPNowRawReassemblyResult::REJECTED);
|
||||
assert(!diag::isProbeCandidate(frames.data[1], frames.lengths[1]));
|
||||
assert(raw.acceptFrame(source, frames.data[1], frames.lengths[1], 3,
|
||||
output, sizeof(output), output_len)
|
||||
== mesh::espnow::ESPNowRawReassemblyResult::PACKET_COMPLETE);
|
||||
assert(output_len == wire_len && memcmp(output, wire, wire_len) == 0);
|
||||
assert(parsed.readFrom(output, static_cast<uint8_t>(output_len)));
|
||||
}
|
||||
|
||||
static void counters() {
|
||||
static_assert(std::is_trivially_copyable<diag::Stats>::value,
|
||||
"Snapshots must copy without heap ownership");
|
||||
static_assert(sizeof(diag::Stats) <= 160, "Counter storage is bounded");
|
||||
diag::Stats stats;
|
||||
assert(stats.rx.frames == 0 && stats.tx.requested == 0
|
||||
&& stats.probe.rx_ok == 0 && stats.error.stage == diag::Stage::None);
|
||||
uint32_t count = UINT32_MAX - 1;
|
||||
diag::increment(count);
|
||||
assert(count == UINT32_MAX);
|
||||
diag::increment(count);
|
||||
assert(count == UINT32_MAX);
|
||||
count = 0;
|
||||
diag::increment(count);
|
||||
assert(count == 1);
|
||||
for (uint8_t stage = 0; stage <= static_cast<uint8_t>(diag::Stage::TestQueue);
|
||||
++stage) {
|
||||
assert(strcmp(diag::stageName(static_cast<diag::Stage>(stage)), "unknown") != 0);
|
||||
}
|
||||
assert(strcmp(diag::stageName(static_cast<diag::Stage>(255)), "unknown") == 0);
|
||||
printf("counter_bytes=%zu\n", sizeof(stats));
|
||||
}
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
assert(argc == 2);
|
||||
if (!strcmp(argv[1], "roundtrip")) roundtrip();
|
||||
else if (!strcmp(argv[1], "bounds")) bounds();
|
||||
else if (!strcmp(argv[1], "metadata")) metadata();
|
||||
else if (!strcmp(argv[1], "corruption")) corruption();
|
||||
else if (!strcmp(argv[1], "candidate")) candidate();
|
||||
else if (!strcmp(argv[1], "nonce")) nonce();
|
||||
else if (!strcmp(argv[1], "legacy")) legacy();
|
||||
else if (!strcmp(argv[1], "counters")) counters();
|
||||
else assert(false);
|
||||
return 0;
|
||||
}
|
||||
+6
-1
@@ -7,6 +7,7 @@
|
||||
#include <helpers/WirelessControl.h>
|
||||
#include <helpers/ESPNowRawFragmentation.h>
|
||||
#include <helpers/bridges/ESPNowBridgeFormat.h>
|
||||
#include <helpers/bridges/ESPNowBridgeDiagnostics.h>
|
||||
|
||||
#define ESP_IDF_VERSION_VAL(a,b,c) ((a)*10000+(b)*100+(c))
|
||||
#define BRIDGE_DEBUG_PRINTLN(...) ((void)0)
|
||||
@@ -156,6 +157,10 @@ struct Backend : mesh::wireless::Backend {
|
||||
};
|
||||
class Bridge {
|
||||
public:
|
||||
static constexpr int ESP_ERR_INVALID_STATE=-78,ESP_ERR_INVALID_ARG=-79;
|
||||
std::atomic<bool> _debug_dirty{false};
|
||||
void recordError(mesh::bridge::diag::Stage, int32_t) {}
|
||||
void emitDebug() {}
|
||||
struct Prefs { int bridge_format=mesh::bridge::ESPNOW_FORMAT_RAW; uint8_t bridge_channel=6; } prefs;
|
||||
Prefs* _prefs=&prefs;
|
||||
bool _initialized=false;
|
||||
@@ -163,7 +168,7 @@ public:
|
||||
int _tx_mux=0, _tx_head=0, _tx_tail=0, _tx_count=0, _tx_waiting=0, _tx_callback_done=0;
|
||||
int _tx_callback_status=0, _tx_dropped=0, _tx_dropped_reported=0;
|
||||
mesh::espnow::ESPNowRawReassembler _raw_reassembler;
|
||||
struct QueuedTransmit { bool started=false; int packet=0; };
|
||||
struct QueuedTransmit { bool started=false, diagnostic=false; int packet=0; };
|
||||
static constexpr int TX_QUEUE_DEPTH=2;
|
||||
QueuedTransmit _tx_queue[TX_QUEUE_DEPTH];
|
||||
struct { void clear(const int*) {} } _seen_packets;
|
||||
|
||||
@@ -15,7 +15,10 @@ MOCKS = r'''
|
||||
#include <algorithm>
|
||||
#include <array>
|
||||
#include <cstdio>
|
||||
#include <cstdarg>
|
||||
#include <string>
|
||||
#include <helpers/bridges/RS232Heartbeat.h>
|
||||
#include <helpers/bridges/ESPNowBridgeDiagnostics.h>
|
||||
#define MAX_TRANS_UNIT 255
|
||||
#define PAYLOAD_TYPE_OTA 0x0c
|
||||
using portMUX_TYPE=int;
|
||||
@@ -23,6 +26,11 @@ using portMUX_TYPE=int;
|
||||
struct esp_now_recv_info_t {const uint8_t* src_addr;};
|
||||
struct esp_now_send_info_t {const uint8_t* des_addr;};
|
||||
constexpr int ESP_ERR_ESPNOW_NO_MEM=-77;
|
||||
constexpr int ESP_ERR_INVALID_STATE=-78,ESP_ERR_INVALID_ARG=-79;
|
||||
constexpr int ESP_ERR_TIMEOUT=-80;
|
||||
enum wifi_ps_type_t {WIFI_PS_NONE=0,WIFI_PS_MIN_MODEM=1};
|
||||
int esp_wifi_get_ps(wifi_ps_type_t* value){*value=WIFI_PS_NONE;return sdk_initialized?ESP_OK:-1;}
|
||||
int esp_wifi_get_protocol(int,uint8_t* value){*value=15;return sdk_initialized?ESP_OK:-1;}
|
||||
uint32_t now_ms=100;
|
||||
uint32_t millis(){return now_ms;}
|
||||
int send_result=0,send_calls=0;
|
||||
@@ -33,6 +41,23 @@ int esp_now_send(const uint8_t*,const uint8_t* bytes,size_t len){
|
||||
sent.emplace_back(bytes,bytes+len);return ESP_OK;
|
||||
}
|
||||
namespace mesh {
|
||||
bool master_logging=false,verbose_logging=false,in_sdk_callback=false;
|
||||
std::vector<std::string> debug_output;
|
||||
bool isUsbDebugLoggingEnabled(){return master_logging&&verbose_logging;}
|
||||
struct DebugPort {
|
||||
int capacity=1024;
|
||||
int availableForWrite()const{return capacity;}
|
||||
size_t write(const uint8_t* bytes,size_t length){
|
||||
assert(!in_sdk_callback&&length<=static_cast<size_t>(capacity));
|
||||
debug_output.emplace_back(reinterpret_cast<const char*>(bytes),length);return length;
|
||||
}
|
||||
} debug_port;
|
||||
DebugPort& usbLoggingPort(){return debug_port;}
|
||||
size_t nrf52DebugPrintf(const char* format,...){
|
||||
assert(!in_sdk_callback);char output[256];va_list args;va_start(args,format);
|
||||
const int count=vsnprintf(output,sizeof(output),format,args);va_end(args);
|
||||
if(count>0)debug_output.emplace_back(output);return count>0?static_cast<size_t>(count):0;
|
||||
}
|
||||
struct RTCClock {};
|
||||
struct Packet {
|
||||
uint8_t data[MAX_TRANS_UNIT]={};uint16_t length=4;
|
||||
@@ -61,6 +86,7 @@ struct PacketManager {
|
||||
struct NodePrefs {
|
||||
int bridge_format=mesh::bridge::ESPNOW_FORMAT_RAW;
|
||||
uint8_t bridge_channel=6;uint32_t bridge_baud=115200,bridge_delay=1;
|
||||
uint8_t bridge_pkt_src=0;
|
||||
char bridge_secret[32]="fleet-test";
|
||||
};
|
||||
struct Seen {
|
||||
@@ -71,6 +97,7 @@ struct Seen {
|
||||
};
|
||||
class BridgeBase {
|
||||
public:
|
||||
@INGRESS_HOOK@
|
||||
static constexpr uint16_t BRIDGE_PACKET_MAGIC=0xc03e;
|
||||
static constexpr uint16_t BRIDGE_MAGIC_SIZE=2,BRIDGE_LENGTH_SIZE=2,BRIDGE_CHECKSUM_SIZE=2;
|
||||
NodePrefs* _prefs;mesh::PacketManager* _mgr;mesh::RTCClock* _rtc;
|
||||
@@ -110,6 +137,10 @@ def code():
|
||||
sdk = sdk.replace("int esp_now_deinit() { assert(espnow_active); espnow_active=false; return ESP_OK; }",
|
||||
"int esp_now_deinit() { assert(espnow_active); if(failure==18)return -1; espnow_active=false; return ESP_OK; }")
|
||||
base = (ROOT / "src/helpers/bridges/BridgeBase.cpp").read_text()
|
||||
base_header = (ROOT / "src/helpers/bridges/BridgeBase.h").read_text()
|
||||
ingress_hook = "#if defined(WITH_ESPNOW_BRIDGE)\n"
|
||||
ingress_hook += method(base_header, "enum class IngressResult") + ";\n"
|
||||
ingress_hook += method(base_header, "virtual void onIngressResult(") + "\n#endif\n"
|
||||
base_methods = "\n".join(method(base, signature) for signature in (
|
||||
"uint16_t BridgeBase::fletcher16(", "bool BridgeBase::validateChecksum(",
|
||||
"void BridgeBase::handleReceivedPacket("))
|
||||
@@ -119,7 +150,7 @@ def code():
|
||||
source = (ROOT / f"src/helpers/bridges/{name}.cpp").read_text()
|
||||
headers.append(re.sub(r"^\s*#(?:include|pragma).*?$", "", header, flags=re.MULTILINE).replace("private:", "public:"))
|
||||
sources.append(re.sub(r"^\s*#include.*?$", "", source, flags=re.MULTILINE))
|
||||
return sdk + MOCKS + "\n".join(headers) + base_methods + "\n".join(sources)
|
||||
return sdk + MOCKS.replace("@INGRESS_HOOK@", ingress_hook) + "\n".join(headers) + base_methods + "\n".join(sources)
|
||||
|
||||
|
||||
COMMON = r'''
|
||||
|
||||
@@ -0,0 +1,182 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Exercise bounded ESP-NOW diagnostics and actual legacy wire rejection."""
|
||||
|
||||
from pathlib import Path
|
||||
import os
|
||||
import re
|
||||
import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import unittest
|
||||
import zlib
|
||||
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
|
||||
|
||||
class ESPNowBridgeDiagnosticsTests(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.compiler = os.environ.get("CXX") or shutil.which("g++") or shutil.which("clang++")
|
||||
if not cls.compiler:
|
||||
raise RuntimeError("A host C++17 compiler is required")
|
||||
cls.temporary = tempfile.TemporaryDirectory(prefix="espnow-diagnostics-")
|
||||
cls.addClassCleanup(cls.temporary.cleanup)
|
||||
cls.work = Path(cls.temporary.name)
|
||||
cls.binary = cls.work / "diagnostics"
|
||||
base = (ROOT / "src/helpers/bridges/BridgeBase.h").read_text(encoding="ascii")
|
||||
magic = re.findall(r"BRIDGE_PACKET_MAGIC\s*=\s*(0x[0-9A-Fa-f]+)\s*;", base)
|
||||
if len(magic) != 1:
|
||||
raise AssertionError("Expected one production wrapped bridge magic")
|
||||
flags = (["-fsanitize=address,undefined", "-fno-sanitize-recover=all",
|
||||
"-fno-pie", "-no-pie"] if sys.platform.startswith("linux") else [])
|
||||
built = subprocess.run([
|
||||
cls.compiler, "-std=c++17", "-Wall", "-Wextra", "-Werror",
|
||||
"-Wno-unused-parameter", *flags,
|
||||
"-DWRAPPED_BRIDGE_MAGIC=" + magic[0],
|
||||
"-I" + str(ROOT / "src"), "-I" + str(ROOT / "test/mocks"),
|
||||
str(ROOT / "test/fixtures/espnow_bridge_diagnostics.cpp"),
|
||||
str(ROOT / "src/Packet.cpp"), "-o", str(cls.binary),
|
||||
], capture_output=True, text=True, timeout=60)
|
||||
if built.returncode:
|
||||
raise AssertionError(built.stdout + built.stderr)
|
||||
|
||||
def run_case(self, scenario):
|
||||
result = subprocess.run([str(self.binary), scenario], capture_output=True,
|
||||
text=True, timeout=10)
|
||||
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
|
||||
return result.stdout
|
||||
|
||||
def test_roundtrip_and_independent_wire_crc(self):
|
||||
wire = bytes.fromhex(self.run_case("roundtrip").strip())
|
||||
self.assertEqual(wire[:12], bytes.fromhex("FE4D43440101010D01234567"))
|
||||
self.assertEqual(int.from_bytes(wire[12:], "big"), zlib.crc32(wire[:12]))
|
||||
|
||||
def test_null_short_and_oversize_inputs_preserve_outputs(self):
|
||||
self.run_case("bounds")
|
||||
|
||||
def test_semantics_reject_invalid_metadata_with_valid_crc(self):
|
||||
self.run_case("metadata")
|
||||
|
||||
def test_every_single_bit_corruption_is_rejected(self):
|
||||
self.run_case("corruption")
|
||||
|
||||
def test_candidates_include_malformed_but_exclude_raw_fragments(self):
|
||||
self.run_case("candidate")
|
||||
|
||||
def test_nonce_is_exactly_eight_hex_digits(self):
|
||||
self.run_case("nonce")
|
||||
|
||||
def test_actual_legacy_packet_and_reassembler_reject_probe(self):
|
||||
self.run_case("legacy")
|
||||
|
||||
def test_fixed_counters_saturate_and_unknown_error_is_safe(self):
|
||||
self.assertIn("counter_bytes=132", self.run_case("counters"))
|
||||
|
||||
def test_helper_has_no_allocator_sdk_clock_or_output_dependencies(self):
|
||||
source = self.work / "pure.cpp"
|
||||
binary = self.work / "pure.o"
|
||||
source.write_text('''#include <helpers/bridges/ESPNowBridgeDiagnostics.h>
|
||||
namespace diag = mesh::bridge::diag;
|
||||
bool encode(uint8_t* out, size_t len, const diag::Probe& probe) {
|
||||
return diag::encodeProbe(out, len, probe);
|
||||
}
|
||||
bool decode(const uint8_t* bytes, size_t len, diag::Probe& probe) {
|
||||
return diag::decodeProbe(bytes, len, probe);
|
||||
}
|
||||
bool nonce(const char* text, uint32_t& value) {
|
||||
return diag::parseNonce(text, value);
|
||||
}
|
||||
''', encoding="ascii")
|
||||
result = subprocess.run([self.compiler, "-std=c++17", "-O2", "-c",
|
||||
"-I" + str(ROOT / "src"), str(source), "-o", str(binary)],
|
||||
capture_output=True, text=True, timeout=30)
|
||||
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
|
||||
nm = shutil.which("nm")
|
||||
self.assertIsNotNone(nm, "nm is required for dependency inspection")
|
||||
symbols = subprocess.run([nm, "-u", str(binary)], capture_output=True,
|
||||
text=True, timeout=10, check=True).stdout
|
||||
self.assertNotRegex(symbols, r"(?i)malloc|calloc|realloc|free|_Zn[aw]|esp_|Serial|printf|millis|micros|atomic|mutex")
|
||||
|
||||
|
||||
class ESPNowBridgeProductionDiagnosticsTests(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
from test_bridge_recovery import code, COMMON
|
||||
cls.compiler = os.environ.get("CXX") or shutil.which("g++") or shutil.which("clang++")
|
||||
if not cls.compiler:
|
||||
raise RuntimeError("A host C++17 compiler is required")
|
||||
cls.temporary = tempfile.TemporaryDirectory(prefix="espnow-production-diagnostics-")
|
||||
cls.addClassCleanup(cls.temporary.cleanup)
|
||||
cls.work = Path(cls.temporary.name)
|
||||
cls.source = cls.work / "production.cpp"
|
||||
fixture = (ROOT / "test/fixtures/espnow_bridge_diagnostic_runtime.cpp").read_text(encoding="ascii")
|
||||
cls.source.write_text(code() + COMMON + fixture, encoding="ascii")
|
||||
cls.binary = cls.build(50200)
|
||||
|
||||
@classmethod
|
||||
def build(cls, version, cooperative=1):
|
||||
binary = cls.work / ("production-" + str(version) + "-usb-" + str(cooperative))
|
||||
result = subprocess.run([
|
||||
cls.compiler, "-std=c++17", "-O1", "-Wall", "-Wextra",
|
||||
"-fsanitize=address,undefined", "-fno-sanitize-recover=all",
|
||||
"-fno-omit-frame-pointer", "-fno-pie", "-no-pie",
|
||||
"-DESP32=1", "-DARDUINO=1",
|
||||
"-DMESH_ESP32_USB_CONSOLE_COOPERATIVE=" + str(cooperative),
|
||||
"-DWITH_ESPNOW_BRIDGE=1", "-DWITH_RS232_BRIDGE=1",
|
||||
"-DESP_IDF_VERSION=" + str(version),
|
||||
"-DESP_IDF_VERSION_MAJOR=" + str(version // 10000),
|
||||
"-I" + str(ROOT / "src"), str(cls.source), "-o", str(binary),
|
||||
], capture_output=True, text=True, timeout=60)
|
||||
if result.returncode:
|
||||
raise AssertionError(result.stdout + result.stderr)
|
||||
return binary
|
||||
|
||||
def run_case(self, scenario, binary=None):
|
||||
result = subprocess.run([str(binary or self.binary), scenario],
|
||||
capture_output=True, text=True, timeout=10)
|
||||
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
|
||||
return result.stdout
|
||||
|
||||
def test_receive_probes_never_allocate_echo_or_admit_mesh_in_either_format(self):
|
||||
self.run_case("rx-probes")
|
||||
|
||||
def test_probe_sdk_rejection_callback_failure_and_timeout_never_retry(self):
|
||||
self.run_case("one-shot")
|
||||
|
||||
def test_probe_and_mesh_queue_order_and_seen_ownership(self):
|
||||
self.run_case("ownership")
|
||||
|
||||
def test_existing_admission_decisions_drive_exact_counters(self):
|
||||
self.run_case("admission")
|
||||
|
||||
def test_queue_overflow_restart_persistence_and_reset_preserve_accepted_work(self):
|
||||
self.run_case("overflow-reset")
|
||||
|
||||
def test_startup_error_stage_and_code_preserve_shared_wifi(self):
|
||||
self.run_case("startup")
|
||||
|
||||
def test_saturated_pages_and_status_fit_reserved_reply_capacity(self):
|
||||
reply = self.run_case("replies")
|
||||
for suffix in ("parse=4294967295", "timeout=4294967295",
|
||||
"big=4294967295", "rxid=FFFFFFFF",
|
||||
"last=channel.conflict/-2147483648"):
|
||||
self.assertIn(suffix, reply)
|
||||
|
||||
def test_callbacks_never_print_and_loop_logging_requires_both_gates(self):
|
||||
self.run_case("logging")
|
||||
|
||||
def test_uart_logging_has_the_same_owner_gates_and_drops_without_capacity(self):
|
||||
self.run_case("logging", self.build(50200, cooperative=0))
|
||||
|
||||
def test_diagnostic_callbacks_support_each_sdk_signature(self):
|
||||
for version in (40400, 50500):
|
||||
with self.subTest(idf=version):
|
||||
binary = self.build(version)
|
||||
self.run_case("rx-probes", binary)
|
||||
self.run_case("one-shot", binary)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,240 @@
|
||||
"""Compile actual ESP-NOW diagnostic dispatch/forwarders with native fakes."""
|
||||
from pathlib import Path
|
||||
import re
|
||||
import shutil
|
||||
import subprocess
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
from test_replay_reset_integration import extract_braced
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
|
||||
|
||||
class EspNowDiagnosticCliTests(unittest.TestCase):
|
||||
def compile_run(self, source, flags=()):
|
||||
compiler = shutil.which("g++") or shutil.which("clang++")
|
||||
self.assertIsNotNone(compiler)
|
||||
with tempfile.TemporaryDirectory(prefix="espnow-cli-") as directory:
|
||||
source_path = Path(directory) / "main.cpp"
|
||||
binary = Path(directory) / "check"
|
||||
source_path.write_text(source, encoding="ascii")
|
||||
subprocess.run([compiler, "-std=c++17", "-Wall", "-Wextra", "-Werror",
|
||||
"-fsanitize=address,undefined", "-fno-omit-frame-pointer",
|
||||
"-I", str(ROOT / "src"), *flags, str(source_path),
|
||||
"-o", str(binary)], check=True, capture_output=True, text=True)
|
||||
subprocess.run([str(binary)], check=True, capture_output=True, text=True)
|
||||
|
||||
def test_actual_dispatch_strict_local_actions_and_bounded_replies(self):
|
||||
source = (ROOT / "src/helpers/CommonCLI.cpp").read_text(encoding="ascii")
|
||||
header = (ROOT / "src/helpers/CommonCLI.h").read_text(encoding="ascii")
|
||||
body = extract_braced(source, "bool CommonCLI::handleEspNowDiagnosticCommand(")
|
||||
defaults = "\n".join(extract_braced(header, signature) for signature in (
|
||||
"virtual void formatEspNowStatus(", "virtual void formatEspNowStats(",
|
||||
"virtual bool sendEspNowTest(", "virtual bool resetEspNowStats("))
|
||||
self.assertIn("if (handleEspNowDiagnosticCommand(sender_timestamp, command, reply)) return;", source)
|
||||
self.compile_run(r'''
|
||||
#include <cassert>
|
||||
#include <cstdint>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
#include <helpers/bridges/ESPNowBridgeDiagnostics.h>
|
||||
static uint32_t now_ms = 0x1234ABCD;
|
||||
uint32_t millis() { return now_ms; }
|
||||
struct Callbacks {
|
||||
virtual ~Callbacks() = default;
|
||||
''' + defaults + r'''
|
||||
};
|
||||
struct Fake : Callbacks {
|
||||
int statuses = 0, stats = 0, sends = 0, resets = 0;
|
||||
uint32_t nonce = 0;
|
||||
size_t capacity = 0;
|
||||
std::string page;
|
||||
bool send_result = true, reset_result = true, long_reply = false;
|
||||
void fill(char* reply, size_t cap, const char* value) {
|
||||
capacity = cap;
|
||||
const std::string text = long_reply ? std::string(300, 'x') : value;
|
||||
snprintf(reply, cap, "%s", text.c_str());
|
||||
}
|
||||
void formatEspNowStatus(char* r, size_t cap) override {
|
||||
++statuses; fill(r, cap, "status");
|
||||
}
|
||||
void formatEspNowStats(const char* p, char* r, size_t cap) override {
|
||||
++stats; page = p; fill(r, cap, "stats");
|
||||
}
|
||||
bool sendEspNowTest(uint32_t n) override {
|
||||
++sends; nonce = n; return send_result;
|
||||
}
|
||||
bool resetEspNowStats() override { ++resets; return reset_result; }
|
||||
int count() const { return statuses + stats + sends + resets; }
|
||||
};
|
||||
struct CommonCLI {
|
||||
Callbacks* _callbacks;
|
||||
bool handleEspNowDiagnosticCommand(uint32_t, const char*, char*);
|
||||
};
|
||||
''' + body + r'''
|
||||
int main() {
|
||||
Fake callbacks;
|
||||
CommonCLI cli{&callbacks};
|
||||
char reply[160];
|
||||
auto command = [&](const char* text, uint32_t sender = 0) {
|
||||
memset(reply, 'Z', sizeof(reply));
|
||||
const bool handled = cli.handleEspNowDiagnosticCommand(sender, text, reply);
|
||||
assert(reply[157] == 'Z' && reply[158] == 'Z' && reply[159] == 'Z');
|
||||
if (handled) assert(memchr(reply, 0, 157) != nullptr);
|
||||
return handled;
|
||||
};
|
||||
assert(command("get espnow.status", 77));
|
||||
assert(callbacks.statuses == 1 && callbacks.capacity == 157);
|
||||
for (const char* page : {"", "rx", "tx", "drops", "test"}) {
|
||||
const std::string text = std::string("get espnow.stats") + (*page ? " " : "") + page;
|
||||
assert(command(text.c_str(), 77));
|
||||
assert(callbacks.page == page && callbacks.capacity == 157);
|
||||
}
|
||||
callbacks.long_reply = true;
|
||||
assert(command("get espnow.status"));
|
||||
assert(strlen(reply) == 156);
|
||||
assert(command("get espnow.stats rx"));
|
||||
assert(strlen(reply) == 156);
|
||||
callbacks.long_reply = false;
|
||||
for (const char* text : {
|
||||
"get espnow.status extra", "get espnow.statusx", "get espnow.status ",
|
||||
"get espnow.statsrx", "get espnow.stats x", "get espnow.stats rx junk",
|
||||
"get espnow.stats ", "get espnow.stats\trx", "get espnow.stats rx",
|
||||
"espnow", "espnow testx", "espnow test ", "espnow test 1234567",
|
||||
"espnow test 123456789", "espnow test 0x123456", "espnow test +1234567",
|
||||
"espnow test 1234567Z", "espnow test 12345678 ", "espnow test 12345678 x",
|
||||
"espnow resetstatsx", "espnow resetstats ", "espnow resetstats now"}) {
|
||||
const int before = callbacks.count();
|
||||
assert(command(text));
|
||||
assert(strncmp(reply, "Error:", 6) == 0 && callbacks.count() == before);
|
||||
}
|
||||
for (const char* text : {"espnowtest", "espnowx test", "get espnow.enabled", "get repeat"}) {
|
||||
const int before = callbacks.count();
|
||||
assert(!command(text));
|
||||
assert(callbacks.count() == before);
|
||||
}
|
||||
for (uint32_t remote : {1U, UINT32_MAX}) {
|
||||
for (const char* text : {"espnow test", "espnow test 12345678", "espnow resetstats"}) {
|
||||
const int before = callbacks.count();
|
||||
assert(command(text, remote));
|
||||
assert(strstr(reply, "local connection") && callbacks.count() == before);
|
||||
}
|
||||
}
|
||||
assert(command("espnow test"));
|
||||
assert(callbacks.sends == 1 && callbacks.nonce == now_ms);
|
||||
assert(strcmp(reply, "OK - test queued id=1234ABCD; confirm on peer") == 0);
|
||||
assert(command("espnow test 89abcDEF"));
|
||||
assert(callbacks.sends == 2 && callbacks.nonce == 0x89ABCDEF);
|
||||
assert(command("espnow test 00000000"));
|
||||
assert(callbacks.sends == 3 && callbacks.nonce == 0);
|
||||
callbacks.send_result = false;
|
||||
assert(command("espnow test DEADBEEF"));
|
||||
assert(callbacks.sends == 4 && strstr(reply, "not queued"));
|
||||
assert(command("espnow resetstats"));
|
||||
assert(callbacks.resets == 1 && strcmp(reply, "OK - ESP-NOW statistics reset") == 0);
|
||||
callbacks.reset_result = false;
|
||||
assert(command("espnow resetstats"));
|
||||
assert(callbacks.resets == 2 && strstr(reply, "unavailable"));
|
||||
Callbacks unsupported;
|
||||
cli._callbacks = &unsupported;
|
||||
assert(command("get espnow.status") && strstr(reply, "unavailable"));
|
||||
assert(command("get espnow.stats") && strstr(reply, "unavailable"));
|
||||
assert(command("espnow test") && strstr(reply, "not queued"));
|
||||
assert(command("espnow resetstats") && strstr(reply, "unavailable"));
|
||||
}
|
||||
''')
|
||||
|
||||
def test_actual_role_forwarders_select_only_the_espnow_transport(self):
|
||||
repeater = (ROOT / "examples/simple_repeater/MyMesh.h").read_text(encoding="ascii")
|
||||
start = repeater.index("#if defined(WITH_ESPNOW_BRIDGE)\n ESPNowBridge& diagnosticEspNowBridge()")
|
||||
end = repeater.index(" // Retry ESP-NOW", start)
|
||||
repeater = repeater[start:end] + "\n#endif\n"
|
||||
room = (ROOT / "examples/simple_room_server/MyMesh.h").read_text(encoding="ascii")
|
||||
start = room.index("#if defined(WITH_BRIDGE)\n#if defined(WITH_MQTT_BRIDGE) && defined(WITH_ESPNOW_BRIDGE)\n void formatEspNowStatus(")
|
||||
end = room.index("\n#endif", start) + len("\n#endif")
|
||||
room = room[start:end] + "\n#endif\n"
|
||||
prefix = r'''
|
||||
#include <cassert>
|
||||
#include <cstdint>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
struct Base {
|
||||
virtual void formatEspNowStatus(char*, size_t) {}
|
||||
virtual void formatEspNowStats(const char*, char*, size_t) {}
|
||||
virtual bool sendEspNowTest(uint32_t) { return false; }
|
||||
virtual bool resetEspNowStats() { return false; }
|
||||
};
|
||||
struct ESPNowBridge {
|
||||
int calls = 0; uint32_t nonce = 0;
|
||||
void formatStatus(char* r, size_t cap) { ++calls; snprintf(r, cap, "status"); }
|
||||
void formatStats(const char* page, char* r, size_t cap) { ++calls; assert(strcmp(page,"rx")==0); snprintf(r, cap, "rx"); }
|
||||
bool sendTest(uint32_t n) { ++calls; nonce = n; return true; }
|
||||
void resetStats() { ++calls; }
|
||||
};
|
||||
struct Role : Base {
|
||||
ESPNowBridge bridge, espnow_bridge;
|
||||
'''
|
||||
suffix = r'''
|
||||
};
|
||||
int main() {
|
||||
Role role; char reply[157];
|
||||
role.formatEspNowStatus(reply, sizeof(reply));
|
||||
role.formatEspNowStats("rx", reply, sizeof(reply));
|
||||
assert(role.sendEspNowTest(0xABCD));
|
||||
assert(role.resetEspNowStats());
|
||||
assert(role.EXPECTED.calls == 4 && role.EXPECTED.nonce == 0xABCD);
|
||||
assert(role.OTHER.calls == 0);
|
||||
}
|
||||
'''
|
||||
for macros in ((), ("WITH_RS232_BRIDGE",), ("WITH_MQTT_BRIDGE",),
|
||||
("WITH_MQTT_BRIDGE", "WITH_RS232_BRIDGE")):
|
||||
with self.subTest(role="repeater", macros=macros):
|
||||
selected = "espnow_bridge" if macros else "bridge"
|
||||
code = prefix + repeater + suffix.replace("EXPECTED", selected).replace(
|
||||
"OTHER", "bridge" if macros else "espnow_bridge")
|
||||
self.compile_run(code, ["-DWITH_ESPNOW_BRIDGE=1", *["-D" + m for m in macros]])
|
||||
with self.subTest(role="room"):
|
||||
code = prefix + room + suffix.replace("EXPECTED", "espnow_bridge").replace("OTHER", "bridge")
|
||||
self.compile_run(code, ["-DWITH_BRIDGE=1", "-DWITH_MQTT_BRIDGE=1", "-DWITH_ESPNOW_BRIDGE=1"])
|
||||
|
||||
def test_diagnostic_virtuals_are_absent_without_espnow(self):
|
||||
header = (ROOT / "src/helpers/CommonCLI.h").read_text(encoding="ascii")
|
||||
start = header.index("#if defined(WITH_ESPNOW_BRIDGE)\n virtual void formatEspNowStatus(")
|
||||
end = header.index("\n#endif", start) + len("\n#endif")
|
||||
block = header[start:end]
|
||||
source = r'''
|
||||
#include <cassert>
|
||||
#include <cstdint>
|
||||
#include <cstdio>
|
||||
#include <type_traits>
|
||||
#include <utility>
|
||||
struct Callbacks {
|
||||
''' + block + r'''
|
||||
};
|
||||
template <typename T, typename = void> struct HasDiagnostics : std::false_type {};
|
||||
template <typename T> struct HasDiagnostics<T, std::void_t<
|
||||
decltype(std::declval<T>().formatEspNowStatus(nullptr, 0)),
|
||||
decltype(std::declval<T>().formatEspNowStats(nullptr, nullptr, 0)),
|
||||
decltype(std::declval<T>().sendEspNowTest(0)),
|
||||
decltype(std::declval<T>().resetEspNowStats())>> : std::true_type {};
|
||||
int main() {
|
||||
#if defined(WITH_ESPNOW_BRIDGE)
|
||||
static_assert(HasDiagnostics<Callbacks>::value);
|
||||
Callbacks callbacks; char reply[157];
|
||||
callbacks.formatEspNowStatus(reply, sizeof(reply));
|
||||
assert(reply[0] == 'E');
|
||||
assert(!callbacks.sendEspNowTest(0) && !callbacks.resetEspNowStats());
|
||||
#else
|
||||
static_assert(!HasDiagnostics<Callbacks>::value);
|
||||
static_assert(sizeof(Callbacks) == 1);
|
||||
#endif
|
||||
}
|
||||
'''
|
||||
self.compile_run(source)
|
||||
self.compile_run(source, ["-DWITH_ESPNOW_BRIDGE=1"])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -14,6 +14,7 @@ STUBS = r'''
|
||||
#include <cstring>
|
||||
#include <helpers/WirelessControl.h>
|
||||
#include <helpers/ESPNowRawFragmentation.h>
|
||||
#include <helpers/bridges/ESPNowBridgeDiagnostics.h>
|
||||
#define ESP_IDF_VERSION_VAL(a,b,c) ((a)*10000+(b)*100+(c))
|
||||
#define ESPNOW_DEBUG_PRINTLN(...) ((void)0)
|
||||
#define portENTER_CRITICAL(x) ((void)0)
|
||||
@@ -213,6 +214,10 @@ struct Backend : mesh::wireless::Backend {
|
||||
};
|
||||
class Bridge {
|
||||
public:
|
||||
static constexpr int ESP_ERR_INVALID_STATE=-78,ESP_ERR_INVALID_ARG=-79;
|
||||
std::atomic<bool> _debug_dirty{false};
|
||||
void recordError(mesh::bridge::diag::Stage,int32_t){}
|
||||
void emitDebug(){}
|
||||
struct Prefs {int bridge_format=mesh::bridge::ESPNOW_FORMAT_RAW;uint8_t bridge_channel=6;} prefs;
|
||||
Prefs* _prefs=&prefs;bool _initialized=false;
|
||||
int _active_format=0,_rx_mux=0,_rx_head=0,_rx_tail=0,_rx_count=0,_rx_dropped=0,_rx_dropped_reported=0;
|
||||
@@ -220,7 +225,7 @@ public:
|
||||
int _tx_callback_status=0,_tx_dropped=0,_tx_dropped_reported=0;
|
||||
uint32_t _tx_started_at=0,_tx_retry_at=0;bool _sdk_teardown_failed=false;
|
||||
mesh::espnow::ESPNowRawReassembler _raw_reassembler;
|
||||
struct QueuedTransmit {bool started=false;int packet=0;};
|
||||
struct QueuedTransmit {bool started=false,diagnostic=false;int packet=0;};
|
||||
static constexpr int TX_QUEUE_DEPTH=2;
|
||||
QueuedTransmit _tx_queue[TX_QUEUE_DEPTH];
|
||||
struct {void clear(const int*){}} _seen_packets;
|
||||
|
||||
@@ -40,6 +40,8 @@ HARNESS = r'''
|
||||
#include <cassert>
|
||||
#include <vector>
|
||||
#include <helpers/bridges/RS232Heartbeat.h>
|
||||
#include <helpers/bridges/ESPNowBridgeDiagnostics.h>
|
||||
#include <helpers/bridges/ESPNowBridgeFormat.h>
|
||||
#define BRIDGE_DEBUG_PRINTLN(...) ((void)0)
|
||||
#define PUB_KEY_SIZE 32
|
||||
#define PAYLOAD_TYPE_ADVERT 4
|
||||
@@ -57,15 +59,6 @@ struct Identity {
|
||||
explicit Identity(const uint8_t*) {}
|
||||
bool verify(const uint8_t*,const uint8_t*,int) {assert(false);return false;}
|
||||
};
|
||||
namespace espnow {
|
||||
struct ESPNowRawFrames {uint8_t count=0;uint16_t lengths[2]={};uint8_t data[2][256]={};};
|
||||
bool encodeEspNowRawFrames(const uint8_t*,size_t,ESPNowRawFrames& f) {f.count=1;return true;}
|
||||
}
|
||||
namespace bridge {
|
||||
enum {ESPNOW_FORMAT_RAW=0};
|
||||
size_t espNowMaxMeshPacketSize(int) {return 256;}
|
||||
const char* espNowFormatName(int) {return "raw";}
|
||||
}
|
||||
}
|
||||
namespace AdvertSignature {
|
||||
constexpr unsigned kMaxMessageLen=68;
|
||||
@@ -83,6 +76,7 @@ struct Manager {
|
||||
};
|
||||
struct Prefs {unsigned bridge_delay=10;unsigned bridge_baud=115200;};
|
||||
struct BridgeBase : AbstractBridge {
|
||||
@INGRESS_HOOK@
|
||||
bool _initialized=true;
|
||||
Seen _seen_packets;
|
||||
Manager manager; Manager* _mgr=&manager;
|
||||
@@ -120,8 +114,16 @@ struct RS232Bridge : BridgeBase {
|
||||
};
|
||||
struct ESPNowBridge : BridgeBase {
|
||||
int _active_format=0;
|
||||
mesh::bridge::diag::Stats _stats;
|
||||
std::atomic<bool> _debug_dirty{false};
|
||||
void noteTx(uint32_t mesh::bridge::diag::TxStats::* field) {
|
||||
mesh::bridge::diag::increment(_stats.tx.*field);
|
||||
}
|
||||
void recordError(mesh::bridge::diag::Stage stage,int32_t code) {
|
||||
_stats.error={stage,code,millis()};
|
||||
}
|
||||
bool xorCrypt(uint8_t*,size_t) {return true;}
|
||||
bool queueTransmitFrames(mesh::espnow::ESPNowRawFrames&,const mesh::Packet&) {++queued;return true;}
|
||||
bool queueTransmitFrames(const mesh::espnow::ESPNowRawFrames&,const mesh::Packet&,bool=false) {++queued;return true;}
|
||||
void sendPacket(mesh::Packet*) override;
|
||||
};
|
||||
struct MQTTBridge : BridgeBase {
|
||||
@@ -205,6 +207,14 @@ int main() {
|
||||
}
|
||||
'''
|
||||
|
||||
# Importers use this shared harness directly, so expand its production hook
|
||||
# here rather than leaving fixture setup to one test's compilation path.
|
||||
_base_header = (ROOT / 'src/helpers/bridges/BridgeBase.h').read_text(encoding='ascii')
|
||||
_ingress_hook = '#if defined(WITH_ESPNOW_BRIDGE)\n'
|
||||
_ingress_hook += method(_base_header, 'enum class IngressResult') + ';\n'
|
||||
_ingress_hook += method(_base_header, 'virtual void onIngressResult(') + '\n#endif\n'
|
||||
HARNESS = HARNESS.replace('@INGRESS_HOOK@', _ingress_hook)
|
||||
|
||||
class TransportFilterWiring(unittest.TestCase):
|
||||
def test_aliases_dispatch_the_original_suffix_without_expanding_a_command_buffer(self):
|
||||
source = (ROOT/'examples/simple_repeater/MyMesh.cpp').read_text()
|
||||
@@ -394,11 +404,13 @@ int main() {
|
||||
(work/'Mesh.h').write_text(PACKET)
|
||||
code = '#include <initializer_list>\n' + HARNESS.replace('@METHODS@', '\n'.join(methods))
|
||||
(work/'test.cpp').write_text(code)
|
||||
result = subprocess.run(['g++', '-std=c++17', '-Wall', '-Wextra', '-Werror',
|
||||
'-I', str(work), '-I', str(ROOT/'src'), str(work/'test.cpp'),
|
||||
'-o', str(work/'test')], text=True, capture_output=True)
|
||||
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
|
||||
subprocess.run([str(work/'test')], check=True)
|
||||
for macros in [[], ['-DWITH_ESPNOW_BRIDGE=1']]:
|
||||
with self.subTest(macros=macros):
|
||||
result = subprocess.run(['g++', '-std=c++17', '-Wall', '-Wextra', '-Werror',
|
||||
*macros, '-I', str(work), '-I', str(ROOT/'src'), str(work/'test.cpp'),
|
||||
'-o', str(work/'test')], text=True, capture_output=True)
|
||||
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
|
||||
subprocess.run([str(work/'test')], check=True)
|
||||
|
||||
def test_roles_wire_filter_at_every_bridge_start_and_cross_hook(self):
|
||||
for role in ['simple_repeater', 'simple_room_server']:
|
||||
|
||||
+1
-1
@@ -2174,7 +2174,7 @@ var CLI_KEYS=[
|
||||
["bridge.source","Packets the bridge carries",0,"rx|tx"],
|
||||
["bridge.baud","Bridge serial baud rate",0],
|
||||
["bridge.delay","Bridge send delay",0],
|
||||
["bridge.channel","Bridge channel",0],
|
||||
["bridge.channel","ESP-NOW 2.4 GHz channel",0],
|
||||
["bridge.format","ESP-NOW bridge wire format",0,"wrapped|raw"],
|
||||
["bridge.secret","Bridge shared secret",0]
|
||||
];
|
||||
|
||||
Reference in new issue
Block a user