Merge branch 'develop' into boot-status

* add noise floor

* Sliding window noise floor

* Add getCurrentRSSI() to SimRadio for noise floor support

* Remove sendLocalStatsToPhone call from runOnce

* Change noise floor to int32_t type

* Use int32_t for RSSI sample storage in noise floor

* Remove float cast from noise floor assignment

* Fix Copilot review issues: fix noise floor logic, types, and null pointer

- Use robust busyTx/busyRx checks instead of simple isReceiving check
- Initialize noiseFloorSamples to NOISE_FLOOR_MIN instead of 0
- Move noise_floor assignment inside null check to prevent potential crash
- Change getNoiseFloor() and getAverageNoiseFloor() to return int32_t
- Fix RSSI validation to check for positive values (rssi > 0)
- Fix format specifier from %.1f to %d for int32_t
- Update comments to accurately reflect the sampling logic

* Fix RSSI condition to include zero value

* Change noise floor initialization to zero

* Disable noise floor for LR11x0 chips: getRSSI(bool) unsupported

* Remove updateNoiseFloor call from onNotify to avoid radio queue overflow

Per PR review feedback, calling updateNoiseFloor() in onNotify() for every
ISR event (ISR_TX, ISR_RX, TRANSMIT_DELAY_COMPLETED) can cause the LoRa
radio queue to get full. The noise floor sampling still happens in
startReceive() and after transmitting.

* fix lr11x0 current rssi

* Address noise floor review comments

* Address Copilot SimRadio noise floor comments

* Fix RadioLibInterface formatting

---------

Co-authored-by: Ben Meadors <benmmeadors@gmail.com>
Co-authored-by: Jonathan Bennett <jbennett@incomsystems.biz>

.github/workflows/main_matrix.yml

@@ -333,6 +333,7 @@ jobs:
           prerelease: true
           name: Meshtastic Firmware ${{ needs.version.outputs.long }} Alpha
           tag_name: v${{ needs.version.outputs.long }}
+          target_commitish: ${{ github.sha }}
           body: ${{ steps.release_notes.outputs.notes }}
 
       - name: Download source deb

src/DebugConfiguration.h

@@ -152,7 +152,9 @@ extern "C" void logLegacy(const char *level, const char *fmt, ...);
 // Default Bluetooth PIN
 #define defaultBLEPin 123456
 
-#if HAS_ETHERNET && defined(USE_CH390D)
+#if HAS_ETHERNET && defined(USE_ARDUINO_ETHERNET)
+#include <Ethernet.h> // arduino-libraries/Ethernet — supports W5500 auto-detect
+#elif HAS_ETHERNET && defined(USE_CH390D)
 #include <ESP32_CH390.h>
 #elif HAS_ETHERNET && !defined(USE_WS5500)
 #include <RAK13800_W5100S.h>

src/DisplayFormatters.cpp

@@ -1,4 +1,5 @@
 #include "DisplayFormatters.h"
+#include "MeshRadio.h"
 
 const char *DisplayFormatters::getModemPresetDisplayName(meshtastic_Config_LoRaConfig_ModemPreset preset, bool useShortName,
                                                          bool usePreset)
@@ -11,33 +12,45 @@ const char *DisplayFormatters::getModemPresetDisplayName(meshtastic_Config_LoRaC
     }
 
     switch (preset) {
-    case meshtastic_Config_LoRaConfig_ModemPreset_SHORT_TURBO:
+    case PRESET(SHORT_TURBO):
         return useShortName ? "ShortT" : "ShortTurbo";
         break;
-    case meshtastic_Config_LoRaConfig_ModemPreset_SHORT_SLOW:
+    case PRESET(SHORT_SLOW):
         return useShortName ? "ShortS" : "ShortSlow";
         break;
-    case meshtastic_Config_LoRaConfig_ModemPreset_SHORT_FAST:
+    case PRESET(SHORT_FAST):
         return useShortName ? "ShortF" : "ShortFast";
         break;
-    case meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_SLOW:
+    case PRESET(MEDIUM_SLOW):
         return useShortName ? "MedS" : "MediumSlow";
         break;
-    case meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST:
+    case PRESET(MEDIUM_FAST):
         return useShortName ? "MedF" : "MediumFast";
         break;
-    case meshtastic_Config_LoRaConfig_ModemPreset_LONG_SLOW:
+    case PRESET(LONG_SLOW):
         return useShortName ? "LongS" : "LongSlow";
         break;
-    case meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST:
+    case PRESET(LONG_FAST):
         return useShortName ? "LongF" : "LongFast";
         break;
-    case meshtastic_Config_LoRaConfig_ModemPreset_LONG_TURBO:
+    case PRESET(LONG_TURBO):
         return useShortName ? "LongT" : "LongTurbo";
         break;
-    case meshtastic_Config_LoRaConfig_ModemPreset_LONG_MODERATE:
+    case PRESET(LONG_MODERATE):
         return useShortName ? "LongM" : "LongMod";
         break;
+    case PRESET(LITE_FAST):
+        return useShortName ? "LiteF" : "LiteFast";
+        break;
+    case PRESET(LITE_SLOW):
+        return useShortName ? "LiteS" : "LiteSlow";
+        break;
+    case PRESET(NARROW_FAST):
+        return useShortName ? "NarF" : "NarrowFast";
+        break;
+    case PRESET(NARROW_SLOW):
+        return useShortName ? "NarS" : "NarrowSlow";
+        break;
     default:
         return useShortName ? "Custom" : "Invalid";
         break;

src/airtime.cpp

@@ -133,11 +133,12 @@ bool AirTime::isTxAllowedChannelUtil(bool polite)
 
 bool AirTime::isTxAllowedAirUtil()
 {
-    if (!config.lora.override_duty_cycle && myRegion->dutyCycle < 100) {
-        if (utilizationTXPercent() < myRegion->dutyCycle * polite_duty_cycle_percent / 100) {
+    float effectiveDutyCycle = getEffectiveDutyCycle();
+    if (!config.lora.override_duty_cycle && effectiveDutyCycle < 100) {
+        if (utilizationTXPercent() < effectiveDutyCycle * polite_duty_cycle_percent / 100) {
             return true;
         } else {
-            LOG_WARN("TX air util. >%f%%. Skip send", myRegion->dutyCycle * polite_duty_cycle_percent / 100);
+            LOG_WARN("TX air util. >%f%%. Skip send", effectiveDutyCycle * polite_duty_cycle_percent / 100);
             return false;
         }
     }

src/detect/ScanI2CTwoWire.cpp

@@ -179,8 +179,22 @@ String readSEN5xProductName(TwoWire *i2cBus, uint8_t address)
 #endif
 
 #if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR
+static uint8_t crcSHT2X(const uint8_t *data, uint8_t len)
+{
+    uint8_t crc = 0;
+    for (uint8_t i = 0; i < len; i++) {
+        crc ^= data[i];
+        for (uint8_t bit = 0; bit < 8; bit++) {
+            crc = (crc & 0x80) ? (crc << 1) ^ 0x31 : crc << 1;
+        }
+    }
+    return crc;
+}
+
 bool detectSHT21SerialNumber(TwoWire *i2cBus, uint8_t address)
 {
+    uint8_t serialA[8] = {0};
+    uint8_t serialB[6] = {0};
 
     i2cBus->beginTransmission(address);
     i2cBus->write(0xFA);
@@ -189,12 +203,13 @@ bool detectSHT21SerialNumber(TwoWire *i2cBus, uint8_t address)
     if (i2cBus->endTransmission() != 0)
         return false;
 
-    if (i2cBus->requestFrom(address, (uint8_t)8) != 8)
+    if (i2cBus->requestFrom(address, (uint8_t)sizeof(serialA)) != sizeof(serialA))
         return false;
 
-    // Just flush the data
-    while (i2cBus->available() < 8) {
-        i2cBus->read();
+    for (uint8_t i = 0; i < sizeof(serialA); i++) {
+        if (!i2cBus->available())
+            return false;
+        serialA[i] = i2cBus->read();
     }
 
     i2cBus->beginTransmission(address);
@@ -204,16 +219,18 @@ bool detectSHT21SerialNumber(TwoWire *i2cBus, uint8_t address)
     if (i2cBus->endTransmission() != 0)
         return false;
 
-    if (i2cBus->requestFrom(address, (uint8_t)6) != 6)
+    if (i2cBus->requestFrom(address, (uint8_t)sizeof(serialB)) != sizeof(serialB))
         return false;
 
-    // Just flush the data
-    while (i2cBus->available() < 6) {
-        i2cBus->read();
+    for (uint8_t i = 0; i < sizeof(serialB); i++) {
+        if (!i2cBus->available())
+            return false;
+        serialB[i] = i2cBus->read();
     }
 
-    // Assume we detect the SHT21 if something came back from the request
-    return true;
+    return crcSHT2X(&serialA[0], 1) == serialA[1] && crcSHT2X(&serialA[2], 1) == serialA[3] &&
+           crcSHT2X(&serialA[4], 1) == serialA[5] && crcSHT2X(&serialA[6], 1) == serialA[7] &&
+           crcSHT2X(&serialB[0], 2) == serialB[2] && crcSHT2X(&serialB[3], 2) == serialB[5];
 }
 #endif
 

src/gps/GPS.cpp

@@ -505,12 +505,15 @@ bool GPS::setup()
         int msglen = 0;
         if (tx_gpio && gnssModel == GNSS_MODEL_UNKNOWN) {
             if (probeTries < GPS_PROBETRIES) {
+                bootString = "Probing GPS...";
                 gnssModel = probe(serialSpeeds[speedSelect]);
                 if (gnssModel == GNSS_MODEL_UNKNOWN) {
                     if (currentStep == 0 && ++speedSelect == array_count(serialSpeeds)) {
                         speedSelect = 0;
                         ++probeTries;
                     }
+                } else {
+                    currentStep = 0;
                 }
             }
             // Rare Serial Speeds
@@ -522,6 +525,8 @@ bool GPS::setup()
                         LOG_WARN("Give up on GPS probe and set to %d", GPS_BAUDRATE);
                         return true;
                     }
+                } else {
+                    currentStep = 0;
                 }
             }
 #endif
@@ -538,86 +543,133 @@ bool GPS::setup()
              * t-beam-s3-core uses the same L76K GNSS module as t-echo.
              * Unlike t-echo, L76K uses 9600 baud rate for communication by default.
              * */
-
-            // Initialize the L76K Chip, use GPS + GLONASS + BEIDOU
-            _serial_gps->write("$PCAS04,7*1E\r\n");
-            delay(250);
-            // only ask for RMC and GGA
-            _serial_gps->write("$PCAS03,1,0,0,0,1,0,0,0,0,0,,,0,0*02\r\n");
-            delay(250);
-            // Switch to Vehicle Mode, since SoftRF enables Aviation < 2g
-            _serial_gps->write("$PCAS11,3*1E\r\n");
-            delay(250);
+            if (currentStep == 0) {
+                // Initialize the L76K Chip, use GPS + GLONASS + BEIDOU
+                _serial_gps->write("$PCAS04,7*1E\r\n");
+                currentStep++;
+                currentDelay = 250;
+                return false;
+            } else if (currentStep == 1) {
+                // only ask for RMC and GGA
+                _serial_gps->write("$PCAS03,1,0,0,0,1,0,0,0,0,0,,,0,0*02\r\n");
+                currentStep++;
+                currentDelay = 250;
+                return false;
+            } else if (currentStep == 2) {
+                // Switch to Vehicle Mode, since SoftRF enables Aviation < 2g
+                _serial_gps->write("$PCAS11,3*1E\r\n");
+                currentDelay = 250;
+            }
         } else if (gnssModel == GNSS_MODEL_MTK_L76B) {
             // Waveshare Pico-GPS hat uses the L76B with 9600 baud
             // Initialize the L76B Chip, use GPS + GLONASS
             // See note in L76_Series_GNSS_Protocol_Specification, chapter 3.29
-            _serial_gps->write("$PMTK353,1,1,0,0,0*2B\r\n");
-            // Above command will reset the GPS and takes longer before it will accept new commands
-            delay(1000);
-            // only ask for RMC and GGA (GNRMC and GNGGA)
-            // See note in L76_Series_GNSS_Protocol_Specification, chapter 2.1
-            _serial_gps->write("$PMTK314,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0*28\r\n");
-            delay(250);
-            // Enable SBAS
-            _serial_gps->write("$PMTK301,2*2E\r\n");
-            delay(250);
-            // Enable PPS for 2D/3D fix only
-            _serial_gps->write("$PMTK285,3,100*3F\r\n");
-            delay(250);
-            // Switch to Fitness Mode, for running and walking purpose with low speed (<5 m/s)
-            _serial_gps->write("$PMTK886,1*29\r\n");
-            delay(250);
+            if (currentStep == 0) {
+                _serial_gps->write("$PMTK353,1,1,0,0,0*2B\r\n");
+                currentStep++;
+                currentDelay = 1000;
+                return false;
+            } else if (currentStep == 1) {
+                // Above command will reset the GPS and takes longer before it will accept new commands
+                // only ask for RMC and GGA (GNRMC and GNGGA)
+                // See note in L76_Series_GNSS_Protocol_Specification, chapter 2.1
+                _serial_gps->write("$PMTK314,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0*28\r\n");
+                currentStep++;
+                currentDelay = 250;
+                return false;
+            } else if (currentStep == 2) {
+                // Enable SBAS
+                _serial_gps->write("$PMTK301,2*2E\r\n");
+                currentStep++;
+                currentDelay = 250;
+                return false;
+            } else if (currentStep == 3) {
+                // Enable PPS for 2D/3D fix only
+                _serial_gps->write("$PMTK285,3,100*3F\r\n");
+                currentStep++;
+                currentDelay = 250;
+                return false;
+            } else if (currentStep == 4) {
+                // Switch to Fitness Mode, for running and walking purpose with low speed (<5 m/s)
+                _serial_gps->write("$PMTK886,1*29\r\n");
+                currentDelay = 250;
+            }
         } else if (gnssModel == GNSS_MODEL_MTK_PA1010D) {
             // PA1010D is used in the Pimoroni GPS board.
-
-            // Enable all constellations.
-            _serial_gps->write("$PMTK353,1,1,1,1,1*2A\r\n");
-            // Above command will reset the GPS and takes longer before it will accept new commands
-            delay(1000);
-            // Only ask for RMC and GGA (GNRMC and GNGGA)
-            _serial_gps->write("$PMTK314,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0*28\r\n");
-            delay(250);
-            // Enable SBAS / WAAS
-            _serial_gps->write("$PMTK301,2*2E\r\n");
-            delay(250);
+            if (currentStep == 0) {
+                // Enable all constellations.
+                _serial_gps->write("$PMTK353,1,1,1,1,1*2A\r\n");
+                currentStep++;
+                currentDelay = 1000;
+                return false;
+            } else if (currentStep == 1) {
+                // Above command will reset the GPS and takes longer before it will accept new commands
+                // Only ask for RMC and GGA (GNRMC and GNGGA)
+                _serial_gps->write("$PMTK314,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0*28\r\n");
+                currentStep++;
+                currentDelay = 250;
+                return false;
+            } else if (currentStep == 2) {
+                // Enable SBAS / WAAS
+                _serial_gps->write("$PMTK301,2*2E\r\n");
+                currentDelay = 250;
+            }
         } else if (gnssModel == GNSS_MODEL_MTK_PA1616S) {
             // PA1616S is used in some GPS breakout boards from Adafruit
             // PA1616S does not have GLONASS capability. PA1616D does, but is not implemented here.
-            _serial_gps->write("$PMTK353,1,0,0,0,0*2A\r\n");
-            // Above command will reset the GPS and takes longer before it will accept new commands
-            delay(1000);
-            // Only ask for RMC and GGA (GNRMC and GNGGA)
-            _serial_gps->write("$PMTK314,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0*28\r\n");
-            delay(250);
-            // Enable SBAS / WAAS
-            _serial_gps->write("$PMTK301,2*2E\r\n");
-            delay(250);
+            if (currentStep == 0) {
+                _serial_gps->write("$PMTK353,1,0,0,0,0*2A\r\n");
+                currentStep++;
+                currentDelay = 1000;
+                return false;
+            } else if (currentStep == 1) {
+                // Above command will reset the GPS and takes longer before it will accept new commands
+                // Only ask for RMC and GGA (GNRMC and GNGGA)
+                _serial_gps->write("$PMTK314,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0*28\r\n");
+                currentStep++;
+                currentDelay = 250;
+                return false;
+            } else if (currentStep == 2) {
+                // Enable SBAS / WAAS
+                _serial_gps->write("$PMTK301,2*2E\r\n");
+                currentDelay = 250;
+            }
         } else if (gnssModel == GNSS_MODEL_ATGM336H) {
-            // Set the initial configuration of the device - these _should_ work for most AT6558 devices
-            msglen = makeCASPacket(0x06, 0x07, sizeof(_message_CAS_CFG_NAVX_CONF), _message_CAS_CFG_NAVX_CONF);
-            _serial_gps->write(UBXscratch, msglen);
-            if (getACKCas(0x06, 0x07, 250) != GNSS_RESPONSE_OK) {
-                LOG_WARN("ATGM336H: Could not set Config");
-            }
-
-            // Set the update frequency to 1Hz
-            msglen = makeCASPacket(0x06, 0x04, sizeof(_message_CAS_CFG_RATE_1HZ), _message_CAS_CFG_RATE_1HZ);
-            _serial_gps->write(UBXscratch, msglen);
-            if (getACKCas(0x06, 0x04, 250) != GNSS_RESPONSE_OK) {
-                LOG_WARN("ATGM336H: Could not set Update Frequency");
-            }
-
-            // Set the NEMA output messages
-            // Ask for only RMC and GGA
-            uint8_t fields[] = {CAS_NEMA_RMC, CAS_NEMA_GGA};
-            for (unsigned int i = 0; i < sizeof(fields); i++) {
+            if (currentStep == 0) {
+                // Set the initial configuration of the device - these _should_ work for most AT6558 devices
+                msglen = makeCASPacket(0x06, 0x07, sizeof(_message_CAS_CFG_NAVX_CONF), _message_CAS_CFG_NAVX_CONF);
+                _serial_gps->write(UBXscratch, msglen);
+                if (getACKCas(0x06, 0x07, 250) != GNSS_RESPONSE_OK) {
+                    LOG_WARN("ATGM336H: Could not set Config");
+                }
+                currentStep++;
+                return false;
+            } else if (currentStep == 1) {
+                // Set the update frequency to 1Hz
+                msglen = makeCASPacket(0x06, 0x04, sizeof(_message_CAS_CFG_RATE_1HZ), _message_CAS_CFG_RATE_1HZ);
+                _serial_gps->write(UBXscratch, msglen);
+                if (getACKCas(0x06, 0x04, 250) != GNSS_RESPONSE_OK) {
+                    LOG_WARN("ATGM336H: Could not set Update Frequency");
+                }
+                currentStep++;
+                return false;
+            } else if (currentStep == 2) {
+                // Set the NEMA output messages - Ask for only RMC and GGA
                 // Construct a CAS-CFG-MSG packet
-                uint8_t cas_cfg_msg_packet[] = {0x4e, fields[i], 0x01, 0x00};
+                uint8_t cas_cfg_msg_packet[] = {0x4e, CAS_NEMA_RMC, 0x01, 0x00};
                 msglen = makeCASPacket(0x06, 0x01, sizeof(cas_cfg_msg_packet), cas_cfg_msg_packet);
                 _serial_gps->write(UBXscratch, msglen);
                 if (getACKCas(0x06, 0x01, 250) != GNSS_RESPONSE_OK) {
-                    LOG_WARN("ATGM336H: Could not enable NMEA MSG: %d", fields[i]);
+                    LOG_WARN("ATGM336H: Could not enable NMEA MSG: %d", CAS_NEMA_RMC);
+                }
+                currentStep++;
+                return false;
+            } else if (currentStep == 3) {
+                uint8_t cas_cfg_msg_packet[] = {0x4e, CAS_NEMA_GGA, 0x01, 0x00};
+                msglen = makeCASPacket(0x06, 0x01, sizeof(cas_cfg_msg_packet), cas_cfg_msg_packet);
+                _serial_gps->write(UBXscratch, msglen);
+                if (getACKCas(0x06, 0x01, 250) != GNSS_RESPONSE_OK) {
+                    LOG_WARN("ATGM336H: Could not enable NMEA MSG: %d", CAS_NEMA_GGA);
                 }
             }
         } else if (gnssModel == GNSS_MODEL_UC6580) {
@@ -625,195 +677,363 @@ bool GPS::setup()
             // use GPS L1 & L5 + BDS B1I & B2a + GLONASS L1 + GALILEO E1 & E5a + SBAS + QZSS
             // This will reset the receiver, so wait a bit afterwards
             // The paranoid will wait for the OK*04 confirmation response after each command.
-            _serial_gps->write("$CFGSYS,h35155\r\n");
-            delay(750);
-            // Must be done after the CFGSYS command
-            // Turn off GSV messages, we don't really care about which and where the sats are, maybe someday.
-            _serial_gps->write("$CFGMSG,0,3,0\r\n");
-            delay(250);
-            // Turn off GSA messages, TinyGPS++ doesn't use this message.
-            _serial_gps->write("$CFGMSG,0,2,0\r\n");
-            delay(250);
-            // Turn off NOTICE __TXT messages, these may provide Unicore some info but we don't care.
-            _serial_gps->write("$CFGMSG,6,0,0\r\n");
-            delay(250);
-            _serial_gps->write("$CFGMSG,6,1,0\r\n");
-            delay(250);
-        } else if (IS_ONE_OF(gnssModel, GNSS_MODEL_AG3335, GNSS_MODEL_AG3352)) {
-
-            if (config.lora.region == meshtastic_Config_LoRaConfig_RegionCode_IN ||
-                config.lora.region == meshtastic_Config_LoRaConfig_RegionCode_NP_865) {
-                _serial_gps->write("$PAIR066,1,0,1,0,0,1*3B\r\n"); // Enable GPS+GALILEO+NAVIC
-                // GPS GLONASS GALILEO BDS QZSS NAVIC
-                //  1    0       1      0   0    1
-            } else {
-                _serial_gps->write("$PAIR066,1,1,1,1,0,0*3A\r\n"); // Enable GPS+GLONASS+GALILEO+BDS
-                // GPS GLONASS GALILEO BDS QZSS NAVIC
-                //  1    1       1      1   0    0
+            if (currentStep == 0) {
+                _serial_gps->write("$CFGSYS,h35155\r\n");
+                currentStep++;
+                currentDelay = 750;
+                return false;
+            } else if (currentStep == 1) {
+                // Must be done after the CFGSYS command
+                // Turn off GSV messages, we don't really care about which and where the sats are, maybe someday.
+                _serial_gps->write("$CFGMSG,0,3,0\r\n");
+                currentStep++;
+                currentDelay = 250;
+                return false;
+            } else if (currentStep == 2) {
+                // Turn off GSA messages, TinyGPS++ doesn't use this message.
+                _serial_gps->write("$CFGMSG,0,2,0\r\n");
+                currentStep++;
+                currentDelay = 250;
+                return false;
+            } else if (currentStep == 3) {
+                // Turn off NOTICE __TXT messages, these may provide Unicore some info but we don't care.
+                _serial_gps->write("$CFGMSG,6,0,0\r\n");
+                currentStep++;
+                currentDelay = 250;
+                return false;
+            } else if (currentStep == 4) {
+                _serial_gps->write("$CFGMSG,6,1,0\r\n");
+                currentDelay = 250;
+            }
+        } else if (IS_ONE_OF(gnssModel, GNSS_MODEL_AG3335, GNSS_MODEL_AG3352)) {
+            if (currentStep == 0) {
+                if (config.lora.region == meshtastic_Config_LoRaConfig_RegionCode_IN ||
+                    config.lora.region == meshtastic_Config_LoRaConfig_RegionCode_NP_865) {
+                    _serial_gps->write("$PAIR066,1,0,1,0,0,1*3B\r\n"); // Enable GPS+GALILEO+NAVIC
+                    // GPS GLONASS GALILEO BDS QZSS NAVIC
+                    //  1    0       1      0   0    1
+                } else {
+                    _serial_gps->write("$PAIR066,1,1,1,1,0,0*3A\r\n"); // Enable GPS+GLONASS+GALILEO+BDS
+                    // GPS GLONASS GALILEO BDS QZSS NAVIC
+                    //  1    1       1      1   0    0
+                }
+                currentStep++;
+                return false;
+            } else if (currentStep == 1) {
+                // Configure NMEA (sentences will output once per fix)
+                _serial_gps->write("$PAIR062,0,1*3F\r\n"); // GGA ON
+                currentStep++;
+                return false;
+            } else if (currentStep == 2) {
+                _serial_gps->write("$PAIR062,1,0*3F\r\n"); // GLL OFF
+                currentStep++;
+                return false;
+            } else if (currentStep == 3) {
+                _serial_gps->write("$PAIR062,2,0*3C\r\n"); // GSA OFF
+                currentStep++;
+                return false;
+            } else if (currentStep == 4) {
+                _serial_gps->write("$PAIR062,3,0*3D\r\n"); // GSV OFF
+                currentStep++;
+                return false;
+            } else if (currentStep == 5) {
+                _serial_gps->write("$PAIR062,4,1*3B\r\n"); // RMC ON
+                currentStep++;
+                return false;
+            } else if (currentStep == 6) {
+                _serial_gps->write("$PAIR062,5,0*3B\r\n"); // VTG OFF
+                currentStep++;
+                return false;
+            } else if (currentStep == 7) {
+                _serial_gps->write("$PAIR062,6,0*38\r\n"); // ZDA ON
+                currentStep++;
+                currentDelay = 250;
+                return false;
+            } else if (currentStep == 8) {
+                _serial_gps->write("$PAIR513*3D\r\n"); // save configuration
             }
-            // Configure NMEA (sentences will output once per fix)
-            _serial_gps->write("$PAIR062,0,1*3F\r\n"); // GGA ON
-            _serial_gps->write("$PAIR062,1,0*3F\r\n"); // GLL OFF
-            _serial_gps->write("$PAIR062,2,0*3C\r\n"); // GSA OFF
-            _serial_gps->write("$PAIR062,3,0*3D\r\n"); // GSV OFF
-            _serial_gps->write("$PAIR062,4,1*3B\r\n"); // RMC ON
-            _serial_gps->write("$PAIR062,5,0*3B\r\n"); // VTG OFF
-            _serial_gps->write("$PAIR062,6,0*38\r\n"); // ZDA ON
-
-            delay(250);
-            _serial_gps->write("$PAIR513*3D\r\n"); // save configuration
         } else if (gnssModel == GNSS_MODEL_UBLOX6) {
-            clearBuffer();
-            SEND_UBX_PACKET(0x06, 0x02, _message_DISABLE_TXT_INFO, "disable text info messages", 500);
-            SEND_UBX_PACKET(0x06, 0x39, _message_JAM_6_7, "enable interference resistance", 500);
-            SEND_UBX_PACKET(0x06, 0x23, _message_NAVX5, "configure NAVX5 settings", 500);
-
-            // Turn off unwanted NMEA messages, set update rate
-            SEND_UBX_PACKET(0x06, 0x08, _message_1HZ, "set GPS update rate", 500);
-            SEND_UBX_PACKET(0x06, 0x01, _message_GLL, "disable NMEA GLL", 500);
-            SEND_UBX_PACKET(0x06, 0x01, _message_GSA, "enable NMEA GSA", 500);
-            SEND_UBX_PACKET(0x06, 0x01, _message_GSV, "disable NMEA GSV", 500);
-            SEND_UBX_PACKET(0x06, 0x01, _message_VTG, "disable NMEA VTG", 500);
-            SEND_UBX_PACKET(0x06, 0x01, _message_RMC, "enable NMEA RMC", 500);
-            SEND_UBX_PACKET(0x06, 0x01, _message_GGA, "enable NMEA GGA", 500);
-
-            clearBuffer();
-            SEND_UBX_PACKET(0x06, 0x11, _message_CFG_RXM_ECO, "enable powersave ECO mode for Neo-6", 500);
-            SEND_UBX_PACKET(0x06, 0x3B, _message_CFG_PM2, "enable powersave details for GPS", 500);
-            SEND_UBX_PACKET(0x06, 0x01, _message_AID, "disable UBX-AID", 500);
-
-            msglen = makeUBXPacket(0x06, 0x09, sizeof(_message_SAVE), _message_SAVE);
-            _serial_gps->write(UBXscratch, msglen);
-            if (getACK(0x06, 0x09, 2000) != GNSS_RESPONSE_OK) {
-                LOG_WARN("Unable to save GNSS module config");
-            } else {
-                LOG_INFO("GNSS module config saved!");
+            if (currentStep == 0) {
+                clearBuffer();
+                SEND_UBX_PACKET(0x06, 0x02, _message_DISABLE_TXT_INFO, "disable text info messages", 500);
+                currentStep++;
+                return false;
+            } else if (currentStep == 1) {
+                SEND_UBX_PACKET(0x06, 0x39, _message_JAM_6_7, "enable interference resistance", 500);
+                currentStep++;
+                return false;
+            } else if (currentStep == 2) {
+                SEND_UBX_PACKET(0x06, 0x23, _message_NAVX5, "configure NAVX5 settings", 500);
+                currentStep++;
+                return false;
+            } else if (currentStep == 3) {
+                // Turn off unwanted NMEA messages, set update rate
+                SEND_UBX_PACKET(0x06, 0x08, _message_1HZ, "set GPS update rate", 500);
+                currentStep++;
+                return false;
+            } else if (currentStep == 4) {
+                SEND_UBX_PACKET(0x06, 0x01, _message_GLL, "disable NMEA GLL", 500);
+                currentStep++;
+                return false;
+            } else if (currentStep == 5) {
+                SEND_UBX_PACKET(0x06, 0x01, _message_GSA, "enable NMEA GSA", 500);
+                currentStep++;
+                return false;
+            } else if (currentStep == 6) {
+                SEND_UBX_PACKET(0x06, 0x01, _message_GSV, "disable NMEA GSV", 500);
+                currentStep++;
+                return false;
+            } else if (currentStep == 7) {
+                SEND_UBX_PACKET(0x06, 0x01, _message_VTG, "disable NMEA VTG", 500);
+                currentStep++;
+                return false;
+            } else if (currentStep == 8) {
+                SEND_UBX_PACKET(0x06, 0x01, _message_RMC, "enable NMEA RMC", 500);
+                currentStep++;
+                return false;
+            } else if (currentStep == 9) {
+                SEND_UBX_PACKET(0x06, 0x01, _message_GGA, "enable NMEA GGA", 500);
+                currentStep++;
+                return false;
+            } else if (currentStep == 10) {
+                clearBuffer();
+                SEND_UBX_PACKET(0x06, 0x11, _message_CFG_RXM_ECO, "enable powersave ECO mode for Neo-6", 500);
+                currentStep++;
+                return false;
+            } else if (currentStep == 11) {
+                SEND_UBX_PACKET(0x06, 0x3B, _message_CFG_PM2, "enable powersave details for GPS", 500);
+                currentStep++;
+                return false;
+            } else if (currentStep == 12) {
+                SEND_UBX_PACKET(0x06, 0x01, _message_AID, "disable UBX-AID", 500);
+                currentStep++;
+                return false;
+            } else if (currentStep == 13) {
+                msglen = makeUBXPacket(0x06, 0x09, sizeof(_message_SAVE), _message_SAVE);
+                _serial_gps->write(UBXscratch, msglen);
+                if (getACK(0x06, 0x09, 2000) != GNSS_RESPONSE_OK) {
+                    LOG_WARN("Unable to save GNSS module config");
+                } else {
+                    LOG_INFO("GNSS module config saved!");
+                }
             }
         } else if (IS_ONE_OF(gnssModel, GNSS_MODEL_UBLOX7, GNSS_MODEL_UBLOX8, GNSS_MODEL_UBLOX9)) {
-            if (gnssModel == GNSS_MODEL_UBLOX7) {
-                LOG_DEBUG("Set GPS+SBAS");
-                msglen = makeUBXPacket(0x06, 0x3e, sizeof(_message_GNSS_7), _message_GNSS_7);
-                _serial_gps->write(UBXscratch, msglen);
-            } else { // 8,9
-                msglen = makeUBXPacket(0x06, 0x3e, sizeof(_message_GNSS_8), _message_GNSS_8);
-                _serial_gps->write(UBXscratch, msglen);
-            }
-
-            if (getACK(0x06, 0x3e, 800) == GNSS_RESPONSE_NAK) {
-                // It's not critical if the module doesn't acknowledge this configuration.
-                LOG_DEBUG("reconfigure GNSS - defaults maintained. Is this module GPS-only?");
-            } else {
+            if (currentStep == 0) {
                 if (gnssModel == GNSS_MODEL_UBLOX7) {
-                    LOG_INFO("GPS+SBAS configured");
+                    LOG_DEBUG("Set GPS+SBAS");
+                    msglen = makeUBXPacket(0x06, 0x3e, sizeof(_message_GNSS_7), _message_GNSS_7);
+                    _serial_gps->write(UBXscratch, msglen);
                 } else { // 8,9
-                    LOG_INFO("GPS+SBAS+GLONASS+Galileo configured");
+                    msglen = makeUBXPacket(0x06, 0x3e, sizeof(_message_GNSS_8), _message_GNSS_8);
+                    _serial_gps->write(UBXscratch, msglen);
                 }
-                // Documentation say, we need wait at least 0.5s after reconfiguration of GNSS module, before sending next
-                // commands for the M8 it tends to be more... 1 sec should be enough ;>)
-                delay(1000);
-            }
-
-            // Disable Text Info messages //6,7,8,9
-            clearBuffer();
-            SEND_UBX_PACKET(0x06, 0x02, _message_DISABLE_TXT_INFO, "disable text info messages", 500);
-
-            if (gnssModel == GNSS_MODEL_UBLOX8) { // 8
+                if (getACK(0x06, 0x3e, 800) == GNSS_RESPONSE_NAK) {
+                    // It's not critical if the module doesn't acknowledge this configuration.
+                    LOG_DEBUG("reconfigure GNSS - defaults maintained. Is this module GPS-only?");
+                } else {
+                    if (gnssModel == GNSS_MODEL_UBLOX7) {
+                        LOG_INFO("GPS+SBAS configured");
+                    } else { // 8,9
+                        LOG_INFO("GPS+SBAS+GLONASS+Galileo configured");
+                    }
+                    // Documentation say, we need wait at least 0.5s after reconfiguration of GNSS module, before sending next
+                    // commands for the M8 it tends to be more... 1 sec should be enough ;>)
+                    delay(1000);
+                }
+                currentStep++;
+                return false;
+            } else if (currentStep == 1) {
+                // Disable Text Info messages //6,7,8,9
                 clearBuffer();
-                SEND_UBX_PACKET(0x06, 0x39, _message_JAM_8, "enable interference resistance", 500);
-
-                clearBuffer();
-                SEND_UBX_PACKET(0x06, 0x23, _message_NAVX5_8, "configure NAVX5_8 settings", 500);
-            } else { // 6,7,9
-                SEND_UBX_PACKET(0x06, 0x39, _message_JAM_6_7, "enable interference resistance", 500);
-                SEND_UBX_PACKET(0x06, 0x23, _message_NAVX5, "configure NAVX5 settings", 500);
-            }
-            // Turn off unwanted NMEA messages, set update rate
-            SEND_UBX_PACKET(0x06, 0x08, _message_1HZ, "set GPS update rate", 500);
-            SEND_UBX_PACKET(0x06, 0x01, _message_GLL, "disable NMEA GLL", 500);
-            SEND_UBX_PACKET(0x06, 0x01, _message_GSA, "enable NMEA GSA", 500);
-            SEND_UBX_PACKET(0x06, 0x01, _message_GSV, "disable NMEA GSV", 500);
-            SEND_UBX_PACKET(0x06, 0x01, _message_VTG, "disable NMEA VTG", 500);
-            SEND_UBX_PACKET(0x06, 0x01, _message_RMC, "enable NMEA RMC", 500);
-            SEND_UBX_PACKET(0x06, 0x01, _message_GGA, "enable NMEA GGA", 500);
-
-            if (ublox_info.protocol_version >= 18) {
-                clearBuffer();
-                SEND_UBX_PACKET(0x06, 0x86, _message_PMS, "enable powersave for GPS", 500);
+                SEND_UBX_PACKET(0x06, 0x02, _message_DISABLE_TXT_INFO, "disable text info messages", 500);
+                currentStep++;
+                return false;
+            } else if (currentStep == 2) {
+                if (gnssModel == GNSS_MODEL_UBLOX8) { // 8
+                    clearBuffer();
+                    SEND_UBX_PACKET(0x06, 0x39, _message_JAM_8, "enable interference resistance", 500);
+                } else { // 7,9
+                    SEND_UBX_PACKET(0x06, 0x39, _message_JAM_6_7, "enable interference resistance", 500);
+                }
+                currentStep++;
+                return false;
+            } else if (currentStep == 3) {
+                if (gnssModel == GNSS_MODEL_UBLOX8) { // 8
+                    clearBuffer();
+                    SEND_UBX_PACKET(0x06, 0x23, _message_NAVX5_8, "configure NAVX5_8 settings", 500);
+                } else { // 7,9
+                    SEND_UBX_PACKET(0x06, 0x23, _message_NAVX5, "configure NAVX5 settings", 500);
+                }
+                currentStep++;
+                return false;
+            } else if (currentStep == 4) {
+                // Turn off unwanted NMEA messages, set update rate
+                SEND_UBX_PACKET(0x06, 0x08, _message_1HZ, "set GPS update rate", 500);
+                currentStep++;
+                return false;
+            } else if (currentStep == 5) {
+                SEND_UBX_PACKET(0x06, 0x01, _message_GLL, "disable NMEA GLL", 500);
+                currentStep++;
+                return false;
+            } else if (currentStep == 6) {
+                SEND_UBX_PACKET(0x06, 0x01, _message_GSA, "enable NMEA GSA", 500);
+                currentStep++;
+                return false;
+            } else if (currentStep == 7) {
+                SEND_UBX_PACKET(0x06, 0x01, _message_GSV, "disable NMEA GSV", 500);
+                currentStep++;
+                return false;
+            } else if (currentStep == 8) {
+                SEND_UBX_PACKET(0x06, 0x01, _message_VTG, "disable NMEA VTG", 500);
+                currentStep++;
+                return false;
+            } else if (currentStep == 9) {
+                SEND_UBX_PACKET(0x06, 0x01, _message_RMC, "enable NMEA RMC", 500);
+                currentStep++;
+                return false;
+            } else if (currentStep == 10) {
+                SEND_UBX_PACKET(0x06, 0x01, _message_GGA, "enable NMEA GGA", 500);
+                currentStep++;
+                return false;
+            } else if (currentStep == 11) {
+                if (ublox_info.protocol_version >= 18) {
+                    clearBuffer();
+                    SEND_UBX_PACKET(0x06, 0x86, _message_PMS, "enable powersave for GPS", 500);
+                } else {
+                    SEND_UBX_PACKET(0x06, 0x11, _message_CFG_RXM_PSM, "enable powersave mode for GPS", 500);
+                }
+                currentStep++;
+                return false;
+            } else if (currentStep == 12) {
                 SEND_UBX_PACKET(0x06, 0x3B, _message_CFG_PM2, "enable powersave details for GPS", 500);
-
+                currentStep++;
+                return false;
+            } else if (currentStep == 13) {
                 // For M8 we want to enable NMEA version 4.10 so we can see the additional sats.
-                if (gnssModel == GNSS_MODEL_UBLOX8) {
+                if (ublox_info.protocol_version >= 18 && gnssModel == GNSS_MODEL_UBLOX8) {
                     clearBuffer();
                     SEND_UBX_PACKET(0x06, 0x17, _message_NMEA, "enable NMEA 4.10", 500);
+                    currentStep++;
+                    return false;
+                }
+                msglen = makeUBXPacket(0x06, 0x09, sizeof(_message_SAVE), _message_SAVE);
+                _serial_gps->write(UBXscratch, msglen);
+                if (getACK(0x06, 0x09, 2000) != GNSS_RESPONSE_OK) {
+                    LOG_WARN("Unable to save GNSS module config");
+                } else {
+                    LOG_INFO("GNSS module configuration saved!");
+                }
+            } else if (currentStep == 14) {
+                msglen = makeUBXPacket(0x06, 0x09, sizeof(_message_SAVE), _message_SAVE);
+                _serial_gps->write(UBXscratch, msglen);
+                if (getACK(0x06, 0x09, 2000) != GNSS_RESPONSE_OK) {
+                    LOG_WARN("Unable to save GNSS module config");
+                } else {
+                    LOG_INFO("GNSS module configuration saved!");
                 }
-            } else {
-                SEND_UBX_PACKET(0x06, 0x11, _message_CFG_RXM_PSM, "enable powersave mode for GPS", 500);
-                SEND_UBX_PACKET(0x06, 0x3B, _message_CFG_PM2, "enable powersave details for GPS", 500);
-            }
-
-            msglen = makeUBXPacket(0x06, 0x09, sizeof(_message_SAVE), _message_SAVE);
-            _serial_gps->write(UBXscratch, msglen);
-            if (getACK(0x06, 0x09, 2000) != GNSS_RESPONSE_OK) {
-                LOG_WARN("Unable to save GNSS module config");
-            } else {
-                LOG_INFO("GNSS module configuration saved!");
             }
         } else if (gnssModel == GNSS_MODEL_UBLOX10) {
-            delay(1000);
-            clearBuffer();
-            SEND_UBX_PACKET(0x06, 0x8A, _message_VALSET_DISABLE_NMEA_RAM, "disable NMEA messages in M10 RAM", 300);
-            delay(750);
-            clearBuffer();
-            SEND_UBX_PACKET(0x06, 0x8A, _message_VALSET_DISABLE_NMEA_BBR, "disable NMEA messages in M10 BBR", 300);
-            delay(750);
-            clearBuffer();
-            SEND_UBX_PACKET(0x06, 0x8A, _message_VALSET_DISABLE_TXT_INFO_RAM, "disable Info messages for M10 GPS RAM", 300);
-            delay(750);
-            // Next disable Info txt messages in BBR layer
-            clearBuffer();
-            SEND_UBX_PACKET(0x06, 0x8A, _message_VALSET_DISABLE_TXT_INFO_BBR, "disable Info messages for M10 GPS BBR", 300);
-            delay(750);
-            // Do M10 configuration for Power Management.
-            SEND_UBX_PACKET(0x06, 0x8A, _message_VALSET_PM_RAM, "enable powersave for M10 GPS RAM", 300);
-            delay(750);
-            SEND_UBX_PACKET(0x06, 0x8A, _message_VALSET_PM_BBR, "enable powersave for M10 GPS BBR", 300);
-            delay(750);
-            SEND_UBX_PACKET(0x06, 0x8A, _message_VALSET_ITFM_RAM, "enable jam detection M10 GPS RAM", 300);
-            delay(750);
-            SEND_UBX_PACKET(0x06, 0x8A, _message_VALSET_ITFM_BBR, "enable jam detection M10 GPS BBR", 300);
-            delay(750);
-            // Here is where the init commands should go to do further M10 initialization.
-            SEND_UBX_PACKET(0x06, 0x8A, _message_VALSET_DISABLE_SBAS_RAM, "disable SBAS M10 GPS RAM", 300);
-            delay(750); // will cause a receiver restart so wait a bit
-            SEND_UBX_PACKET(0x06, 0x8A, _message_VALSET_DISABLE_SBAS_BBR, "disable SBAS M10 GPS BBR", 300);
-            delay(750); // will cause a receiver restart so wait a bit
-
-            // Done with initialization, Now enable wanted NMEA messages in BBR layer so they will survive a periodic
-            // sleep.
-            SEND_UBX_PACKET(0x06, 0x8A, _message_VALSET_ENABLE_NMEA_BBR, "enable messages for M10 GPS BBR", 300);
-            delay(750);
-            // Next enable wanted NMEA messages in RAM layer
-            SEND_UBX_PACKET(0x06, 0x8A, _message_VALSET_ENABLE_NMEA_RAM, "enable messages for M10 GPS RAM", 500);
-            delay(750);
-
-            // As the M10 has no flash, the best we can do to preserve the config is to set it in RAM and BBR.
-            // BBR will survive a restart, and power off for a while, but modules with small backup
-            // batteries or super caps will not retain the config for a long power off time.
-            msglen = makeUBXPacket(0x06, 0x09, sizeof(_message_SAVE_10), _message_SAVE_10);
-            _serial_gps->write(UBXscratch, msglen);
-            if (getACK(0x06, 0x09, 2000) != GNSS_RESPONSE_OK) {
-                LOG_WARN("Unable to save GNSS module config");
-            } else {
-                LOG_INFO("GNSS module configuration saved!");
+            if (currentStep == 0) {
+                LOG_INFO("Configuring M10 GPS step 0");
+                delay(1000);
+                clearBuffer();
+                SEND_UBX_PACKET(0x06, 0x8A, _message_VALSET_DISABLE_NMEA_RAM, "disable NMEA messages in M10 RAM", 300);
+                currentStep++;
+                currentDelay = 750;
+                return false;
+            } else if (currentStep == 1) {
+                LOG_INFO("Configuring M10 GPS step 1");
+                clearBuffer();
+                SEND_UBX_PACKET(0x06, 0x8A, _message_VALSET_DISABLE_NMEA_BBR, "disable NMEA messages in M10 BBR", 300);
+                currentStep++;
+                currentDelay = 750;
+                return false;
+            } else if (currentStep == 2) {
+                clearBuffer();
+                SEND_UBX_PACKET(0x06, 0x8A, _message_VALSET_DISABLE_TXT_INFO_RAM, "disable Info messages for M10 GPS RAM", 300);
+                currentStep++;
+                currentDelay = 750;
+                return false;
+            } else if (currentStep == 3) {
+                // Next disable Info txt messages in BBR layer
+                clearBuffer();
+                SEND_UBX_PACKET(0x06, 0x8A, _message_VALSET_DISABLE_TXT_INFO_BBR, "disable Info messages for M10 GPS BBR", 300);
+                currentStep++;
+                currentDelay = 750;
+                return false;
+            } else if (currentStep == 4) {
+                // Do M10 configuration for Power Management.
+                SEND_UBX_PACKET(0x06, 0x8A, _message_VALSET_PM_RAM, "enable powersave for M10 GPS RAM", 300);
+                currentStep++;
+                currentDelay = 750;
+                return false;
+            } else if (currentStep == 5) {
+                // Next enable powersave in BBR layer
+                SEND_UBX_PACKET(0x06, 0x8A, _message_VALSET_PM_BBR, "enable powersave for M10 GPS BBR", 300);
+                currentStep++;
+                currentDelay = 750;
+                return false;
+            } else if (currentStep == 6) {
+                SEND_UBX_PACKET(0x06, 0x8A, _message_VALSET_ITFM_RAM, "enable jam detection M10 GPS RAM", 300);
+                currentStep++;
+                currentDelay = 750;
+                return false;
+            } else if (currentStep == 7) {
+                SEND_UBX_PACKET(0x06, 0x8A, _message_VALSET_ITFM_BBR, "enable jam detection M10 GPS BBR", 300);
+                currentStep++;
+                currentDelay = 750;
+                return false;
+            } else if (currentStep == 8) {
+                // Here is where the init commands should go to do further M10 initialization.
+                SEND_UBX_PACKET(0x06, 0x8A, _message_VALSET_DISABLE_SBAS_RAM, "disable SBAS M10 GPS RAM", 300);
+                currentStep++;
+                currentDelay = 750;
+                return false;
+            } else if (currentStep == 9) {
+                // will cause a receiver restart so wait a bit
+                SEND_UBX_PACKET(0x06, 0x8A, _message_VALSET_DISABLE_SBAS_BBR, "disable SBAS M10 GPS BBR", 300);
+                currentStep++;
+                currentDelay = 750;
+                return false;
+            } else if (currentStep == 10) {
+                // Done with initialization, Now enable wanted NMEA messages in BBR layer so they will survive a periodic
+                // sleep.
+                SEND_UBX_PACKET(0x06, 0x8A, _message_VALSET_ENABLE_NMEA_BBR, "enable messages for M10 GPS BBR", 300);
+                currentStep++;
+                currentDelay = 750;
+                return false;
+            } else if (currentStep == 11) {
+                // Next enable wanted NMEA messages in RAM layer
+                SEND_UBX_PACKET(0x06, 0x8A, _message_VALSET_ENABLE_NMEA_RAM, "enable messages for M10 GPS RAM", 500);
+                currentStep++;
+                currentDelay = 750;
+                return false;
+            } else if (currentStep == 12) {
+                // As the M10 has no flash, the best we can do to preserve the config is to set it in RAM and BBR.
+                // BBR will survive a restart, and power off for a while, but modules with small backup
+                // batteries or super caps will not retain the config for a long power off time.
+                msglen = makeUBXPacket(0x06, 0x09, sizeof(_message_SAVE_10), _message_SAVE_10);
+                _serial_gps->write(UBXscratch, msglen);
+                if (getACK(0x06, 0x09, 2000) != GNSS_RESPONSE_OK) {
+                    LOG_WARN("Unable to save GNSS module config");
+                } else {
+                    LOG_INFO("GNSS module configuration saved!");
+                }
+                didSerialInit = true;
             }
         } else if (gnssModel == GNSS_MODEL_CM121) {
             // only ask for RMC and GGA
-            // enable GGA
-            _serial_gps->write("$CFGMSG,0,0,1,1*1B\r\n");
-            delay(250);
-            // enable RMC
-            _serial_gps->write("$CFGMSG,0,4,1,1*1F\r\n");
-            delay(250);
+            if (currentStep == 0) {
+                // enable GGA
+                _serial_gps->write("$CFGMSG,0,0,1,1*1B\r\n");
+                currentStep++;
+                currentDelay = 250;
+                return false;
+            } else if (currentStep == 1) {
+                // enable RMC
+                _serial_gps->write("$CFGMSG,0,4,1,1*1F\r\n");
+                currentDelay = 250;
+            }
         }
         didSerialInit = true;
     }

src/gps/GPS.h

@@ -128,6 +128,8 @@ class GPS : private concurrency::OSThread
     // Let the GPS hardware save power between updates
     void down();
 
+    bool initFinished() const { return GPSInitFinished; };
+
   private:
     GPS() : concurrency::OSThread("GPS") {}
 

src/graphics/Screen.cpp

@@ -891,7 +891,7 @@ int32_t Screen::runOnce()
     // Show boot screen for first logo_timeout seconds, then switch to normal operation.
     // serialSinceMsec adjusts for additional serial wait time during nRF52 bootup
     static bool showingBootScreen = true;
-    if (showingBootScreen && (millis() > (logo_timeout + serialSinceMsec))) {
+    if (showingBootScreen && (!gps || gps->initFinished()) && (millis() > (logo_timeout + serialSinceMsec))) {
         LOG_INFO("Done with boot screen");
         stopBootScreen();
         showingBootScreen = false;

src/graphics/VirtualKeyboard.cpp

@@ -142,8 +142,9 @@ void VirtualKeyboard::draw(OLEDDisplay *display, int16_t offsetX, int16_t offset
         if (keyboardStartY < 0)
             keyboardStartY = 0;
     } else {
-        // Default (non-wide, non-64px) behavior: use key height heuristic and place at bottom
-        cellH = KEY_HEIGHT;
+        // Default (non-wide, non-64px) e.g. SH1107 128x128:
+        // cellH = FONT_HEIGHT_SMALL - 2 so rows are tighter while still hosting the font
+        cellH = std::max((int)KEY_HEIGHT, FONT_HEIGHT_SMALL - 2);
         int keyboardHeight = KEYBOARD_ROWS * cellH;
         keyboardStartY = screenH - keyboardHeight;
         if (keyboardStartY < 0)
@@ -446,11 +447,8 @@ void VirtualKeyboard::drawKey(OLEDDisplay *display, const VirtualKey &key, bool
         if (textX < x)
             textX = x; // guard
     } else {
-        if (display->getHeight() <= 64 && (key.character >= '0' && key.character <= '9')) {
-            textX = x + (width - textWidth + 1) / 2;
-        } else {
-            textX = x + (width - textWidth) / 2;
-        }
+        // Use ceil rounding for all screens (consistent with 128x64 behavior for numbers)
+        textX = x + (width - textWidth + 1) / 2;
     }
     int contentTop = y;
     int contentH = height;
@@ -746,4 +744,4 @@ bool VirtualKeyboard::isTimedOut() const
 }
 
 } // namespace graphics
-#endif
+#endif

src/graphics/draw/MenuHandler.cpp

@@ -2,6 +2,7 @@
 #if HAS_SCREEN
 #include "ClockRenderer.h"
 #include "Default.h"
+#include "DisplayFormatters.h"
 #include "GPS.h"
 #include "MenuHandler.h"
 #include "MeshRadio.h"
@@ -180,6 +181,8 @@ void menuHandler::LoraRegionPicker(uint32_t duration)
         {"US", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_US},
         {"EU_433", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_EU_433},
         {"EU_868", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_EU_868},
+        {"EU_866", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_EU_866},
+        {"EU_868_NARROW", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_EU_N_868},
         {"CN", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_CN},
         {"JP", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_JP},
         {"ANZ", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_ANZ},
@@ -203,6 +206,7 @@ void menuHandler::LoraRegionPicker(uint32_t duration)
         {"KZ_863", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_KZ_863},
         {"NP_865", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_NP_865},
         {"BR_902", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_BR_902},
+
     };
 
     constexpr size_t regionCount = sizeof(regionOptions) / sizeof(regionOptions[0]);
@@ -244,7 +248,7 @@ void menuHandler::LoraRegionPicker(uint32_t duration)
 #endif
             config.lora.tx_enabled = true;
             initRegion();
-            if (myRegion->dutyCycle < 100) {
+            if (getEffectiveDutyCycle() < 100) {
                 config.lora.ignore_mqtt = true; // Ignore MQTT by default if region has a duty cycle limit
             }
 
@@ -378,42 +382,64 @@ void menuHandler::FrequencySlotPicker()
     screen->showOverlayBanner(bannerOptions);
 }
 
+// Maximum presets any region can have + 1 for Back
+static constexpr int MAX_PRESET_OPTIONS = 16;
+
+static BannerOverlayOptions buildRegionPresetBanner()
+{
+    // Static storage reused each call — safe because the banner is shown immediately after.
+    static const char *optionsArray[MAX_PRESET_OPTIONS];
+    static int optionsEnumArray[MAX_PRESET_OPTIONS];
+    static char presetLabelBuf[MAX_PRESET_OPTIONS][12]; // scratch space for name copies
+    int count = 0;
+
+    optionsArray[count] = "Back";
+    optionsEnumArray[count++] = -1;
+
+    if (myRegion && myRegion->profile) {
+        const meshtastic_Config_LoRaConfig_ModemPreset *presets = myRegion->getAvailablePresets();
+        size_t numPresets = myRegion->getNumPresets();
+        for (size_t i = 0; i < numPresets && count < MAX_PRESET_OPTIONS; ++i) {
+            const char *name = DisplayFormatters::getModemPresetDisplayName(presets[i], false, true);
+            strncpy(presetLabelBuf[count], name, sizeof(presetLabelBuf[count]) - 1);
+            presetLabelBuf[count][sizeof(presetLabelBuf[count]) - 1] = '\0';
+            optionsArray[count] = presetLabelBuf[count];
+            optionsEnumArray[count++] = static_cast<int>(presets[i]);
+        }
+    }
+
+    int initialSelection = 0;
+    for (int i = 1; i < count; ++i) {
+        if (optionsEnumArray[i] == static_cast<int>(config.lora.modem_preset)) {
+            initialSelection = i;
+            break;
+        }
+    }
+
+    BannerOverlayOptions bannerOptions;
+    bannerOptions.message = "Radio Preset";
+    bannerOptions.optionsArrayPtr = optionsArray;
+    bannerOptions.optionsEnumPtr = optionsEnumArray;
+    bannerOptions.optionsCount = static_cast<uint8_t>(count);
+    bannerOptions.InitialSelected = initialSelection;
+    bannerOptions.bannerCallback = [](int selected) -> void {
+        if (selected == -1) {
+            menuHandler::menuQueue = menuHandler::LoraMenu;
+            screen->runNow();
+            return;
+        }
+        config.lora.use_preset = true;
+        config.lora.modem_preset = static_cast<meshtastic_Config_LoRaConfig_ModemPreset>(selected);
+        config.lora.channel_num = 0;        // Reset to default channel for the preset
+        config.lora.override_frequency = 0; // Clear any custom frequency
+        service->reloadConfig(SEGMENT_CONFIG);
+    };
+    return bannerOptions;
+}
+
 void menuHandler::radioPresetPicker()
 {
-    static const RadioPresetOption presetOptions[] = {
-        {"Back", OptionsAction::Back},
-        {"LongTurbo", OptionsAction::Select, meshtastic_Config_LoRaConfig_ModemPreset_LONG_TURBO},
-        {"LongModerate", OptionsAction::Select, meshtastic_Config_LoRaConfig_ModemPreset_LONG_MODERATE},
-        {"LongFast", OptionsAction::Select, meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST},
-        {"MediumSlow", OptionsAction::Select, meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_SLOW},
-        {"MediumFast", OptionsAction::Select, meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST},
-        {"ShortSlow", OptionsAction::Select, meshtastic_Config_LoRaConfig_ModemPreset_SHORT_SLOW},
-        {"ShortFast", OptionsAction::Select, meshtastic_Config_LoRaConfig_ModemPreset_SHORT_FAST},
-        {"ShortTurbo", OptionsAction::Select, meshtastic_Config_LoRaConfig_ModemPreset_SHORT_TURBO},
-    };
-
-    constexpr size_t presetCount = sizeof(presetOptions) / sizeof(presetOptions[0]);
-    static std::array<const char *, presetCount> presetLabels{};
-
-    auto bannerOptions =
-        createStaticBannerOptions("Radio Preset", presetOptions, presetLabels, [](const RadioPresetOption &option, int) -> void {
-            if (option.action == OptionsAction::Back) {
-                menuHandler::menuQueue = menuHandler::LoraMenu;
-                screen->runNow();
-                return;
-            }
-
-            if (!option.hasValue) {
-                return;
-            }
-
-            config.lora.modem_preset = option.value;
-            config.lora.channel_num = 0;        // Reset to default channel for the preset
-            config.lora.override_frequency = 0; // Clear any custom frequency
-            service->reloadConfig(SEGMENT_CONFIG);
-        });
-
-    screen->showOverlayBanner(bannerOptions);
+    screen->showOverlayBanner(buildRegionPresetBanner());
 }
 
 void menuHandler::twelveHourPicker()

src/graphics/draw/UIRenderer.cpp

@@ -2,6 +2,7 @@
 #if HAS_SCREEN
 #include "CompassRenderer.h"
 #include "GPSStatus.h"
+#include "MeshRadio.h"
 #include "MeshService.h"
 #include "NodeDB.h"
 #include "NodeListRenderer.h"
@@ -816,16 +817,16 @@ void UIRenderer::drawFavoriteNode(OLEDDisplay *display, OLEDDisplayUiState *stat
     // Helper to get SNR limit based on modem preset
     auto getSnrLimit = [](meshtastic_Config_LoRaConfig_ModemPreset preset) -> float {
         switch (preset) {
-        case meshtastic_Config_LoRaConfig_ModemPreset_LONG_SLOW:
-        case meshtastic_Config_LoRaConfig_ModemPreset_LONG_MODERATE:
-        case meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST:
+        case PRESET(LONG_SLOW):
+        case PRESET(LONG_MODERATE):
+        case PRESET(LONG_FAST):
             return -6.0f;
-        case meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_SLOW:
-        case meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST:
+        case PRESET(MEDIUM_SLOW):
+        case PRESET(MEDIUM_FAST):
             return -5.5f;
-        case meshtastic_Config_LoRaConfig_ModemPreset_SHORT_SLOW:
-        case meshtastic_Config_LoRaConfig_ModemPreset_SHORT_FAST:
-        case meshtastic_Config_LoRaConfig_ModemPreset_SHORT_TURBO:
+        case PRESET(SHORT_SLOW):
+        case PRESET(SHORT_FAST):
+        case PRESET(SHORT_TURBO):
             return -4.5f;
         default:
             return -6.0f;
@@ -1504,6 +1505,24 @@ void UIRenderer::drawIconScreen(const char *upperMsg, OLEDDisplay *display, OLED
         display->drawString(x + getStringCenteredX(title) + 1, y + SCREEN_HEIGHT - FONT_HEIGHT_MEDIUM - 5, title);
     }
     display->setFont(FONT_SMALL);
+    if (bootString != nullptr) {
+        static uint8_t bootStringStep = 0;
+        char stringCharacter = '.';
+        uint32_t stringWidth = getStringCenteredX(bootString);
+        if (bootStringStep == 0) {
+            stringCharacter = '.';
+            bootStringStep++;
+        } else if (bootStringStep == 1) {
+            stringCharacter = 'o';
+            bootStringStep++;
+        } else if (bootStringStep == 2) {
+            stringCharacter = 'O';
+            bootStringStep = 0;
+        }
+        char tmpBootString[40];
+        snprintf(tmpBootString, sizeof(tmpBootString), "%s %c", bootString, stringCharacter);
+        display->drawString(x + stringWidth, y + SCREEN_HEIGHT - 2 * FONT_HEIGHT_MEDIUM, tmpBootString);
+    }
     // Draw region in upper left
     if (upperMsg) {
         display->drawString(x + 5, y + 5, upperMsg);

src/graphics/niche/InkHUD/Applets/System/Menu/MenuAction.h

@@ -64,6 +64,8 @@ enum MenuAction {
     SET_REGION_KZ_863,
     SET_REGION_NP_865,
     SET_REGION_BR_902,
+    SET_REGION_EU_866,
+    SET_REGION_NARROW_868,
     // Device Roles
     SET_ROLE_CLIENT,
     SET_ROLE_CLIENT_MUTE,
@@ -78,6 +80,11 @@ enum MenuAction {
     SET_PRESET_SHORT_SLOW,
     SET_PRESET_SHORT_FAST,
     SET_PRESET_SHORT_TURBO,
+    SET_PRESET_LITE_SLOW,
+    SET_PRESET_LITE_FAST,
+    SET_PRESET_NARROW_SLOW,
+    SET_PRESET_NARROW_FAST,
+    SET_PRESET_FROM_REGION, // Dynamic: preset chosen from region-available list
     // Timezones
     SET_TZ_US_HAWAII,
     SET_TZ_US_ALASKA,

src/graphics/niche/InkHUD/Applets/System/Menu/MenuApplet.cpp

@@ -4,6 +4,7 @@
 
 #include "DisplayFormatters.h"
 #include "GPS.h"
+#include "MeshRadio.h"
 #include "MeshService.h"
 #include "RTC.h"
 #include "Router.h"
@@ -257,6 +258,11 @@ int32_t InkHUD::MenuApplet::runOnce()
     return OSThread::disable();
 }
 
+// Storage for the dynamically-built region preset list — populated in showPage(NODE_CONFIG_PRESET)
+static constexpr uint8_t MAX_REGION_PRESETS = 16;
+static meshtastic_Config_LoRaConfig_ModemPreset regionPresets[MAX_REGION_PRESETS];
+static uint8_t regionPresetCount = 0;
+
 static void applyLoRaRegion(meshtastic_Config_LoRaConfig_RegionCode region)
 {
     if (config.lora.region == region)
@@ -276,7 +282,7 @@ static void applyLoRaRegion(meshtastic_Config_LoRaConfig_RegionCode region)
 
     initRegion();
 
-    if (myRegion && myRegion->dutyCycle < 100) {
+    if (myRegion && getEffectiveDutyCycle() < 100) {
         config.lora.ignore_mqtt = true;
     }
 
@@ -770,6 +776,14 @@ void InkHUD::MenuApplet::execute(MenuItem item)
         applyLoRaRegion(meshtastic_Config_LoRaConfig_RegionCode_BR_902);
         break;
 
+    case SET_REGION_EU_866:
+        applyLoRaRegion(meshtastic_Config_LoRaConfig_RegionCode_EU_866);
+        break;
+
+    case SET_REGION_NARROW_868:
+        applyLoRaRegion(meshtastic_Config_LoRaConfig_RegionCode_EU_N_868);
+        break;
+
     // Roles
     case SET_ROLE_CLIENT:
         applyDeviceRole(meshtastic_Config_DeviceConfig_Role_CLIENT);
@@ -789,37 +803,46 @@ void InkHUD::MenuApplet::execute(MenuItem item)
 
     // Presets
     case SET_PRESET_LONG_SLOW:
-        applyLoRaPreset(meshtastic_Config_LoRaConfig_ModemPreset_LONG_SLOW);
+        applyLoRaPreset(PRESET(LONG_SLOW));
         break;
 
     case SET_PRESET_LONG_MODERATE:
-        applyLoRaPreset(meshtastic_Config_LoRaConfig_ModemPreset_LONG_MODERATE);
+        applyLoRaPreset(PRESET(LONG_MODERATE));
         break;
 
     case SET_PRESET_LONG_FAST:
-        applyLoRaPreset(meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST);
+        applyLoRaPreset(PRESET(LONG_FAST));
         break;
 
     case SET_PRESET_MEDIUM_SLOW:
-        applyLoRaPreset(meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_SLOW);
+        applyLoRaPreset(PRESET(MEDIUM_SLOW));
         break;
 
     case SET_PRESET_MEDIUM_FAST:
-        applyLoRaPreset(meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST);
+        applyLoRaPreset(PRESET(MEDIUM_FAST));
         break;
 
     case SET_PRESET_SHORT_SLOW:
-        applyLoRaPreset(meshtastic_Config_LoRaConfig_ModemPreset_SHORT_SLOW);
+        applyLoRaPreset(PRESET(SHORT_SLOW));
         break;
 
     case SET_PRESET_SHORT_FAST:
-        applyLoRaPreset(meshtastic_Config_LoRaConfig_ModemPreset_SHORT_FAST);
+        applyLoRaPreset(PRESET(SHORT_FAST));
         break;
 
     case SET_PRESET_SHORT_TURBO:
-        applyLoRaPreset(meshtastic_Config_LoRaConfig_ModemPreset_SHORT_TURBO);
+        applyLoRaPreset(PRESET(SHORT_TURBO));
         break;
 
+    case SET_PRESET_FROM_REGION: {
+        // cursor - 1 because index 0 is "Back"
+        const uint8_t index = cursor - 1;
+        if (index < regionPresetCount) {
+            applyLoRaPreset(regionPresets[index]);
+        }
+        break;
+    }
+
     // Timezones
     case SET_TZ_US_HAWAII:
         applyTimezone("HST10");
@@ -1421,6 +1444,8 @@ void InkHUD::MenuApplet::showPage(MenuPage page)
         items.push_back(MenuItem("US", MenuAction::SET_REGION_US, MenuPage::EXIT));
         items.push_back(MenuItem("EU 868", MenuAction::SET_REGION_EU_868, MenuPage::EXIT));
         items.push_back(MenuItem("EU 433", MenuAction::SET_REGION_EU_433, MenuPage::EXIT));
+        items.push_back(MenuItem("EU 866", MenuAction::SET_REGION_EU_866, MenuPage::EXIT));
+        items.push_back(MenuItem("EU 868 Narrow", MenuAction::SET_REGION_NARROW_868, MenuPage::EXIT));
         items.push_back(MenuItem("CN", MenuAction::SET_REGION_CN, MenuPage::EXIT));
         items.push_back(MenuItem("JP", MenuAction::SET_REGION_JP, MenuPage::EXIT));
         items.push_back(MenuItem("ANZ", MenuAction::SET_REGION_ANZ, MenuPage::EXIT));
@@ -1450,13 +1475,17 @@ void InkHUD::MenuApplet::showPage(MenuPage page)
     case NODE_CONFIG_PRESET: {
         previousPage = MenuPage::NODE_CONFIG_LORA;
         items.push_back(MenuItem("Back", previousPage));
-        items.push_back(MenuItem("Long Moderate", MenuAction::SET_PRESET_LONG_MODERATE, MenuPage::EXIT));
-        items.push_back(MenuItem("Long Fast", MenuAction::SET_PRESET_LONG_FAST, MenuPage::EXIT));
-        items.push_back(MenuItem("Medium Slow", MenuAction::SET_PRESET_MEDIUM_SLOW, MenuPage::EXIT));
-        items.push_back(MenuItem("Medium Fast", MenuAction::SET_PRESET_MEDIUM_FAST, MenuPage::EXIT));
-        items.push_back(MenuItem("Short Slow", MenuAction::SET_PRESET_SHORT_SLOW, MenuPage::EXIT));
-        items.push_back(MenuItem("Short Fast", MenuAction::SET_PRESET_SHORT_FAST, MenuPage::EXIT));
-        items.push_back(MenuItem("Short Turbo", MenuAction::SET_PRESET_SHORT_TURBO, MenuPage::EXIT));
+        regionPresetCount = 0;
+        if (myRegion && myRegion->profile) {
+            const meshtastic_Config_LoRaConfig_ModemPreset *presets = myRegion->getAvailablePresets();
+            size_t numPresets = myRegion->getNumPresets();
+            for (size_t i = 0; i < numPresets && regionPresetCount < MAX_REGION_PRESETS; ++i) {
+                regionPresets[regionPresetCount++] = presets[i];
+                const char *name = DisplayFormatters::getModemPresetDisplayName(presets[i], false, true);
+                nodeConfigLabels.emplace_back(name);
+                items.push_back(MenuItem(nodeConfigLabels.back().c_str(), MenuAction::SET_PRESET_FROM_REGION, MenuPage::EXIT));
+            }
+        }
         items.push_back(MenuItem("Exit", MenuPage::EXIT));
         break;
     }

src/main.cpp

@@ -92,6 +92,8 @@ NRF54L15Bluetooth *nrf54l15Bluetooth = nullptr;
 #include <string>
 #endif
 
+const char *bootString =
+    nullptr; // Pointer to a string that will be drawn on the boot screen, if set (used for GPS probing status)
 #ifdef ARCH_ESP32
 #ifdef DEBUG_PARTITION_TABLE
 #include "esp_partition.h"

src/main.h

@@ -105,3 +105,5 @@ void scannerToSensorsMap(const std::unique_ptr<ScanI2CTwoWire> &i2cScanner, Scan
 
 // We default to 4MHz SPI, SPI mode 0
 extern SPISettings spiSettings;
+
+extern const char *bootString;

src/mesh/Default.cpp

@@ -60,6 +60,26 @@ uint32_t Default::getConfiguredOrDefaultMsScaled(uint32_t configured, uint32_t d
     return base * coef;
 }
 
+uint32_t Default::getConfiguredOrDefaultMsScaled(uint32_t configured, uint32_t defaultValue, uint32_t numOnlineNodes,
+                                                 TrafficType type)
+{
+    uint32_t baseMs = getConfiguredOrDefaultMsScaled(configured, defaultValue, numOnlineNodes);
+
+    if (!myRegion || !myRegion->profile)
+        return baseMs;
+
+    int8_t throttle =
+        (type == TrafficType::POSITION) ? myRegion->profile->positionThrottle : myRegion->profile->telemetryThrottle;
+
+    // throttle <= 0 means unset; 1 is the neutral multiplier — skip the multiply for performance
+    if (throttle <= 1)
+        return baseMs;
+
+    constexpr uint32_t MAX_MS = static_cast<uint32_t>(INT32_MAX);
+    uint64_t result = static_cast<uint64_t>(baseMs) * static_cast<uint64_t>(throttle);
+    return result >= static_cast<uint64_t>(MAX_MS) ? MAX_MS : static_cast<uint32_t>(result);
+}
+
 uint32_t Default::getConfiguredOrMinimumValue(uint32_t configured, uint32_t minValue)
 {
     // If zero, intervals should be coalesced later by getConfiguredOrDefault... methods

src/mesh/Default.h

@@ -31,6 +31,8 @@
 #define min_neighbor_info_broadcast_secs 4 * 60 * 60
 #define default_map_publish_interval_secs 60 * 60
 
+enum class TrafficType { POSITION, TELEMETRY };
+
 // Traffic management defaults
 #define default_traffic_mgmt_position_precision_bits 24               // ~10m grid cells
 #define default_traffic_mgmt_position_min_interval_secs (ONE_DAY / 2) // 12 hours between identical positions
@@ -64,6 +66,8 @@ class Default
     // Note: numOnlineNodes uses uint32_t to match the public API and allow flexibility,
     // even though internal node counts use uint16_t (max 65535 nodes)
     static uint32_t getConfiguredOrDefaultMsScaled(uint32_t configured, uint32_t defaultValue, uint32_t numOnlineNodes);
+    static uint32_t getConfiguredOrDefaultMsScaled(uint32_t configured, uint32_t defaultValue, uint32_t numOnlineNodes,
+                                                   TrafficType type);
     static uint8_t getConfiguredOrDefaultHopLimit(uint8_t configured);
     static uint32_t getConfiguredOrMinimumValue(uint32_t configured, uint32_t minValue);
 

src/mesh/LR11x0Interface.cpp

@@ -368,4 +368,10 @@ template <typename T> bool LR11x0Interface<T>::sleep()
 
     return true;
 }
+
+template <typename T> int16_t LR11x0Interface<T>::getCurrentRSSI()
+{
+    float rssi = lora.getRSSI(false, true);
+    return (int16_t)round(rssi);
+}
 #endif

src/mesh/LR11x0Interface.h

@@ -37,6 +37,8 @@ template <class T> class LR11x0Interface : public RadioLibInterface
      */
     T lora;
 
+    int16_t getCurrentRSSI() override;
+
     /**
      * Glue functions called from ISR land
      */

src/mesh/LR20x0Interface.cpp

@@ -136,17 +136,6 @@ template <typename T> bool LR20x0Interface<T>::init()
     if (res == RADIOLIB_ERR_CHIP_NOT_FOUND || res == RADIOLIB_ERR_SPI_CMD_FAILED)
         return false;
 
-        // Some basic info about the module's explicit firmware version - no other info available
-        // Currently requires radiolib godmode
-
-#if RADIOLIB_GODMODE
-    uint8_t fwMajor = 0;
-    uint8_t fwMinor = 0;
-    int versionRes = lora.getVersion(&fwMajor, &fwMinor);
-    if (versionRes == RADIOLIB_ERR_NONE)
-        LOG_DEBUG("LR20x0 FW %d.%d", fwMajor, fwMinor);
-#endif
-
     LOG_INFO("Frequency set to %f", getFreq());
     LOG_INFO("Bandwidth set to %f", bw);
     LOG_INFO("Power output set to %d", power);
@@ -154,17 +143,6 @@ template <typename T> bool LR20x0Interface<T>::init()
     if (res == RADIOLIB_ERR_NONE)
         res = lora.setCRC(2);
 
-        // Standard DCDC ramp timing from RadioLib workarounds (register 0x00F20024)
-        // Currently requires radiolib godmode
-#if RADIOLIB_GODMODE
-    if (res == RADIOLIB_ERR_NONE) {
-        uint8_t rampTimes[4] = {15, 15, 15, 15}; // Standard case for all conditions
-        res = lora.setRegMode(RADIOLIB_LR2021_REG_MODE_SIMO_NORMAL, rampTimes);
-        if (res != RADIOLIB_ERR_NONE)
-            LOG_WARN("LR2021 setRegMode failed: %d", res);
-    }
-#endif
-
 #ifdef LR2021_DIO_AS_RF_SWITCH
     bool dioAsRfSwitch = true;
 #elif defined(ARCH_PORTDUINO)
@@ -396,4 +374,10 @@ template <typename T> bool LR20x0Interface<T>::sleep()
 
     return true;
 }
+
+template <typename T> int16_t LR20x0Interface<T>::getCurrentRSSI()
+{
+    float rssi = lora.getRSSI(false, true);
+    return (int16_t)round(rssi);
+}
 #endif

src/mesh/LR20x0Interface.h

@@ -37,6 +37,8 @@ template <class T> class LR20x0Interface : public RadioLibInterface
      */
     T lora;
 
+    int16_t getCurrentRSSI() override;
+
     /**
      * Glue functions called from ISR land
      */

src/mesh/MeshRadio.h

@@ -13,9 +13,16 @@
 static const meshtastic_Config_LoRaConfig_ModemPreset MODEM_PRESET_END =
     static_cast<meshtastic_Config_LoRaConfig_ModemPreset>(0xFF);
 
+#define PRESET(name) meshtastic_Config_LoRaConfig_ModemPreset_##name
+
+// Override slot magic numbers for RegionProfile.overrideSlot
+#define OVERRIDE_SLOT_DEFAULT_CHANNEL_HASH 0 // Use hash of primary channel name
+#define OVERRIDE_SLOT_PRESET_HASH -1         // Use hash of preset name instead
+// Positive values (1-32767) are explicit slot numbers
+
 // Region profile: bundles the preset list with regulatory parameters shared across regions
 struct RegionProfile {
-    const meshtastic_Config_LoRaConfig_ModemPreset *presets; // sentinel-terminated; first entry is the default
+    const meshtastic_Config_LoRaConfig_ModemPreset *presets; // sentinel-terminated
     float spacing;                                           // gaps between radio channels
     float padding;                                           // padding at each side of the "operating channel"
     bool audioPermitted;
@@ -23,14 +30,22 @@ struct RegionProfile {
     int8_t textThrottle;      // throttle for text - future expansion
     int8_t positionThrottle;  // throttle for location data - future expansion
     int8_t telemetryThrottle; // throttle for telemetry - future expansion
-    uint8_t overrideSlot;     // a per-region override slot for if we need to fix it in place
+    int16_t overrideSlot;     // a per-region override slot for if we need to fix it in place
+                              // Magic values: 0 = use channel name hash, -1 = use preset name hash, >0 = explicit slot
 };
 
+/**
+ * Get the effective duty cycle for the current region based on device role.
+ * For EU_866, returns 10% for fixed devices (ROUTER, ROUTER_LATE) and 2.5% for mobile devices.
+ * For other regions, returns the standard duty cycle.
+ */
+extern float getEffectiveDutyCycle();
+
 extern const RegionProfile PROFILE_STD;
 extern const RegionProfile PROFILE_EU868;
 extern const RegionProfile PROFILE_UNDEF;
-// extern const RegionProfile  PROFILE_LITE;
-// extern const RegionProfile  PROFILE_NARROW;
+extern const RegionProfile PROFILE_LITE;
+extern const RegionProfile PROFILE_NARROW;
 // extern const RegionProfile  PROFILE_HAM;
 
 // Map from old region names to new region enums
@@ -43,10 +58,11 @@ struct RegionInfo {
     bool freqSwitching;
     bool wideLora;
     const RegionProfile *profile;
+    meshtastic_Config_LoRaConfig_ModemPreset defaultPreset;
     const char *name; // EU433 etc
 
     // Preset accessors (delegate through profile)
-    meshtastic_Config_LoRaConfig_ModemPreset getDefaultPreset() const { return profile->presets[0]; }
+    meshtastic_Config_LoRaConfig_ModemPreset getDefaultPreset() const { return defaultPreset; }
     const meshtastic_Config_LoRaConfig_ModemPreset *getAvailablePresets() const { return profile->presets; }
     size_t getNumPresets() const
     {
@@ -143,46 +159,66 @@ static inline void modemPresetToParams(meshtastic_Config_LoRaConfig_ModemPreset
                                        uint8_t &cr)
 {
     switch (preset) {
-    case meshtastic_Config_LoRaConfig_ModemPreset_SHORT_TURBO:
+    case PRESET(SHORT_TURBO):
         bwKHz = wideLora ? 1625.0f : 500.0f;
         cr = 5;
         sf = 7;
         break;
-    case meshtastic_Config_LoRaConfig_ModemPreset_SHORT_FAST:
+    case PRESET(SHORT_FAST):
         bwKHz = wideLora ? 812.5f : 250.0f;
         cr = 5;
         sf = 7;
         break;
-    case meshtastic_Config_LoRaConfig_ModemPreset_SHORT_SLOW:
+    case PRESET(SHORT_SLOW):
         bwKHz = wideLora ? 812.5f : 250.0f;
         cr = 5;
         sf = 8;
         break;
-    case meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST:
+    case PRESET(MEDIUM_FAST):
         bwKHz = wideLora ? 812.5f : 250.0f;
         cr = 5;
         sf = 9;
         break;
-    case meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_SLOW:
+    case PRESET(MEDIUM_SLOW):
         bwKHz = wideLora ? 812.5f : 250.0f;
         cr = 5;
         sf = 10;
         break;
-    case meshtastic_Config_LoRaConfig_ModemPreset_LONG_TURBO:
+    case PRESET(LONG_TURBO):
         bwKHz = wideLora ? 1625.0f : 500.0f;
         cr = 8;
         sf = 11;
         break;
-    case meshtastic_Config_LoRaConfig_ModemPreset_LONG_MODERATE:
+    case PRESET(LONG_MODERATE):
         bwKHz = wideLora ? 406.25f : 125.0f;
         cr = 8;
         sf = 11;
         break;
-    case meshtastic_Config_LoRaConfig_ModemPreset_LONG_SLOW:
+    case PRESET(LONG_SLOW):
         bwKHz = wideLora ? 406.25f : 125.0f;
         cr = 8;
         sf = 12;
         break;
+    case PRESET(LITE_FAST):
+        bwKHz = 125;
+        cr = 5;
+        sf = 9;
+        break;
+    case PRESET(LITE_SLOW):
+        bwKHz = 125;
+        cr = 5;
+        sf = 10;
+        break;
+    case PRESET(NARROW_FAST):
+        bwKHz = 62.5f;
+        cr = 6;
+        sf = 7;
+        break;
+    case PRESET(NARROW_SLOW):
+        bwKHz = 62.5f;
+        cr = 6;
+        sf = 8;
+        break;
     default: // LONG_FAST (or illegal)
         bwKHz = wideLora ? 812.5f : 250.0f;
         cr = 5;

src/mesh/PositionPrecision.cpp

@@ -4,17 +4,19 @@
 
 #include <Arduino.h>
 
-uint32_t getPositionPrecisionForChannel(uint8_t channelIndex)
+uint32_t getPositionPrecisionForChannel(const meshtastic_Channel &channel)
 {
-    const meshtastic_Channel &channel = channels.getByIndex(channelIndex);
-
     if (channel.settings.has_module_settings) {
         return channel.settings.module_settings.position_precision;
-    } else if (channel.role == meshtastic_Channel_Role_PRIMARY) {
-        return 32;
-    } else {
-        return 0;
     }
+    // No module settings: fail closed. A PRIMARY channel used to default to 32
+    // here, leaking an exact position on a sharing-disabled channel. See #10509.
+    return 0;
+}
+
+uint32_t getPositionPrecisionForChannel(uint8_t channelIndex)
+{
+    return getPositionPrecisionForChannel(channels.getByIndex(channelIndex));
 }
 
 static int32_t truncateCoordinate(int32_t coordinate, uint32_t precision)

src/mesh/PositionPrecision.h

@@ -1,8 +1,10 @@
 #pragma once
 
+#include "meshtastic/channel.pb.h"
 #include "meshtastic/mesh.pb.h"
 #include <stdint.h>
 
+uint32_t getPositionPrecisionForChannel(const meshtastic_Channel &channel);
 uint32_t getPositionPrecisionForChannel(uint8_t channelIndex);
 void applyPositionPrecision(meshtastic_Position &position, uint32_t precision);
 bool applyPositionPrecision(meshtastic_MeshPacket &packet, uint32_t precision);

src/mesh/RF95Interface.cpp

@@ -341,4 +341,10 @@ bool RF95Interface::sleep()
 
     return true;
 }
+
+int16_t RF95Interface::getCurrentRSSI()
+{
+    float rssi = lora->getRSSI(false);
+    return (int16_t)round(rssi);
+}
 #endif

src/mesh/RF95Interface.h

@@ -37,6 +37,8 @@ class RF95Interface : public RadioLibInterface
      */
     virtual void disableInterrupt() override;
 
+    int16_t getCurrentRSSI() override;
+
     /**
      * Enable a particular ISR callback glue function
      */

src/mesh/RadioInterface.cpp

@@ -35,31 +35,32 @@
 #endif
 
 static const meshtastic_Config_LoRaConfig_ModemPreset PRESETS_STD[] = {
-    meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST,     meshtastic_Config_LoRaConfig_ModemPreset_LONG_SLOW,
-    meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_SLOW,   meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST,
-    meshtastic_Config_LoRaConfig_ModemPreset_SHORT_SLOW,    meshtastic_Config_LoRaConfig_ModemPreset_SHORT_FAST,
-    meshtastic_Config_LoRaConfig_ModemPreset_LONG_MODERATE, meshtastic_Config_LoRaConfig_ModemPreset_SHORT_TURBO,
-    meshtastic_Config_LoRaConfig_ModemPreset_LONG_TURBO,    MODEM_PRESET_END};
+    PRESET(LONG_FAST),  PRESET(LONG_SLOW),     PRESET(MEDIUM_SLOW), PRESET(MEDIUM_FAST), PRESET(SHORT_SLOW),
+    PRESET(SHORT_FAST), PRESET(LONG_MODERATE), PRESET(SHORT_TURBO), PRESET(LONG_TURBO),  MODEM_PRESET_END};
 
 static const meshtastic_Config_LoRaConfig_ModemPreset PRESETS_EU_868[] = {
-    meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST,     meshtastic_Config_LoRaConfig_ModemPreset_LONG_SLOW,
-    meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_SLOW,   meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST,
-    meshtastic_Config_LoRaConfig_ModemPreset_SHORT_SLOW,    meshtastic_Config_LoRaConfig_ModemPreset_SHORT_FAST,
-    meshtastic_Config_LoRaConfig_ModemPreset_LONG_MODERATE, MODEM_PRESET_END};
+    PRESET(LONG_FAST),  PRESET(LONG_SLOW),  PRESET(MEDIUM_SLOW),   PRESET(MEDIUM_FAST),
+    PRESET(SHORT_SLOW), PRESET(SHORT_FAST), PRESET(LONG_MODERATE), MODEM_PRESET_END};
 
-static const meshtastic_Config_LoRaConfig_ModemPreset PRESETS_UNDEF[] = {meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST,
-                                                                         MODEM_PRESET_END};
+static const meshtastic_Config_LoRaConfig_ModemPreset PRESETS_UNDEF[] = {PRESET(LONG_FAST), MODEM_PRESET_END};
+
+static const meshtastic_Config_LoRaConfig_ModemPreset PRESETS_LITE[] = {PRESET(LITE_FAST), PRESET(LITE_SLOW), MODEM_PRESET_END};
+
+static const meshtastic_Config_LoRaConfig_ModemPreset PRESETS_NARROW[] = {PRESET(NARROW_FAST), PRESET(NARROW_SLOW),
+                                                                          MODEM_PRESET_END};
 
 // Region profiles: bundle preset list + regulatory parameters shared across regions
 // presets, spacing, padding, audio, licensed, text throttle, position throttle, telemetry throttle, override slot
-const RegionProfile PROFILE_STD = {PRESETS_STD, 0, 0, true, false, 0, 0, 0, 0};
-const RegionProfile PROFILE_EU868 = {PRESETS_EU_868, 0, 0, false, false, 0, 0, 0, 0};
-const RegionProfile PROFILE_UNDEF = {PRESETS_UNDEF, 0, 0, true, false, 0, 0, 0, 0};
+const RegionProfile PROFILE_STD = {PRESETS_STD, 0, 0, true, false, 0, 1, 1, 0};
+const RegionProfile PROFILE_EU868 = {PRESETS_EU_868, 0, 0, false, false, 0, 1, 1, 0};
+const RegionProfile PROFILE_UNDEF = {PRESETS_UNDEF, 0, 0, true, false, 0, 1, 1, 0};
+const RegionProfile PROFILE_LITE = {PRESETS_LITE, 0.4, 0.0375f, false, false, 0, 10, 10, 0};
+const RegionProfile PROFILE_NARROW = {PRESETS_NARROW, 0, 0.0104f, true, false, 0, 1, 1, 1};
 
-#define RDEF(name, freq_start, freq_end, duty_cycle, power_limit, frequency_switching, wide_lora, profile_ptr)                   \
+#define RDEF(name, freq_start, freq_end, duty_cycle, power_limit, frequency_switching, wide_lora, profile_ptr, default_preset)   \
     {                                                                                                                            \
         meshtastic_Config_LoRaConfig_RegionCode_##name, freq_start, freq_end, duty_cycle, power_limit, frequency_switching,      \
-            wide_lora, &profile_ptr, #name                                                                                       \
+            wide_lora, &profile_ptr, default_preset, #name                                                                       \
     }
 
 const RegionInfo regions[] = {
@@ -67,7 +68,7 @@ const RegionInfo regions[] = {
         https://link.springer.com/content/pdf/bbm%3A978-1-4842-4357-2%2F1.pdf
         https://www.thethingsnetwork.org/docs/lorawan/regional-parameters/
     */
-    RDEF(US, 902.0f, 928.0f, 100, 30, false, false, PROFILE_STD),
+    RDEF(US, 902.0f, 928.0f, 100, 30, false, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
         EN300220 ETSI V3.2.1 [Table B.1, Item H, p. 21]
@@ -75,7 +76,7 @@ const RegionInfo regions[] = {
         https://www.etsi.org/deliver/etsi_en/300200_300299/30022002/03.02.01_60/en_30022002v030201p.pdf
         FIXME: https://github.com/meshtastic/firmware/issues/3371
      */
-    RDEF(EU_433, 433.0f, 434.0f, 10, 10, false, false, PROFILE_STD),
+    RDEF(EU_433, 433.0f, 434.0f, 10, 10, false, false, PROFILE_STD, PRESET(LONG_FAST)),
     /*
        https://www.thethingsnetwork.org/docs/lorawan/duty-cycle/
        https://www.thethingsnetwork.org/docs/lorawan/regional-parameters/
@@ -90,33 +91,33 @@ const RegionInfo regions[] = {
        AFA) to avoid a duty cycle. (Please refer to line P page 22 of this document.)
        https://www.etsi.org/deliver/etsi_en/300200_300299/30022002/03.01.01_60/en_30022002v030101p.pdf
      */
-    RDEF(EU_868, 869.4f, 869.65f, 10, 27, false, false, PROFILE_EU868),
+    RDEF(EU_868, 869.4f, 869.65f, 10, 27, false, false, PROFILE_EU868, PRESET(LONG_FAST)),
 
     /*
         https://lora-alliance.org/wp-content/uploads/2020/11/lorawan_regional_parameters_v1.0.3reva_0.pdf
      */
-    RDEF(CN, 470.0f, 510.0f, 100, 19, false, false, PROFILE_STD),
+    RDEF(CN, 470.0f, 510.0f, 100, 19, false, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
         https://lora-alliance.org/wp-content/uploads/2020/11/lorawan_regional_parameters_v1.0.3reva_0.pdf
         https://www.arib.or.jp/english/html/overview/doc/5-STD-T108v1_5-E1.pdf
         https://qiita.com/ammo0613/items/d952154f1195b64dc29f
      */
-    RDEF(JP, 920.5f, 923.5f, 100, 13, false, false, PROFILE_STD),
+    RDEF(JP, 920.5f, 923.5f, 100, 13, false, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
         https://www.iot.org.au/wp/wp-content/uploads/2016/12/IoTSpectrumFactSheet.pdf
         https://iotalliance.org.nz/wp-content/uploads/sites/4/2019/05/IoT-Spectrum-in-NZ-Briefing-Paper.pdf
         Also used in Brazil.
      */
-    RDEF(ANZ, 915.0f, 928.0f, 100, 30, false, false, PROFILE_STD),
+    RDEF(ANZ, 915.0f, 928.0f, 100, 30, false, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
         433.05 - 434.79 MHz, 25mW EIRP max, No duty cycle restrictions
         AU Low Interference Potential https://www.acma.gov.au/licences/low-interference-potential-devices-lipd-class-licence
         NZ General User Radio Licence for Short Range Devices https://gazette.govt.nz/notice/id/2022-go3100
      */
-    RDEF(ANZ_433, 433.05f, 434.79f, 100, 14, false, false, PROFILE_STD),
+    RDEF(ANZ_433, 433.05f, 434.79f, 100, 14, false, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
         https://digital.gov.ru/uploaded/files/prilozhenie-12-k-reshenyu-gkrch-18-46-03-1.pdf
@@ -124,13 +125,13 @@ const RegionInfo regions[] = {
         Note:
             - We do LBT, so 100% is allowed.
      */
-    RDEF(RU, 868.7f, 869.2f, 100, 20, false, false, PROFILE_STD),
+    RDEF(RU, 868.7f, 869.2f, 100, 20, false, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
         https://www.law.go.kr/LSW/admRulLsInfoP.do?admRulId=53943&efYd=0
         https://resources.lora-alliance.org/technical-specifications/rp002-1-0-4-regional-parameters
      */
-    RDEF(KR, 920.0f, 923.0f, 100, 23, false, false, PROFILE_STD),
+    RDEF(KR, 920.0f, 923.0f, 100, 23, false, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
         Taiwan, 920-925Mhz, limited to 0.5W indoor or coastal, 1.0W outdoor.
@@ -138,40 +139,40 @@ const RegionInfo regions[] = {
         https://www.ncc.gov.tw/english/files/23070/102_5190_230703_1_doc_C.PDF
         https://gazette.nat.gov.tw/egFront/e_detail.do?metaid=147283
      */
-    RDEF(TW, 920.0f, 925.0f, 100, 27, false, false, PROFILE_STD),
+    RDEF(TW, 920.0f, 925.0f, 100, 27, false, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
         https://lora-alliance.org/wp-content/uploads/2020/11/lorawan_regional_parameters_v1.0.3reva_0.pdf
      */
-    RDEF(IN, 865.0f, 867.0f, 100, 30, false, false, PROFILE_STD),
+    RDEF(IN, 865.0f, 867.0f, 100, 30, false, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
          https://rrf.rsm.govt.nz/smart-web/smart/page/-smart/domain/licence/LicenceSummary.wdk?id=219752
          https://iotalliance.org.nz/wp-content/uploads/sites/4/2019/05/IoT-Spectrum-in-NZ-Briefing-Paper.pdf
       */
-    RDEF(NZ_865, 864.0f, 868.0f, 100, 36, false, false, PROFILE_STD),
+    RDEF(NZ_865, 864.0f, 868.0f, 100, 36, false, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
        https://lora-alliance.org/wp-content/uploads/2020/11/lorawan_regional_parameters_v1.0.3reva_0.pdf
        https://standard.nbtc.go.th/getattachment/Standards/%E0%B8%A1%E0%B8%B2%E0%B8%95%E0%B8%A3%E0%B8%90%E0%B8%B2%E0%B8%99%E0%B8%97%E0%B8%B2%E0%B8%87%E0%B9%80%E0%B8%97%E0%B8%84%E0%B8%99%E0%B8%B4%E0%B8%84%E0%B8%82%E0%B8%AD%E0%B8%87%E0%B9%80%E0%B8%84%E0%B8%A3%E0%B8%B7%E0%B9%88%E0%B8%AD%E0%B8%87%E0%B9%82%E0%B8%97%E0%B8%A3%E0%B8%84%E0%B8%A1%E0%B8%99%E0%B8%B2%E0%B8%84%E0%B8%A1/1033-2565.pdf.aspx?lang=th-TH
        Thailand 920–925 MHz set max TX power to 27 dBm and enforce 10% duty cycle, aligned with NBTC regulations.
     */
-    RDEF(TH, 920.0f, 925.0f, 10, 27, false, false, PROFILE_STD),
+    RDEF(TH, 920.0f, 925.0f, 10, 27, false, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
         433,05-434,7 Mhz 10 mW
         868,0-868,6 Mhz 25 mW
         https://nkrzi.gov.ua/images/upload/256/5810/PDF_UUZ_19_01_2016.pdf
     */
-    RDEF(UA_433, 433.0f, 434.7f, 10, 10, false, false, PROFILE_STD),
-    RDEF(UA_868, 868.0f, 868.6f, 1, 14, false, false, PROFILE_STD),
+    RDEF(UA_433, 433.0f, 434.7f, 10, 10, false, false, PROFILE_STD, PRESET(LONG_FAST)),
+    RDEF(UA_868, 868.0f, 868.6f, 1, 14, false, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
         Malaysia
         433 - 435 MHz at 100mW, no restrictions.
         https://www.mcmc.gov.my/skmmgovmy/media/General/pdf/Short-Range-Devices-Specification.pdf
     */
-    RDEF(MY_433, 433.0f, 435.0f, 100, 20, false, false, PROFILE_STD),
+    RDEF(MY_433, 433.0f, 435.0f, 100, 20, false, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
         Malaysia
@@ -180,14 +181,14 @@ const RegionInfo regions[] = {
         Frequency hopping is used for 919 - 923 MHz.
         https://www.mcmc.gov.my/skmmgovmy/media/General/pdf/Short-Range-Devices-Specification.pdf
     */
-    RDEF(MY_919, 919.0f, 924.0f, 100, 27, true, false, PROFILE_STD),
+    RDEF(MY_919, 919.0f, 924.0f, 100, 27, true, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
         Singapore
         SG_923 Band 30d: 917 - 925 MHz at 100mW, no restrictions.
         https://www.imda.gov.sg/-/media/imda/files/regulation-licensing-and-consultations/ict-standards/telecommunication-standards/radio-comms/imdatssrd.pdf
     */
-    RDEF(SG_923, 917.0f, 925.0f, 100, 20, false, false, PROFILE_STD),
+    RDEF(SG_923, 917.0f, 925.0f, 100, 20, false, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
         Philippines
@@ -197,9 +198,9 @@ const RegionInfo regions[] = {
                 https://github.com/meshtastic/firmware/issues/4948#issuecomment-2394926135
     */
 
-    RDEF(PH_433, 433.0f, 434.7f, 100, 10, false, false, PROFILE_STD),
-    RDEF(PH_868, 868.0f, 869.4f, 100, 14, false, false, PROFILE_STD),
-    RDEF(PH_915, 915.0f, 918.0f, 100, 24, false, false, PROFILE_STD),
+    RDEF(PH_433, 433.0f, 434.7f, 100, 10, false, false, PROFILE_STD, PRESET(LONG_FAST)),
+    RDEF(PH_868, 868.0f, 869.4f, 100, 14, false, false, PROFILE_STD, PRESET(LONG_FAST)),
+    RDEF(PH_915, 915.0f, 918.0f, 100, 24, false, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
         Kazakhstan
@@ -207,32 +208,46 @@ const RegionInfo regions[] = {
                 863 - 868 MHz <25 mW EIRP, 500kHz channels allowed, must not be used at airfields
                                 https://github.com/meshtastic/firmware/issues/7204
     */
-    RDEF(KZ_433, 433.075f, 434.775f, 100, 10, false, false, PROFILE_STD),
-    RDEF(KZ_863, 863.0f, 868.0f, 100, 30, false, false, PROFILE_STD),
+    RDEF(KZ_433, 433.075f, 434.775f, 100, 10, false, false, PROFILE_STD, PRESET(LONG_FAST)),
+    RDEF(KZ_863, 863.0f, 868.0f, 100, 30, false, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
         Nepal
         865 MHz to 868 MHz frequency band for IoT (Internet of Things), M2M (Machine-to-Machine), and smart metering use,
        specifically in non-cellular mode. https://www.nta.gov.np/uploads/contents/Radio-Frequency-Policy-2080-English.pdf
     */
-    RDEF(NP_865, 865.0f, 868.0f, 100, 30, false, false, PROFILE_STD),
+    RDEF(NP_865, 865.0f, 868.0f, 100, 30, false, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
         Brazil
         902 - 907.5 MHz , 1W power limit, no duty cycle restrictions
         https://github.com/meshtastic/firmware/issues/3741
     */
-    RDEF(BR_902, 902.0f, 907.5f, 100, 30, false, false, PROFILE_STD),
+    RDEF(BR_902, 902.0f, 907.5f, 100, 30, false, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
        2.4 GHZ WLAN Band equivalent. Only for SX128x chips.
     */
-    RDEF(LORA_24, 2400.0f, 2483.5f, 100, 10, false, true, PROFILE_STD),
+    RDEF(LORA_24, 2400.0f, 2483.5f, 100, 10, false, true, PROFILE_STD, PRESET(LONG_FAST)),
+
+    /*
+        EU 866MHz band (Band no. 46b of 2006/771/EC and subsequent amendments) for Non-specific short-range devices (SRD)
+        Gives 4 channels at 865.7/866.3/866.9/867.5 MHz, 400 kHz gap plus 37.5 kHz padding between channels, 27 dBm,
+        duty cycle 2.5% (mobile) or 10% (fixed) https://eur-lex.europa.eu/legal-content/EN/TXT/?uri=CELEX:02006D0771(01)-20250123
+    */
+    RDEF(EU_866, 865.6f, 867.6f, 2.5, 27, false, false, PROFILE_LITE, PRESET(LITE_FAST)),
+
+    /*
+        EU 868MHz band: 3 channels at 869.410/869.4625/869.577 MHz
+        Channel centres at 869.442/869.525/869.608 MHz,
+        10.4 kHz padding on channels, 27 dBm, duty cycle 10%
+    */
+    RDEF(EU_N_868, 869.4f, 869.65f, 10, 27, false, false, PROFILE_NARROW, PRESET(NARROW_SLOW)),
 
     /*
         This needs to be last. Same as US.
     */
-    RDEF(UNSET, 902.0f, 928.0f, 100, 30, false, false, PROFILE_UNDEF)
+    RDEF(UNSET, 902.0f, 928.0f, 100, 30, false, false, PROFILE_UNDEF, PRESET(LONG_FAST)),
 
 };
 
@@ -546,6 +561,23 @@ const RegionInfo *getRegion(meshtastic_Config_LoRaConfig_RegionCode code)
     return r;
 }
 
+/**
+ * Get duty cycle for current region. EU_866: 10% for routers, 2.5% for mobile.
+ */
+float getEffectiveDutyCycle()
+{
+    if (myRegion->code == meshtastic_Config_LoRaConfig_RegionCode_EU_866) {
+        if (config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER ||
+            config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER_LATE) {
+            return 10.0f;
+        } else {
+            return 2.5f;
+        }
+    }
+    // For all other regions, return the standard duty cycle
+    return myRegion->dutyCycle;
+}
+
 uint32_t RadioInterface::getPacketTime(const meshtastic_MeshPacket *p, bool received)
 {
     uint32_t pl = 0;
@@ -897,12 +929,15 @@ bool RadioInterface::checkOrClampConfigLora(meshtastic_Config_LoRaConfig &loraCo
     if (loraConfig.override_frequency == 0) {
 
         // Check if we use the default frequency slot
+        // overrideSlot: 0 = channel hash, -1 = preset hash, >0 = explicit slot
         uses_default_frequency_slot =
             (loraConfig.channel_num == 0) || // user choice unset, no frequency override, so use default
-            (newRegion->profile->overrideSlot != 0 &&
-             loraConfig.channel_num == newRegion->profile->overrideSlot) || // user setting matches override
-            ((newRegion->profile->overrideSlot == 0) &&
-             ((uint32_t)(loraConfig.channel_num - 1) == presetNameHashSlot)); // user setting matches preset hash, no override
+            (newRegion->profile->overrideSlot > 0 &&
+             loraConfig.channel_num == newRegion->profile->overrideSlot) || // user setting matches explicit override slot
+            ((newRegion->profile->overrideSlot == OVERRIDE_SLOT_DEFAULT_CHANNEL_HASH) &&
+             ((uint32_t)(loraConfig.channel_num - 1) == channelNameHashSlot)) || // user setting matches channel name hash
+            ((newRegion->profile->overrideSlot == OVERRIDE_SLOT_PRESET_HASH) &&
+             ((uint32_t)(loraConfig.channel_num - 1) == presetNameHashSlot)); // user setting matches preset name hash
 
         // check if user setting different to preset name
         uses_custom_channel_name = (strcmp(channelName, presetNameDisplay) != 0);
@@ -917,10 +952,14 @@ bool RadioInterface::checkOrClampConfigLora(meshtastic_Config_LoRaConfig &loraCo
             if (clamp) {
                 if (uses_custom_channel_name) { // clamp to channel name hash
                     loraConfig.channel_num =
-                        channelNameHashSlot + 1; // channel_num is 1-based, but hash slot is 0-based, so add 1
-                } else if ((loraConfig.use_preset) && (newRegion->profile->overrideSlot != 0)) { // clamp to preset override slot
+                        channelNameHashSlot + 1;                   // channel_num is 1-based, but hash slot is 0-based, so add 1
+                } else if (newRegion->profile->overrideSlot > 0) { // clamp to explicit override slot
                     loraConfig.channel_num =
-                        newRegion->profile->overrideSlot; // use the override slot specified by the region profile
+                        newRegion->profile->overrideSlot; // use the explicit override slot specified by the region profile
+                    uses_default_frequency_slot = true;
+                } else if (newRegion->profile->overrideSlot == OVERRIDE_SLOT_PRESET_HASH && loraConfig.use_preset) {
+                    // clamp to preset name hash
+                    loraConfig.channel_num = presetNameHashSlot + 1; // channel_num is 1-based, but hash slot is 0-based, so add 1
                     uses_default_frequency_slot = true;
                 } else if (loraConfig.use_preset) {                  // clamp to preset slot
                     loraConfig.channel_num = presetNameHashSlot + 1; // channel_num is 1-based, but hash slot is 0-based, so add 1
@@ -1018,6 +1057,8 @@ void RadioInterface::applyModemConfig()
     // Calculate hash of channel name and preset name to pick a default frequency slot if user has not specified one.
     // Note that channel_num is actually (channel_num - 1), i.e. zero-based, since modulus (%) returns values from 0 to
     // (numFreqSlots - 1).
+    const char *channelName = channels.getName(channels.getPrimaryIndex());
+    uint32_t channelNameHashSlot = hash(channelName) % numFreqSlots;
     uint32_t presetNameHashSlot =
         hash(DisplayFormatters::getModemPresetDisplayName(loraConfig.modem_preset, false, loraConfig.use_preset)) % numFreqSlots;
 
@@ -1034,11 +1075,13 @@ void RadioInterface::applyModemConfig()
         // (channel_num - 1), i.e. zero-based, since modulus (%) returns values from 0 to (numFreqSlots - 1).
         // NB: channel_num is also know as frequency slot but it's too late to fix now.
         if (uses_default_frequency_slot) {
-            // if there's an override slot, use that
-            if (newRegion->profile->overrideSlot != 0) {
-                channel_num = newRegion->profile->overrideSlot - 1;
+            // Handle three override slot cases: explicit slot (>0), preset hash (-1), or channel hash (0)
+            if (newRegion->profile->overrideSlot > 0) {
+                channel_num = newRegion->profile->overrideSlot - 1; // explicit override slot (1-based to 0-based)
+            } else if (newRegion->profile->overrideSlot == OVERRIDE_SLOT_PRESET_HASH) {
+                channel_num = presetNameHashSlot; // use preset name hash
             } else {
-                channel_num = presetNameHashSlot;
+                channel_num = channelNameHashSlot; // use channel name hash (default case)
             }
         } else { // use the manually defined one
             channel_num = loraConfig.channel_num - 1;
@@ -1051,7 +1094,6 @@ void RadioInterface::applyModemConfig()
 
     saveChannelNum(channel_num);
     saveFreq(freq + loraConfig.frequency_offset);
-    const char *channelName = channels.getName(channels.getPrimaryIndex());
 
     if (newRegion->wideLora) {                          // clamp if wide freq range
         preambleLength = wideLoraPreambleLengthDefault; // 12 is the default for operation above 2GHz
@@ -1068,9 +1110,11 @@ void RadioInterface::applyModemConfig()
              channel_num, power);
     LOG_INFO("newRegion->freqStart -> newRegion->freqEnd: %f -> %f (%f MHz)", newRegion->freqStart, newRegion->freqEnd,
              newRegion->freqEnd - newRegion->freqStart);
-    LOG_INFO("numFreqSlots: %d x %.3fkHz", numFreqSlots, bw);
-    if (newRegion->profile->overrideSlot != 0) {
-        LOG_INFO("Using region override slot: %d", newRegion->profile->overrideSlot);
+    LOG_INFO("numFreqSlots: %u x %.3fkHz", numFreqSlots, bw);
+    if (newRegion->profile->overrideSlot > 0) {
+        LOG_INFO("Using region explicit override slot: %d", newRegion->profile->overrideSlot);
+    } else if (newRegion->profile->overrideSlot == OVERRIDE_SLOT_PRESET_HASH) {
+        LOG_INFO("Using region preset name hash for slot selection");
     }
     LOG_INFO("channel_num: %d", channel_num + 1);
     LOG_INFO("frequency: %f", getFreq());

src/mesh/RadioInterface.h

@@ -283,6 +283,12 @@ class RadioInterface
      */
     virtual void saveChannelNum(uint32_t savedChannelNum);
 
+    /**
+     * Get current RSSI reading from the radio.
+     * Returns 0 if not available.
+     */
+    virtual int16_t getCurrentRSSI() { return 0; }
+
   private:
     /**
      * Convert our modemConfig enum into wf, sf, etc...

src/mesh/RadioLibInterface.cpp

@@ -15,6 +15,7 @@
 #include "PortduinoGlue.h"
 #include "meshUtils.h"
 #endif
+
 void LockingArduinoHal::spiBeginTransaction()
 {
     spiLock->lock();
@@ -28,6 +29,7 @@ void LockingArduinoHal::spiEndTransaction()
 
     spiLock->unlock();
 }
+
 #if ARCH_PORTDUINO
 void LockingArduinoHal::spiTransfer(uint8_t *out, size_t len, uint8_t *in)
 {
@@ -40,6 +42,12 @@ RadioLibInterface::RadioLibInterface(LockingArduinoHal *hal, RADIOLIB_PIN_TYPE c
     : NotifiedWorkerThread("RadioIf"), module(hal, cs, irq, rst, busy), iface(_iface)
 {
     instance = this;
+
+    // Initialize unused sample slots to a sane default; sample count controls averaging.
+    for (uint8_t i = 0; i < NOISE_FLOOR_SAMPLES; i++) {
+        noiseFloorSamples[i] = NOISE_FLOOR_DEFAULT;
+    }
+
 #if defined(ARCH_STM32WL) && defined(USE_SX1262)
     module.setCb_digitalWrite(stm32wl_emulate_digitalWrite);
     module.setCb_digitalRead(stm32wl_emulate_digitalRead);
@@ -246,6 +254,87 @@ bool RadioLibInterface::findInTxQueue(NodeNum from, PacketId id)
     return txQueue.find(from, id);
 }
 
+void RadioLibInterface::updateNoiseFloor()
+{
+    // Only sample from idle receive mode. TX/RX-critical paths must return to radio work quickly.
+    if (!isReceiving || sendingPacket != NULL || isActivelyReceiving() || isIRQPending()) {
+        return;
+    }
+
+    uint32_t now = millis();
+    if (now - lastNoiseFloorUpdate < NOISE_FLOOR_UPDATE_INTERVAL_MS) {
+        return;
+    }
+    lastNoiseFloorUpdate = now;
+
+    int16_t rssi = getCurrentRSSI();
+    if (rssi == NOISE_FLOOR_INVALID || rssi >= 0 || rssi < NOISE_FLOOR_VALID_MIN) {
+        LOG_DEBUG("Skipping invalid RSSI reading: %d", rssi);
+        return;
+    }
+
+    noiseFloorSamples[currentSampleIndex] = (int32_t)rssi;
+    currentSampleIndex++;
+
+    if (currentSampleIndex >= NOISE_FLOOR_SAMPLES) {
+        currentSampleIndex = 0;
+        isNoiseFloorBufferFull = true;
+    }
+
+    currentNoiseFloor = getAverageNoiseFloorInternal();
+
+    LOG_DEBUG("Noise floor: %d dBm (samples: %d, latest: %d dBm)", currentNoiseFloor, getNoiseFloorSampleCountInternal(), rssi);
+}
+
+uint8_t RadioLibInterface::getNoiseFloorSampleCountInternal() const
+{
+    return isNoiseFloorBufferFull ? NOISE_FLOOR_SAMPLES : currentSampleIndex;
+}
+
+int32_t RadioLibInterface::getAverageNoiseFloorInternal() const
+{
+    uint8_t sampleCount = getNoiseFloorSampleCountInternal();
+
+    if (sampleCount == 0) {
+        return NOISE_FLOOR_DEFAULT;
+    }
+
+    int32_t sum = 0;
+    for (uint8_t i = 0; i < sampleCount; i++) {
+        sum += noiseFloorSamples[i];
+    }
+
+    return sum / sampleCount;
+}
+
+int32_t RadioLibInterface::getAverageNoiseFloor()
+{
+    return getAverageNoiseFloorInternal();
+}
+
+int32_t RadioLibInterface::getNoiseFloor()
+{
+    return currentNoiseFloor;
+}
+
+bool RadioLibInterface::hasNoiseFloorSamples()
+{
+    return getNoiseFloorSampleCountInternal() > 0;
+}
+
+uint8_t RadioLibInterface::getNoiseFloorSampleCount()
+{
+    return getNoiseFloorSampleCountInternal();
+}
+
+void RadioLibInterface::resetNoiseFloor()
+{
+    currentSampleIndex = 0;
+    isNoiseFloorBufferFull = false;
+    currentNoiseFloor = NOISE_FLOOR_DEFAULT;
+    LOG_INFO("Noise floor reset - rolling window collection will restart");
+}
+
 bool RadioLibInterface::randomBytes(uint8_t *buffer, size_t length)
 {
     if (!buffer || length == 0 || !iface) {
@@ -273,6 +362,7 @@ currently active.
 */
 void RadioLibInterface::onNotify(uint32_t notification)
 {
+
     switch (notification) {
     case ISR_TX:
         handleTransmitInterrupt();
@@ -404,11 +494,6 @@ bool RadioLibInterface::removePendingTXPacket(NodeNum from, PacketId id, uint32_
     return false;
 }
 
-/**
- * Remove a packet that is eligible for replacement from the TX queue
- */
-// void RadioLibInterface::removePending
-
 void RadioLibInterface::handleTransmitInterrupt()
 {
     // This can be null if we forced the device to enter standby mode.  In that case

src/mesh/RadioLibInterface.h

@@ -99,6 +99,26 @@ class RadioLibInterface : public RadioInterface, protected concurrency::Notified
     /// are _trying_ to receive a packet currently (note - we might just be waiting for one)
     bool isReceiving = false;
 
+  protected:
+    // Noise floor tracking - rolling window of samples.
+    static const uint8_t NOISE_FLOOR_SAMPLES = 20;
+    static const int32_t NOISE_FLOOR_DEFAULT = -120;
+    static const int32_t NOISE_FLOOR_VALID_MIN = -127;
+    static const int32_t NOISE_FLOOR_INVALID = -128;
+    int32_t noiseFloorSamples[NOISE_FLOOR_SAMPLES];
+    uint8_t currentSampleIndex = 0;
+    bool isNoiseFloorBufferFull = false;
+    uint32_t lastNoiseFloorUpdate = 0;
+    static const uint32_t NOISE_FLOOR_UPDATE_INTERVAL_MS = 5000;
+    int32_t currentNoiseFloor = NOISE_FLOOR_DEFAULT;
+
+    /**
+     * Pure virtual hook for derived radio interfaces to provide instantaneous RSSI.
+     * Implementations should return dBm, or an invalid value that updateNoiseFloor()
+     * can reject.
+     */
+    virtual int16_t getCurrentRSSI() = 0;
+
   public:
     /** Our ISR code currently needs this to find our active instance
      */
@@ -111,6 +131,17 @@ class RadioLibInterface : public RadioInterface, protected concurrency::Notified
             instance = nullptr;
     }
 
+    /**
+     * Get the current calculated noise floor in dBm
+     * Returns -120 dBm if not yet calibrated
+     */
+    int32_t getNoiseFloor();
+
+    /**
+     * Calculate the average noise floor from collected samples
+     */
+    int32_t getAverageNoiseFloor();
+
     /**
      * Glue functions called from ISR land
      */
@@ -179,6 +210,28 @@ class RadioLibInterface : public RadioInterface, protected concurrency::Notified
     /** Attempt to find a packet in the TxQueue. Returns true if the packet was found. */
     virtual bool findInTxQueue(NodeNum from, PacketId id) override;
 
+    /**
+     * Update the noise floor measurement by sampling RSSI from a slow path.
+     * This should not be called from radio interrupt or TX/RX critical paths.
+     */
+    void updateNoiseFloor();
+
+    /**
+     * Check if we have collected any noise floor samples
+     */
+    bool hasNoiseFloorSamples();
+
+    /**
+     * Get the number of samples in the rolling window
+     */
+    uint8_t getNoiseFloorSampleCount();
+
+    /**
+     * Reset the noise floor calibration
+     * Will automatically restart collection
+     */
+    void resetNoiseFloor();
+
     /**
      * Request randomness sourced from the LoRa modem, if supported by the active RadioLib interface.
      * @return true if len bytes were produced, false otherwise.
@@ -186,6 +239,9 @@ class RadioLibInterface : public RadioInterface, protected concurrency::Notified
     bool randomBytes(uint8_t *buffer, size_t length);
 
   private:
+    uint8_t getNoiseFloorSampleCountInternal() const;
+    int32_t getAverageNoiseFloorInternal() const;
+
     /** if we have something waiting to send, start a short (random) timer so we can come check for collision before actually
      * doing the transmit */
     void setTransmitDelay();

src/mesh/Router.cpp

@@ -318,10 +318,11 @@ ErrorCode Router::send(meshtastic_MeshPacket *p)
     } // should have already been handled by sendLocal
 
     // Abort sending if we are violating the duty cycle
-    if (!config.lora.override_duty_cycle && myRegion->dutyCycle < 100) {
+    float effectiveDutyCycle = getEffectiveDutyCycle();
+    if (!config.lora.override_duty_cycle && effectiveDutyCycle < 100) {
         float hourlyTxPercent = airTime->utilizationTXPercent();
-        if (hourlyTxPercent > myRegion->dutyCycle) {
-            uint8_t silentMinutes = airTime->getSilentMinutes(hourlyTxPercent, myRegion->dutyCycle);
+        if (hourlyTxPercent > effectiveDutyCycle) {
+            uint8_t silentMinutes = airTime->getSilentMinutes(hourlyTxPercent, effectiveDutyCycle);
 
             LOG_WARN("Duty cycle limit exceeded. Aborting send for now, you can send again in %d mins", silentMinutes);
 
@@ -368,10 +369,14 @@ ErrorCode Router::send(meshtastic_MeshPacket *p)
     }
 
     fixPriority(p); // Before encryption, fix the priority if it's unset
-    if (!applyPositionPrecisionForChannel(*p, p->channel)) {
-        LOG_ERROR("Dropping malformed position packet before send");
-        packetPool.release(p);
-        return meshtastic_Routing_Error_BAD_REQUEST;
+    // Position precision is an originator-only privacy policy. Relays keep
+    // p->from as the original sender, so do not rewrite their POSITION_APP payload.
+    if (isFromUs(p)) {
+        if (!applyPositionPrecisionForChannel(*p, p->channel)) {
+            LOG_ERROR("Dropping malformed position packet before send");
+            packetPool.release(p);
+            return meshtastic_Routing_Error_BAD_REQUEST;
+        }
     }
 
     // If the packet is not yet encrypted, do so now

src/mesh/SX126xInterface.cpp

@@ -52,8 +52,8 @@ template <typename T> bool SX126xInterface<T>::init()
 
 #ifdef SX126X_POWER_EN // Perhaps add RADIOLIB_NC check, and beforehand define as such if it is undefined, but it is not commonly
                        // used and not part of the 'default' set of pin definitions.
-    digitalWrite(SX126X_POWER_EN, HIGH);
     pinMode(SX126X_POWER_EN, OUTPUT);
+    digitalWrite(SX126X_POWER_EN, HIGH);
 #endif
 
 #if HAS_LORA_FEM
@@ -65,8 +65,8 @@ template <typename T> bool SX126xInterface<T>::init()
 #endif
 
 #ifdef RF95_FAN_EN
-    digitalWrite(RF95_FAN_EN, HIGH);
     pinMode(RF95_FAN_EN, OUTPUT);
+    digitalWrite(RF95_FAN_EN, HIGH);
 #endif
 
 #if ARCH_PORTDUINO
@@ -265,6 +265,12 @@ template <typename T> bool SX126xInterface<T>::reconfigure()
     return true;
 }
 
+template <typename T> int16_t SX126xInterface<T>::getCurrentRSSI()
+{
+    float rssi = lora.getRSSI(false);
+    return (int16_t)round(rssi);
+}
+
 template <typename T> void SX126xInterface<T>::disableInterrupt()
 {
     lora.clearDio1Action();

src/mesh/SX126xInterface.h

@@ -41,6 +41,8 @@ template <class T> class SX126xInterface : public RadioLibInterface
      */
     T lora;
 
+    int16_t getCurrentRSSI() override;
+
     /**
      * Glue functions called from ISR land
      */

src/mesh/SX128xInterface.cpp

@@ -325,4 +325,10 @@ template <typename T> bool SX128xInterface<T>::sleep()
 
     return true;
 }
+
+template <typename T> int16_t SX128xInterface<T>::getCurrentRSSI()
+{
+    float rssi = lora.getRSSI(false);
+    return (int16_t)round(rssi);
+}
 #endif

src/mesh/SX128xInterface.h

@@ -35,6 +35,8 @@ template <class T> class SX128xInterface : public RadioLibInterface
      */
     T lora;
 
+    int16_t getCurrentRSSI() override;
+
     /**
      * Glue functions called from ISR land
      */

src/mesh/api/ethServerAPI.h

@@ -2,7 +2,11 @@
 
 #include "ServerAPI.h"
 #if !defined(USE_WS5500) && !defined(USE_CH390D)
+#if defined(USE_ARDUINO_ETHERNET)
+#include <Ethernet.h>
+#else
 #include <RAK13800_W5100S.h>
+#endif
 
 /**
  * Provides both debug printing and, if the client starts sending protobufs to us, switches to send/receive protobufs

src/mesh/compression/unishox2.h

@@ -1,347 +0,0 @@
-/*
- * Copyright (C) 2020 Siara Logics (cc)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @author Arundale Ramanathan
- *
- * Port for Particle (particle.io) / Aruino - Jonathan Greenblatt
- *
- * This file describes each function of the Unishox2 API \n
- * For finding out how this API can be used in your program, \n
- * please see test_unishox2.c.
- */
-
-#ifndef unishox2
-#define unishox2
-
-#define UNISHOX_VERSION "2.0" ///< Unicode spec version
-
-/**
- * Macro switch to enable/disable output buffer length parameter in low level api \n
- * Disabled by default \n
- * When this macro is defined, the all the API functions \n
- * except the simple API functions accept an additional parameter olen \n
- * that enables the developer to pass the size of the output buffer provided \n
- * so that the api function may not write beyond that length. \n
- * This can be disabled if the developer knows that the buffer provided is sufficient enough \n
- * so no additional parameter is passed and the program is faster since additional check \n
- * for output length is not performed at each step \n
- * The simple api, i.e. unishox2_(de)compress_simple will always omit the buffer length
- */
-#ifndef UNISHOX_API_WITH_OUTPUT_LEN
-#define UNISHOX_API_WITH_OUTPUT_LEN 1
-#endif
-
-/// Upto 8 bits of initial magic bit sequence can be included. Bit count can be specified with UNISHOX_MAGIC_BIT_LEN
-#ifndef UNISHOX_MAGIC_BITS
-#define UNISHOX_MAGIC_BITS 0xFF
-#endif
-
-/// Desired length of Magic bits defined by UNISHOX_MAGIC_BITS
-#ifdef UNISHOX_MAGIC_BIT_LEN
-#if UNISHOX_MAGIC_BIT_LEN < 0 || 9 <= UNISHOX_MAGIC_BIT_LEN
-#error "UNISHOX_MAGIC_BIT_LEN need between [0, 8)"
-#endif
-#else
-#define UNISHOX_MAGIC_BIT_LEN 1
-#endif
-
-// enum {USX_ALPHA = 0, USX_SYM, USX_NUM, USX_DICT, USX_DELTA};
-
-/// Default Horizontal codes. When composition of text is know beforehand, the other hcodes in this section can be used to achieve
-/// more compression.
-#define USX_HCODES_DFLT                                                                                                          \
-    (const unsigned char[])                                                                                                      \
-    {                                                                                                                            \
-        0x00, 0x40, 0x80, 0xC0, 0xE0                                                                                             \
-    }
-/// Length of each default hcode
-#define USX_HCODE_LENS_DFLT                                                                                                      \
-    (const unsigned char[])                                                                                                      \
-    {                                                                                                                            \
-        2, 2, 2, 3, 3                                                                                                            \
-    }
-
-/// Horizontal codes preset for English Alphabet content only
-#define USX_HCODES_ALPHA_ONLY                                                                                                    \
-    (const unsigned char[])                                                                                                      \
-    {                                                                                                                            \
-        0x00, 0x00, 0x00, 0x00, 0x00                                                                                             \
-    }
-/// Length of each Alpha only hcode
-#define USX_HCODE_LENS_ALPHA_ONLY                                                                                                \
-    (const unsigned char[])                                                                                                      \
-    {                                                                                                                            \
-        0, 0, 0, 0, 0                                                                                                            \
-    }
-
-/// Horizontal codes preset for Alpha Numeric content only
-#define USX_HCODES_ALPHA_NUM_ONLY                                                                                                \
-    (const unsigned char[])                                                                                                      \
-    {                                                                                                                            \
-        0x00, 0x00, 0x80, 0x00, 0x00                                                                                             \
-    }
-/// Length of each Alpha numeric hcode
-#define USX_HCODE_LENS_ALPHA_NUM_ONLY                                                                                            \
-    (const unsigned char[])                                                                                                      \
-    {                                                                                                                            \
-        1, 0, 1, 0, 0                                                                                                            \
-    }
-
-/// Horizontal codes preset for Alpha Numeric and Symbol content only
-#define USX_HCODES_ALPHA_NUM_SYM_ONLY                                                                                            \
-    (const unsigned char[])                                                                                                      \
-    {                                                                                                                            \
-        0x00, 0x80, 0xC0, 0x00, 0x00                                                                                             \
-    }
-/// Length of each Alpha numeric and symbol hcodes
-#define USX_HCODE_LENS_ALPHA_NUM_SYM_ONLY                                                                                        \
-    (const unsigned char[])                                                                                                      \
-    {                                                                                                                            \
-        1, 2, 2, 0, 0                                                                                                            \
-    }
-
-/// Horizontal codes preset favouring Alphabet content
-#define USX_HCODES_FAVOR_ALPHA                                                                                                   \
-    (const unsigned char[])                                                                                                      \
-    {                                                                                                                            \
-        0x00, 0x80, 0xA0, 0xC0, 0xE0                                                                                             \
-    }
-/// Length of each hcode favouring Alpha content
-#define USX_HCODE_LENS_FAVOR_ALPHA                                                                                               \
-    (const unsigned char[])                                                                                                      \
-    {                                                                                                                            \
-        1, 3, 3, 3, 3                                                                                                            \
-    }
-
-/// Horizontal codes preset favouring repeating sequences
-#define USX_HCODES_FAVOR_DICT                                                                                                    \
-    (const unsigned char[])                                                                                                      \
-    {                                                                                                                            \
-        0x00, 0x40, 0xC0, 0x80, 0xE0                                                                                             \
-    }
-/// Length of each hcode favouring repeating sequences
-#define USX_HCODE_LENS_FAVOR_DICT                                                                                                \
-    (const unsigned char[])                                                                                                      \
-    {                                                                                                                            \
-        2, 2, 3, 2, 3                                                                                                            \
-    }
-
-/// Horizontal codes preset favouring symbols
-#define USX_HCODES_FAVOR_SYM                                                                                                     \
-    (const unsigned char[])                                                                                                      \
-    {                                                                                                                            \
-        0x80, 0x00, 0xA0, 0xC0, 0xE0                                                                                             \
-    }
-/// Length of each hcode favouring symbols
-#define USX_HCODE_LENS_FAVOR_SYM                                                                                                 \
-    (const unsigned char[])                                                                                                      \
-    {                                                                                                                            \
-        3, 1, 3, 3, 3                                                                                                            \
-    }
-
-// #define USX_HCODES_FAVOR_UMLAUT {0x00, 0x40, 0xE0, 0xC0, 0x80}
-// #define USX_HCODE_LENS_FAVOR_UMLAUT {2, 2, 3, 3, 2}
-
-/// Horizontal codes preset favouring umlaut letters
-#define USX_HCODES_FAVOR_UMLAUT                                                                                                  \
-    (const unsigned char[])                                                                                                      \
-    {                                                                                                                            \
-        0x80, 0xA0, 0xC0, 0xE0, 0x00                                                                                             \
-    }
-/// Length of each hcode favouring umlaut letters
-#define USX_HCODE_LENS_FAVOR_UMLAUT                                                                                              \
-    (const unsigned char[])                                                                                                      \
-    {                                                                                                                            \
-        3, 3, 3, 3, 1                                                                                                            \
-    }
-
-/// Horizontal codes preset for no repeating sequences
-#define USX_HCODES_NO_DICT                                                                                                       \
-    (const unsigned char[])                                                                                                      \
-    {                                                                                                                            \
-        0x00, 0x40, 0x80, 0x00, 0xC0                                                                                             \
-    }
-/// Length of each hcode for no repeating sequences
-#define USX_HCODE_LENS_NO_DICT                                                                                                   \
-    (const unsigned char[])                                                                                                      \
-    {                                                                                                                            \
-        2, 2, 2, 0, 2                                                                                                            \
-    }
-
-/// Horizontal codes preset for no Unicode characters
-#define USX_HCODES_NO_UNI                                                                                                        \
-    (const unsigned char[])                                                                                                      \
-    {                                                                                                                            \
-        0x00, 0x40, 0x80, 0xC0, 0x00                                                                                             \
-    }
-/// Length of each hcode for no Unicode characters
-#define USX_HCODE_LENS_NO_UNI                                                                                                    \
-    (const unsigned char[])                                                                                                      \
-    {                                                                                                                            \
-        2, 2, 2, 2, 0                                                                                                            \
-    }
-
-extern const char *USX_FREQ_SEQ_DFLT[];
-extern const char *USX_FREQ_SEQ_TXT[];
-extern const char *USX_FREQ_SEQ_URL[];
-extern const char *USX_FREQ_SEQ_JSON[];
-extern const char *USX_FREQ_SEQ_HTML[];
-extern const char *USX_FREQ_SEQ_XML[];
-extern const char *USX_TEMPLATES[];
-
-/// Default preset parameter set. When composition of text is know beforehand, the other parameter sets in this section can be
-/// used to achieve more compression.
-#define USX_PSET_DFLT USX_HCODES_DFLT, USX_HCODE_LENS_DFLT, USX_FREQ_SEQ_DFLT, USX_TEMPLATES
-/// Preset parameter set for English Alphabet only content
-#define USX_PSET_ALPHA_ONLY USX_HCODES_ALPHA_ONLY, USX_HCODE_LENS_ALPHA_ONLY, USX_FREQ_SEQ_TXT, USX_TEMPLATES
-/// Preset parameter set for Alpha numeric content
-#define USX_PSET_ALPHA_NUM_ONLY USX_HCODES_ALPHA_NUM_ONLY, USX_HCODE_LENS_ALPHA_NUM_ONLY, USX_FREQ_SEQ_TXT, USX_TEMPLATES
-/// Preset parameter set for Alpha numeric and symbol content
-#define USX_PSET_ALPHA_NUM_SYM_ONLY                                                                                              \
-    USX_HCODES_ALPHA_NUM_SYM_ONLY, USX_HCODE_LENS_ALPHA_NUM_SYM_ONLY, USX_FREQ_SEQ_DFLT, USX_TEMPLATES
-/// Preset parameter set for Alpha numeric symbol content having predominantly text
-#define USX_PSET_ALPHA_NUM_SYM_ONLY_TXT                                                                                          \
-    USX_HCODES_ALPHA_NUM_SYM_ONLY, USX_HCODE_LENS_ALPHA_NUM_SYM_ONLY, USX_FREQ_SEQ_DFLT, USX_TEMPLATES
-/// Preset parameter set favouring Alphabet content
-#define USX_PSET_FAVOR_ALPHA USX_HCODES_FAVOR_ALPHA, USX_HCODE_LENS_FAVOR_ALPHA, USX_FREQ_SEQ_TXT, USX_TEMPLATES
-/// Preset parameter set favouring repeating sequences
-#define USX_PSET_FAVOR_DICT USX_HCODES_FAVOR_DICT, USX_HCODE_LENS_FAVOR_DICT, USX_FREQ_SEQ_DFLT, USX_TEMPLATES
-/// Preset parameter set favouring symbols
-#define USX_PSET_FAVOR_SYM USX_HCODES_FAVOR_SYM, USX_HCODE_LENS_FAVOR_SYM, USX_FREQ_SEQ_DFLT, USX_TEMPLATES
-/// Preset parameter set favouring unlaut letters
-#define USX_PSET_FAVOR_UMLAUT USX_HCODES_FAVOR_UMLAUT, USX_HCODE_LENS_FAVOR_UMLAUT, USX_FREQ_SEQ_DFLT, USX_TEMPLATES
-/// Preset parameter set for when there are no repeating sequences
-#define USX_PSET_NO_DICT USX_HCODES_NO_DICT, USX_HCODE_LENS_NO_DICT, USX_FREQ_SEQ_DFLT, USX_TEMPLATES
-/// Preset parameter set for when there are no unicode symbols
-#define USX_PSET_NO_UNI USX_HCODES_NO_UNI, USX_HCODE_LENS_NO_UNI, USX_FREQ_SEQ_DFLT, USX_TEMPLATES
-/// Preset parameter set for when there are no unicode symbols favouring text
-#define USX_PSET_NO_UNI_FAVOR_TEXT USX_HCODES_NO_UNI, USX_HCODE_LENS_NO_UNI, USX_FREQ_SEQ_TXT, USX_TEMPLATES
-/// Preset parameter set favouring URL content
-#define USX_PSET_URL USX_HCODES_DFLT, USX_HCODE_LENS_DFLT, USX_FREQ_SEQ_URL, USX_TEMPLATES
-/// Preset parameter set favouring JSON content
-#define USX_PSET_JSON USX_HCODES_DFLT, USX_HCODE_LENS_DFLT, USX_FREQ_SEQ_JSON, USX_TEMPLATES
-/// Preset parameter set favouring JSON content having no Unicode symbols
-#define USX_PSET_JSON_NO_UNI USX_HCODES_NO_UNI, USX_HCODE_LENS_NO_UNI, USX_FREQ_SEQ_JSON, USX_TEMPLATES
-/// Preset parameter set favouring XML content
-#define USX_PSET_XML USX_HCODES_DFLT, USX_HCODE_LENS_DFLT, USX_FREQ_SEQ_XML, USX_TEMPLATES
-/// Preset parameter set favouring HTML content
-#define USX_PSET_HTML USX_HCODES_DFLT, USX_HCODE_LENS_DFLT, USX_FREQ_SEQ_HTML, USX_TEMPLATES
-
-/**
- * This structure is used when a string array needs to be compressed.
- * This is passed as a parameter to the unishox2_decompress_lines() function
- */
-struct us_lnk_lst {
-    char *data;
-    struct us_lnk_lst *previous;
-};
-
-/**
- * This macro is for internal use, but builds upon the macro UNISHOX_API_WITH_OUTPUT_LEN
- * When the macro UNISHOX_API_WITH_OUTPUT_LEN is defined, the all the API functions
- * except the simple API functions accept an additional parameter olen
- * that enables the developer to pass the size of the output buffer provided
- * so that the api function may not write beyond that length.
- * This can be disabled if the developer knows that the buffer provided is sufficient enough
- * so no additional parameter is passed and the program is faster since additional check
- * for output length is not performed at each step
- */
-#if defined(UNISHOX_API_WITH_OUTPUT_LEN) && UNISHOX_API_WITH_OUTPUT_LEN != 0
-#define UNISHOX_API_OUT_AND_LEN(out, olen) out, olen
-#else
-#define UNISHOX_API_OUT_AND_LEN(out, olen) out
-#endif
-
-/**
- * Simple API for compressing a string
- * @param[in] in    Input ASCII / UTF-8 string
- * @param[in] len   length in bytes
- * @param[out] out  output buffer - should be large enough to hold compressed output
- */
-extern int unishox2_compress_simple(const char *in, int len, char *out);
-/**
- * Simple API for decompressing a string
- * @param[in] in    Input compressed bytes (output of unishox2_compress functions)
- * @param[in] len   length of 'in' in bytes
- * @param[out] out  output buffer for ASCII / UTF-8 string - should be large enough
- */
-extern int unishox2_decompress_simple(const char *in, int len, char *out);
-/**
- * Comprehensive API for compressing a string
- *
- * Presets are available for the last four parameters so they can be passed as single parameter. \n
- * See USX_PSET_* macros. Example call: \n
- *    unishox2_compress(in, len, out, olen, USX_PSET_ALPHA_ONLY);
- *
- * @param[in] in             Input ASCII / UTF-8 string
- * @param[in] len            length in bytes
- * @param[out] out           output buffer - should be large enough to hold compressed output
- * @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.
- */
-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[],
-                             const char *usx_templates[]);
-/**
- * Comprehensive API for de-compressing a string
- *
- * Presets are available for the last four parameters so they can be passed as single parameter. \n
- * See USX_PSET_* macros. Example call: \n
- *    unishox2_decompress(in, len, out, olen, USX_PSET_ALPHA_ONLY);
- *
- * @param[in] in             Input compressed bytes (output of unishox2_compress functions)
- * @param[in] len            length of 'in' in bytes
- * @param[out] out           output buffer - should be large enough to hold de-compressed output
- * @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.
- */
-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[],
-                               const char *usx_templates[]);
-/**
- * More Comprehensive API for compressing array of strings
- *
- * See unishox2_compress() function for parameter definitions. \n
- * This function takes an additional parameter, i.e. 'prev_lines' - the usx_lnk_lst structure \n
- * See -g parameter in test_unishox2.c to find out how this can be used. \n
- * This function is used when an array of strings need to be compressed \n
- * and stored in a compressed array of bytes for use as a constant in other programs \n
- * where each element of the array can be decompressed and used at runtime.
- */
-extern int unishox2_compress_lines(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[], const char *usx_templates[], struct us_lnk_lst *prev_lines);
-/**
- * More Comprehensive API for de-compressing array of strings \n
- * This function is not be used in conjuction with unishox2_compress_lines()
- *
- * See unishox2_decompress() function for parameter definitions. \n
- * Typically an array is compressed using unishox2_compress_lines() and \n
- * a header (.h) file is generated using the resultant compressed array. \n
- * This header file can be used in another program with another decompress \n
- * routine which takes this compressed array as parameter and index to be \n
- * decompressed.
- */
-extern int unishox2_decompress_lines(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[], const char *usx_templates[], struct us_lnk_lst *prev_lines);
-
-#endif

src/mesh/eth/ethClient.cpp

@@ -6,7 +6,13 @@
 #include "main.h"
 #include "mesh/api/ethServerAPI.h"
 #include "target_specific.h"
+#ifdef USE_ARDUINO_ETHERNET
+#include <Ethernet.h> // arduino-libraries/Ethernet — supports W5100/W5200/W5500
+// Shorter DHCP timeout so LoRa startup isn't blocked when no DHCP server is present.
+#define ETH_DHCP_TIMEOUT_MS 10000
+#else
 #include <RAK13800_W5100S.h>
+#endif
 #include <SPI.h>
 
 #if HAS_NETWORKING && !defined(USE_WS5500) && !defined(USE_CH390D)
@@ -69,6 +75,13 @@ static int32_t reconnectETH()
             delay(100);
 #endif
 
+#ifdef USE_ARDUINO_ETHERNET // Re-configure SPI0 for the W5500 module
+            SPI.setRX(ETH_SPI0_MISO);
+            SPI.setSCK(ETH_SPI0_SCK);
+            SPI.setTX(ETH_SPI0_MOSI);
+            SPI.begin();
+            Ethernet.init(PIN_ETHERNET_SS);
+#else
 #ifdef RAK11310
             ETH_SPI_PORT.setSCK(PIN_SPI0_SCK);
             ETH_SPI_PORT.setTX(PIN_SPI0_MOSI);
@@ -76,10 +89,15 @@ static int32_t reconnectETH()
             ETH_SPI_PORT.begin();
 #endif
             Ethernet.init(ETH_SPI_PORT, PIN_ETHERNET_SS);
+#endif
 
             int status = 0;
             if (config.network.address_mode == meshtastic_Config_NetworkConfig_AddressMode_DHCP) {
+#ifdef ETH_DHCP_TIMEOUT_MS
+                status = Ethernet.begin(expectedMac, ETH_DHCP_TIMEOUT_MS);
+#else
                 status = Ethernet.begin(expectedMac);
+#endif
             } else if (config.network.address_mode == meshtastic_Config_NetworkConfig_AddressMode_STATIC) {
                 Ethernet.begin(expectedMac, config.network.ipv4_config.ip, config.network.ipv4_config.dns,
                                config.network.ipv4_config.gateway, config.network.ipv4_config.subnet);
@@ -182,6 +200,13 @@ bool initEthernet()
         digitalWrite(PIN_ETHERNET_RESET, HIGH); // Reset Time.
 #endif
 
+#ifdef USE_ARDUINO_ETHERNET // Configure SPI0 for the W5500 module
+        SPI.setRX(ETH_SPI0_MISO);
+        SPI.setSCK(ETH_SPI0_SCK);
+        SPI.setTX(ETH_SPI0_MOSI);
+        SPI.begin();
+        Ethernet.init(PIN_ETHERNET_SS);
+#else
 #ifdef RAK11310 // Initialize the SPI port
         ETH_SPI_PORT.setSCK(PIN_SPI0_SCK);
         ETH_SPI_PORT.setTX(PIN_SPI0_MOSI);
@@ -189,6 +214,7 @@ bool initEthernet()
         ETH_SPI_PORT.begin();
 #endif
         Ethernet.init(ETH_SPI_PORT, PIN_ETHERNET_SS);
+#endif
 
         uint8_t mac[6];
 
@@ -201,7 +227,11 @@ bool initEthernet()
 
         if (config.network.address_mode == meshtastic_Config_NetworkConfig_AddressMode_DHCP) {
             LOG_INFO("Start Ethernet DHCP");
+#ifdef ETH_DHCP_TIMEOUT_MS
+            status = Ethernet.begin(mac, ETH_DHCP_TIMEOUT_MS);
+#else
             status = Ethernet.begin(mac);
+#endif
         } else if (config.network.address_mode == meshtastic_Config_NetworkConfig_AddressMode_STATIC) {
             LOG_INFO("Start Ethernet Static");
             Ethernet.begin(mac, config.network.ipv4_config.ip, config.network.ipv4_config.dns, config.network.ipv4_config.gateway,

src/mesh/generated/meshtastic/atak.pb.cpp

@@ -30,7 +30,7 @@ PB_BIND(meshtastic_AircraftTrack, meshtastic_AircraftTrack, AUTO)
 PB_BIND(meshtastic_CotGeoPoint, meshtastic_CotGeoPoint, AUTO)
 
 
-PB_BIND(meshtastic_DrawnShape, meshtastic_DrawnShape, 2)
+PB_BIND(meshtastic_DrawnShape, meshtastic_DrawnShape, AUTO)
 
 
 PB_BIND(meshtastic_Marker, meshtastic_Marker, AUTO)
@@ -63,6 +63,15 @@ PB_BIND(meshtastic_TAKEnvironment, meshtastic_TAKEnvironment, AUTO)
 PB_BIND(meshtastic_SensorFov, meshtastic_SensorFov, AUTO)
 
 
+PB_BIND(meshtastic_TakTalkMessage, meshtastic_TakTalkMessage, AUTO)
+
+
+PB_BIND(meshtastic_TakTalkRoomData, meshtastic_TakTalkRoomData, AUTO)
+
+
+PB_BIND(meshtastic_Marti, meshtastic_Marti, AUTO)
+
+
 PB_BIND(meshtastic_TAKPacketV2, meshtastic_TAKPacketV2, 2)
 
 

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

@@ -325,7 +325,15 @@ typedef enum _meshtastic_CotType {
     meshtastic_CotType_CotType_b_a_o_c = 123,
     /* t-s: Task / engage request. Structured payload carried via the new
  TaskRequest typed variant. */
-    meshtastic_CotType_CotType_t_s = 124
+    meshtastic_CotType_CotType_t_s = 124,
+    /* m-t-t: TAKTALK voice/text chat message. Payload carried via the
+ TakTalkMessage typed variant (text, chatroom_id, lang, from_voice). */
+    meshtastic_CotType_CotType_m_t_t = 125,
+    /* y-: TAKTALK room/membership broadcast. Payload carried via the
+ TakTalkRoomData typed variant (sender_callsign, room_id, room_name,
+ participants). The CoT type literally has a trailing dash and no
+ second atom — not a typo. */
+    meshtastic_CotType_CotType_y = 126
 } meshtastic_CotType;
 
 /* Geopoint and altitude source */
@@ -553,6 +561,18 @@ typedef struct _meshtastic_GeoChat {
     /* Receipt kind discriminator. See ReceiptType doc. Default ReceiptType_None
  means this is a regular chat message, not a receipt. */
     meshtastic_GeoChat_ReceiptType receipt_type;
+    /* BCP-47-ish language tag or human-readable name (e.g. "en", "English")
+ that the originator's TAKTALK plugin recorded for the message. */
+    pb_callback_t lang;
+    /* TAKTALK chatroom UUID (e.g. "30b2755c-c547-44ef-a0cc-cdbd8a15616f") that
+ the receiver's TAKTALK plugin uses to thread the message under the
+ right room. Resolved to a friendly name via TakTalkRoomData broadcasts. */
+    pb_callback_t room_id;
+    /* TAKTALK voice profile pointer. Often empty in practice (the empty
+ marker `<voice_profile_id/>` still signals TAKTALK origination), so
+ receivers should treat empty-but-present as the equivalent of the
+ marker rather than a missing field. */
+    pb_callback_t voice_profile_id;
 } meshtastic_GeoChat;
 
 /* ATAK Group
@@ -715,12 +735,7 @@ typedef struct _meshtastic_DrawnShape {
     uint32_t fill_argb;
     /* Whether labels are rendered on this shape. */
     bool labels_on;
-    /* Vertex list for polyline/polygon/rectangle shapes. Capped at 32 by
- the nanopb pool; senders MUST truncate longer inputs and set
- `truncated = true`. */
-    pb_size_t vertices_count;
-    meshtastic_CotGeoPoint vertices[32];
-    /* True if the sender truncated `vertices` to fit the pool. */
+    /* True if the sender truncated the vertex columns to fit the pool. */
     bool truncated; /* --- Bullseye-only fields. All ignored unless kind == Kind_Bullseye. --- */
     /* Bullseye distance in meters * 10 (e.g. 3285 = 328.5 m). 0 = unset. */
     uint32_t bullseye_distance_dm;
@@ -734,6 +749,8 @@ typedef struct _meshtastic_DrawnShape {
     uint8_t bullseye_flags;
     /* Bullseye reference UID (anchor marker). Empty = anchor is self. */
     char bullseye_uid_ref[48];
+    pb_callback_t vertex_lat_deltas;
+    pb_callback_t vertex_lon_deltas;
 } meshtastic_DrawnShape;
 
 /* Fixed point of interest: spot marker, waypoint, checkpoint, 2525 symbol,
@@ -1068,6 +1085,87 @@ typedef struct _meshtastic_SensorFov {
     pb_callback_t model;
 } meshtastic_SensorFov;
 
+/* TAKTALK chat message payload (CoT type m-t-t).
+
+ TAKTALK is an ATAK plugin for voice + text team messaging. The voice
+ audio stream goes over UDP/RTP and is NOT carried by the mesh — only
+ the text envelope (this message) is. `from_voice` marks messages sent
+ via push-to-talk speech-to-text so receivers can render a mic icon
+ next to the text.
+
+ Wire shape inside <event type="m-t-t">/<detail>:
+   <callsign>...</callsign>        - mapped to TAKPacketV2.callsign
+   <lang>English</lang>            - lang
+   <text>...</text>                - text
+   <chatroom-id>1</chatroom-id>    - chatroom_id
+   <voice/>                        - presence sets from_voice = true */
+typedef struct _meshtastic_TakTalkMessage {
+    /* The text body of the TAKTALK message (speech-to-text transcript when
+ from_voice = true, typed message otherwise). */
+    pb_callback_t text;
+    /* TAKTALK chatroom identifier. May be a short id like "1" for the
+ default room or a UUID like "30b2755c-c547-44ef-a0cc-cdbd8a15616f"
+ for custom rooms (resolved by TakTalkRoomData broadcasts).
+ Empty = broadcast room. */
+    pb_callback_t chatroom_id;
+    /* BCP-47-ish language tag or human-readable name (e.g. "en", "English").
+ Empty = unspecified. */
+    pb_callback_t lang;
+    /* True when the source CoT carried a <voice/> marker, i.e. the message
+ originated as push-to-talk speech-to-text. Lets receivers show a mic
+ icon. Proto3 only encodes when true so empty payload cost is 0 bytes. */
+    bool from_voice;
+} meshtastic_TakTalkMessage;
+
+/* TAKTALK room/membership broadcast (CoT type y-).
+
+ Announces a TAKTALK chatroom's friendly name and roster so peers can
+ resolve room UUIDs (used in TakTalkMessage.chatroom_id and
+ GeoChat.room_id) to a display name and participant list. Not a chat
+ message itself — these events are emitted by TAKTALK when rooms are
+ created or memberships change. */
+typedef struct _meshtastic_TakTalkRoomData {
+    /* Callsign of the device broadcasting the room state (typically the
+ room owner / latest writer).
+
+ DEPRECATED in v0.3.2: always equals TAKPacketV2.callsign, so the wire
+ byte was redundant. Builders stop emitting this field in v0.3.2;
+ parsers still read it for one release so v0.3.1-encoded packets decode
+ cleanly. To be removed entirely in v0.4.x. */
+    pb_callback_t sender_callsign;
+    /* Room UUID, matches TakTalkMessage.chatroom_id / GeoChat.room_id on
+ messages routed into this room. */
+    pb_callback_t room_id;
+    /* Friendly display name for the room (e.g. "test", "Alpha Team"). */
+    pb_callback_t room_name;
+    /* Member callsigns. Wire-encoded as repeated strings; the underlying
+ CoT carries them as a single <chatroom-participants>A,B,C</> element
+ which parsers split / builders join on ','. */
+    pb_callback_t participants;
+} meshtastic_TakTalkRoomData;
+
+/* ATAK directed-routing recipient list (CoT <marti><dest callsign='X'/>…</marti>).
+
+ Present when an event is addressed to specific TAK users rather than the
+ broadcast group. TAKTALK gates voice TTS on this element matching the
+ receiver's callsign; directed b-t-f chats use it for the same purpose. A
+ missing <marti> means "broadcast to all peers", which is the default for
+ PLI, alerts, drawings, and most situational-awareness events.
+
+ Carried as repeated strings (not indexes into a per-packet table) because
+ the typical event has 1-2 destinations and table overhead would erase the
+ savings. Receivers that need the original XML element rebuild it from
+ dest_callsign on emit. */
+typedef struct _meshtastic_Marti {
+    /* Recipient callsigns. Order is preserved end-to-end so receivers can show
+ primary-vs-cc distinction the same way ATAK does.
+
+ If dest_callsign is [TAKPacketV2.callsign] (self-addressed, unusual but
+ legal — e.g. ATAK echoing back to its own room), the builder still emits
+ the element so loopback shapes round-trip cleanly. */
+    pb_callback_t dest_callsign;
+} meshtastic_Marti;
+
 typedef PB_BYTES_ARRAY_T(220) meshtastic_TAKPacketV2_raw_detail_t;
 /* ATAK v2 packet with expanded CoT field support and zstd dictionary compression.
  Sent on ATAK_PLUGIN_V2 port. The wire payload is:
@@ -1089,7 +1187,14 @@ typedef struct _meshtastic_TAKPacketV2 {
     int32_t latitude_i;
     /* Longitude, multiply by 1e-7 to get degrees in floating point */
     int32_t longitude_i;
-    /* Altitude in meters (HAE) */
+    /* Altitude in meters (HAE). ATAK's "no altitude" sentinel is hae=9999999.0.
+
+ NOTE: an earlier v0.4.0 attempt made this `optional` to omit the 9999999
+ sentinel from the wire, but measurement showed it was net-negative: the
+ zstd dictionary already compresses the literal 9999999 to ~nothing, while
+ proto3 `optional` forces a genuine 0 m HAE (common on routes/drawings that
+ carry hae="0.0" or omit hae → parsed as 0) to encode explicitly (+2 bytes),
+ which REGRESSED the worst-case route fixture. Kept as a plain field. */
     int32_t altitude;
     /* Speed in cm/s */
     uint32_t speed;
@@ -1135,10 +1240,18 @@ typedef struct _meshtastic_TAKPacketV2 {
     /* Sensor field-of-view cone (camera, FLIR, laser, etc.). From <sensor>. */
     bool has_sensor_fov;
     meshtastic_SensorFov sensor_fov;
+    /* Directed-routing recipient list (CoT <marti><dest callsign='X'/>…</marti>).
+ Empty / unset = broadcast to all peers (the default for situational-awareness
+ events). Populated for TAKTALK m-t-t, directed b-t-f DMs, and any other CoT
+ shape that ATAK addresses to specific recipients. TAKTALK gates voice TTS
+ playback on this element matching the receiver's callsign, so dropping it
+ silently breaks voice messaging end-to-end.
+
+ See Marti. */
+    bool has_marti;
+    meshtastic_Marti marti;
     pb_size_t which_payload_variant;
     union {
-        /* Position report (true = PLI, no extra fields beyond the common ones above) */
-        bool pli;
         /* ATAK GeoChat message */
         meshtastic_GeoChat chat;
         /* Aircraft track data (ADS-B, military air) */
@@ -1163,6 +1276,14 @@ typedef struct _meshtastic_TAKPacketV2 {
         meshtastic_EmergencyAlert emergency;
         /* Task / engage request. See TaskRequest. */
         meshtastic_TaskRequest task;
+        /* TAKTALK chat message (CoT type m-t-t). See TakTalkMessage.
+     Voice audio itself rides UDP/RTP outside the mesh; this carries the
+     text envelope plus a from_voice marker for receiver UX. */
+        meshtastic_TakTalkMessage taktalk;
+        /* TAKTALK room/membership broadcast (CoT type y-). See TakTalkRoomData.
+     Resolves room UUIDs (used in TakTalkMessage.chatroom_id and
+     GeoChat.room_id) to display name + roster on receivers. */
+        meshtastic_TakTalkRoomData taktalk_room;
     } payload_variant;
 } meshtastic_TAKPacketV2;
 
@@ -1185,8 +1306,8 @@ extern "C" {
 #define _meshtastic_CotHow_ARRAYSIZE ((meshtastic_CotHow)(meshtastic_CotHow_CotHow_m_s+1))
 
 #define _meshtastic_CotType_MIN meshtastic_CotType_CotType_Other
-#define _meshtastic_CotType_MAX meshtastic_CotType_CotType_t_s
-#define _meshtastic_CotType_ARRAYSIZE ((meshtastic_CotType)(meshtastic_CotType_CotType_t_s+1))
+#define _meshtastic_CotType_MAX meshtastic_CotType_CotType_y
+#define _meshtastic_CotType_ARRAYSIZE ((meshtastic_CotType)(meshtastic_CotType_CotType_y+1))
 
 #define _meshtastic_GeoPointSource_MIN meshtastic_GeoPointSource_GeoPointSource_Unspecified
 #define _meshtastic_GeoPointSource_MAX meshtastic_GeoPointSource_GeoPointSource_NETWORK
@@ -1282,6 +1403,9 @@ extern "C" {
 
 #define meshtastic_SensorFov_type_ENUMTYPE meshtastic_SensorFov_SensorType
 
+
+
+
 #define meshtastic_TAKPacketV2_cot_type_id_ENUMTYPE meshtastic_CotType
 #define meshtastic_TAKPacketV2_how_ENUMTYPE meshtastic_CotHow
 #define meshtastic_TAKPacketV2_team_ENUMTYPE meshtastic_Team
@@ -1292,14 +1416,14 @@ extern "C" {
 
 /* Initializer values for message structs */
 #define meshtastic_TAKPacket_init_default        {0, false, meshtastic_Contact_init_default, false, meshtastic_Group_init_default, false, meshtastic_Status_init_default, 0, {meshtastic_PLI_init_default}}
-#define meshtastic_GeoChat_init_default          {"", false, "", false, "", "", _meshtastic_GeoChat_ReceiptType_MIN}
+#define meshtastic_GeoChat_init_default          {"", false, "", false, "", "", _meshtastic_GeoChat_ReceiptType_MIN, {{NULL}, NULL}, {{NULL}, NULL}, {{NULL}, NULL}}
 #define meshtastic_Group_init_default            {_meshtastic_MemberRole_MIN, _meshtastic_Team_MIN}
 #define meshtastic_Status_init_default           {0}
 #define meshtastic_Contact_init_default          {"", ""}
 #define meshtastic_PLI_init_default              {0, 0, 0, 0, 0}
 #define meshtastic_AircraftTrack_init_default    {"", "", "", "", 0, "", 0, 0, ""}
 #define meshtastic_CotGeoPoint_init_default      {0, 0}
-#define meshtastic_DrawnShape_init_default       {_meshtastic_DrawnShape_Kind_MIN, _meshtastic_DrawnShape_StyleMode_MIN, 0, 0, 0, _meshtastic_Team_MIN, 0, 0, _meshtastic_Team_MIN, 0, 0, 0, {meshtastic_CotGeoPoint_init_default, meshtastic_CotGeoPoint_init_default, meshtastic_CotGeoPoint_init_default, meshtastic_CotGeoPoint_init_default, meshtastic_CotGeoPoint_init_default, meshtastic_CotGeoPoint_init_default, meshtastic_CotGeoPoint_init_default, meshtastic_CotGeoPoint_init_default, meshtastic_CotGeoPoint_init_default, meshtastic_CotGeoPoint_init_default, meshtastic_CotGeoPoint_init_default, meshtastic_CotGeoPoint_init_default, meshtastic_CotGeoPoint_init_default, meshtastic_CotGeoPoint_init_default, meshtastic_CotGeoPoint_init_default, meshtastic_CotGeoPoint_init_default, meshtastic_CotGeoPoint_init_default, meshtastic_CotGeoPoint_init_default, meshtastic_CotGeoPoint_init_default, meshtastic_CotGeoPoint_init_default, meshtastic_CotGeoPoint_init_default, meshtastic_CotGeoPoint_init_default, meshtastic_CotGeoPoint_init_default, meshtastic_CotGeoPoint_init_default, meshtastic_CotGeoPoint_init_default, meshtastic_CotGeoPoint_init_default, meshtastic_CotGeoPoint_init_default, meshtastic_CotGeoPoint_init_default, meshtastic_CotGeoPoint_init_default, meshtastic_CotGeoPoint_init_default, meshtastic_CotGeoPoint_init_default, meshtastic_CotGeoPoint_init_default}, 0, 0, 0, 0, ""}
+#define meshtastic_DrawnShape_init_default       {_meshtastic_DrawnShape_Kind_MIN, _meshtastic_DrawnShape_StyleMode_MIN, 0, 0, 0, _meshtastic_Team_MIN, 0, 0, _meshtastic_Team_MIN, 0, 0, 0, 0, 0, 0, "", {{NULL}, NULL}, {{NULL}, NULL}}
 #define meshtastic_Marker_init_default           {_meshtastic_Marker_Kind_MIN, _meshtastic_Team_MIN, 0, 0, "", "", "", ""}
 #define meshtastic_RangeAndBearing_init_default  {false, meshtastic_CotGeoPoint_init_default, "", 0, 0, _meshtastic_Team_MIN, 0, 0}
 #define meshtastic_Route_init_default            {_meshtastic_Route_Method_MIN, _meshtastic_Route_Direction_MIN, "", 0, 0, {meshtastic_Route_Link_init_default, meshtastic_Route_Link_init_default, meshtastic_Route_Link_init_default, meshtastic_Route_Link_init_default, meshtastic_Route_Link_init_default, meshtastic_Route_Link_init_default, meshtastic_Route_Link_init_default, meshtastic_Route_Link_init_default, meshtastic_Route_Link_init_default, meshtastic_Route_Link_init_default, meshtastic_Route_Link_init_default, meshtastic_Route_Link_init_default, meshtastic_Route_Link_init_default, meshtastic_Route_Link_init_default, meshtastic_Route_Link_init_default, meshtastic_Route_Link_init_default}, 0}
@@ -1310,16 +1434,19 @@ extern "C" {
 #define meshtastic_TaskRequest_init_default      {"", "", "", _meshtastic_TaskRequest_Priority_MIN, _meshtastic_TaskRequest_Status_MIN, ""}
 #define meshtastic_TAKEnvironment_init_default   {0, 0, 0}
 #define meshtastic_SensorFov_init_default        {_meshtastic_SensorFov_SensorType_MIN, 0, false, 0, 0, 0, 0, 0, {{NULL}, NULL}}
-#define meshtastic_TAKPacketV2_init_default      {_meshtastic_CotType_MIN, _meshtastic_CotHow_MIN, "", _meshtastic_Team_MIN, _meshtastic_MemberRole_MIN, 0, 0, 0, 0, 0, 0, _meshtastic_GeoPointSource_MIN, _meshtastic_GeoPointSource_MIN, "", "", 0, "", "", "", "", "", "", "", {{NULL}, NULL}, false, meshtastic_TAKEnvironment_init_default, false, meshtastic_SensorFov_init_default, 0, {0}}
+#define meshtastic_TakTalkMessage_init_default   {{{NULL}, NULL}, {{NULL}, NULL}, {{NULL}, NULL}, 0}
+#define meshtastic_TakTalkRoomData_init_default  {{{NULL}, NULL}, {{NULL}, NULL}, {{NULL}, NULL}, {{NULL}, NULL}}
+#define meshtastic_Marti_init_default            {{{NULL}, NULL}}
+#define meshtastic_TAKPacketV2_init_default      {_meshtastic_CotType_MIN, _meshtastic_CotHow_MIN, "", _meshtastic_Team_MIN, _meshtastic_MemberRole_MIN, 0, 0, 0, 0, 0, 0, _meshtastic_GeoPointSource_MIN, _meshtastic_GeoPointSource_MIN, "", "", 0, "", "", "", "", "", "", "", {{NULL}, NULL}, false, meshtastic_TAKEnvironment_init_default, false, meshtastic_SensorFov_init_default, false, meshtastic_Marti_init_default, 0, {meshtastic_GeoChat_init_default}}
 #define meshtastic_TAKPacket_init_zero           {0, false, meshtastic_Contact_init_zero, false, meshtastic_Group_init_zero, false, meshtastic_Status_init_zero, 0, {meshtastic_PLI_init_zero}}
-#define meshtastic_GeoChat_init_zero             {"", false, "", false, "", "", _meshtastic_GeoChat_ReceiptType_MIN}
+#define meshtastic_GeoChat_init_zero             {"", false, "", false, "", "", _meshtastic_GeoChat_ReceiptType_MIN, {{NULL}, NULL}, {{NULL}, NULL}, {{NULL}, NULL}}
 #define meshtastic_Group_init_zero               {_meshtastic_MemberRole_MIN, _meshtastic_Team_MIN}
 #define meshtastic_Status_init_zero              {0}
 #define meshtastic_Contact_init_zero             {"", ""}
 #define meshtastic_PLI_init_zero                 {0, 0, 0, 0, 0}
 #define meshtastic_AircraftTrack_init_zero       {"", "", "", "", 0, "", 0, 0, ""}
 #define meshtastic_CotGeoPoint_init_zero         {0, 0}
-#define meshtastic_DrawnShape_init_zero          {_meshtastic_DrawnShape_Kind_MIN, _meshtastic_DrawnShape_StyleMode_MIN, 0, 0, 0, _meshtastic_Team_MIN, 0, 0, _meshtastic_Team_MIN, 0, 0, 0, {meshtastic_CotGeoPoint_init_zero, meshtastic_CotGeoPoint_init_zero, meshtastic_CotGeoPoint_init_zero, meshtastic_CotGeoPoint_init_zero, meshtastic_CotGeoPoint_init_zero, meshtastic_CotGeoPoint_init_zero, meshtastic_CotGeoPoint_init_zero, meshtastic_CotGeoPoint_init_zero, meshtastic_CotGeoPoint_init_zero, meshtastic_CotGeoPoint_init_zero, meshtastic_CotGeoPoint_init_zero, meshtastic_CotGeoPoint_init_zero, meshtastic_CotGeoPoint_init_zero, meshtastic_CotGeoPoint_init_zero, meshtastic_CotGeoPoint_init_zero, meshtastic_CotGeoPoint_init_zero, meshtastic_CotGeoPoint_init_zero, meshtastic_CotGeoPoint_init_zero, meshtastic_CotGeoPoint_init_zero, meshtastic_CotGeoPoint_init_zero, meshtastic_CotGeoPoint_init_zero, meshtastic_CotGeoPoint_init_zero, meshtastic_CotGeoPoint_init_zero, meshtastic_CotGeoPoint_init_zero, meshtastic_CotGeoPoint_init_zero, meshtastic_CotGeoPoint_init_zero, meshtastic_CotGeoPoint_init_zero, meshtastic_CotGeoPoint_init_zero, meshtastic_CotGeoPoint_init_zero, meshtastic_CotGeoPoint_init_zero, meshtastic_CotGeoPoint_init_zero, meshtastic_CotGeoPoint_init_zero}, 0, 0, 0, 0, ""}
+#define meshtastic_DrawnShape_init_zero          {_meshtastic_DrawnShape_Kind_MIN, _meshtastic_DrawnShape_StyleMode_MIN, 0, 0, 0, _meshtastic_Team_MIN, 0, 0, _meshtastic_Team_MIN, 0, 0, 0, 0, 0, 0, "", {{NULL}, NULL}, {{NULL}, NULL}}
 #define meshtastic_Marker_init_zero              {_meshtastic_Marker_Kind_MIN, _meshtastic_Team_MIN, 0, 0, "", "", "", ""}
 #define meshtastic_RangeAndBearing_init_zero     {false, meshtastic_CotGeoPoint_init_zero, "", 0, 0, _meshtastic_Team_MIN, 0, 0}
 #define meshtastic_Route_init_zero               {_meshtastic_Route_Method_MIN, _meshtastic_Route_Direction_MIN, "", 0, 0, {meshtastic_Route_Link_init_zero, meshtastic_Route_Link_init_zero, meshtastic_Route_Link_init_zero, meshtastic_Route_Link_init_zero, meshtastic_Route_Link_init_zero, meshtastic_Route_Link_init_zero, meshtastic_Route_Link_init_zero, meshtastic_Route_Link_init_zero, meshtastic_Route_Link_init_zero, meshtastic_Route_Link_init_zero, meshtastic_Route_Link_init_zero, meshtastic_Route_Link_init_zero, meshtastic_Route_Link_init_zero, meshtastic_Route_Link_init_zero, meshtastic_Route_Link_init_zero, meshtastic_Route_Link_init_zero}, 0}
@@ -1330,7 +1457,10 @@ extern "C" {
 #define meshtastic_TaskRequest_init_zero         {"", "", "", _meshtastic_TaskRequest_Priority_MIN, _meshtastic_TaskRequest_Status_MIN, ""}
 #define meshtastic_TAKEnvironment_init_zero      {0, 0, 0}
 #define meshtastic_SensorFov_init_zero           {_meshtastic_SensorFov_SensorType_MIN, 0, false, 0, 0, 0, 0, 0, {{NULL}, NULL}}
-#define meshtastic_TAKPacketV2_init_zero         {_meshtastic_CotType_MIN, _meshtastic_CotHow_MIN, "", _meshtastic_Team_MIN, _meshtastic_MemberRole_MIN, 0, 0, 0, 0, 0, 0, _meshtastic_GeoPointSource_MIN, _meshtastic_GeoPointSource_MIN, "", "", 0, "", "", "", "", "", "", "", {{NULL}, NULL}, false, meshtastic_TAKEnvironment_init_zero, false, meshtastic_SensorFov_init_zero, 0, {0}}
+#define meshtastic_TakTalkMessage_init_zero      {{{NULL}, NULL}, {{NULL}, NULL}, {{NULL}, NULL}, 0}
+#define meshtastic_TakTalkRoomData_init_zero     {{{NULL}, NULL}, {{NULL}, NULL}, {{NULL}, NULL}, {{NULL}, NULL}}
+#define meshtastic_Marti_init_zero               {{{NULL}, NULL}}
+#define meshtastic_TAKPacketV2_init_zero         {_meshtastic_CotType_MIN, _meshtastic_CotHow_MIN, "", _meshtastic_Team_MIN, _meshtastic_MemberRole_MIN, 0, 0, 0, 0, 0, 0, _meshtastic_GeoPointSource_MIN, _meshtastic_GeoPointSource_MIN, "", "", 0, "", "", "", "", "", "", "", {{NULL}, NULL}, false, meshtastic_TAKEnvironment_init_zero, false, meshtastic_SensorFov_init_zero, false, meshtastic_Marti_init_zero, 0, {meshtastic_GeoChat_init_zero}}
 
 /* Field tags (for use in manual encoding/decoding) */
 #define meshtastic_GeoChat_message_tag           1
@@ -1338,6 +1468,9 @@ extern "C" {
 #define meshtastic_GeoChat_to_callsign_tag       3
 #define meshtastic_GeoChat_receipt_for_uid_tag   4
 #define meshtastic_GeoChat_receipt_type_tag      5
+#define meshtastic_GeoChat_lang_tag              6
+#define meshtastic_GeoChat_room_id_tag           7
+#define meshtastic_GeoChat_voice_profile_id_tag  8
 #define meshtastic_Group_role_tag                1
 #define meshtastic_Group_team_tag                2
 #define meshtastic_Status_battery_tag            1
@@ -1377,12 +1510,13 @@ extern "C" {
 #define meshtastic_DrawnShape_fill_color_tag     9
 #define meshtastic_DrawnShape_fill_argb_tag      10
 #define meshtastic_DrawnShape_labels_on_tag      11
-#define meshtastic_DrawnShape_vertices_tag       12
 #define meshtastic_DrawnShape_truncated_tag      13
 #define meshtastic_DrawnShape_bullseye_distance_dm_tag 14
 #define meshtastic_DrawnShape_bullseye_bearing_ref_tag 15
 #define meshtastic_DrawnShape_bullseye_flags_tag 16
 #define meshtastic_DrawnShape_bullseye_uid_ref_tag 17
+#define meshtastic_DrawnShape_vertex_lat_deltas_tag 18
+#define meshtastic_DrawnShape_vertex_lon_deltas_tag 19
 #define meshtastic_Marker_kind_tag               1
 #define meshtastic_Marker_color_tag              2
 #define meshtastic_Marker_color_argb_tag         3
@@ -1467,6 +1601,15 @@ extern "C" {
 #define meshtastic_SensorFov_elevation_deg_tag   6
 #define meshtastic_SensorFov_roll_deg_tag        7
 #define meshtastic_SensorFov_model_tag           8
+#define meshtastic_TakTalkMessage_text_tag       1
+#define meshtastic_TakTalkMessage_chatroom_id_tag 2
+#define meshtastic_TakTalkMessage_lang_tag       3
+#define meshtastic_TakTalkMessage_from_voice_tag 4
+#define meshtastic_TakTalkRoomData_sender_callsign_tag 1
+#define meshtastic_TakTalkRoomData_room_id_tag   2
+#define meshtastic_TakTalkRoomData_room_name_tag 3
+#define meshtastic_TakTalkRoomData_participants_tag 4
+#define meshtastic_Marti_dest_callsign_tag       1
 #define meshtastic_TAKPacketV2_cot_type_id_tag   1
 #define meshtastic_TAKPacketV2_how_tag           2
 #define meshtastic_TAKPacketV2_callsign_tag      3
@@ -1493,7 +1636,7 @@ extern "C" {
 #define meshtastic_TAKPacketV2_remarks_tag       24
 #define meshtastic_TAKPacketV2_environment_tag   25
 #define meshtastic_TAKPacketV2_sensor_fov_tag    26
-#define meshtastic_TAKPacketV2_pli_tag           30
+#define meshtastic_TAKPacketV2_marti_tag         29
 #define meshtastic_TAKPacketV2_chat_tag          31
 #define meshtastic_TAKPacketV2_aircraft_tag      32
 #define meshtastic_TAKPacketV2_raw_detail_tag    33
@@ -1504,6 +1647,8 @@ extern "C" {
 #define meshtastic_TAKPacketV2_casevac_tag       38
 #define meshtastic_TAKPacketV2_emergency_tag     39
 #define meshtastic_TAKPacketV2_task_tag          40
+#define meshtastic_TAKPacketV2_taktalk_tag       41
+#define meshtastic_TAKPacketV2_taktalk_room_tag  42
 
 /* Struct field encoding specification for nanopb */
 #define meshtastic_TAKPacket_FIELDLIST(X, a) \
@@ -1527,8 +1672,11 @@ X(a, STATIC,   SINGULAR, STRING,   message,           1) \
 X(a, STATIC,   OPTIONAL, STRING,   to,                2) \
 X(a, STATIC,   OPTIONAL, STRING,   to_callsign,       3) \
 X(a, STATIC,   SINGULAR, STRING,   receipt_for_uid,   4) \
-X(a, STATIC,   SINGULAR, UENUM,    receipt_type,      5)
-#define meshtastic_GeoChat_CALLBACK NULL
+X(a, STATIC,   SINGULAR, UENUM,    receipt_type,      5) \
+X(a, CALLBACK, OPTIONAL, STRING,   lang,              6) \
+X(a, CALLBACK, OPTIONAL, STRING,   room_id,           7) \
+X(a, CALLBACK, OPTIONAL, STRING,   voice_profile_id,   8)
+#define meshtastic_GeoChat_CALLBACK pb_default_field_callback
 #define meshtastic_GeoChat_DEFAULT NULL
 
 #define meshtastic_Group_FIELDLIST(X, a) \
@@ -1588,15 +1736,15 @@ X(a, STATIC,   SINGULAR, UINT32,   stroke_weight_x10,   8) \
 X(a, STATIC,   SINGULAR, UENUM,    fill_color,        9) \
 X(a, STATIC,   SINGULAR, FIXED32,  fill_argb,        10) \
 X(a, STATIC,   SINGULAR, BOOL,     labels_on,        11) \
-X(a, STATIC,   REPEATED, MESSAGE,  vertices,         12) \
 X(a, STATIC,   SINGULAR, BOOL,     truncated,        13) \
 X(a, STATIC,   SINGULAR, UINT32,   bullseye_distance_dm,  14) \
 X(a, STATIC,   SINGULAR, UINT32,   bullseye_bearing_ref,  15) \
 X(a, STATIC,   SINGULAR, UINT32,   bullseye_flags,   16) \
-X(a, STATIC,   SINGULAR, STRING,   bullseye_uid_ref,  17)
-#define meshtastic_DrawnShape_CALLBACK NULL
+X(a, STATIC,   SINGULAR, STRING,   bullseye_uid_ref,  17) \
+X(a, CALLBACK, REPEATED, SINT32,   vertex_lat_deltas,  18) \
+X(a, CALLBACK, REPEATED, SINT32,   vertex_lon_deltas,  19)
+#define meshtastic_DrawnShape_CALLBACK pb_default_field_callback
 #define meshtastic_DrawnShape_DEFAULT NULL
-#define meshtastic_DrawnShape_vertices_MSGTYPE meshtastic_CotGeoPoint
 
 #define meshtastic_Marker_FIELDLIST(X, a) \
 X(a, STATIC,   SINGULAR, UENUM,    kind,              1) \
@@ -1726,6 +1874,27 @@ X(a, CALLBACK, SINGULAR, STRING,   model,             8)
 #define meshtastic_SensorFov_CALLBACK pb_default_field_callback
 #define meshtastic_SensorFov_DEFAULT NULL
 
+#define meshtastic_TakTalkMessage_FIELDLIST(X, a) \
+X(a, CALLBACK, SINGULAR, STRING,   text,              1) \
+X(a, CALLBACK, SINGULAR, STRING,   chatroom_id,       2) \
+X(a, CALLBACK, SINGULAR, STRING,   lang,              3) \
+X(a, STATIC,   SINGULAR, BOOL,     from_voice,        4)
+#define meshtastic_TakTalkMessage_CALLBACK pb_default_field_callback
+#define meshtastic_TakTalkMessage_DEFAULT NULL
+
+#define meshtastic_TakTalkRoomData_FIELDLIST(X, a) \
+X(a, CALLBACK, SINGULAR, STRING,   sender_callsign,   1) \
+X(a, CALLBACK, SINGULAR, STRING,   room_id,           2) \
+X(a, CALLBACK, SINGULAR, STRING,   room_name,         3) \
+X(a, CALLBACK, REPEATED, STRING,   participants,      4)
+#define meshtastic_TakTalkRoomData_CALLBACK pb_default_field_callback
+#define meshtastic_TakTalkRoomData_DEFAULT NULL
+
+#define meshtastic_Marti_FIELDLIST(X, a) \
+X(a, CALLBACK, REPEATED, STRING,   dest_callsign,     1)
+#define meshtastic_Marti_CALLBACK pb_default_field_callback
+#define meshtastic_Marti_DEFAULT NULL
+
 #define meshtastic_TAKPacketV2_FIELDLIST(X, a) \
 X(a, STATIC,   SINGULAR, UENUM,    cot_type_id,       1) \
 X(a, STATIC,   SINGULAR, UENUM,    how,               2) \
@@ -1753,7 +1922,7 @@ X(a, STATIC,   SINGULAR, STRING,   cot_type_str,     23) \
 X(a, CALLBACK, SINGULAR, STRING,   remarks,          24) \
 X(a, STATIC,   OPTIONAL, MESSAGE,  environment,      25) \
 X(a, STATIC,   OPTIONAL, MESSAGE,  sensor_fov,       26) \
-X(a, STATIC,   ONEOF,    BOOL,     (payload_variant,pli,payload_variant.pli),  30) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  marti,            29) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,chat,payload_variant.chat),  31) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,aircraft,payload_variant.aircraft),  32) \
 X(a, STATIC,   ONEOF,    BYTES,    (payload_variant,raw_detail,payload_variant.raw_detail),  33) \
@@ -1763,11 +1932,14 @@ X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,rab,payload_variant.rab),  3
 X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,route,payload_variant.route),  37) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,casevac,payload_variant.casevac),  38) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,emergency,payload_variant.emergency),  39) \
-X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,task,payload_variant.task),  40)
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,task,payload_variant.task),  40) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,taktalk,payload_variant.taktalk),  41) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,taktalk_room,payload_variant.taktalk_room),  42)
 #define meshtastic_TAKPacketV2_CALLBACK pb_default_field_callback
 #define meshtastic_TAKPacketV2_DEFAULT NULL
 #define meshtastic_TAKPacketV2_environment_MSGTYPE meshtastic_TAKEnvironment
 #define meshtastic_TAKPacketV2_sensor_fov_MSGTYPE meshtastic_SensorFov
+#define meshtastic_TAKPacketV2_marti_MSGTYPE meshtastic_Marti
 #define meshtastic_TAKPacketV2_payload_variant_chat_MSGTYPE meshtastic_GeoChat
 #define meshtastic_TAKPacketV2_payload_variant_aircraft_MSGTYPE meshtastic_AircraftTrack
 #define meshtastic_TAKPacketV2_payload_variant_shape_MSGTYPE meshtastic_DrawnShape
@@ -1777,6 +1949,8 @@ X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,task,payload_variant.task),
 #define meshtastic_TAKPacketV2_payload_variant_casevac_MSGTYPE meshtastic_CasevacReport
 #define meshtastic_TAKPacketV2_payload_variant_emergency_MSGTYPE meshtastic_EmergencyAlert
 #define meshtastic_TAKPacketV2_payload_variant_task_MSGTYPE meshtastic_TaskRequest
+#define meshtastic_TAKPacketV2_payload_variant_taktalk_MSGTYPE meshtastic_TakTalkMessage
+#define meshtastic_TAKPacketV2_payload_variant_taktalk_room_MSGTYPE meshtastic_TakTalkRoomData
 
 extern const pb_msgdesc_t meshtastic_TAKPacket_msg;
 extern const pb_msgdesc_t meshtastic_GeoChat_msg;
@@ -1797,6 +1971,9 @@ extern const pb_msgdesc_t meshtastic_EmergencyAlert_msg;
 extern const pb_msgdesc_t meshtastic_TaskRequest_msg;
 extern const pb_msgdesc_t meshtastic_TAKEnvironment_msg;
 extern const pb_msgdesc_t meshtastic_SensorFov_msg;
+extern const pb_msgdesc_t meshtastic_TakTalkMessage_msg;
+extern const pb_msgdesc_t meshtastic_TakTalkRoomData_msg;
+extern const pb_msgdesc_t meshtastic_Marti_msg;
 extern const pb_msgdesc_t meshtastic_TAKPacketV2_msg;
 
 /* Defines for backwards compatibility with code written before nanopb-0.4.0 */
@@ -1819,20 +1996,27 @@ extern const pb_msgdesc_t meshtastic_TAKPacketV2_msg;
 #define meshtastic_TaskRequest_fields &meshtastic_TaskRequest_msg
 #define meshtastic_TAKEnvironment_fields &meshtastic_TAKEnvironment_msg
 #define meshtastic_SensorFov_fields &meshtastic_SensorFov_msg
+#define meshtastic_TakTalkMessage_fields &meshtastic_TakTalkMessage_msg
+#define meshtastic_TakTalkRoomData_fields &meshtastic_TakTalkRoomData_msg
+#define meshtastic_Marti_fields &meshtastic_Marti_msg
 #define meshtastic_TAKPacketV2_fields &meshtastic_TAKPacketV2_msg
 
 /* Maximum encoded size of messages (where known) */
+/* meshtastic_TAKPacket_size depends on runtime parameters */
+/* meshtastic_GeoChat_size depends on runtime parameters */
+/* meshtastic_DrawnShape_size depends on runtime parameters */
 /* meshtastic_CasevacReport_size depends on runtime parameters */
 /* meshtastic_ZMistEntry_size depends on runtime parameters */
 /* meshtastic_SensorFov_size depends on runtime parameters */
+/* meshtastic_TakTalkMessage_size depends on runtime parameters */
+/* meshtastic_TakTalkRoomData_size depends on runtime parameters */
+/* meshtastic_Marti_size depends on runtime parameters */
 /* meshtastic_TAKPacketV2_size depends on runtime parameters */
 #define MESHTASTIC_MESHTASTIC_ATAK_PB_H_MAX_SIZE meshtastic_Route_size
 #define meshtastic_AircraftTrack_size            134
 #define meshtastic_Contact_size                  242
 #define meshtastic_CotGeoPoint_size              12
-#define meshtastic_DrawnShape_size               553
 #define meshtastic_EmergencyAlert_size           100
-#define meshtastic_GeoChat_size                  495
 #define meshtastic_Group_size                    4
 #define meshtastic_Marker_size                   191
 #define meshtastic_PLI_size                      31
@@ -1841,7 +2025,6 @@ extern const pb_msgdesc_t meshtastic_TAKPacketV2_msg;
 #define meshtastic_Route_size                    1379
 #define meshtastic_Status_size                   3
 #define meshtastic_TAKEnvironment_size           18
-#define meshtastic_TAKPacket_size                756
 #define meshtastic_TaskRequest_size              132
 
 #ifdef __cplusplus

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

@@ -290,15 +290,26 @@ typedef enum _meshtastic_Config_LoRaConfig_RegionCode {
     meshtastic_Config_LoRaConfig_RegionCode_BR_902 = 26,
     /* ITU Region 1 Amateur Radio 2m band (144-146 MHz) */
     meshtastic_Config_LoRaConfig_RegionCode_ITU1_2M = 27,
-    /* ITU Region 2 / 3 Amateur Radio 2m band (144-148 MHz) */
-    meshtastic_Config_LoRaConfig_RegionCode_ITU23_2M = 28,
+    /* ITU Region 2 Amateur Radio 2m band (144-148 MHz) */
+    meshtastic_Config_LoRaConfig_RegionCode_ITU2_2M = 28,
     /* EU 866MHz band (Band no. 47b of 2006/771/EC and subsequent amendments) for Non-specific short-range devices (SRD) */
     meshtastic_Config_LoRaConfig_RegionCode_EU_866 = 29,
     /* EU 874MHz and 917MHz bands (Band no. 1 and 4 of 2022/172/EC and subsequent amendments) for Non-specific short-range devices (SRD) */
     meshtastic_Config_LoRaConfig_RegionCode_EU_874 = 30,
     meshtastic_Config_LoRaConfig_RegionCode_EU_917 = 31,
     /* EU 868MHz band, with narrow presets */
-    meshtastic_Config_LoRaConfig_RegionCode_EU_N_868 = 32
+    meshtastic_Config_LoRaConfig_RegionCode_EU_N_868 = 32,
+    /* ITU Region 3 Amateur Radio 2m band (144-148 MHz) */
+    meshtastic_Config_LoRaConfig_RegionCode_ITU3_2M = 33,
+    /* ITU Region 1 Amateur Radio 70cm band (430-440 MHz) */
+    meshtastic_Config_LoRaConfig_RegionCode_ITU1_70CM = 34,
+    /* ITU Region 2 Amateur Radio 70cm band (420-450 MHz)
+ Note: Some countries do not allocate 420-430 MHz or 440-450 MHz.
+ Check local law! */
+    meshtastic_Config_LoRaConfig_RegionCode_ITU2_70CM = 35,
+    /* ITU Region 3 Amateur Radio 70cm band (430-450 MHz)
+ Note: Some countries do not allocate 440-450 MHz. Check local law! */
+    meshtastic_Config_LoRaConfig_RegionCode_ITU3_70CM = 36
 } meshtastic_Config_LoRaConfig_RegionCode;
 
 /* Standard predefined channel settings
@@ -734,8 +745,8 @@ extern "C" {
 #define _meshtastic_Config_DisplayConfig_CompassOrientation_ARRAYSIZE ((meshtastic_Config_DisplayConfig_CompassOrientation)(meshtastic_Config_DisplayConfig_CompassOrientation_DEGREES_270_INVERTED+1))
 
 #define _meshtastic_Config_LoRaConfig_RegionCode_MIN meshtastic_Config_LoRaConfig_RegionCode_UNSET
-#define _meshtastic_Config_LoRaConfig_RegionCode_MAX meshtastic_Config_LoRaConfig_RegionCode_EU_N_868
-#define _meshtastic_Config_LoRaConfig_RegionCode_ARRAYSIZE ((meshtastic_Config_LoRaConfig_RegionCode)(meshtastic_Config_LoRaConfig_RegionCode_EU_N_868+1))
+#define _meshtastic_Config_LoRaConfig_RegionCode_MAX meshtastic_Config_LoRaConfig_RegionCode_ITU3_70CM
+#define _meshtastic_Config_LoRaConfig_RegionCode_ARRAYSIZE ((meshtastic_Config_LoRaConfig_RegionCode)(meshtastic_Config_LoRaConfig_RegionCode_ITU3_70CM+1))
 
 #define _meshtastic_Config_LoRaConfig_ModemPreset_MIN meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST
 #define _meshtastic_Config_LoRaConfig_ModemPreset_MAX meshtastic_Config_LoRaConfig_ModemPreset_NARROW_SLOW

src/modules/AdminModule.cpp

@@ -824,7 +824,7 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c, bool fromOthers)
                 // Ensure initRegion() uses the newly validated region
                 config.lora.region = validatedLora.region;
                 initRegion();
-                if (myRegion->dutyCycle < 100) {
+                if (getEffectiveDutyCycle() < 100) {
                     validatedLora.ignore_mqtt = true; // Ignore MQTT by default if region has a duty cycle limit
                 }
                 if (strncmp(moduleConfig.mqtt.root, default_mqtt_root, strlen(default_mqtt_root)) == 0) {
@@ -1013,11 +1013,11 @@ bool AdminModule::handleSetModuleConfig(const meshtastic_ModuleConfig &c)
     case meshtastic_ModuleConfig_neighbor_info_tag:
         LOG_INFO("Set module config: Neighbor Info");
         moduleConfig.has_neighbor_info = true;
+        moduleConfig.neighbor_info = c.payload_variant.neighbor_info;
         if (moduleConfig.neighbor_info.update_interval < min_neighbor_info_broadcast_secs) {
             LOG_DEBUG("Tried to set update_interval too low, setting to %d", default_neighbor_info_broadcast_secs);
             moduleConfig.neighbor_info.update_interval = default_neighbor_info_broadcast_secs;
         }
-        moduleConfig.neighbor_info = c.payload_variant.neighbor_info;
         break;
     case meshtastic_ModuleConfig_detection_sensor_tag:
         LOG_INFO("Set module config: Detection Sensor");

src/modules/AtakPluginModule.cpp

@@ -1,207 +1,11 @@
 #include "AtakPluginModule.h"
-#include "Default.h"
-#include "MeshService.h"
-#include "NodeDB.h"
-#include "PowerFSM.h"
-#include "configuration.h"
-#include "main.h"
-#include "mesh/compression/unishox2.h"
-#include "meshUtils.h"
-#include "meshtastic/atak.pb.h"
 
 AtakPluginModule *atakPluginModule;
 
-AtakPluginModule::AtakPluginModule()
-    : ProtobufModule("atak", meshtastic_PortNum_ATAK_PLUGIN, &meshtastic_TAKPacket_msg), concurrency::OSThread("AtakPlugin")
+AtakPluginModule::AtakPluginModule() : SinglePortModule("atak", meshtastic_PortNum_ATAK_PLUGIN_V2) {}
+
+ProcessMessage AtakPluginModule::handleReceived(const meshtastic_MeshPacket &mp)
 {
-    ourPortNum = meshtastic_PortNum_ATAK_PLUGIN;
+    (void)mp; // Passthrough — no processing needed, apps handle compression/decompression
+    return ProcessMessage::CONTINUE;
 }
-
-/*
-Encompasses the full construction and sending packet to mesh
-Will be used for broadcast.
-*/
-int32_t AtakPluginModule::runOnce()
-{
-    return default_broadcast_interval_secs;
-}
-
-bool AtakPluginModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshtastic_TAKPacket *r)
-{
-    return false;
-}
-
-meshtastic_TAKPacket AtakPluginModule::cloneTAKPacketData(meshtastic_TAKPacket *t)
-{
-    meshtastic_TAKPacket clone = meshtastic_TAKPacket_init_zero;
-    if (t->has_group) {
-        clone.has_group = true;
-        clone.group = t->group;
-    }
-    if (t->has_status) {
-        clone.has_status = true;
-        clone.status = t->status;
-    }
-    if (t->has_contact) {
-        clone.has_contact = true;
-        clone.contact = {0};
-    }
-
-    if (t->which_payload_variant == meshtastic_TAKPacket_pli_tag) {
-        clone.which_payload_variant = meshtastic_TAKPacket_pli_tag;
-        clone.payload_variant.pli = t->payload_variant.pli;
-    } else if (t->which_payload_variant == meshtastic_TAKPacket_chat_tag) {
-        clone.which_payload_variant = meshtastic_TAKPacket_chat_tag;
-        clone.payload_variant.chat = {0};
-    } else if (t->which_payload_variant == meshtastic_TAKPacket_detail_tag) {
-        clone.which_payload_variant = meshtastic_TAKPacket_detail_tag;
-        clone.payload_variant.detail.size = t->payload_variant.detail.size;
-        memcpy(clone.payload_variant.detail.bytes, t->payload_variant.detail.bytes, t->payload_variant.detail.size);
-    }
-
-    return clone;
-}
-
-void AtakPluginModule::alterReceivedProtobuf(meshtastic_MeshPacket &mp, meshtastic_TAKPacket *t)
-{
-    // From Phone (EUD)
-    if (mp.from == 0) {
-        LOG_DEBUG("Received uncompressed TAK payload from phone: %d bytes", mp.decoded.payload.size);
-        // Compress for LoRA transport
-        auto compressed = cloneTAKPacketData(t);
-        compressed.is_compressed = true;
-        if (t->has_contact) {
-            auto length = unishox2_compress_lines(
-                t->contact.callsign, pb_string_length(t->contact.callsign, sizeof(t->contact.callsign)),
-                compressed.contact.callsign, sizeof(compressed.contact.callsign) - 1, USX_PSET_DFLT, NULL);
-            if (length < 0) {
-                LOG_WARN("Compress overflow contact.callsign. Revert to uncompressed packet");
-                return;
-            }
-            LOG_DEBUG("Compressed callsign: %d bytes", length);
-            length = unishox2_compress_lines(
-                t->contact.device_callsign, pb_string_length(t->contact.device_callsign, sizeof(t->contact.device_callsign)),
-                compressed.contact.device_callsign, sizeof(compressed.contact.device_callsign) - 1, USX_PSET_DFLT, NULL);
-            if (length < 0) {
-                LOG_WARN("Compress overflow contact.device_callsign. Revert to uncompressed packet");
-                return;
-            }
-            LOG_DEBUG("Compressed device_callsign: %d bytes", length);
-        }
-        if (t->which_payload_variant == meshtastic_TAKPacket_chat_tag) {
-            auto length = unishox2_compress_lines(
-                t->payload_variant.chat.message,
-                pb_string_length(t->payload_variant.chat.message, sizeof(t->payload_variant.chat.message)),
-                compressed.payload_variant.chat.message, sizeof(compressed.payload_variant.chat.message) - 1, USX_PSET_DFLT,
-                NULL);
-            if (length < 0) {
-                LOG_WARN("Compress overflow chat.message. Revert to uncompressed packet");
-                return;
-            }
-            LOG_DEBUG("Compressed chat message: %d bytes", length);
-
-            if (t->payload_variant.chat.has_to) {
-                compressed.payload_variant.chat.has_to = true;
-                length = unishox2_compress_lines(
-                    t->payload_variant.chat.to, pb_string_length(t->payload_variant.chat.to, sizeof(t->payload_variant.chat.to)),
-                    compressed.payload_variant.chat.to, sizeof(compressed.payload_variant.chat.to) - 1, USX_PSET_DFLT, NULL);
-                if (length < 0) {
-                    LOG_WARN("Compress overflow chat.to. Revert to uncompressed packet");
-                    return;
-                }
-                LOG_DEBUG("Compressed chat to: %d bytes", length);
-            }
-
-            if (t->payload_variant.chat.has_to_callsign) {
-                compressed.payload_variant.chat.has_to_callsign = true;
-                length = unishox2_compress_lines(
-                    t->payload_variant.chat.to_callsign,
-                    pb_string_length(t->payload_variant.chat.to_callsign, sizeof(t->payload_variant.chat.to_callsign)),
-                    compressed.payload_variant.chat.to_callsign, sizeof(compressed.payload_variant.chat.to_callsign) - 1,
-                    USX_PSET_DFLT, NULL);
-                if (length < 0) {
-                    LOG_WARN("Compress overflow chat.to_callsign. Revert to uncompressed packet");
-                    return;
-                }
-                LOG_DEBUG("Compressed chat to_callsign: %d bytes", length);
-            }
-        }
-        mp.decoded.payload.size = pb_encode_to_bytes(mp.decoded.payload.bytes, sizeof(mp.decoded.payload.bytes),
-                                                     meshtastic_TAKPacket_fields, &compressed);
-        LOG_DEBUG("Final payload: %d bytes", mp.decoded.payload.size);
-    } else {
-        if (!t->is_compressed) {
-            // Not compressed. Something is wrong
-            LOG_WARN("Received uncompressed TAKPacket over radio! Skip");
-            return;
-        }
-
-        // Decompress for Phone (EUD)
-        auto uncompressed = cloneTAKPacketData(t);
-        uncompressed.is_compressed = false;
-        if (t->has_contact) {
-            auto length = unishox2_decompress_lines(
-                t->contact.callsign, pb_string_length(t->contact.callsign, sizeof(t->contact.callsign)),
-                uncompressed.contact.callsign, sizeof(uncompressed.contact.callsign) - 1, USX_PSET_DFLT, NULL);
-            if (length < 0) {
-                LOG_WARN("Decompress overflow contact.callsign. Bailing out");
-                return;
-            }
-            LOG_DEBUG("Decompressed callsign: %d bytes", length);
-
-            length = unishox2_decompress_lines(
-                t->contact.device_callsign, pb_string_length(t->contact.device_callsign, sizeof(t->contact.device_callsign)),
-                uncompressed.contact.device_callsign, sizeof(uncompressed.contact.device_callsign) - 1, USX_PSET_DFLT, NULL);
-            if (length < 0) {
-                LOG_WARN("Decompress overflow contact.device_callsign. Bailing out");
-                return;
-            }
-            LOG_DEBUG("Decompressed device_callsign: %d bytes", length);
-        }
-        if (uncompressed.which_payload_variant == meshtastic_TAKPacket_chat_tag) {
-            auto length = unishox2_decompress_lines(
-                t->payload_variant.chat.message,
-                pb_string_length(t->payload_variant.chat.message, sizeof(t->payload_variant.chat.message)),
-                uncompressed.payload_variant.chat.message, sizeof(uncompressed.payload_variant.chat.message) - 1, USX_PSET_DFLT,
-                NULL);
-            if (length < 0) {
-                LOG_WARN("Decompress overflow chat.message. Bailing out");
-                return;
-            }
-            LOG_DEBUG("Decompressed chat message: %d bytes", length);
-
-            if (t->payload_variant.chat.has_to) {
-                uncompressed.payload_variant.chat.has_to = true;
-                length = unishox2_decompress_lines(
-                    t->payload_variant.chat.to, pb_string_length(t->payload_variant.chat.to, sizeof(t->payload_variant.chat.to)),
-                    uncompressed.payload_variant.chat.to, sizeof(uncompressed.payload_variant.chat.to) - 1, USX_PSET_DFLT, NULL);
-                if (length < 0) {
-                    LOG_WARN("Decompress overflow chat.to. Bailing out");
-                    return;
-                }
-                LOG_DEBUG("Decompressed chat to: %d bytes", length);
-            }
-
-            if (t->payload_variant.chat.has_to_callsign) {
-                uncompressed.payload_variant.chat.has_to_callsign = true;
-                length = unishox2_decompress_lines(
-                    t->payload_variant.chat.to_callsign,
-                    pb_string_length(t->payload_variant.chat.to_callsign, sizeof(t->payload_variant.chat.to_callsign)),
-                    uncompressed.payload_variant.chat.to_callsign, sizeof(uncompressed.payload_variant.chat.to_callsign) - 1,
-                    USX_PSET_DFLT, NULL);
-                if (length < 0) {
-                    LOG_WARN("Decompress overflow chat.to_callsign. Bailing out");
-                    return;
-                }
-                LOG_DEBUG("Decompressed chat to_callsign: %d bytes", length);
-            }
-        }
-        auto decompressedCopy = packetPool.allocCopy(mp);
-        decompressedCopy->decoded.payload.size =
-            pb_encode_to_bytes(decompressedCopy->decoded.payload.bytes, sizeof(decompressedCopy->decoded.payload),
-                               meshtastic_TAKPacket_fields, &uncompressed);
-
-        service->sendToPhone(decompressedCopy);
-    }
-    return;
-}

src/modules/AtakPluginModule.h

@@ -1,11 +1,15 @@
 #pragma once
-#include "ProtobufModule.h"
-#include "meshtastic/atak.pb.h"
+#include "SinglePortModule.h"
 
 /**
- * Waypoint message handling for meshtastic
+ * ATAK Plugin V2 module - passthrough for ATAK_PLUGIN_V2 payloads.
+ * The wire format includes a leading flags byte followed by opaque payload bytes.
+ * Depending on the flags, the payload may be zstd dictionary-compressed or raw/uncompressed protobuf.
+ * Compression/decompression and payload interpretation are handled by the apps
+ * (Android, iOS, ATAK plugin); firmware forwards the bytes unchanged on the
+ * ATAK_PLUGIN_V2 port.
  */
-class AtakPluginModule : public ProtobufModule<meshtastic_TAKPacket>, private concurrency::OSThread
+class AtakPluginModule : public SinglePortModule
 {
   public:
     /** Constructor
@@ -14,13 +18,7 @@ class AtakPluginModule : public ProtobufModule<meshtastic_TAKPacket>, private co
     AtakPluginModule();
 
   protected:
-    virtual bool handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshtastic_TAKPacket *t) override;
-    virtual void alterReceivedProtobuf(meshtastic_MeshPacket &mp, meshtastic_TAKPacket *t) override;
-    /* Does our periodic broadcast */
-    int32_t runOnce() override;
-
-  private:
-    meshtastic_TAKPacket cloneTAKPacketData(meshtastic_TAKPacket *t);
+    virtual ProcessMessage handleReceived(const meshtastic_MeshPacket &mp) override;
 };
 
-extern AtakPluginModule *atakPluginModule;
+extern AtakPluginModule *atakPluginModule;

src/modules/CannedMessageModule.cpp

@@ -6,6 +6,7 @@
 #include "CannedMessageModule.h"
 #include "Channels.h"
 #include "FSCommon.h"
+#include "MeshRadio.h"
 #include "MeshService.h"
 #include "MessageStore.h"
 #include "NodeDB.h"
@@ -2103,16 +2104,16 @@ void CannedMessageModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *st
 static float getSnrLimit(meshtastic_Config_LoRaConfig_ModemPreset preset)
 {
     switch (preset) {
-    case meshtastic_Config_LoRaConfig_ModemPreset_LONG_SLOW:
-    case meshtastic_Config_LoRaConfig_ModemPreset_LONG_MODERATE:
-    case meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST:
+    case PRESET(LONG_SLOW):
+    case PRESET(LONG_MODERATE):
+    case PRESET(LONG_FAST):
         return -6.0f;
-    case meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_SLOW:
-    case meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST:
+    case PRESET(MEDIUM_SLOW):
+    case PRESET(MEDIUM_FAST):
         return -5.5f;
-    case meshtastic_Config_LoRaConfig_ModemPreset_SHORT_SLOW:
-    case meshtastic_Config_LoRaConfig_ModemPreset_SHORT_FAST:
-    case meshtastic_Config_LoRaConfig_ModemPreset_SHORT_TURBO:
+    case PRESET(SHORT_SLOW):
+    case PRESET(SHORT_FAST):
+    case PRESET(SHORT_TURBO):
         return -4.5f;
     default:
         return -6.0f;

src/modules/PositionModule.cpp

@@ -13,7 +13,6 @@
 #include "configuration.h"
 #include "gps/GeoCoord.h"
 #include "main.h"
-#include "mesh/compression/unishox2.h"
 #include "meshUtils.h"
 #include "meshtastic/atak.pb.h"
 #include "sleep.h"
@@ -291,37 +290,77 @@ meshtastic_MeshPacket *PositionModule::allocReply()
 
 meshtastic_MeshPacket *PositionModule::allocAtakPli()
 {
-    LOG_INFO("Send TAK PLI packet");
+    LOG_INFO("Send TAK V2 PLI packet");
     meshtastic_MeshPacket *mp = allocDataPacket();
-    mp->decoded.portnum = meshtastic_PortNum_ATAK_PLUGIN;
+    mp->decoded.portnum = meshtastic_PortNum_ATAK_PLUGIN_V2;
 
-    meshtastic_TAKPacket takPacket = {.is_compressed = true,
-                                      .has_contact = true,
-                                      .contact = meshtastic_Contact_init_default,
-                                      .has_group = true,
-                                      .group = {meshtastic_MemberRole_TeamMember, meshtastic_Team_Cyan},
-                                      .has_status = true,
-                                      .status =
-                                          {
-                                              .battery = powerStatus->getBatteryChargePercent(),
-                                          },
-                                      .which_payload_variant = meshtastic_TAKPacket_pli_tag,
-                                      .payload_variant = {.pli = {
-                                                              .latitude_i = localPosition.latitude_i,
-                                                              .longitude_i = localPosition.longitude_i,
-                                                              .altitude = localPosition.altitude_hae,
-                                                              .speed = localPosition.ground_speed,
-                                                              .course = static_cast<uint16_t>(localPosition.ground_track),
-                                                          }}};
+    meshtastic_TAKPacketV2 takPacket = meshtastic_TAKPacketV2_init_zero;
+    takPacket.cot_type_id = meshtastic_CotType_CotType_a_f_G_U_C;
 
-    auto length = unishox2_compress_lines(owner.long_name, strlen(owner.long_name), takPacket.contact.device_callsign,
-                                          sizeof(takPacket.contact.device_callsign) - 1, USX_PSET_DFLT, NULL);
-    LOG_DEBUG("Uncompressed device_callsign '%s' - %d bytes", owner.long_name, strlen(owner.long_name));
-    LOG_DEBUG("Compressed device_callsign '%s' - %d bytes", takPacket.contact.device_callsign, length);
-    length = unishox2_compress_lines(owner.long_name, strlen(owner.long_name), takPacket.contact.callsign,
-                                     sizeof(takPacket.contact.callsign) - 1, USX_PSET_DFLT, NULL);
-    mp->decoded.payload.size =
-        pb_encode_to_bytes(mp->decoded.payload.bytes, sizeof(mp->decoded.payload.bytes), &meshtastic_TAKPacket_msg, &takPacket);
+    // Use TAK config for team/role if configured, otherwise use defaults (Cyan/TeamMember)
+    if (moduleConfig.has_tak && moduleConfig.tak.team != meshtastic_Team_Unspecifed_Color) {
+        takPacket.team = moduleConfig.tak.team;
+    } else {
+        takPacket.team = meshtastic_Team_Cyan;
+    }
+
+    if (moduleConfig.has_tak && moduleConfig.tak.role != meshtastic_MemberRole_Unspecifed) {
+        takPacket.role = moduleConfig.tak.role;
+    } else {
+        takPacket.role = meshtastic_MemberRole_TeamMember;
+    }
+    takPacket.latitude_i = localPosition.latitude_i;
+    takPacket.longitude_i = localPosition.longitude_i;
+    takPacket.altitude = localPosition.altitude_hae;
+    takPacket.speed = localPosition.ground_speed;
+    // ground_track is stored as degrees * 1e5, course field expects degrees * 100
+    int32_t course = localPosition.ground_track / 1000;
+    if (course < 0)
+        course = 0;
+    else if (course > 36000)
+        course = 36000;
+    takPacket.course = static_cast<uint16_t>(course);
+    takPacket.battery = powerStatus->getBatteryChargePercent();
+
+    // Map position source to CoT how/geo_src/alt_src
+    if (config.position.fixed_position || localPosition.location_source == meshtastic_Position_LocSource_LOC_MANUAL) {
+        takPacket.how = meshtastic_CotHow_CotHow_h_e;
+        takPacket.geo_src = meshtastic_GeoPointSource_GeoPointSource_USER;
+        takPacket.alt_src = meshtastic_GeoPointSource_GeoPointSource_USER;
+    } else {
+        takPacket.how = meshtastic_CotHow_CotHow_m_g;
+        takPacket.geo_src = meshtastic_GeoPointSource_GeoPointSource_GPS;
+        takPacket.alt_src = meshtastic_GeoPointSource_GeoPointSource_GPS;
+    }
+    takPacket.which_payload_variant = meshtastic_TAKPacketV2_pli_tag;
+    takPacket.payload_variant.pli = true;
+
+    // Callsign - stored as plain string (no compression, apps handle that)
+    strncpy(takPacket.callsign, owner.long_name, sizeof(takPacket.callsign) - 1);
+    takPacket.callsign[sizeof(takPacket.callsign) - 1] = '\0';
+    strncpy(takPacket.device_callsign, owner.long_name, sizeof(takPacket.device_callsign) - 1);
+    takPacket.device_callsign[sizeof(takPacket.device_callsign) - 1] = '\0';
+
+    // Encode TAKPacketV2 protobuf, leaving room for flags byte prefix
+    uint8_t protobuf_bytes[sizeof(mp->decoded.payload.bytes) - 1];
+    size_t proto_size = pb_encode_to_bytes(protobuf_bytes, sizeof(protobuf_bytes), &meshtastic_TAKPacketV2_msg, &takPacket);
+
+    if (proto_size == 0) {
+        LOG_ERROR("Failed to encode TAK V2 PLI packet");
+        packetPool.release(mp);
+        return nullptr;
+    }
+
+    // Wire format: [flags byte][protobuf bytes]
+    // Flags byte 0xFF is a reserved sentinel meaning the remainder is an
+    // uncompressed raw protobuf payload (that is, no zstd dictionary ID is
+    // encoded in the flags byte). Decoders must check for this sentinel before
+    // applying any dictionary-ID masking/interpretation.
+    mp->decoded.payload.bytes[0] = 0xFF;
+    memcpy(mp->decoded.payload.bytes + 1, protobuf_bytes, proto_size);
+    mp->decoded.payload.size = proto_size + 1;
+
+    LOG_DEBUG("TAK V2 PLI payload: %zu bytes (1 flags + %zu protobuf)", mp->decoded.payload.size, proto_size);
     return mp;
 }
 
@@ -407,8 +446,8 @@ int32_t PositionModule::runOnce()
 
     // We limit our GPS broadcasts to a max rate
     uint32_t now = millis();
-    uint32_t intervalMs = Default::getConfiguredOrDefaultMsScaled(config.position.position_broadcast_secs,
-                                                                  default_broadcast_interval_secs, numOnlineNodes);
+    uint32_t intervalMs = Default::getConfiguredOrDefaultMsScaled(
+        config.position.position_broadcast_secs, default_broadcast_interval_secs, numOnlineNodes, TrafficType::POSITION);
     uint32_t msSinceLastSend = now - lastGpsSend;
     // Only send packets if the channel util. is less than 25% utilized or we're a tracker with less than 40% utilized.
     if (!airTime->isTxAllowedChannelUtil(config.device.role != meshtastic_Config_DeviceConfig_Role_TRACKER &&

src/modules/Telemetry/AirQualityTelemetry.cpp

@@ -116,11 +116,11 @@ int32_t AirQualityTelemetryModule::runOnce()
         for (TelemetrySensor *sensor : sensors) {
             if (!sensor->canSleep()) {
                 LOG_DEBUG("%s sensor doesn't have sleep feature. Skipping", sensor->sensorName);
-            } else if (((lastTelemetry == 0) ||
-                        !Throttle::isWithinTimespanMs(lastTelemetry - sensor->wakeUpTimeMs(),
-                                                      Default::getConfiguredOrDefaultMsScaled(
-                                                          moduleConfig.telemetry.air_quality_interval,
-                                                          default_telemetry_broadcast_interval_secs, numOnlineNodes))) &&
+            } else if (((lastTelemetry == 0) || !Throttle::isWithinTimespanMs(lastTelemetry - sensor->wakeUpTimeMs(),
+                                                                              Default::getConfiguredOrDefaultMsScaled(
+                                                                                  moduleConfig.telemetry.air_quality_interval,
+                                                                                  default_telemetry_broadcast_interval_secs,
+                                                                                  numOnlineNodes, TrafficType::TELEMETRY))) &&
                        airTime->isTxAllowedChannelUtil(config.device.role != meshtastic_Config_DeviceConfig_Role_SENSOR) &&
                        airTime->isTxAllowedAirUtil()) {
                 if (!sensor->isActive()) {
@@ -136,10 +136,10 @@ int32_t AirQualityTelemetryModule::runOnce()
             }
         }
 
-        if (((lastTelemetry == 0) ||
-             !Throttle::isWithinTimespanMs(lastTelemetry, Default::getConfiguredOrDefaultMsScaled(
-                                                              moduleConfig.telemetry.air_quality_interval,
-                                                              default_telemetry_broadcast_interval_secs, numOnlineNodes))) &&
+        if (((lastTelemetry == 0) || !Throttle::isWithinTimespanMs(lastTelemetry, Default::getConfiguredOrDefaultMsScaled(
+                                                                                      moduleConfig.telemetry.air_quality_interval,
+                                                                                      default_telemetry_broadcast_interval_secs,
+                                                                                      numOnlineNodes, TrafficType::TELEMETRY))) &&
             airTime->isTxAllowedChannelUtil(config.device.role != meshtastic_Config_DeviceConfig_Role_SENSOR) &&
             airTime->isTxAllowedAirUtil()) {
             sendTelemetry();
@@ -159,7 +159,8 @@ int32_t AirQualityTelemetryModule::runOnce()
             if (sensor->isActive() && sensor->canSleep()) {
                 if (sensor->wakeUpTimeMs() <
                     (int32_t)Default::getConfiguredOrDefaultMsScaled(moduleConfig.telemetry.air_quality_interval,
-                                                                     default_telemetry_broadcast_interval_secs, numOnlineNodes)) {
+                                                                     default_telemetry_broadcast_interval_secs, numOnlineNodes,
+                                                                     TrafficType::TELEMETRY)) {
                     LOG_DEBUG("Disabling %s until next period", sensor->sensorName);
                     sensor->sleep();
                 } else {

src/modules/Telemetry/DeviceTelemetry.cpp

@@ -20,13 +20,14 @@ static constexpr uint16_t TX_HISTORY_KEY_DEVICE_TELEMETRY = 0x8001;
 
 int32_t DeviceTelemetryModule::runOnce()
 {
+
     refreshUptime();
     uint32_t lastTelemetry = transmitHistory ? transmitHistory->getLastSentToMeshMillis(TX_HISTORY_KEY_DEVICE_TELEMETRY) : 0;
     bool isImpoliteRole = isSensorOrRouterRole();
     if (((lastTelemetry == 0) ||
          ((uptimeLastMs - lastTelemetry) >= Default::getConfiguredOrDefaultMsScaled(moduleConfig.telemetry.device_update_interval,
                                                                                     default_telemetry_broadcast_interval_secs,
-                                                                                    numOnlineNodes))) &&
+                                                                                    numOnlineNodes, TrafficType::TELEMETRY))) &&
         airTime->isTxAllowedChannelUtil(!isImpoliteRole) && airTime->isTxAllowedAirUtil() &&
         config.device.role != meshtastic_Config_DeviceConfig_Role_CLIENT_HIDDEN &&
         moduleConfig.telemetry.device_telemetry_enabled) {
@@ -99,17 +100,21 @@ meshtastic_Telemetry DeviceTelemetryModule::getDeviceTelemetry()
     t.variant.device_metrics.has_air_util_tx = true;
     t.variant.device_metrics.has_battery_level = true;
     t.variant.device_metrics.has_channel_utilization = true;
-    t.variant.device_metrics.has_voltage = true;
     t.variant.device_metrics.has_uptime_seconds = true;
-
     t.variant.device_metrics.air_util_tx = airTime->utilizationTXPercent();
     t.variant.device_metrics.battery_level = (!powerStatus->getHasBattery() || powerStatus->getIsCharging())
                                                  ? MAGIC_USB_BATTERY_LEVEL
                                                  : powerStatus->getBatteryChargePercent();
     t.variant.device_metrics.channel_utilization = airTime->channelUtilizationPercent();
-    t.variant.device_metrics.voltage = powerStatus->getBatteryVoltageMv() / 1000.0;
+    // Only populate voltage when we actually have a battery reading. Previously this assigned
+    // -0.001 (from -1 mV / 1000) whenever the ADC returned -1, leaking a sentinel onto the wire
+    // that clients then displayed as a real negative voltage. See GH #7958.
+    int32_t batteryMv = powerStatus->getBatteryVoltageMv();
+    if (powerStatus->getHasBattery() && batteryMv > 0) {
+        t.variant.device_metrics.has_voltage = true;
+        t.variant.device_metrics.voltage = batteryMv / 1000.0f;
+    }
     t.variant.device_metrics.uptime_seconds = getUptimeSeconds();
-
     return t;
 }
 
@@ -125,6 +130,8 @@ meshtastic_Telemetry DeviceTelemetryModule::getLocalStatsTelemetry()
     telemetry.variant.local_stats.num_online_nodes = numOnlineNodes;
     telemetry.variant.local_stats.num_total_nodes = nodeDB->getNumMeshNodes();
     if (RadioLibInterface::instance) {
+        RadioLibInterface::instance->updateNoiseFloor();
+        telemetry.variant.local_stats.noise_floor = RadioLibInterface::instance->getAverageNoiseFloor();
         telemetry.variant.local_stats.num_packets_tx = RadioLibInterface::instance->txGood;
         telemetry.variant.local_stats.num_packets_rx = RadioLibInterface::instance->rxGood + RadioLibInterface::instance->rxBad;
         telemetry.variant.local_stats.num_packets_rx_bad = RadioLibInterface::instance->rxBad;
@@ -133,6 +140,8 @@ meshtastic_Telemetry DeviceTelemetryModule::getLocalStatsTelemetry()
     }
 #ifdef ARCH_PORTDUINO
     if (SimRadio::instance) {
+        if (!RadioLibInterface::instance)
+            telemetry.variant.local_stats.noise_floor = SimRadio::instance->getCurrentRSSI();
         telemetry.variant.local_stats.num_packets_tx = SimRadio::instance->txGood;
         telemetry.variant.local_stats.num_packets_rx = SimRadio::instance->rxGood + SimRadio::instance->rxBad;
         telemetry.variant.local_stats.num_packets_rx_bad = SimRadio::instance->rxBad;
@@ -148,10 +157,11 @@ meshtastic_Telemetry DeviceTelemetryModule::getLocalStatsTelemetry()
         telemetry.variant.local_stats.num_tx_relay_canceled = router->txRelayCanceled;
     }
 
-    LOG_INFO("Sending local stats: uptime=%i, channel_utilization=%f, air_util_tx=%f, num_online_nodes=%i, num_total_nodes=%i",
+    LOG_INFO("Sending local stats: uptime=%i, channel_utilization=%f, air_util_tx=%f, num_online_nodes=%i, num_total_nodes=%i, "
+             "noise_floor=%d",
              telemetry.variant.local_stats.uptime_seconds, telemetry.variant.local_stats.channel_utilization,
              telemetry.variant.local_stats.air_util_tx, telemetry.variant.local_stats.num_online_nodes,
-             telemetry.variant.local_stats.num_total_nodes);
+             telemetry.variant.local_stats.num_total_nodes, telemetry.variant.local_stats.noise_floor);
 
     LOG_INFO("num_packets_tx=%i, num_packets_rx=%i, num_packets_rx_bad=%i", telemetry.variant.local_stats.num_packets_tx,
              telemetry.variant.local_stats.num_packets_rx, telemetry.variant.local_stats.num_packets_rx_bad);
@@ -194,4 +204,4 @@ bool DeviceTelemetryModule::sendTelemetry(NodeNum dest, bool phoneOnly)
         service->sendToMesh(p, RX_SRC_LOCAL, true);
     }
     return true;
-}
+}

src/modules/Telemetry/EnvironmentTelemetry.cpp

@@ -310,9 +310,10 @@ int32_t EnvironmentTelemetryModule::runOnce()
         uint32_t lastTelemetry =
             transmitHistory ? transmitHistory->getLastSentToMeshMillis(TX_HISTORY_KEY_ENVIRONMENT_TELEMETRY) : 0;
         if (((lastTelemetry == 0) ||
-             !Throttle::isWithinTimespanMs(lastTelemetry, Default::getConfiguredOrDefaultMsScaled(
-                                                              moduleConfig.telemetry.environment_update_interval,
-                                                              default_telemetry_broadcast_interval_secs, numOnlineNodes))) &&
+             !Throttle::isWithinTimespanMs(
+                 lastTelemetry, Default::getConfiguredOrDefaultMsScaled(moduleConfig.telemetry.environment_update_interval,
+                                                                        default_telemetry_broadcast_interval_secs, numOnlineNodes,
+                                                                        TrafficType::TELEMETRY))) &&
             airTime->isTxAllowedChannelUtil(config.device.role != meshtastic_Config_DeviceConfig_Role_SENSOR) &&
             airTime->isTxAllowedAirUtil()) {
             sendTelemetry();

src/modules/Telemetry/HealthTelemetry.cpp

@@ -74,9 +74,10 @@ int32_t HealthTelemetryModule::runOnce()
 
         uint32_t lastTelemetry = transmitHistory ? transmitHistory->getLastSentToMeshMillis(TX_HISTORY_KEY_HEALTH_TELEMETRY) : 0;
         if (((lastTelemetry == 0) ||
-             !Throttle::isWithinTimespanMs(lastTelemetry, Default::getConfiguredOrDefaultMsScaled(
-                                                              moduleConfig.telemetry.health_update_interval,
-                                                              default_telemetry_broadcast_interval_secs, numOnlineNodes))) &&
+             !Throttle::isWithinTimespanMs(lastTelemetry,
+                                           Default::getConfiguredOrDefaultMsScaled(moduleConfig.telemetry.health_update_interval,
+                                                                                   default_telemetry_broadcast_interval_secs,
+                                                                                   numOnlineNodes, TrafficType::TELEMETRY))) &&
             airTime->isTxAllowedChannelUtil(config.device.role != meshtastic_Config_DeviceConfig_Role_SENSOR) &&
             airTime->isTxAllowedAirUtil()) {
             sendTelemetry();

src/modules/Telemetry/PowerTelemetry.cpp

@@ -55,8 +55,9 @@ int32_t PowerTelemetryModule::runOnce()
         return disable();
     }
 
-    uint32_t sendToMeshIntervalMs = Default::getConfiguredOrDefaultMsScaled(
-        moduleConfig.telemetry.power_update_interval, default_telemetry_broadcast_interval_secs, numOnlineNodes);
+    uint32_t sendToMeshIntervalMs = Default::getConfiguredOrDefaultMsScaled(moduleConfig.telemetry.power_update_interval,
+                                                                            default_telemetry_broadcast_interval_secs,
+                                                                            numOnlineNodes, TrafficType::TELEMETRY);
 
     if (firstTime) {
         // This is the first time the OSThread library has called this function, so do some setup

src/platform/portduino/SimRadio.cpp

@@ -362,4 +362,10 @@ uint32_t SimRadio::getPacketTime(uint32_t pl, bool received)
 
     uint32_t msecs = tPacket * 1000;
     return msecs;
+}
+
+int16_t SimRadio::getCurrentRSSI()
+{
+    // Simulated radio - return a reasonable default noise floor
+    return -120;
 }

src/platform/portduino/SimRadio.h

@@ -48,6 +48,8 @@ class SimRadio : public RadioInterface, protected concurrency::NotifiedWorkerThr
     // Convert Compressed_msg to normal msg and receive it
     void unpackAndReceive(meshtastic_MeshPacket &p);
 
+    int16_t getCurrentRSSI() override;
+
     /**
      * Debugging counts
      */
@@ -93,4 +95,4 @@ class SimRadio : public RadioInterface, protected concurrency::NotifiedWorkerThr
     virtual uint32_t getPacketTime(uint32_t pl, bool received = false) override;
 };
 
-extern SimRadio *simRadio;
+extern SimRadio *simRadio;

test/test_admin_radio/test_main.cpp

@@ -11,6 +11,7 @@
  *  6. Channel spacing calculation (placeholder for future protobuf changes)
  */
 
+#include "DisplayFormatters.h"
 #include "MeshRadio.h"
 #include "MeshService.h"
 #include "NodeDB.h"
@@ -21,6 +22,9 @@
 
 #include "meshtastic/config.pb.h"
 
+// hash() is a file-scope function in RadioInterface.cpp; link it in for slot-formula tests
+extern uint32_t hash(const char *str);
+
 class MockMeshService : public MeshService
 {
   public:
@@ -163,20 +167,58 @@ static const RegionProfile TEST_PROFILE_TURBO = {
     /* overrideSlot */ 0,
 };
 
+// A preset list for the preset-hash override slot test (LONG_FAST + MEDIUM_FAST)
+static const meshtastic_Config_LoRaConfig_ModemPreset TEST_PRESETS_PRESET_HASH[] = {
+    meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST,
+    meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST,
+    MODEM_PRESET_END,
+};
+
+// Profile with overrideSlot = OVERRIDE_SLOT_PRESET_HASH (-1):
+// slot selection always uses hash(presetDisplayName), ignoring the primary channel name.
+static const RegionProfile TEST_PROFILE_PRESET_HASH = {
+    TEST_PRESETS_PRESET_HASH,
+    /* spacing */ 0.0f,
+    /* padding */ 0.0f,
+    /* audioPermitted */ true,
+    /* licensedOnly */ false,
+    /* textThrottle */ 0,
+    /* positionThrottle */ 0,
+    /* telemetryThrottle */ 0,
+    /* overrideSlot */ OVERRIDE_SLOT_PRESET_HASH,
+};
+
+// Standalone test region using US frequencies (26 MHz span → 104 slots at 250 kHz BW)
+// Used to verify OVERRIDE_SLOT_PRESET_HASH slot formula; not inserted into testRegions[].
+static const RegionInfo TEST_REGION_PRESET_HASH = {
+    meshtastic_Config_LoRaConfig_RegionCode_US,
+    902.0f,
+    928.0f,
+    100,
+    30,
+    false,
+    false,
+    &TEST_PROFILE_PRESET_HASH,
+    meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST,
+    "TEST_PRESET_HASH",
+};
+
 static const RegionInfo testRegions[] = {
     // A wide US-like region with spacing + padding
-    {meshtastic_Config_LoRaConfig_RegionCode_US, 902.0f, 928.0f, 100, 30, false, false, &TEST_PROFILE_SPACED, "TEST_US_SPACED"},
+    {meshtastic_Config_LoRaConfig_RegionCode_US, 902.0f, 928.0f, 100, 30, false, false, &TEST_PROFILE_SPACED,
+     meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST, "TEST_US_SPACED"},
 
     // A narrow band simulating tight EU regulation
     {meshtastic_Config_LoRaConfig_RegionCode_EU_868, 869.4f, 869.65f, 10, 14, false, false, &TEST_PROFILE_LICENSED,
-     "TEST_EU_LICENSED"},
+     meshtastic_Config_LoRaConfig_ModemPreset_LONG_SLOW, "TEST_EU_LICENSED"},
 
     // A wide-LoRa region with turbo-only presets
     {meshtastic_Config_LoRaConfig_RegionCode_LORA_24, 2400.0f, 2483.5f, 100, 10, false, true, &TEST_PROFILE_TURBO,
-     "TEST_LORA24_TURBO"},
+     meshtastic_Config_LoRaConfig_ModemPreset_SHORT_TURBO, "TEST_LORA24_TURBO"},
 
     // Sentinel — must be last
-    {meshtastic_Config_LoRaConfig_RegionCode_UNSET, 902.0f, 928.0f, 100, 30, false, false, &TEST_PROFILE_SPACED, "TEST_UNSET"},
+    {meshtastic_Config_LoRaConfig_RegionCode_UNSET, 902.0f, 928.0f, 100, 30, false, false, &TEST_PROFILE_SPACED,
+     meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST, "TEST_UNSET"},
 };
 
 static const RegionInfo *getTestRegion(meshtastic_Config_LoRaConfig_RegionCode code)
@@ -194,6 +236,13 @@ static const RegionInfo *getTestRegion(meshtastic_Config_LoRaConfig_RegionCode c
 // Shadow table tests
 // -----------------------------------------------------------------------
 
+// Helper: replicate the numFreqSlots formula from RadioInterface so tests can compute expected values.
+static uint32_t testComputeNumFreqSlots(const RegionInfo *r, float bw_kHz)
+{
+    float w = r->profile->spacing + (r->profile->padding * 2) + (bw_kHz / 1000.0f);
+    return (uint32_t)(((r->freqEnd - r->freqStart + r->profile->spacing) / w) + 0.5f);
+}
+
 static void test_shadowTable_spacedProfileHasNonZeroSpacing()
 {
     const RegionInfo *r = getTestRegion(meshtastic_Config_LoRaConfig_RegionCode_US);
@@ -268,6 +317,137 @@ static void test_shadowTable_unknownCodeFallsToSentinel()
     TEST_ASSERT_EQUAL_STRING("TEST_UNSET", r->name);
 }
 
+static void test_shadowTable_presetHashProfileHasCorrectOverrideSlot()
+{
+    TEST_ASSERT_EQUAL(OVERRIDE_SLOT_PRESET_HASH, TEST_PROFILE_PRESET_HASH.overrideSlot);
+    TEST_ASSERT_EQUAL(-1, TEST_PROFILE_PRESET_HASH.overrideSlot);
+    TEST_ASSERT_EQUAL(2, TEST_REGION_PRESET_HASH.getNumPresets());
+}
+
+// -----------------------------------------------------------------------
+// OVERRIDE_SLOT_PRESET_HASH (-1) slot formula tests
+//
+// Property under test:
+//   overrideSlot = -1  → slot = hash(presetDisplayName) % numSlots
+//     regardless of what the primary channel is named
+//   overrideSlot = 0   → slot = hash(channelName) % numSlots
+//     when channel name = preset display name, these two modes give identical slots
+// -----------------------------------------------------------------------
+
+static void test_overrideSlotPresetHash_longFast_customChannelMatchesDefaultNameSlot()
+{
+    // US + LONG_FAST: spacing=0, padding=0, bw=250 kHz
+    // numSlots = round((928-902+0)/0.250) = 104
+    const RegionInfo *us = getRegion(meshtastic_Config_LoRaConfig_RegionCode_US);
+    float bw = modemPresetToBwKHz(meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST, us->wideLora);
+    uint32_t numSlots = testComputeNumFreqSlots(us, bw);
+    TEST_ASSERT_EQUAL_UINT32(104, numSlots); // sanity
+
+    const char *presetName =
+        DisplayFormatters::getModemPresetDisplayName(meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST, false, true);
+
+    // OVERRIDE_SLOT_PRESET_HASH (-1):
+    //   channel is "MyCustomNetwork" but slot still uses preset name hash
+    uint32_t slotPresetHashMode = hash(presetName) % numSlots;
+
+    // OVERRIDE_SLOT_DEFAULT_CHANNEL_HASH (0) with channel name = preset name (user never renamed it):
+    //   channelName == presetName → same hash → same slot
+    const char *defaultChannelName = presetName;
+    uint32_t slotChannelHashModeDefaultName = hash(defaultChannelName) % numSlots;
+
+    TEST_ASSERT_EQUAL_UINT32(slotPresetHashMode, slotChannelHashModeDefaultName);
+
+    // Confirm a different custom channel name gives a different hash INPUT
+    // (so mode 0 would diverge while mode -1 stays locked)
+    TEST_ASSERT_TRUE(strcmp(presetName, "MyCustomNetwork") != 0);
+}
+
+static void test_overrideSlotPresetHash_mediumFast_customChannelMatchesDefaultNameSlot()
+{
+    // US + MEDIUM_FAST: bw=250 kHz → same 104 slots as LONG_FAST for US
+    const RegionInfo *us = getRegion(meshtastic_Config_LoRaConfig_RegionCode_US);
+    float bw = modemPresetToBwKHz(meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST, us->wideLora);
+    uint32_t numSlots = testComputeNumFreqSlots(us, bw);
+    TEST_ASSERT_EQUAL_UINT32(104, numSlots); // sanity
+
+    const char *presetName =
+        DisplayFormatters::getModemPresetDisplayName(meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST, false, true);
+
+    // Mode -1: slot = hash(presetName) % numSlots (channel name irrelevant)
+    uint32_t slotPresetHashMode = hash(presetName) % numSlots;
+
+    // Mode 0 + default name (channel name = preset display name):
+    uint32_t slotChannelHashModeDefaultName = hash(presetName) % numSlots;
+
+    TEST_ASSERT_EQUAL_UINT32(slotPresetHashMode, slotChannelHashModeDefaultName);
+
+    TEST_ASSERT_TRUE(strcmp(presetName, "MyCustomNetwork") != 0);
+}
+
+static void test_overrideSlotPresetHash_longFast_slotIsStableAcrossCustomNames()
+{
+    // Mode -1 must give the same slot for LONG_FAST regardless of which custom name is in use.
+    const RegionInfo *us = getRegion(meshtastic_Config_LoRaConfig_RegionCode_US);
+    float bw = modemPresetToBwKHz(meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST, us->wideLora);
+    uint32_t numSlots = testComputeNumFreqSlots(us, bw);
+
+    const char *presetName =
+        DisplayFormatters::getModemPresetDisplayName(meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST, false, true);
+    uint32_t expectedSlot = hash(presetName) % numSlots;
+
+    // Simulate three different custom channel names; mode -1 ignores all of them
+    const char *customNames[] = {"AlphaNet", "BetaMesh", "GammaMesh"};
+    for (int i = 0; i < 3; i++) {
+        uint32_t slotForCustom = hash(presetName) % numSlots; // mode -1: presetName only
+        TEST_ASSERT_EQUAL_UINT32(expectedSlot, slotForCustom);
+        // Confirm input would have differed in mode 0
+        TEST_ASSERT_TRUE(strcmp(presetName, customNames[i]) != 0);
+    }
+}
+
+static void test_overrideSlotPresetHash_mediumFast_slotIsStableAcrossCustomNames()
+{
+    const RegionInfo *us = getRegion(meshtastic_Config_LoRaConfig_RegionCode_US);
+    float bw = modemPresetToBwKHz(meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST, us->wideLora);
+    uint32_t numSlots = testComputeNumFreqSlots(us, bw);
+
+    const char *presetName =
+        DisplayFormatters::getModemPresetDisplayName(meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST, false, true);
+    uint32_t expectedSlot = hash(presetName) % numSlots;
+
+    const char *customNames[] = {"AlphaNet", "BetaMesh", "GammaMesh"};
+    for (int i = 0; i < 3; i++) {
+        uint32_t slotForCustom = hash(presetName) % numSlots; // mode -1: presetName only
+        TEST_ASSERT_EQUAL_UINT32(expectedSlot, slotForCustom);
+        TEST_ASSERT_TRUE(strcmp(presetName, customNames[i]) != 0);
+    }
+}
+
+static void test_overrideSlotPresetHash_longFastAndMediumFast_slotsAreDifferentPresets()
+{
+    // LONG_FAST and MEDIUM_FAST have different display names → likely different hash slots.
+    // This verifies the two presets genuinely occupy distinct positions, so the equivalence
+    // tests above are not trivially vacuous.
+    const RegionInfo *us = getRegion(meshtastic_Config_LoRaConfig_RegionCode_US);
+    float bw_lf = modemPresetToBwKHz(meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST, false);
+    float bw_mf = modemPresetToBwKHz(meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST, false);
+    uint32_t numSlots_lf = testComputeNumFreqSlots(us, bw_lf);
+    uint32_t numSlots_mf = testComputeNumFreqSlots(us, bw_mf);
+
+    const char *nameLF =
+        DisplayFormatters::getModemPresetDisplayName(meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST, false, true);
+    const char *nameMF =
+        DisplayFormatters::getModemPresetDisplayName(meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST, false, true);
+
+    TEST_ASSERT_TRUE(strcmp(nameLF, nameMF) != 0);
+
+    uint32_t slotLF = hash(nameLF) % numSlots_lf;
+    uint32_t slotMF = hash(nameMF) % numSlots_mf;
+    // They use the same numSlots (both 250 kHz on US), so a difference in display name
+    // should produce a different slot.
+    TEST_ASSERT_NOT_EQUAL(slotLF, slotMF);
+}
+
 // -----------------------------------------------------------------------
 // validateConfigLora() tests
 // -----------------------------------------------------------------------
@@ -769,6 +949,7 @@ void setup()
     RUN_TEST(test_shadowTable_channelSpacingWithPadding);
     RUN_TEST(test_shadowTable_turboOnlyOnWideLora);
     RUN_TEST(test_shadowTable_unknownCodeFallsToSentinel);
+    RUN_TEST(test_shadowTable_presetHashProfileHasCorrectOverrideSlot);
 
     // validateConfigLora()
     RUN_TEST(test_validateConfigLora_validPresetForUS);
@@ -798,6 +979,13 @@ void setup()
     RUN_TEST(test_regionFieldsAreSane);
     RUN_TEST(test_onlyLORA24HasWideLora);
 
+    // OVERRIDE_SLOT_PRESET_HASH (-1) slot formula tests
+    RUN_TEST(test_overrideSlotPresetHash_longFast_customChannelMatchesDefaultNameSlot);
+    RUN_TEST(test_overrideSlotPresetHash_mediumFast_customChannelMatchesDefaultNameSlot);
+    RUN_TEST(test_overrideSlotPresetHash_longFast_slotIsStableAcrossCustomNames);
+    RUN_TEST(test_overrideSlotPresetHash_mediumFast_slotIsStableAcrossCustomNames);
+    RUN_TEST(test_overrideSlotPresetHash_longFastAndMediumFast_slotsAreDifferentPresets);
+
     // Channel spacing (current + placeholder)
     RUN_TEST(test_channelSpacingCalculation_US_LONG_FAST);
     RUN_TEST(test_channelSpacingCalculation_EU868_LONG_FAST);

test/test_position_precision/test_main.cpp

@@ -19,6 +19,16 @@ static meshtastic_Position makePosition()
     return position;
 }
 
+static meshtastic_Channel makeChannel(meshtastic_Channel_Role role, bool hasModuleSettings, uint32_t positionPrecision)
+{
+    meshtastic_Channel channel = meshtastic_Channel_init_default;
+    channel.has_settings = true;
+    channel.role = role;
+    channel.settings.has_module_settings = hasModuleSettings;
+    channel.settings.module_settings.position_precision = positionPrecision;
+    return channel;
+}
+
 static void test_applyPositionPrecision_clampsLatLonAndSetsPrecisionBits()
 {
     meshtastic_Position position = makePosition();
@@ -80,6 +90,35 @@ static void test_applyPositionPrecision_reencodesPositionPacket()
     TEST_ASSERT_EQUAL_UINT32(16, decoded.precision_bits);
 }
 
+static void test_getPositionPrecisionForChannel_explicitPrecisionIsHonored()
+{
+    meshtastic_Channel channel = makeChannel(meshtastic_Channel_Role_PRIMARY, true, 16);
+
+    TEST_ASSERT_EQUAL_UINT32(16, getPositionPrecisionForChannel(channel));
+}
+
+static void test_getPositionPrecisionForChannel_explicitZeroDisablesPrimary()
+{
+    meshtastic_Channel channel = makeChannel(meshtastic_Channel_Role_PRIMARY, true, 0);
+
+    TEST_ASSERT_EQUAL_UINT32(0, getPositionPrecisionForChannel(channel));
+}
+
+static void test_getPositionPrecisionForChannel_primaryWithoutModuleSettingsFailsClosed()
+{
+    // Regression guard for #10509: precision 32 below must be ignored (no module settings).
+    meshtastic_Channel channel = makeChannel(meshtastic_Channel_Role_PRIMARY, false, 32);
+
+    TEST_ASSERT_EQUAL_UINT32(0, getPositionPrecisionForChannel(channel));
+}
+
+static void test_getPositionPrecisionForChannel_secondaryWithoutModuleSettingsFailsClosed()
+{
+    meshtastic_Channel channel = makeChannel(meshtastic_Channel_Role_SECONDARY, false, 32);
+
+    TEST_ASSERT_EQUAL_UINT32(0, getPositionPrecisionForChannel(channel));
+}
+
 void setUp(void) {}
 
 void tearDown(void) {}
@@ -93,6 +132,10 @@ void setup()
     RUN_TEST(test_applyPositionPrecision_fullPrecisionKeepsLatLon);
     RUN_TEST(test_applyPositionPrecision_zeroScrubsLocationButKeepsTime);
     RUN_TEST(test_applyPositionPrecision_reencodesPositionPacket);
+    RUN_TEST(test_getPositionPrecisionForChannel_explicitPrecisionIsHonored);
+    RUN_TEST(test_getPositionPrecisionForChannel_explicitZeroDisablesPrimary);
+    RUN_TEST(test_getPositionPrecisionForChannel_primaryWithoutModuleSettingsFailsClosed);
+    RUN_TEST(test_getPositionPrecisionForChannel_secondaryWithoutModuleSettingsFailsClosed);
     exit(UNITY_END());
 }
 

variants/esp32/esp32-common.ini

@@ -195,7 +195,7 @@ custom_sdkconfig =
   ;
   ; MBEDTLS
   ;
-  CONFIG_MBEDTLS_SSL_MAX_CONTENT_LEN=8192
+  CONFIG_MBEDTLS_SSL_MAX_CONTENT_LEN=16384 ; do not change, affects buffer allocation (PR10535)
   CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_FULL=n
   CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_CMN=y
   ; Switch to custom CA bundle (for Meshtastic MQTT/etc) in the future
@@ -205,10 +205,15 @@ custom_sdkconfig =
   CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_MAX_CERTS=1
   ; #shame
   CONFIG_MBEDTLS_ALLOW_WEAK_CERTIFICATE_VERIFICATION=y
-  CONFIG_MBEDTLS_SSL_RENEGOTIATION=n
-  CONFIG_MBEDTLS_SSL_PROTO_DTLS=n
-  CONFIG_MBEDTLS_CLIENT_SSL_SESSION_TICKETS=n
-  CONFIG_MBEDTLS_SERVER_SSL_SESSION_TICKETS=n
+  ; These six options must match the precompiled framework-arduinoespressif32-libs
+  ; which was built with all six enabled. Disabling them changes mbedtls_ssl_context
+  ; struct layout, causing an ABI mismatch and a crash in mbedtls_ssl_set_hostname.
+  CONFIG_MBEDTLS_SSL_RENEGOTIATION=y
+  CONFIG_MBEDTLS_SSL_PROTO_DTLS=y
+  CONFIG_MBEDTLS_CLIENT_SSL_SESSION_TICKETS=y
+  CONFIG_MBEDTLS_SERVER_SSL_SESSION_TICKETS=y
+  CONFIG_MBEDTLS_SSL_KEEP_PEER_CERTIFICATE=y
+  CONFIG_MBEDTLS_SSL_ALPN=y
   CONFIG_MBEDTLS_PKCS7_C=n
   CONFIG_MBEDTLS_CAMELLIA_C=n
   CONFIG_MBEDTLS_CCM_C=n

variants/nrf52840/diy/nrf52_promicro_diy_tcxo/platformio.ini

@@ -15,7 +15,6 @@ board = promicro-nrf52840
 build_flags = ${nrf52840_base.build_flags}
   -I variants/nrf52840/diy/nrf52_promicro_diy_tcxo
   -D NRF52_PROMICRO_DIY
-  ; -D RADIOLIB_GODMODE=1 ; needed for some LR2021 items, but not enabled by default.
 build_src_filter = ${nrf52_base.build_src_filter} +<../variants/nrf52840/diy/nrf52_promicro_diy_tcxo>
 debug_tool = jlink
 

variants/nrf54l15/nrf54l15.ini

@@ -66,7 +66,10 @@ lib_deps =
   https://github.com/adafruit/Adafruit_INA219/archive/refs/tags/1.2.3.zip
   https://github.com/RobTillaart/INA3221_RT/archive/refs/tags/0.4.2.zip
   https://github.com/RobTillaart/INA226/archive/refs/tags/0.6.6.zip
-  https://github.com/adafruit/Adafruit_SHT4X/archive/refs/tags/1.0.5.zip
+  ; SHTXXSensor gates on __has_include(<SHTSensor.h>), a header shipped by
+  ; Sensirion/arduino-sht. Adafruit_SHT4X ships Adafruit_SHT4X.h instead and
+  ; has no consumer in src/, so it left the SHT40 driver out of the build.
+  https://github.com/Sensirion/arduino-sht/archive/refs/tags/v1.2.6.zip
 
 lib_ignore =
   BluetoothOTA

variants/rp2350/diy/pico2_w5500_e22/README.md

@@ -0,0 +1,150 @@
+# Raspberry Pi Pico 2 + W5500 + E22-900M30S — Meshtastic Variant
+
+Meshtastic support for a **Raspberry Pi Pico 2** (RP2350, 4 MB flash) with an external **W5500** Ethernet module and an **EBYTE E22-900M30S** LoRa module.
+
+---
+
+## Required Hardware
+
+| Component | Model               | Notes                                    |
+| --------- | ------------------- | ---------------------------------------- |
+| MCU       | Raspberry Pi Pico 2 | RP2350 @ 150 MHz, 512 KB RAM, 4 MB flash |
+| Ethernet  | W5500 module        | Any WIZnet W5500 breakout board          |
+| LoRa      | EBYTE E22-900M30S   | SX1262 + 30 dBm PA, 868/915 MHz          |
+
+---
+
+## Pinout
+
+### System pins (Pico 2, fixed)
+
+| GPIO | Function                                |
+| ---- | --------------------------------------- |
+| GP24 | VBUS sense — HIGH when USB is connected |
+| GP25 | User LED (heartbeat)                    |
+| GP29 | ADC3 — VSYS/3, measures supply voltage  |
+
+### W5500 Ethernet (SPI0)
+
+| W5500 signal | Pico 2 GPIO |
+| ------------ | ----------- |
+| MISO         | GP16        |
+| CS / SCS     | GP17        |
+| SCK          | GP18        |
+| MOSI         | GP19        |
+| RST          | GP20        |
+| INT          | — (nc)      |
+| VCC          | 3.3V        |
+| GND          | GND         |
+
+> SPI0 is reserved for the W5500.
+
+### E22-900M30S LoRa (SPI1)
+
+| E22 signal | Pico 2 GPIO | Notes                                      |
+| ---------- | ----------- | ------------------------------------------ |
+| SCK        | GP10        | SPI1 clock                                 |
+| MOSI       | GP11        | SPI1 TX                                    |
+| MISO       | GP12        | SPI1 RX                                    |
+| NSS / CS   | GP13        | Chip select                                |
+| RESET      | GP15        | Active LOW reset                           |
+| DIO1       | GP14        | IRQ interrupt                              |
+| BUSY       | GP2         | Module busy indicator                      |
+| RXEN       | GP3         | LNA enable — held HIGH permanently         |
+| TXEN       | ← DIO2      | See wiring note below                      |
+| VCC        | 3.3V        | Add a 100 µF capacitor close to the module |
+| GND        | GND         | —                                          |
+
+> See `wiring.svg` in this directory for the full connection diagram.
+
+---
+
+## Special wiring: DIO2 → TXEN bridge on the E22 module
+
+The E22-900M30S does **not** connect DIO2 to the TXEN pin of its PA internally. They must be bridged with a short wire or solder bridge **on the module itself**:
+
+```text
+E22 DIO2 pin  ──┐
+                ├── wire / solder bridge on the module
+E22 TXEN pin  ──┘
+```
+
+With this bridge in place, `SX126X_DIO2_AS_RF_SWITCH` causes the SX1262 to drive DIO2 HIGH automatically during TX, enabling the PA without needing an RP2350 GPIO for TXEN.
+
+**Without this bridge the module will not transmit.**
+
+---
+
+## Build
+
+```bash
+pio run -e pico2_w5500_e22
+```
+
+### Flash — BOOTSEL mode
+
+1. Hold the **BOOTSEL** button on the Pico 2.
+2. Connect USB to the PC — it appears as a `RPI-RP2` storage drive.
+3. Copy the `.uf2` file:
+
+```text
+.pio/build/pico2_w5500_e22/firmware-pico2_w5500_e22-*.uf2
+```
+
+Or directly with picotool:
+
+```bash
+pio run -e pico2_w5500_e22 -t upload
+```
+
+---
+
+## Network usage
+
+This board uses Ethernet (no Wi-Fi). From the Meshtastic app:
+
+- **Enable Ethernet** under `Config → Network → Ethernet Enabled`
+- **DHCP** by default; static IP can also be configured
+
+Services available once connected:
+
+| Service | Details                     |
+| ------- | --------------------------- |
+| NTP     | Time synchronization        |
+| MQTT    | Messages to external broker |
+| API     | TCP socket on port 4403     |
+| Syslog  | Remote logging (optional)   |
+
+---
+
+## Technical notes
+
+### LoRa — RF control
+
+| Define                         | Effect                                                      |
+| ------------------------------ | ----------------------------------------------------------- |
+| `SX126X_ANT_SW 3`              | GP3 (RXEN) driven HIGH at init and never toggled again      |
+| `SX126X_DIO2_AS_RF_SWITCH`     | SX1262 drives DIO2 HIGH during TX → enables TXEN via bridge |
+| `SX126X_DIO3_TCXO_VOLTAGE 1.8` | E22 TCXO controlled by DIO3                                 |
+| `-D EBYTE_E22_900M30S`         | Sets `TX_GAIN_LORA=7`, max power 22 dBm                     |
+
+> RXEN and TXEN may both be HIGH simultaneously during TX — this is safe for the E22 RF switch.
+
+### Ethernet
+
+- Library: `arduino-libraries/Ethernet@^2.0.2` (supports W5100/W5200/W5500 auto-detection).
+- SPI0 is explicitly initialized with pins GP16/18/19 before `Ethernet.init()`.
+- DHCP timeout is set to 10 s (instead of the default 60 s) to avoid blocking LoRa startup.
+
+### HW_VENDOR
+
+Mapped to `meshtastic_HardwareModel_PRIVATE_HW` — no dedicated model exists in the Meshtastic protobuf for this hardware combination yet.
+
+---
+
+## Memory usage (reference build)
+
+| Resource | Used   | Total   | %     |
+| -------- | ------ | ------- | ----- |
+| RAM      | 94 KB  | 512 KB  | 18%   |
+| Flash    | 964 KB | 3.58 MB | 26.3% |

variants/rp2350/diy/pico2_w5500_e22/platformio.ini

@@ -0,0 +1,25 @@
+[env:pico2_w5500_e22]
+extends = rp2350_base
+board = rpipico2
+board_level = community
+upload_protocol = picotool
+
+build_flags =
+  ${rp2350_base.build_flags}
+  -ULED_BUILTIN                   # avoid "LED_BUILTIN redefined" warnings from framework common.h
+  -I variants/rp2350/diy/pico2_w5500_e22
+  -D HW_SPI1_DEVICE
+  -D EBYTE_E22_900M30S            # selects the EBYTE E22-900M30S module config, including TCXO voltage support and TX gain / max power settings
+
+# Re-enable Ethernet and API source paths excluded in rp2350_base
+build_src_filter = ${rp2350_base.build_src_filter} +<mesh/eth/> +<mesh/api/> +<mqtt/>
+
+lib_deps =
+  ${rp2350_base.lib_deps}
+  ${networking_base.lib_deps}
+  ${networking_extra.lib_deps}
+  # Standard WIZnet Ethernet library — supports W5100/W5200/W5500 auto-detect
+  arduino-libraries/Ethernet@^2.0.2
+
+debug_build_flags = ${rp2350_base.build_flags}, -g
+debug_tool = cmsis-dap

variants/rp2350/diy/pico2_w5500_e22/variant.h

@@ -0,0 +1,88 @@
+// Raspberry Pi Pico 2 + external W5500 Ethernet module + EBYTE E22-900M30S
+// RP2350 (4 MB flash) — wire modules to the GPIO pins listed below
+//
+// LoRa (SX1262 / E22-900M30S) on SPI1:
+//   SCK=GP10  MOSI=GP11  MISO=GP12  CS=GP13
+//   RST=GP15  DIO1/IRQ=GP14  BUSY=GP2  RXEN=GP3
+//   TXEN: bridge E22_DIO2 → E22_TXEN on the module (no RP2350 GPIO needed)
+//
+// W5500 Ethernet on SPI0:
+//   MISO=GP16  CS=GP17  SCK=GP18  MOSI=GP19  RST=GP20
+//
+// See wiring.svg in this directory for a complete connection diagram.
+
+// Community/DIY board — no dedicated Meshtastic HardwareModel
+#define PRIVATE_HW
+
+#define ARDUINO_ARCH_AVR
+
+// Onboard LED (GP25 on Pico 2)
+#define LED_POWER PIN_LED
+
+// Power monitoring
+// GP24: VBUS sense – HIGH when USB is present (digital read)
+// GP29: ADC3 measures VSYS/3 (200 kΩ / 100 kΩ divider, same as standard Pico 2)
+#define EXT_PWR_DETECT 24
+#define BATTERY_PIN 29
+#define ADC_MULTIPLIER 3.0
+#define BATTERY_SENSE_RESOLUTION_BITS 12
+// No real battery — suppress false "battery at 100%" while USB powers VSYS
+#define NO_BATTERY_LEVEL_ON_CHARGE
+
+// Optional user button — connect a button between GP6 and GND
+// #define BUTTON_PIN 6
+// #define BUTTON_NEED_PULLUP
+
+// GPS on UART1 (Serial2) — GP8 TX, GP9 RX
+// GP8/GP9 belong to UART1, so we must use Serial2 (not the default Serial1/UART0).
+// GP0/GP1 (UART0 defaults) are free but the firmware treats pin 0 as "not configured".
+// GP4/GP5 occupied by I2C (SCL/SDA for BMP-280).
+#define HAS_GPS 1
+#define GPS_TX_PIN 8
+#define GPS_RX_PIN 9
+#define GPS_BAUDRATE 38400
+#define GPS_SERIAL_PORT Serial2
+
+// ---- EBYTE E22-900M30S on SPI1 -----------------------------------------
+#define USE_SX1262
+
+#undef LORA_SCK
+#undef LORA_MISO
+#undef LORA_MOSI
+#undef LORA_CS
+
+#define LORA_SCK 10
+#define LORA_MOSI 11
+#define LORA_MISO 12
+#define LORA_CS 13
+
+#define LORA_DIO0 RADIOLIB_NC
+#define LORA_RESET 15
+#define LORA_DIO1 14 // IRQ
+#define LORA_DIO2 2  // BUSY
+#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
+// GP3 = RXEN: driven HIGH at init and held there (LNA always enabled).
+// SX1262 drives DIO2 HIGH during TX → TXEN via bridge on E22 module.
+#define SX126X_ANT_SW 3
+#define SX126X_DIO2_AS_RF_SWITCH
+#define SX126X_DIO3_TCXO_VOLTAGE 1.8
+#endif
+
+// ---- W5500 Ethernet on SPI0 --------------------------------------------
+#define HAS_ETHERNET 1
+// Use the arduino-libraries/Ethernet stack (W5500) instead of RAK13800_W5100S
+#define USE_ARDUINO_ETHERNET 1
+
+#define ETH_SPI0_MISO 16
+#define ETH_SPI0_SCK 18
+#define ETH_SPI0_MOSI 19
+
+#define PIN_ETHERNET_RESET 20
+#define PIN_ETHERNET_SS 17
+#define ETH_SPI_PORT SPI