Fix SHT4x detection by reading unique serial nubmer (#8525 )

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
2026-10-06 12:10:59 +10:00 · 2025-11-03 08:17:52 -06:00 · 2025-11-02 21:30:41 -06:00 · 2025-11-02 06:09:15 -06:00 · 2025-11-02 05:57:15 -06:00 · 2025-11-02 09:25:59 +11:00
93 changed files with 10671 additions and 34552 deletions
@@ -1,7 +1,7 @@
 # trunk-ignore-all(terrascan/AC_DOCKER_0002): Known terrascan issue
 # trunk-ignore-all(hadolint/DL3008): Do not pin apt package versions
 # trunk-ignore-all(hadolint/DL3013): Do not pin pip package versions
-FROM mcr.microsoft.com/devcontainers/cpp:2-debian-13
+FROM mcr.microsoft.com/devcontainers/cpp:2-debian-12

 USER root

@@ -8,7 +8,7 @@
  "features": {
    "ghcr.io/devcontainers/features/python:1": {
      "installTools": true,
-      "version": "3.14"
+      "version": "3.13"
    }
  },
  "customizations": {
@@ -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
@@ -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.486
+    - renovate@41.157.0
    - prettier@3.6.2
-    - trufflehog@3.90.13
+    - trufflehog@3.90.11
    - yamllint@1.37.1
    - bandit@1.8.6
    - trivy@0.67.2
    - taplo@0.10.0
-    - ruff@0.14.4
+    - ruff@0.14.1
    - 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]
@@ -8,8 +8,7 @@ ARG PIO_ENV=native
 ENV PIP_ROOT_USER_ACTION=ignore

 RUN apk --no-cache add \
-        bash g++ libstdc++-dev linux-headers zip git ca-certificates libbsd-dev \
-        libgpiod-dev yaml-cpp-dev bluez-dev \
+        bash g++ libstdc++-dev linux-headers zip git ca-certificates libgpiod-dev yaml-cpp-dev bluez-dev \
        libusb-dev i2c-tools-dev libuv-dev openssl-dev pkgconf argp-standalone \
        libx11-dev libinput-dev libxkbcommon-dev \
    && rm -rf /var/cache/apk/* \
@@ -41,8 +40,8 @@ LABEL org.opencontainers.image.title="Meshtastic" \
 USER root

 RUN apk --no-cache add \
-        shadow libstdc++ libbsd libgpiod yaml-cpp libusb \
-        i2c-tools libuv libx11 libinput libxkbcommon \
+        shadow libstdc++ libgpiod yaml-cpp libusb i2c-tools libuv \
+        libx11 libinput libxkbcommon \
    && rm -rf /var/cache/apk/* \
    && mkdir -p /var/lib/meshtasticd \
    && mkdir -p /etc/meshtasticd/config.d \
@@ -2,7 +2,7 @@
 [portduino_base]
 platform =
  # renovate: datasource=git-refs depName=platform-native packageName=https://github.com/meshtastic/platform-native gitBranch=develop
-  https://github.com/meshtastic/platform-native/archive/f566d364204416cdbf298e349213f7d551f793d9.zip
+  https://github.com/meshtastic/platform-native/archive/d3f6e339534233c7217818867368767590ce549e.zip
 framework = arduino

 build_src_filter = 
@@ -15,12 +15,12 @@ SET "LOGCOUNTER=0"
 SET "BPS_RESET=0"

@REM FIXME: Determine mcu from PlatformIO variant, this is unmaintainable.
-SET "S3=s3 v3 t-deck wireless-paper wireless-tracker station-g2 unphone t-eth-elite tlora-pager mesh-tab dreamcatcher ESP32-S3-Pico seeed-sensecap-indicator heltec_capsule_sensor_v3 vision-master icarus tracksenger elecrow-adv heltec-v4"
+SET "S3=s3 v3 t-deck wireless-paper wireless-tracker station-g2 unphone t-eth-elite tlora-pager mesh-tab dreamcatcher ESP32-S3-Pico seeed-sensecap-indicator heltec_capsule_sensor_v3 vision-master icarus tracksenger elecrow-adv"
 SET "C3=esp32c3"
@REM FIXME: Determine flash size from PlatformIO variant, this is unmaintainable.
 SET "BIGDB_8MB=crowpanel-esp32s3 heltec_capsule_sensor_v3 heltec-v3 heltec-vision-master-e213 heltec-vision-master-e290 heltec-vision-master-t190 heltec-wireless-paper heltec-wireless-tracker heltec-wsl-v3 icarus seeed-xiao-s3 tbeam-s3-core tracksenger"
 SET "MUIDB_8MB=picomputer-s3 unphone seeed-sensecap-indicator"
-SET "BIGDB_16MB=t-deck mesh-tab t-energy-s3 dreamcatcher ESP32-S3-Pico m5stack-cores3 station-g2 t-eth-elite tlora-pager t-watch-s3 elecrow-adv heltec-v4"
+SET "BIGDB_16MB=t-deck mesh-tab t-energy-s3 dreamcatcher ESP32-S3-Pico m5stack-cores3 station-g2 t-eth-elite tlora-pager t-watch-s3 elecrow-adv"

 GOTO getopts
 :help
@@ -87,12 +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>
    <release version="2.7.13" date="2025-10-11">
      <url type="details">https://github.com/meshtastic/firmware/releases?q=tag%3Av2.7.13</url>
    </release>
@@ -1,15 +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
-
- -- GitHub Actions <github-actions[bot]@users.noreply.github.com>  Mon, 03 Nov 2025 16:11:31 +0000
-
 meshtasticd (2.7.13.0) unstable; urgency=medium

  * Version 2.7.13
@@ -3,7 +3,6 @@ Section: misc
 Priority: optional
 Maintainer: Austin Lane <vidplace7@gmail.com>
 Build-Depends: debhelper-compat (= 13),
-               libc6-dev (>= 2.38) | libbsd-dev,
               lsb-release,
               tar,
               gzip,
@@ -49,13 +49,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
@@ -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
@@ -120,7 +120,7 @@ lib_deps =
 [device-ui_base]
 lib_deps =
 	# renovate: datasource=git-refs depName=meshtastic/device-ui packageName=https://github.com/meshtastic/device-ui gitBranch=master
-	https://github.com/meshtastic/device-ui/archive/28167c67dfd13015a0b5eef1828f95fe8e3ab7c3.zip
+	https://github.com/meshtastic/device-ui/archive/19b7855e9a1d9deff37391659ca7194e4ef57c43.zip

 ; Common libs for environmental measurements in telemetry module
 [environmental_base]
@@ -176,11 +176,13 @@ lib_deps =
 	# renovate: datasource=custom.pio depName=Adafruit LTR390 Library packageName=adafruit/library/Adafruit LTR390 Library
 	adafruit/Adafruit LTR390 Library@1.1.2
 	# renovate: datasource=custom.pio depName=Adafruit PCT2075 packageName=adafruit/library/Adafruit PCT2075
-	adafruit/Adafruit PCT2075@1.0.6
+	adafruit/Adafruit PCT2075@1.0.5
 	# renovate: datasource=custom.pio depName=DFRobot_BMM150 packageName=dfrobot/library/DFRobot_BMM150
 	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]
@@ -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;
@@ -50,7 +50,6 @@ void consolePrintf(const char *format, ...)

 SerialConsole::SerialConsole() : StreamAPI(&Port), RedirectablePrint(&Port), concurrency::OSThread("SerialConsole")
 {
-    api_type = TYPE_SERIAL;
    assert(!console);
    console = this;
    canWrite = false; // We don't send packets to our port until it has talked to us first
@@ -250,7 +250,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // -----------------------------------------------------------------------------
 #define FT6336U_ADDR 0x48
 #define CST328_ADDR 0x1A
-#define CHSC6X_ADDR 0x2E

 // -----------------------------------------------------------------------------
 // RAK12035VB Soil Monitor (using RAK12023 up to 3 RAK12035 monitors can be connected)
@@ -83,9 +83,7 @@ class ScanI2C
        BMM150,
        TSL2561,
        DRV2605,
-        BH1750,
-        DA217,
-        CHSC6X
+        BH1750
    } DeviceType;

    // typedef uint8_t DeviceAddress;
@@ -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);
@@ -485,7 +485,6 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
                SCAN_SIMPLE_CASE(LTR390UV_ADDR, LTR390UV, "LTR390UV", (uint8_t)addr.address);
                SCAN_SIMPLE_CASE(PCT2075_ADDR, PCT2075, "PCT2075", (uint8_t)addr.address);
                SCAN_SIMPLE_CASE(CST328_ADDR, CST328, "CST328", (uint8_t)addr.address);
-                SCAN_SIMPLE_CASE(CHSC6X_ADDR, CHSC6X, "CHSC6X", (uint8_t)addr.address);
            case LTR553ALS_ADDR:
                registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x86), 1); // Part ID register
                if (registerValue == 0x92) {                                                       // LTR553ALS Part ID
@@ -1,8 +1,6 @@
 #include "configuration.h"
 #if HAS_SCREEN
-#include "MeshService.h"
 #include "RTC.h"
-#include "draw/NodeListRenderer.h"
 #include "graphics/ScreenFonts.h"
 #include "graphics/SharedUIDisplay.h"
 #include "graphics/draw/UIRenderer.h"
@@ -400,43 +398,6 @@ const int *getTextPositions(OLEDDisplay *display)
    return textPositions;
 }

-// *************************
-// * Common Footer Drawing *
-// *************************
-void drawCommonFooter(OLEDDisplay *display, int16_t x, int16_t y)
-{
-    bool drawConnectionState = false;
-    if (service->api_state == service->STATE_BLE || service->api_state == service->STATE_WIFI ||
-        service->api_state == service->STATE_SERIAL || service->api_state == service->STATE_PACKET ||
-        service->api_state == service->STATE_HTTP || service->api_state == service->STATE_ETH) {
-        drawConnectionState = true;
-    }
-
-    if (drawConnectionState) {
-        if (isHighResolution) {
-            const int scale = 2;
-            const int bytesPerRow = (connection_icon_width + 7) / 8;
-            int iconX = 0;
-            int iconY = SCREEN_HEIGHT - (connection_icon_height * 2);
-
-            for (int yy = 0; yy < connection_icon_height; ++yy) {
-                const uint8_t *rowPtr = connection_icon + yy * bytesPerRow;
-                for (int xx = 0; xx < connection_icon_width; ++xx) {
-                    const uint8_t byteVal = pgm_read_byte(rowPtr + (xx >> 3));
-                    const uint8_t bitMask = 1U << (xx & 7); // XBM is LSB-first
-                    if (byteVal & bitMask) {
-                        display->fillRect(iconX + xx * scale, iconY + yy * scale, scale, scale);
-                    }
-                }
-            }
-
-        } else {
-            display->drawXbm(0, SCREEN_HEIGHT - connection_icon_height, connection_icon_width, connection_icon_height,
-                             connection_icon);
-        }
-    }
-}
-
 bool isAllowedPunctuation(char c)
 {
    const std::string allowed = ".,!?;:-_()[]{}'\"@#$/\\&+=%~^ ";
@@ -52,9 +52,6 @@ void drawRoundedHighlight(OLEDDisplay *display, int16_t x, int16_t y, int16_t w,
 void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const char *titleStr = "", bool force_no_invert = false,
                      bool show_date = false);

-// Shared battery/time/mail header
-void drawCommonFooter(OLEDDisplay *display, int16_t x, int16_t y);
-
 const int *getTextPositions(OLEDDisplay *display);

 bool isAllowedPunctuation(char c);
@@ -422,57 +422,7 @@ static LGFX *tft = nullptr;

 #elif defined(ST7789_CS)
 #include <LovyanGFX.hpp> // Graphics and font library for ST7735 driver chip
-#ifdef HELTEC_V4_TFT
-#include "chsc6x.h"
-#include "lgfx/v1/Touch.hpp"
-namespace lgfx
-{
-inline namespace v1
-{
-class TOUCH_CHSC6X : public ITouch
-{
-  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;
-    };

-    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;
-            tp[0].size = 1;
-            tp[0].id = 1;
-            return 1;
-        }
-        tp[0].size = 0;
-        return 0;
-    };
-
-    void wakeup(void) override{};
-    void sleep(void) override{};
-
-  private:
-    chsc6x *chsc6xTouch = nullptr;
-};
-} // namespace v1
-} // namespace lgfx
-#endif
 class LGFX : public lgfx::LGFX_Device
 {
    lgfx::Panel_ST7789 _panel_instance;
@@ -481,10 +431,6 @@ class LGFX : public lgfx::LGFX_Device
 #if HAS_TOUCHSCREEN
 #if defined(T_WATCH_S3) || defined(ELECROW)
    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 +464,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 = -1;       // Pin number where RST is connected  (-1 = disable)
+            cfg.pin_busy = -1;      // 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.
@@ -302,8 +302,6 @@ void drawDigitalClockFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int1
    display->drawString(startingHourMinuteTextX + timeStringWidth - xOffset, (display->getHeight() - hourMinuteTextY) - yOffset,
                        secondString);
 #endif
-
-    graphics::drawCommonFooter(display, x, y);
 }

 void drawBluetoothConnectedIcon(OLEDDisplay *display, int16_t x, int16_t y)
@@ -518,7 +516,6 @@ void drawAnalogClockFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16
        display->drawLine(centerX, centerY, secondX, secondY);
 #endif
    }
-    graphics::drawCommonFooter(display, x, y);
 }

 } // namespace ClockRenderer
@@ -3,7 +3,6 @@
 #include "../Screen.h"
 #include "DebugRenderer.h"
 #include "FSCommon.h"
-#include "MeshService.h"
 #include "NodeDB.h"
 #include "Throttle.h"
 #include "UIRenderer.h"
@@ -224,8 +223,6 @@ void drawFrameWiFi(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, i

    display->drawString(x, getTextPositions(display)[line++], "URL: http://meshtastic.local");

-    graphics::drawCommonFooter(display, x, y);
-
    /* Display a heartbeat pixel that blinks every time the frame is redrawn */
 #ifdef SHOW_REDRAWS
    if (heartbeat)
@@ -506,7 +503,6 @@ void drawLoRaFocused(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x,
    display->drawString(starting_position + chUtil_x + chutil_bar_width + extraoffset, getTextPositions(display)[line++],
                        chUtilPercentage);
 #endif
-    graphics::drawCommonFooter(display, x, y);
 }

 // ****************************
@@ -646,9 +642,10 @@ void drawSystemScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x
    int textWidth = display->getStringWidth(appversionstr);
    int nameX = (SCREEN_WIDTH - textWidth) / 2;

-    display->drawString(nameX, getTextPositions(display)[line++], appversionstr);
-
-    if (SCREEN_HEIGHT > 64 || (SCREEN_HEIGHT <= 64 && line <= 5)) { // Only show uptime if the screen can show it
+    display->drawString(nameX, getTextPositions(display)[line], appversionstr);
+#if !defined(M5STACK_UNITC6L)
+    if (SCREEN_HEIGHT > 64 || (SCREEN_HEIGHT <= 64 && line < 4)) { // Only show uptime if the screen can show it
+        line += 1;
        char uptimeStr[32] = "";
        uint32_t uptime = millis() / 1000;
        uint32_t days = uptime / 86400;
@@ -663,41 +660,9 @@ void drawSystemScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x
            snprintf(uptimeStr, sizeof(uptimeStr), " Uptime: %um", mins);
        textWidth = display->getStringWidth(uptimeStr);
        nameX = (SCREEN_WIDTH - textWidth) / 2;
-        display->drawString(nameX, getTextPositions(display)[line++], uptimeStr);
+        display->drawString(nameX, getTextPositions(display)[line], uptimeStr);
    }
-
-    if (SCREEN_HEIGHT > 64 || (SCREEN_HEIGHT <= 64 && line <= 5)) { // Only show API state if the screen can show it
-        char api_state[32] = "";
-        const char *clientWord = nullptr;
-
-        // Determine if narrow or wide screen
-        if (isHighResolution) {
-            clientWord = "Client";
-        } else {
-            clientWord = "App";
-        }
-        snprintf(api_state, sizeof(api_state), "No %ss Connected", clientWord);
-
-        if (service->api_state == service->STATE_BLE) {
-            snprintf(api_state, sizeof(api_state), "%s Connected (BLE)", clientWord);
-        } else if (service->api_state == service->STATE_WIFI) {
-            snprintf(api_state, sizeof(api_state), "%s Connected (WiFi)", clientWord);
-        } else if (service->api_state == service->STATE_SERIAL) {
-            snprintf(api_state, sizeof(api_state), "%s Connected (Serial)", clientWord);
-        } else if (service->api_state == service->STATE_PACKET) {
-            snprintf(api_state, sizeof(api_state), "%s Connected (Internal)", clientWord);
-        } else if (service->api_state == service->STATE_HTTP) {
-            snprintf(api_state, sizeof(api_state), "%s Connected (HTTP)", clientWord);
-        } else if (service->api_state == service->STATE_ETH) {
-            snprintf(api_state, sizeof(api_state), "%s Connected (Ethernet)", clientWord);
-        }
-        if (api_state[0] != '\0') {
-            display->drawString((SCREEN_WIDTH - display->getStringWidth(api_state)) / 2, getTextPositions(display)[line++],
-                                api_state);
-        }
-    }
-
-    graphics::drawCommonFooter(display, x, y);
+#endif
 }

 // ****************************
@@ -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;
@@ -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:
@@ -213,7 +213,6 @@ void drawTextMessageFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16
 #else
        display->drawString(center_text, getTextPositions(display)[2], messageString);
 #endif
-        graphics::drawCommonFooter(display, x, y);
        return;
    }

@@ -424,7 +423,6 @@ void drawTextMessageFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16
    // Draw header at the end to sort out overlapping elements
    graphics::drawCommonHeader(display, x, y, titleStr);
 #endif
-    graphics::drawCommonFooter(display, x, y);
 }

 std::vector<std::string> generateLines(OLEDDisplay *display, const char *headerStr, const char *messageBuf, int textWidth)
@@ -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) {
@@ -492,7 +505,6 @@ void drawNodeListScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t
 #endif
    const int scrollStartY = y + 3;
    drawScrollbar(display, visibleNodeRows, totalEntries, scrollIndex, 2, scrollStartY);
-    graphics::drawCommonFooter(display, x, y);
 }

 // =============================
@@ -552,7 +552,6 @@ void UIRenderer::drawNodeInfo(OLEDDisplay *display, const OLEDDisplayUiState *st
        // else show nothing
    }
 #endif
-    graphics::drawCommonFooter(display, x, y);
 }

 // ****************************
@@ -772,7 +771,6 @@ void UIRenderer::drawDeviceFocused(OLEDDisplay *display, OLEDDisplayUiState *sta
        display->drawString(nameX, getTextPositions(display)[line++], shortnameble);
    }
 #endif
-    graphics::drawCommonFooter(display, x, y);
 }

 // Start Functions to write date/time to the screen
@@ -1185,7 +1183,6 @@ void UIRenderer::drawCompassAndLocationScreen(OLEDDisplay *display, OLEDDisplayU
    }
 #endif
 #endif // HAS_GPS
-    graphics::drawCommonFooter(display, x, y);
 }

 #ifdef USERPREFS_OEM_TEXT
@@ -1270,13 +1267,7 @@ void UIRenderer::drawNavigationBar(OLEDDisplay *display, OLEDDisplayUiState *sta
    if (totalIcons == 0)
        return;

-    const int navPadding = isHighResolution ? 24 : 12; // padding per side
-
-    int usableWidth = SCREEN_WIDTH - (navPadding * 2);
-    if (usableWidth < iconSize)
-        usableWidth = iconSize;
-
-    const size_t iconsPerPage = usableWidth / (iconSize + spacing);
+    const size_t iconsPerPage = (SCREEN_WIDTH + spacing) / (iconSize + spacing);
    const size_t currentPage = currentFrame / iconsPerPage;
    const size_t pageStart = currentPage * iconsPerPage;
    const size_t pageEnd = min(pageStart + iconsPerPage, totalIcons);
@@ -1347,47 +1338,6 @@ void UIRenderer::drawNavigationBar(OLEDDisplay *display, OLEDDisplayUiState *sta
            display->setColor(WHITE);
        }
    }
-
-    // Compact arrow drawer
-    auto drawArrow = [&](bool rightSide) {
-        display->setColor(WHITE);
-
-        const int offset = isHighResolution ? 3 : 1;
-        const int halfH = rectHeight / 2;
-
-        const int top = (y - 2) + (rectHeight - halfH) / 2;
-        const int bottom = top + halfH - 1;
-        const int midY = top + (halfH / 2);
-
-        const int maxW = 4;
-
-        // Determine left X coordinate
-        int baseX = rightSide ? (rectX + rectWidth + offset) : // right arrow
-                        (rectX - offset - 1);                  // left arrow
-
-        for (int yy = top; yy <= bottom; yy++) {
-            int dist = abs(yy - midY);
-            int lineW = maxW - (dist * maxW / (halfH / 2));
-            if (lineW < 1)
-                lineW = 1;
-
-            if (rightSide) {
-                display->drawHorizontalLine(baseX, yy, lineW);
-            } else {
-                display->drawHorizontalLine(baseX - lineW + 1, yy, lineW);
-            }
-        }
-    };
-    // Right arrow
-    if (pageEnd < totalIcons) {
-        drawArrow(true);
-    }
-
-    // Left arrow
-    if (pageStart > 0) {
-        drawArrow(false);
-    }
-
    // Knock the corners off the square
    display->setColor(BLACK);
    display->drawRect(rectX, y - 2, 1, 1);
@@ -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
@@ -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
@@ -360,10 +360,6 @@ const uint8_t chirpy_hirez[] = {
 #define chirpy_small_image_height 8
 const uint8_t chirpy_small[] = {0x7f, 0x41, 0x55, 0x55, 0x55, 0x55, 0x41, 0x7f};

-#define connection_icon_width 7
-#define connection_icon_height 5
-const uint8_t connection_icon[] = {0x36, 0x41, 0x5D, 0x41, 0x36};
-
 #ifdef M5STACK_UNITC6L
 #include "img/icon_small.xbm"
 #else
@@ -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
@@ -1,7 +1,5 @@
 #include "InputBroker.h"
 #include "PowerFSM.h" // needed for event trigger
-#include "configuration.h"
-#include "modules/ExternalNotificationModule.h"

 InputBroker *inputBroker = nullptr;

@@ -50,12 +48,6 @@ void InputBroker::processInputEventQueue()
 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()) {
-        externalNotificationModule->stopNow();
-    }
-
    this->notifyObservers(event);
    return 0;
 }
@@ -57,7 +57,7 @@ static unsigned char TDeckProTapMap[_TCA8418_NUM_KEYS][5] = {
    {0x00, 0x00, 0x00},
    {0x00, 0x00, 0x00},
    {0x20, 0x00, 0x00},
-    {0x00, 0x00, '0'},
+    {0x00, 0x00, 0x00},
    {0x00, 0x00, 0x00} // R_Shift, sym, space, mic, L_Shift
 };

@@ -92,10 +92,10 @@ bool CryptoEngine::encryptCurve25519(uint32_t toNode, uint32_t fromNode, meshtas
        LOG_DEBUG("Node %d or their public_key not found", toNode);
        return false;
    }
-    if (!setDHPublicKey(remotePublic.bytes)) {
+    if (!crypto->setDHPublicKey(remotePublic.bytes)) {
        return false;
    }
-    hash(shared_key, 32);
+    crypto->hash(shared_key, 32);
    initNonce(fromNode, packetNum, extraNonceTmp);

    // Calculate the shared secret with the destination node and encrypt
@@ -134,10 +134,10 @@ bool CryptoEngine::decryptCurve25519(uint32_t fromNode, meshtastic_UserLite_publ
    }

    // Calculate the shared secret with the sending node and decrypt
-    if (!setDHPublicKey(remotePublic.bytes)) {
+    if (!crypto->setDHPublicKey(remotePublic.bytes)) {
        return false;
    }
-    hash(shared_key, 32);
+    crypto->hash(shared_key, 32);

    initNonce(fromNode, packetNum, extraNonce);
    printBytes("Attempt decrypt with nonce: ", nonce, 13);
@@ -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) {
@@ -79,18 +79,6 @@ class MeshService
    uint32_t oldFromNum = 0;

  public:
-    enum APIState {
-        STATE_DISCONNECTED, // Initial state, no API is connected
-        STATE_BLE,
-        STATE_WIFI,
-        STATE_SERIAL,
-        STATE_PACKET,
-        STATE_HTTP,
-        STATE_ETH
-    };
-
-    APIState api_state = STATE_DISCONNECTED;
-
    static bool isTextPayload(const meshtastic_MeshPacket *p)
    {
        if (moduleConfig.range_test.enabled && p->decoded.portnum == meshtastic_PortNum_RANGE_TEST_APP) {
@@ -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)) &&                                                                                                  \
    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
@@ -978,25 +984,12 @@ void NodeDB::installDefaultChannels()
    channelFile.version = DEVICESTATE_CUR_VER;
 }

-void NodeDB::resetNodes(bool keepFavorites)
+void NodeDB::resetNodes()
 {
    if (!config.position.fixed_position)
        clearLocalPosition();
    numMeshNodes = 1;
-    if (keepFavorites) {
-        LOG_INFO("Clearing node database - preserving favorites");
-        for (size_t i = 0; i < meshNodes->size(); i++) {
-            meshtastic_NodeInfoLite &node = meshNodes->at(i);
-            if (i > 0 && !node.is_favorite) {
-                node = meshtastic_NodeInfoLite();
-            } else {
-                numMeshNodes += 1;
-            }
-        };
-    } else {
-        LOG_INFO("Clearing node database - removing favorites");
-        std::fill(nodeDatabase.nodes.begin() + 1, nodeDatabase.nodes.end(), meshtastic_NodeInfoLite());
-    }
+    std::fill(nodeDatabase.nodes.begin() + 1, nodeDatabase.nodes.end(), meshtastic_NodeInfoLite());
    devicestate.has_rx_text_message = false;
    devicestate.has_rx_waypoint = false;
    saveNodeDatabaseToDisk();
@@ -1645,32 +1638,13 @@ void NodeDB::addFromContact(meshtastic_SharedContact contact)
        // If should_ignore is set,
        // we need to clear the public key and other cruft, in addition to setting the node as ignored
        info->is_ignored = true;
-        info->is_favorite = false;
        info->has_device_metrics = false;
        info->has_position = false;
        info->user.public_key.size = 0;
        info->user.public_key.bytes[0] = 0;
    } else {
-        /* Clients are sending add_contact before every text message DM (because clients may hold a larger node database with
-         * public keys than the radio holds). However, we don't want to update last_heard just because we sent someone a DM!
-         */
-
-        /* "Boring old nodes" are the first to be evicted out of the node database when full. This includes a newly-zeroed
-         * nodeinfo because it has: !is_favorite && last_heard==0. To keep this from happening when we addFromContact, we set the
-         * new node as a favorite, and we leave last_heard alone (even if it's zero).
-         */
-        if (config.device.role == meshtastic_Config_DeviceConfig_Role_CLIENT_BASE) {
-            // Special case for CLIENT_BASE: is_favorite has special meaning, and we don't want to automatically set it
-            // without the user doing so deliberately. We don't normally expect users to use a CLIENT_BASE to send DMs or to add
-            // contacts, but we should make sure it doesn't auto-favorite in case they do. Instead, as a workaround, we'll set
-            // last_heard to now, so that the add_contact node doesn't immediately get evicted.
-            info->last_heard = getTime();
-        } else {
-            // Normal case: set is_favorite to prevent expiration.
-            // last_heard will remain as-is (or remain 0 if this entry wasn't in the nodeDB).
-            info->is_favorite = true;
-        }
-
+        info->last_heard = getValidTime(RTCQualityNTP);
+        info->is_favorite = true;
        // As the clients will begin sending the contact with DMs, we want to strictly check if the node is manually verified
        if (contact.manually_verified) {
            info->bitfield |= NODEINFO_BITFIELD_IS_KEY_MANUALLY_VERIFIED_MASK;
@@ -229,8 +229,7 @@ class NodeDB
     */
    size_t getNumOnlineMeshNodes(bool localOnly = false);

-    void initConfigIntervals(), initModuleConfigIntervals(), resetNodes(bool keepFavorites = false),
-        removeNodeByNum(NodeNum nodeNum);
+    void initConfigIntervals(), initModuleConfigIntervals(), resetNodes(), removeNodeByNum(NodeNum nodeNum);

    bool factoryReset(bool eraseBleBonds = false);

@@ -87,18 +87,6 @@ void PhoneAPI::handleStartConfig()
 void PhoneAPI::close()
 {
    LOG_DEBUG("PhoneAPI::close()");
-    if (service->api_state == service->STATE_BLE && api_type == TYPE_BLE)
-        service->api_state = service->STATE_DISCONNECTED;
-    else if (service->api_state == service->STATE_WIFI && api_type == TYPE_WIFI)
-        service->api_state = service->STATE_DISCONNECTED;
-    else if (service->api_state == service->STATE_SERIAL && api_type == TYPE_SERIAL)
-        service->api_state = service->STATE_DISCONNECTED;
-    else if (service->api_state == service->STATE_PACKET && api_type == TYPE_PACKET)
-        service->api_state = service->STATE_DISCONNECTED;
-    else if (service->api_state == service->STATE_HTTP && api_type == TYPE_HTTP)
-        service->api_state = service->STATE_DISCONNECTED;
-    else if (service->api_state == service->STATE_ETH && api_type == TYPE_ETH)
-        service->api_state = service->STATE_DISCONNECTED;

    if (state != STATE_SEND_NOTHING) {
        state = STATE_SEND_NOTHING;
@@ -590,19 +578,6 @@ void PhoneAPI::sendConfigComplete()
    fromRadioScratch.config_complete_id = config_nonce;
    config_nonce = 0;
    state = STATE_SEND_PACKETS;
-    if (api_type == TYPE_BLE) {
-        service->api_state = service->STATE_BLE;
-    } else if (api_type == TYPE_WIFI) {
-        service->api_state = service->STATE_WIFI;
-    } else if (api_type == TYPE_SERIAL) {
-        service->api_state = service->STATE_SERIAL;
-    } else if (api_type == TYPE_PACKET) {
-        service->api_state = service->STATE_PACKET;
-    } else if (api_type == TYPE_HTTP) {
-        service->api_state = service->STATE_HTTP;
-    } else if (api_type == TYPE_ETH) {
-        service->api_state = service->STATE_ETH;
-    }

    // Allow subclasses to know we've entered steady-state so they can lower power consumption
    onConfigComplete();
@@ -167,18 +167,6 @@ class PhoneAPI
    /// begin a new connection
    void handleStartConfig();

-    enum APIType {
-        TYPE_NONE, // Initial state, don't send anything until the client starts asking for config
-        TYPE_BLE,
-        TYPE_WIFI,
-        TYPE_SERIAL,
-        TYPE_PACKET,
-        TYPE_HTTP,
-        TYPE_ETH
-    };
-
-    APIType api_type = TYPE_NONE;
-
  private:
    void releasePhonePacket();

@@ -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
     */
@@ -479,11 +479,6 @@ DecodeState perhapsDecode(meshtastic_MeshPacket *p)
                    LOG_ERROR("Invalid protobufs in received mesh packet id=0x%08x (bad psk?)!", p->id);
                } else if (decodedtmp.portnum == meshtastic_PortNum_UNKNOWN_APP) {
                    LOG_ERROR("Invalid portnum (bad psk?)!");
-#if !(MESHTASTIC_EXCLUDE_PKI)
-                } else if (!owner.is_licensed && isToUs(p) && decodedtmp.portnum == meshtastic_PortNum_TEXT_MESSAGE_APP) {
-                    LOG_WARN("Rejecting legacy DM");
-                    return DecodeState::DECODE_FAILURE;
-#endif
                } else {
                    p->decoded = decodedtmp;
                    p->which_payload_variant = meshtastic_MeshPacket_decoded_tag; // change type to decoded
@@ -19,7 +19,6 @@ PacketAPI *PacketAPI::create(PacketServer *_server)
 PacketAPI::PacketAPI(PacketServer *_server)
    : concurrency::OSThread("PacketAPI"), isConnected(false), programmingMode(false), server(_server)
 {
-    api_type = TYPE_PACKET;
 }

 int32_t PacketAPI::runOnce()
@@ -25,7 +25,6 @@ void deInitApiServer()

 WiFiServerAPI::WiFiServerAPI(WiFiClient &_client) : ServerAPI(_client)
 {
-    api_type = TYPE_WIFI;
    LOG_INFO("Incoming wifi connection");
 }

@@ -20,7 +20,6 @@ void initApiServer(int port)
 ethServerAPI::ethServerAPI(EthernetClient &_client) : ServerAPI(_client)
 {
    LOG_INFO("Incoming ethernet connection");
-    api_type = TYPE_ETH;
 }

 ethServerPort::ethServerPort(int port) : APIServerPort(port) {}
@@ -272,9 +272,8 @@ typedef struct _meshtastic_AdminMessage {
        int32_t shutdown_seconds;
        /* Tell the node to factory reset config; all device state and configuration will be returned to factory defaults; BLE bonds will be preserved. */
        int32_t factory_reset_config;
-        /* Tell the node to reset the nodedb.
-     When true, favorites are preserved through reset. */
-        bool nodedb_reset;
+        /* Tell the node to reset the nodedb. */
+        int32_t nodedb_reset;
    };
    /* The node generates this key and sends it with any get_x_response packets.
 The client MUST include the same key with any set_x commands. Key expires after 300 seconds.
@@ -460,7 +459,7 @@ X(a, STATIC,   ONEOF,    BOOL,     (payload_variant,exit_simulator,exit_simulato
 X(a, STATIC,   ONEOF,    INT32,    (payload_variant,reboot_seconds,reboot_seconds),  97) \
 X(a, STATIC,   ONEOF,    INT32,    (payload_variant,shutdown_seconds,shutdown_seconds),  98) \
 X(a, STATIC,   ONEOF,    INT32,    (payload_variant,factory_reset_config,factory_reset_config),  99) \
-X(a, STATIC,   ONEOF,    BOOL,     (payload_variant,nodedb_reset,nodedb_reset), 100) \
+X(a, STATIC,   ONEOF,    INT32,    (payload_variant,nodedb_reset,nodedb_reset), 100) \
 X(a, STATIC,   SINGULAR, BYTES,    session_passkey, 101)
 #define meshtastic_AdminMessage_CALLBACK NULL
 #define meshtastic_AdminMessage_DEFAULT NULL
@@ -284,10 +284,6 @@ typedef enum _meshtastic_HardwareModel {
    meshtastic_HardwareModel_T_WATCH_ULTRA = 114,
    /* Elecrow ThinkNode M3 */
    meshtastic_HardwareModel_THINKNODE_M3 = 115,
-    /* RAK WISMESH_TAP_V2 with ESP32-S3 CPU */
-    meshtastic_HardwareModel_WISMESH_TAP_V2 = 116,
-    /* RAK3401 */
-    meshtastic_HardwareModel_RAK3401 = 117,
    /* ------------------------------------------------------------------------------------------------------------------------------------------
 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.
 ------------------------------------------------------------------------------------------------------------------------------------------ */
@@ -26,7 +26,7 @@ class HttpAPI : public PhoneAPI
 {

  public:
-    HttpAPI() { api_type = TYPE_HTTP; }
+    // Nothing here yet

  private:
    // Nothing here yet
@@ -27,7 +27,7 @@ class HttpAPI : public PhoneAPI
 {

  public:
-    HttpAPI() { api_type = TYPE_HTTP; }
+    // Nothing here yet

  private:
    // Nothing here yet
@@ -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
@@ -104,18 +104,9 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta
            (config.security.admin_key[2].size == 32 &&
             memcmp(mp.public_key.bytes, config.security.admin_key[2].bytes, 32) == 0)) {
            LOG_INFO("PKC admin payload with authorized sender key");
-
-            // Automatically favorite the node that is using the admin key
            auto remoteNode = nodeDB->getMeshNode(mp.from);
            if (remoteNode && !remoteNode->is_favorite) {
-                if (config.device.role == meshtastic_Config_DeviceConfig_Role_CLIENT_BASE) {
-                    // Special case for CLIENT_BASE: is_favorite has special meaning, and we don't want to automatically set it
-                    // without the user doing so deliberately.
-                    LOG_INFO("PKC admin valid, but not auto-favoriting node %x because role==CLIENT_BASE", mp.from);
-                } else {
-                    LOG_INFO("PKC admin valid. Auto-favoriting node %x", mp.from);
-                    remoteNode->is_favorite = true;
-                }
+                remoteNode->is_favorite = true;
            }
        } else {
            myReply = allocErrorResponse(meshtastic_Routing_Error_ADMIN_PUBLIC_KEY_UNAUTHORIZED, &mp);
@@ -289,12 +280,7 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta
    case meshtastic_AdminMessage_nodedb_reset_tag: {
        disableBluetooth();
        LOG_INFO("Initiate node-db reset");
-        //  CLIENT_BASE, ROUTER and ROUTER_LATE are able to preserve the remaining hop count when relaying a packet via a
-        //  favorited node, so ensure that their favorites are kept on reset
-        bool rolePreference =
-            isOneOf(config.device.role, meshtastic_Config_DeviceConfig_Role_CLIENT_BASE,
-                    meshtastic_Config_DeviceConfig_Role_ROUTER, meshtastic_Config_DeviceConfig_Role_ROUTER_LATE);
-        nodeDB->resetNodes(rolePreference ? rolePreference : r->nodedb_reset);
+        nodeDB->resetNodes();
        reboot(DEFAULT_REBOOT_SECONDS);
        break;
    }
@@ -973,14 +973,8 @@ void CannedMessageModule::sendText(NodeNum dest, ChannelIndex channel, const cha
    LOG_INFO("Send message id=%u, dest=%x, msg=%.*s", p->id, p->to, p->decoded.payload.size, p->decoded.payload.bytes);

    if (p->to != 0xffffffff) {
-        // Only add as favorite if our role is NOT CLIENT_BASE
-        if (config.device.role != 12) {
-            LOG_INFO("Proactively adding %x as favorite node", p->to);
-            nodeDB->set_favorite(true, p->to);
-        } else {
-            LOG_DEBUG("Not favoriting node %x as we are CLIENT_BASE role", p->to);
-        }
-
+        LOG_INFO("Proactively adding %x as favorite node", p->to);
+        nodeDB->set_favorite(true, p->to);
        screen->setFrames(graphics::Screen::FOCUS_PRESERVE);
        p->pki_encrypted = true;
        p->channel = 0;
@@ -325,10 +325,6 @@ void ExternalNotificationModule::stopNow()
    drv.stop();
 #endif

-    // Prevent the state machine from immediately re-triggering outputs after a manual stop.
-    isNagging = false;
-    nagCycleCutoff = UINT32_MAX;
-
 #ifdef HAS_I2S
    // GPIO0 is used as mclk for I2S audio and set to OUTPUT by the sound library
    // T-Deck uses GPIO0 as trackball button, so restore the mode
@@ -65,22 +65,13 @@ 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)
-SerialModule::SerialModule() : StreamAPI(&Serial), concurrency::OSThread("Serial")
-{
-    api_type = TYPE_SERIAL;
-}
+SerialModule::SerialModule() : StreamAPI(&Serial), concurrency::OSThread("Serial") {}
 static Print *serialPrint = &Serial;
 #elif defined(CONFIG_IDF_TARGET_ESP32C6) || defined(RAK3172) || defined(EBYTE_E77_MBL)
-SerialModule::SerialModule() : StreamAPI(&Serial1), concurrency::OSThread("Serial")
-{
-    api_type = TYPE_SERIAL;
-}
+SerialModule::SerialModule() : StreamAPI(&Serial1), concurrency::OSThread("Serial") {}
 static Print *serialPrint = &Serial1;
 #else
-SerialModule::SerialModule() : StreamAPI(&Serial2), concurrency::OSThread("Serial")
-{
-    api_type = TYPE_SERIAL;
-}
+SerialModule::SerialModule() : StreamAPI(&Serial2), concurrency::OSThread("Serial") {}
 static Print *serialPrint = &Serial2;
 #endif

@@ -204,10 +204,6 @@ void StoreForwardModule::historyAdd(const meshtastic_MeshPacket &mp)
    this->packetHistory[this->packetHistoryTotalCount].payload_size = p.payload.size;
    this->packetHistory[this->packetHistoryTotalCount].rx_rssi = mp.rx_rssi;
    this->packetHistory[this->packetHistoryTotalCount].rx_snr = mp.rx_snr;
-    this->packetHistory[this->packetHistoryTotalCount].hop_start = mp.hop_start;
-    this->packetHistory[this->packetHistoryTotalCount].hop_limit = mp.hop_limit;
-    this->packetHistory[this->packetHistoryTotalCount].via_mqtt = mp.via_mqtt;
-    this->packetHistory[this->packetHistoryTotalCount].transport_mechanism = mp.transport_mechanism;
    memcpy(this->packetHistory[this->packetHistoryTotalCount].payload, p.payload.bytes, meshtastic_Constants_DATA_PAYLOAD_LEN);

    this->packetHistoryTotalCount++;
@@ -260,10 +256,6 @@ meshtastic_MeshPacket *StoreForwardModule::preparePayload(NodeNum dest, uint32_t
                p->decoded.emoji = (uint32_t)this->packetHistory[i].emoji;
                p->rx_rssi = this->packetHistory[i].rx_rssi;
                p->rx_snr = this->packetHistory[i].rx_snr;
-                p->hop_start = this->packetHistory[i].hop_start;
-                p->hop_limit = this->packetHistory[i].hop_limit;
-                p->via_mqtt = this->packetHistory[i].via_mqtt;
-                p->transport_mechanism = (meshtastic_MeshPacket_TransportMechanism)this->packetHistory[i].transport_mechanism;

                // Let's assume that if the server received the S&F request that the client is in range.
                //   TODO: Make this configurable.
@@ -21,10 +21,6 @@ struct PacketHistoryStruct {
    pb_size_t payload_size;
    int32_t rx_rssi;
    float rx_snr;
-    uint8_t hop_start;
-    uint8_t hop_limit;
-    bool via_mqtt;
-    uint8_t transport_mechanism;
 };

 class StoreForwardModule : private concurrency::OSThread, public ProtobufModule<meshtastic_StoreAndForward>
@@ -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();
@@ -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

@@ -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
 }
@@ -510,7 +517,6 @@ void EnvironmentTelemetryModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiSt

        currentY += rowHeight;
    }
-    graphics::drawCommonFooter(display, x, y);
 }
 #endif

@@ -165,7 +165,6 @@ void PowerTelemetryModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *s
    if (m.has_ch3_voltage || m.has_ch3_current) {
        drawLine("Ch3", m.ch3_voltage, m.ch3_current);
    }
-    graphics::drawCommonFooter(display, x, y);
 }
 #endif

@@ -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
@@ -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
@@ -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;
@@ -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;
 };
@@ -141,7 +141,6 @@ void PaxcounterModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state
    display->drawStringf(display->getWidth() / 2 + x, graphics::getTextPositions(display)[line++], buffer,
                         "WiFi: %d\nBLE: %d\nUptime: %ds", count_from_libpax.wifi_count, count_from_libpax.ble_count,
                         millis() / 1000);
-    graphics::drawCommonFooter(display, x, y);
 }
 #endif // HAS_SCREEN

@@ -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
@@ -157,7 +157,6 @@ void ICM20948Sensor::calibrate(uint16_t forSeconds)
 {
 #if !defined(MESHTASTIC_EXCLUDE_SCREEN) && HAS_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
@@ -296,4 +295,4 @@ bool ICM20948Singleton::setWakeOnMotion()
    return true;
 }

-#endif
+#endif
@@ -69,8 +69,7 @@ void MotionSensor::wakeScreen()
 {
    if (powerFSM.getState() == &stateDARK) {
        LOG_DEBUG("Motion wakeScreen detected");
-        if (config.display.wake_on_tap_or_motion)
-            powerFSM.trigger(EVENT_INPUT);
+        powerFSM.trigger(EVENT_INPUT);
    }
 }

@@ -88,4 +87,4 @@ void MotionSensor::buttonPress() {}

 #endif

-#endif
+#endif
@@ -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)
 {
@@ -60,27 +59,7 @@ inline void onReceiveProto(char *topic, byte *payload, size_t length)
        LOG_ERROR("Invalid MQTT service envelope, topic %s, len %u!", topic, length);
        return;
    }
-
    const meshtastic_Channel &ch = channels.getByName(e.channel_id);
-    // Find channel by channel_id and check downlink_enabled
-    if (!(strcmp(e.channel_id, "PKI") == 0 ||
-          (strcmp(e.channel_id, channels.getGlobalId(ch.index)) == 0 && ch.settings.downlink_enabled))) {
-        return;
-    }
-
-    bool anyChannelHasDownlink = false;
-    size_t numChan = channels.getNumChannels();
-    for (size_t i = 0; i < numChan; ++i) {
-        const auto &c = channels.getByIndex(i);
-        if (c.settings.downlink_enabled) {
-            anyChannelHasDownlink = true;
-            break;
-        }
-    }
-
-    if (strcmp(e.channel_id, "PKI") == 0 && !anyChannelHasDownlink) {
-        return;
-    }
    // Generate node ID from nodenum for comparison
    std::string nodeId = nodeDB->getNodeId();
    if (strcmp(e.gateway_id, nodeId.c_str()) == 0) {
@@ -98,6 +77,11 @@ inline void onReceiveProto(char *topic, byte *payload, size_t length)
        return;
    }

+    // Find channel by channel_id and check downlink_enabled
+    if (!(strcmp(e.channel_id, "PKI") == 0 ||
+          (strcmp(e.channel_id, channels.getGlobalId(ch.index)) == 0 && ch.settings.downlink_enabled))) {
+        return;
+    }
    LOG_INFO("Received MQTT topic %s, len=%u", topic, length);
    if (e.packet->hop_limit > HOP_MAX || e.packet->hop_start > HOP_MAX) {
        LOG_INFO("Invalid hop_limit(%u) or hop_start(%u)", e.packet->hop_limit, e.packet->hop_start);
@@ -321,10 +305,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 +492,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 +519,7 @@ void MQTT::reconnect()
            runASAP = true;
            reconnectCount = 0;
            isMqttServerAddressPrivate = isPrivateIpAddress(clientConnection->remoteIP());
-            isConnected = true;
+
            publishNodeInfo();
            sendSubscriptions();
        } else {
@@ -692,10 +673,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 +880,4 @@ void MQTT::perhapsReportToMap()

    // Update the last report time
    last_report_to_map = millis();
-}
+}
@@ -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;
@@ -119,7 +118,7 @@ class BluetoothPhoneAPI : public PhoneAPI, public concurrency::OSThread
    */

  public:
-    BluetoothPhoneAPI() : concurrency::OSThread("NimbleBluetooth") { api_type = TYPE_BLE; }
+    BluetoothPhoneAPI() : concurrency::OSThread("NimbleBluetooth") {}

    /* Packets from phone (BLE onWrite callback) */
    std::mutex fromPhoneMutex;
@@ -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()
@@ -191,8 +191,6 @@
 #define HW_VENDOR meshtastic_HardwareModel_CROWPANEL
 #elif defined(RAK3312)
 #define HW_VENDOR meshtastic_HardwareModel_RAK3312
-#elif defined(RAK_WISMESH_TAP_V2)
-#define HW_VENDOR meshtastic_HardwareModel_WISMESH_TAP_V2
 #elif defined(LINK_32)
 #define HW_VENDOR meshtastic_HardwareModel_LINK_32
 #elif defined(T_DECK_PRO)
@@ -48,9 +48,6 @@ class BluetoothPhoneAPI : public PhoneAPI

    /// Check the current underlying physical link to see if the client is currently connected
    virtual bool checkIsConnected() override { return Bluefruit.connected(connectionHandle); }
-
-  public:
-    BluetoothPhoneAPI() { api_type = TYPE_BLE; }
 };

 static BluetoothPhoneAPI *bluetoothPhoneAPI;
@@ -60,8 +60,6 @@
 // MAke sure all custom RAK4630 boards are defined before the generic RAK4630
 #elif defined(RAK4630)
 #define HW_VENDOR meshtastic_HardwareModel_RAK4631
-#elif defined(RAK3401)
-#define HW_VENDOR meshtastic_HardwareModel_RAK3401
 #elif defined(TTGO_T_ECHO)
 #define HW_VENDOR meshtastic_HardwareModel_T_ECHO
 #elif defined(T_ECHO_LITE)
@@ -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) {
@@ -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                                         "
 }
@@ -13,8 +13,8 @@ static const uint8_t LED_BUILTIN = 35;
 static const uint8_t TX = 43;
 static const uint8_t RX = 44;

-static const uint8_t SDA = 4;
-static const uint8_t SCL = 3;
+static const uint8_t SDA = 3;
+static const uint8_t SCL = 4;

 static const uint8_t SS = 8;
 static const uint8_t MOSI = 10;
@@ -1,4 +1,4 @@
-[heltec_v4_base] 
+[env:heltec-v4] 
 extends = esp32s3_base
 board = heltec_v4
 board_check = true
@@ -7,106 +7,3 @@ build_flags =
  ${esp32s3_base.build_flags}
  -D HELTEC_V4
  -I variants/esp32s3/heltec_v4
-lib_deps = 
-  ${esp32s3_base.lib_deps}
-
-
-[env:heltec-v4]
-extends = heltec_v4_base
-build_flags = 
-  ${heltec_v4_base.build_flags}
-  -D HELTEC_V4_OLED
-  -D USE_SSD1306 ; Heltec_v4 has an SSD1315 display (compatible with SSD1306 driver)
-  -D LED_PIN=35
-  -D RESET_OLED=21
-  -D I2C_SDA=17
-  -D I2C_SCL=18
-  -D I2C_SDA1=4
-  -D I2C_SCL1=3
-lib_deps = 
-  ${heltec_v4_base.lib_deps}
-
-[env:heltec-v4-tft]
-extends = heltec_v4_base
-build_flags = 
-  ${heltec_v4_base.build_flags} ;-Os
-  -D HELTEC_V4_TFT
-  -D I2C_SDA=4
-  -D I2C_SCL=3
-  -D I2C_SDA1=47
-  -D I2C_SCL1=48
-  -D PIN_BUTTON2=35
-  -D PIN_BUZZER=6
-  -D USE_PIN_BUZZER=PIN_BUZZER
-  -D CONFIG_ARDUHAL_LOG_COLORS
-  -D RADIOLIB_DEBUG_SPI=0
-  -D RADIOLIB_DEBUG_PROTOCOL=0
-  -D RADIOLIB_DEBUG_BASIC=0
-  -D RADIOLIB_VERBOSE_ASSERT=0
-  -D RADIOLIB_SPI_PARANOID=0
-  -D CONFIG_DISABLE_HAL_LOCKS=1
-  -D INPUTDRIVER_BUTTON_TYPE=0
-  -D HAS_SCREEN=1
-  -D HAS_TFT=1
-  -D RAM_SIZE=1560
-  -D LV_LVGL_H_INCLUDE_SIMPLE
-  -D LV_CONF_INCLUDE_SIMPLE
-  -D LV_COMP_CONF_INCLUDE_SIMPLE
-  -D LV_USE_SYSMON=0
-  -D LV_USE_PROFILER=0
-  -D LV_USE_PERF_MONITOR=0
-  -D LV_USE_MEM_MONITOR=0
-  -D LV_USE_LOG=0
-  -D LV_BUILD_TEST=0
-  -D USE_LOG_DEBUG
-  -D LOG_DEBUG_INC=\"DebugConfiguration.h\"
-  -D USE_PACKET_API
-  -D LGFX_DRIVER=LGFX_HELTEC_V4_TFT
-  -D GFX_DRIVER_INC=\"graphics/LGFX/LGFX_HELTEC_V4_TFT.h\"
-  -D VIEW_320x240
-  -D MAP_FULL_REDRAW
-  -D DISPLAY_SIZE=320x240 ; landscape mode
-  -D LGFX_PIN_SCK=17
-  -D LGFX_PIN_MOSI=33
-  -D LGFX_PIN_DC=16
-  -D LGFX_PIN_CS=15
-  -D LGFX_PIN_BL=21
-  -D LGFX_PIN_RST=18
-  -D CUSTOM_TOUCH_DRIVER
-  -D TOUCH_SDA_PIN=I2C_SDA1
-  -D TOUCH_SCL_PIN=I2C_SCL1
-  -D TOUCH_INT_PIN=-1  ;45
-  -D TOUCH_RST_PIN=44
-;base UI
-  -D TFT_CS=LGFX_PIN_CS
-  -D ST7789_CS=TFT_CS
-  -D ST7789_RS=LGFX_PIN_DC
-  -D ST7789_SDA=LGFX_PIN_MOSI 
-  -D ST7789_SCK=LGFX_PIN_SCK
-  -D ST7789_RESET=LGFX_PIN_RST
-  -D ST7789_MISO=-1
-  -D ST7789_BUSY=-1
-  -D ST7789_BL=LGFX_PIN_BL
-  -D ST7789_SPI_HOST=SPI3_HOST
-  -D TFT_BL=ST7789_BL
-  -D SPI_FREQUENCY=40000000
-  -D SPI_READ_FREQUENCY=4000000
-  -D TFT_HEIGHT=320
-  -D TFT_WIDTH=240
-  -D TFT_OFFSET_X=0
-  -D TFT_OFFSET_Y=0
-  -D TFT_OFFSET_ROTATION=0
-  -D SCREEN_ROTATE
-  -D SCREEN_TRANSITION_FRAMERATE=5
-  -D BRIGHTNESS_DEFAULT=130 ; Medium Low Brightness
-  -D HAS_TOUCHSCREEN=1
-  -D TOUCH_I2C_PORT=0
-  -D TOUCH_SLAVE_ADDRESS=0x2E
-  -D SCREEN_TOUCH_INT=TOUCH_INT_PIN
-  -D SCREEN_TOUCH_RST=TOUCH_RST_PIN
-
-lib_deps = ${heltec_v4_base.lib_deps}
-  ; ${device-ui_base.lib_deps}
-  lovyan03/LovyanGFX@1.2.0
-  https://github.com/Quency-D/chsc6x/archive/5cbead829d6b432a8d621ed1aafd4eb474fd4f27.zip
-  https://github.com/Quency-D/device-ui/archive/7c9870b8016641190b059bdd90fe16c1012a39eb.zip
@@ -1,3 +1,11 @@
+#define LED_PIN 35
+
+#define USE_SSD1306 // Heltec_v4 has an SSD1315 display (compatible with SSD1306 driver)
+
+#define RESET_OLED 21
+#define I2C_SDA 17 // I2C pins for this board
+#define I2C_SCL 18
+
 #define VEXT_ENABLE 36 // active low, powers the oled display and the lora antenna boost
 #define BUTTON_PIN 0

@@ -0,0 +1,11 @@
+#include "RadioLib.h"
+
+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, {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,
+};
@@ -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
@@ -18,7 +18,6 @@ build_flags = ${native_base.build_flags}
  !pkg-config --libs libulfius --silence-errors || :
  !pkg-config --libs openssl --silence-errors || :
  !pkg-config --cflags --libs sdl2 --silence-errors || :
-  !pkg-config --cflags --libs libbsd-overlay --silence-errors || :

 [env:native-tft]
 extends = native_base
@@ -44,7 +43,6 @@ build_flags = ${native_base.build_flags} -Os -lX11 -linput -lxkbcommon -ffunctio
  !pkg-config --libs libulfius --silence-errors || :
  !pkg-config --libs openssl --silence-errors || :
  !pkg-config --cflags --libs sdl2 --silence-errors || :
-  !pkg-config --cflags --libs libbsd-overlay --silence-errors || :
 build_src_filter =
  ${native_base.build_src_filter}

@@ -73,7 +71,6 @@ build_flags = ${native_base.build_flags} -Os -ffunction-sections -fdata-sections
  -D MAP_FULL_REDRAW
  !pkg-config --libs libulfius --silence-errors || :
  !pkg-config --libs openssl --silence-errors || :
-  !pkg-config --cflags --libs libbsd-overlay --silence-errors || :
 build_src_filter =
  ${native_base.build_src_filter}

@@ -106,7 +103,6 @@ build_flags = ${native_base.build_flags} -O0 -fsanitize=address -lX11 -linput -l
  -D VIEW_320x240
  !pkg-config --libs libulfius --silence-errors || :
  !pkg-config --libs openssl --silence-errors || :
-  !pkg-config --cflags --libs libbsd-overlay --silence-errors || :
 build_src_filter = ${env:native-tft.build_src_filter}

 [env:coverage]
@@ -1,16 +0,0 @@
-; Elecrow ThinkNode M4 (nRF52840 + LR1110)
-[env:thinknode_m4]
-extends = nrf52840_base
-board = ThinkNode-M4
-board_check = true
-debug_tool = jlink
-
-build_flags = ${nrf52840_base.build_flags}
-  -Ivariants/nrf52840/ELECROW-ThinkNode-M4
-  -DELECROW_ThinkNode_M4
-
-build_src_filter = ${nrf52_base.build_src_filter} +<../variants/nrf52840/ELECROW-ThinkNode-M4>
-lib_deps =
-  ${nrf52840_base.lib_deps}
-  lewisxhe/PCF8563_Library@^1.0.1
-
@@ -1,122 +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_M4_
-#define _VARIANT_ELECROW_THINKNODE_M4_
-
-/** Master clock frequency */
-#define VARIANT_MCK (64000000ul)
-
-#define USE_LFXO // Board uses 32 kHz crystal for LF domain
-
-/*----------------------------------------------------------------------------
- *        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)
-
-// LEDs
-#define PIN_LED1 (32 + 9) // P1.09, status LED (blue)
-#define PIN_LED2 -1
-#define PIN_LED3 -1
-
-#define LED_BUILTIN PIN_LED1
-#define LED_STATE_ON 0 // active-low LED drive
-
-// Buttons
-#define PIN_BUTTON1 (0 + 4) // P0.04 KEY input
-
-// USB / power detection
-#define EXT_PWR_DETECT (32 + 3) // P1.03 USB present sense
-
-// I2C bus
-#define WIRE_INTERFACES_COUNT 1
-#define PIN_WIRE_SDA (32 + 0) // P1.00 SDA1
-#define PIN_WIRE_SCL (32 + 5) // P1.05 SCL1
-
-// Analog pins
-#define PIN_A0 (2) // P0.02
-#define BATTERY_PIN PIN_A0
-#define BATTERY_SENSE_SAMPLES 30
-#define ADC_RESOLUTION 14
-#define BATTERY_SENSE_RESOLUTION_BITS 12
-#define BATTERY_SENSE_RESOLUTION 4096.0
-#define ADC_MULTIPLIER (2.00F)
-#undef AREF_VOLTAGE
-#define AREF_VOLTAGE 3.0
-#define VBAT_AR_INTERNAL AR_INTERNAL_3_0
-
-// GPS interface (L76K)
-#define HAS_GPS 1
-#define GPS_L76K
-#define GPS_BAUDRATE 9600
-#define PIN_GPS_REINIT (0 + 3)   // P0.03 GPS_RST
-#define PIN_GPS_STANDBY (0 + 28) // P0.28 GPS_STANDBY
-#define PIN_GPS_EN (32 + 11)     // P1.11 GPS_EN
-#define GPS_EN_ACTIVE HIGH
-#define GPS_TX_PIN (32 + 12) // P1.12 GPS_TX -> MCU RX
-#define GPS_RX_PIN (32 + 14) // P1.14 GPS_RX -> MCU TX
-#define PIN_SERIAL1_RX GPS_TX_PIN
-#define PIN_SERIAL1_TX GPS_RX_PIN
-#define GPS_THREAD_INTERVAL 50
-
-// LoRa (LR1110) SPI bus
-#define SPI_INTERFACES_COUNT 1
-#define PIN_SPI_MISO (0 + 8) // P0.08
-#define PIN_SPI_MOSI (0 + 7) // P0.07
-#define PIN_SPI_SCK (0 + 6)  // P0.06
-#define PIN_SPI_NSS (0 + 27) // P0.27
-
-#define LORA_CS PIN_SPI_NSS
-#define LORA_SCK PIN_SPI_SCK
-#define LORA_MISO PIN_SPI_MISO
-#define LORA_MOSI PIN_SPI_MOSI
-#define LORA_RESET (32 + 8) // P1.08 LR_NRESET
-#define LORA_DIO1 (0 + 24)  // P0.24 LR_DIO1 / IRQ
-#define LORA_DIO2 (0 + 26)  // P0.26 LR_BUSY (treated as DIO2)
-
-#define USE_LR1110
-#define LR1110_IRQ_PIN LORA_DIO1
-#define LR1110_NRESET_PIN LORA_RESET
-#define LR1110_BUSY_PIN LORA_DIO2
-#define LR1110_SPI_NSS_PIN LORA_CS
-#define LR1110_SPI_SCK_PIN LORA_SCK
-#define LR1110_SPI_MOSI_PIN LORA_MOSI
-#define LR1110_SPI_MISO_PIN LORA_MISO
-#define LR11X0_DIO3_TCXO_VOLTAGE 3.3f
-#define LR11X0_DIO_AS_RF_SWITCH
-
-// Peripheral power control
-#define PIN_POWER_EN (0 + 11) // P0.11 PERIPH_EN
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // _VARIANT_ELECROW_THINKNODE_M4_
@@ -4,9 +4,7 @@

 ## General

-The pinout is contained in the variant.h file, and a [generic schematic](./Schematic_Pro-Micro_Pinouts.pdf) is located in this directory.
-
-This variant is suitable for both TCXO and XTAL types of modules. The old XTAL variant has been removed to reduce confusion.
+The pinout is contained in the variant.h file, and a [generic schematic](./Schematic_Pro-Micro_Pinouts%202024-12-14.pdf) is located in this directory.

 ### Note on DIO2, RXEN, TXEN, and RF switching

@@ -19,13 +17,9 @@ Several modules require external switching between transmit (Tx) and receive (Rx
 RXEN is not required to be connected if the selected module already has internal RF switching, or if external RF switching logic is already applied.
 Also worth noting that the Seeed WIO SX1262 in particular only has RXEN exposed (marked RF_SW) and has the DIO2-TXEN link internally.

-## Making a node based on this variant
-
-Making your own node based on this design is straightforward. There are various open source and free to use PCB design files available, or you can solder wires directly from a module to the pro-micro.
-
 <details>

-<summary> < Click to expand > The table of known modules is at the bottom of the variant.h, and reproduced here for convenience. </summary>
+<summary> The table of known modules is at the bottom of the variant.h, and reproduced here for convenience. </summary>

 | Mfr          | Module           | TCXO | RF Switch | Notes                                 |
 | ------------ | ---------------- | ---- | --------- | ------------------------------------- |
@@ -40,7 +34,6 @@ Making your own node based on this design is straightforward. There are various
 | Waveshare    | Core1262-HF      | yes  | Ext       |                                       |
 | Waveshare    | LoRa Node Module | yes  | Int       |                                       |
 | Seeed        | Wio-SX1262       | yes  | Ext       | Cute! DIO2/TXEN are not exposed       |
-| Seeed        | Wio-LR1121       | yes  | Int       | LR1121, needs alternate rfswitch.h    |
 | AI-Thinker   | RA-02            | No   | Int       | SX1278 **433mhz band only**           |
 | RF Solutions | RFM95            | No   | Int       | Untested                              |
 | Ebyte        | E80-900M2213S    | Yes  | Int       | LR1121 radio                          |
@@ -79,10 +72,6 @@ The Semtech default, the values are (taken from [here](https://github.com/Lora-n

 <details>

-<summary> < Click to expand >
-	
-</summary>
-
 ```cpp
 	.rfswitch = {
 		.enable = LR11XX_SYSTEM_RFSW0_HIGH | LR11XX_SYSTEM_RFSW1_HIGH | LR11XX_SYSTEM_RFSW2_HIGH,
@@ -175,7 +175,6 @@ settings.
 | Waveshare    | Core1262-HF      | yes  | Ext       |                                       |
 | Waveshare    | LoRa Node Module | yes  | Int       |                                       |
 | Seeed        | Wio-SX1262       | yes  | Ext       | Cute! DIO2/TXEN are not exposed       |
-| Seeed        | Wio-LR1121       | yes  | Int       | LR1121, needs alternate rfswitch.h    |
 | AI-Thinker   | RA-02            | No   | Int       | SX1278 **433mhz band only**           |
 | RF Solutions | RFM95            | No   | Int       | Untested                              |
 | Ebyte        | E80-900M2213S    | Yes  | Int       | LR1121 radio                          |
@@ -0,0 +1,12 @@
+; Promicro + E22(0)-xxxMM / RA-01SH modules board variant - DIY - without TCXO
+[env:nrf52_promicro_diy_xtal]
+extends = nrf52840_base
+board = promicro-nrf52840
+board_level = extra
+build_flags = ${nrf52840_base.build_flags}
+  -I variants/nrf52840/diy/nrf52_promicro_diy_xtal
+  -D NRF52_PROMICRO_DIY
+build_src_filter = ${nrf52_base.build_src_filter} +<../variants/nrf52840/diy/nrf52_promicro_diy_xtal>
+lib_deps = 
+  ${nrf52840_base.lib_deps}
+debug_tool = jlink
@@ -24,24 +24,15 @@
 #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,
+    // 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()
 {
-#if (PIN_LED1 >= 0)
-    pinMode(PIN_LED1, OUTPUT);
-    ledOff(PIN_LED1);
-#endif
-#if (PIN_LED2 >= 0)
-    pinMode(PIN_LED2, OUTPUT);
-    ledOff(PIN_LED2);
-#endif
-#if (PIN_LED3 >= 0)
-    pinMode(PIN_LED3, OUTPUT);
-    ledOff(PIN_LED3);
-#endif
+    // 3V3 Power Rail
+    pinMode(PIN_3V3_EN, OUTPUT);
+    digitalWrite(PIN_3V3_EN, HIGH);
 }
@@ -0,0 +1,154 @@
+#ifndef _VARIANT_PROMICRO_DIY_
+#define _VARIANT_PROMICRO_DIY_
+
+/** Master clock frequency */
+#define VARIANT_MCK (64000000ul)
+
+// #define USE_LFXO // Board uses 32khz crystal for LF
+#define USE_LFRC // Board uses RC for LF
+
+#define PROMICRO_DIY_XTAL
+/*----------------------------------------------------------------------------
+ *        Headers
+ *----------------------------------------------------------------------------*/
+
+#include "WVariant.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+/*
+NRF52 PRO MICRO PIN ASSIGNMENT
+
+| Pin   | Function   |   | Pin     | Function    |
+|-------|------------|---|---------|-------------|
+| Gnd   |            |   | vbat    |             |
+| P0.06 | Serial2 RX |   | vbat    |             |
+| P0.08 | Serial2 TX |   | Gnd     |             |
+| Gnd   |            |   | reset   |             |
+| Gnd   |            |   | ext_vcc | *see 0.13   |
+| P0.17 | RXEN       |   | P0.31   | BATTERY_PIN |
+| P0.20 | GPS_RX     |   | P0.29   | BUSY        |
+| P0.22 | GPS_TX     |   | P0.02   | MISO        |
+| P0.24 | GPS_EN     |   | P1.15   | MOSI        |
+| P1.00 | BUTTON_PIN |   | P1.13   | CS          |
+| P0.11 | SCL        |   | P1.11   | SCK         |
+| P1.04 | SDA        |   | P0.10   | DIO1/IRQ    |
+| P1.06 | Free pin   |   | P0.09   | RESET       |
+|       |            |   |         |             |
+|       | Mid board  |   |         | Internal    |
+| P1.01 | Free pin   |   | 0.15    | LED         |
+| P1.02 | Free pin   |   | 0.13    | 3V3_EN      |
+| P1.07 | Free pin   |   |         |             |
+*/
+
+// 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)
+
+// Pin 13 enables 3.3V periphery. If the Lora module is on this pin, then it should stay enabled at all times.
+#define PIN_3V3_EN (0 + 13) // P0.13
+
+// Analog pins
+#define BATTERY_PIN (0 + 31) // P0.31 Battery ADC
+#define ADC_CHANNEL ADC1_GPIO4_CHANNEL
+#define ADC_RESOLUTION 14
+#define BATTERY_SENSE_RESOLUTION_BITS 12
+#define BATTERY_SENSE_RESOLUTION 4096.0
+// Definition of milliVolt per LSB => 3.0V ADC range and 12-bit ADC resolution = 3000mV/4096
+#define VBAT_MV_PER_LSB (0.73242188F)
+// Voltage divider value => 1.5M + 1M voltage divider on VBAT = (1.5M / (1M + 1.5M))
+#define VBAT_DIVIDER (0.6F)
+// Compensation factor for the VBAT divider
+#define VBAT_DIVIDER_COMP (1.73)
+// Fixed calculation of milliVolt from compensation value
+#define REAL_VBAT_MV_PER_LSB (VBAT_DIVIDER_COMP * VBAT_MV_PER_LSB)
+#undef AREF_VOLTAGE
+#define AREF_VOLTAGE 3.0
+#define VBAT_AR_INTERNAL AR_INTERNAL_3_0
+#define ADC_MULTIPLIER VBAT_DIVIDER_COMP // REAL_VBAT_MV_PER_LSB
+#define VBAT_RAW_TO_SCALED(x) (REAL_VBAT_MV_PER_LSB * x)
+
+// WIRE IC AND IIC PINS
+#define WIRE_INTERFACES_COUNT 1
+
+#define PIN_WIRE_SDA (32 + 4) // P1.04
+#define PIN_WIRE_SCL (0 + 11) // P0.11
+
+// LED
+#define PIN_LED1 (0 + 15) // P0.15
+#define LED_BUILTIN PIN_LED1
+// Actually red
+#define LED_BLUE PIN_LED1
+#define LED_STATE_ON 1 // State when LED is lit
+
+// Button
+#define BUTTON_PIN (32 + 0) // P1.00
+
+// GPS
+#define PIN_GPS_TX (0 + 22) // P0.22
+#define PIN_GPS_RX (0 + 20) // P0.20
+
+#define PIN_GPS_EN (0 + 24) // P0.24
+#define GPS_UBLOX
+// define GPS_DEBUG
+
+// UART interfaces
+#define PIN_SERIAL1_RX PIN_GPS_TX
+#define PIN_SERIAL1_TX PIN_GPS_RX
+
+#define PIN_SERIAL2_RX (0 + 6) // P0.06
+#define PIN_SERIAL2_TX (0 + 8) // P0.08
+
+// Serial interfaces
+#define SPI_INTERFACES_COUNT 1
+
+#define PIN_SPI_MISO (0 + 2)   // P0.02
+#define PIN_SPI_MOSI (32 + 15) // P1.15
+#define PIN_SPI_SCK (32 + 11)  // P1.11
+
+// LORA MODULES
+#define USE_LLCC68
+#define USE_SX1262
+// #define USE_RF95
+#define USE_SX1268
+
+// LORA CONFIG
+#define SX126X_CS (32 + 13)      // P1.13 FIXME - we really should define LORA_CS instead
+#define SX126X_DIO1 (0 + 10)     // P0.10 IRQ
+#define SX126X_DIO2_AS_RF_SWITCH // Note for E22 modules: DIO2 is not attached internally to TXEN for automatic TX/RX switching,
+                                 // so it needs connecting externally if it is used in this way
+#define SX126X_BUSY (0 + 29)     // P0.29
+#define SX126X_RESET (0 + 9)     // P0.09
+#define SX126X_RXEN (0 + 17)     // P0.17
+#define SX126X_TXEN RADIOLIB_NC  // Assuming that DIO2 is connected to TXEN pin. If not, TXEN must be connected.
+
+/*
+On the SX1262, DIO3 sets the voltage for an external TCXO, if one is present. If one is not present, then this should not be used.
+
+Ebyte
+e22-900mm22s has no TCXO
+e22-900m22s has TCXO
+e220-900mm22s has no TCXO, works with/without this definition, looks like DIO3 not connected at all
+
+AI-thinker
+RA-01SH does not have TCXO
+
+Waveshare
+Core1262 has TCXO
+
+*/
+// #define SX126X_DIO3_TCXO_VOLTAGE 1.8
+
+#ifdef __cplusplus
+}
+#endif
+
+/*----------------------------------------------------------------------------
+ *        Arduino objects - C++ only
+ *----------------------------------------------------------------------------*/
+
+#endif
@@ -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
@@ -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

@@ -1,4 +1,4 @@
 [VERSION]  
 major = 2
 minor = 7
-build = 15
+build = 13
Author	SHA1	Message	Date
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 horwoodandTom Fifield	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
pa0lin082andTom Fifield	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
shortwavesurfer2009andHarukiToreda	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