Merge branch 'master' into NextHopRouter

First check if it's not still in the TxQueue

.github/workflows/main_matrix.yml

@@ -352,12 +352,6 @@ jobs:
         run: >-
           bin/bump_version.py
 
-      - name: Ensure debian deps are installed
-        shell: bash
-        run: |
-          sudo apt-get update -y --fix-missing
-          sudo apt-get install -y devscripts
-
       - name: Update debian changelog
         run: >-
           debian/ci_changelog.sh

.github/workflows/nightly.yml

@@ -4,11 +4,9 @@ on:
     - cron: 0 8 * * 1-5
   workflow_dispatch: {}
 
-permissions: read-all
-
 jobs:
   trunk_check:
-    name: Trunk Check and Upload
+    name: Trunk Check Upload
     runs-on: ubuntu-latest
 
     steps:
@@ -16,22 +14,6 @@ jobs:
         uses: actions/checkout@v4
 
       - name: Trunk Check
-        uses: trunk-io/trunk-action@v1
+        uses: trunk-io/trunk-action@782e83f803ca6e369f035d64c6ba2768174ba61b
         with:
           trunk-token: ${{ secrets.TRUNK_TOKEN }}
-
-  trunk_upgrade:
-    # See: https://github.com/trunk-io/trunk-action/blob/v1/readme.md#automatic-upgrades
-    name: Trunk Upgrade (PR)
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write # For trunk to create PRs
-      pull-requests: write # For trunk to create PRs
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Trunk Upgrade
-        uses: trunk-io/trunk-action/upgrade@v1
-        with:
-          base: master

.github/workflows/stale_bot.yml

@@ -16,7 +16,7 @@ jobs:
 
     steps:
       - name: Stale PR+Issues
-        uses: actions/stale@v9.1.0
+        uses: actions/stale@v9.0.0
         with:
           exempt-issue-labels: pinned,3.0
           exempt-pr-labels: pinned,3.0

.github/workflows/trunk-check.yml

@@ -20,5 +20,3 @@ jobs:
 
       - name: Trunk Check
         uses: trunk-io/trunk-action@v1
-        with:
-          save-annotations: true

.github/workflows/trunk_annotate_pr.yml

@@ -1,26 +0,0 @@
-name: Annotate PR with trunk issues
-# See: https://github.com/trunk-io/trunk-action/blob/v1/readme.md#getting-inline-annotations-for-fork-prs
-
-on:
-  workflow_run:
-    workflows: [Pull Request] # Name from `trunk_check.yml`
-    types: [completed]
-
-permissions: read-all
-
-jobs:
-  trunk_check:
-    name: Trunk Code Quality Annotate
-    runs-on: ubuntu-latest
-    permissions:
-      checks: write # For trunk to post annotations
-      contents: read # For repo checkout
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Trunk Check
-        uses: trunk-io/trunk-action@v1
-        with:
-          post-annotations: true

.trunk/trunk.yaml

@@ -1,35 +1,37 @@
 version: 0.1
 cli:
-  version: 1.22.10
+  version: 1.22.8
 plugins:
   sources:
     - id: trunk
-      ref: v1.6.7
+      ref: v1.6.6
       uri: https://github.com/trunk-io/plugins
 lint:
   enabled:
-    - prettier@3.5.1
-    - trufflehog@3.88.12
+    - prettier@3.4.2
+    - trufflehog@3.86.1
     - yamllint@1.35.1
-    - bandit@1.8.3
-    - checkov@3.2.372
+    - bandit@1.8.0
+    - checkov@3.2.334
     - terrascan@1.19.9
-    - trivy@0.59.1
+    - trivy@0.58.0
+    #- trufflehog@3.63.2-rc0
     - taplo@0.9.3
-    - ruff@0.9.7
-    - isort@6.0.0
-    - markdownlint@0.44.0
-    - oxipng@9.1.4
+    - ruff@0.8.3
+    - isort@5.13.2
+    - markdownlint@0.43.0
+    - oxipng@9.1.3
     - svgo@3.3.2
-    - actionlint@1.7.7
-    - flake8@7.1.2
+    - actionlint@1.7.4
+    - flake8@7.1.1
     - hadolint@2.12.1-beta
     - shfmt@3.6.0
     - shellcheck@0.10.0
-    - black@25.1.0
+    - black@24.10.0
     - git-diff-check
-    - gitleaks@8.24.0
+    - gitleaks@8.21.2
     - clang-format@16.0.3
+    #- prettier@3.3.3
   ignore:
     - linters: [ALL]
       paths:

README.md

@@ -1,7 +1,4 @@
-<div align="center" markdown="1">
-
-<img src=".github/meshtastic_logo.png" alt="Meshtastic Logo" width="80"/>
-<h1>Meshtastic Firmware</h1>
+# Meshtastic Firmware
 
 ![GitHub release downloads](https://img.shields.io/github/downloads/meshtastic/firmware/total)
 [![CI](https://img.shields.io/github/actions/workflow/status/meshtastic/firmware/main_matrix.yml?branch=master&label=actions&logo=github&color=yellow)](https://github.com/meshtastic/firmware/actions/workflows/ci.yml)
@@ -9,31 +6,13 @@
 [![Fiscal Contributors](https://opencollective.com/meshtastic/tiers/badge.svg?label=Fiscal%20Contributors&color=deeppink)](https://opencollective.com/meshtastic/)
 [![Vercel](https://img.shields.io/static/v1?label=Powered%20by&message=Vercel&style=flat&logo=vercel&color=000000)](https://vercel.com?utm_source=meshtastic&utm_campaign=oss)
 
-<a href="https://trendshift.io/repositories/5524" target="_blank"><img src="https://trendshift.io/api/badge/repositories/5524" alt="meshtastic%2Ffirmware | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
-
-</div>
-
-</div>
-
-<div align="center">
-	<a href="https://meshtastic.org">Website</a>
-	-
-	<a href="https://meshtastic.org/docs/">Documentation</a>
-</div>
-
 ## Overview
 
-This repository contains the official device firmware for Meshtastic, an open-source LoRa mesh networking project designed for long-range, low-power communication without relying on internet or cellular infrastructure. The firmware supports various hardware platforms, including ESP32, nRF52, RP2040/RP2350, and Linux-based devices.
+This repository contains the device firmware for the Meshtastic project.
 
-Meshtastic enables text messaging, location sharing, and telemetry over a decentralized mesh network, making it ideal for outdoor adventures, emergency preparedness, and remote operations.
-
-### Get Started
-
-- 🔧 **[Building Instructions](https://meshtastic.org/docs/development/firmware/build)** – Learn how to compile the firmware from source.
-- ⚡ **[Flashing Instructions](https://meshtastic.org/docs/getting-started/flashing-firmware/)** – Install or update the firmware on your device.
-
-Join our community and help improve Meshtastic! 🚀
+- **[Building Instructions](https://meshtastic.org/docs/development/firmware/build)**
+- **[Flashing Instructions](https://meshtastic.org/docs/getting-started/flashing-firmware/)**
 
 ## Stats
 
-![Alt](https://repobeats.axiom.co/api/embed/8025e56c482ec63541593cc5bd322c19d5c0bdcf.svg "Repobeats analytics image")
+![Alt](https://repobeats.axiom.co/api/embed/a92f097d9197ae853e780ec53d7d126e545629ab.svg "Repobeats analytics image")

arch/esp32/esp32.ini

@@ -2,7 +2,7 @@
 [esp32_base]
 extends = arduino_base
 custom_esp32_kind = esp32
-platform = platformio/espressif32@6.10.0
+platform = platformio/espressif32@6.9.0
 
 build_src_filter = 
   ${arduino_base.build_src_filter} -<platform/nrf52/> -<platform/stm32wl> -<platform/rp2xx0> -<mesh/eth/> -<mesh/raspihttp>
@@ -45,9 +45,9 @@ lib_deps =
   ${environmental_base.lib_deps}
   ${radiolib_base.lib_deps}
   https://github.com/meshtastic/esp32_https_server.git#23665b3adc080a311dcbb586ed5941b5f94d6ea2
-  h2zero/NimBLE-Arduino@^1.4.3
+  h2zero/NimBLE-Arduino@^1.4.2
   https://github.com/dbinfrago/libpax.git#3cdc0371c375676a97967547f4065607d4c53fd1
-  lewisxhe/XPowersLib@^0.2.7
+  lewisxhe/XPowersLib@^0.2.6
   https://github.com/meshtastic/ESP32_Codec2.git#633326c78ac251c059ab3a8c430fcdf25b41672f
   rweather/Crypto@^0.4.0
 
@@ -65,4 +65,4 @@ lib_ignore =
 
 ; customize the partition table
 ; http://docs.platformio.org/en/latest/platforms/espressif32.html#partition-tables
-board_build.partitions = partition-table.csv
+board_build.partitions = partition-table.csv

arch/esp32/esp32c6.ini

@@ -24,7 +24,7 @@ lib_deps =
   ${networking_base.lib_deps}
   ${environmental_base.lib_deps}
   ${radiolib_base.lib_deps}
-  lewisxhe/XPowersLib@^0.2.7
+  lewisxhe/XPowersLib@^0.2.6
   https://github.com/meshtastic/ESP32_Codec2.git#633326c78ac251c059ab3a8c430fcdf25b41672f
   rweather/Crypto@^0.4.0
 
@@ -38,4 +38,4 @@ lib_ignore =
   NonBlockingRTTTL
   NimBLE-Arduino
   libpax
-  
+  

arch/nrf52/nrf52.ini

@@ -4,8 +4,8 @@ platform = platformio/nordicnrf52@^10.7.0
 extends = arduino_base
 platform_packages =
   ; our custom Git version until they merge our PR
-  platformio/framework-arduinoadafruitnrf52 @ https://github.com/meshtastic/Adafruit_nRF52_Arduino.git#e13f5820002a4fb2a5e6754b42ace185277e5adf
-  platformio/toolchain-gccarmnoneeabi@~1.90301.0
+  framework-arduinoadafruitnrf52 @ https://github.com/meshtastic/Adafruit_nRF52_Arduino.git#e13f5820002a4fb2a5e6754b42ace185277e5adf
+  toolchain-gccarmnoneeabi@~1.90301.0
 
 build_type = debug
 build_flags =

arch/rp2xx0/rp2350.ini

@@ -1,8 +1,8 @@
 ; Common settings for rp2040 Processor based targets
 [rp2350_base]
-platform = https://github.com/maxgerhardt/platform-raspberrypi.git#76ecf3c7e9dd4503af0331154c4ca1cddc4b03e5 ; For arduino-pico >= 4.4.3
+platform = https://github.com/maxgerhardt/platform-raspberrypi.git#19e30129fb1428b823be585c787dcb4ac0d9014c ; For arduino-pico >=4.2.1
 extends = arduino_base
-platform_packages = framework-arduinopico@https://github.com/earlephilhower/arduino-pico.git#4.4.3
+platform_packages = framework-arduinopico@https://github.com/earlephilhower/arduino-pico.git#6024e9a7e82a72e38dd90f42029ba3748835eb2e ; 4.3.0 with fix MDNS
 
 board_build.core = earlephilhower
 board_build.filesystem_size = 0.5m
@@ -10,6 +10,7 @@ build_flags =
   ${arduino_base.build_flags} -Wno-unused-variable -Wcast-align
   -Isrc/platform/rp2xx0
   -D__PLAT_RP2350__
+#  -D _POSIX_THREADS
 build_src_filter = 
   ${arduino_base.build_src_filter} -<platform/esp32/> -<nimble/> -<modules/esp32> -<platform/nrf52/> -<platform/stm32wl> -<mesh/eth/> -<mesh/wifi/> -<mesh/http/> -<mesh/raspihttp> -<platform/rp2xx0/pico_sleep> -<platform/rp2xx0/hardware_rosc>
 

arch/stm32/stm32.ini

@@ -1,7 +1,7 @@
 [stm32_base]
 extends = arduino_base
-platform = platformio/ststm32
-platform_packages = platformio/framework-arduinoststm32@^4.20900.0
+platform = ststm32
+platform_packages = platformio/framework-arduinoststm32@https://github.com/stm32duino/Arduino_Core_STM32.git#ea74156acd823b6d14739f389e6cdc648f8ee36e
 
 build_type = release
 

debian/control

@@ -3,7 +3,6 @@ Section: misc
 Priority: optional
 Maintainer: Austin Lane <vidplace7@gmail.com>
 Build-Depends: debhelper-compat (= 13),
-               lsb-release,
                tar,
                gzip,
                platformio,

debian/rules

@@ -11,15 +11,6 @@ PIO_ENV:=\
 	PLATFORMIO_LIBDEPS_DIR=pio/libdeps \
 	PLATFORMIO_PACKAGES_DIR=pio/packages
 
-# Raspbian armhf builds should be compatible with armv6-hardfloat
-# https://www.valvers.com/open-software/raspberry-pi/bare-metal-programming-in-c-part-1/#rpi1-compiler-flags
-ifneq (,$(findstring Raspbian,$(shell lsb_release -is)))
-ifeq ($(DEB_BUILD_ARCH),armhf)
-PIO_ENV+=\
-	PLATFORMIO_BUILD_FLAGS="-mfloat-abi=hard -mfpu=vfp -march=armv6zk"
-endif
-endif
-
 override_dh_auto_build:
 	# Extract tarballs within source deb
 	tar -xf pio.tar

platformio.ini

@@ -59,7 +59,7 @@ lib_deps =
 	https://github.com/meshtastic/arduino-fsm.git#7db3702bf0cfe97b783d6c72595e3f38e0b19159
 	https://github.com/meshtastic/TinyGPSPlus.git#71a82db35f3b973440044c476d4bcdc673b104f4
 	https://github.com/meshtastic/ArduinoThread.git#1ae8778c85d0a2a729f989e0b1e7d7c4dc84eef0
-	nanopb/Nanopb@0.4.91
+	nanopb/Nanopb@0.4.9
 	erriez/ErriezCRC32@1.0.1
 
 ; Used for the code analysis in PIO Home / Inspect

src/detect/ScanI2CTwoWire.cpp

@@ -244,10 +244,6 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
                         logFoundDevice("BMP-388", (uint8_t)addr.address);
                         type = BMP_3XX;
                         break;
-                    case 0x60: // BMP-390 should be 0x60
-                        logFoundDevice("BMP-390", (uint8_t)addr.address);
-                        type = BMP_3XX;
-                        break;
                     case 0x58: // BMP-280 should be 0x58
                     default:
                         logFoundDevice("BMP-280", (uint8_t)addr.address);
@@ -525,4 +521,4 @@ void ScanI2CTwoWire::logFoundDevice(const char *device, uint8_t address)
 {
     LOG_INFO("%s found at address 0x%x", device, address);
 }
-#endif
+#endif

src/detect/einkScan.h

@@ -6,28 +6,28 @@
 
 void d_writeCommand(uint8_t c)
 {
-    SPI1.beginTransaction(SPISettings(4000000, MSBFIRST, SPI_MODE0));
+    SPI.beginTransaction(SPISettings(4000000, MSBFIRST, SPI_MODE0));
     if (PIN_EINK_DC >= 0)
         digitalWrite(PIN_EINK_DC, LOW);
     if (PIN_EINK_CS >= 0)
         digitalWrite(PIN_EINK_CS, LOW);
-    SPI1.transfer(c);
+    SPI.transfer(c);
     if (PIN_EINK_CS >= 0)
         digitalWrite(PIN_EINK_CS, HIGH);
     if (PIN_EINK_DC >= 0)
         digitalWrite(PIN_EINK_DC, HIGH);
-    SPI1.endTransaction();
+    SPI.endTransaction();
 }
 
 void d_writeData(uint8_t d)
 {
-    SPI1.beginTransaction(SPISettings(4000000, MSBFIRST, SPI_MODE0));
+    SPI.beginTransaction(SPISettings(4000000, MSBFIRST, SPI_MODE0));
     if (PIN_EINK_CS >= 0)
         digitalWrite(PIN_EINK_CS, LOW);
-    SPI1.transfer(d);
+    SPI.transfer(d);
     if (PIN_EINK_CS >= 0)
         digitalWrite(PIN_EINK_CS, HIGH);
-    SPI1.endTransaction();
+    SPI.endTransaction();
 }
 
 unsigned long d_waitWhileBusy(uint16_t busy_time)
@@ -53,7 +53,7 @@ unsigned long d_waitWhileBusy(uint16_t busy_time)
 
 void scanEInkDevice(void)
 {
-    SPI1.begin();
+    SPI.begin();
     d_writeCommand(0x22);
     d_writeData(0x83);
     d_writeCommand(0x20);
@@ -62,6 +62,6 @@ void scanEInkDevice(void)
         LOG_DEBUG("EInk display found");
     else
         LOG_DEBUG("EInk display not found");
-    SPI1.end();
+    SPI.end();
 }
 #endif

src/gps/GPS.cpp

@@ -48,6 +48,8 @@ HardwareSerial *GPS::_serial_gps = nullptr;
 
 GPS *gps = nullptr;
 
+static const char *ACK_SUCCESS_MESSAGE = "Get ack success!";
+
 static GPSUpdateScheduling scheduling;
 
 /// Multiple GPS instances might use the same serial port (in sequence), but we can
@@ -435,10 +437,6 @@ static const int serialSpeeds[3] = {9600, 115200, 38400};
 static const int rareSerialSpeeds[3] = {4800, 57600, GPS_BAUDRATE};
 #endif
 
-#ifndef GPS_PROBETRIES
-#define GPS_PROBETRIES 2
-#endif
-
 /**
  * @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.
@@ -462,7 +460,11 @@ bool GPS::setup()
             digitalWrite(PIN_GPS_EN, HIGH);
             delay(1000);
 #endif
-            if (probeTries < GPS_PROBETRIES) {
+#ifdef TRACKER_T1000_E
+            if (probeTries < 5) {
+#else
+            if (probeTries < 2) {
+#endif
                 LOG_DEBUG("Probe for GPS at %d", serialSpeeds[speedSelect]);
                 gnssModel = probe(serialSpeeds[speedSelect]);
                 if (gnssModel == GNSS_MODEL_UNKNOWN) {
@@ -473,7 +475,11 @@ bool GPS::setup()
                 }
             }
             // Rare Serial Speeds
-            if (probeTries == GPS_PROBETRIES) {
+#ifdef TRACKER_T1000_E
+            if (probeTries == 5) {
+#else
+            if (probeTries == 2) {
+#endif
                 LOG_DEBUG("Probe for GPS at %d", rareSerialSpeeds[speedSelect]);
                 gnssModel = probe(rareSerialSpeeds[speedSelect]);
                 if (gnssModel == GNSS_MODEL_UNKNOWN) {
@@ -1037,6 +1043,14 @@ int32_t GPS::runOnce()
         if (config.position.gps_mode != meshtastic_Config_PositionConfig_GpsMode_ENABLED) {
             return disable();
         }
+        // ONCE we will factory reset the GPS for bug #327
+        if (!devicestate.did_gps_reset) {
+            LOG_WARN("GPS FactoryReset requested");
+            if (gps->factoryReset()) { // If we don't succeed try again next time
+                devicestate.did_gps_reset = true;
+                nodeDB->saveToDisk(SEGMENT_DEVICESTATE);
+            }
+        }
         GPSInitFinished = true;
         publishUpdate();
     }
@@ -1049,6 +1063,24 @@ int32_t GPS::runOnce()
     if (whileActive()) {
         // if we have received valid NMEA claim we are connected
         setConnected();
+    } else {
+        if ((config.position.gps_mode == meshtastic_Config_PositionConfig_GpsMode_ENABLED) &&
+            IS_ONE_OF(gnssModel, GNSS_MODEL_UBLOX6, GNSS_MODEL_UBLOX7, GNSS_MODEL_UBLOX8, GNSS_MODEL_UBLOX9,
+                      GNSS_MODEL_UBLOX10)) {
+            // reset the GPS on next bootup
+            if (devicestate.did_gps_reset && scheduling.elapsedSearchMs() > 60 * 1000UL && !hasFlow()) {
+                LOG_DEBUG("GPS is not found, try factory reset on next boot");
+                devicestate.did_gps_reset = false;
+                nodeDB->saveToDisk(SEGMENT_DEVICESTATE);
+                return disable(); // Stop the GPS thread as it can do nothing useful until next reboot.
+            }
+        }
+    }
+    // At least one GPS has a bad habit of losing its mind from time to time
+    if (rebootsSeen > 2) {
+        rebootsSeen = 0;
+        LOG_DEBUG("Would normally factoryReset()");
+        // gps->factoryReset();
     }
 
     // If we're due for an update, wake the GPS
@@ -1383,6 +1415,62 @@ static int32_t toDegInt(RawDegrees d)
     return r;
 }
 
+bool GPS::factoryReset()
+{
+#ifdef PIN_GPS_REINIT
+    // The L76K GNSS on the T-Echo requires the RESET pin to be pulled LOW
+    pinMode(PIN_GPS_REINIT, OUTPUT);
+    digitalWrite(PIN_GPS_REINIT, 0);
+    delay(150); // The L76K datasheet calls for at least 100MS delay
+    digitalWrite(PIN_GPS_REINIT, 1);
+#endif
+
+    if (HW_VENDOR == meshtastic_HardwareModel_TBEAM) {
+        byte _message_reset1[] = {0xB5, 0x62, 0x06, 0x09, 0x0D, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00,
+                                  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x1C, 0xA2};
+        _serial_gps->write(_message_reset1, sizeof(_message_reset1));
+        if (getACK(0x05, 0x01, 10000)) {
+            LOG_DEBUG(ACK_SUCCESS_MESSAGE);
+        }
+        delay(100);
+        byte _message_reset2[] = {0xB5, 0x62, 0x06, 0x09, 0x0D, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00,
+                                  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x1B, 0xA1};
+        _serial_gps->write(_message_reset2, sizeof(_message_reset2));
+        if (getACK(0x05, 0x01, 10000)) {
+            LOG_DEBUG(ACK_SUCCESS_MESSAGE);
+        }
+        delay(100);
+        byte _message_reset3[] = {0xB5, 0x62, 0x06, 0x09, 0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                  0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x03, 0x1D, 0xB3};
+        _serial_gps->write(_message_reset3, sizeof(_message_reset3));
+        if (getACK(0x05, 0x01, 10000)) {
+            LOG_DEBUG(ACK_SUCCESS_MESSAGE);
+        }
+    } else if (gnssModel == GNSS_MODEL_MTK) {
+        // send the CAS10 to perform a factory restart of the device (and other device that support PCAS statements)
+        LOG_INFO("GNSS Factory Reset via PCAS10,3");
+        _serial_gps->write("$PCAS10,3*1F\r\n");
+        delay(100);
+    } else if (gnssModel == GNSS_MODEL_ATGM336H) {
+        LOG_INFO("Factory Reset via CAS-CFG-RST");
+        uint8_t msglen = makeCASPacket(0x06, 0x02, sizeof(_message_CAS_CFG_RST_FACTORY), _message_CAS_CFG_RST_FACTORY);
+        _serial_gps->write(UBXscratch, msglen);
+        delay(100);
+    } else {
+        // fire this for good measure, if we have an L76B - won't harm other devices.
+        _serial_gps->write("$PMTK104*37\r\n");
+        // No PMTK_ACK for this command.
+        delay(100);
+        // send the UBLOX Factory Reset Command regardless of detect state, something is very wrong, just assume it's
+        // UBLOX. Factory Reset
+        byte _message_reset[] = {0xB5, 0x62, 0x06, 0x09, 0x0D, 0x00, 0xFF, 0xFB, 0x00, 0x00, 0x00,
+                                 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x17, 0x2B, 0x7E};
+        _serial_gps->write(_message_reset, sizeof(_message_reset));
+    }
+    delay(1000);
+    return true;
+}
+
 /**
  * Perform any processing that should be done only while the GPS is awake and looking for a fix.
  * Override this method to check for new locations

src/gps/GPS.h

@@ -101,6 +101,8 @@ class GPS : private concurrency::OSThread
     // Empty the input buffer as quickly as possible
     void clearBuffer();
 
+    virtual bool factoryReset();
+
     // Creates an instance of the GPS class.
     // Returns the new instance or null if the GPS is not present.
     static GPS *createGps();

src/main.cpp

@@ -644,9 +644,9 @@ void setup()
     // but we need to do this after main cpu init (esp32setup), because we need the random seed set
     nodeDB = new NodeDB;
 
-    // If we're taking on the repeater role, use flood router and turn off 3V3_S rail because peripherals are not needed
+    // If we're taking on the repeater role, use NextHopRouter and turn off 3V3_S rail because peripherals are not needed
     if (config.device.role == meshtastic_Config_DeviceConfig_Role_REPEATER) {
-        router = new FloodingRouter();
+        router = new NextHopRouter();
 #ifdef PIN_3V3_EN
         digitalWrite(PIN_3V3_EN, LOW);
 #endif
@@ -931,7 +931,6 @@ void setup()
         if (!sxIf->init()) {
             LOG_WARN("No SX1262 radio");
             delete sxIf;
-            rIf = NULL;
         } else {
             LOG_INFO("SX1262 init success");
             rIf = sxIf;
@@ -948,7 +947,6 @@ void setup()
         if (!sxIf->init()) {
             LOG_WARN("No SX1262 radio with TCXO, Vref %fV", SX126X_DIO3_TCXO_VOLTAGE);
             delete sxIf;
-            rIf = NULL;
         } else {
             LOG_INFO("SX1262 init success, TCXO, Vref %fV", SX126X_DIO3_TCXO_VOLTAGE);
             rIf = sxIf;

src/mesh/FloodingRouter.cpp

@@ -13,7 +13,8 @@ FloodingRouter::FloodingRouter() {}
 ErrorCode FloodingRouter::send(meshtastic_MeshPacket *p)
 {
     // Add any messages _we_ send to the seen message list (so we will ignore all retransmissions we see)
-    wasSeenRecently(p); // FIXME, move this to a sniffSent method
+    p->relay_node = nodeDB->getLastByteOfNodeNum(getNodeNum()); // First set the relayer to us
+    wasSeenRecently(p);                                         // FIXME, move this to a sniffSent method
 
     return Router::send(p);
 }
@@ -23,26 +24,17 @@ bool FloodingRouter::shouldFilterReceived(const meshtastic_MeshPacket *p)
     if (wasSeenRecently(p)) { // Note: this will also add a recent packet record
         printPacket("Ignore dupe incoming msg", p);
         rxDupe++;
-        if (config.device.role != meshtastic_Config_DeviceConfig_Role_ROUTER &&
-            config.device.role != meshtastic_Config_DeviceConfig_Role_REPEATER &&
-            config.device.role != meshtastic_Config_DeviceConfig_Role_ROUTER_LATE) {
-            // cancel rebroadcast of this message *if* there was already one, unless we're a router/repeater!
-            if (Router::cancelSending(p->from, p->id))
-                txRelayCanceled++;
-        }
-        if (config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER_LATE && iface) {
-            iface->clampToLateRebroadcastWindow(getFrom(p), p->id);
-        }
 
         /* If the original transmitter is doing retransmissions (hopStart equals hopLimit) for a reliable transmission, e.g., when
-        the ACK got lost, we will handle the packet again to make sure it gets an ACK to its packet. */
+        the ACK got lost, we will handle the packet again to make sure it gets an implicit ACK. */
         bool isRepeated = p->hop_start > 0 && p->hop_start == p->hop_limit;
         if (isRepeated) {
             LOG_DEBUG("Repeated reliable tx");
-            if (!perhapsRebroadcast(p) && isToUs(p) && p->want_ack) {
-                // FIXME - channel index should be used, but the packet is still encrypted here
-                sendAckNak(meshtastic_Routing_Error_NONE, getFrom(p), p->id, 0, 0);
-            }
+            // Check if it's still in the Tx queue, if not, we have to relay it again
+            if (!findInTxQueue(p->from, p->id))
+                perhapsRebroadcast(p);
+        } else {
+            perhapsCancelDupe(p);
         }
 
         return true;
@@ -51,13 +43,27 @@ bool FloodingRouter::shouldFilterReceived(const meshtastic_MeshPacket *p)
     return Router::shouldFilterReceived(p);
 }
 
+void FloodingRouter::perhapsCancelDupe(const meshtastic_MeshPacket *p)
+{
+    if (config.device.role != meshtastic_Config_DeviceConfig_Role_ROUTER &&
+        config.device.role != meshtastic_Config_DeviceConfig_Role_REPEATER &&
+        config.device.role != meshtastic_Config_DeviceConfig_Role_ROUTER_LATE) {
+        // cancel rebroadcast of this message *if* there was already one, unless we're a router/repeater!
+        if (Router::cancelSending(p->from, p->id))
+            txRelayCanceled++;
+    }
+    if (config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER_LATE && iface) {
+        iface->clampToLateRebroadcastWindow(getFrom(p), p->id);
+    }
+}
+
 bool FloodingRouter::isRebroadcaster()
 {
     return config.device.role != meshtastic_Config_DeviceConfig_Role_CLIENT_MUTE &&
            config.device.rebroadcast_mode != meshtastic_Config_DeviceConfig_RebroadcastMode_NONE;
 }
 
-bool FloodingRouter::perhapsRebroadcast(const meshtastic_MeshPacket *p)
+void FloodingRouter::perhapsRebroadcast(const meshtastic_MeshPacket *p)
 {
     if (!isToUs(p) && (p->hop_limit > 0) && !isFromUs(p)) {
         if (p->id != 0) {
@@ -72,13 +78,12 @@ bool FloodingRouter::perhapsRebroadcast(const meshtastic_MeshPacket *p)
                     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
                 // We are careful not to call our hooked version of send() - because we don't want to check this again
                 Router::send(tosend);
-
-                return true;
             } else {
                 LOG_DEBUG("No rebroadcast: Role = CLIENT_MUTE or Rebroadcast Mode = NONE");
             }
@@ -86,13 +91,12 @@ bool FloodingRouter::perhapsRebroadcast(const meshtastic_MeshPacket *p)
             LOG_DEBUG("Ignore 0 id broadcast");
         }
     }
-
-    return false;
 }
 
 void FloodingRouter::sniffReceived(const meshtastic_MeshPacket *p, const meshtastic_Routing *c)
 {
-    bool isAckorReply = (p->which_payload_variant == meshtastic_MeshPacket_decoded_tag) && (p->decoded.request_id != 0);
+    bool isAckorReply = (p->which_payload_variant == meshtastic_MeshPacket_decoded_tag) &&
+                        (p->decoded.request_id != 0 || p->decoded.reply_id != 0);
     if (isAckorReply && !isToUs(p) && !isBroadcast(p->to)) {
         // do not flood direct message that is ACKed or replied to
         LOG_DEBUG("Rxd an ACK/reply not for me, cancel rebroadcast");

src/mesh/FloodingRouter.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include "PacketHistory.h"
 #include "Router.h"
 
 /**
@@ -26,14 +25,11 @@
   Any entries in recentBroadcasts that are older than X seconds (longer than the
   max time a flood can take) will be discarded.
  */
-class FloodingRouter : public Router, protected PacketHistory
+class FloodingRouter : public Router
 {
   private:
-    bool isRebroadcaster();
-
-    /** Check if we should rebroadcast this packet, and do so if needed
-     * @return true if rebroadcasted */
-    bool perhapsRebroadcast(const meshtastic_MeshPacket *p);
+    /* Check if we should rebroadcast this packet, and do so if needed */
+    void perhapsRebroadcast(const meshtastic_MeshPacket *p);
 
   public:
     /**
@@ -62,4 +58,10 @@ class FloodingRouter : public Router, protected PacketHistory
      * Look for broadcasts we need to rebroadcast
      */
     virtual void sniffReceived(const meshtastic_MeshPacket *p, const meshtastic_Routing *c) override;
+
+    /* Call when receiving a duplicate packet to check whether we should cancel a packet in the Tx queue */
+    void perhapsCancelDupe(const meshtastic_MeshPacket *p);
+
+    // Return true if we are a rebroadcaster
+    bool isRebroadcaster();
 };

src/mesh/MeshPacketQueue.cpp

@@ -117,6 +117,19 @@ meshtastic_MeshPacket *MeshPacketQueue::remove(NodeNum from, PacketId id, bool t
     return NULL;
 }
 
+/* Attempt to find a packet from this queue. Return true if it was found. */
+bool MeshPacketQueue::find(NodeNum from, PacketId id)
+{
+    for (auto it = queue.begin(); it != queue.end(); it++) {
+        auto p = (*it);
+        if (getFrom(p) == from && p->id == id) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
 /**
  * Attempt to find a lower-priority packet in the queue and replace it with the provided one.
  * @return True if the replacement succeeded, false otherwise

src/mesh/MeshPacketQueue.h

@@ -37,4 +37,7 @@ class MeshPacketQueue
 
     /** Attempt to find and remove a packet from this queue.  Returns the packet which was removed from the queue */
     meshtastic_MeshPacket *remove(NodeNum from, PacketId id, bool tx_normal = true, bool tx_late = true);
+
+    /* Attempt to find a packet from this queue. Return true if it was found. */
+    bool find(NodeNum from, PacketId id);
 };

src/mesh/MeshService.cpp

@@ -173,7 +173,9 @@ void MeshService::handleToRadio(meshtastic_MeshPacket &p)
         return;
     }
 #endif
-    p.from = 0; // We don't let phones assign nodenums to their sent messages
+    p.from = 0;                          // We don't let clients assign nodenums to their sent messages
+    p.next_hop = NO_NEXT_HOP_PREFERENCE; // We don't let clients assign next_hop to their sent messages
+    p.relay_node = NO_RELAY_NODE;        // We don't let clients assign relay_node to their sent messages
 
     if (p.id == 0)
         p.id = generatePacketId(); // If the phone didn't supply one, then pick one

src/mesh/MeshTypes.h

@@ -40,6 +40,11 @@ enum RxSource {
 /// We normally just use max 3 hops for sending reliable messages
 #define HOP_RELIABLE 3
 
+// For old firmware or when falling back to flooding, there is no next-hop preference
+#define NO_NEXT_HOP_PREFERENCE 0
+// For old firmware there is no relay node set
+#define NO_RELAY_NODE 0
+
 typedef int ErrorCode;
 
 /// Alloc and free packets to our global, ISR safe pool

src/mesh/NextHopRouter.cpp

@@ -0,0 +1,272 @@
+#include "NextHopRouter.h"
+
+NextHopRouter::NextHopRouter() {}
+
+PendingPacket::PendingPacket(meshtastic_MeshPacket *p, uint8_t numRetransmissions)
+{
+    packet = p;
+    this->numRetransmissions = numRetransmissions - 1; // We subtract one, because we assume the user just did the first send
+}
+
+/**
+ * Send a packet
+ */
+ErrorCode NextHopRouter::send(meshtastic_MeshPacket *p)
+{
+    // Add any messages _we_ send to the seen message list (so we will ignore all retransmissions we see)
+    p->relay_node = nodeDB->getLastByteOfNodeNum(getNodeNum()); // First set the relayer to us
+    wasSeenRecently(p);                                         // FIXME, move this to a sniffSent method
+
+    p->next_hop = getNextHop(p->to, p->relay_node); // set the next hop
+    LOG_DEBUG("Setting next hop for packet with dest %x to %x", p->to, p->next_hop);
+
+    // If it's from us, ReliableRouter already handles retransmissions if want_ack is set. If a next hop is set and hop limit is
+    // not 0 or want_ack is set, start retransmissions
+    if ((!isFromUs(p) || !p->want_ack) && p->next_hop != NO_NEXT_HOP_PREFERENCE && (p->hop_limit > 0 || p->want_ack))
+        startRetransmission(packetPool.allocCopy(*p)); // start retransmission for relayed packet
+
+    return Router::send(p);
+}
+
+bool NextHopRouter::shouldFilterReceived(const meshtastic_MeshPacket *p)
+{
+    bool wasFallback = false;
+    bool weWereNextHop = false;
+    if (wasSeenRecently(p, true, &wasFallback, &weWereNextHop)) { // Note: this will also add a recent packet record
+        printPacket("Ignore dupe incoming msg", p);
+        rxDupe++;
+        stopRetransmission(p->from, p->id);
+
+        // If it was a fallback to flooding, try to relay again
+        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);
+        } 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);
+            } else if (!weWereNextHop) {
+                perhapsCancelDupe(p); // If it's a dupe, cancel relay if we were not explicitly asked to relay
+            }
+        }
+        return true;
+    }
+
+    return Router::shouldFilterReceived(p);
+}
+
+void NextHopRouter::sniffReceived(const meshtastic_MeshPacket *p, const meshtastic_Routing *c)
+{
+    NodeNum ourNodeNum = getNodeNum();
+    uint8_t ourRelayID = nodeDB->getLastByteOfNodeNum(ourNodeNum);
+    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
+        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 relayer and the ACK came directly from
+                // the destination
+                if (wasRelayer(p->relay_node, p->decoded.request_id, p->to) ||
+                    (wasRelayer(ourRelayID, p->decoded.request_id, p->to) && p->hop_start != 0 && p->hop_start == p->hop_limit)) {
+                    if (origTx->next_hop != p->relay_node) { // Not already set
+                        LOG_INFO("Update next hop of 0x%x to 0x%x based on ACK/reply", p->from, p->relay_node);
+                        origTx->next_hop = p->relay_node;
+                    }
+                }
+            }
+        }
+        if (!isToUs(p)) {
+            Router::cancelSending(p->to, p->decoded.request_id); // cancel rebroadcast for this DM
+            // stop retransmission for the original packet
+            stopRetransmission(p->to, p->decoded.request_id); // for original packet, from = to and id = request_id
+        }
+    }
+
+    perhapsRelay(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)
+{
+    if (!isToUs(p) && !isFromUs(p) && p->hop_limit > 0) {
+        if (p->next_hop == NO_NEXT_HOP_PREFERENCE || p->next_hop == nodeDB->getLastByteOfNodeNum(getNodeNum())) {
+            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);
+
+                tosend->hop_limit--; // bump down the hop count
+                NextHopRouter::send(tosend);
+
+                return true;
+            } else {
+                LOG_DEBUG("Not rebroadcasting: Role = CLIENT_MUTE or Rebroadcast Mode = NONE");
+            }
+        }
+    }
+
+    return false;
+}
+
+/**
+ * Get the next hop for a destination, given the relay node
+ * @return the node number of the next hop, 0 if no preference (fallback to FloodingRouter)
+ */
+uint8_t NextHopRouter::getNextHop(NodeNum to, uint8_t relay_node)
+{
+    // When we're a repeater router->sniffReceived will call NextHopRouter directly without checking for broadcast
+    if (isBroadcast(to))
+        return NO_NEXT_HOP_PREFERENCE;
+
+    meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(to);
+    if (node && node->next_hop) {
+        // We are careful not to return the relay node as the next hop
+        if (node->next_hop != relay_node) {
+            // LOG_DEBUG("Next hop for 0x%x is 0x%x", to, node->next_hop);
+            return node->next_hop;
+        } else
+            LOG_WARN("Next hop for 0x%x is 0x%x, same as relayer; set no pref", to, node->next_hop);
+    }
+    return NO_NEXT_HOP_PREFERENCE;
+}
+
+PendingPacket *NextHopRouter::findPendingPacket(GlobalPacketId key)
+{
+    auto old = pending.find(key); // If we have an old record, someone messed up because id got reused
+    if (old != pending.end()) {
+        return &old->second;
+    } else
+        return NULL;
+}
+
+/**
+ * Stop any retransmissions we are doing of the specified node/packet ID pair
+ */
+bool NextHopRouter::stopRetransmission(NodeNum from, PacketId id)
+{
+    auto key = GlobalPacketId(from, id);
+    return stopRetransmission(key);
+}
+
+bool NextHopRouter::stopRetransmission(GlobalPacketId key)
+{
+    auto old = findPendingPacket(key);
+    if (old) {
+        auto p = old->packet;
+        /* Only when we already transmitted a packet via LoRa, we will cancel the packet in the Tx queue
+          to avoid canceling a transmission if it was ACKed super fast via MQTT */
+        if (old->numRetransmissions < NUM_RELIABLE_RETX - 1) {
+            // remove the 'original' (identified by originator and packet->id) from the txqueue and free it
+            cancelSending(getFrom(p), p->id);
+            // now free the pooled copy for retransmission too
+            packetPool.release(p);
+        }
+        auto numErased = pending.erase(key);
+        assert(numErased == 1);
+        return true;
+    } else
+        return false;
+}
+
+/**
+ * Add p to the list of packets to retransmit occasionally.  We will free it once we stop retransmitting.
+ */
+PendingPacket *NextHopRouter::startRetransmission(meshtastic_MeshPacket *p, uint8_t numReTx)
+{
+    auto id = GlobalPacketId(p);
+    auto rec = PendingPacket(p, numReTx);
+
+    stopRetransmission(getFrom(p), p->id);
+
+    setNextTx(&rec);
+    pending[id] = rec;
+
+    return &pending[id];
+}
+
+/**
+ * Do any retransmissions that are scheduled (FIXME - for the time being called from loop)
+ */
+int32_t NextHopRouter::doRetransmissions()
+{
+    uint32_t now = millis();
+    int32_t d = INT32_MAX;
+
+    // FIXME, we should use a better datastructure rather than walking through this map.
+    // for(auto el: pending) {
+    for (auto it = pending.begin(), nextIt = it; it != pending.end(); it = nextIt) {
+        ++nextIt; // we use this odd pattern because we might be deleting it...
+        auto &p = it->second;
+
+        bool stillValid = true; // assume we'll keep this record around
+
+        // FIXME, handle 51 day rolloever here!!!
+        if (p.nextTxMsec <= now) {
+            if (p.numRetransmissions == 0) {
+                if (isFromUs(p.packet)) {
+                    LOG_DEBUG("Reliable send failed, returning a nak for fr=0x%x,to=0x%x,id=0x%x", p.packet->from, p.packet->to,
+                              p.packet->id);
+                    sendAckNak(meshtastic_Routing_Error_MAX_RETRANSMIT, getFrom(p.packet), p.packet->id, p.packet->channel);
+                }
+                // Note: we don't stop retransmission here, instead the Nak packet gets processed in sniffReceived
+                stopRetransmission(it->first);
+                stillValid = false; // just deleted it
+            } else {
+                LOG_DEBUG("Sending retransmission fr=0x%x,to=0x%x,id=0x%x, tries left=%d", p.packet->from, p.packet->to,
+                          p.packet->id, p.numRetransmissions);
+
+                if (!isBroadcast(p.packet->to)) {
+                    if (p.numRetransmissions == 1) {
+                        // Last retransmission, reset next_hop (fallback to FloodingRouter)
+                        p.packet->next_hop = NO_NEXT_HOP_PREFERENCE;
+                        // Also reset it in the nodeDB
+                        meshtastic_NodeInfoLite *sentTo = nodeDB->getMeshNode(p.packet->to);
+                        if (sentTo) {
+                            LOG_INFO("Resetting next hop for packet with dest 0x%x\n", p.packet->to);
+                            sentTo->next_hop = NO_NEXT_HOP_PREFERENCE;
+                        }
+                        FloodingRouter::send(packetPool.allocCopy(*p.packet));
+                    } else {
+                        NextHopRouter::send(packetPool.allocCopy(*p.packet));
+                    }
+                } else {
+                    // Note: we call the superclass version because we don't want to have our version of send() add a new
+                    // retransmission record
+                    FloodingRouter::send(packetPool.allocCopy(*p.packet));
+                }
+
+                // Queue again
+                --p.numRetransmissions;
+                setNextTx(&p);
+            }
+        }
+
+        if (stillValid) {
+            // Update our desired sleep delay
+            int32_t t = p.nextTxMsec - now;
+
+            d = min(t, d);
+        }
+    }
+
+    return d;
+}
+
+void NextHopRouter::setNextTx(PendingPacket *pending)
+{
+    assert(iface);
+    auto d = iface->getRetransmissionMsec(pending->packet);
+    pending->nextTxMsec = millis() + d;
+    LOG_DEBUG("Setting next retransmission in %u msecs: ", d);
+    printPacket("", pending->packet);
+    setReceivedMessage(); // Run ASAP, so we can figure out our correct sleep time
+}

src/mesh/NextHopRouter.h

@@ -0,0 +1,151 @@
+#pragma once
+
+#include "FloodingRouter.h"
+#include <unordered_map>
+
+/**
+ * An identifier for a globally unique message - a pair of the sending nodenum and the packet id assigned
+ * to that message
+ */
+struct GlobalPacketId {
+    NodeNum node;
+    PacketId id;
+
+    bool operator==(const GlobalPacketId &p) const { return node == p.node && id == p.id; }
+
+    explicit GlobalPacketId(const meshtastic_MeshPacket *p)
+    {
+        node = getFrom(p);
+        id = p->id;
+    }
+
+    GlobalPacketId(NodeNum _from, PacketId _id)
+    {
+        node = _from;
+        id = _id;
+    }
+};
+
+/**
+ * A packet queued for retransmission
+ */
+struct PendingPacket {
+    meshtastic_MeshPacket *packet;
+
+    /** The next time we should try to retransmit this packet */
+    uint32_t nextTxMsec = 0;
+
+    /** Starts at NUM_RETRANSMISSIONS -1 and counts down.  Once zero it will be removed from the list */
+    uint8_t numRetransmissions = 0;
+
+    PendingPacket() {}
+    explicit PendingPacket(meshtastic_MeshPacket *p, uint8_t numRetransmissions);
+};
+
+class GlobalPacketIdHashFunction
+{
+  public:
+    size_t operator()(const GlobalPacketId &p) const { return (std::hash<NodeNum>()(p.node)) ^ (std::hash<PacketId>()(p.id)); }
+};
+
+/*
+  Router for direct messages, which only relays if it is the next hop for a packet. The next hop is set by the current
+  relayer of a packet, which bases this on information from a previous successful delivery to the destination via flooding.
+  Namely, in the PacketHistory, we keep track of (up to 3) relayers of a packet. When the ACK is delivered back to us via a node
+  that also relayed the original packet, we use that node as next hop for the destination from then on. This makes sure that only
+  when there’s a two-way connection, we assign a next hop. Both the ReliableRouter and NextHopRouter will do retransmissions (the
+  NextHopRouter only 1 time). For the final retry, if no one actually relayed the packet, it will reset the next hop in order to
+  fall back to the FloodingRouter again. Note that thus also intermediate hops will do a single retransmission if the intended
+  next-hop didn’t relay, in order to fix changes in the middle of the route.
+*/
+class NextHopRouter : public FloodingRouter
+{
+  public:
+    /**
+     * Constructor
+     *
+     */
+    NextHopRouter();
+
+    /**
+     * Send a packet
+     * @return an error code
+     */
+    virtual ErrorCode send(meshtastic_MeshPacket *p) override;
+
+    /** Do our retransmission handling */
+    virtual int32_t runOnce() override
+    {
+        // Note: We must doRetransmissions FIRST, because it might queue up work for the base class runOnce implementation
+        doRetransmissions();
+
+        int32_t r = FloodingRouter::runOnce();
+
+        // Also after calling runOnce there might be new packets to retransmit
+        auto d = doRetransmissions();
+        return min(d, r);
+    }
+
+    // The number of retransmissions intermediate nodes will do (actually 1 less than this)
+    constexpr static uint8_t NUM_INTERMEDIATE_RETX = 2;
+    // The number of retransmissions the original sender will do
+    constexpr static uint8_t NUM_RELIABLE_RETX = 3;
+
+  protected:
+    /**
+     * Pending retransmissions
+     */
+    std::unordered_map<GlobalPacketId, PendingPacket, GlobalPacketIdHashFunction> pending;
+
+    /**
+     * Should this incoming filter be dropped?
+     *
+     * Called immediately on reception, before any further processing.
+     * @return true to abandon the packet
+     */
+    virtual bool shouldFilterReceived(const meshtastic_MeshPacket *p) override;
+
+    /**
+     * Look for packets we need to relay
+     */
+    virtual void sniffReceived(const meshtastic_MeshPacket *p, const meshtastic_Routing *c) override;
+
+    /**
+     * Try to find the pending packet record for this ID (or NULL if not found)
+     */
+    PendingPacket *findPendingPacket(NodeNum from, PacketId id) { return findPendingPacket(GlobalPacketId(from, id)); }
+    PendingPacket *findPendingPacket(GlobalPacketId p);
+
+    /**
+     * Add p to the list of packets to retransmit occasionally.  We will free it once we stop retransmitting.
+     */
+    PendingPacket *startRetransmission(meshtastic_MeshPacket *p, uint8_t numReTx = NUM_INTERMEDIATE_RETX);
+
+    /**
+     * Stop any retransmissions we are doing of the specified node/packet ID pair
+     *
+     * @return true if we found and removed a transmission with this ID
+     */
+    bool stopRetransmission(NodeNum from, PacketId id);
+    bool stopRetransmission(GlobalPacketId p);
+
+    /**
+     * Do any retransmissions that are scheduled (FIXME - for the time being called from loop)
+     *
+     * @return the number of msecs until our next retransmission or MAXINT if none scheduled
+     */
+    int32_t doRetransmissions();
+
+    void setNextTx(PendingPacket *pending);
+
+  private:
+    /**
+     * Get the next hop for a destination, given the relay node
+     * @return the node number of the next hop, 0 if no preference (fallback to 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);
+};

src/mesh/NodeDB.h

@@ -104,6 +104,9 @@ class NodeDB
     /// @return our node number
     NodeNum getNodeNum() { return myNodeInfo.my_node_num; }
 
+    // @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); }
+
     /// if returns false, that means our node should send a DenyNodeNum response.  If true, we think the number is okay for use
     // bool handleWantNodeNum(NodeNum n);
 

src/mesh/PacketHistory.cpp

@@ -16,7 +16,7 @@ PacketHistory::PacketHistory()
 /**
  * Update recentBroadcasts and return true if we have already seen this packet
  */
-bool PacketHistory::wasSeenRecently(const meshtastic_MeshPacket *p, bool withUpdate)
+bool PacketHistory::wasSeenRecently(const meshtastic_MeshPacket *p, bool withUpdate, bool *wasFallback, bool *weWereNextHop)
 {
     if (p->id == 0) {
         LOG_DEBUG("Ignore message with zero id");
@@ -27,6 +27,9 @@ bool PacketHistory::wasSeenRecently(const meshtastic_MeshPacket *p, bool withUpd
     r.id = p->id;
     r.sender = getFrom(p);
     r.rxTimeMsec = millis();
+    r.next_hop = p->next_hop;
+    r.relayed_by[0] = p->relay_node;
+    // LOG_INFO("Add relayed_by 0x%x for id=0x%x", p->relay_node, r.id);
 
     auto found = recentPackets.find(r);
     bool seenRecently = (found != recentPackets.end()); // found not equal to .end() means packet was seen recently
@@ -40,14 +43,36 @@ bool PacketHistory::wasSeenRecently(const meshtastic_MeshPacket *p, bool withUpd
 
     if (seenRecently) {
         LOG_DEBUG("Found existing packet record for fr=0x%x,to=0x%x,id=0x%x", p->from, p->to, p->id);
+        uint8_t ourRelayID = nodeDB->getLastByteOfNodeNum(nodeDB->getNodeNum());
+        if (wasFallback) {
+            // If it was seen with a next-hop not set to us and now it's NO_NEXT_HOP_PREFERENCE, and the relayer relayed already
+            // before, it's a fallback to flooding. If we didn't already relay and the next-hop neither, we might need to handle
+            // it now.
+            if (found->sender != nodeDB->getNodeNum() && found->next_hop != NO_NEXT_HOP_PREFERENCE &&
+                found->next_hop != ourRelayID && p->next_hop == NO_NEXT_HOP_PREFERENCE && wasRelayer(p->relay_node, found) &&
+                !wasRelayer(ourRelayID, found) && !wasRelayer(found->next_hop, found)) {
+                *wasFallback = true;
+            }
+        }
+
+        // Check if we were the next hop for this packet
+        if (weWereNextHop) {
+            *weWereNextHop = found->next_hop == ourRelayID;
+        }
     }
 
     if (withUpdate) {
-        if (found != recentPackets.end()) { // delete existing to updated timestamp (re-insert)
-            recentPackets.erase(found);     // as unsorted_set::iterator is const (can't update timestamp - so re-insert..)
+        if (found != recentPackets.end()) { // delete existing to updated timestamp and relayed_by (re-insert)
+            // Add the existing relayed_by to the new record
+            for (uint8_t i = 0; i < NUM_RELAYERS - 1; i++) {
+                if (found->relayed_by[i])
+                    r.relayed_by[i + 1] = found->relayed_by[i];
+            }
+            r.next_hop = found->next_hop; // keep the original next_hop (such that we check whether we were originally asked)
+            recentPackets.erase(found);   // as unsorted_set::iterator is const (can't update - so re-insert..)
         }
         recentPackets.insert(r);
-        printPacket("Add packet record", p);
+        LOG_DEBUG("Add packet record fr=0x%x, id=0x%x", p->from, p->id);
     }
 
     // Capacity is reerved, so only purge expired packets if recentPackets fills past 90% capacity
@@ -75,4 +100,59 @@ void PacketHistory::clearExpiredRecentPackets()
     }
 
     LOG_DEBUG("recentPackets size=%ld (after clearing expired packets)", recentPackets.size());
+}
+
+/* Check if a certain node was a relayer of a packet in the history given an ID and sender
+ * @return true if node was indeed a relayer, false if not */
+bool PacketHistory::wasRelayer(const uint8_t relayer, const uint32_t id, const NodeNum sender)
+{
+    if (relayer == 0)
+        return false;
+
+    PacketRecord r = {.sender = sender, .id = id, .rxTimeMsec = 0, .next_hop = 0};
+    auto found = recentPackets.find(r);
+
+    if (found == recentPackets.end()) {
+        return false;
+    }
+
+    return wasRelayer(relayer, found);
+}
+
+/* Check if a certain node was a relayer of a packet in the history given iterator
+ * @return true if node was indeed a relayer, false if not */
+bool PacketHistory::wasRelayer(const uint8_t relayer, std::unordered_set<PacketRecord, PacketRecordHashFunction>::iterator r)
+{
+    for (uint8_t i = 0; i < NUM_RELAYERS; i++) {
+        if (r->relayed_by[i] == relayer) {
+            return true;
+        }
+    }
+    return false;
+}
+
+// Remove a relayer from the list of relayers of a packet in the history given an ID and sender
+void PacketHistory::removeRelayer(const uint8_t relayer, const uint32_t id, const NodeNum sender)
+{
+    PacketRecord r = {.sender = sender, .id = id, .rxTimeMsec = 0, .next_hop = 0};
+    auto found = recentPackets.find(r);
+
+    if (found == recentPackets.end()) {
+        return;
+    }
+    // Make a copy of the found record
+    r.next_hop = found->next_hop;
+    r.rxTimeMsec = found->rxTimeMsec;
+
+    // Only add the relayers that are not the one we want to remove
+    uint8_t j = 0;
+    for (uint8_t i = 0; i < NUM_RELAYERS; i++) {
+        if (found->relayed_by[i] != relayer) {
+            r.relayed_by[j] = found->relayed_by[i];
+            j++;
+        }
+    }
+
+    recentPackets.erase(found);
+    recentPackets.insert(r);
 }

src/mesh/PacketHistory.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "Router.h"
+#include "NodeDB.h"
 #include <unordered_set>
 
 /// We clear our old flood record 10 minutes after we see the last of it
@@ -10,13 +10,18 @@
 #define FLOOD_EXPIRE_TIME (10 * 60 * 1000L)
 #endif
 
+#define NUM_RELAYERS                                                                                                             \
+    3 // Number of relayer we keep track of. Use 3 to be efficient with memory alignment of PacketRecord to 16 bytes
+
 /**
  * A record of a recent message broadcast
  */
 struct PacketRecord {
     NodeNum sender;
     PacketId id;
-    uint32_t rxTimeMsec; // Unix time in msecs - the time we received it
+    uint32_t rxTimeMsec;              // Unix time in msecs - the time we received it
+    uint8_t next_hop;                 // The next hop asked for this packet
+    uint8_t relayed_by[NUM_RELAYERS]; // Array of nodes that relayed this packet
 
     bool operator==(const PacketRecord &p) const { return sender == p.sender && id == p.id; }
 };
@@ -44,6 +49,20 @@ class PacketHistory
      * Update recentBroadcasts and return true if we have already seen this packet
      *
      * @param withUpdate if true and not found we add an entry to recentPackets
+     * @param wasFallback if not nullptr, packet will be checked for fallback to flooding and value will be set to true if so
+     * @param weWereNextHop if not nullptr, packet will be checked for us being the next hop and value will be set to true if so
      */
-    bool wasSeenRecently(const meshtastic_MeshPacket *p, bool withUpdate = true);
-};
+    bool wasSeenRecently(const meshtastic_MeshPacket *p, bool withUpdate = true, bool *wasFallback = nullptr,
+                         bool *weWereNextHop = nullptr);
+
+    /* Check if a certain node was a relayer of a packet in the history given an ID and sender
+     * @return true if node was indeed a relayer, false if not */
+    bool wasRelayer(const uint8_t relayer, const uint32_t id, const NodeNum sender);
+
+    /* Check if a certain node was a relayer of a packet in the history given iterator
+     * @return true if node was indeed a relayer, false if not */
+    bool wasRelayer(const uint8_t relayer, std::unordered_set<PacketRecord, PacketRecordHashFunction>::iterator r);
+
+    // Remove a relayer from the list of relayers of a packet in the history given an ID and sender
+    void removeRelayer(const uint8_t relayer, const uint32_t id, const NodeNum sender);
+};

src/mesh/PhoneAPI.cpp

@@ -12,6 +12,7 @@
 #include "PhoneAPI.h"
 #include "PowerFSM.h"
 #include "RadioInterface.h"
+#include "Router.h"
 #include "SPILock.h"
 #include "TypeConversions.h"
 #include "main.h"
@@ -643,11 +644,6 @@ bool PhoneAPI::handleToRadioPacket(meshtastic_MeshPacket &p)
         meshtastic_QueueStatus qs = router->getQueueStatus();
         service->sendQueueStatusToPhone(qs, 0, p.id);
         return false;
-    } else if (p.decoded.portnum == meshtastic_PortNum_TRACEROUTE_APP && isBroadcast(p.to) && p.hop_limit > 0) {
-        sendNotification(meshtastic_LogRecord_Level_WARNING, p.id, "Multi-hop traceroute to broadcast address is not allowed");
-        meshtastic_QueueStatus qs = router->getQueueStatus();
-        service->sendQueueStatusToPhone(qs, 0, p.id);
-        return false;
     } else if (p.decoded.portnum == meshtastic_PortNum_POSITION_APP && lastPortNumToRadio[p.decoded.portnum] &&
                Throttle::isWithinTimespanMs(lastPortNumToRadio[p.decoded.portnum], FIVE_SECONDS_MS)) {
         LOG_WARN("Rate limit portnum %d", p.decoded.portnum);

src/mesh/RadioInterface.cpp

@@ -340,6 +340,10 @@ void printPacket(const char *prefix, const meshtastic_MeshPacket *p)
         out += DEBUG_PORT.mt_sprintf(" via MQTT");
     if (p->hop_start != 0)
         out += DEBUG_PORT.mt_sprintf(" hopStart=%d", p->hop_start);
+    if (p->next_hop != 0)
+        out += DEBUG_PORT.mt_sprintf(" nextHop=0x%x", p->next_hop);
+    if (p->relay_node != 0)
+        out += DEBUG_PORT.mt_sprintf(" relay=0x%x", p->relay_node);
     if (p->priority != 0)
         out += DEBUG_PORT.mt_sprintf(" priority=%d", p->priority);
 
@@ -620,8 +624,8 @@ size_t RadioInterface::beginSending(meshtastic_MeshPacket *p)
     radioBuffer.header.to = p->to;
     radioBuffer.header.id = p->id;
     radioBuffer.header.channel = p->channel;
-    radioBuffer.header.next_hop = 0;   // *** For future use ***
-    radioBuffer.header.relay_node = 0; // *** For future use ***
+    radioBuffer.header.next_hop = p->next_hop;
+    radioBuffer.header.relay_node = p->relay_node;
     if (p->hop_limit > HOP_MAX) {
         LOG_WARN("hop limit %d is too high, setting to %d", p->hop_limit, HOP_RELIABLE);
         p->hop_limit = HOP_RELIABLE;

src/mesh/RadioInterface.h

@@ -38,10 +38,10 @@ typedef struct {
     /** The channel hash - used as a hint for the decoder to limit which channels we consider */
     uint8_t channel;
 
-    // ***For future use*** Last byte of the NodeNum of the next-hop for this packet
+    // Last byte of the NodeNum of the next-hop for this packet
     uint8_t next_hop;
 
-    // ***For future use*** Last byte of the NodeNum of the node that will relay/relayed this packet
+    // Last byte of the NodeNum of the node that will relay/relayed this packet
     uint8_t relay_node;
 } PacketHeader;
 
@@ -155,6 +155,9 @@ class RadioInterface
     /** Attempt to cancel a previously sent packet.  Returns true if a packet was found we could cancel */
     virtual bool cancelSending(NodeNum from, PacketId id) { return false; }
 
+    /** Attempt to find a packet in the TxQueue. Returns true if the packet was found. */
+    virtual bool findInTxQueue(NodeNum from, PacketId id) { return false; }
+
     // methods from radiohead
 
     /// Initialise the Driver transport hardware and software.

src/mesh/RadioLibInterface.cpp

@@ -222,6 +222,12 @@ bool RadioLibInterface::cancelSending(NodeNum from, PacketId id)
     return result;
 }
 
+/** Attempt to find a packet in the TxQueue. Returns true if the packet was found. */
+bool RadioLibInterface::findInTxQueue(NodeNum from, PacketId id)
+{
+    return txQueue.find(from, id);
+}
+
 /** radio helper thread callback.
 We never immediately transmit after any operation (either Rx or Tx). Instead we should wait a random multiple of
 'slotTimes' (see definition in RadioInterface.h) taken from a contention window (CW) to lower the chance of collision.
@@ -445,6 +451,9 @@ void RadioLibInterface::handleReceiveInterrupt()
             mp->hop_start = (radioBuffer.header.flags & PACKET_FLAGS_HOP_START_MASK) >> PACKET_FLAGS_HOP_START_SHIFT;
             mp->want_ack = !!(radioBuffer.header.flags & PACKET_FLAGS_WANT_ACK_MASK);
             mp->via_mqtt = !!(radioBuffer.header.flags & PACKET_FLAGS_VIA_MQTT_MASK);
+            // If hop_start is not set, next_hop and relay_node are invalid (firmware <2.3)
+            mp->next_hop = mp->hop_start == 0 ? NO_NEXT_HOP_PREFERENCE : radioBuffer.header.next_hop;
+            mp->relay_node = mp->hop_start == 0 ? NO_RELAY_NODE : radioBuffer.header.relay_node;
 
             addReceiveMetadata(mp);
 

src/mesh/RadioLibInterface.h

@@ -135,6 +135,9 @@ class RadioLibInterface : public RadioInterface, protected concurrency::Notified
     /** Attempt to cancel a previously sent packet.  Returns true if a packet was found we could cancel */
     virtual bool cancelSending(NodeNum from, PacketId id) override;
 
+    /** Attempt to find a packet in the TxQueue. Returns true if the packet was found. */
+    virtual bool findInTxQueue(NodeNum from, PacketId id) override;
+
   private:
     /** if we have something waiting to send, start a short (random) timer so we can come check for collision before actually
      * doing the transmit */

src/mesh/ReliableRouter.cpp

@@ -23,7 +23,7 @@ ErrorCode ReliableRouter::send(meshtastic_MeshPacket *p)
         }
 
         auto copy = packetPool.allocCopy(*p);
-        startRetransmission(copy);
+        startRetransmission(copy, NUM_RELIABLE_RETX);
     }
 
     /* If we have pending retransmissions, add the airtime of this packet to it, because during that time we cannot receive an
@@ -35,7 +35,7 @@ ErrorCode ReliableRouter::send(meshtastic_MeshPacket *p)
         }
     }
 
-    return FloodingRouter::send(p);
+    return isBroadcast(p->to) ? FloodingRouter::send(p) : NextHopRouter::send(p);
 }
 
 bool ReliableRouter::shouldFilterReceived(const meshtastic_MeshPacket *p)
@@ -73,7 +73,7 @@ bool ReliableRouter::shouldFilterReceived(const meshtastic_MeshPacket *p)
         i->second.nextTxMsec += iface->getPacketTime(p);
     }
 
-    return FloodingRouter::shouldFilterReceived(p);
+    return isBroadcast(p->to) ? FloodingRouter::shouldFilterReceived(p) : NextHopRouter::shouldFilterReceived(p);
 }
 
 /**
@@ -138,126 +138,5 @@ void ReliableRouter::sniffReceived(const meshtastic_MeshPacket *p, const meshtas
     }
 
     // handle the packet as normal
-    FloodingRouter::sniffReceived(p, c);
-}
-
-#define NUM_RETRANSMISSIONS 3
-
-PendingPacket::PendingPacket(meshtastic_MeshPacket *p)
-{
-    packet = p;
-    numRetransmissions = NUM_RETRANSMISSIONS - 1; // We subtract one, because we assume the user just did the first send
-}
-
-PendingPacket *ReliableRouter::findPendingPacket(GlobalPacketId key)
-{
-    auto old = pending.find(key); // If we have an old record, someone messed up because id got reused
-    if (old != pending.end()) {
-        return &old->second;
-    } else
-        return NULL;
-}
-/**
- * Stop any retransmissions we are doing of the specified node/packet ID pair
- */
-bool ReliableRouter::stopRetransmission(NodeNum from, PacketId id)
-{
-    auto key = GlobalPacketId(from, id);
-    return stopRetransmission(key);
-}
-
-bool ReliableRouter::stopRetransmission(GlobalPacketId key)
-{
-    auto old = findPendingPacket(key);
-    if (old) {
-        auto p = old->packet;
-        /* Only when we already transmitted a packet via LoRa, we will cancel the packet in the Tx queue
-          to avoid canceling a transmission if it was ACKed super fast via MQTT */
-        if (old->numRetransmissions < NUM_RETRANSMISSIONS - 1) {
-            // remove the 'original' (identified by originator and packet->id) from the txqueue and free it
-            cancelSending(getFrom(p), p->id);
-        }
-        // now free the pooled copy for retransmission too
-        packetPool.release(p);
-        auto numErased = pending.erase(key);
-        assert(numErased == 1);
-        return true;
-    } else
-        return false;
-}
-
-/**
- * Add p to the list of packets to retransmit occasionally.  We will free it once we stop retransmitting.
- */
-PendingPacket *ReliableRouter::startRetransmission(meshtastic_MeshPacket *p)
-{
-    auto id = GlobalPacketId(p);
-    auto rec = PendingPacket(p);
-
-    stopRetransmission(getFrom(p), p->id);
-
-    setNextTx(&rec);
-    pending[id] = rec;
-
-    return &pending[id];
-}
-
-/**
- * Do any retransmissions that are scheduled (FIXME - for the time being called from loop)
- */
-int32_t ReliableRouter::doRetransmissions()
-{
-    uint32_t now = millis();
-    int32_t d = INT32_MAX;
-
-    // FIXME, we should use a better datastructure rather than walking through this map.
-    // for(auto el: pending) {
-    for (auto it = pending.begin(), nextIt = it; it != pending.end(); it = nextIt) {
-        ++nextIt; // we use this odd pattern because we might be deleting it...
-        auto &p = it->second;
-
-        bool stillValid = true; // assume we'll keep this record around
-
-        // FIXME, handle 51 day rollover here!!!
-        if (p.nextTxMsec <= now) {
-            if (p.numRetransmissions == 0) {
-                LOG_DEBUG("Reliable send failed, return a nak for fr=0x%x,to=0x%x,id=0x%x", p.packet->from, p.packet->to,
-                          p.packet->id);
-                sendAckNak(meshtastic_Routing_Error_MAX_RETRANSMIT, getFrom(p.packet), p.packet->id, p.packet->channel);
-                // Note: we don't stop retransmission here, instead the Nak packet gets processed in sniffReceived
-                stopRetransmission(it->first);
-                stillValid = false; // just deleted it
-            } else {
-                LOG_DEBUG("Send reliable retransmission fr=0x%x,to=0x%x,id=0x%x, tries left=%d", p.packet->from, p.packet->to,
-                          p.packet->id, p.numRetransmissions);
-
-                // Note: we call the superclass version because we don't want to have our version of send() add a new
-                // retransmission record
-                FloodingRouter::send(packetPool.allocCopy(*p.packet));
-
-                // Queue again
-                --p.numRetransmissions;
-                setNextTx(&p);
-            }
-        }
-
-        if (stillValid) {
-            // Update our desired sleep delay
-            int32_t t = p.nextTxMsec - now;
-
-            d = min(t, d);
-        }
-    }
-
-    return d;
-}
-
-void ReliableRouter::setNextTx(PendingPacket *pending)
-{
-    assert(iface);
-    auto d = iface->getRetransmissionMsec(pending->packet);
-    pending->nextTxMsec = millis() + d;
-    LOG_DEBUG("Set next retransmission in %u msecs: ", d);
-    printPacket("", pending->packet);
-    setReceivedMessage(); // Run ASAP, so we can figure out our correct sleep time
+    isBroadcast(p->to) ? FloodingRouter::sniffReceived(p, c) : NextHopRouter::sniffReceived(p, c);
 }

src/mesh/ReliableRouter.h

@@ -1,61 +1,12 @@
 #pragma once
 
-#include "FloodingRouter.h"
-#include <unordered_map>
-
-/**
- * An identifier for a globally unique message - a pair of the sending nodenum and the packet id assigned
- * to that message
- */
-struct GlobalPacketId {
-    NodeNum node;
-    PacketId id;
-
-    bool operator==(const GlobalPacketId &p) const { return node == p.node && id == p.id; }
-
-    explicit GlobalPacketId(const meshtastic_MeshPacket *p)
-    {
-        node = getFrom(p);
-        id = p->id;
-    }
-
-    GlobalPacketId(NodeNum _from, PacketId _id)
-    {
-        node = _from;
-        id = _id;
-    }
-};
-
-/**
- * A packet queued for retransmission
- */
-struct PendingPacket {
-    meshtastic_MeshPacket *packet;
-
-    /** The next time we should try to retransmit this packet */
-    uint32_t nextTxMsec = 0;
-
-    /** Starts at NUM_RETRANSMISSIONS -1(normally 3) and counts down.  Once zero it will be removed from the list */
-    uint8_t numRetransmissions = 0;
-
-    PendingPacket() {}
-    explicit PendingPacket(meshtastic_MeshPacket *p);
-};
-
-class GlobalPacketIdHashFunction
-{
-  public:
-    size_t operator()(const GlobalPacketId &p) const { return (std::hash<NodeNum>()(p.node)) ^ (std::hash<PacketId>()(p.id)); }
-};
+#include "NextHopRouter.h"
 
 /**
  * This is a mixin that extends Router with the ability to do (one hop only) reliable message sends.
  */
-class ReliableRouter : public FloodingRouter
+class ReliableRouter : public NextHopRouter
 {
-  private:
-    std::unordered_map<GlobalPacketId, PendingPacket, GlobalPacketIdHashFunction> pending;
-
   public:
     /**
      * Constructor
@@ -70,54 +21,14 @@ class ReliableRouter : public FloodingRouter
      */
     virtual ErrorCode send(meshtastic_MeshPacket *p) override;
 
-    /** Do our retransmission handling */
-    virtual int32_t runOnce() override
-    {
-        // Note: We must doRetransmissions FIRST, because it might queue up work for the base class runOnce implementation
-        auto d = doRetransmissions();
-
-        int32_t r = FloodingRouter::runOnce();
-
-        return min(d, r);
-    }
-
   protected:
     /**
      * Look for acks/naks or someone retransmitting us
      */
     virtual void sniffReceived(const meshtastic_MeshPacket *p, const meshtastic_Routing *c) override;
 
-    /**
-     * Try to find the pending packet record for this ID (or NULL if not found)
-     */
-    PendingPacket *findPendingPacket(NodeNum from, PacketId id) { return findPendingPacket(GlobalPacketId(from, id)); }
-    PendingPacket *findPendingPacket(GlobalPacketId p);
-
     /**
      * We hook this method so we can see packets before FloodingRouter says they should be discarded
      */
     virtual bool shouldFilterReceived(const meshtastic_MeshPacket *p) override;
-
-    /**
-     * Add p to the list of packets to retransmit occasionally.  We will free it once we stop retransmitting.
-     */
-    PendingPacket *startRetransmission(meshtastic_MeshPacket *p);
-
-  private:
-    /**
-     * Stop any retransmissions we are doing of the specified node/packet ID pair
-     *
-     * @return true if we found and removed a transmission with this ID
-     */
-    bool stopRetransmission(NodeNum from, PacketId id);
-    bool stopRetransmission(GlobalPacketId p);
-
-    /**
-     * Do any retransmissions that are scheduled (FIXME - for the time being called from loop)
-     *
-     * @return the number of msecs until our next retransmission or MAXINT if none scheduled
-     */
-    int32_t doRetransmissions();
-
-    void setNextTx(PendingPacket *pending);
-};
+};

src/mesh/Router.cpp

@@ -249,6 +249,7 @@ ErrorCode Router::send(meshtastic_MeshPacket *p)
     // the lora we need to make sure we have replaced it with our local address
     p->from = getFrom(p);
 
+    p->relay_node = nodeDB->getLastByteOfNodeNum(getNodeNum()); // set the relayer to us
     // If we are the original transmitter, set the hop limit with which we start
     if (isFromUs(p))
         p->hop_start = p->hop_limit;
@@ -290,7 +291,18 @@ ErrorCode Router::send(meshtastic_MeshPacket *p)
 /** Attempt to cancel a previously sent packet.  Returns true if a packet was found we could cancel */
 bool Router::cancelSending(NodeNum from, PacketId id)
 {
-    return iface ? iface->cancelSending(from, id) : false;
+    if (iface && iface->cancelSending(from, id)) {
+        // We are not a relayer of this packet anymore
+        removeRelayer(nodeDB->getLastByteOfNodeNum(nodeDB->getNodeNum()), id, from);
+        return true;
+    }
+    return false;
+}
+
+/** Attempt to find a packet in the TxQueue. Returns true if the packet was found. */
+bool Router::findInTxQueue(NodeNum from, PacketId id)
+{
+    return iface->findInTxQueue(from, id);
 }
 
 /**

src/mesh/Router.h

@@ -4,6 +4,7 @@
 #include "MemoryPool.h"
 #include "MeshTypes.h"
 #include "Observer.h"
+#include "PacketHistory.h"
 #include "PointerQueue.h"
 #include "RadioInterface.h"
 #include "concurrency/OSThread.h"
@@ -11,7 +12,7 @@
 /**
  * A mesh aware router that supports multiple interfaces.
  */
-class Router : protected concurrency::OSThread
+class Router : protected concurrency::OSThread, protected PacketHistory
 {
   private:
     /// Packets which have just arrived from the radio, ready to be processed by this service and possibly
@@ -50,6 +51,9 @@ class Router : protected concurrency::OSThread
     /** Attempt to cancel a previously sent packet.  Returns true if a packet was found we could cancel */
     bool cancelSending(NodeNum from, PacketId id);
 
+    /** Attempt to find a packet in the TxQueue. Returns true if the packet was found. */
+    bool findInTxQueue(NodeNum from, PacketId id);
+
     /** Allocate and return a meshpacket which defaults as send to broadcast from the current node.
      * The returned packet is guaranteed to have a unique packet ID already assigned
      */

src/mesh/api/ServerAPI.cpp

@@ -51,8 +51,6 @@ template <class T, class U> int32_t APIServerPort<T, U>::runOnce()
 #else
     auto client = U::available();
 #endif
-#elif defined(ARCH_RP2040)
-    auto client = U::accept();
 #else
     auto client = U::available();
 #endif
@@ -80,4 +78,4 @@ template <class T, class U> int32_t APIServerPort<T, U>::runOnce()
     waitTime = 100;
 #endif
     return 100; // only check occasionally for incoming connections
-}
+}

src/mesh/compression/unishox2.h

@@ -291,8 +291,8 @@ extern int unishox2_decompress_simple(const char *in, int len, char *out);
  * @param[in] olen           length of 'out' buffer in bytes. Can be omitted if sufficient buffer is provided
  * @param[in] usx_hcodes     Horizontal codes (array of bytes). See macro section for samples.
  * @param[in] usx_hcode_lens Length of each element in usx_hcodes array
- * @param[in] usx_freq_seq   Frequently occurring sequences. See USX_FREQ_SEQ_* macros for samples
- * @param[in] usx_templates  Templates of frequently occurring patterns. See USX_TEMPLATES macro.
+ * @param[in] usx_freq_seq   Frequently occuring sequences. See USX_FREQ_SEQ_* macros for samples
+ * @param[in] usx_templates  Templates of frequently occuring patterns. See USX_TEMPLATES macro.
  */
 extern int unishox2_compress(const char *in, int len, UNISHOX_API_OUT_AND_LEN(char *out, int olen),
                              const unsigned char usx_hcodes[], const unsigned char usx_hcode_lens[], const char *usx_freq_seq[],
@@ -310,8 +310,8 @@ extern int unishox2_compress(const char *in, int len, UNISHOX_API_OUT_AND_LEN(ch
  * @param[in] olen           length of 'out' buffer in bytes. Can be omitted if sufficient buffer is provided
  * @param[in] usx_hcodes     Horizontal codes (array of bytes). See macro section for samples.
  * @param[in] usx_hcode_lens Length of each element in usx_hcodes array
- * @param[in] usx_freq_seq   Frequently occurring sequences. See USX_FREQ_SEQ_* macros for samples
- * @param[in] usx_templates  Templates of frequently occurring patterns. See USX_TEMPLATES macro.
+ * @param[in] usx_freq_seq   Frequently occuring sequences. See USX_FREQ_SEQ_* macros for samples
+ * @param[in] usx_templates  Templates of frequently occuring patterns. See USX_TEMPLATES macro.
  */
 extern int unishox2_decompress(const char *in, int len, UNISHOX_API_OUT_AND_LEN(char *out, int olen),
                                const unsigned char usx_hcodes[], const unsigned char usx_hcode_lens[], const char *usx_freq_seq[],
@@ -344,4 +344,4 @@ extern int unishox2_decompress_lines(const char *in, int len, UNISHOX_API_OUT_AN
                                      const unsigned char usx_hcodes[], const unsigned char usx_hcode_lens[],
                                      const char *usx_freq_seq[], const char *usx_templates[], struct us_lnk_lst *prev_lines);
 
-#endif
+#endif

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

@@ -122,8 +122,7 @@ typedef struct _meshtastic_DeviceState {
  Indicates developer is testing and changes should never be saved to flash.
  Deprecated in 2.3.1 */
     bool no_save;
-    /* Previously used to manage GPS factory resets.
- Deprecated in 2.5.23 */
+    /* Some GPS receivers seem to have bogus settings from the factory, so we always do one factory reset. */
     bool did_gps_reset;
     /* We keep the last received waypoint stored in the device flash,
  so we can show it on the screen.

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

@@ -1775,4 +1775,4 @@ extern const pb_msgdesc_t meshtastic_ChunkedPayloadResponse_msg;
 } /* extern "C" */
 #endif
 
-#endif
+#endif

src/modules/AdminModule.cpp

@@ -123,23 +123,23 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta
      * Getters
      */
     case meshtastic_AdminMessage_get_owner_request_tag:
-        LOG_DEBUG("Client got owner");
+        LOG_INFO("Client got owner");
         handleGetOwner(mp);
         break;
 
     case meshtastic_AdminMessage_get_config_request_tag:
-        LOG_DEBUG("Client got config");
+        LOG_INFO("Client got config");
         handleGetConfig(mp, r->get_config_request);
         break;
 
     case meshtastic_AdminMessage_get_module_config_request_tag:
-        LOG_DEBUG("Client got module config");
+        LOG_INFO("Client got module config");
         handleGetModuleConfig(mp, r->get_module_config_request);
         break;
 
     case meshtastic_AdminMessage_get_channel_request_tag: {
         uint32_t i = r->get_channel_request - 1;
-        LOG_DEBUG("Client got channel %u", i);
+        LOG_INFO("Client got channel %u", i);
         if (i >= MAX_NUM_CHANNELS)
             myReply = allocErrorResponse(meshtastic_Routing_Error_BAD_REQUEST, &mp);
         else
@@ -151,35 +151,35 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta
      * Setters
      */
     case meshtastic_AdminMessage_set_owner_tag:
-        LOG_DEBUG("Client set owner");
+        LOG_INFO("Client set owner");
         handleSetOwner(r->set_owner);
         break;
 
     case meshtastic_AdminMessage_set_config_tag:
-        LOG_DEBUG("Client set config");
+        LOG_INFO("Client set config");
         handleSetConfig(r->set_config);
         break;
 
     case meshtastic_AdminMessage_set_module_config_tag:
-        LOG_DEBUG("Client set module config");
+        LOG_INFO("Client set module config");
         if (!handleSetModuleConfig(r->set_module_config)) {
             myReply = allocErrorResponse(meshtastic_Routing_Error_BAD_REQUEST, &mp);
         }
         break;
 
     case meshtastic_AdminMessage_set_channel_tag:
-        LOG_DEBUG("Client set channel %d", r->set_channel.index);
+        LOG_INFO("Client set channel %d", r->set_channel.index);
         if (r->set_channel.index < 0 || r->set_channel.index >= (int)MAX_NUM_CHANNELS)
             myReply = allocErrorResponse(meshtastic_Routing_Error_BAD_REQUEST, &mp);
         else
             handleSetChannel(r->set_channel);
         break;
     case meshtastic_AdminMessage_set_ham_mode_tag:
-        LOG_DEBUG("Client set ham mode");
+        LOG_INFO("Client set ham mode");
         handleSetHamMode(r->set_ham_mode);
         break;
     case meshtastic_AdminMessage_get_ui_config_request_tag: {
-        LOG_DEBUG("Client is getting device-ui config");
+        LOG_INFO("Client is getting device-ui config");
         handleGetDeviceUIConfig(mp);
         handled = true;
         break;
@@ -391,7 +391,7 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta
             LOG_DEBUG("Did not responded to a request that wanted a respond. req.variant=%d", r->which_payload_variant);
         } else if (handleResult != AdminMessageHandleResult::HANDLED) {
             // Probably a message sent by us or sent to our local node.  FIXME, we should avoid scanning these messages
-            LOG_DEBUG("Ignore irrelevant admin %d", r->which_payload_variant);
+            LOG_INFO("Ignore irrelevant admin %d", r->which_payload_variant);
         }
         break;
     }
@@ -1171,4 +1171,4 @@ void disableBluetooth()
         nrf52Bluetooth->shutdown();
 #endif
 #endif
-}
+}

src/modules/Telemetry/PowerTelemetry.cpp

@@ -31,6 +31,7 @@ int32_t PowerTelemetryModule::runOnce()
         doDeepSleep(nightyNightMs, true, false);
     }
 
+    uint32_t result = UINT32_MAX;
     /*
         Uncomment the preferences below if you want to use the module
         without having to configure it from the PythonAPI or WebUI.
@@ -45,33 +46,25 @@ int32_t PowerTelemetryModule::runOnce()
         return disable();
     }
 
-    uint32_t sendToMeshIntervalMs = Default::getConfiguredOrDefaultMsScaled(
-        moduleConfig.telemetry.power_update_interval, default_telemetry_broadcast_interval_secs, numOnlineNodes);
-
     if (firstTime) {
         // This is the first time the OSThread library has called this function, so do some setup
         firstTime = 0;
-        uint32_t result = UINT32_MAX;
-
 #if HAS_TELEMETRY && !defined(ARCH_PORTDUINO)
         if (moduleConfig.telemetry.power_measurement_enabled) {
             LOG_INFO("Power Telemetry: init");
-            // If sensor is already initialized by EnvironmentTelemetryModule, then we don't need to initialize it again,
-            // but we need to set the result to != UINT32_MAX to avoid it being disabled
-            if (ina219Sensor.hasSensor())
-                result = ina219Sensor.isInitialized() ? 0 : ina219Sensor.runOnce();
-            if (ina226Sensor.hasSensor())
-                result = ina226Sensor.isInitialized() ? 0 : ina226Sensor.runOnce();
-            if (ina260Sensor.hasSensor())
-                result = ina260Sensor.isInitialized() ? 0 : ina260Sensor.runOnce();
-            if (ina3221Sensor.hasSensor())
-                result = ina3221Sensor.isInitialized() ? 0 : ina3221Sensor.runOnce();
-            if (max17048Sensor.hasSensor())
-                result = max17048Sensor.isInitialized() ? 0 : max17048Sensor.runOnce();
+            // it's possible to have this module enabled, only for displaying values on the screen.
+            // therefore, we should only enable the sensor loop if measurement is also enabled
+            if (ina219Sensor.hasSensor() && !ina219Sensor.isInitialized())
+                result = ina219Sensor.runOnce();
+            if (ina226Sensor.hasSensor() && !ina226Sensor.isInitialized())
+                result = ina226Sensor.runOnce();
+            if (ina260Sensor.hasSensor() && !ina260Sensor.isInitialized())
+                result = ina260Sensor.runOnce();
+            if (ina3221Sensor.hasSensor() && !ina3221Sensor.isInitialized())
+                result = ina3221Sensor.runOnce();
+            if (max17048Sensor.hasSensor() && !max17048Sensor.isInitialized())
+                result = max17048Sensor.runOnce();
         }
-
-        // it's possible to have this module enabled, only for displaying values on the screen.
-        // therefore, we should only enable the sensor loop if measurement is also enabled
         return result == UINT32_MAX ? disable() : setStartDelay();
 #else
         return disable();
@@ -81,7 +74,10 @@ int32_t PowerTelemetryModule::runOnce()
         if (!moduleConfig.telemetry.power_measurement_enabled)
             return disable();
 
-        if (((lastSentToMesh == 0) || !Throttle::isWithinTimespanMs(lastSentToMesh, sendToMeshIntervalMs)) &&
+        if (((lastSentToMesh == 0) ||
+             !Throttle::isWithinTimespanMs(lastSentToMesh, Default::getConfiguredOrDefaultMsScaled(
+                                                               moduleConfig.telemetry.power_update_interval,
+                                                               default_telemetry_broadcast_interval_secs, numOnlineNodes))) &&
             airTime->isTxAllowedAirUtil()) {
             sendTelemetry();
             lastSentToMesh = millis();
@@ -93,9 +89,8 @@ int32_t PowerTelemetryModule::runOnce()
             lastSentToPhone = millis();
         }
     }
-    return min(sendToPhoneIntervalMs, sendToMeshIntervalMs);
+    return min(sendToPhoneIntervalMs, result);
 }
-
 bool PowerTelemetryModule::wantUIFrame()
 {
     return moduleConfig.telemetry.power_screen_enabled;

src/modules/TraceRouteModule.cpp

@@ -109,7 +109,7 @@ void TraceRouteModule::appendMyIDandSNR(meshtastic_RouteDiscovery *updated, floa
 void TraceRouteModule::printRoute(meshtastic_RouteDiscovery *r, uint32_t origin, uint32_t dest, bool isTowardsDestination)
 {
 #ifdef DEBUG_PORT
-    std::string route = "Route traced:";
+    std::string route = "Route traced:\n";
     route += vformat("0x%x --> ", origin);
     for (uint8_t i = 0; i < r->route_count; i++) {
         if (i < r->snr_towards_count && r->snr_towards[i] != INT8_MIN)
@@ -129,6 +129,7 @@ void TraceRouteModule::printRoute(meshtastic_RouteDiscovery *r, uint32_t origin,
 
     // If there's a route back (or we are the destination as then the route is complete), print it
     if (r->route_back_count > 0 || origin == nodeDB->getNodeNum()) {
+        route += "\n";
         if (r->snr_towards_count > 0 && origin == nodeDB->getNodeNum())
             route += vformat("(%.2fdB) 0x%x <-- ", (float)r->snr_back[r->snr_back_count - 1] / 4, origin);
         else
@@ -150,12 +151,6 @@ meshtastic_MeshPacket *TraceRouteModule::allocReply()
 {
     assert(currentRequest);
 
-    // Ignore multi-hop broadcast requests
-    if (isBroadcast(currentRequest->to) && currentRequest->hop_limit < currentRequest->hop_start) {
-        ignoreRequest = true;
-        return NULL;
-    }
-
     // Copy the payload of the current request
     auto req = *currentRequest;
     const auto &p = req.decoded;

src/mqtt/MQTT.cpp

@@ -41,6 +41,7 @@ MQTT *mqtt;
 namespace
 {
 constexpr int reconnectMax = 5;
+constexpr uint16_t mqttPort = 1883;
 
 // FIXME - this size calculation is super sloppy, but it will go away once we dynamically alloc meshpackets
 static uint8_t bytes[meshtastic_MqttClientProxyMessage_size + 30]; // 12 for channel name and 16 for nodeid
@@ -250,68 +251,6 @@ bool isDefaultServer(const String &host)
 {
     return host.length() == 0 || host == default_mqtt_address;
 }
-
-struct PubSubConfig {
-    explicit PubSubConfig(const meshtastic_ModuleConfig_MQTTConfig &config)
-    {
-        if (*config.address) {
-            serverAddr = config.address;
-            mqttUsername = config.username;
-            mqttPassword = config.password;
-        }
-        if (config.tls_enabled) {
-            serverPort = 8883;
-        }
-        std::tie(serverAddr, serverPort) = parseHostAndPort(serverAddr.c_str(), serverPort);
-    }
-
-    // Defaults
-    static constexpr uint16_t defaultPort = 1883;
-    uint16_t serverPort = defaultPort;
-    String serverAddr = default_mqtt_address;
-    const char *mqttUsername = default_mqtt_username;
-    const char *mqttPassword = default_mqtt_password;
-};
-
-#if HAS_NETWORKING
-bool connectPubSub(const PubSubConfig &config, PubSubClient &pubSub, Client &client)
-{
-    pubSub.setBufferSize(1024);
-    pubSub.setClient(client);
-    pubSub.setServer(config.serverAddr.c_str(), config.serverPort);
-
-    LOG_INFO("Connecting directly to MQTT server %s, port: %d, username: %s, password: %s", config.serverAddr.c_str(),
-             config.serverPort, config.mqttUsername, config.mqttPassword);
-
-    const bool connected = pubSub.connect(owner.id, config.mqttUsername, config.mqttPassword);
-    if (connected) {
-        LOG_INFO("MQTT connected");
-    } else {
-        LOG_WARN("Failed to connect to MQTT server");
-    }
-    return connected;
-}
-#endif
-
-inline bool isConnectedToNetwork()
-{
-#if HAS_WIFI
-    return WiFi.isConnected();
-#elif HAS_ETHERNET
-    return Ethernet.linkStatus() == LinkON;
-#else
-    return false;
-#endif
-}
-
-/** return true if we have a channel that wants uplink/downlink or map reporting is enabled
- */
-bool wantsLink()
-{
-    const bool hasChannelorMapReport =
-        moduleConfig.mqtt.enabled && (moduleConfig.mqtt.map_reporting_enabled || channels.anyMqttEnabled());
-    return hasChannelorMapReport && (moduleConfig.mqtt.proxy_to_client_enabled || isConnectedToNetwork());
-}
 } // namespace
 
 void MQTT::mqttCallback(char *topic, byte *payload, unsigned int length)
@@ -474,18 +413,46 @@ void MQTT::reconnect()
             return; // Don't try to connect directly to the server
         }
 #if HAS_NETWORKING
-        const PubSubConfig config(moduleConfig.mqtt);
+        // Defaults
+        int serverPort = mqttPort;
+        const char *serverAddr = default_mqtt_address;
+        const char *mqttUsername = default_mqtt_username;
+        const char *mqttPassword = default_mqtt_password;
         MQTTClient *clientConnection = mqttClient.get();
-#if MQTT_SUPPORTS_TLS
+
+        if (*moduleConfig.mqtt.address) {
+            serverAddr = moduleConfig.mqtt.address;
+            mqttUsername = moduleConfig.mqtt.username;
+            mqttPassword = moduleConfig.mqtt.password;
+        }
+#if HAS_WIFI && !defined(ARCH_PORTDUINO) && !defined(CONFIG_IDF_TARGET_ESP32C6)
         if (moduleConfig.mqtt.tls_enabled) {
-            mqttClientTLS.setInsecure();
-            LOG_INFO("Use TLS-encrypted session");
-            clientConnection = &mqttClientTLS;
+            // change default for encrypted to 8883
+            try {
+                serverPort = 8883;
+                wifiSecureClient.setInsecure();
+                LOG_INFO("Use TLS-encrypted session");
+                clientConnection = &wifiSecureClient;
+            } catch (const std::exception &e) {
+                LOG_ERROR("MQTT ERROR: %s", e.what());
+            }
         } else {
             LOG_INFO("Use non-TLS-encrypted session");
         }
 #endif
-        if (connectPubSub(config, pubSub, *clientConnection)) {
+        std::pair<String, uint16_t> hostAndPort = parseHostAndPort(serverAddr, serverPort);
+        serverAddr = hostAndPort.first.c_str();
+        serverPort = hostAndPort.second;
+        pubSub.setServer(serverAddr, serverPort);
+        pubSub.setBufferSize(1024);
+
+        LOG_INFO("Connect directly to MQTT server %s, port: %d, username: %s, password: %s", serverAddr, serverPort, mqttUsername,
+                 mqttPassword);
+
+        pubSub.setClient(*clientConnection);
+        bool connected = pubSub.connect(owner.id, mqttUsername, mqttPassword);
+        if (connected) {
+            LOG_INFO("MQTT connected");
             enabled = true; // Start running background process again
             runASAP = true;
             reconnectCount = 0;
@@ -540,6 +507,23 @@ void MQTT::sendSubscriptions()
 #endif
 }
 
+bool MQTT::wantsLink() const
+{
+    bool hasChannelorMapReport =
+        moduleConfig.mqtt.enabled && (moduleConfig.mqtt.map_reporting_enabled || channels.anyMqttEnabled());
+
+    if (hasChannelorMapReport && moduleConfig.mqtt.proxy_to_client_enabled)
+        return true;
+
+#if HAS_WIFI
+    return hasChannelorMapReport && WiFi.isConnected();
+#endif
+#if HAS_ETHERNET
+    return hasChannelorMapReport && Ethernet.linkStatus() == LinkON;
+#endif
+    return false;
+}
+
 int32_t MQTT::runOnce()
 {
 #if HAS_NETWORKING
@@ -583,42 +567,18 @@ int32_t MQTT::runOnce()
     return 30000;
 }
 
-bool MQTT::isValidConfig(const meshtastic_ModuleConfig_MQTTConfig &config, MQTTClient *client)
+bool MQTT::isValidConfig(const meshtastic_ModuleConfig_MQTTConfig &config)
 {
-    const PubSubConfig parsed(config);
-
-    if (config.enabled && !config.proxy_to_client_enabled) {
-#if HAS_NETWORKING
-        std::unique_ptr<MQTTClient> clientConnection;
-        if (config.tls_enabled) {
-#if MQTT_SUPPORTS_TLS
-            MQTTClientTLS *tlsClient = new MQTTClientTLS;
-            clientConnection.reset(tlsClient);
-            tlsClient->setInsecure();
-#else
-            LOG_ERROR("Invalid MQTT config: tls_enabled is not supported on this node");
-            return false;
-#endif
-        } else {
-            clientConnection.reset(new MQTTClient);
-        }
-        std::unique_ptr<PubSubClient> pubSub(new PubSubClient);
-        if (isConnectedToNetwork()) {
-            return connectPubSub(parsed, *pubSub, (client != nullptr) ? *client : *clientConnection);
-        }
-#else
-        LOG_ERROR("Invalid MQTT config: proxy_to_client_enabled must be enabled on nodes that do not have a network");
-        return false;
-#endif
-    }
-
-    const bool defaultServer = isDefaultServer(parsed.serverAddr);
+    String host;
+    uint16_t port;
+    std::tie(host, port) = parseHostAndPort(config.address, mqttPort);
+    const bool defaultServer = isDefaultServer(host);
     if (defaultServer && config.tls_enabled) {
         LOG_ERROR("Invalid MQTT config: TLS was enabled, but the default server does not support TLS");
         return false;
     }
-    if (defaultServer && parsed.serverPort != PubSubConfig::defaultPort) {
-        LOG_ERROR("Invalid MQTT config: Unsupported port '%d' for the default MQTT server", parsed.serverPort);
+    if (defaultServer && port != mqttPort) {
+        LOG_ERROR("Invalid MQTT config: Unsupported port '%d' for the default MQTT server", port);
         return false;
     }
     return true;

src/mqtt/MQTT.h

@@ -10,10 +10,12 @@
 #endif
 #if HAS_WIFI
 #include <WiFiClient.h>
-#if __has_include(<WiFiClientSecure.h>)
+#if !defined(ARCH_PORTDUINO)
+#if defined(ESP_ARDUINO_VERSION_MAJOR) && ESP_ARDUINO_VERSION_MAJOR < 3
 #include <WiFiClientSecure.h>
 #endif
 #endif
+#endif
 #if HAS_ETHERNET
 #include <EthernetClient.h>
 #endif
@@ -59,8 +61,7 @@ class MQTT : private concurrency::OSThread
 
     bool isUsingDefaultServer() { return isConfiguredForDefaultServer; }
 
-    /// Validate the meshtastic_ModuleConfig_MQTTConfig.
-    static bool isValidConfig(const meshtastic_ModuleConfig_MQTTConfig &config) { return isValidConfig(config, nullptr); }
+    static bool isValidConfig(const meshtastic_ModuleConfig_MQTTConfig &config);
 
   protected:
     struct QueueEntry {
@@ -77,23 +78,22 @@ class MQTT : private concurrency::OSThread
 #ifndef PIO_UNIT_TESTING
   private:
 #endif
+    // supposedly the current version is busted:
+    // http://www.iotsharing.com/2017/08/how-to-use-esp32-mqtts-with-mqtts-mosquitto-broker-tls-ssl.html
 #if HAS_WIFI
     using MQTTClient = WiFiClient;
-#if __has_include(<WiFiClientSecure.h>)
-    using MQTTClientTLS = WiFiClientSecure;
-#define MQTT_SUPPORTS_TLS 1
+#if !defined(ARCH_PORTDUINO)
+#if (defined(ESP_ARDUINO_VERSION_MAJOR) && ESP_ARDUINO_VERSION_MAJOR < 3) || defined(RPI_PICO)
+    WiFiClientSecure wifiSecureClient;
 #endif
-#elif HAS_ETHERNET
+#endif
+#endif
+#if HAS_ETHERNET
     using MQTTClient = EthernetClient;
-#else
-    using MQTTClient = void;
 #endif
 
 #if HAS_NETWORKING
     std::unique_ptr<MQTTClient> mqttClient;
-#if MQTT_SUPPORTS_TLS
-    MQTTClientTLS mqttClientTLS;
-#endif
     PubSubClient pubSub;
     explicit MQTT(std::unique_ptr<MQTTClient> mqttClient);
 #endif
@@ -109,6 +109,10 @@ class MQTT : private concurrency::OSThread
     uint32_t map_position_precision = default_map_position_precision;
     uint32_t map_publish_interval_msecs = default_map_publish_interval_secs * 1000;
 
+    /** return true if we have a channel that wants uplink/downlink or map reporting is enabled
+     */
+    bool wantsLink() const;
+
     /** Attempt to connect to server if necessary
      */
     void reconnect();
@@ -120,8 +124,6 @@ class MQTT : private concurrency::OSThread
     /// Callback for direct mqtt subscription messages
     static void mqttCallback(char *topic, byte *payload, unsigned int length);
 
-    static bool isValidConfig(const meshtastic_ModuleConfig_MQTTConfig &config, MQTTClient *client);
-
     /// Called when a new publish arrives from the MQTT server
     void onReceive(char *topic, byte *payload, size_t length);
 

src/nimble/NimbleBluetooth.cpp

@@ -26,7 +26,7 @@ class BluetoothPhoneAPI : public PhoneAPI
     {
         PhoneAPI::onNowHasData(fromRadioNum);
 
-        LOG_DEBUG("BLE notify fromNum");
+        LOG_INFO("BLE notify fromNum");
 
         uint8_t val[4];
         put_le32(val, fromRadioNum);
@@ -51,7 +51,7 @@ class NimbleBluetoothToRadioCallback : public NimBLECharacteristicCallbacks
 {
     virtual void onWrite(NimBLECharacteristic *pCharacteristic)
     {
-        LOG_DEBUG("To Radio onwrite");
+        LOG_INFO("To Radio onwrite");
         auto val = pCharacteristic->getValue();
 
         if (memcmp(lastToRadio, val.data(), val.length()) != 0) {
@@ -298,4 +298,4 @@ void clearNVS()
     ESP.restart();
 #endif
 }
-#endif
+#endif

src/platform/portduino/SimRadio.cpp

@@ -139,6 +139,12 @@ bool SimRadio::cancelSending(NodeNum from, PacketId id)
     return result;
 }
 
+/** Attempt to find a packet in the TxQueue. Returns true if the packet was found. */
+bool SimRadio::findInTxQueue(NodeNum from, PacketId id)
+{
+    return txQueue.find(from, id);
+}
+
 void SimRadio::onNotify(uint32_t notification)
 {
     switch (notification) {

src/platform/portduino/SimRadio.h

@@ -33,6 +33,9 @@ class SimRadio : public RadioInterface, protected concurrency::NotifiedWorkerThr
     /** Attempt to cancel a previously sent packet.  Returns true if a packet was found we could cancel */
     virtual bool cancelSending(NodeNum from, PacketId id) override;
 
+    /** Attempt to find a packet in the TxQueue. Returns true if the packet was found. */
+    virtual bool findInTxQueue(NodeNum from, PacketId id) override;
+
     /**
      * Start waiting to receive a message
      *

src/serialization/MeshPacketSerializer.cpp

@@ -220,11 +220,7 @@ std::string MeshPacketSerializer::JsonSerialize(const meshtastic_MeshPacket *mp,
                 if (pb_decode_from_bytes(mp->decoded.payload.bytes, mp->decoded.payload.size, &meshtastic_RouteDiscovery_msg,
                                          &scratch)) {
                     decoded = &scratch;
-                    JSONArray route;      // Route this message took
-                    JSONArray routeBack;  // Route this message took back
-                    JSONArray snrTowards; // Snr for forward route
-                    JSONArray snrBack;    // Snr for reverse route
-
+                    JSONArray route; // Route this message took
                     // Lambda function for adding a long name to the route
                     auto addToRoute = [](JSONArray *route, NodeNum num) {
                         char long_name[40] = "Unknown";
@@ -240,24 +236,7 @@ std::string MeshPacketSerializer::JsonSerialize(const meshtastic_MeshPacket *mp,
                     }
                     addToRoute(&route, mp->from); // Ended at the original destination (source of response)
 
-                    addToRoute(&routeBack, mp->from); // Started at the original destination (source of response)
-                    for (uint8_t i = 0; i < decoded->route_back_count; i++) {
-                        addToRoute(&routeBack, decoded->route_back[i]);
-                    }
-                    addToRoute(&routeBack, mp->to); // Ended at the original transmitter (destination of response)
-
-                    for (uint8_t i = 0; i < decoded->snr_back_count; i++) {
-                        snrBack.push_back(new JSONValue((float)decoded->snr_back[i] / 4));
-                    }
-
-                    for (uint8_t i = 0; i < decoded->snr_towards_count; i++) {
-                        snrTowards.push_back(new JSONValue((float)decoded->snr_towards[i] / 4));
-                    }
-
                     msgPayload["route"] = new JSONValue(route);
-                    msgPayload["route_back"] = new JSONValue(routeBack);
-                    msgPayload["snr_back"] = new JSONValue(snrBack);
-                    msgPayload["snr_towards"] = new JSONValue(snrTowards);
                     jsonObj["payload"] = new JSONValue(msgPayload);
                 } else if (shouldLog) {
                     LOG_ERROR(errStr, msgType.c_str());

test/test_mqtt/MQTT.cpp

@@ -94,7 +94,6 @@ class MockPubSubServer : public WiFiClient
 
     int connect(IPAddress ip, uint16_t port) override
     {
-        port_ = port;
         if (refuseConnection_)
             return 0;
         connected_ = true;
@@ -102,8 +101,6 @@ class MockPubSubServer : public WiFiClient
     }
     int connect(const char *host, uint16_t port) override
     {
-        host_ = host;
-        port_ = port;
         if (refuseConnection_)
             return 0;
         connected_ = true;
@@ -200,8 +197,6 @@ class MockPubSubServer : public WiFiClient
     bool connected_ = false;
     bool refuseConnection_ = false;       // Simulate a failed connection.
     uint32_t ipAddress_ = 0x01010101;     // IP address of the MQTT server.
-    std::string host_;                    // Requested host.
-    uint16_t port_;                       // Requested port.
     std::list<std::string> buffer_;       // Buffer of messages for the pubSub client to receive.
     std::string command_;                 // Current command received from the pubSub client.
     std::set<std::string> subscriptions_; // Topics that the pubSub client has subscribed to.
@@ -247,7 +242,6 @@ class MQTTUnitTest : public MQTT
         mqttClient.release();
         delete pubsub;
     }
-    using MQTT::isValidConfig;
     using MQTT::reconnect;
     int queueSize() { return mqttQueue.numUsed(); }
     void reportToMap(std::optional<uint32_t> precision = std::nullopt)
@@ -807,25 +801,13 @@ void test_customMqttRoot(void)
 }
 
 // Empty configuration is valid.
-void test_configEmptyIsValid(void)
+void test_configurationEmptyIsValid(void)
 {
-    meshtastic_ModuleConfig_MQTTConfig config = {};
+    meshtastic_ModuleConfig_MQTTConfig config;
 
     TEST_ASSERT_TRUE(MQTT::isValidConfig(config));
 }
 
-// Empty 'enabled' configuration is valid.
-void test_configEnabledEmptyIsValid(void)
-{
-    meshtastic_ModuleConfig_MQTTConfig config = {.enabled = true};
-    MockPubSubServer client;
-
-    TEST_ASSERT_TRUE(MQTTUnitTest::isValidConfig(config, &client));
-    TEST_ASSERT_TRUE(client.connected_);
-    TEST_ASSERT_EQUAL_STRING(default_mqtt_address, client.host_.c_str());
-    TEST_ASSERT_EQUAL(1883, client.port_);
-}
-
 // Configuration with the default server is valid.
 void test_configWithDefaultServer(void)
 {
@@ -850,41 +832,6 @@ void test_configWithDefaultServerAndInvalidTLSEnabled(void)
     TEST_ASSERT_FALSE(MQTT::isValidConfig(config));
 }
 
-// isValidConfig connects to a custom host and port.
-void test_configCustomHostAndPort(void)
-{
-    meshtastic_ModuleConfig_MQTTConfig config = {.enabled = true, .address = "server:1234"};
-    MockPubSubServer client;
-
-    TEST_ASSERT_TRUE(MQTTUnitTest::isValidConfig(config, &client));
-    TEST_ASSERT_TRUE(client.connected_);
-    TEST_ASSERT_EQUAL_STRING("server", client.host_.c_str());
-    TEST_ASSERT_EQUAL(1234, client.port_);
-}
-
-// isValidConfig returns false if a connection cannot be established.
-void test_configWithConnectionFailure(void)
-{
-    meshtastic_ModuleConfig_MQTTConfig config = {.enabled = true, .address = "server"};
-    MockPubSubServer client;
-    client.refuseConnection_ = true;
-
-    TEST_ASSERT_FALSE(MQTTUnitTest::isValidConfig(config, &client));
-}
-
-// isValidConfig returns true when tls_enabled is supported, or false otherwise.
-void test_configWithTLSEnabled(void)
-{
-    meshtastic_ModuleConfig_MQTTConfig config = {.enabled = true, .address = "server", .tls_enabled = true};
-    MockPubSubServer client;
-
-#if MQTT_SUPPORTS_TLS
-    TEST_ASSERT_TRUE(MQTTUnitTest::isValidConfig(config, &client));
-#else
-    TEST_ASSERT_FALSE(MQTTUnitTest::isValidConfig(config, &client));
-#endif
-}
-
 void setup()
 {
     initializeTestEnvironment();
@@ -928,14 +875,10 @@ void setup()
     RUN_TEST(test_enabled);
     RUN_TEST(test_disabled);
     RUN_TEST(test_customMqttRoot);
-    RUN_TEST(test_configEmptyIsValid);
-    RUN_TEST(test_configEnabledEmptyIsValid);
+    RUN_TEST(test_configurationEmptyIsValid);
     RUN_TEST(test_configWithDefaultServer);
     RUN_TEST(test_configWithDefaultServerAndInvalidPort);
     RUN_TEST(test_configWithDefaultServerAndInvalidTLSEnabled);
-    RUN_TEST(test_configCustomHostAndPort);
-    RUN_TEST(test_configWithConnectionFailure);
-    RUN_TEST(test_configWithTLSEnabled);
     exit(UNITY_END());
 }
 #else

variants/Dongle_nRF52840-pca10059-v1/platformio.ini

@@ -10,5 +10,5 @@ build_flags = ${nrf52840_base.build_flags} -Ivariants/Dongle_nRF52840-pca10059-v
 build_src_filter = ${nrf52_base.build_src_filter} +<../variants/Dongle_nRF52840-pca10059-v1>
 lib_deps = 
   ${nrf52840_base.lib_deps}
-  zinggjm/GxEPD2@^1.6.2
-debug_tool = jlink
+  zinggjm/GxEPD2@^1.4.9
+debug_tool = jlink

variants/ME25LS01-4Y10TD_e-ink/platformio.ini

@@ -13,7 +13,7 @@ board_build.ldscript = src/platform/nrf52/nrf52840_s140_v7.ld
 build_src_filter = ${nrf52_base.build_src_filter} +<../variants/ME25LS01-4Y10TD_e-ink>
 lib_deps = 
   ${nrf52840_base.lib_deps}
-  zinggjm/GxEPD2@^1.6.2
+  zinggjm/GxEPD2@^1.5.8
 ; If not set we will default to uploading over serial (first it forces bootloader entry by talking 1200bps to cdcacm)
 upload_protocol = nrfutil
-upload_port = /dev/ttyACM1
+upload_port = /dev/ttyACM1

variants/MakePython_nRF52840_eink/platformio.ini

@@ -5,13 +5,13 @@ board = nordic_pca10059
 build_flags = ${nrf52840_base.build_flags} -Ivariants/MakePython_nRF52840_eink -D PRIVATE_HW
   -L "${platformio.libdeps_dir}/${this.__env__}/bsec2/src/cortex-m4/fpv4-sp-d16-hard"
   -D PIN_EINK_EN
-  -DEINK_DISPLAY_MODEL=GxEPD2_290_T5D
-  -DEINK_WIDTH=296
-  -DEINK_HEIGHT=128
 build_src_filter = ${nrf52_base.build_src_filter} +<../variants/MakePython_nRF52840_eink>
 lib_deps = 
   ${nrf52840_base.lib_deps}
   https://github.com/meshtastic/ESP32_Codec2.git#633326c78ac251c059ab3a8c430fcdf25b41672f
-  zinggjm/GxEPD2@^1.6.2
+  zinggjm/GxEPD2@^1.4.9
+  -DEINK_DISPLAY_MODEL=GxEPD2_290_T5D
+  -DEINK_WIDTH=296
+  -DEINK_HEIGHT=128
 debug_tool = jlink
-;upload_port = /dev/ttyACM4
+;upload_port = /dev/ttyACM4

variants/TWC_mesh_v4/platformio.ini

@@ -6,5 +6,5 @@ build_flags = ${nrf52840_base.build_flags} -I variants/TWC_mesh_v4 -D TWC_mesh_v
 build_src_filter = ${nrf52_base.build_src_filter} +<../variants/TWC_mesh_v4>
 lib_deps = 
   ${nrf52840_base.lib_deps}
-  zinggjm/GxEPD2@^1.6.2
-debug_tool = jlink
+  zinggjm/GxEPD2@^1.4.9
+debug_tool = jlink

variants/esp32-s3-pico/platformio.ini

@@ -21,5 +21,5 @@ build_flags = ${esp32s3_base.build_flags}
   -DEINK_HEIGHT=128
 
 lib_deps = ${esp32s3_base.lib_deps}
-  zinggjm/GxEPD2@^1.6.2
+  zinggjm/GxEPD2@^1.5.3
   adafruit/Adafruit NeoPixel @ ^1.12.0

variants/icarus/platformio.ini

@@ -6,7 +6,7 @@ board_check = true
 board_build.mcu = esp32s3
 upload_protocol = esptool
 upload_speed = 921600
-platform_packages = platformio/framework-arduinoespressif32@https://github.com/PowerFeather/powerfeather-meshtastic-arduino-lib/releases/download/2.0.16a/esp32-2.0.16.zip
+platform_packages = framework-arduinoespressif32@https://github.com/PowerFeather/powerfeather-meshtastic-arduino-lib/releases/download/2.0.16a/esp32-2.0.16.zip
 lib_deps =
   ${esp32s3_base.lib_deps}
 build_unflags =
@@ -16,4 +16,4 @@ build_flags =
   ${esp32s3_base.build_flags} -D PRIVATE_HW -I variants/icarus
   -DBOARD_HAS_PSRAM 
 
-  -DARDUINO_USB_MODE=0
+  -DARDUINO_USB_MODE=0

variants/m5stack_coreink/platformio.ini

@@ -17,11 +17,11 @@ build_flags =
   -DM5STACK
 lib_deps = 
   ${esp32_base.lib_deps}
-  zinggjm/GxEPD2@^1.6.2
+  zinggjm/GxEPD2@^1.5.3
   lewisxhe/PCF8563_Library@^1.0.1
 lib_ignore =
   m5stack-coreink
 monitor_filters = esp32_exception_decoder
 board_build.f_cpu = 240000000L
 upload_protocol = esptool
-upload_port = /dev/ttyACM0
+upload_port = /dev/ttyACM0

variants/my_esp32s3_diy_eink/platformio.ini

@@ -9,10 +9,10 @@ upload_protocol = esptool
 ;upload_port = /dev/ttyACM1
 upload_speed = 921600
 platform_packages =
-  platformio/tool-esptoolpy@^1.40801.0
+  tool-esptoolpy@^1.40500.0
 lib_deps =
   ${esp32_base.lib_deps}
-  zinggjm/GxEPD2@^1.6.2
+  zinggjm/GxEPD2@^1.5.1
   adafruit/Adafruit NeoPixel @ ^1.12.0
 build_unflags =
   ${esp32s3_base.build_unflags}

variants/my_esp32s3_diy_oled/platformio.ini

@@ -9,7 +9,7 @@ upload_protocol = esptool
 ;upload_port = /dev/ttyACM0
 upload_speed = 921600
 platform_packages =
-  platformio/tool-esptoolpy@^1.40801.0
+  tool-esptoolpy@^1.40500.0
 lib_deps =
   ${esp32_base.lib_deps}
   adafruit/Adafruit NeoPixel @ ^1.12.0

variants/rak11310/platformio.ini

@@ -18,4 +18,4 @@ lib_deps =
   ${networking_base.lib_deps}
   https://github.com/RAKWireless/RAK13800-W5100S.git#1.0.2
 debug_build_flags = ${rp2040_base.build_flags}, -g
-debug_tool = cmsis-dap ; for e.g. Picotool
+debug_tool = cmsis-dap ; for e.g. Picotool

variants/rak4631/variant.h

@@ -107,15 +107,11 @@ static const uint8_t AREF = PIN_AREF;
 /*
  * SPI Interfaces
  */
-#define SPI_INTERFACES_COUNT 2
+#define SPI_INTERFACES_COUNT 1
 
-#define PIN_SPI_MISO (45)
-#define PIN_SPI_MOSI (44)
-#define PIN_SPI_SCK (43)
-
-#define PIN_SPI1_MISO (29) // (0 + 29)
-#define PIN_SPI1_MOSI (30) // (0 + 30)
-#define PIN_SPI1_SCK (3)   // (0 + 3)
+#define PIN_SPI_MISO (29)
+#define PIN_SPI_MOSI (30)
+#define PIN_SPI_SCK (3)
 
 static const uint8_t SS = 42;
 static const uint8_t MOSI = PIN_SPI_MOSI;
@@ -130,8 +126,8 @@ static const uint8_t SCK = PIN_SPI_SCK;
 #define PIN_EINK_BUSY (0 + 4)
 #define PIN_EINK_DC (0 + 17)
 #define PIN_EINK_RES (-1)
-#define PIN_EINK_SCLK (0 + 3)
-#define PIN_EINK_MOSI (0 + 30) // also called SDI
+#define PIN_EINK_SCLK PIN_SPI_SCK
+#define PIN_EINK_MOSI PIN_SPI_MOSI // also called SDI
 
 // #define USE_EINK
 
@@ -259,7 +255,7 @@ SO GPIO 39/TXEN MAY NOT BE DEFINED FOR SUCCESSFUL OPERATION OF THE SX1262 - TG
 
 #define PIN_ETHERNET_RESET 21
 #define PIN_ETHERNET_SS PIN_EINK_CS
-#define ETH_SPI_PORT SPI1
+#define ETH_SPI_PORT SPI
 #define AQ_SET_PIN 10
 
 #ifdef __cplusplus

variants/rak4631_epaper/platformio.ini

@@ -13,10 +13,10 @@ build_flags = ${nrf52840_base.build_flags} -Ivariants/rak4631_epaper -D RAK_4631
 build_src_filter = ${nrf52_base.build_src_filter} +<../variants/rak4631_epaper>
 lib_deps = 
   ${nrf52840_base.lib_deps}
-  zinggjm/GxEPD2@^1.6.2
+  zinggjm/GxEPD2@^1.4.9
   melopero/Melopero RV3028@^1.1.0
   rakwireless/RAKwireless NCP5623 RGB LED library@^1.0.2
   beegee-tokyo/RAKwireless RAK12034@^1.0.0
 debug_tool = jlink
 ; If not set we will default to uploading over serial (first it forces bootloader entry by talking 1200bps to cdcacm)
-;upload_protocol = jlink
+;upload_protocol = jlink

variants/rak4631_epaper_onrxtx/platformio.ini

@@ -15,11 +15,11 @@ build_flags = ${nrf52840_base.build_flags} -Ivariants/rak4631_epaper -D RAK_4631
 build_src_filter = ${nrf52_base.build_src_filter} +<../variants/rak4631_epaper_onrxtx>
 lib_deps = 
   ${nrf52840_base.lib_deps}
-  zinggjm/GxEPD2@^1.6.2
+  zinggjm/GxEPD2@^1.5.1
   melopero/Melopero RV3028@^1.1.0
   rakwireless/RAKwireless NCP5623 RGB LED library@^1.0.2
   beegee-tokyo/RAKwireless RAK12034@^1.0.0
 debug_tool = jlink
 ; If not set we will default to uploading over serial (first it forces bootloader entry by talking 1200bps to cdcacm)
 ;upload_protocol = jlink
-;upload_port = /dev/ttyACM3
+;upload_port = /dev/ttyACM3

variants/rpipico2/platformio.ini

@@ -9,7 +9,7 @@ build_flags = ${rp2350_base.build_flags}
   -Ivariants/rpipico2
   -DDEBUG_RP2040_PORT=Serial
   -DHW_SPI1_DEVICE
-  -L "${platformio.libdeps_dir}/${this.__env__}/bsec2/src/cortex-m33"
+  -L "${platformio.libdeps_dir}/${this.__env__}/bsec2/src/cortex-m0plus"
 lib_deps =
   ${rp2350_base.lib_deps}
 debug_build_flags = ${rp2350_base.build_flags}, -g

variants/rpipico2w/platformio.ini

@@ -1,30 +0,0 @@
-[env:pico2w]
-extends = rp2350_base
-board = rpipico2w
-upload_protocol = jlink
-# debug settings for external openocd with RP2040 support (custom build)
-debug_tool = custom
-debug_init_cmds =
-  target extended-remote localhost:3333
-  $INIT_BREAK
-  monitor reset halt
-  $LOAD_CMDS
-  monitor init
-  monitor reset halt
-
-# add our variants files to the include and src paths
-build_flags = ${rp2350_base.build_flags} 
-  -DRPI_PICO2
-  -Ivariants/rpipico2w
-#  -DDEBUG_RP2040_PORT=Serial
-  -DHW_SPI1_DEVICE
-  -DARDUINO_RASPBERRY_PI_PICO_2W
-  -DARDUINO_ARCH_RP2040
-  -DHAS_WIFI=1
-  -L "${platformio.libdeps_dir}/${this.__env__}/bsec2/src/cortex-m33"
-  -fexceptions  # for exception handling in MQTT
-build_src_filter = ${rp2350_base.build_src_filter} +<mesh/wifi/>
-lib_deps =
-  ${rp2350_base.lib_deps}
-  ${networking_base.lib_deps}
-debug_build_flags = ${rp2350_base.build_flags}, -g

variants/rpipico2w/variant.h

@@ -1,52 +0,0 @@
-// #define RADIOLIB_CUSTOM_ARDUINO 1
-// #define RADIOLIB_TONE_UNSUPPORTED 1
-// #define RADIOLIB_SOFTWARE_SERIAL_UNSUPPORTED 1
-
-#define ARDUINO_ARCH_AVR
-
-#ifndef HAS_WIFI
-#define HAS_WIFI 1
-#endif
-
-// default I2C pins:
-// SDA = 4
-// SCL = 5
-
-// Recommended pins for SerialModule:
-// txd = 8
-// rxd = 9
-
-#define EXT_NOTIFY_OUT 22
-#define BUTTON_PIN 17
-
-#define BATTERY_PIN 26
-// ratio of voltage divider = 3.0 (R17=200k, R18=100k)
-#define ADC_MULTIPLIER 3.1 // 3.0 + a bit for being optimistic
-#define BATTERY_SENSE_RESOLUTION_BITS ADC_RESOLUTION
-
-#define USE_SX1262
-
-#undef LORA_SCK
-#undef LORA_MISO
-#undef LORA_MOSI
-#undef LORA_CS
-
-#define LORA_SCK 10
-#define LORA_MISO 12
-#define LORA_MOSI 11
-#define LORA_CS 3
-
-#define LORA_DIO0 RADIOLIB_NC
-#define LORA_RESET 15
-#define LORA_DIO1 20
-#define LORA_DIO2 2
-#define LORA_DIO3 RADIOLIB_NC
-
-#ifdef USE_SX1262
-#define SX126X_CS LORA_CS
-#define SX126X_DIO1 LORA_DIO1
-#define SX126X_BUSY LORA_DIO2
-#define SX126X_RESET LORA_RESET
-#define SX126X_DIO2_AS_RF_SWITCH
-#define SX126X_DIO3_TCXO_VOLTAGE 1.8
-#endif

variants/seeed_xiao_s3/variant.h

@@ -36,10 +36,6 @@ L76K GPS Module Information : https://www.seeedstudio.com/L76K-GNSS-Module-for-S
 #define BUTTON_PIN 21 // This is the Program Button
 #define BUTTON_NEED_PULLUP
 
-#define BATTERY_PIN -1
-#define ADC_CHANNEL ADC1_GPIO1_CHANNEL
-#define BATTERY_SENSE_RESOLUTION_BITS 12
-
 /*Warning:
     https://www.seeedstudio.com/L76K-GNSS-Module-for-Seeed-Studio-XIAO-p-5864.html
     L76K Expansion Board can not directly used, L76K Reset Pin needs to override or physically remove it,

variants/tracker-t1000-e/variant.h

@@ -111,7 +111,6 @@ extern "C" {
 #define GPS_TX_PIN PIN_SERIAL1_TX
 
 #define GPS_BAUDRATE 115200
-#define GPS_PROBETRIES 5
 
 #define PIN_GPS_EN (32 + 11) // P1.11
 #define GPS_EN_ACTIVE HIGH

variants/trackerd/platformio.ini

@@ -1,8 +1,13 @@
 [env:trackerd]
 extends = esp32_base
+;platform = https://github.com/platformio/platform-espressif32.git#feature/arduino-upstream
+platform = espressif32
 board = pico32
 board_build.f_flash = 80000000L
 
 build_flags = 
   ${esp32_base.build_flags} -D PRIVATE_HW -I variants/trackerd -D BSFILE=\"boards/dragino_lbt2.h\"
-;board_build.partitions = no_ota.csv
+;board_build.partitions = no_ota.csv
+;platform_packages =
+;   platformio/framework-arduinoespressif32@3
+;platformio/framework-arduinoespressif32 @ https://github.com/espressif/arduino-esp32.git#2.0.1-RC1

version.properties

@@ -1,4 +1,4 @@
 [VERSION]  
 major = 2
 minor = 5
-build = 23
+build = 22