Merge branch 'develop' into sfpp

* Add null check for p_encrypted before MQTT publish

A user on BayMesh observed a strange crash in MQTT::onSend that seemed to be a null pointer dereference of this value.

* Trunk

bin/config-dist.yaml

@@ -203,6 +203,16 @@ 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

meshtasticd.spec.rpkg

@@ -59,14 +59,8 @@ BuildRequires: pkgconfig(libbsd-overlay)
 
 Requires:      systemd-udev
 
-# Declare that this package provides the user/group it creates in %pre
-# Required for Fedora 43+ which tracks users/groups as RPM dependencies
-Provides:      user(%{meshtasticd_user})
-Provides:      group(%{meshtasticd_user})
-Provides:      group(spi)
-
 %description
-Meshtastic daemon. Meshtastic is an off-grid
+Meshtastic daemon for controlling Meshtastic devices. Meshtastic is an off-grid
 text communication platform that uses inexpensive LoRa radios.
 
 %prep
@@ -157,7 +151,6 @@ fi
 %license LICENSE
 %doc README.md
 %{_bindir}/meshtasticd
-%{_bindir}/meshtasticd-start.sh
 %dir %{_localstatedir}/lib/meshtasticd
 %{_udevrulesdir}/99-meshtasticd-udev.rules
 %dir %{_sysconfdir}/meshtasticd

platformio.ini

@@ -97,7 +97,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/>
+build_src_filter = ${env.build_src_filter} -<platform/portduino/> -<graphics/niche/> -<modules/Native/>
 
 ; Common libs for communicating over TCP/IP networks such as MQTT
 [networking_base]

src/AmbientLightingThread.h

@@ -1,21 +1,19 @@
-#ifndef AMBIENTLIGHTINGTHREAD_H
-#define AMBIENTLIGHTINGTHREAD_H
-
 #include "Observer.h"
 #include "configuration.h"
-#include "detect/ScanI2C.h"
-#include "sleep.h"
 
 #ifdef HAS_NCP5623
-#include <NCP5623.h>
+#include <graphics/RAKled.h>
+NCP5623 rgb;
 #endif
 
 #ifdef HAS_LP5562
 #include <graphics/NomadStarLED.h>
+LP5562 rgbw;
 #endif
 
 #ifdef HAS_NEOPIXEL
-#include <Adafruit_NeoPixel.h>
+#include <graphics/NeoPixel.h>
+Adafruit_NeoPixel pixels(NEOPIXEL_COUNT, NEOPIXEL_DATA, NEOPIXEL_TYPE);
 #endif
 
 #ifdef UNPHONE
@@ -23,24 +21,10 @@
 extern unPhone unphone;
 #endif
 
+namespace concurrency
+{
 class AmbientLightingThread : public concurrency::OSThread
 {
-    friend class StatusLEDModule; // Let the LEDStatusModule trigger the ambient lighting for notifications and battery status.
-    friend class ExternalNotificationModule; // Let the ExternalNotificationModule trigger the ambient lighting for notifications.
-
-  private:
-#ifdef HAS_NCP5623
-    NCP5623 rgb;
-#endif
-
-#ifdef HAS_LP5562
-    LP5562 rgbw;
-#endif
-
-#ifdef HAS_NEOPIXEL
-    Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NEOPIXEL_COUNT, NEOPIXEL_DATA, NEOPIXEL_TYPE);
-#endif
-
   public:
     explicit AmbientLightingThread(ScanI2C::DeviceType type) : OSThread("AmbientLighting")
     {
@@ -52,15 +36,14 @@ class AmbientLightingThread : public concurrency::OSThread
         moduleConfig.ambient_lighting.led_state = true;
 #endif
 #endif
-#if AMBIENT_LIGHTING_TEST
-        // define to enable test
-        moduleConfig.ambient_lighting.led_state = true;
-        moduleConfig.ambient_lighting.current = 10;
+        // Uncomment to test module
+        // moduleConfig.ambient_lighting.led_state = true;
+        // moduleConfig.ambient_lighting.current = 10;
         // Default to a color based on our node number
-        moduleConfig.ambient_lighting.red = (myNodeInfo.my_node_num & 0xFF0000) >> 16;
-        moduleConfig.ambient_lighting.green = (myNodeInfo.my_node_num & 0x00FF00) >> 8;
-        moduleConfig.ambient_lighting.blue = myNodeInfo.my_node_num & 0x0000FF;
-#endif
+        // moduleConfig.ambient_lighting.red = (myNodeInfo.my_node_num & 0xFF0000) >> 16;
+        // moduleConfig.ambient_lighting.green = (myNodeInfo.my_node_num & 0x00FF00) >> 8;
+        // moduleConfig.ambient_lighting.blue = myNodeInfo.my_node_num & 0x0000FF;
+
 #if defined(HAS_NCP5623) || defined(HAS_LP5562)
         _type = type;
         if (_type == ScanI2C::DeviceType::NONE) {
@@ -70,6 +53,11 @@ class AmbientLightingThread : public concurrency::OSThread
         }
 #endif
 #ifdef HAS_RGB_LED
+        if (!moduleConfig.ambient_lighting.led_state) {
+            LOG_DEBUG("AmbientLighting Disable due to moduleConfig.ambient_lighting.led_state OFF");
+            disable();
+            return;
+        }
         LOG_DEBUG("AmbientLighting init");
 #ifdef HAS_NCP5623
         if (_type == ScanI2C::NCP5623) {
@@ -89,13 +77,7 @@ class AmbientLightingThread : public concurrency::OSThread
                 pixels.clear(); // Set all pixel colors to 'off'
                 pixels.setBrightness(moduleConfig.ambient_lighting.current);
 #endif
-                if (!moduleConfig.ambient_lighting.led_state) {
-                    LOG_DEBUG("AmbientLighting Disable due to moduleConfig.ambient_lighting.led_state OFF");
-                    disable();
-                    return;
-                }
-                setLighting(moduleConfig.ambient_lighting.current, moduleConfig.ambient_lighting.red,
-                            moduleConfig.ambient_lighting.green, moduleConfig.ambient_lighting.blue);
+                setLighting();
 #endif
 #if defined(HAS_NCP5623) || defined(HAS_LP5562)
             }
@@ -109,8 +91,7 @@ class AmbientLightingThread : public concurrency::OSThread
 #if defined(HAS_NCP5623) || defined(HAS_LP5562)
             if ((_type == ScanI2C::NCP5623 || _type == ScanI2C::LP5562) && moduleConfig.ambient_lighting.led_state) {
 #endif
-                setLighting(moduleConfig.ambient_lighting.current, moduleConfig.ambient_lighting.red,
-                            moduleConfig.ambient_lighting.green, moduleConfig.ambient_lighting.blue);
+                setLighting();
                 return 30000; // 30 seconds to reset from any animations that may have been running from Ext. Notification
 #if defined(HAS_NCP5623) || defined(HAS_LP5562)
             }
@@ -167,53 +148,65 @@ class AmbientLightingThread : public concurrency::OSThread
             return 0;
         }
 
-      protected:
-        void setLighting(float current, uint8_t red, uint8_t green, uint8_t blue)
+        void setLighting()
         {
 #ifdef HAS_NCP5623
-            rgb.setCurrent(current);
-            rgb.setRed(red);
-            rgb.setGreen(green);
-            rgb.setBlue(blue);
-            LOG_DEBUG("Init NCP5623 Ambient light w/ current=%d, red=%d, green=%d, blue=%d", current, red, green, blue);
+            rgb.setCurrent(moduleConfig.ambient_lighting.current);
+            rgb.setRed(moduleConfig.ambient_lighting.red);
+            rgb.setGreen(moduleConfig.ambient_lighting.green);
+            rgb.setBlue(moduleConfig.ambient_lighting.blue);
+            LOG_DEBUG("Init NCP5623 Ambient light w/ current=%d, red=%d, green=%d, blue=%d",
+                      moduleConfig.ambient_lighting.current, moduleConfig.ambient_lighting.red,
+                      moduleConfig.ambient_lighting.green, moduleConfig.ambient_lighting.blue);
 #endif
 #ifdef HAS_LP5562
-            rgbw.setCurrent(current);
-            rgbw.setRed(red);
-            rgbw.setGreen(green);
-            rgbw.setBlue(blue);
-            LOG_DEBUG("Init LP5562 Ambient light w/ current=%d, red=%d, green=%d, blue=%d", current, red, green, blue);
+            rgbw.setCurrent(moduleConfig.ambient_lighting.current);
+            rgbw.setRed(moduleConfig.ambient_lighting.red);
+            rgbw.setGreen(moduleConfig.ambient_lighting.green);
+            rgbw.setBlue(moduleConfig.ambient_lighting.blue);
+            LOG_DEBUG("Init LP5562 Ambient light w/ current=%d, red=%d, green=%d, blue=%d", moduleConfig.ambient_lighting.current,
+                      moduleConfig.ambient_lighting.red, moduleConfig.ambient_lighting.green, moduleConfig.ambient_lighting.blue);
 #endif
 #ifdef HAS_NEOPIXEL
-            pixels.fill(pixels.Color(red, green, blue), 0, NEOPIXEL_COUNT);
+            pixels.fill(pixels.Color(moduleConfig.ambient_lighting.red, moduleConfig.ambient_lighting.green,
+                                     moduleConfig.ambient_lighting.blue),
+                        0, NEOPIXEL_COUNT);
 
 // RadioMaster Bandit has addressable LED at the two buttons
 // this allow us to set different lighting for them in variant.h file.
+#ifdef RADIOMASTER_900_BANDIT
 #if defined(BUTTON1_COLOR) && defined(BUTTON1_COLOR_INDEX)
             pixels.fill(BUTTON1_COLOR, BUTTON1_COLOR_INDEX, 1);
 #endif
 #if defined(BUTTON2_COLOR) && defined(BUTTON2_COLOR_INDEX)
             pixels.fill(BUTTON2_COLOR, BUTTON2_COLOR_INDEX, 1);
+#endif
 #endif
             pixels.show();
             // LOG_DEBUG("Init NeoPixel Ambient light w/ brightness(current)=%d, red=%d, green=%d, blue=%d",
-            //        current, red, green, blue);
+            //        moduleConfig.ambient_lighting.current, moduleConfig.ambient_lighting.red,
+            //        moduleConfig.ambient_lighting.green, moduleConfig.ambient_lighting.blue);
 #endif
 #ifdef RGBLED_CA
-            analogWrite(RGBLED_RED, 255 - red);
-            analogWrite(RGBLED_GREEN, 255 - green);
-            analogWrite(RGBLED_BLUE, 255 - blue);
-            LOG_DEBUG("Init Ambient light RGB Common Anode w/ red=%d, green=%d, blue=%d", red, green, blue);
+            analogWrite(RGBLED_RED, 255 - moduleConfig.ambient_lighting.red);
+            analogWrite(RGBLED_GREEN, 255 - moduleConfig.ambient_lighting.green);
+            analogWrite(RGBLED_BLUE, 255 - moduleConfig.ambient_lighting.blue);
+            LOG_DEBUG("Init Ambient light RGB Common Anode w/ red=%d, green=%d, blue=%d", moduleConfig.ambient_lighting.red,
+                      moduleConfig.ambient_lighting.green, moduleConfig.ambient_lighting.blue);
 #elif defined(RGBLED_RED)
-        analogWrite(RGBLED_RED, red);
-        analogWrite(RGBLED_GREEN, green);
-        analogWrite(RGBLED_BLUE, blue);
-        LOG_DEBUG("Init Ambient light RGB Common Cathode w/ red=%d, green=%d, blue=%d", red, green, blue);
+        analogWrite(RGBLED_RED, moduleConfig.ambient_lighting.red);
+        analogWrite(RGBLED_GREEN, moduleConfig.ambient_lighting.green);
+        analogWrite(RGBLED_BLUE, moduleConfig.ambient_lighting.blue);
+        LOG_DEBUG("Init Ambient light RGB Common Cathode w/ red=%d, green=%d, blue=%d", moduleConfig.ambient_lighting.red,
+                  moduleConfig.ambient_lighting.green, moduleConfig.ambient_lighting.blue);
 #endif
 #ifdef UNPHONE
-            unphone.rgb(red, green, blue);
-            LOG_DEBUG("Init unPhone Ambient light w/ red=%d, green=%d, blue=%d", red, green, blue);
+            unphone.rgb(moduleConfig.ambient_lighting.red, moduleConfig.ambient_lighting.green,
+                        moduleConfig.ambient_lighting.blue);
+            LOG_DEBUG("Init unPhone Ambient light w/ red=%d, green=%d, blue=%d", moduleConfig.ambient_lighting.red,
+                      moduleConfig.ambient_lighting.green, moduleConfig.ambient_lighting.blue);
 #endif
         }
     };
-#endif // AMBIENTLIGHTINGTHREAD_H
+
+} // namespace concurrency

src/Led.cpp

@@ -0,0 +1,66 @@
+#include "Led.h"
+#include "PowerMon.h"
+#include "main.h"
+#include "power.h"
+
+GpioVirtPin ledForceOn, ledBlink;
+
+#if defined(LED_PIN)
+// Most boards have a GPIO for LED control
+static GpioHwPin ledRawHwPin(LED_PIN);
+#else
+static GpioVirtPin ledRawHwPin; // Dummy pin for no hardware
+#endif
+
+#if LED_STATE_ON == 0
+static GpioVirtPin ledHwPin;
+static GpioNotTransformer ledInverter(&ledHwPin, &ledRawHwPin);
+#else
+static GpioPin &ledHwPin = ledRawHwPin;
+#endif
+
+#if defined(HAS_PMU)
+/**
+ * A GPIO controlled by the PMU
+ */
+class GpioPmuPin : public GpioPin
+{
+  public:
+    void set(bool value)
+    {
+        if (pmu_found && PMU) {
+            // blink the axp led
+            PMU->setChargingLedMode(value ? XPOWERS_CHG_LED_ON : XPOWERS_CHG_LED_OFF);
+        }
+    }
+} ledPmuHwPin;
+
+// In some cases we need to drive a PMU LED and a normal LED
+static GpioSplitter ledFinalPin(&ledHwPin, &ledPmuHwPin);
+#else
+static GpioPin &ledFinalPin = ledHwPin;
+#endif
+
+#ifdef USE_POWERMON
+/**
+ * We monitor changes to the LED drive output because we use that as a sanity test in our power monitor stuff.
+ */
+class MonitoredLedPin : public GpioPin
+{
+  public:
+    void set(bool value)
+    {
+        if (powerMon) {
+            if (value)
+                powerMon->setState(meshtastic_PowerMon_State_LED_On);
+            else
+                powerMon->clearState(meshtastic_PowerMon_State_LED_On);
+        }
+        ledFinalPin.set(value);
+    }
+} monitoredLedPin;
+#else
+static GpioPin &monitoredLedPin = ledFinalPin;
+#endif
+
+static GpioBinaryTransformer ledForcer(&ledForceOn, &ledBlink, &monitoredLedPin, GpioBinaryTransformer::Or);

src/Led.h

@@ -0,0 +1,7 @@
+#include "GpioLogic.h"
+#include "configuration.h"
+
+/**
+ * ledForceOn and ledForceOff both override the normal ledBlinker behavior (which is controlled by main)
+ */
+extern GpioVirtPin ledForceOn, ledBlink;

src/Power.cpp

@@ -692,9 +692,7 @@ bool Power::setup()
     bool found = false;
     if (axpChipInit()) {
         found = true;
-    } else if (cw2015Init()) {
-        found = true;
-    } else if (max17048Init()) {
+    } else if (lipoInit()) {
         found = true;
     } else if (lipoChargerInit()) {
         found = true;
@@ -1323,7 +1321,7 @@ bool Power::axpChipInit()
 /**
  * Wrapper class for an I2C MAX17048 Lipo battery sensor.
  */
-class MAX17048BatteryLevel : public HasBatteryLevel
+class LipoBatteryLevel : public HasBatteryLevel
 {
   private:
     MAX17048Singleton *max17048 = nullptr;
@@ -1371,18 +1369,18 @@ class MAX17048BatteryLevel : public HasBatteryLevel
     virtual bool isCharging() override { return max17048->isBatteryCharging(); }
 };
 
-MAX17048BatteryLevel max17048Level;
+LipoBatteryLevel lipoLevel;
 
 /**
  * Init the Lipo battery level sensor
  */
-bool Power::max17048Init()
+bool Power::lipoInit()
 {
-    bool result = max17048Level.runOnce();
-    LOG_DEBUG("Power::max17048Init lipo sensor is %s", result ? "ready" : "not ready yet");
+    bool result = lipoLevel.runOnce();
+    LOG_DEBUG("Power::lipoInit lipo sensor is %s", result ? "ready" : "not ready yet");
     if (!result)
         return false;
-    batteryLevel = &max17048Level;
+    batteryLevel = &lipoLevel;
     return true;
 }
 
@@ -1390,88 +1388,7 @@ bool Power::max17048Init()
 /**
  * The Lipo battery level sensor is unavailable - default to AnalogBatteryLevel
  */
-bool Power::max17048Init()
-{
-    return false;
-}
-#endif
-
-#if !MESHTASTIC_EXCLUDE_I2C && HAS_CW2015
-
-class CW2015BatteryLevel : public AnalogBatteryLevel
-{
-  public:
-    /**
-     * Battery state of charge, from 0 to 100 or -1 for unknown
-     */
-    virtual int getBatteryPercent() override
-    {
-        int data = -1;
-        Wire.beginTransmission(CW2015_ADDR);
-        Wire.write(0x04);
-        if (Wire.endTransmission() == 0) {
-            if (Wire.requestFrom(CW2015_ADDR, (uint8_t)1)) {
-                data = Wire.read();
-            }
-        }
-        return data;
-    }
-
-    /**
-     * The raw voltage of the battery in millivolts, or NAN if unknown
-     */
-    virtual uint16_t getBattVoltage() override
-    {
-        uint16_t mv = 0;
-        Wire.beginTransmission(CW2015_ADDR);
-        Wire.write(0x02);
-        if (Wire.endTransmission() == 0) {
-            if (Wire.requestFrom(CW2015_ADDR, (uint8_t)2)) {
-                mv = Wire.read();
-                mv <<= 8;
-                mv |= Wire.read();
-                // Voltage is read in  305uV units, convert to mV
-                mv = mv * 305 / 1000;
-            }
-        }
-        return mv;
-    }
-};
-
-CW2015BatteryLevel cw2015Level;
-
-/**
- * Init the CW2015 battery level sensor
- */
-bool Power::cw2015Init()
-{
-
-    Wire.beginTransmission(CW2015_ADDR);
-    uint8_t getInfo[] = {0x0a, 0x00};
-    Wire.write(getInfo, 2);
-    Wire.endTransmission();
-    delay(10);
-    Wire.beginTransmission(CW2015_ADDR);
-    Wire.write(0x00);
-    bool result = false;
-    if (Wire.endTransmission() == 0) {
-        if (Wire.requestFrom(CW2015_ADDR, (uint8_t)1)) {
-            uint8_t data = Wire.read();
-            LOG_DEBUG("CW2015 init read data: 0x%x", data);
-            if (data == 0x73) {
-                result = true;
-                batteryLevel = &cw2015Level;
-            }
-        }
-    }
-    return result;
-}
-
-#else
-/**
- * The CW2015 battery level sensor is unavailable - default to AnalogBatteryLevel
- */
-bool Power::cw2015Init()
+bool Power::lipoInit()
 {
     return false;
 }

src/PowerFSM.cpp

@@ -9,13 +9,13 @@
  */
 #include "PowerFSM.h"
 #include "Default.h"
+#include "Led.h"
 #include "MeshService.h"
 #include "NodeDB.h"
 #include "PowerMon.h"
 #include "configuration.h"
 #include "graphics/Screen.h"
 #include "main.h"
-#include "modules/StatusLEDModule.h"
 #include "sleep.h"
 #include "target_specific.h"
 
@@ -103,7 +103,7 @@ static void lsIdle()
             uint32_t sleepTime = SLEEP_TIME;
 
             powerMon->setState(meshtastic_PowerMon_State_CPU_LightSleep);
-            statusLEDModule->setPowerLED(false);
+            ledBlink.set(false); // Never leave led on while in light sleep
             esp_sleep_source_t wakeCause2 = doLightSleep(sleepTime * 1000LL);
             powerMon->clearState(meshtastic_PowerMon_State_CPU_LightSleep);
 
@@ -111,7 +111,7 @@ static void lsIdle()
             case ESP_SLEEP_WAKEUP_TIMER:
                 // Normal case: timer expired, we should just go back to sleep ASAP
 
-                statusLEDModule->setPowerLED(true);
+                ledBlink.set(true);             // briefly turn on led
                 wakeCause2 = doLightSleep(100); // leave led on for 1ms
 
                 secsSlept += sleepTime;
@@ -146,7 +146,7 @@ static void lsIdle()
         }
     } else {
         // Time to stop sleeping!
-        statusLEDModule->setPowerLED(false);
+        ledBlink.set(false);
         LOG_INFO("Reached ls_secs, service loop()");
         powerFSM.trigger(EVENT_WAKE_TIMER);
     }

src/configuration.h

@@ -233,7 +233,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define NAU7802_ADDR 0x2A
 #define MAX30102_ADDR 0x57
 #define SCD4X_ADDR 0x62
-#define CW2015_ADDR 0x62
 #define MLX90614_ADDR_DEF 0x5A
 #define CGRADSENS_ADDR 0x66
 #define LTR390UV_ADDR 0x53

src/detect/ScanI2C.h

@@ -88,8 +88,7 @@ class ScanI2C
         BH1750,
         DA217,
         CHSC6X,
-        CST226SE,
-        CW2015
+        CST226SE
     } DeviceType;
 
     // typedef uint8_t DeviceAddress;

src/detect/ScanI2CTwoWire.cpp

@@ -541,17 +541,7 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
                 break;
 
                 SCAN_SIMPLE_CASE(BHI260AP_ADDR, BHI260AP, "BHI260AP", (uint8_t)addr.address);
-            case SCD4X_ADDR: {
-                registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x8), 1);
-                if (registerValue == 0x18) {
-                    logFoundDevice("CW2015", (uint8_t)addr.address);
-                    type = CW2015;
-                } else {
-                    logFoundDevice("SCD4X", (uint8_t)addr.address);
-                    type = SCD4X;
-                }
-                break;
-            }
+                SCAN_SIMPLE_CASE(SCD4X_ADDR, SCD4X, "SCD4X", (uint8_t)addr.address);
                 SCAN_SIMPLE_CASE(BMM150_ADDR, BMM150, "BMM150", (uint8_t)addr.address);
 #ifdef HAS_TPS65233
                 SCAN_SIMPLE_CASE(TPS65233_ADDR, TPS65233, "TPS65233", (uint8_t)addr.address);

src/graphics/NeoPixel.h

@@ -0,0 +1,4 @@
+#ifdef HAS_NEOPIXEL
+#include <Adafruit_NeoPixel.h>
+extern Adafruit_NeoPixel pixels;
+#endif

src/graphics/RAKled.h

@@ -0,0 +1,5 @@
+#ifdef HAS_NCP5623
+#include <NCP5623.h>
+extern NCP5623 rgb;
+
+#endif

src/graphics/SharedUIDisplay.cpp

@@ -221,6 +221,7 @@ void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const char *ti
 
     if (rtc_sec > 0) {
         // === Build Time String ===
+        long hms = (rtc_sec % SEC_PER_DAY + SEC_PER_DAY) % SEC_PER_DAY;
         int hour, minute, second;
         graphics::decomposeTime(rtc_sec, hour, minute, second);
         snprintf(timeStr, sizeof(timeStr), "%d:%02d", hour, minute);

src/graphics/VirtualKeyboard.cpp

@@ -429,10 +429,6 @@ void VirtualKeyboard::drawKey(OLEDDisplay *display, const VirtualKey &key, bool
             c = c - 'a' + 'A';
         }
         keyText = (key.character == ' ' || key.character == '_') ? "_" : std::string(1, c);
-        // Show the common "/" pairing next to "?" like on a real keyboard
-        if (key.type == VK_CHAR && key.character == '?') {
-            keyText = "?/";
-        }
     }
 
     int textWidth = display->getStringWidth(keyText.c_str());
@@ -522,13 +518,9 @@ char VirtualKeyboard::getCharForKey(const VirtualKey &key, bool isLongPress)
 
     char c = key.character;
 
-    // Long-press: letters become uppercase; for "?" provide "/" like a typical keyboard
-    if (isLongPress) {
-        if (c >= 'a' && c <= 'z') {
-            c = (char)(c - 'a' + 'A');
-        } else if (c == '?') {
-            c = '/';
-        }
+    // Long-press: only keep letter lowercase->uppercase conversion; remove other symbol mappings
+    if (isLongPress && c >= 'a' && c <= 'z') {
+        c = (char)(c - 'a' + 'A');
     }
 
     return c;

src/main.cpp

@@ -7,13 +7,13 @@
 #include "NodeDB.h"
 #include "PowerFSM.h"
 #include "PowerMon.h"
-#include "RadioLibInterface.h"
 #include "ReliableRouter.h"
 #include "airtime.h"
 #include "buzz.h"
 #include "power/PowerHAL.h"
 
 #include "FSCommon.h"
+#include "Led.h"
 #include "RTC.h"
 #include "SPILock.h"
 #include "Throttle.h"
@@ -29,6 +29,7 @@
 #include <Wire.h>
 #endif
 #include "detect/einkScan.h"
+#include "graphics/RAKled.h"
 #include "graphics/Screen.h"
 #include "main.h"
 #include "mesh/generated/meshtastic/config.pb.h"
@@ -192,8 +193,6 @@ bool kb_found = false;
 // global bool to record that on-screen keyboard (OSK) is present
 bool osk_found = false;
 
-unsigned long last_listen = 0;
-
 // The I2C address of the RTC Module (if found)
 ScanI2C::DeviceAddress rtc_found = ScanI2C::ADDRESS_NONE;
 // The I2C address of the Accelerometer (if found)
@@ -243,10 +242,28 @@ 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
+    // config.device.led_heartbeat_disabled is changed
+    if (config.device.led_heartbeat_disabled)
+        return 1000;
+
+    static bool ledOn;
+    ledOn ^= 1;
+
+    ledBlink.set(ledOn);
+
+    // have a very sparse duty cycle of LED being on, unless charging, then blink 0.5Hz square wave rate to indicate that
+    return powerStatus->getIsCharging() ? 1000 : (ledOn ? 1 : 1000);
+}
+
 uint32_t timeLastPowered = 0;
 
+static Periodic *ledPeriodic;
 static OSThread *powerFSMthread;
-OSThread *ambientLightingThread;
+static OSThread *ambientLightingThread;
 
 RadioInterface *rIf = NULL;
 #ifdef ARCH_PORTDUINO
@@ -282,16 +299,21 @@ void earlyInitVariant() {}
 // blink user led in 3 flashes sequence to indicate what is happening
 void waitUntilPowerLevelSafe()
 {
+
+#ifdef LED_PIN
+    pinMode(LED_PIN, OUTPUT);
+#endif
+
     while (powerHAL_isPowerLevelSafe() == false) {
 
-#ifdef LED_POWER
+#ifdef LED_PIN
 
         // 3x: blink for 300 ms, pause for 300 ms
 
         for (int i = 0; i < 3; i++) {
-            digitalWrite(LED_POWER, LED_STATE_ON);
+            digitalWrite(LED_PIN, LED_STATE_ON);
             delay(300);
-            digitalWrite(LED_POWER, LED_STATE_OFF);
+            digitalWrite(LED_PIN, LED_STATE_OFF);
             delay(300);
         }
 #endif
@@ -315,11 +337,6 @@ void setup()
     // initialize power HAL layer as early as possible
     powerHAL_init();
 
-#ifdef LED_POWER
-    pinMode(LED_POWER, OUTPUT);
-    digitalWrite(LED_POWER, LED_STATE_ON);
-#endif
-
     // prevent booting if device is in power failure mode
     // boot sequence will follow when battery level raises to safe mode
     waitUntilPowerLevelSafe();
@@ -332,6 +349,11 @@ void setup()
     digitalWrite(PIN_POWER_EN, HIGH);
 #endif
 
+#ifdef LED_POWER
+    pinMode(LED_POWER, OUTPUT);
+    digitalWrite(LED_POWER, LED_STATE_ON);
+#endif
+
 #ifdef LED_NOTIFICATION
     pinMode(LED_NOTIFICATION, OUTPUT);
     digitalWrite(LED_NOTIFICATION, HIGH ^ LED_STATE_ON);
@@ -462,6 +484,16 @@ 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);
+#else
+
+    ledPeriodic = new Periodic("Blink", ledBlinker);
+
+#endif
+
     fsInit();
 
 #if !MESHTASTIC_EXCLUDE_I2C
@@ -686,6 +718,13 @@ void setup()
     setupSDCard();
 #endif
 
+    // LED init
+
+#ifdef LED_PIN
+    pinMode(LED_PIN, OUTPUT);
+    digitalWrite(LED_PIN, LED_STATE_ON); // turn on for now
+#endif
+
     // Hello
     printInfo();
 #ifdef BUILD_EPOCH
@@ -919,6 +958,12 @@ void setup()
     setupNicheGraphics();
 #endif
 
+#ifdef LED_PIN
+    // Turn LED off after boot, if heartbeat by config
+    if (config.device.led_heartbeat_disabled)
+        digitalWrite(LED_PIN, HIGH ^ LED_STATE_ON);
+#endif
+
 // Do this after service.init (because that clears error_code)
 #ifdef HAS_PMU
     if (!pmu_found)
@@ -1121,12 +1166,6 @@ void loop()
 #endif
     power->powerCommandsCheck();
 
-    if (RadioLibInterface::instance != nullptr && !Throttle::isWithinTimespanMs(last_listen, 1000 * 60) &&
-        !(RadioLibInterface::instance->isSending() || RadioLibInterface::instance->isActivelyReceiving())) {
-        RadioLibInterface::instance->startReceive();
-        LOG_DEBUG("attempting AGC reset");
-    }
-
 #ifdef DEBUG_STACK
     static uint32_t lastPrint = 0;
     if (!Throttle::isWithinTimespanMs(lastPrint, 10 * 1000L)) {

src/main.h

@@ -33,7 +33,6 @@ extern ScanI2C::DeviceAddress cardkb_found;
 extern uint8_t kb_model;
 extern bool kb_found;
 extern bool osk_found;
-extern unsigned long last_listen;
 extern ScanI2C::DeviceAddress rtc_found;
 extern ScanI2C::DeviceAddress accelerometer_found;
 extern ScanI2C::FoundDevice rgb_found;

src/mesh/NextHopRouter.cpp

@@ -145,6 +145,18 @@ 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/PacketHistory.cpp

@@ -90,9 +90,9 @@ bool PacketHistory::wasSeenRecently(const meshtastic_MeshPacket *p, bool withUpd
     bool seenRecently = (found != NULL);        // If found -> the packet was seen recently
 
     // Check for hop_limit upgrade scenario
-    if (seenRecently && wasUpgraded && getHighestHopLimit(*found) < p->hop_limit) {
-        LOG_DEBUG("Packet History - Hop limit upgrade: packet 0x%08x from hop_limit=%d to hop_limit=%d", p->id,
-                  getHighestHopLimit(*found), p->hop_limit);
+    if (seenRecently && wasUpgraded && found->hop_limit < p->hop_limit) {
+        LOG_DEBUG("Packet History - Hop limit upgrade: packet 0x%08x from hop_limit=%d to hop_limit=%d", p->id, found->hop_limit,
+                  p->hop_limit);
         *wasUpgraded = true;
     } else if (wasUpgraded) {
         *wasUpgraded = false; // Initialize to false if not an upgrade

src/mesh/RadioInterface.cpp

@@ -648,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 Ch=0x%x", prefix, p->id,
-                              p->from, p->to, p->transport_mechanism, p->want_ack, p->hop_limit, 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 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);
     if (p->which_payload_variant == meshtastic_MeshPacket_decoded_tag) {
         auto &s = p->decoded;
 

src/mesh/RadioLibInterface.cpp

@@ -514,8 +514,6 @@ void RadioLibInterface::handleReceiveInterrupt()
 
 void RadioLibInterface::startReceive()
 {
-    // Note the updated timestamp, to avoid unneeded AGC resets
-    last_listen = millis();
     isReceiving = true;
     powerMon->setState(meshtastic_PowerMon_State_Lora_RXOn);
 }

src/mesh/Router.cpp

@@ -16,6 +16,7 @@
 #endif
 #include "Default.h"
 #if ARCH_PORTDUINO
+#include "modules/Native/StoreForwardPlusPlus.h"
 #include "platform/portduino/PortduinoGlue.h"
 #endif
 #if ENABLE_JSON_LOGGING || ARCH_PORTDUINO
@@ -365,6 +366,12 @@ 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) {
@@ -745,6 +752,22 @@ 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/http/ContentHandler.cpp

@@ -9,6 +9,7 @@
 #if HAS_WIFI
 #include "mesh/wifi/WiFiAPClient.h"
 #endif
+#include "Led.h"
 #include "SPILock.h"
 #include "power.h"
 #include "serialization/JSON.h"
@@ -91,6 +92,7 @@ void registerHandlers(HTTPServer *insecureServer, HTTPSServer *secureServer)
     ResourceNode *nodeFormUpload = new ResourceNode("/upload", "POST", &handleFormUpload);
 
     ResourceNode *nodeJsonScanNetworks = new ResourceNode("/json/scanNetworks", "GET", &handleScanNetworks);
+    ResourceNode *nodeJsonBlinkLED = new ResourceNode("/json/blink", "POST", &handleBlinkLED);
     ResourceNode *nodeJsonReport = new ResourceNode("/json/report", "GET", &handleReport);
     ResourceNode *nodeJsonNodes = new ResourceNode("/json/nodes", "GET", &handleNodes);
     ResourceNode *nodeJsonFsBrowseStatic = new ResourceNode("/json/fs/browse/static", "GET", &handleFsBrowseStatic);
@@ -108,6 +110,7 @@ void registerHandlers(HTTPServer *insecureServer, HTTPSServer *secureServer)
     secureServer->registerNode(nodeRestart);
     secureServer->registerNode(nodeFormUpload);
     secureServer->registerNode(nodeJsonScanNetworks);
+    secureServer->registerNode(nodeJsonBlinkLED);
     secureServer->registerNode(nodeJsonFsBrowseStatic);
     secureServer->registerNode(nodeJsonDelete);
     secureServer->registerNode(nodeJsonReport);
@@ -130,6 +133,7 @@ void registerHandlers(HTTPServer *insecureServer, HTTPSServer *secureServer)
     insecureServer->registerNode(nodeRestart);
     insecureServer->registerNode(nodeFormUpload);
     insecureServer->registerNode(nodeJsonScanNetworks);
+    insecureServer->registerNode(nodeJsonBlinkLED);
     insecureServer->registerNode(nodeJsonFsBrowseStatic);
     insecureServer->registerNode(nodeJsonDelete);
     insecureServer->registerNode(nodeJsonReport);
@@ -900,6 +904,45 @@ void handleRestart(HTTPRequest *req, HTTPResponse *res)
     webServerThread->requestRestart = (millis() / 1000) + 5;
 }
 
+void handleBlinkLED(HTTPRequest *req, HTTPResponse *res)
+{
+    res->setHeader("Content-Type", "application/json");
+    res->setHeader("Access-Control-Allow-Origin", "*");
+    res->setHeader("Access-Control-Allow-Methods", "POST");
+
+    ResourceParameters *params = req->getParams();
+    std::string blink_target;
+
+    if (!params->getQueryParameter("blink_target", blink_target)) {
+        // if no blink_target was supplied in the URL parameters of the
+        // POST request, then assume we should blink the LED
+        blink_target = "LED";
+    }
+
+    if (blink_target == "LED") {
+        uint8_t count = 10;
+        while (count > 0) {
+            ledBlink.set(true);
+            delay(50);
+            ledBlink.set(false);
+            delay(50);
+            count = count - 1;
+        }
+    } else {
+#if HAS_SCREEN
+        if (screen)
+            screen->blink();
+#endif
+    }
+
+    JSONObject jsonObjOuter;
+    jsonObjOuter["status"] = new JSONValue("ok");
+    JSONValue *value = new JSONValue(jsonObjOuter);
+    std::string jsonString = value->Stringify();
+    res->print(jsonString.c_str());
+    delete value;
+}
+
 void handleScanNetworks(HTTPRequest *req, HTTPResponse *res)
 {
     res->setHeader("Content-Type", "application/json");

src/mesh/http/ContentHandler.h

@@ -11,6 +11,7 @@ void handleFormUpload(HTTPRequest *req, HTTPResponse *res);
 void handleScanNetworks(HTTPRequest *req, HTTPResponse *res);
 void handleFsBrowseStatic(HTTPRequest *req, HTTPResponse *res);
 void handleFsDeleteStatic(HTTPRequest *req, HTTPResponse *res);
+void handleBlinkLED(HTTPRequest *req, HTTPResponse *res);
 void handleReport(HTTPRequest *req, HTTPResponse *res);
 void handleNodes(HTTPRequest *req, HTTPResponse *res);
 void handleUpdateFs(HTTPRequest *req, HTTPResponse *res);

src/modules/AdminModule.cpp

@@ -643,6 +643,12 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c)
             accelerometerThread->enabled = true;
             accelerometerThread->start();
         }
+#endif
+#ifdef LED_PIN
+        // Turn LED off if heartbeat by config
+        if (c.payload_variant.device.led_heartbeat_disabled) {
+            digitalWrite(LED_PIN, HIGH ^ LED_STATE_ON);
+        }
 #endif
         if (config.device.button_gpio == c.payload_variant.device.button_gpio &&
             config.device.buzzer_gpio == c.payload_variant.device.buzzer_gpio &&

src/modules/ExternalNotificationModule.cpp

@@ -24,8 +24,24 @@
 #include "mesh/generated/meshtastic/rtttl.pb.h"
 #include <Arduino.h>
 
+#ifdef HAS_NCP5623
+#include <graphics/RAKled.h>
+#endif
+
+#ifdef HAS_LP5562
+#include <graphics/NomadStarLED.h>
+#endif
+
+#ifdef HAS_NEOPIXEL
+#include <graphics/NeoPixel.h>
+#endif
+
+#ifdef UNPHONE
+#include "unPhone.h"
+extern unPhone unphone;
+#endif
+
 #if defined(HAS_RGB_LED)
-#include "AmbientLightingThread.h"
 uint8_t red = 0;
 uint8_t green = 0;
 uint8_t blue = 0;
@@ -107,6 +123,32 @@ int32_t ExternalNotificationModule::runOnce()
             green = (colorState & 2) ? brightnessValues[brightnessIndex] : 0;        // Green enabled on colorState = 2,3,6,7
             blue = (colorState & 1) ? (brightnessValues[brightnessIndex] * 1.5) : 0; // Blue enabled on colorState = 1,3,5,7
             white = (colorState & 12) ? brightnessValues[brightnessIndex] : 0;
+#ifdef HAS_NCP5623
+            if (rgb_found.type == ScanI2C::NCP5623) {
+                rgb.setColor(red, green, blue);
+            }
+#endif
+#ifdef HAS_LP5562
+            if (rgb_found.type == ScanI2C::LP5562) {
+                rgbw.setColor(red, green, blue, white);
+            }
+#endif
+#ifdef RGBLED_CA
+            analogWrite(RGBLED_RED, 255 - red); // CA type needs reverse logic
+            analogWrite(RGBLED_GREEN, 255 - green);
+            analogWrite(RGBLED_BLUE, 255 - blue);
+#elif defined(RGBLED_RED)
+            analogWrite(RGBLED_RED, red);
+            analogWrite(RGBLED_GREEN, green);
+            analogWrite(RGBLED_BLUE, blue);
+#endif
+#ifdef HAS_NEOPIXEL
+            pixels.fill(pixels.Color(red, green, blue), 0, NEOPIXEL_COUNT);
+            pixels.show();
+#endif
+#ifdef UNPHONE
+            unphone.rgb(red, green, blue);
+#endif
             if (ascending) { // fade in
                 brightnessIndex++;
                 if (brightnessIndex == (sizeof(brightnessValues) - 1)) {
@@ -213,9 +255,34 @@ void ExternalNotificationModule::setExternalState(uint8_t index, bool on)
         blue = 0;
         white = 0;
     }
-    ambientLightingThread->setLighting(moduleConfig.ambient_lighting.current, red, green, blue);
 #endif
 
+#ifdef HAS_NCP5623
+    if (rgb_found.type == ScanI2C::NCP5623) {
+        rgb.setColor(red, green, blue);
+    }
+#endif
+#ifdef HAS_LP5562
+    if (rgb_found.type == ScanI2C::LP5562) {
+        rgbw.setColor(red, green, blue, white);
+    }
+#endif
+#ifdef RGBLED_CA
+    analogWrite(RGBLED_RED, 255 - red); // CA type needs reverse logic
+    analogWrite(RGBLED_GREEN, 255 - green);
+    analogWrite(RGBLED_BLUE, 255 - blue);
+#elif defined(RGBLED_RED)
+    analogWrite(RGBLED_RED, red);
+    analogWrite(RGBLED_GREEN, green);
+    analogWrite(RGBLED_BLUE, blue);
+#endif
+#ifdef HAS_NEOPIXEL
+    pixels.fill(pixels.Color(red, green, blue), 0, NEOPIXEL_COUNT);
+    pixels.show();
+#endif
+#ifdef UNPHONE
+    unphone.rgb(red, green, blue);
+#endif
 #ifdef HAS_DRV2605
     if (on) {
         drv.go();
@@ -340,6 +407,33 @@ ExternalNotificationModule::ExternalNotificationModule()
                 LOG_INFO("Use Pin %i in PWM mode", config.device.buzzer_gpio);
             }
         }
+#ifdef HAS_NCP5623
+        if (rgb_found.type == ScanI2C::NCP5623) {
+            rgb.begin();
+            rgb.setCurrent(10);
+        }
+#endif
+#ifdef HAS_LP5562
+        if (rgb_found.type == ScanI2C::LP5562) {
+            rgbw.begin();
+            rgbw.setCurrent(20);
+        }
+#endif
+#ifdef RGBLED_RED
+        pinMode(RGBLED_RED, OUTPUT); // set up the RGB led pins
+        pinMode(RGBLED_GREEN, OUTPUT);
+        pinMode(RGBLED_BLUE, OUTPUT);
+#endif
+#ifdef RGBLED_CA
+        analogWrite(RGBLED_RED, 255);   // with a common anode type, logic is reversed
+        analogWrite(RGBLED_GREEN, 255); // so we want to initialise with lights off
+        analogWrite(RGBLED_BLUE, 255);
+#endif
+#ifdef HAS_NEOPIXEL
+        pixels.begin(); // Initialise the pixel(s)
+        pixels.clear(); // Set all pixel colors to 'off'
+        pixels.setBrightness(moduleConfig.ambient_lighting.current);
+#endif
     } else {
         LOG_INFO("External Notification Module Disabled");
         disable();

src/modules/ExternalNotificationModule.h

@@ -5,11 +5,6 @@
 #include "configuration.h"
 #include "input/InputBroker.h"
 
-#ifdef HAS_RGB_LED
-#include "AmbientLightingThread.h"
-extern AmbientLightingThread *ambientLightingThread;
-#endif
-
 #if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL) && !defined(CONFIG_IDF_TARGET_ESP32C6)
 #include <NonBlockingRtttl.h>
 #else

src/modules/Modules.cpp

@@ -1,9 +1,9 @@
 #include "configuration.h"
 #if !MESHTASTIC_EXCLUDE_INPUTBROKER
 #include "buzz/BuzzerFeedbackThread.h"
+#include "modules/StatusLEDModule.h"
 #include "modules/SystemCommandsModule.h"
 #endif
-#include "modules/StatusLEDModule.h"
 #if !MESHTASTIC_EXCLUDE_REPLYBOT
 #include "ReplyBotModule.h"
 #endif
@@ -46,6 +46,9 @@
 #include "modules/WaypointModule.h"
 #endif
 #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"
@@ -112,7 +115,9 @@ void setupModules()
         buzzerFeedbackThread = new BuzzerFeedbackThread();
     }
 #endif
+#if defined(LED_CHARGE) || defined(LED_PAIRING)
     statusLEDModule = new StatusLEDModule();
+#endif
 #if !MESHTASTIC_EXCLUDE_REPLYBOT
     new ReplyBotModule();
 #endif
@@ -180,6 +185,11 @@ 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

@@ -0,0 +1,310 @@
+#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/modules/PowerStressModule.cpp

@@ -1,4 +1,5 @@
 #include "PowerStressModule.h"
+#include "Led.h"
 #include "MeshService.h"
 #include "NodeDB.h"
 #include "PowerMon.h"
@@ -77,12 +78,10 @@ int32_t PowerStressModule::runOnce()
 
             switch (p.cmd) {
             case meshtastic_PowerStressMessage_Opcode_LED_ON:
-                // FIXME - implement
-                // ledForceOn.set(true);
+                ledForceOn.set(true);
                 break;
             case meshtastic_PowerStressMessage_Opcode_LED_OFF:
-                // FIXME - implement
-                // ledForceOn.set(false);
+                ledForceOn.set(false);
                 break;
             case meshtastic_PowerStressMessage_Opcode_GPS_ON:
                 // FIXME - implement

src/modules/StatusLEDModule.cpp

@@ -13,10 +13,8 @@ StatusLEDModule::StatusLEDModule() : concurrency::OSThread("StatusLEDModule")
 {
     bluetoothStatusObserver.observe(&bluetoothStatus->onNewStatus);
     powerStatusObserver.observe(&powerStatus->onNewStatus);
-#if !MESHTASTIC_EXCLUDE_INPUTBROKER
     if (inputBroker)
         inputObserver.observe(inputBroker);
-#endif
 }
 
 int StatusLEDModule::handleStatusUpdate(const meshtastic::Status *arg)
@@ -64,22 +62,19 @@ int StatusLEDModule::handleStatusUpdate(const meshtastic::Status *arg)
     }
     return 0;
 };
-#if !MESHTASTIC_EXCLUDE_INPUTBROKER
+
 int StatusLEDModule::handleInputEvent(const InputEvent *event)
 {
     lastUserbuttonTime = millis();
     return 0;
 }
-#endif
 
 int32_t StatusLEDModule::runOnce()
 {
     my_interval = 1000;
 
     if (power_state == charging) {
-#ifndef POWER_LED_HARDWARE_BLINKS_WHILE_CHARGING
         CHARGE_LED_state = !CHARGE_LED_state;
-#endif
     } else if (power_state == charged) {
         CHARGE_LED_state = LED_STATE_ON;
     } else if (power_state == critical) {
@@ -99,15 +94,7 @@ int32_t StatusLEDModule::runOnce()
         }
 
     } else {
-        if (doing_fast_blink) {
-            CHARGE_LED_state = LED_STATE_OFF;
-            doing_fast_blink = false;
-            my_interval = 999;
-        } else {
-            CHARGE_LED_state = LED_STATE_ON;
-            doing_fast_blink = true;
-            my_interval = 1;
-        }
+        CHARGE_LED_state = LED_STATE_OFF;
     }
 
     if (!config.bluetooth.enabled || PAIRING_LED_starttime + 30 * 1000 < millis() || doing_fast_blink) {
@@ -125,11 +112,6 @@ int32_t StatusLEDModule::runOnce()
         PAIRING_LED_state = LED_STATE_ON;
     }
 
-    // Override if disabled in config
-    if (config.device.led_heartbeat_disabled) {
-        CHARGE_LED_state = LED_STATE_OFF;
-    }
-#ifdef Battery_LED_1
     bool chargeIndicatorLED1 = LED_STATE_OFF;
     bool chargeIndicatorLED2 = LED_STATE_OFF;
     bool chargeIndicatorLED3 = LED_STATE_OFF;
@@ -144,38 +126,14 @@ int32_t StatusLEDModule::runOnce()
         if (powerStatus && powerStatus->getBatteryChargePercent() >= 75)
             chargeIndicatorLED4 = LED_STATE_ON;
     }
-#endif
 
-#if defined(HAS_PMU)
-    if (pmu_found && PMU) {
-        // blink the axp led
-        PMU->setChargingLedMode(CHARGE_LED_state ? XPOWERS_CHG_LED_ON : XPOWERS_CHG_LED_OFF);
-    }
-#endif
-
-#ifdef PCA_LED_POWER
-    io.digitalWrite(PCA_LED_POWER, CHARGE_LED_state);
-#endif
-#ifdef PCA_LED_ENABLE
-    io.digitalWrite(PCA_LED_ENABLE, CHARGE_LED_state);
-#endif
-#ifdef LED_POWER
-    digitalWrite(LED_POWER, CHARGE_LED_state);
+#ifdef LED_CHARGE
+    digitalWrite(LED_CHARGE, CHARGE_LED_state);
 #endif
 #ifdef LED_PAIRING
     digitalWrite(LED_PAIRING, PAIRING_LED_state);
 #endif
 
-#ifdef RGB_LED_POWER
-    if (!config.device.led_heartbeat_disabled) {
-        if (CHARGE_LED_state == LED_STATE_ON) {
-            ambientLightingThread->setLighting(10, 255, 0, 0);
-        } else {
-            ambientLightingThread->setLighting(0, 0, 0, 0);
-        }
-    }
-#endif
-
 #ifdef Battery_LED_1
     digitalWrite(Battery_LED_1, chargeIndicatorLED1);
 #endif
@@ -191,43 +149,3 @@ int32_t StatusLEDModule::runOnce()
 
     return (my_interval);
 }
-
-void StatusLEDModule::setPowerLED(bool LEDon)
-{
-
-#if defined(HAS_PMU)
-    if (pmu_found && PMU) {
-        // blink the axp led
-        PMU->setChargingLedMode(LEDon ? XPOWERS_CHG_LED_ON : XPOWERS_CHG_LED_OFF);
-    }
-#endif
-    if (LEDon)
-        LEDon = LED_STATE_ON;
-    else
-        LEDon = LED_STATE_OFF;
-#ifdef PCA_LED_POWER
-    io.digitalWrite(PCA_LED_POWER, LEDon);
-#endif
-#ifdef PCA_LED_ENABLE
-    io.digitalWrite(PCA_LED_ENABLE, LEDon);
-#endif
-#ifdef LED_POWER
-    digitalWrite(LED_POWER, LEDon);
-#endif
-#ifdef LED_PAIRING
-    digitalWrite(LED_PAIRING, LEDon);
-#endif
-
-#ifdef Battery_LED_1
-    digitalWrite(Battery_LED_1, LEDon);
-#endif
-#ifdef Battery_LED_2
-    digitalWrite(Battery_LED_2, LEDon);
-#endif
-#ifdef Battery_LED_3
-    digitalWrite(Battery_LED_3, LEDon);
-#endif
-#ifdef Battery_LED_4
-    digitalWrite(Battery_LED_4, LEDon);
-#endif
-}

src/modules/StatusLEDModule.h

@@ -5,14 +5,10 @@
 #include "PowerStatus.h"
 #include "concurrency/OSThread.h"
 #include "configuration.h"
-#include "main.h"
+#include "input/InputBroker.h"
 #include <Arduino.h>
 #include <functional>
 
-#if !MESHTASTIC_EXCLUDE_INPUTBROKER
-#include "input/InputBroker.h"
-#endif
-
 class StatusLEDModule : private concurrency::OSThread
 {
     bool slowTrack = false;
@@ -21,11 +17,8 @@ class StatusLEDModule : private concurrency::OSThread
     StatusLEDModule();
 
     int handleStatusUpdate(const meshtastic::Status *);
-#if !MESHTASTIC_EXCLUDE_INPUTBROKER
-    int handleInputEvent(const InputEvent *arg);
-#endif
 
-    void setPowerLED(bool);
+    int handleInputEvent(const InputEvent *arg);
 
   protected:
     unsigned int my_interval = 1000; // interval in millisconds
@@ -35,10 +28,8 @@ class StatusLEDModule : private concurrency::OSThread
         CallbackObserver<StatusLEDModule, const meshtastic::Status *>(this, &StatusLEDModule::handleStatusUpdate);
     CallbackObserver<StatusLEDModule, const meshtastic::Status *> powerStatusObserver =
         CallbackObserver<StatusLEDModule, const meshtastic::Status *>(this, &StatusLEDModule::handleStatusUpdate);
-#if !MESHTASTIC_EXCLUDE_INPUTBROKER
     CallbackObserver<StatusLEDModule, const InputEvent *> inputObserver =
         CallbackObserver<StatusLEDModule, const InputEvent *>(this, &StatusLEDModule::handleInputEvent);
-#endif
 
   private:
     bool CHARGE_LED_state = LED_STATE_OFF;
@@ -59,7 +50,3 @@ class StatusLEDModule : private concurrency::OSThread
 };
 
 extern StatusLEDModule *statusLEDModule;
-#ifdef RGB_LED_POWER
-#include "AmbientLightingThread.h"
-extern AmbientLightingThread *ambientLightingThread;
-#endif

src/platform/nrf52/architecture.h

@@ -158,7 +158,7 @@
 #endif
 
 #ifdef PIN_LED1
-#define LED_POWER PIN_LED1 // LED1 on nrf52840-DK
+#define LED_PIN PIN_LED1 // LED1 on nrf52840-DK
 #endif
 
 #ifdef PIN_BUTTON1

src/platform/portduino/PortduinoGlue.cpp

@@ -182,6 +182,7 @@ 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)
@@ -894,6 +895,28 @@ 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

@@ -184,6 +184,26 @@ extern struct portduino_config_struct {
     bool has_statusMessage = false;
     bool enable_UDP = 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,6 +558,29 @@ 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/power.h

@@ -103,10 +103,8 @@ class Power : private concurrency::OSThread
     bool axpChipInit();
     /// Setup a simple ADC input based battery sensor
     bool analogInit();
-    /// Setup cw2015 battery level sensor
-    bool cw2015Init();
-    /// Setup a 17048 battery level sensor
-    bool max17048Init();
+    /// Setup a Lipo battery level sensor
+    bool lipoInit();
     /// Setup a Lipo charger
     bool lipoChargerInit();
     /// Setup a meshSolar battery sensor

src/sleep.cpp

@@ -5,6 +5,7 @@
 #endif
 
 #include "Default.h"
+#include "Led.h"
 #include "MeshRadio.h"
 #include "MeshService.h"
 #include "NodeDB.h"
@@ -12,7 +13,6 @@
 #include "detect/LoRaRadioType.h"
 #include "error.h"
 #include "main.h"
-#include "modules/StatusLEDModule.h"
 #include "sleep.h"
 #include "target_specific.h"
 
@@ -268,7 +268,8 @@ void doDeepSleep(uint32_t msecToWake, bool skipPreflight = false, bool skipSaveN
     digitalWrite(PIN_WD_EN, LOW);
 #endif
 #endif
-    statusLEDModule->setPowerLED(false);
+    ledBlink.set(false);
+
 #ifdef RESET_OLED
     digitalWrite(RESET_OLED, 1); // put the display in reset before killing its power
 #endif

variants/esp32/betafpv_2400_tx_micro/variant.h

@@ -14,7 +14,7 @@
 #define LORA_CS 5
 #define RF95_FAN_EN 17
 
-// This is a LED_WS2812 not a standard LED
+// #define LED_PIN 16 // This is a LED_WS2812 not a standard LED
 #define HAS_NEOPIXEL                         // Enable the use of neopixels
 #define NEOPIXEL_COUNT 1                     // How many neopixels are connected
 #define NEOPIXEL_DATA 16                     // gpio pin used to send data to the neopixels

variants/esp32/betafpv_900_tx_nano/variant.h

@@ -20,7 +20,7 @@
 #define LORA_DIO2
 #define LORA_DIO3
 
-#define LED_POWER 16 // green - blue is at 17
+#define LED_PIN 16 // green - blue is at 17
 
 #define BUTTON_PIN 25
 #define BUTTON_NEED_PULLUP

variants/esp32/chatter2/variant.h

@@ -23,6 +23,8 @@
 #define SX126X_TXEN RADIOLIB_NC
 #define SX126X_RXEN RADIOLIB_NC
 
+// Status
+// #define LED_PIN 1
 // External notification
 // FIXME: Check if EXT_NOTIFY_OUT actualy has any effect and removes the need for setting the external notication pin in the
 // app/preferences

variants/esp32/diy/9m2ibr_aprs_lora_tracker/variant.h

@@ -21,8 +21,8 @@
 #define BUTTON_PIN 15 // Right side button - if not available, set device.button_gpio to 0 from Meshtastic client
 
 // LEDs
-#define LED_POWER 13 // Tx LED
-#define USER_LED 2   // Rx LED
+#define LED_PIN 13 // Tx LED
+#define USER_LED 2 // Rx LED
 
 // Buzzer
 #define PIN_BUZZER 33

variants/esp32/diy/hydra/variant.h

@@ -15,7 +15,7 @@
 #define ADC_MULTIPLIER 1.85 // (R1 = 470k, R2 = 680k)
 #define EXT_PWR_DETECT 4    // Pin to detect connected external power source for LILYGO® TTGO T-Energy T18 and other DIY boards
 #define EXT_NOTIFY_OUT 12   // Overridden default pin to use for Ext Notify Module (#975).
-#define LED_POWER 2         // add status LED (compatible with core-pcb and DIY targets)
+#define LED_PIN 2           // add status LED (compatible with core-pcb and DIY targets)
 
 // Radio
 #define USE_SX1262 // E22-900M30S uses SX1262

variants/esp32/diy/v1/variant.h

@@ -15,7 +15,7 @@
 #define ADC_MULTIPLIER 1.85 // (R1 = 470k, R2 = 680k)
 #define EXT_PWR_DETECT 4    // Pin to detect connected external power source for LILYGO® TTGO T-Energy T18 and other DIY boards
 #define EXT_NOTIFY_OUT 12   // Overridden default pin to use for Ext Notify Module (#975).
-#define LED_POWER 2         // add status LED (compatible with core-pcb and DIY targets)
+#define LED_PIN 2           // add status LED (compatible with core-pcb and DIY targets)
 
 #define LORA_DIO0 26  // a No connect on the SX1262/SX1268 module
 #define LORA_RESET 23 // RST for SX1276, and for SX1262/SX1268

variants/esp32/hackerboxes_esp32_io/variant.h

@@ -3,7 +3,7 @@
 // HACKBOX LoRa IO Kit
 // Uses a ESP-32-WROOM and a RA-01SH (SX1262) LoRa Board
 
-#define LED_POWER 2    // LED
+#define LED_PIN 2      // LED
 #define LED_STATE_ON 1 // State when LED is lit
 
 #define HAS_SCREEN 0

variants/esp32/heltec_v1/variant.h

@@ -12,7 +12,7 @@
 
 #define RESET_OLED 16 // If defined, this pin will be used to reset the display controller
 
-#define LED_POWER 25 // If defined we will blink this LED
+#define LED_PIN 25   // If defined we will blink this LED
 #define BUTTON_PIN 0 // If defined, this will be used for user button presses
 
 #define USE_RF95

variants/esp32/heltec_v2.1/variant.h

@@ -18,7 +18,7 @@
 #define RESET_OLED 16 // If defined, this pin will be used to reset the display controller
 
 #define VEXT_ENABLE 21 // active low, powers the oled display and the lora antenna boost
-#define LED_POWER 25   // If defined we will blink this LED
+#define LED_PIN 25     // If defined we will blink this LED
 #define BUTTON_PIN 0   // If defined, this will be used for user button presses
 
 #define USE_RF95

variants/esp32/heltec_v2/variant.h

@@ -13,7 +13,7 @@
 #define RESET_OLED 16 // If defined, this pin will be used to reset the display controller
 
 #define VEXT_ENABLE 21 // active low, powers the oled display and the lora antenna boost
-#define LED_POWER 25   // If defined we will blink this LED
+#define LED_PIN 25     // If defined we will blink this LED
 #define BUTTON_PIN 0   // If defined, this will be used for user button presses
 
 #define USE_RF95

variants/esp32/heltec_wireless_bridge/variant.h

@@ -15,7 +15,7 @@
 #undef GPS_TX_PIN
 
 // Green / Lora = PIN 22 / GPIO2, Yellow / Wifi = PIN 23 / GPIO0, Blue / BLE = PIN 25 / GPIO16
-#define LED_POWER 22
+#define LED_PIN 22
 #define WIFI_LED 23
 #define BLE_LED 25
 

variants/esp32/heltec_wsl_v2.1/variant.h

@@ -1,7 +1,7 @@
 #define I2C_SCL SCL
 #define I2C_SDA SDA
 
-#define LED_POWER LED
+#define LED_PIN LED
 
 // active low, powers the Battery reader, but no lora antenna boost (?)
 // #define VEXT_ENABLE Vext

variants/esp32/m5stack_coreink/variant.h

@@ -11,7 +11,7 @@
 
 // Green LED
 #define LED_STATE_ON 1 // State when LED is lit
-#define LED_POWER 10
+#define LED_PIN 10
 
 // PCF8563 RTC Module
 #define PCF8563_RTC 0x51

variants/esp32/radiomaster_900_bandit_nano/variant.h

@@ -37,7 +37,7 @@
 /*
   LED PIN setup.
 */
-#define LED_POWER 15
+#define LED_PIN 15
 
 /*
   Five way button when using ADC.

variants/esp32/rak11200/variant.h

@@ -43,7 +43,7 @@ static const uint8_t SCK = 33;
 #undef GPS_TX_PIN
 #define GPS_TX_PIN (TX1)
 
-#define LED_POWER LED_BLUE
+#define LED_PIN LED_BLUE
 
 #define PIN_VBAT WB_A0
 #define BATTERY_PIN PIN_VBAT

variants/esp32/tbeam/variant.h

@@ -9,7 +9,7 @@
 #define EXT_NOTIFY_OUT 13 // Default pin to use for Ext Notify Module.
 
 #define LED_STATE_ON 0 // State when LED is lit
-#define LED_POWER 4    // Newer tbeams (1.1) have an extra led on GPIO4
+#define LED_PIN 4      // Newer tbeams (1.1) have an extra led on GPIO4
 
 // TTGO uses a common pinout for their SX1262 vs RF95 modules - both can be enabled and we will probe at runtime for RF95 and if
 // not found then probe for SX1262
@@ -49,7 +49,7 @@
 
 #undef EXT_NOTIFY_OUT
 #undef LED_STATE_ON
-#undef LED_POWER
+#undef LED_PIN
 
 #define HAS_CST226SE 1
 #define HAS_TOUCHSCREEN 1

variants/esp32/tlora_v1/variant.h

@@ -5,7 +5,7 @@
 
 #define VEXT_ENABLE 21 // active low, powers the oled display and the lora antenna boost
 #define VEXT_ON_VALUE LOW
-#define LED_POWER 2  // If defined we will blink this LED
+#define LED_PIN 2    // If defined we will blink this LED
 #define BUTTON_PIN 0 // If defined, this will be used for user button presses
 #define BUTTON_NEED_PULLUP
 #define EXT_NOTIFY_OUT 13 // Default pin to use for Ext Notify Module.

variants/esp32/tlora_v1_3/variant.h

@@ -7,7 +7,7 @@
 #define RESET_OLED 16 // If defined, this pin will be used to reset the display controller
 
 #define VEXT_ENABLE 21 // active low, powers the oled display and the lora antenna boost
-#define LED_POWER 25   // If defined we will blink this LED
+#define LED_PIN 25     // If defined we will blink this LED
 #define BUTTON_PIN 36
 #define BUTTON_NEED_PULLUP
 

variants/esp32/tlora_v2/variant.h

@@ -5,7 +5,7 @@
 #define I2C_SCL 22
 
 #define VEXT_ENABLE 21 // active low, powers the oled display and the lora antenna boost
-#define LED_POWER 25   // If defined we will blink this LED
+#define LED_PIN 25     // If defined we will blink this LED
 #define BUTTON_PIN                                                                                                               \
     0 // If defined, this will be used for user button presses, if your board doesn't have a physical switch, you can wire one
       // between this pin and ground

variants/esp32/tlora_v2_1_16/platformio.ini

@@ -22,4 +22,4 @@ build_flags =
   ${env:tlora-v2-1-1_6.build_flags}
   -DBUTTON_PIN=0
   -DPIN_BUZZER=25
-  -DLED_POWER=-1
+  -DLED_PIN=-1

variants/esp32/tlora_v2_1_16/variant.h

@@ -8,10 +8,10 @@
 #define I2C_SDA 21 // I2C pins for this board
 #define I2C_SCL 22
 
-#if defined(LED_POWER) && LED_POWER == -1
-#undef LED_POWER
+#if defined(LED_PIN) && LED_PIN == -1
+#undef LED_PIN
 #else
-#define LED_POWER 25 // If defined we will blink this LED
+#define LED_PIN 25 // If defined we will blink this LED
 #endif
 
 #define USE_RF95

variants/esp32/tlora_v2_1_18/variant.h

@@ -6,7 +6,7 @@
 #define I2C_SDA 21 // I2C pins for this board
 #define I2C_SCL 22
 
-#define LED_POWER 25  // If defined we will blink this LED
+#define LED_PIN 25    // If defined we will blink this LED
 #define BUTTON_PIN 12 // If defined, this will be used for user button presses,
 
 #define BUTTON_NEED_PULLUP

variants/esp32/trackerd/variant.h

@@ -8,7 +8,7 @@
 #define GPS_RX_PIN 9
 #define GPS_TX_PIN 10
 
-#define LED_POWER 13 // 13 red, 2 blue, 15 red
+#define LED_PIN 13 // 13 red, 2 blue, 15 red
 
 #define BUTTON_PIN 0
 #define BUTTON_NEED_PULLUP

variants/esp32c3/ai-c3/variant.h

@@ -4,7 +4,7 @@
 #define I2C_SCL SCL
 
 #define BUTTON_PIN 9 // BOOT button
-#define LED_POWER 30 // RGB LED
+#define LED_PIN 30   // RGB LED
 
 #define USE_RF95
 #define LORA_SCK 4

variants/esp32c3/hackerboxes_esp32c3_oled/variant.h

@@ -3,7 +3,7 @@
 // Hackerboxes LoRa ESP32-C3 OLED Kit
 // Uses a ESP32-C3 OLED Board and a RA-01SH (SX1262) LoRa Board
 
-#define LED_POWER 8    // LED
+#define LED_PIN 8      // LED
 #define LED_STATE_ON 1 // State when LED is lit
 
 #define HAS_SCREEN 0

variants/esp32c3/heltec_esp32c3/variant.h

@@ -3,7 +3,7 @@
 // LED pin on HT-DEV-ESP_V2 and HT-DEV-ESP_V3
 // https://resource.heltec.cn/download/HT-CT62/HT-CT62_Reference_Design.pdf
 // https://resource.heltec.cn/download/HT-DEV-ESP/HT-DEV-ESP_V3_Sch.pdf
-#define LED_POWER 2    // LED
+#define LED_PIN 2      // LED
 #define LED_STATE_ON 1 // State when LED is lit
 
 #define HAS_SCREEN 0

variants/esp32c6/tlora_c6/variant.h

@@ -1,7 +1,7 @@
 #define I2C_SDA 8 // I2C pins for this board
 #define I2C_SCL 9
 
-#define LED_POWER 7    // If defined we will blink this LED
+#define LED_PIN 7      // If defined we will blink this LED
 #define LED_STATE_ON 0 // State when LED is lit
 
 #define USE_SX1262

variants/esp32s2/nugget_s2_lora/variant.h

@@ -1,7 +1,7 @@
 #define I2C_SDA 34 // I2C pins for this board
 #define I2C_SCL 36
 
-#define LED_POWER 15 // If defined we will blink this LED
+#define LED_PIN 15 // If defined we will blink this LED
 
 #define HAS_NEOPIXEL                         // Enable the use of neopixels
 #define NEOPIXEL_COUNT 3                     // How many neopixels are connected

variants/esp32s3/CDEBYTE_EoRa-Hub/variant.h

@@ -1,7 +1,7 @@
 // EByte EoRA-Hub
 // Uses E80 (LR1121) LoRa module
 
-#define LED_POWER 35
+#define LED_PIN 35
 
 // Button - user interface
 #define BUTTON_PIN 0 // BOOT button

variants/esp32s3/CDEBYTE_EoRa-S3/variant.h

@@ -1,5 +1,5 @@
 // LED - status indication
-#define LED_POWER 37
+#define LED_PIN 37
 
 // Button - user interface
 #define BUTTON_PIN 0 // This is the BOOT button, and it has its own pull-up resistor

variants/esp32s3/EBYTE_ESP32-S3/variant.h

@@ -100,7 +100,7 @@
 */
 
 // Status
-#define LED_POWER 1
+#define LED_PIN 1
 #define LED_STATE_ON 1 // State when LED is lit
 // External notification
 // FIXME: Check if EXT_NOTIFY_OUT actualy has any effect and removes the need for setting the external notication pin in the

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

@@ -1,5 +1,5 @@
 // Status
-#define LED_POWER 1
+#define LED_PIN 1
 
 #define PIN_BUTTON1 47 // 功能键
 #define PIN_BUTTON2 4  // 电源键

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

@@ -8,11 +8,5 @@ void earlyInitVariant()
     Wire.begin(48, 47);
     io.pinMode(PCA_PIN_EINK_EN, OUTPUT);
     io.pinMode(PCA_PIN_POWER_EN, OUTPUT);
-    io.pinMode(PCA_LED_POWER, OUTPUT);
-    io.pinMode(PCA_LED_USER, OUTPUT);
-    io.pinMode(PCA_LED_ENABLE, OUTPUT);
-
     io.digitalWrite(PCA_PIN_POWER_EN, HIGH);
-    io.digitalWrite(PCA_LED_USER, LOW);
-    io.digitalWrite(PCA_LED_ENABLE, LOW);
 }

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

@@ -8,10 +8,8 @@
 
 // LED
 // Both of these are on the GPIO expander
-#define PCA_LED_USER 1   // the Blue LED
-#define PCA_LED_ENABLE 2 // the power supply to the LEDs, in an OR arrangement with VBUS power
-#define PCA_LED_POWER 3  // the Red LED? Seems to have hardware logic to blink when USB is plugged in.
-#define POWER_LED_HARDWARE_BLINKS_WHILE_CHARGING
+#define PCA_LED_USER 1  // the Blue LED
+#define PCA_LED_POWER 3 // the Red LED? Seems to have hardware logic to blink when USB is plugged in.
 
 // USB_CHECK
 #define EXT_PWR_DETECT 12

variants/esp32s3/bpi_picow_esp32_s3/variant.h

@@ -11,7 +11,7 @@
 #define I2C_SDA 12
 #define I2C_SCL 14
 
-#define LED_POWER 46
+#define LED_PIN 46
 #define LED_STATE_ON 0 // State when LED is litted
 
 // #define BUTTON_PIN 15 // Pico OLED 1.3 User key 0 - removed User key 1 (17)

variants/esp32s3/crowpanel-esp32s3-5-epaper/variant.h

@@ -26,7 +26,7 @@
 // #define GPS_RX_PIN 44
 // #define GPS_TX_PIN 43
 
-#define LED_POWER 41
+#define LED_PIN 41
 #define BUTTON_PIN 2
 #define BUTTON_NEED_PULLUP
 

variants/esp32s3/diy/my_esp32s3_diy_eink/variant.h

@@ -11,7 +11,7 @@
 #define I2C_SDA 18 // 1 // I2C pins for this board
 #define I2C_SCL 17 // 2
 
-// #define LED_POWER 38     // This is a RGB LED not a standard LED
+// #define LED_PIN 38     // This is a RGB LED not a standard LED
 #define HAS_NEOPIXEL                         // Enable the use of neopixels
 #define NEOPIXEL_COUNT 1                     // How many neopixels are connected
 #define NEOPIXEL_DATA 38                     // gpio pin used to send data to the neopixels

variants/esp32s3/diy/my_esp32s3_diy_oled/variant.h

@@ -11,7 +11,7 @@
 #define I2C_SDA 18 // 1 // I2C pins for this board
 #define I2C_SCL 17 // 2
 
-// #define LED_POWER 38     // This is a RGB LED not a standard LED
+// #define LED_PIN 38     // This is a RGB LED not a standard LED
 #define HAS_NEOPIXEL                         // Enable the use of neopixels
 #define NEOPIXEL_COUNT 1                     // How many neopixels are connected
 #define NEOPIXEL_DATA 38                     // gpio pin used to send data to the neopixels

variants/esp32s3/dreamcatcher/variant.h

@@ -6,7 +6,7 @@
 #define I2C_SDA1 45
 #define I2C_SCL1 46
 
-#define LED_POWER 6
+#define LED_PIN 6
 #define LED_STATE_ON 1
 #define BUTTON_PIN 0
 

variants/esp32s3/heltec_capsule_sensor_v3/variant.h

@@ -1,5 +1,5 @@
-#define LED_POWER 33
-#define LED_POWER2 34
+#define LED_PIN 33
+#define LED_PIN2 34
 #define EXT_PWR_DETECT 35
 
 #define BUTTON_PIN 18

variants/esp32s3/heltec_v3/variant.h

@@ -1,4 +1,4 @@
-#define LED_POWER LED
+#define LED_PIN LED
 
 #define USE_SSD1306 // Heltec_v3 has a SSD1306 display
 

variants/esp32s3/heltec_v4/platformio.ini

@@ -26,7 +26,7 @@ build_flags =
   ${heltec_v4_base.build_flags}
   -D HELTEC_V4_OLED
   -D USE_SSD1306 ; Heltec_v4 has an SSD1315 display (compatible with SSD1306 driver)
-  -D LED_POWER=35
+  -D LED_PIN=35
   -D RESET_OLED=21
   -D I2C_SDA=17
   -D I2C_SCL=18

variants/esp32s3/heltec_vision_master_e213/variant.h

@@ -1,4 +1,4 @@
-#define LED_POWER 45 // LED is not populated on earliest board variant
+#define LED_PIN 45 // LED is not populated on earliest board variant
 #define BUTTON_PIN 0
 #define PIN_BUTTON2 21             // Second built-in button
 #define ALT_BUTTON_PIN PIN_BUTTON2 // Send the up event

variants/esp32s3/heltec_vision_master_e290/variant.h

@@ -1,4 +1,4 @@
-#define LED_POWER 45 // LED is not populated on earliest board variant
+#define LED_PIN 45 // LED is not populated on earliest board variant
 #define BUTTON_PIN 0
 #define PIN_BUTTON2 21             // Second built-in button
 #define ALT_BUTTON_PIN PIN_BUTTON2 // Send the up event

variants/esp32s3/heltec_wireless_paper/variant.h

@@ -1,4 +1,4 @@
-#define LED_POWER 18
+#define LED_PIN 18
 #define BUTTON_PIN 0
 
 // I2C

variants/esp32s3/heltec_wireless_paper_v1/variant.h

@@ -1,4 +1,4 @@
-#define LED_POWER 18
+#define LED_PIN 18
 #define BUTTON_PIN 0
 
 // I2C

variants/esp32s3/heltec_wireless_tracker/variant.h

@@ -1,4 +1,4 @@
-#define LED_POWER 18
+#define LED_PIN 18
 
 #define _VARIANT_HELTEC_WIRELESS_TRACKER
 #define HELTEC_TRACKER_V1_X

variants/esp32s3/heltec_wireless_tracker_V1_0/variant.h

@@ -1,4 +1,4 @@
-#define LED_POWER 18
+#define LED_PIN 18
 
 #define HELTEC_TRACKER_V1_X
 

variants/esp32s3/heltec_wireless_tracker_v2/variant.h

@@ -1,4 +1,4 @@
-#define LED_POWER 18
+#define LED_PIN 18
 
 #define _VARIANT_HELTEC_WIRELESS_TRACKER
 

variants/esp32s3/heltec_wsl_v3/variant.h

@@ -1,7 +1,7 @@
 #define I2C_SCL SCL
 #define I2C_SDA SDA
 
-#define LED_POWER LED
+#define LED_PIN LED
 
 #define VEXT_ENABLE Vext // active low, powers the oled display and the lora antenna boost
 #define VEXT_ON_VALUE LOW

variants/esp32s3/mesh-tab/variant.h

@@ -13,7 +13,7 @@
 #define ADC_CHANNEL ADC1_GPIO4_CHANNEL
 
 // LED
-#define LED_POWER 21
+#define LED_PIN 21
 
 // Button
 #define BUTTON_PIN 0

variants/esp32s3/nibble_esp32/variant.h

@@ -1,7 +1,7 @@
 #define I2C_SDA 11 // I2C pins for this board
 #define I2C_SCL 10
 
-#define LED_POWER 1 // If defined we will blink this LED
+#define LED_PIN 1 // If defined we will blink this LED
 
 #define BUTTON_PIN 0 // If defined, this will be used for user button presses
 #define BUTTON_NEED_PULLUP

variants/esp32s3/nugget_s3_lora/variant.h

@@ -4,7 +4,7 @@
 #define USE_SSD1306
 #define DISPLAY_FLIP_SCREEN
 
-#define LED_POWER 15 // If defined we will blink this LED
+#define LED_PIN 15 // If defined we will blink this LED
 
 #define HAS_NEOPIXEL                         // Enable the use of neopixels
 #define NEOPIXEL_COUNT 3                     // How many neopixels are connected

variants/esp32s3/rak3312/variant.h

@@ -24,7 +24,7 @@
 #define PIN_LED1 LED_GREEN
 #define LED_NOTIFICATION LED_BLUE
 
-#define LED_POWER LED_GREEN
+#define LED_PIN LED_GREEN
 #define ledOff(pin) pinMode(pin, INPUT)
 
 #define LED_STATE_ON 1 // State when LED is litted

variants/esp32s3/rak_wismesh_tap_v2/variant.h

@@ -32,7 +32,7 @@
 #define PIN_LED1 LED_GREEN
 #define LED_NOTIFICATION LED_BLUE
 
-#define LED_POWER LED_GREEN
+#define LED_PIN LED_GREEN
 #define ledOff(pin) pinMode(pin, INPUT)
 
 #define LED_STATE_ON 1 // State when LED is litted

variants/esp32s3/seeed_xiao_s3/variant.h

@@ -30,7 +30,7 @@ Expansion Board Infomation : https://www.seeedstudio.com/Seeeduino-XIAO-Expansio
 L76K GPS Module Information : https://www.seeedstudio.com/L76K-GNSS-Module-for-Seeed-Studio-XIAO-p-5864.html
 */
 
-#define LED_POWER 48
+#define LED_PIN 48
 #define LED_STATE_ON 1 // State when LED is lit
 
 #define BUTTON_PIN 21 // This is the Program Button

variants/esp32s3/t-beam-1w/variant.h

@@ -67,7 +67,7 @@
 #endif
 
 // LED
-#define LED_POWER 18
+#define LED_PIN 18
 #define LED_STATE_ON 1 // HIGH = ON
 
 // Battery ADC

variants/esp32s3/t-eth-elite/variant.h

@@ -12,7 +12,7 @@
 
 #define HAS_SCREEN 1 // Allow for OLED Screens on I2C Header of shield
 
-#define LED_POWER 38 // If defined we will blink this LED
+#define LED_PIN 38   // If defined we will blink this LED
 #define BUTTON_PIN 0 // If defined, this will be used for user button presses,
 
 #define BUTTON_NEED_PULLUP

variants/esp32s3/tlora_t3s3_epaper/variant.h

@@ -22,7 +22,7 @@
 #define GPS_RX_PIN 44
 #define GPS_TX_PIN 43
 
-#define LED_POWER 37
+#define LED_PIN 37
 #define BUTTON_PIN 0
 #define BUTTON_NEED_PULLUP
 

variants/esp32s3/tlora_t3s3_v1/variant.h

@@ -14,7 +14,7 @@
 #define I2C_SDA1 43
 #define I2C_SCL1 44
 
-#define LED_POWER 37 // If defined we will blink this LED
+#define LED_PIN 37   // If defined we will blink this LED
 #define BUTTON_PIN 0 // If defined, this will be used for user button presses,
 
 #define BUTTON_NEED_PULLUP

variants/esp32s3/tracksenger/internal/variant.h

@@ -1,4 +1,4 @@
-#define LED_POWER 18
+#define LED_PIN 18
 
 #define HELTEC_TRACKER_V1_X
 

variants/esp32s3/tracksenger/lcd/variant.h

@@ -1,4 +1,4 @@
-#define LED_POWER 18
+#define LED_PIN 18
 
 #define HELTEC_TRACKER_V1_X