Added adaptive coding rate support and unit tests

* Add LilyGO T-Beam 1W support
- Add board definition and variant files for ESP32-S3 based T-Beam 1W
- Add RF95_FAN_EN support to SX126xInterface for PA cooling fan
- Add SX126X_PA_RAMP_US for configurable PA ramp time (800us for 1W PA)
- Configure RF switch: DIO2 for PA, GPIO 21 for LNA control

* Set TX_GAIN_LORA to 10dB per PR feedback (offset for 1W PA)

* Apply suggestion from @Copilot

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

---------

Co-authored-by: Ben Meadors <benmmeadors@gmail.com>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

.github/workflows/first_time_contributor.yml

@@ -0,0 +1,47 @@
+name: Welcome First-Time Contributor
+
+on:
+  issues:
+    types: opened
+  pull_request_target:
+    types: opened
+
+permissions: {}
+
+jobs:
+  welcome:
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write # Required to post comments and labels on issues
+      pull-requests: write # Required to post comments and labels on PRs
+    steps:
+      - uses: plbstl/first-contribution@v4
+        with:
+          labels: first-contribution
+          issue-opened-msg: |
+            ### @{fc-author}, Welcome to Meshtastic! :wave:
+
+            Thanks for opening your first issue. If it's helpful, an easy way
+            to get logs is the "Open Serial Monitor" button on the [Web Flasher](https://flasher.meshtastic.org).
+
+            If you have ideas for features, note that we often debate big ideas
+            in the [discussions tab](https://github.com/meshtastic/firmware/discussions/categories/ideas)
+            first. This tracker tends to be for ideas that have community
+            consensus and a clear implementation.
+
+            We're very active [on discord](https://discord.com/invite/meshtastic),
+            especially the \#firmware and \#alphanauts-testing channels. If you'll
+            be around for a while, we'd love to see you there!
+
+            Welcome to the community! :heart:
+
+          pr-opened-msg: |
+            ### @{fc-author}, Welcome to Meshtastic!
+
+            Thanks for opening your first pull request. We really appreciate it.
+
+            We discuss work as a team in discord, please join us in the [#firmware channel](https://discord.com/invite/meshtastic).
+            There's a big backlog of patches at the moment. If you have time,
+            please help us with some code review and testing of [other PRs](https://github.com/meshtastic/firmware/pulls)!
+
+            Welcome to the team :smile:

.github/workflows/main_matrix.yml

@@ -8,7 +8,9 @@ on:
     branches:
       - master
       - develop
+      - pioarduino # Remove when merged // use `feature/` in the future.
       - event/*
+      - feature/*
     paths-ignore:
       - "**.md"
       - version.properties
@@ -18,7 +20,9 @@ on:
     branches:
       - master
       - develop
+      - pioarduino # Remove when merged // use `feature/` in the future.
       - event/*
+      - feature/*
     paths-ignore:
       - "**.md"
       #- "**.yml"
@@ -240,6 +244,7 @@ jobs:
     needs: [build]
     steps:
       - uses: actions/checkout@v6
+        if: github.event_name == 'pull_request_target'
         with:
           filter: blob:none # means we download all the git history but none of the commit (except ones with checkout like the head)
           fetch-depth: 0
@@ -253,19 +258,26 @@ jobs:
         uses: actions/upload-artifact@v6
         id: upload-manifest
         with:
-          name: manifests-all
+          name: manifests-${{ github.sha }}
           overwrite: true
-          path: |
-            manifests-new/*.mt.json
+          path: manifests-new/*.mt.json
       - name: Find the merge base
+        if: github.event_name == 'pull_request_target'
         run: echo "MERGE_BASE=$(git merge-base "origin/$base" "$head")" >> $GITHUB_ENV
         env:
           base: ${{ github.base_ref }}
-          head: ${{ github.head_ref }}
-      - name: Download the old manifests
-        run: gh run download -R ${{ github.repository }} --commit ${{ env.MERGE_BASE }} --name manifests-all --dir manifest-old/
-      - name: Do scan and post comment
-        run: python3 bin/shame.py ${{ github.event.pull_request.number }} manifests-old/ manifests-new/
+          head: ${{ github.sha }}
+      # Currently broken (for-loop through EVERY artifact -- rate limiting)
+      # - name: Download the old manifests
+      #   if: github.event_name == 'pull_request_target'
+      #   run: gh run download -R "$repo" --name "manifests-$merge_base" --dir manifest-old/
+      #   env:
+      #     GH_TOKEN: ${{ github.token }}
+      #     merge_base: ${{ env.MERGE_BASE }}
+      #     repo: ${{ github.repository }}
+      # - name: Do scan and post comment
+      #   if: github.event_name == 'pull_request_target'
+      #   run: python3 bin/shame.py ${{ github.event.pull_request.number }} manifests-old/ manifests-new/
 
   release-artifacts:
     runs-on: ubuntu-latest

.github/workflows/test_native.yml

@@ -143,7 +143,7 @@ jobs:
           merge-multiple: true
 
       - name: Test Report
-        uses: dorny/test-reporter@v2.3.0
+        uses: dorny/test-reporter@v2.4.0
         with:
           name: PlatformIO Tests
           path: testreport.xml

.gitignore

@@ -41,3 +41,12 @@ src/mesh/raspihttp/private_key.pem
 
 # Ignore logo (set at build time with platformio-custom.py)
 data/boot/logo.*
+
+# pioarduino platform
+managed_components/*
+arduino-lib-builder*
+dependencies.lock
+idf_component.yml
+CMakeLists.txt
+sdkconfig.*
+.dummy/*

.trunk/trunk.yaml

@@ -8,10 +8,10 @@ plugins:
       uri: https://github.com/trunk-io/plugins
 lint:
   enabled:
-    - checkov@3.2.495
-    - renovate@42.64.1
+    - checkov@3.2.496
+    - renovate@42.66.14
     - prettier@3.7.4
-    - trufflehog@3.92.3
+    - trufflehog@3.92.4
     - yamllint@1.37.1
     - bandit@1.9.2
     - trivy@0.68.2

Dockerfile.test

@@ -0,0 +1,43 @@
+# Minimal container to run PlatformIO native/portduino tests
+FROM ubuntu:22.04
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends \
+        python3 \
+        python3-pip \
+        git \
+        build-essential \
+        cmake \
+        pkg-config \
+        libssl-dev \
+        libncurses5 \
+        libsdl2-dev \
+        libx11-dev \
+        libxext-dev \
+        libusb-1.0-0-dev \
+        libyaml-cpp-dev \
+        libuv1-dev \
+        libgpiod-dev \
+        libbluetooth-dev \
+        libulfius-dev \
+        liborcania-dev \
+        libmicrohttpd-dev \
+        libjansson-dev \
+        libgnutls28-dev \
+        libcurl4-gnutls-dev \
+        libi2c-dev \
+        openssl \
+        lsb-release \
+        cppcheck \
+        uuid-dev \
+        zlib1g-dev \
+        libbsd-dev \
+        gdb \
+    && pip3 install --no-cache-dir platformio \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /workspace
+
+CMD ["bash"]

SECURITY.md

@@ -4,8 +4,8 @@
 
 | Firmware Version | Supported          |
 | ---------------- | ------------------ |
-| 2.6.x            | :white_check_mark: |
-| <= 2.5.x         | :x:                |
+| 2.7.x            | :white_check_mark: |
+| <= 2.6.x         | :x:                |
 
 ## Reporting a Vulnerability
 

bin/build-nrf52.sh

@@ -21,13 +21,14 @@ rm -f $BUILDDIR/firmware*
 export APP_VERSION=$VERSION
 
 basename=firmware-$1-$VERSION
+ota_basename=${basename}-ota
 
 pio run --environment $1 -t mtjson # -v
 
 cp $BUILDDIR/$basename.elf $OUTDIR/$basename.elf
 
 echo "Copying NRF52 dfu (OTA) file"
-cp $BUILDDIR/$basename.zip $OUTDIR/$basename.zip
+cp $BUILDDIR/$basename.zip $OUTDIR/$ota_basename.zip
 
 echo "Copying NRF52 UF2 file"
 cp $BUILDDIR/$basename.uf2 $OUTDIR/$basename.uf2

bin/org.meshtastic.meshtasticd.metainfo.xml

@@ -87,7 +87,7 @@
   </screenshots>
 
   <releases>
-    <release version="2.7.18" date="2025-12-20">
+    <release version="2.7.18" date="2026-01-02">
       <url type="details">https://github.com/meshtastic/firmware/releases?q=tag%3Av2.7.18</url>
     </release>
     <release version="2.7.17" date="2025-11-28">

bin/platformio-custom.py

@@ -17,6 +17,8 @@ lfsbin = f"{progname.replace('firmware-', 'littlefs-')}.bin"
 
 def manifest_gather(source, target, env):
     out = []
+    board_platform = env.BoardConfig().get("platform")
+    needs_ota_suffix = board_platform == "nordicnrf52"
     check_paths = [
         progname,
         f"{progname}.elf",
@@ -32,8 +34,11 @@ def manifest_gather(source, target, env):
     for p in check_paths:
         f = env.File(env.subst(f"$BUILD_DIR/{p}"))
         if f.exists():
+            manifest_name = p
+            if needs_ota_suffix and p == f"{progname}.zip":
+                manifest_name = f"{progname}-ota.zip"
             d = {
-                "name": p,
+                "name": manifest_name,
                 "md5": f.get_content_hash(), # Returns MD5 hash
                 "bytes": f.get_size() # Returns file size in bytes
             }

boards/t-beam-1w.json

@@ -0,0 +1,50 @@
+{
+    "build": {
+        "arduino": {
+            "ldscript": "esp32s3_out.ld",
+            "memory_type": "qio_opi"
+        },
+        "core": "esp32",
+        "extra_flags": [
+            "-DBOARD_HAS_PSRAM",
+            "-DLILYGO_TBEAM_1W",
+            "-DARDUINO_USB_CDC_ON_BOOT=1",
+            "-DARDUINO_USB_MODE=0",
+            "-DARDUINO_RUNNING_CORE=1",
+            "-DARDUINO_EVENT_RUNNING_CORE=1"
+        ],
+        "f_cpu": "240000000L",
+        "f_flash": "80000000L",
+        "flash_mode": "qio",
+        "psram_type": "opi",
+        "hwids": [
+            [
+                "0x303A",
+                "0x1001"
+            ]
+        ],
+        "mcu": "esp32s3",
+        "variant": "t-beam-1w"
+    },
+    "connectivity": [
+        "wifi",
+        "bluetooth",
+        "lora"
+    ],
+    "debug": {
+        "openocd_target": "esp32s3.cfg"
+    },
+    "frameworks": [
+        "arduino"
+    ],
+    "name": "LilyGo TBeam-1W",
+    "upload": {
+        "flash_size": "16MB",
+        "maximum_ram_size": 327680,
+        "maximum_size": 16777216,
+        "require_upload_port": true,
+        "speed": 921600
+    },
+    "url": "http://www.lilygo.cn/",
+    "vendor": "LilyGo"
+}

debian/changelog

@@ -2,7 +2,7 @@ meshtasticd (2.7.18.0) unstable; urgency=medium
 
   * Version 2.7.18
 
- -- GitHub Actions <github-actions[bot]@users.noreply.github.com>  Sat, 20 Dec 2025 15:47:25 +0000
+ -- GitHub Actions <github-actions[bot]@users.noreply.github.com>  Fri, 02 Jan 2026 12:45:36 +0000
 
 meshtasticd (2.7.17.0) unstable; urgency=medium
 

platformio.ini

@@ -64,7 +64,7 @@ monitor_speed = 115200
 monitor_filters = direct
 lib_deps =
 	# renovate: datasource=git-refs depName=meshtastic-esp8266-oled-ssd1306 packageName=https://github.com/meshtastic/esp8266-oled-ssd1306 gitBranch=master
-	https://github.com/meshtastic/esp8266-oled-ssd1306/archive/2887bf4a19f64d92c984dcc8fd5ca7429e425e4a.zip
+	https://github.com/meshtastic/esp8266-oled-ssd1306/archive/b34c6817c25d6faabb3a8a162b5d14fb75395433.zip
 	# renovate: datasource=git-refs depName=meshtastic-OneButton packageName=https://github.com/meshtastic/OneButton gitBranch=master
 	https://github.com/meshtastic/OneButton/archive/fa352d668c53f290cfa480a5f79ad422cd828c70.zip
 	# renovate: datasource=git-refs depName=meshtastic-arduino-fsm packageName=https://github.com/meshtastic/arduino-fsm gitBranch=master
@@ -94,7 +94,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/862ed040c4ab44f0dfbbe492691f144886102588.zip
+	https://github.com/meshtastic/device-ui/archive/a8e2f947f7abaf0c5ac8e6dd189a22156335beaa.zip
 
 ; Common libs for environmental measurements in telemetry module
 [environmental_base]

src/buzz/BuzzerFeedbackThread.cpp

@@ -24,6 +24,9 @@ int BuzzerFeedbackThread::handleInputEvent(const InputEvent *event)
     switch (event->inputEvent) {
     case INPUT_BROKER_USER_PRESS:
     case INPUT_BROKER_ALT_PRESS:
+        playClick(); // Low delay feedback
+        break;
+
     case INPUT_BROKER_SELECT:
     case INPUT_BROKER_SELECT_LONG:
         playBeep(); // Confirmation feedback
@@ -58,4 +61,4 @@ int BuzzerFeedbackThread::handleInputEvent(const InputEvent *event)
     }
 
     return 0; // Allow other handlers to process the event
-}
+}

src/buzz/buzz.cpp

@@ -113,7 +113,14 @@ void playShutdownMelody()
 void playChirp()
 {
     // A short, friendly "chirp" sound for key presses
-    ToneDuration melody[] = {{NOTE_AS3, 20}}; // Very short AS3 note
+    ToneDuration melody[] = {{NOTE_AS3, 20}}; // Short AS3 note
+    playTones(melody, sizeof(melody) / sizeof(ToneDuration));
+}
+
+void playClick()
+{
+    // A very short "click" sound with minimum delay; ideal for rotary encoder events
+    ToneDuration melody[] = {{NOTE_AS3, 1}}; // Very Short AS3
     playTones(melody, sizeof(melody) / sizeof(ToneDuration));
 }
 

src/buzz/buzz.h

@@ -9,6 +9,7 @@ void playGPSDisableBeep();
 void playComboTune();
 void playBoop();
 void playChirp();
+void playClick();
 void playLongPressLeadUp();
 bool playNextLeadUpNote();  // Play the next note in the lead-up sequence
 void resetLeadUpSequence(); // Reset the lead-up sequence to start from beginning

src/configuration.h

@@ -444,6 +444,18 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #endif
 #endif
 
+// BME680 BSEC2 support detection
+#if !defined(MESHTASTIC_BME680_BSEC2_SUPPORTED)
+#if defined(RAK_4631) || defined(TBEAM_V10)
+
+#define MESHTASTIC_BME680_BSEC2_SUPPORTED 1
+#define MESHTASTIC_BME680_HEADER <bsec2.h>
+#else
+#define MESHTASTIC_BME680_BSEC2_SUPPORTED 0
+#define MESHTASTIC_BME680_HEADER <Adafruit_BME680.h>
+#endif // defined(RAK_4631)
+#endif // !defined(MESHTASTIC_BME680_BSEC2_SUPPORTED)
+
 // -----------------------------------------------------------------------------
 // Global switches to turn off features for a minimized build
 // -----------------------------------------------------------------------------

src/graphics/SharedUIDisplay.cpp

@@ -8,6 +8,7 @@
 #include "graphics/draw/UIRenderer.h"
 #include "main.h"
 #include "meshtastic/config.pb.h"
+#include "modules/ExternalNotificationModule.h"
 #include "power.h"
 #include <OLEDDisplay.h>
 #include <graphics/images.h>
@@ -56,7 +57,6 @@ void decomposeTime(uint32_t rtc_sec, int &hour, int &minute, int &second)
 
 // === Shared External State ===
 bool hasUnreadMessage = false;
-bool isMuted = false;
 ScreenResolution currentResolution = ScreenResolution::Low;
 
 // === Internal State ===
@@ -306,7 +306,7 @@ void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const char *ti
                 }
                 display->drawXbm(iconX, iconY, mail_width, mail_height, mail);
             }
-        } else if (isMuted) {
+        } else if (externalNotificationModule->getMute()) {
             if (currentResolution == ScreenResolution::High) {
                 int iconX = iconRightEdge - mute_symbol_big_width;
                 int iconY = textY + (FONT_HEIGHT_SMALL - mute_symbol_big_height) / 2;
@@ -325,7 +325,7 @@ void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const char *ti
                 int iconX = iconRightEdge - mute_symbol_width;
                 int iconY = textY + (FONT_HEIGHT_SMALL - mail_height) / 2;
 
-                if (isInverted) {
+                if (isInverted && !force_no_invert) {
                     display->setColor(WHITE);
                     display->fillRect(iconX - 1, iconY - 1, mute_symbol_width + 2, mute_symbol_height + 2);
                     display->setColor(BLACK);
@@ -383,7 +383,7 @@ void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const char *ti
                 int iconY = textY + (FONT_HEIGHT_SMALL - mail_height) / 2;
                 display->drawXbm(iconX, iconY, mail_width, mail_height, mail);
             }
-        } else if (isMuted) {
+        } else if (externalNotificationModule->getMute()) {
             if (currentResolution == ScreenResolution::High) {
                 int iconX = iconRightEdge - mute_symbol_big_width;
                 int iconY = textY + (FONT_HEIGHT_SMALL - mute_symbol_big_height) / 2;
@@ -470,18 +470,49 @@ bool isAllowedPunctuation(char c)
     return allowed.find(c) != std::string::npos;
 }
 
+static void replaceAll(std::string &s, const std::string &from, const std::string &to)
+{
+    if (from.empty())
+        return;
+    size_t pos = 0;
+    while ((pos = s.find(from, pos)) != std::string::npos) {
+        s.replace(pos, from.size(), to);
+        pos += to.size();
+    }
+}
+
 std::string sanitizeString(const std::string &input)
 {
     std::string output;
     bool inReplacement = false;
 
-    for (char c : input) {
-        if (std::isalnum(static_cast<unsigned char>(c)) || isAllowedPunctuation(c)) {
+    // Make a mutable copy so we can normalize UTF-8 “smart punctuation” into ASCII first.
+    std::string s = input;
+
+    // Curly single quotes: ‘ ’
+    replaceAll(s, "\xE2\x80\x98", "'"); // U+2018
+    replaceAll(s, "\xE2\x80\x99", "'"); // U+2019
+
+    // Curly double quotes: “ ”
+    replaceAll(s, "\xE2\x80\x9C", "\""); // U+201C
+    replaceAll(s, "\xE2\x80\x9D", "\""); // U+201D
+
+    // En dash / Em dash: – —
+    replaceAll(s, "\xE2\x80\x93", "-"); // U+2013
+    replaceAll(s, "\xE2\x80\x94", "-"); // U+2014
+
+    // Non-breaking space
+    replaceAll(s, "\xC2\xA0", " "); // U+00A0
+
+    // Now do your original sanitize pass over the normalized string.
+    for (unsigned char uc : s) {
+        char c = static_cast<char>(uc);
+        if (std::isalnum(uc) || isAllowedPunctuation(c)) {
             output += c;
             inReplacement = false;
         } else {
             if (!inReplacement) {
-                output += 0xbf; // ISO-8859-1 for inverted question mark
+                output += static_cast<char>(0xBF); // ISO-8859-1 for inverted question mark
                 inReplacement = true;
             }
         }

src/graphics/SharedUIDisplay.h

@@ -41,7 +41,6 @@ namespace graphics
 
 // Shared state (declare inside namespace)
 extern bool hasUnreadMessage;
-extern bool isMuted;
 enum class ScreenResolution : uint8_t { UltraLow = 0, Low = 1, High = 2 };
 extern ScreenResolution currentResolution;
 ScreenResolution determineScreenResolution(int16_t screenheight, int16_t screenwidth);

src/graphics/draw/MenuHandler.h

@@ -22,6 +22,9 @@ class menuHandler
         node_base_menu,
         gps_toggle_menu,
         gps_format_menu,
+        gps_smart_position_menu,
+        gps_update_interval_menu,
+        gps_position_broadcast_menu,
         compass_point_north_menu,
         reset_node_db_menu,
         buzzermodemenupicker,
@@ -36,7 +39,6 @@ class menuHandler
         number_test,
         wifi_toggle_menu,
         bluetooth_toggle_menu,
-        notifications_menu,
         screen_options_menu,
         power_menu,
         system_base_menu,
@@ -77,6 +79,9 @@ class menuHandler
     static void compassNorthMenu();
     static void GPSToggleMenu();
     static void GPSFormatMenu();
+    static void GPSSmartPositionMenu();
+    static void GPSUpdateIntervalMenu();
+    static void GPSPositionBroadcastMenu();
     static void BuzzerModeMenu();
     static void switchToMUIMenu();
     static void TFTColorPickerMenu(OLEDDisplay *display);
@@ -92,7 +97,6 @@ class menuHandler
     static void numberTest();
     static void wifiBaseMenu();
     static void wifiToggleMenu();
-    static void notificationsMenu();
     static void screenOptionsMenu();
     static void powerMenu();
     static void nodeNameLengthMenu();
@@ -124,7 +128,28 @@ template <typename T> struct MenuOption {
     MenuOption(const char *labelIn, OptionsAction actionIn) : label(labelIn), action(actionIn), hasValue(false), value() {}
 };
 
+struct ScreenColor {
+    uint8_t r;
+    uint8_t g;
+    uint8_t b;
+    bool useVariant;
+
+    ScreenColor(uint8_t rIn = 0, uint8_t gIn = 0, uint8_t bIn = 0, bool variantIn = false)
+        : r(rIn), g(gIn), b(bIn), useVariant(variantIn)
+    {
+    }
+};
+
 using RadioPresetOption = MenuOption<meshtastic_Config_LoRaConfig_ModemPreset>;
+using LoraRegionOption = MenuOption<meshtastic_Config_LoRaConfig_RegionCode>;
+using TimezoneOption = MenuOption<const char *>;
+using CompassOption = MenuOption<meshtastic_CompassMode>;
+using ScreenColorOption = MenuOption<ScreenColor>;
+using GPSToggleOption = MenuOption<meshtastic_Config_PositionConfig_GpsMode>;
+using GPSFormatOption = MenuOption<meshtastic_DeviceUIConfig_GpsCoordinateFormat>;
+using NodeNameOption = MenuOption<bool>;
+using PositionMenuOption = MenuOption<int>;
+using ClockFaceOption = MenuOption<bool>;
 
 } // namespace graphics
 #endif

src/graphics/niche/InkHUD/Applets/User/Positions/PositionsApplet.cpp

@@ -1,6 +1,7 @@
 #ifdef MESHTASTIC_INCLUDE_INKHUD
 
 #include "./PositionsApplet.h"
+#include "NodeDB.h"
 
 using namespace NicheGraphics;
 
@@ -49,8 +50,8 @@ ProcessMessage InkHUD::PositionsApplet::handleReceived(const meshtastic_MeshPack
     if (!hasPosition)
         return ProcessMessage::CONTINUE;
 
-    bool hasHopsAway = (mp.hop_start != 0 && mp.hop_limit <= mp.hop_start); // From NodeDB::updateFrom
-    uint8_t hopsAway = mp.hop_start - mp.hop_limit;
+    const int8_t hopsAway = getHopsAway(mp);
+    const bool hasHopsAway = hopsAway >= 0;
 
     // Determine if the position packet would change anything on-screen
     // -----------------------------------------------------------------

src/input/RotaryEncoderInterruptImpl1.cpp

@@ -27,7 +27,9 @@ bool RotaryEncoderInterruptImpl1::init()
                                      RotaryEncoderInterruptImpl1::handleIntA, RotaryEncoderInterruptImpl1::handleIntB,
                                      RotaryEncoderInterruptImpl1::handleIntPressed);
     inputBroker->registerSource(this);
+#ifndef HAS_PHYSICAL_KEYBOARD
     osk_found = true;
+#endif
     return true;
 }
 

src/input/TrackballInterruptBase.cpp

@@ -45,7 +45,9 @@ void TrackballInterruptBase::init(uint8_t pinDown, uint8_t pinUp, uint8_t pinLef
 
     LOG_DEBUG("Trackball GPIO initialized - UP:%d DOWN:%d LEFT:%d RIGHT:%d PRESS:%d", this->_pinUp, this->_pinDown,
               this->_pinLeft, this->_pinRight, pinPress);
+#ifndef HAS_PHYSICAL_KEYBOARD
     osk_found = true;
+#endif
     this->setInterval(100);
 }
 

src/input/UpDownInterruptImpl1.cpp

@@ -29,7 +29,9 @@ bool UpDownInterruptImpl1::init()
                               eventDownLong, UpDownInterruptImpl1::handleIntDown, UpDownInterruptImpl1::handleIntUp,
                               UpDownInterruptImpl1::handleIntPressed);
     inputBroker->registerSource(this);
+#ifndef HAS_PHYSICAL_KEYBOARD
     osk_found = true;
+#endif
     return true;
 }
 

src/main.cpp

@@ -1186,11 +1186,6 @@ void setup()
 #endif
 #endif
 
-#ifdef PIN_PWR_DELAY_MS
-    // This may be required to give the peripherals time to power up.
-    delay(PIN_PWR_DELAY_MS);
-#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,
@@ -1465,8 +1460,10 @@ void setup()
 #endif
 
 #if defined(HAS_TRACKBALL) || (defined(INPUTDRIVER_ENCODER_TYPE) && INPUTDRIVER_ENCODER_TYPE == 2)
+#ifndef HAS_PHYSICAL_KEYBOARD
     osk_found = true;
 #endif
+#endif
 
 #if defined(ARCH_ESP32) && !MESHTASTIC_EXCLUDE_WEBSERVER
     // Start web server thread.

src/mesh/MeshModule.cpp

@@ -195,7 +195,7 @@ void MeshModule::callModules(meshtastic_MeshPacket &mp, RxSource src)
             // but opted NOT TO.  Because it is not a good idea to let remote nodes 'probe' to find out which PSKs were "good" vs
             // bad.
             routingModule->sendAckNak(meshtastic_Routing_Error_NO_RESPONSE, getFrom(&mp), mp.id, mp.channel,
-                                      routingModule->getHopLimitForResponse(mp.hop_start, mp.hop_limit));
+                                      routingModule->getHopLimitForResponse(mp));
         }
     }
 
@@ -235,7 +235,7 @@ void setReplyTo(meshtastic_MeshPacket *p, const meshtastic_MeshPacket &to)
     assert(p->which_payload_variant == meshtastic_MeshPacket_decoded_tag); // Should already be set by now
     p->to = getFrom(&to);    // Make sure that if we are sending to the local node, we use our local node addr, not 0
     p->channel = to.channel; // Use the same channel that the request came in on
-    p->hop_limit = routingModule->getHopLimitForResponse(to.hop_start, to.hop_limit);
+    p->hop_limit = routingModule->getHopLimitForResponse(to);
 
     // No need for an ack if we are just delivering locally (it just generates an ignored ack)
     p->want_ack = (to.from != 0) ? to.want_ack : false;

src/mesh/MeshService.cpp

@@ -95,11 +95,8 @@ int MeshService::handleFromRadio(const meshtastic_MeshPacket *mp)
     } else if (mp->which_payload_variant == meshtastic_MeshPacket_decoded_tag && !nodeDB->getMeshNode(mp->from)->has_user &&
                nodeInfoModule && !isPreferredRebroadcaster && !nodeDB->isFull()) {
         if (airTime->isTxAllowedChannelUtil(true)) {
-            // Hops used by the request. If somebody in between running modified firmware modified it, ignore it
-            auto hopStart = mp->hop_start;
-            auto hopLimit = mp->hop_limit;
-            uint8_t hopsUsed = hopStart < hopLimit ? config.lora.hop_limit : hopStart - hopLimit;
-            if (hopsUsed > config.lora.hop_limit + 2) {
+            const int8_t hopsUsed = getHopsAway(*mp, config.lora.hop_limit);
+            if (hopsUsed > (int32_t)(config.lora.hop_limit + 2)) {
                 LOG_DEBUG("Skip send NodeInfo: %d hops away is too far away", hopsUsed);
             } else {
                 LOG_INFO("Heard new node on ch. %d, send NodeInfo and ask for response", mp->channel);
@@ -195,15 +192,13 @@ void MeshService::handleToRadio(meshtastic_MeshPacket &p)
 
     p.rx_time = getValidTime(RTCQualityFromNet); // Record the time the packet arrived from the phone
 
-#if HAS_SCREEN
-    if (screen && p.decoded.portnum == meshtastic_PortNum_TEXT_MESSAGE_APP && p.decoded.payload.size > 0 &&
-        p.to != NODENUM_BROADCAST && p.to != 0) // DM only
-    {
-        perhapsDecode(&p);
-        const StoredMessage &sm = messageStore.addFromPacket(p);
-        graphics::MessageRenderer::handleNewMessage(nullptr, sm, p); // notify UI
-    }
-#endif
+    IF_SCREEN(if (p.decoded.portnum == meshtastic_PortNum_TEXT_MESSAGE_APP && p.decoded.payload.size > 0 &&
+                  p.to != NODENUM_BROADCAST && p.to != 0) // DM only
+              {
+                  perhapsDecode(&p);
+                  const StoredMessage &sm = messageStore.addFromPacket(p);
+                  graphics::MessageRenderer::handleNewMessage(nullptr, sm, p); // notify UI
+              })
     // Send the packet into the mesh
     DEBUG_HEAP_BEFORE;
     auto a = packetPool.allocCopy(p);

src/mesh/NextHopRouter.cpp

@@ -64,7 +64,7 @@ bool NextHopRouter::shouldFilterReceived(const meshtastic_MeshPacket *p)
                 perhapsRebroadcast(p);
             }
         } else {
-            bool isRepeated = p->hop_start > 0 && p->hop_start == p->hop_limit;
+            bool isRepeated = getHopsAway(*p) == 0;
             // If repeated and not in Tx queue anymore, try relaying again, or if we are the destination, send the ACK again
             if (isRepeated) {
                 if (!findInTxQueue(p->from, p->id)) {
@@ -101,8 +101,7 @@ void NextHopRouter::sniffReceived(const meshtastic_MeshPacket *p, const meshtast
                 bool wasAlreadyRelayer = wasRelayer(p->relay_node, p->decoded.request_id, p->to);
                 bool weWereSoleRelayer = false;
                 bool weWereRelayer = wasRelayer(ourRelayID, p->decoded.request_id, p->to, &weWereSoleRelayer);
-                if ((weWereRelayer && wasAlreadyRelayer) ||
-                    (p->hop_start != 0 && p->hop_start == p->hop_limit && weWereSoleRelayer)) {
+                if ((weWereRelayer && wasAlreadyRelayer) || (getHopsAway(*p) == 0 && weWereSoleRelayer)) {
                     if (origTx->next_hop != p->relay_node) { // Not already set
                         LOG_INFO("Update next hop of 0x%x to 0x%x based on ACK/reply (was relayer %d we were sole %d)", p->from,
                                  p->relay_node, wasAlreadyRelayer, weWereSoleRelayer);
@@ -239,6 +238,12 @@ bool NextHopRouter::stopRetransmission(GlobalPacketId key)
         // call to startRetransmission.
         packetPool.release(p);
 
+#ifdef USE_ADAPTIVE_CODING_RATE
+        if (iface) {
+            iface->clearAdaptiveCodingRateState(getFrom(p), p->id);
+        }
+#endif
+
         return true;
     } else
         return false;

src/mesh/NodeDB.cpp

@@ -805,7 +805,8 @@ void NodeDB::installDefaultModuleConfig()
     moduleConfig.external_notification.output_ms = 500;
     moduleConfig.external_notification.nag_timeout = 2;
 #endif
-#if defined(RAK4630) || defined(RAK11310) || defined(RAK3312) || defined(MUZI_BASE) || defined(ELECROW_ThinkNode_M3)
+#if defined(RAK4630) || defined(RAK11310) || defined(RAK3312) || defined(MUZI_BASE) || defined(ELECROW_ThinkNode_M3) ||          \
+    defined(ELECROW_ThinkNode_M6)
     // Default to PIN_LED2 for external notification output (LED color depends on device variant)
     moduleConfig.external_notification.enabled = true;
     moduleConfig.external_notification.output = PIN_LED2;
@@ -1548,6 +1549,23 @@ uint32_t sinceReceived(const meshtastic_MeshPacket *p)
     return delta;
 }
 
+int8_t getHopsAway(const meshtastic_MeshPacket &p, int8_t defaultIfUnknown)
+{
+    // Firmware prior to 2.3.0 (585805c) lacked a hop_start field. Firmware version 2.5.0 (bf34329) introduced a
+    // bitfield that is always present. Use the presence of the bitfield to determine if the origin's firmware
+    // version is guaranteed to have hop_start populated. Note that this can only be done for decoded packets as
+    // the bitfield is encrypted under the channel encryption key. For encrypted packets, this returns
+    // defaultIfUnknown when hop_start is 0.
+    if (p.hop_start == 0 && !(p.which_payload_variant == meshtastic_MeshPacket_decoded_tag && p.decoded.has_bitfield))
+        return defaultIfUnknown; // Cannot reliably determine the number of hops.
+
+    // Guard against invalid values.
+    if (p.hop_start < p.hop_limit)
+        return defaultIfUnknown;
+
+    return p.hop_start - p.hop_limit;
+}
+
 #define NUM_ONLINE_SECS (60 * 60 * 2) // 2 hrs to consider someone offline
 
 size_t NodeDB::getNumOnlineMeshNodes(bool localOnly)
@@ -1800,9 +1818,10 @@ void NodeDB::updateFrom(const meshtastic_MeshPacket &mp)
         info->via_mqtt = mp.via_mqtt; // Store if we received this packet via MQTT
 
         // If hopStart was set and there wasn't someone messing with the limit in the middle, add hopsAway
-        if (mp.hop_start != 0 && mp.hop_limit <= mp.hop_start) {
+        const int8_t hopsAway = getHopsAway(mp);
+        if (hopsAway >= 0) {
             info->has_hops_away = true;
-            info->hops_away = mp.hop_start - mp.hop_limit;
+            info->hops_away = hopsAway;
         }
         sortMeshDB();
     }

src/mesh/NodeDB.h

@@ -110,6 +110,10 @@ uint32_t sinceLastSeen(const meshtastic_NodeInfoLite *n);
 /// Given a packet, return how many seconds in the past (vs now) it was received
 uint32_t sinceReceived(const meshtastic_MeshPacket *p);
 
+/// Given a packet, return the number of hops used to reach this node.
+/// Returns defaultIfUnknown if the number of hops couldn't be determined.
+int8_t getHopsAway(const meshtastic_MeshPacket &p, int8_t defaultIfUnknown = -1);
+
 enum LoadFileResult {
     // Successfully opened the file
     LOAD_SUCCESS = 1,

src/mesh/RadioInterface.cpp

@@ -171,7 +171,8 @@ const RegionInfo regions[] = {
                 863 - 868 MHz <25 mW EIRP, 500kHz channels allowed, must not be used at airfields
                                 https://github.com/meshtastic/firmware/issues/7204
     */
-    RDEF(KZ_433, 433.075f, 434.775f, 100, 0, 10, true, false, false), RDEF(KZ_863, 863.0f, 868.0f, 100, 0, 30, true, false, true),
+    RDEF(KZ_433, 433.075f, 434.775f, 100, 0, 10, true, false, false),
+    RDEF(KZ_863, 863.0f, 868.0f, 100, 0, 30, true, false, false),
 
     /*
         Nepal
@@ -323,9 +324,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;
 
@@ -519,6 +520,10 @@ void RadioInterface::applyModemConfig()
                 sf = 12;
                 break;
             }
+            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);
+            }
         } else {
             sf = loraConfig.spread_factor;
             cr = loraConfig.coding_rate;
@@ -613,6 +618,13 @@ void RadioInterface::applyModemConfig()
     slotTimeMsec = computeSlotTimeMsec();
     preambleTimeMsec = preambleLength * (pow_of_2(sf) / bw);
 
+#ifdef USE_ADAPTIVE_CODING_RATE
+    if (adaptiveCrOverride >= 5 && adaptiveCrOverride <= 8 && cr != adaptiveCrOverride) {
+        cr = adaptiveCrOverride;
+        LOG_DEBUG("Adaptive coding rate override set to %u", cr);
+    }
+#endif
+
     LOG_INFO("Radio freq=%.3f, config.lora.frequency_offset=%.3f", freq, loraConfig.frequency_offset);
     LOG_INFO("Set radio: region=%s, name=%s, config=%u, ch=%d, power=%d", myRegion->name, channelName, loraConfig.modem_preset,
              channel_num, power);
@@ -725,3 +737,70 @@ size_t RadioInterface::beginSending(meshtastic_MeshPacket *p)
     sendingPacket = p;
     return p->encrypted.size + sizeof(PacketHeader);
 }
+
+#ifdef USE_ADAPTIVE_CODING_RATE
+uint8_t RadioInterface::computeAdaptiveCodingRate(uint8_t attempt) const
+{
+    if (attempt <= 1) {
+        return 5; // Attempt 1: 4/5
+    }
+    if (attempt == 2) {
+        return 7; // Attempt 2: 4/7
+    }
+    return 8; // Attempt 3+: 4/8
+}
+
+uint64_t RadioInterface::adaptiveKey(NodeNum from, PacketId id) const
+{
+    return (static_cast<uint64_t>(from) << 32) | id;
+}
+
+void RadioInterface::pruneAdaptiveAttempts(uint32_t now)
+{
+    const uint32_t expiryMsec = 5 * 60 * 1000UL; // drop state after 5 minutes
+    for (auto it = adaptiveAttempts.begin(); it != adaptiveAttempts.end();) {
+        if (now - it->second.lastUseMsec > expiryMsec) {
+            it = adaptiveAttempts.erase(it);
+        } else {
+            ++it;
+        }
+    }
+}
+
+uint8_t RadioInterface::recordAdaptiveAttempt(const meshtastic_MeshPacket *p)
+{
+    const uint32_t now = millis();
+    pruneAdaptiveAttempts(now);
+
+    const uint64_t key = adaptiveKey(getFrom(p), p->id);
+    auto &state = adaptiveAttempts[key];
+    if (state.attempts < UINT8_MAX) {
+        state.attempts++;
+    }
+    state.lastUseMsec = now;
+    return state.attempts;
+}
+
+bool RadioInterface::applyAdaptiveCodingRate(const meshtastic_MeshPacket *p)
+{
+    const uint8_t attempt = recordAdaptiveAttempt(p);
+    const uint8_t desiredCr = computeAdaptiveCodingRate(attempt);
+    if (desiredCr < 5 || desiredCr > 8) {
+        return false;
+    }
+
+    adaptiveCrOverride = desiredCr;
+    if (cr != desiredCr) {
+        cr = desiredCr;
+        reconfigure();
+        return true;
+    }
+
+    return false;
+}
+
+void RadioInterface::clearAdaptiveCodingRateState(NodeNum from, PacketId id)
+{
+    adaptiveAttempts.erase(adaptiveKey(from, id));
+}
+#endif

src/mesh/RadioInterface.h

@@ -6,6 +6,9 @@
 #include "PointerQueue.h"
 #include "airtime.h"
 #include "error.h"
+#ifdef USE_ADAPTIVE_CODING_RATE
+#include <unordered_map>
+#endif
 
 #define MAX_TX_QUEUE 16 // max number of packets which can be waiting for transmission
 
@@ -220,6 +223,11 @@ class RadioInterface
     // Whether we use the default frequency slot given our LoRa config (region and modem preset)
     static bool uses_default_frequency_slot;
 
+#ifdef USE_ADAPTIVE_CODING_RATE
+    /** Clear adaptive coding rate tracking for a completed packet id */
+    void clearAdaptiveCodingRateState(NodeNum from, PacketId id);
+#endif
+
   protected:
     int8_t power = 17; // Set by applyModemConfig()
 
@@ -250,6 +258,20 @@ class RadioInterface
      */
     virtual void saveChannelNum(uint32_t savedChannelNum);
 
+#ifdef USE_ADAPTIVE_CODING_RATE
+    bool applyAdaptiveCodingRate(const meshtastic_MeshPacket *p);
+    struct AdaptiveAttemptState {
+        uint8_t attempts = 0;
+        uint32_t lastUseMsec = 0;
+    };
+    std::unordered_map<uint64_t, AdaptiveAttemptState> adaptiveAttempts;
+    uint8_t adaptiveCrOverride = 0;
+    uint8_t recordAdaptiveAttempt(const meshtastic_MeshPacket *p);
+    uint8_t computeAdaptiveCodingRate(uint8_t attempt) const;
+    void pruneAdaptiveAttempts(uint32_t now);
+    uint64_t adaptiveKey(NodeNum from, PacketId id) const;
+#endif
+
   private:
     /**
      * Convert our modemConfig enum into wf, sf, etc...

src/mesh/RadioLibInterface.cpp

@@ -540,6 +540,9 @@ bool RadioLibInterface::startSend(meshtastic_MeshPacket *txp)
         packetPool.release(txp);
         return false;
     } else {
+#ifdef USE_ADAPTIVE_CODING_RATE
+        applyAdaptiveCodingRate(txp);
+#endif
         configHardwareForSend(); // must be after setStandby
 
         size_t numbytes = beginSending(txp);

src/mesh/ReliableRouter.cpp

@@ -1,6 +1,7 @@
 #include "ReliableRouter.h"
 #include "Default.h"
 #include "MeshTypes.h"
+#include "NodeDB.h"
 #include "configuration.h"
 #include "memGet.h"
 #include "mesh-pb-constants.h"
@@ -108,12 +109,12 @@ void ReliableRouter::sniffReceived(const meshtastic_MeshPacket *p, const meshtas
                         // If this packet should always be ACKed reliably with want_ack back to the original sender, make sure we
                         // do that unconditionally.
                         sendAckNak(meshtastic_Routing_Error_NONE, getFrom(p), p->id, p->channel,
-                                   routingModule->getHopLimitForResponse(p->hop_start, p->hop_limit), true);
+                                   routingModule->getHopLimitForResponse(*p), true);
                     } else if (!p->decoded.request_id && !p->decoded.reply_id) {
                         // If it's not an ACK or a reply, send an ACK.
                         sendAckNak(meshtastic_Routing_Error_NONE, getFrom(p), p->id, p->channel,
-                                   routingModule->getHopLimitForResponse(p->hop_start, p->hop_limit));
-                    } else if ((p->hop_start > 0 && p->hop_start == p->hop_limit) || p->next_hop != NO_NEXT_HOP_PREFERENCE) {
+                                   routingModule->getHopLimitForResponse(*p));
+                    } else if ((getHopsAway(*p) == 0) || p->next_hop != NO_NEXT_HOP_PREFERENCE) {
                         // If we received the packet directly from the original sender, send a 0-hop ACK since the original sender
                         // won't overhear any implicit ACKs. If we received the packet via NextHopRouter, also send a 0-hop ACK to
                         // stop the immediate relayer's retransmissions.
@@ -123,11 +124,11 @@ void ReliableRouter::sniffReceived(const meshtastic_MeshPacket *p, const meshtas
                            (nodeDB->getMeshNode(p->from) == nullptr || nodeDB->getMeshNode(p->from)->user.public_key.size == 0)) {
                     LOG_INFO("PKI packet from unknown node, send PKI_UNKNOWN_PUBKEY");
                     sendAckNak(meshtastic_Routing_Error_PKI_UNKNOWN_PUBKEY, getFrom(p), p->id, channels.getPrimaryIndex(),
-                               routingModule->getHopLimitForResponse(p->hop_start, p->hop_limit));
+                               routingModule->getHopLimitForResponse(*p));
                 } else {
                     // Send a 'NO_CHANNEL' error on the primary channel if want_ack packet destined for us cannot be decoded
                     sendAckNak(meshtastic_Routing_Error_NO_CHANNEL, getFrom(p), p->id, channels.getPrimaryIndex(),
-                               routingModule->getHopLimitForResponse(p->hop_start, p->hop_limit));
+                               routingModule->getHopLimitForResponse(*p));
                 }
             } else if (p->next_hop == nodeDB->getLastByteOfNodeNum(getNodeNum()) && p->hop_limit > 0) {
                 // No wantAck, but we need to ACK with hop limit of 0 if we were the next hop to stop their retransmissions

src/mesh/Router.cpp

@@ -81,8 +81,7 @@ Router::Router() : concurrency::OSThread("Router"), fromRadioQueue(MAX_RX_FROMRA
 bool Router::shouldDecrementHopLimit(const meshtastic_MeshPacket *p)
 {
     // First hop MUST always decrement to prevent retry issues
-    bool isFirstHop = (p->hop_start != 0 && p->hop_start == p->hop_limit);
-    if (isFirstHop) {
+    if (getHopsAway(*p) == 0) {
         return true; // Always decrement on first hop
     }
 
@@ -114,7 +113,7 @@ bool Router::shouldDecrementHopLimit(const meshtastic_MeshPacket *p)
 
         // Check 3: role check (moderate cost - multiple comparisons)
         if (!IS_ONE_OF(node->user.role, meshtastic_Config_DeviceConfig_Role_ROUTER,
-                       meshtastic_Config_DeviceConfig_Role_ROUTER_LATE)) {
+                       meshtastic_Config_DeviceConfig_Role_ROUTER_LATE, meshtastic_Config_DeviceConfig_Role_CLIENT_BASE)) {
             continue;
         }
 
@@ -730,7 +729,8 @@ void Router::handleReceived(meshtastic_MeshPacket *p, RxSource src)
                        meshtastic_PortNum_POSITION_APP, meshtastic_PortNum_NODEINFO_APP, meshtastic_PortNum_ROUTING_APP,
                        meshtastic_PortNum_TELEMETRY_APP, meshtastic_PortNum_ADMIN_APP, meshtastic_PortNum_ALERT_APP,
                        meshtastic_PortNum_KEY_VERIFICATION_APP, meshtastic_PortNum_WAYPOINT_APP,
-                       meshtastic_PortNum_STORE_FORWARD_APP, meshtastic_PortNum_TRACEROUTE_APP)) {
+                       meshtastic_PortNum_STORE_FORWARD_APP, meshtastic_PortNum_TRACEROUTE_APP,
+                       meshtastic_PortNum_STORE_FORWARD_PLUSPLUS_APP)) {
             LOG_DEBUG("Ignore packet on non-standard portnum for CORE_PORTNUMS_ONLY");
             cancelSending(p->from, p->id);
             skipHandle = true;
@@ -745,15 +745,19 @@ void Router::handleReceived(meshtastic_MeshPacket *p, RxSource src)
         MeshModule::callModules(*p, src);
 
 #if !MESHTASTIC_EXCLUDE_MQTT
-        // Mark as pki_encrypted if it is not yet decoded and MQTT encryption is also enabled, hash matches and it's a DM not to
-        // us (because we would be able to decrypt it)
-        if (decodedState == DecodeState::DECODE_FAILURE && moduleConfig.mqtt.encryption_enabled && p->channel == 0x00 &&
-            !isBroadcast(p->to) && !isToUs(p))
-            p_encrypted->pki_encrypted = true;
-        // After potentially altering it, publish received message to MQTT if we're not the original transmitter of the packet
-        if ((decodedState == DecodeState::DECODE_SUCCESS || p_encrypted->pki_encrypted) && moduleConfig.mqtt.enabled &&
-            !isFromUs(p) && mqtt)
-            mqtt->onSend(*p_encrypted, *p, p->channel);
+        if (p_encrypted == nullptr) {
+            LOG_WARN("p_encrypted is null, skipping MQTT publish");
+        } else {
+            // Mark as pki_encrypted if it is not yet decoded and MQTT encryption is also enabled, hash matches and it's a DM not
+            // to us (because we would be able to decrypt it)
+            if (decodedState == DecodeState::DECODE_FAILURE && moduleConfig.mqtt.encryption_enabled && p->channel == 0x00 &&
+                !isBroadcast(p->to) && !isToUs(p))
+                p_encrypted->pki_encrypted = true;
+            // After potentially altering it, publish received message to MQTT if we're not the original transmitter of the packet
+            if ((decodedState == DecodeState::DECODE_SUCCESS || p_encrypted->pki_encrypted) && moduleConfig.mqtt.enabled &&
+                !isFromUs(p) && mqtt)
+                mqtt->onSend(*p_encrypted, *p, p->channel);
+        }
 #endif
     }
 

src/mesh/SX126xInterface.cpp

@@ -62,6 +62,11 @@ template <typename T> bool SX126xInterface<T>::init()
     digitalWrite(LORA_PA_TX_EN, LOW);
 #endif
 
+#ifdef RF95_FAN_EN
+    digitalWrite(RF95_FAN_EN, HIGH);
+    pinMode(RF95_FAN_EN, OUTPUT);
+#endif
+
 #if ARCH_PORTDUINO
     tcxoVoltage = (float)portduino_config.dio3_tcxo_voltage / 1000;
     if (portduino_config.lora_sx126x_ant_sw_pin.pin != RADIOLIB_NC) {
@@ -85,6 +90,13 @@ template <typename T> bool SX126xInterface<T>::init()
         power = -9;
 
     int res = lora.begin(getFreq(), bw, sf, cr, syncWord, power, preambleLength, tcxoVoltage, useRegulatorLDO);
+
+#ifdef SX126X_PA_RAMP_US
+    // Set custom PA ramp time for boards requiring longer stabilization (e.g., T-Beam 1W needs >800us)
+    if (res == RADIOLIB_ERR_NONE) {
+        lora.setPaRampTime(SX126X_PA_RAMP_US);
+    }
+#endif
     // \todo Display actual typename of the adapter, not just `SX126x`
     LOG_INFO("SX126x init result %d", res);
     if (res == RADIOLIB_ERR_CHIP_NOT_FOUND || res == RADIOLIB_ERR_SPI_CMD_FAILED)

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

@@ -33,3 +33,5 @@ PB_BIND(meshtastic_KeyVerificationAdmin, meshtastic_KeyVerificationAdmin, AUTO)
 
 
 
+
+

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

@@ -16,6 +16,16 @@
 #endif
 
 /* Enum definitions */
+/* Firmware update mode for OTA updates */
+typedef enum _meshtastic_OTAMode {
+    /* Do not reboot into OTA mode */
+    meshtastic_OTAMode_NO_REBOOT_OTA = 0,
+    /* Reboot into OTA mode for BLE firmware update */
+    meshtastic_OTAMode_OTA_BLE = 1,
+    /* Reboot into OTA mode for WiFi firmware update */
+    meshtastic_OTAMode_OTA_WIFI = 2
+} meshtastic_OTAMode;
+
 /* TODO: REPLACE */
 typedef enum _meshtastic_AdminMessage_ConfigType {
     /* TODO: REPLACE */
@@ -258,10 +268,13 @@ typedef struct _meshtastic_AdminMessage {
         meshtastic_SharedContact add_contact;
         /* Initiate or respond to a key verification request */
         meshtastic_KeyVerificationAdmin key_verification;
+        /* Tell the node to reboot into OTA mode for firmware update via BLE or WiFi (ESP32 only for now) */
+        meshtastic_OTAMode reboot_ota_mode;
         /* Tell the node to factory reset config everything; all device state and configuration will be returned to factory defaults and BLE bonds will be cleared. */
         int32_t factory_reset_device;
         /* Tell the node to reboot into the OTA Firmware in this many seconds (or <0 to cancel reboot)
-     Only Implemented for ESP32 Devices. This needs to be issued to send a new main firmware via bluetooth. */
+     Only Implemented for ESP32 Devices. This needs to be issued to send a new main firmware via bluetooth.
+     Deprecated in favor of reboot_ota_mode in 2.7.17 */
         int32_t reboot_ota_seconds;
         /* This message is only supported for the simulator Portduino build.
      If received the simulator will exit successfully. */
@@ -288,6 +301,10 @@ extern "C" {
 #endif
 
 /* Helper constants for enums */
+#define _meshtastic_OTAMode_MIN meshtastic_OTAMode_NO_REBOOT_OTA
+#define _meshtastic_OTAMode_MAX meshtastic_OTAMode_OTA_WIFI
+#define _meshtastic_OTAMode_ARRAYSIZE ((meshtastic_OTAMode)(meshtastic_OTAMode_OTA_WIFI+1))
+
 #define _meshtastic_AdminMessage_ConfigType_MIN meshtastic_AdminMessage_ConfigType_DEVICE_CONFIG
 #define _meshtastic_AdminMessage_ConfigType_MAX meshtastic_AdminMessage_ConfigType_DEVICEUI_CONFIG
 #define _meshtastic_AdminMessage_ConfigType_ARRAYSIZE ((meshtastic_AdminMessage_ConfigType)(meshtastic_AdminMessage_ConfigType_DEVICEUI_CONFIG+1))
@@ -309,6 +326,7 @@ extern "C" {
 #define meshtastic_AdminMessage_payload_variant_backup_preferences_ENUMTYPE meshtastic_AdminMessage_BackupLocation
 #define meshtastic_AdminMessage_payload_variant_restore_preferences_ENUMTYPE meshtastic_AdminMessage_BackupLocation
 #define meshtastic_AdminMessage_payload_variant_remove_backup_preferences_ENUMTYPE meshtastic_AdminMessage_BackupLocation
+#define meshtastic_AdminMessage_payload_variant_reboot_ota_mode_ENUMTYPE meshtastic_OTAMode
 
 
 
@@ -396,6 +414,7 @@ extern "C" {
 #define meshtastic_AdminMessage_commit_edit_settings_tag 65
 #define meshtastic_AdminMessage_add_contact_tag  66
 #define meshtastic_AdminMessage_key_verification_tag 67
+#define meshtastic_AdminMessage_reboot_ota_mode_tag 68
 #define meshtastic_AdminMessage_factory_reset_device_tag 94
 #define meshtastic_AdminMessage_reboot_ota_seconds_tag 95
 #define meshtastic_AdminMessage_exit_simulator_tag 96
@@ -454,6 +473,7 @@ X(a, STATIC,   ONEOF,    BOOL,     (payload_variant,begin_edit_settings,begin_ed
 X(a, STATIC,   ONEOF,    BOOL,     (payload_variant,commit_edit_settings,commit_edit_settings),  65) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,add_contact,add_contact),  66) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,key_verification,key_verification),  67) \
+X(a, STATIC,   ONEOF,    UENUM,    (payload_variant,reboot_ota_mode,reboot_ota_mode),  68) \
 X(a, STATIC,   ONEOF,    INT32,    (payload_variant,factory_reset_device,factory_reset_device),  94) \
 X(a, STATIC,   ONEOF,    INT32,    (payload_variant,reboot_ota_seconds,reboot_ota_seconds),  95) \
 X(a, STATIC,   ONEOF,    BOOL,     (payload_variant,exit_simulator,exit_simulator),  96) \

src/modules/CannedMessageModule.cpp

@@ -115,7 +115,6 @@ namespace graphics
 extern int bannerSignalBars;
 }
 extern ScanI2C::DeviceAddress cardkb_found;
-extern bool graphics::isMuted;
 extern bool osk_found;
 
 static const char *cannedMessagesConfigFile = "/prefs/cannedConf.proto";

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,9 +243,6 @@ void setupModules()
 #endif
 #if ARCH_PORTDUINO
     new HostMetricsModule();
-#if SFPP_ENABLED
-    new StoreForwardPlusPlusModule();
-#endif
 #endif
 #if HAS_TELEMETRY
     new DeviceTelemetryModule();

src/modules/Native/StoreForwardPlusPlus.h

@@ -1,224 +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 32
-#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
-    {
-        switch (p->decoded.portnum) {
-        case meshtastic_PortNum_TEXT_MESSAGE_APP:
-        case meshtastic_PortNum_TEXT_MESSAGE_COMPRESSED_APP:
-            return true;
-        default:
-            return false;
-        }
-    }
-
-  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 *checkDup;
-    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 *getHashFromRootStmt;
-    sqlite3_stmt *addRootToMappingsStmt;
-    sqlite3_stmt *getRootFromChannelHashStmt;
-    sqlite3_stmt *getFullRootHashStmt;
-    sqlite3_stmt *setChainCountStmt;
-    sqlite3_stmt *getChainCountStmt;
-
-    // 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);
-
-    // 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(uint8_t *, uint8_t *, uint8_t *, uint32_t);
-
-    // checks if the message hash is present in the canonical chain database
-    bool isInDB(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);
-
-    // 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 message hash
-    link_object getLink(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);
-
-    // query the mappings table for the chain count for the given root hash
-    uint32_t getChainCount(uint8_t *, size_t);
-
-    link_object getLinkFromCount(uint32_t, uint8_t *, size_t);
-
-    // 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
-};
-#endif

src/modules/NeighborInfoModule.cpp

@@ -170,7 +170,7 @@ bool NeighborInfoModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp,
         } else {
             LOG_DEBUG("  Ignoring dummy neighbor info packet (single neighbor with nodeId 0, snr 0)");
         }
-    } else if (mp.hop_start != 0 && mp.hop_start == mp.hop_limit) {
+    } else if (getHopsAway(mp) == 0) {
         LOG_DEBUG("Get or create neighbor: %u with snr %f", mp.from, mp.rx_snr);
         // If the hopLimit is the same as hopStart, then it is a neighbor
         getOrCreateNeighbor(mp.from, mp.from, 0,

src/modules/PositionModule.cpp

@@ -429,7 +429,9 @@ int32_t PositionModule::runOnce()
 
     if (lastGpsSend == 0 || msSinceLastSend >= intervalMs) {
         if (waitingForFreshPosition) {
+#ifdef GPS_DEBUG
             LOG_DEBUG("Skip initial position send; no fresh position since boot");
+#endif
         } else if (nodeDB->hasValidPosition(node)) {
             lastGpsSend = now;
 

src/modules/PositionModule.h

@@ -69,7 +69,7 @@ class PositionModule : public ProtobufModule<meshtastic_Position>, private concu
     // In event mode we want to prevent excessive position broadcasts
     // we set the minimum interval to 5m
     const uint32_t minimumTimeThreshold =
-        max(300000, Default::getConfiguredOrDefaultMs(config.position.broadcast_smart_minimum_interval_secs, 30));
+        max(uint32_t(300000), Default::getConfiguredOrDefaultMs(config.position.broadcast_smart_minimum_interval_secs, 30));
 #else
     const uint32_t minimumTimeThreshold =
         Default::getConfiguredOrDefaultMs(config.position.broadcast_smart_minimum_interval_secs, 30);

src/modules/RoutingModule.cpp

@@ -58,12 +58,11 @@ void RoutingModule::sendAckNak(meshtastic_Routing_Error err, NodeNum to, PacketI
     router->sendLocal(p); // we sometimes send directly to the local node
 }
 
-uint8_t RoutingModule::getHopLimitForResponse(uint8_t hopStart, uint8_t hopLimit)
+uint8_t RoutingModule::getHopLimitForResponse(const meshtastic_MeshPacket &mp)
 {
-    if (hopStart != 0) {
-        // Hops used by the request. If somebody in between running modified firmware modified it, ignore it
-        uint8_t hopsUsed = hopStart < hopLimit ? config.lora.hop_limit : hopStart - hopLimit;
-        if (hopsUsed > config.lora.hop_limit) {
+    const int8_t hopsUsed = getHopsAway(mp);
+    if (hopsUsed >= 0) {
+        if (hopsUsed > (int32_t)(config.lora.hop_limit)) {
 // In event mode, we never want to send packets with more than our default 3 hops.
 #if !(EVENTMODE)             // This falls through to the default.
             return hopsUsed; // If the request used more hops than the limit, use the same amount of hops

src/modules/RoutingModule.h

@@ -20,7 +20,7 @@ class RoutingModule : public ProtobufModule<meshtastic_Routing>
                                        uint8_t hopLimit = 0);
 
     // Given the hopStart and hopLimit upon reception of a request, return the hop limit to use for the response
-    uint8_t getHopLimitForResponse(uint8_t hopStart, uint8_t hopLimit);
+    uint8_t getHopLimitForResponse(const meshtastic_MeshPacket &mp);
 
   protected:
     friend class Router;

src/modules/StatusLEDModule.cpp

@@ -20,7 +20,7 @@ int StatusLEDModule::handleStatusUpdate(const meshtastic::Status *arg)
     switch (arg->getStatusType()) {
     case STATUS_TYPE_POWER: {
         meshtastic::PowerStatus *powerStatus = (meshtastic::PowerStatus *)arg;
-        if (powerStatus->getHasUSB()) {
+        if (powerStatus->getHasUSB() || powerStatus->getIsCharging()) {
             power_state = charging;
             if (powerStatus->getBatteryChargePercent() >= 100) {
                 power_state = charged;

src/modules/SystemCommandsModule.cpp

@@ -45,10 +45,9 @@ int SystemCommandsModule::handleInputEvent(const InputEvent *event)
     // Mute
     case INPUT_BROKER_MSG_MUTE_TOGGLE:
         if (moduleConfig.external_notification.enabled && externalNotificationModule) {
-            bool isMuted = externalNotificationModule->getMute();
-            externalNotificationModule->setMute(!isMuted);
-            IF_SCREEN(graphics::isMuted = !isMuted; if (!isMuted) externalNotificationModule->stopNow();
-                      screen->showSimpleBanner(isMuted ? "Notifications\nEnabled" : "Notifications\nDisabled", 3000);)
+            externalNotificationModule->setMute(externalNotificationModule->getMute());
+            IF_SCREEN(if (!externalNotificationModule->getMute()) externalNotificationModule->stopNow(); screen->showSimpleBanner(
+                externalNotificationModule->getMute() ? "Notifications\nEnabled" : "Notifications\nDisabled", 3000);)
         }
         return 0;
     // Bluetooth

src/modules/Telemetry/EnvironmentTelemetry.cpp

@@ -53,7 +53,7 @@ extern void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const c
 #include "Sensor/LTR390UVSensor.h"
 #endif
 
-#if __has_include(<bsec2.h>)
+#if __has_include(MESHTASTIC_BME680_HEADER)
 #include "Sensor/BME680Sensor.h"
 #endif
 
@@ -214,7 +214,7 @@ void EnvironmentTelemetryModule::i2cScanFinished(ScanI2C *i2cScanner)
 #if __has_include(<Adafruit_LTR390.h>)
     addSensor<LTR390UVSensor>(i2cScanner, ScanI2C::DeviceType::LTR390UV);
 #endif
-#if __has_include(<bsec2.h>)
+#if __has_include(MESHTASTIC_BME680_HEADER)
     addSensor<BME680Sensor>(i2cScanner, ScanI2C::DeviceType::BME_680);
 #endif
 #if __has_include(<Adafruit_BMP280.h>)

src/modules/Telemetry/HealthTelemetry.cpp

@@ -136,12 +136,12 @@ void HealthTelemetryModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *
     display->drawString(x, y += _fontHeight(FONT_SMALL), tempStr);
     if (lastMeasurement.variant.health_metrics.has_heart_bpm) {
         char heartStr[32];
-        snprintf(heartStr, sizeof(heartStr), "Heart Rate: %.0f bpm", lastMeasurement.variant.health_metrics.heart_bpm);
+        snprintf(heartStr, sizeof(heartStr), "Heart Rate: %u bpm", lastMeasurement.variant.health_metrics.heart_bpm);
         display->drawString(x, y += _fontHeight(FONT_SMALL), heartStr);
     }
     if (lastMeasurement.variant.health_metrics.has_spO2) {
         char spo2Str[32];
-        snprintf(spo2Str, sizeof(spo2Str), "spO2: %.0f %%", lastMeasurement.variant.health_metrics.spO2);
+        snprintf(spo2Str, sizeof(spo2Str), "spO2: %u %%", lastMeasurement.variant.health_metrics.spO2);
         display->drawString(x, y += _fontHeight(FONT_SMALL), spo2Str);
     }
 }

src/modules/Telemetry/Sensor/BME680Sensor.cpp

@@ -1,6 +1,6 @@
 #include "configuration.h"
 
-#if !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && __has_include(<bsec2.h>)
+#if !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && __has_include(MESHTASTIC_BME680_HEADER)
 
 #include "../mesh/generated/meshtastic/telemetry.pb.h"
 #include "BME680Sensor.h"
@@ -10,6 +10,7 @@
 
 BME680Sensor::BME680Sensor() : TelemetrySensor(meshtastic_TelemetrySensorType_BME680, "BME680") {}
 
+#if MESHTASTIC_BME680_BSEC2_SUPPORTED == 1
 int32_t BME680Sensor::runOnce()
 {
     if (!bme680.run()) {
@@ -17,10 +18,13 @@ int32_t BME680Sensor::runOnce()
     }
     return 35;
 }
+#endif // defined(MESHTASTIC_BME680_BSEC2_SUPPORTED)
 
 bool BME680Sensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
 {
     status = 0;
+
+#if MESHTASTIC_BME680_BSEC2_SUPPORTED == 1
     if (!bme680.begin(dev->address.address, *bus))
         checkStatus("begin");
 
@@ -42,12 +46,25 @@ bool BME680Sensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
     if (status == 0)
         LOG_DEBUG("BME680Sensor::runOnce: bme680.status %d", bme680.status);
 
+#else
+    bme680 = makeBME680(bus);
+
+    if (!bme680->begin(dev->address.address)) {
+        LOG_ERROR("Init sensor: %s failed at begin()", sensorName);
+        return status;
+    }
+
+    status = 1;
+
+#endif // MESHTASTIC_BME680_BSEC2_SUPPORTED
+
     initI2CSensor();
     return status;
 }
 
 bool BME680Sensor::getMetrics(meshtastic_Telemetry *measurement)
 {
+#if MESHTASTIC_BME680_BSEC2_SUPPORTED == 1
     if (bme680.getData(BSEC_OUTPUT_RAW_PRESSURE).signal == 0)
         return false;
 
@@ -65,9 +82,27 @@ bool BME680Sensor::getMetrics(meshtastic_Telemetry *measurement)
     // Check if we need to save state to filesystem (every STATE_SAVE_PERIOD ms)
     measurement->variant.environment_metrics.iaq = bme680.getData(BSEC_OUTPUT_IAQ).signal;
     updateState();
+#else
+    if (!bme680->performReading()) {
+        LOG_ERROR("BME680Sensor::getMetrics: performReading failed");
+        return false;
+    }
+
+    measurement->variant.environment_metrics.has_temperature = true;
+    measurement->variant.environment_metrics.has_relative_humidity = true;
+    measurement->variant.environment_metrics.has_barometric_pressure = true;
+    measurement->variant.environment_metrics.has_gas_resistance = true;
+
+    measurement->variant.environment_metrics.temperature = bme680->readTemperature();
+    measurement->variant.environment_metrics.relative_humidity = bme680->readHumidity();
+    measurement->variant.environment_metrics.barometric_pressure = bme680->readPressure() / 100.0F;
+    measurement->variant.environment_metrics.gas_resistance = bme680->readGas() / 1000.0;
+
+#endif // MESHTASTIC_BME680_BSEC2_SUPPORTED
     return true;
 }
 
+#if MESHTASTIC_BME680_BSEC2_SUPPORTED == 1
 void BME680Sensor::loadState()
 {
 #ifdef FSCom
@@ -144,5 +179,6 @@ void BME680Sensor::checkStatus(const char *functionName)
     else if (bme680.sensor.status > BME68X_OK)
         LOG_WARN("%s BME68X code: %d", functionName, bme680.sensor.status);
 }
+#endif // MESHTASTIC_BME680_BSEC2_SUPPORTED
 
 #endif

src/modules/Telemetry/Sensor/BME680Sensor.h

@@ -1,23 +1,40 @@
 #include "configuration.h"
 
-#if !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && __has_include(<bsec2.h>)
+#if !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && __has_include(MESHTASTIC_BME680_HEADER)
 
 #include "../mesh/generated/meshtastic/telemetry.pb.h"
 #include "TelemetrySensor.h"
+
+#if MESHTASTIC_BME680_BSEC2_SUPPORTED == 1
+#include <bme68xLibrary.h>
 #include <bsec2.h>
+#else
+#include <Adafruit_BME680.h>
+#include <memory>
+#endif // MESHTASTIC_BME680_BSEC2_SUPPORTED
 
 #define STATE_SAVE_PERIOD UINT32_C(360 * 60 * 1000) // That's 6 hours worth of millis()
 
+#if MESHTASTIC_BME680_BSEC2_SUPPORTED == 1
 const uint8_t bsec_config[] = {
 #include "config/bme680/bme680_iaq_33v_3s_4d/bsec_iaq.txt"
 };
-
+#endif // MESHTASTIC_BME680_BSEC2_SUPPORTED
 class BME680Sensor : public TelemetrySensor
 {
   private:
+#if MESHTASTIC_BME680_BSEC2_SUPPORTED == 1
     Bsec2 bme680;
+#else
+    using BME680Ptr = std::unique_ptr<Adafruit_BME680>;
+
+    static BME680Ptr makeBME680(TwoWire *bus) { return std::make_unique<Adafruit_BME680>(bus); }
+
+    BME680Ptr bme680;
+#endif // MESHTASTIC_BME680_BSEC2_SUPPORTED
 
   protected:
+#if MESHTASTIC_BME680_BSEC2_SUPPORTED == 1
     const char *bsecConfigFileName = "/prefs/bsec.dat";
     uint8_t bsecState[BSEC_MAX_STATE_BLOB_SIZE] = {0};
     uint8_t accuracy = 0;
@@ -34,10 +51,13 @@ class BME680Sensor : public TelemetrySensor
     void loadState();
     void updateState();
     void checkStatus(const char *functionName);
+#endif // MESHTASTIC_BME680_BSEC2_SUPPORTED
 
   public:
     BME680Sensor();
+#if MESHTASTIC_BME680_BSEC2_SUPPORTED == 1
     virtual int32_t runOnce() override;
+#endif // MESHTASTIC_BME680_BSEC2_SUPPORTED
     virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
     virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) override;
 };

src/modules/TextMessageModule.cpp

@@ -21,18 +21,17 @@ ProcessMessage TextMessageModule::handleReceived(const meshtastic_MeshPacket &mp
     // We only store/display messages destined for us.
     devicestate.rx_text_message = mp;
     devicestate.has_rx_text_message = true;
-#if HAS_SCREEN
-    // Guard against running in MeshtasticUI
-    if (screen && config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_COLOR) {
-        // Store in the central message history
-        const StoredMessage &sm = messageStore.addFromPacket(mp);
+    IF_SCREEN(
+        // Guard against running in MeshtasticUI or with no screen
+        if (config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_COLOR) {
+            // Store in the central message history
+            const StoredMessage &sm = messageStore.addFromPacket(mp);
 
-        // Pass message to renderer (banner + thread switching + scroll reset)
-        // Use the global Screen singleton to retrieve the current OLED display
-        auto *display = screen ? screen->getDisplayDevice() : nullptr;
-        graphics::MessageRenderer::handleNewMessage(display, sm, mp);
-    }
-#endif
+            // Pass message to renderer (banner + thread switching + scroll reset)
+            // Use the global Screen singleton to retrieve the current OLED display
+            auto *display = screen ? screen->getDisplayDevice() : nullptr;
+            graphics::MessageRenderer::handleNewMessage(display, sm, mp);
+        })
     // Only trigger screen wake if configuration allows it
     if (shouldWakeOnReceivedMessage()) {
         powerFSM.trigger(EVENT_RECEIVED_MSG);

src/modules/TraceRouteModule.cpp

@@ -1,5 +1,6 @@
 #include "TraceRouteModule.h"
 #include "MeshService.h"
+#include "NodeDB.h"
 #include "graphics/Screen.h"
 #include "graphics/ScreenFonts.h"
 #include "graphics/SharedUIDisplay.h"
@@ -359,10 +360,10 @@ void TraceRouteModule::insertUnknownHops(meshtastic_MeshPacket &p, meshtastic_Ro
     }
 
     // Only insert unknown hops if hop_start is valid
-    if (p.hop_start != 0 && p.hop_limit <= p.hop_start) {
-        uint8_t hopsTaken = p.hop_start - p.hop_limit;
+    const int8_t hopsTaken = getHopsAway(p);
+    if (hopsTaken >= 0) {
         int8_t diff = hopsTaken - *route_count;
-        for (uint8_t i = 0; i < diff; i++) {
+        for (int8_t i = 0; i < diff; i++) {
             if (*route_count < ROUTE_SIZE) {
                 route[*route_count] = NODENUM_BROADCAST; // This will represent an unknown hop
                 *route_count += 1;
@@ -370,7 +371,7 @@ void TraceRouteModule::insertUnknownHops(meshtastic_MeshPacket &p, meshtastic_Ro
         }
         // Add unknown SNR values if necessary
         diff = *route_count - *snr_count;
-        for (uint8_t i = 0; i < diff; i++) {
+        for (int8_t i = 0; i < diff; i++) {
             if (*snr_count < ROUTE_SIZE) {
                 snr_list[*snr_count] = INT8_MIN; // This will represent an unknown SNR
                 *snr_count += 1;

src/nimble/NimbleBluetooth.cpp

@@ -14,11 +14,11 @@
 #include <atomic>
 #include <mutex>
 
+#ifdef NIMBLE_TWO
 #include "NimBLEAdvertising.h"
-#ifdef CONFIG_BT_NIMBLE_EXT_ADV
 #include "NimBLEExtAdvertising.h"
-#endif
 #include "PowerStatus.h"
+#endif
 
 #if defined(CONFIG_NIMBLE_CPP_IDF)
 #include "host/ble_gap.h"
@@ -26,12 +26,15 @@
 #include "nimble/nimble/host/include/host/ble_gap.h"
 #endif
 
+#if defined(CONFIG_IDF_TARGET_ESP32S3) || defined(CONFIG_IDF_TARGET_ESP32C6)
+
 namespace
 {
 constexpr uint16_t kPreferredBleMtu = 517;
 constexpr uint16_t kPreferredBleTxOctets = 251;
 constexpr uint16_t kPreferredBleTxTimeUs = (kPreferredBleTxOctets + 14) * 8;
 } // namespace
+#endif
 
 // Debugging options: careful, they slow things down quite a bit!
 // #define DEBUG_NIMBLE_ON_READ_TIMING  // uncomment to time onRead duration
@@ -310,9 +313,11 @@ class BluetoothPhoneAPI : public PhoneAPI, public concurrency::OSThread
     {
         PhoneAPI::onNowHasData(fromRadioNum);
 
-#ifdef DEBUG_NIMBLE_NOTIFY
         int currentNotifyCount = notifyCount.fetch_add(1);
+
         uint8_t cc = bleServer->getConnectedCount();
+
+#ifdef DEBUG_NIMBLE_NOTIFY
         // This logging slows things down when there are lots of packets going to the phone, like initial connection:
         LOG_DEBUG("BLE notify(%d) fromNum: %d connections: %d", currentNotifyCount, fromRadioNum, cc);
 #endif
@@ -321,7 +326,13 @@ class BluetoothPhoneAPI : public PhoneAPI, public concurrency::OSThread
         put_le32(val, fromRadioNum);
 
         fromNumCharacteristic->setValue(val, sizeof(val));
+#ifdef NIMBLE_TWO
+        // NOTE: I don't have any NIMBLE_TWO devices, but this line makes me suspicious, and I suspect it needs to just be
+        // notify().
         fromNumCharacteristic->notify(val, sizeof(val), BLE_HS_CONN_HANDLE_NONE);
+#else
+        fromNumCharacteristic->notify();
+#endif
     }
 
     /// Check the current underlying physical link to see if the client is currently connected
@@ -386,7 +397,12 @@ static uint8_t lastToRadio[MAX_TO_FROM_RADIO_SIZE];
 
 class NimbleBluetoothToRadioCallback : public NimBLECharacteristicCallbacks
 {
-    void onWrite(NimBLECharacteristic *pCharacteristic, NimBLEConnInfo &) override
+#ifdef NIMBLE_TWO
+    virtual void onWrite(NimBLECharacteristic *pCharacteristic, NimBLEConnInfo &connInfo)
+#else
+    virtual void onWrite(NimBLECharacteristic *pCharacteristic)
+
+#endif
     {
         // CAUTION: This callback runs in the NimBLE task!!! Don't do anything except communicate with the main task's runOnce.
         // Assumption: onWrite is serialized by NimBLE, so we don't need to lock here against multiple concurrent onWrite calls.
@@ -433,7 +449,11 @@ class NimbleBluetoothToRadioCallback : public NimBLECharacteristicCallbacks
 
 class NimbleBluetoothFromRadioCallback : public NimBLECharacteristicCallbacks
 {
-    void onRead(NimBLECharacteristic *pCharacteristic, NimBLEConnInfo &) override
+#ifdef NIMBLE_TWO
+    virtual void onRead(NimBLECharacteristic *pCharacteristic, NimBLEConnInfo &connInfo)
+#else
+    virtual void onRead(NimBLECharacteristic *pCharacteristic)
+#endif
     {
         // CAUTION: This callback runs in the NimBLE task!!! Don't do anything except communicate with the main task's runOnce.
 
@@ -541,27 +561,32 @@ class NimbleBluetoothFromRadioCallback : public NimBLECharacteristicCallbacks
 
 class NimbleBluetoothServerCallback : public NimBLEServerCallbacks
 {
+#ifdef NIMBLE_TWO
   public:
-    explicit NimbleBluetoothServerCallback(NimbleBluetooth *ble) : ble(ble) {}
+    NimbleBluetoothServerCallback(NimbleBluetooth *ble) { this->ble = ble; }
 
   private:
     NimbleBluetooth *ble;
 
-    uint32_t onPassKeyDisplay() override
+    virtual uint32_t onPassKeyDisplay()
+#else
+    virtual uint32_t onPassKeyRequest()
+#endif
     {
         uint32_t passkey = config.bluetooth.fixed_pin;
 
         if (config.bluetooth.mode == meshtastic_Config_BluetoothConfig_PairingMode_RANDOM_PIN) {
             LOG_INFO("Use random passkey");
+            // This is the passkey to be entered on peer - we pick a number >100,000 to ensure 6 digits
             passkey = random(100000, 999999);
         }
-        LOG_INFO("*** Enter passkey %06u on the peer side ***", passkey);
+        LOG_INFO("*** Enter passkey %d on the peer side ***", passkey);
 
         powerFSM.trigger(EVENT_BLUETOOTH_PAIR);
         meshtastic::BluetoothStatus newStatus(std::to_string(passkey));
         bluetoothStatus->updateStatus(&newStatus);
 
-#if HAS_SCREEN
+#if HAS_SCREEN // Todo: migrate this display code back into Screen class, and observe bluetoothStatus
         if (screen) {
             screen->startAlert([passkey](OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y) -> void {
                 char btPIN[16] = "888888";
@@ -590,29 +615,39 @@ class NimbleBluetoothServerCallback : public NimBLEServerCallbacks
             });
         }
 #endif
-
         passkeyShowing = true;
+
         return passkey;
     }
 
-    void onAuthenticationComplete(NimBLEConnInfo &connInfo) override
+#ifdef NIMBLE_TWO
+    virtual void onAuthenticationComplete(NimBLEConnInfo &connInfo)
+#else
+    virtual void onAuthenticationComplete(ble_gap_conn_desc *desc)
+#endif
     {
         LOG_INFO("BLE authentication complete");
 
         meshtastic::BluetoothStatus newStatus(meshtastic::BluetoothStatus::ConnectionState::CONNECTED);
         bluetoothStatus->updateStatus(&newStatus);
 
+        // Todo: migrate this display code back into Screen class, and observe bluetoothStatus
         if (passkeyShowing) {
             passkeyShowing = false;
-            if (screen) {
+            if (screen)
                 screen->endAlert();
-            }
         }
 
+        // Store the connection handle for future use
+#ifdef NIMBLE_TWO
         nimbleBluetoothConnHandle = connInfo.getConnHandle();
+#else
+        nimbleBluetoothConnHandle = desc->conn_handle;
+#endif
     }
 
-    void onConnect(NimBLEServer *pServer, NimBLEConnInfo &connInfo) override
+#ifdef NIMBLE_TWO
+    virtual void onConnect(NimBLEServer *pServer, NimBLEConnInfo &connInfo)
     {
         LOG_INFO("BLE incoming connection %s", connInfo.getAddress().toString().c_str());
 
@@ -637,12 +672,21 @@ class NimbleBluetoothServerCallback : public NimBLEServerCallbacks
         LOG_INFO("BLE conn %u initial MTU %u (target %u)", connHandle, connInfo.getMTU(), kPreferredBleMtu);
         pServer->updateConnParams(connHandle, 6, 12, 0, 200);
     }
+#endif
 
-    void onDisconnect(NimBLEServer *pServer, NimBLEConnInfo &connInfo, int reason) override
+#ifdef NIMBLE_TWO
+    virtual void onDisconnect(NimBLEServer *pServer, NimBLEConnInfo &connInfo, int reason)
     {
         LOG_INFO("BLE disconnect reason: %d", reason);
+#else
+    virtual void onDisconnect(NimBLEServer *pServer, ble_gap_conn_desc *desc)
+    {
+        LOG_INFO("BLE disconnect");
+#endif
+#ifdef NIMBLE_TWO
         if (ble->isDeInit)
             return;
+#endif
 
         meshtastic::BluetoothStatus newStatus(meshtastic::BluetoothStatus::ConnectionState::DISCONNECTED);
         bluetoothStatus->updateStatus(&newStatus);
@@ -666,69 +710,35 @@ class NimbleBluetoothServerCallback : public NimBLEServerCallbacks
             bluetoothPhoneAPI->writeCount = 0;
         }
 
+        // Clear the last ToRadio packet buffer to avoid rejecting first packet from new connection
         memset(lastToRadio, 0, sizeof(lastToRadio));
 
-        nimbleBluetoothConnHandle = BLE_HS_CONN_HANDLE_NONE;
+        nimbleBluetoothConnHandle = BLE_HS_CONN_HANDLE_NONE; // BLE_HS_CONN_HANDLE_NONE means "no connection"
 
+#ifdef NIMBLE_TWO
+        // Restart Advertising
         ble->startAdvertising();
+#else
+        NimBLEAdvertising *pAdvertising = NimBLEDevice::getAdvertising();
+        if (!pAdvertising->start(0)) {
+            if (pAdvertising->isAdvertising()) {
+                LOG_DEBUG("BLE advertising already running");
+            } else {
+                LOG_ERROR("BLE failed to restart advertising");
+            }
+        }
+#endif
     }
 };
 
 static NimbleBluetoothToRadioCallback *toRadioCallbacks;
 static NimbleBluetoothFromRadioCallback *fromRadioCallbacks;
 
-void NimbleBluetooth::startAdvertising()
-{
-#if defined(CONFIG_BT_NIMBLE_EXT_ADV)
-    NimBLEExtAdvertising *pAdvertising = NimBLEDevice::getAdvertising();
-    NimBLEExtAdvertisement legacyAdvertising;
-
-    legacyAdvertising.setLegacyAdvertising(true);
-    legacyAdvertising.setScannable(true);
-    legacyAdvertising.setConnectable(true);
-    legacyAdvertising.setFlags(BLE_HS_ADV_F_DISC_GEN);
-    if (powerStatus->getHasBattery() == 1) {
-        legacyAdvertising.setCompleteServices(NimBLEUUID((uint16_t)0x180f));
-    }
-    legacyAdvertising.setCompleteServices(NimBLEUUID(MESH_SERVICE_UUID));
-    legacyAdvertising.setMinInterval(500);
-    legacyAdvertising.setMaxInterval(1000);
-
-    NimBLEExtAdvertisement legacyScanResponse;
-    legacyScanResponse.setLegacyAdvertising(true);
-    legacyScanResponse.setConnectable(true);
-    legacyScanResponse.setName(getDeviceName());
-
-    if (!pAdvertising->setInstanceData(0, legacyAdvertising)) {
-        LOG_ERROR("BLE failed to set legacyAdvertising");
-    } else if (!pAdvertising->setScanResponseData(0, legacyScanResponse)) {
-        LOG_ERROR("BLE failed to set legacyScanResponse");
-    } else if (!pAdvertising->start(0, 0, 0)) {
-        LOG_ERROR("BLE failed to start legacyAdvertising");
-    }
-#else
-    NimBLEAdvertising *pAdvertising = NimBLEDevice::getAdvertising();
-    pAdvertising->reset();
-    pAdvertising->addServiceUUID(MESH_SERVICE_UUID);
-    if (powerStatus->getHasBattery() == 1) {
-        pAdvertising->addServiceUUID(NimBLEUUID((uint16_t)0x180f));
-    }
-
-    NimBLEAdvertisementData scan;
-    scan.setName(getDeviceName());
-    pAdvertising->setScanResponseData(scan);
-    pAdvertising->enableScanResponse(true);
-
-    if (!pAdvertising->start(0)) {
-        LOG_ERROR("BLE failed to start advertising");
-    }
-#endif
-    LOG_DEBUG("BLE Advertising started");
-}
-
 void NimbleBluetooth::shutdown()
 {
+    // No measurable power saving for ESP32 during light-sleep(?)
 #ifndef ARCH_ESP32
+    // Shutdown bluetooth for minimum power draw
     LOG_INFO("Disable bluetooth");
     NimBLEAdvertising *pAdvertising = NimBLEDevice::getAdvertising();
     pAdvertising->reset();
@@ -736,6 +746,7 @@ void NimbleBluetooth::shutdown()
 #endif
 }
 
+// Proper shutdown for ESP32. Needs reboot to reverse.
 void NimbleBluetooth::deinit()
 {
 #ifdef ARCH_ESP32
@@ -749,17 +760,21 @@ void NimbleBluetooth::deinit()
     digitalWrite(BLE_LED, LOW);
 #endif
 #endif
+#ifndef NIMBLE_TWO
+    NimBLEDevice::deinit();
+#endif
 #endif
 }
 
+// Has initial setup been completed
 bool NimbleBluetooth::isActive()
 {
-    return bleServer != nullptr;
+    return bleServer;
 }
 
 bool NimbleBluetooth::isConnected()
 {
-    return bleServer && bleServer->getConnectedCount() > 0;
+    return bleServer->getConnectedCount() > 0;
 }
 
 int NimbleBluetooth::getRssi()
@@ -803,7 +818,7 @@ void NimbleBluetooth::setup()
     LOG_INFO("Init the NimBLE bluetooth module");
 
     NimBLEDevice::init(getDeviceName());
-    NimBLEDevice::setPower(9);
+    NimBLEDevice::setPower(ESP_PWR_LVL_P9);
 
 #if NIMBLE_ENABLE_2M_PHY && (defined(CONFIG_IDF_TARGET_ESP32S3) || defined(CONFIG_IDF_TARGET_ESP32C6))
     int mtuResult = NimBLEDevice::setMTU(kPreferredBleMtu);
@@ -836,7 +851,11 @@ void NimbleBluetooth::setup()
         NimBLEDevice::setSecurityIOCap(BLE_HS_IO_DISPLAY_ONLY);
     }
     bleServer = NimBLEDevice::createServer();
-    auto *serverCallbacks = new NimbleBluetoothServerCallback(this);
+#ifdef NIMBLE_TWO
+    NimbleBluetoothServerCallback *serverCallbacks = new NimbleBluetoothServerCallback(this);
+#else
+    NimbleBluetoothServerCallback *serverCallbacks = new NimbleBluetoothServerCallback();
+#endif
     bleServer->setCallbacks(serverCallbacks, true);
     setupService();
     startAdvertising();
@@ -881,7 +900,11 @@ void NimbleBluetooth::setupService()
     NimBLEService *batteryService = bleServer->createService(NimBLEUUID((uint16_t)0x180f)); // 0x180F is the Battery Service
     BatteryCharacteristic = batteryService->createCharacteristic( // 0x2A19 is the Battery Level characteristic)
         (uint16_t)0x2a19, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::NOTIFY, 1);
+#ifdef NIMBLE_TWO
     NimBLE2904 *batteryLevelDescriptor = BatteryCharacteristic->create2904();
+#else
+    NimBLE2904 *batteryLevelDescriptor = (NimBLE2904 *)BatteryCharacteristic->createDescriptor((uint16_t)0x2904);
+#endif
     batteryLevelDescriptor->setFormat(NimBLE2904::FORMAT_UINT8);
     batteryLevelDescriptor->setNamespace(1);
     batteryLevelDescriptor->setUnit(0x27ad);
@@ -889,12 +912,54 @@ void NimbleBluetooth::setupService()
     batteryService->start();
 }
 
+void NimbleBluetooth::startAdvertising()
+{
+#ifdef NIMBLE_TWO
+    NimBLEExtAdvertising *pAdvertising = NimBLEDevice::getAdvertising();
+    NimBLEExtAdvertisement legacyAdvertising;
+
+    legacyAdvertising.setLegacyAdvertising(true);
+    legacyAdvertising.setScannable(true);
+    legacyAdvertising.setConnectable(true);
+    legacyAdvertising.setFlags(BLE_HS_ADV_F_DISC_GEN);
+    if (powerStatus->getHasBattery() == 1) {
+        legacyAdvertising.setCompleteServices(NimBLEUUID((uint16_t)0x180f));
+    }
+    legacyAdvertising.setCompleteServices(NimBLEUUID(MESH_SERVICE_UUID));
+    legacyAdvertising.setMinInterval(500);
+    legacyAdvertising.setMaxInterval(1000);
+
+    NimBLEExtAdvertisement legacyScanResponse;
+    legacyScanResponse.setLegacyAdvertising(true);
+    legacyScanResponse.setConnectable(true);
+    legacyScanResponse.setName(getDeviceName());
+
+    if (!pAdvertising->setInstanceData(0, legacyAdvertising)) {
+        LOG_ERROR("BLE failed to set legacyAdvertising");
+    } else if (!pAdvertising->setScanResponseData(0, legacyScanResponse)) {
+        LOG_ERROR("BLE failed to set legacyScanResponse");
+    } else if (!pAdvertising->start(0, 0, 0)) {
+        LOG_ERROR("BLE failed to start legacyAdvertising");
+    }
+#else
+    NimBLEAdvertising *pAdvertising = NimBLEDevice::getAdvertising();
+    pAdvertising->reset();
+    pAdvertising->addServiceUUID(MESH_SERVICE_UUID);
+    pAdvertising->addServiceUUID(NimBLEUUID((uint16_t)0x180f)); // 0x180F is the Battery Service
+    pAdvertising->start(0);
+#endif
+}
+
 /// Given a level between 0-100, update the BLE attribute
 void updateBatteryLevel(uint8_t level)
 {
     if ((config.bluetooth.enabled == true) && bleServer && nimbleBluetooth->isConnected()) {
         BatteryCharacteristic->setValue(&level, 1);
+#ifdef NIMBLE_TWO
         BatteryCharacteristic->notify(&level, 1, BLE_HS_CONN_HANDLE_NONE);
+#else
+        BatteryCharacteristic->notify();
+#endif
     }
 }
 
@@ -909,7 +974,11 @@ void NimbleBluetooth::sendLog(const uint8_t *logMessage, size_t length)
     if (!bleServer || !isConnected() || length > 512) {
         return;
     }
+#ifdef NIMBLE_TWO
     logRadioCharacteristic->notify(logMessage, length, BLE_HS_CONN_HANDLE_NONE);
+#else
+    logRadioCharacteristic->notify(logMessage, length, true);
+#endif
 }
 
 void clearNVS()

src/nimble/NimbleBluetooth.h

@@ -12,11 +12,16 @@ class NimbleBluetooth : BluetoothApi
     bool isConnected();
     int getRssi();
     void sendLog(const uint8_t *logMessage, size_t length);
+#if defined(NIMBLE_TWO)
     void startAdvertising();
+#endif
     bool isDeInit = false;
 
   private:
     void setupService();
+#if !defined(NIMBLE_TWO)
+    void startAdvertising();
+#endif
 };
 
 void setBluetoothEnable(bool enable);

src/platform/portduino/PortduinoGlue.cpp

@@ -279,7 +279,7 @@ void portduinoSetup()
         //      RAK6421-13300-S1:aabbcc123456:5ba85807d92138b7519cfb60460573af:3061e8d8
         // <model string>:mac address :<16 random unique bytes in hexidecimal> : crc32
         // crc32 is calculated on the eeprom string up to but not including the final colon
-        if (strlen(autoconf_product) < 6) {
+        if (strlen(autoconf_product) < 6 && portduino_config.i2cdev != "") {
             try {
                 char *mac_start = nullptr;
                 char *devID_start = nullptr;
@@ -788,12 +788,6 @@ bool loadConfig(const char *configPath)
             }
         }
 
-        if (yamlConfig["StoreAndForward"]) {
-            portduino_config.sfpp_stratum0 = (yamlConfig["StoreAndForward"]["Stratum0"]).as<bool>(false);
-            portduino_config.sfpp_initial_sync = (yamlConfig["StoreAndForward"]["InitialSync"]).as<int>(10);
-            portduino_config.sfpp_hops = (yamlConfig["StoreAndForward"]["Hops"]).as<int>(3);
-        }
-
         if (yamlConfig["General"]) {
             portduino_config.MaxNodes = (yamlConfig["General"]["MaxNodes"]).as<int>(200);
             portduino_config.maxtophone = (yamlConfig["General"]["MaxMessageQueue"]).as<int>(100);
@@ -875,4 +869,4 @@ void readGPIOFromYaml(YAML::Node sourceNode, pinMapping &destPin, int pinDefault
         destPin.line = destPin.pin;
         destPin.gpiochip = portduino_config.lora_default_gpiochip;
     }
-}
+}

src/platform/portduino/PortduinoGlue.h

@@ -169,19 +169,6 @@ extern struct portduino_config_struct {
     int configDisplayMode = 0;
     bool has_configDisplayMode = false;
 
-    // Store and Forward++
-    // DB location /var/lib/meshtasticd/
-    std::string sfpp_db_path = "/var/lib/meshtasticd/";
-    bool sfpp_stratum0 = false;
-    int sfpp_initial_sync = 10;
-    int sfpp_hops = 3;
-    int sfpp_announce_interval = 5; // minutes
-    uint32_t sfpp_max_chain = 1000;
-    // allowed root hashes
-    // upstream node
-    // Are we allowing unknown channel hashes? Does this even make sense?
-    // Allow DMs
-
     // General
     std::string mac_address = "";
     bool mac_address_explicit = false;
@@ -501,18 +488,6 @@ extern struct portduino_config_struct {
             out << YAML::EndMap; // Config
         }
 
-        // StoreAndForward
-        if (sfpp_stratum0 || sfpp_initial_sync != 10 || sfpp_hops != 3 || sfpp_announce_interval != 5 || sfpp_max_chain != 1000) {
-            out << YAML::Key << "StoreAndForward" << YAML::Value << YAML::BeginMap;
-
-            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 << "MaxChainLength" << YAML::Value << sfpp_max_chain;
-            out << YAML::EndMap; // StoreAndForward
-        }
-
         // General
         out << YAML::Key << "General" << YAML::Value << YAML::BeginMap;
         if (config_directory != "")

src/serialization/MeshPacketSerializer.cpp

@@ -418,8 +418,9 @@ std::string MeshPacketSerializer::JsonSerialize(const meshtastic_MeshPacket *mp,
         jsonObj["rssi"] = new JSONValue((int)mp->rx_rssi);
     if (mp->rx_snr != 0)
         jsonObj["snr"] = new JSONValue((float)mp->rx_snr);
-    if (mp->hop_start != 0 && mp->hop_limit <= mp->hop_start) {
-        jsonObj["hops_away"] = new JSONValue((unsigned int)(mp->hop_start - mp->hop_limit));
+    const int8_t hopsAway = getHopsAway(*mp);
+    if (hopsAway >= 0) {
+        jsonObj["hops_away"] = new JSONValue((unsigned int)(hopsAway));
         jsonObj["hop_start"] = new JSONValue((unsigned int)(mp->hop_start));
     }
 
@@ -450,8 +451,9 @@ std::string MeshPacketSerializer::JsonSerializeEncrypted(const meshtastic_MeshPa
         jsonObj["rssi"] = new JSONValue((int)mp->rx_rssi);
     if (mp->rx_snr != 0)
         jsonObj["snr"] = new JSONValue((float)mp->rx_snr);
-    if (mp->hop_start != 0 && mp->hop_limit <= mp->hop_start) {
-        jsonObj["hops_away"] = new JSONValue((unsigned int)(mp->hop_start - mp->hop_limit));
+    const int8_t hopsAway = getHopsAway(*mp);
+    if (hopsAway >= 0) {
+        jsonObj["hops_away"] = new JSONValue((unsigned int)(hopsAway));
         jsonObj["hop_start"] = new JSONValue((unsigned int)(mp->hop_start));
     }
     jsonObj["size"] = new JSONValue((unsigned int)mp->encrypted.size);

src/serialization/MeshPacketSerializer_nRF52.cpp

@@ -358,8 +358,9 @@ std::string MeshPacketSerializer::JsonSerialize(const meshtastic_MeshPacket *mp,
         jsonObj["rssi"] = (int)mp->rx_rssi;
     if (mp->rx_snr != 0)
         jsonObj["snr"] = (float)mp->rx_snr;
-    if (mp->hop_start != 0 && mp->hop_limit <= mp->hop_start) {
-        jsonObj["hops_away"] = (unsigned int)(mp->hop_start - mp->hop_limit);
+    const int8_t hopsAway = getHopsAway(*mp);
+    if (hopsAway >= 0) {
+        jsonObj["hops_away"] = (unsigned int)(hopsAway);
         jsonObj["hop_start"] = (unsigned int)(mp->hop_start);
     }
 
@@ -393,8 +394,9 @@ std::string MeshPacketSerializer::JsonSerializeEncrypted(const meshtastic_MeshPa
         jsonObj["rssi"] = (int)mp->rx_rssi;
     if (mp->rx_snr != 0)
         jsonObj["snr"] = (float)mp->rx_snr;
-    if (mp->hop_start != 0 && mp->hop_limit <= mp->hop_start) {
-        jsonObj["hops_away"] = (unsigned int)(mp->hop_start - mp->hop_limit);
+    const int8_t hopsAway = getHopsAway(*mp);
+    if (hopsAway >= 0) {
+        jsonObj["hops_away"] = (unsigned int)(hopsAway);
         jsonObj["hop_start"] = (unsigned int)(mp->hop_start);
     }
     jsonObj["size"] = (unsigned int)mp->encrypted.size;

test/TestUtil.cpp

@@ -1,6 +1,8 @@
 #include "SerialConsole.h"
 #include "concurrency/OSThread.h"
 #include "gps/RTC.h"
+#include "mesh/MeshRadio.h"
+#include "mesh/NodeDB.h"
 
 #include "TestUtil.h"
 
@@ -14,5 +16,19 @@ void initializeTestEnvironment()
     tv.tv_usec = 0;
     perhapsSetRTC(RTCQualityNTP, &tv);
 #endif
+    concurrency::OSThread::setup();
+}
+
+void initializeTestEnvironmentMinimal()
+{
+    // Only satisfy OSThread assertions; skip SerialConsole and platform-specific setup
+    concurrency::hasBeenSetup = true;
+
+    // Ensure region/config globals are sane before any RadioInterface instances compute slot timing
+    config.lora.region = meshtastic_Config_LoRaConfig_RegionCode_UNSET;
+    config.lora.use_preset = true;
+    config.lora.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST;
+    initRegion();
+
     concurrency::OSThread::setup();
 }

test/TestUtil.h

@@ -1,4 +1,7 @@
 #pragma once
 
 // Initialize testing environment.
-void initializeTestEnvironment();
+void initializeTestEnvironment();
+
+// Minimal init without creating SerialConsole or portduino peripherals (useful for lightweight logic tests)
+void initializeTestEnvironmentMinimal();

test/test_adaptive_coding_rate/AdaptiveCodingRate.cpp

@@ -0,0 +1,164 @@
+#include <Arduino.h>
+#include <unity.h>
+
+#include "TestUtil.h"
+// Ensure adaptive coding rate logic is available during tests
+#ifndef USE_ADAPTIVE_CODING_RATE
+#define USE_ADAPTIVE_CODING_RATE 1
+#endif
+#include "mesh/RadioInterface.h"
+
+class TestRadio : public RadioInterface
+{
+  public:
+    bool applyForTest(const meshtastic_MeshPacket *p) { return applyAdaptiveCodingRate(p); }
+
+    uint8_t getAttempts(NodeNum from, PacketId id)
+    {
+#ifdef USE_ADAPTIVE_CODING_RATE
+        auto it = adaptiveAttempts.find(adaptiveKey(from, id));
+        return (it == adaptiveAttempts.end()) ? 0 : it->second.attempts;
+#else
+        (void)from;
+        (void)id;
+        return 0;
+#endif
+    }
+
+#ifdef USE_ADAPTIVE_CODING_RATE
+    void setAdaptiveState(NodeNum from, PacketId id, uint8_t attempts, uint32_t lastUse)
+    {
+        adaptiveAttempts[adaptiveKey(from, id)] = {attempts, lastUse};
+    }
+#endif
+
+    uint8_t currentCr() const { return cr; }
+    void setCrForTest(uint8_t value) { cr = value; }
+
+    ErrorCode send(meshtastic_MeshPacket *p) override
+    {
+        packetPool.release(p);
+        return ERRNO_OK;
+    }
+
+    uint32_t getPacketTime(uint32_t /*totalPacketLen*/, bool /*received*/ = false) override { return 0; }
+
+    bool reconfigure() override
+    {
+        reconfigureCount++;
+        lastCr = cr;
+        return true;
+    }
+
+    uint32_t reconfigureCount = 0;
+    uint8_t lastCr = 0;
+};
+
+void test_attempt_progression()
+{
+    TestRadio radio;
+    meshtastic_MeshPacket packet = {};
+    packet.from = 0xABCDEF01;
+    packet.id = 0x1;
+
+    TEST_ASSERT_FALSE(radio.applyForTest(&packet));
+    TEST_ASSERT_EQUAL_UINT8(1, radio.getAttempts(packet.from, packet.id));
+    TEST_ASSERT_EQUAL_UINT8(5, radio.currentCr());
+    TEST_ASSERT_EQUAL_UINT32(0, radio.reconfigureCount);
+
+    TEST_ASSERT_TRUE(radio.applyForTest(&packet));
+    TEST_ASSERT_EQUAL_UINT8(2, radio.getAttempts(packet.from, packet.id));
+    TEST_ASSERT_EQUAL_UINT8(7, radio.currentCr());
+    TEST_ASSERT_EQUAL_UINT32(1, radio.reconfigureCount);
+    TEST_ASSERT_EQUAL_UINT8(7, radio.lastCr);
+
+    TEST_ASSERT_TRUE(radio.applyForTest(&packet));
+    TEST_ASSERT_EQUAL_UINT8(3, radio.getAttempts(packet.from, packet.id));
+    TEST_ASSERT_EQUAL_UINT8(8, radio.currentCr());
+    TEST_ASSERT_EQUAL_UINT32(2, radio.reconfigureCount);
+    TEST_ASSERT_EQUAL_UINT8(8, radio.lastCr);
+}
+
+void test_attempts_are_per_packet()
+{
+    TestRadio radio;
+    meshtastic_MeshPacket first = {};
+    first.from = 0x1001;
+    first.id = 0xA;
+
+    meshtastic_MeshPacket second = {};
+    second.from = 0x1001;
+    second.id = 0xB;
+
+    radio.applyForTest(&first);
+    radio.applyForTest(&second);
+    radio.applyForTest(&first);
+
+    TEST_ASSERT_EQUAL_UINT8(2, radio.getAttempts(first.from, first.id));
+    TEST_ASSERT_EQUAL_UINT8(1, radio.getAttempts(second.from, second.id));
+    TEST_ASSERT_EQUAL_UINT8(7, radio.currentCr());
+}
+
+void test_clear_resets_attempts_and_rate()
+{
+    TestRadio radio;
+    meshtastic_MeshPacket packet = {};
+    packet.from = 0xCAFE;
+    packet.id = 0x55;
+
+    radio.applyForTest(&packet);
+    radio.applyForTest(&packet);
+    radio.applyForTest(&packet);
+
+    radio.reconfigureCount = 0;
+    radio.setCrForTest(8);
+    radio.clearAdaptiveCodingRateState(packet.from, packet.id);
+
+    TEST_ASSERT_TRUE(radio.applyForTest(&packet));
+    TEST_ASSERT_EQUAL_UINT8(1, radio.getAttempts(packet.from, packet.id));
+    TEST_ASSERT_EQUAL_UINT8(5, radio.currentCr());
+    TEST_ASSERT_EQUAL_UINT32(1, radio.reconfigureCount);
+}
+
+void test_prunes_expired_state()
+{
+    TestRadio radio;
+    meshtastic_MeshPacket packet = {};
+    packet.from = 0xBEEF;
+    packet.id = 0x99;
+
+    radio.applyForTest(&packet);
+#ifdef USE_ADAPTIVE_CODING_RATE
+    const uint32_t now = millis();
+    radio.setAdaptiveState(packet.from, packet.id, 3, now - (5 * 60 * 1000UL + 50));
+#endif
+    radio.reconfigureCount = 0;
+    radio.setCrForTest(5);
+
+    TEST_ASSERT_FALSE(radio.applyForTest(&packet));
+    TEST_ASSERT_EQUAL_UINT8(1, radio.getAttempts(packet.from, packet.id));
+    TEST_ASSERT_EQUAL_UINT32(0, radio.reconfigureCount);
+}
+
+void setup()
+{
+    printf("AdaptiveCodingRate test setup start\n");
+    fflush(stdout);
+    // Use minimal init to avoid pulling in SerialConsole/portduino peripherals for these logic-only tests
+    initializeTestEnvironmentMinimal();
+
+    printf("AdaptiveCodingRate test init done\n");
+    fflush(stdout);
+
+    UNITY_BEGIN();
+    RUN_TEST(test_attempt_progression);
+    RUN_TEST(test_attempts_are_per_packet);
+    RUN_TEST(test_clear_resets_attempts_and_rate);
+    RUN_TEST(test_prunes_expired_state);
+    UNITY_END();
+}
+
+void loop()
+{
+    delay(1000);
+}

variants/esp32/esp32-common.ini

@@ -38,7 +38,6 @@ build_flags =
   -DAXP_DEBUG_PORT=Serial
   -DCONFIG_BT_NIMBLE_ENABLED
   -DCONFIG_BT_NIMBLE_MAX_BONDS=6 # default is 3
-  -DCONFIG_BT_NIMBLE_ROLE_CENTRAL_DISABLED
   -DCONFIG_NIMBLE_CPP_LOG_LEVEL=2
   -DCONFIG_BT_NIMBLE_MAX_CCCDS=20
   -DCONFIG_BT_NIMBLE_HOST_TASK_STACK_SIZE=8192
@@ -61,11 +60,11 @@ 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
   # renovate: datasource=custom.pio depName=NimBLE-Arduino packageName=h2zero/library/NimBLE-Arduino
-  h2zero/NimBLE-Arduino@2.3.7
+  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=custom.pio depName=XPowersLib packageName=lewisxhe/library/XPowersLib
-  lewisxhe/XPowersLib@0.3.2
+  # renovate: datasource=github-tags depName=XPowersLib packageName=lewisxhe/XPowersLib
+  https://github.com/lewisxhe/XPowersLib/archive/v0.3.2.zip
   # 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/esp32/esp32.ini

@@ -5,4 +5,4 @@ extends = esp32_common
 custom_esp32_kind = esp32
 
 build_flags =
-  ${esp32_common.build_flags}
+  ${esp32_common.build_flags}

variants/esp32/tbeam/platformio.ini

@@ -2,7 +2,7 @@
 [env:tbeam]
 extends = esp32_base
 board = ttgo-t-beam
-board_level = extra
+
 board_check = true
 build_flags = ${esp32_base.build_flags}
   -D TBEAM_V10
@@ -13,7 +13,7 @@ upload_speed = 921600
 
 [env:tbeam-displayshield]
 extends = env:tbeam
-
+board_level = extra
 build_flags =
   ${env:tbeam.build_flags}
   -D USE_ST7796

variants/esp32c3/esp32c3.ini

@@ -4,8 +4,3 @@ custom_esp32_kind = esp32c3
 
 monitor_speed = 115200
 monitor_filters = esp32_c3_exception_decoder
-
-build_flags =
-  ${esp32_common.build_flags}
-  -DCONFIG_BT_NIMBLE_EXT_ADV=1
-  -DCONFIG_BT_NIMBLE_MAX_EXT_ADV_INSTANCES=2

variants/esp32c6/m5stack_unitc6l/platformio.ini

@@ -26,6 +26,7 @@ build_flags =
   -D HAS_BLUETOOTH=1
 	-DCONFIG_BT_NIMBLE_EXT_ADV=1
 	-DCONFIG_BT_NIMBLE_MAX_EXT_ADV_INSTANCES=2
+  -D NIMBLE_TWO
 monitor_speed=115200
 lib_ignore =
   NonBlockingRTTTL

variants/esp32s3/esp32s3.ini

@@ -3,8 +3,3 @@ extends = esp32_common
 custom_esp32_kind = esp32s3
 
 monitor_speed = 115200
-
-build_flags =
-  ${esp32_common.build_flags}
-  -DCONFIG_BT_NIMBLE_EXT_ADV=1
-  -DCONFIG_BT_NIMBLE_MAX_EXT_ADV_INSTANCES=2

variants/esp32s3/mesh-tab/variant.h

@@ -55,5 +55,6 @@
 #define SX126X_RESET 14
 #define SX126X_RXEN 47
 #define SX126X_TXEN RADIOLIB_NC // Assuming that DIO2 is connected to TXEN pin
+#define SX126X_DIO3_TCXO_VOLTAGE 1.8
 
 #endif

variants/esp32s3/rak3312/pins_arduino.h

@@ -17,6 +17,8 @@ static const uint8_t MOSI = 11;
 static const uint8_t MISO = 10;
 static const uint8_t SCK = 13;
 
+#define SPI_INTERFACES_COUNT 1
+
 #define SPI_MOSI (11)
 #define SPI_SCK (13)
 #define SPI_MISO (10)
@@ -25,4 +27,51 @@ static const uint8_t SCK = 13;
 // LEDs
 #define LED_BUILTIN LED_GREEN
 
+#ifdef _VARIANT_RAK3112_
+/*
+ * Serial interfaces
+ */
+// TXD1 RXD1 on Base Board
+#define PIN_SERIAL1_RX (44)
+#define PIN_SERIAL1_TX (43)
+
+/*
+ * Internal SPI to LoRa transceiver
+ */
+#define LORA_SX126X_SCK 5
+#define LORA_SX126X_MISO 3
+#define LORA_SX126X_MOSI 6
+
+/*
+ * Analog pins
+ */
+#define PIN_A0 (21)
+#define PIN_A1 (14)
+
+/*
+ * Wire Interfaces
+ */
+#define WIRE_INTERFACES_COUNT 2
+
+#define PIN_WIRE1_SDA (17)
+#define PIN_WIRE1_SCL (18)
+
+/*
+ * GPIO's
+ */
+#define WB_IO1 21
+#define WB_IO2 2
+// #define WB_IO2 14
+#define WB_IO3 41
+#define WB_IO4 42
+#define WB_IO5 38
+#define WB_IO6 39
+// #define WB_SW1 35 NC
+#define WB_A0 1
+#define WB_A1 2
+#define WB_CS 12
+#define WB_LED1 46
+#define WB_LED2 45
+#endif
+
 #endif /* Pins_Arduino_h */

variants/esp32s3/rak3312/platformio.ini

@@ -9,3 +9,15 @@ build_flags =
   ${esp32s3_base.build_flags}
   -D RAK3312
   -I variants/esp32s3/rak3312
+
+[env:rak3112]
+extends = esp32s3_base
+board = wiscore_rak3312
+board_level = extra
+upload_protocol = esptool
+
+build_flags =
+  ${esp32_base.build_flags}
+  -D RAK3312 
+  -D _VARIANT_RAK3112_
+  -I variants/esp32s3/rak3312

variants/esp32s3/rak3312/variant.h

@@ -18,11 +18,6 @@
 #define SX126X_DIO3_TCXO_VOLTAGE 1.8
 #endif
 
-#define SX126X_POWER_EN (4)
-
-#define PIN_POWER_EN PIN_3V3_EN
-#define PIN_3V3_EN (14)
-
 #define LED_GREEN 46
 #define LED_BLUE 45
 
@@ -35,10 +30,30 @@
 
 #define LED_STATE_ON 1 // State when LED is litted
 
+#define BATTERY_PIN 1
+#define ADC_CHANNEL ADC1_GPIO1_CHANNEL
+
+#ifdef _VARIANT_RAK3112_ //  Modular variant (stamp)
+#define ADC_MULTIPLIER 2.11
+
+#define BUTTON_NEED_PULLUP
+
+#define HAS_SDCARD
+#define SDCARD_USE_SPI1
+#define SDCARD_CS SPI_CS
+
+#define I2C_SDA1 PIN_WIRE1_SDA
+#define I2C_SCL1 PIN_WIRE1_SCL
+#else // Generic 3312 variant (40-pin standard connector)
+#define ADC_MULTIPLIER 1.667
+
+#define SX126X_POWER_EN (4)
+
+#define PIN_POWER_EN PIN_3V3_EN
+#define PIN_3V3_EN (14)
+
 #define HAS_GPS 1
 #define GPS_TX_PIN 43
 #define GPS_RX_PIN 44
 
-#define BATTERY_PIN 1
-#define ADC_CHANNEL ADC1_GPIO1_CHANNEL
-#define ADC_MULTIPLIER 1.667
+#endif

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

@@ -0,0 +1,25 @@
+#ifndef Pins_Arduino_h
+#define Pins_Arduino_h
+
+#include <stdint.h>
+
+#define USB_VID 0x303a
+#define USB_PID 0x1001
+
+static const uint8_t TX = 43;
+static const uint8_t RX = 44;
+
+// I2C for OLED and sensors
+static const uint8_t SDA = 8;
+static const uint8_t SCL = 9;
+
+// Default SPI mapped to Radio/SD
+static const uint8_t SS = 15;   // LoRa CS
+static const uint8_t MOSI = 11;
+static const uint8_t MISO = 12;
+static const uint8_t SCK = 13;
+
+// SD Card CS
+#define SDCARD_CS 10
+
+#endif /* Pins_Arduino_h */

variants/esp32s3/t-beam-1w/platformio.ini

@@ -0,0 +1,14 @@
+; LilyGo T-Beam-1W (1 Watt LoRa with external PA)
+[env:t-beam-1w]
+extends = esp32s3_base
+board = t-beam-1w
+board_build.partitions = default_8MB.csv
+board_check = true
+
+lib_deps =
+  ${esp32s3_base.lib_deps}
+
+build_flags = 
+  ${esp32s3_base.build_flags} 
+  -I variants/esp32s3/t-beam-1w
+  -D T_BEAM_1W

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

@@ -0,0 +1,97 @@
+// LilyGo T-Beam-1W variant.h  
+// Configuration based on LilyGO utilities.h and RF documentation
+
+// I2C for OLED display (SH1106 at 0x3C)
+#define I2C_SDA 8
+#define I2C_SCL 9
+
+// GPS - Quectel L76K
+#define GPS_RX_PIN 5
+#define GPS_TX_PIN 6
+#define GPS_1PPS_PIN 7
+#define GPS_WAKEUP_PIN 16  // GPS_EN_PIN in LilyGO code
+#define HAS_GPS 1
+#define GPS_BAUDRATE 9600
+
+// Buttons
+#define BUTTON_PIN 0         // BUTTON 1
+#define BUTTON_PIN_ALT 17    // BUTTON 2
+
+// SPI (shared by LoRa and SD)
+#define SPI_MOSI 11
+#define SPI_SCK 13
+#define SPI_MISO 12
+#define SPI_CS 10
+
+// SD Card
+#define HAS_SDCARD
+#define SDCARD_USE_SPI1
+#define SDCARD_CS SPI_CS
+
+// LoRa Radio - SX1262 with 1W PA
+#define USE_SX1262
+
+#define LORA_SCK SPI_SCK
+#define LORA_MISO SPI_MISO  
+#define LORA_MOSI SPI_MOSI
+#define LORA_CS 15
+#define LORA_RESET 3
+#define LORA_DIO1 1
+#define LORA_BUSY 38
+
+// CRITICAL: Radio power enable - MUST be HIGH before lora.begin()!
+// GPIO 40 powers the SX1262 + PA module via LDO
+#define SX126X_POWER_EN 40
+
+// TX power offset for external PA (0 = no offset, full SX1262 power)
+#define TX_GAIN_LORA 10
+
+#ifdef USE_SX1262
+#define SX126X_CS LORA_CS
+#define SX126X_DIO1 LORA_DIO1
+#define SX126X_BUSY LORA_BUSY
+#define SX126X_RESET LORA_RESET
+
+// RF switching configuration for 1W PA module
+// DIO2 controls PA (via SX126X_DIO2_AS_RF_SWITCH)
+// CTRL PIN (GPIO 21) controls LNA - must be HIGH during RX
+// Truth table: DIO2=1,CTRL=0 → TX (PA on, LNA off)
+//              DIO2=0,CTRL=1 → RX (PA off, LNA on)
+#define SX126X_DIO2_AS_RF_SWITCH
+#define SX126X_RXEN 21  // LNA enable - HIGH during RX
+
+// TCXO voltage - required for radio init
+#define SX126X_DIO3_TCXO_VOLTAGE 1.8
+
+#define SX126X_MAX_POWER 22
+#endif
+
+// LED
+#define LED_PIN 18
+#define LED_STATE_ON 1  // HIGH = ON
+
+// Battery ADC
+#define BATTERY_PIN 4
+#define ADC_CHANNEL ADC1_GPIO4_CHANNEL
+#define BATTERY_SENSE_SAMPLES 30
+#define ADC_MULTIPLIER 2.9333
+
+// NTC temperature sensor
+#define NTC_PIN 14
+
+// Fan control
+#define FAN_CTRL_PIN 41
+// Meshtastic standard fan control pin macro
+#define RF95_FAN_EN FAN_CTRL_PIN
+
+// PA Ramp Time - T-Beam 1W requires >800us stabilization (default is 200us)
+// Value 0x05 = RADIOLIB_SX126X_PA_RAMP_800U
+#define SX126X_PA_RAMP_US 0x05
+
+// Display - SH1106 OLED (128x64)
+#define USE_SH1106 
+#define OLED_WIDTH 128
+#define OLED_HEIGHT 64
+
+// 32768 Hz crystal present
+#define HAS_32768HZ 1

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

@@ -100,3 +100,5 @@
 #define MODEM_DTR 8
 #define MODEM_RX 10
 #define MODEM_TX 11
+
+#define HAS_PHYSICAL_KEYBOARD 1

variants/esp32s3/t-deck/variant.h

@@ -23,6 +23,7 @@
 #define SCREEN_TRANSITION_FRAMERATE 5
 #define BRIGHTNESS_DEFAULT 130 // Medium Low Brightness
 #define USE_TFTDISPLAY 1
+#define HAS_PHYSICAL_KEYBOARD 1
 
 #define HAS_TOUCHSCREEN 1
 #define SCREEN_TOUCH_INT 16

variants/esp32s3/tlora-pager/variant.h

@@ -21,6 +21,7 @@
 #define SCREEN_TRANSITION_FRAMERATE 5
 #define BRIGHTNESS_DEFAULT 130 // Medium Low Brightness
 #define USE_TFTDISPLAY 1
+#define HAS_PHYSICAL_KEYBOARD 1
 
 #define I2C_SDA SDA
 #define I2C_SCL SCL

variants/native/portduino.ini

@@ -34,6 +34,8 @@ lib_deps =
 	adafruit/Adafruit seesaw Library@1.7.9
   # renovate: datasource=git-refs depName=RAK12034-BMX160 packageName=https://github.com/RAKWireless/RAK12034-BMX160 gitBranch=main
   https://github.com/RAKWireless/RAK12034-BMX160/archive/dcead07ffa267d3c906e9ca4a1330ab989e957e2.zip
+  # renovate: datasource=custom.pio depName=adafruit/Adafruit BME680 Library packageName=adafruit/library/Adafruit BME680
+  adafruit/Adafruit BME680 Library@^2.0.5
 
 build_flags =
   ${arduino_base.build_flags}

variants/native/portduino/platformio.ini

@@ -2,6 +2,9 @@
 extends = portduino_base
 build_flags = ${portduino_base.build_flags} -I variants/native/portduino
   -I /usr/include
+  -I /opt/homebrew/include
+  -L /opt/homebrew/lib -largp
+  -DUSE_ADAPTIVE_CODING_RATE
 board = cross_platform
 board_level = extra
 lib_deps = 
@@ -9,7 +12,12 @@ 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/>
+; Disable LovyanGFX for native test builds to avoid missing macOS system headers
+lib_ignore =
+  ${portduino_base.lib_ignore}
+  LovyanGFX
+
+build_src_filter = ${portduino_base.build_src_filter}
 
 [env:native]
 extends = native_base
@@ -20,7 +28,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 +54,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 +83,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 +116,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/ELECROW-ThinkNode-M3/platformio.ini

@@ -7,6 +7,7 @@ build_flags =
   ${nrf52840_base.build_flags} 
   -Ivariants/nrf52840/ELECROW-ThinkNode-M3
   -DELECROW_ThinkNode_M3
+  -DUSE_ADAPTIVE_CODING_RATE
   -DGPS_POWER_TOGGLE
   -D CONFIG_NFCT_PINS_AS_GPIOS=1
   -L "${platformio.libdeps_dir}/${this.__env__}/bsec2/src/cortex-m4/fpv4-sp-d16-hard"
@@ -15,5 +16,5 @@ lib_deps =
   ${nrf52840_base.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=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

variants/nrf52840/ELECROW-ThinkNode-M3/variant.h

@@ -114,7 +114,8 @@ extern "C" {
 #define LR11X0_DIO_AS_RF_SWITCH
 
 // PCF8563 RTC Module
-#define PCF8563_RTC 0x51
+// REVISIT https://github.com/meshtastic/firmware/pull/9084
+// #define PCF8563_RTC 0x51
 
 #ifdef __cplusplus
 }

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

@@ -12,5 +12,5 @@ build_flags = ${nrf52840_base.build_flags}
 build_src_filter = ${nrf52_base.build_src_filter} +<../variants/nrf52840/ELECROW-ThinkNode-M6>
 lib_deps =
   ${nrf52840_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

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

@@ -41,3 +41,30 @@ void initVariant()
     pinMode(VDD_FLASH_EN, OUTPUT);
     digitalWrite(VDD_FLASH_EN, HIGH);
 }
+
+// called from main-nrf52.cpp during the cpuDeepSleep() function
+void variant_shutdown()
+{
+    // This sets the pin to OUTPUT and LOW for the pins *not* in the if block.
+    for (int pin = 0; pin < 48; pin++) {
+        if (pin == PIN_GPS_EN || pin == ADC_CTRL || pin == PIN_BUTTON1 || pin == PIN_SPI_MISO || pin == PIN_SPI_MOSI ||
+            pin == PIN_SPI_SCK) {
+            continue;
+        }
+        pinMode(pin, OUTPUT);
+        digitalWrite(pin, LOW);
+        if (pin >= 32) {
+            NRF_P1->DIRCLR = (1 << (pin - 32));
+        } else {
+            NRF_GPIO->DIRCLR = (1 << pin);
+        }
+    }
+
+    digitalWrite(PIN_GPS_EN, LOW);
+    digitalWrite(ADC_CTRL, LOW);
+    // digitalWrite(RTC_POWER, LOW);
+
+    nrf_gpio_cfg_input(PIN_BUTTON1, NRF_GPIO_PIN_PULLUP); // Configure the pin to be woken up as an input
+    nrf_gpio_pin_sense_t sense1 = NRF_GPIO_PIN_SENSE_LOW;
+    nrf_gpio_cfg_sense_set(PIN_BUTTON1, sense1);
+}

variants/nrf52840/ELECROW-ThinkNode-M6/variant.h

@@ -44,8 +44,10 @@ extern "C" {
 #define LED_BLUE -1
 #define LED_CHARGE (12)
 #define LED_PAIRING (7)
+#define PIN_LED2 LED_PAIRING
 
-#define LED_STATE_ON 1
+#define LED_STATE_ON HIGH
+#define LED_STATE_OFF LOW
 
 // USB power detection
 #define EXT_PWR_DETECT (13)
@@ -119,7 +121,8 @@ static const uint8_t A0 = PIN_A0;
 #define PIN_SERIAL2_TX (24)
 
 // PCF8563 RTC Module
-#define PCF8563_RTC 0x51
+// REVISIT https://github.com/meshtastic/firmware/pull/9084
+// #define PCF8563_RTC 0x51
 
 // SPI
 #define SPI_INTERFACES_COUNT 1

variants/nrf52840/canaryone/variant.h

@@ -103,7 +103,7 @@ static const uint8_t A0 = PIN_A0;
 #define EXTERNAL_FLASH_USE_QSPI
 
 // Add a delay on startup to allow LoRa and GPS to power up
-#define PIN_PWR_DELAY_MS 100
+#define PERIPHERAL_WARMUP_MS 100
 
 /*
  * Lora radio
@@ -178,4 +178,4 @@ static const uint8_t A0 = PIN_A0;
  *        Arduino objects - C++ only
  *----------------------------------------------------------------------------*/
 
-#endif
+#endif

variants/nrf52840/heltec_mesh_pocket/platformio.ini

@@ -9,6 +9,7 @@ build_flags = ${nrf52840_base.build_flags}
   -Ivariants/nrf52840/heltec_mesh_pocket
   -DHELTEC_MESH_POCKET
   -DHELTEC_MESH_POCKET_BATTERY_5000
+  -DUSE_ADAPTIVE_CODING_RATE
   -DUSE_EINK
   -DEINK_DISPLAY_MODEL=GxEPD2_213_B74
   -DEINK_WIDTH=250
@@ -38,6 +39,7 @@ build_flags =
   -I variants/nrf52840/heltec_mesh_pocket
   -D HELTEC_MESH_POCKET
   -D HELTEC_MESH_POCKET_BATTERY_5000
+  -DUSE_ADAPTIVE_CODING_RATE
 lib_deps =
   ${inkhud.lib_deps} ; InkHUD libs first, so we get GFXRoot instead of AdafruitGFX
   ${nrf52840_base.lib_deps}
@@ -54,6 +56,7 @@ build_flags = ${nrf52840_base.build_flags}
   -Ivariants/nrf52840/heltec_mesh_pocket
   -DHELTEC_MESH_POCKET
   -DHELTEC_MESH_POCKET_BATTERY_10000
+  -DUSE_ADAPTIVE_CODING_RATE
   -DUSE_EINK
   -DEINK_DISPLAY_MODEL=GxEPD2_213_B74
   -DEINK_WIDTH=250
@@ -83,6 +86,7 @@ build_flags =
   -I variants/nrf52840/heltec_mesh_pocket
   -D HELTEC_MESH_POCKET
   -D HELTEC_MESH_POCKET_BATTERY_10000
+  -DUSE_ADAPTIVE_CODING_RATE
 lib_deps =
   ${inkhud.lib_deps} ; InkHUD libs first, so we get GFXRoot instead of AdafruitGFX
   ${nrf52840_base.lib_deps}

variants/nrf52840/rak_wismeshtag/platformio.ini

@@ -7,6 +7,7 @@ build_flags = ${nrf52840_base.build_flags}
   -I variants/nrf52840/rak_wismeshtag
   -D WISMESH_TAG
   -D RAK_4631
+  -DUSE_ADAPTIVE_CODING_RATE
   -DRADIOLIB_EXCLUDE_SX128X=1
   -DRADIOLIB_EXCLUDE_SX127X=1
   -DRADIOLIB_EXCLUDE_LR11X0=1

variants/nrf52840/tracker-t1000-e/platformio.ini

@@ -7,6 +7,7 @@ build_flags = ${nrf52840_base.build_flags}
   -Isrc/platform/nrf52/softdevice
   -Isrc/platform/nrf52/softdevice/nrf52
   -DTRACKER_T1000_E
+  -DUSE_ADAPTIVE_CODING_RATE
   -DMESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR_EXTERNAL=1
   -DMESHTASTIC_EXCLUDE_CANNEDMESSAGES=1
   -DMESHTASTIC_EXCLUDE_SCREEN=1