Merge branch 'develop' into zps-module

.github/copilot-instructions.md

@@ -376,14 +376,14 @@ Multiple display driver families in `src/graphics/`:
 
 - **OLED**: SSD1306, SH1106, ST7567
 - **TFT**: TFTDisplay (LovyanGFX-based)
-- **E-Ink**: `src/graphics/BaseUIEInkDisplay.*` is the OLEDDisplay-compatible adapter (peer of `TFTDisplay`). The hardware layer it drives lives in `src/graphics/eink/` — chipset drivers in `Drivers/`, panel profiles in `Panels/`, optional `Backlight/`. Shared by both BaseUI-on-eink and InkHUD builds.
+- **E-Ink**: EInkDisplay2, EInkDynamicDisplay, EInkParallelDisplay
 
-**InkHUD** (`src/graphics/niche/`) is an event-driven e-ink UI framework that sits on top of the `graphics/eink/` layer:
+**InkHUD** (`src/graphics/niche/InkHUD/`) is an event-driven e-ink UI framework:
 
 - Applet-based architecture — modular display tiles
 - Read-only, static display optimized for minimal refreshes and low power
 - Configured per-variant via `nicheGraphics.h`
-- Build helpers in top-level `platformio.ini` — `[niche]` pulls `graphics/eink/` only (BaseUI path), `[inkhud]` extends it with `graphics/niche/`
+- Separate PlatformIO config: `src/graphics/niche/InkHUD/PlatformioConfig.ini`
 
 ### Input System
 

.github/prompts/new-variant.prompt.md

@@ -132,7 +132,7 @@ For e-ink display variants using the InkHUD framework, add `nicheGraphics.h`:
 // Configure display, applets, and refresh behavior per device
 ```
 
-InkHUD and the shared E-Ink layer are wired up via the top-level `platformio.ini` `[niche]` (BaseUI + driver/panel layer in `src/graphics/eink/`) and `[inkhud]` (adds the InkHUD UI in `src/graphics/niche/`). Variants opt in with `extends = ..., niche` or `extends = ..., inkhud`.
+InkHUD has its own PlatformIO config: `src/graphics/niche/InkHUD/PlatformioConfig.ini`
 
 ## I2C Device Detection
 

extra_scripts/zps_observer.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+# trunk-ignore-all(ruff/F821)
+# trunk-ignore-all(flake8/F821): For SConstruct imports
+import re
+
+Import("env")
+
+# The ZPS module scans BLE through the NimBLE *host* API ble_gap_disc(), which the
+# ESP-IDF only compiles when CONFIG_BT_NIMBLE_ROLE_OBSERVER=y. The base esp32 config
+# disables the observer role to save flash (see variants/esp32/esp32-common.ini), so
+# re-enable it ONLY when the ZPS module is actually built. This keeps a single flag
+# (-DMESHTASTIC_EXCLUDE_ZPS) driving both the C++ module and the IDF sdkconfig.
+#
+# This runs as a pre: script, before the arduino framework builder reads
+# custom_sdkconfig (PlatformIO core runs pre-scripts before $BUILD_SCRIPT). Appending
+# to custom_sdkconfig changes its hash and triggers the framework's IDF rebuild path,
+# but only for ZPS-enabled envs; for every normal build this is a no-op.
+flags = env.GetProjectOption("build_flags", "")
+if isinstance(flags, (list, tuple)):
+    flags = " ".join(flags)
+
+# Mirror the C semantics of `#if !MESHTASTIC_EXCLUDE_ZPS`:
+#   flag absent          -> module enabled
+#   -DMESHTASTIC_EXCLUDE_ZPS=0 -> module enabled
+#   -DMESHTASTIC_EXCLUDE_ZPS or =1 (or anything else) -> module excluded
+match = re.search(r"\bMESHTASTIC_EXCLUDE_ZPS\b(?:=(\S+))?", flags)
+zps_enabled = (match is None) or (match.group(1) == "0")
+
+section = "env:" + env["PIOENV"]
+config = env.GetProjectConfig()
+if zps_enabled and config.has_option(section, "custom_sdkconfig"):
+    sdkconfig = env.GetProjectOption("custom_sdkconfig")
+    if "CONFIG_BT_NIMBLE_ROLE_OBSERVER" not in sdkconfig:
+        config.set(
+            section,
+            "custom_sdkconfig",
+            sdkconfig.rstrip("\n") + "\n  CONFIG_BT_NIMBLE_ROLE_OBSERVER=y\n",
+        )
+        print("[ZPS] module enabled -> CONFIG_BT_NIMBLE_ROLE_OBSERVER=y (IDF rebuild)")

platformio.ini

@@ -8,30 +8,10 @@ extra_configs =
 	variants/*/*.ini
 	variants/*/*/platformio.ini
 	variants/*/diy/*/platformio.ini
+	src/graphics/niche/InkHUD/PlatformioConfig.ini
 
 description = Meshtastic
 
-; E-Ink / NicheGraphics build helpers.
-[niche]
-build_src_filter =
-  +<graphics/eink/>
-build_flags =
-  -D MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-
-[inkhud]
-build_src_filter =
-  ${niche.build_src_filter}
-  +<graphics/niche/>
-build_flags =
-  ${niche.build_flags}
-  -D MESHTASTIC_INCLUDE_INKHUD ; Use InkHUD as the UI
-  -D MESHTASTIC_EXCLUDE_SCREEN ; Suppress default Screen class
-  -D MESHTASTIC_EXCLUDE_INPUTBROKER ; Suppress default input handling
-  -D HAS_BUTTON=0 ; Suppress default ButtonThread
-lib_deps =
-  # renovate: datasource=github-tags depName=GFX_Root packageName=ZinggJM/GFX_Root
-  https://github.com/ZinggJM/GFX_Root/archive/3195764e352a0d2567c8d277ac408ca7293a99b0.zip ; Used by InkHUD as a "slimmer" version of AdafruitGFX
-
 [env]
 test_build_src = true
 extra_scripts =
@@ -73,6 +53,7 @@ build_flags = -Wno-missing-field-initializers
 	-DRADIOLIB_EXCLUDE_ADSB=1
 	-DRADIOLIB_EXCLUDE_LORAWAN=1
 	-DMESHTASTIC_EXCLUDE_DROPZONE=1
+	-DMESHTASTIC_EXCLUDE_ZPS=1
 	-DMESHTASTIC_EXCLUDE_REPLYBOT=1
 	-DMESHTASTIC_EXCLUDE_REMOTEHARDWARE=1
 	-DMESHTASTIC_EXCLUDE_HEALTH_TELEMETRY=1
@@ -123,7 +104,7 @@ build_unflags =
 	-std=gnu++11
 build_flags = ${env.build_flags} -Os
 	-std=gnu++17
-build_src_filter = ${env.build_src_filter} -<platform/portduino/> -<graphics/niche/> -<graphics/eink/>
+build_src_filter = ${env.build_src_filter} -<platform/portduino/> -<graphics/niche/>
 
 ; Common libs for communicating over TCP/IP networks such as MQTT
 [networking_base]

src/graphics/BaseUIEInkDisplay.cpp

@@ -1,211 +0,0 @@
-#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-
-#include "./BaseUIEInkDisplay.h"
-
-#include "configuration.h"
-#include "main.h"
-
-using namespace NicheGraphics;
-
-BaseUIEInkDisplay::BaseUIEInkDisplay(Drivers::EInk *driver, uint8_t rotation) : driver(driver), rotation(rotation & 0x3)
-{
-    this->geometry = GEOMETRY_RAWMODE;
-
-    // BaseUI draws in UI orientation. Physical panel dimensions are swapped for 90°/270°.
-    const bool swap = (this->rotation == 1) || (this->rotation == 3);
-    this->displayWidth = swap ? driver->height : driver->width;
-    this->displayHeight = swap ? driver->width : driver->height;
-
-    uint16_t shortSide = min(displayWidth, displayHeight);
-    uint16_t longSide = max(displayWidth, displayHeight);
-    if (shortSide % 8 != 0)
-        shortSide = (shortSide | 7) + 1;
-    this->displayBufferSize = longSide * (shortSide / 8);
-
-    // Panel-native row-major buffer
-    panelRowBytes = ((driver->width - 1) / 8) + 1;
-    panelBufferSize = panelRowBytes * driver->height;
-    panelBuffer = new uint8_t[panelBufferSize];
-    memset(panelBuffer, 0xFF, panelBufferSize); // All white
-}
-
-BaseUIEInkDisplay::~BaseUIEInkDisplay()
-{
-    delete[] panelBuffer;
-}
-
-bool BaseUIEInkDisplay::connect()
-{
-    LOG_INFO("Init BaseUI E-Ink (%u x %u, rot %u)", driver->width, driver->height, rotation);
-    return true;
-}
-
-void BaseUIEInkDisplay::addFrameFlag(frameFlagTypes flag)
-{
-    frameFlags = (frameFlagTypes)(frameFlags | flag);
-}
-
-void BaseUIEInkDisplay::setDisplayResilience(uint8_t fastPerFull, float stressMultiplier)
-{
-    this->fastPerFull = (fastPerFull == 0) ? 1 : fastPerFull;
-    this->stressMultiplier = stressMultiplier;
-}
-
-void BaseUIEInkDisplay::joinAsyncRefresh()
-{
-    if (driver->busy())
-        driver->await();
-}
-
-// OLEDDisplayUi tick path. Honours rate-limit unless flags demand otherwise.
-void BaseUIEInkDisplay::display()
-{
-    const bool demandFast = frameFlags & DEMAND_FAST;
-    const bool cosmetic = frameFlags & COSMETIC;
-    const bool unlimitedFast = frameFlags & UNLIMITED_FAST;
-
-    if (!demandFast && !cosmetic && !unlimitedFast) {
-        if (!forceDisplay(lastDrawMsec == 0 ? 0 : 1000))
-            return;
-        return;
-    }
-
-    forceDisplay(0);
-}
-
-// Keyframe path. Returns true if a frame was pushed (sets lastDrawMsec).
-bool BaseUIEInkDisplay::forceDisplay(uint32_t msecLimit)
-{
-    const uint32_t now = millis();
-    if (lastDrawMsec != 0 && (now - lastDrawMsec) < msecLimit)
-        return false;
-
-    const bool blocking = frameFlags & BLOCKING;
-    Drivers::EInk::UpdateTypes type = decide();
-
-    // Don't pile frames on top of a running update - wait it out.
-    if (driver->busy())
-        driver->await();
-
-    const bool pushed = commit(type, blocking);
-    if (pushed)
-        lastDrawMsec = now;
-
-    // Reset flags for next frame
-    frameFlags = BACKGROUND;
-    return pushed;
-}
-
-bool BaseUIEInkDisplay::commit(Drivers::EInk::UpdateTypes type, bool blocking)
-{
-    uint32_t hash = repack();
-
-    // Skip if frame unchanged. Exception: caller explicitly wants a refresh (COSMETIC or FULL).
-    if (hash == lastHash && type != Drivers::EInk::UpdateTypes::FULL && lastDrawMsec != 0)
-        return false;
-    lastHash = hash;
-
-    // Fall back to FULL on panels that don't advertise FAST support.
-    if (type == Drivers::EInk::UpdateTypes::FAST && !driver->supports(Drivers::EInk::UpdateTypes::FAST))
-        type = Drivers::EInk::UpdateTypes::FULL;
-
-    driver->update(panelBuffer, type);
-
-    if (blocking)
-        driver->await();
-    return true;
-}
-
-Drivers::EInk::UpdateTypes BaseUIEInkDisplay::decide()
-{
-    typedef Drivers::EInk::UpdateTypes UT;
-
-    const bool unlimitedFast = frameFlags & UNLIMITED_FAST;
-
-    // Explicit flag wins outright
-    if (frameFlags & COSMETIC) {
-        fullRefreshDebt = max(fullRefreshDebt - 1.0f, 0.0f);
-        return UT::FULL;
-    }
-    if (frameFlags & DEMAND_FAST) {
-        if (!unlimitedFast) {
-            fullRefreshDebt += (fullRefreshDebt < 1.0f) ? (1.0f / fastPerFull) : (stressMultiplier * (1.0f / fastPerFull));
-        }
-        return UT::FAST;
-    }
-
-    const bool explicitFast = frameFlags & RESPONSIVE;
-
-    if (explicitFast || unlimitedFast) {
-        if (!unlimitedFast) {
-            fullRefreshDebt += (fullRefreshDebt < 1.0f) ? (1.0f / fastPerFull) : (stressMultiplier * (1.0f / fastPerFull));
-        }
-        return UT::FAST;
-    }
-
-    // BACKGROUND / unspecified: let debt decide
-    if (fullRefreshDebt >= 1.0f) {
-        fullRefreshDebt = max(fullRefreshDebt - 1.0f, 0.0f);
-        return UT::FULL;
-    }
-    fullRefreshDebt += 1.0f / fastPerFull;
-    return UT::FAST;
-}
-
-uint32_t BaseUIEInkDisplay::repack()
-{
-    memset(panelBuffer, 0xFF, panelBufferSize); // start all-white
-
-    const uint16_t pw = driver->width;
-    const uint16_t ph = driver->height;
-
-    // OLEDDisplay buffer: byte = buffer[x + (y/8) * displayWidth]; bit = 1 << (y & 7); 1 = black
-    // Niche buffer:       byte = (y * panelRowBytes) + (x/8);      bit = 1 << (7 - x%8); 1 = white
-    for (uint16_t oy = 0; oy < displayHeight; oy++) {
-        for (uint16_t ox = 0; ox < displayWidth; ox++) {
-            const uint8_t b = buffer[ox + (oy / 8) * displayWidth];
-            const bool isBlack = b & (1 << (oy & 7));
-
-            uint16_t px, py;
-            switch (rotation) {
-            case 1: // 90° CW: OLED (ox,oy) → panel (pw-1-oy, ox)
-                px = pw - 1 - oy;
-                py = ox;
-                break;
-            case 2: // 180°
-                px = pw - 1 - ox;
-                py = ph - 1 - oy;
-                break;
-            case 3: // 270° CW
-                px = oy;
-                py = ph - 1 - ox;
-                break;
-            case 0:
-            default:
-                px = ox;
-                py = oy;
-                break;
-            }
-
-            if (px >= pw || py >= ph)
-                continue;
-
-            const uint32_t byteNum = (py * panelRowBytes) + (px / 8);
-            const uint8_t bitNum = 7 - (px % 8);
-            if (isBlack)
-                panelBuffer[byteNum] &= ~(1 << bitNum);
-            else
-                panelBuffer[byteNum] |= (1 << bitNum);
-        }
-    }
-
-    // FNV-1a
-    uint32_t h = 2166136261u;
-    for (uint32_t i = 0; i < panelBufferSize; i++) {
-        h ^= panelBuffer[i];
-        h *= 16777619u;
-    }
-    return h;
-}
-
-#endif // MESHTASTIC_INCLUDE_NICHE_GRAPHICS

src/graphics/BaseUIEInkDisplay.h

@@ -1,98 +0,0 @@
-/*
-
-OLEDDisplay adapter that routes BaseUI pixel output to a NicheGraphics::Drivers::EInk driver.
-
-One adapter serves all E-Ink variants: the panel driver and orientation are injected at construction,
-and FULL/FAST selection is made by the shared DisplayHealth model (same as InkHUD).
-
-Replaces the per-board branching in EInkDisplay2 / EInkDynamicDisplay / EInkParallelDisplay.
-
-*/
-
-#pragma once
-
-#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-
-#include "configuration.h"
-
-#include "graphics/eink/Drivers/EInk.h"
-
-#include <OLEDDisplay.h>
-
-namespace NicheGraphics
-{
-
-class BaseUIEInkDisplay : public OLEDDisplay
-{
-  public:
-    // Flags Screen.cpp sets via EINK_ADD_FRAMEFLAG before triggering a draw.
-    // Bits are combined; decided at render time.
-    enum frameFlagTypes : uint8_t {
-        BACKGROUND = (1 << 0),     // Regular OLEDDisplayUi tick - no urgency, UNSPECIFIED
-        RESPONSIVE = (1 << 1),     // User-driven refresh - prefer FAST
-        COSMETIC = (1 << 2),       // Clean splash / wake-from-sleep - force FULL
-        DEMAND_FAST = (1 << 3),    // Menu interaction - force FAST
-        BLOCKING = (1 << 4),       // Wait for update to finish before returning
-        UNLIMITED_FAST = (1 << 5), // Suppress health-driven FULL promotion (typing modes)
-    };
-
-    BaseUIEInkDisplay(Drivers::EInk *driver, uint8_t rotation);
-    ~BaseUIEInkDisplay() override;
-
-    // OLEDDisplay overrides
-    bool connect() override;
-    void display() override;
-    void sendCommand(uint8_t com) override { (void)com; }
-    int getBufferOffset(void) override { return 0; }
-
-    // BaseUI public API (same shape as the old EInkDynamicDisplay)
-    bool forceDisplay(uint32_t msecLimit = 1000);
-    void addFrameFlag(frameFlagTypes flag);
-    void joinAsyncRefresh();
-    void enableUnlimitedFastMode() { addFrameFlag(UNLIMITED_FAST); }
-    void disableUnlimitedFastMode() { frameFlags = (frameFlagTypes)(frameFlags & ~UNLIMITED_FAST); }
-
-    // Tuning, called once per panel profile
-    void setDisplayResilience(uint8_t fastPerFull, float stressMultiplier = 2.0f);
-
-    // Exposed so Screen.cpp / variants can read the rotation passed in at construction
-    uint8_t getRotation() const { return rotation; }
-
-  private:
-    // Perform an update now, unconditionally. Returns true if a frame was pushed to the driver.
-    bool commit(Drivers::EInk::UpdateTypes type, bool blocking);
-
-    // Convert OLEDDisplay's column-major buffer into the panel's row-major MSB-left buffer.
-    // Applies rotation. Returns the hash of the panel buffer for frame-skip comparison.
-    uint32_t repack();
-
-    // Decide FULL vs FAST based on current frame flags + accumulated debt.
-    Drivers::EInk::UpdateTypes decide();
-
-    Drivers::EInk *driver = nullptr;
-    uint8_t rotation = 0; // 0=0°, 1=90°CW, 2=180°, 3=270°CW
-    uint8_t *panelBuffer = nullptr;
-    uint32_t panelBufferSize = 0;
-    uint16_t panelRowBytes = 0;
-
-    frameFlagTypes frameFlags = BACKGROUND;
-    uint32_t lastDrawMsec = 0;
-    uint32_t lastHash = 0;
-
-    // DisplayHealth-style debt tracking
-    float fullRefreshDebt = 0.0f;
-    uint8_t fastPerFull = 7;
-    float stressMultiplier = 2.0f;
-};
-
-} // namespace NicheGraphics
-
-// Compat macros used throughout Screen.cpp - route straight to the adapter.
-#define EINK_ADD_FRAMEFLAG(display, flag)                                                                                        \
-    static_cast<NicheGraphics::BaseUIEInkDisplay *>(display)->addFrameFlag(NicheGraphics::BaseUIEInkDisplay::flag)
-#define EINK_JOIN_ASYNCREFRESH(display) static_cast<NicheGraphics::BaseUIEInkDisplay *>(display)->joinAsyncRefresh()
-
-#else // !MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-#define EINK_ADD_FRAMEFLAG(display, flag)
-#define EINK_JOIN_ASYNCREFRESH(display)
-#endif

src/graphics/EInkDisplay2.cpp

@@ -0,0 +1,298 @@
+#include "configuration.h"
+
+#if defined(USE_EINK) && !defined(USE_EINK_PARALLELDISPLAY)
+#include "EInkDisplay2.h"
+#include "SPILock.h"
+#include "main.h"
+#include <SPI.h>
+
+#ifdef GXEPD2_DRIVER_0
+#include "einkDetect.h"
+#endif
+
+/*
+    The macros EINK_DISPLAY_MODEL, EINK_WIDTH, and EINK_HEIGHT are defined as build_flags in a variant's platformio.ini
+    Previously, these macros were defined at the top of this file.
+
+    For archival reasons, note that the following configurations had also been tested during this period:
+    * ifdef RAK4631
+        - 4.2 inch
+          EINK_DISPLAY_MODEL: GxEPD2_420_M01
+          EINK_WIDTH: 300
+          EINK_WIDTH: 400
+
+        - 2.9 inch
+          EINK_DISPLAY_MODEL: GxEPD2_290_T5D
+          EINK_WIDTH: 296
+          EINK_HEIGHT: 128
+
+        - 1.54 inch
+          EINK_DISPLAY_MODEL: GxEPD2_154_M09
+          EINK_WIDTH: 200
+          EINK_HEIGHT: 200
+*/
+
+// Constructor
+EInkDisplay::EInkDisplay(uint8_t address, int sda, int scl, OLEDDISPLAY_GEOMETRY geometry, HW_I2C i2cBus)
+{
+    // Set dimensions in OLEDDisplay base class
+    this->geometry = GEOMETRY_RAWMODE;
+    this->displayWidth = EINK_WIDTH;
+    this->displayHeight = EINK_HEIGHT;
+
+    // Round shortest side up to nearest byte, to prevent truncation causing an undersized buffer
+    uint16_t shortSide = min(EINK_WIDTH, EINK_HEIGHT);
+    uint16_t longSide = max(EINK_WIDTH, EINK_HEIGHT);
+    if (shortSide % 8 != 0)
+        shortSide = (shortSide | 7) + 1;
+
+    this->displayBufferSize = longSide * (shortSide / 8);
+}
+
+/**
+ * Force a display update if we haven't drawn within the specified msecLimit
+ */
+bool EInkDisplay::forceDisplay(uint32_t msecLimit)
+{
+    // No need to grab this lock because we are on our own SPI bus
+    // concurrency::LockGuard g(spiLock);
+
+    uint32_t now = millis();
+    uint32_t sinceLast = now - lastDrawMsec;
+
+    if (adafruitDisplay && (sinceLast > msecLimit || lastDrawMsec == 0))
+        lastDrawMsec = now;
+    else
+        return false;
+
+    // FIXME - only draw bits have changed (use backbuf similar to the other displays)
+    const bool flipped = config.display.flip_screen;
+    // HACK for L1 EInk
+#if defined(SEEED_WIO_TRACKER_L1_EINK)
+    // For SEEED_WIO_TRACKER_L1_EINK, setRotation(3) is correct but mirrored; flip both axes
+    for (uint32_t y = 0; y < displayHeight; y++) {
+        for (uint32_t x = 0; x < displayWidth; x++) {
+            auto b = buffer[x + (y / 8) * displayWidth];
+            auto isset = b & (1 << (y & 7));
+            adafruitDisplay->drawPixel((displayWidth - 1) - x, (displayHeight - 1) - y, isset ? GxEPD_BLACK : GxEPD_WHITE);
+        }
+    }
+#else
+    for (uint32_t y = 0; y < displayHeight; y++) {
+        for (uint32_t x = 0; x < displayWidth; x++) {
+            auto b = buffer[x + (y / 8) * displayWidth];
+            auto isset = b & (1 << (y & 7));
+            if (flipped)
+                adafruitDisplay->drawPixel((displayWidth - 1) - x, (displayHeight - 1) - y, isset ? GxEPD_BLACK : GxEPD_WHITE);
+            else
+                adafruitDisplay->drawPixel(x, y, isset ? GxEPD_BLACK : GxEPD_WHITE);
+        }
+    }
+#endif
+
+    // Trigger the refresh in GxEPD2
+    LOG_DEBUG("Update E-Paper");
+    adafruitDisplay->nextPage();
+
+    // End the update process
+    endUpdate();
+
+    LOG_DEBUG("done");
+    return true;
+}
+
+// End the update process - virtual method, overridden in derived class
+void EInkDisplay::endUpdate()
+{
+#ifndef EINK_NOT_HIBERNATE
+    // By default, power off the E-Ink display hardware and enter hibernate().
+    // Boards/panels that define EINK_NOT_HIBERNATE intentionally skip this step.
+    // Skipping hibernate() can help avoid panel-specific wake/refresh or ghosting issues,
+    // but it typically trades lower power savings for that compatibility.
+    adafruitDisplay->hibernate();
+#endif
+}
+
+// Write the buffer to the display memory
+void EInkDisplay::display(void)
+{
+    // We don't allow regular 'dumb' display() calls to draw on eink until we've shown
+    // at least one forceDisplay() keyframe.  This prevents flashing when we should the critical
+    // bootscreen (that we want to look nice)
+
+    if (lastDrawMsec) {
+        forceDisplay(slowUpdateMsec); // Show the first screen a few seconds after boot, then slower
+    }
+}
+
+// Send a command to the display (low level function)
+void EInkDisplay::sendCommand(uint8_t com)
+{
+    (void)com;
+    // Drop all commands to device (we just update the buffer)
+}
+
+void EInkDisplay::setDetected(uint8_t detected)
+{
+    (void)detected;
+}
+
+// Connect to the display - variant specific
+bool EInkDisplay::connect()
+{
+    LOG_INFO("Do EInk init");
+
+#ifdef PIN_EINK_EN
+    // backlight power, HIGH is backlight on, LOW is off
+    pinMode(PIN_EINK_EN, OUTPUT);
+#ifdef ELECROW_ThinkNode_M1
+    // ThinkNode M1 has a hardware dimmable backlight. Start enabled
+    digitalWrite(PIN_EINK_EN, HIGH);
+#elif defined(MINI_EPAPER_S3)
+    // T-Mini Epaper S3 requires panel power rail enabled before SPI transfer.
+    digitalWrite(PIN_EINK_EN, HIGH);
+    delay(10);
+#else
+    digitalWrite(PIN_EINK_EN, LOW);
+#endif
+#endif
+
+#if defined(TTGO_T_ECHO) || defined(ELECROW_ThinkNode_M1) || defined(T_ECHO_LITE) || defined(TTGO_T_ECHO_PLUS)
+    {
+        auto lowLevel = new EINK_DISPLAY_MODEL(PIN_EINK_CS, PIN_EINK_DC, PIN_EINK_RES, PIN_EINK_BUSY, SPI1);
+
+        adafruitDisplay = new GxEPD2_BW<EINK_DISPLAY_MODEL, EINK_DISPLAY_MODEL::HEIGHT>(*lowLevel);
+        adafruitDisplay->init();
+#if defined(ELECROW_ThinkNode_M1) || defined(T_ECHO_LITE)
+        adafruitDisplay->setRotation(4);
+#else
+        adafruitDisplay->setRotation(3);
+#endif
+        adafruitDisplay->setPartialWindow(0, 0, displayWidth, displayHeight);
+    }
+#elif defined(ELECROW_ThinkNode_M5)
+    {
+        // Start HSPI
+        hspi = new SPIClass(HSPI);
+        hspi->begin(PIN_EINK_SCLK, -1, PIN_EINK_MOSI, PIN_EINK_CS); // SCLK, MISO, MOSI, SS
+
+        auto lowLevel = new EINK_DISPLAY_MODEL(PIN_EINK_CS, PIN_EINK_DC, PIN_EINK_RES, PIN_EINK_BUSY, *hspi);
+
+        adafruitDisplay = new GxEPD2_BW<EINK_DISPLAY_MODEL, EINK_DISPLAY_MODEL::HEIGHT>(*lowLevel);
+        adafruitDisplay->init();
+
+        adafruitDisplay->setRotation(4);
+
+        adafruitDisplay->setPartialWindow(0, 0, displayWidth, displayHeight);
+    }
+#elif defined(MESHLINK)
+    {
+        auto lowLevel = new EINK_DISPLAY_MODEL(PIN_EINK_CS, PIN_EINK_DC, PIN_EINK_RES, PIN_EINK_BUSY, SPI1);
+
+        adafruitDisplay = new GxEPD2_BW<EINK_DISPLAY_MODEL, EINK_DISPLAY_MODEL::HEIGHT>(*lowLevel);
+        adafruitDisplay->init();
+        adafruitDisplay->setRotation(3);
+        adafruitDisplay->setPartialWindow(0, 0, displayWidth, displayHeight);
+    }
+#elif defined(RAK4630) || defined(MAKERPYTHON)
+    {
+        if (eink_found) {
+            auto lowLevel = new EINK_DISPLAY_MODEL(PIN_EINK_CS, PIN_EINK_DC, PIN_EINK_RES, PIN_EINK_BUSY);
+            adafruitDisplay = new GxEPD2_BW<EINK_DISPLAY_MODEL, EINK_DISPLAY_MODEL::HEIGHT>(*lowLevel);
+            adafruitDisplay->init(115200, true, 10, false, SPI1, SPISettings(4000000, MSBFIRST, SPI_MODE0));
+            // RAK14000 2.13 inch b/w 250x122 does actually now support fast refresh
+            adafruitDisplay->setRotation(3);
+            // Fast refresh support for  1.54, 2.13 RAK14000 b/w , 2.9 and 4.2
+            // adafruitDisplay->setRotation(1);
+            adafruitDisplay->setPartialWindow(0, 0, displayWidth, displayHeight);
+        } else {
+            (void)adafruitDisplay;
+        }
+    }
+
+#elif defined(HELTEC_WIRELESS_PAPER_V1_0) || defined(HELTEC_VISION_MASTER_E290) || defined(TLORA_T3S3_EPAPER) ||                 \
+    defined(CROWPANEL_ESP32S3_5_EPAPER) || defined(CROWPANEL_ESP32S3_4_EPAPER) || defined(CROWPANEL_ESP32S3_2_EPAPER) ||         \
+    defined(MINI_EPAPER_S3)
+    {
+        // Start HSPI
+        hspi = new SPIClass(HSPI);
+        hspi->begin(PIN_EINK_SCLK, -1, PIN_EINK_MOSI, PIN_EINK_CS); // SCLK, MISO, MOSI, SS
+        // VExt already enabled in setup()
+        // RTC GPIO hold disabled in setup()
+
+        // Create GxEPD2 objects
+        auto lowLevel = new EINK_DISPLAY_MODEL(PIN_EINK_CS, PIN_EINK_DC, PIN_EINK_RES, PIN_EINK_BUSY, *hspi);
+        adafruitDisplay = new GxEPD2_BW<EINK_DISPLAY_MODEL, EINK_DISPLAY_MODEL::HEIGHT>(*lowLevel);
+
+        // Init GxEPD2
+        adafruitDisplay->init();
+#if defined(MINI_EPAPER_S3)
+        adafruitDisplay->setRotation(3);
+#else
+        adafruitDisplay->setRotation(3);
+#if defined(CROWPANEL_ESP32S3_5_EPAPER) || defined(CROWPANEL_ESP32S3_4_EPAPER)
+        adafruitDisplay->setRotation(0);
+#endif
+#endif
+    }
+#elif defined(PCA10059) || defined(ME25LS01)
+    {
+        auto lowLevel = new EINK_DISPLAY_MODEL(PIN_EINK_CS, PIN_EINK_DC, PIN_EINK_RES, PIN_EINK_BUSY);
+        adafruitDisplay = new GxEPD2_BW<EINK_DISPLAY_MODEL, EINK_DISPLAY_MODEL::HEIGHT>(*lowLevel);
+        adafruitDisplay->init(115200, true, 40, false, SPI1, SPISettings(4000000, MSBFIRST, SPI_MODE0));
+        adafruitDisplay->setRotation(0);
+        adafruitDisplay->setPartialWindow(0, 0, EINK_WIDTH, EINK_HEIGHT);
+    }
+#elif defined(M5_COREINK) || defined(T_DECK_PRO)
+    auto lowLevel = new EINK_DISPLAY_MODEL(PIN_EINK_CS, PIN_EINK_DC, PIN_EINK_RES, PIN_EINK_BUSY);
+    adafruitDisplay = new GxEPD2_BW<EINK_DISPLAY_MODEL, EINK_DISPLAY_MODEL::HEIGHT>(*lowLevel);
+    adafruitDisplay->init(115200, true, 40, false, SPI, SPISettings(4000000, MSBFIRST, SPI_MODE0));
+    adafruitDisplay->setRotation(0);
+    adafruitDisplay->setPartialWindow(0, 0, EINK_WIDTH, EINK_HEIGHT);
+#elif defined(my) || defined(ESP32_S3_PICO)
+    {
+        auto lowLevel = new EINK_DISPLAY_MODEL(PIN_EINK_CS, PIN_EINK_DC, PIN_EINK_RES, PIN_EINK_BUSY);
+        adafruitDisplay = new GxEPD2_BW<EINK_DISPLAY_MODEL, EINK_DISPLAY_MODEL::HEIGHT>(*lowLevel);
+        adafruitDisplay->init(115200, true, 40, false, SPI, SPISettings(4000000, MSBFIRST, SPI_MODE0));
+        adafruitDisplay->setRotation(1);
+        adafruitDisplay->setPartialWindow(0, 0, EINK_WIDTH, EINK_HEIGHT);
+    }
+#elif defined(HELTEC_MESH_POCKET) || defined(SEEED_WIO_TRACKER_L1_EINK) || defined(HELTEC_MESH_SOLAR_EINK)
+    {
+        spi1 = &SPI1;
+        spi1->begin();
+        // VExt already enabled in setup()
+        // RTC GPIO hold disabled in setup()
+
+        // Create GxEPD2 objects
+        auto lowLevel = new EINK_DISPLAY_MODEL(PIN_EINK_CS, PIN_EINK_DC, PIN_EINK_RES, PIN_EINK_BUSY, *spi1);
+        adafruitDisplay = new GxEPD2_BW<EINK_DISPLAY_MODEL, EINK_DISPLAY_MODEL::HEIGHT>(*lowLevel);
+
+        // Init GxEPD2
+        adafruitDisplay->init();
+        adafruitDisplay->setRotation(3);
+        adafruitDisplay->setPartialWindow(0, 0, EINK_WIDTH, EINK_HEIGHT);
+    }
+#elif defined(HELTEC_WIRELESS_PAPER) || defined(HELTEC_VISION_MASTER_E213)
+
+    // Detect display model, before starting SPI
+    EInkDetectionResult displayModel = detectEInk();
+
+    // Start HSPI
+    hspi = new SPIClass(HSPI);
+    hspi->begin(PIN_EINK_SCLK, -1, PIN_EINK_MOSI, PIN_EINK_CS); // SCLK, MISO, MOSI, SS
+
+    // Create GxEPD2 object
+    adafruitDisplay = new GxEPD2_Multi<GXEPD2_DRIVER_0, GXEPD2_DRIVER_1>((uint8_t)displayModel, PIN_EINK_CS, PIN_EINK_DC,
+                                                                         PIN_EINK_RES, PIN_EINK_BUSY, *hspi);
+
+    // Init GxEPD2
+    adafruitDisplay->init();
+    adafruitDisplay->setRotation(3);
+
+#endif
+
+    return true;
+}
+
+#endif

src/graphics/EInkDisplay2.h

@@ -0,0 +1,106 @@
+#pragma once
+
+#if defined(USE_EINK) && !defined(USE_EINK_PARALLELDISPLAY)
+
+#include "GxEPD2_BW.h"
+#include <OLEDDisplay.h>
+
+#ifdef GXEPD2_DRIVER_0 // If variant has multiple possible display models
+#include "GxEPD2Multi.h"
+#endif
+
+// Limit how often we push a full E-Ink refresh. T-Deck Pro needs faster updates for typing.
+#ifndef EINK_FORCE_DISPLAY_THROTTLE_MS
+#if defined(T_DECK_PRO)
+#define EINK_FORCE_DISPLAY_THROTTLE_MS 200
+#else
+#define EINK_FORCE_DISPLAY_THROTTLE_MS 1000
+#endif
+#endif
+
+/**
+ * An adapter class that allows using the GxEPD2 library as if it was an OLEDDisplay implementation.
+ *
+ * Note: EInkDynamicDisplay derives from this class.
+ *
+ * Remaining TODO:
+ * optimize display() to only draw changed pixels (see other OLED subclasses for examples)
+ * implement displayOn/displayOff to turn off the TFT device (and backlight)
+ * Use the fast NRF52 SPI API rather than the slow standard arduino version
+ *
+ * turn radio back on - currently with both on spi bus is fucked? or are we leaving chip select asserted?
+ * Suggestion: perhaps similar to HELTEC_WIRELESS_PAPER issue, which resolved with rtc_gpio_hold_dis()
+ */
+class EInkDisplay : public OLEDDisplay
+{
+    /// How often should we update the display
+    /// thereafter we do once per 5 minutes
+    uint32_t slowUpdateMsec = 5 * 60 * 1000;
+
+  public:
+    /* constructor
+    FIXME - the parameters are not used, just a temporary hack to keep working like the old displays
+    */
+    EInkDisplay(uint8_t, int, int, OLEDDISPLAY_GEOMETRY, HW_I2C);
+
+    // Write the buffer to the display memory (for eink we only do this occasionally)
+    virtual void display(void) override;
+
+    /**
+     * Force a display update if we haven't drawn within the specified msecLimit
+     *
+     * @return true if we did draw the screen
+     */
+    virtual bool forceDisplay(uint32_t msecLimit = EINK_FORCE_DISPLAY_THROTTLE_MS);
+
+    /**
+     * Run any code needed to complete an update, after the physical refresh has completed.
+     * Split from forceDisplay(), to enable async refresh in derived EInkDynamicDisplay class.
+     *
+     */
+    virtual void endUpdate();
+
+    /**
+     * shim to make the abstraction happy
+     *
+     */
+    void setDetected(uint8_t detected);
+
+  protected:
+    // the header size of the buffer used, e.g. for the SPI command header
+    virtual int getBufferOffset(void) override { return 0; }
+
+    // Send a command to the display (low level function)
+    virtual void sendCommand(uint8_t com) override;
+
+    // Connect to the display
+    virtual bool connect() override;
+
+#ifdef GXEPD2_DRIVER_0
+    // AdafruitGFX display object - wrapper for multiple drivers
+    // Allows runtime detection of multiple displays
+    // Avoid this situation if possible!
+    GxEPD2_Multi<GXEPD2_DRIVER_0, GXEPD2_DRIVER_1> *adafruitDisplay = NULL;
+#else
+    // AdafruitGFX display object (for single display model) - instantiated in connect(), variant specific
+    GxEPD2_BW<EINK_DISPLAY_MODEL, EINK_DISPLAY_MODEL::HEIGHT> *adafruitDisplay = NULL;
+#endif
+
+    // If display uses HSPI
+#if defined(HELTEC_WIRELESS_PAPER) || defined(HELTEC_WIRELESS_PAPER_V1_0) || defined(HELTEC_VISION_MASTER_E213) ||               \
+    defined(HELTEC_VISION_MASTER_E290) || defined(TLORA_T3S3_EPAPER) || defined(CROWPANEL_ESP32S3_5_EPAPER) ||                   \
+    defined(CROWPANEL_ESP32S3_4_EPAPER) || defined(CROWPANEL_ESP32S3_2_EPAPER) || defined(ELECROW_ThinkNode_M5) ||               \
+    defined(MINI_EPAPER_S3)
+    SPIClass *hspi = NULL;
+#endif
+
+#if defined(HELTEC_MESH_POCKET) || defined(SEEED_WIO_TRACKER_L1_EINK) || defined(HELTEC_MESH_SOLAR_EINK)
+    SPIClass *spi1 = NULL;
+#endif
+
+  private:
+    // FIXME quick hack to limit drawing to a very slow rate
+    uint32_t lastDrawMsec = 0;
+};
+
+#endif

src/graphics/EInkDynamicDisplay.cpp

@@ -0,0 +1,564 @@
+#include "Throttle.h"
+#include "configuration.h"
+
+#if defined(USE_EINK) && defined(USE_EINK_DYNAMICDISPLAY)
+#include "EInkDynamicDisplay.h"
+
+// Constructor
+EInkDynamicDisplay::EInkDynamicDisplay(uint8_t address, int sda, int scl, OLEDDISPLAY_GEOMETRY geometry, HW_I2C i2cBus)
+    : EInkDisplay(address, sda, scl, geometry, i2cBus), NotifiedWorkerThread("EInkDynamicDisplay")
+{
+    // If tracking ghost pixels, grab memory
+#ifdef EINK_LIMIT_GHOSTING_PX
+    dirtyPixels = std::unique_ptr<uint8_t[]>(new uint8_t[EInkDisplay::displayBufferSize]()); // Init with zeros
+#endif
+}
+
+// Destructor
+EInkDynamicDisplay::~EInkDynamicDisplay()
+{
+    // If we were tracking ghost pixels, free the memory
+#ifdef EINK_LIMIT_GHOSTING_PX
+    dirtyPixels = nullptr;
+#endif
+}
+
+// Screen requests a BACKGROUND frame
+void EInkDynamicDisplay::display()
+{
+    addFrameFlag(BACKGROUND);
+    update();
+}
+
+// Screen requests a RESPONSIVE frame
+bool EInkDynamicDisplay::forceDisplay(uint32_t msecLimit)
+{
+    addFrameFlag(RESPONSIVE);
+    return update(); // (Unutilized) Base class promises to return true if update ran
+}
+
+// Add flag for the next frame
+void EInkDynamicDisplay::addFrameFlag(frameFlagTypes flag)
+{
+    // OR the new flag into the existing flags
+    this->frameFlags = (frameFlagTypes)(this->frameFlags | flag);
+}
+
+// GxEPD2 code to set fast refresh
+void EInkDynamicDisplay::configForFastRefresh()
+{
+    // Variant-specific code can go here
+#if defined(PRIVATE_HW)
+#else
+    // Otherwise:
+    adafruitDisplay->setPartialWindow(0, 0, adafruitDisplay->width(), adafruitDisplay->height());
+#endif
+}
+
+// GxEPD2 code to set full refresh
+void EInkDynamicDisplay::configForFullRefresh()
+{
+    // Variant-specific code can go here
+#if defined(PRIVATE_HW)
+#else
+    // Otherwise:
+    adafruitDisplay->setFullWindow();
+#endif
+}
+
+// Run any relevant GxEPD2 code, so next update will use correct refresh type
+void EInkDynamicDisplay::applyRefreshMode()
+{
+    // Change from FULL to FAST
+    if (currentConfig == FULL && refresh == FAST) {
+        configForFastRefresh();
+        currentConfig = FAST;
+    }
+
+    // Change from FAST back to FULL
+    else if (currentConfig == FAST && refresh == FULL) {
+        configForFullRefresh();
+        currentConfig = FULL;
+    }
+}
+
+// Update fastRefreshCount
+void EInkDynamicDisplay::adjustRefreshCounters()
+{
+    if (refresh == FAST)
+        fastRefreshCount++;
+
+    else if (refresh == FULL)
+        fastRefreshCount = 0;
+}
+
+// Trigger the display update by calling base class
+bool EInkDynamicDisplay::update()
+{
+    // Determine the refresh mode to use, and start the update
+    bool refreshApproved = determineMode();
+    if (refreshApproved) {
+        EInkDisplay::forceDisplay(0); // Bypass base class' own rate-limiting system
+        storeAndReset();              // Store the result of this loop for next time. Note: call *before* endOrDetach()
+        endOrDetach();                // endUpdate() right now, or set the async refresh flag (if FULL and HAS_EINK_ASYNCFULL)
+    } else
+        storeAndReset(); // No update, no post-update code, just store the results
+
+    return refreshApproved; // (Unutilized) Base class promises to return true if update ran
+}
+
+// Figure out who runs the post-update code
+void EInkDynamicDisplay::endOrDetach()
+{
+    // If the GxEPD2 version reports that it has the async modifications
+#ifdef HAS_EINK_ASYNCFULL
+    if (previousRefresh == FULL) {
+        asyncRefreshRunning = true; // Set the flag - checked in determineMode(); cleared by onNotify()
+
+        if (previousFrameFlags & BLOCKING)
+            awaitRefresh();
+        else {
+            // Async begins
+            LOG_DEBUG("Async full-refresh begins (drop frames)");
+            notifyLater(intervalPollAsyncRefresh, DUE_POLL_ASYNCREFRESH, true); // Hand-off to NotifiedWorkerThread
+        }
+    }
+
+    // Fast Refresh
+    else if (previousRefresh == FAST)
+        EInkDisplay::endUpdate(); // Still block while updating, but EInkDisplay needs us to call endUpdate() ourselves.
+
+        // Fallback - If using an unmodified version of GxEPD2 for some reason
+#else
+    if (previousRefresh == FULL || previousRefresh == FAST) { // If refresh wasn't skipped (on unspecified..)
+        LOG_WARN(
+            "GxEPD2 version has not been modified to support async refresh; using fallback behavior. Please update lib_deps in "
+            "variant's platformio.ini file");
+        EInkDisplay::endUpdate();
+    }
+#endif
+}
+
+// Assess situation, pick a refresh type
+bool EInkDynamicDisplay::determineMode()
+{
+    checkInitialized();
+    checkForPromotion();
+#if defined(HAS_EINK_ASYNCFULL)
+    checkBusyAsyncRefresh();
+#endif
+    checkRateLimiting();
+
+    // If too soon for a new frame, or display busy, abort early
+    if (refresh == SKIPPED)
+        return false; // No refresh
+
+    // -- New frame is due --
+
+    resetRateLimiting(); // Once determineMode() ends, will have to wait again
+    hashImage();         // Generate here, so we can still copy it to previousImageHash, even if we skip the comparison check
+    LOG_DEBUG("determineMode(): "); // Begin log entry
+
+    // Once mode determined, any remaining checks will bypass
+    checkCosmetic();
+    checkDemandingFast();
+    checkFrameMatchesPrevious();
+    checkConsecutiveFastRefreshes();
+#ifdef EINK_LIMIT_GHOSTING_PX
+    checkExcessiveGhosting();
+#endif
+    checkFastRequested();
+
+    if (refresh == UNSPECIFIED)
+        LOG_WARN("There was a flaw in the determineMode() logic");
+
+    // -- Decision has been reached --
+    applyRefreshMode();
+    adjustRefreshCounters();
+
+#ifdef EINK_LIMIT_GHOSTING_PX
+    // Full refresh clears any ghosting
+    if (refresh == FULL)
+        resetGhostPixelTracking();
+#endif
+
+    // Return - call a refresh or not?
+    if (refresh == SKIPPED)
+        return false; // Don't trigger a refresh
+    else
+        return true; // Do trigger a refresh
+}
+
+// Is this the very first frame?
+void EInkDynamicDisplay::checkInitialized()
+{
+    if (!initialized) {
+        // Undo GxEPD2_BW::partialWindow(), if set by developer in EInkDisplay::connect()
+        configForFullRefresh();
+
+        // Clear any existing image, so we can draw logo with fast-refresh, but also to set GxEPD2_EPD::_initial_write
+        adafruitDisplay->clearScreen();
+
+        LOG_DEBUG("initialized, ");
+        initialized = true;
+
+        // Use a fast-refresh for the next frame; no skipping or else blank screen when waking from deep sleep
+        addFrameFlag(DEMAND_FAST);
+    }
+}
+
+// Was a frame skipped (rate, display busy) that should have been a FAST refresh?
+void EInkDynamicDisplay::checkForPromotion()
+{
+    // If a frame was skipped (rate, display busy), then promote a BACKGROUND frame
+    // Because we DID want a RESPONSIVE/COSMETIC/DEMAND_FULL frame last time, we just didn't get it
+
+    switch (previousReason) {
+    case ASYNC_REFRESH_BLOCKED_DEMANDFAST:
+        addFrameFlag(DEMAND_FAST);
+        break;
+    case ASYNC_REFRESH_BLOCKED_COSMETIC:
+        addFrameFlag(COSMETIC);
+        break;
+    case ASYNC_REFRESH_BLOCKED_RESPONSIVE:
+    case EXCEEDED_RATELIMIT_FAST:
+        addFrameFlag(RESPONSIVE);
+        break;
+    default:
+        break;
+    }
+}
+
+// Is it too soon for another frame of this type?
+void EInkDynamicDisplay::checkRateLimiting()
+{
+    // Sanity check: millis() overflow - just let the update run..
+    if (previousRunMs > millis())
+        return;
+
+    // Skip update: too soon for BACKGROUND
+    if (frameFlags == BACKGROUND) {
+        if (Throttle::isWithinTimespanMs(previousRunMs, 30000)) {
+            refresh = SKIPPED;
+            reason = EXCEEDED_RATELIMIT_FULL;
+            return;
+        }
+    }
+
+    // No rate-limit for these special cases
+    if (frameFlags & COSMETIC || frameFlags & DEMAND_FAST)
+        return;
+
+    // Skip update: too soon for RESPONSIVE
+    if (frameFlags & RESPONSIVE) {
+        if (Throttle::isWithinTimespanMs(previousRunMs, 1000)) {
+            refresh = SKIPPED;
+            reason = EXCEEDED_RATELIMIT_FAST;
+            LOG_DEBUG("refresh=SKIPPED, reason=EXCEEDED_RATELIMIT_FAST, frameFlags=0x%x", frameFlags);
+            return;
+        }
+    }
+}
+
+// Is this frame COSMETIC (splash screens?)
+void EInkDynamicDisplay::checkCosmetic()
+{
+    // If a decision was already reached, don't run the check
+    if (refresh != UNSPECIFIED)
+        return;
+
+    // A full refresh is requested for cosmetic purposes: we have a decision
+    if (frameFlags & COSMETIC) {
+        refresh = FULL;
+        reason = FLAGGED_COSMETIC;
+        LOG_DEBUG("refresh=FULL, reason=FLAGGED_COSMETIC, frameFlags=0x%x", frameFlags);
+    }
+}
+
+// Is this a one-off special circumstance, where we REALLY want a fast refresh?
+void EInkDynamicDisplay::checkDemandingFast()
+{
+    // If a decision was already reached, don't run the check
+    if (refresh != UNSPECIFIED)
+        return;
+
+    // A fast refresh is demanded: we have a decision
+    if (frameFlags & DEMAND_FAST) {
+        refresh = FAST;
+        reason = FLAGGED_DEMAND_FAST;
+        LOG_DEBUG("refresh=FAST, reason=FLAGGED_DEMAND_FAST, frameFlags=0x%x", frameFlags);
+    }
+}
+
+// Does the new frame match the currently displayed image?
+void EInkDynamicDisplay::checkFrameMatchesPrevious()
+{
+    // If a decision was already reached, don't run the check
+    if (refresh != UNSPECIFIED)
+        return;
+
+    // If frame is *not* a duplicate, abort the check
+    if (imageHash != previousImageHash)
+        return;
+
+#if !defined(EINK_BACKGROUND_USES_FAST)
+    // If BACKGROUND, and last update was FAST: redraw the same image in FULL (for display health + image quality)
+    if (frameFlags == BACKGROUND && fastRefreshCount > 0) {
+        refresh = FULL;
+        reason = REDRAW_WITH_FULL;
+        LOG_DEBUG("refresh=FULL, reason=REDRAW_WITH_FULL, frameFlags=0x%x", frameFlags);
+        return;
+    }
+#endif
+
+    // Not redrawn, not COSMETIC, not DEMAND_FAST
+    refresh = SKIPPED;
+    reason = FRAME_MATCHED_PREVIOUS;
+    LOG_DEBUG("refresh=SKIPPED, reason=FRAME_MATCHED_PREVIOUS, frameFlags=0x%x", frameFlags);
+}
+
+// Have too many fast-refreshes occurred consecutively, since last full refresh?
+void EInkDynamicDisplay::checkConsecutiveFastRefreshes()
+{
+    // If a decision was already reached, don't run the check
+    if (refresh != UNSPECIFIED)
+        return;
+
+    // Bypass limit if UNLIMITED_FAST mode is active
+    if (frameFlags & UNLIMITED_FAST) {
+        refresh = FAST;
+        reason = NO_OBJECTIONS;
+        LOG_DEBUG("refresh=FAST, reason=UNLIMITED_FAST_MODE_ACTIVE, frameFlags=0x%x", frameFlags);
+        return;
+    }
+
+    // If too many FAST refreshes consecutively - force a FULL refresh
+    if (fastRefreshCount >= EINK_LIMIT_FASTREFRESH) {
+        refresh = FULL;
+        reason = EXCEEDED_LIMIT_FASTREFRESH;
+        LOG_DEBUG("refresh=FULL, reason=EXCEEDED_LIMIT_FASTREFRESH, frameFlags=0x%x", frameFlags);
+    }
+}
+
+// No objections, we can perform fast-refresh, if desired
+void EInkDynamicDisplay::checkFastRequested()
+{
+    if (refresh != UNSPECIFIED)
+        return;
+
+    if (frameFlags == BACKGROUND) {
+#ifdef EINK_BACKGROUND_USES_FAST
+        // If we want BACKGROUND to use fast. (FULL only when a limit is hit)
+        refresh = FAST;
+        reason = BACKGROUND_USES_FAST;
+        LOG_DEBUG("refresh=FAST, reason=BACKGROUND_USES_FAST, fastRefreshCount=%lu, frameFlags=0x%x", fastRefreshCount,
+                  frameFlags);
+#else
+        // If we do want to use FULL for BACKGROUND updates
+        refresh = FULL;
+        reason = FLAGGED_BACKGROUND;
+        LOG_DEBUG("refresh=FULL, reason=FLAGGED_BACKGROUND");
+#endif
+    }
+
+    // Sanity: confirm that we did ask for a RESPONSIVE frame.
+    if (frameFlags & RESPONSIVE) {
+        refresh = FAST;
+        reason = NO_OBJECTIONS;
+        LOG_DEBUG("refresh=FAST, reason=NO_OBJECTIONS, fastRefreshCount=%lu, frameFlags=0x%x", fastRefreshCount, frameFlags);
+    }
+}
+
+// Reset the timer used for rate-limiting
+void EInkDynamicDisplay::resetRateLimiting()
+{
+    previousRunMs = millis();
+}
+
+// Generate a hash of this frame, to compare against previous update
+void EInkDynamicDisplay::hashImage()
+{
+    imageHash = 0;
+
+    // Sum all bytes of the image buffer together
+    for (uint16_t b = 0; b < (displayWidth / 8) * displayHeight; b++) {
+        imageHash ^= buffer[b] << b;
+    }
+}
+
+// Store the results of determineMode() for future use, and reset for next call
+void EInkDynamicDisplay::storeAndReset()
+{
+    previousFrameFlags = frameFlags;
+    previousRefresh = refresh;
+    previousReason = reason;
+
+    // Only store image hash if the display will update
+    if (refresh != SKIPPED) {
+        previousImageHash = imageHash;
+    }
+
+    frameFlags = BACKGROUND;
+    refresh = UNSPECIFIED;
+}
+
+#ifdef EINK_LIMIT_GHOSTING_PX
+// Count how many ghost pixels the new image will display
+void EInkDynamicDisplay::countGhostPixels()
+{
+    // If a decision was already reached, don't run the check
+    if (refresh != UNSPECIFIED)
+        return;
+
+    // Start a new count
+    ghostPixelCount = 0;
+
+    // Check new image, bit by bit, for any white pixels at locations marked "dirty"
+    for (uint16_t i = 0; i < displayBufferSize; i++) {
+        for (uint8_t bit = 0; bit < 7; bit++) {
+
+            const bool dirty = (dirtyPixels[i] >> bit) & 1;       // Has pixel location been drawn to since full-refresh?
+            const bool shouldBeBlank = !((buffer[i] >> bit) & 1); // Is pixel location white in the new image?
+
+            // If pixel is (or has been) black since last full-refresh, and now is white: ghosting
+            if (dirty && shouldBeBlank)
+                ghostPixelCount++;
+
+            // Update the dirty status for this pixel - will this location become a ghost if set white in future?
+            if (!dirty && !shouldBeBlank)
+                dirtyPixels[i] |= (1 << bit);
+        }
+    }
+
+    LOG_DEBUG("ghostPixels=%hu, ", ghostPixelCount);
+}
+
+// Check if ghost pixel count exceeds the defined limit
+void EInkDynamicDisplay::checkExcessiveGhosting()
+{
+    // If a decision was already reached, don't run the check
+    if (refresh != UNSPECIFIED)
+        return;
+
+    countGhostPixels();
+
+    // If too many ghost pixels, select full refresh
+    if (ghostPixelCount > EINK_LIMIT_GHOSTING_PX) {
+        refresh = FULL;
+        reason = EXCEEDED_GHOSTINGLIMIT;
+        LOG_DEBUG("refresh=FULL, reason=EXCEEDED_GHOSTINGLIMIT, frameFlags=0x%x", frameFlags);
+    }
+}
+
+// Clear the dirty pixels array. Call when full-refresh cleans the display.
+void EInkDynamicDisplay::resetGhostPixelTracking()
+{
+    // Copy the current frame into dirtyPixels[] from the display buffer
+    memcpy(dirtyPixels.get(), EInkDisplay::buffer, EInkDisplay::displayBufferSize);
+}
+#endif // EINK_LIMIT_GHOSTING_PX
+
+// Handle any asyc tasks
+void EInkDynamicDisplay::onNotify(uint32_t notification)
+{
+    // Which task
+    switch (notification) {
+    case DUE_POLL_ASYNCREFRESH:
+        pollAsyncRefresh();
+        break;
+    }
+}
+
+#ifdef HAS_EINK_ASYNCFULL
+// Public: wait for an refresh already in progress, then run the post-update code. See Screen::setScreensaverFrames()
+void EInkDynamicDisplay::joinAsyncRefresh()
+{
+    // If no async refresh running, nothing to do
+    if (!asyncRefreshRunning)
+        return;
+
+    LOG_DEBUG("Join an async refresh in progress");
+
+    // Continually poll the BUSY pin
+    while (adafruitDisplay->epd2.isBusy())
+        yield();
+
+    // If asyncRefreshRunning flag is still set, but display's BUSY pin reports the refresh is done
+    adafruitDisplay->endAsyncFull(); // Run the end of nextPage() code
+    EInkDisplay::endUpdate();        // Run base-class code to finish off update (NOT our derived class override)
+    asyncRefreshRunning = false;     // Unset the flag
+    LOG_DEBUG("Refresh complete");
+
+    // Note: this code only works because of a modification to meshtastic/GxEPD2.
+    // It is only equipped to intercept calls to nextPage()
+}
+
+// Called from NotifiedWorkerThread. Run the post-update code if the hardware is ready
+void EInkDynamicDisplay::pollAsyncRefresh()
+{
+    // In theory, this condition should never be met
+    if (!asyncRefreshRunning)
+        return;
+
+    // Still running, check back later
+    if (adafruitDisplay->epd2.isBusy()) {
+        // Schedule next call of pollAsyncRefresh()
+        NotifiedWorkerThread::notifyLater(intervalPollAsyncRefresh, DUE_POLL_ASYNCREFRESH, true);
+        return;
+    }
+
+    // If asyncRefreshRunning flag is still set, but display's BUSY pin reports the refresh is done
+    adafruitDisplay->endAsyncFull(); // Run the end of nextPage() code
+    EInkDisplay::endUpdate();        // Run base-class code to finish off update (NOT our derived class override)
+    asyncRefreshRunning = false;     // Unset the flag
+    LOG_DEBUG("Async full-refresh complete");
+
+    // Note: this code only works because of a modification to meshtastic/GxEPD2.
+    // It is only equipped to intercept calls to nextPage()
+}
+
+// Check the status of "async full-refresh"; skip if running
+void EInkDynamicDisplay::checkBusyAsyncRefresh()
+{
+    // No refresh taking place, continue with determineMode()
+    if (!asyncRefreshRunning)
+        return;
+
+    // Full refresh still running
+    if (adafruitDisplay->epd2.isBusy()) {
+        // No refresh
+        refresh = SKIPPED;
+
+        // Set the reason, marking what type of frame we're skipping
+        if (frameFlags & DEMAND_FAST)
+            reason = ASYNC_REFRESH_BLOCKED_DEMANDFAST;
+        else if (frameFlags & COSMETIC)
+            reason = ASYNC_REFRESH_BLOCKED_COSMETIC;
+        else if (frameFlags & RESPONSIVE)
+            reason = ASYNC_REFRESH_BLOCKED_RESPONSIVE;
+        else
+            reason = ASYNC_REFRESH_BLOCKED_BACKGROUND;
+
+        return;
+    }
+
+    // Async refresh appears to have stopped, but wasn't caught by onNotify()
+    else
+        pollAsyncRefresh(); // Check (and terminate) the async refresh manually
+}
+
+// Hold control while an async refresh runs
+void EInkDynamicDisplay::awaitRefresh()
+{
+    // Continually poll the BUSY pin
+    while (adafruitDisplay->epd2.isBusy())
+        yield();
+
+    // End the full-refresh process
+    adafruitDisplay->endAsyncFull(); // Run the end of nextPage() code
+    EInkDisplay::endUpdate();        // Run base-class code to finish off update (NOT our derived class override)
+    asyncRefreshRunning = false;     // Unset the flag
+}
+#endif // HAS_EINK_ASYNCFULL
+
+#endif // USE_EINK_DYNAMICDISPLAY

src/graphics/EInkDynamicDisplay.h

@@ -0,0 +1,155 @@
+#pragma once
+
+#include "configuration.h"
+#include <memory>
+
+#if defined(USE_EINK) && defined(USE_EINK_DYNAMICDISPLAY)
+
+#include "EInkDisplay2.h"
+#include "GxEPD2_BW.h"
+#include "concurrency/NotifiedWorkerThread.h"
+
+/*
+    Derives from the EInkDisplay adapter class.
+    Accepts suggestions from Screen class about frame type.
+    Determines which refresh type is most suitable.
+    (Full, Fast, Skip)
+*/
+
+class EInkDynamicDisplay : public EInkDisplay, protected concurrency::NotifiedWorkerThread
+{
+  public:
+    // Constructor
+    // ( Parameters unused, passed to EInkDisplay. Maintains compatibility OLEDDisplay class )
+    EInkDynamicDisplay(uint8_t address, int sda, int scl, OLEDDISPLAY_GEOMETRY geometry, HW_I2C i2cBus);
+    ~EInkDynamicDisplay();
+
+    // Methods to enable or disable unlimited fast refresh mode
+    void enableUnlimitedFastMode() { addFrameFlag(UNLIMITED_FAST); }
+    void disableUnlimitedFastMode() { frameFlags = (frameFlagTypes)(frameFlags & ~UNLIMITED_FAST); }
+
+    // What kind of frame is this
+    enum frameFlagTypes : uint8_t {
+        BACKGROUND = (1 << 0),  // For frames via display()
+        RESPONSIVE = (1 << 1),  // For frames via forceDisplay()
+        COSMETIC = (1 << 2),    // For splashes
+        DEMAND_FAST = (1 << 3), // Special case only
+        BLOCKING = (1 << 4),    // Modifier - block while refresh runs
+        UNLIMITED_FAST = (1 << 5)
+    };
+    void addFrameFlag(frameFlagTypes flag);
+
+    // Set the correct frame flag, then call universal "update()" method
+    void display() override;
+    bool forceDisplay(uint32_t msecLimit) override; // Shadows base class. Parameter and return val unused.
+
+  protected:
+    enum refreshTypes : uint8_t { // Which refresh operation will be used
+        UNSPECIFIED,
+        FULL,
+        FAST,
+        SKIPPED,
+    };
+    enum reasonTypes : uint8_t { // How was the decision reached
+        NO_OBJECTIONS,
+        ASYNC_REFRESH_BLOCKED_DEMANDFAST,
+        ASYNC_REFRESH_BLOCKED_COSMETIC,
+        ASYNC_REFRESH_BLOCKED_RESPONSIVE,
+        ASYNC_REFRESH_BLOCKED_BACKGROUND,
+        EXCEEDED_RATELIMIT_FAST,
+        EXCEEDED_RATELIMIT_FULL,
+        FLAGGED_COSMETIC,
+        FLAGGED_DEMAND_FAST,
+        EXCEEDED_LIMIT_FASTREFRESH,
+        EXCEEDED_GHOSTINGLIMIT,
+        FRAME_MATCHED_PREVIOUS,
+        BACKGROUND_USES_FAST,
+        FLAGGED_BACKGROUND,
+        REDRAW_WITH_FULL,
+    };
+
+    enum notificationTypes : uint8_t { // What was onNotify() called for
+        NONE = 0,                      // This behavior (NONE=0) is fixed by NotifiedWorkerThread class
+        DUE_POLL_ASYNCREFRESH = 1,
+    };
+    const uint32_t intervalPollAsyncRefresh = 100;
+
+    void onNotify(uint32_t notification) override; // Handle any async tasks - overrides NotifiedWorkerThread
+    void configForFastRefresh();                   // GxEPD2 code to set fast-refresh
+    void configForFullRefresh();                   // GxEPD2 code to set full-refresh
+    bool determineMode();                          // Assess situation, pick a refresh type
+    void applyRefreshMode();                       // Run any relevant GxEPD2 code, so next update will use correct refresh type
+    void adjustRefreshCounters();                  // Update fastRefreshCount
+    bool update();                                 // Trigger the display update - determine mode, then call base class
+    void endOrDetach();                            // Run the post-update code, or delegate it off to checkBusyAsyncRefresh()
+
+    // Checks as part of determineMode()
+    void checkInitialized();              // Is this the very first frame?
+    void checkForPromotion();             // Was a frame skipped (rate, display busy) that should have been a FAST refresh?
+    void checkRateLimiting();             // Is this frame too soon?
+    void checkCosmetic();                 // Was the COSMETIC flag set?
+    void checkDemandingFast();            // Was the DEMAND_FAST flag set?
+    void checkFrameMatchesPrevious();     // Does the new frame match the existing display image?
+    void checkConsecutiveFastRefreshes(); // Too many fast-refreshes consecutively?
+    void checkFastRequested();            // Was the flag set for RESPONSIVE, or only BACKGROUND?
+
+    void resetRateLimiting(); // Set previousRunMs - this now counts as an update, for rate-limiting
+    void hashImage();         // Generate a hashed version of this frame, to compare against previous update
+    void storeAndReset();     // Keep results of determineMode() for later, tidy-up for next call
+
+    // What we are determining for this frame
+    frameFlagTypes frameFlags = BACKGROUND; // Frame characteristics - determineMode() input
+    refreshTypes refresh = UNSPECIFIED;     // Refresh type - determineMode() output
+    reasonTypes reason = NO_OBJECTIONS;     // Reason - why was refresh type used
+
+    // What happened last time determineMode() ran
+    frameFlagTypes previousFrameFlags = BACKGROUND; // (Previous) Frame flags
+    refreshTypes previousRefresh = UNSPECIFIED;     // (Previous) Outcome
+    reasonTypes previousReason = NO_OBJECTIONS;     // (Previous) Reason
+
+    bool initialized = false;          // Have we drawn at least one frame yet?
+    uint32_t previousRunMs = -1;       // When did determineMode() last run (rather than rejecting for rate-limiting)
+    uint32_t imageHash = 0;            // Hash of the current frame. Don't bother updating if nothing has changed!
+    uint32_t previousImageHash = 0;    // Hash of the previous update's frame
+    uint32_t fastRefreshCount = 0;     // How many fast-refreshes consecutively since last full refresh?
+    refreshTypes currentConfig = FULL; // Which refresh type is GxEPD2 currently configured for
+
+    // Optional - track ghosting, pixel by pixel
+    // May 2024: no longer used by any display. Kept for possible future use.
+#ifdef EINK_LIMIT_GHOSTING_PX
+    void countGhostPixels();                // Count any pixels which have moved from black to white since last full-refresh
+    void checkExcessiveGhosting();          // Check if ghosting exceeds defined limit
+    void resetGhostPixelTracking();         // Clear the dirty pixels array. Call when full-refresh cleans the display.
+    std::unique_ptr<uint8_t[]> dirtyPixels; // Any pixels that have been black since last full-refresh (dynamically allocated mem)
+    uint32_t ghostPixelCount = 0;           // Number of pixels with problematic ghosting. Retained here for LOG_DEBUG use
+#endif
+
+    // Conditional - async full refresh - only with modified meshtastic/GxEPD2
+#if defined(HAS_EINK_ASYNCFULL)
+  public:
+    void joinAsyncRefresh(); // Main thread joins an async refresh already in progress. Blocks, then runs post-update code
+
+  protected:
+    void pollAsyncRefresh();          // Run the post-update code if the hardware is ready
+    void checkBusyAsyncRefresh();     // Check if display is busy running an async full-refresh (rejecting new frames)
+    void awaitRefresh();              // Hold control while an async refresh runs
+    void endUpdate() override {}      // Disable base-class behavior of running post-update immediately after forceDisplay()
+    bool asyncRefreshRunning = false; // Flag, checked by checkBusyAsyncRefresh()
+#else
+  public:
+    void joinAsyncRefresh() {} // Dummy method
+
+  protected:
+    void pollAsyncRefresh() {} // Dummy method. In theory, not reachable
+#endif
+};
+
+// Hide the ugly casts used in Screen.cpp
+#define EINK_ADD_FRAMEFLAG(display, flag) static_cast<EInkDynamicDisplay *>(display)->addFrameFlag(EInkDynamicDisplay::flag)
+#define EINK_JOIN_ASYNCREFRESH(display) static_cast<EInkDynamicDisplay *>(display)->joinAsyncRefresh()
+
+#else // !USE_EINK_DYNAMICDISPLAY
+// Dummy-macro, removes the need for include guards
+#define EINK_ADD_FRAMEFLAG(display, flag)
+#define EINK_JOIN_ASYNCREFRESH(display)
+#endif

src/graphics/EInkParallelDisplay.cpp

@@ -0,0 +1,427 @@
+#include "EInkParallelDisplay.h"
+
+#ifdef USE_EINK_PARALLELDISPLAY
+
+#include "Wire.h"
+#include "variant.h"
+#include <Arduino.h>
+#include <atomic>
+#include <stdlib.h>
+#include <string.h>
+
+#include "FastEPD.h"
+
+// Thresholds for choosing partial vs full update
+#ifndef EPD_PARTIAL_THRESHOLD_ROWS
+#define EPD_PARTIAL_THRESHOLD_ROWS 128 // if changed region <= this many rows, prefer partial
+#endif
+#ifndef EPD_FULLSLOW_PERIOD
+#define EPD_FULLSLOW_PERIOD 100 // every N full updates do a slow (CLEAR_SLOW) full refresh
+#endif
+#ifndef EPD_RESPONSIVE_MIN_MS
+#define EPD_RESPONSIVE_MIN_MS 1000 // simple rate-limit (ms) for responsive updates
+#endif
+
+EInkParallelDisplay::EInkParallelDisplay(uint16_t width, uint16_t height, EpdRotation rot) : epaper(nullptr), rotation(rot)
+{
+    LOG_INFO("init EInkParallelDisplay");
+    // Set dimensions in OLEDDisplay base class
+    this->geometry = GEOMETRY_RAWMODE;
+    this->displayWidth = width;
+    this->displayHeight = height;
+
+    // Round shortest side up to nearest byte, to prevent truncation causing an undersized buffer
+    uint16_t shortSide = min(width, height);
+    uint16_t longSide = max(width, height);
+    if (shortSide % 8 != 0)
+        shortSide = (shortSide | 7) + 1;
+
+    this->displayBufferSize = longSide * (shortSide / 8);
+
+#ifdef EINK_LIMIT_GHOSTING_PX
+    // allocate dirty pixel buffer same size as epaper buffers (rowBytes * height)
+    size_t rowBytes = (this->displayWidth + 7) / 8;
+    dirtyPixelsSize = rowBytes * this->displayHeight;
+    dirtyPixels = (uint8_t *)calloc(dirtyPixelsSize, 1);
+    ghostPixelCount = 0;
+#endif
+}
+
+EInkParallelDisplay::~EInkParallelDisplay()
+{
+#ifdef EINK_LIMIT_GHOSTING_PX
+    if (dirtyPixels) {
+        free(dirtyPixels);
+        dirtyPixels = nullptr;
+    }
+#endif
+    // If an async full update is running, wait for it to finish
+    if (asyncFullRunning.load()) {
+        // wait a short while for task to finish
+        for (int i = 0; i < 50 && asyncFullRunning.load(); ++i) {
+            delay(50);
+        }
+        if (asyncTaskHandle) {
+            // Let it finish or delete it
+            vTaskDelete(asyncTaskHandle);
+            asyncTaskHandle = nullptr;
+        }
+    }
+
+    delete epaper;
+}
+
+/*
+ * Called by the OLEDDisplay::init() path.
+ */
+bool EInkParallelDisplay::connect()
+{
+    LOG_INFO("Do EPD init");
+    if (!epaper) {
+        epaper = new FASTEPD;
+#if defined(T5_S3_EPAPER_PRO_V1)
+        epaper->initPanel(BB_PANEL_LILYGO_T5PRO, 28000000);
+#elif defined(T5_S3_EPAPER_PRO_V2)
+        epaper->initPanel(BB_PANEL_LILYGO_T5PRO_V2, 28000000);
+        // initialize all port 0 pins (0-7) as outputs / HIGH
+        for (int i = 0; i < 8; i++) {
+            epaper->ioPinMode(i, OUTPUT);
+            epaper->ioWrite(i, HIGH);
+        }
+#else
+#error "unsupported EPD device!"
+#endif
+    }
+
+    // epaper->setRotation(rotation); // does not work, messes up width/height
+    epaper->setMode(BB_MODE_1BPP);
+    epaper->clearWhite();
+    epaper->fullUpdate(true);
+
+#ifdef EINK_LIMIT_GHOSTING_PX
+    // After a full/clear the dirty tracking should be reset
+    resetGhostPixelTracking();
+#endif
+
+    return true;
+}
+
+/*
+ * sendCommand - simple passthrough (not required for epd_driver-based path)
+ */
+void EInkParallelDisplay::sendCommand(uint8_t com)
+{
+    LOG_DEBUG("EInkParallelDisplay::sendCommand %d", (int)com);
+}
+
+/*
+ * Start a background task that will perform a blocking fullUpdate(). This lets
+ * display() return quickly while the heavy refresh runs in the background.
+ */
+void EInkParallelDisplay::startAsyncFullUpdate(int clearMode)
+{
+    if (asyncFullRunning.load())
+        return; // already running
+
+    asyncFullRunning.store(true);
+    // pass 'this' as parameter
+    BaseType_t rc = xTaskCreatePinnedToCore(EInkParallelDisplay::asyncFullUpdateTask, "epd_full", 4096 / sizeof(StackType_t),
+                                            this, 2, &asyncTaskHandle,
+#if CONFIG_FREERTOS_UNICORE
+                                            0
+#else
+                                            1
+#endif
+    );
+    if (rc != pdPASS) {
+        LOG_WARN("Failed to create async full-update task, falling back to blocking update");
+        epaper->fullUpdate(clearMode, false);
+        epaper->backupPlane();
+        asyncFullRunning.store(false);
+        asyncTaskHandle = nullptr;
+    }
+}
+
+/*
+ * FreeRTOS task entry: runs the full update and then backs up plane.
+ */
+void EInkParallelDisplay::asyncFullUpdateTask(void *pvParameters)
+{
+    EInkParallelDisplay *self = static_cast<EInkParallelDisplay *>(pvParameters);
+    if (!self) {
+        vTaskDelete(nullptr);
+        return;
+    }
+
+    // choose CLEAR_SLOW occasionally
+    int clearMode = CLEAR_FAST;
+    if (self->fastRefreshCount >= EPD_FULLSLOW_PERIOD) {
+        clearMode = CLEAR_SLOW;
+        self->fastRefreshCount = 0;
+    } else {
+        // when running async full, treat it as a full so reset fast count
+        self->fastRefreshCount = 0;
+    }
+
+    self->epaper->fullUpdate(clearMode, false);
+    self->epaper->backupPlane();
+
+#ifdef EINK_LIMIT_GHOSTING_PX
+    // A full refresh clears ghosting state
+    self->resetGhostPixelTracking();
+#endif
+
+    self->asyncFullRunning.store(false);
+    self->asyncTaskHandle = nullptr;
+
+    // delete this task
+    vTaskDelete(nullptr);
+}
+
+/*
+ * Convert the OLEDDisplay buffer (vertical byte layout) into the 1bpp horizontal-bytes
+ * buffer used by the FASTEPD library. For performance we write directly into FASTEPD's
+ * currentBuffer() while comparing against previousBuffer() to detect changed rows.
+ * After conversion we call FASTEPD::partialUpdate() or FASTEPD::fullUpdate() according
+ * to a heuristic so only the minimal region is refreshed.
+ */
+void EInkParallelDisplay::display(void)
+{
+    const uint16_t w = this->displayWidth;
+    const uint16_t h = this->displayHeight;
+
+    // Simple rate limiting: avoid very-frequent responsive updates
+    uint32_t nowMs = millis();
+    if (lastUpdateMs != 0 && (nowMs - lastUpdateMs) < EPD_RESPONSIVE_MIN_MS) {
+        LOG_DEBUG("rate-limited, skipping update");
+        return;
+    }
+
+    // bytes per row in epd format (one byte = 8 horizontal pixels)
+    const uint32_t rowBytes = (w + 7) / 8;
+
+    // Get pointers to internal buffers
+    uint8_t *cur = epaper->currentBuffer();
+    const uint8_t *prev = epaper->previousBuffer(); // may be NULL on first init
+
+    // Track changed row range while converting
+    int newTop = h;     // min changed row (initialized to out-of-range)
+    int newBottom = -1; // max changed row
+
+#ifdef FAST_EPD_PARTIAL_UPDATE_BUG
+    // Track changed byte column range (for clipped fullUpdate fallback)
+    int newLeftByte = (int)rowBytes;
+    int newRightByte = -1;
+#endif
+
+    // Compute a quick hash of the incoming OLED buffer (so we can skip identical frames)
+    uint32_t imageHash = 0;
+    uint32_t bufBytes = (w / 8) * h; // vertical-byte layout size
+    for (uint32_t bi = 0; bi < bufBytes; ++bi) {
+        imageHash ^= ((uint32_t)buffer[bi]) << (bi & 31);
+    }
+    if (imageHash == previousImageHash) {
+        // LOG_DEBUG("image identical to previous, skipping update");
+        return;
+    }
+
+#ifdef EINK_LIMIT_GHOSTING_PX
+    // reset ghost count for this conversion pass; we'll mark bits that change
+    ghostPixelCount = 0;
+#endif
+
+    // Convert: OLED buffer layout -> FASTEPD 1bpp horizontal-bytes layout into cur,
+    // comparing against prev when available to detect changes.
+    for (uint32_t y = 0; y < h; ++y) {
+        const uint32_t base = (y >> 3) * w;               // (y/8) * width
+        const uint8_t bitMask = (uint8_t)(1u << (y & 7)); // mask for this row in vertical-byte layout
+        const uint32_t rowBase = y * rowBytes;
+
+        // process full 8-pixel bytes
+        for (uint32_t xb = 0; xb < rowBytes; ++xb) {
+            uint32_t x0 = xb * 8;
+            // read up to 8 source bytes (vertical-byte per column)
+            uint8_t b0 = (x0 + 0 < w) ? buffer[base + x0 + 0] : 0;
+            uint8_t b1 = (x0 + 1 < w) ? buffer[base + x0 + 1] : 0;
+            uint8_t b2 = (x0 + 2 < w) ? buffer[base + x0 + 2] : 0;
+            uint8_t b3 = (x0 + 3 < w) ? buffer[base + x0 + 3] : 0;
+            uint8_t b4 = (x0 + 4 < w) ? buffer[base + x0 + 4] : 0;
+            uint8_t b5 = (x0 + 5 < w) ? buffer[base + x0 + 5] : 0;
+            uint8_t b6 = (x0 + 6 < w) ? buffer[base + x0 + 6] : 0;
+            uint8_t b7 = (x0 + 7 < w) ? buffer[base + x0 + 7] : 0;
+
+            // build output byte: MSB = leftmost pixel
+            uint8_t out = 0;
+            out |= (uint8_t)((b0 & bitMask) ? 0x80 : 0x00);
+            out |= (uint8_t)((b1 & bitMask) ? 0x40 : 0x00);
+            out |= (uint8_t)((b2 & bitMask) ? 0x20 : 0x00);
+            out |= (uint8_t)((b3 & bitMask) ? 0x10 : 0x00);
+            out |= (uint8_t)((b4 & bitMask) ? 0x08 : 0x00);
+            out |= (uint8_t)((b5 & bitMask) ? 0x04 : 0x00);
+            out |= (uint8_t)((b6 & bitMask) ? 0x02 : 0x00);
+            out |= (uint8_t)((b7 & bitMask) ? 0x01 : 0x00);
+
+            // handle partial byte at end of row by masking off invalid bits
+            uint8_t mask = 0xFF;
+            uint32_t bitsRemain = (w > x0) ? (w - x0) : 0;
+            if (bitsRemain > 0 && bitsRemain < 8) {
+                mask = (uint8_t)(0xFF << (8 - bitsRemain));
+                out &= mask;
+            }
+
+            // invert to FASTEPD polarity
+            out = (~out) & mask;
+
+            uint32_t pos = rowBase + xb;
+            uint8_t prevVal = prev ? (prev[pos] & mask) : 0x00;
+            // Consider this byte changed if previous buffer differs (or prev is null)
+            bool changed = (prev == nullptr) || (prevVal != out);
+
+#ifdef EINK_LIMIT_GHOSTING_PX
+            if (changed && prev)
+                markDirtyBits(prev, pos, mask, out);
+#endif
+
+            // mark row changed only if the previous buffer differs
+            if (changed) {
+                if (y < (uint32_t)newTop)
+                    newTop = y;
+                if ((int)y > newBottom)
+                    newBottom = y;
+#ifdef FAST_EPD_PARTIAL_UPDATE_BUG
+                // record changed column bytes
+                if ((int)xb < newLeftByte)
+                    newLeftByte = (int)xb;
+                if ((int)xb > newRightByte)
+                    newRightByte = (int)xb;
+#endif
+            }
+
+            // Always write the computed value into the current buffer (avoid leaving stale bytes)
+            cur[pos] = (cur[pos] & ~mask) | out;
+        }
+    }
+
+    // If nothing changed, avoid any panel update
+    if (newBottom < 0) {
+        LOG_DEBUG("no pixel changes detected, skipping update (conv)");
+        previousImageHash = imageHash; // still remember that frame
+        return;
+    }
+
+    // Choose partial vs full update using heuristic
+    // Decide if we should force a full update after many fast updates
+    bool forceFull = (fastRefreshCount >= EPD_FULLSLOW_PERIOD);
+
+#ifdef EINK_LIMIT_GHOSTING_PX
+    // If ghost pixels exceed limit, force a full update to clear ghosting
+    if (ghostPixelCount > ghostPixelLimit) {
+        LOG_WARN("ghost pixels %u > limit %u, forcing full refresh", ghostPixelCount, ghostPixelLimit);
+        forceFull = true;
+    }
+#endif
+
+    // Compute pixel bounds from newTop/newBottom
+    int startRow = (newTop / 8) * 8;
+    int endRow = (newBottom / 8) * 8 + 7;
+
+    LOG_DEBUG("EPD update rows=%d..%d alignedRows=%d..%d rowBytes=%u", newTop, newBottom, startRow, endRow, rowBytes);
+
+    if (epaper->getMode() == BB_MODE_1BPP && !forceFull && (newBottom - newTop) <= EPD_PARTIAL_THRESHOLD_ROWS) {
+        // Prefer partial update path if driver is reliable; otherwise use clipped fullUpdate fallback.
+#ifdef FAST_EPD_PARTIAL_UPDATE_BUG
+        // Workaround for FastEPD partial update bug: use clipped fullUpdate instead
+        // Build a pixel rectangle for a clipped fullUpdate using the changed columns
+        int startCol = (newLeftByte <= newRightByte) ? (newLeftByte * 8) : 0;
+        int endCol = (newLeftByte <= newRightByte) ? ((newRightByte + 1) * 8 - 1) : (w - 1);
+
+        BB_RECT rect{startCol, startRow, endCol - startCol + 1, endRow - startRow + 1};
+        // LOG_DEBUG("Using clipped fullUpdate rect x=%d y=%d w=%d h=%d", rect.x, rect.y, rect.w, rect.h);
+        epaper->fullUpdate(CLEAR_FAST, false, &rect);
+#else
+        // Use rows for partial update
+        LOG_DEBUG("calling partialUpdate startRow=%d endRow=%d", startRow, endRow);
+        epaper->partialUpdate(true, startRow, endRow);
+#endif
+        epaper->backupPlane();
+        fastRefreshCount++;
+    } else {
+        // Full update: run async if possible (startAsyncFullUpdate will fall back to blocking)
+        startAsyncFullUpdate(forceFull ? CLEAR_SLOW : CLEAR_FAST);
+    }
+
+    lastUpdateMs = millis();
+    previousImageHash = imageHash;
+
+    // Keep same behavior as before
+    lastDrawMsec = millis();
+}
+
+#ifdef EINK_LIMIT_GHOSTING_PX
+// markDirtyBits: mark per-bit dirty flags and update ghostPixelCount
+void EInkParallelDisplay::markDirtyBits(const uint8_t *prevBuf, uint32_t pos, uint8_t mask, uint8_t out)
+{
+    // defensive: need dirtyPixels allocated and prevBuf valid
+    if (!dirtyPixels || !prevBuf)
+        return;
+
+    // 'out' is in FASTEPD polarity (1 = black, 0 = white)
+    uint8_t newBlack = out & mask;    // bits that will be black now
+    uint8_t newWhite = (~out) & mask; // bits that will be white now
+
+    // previously recorded dirty bits for this byte
+    uint8_t before = dirtyPixels[pos];
+
+    // Ghost bits: bits that were previously marked dirty and are now being driven white
+    uint8_t ghostBits = before & newWhite;
+    if (ghostBits) {
+        ghostPixelCount += __builtin_popcount((unsigned)ghostBits);
+    }
+
+    // Only mark bits dirty when they turn black now (accumulate until a full refresh)
+    uint8_t newlyDirty = newBlack & (~before);
+    if (newlyDirty) {
+        dirtyPixels[pos] |= newlyDirty;
+    }
+}
+
+// reset ghost tracking (call after a full refresh)
+void EInkParallelDisplay::resetGhostPixelTracking()
+{
+    if (!dirtyPixels)
+        return;
+    memset(dirtyPixels, 0, dirtyPixelsSize);
+    ghostPixelCount = 0;
+}
+#endif
+
+/*
+ * forceDisplay: use lastDrawMsec
+ */
+bool EInkParallelDisplay::forceDisplay(uint32_t msecLimit)
+{
+    uint32_t now = millis();
+    if (lastDrawMsec == 0 || (now - lastDrawMsec) > msecLimit) {
+        display();
+        return true;
+    }
+    return false;
+}
+
+void EInkParallelDisplay::endUpdate()
+{
+    {
+        // ensure any async full update is started/completed
+        if (asyncFullRunning.load()) {
+            // nothing to do; background task will run and call backupPlane when done
+        } else {
+            epaper->fullUpdate(CLEAR_FAST, false);
+            epaper->backupPlane();
+#ifdef EINK_LIMIT_GHOSTING_PX
+            resetGhostPixelTracking();
+#endif
+        }
+    }
+}
+
+#endif

src/graphics/EInkParallelDisplay.h

@@ -0,0 +1,69 @@
+#pragma once
+
+#include "configuration.h"
+
+#ifdef USE_EINK_PARALLELDISPLAY
+#include <OLEDDisplay.h>
+
+#include <atomic>
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+
+class FASTEPD;
+
+/**
+ * Adapter for E-Ink 8-bit parallel displays (EPD), specifically devices supported by FastEPD library
+ */
+class EInkParallelDisplay : public OLEDDisplay
+{
+  public:
+    enum EpdRotation {
+        EPD_ROT_LANDSCAPE = 0,
+        EPD_ROT_PORTRAIT = 90,
+        EPD_ROT_INVERTED_LANDSCAPE = 180,
+        EPD_ROT_INVERTED_PORTRAIT = 270,
+    };
+
+    EInkParallelDisplay(uint16_t width, uint16_t height, EpdRotation rotation);
+    virtual ~EInkParallelDisplay();
+
+    // OLEDDisplay virtuals
+    bool connect() override;
+    void sendCommand(uint8_t com) override;
+    int getBufferOffset(void) override { return 0; }
+
+    void display(void) override;
+    bool forceDisplay(uint32_t msecLimit = 1000);
+    void endUpdate();
+
+  protected:
+    uint32_t lastDrawMsec = 0;
+    FASTEPD *epaper;
+
+  private:
+    // Async full-refresh support
+    std::atomic<bool> asyncFullRunning{false};
+    TaskHandle_t asyncTaskHandle = nullptr;
+    void startAsyncFullUpdate(int clearMode);
+    static void asyncFullUpdateTask(void *pvParameters);
+
+#ifdef EINK_LIMIT_GHOSTING_PX
+    // helpers
+    void resetGhostPixelTracking();
+    void markDirtyBits(const uint8_t *prevBuf, uint32_t pos, uint8_t mask, uint8_t out);
+    void countGhostPixelsAndMaybePromote(int &newTop, int &newBottom, bool &forceFull);
+
+    // per-bit dirty buffer (same format as epaper buffers): one bit == one pixel
+    uint8_t *dirtyPixels = nullptr;
+    size_t dirtyPixelsSize = 0;
+    uint32_t ghostPixelCount = 0;
+    uint32_t ghostPixelLimit = EINK_LIMIT_GHOSTING_PX;
+#endif
+
+    EpdRotation rotation;
+    uint32_t previousImageHash = 0;
+    uint32_t lastUpdateMs = 0;
+    int fastRefreshCount = 0;
+};
+
+#endif

src/graphics/GxEPD2Multi.h

@@ -0,0 +1,135 @@
+// Wrapper class for GxEPD2_BW
+
+// Generic signature at build-time, so that we can detect display model at run-time
+// Workaround for issue of GxEPD2_BW objects not having a shared base class
+// Only exposes methods which we are actually using
+
+template <typename Driver0, typename Driver1> class GxEPD2_Multi
+{
+  public:
+    void drawPixel(int16_t x, int16_t y, uint16_t color)
+    {
+        if (which == 0)
+            driver0->drawPixel(x, y, color);
+        else
+            driver1->drawPixel(x, y, color);
+    }
+
+    bool nextPage()
+    {
+        if (which == 0)
+            return driver0->nextPage();
+        else
+            return driver1->nextPage();
+    }
+
+    void hibernate()
+    {
+        if (which == 0)
+            driver0->hibernate();
+        else
+            driver1->hibernate();
+    }
+
+    void init(uint32_t serial_diag_bitrate = 0)
+    {
+        if (which == 0)
+            driver0->init(serial_diag_bitrate);
+        else
+            driver1->init(serial_diag_bitrate);
+    }
+
+    void init(uint32_t serial_diag_bitrate, bool initial, uint16_t reset_duration = 20, bool pulldown_rst_mode = false)
+    {
+        if (which == 0)
+            driver0->init(serial_diag_bitrate, initial, reset_duration, pulldown_rst_mode);
+        else
+            driver1->init(serial_diag_bitrate, initial, reset_duration, pulldown_rst_mode);
+    }
+
+    void setRotation(uint8_t x)
+    {
+        if (which == 0)
+            driver0->setRotation(x);
+        else
+            driver1->setRotation(x);
+    }
+
+    void setPartialWindow(uint16_t x, uint16_t y, uint16_t w, uint16_t h)
+    {
+        if (which == 0)
+            driver0->setPartialWindow(x, y, w, h);
+        else
+            driver1->setPartialWindow(x, y, w, h);
+    }
+
+    void setFullWindow()
+    {
+        if (which == 0)
+            driver0->setFullWindow();
+        else
+            driver1->setFullWindow();
+    }
+
+    int16_t width()
+    {
+        if (which == 0)
+            return driver0->width();
+        else
+            return driver1->width();
+    }
+
+    int16_t height()
+    {
+        if (which == 0)
+            return driver0->height();
+        else
+            return driver1->height();
+    }
+
+    void clearScreen(uint8_t value = 0xFF)
+    {
+        if (which == 0)
+            driver0->clearScreen();
+        else
+            driver1->clearScreen();
+    }
+
+    void endAsyncFull()
+    {
+        if (which == 0)
+            driver0->endAsyncFull();
+        else
+            driver1->endAsyncFull();
+    }
+
+    // Exposes methods of the GxEPD2_EPD object which is usually available as GxEPD2_BW::epd
+    class Epd2Wrapper
+    {
+      public:
+        bool isBusy() { return m_epd2->isBusy(); }
+        GxEPD2_EPD *m_epd2;
+    } epd2;
+
+    // Constructor
+    // Select driver by passing whichDriver as 0 or 1
+    GxEPD2_Multi(uint8_t whichDriver, int16_t cs, int16_t dc, int16_t rst, int16_t busy, SPIClass &spi)
+    {
+        assert(whichDriver == 0 || whichDriver == 1);
+        which = whichDriver;
+        LOG_DEBUG("GxEPD2_Multi driver: %d", which);
+
+        if (which == 0) {
+            driver0 = new GxEPD2_BW<Driver0, Driver0::HEIGHT>(Driver0(cs, dc, rst, busy, spi));
+            epd2.m_epd2 = &(driver0->epd2);
+        } else if (which == 1) {
+            driver1 = new GxEPD2_BW<Driver1, Driver1::HEIGHT>(Driver1(cs, dc, rst, busy, spi));
+            epd2.m_epd2 = &(driver1->epd2);
+        }
+    }
+
+  private:
+    uint8_t which;
+    GxEPD2_BW<Driver0, Driver0::HEIGHT> *driver0;
+    GxEPD2_BW<Driver1, Driver1::HEIGHT> *driver1;
+};

src/graphics/Screen.cpp

@@ -27,14 +27,9 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "configuration.h"
 #include "meshUtils.h"
 #if HAS_SCREEN
+#include "EInkParallelDisplay.h"
 #include <OLEDDisplay.h>
 
-#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-#include "graphics/BaseUIEInkDisplay.h"
-// Provided by each niche-enabled variant's nicheGraphics.h (defined once, in main.cpp TU).
-extern NicheGraphics::BaseUIEInkDisplay *setupNicheGraphicsBaseUI();
-#endif
-
 #include "DisplayFormatters.h"
 #include "TimeFormatters.h"
 #include "draw/ClockRenderer.h"
@@ -448,9 +443,14 @@ Screen::Screen(ScanI2C::DeviceAddress address, meshtastic_Config_DisplayConfig_O
     defined(RAK14014) || defined(HX8357_CS) || defined(ILI9488_CS) || defined(ST7796_CS) || defined(HACKADAY_COMMUNICATOR)
     dispdev = new TFTDisplay(address.address, -1, -1, geometry,
                              (address.port == ScanI2C::I2CPort::WIRE1) ? HW_I2C::I2C_TWO : HW_I2C::I2C_ONE);
-#elif defined(USE_EINK) && defined(MESHTASTIC_INCLUDE_NICHE_GRAPHICS)
-    // NicheGraphics-backed BaseUI E-Ink path. Variant provides setupNicheGraphicsBaseUI() in its nicheGraphics.h.
-    dispdev = setupNicheGraphicsBaseUI();
+#elif defined(USE_EINK) && !defined(USE_EINK_DYNAMICDISPLAY) && !defined(USE_EINK_PARALLELDISPLAY)
+    dispdev = new EInkDisplay(address.address, -1, -1, geometry,
+                              (address.port == ScanI2C::I2CPort::WIRE1) ? HW_I2C::I2C_TWO : HW_I2C::I2C_ONE);
+#elif defined(USE_EINK) && defined(USE_EINK_DYNAMICDISPLAY)
+    dispdev = new EInkDynamicDisplay(address.address, -1, -1, geometry,
+                                     (address.port == ScanI2C::I2CPort::WIRE1) ? HW_I2C::I2C_TWO : HW_I2C::I2C_ONE);
+#elif defined(USE_EINK_PARALLELDISPLAY)
+    dispdev = new EInkParallelDisplay(EPD_WIDTH, EPD_HEIGHT, EInkParallelDisplay::EPD_ROT_PORTRAIT);
 #elif defined(USE_ST7567)
     dispdev = new ST7567Wire(address.address, -1, -1, geometry,
                              (address.port == ScanI2C::I2CPort::WIRE1) ? HW_I2C::I2C_TWO : HW_I2C::I2C_ONE);
@@ -848,8 +848,10 @@ void Screen::forceDisplay(bool forceUiUpdate)
     }
 
     // Tell EInk class to update the display
-#if defined(MESHTASTIC_INCLUDE_NICHE_GRAPHICS)
-    static_cast<NicheGraphics::BaseUIEInkDisplay *>(dispdev)->forceDisplay();
+#if defined(USE_EINK_PARALLELDISPLAY)
+    static_cast<EInkParallelDisplay *>(dispdev)->forceDisplay();
+#elif defined(USE_EINK)
+    static_cast<EInkDisplay *>(dispdev)->forceDisplay();
 #endif
 #else
     // No delay between UI frame rendering
@@ -1036,7 +1038,12 @@ int32_t Screen::runOnce()
             NotificationRenderer::current_notification_type != notificationTypeEnum::text_input &&
             !Throttle::isWithinTimespanMs(lastScreenTransition, config.display.auto_screen_carousel_secs * 1000)) {
 
-            // Carousel rotations let BaseUIEInkDisplay's DisplayHealth debt model decide FAST vs FULL.
+            // If an E-Ink display struggles with fast refresh, force carousel to use full refresh instead
+            // Carousel is potentially a major source of E-Ink display wear
+#if !defined(EINK_BACKGROUND_USES_FAST)
+            EINK_ADD_FRAMEFLAG(dispdev, COSMETIC);
+#endif
+
             LOG_DEBUG("LastScreenTransition exceeded %ums transition to next frame", (millis() - lastScreenTransition));
             handleOnPress();
         }
@@ -1070,8 +1077,11 @@ void Screen::setScreensaverFrames(FrameCallback einkScreensaver)
     static FrameCallback screensaverFrame;
     static OverlayCallback screensaverOverlay;
 
-    // Join (await) any currently running async refresh before drawing the screensaver frame.
+#if defined(HAS_EINK_ASYNCFULL) && defined(USE_EINK_DYNAMICDISPLAY)
+    // Join (await) a currently running async refresh, then run the post-update code.
+    // Avoid skipping of screensaver frame. Would otherwise be handled by NotifiedWorkerThread.
     EINK_JOIN_ASYNCREFRESH(dispdev);
+#endif
 
     // If: one-off screensaver frame passed as argument. Handles doDeepSleep()
     if (einkScreensaver != NULL) {
@@ -1094,17 +1104,23 @@ void Screen::setScreensaverFrames(FrameCallback einkScreensaver)
         updateUiFrame(ui);
     } while (ui->getUiState()->lastUpdate < startUpdate);
 
-#if defined(MESHTASTIC_INCLUDE_NICHE_GRAPHICS)
-    static_cast<NicheGraphics::BaseUIEInkDisplay *>(dispdev)->forceDisplay(0);
+#if defined(USE_EINK_PARALLELDISPLAY)
+    static_cast<EInkParallelDisplay *>(dispdev)->forceDisplay(0);
+#elif defined(USE_EINK) && !defined(USE_EINK_DYNAMICDISPLAY)
+    // Old EInkDisplay class
+    static_cast<EInkDisplay *>(dispdev)->forceDisplay(0); // Screen::forceDisplay(), but override rate-limit
 #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
 
-    // Pick a refresh method for when the display wakes. RESPONSIVE = FAST; DisplayHealth
-    // will promote to FULL on its own schedule if FAST debt has built up.
-    EINK_ADD_FRAMEFLAG(dispdev, RESPONSIVE);
+    // Pick a refresh method, for when display wakes
+#ifdef EINK_HASQUIRK_GHOSTING
+    EINK_ADD_FRAMEFLAG(dispdev, COSMETIC); // Really ugly to see ghosting from "screen paused"
+#else
+    EINK_ADD_FRAMEFLAG(dispdev, RESPONSIVE);              // Really nice to wake screen with a fast-refresh
+#endif
 }
 #endif
 

src/graphics/Screen.h

@@ -87,7 +87,8 @@ class Screen
 #include <AutoOLEDWire.h>
 #endif
 
-#include "BaseUIEInkDisplay.h"
+#include "EInkDisplay2.h"
+#include "EInkDynamicDisplay.h"
 #include "PointStruct.h"
 #include "TFTDisplay.h"
 #include "TypedQueue.h"

src/graphics/eink/Drivers/EInkParallel.cpp

@@ -1,132 +0,0 @@
-#include "./EInkParallel.h"
-
-#if defined(MESHTASTIC_INCLUDE_NICHE_GRAPHICS) && defined(ARCH_ESP32) && defined(NICHE_HAS_FASTEPD)
-
-#include "FastEPD.h"
-
-using namespace NicheGraphics::Drivers;
-
-EInkParallel::EInkParallel(uint16_t width, uint16_t height, uint32_t panelType, uint32_t panelClock)
-    : EInk(width, height, (UpdateTypes)(FULL | FAST)), panelType(panelType), panelClock(panelClock)
-{
-}
-
-EInkParallel::~EInkParallel()
-{
-    if (asyncRunning.load()) {
-        for (int i = 0; i < 50 && asyncRunning.load(); ++i)
-            delay(50);
-        if (asyncTaskHandle) {
-            vTaskDelete(asyncTaskHandle);
-            asyncTaskHandle = nullptr;
-        }
-    }
-    delete epaper;
-}
-
-void EInkParallel::begin(SPIClass *, uint8_t, uint8_t, uint8_t, uint8_t)
-{
-    // Parallel panels don't use the SPI args; FastEPD owns the bus.
-    if (!epaper) {
-        epaper = new FASTEPD;
-        epaper->initPanel((int)panelType, panelClock);
-        postPanelInit();
-        epaper->setMode(BB_MODE_1BPP);
-        epaper->clearWhite();
-        epaper->fullUpdate(true);
-    }
-}
-
-void EInkParallel::update(uint8_t *imageData, UpdateTypes type)
-{
-    if (!epaper)
-        return;
-
-    pendingType = type;
-    copyImageInverted(imageData);
-
-    if (type == FULL) {
-        // Pick CLEAR_SLOW periodically to clear ghosting.
-        const int clearMode = (fastRefreshCount >= FULL_SLOW_PERIOD) ? CLEAR_SLOW : CLEAR_FAST;
-        fastRefreshCount = 0;
-
-        if (!asyncRunning.load()) {
-            asyncRunning.store(true);
-            BaseType_t rc =
-                xTaskCreatePinnedToCore(asyncFullTask, "epd_full", 4096 / sizeof(StackType_t), this, 2, &asyncTaskHandle,
-#if CONFIG_FREERTOS_UNICORE
-                                        0
-#else
-                                        1
-#endif
-                );
-            if (rc != pdPASS) {
-                LOG_WARN("Async full failed; running blocking");
-                epaper->fullUpdate(clearMode, false);
-                epaper->backupPlane();
-                asyncRunning.store(false);
-                asyncTaskHandle = nullptr;
-                return; // synchronous: nothing to poll
-            }
-            // Begin polling for completion.
-            beginPolling(100, 1500);
-        }
-    } else {
-        // FAST: synchronous partial / clipped fullUpdate. Block briefly here.
-        epaper->fullUpdate(CLEAR_FAST, false);
-        epaper->backupPlane();
-        fastRefreshCount++;
-        // No polling needed; isUpdateDone() will report done immediately.
-        beginPolling(10, 0);
-    }
-}
-
-void EInkParallel::asyncFullTask(void *param)
-{
-    auto *self = static_cast<EInkParallel *>(param);
-    if (!self) {
-        vTaskDelete(nullptr);
-        return;
-    }
-    self->epaper->fullUpdate(CLEAR_FAST, false);
-    self->epaper->backupPlane();
-    self->asyncRunning.store(false);
-    self->asyncTaskHandle = nullptr;
-    vTaskDelete(nullptr);
-}
-
-bool EInkParallel::isUpdateDone()
-{
-    return !asyncRunning.load();
-}
-
-void EInkParallel::finalizeUpdate()
-{
-    pendingType = UpdateTypes::UNSPECIFIED;
-}
-
-// Convert a niche-format buffer (row-major, MSB-left, 1=WHITE) into FastEPD's currentBuffer
-// (row-major, MSB-left, 1=BLACK). Polarity inversion only.
-void EInkParallel::copyImageInverted(const uint8_t *src)
-{
-    uint8_t *dst = epaper->currentBuffer();
-    if (!dst || !src)
-        return;
-
-    const uint16_t rowBytes = ((width - 1) / 8) + 1;
-    const uint32_t total = rowBytes * height;
-
-    // Mask off bits beyond the panel width in the trailing byte of each row.
-    const uint8_t trailingMask = (uint8_t)(0xFFu << ((rowBytes * 8) - width));
-
-    for (uint16_t y = 0; y < height; y++) {
-        const uint32_t base = y * rowBytes;
-        for (uint16_t b = 0; b < rowBytes - 1; b++) {
-            dst[base + b] = ~src[base + b];
-        }
-        dst[base + rowBytes - 1] = (~src[base + rowBytes - 1]) & trailingMask;
-    }
-    (void)total;
-}
-
-#endif // MESHTASTIC_INCLUDE_NICHE_GRAPHICS && ARCH_ESP32 && NICHE_HAS_FASTEPD

src/graphics/eink/Drivers/EInkParallel.h

@@ -1,69 +0,0 @@
-/*
-
-Parallel-EPD niche driver, backed by FastEPD.
-
-Used for boards with an 8-bit parallel EPD interface (e.g. LILYGO T5 S3 ePaper).
-The base class signature passes SPI parameters; this driver ignores them and uses FastEPD
-to drive the parallel bus directly.
-
-Gated on NICHE_HAS_FASTEPD because FastEPD is a heavy dependency that only parallel-EPD
-variants want pulled in. Variants opt in by defining NICHE_HAS_FASTEPD in their platformio.ini
-and adding the FastEPD library to lib_deps.
-
-*/
-
-#pragma once
-
-#include "configuration.h"
-
-#if defined(MESHTASTIC_INCLUDE_NICHE_GRAPHICS) && defined(ARCH_ESP32) && defined(NICHE_HAS_FASTEPD)
-
-#include "./EInk.h"
-
-#include <atomic>
-#include <freertos/FreeRTOS.h>
-#include <freertos/task.h>
-
-class FASTEPD;
-
-namespace NicheGraphics::Drivers
-{
-
-class EInkParallel : public EInk
-{
-  public:
-    EInkParallel(uint16_t width, uint16_t height, uint32_t panelType, uint32_t panelClock = 28000000);
-    ~EInkParallel();
-
-    // SPI parameters are unused for parallel panels.
-    void begin(SPIClass *spi, uint8_t pin_dc, uint8_t pin_cs, uint8_t pin_busy, uint8_t pin_rst = -1) override;
-    void update(uint8_t *imageData, UpdateTypes type) override;
-
-    FASTEPD *fastEpd() { return epaper; }
-
-  protected:
-    bool isUpdateDone() override;
-    void finalizeUpdate() override;
-
-    // Hook for boards that need to bring up GPIO expanders / power pins after FastEPD::initPanel.
-    virtual void postPanelInit() {}
-
-  private:
-    void copyImageInverted(const uint8_t *src);
-    static void asyncFullTask(void *param);
-
-    FASTEPD *epaper = nullptr;
-    uint32_t panelType;
-    uint32_t panelClock;
-
-    UpdateTypes pendingType = UpdateTypes::UNSPECIFIED;
-    std::atomic<bool> asyncRunning{false};
-    TaskHandle_t asyncTaskHandle = nullptr;
-
-    uint8_t fastRefreshCount = 0;
-    static constexpr uint8_t FULL_SLOW_PERIOD = 100;
-};
-
-} // namespace NicheGraphics::Drivers
-
-#endif // MESHTASTIC_INCLUDE_NICHE_GRAPHICS && ARCH_ESP32 && NICHE_HAS_FASTEPD

src/graphics/eink/Drivers/GDEH0122T61.cpp

@@ -1,49 +0,0 @@
-#include "./GDEH0122T61.h"
-
-#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-
-using namespace NicheGraphics::Drivers;
-
-void GDEH0122T61::configScanning()
-{
-    sendCommand(0x01);
-    sendData(0xAF); // Scan until gate 175 (176px vertical resolution, low byte)
-    sendData(0x00); // high byte
-    sendData(0x00);
-}
-
-void GDEH0122T61::configWaveform()
-{
-    sendCommand(0x3C);
-    sendData(0x05);
-
-    sendCommand(0x18);
-    sendData(0x80);
-}
-
-void GDEH0122T61::configUpdateSequence()
-{
-    switch (updateType) {
-    case FAST:
-        sendCommand(0x22);
-        sendData(0xFF);
-        break;
-    case FULL:
-    default:
-        sendCommand(0x22);
-        sendData(0xF7);
-        break;
-    }
-}
-
-void GDEH0122T61::detachFromUpdate()
-{
-    switch (updateType) {
-    case FAST:
-        return beginPolling(50, 250);
-    case FULL:
-    default:
-        return beginPolling(100, 1500);
-    }
-}
-#endif // MESHTASTIC_INCLUDE_NICHE_GRAPHICS

src/graphics/eink/Drivers/GDEH0122T61.h

@@ -1,43 +0,0 @@
-/*
-
-E-Ink display driver
-    - GDEH0122T61
-    - Manufacturer: Good Display
-    - Size: 1.22 inch
-    - Resolution: 192px x 176px
-    - Controller IC: SSD1681 (operating in a sub-200x200 window)
-
-    Used by: t-echo-lite.
-
-*/
-
-#pragma once
-
-#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-
-#include "configuration.h"
-
-#include "./SSD16XX.h"
-
-namespace NicheGraphics::Drivers
-{
-class GDEH0122T61 : public SSD16XX
-{
-  private:
-    static constexpr uint32_t width = 192;
-    static constexpr uint32_t height = 176;
-    static constexpr UpdateTypes supported = (UpdateTypes)(FULL | FAST);
-
-  public:
-    GDEH0122T61() : SSD16XX(width, height, supported) {}
-
-  protected:
-    void configScanning() override;
-    void configWaveform() override;
-    void configUpdateSequence() override;
-    void detachFromUpdate() override;
-};
-
-} // namespace NicheGraphics::Drivers
-
-#endif // MESHTASTIC_INCLUDE_NICHE_GRAPHICS

src/graphics/eink/Drivers/GDEQ031T10.cpp

@@ -1,57 +0,0 @@
-#include "./GDEQ031T10.h"
-
-#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-
-using namespace NicheGraphics::Drivers;
-
-void GDEQ031T10::configScanning()
-{
-    sendCommand(0x01);
-    sendData(0x3F); // 319, low byte
-    sendData(0x01); // 319, high byte
-    sendData(0x00);
-}
-
-void GDEQ031T10::configWaveform()
-{
-    sendCommand(0x3C);
-    sendData(0x01);
-
-    sendCommand(0x18);
-    sendData(0x80);
-}
-
-void GDEQ031T10::configUpdateSequence()
-{
-    switch (updateType) {
-    case FAST:
-        sendCommand(0x21);
-        sendData(0x00);
-        sendData(0x00);
-
-        sendCommand(0x22);
-        sendData(0xFF);
-        break;
-    case FULL:
-    default:
-        sendCommand(0x21);
-        sendData(0x40);
-        sendData(0x00);
-
-        sendCommand(0x22);
-        sendData(0xF7);
-        break;
-    }
-}
-
-void GDEQ031T10::detachFromUpdate()
-{
-    switch (updateType) {
-    case FAST:
-        return beginPolling(50, 400);
-    case FULL:
-    default:
-        return beginPolling(100, 2500);
-    }
-}
-#endif // MESHTASTIC_INCLUDE_NICHE_GRAPHICS

src/graphics/eink/Drivers/GDEQ031T10.h

@@ -1,43 +0,0 @@
-/*
-
-E-Ink display driver
-    - GDEQ031T10
-    - Manufacturer: Good Display
-    - Size: 3.1 inch
-    - Resolution: 240px x 320px
-    - Controller IC: SSD1677 (SSD16XX-family, larger memory range)
-
-    Used by: t-deck-pro.
-
-*/
-
-#pragma once
-
-#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-
-#include "configuration.h"
-
-#include "./SSD16XX.h"
-
-namespace NicheGraphics::Drivers
-{
-class GDEQ031T10 : public SSD16XX
-{
-  private:
-    static constexpr uint32_t width = 240;
-    static constexpr uint32_t height = 320;
-    static constexpr UpdateTypes supported = (UpdateTypes)(FULL | FAST);
-
-  public:
-    GDEQ031T10() : SSD16XX(width, height, supported) {}
-
-  protected:
-    void configScanning() override;
-    void configWaveform() override;
-    void configUpdateSequence() override;
-    void detachFromUpdate() override;
-};
-
-} // namespace NicheGraphics::Drivers
-
-#endif // MESHTASTIC_INCLUDE_NICHE_GRAPHICS

src/graphics/eink/Drivers/GDEY029T94.cpp

@@ -1,49 +0,0 @@
-#include "./GDEY029T94.h"
-
-#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-
-using namespace NicheGraphics::Drivers;
-
-void GDEY029T94::configScanning()
-{
-    sendCommand(0x01);
-    sendData(0x27); // 295, low byte
-    sendData(0x01); // 295, high byte
-    sendData(0x00);
-}
-
-void GDEY029T94::configWaveform()
-{
-    sendCommand(0x3C);
-    sendData(0x05);
-
-    sendCommand(0x18);
-    sendData(0x80);
-}
-
-void GDEY029T94::configUpdateSequence()
-{
-    switch (updateType) {
-    case FAST:
-        sendCommand(0x22);
-        sendData(0xFF);
-        break;
-    case FULL:
-    default:
-        sendCommand(0x22);
-        sendData(0xF7);
-        break;
-    }
-}
-
-void GDEY029T94::detachFromUpdate()
-{
-    switch (updateType) {
-    case FAST:
-        return beginPolling(50, 300);
-    case FULL:
-    default:
-        return beginPolling(100, 2000);
-    }
-}
-#endif // MESHTASTIC_INCLUDE_NICHE_GRAPHICS

src/graphics/eink/Drivers/GDEY029T94.h

@@ -1,43 +0,0 @@
-/*
-
-E-Ink display driver
-    - GDEY029T94 (also sold as GDEY029T94-V2)
-    - Manufacturer: Good Display
-    - Size: 2.9 inch
-    - Resolution: 128px x 296px
-    - Controller IC: SSD1680
-
-    Used by: esp32-s3-pico, crowpanel-esp32s3-2-epaper.
-
-*/
-
-#pragma once
-
-#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-
-#include "configuration.h"
-
-#include "./SSD16XX.h"
-
-namespace NicheGraphics::Drivers
-{
-class GDEY029T94 : public SSD16XX
-{
-  private:
-    static constexpr uint32_t width = 128;
-    static constexpr uint32_t height = 296;
-    static constexpr UpdateTypes supported = (UpdateTypes)(FULL | FAST);
-
-  public:
-    GDEY029T94() : SSD16XX(width, height, supported) {}
-
-  protected:
-    void configScanning() override;
-    void configWaveform() override;
-    void configUpdateSequence() override;
-    void detachFromUpdate() override;
-};
-
-} // namespace NicheGraphics::Drivers
-
-#endif // MESHTASTIC_INCLUDE_NICHE_GRAPHICS

src/graphics/eink/Drivers/GDEY042T81.cpp

@@ -1,49 +0,0 @@
-#include "./GDEY042T81.h"
-
-#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-
-using namespace NicheGraphics::Drivers;
-
-void GDEY042T81::configWaveform()
-{
-    sendCommand(0x3C);
-    sendData(0x01);
-
-    sendCommand(0x18);
-    sendData(0x80);
-}
-
-void GDEY042T81::configUpdateSequence()
-{
-    switch (updateType) {
-    case FAST:
-        sendCommand(0x21);
-        sendData(0x00);
-        sendData(0x00);
-
-        sendCommand(0x22);
-        sendData(0xFF);
-        break;
-    case FULL:
-    default:
-        sendCommand(0x21);
-        sendData(0x40);
-        sendData(0x00);
-
-        sendCommand(0x22);
-        sendData(0xF7);
-        break;
-    }
-}
-
-void GDEY042T81::detachFromUpdate()
-{
-    switch (updateType) {
-    case FAST:
-        return beginPolling(50, 1000);
-    case FULL:
-    default:
-        return beginPolling(100, 3500);
-    }
-}
-#endif // MESHTASTIC_INCLUDE_NICHE_GRAPHICS

src/graphics/eink/Drivers/GDEY042T81.h

@@ -1,42 +0,0 @@
-/*
-
-E-Ink display driver
-    - GDEY042T81
-    - Manufacturer: Good Display
-    - Size: 4.2 inch
-    - Resolution: 400px x 300px
-    - Controller IC: SSD1683
-
-    Used by: ME25LS01-4Y10TD_e-ink.
-
-*/
-
-#pragma once
-
-#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-
-#include "configuration.h"
-
-#include "./SSD16XX.h"
-
-namespace NicheGraphics::Drivers
-{
-class GDEY042T81 : public SSD16XX
-{
-  private:
-    static constexpr uint32_t width = 400;
-    static constexpr uint32_t height = 300;
-    static constexpr UpdateTypes supported = (UpdateTypes)(FULL | FAST);
-
-  public:
-    GDEY042T81() : SSD16XX(width, height, supported) {}
-
-  protected:
-    void configWaveform() override;
-    void configUpdateSequence() override;
-    void detachFromUpdate() override;
-};
-
-} // namespace NicheGraphics::Drivers
-
-#endif // MESHTASTIC_INCLUDE_NICHE_GRAPHICS

src/graphics/eink/Drivers/GDEY0579T93.cpp

@@ -1,57 +0,0 @@
-#include "./GDEY0579T93.h"
-
-#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-
-using namespace NicheGraphics::Drivers;
-
-void GDEY0579T93::configScanning()
-{
-    sendCommand(0x01);
-    sendData(0x0F); // 271, low byte
-    sendData(0x01); // 271, high byte
-    sendData(0x00);
-}
-
-void GDEY0579T93::configWaveform()
-{
-    sendCommand(0x3C);
-    sendData(0x01);
-
-    sendCommand(0x18);
-    sendData(0x80);
-}
-
-void GDEY0579T93::configUpdateSequence()
-{
-    switch (updateType) {
-    case FAST:
-        sendCommand(0x21);
-        sendData(0x00);
-        sendData(0x00);
-
-        sendCommand(0x22);
-        sendData(0xFF);
-        break;
-    case FULL:
-    default:
-        sendCommand(0x21);
-        sendData(0x40);
-        sendData(0x00);
-
-        sendCommand(0x22);
-        sendData(0xF7);
-        break;
-    }
-}
-
-void GDEY0579T93::detachFromUpdate()
-{
-    switch (updateType) {
-    case FAST:
-        return beginPolling(100, 2000);
-    case FULL:
-    default:
-        return beginPolling(150, 5000);
-    }
-}
-#endif // MESHTASTIC_INCLUDE_NICHE_GRAPHICS

src/graphics/eink/Drivers/GDEY0579T93.h

@@ -1,43 +0,0 @@
-/*
-
-E-Ink display driver
-    - GDEY0579T93
-    - Manufacturer: Good Display
-    - Size: 5.79 inch
-    - Resolution: 792px x 272px
-    - Controller IC: SSD1683 (extended memory range)
-
-    Used by: crowpanel-esp32s3-5-epaper.
-
-*/
-
-#pragma once
-
-#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-
-#include "configuration.h"
-
-#include "./SSD16XX.h"
-
-namespace NicheGraphics::Drivers
-{
-class GDEY0579T93 : public SSD16XX
-{
-  private:
-    static constexpr uint32_t width = 792;
-    static constexpr uint32_t height = 272;
-    static constexpr UpdateTypes supported = (UpdateTypes)(FULL | FAST);
-
-  public:
-    GDEY0579T93() : SSD16XX(width, height, supported) {}
-
-  protected:
-    void configScanning() override;
-    void configWaveform() override;
-    void configUpdateSequence() override;
-    void detachFromUpdate() override;
-};
-
-} // namespace NicheGraphics::Drivers
-
-#endif // MESHTASTIC_INCLUDE_NICHE_GRAPHICS

src/graphics/eink/Panels/DEPG0213BNS800.h

@@ -1,25 +0,0 @@
-#pragma once
-
-#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-
-#include "./PanelProfile.h"
-#include "graphics/eink/Drivers/DEPG0213BNS800.h"
-
-namespace NicheGraphics::Panels
-{
-class DEPG0213BNS800 : public PanelProfile
-{
-  public:
-    NicheGraphics::Drivers::EInk *create() override
-    {
-        prePowerOn();
-        SPIClass *spi = beginSpi();
-        auto *drv = new NicheGraphics::Drivers::DEPG0213BNS800();
-        drv->begin(spi, pinDC(), pinCS(), pinBusy(), pinReset());
-        return drv;
-    }
-    uint8_t rotation() const override { return 3; }
-};
-} // namespace NicheGraphics::Panels
-
-#endif

src/graphics/eink/Panels/DEPG0290BNS800.h

@@ -1,25 +0,0 @@
-#pragma once
-
-#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-
-#include "./PanelProfile.h"
-#include "graphics/eink/Drivers/DEPG0290BNS800.h"
-
-namespace NicheGraphics::Panels
-{
-class DEPG0290BNS800 : public PanelProfile
-{
-  public:
-    NicheGraphics::Drivers::EInk *create() override
-    {
-        prePowerOn();
-        SPIClass *spi = beginSpi();
-        auto *drv = new NicheGraphics::Drivers::DEPG0290BNS800();
-        drv->begin(spi, pinDC(), pinCS(), pinBusy(), pinReset());
-        return drv;
-    }
-    uint8_t rotation() const override { return 1; }
-};
-} // namespace NicheGraphics::Panels
-
-#endif

src/graphics/eink/Panels/E0213A367.h

@@ -1,25 +0,0 @@
-#pragma once
-
-#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-
-#include "./PanelProfile.h"
-#include "graphics/eink/Drivers/E0213A367.h"
-
-namespace NicheGraphics::Panels
-{
-class E0213A367 : public PanelProfile
-{
-  public:
-    NicheGraphics::Drivers::EInk *create() override
-    {
-        prePowerOn();
-        SPIClass *spi = beginSpi();
-        auto *drv = new NicheGraphics::Drivers::E0213A367();
-        drv->begin(spi, pinDC(), pinCS(), pinBusy(), pinReset());
-        return drv;
-    }
-    uint8_t rotation() const override { return 3; }
-};
-} // namespace NicheGraphics::Panels
-
-#endif

src/graphics/eink/Panels/GDEH0122T61.h

@@ -1,24 +0,0 @@
-#pragma once
-
-#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-
-#include "./PanelProfile.h"
-#include "graphics/eink/Drivers/GDEH0122T61.h"
-
-namespace NicheGraphics::Panels
-{
-class GDEH0122T61 : public PanelProfile
-{
-  public:
-    NicheGraphics::Drivers::EInk *create() override
-    {
-        prePowerOn();
-        SPIClass *spi = beginSpi();
-        auto *drv = new NicheGraphics::Drivers::GDEH0122T61();
-        drv->begin(spi, pinDC(), pinCS(), pinBusy(), pinReset());
-        return drv;
-    }
-};
-} // namespace NicheGraphics::Panels
-
-#endif

src/graphics/eink/Panels/GDEQ031T10.h

@@ -1,24 +0,0 @@
-#pragma once
-
-#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-
-#include "./PanelProfile.h"
-#include "graphics/eink/Drivers/GDEQ031T10.h"
-
-namespace NicheGraphics::Panels
-{
-class GDEQ031T10 : public PanelProfile
-{
-  public:
-    NicheGraphics::Drivers::EInk *create() override
-    {
-        prePowerOn();
-        SPIClass *spi = beginSpi();
-        auto *drv = new NicheGraphics::Drivers::GDEQ031T10();
-        drv->begin(spi, pinDC(), pinCS(), pinBusy(), pinReset());
-        return drv;
-    }
-};
-} // namespace NicheGraphics::Panels
-
-#endif

src/graphics/eink/Panels/GDEW0102T4.h

@@ -1,25 +0,0 @@
-#pragma once
-
-#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-
-#include "./PanelProfile.h"
-#include "graphics/eink/Drivers/GDEW0102T4.h"
-
-namespace NicheGraphics::Panels
-{
-class GDEW0102T4 : public PanelProfile
-{
-  public:
-    NicheGraphics::Drivers::EInk *create() override
-    {
-        prePowerOn();
-        SPIClass *spi = beginSpi();
-        auto *drv = new NicheGraphics::Drivers::GDEW0102T4();
-        drv->begin(spi, pinDC(), pinCS(), pinBusy(), pinReset());
-        return drv;
-    }
-    uint8_t rotation() const override { return 3; }
-};
-} // namespace NicheGraphics::Panels
-
-#endif

src/graphics/eink/Panels/GDEY0154D67.h

@@ -1,24 +0,0 @@
-#pragma once
-
-#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-
-#include "./PanelProfile.h"
-#include "graphics/eink/Drivers/GDEY0154D67.h"
-
-namespace NicheGraphics::Panels
-{
-class GDEY0154D67 : public PanelProfile
-{
-  public:
-    NicheGraphics::Drivers::EInk *create() override
-    {
-        prePowerOn();
-        SPIClass *spi = beginSpi();
-        auto *drv = new NicheGraphics::Drivers::GDEY0154D67();
-        drv->begin(spi, pinDC(), pinCS(), pinBusy(), pinReset());
-        return drv;
-    }
-};
-} // namespace NicheGraphics::Panels
-
-#endif

src/graphics/eink/Panels/GDEY0213B74.h

@@ -1,25 +0,0 @@
-#pragma once
-
-#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-
-#include "./PanelProfile.h"
-#include "graphics/eink/Drivers/GDEY0213B74.h"
-
-namespace NicheGraphics::Panels
-{
-class GDEY0213B74 : public PanelProfile
-{
-  public:
-    NicheGraphics::Drivers::EInk *create() override
-    {
-        prePowerOn();
-        SPIClass *spi = beginSpi();
-        auto *drv = new NicheGraphics::Drivers::GDEY0213B74();
-        drv->begin(spi, pinDC(), pinCS(), pinBusy(), pinReset());
-        return drv;
-    }
-    uint8_t rotation() const override { return 3; }
-};
-} // namespace NicheGraphics::Panels
-
-#endif

src/graphics/eink/Panels/GDEY029T94.h

@@ -1,25 +0,0 @@
-#pragma once
-
-#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-
-#include "./PanelProfile.h"
-#include "graphics/eink/Drivers/GDEY029T94.h"
-
-namespace NicheGraphics::Panels
-{
-class GDEY029T94 : public PanelProfile
-{
-  public:
-    NicheGraphics::Drivers::EInk *create() override
-    {
-        prePowerOn();
-        SPIClass *spi = beginSpi();
-        auto *drv = new NicheGraphics::Drivers::GDEY029T94();
-        drv->begin(spi, pinDC(), pinCS(), pinBusy(), pinReset());
-        return drv;
-    }
-    uint8_t rotation() const override { return 1; }
-};
-} // namespace NicheGraphics::Panels
-
-#endif

src/graphics/eink/Panels/GDEY042T81.h

@@ -1,24 +0,0 @@
-#pragma once
-
-#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-
-#include "./PanelProfile.h"
-#include "graphics/eink/Drivers/GDEY042T81.h"
-
-namespace NicheGraphics::Panels
-{
-class GDEY042T81 : public PanelProfile
-{
-  public:
-    NicheGraphics::Drivers::EInk *create() override
-    {
-        prePowerOn();
-        SPIClass *spi = beginSpi();
-        auto *drv = new NicheGraphics::Drivers::GDEY042T81();
-        drv->begin(spi, pinDC(), pinCS(), pinBusy(), pinReset());
-        return drv;
-    }
-};
-} // namespace NicheGraphics::Panels
-
-#endif

src/graphics/eink/Panels/GDEY0579T93.h

@@ -1,24 +0,0 @@
-#pragma once
-
-#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-
-#include "./PanelProfile.h"
-#include "graphics/eink/Drivers/GDEY0579T93.h"
-
-namespace NicheGraphics::Panels
-{
-class GDEY0579T93 : public PanelProfile
-{
-  public:
-    NicheGraphics::Drivers::EInk *create() override
-    {
-        prePowerOn();
-        SPIClass *spi = beginSpi();
-        auto *drv = new NicheGraphics::Drivers::GDEY0579T93();
-        drv->begin(spi, pinDC(), pinCS(), pinBusy(), pinReset());
-        return drv;
-    }
-};
-} // namespace NicheGraphics::Panels
-
-#endif

src/graphics/eink/Panels/HINK_E042A87.h

@@ -1,24 +0,0 @@
-#pragma once
-
-#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-
-#include "./PanelProfile.h"
-#include "graphics/eink/Drivers/HINK_E042A87.h"
-
-namespace NicheGraphics::Panels
-{
-class HINK_E042A87 : public PanelProfile
-{
-  public:
-    NicheGraphics::Drivers::EInk *create() override
-    {
-        prePowerOn();
-        SPIClass *spi = beginSpi();
-        auto *drv = new NicheGraphics::Drivers::HINK_E042A87();
-        drv->begin(spi, pinDC(), pinCS(), pinBusy(), pinReset());
-        return drv;
-    }
-};
-} // namespace NicheGraphics::Panels
-
-#endif

src/graphics/eink/Panels/LCMEN213EFC1.h

@@ -1,25 +0,0 @@
-#pragma once
-
-#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-
-#include "./PanelProfile.h"
-#include "graphics/eink/Drivers/LCMEN2R13EFC1.h"
-
-namespace NicheGraphics::Panels
-{
-class LCMEN213EFC1 : public PanelProfile
-{
-  public:
-    NicheGraphics::Drivers::EInk *create() override
-    {
-        prePowerOn();
-        SPIClass *spi = beginSpi();
-        auto *drv = new NicheGraphics::Drivers::LCMEN213EFC1();
-        drv->begin(spi, pinDC(), pinCS(), pinBusy(), pinReset());
-        return drv;
-    }
-    uint8_t rotation() const override { return 3; }
-};
-} // namespace NicheGraphics::Panels
-
-#endif

src/graphics/eink/Panels/LCMEN2R13ECC1.h

@@ -1,25 +0,0 @@
-#pragma once
-
-#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-
-#include "./PanelProfile.h"
-#include "graphics/eink/Drivers/LCMEN2R13ECC1.h"
-
-namespace NicheGraphics::Panels
-{
-class LCMEN2R13ECC1 : public PanelProfile
-{
-  public:
-    NicheGraphics::Drivers::EInk *create() override
-    {
-        prePowerOn();
-        SPIClass *spi = beginSpi();
-        auto *drv = new NicheGraphics::Drivers::LCMEN2R13ECC1();
-        drv->begin(spi, pinDC(), pinCS(), pinBusy(), pinReset());
-        return drv;
-    }
-    uint8_t rotation() const override { return 3; }
-};
-} // namespace NicheGraphics::Panels
-
-#endif

src/graphics/eink/Panels/PanelProfile.cpp

@@ -1,70 +0,0 @@
-#include "./PanelProfile.h"
-
-#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-
-using namespace NicheGraphics::Panels;
-
-SPIClass *PanelProfile::beginSpi()
-{
-#if defined(ARCH_ESP32)
-    auto *spi = new SPIClass(HSPI);
-#if defined(PIN_EINK_SCLK) && defined(PIN_EINK_MOSI) && defined(PIN_EINK_CS)
-    spi->begin(PIN_EINK_SCLK, -1, PIN_EINK_MOSI, PIN_EINK_CS);
-#else
-    spi->begin();
-#endif
-    return spi;
-#elif defined(ARCH_NRF52)
-    SPI1.begin();
-    return &SPI1;
-#else
-    return &SPI;
-#endif
-}
-
-int8_t PanelProfile::backlightPin() const
-{
-#ifdef PIN_EINK_EN
-    return PIN_EINK_EN;
-#else
-    return -1;
-#endif
-}
-
-uint8_t PanelProfile::pinDC() const
-{
-#ifdef PIN_EINK_DC
-    return PIN_EINK_DC;
-#else
-    return 0xFF;
-#endif
-}
-
-uint8_t PanelProfile::pinCS() const
-{
-#ifdef PIN_EINK_CS
-    return PIN_EINK_CS;
-#else
-    return 0xFF;
-#endif
-}
-
-uint8_t PanelProfile::pinBusy() const
-{
-#ifdef PIN_EINK_BUSY
-    return PIN_EINK_BUSY;
-#else
-    return 0xFF;
-#endif
-}
-
-int8_t PanelProfile::pinReset() const
-{
-#ifdef PIN_EINK_RES
-    return PIN_EINK_RES;
-#else
-    return -1;
-#endif
-}
-
-#endif // MESHTASTIC_INCLUDE_NICHE_GRAPHICS

src/graphics/eink/Panels/PanelProfile.h

@@ -1,52 +0,0 @@
-/*
-
-Panel profile: single source of truth for how a specific E-Ink panel is wired and brought up.
-Variants subclass a per-panel profile only to override differences (SPI bus, pins, rotation, backlight pin,
-power-up quirks). The profile's create() constructs and begins the underlying
-NicheGraphics::Drivers::EInk subclass exactly once.
-
-*/
-
-#pragma once
-
-#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-
-#include "configuration.h"
-
-#include "graphics/eink/Drivers/EInk.h"
-
-#include <SPI.h>
-
-namespace NicheGraphics::Panels
-{
-
-class PanelProfile
-{
-  public:
-    virtual ~PanelProfile() = default;
-
-    // Produce and begin() the underlying E-Ink driver. Called once per boot.
-    virtual NicheGraphics::Drivers::EInk *create() = 0;
-
-    // Public, variant-overridable metadata
-    virtual uint8_t rotation() const { return 0; }
-    virtual int8_t backlightPin() const;
-
-  protected:
-    // Default SPI bring-up. ESP32 uses HSPI with PIN_EINK_SCLK/MOSI; nRF52 uses SPI1 (pins from variant.h).
-    // Variants override when using a non-default bus or pin set.
-    virtual SPIClass *beginSpi();
-
-    // Pin defaults read the variant's PIN_EINK_* macros. Variants override if mapping differs.
-    virtual uint8_t pinDC() const;
-    virtual uint8_t pinCS() const;
-    virtual uint8_t pinBusy() const;
-    virtual int8_t pinReset() const;
-
-    // Hook for variants that need to raise a power rail / observe settle time before SPI traffic.
-    virtual void prePowerOn() {}
-};
-
-} // namespace NicheGraphics::Panels
-
-#endif // MESHTASTIC_INCLUDE_NICHE_GRAPHICS

src/graphics/eink/Panels/T5Epaper.h

@@ -1,38 +0,0 @@
-/*
-
-Panel profile base for the LILYGO T5 ePaper Pro family (ED047TC1, 960x540, 8-bit parallel via FastEPD).
-
-V1 and V2 use different FastEPD panel IDs and V2 also needs GPIO-expander pins raised.
-Variants subclass to provide a Drivers::EInkParallel subclass that implements
-postPanelInit() if needed.
-
-*/
-
-#pragma once
-
-#include "configuration.h"
-
-#if defined(MESHTASTIC_INCLUDE_NICHE_GRAPHICS) && defined(ARCH_ESP32) && defined(NICHE_HAS_FASTEPD)
-
-#include "./PanelProfile.h"
-#include "graphics/eink/Drivers/EInkParallel.h"
-
-namespace NicheGraphics::Panels
-{
-class T5EpaperPanel : public PanelProfile
-{
-  public:
-    NicheGraphics::Drivers::EInk *create() override
-    {
-        auto *drv = makeDriver();
-        drv->begin(nullptr, 0, 0, 0); // SPI args ignored
-        return drv;
-    }
-
-  protected:
-    // Variant returns a Drivers::EInkParallel subclass configured for its specific panel/init.
-    virtual NicheGraphics::Drivers::EInkParallel *makeDriver() = 0;
-};
-} // namespace NicheGraphics::Panels
-
-#endif // MESHTASTIC_INCLUDE_NICHE_GRAPHICS && ARCH_ESP32 && NICHE_HAS_FASTEPD

src/graphics/eink/Panels/ZJY122250_0213BAAMFGN.h

@@ -1,25 +0,0 @@
-#pragma once
-
-#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-
-#include "./PanelProfile.h"
-#include "graphics/eink/Drivers/ZJY122250_0213BAAMFGN.h"
-
-namespace NicheGraphics::Panels
-{
-class ZJY122250_0213BAAMFGN : public PanelProfile
-{
-  public:
-    NicheGraphics::Drivers::EInk *create() override
-    {
-        prePowerOn();
-        SPIClass *spi = beginSpi();
-        auto *drv = new NicheGraphics::Drivers::ZJY122250_0213BAAMFGN();
-        drv->begin(spi, pinDC(), pinCS(), pinBusy(), pinReset());
-        return drv;
-    }
-    uint8_t rotation() const override { return 1; }
-};
-} // namespace NicheGraphics::Panels
-
-#endif

src/graphics/niche/InkHUD/Applet.cpp

@@ -1,4 +1,4 @@
-#include "graphics/niche/Tile.h"
+#include "graphics/niche/InkHUD/Tile.h"
 #include <cstdint>
 #ifdef MESHTASTIC_INCLUDE_INKHUD
 

src/graphics/niche/InkHUD/Applet.h

@@ -23,7 +23,7 @@
 #include "./InkHUD.h"
 #include "./Persistence.h"
 #include "./Tile.h"
-#include "graphics/eink/Drivers/EInk.h"
+#include "graphics/niche/Drivers/EInk/EInk.h"
 
 namespace NicheGraphics::InkHUD
 {

src/graphics/niche/InkHUD/Applets/Bases/Map/MapApplet.h

@@ -16,7 +16,7 @@ The base applet doesn't handle any events; this is left to the derived applets.
 
 #include "configuration.h"
 
-#include "graphics/niche/Applet.h"
+#include "graphics/niche/InkHUD/Applet.h"
 
 #include "MeshModule.h"
 #include "gps/GeoCoord.h"

src/graphics/niche/InkHUD/Applets/Bases/NodeList/NodeListApplet.h

@@ -21,7 +21,7 @@ Used by the "Recents" and "Heard" applets. Possibly more in future?
 
 #include "configuration.h"
 
-#include "graphics/niche/Applet.h"
+#include "graphics/niche/InkHUD/Applet.h"
 
 #include "main.h"
 

src/graphics/niche/InkHUD/Applets/Examples/BasicExample/BasicExampleApplet.h

@@ -17,7 +17,7 @@ In variants/<your device>/nicheGraphics.h:
 
 #include "configuration.h"
 
-#include "graphics/niche/Applet.h"
+#include "graphics/niche/InkHUD/Applet.h"
 
 namespace NicheGraphics::InkHUD
 {

src/graphics/niche/InkHUD/Applets/Examples/NewMsgExample/NewMsgExampleApplet.h

@@ -20,7 +20,7 @@ In variants/<your device>/nicheGraphics.h:
 
 #include "configuration.h"
 
-#include "graphics/niche/Applet.h"
+#include "graphics/niche/InkHUD/Applet.h"
 
 #include "mesh/SinglePortModule.h"
 

src/graphics/niche/InkHUD/Applets/Examples/UserAppletInputExample/UserAppletInputExample.h

@@ -4,7 +4,7 @@
 
 #include "configuration.h"
 
-#include "graphics/niche/Applet.h"
+#include "graphics/niche/InkHUD/Applet.h"
 
 namespace NicheGraphics::InkHUD
 {

src/graphics/niche/InkHUD/Applets/System/AlignStick/AlignStickApplet.h

@@ -13,7 +13,7 @@ and not aligned to the screen
 
 #include "configuration.h"
 
-#include "graphics/niche/SystemApplet.h"
+#include "graphics/niche/InkHUD/SystemApplet.h"
 
 namespace NicheGraphics::InkHUD
 {