Add portduino_status, assign hardware device IDs, and try to recover a CH341 device on a USB error

Co-authored-by: Jonathan Bennett <jbennett@incomsystems.biz>

bin/config-dist.yaml

@@ -203,16 +203,6 @@ HostMetrics:
 #  UserStringCommand: cat /sys/firmware/devicetree/base/serial-number # Command to execute, to send the results as the userString
 
 
-StoreAndForward:
-#  Enabled: true # Enable Store and Forward++, true by default
-#  DBPath: /var/lib/meshtasticd/ # Path to the S&F++ Sqlite DB
-#  Stratum0: false # Specify if this node is a Stratum 0 node, the controller node.
-#  InitialSync: 10 # Number of messages to 
-#  Hops: 3 # Number of hops to use for SF++ messages
-#  AnnounceInterval: 5 # Interval in minutes between announcing tip of chain hash
-#  MaxChainLength: 1000 # Maximum number of messages to store in a chain
-
-
 Config:
 #  DisplayMode: TWOCOLOR # uncomment to force BaseUI
 #  DisplayMode: COLOR # uncomment to force MUI

platformio.ini

@@ -95,7 +95,7 @@ lib_deps =
 	# renovate: datasource=custom.pio depName=NonBlockingRTTTL packageName=end2endzone/library/NonBlockingRTTTL
 	end2endzone/NonBlockingRTTTL@1.4.0
 build_flags = ${env.build_flags} -Os
-build_src_filter = ${env.build_src_filter} -<platform/portduino/> -<graphics/niche/> -<modules/Native/>
+build_src_filter = ${env.build_src_filter} -<platform/portduino/> -<graphics/niche/>
 
 ; Common libs for communicating over TCP/IP networks such as MQTT
 [networking_base]
@@ -119,7 +119,7 @@ lib_deps =
 [device-ui_base]
 lib_deps =
 	# renovate: datasource=git-refs depName=meshtastic/device-ui packageName=https://github.com/meshtastic/device-ui gitBranch=master
-	https://github.com/meshtastic/device-ui/archive/613c0953313bbd236f4ddc5ede447e9edf8e890a.zip
+	https://github.com/meshtastic/device-ui/archive/37ad715b76cd6ca4aa500a4a4d9740e3cdf3e3cb.zip
 
 ; Common libs for environmental measurements in telemetry module
 [environmental_base]

src/gps/RTC.cpp

@@ -397,7 +397,7 @@ uint32_t getValidTime(RTCQuality minQuality, bool local)
     return (currentQuality >= minQuality) ? getTime(local) : 0;
 }
 
-time_t gm_mktime(struct tm *tm)
+time_t gm_mktime(const struct tm *tm)
 {
 #if !MESHTASTIC_EXCLUDE_TZ
     time_t result = 0;
@@ -413,8 +413,8 @@ time_t gm_mktime(struct tm *tm)
     days_before_this_year -= 719162; // (1969 * 365 + 1969 / 4 - 1969 / 100 + 1969 / 400);
 
     // Now, within this tm->year, compute the days *before* this tm->month starts.
-    int days_before_month[12] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334}; // non-leap year
-    int days_this_year_before_this_month = days_before_month[tm->tm_mon];                // tm->tm_mon is 0..11
+    static const int days_before_month[12] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334}; // non-leap year
+    int days_this_year_before_this_month = days_before_month[tm->tm_mon];                             // tm->tm_mon is 0..11
 
     // If this is a leap year, and we're past February, add a day:
     if (tm->tm_mon >= 2 && (year % 4) == 0 && ((year % 100) != 0 || (year % 400) == 0)) {
@@ -435,6 +435,7 @@ time_t gm_mktime(struct tm *tm)
 
     return result;
 #else
-    return mktime(tm);
+    struct tm tmCopy = *tm;
+    return mktime(&tmCopy);
 #endif
 }

src/gps/RTC.h

@@ -54,7 +54,7 @@ uint32_t getValidTime(RTCQuality minQuality, bool local = false);
 
 RTCSetResult readFromRTC();
 
-time_t gm_mktime(struct tm *tm);
+time_t gm_mktime(const struct tm *tm);
 
 #define SEC_PER_DAY 86400
 #define SEC_PER_HOUR 3600

src/graphics/draw/MenuHandler.cpp

@@ -266,52 +266,8 @@ void menuHandler::FrequencySlotPicker()
 
     // Calculate number of channels (copied from RadioInterface::applyModemConfig())
     meshtastic_Config_LoRaConfig &loraConfig = config.lora;
-    double bw = loraConfig.bandwidth;
-    if (loraConfig.use_preset) {
-        switch (loraConfig.modem_preset) {
-        case meshtastic_Config_LoRaConfig_ModemPreset_SHORT_TURBO:
-            bw = (myRegion->wideLora) ? 1625.0 : 500;
-            break;
-        case meshtastic_Config_LoRaConfig_ModemPreset_SHORT_FAST:
-            bw = (myRegion->wideLora) ? 812.5 : 250;
-            break;
-        case meshtastic_Config_LoRaConfig_ModemPreset_SHORT_SLOW:
-            bw = (myRegion->wideLora) ? 812.5 : 250;
-            break;
-        case meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST:
-            bw = (myRegion->wideLora) ? 812.5 : 250;
-            break;
-        case meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_SLOW:
-            bw = (myRegion->wideLora) ? 812.5 : 250;
-            break;
-        case meshtastic_Config_LoRaConfig_ModemPreset_LONG_TURBO:
-            bw = (myRegion->wideLora) ? 1625.0 : 500;
-            break;
-        default:
-            bw = (myRegion->wideLora) ? 812.5 : 250;
-            break;
-        case meshtastic_Config_LoRaConfig_ModemPreset_LONG_MODERATE:
-            bw = (myRegion->wideLora) ? 406.25 : 125;
-            break;
-        case meshtastic_Config_LoRaConfig_ModemPreset_LONG_SLOW:
-            bw = (myRegion->wideLora) ? 406.25 : 125;
-            break;
-        }
-    } else {
-        bw = loraConfig.bandwidth;
-        if (bw == 31) // This parameter is not an integer
-            bw = 31.25;
-        if (bw == 62) // Fix for 62.5Khz bandwidth
-            bw = 62.5;
-        if (bw == 200)
-            bw = 203.125;
-        if (bw == 400)
-            bw = 406.25;
-        if (bw == 800)
-            bw = 812.5;
-        if (bw == 1600)
-            bw = 1625.0;
-    }
+    double bw = loraConfig.use_preset ? modemPresetToBwKHz(loraConfig.modem_preset, myRegion->wideLora)
+                                      : bwCodeToKHz(loraConfig.bandwidth);
 
     uint32_t numChannels = 0;
     if (myRegion) {

src/graphics/draw/MenuHandler.h

@@ -140,7 +140,7 @@ struct ScreenColor {
     uint8_t b;
     bool useVariant;
 
-    ScreenColor(uint8_t rIn = 0, uint8_t gIn = 0, uint8_t bIn = 0, bool variantIn = false)
+    explicit ScreenColor(uint8_t rIn = 0, uint8_t gIn = 0, uint8_t bIn = 0, bool variantIn = false)
         : r(rIn), g(gIn), b(bIn), useVariant(variantIn)
     {
     }

src/input/TrackballInterruptBase.cpp

@@ -1,5 +1,7 @@
 #include "TrackballInterruptBase.h"
+#include "Throttle.h"
 #include "configuration.h"
+
 extern bool osk_found;
 
 TrackballInterruptBase::TrackballInterruptBase(const char *name) : concurrency::OSThread(name), _originName(name) {}
@@ -55,17 +57,27 @@ int32_t TrackballInterruptBase::runOnce()
 {
     InputEvent e = {};
     e.inputEvent = INPUT_BROKER_NONE;
+#if TB_THRESHOLD
+    if (lastInterruptTime && !Throttle::isWithinTimespanMs(lastInterruptTime, 1000)) {
+        left_counter = 0;
+        right_counter = 0;
+        up_counter = 0;
+        down_counter = 0;
+        lastInterruptTime = 0;
+    }
+#ifdef INPUT_DEBUG
+    if (left_counter > 0 || right_counter > 0 || up_counter > 0 || down_counter > 0) {
+        LOG_DEBUG("L %u R %u U %u D %u, time %u", left_counter, right_counter, up_counter, down_counter, millis());
+    }
+#endif
+#endif
 
     // Handle long press detection for press button
     if (pressDetected && pressStartTime > 0) {
         uint32_t pressDuration = millis() - pressStartTime;
         bool buttonStillPressed = false;
 
-#if defined(T_DECK)
-        buttonStillPressed = (this->action == TB_ACTION_PRESSED);
-#else
         buttonStillPressed = !digitalRead(_pinPress);
-#endif
 
         if (!buttonStillPressed) {
             // Button released
@@ -134,23 +146,31 @@ int32_t TrackballInterruptBase::runOnce()
         }
     }
 
-#if defined(T_DECK) // T-deck gets a super-simple debounce on trackball
-    if (this->action == TB_ACTION_PRESSED && !pressDetected) {
+#if TB_THRESHOLD
+    if (this->action == TB_ACTION_PRESSED && (!pressDetected || pressStartTime == 0)) {
         // Start long press detection
         pressDetected = true;
         pressStartTime = millis();
         // Don't send event yet, wait to see if it's a long press
-    } else if (this->action == TB_ACTION_UP && lastEvent == TB_ACTION_UP) {
-        // LOG_DEBUG("Trackball event UP");
+    } else if (up_counter >= TB_THRESHOLD) {
+#ifdef INPUT_DEBUG
+        LOG_DEBUG("Trackball event UP %u", millis());
+#endif
         e.inputEvent = this->_eventUp;
-    } else if (this->action == TB_ACTION_DOWN && lastEvent == TB_ACTION_DOWN) {
-        // LOG_DEBUG("Trackball event DOWN");
+    } else if (down_counter >= TB_THRESHOLD) {
+#ifdef INPUT_DEBUG
+        LOG_DEBUG("Trackball event DOWN %u", millis());
+#endif
         e.inputEvent = this->_eventDown;
-    } else if (this->action == TB_ACTION_LEFT && lastEvent == TB_ACTION_LEFT) {
-        // LOG_DEBUG("Trackball event LEFT");
+    } else if (left_counter >= TB_THRESHOLD) {
+#ifdef INPUT_DEBUG
+        LOG_DEBUG("Trackball event LEFT %u", millis());
+#endif
         e.inputEvent = this->_eventLeft;
-    } else if (this->action == TB_ACTION_RIGHT && lastEvent == TB_ACTION_RIGHT) {
-        // LOG_DEBUG("Trackball event RIGHT");
+    } else if (right_counter >= TB_THRESHOLD) {
+#ifdef INPUT_DEBUG
+        LOG_DEBUG("Trackball event RIGHT %u", millis());
+#endif
         e.inputEvent = this->_eventRight;
     }
 #else
@@ -183,6 +203,12 @@ int32_t TrackballInterruptBase::runOnce()
         e.source = this->_originName;
         e.kbchar = 0x00;
         this->notifyObservers(&e);
+#if TB_THRESHOLD
+        left_counter = 0;
+        right_counter = 0;
+        up_counter = 0;
+        down_counter = 0;
+#endif
     }
 
     // Only update lastEvent for non-press actions or completed press actions
@@ -198,25 +224,49 @@ int32_t TrackballInterruptBase::runOnce()
 
 void TrackballInterruptBase::intPressHandler()
 {
-    this->action = TB_ACTION_PRESSED;
+    if (!Throttle::isWithinTimespanMs(lastInterruptTime, 10))
+        this->action = TB_ACTION_PRESSED;
+    lastInterruptTime = millis();
 }
 
 void TrackballInterruptBase::intDownHandler()
 {
-    this->action = TB_ACTION_DOWN;
+    if (TB_THRESHOLD || !Throttle::isWithinTimespanMs(lastInterruptTime, 10))
+        this->action = TB_ACTION_DOWN;
+    lastInterruptTime = millis();
+
+#if TB_THRESHOLD
+    down_counter++;
+#endif
 }
 
 void TrackballInterruptBase::intUpHandler()
 {
-    this->action = TB_ACTION_UP;
+    if (TB_THRESHOLD || !Throttle::isWithinTimespanMs(lastInterruptTime, 10))
+        this->action = TB_ACTION_UP;
+    lastInterruptTime = millis();
+
+#if TB_THRESHOLD
+    up_counter++;
+#endif
 }
 
 void TrackballInterruptBase::intLeftHandler()
 {
-    this->action = TB_ACTION_LEFT;
+    if (TB_THRESHOLD || !Throttle::isWithinTimespanMs(lastInterruptTime, 10))
+        this->action = TB_ACTION_LEFT;
+    lastInterruptTime = millis();
+#if TB_THRESHOLD
+    left_counter++;
+#endif
 }
 
 void TrackballInterruptBase::intRightHandler()
 {
-    this->action = TB_ACTION_RIGHT;
+    if (TB_THRESHOLD || !Throttle::isWithinTimespanMs(lastInterruptTime, 10))
+        this->action = TB_ACTION_RIGHT;
+    lastInterruptTime = millis();
+#if TB_THRESHOLD
+    right_counter++;
+#endif
 }

src/input/TrackballInterruptBase.h

@@ -12,6 +12,10 @@
 #endif
 #endif
 
+#ifndef TB_THRESHOLD
+#define TB_THRESHOLD 0
+#endif
+
 class TrackballInterruptBase : public Observable<const InputEvent *>, public concurrency::OSThread
 {
   public:
@@ -25,8 +29,6 @@ class TrackballInterruptBase : public Observable<const InputEvent *>, public con
     void intUpHandler();
     void intLeftHandler();
     void intRightHandler();
-    uint32_t lastTime = 0;
-
     virtual int32_t runOnce() override;
 
   protected:
@@ -67,4 +69,12 @@ class TrackballInterruptBase : public Observable<const InputEvent *>, public con
     input_broker_event _eventPressedLong = INPUT_BROKER_NONE;
     const char *_originName;
     TrackballInterruptBaseActionType lastEvent = TB_ACTION_NONE;
+    volatile uint32_t lastInterruptTime = 0;
+
+#if TB_THRESHOLD
+    volatile uint8_t left_counter = 0;
+    volatile uint8_t right_counter = 0;
+    volatile uint8_t up_counter = 0;
+    volatile uint8_t down_counter = 0;
+#endif
 };

src/input/TrackballInterruptImpl1.cpp

@@ -24,41 +24,26 @@ void TrackballInterruptImpl1::init(uint8_t pinDown, uint8_t pinUp, uint8_t pinLe
 
 void TrackballInterruptImpl1::handleIntDown()
 {
-    if (TB_DIRECTION == RISING || millis() > trackballInterruptImpl1->lastTime + 10) {
-        trackballInterruptImpl1->lastTime = millis();
-        trackballInterruptImpl1->intDownHandler();
-        trackballInterruptImpl1->setIntervalFromNow(20);
-    }
+    trackballInterruptImpl1->intDownHandler();
+    trackballInterruptImpl1->setIntervalFromNow(20);
 }
 void TrackballInterruptImpl1::handleIntUp()
 {
-    if (TB_DIRECTION == RISING || millis() > trackballInterruptImpl1->lastTime + 10) {
-        trackballInterruptImpl1->lastTime = millis();
-        trackballInterruptImpl1->intUpHandler();
-        trackballInterruptImpl1->setIntervalFromNow(20);
-    }
+    trackballInterruptImpl1->intUpHandler();
+    trackballInterruptImpl1->setIntervalFromNow(20);
 }
 void TrackballInterruptImpl1::handleIntLeft()
 {
-    if (TB_DIRECTION == RISING || millis() > trackballInterruptImpl1->lastTime + 10) {
-        trackballInterruptImpl1->lastTime = millis();
-        trackballInterruptImpl1->intLeftHandler();
-        trackballInterruptImpl1->setIntervalFromNow(20);
-    }
+    trackballInterruptImpl1->intLeftHandler();
+    trackballInterruptImpl1->setIntervalFromNow(20);
 }
 void TrackballInterruptImpl1::handleIntRight()
 {
-    if (TB_DIRECTION == RISING || millis() > trackballInterruptImpl1->lastTime + 10) {
-        trackballInterruptImpl1->lastTime = millis();
-        trackballInterruptImpl1->intRightHandler();
-        trackballInterruptImpl1->setIntervalFromNow(20);
-    }
+    trackballInterruptImpl1->intRightHandler();
+    trackballInterruptImpl1->setIntervalFromNow(20);
 }
 void TrackballInterruptImpl1::handleIntPressed()
 {
-    if (TB_DIRECTION == RISING || millis() > trackballInterruptImpl1->lastTime + 10) {
-        trackballInterruptImpl1->lastTime = millis();
-        trackballInterruptImpl1->intPressHandler();
-        trackballInterruptImpl1->setIntervalFromNow(20);
-    }
+    trackballInterruptImpl1->intPressHandler();
+    trackballInterruptImpl1->setIntervalFromNow(20);
 }

src/main.cpp

@@ -43,10 +43,6 @@
 #include "MessageStore.h"
 #endif
 
-#ifdef ELECROW_ThinkNode_M5
-PCA9557 io(0x18, &Wire);
-#endif
-
 #ifdef ARCH_ESP32
 #include "freertosinc.h"
 #if !MESHTASTIC_EXCLUDE_WEBSERVER
@@ -77,29 +73,10 @@ NRF52Bluetooth *nrf52Bluetooth = nullptr;
 #include "mqtt/MQTT.h"
 #endif
 
-#include "LLCC68Interface.h"
-#include "LR1110Interface.h"
-#include "LR1120Interface.h"
-#include "LR1121Interface.h"
-#include "RF95Interface.h"
-#include "SX1262Interface.h"
-#include "SX1268Interface.h"
-#include "SX1280Interface.h"
-#include "detect/LoRaRadioType.h"
-
-#ifdef ARCH_STM32WL
-#include "STM32WLE5JCInterface.h"
-#endif
-
-#if defined(ARCH_PORTDUINO)
-#include "platform/portduino/SimRadio.h"
-#endif
-
 #ifdef ARCH_PORTDUINO
 #include "linux/LinuxHardwareI2C.h"
 #include "mesh/raspihttp/PiWebServer.h"
 #include "platform/portduino/PortduinoGlue.h"
-#include "platform/portduino/USBHal.h"
 #include <cstdlib>
 #include <fstream>
 #include <iostream>
@@ -254,9 +231,6 @@ ScanI2C::DeviceAddress aqi_found = ScanI2C::ADDRESS_NONE;
 Adafruit_DRV2605 drv;
 #endif
 
-// Global LoRa radio type
-LoRaRadioType radioType = NO_RADIO;
-
 bool isVibrating = false;
 
 bool eink_found = true;
@@ -293,6 +267,7 @@ const char *getDeviceName()
     return name;
 }
 
+// TODO remove from main.cpp
 static int32_t ledBlinker()
 {
     // Still set up the blinking (heartbeat) interval but skip code path below, so LED will blink if
@@ -333,6 +308,9 @@ __attribute__((weak, noinline)) bool loopCanSleep()
 void lateInitVariant() __attribute__((weak));
 void lateInitVariant() {}
 
+void earlyInitVariant() __attribute__((weak));
+void earlyInitVariant() {}
+
 // NRF52 (and probably other platforms) can report when system is in power failure mode
 // (eg. too low battery voltage) and operating it is unsafe (data corruption, bootloops, etc).
 // For example NRF52 will prevent any flash writes in that case automatically
@@ -388,26 +366,14 @@ void setup()
     // boot sequence will follow when battery level raises to safe mode
     waitUntilPowerLevelSafe();
 
-#if defined(R1_NEO)
-    pinMode(DCDC_EN_HOLD, OUTPUT);
-    digitalWrite(DCDC_EN_HOLD, HIGH);
-    pinMode(NRF_ON, OUTPUT);
-    digitalWrite(NRF_ON, HIGH);
-#endif
+    // Defined in variant.cpp for early init code
+    earlyInitVariant();
 
 #if defined(PIN_POWER_EN)
     pinMode(PIN_POWER_EN, OUTPUT);
     digitalWrite(PIN_POWER_EN, HIGH);
 #endif
 
-#if defined(ELECROW_ThinkNode_M5)
-    Wire.begin(48, 47);
-    io.pinMode(PCA_PIN_EINK_EN, OUTPUT);
-    io.pinMode(PCA_PIN_POWER_EN, OUTPUT);
-    io.digitalWrite(PCA_PIN_POWER_EN, HIGH);
-    // io.pinMode(C2_PIN, OUTPUT);
-#endif
-
 #ifdef LED_POWER
     pinMode(LED_POWER, OUTPUT);
     digitalWrite(LED_POWER, LED_STATE_ON);
@@ -432,68 +398,7 @@ void setup()
 #endif
 #endif
 
-#if defined(T_DECK)
-    // GPIO10 manages all peripheral power supplies
-    // Turn on peripheral power immediately after MUC starts.
-    // If some boards are turned on late, ESP32 will reset due to low voltage.
-    // ESP32-C3(Keyboard) , MAX98357A(Audio Power Amplifier) ,
-    // TF Card , Display backlight(AW9364DNR) , AN48841B(Trackball) , ES7210(Decoder)
-    pinMode(KB_POWERON, OUTPUT);
-    digitalWrite(KB_POWERON, HIGH);
-    // T-Deck has all three SPI peripherals (TFT, SD, LoRa) attached to the same SPI bus
-    // We need to initialize all CS pins in advance otherwise there will be SPI communication issues
-    // e.g. when detecting the SD card
-    pinMode(LORA_CS, OUTPUT);
-    digitalWrite(LORA_CS, HIGH);
-    pinMode(SDCARD_CS, OUTPUT);
-    digitalWrite(SDCARD_CS, HIGH);
-    pinMode(TFT_CS, OUTPUT);
-    digitalWrite(TFT_CS, HIGH);
-    delay(100);
-#elif defined(T_DECK_PRO)
-    pinMode(LORA_EN, OUTPUT);
-    digitalWrite(LORA_EN, HIGH);
-    pinMode(LORA_CS, OUTPUT);
-    digitalWrite(LORA_CS, HIGH);
-    pinMode(SDCARD_CS, OUTPUT);
-    digitalWrite(SDCARD_CS, HIGH);
-    pinMode(PIN_EINK_CS, OUTPUT);
-    digitalWrite(PIN_EINK_CS, HIGH);
-#elif defined(T_LORA_PAGER)
-    pinMode(LORA_CS, OUTPUT);
-    digitalWrite(LORA_CS, HIGH);
-    pinMode(SDCARD_CS, OUTPUT);
-    digitalWrite(SDCARD_CS, HIGH);
-    pinMode(TFT_CS, OUTPUT);
-    digitalWrite(TFT_CS, HIGH);
-    pinMode(KB_INT, INPUT_PULLUP);
-    // io expander
-    io.begin(Wire, XL9555_SLAVE_ADDRESS0, SDA, SCL);
-    io.pinMode(EXPANDS_DRV_EN, OUTPUT);
-    io.digitalWrite(EXPANDS_DRV_EN, HIGH);
-    io.pinMode(EXPANDS_AMP_EN, OUTPUT);
-    io.digitalWrite(EXPANDS_AMP_EN, LOW);
-    io.pinMode(EXPANDS_LORA_EN, OUTPUT);
-    io.digitalWrite(EXPANDS_LORA_EN, HIGH);
-    io.pinMode(EXPANDS_GPS_EN, OUTPUT);
-    io.digitalWrite(EXPANDS_GPS_EN, HIGH);
-    io.pinMode(EXPANDS_KB_EN, OUTPUT);
-    io.digitalWrite(EXPANDS_KB_EN, HIGH);
-    io.pinMode(EXPANDS_SD_EN, OUTPUT);
-    io.digitalWrite(EXPANDS_SD_EN, HIGH);
-    io.pinMode(EXPANDS_GPIO_EN, OUTPUT);
-    io.digitalWrite(EXPANDS_GPIO_EN, HIGH);
-    io.pinMode(EXPANDS_SD_PULLEN, INPUT);
-#elif defined(HACKADAY_COMMUNICATOR)
-    pinMode(KB_INT, INPUT);
-#endif
-
     concurrency::hasBeenSetup = true;
-#if ARCH_PORTDUINO
-    SPISettings spiSettings(portduino_config.spiSpeed, MSBFIRST, SPI_MODE0);
-#else
-    SPISettings spiSettings(4000000, MSBFIRST, SPI_MODE0);
-#endif
 
     meshtastic_Config_DisplayConfig_OledType screen_model =
         meshtastic_Config_DisplayConfig_OledType::meshtastic_Config_DisplayConfig_OledType_OLED_AUTO;
@@ -632,6 +537,7 @@ void setup()
 
     OSThread::setup();
 
+    // TODO make this ifdef based on defined pins and move from main.cpp
 #if defined(ELECROW_ThinkNode_M1) || defined(ELECROW_ThinkNode_M2)
     // The ThinkNodes have their own blink logic
     // ledPeriodic = new Periodic("Blink", elecrowLedBlinker);
@@ -1009,6 +915,7 @@ void setup()
     }
 #endif // HAS_SCREEN
 
+    // TODO Remove magic string
     // setup TZ prior to time actions.
 #if !MESHTASTIC_EXCLUDE_TZ
     LOG_DEBUG("Use compiled/slipstreamed %s", slipstreamTZString); // important, removing this clobbers our magic string
@@ -1304,252 +1211,7 @@ void setup()
 #endif
 #endif
 
-#ifdef ARCH_PORTDUINO
-    // as one can't use a function pointer to the class constructor:
-    auto loraModuleInterface = [](LockingArduinoHal *hal, RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst,
-                                  RADIOLIB_PIN_TYPE busy) {
-        switch (portduino_config.lora_module) {
-        case use_rf95:
-            return (RadioInterface *)new RF95Interface(hal, cs, irq, rst, busy);
-        case use_sx1262:
-            return (RadioInterface *)new SX1262Interface(hal, cs, irq, rst, busy);
-        case use_sx1268:
-            return (RadioInterface *)new SX1268Interface(hal, cs, irq, rst, busy);
-        case use_sx1280:
-            return (RadioInterface *)new SX1280Interface(hal, cs, irq, rst, busy);
-        case use_lr1110:
-            return (RadioInterface *)new LR1110Interface(hal, cs, irq, rst, busy);
-        case use_lr1120:
-            return (RadioInterface *)new LR1120Interface(hal, cs, irq, rst, busy);
-        case use_lr1121:
-            return (RadioInterface *)new LR1121Interface(hal, cs, irq, rst, busy);
-        case use_llcc68:
-            return (RadioInterface *)new LLCC68Interface(hal, cs, irq, rst, busy);
-        case use_simradio:
-            return (RadioInterface *)new SimRadio;
-        default:
-            assert(0); // shouldn't happen
-            return (RadioInterface *)nullptr;
-        }
-    };
-
-    LOG_DEBUG("Activate %s radio on SPI port %s", portduino_config.loraModules[portduino_config.lora_module].c_str(),
-              portduino_config.lora_spi_dev.c_str());
-    if (portduino_config.lora_spi_dev == "ch341") {
-        RadioLibHAL = ch341Hal;
-    } else {
-        RadioLibHAL = new LockingArduinoHal(SPI, spiSettings);
-    }
-    rIf =
-        loraModuleInterface((LockingArduinoHal *)RadioLibHAL, portduino_config.lora_cs_pin.pin, portduino_config.lora_irq_pin.pin,
-                            portduino_config.lora_reset_pin.pin, portduino_config.lora_busy_pin.pin);
-
-    if (!rIf->init()) {
-        LOG_WARN("No %s radio", portduino_config.loraModules[portduino_config.lora_module].c_str());
-        delete rIf;
-        rIf = NULL;
-        exit(EXIT_FAILURE);
-    } else {
-        LOG_INFO("%s init success", portduino_config.loraModules[portduino_config.lora_module].c_str());
-    }
-
-#elif defined(HW_SPI1_DEVICE)
-    LockingArduinoHal *RadioLibHAL = new LockingArduinoHal(SPI1, spiSettings);
-#else // HW_SPI1_DEVICE
-    LockingArduinoHal *RadioLibHAL = new LockingArduinoHal(SPI, spiSettings);
-#endif
-
-    // radio init MUST BE AFTER service.init, so we have our radio config settings (from nodedb init)
-#if defined(USE_STM32WLx)
-    if (!rIf) {
-        rIf = new STM32WLE5JCInterface(RadioLibHAL, SX126X_CS, SX126X_DIO1, SX126X_RESET, SX126X_BUSY);
-        if (!rIf->init()) {
-            LOG_WARN("No STM32WL radio");
-            delete rIf;
-            rIf = NULL;
-        } else {
-            LOG_INFO("STM32WL init success");
-            radioType = STM32WLx_RADIO;
-        }
-    }
-#endif
-
-#if defined(RF95_IRQ) && RADIOLIB_EXCLUDE_SX127X != 1
-    if ((!rIf) && (config.lora.region != meshtastic_Config_LoRaConfig_RegionCode_LORA_24)) {
-        rIf = new RF95Interface(RadioLibHAL, LORA_CS, RF95_IRQ, RF95_RESET, RF95_DIO1);
-        if (!rIf->init()) {
-            LOG_WARN("No RF95 radio");
-            delete rIf;
-            rIf = NULL;
-        } else {
-            LOG_INFO("RF95 init success");
-            radioType = RF95_RADIO;
-        }
-    }
-#endif
-
-#if defined(USE_SX1262) && !defined(ARCH_PORTDUINO) && !defined(TCXO_OPTIONAL) && RADIOLIB_EXCLUDE_SX126X != 1
-    if ((!rIf) && (config.lora.region != meshtastic_Config_LoRaConfig_RegionCode_LORA_24)) {
-        auto *sxIf = new SX1262Interface(RadioLibHAL, SX126X_CS, SX126X_DIO1, SX126X_RESET, SX126X_BUSY);
-#ifdef SX126X_DIO3_TCXO_VOLTAGE
-        sxIf->setTCXOVoltage(SX126X_DIO3_TCXO_VOLTAGE);
-#endif
-        if (!sxIf->init()) {
-            LOG_WARN("No SX1262 radio");
-            delete sxIf;
-            rIf = NULL;
-        } else {
-            LOG_INFO("SX1262 init success");
-            rIf = sxIf;
-            radioType = SX1262_RADIO;
-        }
-    }
-#endif
-
-#if defined(USE_SX1262) && !defined(ARCH_PORTDUINO) && defined(TCXO_OPTIONAL)
-    if ((!rIf) && (config.lora.region != meshtastic_Config_LoRaConfig_RegionCode_LORA_24)) {
-        // try using the specified TCXO voltage
-        auto *sxIf = new SX1262Interface(RadioLibHAL, SX126X_CS, SX126X_DIO1, SX126X_RESET, SX126X_BUSY);
-        sxIf->setTCXOVoltage(SX126X_DIO3_TCXO_VOLTAGE);
-        if (!sxIf->init()) {
-            LOG_WARN("No SX1262 radio with TCXO, Vref %fV", SX126X_DIO3_TCXO_VOLTAGE);
-            delete sxIf;
-            rIf = NULL;
-        } else {
-            LOG_INFO("SX1262 init success, TCXO, Vref %fV", SX126X_DIO3_TCXO_VOLTAGE);
-            rIf = sxIf;
-            radioType = SX1262_RADIO;
-        }
-    }
-
-    if ((!rIf) && (config.lora.region != meshtastic_Config_LoRaConfig_RegionCode_LORA_24)) {
-        // If specified TCXO voltage fails, attempt to use DIO3 as a reference instead
-        rIf = new SX1262Interface(RadioLibHAL, SX126X_CS, SX126X_DIO1, SX126X_RESET, SX126X_BUSY);
-        if (!rIf->init()) {
-            LOG_WARN("No SX1262 radio with XTAL, Vref 0.0V");
-            delete rIf;
-            rIf = NULL;
-        } else {
-            LOG_INFO("SX1262 init success, XTAL, Vref 0.0V");
-            radioType = SX1262_RADIO;
-        }
-    }
-#endif
-
-#if defined(USE_SX1268)
-#if defined(SX126X_DIO3_TCXO_VOLTAGE) && defined(TCXO_OPTIONAL)
-    if ((!rIf) && (config.lora.region != meshtastic_Config_LoRaConfig_RegionCode_LORA_24)) {
-        // try using the specified TCXO voltage
-        auto *sxIf = new SX1268Interface(RadioLibHAL, SX126X_CS, SX126X_DIO1, SX126X_RESET, SX126X_BUSY);
-        sxIf->setTCXOVoltage(SX126X_DIO3_TCXO_VOLTAGE);
-        if (!sxIf->init()) {
-            LOG_WARN("No SX1268 radio with TCXO, Vref %fV", SX126X_DIO3_TCXO_VOLTAGE);
-            delete sxIf;
-            rIf = NULL;
-        } else {
-            LOG_INFO("SX1268 init success, TCXO, Vref %fV", SX126X_DIO3_TCXO_VOLTAGE);
-            rIf = sxIf;
-            radioType = SX1268_RADIO;
-        }
-    }
-#endif
-    if ((!rIf) && (config.lora.region != meshtastic_Config_LoRaConfig_RegionCode_LORA_24)) {
-        rIf = new SX1268Interface(RadioLibHAL, SX126X_CS, SX126X_DIO1, SX126X_RESET, SX126X_BUSY);
-        if (!rIf->init()) {
-            LOG_WARN("No SX1268 radio");
-            delete rIf;
-            rIf = NULL;
-        } else {
-            LOG_INFO("SX1268 init success");
-            radioType = SX1268_RADIO;
-        }
-    }
-#endif
-
-#if defined(USE_LLCC68)
-    if ((!rIf) && (config.lora.region != meshtastic_Config_LoRaConfig_RegionCode_LORA_24)) {
-        rIf = new LLCC68Interface(RadioLibHAL, SX126X_CS, SX126X_DIO1, SX126X_RESET, SX126X_BUSY);
-        if (!rIf->init()) {
-            LOG_WARN("No LLCC68 radio");
-            delete rIf;
-            rIf = NULL;
-        } else {
-            LOG_INFO("LLCC68 init success");
-            radioType = LLCC68_RADIO;
-        }
-    }
-#endif
-
-#if defined(USE_LR1110) && RADIOLIB_EXCLUDE_LR11X0 != 1
-    if ((!rIf) && (config.lora.region != meshtastic_Config_LoRaConfig_RegionCode_LORA_24)) {
-        rIf = new LR1110Interface(RadioLibHAL, LR1110_SPI_NSS_PIN, LR1110_IRQ_PIN, LR1110_NRESET_PIN, LR1110_BUSY_PIN);
-        if (!rIf->init()) {
-            LOG_WARN("No LR1110 radio");
-            delete rIf;
-            rIf = NULL;
-        } else {
-            LOG_INFO("LR1110 init success");
-            radioType = LR1110_RADIO;
-        }
-    }
-#endif
-
-#if defined(USE_LR1120) && RADIOLIB_EXCLUDE_LR11X0 != 1
-    if (!rIf) {
-        rIf = new LR1120Interface(RadioLibHAL, LR1120_SPI_NSS_PIN, LR1120_IRQ_PIN, LR1120_NRESET_PIN, LR1120_BUSY_PIN);
-        if (!rIf->init()) {
-            LOG_WARN("No LR1120 radio");
-            delete rIf;
-            rIf = NULL;
-        } else {
-            LOG_INFO("LR1120 init success");
-            radioType = LR1120_RADIO;
-        }
-    }
-#endif
-
-#if defined(USE_LR1121) && RADIOLIB_EXCLUDE_LR11X0 != 1
-    if (!rIf) {
-        rIf = new LR1121Interface(RadioLibHAL, LR1121_SPI_NSS_PIN, LR1121_IRQ_PIN, LR1121_NRESET_PIN, LR1121_BUSY_PIN);
-        if (!rIf->init()) {
-            LOG_WARN("No LR1121 radio");
-            delete rIf;
-            rIf = NULL;
-        } else {
-            LOG_INFO("LR1121 init success");
-            radioType = LR1121_RADIO;
-        }
-    }
-#endif
-
-#if defined(USE_SX1280) && RADIOLIB_EXCLUDE_SX128X != 1
-    if (!rIf) {
-        rIf = new SX1280Interface(RadioLibHAL, SX128X_CS, SX128X_DIO1, SX128X_RESET, SX128X_BUSY);
-        if (!rIf->init()) {
-            LOG_WARN("No SX1280 radio");
-            delete rIf;
-            rIf = NULL;
-        } else {
-            LOG_INFO("SX1280 init success");
-            radioType = SX1280_RADIO;
-        }
-    }
-#endif
-
-    // check if the radio chip matches the selected region
-    if ((config.lora.region == meshtastic_Config_LoRaConfig_RegionCode_LORA_24) && rIf && (!rIf->wideLora())) {
-        LOG_WARN("LoRa chip does not support 2.4GHz. Revert to unset");
-        config.lora.region = meshtastic_Config_LoRaConfig_RegionCode_UNSET;
-        nodeDB->saveToDisk(SEGMENT_CONFIG);
-
-        if (!rIf->reconfigure()) {
-            LOG_WARN("Reconfigure failed, rebooting");
-            if (screen) {
-                screen->showSimpleBanner("Rebooting...");
-            }
-            rebootAtMsec = millis() + 5000;
-        }
-    }
+    initLoRa();
 
     lateInitVariant(); // Do board specific init (see extra_variants/README.md for documentation)
 
@@ -1638,6 +1300,7 @@ bool suppressRebootBanner; // If true, suppress "Rebooting..." overlay (used for
 // This will suppress the current delay and instead try to run ASAP.
 bool runASAP;
 
+// TODO find better home than main.cpp
 extern meshtastic_DeviceMetadata getDeviceMetadata()
 {
     meshtastic_DeviceMetadata deviceMetadata;
@@ -1738,7 +1401,39 @@ void loop()
     if (inputBroker)
         inputBroker->processInputEventQueue();
 #endif
-#if ARCH_PORTDUINO && HAS_TFT
+#if ARCH_PORTDUINO
+    if (portduino_config.lora_spi_dev == "ch341" && ch341Hal != nullptr) {
+        ch341Hal->checkError();
+    }
+    if (portduino_status.LoRa_in_error && rebootAtMsec == 0) {
+        LOG_ERROR("LoRa in error detected, attempting to recover");
+        if (portduino_config.lora_spi_dev == "ch341") {
+            if (ch341Hal != nullptr) {
+                delete ch341Hal;
+                ch341Hal = nullptr;
+                sleep(3);
+            }
+            try {
+                ch341Hal = new Ch341Hal(0, portduino_config.lora_usb_serial_num, portduino_config.lora_usb_vid,
+                                        portduino_config.lora_usb_pid);
+            } catch (std::exception &e) {
+                std::cerr << e.what() << std::endl;
+                std::cerr << "Could not initialize CH341 device!" << std::endl;
+                exit(EXIT_FAILURE);
+            }
+        }
+        if (initLoRa()) {
+            router->addInterface(rIf);
+            portduino_status.LoRa_in_error = false;
+        } else {
+            LOG_WARN("Reconfigure failed, rebooting");
+            if (screen) {
+                screen->showSimpleBanner("Rebooting...");
+            }
+            rebootAtMsec = millis() + 25;
+        }
+    }
+#if HAS_TFT
     if (screen && portduino_config.displayPanel == x11 &&
         config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_COLOR) {
         auto dispdev = screen->getDisplayDevice();
@@ -1746,6 +1441,7 @@ void loop()
             static_cast<TFTDisplay *>(dispdev)->sdlLoop();
     }
 #endif
+#endif
 #if HAS_SCREEN && ENABLE_MESSAGE_PERSISTENCE
     messageStoreAutosaveTick();
 #endif

src/main.h

@@ -26,8 +26,8 @@ extern NRF52Bluetooth *nrf52Bluetooth;
 #if ARCH_PORTDUINO
 extern HardwareSPI *DisplaySPI;
 extern HardwareSPI *LoraSPI;
-
 #endif
+
 extern ScanI2C::DeviceAddress screen_found;
 extern ScanI2C::DeviceAddress cardkb_found;
 extern uint8_t kb_model;
@@ -47,16 +47,16 @@ extern bool isUSBPowered;
 extern Adafruit_DRV2605 drv;
 #endif
 
+#ifdef HAS_PCA9557
+#include <PCA9557.h>
+extern PCA9557 io;
+#endif
+
 #ifdef HAS_I2S
 #include "AudioThread.h"
 extern AudioThread *audioThread;
 #endif
 
-#ifdef ELECROW_ThinkNode_M5
-#include <PCA9557.h>
-extern PCA9557 io;
-#endif
-
 #ifdef HAS_UDP_MULTICAST
 #include "mesh/udp/UdpMulticastHandler.h"
 extern UdpMulticastHandler *udpHandler;

src/mesh/MeshRadio.h

@@ -23,3 +23,98 @@ extern const RegionInfo regions[];
 extern const RegionInfo *myRegion;
 
 extern void initRegion();
+
+static inline float bwCodeToKHz(uint16_t bwCode)
+{
+    if (bwCode == 31)
+        return 31.25f;
+    if (bwCode == 62)
+        return 62.5f;
+    if (bwCode == 200)
+        return 203.125f;
+    if (bwCode == 400)
+        return 406.25f;
+    if (bwCode == 800)
+        return 812.5f;
+    if (bwCode == 1600)
+        return 1625.0f;
+    return (float)bwCode;
+}
+
+static inline uint16_t bwKHzToCode(float bwKHz)
+{
+    if (bwKHz > 31.24f && bwKHz < 31.26f)
+        return 31;
+    if (bwKHz > 62.49f && bwKHz < 62.51f)
+        return 62;
+    if (bwKHz > 203.12f && bwKHz < 203.13f)
+        return 200;
+    if (bwKHz > 406.24f && bwKHz < 406.26f)
+        return 400;
+    if (bwKHz > 812.49f && bwKHz < 812.51f)
+        return 800;
+    if (bwKHz > 1624.99f && bwKHz < 1625.01f)
+        return 1600;
+    return (uint16_t)(bwKHz + 0.5f);
+}
+
+static inline void modemPresetToParams(meshtastic_Config_LoRaConfig_ModemPreset preset, bool wideLora, float &bwKHz, uint8_t &sf,
+                                       uint8_t &cr)
+{
+    switch (preset) {
+    case meshtastic_Config_LoRaConfig_ModemPreset_SHORT_TURBO:
+        bwKHz = wideLora ? 1625.0f : 500.0f;
+        cr = 5;
+        sf = 7;
+        break;
+    case meshtastic_Config_LoRaConfig_ModemPreset_SHORT_FAST:
+        bwKHz = wideLora ? 812.5f : 250.0f;
+        cr = 5;
+        sf = 7;
+        break;
+    case meshtastic_Config_LoRaConfig_ModemPreset_SHORT_SLOW:
+        bwKHz = wideLora ? 812.5f : 250.0f;
+        cr = 5;
+        sf = 8;
+        break;
+    case meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST:
+        bwKHz = wideLora ? 812.5f : 250.0f;
+        cr = 5;
+        sf = 9;
+        break;
+    case meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_SLOW:
+        bwKHz = wideLora ? 812.5f : 250.0f;
+        cr = 5;
+        sf = 10;
+        break;
+    case meshtastic_Config_LoRaConfig_ModemPreset_LONG_TURBO:
+        bwKHz = wideLora ? 1625.0f : 500.0f;
+        cr = 8;
+        sf = 11;
+        break;
+    case meshtastic_Config_LoRaConfig_ModemPreset_LONG_MODERATE:
+        bwKHz = wideLora ? 406.25f : 125.0f;
+        cr = 8;
+        sf = 11;
+        break;
+    case meshtastic_Config_LoRaConfig_ModemPreset_LONG_SLOW:
+        bwKHz = wideLora ? 406.25f : 125.0f;
+        cr = 8;
+        sf = 12;
+        break;
+    default: // LONG_FAST (or illegal)
+        bwKHz = wideLora ? 812.5f : 250.0f;
+        cr = 5;
+        sf = 11;
+        break;
+    }
+}
+
+static inline float modemPresetToBwKHz(meshtastic_Config_LoRaConfig_ModemPreset preset, bool wideLora)
+{
+    float bwKHz = 0;
+    uint8_t sf = 0;
+    uint8_t cr = 0;
+    modemPresetToParams(preset, wideLora, bwKHz, sf, cr);
+    return bwKHz;
+}

src/mesh/NextHopRouter.cpp

@@ -145,18 +145,6 @@ bool NextHopRouter::perhapsRebroadcast(const meshtastic_MeshPacket *p)
                         tosend->hop_start -= (tosend->hop_limit - 2);
                         tosend->hop_limit = 2;
                     }
-#elif ARCH_PORTDUINO
-                    if (tosend->which_payload_variant == meshtastic_MeshPacket_decoded_tag &&
-                        portduino_config.nohop_ports.size()) {
-                        for (const auto &port : portduino_config.nohop_ports) {
-                            if (port == tosend->decoded.portnum) {
-                                LOG_DEBUG("0-hopping portnum %u", tosend->decoded.portnum);
-                                tosend->hop_start -= tosend->hop_limit;
-                                tosend->hop_limit = 0;
-                                break;
-                            }
-                        }
-                    }
 #endif
 
                     if (p->next_hop == NO_NEXT_HOP_PREFERENCE) {

src/mesh/NodeDB.cpp

@@ -13,6 +13,7 @@
 #include "PacketHistory.h"
 #include "PowerFSM.h"
 #include "RTC.h"
+#include "RadioInterface.h"
 #include "Router.h"
 #include "SPILock.h"
 #include "SafeFile.h"
@@ -1298,6 +1299,13 @@ void NodeDB::loadFromDisk()
             LOG_INFO("Loaded saved config version %d", config.version);
         }
     }
+
+    // Coerce LoRa config fields derived from presets while bootstrapping.
+    // Some clients/UI components display bandwidth/spread_factor directly from config even in preset mode.
+    if (config.has_lora && config.lora.use_preset) {
+        RadioInterface::bootstrapLoRaConfigFromPreset(config.lora);
+    }
+
     if (backupSecurity.private_key.size > 0) {
         LOG_DEBUG("Restoring backup of security config");
         config.security = backupSecurity;
@@ -2239,7 +2247,10 @@ void recordCriticalError(meshtastic_CriticalErrorCode code, uint32_t address, co
 
     // Currently portuino is mostly used for simulation.  Make sure the user notices something really bad happened
 #ifdef ARCH_PORTDUINO
-    LOG_ERROR("A critical failure occurred, portduino is exiting");
-    exit(2);
+    LOG_ERROR("A critical failure occurred");
+    // TODO: Determine if other critical errors should also cause an immediate exit
+    if (code == meshtastic_CriticalErrorCode_FLASH_CORRUPTION_RECOVERABLE ||
+        code == meshtastic_CriticalErrorCode_FLASH_CORRUPTION_UNRECOVERABLE)
+        exit(2);
 #endif
 }

src/mesh/RadioInterface.cpp

@@ -1,17 +1,36 @@
 #include "RadioInterface.h"
 #include "Channels.h"
 #include "DisplayFormatters.h"
+#include "LLCC68Interface.h"
+#include "LR1110Interface.h"
+#include "LR1120Interface.h"
+#include "LR1121Interface.h"
 #include "MeshRadio.h"
 #include "MeshService.h"
 #include "NodeDB.h"
+#include "RF95Interface.h"
 #include "Router.h"
+#include "SX1262Interface.h"
+#include "SX1268Interface.h"
+#include "SX1280Interface.h"
 #include "configuration.h"
+#include "detect/LoRaRadioType.h"
 #include "main.h"
 #include "sleep.h"
 #include <assert.h>
 #include <pb_decode.h>
 #include <pb_encode.h>
 
+#ifdef ARCH_PORTDUINO
+#include "platform/portduino/PortduinoGlue.h"
+#include "platform/portduino/SimRadio.h"
+#include "platform/portduino/USBHal.h"
+#endif
+
+#ifdef ARCH_STM32WL>
+#include "STM32WLE5JCInterface.h"
+#endif
+
 // Calculate 2^n without calling pow()
 uint32_t pow_of_2(uint32_t n)
 {
@@ -205,6 +224,281 @@ bool RadioInterface::uses_default_frequency_slot = true;
 
 static uint8_t bytes[MAX_LORA_PAYLOAD_LEN + 1];
 
+// Global LoRa radio type
+LoRaRadioType radioType = NO_RADIO;
+
+extern RadioInterface *rIf;
+extern RadioLibHal *RadioLibHAL;
+#if defined(HW_SPI1_DEVICE) && defined(ARCH_ESP32)
+extern SPIClass SPI1;
+#endif
+
+bool initLoRa()
+{
+    if (rIf != nullptr) {
+        delete rIf;
+        rIf = nullptr;
+    }
+
+#if ARCH_PORTDUINO
+    SPISettings spiSettings(portduino_config.spiSpeed, MSBFIRST, SPI_MODE0);
+#else
+    SPISettings spiSettings(4000000, MSBFIRST, SPI_MODE0);
+#endif
+
+#ifdef ARCH_PORTDUINO
+    // as one can't use a function pointer to the class constructor:
+    auto loraModuleInterface = [](LockingArduinoHal *hal, RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst,
+                                  RADIOLIB_PIN_TYPE busy) {
+        switch (portduino_config.lora_module) {
+        case use_rf95:
+            return (RadioInterface *)new RF95Interface(hal, cs, irq, rst, busy);
+        case use_sx1262:
+            return (RadioInterface *)new SX1262Interface(hal, cs, irq, rst, busy);
+        case use_sx1268:
+            return (RadioInterface *)new SX1268Interface(hal, cs, irq, rst, busy);
+        case use_sx1280:
+            return (RadioInterface *)new SX1280Interface(hal, cs, irq, rst, busy);
+        case use_lr1110:
+            return (RadioInterface *)new LR1110Interface(hal, cs, irq, rst, busy);
+        case use_lr1120:
+            return (RadioInterface *)new LR1120Interface(hal, cs, irq, rst, busy);
+        case use_lr1121:
+            return (RadioInterface *)new LR1121Interface(hal, cs, irq, rst, busy);
+        case use_llcc68:
+            return (RadioInterface *)new LLCC68Interface(hal, cs, irq, rst, busy);
+        case use_simradio:
+            return (RadioInterface *)new SimRadio;
+        default:
+            assert(0); // shouldn't happen
+            return (RadioInterface *)nullptr;
+        }
+    };
+
+    LOG_DEBUG("Activate %s radio on SPI port %s", portduino_config.loraModules[portduino_config.lora_module].c_str(),
+              portduino_config.lora_spi_dev.c_str());
+    if (portduino_config.lora_spi_dev == "ch341") {
+        RadioLibHAL = ch341Hal;
+    } else {
+        if (RadioLibHAL != nullptr) {
+            delete RadioLibHAL;
+            RadioLibHAL = nullptr;
+        }
+        RadioLibHAL = new LockingArduinoHal(SPI, spiSettings);
+    }
+    rIf =
+        loraModuleInterface((LockingArduinoHal *)RadioLibHAL, portduino_config.lora_cs_pin.pin, portduino_config.lora_irq_pin.pin,
+                            portduino_config.lora_reset_pin.pin, portduino_config.lora_busy_pin.pin);
+
+    if (!rIf->init()) {
+        LOG_WARN("No %s radio", portduino_config.loraModules[portduino_config.lora_module].c_str());
+        delete rIf;
+        rIf = NULL;
+        exit(EXIT_FAILURE);
+    } else {
+        LOG_INFO("%s init success", portduino_config.loraModules[portduino_config.lora_module].c_str());
+    }
+
+#elif defined(HW_SPI1_DEVICE)
+    LockingArduinoHal *RadioLibHAL = new LockingArduinoHal(SPI1, spiSettings);
+#else // HW_SPI1_DEVICE
+    LockingArduinoHal *RadioLibHAL = new LockingArduinoHal(SPI, spiSettings);
+#endif
+
+// radio init MUST BE AFTER service.init, so we have our radio config settings (from nodedb init)
+#if defined(USE_STM32WLx)
+    if (!rIf) {
+        rIf = new STM32WLE5JCInterface(RadioLibHAL, SX126X_CS, SX126X_DIO1, SX126X_RESET, SX126X_BUSY);
+        if (!rIf->init()) {
+            LOG_WARN("No STM32WL radio");
+            delete rIf;
+            rIf = NULL;
+        } else {
+            LOG_INFO("STM32WL init success");
+            radioType = STM32WLx_RADIO;
+        }
+    }
+#endif
+
+#if defined(RF95_IRQ) && RADIOLIB_EXCLUDE_SX127X != 1
+    if ((!rIf) && (config.lora.region != meshtastic_Config_LoRaConfig_RegionCode_LORA_24)) {
+        rIf = new RF95Interface(RadioLibHAL, LORA_CS, RF95_IRQ, RF95_RESET, RF95_DIO1);
+        if (!rIf->init()) {
+            LOG_WARN("No RF95 radio");
+            delete rIf;
+            rIf = NULL;
+        } else {
+            LOG_INFO("RF95 init success");
+            radioType = RF95_RADIO;
+        }
+    }
+#endif
+
+#if defined(USE_SX1262) && !defined(ARCH_PORTDUINO) && !defined(TCXO_OPTIONAL) && RADIOLIB_EXCLUDE_SX126X != 1
+    if ((!rIf) && (config.lora.region != meshtastic_Config_LoRaConfig_RegionCode_LORA_24)) {
+        auto *sxIf = new SX1262Interface(RadioLibHAL, SX126X_CS, SX126X_DIO1, SX126X_RESET, SX126X_BUSY);
+#ifdef SX126X_DIO3_TCXO_VOLTAGE
+        sxIf->setTCXOVoltage(SX126X_DIO3_TCXO_VOLTAGE);
+#endif
+        if (!sxIf->init()) {
+            LOG_WARN("No SX1262 radio");
+            delete sxIf;
+            rIf = NULL;
+        } else {
+            LOG_INFO("SX1262 init success");
+            rIf = sxIf;
+            radioType = SX1262_RADIO;
+        }
+    }
+#endif
+
+#if defined(USE_SX1262) && !defined(ARCH_PORTDUINO) && defined(TCXO_OPTIONAL)
+    if ((!rIf) && (config.lora.region != meshtastic_Config_LoRaConfig_RegionCode_LORA_24)) {
+        // try using the specified TCXO voltage
+        auto *sxIf = new SX1262Interface(RadioLibHAL, SX126X_CS, SX126X_DIO1, SX126X_RESET, SX126X_BUSY);
+        sxIf->setTCXOVoltage(SX126X_DIO3_TCXO_VOLTAGE);
+        if (!sxIf->init()) {
+            LOG_WARN("No SX1262 radio with TCXO, Vref %fV", SX126X_DIO3_TCXO_VOLTAGE);
+            delete sxIf;
+            rIf = NULL;
+        } else {
+            LOG_INFO("SX1262 init success, TCXO, Vref %fV", SX126X_DIO3_TCXO_VOLTAGE);
+            rIf = sxIf;
+            radioType = SX1262_RADIO;
+        }
+    }
+
+    if ((!rIf) && (config.lora.region != meshtastic_Config_LoRaConfig_RegionCode_LORA_24)) {
+        // If specified TCXO voltage fails, attempt to use DIO3 as a reference instead
+        rIf = new SX1262Interface(RadioLibHAL, SX126X_CS, SX126X_DIO1, SX126X_RESET, SX126X_BUSY);
+        if (!rIf->init()) {
+            LOG_WARN("No SX1262 radio with XTAL, Vref 0.0V");
+            delete rIf;
+            rIf = NULL;
+        } else {
+            LOG_INFO("SX1262 init success, XTAL, Vref 0.0V");
+            radioType = SX1262_RADIO;
+        }
+    }
+#endif
+
+#if defined(USE_SX1268)
+#if defined(SX126X_DIO3_TCXO_VOLTAGE) && defined(TCXO_OPTIONAL)
+    if ((!rIf) && (config.lora.region != meshtastic_Config_LoRaConfig_RegionCode_LORA_24)) {
+        // try using the specified TCXO voltage
+        auto *sxIf = new SX1268Interface(RadioLibHAL, SX126X_CS, SX126X_DIO1, SX126X_RESET, SX126X_BUSY);
+        sxIf->setTCXOVoltage(SX126X_DIO3_TCXO_VOLTAGE);
+        if (!sxIf->init()) {
+            LOG_WARN("No SX1268 radio with TCXO, Vref %fV", SX126X_DIO3_TCXO_VOLTAGE);
+            delete sxIf;
+            rIf = NULL;
+        } else {
+            LOG_INFO("SX1268 init success, TCXO, Vref %fV", SX126X_DIO3_TCXO_VOLTAGE);
+            rIf = sxIf;
+            radioType = SX1268_RADIO;
+        }
+    }
+#endif
+    if ((!rIf) && (config.lora.region != meshtastic_Config_LoRaConfig_RegionCode_LORA_24)) {
+        rIf = new SX1268Interface(RadioLibHAL, SX126X_CS, SX126X_DIO1, SX126X_RESET, SX126X_BUSY);
+        if (!rIf->init()) {
+            LOG_WARN("No SX1268 radio");
+            delete rIf;
+            rIf = NULL;
+        } else {
+            LOG_INFO("SX1268 init success");
+            radioType = SX1268_RADIO;
+        }
+    }
+#endif
+
+#if defined(USE_LLCC68)
+    if ((!rIf) && (config.lora.region != meshtastic_Config_LoRaConfig_RegionCode_LORA_24)) {
+        rIf = new LLCC68Interface(RadioLibHAL, SX126X_CS, SX126X_DIO1, SX126X_RESET, SX126X_BUSY);
+        if (!rIf->init()) {
+            LOG_WARN("No LLCC68 radio");
+            delete rIf;
+            rIf = NULL;
+        } else {
+            LOG_INFO("LLCC68 init success");
+            radioType = LLCC68_RADIO;
+        }
+    }
+#endif
+
+#if defined(USE_LR1110) && RADIOLIB_EXCLUDE_LR11X0 != 1
+    if ((!rIf) && (config.lora.region != meshtastic_Config_LoRaConfig_RegionCode_LORA_24)) {
+        rIf = new LR1110Interface(RadioLibHAL, LR1110_SPI_NSS_PIN, LR1110_IRQ_PIN, LR1110_NRESET_PIN, LR1110_BUSY_PIN);
+        if (!rIf->init()) {
+            LOG_WARN("No LR1110 radio");
+            delete rIf;
+            rIf = NULL;
+        } else {
+            LOG_INFO("LR1110 init success");
+            radioType = LR1110_RADIO;
+        }
+    }
+#endif
+
+#if defined(USE_LR1120) && RADIOLIB_EXCLUDE_LR11X0 != 1
+    if (!rIf) {
+        rIf = new LR1120Interface(RadioLibHAL, LR1120_SPI_NSS_PIN, LR1120_IRQ_PIN, LR1120_NRESET_PIN, LR1120_BUSY_PIN);
+        if (!rIf->init()) {
+            LOG_WARN("No LR1120 radio");
+            delete rIf;
+            rIf = NULL;
+        } else {
+            LOG_INFO("LR1120 init success");
+            radioType = LR1120_RADIO;
+        }
+    }
+#endif
+
+#if defined(USE_LR1121) && RADIOLIB_EXCLUDE_LR11X0 != 1
+    if (!rIf) {
+        rIf = new LR1121Interface(RadioLibHAL, LR1121_SPI_NSS_PIN, LR1121_IRQ_PIN, LR1121_NRESET_PIN, LR1121_BUSY_PIN);
+        if (!rIf->init()) {
+            LOG_WARN("No LR1121 radio");
+            delete rIf;
+            rIf = NULL;
+        } else {
+            LOG_INFO("LR1121 init success");
+            radioType = LR1121_RADIO;
+        }
+    }
+#endif
+
+#if defined(USE_SX1280) && RADIOLIB_EXCLUDE_SX128X != 1
+    if (!rIf) {
+        rIf = new SX1280Interface(RadioLibHAL, SX128X_CS, SX128X_DIO1, SX128X_RESET, SX128X_BUSY);
+        if (!rIf->init()) {
+            LOG_WARN("No SX1280 radio");
+            delete rIf;
+            rIf = NULL;
+        } else {
+            LOG_INFO("SX1280 init success");
+            radioType = SX1280_RADIO;
+        }
+    }
+#endif
+
+    // check if the radio chip matches the selected region
+    if ((config.lora.region == meshtastic_Config_LoRaConfig_RegionCode_LORA_24) && rIf && (!rIf->wideLora())) {
+        LOG_WARN("LoRa chip does not support 2.4GHz. Revert to unset");
+        config.lora.region = meshtastic_Config_LoRaConfig_RegionCode_UNSET;
+        nodeDB->saveToDisk(SEGMENT_CONFIG);
+
+        if (rIf && !rIf->reconfigure()) {
+            LOG_WARN("Reconfigure failed, rebooting");
+            if (screen) {
+                screen->showSimpleBanner("Rebooting...");
+            }
+            rebootAtMsec = millis() + 5000;
+        }
+    }
+    return rIf != nullptr;
+}
+
 void initRegion()
 {
     const RegionInfo *r = regions;
@@ -220,6 +514,34 @@ void initRegion()
     myRegion = r;
 }
 
+void RadioInterface::bootstrapLoRaConfigFromPreset(meshtastic_Config_LoRaConfig &loraConfig)
+{
+    if (!loraConfig.use_preset) {
+        return;
+    }
+
+    // Find region info to determine whether "wide" LoRa is permitted (2.4 GHz uses wider bandwidth codes).
+    const RegionInfo *r = regions;
+    for (; r->code != meshtastic_Config_LoRaConfig_RegionCode_UNSET && r->code != loraConfig.region; r++)
+        ;
+
+    const bool regionWideLora = r->wideLora;
+
+    float bwKHz = 0;
+    uint8_t sf = 0;
+    uint8_t cr = 0;
+    modemPresetToParams(loraConfig.modem_preset, regionWideLora, bwKHz, sf, cr);
+
+    // If selected preset requests a bandwidth larger than the region span, fall back to LONG_FAST.
+    if (r->code != meshtastic_Config_LoRaConfig_RegionCode_UNSET && (r->freqEnd - r->freqStart) < (bwKHz / 1000.0f)) {
+        loraConfig.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST;
+        modemPresetToParams(loraConfig.modem_preset, regionWideLora, bwKHz, sf, cr);
+    }
+
+    loraConfig.bandwidth = bwKHzToCode(bwKHz);
+    loraConfig.spread_factor = sf;
+}
+
 /**
  * ## LoRaWAN for North America
 
@@ -326,9 +648,9 @@ uint32_t RadioInterface::getTxDelayMsecWeighted(meshtastic_MeshPacket *p)
 void printPacket(const char *prefix, const meshtastic_MeshPacket *p)
 {
 #if defined(DEBUG_PORT) && !defined(DEBUG_MUTE)
-    std::string out = DEBUG_PORT.mt_sprintf(
-        "%s (id=0x%08x fr=0x%08x to=0x%08x, transport = %u, WantAck=%d, HopLim=%d HopStart=%d Ch=0x%x", prefix, p->id, p->from,
-        p->to, p->transport_mechanism, p->want_ack, p->hop_limit, p->hop_start, p->channel);
+    std::string out =
+        DEBUG_PORT.mt_sprintf("%s (id=0x%08x fr=0x%08x to=0x%08x, transport = %u, WantAck=%d, HopLim=%d Ch=0x%x", prefix, p->id,
+                              p->from, p->to, p->transport_mechanism, p->want_ack, p->hop_limit, p->channel);
     if (p->which_payload_variant == meshtastic_MeshPacket_decoded_tag) {
         auto &s = p->decoded;
 
@@ -474,54 +796,7 @@ void RadioInterface::applyModemConfig()
     bool validConfig = false; // We need to check for a valid configuration
     while (!validConfig) {
         if (loraConfig.use_preset) {
-
-            switch (loraConfig.modem_preset) {
-            case meshtastic_Config_LoRaConfig_ModemPreset_SHORT_TURBO:
-                bw = (myRegion->wideLora) ? 1625.0 : 500;
-                cr = 5;
-                sf = 7;
-                break;
-            case meshtastic_Config_LoRaConfig_ModemPreset_SHORT_FAST:
-                bw = (myRegion->wideLora) ? 812.5 : 250;
-                cr = 5;
-                sf = 7;
-                break;
-            case meshtastic_Config_LoRaConfig_ModemPreset_SHORT_SLOW:
-                bw = (myRegion->wideLora) ? 812.5 : 250;
-                cr = 5;
-                sf = 8;
-                break;
-            case meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST:
-                bw = (myRegion->wideLora) ? 812.5 : 250;
-                cr = 5;
-                sf = 9;
-                break;
-            case meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_SLOW:
-                bw = (myRegion->wideLora) ? 812.5 : 250;
-                cr = 5;
-                sf = 10;
-                break;
-            case meshtastic_Config_LoRaConfig_ModemPreset_LONG_TURBO:
-                bw = (myRegion->wideLora) ? 1625.0 : 500;
-                cr = 8;
-                sf = 11;
-                break;
-            default: // Config_LoRaConfig_ModemPreset_LONG_FAST is default. Gracefully use this is preset is something illegal.
-                bw = (myRegion->wideLora) ? 812.5 : 250;
-                cr = 5;
-                sf = 11;
-                break;
-            case meshtastic_Config_LoRaConfig_ModemPreset_LONG_MODERATE:
-                bw = (myRegion->wideLora) ? 406.25 : 125;
-                cr = 8;
-                sf = 11;
-                break;
-            case meshtastic_Config_LoRaConfig_ModemPreset_LONG_SLOW:
-                bw = (myRegion->wideLora) ? 406.25 : 125;
-                cr = 8;
-                sf = 12;
-                break;
-            }
+            modemPresetToParams(loraConfig.modem_preset, myRegion->wideLora, bw, sf, cr);
             if (loraConfig.coding_rate >= 5 && loraConfig.coding_rate <= 8 && loraConfig.coding_rate != cr) {
                 cr = loraConfig.coding_rate;
                 LOG_INFO("Using custom Coding Rate %u", cr);
@@ -529,20 +804,7 @@ void RadioInterface::applyModemConfig()
         } else {
             sf = loraConfig.spread_factor;
             cr = loraConfig.coding_rate;
-            bw = loraConfig.bandwidth;
-
-            if (bw == 31) // This parameter is not an integer
-                bw = 31.25;
-            if (bw == 62) // Fix for 62.5Khz bandwidth
-                bw = 62.5;
-            if (bw == 200)
-                bw = 203.125;
-            if (bw == 400)
-                bw = 406.25;
-            if (bw == 800)
-                bw = 812.5;
-            if (bw == 1600)
-                bw = 1625.0;
+            bw = bwCodeToKHz(loraConfig.bandwidth);
         }
 
         if ((myRegion->freqEnd - myRegion->freqStart) < bw / 1000) {

src/mesh/RadioInterface.h

@@ -7,6 +7,9 @@
 #include "airtime.h"
 #include "error.h"
 
+// Forward decl to avoid a direct include of generated config headers / full LoRaConfig definition in this widely-included file.
+typedef struct _meshtastic_Config_LoRaConfig meshtastic_Config_LoRaConfig;
+
 #define MAX_TX_QUEUE 16 // max number of packets which can be waiting for transmission
 
 #define MAX_LORA_PAYLOAD_LEN 255 // max length of 255 per Semtech's datasheets on SX12xx
@@ -115,6 +118,12 @@ class RadioInterface
 
     virtual ~RadioInterface() {}
 
+    /**
+     * Coerce LoRa config fields (bandwidth/spread_factor) derived from presets.
+     * This is used during early bootstrapping so UIs that display these fields directly remain consistent.
+     */
+    static void bootstrapLoRaConfigFromPreset(meshtastic_Config_LoRaConfig &loraConfig);
+
     /**
      * Return true if we think the board can go to sleep (i.e. our tx queue is empty, we are not sending or receiving)
      *
@@ -270,5 +279,7 @@ class RadioInterface
     }
 };
 
+bool initLoRa();
+
 /// Debug printing for packets
 void printPacket(const char *prefix, const meshtastic_MeshPacket *p);

src/mesh/Router.cpp

@@ -7,7 +7,6 @@
 #include "RTC.h"
 
 #include "configuration.h"
-#include "detect/LoRaRadioType.h"
 #include "main.h"
 #include "mesh-pb-constants.h"
 #include "meshUtils.h"
@@ -17,7 +16,6 @@
 #endif
 #include "Default.h"
 #if ARCH_PORTDUINO
-#include "modules/Native/StoreForwardPlusPlus.h"
 #include "platform/portduino/PortduinoGlue.h"
 #endif
 #if ENABLE_JSON_LOGGING || ARCH_PORTDUINO
@@ -360,12 +358,6 @@ ErrorCode Router::send(meshtastic_MeshPacket *p)
             abortSendAndNak(encodeResult, p);
             return encodeResult; // FIXME - this isn't a valid ErrorCode
         }
-#if ARCH_PORTDUINO
-        if (p_decoded->decoded.portnum == meshtastic_PortNum_TEXT_MESSAGE_APP &&
-            (p->from == 0 || p->from == nodeDB->getNodeNum()) && storeForwardPlusPlusModule && portduino_config.sfpp_enabled) {
-            storeForwardPlusPlusModule->handleEncrypted(p_decoded, p);
-        }
-#endif
 #if !MESHTASTIC_EXCLUDE_MQTT
         // Only publish to MQTT if we're the original transmitter of the packet
         if (moduleConfig.mqtt.enabled && isFromUs(p) && mqtt) {
@@ -742,22 +734,6 @@ void Router::handleReceived(meshtastic_MeshPacket *p, RxSource src)
             cancelSending(p->from, p->id);
             skipHandle = true;
         }
-#if ARCH_PORTDUINO
-        if (portduino_config.whitelist_enabled) {
-            bool allowed = false;
-            for (const auto &port : portduino_config.whitelist_ports) {
-                if (port == p->decoded.portnum) {
-                    allowed = true;
-                    break;
-                }
-            }
-            if (!allowed) {
-                LOG_DEBUG("Dropping packet not on Portduino Whitelist");
-                cancelSending(p->from, p->id);
-                skipHandle = true;
-            }
-        }
-#endif
     } else {
         printPacket("packet decoding failed or skipped (no PSK?)", p);
     }

src/mesh/SX126xInterface.cpp

@@ -269,8 +269,12 @@ template <typename T> void SX126xInterface<T>::setStandby()
 
     if (err != RADIOLIB_ERR_NONE)
         LOG_DEBUG("SX126x standby %s%d", radioLibErr, err);
+#ifdef ARCH_PORTDUINO
+    if (err != RADIOLIB_ERR_NONE)
+        portduino_status.LoRa_in_error = true;
+#else
     assert(err == RADIOLIB_ERR_NONE);
-
+#endif
     isReceiving = false; // If we were receiving, not any more
     activeReceiveStart = 0;
     disableInterrupt();
@@ -313,7 +317,12 @@ template <typename T> void SX126xInterface<T>::startReceive()
     int err = lora.startReceiveDutyCycleAuto(preambleLength, 8, MESHTASTIC_RADIOLIB_IRQ_RX_FLAGS);
     if (err != RADIOLIB_ERR_NONE)
         LOG_ERROR("SX126X startReceiveDutyCycleAuto %s%d", radioLibErr, err);
+#ifdef ARCH_PORTDUINO
+    if (err != RADIOLIB_ERR_NONE)
+        portduino_status.LoRa_in_error = true;
+#else
     assert(err == RADIOLIB_ERR_NONE);
+#endif
 
     RadioLibInterface::startReceive();
 
@@ -341,7 +350,12 @@ template <typename T> bool SX126xInterface<T>::isChannelActive()
         return true;
     if (result != RADIOLIB_CHANNEL_FREE)
         LOG_ERROR("SX126X scanChannel %s%d", radioLibErr, result);
+#ifdef ARCH_PORTDUINO
+    if (result == RADIOLIB_ERR_WRONG_MODEM)
+        portduino_status.LoRa_in_error = true;
+#else
     assert(result != RADIOLIB_ERR_WRONG_MODEM);
+#endif
 
     return false;
 }

src/modules/Modules.cpp

@@ -61,7 +61,6 @@
 #if ARCH_PORTDUINO
 #include "input/LinuxInputImpl.h"
 #include "input/SeesawRotary.h"
-#include "modules/Native/StoreForwardPlusPlus.h"
 #include "modules/Telemetry/HostMetrics.h"
 #if !MESHTASTIC_EXCLUDE_STOREFORWARD
 #include "modules/StoreForwardModule.h"
@@ -244,11 +243,6 @@ void setupModules()
 #endif
 #if ARCH_PORTDUINO
     new HostMetricsModule();
-#if SFPP_ENABLED
-    if (portduino_config.sfpp_enabled) {
-        storeForwardPlusPlusModule = new StoreForwardPlusPlusModule();
-    }
-#endif
 #endif
 #if HAS_TELEMETRY
     new DeviceTelemetryModule();

src/modules/Native/StoreForwardPlusPlus.h

@@ -1,310 +0,0 @@
-#pragma once
-#if __has_include("sqlite3.h")
-#define SFPP_ENABLED 1
-#include "Channels.h"
-#include "ProtobufModule.h"
-#include "Router.h"
-#include "SinglePortModule.h"
-#include "sqlite3.h"
-
-#define SFPP_HASH_SIZE 16
-#define SFPP_SHORT_HASH_SIZE 8
-
-/**
- * Store and forward ++ module
- * There's an obvious need for a store-and-forward mechanism in Meshtastic.
- * This module takes heavy inspiration from Git, building a chain of messages that can be synced between nodes.
- * Each message is hashed, and the chain is built by hashing the previous commit hash and the current message hash.
- * Nodes can request missing messages by requesting the next message after a given commit hash.
- *
- * The current focus is text messages, limited to the primary channel.
- *
- * Each chain is identified by a root hash, which is derived from the channelHash, the local nodenum, and the timestamp when
- * created.
- *
- * Each message is also given a message hash, derived from the encrypted payload, the to, from, id.
- * Notably not the timestamp, as we want these to match across nodes, even if the timestamps differ.
- *
- * The authoritative node for the chain will generate a commit hash for each message when adding it to the chain.
- * The first message's commit hash is derived from the root hash and the message hash.
- * Subsequent messages' commit hashes are derived from the previous commit hash and the current message hash.
- * This allows a node to see only the last commit hash, and confirm it hasn't missed any messages.
- *
- * Nodes can request the next message in the chain by sending a LINK_REQUEST message with the root hash and the last known commit
- * hash. Any node that has the next message can respond with a LINK_PROVIDE message containing the next message.
- *
- * When a satellite node sees a new text message, it stores it in a scratch database.
- * These messages are periodically offered to the authoritative node for inclusion in the chain.
- *
- * The LINK_PROVIDE message does double-duty, sending both on-chain and off-chain messages.
- * The differentiator is whether the commit hash is set or left empty.
- *
- * When a satellite node receives a canonical link message, it checks if it has the message in scratch.
- * And evicts it when adding it to the canonical chain.
- *
- * This approach allows a node to know whether it has seen a given message before, or if it is new coming via SFPP.
- * If new, and the timestamp is within the rebroadcast timeout, it will process that message as if it were just received from the
- * mesh, allowing it to be decrypted, shown to the user, and rebroadcast.
- */
-class StoreForwardPlusPlusModule : public ProtobufModule<meshtastic_StoreForwardPlusPlus>, private concurrency::OSThread
-{
-    struct link_object {
-        uint32_t to;
-        uint32_t from;
-        uint32_t id;
-        uint32_t rx_time = 0;
-        ChannelHash channel_hash;
-        uint8_t encrypted_bytes[256] = {0};
-        size_t encrypted_len;
-        uint8_t message_hash[SFPP_HASH_SIZE] = {0};
-        size_t message_hash_len = 0;
-        uint8_t root_hash[SFPP_HASH_SIZE] = {0};
-        size_t root_hash_len = 0;
-        uint8_t commit_hash[SFPP_HASH_SIZE] = {0};
-        size_t commit_hash_len = 0;
-        uint32_t counter = 0;
-        std::string payload;
-        bool validObject = true; // set this false when a chain calulation fails, etc.
-    };
-
-  public:
-    /** Constructor
-     *
-     */
-    StoreForwardPlusPlusModule();
-
-    /*
-      -Override the wantPacket method.
-    */
-    virtual bool wantPacket(const meshtastic_MeshPacket *p) override
-    {
-        if (p->decoded.portnum == meshtastic_PortNum_TEXT_MESSAGE_APP ||
-            p->decoded.portnum == (portduino_config.sfpp_steal_port ? meshtastic_PortNum_TEXT_MESSAGE_COMPRESSED_APP
-                                                                    : meshtastic_PortNum_STORE_FORWARD_PLUSPLUS_APP)) {
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    void handleEncrypted(const meshtastic_MeshPacket *, const meshtastic_MeshPacket *);
-
-  protected:
-    /** Called to handle a particular incoming message
-    @return ProcessMessage::STOP if you've guaranteed you've handled this message and no other handlers should be considered for
-    it
-    */
-    virtual ProcessMessage handleReceived(const meshtastic_MeshPacket &mp) override;
-    virtual bool handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshtastic_StoreForwardPlusPlus *t) override;
-
-    virtual int32_t runOnce() override;
-
-  private:
-    sqlite3 *ppDb;
-    sqlite3_stmt *chain_insert_stmt;
-    sqlite3_stmt *scratch_insert_stmt;
-    sqlite3_stmt *checkDupMessageHash;
-    sqlite3_stmt *checkDupCommitHash;
-    sqlite3_stmt *checkScratch;
-    sqlite3_stmt *removeScratch;
-    sqlite3_stmt *updatePayloadStmt;
-    sqlite3_stmt *getPayloadFromScratchStmt;
-    sqlite3_stmt *fromScratchStmt;
-    sqlite3_stmt *fromScratchByHashStmt;
-    sqlite3_stmt *getNextHashStmt;
-    sqlite3_stmt *getChainEndStmt;
-    sqlite3_stmt *getLinkStmt;
-    sqlite3_stmt *getLinkFromMessageHashStmt;
-    sqlite3_stmt *getHashFromRootStmt;
-    sqlite3_stmt *addRootToMappingsStmt;
-    sqlite3_stmt *getRootFromChannelHashStmt;
-    sqlite3_stmt *getFullRootHashStmt;
-    sqlite3_stmt *setChainCountStmt;
-    sqlite3_stmt *getChainCountStmt;
-    sqlite3_stmt *getScratchCountStmt;
-    sqlite3_stmt *getRootCanonScratchCountStmt;
-    sqlite3_stmt *pruneScratchQueueStmt;
-    sqlite3_stmt *trimOldestLinkStmt;
-    sqlite3_stmt *maybeAddPeerStmt;
-    sqlite3_stmt *getPeerStmt;
-    sqlite3_stmt *updatePeerStmt;
-    sqlite3_stmt *clearChainStmt;
-    sqlite3_stmt *canon_scratch_insert_stmt;
-    sqlite3_stmt *getCanonScratchCountStmt;
-    sqlite3_stmt *getCanonScratchStmt;
-    sqlite3_stmt *removeCanonScratch;
-    sqlite3_stmt *clearCanonScratchStmt;
-
-    // For a given Meshtastic ChannelHash, fills the root_hash buffer with a 32-byte root hash
-    // returns true if the root hash was found
-    bool getRootFromChannelHash(ChannelHash, uint8_t *);
-
-    // For a given root hash, returns the ChannelHash
-    // can handle partial root hashes
-    ChannelHash getChannelHashFromRoot(uint8_t *_root_hash, size_t);
-
-    // given a root hash and commit hash, returns the next commit hash in the chain
-    // can handle partial root and commit hashes, always fills the buffer with 32 bytes
-    // returns true if a next hash was found
-    bool getNextHash(uint8_t *, size_t, uint8_t *, size_t, uint8_t *);
-
-    // For a given Meshtastic ChannelHash, fills the root_hash buffer with a 32-byte root hash
-    // but this function will add the root hash if it is not already present
-    // returns hash size or 0 if not found/added
-    size_t getOrAddRootFromChannelHash(ChannelHash, uint8_t *);
-
-    // adds the ChannelHash and root_hash to the mappings table
-    void addRootToMappings(ChannelHash, uint8_t *);
-
-    // requests the next message in the chain from the mesh network
-    // Sends a LINK_REQUEST message
-    void requestNextMessage(uint8_t *, size_t, uint8_t *, size_t);
-
-    // request the message X entries from the end.
-    // used to bootstrap a chain, without downloading all of the history
-    void requestMessageCount(uint8_t *, size_t, uint32_t);
-
-    // sends a LINK_PROVIDE message broadcasting the given link object
-    void broadcastLink(uint8_t *, size_t);
-
-    // sends a LINK_PROVIDE message broadcasting the given link object
-    void broadcastLink(link_object &, bool, bool = false);
-
-    // sends a LINK_PROVIDE message broadcasting the given link object from scratch message store
-    bool sendFromScratch(uint8_t *);
-
-    // Adds the given link object to the canonical chain database
-    bool addToChain(link_object &);
-
-    // Adds an incoming text message to the scratch database
-    bool addToScratch(link_object &);
-
-    // sends a CANON_ANNOUNCE message, specifying the given root and commit hashes
-    void canonAnnounce(link_object &);
-
-    // checks if the message hash is present in the canonical chain database
-    bool isInDB(uint8_t *, size_t);
-
-    // checks if the commit hash is present in the canonical chain database
-    bool isCommitInDB(uint8_t *, size_t);
-
-    // checks if the message hash is present in the scratch database
-    bool isInScratch(uint8_t *, size_t);
-
-    // retrieves a link object from the scratch database
-    link_object getFromScratch(uint8_t *, size_t);
-
-    // removes a link object from the scratch database
-    void removeFromScratch(uint8_t *, size_t);
-
-    // iterate through our scratch database, and see if we can speculate a chain up to the given commit hash
-    bool speculateScratchChain(uint8_t *, size_t, uint8_t *, uint8_t *);
-
-    // retrieves the next link object from scratch given a root hash
-    link_object getNextScratchObject(uint8_t *);
-
-    // fills the payload section with the decrypted data for the given message hash
-    // probably not needed for production, but useful for testing
-    void updatePayload(uint8_t *, size_t, std::string);
-
-    // Takes the decrypted MeshPacket and the encrypted packet copy, and builds a link_object
-    // Generates a message hash, but does not set the commit hash
-    link_object ingestTextPacket(const meshtastic_MeshPacket &, const meshtastic_MeshPacket *);
-
-    // ingests a LINK_PROVIDE message and builds a link_object
-    // confirms the root hash and commit hash
-    link_object ingestLinkMessage(meshtastic_StoreForwardPlusPlus *);
-
-    // retrieves a link object from the canonical chain database given a commit hash
-    link_object getLink(uint8_t *, size_t);
-
-    // retrieves a link object from the canonical chain database given a message hash
-    link_object getLinkFromMessageHash(uint8_t *, size_t);
-
-    // puts the encrypted payload back into the queue as if it were just received
-    void rebroadcastLinkObject(link_object &);
-
-    // Check if an incoming link object's commit hash matches the calculated commit hash
-    bool checkCommitHash(link_object &lo, uint8_t *commit_hash_bytes, size_t hash_len);
-
-    // given a partial root hash, looks up the full 32-byte root hash
-    // returns true if found
-    bool lookUpFullRootHash(uint8_t *partial_root_hash, size_t partial_root_hash_len, uint8_t *full_root_hash);
-
-    // update the mappings table to set the chain count for the given root hash
-    void setChainCount(uint8_t *, size_t, uint32_t);
-
-    // get the chain count for the given root hash
-    uint32_t getChainCount(uint8_t *, size_t);
-
-    // get the scratch count for the given root hash
-    uint32_t getScratchCount(uint8_t *, size_t);
-
-    // get the canon scratch count for the given root hash
-    uint32_t getCanonScratchCount(uint8_t *, size_t);
-
-    link_object getLinkFromPositionFromTip(uint32_t, uint8_t *, size_t);
-
-    void pruneScratchQueue();
-
-    void trimOldestLink(uint8_t *, size_t);
-
-    void clearChain(uint8_t *, size_t);
-
-    void recalculateMessageHash(link_object &);
-
-    // given a link object with a payload and other fields, recalculates the message hash
-    // returns true if a match
-    bool recalculateHash(link_object &, uint8_t *, size_t, uint8_t *, size_t);
-
-    void updatePeers(const meshtastic_MeshPacket &, meshtastic_StoreForwardPlusPlus_SFPP_message_type);
-
-    void maybeMoveFromCanonScratch(uint8_t *, size_t);
-
-    void addToCanonScratch(link_object &);
-
-    link_object getfromCanonScratch(uint8_t *, size_t);
-    void removeFromCanonScratch(uint8_t *, size_t);
-
-    void clearCanonScratch(uint8_t *, size_t, uint32_t);
-
-    bool isInCanonScratch(uint8_t *, size_t);
-
-    void logLinkObject(link_object &);
-
-    // Track if we have a scheduled runOnce pending
-    // useful to not accudentally delay a scheduled runOnce
-    bool pendingRun = false;
-
-    // Once we have multiple chain types, we can extend this
-    enum chain_types {
-        channel_chain = 0,
-    };
-
-    uint32_t rebroadcastTimeout = 3600; // Messages older than this (in seconds) will not be rebroadcast
-    bool doing_split_send = false;
-    link_object split_link_out;
-
-    bool doing_split_receive = false;
-    link_object split_link_in;
-
-    bool did_announce_last = false;
-
-    uint32_t texts_rebroadcast = 0;
-    uint32_t links_speculated = 0;
-    uint32_t canon_announces = 0;
-    uint32_t links_requested = 0;
-    uint32_t links_provided = 0;
-    uint32_t links_added = 0;
-    uint32_t links_from_canon_scratch = 0;
-    uint32_t links_from_scratch = 0;
-    uint32_t split_links_sent = 0;
-    uint32_t split_links_received = 0;
-    uint32_t links_pruned = 0;
-    uint32_t scratch_timed_out = 0;
-    uint32_t sent_from_scratch = 0;
-    uint32_t received_from_scratch = 0;
-};
-
-extern StoreForwardPlusPlusModule *storeForwardPlusPlusModule;
-#endif

src/mqtt/MQTT.cpp

@@ -475,8 +475,10 @@ bool MQTT::publish(const char *topic, const char *payload, bool retained)
     if (moduleConfig.mqtt.proxy_to_client_enabled) {
         meshtastic_MqttClientProxyMessage *msg = mqttClientProxyMessagePool.allocZeroed();
         msg->which_payload_variant = meshtastic_MqttClientProxyMessage_text_tag;
-        strcpy(msg->topic, topic);
-        strcpy(msg->payload_variant.text, payload);
+        strncpy(msg->topic, topic, sizeof(msg->topic));
+        msg->topic[sizeof(msg->topic) - 1] = '\0';
+        strncpy(msg->payload_variant.text, payload, sizeof(msg->payload_variant.text));
+        msg->payload_variant.text[sizeof(msg->payload_variant.text) - 1] = '\0';
         msg->retained = retained;
         service->sendMqttMessageToClientProxy(msg);
         return true;

src/platform/extra_variants/README.md

@@ -5,7 +5,7 @@ This directory tree is designed to solve two problems.
 - The ESP32 arduino/platformio project doesn't support the nice "if initVariant() is found, call that after init" behavior of the nrf52 builds (they use initVariant() internally).
 - Over the years a lot of 'board specific' init code has been added to init() in main.cpp. It would be great to have a general/clean mechanism to allow developers to specify board specific/unique code in a clean fashion without mucking in main.
 
-So we are borrowing the initVariant() ideas here (by using weak gcc references). You can now define lateInitVariant() if your board needs it.
+So we are borrowing the initVariant() ideas here (by using weak gcc references). You can now define earlyInitVariant() and lateInitVariant() if your board needs them. earlyInitVariant() runs at the beginning of setup() directly after waitUntilPowerLevelSafe(); while lateInitVariant() runs after the LoRa radio is initialized.
 
 If you'd like a board specific variant to be run, add the variant.cpp file to an appropriately named
 subdirectory and check for \_VARIANT_boardname in the cpp file (so that your code is only built for your board).

src/platform/nrf52/main-nrf52.cpp

@@ -430,15 +430,6 @@ void cpuDeepSleep(uint32_t msecToWake)
         Serial1.end();
 #endif
 
-#ifdef TTGO_T_ECHO
-    // To power off the T-Echo, the display must be set
-    // as an input pin; otherwise, there will be leakage current.
-    pinMode(PIN_EINK_CS, INPUT);
-    pinMode(PIN_EINK_DC, INPUT);
-    pinMode(PIN_EINK_RES, INPUT);
-    pinMode(PIN_EINK_BUSY, INPUT);
-#endif
-
     setBluetoothEnable(false);
 
 #ifdef RAK4630
@@ -449,57 +440,8 @@ void cpuDeepSleep(uint32_t msecToWake)
     // RAK-12039 set pin for Air quality sensor
     digitalWrite(AQ_SET_PIN, LOW);
 #endif
-#ifdef RAK14014
-    // GPIO restores input status, otherwise there will be leakage current
-    nrf_gpio_cfg_default(TFT_BL);
-    nrf_gpio_cfg_default(TFT_DC);
-    nrf_gpio_cfg_default(TFT_CS);
-    nrf_gpio_cfg_default(TFT_SCLK);
-    nrf_gpio_cfg_default(TFT_MOSI);
-    nrf_gpio_cfg_default(TFT_MISO);
-    nrf_gpio_cfg_default(SCREEN_TOUCH_INT);
-    nrf_gpio_cfg_default(WB_I2C1_SCL);
-    nrf_gpio_cfg_default(WB_I2C1_SDA);
-
-    // nrf_gpio_cfg_default(WB_I2C2_SCL);
-    // nrf_gpio_cfg_default(WB_I2C2_SDA);
-#endif
-#endif
-#ifdef MESHLINK
-#ifdef PIN_WD_EN
-    digitalWrite(PIN_WD_EN, LOW);
-#endif
-#endif
-
-#if defined(HELTEC_MESH_NODE_T114) || defined(HELTEC_MESH_SOLAR)
-    nrf_gpio_cfg_default(PIN_GPS_PPS);
-    detachInterrupt(PIN_GPS_PPS);
-    detachInterrupt(PIN_BUTTON1);
-#endif
-
-#ifdef ELECROW_ThinkNode_M1
-    for (int pin = 0; pin < 48; pin++) {
-        if (pin == 17 || pin == 19 || pin == 20 || pin == 22 || pin == 23 || pin == 24 || pin == 25 || pin == 9 || pin == 10 ||
-            pin == PIN_BUTTON1 || pin == PIN_BUTTON2) {
-            continue;
-        }
-        pinMode(pin, OUTPUT);
-    }
-    for (int pin = 0; pin < 48; pin++) {
-        if (pin == 17 || pin == 19 || pin == 20 || pin == 22 || pin == 23 || pin == 24 || pin == 25 || pin == 9 || pin == 10 ||
-            pin == PIN_BUTTON1 || pin == PIN_BUTTON2) {
-            continue;
-        }
-        digitalWrite(pin, LOW);
-    }
-    for (int pin = 0; pin < 48; pin++) {
-        if (pin == 17 || pin == 19 || pin == 20 || pin == 22 || pin == 23 || pin == 24 || pin == 25 || pin == 9 || pin == 10 ||
-            pin == PIN_BUTTON1 || pin == PIN_BUTTON2) {
-            continue;
-        }
-        NRF_GPIO->DIRCLR = (1 << pin);
-    }
 #endif
+    // Run shutdown code if specified in variant.cpp
     variant_shutdown();
 
     // Sleepy trackers or sensors can low power "sleep"

src/platform/portduino/PortduinoGlue.cpp

@@ -29,6 +29,7 @@
 #include "platform/portduino/USBHal.h"
 
 portduino_config_struct portduino_config;
+portduino_status_struct portduino_status;
 std::ofstream traceFile;
 std::ofstream JSONFile;
 Ch341Hal *ch341Hal = nullptr;
@@ -180,7 +181,6 @@ void portduinoSetup()
 
     if (portduino_config.force_simradio == true) {
         portduino_config.lora_module = use_simradio;
-        portduino_config.sfpp_enabled = false;
     } else if (configPath != nullptr) {
         if (loadConfig(configPath)) {
             if (!yamlOnly)
@@ -401,6 +401,10 @@ void portduinoSetup()
                 if (found_hat) {
                     product_config =
                         cleanupNameForAutoconf("lora-hat-" + std::string(hat_vendor) + "-" + autoconf_product + ".yaml");
+                    if (strncmp(hat_vendor, "RAK", 14) == 0 && strncmp(autoconf_product, "6421 Pi Hat", 14) == 0) {
+                        std::cout << "autoconf: Setting hardwareModel to RAK6421" << std::endl;
+                        portduino_status.hardwareModel = meshtastic_HardwareModel_RAK6421;
+                    }
                 } else if (found_ch341) {
                     product_config = cleanupNameForAutoconf("lora-usb-" + std::string(autoconf_product) + ".yaml");
                     // look for more data after the null terminator
@@ -409,6 +413,10 @@ void portduinoSetup()
                         memcpy(portduino_config.device_id, autoconf_product + len + 1, 16);
                         if (!memfll(portduino_config.device_id, '\0', 16) && !memfll(portduino_config.device_id, 0xff, 16)) {
                             portduino_config.has_device_id = true;
+                            if (strncmp(autoconf_product, "MESHSTICK 1262", 14) == 0) {
+                                std::cout << "autoconf: Setting hardwareModel to Meshstick 1262" << std::endl;
+                                portduino_status.hardwareModel = meshtastic_HardwareModel_MESHSTICK_1262;
+                            }
                         }
                     }
                 }
@@ -876,28 +884,6 @@ bool loadConfig(const char *configPath)
             }
         }
 
-        if (yamlConfig["StoreAndForward"]) {
-            portduino_config.sfpp_stratum0 = (yamlConfig["StoreAndForward"]["Stratum0"]).as<bool>(false);
-            portduino_config.sfpp_enabled = (yamlConfig["StoreAndForward"]["Enabled"]).as<bool>(true);
-            portduino_config.sfpp_db_path = (yamlConfig["StoreAndForward"]["DBPath"]).as<std::string>("/var/lib/meshtasticd/");
-            portduino_config.sfpp_initial_sync = (yamlConfig["StoreAndForward"]["InitialSync"]).as<int>(10);
-            portduino_config.sfpp_hops = (yamlConfig["StoreAndForward"]["Hops"]).as<int>(3);
-            portduino_config.sfpp_announce_interval = (yamlConfig["StoreAndForward"]["AnnounceInterval"]).as<int>(5);
-            portduino_config.sfpp_max_chain = (yamlConfig["StoreAndForward"]["MaxChainLength"]).as<uint32_t>(1000);
-            portduino_config.sfpp_backlog_limit = (yamlConfig["StoreAndForward"]["BacklogLimit"]).as<uint32_t>(100);
-            portduino_config.sfpp_steal_port = (yamlConfig["StoreAndForward"]["StealPort"]).as<bool>(false);
-        }
-        if (yamlConfig["Routing"]) {
-            if (yamlConfig["Routing"]["WhitelistPorts"]) {
-                portduino_config.whitelist_ports = (yamlConfig["Routing"]["WhitelistPorts"]).as<std::vector<int>>();
-                if (portduino_config.whitelist_ports.size() > 0) {
-                    portduino_config.whitelist_enabled = true;
-                }
-            }
-            if (yamlConfig["Routing"]["NoHopPorts"]) {
-                portduino_config.nohop_ports = (yamlConfig["Routing"]["NoHopPorts"]).as<std::vector<int>>();
-            }
-        }
         if (yamlConfig["General"]) {
             portduino_config.MaxNodes = (yamlConfig["General"]["MaxNodes"]).as<int>(200);
             portduino_config.maxtophone = (yamlConfig["General"]["MaxMessageQueue"]).as<int>(100);

src/platform/portduino/PortduinoGlue.h

@@ -1,15 +1,22 @@
 #pragma once
 #include <fstream>
 #include <map>
+#include <unistd.h>
 #include <unordered_map>
 #include <vector>
 
 #include "LR11x0Interface.h"
 #include "Module.h"
 #include "mesh/generated/meshtastic/mesh.pb.h"
-#include "platform/portduino/USBHal.h"
 #include "yaml-cpp/yaml.h"
 
+extern struct portduino_status_struct {
+    bool LoRa_in_error = false;
+    _meshtastic_HardwareModel hardwareModel = meshtastic_HardwareModel_PORTDUINO;
+} portduino_status;
+
+#include "platform/portduino/USBHal.h"
+
 // Product strings for auto-configuration
 // {"PRODUCT_STRING", "CONFIG.YAML"}
 // YAML paths are relative to `meshtastic/available.d`
@@ -173,26 +180,6 @@ extern struct portduino_config_struct {
     int configDisplayMode = 0;
     bool has_configDisplayMode = false;
 
-    // Store and Forward++
-    std::string sfpp_db_path = "/var/lib/meshtasticd/";
-    bool sfpp_stratum0 = false;
-    bool sfpp_enabled = true;
-    bool sfpp_steal_port = false;
-    int sfpp_initial_sync = 10;
-    int sfpp_hops = 3;
-    int sfpp_announce_interval = 5; // minutes
-    uint32_t sfpp_max_chain = 1000;
-    uint32_t sfpp_backlog_limit = 100;
-    // allowed root hashes
-    // upstream node
-    // Are we allowing unknown channel hashes? Does this even make sense?
-    // Allow DMs
-
-    // Routing
-    bool whitelist_enabled = false;
-    std::vector<int> whitelist_ports = {};
-    std::vector<int> nohop_ports = {};
-
     // General
     std::string mac_address = "";
     bool mac_address_explicit = false;
@@ -538,29 +525,6 @@ extern struct portduino_config_struct {
             out << YAML::EndMap; // Config
         }
 
-        // StoreAndForward
-        if (sfpp_enabled) {
-            out << YAML::Key << "StoreAndForward" << YAML::Value << YAML::BeginMap;
-            out << YAML::Key << "Enabled" << YAML::Value << sfpp_enabled;
-            out << YAML::Key << "DBPath" << YAML::Value << sfpp_db_path;
-            out << YAML::Key << "Stratum0" << YAML::Value << sfpp_stratum0;
-            out << YAML::Key << "InitialSync" << YAML::Value << sfpp_initial_sync;
-            out << YAML::Key << "Hops" << YAML::Value << sfpp_hops;
-            out << YAML::Key << "AnnounceInterval" << YAML::Value << sfpp_announce_interval;
-            out << YAML::Key << "BacklogLimit" << YAML::Value << sfpp_backlog_limit;
-            out << YAML::Key << "MaxChainLength" << YAML::Value << sfpp_max_chain;
-            out << YAML::Key << "StealPort" << YAML::Value << sfpp_steal_port;
-            out << YAML::EndMap; // StoreAndForward
-        }
-
-        // Routing
-        if (whitelist_enabled || nohop_ports.size() > 0) {
-            out << YAML::Key << "Routing" << YAML::Value << YAML::BeginMap;
-            out << YAML::Key << "WhitelistPorts" << YAML::Value << whitelist_ports;
-            out << YAML::Key << "NoHopPorts" << YAML::Value << nohop_ports;
-            out << YAML::EndMap; // Routing
-        }
-
         // General
         out << YAML::Key << "General" << YAML::Value << YAML::BeginMap;
         if (config_directory != "")

src/platform/portduino/USBHal.h

@@ -9,6 +9,8 @@
 #include <libpinedio-usb.h>
 #include <unistd.h>
 
+extern uint32_t rebootAtMsec;
+
 // include the library for Raspberry GPIO pins
 
 #define PI_RISING (PINEDIO_INT_MODE_RISING)
@@ -45,7 +47,7 @@ class Ch341Hal : public RadioLibHal
         int32_t ret = pinedio_init(&pinedio, NULL);
         if (ret != 0) {
             std::string s = "Could not open SPI: ";
-            throw(s + std::to_string(ret));
+            throw std::runtime_error(s + std::to_string(ret));
         }
 
         pinedio_set_option(&pinedio, PINEDIO_OPTION_AUTO_CS, 0);
@@ -74,30 +76,55 @@ class Ch341Hal : public RadioLibHal
     // RADIOLIB_NC as an alias for non-connected pins
     void pinMode(uint32_t pin, uint32_t mode) override
     {
+        if (checkError()) {
+            return;
+        }
         if (pin == RADIOLIB_NC) {
             return;
         }
-        pinedio_set_pin_mode(&pinedio, pin, mode);
+        auto res = pinedio_set_pin_mode(&pinedio, pin, mode);
+        if (res < 0 && rebootAtMsec == 0) {
+            LOG_ERROR("USBHal pinMode: Could not set pin %d mode to %d: %d", pin, mode, res);
+        }
     }
 
     void digitalWrite(uint32_t pin, uint32_t value) override
     {
+        if (checkError()) {
+            return;
+        }
         if (pin == RADIOLIB_NC) {
             return;
         }
-        pinedio_digital_write(&pinedio, pin, value);
+        auto res = pinedio_digital_write(&pinedio, pin, value);
+        if (res < 0 && rebootAtMsec == 0) {
+            LOG_ERROR("USBHal digitalWrite: Could not write pin %d: %d", pin, res);
+            portduino_status.LoRa_in_error = true;
+        }
     }
 
     uint32_t digitalRead(uint32_t pin) override
     {
+        if (checkError()) {
+            return 0;
+        }
         if (pin == RADIOLIB_NC) {
             return 0;
         }
-        return pinedio_digital_read(&pinedio, pin);
+        auto res = pinedio_digital_read(&pinedio, pin);
+        if (res < 0 && rebootAtMsec == 0) {
+            LOG_ERROR("USBHal digitalRead: Could not read pin %d: %d", pin, res);
+            portduino_status.LoRa_in_error = true;
+            return 0;
+        }
+        return res;
     }
 
     void attachInterrupt(uint32_t interruptNum, void (*interruptCb)(void), uint32_t mode) override
     {
+        if (checkError()) {
+            return;
+        }
         if (interruptNum == RADIOLIB_NC) {
             return;
         }
@@ -107,6 +134,9 @@ class Ch341Hal : public RadioLibHal
 
     void detachInterrupt(uint32_t interruptNum) override
     {
+        if (checkError()) {
+            return;
+        }
         if (interruptNum == RADIOLIB_NC) {
             return;
         }
@@ -152,6 +182,9 @@ class Ch341Hal : public RadioLibHal
 
     void spiTransfer(uint8_t *out, size_t len, uint8_t *in)
     {
+        if (checkError()) {
+            return;
+        }
         int32_t ret = pinedio_transceive(&this->pinedio, out, in, len);
         if (ret < 0) {
             std::cerr << "Could not perform SPI transfer: " << ret << std::endl;
@@ -160,9 +193,22 @@ class Ch341Hal : public RadioLibHal
 
     void spiEndTransaction() {}
     void spiEnd() {}
+    bool checkError()
+    {
+        if (pinedio.in_error) {
+            if (!has_warned)
+                LOG_ERROR("USBHal: libch341 in_error detected");
+            portduino_status.LoRa_in_error = true;
+            has_warned = true;
+            return true;
+        }
+        has_warned = false;
+        return false;
+    }
 
   private:
     pinedio_inst pinedio = {0};
+    bool has_warned = false;
 };
 
 #endif

src/platform/portduino/architecture.h

@@ -6,7 +6,7 @@
 // set HW_VENDOR
 //
 
-#define HW_VENDOR meshtastic_HardwareModel_PORTDUINO
+#define HW_VENDOR portduino_status.hardwareModel
 
 #ifndef HAS_BUTTON
 #define HAS_BUTTON 1

test/test_radio/test_main.cpp

@@ -0,0 +1,100 @@
+#include "MeshRadio.h"
+#include "RadioInterface.h"
+#include "TestUtil.h"
+#include <unity.h>
+
+#include "meshtastic/config.pb.h"
+
+static void test_bwCodeToKHz_specialMappings()
+{
+    TEST_ASSERT_FLOAT_WITHIN(0.0001f, 31.25f, bwCodeToKHz(31));
+    TEST_ASSERT_FLOAT_WITHIN(0.0001f, 62.5f, bwCodeToKHz(62));
+    TEST_ASSERT_FLOAT_WITHIN(0.0001f, 203.125f, bwCodeToKHz(200));
+    TEST_ASSERT_FLOAT_WITHIN(0.0001f, 406.25f, bwCodeToKHz(400));
+    TEST_ASSERT_FLOAT_WITHIN(0.0001f, 812.5f, bwCodeToKHz(800));
+    TEST_ASSERT_FLOAT_WITHIN(0.0001f, 1625.0f, bwCodeToKHz(1600));
+}
+
+static void test_bwCodeToKHz_passthrough()
+{
+    TEST_ASSERT_FLOAT_WITHIN(0.0001f, 125.0f, bwCodeToKHz(125));
+    TEST_ASSERT_FLOAT_WITHIN(0.0001f, 250.0f, bwCodeToKHz(250));
+}
+
+static void test_bootstrapLoRaConfigFromPreset_noopWhenUsePresetFalse()
+{
+    meshtastic_Config_LoRaConfig cfg = meshtastic_Config_LoRaConfig_init_zero;
+    cfg.use_preset = false;
+    cfg.region = meshtastic_Config_LoRaConfig_RegionCode_US;
+    cfg.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST;
+    cfg.bandwidth = 123;
+    cfg.spread_factor = 8;
+
+    RadioInterface::bootstrapLoRaConfigFromPreset(cfg);
+
+    TEST_ASSERT_EQUAL_UINT16(123, cfg.bandwidth);
+    TEST_ASSERT_EQUAL_UINT32(8, cfg.spread_factor);
+    TEST_ASSERT_EQUAL(meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST, cfg.modem_preset);
+}
+
+static void test_bootstrapLoRaConfigFromPreset_setsDerivedFields_nonWideRegion()
+{
+    meshtastic_Config_LoRaConfig cfg = meshtastic_Config_LoRaConfig_init_zero;
+    cfg.use_preset = true;
+    cfg.region = meshtastic_Config_LoRaConfig_RegionCode_US;
+    cfg.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST;
+
+    RadioInterface::bootstrapLoRaConfigFromPreset(cfg);
+
+    TEST_ASSERT_EQUAL_UINT16(250, cfg.bandwidth);
+    TEST_ASSERT_EQUAL_UINT32(9, cfg.spread_factor);
+}
+
+static void test_bootstrapLoRaConfigFromPreset_setsDerivedFields_wideRegion()
+{
+    meshtastic_Config_LoRaConfig cfg = meshtastic_Config_LoRaConfig_init_zero;
+    cfg.use_preset = true;
+    cfg.region = meshtastic_Config_LoRaConfig_RegionCode_LORA_24;
+    cfg.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST;
+
+    RadioInterface::bootstrapLoRaConfigFromPreset(cfg);
+
+    TEST_ASSERT_EQUAL_UINT16(800, cfg.bandwidth);
+    TEST_ASSERT_EQUAL_UINT32(9, cfg.spread_factor);
+}
+
+static void test_bootstrapLoRaConfigFromPreset_fallsBackIfBandwidthExceedsRegionSpan()
+{
+    meshtastic_Config_LoRaConfig cfg = meshtastic_Config_LoRaConfig_init_zero;
+    cfg.use_preset = true;
+    cfg.region = meshtastic_Config_LoRaConfig_RegionCode_EU_868;
+    cfg.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_SHORT_TURBO;
+
+    RadioInterface::bootstrapLoRaConfigFromPreset(cfg);
+
+    TEST_ASSERT_EQUAL(meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST, cfg.modem_preset);
+    TEST_ASSERT_EQUAL_UINT16(250, cfg.bandwidth);
+    TEST_ASSERT_EQUAL_UINT32(11, cfg.spread_factor);
+}
+
+void setUp(void) {}
+void tearDown(void) {}
+
+void setup()
+{
+    delay(10);
+    delay(2000);
+
+    initializeTestEnvironment();
+
+    UNITY_BEGIN();
+    RUN_TEST(test_bwCodeToKHz_specialMappings);
+    RUN_TEST(test_bwCodeToKHz_passthrough);
+    RUN_TEST(test_bootstrapLoRaConfigFromPreset_noopWhenUsePresetFalse);
+    RUN_TEST(test_bootstrapLoRaConfigFromPreset_setsDerivedFields_nonWideRegion);
+    RUN_TEST(test_bootstrapLoRaConfigFromPreset_setsDerivedFields_wideRegion);
+    RUN_TEST(test_bootstrapLoRaConfigFromPreset_fallsBackIfBandwidthExceedsRegionSpan);
+    exit(UNITY_END());
+}
+
+void loop() {}

variants/esp32/esp32-common.ini

@@ -59,13 +59,13 @@ lib_deps =
   ${environmental_extra.lib_deps}
   ${radiolib_base.lib_deps}
   # renovate: datasource=git-refs depName=meshtastic-esp32_https_server packageName=https://github.com/meshtastic/esp32_https_server gitBranch=master
-  https://github.com/meshtastic/esp32_https_server/archive/3223704846752e6d545139204837bdb2a55459ca.zip
+  https://github.com/meshtastic/esp32_https_server/archive/b0f3960b3e8444563280656d88e22b5899481884.zip
   # renovate: datasource=custom.pio depName=NimBLE-Arduino packageName=h2zero/library/NimBLE-Arduino
   h2zero/NimBLE-Arduino@^1.4.3
   # renovate: datasource=git-refs depName=libpax packageName=https://github.com/dbinfrago/libpax gitBranch=master
   https://github.com/dbinfrago/libpax/archive/3cdc0371c375676a97967547f4065607d4c53fd1.zip
   # renovate: datasource=github-tags depName=XPowersLib packageName=lewisxhe/XPowersLib
-  https://github.com/lewisxhe/XPowersLib/archive/v0.3.2.zip
+  https://github.com/lewisxhe/XPowersLib/archive/v0.3.3.zip
   # renovate: datasource=custom.pio depName=rweather/Crypto packageName=rweather/library/Crypto
   rweather/Crypto@0.4.0
 

variants/esp32/esp32.ini

@@ -17,12 +17,12 @@ lib_deps =
   ${environmental_extra_no_bsec.lib_deps}
   ${radiolib_base.lib_deps}
   # renovate: datasource=git-refs depName=meshtastic-esp32_https_server packageName=https://github.com/meshtastic/esp32_https_server gitBranch=master
-  https://github.com/meshtastic/esp32_https_server/archive/3223704846752e6d545139204837bdb2a55459ca.zip
+  https://github.com/meshtastic/esp32_https_server/archive/b0f3960b3e8444563280656d88e22b5899481884.zip
   # renovate: datasource=custom.pio depName=NimBLE-Arduino packageName=h2zero/library/NimBLE-Arduino
   h2zero/NimBLE-Arduino@^1.4.3
   # renovate: datasource=git-refs depName=libpax packageName=https://github.com/dbinfrago/libpax gitBranch=master
   https://github.com/dbinfrago/libpax/archive/3cdc0371c375676a97967547f4065607d4c53fd1.zip
   # renovate: datasource=github-tags depName=XPowersLib packageName=lewisxhe/XPowersLib
-  https://github.com/lewisxhe/XPowersLib/archive/v0.3.2.zip
+  https://github.com/lewisxhe/XPowersLib/archive/v0.3.3.zip
   # renovate: datasource=custom.pio depName=rweather/Crypto packageName=rweather/library/Crypto
   rweather/Crypto@0.4.0

variants/esp32/m5stack_coreink/platformio.ini

@@ -19,9 +19,9 @@ build_flags =
 lib_deps = 
   ${esp32_base.lib_deps}
   # renovate: datasource=custom.pio depName=GxEPD2 packageName=zinggjm/library/GxEPD2
-  zinggjm/GxEPD2@1.6.5
+  zinggjm/GxEPD2@1.6.6
   # renovate: datasource=custom.pio depName=SensorLib packageName=lewisxhe/library/SensorLib
-  lewisxhe/SensorLib@0.3.3
+  lewisxhe/SensorLib@0.3.4
 lib_ignore =
   m5stack-coreink
 monitor_filters = esp32_exception_decoder

variants/esp32/tbeam/platformio.ini

@@ -32,4 +32,4 @@ lib_deps =
   # renovate: datasource=github-tags depName=meshtastic-st7796 packageName=meshtastic/st7796
   https://github.com/meshtastic/st7796/archive/1.0.5.zip
   # renovate: datasource=custom.pio depName=lewisxhe-SensorLib packageName=lewisxhe/library/SensorLib
-  lewisxhe/SensorLib@0.3.3
+  lewisxhe/SensorLib@0.3.4

variants/esp32c6/esp32c6.ini

@@ -28,7 +28,7 @@ lib_deps =
   ${environmental_extra.lib_deps}
   ${radiolib_base.lib_deps}
   # renovate: datasource=custom.pio depName=XPowersLib packageName=lewisxhe/library/XPowersLib
-  lewisxhe/XPowersLib@0.3.2
+  lewisxhe/XPowersLib@0.3.3
   # renovate: datasource=git-refs depName=meshtastic-ESP32_Codec2 packageName=https://github.com/meshtastic/ESP32_Codec2 gitBranch=master
   https://github.com/meshtastic/ESP32_Codec2/archive/633326c78ac251c059ab3a8c430fcdf25b41672f.zip
   # renovate: datasource=custom.pio depName=rweather/Crypto packageName=rweather/library/Crypto

variants/esp32s3/ELECROW-ThinkNode-M5/platformio.ini

@@ -11,6 +11,10 @@ custom_meshtastic_requires_dfu = false
 
 extends = esp32s3_base
 board = ESP32-S3-WROOM-1-N4
+build_src_filter =
+  ${esp32s3_base.build_src_filter}
+  +<../variants/esp32s3/ELECROW-ThinkNode-M5>
+
 build_flags =
   ${esp32s3_base.build_flags}
   -D ELECROW_ThinkNode_M5

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

@@ -0,0 +1,12 @@
+#include "variant.h"
+#include <PCA9557.h>
+
+PCA9557 io(0x18, &Wire);
+
+void earlyInitVariant()
+{
+    Wire.begin(48, 47);
+    io.pinMode(PCA_PIN_EINK_EN, OUTPUT);
+    io.pinMode(PCA_PIN_POWER_EN, OUTPUT);
+    io.digitalWrite(PCA_PIN_POWER_EN, HIGH);
+}

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

@@ -4,6 +4,8 @@
 #define UART_TX 43
 #define UART_RX 44
 
+#define HAS_PCA9557
+
 // LED
 // Both of these are on the GPIO expander
 #define PCA_LED_USER 1  // the Blue LED

variants/esp32s3/diy/my_esp32s3_diy_eink/platformio.ini

@@ -11,7 +11,7 @@ upload_speed = 921600
 lib_deps =
   ${esp32s3_base.lib_deps}
   # renovate: datasource=custom.pio depName=GxEPD2 packageName=zinggjm/library/GxEPD2
-  zinggjm/GxEPD2@1.6.5
+  zinggjm/GxEPD2@1.6.6
   # renovate: datasource=custom.pio depName=NeoPixel packageName=adafruit/library/Adafruit NeoPixel
   adafruit/Adafruit NeoPixel@1.15.2
 build_unflags =

variants/esp32s3/esp32-s3-pico/platformio.ini

@@ -23,6 +23,6 @@ build_flags = ${esp32s3_base.build_flags}
 
 lib_deps = ${esp32s3_base.lib_deps}
   # renovate: datasource=custom.pio depName=GxEPD2 packageName=zinggjm/library/GxEPD2
-  zinggjm/GxEPD2@1.6.5
+  zinggjm/GxEPD2@1.6.6
   # renovate: datasource=custom.pio depName=NeoPixel packageName=adafruit/library/Adafruit NeoPixel
   adafruit/Adafruit NeoPixel@1.15.2

variants/esp32s3/hackaday-communicator/platformio.ini

@@ -6,6 +6,10 @@ board_check = true
 board_build.partitions = default_16MB.csv
 upload_protocol = esptool
 
+build_src_filter =
+  ${esp32s3_base.build_src_filter}
+  +<../variants/esp32s3/hackaday-communicator>
+
 build_flags = ${esp32s3_base.build_flags} 
   -D HACKADAY_COMMUNICATOR
   -D BOARD_HAS_PSRAM

variants/esp32s3/hackaday-communicator/variant.cpp

@@ -0,0 +1,6 @@
+#include "variant.h"
+#include "Arduino.h"
+void earlyInitVariant()
+{
+    pinMode(KB_INT, INPUT);
+}

variants/esp32s3/t-deck-pro/platformio.ini

@@ -15,6 +15,10 @@ board = t-deck-pro
 board_check = true
 upload_protocol = esptool
 
+build_src_filter =
+  ${esp32s3_base.build_src_filter}
+  +<../variants/esp32s3/t-deck-pro>
+
 build_flags = 
   ${esp32s3_base.build_flags} -I variants/esp32s3/t-deck-pro
   -D T_DECK_PRO
@@ -29,7 +33,7 @@ build_flags =
 lib_deps =
   ${esp32s3_base.lib_deps}
   # renovate: datasource=custom.pio depName=GxEPD2 packageName=zinggjm/library/GxEPD2
-  zinggjm/GxEPD2@1.6.5
+  zinggjm/GxEPD2@1.6.6
   # renovate: datasource=git-refs depName=CSE_Touch packageName=https://github.com/CIRCUITSTATE/CSE_Touch gitBranch=main
   https://github.com/CIRCUITSTATE/CSE_Touch/archive/b44f23b6f870b848f1fbe453c190879bc6cfaafa.zip
   # renovate: datasource=github-tags depName=CSE_CST328 packageName=CIRCUITSTATE/CSE_CST328

variants/esp32s3/t-deck-pro/variant.cpp

@@ -0,0 +1,14 @@
+#include "variant.h"
+#include "Arduino.h"
+
+void earlyInitVariant()
+{
+    pinMode(LORA_EN, OUTPUT);
+    digitalWrite(LORA_EN, HIGH);
+    pinMode(LORA_CS, OUTPUT);
+    digitalWrite(LORA_CS, HIGH);
+    pinMode(SDCARD_CS, OUTPUT);
+    digitalWrite(SDCARD_CS, HIGH);
+    pinMode(PIN_EINK_CS, OUTPUT);
+    digitalWrite(PIN_EINK_CS, HIGH);
+}

variants/esp32s3/t-deck/platformio.ini

@@ -17,6 +17,10 @@ board_check = true
 board_build.partitions = default_16MB.csv
 upload_protocol = esptool
 
+build_src_filter =
+  ${esp32s3_base.build_src_filter}
+  +<../variants/esp32s3/t-deck>
+
 build_flags = ${esp32s3_base.build_flags} 
   -D T_DECK 
   -D BOARD_HAS_PSRAM

variants/esp32s3/t-deck/variant.cpp

@@ -0,0 +1,23 @@
+#include "variant.h"
+#include "Arduino.h"
+
+void earlyInitVariant()
+{
+    // GPIO10 manages all peripheral power supplies
+    // Turn on peripheral power immediately after MUC starts.
+    // If some boards are turned on late, ESP32 will reset due to low voltage.
+    // ESP32-C3(Keyboard) , MAX98357A(Audio Power Amplifier) ,
+    // TF Card , Display backlight(AW9364DNR) , AN48841B(Trackball) , ES7210(Decoder)
+    pinMode(KB_POWERON, OUTPUT);
+    digitalWrite(KB_POWERON, HIGH);
+    // T-Deck has all three SPI peripherals (TFT, SD, LoRa) attached to the same SPI bus
+    // We need to initialize all CS pins in advance otherwise there will be SPI communication issues
+    // e.g. when detecting the SD card
+    pinMode(LORA_CS, OUTPUT);
+    digitalWrite(LORA_CS, HIGH);
+    pinMode(SDCARD_CS, OUTPUT);
+    digitalWrite(SDCARD_CS, HIGH);
+    pinMode(TFT_CS, OUTPUT);
+    digitalWrite(TFT_CS, HIGH);
+    delay(100);
+}

variants/esp32s3/t-deck/variant.h

@@ -71,6 +71,7 @@
 #define TB_RIGHT 2
 #define TB_PRESS 0 // BUTTON_PIN
 #define TB_DIRECTION FALLING
+#define TB_THRESHOLD 3
 
 // microphone
 #define ES7210_SCK 47

variants/esp32s3/t-watch-s3/platformio.ini

@@ -24,7 +24,7 @@ lib_deps = ${esp32s3_base.lib_deps}
   # renovate: datasource=custom.pio depName=LovyanGFX packageName=lovyan03/library/LovyanGFX
   lovyan03/LovyanGFX@1.2.7
   # renovate: datasource=custom.pio depName=SensorLib packageName=lewisxhe/library/SensorLib
-  lewisxhe/SensorLib@0.3.3
+  lewisxhe/SensorLib@0.3.4
   # renovate: datasource=custom.pio depName=Adafruit DRV2605 packageName=adafruit/library/Adafruit DRV2605 Library
   adafruit/Adafruit DRV2605 Library@1.2.4
   # renovate: datasource=custom.pio depName=ESP8266Audio packageName=earlephilhower/library/ESP8266Audio

variants/esp32s3/tbeam-s3-core/platformio.ini

@@ -19,7 +19,7 @@ board_check = true
 lib_deps =
   ${esp32s3_base.lib_deps}
   # renovate: datasource=custom.pio depName=SensorLib packageName=lewisxhe/library/SensorLib
-  lewisxhe/SensorLib@0.3.3
+  lewisxhe/SensorLib@0.3.4
 
 build_flags = 
   ${esp32s3_base.build_flags} 

variants/esp32s3/tlora-pager/platformio.ini

@@ -17,6 +17,10 @@ board_check = true
 board_build.partitions = default_16MB.csv
 upload_protocol = esptool
 
+build_src_filter =
+  ${esp32s3_base.build_src_filter}
+  +<../variants/esp32s3/tlora-pager>
+
 build_flags = ${esp32s3_base.build_flags} 
   -I variants/esp32s3/tlora-pager
   -D T_LORA_PAGER 
@@ -39,7 +43,7 @@ lib_deps = ${esp32s3_base.lib_deps}
   # renovate: datasource=custom.pio depName=PCF8563 packageName=lewisxhe/library/PCF8563_Library
   lewisxhe/PCF8563_Library@1.0.1
   # renovate: datasource=custom.pio depName=SensorLib packageName=lewisxhe/library/SensorLib
-  lewisxhe/SensorLib@0.3.3
+  lewisxhe/SensorLib@0.3.4
   # renovate: datasource=github-tags depName=pschatzmann_arduino-audio-driver packageName=pschatzmann/arduino-audio-driver
   https://github.com/pschatzmann/arduino-audio-driver/archive/v0.2.0.zip
   # TODO renovate

variants/esp32s3/tlora-pager/variant.cpp

@@ -0,0 +1,31 @@
+#include "variant.h"
+#include "ExtensionIOXL9555.hpp"
+extern ExtensionIOXL9555 io;
+
+void earlyInitVariant()
+{
+    pinMode(LORA_CS, OUTPUT);
+    digitalWrite(LORA_CS, HIGH);
+    pinMode(SDCARD_CS, OUTPUT);
+    digitalWrite(SDCARD_CS, HIGH);
+    pinMode(TFT_CS, OUTPUT);
+    digitalWrite(TFT_CS, HIGH);
+    pinMode(KB_INT, INPUT_PULLUP);
+    // io expander
+    io.begin(Wire, XL9555_SLAVE_ADDRESS0, SDA, SCL);
+    io.pinMode(EXPANDS_DRV_EN, OUTPUT);
+    io.digitalWrite(EXPANDS_DRV_EN, HIGH);
+    io.pinMode(EXPANDS_AMP_EN, OUTPUT);
+    io.digitalWrite(EXPANDS_AMP_EN, LOW);
+    io.pinMode(EXPANDS_LORA_EN, OUTPUT);
+    io.digitalWrite(EXPANDS_LORA_EN, HIGH);
+    io.pinMode(EXPANDS_GPS_EN, OUTPUT);
+    io.digitalWrite(EXPANDS_GPS_EN, HIGH);
+    io.pinMode(EXPANDS_KB_EN, OUTPUT);
+    io.digitalWrite(EXPANDS_KB_EN, HIGH);
+    io.pinMode(EXPANDS_SD_EN, OUTPUT);
+    io.digitalWrite(EXPANDS_SD_EN, HIGH);
+    io.pinMode(EXPANDS_GPIO_EN, OUTPUT);
+    io.digitalWrite(EXPANDS_GPIO_EN, HIGH);
+    io.pinMode(EXPANDS_SD_PULLEN, INPUT);
+}

variants/native/portduino.ini

@@ -29,7 +29,7 @@ lib_deps =
   # renovate: datasource=custom.pio depName=LovyanGFX packageName=lovyan03/library/LovyanGFX
   lovyan03/LovyanGFX@1.2.7
   # renovate: datasource=git-refs depName=libch341-spi-userspace packageName=https://github.com/pine64/libch341-spi-userspace gitBranch=main
-  https://github.com/pine64/libch341-spi-userspace/archive/af9bc27c9c30fa90772279925b7c5913dff789b4.zip
+  https://github.com/pine64/libch341-spi-userspace/archive/23c42319a69cffcb65868e3c72e6bed83974a393.zip
   # renovate: datasource=custom.pio depName=adafruit/Adafruit seesaw Library packageName=adafruit/library/Adafruit seesaw Library
 	adafruit/Adafruit seesaw Library@1.7.9
   # renovate: datasource=git-refs depName=RAK12034-BMX160 packageName=https://github.com/RAKWireless/RAK12034-BMX160 gitBranch=main

variants/native/portduino/platformio.ini

@@ -9,7 +9,7 @@ lib_deps =
   # renovate: datasource=custom.pio depName=Melopero RV3028 packageName=melopero/library/Melopero RV3028
   melopero/Melopero RV3028@1.2.0
 
-build_src_filter = ${portduino_base.build_src_filter} +<modules/Native/>
+build_src_filter = ${portduino_base.build_src_filter}
 
 [env:native]
 extends = native_base
@@ -20,7 +20,6 @@ build_flags = ${native_base.build_flags}
   !pkg-config --libs openssl --silence-errors || :
   !pkg-config --cflags --libs sdl2 --silence-errors || :
   !pkg-config --cflags --libs libbsd-overlay --silence-errors || :
-  !pkg-config --cflags --libs sqlite3 --silence-errors || :
 
 [env:native-tft]
 extends = native_base
@@ -47,7 +46,6 @@ build_flags = ${native_base.build_flags} -Os -lX11 -linput -lxkbcommon -ffunctio
   !pkg-config --libs openssl --silence-errors || :
   !pkg-config --cflags --libs sdl2 --silence-errors || :
   !pkg-config --cflags --libs libbsd-overlay --silence-errors || :
-  !pkg-config --cflags --libs sqlite3 --silence-errors || :
 build_src_filter =
   ${native_base.build_src_filter}
 
@@ -77,7 +75,6 @@ build_flags = ${native_base.build_flags} -Os -ffunction-sections -fdata-sections
   !pkg-config --libs libulfius --silence-errors || :
   !pkg-config --libs openssl --silence-errors || :
   !pkg-config --cflags --libs libbsd-overlay --silence-errors || :
-  !pkg-config --cflags --libs sqlite3 --silence-errors || :
 build_src_filter =
   ${native_base.build_src_filter}
 
@@ -111,7 +108,6 @@ build_flags = ${native_base.build_flags} -O0 -fsanitize=address -lX11 -linput -l
   !pkg-config --libs libulfius --silence-errors || :
   !pkg-config --libs openssl --silence-errors || :
   !pkg-config --cflags --libs libbsd-overlay --silence-errors || :
-  !pkg-config --cflags --libs sqlite3 --silence-errors || :
 build_src_filter = ${env:native-tft.build_src_filter}
 
 [env:coverage]

variants/nrf52840/Dongle_nRF52840-pca10059-v1/platformio.ini

@@ -12,5 +12,5 @@ build_src_filter = ${nrf52_base.build_src_filter} +<../variants/nrf52840/Dongle_
 lib_deps = 
   ${nrf52840_base.lib_deps}
   # renovate: datasource=custom.pio depName=GxEPD2 packageName=zinggjm/library/GxEPD2
-  zinggjm/GxEPD2@1.6.5
+  zinggjm/GxEPD2@1.6.6
 debug_tool = jlink

variants/nrf52840/ELECROW-ThinkNode-M1/variant.cpp

@@ -42,3 +42,21 @@ void initVariant()
     pinMode(PIN_LED3, OUTPUT);
     ledOff(PIN_LED3);
 }
+
+void variant_shutdown()
+{
+    for (int pin = 0; pin < 48; pin++) {
+        if (pin == SX126X_BUSY || pin == PIN_SPI_SCK || pin == SX126X_DIO1 || pin == PIN_SPI_MOSI || pin == PIN_SPI_MISO ||
+            pin == SX126X_CS || pin == SX126X_RESET || pin == PIN_NFC1 || pin == PIN_NFC2 || pin == PIN_BUTTON1 ||
+            pin == PIN_BUTTON2) {
+            continue;
+        }
+        pinMode(pin, OUTPUT);
+        digitalWrite(pin, LOW);
+        if (pin >= 32) {
+            NRF_P1->DIRCLR = (1 << (pin - 32));
+        } else {
+            NRF_GPIO->DIRCLR = (1 << pin);
+        }
+    }
+}

variants/nrf52840/ELECROW-ThinkNode-M3/platformio.ini

@@ -25,4 +25,4 @@ lib_deps =
   # renovate: datasource=custom.pio depName=nRF52_PWM packageName=khoih-prog/library/nRF52_PWM
   khoih-prog/nRF52_PWM@1.0.1
   ; # renovate: datasource=custom.pio depName=SensorLib packageName=lewisxhe/library/SensorLib
-  ; lewisxhe/SensorLib@0.3.3
+  ; lewisxhe/SensorLib@0.3.4

variants/nrf52840/ELECROW-ThinkNode-M6/platformio.ini

@@ -22,4 +22,4 @@ build_src_filter = ${nrf52_base.build_src_filter} +<../variants/nrf52840/ELECROW
 lib_deps =
   ${nrf52840_base.lib_deps}
   ; # renovate: datasource=custom.pio depName=SensorLib packageName=lewisxhe/library/SensorLib
-  ; lewisxhe/SensorLib@0.3.3
+  ; lewisxhe/SensorLib@0.3.4

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

@@ -16,7 +16,7 @@ build_src_filter = ${nrf52_base.build_src_filter} +<../variants/nrf52840/ME25LS0
 lib_deps = 
   ${nrf52840_base.lib_deps}
   # renovate: datasource=custom.pio depName=GxEPD2 packageName=zinggjm/library/GxEPD2
-  zinggjm/GxEPD2@1.6.5
+  zinggjm/GxEPD2@1.6.6
 ; If not set we will default to uploading over serial (first it forces bootloader entry by talking 1200bps to cdcacm)
 upload_protocol = nrfutil
 ;upload_port = /dev/ttyACM1

variants/nrf52840/MakePython_nRF52840_eink/platformio.ini

@@ -15,6 +15,6 @@ lib_deps =
   # renovate: datasource=git-refs depName=meshtastic-ESP32_Codec2 packageName=https://github.com/meshtastic/ESP32_Codec2 gitBranch=master
   https://github.com/meshtastic/ESP32_Codec2/archive/633326c78ac251c059ab3a8c430fcdf25b41672f.zip
   # renovate: datasource=custom.pio depName=GxEPD2 packageName=zinggjm/library/GxEPD2
-  zinggjm/GxEPD2@1.6.5
+  zinggjm/GxEPD2@1.6.6
 debug_tool = jlink
 ;upload_port = /dev/ttyACM4

variants/nrf52840/TWC_mesh_v4/platformio.ini

@@ -9,5 +9,5 @@ build_src_filter = ${nrf52_base.build_src_filter} +<../variants/nrf52840/TWC_mes
 lib_deps = 
   ${nrf52840_base.lib_deps}
   # renovate: datasource=custom.pio depName=GxEPD2 packageName=zinggjm/library/GxEPD2
-  zinggjm/GxEPD2@1.6.5
+  zinggjm/GxEPD2@1.6.6
 debug_tool = jlink

variants/nrf52840/heltec_mesh_node_t114-inkhud/variant.cpp

@@ -19,6 +19,7 @@
 */
 
 #include "variant.h"
+#include "Arduino.h"
 #include "nrf.h"
 #include "wiring_constants.h"
 #include "wiring_digital.h"
@@ -36,3 +37,10 @@ void initVariant()
     pinMode(PIN_LED1, OUTPUT);
     ledOff(PIN_LED1);
 }
+
+void variant_shutdown()
+{
+    nrf_gpio_cfg_default(PIN_GPS_PPS);
+    detachInterrupt(PIN_GPS_PPS);
+    detachInterrupt(PIN_BUTTON1);
+}

variants/nrf52840/heltec_mesh_node_t114/variant.cpp

@@ -19,6 +19,7 @@
 */
 
 #include "variant.h"
+#include "Arduino.h"
 #include "nrf.h"
 #include "wiring_constants.h"
 #include "wiring_digital.h"
@@ -36,3 +37,10 @@ void initVariant()
     pinMode(PIN_LED1, OUTPUT);
     ledOff(PIN_LED1);
 }
+
+void variant_shutdown()
+{
+    nrf_gpio_cfg_default(PIN_GPS_PPS);
+    detachInterrupt(PIN_GPS_PPS);
+    detachInterrupt(PIN_BUTTON1);
+}

variants/nrf52840/heltec_mesh_node_t114/variant.h

@@ -156,7 +156,7 @@ No longer populated on PCB
 
 // The bluetooth transmit power on the nRF52840 is adjustable from -20dB to +8dB in steps of 4dB
 // so NRF52_BLE_TX_POWER can be set to -20, -16, -12, -8, -4, 0 (default), 4, and 8.
-//#define NRF52_BLE_TX_POWER 8
+// #define NRF52_BLE_TX_POWER 8
 
 /*
  * GPS pins

variants/nrf52840/heltec_mesh_solar/variant.cpp

@@ -19,6 +19,7 @@
 */
 
 #include "variant.h"
+#include "Arduino.h"
 #include "nrf.h"
 #include "wiring_constants.h"
 #include "wiring_digital.h"
@@ -38,3 +39,10 @@ void initVariant()
     digitalWrite(PIN_SCREEN_VDD_CTL, LOW); // Start with power on
 #endif
 }
+
+void variant_shutdown()
+{
+    nrf_gpio_cfg_default(PIN_GPS_PPS);
+    detachInterrupt(PIN_GPS_PPS);
+    detachInterrupt(PIN_BUTTON1);
+}

variants/nrf52840/meshlink/variant.cpp

@@ -21,3 +21,10 @@ void initVariant()
     digitalWrite(PIN_WD_EN, HIGH); // Enable the Watchdog at boot
 #endif
 }
+
+void variant_shutdown()
+{
+#ifdef PIN_WD_EN
+    digitalWrite(PIN_WD_EN, LOW);
+#endif
+}

variants/nrf52840/nano-g2-ultra/platformio.ini

@@ -20,5 +20,5 @@ build_src_filter = ${nrf52_base.build_src_filter} +<../variants/nrf52840/nano-g2
 lib_deps = 
   ${nrf52840_base.lib_deps}
   # renovate: datasource=custom.pio depName=SensorLib packageName=lewisxhe/library/SensorLib
-  lewisxhe/SensorLib@0.3.3
+  lewisxhe/SensorLib@0.3.4
 ;upload_protocol = fs

variants/nrf52840/r1-neo/variant.cpp

@@ -43,3 +43,11 @@ void initVariant()
     // pinMode(PIN_3V3_EN, OUTPUT);
     // digitalWrite(PIN_3V3_EN, HIGH);
 }
+
+void earlyInitVariant()
+{
+    pinMode(DCDC_EN_HOLD, OUTPUT);
+    digitalWrite(DCDC_EN_HOLD, HIGH);
+    pinMode(NRF_ON, OUTPUT);
+    digitalWrite(NRF_ON, HIGH);
+}

variants/nrf52840/rak4631_epaper/platformio.ini

@@ -15,7 +15,7 @@ build_src_filter = ${nrf52_base.build_src_filter} +<../variants/nrf52840/rak4631
 lib_deps = 
   ${nrf52840_base.lib_deps}
   # renovate: datasource=custom.pio depName=GxEPD2 packageName=zinggjm/library/GxEPD2
-  zinggjm/GxEPD2@1.6.5
+  zinggjm/GxEPD2@1.6.6
   # renovate: datasource=custom.pio depName=Melopero RV3028 packageName=melopero/library/Melopero RV3028
   melopero/Melopero RV3028@1.2.0
   # renovate: datasource=custom.pio depName=RAK NCP5623 RGB LED packageName=rakwireless/library/RAKwireless NCP5623 RGB LED library

variants/nrf52840/rak4631_epaper_onrxtx/platformio.ini

@@ -17,7 +17,7 @@ build_src_filter = ${nrf52_base.build_src_filter} +<../variants/nrf52840/rak4631
 lib_deps = 
   ${nrf52840_base.lib_deps}
   # renovate: datasource=custom.pio depName=GxEPD2 packageName=zinggjm/library/GxEPD2
-  zinggjm/GxEPD2@1.6.5
+  zinggjm/GxEPD2@1.6.6
   # renovate: datasource=custom.pio depName=Melopero RV3028 packageName=melopero/library/Melopero RV3028
   melopero/Melopero RV3028@1.2.0
   # renovate: datasource=custom.pio depName=RAK NCP5623 RGB LED packageName=rakwireless/library/RAKwireless NCP5623 RGB LED library

variants/nrf52840/rak_wismeshtap/variant.cpp

@@ -43,3 +43,20 @@ void initVariant()
     pinMode(PIN_3V3_EN, OUTPUT);
     digitalWrite(PIN_3V3_EN, HIGH);
 }
+
+void variant_shutdown()
+{
+    // GPIO restores input status, otherwise there will be leakage current
+    nrf_gpio_cfg_default(TFT_BL);
+    nrf_gpio_cfg_default(TFT_DC);
+    nrf_gpio_cfg_default(TFT_CS);
+    nrf_gpio_cfg_default(TFT_SCLK);
+    nrf_gpio_cfg_default(TFT_MOSI);
+    nrf_gpio_cfg_default(TFT_MISO);
+    nrf_gpio_cfg_default(SCREEN_TOUCH_INT);
+    nrf_gpio_cfg_default(WB_I2C1_SCL);
+    nrf_gpio_cfg_default(WB_I2C1_SDA);
+
+    // nrf_gpio_cfg_default(WB_I2C2_SCL);
+    // nrf_gpio_cfg_default(WB_I2C2_SDA);
+}

variants/nrf52840/t-echo/platformio.ini

@@ -32,7 +32,7 @@ lib_deps =
   # renovate: datasource=git-refs depName=meshtastic-GxEPD2 packageName=https://github.com/meshtastic/GxEPD2 gitBranch=master
   https://github.com/meshtastic/GxEPD2/archive/a05c11c02862624266b61599b0d6ba93e33c6f24.zip
   # renovate: datasource=custom.pio depName=SensorLib packageName=lewisxhe/library/SensorLib
-  lewisxhe/SensorLib@0.3.3
+  lewisxhe/SensorLib@0.3.4
 ;upload_protocol = fs
 
 [env:t-echo-inkhud]
@@ -53,4 +53,4 @@ lib_deps =
   ${inkhud.lib_deps} ; InkHUD libs first, so we get GFXRoot instead of AdafruitGFX
   ${nrf52840_base.lib_deps}
   # renovate: datasource=custom.pio depName=SensorLib packageName=lewisxhe/library/SensorLib
-  lewisxhe/SensorLib@0.3.3
+  lewisxhe/SensorLib@0.3.4

variants/nrf52840/t-echo/variant.cpp

@@ -42,3 +42,13 @@ void initVariant()
     pinMode(PIN_LED3, OUTPUT);
     ledOff(PIN_LED3);
 }
+
+void variant_shutdown()
+{
+    // To power off the T-Echo, the display must be set
+    // as an input pin; otherwise, there will be leakage current.
+    pinMode(PIN_EINK_CS, INPUT);
+    pinMode(PIN_EINK_DC, INPUT);
+    pinMode(PIN_EINK_RES, INPUT);
+    pinMode(PIN_EINK_BUSY, INPUT);
+}