Remove banner notification, we display the icon immediately

* Reviews sometimes miss things, whoops
* Validation is hard - but this fixes it

.github/workflows/main_matrix.yml

@@ -240,6 +240,7 @@ jobs:
     needs: [build]
     steps:
       - uses: actions/checkout@v6
+        if: github.event_name == 'pull_request_target'
         with:
           filter: blob:none # means we download all the git history but none of the commit (except ones with checkout like the head)
           fetch-depth: 0
@@ -253,18 +254,24 @@ jobs:
         uses: actions/upload-artifact@v6
         id: upload-manifest
         with:
-          name: manifests-all
+          name: manifests-${{ github.sha }}
           overwrite: true
-          path: |
-            manifests-new/*.mt.json
+          path: manifests-new/*.mt.json
       - name: Find the merge base
+        if: github.event_name == 'pull_request_target'
         run: echo "MERGE_BASE=$(git merge-base "origin/$base" "$head")" >> $GITHUB_ENV
         env:
           base: ${{ github.base_ref }}
-          head: ${{ github.head_ref }}
+          head: ${{ github.sha }}
       - name: Download the old manifests
-        run: gh run download -R ${{ github.repository }} --commit ${{ env.MERGE_BASE }} --name manifests-all --dir manifest-old/
+        if: github.event_name == 'pull_request_target'
+        run: gh run download -R "$repo" --name "manifests-$merge_base" --dir manifest-old/
+        env:
+          GH_TOKEN: ${{ github.token }}
+          merge_base: ${{ env.MERGE_BASE }}
+          repo: ${{ github.repository }}
       - name: Do scan and post comment
+        if: github.event_name == 'pull_request_target'
         run: python3 bin/shame.py ${{ github.event.pull_request.number }} manifests-old/ manifests-new/
 
   release-artifacts:

.gitignore

@@ -41,3 +41,12 @@ src/mesh/raspihttp/private_key.pem
 
 # Ignore logo (set at build time with platformio-custom.py)
 data/boot/logo.*
+
+# pioarduino platform
+managed_components/*
+arduino-lib-builder*
+dependencies.lock
+idf_component.yml
+CMakeLists.txt
+sdkconfig.*
+.dummy/*

.trunk/trunk.yaml

@@ -9,9 +9,9 @@ plugins:
 lint:
   enabled:
     - checkov@3.2.495
-    - renovate@42.64.1
+    - renovate@42.66.8
     - prettier@3.7.4
-    - trufflehog@3.92.3
+    - trufflehog@3.92.4
     - yamllint@1.37.1
     - bandit@1.9.2
     - trivy@0.68.2

bin/build-nrf52.sh

@@ -21,13 +21,14 @@ rm -f $BUILDDIR/firmware*
 export APP_VERSION=$VERSION
 
 basename=firmware-$1-$VERSION
+ota_basename=${basename}-ota
 
 pio run --environment $1 -t mtjson # -v
 
 cp $BUILDDIR/$basename.elf $OUTDIR/$basename.elf
 
 echo "Copying NRF52 dfu (OTA) file"
-cp $BUILDDIR/$basename.zip $OUTDIR/$basename.zip
+cp $BUILDDIR/$basename.zip $OUTDIR/$ota_basename.zip
 
 echo "Copying NRF52 UF2 file"
 cp $BUILDDIR/$basename.uf2 $OUTDIR/$basename.uf2

bin/org.meshtastic.meshtasticd.metainfo.xml

@@ -87,9 +87,6 @@
   </screenshots>
 
   <releases>
-    <release version="2.7.18" date="2025-12-20">
-      <url type="details">https://github.com/meshtastic/firmware/releases?q=tag%3Av2.7.18</url>
-    </release>
     <release version="2.7.17" date="2025-11-28">
       <url type="details">https://github.com/meshtastic/firmware/releases?q=tag%3Av2.7.17</url>
     </release>

bin/platformio-custom.py

@@ -17,6 +17,8 @@ lfsbin = f"{progname.replace('firmware-', 'littlefs-')}.bin"
 
 def manifest_gather(source, target, env):
     out = []
+    board_platform = env.BoardConfig().get("platform")
+    needs_ota_suffix = board_platform == "nordicnrf52"
     check_paths = [
         progname,
         f"{progname}.elf",
@@ -32,8 +34,11 @@ def manifest_gather(source, target, env):
     for p in check_paths:
         f = env.File(env.subst(f"$BUILD_DIR/{p}"))
         if f.exists():
+            manifest_name = p
+            if needs_ota_suffix and p == f"{progname}.zip":
+                manifest_name = f"{progname}-ota.zip"
             d = {
-                "name": p,
+                "name": manifest_name,
                 "md5": f.get_content_hash(), # Returns MD5 hash
                 "bytes": f.get_size() # Returns file size in bytes
             }

debian/changelog

@@ -1,9 +1,3 @@
-meshtasticd (2.7.18.0) unstable; urgency=medium
-
-  * Version 2.7.18
-
- -- GitHub Actions <github-actions[bot]@users.noreply.github.com>  Sat, 20 Dec 2025 15:47:25 +0000
-
 meshtasticd (2.7.17.0) unstable; urgency=medium
 
   * Version 2.7.17

platformio.ini

@@ -64,7 +64,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/b34c6817c25d6faabb3a8a162b5d14fb75395433.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

src/MessageStore.cpp

@@ -0,0 +1,426 @@
+#include "configuration.h"
+#if HAS_SCREEN
+#include "FSCommon.h"
+#include "MessageStore.h"
+#include "NodeDB.h"
+#include "SPILock.h"
+#include "SafeFile.h"
+#include "gps/RTC.h"
+#include "graphics/draw/MessageRenderer.h"
+#include <cstring> // memcpy
+
+#ifndef MESSAGE_TEXT_POOL_SIZE
+#define MESSAGE_TEXT_POOL_SIZE (MAX_MESSAGES_SAVED * MAX_MESSAGE_SIZE)
+#endif
+
+// Global message text pool and state
+static char *g_messagePool = nullptr;
+static size_t g_poolWritePos = 0;
+
+// Reset pool (called on boot or clear)
+static inline void resetMessagePool()
+{
+    if (!g_messagePool) {
+        g_messagePool = static_cast<char *>(malloc(MESSAGE_TEXT_POOL_SIZE));
+        if (!g_messagePool) {
+            LOG_ERROR("MessageStore: Failed to allocate %d bytes for message pool", MESSAGE_TEXT_POOL_SIZE);
+            return;
+        }
+    }
+    g_poolWritePos = 0;
+    memset(g_messagePool, 0, MESSAGE_TEXT_POOL_SIZE);
+}
+
+// Allocate text in pool and return offset
+// If not enough space remains, wrap around (ring buffer style)
+static inline uint16_t storeTextInPool(const char *src, size_t len)
+{
+    if (len >= MAX_MESSAGE_SIZE)
+        len = MAX_MESSAGE_SIZE - 1;
+
+    // Wrap pool if out of space
+    if (g_poolWritePos + len + 1 >= MESSAGE_TEXT_POOL_SIZE) {
+        g_poolWritePos = 0;
+    }
+
+    uint16_t offset = g_poolWritePos;
+    memcpy(&g_messagePool[g_poolWritePos], src, len);
+    g_messagePool[g_poolWritePos + len] = '\0';
+    g_poolWritePos += (len + 1);
+    return offset;
+}
+
+// Retrieve a const pointer to message text by offset
+static inline const char *getTextFromPool(uint16_t offset)
+{
+    if (!g_messagePool || offset >= MESSAGE_TEXT_POOL_SIZE)
+        return "";
+    return &g_messagePool[offset];
+}
+
+// Helper: assign a timestamp (RTC if available, else boot-relative)
+static inline void assignTimestamp(StoredMessage &sm)
+{
+    uint32_t nowSecs = getValidTime(RTCQuality::RTCQualityDevice, true);
+    if (nowSecs) {
+        sm.timestamp = nowSecs;
+        sm.isBootRelative = false;
+    } else {
+        sm.timestamp = millis() / 1000;
+        sm.isBootRelative = true;
+    }
+}
+
+// Generic push with cap (used by live + persisted queues)
+template <typename T> static inline void pushWithLimit(std::deque<T> &queue, const T &msg)
+{
+    if (queue.size() >= MAX_MESSAGES_SAVED)
+        queue.pop_front();
+    queue.push_back(msg);
+}
+
+template <typename T> static inline void pushWithLimit(std::deque<T> &queue, T &&msg)
+{
+    if (queue.size() >= MAX_MESSAGES_SAVED)
+        queue.pop_front();
+    queue.emplace_back(std::move(msg));
+}
+
+MessageStore::MessageStore(const std::string &label)
+{
+    filename = "/Messages_" + label + ".msgs";
+    resetMessagePool(); // initialize text pool on boot
+}
+
+// Live message handling (RAM only)
+void MessageStore::addLiveMessage(StoredMessage &&msg)
+{
+    pushWithLimit(liveMessages, std::move(msg));
+}
+void MessageStore::addLiveMessage(const StoredMessage &msg)
+{
+    pushWithLimit(liveMessages, msg);
+}
+
+// Add from incoming/outgoing packet
+const StoredMessage &MessageStore::addFromPacket(const meshtastic_MeshPacket &packet)
+{
+    StoredMessage sm;
+    assignTimestamp(sm);
+    sm.channelIndex = packet.channel;
+
+    const char *payload = reinterpret_cast<const char *>(packet.decoded.payload.bytes);
+    size_t len = strnlen(payload, MAX_MESSAGE_SIZE - 1);
+    sm.textOffset = storeTextInPool(payload, len);
+    sm.textLength = len;
+
+    // Determine sender
+    uint32_t localNode = nodeDB->getNodeNum();
+    sm.sender = (packet.from == 0) ? localNode : packet.from;
+
+    sm.dest = packet.to;
+
+    bool isDM = (sm.dest != 0 && sm.dest != NODENUM_BROADCAST);
+
+    if (packet.from == 0) {
+        sm.type = isDM ? MessageType::DM_TO_US : MessageType::BROADCAST;
+        sm.ackStatus = AckStatus::NONE;
+    } else {
+        sm.type = isDM ? MessageType::DM_TO_US : MessageType::BROADCAST;
+        sm.ackStatus = AckStatus::ACKED;
+    }
+
+    addLiveMessage(sm);
+    return liveMessages.back();
+}
+
+// Outgoing/manual message
+void MessageStore::addFromString(uint32_t sender, uint8_t channelIndex, const std::string &text)
+{
+    StoredMessage sm;
+
+    // Always use our local time (helper handles RTC vs boot time)
+    assignTimestamp(sm);
+
+    sm.sender = sender;
+    sm.channelIndex = channelIndex;
+    sm.textOffset = storeTextInPool(text.c_str(), text.size());
+    sm.textLength = text.size();
+
+    // Use the provided destination
+    sm.dest = sender;
+    sm.type = MessageType::DM_TO_US;
+
+    // Outgoing messages always start with unknown ack status
+    sm.ackStatus = AckStatus::NONE;
+
+    addLiveMessage(sm);
+}
+
+#if ENABLE_MESSAGE_PERSISTENCE
+
+// Compact, fixed-size on-flash representation using offset + length
+struct __attribute__((packed)) StoredMessageRecord {
+    uint32_t timestamp;
+    uint32_t sender;
+    uint8_t channelIndex;
+    uint32_t dest;
+    uint8_t isBootRelative;
+    uint8_t ackStatus;           // static_cast<uint8_t>(AckStatus)
+    uint8_t type;                // static_cast<uint8_t>(MessageType)
+    uint16_t textLength;         // message length
+    char text[MAX_MESSAGE_SIZE]; // store actual text here
+};
+
+// Serialize one StoredMessage to flash
+static inline void writeMessageRecord(SafeFile &f, const StoredMessage &m)
+{
+    StoredMessageRecord rec = {};
+    rec.timestamp = m.timestamp;
+    rec.sender = m.sender;
+    rec.channelIndex = m.channelIndex;
+    rec.dest = m.dest;
+    rec.isBootRelative = m.isBootRelative;
+    rec.ackStatus = static_cast<uint8_t>(m.ackStatus);
+    rec.type = static_cast<uint8_t>(m.type);
+    rec.textLength = m.textLength;
+
+    // Copy the actual text into the record from RAM pool
+    const char *txt = getTextFromPool(m.textOffset);
+    strncpy(rec.text, txt, MAX_MESSAGE_SIZE - 1);
+    rec.text[MAX_MESSAGE_SIZE - 1] = '\0';
+
+    f.write(reinterpret_cast<const uint8_t *>(&rec), sizeof(rec));
+}
+
+// Deserialize one StoredMessage from flash; returns false on short read
+static inline bool readMessageRecord(File &f, StoredMessage &m)
+{
+    StoredMessageRecord rec = {};
+    if (f.readBytes(reinterpret_cast<char *>(&rec), sizeof(rec)) != sizeof(rec))
+        return false;
+
+    m.timestamp = rec.timestamp;
+    m.sender = rec.sender;
+    m.channelIndex = rec.channelIndex;
+    m.dest = rec.dest;
+    m.isBootRelative = rec.isBootRelative;
+    m.ackStatus = static_cast<AckStatus>(rec.ackStatus);
+    m.type = static_cast<MessageType>(rec.type);
+    m.textLength = rec.textLength;
+
+    // 💡 Re-store text into pool and update offset
+    m.textLength = strnlen(rec.text, MAX_MESSAGE_SIZE - 1);
+    m.textOffset = storeTextInPool(rec.text, m.textLength);
+
+    return true;
+}
+
+void MessageStore::saveToFlash()
+{
+#ifdef FSCom
+    // Ensure root exists
+    spiLock->lock();
+    FSCom.mkdir("/");
+    spiLock->unlock();
+
+    SafeFile f(filename.c_str(), false);
+
+    spiLock->lock();
+    uint8_t count = static_cast<uint8_t>(liveMessages.size());
+    if (count > MAX_MESSAGES_SAVED)
+        count = MAX_MESSAGES_SAVED;
+    f.write(&count, 1);
+
+    for (uint8_t i = 0; i < count; ++i) {
+        writeMessageRecord(f, liveMessages[i]);
+    }
+    spiLock->unlock();
+
+    f.close();
+#endif
+}
+
+void MessageStore::loadFromFlash()
+{
+    std::deque<StoredMessage>().swap(liveMessages);
+    resetMessagePool(); // reset pool when loading
+
+#ifdef FSCom
+    concurrency::LockGuard guard(spiLock);
+
+    if (!FSCom.exists(filename.c_str()))
+        return;
+
+    auto f = FSCom.open(filename.c_str(), FILE_O_READ);
+    if (!f)
+        return;
+
+    uint8_t count = 0;
+    f.readBytes(reinterpret_cast<char *>(&count), 1);
+    if (count > MAX_MESSAGES_SAVED)
+        count = MAX_MESSAGES_SAVED;
+
+    for (uint8_t i = 0; i < count; ++i) {
+        StoredMessage m;
+        if (!readMessageRecord(f, m))
+            break;
+        liveMessages.push_back(m);
+    }
+
+    f.close();
+#endif
+}
+
+#else
+// If persistence is disabled, these functions become no-ops
+void MessageStore::saveToFlash() {}
+void MessageStore::loadFromFlash() {}
+#endif
+
+// Clear all messages (RAM + persisted queue)
+void MessageStore::clearAllMessages()
+{
+    std::deque<StoredMessage>().swap(liveMessages);
+    resetMessagePool();
+
+#ifdef FSCom
+    SafeFile f(filename.c_str(), false);
+    uint8_t count = 0;
+    f.write(&count, 1); // write "0 messages"
+    f.close();
+#endif
+}
+
+// Internal helper: erase first or last message matching a predicate
+template <typename Predicate> static void eraseIf(std::deque<StoredMessage> &deque, Predicate pred, bool fromBack = false)
+{
+    if (fromBack) {
+        // Iterate from the back and erase all matches from the end
+        for (auto it = deque.rbegin(); it != deque.rend();) {
+            if (pred(*it)) {
+                it = std::deque<StoredMessage>::reverse_iterator(deque.erase(std::next(it).base()));
+            } else {
+                ++it;
+            }
+        }
+    } else {
+        // Manual forward search to erase all matches
+        for (auto it = deque.begin(); it != deque.end();) {
+            if (pred(*it)) {
+                it = deque.erase(it);
+            } else {
+                ++it;
+            }
+        }
+    }
+}
+
+// Delete oldest message (RAM + persisted queue)
+void MessageStore::deleteOldestMessage()
+{
+    eraseIf(liveMessages, [](StoredMessage &) { return true; });
+    saveToFlash();
+}
+
+// Delete oldest message in a specific channel
+void MessageStore::deleteOldestMessageInChannel(uint8_t channel)
+{
+    auto pred = [channel](const StoredMessage &m) { return m.type == MessageType::BROADCAST && m.channelIndex == channel; };
+    eraseIf(liveMessages, pred);
+    saveToFlash();
+}
+
+void MessageStore::deleteAllMessagesInChannel(uint8_t channel)
+{
+    auto pred = [channel](const StoredMessage &m) { return m.type == MessageType::BROADCAST && m.channelIndex == channel; };
+    eraseIf(liveMessages, pred, false /* delete ALL, not just first */);
+    saveToFlash();
+}
+
+void MessageStore::deleteAllMessagesWithPeer(uint32_t peer)
+{
+    uint32_t local = nodeDB->getNodeNum();
+    auto pred = [&](const StoredMessage &m) {
+        if (m.type != MessageType::DM_TO_US)
+            return false;
+        uint32_t other = (m.sender == local) ? m.dest : m.sender;
+        return other == peer;
+    };
+    eraseIf(liveMessages, pred, false);
+    saveToFlash();
+}
+
+// Delete oldest message in a direct chat with a node
+void MessageStore::deleteOldestMessageWithPeer(uint32_t peer)
+{
+    auto pred = [peer](const StoredMessage &m) {
+        if (m.type != MessageType::DM_TO_US)
+            return false;
+        uint32_t other = (m.sender == nodeDB->getNodeNum()) ? m.dest : m.sender;
+        return other == peer;
+    };
+    eraseIf(liveMessages, pred);
+    saveToFlash();
+}
+
+std::deque<StoredMessage> MessageStore::getChannelMessages(uint8_t channel) const
+{
+    std::deque<StoredMessage> result;
+    for (const auto &m : liveMessages) {
+        if (m.type == MessageType::BROADCAST && m.channelIndex == channel) {
+            result.push_back(m);
+        }
+    }
+    return result;
+}
+
+std::deque<StoredMessage> MessageStore::getDirectMessages() const
+{
+    std::deque<StoredMessage> result;
+    for (const auto &m : liveMessages) {
+        if (m.type == MessageType::DM_TO_US) {
+            result.push_back(m);
+        }
+    }
+    return result;
+}
+
+// Upgrade boot-relative timestamps once RTC is valid
+// Only same-boot boot-relative messages are healed.
+// Persisted boot-relative messages from old boots stay ??? forever.
+void MessageStore::upgradeBootRelativeTimestamps()
+{
+    uint32_t nowSecs = getValidTime(RTCQuality::RTCQualityDevice, true);
+    if (nowSecs == 0)
+        return; // Still no valid RTC
+
+    uint32_t bootNow = millis() / 1000;
+
+    auto fix = [&](std::deque<StoredMessage> &dq) {
+        for (auto &m : dq) {
+            if (m.isBootRelative && m.timestamp <= bootNow) {
+                uint32_t bootOffset = nowSecs - bootNow;
+                m.timestamp += bootOffset;
+                m.isBootRelative = false;
+            }
+        }
+    };
+    fix(liveMessages);
+}
+
+const char *MessageStore::getText(const StoredMessage &msg)
+{
+    // Wrapper around the internal helper
+    return getTextFromPool(msg.textOffset);
+}
+
+uint16_t MessageStore::storeText(const char *src, size_t len)
+{
+    // Wrapper around the internal helper
+    return storeTextInPool(src, len);
+}
+
+// Global definition
+MessageStore messageStore("default");
+#endif

src/MessageStore.h

@@ -0,0 +1,131 @@
+#pragma once
+
+#if HAS_SCREEN
+
+// Disable debug logging entirely on release builds of HELTEC_MESH_SOLAR for space constraints
+#if defined(HELTEC_MESH_SOLAR)
+#define LOG_DEBUG(...)
+#endif
+
+// Enable or disable message persistence (flash storage)
+// Define -DENABLE_MESSAGE_PERSISTENCE=0 in build_flags to disable it entirely
+#ifndef ENABLE_MESSAGE_PERSISTENCE
+#define ENABLE_MESSAGE_PERSISTENCE 1
+#endif
+
+#include "mesh/generated/meshtastic/mesh.pb.h"
+#include <cstdint>
+#include <deque>
+#include <string>
+
+// How many messages are stored (RAM + flash).
+// Define -DMESSAGE_HISTORY_LIMIT=N in build_flags to control memory usage.
+#ifndef MESSAGE_HISTORY_LIMIT
+#define MESSAGE_HISTORY_LIMIT 20
+#endif
+
+// Internal alias used everywhere in code – do NOT redefine elsewhere.
+#define MAX_MESSAGES_SAVED MESSAGE_HISTORY_LIMIT
+
+// Maximum text payload size per message in bytes.
+// This still defines the max message length, but we no longer reserve this space per message.
+#define MAX_MESSAGE_SIZE 220
+
+// Total shared text pool size for all messages combined.
+// The text pool is RAM-only. Text is re-stored from flash into the pool on boot.
+#ifndef MESSAGE_TEXT_POOL_SIZE
+#define MESSAGE_TEXT_POOL_SIZE (MAX_MESSAGES_SAVED * MAX_MESSAGE_SIZE)
+#endif
+
+// Explicit message classification
+enum class MessageType : uint8_t {
+    BROADCAST = 0, // broadcast message
+    DM_TO_US = 1   // direct message addressed to this node
+};
+
+// Delivery status for messages we sent
+enum class AckStatus : uint8_t {
+    NONE = 0,    // just sent, waiting (no symbol shown)
+    ACKED = 1,   // got a valid ACK from destination
+    NACKED = 2,  // explicitly failed
+    TIMEOUT = 3, // no ACK after retry window
+    RELAYED = 4  // got an ACK from relay, not destination
+};
+
+struct StoredMessage {
+    uint32_t timestamp;   // When message was created (secs since boot or RTC)
+    uint32_t sender;      // NodeNum of sender
+    uint8_t channelIndex; // Channel index used
+    uint32_t dest;        // Destination node (broadcast or direct)
+    MessageType type;     // Derived from dest (explicit classification)
+    bool isBootRelative;  // true = millis()/1000 fallback; false = epoch/RTC absolute
+    AckStatus ackStatus;  // Delivery status (only meaningful for our own sent messages)
+
+    // Text storage metadata — rebuilt from flash at boot
+    uint16_t textOffset; // Offset into global text pool (valid only after loadFromFlash())
+    uint16_t textLength; // Length of text in bytes
+
+    // Default constructor initializes all fields safely
+    StoredMessage()
+        : timestamp(0), sender(0), channelIndex(0), dest(0xffffffff), type(MessageType::BROADCAST), isBootRelative(false),
+          ackStatus(AckStatus::NONE), textOffset(0), textLength(0)
+    {
+    }
+};
+
+class MessageStore
+{
+  public:
+    explicit MessageStore(const std::string &label);
+
+    // Live RAM methods (always current, used by UI and runtime)
+    void addLiveMessage(StoredMessage &&msg);
+    void addLiveMessage(const StoredMessage &msg); // convenience overload
+    const std::deque<StoredMessage> &getLiveMessages() const { return liveMessages; }
+
+    // Add new messages from packets or manual input
+    const StoredMessage &addFromPacket(const meshtastic_MeshPacket &mp);                // Incoming/outgoing → RAM only
+    void addFromString(uint32_t sender, uint8_t channelIndex, const std::string &text); // Manual add
+
+    // Persistence methods (used only on boot/shutdown)
+    void saveToFlash();   // Save messages to flash
+    void loadFromFlash(); // Load messages from flash
+
+    // Clear all messages (RAM + persisted queue + text pool)
+    void clearAllMessages();
+
+    // Delete helpers
+    void deleteOldestMessage(); // remove oldest from RAM (and flash on save)
+    void deleteOldestMessageInChannel(uint8_t channel);
+    void deleteOldestMessageWithPeer(uint32_t peer);
+    void deleteAllMessagesInChannel(uint8_t channel);
+    void deleteAllMessagesWithPeer(uint32_t peer);
+
+    // Unified accessor (for UI code, defaults to RAM buffer)
+    const std::deque<StoredMessage> &getMessages() const { return liveMessages; }
+
+    // Helper filters for future use
+    std::deque<StoredMessage> getChannelMessages(uint8_t channel) const; // Only broadcast messages on a channel
+    std::deque<StoredMessage> getDirectMessages() const;                 // Only direct messages
+
+    // Upgrade boot-relative timestamps once RTC is valid
+    void upgradeBootRelativeTimestamps();
+
+    // Retrieve the C-string text for a stored message
+    static const char *getText(const StoredMessage &msg);
+
+    // Allocate text into pool (used by sender-side code)
+    static uint16_t storeText(const char *src, size_t len);
+
+    // Used when loading from flash to rebuild the text pool
+    static uint16_t rebuildTextFromFlash(const char *src, size_t len);
+
+  private:
+    std::deque<StoredMessage> liveMessages; // Single in-RAM message buffer (also used for persistence)
+    std::string filename;                   // Flash filename for persistence
+};
+
+// Global instance (defined in MessageStore.cpp)
+extern MessageStore messageStore;
+
+#endif

src/Power.cpp

@@ -11,6 +11,7 @@
  * For more information, see: https://meshtastic.org/
  */
 #include "power.h"
+#include "MessageStore.h"
 #include "NodeDB.h"
 #include "PowerFSM.h"
 #include "Throttle.h"
@@ -786,7 +787,9 @@ void Power::shutdown()
     playShutdownMelody();
 #endif
     nodeDB->saveToDisk();
-
+#if HAS_SCREEN
+    messageStore.saveToFlash();
+#endif
 #if defined(ARCH_NRF52) || defined(ARCH_ESP32) || defined(ARCH_RP2040)
 #ifdef PIN_LED1
     ledOff(PIN_LED1);

src/RedirectablePrint.cpp

@@ -131,6 +131,7 @@ void RedirectablePrint::log_to_serial(const char *logLevel, const char *format,
         int hour = hms / SEC_PER_HOUR;
         int min = (hms % SEC_PER_HOUR) / SEC_PER_MIN;
         int sec = (hms % SEC_PER_HOUR) % SEC_PER_MIN; // or hms % SEC_PER_MIN
+
 #ifdef ARCH_PORTDUINO
         ::printf("%s ", logLevel);
         if (color) {

src/graphics/Screen.cpp

@@ -46,6 +46,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #endif
 #include "FSCommon.h"
 #include "MeshService.h"
+#include "MessageStore.h"
 #include "RadioLibInterface.h"
 #include "error.h"
 #include "gps/GeoCoord.h"
@@ -64,10 +65,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "modules/WaypointModule.h"
 #include "sleep.h"
 #include "target_specific.h"
-
-using graphics::Emote;
-using graphics::emotes;
-using graphics::numEmotes;
+extern MessageStore messageStore;
 
 #if USE_TFTDISPLAY
 extern uint16_t TFT_MESH;
@@ -119,10 +117,6 @@ uint32_t dopThresholds[5] = {2000, 1000, 500, 200, 100};
 // we'll need to hold onto pointers for the modules that can draw a frame.
 std::vector<MeshModule *> moduleFrames;
 
-// Global variables for screen function overlay symbols
-std::vector<std::string> functionSymbol;
-std::string functionSymbolString;
-
 #if HAS_GPS
 // GeoCoord object for the screen
 GeoCoord geoCoord;
@@ -263,19 +257,11 @@ static void drawModuleFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int
     } else {
         // otherwise, just display the module frame that's aligned with the current frame
         module_frame = state->currentFrame;
-        // LOG_DEBUG("Screen is not in transition.  Frame: %d", module_frame);
     }
-    // LOG_DEBUG("Draw Module Frame %d", module_frame);
     MeshModule &pi = *moduleFrames.at(module_frame);
     pi.drawFrame(display, state, x, y);
 }
 
-// Ignore messages originating from phone (from the current node 0x0) unless range test or store and forward module are enabled
-static bool shouldDrawMessage(const meshtastic_MeshPacket *packet)
-{
-    return packet->from != 0 && !moduleConfig.store_forward.enabled;
-}
-
 /**
  * Given a recent lat/lon return a guess of the heading the user is walking on.
  *
@@ -322,16 +308,16 @@ Screen::Screen(ScanI2C::DeviceAddress address, meshtastic_Config_DisplayConfig_O
 {
     graphics::normalFrames = new FrameCallback[MAX_NUM_NODES + NUM_EXTRA_FRAMES];
 
-    LOG_INFO("Protobuf Value uiconfig.screen_rgb_color: %d", uiconfig.screen_rgb_color);
     int32_t rawRGB = uiconfig.screen_rgb_color;
-    if (rawRGB > 0 && rawRGB <= 255255255) {
-        uint8_t TFT_MESH_r = (rawRGB >> 16) & 0xFF;
-        uint8_t TFT_MESH_g = (rawRGB >> 8) & 0xFF;
-        uint8_t TFT_MESH_b = rawRGB & 0xFF;
-        LOG_INFO("Values of r,g,b: %d, %d, %d", TFT_MESH_r, TFT_MESH_g, TFT_MESH_b);
 
-        if (TFT_MESH_r <= 255 && TFT_MESH_g <= 255 && TFT_MESH_b <= 255) {
-            TFT_MESH = COLOR565(TFT_MESH_r, TFT_MESH_g, TFT_MESH_b);
+    // Only validate the combined value once
+    if (rawRGB > 0 && rawRGB <= 255255255) {
+        // Extract each component as a normal int first
+        int r = (rawRGB >> 16) & 0xFF;
+        int g = (rawRGB >> 8) & 0xFF;
+        int b = rawRGB & 0xFF;
+        if (r >= 0 && r <= 255 && g >= 0 && g <= 255 && b >= 0 && b <= 255) {
+            TFT_MESH = COLOR565(static_cast<uint8_t>(r), static_cast<uint8_t>(g), static_cast<uint8_t>(b));
         }
     }
 
@@ -550,10 +536,10 @@ void Screen::handleSetOn(bool on, FrameCallback einkScreensaver)
 void Screen::setup()
 {
 
-    // === Enable display rendering ===
+    // Enable display rendering
     useDisplay = true;
 
-    // === Load saved brightness from UI config ===
+    // Load saved brightness from UI config
     // For OLED displays (SSD1306), default brightness is 255 if not set
     if (uiconfig.screen_brightness == 0) {
 #if defined(USE_OLED) || defined(USE_SSD1306) || defined(USE_SH1106) || defined(USE_SH1107)
@@ -565,7 +551,7 @@ void Screen::setup()
         brightness = uiconfig.screen_brightness;
     }
 
-    // === Detect OLED subtype (if supported by board variant) ===
+    // Detect OLED subtype (if supported by board variant)
 #ifdef AutoOLEDWire_h
     if (isAUTOOled)
         static_cast<AutoOLEDWire *>(dispdev)->setDetected(model);
@@ -587,7 +573,7 @@ void Screen::setup()
     static_cast<ST7796Spi *>(dispdev)->setRGB(TFT_MESH);
 #endif
 
-    // === Initialize display and UI system ===
+    // Initialize display and UI system
     ui->init();
     displayWidth = dispdev->width();
     displayHeight = dispdev->height();
@@ -599,7 +585,7 @@ void Screen::setup()
     ui->disableAllIndicators();            // Disable page indicator dots
     ui->getUiState()->userData = this;     // Allow static callbacks to access Screen instance
 
-    // === Apply loaded brightness ===
+    // Apply loaded brightness
 #if defined(ST7789_CS)
     static_cast<TFTDisplay *>(dispdev)->setDisplayBrightness(brightness);
 #elif defined(USE_OLED) || defined(USE_SSD1306) || defined(USE_SH1106) || defined(USE_SH1107) || defined(USE_SPISSD1306)
@@ -607,20 +593,20 @@ void Screen::setup()
 #endif
     LOG_INFO("Applied screen brightness: %d", brightness);
 
-    // === Set custom overlay callbacks ===
+    // Set custom overlay callbacks
     static OverlayCallback overlays[] = {
         graphics::UIRenderer::drawNavigationBar // Custom indicator icons for each frame
     };
     ui->setOverlays(overlays, sizeof(overlays) / sizeof(overlays[0]));
 
-    // === Enable UTF-8 to display mapping ===
+    // Enable UTF-8 to display mapping
     dispdev->setFontTableLookupFunction(customFontTableLookup);
 
 #ifdef USERPREFS_OEM_TEXT
     logo_timeout *= 2; // Give more time for branded boot logos
 #endif
 
-    // === Configure alert frames (e.g., "Resuming..." or region name) ===
+    // Configure alert frames (e.g., "Resuming..." or region name)
     EINK_ADD_FRAMEFLAG(dispdev, DEMAND_FAST); // Skip slow refresh
     alertFrames[0] = [this](OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y) {
 #ifdef ARCH_ESP32
@@ -636,10 +622,10 @@ void Screen::setup()
     ui->setFrames(alertFrames, 1);
     ui->disableAutoTransition(); // Require manual navigation between frames
 
-    // === Log buffer for on-screen logs (3 lines max) ===
+    // Log buffer for on-screen logs (3 lines max)
     dispdev->setLogBuffer(3, 32);
 
-    // === Optional screen mirroring or flipping (e.g. for T-Beam orientation) ===
+    // Optional screen mirroring or flipping (e.g. for T-Beam orientation)
 #ifdef SCREEN_MIRROR
     dispdev->mirrorScreen();
 #else
@@ -657,7 +643,7 @@ void Screen::setup()
     }
 #endif
 
-    // === Generate device ID from MAC address ===
+    // Generate device ID from MAC address
     uint8_t dmac[6];
     getMacAddr(dmac);
     snprintf(screen->ourId, sizeof(screen->ourId), "%02x%02x", dmac[4], dmac[5]);
@@ -666,9 +652,9 @@ void Screen::setup()
     handleSetOn(false); // Ensure proper init for Arduino targets
 #endif
 
-    // === Turn on display and trigger first draw ===
+    //  Turn on display and trigger first draw
     handleSetOn(true);
-    determineResolution(dispdev->height(), dispdev->width());
+    graphics::currentResolution = graphics::determineScreenResolution(dispdev->height(), dispdev->width());
     ui->update();
 #ifndef USE_EINK
     ui->update(); // Some SSD1306 clones drop the first draw, so run twice
@@ -689,7 +675,7 @@ void Screen::setup()
     touchScreenImpl1->init();
 #endif
 
-    // === Subscribe to device status updates ===
+    // Subscribe to device status updates
     powerStatusObserver.observe(&powerStatus->onNewStatus);
     gpsStatusObserver.observe(&gpsStatus->onNewStatus);
     nodeStatusObserver.observe(&nodeStatus->onNewStatus);
@@ -697,12 +683,14 @@ void Screen::setup()
 #if !MESHTASTIC_EXCLUDE_ADMIN
     adminMessageObserver.observe(adminModule);
 #endif
-    if (textMessageModule)
-        textMessageObserver.observe(textMessageModule);
     if (inputBroker)
         inputObserver.observe(inputBroker);
 
-    // === Notify modules that support UI events ===
+    // Load persisted messages into RAM
+    messageStore.loadFromFlash();
+    LOG_INFO("MessageStore loaded from flash");
+
+    // Notify modules that support UI events
     MeshModule::observeUIEvents(&uiFrameEventObserver);
 }
 
@@ -773,6 +761,23 @@ int32_t Screen::runOnce()
     if (displayHeight == 0) {
         displayHeight = dispdev->getHeight();
     }
+
+    // Detect frame transitions and clear message cache when leaving text message screen
+    {
+        static int8_t lastFrameIndex = -1;
+        int8_t currentFrameIndex = ui->getUiState()->currentFrame;
+        int8_t textMsgIndex = framesetInfo.positions.textMessage;
+
+        if (lastFrameIndex != -1 && currentFrameIndex != lastFrameIndex) {
+
+            if (lastFrameIndex == textMsgIndex && currentFrameIndex != textMsgIndex) {
+                graphics::MessageRenderer::clearMessageCache();
+            }
+        }
+
+        lastFrameIndex = currentFrameIndex;
+    }
+
     menuHandler::handleMenuSwitch(dispdev);
 
     // Show boot screen for first logo_timeout seconds, then switch to normal operation.
@@ -828,17 +833,17 @@ int32_t Screen::runOnce()
             break;
         case Cmd::ON_PRESS:
             if (NotificationRenderer::current_notification_type != notificationTypeEnum::text_input) {
-                handleOnPress();
+                showFrame(FrameDirection::NEXT);
             }
             break;
         case Cmd::SHOW_PREV_FRAME:
             if (NotificationRenderer::current_notification_type != notificationTypeEnum::text_input) {
-                handleShowPrevFrame();
+                showFrame(FrameDirection::PREVIOUS);
             }
             break;
         case Cmd::SHOW_NEXT_FRAME:
             if (NotificationRenderer::current_notification_type != notificationTypeEnum::text_input) {
-                handleShowNextFrame();
+                showFrame(FrameDirection::NEXT);
             }
             break;
         case Cmd::START_ALERT_FRAME: {
@@ -859,6 +864,7 @@ int32_t Screen::runOnce()
             break;
         case Cmd::STOP_ALERT_FRAME:
             NotificationRenderer::pauseBanner = false;
+            break;
         case Cmd::STOP_BOOT_SCREEN:
             EINK_ADD_FRAMEFLAG(dispdev, COSMETIC); // E-Ink: Explicitly use full-refresh for next frame
             if (NotificationRenderer::current_notification_type != notificationTypeEnum::text_input) {
@@ -1029,9 +1035,6 @@ void Screen::setFrames(FrameFocus focus)
     }
 #endif
 
-    // Declare this early so it’s available in FOCUS_PRESERVE block
-    bool willInsertTextMessage = shouldDrawMessage(&devicestate.rx_text_message);
-
     if (!hiddenFrames.home) {
         fsi.positions.home = numframes;
         normalFrames[numframes++] = graphics::UIRenderer::drawDeviceFocused;
@@ -1043,11 +1046,16 @@ void Screen::setFrames(FrameFocus focus)
     indicatorIcons.push_back(icon_mail);
 
 #ifndef USE_EINK
-    if (!hiddenFrames.nodelist) {
-        fsi.positions.nodelist = numframes;
-        normalFrames[numframes++] = graphics::NodeListRenderer::drawDynamicNodeListScreen;
+    if (!hiddenFrames.nodelist_nodes) {
+        fsi.positions.nodelist_nodes = numframes;
+        normalFrames[numframes++] = graphics::NodeListRenderer::drawDynamicListScreen_Nodes;
         indicatorIcons.push_back(icon_nodes);
     }
+    if (!hiddenFrames.nodelist_location) {
+        fsi.positions.nodelist_location = numframes;
+        normalFrames[numframes++] = graphics::NodeListRenderer::drawDynamicListScreen_Location;
+        indicatorIcons.push_back(icon_list);
+    }
 #endif
 
 // Show detailed node views only on E-Ink builds
@@ -1069,11 +1077,13 @@ void Screen::setFrames(FrameFocus focus)
     }
 #endif
 #if HAS_GPS
+#ifdef USE_EINK
     if (!hiddenFrames.nodelist_bearings) {
         fsi.positions.nodelist_bearings = numframes;
         normalFrames[numframes++] = graphics::NodeListRenderer::drawNodeListWithCompasses;
         indicatorIcons.push_back(icon_list);
     }
+#endif
     if (!hiddenFrames.gps) {
         fsi.positions.gps = numframes;
         normalFrames[numframes++] = graphics::UIRenderer::drawCompassAndLocationScreen;
@@ -1173,7 +1183,7 @@ void Screen::setFrames(FrameFocus focus)
     }
 
     fsi.frameCount = numframes;   // Total framecount is used to apply FOCUS_PRESERVE
-    this->frameCount = numframes; // ✅ Save frame count for use in custom overlay
+    this->frameCount = numframes; // Save frame count for use in custom overlay
     LOG_DEBUG("Finished build frames. numframes: %d", numframes);
 
     ui->setFrames(normalFrames, numframes);
@@ -1193,10 +1203,6 @@ void Screen::setFrames(FrameFocus focus)
     case FOCUS_FAULT:
         ui->switchToFrame(fsi.positions.fault);
         break;
-    case FOCUS_TEXTMESSAGE:
-        hasUnreadMessage = false; // ✅ Clear when message is *viewed*
-        ui->switchToFrame(fsi.positions.textMessage);
-        break;
     case FOCUS_MODULE:
         // Whichever frame was marked by MeshModule::requestFocus(), if any
         // If no module requested focus, will show the first frame instead
@@ -1239,8 +1245,11 @@ void Screen::setFrameImmediateDraw(FrameCallback *drawFrames)
 void Screen::toggleFrameVisibility(const std::string &frameName)
 {
 #ifndef USE_EINK
-    if (frameName == "nodelist") {
-        hiddenFrames.nodelist = !hiddenFrames.nodelist;
+    if (frameName == "nodelist_nodes") {
+        hiddenFrames.nodelist_nodes = !hiddenFrames.nodelist_nodes;
+    }
+    if (frameName == "nodelist_location") {
+        hiddenFrames.nodelist_location = !hiddenFrames.nodelist_location;
     }
 #endif
 #ifdef USE_EINK
@@ -1255,9 +1264,11 @@ void Screen::toggleFrameVisibility(const std::string &frameName)
     }
 #endif
 #if HAS_GPS
+#ifdef USE_EINK
     if (frameName == "nodelist_bearings") {
         hiddenFrames.nodelist_bearings = !hiddenFrames.nodelist_bearings;
     }
+#endif
     if (frameName == "gps") {
         hiddenFrames.gps = !hiddenFrames.gps;
     }
@@ -1279,8 +1290,10 @@ void Screen::toggleFrameVisibility(const std::string &frameName)
 bool Screen::isFrameHidden(const std::string &frameName) const
 {
 #ifndef USE_EINK
-    if (frameName == "nodelist")
-        return hiddenFrames.nodelist;
+    if (frameName == "nodelist_nodes")
+        return hiddenFrames.nodelist_nodes;
+    if (frameName == "nodelist_location")
+        return hiddenFrames.nodelist_location;
 #endif
 #ifdef USE_EINK
     if (frameName == "nodelist_lastheard")
@@ -1291,8 +1304,10 @@ bool Screen::isFrameHidden(const std::string &frameName) const
         return hiddenFrames.nodelist_distance;
 #endif
 #if HAS_GPS
+#ifdef USE_EINK
     if (frameName == "nodelist_bearings")
         return hiddenFrames.nodelist_bearings;
+#endif
     if (frameName == "gps")
         return hiddenFrames.gps;
 #endif
@@ -1308,37 +1323,6 @@ bool Screen::isFrameHidden(const std::string &frameName) const
     return false;
 }
 
-// Dismisses the currently displayed screen frame, if possible
-// Relevant for text message, waypoint, others in future?
-// Triggered with a CardKB keycombo
-void Screen::hideCurrentFrame()
-{
-    uint8_t currentFrame = ui->getUiState()->currentFrame;
-    bool dismissed = false;
-    if (currentFrame == framesetInfo.positions.textMessage && devicestate.has_rx_text_message) {
-        LOG_INFO("Hide Text Message");
-        devicestate.has_rx_text_message = false;
-        memset(&devicestate.rx_text_message, 0, sizeof(devicestate.rx_text_message));
-    } else if (currentFrame == framesetInfo.positions.waypoint && devicestate.has_rx_waypoint) {
-        LOG_DEBUG("Hide Waypoint");
-        devicestate.has_rx_waypoint = false;
-        hiddenFrames.waypoint = true;
-        dismissed = true;
-    } else if (currentFrame == framesetInfo.positions.wifi) {
-        LOG_DEBUG("Hide WiFi Screen");
-        hiddenFrames.wifi = true;
-        dismissed = true;
-    } else if (currentFrame == framesetInfo.positions.lora) {
-        LOG_INFO("Hide LoRa");
-        hiddenFrames.lora = true;
-        dismissed = true;
-    }
-
-    if (dismissed) {
-        setFrames(FOCUS_DEFAULT); // You could also use FOCUS_PRESERVE
-    }
-}
-
 void Screen::handleStartFirmwareUpdateScreen()
 {
     LOG_DEBUG("Show firmware screen");
@@ -1391,28 +1375,6 @@ void Screen::decreaseBrightness()
     /* TO DO: add little popup in center of screen saying what brightness level it is set to*/
 }
 
-void Screen::setFunctionSymbol(std::string sym)
-{
-    if (std::find(functionSymbol.begin(), functionSymbol.end(), sym) == functionSymbol.end()) {
-        functionSymbol.push_back(sym);
-        functionSymbolString = "";
-        for (auto symbol : functionSymbol) {
-            functionSymbolString = symbol + " " + functionSymbolString;
-        }
-        setFastFramerate();
-    }
-}
-
-void Screen::removeFunctionSymbol(std::string sym)
-{
-    functionSymbol.erase(std::remove(functionSymbol.begin(), functionSymbol.end(), sym), functionSymbol.end());
-    functionSymbolString = "";
-    for (auto symbol : functionSymbol) {
-        functionSymbolString = symbol + " " + functionSymbolString;
-    }
-    setFastFramerate();
-}
-
 void Screen::handleOnPress()
 {
     // If screen was off, just wake it, otherwise advance to next frame
@@ -1424,23 +1386,17 @@ void Screen::handleOnPress()
     }
 }
 
-void Screen::handleShowPrevFrame()
+void Screen::showFrame(FrameDirection direction)
 {
-    // If screen was off, just wake it, otherwise go back to previous frame
-    // If we are in a transition, the press must have bounced, drop it.
+    // Only advance frames when UI is stable
     if (ui->getUiState()->frameState == FIXED) {
-        ui->previousFrame();
-        lastScreenTransition = millis();
-        setFastFramerate();
-    }
-}
 
-void Screen::handleShowNextFrame()
-{
-    // If screen was off, just wake it, otherwise advance to next frame
-    // If we are in a transition, the press must have bounced, drop it.
-    if (ui->getUiState()->frameState == FIXED) {
-        ui->nextFrame();
+        if (direction == FrameDirection::NEXT) {
+            ui->nextFrame();
+        } else {
+            ui->previousFrame();
+        }
+
         lastScreenTransition = millis();
         setFastFramerate();
     }
@@ -1466,7 +1422,6 @@ void Screen::setFastFramerate()
 
 int Screen::handleStatusUpdate(const meshtastic::Status *arg)
 {
-    // LOG_DEBUG("Screen got status update %d", arg->getStatusType());
     switch (arg->getStatusType()) {
     case STATUS_TYPE_NODE:
         if (showingNormalScreen && nodeStatus->getLastNumTotal() != nodeStatus->getNumTotal()) {
@@ -1584,11 +1539,11 @@ int Screen::handleTextMessage(const meshtastic_MeshPacket *packet)
                     screen->showSimpleBanner(banner, 3000);
                 } else if (!channel.settings.has_module_settings || !channel.settings.module_settings.is_muted) {
                     if (longName && longName[0]) {
-#if defined(M5STACK_UNITC6L)
-                        strcpy(banner, "New Message");
-#else
-                        snprintf(banner, sizeof(banner), "New Message from\n%s", longName);
-#endif
+                        if (currentResolution == ScreenResolution::UltraLow) {
+                            strcpy(banner, "New Message");
+                        } else {
+                            snprintf(banner, sizeof(banner), "New Message from\n%s", longName);
+                        }
                     } else {
                         strcpy(banner, "New Message");
                     }
@@ -1624,16 +1579,26 @@ int Screen::handleUIFrameEvent(const UIFrameEvent *event)
 
     if (showingNormalScreen) {
         // Regenerate the frameset, potentially honoring a module's internal requestFocus() call
-        if (event->action == UIFrameEvent::Action::REGENERATE_FRAMESET)
+        if (event->action == UIFrameEvent::Action::REGENERATE_FRAMESET) {
             setFrames(FOCUS_MODULE);
+        }
 
-        // Regenerate the frameset, while Attempt to maintain focus on the current frame
-        else if (event->action == UIFrameEvent::Action::REGENERATE_FRAMESET_BACKGROUND)
+        // Regenerate the frameset, while attempting to maintain focus on the current frame
+        else if (event->action == UIFrameEvent::Action::REGENERATE_FRAMESET_BACKGROUND) {
             setFrames(FOCUS_PRESERVE);
+        }
 
         // Don't regenerate the frameset, just re-draw whatever is on screen ASAP
-        else if (event->action == UIFrameEvent::Action::REDRAW_ONLY)
+        else if (event->action == UIFrameEvent::Action::REDRAW_ONLY) {
             setFastFramerate();
+        }
+
+        // Jump directly to the Text Message screen
+        else if (event->action == UIFrameEvent::Action::SWITCH_TO_TEXTMESSAGE) {
+            setFrames(FOCUS_PRESERVE); // preserve current frame ordering
+            ui->switchToFrame(framesetInfo.positions.textMessage);
+            setFastFramerate(); // force redraw ASAP
+        }
     }
 
     return 0;
@@ -1671,7 +1636,48 @@ int Screen::handleInputEvent(const InputEvent *event)
         menuHandler::handleMenuSwitch(dispdev);
         return 0;
     }
+    // UP/DOWN in message screen scrolls through message threads
+    if (ui->getUiState()->currentFrame == framesetInfo.positions.textMessage) {
 
+        if (event->inputEvent == INPUT_BROKER_UP) {
+            if (messageStore.getMessages().empty()) {
+                cannedMessageModule->LaunchWithDestination(NODENUM_BROADCAST);
+            } else {
+                graphics::MessageRenderer::scrollUp();
+                setFastFramerate(); // match existing behavior
+                return 0;
+            }
+        }
+
+        if (event->inputEvent == INPUT_BROKER_DOWN) {
+            if (messageStore.getMessages().empty()) {
+                cannedMessageModule->LaunchWithDestination(NODENUM_BROADCAST);
+            } else {
+                graphics::MessageRenderer::scrollDown();
+                setFastFramerate();
+                return 0;
+            }
+        }
+    }
+    // UP/DOWN in node list screens scrolls through node pages
+    if (ui->getUiState()->currentFrame == framesetInfo.positions.nodelist_nodes ||
+        ui->getUiState()->currentFrame == framesetInfo.positions.nodelist_location ||
+        ui->getUiState()->currentFrame == framesetInfo.positions.nodelist_lastheard ||
+        ui->getUiState()->currentFrame == framesetInfo.positions.nodelist_hopsignal ||
+        ui->getUiState()->currentFrame == framesetInfo.positions.nodelist_distance ||
+        ui->getUiState()->currentFrame == framesetInfo.positions.nodelist_bearings) {
+        if (event->inputEvent == INPUT_BROKER_UP) {
+            graphics::NodeListRenderer::scrollUp();
+            setFastFramerate();
+            return 0;
+        }
+
+        if (event->inputEvent == INPUT_BROKER_DOWN) {
+            graphics::NodeListRenderer::scrollDown();
+            setFastFramerate();
+            return 0;
+        }
+    }
     // Use left or right input from a keyboard to move between frames,
     // so long as a mesh module isn't using these events for some other purpose
     if (showingNormalScreen) {
@@ -1685,16 +1691,39 @@ int Screen::handleInputEvent(const InputEvent *event)
 
         // If no modules are using the input, move between frames
         if (!inputIntercepted) {
+#if defined(INPUTDRIVER_ENCODER_TYPE) && INPUTDRIVER_ENCODER_TYPE == 2
+            bool handledEncoderScroll = false;
+            const bool isTextMessageFrame = (framesetInfo.positions.textMessage != 255 &&
+                                             this->ui->getUiState()->currentFrame == framesetInfo.positions.textMessage &&
+                                             !messageStore.getMessages().empty());
+            if (isTextMessageFrame) {
+                if (event->inputEvent == INPUT_BROKER_UP_LONG) {
+                    graphics::MessageRenderer::nudgeScroll(-1);
+                    handledEncoderScroll = true;
+                } else if (event->inputEvent == INPUT_BROKER_DOWN_LONG) {
+                    graphics::MessageRenderer::nudgeScroll(1);
+                    handledEncoderScroll = true;
+                }
+            }
+
+            if (handledEncoderScroll) {
+                setFastFramerate();
+                return 0;
+            }
+#endif
             if (event->inputEvent == INPUT_BROKER_LEFT || event->inputEvent == INPUT_BROKER_ALT_PRESS) {
-                showPrevFrame();
+                showFrame(FrameDirection::PREVIOUS);
             } else if (event->inputEvent == INPUT_BROKER_RIGHT || event->inputEvent == INPUT_BROKER_USER_PRESS) {
-                showNextFrame();
+                showFrame(FrameDirection::NEXT);
             } else if (event->inputEvent == INPUT_BROKER_UP_LONG) {
                 // Long press up button for fast frame switching
                 showPrevFrame();
             } else if (event->inputEvent == INPUT_BROKER_DOWN_LONG) {
                 // Long press down button for fast frame switching
                 showNextFrame();
+            } else if ((event->inputEvent == INPUT_BROKER_UP || event->inputEvent == INPUT_BROKER_DOWN) &&
+                       this->ui->getUiState()->currentFrame == framesetInfo.positions.home) {
+                cannedMessageModule->LaunchWithDestination(NODENUM_BROADCAST);
             } else if (event->inputEvent == INPUT_BROKER_SELECT) {
                 if (this->ui->getUiState()->currentFrame == framesetInfo.positions.home) {
                     menuHandler::homeBaseMenu();
@@ -1709,20 +1738,21 @@ int Screen::handleInputEvent(const InputEvent *event)
                 } else if (this->ui->getUiState()->currentFrame == framesetInfo.positions.lora) {
                     menuHandler::loraMenu();
                 } else if (this->ui->getUiState()->currentFrame == framesetInfo.positions.textMessage) {
-                    if (devicestate.rx_text_message.from) {
+                    if (!messageStore.getMessages().empty()) {
                         menuHandler::messageResponseMenu();
                     } else {
-#if defined(M5STACK_UNITC6L)
-                        menuHandler::textMessageMenu();
-#else
-                        menuHandler::textMessageBaseMenu();
-#endif
+                        if (currentResolution == ScreenResolution::UltraLow) {
+                            menuHandler::textMessageMenu();
+                        } else {
+                            menuHandler::textMessageBaseMenu();
+                        }
                     }
                 } else if (framesetInfo.positions.firstFavorite != 255 &&
                            this->ui->getUiState()->currentFrame >= framesetInfo.positions.firstFavorite &&
                            this->ui->getUiState()->currentFrame <= framesetInfo.positions.lastFavorite) {
                     menuHandler::favoriteBaseMenu();
-                } else if (this->ui->getUiState()->currentFrame == framesetInfo.positions.nodelist ||
+                } else if (this->ui->getUiState()->currentFrame == framesetInfo.positions.nodelist_nodes ||
+                           this->ui->getUiState()->currentFrame == framesetInfo.positions.nodelist_location ||
                            this->ui->getUiState()->currentFrame == framesetInfo.positions.nodelist_lastheard ||
                            this->ui->getUiState()->currentFrame == framesetInfo.positions.nodelist_hopsignal ||
                            this->ui->getUiState()->currentFrame == framesetInfo.positions.nodelist_distance ||
@@ -1733,7 +1763,7 @@ int Screen::handleInputEvent(const InputEvent *event)
                     menuHandler::wifiBaseMenu();
                 }
             } else if (event->inputEvent == INPUT_BROKER_BACK) {
-                showPrevFrame();
+                showFrame(FrameDirection::PREVIOUS);
             } else if (event->inputEvent == INPUT_BROKER_CANCEL) {
                 setOn(false);
             }

src/graphics/Screen.h

@@ -40,7 +40,6 @@ class Screen
         FOCUS_DEFAULT,  // No specific frame
         FOCUS_PRESERVE, // Return to the previous frame
         FOCUS_FAULT,
-        FOCUS_TEXTMESSAGE,
         FOCUS_MODULE, // Note: target module should call requestFocus(), otherwise no info about which module to focus
         FOCUS_CLOCK,
         FOCUS_SYSTEM,
@@ -55,8 +54,6 @@ class Screen
     void startFirmwareUpdateScreen() {}
     void increaseBrightness() {}
     void decreaseBrightness() {}
-    void setFunctionSymbol(std::string) {}
-    void removeFunctionSymbol(std::string) {}
     void startAlert(const char *) {}
     void showSimpleBanner(const char *message, uint32_t durationMs = 0) {}
     void showOverlayBanner(BannerOverlayOptions) {}
@@ -172,6 +169,8 @@ class Point
 namespace graphics
 {
 
+enum class FrameDirection { NEXT, PREVIOUS };
+
 // Forward declarations
 class Screen;
 
@@ -211,8 +210,6 @@ class Screen : public concurrency::OSThread
         CallbackObserver<Screen, const meshtastic::Status *>(this, &Screen::handleStatusUpdate);
     CallbackObserver<Screen, const meshtastic::Status *> nodeStatusObserver =
         CallbackObserver<Screen, const meshtastic::Status *>(this, &Screen::handleStatusUpdate);
-    CallbackObserver<Screen, const meshtastic_MeshPacket *> textMessageObserver =
-        CallbackObserver<Screen, const meshtastic_MeshPacket *>(this, &Screen::handleTextMessage);
     CallbackObserver<Screen, const UIFrameEvent *> uiFrameEventObserver =
         CallbackObserver<Screen, const UIFrameEvent *>(this, &Screen::handleUIFrameEvent); // Sent by Mesh Modules
     CallbackObserver<Screen, const InputEvent *> inputObserver =
@@ -223,6 +220,10 @@ class Screen : public concurrency::OSThread
   public:
     OLEDDisplay *getDisplayDevice() { return dispdev; }
     explicit Screen(ScanI2C::DeviceAddress, meshtastic_Config_DisplayConfig_OledType, OLEDDISPLAY_GEOMETRY);
+
+    // Screen dimension accessors
+    inline int getHeight() const { return displayHeight; }
+    inline int getWidth() const { return displayWidth; }
     size_t frameCount = 0; // Total number of active frames
     ~Screen();
 
@@ -231,7 +232,6 @@ class Screen : public concurrency::OSThread
         FOCUS_DEFAULT,  // No specific frame
         FOCUS_PRESERVE, // Return to the previous frame
         FOCUS_FAULT,
-        FOCUS_TEXTMESSAGE,
         FOCUS_MODULE, // Note: target module should call requestFocus(), otherwise no info about which module to focus
         FOCUS_CLOCK,
         FOCUS_SYSTEM,
@@ -279,6 +279,7 @@ class Screen : public concurrency::OSThread
     void onPress() { enqueueCmd(ScreenCmd{.cmd = Cmd::ON_PRESS}); }
     void showPrevFrame() { enqueueCmd(ScreenCmd{.cmd = Cmd::SHOW_PREV_FRAME}); }
     void showNextFrame() { enqueueCmd(ScreenCmd{.cmd = Cmd::SHOW_NEXT_FRAME}); }
+    void showFrame(FrameDirection direction);
 
     // generic alert start
     void startAlert(FrameCallback _alertFrame)
@@ -346,9 +347,6 @@ class Screen : public concurrency::OSThread
     void increaseBrightness();
     void decreaseBrightness();
 
-    void setFunctionSymbol(std::string sym);
-    void removeFunctionSymbol(std::string sym);
-
     /// Stops showing the boot screen.
     void stopBootScreen() { enqueueCmd(ScreenCmd{.cmd = Cmd::STOP_BOOT_SCREEN}); }
 
@@ -579,7 +577,7 @@ class Screen : public concurrency::OSThread
 
     // Handle observer events
     int handleStatusUpdate(const meshtastic::Status *arg);
-    int handleTextMessage(const meshtastic_MeshPacket *arg);
+    int handleTextMessage(const meshtastic_MeshPacket *packet);
     int handleUIFrameEvent(const UIFrameEvent *arg);
     int handleInputEvent(const InputEvent *arg);
     int handleAdminMessage(AdminModule_ObserverData *arg);
@@ -590,9 +588,6 @@ class Screen : public concurrency::OSThread
     /// Draws our SSL cert screen during boot (called from WebServer)
     void setSSLFrames();
 
-    // Dismiss the currently focussed frame, if possible (e.g. text message, waypoint)
-    void hideCurrentFrame();
-
     // Menu-driven Show / Hide Toggle
     void toggleFrameVisibility(const std::string &frameName);
     bool isFrameHidden(const std::string &frameName) const;
@@ -640,8 +635,6 @@ class Screen : public concurrency::OSThread
     // Implementations of various commands, called from doTask().
     void handleSetOn(bool on, FrameCallback einkScreensaver = NULL);
     void handleOnPress();
-    void handleShowNextFrame();
-    void handleShowPrevFrame();
     void handleStartFirmwareUpdateScreen();
 
     // Info collected by setFrames method.
@@ -661,7 +654,8 @@ class Screen : public concurrency::OSThread
             uint8_t gps = 255;
             uint8_t home = 255;
             uint8_t textMessage = 255;
-            uint8_t nodelist = 255;
+            uint8_t nodelist_nodes = 255;
+            uint8_t nodelist_location = 255;
             uint8_t nodelist_lastheard = 255;
             uint8_t nodelist_hopsignal = 255;
             uint8_t nodelist_distance = 255;
@@ -684,7 +678,8 @@ class Screen : public concurrency::OSThread
         bool home = false;
         bool clock = false;
 #ifndef USE_EINK
-        bool nodelist = false;
+        bool nodelist_nodes = false;
+        bool nodelist_location = false;
 #endif
 #ifdef USE_EINK
         bool nodelist_lastheard = false;
@@ -692,7 +687,9 @@ class Screen : public concurrency::OSThread
         bool nodelist_distance = false;
 #endif
 #if HAS_GPS
+#ifdef USE_EINK
         bool nodelist_bearings = false;
+#endif
         bool gps = false;
 #endif
         bool lora = false;

src/graphics/SharedUIDisplay.cpp

@@ -15,27 +15,49 @@
 namespace graphics
 {
 
-void determineResolution(int16_t screenheight, int16_t screenwidth)
+ScreenResolution determineScreenResolution(int16_t screenheight, int16_t screenwidth)
 {
 
 #ifdef FORCE_LOW_RES
-    isHighResolution = false;
-    return;
-#endif
-
-    if (screenwidth > 128) {
-        isHighResolution = true;
+    return ScreenResolution::Low;
+#else
+    // Unit C6L and other ultra low res screens
+    if (screenwidth <= 64 || screenheight <= 48) {
+        return ScreenResolution::UltraLow;
     }
 
+    // Standard OLED screens
     if (screenwidth > 128 && screenheight <= 64) {
-        isHighResolution = false;
+        return ScreenResolution::Low;
     }
+
+    // High Resolutions screens like T114, TDeck, TLora Pager, etc
+    if (screenwidth > 128) {
+        return ScreenResolution::High;
+    }
+
+    // Default to low resolution
+    return ScreenResolution::Low;
+#endif
+}
+
+void decomposeTime(uint32_t rtc_sec, int &hour, int &minute, int &second)
+{
+    hour = 0;
+    minute = 0;
+    second = 0;
+    if (rtc_sec == 0)
+        return;
+    uint32_t hms = (rtc_sec % SEC_PER_DAY + SEC_PER_DAY) % SEC_PER_DAY;
+    hour = hms / SEC_PER_HOUR;
+    minute = (hms % SEC_PER_HOUR) / SEC_PER_MIN;
+    second = hms % SEC_PER_MIN;
 }
 
 // === Shared External State ===
 bool hasUnreadMessage = false;
 bool isMuted = false;
-bool isHighResolution = false;
+ScreenResolution currentResolution = ScreenResolution::Low;
 
 // === Internal State ===
 bool isBoltVisibleShared = true;
@@ -91,7 +113,7 @@ void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const char *ti
             display->setColor(BLACK);
             display->fillRect(0, 0, screenW, highlightHeight + 2);
             display->setColor(WHITE);
-            if (isHighResolution) {
+            if (currentResolution == ScreenResolution::High) {
                 display->drawLine(0, 20, screenW, 20);
             } else {
                 display->drawLine(0, 14, screenW, 14);
@@ -129,7 +151,7 @@ void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const char *ti
     }
 #endif
 
-    bool useHorizontalBattery = (isHighResolution && screenW >= screenH);
+    bool useHorizontalBattery = (currentResolution == ScreenResolution::High && screenW >= screenH);
     const int textY = y + (highlightHeight - FONT_HEIGHT_SMALL) / 2;
 
     int batteryX = 1;
@@ -139,7 +161,7 @@ void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const char *ti
     if (usbPowered && !isCharging) { // This is a basic check to determine USB Powered is flagged but not charging
         batteryX += 1;
         batteryY += 2;
-        if (isHighResolution) {
+        if (currentResolution == ScreenResolution::High) {
             display->drawXbm(batteryX, batteryY, 19, 12, imgUSB_HighResolution);
             batteryX += 20; // Icon + 1 pixel
         } else {
@@ -200,8 +222,8 @@ void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const char *ti
     if (rtc_sec > 0) {
         // === Build Time String ===
         long hms = (rtc_sec % SEC_PER_DAY + SEC_PER_DAY) % SEC_PER_DAY;
-        int hour = hms / SEC_PER_HOUR;
-        int minute = (hms % SEC_PER_HOUR) / SEC_PER_MIN;
+        int hour, minute, second;
+        graphics::decomposeTime(rtc_sec, hour, minute, second);
         snprintf(timeStr, sizeof(timeStr), "%d:%02d", hour, minute);
 
         // === Build Date String ===
@@ -209,7 +231,7 @@ void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const char *ti
         UIRenderer::formatDateTime(datetimeStr, sizeof(datetimeStr), rtc_sec, display, false);
         char dateLine[40];
 
-        if (isHighResolution) {
+        if (currentResolution == ScreenResolution::High) {
             snprintf(dateLine, sizeof(dateLine), "%s", datetimeStr);
         } else {
             if (hasUnreadMessage) {
@@ -285,7 +307,7 @@ void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const char *ti
                 display->drawXbm(iconX, iconY, mail_width, mail_height, mail);
             }
         } else if (isMuted) {
-            if (isHighResolution) {
+            if (currentResolution == ScreenResolution::High) {
                 int iconX = iconRightEdge - mute_symbol_big_width;
                 int iconY = textY + (FONT_HEIGHT_SMALL - mute_symbol_big_height) / 2;
 
@@ -303,7 +325,7 @@ void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const char *ti
                 int iconX = iconRightEdge - mute_symbol_width;
                 int iconY = textY + (FONT_HEIGHT_SMALL - mail_height) / 2;
 
-                if (isInverted) {
+                if (isInverted && !force_no_invert) {
                     display->setColor(WHITE);
                     display->fillRect(iconX - 1, iconY - 1, mute_symbol_width + 2, mute_symbol_height + 2);
                     display->setColor(BLACK);
@@ -362,7 +384,7 @@ void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const char *ti
                 display->drawXbm(iconX, iconY, mail_width, mail_height, mail);
             }
         } else if (isMuted) {
-            if (isHighResolution) {
+            if (currentResolution == ScreenResolution::High) {
                 int iconX = iconRightEdge - mute_symbol_big_width;
                 int iconY = textY + (FONT_HEIGHT_SMALL - mute_symbol_big_height) / 2;
                 display->drawXbm(iconX, iconY, mute_symbol_big_width, mute_symbol_big_height, mute_symbol_big);
@@ -381,7 +403,7 @@ const int *getTextPositions(OLEDDisplay *display)
 {
     static int textPositions[7]; // Static array that persists beyond function scope
 
-    if (isHighResolution) {
+    if (currentResolution == ScreenResolution::High) {
         textPositions[0] = textZeroLine;
         textPositions[1] = textFirstLine_medium;
         textPositions[2] = textSecondLine_medium;
@@ -414,8 +436,12 @@ void drawCommonFooter(OLEDDisplay *display, int16_t x, int16_t y)
     }
 
     if (drawConnectionState) {
-        if (isHighResolution) {
-            const int scale = 2;
+        const int scale = (currentResolution == ScreenResolution::High) ? 2 : 1;
+        display->setColor(BLACK);
+        display->fillRect(0, SCREEN_HEIGHT - (1 * scale) - (connection_icon_height * scale), (connection_icon_width * scale),
+                          (connection_icon_height * scale) + (2 * scale));
+        display->setColor(WHITE);
+        if (currentResolution == ScreenResolution::High) {
             const int bytesPerRow = (connection_icon_width + 7) / 8;
             int iconX = 0;
             int iconY = SCREEN_HEIGHT - (connection_icon_height * 2);
@@ -444,18 +470,49 @@ bool isAllowedPunctuation(char c)
     return allowed.find(c) != std::string::npos;
 }
 
+static void replaceAll(std::string &s, const std::string &from, const std::string &to)
+{
+    if (from.empty())
+        return;
+    size_t pos = 0;
+    while ((pos = s.find(from, pos)) != std::string::npos) {
+        s.replace(pos, from.size(), to);
+        pos += to.size();
+    }
+}
+
 std::string sanitizeString(const std::string &input)
 {
     std::string output;
     bool inReplacement = false;
 
-    for (char c : input) {
-        if (std::isalnum(static_cast<unsigned char>(c)) || isAllowedPunctuation(c)) {
+    // Make a mutable copy so we can normalize UTF-8 “smart punctuation” into ASCII first.
+    std::string s = input;
+
+    // Curly single quotes: ‘ ’
+    replaceAll(s, "\xE2\x80\x98", "'"); // U+2018
+    replaceAll(s, "\xE2\x80\x99", "'"); // U+2019
+
+    // Curly double quotes: “ ”
+    replaceAll(s, "\xE2\x80\x9C", "\""); // U+201C
+    replaceAll(s, "\xE2\x80\x9D", "\""); // U+201D
+
+    // En dash / Em dash: – —
+    replaceAll(s, "\xE2\x80\x93", "-"); // U+2013
+    replaceAll(s, "\xE2\x80\x94", "-"); // U+2014
+
+    // Non-breaking space
+    replaceAll(s, "\xC2\xA0", " "); // U+00A0
+
+    // Now do your original sanitize pass over the normalized string.
+    for (unsigned char uc : s) {
+        char c = static_cast<char>(uc);
+        if (std::isalnum(uc) || isAllowedPunctuation(c)) {
             output += c;
             inReplacement = false;
         } else {
             if (!inReplacement) {
-                output += 0xbf; // ISO-8859-1 for inverted question mark
+                output += static_cast<char>(0xBF); // ISO-8859-1 for inverted question mark
                 inReplacement = true;
             }
         }

src/graphics/SharedUIDisplay.h

@@ -42,8 +42,11 @@ namespace graphics
 // Shared state (declare inside namespace)
 extern bool hasUnreadMessage;
 extern bool isMuted;
-extern bool isHighResolution;
-void determineResolution(int16_t screenheight, int16_t screenwidth);
+enum class ScreenResolution : uint8_t { UltraLow = 0, Low = 1, High = 2 };
+extern ScreenResolution currentResolution;
+ScreenResolution determineScreenResolution(int16_t screenheight, int16_t screenwidth);
+
+void decomposeTime(uint32_t rtc_sec, int &hour, int &minute, int &second);
 
 // Rounded highlight (used for inverted headers)
 void drawRoundedHighlight(OLEDDisplay *display, int16_t x, int16_t y, int16_t w, int16_t h, int16_t r);

src/graphics/VirtualKeyboard.cpp

@@ -354,8 +354,6 @@ void VirtualKeyboard::drawInputArea(OLEDDisplay *display, int16_t offsetX, int16
         if (screenHeight <= 64) {
             textY = boxY + (boxHeight - inputLineH) / 2;
         } else {
-            const int innerLeft = boxX + 1;
-            const int innerRight = boxX + boxWidth - 2;
             const int innerTop = boxY + 1;
             const int innerBottom = boxY + boxHeight - 2;
 

src/graphics/draw/ClockRenderer.cpp

@@ -1,15 +1,10 @@
 #include "configuration.h"
 #if HAS_SCREEN
 #include "ClockRenderer.h"
-#include "NodeDB.h"
-#include "UIRenderer.h"
-#include "configuration.h"
-#include "gps/GeoCoord.h"
 #include "gps/RTC.h"
 #include "graphics/ScreenFonts.h"
 #include "graphics/SharedUIDisplay.h"
 #include "graphics/draw/UIRenderer.h"
-#include "graphics/emotes.h"
 #include "graphics/images.h"
 #include "main.h"
 
@@ -23,6 +18,31 @@ namespace graphics
 namespace ClockRenderer
 {
 
+// Segment bitmaps for numerals 0-9 stored in flash to save RAM.
+// Each row is a digit, each column is a segment state (1 = on, 0 = off).
+// Segment layout reference:
+//
+//             ___1___
+//           6 |     | 2
+//             |_7___|
+//           5 |     | 3
+//             |___4_|
+//
+// Segment order: [1, 2, 3, 4, 5, 6, 7]
+//
+static const uint8_t PROGMEM digitSegments[10][7] = {
+    {1, 1, 1, 1, 1, 1, 0}, // 0
+    {0, 1, 1, 0, 0, 0, 0}, // 1
+    {1, 1, 0, 1, 1, 0, 1}, // 2
+    {1, 1, 1, 1, 0, 0, 1}, // 3
+    {0, 1, 1, 0, 0, 1, 1}, // 4
+    {1, 0, 1, 1, 0, 1, 1}, // 5
+    {1, 0, 1, 1, 1, 1, 1}, // 6
+    {1, 1, 1, 0, 0, 1, 0}, // 7
+    {1, 1, 1, 1, 1, 1, 1}, // 8
+    {1, 1, 1, 1, 0, 1, 1}  // 9
+};
+
 void drawSegmentedDisplayColon(OLEDDisplay *display, int x, int y, float scale)
 {
     uint16_t segmentWidth = SEGMENT_WIDTH * scale;
@@ -30,7 +50,7 @@ void drawSegmentedDisplayColon(OLEDDisplay *display, int x, int y, float scale)
 
     uint16_t cellHeight = (segmentWidth * 2) + (segmentHeight * 3) + 8;
 
-    uint16_t topAndBottomX = x + (4 * scale);
+    uint16_t topAndBottomX = x + static_cast<uint16_t>(4 * scale);
 
     uint16_t quarterCellHeight = cellHeight / 4;
 
@@ -43,34 +63,16 @@ void drawSegmentedDisplayColon(OLEDDisplay *display, int x, int y, float scale)
 
 void drawSegmentedDisplayCharacter(OLEDDisplay *display, int x, int y, uint8_t number, float scale)
 {
-    // the numbers 0-9, each expressed as an array of seven boolean (0|1) values encoding the on/off state of
-    // segment {innerIndex + 1}
-    // e.g., to display the numeral '0', segments 1-6 are on, and segment 7 is off.
-    uint8_t numbers[10][7] = {
-        {1, 1, 1, 1, 1, 1, 0}, // 0          Display segment key
-        {0, 1, 1, 0, 0, 0, 0}, // 1                   1
-        {1, 1, 0, 1, 1, 0, 1}, // 2                  ___
-        {1, 1, 1, 1, 0, 0, 1}, // 3              6  |   | 2
-        {0, 1, 1, 0, 0, 1, 1}, // 4                 |_7̲_|
-        {1, 0, 1, 1, 0, 1, 1}, // 5              5  |   | 3
-        {1, 0, 1, 1, 1, 1, 1}, // 6                 |___|
-        {1, 1, 1, 0, 0, 1, 0}, // 7
-        {1, 1, 1, 1, 1, 1, 1}, // 8                   4
-        {1, 1, 1, 1, 0, 1, 1}, // 9
-    };
-
-    // the width and height of each segment's central rectangle:
-    //             _____________________
-    //           ⋰|  (only this part,  |⋱
-    //         ⋰  |   not including    |  ⋱
-    //         ⋱  |   the triangles    |  ⋰
-    //           ⋱|    on the ends)    |⋰
-    //             ‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
+    // Read 7-segment pattern for the digit from flash
+    uint8_t seg[7];
+    for (uint8_t i = 0; i < 7; i++) {
+        seg[i] = pgm_read_byte(&digitSegments[number][i]);
+    }
 
     uint16_t segmentWidth = SEGMENT_WIDTH * scale;
     uint16_t segmentHeight = SEGMENT_HEIGHT * scale;
 
-    // segment x and y coordinates
+    // Precompute segment positions
     uint16_t segmentOneX = x + segmentHeight + 2;
     uint16_t segmentOneY = y;
 
@@ -92,33 +94,21 @@ void drawSegmentedDisplayCharacter(OLEDDisplay *display, int x, int y, uint8_t n
     uint16_t segmentSevenX = segmentOneX;
     uint16_t segmentSevenY = segmentTwoY + segmentWidth + 2;
 
-    if (numbers[number][0]) {
-        graphics::ClockRenderer::drawHorizontalSegment(display, segmentOneX, segmentOneY, segmentWidth, segmentHeight);
-    }
-
-    if (numbers[number][1]) {
-        graphics::ClockRenderer::drawVerticalSegment(display, segmentTwoX, segmentTwoY, segmentWidth, segmentHeight);
-    }
-
-    if (numbers[number][2]) {
-        graphics::ClockRenderer::drawVerticalSegment(display, segmentThreeX, segmentThreeY, segmentWidth, segmentHeight);
-    }
-
-    if (numbers[number][3]) {
-        graphics::ClockRenderer::drawHorizontalSegment(display, segmentFourX, segmentFourY, segmentWidth, segmentHeight);
-    }
-
-    if (numbers[number][4]) {
-        graphics::ClockRenderer::drawVerticalSegment(display, segmentFiveX, segmentFiveY, segmentWidth, segmentHeight);
-    }
-
-    if (numbers[number][5]) {
-        graphics::ClockRenderer::drawVerticalSegment(display, segmentSixX, segmentSixY, segmentWidth, segmentHeight);
-    }
-
-    if (numbers[number][6]) {
-        graphics::ClockRenderer::drawHorizontalSegment(display, segmentSevenX, segmentSevenY, segmentWidth, segmentHeight);
-    }
+    // Draw only the active segments
+    if (seg[0])
+        drawHorizontalSegment(display, segmentOneX, segmentOneY, segmentWidth, segmentHeight);
+    if (seg[1])
+        drawVerticalSegment(display, segmentTwoX, segmentTwoY, segmentWidth, segmentHeight);
+    if (seg[2])
+        drawVerticalSegment(display, segmentThreeX, segmentThreeY, segmentWidth, segmentHeight);
+    if (seg[3])
+        drawHorizontalSegment(display, segmentFourX, segmentFourY, segmentWidth, segmentHeight);
+    if (seg[4])
+        drawVerticalSegment(display, segmentFiveX, segmentFiveY, segmentWidth, segmentHeight);
+    if (seg[5])
+        drawVerticalSegment(display, segmentSixX, segmentSixY, segmentWidth, segmentHeight);
+    if (seg[6])
+        drawHorizontalSegment(display, segmentSevenX, segmentSevenY, segmentWidth, segmentHeight);
 }
 
 void drawHorizontalSegment(OLEDDisplay *display, int x, int y, int width, int height)
@@ -147,42 +137,6 @@ void drawVerticalSegment(OLEDDisplay *display, int x, int y, int width, int heig
     display->fillTriangle(x, y + width, x + height - 1, y + width, x + halfHeight, y + width + halfHeight);
 }
 
-/*
-void drawWatchFaceToggleButton(OLEDDisplay *display, int16_t x, int16_t y, bool digitalMode, float scale)
-{
-    uint16_t segmentWidth = SEGMENT_WIDTH * scale;
-    uint16_t segmentHeight = SEGMENT_HEIGHT * scale;
-
-    if (digitalMode) {
-        uint16_t radius = (segmentWidth + (segmentHeight * 2) + 4) / 2;
-        uint16_t centerX = (x + segmentHeight + 2) + (radius / 2);
-        uint16_t centerY = (y + segmentHeight + 2) + (radius / 2);
-
-        display->drawCircle(centerX, centerY, radius);
-        display->drawCircle(centerX, centerY, radius + 1);
-        display->drawLine(centerX, centerY, centerX, centerY - radius + 3);
-        display->drawLine(centerX, centerY, centerX + radius - 3, centerY);
-    } else {
-        uint16_t segmentOneX = x + segmentHeight + 2;
-        uint16_t segmentOneY = y;
-
-        uint16_t segmentTwoX = segmentOneX + segmentWidth + 2;
-        uint16_t segmentTwoY = segmentOneY + segmentHeight + 2;
-
-        uint16_t segmentThreeX = segmentOneX;
-        uint16_t segmentThreeY = segmentTwoY + segmentWidth + 2;
-
-        uint16_t segmentFourX = x;
-        uint16_t segmentFourY = y + segmentHeight + 2;
-
-        drawHorizontalSegment(display, segmentOneX, segmentOneY, segmentWidth, segmentHeight);
-        drawVerticalSegment(display, segmentTwoX, segmentTwoY, segmentWidth, segmentHeight);
-        drawHorizontalSegment(display, segmentThreeX, segmentThreeY, segmentWidth, segmentHeight);
-        drawVerticalSegment(display, segmentFourX, segmentFourY, segmentWidth, segmentHeight);
-    }
-}
-*/
-// Draw a digital clock
 void drawDigitalClockFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
 {
     display->clear();
@@ -192,7 +146,6 @@ void drawDigitalClockFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int1
     const char *titleStr = "";
     // === Header ===
     graphics::drawCommonHeader(display, x, y, titleStr, true, true);
-    int line = 0;
 
     uint32_t rtc_sec = getValidTime(RTCQuality::RTCQualityDevice, true); // Display local timezone
     char timeString[16];
@@ -237,7 +190,7 @@ void drawDigitalClockFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int1
         float target_width = display->getWidth() * screenwidth_target_ratio;
         float target_height =
             display->getHeight() -
-            (isHighResolution
+            ((currentResolution == ScreenResolution::High)
                  ? 46
                  : 33); // Be careful adjusting this number, we have to account for header and the text under the time
 
@@ -268,10 +221,9 @@ void drawDigitalClockFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int1
         scaleInitialized = true;
     }
 
-    size_t len = strlen(timeString);
-
     // calculate hours:minutes string width
-    uint16_t timeStringWidth = len * 5; // base spacing between characters
+    size_t len = strlen(timeString);
+    uint16_t timeStringWidth = len * 5;
 
     for (size_t i = 0; i < len; i++) {
         char character = timeString[i];
@@ -310,9 +262,16 @@ void drawDigitalClockFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int1
 
     // draw seconds string + AM/PM
     display->setFont(FONT_SMALL);
-    int xOffset = (isHighResolution) ? 0 : -1;
+    int xOffset = -1;
+    if (currentResolution == ScreenResolution::High) {
+        xOffset = 0;
+    }
     if (hour >= 10) {
-        xOffset += (isHighResolution) ? 32 : 18;
+        if (currentResolution == ScreenResolution::High) {
+            xOffset += 32;
+        } else {
+            xOffset += 18;
+        }
     }
 
     if (config.display.use_12h_clock) {
@@ -320,7 +279,7 @@ void drawDigitalClockFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int1
     }
 
 #ifndef USE_EINK
-    xOffset = (isHighResolution) ? 18 : 10;
+    xOffset = (currentResolution == ScreenResolution::High) ? 18 : 10;
     if (scale >= 2.0f) {
         xOffset -= (int)(4.5f * scale);
     }
@@ -339,19 +298,13 @@ void drawAnalogClockFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16
     const char *titleStr = "";
     // === Header ===
     graphics::drawCommonHeader(display, x, y, titleStr, true, true);
-    int line = 0;
 
     // clock face center coordinates
     int16_t centerX = display->getWidth() / 2;
     int16_t centerY = display->getHeight() / 2;
 
     // clock face radius
-    int16_t radius = 0;
-    if (display->getHeight() < display->getWidth()) {
-        radius = (display->getHeight() / 2) * 0.9;
-    } else {
-        radius = (display->getWidth() / 2) * 0.9;
-    }
+    int16_t radius = (std::min(display->getWidth(), display->getHeight()) / 2) * 0.9;
 #ifdef T_WATCH_S3
     radius = (display->getWidth() / 2) * 0.8;
 #endif
@@ -366,17 +319,8 @@ void drawAnalogClockFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16
     // tick mark outer y coordinate; (first nested circle)
     int16_t tickMarkOuterNoonY = secondHandNoonY;
 
-    // seconds tick mark inner y coordinate; (second nested circle)
-    double secondsTickMarkInnerNoonY = (double)noonY + 4;
-    if (isHighResolution) {
-        secondsTickMarkInnerNoonY = (double)noonY + 8;
-    }
-
-    // hours tick mark inner y coordinate; (third nested circle)
-    double hoursTickMarkInnerNoonY = (double)noonY + 6;
-    if (isHighResolution) {
-        hoursTickMarkInnerNoonY = (double)noonY + 16;
-    }
+    double secondsTickMarkInnerNoonY = noonY + ((currentResolution == ScreenResolution::High) ? 8 : 4);
+    double hoursTickMarkInnerNoonY = noonY + ((currentResolution == ScreenResolution::High) ? 16 : 6);
 
     // minute hand y coordinate
     int16_t minuteHandNoonY = secondsTickMarkInnerNoonY + 4;
@@ -386,7 +330,7 @@ void drawAnalogClockFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16
 
     // hour hand radius and y coordinate
     int16_t hourHandRadius = radius * 0.35;
-    if (isHighResolution) {
+    if (currentResolution == ScreenResolution::High) {
         hourHandRadius = radius * 0.55;
     }
     int16_t hourHandNoonY = centerY - hourHandRadius;
@@ -396,19 +340,13 @@ void drawAnalogClockFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16
 
     uint32_t rtc_sec = getValidTime(RTCQuality::RTCQualityDevice, true); // Display local timezone
     if (rtc_sec > 0) {
-        long hms = rtc_sec % SEC_PER_DAY;
-        hms = (hms + SEC_PER_DAY) % SEC_PER_DAY;
+        int hour, minute, second;
+        decomposeTime(rtc_sec, hour, minute, second);
 
-        // Tear apart hms into h:m:s
-        int hour = hms / SEC_PER_HOUR;
-        int minute = (hms % SEC_PER_HOUR) / SEC_PER_MIN;
-        int second = (hms % SEC_PER_HOUR) % SEC_PER_MIN; // or hms % SEC_PER_MIN
-
-        bool isPM = hour >= 12;
         if (config.display.use_12h_clock) {
-            isPM = hour >= 12;
+            bool isPM = hour >= 12;
             display->setFont(FONT_SMALL);
-            int yOffset = isHighResolution ? 1 : 0;
+            int yOffset = (currentResolution == ScreenResolution::High) ? 1 : 0;
 #ifdef USE_EINK
             yOffset += 3;
 #endif
@@ -499,12 +437,13 @@ void drawAnalogClockFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16
                 display->drawStringf(hourStringX, hourStringY, buffer, "%d", hourInt);
 #else
 #ifdef USE_EINK
-                if (isHighResolution) {
+                if (currentResolution == ScreenResolution::High) {
                     // draw hour number
                     display->drawStringf(hourStringX, hourStringY, buffer, "%d", hourInt);
                 }
 #else
-                if (isHighResolution && (hourInt == 3 || hourInt == 6 || hourInt == 9 || hourInt == 12)) {
+                if (currentResolution == ScreenResolution::High &&
+                    (hourInt == 3 || hourInt == 6 || hourInt == 9 || hourInt == 12)) {
                     // draw hour number
                     display->drawStringf(hourStringX, hourStringY, buffer, "%d", hourInt);
                 }
@@ -516,7 +455,7 @@ void drawAnalogClockFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16
                 double startX = sineAngleInRadians * (secondsTickMarkInnerNoonY - centerY) + noonX;
                 double startY = cosineAngleInRadians * (secondsTickMarkInnerNoonY - centerY) + centerY;
 
-                if (isHighResolution) {
+                if (currentResolution == ScreenResolution::High) {
                     // draw minute tick mark
                     display->drawLine(startX, startY, endX, endY);
                 }

src/graphics/draw/CompassRenderer.cpp

@@ -48,7 +48,7 @@ void drawCompassNorth(OLEDDisplay *display, int16_t compassX, int16_t compassY,
     // This could draw a "N" indicator or north arrow
     // For now, we'll draw a simple north indicator
     // const float radius = 17.0f;
-    if (isHighResolution) {
+    if (currentResolution == ScreenResolution::High) {
         radius += 4;
     }
     Point north(0, -radius);
@@ -59,7 +59,7 @@ void drawCompassNorth(OLEDDisplay *display, int16_t compassX, int16_t compassY,
     display->setFont(FONT_SMALL);
     display->setTextAlignment(TEXT_ALIGN_CENTER);
     display->setColor(BLACK);
-    if (isHighResolution) {
+    if (currentResolution == ScreenResolution::High) {
         display->fillRect(north.x - 8, north.y - 1, display->getStringWidth("N") + 3, FONT_HEIGHT_SMALL - 6);
     } else {
         display->fillRect(north.x - 4, north.y - 1, display->getStringWidth("N") + 2, FONT_HEIGHT_SMALL - 6);

src/graphics/draw/DebugRenderer.cpp

@@ -282,13 +282,13 @@ void drawFrameSettings(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t
     std::string uptime = UIRenderer::drawTimeDelta(days, hours, minutes, seconds);
 
     // Line 1 (Still)
-#if !defined(M5STACK_UNITC6L)
-    display->drawString(x + SCREEN_WIDTH - display->getStringWidth(uptime.c_str()), y, uptime.c_str());
-    if (config.display.heading_bold)
-        display->drawString(x - 1 + SCREEN_WIDTH - display->getStringWidth(uptime.c_str()), y, uptime.c_str());
+    if (currentResolution != graphics::ScreenResolution::UltraLow) {
+        display->drawString(x + SCREEN_WIDTH - display->getStringWidth(uptime.c_str()), y, uptime.c_str());
+        if (config.display.heading_bold)
+            display->drawString(x - 1 + SCREEN_WIDTH - display->getStringWidth(uptime.c_str()), y, uptime.c_str());
 
-    display->setColor(WHITE);
-#endif
+        display->setColor(WHITE);
+    }
     // Setup string to assemble analogClock string
     std::string analogClock = "";
 
@@ -301,9 +301,8 @@ void drawFrameSettings(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t
         hms = (hms + SEC_PER_DAY) % SEC_PER_DAY;
 
         // Tear apart hms into h:m:s
-        int hour = hms / SEC_PER_HOUR;
-        int min = (hms % SEC_PER_HOUR) / SEC_PER_MIN;
-        int sec = (hms % SEC_PER_HOUR) % SEC_PER_MIN; // or hms % SEC_PER_MIN
+        int hour, min, sec;
+        graphics::decomposeTime(rtc_sec, hour, min, sec);
 
         char timebuf[12];
 
@@ -379,7 +378,7 @@ void drawLoRaFocused(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x,
     int line = 1;
 
     // === Set Title
-    const char *titleStr = (isHighResolution) ? "LoRa Info" : "LoRa";
+    const char *titleStr = (currentResolution == ScreenResolution::High) ? "LoRa Info" : "LoRa";
 
     // === Header ===
     graphics::drawCommonHeader(display, x, y, titleStr);
@@ -391,11 +390,11 @@ void drawLoRaFocused(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x,
     char shortnameble[35];
     getMacAddr(dmac);
     snprintf(screen->ourId, sizeof(screen->ourId), "%02x%02x", dmac[4], dmac[5]);
-#if defined(M5STACK_UNITC6L)
-    snprintf(shortnameble, sizeof(shortnameble), "%s", screen->ourId);
-#else
-    snprintf(shortnameble, sizeof(shortnameble), "BLE: %s", screen->ourId);
-#endif
+    if (currentResolution == ScreenResolution::UltraLow) {
+        snprintf(shortnameble, sizeof(shortnameble), "%s", screen->ourId);
+    } else {
+        snprintf(shortnameble, sizeof(shortnameble), "BLE: %s", screen->ourId);
+    }
     int textWidth = display->getStringWidth(shortnameble);
     int nameX = (SCREEN_WIDTH - textWidth);
     display->drawString(nameX, getTextPositions(display)[line++], shortnameble);
@@ -414,11 +413,11 @@ void drawLoRaFocused(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x,
     char regionradiopreset[25];
     const char *region = myRegion ? myRegion->name : NULL;
     if (region != nullptr) {
-#if defined(M5STACK_UNITC6L)
-        snprintf(regionradiopreset, sizeof(regionradiopreset), "%s", region);
-#else
-        snprintf(regionradiopreset, sizeof(regionradiopreset), "%s/%s", region, mode);
-#endif
+        if (currentResolution == ScreenResolution::UltraLow) {
+            snprintf(regionradiopreset, sizeof(regionradiopreset), "%s", region);
+        } else {
+            snprintf(regionradiopreset, sizeof(regionradiopreset), "%s/%s", region, mode);
+        }
     }
     textWidth = display->getStringWidth(regionradiopreset);
     nameX = (SCREEN_WIDTH - textWidth) / 2;
@@ -430,17 +429,17 @@ void drawLoRaFocused(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x,
     float freq = RadioLibInterface::instance->getFreq();
     snprintf(freqStr, sizeof(freqStr), "%.3f", freq);
     if (config.lora.channel_num == 0) {
-#if defined(M5STACK_UNITC6L)
-        snprintf(frequencyslot, sizeof(frequencyslot), "%sMHz", freqStr);
-#else
-        snprintf(frequencyslot, sizeof(frequencyslot), "Freq: %sMHz", freqStr);
-#endif
+        if (currentResolution == ScreenResolution::UltraLow) {
+            snprintf(frequencyslot, sizeof(frequencyslot), "%sMHz", freqStr);
+        } else {
+            snprintf(frequencyslot, sizeof(frequencyslot), "Freq: %sMHz", freqStr);
+        }
     } else {
-#if defined(M5STACK_UNITC6L)
-        snprintf(frequencyslot, sizeof(frequencyslot), "%sMHz (%d)", freqStr, config.lora.channel_num);
-#else
-        snprintf(frequencyslot, sizeof(frequencyslot), "Freq/Ch: %sMHz (%d)", freqStr, config.lora.channel_num);
-#endif
+        if (currentResolution == ScreenResolution::UltraLow) {
+            snprintf(frequencyslot, sizeof(frequencyslot), "%sMHz (%d)", freqStr, config.lora.channel_num);
+        } else {
+            snprintf(frequencyslot, sizeof(frequencyslot), "Freq/Ch: %sMHz (%d)", freqStr, config.lora.channel_num);
+        }
     }
     size_t len = strlen(frequencyslot);
     if (len >= 4 && strcmp(frequencyslot + len - 4, " (0)") == 0) {
@@ -456,12 +455,13 @@ void drawLoRaFocused(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x,
     char chUtilPercentage[10];
     snprintf(chUtilPercentage, sizeof(chUtilPercentage), "%2.0f%%", airTime->channelUtilizationPercent());
 
-    int chUtil_x = (isHighResolution) ? display->getStringWidth(chUtil) + 10 : display->getStringWidth(chUtil) + 5;
+    int chUtil_x = (currentResolution == ScreenResolution::High) ? display->getStringWidth(chUtil) + 10
+                                                                 : display->getStringWidth(chUtil) + 5;
     int chUtil_y = getTextPositions(display)[line] + 3;
 
-    int chutil_bar_width = (isHighResolution) ? 100 : 50;
-    int chutil_bar_height = (isHighResolution) ? 12 : 7;
-    int extraoffset = (isHighResolution) ? 6 : 3;
+    int chutil_bar_width = (currentResolution == ScreenResolution::High) ? 100 : 50;
+    int chutil_bar_height = (currentResolution == ScreenResolution::High) ? 12 : 7;
+    int extraoffset = (currentResolution == ScreenResolution::High) ? 6 : 3;
     int chutil_percent = airTime->channelUtilizationPercent();
 
     int centerofscreen = SCREEN_WIDTH / 2;
@@ -530,17 +530,18 @@ void drawSystemScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x
     int line = 1;
     const int barHeight = 6;
     const int labelX = x;
-    int barsOffset = (isHighResolution) ? 24 : 0;
+    int barsOffset = (currentResolution == ScreenResolution::High) ? 24 : 0;
 #ifdef USE_EINK
 #ifndef T_DECK_PRO
     barsOffset -= 12;
 #endif
 #endif
-#if defined(M5STACK_UNITC6L)
-    const int barX = x + 45 + barsOffset;
-#else
-    const int barX = x + 40 + barsOffset;
-#endif
+    int barX = x + barsOffset;
+    if (currentResolution == ScreenResolution::UltraLow) {
+        barX += 45;
+    } else {
+        barX += 40;
+    }
     auto drawUsageRow = [&](const char *label, uint32_t used, uint32_t total, bool isHeap = false) {
         if (total == 0)
             return;
@@ -548,7 +549,7 @@ void drawSystemScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x
         int percent = (used * 100) / total;
 
         char combinedStr[24];
-        if (isHighResolution) {
+        if (currentResolution == ScreenResolution::High) {
             snprintf(combinedStr, sizeof(combinedStr), "%s%3d%%  %u/%uKB", (percent > 80) ? "! " : "", percent, used / 1024,
                      total / 1024);
         } else {
@@ -628,25 +629,33 @@ void drawSystemScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x
     line += 1;
 
     char appversionstr[35];
-    snprintf(appversionstr, sizeof(appversionstr), "Ver: %s", optstr(APP_VERSION));
     char appversionstr_formatted[40];
-    char *lastDot = strrchr(appversionstr, '.');
-#if defined(M5STACK_UNITC6L)
-    if (lastDot != nullptr) {
-        *lastDot = '\0'; // truncate string
+
+    const char *ver = optstr(APP_VERSION);
+    char verbuf[32];
+    strncpy(verbuf, ver, sizeof(verbuf) - 1);
+    verbuf[sizeof(verbuf) - 1] = '\0';
+
+    char *lastDot = strrchr(verbuf, '.');
+
+    if (currentResolution == ScreenResolution::UltraLow) {
+        if (lastDot != nullptr) {
+            *lastDot = '\0';
+        }
+        snprintf(appversionstr, sizeof(appversionstr), "Ver: %s", verbuf);
+    } else {
+        if (lastDot) {
+            size_t prefixLen = (size_t)(lastDot - verbuf);
+            snprintf(appversionstr_formatted, sizeof(appversionstr_formatted), "Ver: %.*s", (int)prefixLen, verbuf);
+            strncat(appversionstr_formatted, " (", sizeof(appversionstr_formatted) - strlen(appversionstr_formatted) - 1);
+            strncat(appversionstr_formatted, lastDot + 1, sizeof(appversionstr_formatted) - strlen(appversionstr_formatted) - 1);
+            strncat(appversionstr_formatted, ")", sizeof(appversionstr_formatted) - strlen(appversionstr_formatted) - 1);
+            strncpy(appversionstr, appversionstr_formatted, sizeof(appversionstr) - 1);
+            appversionstr[sizeof(appversionstr) - 1] = '\0';
+        } else {
+            snprintf(appversionstr, sizeof(appversionstr), "Ver: %s", verbuf);
+        }
     }
-#else
-    if (lastDot) {
-        size_t prefixLen = lastDot - appversionstr;
-        strncpy(appversionstr_formatted, appversionstr, prefixLen);
-        appversionstr_formatted[prefixLen] = '\0';
-        strncat(appversionstr_formatted, " (", sizeof(appversionstr_formatted) - strlen(appversionstr_formatted) - 1);
-        strncat(appversionstr_formatted, lastDot + 1, sizeof(appversionstr_formatted) - strlen(appversionstr_formatted) - 1);
-        strncat(appversionstr_formatted, ")", sizeof(appversionstr_formatted) - strlen(appversionstr_formatted) - 1);
-        strncpy(appversionstr, appversionstr_formatted, sizeof(appversionstr) - 1);
-        appversionstr[sizeof(appversionstr) - 1] = '\0';
-    }
-#endif
     int textWidth = display->getStringWidth(appversionstr);
     int nameX = (SCREEN_WIDTH - textWidth) / 2;
 
@@ -665,7 +674,7 @@ void drawSystemScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x
         const char *clientWord = nullptr;
 
         // Determine if narrow or wide screen
-        if (isHighResolution) {
+        if (currentResolution == ScreenResolution::High) {
             clientWord = "Client";
         } else {
             clientWord = "App";
@@ -706,11 +715,23 @@ void drawChirpy(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int1
     int iconX = SCREEN_WIDTH - chirpy_width - (chirpy_width / 3);
     int iconY = (SCREEN_HEIGHT - chirpy_height) / 2;
     int textX_offset = 10;
-    if (isHighResolution) {
-        iconX = SCREEN_WIDTH - chirpy_width_hirez - (chirpy_width_hirez / 3);
-        iconY = (SCREEN_HEIGHT - chirpy_height_hirez) / 2;
+    if (currentResolution == ScreenResolution::High) {
         textX_offset = textX_offset * 4;
-        display->drawXbm(iconX, iconY, chirpy_width_hirez, chirpy_height_hirez, chirpy_hirez);
+        const int scale = 2;
+        const int bytesPerRow = (chirpy_width + 7) / 8;
+
+        for (int yy = 0; yy < chirpy_height; ++yy) {
+            iconX = SCREEN_WIDTH - (chirpy_width * 2) - ((chirpy_width * 2) / 3);
+            iconY = (SCREEN_HEIGHT - (chirpy_height * 2)) / 2;
+            const uint8_t *rowPtr = chirpy + yy * bytesPerRow;
+            for (int xx = 0; xx < chirpy_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(iconX, iconY, chirpy_width, chirpy_height, chirpy);
     }

src/graphics/draw/DrawRenderers.h

@@ -11,7 +11,6 @@
 #include "graphics/draw/CompassRenderer.h"
 #include "graphics/draw/DebugRenderer.h"
 #include "graphics/draw/NodeListRenderer.h"
-#include "graphics/draw/ScreenRenderer.h"
 #include "graphics/draw/UIRenderer.h"
 
 namespace graphics
@@ -30,8 +29,6 @@ using namespace ClockRenderer;
 using namespace CompassRenderer;
 using namespace DebugRenderer;
 using namespace NodeListRenderer;
-using namespace ScreenRenderer;
-using namespace UIRenderer;
 
 } // namespace DrawRenderers
 

src/graphics/draw/MenuHandler.h

@@ -19,8 +19,12 @@ class menuHandler
         clock_face_picker,
         clock_menu,
         position_base_menu,
+        node_base_menu,
         gps_toggle_menu,
         gps_format_menu,
+        gps_smart_position_menu,
+        gps_update_interval_menu,
+        gps_position_broadcast_menu,
         compass_point_north_menu,
         reset_node_db_menu,
         buzzermodemenupicker,
@@ -35,7 +39,6 @@ class menuHandler
         number_test,
         wifi_toggle_menu,
         bluetooth_toggle_menu,
-        notifications_menu,
         screen_options_menu,
         power_menu,
         system_base_menu,
@@ -43,6 +46,10 @@ class menuHandler
         key_verification_final_prompt,
         trace_route_menu,
         throttle_message,
+        message_response_menu,
+        message_viewmode_menu,
+        reply_menu,
+        delete_messages_menu,
         node_name_length_menu,
         FrameToggles,
         DisplayUnits
@@ -61,6 +68,9 @@ class menuHandler
     static void TwelveHourPicker();
     static void ClockFacePicker();
     static void messageResponseMenu();
+    static void messageViewModeMenu();
+    static void replyMenu();
+    static void deleteMessagesMenu();
     static void homeBaseMenu();
     static void textMessageBaseMenu();
     static void systemBaseMenu();
@@ -69,6 +79,9 @@ class menuHandler
     static void compassNorthMenu();
     static void GPSToggleMenu();
     static void GPSFormatMenu();
+    static void GPSSmartPositionMenu();
+    static void GPSUpdateIntervalMenu();
+    static void GPSPositionBroadcastMenu();
     static void BuzzerModeMenu();
     static void switchToMUIMenu();
     static void TFTColorPickerMenu(OLEDDisplay *display);
@@ -84,7 +97,6 @@ class menuHandler
     static void numberTest();
     static void wifiBaseMenu();
     static void wifiToggleMenu();
-    static void notificationsMenu();
     static void screenOptionsMenu();
     static void powerMenu();
     static void nodeNameLengthMenu();
@@ -119,4 +131,4 @@ template <typename T> struct MenuOption {
 using RadioPresetOption = MenuOption<meshtastic_Config_LoRaConfig_ModemPreset>;
 
 } // namespace graphics
-#endif
+#endif

src/graphics/draw/MessageRenderer.h

@@ -1,7 +1,11 @@
 #pragma once
+#include "MessageStore.h" // for StoredMessage
+#if HAS_SCREEN
 #include "OLEDDisplay.h"
 #include "OLEDDisplayUi.h"
 #include "graphics/emotes.h"
+#include "mesh/generated/meshtastic/mesh.pb.h" // for meshtastic_MeshPacket
+#include <cstdint>
 #include <string>
 #include <vector>
 
@@ -10,6 +14,27 @@ namespace graphics
 namespace MessageRenderer
 {
 
+// Thread filter modes
+enum class ThreadMode { ALL, CHANNEL, DIRECT };
+
+// Setter for switching thread mode
+void setThreadMode(ThreadMode mode, int channel = -1, uint32_t peer = 0);
+
+// Getter for current mode
+ThreadMode getThreadMode();
+
+// Getter for current channel (valid if mode == CHANNEL)
+int getThreadChannel();
+
+// Getter for current peer (valid if mode == DIRECT)
+uint32_t getThreadPeer();
+
+// Registry accessors for menuHandler
+const std::vector<int> &getSeenChannels();
+const std::vector<uint32_t> &getSeenPeers();
+
+void clearThreadRegistries();
+
 // Text and emote rendering
 void drawStringWithEmotes(OLEDDisplay *display, int x, int y, const std::string &line, const Emote *emotes, int emoteCount);
 
@@ -20,11 +45,27 @@ void drawTextMessageFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16
 std::vector<std::string> generateLines(OLEDDisplay *display, const char *headerStr, const char *messageBuf, int textWidth);
 
 // Function to calculate heights for each line
-std::vector<int> calculateLineHeights(const std::vector<std::string> &lines, const Emote *emotes);
+std::vector<int> calculateLineHeights(const std::vector<std::string> &lines, const Emote *emotes,
+                                      const std::vector<bool> &isHeaderVec);
 
-// Function to render the message content
-void renderMessageContent(OLEDDisplay *display, const std::vector<std::string> &lines, const std::vector<int> &rowHeights, int x,
-                          int yOffset, int scrollBottom, const Emote *emotes, int numEmotes, bool isInverted, bool isBold);
+// Reset scroll state when new messages arrive
+void resetScrollState();
+
+// Manual scroll control for encoder-style inputs
+void nudgeScroll(int8_t direction);
+
+// Helper to auto-select the correct thread mode from a message
+void setThreadFor(const StoredMessage &sm, const meshtastic_MeshPacket &packet);
+
+// Handles a new incoming/outgoing message: banner, wake, thread select, scroll reset
+void handleNewMessage(OLEDDisplay *display, const StoredMessage &sm, const meshtastic_MeshPacket &packet);
+
+// Clear Message Line Cache from Message Renderer
+void clearMessageCache();
+
+void scrollUp();
+void scrollDown();
 
 } // namespace MessageRenderer
 } // namespace graphics
+#endif

src/graphics/draw/NodeListRenderer.cpp

@@ -23,7 +23,6 @@ extern graphics::Screen *screen;
 
 #if defined(M5STACK_UNITC6L)
 static uint32_t lastSwitchTime = 0;
-#else
 #endif
 namespace graphics
 {
@@ -46,79 +45,119 @@ void drawScaledXBitmap16x16(int x, int y, int width, int height, const uint8_t *
 }
 
 // Static variables for dynamic cycling
-static NodeListMode currentMode = MODE_LAST_HEARD;
+static ListMode_Node currentMode_Nodes = MODE_LAST_HEARD;
+static ListMode_Location currentMode_Location = MODE_DISTANCE;
 static int scrollIndex = 0;
+// Popup overlay state
+static uint32_t popupTime = 0;
+static int popupTotal = 0;
+static int popupStart = 0;
+static int popupEnd = 0;
+static int popupPage = 1;
+static int popupMaxPage = 1;
+
+static const uint32_t POPUP_DURATION_MS = 1000; // 1 second visible
+
+// =============================
+// Scrolling Logic
+// =============================
+void scrollUp()
+{
+    if (scrollIndex > 0)
+        scrollIndex--;
+
+    popupTime = millis(); // show popup
+}
+
+void scrollDown()
+{
+    scrollIndex++;
+    popupTime = millis();
+}
 
 // =============================
 // Utility Functions
 // =============================
 
-const char *getSafeNodeName(OLEDDisplay *display, meshtastic_NodeInfoLite *node)
+const char *getSafeNodeName(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int columnWidth)
 {
-    const char *name = NULL;
-    static char nodeName[16] = "?";
-    if (config.display.use_long_node_name == true) {
-        if (node->has_user && strlen(node->user.long_name) > 0) {
-            name = node->user.long_name;
-        } else {
-            snprintf(nodeName, sizeof(nodeName), "(%04X)", (uint16_t)(node->num & 0xFFFF));
-        }
-    } else {
-        if (node->has_user && strlen(node->user.short_name) > 0) {
-            name = node->user.short_name;
-        } else {
-            snprintf(nodeName, sizeof(nodeName), "(%04X)", (uint16_t)(node->num & 0xFFFF));
-        }
+    static char nodeName[25]; // single static buffer we return
+    nodeName[0] = '\0';
+
+    auto writeFallbackId = [&] {
+        std::snprintf(nodeName, sizeof(nodeName), "(%04X)", static_cast<uint16_t>(node ? (node->num & 0xFFFF) : 0));
+    };
+
+    // 1) Choose target candidate (long vs short) only if present
+    const char *raw = nullptr;
+    if (node && node->has_user) {
+        raw = config.display.use_long_node_name ? node->user.long_name : node->user.short_name;
     }
 
-    // Use sanitizeString() function and copy directly into nodeName
-    std::string sanitized_name = sanitizeString(name ? name : "");
+    // 2) Sanitize (empty if raw is null/empty)
+    std::string s = (raw && *raw) ? sanitizeString(raw) : std::string{};
 
-    if (!sanitized_name.empty()) {
-        strncpy(nodeName, sanitized_name.c_str(), sizeof(nodeName) - 1);
-        nodeName[sizeof(nodeName) - 1] = '\0';
+    // 3) Fallback if sanitize yields empty; otherwise copy safely (truncate if needed)
+    if (s.empty() || s == "¿" || s.find_first_not_of("¿") == std::string::npos) {
+        writeFallbackId();
     } else {
-        snprintf(nodeName, sizeof(nodeName), "(%04X)", (uint16_t)(node->num & 0xFFFF));
+        // %.*s ensures null-termination and safe truncation to buffer size - 1
+        std::snprintf(nodeName, sizeof(nodeName), "%.*s", static_cast<int>(sizeof(nodeName) - 1), s.c_str());
     }
 
-    if (config.display.use_long_node_name == true) {
-        int availWidth = (SCREEN_WIDTH / 2) - 65;
+    // 4) Width-based truncation + ellipsis (long-name mode only)
+    if (config.display.use_long_node_name && display) {
+        int availWidth = columnWidth - ((currentResolution == ScreenResolution::High) ? 65 : 38);
         if (availWidth < 0)
             availWidth = 0;
 
-        size_t origLen = strlen(nodeName);
-        while (nodeName[0] && display->getStringWidth(nodeName) > availWidth) {
-            nodeName[strlen(nodeName) - 1] = '\0';
+        const size_t beforeLen = std::strlen(nodeName);
+
+        // Trim from the end until it fits or is empty
+        size_t len = beforeLen;
+        while (len && display->getStringWidth(nodeName) > availWidth) {
+            nodeName[--len] = '\0';
         }
 
-        // If we actually truncated, append "..." (ensure space remains in buffer)
-        if (strlen(nodeName) < origLen) {
-            size_t len = strlen(nodeName);
-            size_t maxLen = sizeof(nodeName) - 4; // 3 for "..." and 1 for '\0'
-            if (len > maxLen) {
-                nodeName[maxLen] = '\0';
-                len = maxLen;
+        // If truncated, append "..." (respect buffer size)
+        if (len < beforeLen) {
+            // Make sure there's room for "..." and '\0'
+            const size_t capForText = sizeof(nodeName) - 1; // leaving space for '\0'
+            const size_t needed = 3;                        // "..."
+            if (len > capForText - needed) {
+                len = capForText - needed;
+                nodeName[len] = '\0';
             }
-            strcat(nodeName, "...");
+            std::strcat(nodeName, "...");
         }
     }
 
     return nodeName;
 }
 
-const char *getCurrentModeTitle(int screenWidth)
+const char *getCurrentModeTitle_Nodes(int screenWidth)
 {
-    switch (currentMode) {
+    switch (currentMode_Nodes) {
     case MODE_LAST_HEARD:
         return "Last Heard";
     case MODE_HOP_SIGNAL:
 #ifdef USE_EINK
         return "Hops/Sig";
 #else
-        return (isHighResolution) ? "Hops/Signal" : "Hops/Sig";
+        return (currentResolution == ScreenResolution::High) ? "Hops/Signal" : "Hops/Sig";
 #endif
+    default:
+        return "Nodes";
+    }
+}
+
+const char *getCurrentModeTitle_Location(int screenWidth)
+{
+    switch (currentMode_Location) {
     case MODE_DISTANCE:
         return "Distance";
+    case MODE_BEARING:
+        return "Bearings";
     default:
         return "Nodes";
     }
@@ -137,10 +176,8 @@ int calculateMaxScroll(int totalEntries, int visibleRows)
 
 void drawColumnSeparator(OLEDDisplay *display, int16_t x, int16_t yStart, int16_t yEnd)
 {
-    int columnWidth = display->getWidth() / 2;
-    int separatorX = x + columnWidth - 2;
     for (int y = yStart; y <= yEnd; y += 2) {
-        display->setPixel(separatorX, y);
+        display->setPixel(x, y);
     }
 }
 
@@ -152,7 +189,8 @@ void drawScrollbar(OLEDDisplay *display, int visibleNodeRows, int totalEntries,
     int scrollbarX = display->getWidth() - 2;
     int scrollbarHeight = display->getHeight() - scrollStartY - 10;
     int thumbHeight = std::max(4, (scrollbarHeight * visibleNodeRows * columns) / totalEntries);
-    int maxScroll = calculateMaxScroll(totalEntries, visibleNodeRows);
+    int perPage = visibleNodeRows * columns;
+    int maxScroll = std::max(0, (totalEntries - 1) / perPage);
     int thumbY = scrollStartY + (scrollIndex * (scrollbarHeight - thumbHeight)) / std::max(1, maxScroll);
 
     for (int i = 0; i < thumbHeight; i++) {
@@ -167,9 +205,9 @@ void drawScrollbar(OLEDDisplay *display, int visibleNodeRows, int totalEntries,
 void drawEntryLastHeard(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16_t x, int16_t y, int columnWidth)
 {
     bool isLeftCol = (x < SCREEN_WIDTH / 2);
-    int timeOffset = (isHighResolution) ? (isLeftCol ? 7 : 10) : (isLeftCol ? 3 : 7);
+    int timeOffset = (currentResolution == ScreenResolution::High) ? (isLeftCol ? 7 : 10) : (isLeftCol ? 3 : 7);
 
-    const char *nodeName = getSafeNodeName(display, node);
+    const char *nodeName = getSafeNodeName(display, node, columnWidth);
 
     char timeStr[10];
     uint32_t seconds = sinceLastSeen(node);
@@ -188,9 +226,9 @@ void drawEntryLastHeard(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int
 
     display->setTextAlignment(TEXT_ALIGN_LEFT);
     display->setFont(FONT_SMALL);
-    display->drawString(x + ((isHighResolution) ? 6 : 3), y, nodeName);
+    display->drawString(x + ((currentResolution == ScreenResolution::High) ? 6 : 3), y, nodeName);
     if (node->is_favorite) {
-        if (isHighResolution) {
+        if (currentResolution == ScreenResolution::High) {
             drawScaledXBitmap16x16(x, y + 6, smallbulletpoint_width, smallbulletpoint_height, smallbulletpoint, display);
         } else {
             display->drawXbm(x, y + 5, smallbulletpoint_width, smallbulletpoint_height, smallbulletpoint);
@@ -209,19 +247,19 @@ void drawEntryHopSignal(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int
     bool isLeftCol = (x < SCREEN_WIDTH / 2);
 
     int nameMaxWidth = columnWidth - 25;
-    int barsOffset = (isHighResolution) ? (isLeftCol ? 20 : 24) : (isLeftCol ? 15 : 19);
-    int hopOffset = (isHighResolution) ? (isLeftCol ? 21 : 29) : (isLeftCol ? 13 : 17);
+    int barsOffset = (currentResolution == ScreenResolution::High) ? (isLeftCol ? 20 : 24) : (isLeftCol ? 15 : 19);
+    int hopOffset = (currentResolution == ScreenResolution::High) ? (isLeftCol ? 21 : 29) : (isLeftCol ? 13 : 17);
 
     int barsXOffset = columnWidth - barsOffset;
 
-    const char *nodeName = getSafeNodeName(display, node);
+    const char *nodeName = getSafeNodeName(display, node, columnWidth);
 
     display->setTextAlignment(TEXT_ALIGN_LEFT);
     display->setFont(FONT_SMALL);
 
-    display->drawStringMaxWidth(x + ((isHighResolution) ? 6 : 3), y, nameMaxWidth, nodeName);
+    display->drawStringMaxWidth(x + ((currentResolution == ScreenResolution::High) ? 6 : 3), y, nameMaxWidth, nodeName);
     if (node->is_favorite) {
-        if (isHighResolution) {
+        if (currentResolution == ScreenResolution::High) {
             drawScaledXBitmap16x16(x, y + 6, smallbulletpoint_width, smallbulletpoint_height, smallbulletpoint, display);
         } else {
             display->drawXbm(x, y + 5, smallbulletpoint_width, smallbulletpoint_height, smallbulletpoint);
@@ -256,9 +294,10 @@ void drawEntryHopSignal(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int
 void drawNodeDistance(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16_t x, int16_t y, int columnWidth)
 {
     bool isLeftCol = (x < SCREEN_WIDTH / 2);
-    int nameMaxWidth = columnWidth - (isHighResolution ? (isLeftCol ? 25 : 28) : (isLeftCol ? 20 : 22));
+    int nameMaxWidth =
+        columnWidth - ((currentResolution == ScreenResolution::High) ? (isLeftCol ? 25 : 28) : (isLeftCol ? 20 : 22));
 
-    const char *nodeName = getSafeNodeName(display, node);
+    const char *nodeName = getSafeNodeName(display, node, columnWidth);
     char distStr[10] = "";
 
     meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
@@ -311,9 +350,9 @@ void drawNodeDistance(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16
 
     display->setTextAlignment(TEXT_ALIGN_LEFT);
     display->setFont(FONT_SMALL);
-    display->drawStringMaxWidth(x + ((isHighResolution) ? 6 : 3), y, nameMaxWidth, nodeName);
+    display->drawStringMaxWidth(x + ((currentResolution == ScreenResolution::High) ? 6 : 3), y, nameMaxWidth, nodeName);
     if (node->is_favorite) {
-        if (isHighResolution) {
+        if (currentResolution == ScreenResolution::High) {
             drawScaledXBitmap16x16(x, y + 6, smallbulletpoint_width, smallbulletpoint_height, smallbulletpoint, display);
         } else {
             display->drawXbm(x, y + 5, smallbulletpoint_width, smallbulletpoint_height, smallbulletpoint);
@@ -321,26 +360,24 @@ void drawNodeDistance(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16
     }
 
     if (strlen(distStr) > 0) {
-        int offset = (isHighResolution) ? (isLeftCol ? 7 : 10) // Offset for Wide Screens (Left Column:Right Column)
-                                        : (isLeftCol ? 4 : 7); // Offset for Narrow Screens (Left Column:Right Column)
+        int offset = (currentResolution == ScreenResolution::High)
+                         ? (isLeftCol ? 7 : 10) // Offset for Wide Screens (Left Column:Right Column)
+                         : (isLeftCol ? 4 : 7); // Offset for Narrow Screens (Left Column:Right Column)
         int rightEdge = x + columnWidth - offset;
         int textWidth = display->getStringWidth(distStr);
         display->drawString(rightEdge - textWidth, y, distStr);
     }
 }
 
-void drawEntryDynamic(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16_t x, int16_t y, int columnWidth)
+void drawEntryDynamic_Nodes(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16_t x, int16_t y, int columnWidth)
 {
-    switch (currentMode) {
+    switch (currentMode_Nodes) {
     case MODE_LAST_HEARD:
         drawEntryLastHeard(display, node, x, y, columnWidth);
         break;
     case MODE_HOP_SIGNAL:
         drawEntryHopSignal(display, node, x, y, columnWidth);
         break;
-    case MODE_DISTANCE:
-        drawNodeDistance(display, node, x, y, columnWidth);
-        break;
     default:
         break;
     }
@@ -351,15 +388,16 @@ void drawEntryCompass(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16
     bool isLeftCol = (x < SCREEN_WIDTH / 2);
 
     // Adjust max text width depending on column and screen width
-    int nameMaxWidth = columnWidth - (isHighResolution ? (isLeftCol ? 25 : 28) : (isLeftCol ? 20 : 22));
+    int nameMaxWidth =
+        columnWidth - ((currentResolution == ScreenResolution::High) ? (isLeftCol ? 25 : 28) : (isLeftCol ? 20 : 22));
 
-    const char *nodeName = getSafeNodeName(display, node);
+    const char *nodeName = getSafeNodeName(display, node, columnWidth);
 
     display->setTextAlignment(TEXT_ALIGN_LEFT);
     display->setFont(FONT_SMALL);
-    display->drawStringMaxWidth(x + ((isHighResolution) ? 6 : 3), y, nameMaxWidth, nodeName);
+    display->drawStringMaxWidth(x + ((currentResolution == ScreenResolution::High) ? 6 : 3), y, nameMaxWidth, nodeName);
     if (node->is_favorite) {
-        if (isHighResolution) {
+        if (currentResolution == ScreenResolution::High) {
             drawScaledXBitmap16x16(x, y + 6, smallbulletpoint_width, smallbulletpoint_height, smallbulletpoint, display);
         } else {
             display->drawXbm(x, y + 5, smallbulletpoint_width, smallbulletpoint_height, smallbulletpoint);
@@ -374,7 +412,7 @@ void drawCompassArrow(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16
         return;
 
     bool isLeftCol = (x < SCREEN_WIDTH / 2);
-    int arrowXOffset = (isHighResolution) ? (isLeftCol ? 22 : 24) : (isLeftCol ? 12 : 18);
+    int arrowXOffset = (currentResolution == ScreenResolution::High) ? (isLeftCol ? 22 : 24) : (isLeftCol ? 12 : 18);
 
     int centerX = x + columnWidth - arrowXOffset;
     int centerY = y + FONT_HEIGHT_SMALL / 2;
@@ -431,11 +469,6 @@ void drawNodeListScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t
         locationScreen = true;
     else if (strcmp(title, "Distance") == 0)
         locationScreen = true;
-#if defined(M5STACK_UNITC6L)
-    int columnWidth = display->getWidth();
-#else
-    int columnWidth = display->getWidth() / 2;
-#endif
     display->clear();
 
     // Draw the battery/time header
@@ -444,39 +477,74 @@ void drawNodeListScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t
     // Space below header
     y += COMMON_HEADER_HEIGHT;
 
+    int totalColumns = 1; // Default to 1 column
+
+    if (config.display.use_long_node_name) {
+        if (SCREEN_WIDTH <= 240) {
+            totalColumns = 1;
+        } else if (SCREEN_WIDTH > 240) {
+            totalColumns = 2;
+        }
+    } else {
+        if (SCREEN_WIDTH <= 64) {
+            totalColumns = 1;
+        } else if (SCREEN_WIDTH > 64 && SCREEN_WIDTH <= 240) {
+            totalColumns = 2;
+        } else {
+            totalColumns = 3;
+        }
+    }
+
+    int columnWidth = display->getWidth() / totalColumns;
+
     int totalEntries = nodeDB->getNumMeshNodes();
     int totalRowsAvailable = (display->getHeight() - y) / rowYOffset;
     int numskipped = 0;
     int visibleNodeRows = totalRowsAvailable;
-#if defined(M5STACK_UNITC6L)
-    int totalColumns = 1;
-#else
-    int totalColumns = 2;
-#endif
-    int startIndex = scrollIndex * visibleNodeRows * totalColumns;
-    if (nodeDB->getMeshNodeByIndex(startIndex)->num == nodeDB->getNodeNum()) {
-        startIndex++; // skip own node
-    }
-    int endIndex = std::min(startIndex + visibleNodeRows * totalColumns, totalEntries);
 
+    // Build filtered + ordered list
+    std::vector<int> drawList;
+    drawList.reserve(totalEntries);
+    for (int i = 0; i < totalEntries; i++) {
+        auto *n = nodeDB->getMeshNodeByIndex(i);
+
+        if (!n)
+            continue;
+        if (n->num == nodeDB->getNodeNum())
+            continue;
+        if (locationScreen && !n->has_position)
+            continue;
+
+        drawList.push_back(n->num);
+    }
+    totalEntries = drawList.size();
+    int perPage = visibleNodeRows * totalColumns;
+
+    int maxScroll = 0;
+    if (perPage > 0) {
+        maxScroll = std::max(0, (totalEntries - 1) / perPage);
+    }
+
+    if (scrollIndex > maxScroll)
+        scrollIndex = maxScroll;
+    int startIndex = scrollIndex * visibleNodeRows * totalColumns;
+    int endIndex = std::min(startIndex + visibleNodeRows * totalColumns, totalEntries);
     int yOffset = 0;
     int col = 0;
     int lastNodeY = y;
     int shownCount = 0;
     int rowCount = 0;
 
-    for (int i = startIndex; i < endIndex; ++i) {
-        if (locationScreen && !nodeDB->getMeshNodeByIndex(i)->has_position) {
-            numskipped++;
-            continue;
-        }
+    for (int idx = startIndex; idx < endIndex; idx++) {
+        uint32_t nodeNum = drawList[idx];
+        auto *node = nodeDB->getMeshNode(nodeNum);
         int xPos = x + (col * columnWidth);
         int yPos = y + yOffset;
-        renderer(display, nodeDB->getMeshNodeByIndex(i), xPos, yPos, columnWidth);
 
-        if (extras) {
-            extras(display, nodeDB->getMeshNodeByIndex(i), xPos, yPos, columnWidth, heading, lat, lon);
-        }
+        renderer(display, node, xPos, yPos, columnWidth);
+
+        if (extras)
+            extras(display, node, xPos, yPos, columnWidth, heading, lat, lon);
 
         lastNodeY = std::max(lastNodeY, yPos + FONT_HEIGHT_SMALL);
         yOffset += rowYOffset;
@@ -495,17 +563,73 @@ 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) {
+    if (currentResolution != ScreenResolution::UltraLow && shownCount > 0) {
         const int firstNodeY = y + 3;
-        drawColumnSeparator(display, x, firstNodeY, lastNodeY);
+        for (int horizontal_offset = 1; horizontal_offset < totalColumns; horizontal_offset++) {
+            drawColumnSeparator(display, columnWidth * horizontal_offset, firstNodeY, lastNodeY);
+        }
     }
 
-#endif
     const int scrollStartY = y + 3;
-    drawScrollbar(display, visibleNodeRows, totalEntries, scrollIndex, 2, scrollStartY);
+    drawScrollbar(display, visibleNodeRows, totalEntries, scrollIndex, totalColumns, scrollStartY);
     graphics::drawCommonFooter(display, x, y);
+
+    // Scroll Popup Overlay
+    if (millis() - popupTime < POPUP_DURATION_MS) {
+        popupTotal = totalEntries;
+
+        int perPage = visibleNodeRows * totalColumns;
+
+        popupStart = startIndex + 1;
+        popupEnd = std::min(startIndex + perPage, totalEntries);
+
+        popupPage = (scrollIndex + 1);
+        popupMaxPage = std::max(1, (totalEntries + perPage - 1) / perPage);
+
+        char buf[32];
+        snprintf(buf, sizeof(buf), "%d-%d/%d  Pg %d/%d", popupStart, popupEnd, popupTotal, popupPage, popupMaxPage);
+
+        display->setTextAlignment(TEXT_ALIGN_LEFT);
+
+        // Box padding
+        int padding = 2;
+        int textW = display->getStringWidth(buf);
+        int textH = FONT_HEIGHT_SMALL;
+        int boxWidth = textW + padding * 3;
+        int boxHeight = textH + padding * 2;
+
+        // Center of usable screen area:
+        int headerHeight = FONT_HEIGHT_SMALL - 1;
+        int footerHeight = FONT_HEIGHT_SMALL + 2;
+
+        int usableTop = headerHeight;
+        int usableBottom = display->getHeight() - footerHeight;
+        int usableHeight = usableBottom - usableTop;
+
+        // Center point inside usable area
+        int boxLeft = (display->getWidth() - boxWidth) / 2;
+        int boxTop = usableTop + (usableHeight - boxHeight) / 2;
+
+        // Draw Box
+        display->setColor(BLACK);
+        display->fillRect(boxLeft - 1, boxTop - 1, boxWidth + 2, boxHeight + 2);
+        display->fillRect(boxLeft, boxTop - 2, boxWidth, 1);
+        display->fillRect(boxLeft, boxTop + boxHeight + 1, boxWidth, 1);
+        display->fillRect(boxLeft - 2, boxTop, 1, boxHeight);
+        display->fillRect(boxLeft + boxWidth + 1, boxTop, 1, boxHeight);
+        display->setColor(WHITE);
+        display->drawRect(boxLeft, boxTop, boxWidth, boxHeight);
+        display->setColor(BLACK);
+        display->fillRect(boxLeft, boxTop, 1, 1);
+        display->fillRect(boxLeft + boxWidth - 1, boxTop, 1, 1);
+        display->fillRect(boxLeft, boxTop + boxHeight - 1, 1, 1);
+        display->fillRect(boxLeft + boxWidth - 1, boxTop + boxHeight - 1, 1, 1);
+        display->setColor(WHITE);
+
+        // Text
+        display->drawString(boxLeft + padding, boxTop + padding, buf);
+    }
 }
 
 // =============================
@@ -513,10 +637,11 @@ void drawNodeListScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t
 // =============================
 
 #ifndef USE_EINK
-void drawDynamicNodeListScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
+// Node list for Last Heard and Hop Signal views
+void drawDynamicListScreen_Nodes(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
 {
     // Static variables to track mode and duration
-    static NodeListMode lastRenderedMode = MODE_COUNT;
+    static ListMode_Node lastRenderedMode = MODE_COUNT_NODE;
     static unsigned long modeStartTime = 0;
 
     unsigned long now = millis();
@@ -529,23 +654,65 @@ void drawDynamicNodeListScreen(OLEDDisplay *display, OLEDDisplayUiState *state,
     }
 #endif
     // On very first call (on boot or state enter)
-    if (lastRenderedMode == MODE_COUNT) {
-        currentMode = MODE_LAST_HEARD;
+    if (lastRenderedMode == MODE_COUNT_NODE) {
+        currentMode_Nodes = MODE_LAST_HEARD;
         modeStartTime = now;
     }
 
     // Time to switch to next mode?
     if (now - modeStartTime >= getModeCycleIntervalMs()) {
-        currentMode = static_cast<NodeListMode>((currentMode + 1) % MODE_COUNT);
+        currentMode_Nodes = static_cast<ListMode_Node>((currentMode_Nodes + 1) % MODE_COUNT_NODE);
         modeStartTime = now;
     }
 
     // Render screen based on currentMode
-    const char *title = getCurrentModeTitle(display->getWidth());
-    drawNodeListScreen(display, state, x, y, title, drawEntryDynamic);
+    const char *title = getCurrentModeTitle_Nodes(display->getWidth());
+    drawNodeListScreen(display, state, x, y, title, drawEntryDynamic_Nodes);
 
     // Track the last mode to avoid reinitializing modeStartTime
-    lastRenderedMode = currentMode;
+    lastRenderedMode = currentMode_Nodes;
+}
+
+// Node list for Distance and Bearings views
+void drawDynamicListScreen_Location(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
+{
+    // Static variables to track mode and duration
+    static ListMode_Location lastRenderedMode = MODE_COUNT_LOCATION;
+    static unsigned long modeStartTime = 0;
+
+    unsigned long now = millis();
+
+#if defined(M5STACK_UNITC6L)
+    display->clear();
+    if (now - lastSwitchTime >= 3000) {
+        display->display();
+        lastSwitchTime = now;
+    }
+#endif
+    // On very first call (on boot or state enter)
+    if (lastRenderedMode == MODE_COUNT_LOCATION) {
+        currentMode_Location = MODE_DISTANCE;
+        modeStartTime = now;
+    }
+
+    // Time to switch to next mode?
+    if (now - modeStartTime >= getModeCycleIntervalMs()) {
+        currentMode_Location = static_cast<ListMode_Location>((currentMode_Location + 1) % MODE_COUNT_LOCATION);
+        modeStartTime = now;
+    }
+
+    // Render screen based on currentMode
+    const char *title = getCurrentModeTitle_Location(display->getWidth());
+
+    // Render screen based on currentMode_Location
+    if (currentMode_Location == MODE_DISTANCE) {
+        drawNodeListScreen(display, state, x, y, title, drawNodeDistance);
+    } else if (currentMode_Location == MODE_BEARING) {
+        drawNodeListWithCompasses(display, state, x, y);
+    }
+
+    // Track the last mode to avoid reinitializing modeStartTime
+    lastRenderedMode = currentMode_Location;
 }
 #endif
 
@@ -566,14 +733,12 @@ void drawHopSignalScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_
 #endif
     drawNodeListScreen(display, state, x, y, title, drawEntryHopSignal);
 }
-
 void drawDistanceScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
 {
     const char *title = "Distance";
     drawNodeListScreen(display, state, x, y, title, drawNodeDistance);
 }
 #endif
-
 void drawNodeListWithCompasses(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
 {
     float heading = 0;

src/graphics/draw/NodeListRenderer.h

@@ -23,8 +23,11 @@ namespace NodeListRenderer
 typedef void (*EntryRenderer)(OLEDDisplay *, meshtastic_NodeInfoLite *, int16_t, int16_t, int);
 typedef void (*NodeExtrasRenderer)(OLEDDisplay *, meshtastic_NodeInfoLite *, int16_t, int16_t, int, float, double, double);
 
-// Node list mode enumeration
-enum NodeListMode { MODE_LAST_HEARD = 0, MODE_HOP_SIGNAL = 1, MODE_DISTANCE = 2, MODE_COUNT = 3 };
+// Node list mode enumeration for Last Heard and Hop Signal views
+enum ListMode_Node { MODE_LAST_HEARD = 0, MODE_HOP_SIGNAL = 1, MODE_COUNT_NODE = 2 };
+
+// Node list mode enumeration for Distance and Bearings views
+enum ListMode_Location { MODE_DISTANCE = 0, MODE_BEARING = 1, MODE_COUNT_LOCATION = 2 };
 
 // Main node list screen function
 void drawNodeListScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y, const char *title,
@@ -35,7 +38,7 @@ void drawNodeListScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t
 void drawEntryLastHeard(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16_t x, int16_t y, int columnWidth);
 void drawEntryHopSignal(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16_t x, int16_t y, int columnWidth);
 void drawNodeDistance(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16_t x, int16_t y, int columnWidth);
-void drawEntryDynamic(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16_t x, int16_t y, int columnWidth);
+void drawEntryDynamic_Nodes(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16_t x, int16_t y, int columnWidth);
 void drawEntryCompass(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16_t x, int16_t y, int columnWidth);
 
 // Extras renderers
@@ -46,14 +49,20 @@ void drawCompassArrow(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16
 void drawLastHeardScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);
 void drawHopSignalScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);
 void drawDistanceScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);
-void drawDynamicNodeListScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);
+void drawDynamicListScreen_Nodes(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);
+void drawDynamicListScreen_Location(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);
 void drawNodeListWithCompasses(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);
 
 // Utility functions
-const char *getCurrentModeTitle(int screenWidth);
-const char *getSafeNodeName(meshtastic_NodeInfoLite *node);
+const char *getCurrentModeTitle_Nodes(int screenWidth);
+const char *getCurrentModeTitle_Location(int screenWidth);
+const char *getSafeNodeName(meshtastic_NodeInfoLite *node, int columnWidth);
 void drawColumns(OLEDDisplay *display, int16_t x, int16_t y, const char **fields);
 
+// Scrolling controls
+void scrollUp();
+void scrollDown();
+
 // Bitmap drawing function
 void drawScaledXBitmap16x16(int x, int y, int width, int height, const uint8_t *bitmapXBM, OLEDDisplay *display);
 

src/graphics/draw/NotificationRenderer.cpp

@@ -1,6 +1,6 @@
 #include "configuration.h"
-#if HAS_SCREEN
 
+#if HAS_SCREEN
 #include "DisplayFormatters.h"
 #include "NodeDB.h"
 #include "NotificationRenderer.h"
@@ -38,7 +38,7 @@ extern bool hasUnreadMessage;
 
 namespace graphics
 {
-
+int bannerSignalBars = -1;
 InputEvent NotificationRenderer::inEvent;
 int8_t NotificationRenderer::curSelected = 0;
 char NotificationRenderer::alertBannerMessage[256] = {0};
@@ -321,7 +321,7 @@ void NotificationRenderer::drawNodePicker(OLEDDisplay *display, OLEDDisplayUiSta
         }
         if (i == curSelected) {
             selectedNodenum = nodeDB->getMeshNodeByIndex(i + 1)->num;
-            if (isHighResolution) {
+            if (currentResolution == ScreenResolution::High) {
                 strncpy(scratchLineBuffer[scratchLineNum], "> ", 3);
                 strncpy(scratchLineBuffer[scratchLineNum] + 2, temp_name, 36);
                 strncpy(scratchLineBuffer[scratchLineNum] + strlen(temp_name) + 2, " <", 3);
@@ -449,7 +449,7 @@ void NotificationRenderer::drawAlertBannerOverlay(OLEDDisplay *display, OLEDDisp
 
     for (int i = firstOptionToShow; i < alertBannerOptions && linesShown < visibleTotalLines; i++, linesShown++) {
         if (i == curSelected) {
-            if (isHighResolution) {
+            if (currentResolution == ScreenResolution::High) {
                 strncpy(lineBuffer, "> ", 3);
                 strncpy(lineBuffer + 2, optionsArrayPtr[i], 36);
                 strncpy(lineBuffer + strlen(optionsArrayPtr[i]) + 2, " <", 3);
@@ -477,7 +477,7 @@ void NotificationRenderer::drawNotificationBox(OLEDDisplay *display, OLEDDisplay
 
     bool is_picker = false;
     uint16_t lineCount = 0;
-    // === Layout Configuration ===
+    // Layout Configuration
     constexpr uint16_t hPadding = 5;
     constexpr uint16_t vPadding = 2;
     bool needs_bell = false;
@@ -491,13 +491,32 @@ void NotificationRenderer::drawNotificationBox(OLEDDisplay *display, OLEDDisplay
     display->setFont(FONT_SMALL);
     display->setTextAlignment(TEXT_ALIGN_LEFT);
 
+    // Track widest line INCLUDING bars (but don't change per-line widths)
+    uint16_t widestLineWithBars = 0;
+
     while (lines[lineCount] != nullptr) {
         auto newlinePointer = strchr(lines[lineCount], '\n');
         if (newlinePointer)
             lineLengths[lineCount] = (newlinePointer - lines[lineCount]); // Check for newlines first
         else // if the newline wasn't found, then pull string length from strlen
             lineLengths[lineCount] = strlen(lines[lineCount]);
+
         lineWidths[lineCount] = display->getStringWidth(lines[lineCount], lineLengths[lineCount], true);
+
+        // Consider extra width for signal bars on lines that contain "Signal:"
+        uint16_t potentialWidth = lineWidths[lineCount];
+        if (graphics::bannerSignalBars >= 0 && strncmp(lines[lineCount], "Signal:", 7) == 0) {
+            const int totalBars = 5;
+            const int barWidth = 3;
+            const int barSpacing = 2;
+            const int gap = 6; // space between text and bars
+            int barsWidth = totalBars * barWidth + (totalBars - 1) * barSpacing + gap;
+            potentialWidth += barsWidth;
+        }
+
+        if (potentialWidth > widestLineWithBars)
+            widestLineWithBars = potentialWidth;
+
         if (!is_picker) {
             needs_bell |= (strstr(alertBannerMessage, "Alert Received") != nullptr);
             if (lineWidths[lineCount] > maxWidth)
@@ -507,12 +526,16 @@ void NotificationRenderer::drawNotificationBox(OLEDDisplay *display, OLEDDisplay
     }
     // count lines
 
+    // Ensure box accounts for signal bars if present
+    if (widestLineWithBars > maxWidth)
+        maxWidth = widestLineWithBars;
+
     uint16_t boxWidth = hPadding * 2 + maxWidth;
-#if defined(M5STACK_UNITC6L)
+
     if (needs_bell) {
-        if (isHighResolution && boxWidth <= 150)
+        if ((currentResolution == ScreenResolution::High) && boxWidth <= 150)
             boxWidth += 26;
-        if (!isHighResolution && boxWidth <= 100)
+        if ((currentResolution == ScreenResolution::Low || currentResolution == ScreenResolution::UltraLow) && boxWidth <= 100)
             boxWidth += 20;
     }
 
@@ -521,14 +544,17 @@ void NotificationRenderer::drawNotificationBox(OLEDDisplay *display, OLEDDisplay
     uint8_t visibleTotalLines = std::min<uint8_t>(lineCount, (screenHeight - vPadding * 2) / effectiveLineHeight);
     uint16_t contentHeight = visibleTotalLines * effectiveLineHeight;
     uint16_t boxHeight = contentHeight + vPadding * 2;
-    if (visibleTotalLines == 1)
-        boxHeight += (isHighResolution ? 4 : 3);
+    if (visibleTotalLines == 1) {
+        boxHeight += (currentResolution == ScreenResolution::High) ? 4 : 3;
+    }
 
     int16_t boxLeft = (display->width() / 2) - (boxWidth / 2);
-    if (totalLines > visibleTotalLines)
-        boxWidth += (isHighResolution ? 4 : 2);
+    if (totalLines > visibleTotalLines) {
+        boxWidth += (currentResolution == ScreenResolution::High) ? 4 : 2;
+    }
     int16_t boxTop = (display->height() / 2) - (boxHeight / 2);
-
+    boxHeight += (currentResolution == ScreenResolution::High) ? 2 : 1;
+#if defined(M5STACK_UNITC6L)
     if (visibleTotalLines == 1) {
         boxTop += 25;
     }
@@ -539,127 +565,9 @@ void NotificationRenderer::drawNotificationBox(OLEDDisplay *display, OLEDDisplay
         if (boxTop < 0)
             boxTop = 0;
     }
+#endif
 
-    // === Draw Box ===
-    display->setColor(BLACK);
-    display->fillRect(boxLeft, boxTop, boxWidth, boxHeight);
-    display->setColor(WHITE);
-    display->drawRect(boxLeft, boxTop, boxWidth, boxHeight);
-    display->fillRect(boxLeft, boxTop - 2, boxWidth, 1);
-    display->fillRect(boxLeft - 2, boxTop, 1, boxHeight);
-    display->fillRect(boxLeft + boxWidth + 1, boxTop, 1, boxHeight);
-    display->setColor(BLACK);
-    display->fillRect(boxLeft, boxTop, 1, 1);
-    display->fillRect(boxLeft + boxWidth - 1, boxTop, 1, 1);
-    display->fillRect(boxLeft, boxTop + boxHeight - 1, 1, 1);
-    display->fillRect(boxLeft + boxWidth - 1, boxTop + boxHeight - 1, 1, 1);
-    display->setColor(WHITE);
-    int16_t lineY = boxTop + vPadding;
-    int swingRange = 8;
-    static int swingOffset = 0;
-    static bool swingRight = true;
-    static unsigned long lastSwingTime = 0;
-    unsigned long now = millis();
-    int swingSpeedMs = 10 / (swingRange * 2);
-    if (now - lastSwingTime >= (unsigned long)swingSpeedMs) {
-        lastSwingTime = now;
-        if (swingRight) {
-            swingOffset++;
-            if (swingOffset >= swingRange)
-                swingRight = false;
-        } else {
-            swingOffset--;
-            if (swingOffset <= 0)
-                swingRight = true;
-        }
-    }
-    for (int i = 0; i < lineCount; i++) {
-        bool isTitle = (i == 0);
-        int globalOptionIndex = (i - 1) + firstOptionToShow;
-        bool isSelectedOption = (!isTitle && globalOptionIndex >= 0 && globalOptionIndex == curSelected);
-
-        uint16_t visibleWidth = 64 - hPadding * 2;
-        if (totalLines > visibleTotalLines)
-            visibleWidth -= 6;
-        char lineBuffer[lineLengths[i] + 1];
-        strncpy(lineBuffer, lines[i], lineLengths[i]);
-        lineBuffer[lineLengths[i]] = '\0';
-
-        if (isTitle) {
-            if (visibleTotalLines == 1) {
-                display->setColor(BLACK);
-                display->fillRect(boxLeft, boxTop, boxWidth, effectiveLineHeight);
-                display->setColor(WHITE);
-                display->drawString(boxLeft + (boxWidth - lineWidths[i]) / 2, boxTop, lineBuffer);
-            } else {
-                display->setColor(WHITE);
-                display->fillRect(boxLeft, boxTop, boxWidth, effectiveLineHeight);
-                display->setColor(BLACK);
-                display->drawString(boxLeft + (boxWidth - lineWidths[i]) / 2, boxTop, lineBuffer);
-                display->setColor(WHITE);
-                if (needs_bell) {
-                    int bellY = boxTop + (FONT_HEIGHT_SMALL - 8) / 2;
-                    display->drawXbm(boxLeft + (boxWidth - lineWidths[i]) / 2 - 10, bellY, 8, 8, bell_alert);
-                    display->drawXbm(boxLeft + (boxWidth + lineWidths[i]) / 2 + 2, bellY, 8, 8, bell_alert);
-                }
-            }
-            lineY = boxTop + effectiveLineHeight + 1;
-        } else if (isSelectedOption) {
-            display->setColor(WHITE);
-            display->fillRect(boxLeft, lineY, boxWidth, effectiveLineHeight);
-            display->setColor(BLACK);
-            if (lineLengths[i] > 15 && lineWidths[i] > visibleWidth) {
-                int textX = boxLeft + hPadding + swingOffset;
-                display->drawString(textX, lineY - 1, lineBuffer);
-            } else {
-                display->drawString(boxLeft + (boxWidth - lineWidths[i]) / 2, lineY - 1, lineBuffer);
-            }
-            display->setColor(WHITE);
-            lineY += effectiveLineHeight;
-        } else {
-            display->setColor(BLACK);
-            display->fillRect(boxLeft, lineY, boxWidth, effectiveLineHeight);
-            display->setColor(WHITE);
-            display->drawString(boxLeft + (boxWidth - lineWidths[i]) / 2, lineY, lineBuffer);
-            lineY += effectiveLineHeight;
-        }
-    }
-    if (totalLines > visibleTotalLines) {
-        const uint8_t scrollBarWidth = 5;
-        int16_t scrollBarX = boxLeft + boxWidth - scrollBarWidth - 2;
-        int16_t scrollBarY = boxTop + vPadding + effectiveLineHeight;
-        uint16_t scrollBarHeight = boxHeight - vPadding * 2 - effectiveLineHeight;
-        float ratio = (float)visibleTotalLines / totalLines;
-        uint16_t indicatorHeight = std::max((int)(scrollBarHeight * ratio), 4);
-        float scrollRatio = (float)(firstOptionToShow + lineCount - visibleTotalLines) / (totalLines - visibleTotalLines);
-        uint16_t indicatorY = scrollBarY + scrollRatio * (scrollBarHeight - indicatorHeight);
-        display->drawRect(scrollBarX, scrollBarY, scrollBarWidth, scrollBarHeight);
-        display->fillRect(scrollBarX + 1, indicatorY, scrollBarWidth - 2, indicatorHeight);
-    }
-#else
-    if (needs_bell) {
-        if (isHighResolution && boxWidth <= 150)
-            boxWidth += 26;
-        if (!isHighResolution && boxWidth <= 100)
-            boxWidth += 20;
-    }
-
-    uint16_t screenHeight = display->height();
-    uint8_t effectiveLineHeight = FONT_HEIGHT_SMALL - 3;
-    uint8_t visibleTotalLines = std::min<uint8_t>(lineCount, (screenHeight - vPadding * 2) / effectiveLineHeight);
-    uint16_t contentHeight = visibleTotalLines * effectiveLineHeight;
-    uint16_t boxHeight = contentHeight + vPadding * 2;
-    if (visibleTotalLines == 1) {
-        boxHeight += (isHighResolution) ? 4 : 3;
-    }
-
-    int16_t boxLeft = (display->width() / 2) - (boxWidth / 2);
-    if (totalLines > visibleTotalLines) {
-        boxWidth += (isHighResolution) ? 4 : 2;
-    }
-    int16_t boxTop = (display->height() / 2) - (boxHeight / 2);
-
-    // === Draw Box ===
+    // Draw Box
     display->setColor(BLACK);
     display->fillRect(boxLeft - 1, boxTop - 1, boxWidth + 2, boxHeight + 2);
     display->fillRect(boxLeft, boxTop - 2, boxWidth, 1);
@@ -675,7 +583,7 @@ void NotificationRenderer::drawNotificationBox(OLEDDisplay *display, OLEDDisplay
     display->fillRect(boxLeft + boxWidth - 1, boxTop + boxHeight - 1, 1, 1);
     display->setColor(WHITE);
 
-    // === Draw Content ===
+    // Draw Content
     int16_t lineY = boxTop + vPadding;
     for (int i = 0; i < lineCount; i++) {
         int16_t textX = boxLeft + (boxWidth - lineWidths[i]) / 2;
@@ -704,17 +612,47 @@ void NotificationRenderer::drawNotificationBox(OLEDDisplay *display, OLEDDisplay
             lineY += (effectiveLineHeight - 2 - background_yOffset);
         } else {
             // Pop-up
-            display->drawString(textX, lineY, lineBuffer);
+            // If this is the Signal line, center text + bars as one group
+            bool isSignalLine = (graphics::bannerSignalBars >= 0 && strstr(lineBuffer, "Signal:") != nullptr);
+            if (isSignalLine) {
+                const int totalBars = 5;
+                const int barWidth = 3;
+                const int barSpacing = 2;
+                const int barHeightStep = 2;
+                const int gap = 6;
+
+                int textWidth = display->getStringWidth(lineBuffer, strlen(lineBuffer), true);
+                int barsWidth = totalBars * barWidth + (totalBars - 1) * barSpacing + gap;
+                int totalWidth = textWidth + barsWidth;
+                int groupStartX = boxLeft + (boxWidth - totalWidth) / 2;
+
+                display->drawString(groupStartX, lineY, lineBuffer);
+
+                int baseX = groupStartX + textWidth + gap;
+                int baseY = lineY + effectiveLineHeight - 1;
+                for (int b = 0; b < totalBars; b++) {
+                    int barHeight = (b + 1) * barHeightStep;
+                    int x = baseX + b * (barWidth + barSpacing);
+                    int y = baseY - barHeight;
+
+                    if (b < graphics::bannerSignalBars) {
+                        display->fillRect(x, y, barWidth, barHeight);
+                    } else {
+                        display->drawRect(x, y, barWidth, barHeight);
+                    }
+                }
+            } else {
+                display->drawString(textX, lineY, lineBuffer);
+            }
             lineY += (effectiveLineHeight);
         }
     }
 
-    // === Scroll Bar (Thicker, inside box, not over title) ===
+    // Scroll Bar (Thicker, inside box, not over title)
     if (totalLines > visibleTotalLines) {
         const uint8_t scrollBarWidth = 5;
-
         int16_t scrollBarX = boxLeft + boxWidth - scrollBarWidth - 2;
-        int16_t scrollBarY = boxTop + vPadding + effectiveLineHeight; // start after title line
+        int16_t scrollBarY = boxTop + vPadding + effectiveLineHeight;
         uint16_t scrollBarHeight = boxHeight - vPadding * 2 - effectiveLineHeight;
 
         float ratio = (float)visibleTotalLines / totalLines;
@@ -725,7 +663,6 @@ void NotificationRenderer::drawNotificationBox(OLEDDisplay *display, OLEDDisplay
         display->drawRect(scrollBarX, scrollBarY, scrollBarWidth, scrollBarHeight);
         display->fillRect(scrollBarX + 1, indicatorY, scrollBarWidth - 2, indicatorHeight);
     }
-#endif
 }
 
 /// Draw the last text message we received

src/graphics/draw/UIRenderer.cpp

@@ -6,10 +6,7 @@
 #include "NodeListRenderer.h"
 #include "UIRenderer.h"
 #include "airtime.h"
-#include "configuration.h"
 #include "gps/GeoCoord.h"
-#include "graphics/Screen.h"
-#include "graphics/ScreenFonts.h"
 #include "graphics/SharedUIDisplay.h"
 #include "graphics/TimeFormatters.h"
 #include "graphics/images.h"
@@ -29,6 +26,16 @@ namespace graphics
 NodeNum UIRenderer::currentFavoriteNodeNum = 0;
 std::vector<meshtastic_NodeInfoLite *> graphics::UIRenderer::favoritedNodes;
 
+static inline void drawSatelliteIcon(OLEDDisplay *display, int16_t x, int16_t y)
+{
+    int yOffset = (currentResolution == ScreenResolution::High) ? -5 : 1;
+    if (currentResolution == ScreenResolution::High) {
+        NodeListRenderer::drawScaledXBitmap16x16(x, y + yOffset, imgSatellite_width, imgSatellite_height, imgSatellite, display);
+    } else {
+        display->drawXbm(x + 1, y + yOffset, imgSatellite_width, imgSatellite_height, imgSatellite);
+    }
+}
+
 void graphics::UIRenderer::rebuildFavoritedNodes()
 {
     favoritedNodes.clear();
@@ -56,7 +63,7 @@ extern uint32_t dopThresholds[5];
 void UIRenderer::drawGps(OLEDDisplay *display, int16_t x, int16_t y, const meshtastic::GPSStatus *gps)
 {
     // Draw satellite image
-    if (isHighResolution) {
+    if (currentResolution == ScreenResolution::High) {
         NodeListRenderer::drawScaledXBitmap16x16(x, y - 2, imgSatellite_width, imgSatellite_height, imgSatellite, display);
     } else {
         display->drawXbm(x + 1, y + 1, imgSatellite_width, imgSatellite_height, imgSatellite);
@@ -76,7 +83,7 @@ void UIRenderer::drawGps(OLEDDisplay *display, int16_t x, int16_t y, const mesht
     } else {
         snprintf(textString, sizeof(textString), "%u sats", gps->getNumSatellites());
     }
-    if (isHighResolution) {
+    if (currentResolution == ScreenResolution::High) {
         display->drawString(x + 18, y, textString);
     } else {
         display->drawString(x + 11, y, textString);
@@ -244,16 +251,16 @@ void UIRenderer::drawGpsCoordinates(OLEDDisplay *display, int16_t x, int16_t y,
 
 // Draw nodes status
 void UIRenderer::drawNodes(OLEDDisplay *display, int16_t x, int16_t y, const meshtastic::NodeStatus *nodeStatus, int node_offset,
-                           bool show_total, String additional_words)
+                           bool show_total, const char *additional_words)
 {
     char usersString[20];
     int nodes_online = (nodeStatus->getNumOnline() > 0) ? nodeStatus->getNumOnline() + node_offset : 0;
 
-    snprintf(usersString, sizeof(usersString), "%d %s", nodes_online, additional_words.c_str());
+    snprintf(usersString, sizeof(usersString), "%d %s", nodes_online, additional_words);
 
     if (show_total) {
         int nodes_total = (nodeStatus->getNumTotal() > 0) ? nodeStatus->getNumTotal() + node_offset : 0;
-        snprintf(usersString, sizeof(usersString), "%d/%d %s", nodes_online, nodes_total, additional_words.c_str());
+        snprintf(usersString, sizeof(usersString), "%d/%d %s", nodes_online, nodes_total, additional_words);
     }
 
 #if (defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ILI9342_DRIVER) || defined(ST7701_CS) || defined(ST7735_CS) ||      \
@@ -261,19 +268,19 @@ void UIRenderer::drawNodes(OLEDDisplay *display, int16_t x, int16_t y, const mes
      defined(HACKADAY_COMMUNICATOR) || defined(USE_ST7796)) &&                                                                   \
     !defined(DISPLAY_FORCE_SMALL_FONTS)
 
-    if (isHighResolution) {
+    if (currentResolution == ScreenResolution::High) {
         NodeListRenderer::drawScaledXBitmap16x16(x, y - 1, 8, 8, imgUser, display);
     } else {
         display->drawFastImage(x, y + 3, 8, 8, imgUser);
     }
 #else
-    if (isHighResolution) {
+    if (currentResolution == ScreenResolution::High) {
         NodeListRenderer::drawScaledXBitmap16x16(x, y - 1, 8, 8, imgUser, display);
     } else {
         display->drawFastImage(x, y + 1, 8, 8, imgUser);
     }
 #endif
-    int string_offset = (isHighResolution) ? 9 : 0;
+    int string_offset = (currentResolution == ScreenResolution::High) ? 9 : 0;
     display->drawString(x + 10 + string_offset, y - 2, usersString);
 }
 
@@ -321,11 +328,12 @@ void UIRenderer::drawNodeInfo(OLEDDisplay *display, const OLEDDisplayUiState *st
     int line = 1; // which slot to use next
     std::string usernameStr;
     // === 1. Long Name (always try to show first) ===
-#if defined(M5STACK_UNITC6L)
-    const char *username = (node->has_user && node->user.long_name[0]) ? node->user.short_name : nullptr;
-#else
-    const char *username = (node->has_user && node->user.long_name[0]) ? node->user.long_name : nullptr;
-#endif
+    const char *username;
+    if (currentResolution == ScreenResolution::UltraLow) {
+        username = (node->has_user && node->user.long_name[0]) ? node->user.short_name : nullptr;
+    } else {
+        username = (node->has_user && node->user.long_name[0]) ? node->user.long_name : nullptr;
+    }
 
     if (username) {
         usernameStr = sanitizeString(username); // Sanitize the incoming long_name just in case
@@ -501,7 +509,7 @@ void UIRenderer::drawNodeInfo(OLEDDisplay *display, const OLEDDisplayUiState *st
             const int margin = 4;
 // --------- PATCH FOR EINK NAV BAR (ONLY CHANGE BELOW) -----------
 #if defined(USE_EINK)
-            const int iconSize = (isHighResolution) ? 16 : 8;
+            const int iconSize = (currentResolution == ScreenResolution::High) ? 16 : 8;
             const int navBarHeight = iconSize + 6;
 #else
             const int navBarHeight = 0;
@@ -559,11 +567,11 @@ void UIRenderer::drawDeviceFocused(OLEDDisplay *display, OLEDDisplayUiState *sta
     meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
 
     // === Header ===
-#if defined(M5STACK_UNITC6L)
-    graphics::drawCommonHeader(display, x, y, "Home");
-#else
-    graphics::drawCommonHeader(display, x, y, "");
-#endif
+    if (currentResolution == ScreenResolution::UltraLow) {
+        graphics::drawCommonHeader(display, x, y, "Home");
+    } else {
+        graphics::drawCommonHeader(display, x, y, "");
+    }
 
     // === Content below header ===
 
@@ -578,15 +586,15 @@ void UIRenderer::drawDeviceFocused(OLEDDisplay *display, OLEDDisplayUiState *sta
     config.display.heading_bold = false;
 
     // Display Region and Channel Utilization
-#if defined(M5STACK_UNITC6L)
-    drawNodes(display, x, getTextPositions(display)[line] + 2, nodeStatus, -1, false, "online");
-#else
-    drawNodes(display, x + 1, getTextPositions(display)[line] + 2, nodeStatus, -1, false, "online");
-#endif
+    if (currentResolution == ScreenResolution::UltraLow) {
+        drawNodes(display, x, getTextPositions(display)[line] + 2, nodeStatus, -1, false, "online");
+    } else {
+        drawNodes(display, x + 1, getTextPositions(display)[line] + 2, nodeStatus, -1, false, "online");
+    }
     char uptimeStr[32] = "";
-#if !defined(M5STACK_UNITC6L)
-    getUptimeStr(millis(), "Up", uptimeStr, sizeof(uptimeStr));
-#endif
+    if (currentResolution != ScreenResolution::UltraLow) {
+        getUptimeStr(millis(), "Up", uptimeStr, sizeof(uptimeStr));
+    }
     display->drawString(SCREEN_WIDTH - display->getStringWidth(uptimeStr), getTextPositions(display)[line++], uptimeStr);
 
     // === Second Row: Satellites and Voltage ===
@@ -600,15 +608,8 @@ void UIRenderer::drawDeviceFocused(OLEDDisplay *display, OLEDDisplayUiState *sta
         } else {
             displayLine = config.position.gps_mode == meshtastic_Config_PositionConfig_GpsMode_NOT_PRESENT ? "No GPS" : "GPS off";
         }
-        int yOffset = (isHighResolution) ? 3 : 1;
-        if (isHighResolution) {
-            NodeListRenderer::drawScaledXBitmap16x16(x, getTextPositions(display)[line] + yOffset - 5, imgSatellite_width,
-                                                     imgSatellite_height, imgSatellite, display);
-        } else {
-            display->drawXbm(x + 1, getTextPositions(display)[line] + yOffset, imgSatellite_width, imgSatellite_height,
-                             imgSatellite);
-        }
-        int xOffset = (isHighResolution) ? 6 : 0;
+        drawSatelliteIcon(display, x, getTextPositions(display)[line]);
+        int xOffset = (currentResolution == ScreenResolution::High) ? 6 : 0;
         display->drawString(x + 11 + xOffset, getTextPositions(display)[line], displayLine);
     } else {
         UIRenderer::drawGps(display, 0, getTextPositions(display)[line], gpsStatus);
@@ -647,21 +648,22 @@ void UIRenderer::drawDeviceFocused(OLEDDisplay *display, OLEDDisplayUiState *sta
     char chUtilPercentage[10];
     snprintf(chUtilPercentage, sizeof(chUtilPercentage), "%2.0f%%", airTime->channelUtilizationPercent());
 
-    int chUtil_x = (isHighResolution) ? display->getStringWidth(chUtil) + 10 : display->getStringWidth(chUtil) + 5;
+    int chUtil_x = (currentResolution == ScreenResolution::High) ? display->getStringWidth(chUtil) + 10
+                                                                 : display->getStringWidth(chUtil) + 5;
     int chUtil_y = getTextPositions(display)[line] + 3;
 
-    int chutil_bar_width = (isHighResolution) ? 100 : 50;
+    int chutil_bar_width = (currentResolution == ScreenResolution::High) ? 100 : 50;
     if (!config.bluetooth.enabled) {
 #if defined(USE_EINK)
-        chutil_bar_width = (isHighResolution) ? 50 : 30;
+        chutil_bar_width = (currentResolution == ScreenResolution::High) ? 50 : 30;
 #else
-        chutil_bar_width = (isHighResolution) ? 80 : 40;
+        chutil_bar_width = (currentResolution == ScreenResolution::High) ? 80 : 40;
 #endif
     }
-    int chutil_bar_height = (isHighResolution) ? 12 : 7;
-    int extraoffset = (isHighResolution) ? 6 : 3;
+    int chutil_bar_height = (currentResolution == ScreenResolution::High) ? 12 : 7;
+    int extraoffset = (currentResolution == ScreenResolution::High) ? 6 : 3;
     if (!config.bluetooth.enabled) {
-        extraoffset = (isHighResolution) ? 6 : 1;
+        extraoffset = (currentResolution == ScreenResolution::High) ? 6 : 1;
     }
     int chutil_percent = airTime->channelUtilizationPercent();
 
@@ -721,7 +723,7 @@ void UIRenderer::drawDeviceFocused(OLEDDisplay *display, OLEDDisplayUiState *sta
     // === Fourth & Fifth Rows: Node Identity ===
     int textWidth = 0;
     int nameX = 0;
-    int yOffset = (isHighResolution) ? 0 : 5;
+    int yOffset = (currentResolution == ScreenResolution::High) ? 0 : 5;
     std::string longNameStr;
 
     if (ourNode && ourNode->has_user && strlen(ourNode->user.long_name) > 0) {
@@ -759,7 +761,7 @@ void UIRenderer::drawDeviceFocused(OLEDDisplay *display, OLEDDisplayUiState *sta
 
 // Start Functions to write date/time to the screen
 // Helper function to check if a year is a leap year
-bool isLeapYear(int year)
+constexpr bool isLeapYear(int year)
 {
     return (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0));
 }
@@ -990,15 +992,8 @@ void UIRenderer::drawCompassAndLocationScreen(OLEDDisplay *display, OLEDDisplayU
         } else {
             displayLine = config.position.gps_mode == meshtastic_Config_PositionConfig_GpsMode_NOT_PRESENT ? "No GPS" : "GPS off";
         }
-        int yOffset = (isHighResolution) ? 3 : 1;
-        if (isHighResolution) {
-            NodeListRenderer::drawScaledXBitmap16x16(x, getTextPositions(display)[line] + yOffset - 5, imgSatellite_width,
-                                                     imgSatellite_height, imgSatellite, display);
-        } else {
-            display->drawXbm(x + 1, getTextPositions(display)[line] + yOffset, imgSatellite_width, imgSatellite_height,
-                             imgSatellite);
-        }
-        int xOffset = (isHighResolution) ? 6 : 0;
+        drawSatelliteIcon(display, x, getTextPositions(display)[line]);
+        int xOffset = (currentResolution == ScreenResolution::High) ? 6 : 0;
         display->drawString(x + 11 + xOffset, getTextPositions(display)[line++], displayLine);
     } else {
         // Onboard GPS
@@ -1156,7 +1151,7 @@ void UIRenderer::drawCompassAndLocationScreen(OLEDDisplay *display, OLEDDisplayU
 void UIRenderer::drawOEMIconScreen(const char *upperMsg, OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
 {
     static const uint8_t xbm[] = USERPREFS_OEM_IMAGE_DATA;
-    if (isHighResolution) {
+    if (currentResolution == ScreenResolution::High) {
         display->drawXbm(x + (SCREEN_WIDTH - USERPREFS_OEM_IMAGE_WIDTH) / 2,
                          y + (SCREEN_HEIGHT - FONT_HEIGHT_MEDIUM - USERPREFS_OEM_IMAGE_HEIGHT) / 2 + 2, USERPREFS_OEM_IMAGE_WIDTH,
                          USERPREFS_OEM_IMAGE_HEIGHT, xbm);
@@ -1181,7 +1176,7 @@ void UIRenderer::drawOEMIconScreen(const char *upperMsg, OLEDDisplay *display, O
 
     display->setTextAlignment(TEXT_ALIGN_LEFT);
     const char *title = USERPREFS_OEM_TEXT;
-    if (isHighResolution) {
+    if (currentResolution == ScreenResolution::High) {
         display->drawString(x + getStringCenteredX(title), y + SCREEN_HEIGHT - FONT_HEIGHT_MEDIUM, title);
     }
     display->setFont(FONT_SMALL);
@@ -1225,15 +1220,15 @@ void UIRenderer::drawNavigationBar(OLEDDisplay *display, OLEDDisplayUiState *sta
         lastFrameChangeTime = millis();
     }
 
-    const int iconSize = isHighResolution ? 16 : 8;
-    const int spacing = isHighResolution ? 8 : 4;
-    const int bigOffset = isHighResolution ? 1 : 0;
+    const int iconSize = (currentResolution == ScreenResolution::High) ? 16 : 8;
+    const int spacing = (currentResolution == ScreenResolution::High) ? 8 : 4;
+    const int bigOffset = (currentResolution == ScreenResolution::High) ? 1 : 0;
 
     const size_t totalIcons = screen->indicatorIcons.size();
     if (totalIcons == 0)
         return;
 
-    const int navPadding = isHighResolution ? 24 : 12; // padding per side
+    const int navPadding = (currentResolution == ScreenResolution::High) ? 24 : 12; // padding per side
 
     int usableWidth = SCREEN_WIDTH - (navPadding * 2);
     if (usableWidth < iconSize)
@@ -1300,7 +1295,7 @@ void UIRenderer::drawNavigationBar(OLEDDisplay *display, OLEDDisplayUiState *sta
             display->setColor(BLACK);
         }
 
-        if (isHighResolution) {
+        if (currentResolution == ScreenResolution::High) {
             NodeListRenderer::drawScaledXBitmap16x16(x, y, 8, 8, icon, display);
         } else {
             display->drawXbm(x, y, iconSize, iconSize, icon);
@@ -1315,7 +1310,7 @@ void UIRenderer::drawNavigationBar(OLEDDisplay *display, OLEDDisplayUiState *sta
     auto drawArrow = [&](bool rightSide) {
         display->setColor(WHITE);
 
-        const int offset = isHighResolution ? 3 : 1;
+        const int offset = (currentResolution == ScreenResolution::High) ? 3 : 1;
         const int halfH = rectHeight / 2;
 
         const int top = (y - 2) + (rectHeight - halfH) / 2;

src/graphics/draw/UIRenderer.h

@@ -34,7 +34,7 @@ class UIRenderer
   public:
     // Common UI elements
     static void drawNodes(OLEDDisplay *display, int16_t x, int16_t y, const meshtastic::NodeStatus *nodeStatus,
-                          int node_offset = 0, bool show_total = true, String additional_words = "");
+                          int node_offset = 0, bool show_total = true, const char *additional_words = "");
 
     // GPS status functions
     static void drawGps(OLEDDisplay *display, int16_t x, int16_t y, const meshtastic::GPSStatus *gpsStatus);
@@ -43,9 +43,6 @@ class UIRenderer
     static void drawGpsAltitude(OLEDDisplay *display, int16_t x, int16_t y, const meshtastic::GPSStatus *gpsStatus);
     static void drawGpsPowerStatus(OLEDDisplay *display, int16_t x, int16_t y, const meshtastic::GPSStatus *gpsStatus);
 
-    // Layout and utility functions
-    static void drawScrollbar(OLEDDisplay *display, int visibleItems, int totalItems, int scrollIndex, int x, int startY);
-
     // Overlay and special screens
     static void drawFrameText(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y, const char *text);
 
@@ -83,8 +80,6 @@ class UIRenderer
     static std::string drawTimeDelta(uint32_t days, uint32_t hours, uint32_t minutes, uint32_t seconds);
     static int formatDateTime(char *buffer, size_t bufferSize, uint32_t rtc_sec, OLEDDisplay *display, bool showTime);
 
-    // Message filtering
-    static bool shouldDrawMessage(const meshtastic_MeshPacket *packet);
     // Check if the display can render a string (detect special chars; emoji)
     static bool haveGlyphs(const char *str);
 }; // namespace UIRenderer

src/graphics/images.h

@@ -304,58 +304,6 @@ const uint8_t chirpy[] = {
     0x01, 0x18, 0x06, 0x18, 0xe0, 0x01, 0x18, 0x06, 0x18, 0xe0, 0x01, 0x0c, 0x03, 0x30, 0xe0, 0x01, 0x0c, 0x03, 0x30, 0xe0, 0x01,
     0x00, 0x00, 0x00, 0xe0, 0x01, 0x00, 0x00, 0x00, 0xe0, 0x01, 0x00, 0x00, 0x00, 0xe0, 0xfe, 0xff, 0xff, 0xff, 0xdf};
 
-#define chirpy_width_hirez 76
-#define chirpy_height_hirez 100
-const uint8_t chirpy_hirez[] = {
-    0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x03,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0xc0, 0x0f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x0f, 0xfc, 0x03, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0xf0, 0x3f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x3f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0xf0, 0x3f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x3f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0xf0, 0x3f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x3f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0xc0, 0x0f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x0f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0xc0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00,
-    0xfc, 0x03, 0xc0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0xfc, 0x03, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xfc,
-    0x03, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xfc, 0x03,
-    0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0xff, 0xf0, 0xff, 0x3f, 0xfc, 0xff, 0x00, 0xfc, 0x03, 0xf0,
-    0xff, 0xf0, 0xff, 0x3f, 0xfc, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f,
-    0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0,
-    0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff,
-    0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f,
-    0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0,
-    0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff,
-    0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00,
-    0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc,
-    0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03,
-    0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0,
-    0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f,
-    0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0,
-    0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0xff, 0xf0, 0xff,
-    0x3f, 0xfc, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0xff, 0xf0, 0xff, 0x3f, 0xfc, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0x00, 0xfc, 0x03, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xfc, 0x03, 0xc0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f,
-    0x00, 0xfc, 0x03, 0xc0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc,
-    0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x0f, 0xf0, 0x00, 0x00, 0x00, 0xfc, 0x03,
-    0x00, 0x00, 0x00, 0x0f, 0xf0, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x0f, 0xf0, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00,
-    0x00, 0x00, 0x0f, 0xf0, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0xc0, 0x03, 0xfc, 0x03, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00,
-    0xc0, 0x03, 0xfc, 0x03, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0xc0, 0x03, 0xfc, 0x03, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0xc0,
-    0x03, 0xfc, 0x03, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0xf0, 0x00, 0x0f, 0x0f, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0xf0, 0x00,
-    0x0f, 0x0f, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0xf0, 0x00, 0x0f, 0x0f, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0xf0, 0x00, 0x0f,
-    0x0f, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x3c, 0xc0, 0x03, 0x3c, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x3c, 0xc0, 0x03, 0x3c,
-    0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x3c, 0xc0, 0x03, 0x3c, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x3c, 0xc0, 0x03, 0x3c, 0x00,
-    0x00, 0xfc, 0x03, 0x00, 0x00, 0x0f, 0xf0, 0x00, 0xf0, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x0f, 0xf0, 0x00, 0xf0, 0x00, 0x00,
-    0xfc, 0x03, 0x00, 0x00, 0x0f, 0xf0, 0x00, 0xf0, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x0f, 0xf0, 0x00, 0xf0, 0x00, 0x00, 0xfc,
-    0x03, 0x00, 0xc0, 0x03, 0x3c, 0x00, 0xc0, 0x03, 0x00, 0xfc, 0x03, 0x00, 0xc0, 0x03, 0x3c, 0x00, 0xc0, 0x03, 0x00, 0xfc, 0x03,
-    0x00, 0xc0, 0x03, 0x3c, 0x00, 0xc0, 0x03, 0x00, 0xfc, 0x03, 0x00, 0xc0, 0x03, 0x3c, 0x00, 0xc0, 0x03, 0x00, 0xfc, 0x03, 0x00,
-    0xf0, 0x00, 0x0f, 0x00, 0x00, 0x0f, 0x00, 0xfc, 0x03, 0x00, 0xf0, 0x00, 0x0f, 0x00, 0x00, 0x0f, 0x00, 0xfc, 0x03, 0x00, 0xf0,
-    0x00, 0x0f, 0x00, 0x00, 0x0f, 0x00, 0xfc, 0x03, 0x00, 0xf0, 0x00, 0x0f, 0x00, 0x00, 0x0f, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xf3, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3};
-
 #define chirpy_small_image_width 8
 #define chirpy_small_image_height 8
 const uint8_t chirpy_small[] = {0x7f, 0x41, 0x55, 0x55, 0x55, 0x55, 0x41, 0x7f};

src/graphics/niche/InkHUD/docs/README.md

@@ -273,7 +273,7 @@ _(Example shows only config required by InkHUD. This is not a complete `env` def
 extends = esp32s3_base, inkhud ; or nrf52840_base, etc
 
 build_src_filter =
-${esp32_base.build_src_filter}
+${esp32s3_base.build_src_filter}
 ${inkhud.build_src_filter}
 
 build_flags =
@@ -756,12 +756,12 @@ This mapping of emoji to control characters is fairly arbitrary. Selection was i
 | `0x03`     | 🙂                                             |
 | `0x04`     | 😆                                             |
 | `0x05`     | 👋                                             |
-| `0x06`     | ☀                                             |
+| `0x06`     | ☀                                              |
 | ~~`0x07`~~ | (bell char, unused)                            |
 | `0x08`     | 🌧                                             |
-| `0x09`     | ☁                                             |
+| `0x09`     | ☁                                              |
 | ~~`0x0A`~~ | (line feed, unused)                            |
-| `0x0B`     | ♥                                             |
+| `0x0B`     | ♥                                              |
 | `0x0C`     | 💩                                             |
 | ~~`0x0D`~~ | (carriage return, unused)                      |
 | `0x0E`     | 🔔                                             |

src/input/RotaryEncoderInterruptImpl1.cpp

@@ -27,7 +27,9 @@ bool RotaryEncoderInterruptImpl1::init()
                                      RotaryEncoderInterruptImpl1::handleIntA, RotaryEncoderInterruptImpl1::handleIntB,
                                      RotaryEncoderInterruptImpl1::handleIntPressed);
     inputBroker->registerSource(this);
+#ifndef HAS_PHYSICAL_KEYBOARD
     osk_found = true;
+#endif
     return true;
 }
 

src/input/TrackballInterruptBase.cpp

@@ -45,7 +45,9 @@ void TrackballInterruptBase::init(uint8_t pinDown, uint8_t pinUp, uint8_t pinLef
 
     LOG_DEBUG("Trackball GPIO initialized - UP:%d DOWN:%d LEFT:%d RIGHT:%d PRESS:%d", this->_pinUp, this->_pinDown,
               this->_pinLeft, this->_pinRight, pinPress);
+#ifndef HAS_PHYSICAL_KEYBOARD
     osk_found = true;
+#endif
     this->setInterval(100);
 }
 

src/input/UpDownInterruptImpl1.cpp

@@ -29,7 +29,9 @@ bool UpDownInterruptImpl1::init()
                               eventDownLong, UpDownInterruptImpl1::handleIntDown, UpDownInterruptImpl1::handleIntUp,
                               UpDownInterruptImpl1::handleIntPressed);
     inputBroker->registerSource(this);
+#ifndef HAS_PHYSICAL_KEYBOARD
     osk_found = true;
+#endif
     return true;
 }
 

src/input/kbI2cBase.cpp

@@ -489,8 +489,6 @@ int32_t KbI2cBase::runOnce()
             case 0x90: // fn+r      INPUT_BROKER_MSG_REBOOT
             case 0x91: // fn+t
             case 0xac: // fn+m      INPUT_BROKER_MSG_MUTE_TOGGLE
-
-            case 0x8b: // fn+del    INPUT_BROKEN_MSG_DISMISS_FRAME
             case 0xAA: // fn+b      INPUT_BROKER_MSG_BLUETOOTH_TOGGLE
             case 0x8F: // fn+e      INPUT_BROKER_MSG_EMOTE_LIST
                 // just pass those unmodified

src/main.cpp

@@ -1186,11 +1186,6 @@ void setup()
 #endif
 #endif
 
-#ifdef PIN_PWR_DELAY_MS
-    // This may be required to give the peripherals time to power up.
-    delay(PIN_PWR_DELAY_MS);
-#endif
-
 #ifdef ARCH_PORTDUINO
     // as one can't use a function pointer to the class constructor:
     auto loraModuleInterface = [](LockingArduinoHal *hal, RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst,
@@ -1465,8 +1460,10 @@ void setup()
 #endif
 
 #if defined(HAS_TRACKBALL) || (defined(INPUTDRIVER_ENCODER_TYPE) && INPUTDRIVER_ENCODER_TYPE == 2)
+#ifndef HAS_PHYSICAL_KEYBOARD
     osk_found = true;
 #endif
+#endif
 
 #if defined(ARCH_ESP32) && !MESHTASTIC_EXCLUDE_WEBSERVER
     // Start web server thread.

src/mesh/MeshModule.h

@@ -44,6 +44,7 @@ struct UIFrameEvent {
         REDRAW_ONLY,                    // Don't change which frames are show, just redraw, asap
         REGENERATE_FRAMESET,            // Regenerate (change? add? remove?) screen frames, honoring requestFocus()
         REGENERATE_FRAMESET_BACKGROUND, // Regenerate screen frames, Attempt to remain on the same frame throughout
+        SWITCH_TO_TEXTMESSAGE           // Jump directly to the Text Message screen
     } action = REDRAW_ONLY;
 
     // We might want to pass additional data inside this struct at some point

src/mesh/MeshService.cpp

@@ -7,10 +7,12 @@
 #include "../concurrency/Periodic.h"
 #include "BluetoothCommon.h" // needed for updateBatteryLevel, FIXME, eventually when we pull mesh out into a lib we shouldn't be whacking bluetooth from here
 #include "MeshService.h"
+#include "MessageStore.h"
 #include "NodeDB.h"
 #include "PowerFSM.h"
 #include "RTC.h"
 #include "TypeConversions.h"
+#include "graphics/draw/MessageRenderer.h"
 #include "main.h"
 #include "mesh-pb-constants.h"
 #include "meshUtils.h"
@@ -192,8 +194,16 @@ void MeshService::handleToRadio(meshtastic_MeshPacket &p)
         p.id = generatePacketId(); // If the phone didn't supply one, then pick one
 
     p.rx_time = getValidTime(RTCQualityFromNet); // Record the time the packet arrived from the phone
-                                                 // (so we update our nodedb for the local node)
 
+#if HAS_SCREEN
+    if (p.decoded.portnum == meshtastic_PortNum_TEXT_MESSAGE_APP && p.decoded.payload.size > 0 && p.to != NODENUM_BROADCAST &&
+        p.to != 0) // DM only
+    {
+        perhapsDecode(&p);
+        const StoredMessage &sm = messageStore.addFromPacket(p);
+        graphics::MessageRenderer::handleNewMessage(nullptr, sm, p); // notify UI
+    }
+#endif
     // Send the packet into the mesh
     DEBUG_HEAP_BEFORE;
     auto a = packetPool.allocCopy(p);

src/mesh/NodeDB.cpp

@@ -805,7 +805,8 @@ void NodeDB::installDefaultModuleConfig()
     moduleConfig.external_notification.output_ms = 500;
     moduleConfig.external_notification.nag_timeout = 2;
 #endif
-#if defined(RAK4630) || defined(RAK11310) || defined(RAK3312) || defined(MUZI_BASE) || defined(ELECROW_ThinkNode_M3)
+#if defined(RAK4630) || defined(RAK11310) || defined(RAK3312) || defined(MUZI_BASE) || defined(ELECROW_ThinkNode_M3) ||          \
+    defined(ELECROW_ThinkNode_M6)
     // Default to PIN_LED2 for external notification output (LED color depends on device variant)
     moduleConfig.external_notification.enabled = true;
     moduleConfig.external_notification.output = PIN_LED2;

src/modules/CannedMessageModule.h

@@ -75,7 +75,6 @@ class CannedMessageModule : public SinglePortModule, public Observable<const UIF
     // === State/UI ===
     bool shouldDraw();
     bool hasMessages();
-    void showTemporaryMessage(const String &message);
     void resetSearch();
     void updateDestinationSelectionList();
     void drawDestinationSelectionScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);
@@ -153,10 +152,9 @@ class CannedMessageModule : public SinglePortModule, public Observable<const UIF
     unsigned long lastUpdateMillis = 0;
     String searchQuery;
     String freetext;
-    String temporaryMessage;
 
     // === Message Storage ===
-    char messageStore[CANNED_MESSAGE_MODULE_MESSAGES_SIZE + 1];
+    char messageBuffer[CANNED_MESSAGE_MODULE_MESSAGES_SIZE + 1];
     char *messages[CANNED_MESSAGE_MODULE_MESSAGE_MAX_COUNT];
     int messagesCount = 0;
     int currentMessageIndex = -1;
@@ -167,14 +165,11 @@ class CannedMessageModule : public SinglePortModule, public Observable<const UIF
     NodeNum lastSentNode = 0;             // Tracks the most recent node we sent a message to (for UI display)
     ChannelIndex channel = 0;             // Channel index used when sending a message
 
-    bool ack = false;               // True = ACK received, False = NACK or failed
-    bool waitingForAck = false;     // True if we're expecting an ACK and should monitor routing packets
-    bool lastAckWasRelayed = false; // True if the ACK was relayed through intermediate nodes
-    uint8_t lastAckHopStart = 0;    // Hop start value from the received ACK packet
-    uint8_t lastAckHopLimit = 0;    // Hop limit value from the received ACK packet
-
-    float lastRxSnr = 0;    // SNR from last received ACK (used for diagnostics/UI)
-    int32_t lastRxRssi = 0; // RSSI from last received ACK (used for diagnostics/UI)
+    bool ack = false;           // True = ACK received, False = NACK or failed
+    bool waitingForAck = false; // True if we're expecting an ACK and should monitor routing packets
+    float lastRxSnr = 0;        // SNR from last received ACK (used for diagnostics/UI)
+    int32_t lastRxRssi = 0;     // RSSI from last received ACK (used for diagnostics/UI)
+    uint32_t lastRequestId = 0; // tracks the request_id of our last sent packet
 
     // === State Tracking ===
     cannedMessageModuleRunState runState = CANNED_MESSAGE_RUN_STATE_INACTIVE;

src/modules/DropzoneModule.cpp

@@ -60,9 +60,7 @@ meshtastic_MeshPacket *DropzoneModule::sendConditions()
         long hms = rtc_sec % SEC_PER_DAY;
         hms = (hms + SEC_PER_DAY) % SEC_PER_DAY;
 
-        hour = hms / SEC_PER_HOUR;
-        min = (hms % SEC_PER_HOUR) / SEC_PER_MIN;
-        sec = (hms % SEC_PER_HOUR) % SEC_PER_MIN;
+        graphics::decomposeTime(rtc_sec, hour, min, sec);
     }
 
     // Check if the dropzone is open or closed by reading the analog pin

src/modules/PositionModule.cpp

@@ -428,9 +428,10 @@ int32_t PositionModule::runOnce()
     bool waitingForFreshPosition = (lastGpsSend == 0) && !config.position.fixed_position && !nodeDB->hasLocalPositionSinceBoot();
 
     if (lastGpsSend == 0 || msSinceLastSend >= intervalMs) {
-        if (waitingForFreshPosition && !Throttle::isWithinTimespanMs(lastWarn, ONE_MINUTE_MS)) {
+        if (waitingForFreshPosition) {
+#ifdef GPS_DEBUG
             LOG_DEBUG("Skip initial position send; no fresh position since boot");
-            lastWarn = now;
+#endif
         } else if (nodeDB->hasValidPosition(node)) {
             lastGpsSend = now;
 

src/modules/PositionModule.h

@@ -64,13 +64,12 @@ class PositionModule : public ProtobufModule<meshtastic_Position>, private concu
     bool hasQualityTimesource();
     bool hasGPS();
     uint32_t lastSentReply = 0; // Last time we sent a position reply (used for reply throttling only)
-    uint32_t lastWarn = 0;      // for throttling initial position warning
 
 #if USERPREFS_EVENT_MODE
     // In event mode we want to prevent excessive position broadcasts
     // we set the minimum interval to 5m
     const uint32_t minimumTimeThreshold =
-        max(300000, Default::getConfiguredOrDefaultMs(config.position.broadcast_smart_minimum_interval_secs, 30));
+        max(uint32_t(300000), Default::getConfiguredOrDefaultMs(config.position.broadcast_smart_minimum_interval_secs, 30));
 #else
     const uint32_t minimumTimeThreshold =
         Default::getConfiguredOrDefaultMs(config.position.broadcast_smart_minimum_interval_secs, 30);

src/modules/StatusLEDModule.cpp

@@ -20,7 +20,7 @@ int StatusLEDModule::handleStatusUpdate(const meshtastic::Status *arg)
     switch (arg->getStatusType()) {
     case STATUS_TYPE_POWER: {
         meshtastic::PowerStatus *powerStatus = (meshtastic::PowerStatus *)arg;
-        if (powerStatus->getHasUSB()) {
+        if (powerStatus->getHasUSB() || powerStatus->getIsCharging()) {
             power_state = charging;
             if (powerStatus->getBatteryChargePercent() >= 100) {
                 power_state = charged;

src/modules/SystemCommandsModule.cpp

@@ -1,10 +1,13 @@
 #include "SystemCommandsModule.h"
 #include "input/InputBroker.h"
 #include "meshUtils.h"
+
 #if HAS_SCREEN
+#include "MessageStore.h"
 #include "graphics/Screen.h"
 #include "graphics/SharedUIDisplay.h"
 #endif
+
 #include "GPS.h"
 #include "MeshService.h"
 #include "Module.h"
@@ -28,10 +31,7 @@ int SystemCommandsModule::handleInputEvent(const InputEvent *event)
     switch (event->kbchar) {
     // Fn key symbols
     case INPUT_BROKER_MSG_FN_SYMBOL_ON:
-        IF_SCREEN(screen->setFunctionSymbol("Fn"));
-        return 0;
     case INPUT_BROKER_MSG_FN_SYMBOL_OFF:
-        IF_SCREEN(screen->removeFunctionSymbol("Fn"));
         return 0;
     // Brightness
     case INPUT_BROKER_MSG_BRIGHTNESS_UP:
@@ -78,6 +78,9 @@ int SystemCommandsModule::handleInputEvent(const InputEvent *event)
     case INPUT_BROKER_MSG_REBOOT:
         IF_SCREEN(screen->showSimpleBanner("Rebooting...", 0));
         nodeDB->saveToDisk();
+#if HAS_SCREEN
+        messageStore.saveToFlash();
+#endif
         rebootAtMsec = millis() + DEFAULT_REBOOT_SECONDS * 1000;
         // runState = CANNED_MESSAGE_RUN_STATE_INACTIVE;
         return true;

src/modules/Telemetry/EnvironmentTelemetry.cpp

@@ -378,7 +378,7 @@ void EnvironmentTelemetryModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiSt
     int line = 1;
 
     // === Set Title
-    const char *titleStr = (graphics::isHighResolution) ? "Environment" : "Env.";
+    const char *titleStr = (graphics::currentResolution == graphics::ScreenResolution::High) ? "Environment" : "Env.";
 
     // === Header ===
     graphics::drawCommonHeader(display, x, y, titleStr);

src/modules/Telemetry/PowerTelemetry.cpp

@@ -117,7 +117,7 @@ void PowerTelemetryModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *s
     int line = 1;
 
     // === Set Title
-    const char *titleStr = (graphics::isHighResolution) ? "Power Telem." : "Power";
+    const char *titleStr = (graphics::currentResolution == graphics::ScreenResolution::High) ? "Power Telem." : "Power";
 
     // === Header ===
     graphics::drawCommonHeader(display, x, y, titleStr);

src/modules/TextMessageModule.cpp

@@ -1,10 +1,14 @@
 #include "TextMessageModule.h"
 #include "MeshService.h"
+#include "MessageStore.h"
 #include "NodeDB.h"
 #include "PowerFSM.h"
 #include "buzz.h"
 #include "configuration.h"
 #include "graphics/Screen.h"
+#include "graphics/SharedUIDisplay.h"
+#include "graphics/draw/MessageRenderer.h"
+#include "main.h"
 TextMessageModule *textMessageModule;
 
 ProcessMessage TextMessageModule::handleReceived(const meshtastic_MeshPacket &mp)
@@ -15,14 +19,26 @@ ProcessMessage TextMessageModule::handleReceived(const meshtastic_MeshPacket &mp
 #endif
 
     // We only store/display messages destined for us.
-    // Keep a copy of the most recent text message.
     devicestate.rx_text_message = mp;
     devicestate.has_rx_text_message = true;
+#if HAS_SCREEN
+    // Guard against running in MeshtasticUI
+    if (config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_COLOR) {
+        // Store in the central message history
+        const StoredMessage &sm = messageStore.addFromPacket(mp);
 
+        // Pass message to renderer (banner + thread switching + scroll reset)
+        // Use the global Screen singleton to retrieve the current OLED display
+        auto *display = screen ? screen->getDisplayDevice() : nullptr;
+        graphics::MessageRenderer::handleNewMessage(display, sm, mp);
+    }
+#endif
     // Only trigger screen wake if configuration allows it
     if (shouldWakeOnReceivedMessage()) {
         powerFSM.trigger(EVENT_RECEIVED_MSG);
     }
+
+    // Notify any observers (e.g. external modules that care about packets)
     notifyObservers(&mp);
 
     return ProcessMessage::CONTINUE; // Let others look at this message also if they want

src/modules/TextMessageModule.h

@@ -3,7 +3,13 @@
 #include "SinglePortModule.h"
 
 /**
- * Text message handling for meshtastic - draws on the OLED display the most recent received message
+ * Text message handling for Meshtastic.
+ *
+ * This module is responsible for receiving and storing incoming text messages
+ * from the mesh. It updates device state and notifies observers so that other
+ * components (such as the MessageRenderer) can later display or process them.
+ *
+ * Rendering of messages on screen is no longer done here.
  */
 class TextMessageModule : public SinglePortModule, public Observable<const meshtastic_MeshPacket *>
 {
@@ -15,10 +21,10 @@ class TextMessageModule : public SinglePortModule, public Observable<const mesht
 
   protected:
     /** Called to handle a particular incoming message
-
-    @return ProcessMessage::STOP if you've guaranteed you've handled this message and no other handlers should be considered for
-    it
-    */
+     *
+     * @return ProcessMessage::STOP if you've guaranteed you've handled this
+     *         message and no other handlers should be considered for it.
+     */
     virtual ProcessMessage handleReceived(const meshtastic_MeshPacket &mp) override;
     virtual bool wantPacket(const meshtastic_MeshPacket *p) override;
 };

src/modules/WaypointModule.cpp

@@ -2,6 +2,7 @@
 #include "NodeDB.h"
 #include "PowerFSM.h"
 #include "configuration.h"
+#include "graphics/SharedUIDisplay.h"
 #include "graphics/draw/CompassRenderer.h"
 
 #if HAS_SCREEN
@@ -14,6 +15,15 @@
 
 WaypointModule *waypointModule;
 
+static inline float degToRad(float deg)
+{
+    return deg * PI / 180.0f;
+}
+static inline float radToDeg(float rad)
+{
+    return rad * 180.0f / PI;
+}
+
 ProcessMessage WaypointModule::handleReceived(const meshtastic_MeshPacket &mp)
 {
 #if defined(DEBUG_PORT) && !defined(DEBUG_MUTE)
@@ -52,31 +62,15 @@ ProcessMessage WaypointModule::handleReceived(const meshtastic_MeshPacket &mp)
 bool WaypointModule::shouldDraw()
 {
 #if !MESHTASTIC_EXCLUDE_WAYPOINT
-    if (screen == nullptr)
-        return false;
-    // If no waypoint to show
-    if (!devicestate.has_rx_waypoint)
+    if (!screen || !devicestate.has_rx_waypoint)
         return false;
 
-    // Decode the message, to find the expiration time (is waypoint still valid)
-    // This handles "deletion" as well as expiration
-    meshtastic_Waypoint wp;
-    memset(&wp, 0, sizeof(wp));
+    meshtastic_Waypoint wp{}; // <- replaces memset
     if (pb_decode_from_bytes(devicestate.rx_waypoint.decoded.payload.bytes, devicestate.rx_waypoint.decoded.payload.size,
                              &meshtastic_Waypoint_msg, &wp)) {
-        // Valid waypoint
-        if (wp.expire > getTime())
-            return devicestate.has_rx_waypoint = true;
-
-        // Expired, or deleted
-        else
-            return devicestate.has_rx_waypoint = false;
+        return wp.expire > getTime();
     }
-
-    // If decoding failed
-    LOG_ERROR("Failed to decode waypoint");
-    devicestate.has_rx_waypoint = false;
-    return false;
+    return false; // no LOG_ERROR, no flag writes
 #else
     return false;
 #endif
@@ -85,53 +79,46 @@ bool WaypointModule::shouldDraw()
 /// Draw the last waypoint we received
 void WaypointModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
 {
-    if (screen == nullptr)
+    if (!screen)
         return;
-    // Prepare to draw
-    display->setFont(FONT_SMALL);
+    display->clear();
     display->setTextAlignment(TEXT_ALIGN_LEFT);
+    display->setFont(FONT_SMALL);
+    int line = 1;
 
-    // Handle inverted display
-    // Unsure of expected behavior: for now, copy drawNodeInfo
-    if (config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_INVERTED)
-        display->fillRect(0 + x, 0 + y, x + display->getWidth(), y + FONT_HEIGHT_SMALL);
+    // === Set Title
+    const char *titleStr = "Waypoint";
+
+    // === Header ===
+    graphics::drawCommonHeader(display, x, y, titleStr);
+
+    const int w = display->getWidth();
+    const int h = display->getHeight();
 
     // Decode the waypoint
     const meshtastic_MeshPacket &mp = devicestate.rx_waypoint;
-    meshtastic_Waypoint wp;
-    memset(&wp, 0, sizeof(wp));
+    meshtastic_Waypoint wp{};
     if (!pb_decode_from_bytes(mp.decoded.payload.bytes, mp.decoded.payload.size, &meshtastic_Waypoint_msg, &wp)) {
-        // This *should* be caught by shouldDrawWaypoint, but we'll short-circuit here just in case
-        display->drawStringMaxWidth(0 + x, 0 + y, x + display->getWidth(), "Couldn't decode waypoint");
         devicestate.has_rx_waypoint = false;
         return;
     }
 
     // Get timestamp info. Will pass as a field to drawColumns
-    static char lastStr[20];
+    char lastStr[20];
     getTimeAgoStr(sinceReceived(&mp), lastStr, sizeof(lastStr));
 
     // Will contain distance information, passed as a field to drawColumns
-    static char distStr[20];
+    char distStr[20];
 
     // Get our node, to use our own position
     meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
 
-    // Text fields to draw (left of compass)
-    // Last element must be NULL. This signals the end of the char*[] to drawColumns
-    const char *fields[] = {"Waypoint", lastStr, wp.name, distStr, NULL};
-
     // Dimensions / co-ordinates for the compass/circle
-    int16_t compassX = 0, compassY = 0;
-    uint16_t compassDiam = graphics::CompassRenderer::getCompassDiam(display->getWidth(), display->getHeight());
-
-    if (config.display.displaymode == meshtastic_Config_DisplayConfig_DisplayMode_DEFAULT) {
-        compassX = x + display->getWidth() - compassDiam / 2 - 5;
-        compassY = y + display->getHeight() / 2;
-    } else {
-        compassX = x + display->getWidth() - compassDiam / 2 - 5;
-        compassY = y + FONT_HEIGHT_SMALL + (display->getHeight() - FONT_HEIGHT_SMALL) / 2;
-    }
+    const uint16_t compassDiam = graphics::CompassRenderer::getCompassDiam(w, h);
+    const int16_t compassX = x + w - (compassDiam / 2) - 5;
+    const int16_t compassY = (config.display.displaymode == meshtastic_Config_DisplayConfig_DisplayMode_DEFAULT)
+                                 ? y + h / 2
+                                 : y + FONT_HEIGHT_SMALL + (h - FONT_HEIGHT_SMALL) / 2;
 
     // If our node has a position:
     if (ourNode && (nodeDB->hasValidPosition(ourNode) || screen->hasHeading())) {
@@ -141,7 +128,7 @@ void WaypointModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state,
             myHeading = 0;
         } else {
             if (screen->hasHeading())
-                myHeading = (screen->getHeading()) * PI / 180; // gotta convert compass degrees to Radians
+                myHeading = degToRad(screen->getHeading());
             else
                 myHeading = screen->estimatedHeading(DegD(op.latitude_i), DegD(op.longitude_i));
         }
@@ -157,46 +144,35 @@ void WaypointModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state,
         graphics::CompassRenderer::drawNodeHeading(display, compassX, compassY, compassDiam, bearingToOther);
 
         float bearingToOtherDegrees = (bearingToOther < 0) ? bearingToOther + 2 * PI : bearingToOther;
-        bearingToOtherDegrees = bearingToOtherDegrees * 180 / PI;
+        bearingToOtherDegrees = radToDeg(bearingToOtherDegrees);
 
         // Distance to Waypoint
         float d = GeoCoord::latLongToMeter(DegD(wp.latitude_i), DegD(wp.longitude_i), DegD(op.latitude_i), DegD(op.longitude_i));
         if (config.display.units == meshtastic_Config_DisplayConfig_DisplayUnits_IMPERIAL) {
-            if (d < (2 * MILES_TO_FEET))
-                snprintf(distStr, sizeof(distStr), "%.0fft   %.0f°", d * METERS_TO_FEET, bearingToOtherDegrees);
-            else
-                snprintf(distStr, sizeof(distStr), "%.1fmi   %.0f°", d * METERS_TO_FEET / MILES_TO_FEET, bearingToOtherDegrees);
+            float feet = d * METERS_TO_FEET;
+            snprintf(distStr, sizeof(distStr), feet < (2 * MILES_TO_FEET) ? "%.0fft   %.0f°" : "%.1fmi   %.0f°",
+                     feet < (2 * MILES_TO_FEET) ? feet : feet / MILES_TO_FEET, bearingToOtherDegrees);
         } else {
-            if (d < 2000)
-                snprintf(distStr, sizeof(distStr), "%.0fm   %.0f°", d, bearingToOtherDegrees);
-            else
-                snprintf(distStr, sizeof(distStr), "%.1fkm   %.0f°", d / 1000, bearingToOtherDegrees);
+            snprintf(distStr, sizeof(distStr), d < 2000 ? "%.0fm   %.0f°" : "%.1fkm   %.0f°", d < 2000 ? d : d / 1000,
+                     bearingToOtherDegrees);
         }
-
     }
 
-    // If our node doesn't have position
     else {
-        // ? in the compass
         display->drawString(compassX - FONT_HEIGHT_SMALL / 4, compassY - FONT_HEIGHT_SMALL / 2, "?");
 
         // ? in the distance field
-        if (config.display.units == meshtastic_Config_DisplayConfig_DisplayUnits_IMPERIAL)
-            strncpy(distStr, "? mi ?°", sizeof(distStr));
-        else
-            strncpy(distStr, "? km ?°", sizeof(distStr));
+        snprintf(distStr, sizeof(distStr), "? %s ?°",
+                 (config.display.units == meshtastic_Config_DisplayConfig_DisplayUnits_IMPERIAL) ? "mi" : "km");
     }
 
     // Draw compass circle
     display->drawCircle(compassX, compassY, compassDiam / 2);
 
-    // Undo color-inversion, if set prior to drawing header
-    // Unsure of expected behavior? For now: copy drawNodeInfo
-    if (config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_INVERTED) {
-        display->setColor(BLACK);
-    }
-
-    // Must be after distStr is populated
-    graphics::NodeListRenderer::drawColumns(display, x, y, fields);
+    display->setTextAlignment(TEXT_ALIGN_LEFT); // Something above me changes to a different alignment, forcing a fix here!
+    display->drawString(0, graphics::getTextPositions(display)[line++], lastStr);
+    display->drawString(0, graphics::getTextPositions(display)[line++], wp.name);
+    display->drawString(0, graphics::getTextPositions(display)[line++], wp.description);
+    display->drawString(0, graphics::getTextPositions(display)[line++], distStr);
 }
 #endif

src/platform/portduino/PortduinoGlue.cpp

@@ -279,7 +279,7 @@ void portduinoSetup()
         //      RAK6421-13300-S1:aabbcc123456:5ba85807d92138b7519cfb60460573af:3061e8d8
         // <model string>:mac address :<16 random unique bytes in hexidecimal> : crc32
         // crc32 is calculated on the eeprom string up to but not including the final colon
-        if (strlen(autoconf_product) < 6) {
+        if (strlen(autoconf_product) < 6 && portduino_config.i2cdev != "") {
             try {
                 char *mac_start = nullptr;
                 char *devID_start = nullptr;
@@ -427,11 +427,13 @@ void portduinoSetup()
     }
 
     getMacAddr(dmac);
+#ifndef UNIT_TEST
     if (dmac[0] == 0 && dmac[1] == 0 && dmac[2] == 0 && dmac[3] == 0 && dmac[4] == 0 && dmac[5] == 0) {
         std::cout << "*** Blank MAC Address not allowed!" << std::endl;
         std::cout << "Please set a MAC Address in config.yaml using either MACAddress or MACAddressSource." << std::endl;
         exit(EXIT_FAILURE);
     }
+#endif
     printf("MAC ADDRESS: %02X:%02X:%02X:%02X:%02X:%02X\n", dmac[0], dmac[1], dmac[2], dmac[3], dmac[4], dmac[5]);
     // Rather important to set this, if not running simulated.
     randomSeed(time(NULL));
@@ -867,4 +869,4 @@ void readGPIOFromYaml(YAML::Node sourceNode, pinMapping &destPin, int pinDefault
         destPin.line = destPin.pin;
         destPin.gpiochip = portduino_config.lora_default_gpiochip;
     }
-}
+}

variants/esp32/esp32-common.ini

@@ -0,0 +1,88 @@
+; Common settings for ESP targets, mixin with extends = esp32_common
+[esp32_common]
+extends = arduino_base
+custom_esp32_kind =
+custom_mtjson_part =
+platform =
+  # renovate: datasource=custom.pio depName=platformio/espressif32 packageName=platformio/platform/espressif32
+  platformio/espressif32@6.12.0
+
+extra_scripts =
+  ${env.extra_scripts}
+  pre:extra_scripts/esp32_pre.py
+  extra_scripts/esp32_extra.py
+
+build_src_filter = 
+  ${arduino_base.build_src_filter} -<platform/nrf52/> -<platform/stm32wl> -<platform/rp2xx0> -<mesh/eth/> -<mesh/raspihttp>
+
+upload_speed = 921600
+debug_init_break = tbreak setup
+monitor_filters = esp32_exception_decoder
+
+board_build.filesystem = littlefs
+
+# Remove -DMYNEWT_VAL_BLE_HS_LOG_LVL=LOG_LEVEL_CRITICAL for low level BLE logging.
+# See library directory for BLE logging possible values: .pio/libdeps/tbeam/NimBLE-Arduino/src/log_common/log_common.h
+# This overrides the BLE logging default of LOG_LEVEL_INFO (1) from: .pio/libdeps/tbeam/NimBLE-Arduino/src/esp_nimble_cfg.h
+build_unflags = -fno-lto
+build_flags =
+  ${arduino_base.build_flags}
+  -flto
+  -Wall
+  -Wextra
+  -Isrc/platform/esp32
+  -std=c++11
+  -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG
+  -DCORE_DEBUG_LEVEL=ARDUHAL_LOG_LEVEL_DEBUG
+  -DMYNEWT_VAL_BLE_HS_LOG_LVL=LOG_LEVEL_CRITICAL
+  -DAXP_DEBUG_PORT=Serial
+  -DCONFIG_BT_NIMBLE_ENABLED
+  -DCONFIG_BT_NIMBLE_MAX_BONDS=6 # default is 3
+  -DCONFIG_BT_NIMBLE_ROLE_CENTRAL_DISABLED
+  -DCONFIG_NIMBLE_CPP_LOG_LEVEL=2
+  -DCONFIG_BT_NIMBLE_MAX_CCCDS=20
+  -DCONFIG_BT_NIMBLE_HOST_TASK_STACK_SIZE=8192
+  -DESP_OPENSSL_SUPPRESS_LEGACY_WARNING
+  -DSERIAL_BUFFER_SIZE=4096
+  -DSERIAL_HAS_ON_RECEIVE
+  -DLIBPAX_ARDUINO
+  -DLIBPAX_WIFI
+  -DLIBPAX_BLE
+  -DHAS_UDP_MULTICAST=1
+  ;-DDEBUG_HEAP
+
+lib_deps =
+  ${arduino_base.lib_deps}
+  ${networking_base.lib_deps}
+  ${networking_extra.lib_deps}
+  ${environmental_base.lib_deps}
+  ${environmental_extra.lib_deps}
+  ${radiolib_base.lib_deps}
+  # renovate: datasource=git-refs depName=meshtastic-esp32_https_server packageName=https://github.com/meshtastic/esp32_https_server gitBranch=master
+  https://github.com/meshtastic/esp32_https_server/archive/3223704846752e6d545139204837bdb2a55459ca.zip
+  # renovate: datasource=custom.pio depName=NimBLE-Arduino packageName=h2zero/library/NimBLE-Arduino
+  h2zero/NimBLE-Arduino@2.3.7
+  # renovate: datasource=git-refs depName=libpax packageName=https://github.com/dbinfrago/libpax gitBranch=master
+  https://github.com/dbinfrago/libpax/archive/3cdc0371c375676a97967547f4065607d4c53fd1.zip
+  # renovate: datasource=custom.pio depName=XPowersLib packageName=lewisxhe/library/XPowersLib
+  lewisxhe/XPowersLib@0.3.2
+  # renovate: datasource=git-refs depName=meshtastic-ESP32_Codec2 packageName=https://github.com/meshtastic/ESP32_Codec2 gitBranch=master
+  https://github.com/meshtastic/ESP32_Codec2/archive/633326c78ac251c059ab3a8c430fcdf25b41672f.zip
+  # renovate: datasource=custom.pio depName=rweather/Crypto packageName=rweather/library/Crypto
+  rweather/Crypto@0.4.0
+
+lib_ignore = 
+  segger_rtt
+  ESP32 BLE Arduino
+
+; leave this commented out to avoid breaking Windows
+;upload_port = /dev/ttyUSB0
+;monitor_port = /dev/ttyUSB0
+
+; Please don't delete these lines. JM uses them.
+;upload_port = /dev/cu.SLAB_USBtoUART
+;monitor_port = /dev/cu.SLAB_USBtoUART
+
+; customize the partition table
+; http://docs.platformio.org/en/latest/platforms/espressif32.html#partition-tables
+board_build.partitions = partition-table.csv

variants/esp32/esp32.ini

@@ -1,88 +1,8 @@
-; Common settings for ESP targes, mixin with extends = esp32_base
+; Common settings for ESP32 OG (without suffix)
+; See 'esp32_common' for common ESP32-family settings
 [esp32_base]
-extends = arduino_base
+extends = esp32_common
 custom_esp32_kind = esp32
-custom_mtjson_part =
-platform =
-  # renovate: datasource=custom.pio depName=platformio/espressif32 packageName=platformio/platform/espressif32
-  platformio/espressif32@6.12.0
 
-extra_scripts =
-  ${env.extra_scripts}
-  pre:extra_scripts/esp32_pre.py
-  extra_scripts/esp32_extra.py
-
-build_src_filter = 
-  ${arduino_base.build_src_filter} -<platform/nrf52/> -<platform/stm32wl> -<platform/rp2xx0> -<mesh/eth/> -<mesh/raspihttp>
-
-upload_speed = 921600
-debug_init_break = tbreak setup
-monitor_filters = esp32_exception_decoder
-
-board_build.filesystem = littlefs
-
-# Remove -DMYNEWT_VAL_BLE_HS_LOG_LVL=LOG_LEVEL_CRITICAL for low level BLE logging.
-# See library directory for BLE logging possible values: .pio/libdeps/tbeam/NimBLE-Arduino/src/log_common/log_common.h
-# This overrides the BLE logging default of LOG_LEVEL_INFO (1) from: .pio/libdeps/tbeam/NimBLE-Arduino/src/esp_nimble_cfg.h
-build_unflags = -fno-lto
 build_flags =
-  ${arduino_base.build_flags}
-  -flto
-  -Wall
-  -Wextra
-  -Isrc/platform/esp32
-  -std=c++11
-  -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG
-  -DCORE_DEBUG_LEVEL=ARDUHAL_LOG_LEVEL_DEBUG
-  -DMYNEWT_VAL_BLE_HS_LOG_LVL=LOG_LEVEL_CRITICAL
-  -DAXP_DEBUG_PORT=Serial
-  -DCONFIG_BT_NIMBLE_ENABLED
-  -DCONFIG_BT_NIMBLE_MAX_BONDS=6 # default is 3
-  -DCONFIG_BT_NIMBLE_ROLE_CENTRAL_DISABLED
-  -DCONFIG_NIMBLE_CPP_LOG_LEVEL=2
-  -DCONFIG_BT_NIMBLE_MAX_CCCDS=20
-  -DCONFIG_BT_NIMBLE_HOST_TASK_STACK_SIZE=8192
-  -DESP_OPENSSL_SUPPRESS_LEGACY_WARNING
-  -DSERIAL_BUFFER_SIZE=4096
-  -DSERIAL_HAS_ON_RECEIVE
-  -DLIBPAX_ARDUINO
-  -DLIBPAX_WIFI
-  -DLIBPAX_BLE
-  -DHAS_UDP_MULTICAST=1
-  ;-DDEBUG_HEAP
-
-lib_deps =
-  ${arduino_base.lib_deps}
-  ${networking_base.lib_deps}
-  ${networking_extra.lib_deps}
-  ${environmental_base.lib_deps}
-  ${environmental_extra.lib_deps}
-  ${radiolib_base.lib_deps}
-  # renovate: datasource=git-refs depName=meshtastic-esp32_https_server packageName=https://github.com/meshtastic/esp32_https_server gitBranch=master
-  https://github.com/meshtastic/esp32_https_server/archive/3223704846752e6d545139204837bdb2a55459ca.zip
-  # renovate: datasource=custom.pio depName=NimBLE-Arduino packageName=h2zero/library/NimBLE-Arduino
-  h2zero/NimBLE-Arduino@^2.3.7
-  # renovate: datasource=git-refs depName=libpax packageName=https://github.com/dbinfrago/libpax gitBranch=master
-  https://github.com/dbinfrago/libpax/archive/3cdc0371c375676a97967547f4065607d4c53fd1.zip
-  # renovate: datasource=custom.pio depName=XPowersLib packageName=lewisxhe/library/XPowersLib
-  lewisxhe/XPowersLib@0.3.2
-  # renovate: datasource=git-refs depName=meshtastic-ESP32_Codec2 packageName=https://github.com/meshtastic/ESP32_Codec2 gitBranch=master
-  https://github.com/meshtastic/ESP32_Codec2/archive/633326c78ac251c059ab3a8c430fcdf25b41672f.zip
-  # renovate: datasource=custom.pio depName=rweather/Crypto packageName=rweather/library/Crypto
-  rweather/Crypto@0.4.0
-
-lib_ignore = 
-  segger_rtt
-  ESP32 BLE Arduino
-
-; leave this commented out to avoid breaking Windows
-;upload_port = /dev/ttyUSB0
-;monitor_port = /dev/ttyUSB0
-
-; Please don't delete these lines. JM uses them.
-;upload_port = /dev/cu.SLAB_USBtoUART
-;monitor_port = /dev/cu.SLAB_USBtoUART
-
-; customize the partition table
-; http://docs.platformio.org/en/latest/platforms/espressif32.html#partition-tables
-board_build.partitions = partition-table.csv
+  ${esp32_common.build_flags}

variants/esp32/m5stack_coreink/platformio.ini

@@ -21,7 +21,7 @@ lib_deps =
   # renovate: datasource=custom.pio depName=GxEPD2 packageName=zinggjm/library/GxEPD2
   zinggjm/GxEPD2@1.6.5
   # renovate: datasource=custom.pio depName=SensorLib packageName=lewisxhe/library/SensorLib
-  lewisxhe/SensorLib@0.3.2
+  lewisxhe/SensorLib@0.3.3
 lib_ignore =
   m5stack-coreink
 monitor_filters = esp32_exception_decoder

variants/esp32/tbeam/platformio.ini

@@ -23,4 +23,4 @@ lib_deps =
   # renovate: datasource=github-tags depName=meshtastic-st7796 packageName=meshtastic/st7796
   https://github.com/meshtastic/st7796/archive/1.0.5.zip
   # renovate: datasource=custom.pio depName=lewisxhe-SensorLib packageName=lewisxhe/library/SensorLib
-  lewisxhe/SensorLib@0.3.1
+  lewisxhe/SensorLib@0.3.3

variants/esp32c3/esp32c3.ini

@@ -1,11 +1,11 @@
 [esp32c3_base]
-extends = esp32_base
+extends = esp32_common
 custom_esp32_kind = esp32c3
 
 monitor_speed = 115200
 monitor_filters = esp32_c3_exception_decoder
 
 build_flags =
-	${esp32_base.build_flags}
-	-DCONFIG_BT_NIMBLE_EXT_ADV=1
-	-DCONFIG_BT_NIMBLE_MAX_EXT_ADV_INSTANCES=2
+  ${esp32_common.build_flags}
+  -DCONFIG_BT_NIMBLE_EXT_ADV=1
+  -DCONFIG_BT_NIMBLE_MAX_EXT_ADV_INSTANCES=2

variants/esp32c6/esp32c6.ini

@@ -1,5 +1,5 @@
 [esp32c6_base]
-extends = esp32_base
+extends = esp32_common
 platform =
   # Do not renovate until we have switched to pioarduino tagged builds
   https://github.com/Jason2866/platform-espressif32/archive/22faa566df8c789000f8136cd8d0aca49617af55.zip
@@ -35,12 +35,13 @@ lib_deps =
   rweather/Crypto@0.4.0
 
 build_src_filter = 
- ${esp32_base.build_src_filter} -<mesh/http> 
+  ${esp32_common.build_src_filter} -<mesh/http>
 
 monitor_speed = 460800
 monitor_filters = esp32_c3_exception_decoder
 
 lib_ignore =
+  ${esp32_common.lib_ignore}
   NonBlockingRTTTL
   NimBLE-Arduino
   libpax

variants/esp32s2/esp32s2.ini

@@ -1,19 +1,19 @@
 [esp32s2_base]
-extends = esp32_base
+extends = esp32_common
 custom_esp32_kind = esp32s2
 
 build_src_filter = 
- ${esp32_base.build_src_filter} - <libpax/> -<nimble/> -<mesh/raspihttp>
+ ${esp32_common.build_src_filter} - <libpax/> -<nimble/> -<mesh/raspihttp>
 
 monitor_speed = 115200
 
 build_flags =
-  ${esp32_base.build_flags} 
+  ${esp32_common.build_flags}
   -DHAS_BLUETOOTH=0
   -DMESHTASTIC_EXCLUDE_PAXCOUNTER
   -DMESHTASTIC_EXCLUDE_BLUETOOTH
   
 lib_ignore = 
-  ${esp32_base.lib_ignore} 
+  ${esp32_common.lib_ignore}
   NimBLE-Arduino
   libpax

variants/esp32s3/esp32s3.ini

@@ -1,10 +1,10 @@
 [esp32s3_base]
-extends = esp32_base
+extends = esp32_common
 custom_esp32_kind = esp32s3
 
 monitor_speed = 115200
 
 build_flags =
-	${esp32_base.build_flags}
-	-DCONFIG_BT_NIMBLE_EXT_ADV=1
-	-DCONFIG_BT_NIMBLE_MAX_EXT_ADV_INSTANCES=2
+  ${esp32_common.build_flags}
+  -DCONFIG_BT_NIMBLE_EXT_ADV=1
+  -DCONFIG_BT_NIMBLE_MAX_EXT_ADV_INSTANCES=2

variants/esp32s3/icarus/platformio.ini

@@ -7,8 +7,6 @@ board_build.mcu = esp32s3
 board_build.partitions = default_8MB.csv
 upload_protocol = esptool
 upload_speed = 921600
-; TODO renovate or remove
-platform_packages = platformio/framework-arduinoespressif32@https://github.com/PowerFeather/powerfeather-meshtastic-arduino-lib/releases/download/2.0.16a/esp32-2.0.16.zip
 build_unflags =
   ${esp32s3_base.build_unflags}
   -DARDUINO_USB_MODE=1

variants/esp32s3/t-deck-pro/variant.h

@@ -100,3 +100,5 @@
 #define MODEM_DTR 8
 #define MODEM_RX 10
 #define MODEM_TX 11
+
+#define HAS_PHYSICAL_KEYBOARD 1

variants/esp32s3/t-deck/variant.h

@@ -23,6 +23,7 @@
 #define SCREEN_TRANSITION_FRAMERATE 5
 #define BRIGHTNESS_DEFAULT 130 // Medium Low Brightness
 #define USE_TFTDISPLAY 1
+#define HAS_PHYSICAL_KEYBOARD 1
 
 #define HAS_TOUCHSCREEN 1
 #define SCREEN_TOUCH_INT 16

variants/esp32s3/t-watch-s3/platformio.ini

@@ -14,12 +14,10 @@ lib_deps = ${esp32s3_base.lib_deps}
   # renovate: datasource=custom.pio depName=LovyanGFX packageName=lovyan03/library/LovyanGFX
   lovyan03/LovyanGFX@1.2.7
   # renovate: datasource=custom.pio depName=SensorLib packageName=lewisxhe/library/SensorLib
-  lewisxhe/SensorLib@0.3.2
+  lewisxhe/SensorLib@0.3.3
   # renovate: datasource=custom.pio depName=Adafruit DRV2605 packageName=adafruit/library/Adafruit DRV2605 Library
   adafruit/Adafruit DRV2605 Library@1.2.4
   # renovate: datasource=custom.pio depName=ESP8266Audio packageName=earlephilhower/library/ESP8266Audio
   earlephilhower/ESP8266Audio@1.9.9
   # renovate: datasource=custom.pio depName=ESP8266SAM packageName=earlephilhower/library/ESP8266SAM
   earlephilhower/ESP8266SAM@1.1.0
-  # renovate: datasource=custom.pio depName=lewisxhe-SensorLib packageName=lewisxhe/library/SensorLib
-  lewisxhe/SensorLib@0.2.0

variants/esp32s3/tbeam-s3-core/platformio.ini

@@ -8,7 +8,7 @@ board_check = true
 lib_deps =
   ${esp32s3_base.lib_deps}
   # renovate: datasource=custom.pio depName=SensorLib packageName=lewisxhe/library/SensorLib
-  lewisxhe/SensorLib@0.3.2
+  lewisxhe/SensorLib@0.3.3
 
 build_flags = 
   ${esp32s3_base.build_flags} 

variants/esp32s3/tlora-pager/platformio.ini

@@ -28,7 +28,7 @@ lib_deps = ${esp32s3_base.lib_deps}
   # renovate: datasource=custom.pio depName=PCF8563 packageName=lewisxhe/library/PCF8563_Library
   lewisxhe/PCF8563_Library@1.0.1
   # renovate: datasource=custom.pio depName=SensorLib packageName=lewisxhe/library/SensorLib
-  lewisxhe/SensorLib@0.3.2
+  lewisxhe/SensorLib@0.3.3
   # renovate: datasource=github-tags depName=pschatzmann_arduino-audio-driver packageName=pschatzmann/arduino-audio-driver
   https://github.com/pschatzmann/arduino-audio-driver/archive/v0.1.3.zip
   # TODO renovate

variants/esp32s3/tlora-pager/variant.h

@@ -21,6 +21,7 @@
 #define SCREEN_TRANSITION_FRAMERATE 5
 #define BRIGHTNESS_DEFAULT 130 // Medium Low Brightness
 #define USE_TFTDISPLAY 1
+#define HAS_PHYSICAL_KEYBOARD 1
 
 #define I2C_SDA SDA
 #define I2C_SCL SCL

variants/nrf52840/ELECROW-ThinkNode-M3/platformio.ini

@@ -15,5 +15,5 @@ lib_deps =
   ${nrf52840_base.lib_deps}
   # renovate: datasource=custom.pio depName=nRF52_PWM packageName=khoih-prog/library/nRF52_PWM
   khoih-prog/nRF52_PWM@1.0.1
-  # renovate: datasource=custom.pio depName=PCF8563 packageName=lewisxhe/library/PCF8563_Library
-  lewisxhe/PCF8563_Library@1.0.1
+  ; # renovate: datasource=custom.pio depName=SensorLib packageName=lewisxhe/library/SensorLib
+  ; lewisxhe/SensorLib@0.3.3

variants/nrf52840/ELECROW-ThinkNode-M3/variant.h

@@ -114,7 +114,8 @@ extern "C" {
 #define LR11X0_DIO_AS_RF_SWITCH
 
 // PCF8563 RTC Module
-#define PCF8563_RTC 0x51
+// REVISIT https://github.com/meshtastic/firmware/pull/9084
+// #define PCF8563_RTC 0x51
 
 #ifdef __cplusplus
 }

variants/nrf52840/ELECROW-ThinkNode-M6/platformio.ini

@@ -12,5 +12,5 @@ build_flags = ${nrf52840_base.build_flags}
 build_src_filter = ${nrf52_base.build_src_filter} +<../variants/nrf52840/ELECROW-ThinkNode-M6>
 lib_deps =
   ${nrf52840_base.lib_deps}
-  # renovate: datasource=custom.pio depName=PCF8563 packageName=lewisxhe/library/PCF8563_Library
-  lewisxhe/PCF8563_Library@1.0.1
+  ; # renovate: datasource=custom.pio depName=SensorLib packageName=lewisxhe/library/SensorLib
+  ; lewisxhe/SensorLib@0.3.3

variants/nrf52840/ELECROW-ThinkNode-M6/variant.cpp

@@ -41,3 +41,30 @@ void initVariant()
     pinMode(VDD_FLASH_EN, OUTPUT);
     digitalWrite(VDD_FLASH_EN, HIGH);
 }
+
+// called from main-nrf52.cpp during the cpuDeepSleep() function
+void variant_shutdown()
+{
+    // This sets the pin to OUTPUT and LOW for the pins *not* in the if block.
+    for (int pin = 0; pin < 48; pin++) {
+        if (pin == PIN_GPS_EN || pin == ADC_CTRL || pin == PIN_BUTTON1 || pin == PIN_SPI_MISO || pin == PIN_SPI_MOSI ||
+            pin == PIN_SPI_SCK) {
+            continue;
+        }
+        pinMode(pin, OUTPUT);
+        digitalWrite(pin, LOW);
+        if (pin >= 32) {
+            NRF_P1->DIRCLR = (1 << (pin - 32));
+        } else {
+            NRF_GPIO->DIRCLR = (1 << pin);
+        }
+    }
+
+    digitalWrite(PIN_GPS_EN, LOW);
+    digitalWrite(ADC_CTRL, LOW);
+    // digitalWrite(RTC_POWER, LOW);
+
+    nrf_gpio_cfg_input(PIN_BUTTON1, NRF_GPIO_PIN_PULLUP); // Configure the pin to be woken up as an input
+    nrf_gpio_pin_sense_t sense1 = NRF_GPIO_PIN_SENSE_LOW;
+    nrf_gpio_cfg_sense_set(PIN_BUTTON1, sense1);
+}

variants/nrf52840/ELECROW-ThinkNode-M6/variant.h

@@ -44,8 +44,10 @@ extern "C" {
 #define LED_BLUE -1
 #define LED_CHARGE (12)
 #define LED_PAIRING (7)
+#define PIN_LED2 LED_PAIRING
 
-#define LED_STATE_ON 1
+#define LED_STATE_ON HIGH
+#define LED_STATE_OFF LOW
 
 // USB power detection
 #define EXT_PWR_DETECT (13)
@@ -119,7 +121,8 @@ static const uint8_t A0 = PIN_A0;
 #define PIN_SERIAL2_TX (24)
 
 // PCF8563 RTC Module
-#define PCF8563_RTC 0x51
+// REVISIT https://github.com/meshtastic/firmware/pull/9084
+// #define PCF8563_RTC 0x51
 
 // SPI
 #define SPI_INTERFACES_COUNT 1

variants/nrf52840/canaryone/variant.h

@@ -103,7 +103,7 @@ static const uint8_t A0 = PIN_A0;
 #define EXTERNAL_FLASH_USE_QSPI
 
 // Add a delay on startup to allow LoRa and GPS to power up
-#define PIN_PWR_DELAY_MS 100
+#define PERIPHERAL_WARMUP_MS 100
 
 /*
  * Lora radio
@@ -178,4 +178,4 @@ static const uint8_t A0 = PIN_A0;
  *        Arduino objects - C++ only
  *----------------------------------------------------------------------------*/
 
-#endif
+#endif

variants/nrf52840/diy/nrf52_promicro_diy_tcxo/variant.h

@@ -90,16 +90,16 @@ NRF52 PRO MICRO PIN ASSIGNMENT
 #define BUTTON_PIN (32 + 0) // P1.00
 
 // GPS
-#define PIN_GPS_TX (0 + 20) // P0.20 - This is data from the MCU
-#define PIN_GPS_RX (0 + 22) // P0.22 - This is data from the GNSS
+#define GPS_TX_PIN (0 + 20) // P0.20 - This is data from the MCU
+#define GPS_RX_PIN (0 + 22) // P0.22 - This is data from the GNSS
 
 #define PIN_GPS_EN (0 + 24) // P0.24
 #define GPS_UBLOX
 // define GPS_DEBUG
 
 // UART interfaces
-#define PIN_SERIAL1_TX PIN_GPS_TX
-#define PIN_SERIAL1_RX PIN_GPS_RX
+#define PIN_SERIAL1_TX GPS_TX_PIN
+#define PIN_SERIAL1_RX GPS_RX_PIN
 
 #define PIN_SERIAL2_RX (0 + 6) // P0.06
 #define PIN_SERIAL2_TX (0 + 8) // P0.08

variants/nrf52840/heltec_mesh_solar/platformio.ini

@@ -48,6 +48,14 @@ build_flags = ${heltec_mesh_solar_base.build_flags}
   -DEINK_LIMIT_RATE_RESPONSIVE_SEC=1   ; Minimum interval between RESPONSIVE updates
   -DEINK_BACKGROUND_USES_FAST          ; (Optional) Use FAST refresh for both BACKGROUND and RESPONSIVE, until a limit is reached.
   -DEINK_HASQUIRK_GHOSTING             ; Display model is identified as "prone to ghosting"
+  -DENABLE_MESSAGE_PERSISTENCE=0       ; Disable flash persistence for space-limited build
+  -DMESHTASTIC_EXCLUDE_WIFI=1
+  -DMESHTASTIC_EXCLUDE_EXTERNALNOTIFICATION=1
+  -DMESHTASTIC_EXCLUDE_PAXCOUNTER=1
+  -DMESHTASTIC_EXCLUDE_REMOTEHARDWARE=1
+  -DMESHTASTIC_EXCLUDE_STOREFORWARD=1
+  -DMESHTASTIC_EXCLUDE_CANNEDMESSAGES=1
+  -DMESHTASTIC_EXCLUDE_WAYPOINT=1
 lib_deps =
   ${heltec_mesh_solar_base.lib_deps}
   # renovate: datasource=git-refs depName=meshtastic-GxEPD2 packageName=https://github.com/meshtastic/GxEPD2 gitBranch=master

variants/nrf52840/nano-g2-ultra/platformio.ini

@@ -11,5 +11,5 @@ build_src_filter = ${nrf52_base.build_src_filter} +<../variants/nrf52840/nano-g2
 lib_deps = 
   ${nrf52840_base.lib_deps}
   # renovate: datasource=custom.pio depName=SensorLib packageName=lewisxhe/library/SensorLib
-  lewisxhe/SensorLib@0.3.2
+  lewisxhe/SensorLib@0.3.3
 ;upload_protocol = fs

variants/nrf52840/nano-g2-ultra/variant.h

@@ -130,13 +130,13 @@ External serial flash W25Q16JV_IQ
 #define GPS_L76K
 
 #define PIN_GPS_STANDBY (0 + 13) // An output to wake GPS, low means allow sleep, high means force wake STANDBY
-#define PIN_GPS_TX (0 + 10)      // This is for bits going TOWARDS the CPU
-#define PIN_GPS_RX (0 + 9)       // This is for bits going TOWARDS the GPS
+#define GPS_TX_PIN (0 + 10)      // This is for bits going FROM the CPU
+#define GPS_RX_PIN (0 + 9)       // This is for bits going FROM the GPS
 
 // #define GPS_THREAD_INTERVAL 50
 
-#define PIN_SERIAL1_TX PIN_GPS_TX
-#define PIN_SERIAL1_RX PIN_GPS_RX
+#define PIN_SERIAL1_TX GPS_TX_PIN
+#define PIN_SERIAL1_RX GPS_RX_PIN
 
 // PCF8563 RTC Module
 #define PIN_RTC_INT (0 + 14) // Interrupt from the PCF8563 RTC

variants/nrf52840/seeed_solar_node/variant.h

@@ -116,13 +116,13 @@ static const uint8_t SCL = PIN_WIRE_SCL;
 // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 #define GPS_L76K
 #ifdef GPS_L76K
-#define PIN_GPS_TX D6 // 44
-#define PIN_GPS_RX D7 // 43
+#define GPS_TX_PIN D6 // 44
+#define GPS_RX_PIN D7 // 43
 #define HAS_GPS 1
 #define GPS_BAUDRATE 9600
 #define GPS_THREAD_INTERVAL 50
-#define PIN_SERIAL1_TX PIN_GPS_TX
-#define PIN_SERIAL1_RX PIN_GPS_RX
+#define PIN_SERIAL1_TX GPS_TX_PIN
+#define PIN_SERIAL1_RX GPS_RX_PIN
 #define PIN_GPS_STANDBY D0
 #define GPS_EN D18 // P1.05
 #endif

variants/nrf52840/seeed_wio_tracker_L1/variant.h

@@ -119,16 +119,14 @@ static const uint8_t SCL = PIN_WIRE_SCL;
 // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 #define GPS_L76K
 #ifdef GPS_L76K
-#define PIN_GPS_RX D6 // P0.26
-#define PIN_GPS_TX D7
+#define GPS_TX_PIN D6 // P0.26 - This is data from the MCU
+#define GPS_RX_PIN D7 // P0.27 - This is data from the GNSS
 #define HAS_GPS 1
 #define GPS_BAUDRATE 9600
 #define GPS_THREAD_INTERVAL 50
-#define PIN_SERIAL1_RX PIN_GPS_TX
-#define PIN_SERIAL1_TX PIN_GPS_RX
+#define PIN_SERIAL1_RX GPS_RX_PIN
+#define PIN_SERIAL1_TX GPS_TX_PIN
 
-#define GPS_RX_PIN PIN_GPS_TX
-#define GPS_TX_PIN PIN_GPS_RX
 #define PIN_GPS_STANDBY D0
 
 // #define GPS_DEBUG

variants/nrf52840/seeed_wio_tracker_L1_eink/variant.h

@@ -129,16 +129,14 @@ static const uint8_t SCL = PIN_WIRE_SCL;
 // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 #define GPS_L76K
 #ifdef GPS_L76K
-#define PIN_GPS_RX D6 // P0.26
-#define PIN_GPS_TX D7
+#define GPS_TX_PIN D6 // P0.26 - This is data from the MCU
+#define GPS_RX_PIN D7 // P0.27 - This is data from the GNSS
 #define HAS_GPS 1
 #define GPS_BAUDRATE 9600
 #define GPS_THREAD_INTERVAL 50
-#define PIN_SERIAL1_RX PIN_GPS_TX
-#define PIN_SERIAL1_TX PIN_GPS_RX
+#define PIN_SERIAL1_RX GPS_RX_PIN
+#define PIN_SERIAL1_TX GPS_TX_PIN
 
-#define GPS_RX_PIN PIN_GPS_TX
-#define GPS_TX_PIN PIN_GPS_RX
 #define PIN_GPS_STANDBY D0
 
 // #define GPS_DEBUG

variants/nrf52840/seeed_xiao_nrf52840_kit/variant.h

@@ -147,12 +147,12 @@ static const uint8_t SCK = PIN_SPI_SCK;
  */
 // GPS L76K
 #ifdef GPS_L76K
-#define PIN_GPS_TX D6
-#define PIN_GPS_RX D7
+#define GPS_TX_PIN D6 // This is data from the MCU
+#define GPS_RX_PIN D7 // This is data from the GNSS module
 #define HAS_GPS 1
 #define GPS_THREAD_INTERVAL 50
-#define PIN_SERIAL1_TX PIN_GPS_TX
-#define PIN_SERIAL1_RX PIN_GPS_RX
+#define PIN_SERIAL1_TX GPS_TX_PIN
+#define PIN_SERIAL1_RX GPS_RX_PIN
 #define PIN_GPS_STANDBY D0
 #else
 #define PIN_SERIAL1_RX (-1)

variants/nrf52840/t-echo/platformio.ini

@@ -23,7 +23,7 @@ lib_deps =
   # renovate: datasource=git-refs depName=meshtastic-GxEPD2 packageName=https://github.com/meshtastic/GxEPD2 gitBranch=master
   https://github.com/meshtastic/GxEPD2/archive/55f618961db45a23eff0233546430f1e5a80f63a.zip
   # renovate: datasource=custom.pio depName=SensorLib packageName=lewisxhe/library/SensorLib
-  lewisxhe/SensorLib@0.3.2
+  lewisxhe/SensorLib@0.3.3
 ;upload_protocol = fs
 
 [env:t-echo-inkhud]
@@ -44,4 +44,4 @@ lib_deps =
   ${inkhud.lib_deps} ; InkHUD libs first, so we get GFXRoot instead of AdafruitGFX
   ${nrf52840_base.lib_deps}
   # renovate: datasource=custom.pio depName=SensorLib packageName=lewisxhe/library/SensorLib
-  lewisxhe/SensorLib@0.3.2
+  lewisxhe/SensorLib@0.3.3

version.properties

@@ -1,4 +1,4 @@
 [VERSION]  
 major = 2
 minor = 7
-build = 18
+build = 17