Revert "Sync Wio lr1110 refresh with master (#4288)"

This reverts commit 5cc8ca59a3. Revert "Sync Wio lr1110 refresh with master (#4251)" This reverts commit d97e6b86b8. Revert "update SD_FLASH_SIZE to 0x27000 (#4232)" This reverts commit 2df8093fef.
2025-12-31 23:21:06 +00:00 · 2024-07-22 15:30:36 +02:00
parent 5cc8ca59a3
commit bdd1c53072
161 changed files with 1322 additions and 22200 deletions
--- a/src/graphics/Screen.cpp
+++ b/src/graphics/Screen.cpp
@@ -41,7 +41,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "mesh/Channels.h"
 #include "mesh/generated/meshtastic/deviceonly.pb.h"
 #include "meshUtils.h"
-#include "modules/AdminModule.h"
 #include "modules/ExternalNotificationModule.h"
 #include "modules/TextMessageModule.h"
 #include "sleep.h"
@@ -76,6 +75,7 @@ namespace graphics
 // A text message frame + debug frame + all the node infos
 FrameCallback *normalFrames;
 static uint32_t targetFramerate = IDLE_FRAMERATE;
+static char btPIN[16] = "888888";

 uint32_t logo_timeout = 5000; // 4 seconds for EACH logo

@@ -108,39 +108,15 @@ GeoCoord geoCoord;
 static bool heartbeat = false;
 #endif

-// Quick access to screen dimensions from static drawing functions
-// DEPRECATED. To-do: move static functions inside Screen class
-#define SCREEN_WIDTH display->getWidth()
-#define SCREEN_HEIGHT display->getHeight()
+static uint16_t displayWidth, displayHeight;
+
+#define SCREEN_WIDTH displayWidth
+#define SCREEN_HEIGHT displayHeight

 #include "graphics/ScreenFonts.h"

 #define getStringCenteredX(s) ((SCREEN_WIDTH - display->getStringWidth(s)) / 2)

-/// Check if the display can render a string (detect special chars; emoji)
-static bool haveGlyphs(const char *str)
-{
-#if defined(OLED_UA) || defined(OLED_RU)
-    // Don't want to make any assumptions about custom language support
-    return true;
-#endif
-
-    // Check each character with the lookup function for the OLED library
-    // We're not really meant to use this directly..
-    bool have = true;
-    for (uint16_t i = 0; i < strlen(str); i++) {
-        uint8_t result = Screen::customFontTableLookup((uint8_t)str[i]);
-        // If font doesn't support a character, it is substituted for ¿
-        if (result == 191 && (uint8_t)str[i] != 191) {
-            have = false;
-            break;
-        }
-    }
-
-    LOG_DEBUG("haveGlyphs=%d\n", have);
-    return have;
-}
-
 /**
 * Draw the icon with extra info printed around the corners
 */
@@ -164,15 +140,13 @@ static void drawIconScreen(const char *upperMsg, OLEDDisplay *display, OLEDDispl
    if (upperMsg)
        display->drawString(x + 0, y + 0, upperMsg);

-    // Draw version and short name in upper right
-    char buf[25];
-    snprintf(buf, sizeof(buf), "%s\n%s", xstr(APP_VERSION_SHORT), haveGlyphs(owner.short_name) ? owner.short_name : "");
-
-    display->setTextAlignment(TEXT_ALIGN_RIGHT);
-    display->drawString(x + SCREEN_WIDTH, y + 0, buf);
+    // Draw version in upper right
+    char buf[16];
+    snprintf(buf, sizeof(buf), "%s",
+             xstr(APP_VERSION_SHORT)); // Note: we don't bother printing region or now, it makes the string too long
+    display->drawString(x + SCREEN_WIDTH - display->getStringWidth(buf), y + 0, buf);
    screen->forceDisplay();
-
-    display->setTextAlignment(TEXT_ALIGN_LEFT); // Restore left align, just to be kind to any other unsuspecting code
+    // FIXME - draw serial # somewhere?
 }

 static void drawOEMIconScreen(const char *upperMsg, OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
@@ -207,15 +181,14 @@ static void drawOEMIconScreen(const char *upperMsg, OLEDDisplay *display, OLEDDi
    if (upperMsg)
        display->drawString(x + 0, y + 0, upperMsg);

-    // Draw version and shortname in upper right
-    char buf[25];
-    snprintf(buf, sizeof(buf), "%s\n%s", xstr(APP_VERSION_SHORT), haveGlyphs(owner.short_name) ? owner.short_name : "");
-
-    display->setTextAlignment(TEXT_ALIGN_RIGHT);
-    display->drawString(x + SCREEN_WIDTH, y + 0, buf);
+    // Draw version in upper right
+    char buf[16];
+    snprintf(buf, sizeof(buf), "%s",
+             xstr(APP_VERSION_SHORT)); // Note: we don't bother printing region or now, it makes the string too long
+    display->drawString(x + SCREEN_WIDTH - display->getStringWidth(buf), y + 0, buf);
    screen->forceDisplay();

-    display->setTextAlignment(TEXT_ALIGN_LEFT); // Restore left align, just to be kind to any other unsuspecting code
+    // FIXME - draw serial # somewhere?
 }

 static void drawOEMBootScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
@@ -225,7 +198,7 @@ static void drawOEMBootScreen(OLEDDisplay *display, OLEDDisplayUiState *state, i
    drawOEMIconScreen(region, display, state, x, y);
 }

-void Screen::drawFrameText(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y, const char *message)
+static void drawFrameText(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y, const char *message)
 {
    uint16_t x_offset = display->width() / 2;
    display->setTextAlignment(TEXT_ALIGN_CENTER);
@@ -233,6 +206,20 @@ void Screen::drawFrameText(OLEDDisplay *display, OLEDDisplayUiState *state, int1
    display->drawString(x_offset + x, 26 + y, message);
 }

+static void drawBootScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
+{
+#ifdef ARCH_ESP32
+    if (wakeCause == ESP_SLEEP_WAKEUP_TIMER || wakeCause == ESP_SLEEP_WAKEUP_EXT1) {
+        drawFrameText(display, state, x, y, "Resuming...");
+    } else
+#endif
+    {
+        // Draw region in upper left
+        const char *region = myRegion ? myRegion->name : NULL;
+        drawIconScreen(region, display, state, x, y);
+    }
+}
+
 // Used on boot when a certificate is being created
 static void drawSSLScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
 {
@@ -290,19 +277,40 @@ static void drawFunctionOverlay(OLEDDisplay *display, OLEDDisplayUiState *state)
    }
 }

+/// Check if the display can render a string (detect special chars; emoji)
+static bool haveGlyphs(const char *str)
+{
+#if defined(OLED_UA) || defined(OLED_RU)
+    // Don't want to make any assumptions about custom language support
+    return true;
+#endif
+
+    // Check each character with the lookup function for the OLED library
+    // We're not really meant to use this directly..
+    bool have = true;
+    for (uint16_t i = 0; i < strlen(str); i++) {
+        uint8_t result = Screen::customFontTableLookup((uint8_t)str[i]);
+        // If font doesn't support a character, it is substituted for ¿
+        if (result == 191 && (uint8_t)str[i] != 191) {
+            have = false;
+            break;
+        }
+    }
+
+    LOG_DEBUG("haveGlyphs=%d\n", have);
+    return have;
+}
+
 #ifdef USE_EINK
 /// Used on eink displays while in deep sleep
 static void drawDeepSleepScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
 {
-
    // Next frame should use full-refresh, and block while running, else device will sleep before async callback
    EINK_ADD_FRAMEFLAG(display, COSMETIC);
    EINK_ADD_FRAMEFLAG(display, BLOCKING);

    LOG_DEBUG("Drawing deep sleep screen\n");
-
-    // Display displayStr on the screen
-    drawIconScreen("Sleeping", display, state, x, y);
+    drawIconScreen("Sleeping...", display, state, x, y);
 }

 /// Used on eink displays when screen updates are paused
@@ -367,7 +375,7 @@ static void drawModuleFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int
    // in the array of "drawScreen" functions; however,
    // the passed-state doesn't quite reflect the "current"
    // screen, so we have to detect it.
-    if (state->frameState == IN_TRANSITION && state->transitionFrameRelationship == TransitionRelationship_INCOMING) {
+    if (state->frameState == IN_TRANSITION && state->transitionFrameRelationship == INCOMING) {
        // if we're transitioning from the end of the frame list back around to the first
        // frame, then we want this to be `0`
        module_frame = state->transitionFrameTarget;
@@ -381,6 +389,31 @@ static void drawModuleFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int
    pi.drawFrame(display, state, x, y);
 }

+static void drawFrameBluetooth(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
+{
+    int x_offset = display->width() / 2;
+    int y_offset = display->height() <= 80 ? 0 : 32;
+    display->setTextAlignment(TEXT_ALIGN_CENTER);
+    display->setFont(FONT_MEDIUM);
+    display->drawString(x_offset + x, y_offset + y, "Bluetooth");
+
+    display->setFont(FONT_SMALL);
+    y_offset = display->height() == 64 ? y_offset + FONT_HEIGHT_MEDIUM - 4 : y_offset + FONT_HEIGHT_MEDIUM + 5;
+    display->drawString(x_offset + x, y_offset + y, "Enter this code");
+
+    display->setFont(FONT_LARGE);
+    String displayPin(btPIN);
+    String pin = displayPin.substring(0, 3) + " " + displayPin.substring(3, 6);
+    y_offset = display->height() == 64 ? y_offset + FONT_HEIGHT_SMALL - 5 : y_offset + FONT_HEIGHT_SMALL + 5;
+    display->drawString(x_offset + x, y_offset + y, pin);
+
+    display->setFont(FONT_SMALL);
+    String deviceName = "Name: ";
+    deviceName.concat(getDeviceName());
+    y_offset = display->height() == 64 ? y_offset + FONT_HEIGHT_LARGE - 6 : y_offset + FONT_HEIGHT_LARGE + 5;
+    display->drawString(x_offset + x, y_offset + y, deviceName);
+}
+
 static void drawFrameFirmware(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
 {
    display->setTextAlignment(TEXT_ALIGN_CENTER);
@@ -1058,8 +1091,45 @@ static void drawTextMessageFrame(OLEDDisplay *display, OLEDDisplayUiState *state
 #endif
 }

+/// Draw the last waypoint we received
+static void drawWaypointFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
+{
+    static char tempBuf[237];
+
+    meshtastic_MeshPacket &mp = devicestate.rx_waypoint;
+    meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(getFrom(&mp));
+
+    display->setTextAlignment(TEXT_ALIGN_LEFT);
+    display->setFont(FONT_SMALL);
+    if (config.display.displaymode == meshtastic_Config_DisplayConfig_DisplayMode_INVERTED) {
+        display->fillRect(0 + x, 0 + y, x + display->getWidth(), y + FONT_HEIGHT_SMALL);
+        display->setColor(BLACK);
+    }
+
+    uint32_t seconds = sinceReceived(&mp);
+    uint32_t minutes = seconds / 60;
+    uint32_t hours = minutes / 60;
+    uint32_t days = hours / 24;
+
+    if (config.display.heading_bold) {
+        display->drawStringf(1 + x, 0 + y, tempBuf, "%s ago from %s",
+                             screen->drawTimeDelta(days, hours, minutes, seconds).c_str(),
+                             (node && node->has_user) ? node->user.short_name : "???");
+    }
+    display->drawStringf(0 + x, 0 + y, tempBuf, "%s ago from %s", screen->drawTimeDelta(days, hours, minutes, seconds).c_str(),
+                         (node && node->has_user) ? node->user.short_name : "???");
+
+    display->setColor(WHITE);
+    meshtastic_Waypoint scratch;
+    memset(&scratch, 0, sizeof(scratch));
+    if (pb_decode_from_bytes(mp.decoded.payload.bytes, mp.decoded.payload.size, &meshtastic_Waypoint_msg, &scratch)) {
+        snprintf(tempBuf, sizeof(tempBuf), "Received waypoint: %s", scratch.name);
+        display->drawStringMaxWidth(0 + x, 0 + y + FONT_HEIGHT_SMALL, x + display->getWidth(), tempBuf);
+    }
+}
+
 /// Draw a series of fields in a column, wrapping to multiple columns if needed
-void Screen::drawColumns(OLEDDisplay *display, int16_t x, int16_t y, const char **fields)
+static void drawColumns(OLEDDisplay *display, int16_t x, int16_t y, const char **fields)
 {
    // The coordinates define the left starting point of the text
    display->setTextAlignment(TEXT_ALIGN_LEFT);
@@ -1239,13 +1309,56 @@ static void drawGPScoordinates(OLEDDisplay *display, int16_t x, int16_t y, const
    }
 }
 #endif
+namespace
+{
+
+/// A basic 2D point class for drawing
+class Point
+{
+  public:
+    float x, y;
+
+    Point(float _x, float _y) : x(_x), y(_y) {}
+
+    /// Apply a rotation around zero (standard rotation matrix math)
+    void rotate(float radian)
+    {
+        float cos = cosf(radian), sin = sinf(radian);
+        float rx = x * cos + y * sin, ry = -x * sin + y * cos;
+
+        x = rx;
+        y = ry;
+    }
+
+    void translate(int16_t dx, int dy)
+    {
+        x += dx;
+        y += dy;
+    }
+
+    void scale(float f)
+    {
+        // We use -f here to counter the flip that happens
+        // on the y axis when drawing and rotating on screen
+        x *= f;
+        y *= -f;
+    }
+};
+
+} // namespace
+
+static void drawLine(OLEDDisplay *d, const Point &p1, const Point &p2)
+{
+    d->drawLine(p1.x, p1.y, p2.x, p2.y);
+}
+
 /**
 * Given a recent lat/lon return a guess of the heading the user is walking on.
 *
 * We keep a series of "after you've gone 10 meters, what is your heading since
 * the last reference point?"
 */
-float Screen::estimatedHeading(double lat, double lon)
+static float estimatedHeading(double lat, double lon)
 {
    static double oldLat, oldLon;
    static float b;
@@ -1269,13 +1382,38 @@ float Screen::estimatedHeading(double lat, double lon)
    return b;
 }

+static uint16_t getCompassDiam(OLEDDisplay *display)
+{
+    uint16_t diam = 0;
+    uint16_t offset = 0;
+
+    if (config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_DEFAULT)
+        offset = FONT_HEIGHT_SMALL;
+
+    // get the smaller of the 2 dimensions and subtract 20
+    if (display->getWidth() > (display->getHeight() - offset)) {
+        diam = display->getHeight() - offset;
+        // if 2/3 of the other size would be smaller, use that
+        if (diam > (display->getWidth() * 2 / 3)) {
+            diam = display->getWidth() * 2 / 3;
+        }
+    } else {
+        diam = display->getWidth();
+        if (diam > ((display->getHeight() - offset) * 2 / 3)) {
+            diam = (display->getHeight() - offset) * 2 / 3;
+        }
+    }
+
+    return diam - 20;
+};
+
 /// We will skip one node - the one for us, so we just blindly loop over all
 /// nodes
 static size_t nodeIndex;
 static int8_t prevFrame = -1;

 // Draw the arrow pointing to a node's location
-void Screen::drawNodeHeading(OLEDDisplay *display, int16_t compassX, int16_t compassY, uint16_t compassDiam, float headingRadian)
+static void drawNodeHeading(OLEDDisplay *display, int16_t compassX, int16_t compassY, float headingRadian)
 {
    Point tip(0.0f, 0.5f), tail(0.0f, -0.5f); // pointing up initially
    float arrowOffsetX = 0.2f, arrowOffsetY = 0.2f;
@@ -1285,45 +1423,16 @@ void Screen::drawNodeHeading(OLEDDisplay *display, int16_t compassX, int16_t com

    for (int i = 0; i < 4; i++) {
        arrowPoints[i]->rotate(headingRadian);
-        arrowPoints[i]->scale(compassDiam * 0.6);
+        arrowPoints[i]->scale(getCompassDiam(display) * 0.6);
        arrowPoints[i]->translate(compassX, compassY);
    }
-    display->drawLine(tip.x, tip.y, tail.x, tail.y);
-    display->drawLine(leftArrow.x, leftArrow.y, tip.x, tip.y);
-    display->drawLine(rightArrow.x, rightArrow.y, tip.x, tip.y);
+    drawLine(display, tip, tail);
+    drawLine(display, leftArrow, tip);
+    drawLine(display, rightArrow, tip);
 }

-// Get a string representation of the time passed since something happened
-void Screen::getTimeAgoStr(uint32_t agoSecs, char *timeStr, uint8_t maxLength)
-{
-    // Use an absolute timestamp in some cases.
-    // Particularly useful with E-Ink displays. Static UI, fewer refreshes.
-    uint8_t timestampHours, timestampMinutes;
-    int32_t daysAgo;
-    bool useTimestamp = deltaToTimestamp(agoSecs, &timestampHours, &timestampMinutes, &daysAgo);
-
-    if (agoSecs < 120) // last 2 mins?
-        snprintf(timeStr, maxLength, "%u seconds ago", agoSecs);
-    // -- if suitable for timestamp --
-    else if (useTimestamp && agoSecs < 15 * SECONDS_IN_MINUTE) // Last 15 minutes
-        snprintf(timeStr, maxLength, "%u minutes ago", agoSecs / SECONDS_IN_MINUTE);
-    else if (useTimestamp && daysAgo == 0) // Today
-        snprintf(timeStr, maxLength, "Last seen: %02u:%02u", (unsigned int)timestampHours, (unsigned int)timestampMinutes);
-    else if (useTimestamp && daysAgo == 1) // Yesterday
-        snprintf(timeStr, maxLength, "Seen yesterday");
-    else if (useTimestamp && daysAgo > 1) // Last six months (capped by deltaToTimestamp method)
-        snprintf(timeStr, maxLength, "%li days ago", (long)daysAgo);
-    // -- if using time delta instead --
-    else if (agoSecs < 120 * 60) // last 2 hrs
-        snprintf(timeStr, maxLength, "%u minutes ago", agoSecs / 60);
-    // Only show hours ago if it's been less than 6 months. Otherwise, we may have bad data.
-    else if ((agoSecs / 60 / 60) < (hours_in_month * 6))
-        snprintf(timeStr, maxLength, "%u hours ago", agoSecs / 60 / 60);
-    else
-        snprintf(timeStr, maxLength, "unknown age");
-}
-
-void Screen::drawCompassNorth(OLEDDisplay *display, int16_t compassX, int16_t compassY, float myHeading)
+// Draw north
+static void drawCompassNorth(OLEDDisplay *display, int16_t compassX, int16_t compassY, float myHeading)
 {
    // If north is supposed to be at the top of the compass we want rotation to be +0
    if (config.display.compass_north_top)
@@ -1333,43 +1442,19 @@ void Screen::drawCompassNorth(OLEDDisplay *display, int16_t compassX, int16_t co
    Point N3(-0.04f, 0.55f), N4(0.04f, 0.55f);
    Point *rosePoints[] = {&N1, &N2, &N3, &N4};

-    uint16_t compassDiam = Screen::getCompassDiam(SCREEN_WIDTH, SCREEN_HEIGHT);
-
    for (int i = 0; i < 4; i++) {
        // North on compass will be negative of heading
        rosePoints[i]->rotate(-myHeading);
-        rosePoints[i]->scale(compassDiam);
+        rosePoints[i]->scale(getCompassDiam(display));
        rosePoints[i]->translate(compassX, compassY);
    }
-    display->drawLine(N1.x, N1.y, N3.x, N3.y);
-    display->drawLine(N2.x, N2.y, N4.x, N4.y);
-    display->drawLine(N1.x, N1.y, N4.x, N4.y);
+    drawLine(display, N1, N3);
+    drawLine(display, N2, N4);
+    drawLine(display, N1, N4);
 }

-uint16_t Screen::getCompassDiam(uint32_t displayWidth, uint32_t displayHeight)
-{
-    uint16_t diam = 0;
-    uint16_t offset = 0;
-
-    if (config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_DEFAULT)
-        offset = FONT_HEIGHT_SMALL;
-
-    // get the smaller of the 2 dimensions and subtract 20
-    if (displayWidth > (displayHeight - offset)) {
-        diam = displayHeight - offset;
-        // if 2/3 of the other size would be smaller, use that
-        if (diam > (displayWidth * 2 / 3)) {
-            diam = displayWidth * 2 / 3;
-        }
-    } else {
-        diam = displayWidth;
-        if (diam > ((displayHeight - offset) * 2 / 3)) {
-            diam = (displayHeight - offset) * 2 / 3;
-        }
-    }
-
-    return diam - 20;
-};
+/// Convert an integer GPS coords to a floating point
+#define DegD(i) (i * 1e-7)

 static void drawNodeInfo(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
 {
@@ -1409,8 +1494,34 @@ static void drawNodeInfo(OLEDDisplay *display, OLEDDisplayUiState *state, int16_
        snprintf(signalStr, sizeof(signalStr), "Signal: %d%%", clamp((int)((node->snr + 10) * 5), 0, 100));
    }

+    uint32_t agoSecs = sinceLastSeen(node);
    static char lastStr[20];
-    screen->getTimeAgoStr(sinceLastSeen(node), lastStr, sizeof(lastStr));
+
+    // Use an absolute timestamp in some cases.
+    // Particularly useful with E-Ink displays. Static UI, fewer refreshes.
+    uint8_t timestampHours, timestampMinutes;
+    int32_t daysAgo;
+    bool useTimestamp = deltaToTimestamp(agoSecs, &timestampHours, &timestampMinutes, &daysAgo);
+
+    if (agoSecs < 120) // last 2 mins?
+        snprintf(lastStr, sizeof(lastStr), "%u seconds ago", agoSecs);
+    // -- if suitable for timestamp --
+    else if (useTimestamp && agoSecs < 15 * SECONDS_IN_MINUTE) // Last 15 minutes
+        snprintf(lastStr, sizeof(lastStr), "%u minutes ago", agoSecs / SECONDS_IN_MINUTE);
+    else if (useTimestamp && daysAgo == 0) // Today
+        snprintf(lastStr, sizeof(lastStr), "Last seen: %02u:%02u", (unsigned int)timestampHours, (unsigned int)timestampMinutes);
+    else if (useTimestamp && daysAgo == 1) // Yesterday
+        snprintf(lastStr, sizeof(lastStr), "Seen yesterday");
+    else if (useTimestamp && daysAgo > 1) // Last six months (capped by deltaToTimestamp method)
+        snprintf(lastStr, sizeof(lastStr), "%li days ago", (long)daysAgo);
+    // -- if using time delta instead --
+    else if (agoSecs < 120 * 60) // last 2 hrs
+        snprintf(lastStr, sizeof(lastStr), "%u minutes ago", agoSecs / 60);
+    // Only show hours ago if it's been less than 6 months. Otherwise, we may have bad data.
+    else if ((agoSecs / 60 / 60) < (hours_in_month * 6))
+        snprintf(lastStr, sizeof(lastStr), "%u hours ago", agoSecs / 60 / 60);
+    else
+        snprintf(lastStr, sizeof(lastStr), "unknown age");

    static char distStr[20];
    if (config.display.units == meshtastic_Config_DisplayConfig_DisplayUnits_IMPERIAL) {
@@ -1421,14 +1532,13 @@ static void drawNodeInfo(OLEDDisplay *display, OLEDDisplayUiState *state, int16_
    meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
    const char *fields[] = {username, lastStr, signalStr, distStr, NULL};
    int16_t compassX = 0, compassY = 0;
-    uint16_t compassDiam = Screen::getCompassDiam(SCREEN_WIDTH, SCREEN_HEIGHT);

    // coordinates for the center of the compass/circle
    if (config.display.displaymode == meshtastic_Config_DisplayConfig_DisplayMode_DEFAULT) {
-        compassX = x + SCREEN_WIDTH - compassDiam / 2 - 5;
+        compassX = x + SCREEN_WIDTH - getCompassDiam(display) / 2 - 5;
        compassY = y + SCREEN_HEIGHT / 2;
    } else {
-        compassX = x + SCREEN_WIDTH - compassDiam / 2 - 5;
+        compassX = x + SCREEN_WIDTH - getCompassDiam(display) / 2 - 5;
        compassY = y + FONT_HEIGHT_SMALL + (SCREEN_HEIGHT - FONT_HEIGHT_SMALL) / 2;
    }
    bool hasNodeHeading = false;
@@ -1439,8 +1549,8 @@ static void drawNodeInfo(OLEDDisplay *display, OLEDDisplayUiState *state, int16_
        if (screen->hasHeading())
            myHeading = (screen->getHeading()) * PI / 180; // gotta convert compass degrees to Radians
        else
-            myHeading = screen->estimatedHeading(DegD(op.latitude_i), DegD(op.longitude_i));
-        screen->drawCompassNorth(display, compassX, compassY, myHeading);
+            myHeading = estimatedHeading(DegD(op.latitude_i), DegD(op.longitude_i));
+        drawCompassNorth(display, compassX, compassY, myHeading);

        if (hasValidPosition(node)) {
            // display direction toward node
@@ -1467,7 +1577,7 @@ static void drawNodeInfo(OLEDDisplay *display, OLEDDisplayUiState *state, int16_
            // If the top of the compass is not a static north we need adjust bearingToOther based on heading
            if (!config.display.compass_north_top)
                bearingToOther -= myHeading;
-            screen->drawNodeHeading(display, compassX, compassY, compassDiam, bearingToOther);
+            drawNodeHeading(display, compassX, compassY, bearingToOther);
        }
    }
    if (!hasNodeHeading) {
@@ -1477,19 +1587,15 @@ static void drawNodeInfo(OLEDDisplay *display, OLEDDisplayUiState *state, int16_
        // hasValidPosition(node));
        display->drawString(compassX - FONT_HEIGHT_SMALL / 4, compassY - FONT_HEIGHT_SMALL / 2, "?");
    }
-    display->drawCircle(compassX, compassY, compassDiam / 2);
+    display->drawCircle(compassX, compassY, getCompassDiam(display) / 2);

    if (config.display.displaymode == meshtastic_Config_DisplayConfig_DisplayMode_INVERTED) {
        display->setColor(BLACK);
    }
    // Must be after distStr is populated
-    screen->drawColumns(display, x, y, fields);
+    drawColumns(display, x, y, fields);
 }

-#if defined(ESP_PLATFORM) && defined(USE_ST7789)
-SPIClass SPI1(HSPI);
-#endif
-
 Screen::Screen(ScanI2C::DeviceAddress address, meshtastic_Config_DisplayConfig_OledType screenType, OLEDDISPLAY_GEOMETRY geometry)
    : concurrency::OSThread("Screen"), address_found(address), model(screenType), geometry(geometry), cmdQueue(32)
 {
@@ -1497,13 +1603,6 @@ Screen::Screen(ScanI2C::DeviceAddress address, meshtastic_Config_DisplayConfig_O
 #if defined(USE_SH1106) || defined(USE_SH1107) || defined(USE_SH1107_128_64)
    dispdev = new SH1106Wire(address.address, -1, -1, geometry,
                             (address.port == ScanI2C::I2CPort::WIRE1) ? HW_I2C::I2C_TWO : HW_I2C::I2C_ONE);
-#elif defined(USE_ST7789)
-#ifdef ESP_PLATFORM
-    dispdev = new ST7789Spi(&SPI1, ST7789_RESET, ST7789_RS, ST7789_NSS, GEOMETRY_RAWMODE, TFT_WIDTH, TFT_HEIGHT, ST7789_SDA,
-                            ST7789_MISO, ST7789_SCK);
-#else
-    dispdev = new ST7789Spi(&SPI1, ST7789_RESET, ST7789_RS, ST7789_NSS, GEOMETRY_RAWMODE, TFT_WIDTH, TFT_HEIGHT);
-#endif
 #elif defined(USE_SSD1306)
    dispdev = new SSD1306Wire(address.address, -1, -1, geometry,
                              (address.port == ScanI2C::I2CPort::WIRE1) ? HW_I2C::I2C_TWO : HW_I2C::I2C_ONE);
@@ -1582,14 +1681,7 @@ void Screen::handleSetOn(bool on, FrameCallback einkScreensaver)
 #endif

            dispdev->displayOn();
-#ifdef USE_ST7789
-#ifdef ESP_PLATFORM
-            analogWrite(VTFT_LEDA, BRIGHTNESS_DEFAULT);
-#else
-            pinMode(VTFT_LEDA, OUTPUT);
-            digitalWrite(VTFT_LEDA, TFT_BACKLIGHT_ON);
-#endif
-#endif
+
            enabled = true;
            setInterval(0); // Draw ASAP
            runASAP = true;
@@ -1600,12 +1692,6 @@ void Screen::handleSetOn(bool on, FrameCallback einkScreensaver)
 #endif
            LOG_INFO("Turning off screen\n");
            dispdev->displayOff();
-
-#ifdef USE_ST7789
-            pinMode(VTFT_LEDA, OUTPUT);
-            digitalWrite(VTFT_LEDA, !TFT_BACKLIGHT_ON);
-#endif
-
 #ifdef T_WATCH_S3
            PMU->disablePowerOutput(XPOWERS_ALDO2);
 #endif
@@ -1655,19 +1741,9 @@ void Screen::setup()

    // Add frames.
    EINK_ADD_FRAMEFLAG(dispdev, DEMAND_FAST);
-    alertFrames[0] = [this](OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y) -> void {
-#ifdef ARCH_ESP32
-        if (wakeCause == ESP_SLEEP_WAKEUP_TIMER || wakeCause == ESP_SLEEP_WAKEUP_EXT1) {
-            drawFrameText(display, state, x, y, "Resuming...");
-        } else
-#endif
-        {
-            // Draw region in upper left
-            const char *region = myRegion ? myRegion->name : NULL;
-            drawIconScreen(region, display, state, x, y);
-        }
-    };
-    ui->setFrames(alertFrames, 1);
+    static FrameCallback bootFrames[] = {drawBootScreen};
+    static const int bootFrameCount = sizeof(bootFrames) / sizeof(bootFrames[0]);
+    ui->setFrames(bootFrames, bootFrameCount);
    // No overlays.
    ui->setOverlays(nullptr, 0);

@@ -1726,7 +1802,6 @@ void Screen::setup()
    powerStatusObserver.observe(&powerStatus->onNewStatus);
    gpsStatusObserver.observe(&gpsStatus->onNewStatus);
    nodeStatusObserver.observe(&nodeStatus->onNewStatus);
-    adminMessageObserver.observe(adminModule);
    if (textMessageModule)
        textMessageObserver.observe(textMessageModule);
    if (inputBroker)
@@ -1841,22 +1916,13 @@ int32_t Screen::runOnce()
        case Cmd::SHOW_NEXT_FRAME:
            handleShowNextFrame();
            break;
-        case Cmd::START_ALERT_FRAME: {
-            showingBootScreen = false; // this should avoid the edge case where an alert triggers before the boot screen goes away
-            showingNormalScreen = false;
-            alertFrames[0] = alertFrame;
-#ifdef USE_EINK
-            EINK_ADD_FRAMEFLAG(dispdev, DEMAND_FAST); // Use fast-refresh for next frame, no skip please
-            EINK_ADD_FRAMEFLAG(dispdev, BLOCKING);    // Edge case: if this frame is promoted to COSMETIC, wait for update
-            handleSetOn(true); // Ensure power-on to receive deep-sleep screensaver (PowerFSM should handle?)
-#endif
-            setFrameImmediateDraw(alertFrames);
+        case Cmd::START_BLUETOOTH_PIN_SCREEN:
+            handleStartBluetoothPinScreen(cmd.bluetooth_pin);
            break;
-        }
        case Cmd::START_FIRMWARE_UPDATE_SCREEN:
            handleStartFirmwareUpdateScreen();
            break;
-        case Cmd::STOP_ALERT_FRAME:
+        case Cmd::STOP_BLUETOOTH_PIN_SCREEN:
        case Cmd::STOP_BOOT_SCREEN:
            EINK_ADD_FRAMEFLAG(dispdev, COSMETIC); // E-Ink: Explicitly use full-refresh for next frame
            setFrames();
@@ -1865,6 +1931,12 @@ int32_t Screen::runOnce()
            handlePrint(cmd.print_text);
            free(cmd.print_text);
            break;
+        case Cmd::START_SHUTDOWN_SCREEN:
+            handleShutdownScreen();
+            break;
+        case Cmd::START_REBOOT_SCREEN:
+            handleRebootScreen();
+            break;
        default:
            LOG_ERROR("Invalid screen cmd\n");
        }
@@ -1955,6 +2027,9 @@ void Screen::setWelcomeFrames()
 /// Determine which screensaver frame to use, then set the FrameCallback
 void Screen::setScreensaverFrames(FrameCallback einkScreensaver)
 {
+    // Remember current frame, restore position at power-on
+    uint8_t frameNumber = ui->getUiState()->currentFrame;
+
    // Retain specified frame / overlay callback beyond scope of this method
    static FrameCallback screensaverFrame;
    static OverlayCallback screensaverOverlay;
@@ -1992,8 +2067,9 @@ void Screen::setScreensaverFrames(FrameCallback einkScreensaver)
 #endif

    // Prepare now for next frame, shown when display wakes
-    ui->setOverlays(NULL, 0);  // Clear overlay
-    setFrames(FOCUS_PRESERVE); // Return to normal display updates, showing same frame as before screensaver, ideally
+    ui->setOverlays(NULL, 0);       // Clear overlay
+    setFrames();                    // Return to normal display updates
+    ui->switchToFrame(frameNumber); // Attempt to return to same frame after power-on

    // Pick a refresh method, for when display wakes
 #ifdef EINK_HASQUIRK_GHOSTING
@@ -2004,13 +2080,9 @@ void Screen::setScreensaverFrames(FrameCallback einkScreensaver)
 }
 #endif

-// Regenerate the normal set of frames, focusing a specific frame if requested
-// Called when a frame should be added / removed, or custom frames should be cleared
-void Screen::setFrames(FrameFocus focus)
+// restore our regular frame list
+void Screen::setFrames()
 {
-    uint8_t originalPosition = ui->getUiState()->currentFrame;
-    FramesetInfo fsi; // Location of specific frames, for applying focus parameter
-
    LOG_DEBUG("showing standard frames\n");
    showingNormalScreen = true;

@@ -2044,36 +2116,27 @@ void Screen::setFrames(FrameFocus focus)
    // is the same offset into the moduleFrames vector
    // so that we can invoke the module's callback
    for (auto i = moduleFrames.begin(); i != moduleFrames.end(); ++i) {
-        // Draw the module frame, using the hack described above
-        normalFrames[numframes] = drawModuleFrame;
-
-        // Check if the module being drawn has requested focus
-        // We will honor this request later, if setFrames was triggered by a UIFrameEvent
-        MeshModule *m = *i;
-        if (m->isRequestingFocus())
-            fsi.positions.focusedModule = numframes;
-
-        numframes++;
+        normalFrames[numframes++] = drawModuleFrame;
    }

    LOG_DEBUG("Added modules.  numframes: %d\n", numframes);

    // If we have a critical fault, show it first
-    fsi.positions.fault = numframes;
-    if (error_code) {
+    if (error_code)
        normalFrames[numframes++] = drawCriticalFaultFrame;
-        focus = FOCUS_FAULT; // Change our "focus" parameter, to ensure we show the fault frame
-    }

 #ifdef T_WATCH_S3
    normalFrames[numframes++] = screen->digitalWatchFace ? &Screen::drawDigitalClockFrame : &Screen::drawAnalogClockFrame;
 #endif

    // If we have a text message - show it next, unless it's a phone message and we aren't using any special modules
-    fsi.positions.textMessage = numframes;
    if (devicestate.has_rx_text_message && shouldDrawMessage(&devicestate.rx_text_message)) {
        normalFrames[numframes++] = drawTextMessageFrame;
    }
+    // If we have a waypoint - show it next, unless it's a phone message and we aren't using any special modules
+    if (devicestate.has_rx_waypoint && shouldDrawMessage(&devicestate.rx_waypoint)) {
+        normalFrames[numframes++] = drawWaypointFrame;
+    }

    // then all the nodes
    // We only show a few nodes in our scrolling list - because meshes with many nodes would have too many screens
@@ -2085,14 +2148,11 @@ void Screen::setFrames(FrameFocus focus)
    //
    // Since frames are basic function pointers, we have to use a helper to
    // call a method on debugInfo object.
-    fsi.positions.log = numframes;
    normalFrames[numframes++] = &Screen::drawDebugInfoTrampoline;

    // call a method on debugInfoScreen object (for more details)
-    fsi.positions.settings = numframes;
    normalFrames[numframes++] = &Screen::drawDebugInfoSettingsTrampoline;

-    fsi.positions.wifi = numframes;
 #if HAS_WIFI && !defined(ARCH_PORTDUINO)
    if (isWifiAvailable()) {
        // call a method on debugInfoScreen object (for more details)
@@ -2100,7 +2160,6 @@ void Screen::setFrames(FrameFocus focus)
    }
 #endif

-    fsi.frameCount = numframes; // Total framecount is used to apply FOCUS_PRESERVE
    LOG_DEBUG("Finished building frames. numframes: %d\n", numframes);

    ui->setFrames(normalFrames, numframes);
@@ -2114,58 +2173,20 @@ void Screen::setFrames(FrameFocus focus)
    prevFrame = -1; // Force drawNodeInfo to pick a new node (because our list
                    // just changed)

-    // Focus on a specific frame, in the frame set we just created
-    switch (focus) {
-    case FOCUS_DEFAULT:
-        ui->switchToFrame(0); // First frame
-        break;
-    case FOCUS_FAULT:
-        ui->switchToFrame(fsi.positions.fault);
-        break;
-    case FOCUS_TEXTMESSAGE:
-        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
-        ui->switchToFrame(fsi.positions.focusedModule);
-        break;
-
-    case FOCUS_PRESERVE:
-        // If we can identify which type of frame "originalPosition" was, can move directly to it in the new frameset
-        FramesetInfo &oldFsi = this->framesetInfo;
-        if (originalPosition == oldFsi.positions.log)
-            ui->switchToFrame(fsi.positions.log);
-        else if (originalPosition == oldFsi.positions.settings)
-            ui->switchToFrame(fsi.positions.settings);
-        else if (originalPosition == oldFsi.positions.wifi)
-            ui->switchToFrame(fsi.positions.wifi);
-
-        // If frame count has decreased
-        else if (fsi.frameCount < oldFsi.frameCount) {
-            uint8_t numDropped = oldFsi.frameCount - fsi.frameCount;
-            // Move n frames backwards
-            if (numDropped <= originalPosition)
-                ui->switchToFrame(originalPosition - numDropped);
-            // Unless that would put us "out of bounds" (< 0)
-            else
-                ui->switchToFrame(0);
-        }
-
-        // If we're not sure exactly which frame we were on, at least return to the same frame number
-        // (node frames; module frames)
-        else
-            ui->switchToFrame(originalPosition);
-
-        break;
-    }
-
-    // Store the info about this frameset, for future setFrames calls
-    this->framesetInfo = fsi;
-
    setFastFramerate(); // Draw ASAP
 }

+void Screen::handleStartBluetoothPinScreen(uint32_t pin)
+{
+    LOG_DEBUG("showing bluetooth screen\n");
+    showingNormalScreen = false;
+    EINK_ADD_FRAMEFLAG(dispdev, DEMAND_FAST); // E-Ink: Explicitly use fast-refresh for next frame
+
+    static FrameCallback frames[] = {drawFrameBluetooth};
+    snprintf(btPIN, sizeof(btPIN), "%06u", pin);
+    setFrameImmediateDraw(frames);
+}
+
 void Screen::setFrameImmediateDraw(FrameCallback *drawFrames)
 {
    ui->disableAllIndicators();
@@ -2173,6 +2194,41 @@ void Screen::setFrameImmediateDraw(FrameCallback *drawFrames)
    setFastFramerate();
 }

+void Screen::handleShutdownScreen()
+{
+    LOG_DEBUG("showing shutdown screen\n");
+    showingNormalScreen = false;
+#ifdef USE_EINK
+    EINK_ADD_FRAMEFLAG(dispdev, DEMAND_FAST); // Use fast-refresh for next frame, no skip please
+    EINK_ADD_FRAMEFLAG(dispdev, BLOCKING);    // Edge case: if this frame is promoted to COSMETIC, wait for update
+    handleSetOn(true);                        // Ensure power-on to receive deep-sleep screensaver (PowerFSM should handle?)
+#endif
+
+    auto frame = [](OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y) -> void {
+        drawFrameText(display, state, x, y, "Shutting down...");
+    };
+    static FrameCallback frames[] = {frame};
+
+    setFrameImmediateDraw(frames);
+}
+
+void Screen::handleRebootScreen()
+{
+    LOG_DEBUG("showing reboot screen\n");
+    showingNormalScreen = false;
+#ifdef USE_EINK
+    EINK_ADD_FRAMEFLAG(dispdev, DEMAND_FAST); // Use fast-refresh for next frame, no skip please
+    EINK_ADD_FRAMEFLAG(dispdev, BLOCKING);    // Edge case: if this frame is promoted to COSMETIC, wait for update
+    handleSetOn(true);                        // Power-on to show rebooting screen (PowerFSM should handle?)
+#endif
+
+    auto frame = [](OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y) -> void {
+        drawFrameText(display, state, x, y, "Rebooting...");
+    };
+    static FrameCallback frames[] = {frame};
+    setFrameImmediateDraw(frames);
+}
+
 void Screen::handleStartFirmwareUpdateScreen()
 {
    LOG_DEBUG("showing firmware screen\n");
@@ -2189,7 +2245,7 @@ void Screen::blink()
    uint8_t count = 10;
    dispdev->setBrightness(254);
    while (count > 0) {
-        dispdev->fillRect(0, 0, dispdev->getWidth(), dispdev->getHeight());
+        dispdev->fillRect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
        dispdev->display();
        delay(50);
        dispdev->clear();
@@ -2617,7 +2673,7 @@ int Screen::handleStatusUpdate(const meshtastic::Status *arg)
    switch (arg->getStatusType()) {
    case STATUS_TYPE_NODE:
        if (showingNormalScreen && nodeStatus->getLastNumTotal() != nodeStatus->getNumTotal()) {
-            setFrames(FOCUS_PRESERVE); // Regen the list of screen frames (returning to same frame, if possible)
+            setFrames(); // Regen the list of screens
        }
        nodeDB->updateGUI = false;
        break;
@@ -2629,33 +2685,23 @@ int Screen::handleStatusUpdate(const meshtastic::Status *arg)
 int Screen::handleTextMessage(const meshtastic_MeshPacket *packet)
 {
    if (showingNormalScreen) {
-        // Outgoing message
-        if (packet->from == 0)
-            setFrames(FOCUS_PRESERVE); // Return to same frame (quietly hiding the rx text message frame)
-
-        // Incoming message
-        else
-            setFrames(FOCUS_TEXTMESSAGE); // Focus on the new message
+        setFrames(); // Regen the list of screens (will show new text message)
    }

    return 0;
 }

-// Triggered by MeshModules
 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)
-            setFrames(FOCUS_MODULE);
-
-        // 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)
+        if (event->frameChanged) {
+            setFrames(); // Regen the list of screens (will show new text message)
+        } else if (event->needRedraw) {
            setFastFramerate();
+            // TODO: We might also want switch to corresponding frame,
+            //       but we don't know the exact frame number.
+            // ui->switchToFrame(0);
+        }
    }

    return 0;
@@ -2690,24 +2736,6 @@ int Screen::handleInputEvent(const InputEvent *event)
    return 0;
 }

-int Screen::handleAdminMessage(const meshtastic_AdminMessage *arg)
-{
-    // Note: only selected admin messages notify this observer
-    // If you wish to handle a new type of message, you should modify AdminModule.cpp first
-
-    switch (arg->which_payload_variant) {
-    // Node removed manually (i.e. via app)
-    case meshtastic_AdminMessage_remove_by_nodenum_tag:
-        setFrames(FOCUS_PRESERVE);
-        break;
-
-    // Default no-op, in case the admin message observable gets used by other classes in future
-    default:
-        break;
-    }
-    return 0;
-}
-
 } // namespace graphics
 #else
 graphics::Screen::Screen(ScanI2C::DeviceAddress, meshtastic_Config_DisplayConfig_OledType, OLEDDISPLAY_GEOMETRY) {}