S1 plan: the resting loop and the GNSS pause ship in v0.8.1

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EhqxQ49eCju4CzKYNjZzwT

CONTEXT.md

@@ -69,7 +69,7 @@ The Service that owns the Wi-Fi radio. It's always in exactly one mode: *Off*, *
 _Avoid_: network manager
 
 **Saved Network**:
-A Wi-Fi network the device may join on its own (name, password). When several are in range, the strongest wins.
+A Wi-Fi network the device may join on its own: its name, its password, and how it gets its address, *Automatic* (DHCP) or *Fixed* (an address, a prefix and an optional gateway typed in Settings). When several are in range, the strongest wins.
 _Avoid_: profile, known network
 
 **IRC Service**:

README.md

@@ -54,6 +54,24 @@ To install from the SD card instead, copy the `.ota` file from `.pio/build/cardp
 
 **The private key** lives in `~/.config/roro9stack/ota-key.pem` and must never be committed. If it's lost, generate a new pair and flash once over USB.
 
+## Networks without DHCP
+
+Each Saved Network gets its address automatically (DHCP) or has a Fixed one (docs/milestones/S1.md): in Settings > Wi-Fi, Enter on a network opens its page, where "IP address" switches between Automatic and Fixed, with an address, a prefix length (24 is 255.255.255.0) and an optional gateway. Switching to Fixed starts from what the network is giving the device at that moment. The setting is checked and applied when you leave the page. IPv4 only.
+
+"DNS and NTP" on the same screen holds two DNS servers (9.9.9.9 and 1.1.1.1 by default), used on Fixed networks, or on every network with "Always use my DNS"; and two NTP servers (pool.ntp.org and time.cloudflare.com), used after any the network's DHCP offers. Enter on "Status" shows what's in use and where each value came from.
+
+## System
+
+The System App (docs/milestones/S1.md) shows what the device is doing, live and read-only, in any build. Tab moves between five views:
+
+- **Overview:** each core's load, free memory, network traffic, battery, uptime and chip temperature, and both cores' load over the last two minutes.
+- **Tasks:** every FreeRTOS task with its core, its share of a core over the last second, and the least stack it ever had left (in the warning colour under 512 bytes). `s` sorts by share, stack or name.
+- **Memory:** free heap, the lowest since boot and the largest free block, with two minutes of free heap drawn against the three memory floors (55, 40 and 20 KB).
+- **Network:** the connection, then for IRC, Gemini, the Debug Console and Firmware Updates the bytes read and written since boot and what's moving now. For TLS connections these are the bytes the service sees, without the encryption overhead.
+- **System:** what `info` prints, plus the battery, the SD card with its write faults, the radio and the GNSS receiver.
+
+It samples once a second and keeps its history only while it's open.
+
 ## Gemini
 
 The Gemini App browses Geminispace (docs/milestones/G1.md): Tab and Shift+Tab pick a link, Enter follows it, Back returns (to where the page was scrolled), Space pages down, `g` types an address. Certificates are trusted on first use; a changed one stops the page and asks.
@@ -62,7 +80,7 @@ On a page, `b` bookmarks it, `s` saves it to the SD card to read offline (a non-
 
 ## 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.
+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 GNSS receiver on the same Cap raises the radio's noise floor by 8 dB while it runs: Settings > "Pause GNSS for LoRa" (off by default) puts it in standby while the radio listens, except during a Track. 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
 
@@ -75,7 +93,10 @@ The LoRa Scanner (docs/milestones/M3.md) listens with the Cap's radio and **neve
 | `sound on` / `sound off` | Toggles the Sound setting (beep + LED) |
 | `short` / `normal` | Screen timeouts 5 s / 10 s, or 30 s / 60 s |
 | `wifi add <ssid><TAB><password>` | Adds a Saved Network (so credentials stay out of the repo) |
+| `wifi ip <ssid> dhcp` / `wifi ip <ssid> <address>/<prefix> [gateway]` | A Saved Network's IP setting: Automatic, or Fixed. Debug Builds: add `try <seconds>` to go back to the previous setting unless `wifi ip keep` follows |
+| `wifi dns <a> [b]` / `wifi dns always on\|off` / `wifi ntp <a> [b]` | DNS servers (used on Fixed networks, or always), and NTP servers |
 | `log <text>` | Appends a line to a test IRC Log (`/irc/dev/#test/<date>.log`) |
+| `sd card` | What the SD card says it is: type, size, and its identity register (maker, name, revision, serial, date) |
 | `sd list` | Lists the files of each Storage Clean-up category |
 | `cat <path>` | Prints the first ~1.2 KB of a file on the SD card |
 | `irc start` | Starts the IRC Service (normally done by opening the IRC App) |
@@ -84,9 +105,10 @@ The LoRa Scanner (docs/milestones/M3.md) listens with the Cap's radio and **neve
 | `gemini trust <host> <port> <sha256>` | Pins a certificate by hand (the Gemini App asks when one changes) |
 | `irc say <buffer> <text>` | Types into a Buffer, commands included (`irc say 0 /join #test`) |
 | `irc dump` | Prints IRC status, memory, and the last lines of each Buffer |
-| `wifi status` | Prints Wi-Fi state, network, signal, clock and free heap |
-| `info` | Firmware, uptime, last start reason, memory, Wi-Fi, and both app slots with their versions and OTA states |
-| `tasks` | FreeRTOS tasks: state, priority, lowest free stack, CPU share |
+| `wifi status` | Prints Wi-Fi state, network, signal, clock and free heap, then the address, gateway, DNS and NTP servers in use and where each came from |
+| `info` | Firmware, uptime, last start reason, memory, Wi-Fi, the SD card and its write faults since boot, and both app slots with their versions and OTA states |
+| `tasks` | FreeRTOS tasks over the next second: state, priority, lowest free stack, share of a core, each core's load, and how many passes the main loop made |
+| `net` | Bytes each network service has read and written since boot |
 | `reboot` / `boot other` | Restart, or restart into the other app slot (a manual Rollback) |
 | `log level <0-5>` | ESP-IDF log level |
 | `ls [folder]` / `rm <path>` | Lists a folder of the SD card, or deletes a file |
@@ -97,9 +119,12 @@ The LoRa Scanner (docs/milestones/M3.md) listens with the Cap's radio and **neve
 | `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 |
+| `gnss quiet on` / `gnss quiet off` | The "Pause GNSS for LoRa" setting |
+| `lora noise test [gnss\|quiet]` / `lora noise report` | Debug Builds: Sweep under one changed condition at a time to find what raises the noise floor (Wi-Fi goes off for a few seconds); then the result |
 | `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 |
+| `loop spin on` / `loop spin off` | Debug Builds: make the main loop spin without resting, to compare load and radio noise |
 | `crash abort` / `crash wdt` | Debug Builds: crash on purpose, or hang the main loop until the watchdog fires |
 | `help` | Lists the commands |
 

docs/adr/0007-own-copy-of-the-sd-driver.md

@@ -0,0 +1,20 @@
+# Our own copy of the SD driver, for one missing byte
+
+Arduino-ESP32's `SD` library talks to the card over SPI through `sd_diskio.cpp`. That driver gives up on a write without saying why, and about once in 1,500 multi-block writes it gave up on one that had worked (issue #21). A 1.7 MB upload failed about three times in ten; before M3, the retry on top of it then filled the gap with zeros.
+
+The cause, measured with a driver that records where it stops: after the "Stop Tran" token that ends a multi-block write, a card takes about a byte of clock to signal busy. The driver deselects, selects again, and reads one byte to see whether the card is ready. Read too early, that byte is 0xFF, "ready"; the status check (CMD13) then goes out while the card is still programming, and its answer (0xFF, 0x1F) is taken for an error. Every failure seen was this one: all blocks accepted, then a status that isn't one. ChaN's reference driver, which FatFs ships as its example, sends a dummy byte after selecting the card for this reason. Arduino's doesn't.
+
+PlatformIO links the framework's library objects directly, so one file can't be replaced from `src`. A project library with the same name takes its place: **`lib/SD` is Arduino-ESP32 3.3.12's SD library (Apache-2.0), with `sd_diskio.cpp` changed** and the other files as they came. The changes are marked `roro:`:
+
+- A dummy byte after selecting the card, before the ready test, and one after Stop Tran.
+- Each place a write gives up records the step and the card's answer (`sd_fault.h`): `info` shows the count, and the Debug Console's `put` prints the detail.
+
+Halving the SPI clock to 10 MHz didn't change the failure rate, so the card stays at 20 MHz.
+
+## Consequences
+
+- 30 uploads of 1.7 MB in a row, each read back and compared by SHA-256, ten of them with the LoRa radio listening on the same bus: no write fault. Before: 3 failures in 10.
+- Every writer gains: Logs, Tracks, Gemini pages, Saved Pages, Captures and Update Files installed from the card all go through this driver, and none of them checked.
+- **The copy has to follow the framework.** When the platform is updated, compare `lib/SD` with the new `libraries/SD` and carry the `roro:` changes over. If upstream fixes the ready test, drop the copy. Reported as [arduino-esp32#12970](https://github.com/espressif/arduino-esp32/issues/12970); issue #39 follows it.
+- One more defect was read in the code and left alone, because nothing here exercises it: the driver tests the card's answer to a data block against 0x0A and 0x0C, values it can't take (accepted is 0x05, CRC error 0x0B, write error 0x0D), so a block rejected for a CRC error is never resent. No such rejection was seen in any failure. If `DataToken` faults ever show in `info`, that's the next fix.
+- A fault is now counted and explained instead of silent, so the next cause, if there is one, starts with evidence.

docs/milestones/S1.md

@@ -0,0 +1,138 @@
+# S1 — System basics
+
+**Status:** the three planned items are done: the SD driver fix in v0.6.1 (issue #21, ADR 0007), fixed IPv4 settings in v0.7.0 (issue #7), the System App in v0.8.0 (issue #11). v0.8.1 adds the resting main loop (issue #40) and the GNSS pause for the radio's noise (issue #20, still open for the 11 dB that remain). Still open in the milestone: #39, following the SD driver upstream.
+
+**Goal:** the device works on any network, the card can be trusted, and you can see what the system is doing. A side milestone, like G1.
+
+## Fixed IPv4, DNS and NTP (issue #7)
+
+Not every network has a DHCP server: a lab bench, a direct link to a router, a network where addresses are handed out by hand. Until now every Saved Network used DHCP, DNS always came from DHCP, and the NTP server was `pool.ntp.org`, hard-coded.
+
+**IPv4 only.** IPv6 isn't part of this, now or as a planned follow-up.
+
+### Decisions (design round 2026-10-05)
+
+| # | Decision |
+|---|---|
+| Q105 | The IP setting is **per Saved Network**: *Automatic* (DHCP, as before) or *Fixed*, with its own address, prefix and gateway. New networks start Automatic. |
+| Q106 | The subnet is entered as a **prefix length** (`24`), with the mask shown next to it. |
+| Q107 | The **gateway is optional**: left empty, the device talks to its own subnet only. |
+| Q108 | **DNS is global:** two servers in Settings, used on every Fixed network. On Automatic networks DHCP's DNS is used, unless **"Always use my DNS"** is on. |
+| Q109 | DNS defaults: **9.9.9.9** (Quad9), then **1.1.1.1** (Cloudflare). |
+| Q110 | **NTP is global:** two servers in Settings, names or addresses, defaulting to `pool.ntp.org` and `time.cloudflare.com`. NTP servers offered by DHCP are used first. GNSS still outranks NTP for the clock. |
+| Q111 | What's typed is checked, host-tested in `lib/wifi`: an address is four numbers from 0 to 255; a prefix is 1 to 30; the address isn't the subnet's network or broadcast address; the gateway is inside the subnet and isn't the device's own address. Refusals say why. |
+| Q112 | Addresses are typed in the line editor, limited to digits and dots. |
+| Q113 | Enter on a Saved Network opens **its page** (IP, Address, Prefix, Gateway, Forget) instead of asking to forget it. Settings > Wi-Fi gains DNS servers, "Always use my DNS" and NTP servers. The Status row opens **connection details**: address, mask, gateway, DNS and NTP in use, and where each came from. |
+| Q114 | A change applies **at once**: the network in use reconnects with the new settings. No automatic way back; the keyboard still works if Wi-Fi is cut. |
+| Q115 | Console: `wifi status` shows address, gateway, DNS, NTP and their sources; `wifi ip <ssid> dhcp`, `wifi ip <ssid> <address>/<prefix> [gateway]`, `wifi dns <a> [b]`, `wifi ntp <a> [b]`. Debug Builds: `wifi ip … try 60` goes back to the previous setting after 60 s unless confirmed with `wifi ip keep`. |
+| Q116 | Left out: checking whether the address is already taken, and per-network DNS. |
+
+The SDK already allows 3 NTP servers and 3 DNS servers and can take NTP servers from DHCP (`CONFIG_LWIP_SNTP_MAX_SERVERS=3`, `CONFIG_LWIP_DHCP_GET_NTP_SRV=y`), so the framework isn't rebuilt for this.
+
+### Done when
+
+- A Saved Network set to Fixed joins with that address, mask and gateway, and the device reaches the internet (IRC, Gemini, NTP) through the DNS servers from Settings.
+- Set back to Automatic, it gets its address from DHCP again.
+- With "Always use my DNS" on, an Automatic network resolves through the servers from Settings.
+- The NTP servers from Settings set the clock.
+- Wrong entries are refused with a reason, in Settings and on the console.
+- Connection details show what's in use and where it came from.
+- Tested on `knbg-guests` with 10.39.39.12 (the device's DHCP lease) and 10.39.39.13 (free: the device is alone on that network).
+
+### Measured (2026-10-05 and 06, on `knbg-guests`)
+
+The network is 10.39.39.0/24, gateway 10.39.39.1; DHCP gives 10.39.39.1 as DNS and offers no NTP server.
+
+- **Fixed 10.39.39.12/24** (the device's own lease) and **Fixed 10.39.39.13/24**, gateway 10.39.39.1: the device joins with that address, DNS is 9.9.9.9 and 1.1.1.1 from Settings, and a Gemini page loads (name resolution, routing, TLS). On .13, .12 no longer answers.
+- **A wrong gateway** (10.39.39.254) on a 60 s trial: the device stops answering from another subnet, and comes back by itself with the previous setting.
+- **Back to Automatic:** 10.39.39.12 by DHCP again, DNS 10.39.39.1 from DHCP.
+- **"Always use my DNS"** on an Automatic network: DNS becomes 9.9.9.9 and 1.1.1.1; switched off, the device joins again and has DHCP's DNS back.
+- **NTP:** `pool.ntp.org` answers; set to `time.cloudflare.com` alone, that one answers within 25 s.
+- **Refusals**, on the console and in Settings: the network's own address, a gateway outside the subnet, a prefix of 31 or 99, 10.39.39.300, an unknown network, a DNS name where an address is needed, a host name with an underscore.
+- **In Settings:** the network's page pre-fills Fixed with the address, prefix and gateway in use; leaving the page applies it; connection details show each value and where it came from.
+- **Not tested:** NTP servers offered by DHCP (this network offers none), and a Fixed network with no gateway.
+
+### Work breakdown
+
+1. **IPv4 logic** (host-tested): parsing and formatting addresses, prefix and mask, the checks of Q111.
+2. **Storage:** the IP setting in each Saved Network; DNS, "Always use my DNS" and NTP in Settings.
+3. **Wi-Fi Service:** apply it when joining; DNS and NTP; `wifi status` and the console commands.
+4. **Settings:** the network page, the DNS and NTP rows, connection details.
+5. **Tests on the device**, recorded here.
+
+## System Monitor (issue #11)
+
+Every milestone so far was driven by measurements, heap floors, stack sizes, TLS dips, that needed a Debug Build and a computer. The System App shows them on the device, in any build.
+
+### Decisions (design round 2026-10-06)
+
+| # | Decision |
+|---|---|
+| Q117 | An App of its own, **System**, in release builds too. Read-only. |
+| Q118 | Four views, switched with Tab: **Overview** (CPU per core, memory, network, battery), **Tasks**, **Memory**, **System**. |
+| Q119 | Sampled once a second. A task's share is its run time over the last second; a core's load is 100 % minus its idle task's share. |
+| Q120 | **History only while the App is open:** two minutes at one sample a second, about 1 KB. The system already keeps what matters afterwards: the lowest free heap since boot and each task's lowest free stack. |
+| Q121 | **Bytes are counted per service:** IRC, Gemini, the Debug Console and Firmware Updates add what they read and write to a shared counter. The network view shows the connection details, each service's bytes in and out, and the signal strength. |
+| Q122 | Tasks: name, core, share, state and lowest free stack, sorted by share; `s` cycles the sort (share, stack, name). **Under 512 bytes of stack left shows in the warning colour.** |
+| Q123 | Memory: free heap, lowest since boot, largest free block, and a two-minute graph of free heap **with the floors of Q86 drawn as lines** (55, 40 and 20 KB). |
+| Q124 | System: uptime and why it last started, firmware and both app slots, chip temperature and CPU frequency, battery voltage and percentage, SD usage and write faults, the radio's and the GNSS receiver's state. |
+| Q125 | `info` and `tasks` are split into a **snapshot** that the console and the App share; the arithmetic (shares from two samples, sorting, the stack warning) is host-tested. |
+| Q126 | Left out: acting on tasks, an event log, exporting snapshots to the card. |
+| Q127 | The main loop uses about 81 % of a core. The App shows it; fixing it is issue #40, not part of #11. |
+
+The App has five views, not four: Q121's network view is one of its own (Overview, Tasks, Memory, Network, System).
+
+### Measured (2026-10-06)
+
+- **Traffic counters are exact.** A Gemini fetch of a 164,970-byte page counts 164,986 bytes in (the page and its 16-byte header line) and 42 out (the 40-character URL and CRLF). A 1,797,760-byte upload counts 1,798,123 in for the Debug Console, commands included.
+- **The Memory view shows a TLS dip as it happens.** Starting IRC and a 165 KB Gemini fetch together: free heap falls from about 100 KB through the three floors to a low of 12.1 KB, then settles near 50 KB. That's the dip accepted in G1 (Q86).
+- **A run-time counter only moves when its task is switched out.** FreeRTOS adds to a task's run time at the context switch. The main loop takes the samples, and with core 1 to itself it's never switched out: its counter said 2 % while the core's idle task had 0 %. So the task that samples gets what's left of its core. With that: **the main loop uses 100 % of core 1 at rest** (issue #40 said 81 %, an average since boot).
+- **`tasks` on the console** sampled twice inside one command at first, a quarter second apart, and showed the loop at 1 %: it was asleep in the command's own wait. It now samples, lets the loop run for a second, and prints.
+- **Low stack, flagged:** `IDLE0` (232 bytes left), `IDLE1` (328 to 352) and `spk_task` (256 to 264), all the framework's own tasks.
+- **Cost:** 15.6 KB of flash for the App and the counters (1,742,723 bytes, release). Nothing while it's closed; about 2 KB of history and samples while it's open.
+
+## The main loop rests (issue #40)
+
+The loop polled the keyboard, ticked the Services, ran the consoles and redrew when needed, then came straight back: 50,000 passes a second, and core 1 100 % busy with the device idle and the screen off.
+
+Nothing needs that. The keyboard controller buffers key events; the consoles and the radio have their own tasks or interrupts; no Service asks for a tick more often than every 50 ms. So after each pass the loop now rests: **5 ms with the screen on, 20 ms with it off**, and not at all during a serial file transfer (`sd put`), which reads its bytes from the loop. Safe Mode's loop rests 5 ms too. Debug Builds have `loop spin on|off` to bring the old behaviour back for comparison.
+
+### Measured (2026-10-06, Debug Build, Wi-Fi connected, GNSS on, on USB power)
+
+| | Spinning | Resting |
+|---|---|---|
+| Passes a second, screen off | 50,160 | 50 |
+| Core 1 load, screen off | 100 % | 1 % |
+| Passes a second, screen on (Launcher) | 1,203 | 167 |
+| Core 1 load, screen on | 62 % | 10 % |
+| Chip temperature at rest, settled | 38.3 C | 34.3 C |
+| A 1.8 MB upload over the Debug Console | about 230 KB/s | 288 KB/s |
+
+- Still working at this pace: GNSS (a 3D Fix, 22 satellites), a Gemini fetch (52 KB), the upload read back by SHA-256, the Sweep (still 606 to 610 ms a pass), the radio's DIO1 interrupt.
+- **Not measured:** the current drawn (no meter on the battery line), and how typing feels on the real keyboard: a key now waits up to 5 ms for the loop, 20 ms if it's the one that wakes the screen.
+- **The radio's noise floor didn't move** (-97 to -99 dBm at 125 kHz either way): the spinning loop wasn't the source (issue #20).
+- **Not done:** real sleep. The framework is built without power management (`CONFIG_PM_ENABLE` is off), so an idle core only halts until the next interrupt. Automatic light sleep would need the framework rebuilt with it, Wi-Fi in modem sleep, and the USB serial port's behaviour checked. A next step if battery life calls for it.
+
+## The radio's noise: the GNSS receiver (issue #20)
+
+M3 found the LoRa radio's noise floor about 15 dB above what the chip hears alone, and that the source travels with the device. Which part? Debug Builds got a self-test, `lora noise test`: it changes one thing at a time, Sweeps the band eight passes (568 readings), records the median as the floor, and puts the thing back. It runs on the device by itself, because one condition switches Wi-Fi off, and `lora noise report` prints the result afterwards.
+
+### Measured (2026-10-06, indoors, on USB power, dBm at 125 kHz)
+
+| Condition | Floor |
+|---|---|
+| Antenna switched off (the chip alone) | -117 |
+| Antenna on, GNSS in standby | -106 |
+| Antenna on, GNSS running (as shipped) | -98 |
+
+- **The GNSS receiver, while it runs, raises the floor by 8 dB.** Three runs: -98 or -99 with it running, -106 in standby, every time. On LongFast (250 kHz) the Sniffer's own reading goes from about -93.5 to -101.5 dBm.
+- **It's the receiver working, not its serial line:** with one NMEA sentence a second instead of twenty (`PCAS03`), the receiver still tracking, the floor stays at -98.
+- **Nothing else moves it by more than 1 dB**, with GNSS running or in standby: the main loop spinning or resting, the CPU at 240, 160 or 80 MHz, Wi-Fi on or off, the screen on or off, the radio chip's regulator as DC-DC or LDO, its receive gain boosted or not.
+- **11 dB remain** between the antenna connected with GNSS quiet (-106) and the chip alone (-117). It comes in through the antenna and none of those switches changes it: the surroundings, or parts of the Cardputer that can't be switched off. Not separated: that needs another place, or the antenna on a cable away from the case.
+- M3's quick check had GNSS at "1 or 2 dB": it read one frequency for a few seconds, in a noisier spot. The median over the band is the better measure.
+
+### What the firmware does about it
+
+**Settings > Pause GNSS for LoRa**, off by default: while the LoRa radio listens or sweeps, the GNSS receiver waits in standby, and wakes when the radio goes back to sleep (a Fix again after about 7 s here). Never during a Track. The GNSS App says "GNSS is paused" meanwhile. `gnss quiet on|off` on the console.
+
+It's off by default because GNSS on by default was decided in M2 (Q58), and from M4 the radio listens all the time: then "pause while listening" means GNSS mostly off, which is a decision about position, the clock and Tracks, for M4's design round (issue #23).

lib/SD/library.json

@@ -0,0 +1,7 @@
+{
+  "name": "SD",
+  "version": "3.3.12",
+  "description": "roro9stack's copy of Arduino-ESP32's SD library (Apache-2.0), shadowing the framework's. Only sd_diskio.cpp is changed (marked \"roro:\"): it records why a write failed and resends a block the card rejects. See issue #21.",
+  "frameworks": "arduino",
+  "platforms": "espressif32"
+}

lib/SD/src/SD.cpp

@@ -0,0 +1,134 @@
+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "vfs_api.h"
+#include "sd_diskio.h"
+#include "ff.h"
+#include "FS.h"
+#include "SD.h"
+
+using namespace fs;
+
+SDFS::SDFS(FSImplPtr impl) : FS(impl), _pdrv(0xFF) {}
+
+SDFS::~SDFS() {
+  end();
+}
+
+bool SDFS::begin(uint8_t ssPin, SPIClass &spi, uint32_t frequency, const char *mountpoint, uint8_t max_files, bool format_if_empty) {
+  if (_pdrv != 0xFF) {
+    return true;
+  }
+
+  if (!spi.begin()) {
+    return false;
+  }
+
+  _pdrv = sdcard_init(ssPin, &spi, frequency);
+  if (_pdrv == 0xFF) {
+    return false;
+  }
+
+  if (!sdcard_mount(_pdrv, mountpoint, max_files, format_if_empty)) {
+    sdcard_unmount(_pdrv);
+    sdcard_uninit(_pdrv);
+    _pdrv = 0xFF;
+    return false;
+  }
+
+  _impl->mountpoint(mountpoint);
+  return true;
+}
+
+void SDFS::end() {
+  if (_pdrv != 0xFF) {
+    _impl->mountpoint(NULL);
+    sdcard_unmount(_pdrv);
+
+    sdcard_uninit(_pdrv);
+    _pdrv = 0xFF;
+  }
+}
+
+sdcard_type_t SDFS::cardType() {
+  if (_pdrv == 0xFF) {
+    return CARD_NONE;
+  }
+  return sdcard_type(_pdrv);
+}
+
+uint64_t SDFS::cardSize() {
+  if (_pdrv == 0xFF) {
+    return 0;
+  }
+  size_t sectors = sdcard_num_sectors(_pdrv);
+  size_t sectorSize = sdcard_sector_size(_pdrv);
+  return (uint64_t)sectors * sectorSize;
+}
+
+size_t SDFS::numSectors() {
+  if (_pdrv == 0xFF) {
+    return 0;
+  }
+  return sdcard_num_sectors(_pdrv);
+}
+
+size_t SDFS::sectorSize() {
+  if (_pdrv == 0xFF) {
+    return 0;
+  }
+  return sdcard_sector_size(_pdrv);
+}
+
+uint64_t SDFS::totalBytes() {
+  FATFS *fsinfo;
+  DWORD fre_clust;
+  char drv[3] = {(char)(48 + _pdrv), ':', 0};
+  if (f_getfree(drv, &fre_clust, &fsinfo) != 0) {
+    return 0;
+  }
+  uint64_t size = ((uint64_t)(fsinfo->csize)) * (fsinfo->n_fatent - 2)
+#if _MAX_SS != 512
+                  * (fsinfo->ssize);
+#else
+                  * 512;
+#endif
+  return size;
+}
+
+uint64_t SDFS::usedBytes() {
+  FATFS *fsinfo;
+  DWORD fre_clust;
+  char drv[3] = {(char)(48 + _pdrv), ':', 0};
+  if (f_getfree(drv, &fre_clust, &fsinfo) != 0) {
+    return 0;
+  }
+  uint64_t size = ((uint64_t)(fsinfo->csize)) * ((fsinfo->n_fatent - 2) - (fsinfo->free_clst))
+#if _MAX_SS != 512
+                  * (fsinfo->ssize);
+#else
+                  * 512;
+#endif
+  return size;
+}
+
+bool SDFS::readRAW(uint8_t *buffer, uint32_t sector) {
+  return sd_read_raw(_pdrv, buffer, sector);
+}
+
+bool SDFS::writeRAW(uint8_t *buffer, uint32_t sector) {
+  return sd_write_raw(_pdrv, buffer, sector);
+}
+
+SDFS SD = SDFS(FSImplPtr(new VFSImpl()));

lib/SD/src/SD.h

@@ -0,0 +1,55 @@
+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#ifndef _SD_H_
+#define _SD_H_
+
+#include "FS.h"
+#include "SPI.h"
+#include "sd_defines.h"
+
+namespace fs {
+
+class SDFS : public FS {
+protected:
+  uint8_t _pdrv;
+
+public:
+  SDFS(FSImplPtr impl);
+  ~SDFS();
+  bool begin(
+    uint8_t ssPin = SS, SPIClass &spi = SPI, uint32_t frequency = 4000000, const char *mountpoint = "/sd", uint8_t max_files = 5, bool format_if_empty = false
+  );
+  void end();
+  sdcard_type_t cardType();
+  uint64_t cardSize();
+  size_t numSectors();
+  size_t sectorSize();
+  uint64_t totalBytes();
+  uint64_t usedBytes();
+  bool readRAW(uint8_t *buffer, uint32_t sector);
+  bool writeRAW(uint8_t *buffer, uint32_t sector);
+};
+
+}  // namespace fs
+
+#if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_SD)
+extern fs::SDFS SD;
+#endif
+
+using namespace fs;
+typedef fs::File SDFile;
+typedef fs::SDFS SDFileSystemClass;
+#define SDFileSystem SD
+
+#endif /* _SD_H_ */

lib/SD/src/sd_defines.h

@@ -0,0 +1,25 @@
+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#ifndef _SD_DEFINES_H_
+#define _SD_DEFINES_H_
+
+typedef enum {
+  CARD_NONE,
+  CARD_MMC,
+  CARD_SD,
+  CARD_SDHC,
+  CARD_UNKNOWN
+} sdcard_type_t;
+
+#endif /* _SD_DISKIO_H_ */

lib/SD/src/sd_diskio.cpp

@@ -0,0 +1,949 @@
+// roro9stack's copy of the SD-over-SPI driver from Arduino-ESP32 3.3.12 (libraries/SD/src/
+// sd_diskio.cpp), linked instead of the framework's: defining every function the SD class needs
+// keeps the library's file out of the link. Changes are marked "roro:". Why (issue #21): the
+// original gives up on a write without saying why, and never resends a block the card rejects.
+//
+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Disable the automatic pin remapping of the API calls in this file
+#define ARDUINO_CORE_BUILD
+
+#include "Arduino.h"
+#include "sd_diskio.h"
+#include "esp_system.h"
+#include "esp32-hal-periman.h"
+
+extern "C" {
+#include "ff.h"
+#include "diskio.h"
+#if ESP_IDF_VERSION_MAJOR > 3
+#include "diskio_impl.h"
+#endif
+//#include "esp_vfs.h"
+#include "esp_vfs_fat.h"
+
+char CRC7(const char *data, int length);
+unsigned short CRC16(const char *data, int length);
+}
+
+// roro: why the last write failed.
+#include "sd_fault.h"
+static roro::SdFault s_fault;
+static bool sdFault(roro::SdFault::Step step, uint8_t token = 0, uint32_t resp = 0) {
+  s_fault.step = step;
+  s_fault.token = token;
+  s_fault.resp = resp;
+  s_fault.count++;
+  return false;
+}
+namespace roro {
+SdFault sdLastFault() { return s_fault; }
+}  // namespace roro
+
+typedef enum {
+  GO_IDLE_STATE = 0,
+  SEND_OP_COND = 1,
+  SEND_CID = 2,
+  SEND_RELATIVE_ADDR = 3,
+  SEND_SWITCH_FUNC = 6,
+  SEND_IF_COND = 8,
+  SEND_CSD = 9,
+  STOP_TRANSMISSION = 12,
+  SEND_STATUS = 13,
+  SET_BLOCKLEN = 16,
+  READ_BLOCK_SINGLE = 17,
+  READ_BLOCK_MULTIPLE = 18,
+  SEND_NUM_WR_BLOCKS = 22,
+  SET_WR_BLK_ERASE_COUNT = 23,
+  WRITE_BLOCK_SINGLE = 24,
+  WRITE_BLOCK_MULTIPLE = 25,
+  APP_OP_COND = 41,
+  APP_CLR_CARD_DETECT = 42,
+  APP_CMD = 55,
+  READ_OCR = 58,
+  CRC_ON_OFF = 59
+} ardu_sdcard_command_t;
+
+// Align with ESP-IDF sdmmc SPI init (ACMD41 timeout must be >1s per SD spec)
+static constexpr uint32_t sd_go_idle_delay_ms = 20;
+static constexpr uint32_t sd_op_cond_timeout_ms = 3000;
+
+typedef struct {
+  uint8_t ssPin;
+  SPIClass *spi;
+  int frequency;
+  char *base_path;
+  sdcard_type_t type;
+  unsigned long sectors;
+  bool supports_crc;
+  int status;
+} ardu_sdcard_t;
+
+static ardu_sdcard_t *s_cards[FF_VOLUMES] = {NULL};
+
+#if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_ERROR
+const char *fferr2str[] = {
+  "(0) Succeeded",
+  "(1) A hard error occurred in the low level disk I/O layer",
+  "(2) Assertion failed",
+  "(3) The physical drive cannot work",
+  "(4) Could not find the file",
+  "(5) Could not find the path",
+  "(6) The path name format is invalid",
+  "(7) Access denied due to prohibited access or directory full",
+  "(8) Access denied due to prohibited access",
+  "(9) The file/directory object is invalid",
+  "(10) The physical drive is write protected",
+  "(11) The logical drive number is invalid",
+  "(12) The volume has no work area",
+  "(13) There is no valid FAT volume",
+  "(14) The f_mkfs() aborted due to any problem",
+  "(15) Could not get a grant to access the volume within defined period",
+  "(16) The operation is rejected according to the file sharing policy",
+  "(17) LFN working buffer could not be allocated",
+  "(18) Number of open files > FF_FS_LOCK",
+  "(19) Given parameter is invalid"
+};
+#endif
+
+/*
+ * SD SPI
+ * */
+
+bool sdWait(uint8_t pdrv, int timeout) {
+  char resp;
+  uint32_t start = millis();
+
+  do {
+    resp = s_cards[pdrv]->spi->transfer(0xFF);
+  } while (resp == 0x00 && (millis() - start) < (unsigned int)timeout);
+
+  if (!resp) {
+    log_w("Wait Failed");
+  }
+  return (resp > 0x00);
+}
+
+void sdStop(uint8_t pdrv) {
+  s_cards[pdrv]->spi->write(0xFD);
+}
+
+void sdDeselectCard(uint8_t pdrv) {
+  ardu_sdcard_t *card = s_cards[pdrv];
+  digitalWrite(card->ssPin, HIGH);
+}
+
+bool sdSelectCard(uint8_t pdrv) {
+  ardu_sdcard_t *card = s_cards[pdrv];
+  digitalWrite(card->ssPin, LOW);
+  // roro: one dummy byte before asking whether the card is ready, as ChaN's reference driver does.
+  // A card that has just been given a write takes about a byte of clock to signal busy; without
+  // this, that first byte reads 0xFF, "ready", and the next command (the status check after a
+  // write) goes out while the card is still programming and comes back as garbage (#21).
+  card->spi->transfer(0xFF);
+  bool s = sdWait(pdrv, 500);
+  if (!s) {
+    log_e("Select Failed");
+    digitalWrite(card->ssPin, HIGH);
+    return false;
+  }
+  return true;
+}
+
+char sdCommand(uint8_t pdrv, char cmd, unsigned int arg, unsigned int *resp) {
+  char token;
+  ardu_sdcard_t *card = s_cards[pdrv];
+
+  for (int f = 0; f < 3; f++) {
+    if (cmd == SEND_NUM_WR_BLOCKS || cmd == SET_WR_BLK_ERASE_COUNT || cmd == APP_OP_COND || cmd == APP_CLR_CARD_DETECT) {
+      token = sdCommand(pdrv, APP_CMD, 0, NULL);
+      sdDeselectCard(pdrv);
+      if (token > 1) {
+        break;
+      }
+      if (!sdSelectCard(pdrv)) {
+        token = 0xFF;
+        break;
+      }
+    }
+
+    char cmdPacket[7];
+    cmdPacket[0] = cmd | 0x40;
+    cmdPacket[1] = arg >> 24;
+    cmdPacket[2] = arg >> 16;
+    cmdPacket[3] = arg >> 8;
+    cmdPacket[4] = arg;
+    if (card->supports_crc || cmd == GO_IDLE_STATE || cmd == SEND_IF_COND) {
+      cmdPacket[5] = (CRC7(cmdPacket, 5) << 1) | 0x01;
+    } else {
+      cmdPacket[5] = 0x01;
+    }
+    cmdPacket[6] = 0xFF;
+
+    card->spi->writeBytes((uint8_t *)cmdPacket, (cmd == STOP_TRANSMISSION) ? 7 : 6);
+
+    for (int i = 0; i < 9; i++) {
+      token = card->spi->transfer(0xFF);
+      if (!(token & 0x80)) {
+        break;
+      }
+    }
+
+    if (token == 0xFF) {
+      log_w("no token received");
+      sdDeselectCard(pdrv);
+      delay(100);
+      sdSelectCard(pdrv);
+      continue;
+    } else if (token & 0x08) {
+      log_w("crc error");
+      sdDeselectCard(pdrv);
+      delay(100);
+      sdSelectCard(pdrv);
+      continue;
+    } else if (token > 1) {
+      log_w("token error [%u] 0x%x", cmd, token);
+      break;
+    }
+
+    if (cmd == SEND_STATUS && resp) {
+      *resp = card->spi->transfer(0xFF);
+    } else if ((cmd == SEND_IF_COND || cmd == READ_OCR) && resp) {
+      *resp = card->spi->transfer32(0xFFFFFFFF);
+    }
+
+    break;
+  }
+  if (token == 0xFF) {
+    log_e("Card Failed! cmd: 0x%02x", cmd);
+    card->status = STA_NOINIT;
+  }
+  return token;
+}
+
+bool sdReadBytes(uint8_t pdrv, char *buffer, int length) {
+  char token;
+  unsigned short crc;
+  ardu_sdcard_t *card = s_cards[pdrv];
+
+  uint32_t start = millis();
+  do {
+    token = card->spi->transfer(0xFF);
+  } while (token == 0xFF && (millis() - start) < 500);
+
+  if (token != 0xFE) {
+    return false;
+  }
+
+  card->spi->transferBytes(NULL, (uint8_t *)buffer, length);
+  crc = card->spi->transfer16(0xFFFF);
+  return (!card->supports_crc || crc == CRC16(buffer, length));
+}
+
+char sdWriteBytes(uint8_t pdrv, const char *buffer, char token) {
+  ardu_sdcard_t *card = s_cards[pdrv];
+  unsigned short crc = (card->supports_crc) ? CRC16(buffer, 512) : 0xFFFF;
+  if (!sdWait(pdrv, 500)) {
+    return 0;
+  }
+
+  card->spi->write(token);
+  card->spi->writeBytes((uint8_t *)buffer, 512);
+  card->spi->write16(crc);
+  return (card->spi->transfer(0xFF) & 0x1F);
+}
+
+/*
+ * SPI SDCARD Communication
+ * */
+
+char sdTransaction(uint8_t pdrv, char cmd, unsigned int arg, unsigned int *resp) {
+  if (!sdSelectCard(pdrv)) {
+    return 0xFF;
+  }
+  char token = sdCommand(pdrv, cmd, arg, resp);
+  sdDeselectCard(pdrv);
+  return token;
+}
+
+bool sdReadSector(uint8_t pdrv, char *buffer, unsigned long long sector) {
+  for (int f = 0; f < 3; f++) {
+    if (!sdSelectCard(pdrv)) {
+      return false;
+    }
+    if (!sdCommand(pdrv, READ_BLOCK_SINGLE, (s_cards[pdrv]->type == CARD_SDHC) ? sector : sector << 9, NULL)) {
+      bool success = sdReadBytes(pdrv, buffer, 512);
+      sdDeselectCard(pdrv);
+      if (success) {
+        return true;
+      }
+    } else {
+      break;
+    }
+  }
+  sdDeselectCard(pdrv);
+  return false;
+}
+
+bool sdReadSectors(uint8_t pdrv, char *buffer, unsigned long long sector, int count) {
+  for (int f = 0; f < 3;) {
+    if (!sdSelectCard(pdrv)) {
+      return false;
+    }
+
+    if (!sdCommand(pdrv, READ_BLOCK_MULTIPLE, (s_cards[pdrv]->type == CARD_SDHC) ? sector : sector << 9, NULL)) {
+      do {
+        if (!sdReadBytes(pdrv, buffer, 512)) {
+          f++;
+          break;
+        }
+
+        sector++;
+        buffer += 512;
+        f = 0;
+      } while (--count);
+
+      if (sdCommand(pdrv, STOP_TRANSMISSION, 0, NULL)) {
+        log_e("command failed");
+        break;
+      }
+
+      sdDeselectCard(pdrv);
+      if (count == 0) {
+        return true;
+      }
+    } else {
+      break;
+    }
+  }
+  sdDeselectCard(pdrv);
+  return false;
+}
+
+bool sdWriteSector(uint8_t pdrv, const char *buffer, unsigned long long sector) {
+  using roro::SdFault;
+  for (int f = 0; f < 3; f++) {
+    if (!sdSelectCard(pdrv)) {
+      return sdFault(SdFault::Select);  // roro: say why
+    }
+    if (!sdCommand(pdrv, WRITE_BLOCK_SINGLE, (s_cards[pdrv]->type == CARD_SDHC) ? sector : sector << 9, NULL)) {
+      char token = sdWriteBytes(pdrv, buffer, 0xFE);
+      sdDeselectCard(pdrv);
+
+      if (token == 0x0A) {
+        continue;
+      } else if (token == 0x0C) {
+        return sdFault(SdFault::DataToken, token);
+      }
+
+      unsigned int resp;
+      char status = sdTransaction(pdrv, SEND_STATUS, 0, &resp);
+      if (status || resp) {
+        return token != 0x05 ? sdFault(SdFault::DataToken, token, resp) : sdFault(SdFault::Status, status, resp);
+      }
+      return true;
+    } else {
+      break;
+    }
+  }
+  sdDeselectCard(pdrv);
+  return sdFault(SdFault::Command);
+}
+
+bool sdWriteSectors(uint8_t pdrv, const char *buffer, unsigned long long sector, int count) {
+  using roro::SdFault;
+  char token;
+  const char *currentBuffer = buffer;
+  unsigned long long currentSector = sector;
+  int currentCount = count;
+  ardu_sdcard_t *card = s_cards[pdrv];
+  SdFault::Step why = SdFault::Command;  // roro: what stopped it, for the last return
+  uint8_t whyToken = 0;
+
+  for (int f = 0; f < 3;) {
+    if (card->type != CARD_MMC) {
+      char refused = sdTransaction(pdrv, SET_WR_BLK_ERASE_COUNT, currentCount, NULL);
+      if (refused) {
+        return sdFault(SdFault::EraseCount, refused);
+      }
+    }
+
+    if (!sdSelectCard(pdrv)) {
+      return sdFault(SdFault::Select);
+    }
+
+    if (!sdCommand(pdrv, WRITE_BLOCK_MULTIPLE, (card->type == CARD_SDHC) ? currentSector : currentSector << 9, NULL)) {
+      do {
+        token = sdWriteBytes(pdrv, currentBuffer, 0xFC);
+        if (token != 0x05) {
+          f++;
+          break;
+        }
+        currentBuffer += 512;
+        f = 0;
+      } while (--currentCount);
+
+      if (!sdWait(pdrv, 500)) {
+        why = SdFault::BusyAfter;
+        break;
+      }
+
+      if (currentCount == 0) {
+        sdStop(pdrv);
+        card->spi->transfer(0xFF);  // roro: the byte the card takes to go busy after Stop Tran (#21)
+        sdDeselectCard(pdrv);
+
+        unsigned int resp;
+        char status = sdTransaction(pdrv, SEND_STATUS, 0, &resp);
+        if (status || resp) {
+          return sdFault(SdFault::Status, status, resp);
+        }
+        return true;
+      } else {
+        if (sdCommand(pdrv, STOP_TRANSMISSION, 0, NULL)) {
+          why = SdFault::StopCommand;
+          whyToken = token;
+          break;
+        }
+
+        if (token == 0x0A) {
+          sdDeselectCard(pdrv);
+          unsigned int writtenBlocks = 0;
+          if (card->type != CARD_MMC && sdSelectCard(pdrv)) {
+            if (!sdCommand(pdrv, SEND_NUM_WR_BLOCKS, 0, NULL)) {
+              char acmdData[4];
+              if (sdReadBytes(pdrv, acmdData, 4)) {
+                writtenBlocks = acmdData[0] << 24;
+                writtenBlocks |= acmdData[1] << 16;
+                writtenBlocks |= acmdData[2] << 8;
+                writtenBlocks |= acmdData[3];
+              }
+            }
+            sdDeselectCard(pdrv);
+          }
+          currentBuffer = buffer + (writtenBlocks << 9);
+          currentSector = sector + writtenBlocks;
+          currentCount = count - writtenBlocks;
+          continue;
+        } else {
+          why = SdFault::DataToken;
+          whyToken = token;
+          break;
+        }
+      }
+    } else {
+      break;
+    }
+  }
+  sdDeselectCard(pdrv);
+  return sdFault(why, whyToken);
+}
+
+unsigned long sdGetSectorsCount(uint8_t pdrv) {
+  for (int f = 0; f < 3; f++) {
+    if (!sdSelectCard(pdrv)) {
+      return 0;
+    }
+
+    if (!sdCommand(pdrv, SEND_CSD, 0, NULL)) {
+      char csd[16];
+      bool success = sdReadBytes(pdrv, csd, 16);
+      sdDeselectCard(pdrv);
+      if (success) {
+        if ((csd[0] >> 6) == 0x01) {
+          unsigned long size = (((unsigned long)(csd[7] & 0x3F) << 16) | ((unsigned long)csd[8] << 8) | csd[9]) + 1;
+          return size << 10;
+        }
+        unsigned long size = (((unsigned long)(csd[6] & 0x03) << 10) | ((unsigned long)csd[7] << 2) | ((csd[8] & 0xC0) >> 6)) + 1;
+        size <<= ((((csd[9] & 0x03) << 1) | ((csd[10] & 0x80) >> 7)) + 2);
+        size <<= (csd[5] & 0x0F);
+        return size >> 9;
+      }
+    } else {
+      break;
+    }
+  }
+
+  sdDeselectCard(pdrv);
+  return 0;
+}
+
+namespace {
+
+struct AcquireSPI {
+  ardu_sdcard_t *card;
+  explicit AcquireSPI(ardu_sdcard_t *card) : card(card) {
+    card->spi->beginTransaction(SPISettings(card->frequency, MSBFIRST, SPI_MODE0));
+  }
+  AcquireSPI(ardu_sdcard_t *card, int frequency) : card(card) {
+    card->spi->beginTransaction(SPISettings(frequency, MSBFIRST, SPI_MODE0));
+  }
+  ~AcquireSPI() {
+    card->spi->endTransaction();
+  }
+
+private:
+  AcquireSPI(AcquireSPI const &);
+  AcquireSPI &operator=(AcquireSPI const &);
+};
+
+}  // namespace
+
+/*
+ * FATFS API
+ * */
+
+/**
+ * @brief Initialize an SD card for use with FatFs
+ *
+ * This function implements the complete SD card initialization sequence according to
+ * the SD card specification. It performs card detection, type identification,
+ * and configuration for SPI mode operation.
+ *
+ * The initialization sequence follows the SD card protocol (SPI mode, aligned with IDF):
+ * 1. Power-up sequence with 74+ clock cycles
+ * 2. Two GO_IDLE_STATE attempts to enter SPI mode
+ * 3. CRC_ON_OFF to enable CRC checking (with retry)
+ * 4. SEND_IF_COND to identify SDHC/SDXC cards
+ * 5. APP_OP_COND / SEND_OP_COND (SPI args; timeout >1s)
+ * 6. Card type detection (SD/SDHC/MMC)
+ * 7. Final configuration and sector count retrieval
+ *
+ * @param pdrv Physical drive number (0-9)
+ * @return DSTATUS Status of the initialization (0 = success, STA_NOINIT = failed)
+ */
+DSTATUS ff_sd_initialize(uint8_t pdrv) {
+  char token;
+  unsigned int resp;
+  unsigned int start;
+
+  // Get the card structure for the given drive number
+  ardu_sdcard_t *card = s_cards[pdrv];
+
+  // If the card is already initialized, return its current status
+  if (!(card->status & STA_NOINIT)) {
+    return card->status;
+  }
+
+  // Lock the SPI bus and set it to a low frequency (400kHz) for initialization
+  // Low frequency is required during initialization for reliable communication
+  AcquireSPI card_locked(card, 400000);
+
+  // Step 1: Power-up sequence - Send at least 74 clock cycles with CS high and MOSI high
+  // This is required by the SD card specification to ensure proper card state reset
+  // We send 20 bytes (160 clock cycles) to exceed the minimum requirement
+  digitalWrite(card->ssPin, HIGH);
+  for (uint8_t i = 0; i < 20; i++) {
+    card->spi->transfer(0XFF);
+  }
+
+  // Step 2: Perform two GO_IDLE_STATE (CMD0) attempts in SPI mode.
+  // Per SD Simplified Spec (figure 4-1) / IDF: some cards enter SD mode on the
+  // first attempt, so the first response may fail; the second must succeed.
+  // (sdCommand may also retry internally on no-token/CRC errors.)
+  // Fix mount issue - sdWait fail ignored before each CMD0 attempt
+  digitalWrite(card->ssPin, LOW);
+  if (!sdWait(pdrv, 500)) {
+    log_w("sdWait fail ignored, card initialize continues");
+  }
+  (void)sdCommand(pdrv, GO_IDLE_STATE, 0, NULL);
+  sdDeselectCard(pdrv);
+  delay(sd_go_idle_delay_ms);
+
+  digitalWrite(card->ssPin, LOW);
+  if (!sdWait(pdrv, 500)) {
+    log_w("sdWait fail ignored, card initialize continues");
+  }
+  if (sdCommand(pdrv, GO_IDLE_STATE, 0, NULL) != 1) {
+    sdDeselectCard(pdrv);
+    log_w("GO_IDLE_STATE failed");
+    goto unknown_card;
+  }
+  sdDeselectCard(pdrv);
+  delay(sd_go_idle_delay_ms);
+
+  // Step 3: Configure CRC checking
+  // Enable CRC for data transfers in SPI mode (required for reliable communication).
+  // Some cards reject the first CRC_ON_OFF; retry once (same as IDF).
+  token = sdTransaction(pdrv, CRC_ON_OFF, 1, NULL);
+  if (token != 1 && token != 0x5) {
+    delay(10);
+    token = sdTransaction(pdrv, CRC_ON_OFF, 1, NULL);
+  }
+  if (token == 0x5) {
+    // Old card that doesn't support CRC - disable CRC checking
+    card->supports_crc = false;
+  } else if (token != 1) {
+    log_w("CRC_ON_OFF failed: %u", token);
+    goto unknown_card;
+  }
+
+  // Step 4: Card type detection and initialization
+  // Try to identify SDHC/SDXC cards using SEND_IF_COND command
+  if (sdTransaction(pdrv, SEND_IF_COND, 0x1AA, &resp) == 1) {
+    // Card responded to SEND_IF_COND - likely SDHC/SDXC
+    if ((resp & 0xFFF) != 0x1AA) {
+      log_w("SEND_IF_COND failed: %03" PRIX32, (uint32_t)(resp & 0xFFF));
+      goto unknown_card;
+    }
+
+    // Read Operating Conditions Register to check card capabilities
+    if (sdTransaction(pdrv, READ_OCR, 0, &resp) != 1 || !(resp & (1 << 20))) {
+      log_w("READ_OCR failed: %X", resp);
+      goto unknown_card;
+    }
+
+    // Send APP_OP_COND to set operating conditions for SDHC/SDXC.
+    // In SPI mode only HCS (bit 30) is valid; voltage bits must be 0 (same as IDF).
+    // Timeout must be >1s per SD spec (IDF uses ~3s).
+    start = millis();
+    do {
+      token = sdTransaction(pdrv, APP_OP_COND, 0x40000000, NULL);
+    } while (token == 1 && (millis() - start) < sd_op_cond_timeout_ms);
+
+    if (token) {
+      log_w("APP_OP_COND failed: %u", token);
+      goto unknown_card;
+    }
+
+    // Determine if it's SDHC (high capacity) or regular SD
+    if (!sdTransaction(pdrv, READ_OCR, 0, &resp)) {
+      if (resp & (1 << 30)) {
+        card->type = CARD_SDHC;  // High capacity card (SDHC/SDXC)
+      } else {
+        card->type = CARD_SD;  // Standard capacity card
+      }
+    } else {
+      log_w("READ_OCR failed: %X", resp);
+      goto unknown_card;
+    }
+  } else {
+    // Card didn't respond to SEND_IF_COND - try SD or MMC initialization
+    if (sdTransaction(pdrv, READ_OCR, 0, &resp) != 1 || !(resp & (1 << 20))) {
+      log_w("READ_OCR failed: %X", resp);
+      goto unknown_card;
+    }
+
+    // Try SD card initialization first (SPI mode: ACMD41 arg must be 0)
+    start = millis();
+    do {
+      token = sdTransaction(pdrv, APP_OP_COND, 0, NULL);
+    } while (token == 0x01 && (millis() - start) < sd_op_cond_timeout_ms);
+
+    if (!token) {
+      card->type = CARD_SD;  // Standard SD card
+    } else {
+      // Try MMC card initialization (SPI mode: CMD1 arg must be 0)
+      start = millis();
+      do {
+        token = sdTransaction(pdrv, SEND_OP_COND, 0, NULL);
+      } while (token != 0x00 && (millis() - start) < sd_op_cond_timeout_ms);
+
+      if (token == 0x00) {
+        card->type = CARD_MMC;  // MMC card
+      } else {
+        log_w("SEND_OP_COND failed: %u", token);
+        goto unknown_card;
+      }
+    }
+  }
+
+  // Step 5: Clear card detection for SD cards (not needed for MMC)
+  if (card->type != CARD_MMC) {
+    if (sdTransaction(pdrv, APP_CLR_CARD_DETECT, 0, NULL)) {
+      log_w("APP_CLR_CARD_DETECT failed");
+      goto unknown_card;
+    }
+  }
+
+  // Step 6: Set block length for non-SDHC cards
+  // SDHC cards have fixed 512-byte blocks, others need explicit block length setting
+  if (card->type != CARD_SDHC) {
+    if (sdTransaction(pdrv, SET_BLOCKLEN, 512, NULL) != 0x00) {
+      log_w("SET_BLOCKLEN failed");
+      goto unknown_card;
+    }
+  }
+
+  // Step 7: Get card capacity and finalize initialization
+  card->sectors = sdGetSectorsCount(pdrv);
+
+  // Limit frequency to 25MHz for compatibility (SD spec maximum for non-UHS cards)
+  if (card->frequency > 25000000) {
+    card->frequency = 25000000;
+  }
+
+  // Mark card as initialized
+  card->status &= ~STA_NOINIT;
+  return card->status;
+
+unknown_card:
+  // Mark card as unknown type if initialization failed
+  card->type = CARD_UNKNOWN;
+  return card->status;
+}
+
+DSTATUS ff_sd_status(uint8_t pdrv) {
+  ardu_sdcard_t *card = s_cards[pdrv];
+  AcquireSPI lock(card);
+
+  if (sdTransaction(pdrv, SEND_STATUS, 0, NULL)) {
+    log_e("Check status failed");
+    return STA_NOINIT;
+  }
+  return s_cards[pdrv]->status;
+}
+
+DRESULT ff_sd_read(uint8_t pdrv, uint8_t *buffer, DWORD sector, UINT count) {
+  ardu_sdcard_t *card = s_cards[pdrv];
+  if (card->status & STA_NOINIT) {
+    return RES_NOTRDY;
+  }
+  DRESULT res = RES_OK;
+
+  AcquireSPI lock(card);
+
+  if (count > 1) {
+    res = sdReadSectors(pdrv, (char *)buffer, sector, count) ? RES_OK : RES_ERROR;
+  } else {
+    res = sdReadSector(pdrv, (char *)buffer, sector) ? RES_OK : RES_ERROR;
+  }
+  return res;
+}
+
+DRESULT ff_sd_write(uint8_t pdrv, const uint8_t *buffer, DWORD sector, UINT count) {
+  ardu_sdcard_t *card = s_cards[pdrv];
+  if (card->status & STA_NOINIT) {
+    return RES_NOTRDY;
+  }
+
+  if (card->status & STA_PROTECT) {
+    return RES_WRPRT;
+  }
+  DRESULT res = RES_OK;
+
+  AcquireSPI lock(card);
+
+  if (count > 1) {
+    res = sdWriteSectors(pdrv, (const char *)buffer, sector, count) ? RES_OK : RES_ERROR;
+  } else {
+    res = sdWriteSector(pdrv, (const char *)buffer, sector) ? RES_OK : RES_ERROR;
+  }
+  return res;
+}
+
+DRESULT ff_sd_ioctl(uint8_t pdrv, uint8_t cmd, void *buff) {
+  switch (cmd) {
+    case CTRL_SYNC:
+    {
+      AcquireSPI lock(s_cards[pdrv]);
+      if (sdSelectCard(pdrv)) {
+        sdDeselectCard(pdrv);
+        return RES_OK;
+      }
+    }
+      return RES_ERROR;
+    case GET_SECTOR_COUNT: *((unsigned long *)buff) = s_cards[pdrv]->sectors; return RES_OK;
+    case GET_SECTOR_SIZE:  *((WORD *)buff) = 512; return RES_OK;
+    case GET_BLOCK_SIZE:   *((uint32_t *)buff) = 1; return RES_OK;
+  }
+  return RES_PARERR;
+}
+
+bool sd_read_raw(uint8_t pdrv, uint8_t *buffer, DWORD sector) {
+  return ff_sd_read(pdrv, buffer, sector, 1) == ESP_OK;
+}
+
+bool sd_write_raw(uint8_t pdrv, uint8_t *buffer, DWORD sector) {
+  return ff_sd_write(pdrv, buffer, sector, 1) == ESP_OK;
+}
+
+/*
+ * Public methods
+ * */
+
+uint8_t sdcard_uninit(uint8_t pdrv) {
+  ardu_sdcard_t *card = s_cards[pdrv];
+  if (pdrv >= FF_VOLUMES || card == NULL) {
+    return 1;
+  }
+  {
+    AcquireSPI lock(card);
+    sdTransaction(pdrv, GO_IDLE_STATE, 0, NULL);
+  }  // lock is destructed here
+  ff_diskio_register(pdrv, NULL);
+  s_cards[pdrv] = NULL;
+  esp_err_t err = ESP_OK;
+  if (card->base_path) {
+    err = esp_vfs_fat_unregister_path(card->base_path);
+    free(card->base_path);
+  }
+  free(card);
+  return err;
+}
+
+uint8_t sdcard_init(uint8_t cs, SPIClass *spi, int hz) {
+
+  uint8_t pdrv = 0xFF;
+  if (ff_diskio_get_drive(&pdrv) != ESP_OK || pdrv == 0xFF) {
+    return pdrv;
+  }
+
+  ardu_sdcard_t *card = (ardu_sdcard_t *)malloc(sizeof(ardu_sdcard_t));
+  if (!card) {
+    return 0xFF;
+  }
+
+  card->base_path = NULL;
+  card->frequency = hz;
+  card->spi = spi;
+  card->ssPin = digitalPinToGPIONumber(cs);
+
+  card->supports_crc = true;
+  card->type = CARD_NONE;
+  card->status = STA_NOINIT;
+
+  pinMode(card->ssPin, OUTPUT);
+  digitalWrite(card->ssPin, HIGH);
+  perimanSetPinBusExtraType(card->ssPin, "SD_SS");
+
+  s_cards[pdrv] = card;
+
+  static const ff_diskio_impl_t sd_impl = {
+    .init = &ff_sd_initialize, .status = &ff_sd_status, .read = &ff_sd_read, .write = &ff_sd_write, .ioctl = &ff_sd_ioctl
+  };
+  ff_diskio_register(pdrv, &sd_impl);
+
+  return pdrv;
+}
+
+uint8_t sdcard_unmount(uint8_t pdrv) {
+  ardu_sdcard_t *card = s_cards[pdrv];
+  if (pdrv >= FF_VOLUMES || card == NULL) {
+    return 1;
+  }
+  card->status |= STA_NOINIT;
+  card->type = CARD_NONE;
+
+  char drv[3] = {(char)('0' + pdrv), ':', 0};
+  f_mount(NULL, drv, 0);
+  return 0;
+}
+
+bool sdcard_mount(uint8_t pdrv, const char *path, uint8_t max_files, bool format_if_empty) {
+  ardu_sdcard_t *card = s_cards[pdrv];
+  if (pdrv >= FF_VOLUMES || card == NULL) {
+    return false;
+  }
+
+  if (card->base_path) {
+    free(card->base_path);
+  }
+  card->base_path = strdup(path);
+
+  FATFS *fs;
+  char drv[3] = {(char)('0' + pdrv), ':', 0};
+
+#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(6, 0, 0)
+  esp_err_t err = esp_vfs_fat_register(path, drv, max_files, &fs);
+#else
+  esp_vfs_fat_conf_t conf = {.base_path = path, .fat_drive = drv, .max_files = max_files};
+  esp_err_t err = esp_vfs_fat_register(&conf, &fs);
+#endif
+
+  if (err == ESP_ERR_INVALID_STATE) {
+    log_e("esp_vfs_fat_register failed 0x(%x): SD is registered.", err);
+    return false;
+  } else if (err != ESP_OK) {
+    log_e("esp_vfs_fat_register failed 0x(%x)", err);
+    return false;
+  }
+
+  FRESULT res = f_mount(fs, drv, 1);
+  if (res != FR_OK) {
+    log_e("f_mount failed: %s", fferr2str[res]);
+    if (res == 13 && format_if_empty) {
+      BYTE *work = (BYTE *)malloc(sizeof(BYTE) * FF_MAX_SS);
+      if (!work) {
+        log_e("alloc for f_mkfs failed");
+        return false;
+      }
+      //FRESULT f_mkfs (const TCHAR* path, const MKFS_PARM* opt, void* work, UINT len);
+      const MKFS_PARM opt = {(BYTE)FM_ANY, 0, 0, 0, 0};
+      res = f_mkfs(drv, &opt, work, sizeof(BYTE) * FF_MAX_SS);
+      free(work);
+      if (res != FR_OK) {
+        log_e("f_mkfs failed: %s", fferr2str[res]);
+        esp_vfs_fat_unregister_path(path);
+        return false;
+      }
+      res = f_mount(fs, drv, 1);
+      if (res != FR_OK) {
+        log_e("f_mount failed: %s", fferr2str[res]);
+        esp_vfs_fat_unregister_path(path);
+        return false;
+      }
+    } else {
+      esp_vfs_fat_unregister_path(path);
+      return false;
+    }
+  }
+  AcquireSPI lock(card);
+  card->sectors = sdGetSectorsCount(pdrv);
+  return true;
+}
+
+uint32_t sdcard_num_sectors(uint8_t pdrv) {
+  ardu_sdcard_t *card = s_cards[pdrv];
+  if (pdrv >= FF_VOLUMES || card == NULL) {
+    return 0;
+  }
+  return card->sectors;
+}
+
+uint32_t sdcard_sector_size(uint8_t pdrv) {
+  if (pdrv >= FF_VOLUMES || s_cards[pdrv] == NULL) {
+    return 0;
+  }
+  return 512;
+}
+
+// roro: the card's CID. CMD10 in SPI mode (the enum's SEND_CID, 2, is the SD-mode command).
+namespace roro {
+bool sdReadCid(uint8_t cid[16]) {
+  for (uint8_t pdrv = 0; pdrv < FF_VOLUMES; ++pdrv) {
+    ardu_sdcard_t *card = s_cards[pdrv];
+    if (!card) {
+      continue;
+    }
+    AcquireSPI lock(card);
+    if (!sdSelectCard(pdrv)) {
+      return false;
+    }
+    bool ok = !sdCommand(pdrv, 10, 0, NULL) && sdReadBytes(pdrv, (char *)cid, 16);
+    sdDeselectCard(pdrv);
+    return ok;
+  }
+  return false;
+}
+}  // namespace roro
+
+sdcard_type_t sdcard_type(uint8_t pdrv) {
+  ardu_sdcard_t *card = s_cards[pdrv];
+  if (pdrv >= FF_VOLUMES || card == NULL) {
+    return CARD_NONE;
+  }
+  return card->type;
+}

lib/SD/src/sd_diskio.h

@@ -0,0 +1,34 @@
+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#ifndef _SD_DISKIO_H_
+#define _SD_DISKIO_H_
+
+#include "Arduino.h"
+#include "SPI.h"
+#include "sd_defines.h"
+// #include "diskio.h"
+
+uint8_t sdcard_init(uint8_t cs, SPIClass *spi, int hz);
+uint8_t sdcard_uninit(uint8_t pdrv);
+
+bool sdcard_mount(uint8_t pdrv, const char *path, uint8_t max_files, bool format_if_empty);
+uint8_t sdcard_unmount(uint8_t pdrv);
+
+sdcard_type_t sdcard_type(uint8_t pdrv);
+uint32_t sdcard_num_sectors(uint8_t pdrv);
+uint32_t sdcard_sector_size(uint8_t pdrv);
+bool sd_read_raw(uint8_t pdrv, uint8_t *buffer, uint32_t sector);
+bool sd_write_raw(uint8_t pdrv, uint8_t *buffer, uint32_t sector);
+
+#endif /* _SD_DISKIO_H_ */

lib/SD/src/sd_diskio_crc.c

@@ -0,0 +1,61 @@
+/* SD/MMC File System Library
+ * Copyright (c) 2014 Neil Thiessen
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const char m_CRC7Table[] = {0x00, 0x09, 0x12, 0x1B, 0x24, 0x2D, 0x36, 0x3F, 0x48, 0x41, 0x5A, 0x53, 0x6C, 0x65, 0x7E, 0x77, 0x19, 0x10, 0x0B, 0x02, 0x3D, 0x34,
+                            0x2F, 0x26, 0x51, 0x58, 0x43, 0x4A, 0x75, 0x7C, 0x67, 0x6E, 0x32, 0x3B, 0x20, 0x29, 0x16, 0x1F, 0x04, 0x0D, 0x7A, 0x73, 0x68, 0x61,
+                            0x5E, 0x57, 0x4C, 0x45, 0x2B, 0x22, 0x39, 0x30, 0x0F, 0x06, 0x1D, 0x14, 0x63, 0x6A, 0x71, 0x78, 0x47, 0x4E, 0x55, 0x5C, 0x64, 0x6D,
+                            0x76, 0x7F, 0x40, 0x49, 0x52, 0x5B, 0x2C, 0x25, 0x3E, 0x37, 0x08, 0x01, 0x1A, 0x13, 0x7D, 0x74, 0x6F, 0x66, 0x59, 0x50, 0x4B, 0x42,
+                            0x35, 0x3C, 0x27, 0x2E, 0x11, 0x18, 0x03, 0x0A, 0x56, 0x5F, 0x44, 0x4D, 0x72, 0x7B, 0x60, 0x69, 0x1E, 0x17, 0x0C, 0x05, 0x3A, 0x33,
+                            0x28, 0x21, 0x4F, 0x46, 0x5D, 0x54, 0x6B, 0x62, 0x79, 0x70, 0x07, 0x0E, 0x15, 0x1C, 0x23, 0x2A, 0x31, 0x38, 0x41, 0x48, 0x53, 0x5A,
+                            0x65, 0x6C, 0x77, 0x7E, 0x09, 0x00, 0x1B, 0x12, 0x2D, 0x24, 0x3F, 0x36, 0x58, 0x51, 0x4A, 0x43, 0x7C, 0x75, 0x6E, 0x67, 0x10, 0x19,
+                            0x02, 0x0B, 0x34, 0x3D, 0x26, 0x2F, 0x73, 0x7A, 0x61, 0x68, 0x57, 0x5E, 0x45, 0x4C, 0x3B, 0x32, 0x29, 0x20, 0x1F, 0x16, 0x0D, 0x04,
+                            0x6A, 0x63, 0x78, 0x71, 0x4E, 0x47, 0x5C, 0x55, 0x22, 0x2B, 0x30, 0x39, 0x06, 0x0F, 0x14, 0x1D, 0x25, 0x2C, 0x37, 0x3E, 0x01, 0x08,
+                            0x13, 0x1A, 0x6D, 0x64, 0x7F, 0x76, 0x49, 0x40, 0x5B, 0x52, 0x3C, 0x35, 0x2E, 0x27, 0x18, 0x11, 0x0A, 0x03, 0x74, 0x7D, 0x66, 0x6F,
+                            0x50, 0x59, 0x42, 0x4B, 0x17, 0x1E, 0x05, 0x0C, 0x33, 0x3A, 0x21, 0x28, 0x5F, 0x56, 0x4D, 0x44, 0x7B, 0x72, 0x69, 0x60, 0x0E, 0x07,
+                            0x1C, 0x15, 0x2A, 0x23, 0x38, 0x31, 0x46, 0x4F, 0x54, 0x5D, 0x62, 0x6B, 0x70, 0x79};
+
+char CRC7(const char *data, int length) {
+  char crc = 0;
+  for (int i = 0; i < length; i++) {
+    crc = m_CRC7Table[(crc << 1) ^ data[i]];
+  }
+  return crc;
+}
+
+const unsigned short m_CRC16Table[256] = {
+  0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7, 0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF, 0x1231, 0x0210, 0x3273,
+  0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6, 0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE, 0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7,
+  0x44A4, 0x5485, 0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D, 0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4, 0xB75B,
+  0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC, 0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823, 0xC9CC, 0xD9ED, 0xE98E, 0xF9AF,
+  0x8948, 0x9969, 0xA90A, 0xB92B, 0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12, 0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B,
+  0xAB1A, 0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41, 0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49, 0x7E97, 0x6EB6,
+  0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70, 0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78, 0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C,
+  0xC12D, 0xF14E, 0xE16F, 0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067, 0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
+  0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256, 0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D, 0x34E2, 0x24C3, 0x14A0,
+  0x0481, 0x7466, 0x6447, 0x5424, 0x4405, 0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C, 0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676,
+  0x4615, 0x5634, 0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB, 0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3, 0xCB7D,
+  0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A, 0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92, 0xFD2E, 0xED0F, 0xDD6C, 0xCD4D,
+  0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9, 0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1, 0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9,
+  0x9FF8, 0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
+};
+
+unsigned short CRC16(const char *data, int length) {
+  unsigned short crc = 0;
+  for (int i = 0; i < length; i++) {
+    crc = (crc << 8) ^ m_CRC16Table[((crc >> 8) ^ data[i]) & 0x00FF];
+  }
+  return crc;
+}

lib/SD/src/sd_fault.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <cstdint>
+
+namespace roro {
+
+// Why the SD driver last gave up on a write (see sd_diskio.cpp, issue #21). The framework's driver
+// fails without saying why; ours records it.
+struct SdFault {
+    enum Step : uint8_t {
+        None,
+        EraseCount,   // ACMD23 before a multi-block write was refused
+        Select,       // the card stayed busy for 500 ms
+        Command,      // the write command itself was refused
+        DataToken,    // the card's answer to a data block: 0x0B CRC error, 0x0D write error
+        BusyAfter,    // still busy 500 ms after the last block
+        Status,       // CMD13 after the write reported an error (resp)
+        StopCommand,  // CMD12 after a rejected block was refused
+    };
+    Step step = None;
+    uint8_t token = 0;   // the driver's or the card's answer at that step
+    uint32_t resp = 0;   // CMD13's status bits, for Status
+    uint32_t count = 0;  // failed writes since boot
+    uint32_t retried = 0;  // blocks resent after a CRC error, since boot
+};
+
+SdFault sdLastFault();
+
+// The mounted card's identity register (CID, CMD10): who made it, its name, serial and date.
+// Call it where card access is allowed (the storage task).
+bool sdReadCid(uint8_t cid[16]);
+
+}  // namespace roro

lib/apps_model/src/settings_menu.cpp

@@ -20,7 +20,8 @@ const RowDef kRows[] = {
     {Row::Region, Kind::Choice, "Region"},      {Row::Timezone, Kind::Choice, "Timezone"},
     {Row::Brightness, Kind::Slider, "Brightness"}, {Row::DimTimeout, Kind::Choice, "Dim after"},
     {Row::OffTimeout, Kind::Choice, "Screen off after"}, {Row::Sound, Kind::Toggle, "Sound & LED"},
-    {Row::Gnss, Kind::Toggle, "GNSS"}, {Row::Coordinates, Kind::Toggle, "Coordinates"},
+    {Row::Gnss, Kind::Toggle, "GNSS"}, {Row::GnssQuiet, Kind::Toggle, "Pause GNSS for LoRa"},
+    {Row::Coordinates, Kind::Toggle, "Coordinates"},
     {Row::ProbeMacs, Kind::Toggle, "Probe MACs"}, {Row::Wifi, Kind::Page, "Wi-Fi"},
     {Row::Storage, Kind::Page, "Storage"},
     {Row::Firmware, Kind::Page, "Firmware"},
@@ -81,6 +82,7 @@ std::string SettingsMenu::value(int i) const {
         case Row::OffTimeout: return formatSeconds(settings_.getInt(Setting::OffTimeoutS));
         case Row::Sound: return settings_.getBool(Setting::Sound) ? "On" : "Off";
         case Row::Gnss: return settings_.getBool(Setting::GnssEnabled) ? "On" : "Off";
+        case Row::GnssQuiet: return settings_.getBool(Setting::GnssQuietForLora) ? "On" : "Off";
         case Row::Coordinates: return settings_.getBool(Setting::CoordinatesDms) ? "Deg min sec" : "Decimal";
         case Row::ProbeMacs: return settings_.getBool(Setting::ProbeMacRaw) ? "Raw" : "Pseudonymised";
         case Row::Wifi: return settings_.getBool(Setting::WifiEnabled) ? "On" : "Off";
@@ -126,6 +128,7 @@ std::string SettingsMenu::choose(int i, int c) {
 void SettingsMenu::toggle(int i) {
     if (row(i) == Row::Sound) settings_.setBool(Setting::Sound, !settings_.getBool(Setting::Sound));
     if (row(i) == Row::Gnss) settings_.setBool(Setting::GnssEnabled, !settings_.getBool(Setting::GnssEnabled));
+    if (row(i) == Row::GnssQuiet) settings_.setBool(Setting::GnssQuietForLora, !settings_.getBool(Setting::GnssQuietForLora));
     if (row(i) == Row::Coordinates) settings_.setBool(Setting::CoordinatesDms, !settings_.getBool(Setting::CoordinatesDms));
     if (row(i) == Row::ProbeMacs) settings_.setBool(Setting::ProbeMacRaw, !settings_.getBool(Setting::ProbeMacRaw));
 }

lib/apps_model/src/settings_menu.h

@@ -11,7 +11,7 @@ namespace roro {
 // values, choice lists and validation messages. Rendering and navigation live in the App.
 class SettingsMenu {
    public:
-    enum class Row { LongName, ShortName, Region, Timezone, Brightness, DimTimeout, OffTimeout, Sound, Gnss, Coordinates, ProbeMacs, Wifi, Storage, Firmware, About };
+    enum class Row { LongName, ShortName, Region, Timezone, Brightness, DimTimeout, OffTimeout, Sound, Gnss, GnssQuiet, Coordinates, ProbeMacs, Wifi, Storage, Firmware, About };
     enum class Kind { Text, Choice, Toggle, Slider, Page };
 
     explicit SettingsMenu(Settings& settings) : settings_(settings) {}

lib/net/src/ipv4.cpp

@@ -0,0 +1,97 @@
+#include "ipv4.h"
+
+#include <cstdio>
+
+namespace roro::net {
+
+bool parseIpv4(const std::string& text, uint32_t& out) {
+    uint32_t value = 0;
+    int parts = 0, digits = 0, part = 0;
+    for (char c : text) {
+        if (c >= '0' && c <= '9') {
+            if (++digits > 3) return false;
+            part = part * 10 + (c - '0');
+            if (part > 255) return false;
+        } else if (c == '.') {
+            if (digits == 0 || ++parts > 3) return false;
+            value = value << 8 | part;
+            part = digits = 0;
+        } else {
+            return false;
+        }
+    }
+    if (digits == 0 || parts != 3) return false;
+    out = value << 8 | part;
+    return true;
+}
+
+std::string formatIpv4(uint32_t a) {
+    char s[16];
+    std::snprintf(s, sizeof s, "%u.%u.%u.%u", static_cast<unsigned>(a >> 24), static_cast<unsigned>(a >> 16 & 255),
+                  static_cast<unsigned>(a >> 8 & 255), static_cast<unsigned>(a & 255));
+    return s;
+}
+
+uint32_t maskOf(int prefix) { return prefix <= 0 ? 0 : prefix >= 32 ? 0xFFFFFFFFu : ~0u << (32 - prefix); }
+
+std::string checkFixed(const FixedIp& f) {
+    if (f.prefix < 1 || f.prefix > 30) return "The prefix must be 1 to 30";
+    if (f.address == 0) return "0.0.0.0 isn't an address a device can have";
+    uint32_t mask = maskOf(f.prefix), network = f.address & mask, broadcast = network | ~mask;
+    if (f.address == network) return formatIpv4(f.address) + " is the network's own address";
+    if (f.address == broadcast) return formatIpv4(f.address) + " is the broadcast address";
+    if (f.gateway == 0) return "";
+    if (f.gateway == f.address) return "The gateway can't be this device's address";
+    if ((f.gateway & mask) != network)
+        return "The gateway " + formatIpv4(f.gateway) + " isn't in " + formatIpv4(network) + "/" + std::to_string(f.prefix);
+    if (f.gateway == broadcast) return "The gateway " + formatIpv4(f.gateway) + " is the broadcast address";
+    if (f.gateway == network) return "The gateway " + formatIpv4(f.gateway) + " is the network's own address";
+    return "";
+}
+
+std::string parseFixed(const std::string& text, FixedIp& out) {
+    size_t slash = text.find('/');
+    if (slash == std::string::npos) return "Write it as address/prefix, then the gateway if there is one";
+    size_t space = text.find(' ', slash);
+    std::string address = text.substr(0, slash);
+    std::string prefix = text.substr(slash + 1, space == std::string::npos ? std::string::npos : space - slash - 1);
+    std::string gateway = space == std::string::npos ? "" : text.substr(space + 1);
+    FixedIp f;
+    if (!parseIpv4(address, f.address)) return address + " isn't an IPv4 address";
+    int p = 0;
+    if (prefix.empty() || prefix.size() > 2) return "The prefix must be 1 to 30";
+    for (char c : prefix) {
+        if (c < '0' || c > '9') return "The prefix must be 1 to 30";
+        p = p * 10 + (c - '0');
+    }
+    f.prefix = static_cast<uint8_t>(p);
+    if (!gateway.empty() && !parseIpv4(gateway, f.gateway)) return gateway + " isn't an IPv4 address";
+    std::string why = checkFixed(f);
+    if (why.empty()) out = f;
+    return why;
+}
+
+std::string formatFixed(const FixedIp& f) {
+    std::string s = formatIpv4(f.address) + "/" + std::to_string(f.prefix);
+    if (f.gateway) s += " " + formatIpv4(f.gateway);
+    return s;
+}
+
+bool validHost(const std::string& text) {
+    if (text.empty() || text.size() > 63) return false;
+    uint32_t ignored;
+    if (parseIpv4(text, ignored)) return true;
+    bool allNumeric = true;  // digits and dots only, but not an address: "1.2.3", "999.1.1.1"
+    char previous = '.';
+    for (char c : text) {
+        bool letter = (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'), digit = c >= '0' && c <= '9';
+        if (!letter && !digit && c != '-' && c != '.') return false;
+        if (c == '.' && (previous == '.' || previous == '-')) return false;  // empty label, or one ending in '-'
+        if (c == '-' && previous == '.') return false;                       // a label starting with '-'
+        if (letter || c == '-') allNumeric = false;
+        previous = c;
+    }
+    return previous != '.' && previous != '-' && !allNumeric;
+}
+
+}  // namespace roro::net

lib/net/src/ipv4.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <cstdint>
+#include <string>
+
+namespace roro::net {
+
+// IPv4 addresses as 32-bit numbers, most significant byte first: 10.39.39.12 is 0x0A27270C.
+bool parseIpv4(const std::string& text, uint32_t& out);  // strict: four decimal numbers, 0 to 255
+std::string formatIpv4(uint32_t address);
+uint32_t maskOf(int prefix);  // 24 -> 255.255.255.0
+
+// A Saved Network's Fixed setting (S1, Q105 to Q107). gateway 0: none.
+struct FixedIp {
+    uint32_t address = 0;
+    uint8_t prefix = 24;
+    uint32_t gateway = 0;
+};
+
+// "" when a device can use it, otherwise why not, for a human (Q111).
+std::string checkFixed(const FixedIp& f);
+
+// "address/prefix [gateway]", as typed on the console and kept in flash. parseFixed() also checks.
+std::string parseFixed(const std::string& text, FixedIp& out);
+std::string formatFixed(const FixedIp& f);
+
+// An IPv4 address or a host name, as an NTP server may be (Q110).
+bool validHost(const std::string& text);
+
+}  // namespace roro::net

lib/net/src/traffic.cpp

@@ -0,0 +1,46 @@
+#include "traffic.h"
+
+#include <atomic>
+#include <cstdio>
+
+namespace roro::net {
+
+namespace {
+constexpr size_t kUsers = static_cast<size_t>(User::Count);
+std::atomic<uint32_t> in_[kUsers], out_[kUsers];
+}  // namespace
+
+const char* userName(User user) {
+    switch (user) {
+        case User::Irc: return "IRC";
+        case User::Gemini: return "Gemini";
+        case User::DebugConsole: return "Debug Console";
+        case User::Updates: return "Updates";
+        default: return "?";
+    }
+}
+
+void received(User user, size_t bytes) { in_[static_cast<size_t>(user)] += static_cast<uint32_t>(bytes); }
+void sent(User user, size_t bytes) { out_[static_cast<size_t>(user)] += static_cast<uint32_t>(bytes); }
+Traffic traffic(User user) { return {in_[static_cast<size_t>(user)], out_[static_cast<size_t>(user)]}; }
+
+void resetTraffic() {
+    for (size_t i = 0; i < kUsers; i++) in_[i] = out_[i] = 0;
+}
+
+uint32_t bytesPerSecond(uint32_t before, uint32_t now, uint32_t elapsedMs) {
+    if (!elapsedMs) return 0;
+    return static_cast<uint32_t>(static_cast<uint64_t>(now - before) * 1000 / elapsedMs);  // wraps with the counter
+}
+
+std::string formatTraffic(uint32_t bytes) {
+    char s[16];
+    if (bytes < 1000) std::snprintf(s, sizeof s, "%u B", static_cast<unsigned>(bytes));
+    else if (bytes < 10 * 1024) std::snprintf(s, sizeof s, "%.1f KB", bytes / 1024.0);
+    else if (bytes < 1000 * 1024) std::snprintf(s, sizeof s, "%u KB", static_cast<unsigned>(bytes / 1024));
+    else if (bytes < 10u * 1024 * 1024) std::snprintf(s, sizeof s, "%.1f MB", bytes / 1048576.0);
+    else std::snprintf(s, sizeof s, "%u MB", static_cast<unsigned>(bytes / 1048576));
+    return s;
+}
+
+}  // namespace roro::net

lib/net/src/traffic.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+
+namespace roro::net {
+
+// Bytes each network service has read and written since boot (S1, Q121), as the service sees
+// them: for TLS connections that's the plain text, without the handshake or record overhead.
+// Counted from the services' own tasks, read from the main loop.
+enum class User : uint8_t { Irc, Gemini, DebugConsole, Updates, Count };
+const char* userName(User user);
+
+struct Traffic {
+    uint32_t in = 0, out = 0;
+};
+void received(User user, size_t bytes);
+void sent(User user, size_t bytes);
+Traffic traffic(User user);
+void resetTraffic();  // for tests
+
+uint32_t bytesPerSecond(uint32_t before, uint32_t now, uint32_t elapsedMs);
+std::string formatTraffic(uint32_t bytes);  // "999 B", "1.5 KB", "12 KB", "1.7 MB"
+
+}  // namespace roro::net

lib/services/src/settings.cpp

@@ -1,5 +1,7 @@
 #include "settings.h"
 
+#include "ipv4.h"
+
 namespace roro {
 
 namespace {
@@ -32,6 +34,12 @@ const Definition kDefinitions[] = {
     {"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
+    {"dns1", Kind::String, 0, "9.9.9.9", 7, 15},  // Quad9
+    {"dns2", Kind::String, 0, "1.1.1.1", 0, 15},  // Cloudflare
+    {"dns_always", Kind::Bool, 0, nullptr, 0, 1},
+    {"ntp1", Kind::String, 0, "pool.ntp.org", 1, 63},
+    {"ntp2", Kind::String, 0, "time.cloudflare.com", 0, 63},
+    {"gnss_quiet", Kind::Bool, 0, nullptr, 0, 1},  // off: GNSS stays on, as decided in M2 (Q58)
 };
 static_assert(sizeof(kDefinitions) / sizeof(kDefinitions[0]) == static_cast<size_t>(Setting::Count),
               "every Setting needs a definition");
@@ -84,6 +92,11 @@ bool Settings::validString(Setting s, const std::string& value) const {
             if (value == region) return true;
         return false;
     }
+    uint32_t address;
+    if (s == Setting::Dns1) return net::parseIpv4(value, address);
+    if (s == Setting::Dns2) return value.empty() || net::parseIpv4(value, address);
+    if (s == Setting::Ntp1) return net::validHost(value);
+    if (s == Setting::Ntp2) return value.empty() || net::validHost(value);
     return true;
 }
 

lib/services/src/settings.h

@@ -24,6 +24,12 @@ enum class Setting : uint8_t {
     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)
+    Dns1,             // string: the first DNS server, an IPv4 address (S1, Q108, Q109)
+    Dns2,             // string: the second, or empty
+    DnsAlways,        // bool: use them on Automatic (DHCP) networks too, instead of DHCP's
+    Ntp1,             // string: the first NTP server, a host name or an IPv4 address (S1, Q110)
+    Ntp2,             // string: the second, or empty
+    GnssQuietForLora, // bool: put the GNSS receiver in standby while the LoRa radio listens (issue #20)
     Count
 };
 

lib/storage_model/src/sd_card_id.cpp

@@ -0,0 +1,53 @@
+#include "sd_card_id.h"
+
+#include <cstdio>
+
+namespace roro {
+
+namespace {
+char printable(uint8_t b) { return b >= 0x20 && b < 0x7F ? static_cast<char>(b) : '?'; }
+}  // namespace
+
+SdCardId parseSdCid(const uint8_t cid[16]) {
+    SdCardId id;
+    id.manufacturer = cid[0];
+    for (int i = 0; i < 2; ++i) id.oem[i] = printable(cid[1 + i]);
+    for (int i = 0; i < 5; ++i) id.product[i] = printable(cid[3 + i]);
+    id.revisionMajor = cid[8] >> 4;
+    id.revisionMinor = cid[8] & 0x0F;
+    id.serial = static_cast<uint32_t>(cid[9]) << 24 | cid[10] << 16 | cid[11] << 8 | cid[12];
+    // 4 reserved bits, 8 bits of year since 2000, 4 bits of month.
+    id.year = 2000 + (((cid[13] & 0x0F) << 4) | (cid[14] >> 4));
+    id.month = cid[14] & 0x0F;
+    return id;
+}
+
+const char* sdManufacturerName(uint8_t id) {
+    switch (id) {
+        case 0x01: return "Panasonic";
+        case 0x02: return "Toshiba/Kioxia";
+        case 0x03: return "SanDisk";
+        case 0x1B: return "Samsung";
+        case 0x1D: return "ADATA";
+        case 0x27: return "Phison";
+        case 0x28: return "Lexar";
+        case 0x31: return "Silicon Power";
+        case 0x41: return "Kingston";
+        case 0x74: return "Transcend";
+        case 0x76: return "Patriot";
+        case 0x82: return "Sony";
+        case 0x9C: return "Angelbird/Hoodman";
+        case 0xAD: return "Longsys/Lexar";
+        default: return "unknown";
+    }
+}
+
+std::string sdCardSummary(const SdCardId& id) {
+    char s[112];
+    std::snprintf(s, sizeof s, "%s (0x%02X) \"%s\" \"%s\" rev %u.%u, serial %08x, made %04d-%02d",
+                  sdManufacturerName(id.manufacturer), id.manufacturer, id.oem, id.product, id.revisionMajor,
+                  id.revisionMinor, static_cast<unsigned>(id.serial), id.year, id.month);
+    return s;
+}
+
+}  // namespace roro

lib/storage_model/src/sd_card_id.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <cstdint>
+#include <string>
+
+namespace roro {
+
+// What an SD card says it is: its CID register, 16 bytes (SD Physical Layer spec, 5.2).
+struct SdCardId {
+    uint8_t manufacturer = 0;  // assigned by the SD Association; see sdManufacturerName()
+    char oem[3] = {};          // two characters
+    char product[6] = {};      // five characters
+    uint8_t revisionMajor = 0, revisionMinor = 0;
+    uint32_t serial = 0;
+    int year = 0, month = 0;  // manufactured
+};
+
+SdCardId parseSdCid(const uint8_t cid[16]);
+
+// The usual holder of a manufacturer ID. The SD Association doesn't publish its list: these are
+// the commonly reported ones, and resold or counterfeit cards carry whatever their maker chose.
+const char* sdManufacturerName(uint8_t id);
+
+// "SanDisk (0x03) "SD" "SU08G" rev 8.0, serial 1234abcd, made 2014-03".
+std::string sdCardSummary(const SdCardId& id);
+
+}  // namespace roro

lib/system/src/task_stats.cpp

@@ -0,0 +1,72 @@
+#include "task_stats.h"
+
+#include <algorithm>
+#include <cctype>
+#include <cstring>
+
+namespace roro {
+
+std::vector<TaskRow> taskRows(const std::vector<TaskSample>& before, uint32_t totalBefore,
+                              const std::vector<TaskSample>& now, uint32_t totalNow) {
+    uint32_t elapsed = totalNow - totalBefore;  // unsigned: right across one wrap
+    std::vector<TaskRow> rows;
+    rows.reserve(now.size());
+    for (const TaskSample& t : now) {
+        uint32_t ran = t.runtime;  // a task that wasn't there before ran all of it since
+        for (const TaskSample& b : before)
+            if (b.id == t.id) {
+                ran = t.runtime - b.runtime;
+                break;
+            }
+        TaskRow r;
+        r.name = t.name;
+        r.core = t.core;
+        r.state = t.state;
+        r.priority = t.priority;
+        r.stackFree = t.stackFree;
+        r.permille = elapsed ? static_cast<uint16_t>(std::min<uint64_t>(1000, static_cast<uint64_t>(ran) * 1000 / elapsed)) : 0;
+        r.lowStack = t.stackFree < kLowStackBytes;
+        r.idle = std::strncmp(t.name, "IDLE", 4) == 0;
+        rows.push_back(r);
+    }
+    // The task that took the sample is running, and FreeRTOS counts a task's time when it's
+    // switched out: with its core to itself it never was, and its counter hardly moved. Give it
+    // what's left of its core once the idle task and the other tasks pinned there are counted.
+    for (TaskRow& r : rows) {
+        if (r.state != 0 || r.idle || r.core < 0) continue;  // 0: eRunning
+        int others = 0;
+        bool idleSeen = false;
+        for (const TaskRow& o : rows) {
+            if (&o == &r || o.core != r.core) continue;
+            others += o.permille;
+            idleSeen |= o.idle;
+        }
+        if (idleSeen && elapsed && 1000 - others > r.permille) r.permille = static_cast<uint16_t>(std::max(0, 1000 - others));
+    }
+    return rows;
+}
+
+int coreLoad(const std::vector<TaskRow>& rows, int core) {
+    for (const TaskRow& r : rows)
+        if (r.idle && r.core == core) return 100 - (r.permille + 5) / 10;
+    return -1;
+}
+
+void sortTasks(std::vector<TaskRow>& rows, TaskSort by) {
+    auto lower = [](const std::string& s) {
+        std::string l = s;
+        for (char& c : l) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
+        return l;
+    };
+    std::stable_sort(rows.begin(), rows.end(), [&](const TaskRow& a, const TaskRow& b) {
+        switch (by) {
+            case TaskSort::Share:
+                if (a.idle != b.idle) return !a.idle;  // idle tasks last
+                return a.permille > b.permille;
+            case TaskSort::Stack: return a.stackFree < b.stackFree;
+            default: return lower(a.name) < lower(b.name);
+        }
+    });
+}
+
+}  // namespace roro

lib/system/src/task_stats.h

@@ -0,0 +1,65 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <string>
+#include <vector>
+
+namespace roro {
+
+// One task as FreeRTOS reports it at one moment.
+struct TaskSample {
+    uint32_t id = 0;       // unique per task: a new task with an old name has another
+    char name[17] = {};
+    uint32_t runtime = 0;  // microseconds on a CPU since it started; 32 bits, so it wraps every 71 minutes
+    uint16_t stackFree = 0;  // the least it ever had left, bytes
+    int8_t core = -1;        // -1: not pinned
+    uint8_t state = 0;       // eTaskState
+    uint8_t priority = 0;
+};
+
+// What the System App and `tasks` show for a task (S1, Q119, Q122).
+struct TaskRow {
+    std::string name;
+    int core = -1;
+    uint8_t state = 0, priority = 0;
+    uint16_t stackFree = 0;
+    uint16_t permille = 0;  // share of one core over the interval, in tenths of a percent
+    bool lowStack = false;
+    bool idle = false;      // a core's idle task: what's left over
+};
+
+constexpr uint16_t kLowStackBytes = 512;
+
+// Shares from two samples: each task's run time between them over the time that passed. The
+// 32-bit counters may have wrapped once in between. The task that took the samples (the one
+// running) gets what's left of its core: see the .cpp.
+std::vector<TaskRow> taskRows(const std::vector<TaskSample>& before, uint32_t totalBefore,
+                              const std::vector<TaskSample>& now, uint32_t totalNow);
+
+// A core's load in percent: what its idle task didn't use. -1 without that task in the rows.
+int coreLoad(const std::vector<TaskRow>& rows, int core);
+
+enum class TaskSort : uint8_t { Share, Stack, Name };
+void sortTasks(std::vector<TaskRow>& rows, TaskSort by);
+
+// The last N samples, oldest first (Q120).
+template <typename T, size_t N>
+class History {
+   public:
+    void push(T value) {
+        values_[(first_ + size_) % N] = value;
+        if (size_ < N) size_++;
+        else first_ = (first_ + 1) % N;
+    }
+    size_t size() const { return size_; }
+    T at(size_t i) const { return values_[(first_ + i) % N]; }  // 0: the oldest kept
+    void clear() { first_ = size_ = 0; }
+
+   private:
+    T values_[N] = {};
+    size_t first_ = 0, size_ = 0;
+};
+
+}  // namespace roro

lib/wifi/src/saved_networks.cpp

@@ -17,6 +17,8 @@ void SavedNetworks::load() {
         int32_t hidden = 0;
         store_.getInt(key(i, "hid").c_str(), hidden);
         net.hidden = hidden != 0;
+        std::string ip;  // "address/prefix [gateway]", or empty for Automatic
+        net.fixed = store_.getString(key(i, "ip").c_str(), ip) && !ip.empty() && net::parseFixed(ip, net.ip).empty();
         networks_.push_back(net);
     }
 }
@@ -40,11 +42,30 @@ std::string SavedNetworks::add(const std::string& ssid, const std::string& passw
         }
     }
     if (count() >= kMax) return "Already 8 saved networks: forget one first";
-    networks_.push_back({ssid, password, hidden});
+    SavedNetwork added;
+    added.ssid = ssid;
+    added.password = password;
+    added.hidden = hidden;
+    networks_.push_back(added);
     save();
     return "";
 }
 
+std::string SavedNetworks::setIp(const std::string& ssid, const net::FixedIp* fixed) {
+    for (auto& n : networks_) {
+        if (n.ssid != ssid) continue;
+        if (fixed) {
+            std::string why = net::checkFixed(*fixed);
+            if (!why.empty()) return why;
+            n.ip = *fixed;
+        }
+        n.fixed = fixed != nullptr;
+        save();
+        return "";
+    }
+    return "Not a saved network";
+}
+
 void SavedNetworks::forget(const std::string& ssid) {
     for (auto it = networks_.begin(); it != networks_.end(); ++it) {
         if (it->ssid == ssid) {
@@ -60,6 +81,7 @@ void SavedNetworks::save() {
         store_.putString(key(i, "ssid").c_str(), networks_[i].ssid);
         store_.putString(key(i, "pass").c_str(), networks_[i].password);
         store_.putInt(key(i, "hid").c_str(), networks_[i].hidden ? 1 : 0);
+        store_.putString(key(i, "ip").c_str(), networks_[i].fixed ? net::formatFixed(networks_[i].ip) : "");
     }
     store_.putInt("net_count", count());
 }

lib/wifi/src/saved_networks.h

@@ -3,6 +3,7 @@
 #include <string>
 #include <vector>
 
+#include "ipv4.h"
 #include "key_value_store.h"
 
 namespace roro {
@@ -11,6 +12,8 @@ struct SavedNetwork {
     std::string ssid;
     std::string password;  // empty for an open network
     bool hidden = false;   // doesn't broadcast its name, so never shows up in scans
+    bool fixed = false;    // S1, Q105: Fixed address (`ip`), or Automatic (DHCP)
+    net::FixedIp ip;
 };
 
 // The Saved Networks the Wi-Fi Service may join (see CONTEXT.md), persisted in internal flash.
@@ -28,6 +31,8 @@ class SavedNetworks {
     // Adds, or updates the password of an existing SSID. Empty on success, otherwise why not.
     std::string add(const std::string& ssid, const std::string& password, bool hidden = false);
     void forget(const std::string& ssid);
+    // The IP setting: Fixed with these values, or Automatic (DHCP) for nullptr. Empty, or why not.
+    std::string setIp(const std::string& ssid, const net::FixedIp* fixed);
 
    private:
     void save();

src/apps/gnss_app.cpp

@@ -71,10 +71,12 @@ void GnssApp::draw(Canvas& c) {
     if (!gnss_.on()) {
         c.setFont(&fonts::bold);
         c.setTextColor(theme::kText);
-        c.drawString("GNSS is off", 4, area.y + 4);
+        bool held = gnss_.heldForLora();
+        c.drawString(held ? "GNSS is paused" : "GNSS is off", 4, area.y + 4);
         c.setFont(&fonts::body);
         c.setTextColor(theme::kMuted);
-        c.drawString("Settings > GNSS turns it on.", 4, area.y + 22);
+        c.drawString(held ? "The LoRa radio is listening, and" : "Settings > GNSS turns it on.", 4, area.y + 22);
+        if (held) c.drawString("Settings pauses GNSS for it.", 4, area.y + 22 + theme::kLineHeight);
         return;
     }
     sky_ ? drawSky(c) : drawPosition(c);

src/apps/system_app.cpp

@@ -0,0 +1,361 @@
+#include "system_app.h"
+
+#include <Arduino.h>
+#include <SD.h>
+#include <esp_heap_caps.h>
+
+#include <algorithm>
+#include <cstdio>
+
+#include "cleanup_plan.h"
+#include "platform/system_info.h"
+#include "sd_fault.h"
+#include "services/gemini_service.h"
+#include "ui/canvas.h"
+#include "ui/fonts.h"
+#include "ui/theme.h"
+#include "ui/widgets.h"
+
+namespace roro {
+
+namespace {
+
+constexpr size_t kUsers = static_cast<size_t>(net::User::Count);
+
+// Collects what the console's `info` prints, so the System view can't drift from it (Q125).
+class Lines : public Print {
+   public:
+    size_t write(uint8_t ch) override {
+        if (ch == '\n') {
+            lines.push_back(current_);
+            current_.clear();
+        } else if (ch != '\r') {
+            current_ += static_cast<char>(ch);
+        }
+        return 1;
+    }
+    std::vector<std::string> lines;
+
+   private:
+    std::string current_;
+};
+
+std::string duration(uint32_t seconds) {
+    char s[24];
+    if (seconds < 3600) std::snprintf(s, sizeof s, "%lu min %02lu s", (unsigned long)(seconds / 60), (unsigned long)(seconds % 60));
+    else std::snprintf(s, sizeof s, "%lu h %02lu min", (unsigned long)(seconds / 3600), (unsigned long)(seconds / 60 % 60));
+    return s;
+}
+
+// A filled bar for a percentage; the warning colour from 90 %.
+void bar(Canvas& c, int x, int y, int w, int percent) {
+    c.drawRect(x, y, w, 9, theme::kMuted);
+    int filled = std::clamp(percent, 0, 100) * (w - 2) / 100;
+    if (filled > 0) c.fillRect(x + 1, y + 1, filled, 7, percent >= 90 ? theme::kWarning : theme::kAccent);
+}
+
+}  // namespace
+
+void SystemApp::onEnter() {
+    view_ = View::Overview;
+    beforeTotal_ = system_info::sampleTasks(before_);
+    sampledMs_ = millis();
+    for (size_t i = 0; i < kUsers; i++) traffic_[i] = net::traffic(static_cast<net::User>(i));
+    requestRedraw();
+}
+
+void SystemApp::onExit() {  // nothing is kept while it's closed (Q120)
+    std::vector<TaskSample>().swap(before_);
+    std::vector<TaskRow>().swap(rows_);
+    std::vector<std::string>().swap(systemLines_);
+    for (auto& h : loadHistory_) h.clear();
+    heapHistory_.clear();
+    load_[0] = load_[1] = -1;
+}
+
+bool SystemApp::onKey(const KeyEvent& e) {
+    if (e.key == Key::Tab) {
+        int n = static_cast<int>(View::Count), v = static_cast<int>(view_);
+        view_ = static_cast<View>(e.shift ? (v + n - 1) % n : (v + 1) % n);
+        taskTop_ = systemTop_ = 0;
+        requestRedraw();
+        return true;
+    }
+    int step = e.key == Key::Up ? -1 : e.key == Key::Down ? 1 : 0;
+    if (step && view_ == View::Tasks) {
+        taskTop_ = std::clamp(taskTop_ + step, 0, std::max(0, static_cast<int>(rows_.size()) - kTaskRows));
+        requestRedraw();
+        return true;
+    }
+    if (step && view_ == View::System) {
+        systemTop_ = std::clamp(systemTop_ + step, 0, std::max(0, wrappedLines_ - 8));
+        requestRedraw();
+        return true;
+    }
+    if (view_ == View::Tasks && e.key == Key::Char && (e.ch == 's' || e.ch == 'S')) {  // Q122
+        sort_ = static_cast<TaskSort>((static_cast<int>(sort_) + 1) % 3);
+        sortTasks(rows_, sort_);
+        taskTop_ = 0;
+        requestRedraw();
+        return true;
+    }
+    return false;  // Back leaves the App
+}
+
+void SystemApp::update(uint32_t nowMs) {
+    if (nowMs - sampledMs_ >= 1000) sample(nowMs);
+}
+
+// Once a second (Q119): the tasks' shares over that second, the cores' load, the heap, the traffic.
+void SystemApp::sample(uint32_t nowMs) {
+    uint32_t elapsedMs = nowMs - sampledMs_;
+    sampledMs_ = nowMs;
+
+    std::vector<TaskSample> now;
+    uint32_t total = system_info::sampleTasks(now);
+    rows_ = taskRows(before_, beforeTotal_, now, total);
+    sortTasks(rows_, sort_);
+    before_.swap(now);
+    beforeTotal_ = total;
+    for (int core = 0; core < 2; core++) {
+        load_[core] = coreLoad(rows_, core);
+        loadHistory_[core].push(static_cast<uint8_t>(std::max(0, load_[core])));
+    }
+    heapHistory_.push(static_cast<uint16_t>(ESP.getFreeHeap() / 1024));
+
+    for (size_t i = 0; i < kUsers; i++) {
+        net::Traffic t = net::traffic(static_cast<net::User>(i));
+        rateIn_[i] = net::bytesPerSecond(traffic_[i].in, t.in, elapsedMs);
+        rateOut_[i] = net::bytesPerSecond(traffic_[i].out, t.out, elapsedMs);
+        traffic_[i] = t;
+    }
+
+    if (view_ == View::System) {  // the slow things: only while they're on screen
+        Lines out;
+        system_info::printSystem(out);
+        const BatteryEstimator& b = battery_.estimator();
+        if (b.hasReading()) out.printf("battery: %d %%, %d.%02d V\n", b.percent(), b.millivolts() / 1000, b.millivolts() % 1000 / 10);
+        StorageState card = storage_.state();
+        if (card.present)
+            out.printf("sd: %s of %s used, %u write faults\n", formatBytes(card.usedBytes).c_str(), formatBytes(card.totalBytes).c_str(),
+                       (unsigned)sdLastFault().count);
+        else out.println("sd: no card");
+        out.printf("radio: %s\n", !radio_.present() ? "none" : radio_.sweeping() ? "sweeping" : radio_.listening() ? "listening" : "asleep");
+        const auto& g = gnss_.state();
+        out.printf("gnss: %s, %d satellites used\n", !gnss_.on() ? "off" : gnss_.receiving(nowMs) ? "receiving" : "silent", g.satellitesUsed);
+        system_info::printSlots(out, store_);
+        systemLines_.swap(out.lines);
+    }
+    requestRedraw();
+}
+
+void SystemApp::footer(Canvas& c, const char* keys) {
+    const auto& area = theme::kContent;
+    c.setFont(&fonts::small);
+    c.setTextColor(theme::kMuted);
+    c.setTextDatum(top_left);
+    c.drawString(keys, 4, area.y + area.h - 9);
+}
+
+void SystemApp::draw(Canvas& c) {
+    c.setTextDatum(top_left);
+    switch (view_) {
+        case View::Overview: drawOverview(c); break;
+        case View::Tasks: drawTasks(c); break;
+        case View::Memory: drawMemory(c); break;
+        case View::Network: drawNetwork(c); break;
+        case View::System: drawSystem(c); break;
+        default: break;
+    }
+}
+
+void SystemApp::drawOverview(Canvas& c) {
+    const auto& area = theme::kContent;
+    char line[72];
+    c.setFont(&fonts::body);
+    int y = area.y + 2;
+    for (int core = 0; core < 2; core++) {
+        c.setTextColor(theme::kMuted);
+        std::snprintf(line, sizeof line, "Core %d", core);
+        c.drawString(line, 4, y);
+        bar(c, 52, y + 2, 130, load_[core]);
+        c.setTextColor(theme::kText);
+        if (load_[core] >= 0) std::snprintf(line, sizeof line, "%d%%", load_[core]);
+        else std::snprintf(line, sizeof line, "...");
+        c.drawString(line, 190, y);
+        y += theme::kLineHeight;
+    }
+    auto row = [&](const char* label, const std::string& value) {
+        c.setTextColor(theme::kMuted);
+        c.drawString(label, 4, y);
+        c.setTextColor(theme::kText);
+        c.drawString(value.c_str(), 62, y);
+        y += theme::kLineHeight;
+    };
+    std::snprintf(line, sizeof line, "%u KB free, lowest %u", (unsigned)(ESP.getFreeHeap() / 1024), (unsigned)(ESP.getMinFreeHeap() / 1024));
+    row("Memory", line);
+    uint32_t in = 0, out = 0;
+    for (size_t i = 0; i < kUsers; i++) in += rateIn_[i], out += rateOut_[i];
+    if (wifi_.state() == WifiController::State::Connected)
+        std::snprintf(line, sizeof line, "%s/s in, %s/s out", net::formatTraffic(in).c_str(), net::formatTraffic(out).c_str());
+    else std::snprintf(line, sizeof line, "not connected");
+    row("Network", line);
+    const BatteryEstimator& b = battery_.estimator();
+    if (b.hasReading()) std::snprintf(line, sizeof line, "%d%%, %d.%02d V", b.percent(), b.millivolts() / 1000, b.millivolts() % 1000 / 10);
+    else std::snprintf(line, sizeof line, "...");
+    row("Battery", line);
+    std::snprintf(line, sizeof line, "%s, %.0f C", duration(millis() / 1000).c_str(), temperatureRead());
+    row("Uptime", line);
+
+    // Both cores over the last two minutes: core 0 in the accent colour, core 1 in green.
+    int gx = 4, gy = y + 3, gw = static_cast<int>(kHistory) * 2 - 8, gh = area.y + area.h - 12 - gy;
+    if (gh > 8) {
+        c.drawRect(gx, gy, gw + 2, gh + 2, theme::kMuted);
+        for (int core = 0; core < 2; core++) {
+            const auto& h = loadHistory_[core];
+            for (size_t i = 1; i < h.size(); i++) {
+                int x0 = gx + 1 + static_cast<int>((i - 1) * gw / kHistory), x1 = gx + 1 + static_cast<int>(i * gw / kHistory);
+                c.drawLine(x0, gy + gh - h.at(i - 1) * gh / 100, x1, gy + gh - h.at(i) * gh / 100, core ? theme::kMessage : theme::kAccent);
+            }
+        }
+    }
+    footer(c, "Tab: tasks, memory, network, system");
+}
+
+void SystemApp::drawTasks(Canvas& c) {
+    const auto& area = theme::kContent;
+    c.setFont(&fonts::small);
+    c.setTextColor(theme::kMuted);
+    c.drawString("task", 4, area.y + 2);
+    c.setTextDatum(top_right);
+    c.drawString("core", 128, area.y + 2);
+    c.drawString("cpu", 176, area.y + 2);
+    c.drawString("stack left", area.w - 4, area.y + 2);
+    c.setFont(&fonts::body);
+    char cell[16];
+    for (int i = 0; i < kTaskRows && taskTop_ + i < static_cast<int>(rows_.size()); i++) {
+        const TaskRow& r = rows_[taskTop_ + i];
+        int y = area.y + 12 + i * theme::kLineHeight;
+        c.setTextDatum(top_left);
+        c.setTextColor(r.idle ? theme::kMuted : theme::kText);
+        c.drawString(r.name.c_str(), 4, y);
+        c.setTextDatum(top_right);
+        c.setTextColor(theme::kMuted);
+        c.drawString(r.core < 0 ? "any" : std::to_string(r.core).c_str(), 128, y);
+        c.setTextColor(r.idle ? theme::kMuted : theme::kText);
+        std::snprintf(cell, sizeof cell, "%u.%u%%", r.permille / 10, r.permille % 10);
+        c.drawString(cell, 176, y);
+        c.setTextColor(r.lowStack ? theme::kWarning : theme::kMuted);  // Q122: under 512 bytes
+        c.drawString(std::to_string(r.stackFree).c_str(), area.w - 4, y);
+    }
+    c.setTextDatum(top_left);
+    std::string keys = std::string("s: by ") + (sort_ == TaskSort::Share ? "stack" : sort_ == TaskSort::Stack ? "name" : "cpu") +
+                       "   " + std::to_string(rows_.size()) + " tasks   Tab: memory";
+    footer(c, keys.c_str());
+}
+
+void SystemApp::drawMemory(Canvas& c) {
+    const auto& area = theme::kContent;
+    char line[72];
+    c.setFont(&fonts::body);
+    c.setTextColor(theme::kText);
+    std::snprintf(line, sizeof line, "%.1f KB free, lowest %.1f", ESP.getFreeHeap() / 1024.0, ESP.getMinFreeHeap() / 1024.0);
+    c.drawString(line, 4, area.y + 2);
+    c.setTextColor(theme::kMuted);
+    std::snprintf(line, sizeof line, "largest free block %.1f KB", heap_caps_get_largest_free_block(MALLOC_CAP_8BIT) / 1024.0);
+    c.drawString(line, 4, area.y + 2 + theme::kLineHeight);
+
+    // Free heap over two minutes, with the floors of Q86 as lines.
+    int gx = 26, gy = area.y + 32, gw = area.w - gx - 6, gh = area.y + area.h - 12 - gy;
+    uint16_t top = 128;  // KB at the top of the scale: more if the heap has been higher
+    for (size_t i = 0; i < heapHistory_.size(); i++) top = std::max<uint16_t>(top, heapHistory_.at(i) + 8);
+    auto yOf = [&](int kb) { return gy + gh - std::clamp(kb, 0, static_cast<int>(top)) * gh / top; };
+    c.drawRect(gx, gy, gw, gh + 1, theme::kMuted);
+    c.setFont(&fonts::small);
+    struct {
+        size_t bytes;
+        uint16_t color;
+    } floors[] = {{GeminiService::kStartFloor, theme::kMuted}, {GeminiService::kSteadyFloor, theme::kWarning}, {GeminiService::kTransientFloor, theme::kMessage}};
+    for (auto& f : floors) {
+        int kb = static_cast<int>(f.bytes / 1024), y = yOf(kb);
+        for (int x = gx + 1; x < gx + gw - 1; x += 4) c.drawPixel(x, y, f.color);
+        c.setTextColor(f.color);
+        c.setTextDatum(top_right);
+        c.drawString(std::to_string(kb).c_str(), gx - 3, y - 3);
+    }
+    c.setTextDatum(top_left);
+    for (size_t i = 1; i < heapHistory_.size(); i++) {
+        int x0 = gx + 1 + static_cast<int>((i - 1) * (gw - 2) / kHistory), x1 = gx + 1 + static_cast<int>(i * (gw - 2) / kHistory);
+        c.drawLine(x0, yOf(heapHistory_.at(i - 1)), x1, yOf(heapHistory_.at(i)), theme::kAccent);
+    }
+    footer(c, "KB free, 2 min, with the floors   Tab: network");
+}
+
+void SystemApp::drawNetwork(Canvas& c) {
+    const auto& area = theme::kContent;
+    char line[72];
+    c.setFont(&fonts::body);
+    WifiService::Connection n = wifi_.connection();
+    c.setTextColor(n.connected ? theme::kText : theme::kWarning);
+    if (n.connected) std::snprintf(line, sizeof line, "%s, %d dBm", wifi_.ssid().c_str(), wifi_.rssi());
+    else std::snprintf(line, sizeof line, "Wi-Fi isn't connected");
+    c.drawString(line, 4, area.y + 2);
+    if (n.connected) {
+        c.setTextColor(theme::kMuted);
+        std::snprintf(line, sizeof line, "%s/%d %s, gw %s", n.address.c_str(), n.prefix, n.fixed ? "fixed" : "DHCP",
+                      n.gateway.empty() ? "none" : n.gateway.c_str());
+        c.drawString(line, 4, area.y + 2 + theme::kLineHeight);
+    }
+    // Per service (Q121): totals since boot, and the last second.
+    int y = area.y + 32;
+    c.setFont(&fonts::small);
+    c.setTextColor(theme::kMuted);
+    c.drawString("service", 4, y);
+    c.setTextDatum(top_right);
+    c.drawString("in", 124, y);
+    c.drawString("out", 168, y);
+    c.drawString("now, /s", area.w - 4, y);
+    c.setFont(&fonts::body);
+    y += 10;
+    for (size_t i = 0; i < kUsers; i++) {
+        bool active = rateIn_[i] || rateOut_[i];
+        c.setTextDatum(top_left);
+        c.setTextColor(active ? theme::kMessage : theme::kText);
+        c.drawString(net::userName(static_cast<net::User>(i)), 4, y);
+        c.setTextDatum(top_right);
+        c.setTextColor(theme::kText);
+        c.drawString(net::formatTraffic(traffic_[i].in).c_str(), 124, y);
+        c.drawString(net::formatTraffic(traffic_[i].out).c_str(), 168, y);
+        c.setTextColor(active ? theme::kMessage : theme::kMuted);
+        c.drawString(active ? net::formatTraffic(rateIn_[i] + rateOut_[i]).c_str() : "-", area.w - 4, y);
+        y += theme::kLineHeight;
+    }
+    c.setTextDatum(top_left);
+    footer(c, "bytes since boot   Tab: system");
+}
+
+void SystemApp::drawSystem(Canvas& c) {
+    const auto& area = theme::kContent;
+    if (systemLines_.empty()) {
+        c.setFont(&fonts::body);
+        c.setTextColor(theme::kMuted);
+        c.drawString("Reading...", 4, area.y + 4);
+        return;
+    }
+    // The console's lines are longer than the screen: wrap them, continuation lines indented.
+    std::vector<std::string> wrapped;
+    auto measure = widgets::bodyMeasure(c);
+    for (const std::string& line : systemLines_) {
+        bool first = true;
+        for (const std::string& part : wrapText(line, area.w - 14, measure)) {
+            wrapped.push_back(first ? part : "  " + part);
+            first = false;
+        }
+    }
+    wrappedLines_ = static_cast<int>(wrapped.size());
+    systemTop_ = std::clamp(systemTop_, 0, std::max(0, wrappedLines_ - 8));
+    widgets::textLines(c, wrapped, systemTop_, {area.x + 2, area.y + 2, area.w - 2, area.h - 12});
+    footer(c, "Tab: overview");
+}
+
+}  // namespace roro

src/apps/system_app.h

@@ -0,0 +1,67 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "app.h"
+#include "key_value_store.h"
+#include "services/battery_service.h"
+#include "services/gnss_service.h"
+#include "services/radio_service.h"
+#include "services/storage_service.h"
+#include "services/wifi_service.h"
+#include "task_stats.h"
+#include "traffic.h"
+
+namespace roro {
+
+// The System App (docs/milestones/S1.md, Q117 to Q127): what the device is doing, live and
+// read-only. Tab moves between Overview, Tasks, Memory, Network and System. It samples once a
+// second and keeps two minutes of history, only while it's open (Q120).
+class SystemApp : public App {
+   public:
+    SystemApp(WifiService& wifi, BatteryService& battery, StorageService& storage, RadioService& radio, GnssService& gnss,
+              KeyValueStore& store)
+        : wifi_(wifi), battery_(battery), storage_(storage), radio_(radio), gnss_(gnss), store_(store) {}
+    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 : uint8_t { Overview, Tasks, Memory, Network, System, Count };
+    static constexpr size_t kHistory = 120;  // seconds
+    static constexpr int kTaskRows = 7;
+
+    void sample(uint32_t nowMs);
+    void drawOverview(Canvas& c);
+    void drawTasks(Canvas& c);
+    void drawMemory(Canvas& c);
+    void drawNetwork(Canvas& c);
+    void drawSystem(Canvas& c);
+    void footer(Canvas& c, const char* keys);
+
+    WifiService& wifi_;
+    BatteryService& battery_;
+    StorageService& storage_;
+    RadioService& radio_;
+    GnssService& gnss_;
+    KeyValueStore& store_;
+    View view_ = View::Overview;
+    uint32_t sampledMs_ = 0;
+    std::vector<TaskSample> before_;
+    uint32_t beforeTotal_ = 0;
+    std::vector<TaskRow> rows_;  // the last second, sorted
+    TaskSort sort_ = TaskSort::Share;
+    int taskTop_ = 0;
+    int load_[2] = {-1, -1};
+    History<uint8_t, kHistory> loadHistory_[2];
+    History<uint16_t, kHistory> heapHistory_;  // free heap, KB
+    net::Traffic traffic_[static_cast<size_t>(net::User::Count)];
+    uint32_t rateIn_[static_cast<size_t>(net::User::Count)] = {}, rateOut_[static_cast<size_t>(net::User::Count)] = {};
+    std::vector<std::string> systemLines_;
+    int systemTop_ = 0, wrappedLines_ = 0;
+};
+
+}  // namespace roro

src/apps/wifi_settings_page.cpp

@@ -1,5 +1,6 @@
 #include "wifi_settings_page.h"
 
+#include "ipv4.h"
 #include "ui/fonts.h"
 #include "ui/widgets.h"
 
@@ -15,6 +16,62 @@ void WifiSettingsPage::enter() {
 
 void WifiSettingsPage::refreshMain() { main_.setCount(kFixedRows + saved_.count()); }
 
+// With Automatic, a network's page shows only the IP row and Forget.
+WifiSettingsPage::NetworkRow WifiSettingsPage::networkRow(int i) const {
+    if (draftFixed_) return static_cast<NetworkRow>(i);
+    return i == 0 ? kIpMode : kForget;
+}
+
+void WifiSettingsPage::openNetwork(const SavedNetwork& n) {
+    netSsid_ = n.ssid;
+    draftFixed_ = n.fixed;
+    draftAddress_ = n.fixed ? net::formatIpv4(n.ip.address) : "";
+    draftPrefix_ = n.fixed ? std::to_string(n.ip.prefix) : "";
+    draftGateway_ = n.fixed && n.ip.gateway ? net::formatIpv4(n.ip.gateway) : "";
+    network_.setCount(draftFixed_ ? 5 : 2);
+    network_.select(0);
+    view_ = View::Network;
+}
+
+// Leaving a network's page applies its IP setting (Q114), if it passes the checks (Q111).
+bool WifiSettingsPage::leaveNetwork() {
+    const SavedNetwork* n = saved_.find(netSsid_);
+    if (!n) return true;  // forgotten meanwhile
+    std::string why;
+    if (draftFixed_) {
+        net::FixedIp fixed;
+        why = net::parseFixed(draftAddress_ + "/" + draftPrefix_ + (draftGateway_.empty() ? "" : " " + draftGateway_), fixed);
+        if (draftAddress_.empty()) why = "A Fixed setting needs an address";
+        if (!why.empty()) {
+            warn(why);
+            return false;
+        }
+        bool same = n->fixed && n->ip.address == fixed.address && n->ip.prefix == fixed.prefix && n->ip.gateway == fixed.gateway;
+        if (same) return true;
+        why = saved_.setIp(netSsid_, &fixed);
+        if (why.empty()) warn(netSsid_ + ": fixed, " + net::formatFixed(fixed), NotificationLevel::Info);
+    } else {
+        if (!n->fixed) return true;
+        why = saved_.setIp(netSsid_, nullptr);
+        if (why.empty()) warn(netSsid_ + ": automatic (DHCP)", NotificationLevel::Info);
+    }
+    if (!why.empty()) {
+        warn(why);
+        return false;
+    }
+    wifi_.ipSettingChanged(netSsid_);
+    return true;
+}
+
+void WifiSettingsPage::edit(Field field, const std::string& title, const std::string& value, View from) {
+    field_ = field;
+    editTitle_ = title;
+    editFrom_ = from;
+    editor_ = LineEditor(field == Field::Ntp1 || field == Field::Ntp2 ? 63 : 15);
+    for (char ch : value) editor_.insert(static_cast<uint8_t>(ch));
+    view_ = View::Edit;
+}
+
 void WifiSettingsPage::warn(const std::string& text, NotificationLevel level) {
     bus_.publish(Event::withText(EventType::Notification, text.c_str(), static_cast<int32_t>(level)));
 }
@@ -35,42 +92,22 @@ bool WifiSettingsPage::onKey(const KeyEvent& e) {
     if (forgetDialog_) {
         forgetDialog_->onKey(e);
         if (forgetDialog_->result() == 1) {
-            saved_.forget(saved_.at(main_.selected() - kFixedRows).ssid);
-            refreshMain();
+            saved_.forget(netSsid_);
+            wifi_.ipSettingChanged(netSsid_);  // it may be the one in use
+            enter();
         }
-        if (forgetDialog_->result() != DialogModel::kPending) forgetDialog_.reset();
+        if (forgetDialog_ && forgetDialog_->result() != DialogModel::kPending) forgetDialog_.reset();
         return true;
     }
 
     switch (view_) {
-        case View::Main:
-            switch (e.key) {
-                case Key::Up: main_.up(); return true;
-                case Key::Down: main_.down(); return true;
-                case Key::Back: return false;
-                case Key::Left:
-                case Key::Right:
-                    if (main_.selected() != kToggle) return true;
-                    [[fallthrough]];
-                case Key::Select:
-                    switch (main_.selected()) {
-                        case kToggle: settings_.setBool(Setting::WifiEnabled, !settings_.getBool(Setting::WifiEnabled)); break;
-                        case kStatus: break;
-                        case kAddScanned:
-                            wifi_.startListScan();
-                            scan_.setCount(0);
-                            view_ = View::Scan;
-                            break;
-                        case kAddHidden:
-                            newHidden_ = true;
-                            editor_ = LineEditor(32);
-                            view_ = View::Ssid;
-                            break;
-                        default: forgetDialog_.reset(new DialogModel({"Cancel", "Forget"})); break;
-                    }
-                    return true;
-                default: return true;
-            }
+        case View::Main: return mainKey(e);
+        case View::Servers: return serversKey(e);
+        case View::Network: return networkKey(e);
+        case View::Edit: return editKey(e);
+        case View::Details:
+            if (e.key == Key::Back || e.key == Key::Select) view_ = View::Main;
+            return true;
 
         case View::Scan: {
             std::vector<ScanEntry> found;
@@ -131,6 +168,159 @@ bool WifiSettingsPage::onKey(const KeyEvent& e) {
     return true;
 }
 
+bool WifiSettingsPage::mainKey(const KeyEvent& e) {
+    switch (e.key) {
+        case Key::Up: main_.up(); return true;
+        case Key::Down: main_.down(); return true;
+        case Key::Back: return false;
+        case Key::Left:
+        case Key::Right:
+            if (main_.selected() != kToggle) return true;
+            [[fallthrough]];
+        case Key::Select:
+            switch (main_.selected()) {
+                case kToggle: settings_.setBool(Setting::WifiEnabled, !settings_.getBool(Setting::WifiEnabled)); break;
+                case kStatus: view_ = View::Details; break;
+                case kServers:
+                    servers_.setCount(kServerRows);
+                    view_ = View::Servers;
+                    break;
+                case kAddScanned:
+                    wifi_.startListScan();
+                    scan_.setCount(0);
+                    view_ = View::Scan;
+                    break;
+                case kAddHidden:
+                    newHidden_ = true;
+                    editor_ = LineEditor(32);
+                    view_ = View::Ssid;
+                    break;
+                default: openNetwork(saved_.at(main_.selected() - kFixedRows)); break;
+            }
+            return true;
+        default: return true;
+    }
+}
+
+// DNS and NTP servers (Q108 to Q110).
+bool WifiSettingsPage::serversKey(const KeyEvent& e) {
+    switch (e.key) {
+        case Key::Up: servers_.up(); break;
+        case Key::Down: servers_.down(); break;
+        case Key::Back: view_ = View::Main; break;
+        case Key::Left:
+        case Key::Right:
+            if (servers_.selected() != kDnsAlways) break;
+            [[fallthrough]];
+        case Key::Select:
+            switch (servers_.selected()) {
+                case kDns1: edit(Field::Dns1, "First DNS server", settings_.getString(Setting::Dns1), View::Servers); break;
+                case kDns2: edit(Field::Dns2, "Second DNS server (or empty)", settings_.getString(Setting::Dns2), View::Servers); break;
+                case kDnsAlways:
+                    settings_.setBool(Setting::DnsAlways, !settings_.getBool(Setting::DnsAlways));
+                    wifi_.serversChanged();
+                    break;
+                case kNtp1: edit(Field::Ntp1, "First NTP server", settings_.getString(Setting::Ntp1), View::Servers); break;
+                case kNtp2: edit(Field::Ntp2, "Second NTP server (or empty)", settings_.getString(Setting::Ntp2), View::Servers); break;
+            }
+            break;
+        default: break;
+    }
+    return true;
+}
+
+bool WifiSettingsPage::networkKey(const KeyEvent& e) {
+    switch (e.key) {
+        case Key::Up: network_.up(); break;
+        case Key::Down: network_.down(); break;
+        case Key::Back:
+            if (leaveNetwork()) enter();
+            break;
+        case Key::Left:
+        case Key::Right:
+            if (networkRow(network_.selected()) != kIpMode) break;
+            [[fallthrough]];
+        case Key::Select:
+            switch (networkRow(network_.selected())) {
+                case kIpMode: {
+                    draftFixed_ = !draftFixed_;
+                    // Fixed for the first time: start from what the network gave us, if we're on it.
+                    WifiService::Connection now = wifi_.connection();
+                    if (draftFixed_ && draftAddress_.empty() && now.connected && wifi_.ssid() == netSsid_) {
+                        draftAddress_ = now.address;
+                        draftPrefix_ = std::to_string(now.prefix);
+                        draftGateway_ = now.gateway;
+                    }
+                    if (draftFixed_ && draftPrefix_.empty()) draftPrefix_ = "24";
+                    network_.setCount(draftFixed_ ? 5 : 2);
+                    network_.select(0);
+                    break;
+                }
+                case kAddress: edit(Field::Address, "Address", draftAddress_, View::Network); break;
+                case kPrefix: edit(Field::Prefix, "Prefix (1 to 30; 24 = 255.255.255.0)", draftPrefix_, View::Network); break;
+                case kGateway: edit(Field::Gateway, "Gateway (or empty for none)", draftGateway_, View::Network); break;
+                case kForget: forgetDialog_.reset(new DialogModel({"Cancel", "Forget"})); break;
+            }
+            break;
+        default: break;
+    }
+    return true;
+}
+
+// One field. Addresses take digits and dots only (Q112); what's typed is checked on Enter (Q111).
+bool WifiSettingsPage::editKey(const KeyEvent& e) {
+    bool name = field_ == Field::Ntp1 || field_ == Field::Ntp2;
+    switch (e.key) {
+        case Key::Char: {
+            bool digit = e.ch >= '0' && e.ch <= '9';
+            bool ok = name ? e.ch > ' ' && e.ch < 0x7F : field_ == Field::Prefix ? digit : digit || e.ch == '.';
+            if (ok) editor_.insert(e.ch);
+            break;
+        }
+        case Key::Delete: editor_.backspace(); break;
+        case Key::Left: editor_.left(); break;
+        case Key::Right: editor_.right(); break;
+        case Key::Back: view_ = editFrom_; break;
+        case Key::Select: {
+            std::string text = editor_.text(), why;
+            uint32_t address;
+            switch (field_) {
+                case Field::Address:
+                    if (!net::parseIpv4(text, address)) why = "Four numbers from 0 to 255, like 10.39.39.13";
+                    else draftAddress_ = text;
+                    break;
+                case Field::Prefix: {
+                    int p = text.empty() ? 0 : atoi(text.c_str());
+                    if (p < 1 || p > 30) why = "The prefix must be 1 to 30";
+                    else draftPrefix_ = std::to_string(p);
+                    break;
+                }
+                case Field::Gateway:
+                    if (!text.empty() && !net::parseIpv4(text, address)) why = "Four numbers from 0 to 255, or empty";
+                    else draftGateway_ = text;
+                    break;
+                case Field::Dns1:
+                case Field::Dns2:
+                    if (!settings_.setString(field_ == Field::Dns1 ? Setting::Dns1 : Setting::Dns2, text))
+                        why = field_ == Field::Dns1 ? "An IPv4 address, like 9.9.9.9" : "An IPv4 address, or empty";
+                    else wifi_.serversChanged();
+                    break;
+                case Field::Ntp1:
+                case Field::Ntp2:
+                    if (!settings_.setString(field_ == Field::Ntp1 ? Setting::Ntp1 : Setting::Ntp2, text))
+                        why = field_ == Field::Ntp1 ? "A host name or an IPv4 address" : "A host name, an IPv4 address, or empty";
+                    else wifi_.serversChanged();
+                    break;
+            }
+            if (why.empty()) view_ = editFrom_;
+            else warn(why);
+            break;
+        }
+        default: break;
+    }
+    return true;
+}
+
 void WifiSettingsPage::draw(Canvas& c) {
     const auto& area = theme::kContent;
     switch (view_) {
@@ -141,6 +331,7 @@ void WifiSettingsPage::draw(Canvas& c) {
                     switch (i) {
                         case kToggle: return "Wi-Fi";
                         case kStatus: return "Status";
+                        case kServers: return "DNS and NTP";
                         case kAddScanned: return "Add a network";
                         case kAddHidden: return "Add a hidden network";
                         default: {
@@ -153,14 +344,78 @@ void WifiSettingsPage::draw(Canvas& c) {
                     switch (i) {
                         case kToggle: return settings_.getBool(Setting::WifiEnabled) ? "On" : "Off";
                         case kStatus: return statusText();
+                        case kServers:
                         case kAddScanned:
                         case kAddHidden: return ">";
+                        default: return saved_.at(i - kFixedRows).fixed ? "fixed" : "";
+                    }
+                });
+            break;
+
+        case View::Details: drawDetails(c); break;
+
+        case View::Servers:
+            widgets::list(
+                c, servers_, area,
+                [](int i) -> std::string {
+                    switch (i) {
+                        case kDns1: return "DNS 1";
+                        case kDns2: return "DNS 2";
+                        case kDnsAlways: return "Always use my DNS";
+                        case kNtp1: return "NTP 1";
+                        default: return "NTP 2";
+                    }
+                },
+                [this](int i) -> std::string {
+                    switch (i) {
+                        case kDns1: return settings_.getString(Setting::Dns1);
+                        case kDns2: return settings_.getString(Setting::Dns2).empty() ? "none" : settings_.getString(Setting::Dns2);
+                        case kDnsAlways: return settings_.getBool(Setting::DnsAlways) ? "On" : "Off";
+                        case kNtp1: return settings_.getString(Setting::Ntp1);
+                        default: return settings_.getString(Setting::Ntp2).empty() ? "none" : settings_.getString(Setting::Ntp2);
+                    }
+                });
+            break;
+
+        case View::Network: {
+            c.setFont(&fonts::small);
+            c.setTextColor(theme::kMuted);
+            c.drawString(netSsid_.c_str(), 4, area.y + 2);
+            widgets::list(
+                c, network_, {area.x, area.y + 12, area.w, area.h - 12},
+                [this](int i) -> std::string {
+                    switch (networkRow(i)) {
+                        case kIpMode: return "IP address";
+                        case kAddress: return "  Address";
+                        case kPrefix: return "  Prefix";
+                        case kGateway: return "  Gateway";
+                        default: return "Forget this network";
+                    }
+                },
+                [this](int i) -> std::string {
+                    switch (networkRow(i)) {
+                        case kIpMode: return draftFixed_ ? "Fixed" : "Automatic";
+                        case kAddress: return draftAddress_.empty() ? "not set" : draftAddress_;
+                        case kPrefix: {
+                            int p = atoi(draftPrefix_.c_str());
+                            return draftPrefix_ + " (" + net::formatIpv4(net::maskOf(p)) + ")";
+                        }
+                        case kGateway: return draftGateway_.empty() ? "none" : draftGateway_;
                         default: return "";
                     }
                 });
-            if (forgetDialog_ && main_.selected() >= kFixedRows)
-                widgets::dialog(c, "Forget network?", saved_.at(main_.selected() - kFixedRows).ssid, *forgetDialog_);
+            if (forgetDialog_) widgets::dialog(c, "Forget network?", netSsid_, *forgetDialog_);
             break;
+        }
+
+        case View::Edit: {
+            c.setFont(&fonts::body);
+            c.setTextColor(theme::kMuted);
+            c.drawString(editTitle_.c_str(), 4, area.y + 4);
+            widgets::lineEditor(c, editor_, {4, area.y + 22, area.w - 8, 0});
+            c.drawString("Enter: save   `: cancel", 4, area.y + 44);
+            break;
+        }
 
         case View::Scan: {
             if (!wifi_.listScanDone()) {
@@ -195,4 +450,25 @@ void WifiSettingsPage::draw(Canvas& c) {
     }
 }
 
+// What the device is using and where each part came from (Q113).
+void WifiSettingsPage::drawDetails(Canvas& c) {
+    const auto& area = theme::kContent;
+    WifiService::Connection n = wifi_.connection();
+    std::vector<std::string> lines;
+    if (!n.connected) {
+        lines = {statusText(), "", "`: back"};
+    } else {
+        lines.push_back(wifi_.ssid() + ", " + std::to_string(wifi_.rssi()) + " dBm");
+        lines.push_back("Address " + n.address + "/" + std::to_string(n.prefix) + (n.fixed ? " (fixed)" : " (DHCP)"));
+        lines.push_back("Mask " + n.mask);
+        lines.push_back("Gateway " + (n.gateway.empty() ? std::string("none") : n.gateway));
+        std::string from = n.dnsFromSettings ? " (Settings)" : " (DHCP)";
+        lines.push_back("DNS " + (n.dns[0].empty() ? std::string("none") : n.dns[0] + from));
+        if (!n.dns[1].empty()) lines.push_back("DNS " + n.dns[1] + from);
+        for (int i = 0; i < n.ntpCount; i++)
+            lines.push_back("NTP " + n.ntp[i].server + (n.ntp[i].fromDhcp ? " (DHCP)" : "") + (n.ntp[i].answered ? ", answered" : ""));
+    }
+    widgets::textLines(c, lines, 0, {area.x + 2, area.y + 2, area.w - 2, area.h - 2});
+}
+
 }  // namespace roro

src/apps/wifi_settings_page.h

@@ -16,8 +16,9 @@
 
 namespace roro {
 
-// Settings → Wi-Fi: the On/Off switch, current connection, Saved Networks, and adding networks
-// from a scan or by name (hidden). Owned by the Settings App.
+// Settings → Wi-Fi: the On/Off switch, the connection and its details, DNS and NTP servers, and
+// the Saved Networks: adding one from a scan or by name (hidden), and each one's own page with its
+// IP setting, Automatic or Fixed (docs/milestones/S1.md, Q113). Owned by the Settings App.
 class WifiSettingsPage {
    public:
     WifiSettingsPage(Settings& settings, SavedNetworks& saved, WifiService& wifi, EventBus& bus)
@@ -25,17 +26,31 @@ class WifiSettingsPage {
 
     void enter();
     bool onKey(const KeyEvent& e);  // false: leave the page
-    bool textEntryActive() const { return view_ == View::Ssid || view_ == View::Password; }
-    bool live() const { return view_ == View::Main || view_ == View::Scan; }  // redraw periodically
+    bool textEntryActive() const { return view_ == View::Ssid || view_ == View::Password || view_ == View::Edit; }
+    // Redraw periodically: the status, a scan, the connection details.
+    bool live() const { return view_ == View::Main || view_ == View::Scan || view_ == View::Details; }
     void draw(Canvas& c);
 
    private:
-    enum class View { Main, Scan, Ssid, Password };
-    enum Fixed { kToggle, kStatus, kAddScanned, kAddHidden, kFixedRows };
+    enum class View { Main, Scan, Ssid, Password, Details, Servers, Network, Edit };
+    enum Fixed { kToggle, kStatus, kServers, kAddScanned, kAddHidden, kFixedRows };
+    enum ServerRow { kDns1, kDns2, kDnsAlways, kNtp1, kNtp2, kServerRows };
+    // A Saved Network's page: with Automatic, only kIpMode and kForget are shown.
+    enum NetworkRow { kIpMode, kAddress, kPrefix, kGateway, kForget };
+    enum class Field { Address, Prefix, Gateway, Dns1, Dns2, Ntp1, Ntp2 };
 
     void refreshMain();
     void warn(const std::string& text, NotificationLevel level = NotificationLevel::Warning);
     std::string statusText() const;
+    bool mainKey(const KeyEvent& e);
+    bool serversKey(const KeyEvent& e);
+    bool networkKey(const KeyEvent& e);
+    bool editKey(const KeyEvent& e);
+    void openNetwork(const SavedNetwork& n);
+    bool leaveNetwork();  // checks and applies the draft; false (with a Toast) when it's refused
+    NetworkRow networkRow(int i) const;
+    void edit(Field field, const std::string& title, const std::string& value, View from);
+    void drawDetails(Canvas& c);
 
     Settings& settings_;
     SavedNetworks& saved_;
@@ -44,10 +59,21 @@ class WifiSettingsPage {
     View view_ = View::Main;
     ListModel main_{theme::kContent.h / theme::kLineHeight};
     ListModel scan_{theme::kContent.h / theme::kLineHeight};
+    ListModel servers_{theme::kContent.h / theme::kLineHeight};
+    ListModel network_{theme::kContent.h / theme::kLineHeight - 1};
     LineEditor editor_{63};
     std::string newSsid_;
     bool newHidden_ = false;
     std::unique_ptr<DialogModel> forgetDialog_;
+    // The Saved Network whose page is open, and its IP setting as being typed (a draft: applied on
+    // leaving the page, so a half-typed address is never used).
+    std::string netSsid_;
+    bool draftFixed_ = false;
+    std::string draftAddress_, draftPrefix_, draftGateway_;
+    // The field being edited, and where Enter and Back return to.
+    Field field_ = Field::Address;
+    std::string editTitle_;
+    View editFrom_ = View::Main;
 };
 
 }  // namespace roro

src/main.cpp

@@ -14,15 +14,20 @@
 #include "apps/launcher_app.h"
 #include "apps/lora_scanner_app.h"
 #include "apps/settings_app.h"
+#include "apps/system_app.h"
 #include "apps/wifi_tools_app.h"
 #include "apps/setup_app.h"
 #include "event_bus.h"
 #include "file_receiver.h"
+#include "ipv4.h"
+#include "traffic.h"
 #include "key_mapper.h"
 #include "platform/console.h"
 #include "platform/crash_report.h"
 #include "platform/nvs_store.h"
 #include "platform/system_info.h"
+#include "sd_card_id.h"
+#include "sd_fault.h"
 #include "service_manager.h"
 #include "platform/identity.h"
 #include "services/battery_service.h"
@@ -33,6 +38,7 @@
 #include "services/gnss_service.h"
 #include "services/power_service.h"
 #include "services/lora_capture_service.h"
+#include "services/noise_test.h"
 #include "services/radio_service.h"
 #include "services/storage_service.h"
 #include "services/update_service.h"
@@ -61,6 +67,9 @@ static ClockService* clockService;
 static GnssService* gnssService;
 static RadioService* radioService;
 static LoraCaptureService* loraCapture;
+#ifdef RORO_DEBUG
+static NoiseTest* noiseTest;
+#endif
 static GeminiService* geminiService;
 static SavedNetworks* savedNetworks;
 static WifiService* wifi;
@@ -175,6 +184,9 @@ void setup() {
     services.add(*gnssService);
     services.add(*radioService);
     loraCapture = new LoraCaptureService(*radioService, *storageService, *clockService, bus);
+#ifdef RORO_DEBUG
+    noiseTest = new NoiseTest(*radioService);
+#endif
     services.add(*loraCapture);
     services.add(*storageService);
     services.add(*wifi);
@@ -192,6 +204,8 @@ void setup() {
     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({"system", "System", false,
+                       new SystemApp(*wifi, *battery, *storageService, *radioService, *gnssService, nvs)});
     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)});
@@ -357,9 +371,49 @@ static void uploadStep() {
     }
 }
 
+#ifdef RORO_DEBUG
+// `wifi ip ... try <seconds>`: a trial IP setting that reverts unless `wifi ip keep` arrives, so a
+// wrong address tried over Wi-Fi doesn't cut the device off for good.
+static struct {
+    bool active = false;
+    uint32_t untilMs = 0;
+    std::string ssid;
+    bool wasFixed = false;
+    net::FixedIp was;
+} ipTrial;
+
+static void ipTrialStep() {
+    if (!ipTrial.active || static_cast<int32_t>(millis() - ipTrial.untilMs) < 0) return;
+    ipTrial.active = false;
+    savedNetworks->setIp(ipTrial.ssid, ipTrial.wasFixed ? &ipTrial.was : nullptr);
+    console.printf("wifi ip: trial over, %s is back to %s\n", ipTrial.ssid.c_str(),
+                   ipTrial.wasFixed ? net::formatFixed(ipTrial.was).c_str() : "Automatic (DHCP)");
+    wifi->ipSettingChanged(ipTrial.ssid);
+}
+#endif
+
+// `tasks`: the first sample, and when to take the second and print.
+static std::vector<TaskSample> tasksBefore;
+static uint32_t tasksTotal = 0, tasksDueMs = 0;
+static bool tasksPending = false;
+
+static uint32_t loopPasses = 0;  // counted in loop(), for `tasks` (issue #40)
+#ifdef RORO_DEBUG
+static bool loopSpin = false;  // `loop spin on`: no rest between passes, to compare load and radio noise
+#endif
+static uint32_t tasksPasses = 0;
+
+static void tasksStep() {
+    if (!tasksPending || static_cast<int32_t>(millis() - tasksDueMs) < 0) return;
+    tasksPending = false;
+    system_info::printTasks(console, tasksBefore, tasksTotal);
+    console.printf("loop: %lu passes in the last second, chip %.1f C\n", (unsigned long)(loopPasses - tasksPasses), temperatureRead());
+    std::vector<TaskSample>().swap(tasksBefore);
+}
+
 static const char* const kHelp =
     "info              firmware, uptime, memory, Wi-Fi, app slots\n"
-    "tasks             FreeRTOS tasks: state, priority, free stack, CPU\n"
+    "tasks             FreeRTOS tasks over the next second: state, priority, free stack, CPU share\n"    "net               bytes each network service has read and written since boot\n"
     "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"
@@ -367,17 +421,23 @@ static const char* const kHelp =
     "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 quiet on|off   pause the GNSS receiver while the LoRa radio listens (it costs the radio 8 dB)\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"
     "key <name|char>   press a key: up down left right select back home del tab space, or one character\n"
     "wifi status | wifi add <ssid><TAB><password>\n"
+    "wifi ip <ssid> dhcp | wifi ip <ssid> <address>/<prefix> [gateway]   a Saved Network's IP setting\n"
+    "wifi dns <a> [b] | wifi dns always on|off | wifi ntp <a> [b]   DNS and NTP servers\n"
     "gemini get <url>  fetch a Gemini page and report header, size, certificate, heap\n"
     "irc start | irc stop | irc dump | irc say <buffer> <text>\n"
     "ls [folder] | rm <path> | install <path.ota> (Update from SD)\n"
-    "sd list | cat <path> | log <text> | burst | sound on|off | short | normal\n"
+    "sd card | 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"
+    "wifi ip ... try <seconds> | wifi ip keep   a trial IP setting: back to the previous one unless kept\n"
+    "loop spin on|off  make the main loop spin without resting, to compare load and radio noise\n"
+    "lora noise test [gnss|quiet] | lora noise report   Sweep under one changed condition at a time (Wi-Fi goes off for a moment)\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"
@@ -388,7 +448,7 @@ static const char* const kHelp =
 
 // Commands that only touch what Safe Mode starts.
 static bool safeModeCommand(const String& line) {
-    return line == "help" || line == "info" || line == "tasks" || line == "reboot" || line == "boot other" ||
+    return line == "help" || line == "info" || line == "tasks" || line == "net" || line == "reboot" || line == "boot other" ||
            line.startsWith("log level ") || line.startsWith("crash") || line.startsWith("coredump") ||
            line == "wifi status" || line.startsWith("wifi add ");
 }
@@ -400,12 +460,30 @@ static void runCommand(String line) {
     if (line == "help") console.print(kHelp);
     if (line == "info") {
         system_info::printSystem(console);
-        console.printf("wifi: %s, ip %s, rssi %d | sd: %s\n", wifi->ssid().c_str(), wifi->ip().c_str(), wifi->rssi(),
-                       storageService->state().present ? "present" : "none");
+        console.printf("wifi: %s, ip %s, rssi %d | sd: %s, %u write faults\n", wifi->ssid().c_str(), wifi->ip().c_str(),
+                       wifi->rssi(), storageService->state().present ? "present" : "none", (unsigned)sdLastFault().count);
         console.printf("update: %s\n", update->onProbation() ? "on probation" : "confirmed");
         system_info::printSlots(console, nvs);
     }
-    if (line == "tasks") system_info::printTasks(console);
+#ifdef RORO_DEBUG
+    if (line == "loop spin on" || line == "loop spin off") {
+        loopSpin = line.endsWith("on");
+        console.printf("loop: %s\n", loopSpin ? "spinning, no rest" : "resting between passes");
+    }
+#endif
+    if (line == "tasks") {  // sampled now, printed a second later by tasksStep(): the loop must run in between
+        tasksTotal = system_info::sampleTasks(tasksBefore);
+        tasksDueMs = millis() + 1000;
+        tasksPasses = loopPasses;
+        tasksPending = true;
+    }
+    if (line == "net") {  // bytes each service has read and written since boot (S1, Q121)
+        for (int i = 0; i < static_cast<int>(net::User::Count); i++) {
+            net::Traffic t = net::traffic(static_cast<net::User>(i));
+            console.printf("net: %-14s in %10lu  out %10lu\n", net::userName(static_cast<net::User>(i)), (unsigned long)t.in,
+                           (unsigned long)t.out);
+        }
+    }
     if (line == "reboot") {
         console.println("restarting");
         delay(300);
@@ -434,6 +512,72 @@ static void runCommand(String line) {
     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"));
+#ifdef RORO_DEBUG
+    if (line == "lora noise report" && noiseTest) noiseTest->printReport(console);
+    if (line == "lora noise test" && noiseTest && !noiseTest->running()) {
+        // One thing changed at a time, each put back before the next (issue #20). Wi-Fi off cuts the
+        // Debug Console: the report prints when it's over, and `lora noise report` shows it again.
+        using C = NoiseTest::Condition;
+        auto radioOptions = [](bool ldo, bool boosted) { return [=]() { radioService->debugOptions(ldo, boosted); }; };
+        std::vector<C> conditions = {
+            {"as it is", nullptr, nullptr},
+            {"loop spinning", []() { loopSpin = true; }, []() { loopSpin = false; }},
+            {"GNSS in standby", []() { gnssService->send("PCAS12,30"); }, []() { gnssService->restart(millis()); }, 2500},
+            {"CPU at 160 MHz", []() { setCpuFrequencyMhz(160); }, []() { setCpuFrequencyMhz(240); }},
+            {"CPU at 80 MHz", []() { setCpuFrequencyMhz(80); }, []() { setCpuFrequencyMhz(240); }},
+            {"radio regulator: LDO", radioOptions(true, true), radioOptions(false, true)},
+            {"radio gain not boosted", radioOptions(false, false), radioOptions(false, true)},
+            {"as it is, again", nullptr, nullptr},
+            {"Wi-Fi off", []() { wifi->debugPause(true); }, []() { wifi->debugPause(false); }, 4000},
+            {"screen on", []() { power->onKey(millis()); }, nullptr, 1000},
+            {"as it is, at the end", nullptr, nullptr, 8000},
+        };
+        noiseTest->start(std::move(conditions));
+    }
+    if (line == "lora noise test quiet" && noiseTest && !noiseTest->running()) {
+        // The same conditions as the first test, with the GNSS receiver in standby throughout: with
+        // the loudest source out of the way, what else shows?
+        using C = NoiseTest::Condition;
+        auto radioOptions = [](bool ldo, bool boosted) { return [=]() { radioService->debugOptions(ldo, boosted); }; };
+        std::vector<C> conditions = {
+            {"GNSS on (reference)", nullptr, nullptr},
+            {"GNSS in standby", []() { gnssService->send("PCAS12,300"); }, nullptr, 2500},
+            {"+ loop spinning", []() { loopSpin = true; }, []() { loopSpin = false; }},
+            {"+ CPU at 160 MHz", []() { setCpuFrequencyMhz(160); }, []() { setCpuFrequencyMhz(240); }},
+            {"+ CPU at 80 MHz", []() { setCpuFrequencyMhz(80); }, []() { setCpuFrequencyMhz(240); }},
+            {"+ radio regulator: LDO", radioOptions(true, true), radioOptions(false, true)},
+            {"+ radio gain not boosted", radioOptions(false, false), radioOptions(false, true)},
+            {"GNSS in standby, again", nullptr, nullptr},
+            {"+ Wi-Fi off", []() { wifi->debugPause(true); }, []() { wifi->debugPause(false); }, 4000},
+            {"+ screen on", []() { power->onKey(millis()); }, nullptr, 1000},
+            {"+ antenna switched off", []() { radioService->debugAntenna(false); }, []() { radioService->debugAntenna(true); }},
+            {"+ antenna off, gain not boosted", []() { radioService->debugAntenna(false); radioService->debugOptions(false, false); },
+             []() { radioService->debugAntenna(true); radioService->debugOptions(false, true); }},
+            {"GNSS in standby, at the end", nullptr, []() { gnssService->restart(millis()); }, 8000},
+        };
+        noiseTest->start(std::move(conditions));
+    }
+    if (line == "lora noise test gnss" && noiseTest && !noiseTest->running()) {
+        // The first test pointed at the GNSS receiver. Is it the receiver working, or its serial
+        // line (about 20 sentences a second, next to the antenna)? Standby stops both; one sentence
+        // a second quietens the line and leaves the receiver tracking. PCAS03 picks the sentences:
+        // GGA, GLL, GSA, GSV, RMC, VTG, ZDA, ANT; all eight are on by default.
+        using C = NoiseTest::Condition;
+        auto standby = []() { gnssService->send("PCAS12,30"); };
+        auto wake = []() { gnssService->restart(millis()); };
+        std::vector<C> conditions = {
+            {"as it is", nullptr, nullptr},
+            {"GNSS in standby", standby, wake, 2500},
+            {"GNSS on again", nullptr, nullptr, 5000},
+            {"GNSS: RMC only", []() { gnssService->send("PCAS03,0,0,0,0,1,0,0,0,0,0,,,0,0"); },
+             []() { gnssService->send("PCAS03,1,1,1,1,1,1,1,1,0,0,,,0,0"); }, 2500},
+            {"GNSS: all sentences again", nullptr, nullptr, 3000},
+            {"GNSS in standby, again", standby, wake, 2500},
+            {"GNSS on again", nullptr, nullptr, 5000},
+        };
+        noiseTest->start(std::move(conditions));
+    }
+#endif
     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") {
@@ -481,6 +625,10 @@ static void runCommand(String line) {
         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 quiet on" || line == "gnss quiet off") {  // Settings > Pause GNSS for LoRa (issue #20)
+        settings.setBool(Setting::GnssQuietForLora, line.endsWith("on"));
+        console.printf("gnss quiet: %s\n", line.endsWith("on") ? "GNSS pauses while the LoRa radio listens" : "GNSS stays on");
+    }
     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());
@@ -537,6 +685,18 @@ static void runCommand(String line) {
         }
     }
     if (line.startsWith("sd put ")) startUpload(line.substring(7));  // then raw bytes: see uploadStep()
+    if (line == "sd card") {  // what the card says it is, from its CID register
+        if (!storageService->state().present) return (void)console.println("sd card: no card");
+        storageService->runJob([]() {
+            uint8_t cid[16];
+            const char* type = SD.cardType() == CARD_SDHC ? "SDHC/SDXC" : SD.cardType() == CARD_SD ? "SDSC" : "MMC or unknown";
+            if (!sdReadCid(cid)) return (void)console.println("sd card: the card didn't answer");
+            console.printf("sd card: %s, %.1f GB, %s\n", type, SD.cardSize() / 1e9, sdCardSummary(parseSdCid(cid)).c_str());
+            console.printf("sd card: CID");
+            for (uint8_t b : cid) console.printf(" %02x", b);
+            console.println();
+        });
+    }
     if (line == "sd list") {
         storageService->requestListing();
         listingWanted = true;
@@ -574,11 +734,77 @@ static void runCommand(String line) {
             }
         });
     }
-    if (line == "wifi status")
+    if (line == "wifi status") {
         console.printf("wifi: state %d ssid '%s' rssi %d ip %s clock %s heap %u min %u | fw %s%s\n",
                        (int)wifi->state(), wifi->ssid().c_str(), wifi->rssi(), wifi->ip().c_str(),
                        clockService->displayTime().c_str(), ESP.getFreeHeap(), ESP.getMinFreeHeap(), versionString(),
                        update->onProbation() ? " (on probation)" : "");
+        WifiService::Connection c = wifi->connection();  // S1, Q115: what's in use and where it came from
+        if (c.connected) {
+            console.printf("wifi: address %s/%d (%s), gateway %s\n", c.address.c_str(), c.prefix, c.fixed ? "fixed" : "DHCP",
+                           c.gateway.empty() ? "none" : c.gateway.c_str());
+            console.printf("wifi: dns %s %s (%s)\n", c.dns[0].empty() ? "none" : c.dns[0].c_str(), c.dns[1].c_str(),
+                           c.dnsFromSettings ? "Settings" : "DHCP");
+            console.print("wifi: ntp");
+            for (int i = 0; i < c.ntpCount; i++) console.printf(" %s (%s%s)", c.ntp[i].server.c_str(), c.ntp[i].fromDhcp ? "DHCP" : "Settings", c.ntp[i].answered ? ", answered" : "");
+            console.println(c.ntpCount ? "" : " none");
+        }
+    }
+    if (line.startsWith("wifi ip ")) {  // wifi ip <ssid> dhcp | <address>/<prefix> [gateway]  (the SSID may hold spaces)
+        std::string rest = line.substring(8).c_str();
+#ifdef RORO_DEBUG
+        if (rest == "keep") {  // the trial setting stays
+            console.println(ipTrial.active ? "wifi ip: kept" : "wifi ip: no trial running");
+            ipTrial.active = false;
+            return;
+        }
+        uint32_t trialS = 0;
+        size_t tryAt = rest.rfind(" try ");
+        if (tryAt != std::string::npos) {
+            trialS = strtoul(rest.c_str() + tryAt + 5, nullptr, 10);
+            rest = rest.substr(0, tryAt);
+        }
+#endif
+        std::string ssid, why;
+        net::FixedIp fixed;
+        bool dhcp = rest.size() > 5 && rest.compare(rest.size() - 5, 5, " dhcp") == 0;
+        if (dhcp) ssid = rest.substr(0, rest.size() - 5);
+        else {
+            size_t slash = rest.rfind('/'), space = slash == std::string::npos ? slash : rest.rfind(' ', slash);
+            if (space == std::string::npos) why = "usage: wifi ip <ssid> dhcp | <address>/<prefix> [gateway]";
+            else {
+                ssid = rest.substr(0, space);
+                why = net::parseFixed(rest.substr(space + 1), fixed);
+            }
+        }
+        const SavedNetwork* before = why.empty() ? savedNetworks->find(ssid) : nullptr;
+#ifdef RORO_DEBUG
+        if (before && trialS) ipTrial = {true, millis() + trialS * 1000, ssid, before->fixed, before->ip};
+#endif
+        if (why.empty()) why = savedNetworks->setIp(ssid, dhcp ? nullptr : &fixed);
+        if (!why.empty()) return (void)console.printf("wifi ip: %s\n", why.c_str());
+        console.printf("wifi ip: %s is now %s\n", ssid.c_str(), dhcp ? "Automatic (DHCP)" : net::formatFixed(fixed).c_str());
+        wifi->ipSettingChanged(ssid);
+    }
+    if ((line.startsWith("wifi dns ") && !line.startsWith("wifi dns always")) || line.startsWith("wifi ntp ")) {  // <a> [b]
+        bool dns = line.startsWith("wifi dns ");
+        std::string rest = line.substring(9).c_str();
+        size_t space = rest.find(' ');
+        std::string first = rest.substr(0, space), second = space == std::string::npos ? "" : rest.substr(space + 1);
+        Setting a = dns ? Setting::Dns1 : Setting::Ntp1, b = dns ? Setting::Dns2 : Setting::Ntp2;
+        std::string oldFirst = settings.getString(a);
+        // Both or neither: a refused second entry leaves the first as it was.
+        bool ok = settings.setString(a, first) && (settings.setString(b, second) || (settings.setString(a, oldFirst), false));
+        if (!ok) console.printf("wifi %s: %s\n", dns ? "dns" : "ntp", dns ? "an IPv4 address, then a second one if you like" : "a host name or an IPv4 address, then a second one if you like");
+        else {
+            console.printf("wifi %s: %s %s\n", dns ? "dns" : "ntp", first.c_str(), second.c_str());
+            wifi->serversChanged();
+        }
+    }
+    if (line == "wifi dns always on" || line == "wifi dns always off") {
+        settings.setBool(Setting::DnsAlways, line.endsWith("on"));
+        wifi->serversChanged();
+    }
     if (line == "sound off") settings.setBool(Setting::Sound, false);
     if (line == "sound on") settings.setBool(Setting::Sound, true);
     if (line == "short") {
@@ -626,6 +852,7 @@ static void loopSafeMode() {
     uint32_t now = millis();
     serialCommands();
     remoteCommands();
+    tasksStep();
     services.tick(now);
     bus.dispatch();
     noteStableOnce(now);
@@ -645,8 +872,30 @@ static void loopSafeMode() {
     delay(10);
 }
 
+// How long the main loop rests after a pass (issue #40). Spinning, it made 50,000 passes a
+// second and kept core 1 100 % busy for nothing: keys are buffered by the keyboard controller,
+// the consoles and the radio have their own tasks, and no Service asks for a tick more often than
+// every 50 ms. Shorter with the screen on, so a key or a redraw never waits long.
+constexpr uint32_t kLoopRestScreenOnMs = 5;
+constexpr uint32_t kLoopRestScreenOffMs = 20;
+static void loopPass();
+
 void loop() {
-    if (safeMode) return loopSafeMode();
+    loopPasses++;
+    if (safeMode) {
+        loopSafeMode();
+        delay(kLoopRestScreenOnMs);
+        return;
+    }
+    loopPass();
+#ifdef RORO_DEBUG
+    if (loopSpin) return;
+#endif
+    if (upload.active()) return;  // a serial file transfer: every byte is read promptly
+    delay(power->screen() == ScreenState::Off ? kLoopRestScreenOffMs : kLoopRestScreenOnMs);
+}
+
+static void loopPass() {
 #ifdef RORO_TEST_CRASH
     // Test builds only (never in a release): crash during Probation to exercise Rollback.
     if (millis() > 5000) abort();
@@ -657,6 +906,11 @@ void loop() {
 
     serialCommands();
     remoteCommands();
+    tasksStep();
+#ifdef RORO_DEBUG
+    ipTrialStep();
+    if (noiseTest) noiseTest->step(now);
+#endif
     noteStableOnce(now);
     uploadStep();
     printListingWhenReady();
@@ -669,6 +923,10 @@ void loop() {
             for (auto& e : events) apps->handleKey(e);
     }
 
+    // Issue #20: the GNSS receiver costs the LoRa radio 8 dB while it runs. If the user chose so,
+    // it waits in standby while the radio listens or sweeps; never while a Track is recording.
+    gnssService->holdForLora(settings.getBool(Setting::GnssQuietForLora) && !gnssService->tracking() &&
+                             (radioService->listening() || radioService->sweeping()));
     services.tick(now);
     bus.dispatch();
     notifier->update(now);

src/platform/counted_client.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+
+#include "traffic.h"
+
+namespace roro {
+
+// A NetworkClient (or NetworkClientSecure) that adds what it reads and writes to its service's
+// traffic counters (S1, Q121). Only the two buffer calls are overridden: the single-byte ones,
+// print() and printf() all go through them, so every byte is counted once.
+template <class Base>
+class Counted : public Base {
+   public:
+    explicit Counted(net::User user) : user_(user) {}
+    Counted(const Base& accepted, net::User user) : Base(accepted), user_(user) {}
+
+    // Overriding the buffer calls hides the single-byte ones; these put them back. They end up in
+    // the buffer calls below, where the counting happens.
+    int read() override { return Base::read(); }
+    size_t write(uint8_t byte) override { return Base::write(byte); }
+
+    size_t write(const uint8_t* buf, size_t size) override {
+        size_t n = Base::write(buf, size);
+        net::sent(user_, n);
+        return n;
+    }
+
+    int read(uint8_t* buf, size_t size) override {
+        int n = Base::read(buf, size);
+        if (n > 0) net::received(user_, static_cast<size_t>(n));
+        return n;
+    }
+
+   private:
+    net::User user_;
+};
+
+}  // namespace roro

src/platform/system_info.cpp

@@ -7,6 +7,8 @@
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
 
+#include <algorithm>
+#include <cstdio>
 #include <string>
 #include <vector>
 
@@ -89,20 +91,40 @@ void printSlots(Print& out, KeyValueStore& store) {
     }
 }
 
-void printTasks(Print& out) {
+uint32_t sampleTasks(std::vector<TaskSample>& out) {
     UBaseType_t n = uxTaskGetNumberOfTasks();
     std::vector<TaskStatus_t> tasks(n + 4);
     uint32_t total = 0;
     n = uxTaskGetSystemState(tasks.data(), tasks.size(), &total);
-    out.printf("%-16s %-4s %3s %6s %5s %s\n", "task", "st", "pri", "stack", "cpu%", "core");
-    static const char kStates[] = "RrBSD";  // running, ready, blocked, suspended, deleted
+    out.clear();
+    out.reserve(n);
     for (UBaseType_t i = 0; i < n; i++) {
         const TaskStatus_t& t = tasks[i];
-        unsigned cpu = total ? (unsigned)((uint64_t)t.ulRunTimeCounter * 100 / total) : 0;
-        int core = t.xCoreID == tskNO_AFFINITY ? -1 : (int)t.xCoreID;
-        out.printf("%-16s %-4c %3u %6u %5u %d\n", t.pcTaskName, t.eCurrentState < 5 ? kStates[t.eCurrentState] : '?',
-                   (unsigned)t.uxCurrentPriority, (unsigned)t.usStackHighWaterMark, cpu, core);
+        TaskSample s;
+        s.id = t.xTaskNumber;
+        std::snprintf(s.name, sizeof s.name, "%s", t.pcTaskName);
+        s.runtime = t.ulRunTimeCounter;
+        s.stackFree = static_cast<uint16_t>(std::min<uint32_t>(t.usStackHighWaterMark, 0xFFFF));
+        s.core = t.xCoreID == tskNO_AFFINITY ? -1 : static_cast<int8_t>(t.xCoreID);
+        s.state = static_cast<uint8_t>(t.eCurrentState);
+        s.priority = static_cast<uint8_t>(t.uxCurrentPriority);
+        out.push_back(s);
     }
+    return total;
+}
+
+// Shares over the interval since `before`, not since boot: the counters wrap every 71 minutes.
+void printTasks(Print& out, const std::vector<TaskSample>& before, uint32_t beforeTotal) {
+    std::vector<TaskSample> now;
+    uint32_t t1 = sampleTasks(now);
+    std::vector<TaskRow> rows = taskRows(before, beforeTotal, now, t1);
+    sortTasks(rows, TaskSort::Share);
+    out.printf("%-16s %-4s %3s %6s %6s %s\n", "task", "st", "pri", "stack", "cpu%", "core");
+    static const char kStates[] = "RrBSD";  // running, ready, blocked, suspended, deleted
+    for (const TaskRow& r : rows)
+        out.printf("%-16s %-4c %3u %6u %4u.%u %d%s\n", r.name.c_str(), r.state < 5 ? kStates[r.state] : '?', r.priority,
+                   r.stackFree, r.permille / 10, r.permille % 10, r.core, r.lowStack ? "  low stack" : "");
+    out.printf("load: core 0 %d %%, core 1 %d %%\n", coreLoad(rows, 0), coreLoad(rows, 1));
 }
 
 const char* bootOtherSlot() {

src/platform/system_info.h

@@ -3,7 +3,10 @@
 #include <Print.h>
 #include <esp_partition.h>
 
+#include <vector>
+
 #include "key_value_store.h"
+#include "task_stats.h"
 
 namespace roro::system_info {
 
@@ -20,7 +23,12 @@ void printSlots(Print& out, KeyValueStore& store);
 // Remembers which version the running slot holds (call at boot), or the slot an update just wrote.
 void recordSlotVersion(KeyValueStore& store, const esp_partition_t* slot, const char* version);
 // FreeRTOS tasks: state, priority, lowest free stack, CPU share since boot.
-void printTasks(Print& out);
+// The tasks' shares since `before` was sampled (with its run-time clock). The caller lets the main
+// loop run in between: sampling twice inside one command would show the loop asleep.
+void printTasks(Print& out, const std::vector<TaskSample>& before, uint32_t beforeTotal);
+// Every task as FreeRTOS reports it now; returns the run-time clock (microseconds, 32 bits), to
+// pair with the samples. Two of these make the shares the System App and `tasks` show.
+uint32_t sampleTasks(std::vector<TaskSample>& out);
 
 // Boots the firmware in the other app slot if it holds a valid image (a manual Rollback).
 // Returns an error message; on success it restarts and doesn't return.

src/services/debug_console.cpp

@@ -17,6 +17,8 @@
 #include "file_receiver.h"
 #include "sha256.h"
 #include "platform/console.h"
+#include "platform/counted_client.h"
+#include "sd_fault.h"
 #include "version.h"
 
 namespace roro {
@@ -109,7 +111,7 @@ void DebugConsole::listen() {
             listening = false;
         }
         if (listening) {
-            NetworkClient client = server.accept();
+            Counted<NetworkClient> client(server.accept(), net::User::DebugConsole);
             if (client) {
                 client.setNoDelay(true);
                 if (authenticate(client)) serve(client);
@@ -232,7 +234,16 @@ void DebugConsole::put(NetworkClient& client, const std::string& args) {
         while (r.state() == S::Receiving || r.state() == S::Writing) {
             if (r.state() == S::Writing) {
                 const auto& c = r.chunk();
+                uint32_t t0 = millis();
                 bool ok = f.write(c.data(), c.size()) == c.size();
+                uint32_t took = millis() - t0;
+                // Why, from our copy of the SD driver (lib/SD, #21): the step that gave up and what
+                // the card answered. How long it took tells a 500 ms busy timeout from a refusal.
+                if (!ok) {
+                    SdFault sd = sdLastFault();
+                    console.printf("put: write failed at %u after %u ms: SD step %u, answer 0x%02X, status 0x%04X (%u so far)\n",
+                                   (unsigned)r.received(), (unsigned)took, sd.step, sd.token, (unsigned)sd.resp, (unsigned)sd.count);
+                }
                 // 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. Earlier chunks may
                 // have been lost with the write buffer (M3: 3 KB came back as zeros): never extend

src/services/gemini_service.cpp

@@ -12,6 +12,7 @@
 #include "gemtext.h"
 #include "platform/console.h"
 #include "sha256.h"
+#include "platform/counted_client.h"
 #include "storage_paths.h"
 
 namespace roro {
@@ -544,7 +545,7 @@ void GeminiService::fetchOne(const std::string& url, GeminiPage& page, bool load
     auto track = [this]() { lowest_ = std::min<size_t>(lowest_, esp_get_free_heap_size()); };
 
     size_t freeBefore = esp_get_free_heap_size();  // what's left once the connection closes again
-    NetworkClientSecure tls;
+    Counted<NetworkClientSecure> tls(net::User::Gemini);
     tls.setInsecure();  // trust on first use: the pinned fingerprint is what counts (Q71)
     tls.setTimeout(15);
     if (!tls.connect(u.host.c_str(), u.portOrDefault())) {

src/services/gnss_service.cpp

@@ -66,7 +66,7 @@ void GnssService::close() {
 
 void GnssService::tick(uint32_t nowMs) {
     if (!open_) open(nowMs);
-    bool wanted = settings_.getBool(Setting::GnssEnabled);
+    bool wanted = settings_.getBool(Setting::GnssEnabled) && !held_;
     if (wanted && !active_) wake(nowMs);
     if (!wanted && (active_ || !standbyMs_ || nowMs - standbyMs_ >= kStandbyRenewMs)) standby(nowMs);
 

src/services/gnss_service.h

@@ -35,6 +35,10 @@ class GnssService : public Service {
     void tick(uint32_t nowMs) override;
 
     bool on() const { return active_; }
+    // Standby while the LoRa radio listens, when the user chose that (issue #20): the receiver
+    // raises the radio's noise floor by 8 dB while it runs. Never asked for during a Track.
+    void holdForLora(bool hold) { held_ = hold; }
+    bool heldForLora() const { return held_ && !active_; }
     bool receiving(uint32_t nowMs) const { return active_ && lastLineMs_ && nowMs - lastLineMs_ < kSilentAfterMs; }
     const gnss::GnssState& state() const { return parser_.state(); }
     uint32_t onSinceMs() const { return openedMs_; }  // when the receiver was last woken
@@ -71,7 +75,7 @@ class GnssService : public Service {
     StorageService& storage_;
     EventBus& bus_;
     gnss::NmeaParser parser_;
-    bool open_ = false, active_ = false, echo_ = false;
+    bool open_ = false, active_ = false, echo_ = false, held_ = false;
     uint32_t bytes_ = 0, standbyMs_ = 0;
     uint32_t openedMs_ = 0, lastLineMs_ = 0, firstFixMs_ = 0, clockSetMs_ = 0;
     gnss::FixType lastFix_ = gnss::FixType::None;

src/services/irc_service.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <NetworkClientSecure.h>
+#include "platform/counted_client.h"
 #include <freertos/FreeRTOS.h>
 #include <freertos/semphr.h>
 
@@ -75,8 +76,8 @@ class IrcService : public Service {
     std::unique_ptr<IrcSession> session_;
     SemaphoreHandle_t lock_ = nullptr;
     TaskHandle_t task_ = nullptr;
-    NetworkClientSecure tlsClient_;
-    NetworkClient plainClient_;
+    Counted<NetworkClientSecure> tlsClient_{net::User::Irc};  // counted for the System App (S1, Q121)
+    Counted<NetworkClient> plainClient_{net::User::Irc};
     NetworkClient* conn_ = &tlsClient_;  // whichever the config asks for
     ReconnectPolicy backoff_;
     std::string partial_;

src/services/noise_test.cpp

@@ -0,0 +1,110 @@
+#ifdef RORO_DEBUG
+
+#include "services/noise_test.h"
+
+#include <Arduino.h>
+
+#include <algorithm>
+#include <cstdio>
+
+#include "platform/console.h"
+#include "sweep_view.h"
+
+namespace roro {
+
+void NoiseTest::start(std::vector<Condition> conditions, int passes) {
+    if (running()) return;
+    conditions_ = std::move(conditions);
+    results_.clear();
+    report_.clear();
+    passes_ = passes;
+    index_ = 0;
+    console.printf("noise test: %u conditions, %d passes each\n", (unsigned)conditions_.size(), passes_);
+    begin(millis());
+}
+
+void NoiseTest::begin(uint32_t nowMs) {
+    const Condition& c = conditions_[index_];
+    if (c.apply) c.apply();
+    radio_.sweep(true);  // sets the radio up again, with whatever the condition changed
+    std::fill(std::begin(lowest_), std::end(lowest_), 0);
+    std::fill(std::begin(counts_), std::end(counts_), 0);
+    seen_ = 0;
+    phase_ = Phase::Settle;
+    phaseMs_ = nowMs;
+}
+
+void NoiseTest::step(uint32_t nowMs) {
+    if (phase_ == Phase::Idle) return;
+    const Condition& c = conditions_[index_];
+    if (phase_ == Phase::Settle) {
+        if (nowMs - phaseMs_ < c.settleMs) return;
+        lastSeq_ = radio_.sweeps();
+        phase_ = Phase::Sweep;
+        phaseMs_ = nowMs;
+        return;
+    }
+    SweepFrame f;
+    if (radio_.sweeps() != lastSeq_ && radio_.sweepFrame(f)) {
+        lastSeq_ = f.seq;
+        fromHz_ = f.fromHz, stepHz_ = f.stepHz, steps_ = f.steps;
+        for (uint16_t i = 0; i < f.steps; i++) {
+            lowest_[i] = seen_ ? std::min(lowest_[i], f.dbm[i]) : f.dbm[i];
+            counts_[std::clamp<int>(-f.dbm[i], 0, 127)]++;
+        }
+        seen_++;
+    }
+    bool stuck = nowMs - phaseMs_ > 20000;  // the radio never swept: don't hang the test
+    if (seen_ < passes_ && !stuck) return;
+
+    Result r;
+    r.name = c.name;
+    if (seen_) {
+        // The floor: the median of every reading. The top and the peaks: from the lowest reading
+        // at each step, so a burst in one pass doesn't count and a steady carrier does.
+        uint32_t total = 0, half = static_cast<uint32_t>(seen_) * steps_ / 2;
+        for (int level = 127; level >= 0; level--) {
+            total += counts_[level];
+            if (total > half) {
+                r.floor = -level;
+                break;
+            }
+        }
+        lora::SweepStats st = lora::summarize(lowest_, steps_, fromHz_, stepHz_);
+        r.top = st.top;
+        char p[32];
+        for (auto& peak : st.peaks) {
+            std::snprintf(p, sizeof p, "%s%.1f %d", r.peaks.empty() ? "" : ", ", peak.hz / 1e6, peak.dbm);
+            r.peaks += p;
+        }
+    } else {
+        r.name += " (no sweep)";
+    }
+    results_.push_back(r);
+    radio_.sweep(false);
+    if (c.restore) c.restore();
+    if (++index_ < conditions_.size()) begin(nowMs);
+    else finish();
+}
+
+void NoiseTest::finish() {
+    phase_ = Phase::Idle;
+    char line[160];
+    report_.push_back("noise test: floor = median of every reading; top and peaks = steady (lowest of the passes), dBm at 125 kHz");
+    for (auto& r : results_) {
+        std::snprintf(line, sizeof line, "noise test: %-26s floor %4d  top %4d  %s", r.name.c_str(), r.floor, r.top,
+                      r.peaks.empty() ? "no steady peak" : r.peaks.c_str());
+        report_.push_back(line);
+    }
+    report_.push_back("noise test: done");
+    printReport(console);
+}
+
+void NoiseTest::printReport(Print& out) const {
+    if (report_.empty()) return (void)out.println(running() ? "noise test: still running" : "noise test: none run yet");
+    for (auto& l : report_) out.println(l.c_str());
+}
+
+}  // namespace roro
+
+#endif  // RORO_DEBUG

src/services/noise_test.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#ifdef RORO_DEBUG
+
+#include <Print.h>
+
+#include <functional>
+#include <string>
+#include <vector>
+
+#include "services/radio_service.h"
+
+namespace roro {
+
+// `lora noise test` (Debug Builds, issue #20): which part of the Cardputer raises the radio's
+// noise floor? Applies one condition at a time, Sweeps the band a few passes, records the floor
+// and the steady peaks, and puts things back. It runs from the main loop on its own, because one
+// condition switches Wi-Fi off, and prints its report once the console can be reached again.
+class NoiseTest {
+   public:
+    struct Condition {
+        std::string name;
+        std::function<void()> apply, restore;  // either may be empty
+        uint32_t settleMs = 1500;
+    };
+
+    explicit NoiseTest(RadioService& radio) : radio_(radio) {}
+    void start(std::vector<Condition> conditions, int passes = 8);
+    void step(uint32_t nowMs);  // from the main loop
+    bool running() const { return phase_ != Phase::Idle; }
+    void printReport(Print& out) const;
+
+   private:
+    enum class Phase { Idle, Settle, Sweep };
+    struct Result {
+        std::string name;
+        int floor = 0, top = 0;
+        std::string peaks;  // steady ones: the lowest reading at each step over the passes
+    };
+    void begin(uint32_t nowMs);
+    void finish();
+
+    RadioService& radio_;
+    std::vector<Condition> conditions_;
+    std::vector<Result> results_;
+    size_t index_ = 0;
+    int passes_ = 8, seen_ = 0;
+    Phase phase_ = Phase::Idle;
+    uint32_t phaseMs_ = 0, lastSeq_ = 0;
+    int8_t lowest_[SweepFrame::kMaxSteps];
+    uint16_t counts_[128];  // how often each level (in -dBm) was read: for the median
+    uint32_t fromHz_ = 0, stepHz_ = 0;
+    uint16_t steps_ = 0;
+    std::vector<std::string> report_;
+};
+
+}  // namespace roro
+
+#endif  // RORO_DEBUG

src/services/radio_service.cpp

@@ -71,19 +71,19 @@ 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);
+                                  tcxo_, ldo_);
     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);
+                              ldo_);
     }
     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
+    radio_->setRxBoostedGainMode(boostedGain_);  // about 2 dB more sensitivity for about 2 mA
     return true;
 }
 
@@ -191,6 +191,12 @@ void RadioService::store(RadioPacket& p) {
 }
 
 #ifdef RORO_DEBUG
+void RadioService::debugAntenna(bool on) {
+    auto& i2c = M5.In_I2C;
+    uint8_t out = i2c.readRegister8(kExpander, kOutput, kI2cFreq);
+    i2c.writeRegister8(kExpander, kOutput, on ? (out | 1) : (out & ~1), kI2cFreq);
+}
+
 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;

src/services/radio_service.h

@@ -100,6 +100,15 @@ class RadioService : public Service {
     void setEcho(bool echo);
     void probe(Print& out);  // `lora probe`: runs on the radio task
 #ifdef RORO_DEBUG
+    // For the noise self-test (issue #20): the chip's regulator as an LDO instead of its DC-DC
+    // converter, and receive gain boosted or not. Used the next time the radio is set up.
+    void debugOptions(bool ldo, bool boostedGain) {
+        ldo_ = ldo;
+        boostedGain_ = boostedGain;
+    }
+    // The antenna switch (the Cap's expander, P0), for the reference "what the chip hears alone".
+    // From the main loop only, which owns the I2C bus.
+    void debugAntenna(bool on);
     // `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);
@@ -132,6 +141,7 @@ class RadioService : public Service {
     Config config_;
     bool present_ = false, expander_ = false;
     float tcxo_ = 1.8f;
+    std::atomic<bool> ldo_{false}, boostedGain_{true};
     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};

src/services/storage_service.cpp

@@ -166,7 +166,7 @@ void StorageService::format() {
     mounted_ = false;
 
     bool ok = false;
-    uint8_t pdrv = sdcard_init(pins::kSdCs, &sharedSpi(), 20000000);
+    uint8_t pdrv = sdcard_init(pins::kSdCs, &sharedSpi(), kSdHz);
     if (pdrv != 0xFF) {
         constexpr size_t kWorkSize = 4096;  // FF_MAX_SS
         std::unique_ptr<uint8_t[]> work(new uint8_t[kWorkSize]);
@@ -182,7 +182,7 @@ void StorageService::format() {
 }
 
 bool StorageService::mount() {
-    return SD.begin(pins::kSdCs, sharedSpi(), 20000000, "/sd", 5, false);
+    return SD.begin(pins::kSdCs, sharedSpi(), kSdHz, "/sd", 5, false);
 }
 
 void StorageService::poll() {

src/services/storage_service.h

@@ -56,6 +56,7 @@ class StorageService : public Service {
     static constexpr uint32_t kWakeMs = 1000;
     static constexpr uint32_t kPollEvery = 15;  // wake-ups between usage checks
     static constexpr size_t kMaxPendingBytes = 16 * 1024;
+    static constexpr uint32_t kSdHz = 20000000;  // the card's SPI clock; 10 MHz changed nothing (ADR 0007)
 
     static void taskEntry(void* self);
     void loop();

src/services/update_service.cpp

@@ -1,4 +1,5 @@
 #include "update_service.h"
+#include "platform/counted_client.h"
 
 #include <SD.h>
 #include <WiFi.h>
@@ -208,7 +209,7 @@ void UpdateService::listen() {
             }
         }
         if (listening && phase_ == Phase::Idle) {
-            NetworkClient client = server.accept();
+            Counted<NetworkClient> client(server.accept(), net::User::Updates);
             if (client) {
                 client.setNoDelay(true);
                 NetSource src(client);

src/services/wifi_service.cpp

@@ -3,10 +3,121 @@
 #include <WiFi.h>
 #include <esp_sntp.h>
 #include <esp_wifi.h>
+#include <lwip/ip_addr.h>
+
+#include <cstring>
+
+#include "ipv4.h"
 
 namespace roro {
 
 
+namespace {
+IPAddress toIp(uint32_t a) { return IPAddress(a >> 24, a >> 16 & 255, a >> 8 & 255, a & 255); }
+IPAddress toIp(const std::string& text) {
+    uint32_t a = 0;
+    net::parseIpv4(text, a);
+    return toIp(a);
+}
+const IPAddress kNoAddress(static_cast<uint32_t>(0));
+// A slot lwIP filled from DHCP has an address and no name; ours are set by name.
+bool sntpSlotFromDhcp(int i) {
+    const ip_addr_t* a = esp_sntp_getserver(i);
+    return !esp_sntp_getservername(i) && a && !ip_addr_isany(a);
+}
+constexpr int kNtpSlots = 3;  // CONFIG_LWIP_SNTP_MAX_SERVERS
+constexpr uint32_t kServersEveryMs = 30000;
+}  // namespace
+
+// Joins a Saved Network with its IP setting (S1, Q105): Fixed, or DHCP.
+void WifiService::join(const std::string& ssid, const std::string& password) {
+    const SavedNetwork* n = saved_.find(ssid);
+    fixed_ = n && n->fixed;
+    if (fixed_) {
+        // Nothing comes from DHCP here: forget the NTP servers a previous network offered.
+        for (int i = 0; i < kNtpSlots; i++)
+            if (sntpSlotFromDhcp(i)) esp_sntp_setserver(i, nullptr);
+        WiFi.config(toIp(n->ip.address), toIp(n->ip.gateway), toIp(net::maskOf(n->ip.prefix)),
+                    toIp(settings_.getString(Setting::Dns1)), toIp(settings_.getString(Setting::Dns2)));
+    } else {
+        WiFi.config(kNoAddress, kNoAddress, kNoAddress);  // DHCP
+    }
+    WiFi.begin(ssid.c_str(), password.empty() ? nullptr : password.c_str());
+}
+
+void WifiService::ipSettingChanged(const std::string& ssid) {
+    if (controller_.state() != WifiController::State::Connected || controller_.ssid() != ssid) return;
+    WiFi.disconnect();
+    apply(controller_.disconnected(millis()));
+    controller_.retryNow(millis());
+}
+
+// DNS and NTP as decided in Q108 and Q110. Run when connected, when a setting changes, and now
+// and then: a DHCP renewal puts DHCP's DNS back and clears the NTP slots it didn't fill.
+void WifiService::applyServers(Why why) {
+    if (controller_.state() != WifiController::State::Connected) return;
+    serversCheckedMs_ = millis();
+    bool changed = why != Why::Check;
+
+    bool wasFromSettings = dnsFromSettings_;
+    dnsFromSettings_ = fixed_ || settings_.getBool(Setting::DnsAlways);
+    if (dnsFromSettings_) {
+        IPAddress dns1 = toIp(settings_.getString(Setting::Dns1)), dns2 = toIp(settings_.getString(Setting::Dns2));
+        if (WiFi.dnsIP(0) != dns1 || WiFi.dnsIP(1) != dns2) WiFi.setDNS(dns1, dns2);
+    } else if (why == Why::SettingsChanged && wasFromSettings) {
+        // "Always use my DNS" was switched off: only a new lease brings DHCP's servers back.
+        ipSettingChanged(controller_.ssid());
+        return;
+    }
+
+    // NTP: the servers DHCP offered stay first; ours follow.
+    int fromDhcp = 0;
+    while (!fixed_ && fromDhcp < kNtpSlots && sntpSlotFromDhcp(fromDhcp)) fromDhcp++;
+    std::string wanted[2] = {settings_.getString(Setting::Ntp1), settings_.getString(Setting::Ntp2)};
+    bool touched = false;
+    for (int i = fromDhcp, mine = 0; i < kNtpSlots; i++, mine++) {
+        const char* current = esp_sntp_getservername(i);
+        if (mine < 2 && !wanted[mine].empty()) {
+            if (current && wanted[mine] == current) continue;
+            ntpNames_[mine] = wanted[mine];
+            esp_sntp_setservername(i, ntpNames_[mine].c_str());
+            touched = true;
+        } else if (current || sntpSlotFromDhcp(i)) {
+            esp_sntp_setserver(i, nullptr);
+            touched = true;
+        }
+    }
+    if (!esp_sntp_enabled()) {
+        esp_sntp_setoperatingmode(ESP_SNTP_OPMODE_POLL);
+        esp_sntp_init();
+    } else if (touched || changed) {
+        esp_sntp_restart();
+    }
+    if (touched || changed) ntpWaiting_ = true;
+}
+
+WifiService::Connection WifiService::connection() const {
+    Connection c;
+    c.connected = controller_.state() == WifiController::State::Connected;
+    if (!c.connected) return c;
+    c.fixed = fixed_;
+    c.dnsFromSettings = dnsFromSettings_;
+    c.address = WiFi.localIP().toString().c_str();
+    c.mask = WiFi.subnetMask().toString().c_str();
+    c.prefix = WiFi.subnetCIDR();
+    IPAddress gateway = WiFi.gatewayIP();
+    if (gateway != kNoAddress) c.gateway = gateway.toString().c_str();
+    for (int i = 0; i < 2; i++)
+        if (WiFi.dnsIP(i) != kNoAddress) c.dns[i] = WiFi.dnsIP(i).toString().c_str();
+    for (int i = 0; i < kNtpSlots; i++) {
+        const char* name = esp_sntp_getservername(i);
+        bool answered = esp_sntp_getreachability(i) != 0;
+        if (name) c.ntp[c.ntpCount++] = {name, false, answered};
+        else if (sntpSlotFromDhcp(i)) c.ntp[c.ntpCount++] = {ipaddr_ntoa(esp_sntp_getserver(i)), true, answered};
+    }
+    return c;
+}
+
 std::string WifiService::ip() const {
     return controller_.state() == WifiController::State::Connected ? WiFi.localIP().toString().c_str() : "";
 }
@@ -20,6 +131,7 @@ void WifiService::startScan(int channel) {
         WiFi.mode(WIFI_STA);
         WiFi.setAutoReconnect(false);  // the controller decides when to reconnect
         esp_wifi_set_country_code("EU", true);
+        esp_sntp_servermode_dhcp(true);  // before DHCP runs: take the NTP servers it offers (Q110)
         radioInitialised_ = true;
     }
     if (scanRunning_) return;
@@ -87,13 +199,7 @@ void WifiService::finishScan(uint32_t nowMs) {
 
 void WifiService::startNtp() {
     // Not configTime(): it would overwrite the POSIX TZ the Clock applies.
-    if (!esp_sntp_enabled()) {
-        esp_sntp_setoperatingmode(ESP_SNTP_OPMODE_POLL);
-        esp_sntp_setservername(0, "pool.ntp.org");
-        esp_sntp_init();
-    } else {
-        esp_sntp_restart();
-    }
+    applyServers(Why::Joined);
     ntpWaiting_ = true;
 }
 
@@ -102,7 +208,7 @@ void WifiService::apply(const WifiController::Step& step) {
     switch (step.action) {
         case Action::None: break;
         case Action::StartScan: startScan(); break;
-        case Action::Connect: WiFi.begin(step.ssid.c_str(), step.password.empty() ? nullptr : step.password.c_str()); break;
+        case Action::Connect: join(step.ssid, step.password); break;
         case Action::Disconnect: WiFi.disconnect(); break;
         case Action::RadioOff:
             WiFi.disconnect(true);
@@ -141,7 +247,9 @@ void WifiService::tick(uint32_t nowMs) {
         apply(controller_.disconnected(nowMs));
     }
 
-    apply(controller_.update(nowMs, settings_.getBool(Setting::WifiEnabled)));
+    apply(controller_.update(nowMs, settings_.getBool(Setting::WifiEnabled) && !paused_));
+
+    if (controller_.state() == State::Connected && nowMs - serversCheckedMs_ >= kServersEveryMs) applyServers(Why::Check);
 
     if (ntpWaiting_ && sntp_get_sync_status() == SNTP_SYNC_STATUS_COMPLETED) {
         ntpWaiting_ = false;

src/services/wifi_service.h

@@ -36,6 +36,32 @@ class WifiService : public Service {
     // Done with list scans: switch the radio back off if Wi-Fi itself is off.
     void endListScans();
 
+    // What the device is using and where each part came from (S1, Q113).
+    struct Connection {
+        bool connected = false;
+        bool fixed = false;            // the address: Fixed, or from DHCP
+        bool dnsFromSettings = false;  // DNS: from Settings, or from DHCP
+        std::string address, mask, gateway;
+        int prefix = 0;
+        std::string dns[2];
+        struct Ntp {
+            std::string server;
+            bool fromDhcp = false;
+            bool answered = false;  // it has replied since the last (re)start
+        } ntp[3];
+        int ntpCount = 0;
+    };
+    Connection connection() const;
+    // A Saved Network's IP setting changed: if it's the one in use, join it again with it (Q114).
+    void ipSettingChanged(const std::string& ssid);
+    // The DNS or NTP settings changed: use them now.
+    void serversChanged() { applyServers(Why::SettingsChanged); }
+#ifdef RORO_DEBUG
+    // The noise self-test switches the radio off for a few seconds. Not saved anywhere: a restart
+    // during the test brings Wi-Fi back, which a changed setting wouldn't.
+    void debugPause(bool paused) { paused_ = paused; }
+#endif
+
     // A Saved Network was added: try it now rather than after the retry delay.
     void savedNetworksChanged() { controller_.retryNow(millis()); }
 
@@ -47,6 +73,9 @@ class WifiService : public Service {
     void startScan(int channel = 0);
     void finishScan(uint32_t nowMs);
     void startNtp();
+    void join(const std::string& ssid, const std::string& password);
+    enum class Why { Joined, SettingsChanged, Check };
+    void applyServers(Why why);  // DNS and NTP, as Settings and the network say
 
     Settings& settings_;
     SavedNetworks& saved_;
@@ -58,6 +87,11 @@ class WifiService : public Service {
     uint32_t listScanSeq_ = 0;
     bool ntpWaiting_ = false;
     bool radioInitialised_ = false;
+    bool paused_ = false;          // Debug Builds: off for a moment, whatever the setting says
+    bool fixed_ = false;           // the network in use has a Fixed address
+    bool dnsFromSettings_ = false;
+    std::string ntpNames_[2];      // lwIP keeps the pointers, so the names live here
+    uint32_t serversCheckedMs_ = 0;
 };
 
 }  // namespace roro

test/test_ipv4/test_ipv4.cpp

@@ -0,0 +1,101 @@
+#include <unity.h>
+
+#include <string>
+
+#include "ipv4.h"
+
+using namespace roro::net;
+
+void setUp() {}
+void tearDown() {}
+
+static uint32_t ip(const char* s) {
+    uint32_t a = 0;
+    TEST_ASSERT_TRUE_MESSAGE(parseIpv4(s, a), s);
+    return a;
+}
+
+void test_parse_and_format() {
+    TEST_ASSERT_EQUAL_HEX32(0x0A27270C, ip("10.39.39.12"));
+    TEST_ASSERT_EQUAL_HEX32(0x00000000, ip("0.0.0.0"));
+    TEST_ASSERT_EQUAL_HEX32(0xFFFFFFFF, ip("255.255.255.255"));
+    TEST_ASSERT_EQUAL_STRING("10.39.39.12", formatIpv4(0x0A27270C).c_str());
+    TEST_ASSERT_EQUAL_STRING("192.168.1.254", formatIpv4(ip("192.168.1.254")).c_str());
+}
+
+void test_parse_refuses() {
+    uint32_t a;
+    for (const char* bad : {"", "10.39.39", "10.39.39.12.1", "10.39.39.256", "10..39.12", "10.39.39.", ".10.39.39",
+                            "10.39.39.1a", " 10.39.39.12", "10.39.39.12 ", "1.2.3.-4", "01234.1.1.1", "1.2.3.4/24"})
+        TEST_ASSERT_FALSE_MESSAGE(parseIpv4(bad, a), bad);
+}
+
+void test_prefix_and_mask() {
+    TEST_ASSERT_EQUAL_HEX32(0xFFFFFF00, maskOf(24));
+    TEST_ASSERT_EQUAL_HEX32(0xFFFFFFFC, maskOf(30));
+    TEST_ASSERT_EQUAL_HEX32(0x80000000, maskOf(1));
+    TEST_ASSERT_EQUAL_HEX32(0xFFFF0000, maskOf(16));
+    TEST_ASSERT_EQUAL_STRING("255.255.255.0", formatIpv4(maskOf(24)).c_str());
+}
+
+// Q111: what a Fixed setting must satisfy, and the reason given when it doesn't.
+void test_fixed_setting_accepted() {
+    TEST_ASSERT_EQUAL_STRING("", checkFixed({ip("10.39.39.13"), 24, ip("10.39.39.1")}).c_str());
+    TEST_ASSERT_EQUAL_STRING("", checkFixed({ip("192.168.4.2"), 30, ip("192.168.4.1")}).c_str());
+    TEST_ASSERT_EQUAL_STRING("", checkFixed({ip("10.0.0.5"), 8, 0}).c_str());  // Q107: no gateway is fine
+}
+
+void test_fixed_setting_refused() {
+    TEST_ASSERT_EQUAL_STRING("The prefix must be 1 to 30", checkFixed({ip("10.39.39.13"), 0, 0}).c_str());
+    TEST_ASSERT_EQUAL_STRING("The prefix must be 1 to 30", checkFixed({ip("10.39.39.13"), 31, 0}).c_str());
+    TEST_ASSERT_EQUAL_STRING("10.39.39.0 is the network's own address", checkFixed({ip("10.39.39.0"), 24, 0}).c_str());
+    TEST_ASSERT_EQUAL_STRING("10.39.39.255 is the broadcast address", checkFixed({ip("10.39.39.255"), 24, 0}).c_str());
+    TEST_ASSERT_EQUAL_STRING("The gateway 10.39.40.1 isn't in 10.39.39.0/24",
+                             checkFixed({ip("10.39.39.13"), 24, ip("10.39.40.1")}).c_str());
+    TEST_ASSERT_EQUAL_STRING("The gateway can't be this device's address",
+                             checkFixed({ip("10.39.39.13"), 24, ip("10.39.39.13")}).c_str());
+    TEST_ASSERT_EQUAL_STRING("The gateway 10.39.39.255 is the broadcast address",
+                             checkFixed({ip("10.39.39.13"), 24, ip("10.39.39.255")}).c_str());
+    TEST_ASSERT_EQUAL_STRING("0.0.0.0 isn't an address a device can have", checkFixed({0, 24, 0}).c_str());
+}
+
+// How a Fixed setting is typed on the console and kept in flash: "address/prefix [gateway]".
+void test_fixed_setting_as_text() {
+    FixedIp f;
+    TEST_ASSERT_EQUAL_STRING("", parseFixed("10.39.39.13/24 10.39.39.1", f).c_str());
+    TEST_ASSERT_EQUAL_HEX32(ip("10.39.39.13"), f.address);
+    TEST_ASSERT_EQUAL_UINT8(24, f.prefix);
+    TEST_ASSERT_EQUAL_HEX32(ip("10.39.39.1"), f.gateway);
+    TEST_ASSERT_EQUAL_STRING("10.39.39.13/24 10.39.39.1", formatFixed(f).c_str());
+
+    TEST_ASSERT_EQUAL_STRING("", parseFixed("192.168.4.2/30", f).c_str());
+    TEST_ASSERT_EQUAL_HEX32(0, f.gateway);
+    TEST_ASSERT_EQUAL_STRING("192.168.4.2/30", formatFixed(f).c_str());
+
+    TEST_ASSERT_EQUAL_STRING("Write it as address/prefix, then the gateway if there is one", parseFixed("10.39.39.13", f).c_str());
+    TEST_ASSERT_EQUAL_STRING("10.39.39.300 isn't an IPv4 address", parseFixed("10.39.39.300/24", f).c_str());
+    TEST_ASSERT_EQUAL_STRING("The prefix must be 1 to 30", parseFixed("10.39.39.13/abc", f).c_str());
+    TEST_ASSERT_EQUAL_STRING("gw isn't an IPv4 address", parseFixed("10.39.39.13/24 gw", f).c_str());
+    TEST_ASSERT_EQUAL_STRING("The gateway 10.39.40.1 isn't in 10.39.39.0/24", parseFixed("10.39.39.13/24 10.39.40.1", f).c_str());
+}
+
+// An NTP server is an address or a host name (Q110).
+void test_host_names() {
+    for (const char* good : {"pool.ntp.org", "time.cloudflare.com", "10.39.39.1", "ntp", "a-b.example", "0.be.pool.ntp.org"})
+        TEST_ASSERT_TRUE_MESSAGE(validHost(good), good);
+    for (const char* bad : {"", "pool .ntp.org", "-ntp.org", "ntp-.org", "ntp..org", ".ntp.org", "ntp.org.", "n_tp.org", "häst.se",
+                            "999.1.1.1", "1.2.3"})
+        TEST_ASSERT_FALSE_MESSAGE(validHost(bad), bad);
+}
+
+int main() {
+    UNITY_BEGIN();
+    RUN_TEST(test_parse_and_format);
+    RUN_TEST(test_parse_refuses);
+    RUN_TEST(test_prefix_and_mask);
+    RUN_TEST(test_fixed_setting_accepted);
+    RUN_TEST(test_fixed_setting_refused);
+    RUN_TEST(test_fixed_setting_as_text);
+    RUN_TEST(test_host_names);
+    return UNITY_END();
+}

test/test_saved_networks/test_saved_networks.cpp

@@ -97,6 +97,76 @@ void test_find() {
     TEST_ASSERT_NULL(n.find("other"));
 }
 
+// S1, Q105: each Saved Network is Automatic (DHCP) or Fixed, and remembers which.
+void test_new_network_is_automatic() {
+    MemoryStore store;
+    SavedNetworks nets(store);
+    nets.add("home", "password1");
+    TEST_ASSERT_FALSE(nets.find("home")->fixed);
+}
+
+void test_ip_setting_survives_reload() {
+    MemoryStore store;
+    SavedNetworks nets(store);
+    nets.add("home", "password1");
+    nets.add("bench", "");
+    roro::net::FixedIp f;
+    TEST_ASSERT_EQUAL_STRING("", roro::net::parseFixed("10.39.39.13/24 10.39.39.1", f).c_str());
+    TEST_ASSERT_EQUAL_STRING("", nets.setIp("bench", &f).c_str());
+
+    SavedNetworks again(store);
+    again.load();
+    TEST_ASSERT_FALSE(again.find("home")->fixed);
+    TEST_ASSERT_TRUE(again.find("bench")->fixed);
+    TEST_ASSERT_EQUAL_STRING("10.39.39.13/24 10.39.39.1", roro::net::formatFixed(again.find("bench")->ip).c_str());
+
+    TEST_ASSERT_EQUAL_STRING("", again.setIp("bench", nullptr).c_str());  // back to Automatic
+    SavedNetworks third(store);
+    third.load();
+    TEST_ASSERT_FALSE(third.find("bench")->fixed);
+}
+
+void test_ip_setting_is_checked() {
+    MemoryStore store;
+    SavedNetworks nets(store);
+    nets.add("bench", "");
+    roro::net::FixedIp bad{0x0A272700, 24, 0};  // 10.39.39.0: the network's own address
+    TEST_ASSERT_EQUAL_STRING("10.39.39.0 is the network's own address", nets.setIp("bench", &bad).c_str());
+    TEST_ASSERT_FALSE(nets.find("bench")->fixed);
+    roro::net::FixedIp ok{0x0A27270D, 24, 0};
+    TEST_ASSERT_EQUAL_STRING("Not a saved network", nets.setIp("nowhere", &ok).c_str());
+}
+
+// Forgetting a network moves the ones after it: each keeps its own setting.
+void test_ip_setting_follows_its_network() {
+    MemoryStore store;
+    SavedNetworks nets(store);
+    nets.add("a", "");
+    nets.add("b", "");
+    nets.add("c", "");
+    roro::net::FixedIp f{0x0A27270D, 24, 0};
+    nets.setIp("c", &f);
+    nets.forget("a");
+    SavedNetworks again(store);
+    again.load();
+    TEST_ASSERT_FALSE(again.find("b")->fixed);
+    TEST_ASSERT_TRUE(again.find("c")->fixed);
+    // And changing the password keeps it.
+    again.add("c", "password2");
+    TEST_ASSERT_TRUE(again.find("c")->fixed);
+}
+
+// A stored setting that no longer passes the checks falls back to Automatic.
+void test_bad_stored_ip_setting_is_ignored() {
+    MemoryStore store;
+    SavedNetworks nets(store);
+    nets.add("bench", "");
+    store.strings["net0_ip"] = "10.39.39.13/99";
+    SavedNetworks again(store);
+    again.load();
+    TEST_ASSERT_FALSE(again.find("bench")->fixed);
+}
+
 int main() {
     UNITY_BEGIN();
     RUN_TEST(test_empty_store_has_no_networks);
@@ -107,5 +177,10 @@ int main() {
     RUN_TEST(test_validation_follows_wifi_limits);
     RUN_TEST(test_hidden_flag_survives_reload);
     RUN_TEST(test_find);
+    RUN_TEST(test_new_network_is_automatic);
+    RUN_TEST(test_ip_setting_survives_reload);
+    RUN_TEST(test_ip_setting_is_checked);
+    RUN_TEST(test_ip_setting_follows_its_network);
+    RUN_TEST(test_bad_stored_ip_setting_is_ignored);
     return UNITY_END();
 }

test/test_sd_card_id/test_sd_card_id.cpp

@@ -0,0 +1,54 @@
+#include <unity.h>
+
+#include "sd_card_id.h"
+
+using namespace roro;
+
+void setUp() {}
+void tearDown() {}
+
+// A SanDisk 8 GB card's CID: manufacturer 0x03, OEM "SD", product "SU08G", revision 8.0,
+// serial 0x1234ABCD, made in March 2014.
+static const uint8_t kSanDisk[16] = {0x03, 'S', 'D', 'S', 'U', '0', '8', 'G', 0x80,
+                                     0x12, 0x34, 0xAB, 0xCD, 0x00, 0xE3, 0xFF};
+
+void test_fields() {
+    SdCardId id = parseSdCid(kSanDisk);
+    TEST_ASSERT_EQUAL_HEX8(0x03, id.manufacturer);
+    TEST_ASSERT_EQUAL_STRING("SD", id.oem);
+    TEST_ASSERT_EQUAL_STRING("SU08G", id.product);
+    TEST_ASSERT_EQUAL_UINT8(8, id.revisionMajor);
+    TEST_ASSERT_EQUAL_UINT8(0, id.revisionMinor);
+    TEST_ASSERT_EQUAL_HEX32(0x1234ABCD, id.serial);
+    TEST_ASSERT_EQUAL_INT(2014, id.year);
+    TEST_ASSERT_EQUAL_INT(3, id.month);
+}
+
+// Clone cards put anything in the name: unprintable bytes mustn't reach the console.
+void test_unprintable_names() {
+    uint8_t cid[16] = {0x00, 0x00, 0x01, 'A', 0x00, 0xFF, 'B', ' ', 0x10};
+    SdCardId id = parseSdCid(cid);
+    TEST_ASSERT_EQUAL_STRING("??", id.oem);
+    TEST_ASSERT_EQUAL_STRING("A??B ", id.product);
+    TEST_ASSERT_EQUAL_UINT8(1, id.revisionMajor);
+}
+
+void test_manufacturer_names() {
+    TEST_ASSERT_EQUAL_STRING("SanDisk", sdManufacturerName(0x03));
+    TEST_ASSERT_EQUAL_STRING("Samsung", sdManufacturerName(0x1B));
+    TEST_ASSERT_EQUAL_STRING("unknown", sdManufacturerName(0xEE));
+}
+
+void test_summary_line() {
+    TEST_ASSERT_EQUAL_STRING("SanDisk (0x03) \"SD\" \"SU08G\" rev 8.0, serial 1234abcd, made 2014-03",
+                             sdCardSummary(parseSdCid(kSanDisk)).c_str());
+}
+
+int main() {
+    UNITY_BEGIN();
+    RUN_TEST(test_fields);
+    RUN_TEST(test_unprintable_names);
+    RUN_TEST(test_manufacturer_names);
+    RUN_TEST(test_summary_line);
+    return UNITY_END();
+}

test/test_settings/test_settings.cpp

@@ -154,6 +154,37 @@ void test_storage_keys_fit_nvs_limit() {
         TEST_ASSERT_TRUE(std::strlen(Settings::key(static_cast<Setting>(i))) <= 15);
 }
 
+// S1, Q108 to Q110: DNS and NTP servers, with public defaults.
+void test_dns_and_ntp_defaults() {
+    MemoryStore store;
+    EventBus bus;
+    Settings s(store, bus);
+    s.load();
+    TEST_ASSERT_EQUAL_STRING("9.9.9.9", s.getString(Setting::Dns1).c_str());
+    TEST_ASSERT_EQUAL_STRING("1.1.1.1", s.getString(Setting::Dns2).c_str());
+    TEST_ASSERT_FALSE(s.getBool(Setting::DnsAlways));
+    TEST_ASSERT_EQUAL_STRING("pool.ntp.org", s.getString(Setting::Ntp1).c_str());
+    TEST_ASSERT_EQUAL_STRING("time.cloudflare.com", s.getString(Setting::Ntp2).c_str());
+}
+
+void test_dns_and_ntp_are_checked() {
+    MemoryStore store;
+    EventBus bus;
+    Settings s(store, bus);
+    s.load();
+    TEST_ASSERT_TRUE(s.setString(Setting::Dns1, "10.39.39.1"));
+    TEST_ASSERT_FALSE(s.setString(Setting::Dns1, "dns.example"));  // an address, not a name
+    TEST_ASSERT_FALSE(s.setString(Setting::Dns1, ""));             // the first one is required
+    TEST_ASSERT_EQUAL_STRING("10.39.39.1", s.getString(Setting::Dns1).c_str());
+    TEST_ASSERT_TRUE(s.setString(Setting::Dns2, ""));              // the second is optional
+    TEST_ASSERT_FALSE(s.setString(Setting::Dns2, "1.1.1"));
+    TEST_ASSERT_TRUE(s.setString(Setting::Ntp1, "10.39.39.1"));
+    TEST_ASSERT_TRUE(s.setString(Setting::Ntp1, "0.be.pool.ntp.org"));
+    TEST_ASSERT_FALSE(s.setString(Setting::Ntp1, "time server"));
+    TEST_ASSERT_FALSE(s.setString(Setting::Ntp1, ""));
+    TEST_ASSERT_TRUE(s.setString(Setting::Ntp2, ""));
+}
+
 int main() {
     UNITY_BEGIN();
     RUN_TEST(test_defaults_when_store_is_empty);
@@ -168,5 +199,7 @@ int main() {
     RUN_TEST(test_change_publishes_setting_changed_once);
     RUN_TEST(test_transmit_requires_confirmed_region);
     RUN_TEST(test_storage_keys_fit_nvs_limit);
+    RUN_TEST(test_dns_and_ntp_defaults);
+    RUN_TEST(test_dns_and_ntp_are_checked);
     return UNITY_END();
 }

test/test_settings_menu/test_settings_menu.cpp

@@ -107,6 +107,19 @@ void test_names_are_text_rows_with_their_byte_limits() {
     TEST_ASSERT_EQUAL_STRING("RORO", f.menu.value(shortName).c_str());
 }
 
+// Issue #20: the GNSS receiver raises the LoRa radio's noise floor by 8 dB while it runs. Pausing
+// it while the radio listens is offered, and off unless chosen (GNSS on by default: M2, Q58).
+void test_pause_gnss_for_lora_is_off_by_default() {
+    Fixture f;
+    int quiet = f.row(SettingsMenu::Row::GnssQuiet);
+    TEST_ASSERT_EQUAL_STRING("Pause GNSS for LoRa", f.menu.label(quiet).c_str());
+    TEST_ASSERT_EQUAL_STRING("Off", f.menu.value(quiet).c_str());
+    f.menu.toggle(quiet);
+    TEST_ASSERT_TRUE(f.settings.getBool(Setting::GnssQuietForLora));
+    TEST_ASSERT_EQUAL_STRING("On", f.menu.value(quiet).c_str());
+    TEST_ASSERT_TRUE(f.settings.getBool(Setting::GnssEnabled));  // the GNSS switch itself is untouched
+}
+
 void test_gnss_and_coordinate_rows_toggle() {
     Fixture f;
     int gnss = f.row(SettingsMenu::Row::Gnss), coords = f.row(SettingsMenu::Row::Coordinates);
@@ -131,6 +144,7 @@ int main() {
     RUN_TEST(test_brightness_steps_with_left_right_within_bounds);
     RUN_TEST(test_wifi_is_a_page);
     RUN_TEST(test_names_are_text_rows_with_their_byte_limits);
+    RUN_TEST(test_pause_gnss_for_lora_is_off_by_default);
     RUN_TEST(test_gnss_and_coordinate_rows_toggle);
     return UNITY_END();
 }

test/test_task_stats/test_task_stats.cpp

@@ -0,0 +1,160 @@
+#include <unity.h>
+
+#include <vector>
+
+#include "task_stats.h"
+
+using namespace roro;
+
+void setUp() {}
+void tearDown() {}
+
+static TaskSample task(uint32_t id, const char* name, uint32_t runtime, uint16_t stackFree = 2000, int core = 1) {
+    TaskSample t;
+    t.id = id;
+    std::snprintf(t.name, sizeof t.name, "%s", name);
+    t.runtime = runtime;
+    t.stackFree = stackFree;
+    t.core = static_cast<int8_t>(core);
+    t.state = 2;  // blocked, unless a test says it's the one running
+    return t;
+}
+
+static const TaskRow* find(const std::vector<TaskRow>& rows, const char* name) {
+    for (auto& r : rows)
+        if (r.name == name) return &r;
+    return nullptr;
+}
+
+// Q119: a task's share is its run time over the interval between two samples, in tenths of a percent.
+void test_shares_over_the_interval() {
+    std::vector<TaskSample> before = {task(1, "loopTask", 5000000), task(2, "IDLE1", 1000000), task(3, "IDLE0", 4000000, 240, 0),
+                                      task(4, "wifi", 900000, 4000, 0)};
+    std::vector<TaskSample> now = {task(1, "loopTask", 5810000), task(2, "IDLE1", 1170000), task(3, "IDLE0", 4780000, 240, 0),
+                                   task(4, "wifi", 1090000, 4000, 0)};
+    auto rows = taskRows(before, 10000000, now, 11000000);  // one second later
+    TEST_ASSERT_EQUAL_size_t(4, rows.size());
+    TEST_ASSERT_EQUAL_UINT16(810, find(rows, "loopTask")->permille);
+    TEST_ASSERT_EQUAL_UINT16(170, find(rows, "IDLE1")->permille);
+    TEST_ASSERT_EQUAL_UINT16(780, find(rows, "IDLE0")->permille);
+    TEST_ASSERT_EQUAL_UINT16(190, find(rows, "wifi")->permille);
+    // A core's load is what its idle task didn't use.
+    TEST_ASSERT_EQUAL_INT(22, coreLoad(rows, 0));
+    TEST_ASSERT_EQUAL_INT(83, coreLoad(rows, 1));
+    TEST_ASSERT_EQUAL_INT(-1, coreLoad(rows, 2));
+}
+
+// FreeRTOS adds to a task's run time when it's switched out. The task doing the sampling is
+// running: if nothing else wanted its core, it was never switched out and its counter hardly
+// moved. Its real share is what's left of its core.
+void test_the_running_task_gets_what_is_left_of_its_core() {
+    auto running = [](TaskSample t) {
+        t.state = 0;  // eRunning
+        return t;
+    };
+    std::vector<TaskSample> before = {running(task(1, "loopTask", 5000000)), task(2, "IDLE1", 1000000), task(3, "radio", 100),
+                                      task(4, "IDLE0", 4000000, 240, 0), task(5, "wifi", 900000, 4000, 0)};
+    std::vector<TaskSample> now = {running(task(1, "loopTask", 5020000)), task(2, "IDLE1", 1000000), task(3, "radio", 30100),
+                                   task(4, "IDLE0", 4980000, 240, 0), task(5, "wifi", 910000, 4000, 0)};
+    auto rows = taskRows(before, 0, now, 1000000);
+    TEST_ASSERT_EQUAL_UINT16(970, find(rows, "loopTask")->permille);  // not the 2 % its counter says
+    TEST_ASSERT_EQUAL_UINT16(30, find(rows, "radio")->permille);
+    TEST_ASSERT_EQUAL_UINT16(10, find(rows, "wifi")->permille);  // another core: untouched
+    TEST_ASSERT_EQUAL_INT(100, coreLoad(rows, 1));
+    TEST_ASSERT_EQUAL_INT(2, coreLoad(rows, 0));
+}
+
+// When its counter did keep up (it was switched out often), nothing is added.
+void test_the_running_task_keeps_its_own_count_when_it_is_higher() {
+    std::vector<TaskSample> before = {task(1, "loopTask", 0), task(2, "IDLE1", 0)};
+    std::vector<TaskSample> now = {task(1, "loopTask", 600000), task(2, "IDLE1", 400000)};
+    now[0].state = before[0].state = 0;
+    auto rows = taskRows(before, 0, now, 1000000);
+    TEST_ASSERT_EQUAL_UINT16(600, find(rows, "loopTask")->permille);
+}
+
+// The counters are 32-bit microseconds: they wrap every 71 minutes.
+void test_counters_wrap() {
+    std::vector<TaskSample> before = {task(1, "loopTask", 0xFFFFF000u)};
+    std::vector<TaskSample> now = {task(1, "loopTask", 0x0007A120u - 0x1000u)};  // 500 ms of run time later
+    auto rows = taskRows(before, 0xFFFF0000u, now, 0xFFFF0000u + 1000000u);
+    TEST_ASSERT_EQUAL_UINT16(500, rows[0].permille);
+}
+
+void test_tasks_come_and_go() {
+    std::vector<TaskSample> before = {task(1, "loopTask", 100), task(7, "gemini", 50000)};
+    std::vector<TaskSample> now = {task(1, "loopTask", 400100), task(9, "gemini", 30000)};  // a new gemini task: another id
+    auto rows = taskRows(before, 0, now, 1000000);
+    TEST_ASSERT_EQUAL_size_t(2, rows.size());
+    TEST_ASSERT_EQUAL_UINT16(400, find(rows, "loopTask")->permille);
+    TEST_ASSERT_EQUAL_UINT16(30, find(rows, "gemini")->permille);  // all its run time is inside the interval
+}
+
+void test_no_time_passed() {
+    std::vector<TaskSample> one = {task(1, "loopTask", 100)};
+    auto rows = taskRows(one, 500, one, 500);
+    TEST_ASSERT_EQUAL_UINT16(0, rows[0].permille);
+    TEST_ASSERT_EQUAL_INT(-1, coreLoad(rows, 1));  // no idle task in the sample
+}
+
+// Q122: under 512 bytes of stack left is flagged.
+void test_low_stack() {
+    std::vector<TaskSample> s = {task(1, "spk_task", 0, 264), task(2, "IDLE0", 0, 240, 0), task(3, "radio", 0, 2360),
+                                 task(4, "edge", 0, 512)};
+    auto rows = taskRows(s, 0, s, 1000);
+    TEST_ASSERT_TRUE(find(rows, "spk_task")->lowStack);
+    TEST_ASSERT_TRUE(find(rows, "IDLE0")->lowStack);
+    TEST_ASSERT_FALSE(find(rows, "radio")->lowStack);
+    TEST_ASSERT_FALSE(find(rows, "edge")->lowStack);
+}
+
+void test_sorting() {
+    std::vector<TaskSample> before = {task(1, "wifi", 0, 4000), task(2, "loopTask", 0, 2800), task(3, "IDLE0", 0, 240),
+                                      task(4, "irc", 0, 3600)};
+    std::vector<TaskSample> now = {task(1, "wifi", 190000, 4000), task(2, "loopTask", 810000, 2800), task(3, "IDLE0", 780000, 240),
+                                   task(4, "irc", 0, 3600)};
+    auto rows = taskRows(before, 0, now, 1000000);
+    sortTasks(rows, TaskSort::Share);  // busiest first, idle tasks last: they're what's left over
+    TEST_ASSERT_EQUAL_STRING("loopTask", rows[0].name.c_str());
+    TEST_ASSERT_EQUAL_STRING("wifi", rows[1].name.c_str());
+    TEST_ASSERT_EQUAL_STRING("irc", rows[2].name.c_str());
+    TEST_ASSERT_EQUAL_STRING("IDLE0", rows[3].name.c_str());
+    sortTasks(rows, TaskSort::Stack);  // least stack left first
+    TEST_ASSERT_EQUAL_STRING("IDLE0", rows[0].name.c_str());
+    TEST_ASSERT_EQUAL_STRING("loopTask", rows[1].name.c_str());
+    sortTasks(rows, TaskSort::Name);  // letters only, whatever the case
+    TEST_ASSERT_EQUAL_STRING("IDLE0", rows[0].name.c_str());
+    TEST_ASSERT_EQUAL_STRING("irc", rows[1].name.c_str());
+    TEST_ASSERT_EQUAL_STRING("loopTask", rows[2].name.c_str());
+    TEST_ASSERT_EQUAL_STRING("wifi", rows[3].name.c_str());
+}
+
+// Q120: two minutes of history, the oldest sample dropped first.
+void test_history() {
+    History<uint8_t, 4> h;
+    TEST_ASSERT_EQUAL_size_t(0, h.size());
+    for (uint8_t v : {10, 20, 30}) h.push(v);
+    TEST_ASSERT_EQUAL_size_t(3, h.size());
+    TEST_ASSERT_EQUAL_UINT8(10, h.at(0));
+    TEST_ASSERT_EQUAL_UINT8(30, h.at(2));
+    for (uint8_t v : {40, 50, 60}) h.push(v);
+    TEST_ASSERT_EQUAL_size_t(4, h.size());
+    TEST_ASSERT_EQUAL_UINT8(30, h.at(0));  // oldest kept
+    TEST_ASSERT_EQUAL_UINT8(60, h.at(3));  // newest
+    h.clear();
+    TEST_ASSERT_EQUAL_size_t(0, h.size());
+}
+
+int main() {
+    UNITY_BEGIN();
+    RUN_TEST(test_shares_over_the_interval);
+    RUN_TEST(test_the_running_task_gets_what_is_left_of_its_core);
+    RUN_TEST(test_the_running_task_keeps_its_own_count_when_it_is_higher);
+    RUN_TEST(test_counters_wrap);
+    RUN_TEST(test_tasks_come_and_go);
+    RUN_TEST(test_no_time_passed);
+    RUN_TEST(test_low_stack);
+    RUN_TEST(test_sorting);
+    RUN_TEST(test_history);
+    return UNITY_END();
+}

test/test_traffic/test_traffic.cpp

@@ -0,0 +1,54 @@
+#include <unity.h>
+
+#include "traffic.h"
+
+using namespace roro::net;
+
+void setUp() { resetTraffic(); }
+void tearDown() {}
+
+void test_counts_per_service() {
+    received(User::Irc, 100);
+    received(User::Irc, 20);
+    sent(User::Irc, 7);
+    sent(User::Gemini, 40);
+    TEST_ASSERT_EQUAL_UINT32(120, traffic(User::Irc).in);
+    TEST_ASSERT_EQUAL_UINT32(7, traffic(User::Irc).out);
+    TEST_ASSERT_EQUAL_UINT32(0, traffic(User::Gemini).in);
+    TEST_ASSERT_EQUAL_UINT32(40, traffic(User::Gemini).out);
+    TEST_ASSERT_EQUAL_UINT32(0, traffic(User::Updates).in);
+}
+
+void test_names() {
+    TEST_ASSERT_EQUAL_STRING("IRC", userName(User::Irc));
+    TEST_ASSERT_EQUAL_STRING("Gemini", userName(User::Gemini));
+    TEST_ASSERT_EQUAL_STRING("Debug Console", userName(User::DebugConsole));
+    TEST_ASSERT_EQUAL_STRING("Updates", userName(User::Updates));
+}
+
+// Bytes a second between two readings; the counter wraps at 4 GB like any uint32.
+void test_rate() {
+    TEST_ASSERT_EQUAL_UINT32(1000, bytesPerSecond(5000, 6000, 1000));
+    TEST_ASSERT_EQUAL_UINT32(500, bytesPerSecond(0, 1000, 2000));
+    TEST_ASSERT_EQUAL_UINT32(0, bytesPerSecond(7, 7, 1000));
+    TEST_ASSERT_EQUAL_UINT32(20, bytesPerSecond(0xFFFFFFF6u, 10, 1000));
+    TEST_ASSERT_EQUAL_UINT32(0, bytesPerSecond(1, 2, 0));
+}
+
+void test_sizes_for_humans() {
+    TEST_ASSERT_EQUAL_STRING("0 B", formatTraffic(0).c_str());
+    TEST_ASSERT_EQUAL_STRING("999 B", formatTraffic(999).c_str());
+    TEST_ASSERT_EQUAL_STRING("1.5 KB", formatTraffic(1536).c_str());
+    TEST_ASSERT_EQUAL_STRING("12 KB", formatTraffic(12 * 1024 + 100).c_str());
+    TEST_ASSERT_EQUAL_STRING("1.7 MB", formatTraffic(1774688).c_str());
+    TEST_ASSERT_EQUAL_STRING("48 MB", formatTraffic(48u * 1024 * 1024).c_str());
+}
+
+int main() {
+    UNITY_BEGIN();
+    RUN_TEST(test_counts_per_service);
+    RUN_TEST(test_names);
+    RUN_TEST(test_rate);
+    RUN_TEST(test_sizes_for_humans);
+    return UNITY_END();
+}