730 Commits

Include renames

Author	SHA1	Message	Date
Thomas GöttgensandGitHub	7509c1a6dd	Seeed Tracker X1 Support (#10834) ... * Seeed Tracker X1 Support * silence CPPCheck * fix macro order regression and adapt stm32hal for new radiolib * STM32 is a radiolib upstream fix ( https://github.com/jgromes/RadioLib/issues/1825 ) * fix STM32 regression * Seeed Tracker X1 Support * silence CPPCheck * fix macro order regression and adapt stm32hal for new radiolib * STM32 is a radiolib upstream fix ( https://github.com/jgromes/RadioLib/issues/1825 ) * fix STM32 regression * address copilot OCD * Split behavior only when the two LEDs are on distinct pins. * bring naming in line with the other seeed devices * update env name to fit convention too * guarantee evaluation order * Guard sensor readings against null values, make sensor use less power	2026-07-02 07:39:52 -05:00
TomandGitHub	3becaf2d95	emdashes begone (#10847)	2026-07-01 19:01:27 -05:00
4 people	e64d20548c	feat(eth): port mesh/http to RP2350 + W5500 (HTTP/80 + HTTPS/443) (#10573) ... * add watchdog to rp2xx0 * feat(eth-api): phase 0 skeleton — HTTP API server on TCP/80 (503 only) First step of porting mesh/http/ to RP2350 + W5500 (today ESP32-only). Phase 0 stands up the listener over the existing arduino-libraries/Ethernet stack (no Mongoose — its built-in TCP/IP would conflict with EthernetServer and break OTA/MQTT/NTP). Skeleton parses request line, logs it, replies 503. Real handlers (/api/v1/{info,fromradio,toradio}) come in later phases. - New mesh/eth/ethApiServer.{h,cpp} gated by HAS_ETHERNET_API - Wired into ethClient init+loop in parallel with existing ethHttpOTA (port 4244) - Enabled in both wiznet_5500_evb_pico2_e22p and pico2_w5500_e22 variants - Build impact on wiznet: +~9 KB flash (63.0% used), <1 KB RAM * feat(eth-api): phase 1 — implement /api/v1/{fromradio,toradio} with PhoneAPI Replace phase 0 skeleton with the real handlers that bridge the HTTP transport to PhoneAPI, mirroring mesh/http/ContentHandler (ESP32) semantics. - EthHttpAPI : public PhoneAPI (api_type=TYPE_HTTP, checkIsConnected=true), outside the MESHTASTIC_EXCLUDE_WEBSERVER gate so it builds on RP2350. - Minimal HTTP parser: method/path/query/Content-Length, no allocations beyond Arduino String, capped at 32 header lines x 256 bytes (anti-DoS). - OPTIONS preflight -> 204 with CORS + X-Protobuf-Schema. - GET /api/v1/fromradio[?all=true]: stream-write up to 64 protobufs from webAPI.getFromRadio(), Connection: close framing (HTTP/1.0 style). - PUT /api/v1/toradio: read Content-Length bytes (<=512), call webAPI.handleToRadio(), echo body back. - 404 default for unknown paths, 405 for wrong method, 400 for bad body. Validated e2e against wiznet @ 192.168.1.143: - OPTIONS /api/v1/fromradio -> 204 + correct CORS headers - PUT ToRadio{want_config_id=1} (2 bytes) -> 200 + echo - GET /api/v1/fromradio?all=true -> 200 + 3476 bytes (config+channels+nodeinfo) - GET /api/v1/nonexistent -> 404 unknown endpoint - OTA HTTP on port 4244 untouched and still responsive Build impact on wiznet_5500_evb_pico2_e22p: +2 KB flash (63.1%), +1.8 KB RAM (17.6%) vs phase 0. * fix(eth-api): move accept loop to dedicated OSThread (20ms tick) The API server was being polled from the Ethernet client Periodic which runs every 5s. Measured impact before this fix on wiznet @ 192.168.1.143: req 1: ttfb=6.458s total=6.509s (matches the 5s tick + handler overhead) req 2: connection refused (W5500 sockets exhausted) req 3: connection refused After: same hardware, same network, back-to-back requests: req 2: ttfb=0.287s req 3: ttfb=0.015s req 4: ttfb=0.022s req 5: ttfb=0.020s The web client (meshtastic/web served from localhost) was visibly stalling mid-handshake — it had pulled 109 nodes + 19 messages but channels and device info never arrived. With the periodic-only polling, every request takes 5s and the W5500's 4 hardware sockets fill up under the burst. EthApiServerThread mirrors the WebServerThread pattern from ESP32 mesh/http/WebServer.cpp: adaptive interval — 20ms when there's recent traffic, 100ms after 5s of idle, 500ms after 30s. Auto-registers with the OSThread scheduler on construction. ethHttpOTA still ticks from the periodic; left unchanged because OTA is one large transfer that tolerates the latency, and minimizing scope here to one behaviour change at a time. * refactor(eth-api): extract handlers to shared module via IStreamReadWrite Phase 2.0 of the TLS port — separate transport from request handling so the upcoming HTTPS server can reuse the exact same parser + routing logic. - New ethApiHandlers.{h,cpp}: Request, parser, CORS helpers, fromradio/toradio handlers, EthHttpAPI : PhoneAPI subclass. All driven by a single IStreamReadWrite interface that inherits Print (so client.print(...) keeps working transparently). - ethApiServer.cpp slimmed to ~90 LOC: now just the EthernetServer(80) + OSThread + an EthernetClientStream adapter that forwards reads/writes to the underlying EthernetClient. No behaviour change. Validated on wiznet @ 192.168.1.143: 5 curl requests TTFB 18-110ms (same as pre-refactor), protobuf round-trip PUT 200 + GET ?all=true 3499 bytes. Flash impact: +200 bytes (63.2%); RAM unchanged (17.6%). * feat(eth-tls): ECDSA P-256 self-signed cert generation for HTTPS API mbedTLS-based cert generation module that produces a SAN=IP self-signed ECDSA P-256 server certificate, persisted under LittleFS so subsequent boots reuse the same key. Generation runs once on a dedicated OSThread so the ECDSA keygen path (~430 ms) never blocks the Periodic stack or the Ethernet reconnect loop. - mbedTLS 3.6.2 sources compiled in via scripts/add_mbedtls_sources.py (BuildSources of pico-sdk/lib/mbedtls/library/*.c, all 108 files). MBEDTLS_USER_CONFIG_FILE injected as CPPDEFINES tuple in the script — build_flags shell escape mangles the embedded quotes on Windows. - src/mbedtls_user_config.h undefs MBEDTLS_HAVE_TIME, HAVE_TIME_DATE, TIMING_C, NET_C, FS_IO, PSA_ITS_FILE_C, PSA_CRYPTO_STORAGE_C, and defines MBEDTLS_NO_PLATFORM_ENTROPY (entropy_poll.c uses a raw platform check, not gated by a flag). - src/mesh/eth/ethCert.{h,cpp}: ECDSA P-256 keypair + cert with SAN(IP=current) using pico-sdk get_rand_64() directly as f_rng, bypassing mbedtls_entropy. DER buffers heap-allocated to keep the OSThread stack within budget. Cert + key + ip persisted under /prefs/eth_*.der so subsequent boots reuse the same identity. - Gated by HAS_ETHERNET_TLS_API. Standalone phase: generation only; HTTPS server (TCP/443) wired up in the follow-up commit. * feat(eth-tls-api): phase 2.2 — HTTPS server on TCP/443 reusing handlers Brings up an mbedTLS server on port 443 that defers to the ECDSA P-256 self-signed cert produced by [[ethCert]]. Reuses the HTTP request / response handlers from [[ethApiHandlers]] via the IStreamReadWrite interface — there is exactly one code path for routing / CORS / PhoneAPI integration regardless of whether the transport is plain TCP or TLS. EthTlsApiServerThread (OSThread): - Phase A: poll isEthCertReady() every 500 ms while the cert worker runs. Once true, parse cert chain + key, build ssl_config (TLS server, stream transport, default preset, VERIFY_NONE since we are the cert issuer), install own cert, run ssl_setup, bind tlsServer on 443. - Phase B: standard adaptive accept loop (20 / 100 / 500 ms tick), identical to the plain-HTTP server. Per-connection flow: 1. session_reset on the static ssl context (1 in-flight session — multi- session pool is Phase 3 if needed) 2. set_bio routes mbedtls I/O to two C callbacks (netSend / netRecv) that bridge to the live EthernetClient via the void* ctx 3. handshake loop (sync, blocking, with 10 s recv timeout) — mbedTLS errors are logged with mbedtls_strerror 4. wrap (ssl, client) in MbedTlsStream → handleApiClient(stream) 5. close_notify + client.stop Stack budget continues the Phase 2.1-bis discipline: every large buffer (ssl context, cert chain, pk_key, ssl_config) lives in BSS as a static global. The OSThread stack only holds the per-connection EthernetClient adapter and small mbedtls return codes. Validated on wiznet 192.168.1.143: - cert load-from-FS path: 13 ms (regen skipped on second boot) - cert gen path: 290 ms (first boot only) - ssl_setup chain: parse cert, parse key, ssl_config_defaults, conf_own_cert, ssl_setup all return 0 - end-to-end: curl -k https://192.168.1.143/api/v1/fromradio → 200 OK with application/x-protobuf, CORS, X-Protobuf-Schema headers, server initiates close_notify cleanly Footprint vs 2.0: - flash 70.5% → 87.3% (+220 KB for mbedtls_ssl + x509 server-side code) - RAM static 17.6% → 19.8% (+11 KB BSS for ssl_context + cert chain) - heap at runtime adds ~32 KB per active session (mbedtls in/out record buffers, default MBEDTLS_SSL_*_CONTENT_LEN=16384) Next: validate from Firefox direct (https://192.168.1.143 → warning accept → JSON visible), then from client.meshtastic.org hosted to confirm the mixed-content block is gone. * fix(eth-tls): add KeyUsage + EKU serverAuth and cap TLS 1.2 for browser compat Two browser-compat fixes that surfaced in Firefox validation: 1. Cert v1 only had Basic Constraints + SAN. NSS / Firefox refuse to treat a cert as a TLS server cert without an Extended Key Usage extension naming id-kp-serverAuth since 2023 — the error surfaces as a non-overridable 'Secure Connection Failed' with no 'Accept the Risk' path. Add KeyUsage(digitalSignature + keyEncipherment, critical) and ExtendedKeyUsage(serverAuth, critical). Bump cert/key/ip file paths to '_v2' so live boards regenerate on next start instead of loading a v1 cert that the browser silently refuses. 2. pico-sdk mbedtls defines MBEDTLS_SSL_PROTO_TLS1_3 in its default config, but the server-side 1.3 plumbing in this vendored build is incomplete: Firefox and openssl-3.5's s_client default to 1.3 and the handshake dies 4 ms in with MBEDTLS_ERR_ERROR_GENERIC_ERROR (-0x0001). curl/SChannel happened to default to 1.2 so it masked the issue earlier. Cap min/max_tls_version to TLS 1.2 — clients downgrade transparently and we keep the ECDHE-ECDSA + AES-GCM / CHACHA20-POLY1305 suites that already work end-to-end. Validated on wiznet 192.168.1.143: - cert v2 dumps with the 4 extensions visible (openssl x509 -text): BasicConstraints CA:FALSE, KeyUsage(critical) digitalSignature + keyEncipherment, ExtendedKeyUsage(critical) serverAuth, SAN IP. - openssl s_client (no version flag): downgrades to TLS 1.2, handshake completes, verify_return=18 (self-signed, expected). - Firefox: warning self-signed -> Advanced -> Accept Risk -> handshake OK in 632 ms with CHACHA20-POLY1305, request reaches handleApiClient and returns the protobuf body. * perf(eth-api): HTTP/1.1 keep-alive — one handshake per session, not per request Before this change /fromradio used 'Connection: close' framing (HTTP/1.0 style with no Content-Length), forcing each poll to redo the full TLS handshake. client.meshtastic.org needs ~80 sequential /fromradio polls during initial sync (one per packet from the config-replay state machine: MyInfo, channels, every Config_*, every ModuleConfig_*, every NodeInfo), so the user-visible load time was ~50 s of pure handshake overhead (80 requests * ~625 ms ECDSA P-256 each). Three coordinated changes: 1. handleApiClient() now loops on the same connection until the peer closes or parseRequest hits its 3 s idle timeout. requestsServed counter keeps the 'bad/timeout request' debug log from firing on the natural idle close after a keep-alive sequence. 2. handleFromRadio() buffers all packets into a std::vector before writing, so it can emit a real Content-Length and 'Connection: keep-alive'. Buffer is dynamic — common 1-packet response only allocates ~256 B; ?all=true keeps the 64-packet cap which tops out around 16 KB. handleToRadio + sendPreflight switched to keep-alive too (they already had real Content-Length). sendError keeps close — errors are terminal. 3. ethTlsApiServer netRecv RECV_TIMEOUT_MS dropped from 10 s to 3 s so mbedtls_ssl_read can't outlast the handler's idle deadline (a quiet browser leaving the socket open would otherwise wedge the OSThread for 10 s past the natural close). Measured on wiznet 192.168.1.143 against client.meshtastic.org: - one TLS handshake (641 ms, CHACHA20-POLY1305) - ~80 requests pipelined over the same session - full config + 40 NodeInfos in ~6-8 s (vs ~50 s before) - per-request latency post-handshake: ~10-25 ms - curl -kv with two URLs: 'Reusing existing https: connection', server returns 'Connection: keep-alive' explicitly. * fix(eth-tls): watchdog + Chrome compat — handshake stability across browsers Phase 3 keep-alive shipped a working Firefox flow but client.meshtastic.org loops + Chrome 'Test Connection' both rebooted the board. Four distinct issues; collectively they kept the OSThread inside serveClient() too long or spin-looping without yielding, and pico-sdk mbedtls' TLS 1.3 code path choked on Chrome's modern ClientHello. 1. Watchdog reset during keep-alive idle. Once a client drained the replay queue and entered 3 s poll mode, the OSThread sat inside netRecv()'s busy-wait waiting for the next request. Two consecutive 3 s waits plus prior handler time crossed the 8 s RP2350 hardware watchdog. Pet the watchdog inside netRecv()'s poll loop (every 2 ms) so a quiet client can never starve the watchdog. Same fix in the ethApiHandlers per-request yield path. 2. Cap session at 64 requests + yield() between. Defense-in-depth: a pathological client can't monopolize serveClient indefinitely; after the cap it just re-handshakes (~625 ms), still vastly cheaper than the per-request handshake we had before keep-alive. 3. TLS 1.3 code compiled out of mbedtls entirely (#undef MBEDTLS_SSL_PROTO_TLS1_3 in mbedtls_user_config). Capping max_tls_version=TLS1_2 at runtime is enough for Firefox / openssl (they downgrade cleanly), but Chrome's ClientHello carries TLS 1.3 extensions — post-quantum key shares, Encrypted ClientHello, etc. — that the vendored mbedtls 1.3 parser crashes on before the downgrade decision happens. Removing the 1.3 sources sidesteps the parser; ServerHello just announces TLS 1.2 and Chrome accepts. 4. netSend infinite WANT_WRITE spin. When W5500's TX buffer momentarily filled mid-handshake (Chrome draining slower than Firefox during ServerKeyExchange), EthernetClient::write() returned 0, our netSend returned MBEDTLS_ERR_SSL_WANT_WRITE without delay, mbedtls retried immediately, repeat at ~180k iter/sec until ... well, until the board's other threads got nothing done. Log signature: ret=-0x6880 tight-looping in the handshake iter trace. Rewrite netSend to block with delay(2) + watchdog_update() and a 3 s timeout — same shape as netRecv. Return MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY on disconnect (was incorrectly returning WANT_WRITE). Also added granular per-iter handshake logging gated on first 20 iters + every 50th after that, so any future regression localizes itself in COM9 without RTT JLink. Validated on wiznet 192.168.1.143: - Firefox: client.meshtastic.org full sync + idle poll stable (no reset during the previously-crashing 'replay drain complete' phase) - Chrome: 'Test Connection' accepts the cert prompt and connects - Edge: same as Chrome - openssl s_client default + tls1_2 forced: both negotiate TLS 1.2 with ECDHE-ECDSA + AES-GCM / CHACHA20-POLY1305, verify=18 (self- signed, expected) * chore(eth-tls): drop verbose debug logs from cert + TLS init paths The cert pipeline + TLS context init had step-by-step LOG_INFOs and ubiquitous Serial.flush() that were essential while diagnosing the Phase 2.1-bis stack overflow, the Chrome handshake crash, and the keep-alive watchdog reset. Once those bugs were fixed the logs just clutter COM9 on every boot. Kept on hand: - cert: 'loaded from FS', 'generating ...', 'generated N B in T ms', 'persisted to LittleFS', plus all LOG_ERROR / LOG_WARN paths - tls: 'server listening on TCP port 443', 'client connected from', 'handshake OK in N ms ciphersuite=', 'handshake failed -0xXXXX (...)', plus all init LOG_ERRORs Dropped: - cert: 'step 1/8 pk_setup' through 'step 8/8 copy key DER', 'thread woke', 'pipeline OK' (now silent on success) - tls: 'cert is ready, initializing', 'parsing cert chain', 'parsing key', 'ssl_config_defaults', 'conf_own_cert', 'ssl_setup', 'server worker scheduled', and the per-iter handshake trace - obsolete 'Optional mbedtls debug bridge' commented-out stub - all Serial.flush() that were added defensively for the debug-the-crash phase Bin shrinks ~40 KB (logs + format strings). Validated on wiznet 192.168.1.143: HTTP 200 round-trip works post-flash, no regression. * fix(eth): harden API/TLS build guards (review #10573) - ethApiHandlers.{h,cpp}: gate on (HAS_ETHERNET_API || HAS_ETHERNET_TLS_API) so the shared handleApiClient/IStreamReadWrite still compile for an HTTPS-only variant (the TLS server depends on them). - ethTlsApiServer.{cpp,h}, ethCert.{cpp,h}: require ARCH_RP2040 (they use Pico SDK get_rand_64()/watchdog_update()); the ethClient.cpp TLS include + call site are tightened to match, so enabling the flag on a non-RP2040 Ethernet target is a clean no-op instead of a cryptic build break. - clang-format (16) the touched eth files to satisfy Trunk Check. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(eth): address review — listener/cert recovery + keep-alive framing - Rebind HTTP/80 and HTTPS/443 after a W5500 chip reset. reconnectETH() now tears the API/TLS servers down (deInitEthApiServer/deInitEthTlsApiServer) so the restart path recreates them; the singleton guards previously left both bound to dead sockets until reboot. The workers are kept (only the listener is dropped) so nothing is deleted from another thread's runOnce. - Stop the keep-alive loop after a handler error. /fromradio and /toradio return whether the connection may stay open; a 400/405/408 response (Connection: close) now ends the loop so unread body bytes can't be parsed as the next request. - Validate the cached cert/key before trusting it (parse both DERs), and clear the IP commit-marker before rewriting the pair and write it last, so a reset mid-persist regenerates instead of handing the TLS server a truncated or mismatched pair (which would hard-disable HTTPS). - Track a cert generation counter so the TLS server reloads and rebinds when a DHCP lease change regenerates the cert for a new IP (the SAN must follow, or browsers reject the new address). The cert worker is no longer one-shot. - Silence the SCons F821/E402 lint on add_mbedtls_sources.py to match the other extra_scripts. Validated on a W5500 board: a forced chip reset rebinds 80 and 443 without an MCU reboot; a truncated cached cert regenerates and HTTPS recovers; a simulated lease change reissues the cert with the new IP in the SAN. * fix(eth): clear cert readiness on regen failure + verify cached pair Follow-up to the review: - Reset ready_/certIp_ when ensureCertForIp() fails, so isReady() no longer reports true with empty material — otherwise a later TLS reload fails initTlsContext() and stays disabled instead of retrying on the next poll. - certKeyParse() now also checks the cached cert and key form a matching pair (mbedtls_pk_check_pair), rejecting an independently-parseable but mismatched cert/key (e.g. if the IP commit-marker survived a failed clear). Validated on a W5500 board: a valid cached pair still loads from FS, and a regenerated cert reloads cleanly. --------- Co-authored-by: Ben Meadors <benmmeadors@gmail.com> Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-01 05:51:14 -05:00
Jonathan BennettandGitHub	fd8ba4fa4e	Chop down tft-related loooong ifdefs chains (#10803) ... * Chop down tft-related loooong ifdefs chains * Fix accidental sweep-up of portduino into screen #ifdef refactor	2026-06-29 21:23:25 -05:00
3 people	9cef69a9d3	feat(gps): Do not start gps if lora region is unset (#10386) ... * Disable gps thread on startup if lora region is unset There is little reason to waste battery on the gps if the data cannot yet be used. * fix goobered merge Refactor GPS enabling logic and remove duplicate code. * trunk --------- Co-authored-by: Jonathan Bennett <jbennett@incomsystems.biz>	2026-06-28 18:22:09 -05:00
3 people	0baf8b1db6	Portduino WASM hello world (still experimental) (#10793) ... * Add ARCH_PORTDUINO_WASM build: meshtasticd in WebAssembly over WebUSB Compile the full portduino firmware to WebAssembly (Emscripten) so a real node runs in a browser tab or headless Node, driving a LoRa radio over WebUSB through a CH341 — the desktop Ch341Hal path with its libusb backend swapped for a WebUSB one. The native/desktop portduino build is unchanged. New build env under src/platform/portduino/wasm/ (excluded from the native build_src_filter): WebUSB libpinedio backend, config/FS/region/MAC/PhoneAPI glue, wasm setup/loop, JS WebUSB runtime, and build stubs. bin/build-portduino-wasm.sh runs a standalone cached emcc build to build/wasm/meshnode.{mjs,wasm}. Six firmware sources gain #ifdef ARCH_PORTDUINO_WASM guards (single-threaded cooperative emscripten_sleep loop, continuous RX, US region default, std RNG, no-popen exec); none affect non-wasm builds. * PortDuino WASM: CI build job, cross-platform libdeps, configurable adapter bin/build-portduino-wasm.sh: auto-detect native-macos (macOS) vs native (Linux/CI) libdeps with a NATIVE_ENV override, and use the SAME env's Crypto with an XEdDSA-present guard. Drops the heltec-v3/Crypto borrow — the meshtastic/Crypto pin already ships XEdDSA; the native libdeps cache was just stale. No env pin change. Add .github/workflows/build_portduino_wasm.yml: build the ARCH_PORTDUINO_WASM target in CI (ubuntu + emsdk, native libdeps) so it can't silently bit-rot; asserts build/wasm/meshnode.{mjs,wasm}. src/platform/portduino/wasm: add wasm_set_lora_* setters so the JS host can configure any CH341 LoRa adapter (module, USB ids, DIO/TCXO, SPI speed, pins); wasm_config_apply falls back to the MeshToad defaults when unset. * WASM: build as a first-class [env:wasm] via platform-wasm (retire emcc script) Replace the standalone emcc build (bin/build-portduino-wasm.sh) with a normal PlatformIO env, `pio run -e wasm`, using the new meshtastic/platform-wasm platform (emcc/em++ + Asyncify, the WASM sibling of platform-native). The portduino WebAssembly node is now built the same way as every other target. - variants/native/portduino/platformio.ini: add [env:wasm] (platform pinned to platform-wasm, board wasm). Translates the script's source set into a curated build_src_filter, the ~30 EXCLUDE_* defines, and the lib set; defines ARCH_PORTDUINO_WASM in-repo so correctness doesn't hinge on the platform's board.json. - extra_scripts/wasm_link_flags.py: the firmware-specific emcc *link* settings (EXPORT_NAME, EXPORTED_RUNTIME_METHODS, EXPORTED_FUNCTIONS, ASYNCIFY_IMPORTS). PlatformIO feeds build_flags to compile only, so these must ride LINKFLAGS; without it the WebUSB Asyncify seam and the JS host's runtime methods are dropped (the _wasm_* exports survive only via EMSCRIPTEN_KEEPALIVE). - PortduinoGlue.{h,cpp}: guard the yaml-cpp dependency out of the WASM build (#ifndef ARCH_PORTDUINO_WASM around the include, emit_yaml/loadConfig/ readGPIOFromYaml). The browser node configures via the wasm_set_lora_* setters and dead-strips the YAML path; this drops the host yaml-cpp build dependency entirely. Native is unchanged (guards are inert there). - portduino_glue_wasm.cpp / portduino_main_wasm.cpp: repair EM_ASM JS that a formatter had mangled (!== -> != =, regex split) in the prior landing; the emcc link succeeds regardless, so CI now runs `node --check meshnode.mjs`. - .github/workflows/build_portduino_wasm.yml: build via `pio run -e wasm` (artifacts under .pio/build/wasm/), trigger on the shared inputs the env inherits (root platformio.ini, bin/platformio-*.py). - NodeDB.cpp: drop the dead ARCH_PORTDUINO_WASM region-default branch (region now defaults the same as native). - Crypto renovate pins: add the missing gitBranch so they track upstream. Output: .pio/build/wasm/meshnode.{mjs,wasm} (ES module, factory createMeshNode). Verified: pio run -e wasm (against the published platform archive), node --check, module instantiates in Node with all exports; native-macos + Docker native unit tests (450/450) still pass. * Fix name on the Piggystick * wasm: pin platform-wasm at the GPL-3.0-relicensed commit platform-wasm's LICENSE was always GPLv3 (matching this firmware), but its platform.json/README still declared Apache-2.0 (mis-copied from platform-native). That's fixed upstream in b83fa5b; bump the [env:wasm] pin to it. Build output is unchanged (license metadata only). Verified: pio run -e wasm against b83fa5b. * wasm: make reboot() actually restart the node (was a no-op) In wasm the reboot path is live (main.cpp -> Power::powerCommandsCheck -> Power::reboot), but Power::reboot's ARCH_PORTDUINO arm tore down SPI/Wire/Serial and then called the no-op ::reboot() stub — leaving the node running with a dead radio until the tab was manually reloaded. Triggers include an admin/phone reboot, factory reset, the "reconfigure failed" path, and the 60 s stuck-TX hardware watchdog (RadioLibInterface). - Power::reboot(): add an ARCH_PORTDUINO_WASM arm (before ARCH_PORTDUINO, since the wasm build defines both) that skips the host teardown and just calls ::reboot(). notifyReboot already let modules persist. - ::reboot() (glue): hand off to the JS host — browser reloads the tab (NodeDB state survives via IDBFS, same identity returns); headless calls Module.onReboot if provided, else logs. Loose !=/== so clang-format doesn't mangle the EM_ASM JS. - README: document the reboot handoff + the Module.onReboot hook. Verified: pio run -e wasm + node --check (EM_ASM intact); native-macos unaffected. * wasm: rename env to native-wasm and run it in the main CI matrix Rename [env:wasm] -> [env:native-wasm] for consistency with the portduino native family (native, native-macos, native-tft). The build dir follows to .pio/build/native-wasm/ (artifact is still meshnode.{mjs,wasm}); the PIOENV guard in extra_scripts/wasm_link_flags.py, the README, and the companion wrapper move with it. The board stays `wasm`. Also wire the build into normal CI: build_portduino_wasm.yml becomes a reusable workflow (workflow_call) invoked as the `build-wasm` job of main_matrix.yml, so the WebAssembly node is built like every other platform instead of on a separate path trigger. * native-wasm: auto-locate the Emscripten SDK (pre-build script) `pio run -e native-wasm` failed with "emcc not found" whenever it was invoked from a shell that hadn't sourced emsdk_env.sh — a VS Code task, an IDE build button, a bare terminal. Add a pre: extra script that probes the usual emsdk locations ($EMSDK_ENV, $EMSDK, ~/emsdk, ./.emsdk, the sibling companion checkout), sources emsdk_env.sh, and imports the resulting environment so the platform builder and emcc see PATH/EMSDK/EM_CONFIG. No-op when emcc is already reachable (CI), silent when no SDK is found (the platform emits its own error). * wasm: address PR review feedback - js/bridge.js: import CH341 from "./ch341.js" (sibling in this layout), not "../src/ch341.js" which doesn't resolve here. - js/ch341.js: a zero-length transferIn while MISO bytes are still outstanding now throws instead of breaking out with a partially-filled buffer — silent SPI corruption becomes a loud error, matching the comment above it. - libpinedio_webusb.c: webusb_set_auto_cs honors the AUTO_CS option (? 1 : 0) instead of the always-on ? 1 : 1. Runtime behavior is unchanged — Ch341Hal sets AUTO_CS=0 right after pinedio_init (RadioLib drives the active-low NSS); the option just isn't set yet at init, so this now correctly defaults off. - SX126xInterface.cpp: the RX-start error log now names the method actually called (startReceive vs startReceiveDutyCycleAuto) instead of hardcoding the duty-cycle name in the WASM branch. * native-wasm: drop the emsdk bootstrap shim (now in platform-wasm) The Emscripten SDK auto-location moved into the platform-wasm builder, so the firmware no longer needs its own pre: extra script. Remove extra_scripts/wasm_emsdk_env.py and bump the platform pin to the build that carries the bootstrap. The wasm_link_flags.py post script stays — those exported fns / runtime methods / Asyncify import seam are firmware-app-specific. * wasm: use the canonical companion name (meshtasticd-wasm-node) The companion repo was renamed meshtastic-web-node -> meshtasticd-wasm-node; fix the stale name in the wasm README and bump the platform pin to the build that promotes the canonical name in its emsdk auto-location. * wasm: re-entrancy guard for the API/region entry points + flaky-open retry Two robustness fixes for the browser node: - Re-entrancy guard. The node is single-threaded + Asyncify: while setup()/loop() is suspended inside a WebUSB transfer, the JS event loop is free, so a stray DOM/timer callback that re-enters a wasm_* entry point starts a second Asyncify unwind ("async operation already in flight" abort) or clobbers shared PhoneAPI state (observed as a "PhoneAPI::available unexpected state" flood). Add a g_wasm_in_firmware flag set around setup()/loop() (portduino_main_wasm.cpp); the wasm_set_region / wasm_api_to_radio / wasm_api_from_radio / wasm_api_available entry points now reject a mid-tick call (return busy) instead of corrupting or aborting. The host must still call them between ticks — this is the safety net the design lacked, not a substitute for the JS queue. - CH341 open retry (js/bridge.js). First-connect WebUSB is flaky — the interface is briefly unclaimable right after the grant, or held by a prior session, giving a transient "Could not open SPI: -1". Retry the open with a short backoff, closing the device between attempts so claimInterface starts clean. * wasm: exclude emscripten-only sources from cppcheck The `check` board matrix runs `pio check` (cppcheck) over all of src/, including src/platform/portduino/wasm/. cppcheck can't parse the EM_ASYNC_JS/ EM_JS macros (Syntax Error: AST broken at libpinedio_webusb.c:39, internalAstError) and these sources are not part of any checked board build ([env:native-wasm] is board_level=extra, compiled by the build-wasm CI job). Suppress the wasm dir in suppressions.txt, the same way generated/ and .pio/ are already excluded. * wasm: coalesce FS.syncfs so two never run at once IDBFS syncfs is async; the explicit wasm_fs_sync (5s timer + post-save + beforeunload) could overlap a prior in-flight sync, warning "2 FS.syncfs operations in flight at once". Serialize: if a sync is running, mark a pending re-sync and let the in-flight one chain it on completion — at most one in flight, trailing writes still flushed. (Companion drops IDBFS autoPersist so this is the single persistence path.) * wasm: silence false-positive SAST on the emscripten glue - extra_scripts/wasm_link_flags.py: restore the trunk-ignore-all(ruff/F821, flake8/F821) header every other SCons extra_script carries; Import/env are SConscript-injected globals, so ruff/flake8 flag them as undefined. - .semgrepignore: exclude src/platform/portduino/wasm/js/ (browser WebUSB glue, not part of the firmware binary). The unsafe-formatstring rule false-positives on its benign retry/diagnostic console logs. * Update .github/workflows/build_portduino_wasm.yml Co-authored-by: Austin <vidplace7@gmail.com> --------- Co-authored-by: Austin <vidplace7@gmail.com>	2026-06-28 06:50:35 -05:00
3 people	98fa4a67db	[feature] Free a little memory used by bluetooth if wifi is enabled or bluetooth is disabled (#10398) ... * esp32: release BTDM heap when Bluetooth inactive Release ESP-IDF BTDM memory after config load when Bluetooth is disabled or WiFi is enabled, recovering heap on ESP32 targets where BLE won’t be used for this boot. * Address BT memory release review comments --------- Co-authored-by: Ben Meadors <benmmeadors@gmail.com>	2026-06-25 17:05:27 -05:00
3 people	bbcc35e209	Stm32 general (#10700) ... * Attempt to generalize ARCH_STM32 * Trunk * One More ARCH_STM32 * Whoops, one snuck in there * Fix comment to reflect define change Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com> --------- Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>	2026-06-13 12:21:56 -05:00
4 people	07a87a8254	security: runtime-toggleable MESHTASTIC_LOCKDOWN hardening for nRF52 (#10349) ... * security: add MESHTASTIC_LOCKDOWN hardened build option Meshtastic nodes ship with secrets on flash (channel PSKs, the device private key, admin keys, wifi PSK) and over-the-wire access to admin APIs that can re-key the mesh. Lose the device, at a border crossing, in a raid, off a backpack, and an attacker reads everything in 30s with a USB cable. There's no at-rest encryption, no client auth, the screen leaks contents, and SWD is wide open. This adds an opt-in hardened build for users who care. -DMESHTASTIC_LOCKDOWN=1 on nRF52 (CC310) turns on: DEBUG_MUTE silence USB/serial logs MESHTASTIC_ENCRYPTED_STORAGE AES-128-CTR + HMAC-SHA256 on LocalConfig / channels / NodeDB. Passphrase-gated DEK, TTL/boot unlock token, failed-attempt backoff (within-boot, wall-clock, persisted bootsSinceFail). MESHTASTIC_PHONEAPI_ACCESS_CONTROL per-connection auth gate. Secrets emitted as empty proto structs to unauthenticated clients. MESHTASTIC_ENABLE_APPROTECT one-way UICR APPROTECT, reset applied same boot. Recoverable only via \`nrfjprog --recover\`, which also wipes the DEK. LockdownDisplay screen shows "LOCKED" when locked or idle 30s. OLED only; InkHUD / niche / device-ui not yet wired. Wire format is the LockdownAuth / LockdownStatus pair from meshtastic/protobufs#911 (AdminMessage tag 104, FromRadio tag 18). Access-control state is a file-scope 6-slot table in PhoneAPI.cpp keyed by \`this\`, not class members. Adding *any* per-instance field to PhoneAPI breaks USB-CDC enumeration on the current nRF52 Adafruit framework, one volatile bool was enough. Out-of-line side-steps it. lockdown_auth is handled synchronously in PhoneAPI::handleToRadioPacket rather than routed through the mesh Router into AdminModule. Two reasons: the passphrase never travels through a routed MeshPacket queue, and per-connection authorization runs while \`this\` is still on the call stack. The previous async-via-router design lost connection identity (g_currentContext was null by the time AdminModule processed the auth), so per-connection unlock never actually took effect on the originating client. Non-nRF52: #warning, only DEBUG_MUTE activates. tools/lockdown_provision.py drives provision / unlock / lock-now / watch over USB. Display privacy is a screen-lock latch separate from storage-lock state: shouldRedactDisplay() is true when storage is locked OR the latch is set. Screen::setOn(false) sets the latch when the stock idle timeout powers the display off (reusing config.display.screen_on_secs, no second timer); it is cleared only when a client authenticates with the passphrase. A device idling on the mesh keeps routing but hides its screen until re-auth; button input wakes the backlight to the LOCKED frame, not content. The earlier lockdown-specific 30s idle timer is removed — it duplicated PowerFSM idle detection and showed a misleading LOCKED screen on a merely-idle device. Unlock-token TTL fix: a token carrying both a boot-count and a wall-clock TTL is no longer destroyed when the RTC is invalid at cold boot. The boot count is independently verifiable without a clock, so the token falls back to boot-count enforcement instead of being deleted. A token is only hard-rejected when its wall-clock TTL can be evaluated and is found expired. NodeDB::reloadFromDisk() after unlock is deferred to the main loop via lockdownReloadPending rather than run inline on the transport callback stack — the reload is too heavy for the BLE/serial task stack and was resetting the device immediately after a successful unlock. The screen-lock latch also swallows local input events in InputBroker::handleInputEvent while it (or storage-locked) is set. Without that, a blind operator could drive on-device menus, fire canned messages, or change settings through the joystick/buttons even though the screen content was hidden. PowerFSM is still triggered first so the backlight wakes to the LOCKED frame; the event is dropped before reaching the UI observers. The screen-lock latch is initialised to true at boot, so even a token-auto-unlocked cold boot comes up redacted. Otherwise an attacker holding a screen-locked device could power-cycle it (the RAM latch resets) and recover a content screen. After any boot, the operator must authenticate from a client to reveal screen content. MyNodeInfo.device_id is also redacted for unauthenticated clients — it is a stable hardware identifier useful to an attacker for fingerprinting / correlating the device across observations. The public mesh fields (my_node_num, owner short/long name, public key, hw model) are left as-is because they are already broadcast on-mesh. ModuleConfig.mqtt is also redacted for unauthenticated clients — MQTTConfig carries broker username, password, server address, and root_topic. The empty MQTTConfig is emitted via the same zero-init pattern as the other gated sections. Uptime-based session limit (MESHTASTIC_LOCKDOWN_SESSION_DEFAULT_SECONDS) caps how long a single auto-unlocked session can hold storage open, measured in firmware millis() since unlock. 0 = unlimited (existing token-only behavior, suitable for tower/infra nodes); non-zero arms a timer on every passphrase unlock and on every token-auto-unlock that inherits the value, since the cap is persisted in the token (token format bumped to v2: adds sessionMaxSeconds, body 56→60 bytes). On expiry the device revokes per-connection auth, re-engages the screen-lock latch, and reboots WITHOUT deleting the token. Next boot auto-unlocks via the boot count (decrementing it) and arms a fresh session window. Hard exposure ceiling: bootsRemaining * sessionMaxSeconds. Explicit user Lock Now still deletes the token (passphrase required to recover); only session expiry preserves it. Why uptime, not wall-clock: getValidTime() is fed by GPS/RTC/client time pushes — all manipulable by an attacker with the device (GPS spoof to roll the clock back, pull the RTC backup cell, Faraday-cage the whole thing). millis() comes off the Cortex-M's internal cycle counter, sealed inside the chip; the only way to reset it is a reboot, which costs a boot from the on-flash token counter. APPROTECT remains the load-bearing defense against forging higher boot counts via SWD. A future LockdownAuth.max_session_seconds proto field will let the client set this per-token; until that lands the build-time MESHTASTIC_LOCKDOWN_SESSION_DEFAULT_SECONDS macro is the only source. Session expiry now decrements the on-flash boot count in place and re-arms the uptime timer WITHOUT rebooting, while budget remains. Mesh routing keeps running across session boundaries; the device only reboots when bootsRemaining reaches zero (rollback budget exhausted), at which point it hard-locks and forces passphrase re-entry. Each session boundary still: revokes per-connection admin auth so clients must re-authenticate to see content, re-engages the screen lock latch, and emits LockdownStatus{LOCKED, needs_auth, boots=N} so connected clients see the decremented count and know to re-auth. Storage stays unlocked (DEK in RAM) for continuity. The boot count's role as the rollback ledger is unchanged — it decrements monotonically once per session boundary, whether the session ends in a reboot or an in-place roll. Attacker who power- cycles to dodge the session timer still pays a boot via the existing readAndConsumeToken decrement-at-load path. APPROTECT remains the only defense against forging higher counts. Net effect for an unattended/tower node with bootsRemaining=50, sessionSeconds=3600: 50 hours of continuous mesh service, one reboot at the end, vs. the previous design's 50 reboots over the same period. Same exposure ceiling, far better uptime. LockdownAuth.max_session_seconds (proto tag 5) is now consumed: when non-zero the client value wins; 0 falls back to the firmware-side MESHTASTIC_LOCKDOWN_SESSION_DEFAULT_SECONDS, matching the boots_remaining sentinel convention. Protobufs submodule pin bumped to develop tip which contains meshtastic/protobufs#916 (merged). * security: drop dead is_managed allowlist for set_config(security).private_key The 'isLockdownSecurityCmd' allowlist in handleReceivedProtobuf dates from the pre-LockdownAuth design when the passphrase was smuggled through SecurityConfig.private_key. With lockdown_auth handled synchronously in PhoneAPI::handleToRadioPacket before any admin message reaches the Router, this allowlist now serves no legitimate purpose and lets an unauthenticated local client mutate security settings on a managed device by setting private_key.size>=1 — including potentially disabling is_managed itself. Remove the allowlist. Managed-mode local admin now requires a PhoneAPI connection that has already authenticated via lockdown_auth (or, on the pki_encrypted branch below, a valid PKC admin key). Resolves Copilot review feedback on src/modules/AdminModule.cpp:105. * security: protect lockdown-status drain slot from concurrent writers g_pendingLockdownStatus / g_hasPendingLockdownStatus are written from multiple call sites (PhoneAPI::handleLockdownAuthInline on the BLE/USB transport callback, AdminModule on the Router thread, main loop session expiry) and read in getFromRadio() on whichever transport is draining FromRadio. The struct read/write was unprotected, so a writer could corrupt the slot mid-encode. Same pattern as nodeInfoMutex — wrap both the queue path and the drain in a small lock. Drain re-checks the bool under the lock to handle the case where another reader grabbed the slot first. Resolves Copilot review feedback on src/mesh/PhoneAPI.cpp:1560. * security: derive readAndDecrypt size cap from caller buffer, not a hardcoded 64 KB The MAX_PROTO_FILE_SIZE = 65536 + OVERHEAD ceiling was an absolute constant chosen against a since-outdated assumption that 'meshtastic proto files are well under 64 KB'. On variants where MAX_NUM_NODES pushes the serialised NodeDatabase past 64 KB the legitimate file gets rejected at load and the device treats its own real config as corrupt. The caller already knows the maximum plaintext it expects (outBufSize). Cap the ciphertext at outBufSize + OVERHEAD instead — this is the tightest sound bound (anything larger could not possibly decode into the caller's buffer), still defends against OOM / integer overflow, and scales with the platform's actual NodeDB size rather than an arbitrary constant. Resolves Copilot review feedback on src/security/EncryptedStorage.cpp:1327. * docs: fix stale 'passphrase delivery via AdminModule' references in configuration.h The lockdown overview comment block was written when passphrase delivery ran through AdminModule's handleReceivedProtobuf. With the synchronous refactor that path now lives in PhoneAPI::handleLockdownAuthInline, called before the admin message reaches the Router. Update both the nRF52 feature list and the non-nRF52 degraded-mode rationale to point at the current code path. Resolves Copilot review feedback on src/configuration.h:578 (and :604). * docs: refresh unlock-token format doc to match v2 layout The header comment for the UTOK file still described v1 (version 0x01, no session_max_seconds, 71 bytes) even after the in-flight bump to TOKEN_VERSION=0x02 and TOKEN_TOTAL_SIZE=75. The inline body-size breakdown comment was also wrong (claimed 39 bytes and mismatched the real NONCE_SIZE/AES_KEY_SIZE constants). Rewrite both to match the actual on-flash layout and note how v1 tokens are handled on upgrade (rejected via the version byte; passphrase re-entry mints a v2). Resolves Copilot review feedback on src/security/EncryptedStorage.h:50. * docs: correct session-limit comment re: token-auto-unlock behavior The s_sessionMaxMs comment block claimed 'token-auto-unlocked sessions have no session timer (the session feature is a passphrase-unlock-only knob)'. Stale: readAndConsumeToken() now persists sessionMaxSeconds in the token file and re-calls setSession() from the token-load path, so token-auto-unlocked sessions DO inherit the same cap (and consumeSessionBoot() re-arms in place between sessions on a single boot). Update the comment to match. Resolves Copilot review feedback on src/security/EncryptedStorage.cpp:72. * docs: clarify input-swallow gate re: screen-lock latch vs storage state The previous comment said input is swallowed 'until a client authenticates and unlockScreen() clears the latch (or storage is unlocked)'. The parenthetical was misleading: storage being unlocked is not in itself enough to clear the latch — the latch persists across the storage-unlocked-but-screen-locked steady state, and only an explicit unlockScreen() (called from a successful passphrase auth path) clears it. Reword so the only-passphrase-clears-the-latch invariant is explicit and local input is named as something that does NOT clear it. Resolves Copilot review feedback on src/input/InputBroker.cpp:134. * docs: fix reloadFromDisk() trigger comment in NodeDB.h The header still claimed reloadFromDisk() is called by AdminModule after a successful passphrase op. With the synchronous PhoneAPI refactor the actual trigger is PhoneAPI::handleLockdownAuthInline setting lockdownReloadPending, with main.cpp's loop() dispatching the heavy reload on the main thread (the transport callback stack isn't large enough). Update the comment to point at the real path and explain why the deferral exists. Resolves Copilot review feedback on src/mesh/NodeDB.h:393. * style: clang-format lockdown sources Apply trunk clang-format (16.0.3) to satisfy the format check. * style: black-format lockdown_provision.py Satisfy the trunk black formatter check. * security: drop unused v1 EncryptedStorage formats and migration This storage layer has never shipped, so there are no v1 DEK files, v1 unlock tokens, or v1 backoff records anywhere to stay compatible with. Remove the dead compatibility machinery: - legacy init() (FICR-only KEK, no passphrase) — had no callers - deriveKEKv1() / loadDEKv1() and the v1->v2 DEK migration paths in provisionPassphrase() and unlockWithPassphrase() - the 5-byte v1 backoff file format Also drop the now-pointless version byte from the on-disk MENC, MDEK, and UTOK formats. Each is identified by its 4-byte magic (and, for the keyed formats, its HMAC); with only one version that will ever exist, the version field added nothing. Sizes shrink by one byte each (overhead 54->53, DEK 66->65, token 75->74). Rename the surviving helpers to drop the _v2 suffix (deriveKEK, loadDEK, saveDEK, KEK_DOMAIN). No behavioral change for provisioning, unlock, token consumption, or session handling. Verified with an nRF52 lockdown build (rak4631). * fix(lockdown): harden auth-table and lockdown_auth handler (audit) Audit findings addressed: C3 — `~PhoneAPI()` now clears its auth slot unconditionally. The previous slot-clear in `close()` was gated on `state != STATE_SEND_NOTHING`, so a PhoneAPI that never reached config (or that already closed) left `slot.who` pointing at freed memory; a future PhoneAPI heap-allocated at the same address would inherit the prior session's authorization through `findOrAllocSlot`. C4 — All access to `g_authSlots`, `g_authEpoch`, and `g_currentContext` is now serialised through `g_authSlotsMutex`. Previously these were touched without locking from BLE/USB/TCP/Router tasks, so two parallel slot scans could hand out the same slot and mid-update reads could observe authorized=true alongside a stale epoch. Granularity is fine — every critical section is a short linear scan over six entries, and getFromRadio (which calls `getAdminAuthorized()` per redaction check) tolerates the brief blocking. A4 / H1 — `lock_now` now requires the originating connection to be already authorized. Previously any unauthenticated client (BLE/USB/TCP) could submit `lockdown_auth { lock_now=true }` and force a reboot, which was a trivial local-presence DoS — an attacker near the radio could brick-loop it indefinitely. The original "panic button without auth" property is dropped; panic now requires the operator to have passphrase-unlocked the connection. H2 — Empty-passphrase `lockdown_auth` (with `lock_now=false`) used to silently return success. The client received no feedback distinguishing that case from a real success, and an attacker could probe lockdown state for free. Now emits UNLOCK_FAILED with no backoff increment (empty-passphrase is more likely a client bug than an attack, but the honest signal still lets the client correct itself). H14 — `la.boots_remaining > 255` previously truncated silently (256 → 0 → mapped to TOKEN_DEFAULT_BOOTS=50; 257 → 1). Honest clients could not detect the misbehavior. Now rejected explicitly with UNLOCK_FAILED. L1 — The `to == nodeDB->getNodeNum()` allowance in the unauth ToRadio gate now also requires `getNodeNum() != 0`. During the locked-default boot path `getNodeNum()` returns 0, so a packet with `to=0` could otherwise satisfy the equality and bypass the gate. L2 — Comment added on `g_authEpoch` wrap. Practically unreachable (2^32 lockNow events on one boot), but worth recording the behavior. M17 — `findOrAllocSlot_LH` now evicts the first unauthorized stale slot when the table is full of non-nullptr entries, rather than failing closed. Authorized slots are never evicted — they represent live operator sessions. Fail-closed (with LOG_WARN) only when every slot holds a different live authorized PhoneAPI, which would require seven simultaneous authed connections. M18 — `s_screenLocked` is now `std::atomic<bool>` with relaxed ordering. Plain bool happened to work on single-core Cortex-M4 today but breaks silently if lockdown ports to ESP32 / RP2040, or under LTO whole- program elision. Verified with an nRF52 lockdown build (rak4631). * fix(lockdown): gate every admin op on per-connection auth + storage unlock Audit findings addressed: H6 — Unauthenticated local clients could previously set_config / set_module_config / set_channel etc. on a lockdown device whenever is_managed was unset. The previous gate inside AdminModule's is_managed branch consulted PhoneAPI::isLocalAdminAuthorized(), which reads a global g_currentContext set during synchronous PhoneAPI dispatch — but AdminModule runs on the Router task, by which time the dispatch task has exited and the global is unrelated to the originating connection. The check was both broken (always false on Router, so even authed clients were rejected) and unsafe (when it did fire, the wrong connection could be authorized). The fix relocates the gate to PhoneAPI::handleToRadioPacket, where dispatch is synchronous and getAdminAuthorized() can be trusted. The admin payload is already decoded there to extract lockdown_auth; extend the same branch so that any non-lockdown_auth admin variant from an unauthorized connection is dropped before ever reaching the Router queue. H7 — Same root cause: get_config_request / get_module_config_request / get_channel_request handlers returned full security/network/mqtt content to unauthorized local clients. With the H6 gate in PhoneAPI, these requests never reach AdminModule, so handleGetConfig / handleGetModuleConfig / handleGetChannel are only callable from authorized connections. H9 — Remote admin (PKC-authorized peers, mesh-relayed admin) bypassed lockdown entirely. If admin_keys were baked in via USERPREFS or set on a prior unlocked boot, a remote attacker could drive factory_reset / set_config against a locked device before the operator ever unlocked it. Added an EncryptedStorage::isUnlocked() early-return at the top of AdminModule::handleReceivedProtobuf. The local lockdown_auth path is unaffected because PhoneAPI handles it synchronously before AdminModule runs. H10 — Removed g_currentContext, the ContextGuard, authorizeLocalAdmin(), and isLocalAdminAuthorized() entirely. The audit's race (Router-thread reads a pointer set by an unrelated parallel dispatch and authorizes the wrong PhoneAPI) and the always-false-on-Router behavior both disappear with the code that produced them. The PKC-admin auto-authorize path is gone — PKC admin and the per-connection lockdown auth are now independent: clients using PKC admin from a local app must also send lockdown_auth to unlock the redacted FromRadio stream. Cleaned up AdminModule's is_managed branch: under lockdown the PhoneAPI-layer gate has already done its job, so no additional check is needed; without lockdown the legacy is_managed-blocks-plain-admin semantics are preserved. Verified with an nRF52 lockdown build (rak4631). * fix(lockdown): hold radio silent until storage is unlocked Audit finding H8: while locked, the device beaconed nodeinfo and telemetry on the public LongFast default PSK and routed incoming default- channel packets through the locked router. The locked-default boot path in NodeDB::loadFromDisk installs config via installDefaultConfig, which honours USERPREFS_CONFIG_LORA_REGION (the common shape for managed deployments) and synthesises the default LongFast channel. So a locked device on managed firmware came up TX-enabled on a well-known PSK before any operator interaction. Force config.lora.region = UNSET in the locked-boot block. RadioLibInterface gates both TX (startSend) and RX (readData) on region != UNSET — locked devices no longer initialise the SX12xx for either direction. Also set tx_enabled = false for any code path that checks the flag directly without consulting region. reloadFromDisk() restores the persisted lora config once the operator unlocks. Note: until the audit's M8 (radio re-init after reload, the upcoming commit 5 in this remediation series) lands, an unlocked device may need to reboot before its radio fully comes up under the real config; this is no worse than the pre-fix state, where the radio was already running on the wrong (default) config and any real config change required an explicit reconfigure or reboot anyway. Verified with an nRF52 lockdown build (rak4631). * fix(lockdown): per-connection status queue, redaction expansion, log/banner mute (audit) M14 — Replaces the single file-scope LockdownStatus slot with a per- PhoneAPI table keyed by PhoneAPI*, parallel to the auth-slot table and sharing g_authSlotsMutex. Previously a status produced for connection A (UNLOCKED with the active TTL, or UNLOCK_FAILED with a backoff) could be drained by connection B before A read it, leaking A's auth state to B. queueLockdownStatus is now a per-instance method writing to this->slot. A new static broadcastLockdownStatus exists for the main-loop session-expiry callers that have no PhoneAPI* in hand — those want every connected client to learn about the session roll, which is the only legitimate broadcast use case. hasPendingLockdownStatus is a const helper for the FromRadio available()/drain check. M13 — buildStatus_LH (the single point where lock_reason crosses into the on-wire LockdownStatus) collapses any token_* reason to a generic "locked" before emission. The specific reasons (token_hmac_fail, token_wrong_size, token_bad_magic, token_boots_zero, token_expired, token_dek_fail, token_missing) still go to local logs, but no longer tell an unauthenticated client that the firmware noticed their tampering / rollback / corrupt-file attempt. M15 — Extended the STATE_SEND_MY_INFO redaction (previously device_id only) to also wipe pio_env and min_app_version for unauth clients — both are pure build-fingerprint vectors that tell an attacker which known issues to probe. Kept my_node_num (broadcast on the mesh anyway) and nodedb_count (clients need it post-unlock to decide whether to pull the node DB). Added equivalent redaction for STATE_SEND_METADATA: the whole DeviceMetadata struct is wiped for unauth clients (firmware_version, device_state_version, hw_model, hw_model_string, has_bluetooth/has_wifi/has_ethernet, role, position_flags, excluded_modules). Clients re-fetch after authenticating. M16 — LoRa config is now whitelisted for unauth clients to the set that is intrinsically observable on the air anyway: region, modem_preset, use_preset, channel_num, hop_limit. Operator-private knobs (ignore_incoming, override_duty_cycle, override_frequency, sx126x_rx_boosted_gain, tx_power, ignore_mqtt, fem_lna_mode, config_ok_to_mqtt) are zeroed. The whitelist is built as a fresh LoRaConfig stack copy rather than masked in place to avoid touching the persisted struct. M12 — Skip the DEBUG_MUTE "we are muted, FYI" banner under MESHTASTIC_LOCKDOWN. The banner spilled APP_VERSION / APP_ENV / APP_REPO over USB CDC even with all other logging suppressed, which defeats the muting in lockdown builds and gives a USB-attached attacker a free firmware-fingerprint primitive. L9 — Removed the numeric backoff value from the LOG_WARN unlock- failed message. The client receives backoff_seconds via the UNLOCK_FAILED status; printing it again to USB serial under non-DEBUG_MUTE builds (i.e. MESHTASTIC_LOCKDOWN_DEBUG dev builds) was the only place it appeared in logs. Verified with an nRF52 lockdown build (rak4631). * fix(lockdown): atomic post-unlock reload with corruption surface (audit) Closes M6, M7, M8, M9 from the lockdown security audit. M6 — handleLockdownAuthInline no longer flips the connection to authorized or emits UNLOCKED on the cold-unlock path (the first successful passphrase verify after a locked boot). The client keeps seeing LOCKED until reloadFromDisk has actually populated config / channelFile / nodeDatabase with the operator's real values. Without this, the window between the auth call and the main-loop reload exposed two race-friendly bugs: (a) the client could read the locked-default placeholders as if they were the real config, and (b) a set_config in the window would silently overwrite a corrupted baseline once the reload swapped values in. A new per-status-slot bool pendingUnlockAfterReload records that the connection is mid-unlock. The re-verify path (storage already unlocked) is unchanged and authorizes immediately — there is nothing to reload. M7 — reloadFromDisk now holds a new file-scope mutex (g_reloadFromDiskMutex) against itself, parks the radio in sleep mode before swapping config / channelFile, and reconfigures the radio with the now-real settings after. Other readers of config.lora / channelFile / nodeDatabase do not take this lock today; closing those races is a wider locking-discipline change outside the audit's M7 scope. The radio standby+reconfigure prevents the SX12xx from sitting in a half-old/half-new register set across the swap, which otherwise required a reboot to recover from. M8 — RadioInterface::reconfigure() is now called at the end of a successful reload, so the SX12xx register set actually reflects the unlocked operator settings (region, modem preset, channels) rather than staying on the locked-default placeholder. Routed through a new Router::getRadioIface() accessor — the radio interface is owned by Router as a unique_ptr and was not exposed. M9 — NodeDB::loadProto now sets a NodeDB::storageCorruptThisLoad flag whenever an encrypted file fails to decrypt or proto-decode. reloadFromDisk consumes the flag and returns false on any failure instead of silently falling back to defaults. main.cpp's reload service then calls EncryptedStorage::lockNow() and PhoneAPI::revokeAllAuth(), and the new PhoneAPI::completePendingUnlocks(false) emits LOCKED(storage_corrupt) to every pending connection — they stay unauthorized so any set_config they send is dropped at the existing unauth gates. The lock_reason string passes through buildStatus_LH's M13 redaction unchanged because it does not start with token_. The success path goes through PhoneAPI::completePendingUnlocks(true) which authorizes each pending connection, emits UNLOCKED with the current TTL, and clears the screen-lock latch once. Snapshots the target PhoneAPI* list outside the auth-table lock to avoid re-entry when setAdminAuthorized takes the same lock. Verified with an nRF52 lockdown build (rak4631). * fix(lockdown): UI/pairing fixes for first-pair + content-flash + e-ink (audit) Closes H13, M19, M20, L4 from the lockdown audit. (L3 dropped per explicit decision — battery level is not a meaningful security side channel.) H13 — BLE pairing PIN was suppressed by the lockdown lock screen on locked devices. Screen.cpp updateUiFrame's lockdown short-circuit intercepts before ui->update() runs, so the pairing-PIN overlay banner that NRF52Bluetooth::onPairingPasskey queued never painted. Net effect: a freshly-locked device on first BLE pair could not be unlocked over BLE because the operator could never see the PIN — chicken and egg. Adds a new notificationTypeEnum::pairing_pin value and special-cases it in the short-circuit: paint the LOCKED frame first (so the underlying background remains the redacted view, never dashboard content) then let ui->update() composite the PIN banner overlay on top. The PIN itself is an ephemeral pair-handshake artifact (regenerated per attempt, dies on banner timeout) and is not operator content, so this does not regress the redaction guarantee. NRF52Bluetooth::onPairingPasskey switches from showSimpleBanner to showOverlayBanner with notificationType = pairing_pin so the short-circuit's lookup matches. M19 — Brief content-visible window on Screen::handleSetOn(true) wake. OLED GDDRAM physically retains the last-rendered frame while the panel is powered off; the next ui->update() after displayOn() is async, so an observer (or shoulder-surfer) could see the previous frame's content for 16-50 ms on every wake. Under MESHTASTIC_LOCKDOWN we now paint the LOCKED frame into GDDRAM in handleSetOn(false) before calling displayOff(). On wake the only thing the panel can flash is the redacted view. Gated on lockdown only — non-lockdown builds keep the previous frame as a UX cue. M20 — E-ink panels physically retain the last-rendered image without power. A power-cycled lockdown handheld kept showing operator-identifying content (position, messages, nodeinfo) until the firmware's first natural refresh — which on e-ink can be seconds into boot. Now, under MESHTASTIC_LOCKDOWN && USE_EINK, the panel init path in Screen::setup() paints the LOCKED frame and forces a full refresh (forceDisplay) immediately after ui->init() and before any other rendering. Persistent pixels are wiped to the redacted view before an observer can see them. Build-tested on seeed_wio_tracker_L1_eink; hardware-verified visual confirmation is pending a T-Echo session. L4 — Screen::blink() bypasses the normal ui->update() path that the lockdown short-circuit gates. It draws arbitrary geometry, not node data, so it does not actually leak today; but any future change that puts content into blink would silently leak past redaction. Added an early-return on shouldRedactDisplay() to make the function honor the redaction contract. Verified with nRF52 lockdown builds on both rak4631 (OLED) and seeed_wio_tracker_L1_eink (e-ink). * fix(lockdown): refuse APPROTECT on vulnerable silicon, gate on provision (audit) Closes M22 and M23 from the lockdown audit. M22 — APPROTECT lockout on nRF52840 is publicly known to be bypassable on every silicon revision shipping in current Meshtastic hardware (AAB0..AAF0) via SWD glitching, per LimitedResults' published research on the nRF52 series. Engaging APPROTECT on these revisions has two bad properties: (1) the lockout is irreversible without a destructive nrfjprog --recover, and (2) it gives the operator a false sense of security because the lockout itself can be defeated by anyone with ten minutes and a glitcher. enableAPProtect() now reads FICR.INFO.VARIANT (encoded as a 4-byte ASCII word) and refuses to engage on any known-vulnerable revision, logging the variant so the operator knows their device's specific build code. To override (e.g. for end-to-end testing of the engage path on hardware that's known affected), rebuild with -DMESHTASTIC_APPROTECT_OVERRIDE_VULNERABLE_SILICON=1. The vulnerable list is explicit and easy to update: any future revision shown to be fixed can be removed from the list and APPROTECT will engage on it as before. M23 — APPROTECT engagement moved from very early in setup() to after fsInit() + EncryptedStorage::initLocked(), and gated on EncryptedStorage::isProvisioned(). A misconfigured CI build of a lockdown variant flashed to a dev board would otherwise burn SWD on first boot before the operator had set any passphrase, taking the board out of the development/recovery workflow with zero real security benefit (there is no DEK to protect on an unprovisioned device). Engagement now follows operator intent: SWD locks only once they've committed to lockdown via passphrase provisioning. The SWD-attachable window between boot and APPROTECT engagement widens slightly from this reorder (now ~hundreds of ms while fsInit runs) but APPROTECT remains effective on the only payload it could protect (the in-RAM DEK loaded by initLocked which now runs *after* APPROTECT for already-provisioned devices). Verified with an nRF52 lockdown build (rak4631). * tools: harden lockdown_provision.py (audit) Closes M26-M30 and addresses L7. M26 — passphrase input. --passphrase on argv now requires --insecure-passphrase-on-cmdline as an explicit acknowledgement; without it the tool refuses and points at --passphrase-file or the interactive prompt. --passphrase-file refuses to read anything that isn't mode 0600 (so a passphrase another user can read off the filesystem doesn't silently succeed). With neither, the tool reads the passphrase via getpass.getpass — and on 'provision' double-prompts with a confirm. M27 — provision now requires an explicit 'yes' confirmation unless --yes is passed, after printing the warning that the passphrase cannot be recovered. The double-passphrase prompt is built into gather_passphrase(confirm=True). Reduces the chance of a typo binding a device to an unrecoverable passphrase. M28 — 'lock' subcommand gains a 'lock-now' alias, matching how the audit and wire docs refer to it everywhere. Both forms now require 'yes' confirmation unless --yes is set, so an accidental command doesn't immediately reboot the device into a locked state. M29 — the 4-second sleep is gone. Replaced with a StatusFuture single-shot that the FromRadio interceptor signals when the next LockdownStatus arrives. provision/unlock/lock wait up to --wait seconds (default 8) for the actual reply and exit non-zero with the device's reason on UNLOCK_FAILED, surfacing backoff_seconds in the error line. Exit codes are now meaningful: 0 = UNLOCKED 1 = no status / unexpected 2 = NEEDS_PROVISION (or a precondition fault: missing pkg, bad args) 3 = LOCKED (ambiguous: device reported locked rather than the expected unlocked result) 4 = UNLOCK_FAILED This lets ops scripts decide what to do without parsing stdout. M30 — top-of-file docstring gained an explicit SECURITY MODEL block that names the threat model (USB-only, passphrase cleartext on the cable) and forbids extension to TCP/BLE/UDP without a redesign. A runtime banner reprints the headline on every invocation. --port values starting with tcp:/tcp://, ble:/ble://, udp:/udp://, ws:/wss: are rejected at argument parse before any connection attempt; a copy-paste of an example into a context with a different --port cannot silently leak credentials to the wire. L7 — private meshtastic APIs (_handleFromRadio, _sendToRadio, _generatePacketId) are still in use because the lib does not yet dispatch LockdownStatus on a public pubsub topic and there is no public seam for raw ToRadio. Their use is now wrapped in getattr-with-clear-error so a future lib version that removes them produces an actionable error instead of an obscure traceback. The top-of-file note explains why we're on the private surface. Verified end-to-end on hardware (R1-Neo + Seeed Wio Tracker L1) during the audit-remediation hardware test pass: - provision (interactive, with confirm and double-prompt) - unlock (success returns UNLOCKED + boots TTL) - watch (passive listener emits LockdownStatus events) - lock-now (with --yes) * fix(lockdown): H13 — render pairing PIN steady over LOCKED frame Two bugs in the H13 fix from commit 614b7f001: 1. NotificationRenderer::drawBannercallback's switch had no case for the new notificationTypeEnum::pairing_pin. The function fell through to no-op so the banner never rendered. Added pairing_pin alongside text_banner so it dispatches to drawAlertBannerOverlay (same rendering, distinct type so the lockdown short-circuit in Screen.cpp can recognise it). 2. updateUiFrame's lockdown short-circuit called ui->update() to composite the banner. That redraws the current carousel frame (the dashboard) into the host framebuffer BEFORE the overlay paints, so the panel flashed dashboard content under the banner on every cycle. Replaced with a direct call to drawBannercallback so only the banner box is painted on top of the LOCKED pixels. Also: drawLockdownLockScreen used to commit to the panel (display->display()) at its end. With the banner overlay then painting and committing a second time, the panel visibly flickered between 'just LOCKED' and 'LOCKED + banner' on every render cycle. Split into drawLockdownLockScreenIntoBuffer (no commit) for the lockdown short-circuit, and a thin drawLockdownLockScreen wrapper that calls Buffer + display() for the other call sites that don't composite anything on top. The short-circuit now commits exactly once per frame after both LOCKED + any overlay are in the buffer. Verified end-to-end on hardware (Seeed Wio Tracker L1, OLED): fresh BLE pair against a locked device now shows the pairing PIN steadily on top of the LOCKED frame, no flicker, no dashboard leak, and pair completes normally. * fix(lockdown): backoff MAC + atomic writes + fault wipe + size cap (audit) Closes H3, H4, H12, M10, M11, M25 from the lockdown audit. Non-format- breaking: existing devices keep their .dek and .unlock_token but their old plaintext .backoff file (6 bytes, no MAC) is silently rejected as tampered on first read and reseeded with the MAC'd 38-byte format on the next failed-attempt OR successful unlock. H3 — Pre-increment the failed-attempt counter BEFORE running the HMAC verify in unlockWithPassphrase. The previous order wrote the counter only after a failed verify, so an attacker glitching the chip between verify and write could skip the increment and bypass backoff. The slot is now reserved atomically up front; the success path writes attempts=0 to clear the reservation. Worst case for a legitimate user who power-cycles mid-success is one phantom attempt — backoff recovers next try. H4 — .backoff file is now MAC'd with HMAC-SHA256(ephemeralKEK, "backoff-auth" || body) (32-byte tag), and written atomically via SafeFile (tmp + readback verify + rename). readBackoff treats missing / wrong-size / MAC-fail uniformly as max-attempts (255) so an attacker who deletes or rewrites the file can only INCREASE the wait, never decrease it. clearBackoff() now writes an attempts=0 sentinel instead of removing the file, so 'missing == tamper' is unambiguous post-provision. bumpBootsSinceFailOnBoot() skips on un-provisioned devices to avoid false 'tamper' detection during the legitimate fresh window between fsInit and provisionPassphrase. H12 — saveDEK and writeUnlockToken now write via SafeFile in fullAtomic mode (tmp file + readback verify + atomic rename) instead of remove-then-open-then-write. Power loss during a DEK or token write previously left the device unable to unlock — the encrypted prefs files are unreadable without a valid DEK. The atomic path rolls back to the previous file on partial write. M10 — readAndConsumeToken's 74-byte stack buffer (entire wrapped DEK + HMAC, explicitly called out by the audit as never wiped before return) is now a meshtastic_security::ZeroizingBuffer that the destructor scrubs on every return path. Same treatment for the computedHmac stack array next to it, and for the new backoff state buffers in readBackoff / writeBackoff / computeBackoffHmac. Removes the manual secure_zero calls those buffers had on success paths and fixes the missing wipes on the failure-return paths. M11 — Added EncryptedStorage::secureWipeKeys() public API that zeros dek/kek/ephemeralKek in BSS without touching flash, no logging, no locks (safe from interrupt context). HardFault_Impl now calls it as the very first thing on entry, before the diagnostic print / coredump path runs, so a hard-fault crash dump won't capture the DEK / KEK material that the rest of the module leaves in RAM. M25 — migrateFile now refuses to allocate a buffer for any file larger than 64 KiB. The legitimate ceiling is well under that on every supported variant; anything larger is either corrupt or a DFU-injected OOM attempt. Verified with an nRF52 lockdown build (rak4631). * fix(lockdown): MENC header MAC + token rollback counter (audit) Closes M2 and M4 from the lockdown audit. **FORMAT-BREAKING** — devices provisioned with prior lockdown firmware must factory-erase /prefs and reprovision; the previous tokens and encrypted prefs files will not decrypt under the new HMAC/body layouts. M2 — The HMAC on MENC encrypted proto files now covers the full on-disk header (4-byte magic + 13-byte nonce + 4-byte plaintext_len + ciphertext) instead of just (nonce + ciphertext). Without this, magic and plaintext_len were integrity-protected only by the equality check `plaintextLen == ciphertextLen` — which holds today (no padding / compression / AAD) but would silently produce length-oracle and downgrade vulnerabilities the instant any of those got added. Putting the header inside the MAC closes that pre-condition cleanly. The verify side in readAndDecrypt and the compose side in encryptAndWrite update in lockstep. M4 — UTOK gains a 4-byte monotonic counter field inside its MAC'd body. The highest counter ever issued is persisted to a new /prefs/.tokmono file MAC'd with HMAC-SHA256(ephemeralKEK, "tokmono-auth" || counter). On every readAndConsumeToken, any token whose counter is less than the persisted value is rejected as a rollback attempt and deleted. Defeats the audit's threat: an attacker who once captured a token (e.g. bootsRemaining=255 from before the operator lowered the policy) tries to write it back to disk later. Counter is incremented monotonically across the device's lifetime so any captured snapshot loses to the persisted max-seen. Self-heal: a token whose counter exceeds the persisted value (e.g. the .tokmono write itself failed after the token committed, or the .tokmono got wiped via factory-erase) is accepted AND the counter file is promoted to match. This avoids spuriously rejecting valid tokens after partial-update recovery. Threat model caveat (consistent with C2 acceptance): an attacker who has both flash extraction AND FICR can recompute the .tokmono MAC and restore a matching pair (.unlock_token + .tokmono) from an earlier capture. M4 raises the bar to that combined capability; the flash-write-only attacker is now blocked. Verified with an nRF52 lockdown build (rak4631). MIGRATION: devices already provisioned with the prior lockdown firmware will fail to auto-unlock at boot (token format mismatch), fall back to LOCKED(needs_auth), and every passphrase attempt will fail because the encrypted /prefs files are HMAC'd against the old input. Recovery is: factory-erase via the bootloader UF2 then re-provision via lockdown_provision.py or the Android app. * feat(lockdown): make lockdown a runtime client-toggleable setting Converts MESHTASTIC_LOCKDOWN from a per-variant compile-time flag that forced lockdown ON into an internal capability that is ALWAYS compiled in for nRF52 and gated purely at runtime by whether a passphrase has been provisioned. A device that has never been provisioned (or that the operator disabled) behaves exactly like stock firmware. Build/config: - configuration.h auto-defines MESHTASTIC_LOCKDOWN (+ ACCESS_CONTROL, ENCRYPTED_STORAGE, APPROTECT-capable) for ARCH_NRF52 unconditionally. No variant sets -DMESHTASTIC_LOCKDOWN anymore. Flash-constrained variants can opt out with -DMESHTASTIC_EXCLUDE_LOCKDOWN=1. DEBUG_MUTE is no longer coupled to lockdown (a capable-but-off device must log normally). rak4631 lands at 96.2% flash with lockdown always-in. Runtime predicate: - EncryptedStorage::isLockdownActive() == isProvisioned() (.dek exists) is the single source of truth for active/inactive. - PhoneAPI::getAdminAuthorized() returns true when lockdown is inactive, so every existing redaction gate no-ops on a capable-but-off device with no per-site changes. The locked-boot defaults path (NodeDB), the AdminModule storage-locked gate, the screen-redaction predicate, and the plaintext->encrypted migrate block are all additionally gated on isLockdownActive() so an un-provisioned device loads/serves plaintext normally. - sendConfigComplete emits LockdownStatus{DISABLED} when capable-but-off so the client renders its toggle OFF. Enable (off->on): client provisions a passphrase. provisionPassphrase generates the DEK; the existing reload path encrypts the plaintext config in place (migration runs live with the DEK in RAM) and authorizes the connection -> UNLOCKED. No reboot. Disable (on->off): LockdownAuth{passphrase, disable=true}. PhoneAPI verifies the passphrase (loads DEK), sets lockdownDisablePending; the main loop runs NodeDB::disableLockdownToPlaintext() which decrypts every pref via EncryptedStorage::migrateFileToPlaintext() then removeLockdownArtifacts() deletes the DEK/token/counter/backoff (the .dek delete is the atomic commit), then reboots into normal mode. Power-loss safe and re-runnable without a persistent marker — and the crypto runs live with the operator's passphrase in RAM rather than via a boot-time marker an attacker could plant to trigger an unprompted decrypt. APPROTECT is NOT reversed (sticky; permanent on silicon where it engaged). Generated bindings (admin.pb.h / mesh.pb.h) regenerated against protobufs#927 (LockdownAuth.disable, LockdownStatus.State.DISABLED). Submodule pointer stays at the pinned develop commit; the bindings are ahead until #927 merges and the submodule is bumped, same flow as the max_session_seconds work. Builds clean: rak4631 with no flags now auto-includes lockdown. NOTE: this changes the LockdownStatus the firmware emits and adds the disable path; pairs with protobufs#927 and the upcoming Android client toggle work. * fix(lockdown): re-lock per-connection auth on BLE reconnect A provisioned device reused a single BLE PhoneAPI instance, and the per-connection auth slot (keyed by that instance) was only cleared on the !isConnected() disconnect transition. A fast disconnect/reconnect could begin a new config burst while state was still STATE_SEND_PACKETS, so the reconnected client inherited the prior session's authorization: it received SecurityConfig in the clear and no LockdownStatus, and never re-authenticated. Reset the auth slot in NRF52Bluetooth onConnect(), which fires once per physical link, so every new connection starts locked regardless of whether the previous link's close() raced the new handshake. handleStartConfig keeps its !isConnected() reset (do NOT reset on a same-connection want_config: the post-unlock re-fetch is the client pulling now-unredacted config and must keep the auth it just earned, otherwise config comes back redacted and set_config writes get dropped). * fix(lockdown): persist config on a lockdown-capable but disabled device saveProto always called encryptAndWrite when encrypted storage was compiled, and saveToDiskNoRetry skipped every save when !isUnlocked(). On a disabled (never provisioned) device there is no DEK and isUnlocked() is always false, so both paths fired and NO config ever persisted: a LoRa region set before enabling lockdown lived only in RAM, then provisioning migrated the UNSET default from disk and the region was lost. Gate both on isLockdownActive(): when lockdown is inactive the device writes plaintext exactly like stock firmware; the reloadFromDisk migrate pass then re-saves those plaintext files encrypted once the device is provisioned. Verified on hardware: region set while disabled now survives enable, reboot, and unlock. * fix(lockdown): suppress LoRa region picker under the lock screen A locked-boot lockdown device installs region=UNSET as a deliberate RAM placeholder (the real region is in encrypted storage, restored on unlock). Screen.cpp popped the region picker / onboard message whenever region==UNSET, so it rendered over the lock screen and trapped input with no way out. Skip it while the display is being redacted for lockdown. * fix(lockdown): silence cppcheck void* false positive + ruff docstring lints The nRF52 `check` (cppcheck --fail-on-defect=low) flagged arithOperationsOnVoidPointer on EncryptedStorage.cpp buffers. These are false positives: make_zeroizing_array() returns unique_ptr<uint8_t[], ...> so .get() is uint8_t*, not void* — cppcheck just can't resolve the custom-deleter alias. File-scoped suppression, matching the existing crypto-code convention in suppressions.txt. Trunk flagged 5 ruff docstring issues in lockdown_provision.py: D301 (backslashes need a raw docstring) and D405/D407/D411/D413 (the EXAMPLES heading was being parsed as a numpydoc section). Made the docstring raw and renamed the heading to USAGE to dodge section detection while keeping the ASCII-box formatting. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(lockdown): resolve cppcheck const/null-deref defects The nRF52 `check` job (pio check --fail-on-defect=low) flagged seven real cppcheck defects in the lockdown code: - EncryptedStorage.cpp: nonce/encDek are read-only views into the token buffer -> const uint8_t *. - NodeDB.cpp: segments[] lookup table is never mutated -> const. - PhoneAPI.cpp: clearStatusSlot_LH's p is only compared; the auth-check slot and the hasPendingLockdownStatus loop var are read-only -> const. - Screen.cpp: the MESHTASTIC_LOCKDOWN drawLockdownLockScreen() guard introduced a redundant null check (nullPointerRedundantCheck) since dispdev->displayOff() right below derefs it unguarded, as does the rest of the file. Dropped the guard. Verified with cppcheck 2.21 locally against the project suppressions. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(lockdown): const-qualify clearAuthSlot_LH param (cppcheck cascade) Making clearStatusSlot_LH take const PhoneAPI* let cppcheck propagate the same to clearAuthSlot_LH, whose p is only compared and forwarded. The remaining PhoneAPI* params (findOrAlloc*Slot_LH) store p into the slot table, so they correctly stay non-const. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(lockdown): wire runtime-toggle disable flow into provision tool Addresses Copilot review on tools/lockdown_provision.py — the reference tool advertised the runtime-toggle disable lifecycle but couldn't exercise it: - _STATE_NAMES: map LockdownStatus.DISABLED so a capable-but-off boot prints DISABLED instead of an opaque state=<num>. - build_lockdown_auth(): add a disable param that actually sets la.disable, failing loudly on pre-runtime-toggle bindings instead of silently sending a plain unlock. - cmd_disable() + 'disable' subcommand: send LockdownAuth{disable=true, passphrase=...} and wait for the resulting LockdownStatus. Mirrors the firmware: non-empty passphrase required, DISABLED broadcast precedes the reboot, TTL/session fields ignored. - _exit_code_for_status(): treat DISABLED as a success (exit 0) like UNLOCKED. All DISABLED/disable references are hasattr-guarded so the tool still imports and runs the lock/unlock/provision paths against the currently released meshtastic package (verified: it has LockdownAuth but not yet disable/DISABLED). Verified with ruff 0.15.13 and black. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Ben Meadors <benmmeadors@gmail.com> Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-11 15:39:49 -05:00
HarukiToredaandGitHub	5154e81d0b	Unify InkHUD message storage with BaseUI's MessageStore (#10596) ... * Unified Messagestore. * DM fix * Copilot fixes	2026-06-04 10:05:31 -05:00
4 people	60303968bb	Add Heltec mesh node t1 (#10416) ... * add heltec-mesh-node-t1 * fixed low power * Update the sensor enumeration values. Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com> * Fix memory leak in ICM42607PSensor * fix ST7735_MISO error --------- Co-authored-by: Ben Meadors <benmmeadors@gmail.com> Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>	2026-05-29 12:47:09 -05:00
Thomas GöttgensandGitHub	1747e2d8e5	T-Echo-Card support (#10267)	2026-05-19 09:31:04 +02:00
4 people	4a1ff18f57	feat: add Nordic nRF54L15-DK variant (Zephyr + BLE + LoRa) (#10193) ... * feat: add Nordic nRF54L15-DK variant (Zephyr + BLE + LoRa) Adds a community hardware variant for the Nordic nRF54L15-DK (PCA10156) with an external EBYTE E22-900M30S (SX1262) LoRa module. First Meshtastic port running on the Zephyr RTOS; all other Nordic targets use the nRF5 SoftDevice stack. Scope ----- - New Zephyr-based platform layer under src/platform/nrf54l15/ providing Arduino-compatible shims (Arduino.h, SPI, Wire, Print, Stream) over the Zephyr APIs plus a LittleFS-backed InternalFileSystem on SPIM20. - Bluetooth LE peripheral (NRF54L15Bluetooth.*) built on the Zephyr BT host stack, exposing the Meshtastic GATT service with legacy connectable advertising, just-works pairing, dynamic MTU exchange (up to 247 bytes), and iOS connection-parameter tweaks. - Variant directory variants/nrf54l15/nrf54l15dk/ with pin map for the E22 module on connector J1, PlatformIO env (nrf54l15dk), Zephyr DT overlay and a wiring README. - Zephyr project config (zephyr/prj.conf + board overlay) tuned for BT + LoRa: 16 KB main stack, 4 KB BT RX thread, RTT logging in immediate mode, newlib-nano heap sized to leave room for the GATT pools while still allowing ATT MTU=247. - extra_scripts/nrf54l15_linker.py works around a PlatformIO + old Ninja issue where Zephyr's two-pass linker script generation does not run automatically; the post-script parses build.ninja and invokes the gcc -E step directly before the final link. - boards/nrf54l15dk.json board definition (PlatformIO needs it for the DK; the Seeed platform only ships the XIAO variants). - variants/rp2350/rp2350.ini excludes platform/nrf54l15/ from RP2350 build_src_filter so the shared platform tree does not leak between targets. - .gitignore: add nRF J-Link / RTT debug artifacts (flash.jlink, rtt_*.txt). Shared source changes --------------------- - src/main.{cpp,h}, src/RedirectablePrint.cpp, src/FSCommon.{cpp,h}, src/mesh/{Channels,NodeDB,RadioLibInterface,MeshService,PhoneAPI}.cpp, src/mesh/RadioLibInterface.h, src/modules/AdminModule.cpp: add small guards / helpers so the Zephyr build compiles alongside the Arduino targets. Behavior on existing boards is unchanged. Hardware model -------------- HW_VENDOR maps to meshtastic_HardwareModel_PRIVATE_HW until a dedicated protobuf enum value is assigned upstream. The variant declares custom_meshtastic_hw_model = 132 so the maintainers can wire the new enum value through the protobufs repo after merge. Hardware note ------------- The E22-900M30S does not connect its DIO2 pin to TXEN internally — a wire/solder bridge between DIO2 and TXEN on the module is required for TX to work. Details and full pin map are in the variant README. Validation ---------- Built clean against develop. On real hardware (April 2026) the port passes end-to-end: iOS companion app pairs and connects, configuration round-trip works, LoRa TX/RX reaches a canonical tbeam on the same mesh channel, NodeDB updates propagate both ways, and traceroute completes. * fix(nrf54l15): use atomic fs_rename instead of copy fallback Zephyr LittleFS on nrf54l15 supports fs_rename natively, so route it through the same atomic path as ESP32. The previous copyFile+remove fallback truncated the destination before copying, leaving 0-byte files if interrupted mid-write. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(nrf54l15): expand storage_partition from 36KB to 700KB LittleFS on the default 9-block (36KB) storage_partition ran out of space during copy-on-write of config.proto, causing fs_write to return ENOSPC and pb_encode to surface "io error" when saving configuration via the mobile app. Reclaim slot1_partition (the MCUboot secondary slot — unused since we flash directly via J-Link) and grow storage_partition to span 0xb6000..0x165000 (~175 blocks). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(nrf54l15): drop USERPREFS_LORACONFIG_* so LoRa config stays mutable NodeDB rewrites LoRa config from USERPREFS_LORACONFIG_* on every boot, which prevented reconfiguration via the BLE/serial app. Drop the variant-level defaults; users configure region and modem preset through the app like every other variant. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(nrf54l15): enforce MITM passkey pairing on GATT service - Add MESH_PERM_READ/MESH_PERM_WRITE macros (READ_AUTHEN/WRITE_AUTHEN) on all mesh service characteristics so clients must complete passkey exchange before accessing fromNum/fromRadio/toRadio/logRadio. - Wire FIXED_PIN mode to bt_passkey_set() so the device advertises a known PIN (config.bluetooth.fixed_pin); RANDOM_PIN keeps default per-pairing random passkey. - Reduce BleDeferredThread HARD_WATCHDOG_MS from 3min to 1min. - prj.conf: CONFIG_BT_SMP_ENFORCE_MITM=y, CONFIG_BT_FIXED_PASSKEY=y, CONFIG_BT_SMP_SC_PAIR_ONLY=n (legacy fallback for clients that abort SC pairing with reason 0x01 within 150ms). * fix(nrf54l15): resolve develop-merge conflict + cppcheck warnings The `Merge branch 'develop'` left two ~RadioLibInterface() declarations in src/mesh/RadioLibInterface.h: the inline version added upstream by PR #10254 (which independently applied the same UAF guard this PR was carrying) and the out-of-line version this PR introduced. GCC rejects the duplicate, breaking every platform build. Drop the out-of-line declaration + definition; keep upstream's inline form. Also silence the 13 cppcheck low warnings introduced by the new nrf54l15 Arduino shim — Arduino's `String`/`SPISettings` API contract relies on implicit single-arg constructors used pervasively by existing Meshtastic code, so suppress `noExplicitConstructor` inline with a comment instead of breaking the API. The few mechanical wins (`const tmp[2]`, `const uint32_t *sp`) are applied directly. * fmt: fix Trunk Check lint issues on nrf54l15-port - extra_scripts/nrf54l15_linker.py: move regular imports above Import("env") to silence E402, add trunk-ignore-all(F821) for the PIO/SCons SConstruct injection (matches esp32_pre.py / nrf52_extra.py convention) - src/platform/nrf54l15/NRF54L15Bluetooth.cpp: clang-format 16.0.3 - boards/nrf54l15dk.json + variants/nrf54l15/nrf54l15dk/README.md: prettier 3.8.3 (also resolves markdownlint MD060 on README tables) No behavior change. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(nrf54l15): address Copilot review comments + correct clang-format style Six review threads from the 2026-04-30 Copilot review: - src/platform/nrf54l15/nrf54l15_main.cpp: validate PSP against the nRF54L15 SRAM range (0x20000000..0x20040000) and 4-byte alignment before walking the faulting thread's stack, and clamp the walk so it never reads past the end of RAM. Prevents a second fault inside the fatal handler when PSP is corrupted (common in real faults). - src/platform/nrf54l15/nrf54l15_arduino.cpp: gate the bring-up printk traces in digitalWrite/digitalRead (CS/NRESET toggle log, BUSY-before-NRESET snapshot, BUSY periodic timeline) behind a new -DNRF54L15_GPIO_DEBUG flag that is off by default. The "dev NOT READY" message stays unconditional — it indicates a genuine hardware/DTS misconfig. - src/modules/AdminModule.cpp: don't mutate config.device.output_gpio_enabled from handleGetConfig(). Reflect the live pin state in the response payload only — a getter must not write back to disk-persisted state. - src/platform/nrf54l15/InternalFileSystem.h: derive totalBytes() from FIXED_PARTITION_SIZE(storage_partition) at compile time so it tracks the DK overlay's ~700 KB partition instead of the stale 36 KB hard-coded value. Updated the file header comment accordingly. - extra_scripts/nrf54l15_linker.py: make _extract_gcc_command() handle the POSIX Ninja COMMAND format (no `cmd.exe /C "..."` wrapper) in addition to the Windows form, so the script doesn't hard-fail on Linux/macOS hosts. - src/platform/nrf54l15/NRF54L15Bluetooth.cpp: clamp NO_PIN to RANDOM_PIN with a one-shot LOG_WARN. The mesh GATT permissions are declared with BT_GATT_PERM_*_AUTHEN and prj.conf sets CONFIG_BT_SMP_ENFORCE_MITM=y, so NO_PIN with no auth callbacks would leave every characteristic returning BT_ATT_ERR_AUTHENTICATION. Falling back to RANDOM_PIN keeps the link usable instead of silently broken. Also re-formatted this file with the project's .trunk/configs/.clang-format (Linux braces, 4-space indent, 130-col) — the previous lint-fix commit a2aca3234 accidentally used the default LLVM style here, which CI's clang-format would have rejected. Build verified: pio run -e nrf54l15dk passes, RAM 47.4%, Flash 28.6%. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(nrf54l15): address remaining Copilot review threads Round 2/3 review fixes — bugs first, then docs/portability: BLE concurrency (NRF54L15Bluetooth.cpp): - onNowHasData / sendLog / BleDeferredThread / shutdown: acquire active_conn under ble_mutex via new acquire_active_conn() helper so disconnected_cb can't free the conn between the null check and bt_conn_ref/bt_gatt_notify (use-after-unref). - write_toradio: reject writes that exceed MAX_TO_FROM_RADIO_SIZE with ATT_ERR_INVALID_ATTRIBUTE_LEN instead of returning success and silently dropping the payload (would hide failed config writes from the phone). - start_advertising: truncate the device name to fit the 31-byte legacy scan-response limit and switch to BT_DATA_NAME_SHORTENED so bt_le_adv_start() doesn't reject the payload when the name approaches CONFIG_BT_DEVICE_NAME_MAX=32. Linker / portability: - main.h: drop the rp2040Loop() forward declaration that had no definition and no callers — would surface as a link error if any RP2040 build added a call to the symbol. - nrf54l15_arduino.cpp: transfer16() now uses static __aligned(4) DMA buffers (matching transfer()), removing the EasyDMA-reachability hazard of caller-stack buffers on this part. Filesystem (InternalFileSystem.h): - usedBytes(): return real usage from fs_statvfs() instead of 0 so OTA / range-test free-space guards work. - rewindDirectory(): close the dir before reopening — Zephyr fs_dir_t has no rewind, and re-fs_opendir on an open handle leaks LittleFS state. Crash handler (nrf54l15_main.cpp): - After the stack walk, busy-wait 50 ms to flush RTT/printk and call sys_reboot(SYS_REBOOT_COLD) directly so the saved_crash record is actually reported on the next boot. Default Zephyr config has RESET_ON_FATAL_ERROR=n, so the previous k_fatal_halt() spun forever. Generalization / config: - PhoneAPI.cpp: replace the NRF54L15_DK ifdef with a MESHTASTIC_EXCLUDE_FILES_MANIFEST capability flag (defined in the nrf54l15dk env) so future variants can opt in/out without touching shared code. - variants/nrf54l15/nrf54l15.ini: parameterize libdeps include paths via ${PIOENV} so additional nRF54L15 envs sharing nrf54l15_base don't break. - prj.conf: drop the stale "36 KB storage_partition" comments — the DK overlay reclaims slot1 to ~700 KB and runtime size comes from FIXED_PARTITION_SIZE. - nrf54l15dk overlay: remove the zephyr,console / zephyr,shell-uart chosen entries that conflicted with CONFIG_UART_CONSOLE=n + RTT console; keep uart30 enabled so swapping the console is one Kconfig flip away. Build: nrf54l15dk SUCCESS (flash 28.6%, RAM 47.4%); wiznet_5500_evb_pico2 SUCCESS (verifies the shared main.h change). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(nrf54l15dk): use PRIVATE_HW (255) for custom_meshtastic_hw_model Per @thebentern's review: the nRF54L15-DK is a development kit, not a canonical Meshtastic SKU, so it falls under HardwareModel::PRIVATE_HW (255) — the same enum value already used at runtime via HW_VENDOR. The placeholder 132 is removed; no dedicated enum number will be assigned for DK boards. Slug stays NRF54L15_DK as a human-readable identifier. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(nrf54l15): unstarve bt_long_wq so SC pairing completes bt_pub_key_gen() runs the ECC P256 key generation on bt_long_wq. At default prio=10 (preemptible) and stack=1400 it gets starved by Meshtastic app threads at boot — sc_public_key stays NULL for minutes, smp_public_key() defers with SMP_FLAG_PKEY_SEND, and every SC pairing attempt stalls right after the public-key exchange. iOS shows "Connecting…" forever with no PIN prompt; bleak/CLI fails the first CCC notify write with "Protocol Error 0x05: Insufficient Authentication". Set CONFIG_BT_LONG_WQ_PRIO=0 (highest preemptible, ties with main) and CONFIG_BT_LONG_WQ_STACK_SIZE=4096 (margin for the P256M driver frames). Validated E2E with iOS Meshtastic app: bt_smp_pkey_ready fires within ~40 s of boot, 20 SC Passkey Entry rounds complete with matching pcnf/cfm, encrypt 0x01 / sec_level 0x04 (Authenticated MITM), bonded=1. * feat(nrf54l15): hardware I2C bus via TWIM30 + sensor telemetry Adds the Arduino TwoWire layer for the nRF54L15-DK so Meshtastic's sensor drivers can talk to external I2C devices over the hardware TWIM30 peripheral. Bus binding: - &uart30 disabled in the board overlay (peripheral instance 30 is shared between UARTE30 / TWIM30 / SPIM30 — pick one). Console stays on RTT via CONFIG_RTT_CONSOLE. - New i2c30_default / i2c30_sleep pinctrl with SDA=P0.03 / SCL=P0.04. External 4.7 kOhm pull-ups required on both lines. - &i2c30 enabled at I2C_BITRATE_FAST (400 kHz). - button_3 (SW3, P0.04) deleted from DTS so the pad can be claimed by i2c30 pinctrl; SW3 is still wired to the pad on the DK, do not press it during I2C use or it will short SCL to GND. Arduino layer: - src/platform/nrf54l15/Wire.cpp resolves the DT node at compile time via DEVICE_DT_GET(DT_NODELABEL(i2c30)) and dispatches Arduino's beginTransmission / write / endTransmission / requestFrom to i2c_write / i2c_write_read / i2c_read. Buffer is sized to 256 bytes for forward compatibility with the SE050 secure element on the custom PCB. - Wire.h drops the prior compile-only stubs and exposes the real TwoWire surface. - Arduino.h: BitOrder becomes an enum (not #define) so Adafruit_BusIO's `typedef BitOrder BusIOBitOrder;` compiles. Variant + build flags: - nrf54l15.ini flips HAS_WIRE / HAS_SENSOR / HAS_TELEMETRY from 0 to 1 and cherry-picks the sensor libs Meshtastic needs (BusIO, Sensor, BMP280, BME280, INA219/226/260/3221, SHT4X). The full environmental_base group is avoided because it pulls Adafruit_SSD1306 / Adafruit_GFX which rely on Arduino pin macros the Zephyr shim does not implement. - nrf54l15dk variant.h defines PIN_WIRE_SDA / PIN_WIRE_SCL for parity with the Arduino convention used by other variants. The actual bus wiring is fixed by the overlay pinctrl above. Validated 2026-05-14/15 on the DK with BMP280 @ 0x76 (temperature + barometric pressure) and INA3221 @ 0x42 (rail voltage / current); EnvironmentTelemetry / PowerTelemetry packets transmit successfully over LoRa. Footprint cost on nrf54l15dk: +45 KB flash, +1.7 KB RAM. * feat(nodedb): honor USERPREFS for environment telemetry on first boot installDefaultConfig() now respects two new compile-time prefs: USERPREFS_CONFIG_ENV_TELEM_UPDATE_INTERVAL USERPREFS_CONFIG_ENVIRONMENT_MEASUREMENT_ENABLED The mobile apps enforce a 30 min floor on environment_update_interval in the settings UI, which makes short-interval bring-up testing of new sensor hardware painful — you have to wait half an hour for the first LoRa packet to confirm wiring + driver. With these prefs baked into the variant, the firmware can ship a freshly-flashed device that broadcasts on a shorter cadence (e.g. 900 s) the moment storage_partition is empty. Both prefs are gated on #ifdef so the behavior is unchanged for any variant that does not opt in. Documented in userPrefs.jsonc with the existing telemetry-interval pref block. * fix(nrf54l15): allow multiple bonded BLE peers CONFIG_BT_MAX_PAIRED defaults to 1, so once the first peer (e.g. an iOS phone) has paired and bonded, every subsequent pairing attempt from a different MAC fails inside bt_keys_get_addr() with no free key slot — the host returns BT_SECURITY_ERR_KEY_DOES_NOT_EXIST and the second peer never gets past SMP. Raise the slot count to 4 so the device can simultaneously hold an iOS phone, a Windows host, a Linux host, and one spare bond. Add BT_KEYS_OVERWRITE_OLDEST so that once the table fills, the LRU peer is evicted on the next pairing rather than rejecting the new peer. This matches the behavior other Meshtastic ports already provide (nRF52 uses CONFIG_BT_PERIPHERAL_PRIO_CONN with similar semantics). Discovered while bringing up the Python CLI on Windows alongside the existing iOS bond. * fix(nrf54l15): zero-initialize TwoWire buffers + clang-format Wire cppcheck on every CI target (esp32s3, rp2040, rp2350, nrf52840, ...) was failing the build with two `uninitMemberVar` warnings on TwoWire's constructor: `txBuf` and `rxBuf` (256-byte arrays) were not initialized. Even though the buffers are only read after txLen/rxLen is set, leaving them uninitialized is a footgun if any future caller bypasses the len-set step. Use C++11 value-initialization in the member initializer list — costs ~512 B of memset at boot, gains a clean cppcheck pass and defensive-against-future-changes semantics. Also reformat Wire.{cpp,h} with the project's `.trunk/configs/.clang-format` config so the Trunk Check Runner passes — clang-format moved the `<errno.h>` include before the Zephyr-namespaced ones in Wire.cpp and collapsed two inline overloads to single lines in Wire.h. * fix(AdminModule): remove dead OUTPUT_GPIO_PIN/GpioOutputModule references OUTPUT_GPIO_PIN is never defined and modules/GpioOutputModule.h doesn't exist in the codebase; all #ifdef OUTPUT_GPIO_PIN branches were dead code introduced by the nRF54L15-DK variant commit. Strips the include, the output_gpio_enabled OFF→ON/ON→OFF transition logic in handleSetConfig(), and the digitalRead() reflection in handleGetConfig(). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com> Co-authored-by: Ben Meadors <benmmeadors@gmail.com>	2026-05-16 06:16:11 -05:00
Ben Meadors	29a61dc75c	Fix type declaration for ambientLightingThread and correct uint32_t usage in PacketHistory	2026-05-12 21:45:16 -05:00
6 people	8e99ffbe7e	ThinkNode M7 (#8077) ... * ThinkNode G3, ETH support WIP * ThinkNode G3, ETH support WIP * ThinkNode G3, ETH support WIP * ThinkNode G3, ETH support WIP * ThinkNode G3, ETH support WIP * ThinkNode G3, ETH support WIP * ThinkNode G3, ETH support WIP * rename variant and add guard macros * older G3 operational. M7 next. * Split out G3 and M7 to different variants. Completely new PCB design. The G3 stays on 'PRIVATE_HW' * Define button behaviour and use all of the device flash --------- Co-authored-by: Ben Meadors <benmmeadors@gmail.com> Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com> Co-authored-by: caveman99 <25002+caveman99@users.noreply.github.com> Co-authored-by: Jonathan Bennett <jbennett@incomsystems.biz>	2026-05-11 11:33:13 -05:00
BJKandGitHub	fefd424901	Fix screen geometry update for SH1107 display (#10444) ... Added conditional block to update screen geometry for SH1107 128x128.	2026-05-09 12:53:07 -05:00
Jonathan BennettandGitHub	92c0133ef9	Finish evil merge cleanup (#10253)	2026-04-22 21:47:20 -05:00
Ben Meadors	6171ad8c14	Remove duplicate GPIO init block in setup() from bad merge in PR #9378 ... The T-Deck-Pro V1.1 PR (#9378) had a backwards merge (e7b66281) that pulled 236 commits of master INTO a 1-commit fork branch, then a second merge (8fd0a7f2) duplicated the entire T_DECK/T_DECK_PRO/T_LORA_PAGER/HACKADAY peripheral init block in setup(). Also removes a stray digitalWrite(BLE_LED, LED_STATE_OFF) in the HACKADAY section that was an artifact of the evil merge at e7b66281.	2026-04-22 19:35:13 -05:00
Ben MeadorsandGitHub	8fd0a7f283	Merge branch 'master' into master	2026-04-18 11:17:03 -05:00
Ben MeadorsandCopilot	9e26cc3795	Update src/main.cpp ... Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>	2026-04-18 11:11:41 -05:00
lewisxheandBen Meadors	d31d0f85fe	Added compatibility with LilyGo T-Deck-Pro V1.1	2026-04-18 11:11:41 -05:00
3 people	d5af07e458	Update src/main.cpp ... Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>	2026-04-16 07:49:08 -05:00
Ben MeadorsandGitHub	e7b66281fa	Merge branch 'master' into master	2026-04-16 07:07:03 -05:00
Ben MeadorsandGitHub	d693fd4232	Exclude accelerometer on new MESHTASTIC_EXCLUDE_ACCELEROMETER flag (#10004)	2026-03-25 08:57:29 -05:00
Ben MeadorsandGitHub	6920a5f8b1	Increase PSRAM malloc threshold from 256 bytes to 2048 bytes (#9758)	2026-02-28 09:34:26 -06:00
3 people	3a74e049ab	Add Transmit history persistence for respecting traffic intervals between reboots (#9748) ... * Add transmit history for throttling that persists between reboots * Fix RAK long press detection to prevent phantom shutdowns from floating pins * Update test/test_transmit_history/test_main.cpp Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Test fixes and placeholder for content handler tests --------- Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>	2026-02-25 20:41:07 -06:00
WesselandGitHub	ad7d19c317	Remove unused global rIf that shadows locals and fails cppcheck (#9743) ... I noticed because my PR failed	2026-02-24 20:57:58 -06:00
WesselandGitHub	02d42f87d3	Implement 'agc' reset for SX126x & LR11x0 chip families (#9705) ... * Implement 'agc' reset for SX126x chip family There's no actual agc on SX126x chips but you can reset the analog registers by doing a warm sleep & running calibration. * Address PR comments & implement for LR11x0 too * calibrate for configured frequency band * Gate LR11X0_AGC_RESET	2026-02-24 08:03:25 -06:00
3 people	8feb34e7a8	RadioLib edge-triggered interrupts robustness (#9658) ... * Fix potential race condition (read, ISR write, clear) in NotifiedWorkerThread * Check for missed edge-triggered interrupts race condition between startReceive and enableInterrupt * Occasionally poll to catch missed RX_DONE interrupts. (RadioLibInterface::pollMissedIrqs) * Simplify RadioLibInterface::checkRxDoneIrqFlag() --------- Co-authored-by: Ben Meadors <benmmeadors@gmail.com>	2026-02-21 06:14:04 -06:00
Ben Meadors	8c37d6923b	Add #include "RadioLibInterface.h"	2026-02-20 12:00:30 -06:00
Ben MeadorsandGitHub	299ef95f25	Revert "Add agc reset attempt (#8163)" (#9702) ... This reverts commit ac611c4b62.	2026-02-20 11:25:28 -06:00
Thomas GöttgensandGitHub	56fd9c7813	fix a lot of low level cppcheck warnings (#9623) ... * simplify the observer pattern, since all the called functions are const getters. * use arduino macro over std: for numerical values and refactor local variables in drawScrollbar() * oh, so Cppcheck actually complained about const pointers not being const. * slowly getting out of ifdef hell * fix inkHUD warnings as well * last 2 check warnings * git checks should fail on low defects from now on	2026-02-16 12:28:07 +01:00
JorropoandGitHub	ff485d5ff8	replace delete in RadioInterface.cpp with std::unique_ptr (#9645) ... Is part of the unique_ptr modernization effort.	2026-02-14 21:39:26 +01:00
+212 people	15297cb56f	feat/add sfa30 (#9372) ... * Move PMSA003I to separate class and update AQ telemetry * AirQualityTelemetry module not depend on PM sensor presence * Remove commented line * Fixes on PMS class * Add missing warmup period to wakeUp function * Fixes on compilation for different variants * Add functions to check for I2C bus speed and set it * Initial implementation for SFA30Sensor * Move PMSA003I to separate class and update AQ telemetry * AirQualityTelemetry module not depend on PM sensor presence * Remove commented line * Fixes on PMS class * Add missing warmup period to wakeUp function * Fixes on compilation for different variants * Add functions to check for I2C bus speed and set it * Add ScreenFonts.h Co-authored-by: Hannes Fuchs <hannes.fuchs+git@0xef.de> * PMSA003I 1st round test * Fix I2C scan speed * Fix minor issues and bring back I2C SPEED def * Remove PMSA003I library as its no longer needed * Add functional SCD4X * Fix screen frame for CO2 * Add admin commands to SCD4X class * Add further admin commands and fixes. * Remove unused I2C speed functions and cleanup * Cleanup of SEN5X specific code added from switching branches * Remove SCAN_I2C_CLOCK_SPEED block as its not needed * Remove associated functions for setting I2C speed * Unify build epoch to add flag in platformio-custom.py (#7917) * Unify build_epoch replacement logic in platformio-custom * Missed one * Fix build error in rak_wismesh_tap_v2 (#7905) In the logs was: "No screen resolution defined in build_flags. Please define DISPLAY_SIZE." set according to similar devices. * Put guards in place around debug heap operations (#7955) * Put guards in place around debug heap operations * Add macros to clean up code * Add pointer as well * Cleanup * Fix memory leak in NextHopRouter: always free packet copy when removing from pending * Formatting * Only queue 2 client notification * Merge pull request #7965 from compumike/compumike/fix-nrf52-bluetooth-memory-leak Fix memory leak in `NRF52Bluetooth`: allocate `BluetoothStatus` on stack, not heap * Merge pull request #7964 from compumike/compumike/fix-nimble-bluetooth-memory-leak Fix memory leak in `NimbleBluetooth`: allocate `BluetoothStatus` on stack, not heap * Update protobufs (#7973) Co-authored-by: thebentern <9000580+thebentern@users.noreply.github.com> * T-Lora Pager: Support LR1121 and SX1280 models (#7956) * T-Lora Pager: Support LR1121 and SX1280 models * Remove ifdefs * Trunk * Trunk * Static memory pool allocation (#7966) * Static memory pool * Initializer * T-Lora Pager: Support LR1121 and SX1280 models (#7956) * T-Lora Pager: Support LR1121 and SX1280 models * Remove ifdefs --------- Co-authored-by: WillyJL <me@willyjl.dev> * Portduino dynamic alloc * Missed * Drop the limit * Update meshtastic-esp8266-oled-ssd1306 digest to 0cbc26b (#7977) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com> * Fix json report crashes on esp32 (#7978) * Tweak maximums * Fix DRAM overflow on old esp32 targets * Guard bad time warning logs using GPS_DEBUG (#7897) In 2.7.7 / 2.7.8 we introduced some new checks for time accuracy. In combination, these result in a spamming of the logs when a bad time is found When the GPS is active, we're calling the GPS thread every 0.2secs. So this log could be printed 4,500 times in a no-lock scenario :) Reserve this experience for developers using GPS_DEBUG. Fixes https://github.com/meshtastic/firmware/issues/7896 * Scale probe buffer size based on current baud rate (#7975) * Scale probe buffer size based on current baud rate * Throttle bad time validation logging and fix time comparison logic * Remove comment * Missed the other instances * Copy pasta * Fix GPS gm_mktime memory leak (#7981) * Fix overflow of time value (#7984) * Fix overflow of time value * Revert "Fix overflow of time value" This reverts commit 084796920179e80a7500d36c25fd4d82b3ef4214. * That got boogered up * Remove PMSA003 include from modules * Add flag to exclude air quality module * Rework PMSA003I to align with new I2C scanner * Reworks AQ telemetry to match new dynamic allocation method * Adds VBLE_I2C_CLOCK_SPEED build flag for sensors with different I2C speed requirements * Reworks PMSA003I * Move add sensor template to separate file * Split telemetry on screen options * Add variable I2C clock compile flag * Added to Seeed Xiao S3 as demo * Fix drawFrame in AQ module * Module settings override to i2cScan module function * Move to CAN_RECLOCK_I2C per architecture * Add reclock function in TelemetrySensor.cpp * Add flag in ESP32 common * Minor fix * Move I2C reclock function to src/detect * Fix uninitMemberVar errors and compile issue * Make sleep, wakeUp functions generic * Fix STM32 builds * Add exclude AQ sensor to builds that have environmental sensor excludes * Add includes to AddI2CSensorTemplate.h * SEN5X first pass * WIP Sen5X functions * Further (non-working) progress in SEN5X * WIP Sen5X functions * Changes on SEN5X library - removing pm_env as well * Small cleanup of SEN5X sensors * Minor change for SEN5X detection * Remove dup code * Enable PM sensor before sending telemetry. This enables the PM sensor for a predefined period to allow for warmup. Once telemetry is sent, the sensor shuts down again. * Small cleanups in SEN5X sensor * Add dynamic measurement interval for SEN5X * Only disable SEN5X if enough time after reading. * Idle for SEN5X on communication error * Cleanup of logs and remove unnecessary delays * Small TODO * Settle on uint16_t for SEN5X PM data * Make AQTelemetry sensors non-exclusive * Implementation of cleaning in FS prefs and cleanup * Remove unnecessary LOGS * Add cleaning date storage in FS * Report non-cumulative PN * Bring back detection code for SEN5X after branch rebase * Add placeholder for admin message * Add VOC measurements and persistence (WIP) * Adds VOC measurements and state * Still not working on VOC Index persistence * Should it stay in continuous mode? * Add one-shot mode config flag to SEN5X * Add nan checks on sensor data from SEN5X * Working implementation on VOCState * Adds initial timer for SEN55 to not sleep if VOCstate is not stable (1h) * Adds conditions for stability and sensor state * Fixes on VOC state and mode swtiching * Adds a new RHT/Gas only mode, with 3600s stabilization time * Fixes the VOCState buffer mismatch * Fixes SEN50/54/55 model mistake * Adapt SEN5X to new sensor list structure. Improve reclock. * Improve reClockI2C conditions for different variants * Add sleep, wakeUp, pendingForReady, hasSleep functions to PM sensors to save battery * Add SEN5X * Fix merge errors * Small reordering in PMS class for consistency * If one sensor fails, AQ telemetry still reports data * Small formatting fix * Add SEN5X to AQI in ScanI2C * SCD4X now part of AQ module with template list * Fixes difference between idle and sleep * In LowPower, sleep is disabled * Requires testing for I2C clock comms for commands * Remove unnecessary import * Add co2 to serialized AQ metrics * Add SFA30 with new sensor template in AQ module * Update library dependencies in platformio.ini * Fix unitialized variables in SEN5X constructor * Fix missing import * Fix uninitMemberVars * Fix import error for SCD4X * Fix I2CClock logic * Fix not reclocking back to 700000Hz * Fix multiple sensors being read simultaneously * The logic in AQ module is different to the one in EnvironmentTelemetryModule. In Env module, if any sensor fails to getMetrics, no valid flag for the module. This prevents other sensors to report data. * Fix pending clock change in PMSA003 * Cleanup of SEN5X class * Exclude AQ sensor from wio-e5 due to flash limitations * Fix I2C clock change logic * Make sure clock is always set to needed value * Fix returns * Fix trunk * Fix on condition in reclock * Fix trunk * Final SFA30 class implementation * Add HCHO to screen and improve logs * Add metrics to mesh packet serializer * Minor fixes in logs * OCD tidy up of logs * Fix sleep function * Remove old I2C_CLOCK_SPEED code --------- Co-authored-by: nikl <nikl174@mailbox.org> Co-authored-by: Hannes Fuchs <hannes.fuchs+git@0xef.de> Co-authored-by: Nashui-Yan <yannashui10@gmail.com> Co-authored-by: Ben Meadors <benmmeadors@gmail.com> Co-authored-by: Tom Fifield <tom@tomfifield.net> Co-authored-by: Mike Robbins <mrobbins@alum.mit.edu> Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: thebentern <9000580+thebentern@users.noreply.github.com> Co-authored-by: WillyJL <me@willyjl.dev> Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>	2026-02-11 14:13:34 -06:00
Jonathan BennettandGitHub	31fe15bb73	ExternalNotification and StatusLED now call AmbientLighting to update… (#9554) ... * ExternalNotification and StatusLED now call AmbientLighting to update RGB LEDs. Add optional heartbeat * Don't overwrite RGB state if heartbeat is disabled. * Use the right define * Remove another .h and make rgb static * move rgb objects into AmbientLighting class * Straighten out AmbientLighting Thread object * Use %f for floats	2026-02-11 12:02:22 -06:00
Thomas GöttgensandGitHub	f96a8593f2	fix some random compiler warnings (#9596)	2026-02-11 06:43:05 -06:00
Ben Meadors	b12cac3e00	Merge branch 'master' into develop	2026-02-09 12:52:22 -06:00
+111 people	7cbab4838c	Feat/add sen5x (#7245) ... * Move PMSA003I to separate class and update AQ telemetry * AirQualityTelemetry module not depend on PM sensor presence * Remove commented line * Fixes on PMS class * Add missing warmup period to wakeUp function * Fixes on compilation for different variants * Add functions to check for I2C bus speed and set it * Add ScreenFonts.h Co-authored-by: Hannes Fuchs <hannes.fuchs+git@0xef.de> * PMSA003I 1st round test * Fix I2C scan speed * Fix minor issues and bring back I2C SPEED def * Remove PMSA003I library as its no longer needed * Remove unused I2C speed functions and cleanup * Cleanup of SEN5X specific code added from switching branches * Remove SCAN_I2C_CLOCK_SPEED block as its not needed * Remove associated functions for setting I2C speed * Unify build epoch to add flag in platformio-custom.py (#7917) * Unify build_epoch replacement logic in platformio-custom * Missed one * Fix build error in rak_wismesh_tap_v2 (#7905) In the logs was: "No screen resolution defined in build_flags. Please define DISPLAY_SIZE." set according to similar devices. * Put guards in place around debug heap operations (#7955) * Put guards in place around debug heap operations * Add macros to clean up code * Add pointer as well * Cleanup * Fix memory leak in NextHopRouter: always free packet copy when removing from pending * Formatting * Only queue 2 client notification * Merge pull request #7965 from compumike/compumike/fix-nrf52-bluetooth-memory-leak Fix memory leak in `NRF52Bluetooth`: allocate `BluetoothStatus` on stack, not heap * Merge pull request #7964 from compumike/compumike/fix-nimble-bluetooth-memory-leak Fix memory leak in `NimbleBluetooth`: allocate `BluetoothStatus` on stack, not heap * Update protobufs (#7973) Co-authored-by: thebentern <9000580+thebentern@users.noreply.github.com> * T-Lora Pager: Support LR1121 and SX1280 models (#7956) * T-Lora Pager: Support LR1121 and SX1280 models * Remove ifdefs * Trunk * Trunk * Static memory pool allocation (#7966) * Static memory pool * Initializer * T-Lora Pager: Support LR1121 and SX1280 models (#7956) * T-Lora Pager: Support LR1121 and SX1280 models * Remove ifdefs --------- Co-authored-by: WillyJL <me@willyjl.dev> * Portduino dynamic alloc * Missed * Drop the limit * Update meshtastic-esp8266-oled-ssd1306 digest to 0cbc26b (#7977) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com> * Fix json report crashes on esp32 (#7978) * Tweak maximums * Fix DRAM overflow on old esp32 targets * Guard bad time warning logs using GPS_DEBUG (#7897) In 2.7.7 / 2.7.8 we introduced some new checks for time accuracy. In combination, these result in a spamming of the logs when a bad time is found When the GPS is active, we're calling the GPS thread every 0.2secs. So this log could be printed 4,500 times in a no-lock scenario :) Reserve this experience for developers using GPS_DEBUG. Fixes https://github.com/meshtastic/firmware/issues/7896 * Scale probe buffer size based on current baud rate (#7975) * Scale probe buffer size based on current baud rate * Throttle bad time validation logging and fix time comparison logic * Remove comment * Missed the other instances * Copy pasta * Fix GPS gm_mktime memory leak (#7981) * Fix overflow of time value (#7984) * Fix overflow of time value * Revert "Fix overflow of time value" This reverts commit 084796920179e80a7500d36c25fd4d82b3ef4214. * That got boogered up * Remove PMSA003 include from modules * Add flag to exclude air quality module * Rework PMSA003I to align with new I2C scanner * Reworks AQ telemetry to match new dynamic allocation method * Adds VBLE_I2C_CLOCK_SPEED build flag for sensors with different I2C speed requirements * Reworks PMSA003I * Move add sensor template to separate file * Split telemetry on screen options * Add variable I2C clock compile flag * Added to Seeed Xiao S3 as demo * Fix drawFrame in AQ module * Module settings override to i2cScan module function * Move to CAN_RECLOCK_I2C per architecture * Add reclock function in TelemetrySensor.cpp * Add flag in ESP32 common * Minor fix * Move I2C reclock function to src/detect * Fix uninitMemberVar errors and compile issue * Make sleep, wakeUp functions generic * Fix STM32 builds * Add exclude AQ sensor to builds that have environmental sensor excludes * Add includes to AddI2CSensorTemplate.h * SEN5X first pass * WIP Sen5X functions * Further (non-working) progress in SEN5X * WIP Sen5X functions * Changes on SEN5X library - removing pm_env as well * Small cleanup of SEN5X sensors * Minor change for SEN5X detection * Remove dup code * Enable PM sensor before sending telemetry. This enables the PM sensor for a predefined period to allow for warmup. Once telemetry is sent, the sensor shuts down again. * Small cleanups in SEN5X sensor * Add dynamic measurement interval for SEN5X * Only disable SEN5X if enough time after reading. * Idle for SEN5X on communication error * Cleanup of logs and remove unnecessary delays * Small TODO * Settle on uint16_t for SEN5X PM data * Make AQTelemetry sensors non-exclusive * Implementation of cleaning in FS prefs and cleanup * Remove unnecessary LOGS * Add cleaning date storage in FS * Report non-cumulative PN * Bring back detection code for SEN5X after branch rebase * Add placeholder for admin message * Add VOC measurements and persistence (WIP) * Adds VOC measurements and state * Still not working on VOC Index persistence * Should it stay in continuous mode? * Add one-shot mode config flag to SEN5X * Add nan checks on sensor data from SEN5X * Working implementation on VOCState * Adds initial timer for SEN55 to not sleep if VOCstate is not stable (1h) * Adds conditions for stability and sensor state * Fixes on VOC state and mode swtiching * Adds a new RHT/Gas only mode, with 3600s stabilization time * Fixes the VOCState buffer mismatch * Fixes SEN50/54/55 model mistake * Adapt SEN5X to new sensor list structure. Improve reclock. * Improve reClockI2C conditions for different variants * Add sleep, wakeUp, pendingForReady, hasSleep functions to PM sensors to save battery * Add SEN5X * Fix merge errors * Update library dependencies in platformio.ini * Fix unitialized variables in SEN5X constructor * Fix missing import * Cleanup of SEN5X class * Exclude AQ sensor from wio-e5 due to flash limitations * Fix I2C clock change logic * Fix trunk * Fix on condition in reclock * Add check on polling interval of sen5x --------- Co-authored-by: Hannes Fuchs <hannes.fuchs+git@0xef.de> Co-authored-by: Nashui-Yan <yannashui10@gmail.com> Co-authored-by: Ben Meadors <benmmeadors@gmail.com> Co-authored-by: Tom Fifield <tom@tomfifield.net> Co-authored-by: Mike Robbins <mrobbins@alum.mit.edu> Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: thebentern <9000580+thebentern@users.noreply.github.com> Co-authored-by: WillyJL <me@willyjl.dev> Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>	2026-02-08 07:08:09 -06:00
4 people	53231ae4b1	Added toggable config and default for larger screens to enable / hide bubbles on chat messages (#9560) ... * Added toggable config and default for largeer screens to enable / hide bubbles on chat messages * Refactor message bubble rendering logic for improved layout and consistency * Move osk_found initialization for trackball/encoder devices before module setup to fix missing keyboard for L1 * Utilize current checks for consistency * Reverted last changes --------- Co-authored-by: Jason P <applewiz@mac.com> Co-authored-by: HarukiToreda <116696711+HarukiToreda@users.noreply.github.com>	2026-02-07 15:41:31 -06:00
Jonathan BennettandGitHub	2361776992	Rename LED_PIN to LED_POWER, move handling out of main to dedicated module (#9512) ... * Rename LED_PIN to LED_POWER, move handling out of main to dedicated module * Misc * Remove errant endif	2026-02-05 05:41:00 -06:00
3 people	ac611c4b62	Add agc reset attempt (#8163) ... * Add agc reset attempt * Add radioLibInterface include * Trunk * AGC reset don't crash, don't naively call * Update src/main.cpp Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Use Throttle function --------- Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>	2026-02-04 14:47:44 -06:00
Jonathan BennettandGitHub	1d30342c00	Don't ever define PIN_LED or BLE_LED_INVERTED (#9494) ... * Don't ever define PIN_LED * Deprecate BLE_LED_INVERTED	2026-01-31 12:15:06 -06:00
Jonathan BennettandGitHub	dbded86dcb	More variant.h cleanup. LED_NOTIFICATION, remove dead code, etc (#9477)	2026-01-29 12:51:48 -06:00
4 people	1d219a93ab	Move input init to an init function in InputBroker (#9463) ... * Move input init to an init function in iInputBroker * Unbreak targets with EXCLUDE_INPUTBROKER * Update src/input/InputBroker.cpp Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Fix conditional compilation for input broker * Apply suggestions from code review Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Trunk --------- Co-authored-by: Ben Meadors <benmmeadors@gmail.com> Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>	2026-01-28 14:58:05 -06:00
Jonathan BennettandGitHub	69a42e1fd2	Add portduino_status, assign hardware device IDs... (#9441) ... * Add portduino_status, assign hardware device IDs, and try to recover a CH341 device on a USB error * Minor fixes suggested by Copilot	2026-01-27 18:00:20 -06:00
Jonathan BennettandGitHub	c038cfe69a	Move device code from main.cpp to earlyInitVariant (#9438)	2026-01-26 11:54:14 -06:00
Jonathan BennettandGitHub	8a9830282a	Move Lora Init code into LoraInit.cpp/h (#9435) ... * Move Lora Init code into LoraInit.cpp/h * Add missed extern definition * More carefully check for nullptr in LoraInit.cpp * STM32 fixes * Add extern SPI1 for HW_SPI1_DEVICE * Move initLora to RadioInterface.h	2026-01-25 20:54:17 -06:00
4 people	57a3ff8dfc	NRF52 - power management improvements (#9211) ... * minor NRF52 test cleanup * detect USB power input on ProMicro boards * prevent booting on power failure detection * introduce PowerHAL layer * powerHAL basic implementation for NRF52 * prevent data saves on low power * remove comment * Update src/platform/nrf52/main-nrf52.cpp Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Update src/power/PowerHAL.h Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Update src/main.cpp Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Merge missing voltage threshold comparison * add missing variable * add missing function declaration * remove debug strings --------- Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> Co-authored-by: Ben Meadors <benmmeadors@gmail.com>	2026-01-24 08:39:03 -06:00
lewisxhe	15b474172a	Added compatibility with LilyGo T-Deck-Pro V1.1	2026-01-21 17:33:50 +08:00
3 people	64116cd0d3	Meshtastic OTA (moar) (#9327) ... * Initial commit of combined BLE and WiFi OTA * Incorporate ota_hash in AdminMessage protobuf * OTA protobuf changes * Trunk fmt * Partition header check for OTA type * Guards * Guards * Derp * Missed one --------- Co-authored-by: Jake-B <jake-b@users.noreply.github.com>	2026-01-15 14:36:36 -06:00