Merge remote-tracking branch 'origin/master' into develop

.github/workflows/test_native.yml

@@ -136,7 +136,7 @@ jobs:
           merge-multiple: true
 
       - name: Test Report
-        uses: dorny/test-reporter@v2.6.0
+        uses: dorny/test-reporter@v3.0.0
         with:
           name: PlatformIO Tests
           path: testreport.xml

.trunk/trunk.yaml

@@ -8,15 +8,15 @@ plugins:
       uri: https://github.com/trunk-io/plugins
 lint:
   enabled:
-    - checkov@3.2.510
+    - checkov@3.2.511
-    - renovate@43.84.0
+    - renovate@43.92.1
     - prettier@3.8.1
-    - trufflehog@3.93.8
+    - trufflehog@3.94.1
     - yamllint@1.38.0
     - bandit@1.9.4
     - trivy@0.69.3
     - taplo@0.10.0
-    - ruff@0.15.7
+    - ruff@0.15.8
     - isort@8.0.1
     - markdownlint@0.48.0
     - oxipng@10.1.0
@@ -28,7 +28,7 @@ lint:
     - shellcheck@0.11.0
     - black@26.3.1
     - git-diff-check
-    - gitleaks@8.30.0
+    - gitleaks@8.30.1
     - clang-format@16.0.3
   ignore:
     - linters: [ALL]

boards/t5-epaper-s3.json

@@ -0,0 +1,38 @@
+{
+  "build": {
+    "arduino": {
+      "ldscript": "esp32s3_out.ld",
+      "memory_type": "qio_opi",
+      "partitions": "default_16MB.csv"
+    },
+    "core": "esp32",
+    "extra_flags": [
+      "-DBOARD_HAS_PSRAM",
+      "-DARDUINO_RUNNING_CORE=1",
+      "-DARDUINO_EVENT_RUNNING_CORE=0",
+      "-DARDUINO_USB_CDC_ON_BOOT=1",
+      "-DARDUINO_USB_MODE=1"
+    ],
+    "f_cpu": "240000000L",
+    "f_flash": "80000000L",
+    "flash_mode": "qio",
+    "hwids": [["0x303A", "0x1001"]],
+    "mcu": "esp32s3",
+    "variant": "esp32s3"
+  },
+  "connectivity": ["wifi", "bluetooth", "lora"],
+  "debug": {
+    "openocd_target": "esp32s3.cfg"
+  },
+  "frameworks": ["arduino", "espidf"],
+  "name": "LilyGo T5-ePaper-S3",
+  "upload": {
+    "flash_size": "16MB",
+    "maximum_ram_size": 327680,
+    "maximum_size": 16777216,
+    "require_upload_port": true,
+    "speed": 921600
+  },
+  "url": "https://lilygo.cc/products/t5-e-paper-s3-pro",
+  "vendor": "LILYGO"
+}

platformio.ini

@@ -233,5 +233,5 @@ lib_deps =
 [environmental_extra_no_bsec]
 lib_deps =
 	${environmental_extra_common.lib_deps}
-	# renovate: datasource=custom.pio depName=adafruit/Adafruit BME680 Library packageName=adafruit/library/Adafruit BME680
+	# renovate: datasource=custom.pio depName=Adafruit_BME680 packageName=adafruit/library/Adafruit BME680 Library
-	adafruit/Adafruit BME680 Library@^2.0.5
+	adafruit/Adafruit BME680 Library@2.0.6

src/buzz/buzz.cpp

@@ -6,6 +6,11 @@
 #include "Tone.h"
 #endif
 
+#if defined(HAS_I2S)
+#include "main.h"
+#include <unordered_map>
+#endif
+
 #if !defined(ARCH_PORTDUINO)
 extern "C" void delay(uint32_t dwMs);
 #endif
@@ -50,6 +55,50 @@ const int DURATION_1_2 = 500;  // 1/2 note
 const int DURATION_3_4 = 750;  // 3/4 note
 const int DURATION_1_1 = 1000; // 1/1 note
 
+#ifdef HAS_I2S
+void playTonesRTTTL(const ToneDuration *tone_durations, int size)
+{
+    // translate ToneDuration[] to RTTTL string and play using audioThread
+    static std::unordered_map<int, std::string> freqToNote = {
+        {NOTE_C3, "c4"},   {NOTE_CS3, "c#4"}, {NOTE_D3, "d4"},   {NOTE_DS3, "d#4"}, {NOTE_E3, "e4"},   {NOTE_F3, "f4"},
+        {NOTE_FS3, "f#4"}, {NOTE_G3, "g4"},   {NOTE_GS3, "g#4"}, {NOTE_A3, "a4"},   {NOTE_AS3, "a#4"}, {NOTE_B3, "b4"},
+        {NOTE_C4, "c5"},   {NOTE_E4, "e5"},   {NOTE_G4, "g5"},   {NOTE_A4, "a5"},   {NOTE_C5, "c6"},   {NOTE_E5, "e6"},
+        {NOTE_G5, "g6"},   {NOTE_F5, "f6"},   {NOTE_G6, "g7"},   {NOTE_E7, "e8"}};
+
+    char rtttl[128] = "tone:d=32,o=4,b=200:"; // default duration and octave
+    for (int i = 0; i < size; i++) {
+        const auto &td = tone_durations[i];
+        std::string note = "b4";
+        if (freqToNote.find(td.frequency_khz) != freqToNote.end()) {
+            note = freqToNote[td.frequency_khz];
+        }
+        int dur = 32; // default duration
+        if (td.duration_ms >= 1000)
+            dur = 1;
+        else if (td.duration_ms >= 500)
+            dur = 2;
+        else if (td.duration_ms >= 250)
+            dur = 4;
+        else if (td.duration_ms >= 125)
+            dur = 8;
+        else if (td.duration_ms >= 62)
+            dur = 16;
+        else
+            dur = 32;
+
+        char noteStr[64];
+        snprintf(noteStr, sizeof(noteStr), "%s,%d", note.c_str(), dur);
+        strncat(rtttl, noteStr, sizeof(rtttl) - strlen(rtttl) - 1);
+
+        audioThread->beginRttl(rtttl, strlen(rtttl));
+        while (audioThread->isPlaying()) {
+            delay(10);
+        }
+        return;
+    }
+}
+#endif
+
 void playTones(const ToneDuration *tone_durations, int size)
 {
     if (config.device.buzzer_mode == meshtastic_Config_DeviceConfig_BuzzerMode_DISABLED ||
@@ -57,7 +106,13 @@ void playTones(const ToneDuration *tone_durations, int size)
         // Buzzer is disabled or not set to system tones
         return;
     }
-#ifdef PIN_BUZZER
+#ifdef HAS_I2S
+    if (moduleConfig.external_notification.use_i2s_as_buzzer && audioThread) {
+        playTonesRTTTL(tone_durations, size);
+        return;
+    }
+#endif
+#if defined(PIN_BUZZER)
     if (!config.device.buzzer_gpio)
         config.device.buzzer_gpio = PIN_BUZZER;
 #endif

src/graphics/EInkDisplay2.cpp

@@ -1,6 +1,6 @@
 #include "configuration.h"
 
-#ifdef USE_EINK
+#if defined(USE_EINK) && !defined(USE_EINK_PARALLELDISPLAY)
 #include "EInkDisplay2.h"
 #include "SPILock.h"
 #include "main.h"

src/graphics/EInkDisplay2.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#ifdef USE_EINK
+#if defined(USE_EINK) && !defined(USE_EINK_PARALLELDISPLAY)
 
 #include "GxEPD2_BW.h"
 #include <OLEDDisplay.h>

src/graphics/EInkParallelDisplay.cpp

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

src/graphics/EInkParallelDisplay.h

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

src/graphics/Screen.cpp

@@ -27,6 +27,7 @@ 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>
 
 #include "DisplayFormatters.h"
@@ -364,12 +365,14 @@ Screen::Screen(ScanI2C::DeviceAddress address, meshtastic_Config_DisplayConfig_O
     defined(RAK14014) || defined(HX8357_CS) || defined(ILI9488_CS) || defined(ST7796_CS) || defined(HACKADAY_COMMUNICATOR)
     dispdev = new TFTDisplay(address.address, -1, -1, geometry,
                              (address.port == ScanI2C::I2CPort::WIRE1) ? HW_I2C::I2C_TWO : HW_I2C::I2C_ONE);
-#elif defined(USE_EINK) && !defined(USE_EINK_DYNAMICDISPLAY)
+#elif defined(USE_EINK) && !defined(USE_EINK_DYNAMICDISPLAY) && !defined(USE_EINK_PARALLELDISPLAY)
     dispdev = new EInkDisplay(address.address, -1, -1, geometry,
                               (address.port == ScanI2C::I2CPort::WIRE1) ? HW_I2C::I2C_TWO : HW_I2C::I2C_ONE);
 #elif defined(USE_EINK) && defined(USE_EINK_DYNAMICDISPLAY)
     dispdev = new EInkDynamicDisplay(address.address, -1, -1, geometry,
                                      (address.port == ScanI2C::I2CPort::WIRE1) ? HW_I2C::I2C_TWO : HW_I2C::I2C_ONE);
+#elif defined(USE_EINK_PARALLELDISPLAY)
+    dispdev = new EInkParallelDisplay(EPD_WIDTH, EPD_HEIGHT, EInkParallelDisplay::EPD_ROT_PORTRAIT);
 #elif defined(USE_ST7567)
     dispdev = new ST7567Wire(address.address, -1, -1, geometry,
                              (address.port == ScanI2C::I2CPort::WIRE1) ? HW_I2C::I2C_TWO : HW_I2C::I2C_ONE);
@@ -759,7 +762,11 @@ 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();
+#endif
 #else
     // No delay between UI frame rendering
     if (forceUiUpdate) {
@@ -998,8 +1005,10 @@ void Screen::setScreensaverFrames(FrameCallback einkScreensaver)
         ui->update();
     } 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
-#if !defined(USE_EINK_DYNAMICDISPLAY)
     static_cast<EInkDisplay *>(dispdev)->forceDisplay(0); // Screen::forceDisplay(), but override rate-limit
 #endif
 
@@ -1011,7 +1020,7 @@ void Screen::setScreensaverFrames(FrameCallback einkScreensaver)
 #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
+    EINK_ADD_FRAMEFLAG(dispdev, RESPONSIVE);              // Really nice to wake screen with a fast-refresh
 #endif
 }
 #endif

src/graphics/ScreenFonts.h

@@ -20,7 +20,7 @@
 #include "graphics/fonts/OLEDDisplayFontsGR.h"
 #endif
 
-#if defined(CROWPANEL_ESP32S3_5_EPAPER) && defined(USE_EINK)
+#if (defined(CROWPANEL_ESP32S3_5_EPAPER) || defined(T5_S3_EPAPER_PRO)) && defined(USE_EINK)
 #include "graphics/fonts/EinkDisplayFonts.h"
 #endif
 
@@ -90,7 +90,7 @@
 
 #if (defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ILI9342_DRIVER) || defined(ST7701_CS) || defined(ST7735_CS) ||      \
      defined(ST7789_CS) || defined(USE_ST7789) || defined(HX8357_CS) || defined(ILI9488_CS) || defined(ST7796_CS) ||             \
-     defined(HACKADAY_COMMUNICATOR) || defined(USE_ST7796)) &&                                                                   \
+     defined(USE_ST7796) || defined(HACKADAY_COMMUNICATOR)) &&                                                                   \
     !defined(DISPLAY_FORCE_SMALL_FONTS)
 // The screen is bigger so use bigger fonts
 #define FONT_SMALL FONT_MEDIUM_LOCAL // Height: 19
@@ -106,7 +106,7 @@
 #define FONT_LARGE FONT_LARGE_LOCAL   // Height: 28
 #endif
 
-#if defined(CROWPANEL_ESP32S3_5_EPAPER) && defined(USE_EINK)
+#if defined(CROWPANEL_ESP32S3_5_EPAPER) || defined(T5_S3_EPAPER_PRO)
 #undef FONT_SMALL
 #undef FONT_MEDIUM
 #undef FONT_LARGE

src/graphics/draw/DebugRenderer.cpp

@@ -544,6 +544,9 @@ void drawSystemScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x
 #ifndef T_DECK_PRO
     barsOffset -= 12;
 #endif
+#if defined(T5_S3_EPAPER_PRO)
+    barsOffset += 60;
+#endif
 #endif
     int barX = x + barsOffset;
     if (currentResolution == ScreenResolution::UltraLow) {
@@ -593,11 +596,12 @@ void drawSystemScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x
     uint32_t heapUsed = memGet.getHeapSize() - memGet.getFreeHeap();
     uint32_t heapTotal = memGet.getHeapSize();
 
-    uint32_t psramUsed = memGet.getPsramSize() - memGet.getFreePsram();
-    uint32_t psramTotal = memGet.getPsramSize();
-
     uint32_t flashUsed = 0, flashTotal = 0;
 #ifdef ESP32
+#ifndef T5_S3_EPAPER_PRO
+    uint32_t psramUsed = memGet.getPsramSize() - memGet.getFreePsram();
+    uint32_t psramTotal = memGet.getPsramSize();
+#endif
     flashUsed = FSCom.usedBytes();
     flashTotal = FSCom.totalBytes();
 #endif
@@ -616,10 +620,12 @@ void drawSystemScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x
     // === Draw memory rows
     drawUsageRow("Heap:", heapUsed, heapTotal, true);
 #ifdef ESP32
+#ifndef T5_S3_EPAPER_PRO
     if (psramUsed > 0) {
         line += 1;
         drawUsageRow("PSRAM:", psramUsed, psramTotal);
     }
+#endif
     if (flashTotal > 0) {
         line += 1;
         drawUsageRow("Flash:", flashUsed, flashTotal);

src/graphics/draw/MenuHandler.cpp

@@ -1221,9 +1221,11 @@ void menuHandler::positionBaseMenu()
     };
 
     constexpr size_t baseCount = sizeof(baseOptions) / sizeof(baseOptions[0]);
-    constexpr size_t calibrateCount = sizeof(calibrateOptions) / sizeof(calibrateOptions[0]);
     static std::array<const char *, baseCount> baseLabels{};
+#if !MESHTASTIC_EXCLUDE_ACCELEROMETER
+    constexpr size_t calibrateCount = sizeof(calibrateOptions) / sizeof(calibrateOptions[0]);
     static std::array<const char *, calibrateCount> calibrateLabels{};
+#endif
 
     auto onSelection = [](const PositionMenuOption &option, int) -> void {
         if (option.action == OptionsAction::Back) {
@@ -1249,9 +1251,11 @@ void menuHandler::positionBaseMenu()
             screen->runNow();
             break;
         case PositionAction::CompassCalibrate:
+#if !MESHTASTIC_EXCLUDE_ACCELEROMETER
             if (accelerometerThread) {
                 accelerometerThread->calibrate(30);
             }
+#endif
             break;
         case PositionAction::GPSSmartPosition:
             menuQueue = GpsSmartPositionMenu;
@@ -1269,11 +1273,15 @@ void menuHandler::positionBaseMenu()
     };
 
     BannerOverlayOptions bannerOptions;
+#if !MESHTASTIC_EXCLUDE_ACCELEROMETER
     if (accelerometerThread) {
         bannerOptions = createStaticBannerOptions("GPS Action", calibrateOptions, calibrateLabels, onSelection);
     } else {
         bannerOptions = createStaticBannerOptions("GPS Action", baseOptions, baseLabels, onSelection);
     }
+#else
+    bannerOptions = createStaticBannerOptions("GPS Action", baseOptions, baseLabels, onSelection);
+#endif
 
     screen->showOverlayBanner(bannerOptions);
 }
@@ -2203,9 +2211,9 @@ void menuHandler::traceRouteMenu()
 void menuHandler::testMenu()
 {
 
-    enum optionsNumbers { Back, NumberPicker, ShowChirpy };
+    enum optionsNumbers { Back, NumberPicker, ShowChirpy, TestAnnounce };
-    static const char *optionsArray[4] = {"Back"};
+    static const char *optionsArray[5] = {"Back"};
-    static int optionsEnumArray[4] = {Back};
+    static int optionsEnumArray[5] = {Back};
     int options = 1;
 
     optionsArray[options] = "Number Picker";
@@ -2213,6 +2221,10 @@ void menuHandler::testMenu()
 
     optionsArray[options] = screen->isFrameHidden("chirpy") ? "Show Chirpy" : "Hide Chirpy";
     optionsEnumArray[options++] = ShowChirpy;
+#ifdef HAS_I2S
+    optionsArray[options] = "Test Announce";
+    optionsEnumArray[options++] = TestAnnounce;
+#endif
 
     BannerOverlayOptions bannerOptions;
     bannerOptions.message = "Hidden Test Menu";
@@ -2227,6 +2239,10 @@ void menuHandler::testMenu()
             screen->toggleFrameVisibility("chirpy");
             screen->setFrames(Screen::FOCUS_SYSTEM);
 
+        } else if (selected == TestAnnounce) {
+#ifdef HAS_I2S
+            audioThread->readAloud("This is a test of the emergency broadcast system. This is only a test.");
+#endif
         } else {
             menuQueue = SystemBaseMenu;
             screen->runNow();

src/graphics/niche/InkHUD/Applet.h

@@ -15,6 +15,7 @@
 
 #include <GFX.h> // GFXRoot drawing lib
 
+#include "mesh/MeshModule.h"
 #include "mesh/MeshTypes.h"
 
 #include "./AppletFont.h"

src/main.cpp

@@ -123,7 +123,7 @@ void printPartitionTable()
 #include "AmbientLightingThread.h"
 #include "PowerFSMThread.h"
 
-#if !defined(ARCH_STM32WL) && !MESHTASTIC_EXCLUDE_I2C
+#if !defined(ARCH_STM32WL) && !MESHTASTIC_EXCLUDE_I2C && !MESHTASTIC_EXCLUDE_ACCELEROMETER
 #include "motion/AccelerometerThread.h"
 AccelerometerThread *accelerometerThread = nullptr;
 #endif
@@ -657,7 +657,7 @@ void setup()
     }
 #endif
 
-#if !defined(ARCH_STM32WL)
+#if !defined(ARCH_STM32WL) && !MESHTASTIC_EXCLUDE_ACCELEROMETER
     auto acc_info = i2cScanner->firstAccelerometer();
     accelerometer_found = acc_info.type != ScanI2C::DeviceType::NONE ? acc_info.address : accelerometer_found;
     LOG_DEBUG("acc_info = %i", acc_info.type);
@@ -737,7 +737,7 @@ void setup()
 #endif
 
 #if !MESHTASTIC_EXCLUDE_I2C
-#if !defined(ARCH_STM32WL)
+#if !defined(ARCH_STM32WL) && !MESHTASTIC_EXCLUDE_ACCELEROMETER
     if (acc_info.type != ScanI2C::DeviceType::NONE) {
         accelerometerThread = new AccelerometerThread(acc_info.type);
     }

src/main.h

@@ -65,7 +65,7 @@ extern UdpMulticastHandler *udpHandler;
 // Global Screen singleton.
 extern graphics::Screen *screen;
 
-#if !defined(ARCH_STM32WL) && !MESHTASTIC_EXCLUDE_I2C
+#if !defined(ARCH_STM32WL) && !MESHTASTIC_EXCLUDE_I2C && !MESHTASTIC_EXCLUDE_ACCELEROMETER
 #include "motion/AccelerometerThread.h"
 extern AccelerometerThread *accelerometerThread;
 #endif

src/mesh/http/WebServer.h

@@ -5,6 +5,8 @@
 #include <Arduino.h>
 #include <functional>
 
+#if !MESHTASTIC_EXCLUDE_WEBSERVER
+
 void initWebServer();
 void createSSLCert();
 
@@ -24,3 +26,20 @@ class WebServerThread : private concurrency::OSThread
 };
 
 extern WebServerThread *webServerThread;
+
+#else
+// Stub implementations when web server is excluded
+inline void initWebServer() {}
+inline void createSSLCert() {}
+
+class WebServerThread
+{
+  public:
+    WebServerThread() {}
+    uint32_t requestRestart = 0;
+    void markActivity() {}
+};
+
+inline WebServerThread *webServerThread = nullptr;
+
+#endif

src/modules/AdminModule.cpp

@@ -40,7 +40,7 @@
 #include "modules/PositionModule.h"
 #endif
 
-#if !defined(ARCH_STM32WL) && !MESHTASTIC_EXCLUDE_I2C
+#if !defined(ARCH_STM32WL) && !MESHTASTIC_EXCLUDE_I2C && !MESHTASTIC_EXCLUDE_ACCELEROMETER
 #include "motion/AccelerometerThread.h"
 #endif
 #if (defined(ARCH_ESP32) || defined(ARCH_NRF52) || defined(ARCH_RP2040)) && !defined(CONFIG_IDF_TARGET_ESP32S2) &&               \
@@ -664,7 +664,8 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c, bool fromOthers)
     case meshtastic_Config_device_tag:
         LOG_INFO("Set config: Device");
         config.has_device = true;
-#if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL) && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR
+#if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL) && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR &&                            \
+    !MESHTASTIC_EXCLUDE_ACCELEROMETER
         if (config.device.double_tap_as_button_press == false && c.payload_variant.device.double_tap_as_button_press == true &&
             accelerometerThread->enabled == false) {
             config.device.double_tap_as_button_press = c.payload_variant.device.double_tap_as_button_press;
@@ -766,7 +767,8 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c, bool fromOthers)
                    c.payload_variant.display.displaymode == meshtastic_Config_DisplayConfig_DisplayMode_COLOR) {
             config.bluetooth.enabled = false;
         }
-#if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL) && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR
+#if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL) && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR &&                            \
+    !MESHTASTIC_EXCLUDE_ACCELEROMETER
         if (config.display.wake_on_tap_or_motion == false && c.payload_variant.display.wake_on_tap_or_motion == true &&
             accelerometerThread->enabled == false) {
             config.display.wake_on_tap_or_motion = c.payload_variant.display.wake_on_tap_or_motion;

src/motion/AccelerometerThread.h

@@ -4,7 +4,7 @@
 
 #include "configuration.h"
 
-#if !defined(ARCH_STM32WL) && !MESHTASTIC_EXCLUDE_I2C
+#if !defined(ARCH_STM32WL) && !MESHTASTIC_EXCLUDE_I2C && !MESHTASTIC_EXCLUDE_ACCELEROMETER
 
 #include "../concurrency/OSThread.h"
 #ifdef HAS_BMA423

variants/esp32/esp32-common.ini

@@ -8,7 +8,7 @@ platform =
   platformio/espressif32@6.13.0
 platform_packages =
   # renovate: datasource=custom.pio depName=platformio/tool-mklittlefs packageName=platformio/tool/tool-mklittlefs
-  platformio/tool-mklittlefs@^1.203.210628
+  platformio/tool-mklittlefs@1.203.210628
 
 extra_scripts =
   ${env.extra_scripts}
@@ -70,11 +70,11 @@ lib_deps =
   # renovate: datasource=git-refs depName=meshtastic-esp32_https_server packageName=https://github.com/meshtastic/esp32_https_server gitBranch=master
   https://github.com/meshtastic/esp32_https_server/archive/b78f12c86ea65c3ca08968840ff554ff7ed69b60.zip
   # renovate: datasource=custom.pio depName=NimBLE-Arduino packageName=h2zero/library/NimBLE-Arduino
-  h2zero/NimBLE-Arduino@^1.4.3
+  h2zero/NimBLE-Arduino@1.4.3
   # renovate: datasource=git-refs depName=libpax packageName=https://github.com/dbinfrago/libpax gitBranch=master
   https://github.com/dbinfrago/libpax/archive/3cdc0371c375676a97967547f4065607d4c53fd1.zip
-  # renovate: datasource=github-tags depName=XPowersLib packageName=lewisxhe/XPowersLib
+  # renovate: datasource=custom.pio depName=XPowersLib packageName=lewisxhe/library/XPowersLib
-  https://github.com/lewisxhe/XPowersLib/archive/v0.3.3.zip
+  lewisxhe/XPowersLib@0.3.3
   # renovate: datasource=custom.pio depName=rweather/Crypto packageName=rweather/library/Crypto
   rweather/Crypto@0.4.0
 

variants/esp32/esp32.ini

@@ -4,25 +4,29 @@
 extends = esp32_common
 custom_esp32_kind = esp32
 
+build_src_filter =
+  ${esp32_common.build_src_filter}
+  -<modules/esp32/PaxcounterModule.cpp>
+  -<mesh/http/>
+
 build_flags =
   ${esp32_common.build_flags}
   -DMESHTASTIC_EXCLUDE_AUDIO=1
-; Override lib_deps to use environmental_extra_no_bsec instead of environmental_extra
+  -DMESHTASTIC_EXCLUDE_ACCELEROMETER=1
-; BSEC library uses ~3.5KB DRAM which causes overflow on original ESP32 targets
+  -DMESHTASTIC_EXCLUDE_PAXCOUNTER=1
+  -DMESHTASTIC_EXCLUDE_WEBSERVER=1
+  -DMESHTASTIC_EXCLUDE_RANGETEST=1
+
 lib_deps =
   ${arduino_base.lib_deps}
   ${networking_base.lib_deps}
   ${networking_extra.lib_deps}
+  ${radiolib_base.lib_deps}
   ${environmental_base.lib_deps}
   ${environmental_extra_no_bsec.lib_deps}
-  ${radiolib_base.lib_deps}
-  # renovate: datasource=git-refs depName=meshtastic-esp32_https_server packageName=https://github.com/meshtastic/esp32_https_server gitBranch=master
-  https://github.com/meshtastic/esp32_https_server/archive/b78f12c86ea65c3ca08968840ff554ff7ed69b60.zip
   # renovate: datasource=custom.pio depName=NimBLE-Arduino packageName=h2zero/library/NimBLE-Arduino
-  h2zero/NimBLE-Arduino@^1.4.3
+  h2zero/NimBLE-Arduino@1.4.3
-  # renovate: datasource=git-refs depName=libpax packageName=https://github.com/dbinfrago/libpax gitBranch=master
+  # renovate: datasource=custom.pio depName=XPowersLib packageName=lewisxhe/library/XPowersLib
-  https://github.com/dbinfrago/libpax/archive/3cdc0371c375676a97967547f4065607d4c53fd1.zip
+  lewisxhe/XPowersLib@0.3.3
-  # renovate: datasource=github-tags depName=XPowersLib packageName=lewisxhe/XPowersLib
-  https://github.com/lewisxhe/XPowersLib/archive/v0.3.3.zip
   # renovate: datasource=custom.pio depName=rweather/Crypto packageName=rweather/library/Crypto
-  rweather/Crypto@0.4.0
+  rweather/Crypto@0.4.0

variants/esp32/station-g1/platformio.ini

@@ -10,6 +10,9 @@ custom_meshtastic_tags = B&Q
 
 extends = esp32_base
 board = ttgo-t-beam
+build_unflags =
+  ${esp32_common.build_unflags}
+  -DBOARD_HAS_PSRAM
 build_flags = 
   ${esp32_base.build_flags}
   -D STATION_G1

variants/esp32/tbeam/platformio.ini

@@ -32,5 +32,5 @@ lib_deps =
   ${env:tbeam.lib_deps}
   # renovate: datasource=github-tags depName=meshtastic-st7796 packageName=meshtastic/st7796
   https://github.com/meshtastic/st7796/archive/1.0.5.zip
-  # renovate: datasource=custom.pio depName=lewisxhe-SensorLib packageName=lewisxhe/library/SensorLib
+  # renovate: datasource=custom.pio depName=SensorLib packageName=lewisxhe/library/SensorLib
   lewisxhe/SensorLib@0.3.4

variants/esp32s3/m5stack_cardputer_adv/platformio.ini

@@ -8,15 +8,17 @@ upload_protocol = esptool
 build_flags = 
   ${esp32s3_base.build_flags}
   -D M5STACK_CARDPUTER_ADV
-  -D BOARD_HAS_PSRAM
   -D ARDUINO_USB_CDC_ON_BOOT=1
   -I variants/esp32s3/m5stack_cardputer_adv
+build_src_filter =
+  ${esp32s3_base.build_src_filter}
+  +<../variants/esp32s3/m5stack_cardputer_adv>
 lib_deps =
   ${esp32s3_base.lib_deps}
   # renovate: datasource=git-refs depName=meshtastic-st7789 packageName=https://github.com/meshtastic/st7789 gitBranch=main
   https://github.com/meshtastic/st7789/archive/9ee76d6b18b9a8f45a2c5cae06b1134a587691eb.zip
-#  # renovate: datasource=github-tags depName=pschatzmann_arduino-audio-driver packageName=pschatzmann/arduino-audio-driver
+  # renovate: datasource=github-tags depName=pschatzmann_arduino-audio-driver packageName=pschatzmann/arduino-audio-driver
-#  https://github.com/pschatzmann/arduino-audio-driver/archive/v0.2.1.zip
+  https://github.com/pschatzmann/arduino-audio-driver/archive/v0.2.1.zip
   # renovate: datasource=git-refs depName=ESP8266Audio packageName=https://github.com/meshtastic/ESP8266Audio gitBranch=meshtastic-2.0.0-dacfix
   https://github.com/meshtastic/ESP8266Audio/archive/343024632ee78d6216907b2353fc943a62422d80.zip
   # renovate: datasource=custom.pio depName=ESP8266SAM packageName=earlephilhower/library/ESP8266SAM

variants/esp32s3/m5stack_cardputer_adv/variant.cpp

@@ -0,0 +1,40 @@
+#include "AudioBoard.h"
+#include "configuration.h"
+
+DriverPins PinsAudioBoardES8311;
+AudioBoard board(AudioDriverES8311, PinsAudioBoardES8311);
+
+// M5stack Cardputer ADV specific init
+
+void lateInitVariant()
+{
+    // AudioDriverLogger.begin(Serial, AudioDriverLogLevel::Debug);
+    //  I2C: function, scl, sda
+    PinsAudioBoardES8311.addI2C(PinFunction::CODEC, Wire);
+    // I2S: function, mclk, bck, ws, data_out, data_in
+    PinsAudioBoardES8311.addI2S(PinFunction::CODEC, DAC_I2S_MCLK, DAC_I2S_BCK, DAC_I2S_WS, DAC_I2S_DOUT, DAC_I2S_DIN);
+
+    // configure codec
+    CodecConfig cfg;
+    cfg.input_device = ADC_INPUT_LINE1;
+    cfg.output_device = DAC_OUTPUT_ALL;
+    cfg.i2s.bits = BIT_LENGTH_16BITS;
+    cfg.i2s.rate = RATE_44K;
+    board.begin(cfg);
+
+    // extra ES8311 init
+    auto es8311_write_reg = [](uint8_t reg, uint8_t val) {
+        Wire.beginTransmission(0x18); // ES8311 i2c address
+        Wire.write(reg);
+        Wire.write(val);
+        Wire.endTransmission();
+    };
+    es8311_write_reg(0x00, 0x80); // reset, power on
+    es8311_write_reg(0x01, 0xB5); // MCLK = BCLK
+    es8311_write_reg(0x02, 0x18); // CLOCK_MANAGER/ MULT_PRE=3
+    es8311_write_reg(0x0D, 0x01); // analog power up
+    es8311_write_reg(0x12, 0x00); // DAC power up
+    es8311_write_reg(0x13, 0x10); // enable HP drive
+    es8311_write_reg(0x32, 0xBF); // DAC volume (0dB)
+    es8311_write_reg(0x37, 0x08); // EQ bypass
+}

variants/esp32s3/t5s3_epaper/nicheGraphics.h

@@ -0,0 +1,123 @@
+/*
+
+Most of the Meshtastic firmware uses preprocessor macros throughout the code to support different hardware variants.
+NicheGraphics attempts a different approach:
+
+Per-device config takes place in this setupNicheGraphics() method
+(And a small amount in platformio.ini)
+
+This file sets up InkHUD for Heltec VM-E290.
+Different NicheGraphics UIs and different hardware variants will each have their own setup procedure.
+
+*/
+
+#pragma once
+
+#include "configuration.h"
+#include "mesh/MeshModule.h"
+
+#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
+
+// InkHUD-specific components
+// ---------------------------
+// #include "graphics/niche/InkHUD/InkHUD.h"
+#include "graphics/niche/InkHUD/WindowManager.h"
+
+// Applets
+#include "graphics/niche/InkHUD/Applets/User/AllMessage/AllMessageApplet.h"
+#include "graphics/niche/InkHUD/Applets/User/DM/DMApplet.h"
+#include "graphics/niche/InkHUD/Applets/User/Heard/HeardApplet.h"
+#include "graphics/niche/InkHUD/Applets/User/Positions/PositionsApplet.h"
+#include "graphics/niche/InkHUD/Applets/User/RecentsList/RecentsListApplet.h"
+#include "graphics/niche/InkHUD/Applets/User/ThreadedMessage/ThreadedMessageApplet.h"
+
+// Shared NicheGraphics components
+// --------------------------------
+#include "graphics/niche/Drivers/Backlight/LatchingBacklight.h"
+#include "graphics/niche/Drivers/EInk/DEPG0290BNS800.h"
+#include "graphics/niche/Inputs/TwoButton.h"
+
+void setupNicheGraphics()
+{
+    using namespace NicheGraphics;
+
+    // SPI
+    // -----------------------------
+
+    // Display is connected to HSPI
+    SPIClass *hspi = new SPIClass(HSPI);
+    hspi->begin(PIN_EINK_SCLK, -1, PIN_EINK_MOSI, PIN_EINK_CS);
+
+    // E-Ink Driver
+    // -----------------------------
+
+    // Use E-Ink driver
+    Drivers::EInk *driver = new Drivers::DEPG0290BNS800;
+    driver->begin(hspi, PIN_EINK_DC, PIN_EINK_CS, PIN_EINK_BUSY);
+
+    // InkHUD
+    // ----------------------------
+
+    InkHUD::InkHUD *inkhud = InkHUD::InkHUD::getInstance();
+
+    // Set the driver
+    inkhud->setDriver(driver);
+
+    // Set how many FAST updates per FULL update
+    // Set how unhealthy additional FAST updates beyond this number are
+    inkhud->setDisplayResilience(7, 1.5);
+
+    // Prepare fonts
+    InkHUD::Applet::fontLarge = FREESANS_9PT_WIN1252;
+    InkHUD::Applet::fontSmall = FREESANS_6PT_WIN1252;
+
+    // Init settings, and customize defaults
+    inkhud->persistence->settings.userTiles.maxCount = 2; // How many tiles can the display handle?
+    inkhud->persistence->settings.rotation = 1;           // 90 degrees clockwise
+    inkhud->persistence->settings.userTiles.count = 1;    // One tile only by default, keep things simple for new users
+    inkhud->persistence->settings.optionalMenuItems.nextTile = false;  // Behavior handled by aux button instead
+    inkhud->persistence->settings.optionalFeatures.batteryIcon = true; // Device definitely has a battery
+
+    // Setup backlight
+    // Note: AUX button behavior configured further down
+    Drivers::LatchingBacklight *backlight = Drivers::LatchingBacklight::getInstance();
+    backlight->setPin(PIN_EINK_EN);
+
+    // Pick applets
+    // Note: order of applets determines priority of "auto-show" feature
+    // Optional arguments for defaults:
+    // - is activated?
+    // - is autoshown?
+    // - is foreground on a specific tile (index)?
+    inkhud->addApplet("All Messages", new InkHUD::AllMessageApplet, true, true); // Activated, autoshown
+    inkhud->addApplet("DMs", new InkHUD::DMApplet);
+    inkhud->addApplet("Channel 0", new InkHUD::ThreadedMessageApplet(0));
+    inkhud->addApplet("Channel 1", new InkHUD::ThreadedMessageApplet(1));
+    inkhud->addApplet("Positions", new InkHUD::PositionsApplet, true); // Activated
+    inkhud->addApplet("Recents List", new InkHUD::RecentsListApplet);
+    inkhud->addApplet("Heard", new InkHUD::HeardApplet, true, false, 0); // Activated, not autoshown, default on tile 0
+    // inkhud->addApplet("Basic", new InkHUD::BasicExampleApplet);
+    // inkhud->addApplet("NewMsg", new InkHUD::NewMsgExampleApplet);
+
+    // Start running InkHUD
+    inkhud->begin();
+
+    // Buttons
+    // --------------------------
+
+    Inputs::TwoButton *buttons = Inputs::TwoButton::getInstance(); // A shared NicheGraphics component
+
+    // Setup the main user button (0)
+    buttons->setWiring(0, BUTTON_PIN);
+    buttons->setHandlerShortPress(0, []() { InkHUD::InkHUD::getInstance()->shortpress(); });
+    buttons->setHandlerLongPress(0, []() { InkHUD::InkHUD::getInstance()->longpress(); });
+
+    // Setup the aux button (1)
+    // Bonus feature of VME290
+    buttons->setWiring(1, BUTTON_PIN_SECONDARY);
+    buttons->setHandlerShortPress(1, []() { InkHUD::InkHUD::getInstance()->nextTile(); });
+
+    buttons->start();
+}
+
+#endif

variants/esp32s3/t5s3_epaper/pins_arduino.h

@@ -0,0 +1,43 @@
+#ifndef Pins_Arduino_h
+#define Pins_Arduino_h
+
+#include <stdint.h>
+
+#define USB_VID 0x303a
+#define USB_PID 0x1001
+
+#if defined(T5_S3_EPAPER_PRO_V1)
+// The default Wire will be mapped to RTC, Touch, BQ25896, and BQ27220
+static const uint8_t SDA = 6;
+static const uint8_t SCL = 5;
+
+// Default SPI will be mapped to Radio
+static const uint8_t SS = 46;
+static const uint8_t MOSI = 17;
+static const uint8_t MISO = 8;
+static const uint8_t SCK = 18;
+
+#define SPI_MOSI (17)
+#define SPI_SCK (18)
+#define SPI_MISO (8)
+#define SPI_CS (16)
+
+#else // T5_S3_EPAPER_PRO_V2
+// The default Wire will be mapped to RTC, Touch, PCA9535, BQ25896, and BQ27220
+static const uint8_t SDA = 39;
+static const uint8_t SCL = 40;
+
+// Default SPI will be mapped to Radio
+static const uint8_t SS = 46;
+static const uint8_t MOSI = 13;
+static const uint8_t MISO = 21;
+static const uint8_t SCK = 14;
+
+#define SPI_MOSI (13)
+#define SPI_SCK (14)
+#define SPI_MISO (21)
+#define SPI_CS (12)
+
+#endif
+
+#endif /* Pins_Arduino_h */

variants/esp32s3/t5s3_epaper/platformio.ini

@@ -0,0 +1,59 @@
+[t5s3_epaper_base]
+extends = esp32s3_base
+board = t5-epaper-s3
+board_build.partition = default_16MB.csv
+board_check = true
+upload_protocol = esptool
+build_flags = -fno-strict-aliasing
+  ${esp32_base.build_flags} 
+  -I variants/esp32s3/t5s3_epaper
+  -D T5_S3_EPAPER_PRO
+  -D USE_EINK
+  -D USE_EINK_PARALLELDISPLAY
+  -D PRIVATE_HW
+  -D TOUCH_THRESHOLD_X=60
+  -D TOUCH_THRESHOLD_Y=40
+  -D TIME_LONG_PRESS=500
+;  -D EINK_LIMIT_GHOSTING_PX=5000
+  -D EPD_FULLSLOW_PERIOD=100
+  -D FAST_EPD_PARTIAL_UPDATE_BUG ; use rect area update instead of partial
+
+build_src_filter = 
+  ${esp32s3_base.build_src_filter}
+  +<../variants/esp32s3/t5s3_epaper>
+lib_deps =
+  ${esp32s3_base.lib_deps}
+  # renovate: datasource=custom.pio depName=SensorLib packageName=lewisxhe/library/SensorLib
+  lewisxhe/SensorLib@0.3.4
+  https://github.com/mverch67/BQ27220/archive/07d92be846abd8a0258a50c23198dac0858b22ed.zip
+  https://github.com/mverch67/FastEPD/archive/0df1bff329b6fc782e062f611758880762340647.zip
+
+[env:t5s3_epaper_inkhud]
+extends = t5s3_epaper_base, inkhud
+build_flags =
+  ${t5s3_epaper_base.build_flags}
+  ${inkhud.build_flags}
+  -D SDCARD_USE_SPI1
+  -D T5_S3_EPAPER_PRO_V2
+build_src_filter =
+  ${t5s3_epaper_base.build_src_filter}
+  ${inkhud.build_src_filter}
+lib_deps =
+  ${inkhud.lib_deps} ; InkHUD libs first, so we get GFXRoot instead of AdafruitGFX
+  ${t5s3_epaper_base.lib_deps}
+
+
+[env:t5s3-epaper-v1] ; H752
+extends = t5s3_epaper_base
+build_flags =
+  ${t5s3_epaper_base.build_flags}
+  -D T5_S3_EPAPER_PRO_V1
+  -D GPS_DEFAULT_NOT_PRESENT=1
+
+[env:t5s3-epaper-v2] ; H752-01
+extends = t5s3_epaper_base
+build_flags =
+  ${t5s3_epaper_base.build_flags}
+  -D T5_S3_EPAPER_PRO_V2
+  -D SDCARD_USE_SPI1
+  -D GPS_POWER_TOGGLE

variants/esp32s3/t5s3_epaper/variant.cpp

@@ -0,0 +1,47 @@
+#include "configuration.h"
+
+#ifdef T5_S3_EPAPER_PRO
+
+#include "TouchDrvGT911.hpp"
+#include "Wire.h"
+#include "input/TouchScreenImpl1.h"
+
+TouchDrvGT911 touch;
+
+bool readTouch(int16_t *x, int16_t *y)
+{
+    if (!digitalRead(GT911_PIN_INT)) {
+        int16_t raw_x;
+        int16_t raw_y;
+        if (touch.getPoint(&raw_x, &raw_y)) {
+            // rotate 90° for landscape
+            *x = raw_y;
+            *y = EPD_WIDTH - 1 - raw_x;
+            LOG_DEBUG("touched(%d/%d)", *x, *y);
+            return true;
+        }
+    }
+    return false;
+}
+
+void earlyInitVariant()
+{
+    pinMode(LORA_CS, OUTPUT);
+    digitalWrite(LORA_CS, HIGH);
+    pinMode(SDCARD_CS, OUTPUT);
+    digitalWrite(SDCARD_CS, HIGH);
+    pinMode(BOARD_BL_EN, OUTPUT);
+}
+
+// T5-S3-ePaper Pro specific (late-) init
+void lateInitVariant(void)
+{
+    touch.setPins(GT911_PIN_RST, GT911_PIN_INT);
+    if (touch.begin(Wire, GT911_SLAVE_ADDRESS_L, GT911_PIN_SDA, GT911_PIN_SCL)) {
+        touchScreenImpl1 = new TouchScreenImpl1(EPD_WIDTH, EPD_HEIGHT, readTouch);
+        touchScreenImpl1->init();
+    } else {
+        LOG_ERROR("Failed to find touch controller!");
+    }
+}
+#endif

variants/esp32s3/t5s3_epaper/variant.h

@@ -0,0 +1,92 @@
+
+// Display (E-Ink) ED047TC1 - 8bit parallel
+#define EPD_WIDTH 960
+#define EPD_HEIGHT 540
+
+#define CANNED_MESSAGE_MODULE_ENABLE 1
+#define USE_VIRTUAL_KEYBOARD 1
+
+#if defined(T5_S3_EPAPER_PRO_V1)
+#define BOARD_BL_EN 40
+#else
+#define BOARD_BL_EN 11
+#endif
+
+#define I2C_SDA SDA
+#define I2C_SCL SCL
+
+#define HAS_TOUCHSCREEN 1
+#define GT911_PIN_SDA SDA
+#define GT911_PIN_SCL SCL
+#if defined(T5_S3_EPAPER_PRO_V1)
+#define GT911_PIN_INT 15
+#define GT911_PIN_RST 41
+#else
+#define GT911_PIN_INT 3
+#define GT911_PIN_RST 9
+#endif
+
+#define PCF85063_RTC 0x51
+#define HAS_RTC 1
+#define PCF85063_INT 2
+
+#define USE_POWERSAVE
+#define SLEEP_TIME 120
+
+// GPS
+#if !defined(T5_S3_EPAPER_PRO_V1)
+#define GPS_RX_PIN 44
+#define GPS_TX_PIN 43
+#endif
+
+#if defined(T5_S3_EPAPER_PRO_V1)
+#define BUTTON_PIN 48
+#define PIN_BUTTON2 0
+#define ALT_BUTTON_PIN PIN_BUTTON2
+#else
+#define BUTTON_PIN 0
+#endif
+
+// SD card
+#define HAS_SDCARD
+#define SDCARD_CS SPI_CS
+#define SD_SPI_FREQUENCY 75000000U
+
+// battery charger BQ25896
+#define HAS_PPM 1
+#define XPOWERS_CHIP_BQ25896
+
+// battery quality management BQ27220
+#define HAS_BQ27220 1
+#define BQ27220_I2C_SDA SDA
+#define BQ27220_I2C_SCL SCL
+#define BQ27220_DESIGN_CAPACITY 1500
+
+// LoRa
+#define USE_SX1262
+#define USE_SX1268
+
+#define LORA_SCK SCK
+#define LORA_MISO MISO
+#define LORA_MOSI MOSI
+#define LORA_CS 46
+
+#define LORA_DIO0 -1
+#if defined(T5_S3_EPAPER_PRO_V1)
+#define LORA_RESET 43
+#define LORA_DIO1 3  // SX1262 IRQ
+#define LORA_DIO2 44 // SX1262 BUSY
+#define LORA_DIO3
+#else
+#define LORA_RESET 1
+#define LORA_DIO1 10 // SX1262 IRQ
+#define LORA_DIO2 47 // SX1262 BUSY
+#define LORA_DIO3
+#endif
+
+#define SX126X_CS LORA_CS
+#define SX126X_DIO1 LORA_DIO1
+#define SX126X_BUSY LORA_DIO2
+#define SX126X_RESET LORA_RESET
+#define SX126X_DIO2_AS_RF_SWITCH
+#define SX126X_DIO3_TCXO_VOLTAGE 2.4

variants/native/portduino.ini

@@ -34,8 +34,8 @@ lib_deps =
 	adafruit/Adafruit seesaw Library@1.7.9
   # renovate: datasource=git-refs depName=RAK12034-BMX160 packageName=https://github.com/RAKWireless/RAK12034-BMX160 gitBranch=main
   https://github.com/RAKWireless/RAK12034-BMX160/archive/dcead07ffa267d3c906e9ca4a1330ab989e957e2.zip
-  # renovate: datasource=custom.pio depName=adafruit/Adafruit BME680 Library packageName=adafruit/library/Adafruit BME680
+  # renovate: datasource=custom.pio depName=Adafruit_BME680 packageName=adafruit/library/Adafruit BME680 Library
-  adafruit/Adafruit BME680 Library@^2.0.5
+  adafruit/Adafruit BME680 Library@2.0.6
 
 build_flags =
   ${arduino_base.build_flags}

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

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

variants/nrf52840/nrf52.ini

@@ -25,6 +25,7 @@ build_flags =
   -DMESHTASTIC_EXCLUDE_AUDIO=1
   -DMESHTASTIC_EXCLUDE_PAXCOUNTER=1
   -Os
+  -std=gnu++17
 build_unflags =
   -Ofast
   -Og

variants/nrf52840/t-echo-plus/platformio.ini

@@ -22,5 +22,7 @@ build_src_filter = ${nrf52_base.build_src_filter} +<../variants/nrf52840/t-echo-
 lib_deps =
   ${nrf52840_base.lib_deps}
   https://github.com/meshtastic/GxEPD2/archive/55f618961db45a23eff0233546430f1e5a80f63a.zip
-  lewisxhe/PCF8563_Library@^1.0.1
+  # renovate: datasource=custom.pio depName=PCF8563 packageName=lewisxhe/library/PCF8563_Library
+  lewisxhe/PCF8563_Library@1.0.1
+  # renovate: datasource=custom.pio depName=Adafruit DRV2605 packageName=adafruit/library/Adafruit DRV2605 Library
   adafruit/Adafruit DRV2605 Library@1.2.4