Short circuit invalid nodenum check in ham mode.

Until signing is implemented, this will prevent the nodenum from being regenerated upon each reboot.

.claude/settings.json

@@ -0,0 +1,16 @@
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Write|Edit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 -c \"import json,sys,subprocess,shutil,os; f=json.load(sys.stdin).get('tool_input',{}).get('file_path',''); t=shutil.which('trunk') or os.path.expanduser('~/.cache/trunk/launcher/trunk'); f and os.path.exists(t) and subprocess.run([t,'fmt','--force',f],stderr=subprocess.DEVNULL)\" 2>/dev/null || true",
+            "statusMessage": "Formatting..."
+          }
+        ]
+      }
+    ]
+  }
+}

.github/workflows/update_protobufs.yml

@@ -16,13 +16,18 @@ jobs:
           submodules: true
 
       - name: Update submodule
-        if: ${{ github.ref == 'refs/heads/master' || github.ref == 'refs/heads/develop' }}
+        if: ${{ github.ref_name == 'master' || github.ref_name == 'develop' }}
+        working-directory: protobufs
+        env:
+          # Use the branch that triggered the workflow as the protobuf branch.
+          GIT_BRANCH: ${{ github.ref_name }}
         run: |
-          git submodule update --remote protobufs
+          git fetch --prune origin $GIT_BRANCH
+          git checkout origin/$GIT_BRANCH
 
       - name: Download nanopb
         run: |
-          wget https://jpa.kapsi.fi/nanopb/download/nanopb-0.4.9.1-linux-x86.tar.gz
+          wget https://github.com/nanopb/nanopb/releases/download/nanopb-0.4.9.1/nanopb-0.4.9.1-linux-x86.tar.gz
           tar xvzf nanopb-0.4.9.1-linux-x86.tar.gz
           mv nanopb-0.4.9.1-linux-x86 nanopb-0.4.9
 
@@ -33,7 +38,7 @@ jobs:
       - name: Create pull request
         uses: peter-evans/create-pull-request@v8
         with:
-          branch: create-pull-request/update-protobufs
+          branch: create-pull-request/update-protobufs-${{ github.ref_name }}
           labels: submodules
           title: Update protobufs and classes
           commit-message: Update protobufs

extra_scripts/nrf52_lto.py

@@ -0,0 +1,138 @@
+#!/usr/bin/env python3
+# trunk-ignore-all(ruff/F821)
+# trunk-ignore-all(flake8/F821)
+#
+# Whole-image LTO for nrf52840 (~-60KB; ~-23KB beyond src-only LTO), EXCEPT the objects
+# that own interrupt/exception handlers.
+#
+# Every ISR is referenced only from the assembly vector table (gcc_startup_nrf52840.S),
+# which LTO cannot see -> whole-program LTO judges the handlers dead, removes them, and
+# the weak `b .` Default_Handler stubs prevail -> the IRQ lands in an infinite loop and the
+# chip hangs (or the peripheral silently stalls). Compiling the handler-bearing objects
+# WITHOUT LTO lets ordinary linking keep the strong handlers; everything else stays LTO'd:
+#   - framework core (/FrameworkArduino/, /cores/nRF5/): every nrfx ISR + the FreeRTOS
+#     SVC/PendSV port.
+#   - TinyUSB nrf port (Adafruit_TinyUSB_nrf.cpp): USBD_IRQHandler (USB data path).
+#   - library .cpp files that own a vector ISR (would otherwise be silently dropped):
+#       bluefruit.cpp     -> SD_EVT/SWI2_EGU2  (SoftDevice BLE-event delivery -- advertising
+#                            hangs without it)
+#       Wire_nRF52.cpp    -> SPIM0/TWIM0 + SPIM1/TWIM1 (interrupt-driven I2C/SPI)
+#       PDM.cpp           -> PDM_IRQHandler   (PDM microphone)
+#       RotaryEncoder.cpp -> QDEC_IRQHandler  (hardware quadrature/rotary encoder)
+#
+# A post-link guard (bottom of this file) fails the build if a critical handler was dropped
+# anyway -- so a future deps bump or a new ISR-owning library becomes a red build, not a field
+# hang. To hunt a dropped ISR by hand: nm the .elf for `_IRQHandler$` symbols marked `W`, then
+# grep the libs/framework for who defines them.
+#
+# HW-validated: RAK4631 (SX1262) + muzi-base (LR1121).
+import glob
+import os
+
+Import("env")
+
+env.Append(LINKFLAGS=["-flto", "-flto-partition=1to1"])
+
+# The -fno-lto re-compiles below run with the global env, which lacks the framework's
+# bundled-library include dirs -- and those libs cross-include each other (Wire pulls in
+# Adafruit_TinyUSB.h, which pulls in SPI.h, ...). Add every bundled-lib dir (+ its src/) so
+# the re-compiles resolve without chasing headers one at a time.
+_fw = env.PioPlatform().get_package_dir("framework-arduinoadafruitnrf52") or ""
+_extra_inc = []
+for _d in sorted(glob.glob(os.path.join(_fw, "libraries", "*"))):
+    if os.path.isdir(_d):
+        _extra_inc.append(_d)
+        if os.path.isdir(os.path.join(_d, "src")):
+            _extra_inc.append(os.path.join(_d, "src"))
+
+FRAMEWORK = ("/FrameworkArduino/", "/cores/nRF5/")
+USB_ISR = "Adafruit_TinyUSB_nrf"  # USBD_IRQHandler
+# Library .cpp files that define vector-table ISRs (the rest of their lib stays LTO'd):
+LIB_ISR = ("/bluefruit.cpp", "/Wire_nRF52.cpp", "/PDM.cpp", "/RotaryEncoder.cpp")
+
+
+def _no_lto(node):
+    try:
+        path = node.get_abspath()
+    except Exception:
+        path = str(node)
+    path = path.replace(
+        "\\", "/"
+    )  # normalize Windows backslashes so matches work cross-platform
+    if (
+        USB_ISR in path
+        or any(s in path for s in FRAMEWORK)
+        or any(s in path for s in LIB_ISR)
+    ):
+        return env.Object(
+            node,
+            CCFLAGS=env["CCFLAGS"] + ["-fno-lto"],
+            CPPPATH=env["CPPPATH"] + _extra_inc,
+        )
+    return node
+
+
+env.AddBuildMiddleware(_no_lto)
+
+
+# --- post-link guard: catch a dropped ISR handler at build time (CI footgun protection) ----
+# After every link, fail the build if one of these critical vector-table handlers resolved to
+# the weak `b .` Default_Handler stub -- i.e. LTO (or a deps bump, or a new ISR-owning library
+# that nobody added to LIB_ISR) silently dropped it. A dropped handler hangs the chip the
+# instant that IRQ fires; this turns a field hang into a red build. CI builds every nrf52840
+# target, so this runs on every PR automatically. All five are used by every nrf52840
+# Meshtastic build; if a board deliberately stops using one, edit this tuple on purpose.
+_REQUIRED_STRONG = (
+    "SWI2_EGU2_IRQHandler",  # SoftDevice BLE event (SD_EVT) -- advertising & connections
+    "GPIOTE_IRQHandler",  # GPIO interrupts: radio DIO + buttons
+    "RTC1_IRQHandler",  # FreeRTOS scheduler tick
+    "USBD_IRQHandler",  # USB CDC (serial console + 1200bps DFU trigger)
+    "POWER_CLOCK_IRQHandler",  # HF/LF clock + power (HFCLK start for radio & SoftDevice)
+)
+
+_tc = env.PioPlatform().get_package_dir("toolchain-gccarmnoneeabi") or ""
+_NM = os.path.join(_tc, "bin", "arm-none-eabi-nm")
+if not os.path.isfile(_NM):
+    _NM = "arm-none-eabi-nm"  # fall back to PATH
+
+
+def _assert_isr_handlers_survived(source, target, env):
+    import subprocess
+    import sys
+
+    try:
+        # Resolve the ELF at build time; target[0] is the buildprog alias, not the file.
+        elf = env.subst("$BUILD_DIR/${PROGNAME}.elf")
+        out = subprocess.check_output([_NM, elf], universal_newlines=True)
+    except Exception as exc:  # tooling hiccup: warn loudly, don't wedge the build
+        print("nrf52_lto: WARNING - ISR-handler guard skipped (nm failed: %s)" % exc)
+        return
+    # nm line: "<addr> <type> <symbol>". type 'T'/'t' = strong (good); 'W'/'w' = weak stub.
+    kind = {}
+    for line in out.split("\n"):
+        f = line.split()
+        if len(f) >= 3 and f[-1].endswith("_IRQHandler"):
+            kind[f[-1]] = f[-2]
+    dropped = [h for h in _REQUIRED_STRONG if kind.get(h, "W").upper() != "T"]
+    if dropped:
+        sys.stderr.write(
+            "\n*** nrf52 LTO guard: interrupt handler(s) DROPPED: %s ***\n"
+            "Each resolved to the weak Default_Handler stub, so the chip hangs when that IRQ\n"
+            "fires. Compile the .cpp that defines the handler with -fno-lto by adding it to\n"
+            "LIB_ISR in extra_scripts/nrf52_lto.py. Find the owner of FOO_IRQHandler with:\n"
+            "  grep -rl FOO_IRQHandler <framework-arduinoadafruitnrf52>/{libraries,cores}\n\n"
+            % ", ".join(dropped)
+        )
+        from SCons.Script import Exit
+
+        Exit(1)  # canonical SCons build-abort -> red build
+    print(
+        "nrf52_lto: ISR-handler guard OK -- %d critical handlers strong"
+        % len(_REQUIRED_STRONG)
+    )
+
+
+# Attach to the phony "buildprog" alias, NOT the .elf file node: SCons can skip a post-action
+# on a file target during an incremental relink (observed), but the buildprog alias runs every
+# build -- so the guard fires on local incremental rebuilds and clean CI builds alike.
+env.AddPostAction("buildprog", _assert_isr_handlers_survived)

extra_scripts/zps_observer.py

@@ -1,39 +0,0 @@
-#!/usr/bin/env python3
-# trunk-ignore-all(ruff/F821)
-# trunk-ignore-all(flake8/F821): For SConstruct imports
-import re
-
-Import("env")
-
-# The ZPS module scans BLE through the NimBLE *host* API ble_gap_disc(), which the
-# ESP-IDF only compiles when CONFIG_BT_NIMBLE_ROLE_OBSERVER=y. The base esp32 config
-# disables the observer role to save flash (see variants/esp32/esp32-common.ini), so
-# re-enable it ONLY when the ZPS module is actually built. This keeps a single flag
-# (-DMESHTASTIC_EXCLUDE_ZPS) driving both the C++ module and the IDF sdkconfig.
-#
-# This runs as a pre: script, before the arduino framework builder reads
-# custom_sdkconfig (PlatformIO core runs pre-scripts before $BUILD_SCRIPT). Appending
-# to custom_sdkconfig changes its hash and triggers the framework's IDF rebuild path,
-# but only for ZPS-enabled envs; for every normal build this is a no-op.
-flags = env.GetProjectOption("build_flags", "")
-if isinstance(flags, (list, tuple)):
-    flags = " ".join(flags)
-
-# Mirror the C semantics of `#if !MESHTASTIC_EXCLUDE_ZPS`:
-#   flag absent          -> module enabled
-#   -DMESHTASTIC_EXCLUDE_ZPS=0 -> module enabled
-#   -DMESHTASTIC_EXCLUDE_ZPS or =1 (or anything else) -> module excluded
-match = re.search(r"\bMESHTASTIC_EXCLUDE_ZPS\b(?:=(\S+))?", flags)
-zps_enabled = (match is None) or (match.group(1) == "0")
-
-section = "env:" + env["PIOENV"]
-config = env.GetProjectConfig()
-if zps_enabled and config.has_option(section, "custom_sdkconfig"):
-    sdkconfig = env.GetProjectOption("custom_sdkconfig")
-    if "CONFIG_BT_NIMBLE_ROLE_OBSERVER" not in sdkconfig:
-        config.set(
-            section,
-            "custom_sdkconfig",
-            sdkconfig.rstrip("\n") + "\n  CONFIG_BT_NIMBLE_ROLE_OBSERVER=y\n",
-        )
-        print("[ZPS] module enabled -> CONFIG_BT_NIMBLE_ROLE_OBSERVER=y (IDF rebuild)")

platformio.ini

@@ -53,7 +53,6 @@ build_flags = -Wno-missing-field-initializers
 	-DRADIOLIB_EXCLUDE_ADSB=1
 	-DRADIOLIB_EXCLUDE_LORAWAN=1
 	-DMESHTASTIC_EXCLUDE_DROPZONE=1
-	-DMESHTASTIC_EXCLUDE_ZPS=1
 	-DMESHTASTIC_EXCLUDE_REPLYBOT=1
 	-DMESHTASTIC_EXCLUDE_REMOTEHARDWARE=1
 	-DMESHTASTIC_EXCLUDE_HEALTH_TELEMETRY=1

src/gps/GPS.cpp

@@ -17,7 +17,10 @@
 #include "main.h" // pmu_found
 #include "sleep.h"
 
+#include "FSCommon.h"
 #include "GPSUpdateScheduling.h"
+#include "SPILock.h"
+#include "SafeFile.h"
 #include "cas.h"
 #include "ubx.h"
 
@@ -71,6 +74,67 @@ static struct uBloxGnssModelInfo {
 #define GPS_SOL_EXPIRY_MS 5000 // in millis. give 1 second time to combine different sentences. NMEA Frequency isn't higher anyway
 #define NMEA_MSG_GXGSA "GNGSA" // GSA message (GPGSA, GNGSA etc)
 
+namespace
+{
+// Versioned on-disk record for persisted GPS probe results.
+constexpr uint32_t GPS_PROBE_CACHE_MAGIC = 0x47504348UL; // "GPCH"
+constexpr uint16_t GPS_PROBE_CACHE_VERSION = 1;
+constexpr const char *GPS_PROBE_CACHE_FILE = "/prefs/gps_probe_cache.dat";
+
+struct GPSProbeCacheRecord {
+    uint32_t magic;
+    uint16_t version;
+    uint16_t reserved;
+    uint32_t baud;
+    uint8_t model;
+};
+
+bool isValidGnssModel(uint8_t model)
+{
+    // Keep persisted values bounded to known enum range.
+    return model <= static_cast<uint8_t>(GNSS_MODEL_CM121);
+}
+
+bool isValidProbeBaud(uint32_t baud)
+{
+    // Conservative sanity range for UART baud values.
+    return baud >= 1200 && baud <= 921600;
+}
+
+template <typename T> bool sawNmeaSentenceAtBaud(T *serialGps, uint32_t timeoutMs)
+{
+    // Lightweight passive check: look for at least one complete
+    // "$...,<field>\n" style NMEA sentence.
+    const uint32_t deadline = millis() + timeoutMs;
+    bool sawDollar = false;
+    bool sawComma = false;
+
+    while ((int32_t)(millis() - deadline) < 0) {
+        while (serialGps->available()) {
+            char c = static_cast<char>(serialGps->read());
+            if (c == '$') {
+                sawDollar = true;
+                sawComma = false;
+                continue;
+            }
+            if (c == ',') {
+                sawComma = true;
+            }
+            if (c == '\n' || c == '\r') {
+                if (sawDollar && sawComma) {
+                    return true;
+                }
+                sawDollar = false;
+                sawComma = false;
+            }
+        }
+        delay(10);
+    }
+
+    return false;
+}
+} // namespace
+
 // For logging
 static const char *getGPSPowerStateString(GPSPowerState state)
 {
@@ -492,6 +556,201 @@ static const int rareSerialSpeeds[3] = {4800, 57600, GPS_BAUDRATE};
 #define GPS_PROBETRIES 2
 #endif
 
+bool GPS::loadProbeCache()
+{
+#ifdef FSCom
+    // Load the last known-good GPS model/baud pair so we can avoid a full probe
+    // sweep on every boot.
+    triedProbeCache = true; // Latch this boot's load attempt, even if no cache.
+    GPSProbeCacheRecord record = {};
+    size_t bytesRead = 0;
+
+    spiLock->lock();
+    auto file = FSCom.open(GPS_PROBE_CACHE_FILE, FILE_O_READ);
+    if (!file) {
+        spiLock->unlock();
+        return false;
+    }
+    bytesRead = file.read(reinterpret_cast<uint8_t *>(&record), sizeof(record));
+    file.close();
+    spiLock->unlock();
+
+    const bool headerValid = (bytesRead == sizeof(record)) && (record.magic == GPS_PROBE_CACHE_MAGIC) &&
+                             (record.version == GPS_PROBE_CACHE_VERSION) && (record.reserved == 0U);
+    if (!headerValid || !isValidGnssModel(record.model) || !isValidProbeBaud(record.baud)) {
+        clearProbeCache(); // Drop corrupt/invalid cache so next boot can
+                           // recover.
+        return false;
+    }
+
+    cachedProbeBaud = static_cast<int32_t>(record.baud);
+    cachedProbeModel = static_cast<GnssModel_t>(record.model);
+    hasProbeCache = true;
+    triedProbeCache = false;
+    LOG_INFO("Loaded cached GPS probe: baud=%u", record.baud);
+    return true;
+#else
+    return false;
+#endif
+}
+
+void GPS::clearProbeCache()
+{
+    // Invalidate in-memory and on-disk cache so next boot is forced to do a
+    // full probe.
+    hasProbeCache = false;
+    triedProbeCache = true;
+    cachedProbeBaud = 0;
+    cachedProbeModel = GNSS_MODEL_UNKNOWN;
+#ifdef FSCom
+    spiLock->lock();
+    if (FSCom.exists(GPS_PROBE_CACHE_FILE)) {
+        FSCom.remove(GPS_PROBE_CACHE_FILE);
+    }
+    spiLock->unlock();
+#endif
+}
+
+bool GPS::saveProbeCache() const
+{
+#ifdef FSCom
+    if (gnssModel == GNSS_MODEL_UNKNOWN || !isValidGnssModel(static_cast<uint8_t>(gnssModel)) ||
+        !isValidProbeBaud(detectedBaud)) {
+        return false;
+    }
+
+    spiLock->lock();
+    FSCom.mkdir("/prefs");
+    spiLock->unlock();
+    GPSProbeCacheRecord record = {
+        GPS_PROBE_CACHE_MAGIC, GPS_PROBE_CACHE_VERSION, 0, static_cast<uint32_t>(detectedBaud), static_cast<uint8_t>(gnssModel),
+    };
+
+    auto file = SafeFile(GPS_PROBE_CACHE_FILE, true);
+    spiLock->lock();
+    const size_t written = file.write(reinterpret_cast<const uint8_t *>(&record), sizeof(record));
+    spiLock->unlock();
+    return (written == sizeof(record)) && file.close();
+#else
+    return false;
+#endif
+}
+
+bool GPS::verifyCachedProbePresence()
+{
+    if (!hasProbeCache || cachedProbeModel == GNSS_MODEL_UNKNOWN || !isValidProbeBaud(cachedProbeBaud)) {
+        return false;
+    }
+
+#if defined(ARCH_NRF52) || defined(ARCH_PORTDUINO) || defined(ARCH_STM32WL)
+    _serial_gps->end();
+    _serial_gps->begin(cachedProbeBaud);
+#elif defined(ARCH_RP2040)
+    _serial_gps->end();
+    _serial_gps->setFIFOSize(256);
+    _serial_gps->begin(cachedProbeBaud);
+#else
+    if (_serial_gps->baudRate() != cachedProbeBaud) {
+        LOG_DEBUG("Set GPS Baud to %i (cached verify)", cachedProbeBaud);
+        _serial_gps->updateBaudRate(cachedProbeBaud);
+    }
+#endif
+
+    // Before trusting cached model/baud, require either active model-specific
+    // response or passive NMEA flow.
+    clearBuffer();
+    bool present = false;
+
+    // Model-specific "active ping" checks to avoid false stale decisions on
+    // modules that start streaming late.
+    const char *cachedProbeModelName = "UNKNOWN";
+    switch (cachedProbeModel) {
+    case GNSS_MODEL_MTK:
+        cachedProbeModelName = "L76K/MTK";
+        _serial_gps->write("$PCAS06,0*1B\r\n");
+        present = (getACK("$GPTXT,01,01,02,SW=", 700) == GNSS_RESPONSE_OK);
+        break;
+    case GNSS_MODEL_MTK_L76B:
+        cachedProbeModelName = "L76B";
+    case GNSS_MODEL_MTK_PA1010D:
+        if (cachedProbeModel == GNSS_MODEL_MTK_PA1010D)
+            cachedProbeModelName = "PA1010D";
+    case GNSS_MODEL_MTK_PA1616S:
+        if (cachedProbeModel == GNSS_MODEL_MTK_PA1616S)
+            cachedProbeModelName = "PA1616S";
+    case GNSS_MODEL_LS20031:
+        if (cachedProbeModel == GNSS_MODEL_LS20031)
+            cachedProbeModelName = "LS20031";
+        _serial_gps->write("$PMTK605*31\r\n");
+        present = (getACK("$PMTK705", 900) == GNSS_RESPONSE_OK);
+        break;
+    case GNSS_MODEL_AG3335:
+        cachedProbeModelName = "AG3335";
+    case GNSS_MODEL_AG3352:
+        if (cachedProbeModel == GNSS_MODEL_AG3352)
+            cachedProbeModelName = "AG3352";
+        _serial_gps->write("$PAIR021*39\r\n");
+        present = (getACK("$PAIR021,", 900) == GNSS_RESPONSE_OK);
+        break;
+    case GNSS_MODEL_ATGM336H:
+        cachedProbeModelName = "ATGM336H";
+        _serial_gps->write("$PCAS06,1*1A\r\n");
+        present = (getACK("$GPTXT,01,01,02,HW=ATGM", 900) == GNSS_RESPONSE_OK);
+        break;
+    case GNSS_MODEL_UC6580:
+        cachedProbeModelName = "UC6580/UM600";
+        _serial_gps->write("$PDTINFO\r\n");
+        present = (getACK("UC6580", 900) == GNSS_RESPONSE_OK) || (getACK("UM600", 900) == GNSS_RESPONSE_OK);
+        break;
+    case GNSS_MODEL_CM121:
+        cachedProbeModelName = "CM121";
+        _serial_gps->write("$PDTINFO\r\n");
+        present = (getACK("CM121", 900) == GNSS_RESPONSE_OK);
+        break;
+    case GNSS_MODEL_UBLOX6:
+    case GNSS_MODEL_UBLOX7:
+    case GNSS_MODEL_UBLOX8:
+    case GNSS_MODEL_UBLOX9:
+    case GNSS_MODEL_UBLOX10: {
+        if (cachedProbeModel == GNSS_MODEL_UBLOX6)
+            cachedProbeModelName = "U-blox 6";
+        else if (cachedProbeModel == GNSS_MODEL_UBLOX7)
+            cachedProbeModelName = "U-blox 7";
+        else if (cachedProbeModel == GNSS_MODEL_UBLOX8)
+            cachedProbeModelName = "U-blox 8";
+        else if (cachedProbeModel == GNSS_MODEL_UBLOX9)
+            cachedProbeModelName = "U-blox 9";
+        else if (cachedProbeModel == GNSS_MODEL_UBLOX10)
+            cachedProbeModelName = "U-blox 10";
+
+        uint8_t cfg_rate[] = {0xB5, 0x62, 0x06, 0x08, 0x00, 0x00, 0x00, 0x00};
+        UBXChecksum(cfg_rate, sizeof(cfg_rate));
+        _serial_gps->write(cfg_rate, sizeof(cfg_rate));
+        present = (getACK(0x06, 0x08, 900) != GNSS_RESPONSE_NONE);
+        break;
+    }
+    default:
+        break;
+    }
+
+    if (!present) {
+        // Some modules may not respond to probes while still streaming NMEA, so
+        // allow a passive fallback check.
+        present = sawNmeaSentenceAtBaud(_serial_gps, 3000);
+    }
+    if (!present) {
+        LOG_WARN("Cached GPS probe is stale (%s @ %d), clearing cache", cachedProbeModelName, cachedProbeBaud);
+        clearProbeCache();
+        cachedProbeFailedThisBoot = true;
+        return false;
+    }
+
+    detectedBaud = cachedProbeBaud;
+    gnssModel = cachedProbeModel;
+    LOG_INFO("Using cached GPS probe: %s @ %d", cachedProbeModelName, detectedBaud);
+    return true;
+}
+
 /**
  * @brief  Setup the GPS based on the model detected.
  *  We detect the GPS by cycling through a set of baud rates, first common then rare.
@@ -503,25 +762,46 @@ bool GPS::setup()
 {
     if (!didSerialInit) {
         int msglen = 0;
+        if (cachedProbeFailedThisBoot) {
+            // If cached verification failed, suppress further probing until
+            // reboot.
+            didSerialInit = true;
+            return true;
+        }
+
         if (tx_gpio && gnssModel == GNSS_MODEL_UNKNOWN) {
-            if (probeTries < GPS_PROBETRIES) {
+            if (!hasProbeCache && !triedProbeCache) {
+                (void)loadProbeCache();
+            }
+
+            if (hasProbeCache && !triedProbeCache) {
+                triedProbeCache = true;
+                if (!verifyCachedProbePresence()) {
+                    // Cache was stale and got wiped; skip scanning this boot
+                    // and let next boot do a full probe.
+                    didSerialInit = true;
+                    return true;
+                }
+            } else if (probeTries < GPS_PROBETRIES) {
+                // No usable cache: walk common baud rates first.
                 gnssModel = probe(serialSpeeds[speedSelect]);
-                if (gnssModel == GNSS_MODEL_UNKNOWN) {
-                    if (currentStep == 0 && ++speedSelect == array_count(serialSpeeds)) {
-                        speedSelect = 0;
-                        ++probeTries;
-                    }
+                if (gnssModel != GNSS_MODEL_UNKNOWN) {
+                    detectedBaud = serialSpeeds[speedSelect];
+                } else if (currentStep == 0 && ++speedSelect == array_count(serialSpeeds)) {
+                    speedSelect = 0;
+                    ++probeTries;
                 }
             }
             // Rare Serial Speeds
 #ifndef CONFIG_IDF_TARGET_ESP32C6
-            if (probeTries == GPS_PROBETRIES) {
+            else if (probeTries == GPS_PROBETRIES) {
+                // Then try less common baud rates before giving up.
                 gnssModel = probe(rareSerialSpeeds[speedSelect]);
-                if (gnssModel == GNSS_MODEL_UNKNOWN) {
-                    if (currentStep == 0 && ++speedSelect == array_count(rareSerialSpeeds)) {
-                        LOG_WARN("Give up on GPS probe and set to %d", GPS_BAUDRATE);
-                        return true;
-                    }
+                if (gnssModel != GNSS_MODEL_UNKNOWN) {
+                    detectedBaud = rareSerialSpeeds[speedSelect];
+                } else if (currentStep == 0 && ++speedSelect == array_count(rareSerialSpeeds)) {
+                    LOG_WARN("Give up on GPS probe and set to %d", GPS_BAUDRATE);
+                    return true;
                 }
             }
 #endif
@@ -529,6 +809,7 @@ bool GPS::setup()
 
         if (gnssModel != GNSS_MODEL_UNKNOWN) {
             setConnected();
+            (void)saveProbeCache();
         } else {
             return false;
         }
@@ -1102,6 +1383,12 @@ int32_t GPS::runOnce()
         if (!setup())
             return currentDelay; // Setup failed, re-run in two seconds
 
+        if (cachedProbeFailedThisBoot || gnssModel == GNSS_MODEL_UNKNOWN) {
+            LOG_WARN("GPS not detected at cached settings; marked not present "
+                     "for this boot");
+            return disable();
+        }
+
         // We have now loaded our saved preferences from flash
         if (config.position.gps_mode != meshtastic_Config_PositionConfig_GpsMode_ENABLED) {
             return disable();

src/gps/GPS.h

@@ -155,8 +155,19 @@ class GPS : private concurrency::OSThread
      * @return true if we've acquired a new location
      */
     virtual bool lookForLocation();
+    // Load persisted GPS model+baud from /prefs.
+    bool loadProbeCache();
+    // Clear persisted GPS model+baud cache.
+    void clearProbeCache();
+    // Persist the currently detected GPS model+baud.
+    bool saveProbeCache() const;
+    // Verify the cached model+baud still maps to a live GPS device.
+    bool verifyCachedProbePresence();
 
     GnssModel_t gnssModel = GNSS_MODEL_UNKNOWN;
+    int32_t detectedBaud = GPS_BAUDRATE;
+    int32_t cachedProbeBaud = 0;
+    GnssModel_t cachedProbeModel = GNSS_MODEL_UNKNOWN;
 
     TinyGPSPlus reader;
     uint8_t fixQual = 0; // fix quality from GPGGA
@@ -178,6 +189,12 @@ class GPS : private concurrency::OSThread
 
     uint8_t speedSelect = 0;
     uint8_t probeTries = 0;
+    // Cache file is successfully loaded.
+    bool hasProbeCache = false;
+    // Ensures cached probe is attempted once per boot.
+    bool triedProbeCache = false;
+    // Latched when cached presence check fails
+    bool cachedProbeFailedThisBoot = false;
 
     /**
      * hasValidLocation - indicates that the position variables contain a complete

src/graphics/Screen.h

@@ -12,7 +12,7 @@
 #define getStringCenteredX(s) ((SCREEN_WIDTH - display->getStringWidth(s)) / 2)
 namespace graphics
 {
-enum notificationTypeEnum { none, text_banner, selection_picker, node_picker, number_picker, text_input };
+enum notificationTypeEnum { none, text_banner, selection_picker, node_picker, number_picker, hex_picker, text_input };
 
 struct BannerOverlayOptions {
     const char *message;

src/graphics/SharedUIDisplay.cpp

@@ -578,7 +578,11 @@ void drawCommonFooter(OLEDDisplay *display, int16_t x, int16_t y)
 #endif
 
     display->setColor(BLACK);
+#if GRAPHICS_TFT_COLORING_ENABLED
     display->fillRect(0, footerY, SCREEN_WIDTH, footerH);
+#else
+    display->fillRect(0, footerY, connection_icon_width + 1, footerH);
+#endif
     display->setColor(WHITE);
     if (currentResolution == ScreenResolution::High) {
         const int bytesPerRow = (connection_icon_width + 7) / 8;

src/graphics/draw/ClockRenderer.cpp

@@ -183,9 +183,13 @@ void drawDigitalClockFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int1
     static float segmentHeight = SEGMENT_HEIGHT * 0.75f;
 
     if (!scaleInitialized) {
+#ifdef DISPLAY_FORCE_SMALL_FONTS
+        float screenwidth_target_ratio = 0.70f; // Target 70% of display width (adjustable)
+#else
         float screenwidth_target_ratio = 0.80f; // Target 80% of display width (adjustable)
-        float max_scale = 3.5f;                 // Safety limit to avoid runaway scaling
-        float step = 0.05f;                     // Step increment per iteration
+#endif
+        float max_scale = 3.5f; // Safety limit to avoid runaway scaling
+        float step = 0.05f;     // Step increment per iteration
 
         float target_width = display->getWidth() * screenwidth_target_ratio;
         float target_height =

src/graphics/draw/MenuHandler.cpp

@@ -126,6 +126,7 @@ void launchReplyForMessage(const StoredMessage &message, bool freetext)
 
 menuHandler::screenMenus menuHandler::menuQueue = MenuNone;
 uint32_t menuHandler::pickedNodeNum = 0;
+meshtastic_Config_LoRaConfig_RegionCode menuHandler::pendingRegion = meshtastic_Config_LoRaConfig_RegionCode_UNSET;
 bool test_enabled = false;
 uint8_t test_count = 0;
 
@@ -174,6 +175,36 @@ void menuHandler::OnboardMessage()
     screen->showOverlayBanner(bannerOptions);
 }
 
+static void applyLoraRegion(meshtastic_Config_LoRaConfig_RegionCode region, bool isHam)
+{
+    config.lora.region = region;
+    config.lora.channel_num = 0; // Reset to default channel
+
+    if (isHam && adminModule) {
+        meshtastic_HamParameters hamParams = meshtastic_HamParameters_init_zero;
+        strncpy(hamParams.call_sign, "N0CALL", sizeof(hamParams.call_sign) - 1);
+        strncpy(hamParams.short_name, "N0CL", sizeof(hamParams.short_name));
+        hamParams.tx_power = config.lora.tx_power;
+        hamParams.frequency = config.lora.override_frequency;
+        adminModule->handleSetHamMode(hamParams);
+    }
+    auto changes = SEGMENT_CONFIG;
+#if !(MESHTASTIC_EXCLUDE_PKI_KEYGEN || MESHTASTIC_EXCLUDE_PKI)
+    if (crypto) {
+        crypto->ensurePkiKeys(config.security, owner);
+    }
+#endif
+    initRegion();
+    if (getEffectiveDutyCycle() < 100) {
+        config.lora.ignore_mqtt = true;
+    }
+    if (strncmp(moduleConfig.mqtt.root, default_mqtt_root, strlen(default_mqtt_root)) == 0) {
+        sprintf(moduleConfig.mqtt.root, "%s/%s", default_mqtt_root, myRegion->name);
+        changes |= SEGMENT_MODULECONFIG;
+    }
+    service->reloadConfig(changes);
+}
+
 void menuHandler::LoraRegionPicker(uint32_t duration)
 {
     static const LoraRegionOption regionOptions[] = {
@@ -242,27 +273,20 @@ void menuHandler::LoraRegionPicker(uint32_t duration)
                 return;
             }
 
-            config.lora.region = selectedRegion;
-            auto changes = SEGMENT_CONFIG;
-
-#if !(MESHTASTIC_EXCLUDE_PKI_KEYGEN || MESHTASTIC_EXCLUDE_PKI)
-            if (crypto) {
-                crypto->ensurePkiKeys(config.security, owner);
+            bool hamMode = getRegion(selectedRegion)->profile->licensedOnly;
+            if (hamMode) {
+                LOG_INFO("User chose an amateur radio mode region");
+                pendingRegion = selectedRegion;
+                menuQueue = HamModeConfirm;
+                screen->runNow();
+            } else if (owner.is_licensed) {
+                LOG_INFO("Licensed user chose a non-ham region; prompting to revert licensed mode");
+                pendingRegion = selectedRegion;
+                menuQueue = LicensedToNormalConfirm;
+                screen->runNow();
+            } else {
+                applyLoraRegion(selectedRegion, false);
             }
-#endif
-            config.lora.tx_enabled = true;
-            initRegion();
-            if (getEffectiveDutyCycle() < 100) {
-                config.lora.ignore_mqtt = true; // Ignore MQTT by default if region has a duty cycle limit
-            }
-
-            if (strncmp(moduleConfig.mqtt.root, default_mqtt_root, strlen(default_mqtt_root)) == 0) {
-                //  Default broker is in use, so subscribe to the appropriate MQTT root topic for this region
-                sprintf(moduleConfig.mqtt.root, "%s/%s", default_mqtt_root, myRegion->name);
-                changes |= SEGMENT_MODULECONFIG;
-            }
-
-            service->reloadConfig(changes);
         });
 
     bannerOptions.durationMs = duration;
@@ -279,6 +303,38 @@ void menuHandler::LoraRegionPicker(uint32_t duration)
     screen->showOverlayBanner(bannerOptions);
 }
 
+void menuHandler::hamModeConfirmMenu()
+{
+    static const char *confirmOptions[] = {"No", "Yes"};
+    BannerOverlayOptions confirmBanner;
+    confirmBanner.message = "I confirm I am a\nlicensed amateur\nradio operator";
+    confirmBanner.optionsArrayPtr = confirmOptions;
+    confirmBanner.optionsCount = 2;
+    confirmBanner.bannerCallback = [](int selected) {
+        if (selected == 1)
+            applyLoraRegion(pendingRegion, true);
+    };
+    screen->showOverlayBanner(confirmBanner);
+}
+
+void menuHandler::licensedToNormalConfirmMenu()
+{
+    static const char *confirmOptions[] = {"Keep licensed", "Revert to Normal"};
+    BannerOverlayOptions confirmBanner;
+    confirmBanner.message = "Revert licensed\nmode? This will\nre-enable encryption.";
+    confirmBanner.optionsArrayPtr = confirmOptions;
+    confirmBanner.optionsCount = 2;
+    confirmBanner.bannerCallback = [](int selected) {
+        if (selected == 1) {
+            owner.is_licensed = false;
+            config.lora.override_duty_cycle = false;
+            service->reloadOwner(false);
+        }
+        applyLoraRegion(pendingRegion, false);
+    };
+    screen->showOverlayBanner(confirmBanner);
+}
+
 void menuHandler::deviceRolePicker()
 {
     static const char *optionsArray[] = {"Back", "Client", "Client Mute", "Lost and Found", "Tracker"};
@@ -2822,6 +2878,12 @@ void menuHandler::handleMenuSwitch(OLEDDisplay *display)
     case ThemeMenu:
         themeMenu();
         break;
+    case HamModeConfirm:
+        hamModeConfirmMenu();
+        break;
+    case LicensedToNormalConfirm:
+        licensedToNormalConfirmMenu();
+        break;
     }
     menuQueue = MenuNone;
 }

src/graphics/draw/MenuHandler.h

@@ -55,10 +55,13 @@ class menuHandler
         FrameToggles,
         DisplayUnits,
         MessageBubblesMenu,
-        ThemeMenu
+        ThemeMenu,
+        HamModeConfirm,
+        LicensedToNormalConfirm
     };
     static screenMenus menuQueue;
     static uint32_t pickedNodeNum; // node selected by NodePicker for ManageNodeMenu
+    static meshtastic_Config_LoRaConfig_RegionCode pendingRegion;
 
     static void OnboardMessage();
     static void LoraRegionPicker(uint32_t duration = 30000);
@@ -111,6 +114,8 @@ class menuHandler
     static void messageBubblesMenu();
     static void themeMenu();
     static void textMessageMenu();
+    static void hamModeConfirmMenu();
+    static void licensedToNormalConfirmMenu();
 
   private:
     static void saveUIConfig();

src/graphics/draw/NotificationRenderer.cpp

@@ -66,6 +66,15 @@ uint32_t pow_of_10(uint32_t n)
     return ret;
 }
 
+uint64_t pow_of_16(uint32_t n)
+{
+    uint64_t ret = 1;
+    for (uint32_t i = 0; i < n; i++) {
+        ret *= 16ULL;
+    }
+    return ret;
+}
+
 char graphics::NotificationRenderer::alertBannerLines[MAX_LINES + 1][64] = {};
 uint8_t graphics::NotificationRenderer::alertBannerLineCount = 0;
 graphics::NotificationRenderer::BannerFont graphics::NotificationRenderer::alertBannerLineFonts[MAX_LINES + 1] = {};
@@ -259,6 +268,9 @@ void NotificationRenderer::drawBannercallback(OLEDDisplay *display, OLEDDisplayU
     case notificationTypeEnum::number_picker:
         drawNumberPicker(display, state);
         break;
+    case notificationTypeEnum::hex_picker:
+        drawHexPicker(display, state);
+        break;
     }
 }
 
@@ -345,6 +357,105 @@ void NotificationRenderer::drawNumberPicker(OLEDDisplay *display, OLEDDisplayUiS
     drawNotificationBox(display, state, linePointers, totalLines, 0);
 }
 
+void NotificationRenderer::drawHexPicker(OLEDDisplay *display, OLEDDisplayUiState *state)
+{
+    const char *lineStarts[MAX_LINES + 1] = {0};
+    uint16_t lineCount = 0;
+
+    // Parse lines
+    char *alertEnd = alertBannerMessage + strnlen(alertBannerMessage, sizeof(alertBannerMessage));
+    lineStarts[lineCount] = alertBannerMessage;
+
+    // Find lines
+    while ((lineCount < MAX_LINES) && (lineStarts[lineCount] < alertEnd)) {
+        lineStarts[lineCount + 1] = std::find((char *)lineStarts[lineCount], alertEnd, '\n');
+        if (lineStarts[lineCount + 1][0] == '\n')
+            lineStarts[lineCount + 1] += 1;
+        lineCount++;
+    }
+    // modulo to extract
+    uint8_t this_digit = (currentNumber % (pow_of_16(numDigits - curSelected))) / (pow_of_16(numDigits - curSelected - 1));
+    // Handle input
+    if (inEvent.inputEvent == INPUT_BROKER_UP || inEvent.inputEvent == INPUT_BROKER_ALT_PRESS ||
+        inEvent.inputEvent == INPUT_BROKER_UP_LONG) {
+        if (this_digit == 15) {
+            currentNumber -= 15 * (pow_of_16(numDigits - curSelected - 1));
+        } else {
+            currentNumber += (pow_of_16(numDigits - curSelected - 1));
+        }
+    } else if (inEvent.inputEvent == INPUT_BROKER_DOWN || inEvent.inputEvent == INPUT_BROKER_USER_PRESS ||
+               inEvent.inputEvent == INPUT_BROKER_DOWN_LONG) {
+        if (this_digit == 0) {
+            currentNumber += 15 * (pow_of_16(numDigits - curSelected - 1));
+        } else {
+            currentNumber -= (pow_of_16(numDigits - curSelected - 1));
+        }
+    } else if (inEvent.inputEvent == INPUT_BROKER_ANYKEY) {
+        if (inEvent.kbchar > 47 && inEvent.kbchar < 58) { // have a digit
+            currentNumber -= this_digit * (pow_of_16(numDigits - curSelected - 1));
+            currentNumber += (inEvent.kbchar - 48) * (pow_of_16(numDigits - curSelected - 1));
+            curSelected++;
+        }
+    } else if (inEvent.inputEvent == INPUT_BROKER_SELECT || inEvent.inputEvent == INPUT_BROKER_RIGHT) {
+        curSelected++;
+    } else if (inEvent.inputEvent == INPUT_BROKER_LEFT) {
+        curSelected--;
+    } else if ((inEvent.inputEvent == INPUT_BROKER_CANCEL || inEvent.inputEvent == INPUT_BROKER_ALT_LONG) &&
+               alertBannerUntil != 0) {
+        resetBanner();
+        return;
+    }
+    if (curSelected == static_cast<int8_t>(numDigits)) {
+        alertBannerCallback(currentNumber);
+        resetBanner();
+        return;
+    }
+
+    inEvent.inputEvent = INPUT_BROKER_NONE;
+    if (alertBannerMessage[0] == '\0')
+        return;
+
+    uint16_t totalLines = lineCount + 2;
+    const char *linePointers[totalLines + 1] = {0}; // this is sort of a dynamic allocation
+
+    // copy the linestarts to display to the linePointers holder
+    for (uint16_t i = 0; i < lineCount; i++) {
+        linePointers[i] = lineStarts[i];
+    }
+    std::string digits = " ";
+    std::string arrowPointer = " ";
+    for (uint16_t i = 0; i < numDigits; i++) {
+        // Modulo minus modulo to return just the current number
+        uint8_t digitValue = (currentNumber % (pow_of_16(numDigits - i))) / (pow_of_16(numDigits - i - 1));
+        if (digitValue < 10) {
+            digits += std::to_string(digitValue) + " ";
+        } else if (digitValue == 10) {
+            digits += "A ";
+        } else if (digitValue == 11) {
+            digits += "B ";
+        } else if (digitValue == 12) {
+            digits += "C ";
+        } else if (digitValue == 13) {
+            digits += "D ";
+        } else if (digitValue == 14) {
+            digits += "E ";
+        } else if (digitValue == 15) {
+            digits += "F ";
+        }
+
+        if (curSelected == i) {
+            arrowPointer += "^ ";
+        } else {
+            arrowPointer += "_ ";
+        }
+    }
+
+    linePointers[lineCount++] = digits.c_str();
+    linePointers[lineCount++] = arrowPointer.c_str();
+
+    drawNotificationBox(display, state, linePointers, totalLines, 0);
+}
+
 void NotificationRenderer::drawNodePicker(OLEDDisplay *display, OLEDDisplayUiState *state)
 {
     static uint32_t selectedNodenum = 0;

src/graphics/draw/NotificationRenderer.h

@@ -42,6 +42,7 @@ class NotificationRenderer
     static void drawBannercallback(OLEDDisplay *display, OLEDDisplayUiState *state);
     static void drawAlertBannerOverlay(OLEDDisplay *display, OLEDDisplayUiState *state);
     static void drawNumberPicker(OLEDDisplay *display, OLEDDisplayUiState *state);
+    static void drawHexPicker(OLEDDisplay *display, OLEDDisplayUiState *state);
     static void drawNodePicker(OLEDDisplay *display, OLEDDisplayUiState *state);
     static void drawTextInput(OLEDDisplay *display, OLEDDisplayUiState *state);
     static void drawNotificationBox(OLEDDisplay *display, OLEDDisplayUiState *state, const char *lines[MAX_LINES + 1],

src/graphics/draw/UIRenderer.cpp

@@ -79,10 +79,12 @@ static inline void transformNeedlePoint(float localX, float localY, float sinHea
     outY = static_cast<int16_t>(y);
 }
 
+#if GRAPHICS_TFT_COLORING_ENABLED
 static float getCompassRingAngleOffset(float heading)
 {
     return (uiconfig.compass_mode != meshtastic_CompassMode_FIXED_RING) ? -heading : 0.0f;
 }
+#endif
 
 static inline StandardCompassNeedlePoints computeStandardCompassNeedlePoints(int16_t compassX, int16_t compassY,
                                                                              uint16_t compassDiam, float headingRadian,
@@ -1142,11 +1144,16 @@ void UIRenderer::drawDeviceFocused(OLEDDisplay *display, OLEDDisplayUiState *sta
     bool origBold = config.display.heading_bold;
     config.display.heading_bold = false;
 
-    // Display Region and Channel Utilization
-    if (currentResolution == ScreenResolution::UltraLow) {
-        drawNodes(display, x, getTextPositions(display)[line] + 2, nodeStatus, -1, false, "online");
+    if (!config.lora.tx_enabled) {
+        const char *txdisabled = "Transmit Disabled";
+        display->drawString(x, getTextPositions(display)[line], txdisabled);
     } else {
-        drawNodes(display, x + 1, getTextPositions(display)[line] + 2, nodeStatus, -1, false, "online");
+        // Display Region and Channel Utilization
+        if (currentResolution == ScreenResolution::UltraLow) {
+            drawNodes(display, x, getTextPositions(display)[line] + 2, nodeStatus, -1, false, "online");
+        } else {
+            drawNodes(display, x + 1, getTextPositions(display)[line] + 2, nodeStatus, -1, false, "online");
+        }
     }
     char uptimeStr[32] = "";
     if (currentResolution != ScreenResolution::UltraLow) {

src/mesh/NodeDB.cpp

@@ -1542,6 +1542,8 @@ void NodeDB::pickNewNodeNum()
 
     // Identity check via public key (or "empty slot?" when no keys yet);
     // macaddr no longer lives on the slim header.
+    // This check does not work when is_licensed=true since we don't store a public key.
+    // Revisit with XEdDSA signing.
     auto isOurOwnEntry = [&](const meshtastic_NodeInfoLite *n) -> bool {
         if (!n)
             return false;
@@ -1550,13 +1552,16 @@ void NodeDB::pickNewNodeNum()
         return !nodeInfoLiteHasUser(n);
     };
 
-    meshtastic_NodeInfoLite *found;
-    while (((found = getMeshNode(nodeNum)) && !isOurOwnEntry(found)) ||
-           (nodeNum == NODENUM_BROADCAST || nodeNum < NUM_RESERVED)) {
-        NodeNum candidate = random(NUM_RESERVED, LONG_MAX); // try a new random choice
-        if (found)
-            LOG_WARN("NOTE! Our desired nodenum 0x%x is invalid or in use, picking 0x%x", nodeNum, candidate);
-        nodeNum = candidate;
+    // Short circuit the check for licensed devices since they do not have public keys to compare against the nodeDB.
+    if (!owner.is_licensed) {
+        meshtastic_NodeInfoLite *found;
+        while (((found = getMeshNode(nodeNum)) && !isOurOwnEntry(found)) ||
+               (nodeNum == NODENUM_BROADCAST || nodeNum < NUM_RESERVED)) {
+            NodeNum candidate = random(NUM_RESERVED, LONG_MAX); // try a new random choice
+            if (found)
+                LOG_WARN("NOTE! Our desired nodenum 0x%x is invalid or in use, picking 0x%x", nodeNum, candidate);
+            nodeNum = candidate;
+        }
     }
     LOG_DEBUG("Use nodenum 0x%x ", nodeNum);
 
@@ -1989,6 +1994,14 @@ bool NodeDB::saveDeviceStateToDisk()
 
 bool NodeDB::saveNodeDatabaseToDisk()
 {
+    // Don't persist the node DB until this device has a PKI keypair
+    // TODO: revisit when https://github.com/meshtastic/firmware/pull/10478 lands
+#if !(MESHTASTIC_EXCLUDE_PKI_KEYGEN || MESHTASTIC_EXCLUDE_PKI)
+    if (owner.public_key.size != 32 && !owner.is_licensed) {
+        LOG_DEBUG("Skip NodeDB without key");
+        return true;
+    }
+#endif
 
     // do not try to save anything if power level is not safe. In many cases flash will be lock-protected
     // and all writes will fail anyway. Device should be sleeping at this point anyway.

src/mesh/generated/meshtastic/mesh.pb.h

@@ -621,7 +621,9 @@ typedef enum _meshtastic_MeshPacket_TransportMechanism {
     /* Arrived via Multicast UDP */
     meshtastic_MeshPacket_TransportMechanism_TRANSPORT_MULTICAST_UDP = 6,
     /* Arrived via API connection */
-    meshtastic_MeshPacket_TransportMechanism_TRANSPORT_API = 7
+    meshtastic_MeshPacket_TransportMechanism_TRANSPORT_API = 7,
+    /* Arrived via Unicast UDP */
+    meshtastic_MeshPacket_TransportMechanism_TRANSPORT_UNICAST_UDP = 8
 } meshtastic_MeshPacket_TransportMechanism;
 
 /* Log levels, chosen to match python logging conventions. */
@@ -1532,8 +1534,8 @@ extern "C" {
 #define _meshtastic_MeshPacket_Delayed_ARRAYSIZE ((meshtastic_MeshPacket_Delayed)(meshtastic_MeshPacket_Delayed_DELAYED_DIRECT+1))
 
 #define _meshtastic_MeshPacket_TransportMechanism_MIN meshtastic_MeshPacket_TransportMechanism_TRANSPORT_INTERNAL
-#define _meshtastic_MeshPacket_TransportMechanism_MAX meshtastic_MeshPacket_TransportMechanism_TRANSPORT_API
-#define _meshtastic_MeshPacket_TransportMechanism_ARRAYSIZE ((meshtastic_MeshPacket_TransportMechanism)(meshtastic_MeshPacket_TransportMechanism_TRANSPORT_API+1))
+#define _meshtastic_MeshPacket_TransportMechanism_MAX meshtastic_MeshPacket_TransportMechanism_TRANSPORT_UNICAST_UDP
+#define _meshtastic_MeshPacket_TransportMechanism_ARRAYSIZE ((meshtastic_MeshPacket_TransportMechanism)(meshtastic_MeshPacket_TransportMechanism_TRANSPORT_UNICAST_UDP+1))
 
 #define _meshtastic_LogRecord_Level_MIN meshtastic_LogRecord_Level_UNSET
 #define _meshtastic_LogRecord_Level_MAX meshtastic_LogRecord_Level_CRITICAL

src/modules/AdminModule.cpp

@@ -1463,6 +1463,10 @@ void AdminModule::handleSetHamMode(const meshtastic_HamParameters &p)
     }
     channels.onConfigChanged();
 
+    if (strcmp(p.call_sign, "N0CALL") == 0) {
+        config.lora.tx_enabled = false;
+    }
+
     service->reloadOwner(false);
     saveChanges(SEGMENT_CONFIG | SEGMENT_NODEDATABASE | SEGMENT_DEVICESTATE | SEGMENT_CHANNELS);
 }

src/modules/AdminModule.h

@@ -67,7 +67,11 @@ class AdminModule : public ProtobufModule<meshtastic_AdminMessage>, public Obser
   private:
     bool handleSetModuleConfig(const meshtastic_ModuleConfig &c);
     void handleSetChannel();
+
+  public:
     void handleSetHamMode(const meshtastic_HamParameters &req);
+
+  private:
     void handleStoreDeviceUIConfig(const meshtastic_DeviceUIConfig &uicfg);
     void handleSendInputEvent(const meshtastic_AdminMessage_InputEvent &inputEvent);
     void reboot(int32_t seconds);

src/modules/Modules.cpp

@@ -107,10 +107,6 @@
 #include "modules/StatusMessageModule.h"
 #endif
 
-#if !MESHTASTIC_EXCLUDE_ZPS
-#include "modules/esp32/ZPSModule.h"
-#endif
-
 #if defined(HAS_HARDWARE_WATCHDOG)
 #include "watchdog/watchdogThread.h"
 #endif
@@ -185,9 +181,6 @@ void setupModules()
 #if !MESHTASTIC_EXCLUDE_STATUS
     statusMessageModule = new StatusMessageModule();
 #endif
-#if !MESHTASTIC_EXCLUDE_ZPS
-        zpsModule = new ZPSModule();
-#endif
 #if !MESHTASTIC_EXCLUDE_GENERIC_THREAD_MODULE
     new GenericThreadModule();
 #endif

src/modules/esp32/ZPSModule.cpp

@@ -1,429 +0,0 @@
-/*
- * ZPS - Zero-GPS Positioning System for standalone Meshtastic devices
- * - experimental tools for estimating own position without a GPS -
- *
- * Copyright 2021 all rights reserved by https://github.com/a-f-G-U-C
- * Released under GPL v3 (see LICENSE file for details)
- */
-
-#if defined(ARCH_ESP32) && !MESHTASTIC_EXCLUDE_ZPS
-
-#include "ZPSModule.h"
-#include "Default.h"
-#include "MeshService.h"
-#include "NodeDB.h"
-#include "NodeStatus.h"
-#include "Router.h"
-#include "configuration.h"
-#include "gps/RTC.h"
-#include <WiFi.h>
-
-#if !defined(MESHTASTIC_EXCLUDE_BLUETOOTH)
-
-// Use the bundled NimBLE host stack directly (matching src/nimble/NimbleBluetooth.cpp).
-// The external h2zero NimBLE-Arduino library (NimBLEDevice.h) is in lib_ignore since the
-// pioarduino / arduino-esp32 3.x migration, so we talk to the raw host APIs instead.
-#include "host/ble_gap.h"
-#include "host/ble_hs.h"
-#include "host/ble_hs_adv.h"
-#include "host/ble_hs_id.h"
-
-#define BLE_MAX_REC 15
-#define BLE_NO_RESULTS -1 // Indicates a BLE scan is in progress
-
-uint8_t bleCounter = 0; // used internally by the ble scanner
-uint64_t bleResult[BLE_MAX_REC + 1];
-int bleResSize = BLE_NO_RESULTS;
-
-uint64_t scanStart = 0;
-
-ZPSModule *zpsModule;
-
-// Mini BLE scanner, NIMBLE based and modelled loosely after the Wifi scanner
-static int ble_scan(uint32_t duration, bool passive = true, bool dedup = true);
-
-// ZPSModule::ZPSModule()
-//     : ProtobufModule("ZPS", ZPS_PORTNUM, Position_fields), concurrency::OSThread("ZPSModule")
-ZPSModule::ZPSModule() : SinglePortModule("ZPS", ZPS_PORTNUM), concurrency::OSThread("ZPSModule")
-{
-    setIntervalFromNow(ZPS_STARTUP_DELAY); // Delay startup by 10 seconds, no need to race :)
-
-    wantBSS = true;
-    wantBLE = true;
-
-    WiFi.mode(WIFI_STA);
-    WiFi.disconnect();
-    WiFi.scanNetworks(true, true); // nonblock, showhidden
-    scanState = SCAN_BSS_RUN;
-}
-
-ProcessMessage ZPSModule::handleReceived(const meshtastic_MeshPacket &mp)
-{
-    meshtastic_Position pos = meshtastic_Position_init_default;
-
-    auto &pd = mp.decoded;
-    uint8_t nRecs = pd.payload.size >> 3;
-
-    LOG_DEBUG("handleReceived %s 0x%0x->0x%0x, id=0x%x, port=%d, len=%d, rec=%d\n", name, mp.from, mp.to, mp.id, pd.portnum,
-              pd.payload.size, nRecs);
-    if (nRecs > ZPS_DATAPKT_MAXITEMS)
-        nRecs = ZPS_DATAPKT_MAXITEMS;
-    memcpy(&netData, pd.payload.bytes, nRecs << 3);
-
-    // Currently we are unable to act as a position server, so we're
-    // not interested in broadcasts (this will change later)
-    if (mp.to != nodeDB->getNodeNum()) {
-        // Message is not for us, won't process
-        return ProcessMessage::CONTINUE;
-    }
-
-#ifdef ZPS_EXTRAVERBOSE
-    for (int i = 0; i < nRecs; i++) {
-        LOG_DEBUG("ZPS[%d]: %08x"
-                  "%08x\n",
-                  i, (uint32_t)(netData[i] >> 32), (uint32_t)netData[i]);
-    }
-#endif
-
-    if ((netData[0] & 0x800000000000) && (nRecs >= 2)) {
-        // message contains a position
-        pos.PDOP = (netData[0] >> 40) & 0x7f;
-        pos.timestamp = netData[0] & 0xffffffff;
-        // second int64 encodes lat and lon
-        pos.longitude_i = (int32_t)(netData[1] & 0xffffffff);
-        pos.latitude_i = (int32_t)((netData[1] >> 32) & 0xffffffff);
-
-        // FIXME should be conditional, to ensure we don't overwrite a good GPS fix!
-        LOG_DEBUG("ZPS lat/lon/dop/pts %d/%d/%d/%d\n", pos.latitude_i, pos.longitude_i, pos.PDOP, pos.timestamp);
-
-        // Some required fields
-        pos.time = getTime();
-        pos.location_source = meshtastic_Position_LocSource_LOC_EXTERNAL;
-
-        // don't update position if my gps fix is valid
-        if (nodeDB->hasValidPosition(nodeDB->getMeshNode(nodeDB->getNodeNum()))) {
-            LOG_DEBUG("ZPSModule::handleReceived: ignoring position update, GPS is valid\n");
-            return ProcessMessage::CONTINUE;
-        }
-        nodeDB->updatePosition(nodeDB->getNodeNum(), pos);
-    } else {
-        // nothing we can do - for now
-        return ProcessMessage::CONTINUE;
-    }
-
-    return ProcessMessage::CONTINUE; // Let others look at this message also if they want
-}
-
-meshtastic_MeshPacket *ZPSModule::allocReply()
-{
-    meshtastic_MeshPacket *p = allocDataPacket();
-    p->decoded.payload.size = (netRecs + 2) << 3; // actually can be only +1 if no GPS data
-
-    LOG_DEBUG("Allocating dataPacket for %d items, %d bytes\n", netRecs, p->decoded.payload.size);
-    memcpy(p->decoded.payload.bytes, &netData, p->decoded.payload.size);
-
-    return (p);
-}
-
-void ZPSModule::sendDataPacket(NodeNum dest, bool wantReplies)
-{
-    // cancel any not yet sent (now stale) position packets
-    if (prevPacketId)
-        service->cancelSending(prevPacketId);
-
-    meshtastic_MeshPacket *p = allocReply();
-    p->to = dest;
-    p->decoded.portnum = meshtastic_PortNum_ZPS_APP;
-    p->decoded.want_response = wantReplies;
-    p->priority = meshtastic_MeshPacket_Priority_BACKGROUND;
-    prevPacketId = p->id;
-
-    service->sendToMesh(p, RX_SRC_LOCAL);
-}
-
-int32_t ZPSModule::runOnce()
-{
-    meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(nodeDB->getNodeNum());
-    assert(node);
-
-    // LOG_DEBUG("ZPSModule::runOnce() START, scanState: %d\n", (int) scanState);
-
-    int numWifi = 0;
-
-    if (scanState == SCAN_BSS_RUN) {
-        // check completion status of any running Wifi scan
-        numWifi = WiFi.scanComplete();
-
-        if (numWifi >= 0) {
-            // scan is complete
-            LOG_DEBUG("%d BSS found\n", numWifi);
-            LOG_DEBUG("BSS scan done in %d millis\n", millis() - scanStart);
-
-            if (wantBSS && haveBSS) {
-                // old data exists, overwrite it
-                netRecs = 0;
-                haveBSS = haveBLE = false;
-            }
-
-            for (int i = 0; i < numWifi; i++) {
-                // pack each Wifi network record into a 64-bit int
-                uint64_t netBytes = encodeBSS(WiFi.BSSID(i), WiFi.channel(i), abs(WiFi.RSSI(i)));
-
-                if (wantBSS) {
-                    // load into outbound array if needed
-                    outBufAdd(netBytes);
-                    haveBSS = true;
-                }
-#ifdef ZPS_EXTRAVERBOSE
-                LOG_DEBUG("BSS[%02d]: %08x"
-                          "%08x\n",
-                          i, (uint32_t)(netBytes >> 32), (uint32_t)netBytes);
-#endif
-            }
-
-            WiFi.scanDelete();
-            scanState = SCAN_BSS_DONE;
-
-#ifdef ZPS_EXTRAVERBOSE
-        } else if (numWifi == -1) {
-            // LOG_DEBUG("BSS scan in-progress\n");
-        } else {
-            LOG_DEBUG("BSS scan state=%d\n", numWifi);
-#endif
-        }
-    }
-
-    if ((scanState == SCAN_BLE_RUN) && (bleResSize >= 0)) {
-        // completion status checked above (bleResSize >= 0)
-        LOG_DEBUG("BLE scan done in %d millis\n", millis() - scanStart);
-        scanState = SCAN_BLE_DONE;
-
-        if (wantBLE && haveBLE) {
-            // old data exists, overwrite it
-            netRecs = 0;
-            haveBSS = haveBLE = false;
-        }
-
-        for (int i = 0; i < bleResSize; i++) {
-            // load data into output array if needed
-            if (wantBLE) {
-                outBufAdd(bleResult[i]);
-                haveBLE = true;
-            }
-#ifdef ZPS_EXTRAVERBOSE
-            LOG_DEBUG("BLE[%d]: %08x"
-                      "%08x\n",
-                      i, (uint32_t)(bleResult[i] >> 32), (uint32_t)bleResult[i]);
-#endif
-        }
-
-        // Reset the counter once we're done with the dataset
-        bleResSize = BLE_NO_RESULTS;
-    }
-
-    // Are we finished assembling that packet? Then send it out
-    if ((wantBSS == haveBSS) && (wantBLE == haveBLE) &&
-        airTime->isTxAllowedChannelUtil(config.device.role != meshtastic_Config_DeviceConfig_Role_SENSOR) &&
-        airTime->isTxAllowedAirUtil() &&
-        (lastSend == 0 || millis() - lastSend >= Default::getConfiguredOrDefaultMsScaled(config.position.position_broadcast_secs,
-                                                                                         default_broadcast_interval_secs,
-                                                                                         nodeStatus->getNumOnline()))) {
-
-        haveBSS = haveBLE = false;
-        sendDataPacket(NODENUM_BROADCAST, false); // no replies
-        lastSend = millis();
-        netRecs = 0; // reset packet
-    }
-
-    /*
-     * State machine transitions
-     *
-     * FIXME could be managed better, for example: check if we require
-     *   each type of scan (wantBSS/wantBLE), and if not, don't start it!
-     */
-    if (scanState == SCAN_BLE_DONE) {
-        // BLE done, transition to BSS scanning
-        scanStart = millis();
-        LOG_DEBUG("BSS scan start t=%d\n", scanStart);
-        if (WiFi.scanNetworks(true, true) == WIFI_SCAN_RUNNING) // nonblock, showhidden
-            scanState = SCAN_BSS_RUN;
-
-    } else if (scanState == SCAN_BSS_DONE) {
-        // BSS done, transition to BLE scanning
-        scanStart = millis();
-        LOG_DEBUG("BLE scan start t=%d\n", scanStart);
-        if (ble_scan(ZPS_BLE_SCANTIME) == 0)
-            scanState = SCAN_BLE_RUN;
-    }
-
-    // LOG_DEBUG("ZPSModule::runOnce() DONE, scanState=%d\n", scanState);
-    if ((scanState == SCAN_BSS_RUN) || (scanState == SCAN_BLE_RUN)) {
-        return 1000; // scan in progress, re-check soon
-    }
-
-    return 5000;
-}
-
-uint64_t encodeBSS(const uint8_t *bssid, uint8_t chan, uint8_t absRSSI)
-{
-    uint64_t netBytes = absRSSI & 0xff;
-    netBytes <<= 8;
-    netBytes |= (chan & 0xff);
-
-    for (uint8_t b = 0; b < 6; b++) {
-        netBytes <<= 8;
-        netBytes |= bssid[b];
-    }
-
-    return netBytes;
-}
-
-uint64_t encodeBLE(const uint8_t *addr, uint8_t absRSSI)
-{
-    uint64_t netBytes = absRSSI & 0xff;
-    netBytes <<= 8;
-    netBytes |= 0xff; // "channel" byte reserved in BLE records
-
-    for (uint8_t b = 0; b < 6; b++) {
-        netBytes <<= 8;
-        netBytes |= addr[5 - b] & 0xff;
-    }
-
-    return netBytes;
-}
-
-/**
- * Event handler
- */
-static int ble_gap_event(struct ble_gap_event *event, void *arg)
-{
-    // Adverts matching certain patterns are useless for positioning purposes
-    //  (ephemeral MAC etc), so try excluding them if possible
-    //
-    // TODO: Expand the list of reject patterns for BLE adverts.
-    //   There are likely more than 10 patterns to test and reject, including most Apple devices and others.
-    //
-    // TODO: Implement full packet search for reject patterns (use memmem() or similar),
-    //   not just at the beginning (currently uses memcmp()).
-
-    const uint8_t rejPat[] = {0x1e, 0xff, 0x06, 0x00, 0x01}; // one of many
-
-    struct ble_hs_adv_fields fields;
-    int rc;
-    int i = 0;
-
-    uint64_t netBytes = 0;
-
-    switch (event->type) {
-    case BLE_GAP_EVENT_DISC:
-        // called once for every BLE advert received
-        rc = ble_hs_adv_parse_fields(&fields, event->disc.data, event->disc.length_data);
-        if (rc != 0)
-            return 0;
-
-        if (bleResSize != BLE_NO_RESULTS)
-            // as far as we know, we're not in the middle of a BLE scan!
-            LOG_DEBUG("Unexpected BLE_GAP_EVENT_DISC!\n");
-
-#ifdef ZPS_EXTRAVERBOSE
-        // Dump the advertisement packet
-        DEBUG_PORT.hexDump("DEBUG", (unsigned char *)event->disc.data, event->disc.length_data);
-#endif
-        // Reject beacons known to be unreliable (ephemeral etc)
-        if (memcmp(event->disc.data, rejPat, sizeof(rejPat)) == 0) {
-            LOG_DEBUG("(BLE item filtered by pattern)\n");
-            return 0; // Processing-wise, it's still a success
-        }
-
-        //
-        // STORE THE RESULTS IN A SORTED LIST
-        //
-
-        // first, pack each BLE item reading into a 64-bit int
-        netBytes = encodeBLE(event->disc.addr.val, abs(event->disc.rssi));
-
-        // SOME DUPLICATES SURVIVE through filter_duplicates = 1, catch them here
-        // Duplicate filtering is now handled in the sorting loop below,
-        // but right now we write for clarity not optimization
-        for (i = 0; i < bleCounter; i++) {
-            if ((bleResult[i] & 0xffffffffffff) == (netBytes & 0xffffffffffff)) {
-                LOG_DEBUG("(BLE duplicate filtered)\n");
-                return 0;
-            }
-        }
-
-#ifdef ZPS_EXTRAVERBOSE
-        // redundant extraverbosity, but I need it for duplicate hunting
-        LOG_DEBUG("BL_[%02d]: %08x"
-                  "%08x\n",
-                  bleCounter, (uint32_t)(netBytes >> 32), (uint32_t)netBytes);
-#endif
-        // then insert item into a list (up to BLE_MAX_REC records), sorted by RSSI
-        for (i = 0; i < bleCounter; i++) {
-            // find first element greater than ours, that will be our insertion point
-            if (bleResult[i] > netBytes)
-                break;
-        }
-        // any other records move down one position to vacate res[i]
-        for (int j = bleCounter; j > i; j--)
-            bleResult[j] = bleResult[j - 1];
-        // write new element at insertion point
-        bleResult[i] = netBytes;
-
-        // advance tail of list, but not beyond limit
-        if (bleCounter < BLE_MAX_REC)
-            bleCounter++;
-
-        return 0; // SUCCESS
-
-    case BLE_GAP_EVENT_DISC_COMPLETE:
-        LOG_DEBUG("EVENT_DISC_COMPLETE in %d millis\n", (millis() - scanStart));
-        LOG_DEBUG("%d BLE found\n", bleCounter);
-        bleResSize = bleCounter;
-
-        bleCounter = 0; // reset counter
-        return 0;       // SUCCESS
-
-    default:
-        return 0; // SUCCESS
-    }
-}
-
-/**
- * Initiates the GAP general discovery procedure (non-blocking)
- */
-static int ble_scan(uint32_t duration, bool passive, bool dedup)
-{
-    uint8_t own_addr_type;
-    struct ble_gap_disc_params disc_params;
-    int rc;
-
-    // Figure out address type to use
-    rc = ble_hs_id_infer_auto(0, &own_addr_type);
-    if (rc != 0) {
-        LOG_DEBUG("error determining address type; rc=%d\n", rc);
-        return rc;
-    }
-
-    // Scanning parameters, these are mostly default
-    disc_params.itvl = 0;
-    disc_params.window = 0;
-    disc_params.filter_policy = 0;
-    disc_params.limited = 0;
-
-    // These two params are the more interesting ones
-    disc_params.filter_duplicates = dedup; // self-explanatory
-    disc_params.passive = passive;         // passive uses less power
-
-    // Start scanning process (non-blocking) and return
-    rc = ble_gap_disc(own_addr_type, duration, &disc_params, ble_gap_event, NULL);
-    if (rc != 0) {
-        LOG_DEBUG("error initiating GAP discovery; rc=%d\n", rc);
-    }
-
-    return rc;
-}
-
-#endif // MESHTASTIC_EXCLUDE_BLUETOOTH
-
-#endif // ARCH_ESP32 && !MESHTASTIC_EXCLUDE_ZPS

src/modules/esp32/ZPSModule.h

@@ -1,86 +0,0 @@
-#pragma once
-#include "SinglePortModule.h"
-#include "concurrency/OSThread.h"
-#include "gps/RTC.h"
-
-#define ZPS_PORTNUM meshtastic_PortNum_ZPS_APP
-
-#define ZPS_DATAPKT_MAXITEMS 20 // max number of records to pack in an outbound packet (~10)
-#define ZPS_STARTUP_DELAY 10000 // Module startup delay in millis
-
-// Duration of a BLE scan in millis.
-// We want this number to be SLIGHTLY UNDER an integer number of seconds,
-//  to be able to catch the result as fresh as possible on a 1-second polling loop
-#define ZPS_BLE_SCANTIME 2900 // millis
-
-enum SCANSTATE { SCAN_NONE, SCAN_BSS_RUN, SCAN_BSS_DONE, SCAN_BLE_RUN, SCAN_BLE_DONE };
-
-/*
- * Data packing "compression" functions
- * Ingest a WiFi BSSID, channel and RSSI (or BLE address and RSSI)
- *   and encode them into a packed uint64
- */
-uint64_t encodeBSS(const uint8_t *bssid, uint8_t chan, uint8_t absRSSI);
-uint64_t encodeBLE(const uint8_t *addr, uint8_t absRSSI);
-
-class ZPSModule : public SinglePortModule, private concurrency::OSThread
-{
-    /// The id of the last packet we sent, to allow us to cancel it if we make something fresher
-    PacketId prevPacketId = 0;
-
-    /// We limit our broadcasts to a max rate
-    uint32_t lastSend = 0;
-
-    bool wantBSS = true;
-    bool haveBSS = false;
-
-    bool wantBLE = true;
-    bool haveBLE = false;
-
-  public:
-    /** Constructor
-     * name is for debugging output
-     */
-    ZPSModule();
-
-    /**
-     * Send our radio environment data into the mesh
-     */
-    void sendDataPacket(NodeNum dest = NODENUM_BROADCAST, bool wantReplies = false);
-
-  protected:
-    /** Called to handle a particular incoming message
-    @return true if you've guaranteed you've handled this message and no other handlers should be considered for it
-    */
-    virtual ProcessMessage handleReceived(const meshtastic_MeshPacket &mp);
-
-    /** Messages can be received that have the want_response bit set.  If set, this callback will be invoked
-     * so that subclasses can (optionally) send a response back to the original sender.  */
-    virtual meshtastic_MeshPacket *allocReply();
-
-    /** Does our periodic broadcast */
-    virtual int32_t runOnce();
-
-  private:
-    // outbound data packet staging buffer and record counter
-    uint64_t netData[ZPS_DATAPKT_MAXITEMS + 2] = {0};
-    uint8_t netRecs = 0;
-
-    // mini state machine to alternate between BSS(Wifi) and BLE scanning
-    SCANSTATE scanState = SCAN_NONE;
-
-    inline void outBufAdd(uint64_t netBytes)
-    {
-        // If this is the first record, initialize the header with the current time and reset the record count.
-        if (!netRecs) {
-            netData[0] = getTime();
-            netData[1] = 0;
-        }
-
-        // push to buffer and update counter
-        if (netRecs < ZPS_DATAPKT_MAXITEMS)
-            netData[2 + (netRecs++)] = netBytes;
-    }
-};
-
-extern ZPSModule *zpsModule;

src/motion/ICM42607PSensor.cpp

@@ -71,9 +71,6 @@ int32_t ICM42607PSensor::runOnce()
     }
     return MOTION_SENSOR_CHECK_INTERVAL_MS;
 #else
-    int16_t x = 0;
-    int16_t y = 0;
-    int16_t z = 0;
     inv_imu_sensor_event_t event = {};
 
     if (sensor == nullptr || sensor->getDataFromRegisters(event) != 0) {
@@ -85,11 +82,8 @@ int32_t ICM42607PSensor::runOnce()
         return MOTION_SENSOR_CHECK_INTERVAL_MS;
     }
 
-    x = event.accel[0];
-    y = event.accel[1];
-    z = event.accel[2];
-    // LOG_DEBUG("ICM-42607-P accel read x=%.3fg y=%.3fg z=%.3fg", (float)x / ICM42607P_COUNTS_PER_G,
-    //           (float)y / ICM42607P_COUNTS_PER_G, (float)z / ICM42607P_COUNTS_PER_G);
+    // LOG_DEBUG("ICM-42607-P accel read x=%.3fg y=%.3fg z=%.3fg", (float)event.accel[0] / ICM42607P_COUNTS_PER_G,
+    //           (float)event.accel[1] / ICM42607P_COUNTS_PER_G, (float)event.accel[2] / ICM42607P_COUNTS_PER_G);
 
     return MOTION_SENSOR_CHECK_INTERVAL_MS;
 #endif

src/platform/nrf52/architecture.h

@@ -85,6 +85,8 @@
 #define HW_VENDOR meshtastic_HardwareModel_T_ECHO
 #elif defined(T_ECHO_LITE)
 #define HW_VENDOR meshtastic_HardwareModel_T_ECHO_LITE
+#elif defined(T_ECHO_CARD)
+#define HW_VENDOR meshtastic_HardwareModel_T_ECHO_CARD
 #elif defined(TTGO_T_ECHO_PLUS)
 #define HW_VENDOR meshtastic_HardwareModel_T_ECHO_PLUS
 #elif defined(ELECROW_ThinkNode_M1)

variants/esp32/esp32-common.ini

@@ -14,7 +14,6 @@ platform_packages =
 extra_scripts =
   ${env.extra_scripts}
   pre:extra_scripts/esp32_pre.py
-  pre:extra_scripts/zps_observer.py
   extra_scripts/esp32_extra.py
 
 build_src_filter = 

variants/esp32c6/tlora_c6/platformio.ini

@@ -1,7 +1,17 @@
 [env:tlora-c6]
+custom_meshtastic_hw_model = 83
+custom_meshtastic_hw_model_slug = TLORA_C6
+custom_meshtastic_architecture = esp32-c6
+custom_meshtastic_actively_supported = true
+custom_meshtastic_support_level = 1
+custom_meshtastic_display_name = LilyGo T3-C6
+custom_meshtastic_images = tlora-c6.svg
+custom_meshtastic_tags = LilyGo
+
 extends = esp32c6_base
 board = esp32-c6-devkitm-1
 board_level = pr
+
 build_flags = 
   ${esp32c6_base.build_flags}
   -D TLORA_C6

variants/esp32c6/tlora_c6/variant.h

@@ -12,7 +12,6 @@
 #define LORA_RESET 21
 #define SX126X_CS LORA_CS
 #define SX126X_DIO1 23
-#define SX126X_DIO2 20
 #define SX126X_BUSY 22
 #define SX126X_RESET LORA_RESET
 #define SX126X_RXEN 15

variants/esp32s3/ELECROW-ThinkNode-M7/variant.cpp

@@ -0,0 +1,5 @@
+void initVariant()
+{
+    pinMode(LED_PAIRING, OUTPUT);
+    digitalWrite(LED_PAIRING, !LED_STATE_ON); // Turn off the LED to start
+}

variants/esp32s3/ELECROW-ThinkNode-M7/variant.h

@@ -6,11 +6,12 @@
 #define UART_TX 43
 #define UART_RX 44
 
-#define WIFI_LED 3
-#define WIFI_STATE_ON 0
+#define LED_PAIRING 46
+#define LED_LORA 46
 
-#define LED_PIN 46
+#define LED_PIN 3
 #define LED_STATE_ON 0
+#define LED_STATE_OFF 1
 #define BUTTON_PIN 4
 #define BUTTON_ACTIVE_LOW true
 #define BUTTON_ACTIVE_PULLUP true

variants/nrf52840/nrf52.ini

@@ -14,6 +14,7 @@ platform_packages =
 extra_scripts =
   ${env.extra_scripts}
   extra_scripts/nrf52_extra.py
+  pre:extra_scripts/nrf52_lto.py
 
 build_type = release
 build_flags =
@@ -26,6 +27,8 @@ build_flags =
   -DMESHTASTIC_EXCLUDE_PAXCOUNTER=1
   -Os
   -std=gnu++17
+  -flto                 ; whole-image LTO (~-60KB) on every nrf52840 target; nrf52_lto.py (pre: extra_script) keeps the interrupt handlers out of LTO so they survive
+  -fmerge-all-constants ; fold identical constants image-wide (~0.7KB; same flag stm32 uses)
 build_unflags =
   -Ofast
   -Og

variants/nrf52840/t-echo-card/platformio.ini

@@ -6,7 +6,6 @@ debug_tool = jlink
 
 build_flags = ${nrf52840_base.build_flags}
   -I variants/nrf52840/t-echo-card
-  -D PRIVATE_HW
   -D T_ECHO_CARD
 
 build_src_filter = ${nrf52_base.build_src_filter} +<../variants/nrf52840/t-echo-card>