Merge origin/eink-refactor; supersede bot formatting commit (ignored repo clang-format config)

Arduino Release v3.3.9 based on ESP-IDF v5.5.4

May help with recent compile troubles?

.clusterfuzzlite/Dockerfile

@@ -18,7 +18,7 @@ ENV PIP_ROOT_USER_ACTION=ignore
 # trunk-ignore(hadolint/DL3008): apt packages are not pinned.
 # trunk-ignore(terrascan/AC_DOCKER_0002): apt packages are not pinned.
 RUN apt-get update && apt-get install --no-install-recommends -y \
-        cmake git zip libgpiod-dev libbluetooth-dev libi2c-dev \
+        cmake git zip libgpiod-dev libjsoncpp-dev libbluetooth-dev libi2c-dev \
         libunistring-dev libmicrohttpd-dev libgnutls28-dev libgcrypt20-dev \
         libusb-1.0-0-dev libssl-dev pkg-config libsqlite3-dev libsdl2-dev && \
     apt-get clean && rm -rf /var/lib/apt/lists/* && \

.clusterfuzzlite/build.sh

@@ -31,7 +31,7 @@ cmake --install "$WORK/ulfius/$SANITIZER" --prefix /usr
 cd "$SRC/firmware"
 
 PLATFORMIO_EXTRA_SCRIPTS=$(echo -e "pre:.clusterfuzzlite/platformio-clusterfuzzlite-pre.py\npost:.clusterfuzzlite/platformio-clusterfuzzlite-post.py")
-STATIC_LIBS=$(pkg-config --libs --static libulfius openssl libgpiod yaml-cpp bluez --silence-errors)
+STATIC_LIBS=$(pkg-config --libs --static libulfius openssl libgpiod yaml-cpp jsoncpp bluez --silence-errors)
 export PLATFORMIO_EXTRA_SCRIPTS
 export STATIC_LIBS
 export PLATFORMIO_WORKSPACE_DIR="$WORK/pio/$SANITIZER"

.devcontainer/Dockerfile

@@ -16,6 +16,7 @@ RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
     libssl-dev \
     libulfius-dev \
     libyaml-cpp-dev \
+    libjsoncpp-dev \
     pipx \
     pkg-config \
     python3 \

.github/actions/setup-base/action.yml

@@ -13,7 +13,7 @@ runs:
       shell: bash
       run: |
         sudo apt-get -y update --fix-missing
-        sudo apt-get install -y cppcheck libbluetooth-dev libgpiod-dev libyaml-cpp-dev lsb-release
+        sudo apt-get install -y cppcheck libbluetooth-dev libgpiod-dev libyaml-cpp-dev libjsoncpp-dev lsb-release
 
     - name: Setup Python
       uses: actions/setup-python@v6

.github/actions/setup-native/action.yml

@@ -11,4 +11,4 @@ runs:
     - name: Install libs needed for native build
       shell: bash
       run: |
-        sudo apt-get install -y libbluetooth-dev libgpiod-dev libyaml-cpp-dev openssl libssl-dev libulfius-dev liborcania-dev libusb-1.0-0-dev libi2c-dev libuv1-dev
+        sudo apt-get install -y libbluetooth-dev libgpiod-dev libyaml-cpp-dev libjsoncpp-dev openssl libssl-dev libulfius-dev liborcania-dev libusb-1.0-0-dev libi2c-dev libuv1-dev

.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**: EInkDisplay2, EInkDynamicDisplay, EInkParallelDisplay
+- **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.
 
-**InkHUD** (`src/graphics/niche/InkHUD/`) is an event-driven e-ink UI framework:
+**InkHUD** (`src/graphics/niche/`) is an event-driven e-ink UI framework that sits on top of the `graphics/eink/` layer:
 
 - Applet-based architecture — modular display tiles
 - Read-only, static display optimized for minimal refreshes and low power
 - Configured per-variant via `nicheGraphics.h`
-- Separate PlatformIO config: `src/graphics/niche/InkHUD/PlatformioConfig.ini`
+- Build helpers in top-level `platformio.ini` — `[niche]` pulls `graphics/eink/` only (BaseUI path), `[inkhud]` extends it with `graphics/niche/`
 
 ### Input System
 
@@ -609,20 +609,35 @@ Most workflows can be triggered manually via `workflow_dispatch` for testing.
 
 ### Native unit tests (C++)
 
-Unit tests in `test/` directory with 12 test suites:
+Unit tests in `test/` directory with 17 test suites:
 
-- `test_crypto/` - Cryptography
-- `test_mqtt/` - MQTT integration
-- `test_radio/` - Radio interface
-- `test_mesh_module/` - Module framework
-- `test_meshpacket_serializer/` - Packet serialization
-- `test_transmit_history/` - Retransmission tracking
+- `test_admin_radio/` - LoRa region/config validation and AdminModule dispatch
 - `test_atak/` - ATAK integration
+- `test_crypto/` - Cryptography
 - `test_default/` - Default configuration
 - `test_http_content_handler/` - HTTP handling
+- `test_mac_from_string/` - MAC address parsing
+- `test_mesh_module/` - Module framework
+- `test_meshpacket_serializer/` - Packet serialization
+- `test_mqtt/` - MQTT integration
+- `test_packet_history/` - Packet history tracking
+- `test_position_precision/` - Position precision helpers
+- `test_radio/` - Radio interface
 - `test_serial/` - Serial communication
+- `test_traffic_management/` - Traffic management
+- `test_transmit_history/` - Retransmission tracking
+- `test_type_conversions/` - NodeDB v25 type conversion (bitfield round-trips, NodeInfoLite)
+- `test_utf8/` - UTF-8 utilities
 
-Run with: `pio test -e native`
+Run command (preferred — avoids pipe-buffering and the Ubuntu externally-managed-environment error):
+
+```bash
+~/.platformio/penv/bin/python -m platformio test -e native -f test_your_suite > /tmp/test_out.txt 2>&1
+grep -E 'error:|PASS|FAIL|succeeded|failed' /tmp/test_out.txt
+tail -15 /tmp/test_out.txt
+```
+
+Do **not** use `pio test … | tail -N` — it discards build errors and shows stale cached results. Do **not** use `pio test … | grep` — line-buffering makes the terminal appear hung until the process exits. Redirect to a file first, then grep.
 
 Simulation testing: `bin/test-simulator.sh`
 

.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 has its own PlatformIO config: `src/graphics/niche/InkHUD/PlatformioConfig.ini`
+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`.
 
 ## I2C Device Detection
 

.github/workflows/firmware-size-comment.yml

@@ -0,0 +1,62 @@
+name: Post Firmware Size Comment
+
+on:
+  workflow_run:
+    workflows: [CI]
+    types: [completed]
+
+permissions:
+  pull-requests: write
+  actions: read
+
+jobs:
+  post-size-comment:
+    if: >
+      github.event.workflow_run.event == 'pull_request' &&
+      github.event.workflow_run.conclusion != 'cancelled' &&
+      github.repository == 'meshtastic/firmware'
+    continue-on-error: true
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download size report
+        id: download
+        uses: actions/download-artifact@v8
+        continue-on-error: true
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          run-id: ${{ github.event.workflow_run.id }}
+          name: size-report
+          path: ./
+
+      - name: Post or update PR comment
+        if: steps.download.outcome == 'success'
+        uses: actions/github-script@v8
+        with:
+          script: |
+            const fs = require('fs');
+            const marker = '<!-- firmware-size-report -->';
+            const body = fs.readFileSync('./size-report.md', 'utf8');
+            const prNumber = parseInt(fs.readFileSync('./pr-number.txt', 'utf8').trim(), 10);
+
+            const { data: comments } = await github.rest.issues.listComments({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: prNumber,
+            });
+
+            const existing = comments.find(c => c.body.includes(marker));
+            if (existing) {
+              await github.rest.issues.updateComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                comment_id: existing.id,
+                body,
+              });
+            } else {
+              await github.rest.issues.createComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: prNumber,
+                body,
+              });
+            }

.github/workflows/main_matrix.yml

@@ -245,47 +245,126 @@ jobs:
           path: ./*.elf
           retention-days: 30
 
-  shame:
+  firmware-size-report:
     if: github.repository == 'meshtastic/firmware'
     continue-on-error: true
+    permissions:
+      contents: read
+      actions: read
     runs-on: ubuntu-latest
     needs: [build]
     steps:
       - uses: actions/checkout@v6
-        if: github.event_name == 'pull_request'
-        with:
-          filter: blob:none # means we download all the git history but none of the commit (except ones with checkout like the head)
-          fetch-depth: 0
-      - name: Download the current manifests
+
+      - name: Download current manifests
         uses: actions/download-artifact@v8
         with:
-          path: ./manifests-new/
+          path: ./manifests/
           pattern: manifest-*
           merge-multiple: true
-      - name: Upload combined manifests for later commit and global stats crunching.
+
+      - name: Collect current firmware sizes
+        run: python3 bin/collect_sizes.py ./manifests/ ./current-sizes.json
+
+      - name: Upload size report artifact
         uses: actions/upload-artifact@v7
-        id: upload-manifest
         with:
-          name: manifests-${{ github.sha }}
+          name: firmware-sizes-${{ github.sha }}
           overwrite: true
-          path: manifests-new/*.mt.json
-      - name: Find the merge base
+          path: ./current-sizes.json
+          retention-days: 90
+
+      - name: Download baseline sizes from develop
         if: github.event_name == 'pull_request'
-        run: echo "MERGE_BASE=$(git merge-base "origin/$base" "$head")" >> $GITHUB_ENV
+        continue-on-error: true
+        id: baseline-develop
         env:
-          base: ${{ github.base_ref }}
-          head: ${{ github.sha }}
-      # Currently broken (for-loop through EVERY artifact -- rate limiting)
-      # - name: Download the old manifests
-      #   if: github.event_name == 'pull_request'
-      #   run: gh run download -R "$repo" --name "manifests-$merge_base" --dir manifest-old/
-      #   env:
-      #     GH_TOKEN: ${{ github.token }}
-      #     merge_base: ${{ env.MERGE_BASE }}
-      #     repo: ${{ github.repository }}
-      # - name: Do scan and post comment
-      #   if: github.event_name == 'pull_request'
-      #   run: python3 bin/shame.py ${{ github.event.pull_request.number }} manifests-old/ manifests-new/
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          RUN_ID=$(gh run list -R "${{ github.repository }}" \
+            --workflow CI --branch develop --status success \
+            --limit 1 --json databaseId --jq '.[0].databaseId // empty')
+          if [ -n "$RUN_ID" ]; then
+            ARTIFACT_NAME=$(gh api "repos/${{ github.repository }}/actions/runs/${RUN_ID}/artifacts" \
+              --jq '.artifacts[] | select(.name | startswith("firmware-sizes-")) | .name' | head -1)
+            if [ -n "$ARTIFACT_NAME" ]; then
+              gh run download "$RUN_ID" -R "${{ github.repository }}" \
+                --name "$ARTIFACT_NAME" --dir ./baseline-develop/
+              cp "./baseline-develop/${ARTIFACT_NAME}/current-sizes.json" ./develop-sizes.json
+              echo "found=true" >> "$GITHUB_OUTPUT"
+            else
+              echo "found=false" >> "$GITHUB_OUTPUT"
+            fi
+          else
+            echo "found=false" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Download baseline sizes from master
+        if: github.event_name == 'pull_request'
+        continue-on-error: true
+        id: baseline-master
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          RUN_ID=$(gh run list -R "${{ github.repository }}" \
+            --workflow CI --branch master --status success \
+            --limit 1 --json databaseId --jq '.[0].databaseId // empty')
+          if [ -n "$RUN_ID" ]; then
+            ARTIFACT_NAME=$(gh api "repos/${{ github.repository }}/actions/runs/${RUN_ID}/artifacts" \
+              --jq '.artifacts[] | select(.name | startswith("firmware-sizes-")) | .name' | head -1)
+            if [ -n "$ARTIFACT_NAME" ]; then
+              gh run download "$RUN_ID" -R "${{ github.repository }}" \
+                --name "$ARTIFACT_NAME" --dir ./baseline-master/
+              cp "./baseline-master/${ARTIFACT_NAME}/current-sizes.json" ./master-sizes.json
+              echo "found=true" >> "$GITHUB_OUTPUT"
+            else
+              echo "found=false" >> "$GITHUB_OUTPUT"
+            fi
+          else
+            echo "found=false" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Generate size comparison report
+        if: github.event_name == 'pull_request'
+        id: report
+        run: |
+          ARGS="./current-sizes.json"
+          if [ -f ./develop-sizes.json ]; then
+            ARGS="$ARGS --baseline develop:./develop-sizes.json"
+          fi
+          if [ -f ./master-sizes.json ]; then
+            ARGS="$ARGS --baseline master:./master-sizes.json"
+          fi
+          REPORT=$(python3 bin/size_report.py $ARGS)
+          if [ -z "$REPORT" ]; then
+            echo "has_report=false" >> "$GITHUB_OUTPUT"
+          else
+            echo "has_report=true" >> "$GITHUB_OUTPUT"
+            {
+              echo '<!-- firmware-size-report -->'
+              echo '# Firmware Size Report'
+              echo ''
+              echo "$REPORT"
+              echo ''
+              echo '---'
+              echo "*Updated for ${{ github.sha }}*"
+            } > ./size-report.md
+            cat ./size-report.md >> "$GITHUB_STEP_SUMMARY"
+          fi
+
+      - name: Save PR number
+        if: github.event_name == 'pull_request' && steps.report.outputs.has_report == 'true'
+        run: echo "${{ github.event.pull_request.number }}" > ./pr-number.txt
+
+      - name: Upload size report
+        if: github.event_name == 'pull_request' && steps.report.outputs.has_report == 'true'
+        uses: actions/upload-artifact@v7
+        with:
+          name: size-report
+          path: |
+            ./size-report.md
+            ./pr-number.txt
+          retention-days: 5
 
   release-artifacts:
     permissions: # Needed for 'gh release upload'.

AGENTS.md

@@ -10,18 +10,18 @@ This file (`AGENTS.md`) is a short pointer + quick reference for agents that don
 
 ## Quick command reference
 
-| Action                           | Command                                                                                                       |
-| -------------------------------- | ------------------------------------------------------------------------------------------------------------- |
-| Build a firmware variant         | `pio run -e <env>` (e.g. `pio run -e rak4631`, `pio run -e heltec-v3`)                                        |
-| Build native macOS host binary   | `pio run -e native-macos` (Homebrew prereqs + CH341 LoRa setup in `variants/native/portduino/platformio.ini`) |
-| Clean + rebuild                  | `pio run -e <env> -t clean && pio run -e <env>`                                                               |
-| Flash a device                   | `pio run -e <env> -t upload --upload-port <port>` (or use the `pio_flash` MCP tool)                           |
-| Run firmware unit tests (native) | `pio test -e native`                                                                                          |
-| Run MCP hardware tests           | `./mcp-server/run-tests.sh`                                                                                   |
-| Live TUI test runner             | `mcp-server/.venv/bin/meshtastic-mcp-test-tui`                                                                |
-| Format before commit             | `trunk fmt`                                                                                                   |
-| Regenerate protobuf bindings     | `bin/regen-protos.sh`                                                                                         |
-| Generate CI matrix               | `./bin/generate_ci_matrix.py all [--level pr]`                                                                |
+| Action                           | Command                                                                                                                                                                                                        |
+| -------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Build a firmware variant         | `pio run -e <env>` (e.g. `pio run -e rak4631`, `pio run -e heltec-v3`)                                                                                                                                         |
+| Build native macOS host binary   | `pio run -e native-macos` (Homebrew prereqs + CH341 LoRa setup in `variants/native/portduino/platformio.ini`)                                                                                                  |
+| Clean + rebuild                  | `pio run -e <env> -t clean && pio run -e <env>`                                                                                                                                                                |
+| Flash a device                   | `pio run -e <env> -t upload --upload-port <port>` (or use the `pio_flash` MCP tool)                                                                                                                            |
+| Run firmware unit tests (native) | `~/.platformio/penv/bin/python -m platformio test -e native > /tmp/test_out.txt 2>&1` then `grep -E 'error:\|PASS\|FAIL\|succeeded\|failed' /tmp/test_out.txt` (redirect first — piping causes line-buffering) |
+| Run MCP hardware tests           | `./mcp-server/run-tests.sh`                                                                                                                                                                                    |
+| Live TUI test runner             | `mcp-server/.venv/bin/meshtastic-mcp-test-tui`                                                                                                                                                                 |
+| Format before commit             | `trunk fmt`                                                                                                                                                                                                    |
+| Regenerate protobuf bindings     | `bin/regen-protos.sh`                                                                                                                                                                                          |
+| Generate CI matrix               | `./bin/generate_ci_matrix.py all [--level pr]`                                                                                                                                                                 |
 
 ## MCP server (device + test automation)
 
@@ -108,7 +108,7 @@ Sequence these; don't parallelize on the same port.
 | `src/modules/`                    | Feature modules; `Telemetry/Sensor/` has 50+ I2C sensor drivers                                                          |
 | `variants/`                       | 200+ hardware variant definitions (`variant.h` + `platformio.ini` per board)                                             |
 | `protobufs/`                      | `.proto` definitions; regenerate with `bin/regen-protos.sh`                                                              |
-| `test/`                           | Firmware unit tests (12 suites; `pio test -e native`)                                                                    |
+| `test/`                           | Firmware unit tests (17 suites; `pio test -e native`)                                                                    |
 | `mcp-server/`                     | Python MCP server + pytest hardware integration tests                                                                    |
 | `mcp-server/tests/`               | Tiered pytest suite: `unit/`, `mesh/`, `telemetry/`, `monitor/`, `recovery/`, `ui/`, `fleet/`, `admin/`, `provisioning/` |
 | `.claude/commands/`               | Claude Code slash command bodies                                                                                         |

Dockerfile

@@ -14,7 +14,7 @@ ENV PIP_BREAK_SYSTEM_PACKAGES=1
 RUN apt-get update && apt-get install --no-install-recommends -y \
         curl wget g++ zip git ca-certificates pkg-config \
         python3-pip python3-grpc-tools \
-        libgpiod-dev libyaml-cpp-dev libbluetooth-dev libi2c-dev libuv1-dev \
+        libgpiod-dev libyaml-cpp-dev libjsoncpp-dev libbluetooth-dev libi2c-dev libuv1-dev \
         libusb-1.0-0-dev libulfius-dev liborcania-dev libssl-dev \
         libx11-dev libinput-dev libxkbcommon-x11-dev libsqlite3-dev libsdl2-dev \
     && apt-get clean && rm -rf /var/lib/apt/lists/* \
@@ -53,7 +53,7 @@ ENV TZ=Etc/UTC
 USER root
 
 RUN apt-get update && apt-get --no-install-recommends -y install \
-        libc-bin libc6 libgpiod3 libyaml-cpp0.8 libi2c0 libuv1t64 libusb-1.0-0-dev \
+        libc-bin libc6 libgpiod3 libyaml-cpp0.8 libjsoncpp26 libi2c0 libuv1t64 libusb-1.0-0-dev \
         liborcania2.3 libulfius2.7t64 libssl3t64 \
         libx11-6 libinput10 libxkbcommon-x11-0 libsdl2-2.0-0 \
     && apt-get clean && rm -rf /var/lib/apt/lists/* \

Dockerfile.test

@@ -7,7 +7,7 @@ ENV PIP_ROOT_USER_ACTION=ignore
 # hadolint ignore=DL3008
 RUN apt-get update && apt-get install --no-install-recommends -y \
         g++ git ca-certificates pkg-config \
-        libgpiod-dev libyaml-cpp-dev libbluetooth-dev libi2c-dev libuv1-dev \
+        libgpiod-dev libyaml-cpp-dev libjsoncpp-dev libbluetooth-dev libi2c-dev libuv1-dev \
         libusb-1.0-0-dev libulfius-dev liborcania-dev libssl-dev \
         libx11-dev libinput-dev libxkbcommon-x11-dev libsqlite3-dev libsdl2-dev \
     && apt-get clean && rm -rf /var/lib/apt/lists/* \

alpine.Dockerfile

@@ -16,7 +16,7 @@ ENV PIP_BREAK_SYSTEM_PACKAGES=1
 RUN apk --no-cache add \
         bash g++ libstdc++-dev linux-headers zip git ca-certificates libbsd-dev \
         py3-pip py3-grpcio-tools \
-        libgpiod-dev yaml-cpp-dev bluez-dev \
+        libgpiod-dev yaml-cpp-dev jsoncpp-dev bluez-dev \
         libusb-dev i2c-tools-dev libuv-dev openssl-dev pkgconf argp-standalone \
         libx11-dev libinput-dev libxkbcommon-dev sqlite-dev sdl2-dev \
     && rm -rf /var/cache/apk/* \
@@ -48,7 +48,7 @@ LABEL org.opencontainers.image.title="Meshtastic" \
 USER root
 
 RUN apk --no-cache add \
-        shadow libstdc++ libbsd libgpiod yaml-cpp libusb \
+        shadow libstdc++ libbsd libgpiod yaml-cpp jsoncpp libusb \
         i2c-tools libuv libx11 libinput libxkbcommon sdl2 \
     && rm -rf /var/cache/apk/* \
     && mkdir -p /var/lib/meshtasticd \

bin/collect_sizes.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+
+"""Collect firmware binary sizes from manifest (.mt.json) files into a single report."""
+
+import json
+import os
+import sys
+
+
+def collect_sizes(manifest_dir):
+    """Scan manifest_dir for .mt.json files and return {board: size_bytes} dict."""
+    sizes = {}
+    for fname in sorted(os.listdir(manifest_dir)):
+        if not fname.endswith(".mt.json"):
+            continue
+        path = os.path.join(manifest_dir, fname)
+        with open(path) as f:
+            data = json.load(f)
+        board = data.get("platformioTarget", fname.replace(".mt.json", ""))
+        # Find the main firmware .bin size (largest .bin, excluding OTA/littlefs/bleota)
+        bin_size = None
+        for entry in data.get("files", []):
+            name = entry.get("name", "")
+            if name.startswith("firmware-") and name.endswith(".bin"):
+                bin_size = entry["bytes"]
+                break
+        # Fallback: any .bin that isn't ota/littlefs/bleota
+        if bin_size is None:
+            for entry in data.get("files", []):
+                name = entry.get("name", "")
+                if name.endswith(".bin") and not any(
+                    x in name for x in ["littlefs", "bleota", "ota"]
+                ):
+                    bin_size = entry["bytes"]
+                    break
+        if bin_size is not None:
+            sizes[board] = bin_size
+    return sizes
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 3:
+        print(f"Usage: {sys.argv[0]} <manifest_dir> <output.json>", file=sys.stderr)
+        sys.exit(1)
+
+    manifest_dir = sys.argv[1]
+    output_path = sys.argv[2]
+
+    sizes = collect_sizes(manifest_dir)
+    with open(output_path, "w") as f:
+        json.dump(sizes, f, indent=2, sort_keys=True)
+
+    print(f"Collected sizes for {len(sizes)} targets -> {output_path}")

bin/config.d/lora-RAK6421-13300-slot2.yaml

@@ -5,7 +5,9 @@ Meta:
     - raspberry-pi
 
 Lora:
-  ### RAK13300 in Slot 2 pins
+  
+  ### RAK13300 in Slot 2
+  Module: sx1262
   IRQ: 18 #IO6
   Reset: 24 # IO4
   Busy: 19 # IO5
@@ -13,5 +15,7 @@ Lora:
   Enable_Pins:
     - 26
     - 23
+  DIO3_TCXO_VOLTAGE: true
+  DIO2_AS_RF_SWITCH: true
   spidev: spidev0.1
   # CS: 7

bin/config.d/lora-RAK6421-13302-slot2.yaml

@@ -5,14 +5,18 @@ Meta:
     - raspberry-pi
 
 Lora:
-  ### RAK13302 in Slot 2 pins
+
+  ### RAK13302 in Slot 2
+  Module: sx1262
   IRQ: 18 #IO6
   Reset: 24 # IO4
   Busy: 19 # IO5
-  # Ant_sw: 23 # IO3 
+  # Ant_sw: 23 # IO3
   Enable_Pins:
     - 26
     - 23
+  DIO3_TCXO_VOLTAGE: true
+  DIO2_AS_RF_SWITCH: true
   spidev: spidev0.1
   # CS: 7
   TX_GAIN_LORA: [9, 9, 10, 11, 9, 8, 9, 10, 10, 10, 11, 12, 12, 12, 12, 12, 12, 12, 12, 10, 9, 8]

bin/shame.py

@@ -1,95 +0,0 @@
-import sys
-import os
-import json
-from github import Github
-
-def parseFile(path):
-    with open(path, "r") as f:
-        data = json.loads(f)
-    for file in data["files"]:
-        if file["name"].endswith(".bin"):
-            return file["name"], file["bytes"]
-
-if len(sys.argv) != 4:
-    print(f"expected usage: {sys.argv[0]} <PR number> <path to old-manifests> <path to new-manifests>")
-    sys.exit(1)
-
-pr_number = int(sys.argv[1])
-
-token = os.getenv("GITHUB_TOKEN")
-if not token:
-    raise EnvironmentError("GITHUB_TOKEN not found in environment.")
-
-repo_name = os.getenv("GITHUB_REPOSITORY")  # "owner/repo"
-if not repo_name:
-    raise EnvironmentError("GITHUB_REPOSITORY not found in environment.")
-
-oldFiles = sys.argv[2]
-old = set(os.path.join(oldFiles, f) for f in os.listdir(oldFiles) if os.path.isfile(f))
-newFiles = sys.argv[3]
-new = set(os.path.join(newFiles, f) for f in os.listdir(newFiles) if os.path.isfile(f))
-
-startMarkdown = "# Target Size Changes\n\n"
-markdown = ""
-
-newlyIntroduced = new - old
-if len(newlyIntroduced) > 0:
-    markdown += "## Newly Introduced Targets\n\n"
-    # create a table
-    markdown += "| File | Size |\n"
-    markdown += "| ---- | ---- |\n"
-    for f in newlyIntroduced:
-        name, size = parseFile(f)
-        markdown += f"| `{name}` | {size}b |\n"
-
-# do not log removed targets
-# PRs only run a small subset of builds, so removed targets are not meaningful
-# since they are very likely to just be not ran in PR CI
-
-both = old & new
-degradations = []
-improvements = []
-for f in both:
-    oldName, oldSize = parseFile(f)
-    _, newSize = parseFile(f)
-    if oldSize != newSize:
-        if newSize < oldSize:
-            improvements.append((oldName, oldSize, newSize))
-        else:
-            degradations.append((oldName, oldSize, newSize))
-
-if len(degradations) > 0:
-    markdown += "\n## Degradation\n\n"
-    # create a table
-    markdown += "| File | Difference | Old Size | New Size |\n"
-    markdown += "| ---- | ---------- | -------- | -------- |\n"
-    for oldName, oldSize, newSize in degradations:
-        markdown += f"| `{oldName}` | **{oldSize - newSize}b** | {oldSize}b | {newSize}b |\n"
-
-if len(improvements) > 0:
-    markdown += "\n## Improvement\n\n"
-    # create a table
-    markdown += "| File | Difference | Old Size | New Size |\n"
-    markdown += "| ---- | ---------- | -------- | -------- |\n"
-    for oldName, oldSize, newSize in improvements:
-        markdown += f"| `{oldName}` | **{oldSize - newSize}b** | {oldSize}b | {newSize}b |\n"
-
-if len(markdown) == 0:
-    markdown = "No changes in target sizes detected."
-
-g = Github(token)
-repo = g.get_repo(repo_name)
-pr = repo.get_pull(pr_number)
-
-existing_comment = None
-for comment in pr.get_issue_comments():
-    if comment.body.startswith(startMarkdown):
-        existing_comment = comment
-        break
-
-final_markdown = startMarkdown + markdown
-
-if existing_comment:
-    existing_comment.edit(body=final_markdown)
-else:
-    pr.create_issue_comment(body=final_markdown)

bin/size_report.py

@@ -0,0 +1,171 @@
+#!/usr/bin/env python3
+
+"""Compare firmware size reports and generate a markdown summary.
+
+Usage:
+    size_report.py <new_sizes.json> [--baseline <label>:<old_sizes.json>]...
+
+Examples:
+    # Compare PR against develop and master baselines
+    size_report.py pr.json --baseline develop:develop.json --baseline master:master.json
+
+    # Single baseline comparison
+    size_report.py pr.json --baseline develop:develop.json
+
+    # No baselines — shows sizes with blank delta columns
+    size_report.py pr.json
+"""
+
+import argparse
+import json
+import sys
+
+
+def load_sizes(path):
+    with open(path) as f:
+        return json.load(f)
+
+
+def format_delta(n):
+    """Format byte delta with sign and human-friendly suffix."""
+    sign = "+" if n > 0 else ""
+    if abs(n) >= 1024:
+        return f"{sign}{n:,} ({sign}{n / 1024:.1f} KB)"
+    return f"{sign}{n:,}"
+
+
+def generate_markdown(new_sizes, baselines, top_n=5):
+    """Generate a single table with current size and delta columns per baseline.
+
+    baselines: list of (label, old_sizes_dict), may be empty
+    """
+    labels = [label for label, _ in baselines]
+
+    # Build rows: (board, current_size, [(delta, abs_delta) per baseline])
+    rows = []
+    for board in sorted(new_sizes):
+        current = new_sizes[board]
+        deltas = []
+        for _, old_sizes in baselines:
+            old = old_sizes.get(board)
+            if old is not None:
+                d = current - old
+                deltas.append((d, abs(d)))
+            else:
+                deltas.append((None, 0))
+        # Sort key: max abs delta across baselines (biggest changes first)
+        max_abs = max((ad for _, ad in deltas), default=0)
+        rows.append((board, current, deltas, max_abs))
+
+    rows.sort(key=lambda r: r[3], reverse=True)
+
+    # Summary line
+    sections = []
+    summary_parts = [f"{len(new_sizes)} targets"]
+    for i, (label, old_sizes) in enumerate(baselines):
+        increases = sum(
+            1 for _, _, deltas, _ in rows if deltas[i][0] is not None and deltas[i][0] > 0
+        )
+        decreases = sum(
+            1 for _, _, deltas, _ in rows if deltas[i][0] is not None and deltas[i][0] < 0
+        )
+        net = sum(
+            deltas[i][0] for _, _, deltas, _ in rows if deltas[i][0] is not None
+        )
+        parts = []
+        if increases:
+            parts.append(f"{increases} increased")
+        if decreases:
+            parts.append(f"{decreases} decreased")
+        if parts:
+            parts.append(f"net {format_delta(net)}")
+            summary_parts.append(f"vs `{label}`: {', '.join(parts)}")
+        else:
+            summary_parts.append(f"vs `{label}`: no changes")
+
+    if not baselines:
+        summary_parts.append("no baseline available yet")
+
+    sections.append(f"**{' | '.join(summary_parts)}**\n")
+
+    # Table header
+    header = "| Target | Size |"
+    separator = "|--------|-----:|"
+    for label in labels:
+        header += f" vs `{label}` |"
+        separator += "----------:|"
+    sections.append(header)
+    sections.append(separator)
+
+    def format_row(board, current, deltas):
+        row = f"| `{board}` | {current:,} |"
+        for d, _ in deltas:
+            if d is None:
+                row += " |"
+            elif d == 0:
+                row += " 0 |"
+            else:
+                icon = "📈" if d > 0 else "📉"
+                row += f" {icon} {format_delta(d)} |"
+        return row
+
+    # Top N rows always visible
+    top = rows[:top_n]
+    for board, current, deltas, _ in top:
+        sections.append(format_row(board, current, deltas))
+
+    # Remaining rows in expandable section
+    rest = rows[top_n:]
+    if rest:
+        sections.append("")
+        sections.append(
+            f"<details><summary>Show {len(rest)} more target(s)</summary>\n"
+        )
+        sections.append(header)
+        sections.append(separator)
+        for board, current, deltas, _ in rest:
+            sections.append(format_row(board, current, deltas))
+        sections.append("\n</details>")
+
+    sections.append("")
+    return "\n".join(sections)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Compare firmware size reports")
+    parser.add_argument("new_sizes", help="Path to new sizes JSON")
+    parser.add_argument(
+        "--baseline",
+        action="append",
+        default=[],
+        metavar="LABEL:PATH",
+        help="Baseline to compare against (e.g. develop:develop.json)",
+    )
+    parser.add_argument(
+        "--top",
+        type=int,
+        default=5,
+        help="Number of top changes to show before collapsing (default: 5)",
+    )
+    args = parser.parse_args()
+
+    new_sizes = load_sizes(args.new_sizes)
+
+    # Silence output when no targets were built — repo maintainer choice
+    if not new_sizes:
+        return
+
+    baselines = []
+    for b in args.baseline:
+        if ":" not in b:
+            print(f"Error: baseline must be LABEL:PATH, got '{b}'", file=sys.stderr)
+            sys.exit(1)
+        label, path = b.split(":", 1)
+        baselines.append((label, load_sizes(path)))
+
+    md = generate_markdown(new_sizes, baselines, top_n=args.top)
+    print(md)
+
+
+if __name__ == "__main__":
+    main()

bin/test_size_scripts.py

@@ -0,0 +1,262 @@
+#!/usr/bin/env python3
+
+"""Tests for bin/collect_sizes.py and bin/size_report.py."""
+
+import json
+import os
+import subprocess
+import sys
+import tempfile
+
+SCRIPTS_DIR = os.path.join(os.path.dirname(__file__), "..", "bin")
+
+
+def make_manifest(target, firmware_bytes, extra_files=None):
+    """Create a minimal .mt.json manifest dict."""
+    files = [{"name": f"firmware-{target}-2.6.0.bin", "bytes": firmware_bytes}]
+    if extra_files:
+        files.extend(extra_files)
+    return {
+        "platformioTarget": target,
+        "version": "2.6.0.test",
+        "files": files,
+    }
+
+
+def write_manifests(tmpdir, manifests):
+    """Write manifest dicts as .mt.json files into tmpdir."""
+    for target, data in manifests.items():
+        path = os.path.join(tmpdir, f"firmware-{target}.mt.json")
+        with open(path, "w") as f:
+            json.dump(data, f)
+
+
+def run_script(script, args):
+    """Run a Python script and return (returncode, stdout, stderr)."""
+    result = subprocess.run(
+        [sys.executable, os.path.join(SCRIPTS_DIR, script)] + args,
+        capture_output=True,
+        text=True,
+    )
+    return result.returncode, result.stdout, result.stderr
+
+
+def test_collect_sizes_basic():
+    """collect_sizes picks up firmware-*.bin entries from manifests."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        outfile = os.path.join(tmpdir, "sizes.json")
+        manifests = {
+            "heltec-v3": make_manifest("heltec-v3", 1048576),
+            "rak4631": make_manifest("rak4631", 524288),
+            "tbeam": make_manifest("tbeam", 786432),
+        }
+        write_manifests(tmpdir, manifests)
+
+        rc, stdout, stderr = run_script("collect_sizes.py", [tmpdir, outfile])
+        assert rc == 0, f"collect_sizes failed: {stderr}"
+        assert "3 targets" in stdout
+
+        with open(outfile) as f:
+            sizes = json.load(f)
+        assert sizes == {"heltec-v3": 1048576, "rak4631": 524288, "tbeam": 786432}
+
+
+def test_collect_sizes_fallback_bin():
+    """collect_sizes falls back to non-firmware-prefixed .bin if no firmware-*.bin."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        outfile = os.path.join(tmpdir, "sizes.json")
+        # Manifest with only a generic .bin (no firmware- prefix)
+        data = {
+            "platformioTarget": "custom-board",
+            "files": [
+                {"name": "littlefs-custom-board.bin", "bytes": 100000},
+                {"name": "custom-board.bin", "bytes": 500000},
+            ],
+        }
+        path = os.path.join(tmpdir, "firmware-custom-board.mt.json")
+        with open(path, "w") as f:
+            json.dump(data, f)
+
+        rc, stdout, stderr = run_script("collect_sizes.py", [tmpdir, outfile])
+        assert rc == 0, f"collect_sizes failed: {stderr}"
+
+        with open(outfile) as f:
+            sizes = json.load(f)
+        assert sizes == {"custom-board": 500000}
+
+
+def test_collect_sizes_skips_ota_littlefs():
+    """collect_sizes ignores ota/littlefs/bleota .bin files in fallback."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        outfile = os.path.join(tmpdir, "sizes.json")
+        data = {
+            "platformioTarget": "board-x",
+            "files": [
+                {"name": "littlefs-board-x.bin", "bytes": 100000},
+                {"name": "bleota-board-x.bin", "bytes": 50000},
+                {"name": "mt-board-x-ota.bin", "bytes": 60000},
+            ],
+        }
+        path = os.path.join(tmpdir, "firmware-board-x.mt.json")
+        with open(path, "w") as f:
+            json.dump(data, f)
+
+        rc, stdout, stderr = run_script("collect_sizes.py", [tmpdir, outfile])
+        assert rc == 0
+        with open(outfile) as f:
+            sizes = json.load(f)
+        # No valid firmware .bin found, board should be absent
+        assert sizes == {}
+
+
+def test_collect_sizes_ignores_non_mt_json():
+    """collect_sizes skips non .mt.json files."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        outfile = os.path.join(tmpdir, "sizes.json")
+        # Write a valid manifest
+        manifests = {"rak4631": make_manifest("rak4631", 500000)}
+        write_manifests(tmpdir, manifests)
+        # Write a decoy file
+        with open(os.path.join(tmpdir, "readme.txt"), "w") as f:
+            f.write("not a manifest")
+
+        rc, stdout, stderr = run_script("collect_sizes.py", [tmpdir, outfile])
+        assert rc == 0
+        with open(outfile) as f:
+            sizes = json.load(f)
+        assert list(sizes.keys()) == ["rak4631"]
+
+
+def test_size_report_no_baseline():
+    """size_report with no baselines shows sizes only."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        sizes_file = os.path.join(tmpdir, "new.json")
+        with open(sizes_file, "w") as f:
+            json.dump({"heltec-v3": 1000000, "rak4631": 500000}, f)
+
+        rc, stdout, stderr = run_script("size_report.py", [sizes_file])
+        assert rc == 0, f"size_report failed: {stderr}"
+        assert "2 targets" in stdout
+        assert "no baseline available yet" in stdout
+        assert "`heltec-v3`" in stdout
+        assert "`rak4631`" in stdout
+
+
+def test_size_report_with_baseline():
+    """size_report shows deltas against a baseline."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        new_file = os.path.join(tmpdir, "new.json")
+        old_file = os.path.join(tmpdir, "old.json")
+        with open(new_file, "w") as f:
+            json.dump({"heltec-v3": 1050000, "rak4631": 500000, "tbeam": 800000}, f)
+        with open(old_file, "w") as f:
+            json.dump({"heltec-v3": 1000000, "rak4631": 500000, "tbeam": 810000}, f)
+
+        rc, stdout, stderr = run_script(
+            "size_report.py", [new_file, "--baseline", f"develop:{old_file}"]
+        )
+        assert rc == 0, f"size_report failed: {stderr}"
+        assert "3 targets" in stdout
+        assert "1 increased" in stdout
+        assert "1 decreased" in stdout
+        # heltec-v3 grew by 50000
+        assert "📈" in stdout
+        # tbeam shrank by 10000
+        assert "📉" in stdout
+        # rak4631 unchanged
+        assert "vs `develop`" in stdout
+
+
+def test_size_report_multiple_baselines():
+    """size_report handles multiple baselines."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        new_file = os.path.join(tmpdir, "new.json")
+        dev_file = os.path.join(tmpdir, "develop.json")
+        master_file = os.path.join(tmpdir, "master.json")
+        with open(new_file, "w") as f:
+            json.dump({"board-a": 100000}, f)
+        with open(dev_file, "w") as f:
+            json.dump({"board-a": 95000}, f)
+        with open(master_file, "w") as f:
+            json.dump({"board-a": 90000}, f)
+
+        rc, stdout, stderr = run_script(
+            "size_report.py",
+            [new_file, "--baseline", f"develop:{dev_file}", "--baseline", f"master:{master_file}"],
+        )
+        assert rc == 0, f"size_report failed: {stderr}"
+        assert "vs `develop`" in stdout
+        assert "vs `master`" in stdout
+
+
+def test_size_report_new_target_no_baseline_entry():
+    """size_report handles targets not present in baseline (new boards)."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        new_file = os.path.join(tmpdir, "new.json")
+        old_file = os.path.join(tmpdir, "old.json")
+        with open(new_file, "w") as f:
+            json.dump({"new-board": 300000, "existing": 500000}, f)
+        with open(old_file, "w") as f:
+            json.dump({"existing": 500000}, f)
+
+        rc, stdout, stderr = run_script(
+            "size_report.py", [new_file, "--baseline", f"develop:{old_file}"]
+        )
+        assert rc == 0, f"size_report failed: {stderr}"
+        assert "`new-board`" in stdout
+        assert "no changes" in stdout  # only existing is compared, delta=0
+
+
+def test_size_report_all_unchanged():
+    """size_report shows 'no changes' when all sizes match."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        sizes_file = os.path.join(tmpdir, "sizes.json")
+        with open(sizes_file, "w") as f:
+            json.dump({"board-a": 100000, "board-b": 200000}, f)
+
+        rc, stdout, stderr = run_script(
+            "size_report.py", [sizes_file, "--baseline", f"develop:{sizes_file}"]
+        )
+        assert rc == 0, f"size_report failed: {stderr}"
+        assert "no changes" in stdout
+
+
+def test_collect_sizes_bad_args():
+    """collect_sizes exits with error on wrong arg count."""
+    rc, stdout, stderr = run_script("collect_sizes.py", [])
+    assert rc == 1
+    assert "Usage" in stderr
+
+
+def test_size_report_bad_baseline_format():
+    """size_report exits with error on malformed --baseline."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        sizes_file = os.path.join(tmpdir, "sizes.json")
+        with open(sizes_file, "w") as f:
+            json.dump({"x": 1}, f)
+
+        rc, stdout, stderr = run_script(
+            "size_report.py", [sizes_file, "--baseline", "no-colon-here"]
+        )
+        assert rc == 1
+        assert "LABEL:PATH" in stderr
+
+
+if __name__ == "__main__":
+    tests = [v for k, v in globals().items() if k.startswith("test_")]
+    passed = 0
+    failed = 0
+    for test in tests:
+        try:
+            test()
+            print(f"  PASS: {test.__name__}")
+            passed += 1
+        except AssertionError as e:
+            print(f"  FAIL: {test.__name__}: {e}")
+            failed += 1
+        except Exception as e:
+            print(f"  ERROR: {test.__name__}: {type(e).__name__}: {e}")
+            failed += 1
+
+    print(f"\n{passed} passed, {failed} failed out of {passed + failed}")
+    sys.exit(1 if failed else 0)

debian/control

@@ -14,6 +14,7 @@ Build-Depends: debhelper-compat (= 13),
                g++,
                pkg-config,
                libyaml-cpp-dev,
+               libjsoncpp-dev,
                libgpiod-dev,
                libbluetooth-dev,
                libusb-1.0-0-dev,

mcp-server/run-tests.sh

@@ -191,10 +191,12 @@ echo
 # PASS/FAIL — every hardware test would SKIP with "role not present". We
 # narrow to tests/unit explicitly so the summary reads as "no hardware,
 # unit suite only" instead of "big skip count looks suspicious".
+# Keep terminal output condensed (`-q -r fE`) so skip-heavy runs do not print
+# each skipped test in full; skip counts still appear in pytest's summary.
 if [[ -z $DETECTED && $# -eq 0 ]]; then
 	echo "[pre-flight] no supported devices detected; running unit tier only."
 	echo
-	exec "$VENV_PY" -m pytest tests/unit -v --report-log=tests/reportlog.jsonl
+	exec "$VENV_PY" -m pytest tests/unit -q -r fE --report-log=tests/reportlog.jsonl
 fi
 
 # Default pytest args when the user passed none. Power users can invoke
@@ -210,11 +212,13 @@ fi
 # skipping half the hardware tests with "not baked with session profile"
 # errors. Power users who know their hardware is current and want to shave
 # those seconds can pass `--assume-baked` explicitly.
+# Defaults also use condensed reporting (`-q -r fE`) to avoid listing every
+# skipped test verbatim while still surfacing failures/errors and summary data.
 if [[ $# -eq 0 ]]; then
 	set -- tests/ \
 		--html=tests/report.html --self-contained-html \
 		--junitxml=tests/junit.xml \
-		-v --tb=short
+		-q -r fE --tb=short
 fi
 
 # UI tier requires opencv-python-headless (and ideally easyocr). If it's

meshtasticd.spec.rpkg

@@ -34,6 +34,7 @@ BuildRequires: python3dist(grpcio-tools)
 BuildRequires: git-core
 BuildRequires: gcc-c++
 BuildRequires: pkgconfig(yaml-cpp)
+BuildRequires: pkgconfig(jsoncpp)
 BuildRequires: pkgconfig(libgpiod)
 BuildRequires: pkgconfig(bluez)
 BuildRequires: pkgconfig(libusb-1.0)

platformio.ini

@@ -8,10 +8,30 @@ 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 =
@@ -103,7 +123,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/>
+build_src_filter = ${env.build_src_filter} -<platform/portduino/> -<graphics/niche/> -<graphics/eink/>
 
 ; Common libs for communicating over TCP/IP networks such as MQTT
 [networking_base]
@@ -208,16 +228,10 @@ lib_deps =
 	https://github.com/adafruit/Adafruit_BMP3XX/archive/refs/tags/2.1.6.zip
 	# renovate: datasource=github-tags depName=Adafruit MAX1704X packageName=adafruit/Adafruit_MAX1704X
 	https://github.com/adafruit/Adafruit_MAX1704X/archive/refs/tags/1.0.3.zip
-	# renovate: datasource=github-tags depName=Adafruit SHTC3 packageName=adafruit/Adafruit_SHTC3
-	https://github.com/adafruit/Adafruit_SHTC3/archive/refs/tags/1.0.2.zip
 	# renovate: datasource=github-tags depName=Adafruit LPS2X packageName=adafruit/Adafruit_LPS2X
 	https://github.com/adafruit/Adafruit_LPS2X/archive/refs/tags/2.0.6.zip
-	# renovate: datasource=github-tags depName=Adafruit SHT31 packageName=adafruit/Adafruit_SHT31
-	https://github.com/adafruit/Adafruit_SHT31/archive/refs/tags/2.2.2.zip
 	# renovate: datasource=github-tags depName=Adafruit VEML7700 packageName=adafruit/Adafruit_VEML7700
 	https://github.com/adafruit/Adafruit_VEML7700/archive/refs/tags/2.1.6.zip
-	# renovate: datasource=github-tags depName=Adafruit SHT4x packageName=adafruit/Adafruit_SHT4X
-	https://github.com/adafruit/Adafruit_SHT4X/archive/refs/tags/1.0.5.zip
 	# renovate: datasource=github-tags depName=SparkFun Qwiic Scale NAU7802 packageName=sparkfun/SparkFun_Qwiic_Scale_NAU7802_Arduino_Library
 	https://github.com/sparkfun/SparkFun_Qwiic_Scale_NAU7802_Arduino_Library/archive/refs/tags/v1.0.6.zip
 	# renovate: datasource=custom.pio depName=ClosedCube OPT3001 packageName=closedcube/library/ClosedCube OPT3001

src/DisplayFormatters.cpp

@@ -51,6 +51,12 @@ const char *DisplayFormatters::getModemPresetDisplayName(meshtastic_Config_LoRaC
     case PRESET(NARROW_SLOW):
         return useShortName ? "NarS" : "NarrowSlow";
         break;
+    case PRESET(TINY_FAST):
+        return useShortName ? "TinyF" : "TinyFast";
+        break;
+    case PRESET(TINY_SLOW):
+        return useShortName ? "TinyS" : "TinySlow";
+        break;
     default:
         return useShortName ? "Custom" : "Invalid";
         break;

src/MessageStore.cpp

@@ -1,5 +1,5 @@
 #include "configuration.h"
-#if HAS_SCREEN
+#if HAS_SCREEN || defined(MESHTASTIC_INCLUDE_NICHE_GRAPHICS)
 #include "FSCommon.h"
 #include "MessageStore.h"
 #include "NodeDB.h"

src/MessageStore.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#if HAS_SCREEN
+#if HAS_SCREEN || defined(MESHTASTIC_INCLUDE_NICHE_GRAPHICS)
 
 // Disable debug logging entirely on release builds of HELTEC_MESH_SOLAR for space constraints
 #if defined(HELTEC_MESH_SOLAR)

src/RF95Configuration.h

@@ -1,6 +1,16 @@
 // TODO refactor this out with better radio configuration system
 #ifdef USE_RF95
+
+#ifndef RF95_RESET
 #define RF95_RESET LORA_RESET
-#define RF95_IRQ LORA_DIO0  // on SX1262 version this is a no connect DIO0
+#endif
+
+#ifndef RF95_IRQ
+#define RF95_IRQ LORA_DIO0 // on SX1262 version this is a no connect DIO0
+#endif
+
+#ifndef RF95_DIO1
 #define RF95_DIO1 LORA_DIO1 // Note: not really used for RF95, but used for pure SX127x
 #endif
+
+#endif

src/RedirectablePrint.cpp

@@ -51,7 +51,7 @@ size_t RedirectablePrint::write(uint8_t c)
 size_t RedirectablePrint::vprintf(const char *logLevel, const char *format, va_list arg)
 {
     va_list copy;
-#if ENABLE_JSON_LOGGING || ARCH_PORTDUINO
+#if ARCH_PORTDUINO
     static char printBuf[512];
 #else
     static char printBuf[160];

src/concurrency/Lock.cpp

@@ -1,7 +1,6 @@
 #include "Lock.h"
 #include "configuration.h"
 #include <cassert>
-#include <logging.h>
 
 namespace concurrency
 {
@@ -34,33 +33,13 @@ void Lock::unlock()
     }
 }
 #else
-Lock::Lock()
-{
-    pthread_mutex_init(&mutex, NULL);
-}
+Lock::Lock() {}
 
-void Lock::lock()
-{
-    if (locked) {
-        LOG_INFO("Attempt to lock an already locked Lock!");
-    }
-    pthread_mutex_lock(&mutex);
-    locked = true;
+Lock::~Lock() {}
 
-    if (console)
-        LOG_WARN("Lock");
-}
+void Lock::lock() {}
 
-void Lock::unlock()
-{
-    pthread_mutex_unlock(&mutex);
-    locked = false;
-}
-
-Lock::~Lock()
-{
-    pthread_mutex_destroy(&mutex);
-}
+void Lock::unlock() {}
 #endif
 
 } // namespace concurrency

src/concurrency/Lock.h

@@ -30,9 +30,6 @@ class Lock
   private:
 #ifdef HAS_FREE_RTOS
     SemaphoreHandle_t handle;
-#else
-    pthread_mutex_t mutex;
-    bool locked = false;
 #endif
 };
 

src/configuration.h

@@ -31,6 +31,11 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #endif
 #if __has_include("SensorRtcHelper.hpp")
 #include "SensorRtcHelper.hpp"
+// SensorLib defines isBitSet as a macro; undefine it here to avoid conflicts
+// with the SparkFun MMC5983MA library, which has a class method of the same name.
+#ifdef isBitSet
+#undef isBitSet
+#endif
 #endif
 
 /* Offer chance for variant-specific defines */

src/graphics/BaseUIEInkDisplay.cpp

@@ -0,0 +1,211 @@
+#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

@@ -0,0 +1,98 @@
+/*
+
+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

@@ -1,298 +0,0 @@
-#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

@@ -1,106 +0,0 @@
-#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

@@ -1,564 +0,0 @@
-#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

@@ -1,155 +0,0 @@
-#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

@@ -1,427 +0,0 @@
-#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

@@ -1,69 +0,0 @@
-#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

@@ -1,135 +0,0 @@
-// 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,9 +27,14 @@ 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"
@@ -50,6 +55,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "MeshService.h"
 #include "MessageStore.h"
 #include "RadioLibInterface.h"
+#include "SPILock.h"
 #include "error.h"
 #include "gps/GeoCoord.h"
 #include "gps/RTC.h"
@@ -442,14 +448,9 @@ 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(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_EINK) && defined(MESHTASTIC_INCLUDE_NICHE_GRAPHICS)
+    // NicheGraphics-backed BaseUI E-Ink path. Variant provides setupNicheGraphicsBaseUI() in its nicheGraphics.h.
+    dispdev = setupNicheGraphicsBaseUI();
 #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);
@@ -655,6 +656,10 @@ void Screen::setup()
         brightness = uiconfig.screen_brightness;
     }
 
+    // Restore which frames the user has hidden (persisted across reboots).
+    // Must happen before the first setFrames().
+    loadFrameVisibility();
+
     // Detect OLED subtype (if supported by board variant)
 #ifdef AutoOLEDWire_h
     if (isAUTOOled)
@@ -843,10 +848,8 @@ void Screen::forceDisplay(bool forceUiUpdate)
     }
 
     // Tell EInk class to update the display
-#if defined(USE_EINK_PARALLELDISPLAY)
-    static_cast<EInkParallelDisplay *>(dispdev)->forceDisplay();
-#elif defined(USE_EINK)
-    static_cast<EInkDisplay *>(dispdev)->forceDisplay();
+#if defined(MESHTASTIC_INCLUDE_NICHE_GRAPHICS)
+    static_cast<NicheGraphics::BaseUIEInkDisplay *>(dispdev)->forceDisplay();
 #endif
 #else
     // No delay between UI frame rendering
@@ -1033,12 +1036,7 @@ int32_t Screen::runOnce()
             NotificationRenderer::current_notification_type != notificationTypeEnum::text_input &&
             !Throttle::isWithinTimespanMs(lastScreenTransition, config.display.auto_screen_carousel_secs * 1000)) {
 
-            // 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
-
+            // Carousel rotations let BaseUIEInkDisplay's DisplayHealth debt model decide FAST vs FULL.
             LOG_DEBUG("LastScreenTransition exceeded %ums transition to next frame", (millis() - lastScreenTransition));
             handleOnPress();
         }
@@ -1072,11 +1070,8 @@ void Screen::setScreensaverFrames(FrameCallback einkScreensaver)
     static FrameCallback screensaverFrame;
     static OverlayCallback screensaverOverlay;
 
-#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.
+    // Join (await) any currently running async refresh before drawing the screensaver frame.
     EINK_JOIN_ASYNCREFRESH(dispdev);
-#endif
 
     // If: one-off screensaver frame passed as argument. Handles doDeepSleep()
     if (einkScreensaver != NULL) {
@@ -1099,23 +1094,17 @@ void Screen::setScreensaverFrames(FrameCallback einkScreensaver)
         updateUiFrame(ui);
     } while (ui->getUiState()->lastUpdate < startUpdate);
 
-#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
+#if defined(MESHTASTIC_INCLUDE_NICHE_GRAPHICS)
+    static_cast<NicheGraphics::BaseUIEInkDisplay *>(dispdev)->forceDisplay(0);
 #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 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
+    // 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);
 }
 #endif
 
@@ -1416,6 +1405,9 @@ void Screen::toggleFrameVisibility(const std::string &frameName)
     if (frameName == "chirpy") {
         hiddenFrames.chirpy = !hiddenFrames.chirpy;
     }
+
+    // Save the new visibility state so it survives a reboot.
+    saveFrameVisibility();
 }
 
 bool Screen::isFrameHidden(const std::string &frameName) const
@@ -1454,6 +1446,167 @@ bool Screen::isFrameHidden(const std::string &frameName) const
     return false;
 }
 
+// ---------------------------------------------------------------------------
+// Frame visibility persistence
+//
+// The set of hideable frames varies by build (USE_EINK, HAS_GPS, ...), so we
+// serialize to a fixed bitmask where each frame name owns a permanent bit
+// position. Bits for frames that don't exist in the current build are simply
+// left untouched, which keeps the saved file portable across firmware variants.
+// ---------------------------------------------------------------------------
+namespace
+{
+static const char *frameVisibilityFileName = "/prefs/framevis";
+constexpr uint32_t FRAMEVIS_MAGIC = 0x53495646; // "FVIS" little-endian
+constexpr uint8_t FRAMEVIS_VERSION = 1;
+
+// Permanent bit assignments. Never renumber these; only append new ones.
+enum FrameVisBit : uint8_t {
+    FVBIT_TEXT_MESSAGE = 0,
+    FVBIT_WAYPOINT = 1,
+    FVBIT_WIFI = 2,
+    FVBIT_SYSTEM = 3,
+    FVBIT_HOME = 4,
+    FVBIT_CLOCK = 5,
+    FVBIT_NODELIST_NODES = 6,
+    FVBIT_NODELIST_LOCATION = 7,
+    FVBIT_NODELIST_LASTHEARD = 8,
+    FVBIT_NODELIST_HOPSIGNAL = 9,
+    FVBIT_NODELIST_DISTANCE = 10,
+    FVBIT_NODELIST_BEARINGS = 11,
+    FVBIT_GPS = 12,
+    FVBIT_LORA = 13,
+    FVBIT_SHOW_FAVORITES = 14,
+    FVBIT_CHIRPY = 15,
+};
+
+struct __attribute__((packed)) FrameVisFile {
+    uint32_t magic;
+    uint8_t version;
+    uint32_t mask;
+};
+
+inline void setBit(uint32_t &mask, uint8_t bit, bool value)
+{
+    if (value)
+        mask |= (1UL << bit);
+    else
+        mask &= ~(1UL << bit);
+}
+
+inline bool getBit(uint32_t mask, uint8_t bit)
+{
+    return (mask & (1UL << bit)) != 0;
+}
+} // namespace
+
+uint32_t Screen::packHiddenFrames() const
+{
+    uint32_t mask = 0;
+    setBit(mask, FVBIT_TEXT_MESSAGE, hiddenFrames.textMessage);
+    setBit(mask, FVBIT_WAYPOINT, hiddenFrames.waypoint);
+    setBit(mask, FVBIT_WIFI, hiddenFrames.wifi);
+    setBit(mask, FVBIT_SYSTEM, hiddenFrames.system);
+    setBit(mask, FVBIT_HOME, hiddenFrames.home);
+    setBit(mask, FVBIT_CLOCK, hiddenFrames.clock);
+#ifndef USE_EINK
+    setBit(mask, FVBIT_NODELIST_NODES, hiddenFrames.nodelist_nodes);
+    setBit(mask, FVBIT_NODELIST_LOCATION, hiddenFrames.nodelist_location);
+#endif
+#ifdef USE_EINK
+    setBit(mask, FVBIT_NODELIST_LASTHEARD, hiddenFrames.nodelist_lastheard);
+    setBit(mask, FVBIT_NODELIST_HOPSIGNAL, hiddenFrames.nodelist_hopsignal);
+    setBit(mask, FVBIT_NODELIST_DISTANCE, hiddenFrames.nodelist_distance);
+#endif
+#if HAS_GPS
+#ifdef USE_EINK
+    setBit(mask, FVBIT_NODELIST_BEARINGS, hiddenFrames.nodelist_bearings);
+#endif
+    setBit(mask, FVBIT_GPS, hiddenFrames.gps);
+#endif
+    setBit(mask, FVBIT_LORA, hiddenFrames.lora);
+    setBit(mask, FVBIT_SHOW_FAVORITES, hiddenFrames.show_favorites);
+    setBit(mask, FVBIT_CHIRPY, hiddenFrames.chirpy);
+    return mask;
+}
+
+void Screen::applyHiddenFramesMask(uint32_t mask)
+{
+    hiddenFrames.textMessage = getBit(mask, FVBIT_TEXT_MESSAGE);
+    hiddenFrames.waypoint = getBit(mask, FVBIT_WAYPOINT);
+    hiddenFrames.wifi = getBit(mask, FVBIT_WIFI);
+    hiddenFrames.system = getBit(mask, FVBIT_SYSTEM);
+    hiddenFrames.home = getBit(mask, FVBIT_HOME);
+    hiddenFrames.clock = getBit(mask, FVBIT_CLOCK);
+#ifndef USE_EINK
+    hiddenFrames.nodelist_nodes = getBit(mask, FVBIT_NODELIST_NODES);
+    hiddenFrames.nodelist_location = getBit(mask, FVBIT_NODELIST_LOCATION);
+#endif
+#ifdef USE_EINK
+    hiddenFrames.nodelist_lastheard = getBit(mask, FVBIT_NODELIST_LASTHEARD);
+    hiddenFrames.nodelist_hopsignal = getBit(mask, FVBIT_NODELIST_HOPSIGNAL);
+    hiddenFrames.nodelist_distance = getBit(mask, FVBIT_NODELIST_DISTANCE);
+#endif
+#if HAS_GPS
+#ifdef USE_EINK
+    hiddenFrames.nodelist_bearings = getBit(mask, FVBIT_NODELIST_BEARINGS);
+#endif
+    hiddenFrames.gps = getBit(mask, FVBIT_GPS);
+#endif
+    hiddenFrames.lora = getBit(mask, FVBIT_LORA);
+    hiddenFrames.show_favorites = getBit(mask, FVBIT_SHOW_FAVORITES);
+    hiddenFrames.chirpy = getBit(mask, FVBIT_CHIRPY);
+}
+
+void Screen::loadFrameVisibility()
+{
+#ifdef FSCom
+    spiLock->lock();
+    auto file = FSCom.open(frameVisibilityFileName, FILE_O_READ);
+    if (file) {
+        FrameVisFile data{};
+        bool ok = file.read((uint8_t *)&data, sizeof(data)) == sizeof(data) && data.magic == FRAMEVIS_MAGIC &&
+                  data.version == FRAMEVIS_VERSION;
+        file.close();
+        spiLock->unlock();
+        if (ok) {
+            applyHiddenFramesMask(data.mask);
+            LOG_INFO("Loaded frame visibility (mask 0x%08x)", data.mask);
+        } else {
+            LOG_WARN("Frame visibility file invalid, keeping defaults");
+        }
+        return;
+    }
+    spiLock->unlock();
+    LOG_DEBUG("No saved frame visibility, using defaults");
+#endif
+}
+
+void Screen::saveFrameVisibility()
+{
+#ifdef FSCom
+    spiLock->lock();
+    FSCom.mkdir("/prefs");
+    if (FSCom.exists(frameVisibilityFileName))
+        FSCom.remove(frameVisibilityFileName);
+
+    auto file = FSCom.open(frameVisibilityFileName, FILE_O_WRITE);
+    if (file) {
+        FrameVisFile data{};
+        data.magic = FRAMEVIS_MAGIC;
+        data.version = FRAMEVIS_VERSION;
+        data.mask = packHiddenFrames();
+        file.write((uint8_t *)&data, sizeof(data));
+        file.flush();
+        file.close();
+        LOG_INFO("Saved frame visibility (mask 0x%08x)", data.mask);
+    } else {
+        LOG_WARN("Failed to open %s for writing", frameVisibilityFileName);
+    }
+    spiLock->unlock();
+#endif
+}
+
 void Screen::handleStartFirmwareUpdateScreen()
 {
     LOG_DEBUG("Show firmware screen");

src/graphics/Screen.h

@@ -87,8 +87,7 @@ class Screen
 #include <AutoOLEDWire.h>
 #endif
 
-#include "EInkDisplay2.h"
-#include "EInkDynamicDisplay.h"
+#include "BaseUIEInkDisplay.h"
 #include "PointStruct.h"
 #include "TFTDisplay.h"
 #include "TypedQueue.h"
@@ -623,6 +622,11 @@ class Screen : public concurrency::OSThread
     void toggleFrameVisibility(const std::string &frameName);
     bool isFrameHidden(const std::string &frameName) const;
 
+    // Persist / restore which frames are hidden, across reboots.
+    // Stored as a single uint32 bitmask in /prefs (see Screen.cpp for the format).
+    void loadFrameVisibility();
+    void saveFrameVisibility();
+
 #ifdef USE_EINK
     /// Draw an image to remain on E-Ink display after screen off
     void setScreensaverFrames(FrameCallback einkScreensaver = NULL);
@@ -738,6 +742,11 @@ class Screen : public concurrency::OSThread
         bool chirpy = true;
     } hiddenFrames;
 
+    // Convert hiddenFrames to a uint32 bitmask. Bit positions are fixed per
+    // frame name (see Screen.cpp).
+    uint32_t packHiddenFrames() const;
+    void applyHiddenFramesMask(uint32_t mask);
+
     /// Try to start drawing ASAP
     void setFastFramerate();
 

src/graphics/draw/MenuHandler.cpp

@@ -206,6 +206,10 @@ void menuHandler::LoraRegionPicker(uint32_t duration)
         {"KZ_863", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_KZ_863},
         {"NP_865", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_NP_865},
         {"BR_902", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_BR_902},
+        {"ITU1_2M (144-146)", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_ITU1_2M},
+        {"ITU2_2M (144-148)", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_ITU2_2M},
+        {"ITU3_2M (144-148)", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_ITU3_2M},
+        {"ITU2_125CM (220-225)", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_ITU2_125CM},
 
     };
 

src/graphics/eink/Drivers/ED047TC1.cpp

@@ -6,15 +6,12 @@
     FastEPD buffer format: 1bpp, horizontal bytes, MSB = leftmost pixel, 1 = white
 
     Both formats share the same pixel layout and polarity (1 = white, 0 = black).
-    The InkHUD safe-area buffer (944×523) is copied into the centre of the physical
+    The InkHUD safe-area buffer (928×508) is copied into the centre of the physical
     960×540 FastEPD buffer so content clears the panel's inactive edge border.
     See ED047TC1.h for the H_OFFSET_BYTES / V_OFFSET_TOP / V_OFFSET_BOTTOM constants.
 
 */
 
-// Ruler diagnostic — uncomment to draw calibration lines at each physical edge.
-// #define EINK_EDGE_LINES
-
 #ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
 #ifdef T5_S3_EPAPER_PRO
 
@@ -212,35 +209,6 @@ void ED047TC1::update(uint8_t *imageData, UpdateTypes type)
         memcpy(dstRow, srcRow, srcRowBytes);
     }
 
-#ifdef EINK_EDGE_LINES
-    // Draw a 1px black box at the exact boundary of the safe area within the
-    // physical buffer. If the margins are correct, all 4 lines should be
-    // fully visible and right at the edge of the usable display area.
-
-    auto setPixelBlack = [&](uint32_t col, uint32_t row) { cur[row * dstRowBytes + col / 8] &= ~(0x80 >> (col % 8)); };
-
-    const uint32_t safeX = H_OFFSET_BYTES * 8;
-    const uint32_t safeY = V_OFFSET_TOP;
-    const uint32_t safeW = DISPLAY_WIDTH;
-    const uint32_t safeH = DISPLAY_HEIGHT;
-
-    // Top edge: horizontal line at safeY
-    for (uint32_t col = safeX; col < safeX + safeW; col++)
-        setPixelBlack(col, safeY);
-
-    // Bottom edge: horizontal line at safeY + safeH - 1
-    for (uint32_t col = safeX; col < safeX + safeW; col++)
-        setPixelBlack(col, safeY + safeH - 1);
-
-    // Left edge: vertical line at safeX
-    for (uint32_t row = safeY; row < safeY + safeH; row++)
-        setPixelBlack(safeX, row);
-
-    // Right edge: vertical line at safeX + safeW - 1
-    for (uint32_t row = safeY; row < safeY + safeH; row++)
-        setPixelBlack(safeX + safeW - 1, row);
-#endif
-
     if (type == FULL) {
         epaper->fullUpdate(CLEAR_SLOW, false);
         epaper->backupPlane(); // Sync pPrevious so next partialUpdate has a correct baseline

src/graphics/eink/Drivers/ED047TC1.h

@@ -18,9 +18,9 @@
     V_OFFSET_TOP and V_OFFSET_BOTTOM (vertical, pixel rows) to position it.
 
     Changing these constants shifts content inward from each physical edge:
-        H_OFFSET_BYTES = 1  →  8px left margin, 8px right margin   (960 – 8 – 8   = 944)
-        V_OFFSET_TOP   = 9  →  9px top margin  (asymmetric: top ≠ bottom)
-        V_OFFSET_BOTTOM = 8 →  8px bottom margin                    (540 – 9 – 8   = 523)
+        H_OFFSET_BYTES = 2   →  16px left margin, 16px right margin  (960 – 16 – 16 = 928)
+        V_OFFSET_TOP   = 16  →  16px top margin
+        V_OFFSET_BOTTOM = 16 →  16px bottom margin                   (540 – 16 – 16 = 508)
 
 */
 
@@ -61,13 +61,13 @@ class ED047TC1 : public EInk
     //
     // Calibrated by flashing a 1px border box and adjusting until all 4 sides are visible.
 
-    static constexpr uint16_t DISPLAY_WIDTH = 944;  // 960 − H_OFFSET_BYTES×8 − right_margin (8+8 = 16px)
-    static constexpr uint16_t DISPLAY_HEIGHT = 523; // 540 − V_OFFSET_TOP − V_OFFSET_BOTTOM (9+8 = 17px)
+    static constexpr uint16_t DISPLAY_WIDTH = 928;  // 960 − H_OFFSET_BYTES×8 − right_margin (16+16 = 32px)
+    static constexpr uint16_t DISPLAY_HEIGHT = 508; // 540 − V_OFFSET_TOP − V_OFFSET_BOTTOM (16+16 = 32px)
 
-    static constexpr uint8_t H_OFFSET_BYTES = 1;  // visual TOP  : 8px physical left margin
-                                                  // visual BOTTOM: 960−8−944=8px physical right margin
-    static constexpr uint8_t V_OFFSET_TOP = 9;    // visual RIGHT : CONFIRMED OK
-    static constexpr uint8_t V_OFFSET_BOTTOM = 8; // visual LEFT  : 8px physical bottom margin
+    static constexpr uint8_t H_OFFSET_BYTES = 2;   // visual TOP  : 16px physical left margin
+                                                   // visual BOTTOM: 960−16−928=16px physical right margin
+    static constexpr uint8_t V_OFFSET_TOP = 16;    // visual RIGHT : 16px physical top margin
+    static constexpr uint8_t V_OFFSET_BOTTOM = 16; // visual LEFT  : 16px physical bottom margin
 
     static constexpr UpdateTypes supported = static_cast<UpdateTypes>(FULL | FAST);
 

src/graphics/eink/Drivers/EInkParallel.cpp

@@ -0,0 +1,132 @@
+#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

@@ -0,0 +1,69 @@
+/*
+
+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

@@ -0,0 +1,49 @@
+#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

@@ -0,0 +1,43 @@
+/*
+
+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

@@ -0,0 +1,57 @@
+#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

@@ -0,0 +1,43 @@
+/*
+
+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

@@ -0,0 +1,49 @@
+#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

@@ -0,0 +1,43 @@
+/*
+
+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

@@ -0,0 +1,49 @@
+#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

@@ -0,0 +1,42 @@
+/*
+
+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

@@ -0,0 +1,57 @@
+#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

@@ -0,0 +1,43 @@
+/*
+
+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

@@ -0,0 +1,25 @@
+#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

@@ -0,0 +1,25 @@
+#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

@@ -0,0 +1,25 @@
+#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

@@ -0,0 +1,24 @@
+#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