Merge branch 'master' into NextHopRouter

2026-01-21 09:17:29 +00:00 · 2024-06-19 18:00:27 +02:00
parent d4ef0cdba5 8fa0911ec8
commit b8e01b4044
322 changed files with 18819 additions and 1230 deletions
--- a/src/mesh/InterfacesTemplates.cpp
+++ b/src/mesh/InterfacesTemplates.cpp
@@ -1,3 +1,5 @@
+#include "LR11x0Interface.cpp"
+#include "LR11x0Interface.h"
 #include "SX126xInterface.cpp"
 #include "SX126xInterface.h"
 #include "SX128xInterface.cpp"
@@ -10,6 +12,8 @@ template class SX126xInterface<SX1262>;
 template class SX126xInterface<SX1268>;
 template class SX126xInterface<LLCC68>;
 template class SX128xInterface<SX1280>;
+template class LR11x0Interface<LR1110>;
+template class LR11x0Interface<LR1120>;
 #ifdef ARCH_STM32WL
 template class SX126xInterface<STM32WLx>;
 #endif
--- a/src/mesh/LR1110Interface.cpp
+++ b/src/mesh/LR1110Interface.cpp
@@ -0,0 +1,9 @@
+#include "LR1110Interface.h"
+#include "configuration.h"
+#include "error.h"
+
+LR1110Interface::LR1110Interface(LockingArduinoHal *hal, RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst,
+                                 RADIOLIB_PIN_TYPE busy)
+    : LR11x0Interface(hal, cs, irq, rst, busy)
+{
+}
--- a/src/mesh/LR1110Interface.h
+++ b/src/mesh/LR1110Interface.h
@@ -0,0 +1,13 @@
+#pragma once
+
+#include "LR11x0Interface.h"
+
+/**
+ * Our adapter for LR1110 radios
+ */
+class LR1110Interface : public LR11x0Interface<LR1110>
+{
+  public:
+    LR1110Interface(LockingArduinoHal *hal, RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst,
+                    RADIOLIB_PIN_TYPE busy);
+};
--- a/src/mesh/LR1120Interface.cpp
+++ b/src/mesh/LR1120Interface.cpp
@@ -0,0 +1,9 @@
+#include "LR1120Interface.h"
+#include "configuration.h"
+#include "error.h"
+
+LR1120Interface::LR1120Interface(LockingArduinoHal *hal, RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst,
+                                 RADIOLIB_PIN_TYPE busy)
+    : LR11x0Interface(hal, cs, irq, rst, busy)
+{
+}
--- a/src/mesh/LR1120Interface.h
+++ b/src/mesh/LR1120Interface.h
@@ -0,0 +1,13 @@
+#pragma once
+
+#include "LR11x0Interface.h"
+
+/**
+ * Our adapter for LR1120 wideband radios
+ */
+class LR1120Interface : public LR11x0Interface<LR1120>
+{
+  public:
+    LR1120Interface(LockingArduinoHal *hal, RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst,
+                    RADIOLIB_PIN_TYPE busy);
+};
--- a/src/mesh/LR11x0Interface.cpp
+++ b/src/mesh/LR11x0Interface.cpp
@@ -0,0 +1,299 @@
+#include "LR11x0Interface.h"
+#include "configuration.h"
+#include "error.h"
+#include "mesh/NodeDB.h"
+#ifdef ARCH_PORTDUINO
+#include "PortduinoGlue.h"
+#endif
+
+// Particular boards might define a different max power based on what their hardware can do, default to max power output if not
+// specified (may be dangerous if using external PA and LR11x0 power config forgotten)
+#ifndef LR11X0_MAX_POWER
+#define LR11X0_MAX_POWER 22
+#endif
+
+template <typename T>
+LR11x0Interface<T>::LR11x0Interface(LockingArduinoHal *hal, RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst,
+                                    RADIOLIB_PIN_TYPE busy)
+    : RadioLibInterface(hal, cs, irq, rst, busy, &lora), lora(&module)
+{
+    LOG_WARN("LR11x0Interface(cs=%d, irq=%d, rst=%d, busy=%d)\n", cs, irq, rst, busy);
+}
+
+/// Initialise the Driver transport hardware and software.
+/// Make sure the Driver is properly configured before calling init().
+/// \return true if initialisation succeeded.
+template <typename T> bool LR11x0Interface<T>::init()
+{
+#ifdef LR11X0_POWER_EN
+    pinMode(LR11X0_POWER_EN, OUTPUT);
+    digitalWrite(LR11X0_POWER_EN, HIGH);
+#endif
+
+// FIXME: correct logic to default to not using TCXO if no voltage is specified for LR11x0_DIO3_TCXO_VOLTAGE
+#if !defined(LR11X0_DIO3_TCXO_VOLTAGE)
+    float tcxoVoltage =
+        0; // "TCXO reference voltage to be set on DIO3. Defaults to 1.6 V, set to 0 to skip." per
+           // https://github.com/jgromes/RadioLib/blob/690a050ebb46e6097c5d00c371e961c1caa3b52e/src/modules/LR11x0/LR11x0.h#L471C26-L471C104
+    // (DIO3 is free to be used as an IRQ)
+    LOG_DEBUG("LR11X0_DIO3_TCXO_VOLTAGE not defined, not using DIO3 as TCXO reference voltage\n");
+#else
+    float tcxoVoltage = LR11X0_DIO3_TCXO_VOLTAGE;
+    LOG_DEBUG("LR11X0_DIO3_TCXO_VOLTAGE defined, using DIO3 as TCXO reference voltage at %f V\n", LR11X0_DIO3_TCXO_VOLTAGE);
+    // (DIO3 is not free to be used as an IRQ)
+#endif
+
+    RadioLibInterface::init();
+
+    if (power > LR11X0_MAX_POWER) // Clamp power to maximum defined level
+        power = LR11X0_MAX_POWER;
+
+    limitPower();
+
+    // set RF switch configuration for Wio WM1110
+    // Wio WM1110 uses DIO5 and DIO6 for RF switching
+    // NOTE: other boards may be different. If you are
+    // using a different board, you may need to wrap
+    // this in a conditional.
+
+    static const uint32_t rfswitch_dio_pins[] = {RADIOLIB_LR11X0_DIO5, RADIOLIB_LR11X0_DIO6, RADIOLIB_NC, RADIOLIB_NC,
+                                                 RADIOLIB_NC};
+
+    static const Module::RfSwitchMode_t rfswitch_table[] = {
+        // mode                  DIO5  DIO6
+        {LR11x0::MODE_STBY, {LOW, LOW}},  {LR11x0::MODE_RX, {HIGH, LOW}},
+        {LR11x0::MODE_TX, {HIGH, HIGH}},  {LR11x0::MODE_TX_HP, {LOW, HIGH}},
+        {LR11x0::MODE_TX_HF, {LOW, LOW}}, {LR11x0::MODE_GNSS, {LOW, LOW}},
+        {LR11x0::MODE_WIFI, {LOW, LOW}},  END_OF_MODE_TABLE,
+    };
+
+// We need to do this before begin() call
+#ifdef LR11X0_DIO_AS_RF_SWITCH
+    LOG_DEBUG("Setting DIO RF switch\n");
+    bool dioAsRfSwitch = true;
+#elif defined(ARCH_PORTDUINO)
+    bool dioAsRfSwitch = false;
+    if (settingsMap[dio2_as_rf_switch]) {
+        LOG_DEBUG("Setting DIO RF switch\n");
+        dioAsRfSwitch = true;
+    }
+#else
+    bool dioAsRfSwitch = false;
+#endif
+
+    if (dioAsRfSwitch)
+        lora.setRfSwitchTable(rfswitch_dio_pins, rfswitch_table);
+
+    int res = lora.begin(getFreq(), bw, sf, cr, syncWord, power, preambleLength, tcxoVoltage);
+    // \todo Display actual typename of the adapter, not just `LR11x0`
+    LOG_INFO("LR11x0 init result %d\n", res);
+    if (res == RADIOLIB_ERR_CHIP_NOT_FOUND)
+        return false;
+
+    LOG_INFO("Frequency set to %f\n", getFreq());
+    LOG_INFO("Bandwidth set to %f\n", bw);
+    LOG_INFO("Power output set to %d\n", power);
+
+    if (res == RADIOLIB_ERR_NONE)
+        res = lora.setCRC(2);
+
+    // FIXME: May want to set depending on a definition, currently all LR1110 variant files use the DC-DC regulator option
+    if (res == RADIOLIB_ERR_NONE)
+        res = lora.setRegulatorDCDC();
+
+    if (res == RADIOLIB_ERR_NONE) {
+        if (config.lora.sx126x_rx_boosted_gain) { // the name is unfortunate but historically accurate
+            res = lora.setRxBoostedGainMode(true);
+            LOG_INFO("Set RX gain to boosted mode; result: %d\n", res);
+        } else {
+            res = lora.setRxBoostedGainMode(false);
+            LOG_INFO("Set RX gain to power saving mode (boosted mode off); result: %d\n", res);
+        }
+    }
+
+    if (res == RADIOLIB_ERR_NONE)
+        startReceive(); // start receiving
+
+    return res == RADIOLIB_ERR_NONE;
+}
+
+template <typename T> bool LR11x0Interface<T>::reconfigure()
+{
+    RadioLibInterface::reconfigure();
+
+    // set mode to standby
+    setStandby();
+
+    // configure publicly accessible settings
+    int err = lora.setSpreadingFactor(sf);
+    if (err != RADIOLIB_ERR_NONE)
+        RECORD_CRITICALERROR(meshtastic_CriticalErrorCode_INVALID_RADIO_SETTING);
+
+    err = lora.setBandwidth(bw);
+    if (err != RADIOLIB_ERR_NONE)
+        RECORD_CRITICALERROR(meshtastic_CriticalErrorCode_INVALID_RADIO_SETTING);
+
+    err = lora.setCodingRate(cr);
+    if (err != RADIOLIB_ERR_NONE)
+        RECORD_CRITICALERROR(meshtastic_CriticalErrorCode_INVALID_RADIO_SETTING);
+
+    // Hmm - seems to lower SNR when the signal levels are high.  Leaving off for now...
+    // TODO: Confirm gain registers are okay now
+    // err = lora.setRxGain(true);
+    // assert(err == RADIOLIB_ERR_NONE);
+
+    err = lora.setSyncWord(syncWord);
+    assert(err == RADIOLIB_ERR_NONE);
+
+    err = lora.setPreambleLength(preambleLength);
+    assert(err == RADIOLIB_ERR_NONE);
+
+    err = lora.setFrequency(getFreq());
+    if (err != RADIOLIB_ERR_NONE)
+        RECORD_CRITICALERROR(meshtastic_CriticalErrorCode_INVALID_RADIO_SETTING);
+
+    if (power > LR11X0_MAX_POWER) // This chip has lower power limits than some
+        power = LR11X0_MAX_POWER;
+
+    err = lora.setOutputPower(power);
+    assert(err == RADIOLIB_ERR_NONE);
+
+    startReceive(); // restart receiving
+
+    return RADIOLIB_ERR_NONE;
+}
+
+template <typename T> void INTERRUPT_ATTR LR11x0Interface<T>::disableInterrupt()
+{
+    lora.clearIrqAction();
+}
+
+template <typename T> void LR11x0Interface<T>::setStandby()
+{
+    checkNotification(); // handle any pending interrupts before we force standby
+
+    int err = lora.standby();
+
+    if (err != RADIOLIB_ERR_NONE) {
+        LOG_DEBUG("LR11x0 standby failed with error %d\n", err);
+    }
+
+    assert(err == RADIOLIB_ERR_NONE);
+
+    isReceiving = false; // If we were receiving, not any more
+    activeReceiveStart = 0;
+    disableInterrupt();
+    completeSending(); // If we were sending, not anymore
+}
+
+/**
+ * Add SNR data to received messages
+ */
+template <typename T> void LR11x0Interface<T>::addReceiveMetadata(meshtastic_MeshPacket *mp)
+{
+    // LOG_DEBUG("PacketStatus %x\n", lora.getPacketStatus());
+    mp->rx_snr = lora.getSNR();
+    mp->rx_rssi = lround(lora.getRSSI());
+}
+
+/** We override to turn on transmitter power as needed.
+ */
+template <typename T> void LR11x0Interface<T>::configHardwareForSend()
+{
+    RadioLibInterface::configHardwareForSend();
+}
+
+// For power draw measurements, helpful to force radio to stay sleeping
+// #define SLEEP_ONLY
+
+template <typename T> void LR11x0Interface<T>::startReceive()
+{
+#ifdef SLEEP_ONLY
+    sleep();
+#else
+
+    setStandby();
+
+    lora.setPreambleLength(preambleLength); // Solve RX ack fail after direct message sent.  Not sure why this is needed.
+
+    // We use a 16 bit preamble so this should save some power by letting radio sit in standby mostly.
+    // Furthermore, we need the PREAMBLE_DETECTED and HEADER_VALID IRQ flag to detect whether we are actively receiving
+    int err = lora.startReceive(
+        RADIOLIB_LR11X0_RX_TIMEOUT_INF, RADIOLIB_LR11X0_IRQ_RX_DONE,
+        0); // only RX_DONE IRQ is needed, we'll check for PREAMBLE_DETECTED and HEADER_VALID in isActivelyReceiving
+    assert(err == RADIOLIB_ERR_NONE);
+
+    isReceiving = true;
+
+    // Must be done AFTER, starting transmit, because startTransmit clears (possibly stale) interrupt pending register bits
+    enableInterrupt(isrRxLevel0);
+#endif
+}
+
+/** Is the channel currently active? */
+template <typename T> bool LR11x0Interface<T>::isChannelActive()
+{
+    // check if we can detect a LoRa preamble on the current channel
+    int16_t result;
+
+    setStandby();
+    result = lora.scanChannel();
+    if (result == RADIOLIB_LORA_DETECTED)
+        return true;
+
+    assert(result != RADIOLIB_ERR_WRONG_MODEM);
+
+    return false;
+}
+
+/** Could we send right now (i.e. either not actively receiving or transmitting)? */
+template <typename T> bool LR11x0Interface<T>::isActivelyReceiving()
+{
+    // The IRQ status will be cleared when we start our read operation. Check if we've started a header, but haven't yet
+    // received and handled the interrupt for reading the packet/handling errors.
+
+    uint16_t irq = lora.getIrqStatus();
+    bool detected = (irq & (RADIOLIB_LR11X0_IRQ_SYNC_WORD_HEADER_VALID | RADIOLIB_LR11X0_IRQ_PREAMBLE_DETECTED));
+    // Handle false detections
+    if (detected) {
+        uint32_t now = millis();
+        if (!activeReceiveStart) {
+            activeReceiveStart = now;
+        } else if ((now - activeReceiveStart > 2 * preambleTimeMsec) && !(irq & RADIOLIB_LR11X0_IRQ_SYNC_WORD_HEADER_VALID)) {
+            // The HEADER_VALID flag should be set by now if it was really a packet, so ignore PREAMBLE_DETECTED flag
+            activeReceiveStart = 0;
+            LOG_DEBUG("Ignore false preamble detection.\n");
+            return false;
+        } else if (now - activeReceiveStart > maxPacketTimeMsec) {
+            // We should have gotten an RX_DONE IRQ by now if it was really a packet, so ignore HEADER_VALID flag
+            activeReceiveStart = 0;
+            LOG_DEBUG("Ignore false header detection.\n");
+            return false;
+        }
+    }
+
+    // if (detected) LOG_DEBUG("rx detected\n");
+    return detected;
+}
+
+template <typename T> bool LR11x0Interface<T>::sleep()
+{
+    // Not keeping config is busted - next time nrf52 board boots lora sending fails  tcxo related? - see datasheet
+    // \todo Display actual typename of the adapter, not just `LR11x0`
+    LOG_DEBUG("LR11x0 entering sleep mode (FIXME, don't keep config)\n");
+    setStandby(); // Stop any pending operations
+
+    // turn off TCXO if it was powered
+    // FIXME - this isn't correct
+    // lora.setTCXO(0);
+
+    // put chipset into sleep mode (we've already disabled interrupts by now)
+    bool keepConfig = true;
+    lora.sleep(keepConfig, 0); // Note: we do not keep the config, full reinit will be needed
+
+#ifdef LR11X0_POWER_EN
+    digitalWrite(LR11X0_POWER_EN, LOW);
+#endif
+
+    return true;
+}
--- a/src/mesh/LR11x0Interface.h
+++ b/src/mesh/LR11x0Interface.h
@@ -0,0 +1,71 @@
+#pragma once
+
+#include "RadioLibInterface.h"
+
+/**
+ * \brief Adapter for LR11x0 radio family. Implements common logic for child classes.
+ * \tparam T RadioLib module type for LR11x0: SX1262, SX1268.
+ */
+template <class T> class LR11x0Interface : public RadioLibInterface
+{
+  public:
+    LR11x0Interface(LockingArduinoHal *hal, RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst,
+                    RADIOLIB_PIN_TYPE busy);
+
+    /// Initialise the Driver transport hardware and software.
+    /// Make sure the Driver is properly configured before calling init().
+    /// \return true if initialisation succeeded.
+    virtual bool init() override;
+
+    /// Apply any radio provisioning changes
+    /// Make sure the Driver is properly configured before calling init().
+    /// \return true if initialisation succeeded.
+    virtual bool reconfigure() override;
+
+    /// Prepare hardware for sleep.  Call this _only_ for deep sleep, not needed for light sleep.
+    virtual bool sleep() override;
+
+    bool isIRQPending() override { return lora.getIrqStatus() != 0; }
+
+  protected:
+    /**
+     * Specific module instance
+     */
+    T lora;
+
+    /**
+     * Glue functions called from ISR land
+     */
+    virtual void disableInterrupt() override;
+
+    /**
+     * Enable a particular ISR callback glue function
+     */
+    virtual void enableInterrupt(void (*callback)()) { lora.setIrqAction(callback); }
+
+    /** can we detect a LoRa preamble on the current channel? */
+    virtual bool isChannelActive() override;
+
+    /** are we actively receiving a packet (only called during receiving state) */
+    virtual bool isActivelyReceiving() override;
+
+    /**
+     * Start waiting to receive a message
+     */
+    virtual void startReceive() override;
+
+    /**
+     *  We override to turn on transmitter power as needed.
+     */
+    virtual void configHardwareForSend() override;
+
+    /**
+     * Add SNR data to received messages
+     */
+    virtual void addReceiveMetadata(meshtastic_MeshPacket *mp) override;
+
+    virtual void setStandby() override;
+
+  private:
+    uint32_t activeReceiveStart = 0;
+};
--- a/src/mesh/MeshModule.cpp
+++ b/src/mesh/MeshModule.cpp
@@ -62,7 +62,10 @@ meshtastic_MeshPacket *MeshModule::allocAckNak(meshtastic_Routing_Error err, Nod

 meshtastic_MeshPacket *MeshModule::allocErrorResponse(meshtastic_Routing_Error err, const meshtastic_MeshPacket *p)
 {
-    auto r = allocAckNak(err, getFrom(p), p->id, p->channel);
+    // If the original packet couldn't be decoded, use the primary channel
+    uint8_t channelIndex =
+        p->which_payload_variant == meshtastic_MeshPacket_decoded_tag ? p->channel : channels.getPrimaryIndex();
+    auto r = allocAckNak(err, getFrom(p), p->id, channelIndex);

    setReplyTo(r, *p);

@@ -114,13 +117,13 @@ void MeshModule::callModules(meshtastic_MeshPacket &mp, RxSource src)
            /// Also: if a packet comes in on the local PC interface, we don't check for bound channels, because it is TRUSTED and
            /// it needs to to be able to fetch the initial admin packets without yet knowing any channels.

-            bool rxChannelOk = !pi.boundChannel || (mp.from == 0) || (strcasecmp(ch->settings.name, pi.boundChannel) == 0);
+            bool rxChannelOk = !pi.boundChannel || (mp.from == 0) || (ch && strcasecmp(ch->settings.name, pi.boundChannel) == 0);

            if (!rxChannelOk) {
                // no one should have already replied!
                assert(!currentReply);

-                if (mp.decoded.want_response) {
+                if (isDecoded && mp.decoded.want_response) {
                    printPacket("packet on wrong channel, returning error", &mp);
                    currentReply = pi.allocErrorResponse(meshtastic_Routing_Error_NOT_AUTHORIZED, &mp);
                } else
@@ -138,7 +141,8 @@ void MeshModule::callModules(meshtastic_MeshPacket &mp, RxSource src)
                // because currently when the phone sends things, it sends things using the local node ID as the from address.  A
                // better solution (FIXME) would be to let phones have their own distinct addresses and we 'route' to them like
                // any other node.
-                if (mp.decoded.want_response && toUs && (getFrom(&mp) != ourNodeNum || mp.to == ourNodeNum) && !currentReply) {
+                if (isDecoded && mp.decoded.want_response && toUs && (getFrom(&mp) != ourNodeNum || mp.to == ourNodeNum) &&
+                    !currentReply) {
                    pi.sendResponse(mp);
                    ignoreRequest = ignoreRequest || pi.ignoreRequest; // If at least one module asks it, we may ignore a request
                    LOG_INFO("Asked module '%s' to send a response\n", pi.name);
@@ -163,7 +167,7 @@ void MeshModule::callModules(meshtastic_MeshPacket &mp, RxSource src)
        pi.currentRequest = NULL;
    }

-    if (mp.decoded.want_response && toUs) {
+    if (isDecoded && mp.decoded.want_response && toUs) {
        if (currentReply) {
            printPacket("Sending response", currentReply);
            service.sendToMesh(currentReply);
@@ -183,7 +187,7 @@ void MeshModule::callModules(meshtastic_MeshPacket &mp, RxSource src)
        }
    }

-    if (!moduleFound) {
+    if (!moduleFound && isDecoded) {
        LOG_DEBUG("No modules interested in portnum=%d, src=%s\n", mp.decoded.portnum,
                  (src == RX_SRC_LOCAL) ? "LOCAL" : "REMOTE");
    }
--- a/src/mesh/MeshService.cpp
+++ b/src/mesh/MeshService.cpp
@@ -192,9 +192,7 @@ void MeshService::handleToRadio(meshtastic_MeshPacket &p)
        return;
    }
 #endif
-    if (p.from != 0) { // We don't let phones assign nodenums to their sent messages
-        p.from = 0;
-    }
+    p.from = 0; // We don't let phones assign nodenums to their sent messages

    if (p.id == 0)
        p.id = generatePacketId(); // If the phone didn't supply one, then pick one
@@ -259,7 +257,7 @@ void MeshService::sendToMesh(meshtastic_MeshPacket *p, RxSource src, bool ccToPh
        LOG_DEBUG("Can't send status to phone");
    }

-    if (ccToPhone) {
+    if (res == ERRNO_OK && ccToPhone) { // Check if p is not released in case it couldn't be sent
        sendToPhone(packetPool.allocCopy(*p));
    }
 }
--- a/src/mesh/NodeDB.cpp
+++ b/src/mesh/NodeDB.cpp
@@ -56,7 +56,7 @@ meshtastic_OEMStore oemStore;
 bool meshtastic_DeviceState_callback(pb_istream_t *istream, pb_ostream_t *ostream, const pb_field_iter_t *field)
 {
    if (ostream) {
-        std::vector<meshtastic_NodeInfoLite> *vec = (std::vector<meshtastic_NodeInfoLite> *)field->pData;
+        std::vector<meshtastic_NodeInfoLite> const *vec = (std::vector<meshtastic_NodeInfoLite> *)field->pData;
        for (auto item : *vec) {
            if (!pb_encode_tag_for_field(ostream, field))
                return false;
@@ -269,11 +269,11 @@ void NodeDB::installDefaultConfig()
        config.device.node_info_broadcast_secs = default_node_info_broadcast_secs;
    config.device.serial_enabled = true;
    resetRadioConfig();
-    strncpy(config.network.ntp_server, "0.pool.ntp.org", 32);
+    strncpy(config.network.ntp_server, "meshtastic.pool.ntp.org", 32);
    // FIXME: Default to bluetooth capability of platform as default
    config.bluetooth.enabled = true;
    config.bluetooth.fixed_pin = defaultBLEPin;
-#if defined(ST7735_CS) || defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ST7789_CS)
+#if defined(ST7735_CS) || defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ST7789_CS) || defined(HX8357_CS)
    bool hasScreen = true;
 #elif ARCH_PORTDUINO
    bool hasScreen = false;
@@ -292,6 +292,9 @@ void NodeDB::installDefaultConfig()
         meshtastic_Config_PositionConfig_PositionFlags_SPEED | meshtastic_Config_PositionConfig_PositionFlags_HEADING |
         meshtastic_Config_PositionConfig_PositionFlags_DOP | meshtastic_Config_PositionConfig_PositionFlags_SATINVIEW);

+#ifdef RADIOMASTER_900_BANDIT_NANO
+    config.display.flip_screen = true;
+#endif
 #ifdef T_WATCH_S3
    config.display.screen_on_secs = 30;
    config.display.wake_on_tap_or_motion = true;
@@ -441,15 +444,15 @@ void NodeDB::installDefaultChannels()

 void NodeDB::resetNodes()
 {
+    clearLocalPosition();
    numMeshNodes = 1;
    std::fill(devicestate.node_db_lite.begin() + 1, devicestate.node_db_lite.end(), meshtastic_NodeInfoLite());
-    clearLocalPosition();
    saveDeviceStateToDisk();
    if (neighborInfoModule && moduleConfig.neighbor_info.enabled)
        neighborInfoModule->resetNeighbors();
 }

-void NodeDB::removeNodeByNum(uint nodeNum)
+void NodeDB::removeNodeByNum(NodeNum nodeNum)
 {
    int newPos = 0, removed = 0;
    for (int i = 0; i < numMeshNodes; i++) {
--- a/src/mesh/NodeDB.h
+++ b/src/mesh/NodeDB.h
@@ -127,7 +127,7 @@ class NodeDB
     */
    size_t getNumOnlineMeshNodes(bool localOnly = false);

-    void initConfigIntervals(), initModuleConfigIntervals(), resetNodes(), removeNodeByNum(uint nodeNum);
+    void initConfigIntervals(), initModuleConfigIntervals(), resetNodes(), removeNodeByNum(NodeNum nodeNum);

    bool factoryReset();

--- a/src/mesh/PhoneAPI.cpp
+++ b/src/mesh/PhoneAPI.cpp
@@ -140,16 +140,18 @@ bool PhoneAPI::handleToRadio(const uint8_t *buf, size_t bufLength)
 *
 * We assume buf is at least FromRadio_size bytes long.
 *
- * Our sending states progress in the following sequence (the client app ASSUMES THIS SEQUENCE, DO NOT CHANGE IT):
- *      STATE_SEND_MY_INFO, // send our my info record
- *      STATE_SEND_CHANNELS
- *      STATE_SEND_NODEINFO, // states progress in this order as the device sends to the client
-        STATE_SEND_CONFIG,
-        STATE_SEND_MODULE_CONFIG,
-        STATE_SEND_METADATA,
-        STATE_SEND_COMPLETE_ID,
-        STATE_SEND_PACKETS // send packets or debug strings
+ * Our sending states progress in the following sequence (the client apps ASSUME THIS SEQUENCE, DO NOT CHANGE IT):
+    STATE_SEND_MY_INFO, // send our my info record
+    STATE_SEND_OWN_NODEINFO,
+    STATE_SEND_METADATA,
+    STATE_SEND_CHANNELS
+    STATE_SEND_CONFIG,
+    STATE_SEND_MODULE_CONFIG,
+    STATE_SEND_OTHER_NODEINFOS, // states progress in this order as the device sends to the client
+    STATE_SEND_COMPLETE_ID,
+    STATE_SEND_PACKETS // send packets or debug strings
 */
+
 size_t PhoneAPI::getFromRadio(uint8_t *buf)
 {
    if (!available()) {
@@ -171,37 +173,32 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf)
        // app not to send locations on our behalf.
        fromRadioScratch.which_payload_variant = meshtastic_FromRadio_my_info_tag;
        fromRadioScratch.my_info = myNodeInfo;
-        state = STATE_SEND_METADATA;
+        state = STATE_SEND_OWN_NODEINFO;

        service.refreshLocalMeshNode(); // Update my NodeInfo because the client will be asking for it soon.
        break;

+    case STATE_SEND_OWN_NODEINFO: {
+        LOG_INFO("getFromRadio=STATE_SEND_OWN_NODEINFO\n");
+        auto us = nodeDB->readNextMeshNode(readIndex);
+        if (us) {
+            nodeInfoForPhone = TypeConversions::ConvertToNodeInfo(us);
+            fromRadioScratch.which_payload_variant = meshtastic_FromRadio_node_info_tag;
+            fromRadioScratch.node_info = nodeInfoForPhone;
+            // Should allow us to resume sending NodeInfo in STATE_SEND_OTHER_NODEINFOS
+            nodeInfoForPhone.num = 0;
+        }
+        state = STATE_SEND_METADATA;
+        break;
+    }
+
    case STATE_SEND_METADATA:
        LOG_INFO("getFromRadio=STATE_SEND_METADATA\n");
        fromRadioScratch.which_payload_variant = meshtastic_FromRadio_metadata_tag;
        fromRadioScratch.metadata = getDeviceMetadata();
-        state = STATE_SEND_NODEINFO;
+        state = STATE_SEND_CHANNELS;
        break;

-    case STATE_SEND_NODEINFO: {
-        LOG_INFO("getFromRadio=STATE_SEND_NODEINFO\n");
-
-        if (nodeInfoForPhone.num != 0) {
-            LOG_INFO("nodeinfo: num=0x%x, lastseen=%u, id=%s, name=%s\n", nodeInfoForPhone.num, nodeInfoForPhone.last_heard,
-                     nodeInfoForPhone.user.id, nodeInfoForPhone.user.long_name);
-            fromRadioScratch.which_payload_variant = meshtastic_FromRadio_node_info_tag;
-            fromRadioScratch.node_info = nodeInfoForPhone;
-            // Stay in current state until done sending nodeinfos
-            nodeInfoForPhone.num = 0; // We just consumed a nodeinfo, will need a new one next time
-        } else {
-            LOG_INFO("Done sending nodeinfos\n");
-            state = STATE_SEND_CHANNELS;
-            // Go ahead and send that ID right now
-            return getFromRadio(buf);
-        }
-        break;
-    }
-
    case STATE_SEND_CHANNELS:
        LOG_INFO("getFromRadio=STATE_SEND_CHANNELS\n");
        fromRadioScratch.which_payload_variant = meshtastic_FromRadio_channel_tag;
@@ -325,11 +322,30 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf)
        config_state++;
        // Advance when we have sent all of our ModuleConfig objects
        if (config_state > (_meshtastic_AdminMessage_ModuleConfigType_MAX + 1)) {
-            state = STATE_SEND_COMPLETE_ID;
+            // Clients sending special nonce don't want to see other nodeinfos
+            state = config_nonce == SPECIAL_NONCE ? STATE_SEND_COMPLETE_ID : STATE_SEND_OTHER_NODEINFOS;
            config_state = 0;
        }
        break;

+    case STATE_SEND_OTHER_NODEINFOS: {
+        LOG_INFO("getFromRadio=STATE_SEND_OTHER_NODEINFOS\n");
+        if (nodeInfoForPhone.num != 0) {
+            LOG_INFO("nodeinfo: num=0x%x, lastseen=%u, id=%s, name=%s\n", nodeInfoForPhone.num, nodeInfoForPhone.last_heard,
+                     nodeInfoForPhone.user.id, nodeInfoForPhone.user.long_name);
+            fromRadioScratch.which_payload_variant = meshtastic_FromRadio_node_info_tag;
+            fromRadioScratch.node_info = nodeInfoForPhone;
+            // Stay in current state until done sending nodeinfos
+            nodeInfoForPhone.num = 0; // We just consumed a nodeinfo, will need a new one next time
+        } else {
+            LOG_INFO("Done sending nodeinfos\n");
+            state = STATE_SEND_COMPLETE_ID;
+            // Go ahead and send that ID right now
+            return getFromRadio(buf);
+        }
+        break;
+    }
+
    case STATE_SEND_COMPLETE_ID:
        LOG_INFO("getFromRadio=STATE_SEND_COMPLETE_ID\n");
        fromRadioScratch.which_payload_variant = meshtastic_FromRadio_config_complete_id_tag;
@@ -422,10 +438,11 @@ bool PhoneAPI::available()
    case STATE_SEND_CONFIG:
    case STATE_SEND_MODULECONFIG:
    case STATE_SEND_METADATA:
+    case STATE_SEND_OWN_NODEINFO:
    case STATE_SEND_COMPLETE_ID:
        return true;

-    case STATE_SEND_NODEINFO:
+    case STATE_SEND_OTHER_NODEINFOS:
        if (nodeInfoForPhone.num == 0) {
            auto nextNode = nodeDB->readNextMeshNode(readIndex);
            if (nextNode) {
--- a/src/mesh/PhoneAPI.h
+++ b/src/mesh/PhoneAPI.h
@@ -6,6 +6,7 @@

 // Make sure that we never let our packets grow too large for one BLE packet
 #define MAX_TO_FROM_RADIO_SIZE 512
+#define SPECIAL_NONCE 69420

 /**
 * Provides our protobuf based API which phone/PC clients can use to talk to our device
@@ -20,13 +21,14 @@ class PhoneAPI
    : public Observer<uint32_t> // FIXME, we shouldn't be inheriting from Observer, instead use CallbackObserver as a member
 {
    enum State {
-        STATE_SEND_NOTHING,      // Initial state, don't send anything until the client starts asking for config
-        STATE_SEND_MY_INFO,      // send our my info record
-        STATE_SEND_NODEINFO,     // states progress in this order as the device sends to to the client
-        STATE_SEND_CHANNELS,     // Send all channels
-        STATE_SEND_CONFIG,       // Replacement for the old Radioconfig
-        STATE_SEND_MODULECONFIG, // Send Module specific config
+        STATE_SEND_NOTHING, // Initial state, don't send anything until the client starts asking for config
+        STATE_SEND_MY_INFO, // send our my info record
+        STATE_SEND_OWN_NODEINFO,
        STATE_SEND_METADATA,
+        STATE_SEND_CHANNELS,        // Send all channels
+        STATE_SEND_CONFIG,          // Replacement for the old Radioconfig
+        STATE_SEND_MODULECONFIG,    // Send Module specific config
+        STATE_SEND_OTHER_NODEINFOS, // states progress in this order as the device sends to to the client
        STATE_SEND_COMPLETE_ID,
        STATE_SEND_PACKETS // send packets or debug strings
    };
--- a/src/mesh/ProtobufModule.h
+++ b/src/mesh/ProtobufModule.h
@@ -95,12 +95,11 @@ template <class T> class ProtobufModule : protected SinglePortModule
     */
    virtual void alterReceived(meshtastic_MeshPacket &mp) override
    {
-        auto &p = mp.decoded;
-
        T scratch;
        T *decoded = NULL;
        if (mp.which_payload_variant == meshtastic_MeshPacket_decoded_tag && mp.decoded.portnum == ourPortNum) {
            memset(&scratch, 0, sizeof(scratch));
+            auto &p = mp.decoded;
            if (pb_decode_from_bytes(p.payload.bytes, p.payload.size, fields, &scratch)) {
                decoded = &scratch;
            } else {
--- a/src/mesh/RF95Interface.cpp
+++ b/src/mesh/RF95Interface.cpp
@@ -8,12 +8,57 @@
 #include "PortduinoGlue.h"
 #endif

-#define MAX_POWER 20
+#ifndef RF95_MAX_POWER
+#define RF95_MAX_POWER 20
+#endif
+
 // if we use 20 we are limited to 1% duty cycle or hw might overheat.  For continuous operation set a limit of 17
 // In theory up to 27 dBm is possible, but the modules installed in most radios can cope with a max of 20.  So BIG WARNING
 // if you set power to something higher than 17 or 20 you might fry your board.

 #define POWER_DEFAULT 17 // How much power to use if the user hasn't set a power level
+#ifdef RADIOMASTER_900_BANDIT_NANO
+// Structure to hold DAC and DB values
+typedef struct {
+    uint8_t dac;
+    uint8_t db;
+} DACDB;
+
+// Interpolation function
+DACDB interpolate(uint8_t dbm, uint8_t dbm1, uint8_t dbm2, DACDB val1, DACDB val2) {
+    DACDB result;
+    double fraction = (double)(dbm - dbm1) / (dbm2 - dbm1);
+    result.dac = (uint8_t)(val1.dac + fraction * (val2.dac - val1.dac));
+    result.db = (uint8_t)(val1.db + fraction * (val2.db - val1.db));
+    return result;
+}
+
+// Function to find the correct DAC and DB values based on dBm using interpolation
+DACDB getDACandDB(uint8_t dbm) {
+    // Predefined values
+    static const struct {
+        uint8_t dbm;
+        DACDB values;
+    } dbmToDACDB[] = {
+        {20, {168, 2}},  // 100mW
+        {24, {148, 6}},  // 250mW
+        {27, {128, 9}},  // 500mW
+        {30, {90, 12}}   // 1000mW
+    };
+    const int numValues = sizeof(dbmToDACDB) / sizeof(dbmToDACDB[0]);
+
+    // Find the interval dbm falls within and interpolate
+    for (int i = 0; i < numValues - 1; i++) {
+        if (dbm >= dbmToDACDB[i].dbm && dbm <= dbmToDACDB[i + 1].dbm) {
+            return interpolate(dbm, dbmToDACDB[i].dbm, dbmToDACDB[i + 1].dbm, dbmToDACDB[i].values, dbmToDACDB[i + 1].values);
+        }
+    }
+
+    // Return a default value if no match is found and default to 100mW
+    DACDB defaultValue = {168, 2};
+    return defaultValue;
+}
+#endif

 RF95Interface::RF95Interface(LockingArduinoHal *hal, RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst,
                             RADIOLIB_PIN_TYPE busy)
@@ -49,9 +94,16 @@ bool RF95Interface::init()
 {
    RadioLibInterface::init();

-    if (power > MAX_POWER) // This chip has lower power limits than some
-        power = MAX_POWER;
+#ifdef RADIOMASTER_900_BANDIT_NANO
+    // DAC and DB values based on dBm using interpolation
+    DACDB dacDbValues = getDACandDB(power);
+    int8_t powerDAC = dacDbValues.dac;
+    power = dacDbValues.db;
+#endif

+    if (power > RF95_MAX_POWER) // This chip has lower power limits than some
+        power = RF95_MAX_POWER;
+    
    limitPower();

    iface = lora = new RadioLibRF95(&module);
@@ -61,6 +113,19 @@ bool RF95Interface::init()
    digitalWrite(RF95_TCXO, 1);
 #endif

+    // enable PA
+#ifdef RF95_PA_EN
+#if defined(RF95_PA_DAC_EN)
+    #ifdef RADIOMASTER_900_BANDIT_NANO
+        // Use calculated DAC value
+        dacWrite(RF95_PA_EN, powerDAC);
+    #else
+        // Use Value set in /*/variant.h
+        dacWrite(RF95_PA_EN, RF95_PA_LEVEL);
+    #endif
+#endif
+#endif
+
    /*
    #define RF95_TXEN (22) // If defined, this pin should be set high prior to transmit (controls an external analog switch)
    #define RF95_RXEN (23) // If defined, this pin should be set high prior to receive (controls an external analog switch)
@@ -71,6 +136,11 @@ bool RF95Interface::init()
    digitalWrite(RF95_TXEN, 0);
 #endif

+#ifdef RF95_FAN_EN
+    pinMode(RF95_FAN_EN, OUTPUT);
+    digitalWrite(RF95_FAN_EN, 1);
+#endif
+
 #ifdef RF95_RXEN
    pinMode(RF95_RXEN, OUTPUT);
    digitalWrite(RF95_RXEN, 1);
@@ -92,6 +162,9 @@ bool RF95Interface::init()
    LOG_INFO("Frequency set to %f\n", getFreq());
    LOG_INFO("Bandwidth set to %f\n", bw);
    LOG_INFO("Power output set to %d\n", power);
+#ifdef RADIOMASTER_900_BANDIT_NANO
+    LOG_INFO("DAC output set to %d\n", powerDAC);
+#endif

    if (res == RADIOLIB_ERR_NONE)
        res = lora->setCRC(RADIOLIB_SX126X_LORA_CRC_ON);
@@ -146,10 +219,14 @@ bool RF95Interface::reconfigure()
    if (err != RADIOLIB_ERR_NONE)
        RECORD_CRITICALERROR(meshtastic_CriticalErrorCode_INVALID_RADIO_SETTING);

-    if (power > MAX_POWER) // This chip has lower power limits than some
-        power = MAX_POWER;
+    if (power > RF95_MAX_POWER) // This chip has lower power limits than some
+        power = RF95_MAX_POWER;

+#ifdef USE_RF95_RFO
+    err = lora->setOutputPower(power, true);
+#else
    err = lora->setOutputPower(power);
+#endif
    if (err != RADIOLIB_ERR_NONE)
        RECORD_CRITICALERROR(meshtastic_CriticalErrorCode_INVALID_RADIO_SETTING);

@@ -235,5 +312,9 @@ bool RF95Interface::sleep()
    setStandby(); // First cancel any active receiving/sending
    lora->sleep();

+#ifdef RF95_FAN_EN
+    digitalWrite(RF95_FAN_EN, 0);
+#endif
+
    return true;
-}
+}
--- a/src/mesh/RadioInterface.cpp
+++ b/src/mesh/RadioInterface.cpp
@@ -31,18 +31,18 @@ const RegionInfo regions[] = {
    RDEF(EU_433, 433.0f, 434.0f, 10, 0, 12, true, false, false),

    /*
-        https://www.thethingsnetwork.org/docs/lorawan/duty-cycle/
-        https://www.thethingsnetwork.org/docs/lorawan/regional-parameters/
-        https://www.legislation.gov.uk/uksi/1999/930/schedule/6/part/III/made/data.xht?view=snippet&wrap=true
+       https://www.thethingsnetwork.org/docs/lorawan/duty-cycle/
+       https://www.thethingsnetwork.org/docs/lorawan/regional-parameters/
+       https://www.legislation.gov.uk/uksi/1999/930/schedule/6/part/III/made/data.xht?view=snippet&wrap=true

-        audio_permitted = false per regulation
+       audio_permitted = false per regulation

-        Special Note:
-        The link above describes LoRaWAN's band plan, stating a power limit of 16 dBm. This is their own suggested specification,
-        we do not need to follow it. The European Union regulations clearly state that the power limit for this frequency range is
-       500 mW, or 27 dBm. It also states that we can use interference avoidance and spectrum access techniques to avoid a duty
-       cycle. (Please refer to section 4.21 in the following document)
-        https://ec.europa.eu/growth/tools-databases/tris/index.cfm/ro/search/?trisaction=search.detail&year=2021&num=528&dLang=EN
+       Special Note:
+       The link above describes LoRaWAN's band plan, stating a power limit of 16 dBm. This is their own suggested specification,
+       we do not need to follow it. The European Union regulations clearly state that the power limit for this frequency range is
+       500 mW, or 27 dBm. It also states that we can use interference avoidance and spectrum access techniques (such as LBT +
+       AFA) to avoid a duty cycle. (Please refer to line P page 22 of this document.)
+       https://www.etsi.org/deliver/etsi_en/300200_300299/30022002/03.01.01_60/en_30022002v030101p.pdf
     */
    RDEF(EU_868, 869.4f, 869.65f, 10, 0, 27, false, false, false),

@@ -495,7 +495,7 @@ void RadioInterface::applyModemConfig()
    // If user has manually specified a channel num, then use that, otherwise generate one by hashing the name
    const char *channelName = channels.getName(channels.getPrimaryIndex());
    // channel_num is actually (channel_num - 1), since modulus (%) returns values from 0 to (numChannels - 1)
-    uint channel_num = (loraConfig.channel_num ? loraConfig.channel_num - 1 : hash(channelName)) % numChannels;
+    uint32_t channel_num = (loraConfig.channel_num ? loraConfig.channel_num - 1 : hash(channelName)) % numChannels;

    // Check if we use the default frequency slot
    RadioInterface::uses_default_frequency_slot =
--- a/src/mesh/RadioLibInterface.cpp
+++ b/src/mesh/RadioLibInterface.cpp
@@ -25,7 +25,31 @@ void LockingArduinoHal::spiEndTransaction()
 #if ARCH_PORTDUINO
 void LockingArduinoHal::spiTransfer(uint8_t *out, size_t len, uint8_t *in)
 {
-    spi->transfer(out, in, len);
+    if (busy == RADIOLIB_NC) {
+        spi->transfer(out, in, len);
+    } else {
+        uint16_t offset = 0;
+
+        while (len) {
+            uint8_t block_size = (len < 20 ? len : 20);
+            spi->transfer((out != NULL ? out + offset : NULL), (in != NULL ? in + offset : NULL), block_size);
+            if (block_size == len)
+                return;
+
+            // ensure GPIO is low
+
+            uint32_t start = millis();
+            while (digitalRead(busy)) {
+                if (millis() - start >= 2000) {
+                    LOG_ERROR("GPIO mid-transfer timeout, is it connected?");
+                    return;
+                }
+            }
+
+            offset += block_size;
+            len -= block_size;
+        }
+    }
 }
 #endif

--- a/src/mesh/RadioLibInterface.h
+++ b/src/mesh/RadioLibInterface.h
@@ -21,12 +21,20 @@
 class LockingArduinoHal : public ArduinoHal
 {
  public:
-    LockingArduinoHal(SPIClass &spi, SPISettings spiSettings) : ArduinoHal(spi, spiSettings){};
+    LockingArduinoHal(SPIClass &spi, SPISettings spiSettings, RADIOLIB_PIN_TYPE _busy = RADIOLIB_NC)
+        : ArduinoHal(spi, spiSettings)
+    {
+#if ARCH_PORTDUINO
+        busy = _busy;
+#endif
+    };

    void spiBeginTransaction() override;
    void spiEndTransaction() override;
 #if ARCH_PORTDUINO
+    RADIOLIB_PIN_TYPE busy;
    void spiTransfer(uint8_t *out, size_t len, uint8_t *in) override;
+
 #endif
 };

@@ -179,4 +187,4 @@ class RadioLibInterface : public RadioInterface, protected concurrency::Notified
    virtual void addReceiveMetadata(meshtastic_MeshPacket *mp) = 0;

    virtual void setStandby() = 0;
-};
+};
--- a/src/mesh/RadioLibRF95.cpp
+++ b/src/mesh/RadioLibRF95.cpp
@@ -42,7 +42,11 @@ int16_t RadioLibRF95::begin(float freq, float bw, uint8_t sf, uint8_t cr, uint8_
    state = setCodingRate(cr);
    RADIOLIB_ASSERT(state);

+#ifdef USE_RF95_RFO
+    state = setOutputPower(power, true);
+#else
    state = setOutputPower(power);
+#endif
    RADIOLIB_ASSERT(state);

    state = setGain(gain);
--- a/src/mesh/Router.cpp
+++ b/src/mesh/Router.cpp
@@ -312,7 +312,10 @@ bool perhapsDecode(meshtastic_MeshPacket *p)
        if (channels.decryptForHash(chIndex, p->channel)) {
            // Try to decrypt the packet if we can
            size_t rawSize = p->encrypted.size;
-            assert(rawSize <= sizeof(bytes));
+            if (rawSize > sizeof(bytes)) {
+                LOG_ERROR("Packet too large to attempt decription! (rawSize=%d > 256)\n", rawSize);
+                return false;
+            }
            memcpy(bytes, p->encrypted.bytes,
                   rawSize); // we have to copy into a scratch buffer, because these bytes are a union with the decoded protobuf
            crypto->decrypt(p->from, p->id, rawSize, bytes);
--- a/src/mesh/generated/meshtastic/admin.pb.h
+++ b/src/mesh/generated/meshtastic/admin.pb.h
@@ -75,7 +75,7 @@ typedef struct _meshtastic_HamParameters {
 Ensure your radio is capable of operating of the selected frequency before setting this. */
    float frequency;
    /* Optional short name of user */
-    char short_name[6];
+    char short_name[5];
 } meshtastic_HamParameters;

 /* Response envelope for node_remote_hardware_pins */
@@ -135,6 +135,8 @@ typedef struct _meshtastic_AdminMessage {
        bool enter_dfu_mode_request;
        /* Delete the file by the specified path from the device */
        char delete_file_request[201];
+        /* Set zero and offset for scale chips */
+        uint32_t set_scale;
        /* Set the owner for this node */
        meshtastic_User set_owner;
        /* Set channels (using the new API).
@@ -238,6 +240,7 @@ extern "C" {
 #define meshtastic_AdminMessage_get_node_remote_hardware_pins_response_tag 20
 #define meshtastic_AdminMessage_enter_dfu_mode_request_tag 21
 #define meshtastic_AdminMessage_delete_file_request_tag 22
+#define meshtastic_AdminMessage_set_scale_tag    23
 #define meshtastic_AdminMessage_set_owner_tag    32
 #define meshtastic_AdminMessage_set_channel_tag  33
 #define meshtastic_AdminMessage_set_config_tag   34
@@ -281,6 +284,7 @@ X(a, STATIC,   ONEOF,    BOOL,     (payload_variant,get_node_remote_hardware_pin
 X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,get_node_remote_hardware_pins_response,get_node_remote_hardware_pins_response),  20) \
 X(a, STATIC,   ONEOF,    BOOL,     (payload_variant,enter_dfu_mode_request,enter_dfu_mode_request),  21) \
 X(a, STATIC,   ONEOF,    STRING,   (payload_variant,delete_file_request,delete_file_request),  22) \
+X(a, STATIC,   ONEOF,    UINT32,   (payload_variant,set_scale,set_scale),  23) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,set_owner,set_owner),  32) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,set_channel,set_channel),  33) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,set_config,set_config),  34) \
@@ -342,7 +346,7 @@ extern const pb_msgdesc_t meshtastic_NodeRemoteHardwarePinsResponse_msg;
 /* Maximum encoded size of messages (where known) */
 #define MESHTASTIC_MESHTASTIC_ADMIN_PB_H_MAX_SIZE meshtastic_AdminMessage_size
 #define meshtastic_AdminMessage_size             500
-#define meshtastic_HamParameters_size            32
+#define meshtastic_HamParameters_size            31
 #define meshtastic_NodeRemoteHardwarePinsResponse_size 496

 #ifdef __cplusplus
--- a/src/mesh/generated/meshtastic/atak.pb.h
+++ b/src/mesh/generated/meshtastic/atak.pb.h
@@ -73,6 +73,9 @@ typedef struct _meshtastic_GeoChat {
    /* Uid recipient of the message */
    bool has_to;
    char to[120];
+    /* Callsign of the recipient for the message */
+    bool has_to_callsign;
+    char to_callsign[120];
 } meshtastic_GeoChat;

 /* ATAK Group
@@ -164,13 +167,13 @@ extern "C" {

 /* Initializer values for message structs */
 #define meshtastic_TAKPacket_init_default        {0, false, meshtastic_Contact_init_default, false, meshtastic_Group_init_default, false, meshtastic_Status_init_default, 0, {meshtastic_PLI_init_default}}
-#define meshtastic_GeoChat_init_default          {"", false, ""}
+#define meshtastic_GeoChat_init_default          {"", false, "", false, ""}
 #define meshtastic_Group_init_default            {_meshtastic_MemberRole_MIN, _meshtastic_Team_MIN}
 #define meshtastic_Status_init_default           {0}
 #define meshtastic_Contact_init_default          {"", ""}
 #define meshtastic_PLI_init_default              {0, 0, 0, 0, 0}
 #define meshtastic_TAKPacket_init_zero           {0, false, meshtastic_Contact_init_zero, false, meshtastic_Group_init_zero, false, meshtastic_Status_init_zero, 0, {meshtastic_PLI_init_zero}}
-#define meshtastic_GeoChat_init_zero             {"", false, ""}
+#define meshtastic_GeoChat_init_zero             {"", false, "", false, ""}
 #define meshtastic_Group_init_zero               {_meshtastic_MemberRole_MIN, _meshtastic_Team_MIN}
 #define meshtastic_Status_init_zero              {0}
 #define meshtastic_Contact_init_zero             {"", ""}
@@ -179,6 +182,7 @@ extern "C" {
 /* Field tags (for use in manual encoding/decoding) */
 #define meshtastic_GeoChat_message_tag           1
 #define meshtastic_GeoChat_to_tag                2
+#define meshtastic_GeoChat_to_callsign_tag       3
 #define meshtastic_Group_role_tag                1
 #define meshtastic_Group_team_tag                2
 #define meshtastic_Status_battery_tag            1
@@ -214,7 +218,8 @@ X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,chat,payload_variant.chat),

 #define meshtastic_GeoChat_FIELDLIST(X, a) \
 X(a, STATIC,   SINGULAR, STRING,   message,           1) \
-X(a, STATIC,   OPTIONAL, STRING,   to,                2)
+X(a, STATIC,   OPTIONAL, STRING,   to,                2) \
+X(a, STATIC,   OPTIONAL, STRING,   to_callsign,       3)
 #define meshtastic_GeoChat_CALLBACK NULL
 #define meshtastic_GeoChat_DEFAULT NULL

@@ -262,11 +267,11 @@ extern const pb_msgdesc_t meshtastic_PLI_msg;
 /* Maximum encoded size of messages (where known) */
 #define MESHTASTIC_MESHTASTIC_ATAK_PB_H_MAX_SIZE meshtastic_TAKPacket_size
 #define meshtastic_Contact_size                  242
-#define meshtastic_GeoChat_size                  323
+#define meshtastic_GeoChat_size                  444
 #define meshtastic_Group_size                    4
 #define meshtastic_PLI_size                      31
 #define meshtastic_Status_size                   3
-#define meshtastic_TAKPacket_size                584
+#define meshtastic_TAKPacket_size                705

 #ifdef __cplusplus
 } /* extern "C" */
--- a/src/mesh/generated/meshtastic/config.pb.cpp
+++ b/src/mesh/generated/meshtastic/config.pb.cpp
@@ -46,3 +46,4 @@ PB_BIND(meshtastic_Config_BluetoothConfig, meshtastic_Config_BluetoothConfig, AU



+
--- a/src/mesh/generated/meshtastic/config.pb.h
+++ b/src/mesh/generated/meshtastic/config.pb.h
@@ -182,6 +182,25 @@ typedef enum _meshtastic_Config_DisplayConfig_DisplayMode {
    meshtastic_Config_DisplayConfig_DisplayMode_COLOR = 3
 } meshtastic_Config_DisplayConfig_DisplayMode;

+typedef enum _meshtastic_Config_DisplayConfig_CompassOrientation {
+    /* The compass and the display are in the same orientation. */
+    meshtastic_Config_DisplayConfig_CompassOrientation_DEGREES_0 = 0,
+    /* Rotate the compass by 90 degrees. */
+    meshtastic_Config_DisplayConfig_CompassOrientation_DEGREES_90 = 1,
+    /* Rotate the compass by 180 degrees. */
+    meshtastic_Config_DisplayConfig_CompassOrientation_DEGREES_180 = 2,
+    /* Rotate the compass by 270 degrees. */
+    meshtastic_Config_DisplayConfig_CompassOrientation_DEGREES_270 = 3,
+    /* Don't rotate the compass, but invert the result. */
+    meshtastic_Config_DisplayConfig_CompassOrientation_DEGREES_0_INVERTED = 4,
+    /* Rotate the compass by 90 degrees and invert. */
+    meshtastic_Config_DisplayConfig_CompassOrientation_DEGREES_90_INVERTED = 5,
+    /* Rotate the compass by 180 degrees and invert. */
+    meshtastic_Config_DisplayConfig_CompassOrientation_DEGREES_180_INVERTED = 6,
+    /* Rotate the compass by 270 degrees and invert. */
+    meshtastic_Config_DisplayConfig_CompassOrientation_DEGREES_270_INVERTED = 7
+} meshtastic_Config_DisplayConfig_CompassOrientation;
+
 typedef enum _meshtastic_Config_LoRaConfig_RegionCode {
    /* Region is not set */
    meshtastic_Config_LoRaConfig_RegionCode_UNSET = 0,
@@ -413,6 +432,8 @@ typedef struct _meshtastic_Config_DisplayConfig {
    bool heading_bold;
    /* Should we wake the screen up on accelerometer detected motion or tap */
    bool wake_on_tap_or_motion;
+    /* Indicates how to rotate or invert the compass output to accurate display on the display. */
+    meshtastic_Config_DisplayConfig_CompassOrientation compass_orientation;
 } meshtastic_Config_DisplayConfig;

 /* Lora Config */
@@ -549,6 +570,10 @@ extern "C" {
 #define _meshtastic_Config_DisplayConfig_DisplayMode_MAX meshtastic_Config_DisplayConfig_DisplayMode_COLOR
 #define _meshtastic_Config_DisplayConfig_DisplayMode_ARRAYSIZE ((meshtastic_Config_DisplayConfig_DisplayMode)(meshtastic_Config_DisplayConfig_DisplayMode_COLOR+1))

+#define _meshtastic_Config_DisplayConfig_CompassOrientation_MIN meshtastic_Config_DisplayConfig_CompassOrientation_DEGREES_0
+#define _meshtastic_Config_DisplayConfig_CompassOrientation_MAX meshtastic_Config_DisplayConfig_CompassOrientation_DEGREES_270_INVERTED
+#define _meshtastic_Config_DisplayConfig_CompassOrientation_ARRAYSIZE ((meshtastic_Config_DisplayConfig_CompassOrientation)(meshtastic_Config_DisplayConfig_CompassOrientation_DEGREES_270_INVERTED+1))
+
 #define _meshtastic_Config_LoRaConfig_RegionCode_MIN meshtastic_Config_LoRaConfig_RegionCode_UNSET
 #define _meshtastic_Config_LoRaConfig_RegionCode_MAX meshtastic_Config_LoRaConfig_RegionCode_SG_923
 #define _meshtastic_Config_LoRaConfig_RegionCode_ARRAYSIZE ((meshtastic_Config_LoRaConfig_RegionCode)(meshtastic_Config_LoRaConfig_RegionCode_SG_923+1))
@@ -575,6 +600,7 @@ extern "C" {
 #define meshtastic_Config_DisplayConfig_units_ENUMTYPE meshtastic_Config_DisplayConfig_DisplayUnits
 #define meshtastic_Config_DisplayConfig_oled_ENUMTYPE meshtastic_Config_DisplayConfig_OledType
 #define meshtastic_Config_DisplayConfig_displaymode_ENUMTYPE meshtastic_Config_DisplayConfig_DisplayMode
+#define meshtastic_Config_DisplayConfig_compass_orientation_ENUMTYPE meshtastic_Config_DisplayConfig_CompassOrientation

 #define meshtastic_Config_LoRaConfig_modem_preset_ENUMTYPE meshtastic_Config_LoRaConfig_ModemPreset
 #define meshtastic_Config_LoRaConfig_region_ENUMTYPE meshtastic_Config_LoRaConfig_RegionCode
@@ -589,8 +615,8 @@ extern "C" {
 #define meshtastic_Config_PowerConfig_init_default {0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_Config_NetworkConfig_init_default {0, "", "", "", 0, _meshtastic_Config_NetworkConfig_AddressMode_MIN, false, meshtastic_Config_NetworkConfig_IpV4Config_init_default, ""}
 #define meshtastic_Config_NetworkConfig_IpV4Config_init_default {0, 0, 0, 0}
-#define meshtastic_Config_DisplayConfig_init_default {0, _meshtastic_Config_DisplayConfig_GpsCoordinateFormat_MIN, 0, 0, 0, _meshtastic_Config_DisplayConfig_DisplayUnits_MIN, _meshtastic_Config_DisplayConfig_OledType_MIN, _meshtastic_Config_DisplayConfig_DisplayMode_MIN, 0, 0}
-#define meshtastic_Config_LoRaConfig_init_default {0, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, 0, 0, 0, 0, _meshtastic_Config_LoRaConfig_RegionCode_MIN, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}, 0}
+#define meshtastic_Config_DisplayConfig_init_default {0, _meshtastic_Config_DisplayConfig_GpsCoordinateFormat_MIN, 0, 0, 0, _meshtastic_Config_DisplayConfig_DisplayUnits_MIN, _meshtastic_Config_DisplayConfig_OledType_MIN, _meshtastic_Config_DisplayConfig_DisplayMode_MIN, 0, 0, _meshtastic_Config_DisplayConfig_CompassOrientation_MIN}
+#define meshtastic_Config_LoRaConfig_init_default {0, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, 0, 0, 0, 0, _meshtastic_Config_LoRaConfig_RegionCode_MIN, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}, 0}
 #define meshtastic_Config_BluetoothConfig_init_default {0, _meshtastic_Config_BluetoothConfig_PairingMode_MIN, 0}
 #define meshtastic_Config_init_zero              {0, {meshtastic_Config_DeviceConfig_init_zero}}
 #define meshtastic_Config_DeviceConfig_init_zero {_meshtastic_Config_DeviceConfig_Role_MIN, 0, 0, 0, 0, _meshtastic_Config_DeviceConfig_RebroadcastMode_MIN, 0, 0, 0, 0, "", 0}
@@ -598,8 +624,8 @@ extern "C" {
 #define meshtastic_Config_PowerConfig_init_zero  {0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_Config_NetworkConfig_init_zero {0, "", "", "", 0, _meshtastic_Config_NetworkConfig_AddressMode_MIN, false, meshtastic_Config_NetworkConfig_IpV4Config_init_zero, ""}
 #define meshtastic_Config_NetworkConfig_IpV4Config_init_zero {0, 0, 0, 0}
-#define meshtastic_Config_DisplayConfig_init_zero {0, _meshtastic_Config_DisplayConfig_GpsCoordinateFormat_MIN, 0, 0, 0, _meshtastic_Config_DisplayConfig_DisplayUnits_MIN, _meshtastic_Config_DisplayConfig_OledType_MIN, _meshtastic_Config_DisplayConfig_DisplayMode_MIN, 0, 0}
-#define meshtastic_Config_LoRaConfig_init_zero   {0, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, 0, 0, 0, 0, _meshtastic_Config_LoRaConfig_RegionCode_MIN, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}, 0}
+#define meshtastic_Config_DisplayConfig_init_zero {0, _meshtastic_Config_DisplayConfig_GpsCoordinateFormat_MIN, 0, 0, 0, _meshtastic_Config_DisplayConfig_DisplayUnits_MIN, _meshtastic_Config_DisplayConfig_OledType_MIN, _meshtastic_Config_DisplayConfig_DisplayMode_MIN, 0, 0, _meshtastic_Config_DisplayConfig_CompassOrientation_MIN}
+#define meshtastic_Config_LoRaConfig_init_zero   {0, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, 0, 0, 0, 0, _meshtastic_Config_LoRaConfig_RegionCode_MIN, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}, 0}
 #define meshtastic_Config_BluetoothConfig_init_zero {0, _meshtastic_Config_BluetoothConfig_PairingMode_MIN, 0}

 /* Field tags (for use in manual encoding/decoding) */
@@ -658,6 +684,7 @@ extern "C" {
 #define meshtastic_Config_DisplayConfig_displaymode_tag 8
 #define meshtastic_Config_DisplayConfig_heading_bold_tag 9
 #define meshtastic_Config_DisplayConfig_wake_on_tap_or_motion_tag 10
+#define meshtastic_Config_DisplayConfig_compass_orientation_tag 11
 #define meshtastic_Config_LoRaConfig_use_preset_tag 1
 #define meshtastic_Config_LoRaConfig_modem_preset_tag 2
 #define meshtastic_Config_LoRaConfig_bandwidth_tag 3
@@ -781,7 +808,8 @@ X(a, STATIC,   SINGULAR, UENUM,    units,             6) \
 X(a, STATIC,   SINGULAR, UENUM,    oled,              7) \
 X(a, STATIC,   SINGULAR, UENUM,    displaymode,       8) \
 X(a, STATIC,   SINGULAR, BOOL,     heading_bold,      9) \
-X(a, STATIC,   SINGULAR, BOOL,     wake_on_tap_or_motion,  10)
+X(a, STATIC,   SINGULAR, BOOL,     wake_on_tap_or_motion,  10) \
+X(a, STATIC,   SINGULAR, UENUM,    compass_orientation,  11)
 #define meshtastic_Config_DisplayConfig_CALLBACK NULL
 #define meshtastic_Config_DisplayConfig_DEFAULT NULL

@@ -838,8 +866,9 @@ extern const pb_msgdesc_t meshtastic_Config_BluetoothConfig_msg;
 #define MESHTASTIC_MESHTASTIC_CONFIG_PB_H_MAX_SIZE meshtastic_Config_size
 #define meshtastic_Config_BluetoothConfig_size   10
 #define meshtastic_Config_DeviceConfig_size      100
-#define meshtastic_Config_DisplayConfig_size     28
+#define meshtastic_Config_DisplayConfig_size     30
 #define meshtastic_Config_LoRaConfig_size        82
+#define meshtastic_Config_LoRaConfig_size        80
 #define meshtastic_Config_NetworkConfig_IpV4Config_size 20
 #define meshtastic_Config_NetworkConfig_size     196
 #define meshtastic_Config_PositionConfig_size    62
--- a/src/mesh/generated/meshtastic/deviceonly.pb.h
+++ b/src/mesh/generated/meshtastic/deviceonly.pb.h
@@ -314,7 +314,7 @@ extern const pb_msgdesc_t meshtastic_OEMStore_msg;
 #define meshtastic_ChannelFile_size              718
 #define meshtastic_NodeInfoLite_size             166

-#define meshtastic_OEMStore_size                 3346
+#define meshtastic_OEMStore_size                 3370
 #define meshtastic_PositionLite_size             28

 #ifdef __cplusplus
--- a/src/mesh/generated/meshtastic/localonly.pb.h
+++ b/src/mesh/generated/meshtastic/localonly.pb.h
@@ -181,8 +181,8 @@ extern const pb_msgdesc_t meshtastic_LocalModuleConfig_msg;

 /* Maximum encoded size of messages (where known) */
 #define MESHTASTIC_MESHTASTIC_LOCALONLY_PB_H_MAX_SIZE meshtastic_LocalModuleConfig_size
-#define meshtastic_LocalConfig_size              537
-#define meshtastic_LocalModuleConfig_size        663
+#define meshtastic_LocalConfig_size              539
+#define meshtastic_LocalModuleConfig_size        685

 #ifdef __cplusplus
 } /* extern "C" */
--- a/src/mesh/generated/meshtastic/mesh.pb.cpp
+++ b/src/mesh/generated/meshtastic/mesh.pb.cpp
@@ -66,6 +66,15 @@ PB_BIND(meshtastic_Heartbeat, meshtastic_Heartbeat, AUTO)
 PB_BIND(meshtastic_NodeRemoteHardwarePin, meshtastic_NodeRemoteHardwarePin, AUTO)


+PB_BIND(meshtastic_ChunkedPayload, meshtastic_ChunkedPayload, AUTO)
+
+
+PB_BIND(meshtastic_resend_chunks, meshtastic_resend_chunks, AUTO)
+
+
+PB_BIND(meshtastic_ChunkedPayloadResponse, meshtastic_ChunkedPayloadResponse, AUTO)
+
+



--- a/src/mesh/generated/meshtastic/mesh.pb.h
+++ b/src/mesh/generated/meshtastic/mesh.pb.h
@@ -63,6 +63,12 @@ typedef enum _meshtastic_HardwareModel {
    meshtastic_HardwareModel_NANO_G2_ULTRA = 18,
    /* LoRAType device: https://loratype.org/ */
    meshtastic_HardwareModel_LORA_TYPE = 19,
+    /* wiphone https://www.wiphone.io/ */
+    meshtastic_HardwareModel_WIPHONE = 20,
+    /* WIO Tracker WM1110 family from Seeed Studio. Includes wio-1110-tracker and wio-1110-sdk */
+    meshtastic_HardwareModel_WIO_WM1110 = 21,
+    /* RAK2560 Solar base station based on RAK4630 */
+    meshtastic_HardwareModel_RAK2560 = 22,
    /* B&Q Consulting Station Edition G1: https://uniteng.com/wiki/doku.php?id=meshtastic:station */
    meshtastic_HardwareModel_STATION_G1 = 25,
    /* RAK11310 (RP2040 + SX1262) */
@@ -151,6 +157,14 @@ typedef enum _meshtastic_HardwareModel {
    /* TWC_MESH_V4 
 Adafruit NRF52840 feather express with SX1262, SSD1306 OLED and NEO6M GPS */
    meshtastic_HardwareModel_TWC_MESH_V4 = 62,
+    /* NRF52_PROMICRO_DIY
+ Promicro NRF52840 with SX1262/LLCC68, SSD1306 OLED and NEO6M GPS */
+    meshtastic_HardwareModel_NRF52_PROMICRO_DIY = 63,
+    /* RadioMaster 900 Bandit Nano, https://www.radiomasterrc.com/products/bandit-nano-expresslrs-rf-module
+ ESP32-D0WDQ6 With SX1276/SKY66122, SSD1306 OLED and No GPS */
+    meshtastic_HardwareModel_RADIOMASTER_900_BANDIT_NANO = 64,
+    /* Heltec Capsule Sensor V3 with ESP32-S3 CPU, Portable LoRa device that can replace GNSS modules or sensors */
+    meshtastic_HardwareModel_HELTEC_CAPSULE_SENSOR_V3 = 65,
    /* ------------------------------------------------------------------------------------------------------------------------------------------
 Reserved ID For developing private Ports. These will show up in live traffic sparsely, so we can use a high number. Keep it within 8 bits.
 ------------------------------------------------------------------------------------------------------------------------------------------ */
@@ -849,6 +863,38 @@ typedef struct _meshtastic_NodeRemoteHardwarePin {
    meshtastic_RemoteHardwarePin pin;
 } meshtastic_NodeRemoteHardwarePin;

+typedef PB_BYTES_ARRAY_T(228) meshtastic_ChunkedPayload_payload_chunk_t;
+typedef struct _meshtastic_ChunkedPayload {
+    /* The ID of the entire payload */
+    uint32_t payload_id;
+    /* The total number of chunks in the payload */
+    uint16_t chunk_count;
+    /* The current chunk index in the total */
+    uint16_t chunk_index;
+    /* The binary data of the current chunk */
+    meshtastic_ChunkedPayload_payload_chunk_t payload_chunk;
+} meshtastic_ChunkedPayload;
+
+/* Wrapper message for broken repeated oneof support */
+typedef struct _meshtastic_resend_chunks {
+    pb_callback_t chunks;
+} meshtastic_resend_chunks;
+
+/* Responses to a ChunkedPayload request */
+typedef struct _meshtastic_ChunkedPayloadResponse {
+    /* The ID of the entire payload */
+    uint32_t payload_id;
+    pb_size_t which_payload_variant;
+    union {
+        /* Request to transfer chunked payload */
+        bool request_transfer;
+        /* Accept the transfer chunked payload */
+        bool accept_transfer;
+        /* Request missing indexes in the chunked payload */
+        meshtastic_resend_chunks resend_chunks;
+    } payload_variant;
+} meshtastic_ChunkedPayloadResponse;
+

 #ifdef __cplusplus
 extern "C" {
@@ -924,6 +970,9 @@ extern "C" {



+
+
+
 /* Initializer values for message structs */
 #define meshtastic_Position_init_default         {0, 0, 0, 0, _meshtastic_Position_LocSource_MIN, _meshtastic_Position_AltSource_MIN, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_User_init_default             {"", "", "", {0}, _meshtastic_HardwareModel_MIN, 0, _meshtastic_Config_DeviceConfig_Role_MIN}
@@ -945,6 +994,9 @@ extern "C" {
 #define meshtastic_DeviceMetadata_init_default   {"", 0, 0, 0, 0, 0, _meshtastic_Config_DeviceConfig_Role_MIN, 0, _meshtastic_HardwareModel_MIN, 0}
 #define meshtastic_Heartbeat_init_default        {0}
 #define meshtastic_NodeRemoteHardwarePin_init_default {0, false, meshtastic_RemoteHardwarePin_init_default}
+#define meshtastic_ChunkedPayload_init_default   {0, 0, 0, {0, {0}}}
+#define meshtastic_resend_chunks_init_default    {{{NULL}, NULL}}
+#define meshtastic_ChunkedPayloadResponse_init_default {0, 0, {0}}
 #define meshtastic_Position_init_zero            {0, 0, 0, 0, _meshtastic_Position_LocSource_MIN, _meshtastic_Position_AltSource_MIN, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_User_init_zero                {"", "", "", {0}, _meshtastic_HardwareModel_MIN, 0, _meshtastic_Config_DeviceConfig_Role_MIN}
 #define meshtastic_RouteDiscovery_init_zero      {0, {0, 0, 0, 0, 0, 0, 0, 0}}
@@ -965,6 +1017,9 @@ extern "C" {
 #define meshtastic_DeviceMetadata_init_zero      {"", 0, 0, 0, 0, 0, _meshtastic_Config_DeviceConfig_Role_MIN, 0, _meshtastic_HardwareModel_MIN, 0}
 #define meshtastic_Heartbeat_init_zero           {0}
 #define meshtastic_NodeRemoteHardwarePin_init_zero {0, false, meshtastic_RemoteHardwarePin_init_zero}
+#define meshtastic_ChunkedPayload_init_zero      {0, 0, 0, {0, {0}}}
+#define meshtastic_resend_chunks_init_zero       {{{NULL}, NULL}}
+#define meshtastic_ChunkedPayloadResponse_init_zero {0, 0, {0}}

 /* Field tags (for use in manual encoding/decoding) */
 #define meshtastic_Position_latitude_i_tag       1
@@ -1101,6 +1156,15 @@ extern "C" {
 #define meshtastic_ToRadio_heartbeat_tag         7
 #define meshtastic_NodeRemoteHardwarePin_node_num_tag 1
 #define meshtastic_NodeRemoteHardwarePin_pin_tag 2
+#define meshtastic_ChunkedPayload_payload_id_tag 1
+#define meshtastic_ChunkedPayload_chunk_count_tag 2
+#define meshtastic_ChunkedPayload_chunk_index_tag 3
+#define meshtastic_ChunkedPayload_payload_chunk_tag 4
+#define meshtastic_resend_chunks_chunks_tag      1
+#define meshtastic_ChunkedPayloadResponse_payload_id_tag 1
+#define meshtastic_ChunkedPayloadResponse_request_transfer_tag 2
+#define meshtastic_ChunkedPayloadResponse_accept_transfer_tag 3
+#define meshtastic_ChunkedPayloadResponse_resend_chunks_tag 4

 /* Struct field encoding specification for nanopb */
 #define meshtastic_Position_FIELDLIST(X, a) \
@@ -1341,6 +1405,28 @@ X(a, STATIC,   OPTIONAL, MESSAGE,  pin,               2)
 #define meshtastic_NodeRemoteHardwarePin_DEFAULT NULL
 #define meshtastic_NodeRemoteHardwarePin_pin_MSGTYPE meshtastic_RemoteHardwarePin

+#define meshtastic_ChunkedPayload_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UINT32,   payload_id,        1) \
+X(a, STATIC,   SINGULAR, UINT32,   chunk_count,       2) \
+X(a, STATIC,   SINGULAR, UINT32,   chunk_index,       3) \
+X(a, STATIC,   SINGULAR, BYTES,    payload_chunk,     4)
+#define meshtastic_ChunkedPayload_CALLBACK NULL
+#define meshtastic_ChunkedPayload_DEFAULT NULL
+
+#define meshtastic_resend_chunks_FIELDLIST(X, a) \
+X(a, CALLBACK, REPEATED, UINT32,   chunks,            1)
+#define meshtastic_resend_chunks_CALLBACK pb_default_field_callback
+#define meshtastic_resend_chunks_DEFAULT NULL
+
+#define meshtastic_ChunkedPayloadResponse_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UINT32,   payload_id,        1) \
+X(a, STATIC,   ONEOF,    BOOL,     (payload_variant,request_transfer,payload_variant.request_transfer),   2) \
+X(a, STATIC,   ONEOF,    BOOL,     (payload_variant,accept_transfer,payload_variant.accept_transfer),   3) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,resend_chunks,payload_variant.resend_chunks),   4)
+#define meshtastic_ChunkedPayloadResponse_CALLBACK NULL
+#define meshtastic_ChunkedPayloadResponse_DEFAULT NULL
+#define meshtastic_ChunkedPayloadResponse_payload_variant_resend_chunks_MSGTYPE meshtastic_resend_chunks
+
 extern const pb_msgdesc_t meshtastic_Position_msg;
 extern const pb_msgdesc_t meshtastic_User_msg;
 extern const pb_msgdesc_t meshtastic_RouteDiscovery_msg;
@@ -1361,6 +1447,9 @@ extern const pb_msgdesc_t meshtastic_Neighbor_msg;
 extern const pb_msgdesc_t meshtastic_DeviceMetadata_msg;
 extern const pb_msgdesc_t meshtastic_Heartbeat_msg;
 extern const pb_msgdesc_t meshtastic_NodeRemoteHardwarePin_msg;
+extern const pb_msgdesc_t meshtastic_ChunkedPayload_msg;
+extern const pb_msgdesc_t meshtastic_resend_chunks_msg;
+extern const pb_msgdesc_t meshtastic_ChunkedPayloadResponse_msg;

 /* Defines for backwards compatibility with code written before nanopb-0.4.0 */
 #define meshtastic_Position_fields &meshtastic_Position_msg
@@ -1383,9 +1472,15 @@ extern const pb_msgdesc_t meshtastic_NodeRemoteHardwarePin_msg;
 #define meshtastic_DeviceMetadata_fields &meshtastic_DeviceMetadata_msg
 #define meshtastic_Heartbeat_fields &meshtastic_Heartbeat_msg
 #define meshtastic_NodeRemoteHardwarePin_fields &meshtastic_NodeRemoteHardwarePin_msg
+#define meshtastic_ChunkedPayload_fields &meshtastic_ChunkedPayload_msg
+#define meshtastic_resend_chunks_fields &meshtastic_resend_chunks_msg
+#define meshtastic_ChunkedPayloadResponse_fields &meshtastic_ChunkedPayloadResponse_msg

 /* Maximum encoded size of messages (where known) */
+/* meshtastic_resend_chunks_size depends on runtime parameters */
+/* meshtastic_ChunkedPayloadResponse_size depends on runtime parameters */
 #define MESHTASTIC_MESHTASTIC_MESH_PB_H_MAX_SIZE meshtastic_FromRadio_size
+#define meshtastic_ChunkedPayload_size           245
 #define meshtastic_Compressed_size               243
 #define meshtastic_Data_size                     270
 #define meshtastic_DeviceMetadata_size           46
--- a/src/mesh/generated/meshtastic/module_config.pb.h
+++ b/src/mesh/generated/meshtastic/module_config.pb.h
@@ -188,6 +188,10 @@ typedef struct _meshtastic_ModuleConfig_PaxcounterConfig {
    /* Enable the Paxcounter Module */
    bool enabled;
    uint32_t paxcounter_update_interval;
+    /* WiFi RSSI threshold. Defaults to -80 */
+    int32_t wifi_threshold;
+    /* BLE RSSI threshold. Defaults to -80 */
+    int32_t ble_threshold;
 } meshtastic_ModuleConfig_PaxcounterConfig;

 /* Serial Config */
@@ -467,7 +471,7 @@ extern "C" {
 #define meshtastic_ModuleConfig_NeighborInfoConfig_init_default {0, 0}
 #define meshtastic_ModuleConfig_DetectionSensorConfig_init_default {0, 0, 0, 0, "", 0, 0, 0}
 #define meshtastic_ModuleConfig_AudioConfig_init_default {0, 0, _meshtastic_ModuleConfig_AudioConfig_Audio_Baud_MIN, 0, 0, 0, 0}
-#define meshtastic_ModuleConfig_PaxcounterConfig_init_default {0, 0}
+#define meshtastic_ModuleConfig_PaxcounterConfig_init_default {0, 0, 0, 0}
 #define meshtastic_ModuleConfig_SerialConfig_init_default {0, 0, 0, 0, _meshtastic_ModuleConfig_SerialConfig_Serial_Baud_MIN, 0, _meshtastic_ModuleConfig_SerialConfig_Serial_Mode_MIN, 0}
 #define meshtastic_ModuleConfig_ExternalNotificationConfig_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_ModuleConfig_StoreForwardConfig_init_default {0, 0, 0, 0, 0}
@@ -483,7 +487,7 @@ extern "C" {
 #define meshtastic_ModuleConfig_NeighborInfoConfig_init_zero {0, 0}
 #define meshtastic_ModuleConfig_DetectionSensorConfig_init_zero {0, 0, 0, 0, "", 0, 0, 0}
 #define meshtastic_ModuleConfig_AudioConfig_init_zero {0, 0, _meshtastic_ModuleConfig_AudioConfig_Audio_Baud_MIN, 0, 0, 0, 0}
-#define meshtastic_ModuleConfig_PaxcounterConfig_init_zero {0, 0}
+#define meshtastic_ModuleConfig_PaxcounterConfig_init_zero {0, 0, 0, 0}
 #define meshtastic_ModuleConfig_SerialConfig_init_zero {0, 0, 0, 0, _meshtastic_ModuleConfig_SerialConfig_Serial_Baud_MIN, 0, _meshtastic_ModuleConfig_SerialConfig_Serial_Mode_MIN, 0}
 #define meshtastic_ModuleConfig_ExternalNotificationConfig_init_zero {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_ModuleConfig_StoreForwardConfig_init_zero {0, 0, 0, 0, 0}
@@ -526,6 +530,8 @@ extern "C" {
 #define meshtastic_ModuleConfig_AudioConfig_i2s_sck_tag 7
 #define meshtastic_ModuleConfig_PaxcounterConfig_enabled_tag 1
 #define meshtastic_ModuleConfig_PaxcounterConfig_paxcounter_update_interval_tag 2
+#define meshtastic_ModuleConfig_PaxcounterConfig_wifi_threshold_tag 3
+#define meshtastic_ModuleConfig_PaxcounterConfig_ble_threshold_tag 4
 #define meshtastic_ModuleConfig_SerialConfig_enabled_tag 1
 #define meshtastic_ModuleConfig_SerialConfig_echo_tag 2
 #define meshtastic_ModuleConfig_SerialConfig_rxd_tag 3
@@ -695,7 +701,9 @@ X(a, STATIC,   SINGULAR, UINT32,   i2s_sck,           7)

 #define meshtastic_ModuleConfig_PaxcounterConfig_FIELDLIST(X, a) \
 X(a, STATIC,   SINGULAR, BOOL,     enabled,           1) \
-X(a, STATIC,   SINGULAR, UINT32,   paxcounter_update_interval,   2)
+X(a, STATIC,   SINGULAR, UINT32,   paxcounter_update_interval,   2) \
+X(a, STATIC,   SINGULAR, INT32,    wifi_threshold,    3) \
+X(a, STATIC,   SINGULAR, INT32,    ble_threshold,     4)
 #define meshtastic_ModuleConfig_PaxcounterConfig_CALLBACK NULL
 #define meshtastic_ModuleConfig_PaxcounterConfig_DEFAULT NULL

@@ -836,7 +844,7 @@ extern const pb_msgdesc_t meshtastic_RemoteHardwarePin_msg;
 #define meshtastic_ModuleConfig_MQTTConfig_size  254
 #define meshtastic_ModuleConfig_MapReportSettings_size 12
 #define meshtastic_ModuleConfig_NeighborInfoConfig_size 8
-#define meshtastic_ModuleConfig_PaxcounterConfig_size 8
+#define meshtastic_ModuleConfig_PaxcounterConfig_size 30
 #define meshtastic_ModuleConfig_RangeTestConfig_size 10
 #define meshtastic_ModuleConfig_RemoteHardwareConfig_size 96
 #define meshtastic_ModuleConfig_SerialConfig_size 28
--- a/src/mesh/generated/meshtastic/telemetry.pb.cpp
+++ b/src/mesh/generated/meshtastic/telemetry.pb.cpp
@@ -21,5 +21,8 @@ PB_BIND(meshtastic_AirQualityMetrics, meshtastic_AirQualityMetrics, AUTO)
 PB_BIND(meshtastic_Telemetry, meshtastic_Telemetry, AUTO)


+PB_BIND(meshtastic_Nau7802Config, meshtastic_Nau7802Config, AUTO)
+
+


--- a/src/mesh/generated/meshtastic/telemetry.pb.h
+++ b/src/mesh/generated/meshtastic/telemetry.pb.h
@@ -45,7 +45,25 @@ typedef enum _meshtastic_TelemetrySensorType {
    /* BMP085/BMP180 High accuracy temperature and pressure (older Version of BMP280) */
    meshtastic_TelemetrySensorType_BMP085 = 15,
    /* RCWL-9620 Doppler Radar Distance Sensor, used for water level detection */
-    meshtastic_TelemetrySensorType_RCWL9620 = 16
+    meshtastic_TelemetrySensorType_RCWL9620 = 16,
+    /* Sensirion High accuracy temperature and humidity */
+    meshtastic_TelemetrySensorType_SHT4X = 17,
+    /* VEML7700 high accuracy ambient light(Lux) digital 16-bit resolution sensor. */
+    meshtastic_TelemetrySensorType_VEML7700 = 18,
+    /* MLX90632 non-contact IR temperature sensor. */
+    meshtastic_TelemetrySensorType_MLX90632 = 19,
+    /* TI OPT3001 Ambient Light Sensor */
+    meshtastic_TelemetrySensorType_OPT3001 = 20,
+    /* Lite On LTR-390UV-01 UV Light Sensor */
+    meshtastic_TelemetrySensorType_LTR390UV = 21,
+    /* AMS TSL25911FN RGB Light Sensor */
+    meshtastic_TelemetrySensorType_TSL25911FN = 22,
+    /* AHT10 Integrated temperature and humidity sensor */
+    meshtastic_TelemetrySensorType_AHT10 = 23,
+    /* DFRobot Lark Weather station (temperature, humidity, pressure, wind speed and direction) */
+    meshtastic_TelemetrySensorType_DFROBOT_LARK = 24,
+    /* NAU7802 Scale Chip or compatible */
+    meshtastic_TelemetrySensorType_NAU7802 = 25
 } meshtastic_TelemetrySensorType;

 /* Struct definitions */
@@ -82,6 +100,21 @@ typedef struct _meshtastic_EnvironmentMetrics {
    uint16_t iaq;
    /* RCWL9620 Doppler Radar Distance Sensor, used for water level detection. Float value in mm. */
    float distance;
+    /* VEML7700 high accuracy ambient light(Lux) digital 16-bit resolution sensor. */
+    float lux;
+    /* VEML7700 high accuracy white light(irradiance) not calibrated digital 16-bit resolution sensor. */
+    float white_lux;
+    /* Infrared lux */
+    float ir_lux;
+    /* Ultraviolet lux */
+    float uv_lux;
+    /* Wind direction in degrees
+ 0 degrees = North, 90 = East, etc... */
+    uint16_t wind_direction;
+    /* Wind speed in m/s */
+    float wind_speed;
+    /* Weight in KG */
+    float weight;
 } meshtastic_EnvironmentMetrics;

 /* Power Metrics (voltage / current / etc) */
@@ -145,6 +178,14 @@ typedef struct _meshtastic_Telemetry {
    } variant;
 } meshtastic_Telemetry;

+/* NAU7802 Telemetry configuration, for saving to flash */
+typedef struct _meshtastic_Nau7802Config {
+    /* The offset setting for the NAU7802 */
+    int32_t zeroOffset;
+    /* The calibration factor for the NAU7802 */
+    float calibrationFactor;
+} meshtastic_Nau7802Config;
+

 #ifdef __cplusplus
 extern "C" {
@@ -152,8 +193,9 @@ extern "C" {

 /* Helper constants for enums */
 #define _meshtastic_TelemetrySensorType_MIN meshtastic_TelemetrySensorType_SENSOR_UNSET
-#define _meshtastic_TelemetrySensorType_MAX meshtastic_TelemetrySensorType_RCWL9620
-#define _meshtastic_TelemetrySensorType_ARRAYSIZE ((meshtastic_TelemetrySensorType)(meshtastic_TelemetrySensorType_RCWL9620+1))
+#define _meshtastic_TelemetrySensorType_MAX meshtastic_TelemetrySensorType_NAU7802
+#define _meshtastic_TelemetrySensorType_ARRAYSIZE ((meshtastic_TelemetrySensorType)(meshtastic_TelemetrySensorType_NAU7802+1))
+



@@ -163,15 +205,17 @@ extern "C" {

 /* Initializer values for message structs */
 #define meshtastic_DeviceMetrics_init_default    {0, 0, 0, 0, 0}
-#define meshtastic_EnvironmentMetrics_init_default {0, 0, 0, 0, 0, 0, 0, 0}
+#define meshtastic_EnvironmentMetrics_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_PowerMetrics_init_default     {0, 0, 0, 0, 0, 0}
 #define meshtastic_AirQualityMetrics_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_Telemetry_init_default        {0, 0, {meshtastic_DeviceMetrics_init_default}}
+#define meshtastic_Nau7802Config_init_default    {0, 0}
 #define meshtastic_DeviceMetrics_init_zero       {0, 0, 0, 0, 0}
-#define meshtastic_EnvironmentMetrics_init_zero  {0, 0, 0, 0, 0, 0, 0, 0}
+#define meshtastic_EnvironmentMetrics_init_zero  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_PowerMetrics_init_zero        {0, 0, 0, 0, 0, 0}
 #define meshtastic_AirQualityMetrics_init_zero   {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_Telemetry_init_zero           {0, 0, {meshtastic_DeviceMetrics_init_zero}}
+#define meshtastic_Nau7802Config_init_zero       {0, 0}

 /* Field tags (for use in manual encoding/decoding) */
 #define meshtastic_DeviceMetrics_battery_level_tag 1
@@ -187,6 +231,13 @@ extern "C" {
 #define meshtastic_EnvironmentMetrics_current_tag 6
 #define meshtastic_EnvironmentMetrics_iaq_tag    7
 #define meshtastic_EnvironmentMetrics_distance_tag 8
+#define meshtastic_EnvironmentMetrics_lux_tag    9
+#define meshtastic_EnvironmentMetrics_white_lux_tag 10
+#define meshtastic_EnvironmentMetrics_ir_lux_tag 11
+#define meshtastic_EnvironmentMetrics_uv_lux_tag 12
+#define meshtastic_EnvironmentMetrics_wind_direction_tag 13
+#define meshtastic_EnvironmentMetrics_wind_speed_tag 14
+#define meshtastic_EnvironmentMetrics_weight_tag 15
 #define meshtastic_PowerMetrics_ch1_voltage_tag  1
 #define meshtastic_PowerMetrics_ch1_current_tag  2
 #define meshtastic_PowerMetrics_ch2_voltage_tag  3
@@ -210,6 +261,8 @@ extern "C" {
 #define meshtastic_Telemetry_environment_metrics_tag 3
 #define meshtastic_Telemetry_air_quality_metrics_tag 4
 #define meshtastic_Telemetry_power_metrics_tag   5
+#define meshtastic_Nau7802Config_zeroOffset_tag  1
+#define meshtastic_Nau7802Config_calibrationFactor_tag 2

 /* Struct field encoding specification for nanopb */
 #define meshtastic_DeviceMetrics_FIELDLIST(X, a) \
@@ -229,7 +282,14 @@ X(a, STATIC,   SINGULAR, FLOAT,    gas_resistance,    4) \
 X(a, STATIC,   SINGULAR, FLOAT,    voltage,           5) \
 X(a, STATIC,   SINGULAR, FLOAT,    current,           6) \
 X(a, STATIC,   SINGULAR, UINT32,   iaq,               7) \
-X(a, STATIC,   SINGULAR, FLOAT,    distance,          8)
+X(a, STATIC,   SINGULAR, FLOAT,    distance,          8) \
+X(a, STATIC,   SINGULAR, FLOAT,    lux,               9) \
+X(a, STATIC,   SINGULAR, FLOAT,    white_lux,        10) \
+X(a, STATIC,   SINGULAR, FLOAT,    ir_lux,           11) \
+X(a, STATIC,   SINGULAR, FLOAT,    uv_lux,           12) \
+X(a, STATIC,   SINGULAR, UINT32,   wind_direction,   13) \
+X(a, STATIC,   SINGULAR, FLOAT,    wind_speed,       14) \
+X(a, STATIC,   SINGULAR, FLOAT,    weight,           15)
 #define meshtastic_EnvironmentMetrics_CALLBACK NULL
 #define meshtastic_EnvironmentMetrics_DEFAULT NULL

@@ -272,11 +332,18 @@ X(a, STATIC,   ONEOF,    MESSAGE,  (variant,power_metrics,variant.power_metrics)
 #define meshtastic_Telemetry_variant_air_quality_metrics_MSGTYPE meshtastic_AirQualityMetrics
 #define meshtastic_Telemetry_variant_power_metrics_MSGTYPE meshtastic_PowerMetrics

+#define meshtastic_Nau7802Config_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, INT32,    zeroOffset,        1) \
+X(a, STATIC,   SINGULAR, FLOAT,    calibrationFactor,   2)
+#define meshtastic_Nau7802Config_CALLBACK NULL
+#define meshtastic_Nau7802Config_DEFAULT NULL
+
 extern const pb_msgdesc_t meshtastic_DeviceMetrics_msg;
 extern const pb_msgdesc_t meshtastic_EnvironmentMetrics_msg;
 extern const pb_msgdesc_t meshtastic_PowerMetrics_msg;
 extern const pb_msgdesc_t meshtastic_AirQualityMetrics_msg;
 extern const pb_msgdesc_t meshtastic_Telemetry_msg;
+extern const pb_msgdesc_t meshtastic_Nau7802Config_msg;

 /* Defines for backwards compatibility with code written before nanopb-0.4.0 */
 #define meshtastic_DeviceMetrics_fields &meshtastic_DeviceMetrics_msg
@@ -284,14 +351,16 @@ extern const pb_msgdesc_t meshtastic_Telemetry_msg;
 #define meshtastic_PowerMetrics_fields &meshtastic_PowerMetrics_msg
 #define meshtastic_AirQualityMetrics_fields &meshtastic_AirQualityMetrics_msg
 #define meshtastic_Telemetry_fields &meshtastic_Telemetry_msg
+#define meshtastic_Nau7802Config_fields &meshtastic_Nau7802Config_msg

 /* Maximum encoded size of messages (where known) */
 #define MESHTASTIC_MESHTASTIC_TELEMETRY_PB_H_MAX_SIZE meshtastic_Telemetry_size
 #define meshtastic_AirQualityMetrics_size        72
 #define meshtastic_DeviceMetrics_size            27
-#define meshtastic_EnvironmentMetrics_size       39
+#define meshtastic_EnvironmentMetrics_size       73
+#define meshtastic_Nau7802Config_size            16
 #define meshtastic_PowerMetrics_size             30
-#define meshtastic_Telemetry_size                79
+#define meshtastic_Telemetry_size                80

 #ifdef __cplusplus
 } /* extern "C" */
--- a/src/mesh/wifi/WiFiAPClient.cpp
+++ b/src/mesh/wifi/WiFiAPClient.cpp
@@ -108,8 +108,10 @@ static void onNetworkConnected()
    }

    // FIXME this is kinda yucky, instead we should just have an observable for 'wifireconnected'
+#ifndef MESHTASTIC_EXCLUDE_MQTT
    if (mqtt)
        mqtt->reconnect();
+#endif
 }

 static int32_t reconnectWiFi()
@@ -225,10 +227,16 @@ bool initWifi()

            WiFi.mode(WIFI_STA);
            WiFi.setHostname(ourHost);
+
            if (config.network.address_mode == meshtastic_Config_NetworkConfig_AddressMode_STATIC &&
                config.network.ipv4_config.ip != 0) {
+#ifndef ARCH_RP2040
                WiFi.config(config.network.ipv4_config.ip, config.network.ipv4_config.gateway, config.network.ipv4_config.subnet,
                            config.network.ipv4_config.dns);
+#else
+                WiFi.config(config.network.ipv4_config.ip, config.network.ipv4_config.dns, config.network.ipv4_config.gateway,
+                            config.network.ipv4_config.subnet);
+#endif
            }
 #ifndef ARCH_RP2040
            WiFi.onEvent(WiFiEvent);
				`@@ -46,3 +46,4 @@ PB_BIND(meshtastic_Config_BluetoothConfig, meshtastic_Config_BluetoothConfig, AU`