Public Access
Merge branch 'm3': the LoRa radio, receive only, and the LoRa Scanner
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EhqxQ49eCju4CzKYNjZzwT
This commit is contained in:
Claude Opus 5.5
@@ -20,6 +20,10 @@ _Avoid_: daemon, task, driver
|
||||
The Service that keeps the device participating in a mesh network at all times: receiving, relaying, and sending on behalf of Apps.
|
||||
_Avoid_: radio, LoRa app
|
||||
|
||||
**Radio Service**:
|
||||
The Service that owns the LoRa radio on the Cap: it configures it, shares the SPI bus with the SD card, and receives in the background. The LoRa Scanner uses it directly; the Mesh Service sits on top of it.
|
||||
_Avoid_: LoRa driver, modem
|
||||
|
||||
**Mesh Protocol**:
|
||||
One on-air language the Mesh Service can speak (Meshtastic first; others may follow). The Mesh Service speaks Mesh Protocols; Apps don't.
|
||||
_Avoid_: stack, mode
|
||||
@@ -159,6 +163,7 @@ _Avoid_: telnet, remote shell
|
||||
- The **Mesh Service** speaks one or more **Mesh Protocols** and tracks the known **Nodes**.
|
||||
- The **Wi-Fi Service** is either Connected or Monitoring, never both. Monitoring pauses the **IRC Service**, which reconnects and rejoins its **Buffers** afterwards.
|
||||
- **Services** raise **Notifications**; the **Status Bar** summarises **Service** state.
|
||||
- The **Radio Service** owns the radio; the **Mesh Service** and the LoRa Scanner use it.
|
||||
- A **Sweep** pauses the **Mesh Service**; a **Sniffer** does not.
|
||||
- Every transmission is bounded by the **Region** and its **Duty Cycle Budget**.
|
||||
- Past 90% SD usage, **Logs** stop being written; the remaining space is kept for **Captures**. Nothing is deleted without the user's confirmation.
|
||||
|
||||
@@ -60,6 +60,10 @@ The Gemini App browses Geminispace (docs/milestones/G1.md): Tab and Shift+Tab pi
|
||||
|
||||
On a page, `b` bookmarks it, `s` saves it to the SD card to read offline (a non-text file goes to `/gemini/downloads/`), `S` saves it with the pages it links to on the same capsule (up to 30). The start page lists bookmarks and Saved Pages; inside a Saved Page, `r` refreshes it and `d` deletes it. With a card, every page streams through `/gemini/cache/` so a large one arrives whole even with IRC connected; what doesn't fit in memory stays on the card.
|
||||
|
||||
## LoRa Scanner
|
||||
|
||||
The LoRa Scanner (docs/milestones/M3.md) listens with the Cap's radio and **never transmits**. The Sniffer lists what it hears, newest first: time, RSSI, SNR, and for Meshtastic packets the sender and receiver (their last 4 hex digits) and hops. Enter shows a packet's details: the Meshtastic header (which is never encrypted) and a hex dump. `p` picks one of the 7 Meshtastic presets allowed in EU868 (LongFast by default), `c` starts or stops a Capture: a pcap file with LoRaTap headers in `/captures/lora/`, for Wireshark. A Capture keeps recording with the App closed; otherwise the radio sleeps when the App isn't open. Tab switches to **Sweep**: the signal strength across 863–870 MHz in 100 kHz steps, as bars with peak hold and a waterfall, with the Sniffer's frequency marked; the Sniffer is paused meanwhile and picks up where it was. The Status Bar shows `L` while the radio listens (bright for a moment on each packet), `SW` while sweeping, and `CAP` while capturing.
|
||||
|
||||
## Development aids
|
||||
|
||||
`scripts/serial_log.sh [seconds] [command…]` records the serial output, and can send commands to the firmware first. For example, `scripts/serial_log.sh 30 short sleep:12 burst` sets short screen timeouts, waits 12 s, then sends a burst of Toasts.
|
||||
@@ -87,6 +91,13 @@ On a page, `b` bookmarks it, `s` saves it to the SD card to read offline (a non-
|
||||
| `log level <0-5>` | ESP-IDF log level |
|
||||
| `ls [folder]` / `rm <path>` | Lists a folder of the SD card, or deletes a file |
|
||||
| `install <path>` | Update from SD with that `.ota` file, as Settings → Firmware does |
|
||||
| `lora probe` | Finds the radio: chip, oscillator, antenna switch, DIO1 interrupt, noise floor |
|
||||
| `lora status` | Radio settings, who's listening, packet and error counters, noise floor, task stack |
|
||||
| `lora rx on` / `lora rx off` | Listens and prints each packet on the console |
|
||||
| `lora preset <name>` / `lora custom <MHz> <BW kHz> <SF> <CR> <sync hex> [preamble]` | Receive settings: a Meshtastic preset, or anything else (`lora custom 868.1 125 7 5 34 8` for LoRaWAN) |
|
||||
| `lora capture start` / `lora capture stop` | A LoRa Capture, as `c` in the App |
|
||||
| `lora sweep on [from MHz] [to MHz] [step kHz]` / `lora sweep off` / `lora sweep dump` | Sweep a band (863 870 100 by default), with a summary every 2 s (floor, strongest, peaks), or print the latest pass |
|
||||
| `lora inject <hex> [rssi] [snr]` | Debug Builds: a packet into the Scanner as if received (nothing is sent) |
|
||||
| `crash` | The last crash: which firmware, why, task, PC and backtrace (from the core dump in flash) |
|
||||
| `coredump erase` | Forgets the core dump |
|
||||
| `crash abort` / `crash wdt` | Debug Builds: crash on purpose, or hang the main loop until the watchdog fires |
|
||||
|
||||
@@ -0,0 +1,69 @@
|
||||
# M3 — Radio bring-up: the LoRa Scanner
|
||||
|
||||
**Status:** done, tagged v0.6.0. Everything was checked on the device except one "Done when" item: Sweep was never tried against a known transmitter (see below). The listening hour heard nothing, so by Q104 **a reference Meshtastic node is a requirement for M4**.
|
||||
|
||||
**Goal:** the LoRa radio on the Cap works, receive only: a Radio Service owns it and shares the SPI bus with the SD card safely, and a LoRa Scanner App shows what's on the air, either packets (Sniffer) or energy across the band (Sweep). Nothing in M3 can transmit. The mesh comes on top of this in M4 (receive) and M5 (transmit).
|
||||
|
||||
**Hardware:** the Cap LoRa-1262 carries an SX1262 (868–923 MHz, +22 dBm) with an RP-SMA antenna. Pins, as in Meshtastic's board file for the Cardputer ADV: **NSS 5, RST 3, DIO1 (IRQ) 4, BUSY 6**, on the SPI bus shared with the microSD card (SCK 40, MISO 39, MOSI 14; card CS 12). Meshtastic uses DIO2 as the RF switch and DIO3 for a 1.8 V TCXO, marked optional. M5Stack's page adds an FM8625H antenna switch enabled by P0 of a PI4IOE5V6408 I/O expander on the internal I2C bus, address not given; Meshtastic doesn't mention it. Step 1 measures which is true.
|
||||
|
||||
**No other LoRa device yet.** meshmap.net (2026-10-05) lists two Meshtastic nodes within 10 km of the desk and six within 30 km, with positions blurred by a few km; none is known to be in range. M3 needs none: it only receives.
|
||||
|
||||
## Measured
|
||||
|
||||
- **Internal I2C bus (8/9):** 0x18 (ES8311 codec), 0x34 (TCA8418 keyboard), **0x43 (PI4IOE5V6408, ID register 0xA2)**, 0x69 (BMI270 IMU).
|
||||
- **The SX1262 answers** on NSS 5, RST 3, DIO1 4, BUSY 6. Its version string reads `SX1261 V2D 2D02`, which SX1262 chips report too. **The 1.8 V TCXO works** on the first try; the radio is ready 38 ms after `begin`.
|
||||
- **The expander's P0 connects the antenna; it's required.** At power-on P0 is an input (direction 0x00, high-impedance 0xFF), and the receiver reads a flat **-111.9 dBm** at 869.525 MHz, BW 250 kHz: the chip's own floor, deaf. With P0 driven high, the noise floor is **-87 to -94 dBm**: the antenna hearing the room. So the Radio Service drives P0 high at boot (Q91).
|
||||
- **DIO2 doesn't change reception** (within ±2 dB over three runs, P0 high). It likely selects TX versus RX in the FM8625H; it stays the RF switch, as in Meshtastic.
|
||||
- **The noise floor at the desk is high** (-87 to -94 dBm, varying run to run), about 25 dB above thermal noise for 250 kHz. Something nearby is loud, possibly the Cardputer itself or the PC; Sweep (step 5) should show where it sits.
|
||||
- **Step 2:** presets, frequencies and the channel hash are checked against Meshtastic's source (`MeshRadio.h`, `RadioInterface.cpp`): LongFast and the default key give hash 8, MediumFast 31, as Meshtastic shows. Captures were checked with TShark 4.2.5: every LoRaTap field reads back. Wireshark ignores the spec's quarter-dB packet RSSI below 0 dB SNR, so packet RSSI is plain dBm.
|
||||
- **Step 3:** the DIO1 interrupt works (a 100 ms receive timeout wakes the task after 105 ms). While listening: four 1.7 MB uploads and Gemini pages to the card, no radio or card errors (the card refuses a write about once in five uploads with the radio asleep too; `put` now catches it, and issue #21 follows the cause). The ring takes 9.8 KB while listening; the radio task's stack peaks at 2.0 KB.
|
||||
- **No packets yet, and a loud desk.** Twenty minutes on LongFast and on LoRaWAN's three uplink frequencies (SF7, SF9, SF12): no packet and no header, valid or not. The noise floor reads -83 to -94 dBm, against -112 dBm with the antenna switched off: 20 to 30 dB lost to something nearby, not the screen and not the GNSS receiver. Preamble detections are false alarms at this noise level (more on an empty frequency, 869.0 MHz, than on LongFast).
|
||||
- **Step 4:** a Capture made on the device reads back in TShark field for field (time, frequency, SF, RSSI, SNR, payload). A Capture keeps the radio listening with the App closed; stopping it puts the radio back to sleep.
|
||||
- **Step 5:** a pass across 863–870 MHz (71 steps, the strongest of three RSSI readings at each, measured at 125 kHz) takes about 607 ms. At the desk the band is **flat at -100 to -102 dBm**, about 15 dB above the chip's own floor at 125 kHz, with a steady carrier at 863.2 MHz (-89 dBm at its strongest) and fainter lines elsewhere: broadband noise from nearby electronics rather than a transmitter. Sweep's waterfall takes 2.6 KB while shown; 91.9 KB free during a Sweep. The radio task's stack peaks at 1.9 KB.
|
||||
- **Outside, on battery (step 6).** The noise is no lower than at the desk: a Sweep floor of -96 to -99 dBm (median -97) with Wi-Fi on, -99 to -100 with Wi-Fi off, so Wi-Fi accounts for 2 or 3 dB. The same narrow peaks come back on every pass, at 863.2, 863.6, 864.4, 864.8, 865.9, 866.3, 867.8, 869.0 and 869.4 MHz (-88 to -91 dBm), several of them 400 kHz apart; 869.4 MHz is the lower edge of LongFast's channel. A source that follows the device outside and onto its battery is the device: **about 15 dB of the floor is the Cardputer's own** (issue #20). At SF11 that puts the weakest decodable packet near -114 dBm on LongFast, against about -130 dBm for a quiet receiver.
|
||||
- **The listening hour (step 6, Q104):** 20:33 to 21:34 on 2026-10-05, outside, on battery, LongFast, with a Capture running. **0 packets, 0 headers**, 0 radio errors; noise -85 to -87 dBm at 250 kHz throughout; 860 preamble detections, all false alarms. The Capture holds its 24-byte header and nothing else. No restart in 1 h 10 min.
|
||||
- **Floors (Q86):** with the radio listening, Wi-Fi and IRC connected over TLS, 52.6 KB free (lowest 22.7 KB during the TLS handshake, the dip accepted in G1). Without IRC, 93 KB.
|
||||
- **Receive only:** nothing in `src` or `lib` calls a transmit function.
|
||||
- **Cost:** RadioLib 7.8.1 and the probe add 23.6 KB of flash and 656 bytes of static RAM to the release firmware (1,679,843 bytes of 3,342,336). The whole milestone: 51.8 KB of flash (1,708,091 bytes), 365 tests (27 new).
|
||||
|
||||
## Decisions (design round 2026-10-05)
|
||||
|
||||
| # | Decision |
|
||||
|---|---|
|
||||
| Q89 | **M3 is the radio only:** Radio Service, Sniffer, Sweep. Notes and the File Browser (Q30) move out to issue #3 and a Notes issue, as a later side milestone. |
|
||||
| Q90 | **RadioLib**, pinned (ADR 0001). SX1262 on NSS 5, RST 3, DIO1 4, BUSY 6; DIO2 as RF switch; TCXO at 1.8 V tried first, falling back to the crystal (Meshtastic's `TCXO_OPTIONAL`). |
|
||||
| Q91 | Step 1 is `lora probe`: chip status and version, which oscillator setting worked, and an I2C scan of the internal bus for the PI4IOE5V6408. If present, its P0 is set high at boot (harmless) and DIO2 stays the switch. A wrong switch receives deaf, so compare noise floors. |
|
||||
| Q92 | A **Radio Service** owns the SX1262: driver, bus lock, IRQ task. The LoRa Scanner uses it in M3; the Mesh Service sits on top of it in M4. |
|
||||
| Q93 | Every radio transfer takes the shared bus lock (`SPI.beginTransaction`, as the card does). DIO1's interrupt only wakes the task; no SPI in the ISR. **Done when** a Gemini page streams to the card while the Sniffer receives, with no lost packets and no card errors (`lora status` counters). |
|
||||
| Q94 | **Receive only:** the Radio Service has no transmit function in M3. It doesn't exist, rather than being unused. |
|
||||
| Q95 | Sniffer defaults: **EU868 LongFast**, 869.525 MHz, BW 250 kHz, SF 11, CR 4/5, sync word 0x2B, preamble 16 (Q19). The other Meshtastic presets are offered, plus custom settings. |
|
||||
| Q96 | The Sniffer lists packets (time, RSSI, SNR, frequency error, length; hex dump on Enter) **and decodes the Meshtastic header**: the first 16 bytes are never encrypted (destination, sender, packet ID, hop limit and hop start, channel hash, next hop, relay node). Host-tested. Payload decryption is M4. |
|
||||
| Q97 | A Sniffer **Capture** is pcap with **LoRaTap** headers (link type 270), for Wireshark. Started by hand, Status Bar mark, its own Clean-up category, the 90% rule. |
|
||||
| Q98 | **Sweep** steps across the Region's band (863–870 MHz) in 100 kHz steps by default, reading instant RSSI: bars with peak hold, and a waterfall, Wi-Fi Tools style. Optionally CAD on the preset's frequency to tell LoRa traffic from noise. |
|
||||
| Q99 | Sweep takes the radio and pauses the Sniffer, visibly (Q18). From M4 it pauses the Mesh Service the same way. |
|
||||
| Q100 | The Sniffer runs while the App is open **or a Capture is recording**; otherwise the radio sleeps. From M4 the Mesh Service keeps it on. |
|
||||
| Q101 | **Status Bar:** a radio mark while receiving, flashing on each packet; muted during a Sweep. |
|
||||
| Q102 | Debug aids: `lora status` (settings, counters, last RSSI/SNR, noise floor), `lora probe`, `lora rx on/off` (packets on the consoles). Raw packets are never written to the card outside a Capture. |
|
||||
| Q103 | A ring of the **last 32 packets** in RAM (about 9 KB at full length); older ones are dropped unless capturing. IRQ task stack trimmed by measurement; RadioLib's flash and RAM measured in step 1 against the floors. |
|
||||
| Q104 | **Done when** (below) includes an hour of listening on LongFast by a window. Real packets heard become M4 test fixtures. If none are heard, M3 still closes, and a reference Meshtastic node (Q21) becomes a requirement for M4. |
|
||||
|
||||
## Done when
|
||||
|
||||
- `lora probe` reports the SX1262, its oscillator setting and the RF switch arrangement, and the result is written here.
|
||||
- The Sniffer receives on LongFast with the App open or a Capture running, and the radio sleeps otherwise.
|
||||
- Sweep shows the noise floor across 863–870 MHz, and a known signal (a remote key fob, a 868 MHz sensor, anything) stands out. *Half met: the floor and the device's own steady peaks show; no known transmitter was tried.*
|
||||
- The shared-bus test passes (Q93): a Gemini page to the card while the Sniffer receives, no lost packets, no card errors.
|
||||
- A Capture opens in Wireshark with LoRaTap fields.
|
||||
- The Status Bar mark follows Q101.
|
||||
- One hour of LongFast listening by a window has been run and its result recorded here. *Run outside, on battery.*
|
||||
- Free heap stays above the floors (Q86) with the Sniffer, Wi-Fi, IRC on TLS and the UI running.
|
||||
- Nothing in the firmware can transmit.
|
||||
|
||||
## Work breakdown
|
||||
|
||||
1. **Hardware check:** RadioLib in the build, `lora probe` (Q91), flash and RAM cost measured.
|
||||
2. **Meshtastic header and LoRaTap** (host-tested): header parsing, presets and their radio settings, pcap/LoRaTap writing.
|
||||
3. **Radio Service:** receive on its own task behind the bus lock, the packet ring, `lora status` and `lora rx`, the shared-bus test.
|
||||
4. **LoRa Scanner App, Sniffer:** the packet list, details, preset choice, Captures, Status Bar mark.
|
||||
5. **Sweep:** the RSSI sweep, bars and waterfall, pausing the Sniffer.
|
||||
6. **Listening hour** and the measurements above, recorded here.
|
||||
@@ -0,0 +1,64 @@
|
||||
#include "loratap.h"
|
||||
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include <cstdio>
|
||||
#include <ctime>
|
||||
|
||||
namespace roro::lora {
|
||||
|
||||
static void le16(std::vector<uint8_t>& o, uint16_t v) { o.insert(o.end(), {uint8_t(v), uint8_t(v >> 8)}); }
|
||||
static void le32(std::vector<uint8_t>& o, uint32_t v) {
|
||||
o.insert(o.end(), {uint8_t(v), uint8_t(v >> 8), uint8_t(v >> 16), uint8_t(v >> 24)});
|
||||
}
|
||||
|
||||
// LoRaTap's dBm encoding: -139 dBm plus the byte, clamped to what a byte holds.
|
||||
static uint8_t dbmByte(float dbm) {
|
||||
long v = std::lround(dbm + 139);
|
||||
return static_cast<uint8_t>(std::clamp(v, 0L, 255L));
|
||||
}
|
||||
|
||||
std::string capturePath(int64_t utcSeconds) {
|
||||
time_t t = static_cast<time_t>(utcSeconds);
|
||||
struct tm u;
|
||||
gmtime_r(&t, &u);
|
||||
char buf[48];
|
||||
std::snprintf(buf, sizeof buf, "/captures/lora/%04d%02d%02d-%02d%02d%02d.pcap", u.tm_year + 1900, u.tm_mon + 1,
|
||||
u.tm_mday, u.tm_hour, u.tm_min, u.tm_sec);
|
||||
return buf;
|
||||
}
|
||||
|
||||
void appendPcapHeader(std::vector<uint8_t>& out) {
|
||||
le32(out, 0xA1B2C3D4);
|
||||
le16(out, 2);
|
||||
le16(out, 4);
|
||||
le32(out, 0); // time zone
|
||||
le32(out, 0); // timestamp accuracy
|
||||
le32(out, 65535); // snap length
|
||||
le32(out, 270); // LINKTYPE_LORATAP
|
||||
}
|
||||
|
||||
void appendRecord(std::vector<uint8_t>& out, uint32_t seconds, uint32_t micros, const RxInfo& rx, const uint8_t* data,
|
||||
size_t len) {
|
||||
uint32_t captured = static_cast<uint32_t>(kLoraTapSize + len);
|
||||
le32(out, seconds);
|
||||
le32(out, micros);
|
||||
le32(out, captured);
|
||||
le32(out, captured);
|
||||
|
||||
uint32_t f = rx.frequencyHz;
|
||||
// The spec puts packet RSSI in quarter dB below 0 dB SNR (an SX127x formula), but Wireshark
|
||||
// reads it as -139 dBm plus the byte either way, and the SX1262 already gives dBm.
|
||||
uint8_t packetRssi = dbmByte(rx.rssi);
|
||||
long snr = std::clamp(std::lround(rx.snr * 4), -128L, 127L);
|
||||
out.insert(out.end(), {
|
||||
0, 0, 0, uint8_t(kLoraTapSize), // version 0, padding, length
|
||||
uint8_t(f >> 24), uint8_t(f >> 16), uint8_t(f >> 8), uint8_t(f),
|
||||
uint8_t(std::lround(rx.bandwidthKHz / 125)), rx.spreadingFactor,
|
||||
packetRssi, dbmByte(rx.rssi), dbmByte(rx.noiseFloor),
|
||||
static_cast<uint8_t>(static_cast<int8_t>(snr)), rx.syncWord,
|
||||
});
|
||||
if (len) out.insert(out.end(), data, data + len);
|
||||
}
|
||||
|
||||
} // namespace roro::lora
|
||||
@@ -0,0 +1,33 @@
|
||||
#pragma once
|
||||
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace roro::lora {
|
||||
|
||||
// What the radio knew about one received packet.
|
||||
struct RxInfo {
|
||||
uint32_t frequencyHz = 0;
|
||||
float bandwidthKHz = 0;
|
||||
uint8_t spreadingFactor = 0;
|
||||
float rssi = 0; // dBm
|
||||
float snr = 0; // dB
|
||||
float noiseFloor = 0; // dBm, instantaneous RSSI just before the packet, when known
|
||||
uint8_t syncWord = 0;
|
||||
};
|
||||
|
||||
// A Capture file (M3, Q97): pcap with LoRaTap v0 headers (LINKTYPE_LORATAP, 270), which Wireshark
|
||||
// reads. pcap fields are little-endian, LoRaTap fields big-endian.
|
||||
void appendPcapHeader(std::vector<uint8_t>& out);
|
||||
void appendRecord(std::vector<uint8_t>& out, uint32_t seconds, uint32_t micros, const RxInfo& rx, const uint8_t* data,
|
||||
size_t len);
|
||||
|
||||
// "/captures/lora/YYYYMMDD-HHMMSS.pcap" in UTC, dated like Tracks so Storage Clean-up can age it.
|
||||
std::string capturePath(int64_t utcSeconds);
|
||||
|
||||
constexpr size_t kLoraTapSize = 15;
|
||||
constexpr size_t kRecordOverhead = 16 + kLoraTapSize;
|
||||
|
||||
} // namespace roro::lora
|
||||
@@ -0,0 +1,83 @@
|
||||
#include "packet_view.h"
|
||||
|
||||
#include <cmath>
|
||||
#include <cstdio>
|
||||
|
||||
#include "meshtastic_header.h"
|
||||
#include "meshtastic_presets.h"
|
||||
|
||||
namespace roro::lora {
|
||||
|
||||
using namespace meshtastic;
|
||||
|
||||
std::string row(const PacketSummary& p, const std::string& time) {
|
||||
char s[64];
|
||||
int n = std::snprintf(s, sizeof s, "%s %ld %.1f ", time.c_str(), std::lround(p.rssi), p.snr);
|
||||
std::string out(s, n);
|
||||
PacketHeader h;
|
||||
if (!p.crcOk) return out + "bad CRC, " + std::to_string(p.len) + " B";
|
||||
if (!p.meshtastic || !parseHeader(p.data, p.len, h)) return out + std::to_string(p.len) + " B";
|
||||
auto shortId = [](uint32_t node) {
|
||||
if (node == kBroadcast) return std::string("all");
|
||||
char id[8];
|
||||
std::snprintf(id, sizeof id, "%04x", static_cast<unsigned>(node & 0xFFFF));
|
||||
return std::string(id);
|
||||
};
|
||||
out += shortId(h.from) + ">" + shortId(h.to);
|
||||
if (h.hopsAway() >= 0) out += " " + std::to_string(h.hopsAway()) + "/" + std::to_string(h.hopStart());
|
||||
return out;
|
||||
}
|
||||
|
||||
std::vector<std::string> hexDump(const uint8_t* data, size_t len) {
|
||||
std::vector<std::string> lines;
|
||||
for (size_t at = 0; at < len; at += 8) {
|
||||
char s[48];
|
||||
int n = std::snprintf(s, sizeof s, "%04x", static_cast<unsigned>(at));
|
||||
std::string text;
|
||||
for (size_t i = 0; i < 8; ++i) {
|
||||
if (at + i < len) {
|
||||
n += std::snprintf(s + n, sizeof s - n, " %02x", data[at + i]);
|
||||
uint8_t b = data[at + i];
|
||||
text += b >= 0x20 && b < 0x7F ? static_cast<char>(b) : '.';
|
||||
} else {
|
||||
n += std::snprintf(s + n, sizeof s - n, " ");
|
||||
}
|
||||
}
|
||||
lines.push_back(std::string(s, n) + " " + text);
|
||||
}
|
||||
return lines;
|
||||
}
|
||||
|
||||
std::vector<std::string> headerLines(const uint8_t* data, size_t len) {
|
||||
PacketHeader h;
|
||||
if (!parseHeader(data, len, h)) return {};
|
||||
char s[64];
|
||||
std::vector<std::string> lines;
|
||||
lines.push_back("From " + nodeId(h.from) + " to " + nodeId(h.to));
|
||||
std::snprintf(s, sizeof s, "Packet %08x%s%s", static_cast<unsigned>(h.id), h.wantAck() ? ", wants an ack" : "",
|
||||
h.viaMqtt() ? ", via MQTT" : "");
|
||||
lines.push_back(s);
|
||||
if (h.hopsAway() >= 0)
|
||||
std::snprintf(s, sizeof s, "Hops %d of %u, limit %u left", h.hopsAway(), h.hopStart(), h.hopLimit());
|
||||
else
|
||||
std::snprintf(s, sizeof s, "Hop limit %u left (old firmware)", h.hopLimit());
|
||||
lines.push_back(s);
|
||||
// Which preset's default Channel (named after it, with the public key) has this hash.
|
||||
std::string channel;
|
||||
for (size_t i = 0; i < kEu868PresetCount && channel.empty(); ++i)
|
||||
if (channelHash(kEu868Presets[i].name, kDefaultKey, sizeof kDefaultKey) == h.channelHash)
|
||||
channel = std::string(" (") + kEu868Presets[i].name + ", default key)";
|
||||
std::snprintf(s, sizeof s, "Channel 0x%02x%s", h.channelHash, channel.c_str());
|
||||
lines.push_back(s);
|
||||
if (h.relayNode) {
|
||||
std::snprintf(s, sizeof s, "Relayed by ..%02x", h.relayNode);
|
||||
lines.push_back(s);
|
||||
}
|
||||
if (h.nextHop) {
|
||||
std::snprintf(s, sizeof s, "Next hop ..%02x", h.nextHop);
|
||||
lines.push_back(s);
|
||||
}
|
||||
return lines;
|
||||
}
|
||||
|
||||
} // namespace roro::lora
|
||||
@@ -0,0 +1,29 @@
|
||||
#pragma once
|
||||
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace roro::lora {
|
||||
|
||||
// What the LoRa Scanner shows of one packet (M3, Q96).
|
||||
struct PacketSummary {
|
||||
const uint8_t* data;
|
||||
size_t len;
|
||||
float rssi, snr;
|
||||
bool crcOk;
|
||||
bool meshtastic; // received on Meshtastic settings (sync word 0x2B): read its clear header
|
||||
};
|
||||
|
||||
// One list row, at most about 36 characters: "21:45:07 -97 6.2 5678>all 1/3". Nodes by their default
|
||||
// short name (the last 4 hex digits); headerLines() has the full numbers.
|
||||
std::string row(const PacketSummary& p, const std::string& time);
|
||||
|
||||
// Eight bytes a line, with the printable ones: "0000 ff ff ff ff 78 56 34 12 ....xV4.".
|
||||
std::vector<std::string> hexDump(const uint8_t* data, size_t len);
|
||||
|
||||
// The Meshtastic header, one field a line; empty when the packet is too short to have one.
|
||||
std::vector<std::string> headerLines(const uint8_t* data, size_t len);
|
||||
|
||||
} // namespace roro::lora
|
||||
@@ -0,0 +1,48 @@
|
||||
#include "sweep_view.h"
|
||||
|
||||
#include <algorithm>
|
||||
|
||||
namespace roro::lora {
|
||||
|
||||
namespace {
|
||||
constexpr int kPeakAboveFloorDb = 10;
|
||||
constexpr size_t kMaxPeaks = 3;
|
||||
} // namespace
|
||||
|
||||
SweepStats summarize(const int8_t* dbm, size_t steps, uint32_t fromHz, uint32_t stepHz) {
|
||||
SweepStats s;
|
||||
if (!steps) return s;
|
||||
std::vector<int8_t> sorted(dbm, dbm + steps);
|
||||
std::nth_element(sorted.begin(), sorted.begin() + steps / 2, sorted.end());
|
||||
s.floor = sorted[steps / 2];
|
||||
s.top = *std::max_element(dbm, dbm + steps);
|
||||
for (size_t i = 0; i < steps; ++i) {
|
||||
int v = dbm[i];
|
||||
bool localMax = (i == 0 || v >= dbm[i - 1]) && (i + 1 == steps || v > dbm[i + 1]);
|
||||
if (localMax && v >= s.floor + kPeakAboveFloorDb) s.peaks.push_back({fromHz + static_cast<uint32_t>(i) * stepHz, v});
|
||||
}
|
||||
std::stable_sort(s.peaks.begin(), s.peaks.end(), [](const SweepPeak& a, const SweepPeak& b) { return a.dbm > b.dbm; });
|
||||
if (s.peaks.size() > kMaxPeaks) s.peaks.resize(kMaxPeaks);
|
||||
return s;
|
||||
}
|
||||
|
||||
uint8_t heatLevel(int dbm, int low, int high) {
|
||||
if (dbm <= low) return 0;
|
||||
if (dbm >= high) return 255;
|
||||
return static_cast<uint8_t>((dbm - low) * 255 / (high - low) + ((dbm - low) * 255 % (high - low) ? 1 : 0));
|
||||
}
|
||||
|
||||
uint16_t heatColor(uint8_t level) {
|
||||
// Five segments of 51 steps each.
|
||||
auto rgb = [](int r, int g, int b) { return static_cast<uint16_t>((r >> 3) << 11 | (g >> 2) << 5 | (b >> 3)); };
|
||||
int seg = std::min(level / 51, 4), t = (level - seg * 51) * 255 / 51;
|
||||
switch (seg) {
|
||||
case 0: return rgb(0, 0, t); // black to blue
|
||||
case 1: return rgb(0, t, 255); // blue to cyan
|
||||
case 2: return rgb(0, 255, 255 - t); // cyan to green
|
||||
case 3: return rgb(t, 255, 0); // green to yellow
|
||||
default: return rgb(255, 255 - t, 0); // yellow to red
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace roro::lora
|
||||
@@ -0,0 +1,27 @@
|
||||
#pragma once
|
||||
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <vector>
|
||||
|
||||
namespace roro::lora {
|
||||
|
||||
// What a Sweep pass says about the band (M3, Q98): one RSSI reading (dBm) per step.
|
||||
struct SweepPeak {
|
||||
uint32_t hz;
|
||||
int dbm;
|
||||
};
|
||||
struct SweepStats {
|
||||
int floor = 0; // the median: the band's noise floor, whatever a few signals do
|
||||
int top = 0; // the strongest reading
|
||||
std::vector<SweepPeak> peaks; // at most 3, strongest first, each a local maximum >= 10 dB above the floor
|
||||
};
|
||||
|
||||
SweepStats summarize(const int8_t* dbm, size_t steps, uint32_t fromHz, uint32_t stepHz);
|
||||
|
||||
// The waterfall's colours: a reading between `low` and `high` dBm as 0..255, then RGB565 along
|
||||
// black, blue, cyan, green, yellow, red.
|
||||
uint8_t heatLevel(int dbm, int low, int high);
|
||||
uint16_t heatColor(uint8_t level);
|
||||
|
||||
} // namespace roro::lora
|
||||
@@ -0,0 +1,28 @@
|
||||
#include "meshtastic_header.h"
|
||||
|
||||
#include <cstdio>
|
||||
|
||||
namespace roro::meshtastic {
|
||||
|
||||
static uint32_t le32(const uint8_t* p) { return p[0] | p[1] << 8 | p[2] << 16 | static_cast<uint32_t>(p[3]) << 24; }
|
||||
|
||||
bool parseHeader(const uint8_t* data, size_t len, PacketHeader& out) {
|
||||
if (!data || len < kHeaderSize) return false;
|
||||
out.to = le32(data);
|
||||
out.from = le32(data + 4);
|
||||
out.id = le32(data + 8);
|
||||
out.flags = data[12];
|
||||
out.channelHash = data[13];
|
||||
out.nextHop = data[14];
|
||||
out.relayNode = data[15];
|
||||
return true;
|
||||
}
|
||||
|
||||
std::string nodeId(uint32_t node) {
|
||||
if (node == kBroadcast) return "all";
|
||||
char s[10];
|
||||
std::snprintf(s, sizeof s, "!%08x", static_cast<unsigned>(node));
|
||||
return s;
|
||||
}
|
||||
|
||||
} // namespace roro::meshtastic
|
||||
@@ -0,0 +1,36 @@
|
||||
#pragma once
|
||||
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <string>
|
||||
|
||||
namespace roro::meshtastic {
|
||||
|
||||
constexpr uint32_t kBroadcast = 0xFFFFFFFF;
|
||||
|
||||
// The 16 bytes every Meshtastic packet starts with, sent in clear (little-endian). The payload
|
||||
// after it is encrypted with the Channel's key.
|
||||
struct PacketHeader {
|
||||
uint32_t to = 0, from = 0, id = 0;
|
||||
uint8_t flags = 0;
|
||||
uint8_t channelHash = 0; // the Channel's name and key folded into a byte (see channelHash())
|
||||
uint8_t nextHop = 0; // last byte of the Node meant to relay it next; 0 when flooding
|
||||
uint8_t relayNode = 0; // last byte of the Node that relayed it to us
|
||||
|
||||
uint8_t hopLimit() const { return flags & 0x07; }
|
||||
bool wantAck() const { return flags & 0x08; }
|
||||
bool viaMqtt() const { return flags & 0x10; }
|
||||
uint8_t hopStart() const { return flags >> 5; }
|
||||
bool broadcast() const { return to == kBroadcast; }
|
||||
// How many times it was relayed before we heard it; -1 when the sender didn't say (hop start 0).
|
||||
int hopsAway() const { return hopStart() == 0 ? -1 : hopStart() - hopLimit(); }
|
||||
};
|
||||
|
||||
constexpr size_t kHeaderSize = 16;
|
||||
|
||||
bool parseHeader(const uint8_t* data, size_t len, PacketHeader& out);
|
||||
|
||||
// "!12345678", as Meshtastic writes node numbers; "all" for broadcast.
|
||||
std::string nodeId(uint32_t node);
|
||||
|
||||
} // namespace roro::meshtastic
|
||||
@@ -0,0 +1,47 @@
|
||||
#include "meshtastic_presets.h"
|
||||
|
||||
#include <cmath>
|
||||
#include <cstring>
|
||||
|
||||
namespace roro::meshtastic {
|
||||
|
||||
const uint8_t kDefaultKey[16] = {0xd4, 0xf1, 0xbb, 0x3a, 0x20, 0x29, 0x07, 0x59,
|
||||
0xf0, 0xbc, 0xff, 0xab, 0xcf, 0x4e, 0x69, 0x01};
|
||||
|
||||
// firmware src/mesh/MeshRadio.h (modemPresetToParams) and RadioInterface.cpp (PRESETS_EU_868).
|
||||
const Preset kEu868Presets[] = {
|
||||
{"LongFast", 250, 11, 5}, {"LongSlow", 125, 12, 8}, {"MediumSlow", 250, 10, 5}, {"MediumFast", 250, 9, 5},
|
||||
{"ShortSlow", 250, 8, 5}, {"ShortFast", 250, 7, 5}, {"LongMod", 125, 11, 8},
|
||||
};
|
||||
const size_t kEu868PresetCount = sizeof kEu868Presets / sizeof kEu868Presets[0];
|
||||
|
||||
const Preset* findPreset(const char* name) {
|
||||
for (const Preset& p : kEu868Presets)
|
||||
if (std::strcmp(p.name, name) == 0) return &p;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
uint32_t djb2(const char* s) {
|
||||
uint32_t h = 5381;
|
||||
for (; *s; ++s) h = (h << 5) + h + static_cast<unsigned char>(*s);
|
||||
return h;
|
||||
}
|
||||
|
||||
uint8_t channelHash(const char* name, const uint8_t* key, size_t keyLen) {
|
||||
uint8_t h = 0;
|
||||
for (; *name; ++name) h ^= static_cast<uint8_t>(*name);
|
||||
for (size_t i = 0; i < keyLen; ++i) h ^= key[i];
|
||||
return h;
|
||||
}
|
||||
|
||||
uint32_t eu868FrequencyHz(const Preset& preset, const char* channelName) {
|
||||
constexpr double kStartMHz = 869.4, kEndMHz = 869.65;
|
||||
double slotMHz = preset.bwKHz / 1000.0;
|
||||
uint32_t slots = static_cast<uint32_t>(std::lround((kEndMHz - kStartMHz) / slotMHz));
|
||||
const char* name = channelName && *channelName ? channelName : preset.name;
|
||||
uint32_t slot = slots ? djb2(name) % slots : 0;
|
||||
double mhz = kStartMHz + slotMHz / 2 + slot * slotMHz;
|
||||
return static_cast<uint32_t>(std::lround(mhz * 1e6));
|
||||
}
|
||||
|
||||
} // namespace roro::meshtastic
|
||||
@@ -0,0 +1,38 @@
|
||||
#pragma once
|
||||
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
|
||||
namespace roro::meshtastic {
|
||||
|
||||
// Radio settings shared by every Meshtastic preset (firmware src/mesh/RadioInterface.h).
|
||||
constexpr uint8_t kSyncWord = 0x2B;
|
||||
constexpr uint16_t kPreambleLength = 16;
|
||||
|
||||
// The default Channel key ("AQ==", expanded): public, so the default Channel is readable by anyone.
|
||||
extern const uint8_t kDefaultKey[16];
|
||||
|
||||
// A modem preset: bandwidth, spreading factor and coding rate (4/cr). Named as Meshtastic shows them.
|
||||
struct Preset {
|
||||
const char* name;
|
||||
float bwKHz;
|
||||
uint8_t sf;
|
||||
uint8_t cr;
|
||||
};
|
||||
|
||||
// The presets Meshtastic allows in EU_868, its order, LongFast (the default) first.
|
||||
extern const Preset kEu868Presets[];
|
||||
extern const size_t kEu868PresetCount;
|
||||
const Preset* findPreset(const char* name); // nullptr when EU_868 doesn't allow it
|
||||
|
||||
// djb2, as Meshtastic hashes a Channel's name to pick a frequency slot.
|
||||
uint32_t djb2(const char* s);
|
||||
|
||||
// The byte in every packet header naming its Channel: the name's bytes XORed with the key's.
|
||||
uint8_t channelHash(const char* name, const uint8_t* key, size_t keyLen);
|
||||
|
||||
// EU_868 is 869.4 to 869.65 MHz: the slot comes from the Channel's name (the preset's name for
|
||||
// an unnamed Channel, which is the default).
|
||||
uint32_t eu868FrequencyHz(const Preset& preset, const char* channelName = nullptr);
|
||||
|
||||
} // namespace roro::meshtastic
|
||||
@@ -94,6 +94,11 @@ void FileReceiver::chunkWritten(bool ok, uint32_t nowMs) {
|
||||
state_ = received_ == size_ ? State::Finishing : State::Receiving;
|
||||
}
|
||||
|
||||
void FileReceiver::cardChecked(const uint8_t digest[32]) {
|
||||
if (state_ != State::Finishing) return;
|
||||
if (std::memcmp(digest, expected_, sizeof expected_) != 0) fail("the copy on the card differs");
|
||||
}
|
||||
|
||||
void FileReceiver::finished(bool ok) {
|
||||
if (state_ != State::Finishing) return;
|
||||
if (!ok) return fail("rename failed");
|
||||
|
||||
@@ -34,6 +34,9 @@ class FileReceiver {
|
||||
// Takes bytes for the current chunk; returns how many were used (none while a chunk waits).
|
||||
size_t feed(const uint8_t* data, size_t len, uint32_t nowMs);
|
||||
void chunkWritten(bool ok, uint32_t nowMs);
|
||||
// While Finishing: the SHA-256 of the file as read back from the card. The checksum on the
|
||||
// received bytes doesn't prove the card kept them (a failed write can lose buffered data).
|
||||
void cardChecked(const uint8_t digest[32]);
|
||||
void finished(bool ok);
|
||||
void tick(uint32_t nowMs);
|
||||
void reset() { *this = FileReceiver(); }
|
||||
|
||||
@@ -31,6 +31,7 @@ const Definition kDefinitions[] = {
|
||||
{"wifi_on", Kind::Bool, 1, nullptr, 0, 1},
|
||||
{"gnss_on", Kind::Bool, 1, nullptr, 0, 1},
|
||||
{"coord_dms", Kind::Bool, 0, nullptr, 0, 1},
|
||||
{"lora_preset", Kind::Int, 0, nullptr, 0, 6}, // LongFast first
|
||||
};
|
||||
static_assert(sizeof(kDefinitions) / sizeof(kDefinitions[0]) == static_cast<size_t>(Setting::Count),
|
||||
"every Setting needs a definition");
|
||||
|
||||
@@ -23,6 +23,7 @@ enum class Setting : uint8_t {
|
||||
WifiEnabled, // bool: the Wi-Fi Service stays Connected when a Saved Network is in range
|
||||
GnssEnabled, // bool: the GNSS Service reads the receiver (M2, Q58)
|
||||
CoordinatesDms, // bool: show degrees, minutes and seconds instead of decimal degrees (Q64)
|
||||
LoraPreset, // int: the LoRa Scanner's Meshtastic preset, an index into the EU868 list (M3, Q95)
|
||||
Count
|
||||
};
|
||||
|
||||
|
||||
@@ -20,6 +20,7 @@ inline const CleanupCategory kCleanupCategories[] = {
|
||||
{"IRC logs", "/irc"},
|
||||
{"Wi-Fi scan logs", "/wifi/scans"},
|
||||
{"Wi-Fi captures", "/captures/wifi"},
|
||||
{"LoRa captures", "/captures/lora"},
|
||||
{"GNSS tracks", "/gnss/tracks"},
|
||||
};
|
||||
|
||||
|
||||
@@ -19,6 +19,7 @@ build_flags =
|
||||
-DARDUINO_USB_MODE=1
|
||||
lib_deps =
|
||||
m5stack/M5Cardputer @ 1.1.1
|
||||
jgromes/RadioLib @ 7.8.1
|
||||
test_ignore = *
|
||||
; Smaller TLS buffers (M2): the framework is rebuilt with these settings (pioarduino "hybrid
|
||||
; compile"). Receive stays 16 KB (servers send full TLS records); send drops to 4 KB (IRC lines are
|
||||
|
||||
@@ -103,8 +103,11 @@ void GeminiApp::show(GeminiPage&& page) {
|
||||
}
|
||||
|
||||
void GeminiApp::analyse() {
|
||||
types_.clear();
|
||||
links_.clear();
|
||||
// Sized exactly: the Service budgeted these bytes per line (kBytesPerLine), growth by
|
||||
// doubling would take up to twice that.
|
||||
std::vector<uint8_t>().swap(types_);
|
||||
std::vector<uint32_t>().swap(links_);
|
||||
types_.reserve(page_.text.lineCount());
|
||||
// A window may start inside a preformatted block: the index says (bit 31).
|
||||
size_t entry = page_.windowStart / GeminiService::kIndexEvery;
|
||||
bool pre = page_.windowed && entry < page_.lineIndex.size() && (page_.lineIndex[entry] & 0x80000000u);
|
||||
@@ -114,6 +117,7 @@ void GeminiApp::analyse() {
|
||||
types_.push_back(static_cast<uint8_t>(t));
|
||||
if (t == LineType::Link) links_.push_back(i);
|
||||
}
|
||||
links_.shrink_to_fit();
|
||||
layoutDirty_ = true;
|
||||
requestRedraw();
|
||||
}
|
||||
|
||||
@@ -0,0 +1,340 @@
|
||||
#include "lora_scanner_app.h"
|
||||
|
||||
#include <Arduino.h>
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstdio>
|
||||
#include <ctime>
|
||||
|
||||
#include "meshtastic_presets.h"
|
||||
#include "packet_view.h"
|
||||
#include "sweep_view.h"
|
||||
#include "ui/canvas.h"
|
||||
#include "ui/fonts.h"
|
||||
#include "ui/widgets.h"
|
||||
|
||||
namespace roro {
|
||||
|
||||
namespace {
|
||||
constexpr uint32_t kMessageMs = 4000;
|
||||
}
|
||||
|
||||
void LoraScannerApp::onEnter() {
|
||||
int i = std::clamp<int>(settings_.getInt(Setting::LoraPreset), 0, meshtastic::kEu868PresetCount - 1);
|
||||
const meshtastic::Preset& p = meshtastic::kEu868Presets[i];
|
||||
if (std::string(radio_.config().name) != p.name) radio_.setPreset(p);
|
||||
radio_.listen(RadioService::App, true);
|
||||
view_ = View::Packets;
|
||||
selectedSeq_ = 0;
|
||||
followNewest_ = true;
|
||||
shownSeq_ = 0;
|
||||
requestRedraw();
|
||||
}
|
||||
|
||||
void LoraScannerApp::onExit() {
|
||||
showSweep(false);
|
||||
radio_.listen(RadioService::App, false);
|
||||
}
|
||||
|
||||
void LoraScannerApp::showSweep(bool on) {
|
||||
if (on == (view_ == View::Sweep)) return;
|
||||
radio_.sweep(on);
|
||||
view_ = on ? View::Sweep : View::Packets;
|
||||
peak_.clear();
|
||||
std::vector<int8_t>().swap(waterfall_); // its memory only while shown
|
||||
sweepSteps_ = 0;
|
||||
shownSweep_ = radio_.sweeps();
|
||||
requestRedraw();
|
||||
}
|
||||
|
||||
bool LoraScannerApp::meshtasticSettings() const { return radio_.config().syncWord == meshtastic::kSyncWord; }
|
||||
|
||||
void LoraScannerApp::say(const std::string& text) {
|
||||
message_ = text;
|
||||
messageMs_ = millis();
|
||||
requestRedraw();
|
||||
}
|
||||
|
||||
bool LoraScannerApp::onKey(const KeyEvent& e) {
|
||||
if (e.key == Key::Tab && (view_ == View::Packets || view_ == View::Sweep)) {
|
||||
showSweep(view_ == View::Packets);
|
||||
return true;
|
||||
}
|
||||
if (view_ == View::Sweep) {
|
||||
if (e.key == Key::Back) {
|
||||
showSweep(false);
|
||||
return true;
|
||||
}
|
||||
return e.key != Key::Home; // everything else stays here
|
||||
}
|
||||
if (view_ == View::Details) {
|
||||
int last = std::max<int>(0, static_cast<int>(details_.size()) - 8);
|
||||
if (e.key == Key::Up) detailsTop_ = std::max(0, detailsTop_ - 1);
|
||||
else if (e.key == Key::Down) detailsTop_ = std::min(last, detailsTop_ + 1);
|
||||
else if (e.key == Key::Back || e.key == Key::Select) view_ = View::Packets;
|
||||
else return true;
|
||||
requestRedraw();
|
||||
return true;
|
||||
}
|
||||
if (view_ == View::Presets) {
|
||||
if (e.key == Key::Up) presets_.up();
|
||||
else if (e.key == Key::Down) presets_.down();
|
||||
else if (e.key == Key::Select) {
|
||||
int i = presets_.selected();
|
||||
settings_.setInt(Setting::LoraPreset, i);
|
||||
radio_.setPreset(meshtastic::kEu868Presets[i]);
|
||||
say(std::string("Listening on ") + meshtastic::kEu868Presets[i].name);
|
||||
view_ = View::Packets;
|
||||
} else if (e.key == Key::Back) view_ = View::Packets;
|
||||
else return true;
|
||||
requestRedraw();
|
||||
return true;
|
||||
}
|
||||
// The packet list.
|
||||
if (e.key == Key::Up || e.key == Key::Down) {
|
||||
e.key == Key::Up ? packets_.up() : packets_.down();
|
||||
selectedSeq_ = packets_.selected() >= 0 ? radio_.received() - packets_.selected() : 0;
|
||||
followNewest_ = packets_.selected() <= 0;
|
||||
requestRedraw();
|
||||
return true;
|
||||
}
|
||||
if (e.key == Key::Select) {
|
||||
openDetails();
|
||||
return true;
|
||||
}
|
||||
if (e.key == Key::Char && (e.ch == 'p' || e.ch == 'P')) {
|
||||
presets_.setCount(meshtastic::kEu868PresetCount);
|
||||
presets_.select(settings_.getInt(Setting::LoraPreset));
|
||||
view_ = View::Presets;
|
||||
requestRedraw();
|
||||
return true;
|
||||
}
|
||||
if (e.key == Key::Char && (e.ch == 'c' || e.ch == 'C')) {
|
||||
if (capture_.capturing()) capture_.stop();
|
||||
else {
|
||||
std::string why = capture_.start(millis());
|
||||
if (!why.empty()) say(why);
|
||||
}
|
||||
requestRedraw();
|
||||
return true;
|
||||
}
|
||||
return false; // Back leaves the App
|
||||
}
|
||||
|
||||
void LoraScannerApp::openDetails() {
|
||||
RadioPacket p;
|
||||
if (!selectedSeq_ || !radio_.packet(selectedSeq_, p)) return say("That packet has left the list");
|
||||
details_.clear();
|
||||
char line[64];
|
||||
std::snprintf(line, sizeof line, "%s, %u bytes%s", timeOf(p).c_str(), p.len, p.crcOk ? "" : ", bad CRC");
|
||||
details_.push_back(line);
|
||||
std::snprintf(line, sizeof line, "%.0f dBm, SNR %.1f dB, noise %.0f", p.rx.rssi, p.rx.snr, p.rx.noiseFloor);
|
||||
details_.push_back(line);
|
||||
std::snprintf(line, sizeof line, "%.4f MHz, off by %.0f Hz", p.rx.frequencyHz / 1e6, p.frequencyError);
|
||||
details_.push_back(line);
|
||||
if (meshtasticSettings())
|
||||
for (auto& l : lora::headerLines(p.data, p.len)) details_.push_back(l);
|
||||
for (auto& l : lora::hexDump(p.data, p.len)) details_.push_back(l);
|
||||
detailsTop_ = 0;
|
||||
view_ = View::Details;
|
||||
requestRedraw();
|
||||
}
|
||||
|
||||
std::string LoraScannerApp::timeOf(const RadioPacket& p) const {
|
||||
int64_t now = clock_.utcNow();
|
||||
if (now < 0) { // no Clock yet: how long ago
|
||||
char ago[16];
|
||||
std::snprintf(ago, sizeof ago, "-%lus", (unsigned long)((millis() - p.ms) / 1000));
|
||||
return ago;
|
||||
}
|
||||
time_t t = static_cast<time_t>(now - static_cast<int64_t>((millis() - p.ms) / 1000));
|
||||
struct tm local;
|
||||
localtime_r(&t, &local);
|
||||
char buf[12];
|
||||
std::snprintf(buf, sizeof buf, "%02d:%02d:%02d", local.tm_hour, local.tm_min, local.tm_sec);
|
||||
return buf;
|
||||
}
|
||||
|
||||
void LoraScannerApp::update(uint32_t nowMs) {
|
||||
if (view_ == View::Sweep) {
|
||||
if (radio_.sweeps() != shownSweep_) requestRedraw();
|
||||
return;
|
||||
}
|
||||
if (radio_.received() != shownSeq_ || nowMs - lastDrawMs_ >= 1000 ||
|
||||
(!message_.empty() && nowMs - messageMs_ >= kMessageMs))
|
||||
requestRedraw();
|
||||
}
|
||||
|
||||
void LoraScannerApp::draw(Canvas& c) {
|
||||
lastDrawMs_ = millis();
|
||||
c.setTextDatum(top_left);
|
||||
if (!radio_.present()) {
|
||||
c.setFont(&fonts::bold);
|
||||
c.setTextColor(theme::kWarning);
|
||||
c.drawString("No LoRa radio found", 4, theme::kContent.y + 4);
|
||||
c.setFont(&fonts::body);
|
||||
c.setTextColor(theme::kMuted);
|
||||
c.drawString("Is the Cap LoRa-1262 attached?", 4, theme::kContent.y + 22);
|
||||
return;
|
||||
}
|
||||
switch (view_) {
|
||||
case View::Packets: drawPackets(c); break;
|
||||
case View::Details: drawDetails(c); break;
|
||||
case View::Presets: drawPresets(c); break;
|
||||
case View::Sweep: drawSweep(c); break;
|
||||
}
|
||||
}
|
||||
|
||||
void LoraScannerApp::drawPackets(Canvas& c) {
|
||||
const auto& area = theme::kContent;
|
||||
RadioService::Config cfg = radio_.config();
|
||||
uint32_t newest = radio_.received();
|
||||
shownSeq_ = newest;
|
||||
|
||||
// What it's listening to, and the noise floor.
|
||||
char head[64];
|
||||
std::snprintf(head, sizeof head, "%s %.3f MHz, noise %.0f", cfg.name, cfg.frequencyHz / 1e6, radio_.noiseFloor());
|
||||
c.setFont(&fonts::small);
|
||||
c.setTextColor(radio_.listening() ? theme::kMuted : theme::kWarning);
|
||||
c.drawString(radio_.listening() ? head : "Starting the radio...", 4, area.y + 2);
|
||||
if (capture_.capturing()) {
|
||||
c.setTextDatum(top_right);
|
||||
c.setTextColor(theme::kWarning);
|
||||
c.drawString(("CAP " + std::to_string(capture_.packets())).c_str(), area.w - 3, area.y + 2);
|
||||
c.setTextDatum(top_left);
|
||||
}
|
||||
|
||||
// The list, newest first; the selection stays on its packet as new ones arrive.
|
||||
int count = static_cast<int>(radio_.available());
|
||||
packets_.setCount(count);
|
||||
if (!followNewest_ && selectedSeq_ && newest >= selectedSeq_ && newest - selectedSeq_ < static_cast<uint32_t>(count))
|
||||
packets_.select(static_cast<int>(newest - selectedSeq_));
|
||||
else if (count > 0) {
|
||||
followNewest_ = true;
|
||||
packets_.select(0);
|
||||
selectedSeq_ = newest;
|
||||
}
|
||||
theme::Rect list{area.x, area.y + 12, area.w, kListRows * theme::kLineHeight};
|
||||
if (count == 0) {
|
||||
c.setFont(&fonts::body);
|
||||
c.setTextColor(theme::kMuted);
|
||||
c.drawString("No packets yet.", 4, list.y + 4);
|
||||
c.drawString(meshtasticSettings() ? "Meshtastic nodes in range show here." : "Custom settings.", 4,
|
||||
list.y + 4 + theme::kLineHeight);
|
||||
} else {
|
||||
bool mesh = meshtasticSettings();
|
||||
widgets::list(c, packets_, list, [&](int i) {
|
||||
RadioPacket p;
|
||||
if (!radio_.packet(newest - i, p)) return std::string("(gone)");
|
||||
return lora::row({p.data, p.len, p.rx.rssi, p.rx.snr, p.crcOk, mesh}, timeOf(p));
|
||||
});
|
||||
}
|
||||
|
||||
// Footer: a message for a few seconds, or the keys.
|
||||
c.setFont(&fonts::small);
|
||||
bool showMessage = !message_.empty() && millis() - messageMs_ < kMessageMs;
|
||||
c.setTextColor(showMessage ? theme::kWarning : theme::kMuted);
|
||||
std::string keys = std::string("Enter: details p: preset Tab: sweep c: ") + (capture_.capturing() ? "stop" : "capture");
|
||||
c.drawString(showMessage ? message_.c_str() : keys.c_str(), 4, area.y + area.h - 9);
|
||||
}
|
||||
|
||||
void LoraScannerApp::drawDetails(Canvas& c) {
|
||||
const auto& area = theme::kContent;
|
||||
widgets::textLines(c, details_, detailsTop_, {area.x + 2, area.y + 2, area.w - 2, area.h - 2});
|
||||
}
|
||||
|
||||
void LoraScannerApp::drawPresets(Canvas& c) {
|
||||
const auto& area = theme::kContent;
|
||||
c.setFont(&fonts::small);
|
||||
c.setTextColor(theme::kMuted);
|
||||
c.drawString("Meshtastic presets allowed in EU868", 4, area.y + 2);
|
||||
widgets::list(
|
||||
c, presets_, {area.x, area.y + 12, area.w, (kListRows + 1) * theme::kLineHeight},
|
||||
[](int i) { return std::string(meshtastic::kEu868Presets[i].name); },
|
||||
[](int i) {
|
||||
char v[24];
|
||||
const auto& p = meshtastic::kEu868Presets[i];
|
||||
std::snprintf(v, sizeof v, "SF%u %.0fk %.3f", p.sf, p.bwKHz, meshtastic::eu868FrequencyHz(p) / 1e6);
|
||||
return std::string(v);
|
||||
});
|
||||
}
|
||||
|
||||
} // namespace roro
|
||||
|
||||
namespace roro {
|
||||
|
||||
// Sweep (Q98): bars of the latest pass with peak hold, the waterfall underneath (newest at the
|
||||
// top), and where the Sniffer's preset sits in the band.
|
||||
void LoraScannerApp::drawSweep(Canvas& c) {
|
||||
const auto& area = theme::kContent;
|
||||
constexpr int kLow = -120, kHigh = -60; // the scale, dBm: about the chip's floor to a near signal
|
||||
SweepFrame f;
|
||||
bool have = radio_.sweepFrame(f) && f.seq != 0;
|
||||
c.setFont(&fonts::small);
|
||||
c.setTextColor(theme::kMuted);
|
||||
c.drawString("Sweep, the Sniffer is paused", 4, area.y + 2);
|
||||
if (!have) {
|
||||
c.drawString("Measuring...", 4, area.y + 20);
|
||||
return;
|
||||
}
|
||||
// Keep peak hold and the waterfall for this band.
|
||||
if (f.steps != sweepSteps_) {
|
||||
sweepSteps_ = f.steps;
|
||||
peak_.assign(f.steps, -127);
|
||||
waterfall_.assign(static_cast<size_t>(kWaterfallRows) * f.steps, -127);
|
||||
}
|
||||
if (f.seq != shownSweep_) {
|
||||
shownSweep_ = f.seq;
|
||||
for (uint16_t i = 0; i < f.steps; ++i) peak_[i] = std::max(peak_[i], f.dbm[i]);
|
||||
std::copy_backward(waterfall_.begin(), waterfall_.end() - f.steps, waterfall_.end());
|
||||
std::copy(f.dbm, f.dbm + f.steps, waterfall_.begin());
|
||||
}
|
||||
|
||||
// Layout: up to 3 px a step, left-aligned after the scale.
|
||||
int x0 = 26, cell = std::max(1, std::min(3, (area.w - x0 - 2) / std::max<int>(1, f.steps)));
|
||||
int barTop = area.y + 12, barH = 46, barBottom = barTop + barH;
|
||||
auto height = [&](int dbm) { return std::clamp((dbm - kLow) * barH / (kHigh - kLow), 0, barH); };
|
||||
c.setTextColor(theme::kMuted);
|
||||
c.drawString("-60", 2, barTop - 1);
|
||||
c.drawString("-120", 0, barBottom - 7);
|
||||
for (uint16_t i = 0; i < f.steps; ++i) {
|
||||
int x = x0 + i * cell, h = height(f.dbm[i]);
|
||||
if (h > 0) c.fillRect(x, barBottom - h, std::max(1, cell - 1), h, theme::kAccent);
|
||||
int ph = height(peak_[i]);
|
||||
if (ph > 0) c.drawFastHLine(x, barBottom - ph, std::max(1, cell - 1), theme::kText);
|
||||
}
|
||||
// The Sniffer's frequency, when it's in the band.
|
||||
uint32_t hz = radio_.config().frequencyHz;
|
||||
if (hz >= f.fromHz && hz <= f.fromHz + (f.steps - 1) * f.stepHz) {
|
||||
int x = x0 + static_cast<int>((hz - f.fromHz) / f.stepHz) * cell + cell / 2;
|
||||
for (int y = barTop; y < barBottom; y += 3) c.drawPixel(x, y, theme::kMessage);
|
||||
}
|
||||
|
||||
// The waterfall.
|
||||
int wfTop = barBottom + 2;
|
||||
for (int r = 0; r < kWaterfallRows; ++r)
|
||||
for (uint16_t i = 0; i < f.steps; ++i) {
|
||||
int8_t v = waterfall_[static_cast<size_t>(r) * f.steps + i];
|
||||
if (v > -127) c.fillRect(x0 + i * cell, wfTop + r, cell, 1, lora::heatColor(lora::heatLevel(v, kLow, kHigh)));
|
||||
}
|
||||
|
||||
// The band's edges, its floor and its strongest signal.
|
||||
lora::SweepStats st = lora::summarize(f.dbm, f.steps, f.fromHz, f.stepHz);
|
||||
char line[64];
|
||||
int y = area.y + area.h - 9;
|
||||
std::snprintf(line, sizeof line, "%.1f", f.fromHz / 1e6);
|
||||
c.drawString(line, x0, wfTop + kWaterfallRows + 1);
|
||||
std::snprintf(line, sizeof line, "%.1f MHz", (f.fromHz + (f.steps - 1) * f.stepHz) / 1e6);
|
||||
c.setTextDatum(top_right);
|
||||
c.drawString(line, x0 + f.steps * cell, wfTop + kWaterfallRows + 1);
|
||||
c.setTextDatum(top_left);
|
||||
if (st.peaks.empty())
|
||||
std::snprintf(line, sizeof line, "floor %d dBm, nothing above it Tab: sniffer", st.floor);
|
||||
else
|
||||
std::snprintf(line, sizeof line, "floor %d, %.1f MHz at %d dBm Tab: sniffer", st.floor, st.peaks[0].hz / 1e6,
|
||||
st.peaks[0].dbm);
|
||||
c.setTextColor(theme::kMuted);
|
||||
c.drawString(line, 4, y);
|
||||
}
|
||||
|
||||
} // namespace roro
|
||||
@@ -0,0 +1,67 @@
|
||||
#pragma once
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "app.h"
|
||||
#include "list_model.h"
|
||||
#include "services/clock_service.h"
|
||||
#include "services/lora_capture_service.h"
|
||||
#include "services/radio_service.h"
|
||||
#include "settings.h"
|
||||
#include "ui/theme.h"
|
||||
|
||||
namespace roro {
|
||||
|
||||
// The LoRa Scanner (docs/milestones/M3.md). Sniffer: the packets the radio hears, newest first,
|
||||
// with the Meshtastic header read (Q96) and a hex dump on Enter; p picks the preset (Q95), c starts
|
||||
// or stops a Capture (Q97). The radio listens while the App is open (Q100). Tab: Sweep, the band's
|
||||
// RSSI as bars with peak hold and a waterfall (Q98); it pauses the Sniffer while shown (Q99).
|
||||
class LoraScannerApp : public App {
|
||||
public:
|
||||
LoraScannerApp(RadioService& radio, LoraCaptureService& capture, Settings& settings, ClockService& clock)
|
||||
: radio_(radio), capture_(capture), settings_(settings), clock_(clock) {}
|
||||
void onEnter() override;
|
||||
void onExit() override;
|
||||
bool onKey(const KeyEvent& e) override;
|
||||
void update(uint32_t nowMs) override;
|
||||
void draw(Canvas& c) override;
|
||||
|
||||
private:
|
||||
enum class View { Packets, Details, Presets, Sweep };
|
||||
static constexpr int kListRows = 7;
|
||||
|
||||
void drawPackets(Canvas& c);
|
||||
void drawDetails(Canvas& c);
|
||||
void drawPresets(Canvas& c);
|
||||
void drawSweep(Canvas& c);
|
||||
void showSweep(bool on);
|
||||
void openDetails();
|
||||
std::string timeOf(const RadioPacket& p) const;
|
||||
bool meshtasticSettings() const;
|
||||
void say(const std::string& text); // a line in the footer for a few seconds
|
||||
|
||||
RadioService& radio_;
|
||||
LoraCaptureService& capture_;
|
||||
Settings& settings_;
|
||||
ClockService& clock_;
|
||||
View view_ = View::Packets;
|
||||
ListModel packets_{kListRows};
|
||||
ListModel presets_{kListRows + 1};
|
||||
uint32_t shownSeq_ = 0; // the newest packet at the last redraw
|
||||
uint32_t selectedSeq_ = 0; // what the selection points at, kept as packets arrive
|
||||
bool followNewest_ = true; // until the user moves the selection off the top
|
||||
std::vector<std::string> details_;
|
||||
int detailsTop_ = 0;
|
||||
uint32_t lastDrawMs_ = 0;
|
||||
std::string message_;
|
||||
uint32_t messageMs_ = 0;
|
||||
// Sweep, only while shown: peak hold per step, and the waterfall, newest row first.
|
||||
static constexpr int kWaterfallRows = 36;
|
||||
uint32_t shownSweep_ = 0;
|
||||
std::vector<int8_t> peak_;
|
||||
std::vector<int8_t> waterfall_; // kWaterfallRows x steps
|
||||
uint16_t sweepSteps_ = 0;
|
||||
};
|
||||
|
||||
} // namespace roro
|
||||
@@ -12,6 +12,7 @@
|
||||
#include "apps/gnss_app.h"
|
||||
#include "apps/irc_app.h"
|
||||
#include "apps/launcher_app.h"
|
||||
#include "apps/lora_scanner_app.h"
|
||||
#include "apps/settings_app.h"
|
||||
#include "apps/wifi_tools_app.h"
|
||||
#include "apps/setup_app.h"
|
||||
@@ -31,6 +32,8 @@
|
||||
#include "services/gemini_service.h"
|
||||
#include "services/gnss_service.h"
|
||||
#include "services/power_service.h"
|
||||
#include "services/lora_capture_service.h"
|
||||
#include "services/radio_service.h"
|
||||
#include "services/storage_service.h"
|
||||
#include "services/update_service.h"
|
||||
#include "services/wifi_service.h"
|
||||
@@ -56,6 +59,8 @@ static StorageService* storageService;
|
||||
static PowerService* power;
|
||||
static ClockService* clockService;
|
||||
static GnssService* gnssService;
|
||||
static RadioService* radioService;
|
||||
static LoraCaptureService* loraCapture;
|
||||
static GeminiService* geminiService;
|
||||
static SavedNetworks* savedNetworks;
|
||||
static WifiService* wifi;
|
||||
@@ -104,6 +109,12 @@ static StatusInfo currentStatus() {
|
||||
s.gnssSatellites = g.satellitesUsed;
|
||||
s.tracking = gnssService->tracking();
|
||||
}
|
||||
if (radioService && radioService->sweeping()) s.radio = StatusInfo::Radio::Sweep;
|
||||
else if (radioService && radioService->listening()) {
|
||||
uint32_t last = radioService->lastPacketMs();
|
||||
s.radio = last && millis() - last < 400 ? StatusInfo::Radio::Packet : StatusInfo::Radio::Listening;
|
||||
}
|
||||
s.capturing = loraCapture && loraCapture->capturing();
|
||||
using WifiState = WifiController::State;
|
||||
switch (wifi->state()) {
|
||||
case WifiState::Connected: {
|
||||
@@ -150,6 +161,7 @@ void setup() {
|
||||
clockService = new ClockService(settings, bus);
|
||||
geminiService = new GeminiService(nvs, *storageService, *clockService, bus);
|
||||
gnssService = new GnssService(settings, *clockService, *storageService, bus);
|
||||
radioService = new RadioService();
|
||||
savedNetworks = new SavedNetworks(nvs);
|
||||
savedNetworks->load();
|
||||
wifi = new WifiService(settings, *savedNetworks, *clockService);
|
||||
@@ -161,6 +173,9 @@ void setup() {
|
||||
services.add(*clockService);
|
||||
services.add(*battery);
|
||||
services.add(*gnssService);
|
||||
services.add(*radioService);
|
||||
loraCapture = new LoraCaptureService(*radioService, *storageService, *clockService, bus);
|
||||
services.add(*loraCapture);
|
||||
services.add(*storageService);
|
||||
services.add(*wifi);
|
||||
services.add(*irc);
|
||||
@@ -176,6 +191,7 @@ void setup() {
|
||||
apps->registerApp({"wifi-tools", "Wi-Fi Tools", false, new WifiToolsApp(*wifi, *storageService, *clockService)});
|
||||
apps->registerApp({"gnss", "GNSS", false, new GnssApp(*gnssService, settings)});
|
||||
apps->registerApp({"gemini", "Gemini", false, new GeminiApp(*geminiService)});
|
||||
apps->registerApp({"lora", "LoRa Scanner", false, new LoraScannerApp(*radioService, *loraCapture, settings, *clockService)});
|
||||
apps->registerApp({"settings", "Settings", false,
|
||||
new SettingsApp({settings, bus, *apps, *battery, *storageService, *clockService, *wifi, *savedNetworks, *update})});
|
||||
apps->registerApp({"demo", "Widget demo", true, new DemoApp(bus)});
|
||||
@@ -347,6 +363,10 @@ static const char* const kHelp =
|
||||
"reboot restart\n"
|
||||
"boot other restart into the other app slot (manual Rollback)\n"
|
||||
"log level <0-5> ESP-IDF log level (0 none ... 5 verbose)\n"
|
||||
"lora probe | lora status | lora rx on|off | lora preset <name> the LoRa radio, receive only\n"
|
||||
"lora capture start|stop a LoRa Capture to /captures/lora (pcap, LoRaTap)\n"
|
||||
"lora sweep on [from MHz] [to MHz] [step kHz] | off | dump RSSI across a band (863 870 100)\n"
|
||||
"lora custom <MHz> <BW kHz> <SF> <CR 5-8> <sync hex> [preamble] e.g. 868.1 125 7 5 34 8 (LoRaWAN)\n"
|
||||
"gnss status | gnss restart | gnss track start|stop | gnss nmea on|off | gnss send <sentence without $ and checksum>\n"
|
||||
"crash the last crash: firmware, reason, task, backtrace\n"
|
||||
"coredump erase forget the core dump in flash\n"
|
||||
@@ -358,6 +378,7 @@ static const char* const kHelp =
|
||||
"sd list | cat <path> | log <text> | burst | sound on|off | short | normal\n"
|
||||
#ifdef RORO_DEBUG
|
||||
"crash abort|wdt crash on purpose (to test crash reports and Safe Mode)\n"
|
||||
"lora inject <hex> [rssi] [snr] a packet into the LoRa Scanner as if received (nothing is sent)\n"
|
||||
"coredump get (Debug Console only) send the raw core dump: use scripts/rdbg.py coredump\n"
|
||||
"reset (Debug Console only) restart at once, even if the main loop is stuck\n"
|
||||
"get <path> | put <path> <size> <sha256> | screenshot (Debug Console only) binary, see rdbg.py\n"
|
||||
@@ -410,6 +431,56 @@ static void runCommand(String line) {
|
||||
});
|
||||
}
|
||||
if (line.startsWith("install ")) update->installFromSd(line.substring(8).c_str()); // Update from SD
|
||||
if (line == "lora probe" && radioService) radioService->probe(console);
|
||||
if (line == "lora status" && radioService) radioService->printStatus(console);
|
||||
if ((line == "lora rx on" || line == "lora rx off") && radioService) radioService->setEcho(line.endsWith("on"));
|
||||
if (line.startsWith("lora sweep") && radioService) { // on [from MHz] [to MHz] [step kHz] | off | dump
|
||||
if (line == "lora sweep dump") radioService->printSweep(console);
|
||||
else if (line == "lora sweep off") {
|
||||
radioService->setSweepEcho(false);
|
||||
radioService->sweep(false);
|
||||
} else if (line.startsWith("lora sweep on")) {
|
||||
double from = 863, to = 870, step = 100;
|
||||
sscanf(line.c_str() + 13, "%lf %lf %lf", &from, &to, &step);
|
||||
radioService->setSweepEcho(true);
|
||||
radioService->sweep(true, from * 1e6 + 0.5, to * 1e6 + 0.5, step * 1e3 + 0.5);
|
||||
}
|
||||
}
|
||||
if (line == "lora capture start" && loraCapture) {
|
||||
std::string why = loraCapture->start(millis());
|
||||
console.printf("lora capture: %s\n", why.empty() ? loraCapture->path().c_str() : why.c_str());
|
||||
}
|
||||
if (line == "lora capture stop" && loraCapture) loraCapture->stop();
|
||||
#ifdef RORO_DEBUG
|
||||
if (line.startsWith("lora inject ") && radioService) { // <hex> [rssi] [snr]: as if received
|
||||
String hex = line.substring(12);
|
||||
int space = hex.indexOf(' ');
|
||||
float rssi = -100, snr = 5;
|
||||
if (space > 0) sscanf(hex.c_str() + space + 1, "%f %f", &rssi, &snr), hex = hex.substring(0, space);
|
||||
uint8_t data[255];
|
||||
size_t n = 0;
|
||||
for (size_t i = 0; i + 1 < hex.length() && n < sizeof data; i += 2) data[n++] = strtoul(hex.substring(i, i + 2).c_str(), nullptr, 16);
|
||||
radioService->inject(data, n, rssi, snr);
|
||||
}
|
||||
#endif
|
||||
if (line.startsWith("lora custom ") && radioService) {
|
||||
double mhz = 0, bw = 0;
|
||||
unsigned sf = 0, cr = 0, sync = 0, preamble = 8;
|
||||
int n = sscanf(line.c_str() + 12, "%lf %lf %u %u %x %u", &mhz, &bw, &sf, &cr, &sync, &preamble);
|
||||
// Inside what the Cap's SX1262 tunes (868 to 923 MHz) and LoRa's own limits.
|
||||
if (n < 5 || mhz < 863 || mhz > 928 || bw < 7 || bw > 500 || sf < 5 || sf > 12 || cr < 5 || cr > 8 || sync > 0xFF)
|
||||
console.println("lora custom: usage: lora custom <MHz> <BW kHz> <SF 5-12> <CR 5-8> <sync hex> [preamble]");
|
||||
else {
|
||||
radioService->setConfig({static_cast<uint32_t>(mhz * 1e6 + 0.5), static_cast<float>(bw), static_cast<uint8_t>(sf),
|
||||
static_cast<uint8_t>(cr), static_cast<uint8_t>(sync), static_cast<uint16_t>(preamble), "Custom"});
|
||||
console.printf("lora custom: %.3f MHz, BW %.1f kHz, SF %u, CR 4/%u, sync 0x%02X, preamble %u\n", mhz, bw, sf, cr, sync, preamble);
|
||||
}
|
||||
}
|
||||
if (line.startsWith("lora preset ") && radioService) {
|
||||
const meshtastic::Preset* p = meshtastic::findPreset(line.substring(12).c_str());
|
||||
if (p) radioService->setPreset(*p);
|
||||
console.printf("lora preset: %s\n", p ? p->name : "unknown (LongFast LongSlow MediumSlow MediumFast ShortSlow ShortFast LongMod)");
|
||||
}
|
||||
if (line == "gnss status" && gnssService) gnssService->printStatus(console, millis());
|
||||
if ((line == "gnss nmea on" || line == "gnss nmea off") && gnssService) gnssService->setEcho(line.endsWith("on"));
|
||||
if (line == "gnss restart" && gnssService) gnssService->restart(millis());
|
||||
|
||||
@@ -14,4 +14,9 @@ constexpr int kSpiMosi = 14;
|
||||
constexpr int kSdCs = 12;
|
||||
constexpr int kLoraCs = 5;
|
||||
|
||||
// The SX1262 on the Cap (as in Meshtastic's board file for the Cardputer ADV).
|
||||
constexpr int kLoraReset = 3;
|
||||
constexpr int kLoraIrq = 4; // DIO1
|
||||
constexpr int kLoraBusy = 6;
|
||||
|
||||
} // namespace roro::pins
|
||||
|
||||
@@ -15,6 +15,7 @@
|
||||
#include <memory>
|
||||
|
||||
#include "file_receiver.h"
|
||||
#include "sha256.h"
|
||||
#include "platform/console.h"
|
||||
#include "version.h"
|
||||
|
||||
@@ -233,11 +234,20 @@ void DebugConsole::put(NetworkClient& client, const std::string& args) {
|
||||
const auto& c = r.chunk();
|
||||
bool ok = f.write(c.data(), c.size()) == c.size();
|
||||
// A card can fail one write and take the next. FATFS keeps a failed file in error,
|
||||
// so: close, cut back to the last good byte, reopen, try again.
|
||||
// so: close, cut back to the last good byte, reopen, try again. Earlier chunks may
|
||||
// have been lost with the write buffer (M3: 3 KB came back as zeros): never extend
|
||||
// the file to cover them; give up instead, as the sender can't resend them.
|
||||
for (int retry = 1; !ok && retry <= 3; retry++) {
|
||||
console.printf("put: write failed at %u, retry %d\n", (unsigned)r.received(), retry);
|
||||
f.close();
|
||||
delay(50 * retry);
|
||||
f = SD.open(part.c_str(), FILE_READ);
|
||||
size_t onCard = f ? f.size() : 0;
|
||||
if (f) f.close();
|
||||
if (onCard < r.received()) {
|
||||
console.printf("put: the card lost %u B written before\n", (unsigned)(r.received() - onCard));
|
||||
break;
|
||||
}
|
||||
truncate(("/sd" + part).c_str(), r.received());
|
||||
f = SD.open(part.c_str(), FILE_APPEND);
|
||||
ok = f && f.size() == r.received() && f.write(c.data(), c.size()) == c.size();
|
||||
@@ -254,6 +264,15 @@ void DebugConsole::put(NetworkClient& client, const std::string& args) {
|
||||
}
|
||||
}
|
||||
f.close();
|
||||
if (r.state() == S::Finishing) { // read it back: the received checksum doesn't cover the card
|
||||
Sha256 sha;
|
||||
f = SD.open(part.c_str(), FILE_READ);
|
||||
for (int n; f && (n = f.read(buf, sizeof buf)) > 0;) sha.update(buf, n);
|
||||
if (f) f.close();
|
||||
uint8_t digest[32];
|
||||
sha.finish(digest);
|
||||
r.cardChecked(digest);
|
||||
}
|
||||
if (r.state() == S::Finishing) {
|
||||
if (SD.exists(r.path().c_str())) SD.remove(r.path().c_str());
|
||||
r.finished(SD.rename(part.c_str(), r.path().c_str()));
|
||||
|
||||
@@ -192,7 +192,7 @@ bool GeminiService::loadWindow(const GeminiPage& page, size_t firstLine) {
|
||||
windowPage_.lineIndex = page.lineIndex;
|
||||
windowLine_ = firstLine;
|
||||
// The App drops its current window once the new one is in: count that memory as coming back.
|
||||
windowReleasing_ = page.text.bytes() + page.text.lineCount() * 8;
|
||||
windowReleasing_ = page.text.bytes() + page.text.lineCount() * kBytesPerLine;
|
||||
return start(Job::Window);
|
||||
}
|
||||
|
||||
@@ -618,7 +618,7 @@ void GeminiService::fetchOne(const std::string& url, GeminiPage& page, bool load
|
||||
// what was free before minus the steady floor; meanwhile the heap must stay above the
|
||||
// transient floor. Both counted with the next 4 KB chunk and the line index.
|
||||
size_t take = std::min<size_t>(n - i, kMaxBody - page.text.bytes());
|
||||
size_t pageCost = page.text.bytes() + page.text.lineCount() * 8 + TextBuffer::kChunk + take;
|
||||
size_t pageCost = page.text.bytes() + page.text.lineCount() * kBytesPerLine + TextBuffer::kChunk + take;
|
||||
if (take < static_cast<size_t>(n - i)) page.truncatedWhy = "longer than 64 KB";
|
||||
else if (freeBefore < kSteadyFloor + pageCost) page.truncatedWhy = "not enough memory to keep it";
|
||||
else if (esp_get_free_heap_size() < kTransientFloor + TextBuffer::kChunk + take)
|
||||
@@ -720,7 +720,7 @@ void GeminiService::loadFromCard(GeminiPage& page, size_t freeBefore, const std:
|
||||
if (page.totalLines % kIndexEvery == 0) page.lineIndex.push_back(lineStart | (pre ? 0x80000000u : 0));
|
||||
if (line.compare(0, 3, "```") == 0) pre = !pre;
|
||||
if (loading) {
|
||||
if (page.text.bytes() + page.text.lineCount() * 8 + line.size() + 1 > budget) loading = false;
|
||||
if (page.text.bytes() + page.text.lineCount() * kBytesPerLine + line.size() + 1 > budget) loading = false;
|
||||
else {
|
||||
line += '\n';
|
||||
page.text.append(line.data(), line.size());
|
||||
@@ -768,7 +768,7 @@ void GeminiService::readWindow(GeminiPage& page, size_t firstLine, size_t budget
|
||||
continue;
|
||||
}
|
||||
if (lineNo >= firstLine) {
|
||||
if (page.text.bytes() + page.text.lineCount() * 8 + line.size() + 1 > budget) done = true;
|
||||
if (page.text.bytes() + page.text.lineCount() * kBytesPerLine + line.size() + 1 > budget) done = true;
|
||||
else {
|
||||
line += '\n';
|
||||
page.text.append(line.data(), line.size());
|
||||
|
||||
@@ -64,6 +64,10 @@ class GeminiService {
|
||||
static constexpr int kMaxLinkedPages = 30; // Q83
|
||||
static constexpr size_t kIndexEvery = 64; // lines between lineIndex entries
|
||||
static constexpr size_t kMaxLineBytes = 8192; // longer lines are cut
|
||||
// What a page costs per line on top of its text: TextBuffer's index (8) and the App's tables
|
||||
// (type, first row, links: about 8). Counting only the first left the steady floor 1.5 to 3 KB
|
||||
// short on a windowed page (found in M3).
|
||||
static constexpr size_t kBytesPerLine = 16;
|
||||
static constexpr const char* kBookmarks = "/gemini/bookmarks.gmi";
|
||||
static constexpr const char* kStartUrl = "about:start";
|
||||
|
||||
|
||||
@@ -0,0 +1,62 @@
|
||||
#include "services/lora_capture_service.h"
|
||||
|
||||
#include <vector>
|
||||
|
||||
#include "loratap.h"
|
||||
#include "platform/console.h"
|
||||
|
||||
namespace roro {
|
||||
|
||||
std::string LoraCaptureService::start(uint32_t nowMs) {
|
||||
if (capturing()) return "";
|
||||
if (!radio_.present()) return "No LoRa radio";
|
||||
StorageState card = storage_.state();
|
||||
if (!card.present) return "No SD card";
|
||||
if (!card.capturesAllowed) return "The SD card is full";
|
||||
int64_t now = clock_.utcNow();
|
||||
if (now < 0) return "Waiting for the time (GNSS or Wi-Fi)";
|
||||
path_ = lora::capturePath(now);
|
||||
std::vector<uint8_t> header;
|
||||
lora::appendPcapHeader(header);
|
||||
storage_.appendBytes(path_, std::string(header.begin(), header.end()), true);
|
||||
startUtc_ = now;
|
||||
startMs_ = nowMs;
|
||||
written_ = radio_.received(); // from now on
|
||||
packets_ = 0;
|
||||
radio_.listen(RadioService::Capture, true);
|
||||
console.printf("lora: Capture %s started\n", path_.c_str());
|
||||
notify("LoRa Capture started");
|
||||
return "";
|
||||
}
|
||||
|
||||
void LoraCaptureService::stop() {
|
||||
if (!capturing()) return;
|
||||
radio_.listen(RadioService::Capture, false);
|
||||
console.printf("lora: Capture %s stopped, %lu packets\n", path_.c_str(), (unsigned long)packets_);
|
||||
notify("LoRa Capture stopped: " + std::to_string(packets_) + " packets");
|
||||
path_.clear();
|
||||
}
|
||||
|
||||
void LoraCaptureService::tick(uint32_t nowMs) {
|
||||
(void)nowMs;
|
||||
if (!capturing()) return;
|
||||
uint32_t newest = radio_.received();
|
||||
for (uint32_t seq = written_ + 1; seq <= newest; ++seq) {
|
||||
RadioPacket p;
|
||||
if (!radio_.packet(seq, p)) continue; // already left the ring: too many at once
|
||||
uint32_t sinceStart = p.ms - startMs_;
|
||||
std::vector<uint8_t> record;
|
||||
record.reserve(lora::kRecordOverhead + p.len);
|
||||
lora::appendRecord(record, static_cast<uint32_t>(startUtc_ + sinceStart / 1000), (sinceStart % 1000) * 1000,
|
||||
p.rx, p.data, p.len);
|
||||
storage_.appendBytes(path_, std::string(record.begin(), record.end()), true);
|
||||
++packets_;
|
||||
}
|
||||
written_ = newest;
|
||||
}
|
||||
|
||||
void LoraCaptureService::notify(const std::string& text) {
|
||||
bus_.publish(Event::withText(EventType::Notification, text.c_str(), static_cast<int32_t>(NotificationLevel::Info)));
|
||||
}
|
||||
|
||||
} // namespace roro
|
||||
@@ -0,0 +1,44 @@
|
||||
#pragma once
|
||||
|
||||
#include <string>
|
||||
|
||||
#include "event_bus.h"
|
||||
#include "service.h"
|
||||
#include "services/clock_service.h"
|
||||
#include "services/radio_service.h"
|
||||
#include "services/storage_service.h"
|
||||
|
||||
namespace roro {
|
||||
|
||||
// A LoRa Sniffer Capture (CONTEXT.md: Capture; M3, Q97): every packet the radio receives, as pcap
|
||||
// with LoRaTap headers, in /captures/lora/. Started and stopped by hand; keeps the radio listening
|
||||
// and keeps recording whatever App is open (Q100).
|
||||
class LoraCaptureService : public Service {
|
||||
public:
|
||||
LoraCaptureService(RadioService& radio, StorageService& storage, ClockService& clock, EventBus& bus)
|
||||
: radio_(radio), storage_(storage), clock_(clock), bus_(bus) {}
|
||||
const char* name() const override { return "lora-capture"; }
|
||||
uint32_t tickIntervalMs() const override { return 200; }
|
||||
void tick(uint32_t nowMs) override;
|
||||
|
||||
std::string start(uint32_t nowMs); // why it can't, or ""
|
||||
void stop();
|
||||
bool capturing() const { return !path_.empty(); }
|
||||
const std::string& path() const { return path_; }
|
||||
uint32_t packets() const { return packets_; }
|
||||
|
||||
private:
|
||||
void notify(const std::string& text);
|
||||
|
||||
RadioService& radio_;
|
||||
StorageService& storage_;
|
||||
ClockService& clock_;
|
||||
EventBus& bus_;
|
||||
std::string path_;
|
||||
uint32_t written_ = 0; // the radio's seq last written
|
||||
uint32_t packets_ = 0;
|
||||
int64_t startUtc_ = 0; // the Clock and millis() when it started: packet times follow from both
|
||||
uint32_t startMs_ = 0;
|
||||
};
|
||||
|
||||
} // namespace roro
|
||||
@@ -0,0 +1,476 @@
|
||||
#include "services/radio_service.h"
|
||||
|
||||
#include <M5Cardputer.h>
|
||||
#include <RadioLib.h>
|
||||
|
||||
#include <algorithm>
|
||||
#include <new>
|
||||
|
||||
#include "meshtastic_header.h"
|
||||
#include "sweep_view.h"
|
||||
#include "platform/console.h"
|
||||
#include "platform/pins.h"
|
||||
#include "platform/shared_spi.h"
|
||||
|
||||
namespace roro {
|
||||
|
||||
namespace {
|
||||
|
||||
// The Cap's PI4IOE5V6408: its P0 connects the antenna; at power-on it's an input and the receiver
|
||||
// is deaf (M3 step 1, measured). Only touched from the main loop, which owns the I2C bus.
|
||||
constexpr uint8_t kExpander = 0x43;
|
||||
constexpr uint32_t kI2cFreq = 400000;
|
||||
enum ExpanderReg : uint8_t { kId = 0x01, kDirection = 0x03, kOutput = 0x05, kHighZ = 0x07, kInput = 0x0F };
|
||||
|
||||
bool antennaOn() {
|
||||
auto& i2c = M5.In_I2C;
|
||||
if (!i2c.scanID(kExpander, kI2cFreq)) return false;
|
||||
i2c.writeRegister8(kExpander, kOutput, i2c.readRegister8(kExpander, kOutput, kI2cFreq) | 1, kI2cFreq);
|
||||
i2c.writeRegister8(kExpander, kHighZ, i2c.readRegister8(kExpander, kHighZ, kI2cFreq) & ~1, kI2cFreq);
|
||||
i2c.writeRegister8(kExpander, kDirection, i2c.readRegister8(kExpander, kDirection, kI2cFreq) | 1, kI2cFreq);
|
||||
return true;
|
||||
}
|
||||
|
||||
// Below this the receiver hears only itself: the antenna path is open (step 1: -111.9 dBm).
|
||||
constexpr float kDeafBelow = -108.0f;
|
||||
|
||||
} // namespace
|
||||
|
||||
RadioService* RadioService::instance_ = nullptr;
|
||||
|
||||
RadioService::RadioService() : lock_(xSemaphoreCreateMutex()) {
|
||||
const meshtastic::Preset& p = meshtastic::kEu868Presets[0]; // LongFast (Q95)
|
||||
config_ = {meshtastic::eu868FrequencyHz(p), p.bwKHz, p.sf, p.cr, meshtastic::kSyncWord, meshtastic::kPreambleLength,
|
||||
p.name};
|
||||
}
|
||||
|
||||
void RadioService::start() {
|
||||
instance_ = this;
|
||||
expander_ = antennaOn();
|
||||
// SPI transactions take the bus lock the SD card uses; the HAL doesn't re-begin the bus.
|
||||
hal_.reset(new ArduinoHal(sharedSpi(), SPISettings(8000000, MSBFIRST, SPI_MODE0)));
|
||||
module_.reset(new Module(hal_.get(), pins::kLoraCs, pins::kLoraIrq, pins::kLoraReset, pins::kLoraBusy));
|
||||
radio_.reset(new SX1262(module_.get()));
|
||||
// Above the main loop and the other Services' tasks, so a packet is read before the next.
|
||||
xTaskCreatePinnedToCore(taskEntry, "radio", 4096, this, 2, &task_, 1); // peak 2.0 KB (M3 step 3)
|
||||
}
|
||||
|
||||
void RadioService::taskEntry(void* self) { static_cast<RadioService*>(self)->run(); }
|
||||
|
||||
void IRAM_ATTR RadioService::onDio1() {
|
||||
BaseType_t woken = pdFALSE;
|
||||
if (instance_ && instance_->task_) xTaskNotifyFromISR(instance_->task_, kIrq, eSetBits, &woken);
|
||||
portYIELD_FROM_ISR(woken);
|
||||
}
|
||||
|
||||
void RadioService::wake(Notify why) {
|
||||
if (task_) xTaskNotify(task_, why, eSetBits);
|
||||
}
|
||||
|
||||
bool RadioService::beginRadio(Print* report) {
|
||||
Config c = config();
|
||||
float mhz = c.frequencyHz / 1e6f;
|
||||
int16_t state = radio_->begin(mhz, c.bandwidthKHz, c.spreadingFactor, c.codingRate, c.syncWord, 0, c.preamble,
|
||||
tcxo_, false);
|
||||
if (state != RADIOLIB_ERR_NONE && tcxo_ > 0) { // Meshtastic's TCXO_OPTIONAL: fall back to the crystal
|
||||
if (report) report->printf("lora probe: begin with TCXO %.1f V: error %d, trying the crystal\n", tcxo_, state);
|
||||
tcxo_ = 0;
|
||||
state = radio_->begin(mhz, c.bandwidthKHz, c.spreadingFactor, c.codingRate, c.syncWord, 0, c.preamble, tcxo_,
|
||||
false);
|
||||
}
|
||||
if (state != RADIOLIB_ERR_NONE) {
|
||||
if (report) report->printf("lora probe: error %d, no SX1262 found\n", state);
|
||||
return false;
|
||||
}
|
||||
radio_->setDio2AsRfSwitch(true); // DIO2 selects TX or RX in the switch, as in Meshtastic
|
||||
radio_->setRxBoostedGainMode(true); // about 2 dB more sensitivity for about 2 mA
|
||||
return true;
|
||||
}
|
||||
|
||||
void RadioService::run() {
|
||||
present_ = beginRadio(nullptr);
|
||||
if (present_) radio_->sleep();
|
||||
console.printf("radio: %s\n", present_ ? (tcxo_ > 0 ? "SX1262 ready (TCXO), asleep" : "SX1262 ready (crystal), asleep")
|
||||
: "no radio found");
|
||||
for (;;) {
|
||||
uint32_t bits = 0;
|
||||
xTaskNotifyWait(0, UINT32_MAX, &bits,
|
||||
sweepWanted_ ? pdMS_TO_TICKS(20) : listening_ ? pdMS_TO_TICKS(kNoiseEveryMs) : portMAX_DELAY);
|
||||
if (probeWanted_.exchange(false)) runProbe();
|
||||
if (!present_) continue;
|
||||
if (sweepWanted_) { // a Sweep has the radio: the Sniffer waits, its packets kept (Q99)
|
||||
sweepPass();
|
||||
continue;
|
||||
}
|
||||
if (sweeping_) endSweep();
|
||||
bool want = clients_ != 0;
|
||||
if (want && !listening_) startListening();
|
||||
else if (!want && listening_) stopListening();
|
||||
if (listening_ && configChanged_.exchange(false)) startListening(); // again, with the new settings
|
||||
if (listening_ && (bits & kIrq)) readPacket();
|
||||
if (listening_ && millis() - lastNoiseMs_ >= kNoiseEveryMs) sampleNoise();
|
||||
}
|
||||
}
|
||||
|
||||
void RadioService::startListening() {
|
||||
if (!ring_) {
|
||||
ring_.reset(new (std::nothrow) RadioPacket[kRing]);
|
||||
ringFirst_ = seq_ + 1;
|
||||
if (!ring_) {
|
||||
console.println("radio: not enough memory to listen");
|
||||
clients_ = 0;
|
||||
return;
|
||||
}
|
||||
}
|
||||
// A full begin (with a reset) each time: the chip comes back from sleep with nothing assumed.
|
||||
if (!beginRadio(nullptr)) {
|
||||
++radioErrors_;
|
||||
return;
|
||||
}
|
||||
radio_->setPacketReceivedAction(onDio1);
|
||||
int16_t state = receive();
|
||||
if (state != RADIOLIB_ERR_NONE) {
|
||||
++radioErrors_;
|
||||
console.printf("radio: can't receive (error %d)\n", state);
|
||||
return;
|
||||
}
|
||||
if (!listening_) console.printf("radio: listening, %s\n", config().name);
|
||||
listening_ = true;
|
||||
lastNoiseMs_ = 0;
|
||||
}
|
||||
|
||||
void RadioService::stopListening() {
|
||||
radio_->clearPacketReceivedAction();
|
||||
radio_->sleep();
|
||||
listening_ = false;
|
||||
noise_ = 0;
|
||||
xSemaphoreTake(lock_, portMAX_DELAY);
|
||||
ring_.reset(); // listening again starts a fresh list; idle costs nothing (Q100, Q103)
|
||||
xSemaphoreGive(lock_);
|
||||
console.println("radio: asleep");
|
||||
}
|
||||
|
||||
void RadioService::readPacket() {
|
||||
RadioPacket p;
|
||||
size_t len = std::min<size_t>(radio_->getPacketLength(), sizeof p.data);
|
||||
int16_t state = radio_->readData(p.data, len);
|
||||
if (state == RADIOLIB_ERR_CRC_MISMATCH) {
|
||||
p.crcOk = false;
|
||||
++crcErrors_;
|
||||
} else if (state != RADIOLIB_ERR_NONE) { // a header error or a timeout: nothing to keep
|
||||
++radioErrors_;
|
||||
if (receive() != RADIOLIB_ERR_NONE) ++radioErrors_;
|
||||
++restarts_;
|
||||
return;
|
||||
}
|
||||
Config c = config();
|
||||
p.ms = millis();
|
||||
p.len = static_cast<uint8_t>(len);
|
||||
p.rx.frequencyHz = c.frequencyHz;
|
||||
p.rx.bandwidthKHz = c.bandwidthKHz;
|
||||
p.rx.spreadingFactor = c.spreadingFactor;
|
||||
p.rx.syncWord = c.syncWord;
|
||||
p.rx.rssi = radio_->getRSSI();
|
||||
p.rx.snr = radio_->getSNR();
|
||||
p.rx.noiseFloor = noise_;
|
||||
p.frequencyError = radio_->getFrequencyError();
|
||||
if (receive() != RADIOLIB_ERR_NONE) ++radioErrors_;
|
||||
++restarts_;
|
||||
|
||||
store(p);
|
||||
}
|
||||
|
||||
void RadioService::store(RadioPacket& p) {
|
||||
xSemaphoreTake(lock_, portMAX_DELAY);
|
||||
p.seq = seq_ + 1;
|
||||
if (ring_) ring_[p.seq % kRing] = p;
|
||||
seq_ = p.seq;
|
||||
xSemaphoreGive(lock_);
|
||||
++packets_;
|
||||
lastPacketMs_ = p.ms;
|
||||
}
|
||||
|
||||
#ifdef RORO_DEBUG
|
||||
void RadioService::inject(const uint8_t* data, size_t len, float rssi, float snr) {
|
||||
if (!listening_) return (void)console.println("lora inject: not listening");
|
||||
RadioPacket p;
|
||||
Config c = config();
|
||||
p.ms = millis();
|
||||
p.len = static_cast<uint8_t>(std::min(len, sizeof p.data));
|
||||
std::copy(data, data + p.len, p.data);
|
||||
p.rx = {c.frequencyHz, c.bandwidthKHz, c.spreadingFactor, rssi, snr, noise_, c.syncWord};
|
||||
store(p);
|
||||
console.printf("lora inject: #%lu, %u B\n", (unsigned long)p.seq, p.len);
|
||||
}
|
||||
#endif
|
||||
|
||||
// Continuous receive. Only RX done raises DIO1; preambles and headers are only recorded in the
|
||||
// IRQ status, which sampleNoise() reads.
|
||||
int16_t RadioService::receive() {
|
||||
return radio_->startReceive(RADIOLIB_SX126X_RX_TIMEOUT_INF,
|
||||
RADIOLIB_IRQ_RX_DEFAULT_FLAGS | (1UL << RADIOLIB_IRQ_PREAMBLE_DETECTED),
|
||||
RADIOLIB_IRQ_RX_DEFAULT_MASK, 0);
|
||||
}
|
||||
|
||||
void RadioService::sampleNoise() {
|
||||
lastNoiseMs_ = millis();
|
||||
noise_ = radio_->getRSSI(false);
|
||||
constexpr uint16_t kSeen =
|
||||
RADIOLIB_SX126X_IRQ_PREAMBLE_DETECTED | RADIOLIB_SX126X_IRQ_HEADER_VALID | RADIOLIB_SX126X_IRQ_HEADER_ERR;
|
||||
uint32_t flags = radio_->getIrqFlags();
|
||||
if (flags & RADIOLIB_SX126X_IRQ_PREAMBLE_DETECTED) ++preambles_;
|
||||
if (flags & RADIOLIB_SX126X_IRQ_HEADER_VALID) ++headers_;
|
||||
if (flags & RADIOLIB_SX126X_IRQ_HEADER_ERR) ++headerErrors_;
|
||||
if (flags & kSeen) radio_->clearIrqFlags(kSeen); // never RX done: that one is the task's
|
||||
}
|
||||
|
||||
bool RadioService::packet(uint32_t seq, RadioPacket& out) const {
|
||||
if (seq == 0 || seq > seq_ || seq_ - seq >= kRing) return false;
|
||||
xSemaphoreTake(lock_, portMAX_DELAY);
|
||||
bool ok = ring_ && ring_[seq % kRing].seq == seq;
|
||||
if (ok) out = ring_[seq % kRing];
|
||||
xSemaphoreGive(lock_);
|
||||
return ok;
|
||||
}
|
||||
|
||||
void RadioService::sweep(bool on, uint32_t fromHz, uint32_t toHz, uint32_t stepHz) {
|
||||
if (on) {
|
||||
stepHz = std::max<uint32_t>(stepHz, 10000);
|
||||
toHz = std::max(toHz, fromHz);
|
||||
toHz = std::min<uint32_t>(toHz, fromHz + stepHz * (SweepFrame::kMaxSteps - 1));
|
||||
sweepFrom_ = fromHz, sweepTo_ = toHz, sweepStep_ = stepHz;
|
||||
}
|
||||
sweepWanted_ = on;
|
||||
wake(kRequest);
|
||||
}
|
||||
|
||||
bool RadioService::sweepFrame(SweepFrame& out) const {
|
||||
if (!sweepSeq_) return false;
|
||||
xSemaphoreTake(lock_, portMAX_DELAY);
|
||||
out = frame_;
|
||||
xSemaphoreGive(lock_);
|
||||
return true;
|
||||
}
|
||||
|
||||
// One pass across the band. The first one sets the radio up: the Sniffer is paused, not stopped.
|
||||
void RadioService::sweepPass() {
|
||||
if (!sweeping_) {
|
||||
if (listening_) {
|
||||
radio_->clearPacketReceivedAction();
|
||||
listening_ = false; // paused; startListening() resumes on the same ring
|
||||
}
|
||||
if (!beginRadio(nullptr)) {
|
||||
++radioErrors_;
|
||||
sweepWanted_ = false;
|
||||
return;
|
||||
}
|
||||
radio_->setBandwidth(125);
|
||||
radio_->setSpreadingFactor(7);
|
||||
sweeping_ = true;
|
||||
console.println("radio: sweeping, the Sniffer is paused");
|
||||
}
|
||||
uint32_t from = sweepFrom_, to = sweepTo_, step = sweepStep_;
|
||||
uint16_t steps = static_cast<uint16_t>((to - from) / step + 1);
|
||||
int8_t dbm[SweepFrame::kMaxSteps];
|
||||
uint32_t t0 = millis();
|
||||
for (uint16_t i = 0; i < steps && sweepWanted_; ++i) {
|
||||
radio_->standby();
|
||||
// Image calibration is per band and slow; one calibration covers EU868, so skip it per step.
|
||||
radio_->setFrequency((from + i * step) / 1e6f, i != 0);
|
||||
radio_->startReceive();
|
||||
delayMicroseconds(1500); // RSSI settles
|
||||
float best = -200;
|
||||
for (int k = 0; k < 3; ++k) {
|
||||
best = std::max(best, radio_->getRSSI(false));
|
||||
delayMicroseconds(300);
|
||||
}
|
||||
dbm[i] = static_cast<int8_t>(std::clamp(best, -127.0f, 0.0f));
|
||||
}
|
||||
radio_->standby();
|
||||
if (!sweepWanted_) return;
|
||||
xSemaphoreTake(lock_, portMAX_DELAY);
|
||||
frame_.seq = sweepSeq_ + 1;
|
||||
frame_.fromHz = from;
|
||||
frame_.stepHz = step;
|
||||
frame_.steps = steps;
|
||||
frame_.passMs = static_cast<uint16_t>(millis() - t0);
|
||||
std::copy(dbm, dbm + steps, frame_.dbm);
|
||||
xSemaphoreGive(lock_);
|
||||
sweepSeq_ = frame_.seq;
|
||||
}
|
||||
|
||||
void RadioService::endSweep() {
|
||||
sweeping_ = false;
|
||||
console.println("radio: sweep stopped");
|
||||
if (clients_) startListening(); // the Sniffer again, with its settings and its packets
|
||||
else {
|
||||
radio_->sleep();
|
||||
xSemaphoreTake(lock_, portMAX_DELAY);
|
||||
ring_.reset();
|
||||
xSemaphoreGive(lock_);
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t RadioService::available() const {
|
||||
uint32_t newest = seq_, first = ringFirst_;
|
||||
if (!listening_ || newest < first) return 0;
|
||||
return std::min<uint32_t>(newest - first + 1, kRing);
|
||||
}
|
||||
|
||||
void RadioService::listen(Client client, bool on) {
|
||||
if (on) clients_ |= client;
|
||||
else clients_ &= ~client;
|
||||
wake(kRequest);
|
||||
}
|
||||
|
||||
RadioService::Config RadioService::config() const {
|
||||
xSemaphoreTake(lock_, portMAX_DELAY);
|
||||
Config c = config_;
|
||||
xSemaphoreGive(lock_);
|
||||
return c;
|
||||
}
|
||||
|
||||
void RadioService::setPreset(const meshtastic::Preset& p) {
|
||||
xSemaphoreTake(lock_, portMAX_DELAY);
|
||||
config_ = {meshtastic::eu868FrequencyHz(p), p.bwKHz, p.sf, p.cr, meshtastic::kSyncWord, meshtastic::kPreambleLength,
|
||||
p.name};
|
||||
xSemaphoreGive(lock_);
|
||||
configChanged_ = true;
|
||||
wake(kRequest);
|
||||
}
|
||||
|
||||
void RadioService::setConfig(const Config& c) {
|
||||
xSemaphoreTake(lock_, portMAX_DELAY);
|
||||
config_ = c;
|
||||
config_.name = "Custom";
|
||||
xSemaphoreGive(lock_);
|
||||
configChanged_ = true;
|
||||
wake(kRequest);
|
||||
}
|
||||
|
||||
void RadioService::setEcho(bool echo) {
|
||||
echo_ = echo;
|
||||
echoed_ = seq_;
|
||||
listen(Console, echo);
|
||||
}
|
||||
|
||||
void RadioService::tick(uint32_t nowMs) {
|
||||
SweepFrame f;
|
||||
if (sweepEcho_ && sweeping_ && nowMs - sweepEchoMs_ >= 2000 && sweepFrame(f)) {
|
||||
sweepEchoMs_ = nowMs;
|
||||
lora::SweepStats st = lora::summarize(f.dbm, f.steps, f.fromHz, f.stepHz);
|
||||
console.printf("sweep: #%lu floor %d, top %d dBm", (unsigned long)f.seq, st.floor, st.top);
|
||||
for (auto& p : st.peaks) console.printf(", %.1f MHz %d", p.hz / 1e6, p.dbm);
|
||||
console.printf(" (%u ms a pass)\n", f.passMs);
|
||||
}
|
||||
if (!echo_) return;
|
||||
for (uint32_t s = std::max(echoed_ + 1, seq_ > kRing ? seq_ - kRing + 1 : 1u); s <= seq_; ++s) {
|
||||
RadioPacket p;
|
||||
if (!packet(s, p)) continue;
|
||||
console.printf("lora: #%lu %u B %.1f dBm SNR %.1f dB%s", (unsigned long)p.seq, p.len, p.rx.rssi, p.rx.snr,
|
||||
p.crcOk ? "" : " (bad CRC)");
|
||||
meshtastic::PacketHeader h;
|
||||
if (meshtastic::parseHeader(p.data, p.len, h))
|
||||
console.printf(" | %s > %s, ch 0x%02X, hops %d/%u%s", meshtastic::nodeId(h.from).c_str(),
|
||||
meshtastic::nodeId(h.to).c_str(), h.channelHash, h.hopsAway(), h.hopStart(),
|
||||
h.viaMqtt() ? ", via MQTT" : "");
|
||||
console.println();
|
||||
}
|
||||
echoed_ = seq_;
|
||||
}
|
||||
|
||||
void RadioService::printSweep(Print& out) const {
|
||||
SweepFrame f;
|
||||
if (!sweepFrame(f)) return (void)out.println("sweep: none yet (lora sweep on)");
|
||||
out.printf("sweep: #%lu, %u steps of %lu kHz from %.3f MHz, %u ms\n", (unsigned long)f.seq, f.steps,
|
||||
(unsigned long)(f.stepHz / 1000), f.fromHz / 1e6, f.passMs);
|
||||
for (uint16_t i = 0; i < f.steps; i += 8) {
|
||||
out.printf("%8.3f", (f.fromHz + i * f.stepHz) / 1e6);
|
||||
for (uint16_t k = i; k < f.steps && k < i + 8; ++k) out.printf(" %4d", f.dbm[k]);
|
||||
out.println();
|
||||
}
|
||||
}
|
||||
|
||||
void RadioService::printStatus(Print& out) const {
|
||||
Config c = config();
|
||||
Counters n = counters();
|
||||
out.printf("radio: %s, %s, antenna switch %s\n", present_ ? "SX1262" : "no radio",
|
||||
tcxo_ > 0 ? "TCXO 1.8 V" : "crystal", expander_ ? "on (expander 0x43 P0)" : "expander missing");
|
||||
out.printf("radio: %s, %s %.3f MHz, BW %.0f kHz, SF %u, CR 4/%u, sync 0x%02X, preamble %u\n",
|
||||
sweeping_ ? "sweeping" : listening_ ? "listening" : "asleep", c.name, c.frequencyHz / 1e6, c.bandwidthKHz, c.spreadingFactor,
|
||||
c.codingRate, c.syncWord, c.preamble);
|
||||
out.printf("radio: clients%s%s%s%s\n", clients_ ? "" : " none", clients_ & App ? " App" : "",
|
||||
clients_ & Capture ? " Capture" : "", clients_ & Console ? " Console" : "");
|
||||
out.printf("radio: %lu packets, %lu bad CRC, %lu radio errors, %lu receive restarts\n", (unsigned long)n.packets,
|
||||
(unsigned long)n.crcErrors, (unsigned long)n.radioErrors, (unsigned long)n.restarts);
|
||||
out.printf("radio: activity (500 ms samples): %lu preambles, %lu headers, %lu bad headers\n",
|
||||
(unsigned long)n.preambles, (unsigned long)n.headers, (unsigned long)n.headerErrors);
|
||||
if (listening_)
|
||||
out.printf("radio: noise floor %.1f dBm%s\n", noise_.load(),
|
||||
noise_ < kDeafBelow ? " (deaf? the antenna path looks open)" : "");
|
||||
if (task_) out.printf("radio: task stack %u B free\n", (unsigned)uxTaskGetStackHighWaterMark(task_));
|
||||
}
|
||||
|
||||
void RadioService::probe(Print& out) {
|
||||
// The I2C part here, on the main loop; the radio part on the radio task.
|
||||
bool found[120] = {};
|
||||
M5.In_I2C.scanID(found, kI2cFreq);
|
||||
out.print("lora probe: i2c (internal bus, 8/9):");
|
||||
for (int a = 8; a < 120; ++a)
|
||||
if (found[a]) out.printf(" 0x%02X", a);
|
||||
out.println();
|
||||
if (found[kExpander]) {
|
||||
auto r = [](uint8_t reg) { return M5.In_I2C.readRegister8(kExpander, reg, kI2cFreq); };
|
||||
out.printf("lora probe: expander 0x43 dir %02X out %02X highz %02X in %02X: antenna %s\n", r(kDirection),
|
||||
r(kOutput), r(kHighZ), r(kInput), r(kOutput) & 1 && r(kDirection) & 1 ? "on" : "OFF");
|
||||
} else {
|
||||
out.println("lora probe: no expander at 0x43: the antenna switch can't be enabled");
|
||||
}
|
||||
probeOut_ = &out;
|
||||
probeWanted_ = true;
|
||||
wake(kRequest);
|
||||
}
|
||||
|
||||
void RadioService::runProbe() {
|
||||
Print& out = *probeOut_;
|
||||
uint32_t t0 = millis();
|
||||
if (!beginRadio(&out)) return;
|
||||
char version[17] = {};
|
||||
module_->SPIreadRegisterBurst(RADIOLIB_SX126X_REG_VERSION_STRING, 16, reinterpret_cast<uint8_t*>(version));
|
||||
out.printf("lora probe: %s, %s, ready in %u ms\n", version, tcxo_ > 0 ? "TCXO 1.8 V" : "crystal (no TCXO)",
|
||||
(unsigned)(millis() - t0));
|
||||
// DIO1 to the task, with no transmitter needed: a 100 ms receive timeout, routed to DIO1.
|
||||
radio_->setPacketReceivedAction(onDio1);
|
||||
uint32_t bits = 0;
|
||||
xTaskNotifyWait(0, UINT32_MAX, &bits, 0); // drop anything pending
|
||||
uint32_t sent = millis();
|
||||
radio_->startReceive(6400, RADIOLIB_IRQ_RX_DEFAULT_FLAGS,
|
||||
(1UL << RADIOLIB_IRQ_RX_DONE) | (1UL << RADIOLIB_IRQ_TIMEOUT), 0); // 6400 x 15.625 us
|
||||
bits = 0;
|
||||
xTaskNotifyWait(0, UINT32_MAX, &bits, pdMS_TO_TICKS(500));
|
||||
uint32_t flags = radio_->getIrqFlags();
|
||||
if (bits & kIrq)
|
||||
out.printf("lora probe: DIO1 interrupt works (receive timeout after %u ms)\n", (unsigned)(millis() - sent));
|
||||
else
|
||||
out.printf("lora probe: DIO1 interrupt never came (IRQ status 0x%04X)\n", (unsigned)flags);
|
||||
radio_->standby();
|
||||
radio_->clearIrqFlags(RADIOLIB_SX126X_IRQ_ALL);
|
||||
if (!listening_) radio_->clearPacketReceivedAction();
|
||||
receive();
|
||||
delay(20);
|
||||
float sum = 0, low = 0, high = -200;
|
||||
for (int i = 0; i < 64; ++i) {
|
||||
float r = radio_->getRSSI(false);
|
||||
sum += r, low = std::min(low, r), high = std::max(high, r);
|
||||
delay(3);
|
||||
}
|
||||
float mean = sum / 64;
|
||||
out.printf("lora probe: noise %.1f dBm (%.1f to %.1f) at %.3f MHz: %s\n", mean, low, high, config().frequencyHz / 1e6,
|
||||
mean < kDeafBelow ? "deaf, the antenna path looks open" : "the antenna is connected");
|
||||
// Back to what it was doing.
|
||||
if (listening_) startListening();
|
||||
else radio_->sleep();
|
||||
out.println("lora probe: done");
|
||||
}
|
||||
|
||||
} // namespace roro
|
||||
@@ -0,0 +1,151 @@
|
||||
#pragma once
|
||||
|
||||
#include <Print.h>
|
||||
#include <freertos/FreeRTOS.h>
|
||||
#include <freertos/semphr.h>
|
||||
#include <freertos/task.h>
|
||||
|
||||
#include <atomic>
|
||||
#include <cstdint>
|
||||
#include <memory>
|
||||
|
||||
#include "loratap.h"
|
||||
#include "meshtastic_presets.h"
|
||||
#include "service.h"
|
||||
|
||||
class SX1262;
|
||||
class Module;
|
||||
class ArduinoHal;
|
||||
|
||||
namespace roro {
|
||||
|
||||
// One received packet, as the Radio Service keeps it.
|
||||
struct RadioPacket {
|
||||
uint32_t seq = 0; // 1, 2, 3… since boot
|
||||
uint32_t ms = 0; // millis() when it was read (the Clock is read on the main loop, not here)
|
||||
lora::RxInfo rx;
|
||||
float frequencyError = 0; // Hz
|
||||
bool crcOk = true;
|
||||
uint8_t len = 0;
|
||||
uint8_t data[255];
|
||||
};
|
||||
|
||||
// One Sweep pass (M3, Q98): the strongest of three instantaneous RSSI readings at each step.
|
||||
struct SweepFrame {
|
||||
static constexpr size_t kMaxSteps = 160;
|
||||
uint32_t seq = 0; // 1, 2, 3… per pass
|
||||
uint32_t fromHz = 0, stepHz = 0;
|
||||
uint16_t steps = 0;
|
||||
uint16_t passMs = 0; // how long the pass took
|
||||
int8_t dbm[kMaxSteps];
|
||||
};
|
||||
|
||||
// The LoRa radio on the Cap (CONTEXT.md: Radio Service; docs/milestones/M3.md). One task owns the
|
||||
// SX1262 and does all its SPI traffic, behind the bus lock the SD card uses (Q93); the main loop
|
||||
// only posts requests, and DIO1's interrupt only wakes the task. **Receive only (Q94): there is
|
||||
// no way to transmit.** The radio listens while someone asks it to (Q100) and sleeps otherwise.
|
||||
class RadioService : public Service {
|
||||
public:
|
||||
enum Client : uint8_t { App = 1, Capture = 2, Console = 4 };
|
||||
static constexpr size_t kRing = 32; // Q103
|
||||
static constexpr uint32_t kNoiseEveryMs = 500; // instantaneous RSSI while listening
|
||||
|
||||
struct Config {
|
||||
uint32_t frequencyHz;
|
||||
float bandwidthKHz;
|
||||
uint8_t spreadingFactor, codingRate, syncWord;
|
||||
uint16_t preamble;
|
||||
const char* name; // the preset's, or "Custom"
|
||||
};
|
||||
struct Counters {
|
||||
uint32_t packets, crcErrors, radioErrors, restarts;
|
||||
// Seen in the IRQ status at each noise sample (every 500 ms). Preamble detections include
|
||||
// false alarms in noise (M3: more on an empty frequency than on LongFast); headers don't.
|
||||
uint32_t preambles, headers, headerErrors;
|
||||
};
|
||||
|
||||
RadioService();
|
||||
const char* name() const override { return "radio"; }
|
||||
uint32_t tickIntervalMs() const override { return 100; }
|
||||
void start() override;
|
||||
void tick(uint32_t nowMs) override;
|
||||
|
||||
bool present() const { return present_; }
|
||||
bool listening() const { return listening_; }
|
||||
void listen(Client client, bool on);
|
||||
Config config() const;
|
||||
void setPreset(const meshtastic::Preset& preset);
|
||||
void setConfig(const Config& config); // custom settings (Q95), named "Custom"
|
||||
|
||||
uint32_t received() const { return seq_; } // seq of the newest packet
|
||||
uint32_t lastPacketMs() const { return lastPacketMs_; } // millis(), 0 before the first
|
||||
bool packet(uint32_t seq, RadioPacket& out) const; // false once it has left the ring
|
||||
uint32_t available() const; // packets in the ring: seqs received()-available()+1 to received()
|
||||
float noiseFloor() const { return noise_; }
|
||||
Counters counters() const {
|
||||
return {packets_, crcErrors_, radioErrors_, restarts_, preambles_, headers_, headerErrors_};
|
||||
}
|
||||
|
||||
// Sweep (Q98, Q99): takes the radio across a band, pausing the Sniffer (its packets are kept)
|
||||
// until stopped. EU868 by default: 863 to 870 MHz in 100 kHz steps, measured at 125 kHz.
|
||||
void sweep(bool on, uint32_t fromHz = 863000000, uint32_t toHz = 870000000, uint32_t stepHz = 100000);
|
||||
bool sweeping() const { return sweeping_; }
|
||||
bool sweepFrame(SweepFrame& out) const; // the latest pass; false before the first
|
||||
uint32_t sweeps() const { return sweepSeq_; }
|
||||
void setSweepEcho(bool echo) { sweepEcho_ = echo; } // a summary on the console every 2 s
|
||||
void printSweep(Print& out) const; // `lora sweep dump`: the latest pass
|
||||
|
||||
// Debug aids (Q102).
|
||||
void printStatus(Print& out) const;
|
||||
void setEcho(bool echo);
|
||||
void probe(Print& out); // `lora probe`: runs on the radio task
|
||||
#ifdef RORO_DEBUG
|
||||
// `lora inject`: a packet into the ring as if received, to test the App and Captures with no
|
||||
// transmitter in range. Nothing goes on air.
|
||||
void inject(const uint8_t* data, size_t len, float rssi, float snr);
|
||||
#endif
|
||||
|
||||
private:
|
||||
enum Notify : uint32_t { kIrq = 1, kRequest = 2 };
|
||||
static void taskEntry(void* self);
|
||||
static void onDio1();
|
||||
void run();
|
||||
bool beginRadio(Print* report);
|
||||
void applyConfig();
|
||||
void startListening();
|
||||
void stopListening();
|
||||
int16_t receive();
|
||||
void readPacket();
|
||||
void store(RadioPacket& p);
|
||||
void sampleNoise();
|
||||
void runProbe();
|
||||
void sweepPass();
|
||||
void endSweep();
|
||||
void wake(Notify why);
|
||||
|
||||
std::unique_ptr<ArduinoHal> hal_;
|
||||
std::unique_ptr<Module> module_;
|
||||
std::unique_ptr<SX1262> radio_;
|
||||
TaskHandle_t task_ = nullptr;
|
||||
mutable SemaphoreHandle_t lock_; // the ring and the config
|
||||
std::unique_ptr<RadioPacket[]> ring_;
|
||||
Config config_;
|
||||
bool present_ = false, expander_ = false;
|
||||
float tcxo_ = 1.8f;
|
||||
std::atomic<uint8_t> clients_{0};
|
||||
std::atomic<bool> listening_{false}, configChanged_{false}, probeWanted_{false}, echo_{false};
|
||||
std::atomic<uint32_t> seq_{0}, packets_{0}, crcErrors_{0}, radioErrors_{0}, restarts_{0};
|
||||
std::atomic<uint32_t> preambles_{0}, headers_{0}, headerErrors_{0};
|
||||
std::atomic<uint32_t> lastPacketMs_{0};
|
||||
std::atomic<uint32_t> ringFirst_{1}; // the first seq the current ring can hold
|
||||
std::atomic<bool> sweepWanted_{false}, sweeping_{false};
|
||||
std::atomic<uint32_t> sweepFrom_{863000000}, sweepTo_{870000000}, sweepStep_{100000}, sweepSeq_{0};
|
||||
SweepFrame frame_; // under lock_
|
||||
std::atomic<float> noise_{0};
|
||||
uint32_t lastNoiseMs_ = 0, echoed_ = 0, sweepEchoMs_ = 0;
|
||||
bool sweepEcho_ = false;
|
||||
Print* probeOut_ = nullptr;
|
||||
static RadioService* instance_;
|
||||
};
|
||||
|
||||
} // namespace roro
|
||||
@@ -34,12 +34,20 @@ StorageState StorageService::state() const {
|
||||
}
|
||||
|
||||
void StorageService::appendLine(const std::string& path, const std::string& line, bool capture) {
|
||||
append(path, line, capture, true);
|
||||
}
|
||||
|
||||
void StorageService::appendBytes(const std::string& path, const std::string& bytes, bool capture) {
|
||||
append(path, bytes, capture, false);
|
||||
}
|
||||
|
||||
void StorageService::append(const std::string& path, const std::string& data, bool capture, bool newline) {
|
||||
lock();
|
||||
size_t bytes = path.size() + line.size();
|
||||
size_t bytes = path.size() + data.size();
|
||||
bool allowed = capture ? monitor_.state().capturesAllowed : monitor_.state().logsAllowed;
|
||||
bool accept = allowed && pendingBytes_ + bytes <= kMaxPendingBytes;
|
||||
if (accept) {
|
||||
pending_.emplace_back(path, line);
|
||||
pending_.push_back({path, data, newline});
|
||||
pendingBytes_ += bytes;
|
||||
} else {
|
||||
dropped_++;
|
||||
@@ -199,25 +207,25 @@ void StorageService::poll() {
|
||||
|
||||
void StorageService::writePending() {
|
||||
lock();
|
||||
std::deque<std::pair<std::string, std::string>> batch;
|
||||
std::deque<Pending> batch;
|
||||
batch.swap(pending_);
|
||||
pendingBytes_ = 0;
|
||||
unlock();
|
||||
if (batch.empty() || !mounted_) return;
|
||||
|
||||
// Keep each file's lines in order while opening each file once.
|
||||
std::stable_sort(batch.begin(), batch.end(), [](const auto& a, const auto& b) { return a.first < b.first; });
|
||||
std::stable_sort(batch.begin(), batch.end(), [](const auto& a, const auto& b) { return a.path < b.path; });
|
||||
File file;
|
||||
std::string openPath;
|
||||
for (auto& [path, line] : batch) {
|
||||
if (path != openPath) {
|
||||
for (auto& p : batch) {
|
||||
if (p.path != openPath) {
|
||||
if (file) file.close();
|
||||
file = SD.open(path.c_str(), FILE_APPEND, true); // true: create missing folders
|
||||
openPath = path;
|
||||
file = SD.open(p.path.c_str(), FILE_APPEND, true); // true: create missing folders
|
||||
openPath = p.path;
|
||||
}
|
||||
if (file) {
|
||||
file.write(reinterpret_cast<const uint8_t*>(line.data()), line.size());
|
||||
file.write('\n');
|
||||
file.write(reinterpret_cast<const uint8_t*>(p.data.data()), p.data.size());
|
||||
if (p.newline) file.write('\n');
|
||||
}
|
||||
}
|
||||
if (file) file.close();
|
||||
|
||||
@@ -32,6 +32,8 @@ class StorageService : public Service {
|
||||
// paused (over 90 % full, or no card) or if too much is already waiting. A Capture (or a Track,
|
||||
// something the user started) keeps going past 90 %, until the card is full.
|
||||
void appendLine(const std::string& path, const std::string& line, bool capture = false);
|
||||
// The same, for binary files (a pcap Capture): the bytes as they are, no newline.
|
||||
void appendBytes(const std::string& path, const std::string& bytes, bool capture = false);
|
||||
uint32_t droppedLines() const { return dropped_; }
|
||||
|
||||
// Storage Clean-up: list every file of every category, then delete a selection.
|
||||
@@ -73,7 +75,12 @@ class StorageService : public Service {
|
||||
mutable SemaphoreHandle_t lock_ = nullptr;
|
||||
|
||||
// Shared with other tasks, guarded by lock_.
|
||||
std::deque<std::pair<std::string, std::string>> pending_;
|
||||
struct Pending {
|
||||
std::string path, data;
|
||||
bool newline;
|
||||
};
|
||||
std::deque<Pending> pending_;
|
||||
void append(const std::string& path, const std::string& data, bool capture, bool newline);
|
||||
size_t pendingBytes_ = 0;
|
||||
uint32_t dropped_ = 0;
|
||||
bool listingRequested_ = false;
|
||||
|
||||
@@ -49,6 +49,13 @@ void statusBar(Canvas& c, const StatusInfo& info) {
|
||||
case StatusInfo::Wifi::None: break;
|
||||
}
|
||||
if (info.tracking) right("REC", kWarning);
|
||||
if (info.capturing) right("CAP", kWarning);
|
||||
switch (info.radio) { // Q101: muted while listening, bright for a moment on each packet
|
||||
case StatusInfo::Radio::Listening: right("L", kMuted); break;
|
||||
case StatusInfo::Radio::Packet: right("L", kAccent); break;
|
||||
case StatusInfo::Radio::Sweep: right("SW", kMuted); break; // the Sniffer is paused
|
||||
case StatusInfo::Radio::None: break;
|
||||
}
|
||||
switch (info.gnss) { // Q61: muted while searching, normal with a Fix, the count with a 3D Fix
|
||||
case StatusInfo::Gnss::Searching: right("G", kMuted); break;
|
||||
case StatusInfo::Gnss::TwoD: right("G", kText); break;
|
||||
|
||||
+3
-1
@@ -27,12 +27,14 @@ struct StatusInfo {
|
||||
enum class Gnss { None, Searching, TwoD, ThreeD } gnss = Gnss::None; // None: GNSS off (Q61)
|
||||
int gnssSatellites = 0; // used in the Fix
|
||||
bool tracking = false; // a Track is recording (Q63)
|
||||
enum class Radio { None, Listening, Packet, Sweep } radio = Radio::None; // M3, Q101: Packet flashes
|
||||
bool capturing = false; // a LoRa Capture is recording (Q97)
|
||||
|
||||
bool operator==(const StatusInfo& o) const {
|
||||
return title == o.title && batteryPercent == o.batteryPercent && clock == o.clock &&
|
||||
sdPresent == o.sdPresent && sdLevel == o.sdLevel && compose == o.compose && wifi == o.wifi &&
|
||||
wifiBars == o.wifiBars && unread == o.unread && gnss == o.gnss && gnssSatellites == o.gnssSatellites &&
|
||||
tracking == o.tracking;
|
||||
tracking == o.tracking && radio == o.radio && capturing == o.capturing;
|
||||
}
|
||||
bool operator!=(const StatusInfo& o) const { return !(*this == o); }
|
||||
};
|
||||
|
||||
@@ -184,6 +184,34 @@ void test_reset_returns_to_idle() {
|
||||
TEST_ASSERT_FALSE(r.active());
|
||||
}
|
||||
|
||||
// The received bytes can be right and the card's copy wrong: read back, it must hash the same.
|
||||
void test_card_check() {
|
||||
auto data = bytes(10);
|
||||
FileReceiver r;
|
||||
r.begin(args("/a.bin", data), 0);
|
||||
r.feed(data.data(), data.size(), 0);
|
||||
r.chunkWritten(true, 0);
|
||||
TEST_ASSERT_TRUE(r.state() == FileReceiver::State::Finishing);
|
||||
uint8_t good[32];
|
||||
Sha256::hash(data.data(), data.size(), good);
|
||||
r.cardChecked(good);
|
||||
TEST_ASSERT_TRUE(r.state() == FileReceiver::State::Finishing);
|
||||
r.finished(true);
|
||||
TEST_ASSERT_TRUE(r.state() == FileReceiver::State::Done);
|
||||
|
||||
FileReceiver bad;
|
||||
bad.begin(args("/a.bin", data), 0);
|
||||
bad.feed(data.data(), data.size(), 0);
|
||||
bad.chunkWritten(true, 0);
|
||||
auto zeroed = data;
|
||||
zeroed[4] = 0;
|
||||
uint8_t wrong[32];
|
||||
Sha256::hash(zeroed.data(), zeroed.size(), wrong);
|
||||
bad.cardChecked(wrong);
|
||||
TEST_ASSERT_TRUE(bad.state() == FileReceiver::State::Failed);
|
||||
TEST_ASSERT_EQUAL_STRING("the copy on the card differs", bad.error().c_str());
|
||||
}
|
||||
|
||||
int main() {
|
||||
UNITY_BEGIN();
|
||||
RUN_TEST(test_begin_accepts_path_size_and_checksum);
|
||||
@@ -198,5 +226,6 @@ int main() {
|
||||
RUN_TEST(test_wanted_counts_down_within_a_chunk);
|
||||
RUN_TEST(test_a_rename_that_never_completes_times_out);
|
||||
RUN_TEST(test_reset_returns_to_idle);
|
||||
RUN_TEST(test_card_check);
|
||||
return UNITY_END();
|
||||
}
|
||||
|
||||
@@ -0,0 +1,98 @@
|
||||
#include <unity.h>
|
||||
|
||||
#include <vector>
|
||||
|
||||
#include "loratap.h"
|
||||
|
||||
using namespace roro::lora;
|
||||
|
||||
void setUp() {}
|
||||
void tearDown() {}
|
||||
|
||||
static uint32_t le32(const std::vector<uint8_t>& b, size_t at) {
|
||||
return b[at] | b[at + 1] << 8 | b[at + 2] << 16 | (uint32_t)b[at + 3] << 24;
|
||||
}
|
||||
|
||||
void test_pcap_global_header() {
|
||||
std::vector<uint8_t> out;
|
||||
appendPcapHeader(out);
|
||||
TEST_ASSERT_EQUAL_size_t(24, out.size());
|
||||
TEST_ASSERT_EQUAL_HEX32(0xA1B2C3D4, le32(out, 0)); // microsecond timestamps, little-endian file
|
||||
TEST_ASSERT_EQUAL_UINT8(2, out[4]); // version 2.4
|
||||
TEST_ASSERT_EQUAL_UINT8(4, out[6]);
|
||||
TEST_ASSERT_EQUAL_UINT32(65535, le32(out, 16)); // snap length
|
||||
TEST_ASSERT_EQUAL_UINT32(270, le32(out, 20)); // LINKTYPE_LORATAP
|
||||
}
|
||||
|
||||
void test_record_with_loratap_v0() {
|
||||
RxInfo rx;
|
||||
rx.frequencyHz = 869525000;
|
||||
rx.bandwidthKHz = 250;
|
||||
rx.spreadingFactor = 11;
|
||||
rx.rssi = -97.0f;
|
||||
rx.snr = 6.25f;
|
||||
rx.noiseFloor = -110.0f;
|
||||
rx.syncWord = 0x2B;
|
||||
const uint8_t payload[] = {1, 2, 3};
|
||||
std::vector<uint8_t> out;
|
||||
appendRecord(out, 1791230400u, 250000u, rx, payload, sizeof payload);
|
||||
|
||||
TEST_ASSERT_EQUAL_size_t(16 + 15 + 3, out.size());
|
||||
TEST_ASSERT_EQUAL_UINT32(1791230400u, le32(out, 0));
|
||||
TEST_ASSERT_EQUAL_UINT32(250000u, le32(out, 4));
|
||||
TEST_ASSERT_EQUAL_UINT32(18, le32(out, 8)); // captured: LoRaTap header + payload
|
||||
TEST_ASSERT_EQUAL_UINT32(18, le32(out, 12));
|
||||
|
||||
const uint8_t* t = out.data() + 16; // LoRaTap v0, big-endian
|
||||
TEST_ASSERT_EQUAL_UINT8(0, t[0]); // version
|
||||
TEST_ASSERT_EQUAL_UINT8(0, t[1]); // padding
|
||||
TEST_ASSERT_EQUAL_UINT16(15, t[2] << 8 | t[3]);
|
||||
TEST_ASSERT_EQUAL_UINT32(869525000u, (uint32_t)t[4] << 24 | t[5] << 16 | t[6] << 8 | t[7]);
|
||||
TEST_ASSERT_EQUAL_UINT8(2, t[8]); // bandwidth in 125 kHz steps
|
||||
TEST_ASSERT_EQUAL_UINT8(11, t[9]);
|
||||
TEST_ASSERT_EQUAL_UINT8(42, t[10]); // packet RSSI: -139 + 42 = -97 dBm (SNR >= 0)
|
||||
TEST_ASSERT_EQUAL_UINT8(42, t[11]); // max RSSI: the packet's
|
||||
TEST_ASSERT_EQUAL_UINT8(29, t[12]); // current RSSI: the noise floor, -139 + 29 = -110 dBm
|
||||
TEST_ASSERT_EQUAL_UINT8(25, t[13]); // SNR in quarter dB
|
||||
TEST_ASSERT_EQUAL_HEX8(0x2B, t[14]);
|
||||
TEST_ASSERT_EQUAL_UINT8(3, t[17]);
|
||||
}
|
||||
|
||||
// Below 0 dB SNR the spec says quarter dB, but Wireshark (checked with tshark 4.2) reads plain dBm.
|
||||
void test_negative_snr() {
|
||||
RxInfo rx;
|
||||
rx.bandwidthKHz = 125;
|
||||
rx.rssi = -120.5f;
|
||||
rx.snr = -7.5f;
|
||||
std::vector<uint8_t> out;
|
||||
appendRecord(out, 0, 0, rx, nullptr, 0);
|
||||
const uint8_t* t = out.data() + 16;
|
||||
TEST_ASSERT_EQUAL_UINT8(1, t[8]);
|
||||
TEST_ASSERT_EQUAL_UINT8(19, t[10]); // -139 + 19 = -120 dBm (rounded half away)
|
||||
TEST_ASSERT_EQUAL_INT8(-30, static_cast<int8_t>(t[13])); // -7.5 dB
|
||||
}
|
||||
|
||||
void test_rssi_clamped() {
|
||||
RxInfo rx;
|
||||
rx.rssi = -150.0f; // below what LoRaTap can say
|
||||
rx.snr = 1.0f;
|
||||
rx.noiseFloor = 20.0f;
|
||||
std::vector<uint8_t> out;
|
||||
appendRecord(out, 0, 0, rx, nullptr, 0);
|
||||
TEST_ASSERT_EQUAL_UINT8(0, out[16 + 10]);
|
||||
TEST_ASSERT_EQUAL_UINT8(159, out[16 + 12]);
|
||||
}
|
||||
|
||||
void test_capture_path() {
|
||||
TEST_ASSERT_EQUAL_STRING("/captures/lora/20261005-200000.pcap", capturePath(1791230400).c_str());
|
||||
}
|
||||
|
||||
int main() {
|
||||
UNITY_BEGIN();
|
||||
RUN_TEST(test_pcap_global_header);
|
||||
RUN_TEST(test_record_with_loratap_v0);
|
||||
RUN_TEST(test_negative_snr);
|
||||
RUN_TEST(test_rssi_clamped);
|
||||
RUN_TEST(test_capture_path);
|
||||
return UNITY_END();
|
||||
}
|
||||
@@ -0,0 +1,132 @@
|
||||
#include <unity.h>
|
||||
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
|
||||
#include "meshtastic_header.h"
|
||||
#include "meshtastic_presets.h"
|
||||
|
||||
using namespace roro::meshtastic;
|
||||
|
||||
void setUp() {}
|
||||
void tearDown() {}
|
||||
|
||||
// The 16 bytes every Meshtastic packet starts with, little-endian, never encrypted.
|
||||
static const uint8_t kHeader[] = {
|
||||
0xFF, 0xFF, 0xFF, 0xFF, // to: broadcast
|
||||
0x78, 0x56, 0x34, 0x12, // from: !12345678
|
||||
0xEF, 0xBE, 0xAD, 0xDE, // id
|
||||
0x6B, // flags: hop start 3, want ack, hop limit 3
|
||||
0x08, // channel hash: LongFast with the default key
|
||||
0x00, // next hop: none
|
||||
0x42, // relay node: last byte of the Node that relayed it
|
||||
};
|
||||
|
||||
void test_header_fields() {
|
||||
PacketHeader h;
|
||||
TEST_ASSERT_TRUE(parseHeader(kHeader, sizeof kHeader, h));
|
||||
TEST_ASSERT_EQUAL_HEX32(0xFFFFFFFF, h.to);
|
||||
TEST_ASSERT_EQUAL_HEX32(0x12345678, h.from);
|
||||
TEST_ASSERT_EQUAL_HEX32(0xDEADBEEF, h.id);
|
||||
TEST_ASSERT_EQUAL_UINT8(0x08, h.channelHash);
|
||||
TEST_ASSERT_EQUAL_UINT8(0x00, h.nextHop);
|
||||
TEST_ASSERT_EQUAL_UINT8(0x42, h.relayNode);
|
||||
TEST_ASSERT_TRUE(h.broadcast());
|
||||
}
|
||||
|
||||
void test_header_flags() {
|
||||
PacketHeader h;
|
||||
parseHeader(kHeader, sizeof kHeader, h);
|
||||
TEST_ASSERT_EQUAL_UINT8(3, h.hopLimit());
|
||||
TEST_ASSERT_EQUAL_UINT8(3, h.hopStart());
|
||||
TEST_ASSERT_TRUE(h.wantAck());
|
||||
TEST_ASSERT_FALSE(h.viaMqtt());
|
||||
TEST_ASSERT_EQUAL_INT(0, h.hopsAway());
|
||||
|
||||
uint8_t relayed[16];
|
||||
std::memcpy(relayed, kHeader, 16);
|
||||
relayed[12] = 0xF1 | 0x10; // hop start 7, via MQTT, hop limit 1
|
||||
parseHeader(relayed, 16, h);
|
||||
TEST_ASSERT_EQUAL_UINT8(1, h.hopLimit());
|
||||
TEST_ASSERT_EQUAL_UINT8(7, h.hopStart());
|
||||
TEST_ASSERT_TRUE(h.viaMqtt());
|
||||
TEST_ASSERT_FALSE(h.wantAck());
|
||||
TEST_ASSERT_EQUAL_INT(6, h.hopsAway());
|
||||
}
|
||||
|
||||
void test_header_from_old_firmware_has_no_hop_start() {
|
||||
uint8_t old[16];
|
||||
std::memcpy(old, kHeader, 16);
|
||||
old[12] = 0x02; // hop limit 2, hop start 0: firmware before 2.3 didn't set it
|
||||
PacketHeader h;
|
||||
parseHeader(old, 16, h);
|
||||
TEST_ASSERT_EQUAL_INT(-1, h.hopsAway()); // unknown, not "2 hops below zero"
|
||||
}
|
||||
|
||||
void test_header_too_short() {
|
||||
PacketHeader h;
|
||||
TEST_ASSERT_FALSE(parseHeader(kHeader, 15, h));
|
||||
TEST_ASSERT_FALSE(parseHeader(nullptr, 0, h));
|
||||
}
|
||||
|
||||
void test_node_ids() {
|
||||
TEST_ASSERT_EQUAL_STRING("!12345678", nodeId(0x12345678).c_str());
|
||||
TEST_ASSERT_EQUAL_STRING("!0000abcd", nodeId(0xABCD).c_str());
|
||||
TEST_ASSERT_EQUAL_STRING("all", nodeId(kBroadcast).c_str());
|
||||
}
|
||||
|
||||
// Meshtastic shows these hashes for the default key ("AQ==").
|
||||
void test_channel_hash_with_default_key() {
|
||||
TEST_ASSERT_EQUAL_UINT8(8, channelHash("LongFast", kDefaultKey, sizeof kDefaultKey));
|
||||
TEST_ASSERT_EQUAL_UINT8(31, channelHash("MediumFast", kDefaultKey, sizeof kDefaultKey));
|
||||
}
|
||||
|
||||
void test_djb2() {
|
||||
TEST_ASSERT_EQUAL_UINT32(5381, djb2(""));
|
||||
TEST_ASSERT_EQUAL_UINT32(130429955u, djb2("LongFast"));
|
||||
}
|
||||
|
||||
void test_eu868_presets() {
|
||||
TEST_ASSERT_EQUAL_size_t(7, kEu868PresetCount);
|
||||
const Preset& lf = kEu868Presets[0]; // the default comes first
|
||||
TEST_ASSERT_EQUAL_STRING("LongFast", lf.name);
|
||||
TEST_ASSERT_EQUAL_FLOAT(250.0f, lf.bwKHz);
|
||||
TEST_ASSERT_EQUAL_UINT8(11, lf.sf);
|
||||
TEST_ASSERT_EQUAL_UINT8(5, lf.cr);
|
||||
const Preset* ls = findPreset("LongSlow");
|
||||
TEST_ASSERT_NOT_NULL(ls);
|
||||
TEST_ASSERT_EQUAL_FLOAT(125.0f, ls->bwKHz);
|
||||
TEST_ASSERT_EQUAL_UINT8(12, ls->sf);
|
||||
TEST_ASSERT_EQUAL_UINT8(8, ls->cr);
|
||||
TEST_ASSERT_NULL(findPreset("ShortTurbo")); // 500 kHz doesn't fit the 250 kHz sub-band
|
||||
}
|
||||
|
||||
// The frequency slot comes from the channel name's hash; an unnamed channel uses the preset's name.
|
||||
void test_eu868_frequencies() {
|
||||
TEST_ASSERT_EQUAL_UINT32(869525000u, eu868FrequencyHz(*findPreset("LongFast")));
|
||||
TEST_ASSERT_EQUAL_UINT32(869525000u, eu868FrequencyHz(*findPreset("MediumFast")));
|
||||
TEST_ASSERT_EQUAL_UINT32(869462500u, eu868FrequencyHz(*findPreset("LongSlow")));
|
||||
TEST_ASSERT_EQUAL_UINT32(869587500u, eu868FrequencyHz(*findPreset("LongMod")));
|
||||
// A 250 kHz preset has one slot, whatever the channel's name.
|
||||
TEST_ASSERT_EQUAL_UINT32(869525000u, eu868FrequencyHz(*findPreset("LongFast"), "Belgium"));
|
||||
}
|
||||
|
||||
void test_radio_constants() {
|
||||
TEST_ASSERT_EQUAL_HEX8(0x2B, kSyncWord);
|
||||
TEST_ASSERT_EQUAL_UINT16(16, kPreambleLength);
|
||||
}
|
||||
|
||||
int main() {
|
||||
UNITY_BEGIN();
|
||||
RUN_TEST(test_header_fields);
|
||||
RUN_TEST(test_header_flags);
|
||||
RUN_TEST(test_header_from_old_firmware_has_no_hop_start);
|
||||
RUN_TEST(test_header_too_short);
|
||||
RUN_TEST(test_node_ids);
|
||||
RUN_TEST(test_channel_hash_with_default_key);
|
||||
RUN_TEST(test_djb2);
|
||||
RUN_TEST(test_eu868_presets);
|
||||
RUN_TEST(test_eu868_frequencies);
|
||||
RUN_TEST(test_radio_constants);
|
||||
return UNITY_END();
|
||||
}
|
||||
@@ -0,0 +1,75 @@
|
||||
#include <unity.h>
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "packet_view.h"
|
||||
|
||||
using namespace roro::lora;
|
||||
|
||||
void setUp() {}
|
||||
void tearDown() {}
|
||||
|
||||
static const uint8_t kMeshtastic[] = {
|
||||
0xFF, 0xFF, 0xFF, 0xFF, 0x78, 0x56, 0x34, 0x12, 0xEF, 0xBE, 0xAD, 0xDE,
|
||||
0x62, // hop start 3, hop limit 2: relayed once
|
||||
0x08, 0x00, 0x42, 0x01, 0x02, 0x03,
|
||||
};
|
||||
|
||||
void test_row_for_a_meshtastic_packet() {
|
||||
PacketSummary p{kMeshtastic, sizeof kMeshtastic, -97.4f, 6.25f, true, true};
|
||||
// Time, RSSI, SNR, then who sent it to whom (by default short name: the last 4 hex digits,
|
||||
// as Meshtastic names a Node) and how far it came. Fits 40 columns with two node numbers.
|
||||
TEST_ASSERT_EQUAL_STRING("21:45:07 -97 6.2 5678>all 1/3", row(p, "21:45:07").c_str());
|
||||
const uint8_t direct[] = {0x0a, 0x0b, 0x0c, 0x0d, 0xc4, 0xd3, 0xb2, 0xa1, 1, 2, 3, 4, 0x6a, 8, 0, 0xaa};
|
||||
PacketSummary d{direct, sizeof direct, -117.0f, -9.25f, true, true};
|
||||
TEST_ASSERT_EQUAL_STRING("21:45:07 -117 -9.2 d3c4>0b0a 1/3", row(d, "21:45:07").c_str());
|
||||
TEST_ASSERT_TRUE(row(d, "21:45:07").size() <= 38);
|
||||
}
|
||||
|
||||
void test_row_for_something_else() {
|
||||
const uint8_t data[] = {0x40, 0x01, 0x02};
|
||||
PacketSummary p{data, sizeof data, -120.6f, -7.5f, true, false};
|
||||
TEST_ASSERT_EQUAL_STRING("21:45:07 -121 -7.5 3 B", row(p, "21:45:07").c_str());
|
||||
}
|
||||
|
||||
// Not on Meshtastic settings (LoRaWAN, say): the same bytes aren't read as a Meshtastic header.
|
||||
void test_row_not_meshtastic() {
|
||||
PacketSummary p{kMeshtastic, sizeof kMeshtastic, -97.0f, 6.0f, true, false};
|
||||
TEST_ASSERT_EQUAL_STRING("21:45:07 -97 6.0 19 B", row(p, "21:45:07").c_str());
|
||||
}
|
||||
|
||||
void test_row_with_a_bad_crc() {
|
||||
PacketSummary p{kMeshtastic, sizeof kMeshtastic, -97.0f, 6.0f, false, true};
|
||||
TEST_ASSERT_EQUAL_STRING("21:45:07 -97 6.0 bad CRC, 19 B", row(p, "21:45:07").c_str());
|
||||
}
|
||||
|
||||
void test_hex_dump() {
|
||||
auto lines = hexDump(kMeshtastic, sizeof kMeshtastic);
|
||||
TEST_ASSERT_EQUAL_size_t(3, lines.size());
|
||||
TEST_ASSERT_EQUAL_STRING("0000 ff ff ff ff 78 56 34 12 ....xV4.", lines[0].c_str());
|
||||
TEST_ASSERT_EQUAL_STRING("0008 ef be ad de 62 08 00 42 ....b..B", lines[1].c_str());
|
||||
TEST_ASSERT_EQUAL_STRING("0010 01 02 03 ...", lines[2].c_str());
|
||||
}
|
||||
|
||||
void test_header_lines() {
|
||||
auto lines = headerLines(kMeshtastic, sizeof kMeshtastic);
|
||||
TEST_ASSERT_EQUAL_size_t(5, lines.size());
|
||||
TEST_ASSERT_EQUAL_STRING("From !12345678 to all", lines[0].c_str());
|
||||
TEST_ASSERT_EQUAL_STRING("Packet deadbeef", lines[1].c_str());
|
||||
TEST_ASSERT_EQUAL_STRING("Hops 1 of 3, limit 2 left", lines[2].c_str());
|
||||
TEST_ASSERT_EQUAL_STRING("Channel 0x08 (LongFast, default key)", lines[3].c_str());
|
||||
TEST_ASSERT_EQUAL_STRING("Relayed by ..42", lines[4].c_str());
|
||||
TEST_ASSERT_EQUAL_size_t(0, headerLines(kMeshtastic, 12).size()); // too short to be Meshtastic
|
||||
}
|
||||
|
||||
int main() {
|
||||
UNITY_BEGIN();
|
||||
RUN_TEST(test_row_for_a_meshtastic_packet);
|
||||
RUN_TEST(test_row_for_something_else);
|
||||
RUN_TEST(test_row_not_meshtastic);
|
||||
RUN_TEST(test_row_with_a_bad_crc);
|
||||
RUN_TEST(test_hex_dump);
|
||||
RUN_TEST(test_header_lines);
|
||||
return UNITY_END();
|
||||
}
|
||||
@@ -28,6 +28,8 @@ void test_defaults_when_store_is_empty() {
|
||||
TEST_ASSERT_TRUE(s.getBool(Setting::WifiEnabled));
|
||||
TEST_ASSERT_TRUE(s.getBool(Setting::GnssEnabled)); // Q58: on by default
|
||||
TEST_ASSERT_FALSE(s.getBool(Setting::CoordinatesDms)); // Q64: decimal degrees
|
||||
TEST_ASSERT_EQUAL_INT32(0, s.getInt(Setting::LoraPreset)); // Q95: LongFast
|
||||
TEST_ASSERT_FALSE(s.setInt(Setting::LoraPreset, 7)); // seven EU868 presets
|
||||
TEST_ASSERT_EQUAL_STRING("EU868", s.getString(Setting::Region).c_str());
|
||||
TEST_ASSERT_EQUAL_STRING("CET-1CEST,M3.5.0,M10.5.0/3", s.getString(Setting::Timezone).c_str());
|
||||
}
|
||||
|
||||
@@ -0,0 +1,74 @@
|
||||
#include <unity.h>
|
||||
|
||||
#include <vector>
|
||||
|
||||
#include "sweep_view.h"
|
||||
|
||||
using namespace roro::lora;
|
||||
|
||||
void setUp() {}
|
||||
void tearDown() {}
|
||||
|
||||
// 863.0 to 870.0 MHz in 100 kHz steps: 71 readings.
|
||||
static std::vector<int8_t> band(int8_t floor) { return std::vector<int8_t>(71, floor); }
|
||||
|
||||
void test_floor_is_the_median() {
|
||||
auto b = band(-95);
|
||||
b[10] = -60; // a few strong steps don't move the median
|
||||
b[11] = -62;
|
||||
b[50] = -70;
|
||||
SweepStats s = summarize(b.data(), b.size(), 863000000, 100000);
|
||||
TEST_ASSERT_EQUAL_INT(-95, s.floor);
|
||||
TEST_ASSERT_EQUAL_INT(-60, s.top);
|
||||
}
|
||||
|
||||
void test_peaks_strongest_first_and_merged() {
|
||||
auto b = band(-95);
|
||||
b[11] = -70; // 864.1 MHz, with shoulders: one peak, not three
|
||||
b[10] = -75;
|
||||
b[12] = -78;
|
||||
b[65] = -55; // 869.5 MHz
|
||||
b[30] = -90; // only 5 dB above the floor: not a peak
|
||||
SweepStats s = summarize(b.data(), b.size(), 863000000, 100000);
|
||||
TEST_ASSERT_EQUAL_size_t(2, s.peaks.size());
|
||||
TEST_ASSERT_EQUAL_UINT32(869500000u, s.peaks[0].hz);
|
||||
TEST_ASSERT_EQUAL_INT(-55, s.peaks[0].dbm);
|
||||
TEST_ASSERT_EQUAL_UINT32(864100000u, s.peaks[1].hz);
|
||||
}
|
||||
|
||||
void test_at_most_three_peaks() {
|
||||
auto b = band(-100);
|
||||
for (int i = 5; i < 70; i += 10) b[i] = static_cast<int8_t>(-80 + i / 10);
|
||||
SweepStats s = summarize(b.data(), b.size(), 863000000, 100000);
|
||||
TEST_ASSERT_EQUAL_size_t(3, s.peaks.size());
|
||||
TEST_ASSERT_EQUAL_INT(-74, s.peaks[0].dbm); // the strongest three
|
||||
}
|
||||
|
||||
void test_flat_band_has_no_peaks() {
|
||||
auto b = band(-88);
|
||||
SweepStats s = summarize(b.data(), b.size(), 863000000, 100000);
|
||||
TEST_ASSERT_EQUAL_size_t(0, s.peaks.size());
|
||||
TEST_ASSERT_EQUAL_INT(-88, s.floor);
|
||||
}
|
||||
|
||||
// The waterfall's scale: dark at the bottom, through blue and green to red at the top.
|
||||
void test_heat_scale() {
|
||||
TEST_ASSERT_EQUAL_UINT8(0, heatLevel(-130, -120, -60));
|
||||
TEST_ASSERT_EQUAL_UINT8(0, heatLevel(-120, -120, -60));
|
||||
TEST_ASSERT_EQUAL_UINT8(255, heatLevel(-60, -120, -60));
|
||||
TEST_ASSERT_EQUAL_UINT8(255, heatLevel(-20, -120, -60));
|
||||
TEST_ASSERT_EQUAL_UINT8(128, heatLevel(-90, -120, -60));
|
||||
TEST_ASSERT_TRUE(heatColor(0) != heatColor(255));
|
||||
TEST_ASSERT_EQUAL_HEX16(0x0000, heatColor(0)); // black
|
||||
TEST_ASSERT_EQUAL_HEX16(0xF800, heatColor(255)); // red
|
||||
}
|
||||
|
||||
int main() {
|
||||
UNITY_BEGIN();
|
||||
RUN_TEST(test_floor_is_the_median);
|
||||
RUN_TEST(test_peaks_strongest_first_and_merged);
|
||||
RUN_TEST(test_at_most_three_peaks);
|
||||
RUN_TEST(test_flat_band_has_no_peaks);
|
||||
RUN_TEST(test_heat_scale);
|
||||
return UNITY_END();
|
||||
}
|
||||
Reference in New Issue
Block a user