missed t-rexes

Co-authored-by: jp-bennett <5630967+jp-bennett@users.noreply.github.com>

.trunk/trunk.yaml

@@ -9,7 +9,7 @@ plugins:
 lint:
   enabled:
     - checkov@3.2.471
-    - renovate@41.127.2
+    - renovate@41.130.1
     - prettier@3.6.2
     - trufflehog@3.90.8
     - yamllint@1.37.1

arch/esp32/esp32.ini

@@ -36,6 +36,7 @@ build_flags =
   -DCONFIG_BT_NIMBLE_HOST_TASK_STACK_SIZE=8192
   -DESP_OPENSSL_SUPPRESS_LEGACY_WARNING
   -DSERIAL_BUFFER_SIZE=4096
+  -DSERIAL_HAS_ON_RECEIVE
   -DLIBPAX_ARDUINO
   -DLIBPAX_WIFI
   -DLIBPAX_BLE

boards/r1-neo.json

@@ -0,0 +1,52 @@
+{
+  "build": {
+    "arduino": {
+      "ldscript": "nrf52840_s140_v6.ld"
+    },
+    "core": "nRF5",
+    "cpu": "cortex-m4",
+    "extra_flags": "-DARDUINO_NRF52840_FEATHER -DNRF52840_XXAA",
+    "f_cpu": "64000000L",
+    "hwids": [
+      ["0x239A", "0x8029"],
+      ["0x239A", "0x0029"],
+      ["0x239A", "0x002A"],
+      ["0x239A", "0x802A"]
+    ],
+    "usb_product": "Muzi R1 Neo",
+    "mcu": "nrf52840",
+    "variant": "r1-neo",
+    "bsp": {
+      "name": "adafruit"
+    },
+    "softdevice": {
+      "sd_flags": "-DS140",
+      "sd_name": "s140",
+      "sd_version": "6.1.1",
+      "sd_fwid": "0x00B6"
+    },
+    "bootloader": {
+      "settings_addr": "0xFF000"
+    }
+  },
+  "connectivity": ["bluetooth"],
+  "debug": {
+    "jlink_device": "nRF52840_xxAA",
+    "svd_path": "nrf52840.svd",
+    "openocd_target": "nrf52840-mdk-rs"
+  },
+  "frameworks": ["arduino", "freertos"],
+  "name": "WisCore RAK4631 Board",
+  "upload": {
+    "maximum_ram_size": 248832,
+    "maximum_size": 815104,
+    "speed": 115200,
+    "protocol": "nrfutil",
+    "protocols": ["jlink", "nrfjprog", "nrfutil", "stlink"],
+    "use_1200bps_touch": true,
+    "require_upload_port": true,
+    "wait_for_upload_port": true
+  },
+  "url": "https://muzi.works/",
+  "vendor": "Muzi Works"
+}

platformio.ini

@@ -56,6 +56,7 @@ build_flags = -Wno-missing-field-initializers
 	#-DBUILD_EPOCH=$UNIX_TIME ; set in platformio-custom.py now
 	#-D OLED_PL=1
 	#-D DEBUG_HEAP=1 ; uncomment to add free heap space / memory leak debugging logs
+	#-D DEBUG_LOOP_TIMING=1 ; uncomment to add main loop timing logs
 
 monitor_speed = 115200
 monitor_filters = direct

src/AudioThread.h

@@ -26,6 +26,7 @@ class AudioThread : public concurrency::OSThread
         i2sRtttl->begin(rtttlFile, audioOut);
     }
 
+    // Also handles actually playing the RTTTL, needs to be called in loop
     bool isPlaying()
     {
         if (i2sRtttl != nullptr) {

src/DisplayFormatters.cpp

@@ -76,9 +76,6 @@ const char *DisplayFormatters::getDeviceRole(meshtastic_Config_DeviceConfig_Role
     case meshtastic_Config_DeviceConfig_Role_ROUTER_LATE:
         return "Router Late";
         break;
-    case meshtastic_Config_DeviceConfig_Role_REPEATER:
-        return "Repeater";
-        break;
     default:
         return "Unknown";
         break;

src/SerialConsole.cpp

@@ -6,6 +6,14 @@
 #include "configuration.h"
 #include "time.h"
 
+#if defined(ARDUINO_USB_CDC_ON_BOOT) && ARDUINO_USB_CDC_ON_BOOT
+#define IS_USB_SERIAL
+#ifdef SERIAL_HAS_ON_RECEIVE
+#undef SERIAL_HAS_ON_RECEIVE
+#endif
+#include "HWCDC.h"
+#endif
+
 #ifdef RP2040_SLOW_CLOCK
 #define Port Serial2
 #else
@@ -22,7 +30,12 @@ SerialConsole *console;
 
 void consoleInit()
 {
-    new SerialConsole(); // Must be dynamically allocated because we are now inheriting from thread
+    auto sc = new SerialConsole(); // Must be dynamically allocated because we are now inheriting from thread
+
+#if defined(SERIAL_HAS_ON_RECEIVE)
+    // onReceive does only exist for HardwareSerial not for USB CDC serial
+    Port.onReceive([sc]() { sc->rxInt(); });
+#endif
     DEBUG_PORT.rpInit(); // Simply sets up semaphore
 }
 
@@ -65,14 +78,21 @@ SerialConsole::SerialConsole() : StreamAPI(&Port), RedirectablePrint(&Port), con
 int32_t SerialConsole::runOnce()
 {
 #ifdef HELTEC_MESH_SOLAR
-    //After enabling the mesh solar serial port module configuration, command processing is handled by the serial port module.
-    if(moduleConfig.serial.enabled && moduleConfig.serial.override_console_serial_port
-        && moduleConfig.serial.mode==meshtastic_ModuleConfig_SerialConfig_Serial_Mode_MS_CONFIG)
-    {
+    // After enabling the mesh solar serial port module configuration, command processing is handled by the serial port module.
+    if (moduleConfig.serial.enabled && moduleConfig.serial.override_console_serial_port &&
+        moduleConfig.serial.mode == meshtastic_ModuleConfig_SerialConfig_Serial_Mode_MS_CONFIG) {
         return 250;
     }
 #endif
-    return runOncePart();
+
+    int32_t delay = runOncePart();
+#if defined(SERIAL_HAS_ON_RECEIVE)
+    return Port.available() ? delay : INT32_MAX;
+#elif defined(IS_USB_SERIAL)
+    return HWCDC::isPlugged() ? delay : (1000 * 20);
+#else
+    return delay;
+#endif
 }
 
 void SerialConsole::flush()
@@ -80,6 +100,18 @@ void SerialConsole::flush()
     Port.flush();
 }
 
+// trigger tx of serial data
+void SerialConsole::onNowHasData(uint32_t fromRadioNum)
+{
+    setIntervalFromNow(0);
+}
+
+// trigger rx of serial data
+void SerialConsole::rxInt()
+{
+    setIntervalFromNow(0);
+}
+
 // For the serial port we can't really detect if any client is on the other side, so instead just look for recent messages
 bool SerialConsole::checkIsConnected()
 {

src/SerialConsole.h

@@ -32,11 +32,14 @@ class SerialConsole : public StreamAPI, public RedirectablePrint, private concur
     virtual int32_t runOnce() override;
 
     void flush();
+    void rxInt();
 
   protected:
     /// Check the current underlying physical link to see if the client is currently connected
     virtual bool checkIsConnected() override;
 
+    virtual void onNowHasData(uint32_t fromRadioNum) override;
+
     /// Possibly switch to protobufs if we see a valid protobuf message
     virtual void log_to_serial(const char *logLevel, const char *format, va_list arg);
 };

src/buzz/BuzzerFeedbackThread.cpp

@@ -5,7 +5,7 @@
 
 BuzzerFeedbackThread *buzzerFeedbackThread;
 
-BuzzerFeedbackThread::BuzzerFeedbackThread() : OSThread("BuzzerFeedback")
+BuzzerFeedbackThread::BuzzerFeedbackThread()
 {
     if (inputBroker)
         inputObserver.observe(inputBroker);
@@ -19,10 +19,6 @@ int BuzzerFeedbackThread::handleInputEvent(const InputEvent *event)
         return 0; // Let other handlers process the event
     }
 
-    // Track last event time for potential future use
-    lastEventTime = millis();
-    needsUpdate = true;
-
     // Handle different input events with appropriate buzzer feedback
     switch (event->inputEvent) {
     case INPUT_BROKER_USER_PRESS:
@@ -61,15 +57,4 @@ int BuzzerFeedbackThread::handleInputEvent(const InputEvent *event)
     }
 
     return 0; // Allow other handlers to process the event
-}
-
-int32_t BuzzerFeedbackThread::runOnce()
-{
-    // This thread is primarily event-driven, but we can use runOnce
-    // for any periodic tasks if needed in the future
-
-    needsUpdate = false;
-
-    // Run every 100ms when active, less frequently when idle
-    return needsUpdate ? 100 : 1000;
-}
+}

src/buzz/BuzzerFeedbackThread.h

@@ -4,7 +4,7 @@
 #include "concurrency/OSThread.h"
 #include "input/InputBroker.h"
 
-class BuzzerFeedbackThread : public concurrency::OSThread
+class BuzzerFeedbackThread
 {
     CallbackObserver<BuzzerFeedbackThread, const InputEvent *> inputObserver =
         CallbackObserver<BuzzerFeedbackThread, const InputEvent *>(this, &BuzzerFeedbackThread::handleInputEvent);
@@ -12,13 +12,6 @@ class BuzzerFeedbackThread : public concurrency::OSThread
   public:
     BuzzerFeedbackThread();
     int handleInputEvent(const InputEvent *event);
-
-  protected:
-    virtual int32_t runOnce() override;
-
-  private:
-    uint32_t lastEventTime = 0;
-    bool needsUpdate = false;
 };
 
 extern BuzzerFeedbackThread *buzzerFeedbackThread;

src/concurrency/OSThread.cpp

@@ -90,7 +90,9 @@ void OSThread::run()
     if (heap < newHeap)
         LOG_HEAP("++++++ Thread %s freed heap %d -> %d (%d) ++++++", ThreadName.c_str(), heap, newHeap, newHeap - heap);
 #endif
-
+#ifdef DEBUG_LOOP_TIMING
+    LOG_DEBUG("====== Thread next run in: %d", newDelay);
+#endif
     runned();
 
     if (newDelay >= 0)

src/detect/ScanI2C.cpp

@@ -25,8 +25,8 @@ ScanI2C::FoundDevice ScanI2C::firstScreen() const
 
 ScanI2C::FoundDevice ScanI2C::firstRTC() const
 {
-    ScanI2C::DeviceType types[] = {RTC_RV3028, RTC_PCF8563};
-    return firstOfOrNONE(2, types);
+    ScanI2C::DeviceType types[] = {RTC_RV3028, RTC_PCF8563, RTC_RX8130CE};
+    return firstOfOrNONE(3, types);
 }
 
 ScanI2C::FoundDevice ScanI2C::firstKeyboard() const

src/detect/ScanI2C.h

@@ -14,6 +14,7 @@ class ScanI2C
         SCREEN_ST7567,
         RTC_RV3028,
         RTC_PCF8563,
+        RTC_RX8130CE,
         CARDKB,
         TDECKKB,
         BBQ10KB,

src/detect/ScanI2CTwoWire.cpp

@@ -197,6 +197,9 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
 #ifdef PCF8563_RTC
                 SCAN_SIMPLE_CASE(PCF8563_RTC, RTC_PCF8563, "PCF8563", (uint8_t)addr.address)
 #endif
+#ifdef RX8130CE_RTC
+                SCAN_SIMPLE_CASE(RX8130CE_RTC, RTC_RX8130CE, "RX8130CE", (uint8_t)addr.address)
+#endif
 
             case CARDKB_ADDR:
                 // Do we have the RAK14006 instead?

src/gps/GPS.cpp

@@ -1104,11 +1104,6 @@ int32_t GPS::runOnce()
         publishUpdate();
     }
 
-    // Repeaters have no need for GPS
-    if (config.device.role == meshtastic_Config_DeviceConfig_Role_REPEATER) {
-        return disable();
-    }
-
     if (whileActive()) {
         // if we have received valid NMEA claim we are connected
         setConnected();

src/gps/RTC.cpp

@@ -109,6 +109,35 @@ RTCSetResult readFromRTC()
         }
         return RTCSetResultSuccess;
     }
+#elif defined(RX8130CE_RTC)
+    if (rtc_found.address == RX8130CE_RTC) {
+        uint32_t now = millis();
+        ArtronShop_RX8130CE rtc(&Wire);
+        tm t;
+        if (rtc.getTime(&t)) {
+            tv.tv_sec = gm_mktime(&t);
+            tv.tv_usec = 0;
+
+            uint32_t printableEpoch = tv.tv_sec; // Print lib only supports 32 bit but time_t can be 64 bit on some platforms
+            LOG_DEBUG("Read RTC time from RX8130CE getDateTime as %02d-%02d-%02d %02d:%02d:%02d (%ld)", t.tm_year + 1900,
+                      t.tm_mon + 1, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec, printableEpoch);
+#ifdef BUILD_EPOCH
+            if (tv.tv_sec < BUILD_EPOCH) {
+                if (Throttle::isWithinTimespanMs(lastTimeValidationWarning, TIME_VALIDATION_WARNING_INTERVAL_MS) == false) {
+                    LOG_WARN("Ignore time (%ld) before build epoch (%ld)!", printableEpoch, BUILD_EPOCH);
+                    lastTimeValidationWarning = millis();
+                }
+                return RTCSetResultInvalidTime;
+            }
+#endif
+            if (currentQuality == RTCQualityNone) {
+                timeStartMsec = now;
+                zeroOffsetSecs = tv.tv_sec;
+                currentQuality = RTCQualityDevice;
+            }
+            return RTCSetResultSuccess;
+        }
+    }
 #else
     if (!gettimeofday(&tv, NULL)) {
         uint32_t now = millis();
@@ -214,6 +243,17 @@ RTCSetResult perhapsSetRTC(RTCQuality q, const struct timeval *tv, bool forceUpd
             LOG_DEBUG("PCF8563_RTC setDateTime %02d-%02d-%02d %02d:%02d:%02d (%ld)", t->tm_year + 1900, t->tm_mon + 1, t->tm_mday,
                       t->tm_hour, t->tm_min, t->tm_sec, printableEpoch);
         }
+#elif defined(RX8130CE_RTC)
+        if (rtc_found.address == RX8130CE_RTC) {
+            ArtronShop_RX8130CE rtc(&Wire);
+            tm *t = gmtime(&tv->tv_sec);
+            if (rtc.setTime(*t)) {
+                LOG_DEBUG("RX8130CE setDateTime %02d-%02d-%02d %02d:%02d:%02d (%ld)", t->tm_year + 1900, t->tm_mon + 1,
+                          t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec, printableEpoch);
+            } else {
+                LOG_WARN("Failed to set time for RX8130CE");
+            }
+        }
 #elif defined(ARCH_ESP32)
         settimeofday(tv, NULL);
 #endif

src/gps/RTC.h

@@ -4,6 +4,10 @@
 #include "sys/time.h"
 #include <Arduino.h>
 
+#ifdef RX8130CE_RTC
+#include <ArtronShop_RX8130CE.h>
+#endif
+
 enum RTCQuality {
 
     /// We haven't had our RTC set yet

src/graphics/draw/MenuHandler.cpp

@@ -852,24 +852,31 @@ void menuHandler::GPSFormatMenu()
     bannerOptions.bannerCallback = [](int selected) -> void {
         if (selected == 1) {
             uiconfig.gps_format = meshtastic_DeviceUIConfig_GpsCoordinateFormat_DEC;
+            saveUIConfig();
             service->reloadConfig(SEGMENT_CONFIG);
         } else if (selected == 2) {
             uiconfig.gps_format = meshtastic_DeviceUIConfig_GpsCoordinateFormat_DMS;
+            saveUIConfig();
             service->reloadConfig(SEGMENT_CONFIG);
         } else if (selected == 3) {
             uiconfig.gps_format = meshtastic_DeviceUIConfig_GpsCoordinateFormat_UTM;
+            saveUIConfig();
             service->reloadConfig(SEGMENT_CONFIG);
         } else if (selected == 4) {
             uiconfig.gps_format = meshtastic_DeviceUIConfig_GpsCoordinateFormat_MGRS;
+            saveUIConfig();
             service->reloadConfig(SEGMENT_CONFIG);
         } else if (selected == 5) {
             uiconfig.gps_format = meshtastic_DeviceUIConfig_GpsCoordinateFormat_OLC;
+            saveUIConfig();
             service->reloadConfig(SEGMENT_CONFIG);
         } else if (selected == 6) {
             uiconfig.gps_format = meshtastic_DeviceUIConfig_GpsCoordinateFormat_OSGR;
+            saveUIConfig();
             service->reloadConfig(SEGMENT_CONFIG);
         } else if (selected == 7) {
             uiconfig.gps_format = meshtastic_DeviceUIConfig_GpsCoordinateFormat_MLS;
+            saveUIConfig();
             service->reloadConfig(SEGMENT_CONFIG);
         } else {
             menuQueue = position_base_menu;

src/graphics/draw/UIRenderer.cpp

@@ -125,8 +125,10 @@ void UIRenderer::drawGpsCoordinates(OLEDDisplay *display, int16_t x, int16_t y,
     char displayLine[32];
 
     if (!gps->getIsConnected() && !config.position.fixed_position) {
-        strcpy(displayLine, "No GPS present");
-        display->drawString(x, y, displayLine);
+        if (strcmp(mode, "line1") == 0) {
+            strcpy(displayLine, "No GPS present");
+            display->drawString(x, y, displayLine);
+        }
     } else if (!gps->getHasLock() && !config.position.fixed_position) {
         if (strcmp(mode, "line1") == 0) {
             strcpy(displayLine, "No GPS Lock");
@@ -1103,6 +1105,18 @@ void UIRenderer::drawCompassAndLocationScreen(OLEDDisplay *display, OLEDDisplayU
             // === Fourth Row: Line 2 GPS Info ===
             UIRenderer::drawGpsCoordinates(display, x, getTextPositions(display)[line++], gpsStatus, "line2");
         }
+
+        // === Final Row: Altitude ===
+        char altitudeLine[32] = {0};
+        int32_t alt = (strcmp(displayLine, "Phone GPS") == 0 && ourNode && nodeDB->hasValidPosition(ourNode))
+                          ? ourNode->position.altitude
+                          : geoCoord.getAltitude();
+        if (config.display.units == meshtastic_Config_DisplayConfig_DisplayUnits_IMPERIAL) {
+            snprintf(altitudeLine, sizeof(altitudeLine), "Alt: %.0fft", alt * METERS_TO_FEET);
+        } else {
+            snprintf(altitudeLine, sizeof(altitudeLine), "Alt: %.0im", alt);
+        }
+        display->drawString(x, getTextPositions(display)[line++], altitudeLine);
     }
 #if !defined(M5STACK_UNITC6L)
     // === Draw Compass if heading is valid ===

src/input/ButtonThread.cpp

@@ -274,7 +274,12 @@ int32_t ButtonThread::runOnce()
         }
     }
     btnEvent = BUTTON_EVENT_NONE;
-    return 50;
+
+    // only pull when the button is pressed, we get notified via IRQ on a new press
+    if (!userButton.isIdle() || waitingForLongPress) {
+        return 50;
+    }
+    return 100; // FIXME: Why can't we rely on interrupts and use INT32_MAX here?
 }
 
 /*

src/main.cpp

@@ -297,6 +297,12 @@ void printInfo()
 #ifndef PIO_UNIT_TESTING
 void setup()
 {
+#if defined(R1_NEO)
+    pinMode(DCDC_EN_HOLD, OUTPUT);
+    digitalWrite(DCDC_EN_HOLD, HIGH);
+    pinMode(NRF_ON, OUTPUT);
+    digitalWrite(NRF_ON, HIGH);
+#endif
 
 #if defined(PIN_POWER_EN)
     pinMode(PIN_POWER_EN, OUTPUT);
@@ -793,14 +799,7 @@ void setup()
     }
 #endif
 
-    // If we're taking on the repeater role, use NextHopRouter and turn off 3V3_S rail because peripherals are not needed
-    if (config.device.role == meshtastic_Config_DeviceConfig_Role_REPEATER) {
-        router = new NextHopRouter();
-#ifdef PIN_3V3_EN
-        digitalWrite(PIN_3V3_EN, LOW);
-#endif
-    } else
-        router = new ReliableRouter();
+    router = new ReliableRouter();
 
     // only play start melody when role is not tracker or sensor
     if (config.power.is_power_saving == true &&
@@ -926,8 +925,7 @@ void setup()
     if (sensor_detected == false) {
 #endif
         if (HAS_GPS) {
-            if (config.device.role != meshtastic_Config_DeviceConfig_Role_REPEATER &&
-                config.position.gps_mode != meshtastic_Config_PositionConfig_GpsMode_NOT_PRESENT) {
+            if (config.position.gps_mode != meshtastic_Config_PositionConfig_GpsMode_NOT_PRESENT) {
                 gps = GPS::createGps();
                 if (gps) {
                     gpsStatus->observe(&gps->newStatus);
@@ -1002,6 +1000,7 @@ void setup()
             config.pullupSense = INPUT_PULLUP;
             config.intRoutine = []() {
                 UserButtonThread->userButton.tick();
+                UserButtonThread->setIntervalFromNow(0);
                 runASAP = true;
                 BaseType_t higherWake = 0;
                 mainDelay.interruptFromISR(&higherWake);
@@ -1022,6 +1021,7 @@ void setup()
     touchConfig.pullupSense = pullup_sense;
     touchConfig.intRoutine = []() {
         TouchButtonThread->userButton.tick();
+        TouchButtonThread->setIntervalFromNow(0);
         runASAP = true;
         BaseType_t higherWake = 0;
         mainDelay.interruptFromISR(&higherWake);
@@ -1041,6 +1041,7 @@ void setup()
     cancelConfig.pullupSense = pullup_sense;
     cancelConfig.intRoutine = []() {
         CancelButtonThread->userButton.tick();
+        CancelButtonThread->setIntervalFromNow(0);
         runASAP = true;
         BaseType_t higherWake = 0;
         mainDelay.interruptFromISR(&higherWake);
@@ -1061,6 +1062,7 @@ void setup()
     backConfig.pullupSense = pullup_sense;
     backConfig.intRoutine = []() {
         BackButtonThread->userButton.tick();
+        BackButtonThread->setIntervalFromNow(0);
         runASAP = true;
         BaseType_t higherWake = 0;
         mainDelay.interruptFromISR(&higherWake);
@@ -1095,6 +1097,7 @@ void setup()
         userConfig.pullupSense = pullup_sense;
         userConfig.intRoutine = []() {
             UserButtonThread->userButton.tick();
+            UserButtonThread->setIntervalFromNow(0);
             runASAP = true;
             BaseType_t higherWake = 0;
             mainDelay.interruptFromISR(&higherWake);
@@ -1112,6 +1115,7 @@ void setup()
         userConfigNoScreen.pullupSense = pullup_sense;
         userConfigNoScreen.intRoutine = []() {
             UserButtonThread->userButton.tick();
+            UserButtonThread->setIntervalFromNow(0);
             runASAP = true;
             BaseType_t higherWake = 0;
             mainDelay.interruptFromISR(&higherWake);
@@ -1607,6 +1611,9 @@ void loop()
 
     // We want to sleep as long as possible here - because it saves power
     if (!runASAP && loopCanSleep()) {
+#ifdef DEBUG_LOOP_TIMING
+        LOG_DEBUG("main loop delay: %d", delayMsec);
+#endif
         mainDelay.delay(delayMsec);
     }
 }

src/mesh/FloodingRouter.cpp

@@ -54,6 +54,10 @@ bool FloodingRouter::shouldFilterReceived(const meshtastic_MeshPacket *p)
             // We already enqueued the improved copy, so make sure the incoming packet stops here.
             return true;
         }
+
+        // No queue entry was replaced by this upgraded copy, so treat it as a duplicate to avoid
+        // delivering the same packet to applications/phone twice with different hop limits.
+        seenRecently = true;
     }
 
     if (seenRecently) {
@@ -81,9 +85,8 @@ bool FloodingRouter::shouldFilterReceived(const meshtastic_MeshPacket *p)
 bool FloodingRouter::roleAllowsCancelingDupe(const meshtastic_MeshPacket *p)
 {
     if (config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER ||
-        config.device.role == meshtastic_Config_DeviceConfig_Role_REPEATER ||
         config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER_LATE) {
-        // ROUTER, REPEATER, ROUTER_LATE should never cancel relaying a packet (i.e. we should always rebroadcast),
+        // ROUTER, ROUTER_LATE should never cancel relaying a packet (i.e. we should always rebroadcast),
         // even if we've heard another station rebroadcast it already.
         return false;
     }
@@ -102,7 +105,7 @@ bool FloodingRouter::roleAllowsCancelingDupe(const meshtastic_MeshPacket *p)
 void FloodingRouter::perhapsCancelDupe(const meshtastic_MeshPacket *p)
 {
     if (p->transport_mechanism == meshtastic_MeshPacket_TransportMechanism_TRANSPORT_LORA && roleAllowsCancelingDupe(p)) {
-        // cancel rebroadcast of this message *if* there was already one, unless we're a router/repeater!
+        // cancel rebroadcast of this message *if* there was already one, unless we're a router!
         // But only LoRa packets should be able to trigger this.
         if (Router::cancelSending(p->from, p->id))
             txRelayCanceled++;
@@ -143,8 +146,7 @@ void FloodingRouter::perhapsRebroadcast(const meshtastic_MeshPacket *p)
 
                 LOG_INFO("Rebroadcast received floodmsg");
                 // Note: we are careful to resend using the original senders node id
-                // We are careful not to call our hooked version of send() - because we don't want to check this again
-                Router::send(tosend);
+                send(tosend);
             } else {
                 LOG_DEBUG("No rebroadcast: Role = CLIENT_MUTE or Rebroadcast Mode = NONE");
             }

src/mesh/FloodingRouter.h

@@ -59,7 +59,7 @@ class FloodingRouter : public Router
      */
     virtual void sniffReceived(const meshtastic_MeshPacket *p, const meshtastic_Routing *c) override;
 
-    // Return false for roles like ROUTER or REPEATER which should always rebroadcast even when we've heard another rebroadcast of
+    // Return false for roles like ROUTER which should always rebroadcast even when we've heard another rebroadcast of
     // the same packet
     bool roleAllowsCancelingDupe(const meshtastic_MeshPacket *p);
 

src/mesh/MeshService.cpp

@@ -85,12 +85,11 @@ int MeshService::handleFromRadio(const meshtastic_MeshPacket *mp)
     powerFSM.trigger(EVENT_PACKET_FOR_PHONE); // Possibly keep the node from sleeping
 
     nodeDB->updateFrom(*mp); // update our DB state based off sniffing every RX packet from the radio
-    bool isPreferredRebroadcaster =
-        IS_ONE_OF(config.device.role, meshtastic_Config_DeviceConfig_Role_ROUTER, meshtastic_Config_DeviceConfig_Role_REPEATER);
+    bool isPreferredRebroadcaster = config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER;
     if (mp->which_payload_variant == meshtastic_MeshPacket_decoded_tag &&
         mp->decoded.portnum == meshtastic_PortNum_TELEMETRY_APP && mp->decoded.request_id > 0) {
-        LOG_DEBUG("Received telemetry response. Skip sending our NodeInfo"); //  because this potentially a Repeater which will
-                                                                             //  ignore our request for its NodeInfo
+        LOG_DEBUG("Received telemetry response. Skip sending our NodeInfo");
+        //  ignore our request for its NodeInfo
     } else if (mp->which_payload_variant == meshtastic_MeshPacket_decoded_tag && !nodeDB->getMeshNode(mp->from)->has_user &&
                nodeInfoModule && !isPreferredRebroadcaster && !nodeDB->isFull()) {
         if (airTime->isTxAllowedChannelUtil(true)) {

src/mesh/NextHopRouter.cpp

@@ -64,6 +64,10 @@ bool NextHopRouter::shouldFilterReceived(const meshtastic_MeshPacket *p)
             // We already enqueued the improved copy, so make sure the incoming packet stops here.
             return true;
         }
+
+        // No queue entry was replaced by this upgraded copy, so treat it as a duplicate to avoid
+        // delivering the same packet to applications/phone twice with different hop limits.
+        seenRecently = true;
     }
 
     if (seenRecently) {
@@ -110,11 +114,14 @@ void NextHopRouter::sniffReceived(const meshtastic_MeshPacket *p, const meshtast
             if (origTx) {
                 // Either relayer of ACK was also a relayer of the packet, or we were the *only* relayer and the ACK came directly
                 // from the destination
-                if (wasRelayer(p->relay_node, p->decoded.request_id, p->to) ||
-                    (p->hop_start != 0 && p->hop_start == p->hop_limit &&
-                     wasSoleRelayer(ourRelayID, p->decoded.request_id, p->to))) {
+                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 (origTx->next_hop != p->relay_node) { // Not already set
-                        LOG_INFO("Update next hop of 0x%x to 0x%x based on ACK/reply", p->from, p->relay_node);
+                        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);
                         origTx->next_hop = p->relay_node;
                     }
                 }
@@ -167,7 +174,6 @@ bool NextHopRouter::perhapsRelay(const meshtastic_MeshPacket *p)
  */
 uint8_t NextHopRouter::getNextHop(NodeNum to, uint8_t relay_node)
 {
-    // When we're a repeater router->sniffReceived will call NextHopRouter directly without checking for broadcast
     if (isBroadcast(to))
         return NO_NEXT_HOP_PREFERENCE;
 
@@ -205,7 +211,7 @@ bool NextHopRouter::roleAllowsCancelingFromTxQueue(const meshtastic_MeshPacket *
 {
     // Return true if we're allowed to cancel a packet in the txQueue (so we may never transmit it even once)
 
-    // Return false for roles like ROUTER, REPEATER, ROUTER_LATE which should always transmit the packet at least once.
+    // Return false for roles like ROUTER, ROUTER_LATE which should always transmit the packet at least once.
 
     return roleAllowsCancelingDupe(p); // same logic as FloodingRouter::roleAllowsCancelingDupe
 }
@@ -218,7 +224,7 @@ bool NextHopRouter::stopRetransmission(GlobalPacketId key)
         /* Only when we already transmitted a packet via LoRa, we will cancel the packet in the Tx queue
           to avoid canceling a transmission if it was ACKed super fast via MQTT */
         if (old->numRetransmissions < NUM_RELIABLE_RETX - 1) {
-            // We only cancel it if we are the original sender or if we're not a router(_late)/repeater
+            // We only cancel it if we are the original sender or if we're not a router(_late)
             if (isFromUs(p) || roleAllowsCancelingFromTxQueue(p)) {
                 // remove the 'original' (identified by originator and packet->id) from the txqueue and free it
                 cancelSending(getFrom(p), p->id);

src/mesh/NodeDB.cpp

@@ -554,10 +554,9 @@ void NodeDB::installDefaultConfig(bool preserveKey = false)
 #endif
 
 #ifdef USERPREFS_CONFIG_DEVICE_ROLE
-    // Restrict ROUTER*, LOST AND FOUND, and REPEATER roles for security reasons
+    // Restrict ROUTER*, LOST AND FOUND roles for security reasons
     if (IS_ONE_OF(USERPREFS_CONFIG_DEVICE_ROLE, meshtastic_Config_DeviceConfig_Role_ROUTER,
-                  meshtastic_Config_DeviceConfig_Role_ROUTER_LATE, meshtastic_Config_DeviceConfig_Role_REPEATER,
-                  meshtastic_Config_DeviceConfig_Role_LOST_AND_FOUND)) {
+                  meshtastic_Config_DeviceConfig_Role_ROUTER_LATE, meshtastic_Config_DeviceConfig_Role_LOST_AND_FOUND)) {
         LOG_WARN("ROUTER roles are restricted, falling back to CLIENT role");
         config.device.role = meshtastic_Config_DeviceConfig_Role_CLIENT;
     } else {
@@ -701,7 +700,7 @@ void NodeDB::installDefaultConfig(bool preserveKey = false)
 #ifdef USERPREFS_NETWORK_ENABLED_PROTOCOLS
     config.network.enabled_protocols = USERPREFS_NETWORK_ENABLED_PROTOCOLS;
 #else
-    config.network.enabled_protocols = 1;
+    config.network.enabled_protocols = 0;
 #endif
 #endif
 
@@ -906,11 +905,6 @@ void NodeDB::installRoleDefaults(meshtastic_Config_DeviceConfig_Role role)
         moduleConfig.telemetry.device_update_interval = ONE_DAY;
         owner.has_is_unmessagable = true;
         owner.is_unmessagable = true;
-    } else if (role == meshtastic_Config_DeviceConfig_Role_REPEATER) {
-        owner.has_is_unmessagable = true;
-        owner.is_unmessagable = true;
-        config.display.screen_on_secs = 1;
-        config.device.rebroadcast_mode = meshtastic_Config_DeviceConfig_RebroadcastMode_CORE_PORTNUMS_ONLY;
     } else if (role == meshtastic_Config_DeviceConfig_Role_SENSOR) {
         owner.has_is_unmessagable = true;
         owner.is_unmessagable = true;
@@ -1667,9 +1661,6 @@ bool NodeDB::updateUser(uint32_t nodeId, meshtastic_User &p, uint8_t channelInde
             return false;
         }
         LOG_INFO("Public Key set for node, not updating!");
-        // we copy the key into the incoming packet, to prevent overwrite
-        p.public_key.size = 32;
-        memcpy(p.public_key.bytes, info->user.public_key.bytes, 32);
     } else if (p.public_key.size == 32) {
         LOG_INFO("Update Node Pubkey!");
     }

src/mesh/PacketHistory.cpp

@@ -67,8 +67,14 @@ bool PacketHistory::wasSeenRecently(const meshtastic_MeshPacket *p, bool withUpd
     r.id = p->id;
     r.sender = getFrom(p); // If 0 then use our ID
     r.next_hop = p->next_hop;
-    r.hop_limit = p->hop_limit;
-    r.relayed_by[0] = p->relay_node;
+    setHighestHopLimit(r, p->hop_limit);
+    bool weWillRelay = false;
+    uint8_t ourRelayID = nodeDB->getLastByteOfNodeNum(nodeDB->getNodeNum());
+    if (p->relay_node == ourRelayID) { // If the relay_node is us, store it
+        weWillRelay = true;
+        setOurTxHopLimit(r, p->hop_limit);
+        r.relayed_by[0] = p->relay_node;
+    }
 
     r.rxTimeMsec = millis(); //
     if (r.rxTimeMsec == 0)   // =0 every 49.7 days? 0 is special
@@ -94,8 +100,6 @@ bool PacketHistory::wasSeenRecently(const meshtastic_MeshPacket *p, bool withUpd
     }
 
     if (seenRecently) {
-        uint8_t ourRelayID = nodeDB->getLastByteOfNodeNum(nodeDB->getNodeNum()); // Get our relay ID from our node number
-
         if (wasFallback) {
             // If it was seen with a next-hop not set to us and now it's NO_NEXT_HOP_PREFERENCE, and the relayer relayed already
             // before, it's a fallback to flooding. If we didn't already relay and the next-hop neither, we might need to handle
@@ -137,16 +141,40 @@ bool PacketHistory::wasSeenRecently(const meshtastic_MeshPacket *p, bool withUpd
                       found->sender, found->id, found->next_hop, found->relayed_by[0], found->relayed_by[1], found->relayed_by[2],
                       millis() - found->rxTimeMsec);
 #endif
+            // Only update the relayer if it heard us directly (meaning hopLimit is decreased by 1)
+            uint8_t startIdx = weWillRelay ? 1 : 0;
+            if (!weWillRelay) {
+                bool weWereRelayer = wasRelayer(ourRelayID, *found);
+                // We were a relayer and the packet came in with a hop limit that is one less than when we sent it out
+                if (weWereRelayer && (p->hop_limit == getOurTxHopLimit(*found) || p->hop_limit == getOurTxHopLimit(*found) - 1)) {
+                    r.relayed_by[0] = p->relay_node;
+                    startIdx = 1; // Start copying existing relayers from index 1
+                }
+                // keep the original ourTxHopLimit
+                setOurTxHopLimit(r, getOurTxHopLimit(*found));
+            }
 
             // Preserve the highest hop_limit we've ever seen for this packet so upgrades aren't lost when a later copy has
             // fewer hops remaining.
-            if (found->hop_limit > r.hop_limit)
-                r.hop_limit = found->hop_limit;
+            if (getHighestHopLimit(*found) > getHighestHopLimit(r))
+                setHighestHopLimit(r, getHighestHopLimit(*found));
 
-            // Add the existing relayed_by to the new record
-            for (uint8_t i = 0; i < (NUM_RELAYERS - 1); i++) {
-                if (found->relayed_by[i] != 0)
-                    r.relayed_by[i + 1] = found->relayed_by[i];
+            // Add the existing relayed_by to the new record, avoiding duplicates
+            for (uint8_t i = 0; i < (NUM_RELAYERS - startIdx); i++) {
+                if (found->relayed_by[i] == 0)
+                    continue;
+
+                bool exists = false;
+                for (uint8_t j = 0; j < NUM_RELAYERS; j++) {
+                    if (r.relayed_by[j] == found->relayed_by[i]) {
+                        exists = true;
+                        break;
+                    }
+                }
+
+                if (!exists) {
+                    r.relayed_by[i + startIdx] = found->relayed_by[i];
+                }
             }
             r.next_hop = found->next_hop; // keep the original next_hop (such that we check whether we were originally asked)
 #if VERBOSE_PACKET_HISTORY
@@ -369,14 +397,6 @@ bool PacketHistory::wasRelayer(const uint8_t relayer, const PacketRecord &r, boo
     return found;
 }
 
-// Check if a certain node was the *only* relayer of a packet in the history given an ID and sender
-bool PacketHistory::wasSoleRelayer(const uint8_t relayer, const uint32_t id, const NodeNum sender)
-{
-    bool wasSole = false;
-    wasRelayer(relayer, id, sender, &wasSole);
-    return wasSole;
-}
-
 // Remove a relayer from the list of relayers of a packet in the history given an ID and sender
 void PacketHistory::removeRelayer(const uint8_t relayer, const uint32_t id, const NodeNum sender)
 {
@@ -418,3 +438,24 @@ void PacketHistory::removeRelayer(const uint8_t relayer, const uint32_t id, cons
               found->id, found->relayed_by[0], found->relayed_by[1], found->relayed_by[2], relayer, i != j);
 #endif
 }
+
+// Getters and setters for hop limit fields packed in hop_limit
+inline uint8_t PacketHistory::getHighestHopLimit(PacketRecord &r)
+{
+    return r.hop_limit & HOP_LIMIT_HIGHEST_MASK;
+}
+
+inline void PacketHistory::setHighestHopLimit(PacketRecord &r, uint8_t hopLimit)
+{
+    r.hop_limit = (r.hop_limit & ~HOP_LIMIT_HIGHEST_MASK) | (hopLimit & HOP_LIMIT_HIGHEST_MASK);
+}
+
+inline uint8_t PacketHistory::getOurTxHopLimit(PacketRecord &r)
+{
+    return (r.hop_limit & HOP_LIMIT_OUR_TX_MASK) >> HOP_LIMIT_OUR_TX_SHIFT;
+}
+
+inline void PacketHistory::setOurTxHopLimit(PacketRecord &r, uint8_t hopLimit)
+{
+    r.hop_limit = (r.hop_limit & ~HOP_LIMIT_OUR_TX_MASK) | ((hopLimit << HOP_LIMIT_OUR_TX_SHIFT) & HOP_LIMIT_OUR_TX_MASK);
+}

src/mesh/PacketHistory.h

@@ -2,8 +2,11 @@
 
 #include "NodeDB.h"
 
-#define NUM_RELAYERS                                                                                                             \
-    3 // Number of relayer we keep track of. Use 3 to be efficient with memory alignment of PacketRecord to 16 bytes
+// Number of relayers we keep track of. Use 6 to be efficient with memory alignment of PacketRecord to 20 bytes
+#define NUM_RELAYERS 6
+#define HOP_LIMIT_HIGHEST_MASK 0x07 // Bits 0-2
+#define HOP_LIMIT_OUR_TX_MASK 0x38  // Bits 3-5
+#define HOP_LIMIT_OUR_TX_SHIFT 3    // Bits 3-5
 
 /**
  * This is a mixin that adds a record of past packets we have seen
@@ -16,9 +19,10 @@ class PacketHistory
         PacketId id;
         uint32_t rxTimeMsec;              // Unix time in msecs - the time we received it,  0 means empty
         uint8_t next_hop;                 // The next hop asked for this packet
-        uint8_t hop_limit;                // Highest hop limit observed for this packet
+        uint8_t hop_limit;                // bit 0-2: Highest hop limit observed for this packet,
+                                          // bit 3-5: our hop limit when we first transmitted it
         uint8_t relayed_by[NUM_RELAYERS]; // Array of nodes that relayed this packet
-    };                                    // 4B + 4B + 4B + 1B + 1B + 3B = 17B (will be padded to 20B)
+    };                                    // 4B + 4B + 4B + 1B + 1B + 6B = 20B
 
     uint32_t recentPacketsCapacity =
         0; // Can be set in constructor, no need to recompile. Used to allocate memory for mx_recentPackets.
@@ -39,6 +43,11 @@ class PacketHistory
      * @return true if node was indeed a relayer, false if not */
     bool wasRelayer(const uint8_t relayer, const PacketRecord &r, bool *wasSole = nullptr);
 
+    uint8_t getHighestHopLimit(PacketRecord &r);
+    void setHighestHopLimit(PacketRecord &r, uint8_t hopLimit);
+    uint8_t getOurTxHopLimit(PacketRecord &r);
+    void setOurTxHopLimit(PacketRecord &r, uint8_t hopLimit);
+
     PacketHistory(const PacketHistory &);            // non construction-copyable
     PacketHistory &operator=(const PacketHistory &); // non copyable
   public:
@@ -61,9 +70,6 @@ class PacketHistory
      * @return true if node was indeed a relayer, false if not */
     bool wasRelayer(const uint8_t relayer, const uint32_t id, const NodeNum sender, bool *wasSole = nullptr);
 
-    // Check if a certain node was the *only* relayer of a packet in the history given an ID and sender
-    bool wasSoleRelayer(const uint8_t relayer, const uint32_t id, const NodeNum sender);
-
     // Remove a relayer from the list of relayers of a packet in the history given an ID and sender
     void removeRelayer(const uint8_t relayer, const uint32_t id, const NodeNum sender);
 

src/mesh/RadioInterface.cpp

@@ -317,9 +317,8 @@ uint32_t RadioInterface::getTxDelayMsecWeightedWorst(float snr)
 /** Returns true if we should rebroadcast early like a ROUTER */
 bool RadioInterface::shouldRebroadcastEarlyLikeRouter(meshtastic_MeshPacket *p)
 {
-    // If we are a ROUTER or REPEATER, we always rebroadcast early
-    if (config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER ||
-        config.device.role == meshtastic_Config_DeviceConfig_Role_REPEATER) {
+    // If we are a ROUTER, we always rebroadcast early
+    if (config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER) {
         return true;
     }
 

src/mesh/Router.cpp

@@ -90,7 +90,7 @@ bool Router::shouldDecrementHopLimit(const meshtastic_MeshPacket *p)
     // For subsequent hops, check if previous relay is a favorite router
     // Optimized search for favorite routers with matching last byte
     // Check ordering optimized for IoT devices (cheapest checks first)
-    for (int i = 0; i < nodeDB->getNumMeshNodes(); i++) {
+    for (size_t i = 0; i < nodeDB->getNumMeshNodes(); i++) {
         meshtastic_NodeInfoLite *node = nodeDB->getMeshNodeByIndex(i);
         if (!node)
             continue;
@@ -105,7 +105,7 @@ bool Router::shouldDecrementHopLimit(const meshtastic_MeshPacket *p)
 
         // Check 3: role check (moderate cost - multiple comparisons)
         if (!IS_ONE_OF(node->user.role, meshtastic_Config_DeviceConfig_Role_ROUTER,
-                       meshtastic_Config_DeviceConfig_Role_ROUTER_LATE, meshtastic_Config_DeviceConfig_Role_CLIENT_BASE)) {
+                       meshtastic_Config_DeviceConfig_Role_ROUTER_LATE)) {
             continue;
         }
 
@@ -399,10 +399,6 @@ DecodeState perhapsDecode(meshtastic_MeshPacket *p)
 {
     concurrency::LockGuard g(cryptLock);
 
-    if (config.device.role == meshtastic_Config_DeviceConfig_Role_REPEATER &&
-        config.device.rebroadcast_mode == meshtastic_Config_DeviceConfig_RebroadcastMode_ALL_SKIP_DECODING)
-        return DecodeState::DECODE_FAILURE;
-
     if (config.device.rebroadcast_mode == meshtastic_Config_DeviceConfig_RebroadcastMode_KNOWN_ONLY &&
         (nodeDB->getMeshNode(p->from) == NULL || !nodeDB->getMeshNode(p->from)->has_user)) {
         LOG_DEBUG("Node 0x%x not in nodeDB-> Rebroadcast mode KNOWN_ONLY will ignore packet", p->from);
@@ -483,35 +479,6 @@ DecodeState perhapsDecode(meshtastic_MeshPacket *p)
         }
     }
 
-#if HAS_UDP_MULTICAST
-    // Fallback: for UDP multicast, try default preset names with default PSK if normal channel match failed
-    if (!decrypted && p->transport_mechanism == meshtastic_MeshPacket_TransportMechanism_TRANSPORT_MULTICAST_UDP) {
-        if (channels.setDefaultPresetCryptoForHash(p->channel)) {
-            memcpy(bytes, p->encrypted.bytes, rawSize);
-            crypto->decrypt(p->from, p->id, rawSize, bytes);
-
-            meshtastic_Data decodedtmp;
-            memset(&decodedtmp, 0, sizeof(decodedtmp));
-            if (pb_decode_from_bytes(bytes, rawSize, &meshtastic_Data_msg, &decodedtmp) &&
-                decodedtmp.portnum != meshtastic_PortNum_UNKNOWN_APP) {
-                p->decoded = decodedtmp;
-                p->which_payload_variant = meshtastic_MeshPacket_decoded_tag;
-                // Map to our local default channel index (name+PSK default), not necessarily primary
-                ChannelIndex defaultIndex = channels.getPrimaryIndex();
-                for (ChannelIndex i = 0; i < channels.getNumChannels(); ++i) {
-                    if (channels.isDefaultChannel(i)) {
-                        defaultIndex = i;
-                        break;
-                    }
-                }
-                chIndex = defaultIndex;
-                decrypted = true;
-            } else {
-                LOG_WARN("UDP fallback decode attempted but failed for hash 0x%x", p->channel);
-            }
-        }
-    }
-#endif
     if (decrypted) {
         // parsing was successful
         p->channel = chIndex; // change to store the index instead of the hash

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

@@ -55,7 +55,7 @@ extern const pb_msgdesc_t meshtastic_ChannelSet_msg;
 
 /* Maximum encoded size of messages (where known) */
 #define MESHTASTIC_MESHTASTIC_APPONLY_PB_H_MAX_SIZE meshtastic_ChannelSet_size
-#define meshtastic_ChannelSet_size               679
+#define meshtastic_ChannelSet_size               695
 
 #ifdef __cplusplus
 } /* extern "C" */

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

@@ -97,6 +97,8 @@ typedef struct _meshtastic_ChannelSettings {
     /* Per-channel module settings. */
     bool has_module_settings;
     meshtastic_ModuleSettings module_settings;
+    /* Whether or not we should receive notifactions / alerts through this channel */
+    bool mute;
 } meshtastic_ChannelSettings;
 
 /* A pair of a channel number, mode and the (sharable) settings for that channel */
@@ -128,10 +130,10 @@ extern "C" {
 
 
 /* Initializer values for message structs */
-#define meshtastic_ChannelSettings_init_default  {0, {0, {0}}, "", 0, 0, 0, false, meshtastic_ModuleSettings_init_default}
+#define meshtastic_ChannelSettings_init_default  {0, {0, {0}}, "", 0, 0, 0, false, meshtastic_ModuleSettings_init_default, 0}
 #define meshtastic_ModuleSettings_init_default   {0, 0}
 #define meshtastic_Channel_init_default          {0, false, meshtastic_ChannelSettings_init_default, _meshtastic_Channel_Role_MIN}
-#define meshtastic_ChannelSettings_init_zero     {0, {0, {0}}, "", 0, 0, 0, false, meshtastic_ModuleSettings_init_zero}
+#define meshtastic_ChannelSettings_init_zero     {0, {0, {0}}, "", 0, 0, 0, false, meshtastic_ModuleSettings_init_zero, 0}
 #define meshtastic_ModuleSettings_init_zero      {0, 0}
 #define meshtastic_Channel_init_zero             {0, false, meshtastic_ChannelSettings_init_zero, _meshtastic_Channel_Role_MIN}
 
@@ -145,6 +147,7 @@ extern "C" {
 #define meshtastic_ChannelSettings_uplink_enabled_tag 5
 #define meshtastic_ChannelSettings_downlink_enabled_tag 6
 #define meshtastic_ChannelSettings_module_settings_tag 7
+#define meshtastic_ChannelSettings_mute_tag      8
 #define meshtastic_Channel_index_tag             1
 #define meshtastic_Channel_settings_tag          2
 #define meshtastic_Channel_role_tag              3
@@ -157,7 +160,8 @@ X(a, STATIC,   SINGULAR, STRING,   name,              3) \
 X(a, STATIC,   SINGULAR, FIXED32,  id,                4) \
 X(a, STATIC,   SINGULAR, BOOL,     uplink_enabled,    5) \
 X(a, STATIC,   SINGULAR, BOOL,     downlink_enabled,   6) \
-X(a, STATIC,   OPTIONAL, MESSAGE,  module_settings,   7)
+X(a, STATIC,   OPTIONAL, MESSAGE,  module_settings,   7) \
+X(a, STATIC,   SINGULAR, BOOL,     mute,              8)
 #define meshtastic_ChannelSettings_CALLBACK NULL
 #define meshtastic_ChannelSettings_DEFAULT NULL
 #define meshtastic_ChannelSettings_module_settings_MSGTYPE meshtastic_ModuleSettings
@@ -187,8 +191,8 @@ extern const pb_msgdesc_t meshtastic_Channel_msg;
 
 /* Maximum encoded size of messages (where known) */
 #define MESHTASTIC_MESHTASTIC_CHANNEL_PB_H_MAX_SIZE meshtastic_Channel_size
-#define meshtastic_ChannelSettings_size          72
-#define meshtastic_Channel_size                  87
+#define meshtastic_ChannelSettings_size          74
+#define meshtastic_Channel_size                  89
 #define meshtastic_ModuleSettings_size           8
 
 #ifdef __cplusplus

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

@@ -26,7 +26,8 @@ typedef enum _meshtastic_Config_DeviceConfig_Role {
     meshtastic_Config_DeviceConfig_Role_ROUTER_CLIENT = 3,
     /* Description: Infrastructure node for extending network coverage by relaying messages with minimal overhead. Not visible in Nodes list.
  Technical Details: Mesh packets will simply be rebroadcasted over this node. Nodes configured with this role will not originate NodeInfo, Position, Telemetry
-   or any other packet type. They will simply rebroadcast any mesh packets on the same frequency, channel num, spread factor, and coding rate. */
+   or any other packet type. They will simply rebroadcast any mesh packets on the same frequency, channel num, spread factor, and coding rate.
+ Deprecated in v2.7.11 because it creates "holes" in the mesh rebroadcast chain. */
     meshtastic_Config_DeviceConfig_Role_REPEATER = 4,
     /* Description: Broadcasts GPS position packets as priority.
  Technical Details: Position Mesh packets will be prioritized higher and sent more frequently by default.

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

@@ -360,8 +360,8 @@ extern const pb_msgdesc_t meshtastic_BackupPreferences_msg;
 /* Maximum encoded size of messages (where known) */
 /* meshtastic_NodeDatabase_size depends on runtime parameters */
 #define MESHTASTIC_MESHTASTIC_DEVICEONLY_PB_H_MAX_SIZE meshtastic_BackupPreferences_size
-#define meshtastic_BackupPreferences_size        2277
-#define meshtastic_ChannelFile_size              718
+#define meshtastic_BackupPreferences_size        2293
+#define meshtastic_ChannelFile_size              734
 #define meshtastic_DeviceState_size              1737
 #define meshtastic_NodeInfoLite_size             196
 #define meshtastic_PositionLite_size             28

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

@@ -253,8 +253,8 @@ typedef enum _meshtastic_HardwareModel {
     meshtastic_HardwareModel_SEEED_WIO_TRACKER_L1 = 99,
     /* Seeed Tracker L1 EINK driver */
     meshtastic_HardwareModel_SEEED_WIO_TRACKER_L1_EINK = 100,
-    /* Reserved ID for future and past use */
-    meshtastic_HardwareModel_QWANTZ_TINY_ARMS = 101,
+    /* Muzi Works R1 Neo */
+    meshtastic_HardwareModel_MUZI_R1_NEO = 101,
     /* Lilygo T-Deck Pro */
     meshtastic_HardwareModel_T_DECK_PRO = 102,
     /* Lilygo TLora Pager */

src/modules/AdminModule.cpp

@@ -611,10 +611,9 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c)
         }
         config.device = c.payload_variant.device;
         if (config.device.rebroadcast_mode == meshtastic_Config_DeviceConfig_RebroadcastMode_NONE &&
-            IS_ONE_OF(config.device.role, meshtastic_Config_DeviceConfig_Role_ROUTER,
-                      meshtastic_Config_DeviceConfig_Role_REPEATER)) {
+            config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER) {
             config.device.rebroadcast_mode = meshtastic_Config_DeviceConfig_RebroadcastMode_ALL;
-            const char *warning = "Rebroadcast mode can't be set to NONE for a router or repeater";
+            const char *warning = "Rebroadcast mode can't be set to NONE for a router";
             LOG_WARN(warning);
             sendWarning(warning);
         }
@@ -627,8 +626,9 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c)
             LOG_DEBUG("Tried to set node_info_broadcast_secs too low, setting to %d", min_node_info_broadcast_secs);
             config.device.node_info_broadcast_secs = min_node_info_broadcast_secs;
         }
-        // Router Client is deprecated; Set it to client
-        if (c.payload_variant.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER_CLIENT) {
+        // Router Client and Repeater deprecated; Set it to client
+        if (IS_ONE_OF(c.payload_variant.device.role, meshtastic_Config_DeviceConfig_Role_ROUTER_CLIENT,
+                      meshtastic_Config_DeviceConfig_Role_REPEATER)) {
             config.device.role = meshtastic_Config_DeviceConfig_Role_CLIENT;
             if (moduleConfig.store_forward.enabled && !moduleConfig.store_forward.is_server) {
                 moduleConfig.store_forward.is_server = true;
@@ -637,10 +637,9 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c)
             }
         }
 #if USERPREFS_EVENT_MODE
-        // If we're in event mode, nobody is a Router or Repeater
+        // If we're in event mode, nobody is a Router or Router Late
         if (config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER ||
-            config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER_LATE ||
-            config.device.role == meshtastic_Config_DeviceConfig_Role_REPEATER) {
+            config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER_LATE) {
             config.device.role = meshtastic_Config_DeviceConfig_Role_CLIENT;
         }
 #endif
@@ -707,20 +706,40 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c)
 #endif
         config.display = c.payload_variant.display;
         break;
-    case meshtastic_Config_lora_tag:
+
+    case meshtastic_Config_lora_tag: {
+        // Wrap the entire case in a block to scope variables and avoid crossing initialization
+        auto oldLoraConfig = config.lora;
+        auto validatedLora = c.payload_variant.lora;
+
         LOG_INFO("Set config: LoRa");
         config.has_lora = true;
+
+        if (validatedLora.coding_rate < 4 || validatedLora.coding_rate > 8) {
+            LOG_WARN("Invalid coding_rate %d, setting to 5", validatedLora.coding_rate);
+            validatedLora.coding_rate = 5;
+        }
+
+        if (validatedLora.spread_factor < 7 || validatedLora.spread_factor > 12) {
+            LOG_WARN("Invalid spread_factor %d, setting to 11", validatedLora.spread_factor);
+            validatedLora.spread_factor = 11;
+        }
+
+        if (validatedLora.bandwidth == 0) {
+            int originalBandwidth = validatedLora.bandwidth;
+            validatedLora.bandwidth = myRegion->wideLora ? 800 : 250;
+            LOG_WARN("Invalid bandwidth %d, setting to default", originalBandwidth);
+        }
+
         // If no lora radio parameters change, don't need to reboot
-        if (config.lora.use_preset == c.payload_variant.lora.use_preset && config.lora.region == c.payload_variant.lora.region &&
-            config.lora.modem_preset == c.payload_variant.lora.modem_preset &&
-            config.lora.bandwidth == c.payload_variant.lora.bandwidth &&
-            config.lora.spread_factor == c.payload_variant.lora.spread_factor &&
-            config.lora.coding_rate == c.payload_variant.lora.coding_rate &&
-            config.lora.tx_power == c.payload_variant.lora.tx_power &&
-            config.lora.frequency_offset == c.payload_variant.lora.frequency_offset &&
-            config.lora.override_frequency == c.payload_variant.lora.override_frequency &&
-            config.lora.channel_num == c.payload_variant.lora.channel_num &&
-            config.lora.sx126x_rx_boosted_gain == c.payload_variant.lora.sx126x_rx_boosted_gain) {
+        if (oldLoraConfig.use_preset == validatedLora.use_preset && oldLoraConfig.region == validatedLora.region &&
+            oldLoraConfig.modem_preset == validatedLora.modem_preset && oldLoraConfig.bandwidth == validatedLora.bandwidth &&
+            oldLoraConfig.spread_factor == validatedLora.spread_factor &&
+            oldLoraConfig.coding_rate == validatedLora.coding_rate && oldLoraConfig.tx_power == validatedLora.tx_power &&
+            oldLoraConfig.frequency_offset == validatedLora.frequency_offset &&
+            oldLoraConfig.override_frequency == validatedLora.override_frequency &&
+            oldLoraConfig.channel_num == validatedLora.channel_num &&
+            oldLoraConfig.sx126x_rx_boosted_gain == validatedLora.sx126x_rx_boosted_gain) {
             requiresReboot = false;
         }
 
@@ -739,7 +758,7 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c)
             digitalWrite(RF95_FAN_EN, HIGH ^ 0);
         }
 #endif
-        config.lora = c.payload_variant.lora;
+        config.lora = validatedLora;
         // If we're setting region for the first time, init the region and regenerate the keys
         if (isRegionUnset && config.lora.region > meshtastic_Config_LoRaConfig_RegionCode_UNSET) {
             if (!owner.is_licensed) {
@@ -771,6 +790,7 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c)
             }
         }
         break;
+    }
     case meshtastic_Config_bluetooth_tag:
         LOG_INFO("Set config: Bluetooth");
         config.has_bluetooth = true;

src/modules/ExternalNotificationModule.cpp

@@ -69,7 +69,7 @@ bool ascending = true;
 #endif
 #define EXT_NOTIFICATION_MODULE_OUTPUT_MS 1000
 
-#define EXT_NOTIFICATION_DEFAULT_THREAD_MS 25
+#define EXT_NOTIFICATION_FAST_THREAD_MS 25
 
 #define ASCII_BELL 0x07
 
@@ -88,12 +88,13 @@ int32_t ExternalNotificationModule::runOnce()
     if (!moduleConfig.external_notification.enabled) {
         return INT32_MAX; // we don't need this thread here...
     } else {
-
-        bool isPlaying = rtttl::isPlaying();
+        uint32_t delay = EXT_NOTIFICATION_MODULE_OUTPUT_MS;
+        bool isRtttlPlaying = rtttl::isPlaying();
 #ifdef HAS_I2S
-        isPlaying = rtttl::isPlaying() || audioThread->isPlaying();
+        // audioThread->isPlaying() also handles actually playing the RTTTL, needs to be called in loop
+        isRtttlPlaying = isRtttlPlaying || audioThread->isPlaying();
 #endif
-        if ((nagCycleCutoff < millis()) && !isPlaying) {
+        if ((nagCycleCutoff < millis()) && !isRtttlPlaying) {
             // let the song finish if we reach timeout
             nagCycleCutoff = UINT32_MAX;
             LOG_INFO("Turning off external notification: ");
@@ -116,21 +117,16 @@ int32_t ExternalNotificationModule::runOnce()
 
         // If the output is turned on, turn it back off after the given period of time.
         if (isNagging) {
-            if (externalTurnedOn[0] + (moduleConfig.external_notification.output_ms ? moduleConfig.external_notification.output_ms
-                                                                                    : EXT_NOTIFICATION_MODULE_OUTPUT_MS) <
-                millis()) {
+            delay = (moduleConfig.external_notification.output_ms ? moduleConfig.external_notification.output_ms
+                                                                  : EXT_NOTIFICATION_MODULE_OUTPUT_MS);
+            if (externalTurnedOn[0] + delay < millis()) {
                 setExternalState(0, !getExternal(0));
             }
-            if (externalTurnedOn[1] + (moduleConfig.external_notification.output_ms ? moduleConfig.external_notification.output_ms
-                                                                                    : EXT_NOTIFICATION_MODULE_OUTPUT_MS) <
-                millis()) {
+            if (externalTurnedOn[1] + delay < millis()) {
                 setExternalState(1, !getExternal(1));
             }
             // Only toggle buzzer output if not using PWM mode (to avoid conflict with RTTTL)
-            if (!moduleConfig.external_notification.use_pwm &&
-                externalTurnedOn[2] + (moduleConfig.external_notification.output_ms ? moduleConfig.external_notification.output_ms
-                                                                                    : EXT_NOTIFICATION_MODULE_OUTPUT_MS) <
-                    millis()) {
+            if (!moduleConfig.external_notification.use_pwm && externalTurnedOn[2] + delay < millis()) {
                 LOG_DEBUG("EXTERNAL 2 %d compared to %d", externalTurnedOn[2] + moduleConfig.external_notification.output_ms,
                           millis());
                 setExternalState(2, !getExternal(2));
@@ -181,6 +177,8 @@ int32_t ExternalNotificationModule::runOnce()
                     colorState = 1;
                 }
             }
+            // we need fast updates for the color change
+            delay = EXT_NOTIFICATION_FAST_THREAD_MS;
 #endif
 
 #ifdef T_WATCH_S3
@@ -190,12 +188,14 @@ int32_t ExternalNotificationModule::runOnce()
 
         // Play RTTTL over i2s audio interface if enabled as buzzer
 #ifdef HAS_I2S
-        if (moduleConfig.external_notification.use_i2s_as_buzzer && canBuzz()) {
+        if (moduleConfig.external_notification.use_i2s_as_buzzer) {
             if (audioThread->isPlaying()) {
                 // Continue playing
             } else if (isNagging && (nagCycleCutoff >= millis())) {
                 audioThread->beginRttl(rtttlConfig.ringtone, strlen_P(rtttlConfig.ringtone));
             }
+            // we need fast updates to play the RTTTL
+            delay = EXT_NOTIFICATION_FAST_THREAD_MS;
         }
 #endif
         // now let the PWM buzzer play
@@ -206,9 +206,11 @@ int32_t ExternalNotificationModule::runOnce()
                 // start the song again if we have time left
                 rtttl::begin(config.device.buzzer_gpio, rtttlConfig.ringtone);
             }
+            // we need fast updates to play the RTTTL
+            delay = EXT_NOTIFICATION_FAST_THREAD_MS;
         }
 
-        return EXT_NOTIFICATION_DEFAULT_THREAD_MS;
+        return delay;
     }
 }
 

src/modules/Modules.cpp

@@ -112,204 +112,191 @@
  */
 void setupModules()
 {
-    if (config.device.role != meshtastic_Config_DeviceConfig_Role_REPEATER) {
 #if (HAS_BUTTON || ARCH_PORTDUINO) && !MESHTASTIC_EXCLUDE_INPUTBROKER
-        if (config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_COLOR) {
-            inputBroker = new InputBroker();
-            systemCommandsModule = new SystemCommandsModule();
-            buzzerFeedbackThread = new BuzzerFeedbackThread();
-        }
+    if (config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_COLOR) {
+        inputBroker = new InputBroker();
+        systemCommandsModule = new SystemCommandsModule();
+        buzzerFeedbackThread = new BuzzerFeedbackThread();
+    }
 #endif
 #if !MESHTASTIC_EXCLUDE_ADMIN
-        adminModule = new AdminModule();
+    adminModule = new AdminModule();
 #endif
 #if !MESHTASTIC_EXCLUDE_NODEINFO
-        nodeInfoModule = new NodeInfoModule();
+    nodeInfoModule = new NodeInfoModule();
 #endif
 #if !MESHTASTIC_EXCLUDE_GPS
-        positionModule = new PositionModule();
+    positionModule = new PositionModule();
 #endif
 #if !MESHTASTIC_EXCLUDE_WAYPOINT
-        waypointModule = new WaypointModule();
+    waypointModule = new WaypointModule();
 #endif
 #if !MESHTASTIC_EXCLUDE_TEXTMESSAGE
-        textMessageModule = new TextMessageModule();
+    textMessageModule = new TextMessageModule();
 #endif
 #if !MESHTASTIC_EXCLUDE_TRACEROUTE
-        traceRouteModule = new TraceRouteModule();
+    traceRouteModule = new TraceRouteModule();
 #endif
 #if !MESHTASTIC_EXCLUDE_NEIGHBORINFO
-        if (moduleConfig.has_neighbor_info && moduleConfig.neighbor_info.enabled) {
-            neighborInfoModule = new NeighborInfoModule();
-        }
+    if (moduleConfig.has_neighbor_info && moduleConfig.neighbor_info.enabled) {
+        neighborInfoModule = new NeighborInfoModule();
+    }
 #endif
 #if !MESHTASTIC_EXCLUDE_DETECTIONSENSOR
-        if (moduleConfig.has_detection_sensor && moduleConfig.detection_sensor.enabled) {
-            detectionSensorModule = new DetectionSensorModule();
-        }
+    if (moduleConfig.has_detection_sensor && moduleConfig.detection_sensor.enabled) {
+        detectionSensorModule = new DetectionSensorModule();
+    }
 #endif
 #if !MESHTASTIC_EXCLUDE_ATAK
-        if (IS_ONE_OF(config.device.role, meshtastic_Config_DeviceConfig_Role_TAK,
-                      meshtastic_Config_DeviceConfig_Role_TAK_TRACKER)) {
-            atakPluginModule = new AtakPluginModule();
-        }
+    if (IS_ONE_OF(config.device.role, meshtastic_Config_DeviceConfig_Role_TAK, meshtastic_Config_DeviceConfig_Role_TAK_TRACKER)) {
+        atakPluginModule = new AtakPluginModule();
+    }
 #endif
 #if !MESHTASTIC_EXCLUDE_PKI
-        keyVerificationModule = new KeyVerificationModule();
+    keyVerificationModule = new KeyVerificationModule();
 #endif
 #if !MESHTASTIC_EXCLUDE_DROPZONE
-        dropzoneModule = new DropzoneModule();
+    dropzoneModule = new DropzoneModule();
 #endif
 #if !MESHTASTIC_EXCLUDE_GENERIC_THREAD_MODULE
-        new GenericThreadModule();
+    new GenericThreadModule();
 #endif
-        // Note: if the rest of meshtastic doesn't need to explicitly use your module, you do not need to assign the instance
-        // to a global variable.
+    // Note: if the rest of meshtastic doesn't need to explicitly use your module, you do not need to assign the instance
+    // to a global variable.
 
 #if !MESHTASTIC_EXCLUDE_REMOTEHARDWARE
-        new RemoteHardwareModule();
+    new RemoteHardwareModule();
 #endif
 #if !MESHTASTIC_EXCLUDE_POWERSTRESS
-        new PowerStressModule();
+    new PowerStressModule();
 #endif
-        // Example: Put your module here
-        // new ReplyModule();
+    // Example: Put your module here
+    // new ReplyModule();
 #if (HAS_BUTTON || ARCH_PORTDUINO) && !MESHTASTIC_EXCLUDE_INPUTBROKER
-        if (config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_COLOR) {
-            rotaryEncoderInterruptImpl1 = new RotaryEncoderInterruptImpl1();
-            if (!rotaryEncoderInterruptImpl1->init()) {
-                delete rotaryEncoderInterruptImpl1;
-                rotaryEncoderInterruptImpl1 = nullptr;
-            }
+    if (config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_COLOR) {
+        rotaryEncoderInterruptImpl1 = new RotaryEncoderInterruptImpl1();
+        if (!rotaryEncoderInterruptImpl1->init()) {
+            delete rotaryEncoderInterruptImpl1;
+            rotaryEncoderInterruptImpl1 = nullptr;
+        }
 #ifdef T_LORA_PAGER
-            // use a special FSM based rotary encoder version for T-LoRa Pager
-            rotaryEncoderImpl = new RotaryEncoderImpl();
-            if (!rotaryEncoderImpl->init()) {
-                delete rotaryEncoderImpl;
-                rotaryEncoderImpl = nullptr;
-            }
+        // use a special FSM based rotary encoder version for T-LoRa Pager
+        rotaryEncoderImpl = new RotaryEncoderImpl();
+        if (!rotaryEncoderImpl->init()) {
+            delete rotaryEncoderImpl;
+            rotaryEncoderImpl = nullptr;
+        }
 #else
-            upDownInterruptImpl1 = new UpDownInterruptImpl1();
-            if (!upDownInterruptImpl1->init()) {
-                delete upDownInterruptImpl1;
-                upDownInterruptImpl1 = nullptr;
-            }
+        upDownInterruptImpl1 = new UpDownInterruptImpl1();
+        if (!upDownInterruptImpl1->init()) {
+            delete upDownInterruptImpl1;
+            upDownInterruptImpl1 = nullptr;
+        }
 #endif
-            cardKbI2cImpl = new CardKbI2cImpl();
-            cardKbI2cImpl->init();
+        cardKbI2cImpl = new CardKbI2cImpl();
+        cardKbI2cImpl->init();
 #if defined(M5STACK_UNITC6L)
-            i2cButton = new i2cButtonThread("i2cButtonThread");
+        i2cButton = new i2cButtonThread("i2cButtonThread");
 #endif
 #ifdef INPUTBROKER_MATRIX_TYPE
-            kbMatrixImpl = new KbMatrixImpl();
-            kbMatrixImpl->init();
+        kbMatrixImpl = new KbMatrixImpl();
+        kbMatrixImpl->init();
 #endif // INPUTBROKER_MATRIX_TYPE
 #ifdef INPUTBROKER_SERIAL_TYPE
-            aSerialKeyboardImpl = new SerialKeyboardImpl();
-            aSerialKeyboardImpl->init();
+        aSerialKeyboardImpl = new SerialKeyboardImpl();
+        aSerialKeyboardImpl->init();
 #endif // INPUTBROKER_MATRIX_TYPE
-        }
+    }
 #endif // HAS_BUTTON
 #if ARCH_PORTDUINO
-        if (config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_COLOR) {
-            seesawRotary = new SeesawRotary("SeesawRotary");
-            if (!seesawRotary->init()) {
-                delete seesawRotary;
-                seesawRotary = nullptr;
-            }
-            aLinuxInputImpl = new LinuxInputImpl();
-            aLinuxInputImpl->init();
+    if (config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_COLOR) {
+        seesawRotary = new SeesawRotary("SeesawRotary");
+        if (!seesawRotary->init()) {
+            delete seesawRotary;
+            seesawRotary = nullptr;
         }
+        aLinuxInputImpl = new LinuxInputImpl();
+        aLinuxInputImpl->init();
+    }
 #endif
 #if !MESHTASTIC_EXCLUDE_INPUTBROKER && HAS_TRACKBALL
-        if (config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_COLOR) {
-            trackballInterruptImpl1 = new TrackballInterruptImpl1();
-            trackballInterruptImpl1->init(TB_DOWN, TB_UP, TB_LEFT, TB_RIGHT, TB_PRESS);
-        }
+    if (config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_COLOR) {
+        trackballInterruptImpl1 = new TrackballInterruptImpl1();
+        trackballInterruptImpl1->init(TB_DOWN, TB_UP, TB_LEFT, TB_RIGHT, TB_PRESS);
+    }
 #endif
 #ifdef INPUTBROKER_EXPRESSLRSFIVEWAY_TYPE
-        expressLRSFiveWayInput = new ExpressLRSFiveWay();
+    expressLRSFiveWayInput = new ExpressLRSFiveWay();
 #endif
 #if HAS_SCREEN && !MESHTASTIC_EXCLUDE_CANNEDMESSAGES
-        if (config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_COLOR) {
-            cannedMessageModule = new CannedMessageModule();
-        }
+    if (config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_COLOR) {
+        cannedMessageModule = new CannedMessageModule();
+    }
 #endif
 #if ARCH_PORTDUINO
-        new HostMetricsModule();
+    new HostMetricsModule();
 #endif
 #if HAS_TELEMETRY
-        new DeviceTelemetryModule();
+    new DeviceTelemetryModule();
 #endif
 #if HAS_TELEMETRY && HAS_SENSOR && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR
-        if (moduleConfig.has_telemetry &&
-            (moduleConfig.telemetry.environment_measurement_enabled || moduleConfig.telemetry.environment_screen_enabled)) {
-            new EnvironmentTelemetryModule();
-        }
+    if (moduleConfig.has_telemetry &&
+        (moduleConfig.telemetry.environment_measurement_enabled || moduleConfig.telemetry.environment_screen_enabled)) {
+        new EnvironmentTelemetryModule();
+    }
 #if __has_include("Adafruit_PM25AQI.h")
-        if (moduleConfig.has_telemetry && moduleConfig.telemetry.air_quality_enabled &&
-            nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_PMSA003I].first > 0) {
-            new AirQualityTelemetryModule();
-        }
+    if (moduleConfig.has_telemetry && moduleConfig.telemetry.air_quality_enabled &&
+        nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_PMSA003I].first > 0) {
+        new AirQualityTelemetryModule();
+    }
 #endif
 #if !MESHTASTIC_EXCLUDE_HEALTH_TELEMETRY
-        if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_MAX30102].first > 0 ||
-            nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_MLX90614].first > 0) {
-            new HealthTelemetryModule();
-        }
+    if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_MAX30102].first > 0 ||
+        nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_MLX90614].first > 0) {
+        new HealthTelemetryModule();
+    }
 #endif
 #endif
 #if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_POWER_TELEMETRY && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR
-        if (moduleConfig.has_telemetry &&
-            (moduleConfig.telemetry.power_measurement_enabled || moduleConfig.telemetry.power_screen_enabled)) {
-            new PowerTelemetryModule();
-        }
+    if (moduleConfig.has_telemetry &&
+        (moduleConfig.telemetry.power_measurement_enabled || moduleConfig.telemetry.power_screen_enabled)) {
+        new PowerTelemetryModule();
+    }
 #endif
 #if (defined(ARCH_ESP32) || defined(ARCH_NRF52) || defined(ARCH_RP2040) || defined(ARCH_STM32WL)) &&                             \
     !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32C3)
 #if !MESHTASTIC_EXCLUDE_SERIAL
-        if (moduleConfig.has_serial && moduleConfig.serial.enabled &&
-            config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_COLOR) {
-            new SerialModule();
-        }
+    if (moduleConfig.has_serial && moduleConfig.serial.enabled &&
+        config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_COLOR) {
+        new SerialModule();
+    }
 #endif
 #endif
 #ifdef ARCH_ESP32
-        // Only run on an esp32 based device.
+    // Only run on an esp32 based device.
 #if defined(USE_SX1280) && !MESHTASTIC_EXCLUDE_AUDIO
-        audioModule = new AudioModule();
+    audioModule = new AudioModule();
 #endif
 #if !MESHTASTIC_EXCLUDE_PAXCOUNTER
-        if (moduleConfig.has_paxcounter && moduleConfig.paxcounter.enabled) {
-            paxcounterModule = new PaxcounterModule();
-        }
+    if (moduleConfig.has_paxcounter && moduleConfig.paxcounter.enabled) {
+        paxcounterModule = new PaxcounterModule();
+    }
 #endif
 #endif
 #if defined(ARCH_ESP32) || defined(ARCH_PORTDUINO)
 #if !MESHTASTIC_EXCLUDE_STOREFORWARD
-        if (moduleConfig.has_store_forward && moduleConfig.store_forward.enabled) {
-            storeForwardModule = new StoreForwardModule();
-        }
+    if (moduleConfig.has_store_forward && moduleConfig.store_forward.enabled) {
+        storeForwardModule = new StoreForwardModule();
+    }
 #endif
 #endif
 #if !MESHTASTIC_EXCLUDE_EXTERNALNOTIFICATION
-        externalNotificationModule = new ExternalNotificationModule();
+    externalNotificationModule = new ExternalNotificationModule();
 #endif
 #if !MESHTASTIC_EXCLUDE_RANGETEST && !MESHTASTIC_EXCLUDE_GPS
-        if (moduleConfig.has_range_test && moduleConfig.range_test.enabled)
-            new RangeTestModule();
+    if (moduleConfig.has_range_test && moduleConfig.range_test.enabled)
+        new RangeTestModule();
 #endif
-    } else {
-#if !MESHTASTIC_EXCLUDE_ADMIN
-        adminModule = new AdminModule();
-#endif
-#if HAS_TELEMETRY
-        new DeviceTelemetryModule();
-#endif
-#if !MESHTASTIC_EXCLUDE_TRACEROUTE
-        traceRouteModule = new TraceRouteModule();
-#endif
-    }
     // NOTE! This module must be added LAST because it likes to check for replies from other modules and avoid sending extra
     // acks
     routingModule = new RoutingModule();

src/modules/NodeInfoModule.cpp

@@ -94,11 +94,6 @@ meshtastic_MeshPacket *NodeInfoModule::allocReply()
             u.public_key.bytes[0] = 0;
             u.public_key.size = 0;
         }
-        // Coerce unmessagable for Repeater role
-        if (u.role == meshtastic_Config_DeviceConfig_Role_REPEATER) {
-            u.has_is_unmessagable = true;
-            u.is_unmessagable = true;
-        }
 
         LOG_INFO("Send owner %s/%s/%s", u.id, u.long_name, u.short_name);
         lastSentToMesh = millis();

src/modules/RangeTestModule.cpp

@@ -41,12 +41,12 @@ int32_t RangeTestModule::runOnce()
     // moduleConfig.range_test.enabled = 1;
     // moduleConfig.range_test.sender = 30;
     // moduleConfig.range_test.save = 1;
+    // moduleConfig.range_test.clear_on_reboot = 1;
 
     // Fixed position is useful when testing indoors.
     // config.position.fixed_position = 1;
 
     uint32_t senderHeartbeat = moduleConfig.range_test.sender * 1000;
-
     if (moduleConfig.range_test.enabled) {
 
         if (firstTime) {
@@ -54,6 +54,11 @@ int32_t RangeTestModule::runOnce()
 
             firstTime = 0;
 
+            if (moduleConfig.range_test.clear_on_reboot) {
+                // User wants to delete previous range test(s)
+                LOG_INFO("Range Test Module - Clearing out previous test file");
+                rangeTestModuleRadio->removeFile();
+            }
             if (moduleConfig.range_test.sender) {
                 LOG_INFO("Init Range Test Module -- Sender");
                 started = millis(); // make a note of when we started
@@ -141,7 +146,6 @@ ProcessMessage RangeTestModuleRadio::handleReceived(const meshtastic_MeshPacket
         */
 
         if (!isFromUs(&mp)) {
-
             if (moduleConfig.range_test.save) {
                 appendFile(mp);
             }
@@ -295,7 +299,42 @@ bool RangeTestModuleRadio::appendFile(const meshtastic_MeshPacket &mp)
     fileToAppend.printf("\"%s\"\n", p.payload.bytes);
     fileToAppend.flush();
     fileToAppend.close();
-#endif
 
     return 1;
+
+#else
+    LOG_ERROR("Failed to store range test results - feature only available for ESP32");
+
+    return 0;
+#endif
+}
+
+bool RangeTestModuleRadio::removeFile()
+{
+#ifdef ARCH_ESP32
+    if (!FSBegin()) {
+        LOG_DEBUG("An Error has occurred while mounting the filesystem");
+        return 0;
+    }
+
+    if (!FSCom.exists("/static/rangetest.csv")) {
+        LOG_DEBUG("No range tests found.");
+        return 0;
+    }
+
+    LOG_INFO("Deleting previous range test.");
+    bool result = FSCom.remove("/static/rangetest.csv");
+
+    if (!result) {
+        LOG_ERROR("Failed to delete range test.");
+        return 0;
+    }
+    LOG_INFO("Range test removed.");
+
+    return 1;
+#else
+    LOG_ERROR("Failed to remove range test results - feature only available for ESP32");
+
+    return 0;
+#endif
 }

src/modules/RangeTestModule.h

@@ -44,6 +44,11 @@ class RangeTestModuleRadio : public SinglePortModule
      */
     bool appendFile(const meshtastic_MeshPacket &mp);
 
+    /**
+     * Cleanup range test data from filesystem
+     */
+    bool removeFile();
+
   protected:
     /** Called to handle a particular incoming message
 

src/modules/RoutingModule.cpp

@@ -42,8 +42,6 @@ bool RoutingModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, mesh
 
 meshtastic_MeshPacket *RoutingModule::allocReply()
 {
-    if (config.device.role == meshtastic_Config_DeviceConfig_Role_REPEATER)
-        return NULL;
     assert(currentRequest);
 
     return NULL;

src/modules/Telemetry/DeviceTelemetry.cpp

@@ -26,7 +26,6 @@ int32_t DeviceTelemetryModule::runOnce()
           Default::getConfiguredOrDefaultMsScaled(moduleConfig.telemetry.device_update_interval,
                                                   default_telemetry_broadcast_interval_secs, numOnlineNodes))) &&
         airTime->isTxAllowedChannelUtil(!isImpoliteRole) && airTime->isTxAllowedAirUtil() &&
-        config.device.role != meshtastic_Config_DeviceConfig_Role_REPEATER &&
         config.device.role != meshtastic_Config_DeviceConfig_Role_CLIENT_HIDDEN) {
         sendTelemetry();
         lastSentToMesh = uptimeLastMs;
@@ -44,10 +43,6 @@ int32_t DeviceTelemetryModule::runOnce()
 
 bool DeviceTelemetryModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshtastic_Telemetry *t)
 {
-    // Don't worry about storing telemetry in NodeDB if we're a repeater
-    if (config.device.role == meshtastic_Config_DeviceConfig_Role_REPEATER)
-        return false;
-
     if (t->which_variant == meshtastic_Telemetry_device_metrics_tag) {
 #if defined(DEBUG_PORT) && !defined(DEBUG_MUTE)
         const char *sender = getSenderShortName(mp);

src/modules/Telemetry/HostMetrics.cpp

@@ -22,10 +22,6 @@ int32_t HostMetricsModule::runOnce()
 
 bool HostMetricsModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshtastic_Telemetry *t)
 {
-    // Don't worry about storing telemetry in NodeDB if we're a repeater
-    if (config.device.role == meshtastic_Config_DeviceConfig_Role_REPEATER)
-        return false;
-
     if (t->which_variant == meshtastic_Telemetry_host_metrics_tag) {
 #if defined(DEBUG_PORT) && !defined(DEBUG_MUTE)
         const char *sender = getSenderShortName(mp);

src/nimble/NimbleBluetooth.cpp

@@ -53,7 +53,8 @@ class BluetoothPhoneAPI : public PhoneAPI, public concurrency::OSThread
             hasChecked = true;
         }
 
-        return 100;
+        // the run is triggered via NimbleBluetoothToRadioCallback and NimbleBluetoothFromRadioCallback
+        return INT32_MAX;
     }
     /**
      * Subclasses can use this as a hook to provide custom notifications for their transport (i.e. bluetooth notifies)

src/platform/nrf52/NRF52Bluetooth.cpp

@@ -335,7 +335,8 @@ bool NRF52Bluetooth::onPairingPasskey(uint16_t conn_handle, uint8_t const passke
     meshtastic::BluetoothStatus newStatus(textkey);
     bluetoothStatus->updateStatus(&newStatus);
 
-#if !defined(MESHTASTIC_EXCLUDE_SCREEN) // Todo: migrate this display code back into Screen class, and observe bluetoothStatus
+#if HAS_SCREEN &&                                                                                                                \
+    !defined(MESHTASTIC_EXCLUDE_SCREEN) // Todo: migrate this display code back into Screen class, and observe bluetoothStatus
     if (screen) {
         screen->startAlert([](OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y) -> void {
             char btPIN[16] = "888888";

src/platform/nrf52/architecture.h

@@ -98,6 +98,8 @@
 #define HW_VENDOR meshtastic_HardwareModel_SEEED_WIO_TRACKER_L1_EINK
 #elif defined(SEEED_WIO_TRACKER_L1)
 #define HW_VENDOR meshtastic_HardwareModel_SEEED_WIO_TRACKER_L1
+#elif defined(R1_NEO)
+#define HW_VENDOR meshtastic_HardwareModel_MUZI_R1_NEO
 #elif defined(HELTEC_MESH_SOLAR)
 #define HW_VENDOR meshtastic_HardwareModel_HELTEC_MESH_SOLAR
 #else

src/platform/portduino/PortduinoGlue.h

@@ -224,7 +224,7 @@ extern struct portduino_config_struct {
             out << YAML::Key << "RF95_MAX_POWER" << YAML::Value << rf95_max_power;
         out << YAML::Key << "DIO2_AS_RF_SWITCH" << YAML::Value << dio2_as_rf_switch;
         if (dio3_tcxo_voltage != 0)
-            out << YAML::Key << "DIO3_TCXO_VOLTAGE" << YAML::Value << dio3_tcxo_voltage;
+            out << YAML::Key << "DIO3_TCXO_VOLTAGE" << YAML::Value << YAML::Precision(3) << (float)dio3_tcxo_voltage / 1000;
         if (lora_usb_pid != 0x5512)
             out << YAML::Key << "USB_PID" << YAML::Value << YAML::Hex << lora_usb_pid;
         if (lora_usb_vid != 0x1A86)

src/power.h

@@ -34,6 +34,8 @@
 #define OCV_ARRAY 4200, 3876, 3826, 3763, 3713, 3660, 3573, 3485, 3422, 3359, 3300
 #elif defined(SEEED_SOLAR_NODE)
 #define OCV_ARRAY 4200, 3986, 3922, 3812, 3734, 3645, 3527, 3420, 3281, 3087, 2786
+#elif defined(R1_NEO)
+#define OCV_ARRAY 4330, 4292, 4254, 4216, 4178, 4140, 4102, 4064, 4026, 3988, 3950
 #else // LiIon
 #define OCV_ARRAY 4190, 4050, 3990, 3890, 3800, 3720, 3630, 3530, 3420, 3300, 3100
 #endif

src/sleep.cpp

@@ -532,8 +532,7 @@ void enableModemSleep()
 
 bool shouldLoraWake(uint32_t msecToWake)
 {
-    return msecToWake < portMAX_DELAY && (config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER ||
-                                          config.device.role == meshtastic_Config_DeviceConfig_Role_REPEATER);
+    return msecToWake < portMAX_DELAY && (config.device.role == meshtastic_Config_DeviceConfig_Role_ROUTER);
 }
 
 void enableLoraInterrupt()

userPrefs.jsonc

@@ -21,7 +21,7 @@
   // "USERPREFS_CONFIG_LORA_REGION": "meshtastic_Config_LoRaConfig_RegionCode_US",
   // "USERPREFS_CONFIG_OWNER_LONG_NAME": "My Long Name",
   // "USERPREFS_CONFIG_OWNER_SHORT_NAME": "MLN",
-  // "USERPREFS_CONFIG_DEVICE_ROLE": "meshtastic_Config_DeviceConfig_Role_CLIENT", // Defaults to CLIENT. ROUTER*, LOST AND FOUND, and REPEATER roles are restricted.
+  // "USERPREFS_CONFIG_DEVICE_ROLE": "meshtastic_Config_DeviceConfig_Role_CLIENT", // Defaults to CLIENT. ROUTER*, and LOST AND FOUND roles are restricted.
   // "USERPREFS_EVENT_MODE": "1",
   // "USERPREFS_FIRMWARE_EDITION": "meshtastic_FirmwareEdition_BURNING_MAN",
   // "USERPREFS_FIXED_BLUETOOTH": "121212",

variants/nrf52840/r1-neo/platformio.ini

@@ -0,0 +1,19 @@
+; The R1 Neo board
+[env:r1-neo]
+extends = nrf52840_base
+board = r1-neo
+board_check = true
+build_flags = ${nrf52840_base.build_flags}
+  -Ivariants/nrf52840/r1-neo
+  -D R1_NEO
+  -DGPS_POWER_TOGGLE ; comment this line to disable triple press function on the user button to turn off gps entirely.
+  -DRADIOLIB_EXCLUDE_SX128X=1
+  -DRADIOLIB_EXCLUDE_SX127X=1
+  -DRADIOLIB_EXCLUDE_LR11X0=1
+build_src_filter = ${nrf52_base.build_src_filter} +<../variants/nrf52840/r1-neo> +<mesh/api/> +<mqtt/>
+lib_deps = 
+  ${nrf52840_base.lib_deps}
+  ${networking_base.lib_deps}
+  https://github.com/RAKWireless/RAK13800-W5100S/archive/1.0.2.zip
+  rakwireless/RAKwireless NCP5623 RGB LED library@^1.0.2
+  artronshop/ArtronShop_RX8130CE@1.0.0

variants/nrf52840/r1-neo/variant.cpp

@@ -0,0 +1,45 @@
+/*
+  Copyright (c) 2014-2015 Arduino LLC.  All right reserved.
+  Copyright (c) 2016 Sandeep Mistry All right reserved.
+  Copyright (c) 2018, Adafruit Industries (adafruit.com)
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the GNU Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#include "variant.h"
+#include "nrf.h"
+#include "wiring_constants.h"
+#include "wiring_digital.h"
+
+const uint32_t g_ADigitalPinMap[] = {
+    // P0
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+
+    // P1
+    32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47};
+
+void initVariant()
+{
+    // LED1 & LED2
+    pinMode(PIN_LED1, OUTPUT);
+    ledOff(PIN_LED1);
+
+    pinMode(PIN_LED2, OUTPUT);
+    ledOff(PIN_LED2);
+
+    // 3V3 Power Rail
+    // pinMode(PIN_3V3_EN, OUTPUT);
+    // digitalWrite(PIN_3V3_EN, HIGH);
+}

variants/nrf52840/r1-neo/variant.h

@@ -0,0 +1,149 @@
+/*
+  Copyright (c) 2014-2015 Arduino LLC.  All right reserved.
+  Copyright (c) 2016 Sandeep Mistry All right reserved.
+  Copyright (c) 2018, Adafruit Industries (adafruit.com)
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the GNU Lesser General Public License for more details.
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef _VARIANT_R1NEO_
+#define _VARIANT_R1NEO_
+
+#define RAK4630
+
+/** Master clock frequency */
+#define VARIANT_MCK (64000000ul)
+
+#define USE_LFXO // Board uses 32khz crystal for LF
+// define USE_LFRC    // Board uses RC for LF
+
+/*----------------------------------------------------------------------------
+ *        Headers
+ *----------------------------------------------------------------------------*/
+
+#include "WVariant.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+// Number of pins defined in PinDescription array
+#define PINS_COUNT (48)
+#define NUM_DIGITAL_PINS (48)
+#define NUM_ANALOG_INPUTS (1)
+#define NUM_ANALOG_OUTPUTS (0)
+
+// LEDs
+#define PIN_LED1 (32 + 4) // P1.04 Controls Green LED
+#define PIN_LED2 (28)     // P0.28 Controls Blue LED
+
+#define LED_BUILTIN PIN_LED1
+#define LED_CONN PIN_LED2
+
+#define LED_GREEN PIN_LED1
+#define LED_BLUE PIN_LED2
+
+#define LED_STATE_ON 1 // State when LED is litted
+
+// Button
+#define PIN_BUTTON1 (26)
+#define BUTTON_ACTIVE_LOW 0
+#define BUTTON_ACTIVE_PULLUP 0
+#define BUTTON_SENSE_TYPE INPUT_SENSE_HIGH
+
+#define ADC_RESOLUTION 14
+
+// Serial for GPS
+#define PIN_SERIAL1_RX (25)
+#define PIN_SERIAL1_TX (24)
+
+// Connected to Jlink CDC
+#define PIN_SERIAL2_RX (8)
+#define PIN_SERIAL2_TX (6)
+
+/*
+ * SPI Interfaces
+ */
+#define SPI_INTERFACES_COUNT 1
+
+#define PIN_SPI_MISO (45)
+#define PIN_SPI_MOSI (44)
+#define PIN_SPI_SCK (43)
+
+static const uint8_t SS = 42;
+static const uint8_t MOSI = PIN_SPI_MOSI;
+static const uint8_t MISO = PIN_SPI_MISO;
+static const uint8_t SCK = PIN_SPI_SCK;
+
+// R1 Neo Extras
+#define DCDC_EN_HOLD (13) // P0.13 Keeps DCDC alive after user button  is pressed
+#define NRF_ON (29)       // P0.29 Tells IO controller device is on
+
+// RAKRGB
+#define HAS_NCP5623
+
+#define HAS_SCREEN 0
+
+/*
+ * Wire Interfaces
+ */
+#define WIRE_INTERFACES_COUNT 1
+
+#define PIN_WIRE_SDA (19) // P0.19 RTC_SDA
+#define PIN_WIRE_SCL (20) // P0.20 RTC_SCL
+
+#define PIN_BUZZER (0 + 3) // P0.03
+
+#define USE_SX1262
+#define SX126X_CS (42)
+#define SX126X_DIO1 (47)
+#define SX126X_BUSY (46)
+#define SX126X_RESET (38)
+#define SX126X_POWER_EN (37)
+
+// DIO2 controlls an antenna switch and the TCXO voltage is controlled by DIO3
+#define SX126X_DIO2_AS_RF_SWITCH
+#define SX126X_DIO3_TCXO_VOLTAGE 1.8
+
+// Testing USB detection
+#define NRF_APM
+
+#define PIN_GPS_EN (32 + 1) // P1.01
+#define PIN_GPS_PPS (2)     // P0.02 Pulse per second input from the GPS
+
+#define GPS_RX_PIN PIN_SERIAL1_RX
+#define GPS_TX_PIN PIN_SERIAL1_TX
+
+// Battery
+#define BATTERY_PIN (0 + 31) // P0.31 ADC_VBAT
+// and has 12 bit resolution
+#define BATTERY_SENSE_RESOLUTION_BITS 12
+#define BATTERY_SENSE_RESOLUTION 4096.0
+#undef AREF_VOLTAGE
+#define AREF_VOLTAGE 3.0
+#define VBAT_AR_INTERNAL AR_INTERNAL_3_0
+#define ADC_MULTIPLIER 1.73
+
+#define HAS_RTC 1
+
+#define RX8130CE_RTC 0x32
+
+#ifdef __cplusplus
+}
+#endif
+
+/*----------------------------------------------------------------------------
+ *        Arduino objects - C++ only
+ *----------------------------------------------------------------------------*/
+
+#endif