minor changes to bme680 changes

chore: trigger CI
Fix for esp32 CI
2026-01-12 12:57:27 +00:00 · 2026-01-05 19:20:11 -06:00 · 2025-11-24 10:46:28 +09:00 · 2025-11-18 18:58:50 +09:00 · 2025-11-17 21:19:49 +09:00 · 2025-11-14 17:57:33 +09:00
74 changed files with 760 additions and 1759 deletions
--- a/.github/workflows/test_native.yml
+++ b/.github/workflows/test_native.yml
@@ -143,7 +143,7 @@ jobs:
          merge-multiple: true

      - name: Test Report
-        uses: dorny/test-reporter@v2.2.0
+        uses: dorny/test-reporter@v2.1.1
        with:
          name: PlatformIO Tests
          path: testreport.xml
--- a/.trunk/trunk.yaml
+++ b/.trunk/trunk.yaml
@@ -8,15 +8,15 @@ plugins:
      uri: https://github.com/trunk-io/plugins
 lint:
  enabled:
-    - checkov@3.2.492
-    - renovate@42.5.4
+    - checkov@3.2.489
+    - renovate@41.169.1
    - prettier@3.6.2
-    - trufflehog@3.90.13
+    - trufflehog@3.90.12
    - yamllint@1.37.1
    - bandit@1.8.6
    - trivy@0.67.2
    - taplo@0.10.0
-    - ruff@0.14.4
+    - ruff@0.14.3
    - isort@7.0.0
    - markdownlint@0.45.0
    - oxipng@9.1.5
@@ -26,9 +26,9 @@ lint:
    - hadolint@2.14.0
    - shfmt@3.6.0
    - shellcheck@0.11.0
-    - black@25.11.0
+    - black@25.9.0
    - git-diff-check
-    - gitleaks@8.29.0
+    - gitleaks@8.28.0
    - clang-format@16.0.3
  ignore:
    - linters: [ALL]
--- a/arch/portduino/portduino.ini
+++ b/arch/portduino/portduino.ini
@@ -33,6 +33,8 @@ lib_deps =
 	adafruit/Adafruit seesaw Library@1.7.9
  # renovate: datasource=git-refs depName=RAK12034-BMX160 packageName=https://github.com/RAKWireless/RAK12034-BMX160 gitBranch=main
  https://github.com/RAKWireless/RAK12034-BMX160/archive/dcead07ffa267d3c906e9ca4a1330ab989e957e2.zip
+  # renovate: datasource=custom.pio depName=adafruit/Adafruit BME680 Library packageName=adafruit/library/Adafruit BME680
+  adafruit/Adafruit BME680 Library@^2.0.5

 build_flags =
  ${arduino_base.build_flags}
--- a/arch/stm32/stm32.ini
+++ b/arch/stm32/stm32.ini
@@ -37,6 +37,9 @@ build_flags =
  -DRADIOLIB_EXCLUDE_LR11X0=1
  -DHAL_DAC_MODULE_ONLY
  -DHAL_RNG_MODULE_ENABLED
+  -Wl,--wrap=__assert_func
+  -Wl,--wrap=strerror
+  -Wl,--wrap=_tzset_unlocked_r

 build_src_filter =
  ${arduino_base.build_src_filter} -<platform/esp32/> -<nimble/> -<mesh/api/> -<mesh/wifi/> -<mesh/http/> -<modules/esp32> -<mesh/eth/> -<input> -<buzz> -<modules/RemoteHardwareModule.cpp> -<platform/nrf52> -<platform/portduino> -<platform/rp2xx0> -<mesh/raspihttp>
--- a/bin/org.meshtastic.meshtasticd.metainfo.xml
+++ b/bin/org.meshtastic.meshtasticd.metainfo.xml
@@ -87,9 +87,6 @@
  </screenshots>

  <releases>
-    <release version="2.7.15" date="2025-11-13">
-      <url type="details">https://github.com/meshtastic/firmware/releases?q=tag%3Av2.7.15</url>
-    </release>
    <release version="2.7.14" date="2025-11-03">
      <url type="details">https://github.com/meshtastic/firmware/releases?q=tag%3Av2.7.14</url>
    </release>
--- a/boards/ThinkNode-M3.json
+++ b/boards/ThinkNode-M3.json
@@ -1,53 +0,0 @@
-{
-  "build": {
-    "arduino": {
-      "ldscript": "nrf52840_s140_v6.ld"
-    },
-    "core": "nRF5",
-    "cpu": "cortex-m4",
-    "extra_flags": "-DNRF52840_XXAA",
-    "f_cpu": "64000000L",
-    "hwids": [
-      ["0x239A", "0x4405"],
-      ["0x239A", "0x0029"],
-      ["0x239A", "0x002A"]
-    ],
-    "usb_product": "elecrow_eink",
-    "mcu": "nrf52840",
-    "variant": "ELECROW-ThinkNode-M3",
-    "variants_dir": "variants",
-    "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",
-    "onboard_tools": ["jlink"],
-    "svd_path": "nrf52840.svd",
-    "openocd_target": "nrf52840-mdk-rs"
-  },
-  "frameworks": ["arduino"],
-  "name": "elecrow nrf",
-  "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": "",
-  "vendor": "ELECROW"
-}
--- a/boards/ThinkNode-M6.json
+++ b/boards/ThinkNode-M6.json
@@ -1,53 +0,0 @@
-{
-  "build": {
-    "arduino": {
-      "ldscript": "nrf52840_s140_v6.ld"
-    },
-    "core": "nRF5",
-    "cpu": "cortex-m4",
-    "extra_flags": "-DARDUINO_NRF52840_ELECROW_M6 -DNRF52840_XXAA",
-    "f_cpu": "64000000L",
-    "hwids": [
-      ["0x239A", "0x4405"],
-      ["0x239A", "0x0029"],
-      ["0x239A", "0x002A"]
-    ],
-    "usb_product": "elecrow_thinknode_m6",
-    "mcu": "nrf52840",
-    "variant": "ELECROW-ThinkNode-M6",
-    "variants_dir": "variants",
-    "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",
-    "onboard_tools": ["jlink"],
-    "svd_path": "nrf52840.svd",
-    "openocd_target": "nrf52840-mdk-rs"
-  },
-  "frameworks": ["arduino"],
-  "name": "ELECROW ThinkNode M6",
-  "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://www.elecrow.com/thinknode-m6-outdoor-solar-power-for-lora-powered-by-nrf52840-supports-gps.html",
-  "vendor": "ELECROW"
-}
--- a/boards/muzi-base.json
+++ b/boards/muzi-base.json
@@ -1,56 +0,0 @@
-{
-  "build": {
-    "arduino": {
-      "ldscript": "nrf52840_s140_v6.ld"
-    },
-    "core": "nRF5",
-    "cpu": "cortex-m4",
-    "extra_flags": "-DARDUINO_NRF52840_MUZI_BASE -DNRF52840_XXAA",
-    "f_cpu": "64000000L",
-    "hwids": [["0x239A", "0xcafe"]],
-    "mcu": "nrf52840",
-    "variant": "muzi-base",
-    "variants_dir": "variants",
-    "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",
-    "onboard_tools": ["jlink"],
-    "svd_path": "nrf52840.svd",
-    "openocd_target": "nrf52840-mdk-rs"
-  },
-  "frameworks": ["arduino"],
-  "name": "Muzi Base",
-  "url": "https://muzi.works/",
-  "vendor": "MuziWorks",
-  "upload": {
-    "maximum_ram_size": 248832,
-    "maximum_size": 815104,
-    "speed": 115200,
-    "protocol": "nrfutil",
-    "protocols": [
-      "jlink",
-      "nrfjprog",
-      "nrfutil",
-      "blackmagic",
-      "cmsis-dap",
-      "mbed",
-      "stlink"
-    ],
-    "use_1200bps_touch": true,
-    "require_upload_port": true,
-    "wait_for_upload_port": true
-  }
-}
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,9 +1,3 @@
-meshtasticd (2.7.15.0) unstable; urgency=medium
-
-  * Version 2.7.15
-
- -- GitHub Actions <github-actions[bot]@users.noreply.github.com>  Thu, 13 Nov 2025 12:31:57 +0000
-
 meshtasticd (2.7.14.0) unstable; urgency=medium

  * Version 2.7.14
--- a/meshtasticd.spec.rpkg
+++ b/meshtasticd.spec.rpkg
@@ -33,6 +33,7 @@ BuildRequires: python3dist(grpcio[protobuf])
 BuildRequires: python3dist(grpcio-tools)
 BuildRequires: git-core
 BuildRequires: gcc-c++
+BuildRequires: (glibc-devel >= 2.38) or pkgconfig(libbsd-overlay)
 BuildRequires: pkgconfig(yaml-cpp)
 BuildRequires: pkgconfig(libgpiod)
 BuildRequires: pkgconfig(bluez)
@@ -49,13 +50,6 @@ BuildRequires: pkgconfig(x11)
 BuildRequires: pkgconfig(libinput)
 BuildRequires: pkgconfig(xkbcommon-x11)

-# libbsd is needed on older Fedora/RHEL to provide 'strlcpy'
-%if 0%{?fedora} >= 39 || 0%{?rhel} >= 10
-BuildRequires: glibc-devel >= 2.38
-%else
-BuildRequires: pkgconfig(libbsd-overlay)
-%endif
-
 Requires:      systemd-udev

 %description
--- a/platformio.ini
+++ b/platformio.ini
@@ -62,7 +62,7 @@ monitor_speed = 115200
 monitor_filters = direct
 lib_deps =
 	# renovate: datasource=git-refs depName=meshtastic-esp8266-oled-ssd1306 packageName=https://github.com/meshtastic/esp8266-oled-ssd1306 gitBranch=master
-	https://github.com/meshtastic/esp8266-oled-ssd1306/archive/2887bf4a19f64d92c984dcc8fd5ca7429e425e4a.zip
+	https://github.com/meshtastic/esp8266-oled-ssd1306/archive/0cbc26b1f8f61957af0475f486b362eafe7cc4e2.zip
 	# renovate: datasource=git-refs depName=meshtastic-OneButton packageName=https://github.com/meshtastic/OneButton gitBranch=master
 	https://github.com/meshtastic/OneButton/archive/fa352d668c53f290cfa480a5f79ad422cd828c70.zip
 	# renovate: datasource=git-refs depName=meshtastic-arduino-fsm packageName=https://github.com/meshtastic/arduino-fsm gitBranch=master
@@ -115,12 +115,13 @@ lib_deps =
 [radiolib_base]
 lib_deps =
 	# renovate: datasource=custom.pio depName=RadioLib packageName=jgromes/library/RadioLib
-	jgromes/RadioLib@7.3.0
+	# jgromes/RadioLib@7.4.0
+	https://github.com/jgromes/RadioLib/archive/536c7267362e2c1345be7054ba45e503252975ff.zip

 [device-ui_base]
 lib_deps =
 	# renovate: datasource=git-refs depName=meshtastic/device-ui packageName=https://github.com/meshtastic/device-ui gitBranch=master
-	https://github.com/meshtastic/device-ui/archive/28167c67dfd13015a0b5eef1828f95fe8e3ab7c3.zip
+	https://github.com/meshtastic/device-ui/archive/19b7855e9a1d9deff37391659ca7194e4ef57c43.zip

 ; Common libs for environmental measurements in telemetry module
 [environmental_base]
@@ -181,6 +182,8 @@ lib_deps =
 	dfrobot/DFRobot_BMM150@1.0.0
 	# renovate: datasource=custom.pio depName=Adafruit_TSL2561 packageName=adafruit/library/Adafruit TSL2561
 	adafruit/Adafruit TSL2561@1.1.2
+	# renovate: datasource=custom.pio depName=BH1750_WE packageName=wollewald/BH1750_WE@^1.1.10
+	wollewald/BH1750_WE@^1.1.10

 ; (not included in native / portduino)
 [environmental_extra]
--- a/2
+++ b/2
--- a/src/NodeStatus.h
+++ b/src/NodeStatus.h
@@ -14,16 +14,16 @@ class NodeStatus : public Status
    CallbackObserver<NodeStatus, const NodeStatus *> statusObserver =
        CallbackObserver<NodeStatus, const NodeStatus *>(this, &NodeStatus::updateStatus);

-    uint8_t numOnline = 0;
-    uint8_t numTotal = 0;
+    uint16_t numOnline = 0;
+    uint16_t numTotal = 0;

-    uint8_t lastNumTotal = 0;
+    uint16_t lastNumTotal = 0;

  public:
    bool forceUpdate = false;

    NodeStatus() { statusType = STATUS_TYPE_NODE; }
-    NodeStatus(uint8_t numOnline, uint8_t numTotal, bool forceUpdate = false) : Status()
+    NodeStatus(uint16_t numOnline, uint16_t numTotal, bool forceUpdate = false) : Status()
    {
        this->forceUpdate = forceUpdate;
        this->numOnline = numOnline;
@@ -34,11 +34,11 @@ class NodeStatus : public Status

    void observe(Observable<const NodeStatus *> *source) { statusObserver.observe(source); }

-    uint8_t getNumOnline() const { return numOnline; }
+    uint16_t getNumOnline() const { return numOnline; }

-    uint8_t getNumTotal() const { return numTotal; }
+    uint16_t getNumTotal() const { return numTotal; }

-    uint8_t getLastNumTotal() const { return lastNumTotal; }
+    uint16_t getLastNumTotal() const { return lastNumTotal; }

    bool matches(const NodeStatus *newStatus) const
    {
@@ -56,7 +56,7 @@ class NodeStatus : public Status
            numTotal = newStatus->getNumTotal();
        }
        if (isDirty || newStatus->forceUpdate) {
-            LOG_DEBUG("Node status update: %d online, %d total", numOnline, numTotal);
+            LOG_DEBUG("Node status update: %u online, %u total", numOnline, numTotal);
            onNewStatus.notifyObservers(this);
        }
        return 0;
--- a/src/Power.cpp
+++ b/src/Power.cpp
@@ -278,11 +278,6 @@ class AnalogBatteryLevel : public HasBatteryLevel
                break;
            }
        }
-#if defined(BATTERY_CHARGING_INV)
-        // bit of trickery to show 99% up until the charge finishes
-        if (!digitalRead(BATTERY_CHARGING_INV) && battery_SOC > 99)
-            battery_SOC = 99;
-#endif
        return clamp((int)(battery_SOC), 0, 100);
    }

@@ -460,8 +455,6 @@ class AnalogBatteryLevel : public HasBatteryLevel
        }
        // if it's not HIGH - check the battery
 #endif
-#elif defined(MUZI_BASE)
-        return NRF_POWER->USBREGSTATUS & POWER_USBREGSTATUS_VBUSDETECT_Msk;
 #endif
        return getBattVoltage() > chargingVolt;
    }
@@ -477,8 +470,6 @@ class AnalogBatteryLevel : public HasBatteryLevel
 #endif
 #ifdef EXT_CHRG_DETECT
        return digitalRead(EXT_CHRG_DETECT) == ext_chrg_detect_value;
-#elif defined(BATTERY_CHARGING_INV)
-        return !digitalRead(BATTERY_CHARGING_INV);
 #else
 #if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && !defined(DISABLE_INA_CHARGING_DETECTION)
        if (hasINA()) {
@@ -711,16 +702,7 @@ bool Power::setup()
        },
        CHANGE);
 #endif
-#ifdef BATTERY_CHARGING_INV
-    attachInterrupt(
-        BATTERY_CHARGING_INV,
-        []() {
-            power->setIntervalFromNow(0);
-            runASAP = true;
-            BaseType_t higherWake = 0;
-        },
-        CHANGE);
-#endif
+
    enabled = found;
    low_voltage_counter = 0;

--- a/src/configuration.h
+++ b/src/configuration.h
@@ -228,6 +228,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define ICM20948_ADDR_ALT 0x68
 #define BHI260AP_ADDR 0x28
 #define BMM150_ADDR 0x13
+#define DA217_ADDR 0x26

 // -----------------------------------------------------------------------------
 // LED
@@ -395,13 +396,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define HAS_RGB_LED
 #endif

-#ifndef LED_STATE_OFF
-#define LED_STATE_OFF 0
-#endif
-#ifndef LED_STATE_ON
-#define LED_STATE_ON 1
-#endif
-
 // default mapping of pins
 #if defined(PIN_BUTTON2) && !defined(CANCEL_BUTTON_PIN)
 #define ALT_BUTTON_PIN PIN_BUTTON2
@@ -416,6 +410,18 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #endif
 #endif

+// BME680 BSEC2 support detection
+#if !defined(MESHTASTIC_BME680_BSEC2_SUPPORTED)
+#if defined(RAK_4631) || defined(TBEAM_V10)
+
+#define MESHTASTIC_BME680_BSEC2_SUPPORTED 1
+#define MESHTASTIC_BME680_HEADER <bsec2.h>
+#else
+#define MESHTASTIC_BME680_BSEC2_SUPPORTED 0
+#define MESHTASTIC_BME680_HEADER <Adafruit_BME680.h>
+#endif // defined(RAK_4631)
+#endif // !defined(MESHTASTIC_BME680_BSEC2_SUPPORTED)
+
 // -----------------------------------------------------------------------------
 // Global switches to turn off features for a minimized build
 // -----------------------------------------------------------------------------
--- a/src/detect/ScanI2CTwoWire.cpp
+++ b/src/detect/ScanI2CTwoWire.cpp
@@ -106,6 +106,7 @@ uint16_t ScanI2CTwoWire::getRegisterValue(const ScanI2CTwoWire::RegisterLocation
        if (i2cBus->available())
            i2cBus->read();
    }
+    LOG_DEBUG("Register value: 0x%x", value);
    return value;
 }

@@ -377,14 +378,13 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
                }
            case SHT31_4x_ADDR:     // same as OPT3001_ADDR_ALT
            case SHT31_4x_ADDR_ALT: // same as OPT3001_ADDR
-                registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x89), 2);
-                if (registerValue == 0x11a2 || registerValue == 0x11da || registerValue == 0x11f3 || registerValue == 0xe9c ||
-                    registerValue == 0xc8d) {
-                    type = SHT4X;
-                    logFoundDevice("SHT4X", (uint8_t)addr.address);
-                } else if (getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x7E), 2) == 0x5449) {
+                registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x7E), 2);
+                if (registerValue == 0x5449) {
                    type = OPT3001;
                    logFoundDevice("OPT3001", (uint8_t)addr.address);
+                } else if (getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x89), 2) != 0) { // unique SHT4x serial number
+                    type = SHT4X;
+                    logFoundDevice("SHT4X", (uint8_t)addr.address);
                } else {
                    type = SHT31;
                    logFoundDevice("SHT31", (uint8_t)addr.address);
@@ -465,8 +465,23 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
                break;

                SCAN_SIMPLE_CASE(LSM6DS3_ADDR, LSM6DS3, "LSM6DS3", (uint8_t)addr.address);
-                SCAN_SIMPLE_CASE(TCA9555_ADDR, TCA9555, "TCA9555", (uint8_t)addr.address);
                SCAN_SIMPLE_CASE(VEML7700_ADDR, VEML7700, "VEML7700", (uint8_t)addr.address);
+            case TCA9555_ADDR:
+                registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x01), 1);
+                if (registerValue == 0x13) {
+                    registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x00), 1);
+                    if (registerValue == 0x81) {
+                        type = DA217;
+                        logFoundDevice("DA217", (uint8_t)addr.address);
+                    } else {
+                        type = TCA9555;
+                        logFoundDevice("TCA9555", (uint8_t)addr.address);
+                    }
+                } else {
+                    type = TCA9555;
+                    logFoundDevice("TCA9555", (uint8_t)addr.address);
+                }
+                break;
            case TSL25911_ADDR:
                registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x12), 1);
                if (registerValue == 0x50) {
@@ -532,11 +547,6 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
            case ICM20948_ADDR:     // same as BMX160_ADDR
            case ICM20948_ADDR_ALT: // same as MPU6050_ADDR
                registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x00), 1);
-#ifdef HAS_ICM20948
-                type = ICM20948;
-                logFoundDevice("ICM20948", (uint8_t)addr.address);
-                break;
-#endif
                if (registerValue == 0xEA) {
                    type = ICM20948;
                    logFoundDevice("ICM20948", (uint8_t)addr.address);
--- a/src/gps/RTC.cpp
+++ b/src/gps/RTC.cpp
@@ -112,11 +112,7 @@ RTCSetResult readFromRTC()
 #elif defined(RX8130CE_RTC)
    if (rtc_found.address == RX8130CE_RTC) {
        uint32_t now = millis();
-#ifdef MUZI_BASE
-        ArtronShop_RX8130CE rtc(&Wire1);
-#else
        ArtronShop_RX8130CE rtc(&Wire);
-#endif
        tm t;
        if (rtc.getTime(&t)) {
            tv.tv_sec = gm_mktime(&t);
@@ -249,11 +245,7 @@ RTCSetResult perhapsSetRTC(RTCQuality q, const struct timeval *tv, bool forceUpd
        }
 #elif defined(RX8130CE_RTC)
        if (rtc_found.address == RX8130CE_RTC) {
-#ifdef MUZI_BASE
-            ArtronShop_RX8130CE rtc(&Wire1);
-#else
            ArtronShop_RX8130CE rtc(&Wire);
-#endif
            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,
--- a/src/graphics/Screen.cpp
+++ b/src/graphics/Screen.cpp
@@ -435,14 +435,6 @@ void Screen::handleSetOn(bool on, FrameCallback einkScreensaver)
            PMU->enablePowerOutput(XPOWERS_ALDO2);
 #endif

-#if defined(MUZI_BASE)
-            dispdev->init();
-            dispdev->setBrightness(brightness);
-            dispdev->flipScreenVertically();
-            dispdev->resetDisplay();
-            digitalWrite(SCREEN_12V_ENABLE, HIGH);
-            delay(100);
-#endif
 #if !ARCH_PORTDUINO
            dispdev->displayOn();
 #endif
@@ -492,10 +484,6 @@ void Screen::handleSetOn(bool on, FrameCallback einkScreensaver)
 #endif

            dispdev->displayOff();
-
-#ifdef SCREEN_12V_ENABLE
-            digitalWrite(SCREEN_12V_ENABLE, LOW);
-#endif
 #ifdef USE_ST7789
            SPI1.end();
 #if defined(ARCH_ESP32)
@@ -546,7 +534,7 @@ void Screen::setup()
        static_cast<AutoOLEDWire *>(dispdev)->setDetected(model);
 #endif

-#if defined(USE_SH1107_128_64) || defined(USE_SH1107)
+#ifdef USE_SH1107_128_64
    static_cast<SH1106Wire *>(dispdev)->setSubtype(7);
 #endif

@@ -554,9 +542,6 @@ void Screen::setup()
    // Apply custom RGB color (e.g. Heltec T114/T190)
    static_cast<ST7789Spi *>(dispdev)->setRGB(TFT_MESH);
 #endif
-#if defined(MUZI_BASE)
-    dispdev->delayPoweron = true;
-#endif

    // === Initialize display and UI system ===
    ui->init();
--- a/src/graphics/Screen.h
+++ b/src/graphics/Screen.h
@@ -249,8 +249,6 @@ class Screen : public concurrency::OSThread

    bool isOverlayBannerShowing();

-    bool isScreenOn() { return screenOn; }
-
    // Stores the last 4 of our hardware ID, to make finding the device for pairing easier
    // FIXME: Needs refactoring and getMacAddr needs to be moved to a utility class
    char ourId[5];
--- a/src/graphics/TFTDisplay.cpp
+++ b/src/graphics/TFTDisplay.cpp
@@ -427,35 +427,33 @@ static LGFX *tft = nullptr;
 #include "lgfx/v1/Touch.hpp"
 namespace lgfx
 {
-inline namespace v1
-{
+ inline namespace v1
+ {
 class TOUCH_CHSC6X : public ITouch
 {
-  public:
+public:
    TOUCH_CHSC6X(void)
    {
-        _cfg.i2c_addr = TOUCH_SLAVE_ADDRESS;
-        _cfg.x_min = 0;
-        _cfg.x_max = 240;
-        _cfg.y_min = 0;
-        _cfg.y_max = 320;
+      _cfg.i2c_addr = TOUCH_SLAVE_ADDRESS;
+      _cfg.x_min = 0;
+      _cfg.x_max = 240;
+      _cfg.y_min = 0;
+      _cfg.y_max = 320;
    };

-    bool init(void) override
-    {
-        if (chsc6xTouch == nullptr) {
-            chsc6xTouch = new chsc6x(&Wire1, TOUCH_SDA_PIN, TOUCH_SCL_PIN, TOUCH_INT_PIN, TOUCH_RST_PIN);
+    bool init(void) override {
+        if(chsc6xTouch==nullptr) {
+            chsc6xTouch=new chsc6x(&Wire1,TOUCH_SDA_PIN,TOUCH_SCL_PIN,TOUCH_INT_PIN,TOUCH_RST_PIN);
        }
        chsc6xTouch->chsc6x_init();
        return true;
    };

-    uint_fast8_t getTouchRaw(touch_point_t *tp, uint_fast8_t count) override
-    {
-        uint16_t raw_x, raw_y;
-        if (chsc6xTouch->chsc6x_read_touch_info(&raw_x, &raw_y) == 0) {
-            tp[0].x = 320 - 1 - raw_y;
-            tp[0].y = 240 - 1 - raw_x;
+    uint_fast8_t getTouchRaw(touch_point_t* tp, uint_fast8_t count) override {
+        uint16_t raw_x,raw_y;
+        if (chsc6xTouch->chsc6x_read_touch_info(&raw_x, &raw_y)==0) {
+            tp[0].x = 320-1-raw_y;
+            tp[0].y = 240-1-raw_x ;
            tp[0].size = 1;
            tp[0].id = 1;
            return 1;
@@ -464,14 +462,13 @@ class TOUCH_CHSC6X : public ITouch
        return 0;
    };

-    void wakeup(void) override{};
-    void sleep(void) override{};
-
+    void wakeup(void) override {};
+    void sleep(void) override {};
  private:
-    chsc6x *chsc6xTouch = nullptr;
-};
-} // namespace v1
-} // namespace lgfx
+    chsc6x *chsc6xTouch=nullptr;
+  };
+}
+}
 #endif
 class LGFX : public lgfx::LGFX_Device
 {
@@ -483,8 +480,6 @@ class LGFX : public lgfx::LGFX_Device
    lgfx::Touch_FT5x06 _touch_instance;
 #elif defined(HELTEC_V4_TFT)
    lgfx::TOUCH_CHSC6X _touch_instance;
-#elif defined(HELTEC_V4_TFT)
-    lgfx::TOUCH_CHSC6X _touch_instance;
 #else
    lgfx::Touch_GT911 _touch_instance;
 #endif
@@ -518,9 +513,9 @@ class LGFX : public lgfx::LGFX_Device
        {                                        // Set the display panel control.
            auto cfg = _panel_instance.config(); // Gets a structure for display panel settings.

-            cfg.pin_cs = ST7789_CS;     // Pin number where CS is connected (-1 = disable)
-            cfg.pin_rst = ST7789_RESET; // Pin number where RST is connected  (-1 = disable)
-            cfg.pin_busy = ST7789_BUSY; // Pin number where BUSY is connected (-1 = disable)
+            cfg.pin_cs = ST7789_CS; // Pin number where CS is connected (-1 = disable)
+            cfg.pin_rst = ST7789_RESET;       // Pin number where RST is connected  (-1 = disable)
+            cfg.pin_busy = ST7789_BUSY;      // Pin number where BUSY is connected (-1 = disable)

            // The following setting values are general initial values for each panel, so please comment out any
            // unknown items and try them.
--- a/src/graphics/draw/MenuHandler.cpp
+++ b/src/graphics/draw/MenuHandler.cpp
@@ -574,7 +574,7 @@ void menuHandler::textMessageBaseMenu()

 void menuHandler::systemBaseMenu()
 {
-    enum optionsNumbers { Back, Notifications, ScreenOptions, Bluetooth, PowerMenu, FrameToggles, Test, enumEnd };
+    enum optionsNumbers { Back, Notifications, ScreenOptions, Bluetooth, PowerMenu, Test, enumEnd };
    static const char *optionsArray[enumEnd] = {"Back"};
    static int optionsEnumArray[enumEnd] = {Back};
    int options = 1;
@@ -583,12 +583,10 @@ void menuHandler::systemBaseMenu()
    optionsEnumArray[options++] = Notifications;
 #if defined(ST7789_CS) || defined(ST7796_CS) || defined(USE_OLED) || defined(USE_SSD1306) || defined(USE_SH1106) ||              \
    defined(USE_SH1107) || defined(HELTEC_MESH_NODE_T114) || defined(HELTEC_VISION_MASTER_T190) || HAS_TFT
-    optionsArray[options] = "Screen Options";
+    optionsArray[options] = "Display Options";
    optionsEnumArray[options++] = ScreenOptions;
 #endif

-    optionsArray[options] = "Frame Visiblity Toggle";
-    optionsEnumArray[options++] = FrameToggles;
 #if defined(M5STACK_UNITC6L)
    optionsArray[options] = "Bluetooth";
 #else
@@ -626,9 +624,6 @@ void menuHandler::systemBaseMenu()
        } else if (selected == PowerMenu) {
            menuHandler::menuQueue = menuHandler::power_menu;
            screen->runNow();
-        } else if (selected == FrameToggles) {
-            menuHandler::menuQueue = menuHandler::FrameToggles;
-            screen->runNow();
        } else if (selected == Test) {
            menuHandler::menuQueue = menuHandler::test_menu;
            screen->runNow();
@@ -790,24 +785,17 @@ void menuHandler::nodeNameLengthMenu()

 void menuHandler::resetNodeDBMenu()
 {
-    static const char *optionsArray[] = {"Back", "Reset All", "Preserve Favorites"};
+    static const char *optionsArray[] = {"Back", "Confirm"};
    BannerOverlayOptions bannerOptions;
    bannerOptions.message = "Confirm Reset NodeDB";
    bannerOptions.optionsArrayPtr = optionsArray;
-    bannerOptions.optionsCount = 3;
+    bannerOptions.optionsCount = 2;
    bannerOptions.bannerCallback = [](int selected) -> void {
-        if (selected == 1 || selected == 2) {
-            disableBluetooth();
-            screen->setFrames(Screen::FOCUS_DEFAULT);
-        }
        if (selected == 1) {
+            disableBluetooth();
            LOG_INFO("Initiate node-db reset");
            nodeDB->resetNodes();
            rebootAtMsec = (millis() + DEFAULT_REBOOT_SECONDS * 1000);
-        } else if (selected == 2) {
-            LOG_INFO("Initiate node-db reset but keeping favorites");
-            nodeDB->resetNodes(1);
-            rebootAtMsec = (millis() + DEFAULT_REBOOT_SECONDS * 1000);
        }
    };
    screen->showOverlayBanner(bannerOptions);
@@ -943,9 +931,7 @@ void menuHandler::BluetoothToggleMenu()
    bannerOptions.optionsArrayPtr = optionsArray;
    bannerOptions.optionsCount = 3;
    bannerOptions.bannerCallback = [](int selected) -> void {
-        if (selected == 0)
-            return;
-        else if (selected != (config.bluetooth.enabled ? 1 : 2)) {
+        if (selected == 1 || selected == 2) {
            InputEvent event = {.inputEvent = (input_broker_event)170, .kbchar = 170, .touchX = 0, .touchY = 0};
            inputBroker->injectInputEvent(&event);
        }
@@ -1339,7 +1325,7 @@ void menuHandler::screenOptionsMenu()
    hasSupportBrightness = false;
 #endif

-    enum optionsNumbers { Back, NodeNameLength, Brightness, ScreenColor };
+    enum optionsNumbers { Back, NodeNameLength, Brightness, ScreenColor, FrameToggles, DisplayUnits };
    static const char *optionsArray[5] = {"Back"};
    static int optionsEnumArray[5] = {Back};
    int options = 1;
@@ -1361,8 +1347,14 @@ void menuHandler::screenOptionsMenu()
    optionsEnumArray[options++] = ScreenColor;
 #endif

+    optionsArray[options] = "Frame Visiblity Toggle";
+    optionsEnumArray[options++] = FrameToggles;
+
+    optionsArray[options] = "Display Units";
+    optionsEnumArray[options++] = DisplayUnits;
+
    BannerOverlayOptions bannerOptions;
-    bannerOptions.message = "Screen Options";
+    bannerOptions.message = "Display Options";
    bannerOptions.optionsArrayPtr = optionsArray;
    bannerOptions.optionsCount = options;
    bannerOptions.optionsEnumPtr = optionsEnumArray;
@@ -1376,6 +1368,12 @@ void menuHandler::screenOptionsMenu()
        } else if (selected == NodeNameLength) {
            menuHandler::menuQueue = menuHandler::node_name_length_menu;
            screen->runNow();
+        } else if (selected == FrameToggles) {
+            menuHandler::menuQueue = menuHandler::FrameToggles;
+            screen->runNow();
+        } else if (selected == DisplayUnits) {
+            menuHandler::menuQueue = menuHandler::DisplayUnits;
+            screen->runNow();
        } else {
            menuQueue = system_base_menu;
            screen->runNow();
@@ -1587,6 +1585,34 @@ void menuHandler::FrameToggles_menu()
    screen->showOverlayBanner(bannerOptions);
 }

+void menuHandler::DisplayUnits_menu()
+{
+    enum optionsNumbers { Back, MetricUnits, ImperialUnits };
+
+    static const char *optionsArray[] = {"Back", "Metric", "Imperial"};
+    BannerOverlayOptions bannerOptions;
+    bannerOptions.message = " Select display units";
+    bannerOptions.optionsArrayPtr = optionsArray;
+    bannerOptions.optionsCount = 3;
+    if (config.display.units == meshtastic_Config_DisplayConfig_DisplayUnits_IMPERIAL)
+        bannerOptions.InitialSelected = 2;
+    else
+        bannerOptions.InitialSelected = 1;
+    bannerOptions.bannerCallback = [](int selected) -> void {
+        if (selected == MetricUnits) {
+            config.display.units = meshtastic_Config_DisplayConfig_DisplayUnits_METRIC;
+            service->reloadConfig(SEGMENT_CONFIG);
+        } else if (selected == ImperialUnits) {
+            config.display.units = meshtastic_Config_DisplayConfig_DisplayUnits_IMPERIAL;
+            service->reloadConfig(SEGMENT_CONFIG);
+        } else {
+            menuHandler::menuQueue = menuHandler::screen_options_menu;
+            screen->runNow();
+        }
+    };
+    screen->showOverlayBanner(bannerOptions);
+}
+
 void menuHandler::handleMenuSwitch(OLEDDisplay *display)
 {
    if (menuQueue != menu_none)
@@ -1701,6 +1727,9 @@ void menuHandler::handleMenuSwitch(OLEDDisplay *display)
    case FrameToggles:
        FrameToggles_menu();
        break;
+    case DisplayUnits:
+        DisplayUnits_menu();
+        break;
    case throttle_message:
        screen->showSimpleBanner("Too Many Attempts\nTry again in 60 seconds.", 5000);
        break;
--- a/src/graphics/draw/MenuHandler.h
+++ b/src/graphics/draw/MenuHandler.h
@@ -44,7 +44,8 @@ class menuHandler
        trace_route_menu,
        throttle_message,
        node_name_length_menu,
-        FrameToggles
+        FrameToggles,
+        DisplayUnits
    };
    static screenMenus menuQueue;

@@ -88,6 +89,7 @@ class menuHandler
    static void powerMenu();
    static void nodeNameLengthMenu();
    static void FrameToggles_menu();
+    static void DisplayUnits_menu();
    static void textMessageMenu();

  private:
--- a/src/graphics/draw/NodeListRenderer.cpp
+++ b/src/graphics/draw/NodeListRenderer.cpp
@@ -425,6 +425,12 @@ void drawNodeListScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t
 {
    const int COMMON_HEADER_HEIGHT = FONT_HEIGHT_SMALL - 1;
    const int rowYOffset = FONT_HEIGHT_SMALL - 3;
+    bool locationScreen = false;
+
+    if (strcmp(title, "Bearings") == 0)
+        locationScreen = true;
+    else if (strcmp(title, "Distance") == 0)
+        locationScreen = true;
 #if defined(M5STACK_UNITC6L)
    int columnWidth = display->getWidth();
 #else
@@ -440,7 +446,7 @@ void drawNodeListScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t

    int totalEntries = nodeDB->getNumMeshNodes();
    int totalRowsAvailable = (display->getHeight() - y) / rowYOffset;
-
+    int numskipped = 0;
    int visibleNodeRows = totalRowsAvailable;
 #if defined(M5STACK_UNITC6L)
    int totalColumns = 1;
@@ -460,6 +466,10 @@ void drawNodeListScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t
    int rowCount = 0;

    for (int i = startIndex; i < endIndex; ++i) {
+        if (locationScreen && !nodeDB->getMeshNodeByIndex(i)->has_position) {
+            numskipped++;
+            continue;
+        }
        int xPos = x + (col * columnWidth);
        int yPos = y + yOffset;
        renderer(display, nodeDB->getMeshNodeByIndex(i), xPos, yPos, columnWidth);
@@ -482,6 +492,9 @@ void drawNodeListScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t
        }
    }

+    // This should correct the scrollbar
+    totalEntries -= numskipped;
+
 #if !defined(M5STACK_UNITC6L)
    // Draw column separator
    if (shownCount > 0) {
--- a/src/graphics/emotes.cpp
+++ b/src/graphics/emotes.cpp
@@ -18,6 +18,8 @@ const Emote emotes[] = {
    {"\U0001F642", Slightly_Smiling, Slightly_Smiling_width, Slightly_Smiling_height}, // 🙂 Slightly Smiling Face
    {"\U0001F609", Winking_Face, Winking_Face_width, Winking_Face_height},             // 😉 Winking Face
    {"\U0001F601", Grinning_Smiling_Eyes, Grinning_Smiling_Eyes_width, Grinning_Smiling_Eyes_height}, // 😁 Grinning Smiling Eyes
+    {"\U0001F60D", Heart_eyes, Heart_eyes_width, Heart_eyes_height},                                  // 😍 Heart Eyes
+    {"\U0001F970", heart_smile, heart_smile_width, heart_smile_height}, // 🥰 Smiling Face with Hearts

    // --- Question/Alert ---
    {"\u2753", question, question_width, question_height}, // ❓ Question Mark
@@ -30,11 +32,15 @@ const Emote emotes[] = {
    {"\U0001F605", haha, haha_width, haha_height},                                              // 😅 Smiling with Sweat
    {"\U0001F604", Grinning_SmilingEyes2, Grinning_SmilingEyes2_width,
     Grinning_SmilingEyes2_height}, // 😄 Grinning Face with Smiling Eyes
+    {"\U0001F62D", Loudly_Crying_Face, Loudly_Crying_Face_width, Loudly_Crying_Face_height}, // 😭 Loudly Crying Face

    // --- Gestures and People ---
-    {"\U0001F44B", wave_icon, wave_icon_width, wave_icon_height}, // 👋 Waving Hand
-    {"\U0001F920", cowboy, cowboy_width, cowboy_height},          // 🤠 Cowboy Hat Face
-    {"\U0001F3A7", deadmau5, deadmau5_width, deadmau5_height},    // 🎧 Headphones
+    {"\U0001F44B", wave_icon, wave_icon_width, wave_icon_height},             // 👋 Waving Hand
+    {"\u270C\uFE0F", peace_sign, peace_sign_width, peace_sign_height},        // ✌️ Victory Hand
+    {"\U0001F596", vulcan_salute, vulcan_salute_width, vulcan_salute_height}, // 🖖 Vulcan Salute
+    {"\U0001F64F", Praying, Praying_width, Praying_height},                   // 🙏 Praying Hands
+    {"\U0001F920", cowboy, cowboy_width, cowboy_height},                      // 🤠 Cowboy Hat Face
+    {"\U0001F3A7", deadmau5, deadmau5_width, deadmau5_height},                // 🎧 Headphones

    // --- Weather ---
    {"\u2600", sun, sun_width, sun_height},              // ☀ Sun (without variation selector)
@@ -45,8 +51,12 @@ const Emote emotes[] = {

    // --- Misc Faces ---
    {"\U0001F608", devil, devil_width, devil_height}, // 😈 Smiling Face with Horns
+    {"\U0001F921", clown, clown_width, clown_height}, // 🤡 Clown Face
+    {"\U0001F916", robo, robo_width, robo_height},    // 🤖 Robot Face

    // --- Hearts (Multiple Unicode Aliases) ---
+    {"\u2665", heart, heart_width, heart_height},       // ♥ Black Heart Suit
+    {"\u2665\uFE0F", heart, heart_width, heart_height}, // ♥️ Black Heart Suit (emoji presentation)
    {"\u2764\uFE0F", heart, heart_width, heart_height}, // ❤️ Red Heart
    {"\U0001F9E1", heart, heart_width, heart_height},   // 🧡 Orange Heart
    {"\U00002763", heart, heart_width, heart_height},   // ❣ Heart Exclamation
@@ -57,223 +67,166 @@ const Emote emotes[] = {
    {"\U0001F498", heart, heart_width, heart_height},   // 💘 Heart with Arrow

    // --- Objects ---
-    {"\U0001F4A9", poo, poo_width, poo_height},                  // 💩 Pile of Poo
-    {"\U0001F514", bell_icon, bell_icon_width, bell_icon_height} // 🔔 Bell
+    {"\U0001F4A9", poo, poo_width, poo_height},                   // 💩 Pile of Poo
+    {"\U0001F514", bell_icon, bell_icon_width, bell_icon_height}, // 🔔 Bell
+    {"\U0001F36A", cookie, cookie_width, cookie_height},          // 🍪 Cookie
+    {"\U0001F525", Fire, Fire_width, Fire_height},                // 🔥 Fire
+    {"\u2728", Sparkles, Sparkles_width, Sparkles_height},        // ✨ Sparkles
+    {"\U0001F573\uFE0F", hole, hole_width, hole_height},          // 🕳️ Hole
+    {"\U0001F3B3", bowling, bowling_width, bowling_height}        // 🎳 Bowling
 #endif
 };

 const int numEmotes = sizeof(emotes) / sizeof(emotes[0]);

 #ifndef EXCLUDE_EMOJI
-const unsigned char thumbup[] PROGMEM = {
-    0x00, 0x1C, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x80, 0x09, 0x00, 0x00,
-    0xC0, 0x08, 0x00, 0x00, 0x40, 0x08, 0x00, 0x00, 0x20, 0x04, 0x00, 0x00, 0x10, 0x04, 0x00, 0x00, 0x18, 0x02, 0x00, 0x00,
-    0x0C, 0xCE, 0x7F, 0x00, 0x04, 0x20, 0x80, 0x00, 0x02, 0x20, 0x80, 0x00, 0x02, 0x60, 0xC0, 0x00, 0x01, 0xF8, 0xFF, 0x01,
-    0x01, 0x08, 0x00, 0x01, 0x01, 0x08, 0x00, 0x01, 0x01, 0xF8, 0xFF, 0x00, 0x01, 0x10, 0x80, 0x00, 0x01, 0x18, 0x80, 0x00,
-    0x02, 0x30, 0xC0, 0x00, 0x06, 0xE0, 0x3F, 0x00, 0x0C, 0x20, 0x30, 0x00, 0x38, 0x20, 0x10, 0x00, 0xE0, 0xCF, 0x1F, 0x00,
-};
+const unsigned char thumbup[] PROGMEM = {0x00, 0x03, 0x80, 0x04, 0x80, 0x04, 0x40, 0x04, 0x20, 0x02, 0x18,
+                                         0x02, 0x06, 0x3F, 0x06, 0x40, 0x06, 0x70, 0x06, 0x40, 0x06, 0x70,
+                                         0x06, 0x40, 0x06, 0x30, 0x08, 0x20, 0xF0, 0x1F, 0x00, 0x00};

-const unsigned char thumbdown[] PROGMEM = {
-    0xE0, 0xCF, 0x1F, 0x00, 0x38, 0x20, 0x10, 0x00, 0x0C, 0x20, 0x30, 0x00, 0x06, 0xE0, 0x3F, 0x00, 0x02, 0x30, 0xC0, 0x00,
-    0x01, 0x18, 0x80, 0x00, 0x01, 0x10, 0x80, 0x00, 0x01, 0xF8, 0xFF, 0x00, 0x01, 0x08, 0x00, 0x01, 0x01, 0x08, 0x00, 0x01,
-    0x01, 0xF8, 0xFF, 0x01, 0x02, 0x60, 0xC0, 0x00, 0x02, 0x20, 0x80, 0x00, 0x04, 0x20, 0x80, 0x00, 0x0C, 0xCE, 0x7F, 0x00,
-    0x18, 0x02, 0x00, 0x00, 0x10, 0x04, 0x00, 0x00, 0x20, 0x04, 0x00, 0x00, 0x40, 0x08, 0x00, 0x00, 0xC0, 0x08, 0x00, 0x00,
-    0x80, 0x09, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00,
-};
+const unsigned char thumbdown[] PROGMEM = {0xF0, 0x1F, 0x08, 0x20, 0x06, 0x30, 0x06, 0x40, 0x06, 0x70, 0x06,
+                                           0x40, 0x06, 0x70, 0x06, 0x40, 0x06, 0x3F, 0x18, 0x02, 0x20, 0x02,
+                                           0x40, 0x04, 0x80, 0x04, 0x80, 0x04, 0x00, 0x03, 0x00, 0x00};

-const unsigned char Smiling_Eyes[] PROGMEM = {
-    0x00, 0xf8, 0x03, 0xc0, 0x00, 0xfe, 0x0f, 0xc0, 0x80, 0xff, 0x3f, 0xc0, 0xc0, 0xff, 0xff, 0xc0, 0xe0, 0xff, 0xff, 0xc1,
-    0xf0, 0xff, 0xff, 0xc3, 0xf8, 0xff, 0xff, 0xc7, 0xf8, 0xff, 0xff, 0xcf, 0xfc, 0xff, 0xff, 0xcf, 0xfc, 0xff, 0xff, 0xcf,
-    0x7e, 0xf8, 0xc3, 0xdf, 0x3e, 0xf0, 0x81, 0xdf, 0xbf, 0xf7, 0xbd, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9f, 0xff, 0x3f, 0xff,
-    0x6f, 0xff, 0xdf, 0xfe, 0x6f, 0xff, 0xdf, 0xfe, 0x9f, 0xff, 0x3f, 0xff, 0xfe, 0xff, 0xff, 0xdf, 0x7e, 0xff, 0xdf, 0xdf,
-    0x7c, 0xff, 0xdf, 0xcf, 0xfc, 0xfe, 0xef, 0xcf, 0xf8, 0xf9, 0xf7, 0xc7, 0xf8, 0x03, 0xf8, 0xc7, 0xf0, 0xff, 0xff, 0xc3,
-    0xe0, 0xff, 0xff, 0xc1, 0xc0, 0xff, 0xff, 0xc0, 0x80, 0xff, 0x3f, 0xc0, 0x00, 0xfe, 0x0f, 0xc0, 0x00, 0xf8, 0x07, 0xc0};
+const unsigned char Smiling_Eyes[] PROGMEM = {0x00, 0x00, 0xE0, 0x07, 0x18, 0x18, 0x04, 0x20, 0x24, 0x24, 0x52,
+                                              0x4A, 0x02, 0x40, 0x02, 0x40, 0x22, 0x44, 0x22, 0x44, 0xC2, 0x43,
+                                              0x04, 0x20, 0x04, 0x20, 0x18, 0x18, 0xE0, 0x07, 0x00, 0x00};

-const unsigned char Grinning[] PROGMEM = {
-    0x00, 0xf8, 0x03, 0xc0, 0x00, 0xfe, 0x0f, 0xc0, 0x80, 0xff, 0x3f, 0xc0, 0xc0, 0xff, 0xff, 0xc0, 0xe0, 0xff, 0xff, 0xc1,
-    0xf0, 0xff, 0xff, 0xc3, 0xf8, 0xff, 0xff, 0xc7, 0xf8, 0xff, 0xff, 0xcf, 0xfc, 0xf9, 0xf3, 0xcf, 0xfc, 0xf0, 0xe1, 0xcf,
-    0xfe, 0xf0, 0xe1, 0xdf, 0xfe, 0xf0, 0xe1, 0xdf, 0xff, 0xf0, 0xe1, 0xff, 0xff, 0xf9, 0xf3, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x80, 0xff, 0xbe, 0xff, 0xbf, 0xdf, 0x7e, 0x00, 0xc0, 0xdf,
-    0x7c, 0x00, 0xc0, 0xcf, 0xfc, 0x00, 0xe0, 0xcf, 0xf8, 0x01, 0xf0, 0xc7, 0xf8, 0x03, 0xf8, 0xc7, 0xf0, 0xff, 0xff, 0xc3,
-    0xe0, 0xff, 0xff, 0xc1, 0xc0, 0xff, 0xff, 0xc0, 0x80, 0xff, 0x3f, 0xc0, 0x00, 0xfe, 0x0f, 0xc0, 0x00, 0xf8, 0x03, 0xc0};
+const unsigned char Grinning[] PROGMEM = {0x00, 0x00, 0xE0, 0x07, 0x18, 0x18, 0x04, 0x20, 0x44, 0x22, 0x42,
+                                          0x42, 0x02, 0x40, 0x02, 0x40, 0xF2, 0x4F, 0x12, 0x48, 0x22, 0x44,
+                                          0xC4, 0x23, 0x04, 0x20, 0x18, 0x18, 0xE0, 0x07, 0x00, 0x00};

-const unsigned char Slightly_Smiling[] PROGMEM = {
-    0x00, 0xf8, 0x03, 0xc0, 0x00, 0xfe, 0x0f, 0xc0, 0x80, 0xff, 0x3f, 0xc0, 0xc0, 0xff, 0xff, 0xc0, 0xe0, 0xff, 0xff, 0xc1,
-    0xf0, 0xff, 0xff, 0xc3, 0xf8, 0xff, 0xff, 0xc7, 0xf8, 0xff, 0xff, 0xcf, 0xfc, 0xf9, 0xf3, 0xcf, 0xfc, 0xf0, 0xe1, 0xcf,
-    0xfe, 0xf0, 0xe1, 0xdf, 0xfe, 0xf0, 0xe1, 0xdf, 0xff, 0xf0, 0xe1, 0xff, 0xff, 0xf9, 0xf3, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xdf, 0x7e, 0xff, 0xdf, 0xdf,
-    0x7c, 0xff, 0xdf, 0xcf, 0xfc, 0xfe, 0xef, 0xcf, 0xf8, 0xf9, 0xf7, 0xc7, 0xf8, 0x03, 0xf8, 0xc7, 0xf0, 0xff, 0xff, 0xc3,
-    0xe0, 0xff, 0xff, 0xc1, 0xc0, 0xff, 0xff, 0xc0, 0x80, 0xff, 0x3f, 0xc0, 0x00, 0xfe, 0x0f, 0xc0, 0x00, 0xf8, 0x03, 0xc0};
+const unsigned char Slightly_Smiling[] PROGMEM = {0x00, 0x00, 0xE0, 0x07, 0x18, 0x18, 0x04, 0x20, 0x44, 0x22, 0x42,
+                                                  0x42, 0x02, 0x40, 0x02, 0x40, 0x12, 0x48, 0x12, 0x48, 0x22, 0x44,
+                                                  0xC4, 0x23, 0x04, 0x20, 0x18, 0x18, 0xE0, 0x07, 0x00, 0x00};

-const unsigned char Winking_Face[] PROGMEM = {
-    0x00, 0xf8, 0x03, 0xc0, 0x00, 0xfe, 0x0f, 0xc0, 0x80, 0xff, 0x3f, 0xc0, 0xc0, 0xff, 0xff, 0xc0, 0xe0, 0xff, 0xff, 0xc1,
-    0xf0, 0xf0, 0xff, 0xc3, 0x78, 0xef, 0xc3, 0xc7, 0xb8, 0xdf, 0xbd, 0xcf, 0xfc, 0xf9, 0x7f, 0xcf, 0xfc, 0xf0, 0xff, 0xcf,
-    0xfe, 0xf0, 0xc3, 0xdf, 0xfe, 0xf0, 0x81, 0xdf, 0xff, 0xf0, 0xbf, 0xff, 0xff, 0xf9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xdf, 0x7e, 0xff, 0xdf, 0xdf,
-    0x7c, 0xff, 0xdf, 0xcf, 0xfc, 0xfe, 0xef, 0xcf, 0xf8, 0xf9, 0xf7, 0xc7, 0xf8, 0x03, 0xf8, 0xc7, 0xf0, 0xff, 0xff, 0xc3,
-    0xe0, 0xff, 0xff, 0xc1, 0xc0, 0xff, 0xff, 0xc0, 0x80, 0xff, 0x3f, 0xc0, 0x00, 0xfe, 0x0f, 0xc0, 0x00, 0xf8, 0x07, 0xc0};
+const unsigned char Winking_Face[] PROGMEM = {0x00, 0x00, 0xE0, 0x07, 0x18, 0x18, 0x04, 0x20, 0x44, 0x20, 0x42,
+                                              0x46, 0x02, 0x40, 0x02, 0x40, 0x12, 0x48, 0x12, 0x48, 0x22, 0x44,
+                                              0xC4, 0x23, 0x04, 0x20, 0x18, 0x18, 0xE0, 0x07, 0x00, 0x00};

-const unsigned char Grinning_Smiling_Eyes[] PROGMEM = {
-    0x00, 0xf8, 0x03, 0xc0, 0x00, 0xfe, 0x0f, 0xc0, 0x80, 0xff, 0x3f, 0xc0, 0xc0, 0xff, 0xff, 0xc0, 0xe0, 0xff, 0xff, 0xc1,
-    0xf0, 0xff, 0xff, 0xc3, 0xf8, 0xff, 0xff, 0xc7, 0xf8, 0xff, 0xff, 0xcf, 0xfc, 0xf8, 0xe3, 0xcf, 0x7c, 0xf7, 0xdd, 0xcf,
-    0xbe, 0xef, 0xbe, 0xdf, 0xbe, 0xef, 0xbe, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x00, 0xff, 0x5e, 0x55, 0x55, 0xdf, 0x5e, 0x55, 0x55, 0xdf,
-    0x3c, 0x00, 0x80, 0xcf, 0x7c, 0x55, 0xd5, 0xcf, 0xf8, 0x54, 0xe5, 0xc7, 0xf8, 0x03, 0xf8, 0xc7, 0xf0, 0xff, 0xff, 0xc3,
-    0xe0, 0xff, 0xff, 0xc1, 0xc0, 0xff, 0xff, 0xc0, 0x80, 0xff, 0x3f, 0xc0, 0x00, 0xfe, 0x0f, 0xc0, 0x00, 0xf8, 0x03, 0xc0};
+const unsigned char Grinning_Smiling_Eyes[] PROGMEM = {0x00, 0x00, 0xE0, 0x07, 0x18, 0x18, 0x04, 0x20, 0x24, 0x24, 0x52,
+                                                       0x4A, 0x02, 0x40, 0xFA, 0x5F, 0x0A, 0x50, 0x0A, 0x50, 0x12, 0x48,
+                                                       0x24, 0x24, 0xC4, 0x23, 0x18, 0x18, 0xE0, 0x07, 0x00, 0x00};

-const unsigned char question[] PROGMEM = {
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x80, 0xFF, 0x01, 0x00, 0xC0, 0xFF, 0x07, 0x00, 0xE0, 0xFF, 0x07, 0x00,
-    0xE0, 0xC3, 0x0F, 0x00, 0xF0, 0x81, 0x0F, 0x00, 0xF0, 0x01, 0x0F, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x80, 0x0F, 0x00,
-    0x00, 0xC0, 0x0F, 0x00, 0x00, 0xE0, 0x07, 0x00, 0x00, 0xF0, 0x03, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0x7C, 0x00, 0x00,
-    0x00, 0x3C, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x3E, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-};
+const unsigned char heart_smile[] PROGMEM = {0x00, 0x00, 0x6C, 0x07, 0x7C, 0x18, 0x7C, 0x20, 0x38, 0x24, 0x52,
+                                             0x0A, 0x02, 0xD8, 0x02, 0xF8, 0x22, 0xFC, 0x20, 0x74, 0xDB, 0x23,
+                                             0x1F, 0x00, 0x1F, 0x20, 0x0E, 0x18, 0xE4, 0x07, 0x00, 0x00};

-const unsigned char bang[] PROGMEM = {
-    0xFF, 0x0F, 0xFC, 0x3F, 0xFF, 0x0F, 0xFC, 0x3F, 0xFF, 0x0F, 0xFC, 0x3F, 0xFF, 0x07, 0xF8, 0x3F, 0xFF, 0x07, 0xF8, 0x3F,
-    0xFE, 0x07, 0xF8, 0x1F, 0xFE, 0x07, 0xF8, 0x1F, 0xFE, 0x07, 0xF8, 0x1F, 0xFE, 0x07, 0xF8, 0x1F, 0xFE, 0x07, 0xF8, 0x1F,
-    0xFE, 0x03, 0xF0, 0x1F, 0xFE, 0x03, 0xF0, 0x1F, 0xFC, 0x03, 0xF0, 0x0F, 0xFC, 0x03, 0xF0, 0x0F, 0xFC, 0x03, 0xF0, 0x0F,
-    0xFC, 0x03, 0xF0, 0x0F, 0xFC, 0x03, 0xF0, 0x0F, 0xFC, 0x03, 0xF0, 0x0F, 0xFC, 0x01, 0xE0, 0x0F, 0xFC, 0x01, 0xE0, 0x0F,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x00, 0xC0, 0x03, 0xFC, 0x03, 0xF0, 0x0F, 0xFE, 0x03, 0xF0, 0x1F,
-    0xFE, 0x07, 0xF8, 0x1F, 0xFE, 0x07, 0xF8, 0x1F, 0xFE, 0x07, 0xF8, 0x1F, 0xFC, 0x03, 0xF0, 0x0F, 0xF8, 0x01, 0xE0, 0x07,
-};
+const unsigned char Heart_eyes[] PROGMEM = {0x00, 0x00, 0xE0, 0x07, 0x18, 0x18, 0x04, 0x20, 0x54, 0x2A, 0xFA,
+                                            0x5F, 0x72, 0x4E, 0x22, 0x44, 0x02, 0x40, 0x12, 0x48, 0x12, 0x48,
+                                            0x24, 0x24, 0xC4, 0x23, 0x18, 0x18, 0xE0, 0x07, 0x00, 0x00};

-const unsigned char haha[] PROGMEM = {
-    0x00, 0xf8, 0x03, 0xc0, 0x00, 0xfe, 0x0f, 0xc0, 0x80, 0xff, 0x3f, 0xc0, 0xc0, 0xff, 0x7f, 0xc0, 0xe0, 0xf9, 0xf3, 0xc0,
-    0xf0, 0xfe, 0xef, 0xc1, 0x38, 0xff, 0x9f, 0xc3, 0xd8, 0xff, 0x7f, 0xc3, 0xfc, 0xf8, 0xe3, 0xc7, 0x7c, 0xf7, 0xdd, 0xcf,
-    0xbe, 0xef, 0xbe, 0xcf, 0xfe, 0xff, 0xff, 0xcf, 0xef, 0xff, 0xff, 0xde, 0xe7, 0xff, 0xff, 0xdc, 0xeb, 0xff, 0xff, 0xda,
-    0xed, 0xff, 0xff, 0xd6, 0xee, 0xff, 0xff, 0xce, 0x36, 0x00, 0x80, 0xcd, 0xb8, 0xff, 0xbf, 0xc3, 0x7e, 0x00, 0xc0, 0xdf,
-    0x7c, 0x00, 0xc0, 0xcf, 0xfc, 0x00, 0xe0, 0xcf, 0xf8, 0x01, 0xf0, 0xc7, 0xf8, 0x03, 0xf8, 0xc7, 0xf0, 0xff, 0xff, 0xc3,
-    0xe0, 0xff, 0xff, 0xc1, 0xc0, 0xff, 0xff, 0xc0, 0x80, 0xff, 0x3f, 0xc0, 0x00, 0xfe, 0x0f, 0xc0, 0x00, 0xf8, 0x03, 0xc0};
+const unsigned char question[] PROGMEM = {0xE0, 0x07, 0x10, 0x08, 0x08, 0x10, 0x88, 0x11, 0x48, 0x12, 0x48,
+                                          0x12, 0x48, 0x12, 0x30, 0x11, 0x80, 0x08, 0x40, 0x04, 0x40, 0x02,
+                                          0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x40, 0x02, 0x80, 0x01};

-const unsigned char ROFL[] PROGMEM = {
-    0x00, 0x00, 0x00, 0xc0, 0x00, 0xfc, 0x07, 0xc0, 0x00, 0xff, 0x1f, 0xc0, 0x80, 0xff, 0x7f, 0xc0, 0xc0, 0xff, 0xff, 0xc0,
-    0xe0, 0x9f, 0xff, 0xc1, 0xf0, 0x9f, 0xff, 0xc0, 0xf8, 0x9f, 0x7f, 0xcb, 0xf8, 0x9f, 0xbf, 0xcb, 0xfc, 0x9f, 0xdf, 0xdb,
-    0xfc, 0x1f, 0x08, 0xdc, 0xfe, 0x1f, 0xf8, 0xfe, 0xfe, 0xff, 0xff, 0xfe, 0x1e, 0xf0, 0x7f, 0xfe, 0x1e, 0xf0, 0xbf, 0xfe,
-    0xfe, 0xf3, 0xdf, 0xfe, 0xfe, 0xf3, 0x6f, 0xfe, 0xfe, 0xf3, 0x37, 0xfe, 0xfe, 0xeb, 0x1b, 0xfe, 0xfc, 0xef, 0x0d, 0xde,
-    0xfc, 0xe7, 0x06, 0xcf, 0xf8, 0x6b, 0x83, 0xcf, 0xf8, 0x0d, 0xc0, 0xc7, 0xf0, 0xed, 0xff, 0xc7, 0xe0, 0xee, 0xff, 0xc3,
-    0xc0, 0xee, 0xff, 0xc1, 0x80, 0xee, 0xff, 0xc0, 0x00, 0xe6, 0x3f, 0xc0, 0x00, 0xf0, 0x0f, 0xc0, 0x00, 0x00, 0x00, 0xc0};
+const unsigned char bang[] PROGMEM = {0x30, 0x0C, 0x48, 0x12, 0x48, 0x12, 0x48, 0x12, 0x48, 0x12, 0x48,
+                                      0x12, 0x48, 0x12, 0x48, 0x12, 0x48, 0x12, 0x48, 0x12, 0x30, 0x0C,
+                                      0x00, 0x00, 0x30, 0x0C, 0x48, 0x12, 0x30, 0x0C, 0x00, 0x00};

-const unsigned char Smiling_Closed_Eyes[] PROGMEM = {
-    0x00, 0xf8, 0x03, 0xc0, 0x00, 0xfe, 0x0f, 0xc0, 0x80, 0xff, 0x3f, 0xc0, 0xc0, 0xff, 0xff, 0xc0, 0xe0, 0xff, 0xff, 0xc1,
-    0xf0, 0xff, 0xff, 0xc3, 0xf8, 0xff, 0xff, 0xc7, 0xf8, 0xff, 0xff, 0xcf, 0x7c, 0xfe, 0xcf, 0xcf, 0xfc, 0xfc, 0xe7, 0xcf,
-    0xfe, 0xf9, 0xf3, 0xdf, 0xfe, 0xf3, 0xf9, 0xdf, 0xff, 0xf9, 0xf3, 0xff, 0xff, 0xfc, 0xe7, 0xff, 0x7f, 0xfe, 0xcf, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x80, 0xff, 0xbe, 0xff, 0xbf, 0xdf, 0x7e, 0x00, 0xc0, 0xdf,
-    0x7c, 0x00, 0xc0, 0xcf, 0xfc, 0x00, 0xe0, 0xcf, 0xf8, 0x01, 0xf0, 0xc7, 0xf8, 0x03, 0xf8, 0xc7, 0xf0, 0xff, 0xff, 0xc3,
-    0xe0, 0xff, 0xff, 0xc1, 0xc0, 0xff, 0xff, 0xc0, 0x80, 0xff, 0x3f, 0xc0, 0x00, 0xfe, 0x0f, 0xc0, 0x00, 0xf8, 0x03, 0xc0};
+const unsigned char haha[] PROGMEM = {0x00, 0x00, 0xE0, 0x07, 0x18, 0x18, 0x04, 0x20, 0x24, 0x24, 0x52,
+                                      0x4A, 0x0A, 0x50, 0x0E, 0x70, 0xF2, 0x4F, 0x12, 0x48, 0x32, 0x44,
+                                      0xC4, 0x23, 0x04, 0x20, 0x18, 0x18, 0xE0, 0x07, 0x00, 0x00};

-const unsigned char Grinning_SmilingEyes2[] PROGMEM = {
-    0x00, 0xf8, 0x03, 0xc0, 0x00, 0xfe, 0x0f, 0xc0, 0x80, 0xff, 0x3f, 0xc0, 0xc0, 0xff, 0x7f, 0xc0, 0xe0, 0xff, 0xff, 0xc0,
-    0xf0, 0xff, 0xff, 0xc1, 0xf8, 0xff, 0xff, 0xc3, 0xf8, 0xff, 0xff, 0xc3, 0xfc, 0xf8, 0xe3, 0xc7, 0x7c, 0xf7, 0xdd, 0xc7,
-    0xbe, 0xef, 0xbe, 0xcf, 0xfe, 0xff, 0xff, 0xcf, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xdf,
-    0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xdf, 0x3f, 0x00, 0x80, 0xdf, 0xbe, 0xff, 0xbf, 0xcf, 0x7e, 0x00, 0xc0, 0xcf,
-    0x7c, 0x00, 0xc0, 0xc7, 0xfc, 0x00, 0xe0, 0xc7, 0xf8, 0x01, 0xf0, 0xc3, 0xf8, 0x03, 0xf8, 0xc3, 0xf0, 0xff, 0xff, 0xc1,
-    0xe0, 0xff, 0xff, 0xc0, 0xc0, 0xff, 0x7f, 0xc0, 0x80, 0xff, 0x3f, 0xc0, 0x00, 0xfe, 0x0f, 0xc0, 0x00, 0xf8, 0x03, 0xc0};
+const unsigned char ROFL[] PROGMEM = {0x00, 0x00, 0xE0, 0x07, 0x18, 0x18, 0x84, 0x21, 0x84, 0x20, 0x02,
+                                      0x4C, 0x02, 0x4A, 0x1A, 0x49, 0x8A, 0x48, 0x42, 0x48, 0x22, 0x44,
+                                      0xE4, 0x23, 0x04, 0x20, 0x18, 0x18, 0xE0, 0x07, 0x00, 0x00};

-const unsigned char wave_icon[] PROGMEM = {
-    0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x7f, 0xc0, 0x00, 0x00, 0xc0, 0xc1, 0x00, 0x00, 0x00, 0xc7,
-    0x00, 0x00, 0x1e, 0xcc, 0x00, 0x00, 0x30, 0xc8, 0x00, 0x00, 0x60, 0xd8, 0x00, 0x08, 0xc0, 0xd0, 0x00, 0x1a, 0x81, 0xd1,
-    0x00, 0x36, 0x03, 0xd3, 0x80, 0x6d, 0x06, 0xd2, 0x00, 0xdb, 0x0c, 0xc2, 0x80, 0xb6, 0x1d, 0xc0, 0x80, 0x6d, 0x1f, 0xc0,
-    0x00, 0xdb, 0x3f, 0xc0, 0x00, 0xf6, 0x7f, 0xc0, 0x00, 0xfc, 0x7f, 0xc0, 0x08, 0xf8, 0x7f, 0xc0, 0x48, 0xf0, 0x7f, 0xc0,
-    0x48, 0xe0, 0x7f, 0xc0, 0xc8, 0xc0, 0x3f, 0xc0, 0x98, 0x81, 0x1f, 0xc0, 0x10, 0x03, 0x00, 0xc0, 0x30, 0x0e, 0x00, 0xc0,
-    0x20, 0x38, 0x00, 0xc0, 0xe0, 0x00, 0x00, 0xc0, 0x80, 0x07, 0x00, 0xc0, 0x00, 0x1e, 0x00, 0xc0, 0x00, 0x00, 0x00, 0xc0};
+const unsigned char Smiling_Closed_Eyes[] PROGMEM = {0x00, 0x00, 0xE0, 0x07, 0x18, 0x18, 0x04, 0x20, 0x24, 0x24, 0x42,
+                                                     0x42, 0x22, 0x44, 0x02, 0x40, 0xF2, 0x4F, 0x12, 0x48, 0x22, 0x44,
+                                                     0xC4, 0x23, 0x04, 0x20, 0x18, 0x18, 0xE0, 0x07, 0x00, 0x00};

-const unsigned char cowboy[] PROGMEM = {
-    0x00, 0x0c, 0x0c, 0xc0, 0x00, 0x02, 0x10, 0xc0, 0x00, 0x01, 0x20, 0xc0, 0xbc, 0x00, 0x40, 0xcf, 0xc2, 0x01, 0xe0, 0xd0,
-    0x01, 0x01, 0x20, 0xe0, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0xc0,
-    0xc1, 0x3f, 0xff, 0xe0, 0xe1, 0xff, 0xff, 0xe1, 0xf2, 0xf3, 0xf3, 0xd3, 0xf4, 0xf1, 0xe3, 0xcb, 0xfc, 0xf1, 0xe3, 0xc7,
-    0xf8, 0xf1, 0xe3, 0xc7, 0xf8, 0xf1, 0xe3, 0xc7, 0xf8, 0xfb, 0xf7, 0xc7, 0xf8, 0xff, 0xff, 0xc7, 0xf8, 0xff, 0xff, 0xc7,
-    0x70, 0xf8, 0x8f, 0xc3, 0x70, 0x03, 0xb0, 0xc3, 0x70, 0xfe, 0xbf, 0xc3, 0x60, 0x00, 0x80, 0xc1, 0xc0, 0x00, 0xc0, 0xc0,
-    0x80, 0x01, 0x60, 0xc0, 0x00, 0x07, 0x38, 0xc0, 0x00, 0xfe, 0x1f, 0xc0, 0x00, 0xf0, 0x03, 0xc0, 0x00, 0x00, 0x00, 0xc0};
+const unsigned char Grinning_SmilingEyes2[] PROGMEM = {0x00, 0x00, 0xE0, 0x07, 0x18, 0x18, 0x04, 0x20, 0x24, 0x24, 0x52,
+                                                       0x4A, 0x02, 0x40, 0x02, 0x40, 0xF2, 0x4F, 0x12, 0x48, 0x22, 0x44,
+                                                       0xC4, 0x23, 0x04, 0x20, 0x18, 0x18, 0xE0, 0x07, 0x00, 0x00};

-const unsigned char deadmau5[] PROGMEM = {
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x07, 0x00,
-    0x00, 0xFC, 0x03, 0x00, 0x00, 0xFF, 0x3F, 0x00, 0x80, 0xFF, 0x0F, 0x00, 0xC0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0x3F, 0x00,
-    0xE0, 0xFF, 0xFF, 0x01, 0xF0, 0xFF, 0x7F, 0x00, 0xF0, 0xFF, 0xFF, 0x03, 0xF8, 0xFF, 0xFF, 0x00, 0xF0, 0xFF, 0xFF, 0x07,
-    0xFC, 0xFF, 0xFF, 0x00, 0xF0, 0xFF, 0xFF, 0x0F, 0xFC, 0xFF, 0xFF, 0x00, 0xF0, 0xFF, 0xFF, 0x0F, 0xFE, 0xFF, 0xFF, 0x00,
-    0xF0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0xF0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0x3F, 0xFC,
-    0x0F, 0xFF, 0x7F, 0x00, 0xC0, 0xFF, 0x1F, 0xF8, 0x0F, 0xFC, 0x3F, 0x00, 0x80, 0xFF, 0x0F, 0xF8, 0x1F, 0xFC, 0x1F, 0x00,
-    0x00, 0xFF, 0x0F, 0xFC, 0x3F, 0xFC, 0x0F, 0x00, 0x00, 0xF8, 0x1F, 0xFF, 0xFF, 0xFE, 0x01, 0x00, 0x00, 0x00, 0xFC, 0xFF,
-    0xFF, 0x07, 0x00, 0x00, 0x00, 0x00, 0xFC, 0xFF, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00,
-    0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x00, 0xC0, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x80, 0x07, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-};
+const unsigned char Loudly_Crying_Face[] PROGMEM = {0x00, 0x00, 0xE0, 0x07, 0x18, 0x18, 0x04, 0x20, 0x34, 0x2C, 0x4A,
+                                                    0x52, 0x12, 0x48, 0x12, 0x48, 0x92, 0x49, 0x52, 0x4A, 0x52, 0x4A,
+                                                    0x54, 0x2A, 0x94, 0x29, 0x18, 0x18, 0xF0, 0x0F, 0x00, 0x00};

-const unsigned char sun[] PROGMEM = {
-    0x00, 0xC0, 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x30, 0xC0, 0x00, 0x03,
-    0x70, 0x00, 0x80, 0x03, 0xF0, 0x00, 0xC0, 0x03, 0xF0, 0xF8, 0xC7, 0x03, 0xE0, 0xFC, 0xCF, 0x01, 0x00, 0xFE, 0x1F, 0x00,
-    0x00, 0xFF, 0x3F, 0x00, 0x80, 0xFF, 0x7F, 0x00, 0x80, 0xFF, 0x7F, 0x00, 0x8E, 0xFF, 0x7F, 0x1C, 0x9F, 0xFF, 0x7F, 0x3E,
-    0x9F, 0xFF, 0x7F, 0x3E, 0x8E, 0xFF, 0x7F, 0x1C, 0x80, 0xFF, 0x7F, 0x00, 0x80, 0xFF, 0x7F, 0x00, 0x00, 0xFF, 0x3F, 0x00,
-    0x00, 0xFE, 0x1F, 0x00, 0x00, 0xFC, 0x0F, 0x00, 0xC0, 0xF9, 0xE7, 0x00, 0xE0, 0x01, 0xE0, 0x01, 0xF0, 0x01, 0xE0, 0x03,
-    0xF0, 0xC0, 0xC0, 0x03, 0x00, 0xE0, 0x01, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0xC0, 0x00, 0x00,
-};
+const unsigned char wave_icon[] PROGMEM = {0x00, 0x00, 0xC0, 0x18, 0x30, 0x21, 0x48, 0x5A, 0x94, 0x64, 0x24,
+                                           0x25, 0x4A, 0x24, 0x12, 0x44, 0x22, 0x44, 0x04, 0x40, 0x08, 0x40,
+                                           0x12, 0x40, 0x22, 0x20, 0xC4, 0x10, 0x18, 0x0F, 0x00, 0x00};

-const unsigned char rain[] PROGMEM = {
-    0xC0, 0x0F, 0xC0, 0x00, 0x40, 0x00, 0x80, 0x00, 0x20, 0x00, 0x80, 0x00, 0x20, 0x00, 0x80, 0x03, 0x38, 0x00,
-    0x00, 0x0E, 0x0C, 0x00, 0x00, 0x18, 0x02, 0x00, 0x00, 0x10, 0x03, 0x00, 0x00, 0x30, 0x01, 0x00, 0x00, 0x20,
-    0x01, 0x00, 0x00, 0x20, 0x01, 0x00, 0x00, 0x20, 0x01, 0x00, 0x00, 0x20, 0x03, 0x00, 0x00, 0x30, 0x02, 0x00,
-    0x00, 0x10, 0x06, 0x00, 0x00, 0x08, 0xFC, 0xFF, 0xFF, 0x07, 0xF0, 0xFF, 0xFF, 0x01, 0x80, 0x00, 0x01, 0x00,
-    0xC0, 0xC0, 0x81, 0x03, 0xA0, 0x60, 0xC1, 0x03, 0x90, 0x20, 0x41, 0x01, 0xF0, 0xE0, 0xC0, 0x01, 0x60, 0x4C,
-    0x98, 0x00, 0x00, 0x0E, 0x1C, 0x00, 0x00, 0x0B, 0x12, 0x00, 0x00, 0x09, 0x1A, 0x00, 0x00, 0x06, 0x0E, 0x00,
-};
+const unsigned char cowboy[] PROGMEM = {0x70, 0x0E, 0x8F, 0xF1, 0x11, 0x88, 0x21, 0x84, 0xC2, 0x43, 0x1E,
+                                        0x78, 0xE2, 0x47, 0x42, 0x42, 0x12, 0x48, 0x12, 0x48, 0x22, 0x44,
+                                        0xC4, 0x23, 0x04, 0x20, 0x18, 0x18, 0xE0, 0x07, 0x00, 0x00};

-const unsigned char cloud[] PROGMEM = {
-    0x00, 0x80, 0x07, 0x00, 0x00, 0xE0, 0x1F, 0x00, 0x00, 0x70, 0x30, 0x00, 0x00, 0x10, 0x60, 0x00, 0x80, 0x1F, 0x40, 0x00,
-    0xC0, 0x0F, 0xC0, 0x00, 0xC0, 0x00, 0x80, 0x00, 0x60, 0x00, 0x80, 0x00, 0x20, 0x00, 0x80, 0x00, 0x20, 0x00, 0x80, 0x01,
-    0x20, 0x00, 0x00, 0x07, 0x38, 0x00, 0x00, 0x0C, 0x0C, 0x00, 0x00, 0x08, 0x06, 0x00, 0x00, 0x18, 0x02, 0x00, 0x00, 0x10,
-    0x02, 0x00, 0x00, 0x30, 0x03, 0x00, 0x00, 0x20, 0x01, 0x00, 0x00, 0x20, 0x01, 0x00, 0x00, 0x20, 0x01, 0x00, 0x00, 0x20,
-    0x01, 0x00, 0x00, 0x20, 0x01, 0x00, 0x00, 0x20, 0x01, 0x00, 0x00, 0x20, 0x01, 0x00, 0x00, 0x30, 0x03, 0x00, 0x00, 0x10,
-    0x02, 0x00, 0x00, 0x10, 0x06, 0x00, 0x00, 0x18, 0x0C, 0x00, 0x00, 0x0C, 0xFC, 0xFF, 0xFF, 0x07, 0xF0, 0xFF, 0xFF, 0x03,
-};
+const unsigned char deadmau5[] PROGMEM = {0x00, 0x00, 0xE0, 0x07, 0x18, 0x18, 0xE4, 0x27, 0x12, 0x48, 0x0A,
+                                          0x50, 0x0E, 0x70, 0x11, 0x88, 0x19, 0x98, 0x19, 0x98, 0x19, 0x98,
+                                          0x19, 0x98, 0x19, 0x98, 0x11, 0x88, 0x0E, 0x70, 0x00, 0x00};

-const unsigned char fog[] PROGMEM = {
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x78, 0x00, 0x3C, 0x00, 0xFE, 0x01, 0xFF, 0x00, 0x87, 0xC7, 0xC3, 0x01, 0x03, 0xFE, 0x80, 0x01,
-    0x00, 0x38, 0x00, 0x00, 0xFC, 0x00, 0x7E, 0x00, 0xFF, 0x83, 0xFF, 0x01, 0x03, 0xFF, 0x81, 0x01, 0x00, 0x7C, 0x00, 0x00,
-    0xF8, 0x00, 0x3E, 0x00, 0xFE, 0x01, 0xFF, 0x00, 0x87, 0xC7, 0xC3, 0x01, 0x03, 0xFE, 0x80, 0x01, 0x00, 0x38, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-};
+const unsigned char sun[] PROGMEM = {0x00, 0x00, 0x80, 0x01, 0xEC, 0x37, 0xFC, 0x3F, 0xF8, 0x1F, 0xFC,
+                                     0x3F, 0xFE, 0x7F, 0xFC, 0x3F, 0xFC, 0x3F, 0xFE, 0x7F, 0xFC, 0x3F,
+                                     0xF8, 0x1F, 0xFC, 0x3F, 0xEC, 0x37, 0x80, 0x01, 0x00, 0x00};

-const unsigned char devil[] PROGMEM = {
-    0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0xc0, 0x01, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0xf0, 0x0f, 0xfc, 0x0f, 0xfc,
-    0x3f, 0xff, 0x3f, 0xff, 0xfe, 0xff, 0xff, 0xdf, 0xfe, 0xff, 0xff, 0xdf, 0xfe, 0xff, 0xff, 0xdf, 0xfc, 0xff, 0xff, 0xcf,
-    0xfc, 0xff, 0xff, 0xcf, 0xf8, 0xff, 0xff, 0xc7, 0xf0, 0xff, 0xff, 0xc3, 0xf0, 0xff, 0xff, 0xc3, 0xf0, 0xf1, 0xe3, 0xc3,
-    0xf0, 0xe7, 0xf9, 0xc3, 0xf0, 0xe7, 0xf9, 0xc3, 0xf0, 0xe3, 0xf1, 0xc3, 0xf0, 0xe3, 0xf1, 0xc3, 0xf0, 0xe7, 0xf9, 0xc3,
-    0xf0, 0xff, 0xff, 0xc3, 0xe0, 0xfd, 0xef, 0xc1, 0xe0, 0xf3, 0xf3, 0xc1, 0xc0, 0x07, 0xf8, 0xc0, 0x80, 0x1f, 0x7e, 0xc0,
-    0x00, 0xff, 0x3f, 0xc0, 0x00, 0xfe, 0x0f, 0xc0, 0x00, 0xf8, 0x03, 0xc0, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0xc0};
+const unsigned char rain[] PROGMEM = {0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x38, 0x1F, 0xFC, 0x3F, 0xFE,
+                                      0x7F, 0xFE, 0x7F, 0xFE, 0x7F, 0xFC, 0x3F, 0x00, 0x00, 0x48, 0x12,
+                                      0x48, 0x12, 0x24, 0x09, 0x24, 0x09, 0x00, 0x00, 0x00, 0x00};

-const unsigned char heart[] PROGMEM = {
-    0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0xF0, 0x00, 0xF8, 0x0F, 0xFC, 0x07, 0xFC, 0x1F, 0x06, 0x0E, 0xFE, 0x3F, 0x03, 0x18,
-    0xFE, 0xFF, 0x7F, 0x10, 0xFF, 0xFF, 0xFF, 0x31, 0xFF, 0xFF, 0xFF, 0x33, 0xFF, 0xFF, 0xFF, 0x37, 0xFF, 0xFF, 0xFF, 0x37,
-    0xFF, 0xFF, 0xFF, 0x3F, 0xFF, 0xFF, 0xFF, 0x3F, 0xFF, 0xFF, 0xFF, 0x3F, 0xFE, 0xFF, 0xFF, 0x1F, 0xFE, 0xFF, 0xFF, 0x1F,
-    0xFC, 0xFF, 0xFF, 0x0F, 0xFC, 0xFF, 0xFF, 0x0F, 0xF8, 0xFF, 0xFF, 0x07, 0xF0, 0xFF, 0xFF, 0x03, 0xF0, 0xFF, 0xFF, 0x03,
-    0xE0, 0xFF, 0xFF, 0x01, 0xC0, 0xFF, 0xFF, 0x00, 0x80, 0xFF, 0x7F, 0x00, 0x00, 0xFF, 0x3F, 0x00, 0x00, 0xFE, 0x1F, 0x00,
-    0x00, 0xFC, 0x0F, 0x00, 0x00, 0xF8, 0x07, 0x00, 0x00, 0xF0, 0x03, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x80, 0x00, 0x00,
-};
+const unsigned char cloud[] PROGMEM = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x38, 0x1F, 0xFC,
+                                       0x3F, 0xFE, 0x7F, 0xFE, 0x7F, 0xFE, 0x7F, 0xFC, 0x3F, 0xF8, 0x1F,
+                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

-const unsigned char poo[] PROGMEM = {
-    0x00, 0x1c, 0x00, 0xc0, 0x00, 0x7c, 0x00, 0xc0, 0x00, 0xfc, 0x00, 0xc0, 0x00, 0x7c, 0x03, 0xc0, 0x00, 0xbe, 0x03, 0xc0,
-    0x00, 0xdf, 0x0f, 0xc0, 0x80, 0xcf, 0x0f, 0xc0, 0xc0, 0xf1, 0x0f, 0xc0, 0x60, 0xfc, 0x0f, 0xc0, 0x30, 0xff, 0x07, 0xc0,
-    0x90, 0xff, 0x3b, 0xc0, 0xc0, 0xff, 0x7d, 0xc0, 0xf8, 0xff, 0xfc, 0xc0, 0xf8, 0x3f, 0xf0, 0xc0, 0x78, 0x88, 0xc0, 0xc0,
-    0x20, 0xe3, 0x18, 0xc0, 0x98, 0xe7, 0xbc, 0xc1, 0x9c, 0x64, 0xa4, 0xc3, 0x9e, 0x64, 0xa4, 0xc7, 0xbe, 0xe4, 0xa4, 0xc7,
-    0xbc, 0x27, 0xbc, 0xc7, 0x38, 0x03, 0xd9, 0xc3, 0x00, 0xf0, 0x63, 0xc0, 0xf8, 0xfc, 0x3f, 0xcf, 0xfc, 0xff, 0x87, 0xdf,
-    0xfe, 0xff, 0xe0, 0xdf, 0xfc, 0x1f, 0xfe, 0xdf, 0xf8, 0x07, 0xf8, 0xcf, 0xf0, 0x03, 0xe0, 0xc7, 0x00, 0x00, 0x00, 0xc0};
+const unsigned char fog[] PROGMEM = {0x00, 0x00, 0x00, 0x00, 0x88, 0x88, 0x54, 0x55, 0x22, 0x22, 0x00,
+                                     0x00, 0x44, 0x44, 0xAA, 0x2A, 0x11, 0x11, 0x00, 0x00, 0x88, 0x88,
+                                     0x54, 0x55, 0x22, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

-const unsigned char bell_icon[] PROGMEM = {
-    0b00000000, 0b00000000, 0b00000000, 0b00000000, 0b00000000, 0b00000000, 0b00000000, 0b00000000, 0b00000000, 0b11110000,
-    0b00000011, 0b00000000, 0b00000000, 0b11111100, 0b00001111, 0b00000000, 0b00000000, 0b00001111, 0b00111100, 0b00000000,
-    0b00000000, 0b00000011, 0b00110000, 0b00000000, 0b10000000, 0b00000001, 0b01100000, 0b00000000, 0b11000000, 0b00000000,
-    0b11000000, 0b00000000, 0b11000000, 0b00000000, 0b11000000, 0b00000000, 0b11000000, 0b00000000, 0b11000000, 0b00000000,
-    0b11000000, 0b00000000, 0b11000000, 0b00000000, 0b11000000, 0b00000000, 0b11000000, 0b00000000, 0b11000000, 0b00000000,
-    0b11000000, 0b00000000, 0b11000000, 0b00000000, 0b11000000, 0b00000000, 0b11000000, 0b00000000, 0b11000000, 0b00000000,
-    0b11000000, 0b00000000, 0b11000000, 0b00000000, 0b01000000, 0b00000000, 0b10000000, 0b00000000, 0b01100000, 0b00000000,
-    0b10000000, 0b00000001, 0b01110000, 0b00000000, 0b10000000, 0b00000011, 0b00110000, 0b00000000, 0b00000000, 0b00000011,
-    0b00011000, 0b00000000, 0b00000000, 0b00000110, 0b11110000, 0b11111111, 0b11111111, 0b00000011, 0b00000000, 0b00001100,
-    0b00001100, 0b00000000, 0b00000000, 0b00011000, 0b00000110, 0b00000000, 0b00000000, 0b11111000, 0b00000111, 0b00000000,
-    0b00000000, 0b11100000, 0b00000001, 0b00000000, 0b00000000, 0b00000000, 0b00000000, 0b00000000, 0b00000000, 0b00000000,
-    0b00000000, 0b00000000, 0b00000000, 0b00000000, 0b00000000, 0b00000000, 0b00000000, 0b00000000, 0b00000000, 0b00000000};
+const unsigned char devil[] PROGMEM = {0x06, 0x60, 0xCA, 0x53, 0x32, 0x4C, 0x22, 0x44, 0x44, 0x22, 0x3A,
+                                       0x5C, 0x32, 0x4C, 0x52, 0x4A, 0x72, 0x4E, 0x02, 0x40, 0x22, 0x44,
+                                       0xC4, 0x23, 0x04, 0x20, 0x18, 0x18, 0xE0, 0x07, 0x00, 0x00};
+
+const unsigned char heart[] PROGMEM = {0x00, 0x00, 0x00, 0x00, 0x3C, 0x3C, 0x7E, 0x7E, 0xFE, 0x7F, 0xFE,
+                                       0x7F, 0xFE, 0x7F, 0xFE, 0x7F, 0xFC, 0x3F, 0xF8, 0x1F, 0xF8, 0x1F,
+                                       0xF0, 0x0F, 0xE0, 0x07, 0xC0, 0x03, 0x80, 0x01, 0x00, 0x00};
+
+const unsigned char poo[] PROGMEM = {0x00, 0x00, 0x80, 0x01, 0x40, 0x02, 0x20, 0x04, 0x10, 0x04, 0xF0,
+                                     0x08, 0x10, 0x10, 0x48, 0x12, 0x08, 0x18, 0xE8, 0x21, 0x1C, 0x40,
+                                     0x42, 0x42, 0x82, 0x41, 0x02, 0x30, 0xFC, 0x0F, 0x00, 0x00};
+
+const unsigned char bell_icon[] PROGMEM = {0x00, 0x00, 0x80, 0x01, 0x80, 0x01, 0xE0, 0x07, 0xF0, 0x0F, 0xF0,
+                                           0x0F, 0xF8, 0x1F, 0xF8, 0x1F, 0xF8, 0x1F, 0xF8, 0x1F, 0xFC, 0x3F,
+                                           0xFC, 0x3F, 0xFE, 0x7F, 0xFE, 0x7F, 0x80, 0x01, 0x00, 0x00};
+
+const unsigned char cookie[] PROGMEM = {0x00, 0x00, 0xE0, 0x07, 0x18, 0x18, 0x04, 0x20, 0x34, 0x22, 0x32,
+                                        0x40, 0x02, 0x58, 0x82, 0x5B, 0x92, 0x43, 0x82, 0x43, 0x02, 0x40,
+                                        0x64, 0x28, 0x64, 0x20, 0x18, 0x18, 0xE0, 0x07, 0x00, 0x00};
+
+const unsigned char Fire[] PROGMEM = {0x30, 0x00, 0xF0, 0x00, 0xF8, 0x03, 0xF8, 0x07, 0xFC, 0x1F, 0xFC,
+                                      0x1F, 0xFE, 0x3E, 0x7E, 0x3E, 0x3E, 0x7C, 0x1E, 0x78, 0x1E, 0x70,
+                                      0x1C, 0x70, 0x1C, 0x70, 0x38, 0x38, 0x30, 0x38, 0x60, 0x0C};
+
+const unsigned char peace_sign[] PROGMEM = {0xC0, 0x30, 0x40, 0x29, 0x40, 0x25, 0x40, 0x15, 0x40, 0x12, 0x38,
+                                            0x0A, 0x54, 0x68, 0x54, 0x58, 0x54, 0x44, 0x3C, 0x22, 0x04, 0x22,
+                                            0x04, 0x12, 0x08, 0x10, 0x10, 0x08, 0xE0, 0x07, 0x00, 0x00};
+
+const unsigned char Praying[] PROGMEM = {0x00, 0x00, 0x40, 0x02, 0xA0, 0x05, 0x90, 0x09, 0x90, 0x09, 0x90,
+                                         0x09, 0x98, 0x19, 0x94, 0x29, 0xA4, 0x25, 0xA4, 0x25, 0x84, 0x21,
+                                         0x84, 0x21, 0x86, 0x61, 0x4E, 0x72, 0x7F, 0x7E, 0x3F, 0xFC};
+
+const unsigned char Sparkles[] PROGMEM = {0x00, 0x00, 0x10, 0x00, 0x38, 0x04, 0x10, 0x04, 0x00, 0x0E, 0x00,
+                                          0x1F, 0x80, 0x3F, 0xE0, 0xFF, 0x80, 0x3F, 0x10, 0x1F, 0x10, 0x0E,
+                                          0x38, 0x04, 0xFE, 0x04, 0x38, 0x00, 0x10, 0x00, 0x10, 0x00};
+
+const unsigned char clown[] PROGMEM = {0x00, 0x00, 0xEE, 0x77, 0x1A, 0x58, 0x06, 0x60, 0x24, 0x24, 0x72,
+                                       0x4E, 0x22, 0x44, 0x82, 0x41, 0x82, 0x41, 0x1A, 0x58, 0xF2, 0x4F,
+                                       0x14, 0x28, 0xE4, 0x27, 0x18, 0x18, 0xE0, 0x07, 0x00, 0x00};
+
+const unsigned char robo[] PROGMEM = {0x80, 0x01, 0xC0, 0x03, 0x80, 0x01, 0xFC, 0x3F, 0x04, 0x20, 0x74,
+                                      0x2E, 0x52, 0x4A, 0x72, 0x4E, 0x02, 0x40, 0x02, 0x40, 0xA2, 0x4A,
+                                      0x52, 0x45, 0x04, 0x20, 0x04, 0x20, 0xFC, 0x3F, 0x00, 0x00};
+
+const unsigned char hole[] PROGMEM = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x0F, 0x3C, 0x3C,
+                                      0x06, 0x60, 0x0C, 0x30, 0xF0, 0x0F, 0x00, 0x00, 0x00, 0x00};
+
+const unsigned char bowling[] PROGMEM = {0x00, 0x38, 0x00, 0x44, 0x00, 0x44, 0x00, 0x44, 0x00, 0x28, 0x00,
+                                         0x38, 0x00, 0x28, 0x78, 0x44, 0x84, 0x82, 0x22, 0x83, 0x52, 0x83,
+                                         0x02, 0x83, 0x02, 0x45, 0x84, 0x44, 0x78, 0x38, 0x00, 0x00};
+
+const unsigned char vulcan_salute[] PROGMEM = {0x08, 0x02, 0x16, 0x0D, 0x15, 0x15, 0x15, 0x15, 0xA9, 0x12, 0x4A,
+                                               0x0A, 0x02, 0x38, 0x04, 0x48, 0x04, 0x44, 0x04, 0x22, 0x04, 0x22,
+                                               0x04, 0x12, 0x08, 0x10, 0x10, 0x08, 0xE0, 0x07, 0x00, 0x00};
 #endif

 } // namespace graphics
--- a/src/graphics/emotes.h
+++ b/src/graphics/emotes.h
@@ -17,98 +17,150 @@ extern const int numEmotes;

 #ifndef EXCLUDE_EMOJI
 // === Emote Bitmaps ===
-#define thumbs_height 25
-#define thumbs_width 25
+#define thumbs_height 16
+#define thumbs_width 16
 extern const unsigned char thumbup[] PROGMEM;
 extern const unsigned char thumbdown[] PROGMEM;

-#define Smiling_Eyes_height 30
-#define Smiling_Eyes_width 30
+#define Smiling_Eyes_height 16
+#define Smiling_Eyes_width 16
 extern const unsigned char Smiling_Eyes[] PROGMEM;

-#define Grinning_height 30
-#define Grinning_width 30
+#define Grinning_height 16
+#define Grinning_width 16
 extern const unsigned char Grinning[] PROGMEM;

-#define Slightly_Smiling_height 30
-#define Slightly_Smiling_width 30
+#define Slightly_Smiling_height 16
+#define Slightly_Smiling_width 16
 extern const unsigned char Slightly_Smiling[] PROGMEM;

-#define Winking_Face_height 30
-#define Winking_Face_width 30
+#define Winking_Face_height 16
+#define Winking_Face_width 16
 extern const unsigned char Winking_Face[] PROGMEM;

-#define Grinning_Smiling_Eyes_height 30
-#define Grinning_Smiling_Eyes_width 30
+#define Grinning_Smiling_Eyes_height 16
+#define Grinning_Smiling_Eyes_width 16
 extern const unsigned char Grinning_Smiling_Eyes[] PROGMEM;

-#define question_height 25
-#define question_width 25
+#define heart_smile_height 16
+#define heart_smile_width 16
+extern const unsigned char heart_smile[] PROGMEM;
+
+#define Heart_eyes_height 16
+#define Heart_eyes_width 16
+extern const unsigned char Heart_eyes[] PROGMEM;
+
+#define question_height 16
+#define question_width 16
 extern const unsigned char question[] PROGMEM;

-#define bang_height 30
-#define bang_width 30
+#define bang_height 16
+#define bang_width 16
 extern const unsigned char bang[] PROGMEM;

-#define haha_height 30
-#define haha_width 30
+#define haha_height 16
+#define haha_width 16
 extern const unsigned char haha[] PROGMEM;

-#define ROFL_height 30
-#define ROFL_width 30
+#define ROFL_height 16
+#define ROFL_width 16
 extern const unsigned char ROFL[] PROGMEM;

-#define Smiling_Closed_Eyes_height 30
-#define Smiling_Closed_Eyes_width 30
+#define Smiling_Closed_Eyes_height 16
+#define Smiling_Closed_Eyes_width 16
 extern const unsigned char Smiling_Closed_Eyes[] PROGMEM;

-#define Grinning_SmilingEyes2_height 30
-#define Grinning_SmilingEyes2_width 30
+#define Grinning_SmilingEyes2_height 16
+#define Grinning_SmilingEyes2_width 16
 extern const unsigned char Grinning_SmilingEyes2[] PROGMEM;

-#define wave_icon_height 30
-#define wave_icon_width 30
+#define Loudly_Crying_Face_height 16
+#define Loudly_Crying_Face_width 16
+extern const unsigned char Loudly_Crying_Face[] PROGMEM;
+
+#define wave_icon_height 16
+#define wave_icon_width 16
 extern const unsigned char wave_icon[] PROGMEM;

-#define cowboy_height 30
-#define cowboy_width 30
+#define cowboy_height 16
+#define cowboy_width 16
 extern const unsigned char cowboy[] PROGMEM;

-#define deadmau5_height 30
-#define deadmau5_width 60
+#define deadmau5_height 16
+#define deadmau5_width 16
 extern const unsigned char deadmau5[] PROGMEM;

-#define sun_height 30
-#define sun_width 30
+#define sun_height 16
+#define sun_width 16
 extern const unsigned char sun[] PROGMEM;

-#define rain_height 30
-#define rain_width 30
+#define rain_height 16
+#define rain_width 16
 extern const unsigned char rain[] PROGMEM;

-#define cloud_height 30
-#define cloud_width 30
+#define cloud_height 16
+#define cloud_width 16
 extern const unsigned char cloud[] PROGMEM;

-#define fog_height 25
-#define fog_width 25
+#define fog_height 16
+#define fog_width 16
 extern const unsigned char fog[] PROGMEM;

-#define devil_height 30
-#define devil_width 30
+#define devil_height 16
+#define devil_width 16
 extern const unsigned char devil[] PROGMEM;

-#define heart_height 30
-#define heart_width 30
+#define heart_height 16
+#define heart_width 16
 extern const unsigned char heart[] PROGMEM;

-#define poo_height 30
-#define poo_width 30
+#define poo_height 16
+#define poo_width 16
 extern const unsigned char poo[] PROGMEM;

-#define bell_icon_width 30
-#define bell_icon_height 30
+#define bell_icon_width 16
+#define bell_icon_height 16
 extern const unsigned char bell_icon[] PROGMEM;
+
+#define cookie_width 16
+#define cookie_height 16
+extern const unsigned char cookie[] PROGMEM;
+
+#define Fire_width 16
+#define Fire_height 16
+extern const unsigned char Fire[] PROGMEM;
+
+#define peace_sign_width 16
+#define peace_sign_height 16
+extern const unsigned char peace_sign[] PROGMEM;
+
+#define Praying_width 16
+#define Praying_height 16
+extern const unsigned char Praying[] PROGMEM;
+
+#define Sparkles_width 16
+#define Sparkles_height 16
+extern const unsigned char Sparkles[] PROGMEM;
+
+#define clown_width 16
+#define clown_height 16
+extern const unsigned char clown[] PROGMEM;
+
+#define robo_width 16
+#define robo_height 16
+extern const unsigned char robo[] PROGMEM;
+
+#define hole_width 16
+#define hole_height 16
+extern const unsigned char hole[] PROGMEM;
+
+#define bowling_width 16
+#define bowling_height 16
+extern const unsigned char bowling[] PROGMEM;
+
+#define vulcan_salute_width 16
+#define vulcan_salute_height 16
+extern const unsigned char vulcan_salute[] PROGMEM;
 #endif // EXCLUDE_EMOJI

-} // namespace graphics
+} // namespace graphics
--- a/src/graphics/niche/InkHUD/Applets/Bases/Map/MapApplet.cpp
+++ b/src/graphics/niche/InkHUD/Applets/Bases/Map/MapApplet.cpp
@@ -287,7 +287,7 @@ void InkHUD::MapApplet::getMapCenter(float *lat, float *lng)
    float easternmost = lngCenter;
    float westernmost = lngCenter;

-    for (uint8_t i = 0; i < nodeDB->getNumMeshNodes(); i++) {
+    for (size_t i = 0; i < nodeDB->getNumMeshNodes(); i++) {
        meshtastic_NodeInfoLite *node = nodeDB->getMeshNodeByIndex(i);

        // Skip if no position
@@ -474,8 +474,8 @@ void InkHUD::MapApplet::drawLabeledMarker(meshtastic_NodeInfoLite *node)
 // Need at least two, to draw a sensible map
 bool InkHUD::MapApplet::enoughMarkers()
 {
-    uint8_t count = 0;
-    for (uint8_t i = 0; i < nodeDB->getNumMeshNodes(); i++) {
+    size_t count = 0;
+    for (size_t i = 0; i < nodeDB->getNumMeshNodes(); i++) {
        meshtastic_NodeInfoLite *node = nodeDB->getMeshNodeByIndex(i);

        // Count nodes
--- a/src/input/InputBroker.cpp
+++ b/src/input/InputBroker.cpp
@@ -52,7 +52,7 @@ int InputBroker::handleInputEvent(const InputEvent *event)
    powerFSM.trigger(EVENT_INPUT); // todo: not every input should wake, like long hold release

    if (event && event->inputEvent != INPUT_BROKER_NONE && externalNotificationModule &&
-        moduleConfig.external_notification.enabled && externalNotificationModule->nagging()) {
+        moduleConfig.external_notification.enabled) {
        externalNotificationModule->stopNow();
    }

--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1401,7 +1401,7 @@ void setup()
 #endif

    // check if the radio chip matches the selected region
-    if ((config.lora.region == meshtastic_Config_LoRaConfig_RegionCode_LORA_24) && (!rIf->wideLora())) {
+    if ((config.lora.region == meshtastic_Config_LoRaConfig_RegionCode_LORA_24) && rIf && (!rIf->wideLora())) {
        LOG_WARN("LoRa chip does not support 2.4GHz. Revert to unset");
        config.lora.region = meshtastic_Config_LoRaConfig_RegionCode_UNSET;
        nodeDB->saveToDisk(SEGMENT_CONFIG);
--- a/src/mesh/Default.h
+++ b/src/mesh/Default.h
@@ -29,6 +29,7 @@
 #else
 #define default_ringtone_nag_secs 15
 #endif
+#define default_network_ipv6_enabled false

 #define default_mqtt_address "mqtt.meshtastic.org"
 #define default_mqtt_username "meshdev"
@@ -46,12 +47,15 @@ class Default
    static uint32_t getConfiguredOrDefaultMs(uint32_t configuredInterval);
    static uint32_t getConfiguredOrDefaultMs(uint32_t configuredInterval, uint32_t defaultInterval);
    static uint32_t getConfiguredOrDefault(uint32_t configured, uint32_t defaultValue);
+    // Note: numOnlineNodes uses uint32_t to match the public API and allow flexibility,
+    // even though internal node counts use uint16_t (max 65535 nodes)
    static uint32_t getConfiguredOrDefaultMsScaled(uint32_t configured, uint32_t defaultValue, uint32_t numOnlineNodes);
    static uint8_t getConfiguredOrDefaultHopLimit(uint8_t configured);
    static uint32_t getConfiguredOrMinimumValue(uint32_t configured, uint32_t minValue);

  private:
-    static float congestionScalingCoefficient(int numOnlineNodes)
+    // Note: Kept as uint32_t to match the public API parameter type
+    static float congestionScalingCoefficient(uint32_t numOnlineNodes)
    {
        // Increase frequency of broadcasts for small networks regardless of preset
        if (numOnlineNodes <= 10) {
--- a/src/mesh/NodeDB.cpp
+++ b/src/mesh/NodeDB.cpp
@@ -653,7 +653,7 @@ void NodeDB::installDefaultConfig(bool preserveKey = false)
    strncpy(config.network.ntp_server, "meshtastic.pool.ntp.org", 32);

 #if (defined(T_DECK) || defined(T_WATCH_S3) || defined(UNPHONE) || defined(PICOMPUTER_S3) || defined(SENSECAP_INDICATOR) ||      \
-     defined(ELECROW_PANEL) || defined(HELTEC_V4_TFT)) &&                                                                        \
+     defined(ELECROW_PANEL)||defined(HELTEC_V4_TFT)) &&                                                                                                  \
    HAS_TFT
    // switch BT off by default; use TFT programming mode or hotkey to enable
    config.bluetooth.enabled = false;
@@ -718,6 +718,12 @@ void NodeDB::installDefaultConfig(bool preserveKey = false)
    strncpy(config.network.wifi_psk, USERPREFS_NETWORK_WIFI_PSK, sizeof(config.network.wifi_psk));
 #endif

+#if defined(USERPREFS_NETWORK_IPV6_ENABLED)
+    config.network.ipv6_enabled = USERPREFS_NETWORK_IPV6_ENABLED;
+#else
+    config.network.ipv6_enabled = default_network_ipv6_enabled;
+#endif
+
 #ifdef DISPLAY_FLIP_SCREEN
    config.display.flip_screen = true;
 #endif
@@ -728,9 +734,6 @@ void NodeDB::installDefaultConfig(bool preserveKey = false)
    config.display.screen_on_secs = 30;
    config.display.wake_on_tap_or_motion = true;
 #endif
-#ifdef COMPASS_ORIENTATION
-    config.display.compass_orientation = COMPASS_ORIENTATION;
-#endif
 #if defined(ARCH_ESP32) && !MESHTASTIC_EXCLUDE_WIFI
    if (WiFiOTA::isUpdated()) {
        WiFiOTA::recoverConfig(&config.network);
@@ -798,15 +801,11 @@ void NodeDB::installDefaultModuleConfig()
    moduleConfig.external_notification.output_ms = 500;
    moduleConfig.external_notification.nag_timeout = 2;
 #endif
-#if defined(RAK4630) || defined(RAK11310) || defined(RAK3312) || defined(MUZI_BASE) || defined(ELECROW_ThinkNode_M3)
-    // Default to PIN_LED2 for external notification output (LED color depends on device variant)
+#if defined(RAK4630) || defined(RAK11310) || defined(RAK3312)
+    // Default to RAK led pin 2 (blue)
    moduleConfig.external_notification.enabled = true;
    moduleConfig.external_notification.output = PIN_LED2;
-#if defined(MUZI_BASE) || defined(ELECROW_ThinkNode_M3)
-    moduleConfig.external_notification.active = false;
-#else
    moduleConfig.external_notification.active = true;
-#endif
    moduleConfig.external_notification.alert_message = true;
    moduleConfig.external_notification.output_ms = 1000;
    moduleConfig.external_notification.nag_timeout = default_ringtone_nag_secs;
--- a/src/mesh/ProtobufModule.h
+++ b/src/mesh/ProtobufModule.h
@@ -13,7 +13,7 @@ template <class T> class ProtobufModule : protected SinglePortModule
    const pb_msgdesc_t *fields;

  public:
-    uint8_t numOnlineNodes = 0;
+    uint16_t numOnlineNodes = 0;
    /** Constructor
     * name is for debugging output
     */
--- a/src/mesh/generated/meshtastic/mesh.pb.h
+++ b/src/mesh/generated/meshtastic/mesh.pb.h
@@ -288,12 +288,6 @@ typedef enum _meshtastic_HardwareModel {
    meshtastic_HardwareModel_WISMESH_TAP_V2 = 116,
    /* RAK3401 */
    meshtastic_HardwareModel_RAK3401 = 117,
-    /* RAK6421 Hat+ */
-    meshtastic_HardwareModel_RAK6421 = 118,
-    /* Elecrow ThinkNode M4 */
-    meshtastic_HardwareModel_THINKNODE_M4 = 119,
-    /* Elecrow ThinkNode M6 */
-    meshtastic_HardwareModel_THINKNODE_M6 = 120,
    /* ------------------------------------------------------------------------------------------------------------------------------------------
 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.
 ------------------------------------------------------------------------------------------------------------------------------------------ */
@@ -831,11 +825,7 @@ typedef struct _meshtastic_MeshPacket {
 Note: Our crypto implementation uses this field as well.
 See [crypto](/docs/overview/encryption) for details. */
    uint32_t from;
-    /* The (immediate) destination for this packet
- If the value is 4,294,967,295 (maximum value of an unsigned 32bit integer), this indicates that the packet was
- not destined for a specific node, but for a channel as indicated by the value of `channel` below.
- If the value is another, this indicates that the packet was destined for a specific
- node (i.e. a kind of "Direct Message" to this node) and not broadcast on a channel. */
+    /* The (immediate) destination for this packet */
    uint32_t to;
    /* (Usually) If set, this indicates the index in the secondary_channels table that this packet was sent/received on.
 If unset, packet was on the primary channel.
--- a/src/mesh/wifi/WiFiAPClient.cpp
+++ b/src/mesh/wifi/WiFiAPClient.cpp
@@ -334,6 +334,23 @@ bool initWifi()
 }

 #ifdef ARCH_ESP32
+#if ESP_ARDUINO_VERSION <= ESP_ARDUINO_VERSION_VAL(3, 0, 0)
+// Most of the next 12 lines of code are adapted from espressif/arduino-esp32
+// Licensed under the GNU Lesser General Public License v2.1
+// https://github.com/espressif/arduino-esp32/blob/1f038677eb2eaf5e9ca6b6074486803c15468bed/libraries/WiFi/src/WiFiSTA.cpp#L755
+esp_netif_t *get_esp_interface_netif(esp_interface_t interface);
+IPv6Address GlobalIPv6()
+{
+    esp_ip6_addr_t addr;
+    if (WiFiGenericClass::getMode() == WIFI_MODE_NULL) {
+        return IPv6Address();
+    }
+    if (esp_netif_get_ip6_global(get_esp_interface_netif(ESP_IF_WIFI_STA), &addr)) {
+        return IPv6Address();
+    }
+    return IPv6Address(addr.addr);
+}
+#endif
 // Called by the Espressif SDK to
 static void WiFiEvent(WiFiEvent_t event)
 {
@@ -355,6 +372,17 @@ static void WiFiEvent(WiFiEvent_t event)
        break;
    case ARDUINO_EVENT_WIFI_STA_CONNECTED:
        LOG_INFO("Connected to access point");
+        if (config.network.ipv6_enabled) {
+#if ESP_ARDUINO_VERSION >= ESP_ARDUINO_VERSION_VAL(3, 0, 0)
+            if (!WiFi.enableIPv6()) {
+                LOG_WARN("Failed to enable IPv6");
+            }
+#else
+            if (!WiFi.enableIpV6()) {
+                LOG_WARN("Failed to enable IPv6");
+            }
+#endif
+        }
 #ifdef WIFI_LED
        digitalWrite(WIFI_LED, HIGH);
 #endif
@@ -383,7 +411,8 @@ static void WiFiEvent(WiFiEvent_t event)
        LOG_INFO("Obtained Local IP6 address: %s", WiFi.linkLocalIPv6().toString().c_str());
        LOG_INFO("Obtained GlobalIP6 address: %s", WiFi.globalIPv6().toString().c_str());
 #else
-        LOG_INFO("Obtained IP6 address: %s", WiFi.localIPv6().toString().c_str());
+        LOG_INFO("Obtained Local IP6 address: %s", WiFi.localIPv6().toString().c_str());
+        LOG_INFO("Obtained GlobalIP6 address: %s", GlobalIPv6().toString().c_str());
 #endif
        break;
    case ARDUINO_EVENT_WIFI_STA_LOST_IP:
@@ -514,4 +543,4 @@ uint8_t getWifiDisconnectReason()
 {
    return wifiDisconnectReason;
 }
-#endif // HAS_WIFI
+#endif // HAS_WIFI
--- a/src/modules/Modules.cpp
+++ b/src/modules/Modules.cpp
@@ -13,8 +13,6 @@
 #include "input/TrackballInterruptImpl1.h"
 #endif

-#include "modules/StatusLEDModule.h"
-
 #if !MESHTASTIC_EXCLUDE_I2C
 #include "input/cardKbI2cImpl.h"
 #endif
@@ -121,10 +119,6 @@ void setupModules()
        buzzerFeedbackThread = new BuzzerFeedbackThread();
    }
 #endif
-#if defined(LED_CHARGE) || defined(LED_PAIRING)
-    statusLEDModule = new StatusLEDModule();
-#endif
-
 #if !MESHTASTIC_EXCLUDE_ADMIN
    adminModule = new AdminModule();
 #endif
--- a/src/modules/SerialModule.cpp
+++ b/src/modules/SerialModule.cpp
@@ -64,8 +64,7 @@ SerialModule *serialModule;
 SerialModuleRadio *serialModuleRadio;

 #if defined(TTGO_T_ECHO) || defined(CANARYONE) || defined(MESHLINK) || defined(ELECROW_ThinkNode_M1) ||                          \
-    defined(ELECROW_ThinkNode_M5) || defined(HELTEC_MESH_SOLAR) || defined(T_ECHO_LITE) || defined(ELECROW_ThinkNode_M3) ||      \
-    defined(MUZI_BASE)
+    defined(ELECROW_ThinkNode_M5) || defined(HELTEC_MESH_SOLAR) || defined(T_ECHO_LITE)
 SerialModule::SerialModule() : StreamAPI(&Serial), concurrency::OSThread("Serial")
 {
    api_type = TYPE_SERIAL;
@@ -205,7 +204,7 @@ int32_t SerialModule::runOnce()
                Serial.setTimeout(moduleConfig.serial.timeout > 0 ? moduleConfig.serial.timeout : TIMEOUT);
            }
 #elif !defined(TTGO_T_ECHO) && !defined(T_ECHO_LITE) && !defined(CANARYONE) && !defined(MESHLINK) &&                             \
-    !defined(ELECROW_ThinkNode_M1) && !defined(ELECROW_ThinkNode_M3) && !defined(ELECROW_ThinkNode_M5) && !defined(MUZI_BASE)
+    !defined(ELECROW_ThinkNode_M1) && !defined(ELECROW_ThinkNode_M5)
            if (moduleConfig.serial.rxd && moduleConfig.serial.txd) {
 #ifdef ARCH_RP2040
                Serial2.setFIFOSize(RX_BUFFER);
@@ -262,7 +261,7 @@ int32_t SerialModule::runOnce()
            }

 #if !defined(TTGO_T_ECHO) && !defined(T_ECHO_LITE) && !defined(CANARYONE) && !defined(MESHLINK) &&                               \
-    !defined(ELECROW_ThinkNode_M1) && !defined(ELECROW_ThinkNode_M3) && !defined(ELECROW_ThinkNode_M5) && !defined(MUZI_BASE)
+    !defined(ELECROW_ThinkNode_M1) && !defined(ELECROW_ThinkNode_M5)
            else if ((moduleConfig.serial.mode == meshtastic_ModuleConfig_SerialConfig_Serial_Mode_WS85)) {
                processWXSerial();

@@ -537,8 +536,7 @@ ParsedLine parseLine(const char *line)
 void SerialModule::processWXSerial()
 {
 #if !defined(TTGO_T_ECHO) && !defined(T_ECHO_LITE) && !defined(CANARYONE) && !defined(CONFIG_IDF_TARGET_ESP32C6) &&              \
-    !defined(MESHLINK) && !defined(ELECROW_ThinkNode_M1) && !defined(ELECROW_ThinkNode_M3) && !defined(ELECROW_ThinkNode_M5) &&  \
-    !defined(ARCH_STM32WL) && !defined(MUZI_BASE)
+    !defined(MESHLINK) && !defined(ELECROW_ThinkNode_M1) && !defined(ELECROW_ThinkNode_M5) && !defined(ARCH_STM32WL)
    static unsigned int lastAveraged = 0;
    static unsigned int averageIntervalMillis = 300000; // 5 minutes hard coded.
    static double dir_sum_sin = 0;
--- a/src/modules/StatusLEDModule.cpp
+++ b/src/modules/StatusLEDModule.cpp
@@ -1,115 +0,0 @@
-#include "StatusLEDModule.h"
-#include "MeshService.h"
-#include "configuration.h"
-#include <Arduino.h>
-
-/*
-StatusLEDModule manages the device's status LEDs, updating their states based on power and Bluetooth status.
-It reflects charging, charged, discharging, and Bluetooth connection states using the appropriate LEDs.
-*/
-StatusLEDModule *statusLEDModule;
-
-StatusLEDModule::StatusLEDModule() : concurrency::OSThread("StatusLEDModule")
-{
-    bluetoothStatusObserver.observe(&bluetoothStatus->onNewStatus);
-    powerStatusObserver.observe(&powerStatus->onNewStatus);
-}
-
-int StatusLEDModule::handleStatusUpdate(const meshtastic::Status *arg)
-{
-    switch (arg->getStatusType()) {
-    case STATUS_TYPE_POWER: {
-        meshtastic::PowerStatus *powerStatus = (meshtastic::PowerStatus *)arg;
-        if (powerStatus->getHasUSB() || powerStatus->getIsCharging()) {
-            power_state = charging;
-            if (powerStatus->getBatteryChargePercent() >= 100) {
-                power_state = charged;
-            }
-        } else {
-            if (powerStatus->getBatteryChargePercent() > 5) {
-                power_state = discharging;
-            } else {
-                power_state = critical;
-            }
-        }
-        break;
-    }
-    case STATUS_TYPE_BLUETOOTH: {
-        meshtastic::BluetoothStatus *bluetoothStatus = (meshtastic::BluetoothStatus *)arg;
-        switch (bluetoothStatus->getConnectionState()) {
-        case meshtastic::BluetoothStatus::ConnectionState::DISCONNECTED: {
-            ble_state = unpaired;
-            PAIRING_LED_starttime = millis();
-            break;
-        }
-        case meshtastic::BluetoothStatus::ConnectionState::PAIRING: {
-            ble_state = pairing;
-            PAIRING_LED_starttime = millis();
-            break;
-        }
-        case meshtastic::BluetoothStatus::ConnectionState::CONNECTED: {
-            ble_state = connected;
-            PAIRING_LED_starttime = millis();
-            break;
-        }
-        }
-
-        break;
-    }
-    }
-    return 0;
-};
-
-int32_t StatusLEDModule::runOnce()
-{
-    my_interval = 1000;
-
-    if (power_state == charging) {
-        CHARGE_LED_state = !CHARGE_LED_state;
-    } else if (power_state == charged) {
-        CHARGE_LED_state = LED_STATE_ON;
-    } else if (power_state == critical) {
-        if (POWER_LED_starttime + 30000 < millis() && !doing_fast_blink) {
-            doing_fast_blink = true;
-            POWER_LED_starttime = millis();
-        }
-        if (doing_fast_blink) {
-            PAIRING_LED_state = LED_STATE_OFF;
-            CHARGE_LED_state = !CHARGE_LED_state;
-            my_interval = 250;
-            if (POWER_LED_starttime + 2000 < millis()) {
-                doing_fast_blink = false;
-            }
-        } else {
-            CHARGE_LED_state = LED_STATE_OFF;
-        }
-
-    } else {
-        CHARGE_LED_state = LED_STATE_OFF;
-    }
-
-    if (!config.bluetooth.enabled || PAIRING_LED_starttime + 30 * 1000 < millis() || doing_fast_blink) {
-        PAIRING_LED_state = LED_STATE_OFF;
-    } else if (ble_state == unpaired) {
-        if (slowTrack) {
-            PAIRING_LED_state = !PAIRING_LED_state;
-            slowTrack = false;
-        } else {
-            slowTrack = true;
-        }
-    } else if (ble_state == pairing) {
-        PAIRING_LED_state = !PAIRING_LED_state;
-    } else {
-        PAIRING_LED_state = LED_STATE_ON;
-    }
-
-#ifdef LED_CHARGE
-    digitalWrite(LED_CHARGE, CHARGE_LED_state);
-#endif
-    // digitalWrite(green_LED_PIN, LED_STATE_OFF);
-#ifdef LED_PAIRING
-    digitalWrite(LED_PAIRING, PAIRING_LED_state);
-#endif
-
-    return (my_interval);
-}
--- a/src/modules/StatusLEDModule.h
+++ b/src/modules/StatusLEDModule.h
@@ -1,46 +0,0 @@
-#pragma once
-
-#include "BluetoothStatus.h"
-#include "MeshModule.h"
-#include "PowerStatus.h"
-#include "concurrency/OSThread.h"
-#include "configuration.h"
-#include <Arduino.h>
-#include <functional>
-
-class StatusLEDModule : private concurrency::OSThread
-{
-    bool slowTrack = false;
-
-  public:
-    StatusLEDModule();
-
-    int handleStatusUpdate(const meshtastic::Status *);
-
-  protected:
-    unsigned int my_interval = 1000; // interval in millisconds
-    virtual int32_t runOnce() override;
-
-    CallbackObserver<StatusLEDModule, const meshtastic::Status *> bluetoothStatusObserver =
-        CallbackObserver<StatusLEDModule, const meshtastic::Status *>(this, &StatusLEDModule::handleStatusUpdate);
-    CallbackObserver<StatusLEDModule, const meshtastic::Status *> powerStatusObserver =
-        CallbackObserver<StatusLEDModule, const meshtastic::Status *>(this, &StatusLEDModule::handleStatusUpdate);
-
-  private:
-    bool CHARGE_LED_state = LED_STATE_OFF;
-    bool PAIRING_LED_state = LED_STATE_OFF;
-
-    uint32_t PAIRING_LED_starttime = 0;
-    uint32_t POWER_LED_starttime = 0;
-    bool doing_fast_blink = false;
-
-    enum PowerState { discharging, charging, charged, critical };
-
-    PowerState power_state = discharging;
-
-    enum BLEState { unpaired, pairing, connected };
-
-    BLEState ble_state = unpaired;
-};
-
-extern StatusLEDModule *statusLEDModule;
--- a/src/modules/SystemCommandsModule.cpp
+++ b/src/modules/SystemCommandsModule.cpp
@@ -85,8 +85,10 @@ int SystemCommandsModule::handleInputEvent(const InputEvent *event)
    switch (event->inputEvent) {
        // GPS
    case INPUT_BROKER_GPS_TOGGLE:
+        LOG_WARN("GPS Toggle");
 #if !MESHTASTIC_EXCLUDE_GPS
        if (gps) {
+            LOG_WARN("GPS Toggle2");
            if (config.position.gps_mode == meshtastic_Config_PositionConfig_GpsMode_ENABLED &&
                config.position.fixed_position == false) {
                nodeDB->clearLocalPosition();
--- a/src/modules/Telemetry/EnvironmentTelemetry.cpp
+++ b/src/modules/Telemetry/EnvironmentTelemetry.cpp
@@ -53,7 +53,7 @@ extern void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const c
 #include "Sensor/LTR390UVSensor.h"
 #endif

-#if __has_include(<bsec2.h>)
+#if __has_include(MESHTASTIC_BME680_HEADER)
 #include "Sensor/BME680Sensor.h"
 #endif

@@ -134,6 +134,10 @@ extern void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const c
 #include "Sensor/TSL2561Sensor.h"
 #endif

+#if __has_include(<BH1750_WE.h>)
+#include "Sensor/BH1750Sensor.h"
+#endif
+
 #define FAILED_STATE_SENSOR_READ_MULTIPLIER 10
 #define DISPLAY_RECEIVEID_MEASUREMENTS_ON_SCREEN true

@@ -210,7 +214,7 @@ void EnvironmentTelemetryModule::i2cScanFinished(ScanI2C *i2cScanner)
 #if __has_include(<Adafruit_LTR390.h>)
    addSensor<LTR390UVSensor>(i2cScanner, ScanI2C::DeviceType::LTR390UV);
 #endif
-#if __has_include(<bsec2.h>)
+#if __has_include(MESHTASTIC_BME680_HEADER)
    addSensor<BME680Sensor>(i2cScanner, ScanI2C::DeviceType::BME_680);
 #endif
 #if __has_include(<Adafruit_BMP280.h>)
@@ -262,6 +266,9 @@ void EnvironmentTelemetryModule::i2cScanFinished(ScanI2C *i2cScanner)
 #if __has_include(<SparkFun_Qwiic_Scale_NAU7802_Arduino_Library.h>)
    addSensor<NAU7802Sensor>(i2cScanner, ScanI2C::DeviceType::NAU7802);
 #endif
+#if __has_include(<BH1750_WE.h>)
+    addSensor<BH1750Sensor>(i2cScanner, ScanI2C::DeviceType::BH1750);
+#endif

 #endif
 }
--- a/src/modules/Telemetry/Sensor/AHT10.cpp
+++ b/src/modules/Telemetry/Sensor/AHT10.cpp
@@ -35,7 +35,7 @@ bool AHT10Sensor::getMetrics(meshtastic_Telemetry *measurement)
    // prefer other sensors like bmp280, bmp3xx
    if (!measurement->variant.environment_metrics.has_temperature) {
        measurement->variant.environment_metrics.has_temperature = true;
-        measurement->variant.environment_metrics.temperature = temp.temperature + AHT10_TEMP_OFFSET;
+        measurement->variant.environment_metrics.temperature = temp.temperature;
    }

    if (!measurement->variant.environment_metrics.has_relative_humidity) {
--- a/src/modules/Telemetry/Sensor/AHT10.h
+++ b/src/modules/Telemetry/Sensor/AHT10.h
@@ -6,10 +6,6 @@

 #if !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && __has_include(<Adafruit_AHTX0.h>)

-#ifndef AHT10_TEMP_OFFSET
-#define AHT10_TEMP_OFFSET 0
-#endif
-
 #include "../mesh/generated/meshtastic/telemetry.pb.h"
 #include "TelemetrySensor.h"
 #include <Adafruit_AHTX0.h>
--- a/src/modules/Telemetry/Sensor/BH1750Sensor.cpp
+++ b/src/modules/Telemetry/Sensor/BH1750Sensor.cpp
@@ -0,0 +1,54 @@
+#include "configuration.h"
+
+#if !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && __has_include(<BH1750_WE.h>)
+
+#include "../mesh/generated/meshtastic/telemetry.pb.h"
+#include "BH1750Sensor.h"
+#include "TelemetrySensor.h"
+#include <BH1750_WE.h>
+
+#ifndef BH1750_SENSOR_MODE
+#define BH1750_SENSOR_MODE BH1750Mode::CHM
+#endif
+
+BH1750Sensor::BH1750Sensor() : TelemetrySensor(meshtastic_TelemetrySensorType_BH1750, "BH1750") {}
+
+bool BH1750Sensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
+{
+    LOG_INFO("Init sensor: %s with mode %d", sensorName, BH1750_SENSOR_MODE);
+
+    bh1750 = BH1750_WE(bus, dev->address.address);
+    status = bh1750.init();
+    if (!status) {
+        return status;
+    }
+
+    bh1750.setMode(BH1750_SENSOR_MODE);
+
+    initI2CSensor();
+    return status;
+}
+
+bool BH1750Sensor::getMetrics(meshtastic_Telemetry *measurement)
+{
+
+    /* An OTH and OTH_2 measurement takes ~120 ms. I suggest to wait
+    140 ms to be on the safe side.
+    An OTL measurement takes about 16 ms. I suggest to wait 20 ms
+    to be on the safe side. */
+    if (BH1750_SENSOR_MODE == BH1750Mode::OTH || BH1750_SENSOR_MODE == BH1750Mode::OTH_2) {
+        bh1750.setMode(BH1750_SENSOR_MODE);
+        delay(140); // wait for measurement to be completed
+    } else if (BH1750_SENSOR_MODE == BH1750Mode::OTL) {
+        bh1750.setMode(BH1750_SENSOR_MODE);
+        delay(20);
+    }
+
+    measurement->variant.environment_metrics.has_lux = true;
+    float lightIntensity = bh1750.getLux();
+
+    measurement->variant.environment_metrics.lux = lightIntensity;
+    return true;
+}
+
+#endif
--- a/src/modules/Telemetry/Sensor/BH1750Sensor.h
+++ b/src/modules/Telemetry/Sensor/BH1750Sensor.h
@@ -0,0 +1,21 @@
+#pragma once
+#include "configuration.h"
+
+#if !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && __has_include(<BH1750_WE.h>)
+
+#include "../mesh/generated/meshtastic/telemetry.pb.h"
+#include "TelemetrySensor.h"
+#include <BH1750_WE.h>
+
+class BH1750Sensor : public TelemetrySensor
+{
+  private:
+    BH1750_WE bh1750;
+
+  public:
+    BH1750Sensor();
+    virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
+    virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) override;
+};
+
+#endif
--- a/src/modules/Telemetry/Sensor/BME680Sensor.cpp
+++ b/src/modules/Telemetry/Sensor/BME680Sensor.cpp
@@ -1,6 +1,6 @@
 #include "configuration.h"

-#if !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && __has_include(<bsec2.h>)
+#if !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && __has_include(MESHTASTIC_BME680_HEADER)

 #include "../mesh/generated/meshtastic/telemetry.pb.h"
 #include "BME680Sensor.h"
@@ -10,6 +10,7 @@

 BME680Sensor::BME680Sensor() : TelemetrySensor(meshtastic_TelemetrySensorType_BME680, "BME680") {}

+#if MESHTASTIC_BME680_BSEC2_SUPPORTED == 1
 int32_t BME680Sensor::runOnce()
 {
    if (!bme680.run()) {
@@ -17,10 +18,13 @@ int32_t BME680Sensor::runOnce()
    }
    return 35;
 }
+#endif // defined(MESHTASTIC_BME680_BSEC2_SUPPORTED)

 bool BME680Sensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
 {
    status = 0;
+
+#if MESHTASTIC_BME680_BSEC2_SUPPORTED == 1
    if (!bme680.begin(dev->address.address, *bus))
        checkStatus("begin");

@@ -42,12 +46,25 @@ bool BME680Sensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
    if (status == 0)
        LOG_DEBUG("BME680Sensor::runOnce: bme680.status %d", bme680.status);

+#else
+    bme680 = makeBME680(bus);
+
+    if (!bme680->begin(dev->address.address)) {
+        LOG_ERROR("Init sensor: %s failed at begin()", sensorName);
+        return status;
+    }
+
+    status = 1;
+
+#endif // MESHTASTIC_BME680_BSEC2_SUPPORTED
+
    initI2CSensor();
    return status;
 }

 bool BME680Sensor::getMetrics(meshtastic_Telemetry *measurement)
 {
+#if MESHTASTIC_BME680_BSEC2_SUPPORTED == 1
    if (bme680.getData(BSEC_OUTPUT_RAW_PRESSURE).signal == 0)
        return false;

@@ -65,9 +82,27 @@ bool BME680Sensor::getMetrics(meshtastic_Telemetry *measurement)
    // Check if we need to save state to filesystem (every STATE_SAVE_PERIOD ms)
    measurement->variant.environment_metrics.iaq = bme680.getData(BSEC_OUTPUT_IAQ).signal;
    updateState();
+#else
+    if (!bme680->performReading()) {
+        LOG_ERROR("BME680Sensor::getMetrics: performReading failed");
+        return false;
+    }
+
+    measurement->variant.environment_metrics.has_temperature = true;
+    measurement->variant.environment_metrics.has_relative_humidity = true;
+    measurement->variant.environment_metrics.has_barometric_pressure = true;
+    measurement->variant.environment_metrics.has_gas_resistance = true;
+
+    measurement->variant.environment_metrics.temperature = bme680->readTemperature();
+    measurement->variant.environment_metrics.relative_humidity = bme680->readHumidity();
+    measurement->variant.environment_metrics.barometric_pressure = bme680->readPressure() / 100.0F;
+    measurement->variant.environment_metrics.gas_resistance = bme680->readGas() / 1000.0;
+
+#endif // MESHTASTIC_BME680_BSEC2_SUPPORTED
    return true;
 }

+#if MESHTASTIC_BME680_BSEC2_SUPPORTED == 1
 void BME680Sensor::loadState()
 {
 #ifdef FSCom
@@ -144,5 +179,6 @@ void BME680Sensor::checkStatus(const char *functionName)
    else if (bme680.sensor.status > BME68X_OK)
        LOG_WARN("%s BME68X code: %d", functionName, bme680.sensor.status);
 }
+#endif // MESHTASTIC_BME680_BSEC2_SUPPORTED

 #endif
--- a/src/modules/Telemetry/Sensor/BME680Sensor.h
+++ b/src/modules/Telemetry/Sensor/BME680Sensor.h
@@ -1,23 +1,40 @@
 #include "configuration.h"

-#if !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && __has_include(<bsec2.h>)
+#if !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && __has_include(MESHTASTIC_BME680_HEADER)

 #include "../mesh/generated/meshtastic/telemetry.pb.h"
 #include "TelemetrySensor.h"
+
+#if MESHTASTIC_BME680_BSEC2_SUPPORTED == 1
+#include <bme68xLibrary.h>
 #include <bsec2.h>
+#else
+#include <Adafruit_BME680.h>
+#include <memory>
+#endif // MESHTASTIC_BME680_BSEC2_SUPPORTED

 #define STATE_SAVE_PERIOD UINT32_C(360 * 60 * 1000) // That's 6 hours worth of millis()

+#if MESHTASTIC_BME680_BSEC2_SUPPORTED == 1
 const uint8_t bsec_config[] = {
 #include "config/bme680/bme680_iaq_33v_3s_4d/bsec_iaq.txt"
 };
-
+#endif // MESHTASTIC_BME680_BSEC2_SUPPORTED
 class BME680Sensor : public TelemetrySensor
 {
  private:
+#if MESHTASTIC_BME680_BSEC2_SUPPORTED == 1
    Bsec2 bme680;
+#else
+    using BME680Ptr = std::unique_ptr<Adafruit_BME680>;
+
+    static BME680Ptr makeBME680(TwoWire *bus) { return std::make_unique<Adafruit_BME680>(bus); }
+
+    BME680Ptr bme680;
+#endif // MESHTASTIC_BME680_BSEC2_SUPPORTED

  protected:
+#if MESHTASTIC_BME680_BSEC2_SUPPORTED == 1
    const char *bsecConfigFileName = "/prefs/bsec.dat";
    uint8_t bsecState[BSEC_MAX_STATE_BLOB_SIZE] = {0};
    uint8_t accuracy = 0;
@@ -34,10 +51,13 @@ class BME680Sensor : public TelemetrySensor
    void loadState();
    void updateState();
    void checkStatus(const char *functionName);
+#endif // MESHTASTIC_BME680_BSEC2_SUPPORTED

  public:
    BME680Sensor();
+#if MESHTASTIC_BME680_BSEC2_SUPPORTED == 1
    virtual int32_t runOnce() override;
+#endif // MESHTASTIC_BME680_BSEC2_SUPPORTED
    virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
    virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) override;
 };
--- a/src/modules/TraceRouteModule.cpp
+++ b/src/modules/TraceRouteModule.cpp
@@ -11,113 +11,6 @@ extern graphics::Screen *screen;

 TraceRouteModule *traceRouteModule;

-void TraceRouteModule::setResultText(const String &text)
-{
-    resultText = text;
-    resultLines.clear();
-    resultLinesDirty = true;
-}
-
-void TraceRouteModule::clearResultLines()
-{
-    resultLines.clear();
-    resultLinesDirty = false;
-}
-#if HAS_SCREEN
-void TraceRouteModule::rebuildResultLines(OLEDDisplay *display)
-{
-    if (!display) {
-        resultLinesDirty = false;
-        return;
-    }
-
-    resultLines.clear();
-
-    if (resultText.length() == 0) {
-        resultLinesDirty = false;
-        return;
-    }
-
-    int maxWidth = display->getWidth() - 4;
-    if (maxWidth <= 0) {
-        resultLinesDirty = false;
-        return;
-    }
-
-    int start = 0;
-    int textLength = resultText.length();
-
-    while (start <= textLength) {
-        int newlinePos = resultText.indexOf('\n', start);
-        String segment;
-
-        if (newlinePos != -1) {
-            segment = resultText.substring(start, newlinePos);
-            start = newlinePos + 1;
-        } else {
-            segment = resultText.substring(start);
-            start = textLength + 1;
-        }
-
-        if (segment.length() == 0) {
-            resultLines.push_back("");
-            continue;
-        }
-
-        if (display->getStringWidth(segment) <= maxWidth) {
-            resultLines.push_back(segment);
-            continue;
-        }
-
-        String remaining = segment;
-
-        while (remaining.length() > 0) {
-            String tempLine = "";
-            int lastGoodBreak = -1;
-            bool lineComplete = false;
-
-            for (int i = 0; i < static_cast<int>(remaining.length()); i++) {
-                char ch = remaining.charAt(i);
-                String testLine = tempLine + ch;
-
-                if (display->getStringWidth(testLine) > maxWidth) {
-                    if (lastGoodBreak >= 0) {
-                        resultLines.push_back(remaining.substring(0, lastGoodBreak + 1));
-                        remaining = remaining.substring(lastGoodBreak + 1);
-                        lineComplete = true;
-                        break;
-                    } else if (tempLine.length() > 0) {
-                        resultLines.push_back(tempLine);
-                        remaining = remaining.substring(i);
-                        lineComplete = true;
-                        break;
-                    } else {
-                        resultLines.push_back(String(ch));
-                        remaining = remaining.substring(i + 1);
-                        lineComplete = true;
-                        break;
-                    }
-                } else {
-                    tempLine = testLine;
-                    if (ch == ' ' || ch == '>' || ch == '<' || ch == '-' || ch == '(' || ch == ')' || ch == ',') {
-                        lastGoodBreak = i;
-                    }
-                }
-            }
-
-            if (!lineComplete) {
-                if (tempLine.length() > 0) {
-                    resultLines.push_back(tempLine);
-                }
-                break;
-            }
-        }
-    }
-
-    resultLinesDirty = false;
-}
-#endif
-
 bool TraceRouteModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshtastic_RouteDiscovery *r)
 {
    // We only alter the packet in alterReceivedProtobuf()
@@ -513,7 +406,7 @@ bool TraceRouteModule::startTraceRoute(NodeNum node)
    if (node == 0 || node == NODENUM_BROADCAST) {
        LOG_ERROR("Invalid node number for trace route: 0x%08x", node);
        runState = TRACEROUTE_STATE_RESULT;
-        setResultText("Invalid node");
+        resultText = "Invalid node";
        resultShowTime = millis();
        tracingNode = 0;

@@ -527,7 +420,7 @@ bool TraceRouteModule::startTraceRoute(NodeNum node)
    if (node == nodeDB->getNodeNum()) {
        LOG_ERROR("Cannot trace route to self: 0x%08x", node);
        runState = TRACEROUTE_STATE_RESULT;
-        setResultText("Cannot trace self");
+        resultText = "Cannot trace self";
        resultShowTime = millis();
        tracingNode = 0;

@@ -554,8 +447,6 @@ bool TraceRouteModule::startTraceRoute(NodeNum node)
        unsigned long wait = (cooldownMs - (now - lastTraceRouteTime)) / 1000;
        bannerText = String("Wait for ") + String(wait) + String("s");
        runState = TRACEROUTE_STATE_COOLDOWN;
-        resultText = "";
-        clearResultLines();

        requestFocus();
        UIFrameEvent e;
@@ -568,8 +459,6 @@ bool TraceRouteModule::startTraceRoute(NodeNum node)
    tracingNode = node;
    lastTraceRouteTime = now;
    runState = TRACEROUTE_STATE_TRACKING;
-    resultText = "";
-    clearResultLines();
    bannerText = String("Tracing ") + getNodeName(node);

    LOG_INFO("TraceRoute UI: Starting trace route to node 0x%08x, requesting focus", node);
@@ -612,7 +501,7 @@ bool TraceRouteModule::startTraceRoute(NodeNum node)
        } else {
            LOG_ERROR("MeshService is NULL!");
            runState = TRACEROUTE_STATE_RESULT;
-            setResultText("Service unavailable");
+            resultText = "Service unavailable";
            resultShowTime = millis();
            tracingNode = 0;

@@ -625,7 +514,7 @@ bool TraceRouteModule::startTraceRoute(NodeNum node)
    } else {
        LOG_ERROR("Failed to allocate TraceRoute packet from router");
        runState = TRACEROUTE_STATE_RESULT;
-        setResultText("Failed to send");
+        resultText = "Failed to send";
        resultShowTime = millis();
        tracingNode = 0;

@@ -643,7 +532,7 @@ void TraceRouteModule::launch(NodeNum node)
    if (node == 0 || node == NODENUM_BROADCAST) {
        LOG_ERROR("Invalid node number for trace route: 0x%08x", node);
        runState = TRACEROUTE_STATE_RESULT;
-        setResultText("Invalid node");
+        resultText = "Invalid node";
        resultShowTime = millis();
        tracingNode = 0;

@@ -657,7 +546,7 @@ void TraceRouteModule::launch(NodeNum node)
    if (node == nodeDB->getNodeNum()) {
        LOG_ERROR("Cannot trace route to self: 0x%08x", node);
        runState = TRACEROUTE_STATE_RESULT;
-        setResultText("Cannot trace self");
+        resultText = "Cannot trace self";
        resultShowTime = millis();
        tracingNode = 0;

@@ -679,8 +568,6 @@ void TraceRouteModule::launch(NodeNum node)
        unsigned long wait = (cooldownMs - (now - lastTraceRouteTime)) / 1000;
        bannerText = String("Wait for ") + String(wait) + String("s");
        runState = TRACEROUTE_STATE_COOLDOWN;
-        resultText = "";
-        clearResultLines();

        requestFocus();
        UIFrameEvent e;
@@ -693,8 +580,6 @@ void TraceRouteModule::launch(NodeNum node)
    runState = TRACEROUTE_STATE_TRACKING;
    tracingNode = node;
    lastTraceRouteTime = now;
-    resultText = "";
-    clearResultLines();
    bannerText = String("Tracing ") + getNodeName(node);

    requestFocus();
@@ -729,14 +614,14 @@ void TraceRouteModule::launch(NodeNum node)
        } else {
            LOG_ERROR("MeshService is NULL!");
            runState = TRACEROUTE_STATE_RESULT;
-            setResultText("Service unavailable");
+            resultText = "Service unavailable";
            resultShowTime = millis();
            tracingNode = 0;
        }
    } else {
        LOG_ERROR("Failed to allocate TraceRoute packet from router");
        runState = TRACEROUTE_STATE_RESULT;
-        setResultText("Failed to send");
+        resultText = "Failed to send";
        resultShowTime = millis();
        tracingNode = 0;
    }
@@ -744,7 +629,7 @@ void TraceRouteModule::launch(NodeNum node)

 void TraceRouteModule::handleTraceRouteResult(const String &result)
 {
-    setResultText(result);
+    resultText = result;
    runState = TRACEROUTE_STATE_RESULT;
    resultShowTime = millis();
    tracingNode = 0;
@@ -794,15 +679,83 @@ void TraceRouteModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state
        display->setFont(FONT_SMALL);

        if (resultText.length() > 0) {
-            if (resultLinesDirty) {
-                rebuildResultLines(display);
+            std::vector<String> lines;
+            String currentLine = "";
+            int maxWidth = display->getWidth() - 4;
+
+            int start = 0;
+            int newlinePos = resultText.indexOf('\n', start);
+
+            while (newlinePos != -1 || start < static_cast<int>(resultText.length())) {
+                String segment;
+                if (newlinePos != -1) {
+                    segment = resultText.substring(start, newlinePos);
+                    start = newlinePos + 1;
+                    newlinePos = resultText.indexOf('\n', start);
+                } else {
+                    segment = resultText.substring(start);
+                    start = resultText.length();
+                }
+
+                if (display->getStringWidth(segment) <= maxWidth) {
+                    lines.push_back(segment);
+                } else {
+                    // Try to break at better positions (space, >, <, -)
+                    String remaining = segment;
+
+                    while (remaining.length() > 0) {
+                        String tempLine = "";
+                        int lastGoodBreak = -1;
+                        bool lineComplete = false;
+
+                        for (int i = 0; i < static_cast<int>(remaining.length()); i++) {
+                            char ch = remaining.charAt(i);
+                            String testLine = tempLine + ch;
+
+                            if (display->getStringWidth(testLine) > maxWidth) {
+                                if (lastGoodBreak >= 0) {
+                                    // Break at the last good position
+                                    lines.push_back(remaining.substring(0, lastGoodBreak + 1));
+                                    remaining = remaining.substring(lastGoodBreak + 1);
+                                    lineComplete = true;
+                                    break;
+                                } else if (tempLine.length() > 0) {
+                                    lines.push_back(tempLine);
+                                    remaining = remaining.substring(i);
+                                    lineComplete = true;
+                                    break;
+                                } else {
+                                    // Single character exceeds width
+                                    lines.push_back(String(ch));
+                                    remaining = remaining.substring(i + 1);
+                                    lineComplete = true;
+                                    break;
+                                }
+                            } else {
+                                tempLine = testLine;
+                                // Mark good break positions
+                                if (ch == ' ' || ch == '>' || ch == '<' || ch == '-' || ch == '(' || ch == ')') {
+                                    lastGoodBreak = i;
+                                }
+                            }
+                        }
+
+                        if (!lineComplete) {
+                            // Reached end of remaining text
+                            if (tempLine.length() > 0) {
+                                lines.push_back(tempLine);
+                            }
+                            break;
+                        }
+                    }
+                }
            }

            int lineHeight = FONT_HEIGHT_SMALL + 1; // Use proper font height with 1px spacing
-            for (size_t i = 0; i < resultLines.size(); i++) {
+            for (size_t i = 0; i < lines.size(); i++) {
                int lineY = contentStartY + (i * lineHeight);
                if (lineY + FONT_HEIGHT_SMALL <= display->getHeight()) {
-                    display->drawString(x + 2, lineY, resultLines[i]);
+                    display->drawString(x + 2, lineY, lines[i]);
                }
            }
        }
@@ -826,7 +779,7 @@ int32_t TraceRouteModule::runOnce()
    if (runState == TRACEROUTE_STATE_TRACKING && now - lastTraceRouteTime > trackingTimeoutMs) {
        LOG_INFO("TraceRoute timeout, no response received");
        runState = TRACEROUTE_STATE_RESULT;
-        setResultText("No response received");
+        resultText = "No response received";
        resultShowTime = now;
        tracingNode = 0;

@@ -862,8 +815,6 @@ int32_t TraceRouteModule::runOnce()
            // Cooldown finished
            LOG_INFO("TraceRoute cooldown finished, returning to IDLE");
            runState = TRACEROUTE_STATE_IDLE;
-            resultText = "";
-            clearResultLines();
            bannerText = "";
            UIFrameEvent e;
            e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;
@@ -877,7 +828,6 @@ int32_t TraceRouteModule::runOnce()
            LOG_INFO("TraceRoute result display timeout, returning to IDLE");
            runState = TRACEROUTE_STATE_IDLE;
            resultText = "";
-            clearResultLines();
            bannerText = "";
            tracingNode = 0;
            UIFrameEvent e;
--- a/src/modules/TraceRouteModule.h
+++ b/src/modules/TraceRouteModule.h
@@ -7,7 +7,6 @@
 #if HAS_SCREEN
 #include "OLEDDisplayUi.h"
 #endif
-#include <vector>

 #define ROUTE_SIZE sizeof(((meshtastic_RouteDiscovery *)0)->route) / sizeof(((meshtastic_RouteDiscovery *)0)->route[0])

@@ -50,11 +49,6 @@ class TraceRouteModule : public ProtobufModule<meshtastic_RouteDiscovery>,
    virtual int32_t runOnce() override;

  private:
-    void setResultText(const String &text);
-    void clearResultLines();
-#if HAS_SCREEN
-    void rebuildResultLines(OLEDDisplay *display);
-#endif
    // Call to add unknown hops (e.g. when a node couldn't decrypt it) to the route based on hopStart and current hopLimit
    void insertUnknownHops(meshtastic_MeshPacket &p, meshtastic_RouteDiscovery *r, bool isTowardsDestination);

@@ -80,8 +74,6 @@ class TraceRouteModule : public ProtobufModule<meshtastic_RouteDiscovery>,
    unsigned long trackingTimeoutMs = 10000;
    String bannerText;
    String resultText;
-    std::vector<String> resultLines;
-    bool resultLinesDirty = false;
    NodeNum tracingNode = 0;
    bool initialized = false;
 };
--- a/src/motion/BMX160Sensor.cpp
+++ b/src/motion/BMX160Sensor.cpp
@@ -116,7 +116,6 @@ void BMX160Sensor::calibrate(uint16_t forSeconds)
 {
 #if !defined(MESHTASTIC_EXCLUDE_SCREEN)
    LOG_DEBUG("BMX160 calibration started for %is", forSeconds);
-    highestX = 0, lowestX = 0, highestY = 0, lowestY = 0, highestZ = 0, lowestZ = 0;

    doCalibration = true;
    uint16_t calibrateFor = forSeconds * 1000; // calibrate for seconds provided
@@ -128,4 +127,4 @@ void BMX160Sensor::calibrate(uint16_t forSeconds)

 #endif

-#endif
+#endif
--- a/src/motion/ICM20948Sensor.cpp
+++ b/src/motion/ICM20948Sensor.cpp
@@ -47,21 +47,6 @@ int32_t ICM20948Sensor::runOnce()
 int32_t ICM20948Sensor::runOnce()
 {
 #if !defined(MESHTASTIC_EXCLUDE_SCREEN) && HAS_SCREEN
-#if defined(MUZI_BASE) // temporarily gated to single device due to feature freeze
-    if (screen && !screen->isScreenOn() && !config.display.wake_on_tap_or_motion && !config.device.double_tap_as_button_press) {
-        if (!isAsleep) {
-            LOG_DEBUG("sleeping IMU");
-            sensor->sleep(true);
-            isAsleep = true;
-        }
-        return MOTION_SENSOR_CHECK_INTERVAL_MS;
-    }
-    if (isAsleep) {
-        sensor->sleep(false);
-        isAsleep = false;
-    }
-#endif
-
    float magX = 0, magY = 0, magZ = 0;
    if (sensor->dataReady()) {
        sensor->getAGMT();
@@ -171,20 +156,7 @@ int32_t ICM20948Sensor::runOnce()
 void ICM20948Sensor::calibrate(uint16_t forSeconds)
 {
 #if !defined(MESHTASTIC_EXCLUDE_SCREEN) && HAS_SCREEN
-    LOG_DEBUG("Old calibration data: highestX = %f, lowestX = %f, highestY = %f, lowestY = %f, highestZ = %f, lowestZ = %f",
-              highestX, lowestX, highestY, lowestY, highestZ, lowestZ);
-    LOG_DEBUG("Compass calibration started for %is", forSeconds);
-    if (sensor->dataReady()) {
-        sensor->getAGMT();
-        highestX = sensor->agmt.mag.axes.x;
-        lowestX = sensor->agmt.mag.axes.x;
-        highestY = sensor->agmt.mag.axes.y;
-        lowestY = sensor->agmt.mag.axes.y;
-        highestZ = sensor->agmt.mag.axes.z;
-        lowestZ = sensor->agmt.mag.axes.z;
-    } else {
-        highestX = 0, lowestX = 0, highestY = 0, lowestY = 0, highestZ = 0, lowestZ = 0;
-    }
+    LOG_DEBUG("BMX160 calibration started for %is", forSeconds);

    doCalibration = true;
    uint16_t calibrateFor = forSeconds * 1000; // calibrate for seconds provided
@@ -323,4 +295,4 @@ bool ICM20948Singleton::setWakeOnMotion()
    return true;
 }

-#endif
+#endif
--- a/src/motion/ICM20948Sensor.h
+++ b/src/motion/ICM20948Sensor.h
@@ -82,13 +82,7 @@ class ICM20948Sensor : public MotionSensor
  private:
    ICM20948Singleton *sensor = nullptr;
    bool showingScreen = false;
-#ifdef MUZI_BASE
-    bool isAsleep = false;
-    float highestX = 449.000000, lowestX = -140.000000, highestY = 422.000000, lowestY = -232.000000, highestZ = 749.000000,
-          lowestZ = 98.000000;
-#else
    float highestX = 0, lowestX = 0, highestY = 0, lowestY = 0, highestZ = 0, lowestZ = 0;
-#endif

  public:
    explicit ICM20948Sensor(ScanI2C::FoundDevice foundDevice);
--- a/src/mqtt/MQTT.cpp
+++ b/src/mqtt/MQTT.cpp
@@ -51,7 +51,6 @@ constexpr int reconnectMax = 5;
 static uint8_t bytes[meshtastic_MqttClientProxyMessage_size + 30]; // 12 for channel name and 16 for nodeid

 static bool isMqttServerAddressPrivate = false;
-static bool isConnected = false;

 inline void onReceiveProto(char *topic, byte *payload, size_t length)
 {
@@ -321,10 +320,8 @@ bool connectPubSub(const PubSubConfig &config, PubSubClient &pubSub, Client &cli
    std::string nodeId = nodeDB->getNodeId();
    const bool connected = pubSub.connect(nodeId.c_str(), config.mqttUsername, config.mqttPassword);
    if (connected) {
-        isConnected = true;
        LOG_INFO("MQTT connected");
    } else {
-        isConnected = false;
        LOG_WARN("Failed to connect to MQTT server");
    }
    return connected;
@@ -510,7 +507,6 @@ bool MQTT::publish(const char *topic, const uint8_t *payload, size_t length, boo

 void MQTT::reconnect()
 {
-    isConnected = false;
    if (wantsLink()) {
        if (moduleConfig.mqtt.proxy_to_client_enabled) {
            LOG_INFO("MQTT connect via client proxy instead");
@@ -538,7 +534,7 @@ void MQTT::reconnect()
            runASAP = true;
            reconnectCount = 0;
            isMqttServerAddressPrivate = isPrivateIpAddress(clientConnection->remoteIP());
-            isConnected = true;
+
            publishNodeInfo();
            sendSubscriptions();
        } else {
@@ -692,10 +688,7 @@ void MQTT::publishNodeInfo()
 }
 void MQTT::publishQueuedMessages()
 {
-    if (mqttQueue.isEmpty() || !isConnected)
-        return;
-
-    if (!moduleConfig.mqtt.proxy_to_client_enabled && !isConnected)
+    if (mqttQueue.isEmpty())
        return;

    LOG_DEBUG("Publish enqueued MQTT message");
@@ -902,4 +895,4 @@ void MQTT::perhapsReportToMap()

    // Update the last report time
    last_report_to_map = millis();
-}
+}
--- a/src/nimble/NimbleBluetooth.cpp
+++ b/src/nimble/NimbleBluetooth.cpp
@@ -20,14 +20,13 @@
 #include "PowerStatus.h"
 #endif

+#if defined(CONFIG_IDF_TARGET_ESP32S3) || defined(CONFIG_IDF_TARGET_ESP32C6)
 #if defined(CONFIG_NIMBLE_CPP_IDF)
 #include "host/ble_gap.h"
 #else
 #include "nimble/nimble/host/include/host/ble_gap.h"
 #endif

-#if defined(CONFIG_IDF_TARGET_ESP32S3) || defined(CONFIG_IDF_TARGET_ESP32C6)
-
 namespace
 {
 constexpr uint16_t kPreferredBleMtu = 517;
@@ -777,35 +776,16 @@ bool NimbleBluetooth::isConnected()

 int NimbleBluetooth::getRssi()
 {
-#if defined(CONFIG_IDF_TARGET_ESP32S3) || defined(CONFIG_IDF_TARGET_ESP32C6)
-    if (!bleServer || !isConnected()) {
-        return 0; // No active BLE connection
-    }
-
-    uint16_t connHandle = nimbleBluetoothConnHandle.load();
-
-    if (connHandle == BLE_HS_CONN_HANDLE_NONE) {
-        const auto peers = bleServer->getPeerDevices();
-        if (!peers.empty()) {
-            connHandle = peers.front();
-            nimbleBluetoothConnHandle = connHandle;
-        }
-    }
-
-    if (connHandle == BLE_HS_CONN_HANDLE_NONE) {
-        return 0; // Connection handle not available yet
-    }
-
-    int8_t rssi = 0;
-    const int rc = ble_gap_conn_rssi(connHandle, &rssi);
-
-    if (rc == 0) {
-        return rssi;
-    }
-    LOG_DEBUG("BLE RSSI read failed, rc=%d", rc);
+    if (bleServer && isConnected()) {
+        auto service = bleServer->getServiceByUUID(MESH_SERVICE_UUID);
+        uint16_t handle = service->getHandle();
+#ifdef NIMBLE_TWO
+        return NimBLEDevice::getClientByHandle(handle)->getRssi();
+#else
+        return NimBLEDevice::getClientByID(handle)->getRssi();
 #endif
-
-    return 0;
+    }
+    return 0; // FIXME figure out where to source this
 }

 void NimbleBluetooth::setup()
--- a/src/platform/nrf52/architecture.h
+++ b/src/platform/nrf52/architecture.h
@@ -68,10 +68,6 @@
 #define HW_VENDOR meshtastic_HardwareModel_T_ECHO_LITE
 #elif defined(ELECROW_ThinkNode_M1)
 #define HW_VENDOR meshtastic_HardwareModel_THINKNODE_M1
-#elif defined(ELECROW_ThinkNode_M3)
-#define HW_VENDOR meshtastic_HardwareModel_THINKNODE_M3
-#elif defined(ELECROW_ThinkNode_M6)
-#define HW_VENDOR meshtastic_HardwareModel_THINKNODE_M6
 #elif defined(NANO_G2_ULTRA)
 #define HW_VENDOR meshtastic_HardwareModel_NANO_G2_ULTRA
 #elif defined(CANARYONE)
@@ -108,8 +104,6 @@
 #define HW_VENDOR meshtastic_HardwareModel_SEEED_WIO_TRACKER_L1
 #elif defined(HELTEC_MESH_SOLAR)
 #define HW_VENDOR meshtastic_HardwareModel_HELTEC_MESH_SOLAR
-#elif defined(MUZI_BASE)
-#define HW_VENDOR meshtastic_HardwareModel_RESERVED_FRIED_CHICKEN
 #else
 #define HW_VENDOR meshtastic_HardwareModel_NRF52_UNKNOWN
 #endif
@@ -134,9 +128,7 @@

 #endif

-#ifdef PIN_LED1
 #define LED_PIN PIN_LED1 // LED1 on nrf52840-DK
-#endif

 #ifdef PIN_BUTTON1
 #define BUTTON_PIN PIN_BUTTON1
--- a/src/platform/nrf52/main-nrf52.cpp
+++ b/src/platform/nrf52/main-nrf52.cpp
@@ -19,11 +19,6 @@
 #include "BQ25713.h"
 #endif

-// Weak empty variant initialization function.
-// May be redefined by variant files.
-void variant_shutdown() __attribute__((weak));
-void variant_shutdown() {}
-
 static inline void debugger_break(void)
 {
    __asm volatile("bkpt #0x01\n\t"
@@ -357,7 +352,6 @@ void cpuDeepSleep(uint32_t msecToWake)
        NRF_GPIO->DIRCLR = (1 << pin);
    }
 #endif
-    variant_shutdown();

    // Sleepy trackers or sensors can low power "sleep"
    // Don't enter this if we're sleeping portMAX_DELAY, since that's a shutdown event
--- a/src/platform/portduino/PortduinoGlue.cpp
+++ b/src/platform/portduino/PortduinoGlue.cpp
@@ -37,6 +37,8 @@ bool yamlOnly = false;

 const char *argp_program_version = optstr(APP_VERSION);

+char stdoutBuffer[512];
+
 // FIXME - move setBluetoothEnable into a HALPlatform class
 void setBluetoothEnable(bool enable)
 {
@@ -154,6 +156,9 @@ void portduinoSetup()
    std::string gpioChipName = "gpiochip";
    portduino_config.displayPanel = no_screen;

+    // Force stdout to be line buffered
+    setvbuf(stdout, stdoutBuffer, _IOLBF, sizeof(stdoutBuffer));
+
    if (portduino_config.force_simradio == true) {
        portduino_config.lora_module = use_simradio;
    } else if (configPath != nullptr) {
@@ -243,7 +248,7 @@ void portduinoSetup()
        //      RAK6421-13300-S1:aabbcc123456:5ba85807d92138b7519cfb60460573af:3061e8d8
        // <model string>:mac address :<16 random unique bytes in hexidecimal> : crc32
        // crc32 is calculated on the eeprom string up to but not including the final colon
-        if (strlen(autoconf_product) < 6 && portduino_config.i2cdev != "") {
+        if (strlen(autoconf_product) < 6) {
            try {
                char *mac_start = nullptr;
                char *devID_start = nullptr;
@@ -774,4 +779,4 @@ void readGPIOFromYaml(YAML::Node sourceNode, pinMapping &destPin, int pinDefault
        destPin.line = destPin.pin;
        destPin.gpiochip = portduino_config.lora_default_gpiochip;
    }
-}
+}
--- a/src/platform/stm32wl/main-stm32wl.cpp
+++ b/src/platform/stm32wl/main-stm32wl.cpp
@@ -26,3 +26,31 @@ void getMacAddr(uint8_t *dmac)
 }

 void cpuDeepSleep(uint32_t msecToWake) {}
+
+// Hacks to force more code and data out.
+
+// By default __assert_func uses fiprintf which pulls in stdio.
+extern "C" void __wrap___assert_func(const char *, int, const char *, const char *)
+{
+    while (true)
+        ;
+    return;
+}
+
+// By default strerror has a lot of strings we probably don't use. Make it return an empty string instead.
+char empty = 0;
+extern "C" char *__wrap_strerror(int)
+{
+    return &empty;
+}
+
+#ifdef MESHTASTIC_EXCLUDE_TZ
+struct _reent;
+
+// Even if you don't use timezones, mktime will try to set the timezone anyway with _tzset_unlocked(), which pulls in scanf and
+// friends. The timezone is initialized to UTC by default.
+extern "C" void __wrap__tzset_unlocked_r(struct _reent *reent_ptr)
+{
+    return;
+}
+#endif
--- a/src/power.h
+++ b/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
--- a/userPrefs.jsonc
+++ b/userPrefs.jsonc
@@ -56,5 +56,6 @@
  // "USERPREFS_MQTT_ROOT_TOPIC": "event/REPLACEME",
  // "USERPREFS_RINGTONE_NAG_SECS": "60",
  "USERPREFS_RINGTONE_RTTTL": "24:d=32,o=5,b=565:f6,p,f6,4p,p,f6,p,f6,2p,p,b6,p,b6,p,b6,p,b6,p,b,p,b,p,b,p,b,p,b,p,b,p,b,p,b,1p.,2p.,p",
+  // "USERPREFS_NETWORK_IPV6_ENABLED": "1",
  "USERPREFS_TZ_STRING": "tzplaceholder                                         "
 }
--- a/variants/esp32s3/tbeam-s3-core/rfswitch.h
+++ b/variants/esp32s3/tbeam-s3-core/rfswitch.h
@@ -8,4 +8,4 @@ static const Module::RfSwitchMode_t rfswitch_table[] = {
    {LR11x0::MODE_TX, {LOW, 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,
-};
+};
--- a/variants/esp32s3/tbeam-s3-core/variant.h
+++ b/variants/esp32s3/tbeam-s3-core/variant.h
@@ -15,6 +15,7 @@
 // not found then probe for SX1262
 #define USE_SX1262
 #define USE_SX1268
+#define USE_LR1121

 #define LORA_DIO0 -1 // a No connect on the SX1262 module
 #define LORA_RESET 5
@@ -34,6 +35,19 @@
 // code)
 #endif

+// LR1121
+#ifdef USE_LR1121
+#define LR1121_IRQ_PIN 1
+#define LR1121_NRESET_PIN LORA_RESET
+#define LR1121_BUSY_PIN 4
+#define LR1121_SPI_NSS_PIN 10
+#define LR1121_SPI_SCK_PIN 12
+#define LR1121_SPI_MOSI_PIN 11
+#define LR1121_SPI_MISO_PIN 13
+#define LR11X0_DIO3_TCXO_VOLTAGE 3.0
+#define LR11X0_DIO_AS_RF_SWITCH
+#endif
+
 // Leave undefined to disable our PMU IRQ handler.  DO NOT ENABLE THIS because the pmuirq can cause sperious interrupts
 // and waking from light sleep
 // #define PMU_IRQ 40
@@ -64,4 +78,4 @@
 // has 32768 Hz crystal
 #define HAS_32768HZ 1

-#define USE_SH1106
+#define USE_SH1106
--- a/variants/nrf52840/ELECROW-ThinkNode-M3/platformio.ini
+++ b/variants/nrf52840/ELECROW-ThinkNode-M3/platformio.ini
@@ -1,17 +0,0 @@
-[env:thinknode_m3]
-extends = nrf52840_base
-board = ThinkNode-M3
-board_check = true
-debug_tool = jlink
-build_flags = 
-  ${nrf52840_base.build_flags} 
-  -Ivariants/nrf52840/ELECROW-ThinkNode-M3
-  -DELECROW_ThinkNode_M3
-  -DGPS_POWER_TOGGLE
-  -D CONFIG_NFCT_PINS_AS_GPIOS=1
-  -L "${platformio.libdeps_dir}/${this.__env__}/bsec2/src/cortex-m4/fpv4-sp-d16-hard"
-build_src_filter = ${nrf52_base.build_src_filter} +<../variants/nrf52840/ELECROW-ThinkNode-M3>
-lib_deps = 
-  ${nrf52840_base.lib_deps}
-  khoih-prog/nRF52_PWM@^1.0.1
-  lewisxhe/PCF8563_Library@^1.0.1
--- a/variants/nrf52840/ELECROW-ThinkNode-M3/rfswitch.h
+++ b/variants/nrf52840/ELECROW-ThinkNode-M3/rfswitch.h
@@ -1,15 +0,0 @@
-#include "RadioLib.h"
-#include "nrf.h"
-
-// set RF switch configuration for ELECROW ThinkNode M3
-// ELECROW ThinkNode M3 uses DIO5 and DIO6 for RF switching
-
-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,
-};
--- a/variants/nrf52840/ELECROW-ThinkNode-M3/variant.cpp
+++ b/variants/nrf52840/ELECROW-ThinkNode-M3/variant.cpp
@@ -1,104 +0,0 @@
-/*
-  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 "meshUtils.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()
-{
-    pinMode(KEY_POWER, OUTPUT);
-    digitalWrite(KEY_POWER, HIGH);
-    pinMode(RGB_POWER, OUTPUT);
-    digitalWrite(RGB_POWER, HIGH);
-    pinMode(green_LED_PIN, OUTPUT);
-    digitalWrite(green_LED_PIN, LED_STATE_OFF);
-    pinMode(LED_BLUE, OUTPUT);
-    pinMode(PIN_POWER_USB, INPUT);
-    pinMode(PIN_POWER_DONE, INPUT);
-    pinMode(PIN_POWER_CHRG, INPUT);
-    pinMode(BUTTON_PIN, INPUT_PULLUP);
-    pinMode(EEPROM_POWER, OUTPUT);
-    digitalWrite(EEPROM_POWER, HIGH);
-    pinMode(PIN_EN1, OUTPUT);
-    digitalWrite(PIN_EN1, HIGH);
-    pinMode(PIN_EN2, OUTPUT);
-    digitalWrite(PIN_EN2, HIGH);
-    pinMode(ACC_POWER, OUTPUT);
-    digitalWrite(ACC_POWER, LOW);
-    pinMode(DHT_POWER, OUTPUT);
-    digitalWrite(DHT_POWER, HIGH);
-    pinMode(Battery_POWER, OUTPUT);
-    digitalWrite(Battery_POWER, HIGH);
-    pinMode(GPS_POWER, OUTPUT);
-    digitalWrite(GPS_POWER, HIGH);
-}
-
-// called from main-nrf52.cpp during the cpuDeepSleep() function
-void variant_shutdown()
-{
-    digitalWrite(red_LED_PIN, HIGH);
-    digitalWrite(green_LED_PIN, HIGH);
-    digitalWrite(LED_BLUE, HIGH);
-
-    digitalWrite(PIN_EN1, LOW);
-    digitalWrite(PIN_EN2, LOW);
-    digitalWrite(EEPROM_POWER, LOW);
-    digitalWrite(KEY_POWER, LOW);
-    digitalWrite(DHT_POWER, LOW);
-    digitalWrite(ACC_POWER, LOW);
-    digitalWrite(Battery_POWER, LOW);
-    digitalWrite(GPS_POWER, LOW);
-
-    // This sets the pin to OUTPUT and LOW for the pins *not* in the if block.
-    for (int pin = 0; pin < 48; pin++) {
-        if (pin == PIN_POWER_USB || pin == BUTTON_PIN || pin == PIN_EN1 || pin == PIN_EN2 || pin == DHT_POWER ||
-            pin == ACC_POWER || pin == Battery_POWER || pin == GPS_POWER || pin == LR1110_SPI_MISO_PIN ||
-            pin == LR1110_SPI_MOSI_PIN || pin == LR1110_SPI_SCK_PIN || pin == LR1110_SPI_NSS_PIN || pin == LR1110_BUSY_PIN ||
-            pin == LR1110_NRESET_PIN || pin == LR1110_IRQ_PIN || pin == GPS_TX_PIN || pin == GPS_RX_PIN || pin == green_LED_PIN ||
-            pin == red_LED_PIN || pin == LED_BLUE) {
-            continue;
-        }
-        pinMode(pin, OUTPUT);
-        digitalWrite(pin, LOW);
-        if (pin >= 32) {
-            NRF_P1->DIRCLR = (1 << (pin - 32));
-        } else {
-            NRF_GPIO->DIRCLR = (1 << pin);
-        }
-    }
-
-    nrf_gpio_cfg_input(BUTTON_PIN, NRF_GPIO_PIN_PULLUP); // Configure the pin to be woken up as an input
-    nrf_gpio_pin_sense_t sense1 = NRF_GPIO_PIN_SENSE_LOW;
-    nrf_gpio_cfg_sense_set(BUTTON_PIN, sense1);
-
-    nrf_gpio_cfg_input(PIN_POWER_USB, NRF_GPIO_PIN_PULLDOWN); // Configure the pin to be woken up as an input
-    nrf_gpio_pin_sense_t sense2 = NRF_GPIO_PIN_SENSE_HIGH;
-    nrf_gpio_cfg_sense_set(PIN_POWER_USB, sense2);
-}
--- a/variants/nrf52840/ELECROW-ThinkNode-M3/variant.h
+++ b/variants/nrf52840/ELECROW-ThinkNode-M3/variant.h
@@ -1,123 +0,0 @@
-/*
-  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_ELECROW_EINK_V1_0_
-#define _VARIANT_ELECROW_EINK_V1_0_
-
-#ifdef __cplusplus
-extern "C" {
-#endif // __cplusplus
-
-#include "WVariant.h"
-
-#define VARIANT_MCK (64000000ul)
-#define USE_LFXO // Board uses 32khz crystal for LF
-
-#define ELECROW_ThinkNode_M3 1
-// 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)
-
-// Power Pin
-#define NRF_APM
-#define GPS_POWER 14
-#define PIN_POWER_USB 31
-#define EXT_PWR_DETECT PIN_POWER_USB
-#define PIN_POWER_DONE 24
-#define PIN_POWER_CHRG 32
-#define KEY_POWER 16
-#define ACC_POWER 2
-#define DHT_POWER 3
-#define Battery_POWER 17
-#define RGB_POWER 29
-#define EEPROM_POWER 7
-
-// LED
-#define red_LED_PIN 33
-#define LED_POWER red_LED_PIN
-#define LED_CHARGE LED_POWER // Signals the Status LED Module to handle this LED
-#define green_LED_PIN 35
-#define PIN_LED2 green_LED_PIN
-#define LED_BLUE 37
-#define LED_PAIRING LED_BLUE // Signals the Status LED Module to handle this LED
-
-#define LED_BUILTIN -1
-#define LED_STATE_ON LOW
-#define LED_STATE_OFF HIGH
-
-// BUZZER
-#define PIN_BUZZER 23
-#define PIN_EN1 36
-#define PIN_EN2 34
-/*Wire Interfaces*/
-#define WIRE_INTERFACES_COUNT 1
-#define PIN_WIRE_SDA 26
-#define PIN_WIRE_SCL 27
-
-// Temperature correction for sensor
-#define AHT10_TEMP_OFFSET -5.0
-
-/*GPS pins*/
-#define HAS_GPS 1
-#define GPS_BAUDRATE 9600
-#define PIN_GPS_RESET 25
-#define PIN_GPS_STANDBY 21
-#define GPS_TX_PIN 20
-#define GPS_RX_PIN 22
-#define GPS_THREAD_INTERVAL 50
-#define PIN_SERIAL1_RX GPS_TX_PIN
-#define PIN_SERIAL1_TX GPS_RX_PIN
-// Button
-#define BUTTON_PIN 12
-#define BUTTON_PIN_ALT (0 + 12)
-// Battery
-#define BATTERY_PIN 5
-#define BATTERY_SENSE_RESOLUTION_BITS 12
-#define BATTERY_SENSE_RESOLUTION 4096.0
-#undef AREF_VOLTAGE
-#define AREF_VOLTAGE 2.4
-#define VBAT_AR_INTERNAL AR_INTERNAL_2_4
-#define ADC_MULTIPLIER (1.75)
-/*SPI Interfaces*/
-#define SPI_INTERFACES_COUNT 1
-#define PIN_SPI_MISO (32 + 15) // P1.15 47
-#define PIN_SPI_MOSI (32 + 14) // P1.14 46
-#define PIN_SPI_SCK (32 + 13)  // P1.13 45
-#define PIN_SPI_NSS (32 + 12)  // P1.12 44
-/*LORA Interfaces*/
-#define USE_LR1110
-#define LR1110_IRQ_PIN 40
-#define LR1110_NRESET_PIN 42
-#define LR1110_BUSY_PIN 43
-#define LR1110_SPI_NSS_PIN 44
-#define LR1110_SPI_SCK_PIN 45
-#define LR1110_SPI_MOSI_PIN 46
-#define LR1110_SPI_MISO_PIN 47
-#define LR11X0_DIO3_TCXO_VOLTAGE 3.3
-#define LR11X0_DIO_AS_RF_SWITCH
-
-// PCF8563 RTC Module
-#define PCF8563_RTC 0x51
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
--- a/variants/nrf52840/ELECROW-ThinkNode-M6/platformio.ini
+++ b/variants/nrf52840/ELECROW-ThinkNode-M6/platformio.ini
@@ -1,15 +0,0 @@
-; ThinkNode M6 - Outdoor Solar Power nrf52840/sx1262 device
-[env:thinknode_m6]
-extends = nrf52840_base
-board = ThinkNode-M6
-board_check = true
-debug_tool = jlink
-
-build_flags = ${nrf52840_base.build_flags}
-  -Ivariants/nrf52840/ELECROW-ThinkNode-M6
-  -DELECROW_ThinkNode_M6
-
-build_src_filter = ${nrf52_base.build_src_filter} +<../variants/nrf52840/ELECROW-ThinkNode-M6>
-lib_deps =
-  ${nrf52840_base.lib_deps}
-  lewisxhe/PCF8563_Library@^1.0.1
--- a/variants/nrf52840/ELECROW-ThinkNode-M6/variant.cpp
+++ b/variants/nrf52840/ELECROW-ThinkNode-M6/variant.cpp
@@ -1,43 +0,0 @@
-/*
-  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 - pins 0 and 1 are hardwired for xtal and should never be enabled
-    0xff, 0xff, 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()
-{
-    pinMode(LED_CHARGE, OUTPUT);
-    ledOff(LED_CHARGE);
-
-    pinMode(LED_PAIRING, OUTPUT);
-    ledOff(LED_PAIRING);
-
-    pinMode(VDD_FLASH_EN, OUTPUT);
-    digitalWrite(VDD_FLASH_EN, HIGH);
-}
--- a/variants/nrf52840/ELECROW-ThinkNode-M6/variant.h
+++ b/variants/nrf52840/ELECROW-ThinkNode-M6/variant.h
@@ -1,144 +0,0 @@
-/*
- 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_ELECROW_THINKNODE_M6_
-#define _VARIANT_ELECROW_THINKNODE_M6_
-
-/** Master clock frequency */
-#define VARIANT_MCK (64000000ul)
-
-#define USE_LFXO
-
-/*----------------------------------------------------------------------------
- *        Headers
- *----------------------------------------------------------------------------*/
-
-#include "WVariant.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif // __cplusplus
-
-#define PINS_COUNT (48)
-#define NUM_DIGITAL_PINS (48)
-#define NUM_ANALOG_INPUTS (1)
-#define NUM_ANALOG_OUTPUTS (0)
-
-// LEDs
-#define LED_BUILTIN -1
-#define LED_BLUE -1
-#define LED_CHARGE (12)
-#define LED_PAIRING (7)
-
-#define LED_STATE_ON 1
-
-// USB power detection
-#define EXT_PWR_DETECT (13)
-
-// Button
-#define PIN_BUTTON1 (17)
-
-// Battery ADC
-#define PIN_A0 (28)
-#define BATTERY_PIN PIN_A0
-#define ADC_CTRL (11)
-#define ADC_CTRL_ENABLED 1
-
-static const uint8_t A0 = PIN_A0;
-
-#define ADC_RESOLUTION 14
-#define BATTERY_SENSE_SAMPLES 30
-
-#define PIN_NFC1 (9)
-#define PIN_NFC2 (10)
-
-// I2C
-#define WIRE_INTERFACES_COUNT 1
-#define PIN_WIRE_SDA (32 + 9)
-#define PIN_WIRE_SCL (8)
-
-// Peripheral power enable
-#define PIN_POWER_EN (27)
-
-// Solar charger status
-#define EXT_CHRG_DETECT (15)
-#define EXT_CHRG_DETECT_VALUE LOW
-
-// QSPI Flash
-#define PIN_QSPI_SCK (32 + 3)
-#define PIN_QSPI_CS (23)
-#define PIN_QSPI_IO0 (32 + 1)
-#define PIN_QSPI_IO1 (32 + 2)
-#define PIN_QSPI_IO2 (32 + 4)
-#define PIN_QSPI_IO3 (32 + 5)
-
-#define EXTERNAL_FLASH_DEVICES MX25R1635F
-#define EXTERNAL_FLASH_USE_QSPI
-#define VDD_FLASH_EN (21)
-
-// LoRa SX1262
-#define USE_SX1262
-#define SX126X_CS (32 + 12)
-#define SX126X_DIO1 (32 + 6)
-#define SX126X_BUSY (32 + 11)
-#define SX126X_RESET (32 + 10)
-#define SX126X_DIO2_AS_RF_SWITCH
-#define SX126X_DIO3_TCXO_VOLTAGE 3.3
-
-// GPS L76K
-#define GPS_L76K
-#define GPS_BAUDRATE 9600
-#define PIN_GPS_EN (6)
-#define PIN_GPS_REINIT (29)
-#define PIN_GPS_STANDBY (30)
-#define PIN_GPS_PPS (31)
-#define GPS_TX_PIN (3)
-#define GPS_RX_PIN (2)
-#define GPS_THREAD_INTERVAL 50
-
-#define PIN_SERIAL1_RX GPS_TX_PIN
-#define PIN_SERIAL1_TX GPS_RX_PIN
-
-// Secondary UART
-#define PIN_SERIAL2_RX (22)
-#define PIN_SERIAL2_TX (24)
-
-// PCF8563 RTC Module
-#define PCF8563_RTC 0x51
-
-// SPI
-#define SPI_INTERFACES_COUNT 1
-#define PIN_SPI_MISO (32 + 15)
-#define PIN_SPI_MOSI (32 + 14)
-#define PIN_SPI_SCK (32 + 13)
-
-// Battery
-#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.75F)
-
-#define HAS_SOLAR
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
--- a/variants/nrf52840/heltec_mesh_pocket/variant.h
+++ b/variants/nrf52840/heltec_mesh_pocket/variant.h
@@ -120,7 +120,7 @@ No longer populated on PCB
 #undef AREF_VOLTAGE
 #define AREF_VOLTAGE 3.0
 #define VBAT_AR_INTERNAL AR_INTERNAL_3_0
-#define ADC_MULTIPLIER (4.90F)
+#define ADC_MULTIPLIER (4.6425F)

 #undef HAS_GPS
 #define HAS_GPS 0
@@ -129,4 +129,4 @@ No longer populated on PCB
 }
 #endif

-#endif
+#endif
--- a/variants/nrf52840/muzi_base/platformio.ini
+++ b/variants/nrf52840/muzi_base/platformio.ini
@@ -1,15 +0,0 @@
-[env:muzi-base]
-extends = nrf52840_base
-board = muzi-base
-build_flags = ${nrf52840_base.build_flags}
-  -I variants/nrf52840/muzi_base
-  -D MUZI_BASE
-  -D CONFIG_NFCT_PINS_AS_GPIOS=1
-  -L "${platformio.libdeps_dir}/${this.__env__}/bsec2/src/cortex-m4/fpv4-sp-d16-hard"
-
-build_src_filter = ${nrf52840_base.build_src_filter} +<../variants/nrf52840/muzi_base>
-lib_deps = 
-  ${nrf52840_base.lib_deps}
-  artronshop/ArtronShop_RX8130CE@1.0.0
-
-
--- a/variants/nrf52840/muzi_base/variant.cpp
+++ b/variants/nrf52840/muzi_base/variant.cpp
@@ -1,83 +0,0 @@
-#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()
-{
-    // Initialize the digital pins as inputs or outputs
-    pinMode(PIN_LED1, OUTPUT);
-    digitalWrite(PIN_LED1, HIGH);
-
-    pinMode(PIN_LED2, OUTPUT);
-    digitalWrite(PIN_LED2, HIGH);
-
-    // Initialize LoRa pins
-    pinMode(SX126X_RESET, OUTPUT);
-    digitalWrite(SX126X_RESET, HIGH);
-
-    pinMode(SX126X_CS, OUTPUT);
-    digitalWrite(SX126X_CS, HIGH);
-
-    pinMode(GPS_EN_GPIO, OUTPUT);
-    digitalWrite(GPS_EN_GPIO, HIGH); // GPS on initially
-
-    pinMode(SCREEN_12V_ENABLE, OUTPUT);
-    digitalWrite(SCREEN_12V_ENABLE, LOW); //
-
-    pinMode(BATTERY_CHARGING_INV, INPUT);
-}
--- a/variants/nrf52840/muzi_base/variant.h
+++ b/variants/nrf52840/muzi_base/variant.h
@@ -1,192 +0,0 @@
-#pragma once
-
-#ifndef _VARIANT_MUZI_BASE_
-#define _VARIANT_MUZI_BASE_
-
-/** Master clock frequency */
-#define VARIANT_MCK (64000000ul)
-
-#define USE_LFXO // Board uses 32khz crystal 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 (6)
-#define NUM_ANALOG_OUTPUTS (0)
-
-// Define I2C Peripherals
-#define WIRE_INTERFACES_COUNT 2
-
-// this is the OLED bus
-#define PIN_WIRE_SDA (0 + 24) // P0.24
-#define PIN_WIRE_SCL (0 + 25) // P0.25
-
-// IMU bus
-#define PIN_WIRE1_SDA (0 + 04) // P0.04
-#define PIN_WIRE1_SCL (0 + 06) // P0.06
-
-#define COMPASS_ORIENTATION meshtastic_Config_DisplayConfig_CompassOrientation_DEGREES_270
-#define HAS_ICM20948 // forces the i2c address to be seen as this sensor
-
-#define HAS_RTC 1
-#define RX8130CE_RTC 0x32
-
-// LEDs
-#define PIN_LED1 (32 + 3) // P1.03, Green
-#define PIN_LED2 (32 + 4) // P1.04, Blue
-
-#define LED_BUILTIN -1 // PIN_LED1
-#define LED_BLUE PIN_LED2
-#define LED_STATE_ON 0 // State when LED is lit
-
-// Buttons
-#define HAS_TRACKBALL 1
-#define TB_UP (0 + 21)
-#define TB_DOWN (0 + 17)
-#define TB_LEFT (32 + 05)
-#define TB_RIGHT (0 + 16)
-#define TB_PRESS (0 + 10)
-#define TB_DIRECTION FALLING
-
-#define CANCEL_BUTTON_PIN (0 + 15) // P0.15
-#define CANCEL_BUTTON_ACTIVE_LOW true
-#define CANCEL_BUTTON_ACTIVE_PULLUP false
-
-// Switch
-#define SWITCH_MODE1 (32 + 9) // P1.09, Top Position
-#define SWITCH_MODE2 (0 + 12) // P0.12, Middle Position
-#define PIN_GPS_SWITCH SWITCH_MODE2
-
-/*
- * SPI Interfaces
- */
-
-#define SPI_INTERFACES_COUNT 1
-
-// For LORA, spi 0
-#define PIN_SPI_MISO (32 + 15) // P1.15
-#define PIN_SPI_MOSI (32 + 14) // P1.14
-#define PIN_SPI_SCK (32 + 13)  // P1.13
-
-#define LORA_SCK PIN_SPI_SCK
-#define LORA_MISO PIN_SPI_MISO
-#define LORA_MOSI PIN_SPI_MOSI
-#define LORA_CS (32 + 12) // P1.12
-
-#define USE_SX1262
-#define SX126X_CS LORA_CS
-#define SX126X_DIO1 (32 + 6)   // P1.06
-#define SX126X_BUSY (32 + 11)  // P1.11
-#define SX126X_RESET (32 + 10) // P1.10
-#define SX126X_DIO2_AS_RF_SWITCH
-#define SX126X_DIO3_TCXO_VOLTAGE 3.3
-
-#define USE_LR1121
-#define LR1121_IRQ_PIN (32 + 8)     // P1.08
-#define LR1121_NRESET_PIN (32 + 10) // P1.10
-#define LR1121_BUSY_PIN (32 + 11)   // P1.11
-#define LR1121_SPI_NSS_PIN LORA_CS
-#define LR1121_SPI_SCK_PIN LORA_SCK
-#define LR1121_SPI_MOSI_PIN LORA_MOSI
-#define LR1121_SPI_MISO_PIN LORA_MISO
-#define LR11X0_DIO3_TCXO_VOLTAGE 3.0
-#define LR11X0_DIO_AS_RF_SWITCH
-
-// GPS
-#define GPS_RX_PIN (0 + 19)  // P0.19
-#define GPS_TX_PIN (0 + 20)  // P0.20
-#define GPS_EN_GPIO (32 + 1) // P1.01
-
-#define PIN_SERIAL1_RX GPS_TX_PIN
-#define PIN_SERIAL1_TX GPS_RX_PIN
-
-#define PIN_BUZZER (0 + 22) // P0.22
-
-// Battery monitoring
-#define BATTERY_PIN (0 + 31) // P0.31
-
-// #define CHARGER_FAULT (0 + 27) // P0.27
-#define BATTERY_CHARGING_INV (32 + 02) // P1.02
-#define BATTERY_SENSE_RESOLUTION_BITS 12
-#define BATTERY_SENSE_RESOLUTION 4096.0
-#define ADC_MULTIPLIER 1.537
-
-#define OCV_ARRAY 4050, 4010, 3990, 3930, 3870, 3820, 3740, 3630, 3550, 3450, 3100
-
-// Display - I2C display
-#define HAS_SCREEN 1
-#define SCREEN_12V_ENABLE (0 + 23) // P0.23
-#define USE_SH1107
-
-#define USERPREFS_OEM_TEXT "muzi_works_logo"
-#define USERPREFS_OEM_FONT_SIZE 0
-#define USERPREFS_OEM_IMAGE_WIDTH 88  // 11 bytes wide
-#define USERPREFS_OEM_IMAGE_HEIGHT 47 // 517 bytes total
-#define USERPREFS_OEM_IMAGE_DATA                                                                                                 \
-    {                                                                                                                            \
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF,  \
-            0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,    \
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,    \
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,    \
-            0xF7, 0x0F, 0xFF, 0x00, 0xF0, 0xFF, 0x0F, 0xC0, 0xFF, 0x07, 0x78, 0xFF, 0x9F, 0xFF, 0x01, 0xF0, 0xFF, 0x0F, 0xC0,    \
-            0xFF, 0x03, 0x78, 0x3F, 0xFE, 0xF3, 0x01, 0xF0, 0xFF, 0x0F, 0x00, 0xE0, 0x03, 0x78, 0x1F, 0xFC, 0xC0, 0x03, 0xF0,    \
-            0xFF, 0x0F, 0x00, 0xE0, 0x01, 0x78, 0x0F, 0xF8, 0x80, 0x03, 0xF0, 0xFF, 0x0F, 0x00, 0xF0, 0x00, 0x78, 0x0F, 0x78,    \
-            0x80, 0x03, 0xF0, 0xFF, 0x0F, 0x00, 0x70, 0x00, 0x78, 0x07, 0x70, 0x80, 0x03, 0xF0, 0xFF, 0x0F, 0x00, 0x78, 0x00,    \
-            0x78, 0x07, 0x70, 0x80, 0x03, 0xF0, 0xFF, 0x0F, 0x00, 0x3C, 0x00, 0x78, 0x07, 0x70, 0x80, 0x03, 0xF0, 0xFF, 0x0F,    \
-            0x00, 0x1C, 0x00, 0x78, 0x07, 0x70, 0x80, 0x03, 0xF0, 0xFF, 0x0F, 0x00, 0x1E, 0x00, 0x78, 0x07, 0x70, 0x80, 0x03,    \
-            0xE0, 0xFF, 0x0F, 0x00, 0x0F, 0x00, 0x78, 0x07, 0x70, 0x80, 0x03, 0xE0, 0xFF, 0x07, 0x80, 0x07, 0x00, 0x78, 0x07,    \
-            0x70, 0x80, 0x03, 0xC0, 0xFF, 0x07, 0x80, 0x07, 0x00, 0x78, 0x07, 0x70, 0x80, 0x03, 0xC0, 0xFF, 0x03, 0xC0, 0xFF,    \
-            0x07, 0x78, 0x07, 0x70, 0x80, 0x03, 0x00, 0xFF, 0x01, 0xE0, 0xFF, 0x07, 0x78, 0x07, 0x70, 0x80, 0x03, 0x00, 0x7C,    \
-            0x00, 0xF0, 0xFF, 0x07, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,    \
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,    \
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,    \
-            0xFF, 0xFF, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,    \
-            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0xE3, 0xE7, 0xC7, 0x1F, 0xF8, 0x0F, 0xF0, 0xE7, 0xE3, 0x07, 0x7C, 0xC7, 0xE7,    \
-            0xC3, 0x0F, 0xE0, 0x07, 0xE0, 0xC7, 0xE1, 0x03, 0x70, 0xC7, 0xC3, 0xE3, 0x87, 0xC1, 0x07, 0xC0, 0xC7, 0xF8, 0xE3,    \
-            0x71, 0xC7, 0xC3, 0xE3, 0xE3, 0xC7, 0xC7, 0xC7, 0x47, 0xF8, 0xF3, 0x7F, 0x8F, 0xC3, 0xF1, 0xE3, 0x8F, 0xC7, 0x8F,    \
-            0x27, 0xFC, 0xE3, 0x7F, 0x8F, 0x81, 0xF1, 0xF1, 0x8F, 0xC7, 0xCF, 0x07, 0xFE, 0x03, 0x7E, 0x8F, 0x99, 0xF1, 0xF1,    \
-            0x8F, 0x07, 0xC0, 0x07, 0xFF, 0x07, 0x78, 0x9F, 0x99, 0xF9, 0xF1, 0x8F, 0x07, 0xE0, 0x07, 0xFE, 0x3F, 0x70, 0x1F,    \
-            0x18, 0xF8, 0xF3, 0x8F, 0x07, 0xF0, 0x27, 0xFC, 0xFF, 0x71, 0x3F, 0x18, 0xF8, 0xE3, 0xC7, 0xC7, 0xF1, 0x47, 0xF8,    \
-            0xF3, 0x63, 0x3F, 0x3C, 0xFC, 0xC3, 0xC3, 0xC7, 0xE3, 0xC7, 0xF0, 0xE1, 0x71, 0x3F, 0x3C, 0xFC, 0x07, 0xE0, 0xC7,    \
-            0xC7, 0xC7, 0xE1, 0x03, 0x70, 0x7F, 0x7E, 0xFE, 0x0F, 0xF0, 0xC7, 0x87, 0xC7, 0xC3, 0x07, 0x78, 0xFF, 0xFF, 0xFF,    \
-            0x7F, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0x1F, 0x7E, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F,    \
-            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,    \
-            0xFF, 0xFF, 0x7F                                                                                                     \
-    }
-
-// QSPI Pins
-#define PIN_QSPI_SCK (0 + 3)
-#define PIN_QSPI_CS (0 + 26)
-#define PIN_QSPI_IO0 (0 + 30)
-#define PIN_QSPI_IO1 (0 + 29)
-#define PIN_QSPI_IO2 (0 + 28)
-#define PIN_QSPI_IO3 (0 + 2)
-
-// On-board QSPI Flash
-#define EXTERNAL_FLASH_DEVICES W25Q32JVSS
-#define EXTERNAL_FLASH_USE_QSPI
-
-// NFC is disabled via CONFIG_NFCT_PINS_AS_GPIOS=1 build flag
-// This configures P0.09 and P0.10 as regular GPIO pins instead of NFC pins
-
-#ifdef __cplusplus
-}
-#endif
-
-/*----------------------------------------------------------------------------
- *        Arduino objects - C++ only
- *----------------------------------------------------------------------------*/
-#ifdef __cplusplus
-#endif
-
-#endif // _VARIANT_MUZI_BASE_
--- a/variants/nrf52840/r1-neo/variant.h
+++ b/variants/nrf52840/r1-neo/variant.h
@@ -132,8 +132,7 @@ static const uint8_t SCK = PIN_SPI_SCK;
 #undef AREF_VOLTAGE
 #define AREF_VOLTAGE 3.0
 #define VBAT_AR_INTERNAL AR_INTERNAL_3_0
-#define ADC_MULTIPLIER 1.667
-#define OCV_ARRAY 4200, 4020, 4000, 3940, 3870, 3820, 3750, 3630, 3550, 3450, 3100
+#define ADC_MULTIPLIER 1.73

 #define HAS_RTC 1

--- a/variants/stm32/wio-e5/variant.h
+++ b/variants/stm32/wio-e5/variant.h
@@ -15,7 +15,7 @@ Do not expect a working Meshtastic device with this target.
 #define USE_STM32WLx

 #define LED_PIN PB5
-#define LED_STATE_ON 1
+#define LED_STATE_ON 0

 #define WIO_E5

--- a/version.properties
+++ b/version.properties
@@ -1,4 +1,4 @@
 [VERSION]  
 major = 2
 minor = 7
-build = 15
+build = 14
Author	SHA1	Message	Date
Jonathan Bennett	c1aeb1f803	minor changes to bme680 changes	2026-01-05 19:20:11 -06:00
JaeHwan Jin	95ec869d67	chore: trigger CI	2025-11-24 10:46:28 +09:00
JaeHwan Jin	1ac74cefc4	Fix for esp32 CI	2025-11-18 18:58:50 +09:00
JaeHwan Jin	7b6235f4d7	Fix for esp32 CI	2025-11-17 21:19:49 +09:00
JaeHwan Jin	60366f3aff	Fix bosch library dependencies	2025-11-14 17:57:33 +09:00
JaeHwan Jin	09303110ff	Back bsec2 to environmental_extra	2025-11-14 17:04:17 +09:00
JaeHwan Jin	d88640a134	Modify limited to Portduino and RAK4631 only	2025-11-14 16:41:05 +09:00
JaeHwan Jin	52eb9c9f82	Add BME680 and SHTC3 support to meshtasticd and RAK4631	2025-11-12 17:37:10 +09:00
Andrik45719	7212fb9caa	Fix null pointer dereference in radio chip region check (#8613 )	2025-11-11 10:00:08 -06:00
Jason B. Cox	4118e1c0f6	Cleanup unnecessary global dereferencing in CryptoEngine (#8611 ) Co-authored-by: Ben Meadors <benmmeadors@gmail.com>	2025-11-10 20:19:15 -06:00
Thomas Göttgens	a62fed3289	Merge pull request #8610 from meshtastic/fix-ldro Change RadioLib to commit zip til 7.4.1+ is released	2025-11-10 22:31:03 +01:00
Thomas Göttgens	7d2744fae0	Change RadioLib to commit zip til 7.4.1+ is released fixes regression for SX127x chips per @GUVWAF	2025-11-10 16:16:24 +01:00
Chloe Bethel	beaebda4de	stm32wl: Wrap and remove some functions that pull in large amounts of code/data to claw back even more flash space (#8609 )	2025-11-10 09:08:04 -06:00
Tom	36c2178570	Update to Pro-micro variants (#8600 ) * Update to Pro-micro variants Schematic updated Xtal variant removed Extra module added to list Extra explanation added to readme. * Fix markdown formatting in readme.md * Fix formatting in readme.md for RF switch section --------- Co-authored-by: Tom <116762865+Nestpebble@users.noreply.github.com>	2025-11-09 09:24:03 -06:00
Quency-D	50f9be9a2b	Add the Heltec v4 expansion box. (#8539 ) * Add the Heltec v4 expansion box. * Change heltec-v4-oled to heltec-v4. * Add touchscreen to I2C scanning. * Add reset and busy pins to the ST7789. * Ignore the touch interrupt pin and extend the sleep time to 1 hour. * Remove the default sleep function. --------- Co-authored-by: Ben Meadors <benmmeadors@gmail.com>	2025-11-08 06:47:24 -06:00
Benjamin Faershtein	8fe98db5dd	Drop PKI acks if there is no downlink on MQTTClientProxy (#8580 ) * Discard everything if downlink isn't on * Drop PKI packets when downlink not on	2025-11-08 05:59:45 -06:00
Jonathan Bennett	531cad5e88	Add API types, state, and log message in Debug screen. Added persistent "Connected" icon (#8576 ) * Add API types, state, and log message in Debug screen * un-goober the API state tracking * Set the SerialConsole api_type * Add api_type for Ethernet * Remove API state debugging code * Update wording for client connection states * Improve string width for smaller screen devices * Reserve space on navigation bar to fit link indicator * Add persistent Connected icon to screen * Connect System frame to ensure text doesn't overflow --------- Co-authored-by: Ben Meadors <benmmeadors@gmail.com> Co-authored-by: Jason P <applewiz@mac.com> Co-authored-by: HarukiToreda <116696711+HarukiToreda@users.noreply.github.com>	2025-11-07 15:03:56 -06:00
Benjamin Faershtein	77e0a24838	Discard everything if downlink isn't on (#8578 )	2025-11-06 21:01:15 -06:00
Ford Jones	6cad393688	Persist favourites on NodeDB reset (#8292 ) * Conditionally delete favourited nodes on reset * trunk fmt * Fix equality check, use existing macro for role validation * Extend favourite persistence setting to devices of all roles * Refactor: Decoupled role/config check and set role defaults appropriately * Use American-English spelling * Use existing reference * Convert reset to bool, regen protos * Add optional arg to nodedb_reset in favor of additional device setting * Use correct proto commit ID * Regen protos * Log preservation status * Pull latest from master	2025-11-06 16:06:37 -06:00
Ben Meadors	0725b46744	Merge branch 'master' into develop	2025-11-06 07:14:51 -06:00
Mike Robbins	6a6c409b9a	addFromContact: Don't auto-favorite when CLIENT_BASE; don't update last_heard unless CLIENT_BASE (#8495 ) Co-authored-by: Ben Meadors <benmmeadors@gmail.com>	2025-11-06 07:10:20 -06:00
Wessel	7b14b173d9	Store hop/mqtt/transport mechanism info in S&F (#8560 ) Before this, all messages received when enabling S&F server would return Hops away: -1	2025-11-06 06:27:25 -06:00
Jason P	3e40d7896b	Revert "nrf52: add watchdog (#8485 )" (#8554 ) This reverts commit `83954293d8`.	2025-11-05 10:07:28 -06:00
renovate[bot]	03f69b3b77	Update RadioLib to v7.4.0 (#8456 ) * fix strlcpy compile error in Ubuntu 22.04 (#8520) * fix strlcpy error in Ubuntu 20.04 * add to native after tests * Add support for RAK_WISMESH_TAP_V2 and RAK3401 hardware models (#8537) * Update RadioLib to v7.4.0 --------- Co-authored-by: Manuel <71137295+mverch67@users.noreply.github.com> Co-authored-by: Daniel.Cao <144674500+DanielCao0@users.noreply.github.com> Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>	2025-11-04 06:04:56 -06:00
Sebastian Kuzminsky	83954293d8	nrf52: add watchdog (#8485 ) * nrf52: add watchdog Main thread only for now. * bump framework-arduinoadafruitnrf52 to pick up new wdt support * clang-format the new parts of main-nrf52.cpp --------- Co-authored-by: Ben Meadors <benmmeadors@gmail.com>	2025-11-04 05:35:44 -06:00
Austin	91621427f1	Packaging: Add libbsd where needed (#8533 )	2025-11-03 17:56:31 -06:00
Ben Meadors	8d1b9c9dce	Merge pull request #8531 from meshtastic/master Master	2025-11-03 15:56:42 -06:00
Ben Meadors	538c05ad6c	Revert "ADD - heltec v4 support to device install bat (#8528 )" (#8532 ) This reverts commit `468247fb94`.	2025-11-03 15:56:23 -06:00
Quency-D	f6370bea8f	Add the identification code for the DA217 triaxial accelerometer. (#8526 )	2025-11-04 07:18:52 +11:00
Melon	468247fb94	ADD - heltec v4 support to device install bat (#8528 )	2025-11-04 07:14:24 +11:00
github-actions[bot]	3ae7e54681	Automated version bumps (#8527 ) Co-authored-by: thebentern <9000580+thebentern@users.noreply.github.com>	2025-11-03 10:14:08 -06:00
Dmitry Ivanishkin	0a124b7f3d	Fix SHT4x detection by reading unique serial nubmer (#8525 )	2025-11-03 08:17:52 -06:00
Jonathan Bennett	7def82595d	Rename screen options to display options and add units chooser (#8517 ) * Rename screen options to display options and add units chooser * Add InitialSelected to DisplayUnits_menu	2025-11-02 21:30:41 -06:00
Melon	3a67204f6d	Update device-install.sh to support heltec-v4 (#8509 ) * Update device-install.sh * Update device-install.sh	2025-11-02 06:09:15 -06:00
Jonathan Bennett	d1b66782d1	Hide nodes that don't have position in the distance and bearings nodelists (#8518 )	2025-11-02 05:57:15 -06:00
Xavier horwood	718fd118b0	Add IPv6 Support for esp32 (#6866 ) * Update Default.h * Update NodeDB.cpp * Update WiFiAPClient.cpp * Update userPrefs.jsonc * set ipv6 to off by default * Trunk fix --------- Co-authored-by: Tom Fifield <tom@tomfifield.net>	2025-11-02 09:25:59 +11:00
Ben Meadors	75f7ded12c	Merge pull request #8513 from meshtastic/master Master backmerge	2025-11-01 17:17:14 -05:00
pa0lin082	7f78a624cd	Add support for Bh1750 Light Sensor (#8376 ) * regenerate protobuf with bh1750 TelemetrySensorType * Added wollewald/BH1750_WE@^1.1.10 dependecy * Added support for BH1750 during i2C detection * Create new BH1750Sensor and added in EnvironmentTelemetry * clean code * Attempt to fix protobuf include --------- Co-authored-by: Tom Fifield <tom@tomfifield.net>	2025-11-01 09:40:36 +11:00
shortwavesurfer2009	17324fa725	adjust battery curve (#8137 ) Co-authored-by: HarukiToreda <116696711+HarukiToreda@users.noreply.github.com>	2025-11-01 09:39:30 +11:00
Marius Faber	001654e90a	Add basic LR1121 support for T-Beam S3, full support needs #4775 fixed (#8349 )	2025-11-01 09:38:37 +11:00
Andrew Yong	4f817d69eb	fix(wio-e5): Fix LED state inversion (#8500 ) Wio-E5 currently has LED appearing to be steadily on, due to incorrect LED_STATE_ON (it is actually briefly flashing off, but visually it is hard to perceive). Wio-E5 has LED between GPIO PB5 and VCC, so LED_STATE_ON should be 0 for LED to blink correctly. With this commit, it is now flashing correctly. Refer to schematics: * [Wio-E5 Development Kit](https://files.seeedstudio.com/products/113990934/LoRa-E5%20Dev%20Board%20v1.0.pdf) * [Wio-E5 mini](https://files.seeedstudio.com/products/113990939/LoRa-E5%20mini%20v1.0.pdf) Signed-off-by: Andrew Yong <me@ndoo.sg>	2025-10-31 05:55:07 -05:00
Chloe Bethel	de83b448f9	Force stdout to be line buffered - this fixes logs ending early if meshtasticd crashes (#8499 )	2025-10-31 05:54:35 -05:00
Ixitxachitl	c145be8e05	Refactor emote dimensions to 16x16 pixels (#8493 ) Updated the dimensions of various emotes in emotes.h from 30x30 or 25x25 to 16x16 pixels for consistency and optimization. Added new emotes including heart_smile, Heart_eyes, and others, all with the same 16x16 size. This change improves memory usage and aligns with the design specifications for smaller emotes.	2025-10-31 21:20:29 +11:00
Clive Blackledge	28f53d132a	refactor: change node count variables from uint8_t to uint16_t (#8478 ) This is a non-breaking change that increases the internal representation of node counts from uint8_t (max 255) to uint16_t (max 65535) to support larger mesh networks, particularly on ESP32-S3 devices with PSRAM. Changes: - NodeStatus: numOnline, numTotal, lastNumTotal (uint8_t -> uint16_t) - ProtobufModule: numOnlineNodes (uint8_t -> uint16_t) - MapApplet: loop counters changed to size_t for consistency with getNumMeshNodes() - NodeStatus: Fixed log format to use %u for unsigned integers Note: Default class methods keep uint32_t for numOnlineNodes parameter to match the public API and allow flexibility, even though internal node counts use uint16_t (max 65535 nodes). This change does NOT affect protobuf definitions, maintaining wire compatibility with existing clients and devices.	2025-10-28 15:32:08 -05:00
Erayd	f045ca2303	Fix type to ensure correct alignment; saves 4B per entry (#8465 )	2025-10-27 06:05:59 -05:00
Tom Fifield	b6830a68a0	Migrate test workflow to use Node 24 (#8466 ) Node 24 is now the common version amoungst all of our actions.	2025-10-27 19:47:34 +11:00
Ben Meadors	13c4c2037d	Merge pull request #8444 from meshtastic/master Master --> develop	2025-10-24 21:06:29 -05:00