Merge branch 'master' into crowpanelV2

2026-10-21 18:52:36 +10:00 · 2025-12-31 13:35:53 +01:00
parent 469abe8dec 9058ccecf9
commit 3575c48e36
91 changed files with 809 additions and 332 deletions
@@ -31,6 +31,9 @@ const char *DisplayFormatters::getModemPresetDisplayName(meshtastic_Config_LoRaC
    case meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST:
        return useShortName ? "LongF" : "LongFast";
        break;
+    case meshtastic_Config_LoRaConfig_ModemPreset_LONG_TURBO:
+        return useShortName ? "LongT" : "LongTurbo";
+        break;
    case meshtastic_Config_LoRaConfig_ModemPreset_LONG_MODERATE:
        return useShortName ? "LongM" : "LongMod";
        break;
@@ -532,8 +532,10 @@ void drawSystemScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x
    const int labelX = x;
    int barsOffset = (isHighResolution) ? 24 : 0;
 #ifdef USE_EINK
+#ifndef T_DECK_PRO
    barsOffset -= 12;
 #endif
+#endif
 #if defined(M5STACK_UNITC6L)
    const int barX = x + 45 + barsOffset;
 #else
@@ -574,7 +576,7 @@ void drawSystemScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x
 #endif
        // Value string
        display->setTextAlignment(TEXT_ALIGN_RIGHT);
-        display->drawString(SCREEN_WIDTH - 2, getTextPositions(display)[line], combinedStr);
+        display->drawString(SCREEN_WIDTH, getTextPositions(display)[line], combinedStr);
    };

    // === Memory values ===
@@ -20,12 +20,41 @@
 #include "modules/KeyVerificationModule.h"

 #include "modules/TraceRouteModule.h"
+#include <algorithm>
+#include <array>
 #include <functional>
+#include <utility>

 extern uint16_t TFT_MESH;

 namespace graphics
 {
+
+namespace
+{
+
+// Caller must ensure the provided options array outlives the banner callback.
+template <typename T, size_t N, typename Callback>
+BannerOverlayOptions createStaticBannerOptions(const char *message, const MenuOption<T> (&options)[N],
+                                               std::array<const char *, N> &labels, Callback &&onSelection)
+{
+    for (size_t i = 0; i < N; ++i) {
+        labels[i] = options[i].label;
+    }
+
+    const MenuOption<T> *optionsPtr = options;
+    auto callback = std::function<void(const MenuOption<T> &, int)>(std::forward<Callback>(onSelection));
+
+    BannerOverlayOptions bannerOptions;
+    bannerOptions.message = message;
+    bannerOptions.optionsArrayPtr = labels.data();
+    bannerOptions.optionsCount = static_cast<uint8_t>(N);
+    bannerOptions.bannerCallback = [optionsPtr, callback](int selected) -> void { callback(optionsPtr[selected], selected); };
+    return bannerOptions;
+}
+
+} // namespace
+
 menuHandler::screenMenus menuHandler::menuQueue = menu_none;
 bool test_enabled = false;
 uint8_t test_count = 0;
@@ -197,48 +226,38 @@ void menuHandler::DeviceRolePicker()

 void menuHandler::RadioPresetPicker()
 {
-    static const char *optionsArray[] = {"Back",       "LongSlow",  "LongModerate", "LongFast",  "MediumSlow",
-                                         "MediumFast", "ShortSlow", "ShortFast",    "ShortTurbo"};
-    enum optionsNumbers {
-        Back = 0,
-        radiopreset_LongSlow = 1,
-        radiopreset_LongModerate = 2,
-        radiopreset_LongFast = 3,
-        radiopreset_MediumSlow = 4,
-        radiopreset_MediumFast = 5,
-        radiopreset_ShortSlow = 6,
-        radiopreset_ShortFast = 7,
-        radiopreset_ShortTurbo = 8
-    };
-    BannerOverlayOptions bannerOptions;
-    bannerOptions.message = "Radio Preset";
-    bannerOptions.optionsArrayPtr = optionsArray;
-    bannerOptions.optionsCount = 9;
-    bannerOptions.bannerCallback = [](int selected) -> void {
-        if (selected == Back) {
-            menuHandler::menuQueue = menuHandler::lora_Menu;
-            screen->runNow();
-            return;
-        } else if (selected == radiopreset_LongSlow) {
-            config.lora.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_LONG_SLOW;
-        } else if (selected == radiopreset_LongModerate) {
-            config.lora.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_LONG_MODERATE;
-        } else if (selected == radiopreset_LongFast) {
-            config.lora.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST;
-        } else if (selected == radiopreset_MediumSlow) {
-            config.lora.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_SLOW;
-        } else if (selected == radiopreset_MediumFast) {
-            config.lora.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST;
-        } else if (selected == radiopreset_ShortSlow) {
-            config.lora.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_SHORT_SLOW;
-        } else if (selected == radiopreset_ShortFast) {
-            config.lora.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_SHORT_FAST;
-        } else if (selected == radiopreset_ShortTurbo) {
-            config.lora.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_SHORT_TURBO;
-        }
-        service->reloadConfig(SEGMENT_CONFIG);
-        rebootAtMsec = (millis() + DEFAULT_REBOOT_SECONDS * 1000);
+    static const RadioPresetOption presetOptions[] = {
+        {"Back", OptionsAction::Back},
+        {"LongTurbo", OptionsAction::Select, meshtastic_Config_LoRaConfig_ModemPreset_LONG_TURBO},
+        {"LongModerate", OptionsAction::Select, meshtastic_Config_LoRaConfig_ModemPreset_LONG_MODERATE},
+        {"LongFast", OptionsAction::Select, meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST},
+        {"MediumSlow", OptionsAction::Select, meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_SLOW},
+        {"MediumFast", OptionsAction::Select, meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST},
+        {"ShortSlow", OptionsAction::Select, meshtastic_Config_LoRaConfig_ModemPreset_SHORT_SLOW},
+        {"ShortFast", OptionsAction::Select, meshtastic_Config_LoRaConfig_ModemPreset_SHORT_FAST},
+        {"ShortTurbo", OptionsAction::Select, meshtastic_Config_LoRaConfig_ModemPreset_SHORT_TURBO},
    };
+
+    constexpr size_t presetCount = sizeof(presetOptions) / sizeof(presetOptions[0]);
+    static std::array<const char *, presetCount> presetLabels{};
+
+    auto bannerOptions =
+        createStaticBannerOptions("Radio Preset", presetOptions, presetLabels, [](const RadioPresetOption &option, int) -> void {
+            if (option.action == OptionsAction::Back) {
+                menuHandler::menuQueue = menuHandler::lora_Menu;
+                screen->runNow();
+                return;
+            }
+
+            if (!option.hasValue) {
+                return;
+            }
+
+            config.lora.modem_preset = option.value;
+            service->reloadConfig(SEGMENT_CONFIG);
+            rebootAtMsec = (millis() + DEFAULT_REBOOT_SECONDS * 1000);
+        });
+
    screen->showOverlayBanner(bannerOptions);
 }

@@ -1041,12 +1060,13 @@ void menuHandler::switchToMUIMenu()

 void menuHandler::TFTColorPickerMenu(OLEDDisplay *display)
 {
-    static const char *optionsArray[] = {"Back", "Default", "Meshtastic Green", "Yellow", "Red", "Orange", "Purple", "Teal",
-                                         "Pink", "White"};
+    static const char *optionsArray[] = {
+        "Back",  "Default", "Meshtastic Green", "Yellow", "Red", "Orange", "Purple", "Blue", "Teal", "Cyan", "Ice", "Pink",
+        "White", "Gray"};
    BannerOverlayOptions bannerOptions;
    bannerOptions.message = "Select Screen Color";
    bannerOptions.optionsArrayPtr = optionsArray;
-    bannerOptions.optionsCount = 10;
+    bannerOptions.optionsCount = 14;
    bannerOptions.bannerCallback = [display](int selected) -> void {
 #if defined(HELTEC_MESH_NODE_T114) || defined(HELTEC_VISION_MASTER_T190) || defined(T_DECK) || defined(T_LORA_PAGER) ||          \
    HAS_TFT || defined(HACKADAY_COMMUNICATOR)
@@ -1082,20 +1102,40 @@ void menuHandler::TFTColorPickerMenu(OLEDDisplay *display)
            TFT_MESH_g = 153;
            TFT_MESH_b = 255;
        } else if (selected == 7) {
-            LOG_INFO("Setting color to Teal");
-            TFT_MESH_r = 64;
-            TFT_MESH_g = 224;
-            TFT_MESH_b = 208;
+            LOG_INFO("Setting color to Blue");
+            TFT_MESH_r = 0;
+            TFT_MESH_g = 0;
+            TFT_MESH_b = 255;
        } else if (selected == 8) {
+            LOG_INFO("Setting color to Teal");
+            TFT_MESH_r = 16;
+            TFT_MESH_g = 102;
+            TFT_MESH_b = 102;
+        } else if (selected == 9) {
+            LOG_INFO("Setting color to Cyan");
+            TFT_MESH_r = 0;
+            TFT_MESH_g = 255;
+            TFT_MESH_b = 255;
+        } else if (selected == 10) {
+            LOG_INFO("Setting color to Ice");
+            TFT_MESH_r = 173;
+            TFT_MESH_g = 216;
+            TFT_MESH_b = 230;
+        } else if (selected == 11) {
            LOG_INFO("Setting color to Pink");
            TFT_MESH_r = 255;
            TFT_MESH_g = 105;
            TFT_MESH_b = 180;
-        } else if (selected == 9) {
+        } else if (selected == 12) {
            LOG_INFO("Setting color to White");
            TFT_MESH_r = 255;
            TFT_MESH_g = 255;
            TFT_MESH_b = 255;
+        } else if (selected == 13) {
+            LOG_INFO("Setting color to Gray");
+            TFT_MESH_r = 128;
+            TFT_MESH_g = 128;
+            TFT_MESH_b = 128;
        } else {
            menuQueue = system_base_menu;
            screen->runNow();
@@ -99,5 +99,24 @@ class menuHandler
    static void BluetoothToggleMenu();
 };

+/* Generic Menu Options designations  */
+enum class OptionsAction { Back, Select };
+
+template <typename T> struct MenuOption {
+    const char *label;
+    OptionsAction action;
+    bool hasValue;
+    T value;
+
+    MenuOption(const char *labelIn, OptionsAction actionIn, T valueIn)
+        : label(labelIn), action(actionIn), hasValue(true), value(valueIn)
+    {
+    }
+
+    MenuOption(const char *labelIn, OptionsAction actionIn) : label(labelIn), action(actionIn), hasValue(false), value() {}
+};
+
+using RadioPresetOption = MenuOption<meshtastic_Config_LoRaConfig_ModemPreset>;
+
 } // namespace graphics
 #endif
@@ -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
    // -----------------------------------------------------------------
@@ -53,6 +53,7 @@ typedef struct _InputEvent {
 class InputPollable
 {
  public:
+    virtual ~InputPollable() = default;
    virtual void pollOnce() = 0;
 };

@@ -3,6 +3,9 @@
 #include "RotaryEncoderImpl.h"
 #include "InputBroker.h"
 #include "RotaryEncoder.h"
+#ifdef ARCH_ESP32
+#include "sleep.h"
+#endif

 #define ORIGIN_NAME "RotaryEncoder"

@@ -11,6 +14,20 @@ RotaryEncoderImpl *rotaryEncoderImpl;
 RotaryEncoderImpl::RotaryEncoderImpl()
 {
    rotary = nullptr;
+#ifdef ARCH_ESP32
+    isFirstInit = true;
+#endif
+}
+
+RotaryEncoderImpl::~RotaryEncoderImpl()
+{
+    LOG_DEBUG("RotaryEncoderImpl destructor");
+    detachRotaryEncoderInterrupts();
+
+    if (rotary != nullptr) {
+        delete rotary;
+        rotary = nullptr;
+    }
 }

 bool RotaryEncoderImpl::init()
@@ -25,15 +42,22 @@ bool RotaryEncoderImpl::init()
    eventCcw = static_cast<input_broker_event>(moduleConfig.canned_message.inputbroker_event_ccw);
    eventPressed = static_cast<input_broker_event>(moduleConfig.canned_message.inputbroker_event_press);

-    rotary = new RotaryEncoder(moduleConfig.canned_message.inputbroker_pin_a, moduleConfig.canned_message.inputbroker_pin_b,
-                               moduleConfig.canned_message.inputbroker_pin_press);
-    rotary->resetButton();
+    if (rotary == nullptr) {
+        rotary = new RotaryEncoder(moduleConfig.canned_message.inputbroker_pin_a, moduleConfig.canned_message.inputbroker_pin_b,
+                                   moduleConfig.canned_message.inputbroker_pin_press);
+    }

-    interruptInstance = this;
-    auto interruptHandler = []() { inputBroker->requestPollSoon(interruptInstance); };
-    attachInterrupt(moduleConfig.canned_message.inputbroker_pin_a, interruptHandler, CHANGE);
-    attachInterrupt(moduleConfig.canned_message.inputbroker_pin_b, interruptHandler, CHANGE);
-    attachInterrupt(moduleConfig.canned_message.inputbroker_pin_press, interruptHandler, CHANGE);
+    attachRotaryEncoderInterrupts();
+
+#ifdef ARCH_ESP32
+    // Register callbacks for before and after lightsleep
+    // Used to detach and reattach interrupts
+    if (isFirstInit) {
+        lsObserver.observe(&notifyLightSleep);
+        lsEndObserver.observe(&notifyLightSleepEnd);
+        isFirstInit = false;
+    }
+#endif

    LOG_INFO("RotaryEncoder initialized pins(%d, %d, %d), events(%d, %d, %d)", moduleConfig.canned_message.inputbroker_pin_a,
             moduleConfig.canned_message.inputbroker_pin_b, moduleConfig.canned_message.inputbroker_pin_press, eventCw, eventCcw,
@@ -71,6 +95,50 @@ void RotaryEncoderImpl::pollOnce()
    }
 }

+void RotaryEncoderImpl::detachRotaryEncoderInterrupts()
+{
+    LOG_DEBUG("RotaryEncoderImpl detach button interrupts");
+    if (interruptInstance == this) {
+        detachInterrupt(moduleConfig.canned_message.inputbroker_pin_a);
+        detachInterrupt(moduleConfig.canned_message.inputbroker_pin_b);
+        detachInterrupt(moduleConfig.canned_message.inputbroker_pin_press);
+        interruptInstance = nullptr;
+    } else {
+        LOG_WARN("RotaryEncoderImpl: interrupts already detached");
+    }
+}
+
+void RotaryEncoderImpl::attachRotaryEncoderInterrupts()
+{
+    LOG_DEBUG("RotaryEncoderImpl attach button interrupts");
+    if (rotary != nullptr && interruptInstance == nullptr) {
+        rotary->resetButton();
+
+        interruptInstance = this;
+        auto interruptHandler = []() { inputBroker->requestPollSoon(interruptInstance); };
+        attachInterrupt(moduleConfig.canned_message.inputbroker_pin_a, interruptHandler, CHANGE);
+        attachInterrupt(moduleConfig.canned_message.inputbroker_pin_b, interruptHandler, CHANGE);
+        attachInterrupt(moduleConfig.canned_message.inputbroker_pin_press, interruptHandler, CHANGE);
+    } else {
+        LOG_WARN("RotaryEncoderImpl: interrupts already attached");
+    }
+}
+
+#ifdef ARCH_ESP32
+
+int RotaryEncoderImpl::beforeLightSleep(void *unused)
+{
+    detachRotaryEncoderInterrupts();
+    return 0; // Indicates success;
+}
+
+int RotaryEncoderImpl::afterLightSleep(esp_sleep_wakeup_cause_t cause)
+{
+    attachRotaryEncoderInterrupts();
+    return 0; // Indicates success;
+}
+#endif
+
 RotaryEncoderImpl *RotaryEncoderImpl::interruptInstance;

 #endif
@@ -8,12 +8,18 @@

 class RotaryEncoder;

-class RotaryEncoderImpl : public InputPollable
+class RotaryEncoderImpl final : public InputPollable
 {
  public:
    RotaryEncoderImpl();
-    bool init(void);
+    ~RotaryEncoderImpl() override;
+    bool init();
    virtual void pollOnce() override;
+    // Disconnect and reconnect interrupts for light sleep
+#ifdef ARCH_ESP32
+    int beforeLightSleep(void *unused);
+    int afterLightSleep(esp_sleep_wakeup_cause_t cause);
+#endif

  protected:
    static RotaryEncoderImpl *interruptInstance;
@@ -23,6 +29,21 @@ class RotaryEncoderImpl : public InputPollable
    input_broker_event eventPressed = INPUT_BROKER_NONE;

    RotaryEncoder *rotary;
+
+  private:
+#ifdef ARCH_ESP32
+    bool isFirstInit;
+#endif
+    void detachRotaryEncoderInterrupts();
+    void attachRotaryEncoderInterrupts();
+
+#ifdef ARCH_ESP32
+    // Get notified when lightsleep begins and ends
+    CallbackObserver<RotaryEncoderImpl, void *> lsObserver =
+        CallbackObserver<RotaryEncoderImpl, void *>(this, &RotaryEncoderImpl::beforeLightSleep);
+    CallbackObserver<RotaryEncoderImpl, esp_sleep_wakeup_cause_t> lsEndObserver =
+        CallbackObserver<RotaryEncoderImpl, esp_sleep_wakeup_cause_t>(this, &RotaryEncoderImpl::afterLightSleep);
+#endif
 };

 extern RotaryEncoderImpl *rotaryEncoderImpl;
@@ -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;
 }

@@ -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);
 }

@@ -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;
 }

@@ -439,6 +439,13 @@ void setup()

    LOG_INFO("\n\n//\\ E S H T /\\ S T / C\n");

+#if defined(ARCH_ESP32) && defined(BOARD_HAS_PSRAM)
+#ifndef SENSECAP_INDICATOR
+    // use PSRAM for malloc calls > 256 bytes
+    heap_caps_malloc_extmem_enable(256);
+#endif
+#endif
+
 #if defined(DEBUG_MUTE) && defined(DEBUG_PORT)
    DEBUG_PORT.printf("\r\n\r\n//\\ E S H T /\\ S T / C\r\n");
    DEBUG_PORT.printf("Version %s for %s from %s\r\n", optstr(APP_VERSION), optstr(APP_ENV), optstr(APP_REPO));
@@ -1451,8 +1458,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.
@@ -124,6 +124,10 @@ void FloodingRouter::perhapsCancelDupe(const meshtastic_MeshPacket *p)
    if (config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER_LATE && iface) {
        iface->clampToLateRebroadcastWindow(getFrom(p), p->id);
    }
+    if (config.device.role == meshtastic_Config_DeviceConfig_Role_CLIENT_BASE && iface && nodeDB &&
+        nodeDB->isFromOrToFavoritedNode(*p)) {
+        iface->clampToLateRebroadcastWindow(getFrom(p), p->id);
+    }
 }

 bool FloodingRouter::isRebroadcaster()
@@ -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;
@@ -225,4 +225,4 @@ class MeshModule
 /** set the destination and packet parameters of packet p intended as a reply to a particular "to" packet
 * This ensures that if the request packet was sent reliably, the reply is sent that way as well.
 */
-void setReplyTo(meshtastic_MeshPacket *p, const meshtastic_MeshPacket &to);
+void setReplyTo(meshtastic_MeshPacket *p, const meshtastic_MeshPacket &to);
@@ -93,11 +93,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);
@@ -276,6 +273,10 @@ bool MeshService::trySendPosition(NodeNum dest, bool wantReplies)
    if (nodeDB->hasValidPosition(node)) {
 #if HAS_GPS && !MESHTASTIC_EXCLUDE_GPS
        if (positionModule) {
+            if (!config.position.fixed_position && !nodeDB->hasLocalPositionSinceBoot()) {
+                LOG_DEBUG("Skip position ping; no fresh position since boot");
+                return false;
+            }
            LOG_INFO("Send position ping to 0x%x, wantReplies=%d, channel=%d", dest, wantReplies, node->channel);
            positionModule->sendOurPosition(dest, wantReplies, node->channel);
            return true;
@@ -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);
@@ -805,11 +805,16 @@ void NodeDB::installDefaultModuleConfig()
    moduleConfig.external_notification.output_ms = 500;
    moduleConfig.external_notification.nag_timeout = 2;
 #endif
-#if defined(RAK4630) || defined(RAK11310) || defined(RAK3312)
-    // Default to RAK led pin 2 (blue)
+#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;
+#if defined(MUZI_BASE) || defined(ELECROW_ThinkNode_M3)
+    moduleConfig.external_notification.active = false;
+#else
    moduleConfig.external_notification.active = true;
+#endif
    moduleConfig.external_notification.alert_message = true;
    moduleConfig.external_notification.output_ms = 1000;
    moduleConfig.external_notification.nag_timeout = default_ringtone_nag_secs;
@@ -1039,6 +1044,7 @@ void NodeDB::clearLocalPosition()
    node->position.altitude = 0;
    node->position.time = 0;
    setLocalPosition(meshtastic_Position_init_default);
+    localPositionUpdatedSinceBoot = false;
 }

 void NodeDB::cleanupMeshDB()
@@ -1543,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)
@@ -1795,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();
    }
@@ -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,
@@ -279,9 +283,13 @@ class NodeDB
        LOG_DEBUG("Set local position: lat=%i lon=%i time=%u timestamp=%u", position.latitude_i, position.longitude_i,
                  position.time, position.timestamp);
        localPosition = position;
+        if (position.latitude_i != 0 || position.longitude_i != 0) {
+            localPositionUpdatedSinceBoot = true;
+        }
    }

    bool hasValidPosition(const meshtastic_NodeInfoLite *n);
+    bool hasLocalPositionSinceBoot() const { return localPositionUpdatedSinceBoot; }

 #if !defined(MESHTASTIC_EXCLUDE_PKI)
    bool checkLowEntropyPublicKey(const meshtastic_Config_SecurityConfig_public_key_t &keyToTest);
@@ -301,6 +309,7 @@ class NodeDB

  private:
    bool duplicateWarned = false;
+    bool localPositionUpdatedSinceBoot = false;
    uint32_t lastNodeDbSave = 0;    // when we last saved our db to flash
    uint32_t lastBackupAttempt = 0; // when we last tried a backup automatically or manually
    uint32_t lastSort = 0;          // When last sorted the nodeDB
@@ -296,11 +296,6 @@ bool RadioInterface::shouldRebroadcastEarlyLikeRouter(meshtastic_MeshPacket *p)
        return true;
    }

-    // If we are a CLIENT_BASE and the packet is from or to a favorited node, we should rebroadcast early
-    if (config.device.role == meshtastic_Config_DeviceConfig_Role_CLIENT_BASE) {
-        return nodeDB->isFromOrToFavoritedNode(*p);
-    }
-
    return false;
 }

@@ -503,6 +498,11 @@ void RadioInterface::applyModemConfig()
                cr = 5;
                sf = 10;
                break;
+            case meshtastic_Config_LoRaConfig_ModemPreset_LONG_TURBO:
+                bw = (myRegion->wideLora) ? 1625.0 : 500;
+                cr = 8;
+                sf = 11;
+                break;
            default: // Config_LoRaConfig_ModemPreset_LONG_FAST is default. Gracefully use this is preset is something illegal.
                bw = (myRegion->wideLora) ? 812.5 : 250;
                cr = 5;
@@ -539,13 +539,26 @@ void RadioInterface::applyModemConfig()
        }

        if ((myRegion->freqEnd - myRegion->freqStart) < bw / 1000) {
-            static const char *err_string = "Regional frequency range is smaller than bandwidth. Fall back to default preset";
-            LOG_ERROR(err_string);
+            const float regionSpanKHz = (myRegion->freqEnd - myRegion->freqStart) * 1000.0f;
+            const float requestedBwKHz = bw;
+            const bool isWideRequest = requestedBwKHz >= 499.5f; // treat as 500 kHz preset
+            const char *presetName =
+                DisplayFormatters::getModemPresetDisplayName(loraConfig.modem_preset, false, loraConfig.use_preset);
+
+            char err_string[160];
+            if (isWideRequest) {
+                snprintf(err_string, sizeof(err_string), "%s region too narrow for 500kHz preset (%s). Falling back to LongFast.",
+                         myRegion->name, presetName);
+            } else {
+                snprintf(err_string, sizeof(err_string), "%s region span %.0fkHz < requested %.0fkHz. Falling back to LongFast.",
+                         myRegion->name, regionSpanKHz, requestedBwKHz);
+            }
+            LOG_ERROR("%s", err_string);
            RECORD_CRITICALERROR(meshtastic_CriticalErrorCode_INVALID_RADIO_SETTING);

            meshtastic_ClientNotification *cn = clientNotificationPool.allocZeroed();
            cn->level = meshtastic_LogRecord_Level_ERROR;
-            sprintf(cn->message, err_string);
+            snprintf(cn->message, sizeof(cn->message), "%s", err_string);
            service->sendClientNotification(cn);

            // Set to default modem preset
@@ -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
@@ -150,7 +151,9 @@ void ReliableRouter::sniffReceived(const meshtastic_MeshPacket *p, const meshtas
        PacketId nakId = (c && c->error_reason != meshtastic_Routing_Error_NONE) ? p->decoded.request_id : 0;

        // We intentionally don't check wasSeenRecently, because it is harmless to delete non existent retransmission records
-        if (ackId || nakId) {
+        if ((ackId || nakId) &&
+            // Implicit ACKs from MQTT should not stop retransmissions
+            !(isFromUs(p) && p->transport_mechanism == meshtastic_MeshPacket_TransportMechanism_TRANSPORT_MQTT)) {
            LOG_DEBUG("Received a %s for 0x%x, stopping retransmissions", ackId ? "ACK" : "NAK", ackId);
            if (ackId) {
                stopRetransmission(p->to, ackId);
@@ -37,8 +37,8 @@

 static MemoryDynamic<meshtastic_MeshPacket> dynamicPool;
 Allocator<meshtastic_MeshPacket> &packetPool = dynamicPool;
-#elif defined(ARCH_STM32WL)
-// On STM32 there isn't enough heap left over for the rest of the firmware if we allocate this statically.
+#elif defined(ARCH_STM32WL) || defined(BOARD_HAS_PSRAM)
+// On STM32 and boards with PSRAM, there isn't enough heap left over for the rest of the firmware if we allocate this statically.
 // For now, make it dynamic again.
 #define MAX_PACKETS                                                                                                              \
    (MAX_RX_TOPHONE + MAX_RX_FROMRADIO + 2 * MAX_TX_QUEUE +                                                                      \
@@ -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
    }

@@ -526,6 +525,10 @@ DecodeState perhapsDecode(meshtastic_MeshPacket *p)
 #elif ARCH_PORTDUINO
        if (portduino_config.traceFilename != "" || portduino_config.logoutputlevel == level_trace) {
            LOG_TRACE("%s", MeshPacketSerializer::JsonSerialize(p, false).c_str());
+        } else if (portduino_config.JSONFilename != "") {
+            if (portduino_config.JSONFilter == (_meshtastic_PortNum)0 || portduino_config.JSONFilter == p->decoded.portnum) {
+                JSONFile << MeshPacketSerializer::JsonSerialize(p, false) << std::endl;
+            }
        }
 #endif
        return DecodeState::DECODE_SUCCESS;
@@ -293,7 +293,8 @@ typedef enum _meshtastic_Config_LoRaConfig_RegionCode {
 typedef enum _meshtastic_Config_LoRaConfig_ModemPreset {
    /* Long Range - Fast */
    meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST = 0,
-    /* Long Range - Slow */
+    /* Long Range - Slow
+ Deprecated in 2.7: Unpopular slow preset. */
    meshtastic_Config_LoRaConfig_ModemPreset_LONG_SLOW = 1,
    /* Very Long Range - Slow
 Deprecated in 2.5: Works only with txco and is unusably slow */
@@ -311,7 +312,10 @@ typedef enum _meshtastic_Config_LoRaConfig_ModemPreset {
    /* Short Range - Turbo
 This is the fastest preset and the only one with 500kHz bandwidth.
 It is not legal to use in all regions due to this wider bandwidth. */
-    meshtastic_Config_LoRaConfig_ModemPreset_SHORT_TURBO = 8
+    meshtastic_Config_LoRaConfig_ModemPreset_SHORT_TURBO = 8,
+    /* Long Range - Turbo
+ This preset performs similarly to LongFast, but with 500Khz bandwidth. */
+    meshtastic_Config_LoRaConfig_ModemPreset_LONG_TURBO = 9
 } meshtastic_Config_LoRaConfig_ModemPreset;

 typedef enum _meshtastic_Config_BluetoothConfig_PairingMode {
@@ -689,8 +693,8 @@ extern "C" {
 #define _meshtastic_Config_LoRaConfig_RegionCode_ARRAYSIZE ((meshtastic_Config_LoRaConfig_RegionCode)(meshtastic_Config_LoRaConfig_RegionCode_BR_902+1))

 #define _meshtastic_Config_LoRaConfig_ModemPreset_MIN meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST
-#define _meshtastic_Config_LoRaConfig_ModemPreset_MAX meshtastic_Config_LoRaConfig_ModemPreset_SHORT_TURBO
-#define _meshtastic_Config_LoRaConfig_ModemPreset_ARRAYSIZE ((meshtastic_Config_LoRaConfig_ModemPreset)(meshtastic_Config_LoRaConfig_ModemPreset_SHORT_TURBO+1))
+#define _meshtastic_Config_LoRaConfig_ModemPreset_MAX meshtastic_Config_LoRaConfig_ModemPreset_LONG_TURBO
+#define _meshtastic_Config_LoRaConfig_ModemPreset_ARRAYSIZE ((meshtastic_Config_LoRaConfig_ModemPreset)(meshtastic_Config_LoRaConfig_ModemPreset_LONG_TURBO+1))

 #define _meshtastic_Config_BluetoothConfig_PairingMode_MIN meshtastic_Config_BluetoothConfig_PairingMode_RANDOM_PIN
 #define _meshtastic_Config_BluetoothConfig_PairingMode_MAX meshtastic_Config_BluetoothConfig_PairingMode_NO_PIN
@@ -417,6 +417,9 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta
    }
    case meshtastic_AdminMessage_enter_dfu_mode_request_tag: {
        LOG_INFO("Client requesting to enter DFU mode");
+#if HAS_SCREEN
+        IF_SCREEN(screen->showSimpleBanner("Device is rebooting\ninto DFU mode.", 0));
+#endif
 #if defined(ARCH_NRF52) || defined(ARCH_RP2040)
        enterDfuMode();
 #endif
@@ -217,7 +217,7 @@ void setupModules()
    }
 #endif // HAS_BUTTON
 #if ARCH_PORTDUINO
-    if (config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_COLOR) {
+    if (config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_COLOR && portduino_config.i2cdev != "") {
        seesawRotary = new SeesawRotary("SeesawRotary");
        if (!seesawRotary->init()) {
            delete seesawRotary;
@@ -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,
@@ -7,17 +7,41 @@
 #include "configuration.h"
 #include "main.h"
 #include <Throttle.h>
+#include <algorithm>
+
+#ifndef USERPREFS_NODEINFO_REPLY_SUPPRESS_SECS
+#define USERPREFS_NODEINFO_REPLY_SUPPRESS_SECS (12 * 60 * 60)
+#endif

 NodeInfoModule *nodeInfoModule;

+static constexpr uint32_t NodeInfoReplySuppressSeconds = USERPREFS_NODEINFO_REPLY_SUPPRESS_SECS;
+
 bool NodeInfoModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshtastic_User *pptr)
 {
+    suppressReplyForCurrentRequest = false;
+
    if (mp.from == nodeDB->getNodeNum()) {
        LOG_WARN("Ignoring packet supposed to be from our own node: %08x", mp.from);
        return false;
    }

    auto p = *pptr;
+
+    if (mp.decoded.want_response) {
+        const NodeNum sender = getFrom(&mp);
+        const uint32_t now = mp.rx_time ? mp.rx_time : getTime();
+        auto it = lastNodeInfoSeen.find(sender);
+        if (it != lastNodeInfoSeen.end()) {
+            uint32_t sinceLast = now >= it->second ? now - it->second : 0;
+            if (sinceLast < NodeInfoReplySuppressSeconds) {
+                suppressReplyForCurrentRequest = true;
+            }
+        }
+        lastNodeInfoSeen[sender] = now;
+        pruneLastNodeInfoCache();
+    }
+
    if (p.is_licensed != owner.is_licensed) {
        LOG_WARN("Invalid nodeInfo detected, is_licensed mismatch!");
        return true;
@@ -42,6 +66,8 @@ bool NodeInfoModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, mes
        service->sendToPhone(packetCopy);
    }

+    pruneLastNodeInfoCache();
+
    // LOG_DEBUG("did handleReceived");
    return false; // Let others look at this message also if they want
 }
@@ -68,9 +94,11 @@ void NodeInfoModule::sendOurNodeInfo(NodeNum dest, bool wantReplies, uint8_t cha

    if (p) { // Check whether we didn't ignore it
        p->to = dest;
-        p->decoded.want_response = (config.device.role != meshtastic_Config_DeviceConfig_Role_TRACKER &&
+        bool requestWantResponse = (config.device.role != meshtastic_Config_DeviceConfig_Role_TRACKER &&
                                    config.device.role != meshtastic_Config_DeviceConfig_Role_SENSOR) &&
                                   wantReplies;
+
+        p->decoded.want_response = requestWantResponse;
        if (_shorterTimeout)
            p->priority = meshtastic_MeshPacket_Priority_DEFAULT;
        else
@@ -89,6 +117,13 @@ void NodeInfoModule::sendOurNodeInfo(NodeNum dest, bool wantReplies, uint8_t cha

 meshtastic_MeshPacket *NodeInfoModule::allocReply()
 {
+    if (suppressReplyForCurrentRequest) {
+        LOG_DEBUG("Skip send NodeInfo since we heard the requester <12h ago");
+        ignoreRequest = true;
+        suppressReplyForCurrentRequest = false;
+        return NULL;
+    }
+
    if (!airTime->isTxAllowedChannelUtil(false)) {
        ignoreRequest = true; // Mark it as ignored for MeshModule
        LOG_DEBUG("Skip send NodeInfo > 40%% ch. util");
@@ -125,6 +160,29 @@ meshtastic_MeshPacket *NodeInfoModule::allocReply()
    }
 }

+void NodeInfoModule::pruneLastNodeInfoCache()
+{
+    if (!nodeDB || !nodeDB->meshNodes)
+        return;
+
+    const size_t maxEntries = nodeDB->meshNodes->size();
+
+    for (auto it = lastNodeInfoSeen.begin(); it != lastNodeInfoSeen.end();) {
+        if (!nodeDB->getMeshNode(it->first)) {
+            it = lastNodeInfoSeen.erase(it);
+        } else {
+            ++it;
+        }
+    }
+
+    while (!lastNodeInfoSeen.empty() && lastNodeInfoSeen.size() > maxEntries) {
+        auto oldestIt = std::min_element(lastNodeInfoSeen.begin(), lastNodeInfoSeen.end(),
+                                         [](const std::pair<const NodeNum, uint32_t> &lhs,
+                                            const std::pair<const NodeNum, uint32_t> &rhs) { return lhs.second < rhs.second; });
+        lastNodeInfoSeen.erase(oldestIt);
+    }
+}
+
 NodeInfoModule::NodeInfoModule()
    : ProtobufModule("nodeinfo", meshtastic_PortNum_NODEINFO_APP, &meshtastic_User_msg), concurrency::OSThread("NodeInfo")
 {
@@ -1,5 +1,6 @@
 #pragma once
 #include "ProtobufModule.h"
+#include <map>

 /**
 * NodeInfo module for sending/receiving NodeInfos into the mesh
@@ -43,6 +44,10 @@ class NodeInfoModule : public ProtobufModule<meshtastic_User>, private concurren
  private:
    uint32_t lastSentToMesh = 0; // Last time we sent our NodeInfo to the mesh
    bool shorterTimeout = false;
+    bool suppressReplyForCurrentRequest = false;
+    std::map<NodeNum, uint32_t> lastNodeInfoSeen;
+
+    void pruneLastNodeInfoCache();
 };

 extern NodeInfoModule *nodeInfoModule;
@@ -45,8 +45,12 @@ bool PositionModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, mes
 {
    auto p = *pptr;

-    // If inbound message is a replay (or spoof!) of our own messages, we shouldn't process
-    // (why use second-hand sources for our own data?)
+    const auto transport = mp.transport_mechanism;
+    if (isFromUs(&mp) && !IS_ONE_OF(transport, meshtastic_MeshPacket_TransportMechanism_TRANSPORT_INTERNAL,
+                                    meshtastic_MeshPacket_TransportMechanism_TRANSPORT_API)) {
+        LOG_WARN("Ignoring packet supposedly from us over external transport");
+        return true;
+    }

    // FIXME this can in fact happen with packets sent from EUD (src=RX_SRC_USER)
    // to set fixed location, EUD-GPS location or just the time (see also issue #900)
@@ -345,6 +349,11 @@ void PositionModule::sendOurPosition()

 void PositionModule::sendOurPosition(NodeNum dest, bool wantReplies, uint8_t channel)
 {
+    if (!config.position.fixed_position && !nodeDB->hasLocalPositionSinceBoot()) {
+        LOG_DEBUG("Skip position send; no fresh position since boot");
+        return;
+    }
+
    // cancel any not yet sent (now stale) position packets
    if (prevPacketId) // if we wrap around to zero, we'll simply fail to cancel in that rare case (no big deal)
        service->cancelSending(prevPacketId);
@@ -416,8 +425,14 @@ int32_t PositionModule::runOnce()
        return RUNONCE_INTERVAL;
    }

+    bool waitingForFreshPosition = (lastGpsSend == 0) && !config.position.fixed_position && !nodeDB->hasLocalPositionSinceBoot();
+
    if (lastGpsSend == 0 || msSinceLastSend >= intervalMs) {
-        if (nodeDB->hasValidPosition(node)) {
+        if (waitingForFreshPosition) {
+#ifdef GPS_DEBUG
+            LOG_DEBUG("Skip initial position send; no fresh position since boot");
+#endif
+        } else if (nodeDB->hasValidPosition(node)) {
            lastGpsSend = now;

            lastGpsLatitude = node->position.latitude_i;
@@ -472,19 +487,53 @@ void PositionModule::sendLostAndFoundText()
    delete[] message;
 }

+// Helper: return imprecise (truncated + centered) lat/lon as int32 using current precision
+static inline void computeImpreciseLatLon(int32_t inLat, int32_t inLon, uint8_t precisionBits, int32_t &outLat, int32_t &outLon)
+{
+    if (precisionBits > 0 && precisionBits < 32) {
+        // Build mask for top 'precisionBits' bits of a 32-bit unsigned field
+        const uint32_t mask = (precisionBits == 32) ? UINT32_MAX : (UINT32_MAX << (32 - precisionBits));
+        // Note: latitude_i/longitude_i are stored as signed 32-bit in meshtastic code but
+        // the bitmask logic used previously operated as unsigned—preserve that behavior by
+        // casting to uint32_t for masking, then back to int32_t.
+        uint32_t lat_u = static_cast<uint32_t>(inLat) & mask;
+        uint32_t lon_u = static_cast<uint32_t>(inLon) & mask;
+
+        // Add the "center of cell" offset used elsewhere:
+        // The code previously added (1 << (31 - precision)) to produce the middle of the possible location.
+        uint32_t center_offset = (1u << (31 - precisionBits));
+        lat_u += center_offset;
+        lon_u += center_offset;
+
+        outLat = static_cast<int32_t>(lat_u);
+        outLon = static_cast<int32_t>(lon_u);
+    } else {
+        // full precision: return input unchanged
+        outLat = inLat;
+        outLon = inLon;
+    }
+}
+
 struct SmartPosition PositionModule::getDistanceTraveledSinceLastSend(meshtastic_PositionLite currentPosition)
 {
-    // The minimum distance to travel before we are able to send a new position packet.
    const uint32_t distanceTravelThreshold =
        Default::getConfiguredOrDefault(config.position.broadcast_smart_minimum_distance, 100);

-    // Determine the distance in meters between two points on the globe
-    float distanceTraveledSinceLastSend = GeoCoord::latLongToMeter(
-        lastGpsLatitude * 1e-7, lastGpsLongitude * 1e-7, currentPosition.latitude_i * 1e-7, currentPosition.longitude_i * 1e-7);
+    int32_t lastLatImprecise, lastLonImprecise;
+    int32_t currentLatImprecise, currentLonImprecise;

-    return SmartPosition{.distanceTraveled = abs(distanceTraveledSinceLastSend),
+    computeImpreciseLatLon(lastGpsLatitude, lastGpsLongitude, precision, lastLatImprecise, lastLonImprecise);
+    computeImpreciseLatLon(currentPosition.latitude_i, currentPosition.longitude_i, precision, currentLatImprecise,
+                           currentLonImprecise);
+
+    float distMeters = GeoCoord::latLongToMeter(lastLatImprecise * 1e-7, lastLonImprecise * 1e-7, currentLatImprecise * 1e-7,
+                                                currentLonImprecise * 1e-7);
+
+    float distanceTraveled = fabsf(distMeters);
+
+    return SmartPosition{.distanceTraveled = distanceTraveled,
                         .distanceThreshold = distanceTravelThreshold,
-                         .hasTraveledOverThreshold = abs(distanceTraveledSinceLastSend) >= distanceTravelThreshold};
+                         .hasTraveledOverThreshold = distanceTraveled >= distanceTravelThreshold};
 }

 void PositionModule::handleNewPosition()
@@ -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
@@ -75,6 +74,12 @@ uint8_t RoutingModule::getHopLimitForResponse(uint8_t hopStart, uint8_t hopLimit
    return Default::getConfiguredOrDefaultHopLimit(config.lora.hop_limit); // Use the default hop limit
 }

+meshtastic_MeshPacket *RoutingModule::allocAckNak(meshtastic_Routing_Error err, NodeNum to, PacketId idFrom, ChannelIndex chIndex,
+                                                  uint8_t hopLimit)
+{
+    return MeshModule::allocAckNak(err, to, idFrom, chIndex, hopLimit);
+}
+
 RoutingModule::RoutingModule() : ProtobufModule("routing", meshtastic_PortNum_ROUTING_APP, &meshtastic_Routing_msg)
 {
    isPromiscuous = true;
@@ -16,8 +16,11 @@ class RoutingModule : public ProtobufModule<meshtastic_Routing>
    virtual void sendAckNak(meshtastic_Routing_Error err, NodeNum to, PacketId idFrom, ChannelIndex chIndex, uint8_t hopLimit = 0,
                            bool ackWantsAck = false);

+    meshtastic_MeshPacket *allocAckNak(meshtastic_Routing_Error err, NodeNum to, PacketId idFrom, ChannelIndex chIndex,
+                                       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;
@@ -20,13 +20,17 @@ 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;
            }
        } else {
-            power_state = discharging;
+            if (powerStatus->getBatteryChargePercent() > 5) {
+                power_state = discharging;
+            } else {
+                power_state = critical;
+            }
        }
        break;
    }
@@ -58,16 +62,33 @@ int StatusLEDModule::handleStatusUpdate(const meshtastic::Status *arg)

 int32_t StatusLEDModule::runOnce()
 {
+    my_interval = 1000;

    if (power_state == charging) {
        CHARGE_LED_state = !CHARGE_LED_state;
    } else if (power_state == charged) {
        CHARGE_LED_state = LED_STATE_ON;
+    } else if (power_state == critical) {
+        if (POWER_LED_starttime + 30000 < millis() && !doing_fast_blink) {
+            doing_fast_blink = true;
+            POWER_LED_starttime = millis();
+        }
+        if (doing_fast_blink) {
+            PAIRING_LED_state = LED_STATE_OFF;
+            CHARGE_LED_state = !CHARGE_LED_state;
+            my_interval = 250;
+            if (POWER_LED_starttime + 2000 < millis()) {
+                doing_fast_blink = false;
+            }
+        } else {
+            CHARGE_LED_state = LED_STATE_OFF;
+        }
+
    } else {
        CHARGE_LED_state = LED_STATE_OFF;
    }

-    if (!config.bluetooth.enabled || PAIRING_LED_starttime + 30 * 1000 < millis()) {
+    if (!config.bluetooth.enabled || PAIRING_LED_starttime + 30 * 1000 < millis() || doing_fast_blink) {
        PAIRING_LED_state = LED_STATE_OFF;
    } else if (ble_state == unpaired) {
        if (slowTrack) {
@@ -31,8 +31,10 @@ class StatusLEDModule : private concurrency::OSThread
    bool PAIRING_LED_state = LED_STATE_OFF;

    uint32_t PAIRING_LED_starttime = 0;
+    uint32_t POWER_LED_starttime = 0;
+    bool doing_fast_blink = false;

-    enum PowerState { discharging, charging, charged };
+    enum PowerState { discharging, charging, charged, critical };

    PowerState power_state = discharging;

@@ -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;
@@ -87,10 +87,13 @@ inline void onReceiveProto(char *topic, byte *payload, size_t length)
        // Generate an implicit ACK towards ourselves (handled and processed only locally!) for this message.
        // We do this because packets are not rebroadcasted back into MQTT anymore and we assume that at least one node
        // receives it when we get our own packet back. Then we'll stop our retransmissions.
-        if (isFromUs(e.packet))
-            routingModule->sendAckNak(meshtastic_Routing_Error_NONE, getFrom(e.packet), e.packet->id, ch.index);
-        else
+        if (isFromUs(e.packet)) {
+            auto pAck = routingModule->allocAckNak(meshtastic_Routing_Error_NONE, getFrom(e.packet), e.packet->id, ch.index);
+            pAck->transport_mechanism = meshtastic_MeshPacket_TransportMechanism_TRANSPORT_MQTT;
+            router->sendLocal(pAck);
+        } else {
            LOG_INFO("Ignore downlink message we originally sent");
+        }
        return;
    }
    if (isFromUs(e.packet)) {
@@ -64,16 +64,6 @@ void onConnect(uint16_t conn_handle)
    connection->getPeerName(central_name, sizeof(central_name));
    LOG_INFO("BLE Connected to %s", central_name);

-    // negotiate connections params as soon as possible
-
-    ble_gap_conn_params_t newParams;
-    newParams.min_conn_interval = 24;
-    newParams.max_conn_interval = 40;
-    newParams.slave_latency = 5;
-    newParams.conn_sup_timeout = 400;
-
-    sd_ble_gap_conn_param_update(conn_handle, &newParams);
-
    // Notify UI (or any other interested firmware components)
    meshtastic::BluetoothStatus newStatus(meshtastic::BluetoothStatus::ConnectionState::CONNECTED);
    bluetoothStatus->updateStatus(&newStatus);
@@ -129,7 +119,7 @@ void startAdv(void)
    Bluefruit.Advertising.addService(meshBleService);
    /* Start Advertising
     * - Enable auto advertising if disconnected
-     * - Interval:  fast mode = 20 ms, slow mode = 417,5 ms
+     * - Interval:  fast mode = 20 ms, slow mode = 152.5 ms
     * - Timeout for fast mode is 30 seconds
     * - Start(timeout) with timeout = 0 will advertise forever (until connected)
     *
@@ -137,7 +127,7 @@ void startAdv(void)
     * https://developer.apple.com/library/content/qa/qa1931/_index.html
     */
    Bluefruit.Advertising.restartOnDisconnect(true);
-    Bluefruit.Advertising.setInterval(32, 668); // in unit of 0.625 ms
+    Bluefruit.Advertising.setInterval(32, 244); // in unit of 0.625 ms
    Bluefruit.Advertising.setFastTimeout(30);   // number of seconds in fast mode
    Bluefruit.Advertising.start(0); // 0 = Don't stop advertising after n seconds.  FIXME, we should stop advertising after X
 }
@@ -282,24 +272,6 @@ void NRF52Bluetooth::setup()
    // Set the connect/disconnect callback handlers
    Bluefruit.Periph.setConnectCallback(onConnect);
    Bluefruit.Periph.setDisconnectCallback(onDisconnect);
-
-    // Set slave latency to 5 to conserve power
-    // Despite name this does not impact data transfer
-    // https://docs.silabs.com/bluetooth/2.13/bluetooth-general-system-and-performance/optimizing-current-consumption-in-bluetooth-low-energy-devices
-    
-    Bluefruit.Periph.setConnSlaveLatency(5);
-
-    // TODO: Adafruit defaul min, max interval seems to be (20,30) [in 1.25 ms units] -> (25.00, 31.25) milliseconds
-    // so using formula Interval Max * (Slave Latency + 1) ≤ 2 seconds
-    // max slave latency we can use is 30 (max available in BLE)
-    // and even double max inteval (see apple doc linked above for formulas)
-    // See Periph.SetConnInterval method
-
-    // Tweak this later for even more power savings once those changes are confirmed to work well.
-    // Changing min, max interval may slow BLE transfer a bit - bumping slave latency will most likely not.
-
-
-
 #ifndef BLE_DFU_SECURE
    bledfu.setPermission(SECMODE_ENC_WITH_MITM, SECMODE_ENC_WITH_MITM);
    bledfu.begin(); // Install the DFU helper
@@ -328,7 +300,7 @@ void NRF52Bluetooth::setup()
 void NRF52Bluetooth::resumeAdvertising()
 {
    Bluefruit.Advertising.restartOnDisconnect(true);
-    Bluefruit.Advertising.setInterval(32, 668); // in unit of 0.625 ms
+    Bluefruit.Advertising.setInterval(32, 244); // in unit of 0.625 ms
    Bluefruit.Advertising.setFastTimeout(30);   // number of seconds in fast mode
    Bluefruit.Advertising.start(0);
 }
@@ -337,7 +337,7 @@ void cpuDeepSleep(uint32_t msecToWake)
 #endif

 #ifdef TTGO_T_ECHO
-    // To power off the T-Echo, the display must be set 
+    // To power off the T-Echo, the display must be set
    // as an input pin; otherwise, there will be leakage current.
    pinMode(PIN_EINK_CS, INPUT);
    pinMode(PIN_EINK_DC, INPUT);
@@ -29,6 +29,7 @@

 portduino_config_struct portduino_config;
 std::ofstream traceFile;
+std::ofstream JSONFile;
 Ch341Hal *ch341Hal = nullptr;
 char *configPath = nullptr;
 char *optionMac = nullptr;
@@ -278,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;
@@ -463,6 +464,7 @@ void portduinoSetup()
    if (portduino_config.lora_spi_dev != "" && portduino_config.lora_spi_dev != "ch341") {
        SPI.begin(portduino_config.lora_spi_dev.c_str());
    }
+
    if (portduino_config.traceFilename != "") {
        try {
            traceFile.open(portduino_config.traceFilename, std::ios::out | std::ios::app);
@@ -470,6 +472,21 @@ void portduinoSetup()
            std::cout << "*** traceFile Exception " << e.what() << std::endl;
            exit(EXIT_FAILURE);
        }
+        if (!traceFile.is_open()) {
+            std::cout << "*** traceFile open failure" << std::endl;
+            exit(EXIT_FAILURE);
+        }
+    } else if (portduino_config.JSONFilename != "") {
+        try {
+            JSONFile.open(portduino_config.JSONFilename, std::ios::out | std::ios::app);
+        } catch (std::ofstream::failure &e) {
+            std::cout << "*** JSONFile Exception " << e.what() << std::endl;
+            exit(EXIT_FAILURE);
+        }
+        if (!JSONFile.is_open()) {
+            std::cout << "*** JSONFile open failure" << std::endl;
+            exit(EXIT_FAILURE);
+        }
    }
    if (verboseEnabled && portduino_config.logoutputlevel != level_trace) {
        portduino_config.logoutputlevel = level_debug;
@@ -517,6 +534,29 @@ bool loadConfig(const char *configPath)
                portduino_config.logoutputlevel = level_error;
            }
            portduino_config.traceFilename = yamlConfig["Logging"]["TraceFile"].as<std::string>("");
+            portduino_config.JSONFilename = yamlConfig["Logging"]["JSONFile"].as<std::string>("");
+            portduino_config.JSONFilter = (_meshtastic_PortNum)yamlConfig["Logging"]["JSONFilter"].as<int>(0);
+            if (yamlConfig["Logging"]["JSONFilter"].as<std::string>("") == "textmessage")
+                portduino_config.JSONFilter = meshtastic_PortNum_TEXT_MESSAGE_APP;
+            else if (yamlConfig["Logging"]["JSONFilter"].as<std::string>("") == "telemetry")
+                portduino_config.JSONFilter = meshtastic_PortNum_TELEMETRY_APP;
+            else if (yamlConfig["Logging"]["JSONFilter"].as<std::string>("") == "nodeinfo")
+                portduino_config.JSONFilter = meshtastic_PortNum_NODEINFO_APP;
+            else if (yamlConfig["Logging"]["JSONFilter"].as<std::string>("") == "position")
+                portduino_config.JSONFilter = meshtastic_PortNum_POSITION_APP;
+            else if (yamlConfig["Logging"]["JSONFilter"].as<std::string>("") == "waypoint")
+                portduino_config.JSONFilter = meshtastic_PortNum_WAYPOINT_APP;
+            else if (yamlConfig["Logging"]["JSONFilter"].as<std::string>("") == "neighborinfo")
+                portduino_config.JSONFilter = meshtastic_PortNum_NEIGHBORINFO_APP;
+            else if (yamlConfig["Logging"]["JSONFilter"].as<std::string>("") == "traceroute")
+                portduino_config.JSONFilter = meshtastic_PortNum_TRACEROUTE_APP;
+            else if (yamlConfig["Logging"]["JSONFilter"].as<std::string>("") == "detection")
+                portduino_config.JSONFilter = meshtastic_PortNum_DETECTION_SENSOR_APP;
+            else if (yamlConfig["Logging"]["JSONFilter"].as<std::string>("") == "paxcounter")
+                portduino_config.JSONFilter = meshtastic_PortNum_PAXCOUNTER_APP;
+            else if (yamlConfig["Logging"]["JSONFilter"].as<std::string>("") == "remotehardware")
+                portduino_config.JSONFilter = meshtastic_PortNum_REMOTE_HARDWARE_APP;
+
            if (yamlConfig["Logging"]["AsciiLogs"]) {
                // Default is !isatty(1) but can be set explicitly in config.yaml
                portduino_config.ascii_logs = yamlConfig["Logging"]["AsciiLogs"].as<bool>();
@@ -827,4 +867,4 @@ void readGPIOFromYaml(YAML::Node sourceNode, pinMapping &destPin, int pinDefault
        destPin.line = destPin.pin;
        destPin.gpiochip = portduino_config.lora_default_gpiochip;
    }
-}
+}
@@ -5,6 +5,7 @@

 #include "LR11x0Interface.h"
 #include "Module.h"
+#include "mesh/generated/meshtastic/mesh.pb.h"
 #include "platform/portduino/USBHal.h"
 #include "yaml-cpp/yaml.h"

@@ -46,6 +47,8 @@ struct pinMapping {
 };

 extern std::ofstream traceFile;
+extern std::ofstream JSONFile;
+
 extern Ch341Hal *ch341Hal;
 int initGPIOPin(int pinNum, std::string gpioChipname, int line);
 bool loadConfig(const char *configPath);
@@ -148,6 +151,9 @@ extern struct portduino_config_struct {
    bool ascii_logs = !isatty(1);
    bool ascii_logs_explicit = false;

+    std::string JSONFilename;
+    meshtastic_PortNum JSONFilter = (_meshtastic_PortNum)0;
+
    // Webserver
    std::string webserver_root_path = "";
    std::string webserver_ssl_key_path = "/etc/meshtasticd/ssl/private_key.pem";
@@ -413,6 +419,29 @@ extern struct portduino_config_struct {
        }
        if (traceFilename != "")
            out << YAML::Key << "TraceFile" << YAML::Value << traceFilename;
+        if (JSONFilename != "") {
+            out << YAML::Key << "JSONFile" << YAML::Value << JSONFilename;
+            if (JSONFilter == meshtastic_PortNum_TEXT_MESSAGE_APP)
+                out << YAML::Key << "JSONFilter" << YAML::Value << "textmessage";
+            else if (JSONFilter == meshtastic_PortNum_TELEMETRY_APP)
+                out << YAML::Key << "JSONFilter" << YAML::Value << "telemetry";
+            else if (JSONFilter == meshtastic_PortNum_NODEINFO_APP)
+                out << YAML::Key << "JSONFilter" << YAML::Value << "nodeinfo";
+            else if (JSONFilter == meshtastic_PortNum_POSITION_APP)
+                out << YAML::Key << "JSONFilter" << YAML::Value << "position";
+            else if (JSONFilter == meshtastic_PortNum_WAYPOINT_APP)
+                out << YAML::Key << "JSONFilter" << YAML::Value << "waypoint";
+            else if (JSONFilter == meshtastic_PortNum_NEIGHBORINFO_APP)
+                out << YAML::Key << "JSONFilter" << YAML::Value << "neighborinfo";
+            else if (JSONFilter == meshtastic_PortNum_TRACEROUTE_APP)
+                out << YAML::Key << "JSONFilter" << YAML::Value << "traceroute";
+            else if (JSONFilter == meshtastic_PortNum_DETECTION_SENSOR_APP)
+                out << YAML::Key << "JSONFilter" << YAML::Value << "detection";
+            else if (JSONFilter == meshtastic_PortNum_PAXCOUNTER_APP)
+                out << YAML::Key << "JSONFilter" << YAML::Value << "paxcounter";
+            else if (JSONFilter == meshtastic_PortNum_REMOTE_HARDWARE_APP)
+                out << YAML::Key << "JSONFilter" << YAML::Value << "remotehardware";
+        }
        if (ascii_logs_explicit) {
            out << YAML::Key << "AsciiLogs" << YAML::Value << ascii_logs;
        }
@@ -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);
@@ -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;