Update src/platform/portduino/ch341a_i2c.c

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Update src/platform/portduino/ch341a_i2c.h
2025-12-15 15:22:34 +00:00 · 2025-10-07 17:05:04 +11:00 · 2025-10-07 17:05:04 +11:00 · 2025-10-07 17:05:04 +11:00 · 2025-10-07 17:05:04 +11:00
44 changed files with 715 additions and 505 deletions
--- a/.github/workflows/main_matrix.yml
+++ b/.github/workflows/main_matrix.yml
@@ -27,7 +27,6 @@ on:

 jobs:
  setup:
-    if: github.repository == 'meshtastic/firmware'
    strategy:
      fail-fast: true
      matrix:
@@ -42,10 +41,6 @@ jobs:
          python-version: 3.x
          cache: pip
      - run: pip install -U platformio
-      - name: Uncomment build epoch
-        shell: bash
-        run: |
-          sed -i 's/#-DBUILD_EPOCH=$UNIX_TIME/-DBUILD_EPOCH=$UNIX_TIME/' platformio.ini
      - name: Generate matrix
        id: jsonStep
        run: |
@@ -62,7 +57,6 @@ jobs:
      check: ${{ steps.jsonStep.outputs.check }}

  version:
-    if: github.repository == 'meshtastic/firmware'
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v5
--- a/.github/workflows/sec_sast_semgrep_cron.yml
+++ b/.github/workflows/sec_sast_semgrep_cron.yml
@@ -41,7 +41,7 @@ jobs:

      # step 4
      - name: publish code scanning alerts
-        uses: github/codeql-action/upload-sarif@v4
+        uses: github/codeql-action/upload-sarif@v3
        with:
          sarif_file: report.sarif
          category: semgrep
--- a/.trunk/trunk.yaml
+++ b/.trunk/trunk.yaml
@@ -16,7 +16,7 @@ lint:
    - bandit@1.8.6
    - trivy@0.67.0
    - taplo@0.10.0
-    - ruff@0.13.3
+    - ruff@0.13.2
    - isort@6.1.0
    - markdownlint@0.45.0
    - oxipng@9.1.5
--- a/2
+++ b/2
@@ -3,7 +3,7 @@
 # trunk-ignore-all(hadolint/DL3008): Do not pin apt package versions
 # trunk-ignore-all(hadolint/DL3013): Do not pin pip package versions

-FROM python:3.14-slim-trixie AS builder
+FROM python:3.13-slim-trixie AS builder
 ARG PIO_ENV=native
 ENV DEBIAN_FRONTEND=noninteractive
 ENV TZ=Etc/UTC
--- a/alpine.Dockerfile
+++ b/alpine.Dockerfile
@@ -3,7 +3,7 @@
 # trunk-ignore-all(hadolint/DL3018): Do not pin apk package versions
 # trunk-ignore-all(hadolint/DL3013): Do not pin pip package versions

-FROM python:3.14-alpine3.22 AS builder
+FROM python:3.13-alpine3.22 AS builder
 ARG PIO_ENV=native
 ENV PIP_ROOT_USER_ACTION=ignore

--- a/arch/esp32/esp32.ini
+++ b/arch/esp32/esp32.ini
@@ -31,7 +31,6 @@ build_flags =
  -DMYNEWT_VAL_BLE_HS_LOG_LVL=LOG_LEVEL_CRITICAL
  -DAXP_DEBUG_PORT=Serial
  -DCONFIG_BT_NIMBLE_ENABLED
-  -DCONFIG_BT_NIMBLE_MAX_BONDS=6 # default is 3
  -DCONFIG_NIMBLE_CPP_LOG_LEVEL=2
  -DCONFIG_BT_NIMBLE_MAX_CCCDS=20
  -DCONFIG_BT_NIMBLE_HOST_TASK_STACK_SIZE=8192
--- a/bin/web.version
+++ b/bin/web.version
@@ -1 +1 @@
-2.6.6
+2.6.4
--- a/platformio.ini
+++ b/platformio.ini
@@ -70,7 +70,7 @@ lib_deps =
 	# renovate: datasource=git-refs depName=meshtastic-TinyGPSPlus packageName=https://github.com/meshtastic/TinyGPSPlus gitBranch=master
 	https://github.com/meshtastic/TinyGPSPlus/archive/71a82db35f3b973440044c476d4bcdc673b104f4.zip
 	# renovate: datasource=git-refs depName=meshtastic-ArduinoThread packageName=https://github.com/meshtastic/ArduinoThread gitBranch=master
-	https://github.com/meshtastic/ArduinoThread/archive/b841b0415721f1341ea41cccfb4adccfaf951567.zip
+	https://github.com/meshtastic/ArduinoThread/archive/7c3ee9e1951551b949763b1f5280f8db1fa4068d.zip
 	# renovate: datasource=custom.pio depName=Nanopb packageName=nanopb/library/Nanopb
 	nanopb/Nanopb@0.4.91
 	# renovate: datasource=custom.pio depName=ErriezCRC32 packageName=erriez/library/ErriezCRC32
@@ -120,7 +120,7 @@ lib_deps =
 [device-ui_base]
 lib_deps =
 	# renovate: datasource=git-refs depName=meshtastic/device-ui packageName=https://github.com/meshtastic/device-ui gitBranch=master
-	https://github.com/meshtastic/device-ui/archive/6d8cc228298a1ecd9913aed757187e9527c1facc.zip
+	https://github.com/meshtastic/device-ui/archive/505ffadaa7a931df5dc8153229b719a07bbb028c.zip

 ; Common libs for environmental measurements in telemetry module
 [environmental_base]
--- a/src/Power.cpp
+++ b/src/Power.cpp
@@ -691,16 +691,6 @@ bool Power::setup()
 #ifdef NRF_APM
    found = true;
 #endif
-#ifdef EXT_PWR_DETECT
-    attachInterrupt(
-        EXT_PWR_DETECT,
-        []() {
-            power->setIntervalFromNow(0);
-            runASAP = true;
-            BaseType_t higherWake = 0;
-        },
-        CHANGE);
-#endif

    enabled = found;
    low_voltage_counter = 0;
@@ -838,8 +828,11 @@ void Power::readPowerStatus()

    // Notify any status instances that are observing us
    const PowerStatus powerStatus2 = PowerStatus(hasBattery, usbPowered, isChargingNow, batteryVoltageMv, batteryChargePercent);
-    LOG_DEBUG("Battery: usbPower=%d, isCharging=%d, batMv=%d, batPct=%d", powerStatus2.getHasUSB(), powerStatus2.getIsCharging(),
-              powerStatus2.getBatteryVoltageMv(), powerStatus2.getBatteryChargePercent());
+    if (millis() > lastLogTime + 50 * 1000) {
+        LOG_DEBUG("Battery: usbPower=%d, isCharging=%d, batMv=%d, batPct=%d", powerStatus2.getHasUSB(),
+                  powerStatus2.getIsCharging(), powerStatus2.getBatteryVoltageMv(), powerStatus2.getBatteryChargePercent());
+        lastLogTime = millis();
+    }
    newStatus.notifyObservers(&powerStatus2);
 #ifdef DEBUG_HEAP
    if (lastheap != memGet.getFreeHeap()) {
--- a/src/configuration.h
+++ b/src/configuration.h
@@ -33,9 +33,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "pcf8563.h"
 #endif

-/* Offer chance for variant-specific defines */
-#include "variant.h"
-
 // -----------------------------------------------------------------------------
 // Version
 // -----------------------------------------------------------------------------
@@ -126,11 +123,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define TX_GAIN_LORA 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 10, 10, 9, 9, 8, 7
 #endif

-#ifdef STATION_G2
-#define NUM_PA_POINTS 19
-#define TX_GAIN_LORA 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 19, 19, 18, 18
-#endif
-
 // Default system gain to 0 if not defined
 #ifndef TX_GAIN_LORA
 #define TX_GAIN_LORA 0
@@ -268,6 +260,9 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // convert 24-bit color to 16-bit (56K)
 #define COLOR565(r, g, b) (((r & 0xF8) << 8) | ((g & 0xFC) << 3) | ((b & 0xF8) >> 3))

+/* Step #1: offer chance for variant-specific defines */
+#include "variant.h"
+
 #if defined(VEXT_ENABLE) && !defined(VEXT_ON_VALUE)
 // Older variant.h files might not be defining this value, so stay with the old default
 #define VEXT_ON_VALUE LOW
--- a/src/detect/ScanI2CTwoWire.cpp
+++ b/src/detect/ScanI2CTwoWire.cpp
@@ -378,7 +378,7 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
            case SHT31_4x_ADDR:     // same as OPT3001_ADDR_ALT
            case SHT31_4x_ADDR_ALT: // same as OPT3001_ADDR
                registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x89), 2);
-                if (registerValue == 0x11a2 || registerValue == 0x11da || registerValue == 0x11f3 || registerValue == 0xe9c || registerValue == 0xc8d) {
+                if (registerValue == 0x11a2 || registerValue == 0x11da || registerValue == 0xe9c || registerValue == 0xc8d) {
                    type = SHT4X;
                    logFoundDevice("SHT4X", (uint8_t)addr.address);
                } else if (getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x7E), 2) == 0x5449) {
--- a/src/gps/GPS.cpp
+++ b/src/gps/GPS.cpp
@@ -506,9 +506,10 @@ bool GPS::setup()
            delay(1000);
 #endif
            if (probeTries < GPS_PROBETRIES) {
+                LOG_DEBUG("Probe for GPS at %d", serialSpeeds[speedSelect]);
                gnssModel = probe(serialSpeeds[speedSelect]);
                if (gnssModel == GNSS_MODEL_UNKNOWN) {
-                    if (currentStep == 0 && ++speedSelect == array_count(serialSpeeds)) {
+                    if (++speedSelect == array_count(serialSpeeds)) {
                        speedSelect = 0;
                        ++probeTries;
                    }
@@ -517,9 +518,10 @@ bool GPS::setup()
            // Rare Serial Speeds
 #ifndef CONFIG_IDF_TARGET_ESP32C6
            if (probeTries == GPS_PROBETRIES) {
+                LOG_DEBUG("Probe for GPS at %d", rareSerialSpeeds[speedSelect]);
                gnssModel = probe(rareSerialSpeeds[speedSelect]);
                if (gnssModel == GNSS_MODEL_UNKNOWN) {
-                    if (currentStep == 0 && ++speedSelect == array_count(rareSerialSpeeds)) {
+                    if (++speedSelect == array_count(rareSerialSpeeds)) {
                        LOG_WARN("Give up on GPS probe and set to %d", GPS_BAUDRATE);
                        return true;
                    }
@@ -1031,7 +1033,7 @@ void GPS::down()
    LOG_DEBUG("%us until next search", sleepTime / 1000);

    // If update interval less than 10 seconds, no attempt to sleep
-    if (updateInterval <= GPS_UPDATE_ALWAYS_ON_THRESHOLD_MS || sleepTime == 0)
+    if (updateInterval <= 10 * 1000UL || sleepTime == 0)
        setPowerState(GPS_IDLE);

    else {
@@ -1092,7 +1094,7 @@ int32_t GPS::runOnce()
            return disable();
        }
        if (!setup())
-            return currentDelay; // Setup failed, re-run in two seconds
+            return 2000; // Setup failed, re-run in two seconds

        // We have now loaded our saved preferences from flash
        if (config.position.gps_mode != meshtastic_Config_PositionConfig_GpsMode_ENABLED) {
@@ -1102,29 +1104,6 @@ int32_t GPS::runOnce()
        publishUpdate();
    }

-    // ======================== GPS_ACTIVE state ========================
-    // In GPS_ACTIVE state, GPS is powered on and we're receiving NMEA messages.
-    // We use the following logic to determine when to update the local position
-    // or time by running GPS::publishUpdate.
-    // Note: Local position update is asynchronous to position broadcast. We
-    // generally run this state every gps_update_interval seconds, and in most cases
-    // gps_update_interval is faster than the position broadcast interval so there's a
-    // fresh position ready when the device wants to broadcast one on the mesh.
-    //
-    // 1. Got a time for the first time --> set the time, don't publish.
-    // 2. Got a lock for the first time
-    //   --> If gps_update_interval is <= 10s --> publishUpdate
-    //   --> Otherwise, hold for MIN(gps_update_interval - GPS_UPDATE_ALWAYS_ON_THRESHOLD_MS, 20s)
-    //  3. Got a lock after turning back on
-    //   --> If gps_update_interval is <= 10s --> publishUpdate
-    //   --> Otherwise, hold for MIN(gps_update_interval - GPS_UPDATE_ALWAYS_ON_THRESHOLD_MS, 20s)
-    // 4. Hold has expired
-    //   --> If we have a time and a location --> publishUpdate
-    //   --> down()
-    // 5. Search time has expired
-    //   --> If we have a time and a location --> publishUpdate
-    //   --> If we had a location before but don't now --> publishUpdate
-    //   --> down()
    if (whileActive()) {
        // if we have received valid NMEA claim we are connected
        setConnected();
@@ -1134,81 +1113,55 @@ int32_t GPS::runOnce()
    if (!config.position.fixed_position && powerState != GPS_ACTIVE && scheduling.isUpdateDue())
        up();

-    // quality of the previous fix. We set it to 0 when we go down, so it's a way
-    // to check if we're getting a lock after being GPS_OFF.
+    // If we've already set time from the GPS, no need to ask the GPS
+    bool gotTime = (getRTCQuality() >= RTCQualityGPS);
+    if (!gotTime && lookForTime()) { // Note: we count on this && short-circuiting and not resetting the RTC time
+        gotTime = true;
+        shouldPublish = true;
+    }
+
    uint8_t prev_fixQual = fixQual;
+    bool gotLoc = lookForLocation();
+    if (gotLoc && !hasValidLocation) { // declare that we have location ASAP
+        LOG_DEBUG("hasValidLocation RISING EDGE");
+        hasValidLocation = true;
+        shouldPublish = true;
+        // Hold for 20secs after getting a lock to download ephemeris etc
+        fixHoldEnds = millis() + 20000;
+    }

-    if (powerState == GPS_ACTIVE) {
-        // if gps_update_interval is <=10s, GPS never goes off, so we treat that differently
-        uint32_t updateInterval = Default::getConfiguredOrDefaultMs(config.position.gps_update_interval);
+    if (gotLoc && prev_fixQual == 0) { // just got a lock after turning back on.
+        fixHoldEnds = millis() + 20000;
+        shouldPublish = true; // Publish immediately, since next publish is at end of hold
+    }

-        // 1. Got a time for the first time
-        bool gotTime = (getRTCQuality() >= RTCQualityGPS);
-        if (!gotTime && lookForTime()) { // Note: we count on this && short-circuiting and not resetting the RTC time
-            gotTime = true;
-        }
+    bool tooLong = scheduling.searchedTooLong();
+    if (tooLong)
+        LOG_WARN("Couldn't publish a valid location: didn't get a GPS lock in time");

-        // 2. Got a lock for the first time, or 3. Got a lock after turning back on
-        bool gotLoc = lookForLocation();
-        if (gotLoc) {
-#ifdef GPS_DEBUG
-            if (!hasValidLocation) { // declare that we have location ASAP
-                LOG_DEBUG("hasValidLocation RISING EDGE");
-            }
-#endif
-            if (updateInterval <= GPS_UPDATE_ALWAYS_ON_THRESHOLD_MS) {
-                hasValidLocation = true;
-                shouldPublish = true;
-            } else if (!hasValidLocation || prev_fixQual == 0 || (fixHoldEnds + GPS_THREAD_INTERVAL) < millis()) {
-                hasValidLocation = true;
-                // Hold for up to 20secs after getting a lock to download ephemeris etc
-                uint32_t holdTime = updateInterval - GPS_UPDATE_ALWAYS_ON_THRESHOLD_MS;
-                if (holdTime > GPS_FIX_HOLD_MAX_MS)
-                    holdTime = GPS_FIX_HOLD_MAX_MS;
-                fixHoldEnds = millis() + holdTime;
-#ifdef GPS_DEBUG
-                LOG_DEBUG("Holding for %ums after lock", holdTime);
-#endif
-            }
-        }
-
-        bool tooLong = scheduling.searchedTooLong();
+    // Once we get a location we no longer desperately want an update
+    if ((gotLoc && gotTime) || tooLong) {
        if (tooLong && !gotLoc) {
-            LOG_WARN("Couldn't publish a valid location: didn't get a GPS lock in time");
            // we didn't get a location during this ack window, therefore declare loss of lock
            if (hasValidLocation) {
-                p = meshtastic_Position_init_default;
-                hasValidLocation = false;
-                shouldPublish = true;
-#ifdef GPS_DEBUG
                LOG_DEBUG("hasValidLocation FALLING EDGE");
-#endif
            }
+            p = meshtastic_Position_init_default;
+            hasValidLocation = false;
        }
-
-        // Hold has expired , Search time has expired, we got a time only, or we never needed to hold.
-        bool holdExpired = (fixHoldEnds != 0 && millis() > fixHoldEnds);
-        if (shouldPublish || tooLong || holdExpired) {
-            if (gotTime && hasValidLocation) {
-                shouldPublish = true;
-            }
-            if (shouldPublish) {
-                fixHoldEnds = 0;
-                publishUpdate();
-            }
-
-            // There's a chance we just got a time, so keep going to see if we can get a location too
-            if (tooLong || holdExpired) {
-                down();
-            }
-
+        if (millis() > fixHoldEnds) {
+            shouldPublish = true; // publish our update at the end of the lock hold
+            publishUpdate();
+            down();
 #ifdef GPS_DEBUG
-        } else if (fixHoldEnds != 0) {
+        } else {
            LOG_DEBUG("Holding for GPS data download: %d ms (numSats=%d)", fixHoldEnds - millis(), p.sats_in_view);
 #endif
        }
    }
-    // ===================== end GPS_ACTIVE state ========================
+
+    // If state has changed do a publish
+    publishUpdate();

    if (config.position.fixed_position == true && hasValidLocation)
        return disable(); // This should trigger when we have a fixed position, and get that first position
@@ -1265,197 +1218,163 @@ static const char *DETECTED_MESSAGE = "%s detected";

 GnssModel_t GPS::probe(int serialSpeed)
 {
-    uint8_t buffer[768] = {0};
-
-    switch (currentStep) {
-    case 0: {
 #if defined(ARCH_NRF52) || defined(ARCH_PORTDUINO) || defined(ARCH_STM32WL)
-        _serial_gps->end();
-        _serial_gps->begin(serialSpeed);
+    _serial_gps->end();
+    _serial_gps->begin(serialSpeed);
 #elif defined(ARCH_RP2040)
-        _serial_gps->end();
-        _serial_gps->setFIFOSize(256);
-        _serial_gps->begin(serialSpeed);
+    _serial_gps->end();
+    _serial_gps->setFIFOSize(256);
+    _serial_gps->begin(serialSpeed);
 #else
-        if (_serial_gps->baudRate() != serialSpeed) {
-            LOG_DEBUG("Set GPS Baud to %i", serialSpeed);
-            _serial_gps->updateBaudRate(serialSpeed);
-        }
+    if (_serial_gps->baudRate() != serialSpeed) {
+        LOG_DEBUG("Set Baud to %i", serialSpeed);
+        _serial_gps->updateBaudRate(serialSpeed);
+    }
 #endif

-        memset(&ublox_info, 0, sizeof(ublox_info));
-        delay(100);
+    memset(&ublox_info, 0, sizeof(ublox_info));
+    uint8_t buffer[768] = {0};
+    delay(100);

-        // Close all NMEA sentences, valid for L76K, ATGM336H (and likely other AT6558 devices)
-        _serial_gps->write("$PCAS03,0,0,0,0,0,0,0,0,0,0,,,0,0*02\r\n");
-        delay(20);
-        // Close NMEA sequences on Ublox
-        _serial_gps->write("$PUBX,40,GLL,0,0,0,0,0,0*5C\r\n");
-        _serial_gps->write("$PUBX,40,GSV,0,0,0,0,0,0*59\r\n");
-        _serial_gps->write("$PUBX,40,VTG,0,0,0,0,0,0*5E\r\n");
-        delay(20);
-        // Close NMEA sequences on CM121
-        _serial_gps->write("$CFGMSG,0,1,0,1*1B\r\n");
-        _serial_gps->write("$CFGMSG,0,2,0,1*18\r\n");
-        _serial_gps->write("$CFGMSG,0,3,0,1*19\r\n");
-        currentDelay = 20;
-        currentStep = 1;
-        return GNSS_MODEL_UNKNOWN;
-    }
-    case 1: {
+    // Close all NMEA sentences, valid for L76K, ATGM336H (and likely other AT6558 devices)
+    _serial_gps->write("$PCAS03,0,0,0,0,0,0,0,0,0,0,,,0,0*02\r\n");
+    delay(20);
+    // Close NMEA sequences on Ublox
+    _serial_gps->write("$PUBX,40,GLL,0,0,0,0,0,0*5C\r\n");
+    _serial_gps->write("$PUBX,40,GSV,0,0,0,0,0,0*59\r\n");
+    _serial_gps->write("$PUBX,40,VTG,0,0,0,0,0,0*5E\r\n");
+    delay(20);
+    // Close NMEA sequences on CM121
+    _serial_gps->write("$CFGMSG,0,1,0,1*1B\r\n");
+    _serial_gps->write("$CFGMSG,0,2,0,1*18\r\n");
+    _serial_gps->write("$CFGMSG,0,3,0,1*19\r\n");
+    delay(20);

-        // Unicore UFirebirdII Series: UC6580, UM620, UM621, UM670A, UM680A, or UM681A,or CM121
-        std::vector<ChipInfo> unicore = {
-            {"UC6580", "UC6580", GNSS_MODEL_UC6580}, {"UM600", "UM600", GNSS_MODEL_UC6580}, {"CM121", "CM121", GNSS_MODEL_CM121}};
-        PROBE_FAMILY("Unicore Family", "$PDTINFO", unicore, 500);
-        currentDelay = 20;
-        currentStep = 2;
-        return GNSS_MODEL_UNKNOWN;
-    }
-    case 2: {
-        std::vector<ChipInfo> atgm = {
-            {"ATGM336H", "$GPTXT,01,01,02,HW=ATGM336H", GNSS_MODEL_ATGM336H},
-            /* ATGM332D series (-11(GPS), -21(BDS), -31(GPS+BDS), -51(GPS+GLONASS), -71-0(GPS+BDS+GLONASS)) based on AT6558 */
-            {"ATGM332D", "$GPTXT,01,01,02,HW=ATGM332D", GNSS_MODEL_ATGM336H}};
-        PROBE_FAMILY("ATGM33xx Family", "$PCAS06,1*1A", atgm, 500);
-        currentDelay = 20;
-        currentStep = 3;
-        return GNSS_MODEL_UNKNOWN;
-    }
-    case 3: {
-        /* Airoha (Mediatek) AG3335A/M/S, A3352Q, Quectel L89 2.0, SimCom SIM65M */
-        _serial_gps->write("$PAIR062,2,0*3C\r\n"); // GSA OFF to reduce volume
-        _serial_gps->write("$PAIR062,3,0*3D\r\n"); // GSV OFF to reduce volume
-        _serial_gps->write("$PAIR513*3D\r\n");     // save configuration
-        std::vector<ChipInfo> airoha = {{"AG3335", "$PAIR021,AG3335", GNSS_MODEL_AG3335},
-                                        {"AG3352", "$PAIR021,AG3352", GNSS_MODEL_AG3352},
-                                        {"RYS3520", "$PAIR021,REYAX_RYS3520_V2", GNSS_MODEL_AG3352}};
-        PROBE_FAMILY("Airoha Family", "$PAIR021*39", airoha, 1000);
-        currentDelay = 20;
-        currentStep = 4;
-        return GNSS_MODEL_UNKNOWN;
-    }
-    case 4: {
-        PROBE_SIMPLE("LC86", "$PQTMVERNO*58", "$PQTMVERNO,LC86", GNSS_MODEL_AG3352, 500);
-        PROBE_SIMPLE("L76K", "$PCAS06,0*1B", "$GPTXT,01,01,02,SW=", GNSS_MODEL_MTK, 500);
-        currentDelay = 20;
-        currentStep = 5;
-        return GNSS_MODEL_UNKNOWN;
-    }
-    case 5: {
+    // Unicore UFirebirdII Series: UC6580, UM620, UM621, UM670A, UM680A, or UM681A,or CM121
+    std::vector<ChipInfo> unicore = {
+        {"UC6580", "UC6580", GNSS_MODEL_UC6580}, {"UM600", "UM600", GNSS_MODEL_UC6580}, {"CM121", "CM121", GNSS_MODEL_CM121}};
+    PROBE_FAMILY("Unicore Family", "$PDTINFO", unicore, 500);

-        // Close all NMEA sentences, valid for MTK3333 and MTK3339 platforms
-        _serial_gps->write("$PMTK514,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0*2E\r\n");
-        delay(20);
-        std::vector<ChipInfo> mtk = {{"L76B", "Quectel-L76B", GNSS_MODEL_MTK_L76B}, {"PA1010D", "1010D", GNSS_MODEL_MTK_PA1010D},
-                                     {"PA1616S", "1616S", GNSS_MODEL_MTK_PA1616S},  {"LS20031", "MC-1513", GNSS_MODEL_MTK_L76B},
-                                     {"L96", "Quectel-L96", GNSS_MODEL_MTK_L76B},   {"L80-R", "_3337_", GNSS_MODEL_MTK_L76B},
-                                     {"L80", "_3339_", GNSS_MODEL_MTK_L76B}};
+    std::vector<ChipInfo> atgm = {
+        {"ATGM336H", "$GPTXT,01,01,02,HW=ATGM336H", GNSS_MODEL_ATGM336H},
+        /* ATGM332D series (-11(GPS), -21(BDS), -31(GPS+BDS), -51(GPS+GLONASS), -71-0(GPS+BDS+GLONASS)) based on AT6558 */
+        {"ATGM332D", "$GPTXT,01,01,02,HW=ATGM332D", GNSS_MODEL_ATGM336H}};
+    PROBE_FAMILY("ATGM33xx Family", "$PCAS06,1*1A", atgm, 500);

-        PROBE_FAMILY("MTK Family", "$PMTK605*31", mtk, 500);
-        currentDelay = 20;
-        currentStep = 6;
+    /* Airoha (Mediatek) AG3335A/M/S, A3352Q, Quectel L89 2.0, SimCom SIM65M */
+    _serial_gps->write("$PAIR062,2,0*3C\r\n"); // GSA OFF to reduce volume
+    _serial_gps->write("$PAIR062,3,0*3D\r\n"); // GSV OFF to reduce volume
+    _serial_gps->write("$PAIR513*3D\r\n");     // save configuration
+    std::vector<ChipInfo> airoha = {{"AG3335", "$PAIR021,AG3335", GNSS_MODEL_AG3335},
+                                    {"AG3352", "$PAIR021,AG3352", GNSS_MODEL_AG3352},
+                                    {"RYS3520", "$PAIR021,REYAX_RYS3520_V2", GNSS_MODEL_AG3352}};
+    PROBE_FAMILY("Airoha Family", "$PAIR021*39", airoha, 1000);
+
+    PROBE_SIMPLE("LC86", "$PQTMVERNO*58", "$PQTMVERNO,LC86", GNSS_MODEL_AG3352, 500);
+    PROBE_SIMPLE("L76K", "$PCAS06,0*1B", "$GPTXT,01,01,02,SW=", GNSS_MODEL_MTK, 500);
+
+    // Close all NMEA sentences, valid for MTK3333 and MTK3339 platforms
+    _serial_gps->write("$PMTK514,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0*2E\r\n");
+    delay(20);
+    std::vector<ChipInfo> mtk = {{"L76B", "Quectel-L76B", GNSS_MODEL_MTK_L76B}, {"PA1010D", "1010D", GNSS_MODEL_MTK_PA1010D},
+                                 {"PA1616S", "1616S", GNSS_MODEL_MTK_PA1616S},  {"LS20031", "MC-1513", GNSS_MODEL_MTK_L76B},
+                                 {"L96", "Quectel-L96", GNSS_MODEL_MTK_L76B},   {"L80-R", "_3337_", GNSS_MODEL_MTK_L76B},
+                                 {"L80", "_3339_", GNSS_MODEL_MTK_L76B}};
+
+    PROBE_FAMILY("MTK Family", "$PMTK605*31", mtk, 500);
+
+    uint8_t cfg_rate[] = {0xB5, 0x62, 0x06, 0x08, 0x00, 0x00, 0x00, 0x00};
+    UBXChecksum(cfg_rate, sizeof(cfg_rate));
+    clearBuffer();
+    _serial_gps->write(cfg_rate, sizeof(cfg_rate));
+    // Check that the returned response class and message ID are correct
+    GPS_RESPONSE response = getACK(0x06, 0x08, 750);
+    if (response == GNSS_RESPONSE_NONE) {
+        LOG_WARN("No GNSS Module (baudrate %d)", serialSpeed);
        return GNSS_MODEL_UNKNOWN;
+    } else if (response == GNSS_RESPONSE_FRAME_ERRORS) {
+        LOG_INFO("UBlox Frame Errors (baudrate %d)", serialSpeed);
    }
-    case 6: {
-        uint8_t cfg_rate[] = {0xB5, 0x62, 0x06, 0x08, 0x00, 0x00, 0x00, 0x00};
-        UBXChecksum(cfg_rate, sizeof(cfg_rate));
-        clearBuffer();
-        _serial_gps->write(cfg_rate, sizeof(cfg_rate));
-        // Check that the returned response class and message ID are correct
-        GPS_RESPONSE response = getACK(0x06, 0x08, 750);
-        if (response == GNSS_RESPONSE_NONE) {
-            LOG_WARN("No GNSS Module (baudrate %d)", serialSpeed);
-            currentDelay = 2000;
-            currentStep = 0;
-            return GNSS_MODEL_UNKNOWN;
-        } else if (response == GNSS_RESPONSE_FRAME_ERRORS) {
-            LOG_INFO("UBlox Frame Errors (baudrate %d)", serialSpeed);
+
+    memset(buffer, 0, sizeof(buffer));
+    uint8_t _message_MONVER[8] = {
+        0xB5, 0x62, // Sync message for UBX protocol
+        0x0A, 0x04, // Message class and ID (UBX-MON-VER)
+        0x00, 0x00, // Length of payload (we're asking for an answer, so no payload)
+        0x00, 0x00  // Checksum
+    };
+    //  Get Ublox gnss module hardware and software info
+    UBXChecksum(_message_MONVER, sizeof(_message_MONVER));
+    clearBuffer();
+    _serial_gps->write(_message_MONVER, sizeof(_message_MONVER));
+
+    uint16_t len = getACK(buffer, sizeof(buffer), 0x0A, 0x04, 1200);
+    if (len) {
+        uint16_t position = 0;
+        for (int i = 0; i < 30; i++) {
+            ublox_info.swVersion[i] = buffer[position];
+            position++;
+        }
+        for (int i = 0; i < 10; i++) {
+            ublox_info.hwVersion[i] = buffer[position];
+            position++;
+        }
+
+        while (len >= position + 30) {
+            for (int i = 0; i < 30; i++) {
+                ublox_info.extension[ublox_info.extensionNo][i] = buffer[position];
+                position++;
+            }
+            ublox_info.extensionNo++;
+            if (ublox_info.extensionNo > 9)
+                break;
+        }
+
+        LOG_DEBUG("Module Info : ");
+        LOG_DEBUG("Soft version: %s", ublox_info.swVersion);
+        LOG_DEBUG("Hard version: %s", ublox_info.hwVersion);
+        LOG_DEBUG("Extensions:%d", ublox_info.extensionNo);
+        for (int i = 0; i < ublox_info.extensionNo; i++) {
+            LOG_DEBUG("  %s", ublox_info.extension[i]);
        }

        memset(buffer, 0, sizeof(buffer));
-        uint8_t _message_MONVER[8] = {
-            0xB5, 0x62, // Sync message for UBX protocol
-            0x0A, 0x04, // Message class and ID (UBX-MON-VER)
-            0x00, 0x00, // Length of payload (we're asking for an answer, so no payload)
-            0x00, 0x00  // Checksum
-        };
-        //  Get Ublox gnss module hardware and software info
-        UBXChecksum(_message_MONVER, sizeof(_message_MONVER));
-        clearBuffer();
-        _serial_gps->write(_message_MONVER, sizeof(_message_MONVER));

-        uint16_t len = getACK(buffer, sizeof(buffer), 0x0A, 0x04, 1200);
-        if (len) {
-            uint16_t position = 0;
-            for (int i = 0; i < 30; i++) {
-                ublox_info.swVersion[i] = buffer[position];
-                position++;
-            }
-            for (int i = 0; i < 10; i++) {
-                ublox_info.hwVersion[i] = buffer[position];
-                position++;
-            }
-
-            while (len >= position + 30) {
-                for (int i = 0; i < 30; i++) {
-                    ublox_info.extension[ublox_info.extensionNo][i] = buffer[position];
-                    position++;
+        // tips: extensionNo field is 0 on some 6M GNSS modules
+        for (int i = 0; i < ublox_info.extensionNo; ++i) {
+            if (!strncmp(ublox_info.extension[i], "MOD=", 4)) {
+                strncpy((char *)buffer, &(ublox_info.extension[i][4]), sizeof(buffer));
+            } else if (!strncmp(ublox_info.extension[i], "PROTVER", 7)) {
+                char *ptr = nullptr;
+                memset(buffer, 0, sizeof(buffer));
+                strncpy((char *)buffer, &(ublox_info.extension[i][8]), sizeof(buffer));
+                LOG_DEBUG("Protocol Version:%s", (char *)buffer);
+                if (strlen((char *)buffer)) {
+                    ublox_info.protocol_version = strtoul((char *)buffer, &ptr, 10);
+                    LOG_DEBUG("ProtVer=%d", ublox_info.protocol_version);
+                } else {
+                    ublox_info.protocol_version = 0;
                }
-                ublox_info.extensionNo++;
-                if (ublox_info.extensionNo > 9)
-                    break;
-            }
-
-            LOG_DEBUG("Module Info : ");
-            LOG_DEBUG("Soft version: %s", ublox_info.swVersion);
-            LOG_DEBUG("Hard version: %s", ublox_info.hwVersion);
-            LOG_DEBUG("Extensions:%d", ublox_info.extensionNo);
-            for (int i = 0; i < ublox_info.extensionNo; i++) {
-                LOG_DEBUG("  %s", ublox_info.extension[i]);
-            }
-
-            memset(buffer, 0, sizeof(buffer));
-
-            // tips: extensionNo field is 0 on some 6M GNSS modules
-            for (int i = 0; i < ublox_info.extensionNo; ++i) {
-                if (!strncmp(ublox_info.extension[i], "MOD=", 4)) {
-                    strncpy((char *)buffer, &(ublox_info.extension[i][4]), sizeof(buffer));
-                } else if (!strncmp(ublox_info.extension[i], "PROTVER", 7)) {
-                    char *ptr = nullptr;
-                    memset(buffer, 0, sizeof(buffer));
-                    strncpy((char *)buffer, &(ublox_info.extension[i][8]), sizeof(buffer));
-                    LOG_DEBUG("Protocol Version:%s", (char *)buffer);
-                    if (strlen((char *)buffer)) {
-                        ublox_info.protocol_version = strtoul((char *)buffer, &ptr, 10);
-                        LOG_DEBUG("ProtVer=%d", ublox_info.protocol_version);
-                    } else {
-                        ublox_info.protocol_version = 0;
-                    }
-                }
-            }
-            if (strncmp(ublox_info.hwVersion, "00040007", 8) == 0) {
-                LOG_INFO(DETECTED_MESSAGE, "U-blox 6", "6");
-                return GNSS_MODEL_UBLOX6;
-            } else if (strncmp(ublox_info.hwVersion, "00070000", 8) == 0) {
-                LOG_INFO(DETECTED_MESSAGE, "U-blox 7", "7");
-                return GNSS_MODEL_UBLOX7;
-            } else if (strncmp(ublox_info.hwVersion, "00080000", 8) == 0) {
-                LOG_INFO(DETECTED_MESSAGE, "U-blox 8", "8");
-                return GNSS_MODEL_UBLOX8;
-            } else if (strncmp(ublox_info.hwVersion, "00190000", 8) == 0) {
-                LOG_INFO(DETECTED_MESSAGE, "U-blox 9", "9");
-                return GNSS_MODEL_UBLOX9;
-            } else if (strncmp(ublox_info.hwVersion, "000A0000", 8) == 0) {
-                LOG_INFO(DETECTED_MESSAGE, "U-blox 10", "10");
-                return GNSS_MODEL_UBLOX10;
            }
        }
-    }
+        if (strncmp(ublox_info.hwVersion, "00040007", 8) == 0) {
+            LOG_INFO(DETECTED_MESSAGE, "U-blox 6", "6");
+            return GNSS_MODEL_UBLOX6;
+        } else if (strncmp(ublox_info.hwVersion, "00070000", 8) == 0) {
+            LOG_INFO(DETECTED_MESSAGE, "U-blox 7", "7");
+            return GNSS_MODEL_UBLOX7;
+        } else if (strncmp(ublox_info.hwVersion, "00080000", 8) == 0) {
+            LOG_INFO(DETECTED_MESSAGE, "U-blox 8", "8");
+            return GNSS_MODEL_UBLOX8;
+        } else if (strncmp(ublox_info.hwVersion, "00190000", 8) == 0) {
+            LOG_INFO(DETECTED_MESSAGE, "U-blox 9", "9");
+            return GNSS_MODEL_UBLOX9;
+        } else if (strncmp(ublox_info.hwVersion, "000A0000", 8) == 0) {
+            LOG_INFO(DETECTED_MESSAGE, "U-blox 10", "10");
+            return GNSS_MODEL_UBLOX10;
+        }
    }
    LOG_WARN("No GNSS Module (baudrate %d)", serialSpeed);
-    currentDelay = 2000;
-    currentStep = 0;
    return GNSS_MODEL_UNKNOWN;
 }

@@ -1670,8 +1589,12 @@ bool GPS::lookForLocation()

 #ifndef TINYGPS_OPTION_NO_STATISTICS
    if (reader.failedChecksum() > lastChecksumFailCount) {
-        LOG_WARN("%u new GPS checksum failures, for a total of %u", reader.failedChecksum() - lastChecksumFailCount,
-                 reader.failedChecksum());
+// In a GPS_DEBUG build we want to log all of these. In production, we only care if there are many of them.
+#ifndef GPS_DEBUG
+        if (reader.failedChecksum() > 4)
+#endif
+            LOG_WARN("%u new GPS checksum failures, for a total of %u", reader.failedChecksum() - lastChecksumFailCount,
+                     reader.failedChecksum());
        lastChecksumFailCount = reader.failedChecksum();
    }
 #endif
--- a/src/gps/GPS.h
+++ b/src/gps/GPS.h
@@ -16,9 +16,6 @@
 #define GPS_EN_ACTIVE 1
 #endif

-static constexpr uint32_t GPS_UPDATE_ALWAYS_ON_THRESHOLD_MS = 10 * 1000UL;
-static constexpr uint32_t GPS_FIX_HOLD_MAX_MS = 20000;
-
 typedef enum {
    GNSS_MODEL_ATGM336H,
    GNSS_MODEL_MTK,
@@ -154,8 +151,6 @@ class GPS : private concurrency::OSThread
    TinyGPSPlus reader;
    uint8_t fixQual = 0; // fix quality from GPGGA
    uint32_t lastChecksumFailCount = 0;
-    uint8_t currentStep = 0;
-    int32_t currentDelay = 2000;

 #ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
    // (20210908) TinyGps++ can only read the GPGSA "FIX TYPE" field
@@ -178,6 +173,8 @@ class GPS : private concurrency::OSThread
     */
    bool hasValidLocation = false; // default to false, until we complete our first read

+    bool isInPowersave = false;
+
    bool shouldPublish = false; // If we've changed GPS state, this will force a publish the next loop()

    bool hasGPS = false; // Do we have a GPS we are talking to
--- a/src/graphics/Screen.cpp
+++ b/src/graphics/Screen.cpp
@@ -1428,9 +1428,6 @@ int Screen::handleStatusUpdate(const meshtastic::Status *arg)
        }
        nodeDB->updateGUI = false;
        break;
-    case STATUS_TYPE_POWER:
-        forceDisplay(true);
-        break;
    }

    return 0;
@@ -1506,7 +1503,7 @@ int Screen::handleTextMessage(const meshtastic_MeshPacket *packet)
                screen->showSimpleBanner(banner, 1500);
                if (config.device.buzzer_mode != meshtastic_Config_DeviceConfig_BuzzerMode_DIRECT_MSG_ONLY ||
                    (isAlert && moduleConfig.external_notification.alert_bell_buzzer) ||
-                    (!isBroadcast(packet->to) && isToUs(packet))) {
+                    (!isBroadcast(packet->to) && isToUs(p))) {
                    // Beep if not in DIRECT_MSG_ONLY mode or if in DIRECT_MSG_ONLY mode and either
                    // - packet contains an alert and alert bell buzzer is enabled
                    // - packet is a non-broadcast that is addressed to this node
--- a/src/mesh/FloodingRouter.cpp
+++ b/src/mesh/FloodingRouter.cpp
@@ -31,33 +31,8 @@ bool FloodingRouter::shouldFilterReceived(const meshtastic_MeshPacket *p)
        wasSeenRecently(p, true, nullptr, nullptr, &wasUpgraded); // Updates history; returns false when an upgrade is detected

    // Handle hop_limit upgrade scenario for rebroadcasters
-    // isRebroadcaster() is duplicated in perhapsRebroadcast(), but this avoids confusing log messages
-    if (wasUpgraded && isRebroadcaster() && iface && p->hop_limit > 0) {
-        // wasSeenRecently() reports false in upgrade cases so we handle replacement before the duplicate short-circuit
-        // If we overhear a duplicate copy of the packet with more hops left than the one we are waiting to
-        // rebroadcast, then remove the packet currently sitting in the TX queue and use this one instead.
-        uint8_t dropThreshold = p->hop_limit; // remove queued packets that have fewer hops remaining
-        if (iface->removePendingTXPacket(getFrom(p), p->id, dropThreshold)) {
-            LOG_DEBUG("Processing upgraded packet 0x%08x for rebroadcast with hop limit %d (dropping queued < %d)", p->id,
-                      p->hop_limit, dropThreshold);
-
-            if (nodeDB)
-                nodeDB->updateFrom(*p);
-#if !MESHTASTIC_EXCLUDE_TRACEROUTE
-            if (traceRouteModule && p->which_payload_variant == meshtastic_MeshPacket_decoded_tag &&
-                p->decoded.portnum == meshtastic_PortNum_TRACEROUTE_APP)
-                traceRouteModule->processUpgradedPacket(*p);
-#endif
-
-            perhapsRebroadcast(p);
-
-            // We already enqueued the improved copy, so make sure the incoming packet stops here.
-            return true;
-        }
-
-        // No queue entry was replaced by this upgraded copy, so treat it as a duplicate to avoid
-        // delivering the same packet to applications/phone twice with different hop limits.
-        seenRecently = true;
+    if (wasUpgraded && perhapsHandleUpgradedPacket(p)) {
+        return true; // we handled it, so stop processing
    }

    if (seenRecently) {
@@ -70,8 +45,10 @@ bool FloodingRouter::shouldFilterReceived(const meshtastic_MeshPacket *p)
        if (isRepeated) {
            LOG_DEBUG("Repeated reliable tx");
            // Check if it's still in the Tx queue, if not, we have to relay it again
-            if (!findInTxQueue(p->from, p->id))
+            if (!findInTxQueue(p->from, p->id)) {
+                reprocessPacket(p);
                perhapsRebroadcast(p);
+            }
        } else {
            perhapsCancelDupe(p);
        }
@@ -82,6 +59,40 @@ bool FloodingRouter::shouldFilterReceived(const meshtastic_MeshPacket *p)
    return Router::shouldFilterReceived(p);
 }

+bool FloodingRouter::perhapsHandleUpgradedPacket(const meshtastic_MeshPacket *p)
+{
+    // isRebroadcaster() is duplicated in perhapsRebroadcast(), but this avoids confusing log messages
+    if (isRebroadcaster() && iface && p->hop_limit > 0) {
+        // If we overhear a duplicate copy of the packet with more hops left than the one we are waiting to
+        // rebroadcast, then remove the packet currently sitting in the TX queue and use this one instead.
+        uint8_t dropThreshold = p->hop_limit; // remove queued packets that have fewer hops remaining
+        if (iface->removePendingTXPacket(getFrom(p), p->id, dropThreshold)) {
+            LOG_DEBUG("Processing upgraded packet 0x%08x for rebroadcast with hop limit %d (dropping queued < %d)", p->id,
+                      p->hop_limit, dropThreshold);
+
+            reprocessPacket(p);
+            perhapsRebroadcast(p);
+
+            rxDupe++;
+            // We already enqueued the improved copy, so make sure the incoming packet stops here.
+            return true;
+        }
+    }
+
+    return false;
+}
+
+void FloodingRouter::reprocessPacket(const meshtastic_MeshPacket *p)
+{
+    if (nodeDB)
+        nodeDB->updateFrom(*p);
+#if !MESHTASTIC_EXCLUDE_TRACEROUTE
+    if (traceRouteModule && p->which_payload_variant == meshtastic_MeshPacket_decoded_tag &&
+        p->decoded.portnum == meshtastic_PortNum_TRACEROUTE_APP)
+        traceRouteModule->processUpgradedPacket(*p);
+#endif
+}
+
 bool FloodingRouter::roleAllowsCancelingDupe(const meshtastic_MeshPacket *p)
 {
    if (config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER ||
@@ -121,41 +132,6 @@ bool FloodingRouter::isRebroadcaster()
           config.device.rebroadcast_mode != meshtastic_Config_DeviceConfig_RebroadcastMode_NONE;
 }

-void FloodingRouter::perhapsRebroadcast(const meshtastic_MeshPacket *p)
-{
-    if (!isToUs(p) && (p->hop_limit > 0) && !isFromUs(p)) {
-        if (p->id != 0) {
-            if (isRebroadcaster()) {
-                meshtastic_MeshPacket *tosend = packetPool.allocCopy(*p); // keep a copy because we will be sending it
-
-                // Use shared logic to determine if hop_limit should be decremented
-                if (shouldDecrementHopLimit(p)) {
-                    tosend->hop_limit--; // bump down the hop count
-                } else {
-                    LOG_INFO("favorite-ROUTER/CLIENT_BASE-to-ROUTER/CLIENT_BASE flood: preserving hop_limit");
-                }
-#if USERPREFS_EVENT_MODE
-                if (tosend->hop_limit > 2) {
-                    // if we are "correcting" the hop_limit, "correct" the hop_start by the same amount to preserve hops away.
-                    tosend->hop_start -= (tosend->hop_limit - 2);
-                    tosend->hop_limit = 2;
-                }
-#endif
-
-                tosend->next_hop = NO_NEXT_HOP_PREFERENCE; // this should already be the case, but just in case
-
-                LOG_INFO("Rebroadcast received floodmsg");
-                // Note: we are careful to resend using the original senders node id
-                send(tosend);
-            } else {
-                LOG_DEBUG("No rebroadcast: Role = CLIENT_MUTE or Rebroadcast Mode = NONE");
-            }
-        } else {
-            LOG_DEBUG("Ignore 0 id broadcast");
-        }
-    }
-}
-
 void FloodingRouter::sniffReceived(const meshtastic_MeshPacket *p, const meshtastic_Routing *c)
 {
    bool isAckorReply = (p->which_payload_variant == meshtastic_MeshPacket_decoded_tag) &&
--- a/src/mesh/FloodingRouter.h
+++ b/src/mesh/FloodingRouter.h
@@ -27,10 +27,6 @@
 */
 class FloodingRouter : public Router
 {
-  private:
-    /* Check if we should rebroadcast this packet, and do so if needed */
-    void perhapsRebroadcast(const meshtastic_MeshPacket *p);
-
  public:
    /**
     * Constructor
@@ -59,6 +55,17 @@ class FloodingRouter : public Router
     */
    virtual void sniffReceived(const meshtastic_MeshPacket *p, const meshtastic_Routing *c) override;

+    /* Check if we should rebroadcast this packet, and do so if needed */
+    virtual bool perhapsRebroadcast(const meshtastic_MeshPacket *p) = 0;
+
+    /* Check if we should handle an upgraded packet (with higher hop_limit)
+     * @return true if we handled it (so stop processing)
+     */
+    bool perhapsHandleUpgradedPacket(const meshtastic_MeshPacket *p);
+
+    /* Call when we receive a packet that needs some reprocessing, but afterwards should be filtered */
+    void reprocessPacket(const meshtastic_MeshPacket *p);
+
    // Return false for roles like ROUTER which should always rebroadcast even when we've heard another rebroadcast of
    // the same packet
    bool roleAllowsCancelingDupe(const meshtastic_MeshPacket *p);
--- a/src/mesh/NextHopRouter.cpp
+++ b/src/mesh/NextHopRouter.cpp
@@ -43,31 +43,8 @@ bool NextHopRouter::shouldFilterReceived(const meshtastic_MeshPacket *p)
                                        &wasUpgraded); // Updates history; returns false when an upgrade is detected

    // Handle hop_limit upgrade scenario for rebroadcasters
-    // isRebroadcaster() is duplicated in perhapsRelay(), but this avoids confusing log messages
-    if (wasUpgraded && isRebroadcaster() && iface && p->hop_limit > 0) {
-        // Upgrade detection bypasses the duplicate short-circuit so we replace the queued packet before exiting
-        uint8_t dropThreshold = p->hop_limit; // remove queued packets that have fewer hops remaining
-        if (iface->removePendingTXPacket(getFrom(p), p->id, dropThreshold)) {
-            LOG_DEBUG("Processing upgraded packet 0x%08x for relay with hop limit %d (dropping queued < %d)", p->id, p->hop_limit,
-                      dropThreshold);
-
-            if (nodeDB)
-                nodeDB->updateFrom(*p);
-#if !MESHTASTIC_EXCLUDE_TRACEROUTE
-            if (traceRouteModule && p->which_payload_variant == meshtastic_MeshPacket_decoded_tag &&
-                p->decoded.portnum == meshtastic_PortNum_TRACEROUTE_APP)
-                traceRouteModule->processUpgradedPacket(*p);
-#endif
-
-            perhapsRelay(p);
-
-            // We already enqueued the improved copy, so make sure the incoming packet stops here.
-            return true;
-        }
-
-        // No queue entry was replaced by this upgraded copy, so treat it as a duplicate to avoid
-        // delivering the same packet to applications/phone twice with different hop limits.
-        seenRecently = true;
+    if (wasUpgraded && perhapsHandleUpgradedPacket(p)) {
+        return true; // we handled it, so stop processing
    }

    if (seenRecently) {
@@ -82,14 +59,20 @@ bool NextHopRouter::shouldFilterReceived(const meshtastic_MeshPacket *p)
        if (wasFallback) {
            LOG_INFO("Fallback to flooding from relay_node=0x%x", p->relay_node);
            // Check if it's still in the Tx queue, if not, we have to relay it again
-            if (!findInTxQueue(p->from, p->id))
-                perhapsRelay(p);
+            if (!findInTxQueue(p->from, p->id)) {
+                reprocessPacket(p);
+                perhapsRebroadcast(p);
+            }
        } else {
            bool isRepeated = p->hop_start > 0 && p->hop_start == p->hop_limit;
            // If repeated and not in Tx queue anymore, try relaying again, or if we are the destination, send the ACK again
            if (isRepeated) {
-                if (!findInTxQueue(p->from, p->id) && !perhapsRelay(p) && isToUs(p) && p->want_ack)
-                    sendAckNak(meshtastic_Routing_Error_NONE, getFrom(p), p->id, p->channel, 0);
+                if (!findInTxQueue(p->from, p->id)) {
+                    reprocessPacket(p);
+                    if (!perhapsRebroadcast(p) && isToUs(p) && p->want_ack) {
+                        sendAckNak(meshtastic_Routing_Error_NONE, getFrom(p), p->id, p->channel, 0);
+                    }
+                }
            } else if (!weWereNextHop) {
                perhapsCancelDupe(p); // If it's a dupe, cancel relay if we were not explicitly asked to relay
            }
@@ -107,13 +90,14 @@ void NextHopRouter::sniffReceived(const meshtastic_MeshPacket *p, const meshtast
    bool isAckorReply = (p->which_payload_variant == meshtastic_MeshPacket_decoded_tag) &&
                        (p->decoded.request_id != 0 || p->decoded.reply_id != 0);
    if (isAckorReply) {
-        // Update next-hop for the original transmitter of this successful transmission to the relay node, but ONLY if "from" is
-        // not 0 (means implicit ACK) and original packet was also relayed by this node, or we sent it directly to the destination
+        // Update next-hop for the original transmitter of this successful transmission to the relay node, but ONLY if "from"
+        // is not 0 (means implicit ACK) and original packet was also relayed by this node, or we sent it directly to the
+        // destination
        if (p->from != 0) {
            meshtastic_NodeInfoLite *origTx = nodeDB->getMeshNode(p->from);
            if (origTx) {
-                // Either relayer of ACK was also a relayer of the packet, or we were the *only* relayer and the ACK came directly
-                // from the destination
+                // Either relayer of ACK was also a relayer of the packet, or we were the *only* relayer and the ACK came
+                // directly from the destination
                bool wasAlreadyRelayer = wasRelayer(p->relay_node, p->decoded.request_id, p->to);
                bool weWereSoleRelayer = false;
                bool weWereRelayer = wasRelayer(ourRelayID, p->decoded.request_id, p->to, &weWereSoleRelayer);
@@ -134,34 +118,49 @@ void NextHopRouter::sniffReceived(const meshtastic_MeshPacket *p, const meshtast
        }
    }

-    perhapsRelay(p);
+    perhapsRebroadcast(p);

    // handle the packet as normal
    Router::sniffReceived(p, c);
 }

-/* Check if we should be relaying this packet if so, do so. */
-bool NextHopRouter::perhapsRelay(const meshtastic_MeshPacket *p)
+/* Check if we should be rebroadcasting this packet if so, do so. */
+bool NextHopRouter::perhapsRebroadcast(const meshtastic_MeshPacket *p)
 {
    if (!isToUs(p) && !isFromUs(p) && p->hop_limit > 0) {
-        if (p->next_hop == NO_NEXT_HOP_PREFERENCE || p->next_hop == nodeDB->getLastByteOfNodeNum(getNodeNum())) {
+        if (p->id != 0) {
            if (isRebroadcaster()) {
-                meshtastic_MeshPacket *tosend = packetPool.allocCopy(*p); // keep a copy because we will be sending it
-                LOG_INFO("Relaying received message coming from %x", p->relay_node);
+                if (p->next_hop == NO_NEXT_HOP_PREFERENCE || p->next_hop == nodeDB->getLastByteOfNodeNum(getNodeNum())) {
+                    meshtastic_MeshPacket *tosend = packetPool.allocCopy(*p); // keep a copy because we will be sending it
+                    LOG_INFO("Rebroadcast received message coming from %x", p->relay_node);

-                // Use shared logic to determine if hop_limit should be decremented
-                if (shouldDecrementHopLimit(p)) {
-                    tosend->hop_limit--; // bump down the hop count
-                } else {
-                    LOG_INFO("Router/CLIENT_BASE-to-favorite-router/CLIENT_BASE relay: preserving hop_limit");
+                    // Use shared logic to determine if hop_limit should be decremented
+                    if (shouldDecrementHopLimit(p)) {
+                        tosend->hop_limit--; // bump down the hop count
+                    } else {
+                        LOG_INFO("favorite-ROUTER/CLIENT_BASE-to-ROUTER/CLIENT_BASE rebroadcast: preserving hop_limit");
+                    }
+#if USERPREFS_EVENT_MODE
+                    if (tosend->hop_limit > 2) {
+                        // if we are "correcting" the hop_limit, "correct" the hop_start by the same amount to preserve hops away.
+                        tosend->hop_start -= (tosend->hop_limit - 2);
+                        tosend->hop_limit = 2;
+                    }
+#endif
+
+                    if (p->next_hop == NO_NEXT_HOP_PREFERENCE) {
+                        FloodingRouter::send(tosend);
+                    } else {
+                        NextHopRouter::send(tosend);
+                    }
+
+                    return true;
                }
-
-                NextHopRouter::send(tosend);
-
-                return true;
            } else {
-                LOG_DEBUG("Not rebroadcasting: Role = CLIENT_MUTE or Rebroadcast Mode = NONE");
+                LOG_DEBUG("No rebroadcast: Role = CLIENT_MUTE or Rebroadcast Mode = NONE");
            }
+        } else {
+            LOG_DEBUG("Ignore 0 id broadcast");
        }
    }

@@ -231,13 +230,13 @@ bool NextHopRouter::stopRetransmission(GlobalPacketId key)
            }
        }

-        // Regardless of whether or not we canceled this packet from the txQueue, remove it from our pending list so it doesn't
-        // get scheduled again. (This is the core of stopRetransmission.)
+        // Regardless of whether or not we canceled this packet from the txQueue, remove it from our pending list so it
+        // doesn't get scheduled again. (This is the core of stopRetransmission.)
        auto numErased = pending.erase(key);
        assert(numErased == 1);

-        // When we remove an entry from pending, always be sure to release the copy of the packet that was allocated in the call
-        // to startRetransmission.
+        // When we remove an entry from pending, always be sure to release the copy of the packet that was allocated in the
+        // call to startRetransmission.
        packetPool.release(p);

        return true;
--- a/src/mesh/NextHopRouter.h
+++ b/src/mesh/NextHopRouter.h
@@ -148,7 +148,7 @@ class NextHopRouter : public FloodingRouter
     */
    uint8_t getNextHop(NodeNum to, uint8_t relay_node);

-    /** Check if we should be relaying this packet if so, do so.
-     *  @return true if we did relay */
-    bool perhapsRelay(const meshtastic_MeshPacket *p);
+    /** Check if we should be rebroadcasting this packet if so, do so.
+     *  @return true if we did rebroadcast */
+    bool perhapsRebroadcast(const meshtastic_MeshPacket *p) override;
 };
--- a/src/mesh/NodeDB.cpp
+++ b/src/mesh/NodeDB.cpp
@@ -1874,13 +1874,6 @@ uint8_t NodeDB::getMeshNodeChannel(NodeNum n)
    return info->channel;
 }

-std::string NodeDB::getNodeId() const
-{
-    char nodeId[16];
-    snprintf(nodeId, sizeof(nodeId), "!%08x", myNodeInfo.my_node_num);
-    return std::string(nodeId);
-}
-
 /// Find a node in our DB, return null for missing
 /// NOTE: This function might be called from an ISR
 meshtastic_NodeInfoLite *NodeDB::getMeshNode(NodeNum n)
--- a/src/mesh/NodeDB.h
+++ b/src/mesh/NodeDB.h
@@ -5,7 +5,6 @@
 #include <algorithm>
 #include <assert.h>
 #include <pb_encode.h>
-#include <string>
 #include <vector>

 #include "MeshTypes.h"
@@ -204,9 +203,6 @@ class NodeDB
    /// @return our node number
    NodeNum getNodeNum() { return myNodeInfo.my_node_num; }

-    /// @return our node ID as a string in the format "!xxxxxxxx"
-    std::string getNodeId() const;
-
    // @return last byte of a NodeNum, 0xFF if it ended at 0x00
    uint8_t getLastByteOfNodeNum(NodeNum num) { return (uint8_t)((num & 0xFF) ? (num & 0xFF) : 0xFF); }

--- a/src/mesh/PacketHistory.cpp
+++ b/src/mesh/PacketHistory.cpp
@@ -94,7 +94,6 @@ bool PacketHistory::wasSeenRecently(const meshtastic_MeshPacket *p, bool withUpd
        LOG_DEBUG("Packet History - Hop limit upgrade: packet 0x%08x from hop_limit=%d to hop_limit=%d", p->id, found->hop_limit,
                  p->hop_limit);
        *wasUpgraded = true;
-        seenRecently = false; // Allow router processing but prevent duplicate app delivery
    } else if (wasUpgraded) {
        *wasUpgraded = false; // Initialize to false if not an upgrade
    }
--- a/src/mesh/PhoneAPI.cpp
+++ b/src/mesh/PhoneAPI.cpp
@@ -431,9 +431,8 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf)
        break;

    case STATE_SEND_OTHER_NODEINFOS: {
+        LOG_DEBUG("Send known nodes");
        if (nodeInfoForPhone.num != 0) {
-            // Just in case we stored a different user.id in the past, but should never happen going forward
-            sprintf(nodeInfoForPhone.user.id, "!%08x", nodeInfoForPhone.num);
            LOG_INFO("nodeinfo: num=0x%x, lastseen=%u, id=%s, name=%s", nodeInfoForPhone.num, nodeInfoForPhone.last_heard,
                     nodeInfoForPhone.user.id, nodeInfoForPhone.user.long_name);
            fromRadioScratch.which_payload_variant = meshtastic_FromRadio_node_info_tag;
@@ -591,7 +590,6 @@ bool PhoneAPI::available()
                nodeInfoForPhone.snr = isUs ? 0 : nodeInfoForPhone.snr;
                nodeInfoForPhone.via_mqtt = isUs ? false : nodeInfoForPhone.via_mqtt;
                nodeInfoForPhone.is_favorite = nodeInfoForPhone.is_favorite || isUs; // Our node is always a favorite
-
                onNowHasData(0);
            }
        }
@@ -734,7 +732,7 @@ int PhoneAPI::onNotify(uint32_t newValue)
        LOG_INFO("Tell client we have new packets %u", newValue);
        onNowHasData(newValue);
    } else {
-        LOG_DEBUG("Client not yet interested in packets (state=%d)", state);
+        LOG_DEBUG("(Client not yet interested in packets)");
    }

    return timeout ? -1 : 0; // If we timed out, MeshService should stop iterating through observers as we just removed one
--- a/src/mesh/http/ContentHandler.cpp
+++ b/src/mesh/http/ContentHandler.cpp
@@ -148,6 +148,8 @@ void registerHandlers(HTTPServer *insecureServer, HTTPSServer *secureServer)

 void handleAPIv1FromRadio(HTTPRequest *req, HTTPResponse *res)
 {
+    if (webServerThread)
+        webServerThread->markActivity();

    LOG_DEBUG("webAPI handleAPIv1FromRadio");

@@ -391,6 +393,9 @@ void handleFsDeleteStatic(HTTPRequest *req, HTTPResponse *res)

 void handleStatic(HTTPRequest *req, HTTPResponse *res)
 {
+    if (webServerThread)
+        webServerThread->markActivity();
+
    // Get access to the parameters
    ResourceParameters *params = req->getParams();

--- a/src/mesh/http/WebServer.cpp
+++ b/src/mesh/http/WebServer.cpp
@@ -49,6 +49,12 @@ Preferences prefs;
 using namespace httpsserver;
 #include "mesh/http/ContentHandler.h"

+static const uint32_t ACTIVE_THRESHOLD_MS = 5000;
+static const uint32_t MEDIUM_THRESHOLD_MS = 30000;
+static const int32_t ACTIVE_INTERVAL_MS = 50;
+static const int32_t MEDIUM_INTERVAL_MS = 200;
+static const int32_t IDLE_INTERVAL_MS = 1000;
+
 static SSLCert *cert;
 static HTTPSServer *secureServer;
 static HTTPServer *insecureServer;
@@ -175,6 +181,32 @@ WebServerThread::WebServerThread() : concurrency::OSThread("WebServer")
    if (!config.network.wifi_enabled && !config.network.eth_enabled) {
        disable();
    }
+    lastActivityTime = millis();
+}
+
+void WebServerThread::markActivity()
+{
+    lastActivityTime = millis();
+}
+
+int32_t WebServerThread::getAdaptiveInterval()
+{
+    uint32_t currentTime = millis();
+    uint32_t timeSinceActivity;
+
+    if (currentTime >= lastActivityTime) {
+        timeSinceActivity = currentTime - lastActivityTime;
+    } else {
+        timeSinceActivity = (UINT32_MAX - lastActivityTime) + currentTime + 1;
+    }
+
+    if (timeSinceActivity < ACTIVE_THRESHOLD_MS) {
+        return ACTIVE_INTERVAL_MS;
+    } else if (timeSinceActivity < MEDIUM_THRESHOLD_MS) {
+        return MEDIUM_INTERVAL_MS;
+    } else {
+        return IDLE_INTERVAL_MS;
+    }
 }

 int32_t WebServerThread::runOnce()
@@ -189,8 +221,7 @@ int32_t WebServerThread::runOnce()
        ESP.restart();
    }

-    // Loop every 5ms.
-    return (5);
+    return getAdaptiveInterval();
 }

 void initWebServer()
--- a/src/mesh/http/WebServer.h
+++ b/src/mesh/http/WebServer.h
@@ -10,13 +10,17 @@ void createSSLCert();

 class WebServerThread : private concurrency::OSThread
 {
+  private:
+    uint32_t lastActivityTime = 0;

  public:
    WebServerThread();
    uint32_t requestRestart = 0;
+    void markActivity();

  protected:
    virtual int32_t runOnce() override;
+    int32_t getAdaptiveInterval();
 };

 extern WebServerThread *webServerThread;
--- a/src/mesh/wifi/WiFiAPClient.cpp
+++ b/src/mesh/wifi/WiFiAPClient.cpp
@@ -94,11 +94,11 @@ static void onNetworkConnected()
 // ESPmDNS (ESP32) and SimpleMDNS (RP2040) have slightly different APIs for adding TXT records
 #ifdef ARCH_ESP32
            MDNS.addServiceTxt("meshtastic", "tcp", "shortname", String(owner.short_name));
-            MDNS.addServiceTxt("meshtastic", "tcp", "id", String(nodeDB->getNodeId().c_str()));
+            MDNS.addServiceTxt("meshtastic", "tcp", "id", String(owner.id));
            // ESP32 prints obtained IP address in WiFiEvent
 #elif defined(ARCH_RP2040)
            MDNS.addServiceTxt("meshtastic", "shortname", owner.short_name);
-            MDNS.addServiceTxt("meshtastic", "id", nodeDB->getNodeId().c_str());
+            MDNS.addServiceTxt("meshtastic", "id", owner.id);
            LOG_INFO("Obtained IP address: %s", WiFi.localIP().toString().c_str());
 #endif
        }
--- a/src/modules/NodeInfoModule.cpp
+++ b/src/modules/NodeInfoModule.cpp
@@ -113,12 +113,8 @@ meshtastic_MeshPacket *NodeInfoModule::allocReply()
            u.public_key.size = 0;
        }

-        // FIXME: Clear the user.id field since it should be derived from node number on the receiving end
-        // u.id[0] = '\0';
-
-        // Ensure our user.id is derived correctly
-        strcpy(u.id, nodeDB->getNodeId().c_str());
-
+        // Clear the user.id field since it should be derived from node number on the receiving end
+        u.id[0] = '\0';
        LOG_INFO("Send owner %s/%s/%s", u.id, u.long_name, u.short_name);
        lastSentToMesh = millis();
        return allocDataProtobuf(u);
--- a/src/modules/SerialModule.cpp
+++ b/src/modules/SerialModule.cpp
@@ -67,7 +67,7 @@ SerialModuleRadio *serialModuleRadio;
    defined(ELECROW_ThinkNode_M5) || defined(HELTEC_MESH_SOLAR) || defined(T_ECHO_LITE)
 SerialModule::SerialModule() : StreamAPI(&Serial), concurrency::OSThread("Serial") {}
 static Print *serialPrint = &Serial;
-#elif defined(CONFIG_IDF_TARGET_ESP32C6) || defined(RAK3172) || defined(EBYTE_E77_MBL)
+#elif defined(CONFIG_IDF_TARGET_ESP32C6) || defined(RAK3172)
 SerialModule::SerialModule() : StreamAPI(&Serial1), concurrency::OSThread("Serial") {}
 static Print *serialPrint = &Serial1;
 #else
--- a/src/modules/TraceRouteModule.cpp
+++ b/src/modules/TraceRouteModule.cpp
@@ -21,6 +21,11 @@ void TraceRouteModule::alterReceivedProtobuf(meshtastic_MeshPacket &p, meshtasti
 {
    const meshtastic_Data &incoming = p.decoded;

+    // Update next-hops using returned route
+    if (incoming.request_id) {
+        updateNextHops(p, r);
+    }
+
    // Insert unknown hops if necessary
    insertUnknownHops(p, r, !incoming.request_id);

@@ -153,6 +158,65 @@ void TraceRouteModule::alterReceivedProtobuf(meshtastic_MeshPacket &p, meshtasti
    }
 }

+void TraceRouteModule::updateNextHops(meshtastic_MeshPacket &p, meshtastic_RouteDiscovery *r)
+{
+    // E.g. if the route is A->B->C->D and we are B, we can set C as next-hop for C and D
+    // Similarly, if we are C, we can set D as next-hop for D
+    // If we are A, we can set B as next-hop for B, C and D
+
+    // First check if we were the original sender or in the original route
+    int8_t nextHopIndex = -1;
+    if (isToUs(&p)) {
+        nextHopIndex = 0; // We are the original sender, next hop is first in route
+    } else {
+        // Check if we are in the original route
+        for (uint8_t i = 0; i < r->route_count; i++) {
+            if (r->route[i] == nodeDB->getNodeNum()) {
+                nextHopIndex = i + 1; // Next hop is the one after us
+                break;
+            }
+        }
+    }
+
+    // If we are in the original route, update the next hops
+    if (nextHopIndex != -1) {
+        // For every node after us, we can set the next-hop to the first node after us
+        NodeNum nextHop;
+        if (nextHopIndex == r->route_count) {
+            nextHop = p.from; // We are the last in the route, next hop is destination
+        } else {
+            nextHop = r->route[nextHopIndex];
+        }
+
+        if (nextHop == NODENUM_BROADCAST) {
+            return;
+        }
+        uint8_t nextHopByte = nodeDB->getLastByteOfNodeNum(nextHop);
+
+        // For the rest of the nodes in the route, set their next-hop
+        // Note: if we are the last in the route, this loop will not run
+        for (int8_t i = nextHopIndex; i < r->route_count; i++) {
+            NodeNum targetNode = r->route[i];
+            maybeSetNextHop(targetNode, nextHopByte);
+        }
+
+        // Also set next-hop for the destination node
+        maybeSetNextHop(p.from, nextHopByte);
+    }
+}
+
+void TraceRouteModule::maybeSetNextHop(NodeNum target, uint8_t nextHopByte)
+{
+    if (target == NODENUM_BROADCAST)
+        return;
+
+    meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(target);
+    if (node && node->next_hop != nextHopByte) {
+        LOG_INFO("Updating next-hop for 0x%08x to 0x%02x based on traceroute", target, nextHopByte);
+        node->next_hop = nextHopByte;
+    }
+}
+
 void TraceRouteModule::processUpgradedPacket(const meshtastic_MeshPacket &mp)
 {
    if (mp.which_payload_variant != meshtastic_MeshPacket_decoded_tag || mp.decoded.portnum != meshtastic_PortNum_TRACEROUTE_APP)
--- a/src/modules/TraceRouteModule.h
+++ b/src/modules/TraceRouteModule.h
@@ -55,6 +55,12 @@ class TraceRouteModule : public ProtobufModule<meshtastic_RouteDiscovery>,
    // Call to add your ID to the route array of a RouteDiscovery message
    void appendMyIDandSNR(meshtastic_RouteDiscovery *r, float snr, bool isTowardsDestination, bool SNRonly);

+    // Update next-hops in the routing table based on the returned route
+    void updateNextHops(meshtastic_MeshPacket &p, meshtastic_RouteDiscovery *r);
+
+    // Helper to update next-hop for a single node
+    void maybeSetNextHop(NodeNum target, uint8_t nextHopByte);
+
    /* Call to print the route array of a RouteDiscovery message.
       Set origin to where the request came from.
       Set dest to the ID of its destination, or NODENUM_BROADCAST if it has not yet arrived there. */
--- a/src/mqtt/MQTT.cpp
+++ b/src/mqtt/MQTT.cpp
@@ -60,9 +60,7 @@ inline void onReceiveProto(char *topic, byte *payload, size_t length)
        return;
    }
    const meshtastic_Channel &ch = channels.getByName(e.channel_id);
-    // Generate node ID from nodenum for comparison
-    std::string nodeId = nodeDB->getNodeId();
-    if (strcmp(e.gateway_id, nodeId.c_str()) == 0) {
+    if (strcmp(e.gateway_id, owner.id) == 0) {
        // Generate an implicit ACK towards ourselves (handled and processed only locally!) for this message.
        // We do this because packets are not rebroadcasted back into MQTT anymore and we assume that at least one node
        // receives it when we get our own packet back. Then we'll stop our retransmissions.
@@ -130,10 +128,8 @@ inline void onReceiveProto(char *topic, byte *payload, size_t length)
 // returns true if this is a valid JSON envelope which we accept on downlink
 inline bool isValidJsonEnvelope(JSONObject &json)
 {
-    // Generate node ID from nodenum for comparison
-    std::string nodeId = nodeDB->getNodeId();
    // if "sender" is provided, avoid processing packets we uplinked
-    return (json.find("sender") != json.end() ? (json["sender"]->AsString().compare(nodeId) != 0) : true) &&
+    return (json.find("sender") != json.end() ? (json["sender"]->AsString().compare(owner.id) != 0) : true) &&
           (json.find("hopLimit") != json.end() ? json["hopLimit"]->IsNumber() : true) && // hop limit should be a number
           (json.find("from") != json.end()) && json["from"]->IsNumber() &&
           (json["from"]->AsNumber() == nodeDB->getNodeNum()) &&            // only accept message if the "from" is us
@@ -301,9 +297,7 @@ bool connectPubSub(const PubSubConfig &config, PubSubClient &pubSub, Client &cli
    LOG_INFO("Connecting directly to MQTT server %s, port: %d, username: %s, password: %s", config.serverAddr.c_str(),
             config.serverPort, config.mqttUsername, config.mqttPassword);

-    // Generate node ID from nodenum for client identification
-    std::string nodeId = nodeDB->getNodeId();
-    const bool connected = pubSub.connect(nodeId.c_str(), config.mqttUsername, config.mqttPassword);
+    const bool connected = pubSub.connect(owner.id, config.mqttUsername, config.mqttPassword);
    if (connected) {
        LOG_INFO("MQTT connected");
    } else {
@@ -693,14 +687,11 @@ void MQTT::publishQueuedMessages()
    if (jsonString.length() == 0)
        return;

-    // Generate node ID from nodenum for topic
-    std::string nodeId = nodeDB->getNodeId();
-
    std::string topicJson;
    if (env.packet->pki_encrypted) {
-        topicJson = jsonTopic + "PKI/" + nodeId;
+        topicJson = jsonTopic + "PKI/" + owner.id;
    } else {
-        topicJson = jsonTopic + env.channel_id + "/" + nodeId;
+        topicJson = jsonTopic + env.channel_id + "/" + owner.id;
    }
    LOG_INFO("JSON publish message to %s, %u bytes: %s", topicJson.c_str(), jsonString.length(), jsonString.c_str());
    publish(topicJson.c_str(), jsonString.c_str(), false);
@@ -758,14 +749,10 @@ void MQTT::onSend(const meshtastic_MeshPacket &mp_encrypted, const meshtastic_Me
        return; // Don't upload a still-encrypted PKI packet if not encryption_enabled
    }

-    // Generate node ID from nodenum for service envelope
-    std::string nodeId = nodeDB->getNodeId();
-
-    const meshtastic_ServiceEnvelope env = {.packet = const_cast<meshtastic_MeshPacket *>(p),
-                                            .channel_id = const_cast<char *>(channelId),
-                                            .gateway_id = const_cast<char *>(nodeId.c_str())};
+    const meshtastic_ServiceEnvelope env = {
+        .packet = const_cast<meshtastic_MeshPacket *>(p), .channel_id = const_cast<char *>(channelId), .gateway_id = owner.id};
    size_t numBytes = pb_encode_to_bytes(bytes, sizeof(bytes), &meshtastic_ServiceEnvelope_msg, &env);
-    std::string topic = cryptTopic + channelId + "/" + nodeId;
+    std::string topic = cryptTopic + channelId + "/" + owner.id;

    if (moduleConfig.mqtt.proxy_to_client_enabled || this->isConnectedDirectly()) {
        LOG_DEBUG("MQTT Publish %s, %u bytes", topic.c_str(), numBytes);
@@ -779,9 +766,7 @@ void MQTT::onSend(const meshtastic_MeshPacket &mp_encrypted, const meshtastic_Me
        auto jsonString = MeshPacketSerializer::JsonSerialize(&mp_decoded);
        if (jsonString.length() == 0)
            return;
-        // Generate node ID from nodenum for JSON topic
-        std::string nodeIdForJson = nodeDB->getNodeId();
-        std::string topicJson = jsonTopic + channelId + "/" + nodeIdForJson;
+        std::string topicJson = jsonTopic + channelId + "/" + owner.id;
        LOG_INFO("JSON publish message to %s, %u bytes: %s", topicJson.c_str(), jsonString.length(), jsonString.c_str());
        publish(topicJson.c_str(), jsonString.c_str(), false);
 #endif // ARCH_NRF52 NRF52_USE_JSON
@@ -860,14 +845,11 @@ void MQTT::perhapsReportToMap()
    mp->decoded.payload.size =
        pb_encode_to_bytes(mp->decoded.payload.bytes, sizeof(mp->decoded.payload.bytes), &meshtastic_MapReport_msg, &mapReport);

-    // Generate node ID from nodenum for service envelope
-    std::string nodeId = nodeDB->getNodeId();
-
    // Encode the MeshPacket into a binary ServiceEnvelope and publish
    const meshtastic_ServiceEnvelope se = {
        .packet = mp,
        .channel_id = (char *)channels.getGlobalId(channels.getPrimaryIndex()), // Use primary channel as the channel_id
-        .gateway_id = const_cast<char *>(nodeId.c_str())};
+        .gateway_id = owner.id};
    size_t numBytes = pb_encode_to_bytes(bytes, sizeof(bytes), &meshtastic_ServiceEnvelope_msg, &se);

    LOG_INFO("MQTT Publish map report to %s", mapTopic.c_str());
--- a/src/nimble/NimbleBluetooth.cpp
+++ b/src/nimble/NimbleBluetooth.cpp
@@ -31,8 +31,11 @@ class BluetoothPhoneAPI : public PhoneAPI, public concurrency::OSThread
    std::vector<NimBLEAttValue> nimble_queue;
    std::mutex nimble_mutex;
    uint8_t queue_size = 0;
+    bool has_fromRadio = false;
    uint8_t fromRadioBytes[meshtastic_FromRadio_size] = {0};
    size_t numBytes = 0;
+    bool hasChecked = false;
+    bool phoneWants = false;

  protected:
    virtual int32_t runOnce() override
@@ -45,7 +48,10 @@ class BluetoothPhoneAPI : public PhoneAPI, public concurrency::OSThread
            LOG_DEBUG("Queue_size %u", queue_size);
            queue_size = 0;
        }
-        // Note: phoneWants/hasChecked logic removed since onRead() handles getFromRadio() directly
+        if (hasChecked == false && phoneWants == true) {
+            numBytes = getFromRadio(fromRadioBytes);
+            hasChecked = true;
+        }

        // the run is triggered via NimbleBluetoothToRadioCallback and NimbleBluetoothFromRadioCallback
        return INT32_MAX;
@@ -114,17 +120,21 @@ class NimbleBluetoothFromRadioCallback : public NimBLECharacteristicCallbacks
    virtual void onRead(NimBLECharacteristic *pCharacteristic)
 #endif
    {
+        int tries = 0;
+        bluetoothPhoneAPI->phoneWants = true;
+        while (!bluetoothPhoneAPI->hasChecked && tries < 100) {
+            bluetoothPhoneAPI->setIntervalFromNow(0);
+            delay(20);
+            tries++;
+        }
        std::lock_guard<std::mutex> guard(bluetoothPhoneAPI->nimble_mutex);
-
-        // Get fresh data immediately when client reads
-        bluetoothPhoneAPI->numBytes = bluetoothPhoneAPI->getFromRadio(bluetoothPhoneAPI->fromRadioBytes);
-
-        // Set the characteristic value with whatever data we have
        pCharacteristic->setValue(bluetoothPhoneAPI->fromRadioBytes, bluetoothPhoneAPI->numBytes);

        if (bluetoothPhoneAPI->numBytes != 0) // if we did send something, queue it up right away to reload
            bluetoothPhoneAPI->setIntervalFromNow(0);
        bluetoothPhoneAPI->numBytes = 0;
+        bluetoothPhoneAPI->hasChecked = false;
+        bluetoothPhoneAPI->phoneWants = false;
    }
 };

@@ -233,6 +243,8 @@ class NimbleBluetoothServerCallback : public NimBLEServerCallbacks
        if (bluetoothPhoneAPI) {
            std::lock_guard<std::mutex> guard(bluetoothPhoneAPI->nimble_mutex);
            bluetoothPhoneAPI->close();
+            bluetoothPhoneAPI->hasChecked = false;
+            bluetoothPhoneAPI->phoneWants = false;
            bluetoothPhoneAPI->numBytes = 0;
            bluetoothPhoneAPI->queue_size = 0;
        }
--- a/src/platform/portduino/USBHal.h
+++ b/src/platform/portduino/USBHal.h
@@ -8,6 +8,9 @@
 #include <iostream>
 #include <libpinedio-usb.h>
 #include <unistd.h>
+extern "C" {
+#include "platform/portduino/ch341a_i2c.h"
+}

 // include the library for Raspberry GPIO pins

@@ -47,6 +50,9 @@ class Ch341Hal : public RadioLibHal
            std::string s = "Could not open SPI: ";
            throw(s + std::to_string(ret));
        }
+        // How to read the eeprom
+        // uint8_t buffer[1024] = {0};
+        // ch341readEEPROM_param(buffer, 0, 128, 128, 8, 1, 0x50, pinedio.handle);

        pinedio_set_option(&pinedio, PINEDIO_OPTION_AUTO_CS, 0);
        pinedio_set_pin_mode(&pinedio, 3, true);
--- a/src/platform/portduino/ch341a_i2c.c
+++ b/src/platform/portduino/ch341a_i2c.c
@@ -0,0 +1,204 @@
+//
+// ch341eeprom programmer version 0.1 (Beta)
+//
+//  Programming tool for the 24Cxx serial EEPROMs using the Winchiphead CH341A IC
+//
+// (c) December 2011 asbokid <ballymunboy@gmail.com>
+//  (c) August 2023 Mikhail Medvedev <e-ink-reader@yandex.ru>
+//   This program is free software: you can redistribute it and/or modify
+//   it under the terms of the GNU General Public License as published by
+//   the Free Software Foundation, either version 3 of the License, or
+//   (at your option) any later version.
+//
+//   This program is distributed in the hope that it will be useful,
+//   but WITHOUT ANY WARRANTY; without even the implied warranty of
+//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//   GNU General Public License for more details.
+//
+//   You should have received a copy of the GNU General Public License
+//   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "ch341a_i2c.h"
+
+// extern struct libusb_device_handle *handle;
+unsigned char *readbuf;
+uint32_t getnextpkt; // set by the callback function
+uint32_t syncackpkt; // synch / ack flag used by BULK OUT cb function
+uint32_t byteoffset;
+
+// callback functions for async USB transfers
+static void cbBulkIn(struct libusb_transfer *transfer);
+static void cbBulkOut(struct libusb_transfer *transfer);
+
+void ch341ReadCmdMarshall(uint8_t *buffer, uint32_t addr, struct EEPROM *eeprom_info, uint32_t i2c_address)
+{
+    uint8_t *ptr = buffer;
+    uint8_t msb_addr;
+    uint32_t size_kb;
+
+    *ptr++ = CH341_CMD_I2C_STREAM;  // 0
+    *ptr++ = CH341_CMD_I2C_STM_STA; // 1
+    // Write address
+    *ptr++ = CH341_CMD_I2C_STM_OUT | ((*eeprom_info).addr_size + 1); // 2: I2C bus adddress + EEPROM address
+    if ((*eeprom_info).addr_size >= 2) {
+        // 24C32 and more
+        msb_addr = addr >> 16 & (*eeprom_info).i2c_addr_mask;
+        *ptr++ = (i2c_address | msb_addr) << 1; // 3
+        *ptr++ = (addr >> 8 & 0xFF);            // 4
+        *ptr++ = (addr >> 0 & 0xFF);            // 5
+    } else {
+        // 24C16 and less
+        msb_addr = addr >> 8 & (*eeprom_info).i2c_addr_mask;
+        *ptr++ = (i2c_address | msb_addr) << 1; // 3
+        *ptr++ = (addr >> 0 & 0xFF);            // 4
+    }
+    // Read
+    *ptr++ = CH341_CMD_I2C_STM_STA;               // 6/5
+    *ptr++ = CH341_CMD_I2C_STM_OUT | 1;           // 7/6
+    *ptr++ = ((i2c_address | msb_addr) << 1) | 1; // 8/7: Read command
+
+    // Configuration?
+    *ptr++ = 0xE0; // 9/8
+    *ptr++ = 0x00; // 10/9
+    if ((*eeprom_info).addr_size < 2)
+        *ptr++ = 0x10; // x/10
+    memcpy(ptr, "\x00\x06\x04\x00\x00\x00\x00\x00\x00", 9);
+    ptr += 9; // 10
+    size_kb = (*eeprom_info).size / 1024;
+    *ptr++ = size_kb & 0xFF;        // 19
+    *ptr++ = (size_kb >> 8) & 0xFF; // 20
+    memcpy(ptr, "\x00\x00\x11\x4d\x40\x77\xcd\xab\xba\xdc", 10);
+    ptr += 10;
+
+    // Frame 2
+    *ptr++ = CH341_CMD_I2C_STREAM;
+    memcpy(ptr,
+           "\xe0\x00\x00\xc4\xf1\x12\x00\x11\x4d\x40\x77\xf0\xf1\x12\x00"
+           "\xd9\x8b\x41\x7e\x00\xe0\xfd\x7f\xf0\xf1\x12\x00\x5a\x88\x41\x7e",
+           31);
+    ptr += 31;
+
+    // Frame 3
+    *ptr++ = CH341_CMD_I2C_STREAM;
+    memcpy(ptr,
+           "\xe0\x00\x00\x2a\x88\x41\x7e\x06\x04\x00\x00\x11\x4d\x40\x77"
+           "\xe8\xf3\x12\x00\x14\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00",
+           31);
+    ptr += 31;
+
+    // Finalize
+    *ptr++ = CH341_CMD_I2C_STREAM;  // 0xAA
+    *ptr++ = 0xDF;                  // ???
+    *ptr++ = CH341_CMD_I2C_STM_IN;  // 0xC0
+    *ptr++ = CH341_CMD_I2C_STM_STO; // 0x75
+    *ptr++ = CH341_CMD_I2C_STM_END; // 0x00
+
+    assert(ptr - buffer == CH341_EEPROM_READ_CMD_SZ);
+}
+
+// --------------------------------------------------------------------------
+// ch341readEEPROM()
+//      read n bytes from device (in packets of 32 bytes)
+int32_t ch341readEEPROM_param(uint8_t *buffer, uint32_t offset, uint32_t bytestoread, uint32_t ic_size, uint32_t block_size,
+                              uint8_t algorithm, uint32_t i2c_address, struct libusb_device_handle *handle)
+{
+
+    uint8_t ch341outBuffer[EEPROM_READ_BULKOUT_BUF_SZ];
+    uint8_t ch341inBuffer[IN_BUF_SZ]; // 0x100 bytes
+    int32_t ret = 0, readpktcount = 0;
+    struct libusb_transfer *xferBulkIn, *xferBulkOut;
+    struct timeval tv = {0, 100}; // our async polling interval
+    struct EEPROM eeprom_info;
+    eeprom_info.name = "24c01";
+    eeprom_info.size = ic_size;
+    eeprom_info.page_size = (uint16_t)block_size;
+    eeprom_info.addr_size = 0x0f & algorithm;
+    eeprom_info.i2c_addr_mask = (0xf0 & algorithm) / 16;
+
+    xferBulkIn = libusb_alloc_transfer(0);
+    xferBulkOut = libusb_alloc_transfer(0);
+
+    if (!xferBulkIn || !xferBulkOut) {
+        printf("Couldn't allocate USB transfer structures\n");
+        return -1;
+    }
+
+    byteoffset = 0;
+
+    memset(ch341inBuffer, 0, EEPROM_READ_BULKIN_BUF_SZ);
+    ch341ReadCmdMarshall(ch341outBuffer, offset, &eeprom_info, i2c_address); // Fill output buffer
+
+    libusb_fill_bulk_transfer(xferBulkIn, handle, BULK_READ_ENDPOINT, ch341inBuffer, EEPROM_READ_BULKIN_BUF_SZ, cbBulkIn, NULL,
+                              DEFAULT_TIMEOUT);
+
+    libusb_fill_bulk_transfer(xferBulkOut, handle, BULK_WRITE_ENDPOINT, ch341outBuffer, EEPROM_READ_BULKOUT_BUF_SZ, cbBulkOut,
+                              NULL, DEFAULT_TIMEOUT);
+
+    libusb_submit_transfer(xferBulkIn);
+    libusb_submit_transfer(xferBulkOut);
+
+    readbuf = buffer;
+
+    while (1) {
+        ret = libusb_handle_events_timeout(NULL, &tv);
+
+        if (ret < 0 || getnextpkt == -1) { // indicates an error
+            printf("ret from libusb_handle_timeout = %d\n", ret);
+            printf("getnextpkt = %u\n", getnextpkt);
+            if (ret < 0)
+                printf("USB read error : %s\n", strerror(-ret));
+            libusb_free_transfer(xferBulkIn);
+            libusb_free_transfer(xferBulkOut);
+            return -1;
+        }
+        if (getnextpkt == 1) { // callback function reports a new BULK IN packet received
+            getnextpkt = 0;    // reset the flag
+            readpktcount++;    // increment the read packet counter
+            byteoffset += EEPROM_READ_BULKIN_BUF_SZ;
+            if (byteoffset == bytestoread)
+                break;
+
+            libusb_submit_transfer(xferBulkIn); // re-submit request for next BULK IN packet of EEPROM data
+            if (syncackpkt)
+                syncackpkt = 0;
+            // if 4th packet received, we are at end of 0x80 byte data block,
+            // if it is not the last block, then resubmit request for data
+            if (readpktcount == 4) {
+                readpktcount = 0;
+
+                ch341ReadCmdMarshall(ch341outBuffer, byteoffset, &eeprom_info, i2c_address); // Fill output buffer
+                libusb_fill_bulk_transfer(xferBulkOut, handle, BULK_WRITE_ENDPOINT, ch341outBuffer, EEPROM_READ_BULKOUT_BUF_SZ,
+                                          cbBulkOut, NULL, DEFAULT_TIMEOUT);
+
+                libusb_submit_transfer(xferBulkOut); // update transfer struct (with new EEPROM page offset)
+                                                     // and re-submit next transfer request to BULK OUT endpoint
+            }
+        }
+    }
+    libusb_free_transfer(xferBulkIn);
+    libusb_free_transfer(xferBulkOut);
+    return 0;
+}
+
+// Callback function for async bulk in comms
+void cbBulkIn(struct libusb_transfer *transfer)
+{
+    switch (transfer->status) {
+    case LIBUSB_TRANSFER_COMPLETED:
+        // copy read data to our EEPROM buffer
+        memcpy(readbuf + byteoffset, transfer->buffer, transfer->actual_length);
+        getnextpkt = 1;
+        break;
+    default:
+        printf("\ncbBulkIn: error : %d\n", transfer->status);
+        getnextpkt = -1;
+    }
+    return;
+}
+
+// Callback function for async bulk out comms
+void cbBulkOut(struct libusb_transfer *transfer)
+{
+    syncackpkt = 1;
+    return;
+}
--- a/src/platform/portduino/ch341a_i2c.h
+++ b/src/platform/portduino/ch341a_i2c.h
@@ -0,0 +1,43 @@
+// libUSB driver for the ch341a in i2c mode
+//
+// Copyright 2011 asbokid <ballymunboy@gmail.com>
+#ifndef __CH341A_I2C_H__
+#define __CH341A_I2C_H__
+
+#include <assert.h>
+#include <errno.h>
+#include <libusb-1.0/libusb.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define BULK_WRITE_ENDPOINT 0x02 /* bEndpointAddress 0x02  EP 2 OUT (Bulk)*/
+#define BULK_READ_ENDPOINT 0x82  /* bEndpointAddress 0x82  EP 2 IN  (Bulk)*/
+
+#define DEFAULT_TIMEOUT 300 // 300mS for USB timeouts
+
+#define IN_BUF_SZ 0x100
+#define EEPROM_READ_BULKIN_BUF_SZ 0x20
+#define EEPROM_READ_BULKOUT_BUF_SZ 0x65
+
+#define CH341_CMD_I2C_STREAM 0xAA
+#define CH341_CMD_I2C_STM_STA 0x74
+#define CH341_CMD_I2C_STM_STO 0x75
+#define CH341_CMD_I2C_STM_OUT 0x80
+#define CH341_CMD_I2C_STM_IN 0xC0
+#define CH341_CMD_I2C_STM_END 0x00
+
+#define CH341_EEPROM_READ_CMD_SZ 0x65 /* Same size for all 24cXX read setup and next packets*/
+
+struct EEPROM {
+    char *name;
+    uint32_t size;
+    uint16_t page_size;
+    uint8_t addr_size; // Length of address in bytes
+    uint8_t i2c_addr_mask;
+};
+
+int32_t ch341readEEPROM_param(uint8_t *buffer, uint32_t offset, uint32_t bytestoread, uint32_t ic_size, uint32_t block_size,
+                              uint8_t algorithm, uint32_t i2c_address, struct libusb_device_handle *handle);
+#endif /* __CH341A_I2C_H__ */
--- a/src/power.h
+++ b/src/power.h
@@ -138,6 +138,7 @@ class Power : private concurrency::OSThread
    void reboot();
    // open circuit voltage lookup table
    uint8_t low_voltage_counter;
+    int32_t lastLogTime = 0;
 #ifdef DEBUG_HEAP
    uint32_t lastheap;
 #endif
--- a/src/serialization/MeshPacketSerializer.cpp
+++ b/src/serialization/MeshPacketSerializer.cpp
@@ -413,7 +413,7 @@ std::string MeshPacketSerializer::JsonSerialize(const meshtastic_MeshPacket *mp,
    jsonObj["from"] = new JSONValue((unsigned int)mp->from);
    jsonObj["channel"] = new JSONValue((unsigned int)mp->channel);
    jsonObj["type"] = new JSONValue(msgType.c_str());
-    jsonObj["sender"] = new JSONValue(nodeDB->getNodeId().c_str());
+    jsonObj["sender"] = new JSONValue(owner.id);
    if (mp->rx_rssi != 0)
        jsonObj["rssi"] = new JSONValue((int)mp->rx_rssi);
    if (mp->rx_snr != 0)
--- a/src/serialization/MeshPacketSerializer_nRF52.cpp
+++ b/src/serialization/MeshPacketSerializer_nRF52.cpp
@@ -353,7 +353,7 @@ std::string MeshPacketSerializer::JsonSerialize(const meshtastic_MeshPacket *mp,
    jsonObj["from"] = (unsigned int)mp->from;
    jsonObj["channel"] = (unsigned int)mp->channel;
    jsonObj["type"] = msgType.c_str();
-    jsonObj["sender"] = nodeDB->getNodeId().c_str();
+    jsonObj["sender"] = owner.id;
    if (mp->rx_rssi != 0)
        jsonObj["rssi"] = (int)mp->rx_rssi;
    if (mp->rx_snr != 0)
--- a/test/test_mqtt/MQTT.cpp
+++ b/test/test_mqtt/MQTT.cpp
@@ -332,7 +332,7 @@ void setUp(void)
    };
    channelFile.channels_count = 1;
    owner = meshtastic_User{.id = "!12345678"};
-    myNodeInfo = meshtastic_MyNodeInfo{.my_node_num = 0x12345678}; // Match the expected gateway ID in topic
+    myNodeInfo = meshtastic_MyNodeInfo{.my_node_num = 10};
    localPosition =
        meshtastic_Position{.has_latitude_i = true, .latitude_i = 7 * 1e7, .has_longitude_i = true, .longitude_i = 3 * 1e7};

@@ -591,7 +591,7 @@ void test_receiveEncryptedPKITopicToUs(void)
 // Should ignore messages published to MQTT by this gateway.
 void test_receiveIgnoresOwnPublishedMessages(void)
 {
-    unitTest->publish(&decoded, nodeDB->getNodeId().c_str());
+    unitTest->publish(&decoded, owner.id);

    TEST_ASSERT_TRUE(mockRouter->packets_.empty());
    TEST_ASSERT_TRUE(mockRoutingModule->ackNacks_.empty());
@@ -603,7 +603,7 @@ void test_receiveAcksOwnSentMessages(void)
    meshtastic_MeshPacket p = decoded;
    p.from = myNodeInfo.my_node_num;

-    unitTest->publish(&p, nodeDB->getNodeId().c_str());
+    unitTest->publish(&p, owner.id);

    TEST_ASSERT_TRUE(mockRouter->packets_.empty());
    TEST_ASSERT_EQUAL(1, mockRoutingModule->ackNacks_.size());
--- a/variants/native/portduino/platformio.ini
+++ b/variants/native/portduino/platformio.ini
@@ -107,7 +107,3 @@ build_src_filter = ${env:native-tft.build_src_filter}
 [env:coverage]
 extends = env:native
 build_flags = -lgcov --coverage -fprofile-abs-path -fsanitize=address ${env:native.build_flags}
-; https://docs.platformio.org/en/latest/projectconf/sections/env/options/test/test_testing_command.html
-test_testing_command =
-  ${platformio.build_dir}/${this.__env__}/program
-  -s
--- a/variants/stm32/CDEBYTE_E77-MBL/platformio.ini
+++ b/variants/stm32/CDEBYTE_E77-MBL/platformio.ini
@@ -6,12 +6,9 @@ board_level = extra
 build_flags =
  ${stm32_base.build_flags}
  -Ivariants/stm32/CDEBYTE_E77-MBL
-  -DSERIAL_UART_INSTANCE=2
+  -DSERIAL_UART_INSTANCE=1
  -DPIN_SERIAL_RX=PA3
  -DPIN_SERIAL_TX=PA2
-  -DENABLE_HWSERIAL1
-  -DPIN_SERIAL1_RX=PB7
-  -DPIN_SERIAL1_TX=PB6
  -DMESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR=1
  -DMESHTASTIC_EXCLUDE_I2C=1
  -DMESHTASTIC_EXCLUDE_GPS=1
--- a/variants/stm32/CDEBYTE_E77-MBL/variant.h
+++ b/variants/stm32/CDEBYTE_E77-MBL/variant.h
@@ -18,6 +18,4 @@ Do not expect a working Meshtastic device with this target.
 #define LED_PIN PB4 // LED1
 // #define LED_PIN PB3 // LED2
 #define LED_STATE_ON 1
-
-#define EBYTE_E77_MBL
 #endif
--- a/variants/stm32/rak3172/platformio.ini
+++ b/variants/stm32/rak3172/platformio.ini
@@ -6,6 +6,7 @@ board_upload.maximum_size = 233472 ; reserve the last 28KB for filesystem
 build_flags =
  ${stm32_base.build_flags}
  -Ivariants/stm32/rak3172
+  -DRAK3172
  -DENABLE_HWSERIAL1
  -DPIN_SERIAL1_RX=PB7
  -DPIN_SERIAL1_TX=PB6
--- a/variants/stm32/rak3172/variant.h
+++ b/variants/stm32/rak3172/variant.h
@@ -16,6 +16,4 @@ Do not expect a working Meshtastic device with this target.
 #define LED_PIN PA0 // Green LED
 #define LED_STATE_ON 1

-#define RAK3172
-
 #endif
Author	SHA1	Message	Date
Ben Meadors	f8489773a8	Update src/platform/portduino/ch341a_i2c.c Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>	2025-10-07 17:05:04 +11:00
Ben Meadors	8a31276ae7	Update src/platform/portduino/ch341a_i2c.h Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>	2025-10-07 17:05:04 +11:00
Jonathan Bennett	4e23fac167	Move includes to header	2025-10-07 17:05:04 +11:00
Jonathan Bennett	c7dd670e61	Add scaffolding to read EEPROM data from ch341	2025-10-07 17:05:04 +11:00
@@ -1 +1 @@
 .6.6
 .6.4