Vendor GxEPD2 from the zib fork, adding GDEY029F51 support

Switches the vendoring source from upstream ZinggJM/GxEPD2 to
git.zi3.xyz/code/zGxEPD2, a fork one commit past the 1.6.9 tag that
adds a driver for the 128x296 JD79667 BWRY panel Seeed sells as SKU
104990855 (a distinct, smaller panel from GDEY029F51H sharing the same
controller) - upstream has no equivalent. Regenerated catalog.json,
now 101 panels.

components/gxepd2/catalog.json

@@ -415,6 +415,14 @@
     "source": "epd3c/GxEPD2_290c.cpp",
     "wrapper": "GxEPD2_3C"
   },
+  "GxEPD2_290c_GDEY029F51": {
+    "comment": "GDEY029F51 128x296, JD79667 (BWRY)",
+    "ctor_args": 4,
+    "driver": "GxEPD2_290c_GDEY029F51",
+    "height_divisor": 1,
+    "source": "epd4c/GxEPD2_290c_GDEY029F51.cpp",
+    "wrapper": "GxEPD2_4C"
+  },
   "GxEPD2_290c_GDEY029F51H": {
     "comment": "GDEY029F51H 168x384, JD79667 (FPC-H004 22.03.24)",
     "ctor_args": 4,

components/gxepd2/vendor/library.properties

@@ -1,10 +1,10 @@
 name=GxEPD2
-version=1.6.9
+version=1.6.9+zib.1
 author=Jean-Marc Zingg
 maintainer=Jean-Marc Zingg
-sentence=Arduino Display Library for SPI E-Paper displays from Dalian Good Display and Waveshare. 
+sentence=Arduino Display Library for SPI E-Paper displays from Dalian Good Display and Waveshare.
 paragraph=Requires HW SPI and Adafruit_GFX. Caution: the bare e-paper panels require 3.3V supply AND data lines!
 category=Display
-url=https://github.com/ZinggJM/GxEPD2
+url=https://git.zi3.xyz/code/zGxEPD2 (fork of https://github.com/ZinggJM/GxEPD2)
 architectures=*
 depends=Adafruit GFX Library

components/gxepd2/vendor/src/GxEPD2.h

@@ -125,6 +125,7 @@ class GxEPD2
       GDEY0213F51,
       GDEY0266F51H,
       GDEY029F51H,
+      GDEY029F51,
       Waveshare3inch4color,
       GDEM035F51,
       GDEM0397F81,

components/gxepd2/vendor/src/GxEPD2_4C.h

@@ -60,6 +60,9 @@
 #if __has_include("epd4c/GxEPD2_290c_GDEY029F51H.h")
 #include "epd4c/GxEPD2_290c_GDEY029F51H.h"
 #endif
+#if __has_include("epd4c/GxEPD2_290c_GDEY029F51.h")
+#include "epd4c/GxEPD2_290c_GDEY029F51.h"
+#endif
 #if __has_include("epd4c/GxEPD2_300c.h")
 #include "epd4c/GxEPD2_300c.h"
 #endif

components/gxepd2/vendor/src/epd4c/GxEPD2_290c_GDEY029F51.cpp

@@ -0,0 +1,976 @@
+// Display Library for SPI e-paper panels from Dalian Good Display and boards from Waveshare.
+// Requires HW SPI and Adafruit_GFX. Caution: the e-paper panels require 3.3V supply AND data lines!
+//
+// init code adapted from GDEY029F51H (same JD79667 controller), and cross-checked against the
+// JD79667 driver in https://github.com/Seeed-Studio/Seeed_GFX2 (src/driver/epaper/Driver_JD79667.cpp)
+// Panel: GDEY029F51 (128x296, BWRY)
+// Controller: JD79667, no specs, see GDEY0266F51H panel specs for command list subset
+//
+// Author: Jean-Marc Zingg
+//
+// Version: see library.properties
+//
+// Library: https://github.com/ZinggJM/GxEPD2
+
+#include "GxEPD2_290c_GDEY029F51.h"
+
+GxEPD2_290c_GDEY029F51::GxEPD2_290c_GDEY029F51(int16_t cs, int16_t dc, int16_t rst, int16_t busy) :
+  GxEPD2_EPD(cs, dc, rst, busy, LOW, 50000000, WIDTH, HEIGHT, panel, hasColor, hasPartialUpdate, hasFastPartialUpdate)
+{
+  _paged = false;
+}
+
+void GxEPD2_290c_GDEY029F51::clearScreen(uint8_t value)
+{
+  clearScreen(value, 0xFF);
+}
+
+void GxEPD2_290c_GDEY029F51::clearScreen(uint8_t black_value, uint8_t color_value)
+{
+  writeScreenBuffer(black_value, color_value);
+  refresh();
+}
+
+void GxEPD2_290c_GDEY029F51::writeScreenBuffer(uint8_t value)
+{
+  writeScreenBuffer(value, 0xFF);
+}
+
+void GxEPD2_290c_GDEY029F51::writeScreenBuffer(uint8_t black_value, uint8_t color_value)
+{
+  //Serial.println("writeScreenBuffer");
+  if (!_init_display_done) _InitDisplay();
+  _writeCommand(0x10);
+  _startTransfer();
+  for (uint32_t i = 0; i < uint32_t(WIDTH) * uint32_t(HEIGHT) / 4; i++)
+  {
+    _transfer(0xFF == black_value ? 0x55 : 0x00);
+  }
+  _endTransfer();
+  _initial_write = false; // initial full screen buffer clean done
+}
+
+void GxEPD2_290c_GDEY029F51::writeImage(const uint8_t bitmap[], int16_t x, int16_t y, int16_t w, int16_t h, bool invert, bool mirror_y, bool pgm)
+{
+  //Serial.print("writeImage("); Serial.print(x); Serial.print(", "); Serial.print(y); Serial.print(", ");
+  //Serial.print(w); Serial.print(", "); Serial.print(h); Serial.println(")");
+  delay(1); // yield() to avoid WDT on ESP8266 and ESP32
+  if (!_init_display_done) _InitDisplay();
+  if (_initial_write) writeScreenBuffer();
+  if (hasPartialUpdate)
+  {
+    int16_t wb = (w + 7) / 8; // width bytes, bitmaps are padded
+    x -= x % 8; // byte boundary
+    w = wb * 8; // byte boundary
+    int16_t x1 = x < 0 ? 0 : x; // limit
+    int16_t y1 = y < 0 ? 0 : y; // limit
+    int16_t w1 = x + w < int16_t(WIDTH) ? w : int16_t(WIDTH) - x; // limit
+    int16_t h1 = y + h < int16_t(HEIGHT) ? h : int16_t(HEIGHT) - y; // limit
+    int16_t dx = x1 - x;
+    int16_t dy = y1 - y;
+    w1 -= dx;
+    h1 -= dy;
+    if ((w1 <= 0) || (h1 <= 0)) return;
+    _setPartialRamArea(x1, y1, w1, h1);
+    _writeCommand(0x10);
+    _startTransfer();
+    for (int16_t i = 0; i < h1; i++)
+    {
+      for (int16_t j = 0; j < w1 / 8; j++)
+      {
+        uint8_t data = 0xFF;
+        // use wb, h of bitmap for index!
+        uint32_t idx = mirror_y ? j + dx / 8 + uint32_t((h - 1 - (i + dy))) * wb : j + dx / 8 + uint32_t(i + dy) * wb;
+        if (pgm)
+        {
+#if defined(__AVR) || defined(ESP8266) || defined(ESP32)
+          data = pgm_read_byte(&bitmap[idx]);
+#else
+          data = bitmap[idx];
+#endif
+        }
+        else
+        {
+          data = bitmap[idx];
+        }
+        if (invert) data = ~data;
+        for (int16_t k = 0; k < 2; k++)
+        {
+          uint8_t data2 = (data & 0x80 ? 0x40 : 0x00) | (data & 0x40 ? 0x10 : 0x00) |
+                          (data & 0x20 ? 0x04 : 0x00) | (data & 0x10 ? 0x01 : 0x00);
+          data <<= 4;
+          _transfer(data2);
+        }
+      }
+    }
+    _endTransfer();
+  }
+  else
+  {
+    if (_paged && (x == 0) && (w == int16_t(WIDTH)) && (h < int16_t(HEIGHT)))
+    {
+      //Serial.println("paged");
+      _startTransfer();
+      for (uint32_t i = 0; i < uint32_t(WIDTH) * uint32_t(h) / 8; i++)
+      {
+        uint8_t data = bitmap[i];
+        for (int16_t k = 0; k < 2; k++)
+        {
+          uint8_t data2 = (data & 0x80 ? 0x40 : 0x00) | (data & 0x40 ? 0x10 : 0x00) |
+                          (data & 0x20 ? 0x04 : 0x00) | (data & 0x10 ? 0x01 : 0x00);
+          data <<= 4;
+          _transfer(data2);
+        }
+      }
+      _endTransfer();
+      if (y + h == HEIGHT) // last page
+      {
+        //Serial.println("paged ended");
+        _paged = false;
+      }
+    }
+    else
+    {
+      _paged = false;
+      int16_t wb = (w + 7) / 8; // width bytes, bitmaps are padded
+      x -= x % 8; // byte boundary
+      w = wb * 8; // byte boundary
+      if ((w <= 0) || (h <= 0)) return;
+      _writeCommand(0x10);
+      _startTransfer();
+      for (int16_t i = 0; i < int16_t(HEIGHT); i++)
+      {
+        for (int16_t j = 0; j < int16_t(WIDTH); j += 8)
+        {
+          uint8_t data = 0xFF;
+          if ((j >= x) && (j <= x + w) && (i >= y) && (i < y + h))
+          {
+            uint32_t idx = mirror_y ? (j - x) / 8 + uint32_t((h - 1 - (i - y))) * wb : (j - x) / 8 + uint32_t(i - y) * wb;
+            if (pgm)
+            {
+#if defined(__AVR) || defined(ESP8266) || defined(ESP32)
+              data = pgm_read_byte(&bitmap[idx]);
+#else
+              data = bitmap[idx];
+#endif
+            }
+            else
+            {
+              data = bitmap[idx];
+            }
+            if (invert) data = ~data;
+          }
+          for (int16_t k = 0; k < 2; k++)
+          {
+            uint8_t data2 = (data & 0x80 ? 0x40 : 0x00) | (data & 0x40 ? 0x10 : 0x00) |
+                            (data & 0x20 ? 0x04 : 0x00) | (data & 0x10 ? 0x01 : 0x00);
+            data <<= 4;
+            _transfer(data2);
+          }
+        }
+      }
+      _endTransfer();
+    }
+  }
+  delay(1); // yield() to avoid WDT on ESP8266 and ESP32
+}
+
+void GxEPD2_290c_GDEY029F51::writeImage(const uint8_t* black, const uint8_t* color, int16_t x, int16_t y, int16_t w, int16_t h, bool invert, bool mirror_y, bool pgm)
+{
+  if (!black && !color) return;
+  if (!color) return writeImage(black, x, y, w, h, invert, mirror_y, pgm);
+  //Serial.print("writeImage("); Serial.print(x); Serial.print(", "); Serial.print(y); Serial.print(", ");
+  //Serial.print(w); Serial.print(", "); Serial.print(h); Serial.println(")");
+  delay(1); // yield() to avoid WDT on ESP8266 and ESP32
+  if (!_init_display_done) _InitDisplay();
+  if (_initial_write) writeScreenBuffer();
+  if (hasPartialUpdate)
+  {
+    int16_t wb = (w + 7) / 8; // width bytes, bitmaps are padded
+    x -= x % 8; // byte boundary
+    w = wb * 8; // byte boundary
+    int16_t x1 = x < 0 ? 0 : x; // limit
+    int16_t y1 = y < 0 ? 0 : y; // limit
+    int16_t w1 = x + w < int16_t(WIDTH) ? w : int16_t(WIDTH) - x; // limit
+    int16_t h1 = y + h < int16_t(HEIGHT) ? h : int16_t(HEIGHT) - y; // limit
+    int16_t dx = x1 - x;
+    int16_t dy = y1 - y;
+    w1 -= dx;
+    h1 -= dy;
+    if ((w1 <= 0) || (h1 <= 0)) return;
+    _setPartialRamArea(x1, y1, w1, h1);
+    _writeCommand(0x10);
+    _startTransfer();
+    for (int16_t i = 0; i < h1; i++)
+    {
+      for (int16_t j = 0; j < w1 / 8; j++)
+      {
+        uint8_t black_data = 0xFF, color_data = 0xFF;
+        // use wb, h of bitmap for index!
+        uint32_t idx = mirror_y ? j + dx / 8 + uint32_t((h - 1 - (i + dy))) * wb : j + dx / 8 + uint32_t(i + dy) * wb;
+        if (pgm)
+        {
+#if defined(__AVR) || defined(ESP8266) || defined(ESP32)
+          black_data = pgm_read_byte(&black[idx]);
+          color_data = pgm_read_byte(&color[idx]);
+#else
+          black_data = black[idx];
+          color_data = color[idx];
+#endif
+        }
+        else
+        {
+          black_data = black[idx];
+          color_data = color[idx];
+        }
+        if (invert)
+        {
+          black_data = ~black_data;
+          color_data = ~color_data;
+        }
+        for (int16_t k = 0; k < 2; k++)
+        {
+          uint8_t out_data = 0x00;
+          for (int16_t l = 0; l < 4; l++)
+          {
+            out_data <<= 2;
+            if (!(color_data & 0x80)) out_data |= 0x03; // red
+            else out_data |= black_data & 0x80 ? 0x01 : 0x00; // white or black
+            black_data <<= 1;
+            color_data <<= 1;
+          }
+          _transfer(out_data);
+        }
+      }
+    }
+    _endTransfer();
+  }
+  else
+  {
+    if (_paged && (x == 0) && (w == int16_t(WIDTH)) && (h < int16_t(HEIGHT)))
+    {
+      //Serial.println("paged");
+      _startTransfer();
+      for (uint32_t i = 0; i < uint32_t(WIDTH) * uint32_t(h) / 8; i++)
+      {
+        uint8_t black_data = black[i];
+        uint8_t color_data = color[i];
+        for (int16_t k = 0; k < 2; k++)
+        {
+          uint8_t out_data = 0x00;
+          for (int16_t l = 0; l < 4; l++)
+          {
+            out_data <<= 2;
+            if (!(color_data & 0x80)) out_data |= 0x03; // red
+            else out_data |= black_data & 0x80 ? 0x01 : 0x00; // white or black
+            black_data <<= 1;
+            color_data <<= 1;
+          }
+          _transfer(out_data);
+        }
+      }
+      _endTransfer();
+      if (y + h == HEIGHT) // last page
+      {
+        //Serial.println("paged ended");
+        _paged = false;
+      }
+    }
+    else
+    {
+      _paged = false;
+      int16_t wb = (w + 7) / 8; // width bytes, bitmaps are padded
+      x -= x % 8; // byte boundary
+      w = wb * 8; // byte boundary
+      if ((w <= 0) || (h <= 0)) return;
+      _writeCommand(0x10);
+      _startTransfer();
+      for (int16_t i = 0; i < int16_t(HEIGHT); i++)
+      {
+        for (int16_t j = 0; j < int16_t(WIDTH); j += 8)
+        {
+          uint8_t black_data = 0xFF, color_data = 0xFF;
+          if ((j >= x) && (j < x + w) && (i >= y) && (i < y + h))
+          {
+            uint32_t idx = mirror_y ? (j - x) / 8 + uint32_t((h - 1 - (i - y))) * wb : (j - x) / 8 + uint32_t(i - y) * wb;
+            if (pgm)
+            {
+#if defined(__AVR) || defined(ESP8266) || defined(ESP32)
+              black_data = pgm_read_byte(&black[idx]);
+              color_data = pgm_read_byte(&color[idx]);
+#else
+              black_data = black[idx];
+              color_data = color[idx];
+#endif
+            }
+            else
+            {
+              black_data = black[idx];
+              color_data = color[idx];
+            }
+            if (invert)
+            {
+              black_data = ~black_data;
+              color_data = ~color_data;
+            }
+          }
+          for (int16_t k = 0; k < 2; k++)
+          {
+            uint8_t out_data = 0x00;
+            for (int16_t l = 0; l < 4; l++)
+            {
+              out_data <<= 2;
+              if (!(color_data & 0x80)) out_data |= 0x03; // red
+              else out_data |= black_data & 0x80 ? 0x01 : 0x00; // white or black
+              black_data <<= 1;
+              color_data <<= 1;
+            }
+            _transfer(out_data);
+          }
+        }
+      }
+      _endTransfer();
+    }
+  }
+  delay(1); // yield() to avoid WDT on ESP8266 and ESP32
+}
+
+void GxEPD2_290c_GDEY029F51::writeImagePart(const uint8_t bitmap[], int16_t x_part, int16_t y_part, int16_t w_bitmap, int16_t h_bitmap,
+    int16_t x, int16_t y, int16_t w, int16_t h, bool invert, bool mirror_y, bool pgm)
+{
+  //Serial.print("writeImagePart("); Serial.print(x_part); Serial.print(", "); Serial.print(y_part); Serial.print(", ");
+  //Serial.print(w_bitmap); Serial.print(", "); Serial.print(h_bitmap); Serial.print(", ");
+  //Serial.print(x); Serial.print(", "); Serial.print(y); Serial.print(", ");
+  //Serial.print(w); Serial.print(", "); Serial.print(h); Serial.println(")");
+  delay(1); // yield() to avoid WDT on ESP8266 and ESP32
+  if (!_init_display_done) _InitDisplay();
+  if (_initial_write) writeScreenBuffer();
+  if ((w_bitmap < 0) || (h_bitmap < 0) || (w < 0) || (h < 0)) return;
+  if ((x_part < 0) || (x_part >= w_bitmap)) return;
+  if ((y_part < 0) || (y_part >= h_bitmap)) return;
+  int16_t wb_bitmap = (w_bitmap + 7) / 8; // width bytes, bitmaps are padded
+  x_part -= x_part % 8; // byte boundary
+  w = w_bitmap - x_part < w ? w_bitmap - x_part : w; // limit
+  h = h_bitmap - y_part < h ? h_bitmap - y_part : h; // limit
+  // make x, w multiple of 8
+  w += x % 8; // adjust for byte boundary of x
+  x -= x % 8; // byte boundary ox
+  w = 8 * ((w + 7) / 8); // byte boundary, bitmaps are padded
+  int16_t x1 = x < 0 ? 0 : x; // limit
+  int16_t y1 = y < 0 ? 0 : y; // limit
+  int16_t w1 = x + w < int16_t(WIDTH) ? w : int16_t(WIDTH) - x; // limit
+  int16_t h1 = y + h < int16_t(HEIGHT) ? h : int16_t(HEIGHT) - y; // limit
+  int16_t dx = x1 - x;
+  int16_t dy = y1 - y;
+  w1 -= dx;
+  h1 -= dy;
+  if ((w1 <= 0) || (h1 <= 0)) return;
+  if (hasPartialUpdate)
+  {
+    _setPartialRamArea(x1, y1, w1, h1);
+    _writeCommand(0x10);
+    _startTransfer();
+    for (int16_t i = 0; i < h1; i++)
+    {
+      for (int16_t j = 0; j < w1 / 8; j++)
+      {
+        uint8_t data;
+        // use wb_bitmap, h_bitmap of bitmap for index!
+        uint32_t idx = mirror_y ? x_part / 8 + j + dx / 8 + uint32_t((h_bitmap - 1 - (y_part + i + dy))) * wb_bitmap : x_part / 8 + j + dx / 8 + uint32_t(y_part + i + dy) * wb_bitmap;
+        if (pgm)
+        {
+#if defined(__AVR) || defined(ESP8266) || defined(ESP32)
+          data = pgm_read_byte(&bitmap[idx]);
+#else
+          data = bitmap[idx];
+#endif
+        }
+        else
+        {
+          data = bitmap[idx];
+        }
+        if (invert) data = ~data;
+        for (int16_t k = 0; k < 2; k++)
+        {
+          uint8_t data2 = (data & 0x80 ? 0x40 : 0x00) | (data & 0x40 ? 0x10 : 0x00) |
+                          (data & 0x20 ? 0x04 : 0x00) | (data & 0x10 ? 0x01 : 0x00);
+          data <<= 4;
+          _transfer(data2);
+        }
+      }
+    }
+    _endTransfer();
+  }
+  else
+  {
+    _writeCommand(0x10);
+    _startTransfer();
+    for (int16_t i = 0; i < int16_t(HEIGHT); i++)
+    {
+      for (int16_t j = 0; j < int16_t(WIDTH); j += 8)
+      {
+        uint8_t data = 0xFF;
+        if ((j >= x1) && (j < x1 + w) && (i >= y1) && (i < y1 + h))
+        {
+          // use wb_bitmap, h_bitmap of bitmap for index!
+          uint32_t idx = mirror_y ? (x_part + j - x1) / 8 + uint32_t((h_bitmap - 1 - (y_part + i - y1))) * wb_bitmap : (x_part + j - x1) / 8 + uint32_t(y_part + i - y1) * wb_bitmap;
+          if (pgm)
+          {
+#if defined(__AVR) || defined(ESP8266) || defined(ESP32)
+            data = pgm_read_byte(&bitmap[idx]);
+#else
+            data = bitmap[idx];
+#endif
+          }
+          else
+          {
+            data = bitmap[idx];
+          }
+          if (invert) data = ~data;
+        }
+        for (int16_t k = 0; k < 2; k++)
+        {
+          uint8_t data2 = (data & 0x80 ? 0x40 : 0x00) | (data & 0x40 ? 0x10 : 0x00) |
+                          (data & 0x20 ? 0x04 : 0x00) | (data & 0x10 ? 0x01 : 0x00);
+          data <<= 4;
+          _transfer(data2);
+        }
+      }
+    }
+    _endTransfer();
+  }
+  delay(1); // yield() to avoid WDT on ESP8266 and ESP32
+}
+
+void GxEPD2_290c_GDEY029F51::writeImagePart(const uint8_t* black, const uint8_t* color, int16_t x_part, int16_t y_part, int16_t w_bitmap, int16_t h_bitmap,
+    int16_t x, int16_t y, int16_t w, int16_t h, bool invert, bool mirror_y, bool pgm)
+{
+  //Serial.print("writeImagePart("); Serial.print(x_part); Serial.print(", "); Serial.print(y_part); Serial.print(", ");
+  //Serial.print(w_bitmap); Serial.print(", "); Serial.print(h_bitmap); Serial.print(", ");
+  //Serial.print(x); Serial.print(", "); Serial.print(y); Serial.print(", ");
+  //Serial.print(w); Serial.print(", "); Serial.print(h); Serial.println(")");
+  if (!black && !color) return;
+  if (!color) return writeImagePart(black, x_part, y_part, w_bitmap, h_bitmap, x, y, w, h, invert, mirror_y, pgm);
+  if (!_init_display_done) _InitDisplay();
+  if (_initial_write) writeScreenBuffer();
+  delay(1); // yield() to avoid WDT on ESP8266 and ESP32
+  if ((w_bitmap < 0) || (h_bitmap < 0) || (w < 0) || (h < 0)) return;
+  if ((x_part < 0) || (x_part >= w_bitmap)) return;
+  if ((y_part < 0) || (y_part >= h_bitmap)) return;
+  int16_t wb_bitmap = (w_bitmap + 7) / 8; // width bytes, bitmaps are padded
+  x_part -= x_part % 8; // byte boundary
+  w = w_bitmap - x_part < w ? w_bitmap - x_part : w; // limit
+  h = h_bitmap - y_part < h ? h_bitmap - y_part : h; // limit
+  // make x, w multiple of 8
+  w += x % 8; // adjust for byte boundary of x
+  x -= x % 8; // byte boundary ox
+  w = 8 * ((w + 7) / 8); // byte boundary, bitmaps are padded
+  int16_t x1 = x < 0 ? 0 : x; // limit
+  int16_t y1 = y < 0 ? 0 : y; // limit
+  int16_t w1 = x + w < int16_t(WIDTH) ? w : int16_t(WIDTH) - x; // limit
+  int16_t h1 = y + h < int16_t(HEIGHT) ? h : int16_t(HEIGHT) - y; // limit
+  int16_t dx = x1 - x;
+  int16_t dy = y1 - y;
+  w1 -= dx;
+  h1 -= dy;
+  if ((w1 <= 0) || (h1 <= 0)) return;
+  if (hasPartialUpdate)
+  {
+    _setPartialRamArea(x1, y1, w1, h1);
+    _writeCommand(0x10);
+    _startTransfer();
+    for (int16_t i = 0; i < h1; i++)
+    {
+      for (int16_t j = 0; j < w1 / 8; j++)
+      {
+        uint8_t black_data = 0xFF, color_data = 0xFF;
+        // use wb_bitmap, h_bitmap of bitmap for index!
+        uint32_t idx = mirror_y ? x_part / 8 + j + dx / 8 + uint32_t((h_bitmap - 1 - (y_part + i + dy))) * wb_bitmap : x_part / 8 + j + dx / 8 + uint32_t(y_part + i + dy) * wb_bitmap;
+        if (pgm)
+        {
+#if defined(__AVR) || defined(ESP8266) || defined(ESP32)
+          black_data = pgm_read_byte(&black[idx]);
+          color_data = pgm_read_byte(&color[idx]);
+#else
+          black_data = black[idx];
+          color_data = color[idx];
+#endif
+        }
+        else
+        {
+          black_data = black[idx];
+          color_data = color[idx];
+        }
+        for (int16_t k = 0; k < 2; k++)
+        {
+          uint8_t out_data = 0x00;
+          for (int16_t l = 0; l < 4; l++)
+          {
+            out_data <<= 2;
+            if (!(color_data & 0x80)) out_data |= 0x03; // red
+            else out_data |= black_data & 0x80 ? 0x01 : 0x00; // white or black
+            black_data <<= 1;
+            color_data <<= 1;
+          }
+          _transfer(out_data);
+        }
+      }
+    }
+    _endTransfer();
+  }
+  else
+  {
+    _writeCommand(0x10);
+    _startTransfer();
+    for (int16_t i = 0; i < int16_t(HEIGHT); i++)
+    {
+      for (int16_t j = 0; j < int16_t(WIDTH); j += 8)
+      {
+        uint8_t black_data = 0xFF, color_data = 0xFF;
+        if ((j >= x1) && (j < x1 + w) && (i >= y1) && (i < y1 + h))
+        {
+          // use wb_bitmap, h_bitmap of bitmap for index!
+          uint32_t idx = mirror_y ? (x_part + j - x1) / 8 + uint32_t((h_bitmap - 1 - (y_part + i - y1))) * wb_bitmap : (x_part + j - x1) / 8 + uint32_t(y_part + i - y1) * wb_bitmap;
+          if (pgm)
+          {
+#if defined(__AVR) || defined(ESP8266) || defined(ESP32)
+            black_data = pgm_read_byte(&black[idx]);
+            color_data = pgm_read_byte(&color[idx]);
+#else
+            black_data = black[idx];
+            color_data = color[idx];
+#endif
+          }
+          else
+          {
+            black_data = black[idx];
+            color_data = color[idx];
+          }
+          if (invert)
+          {
+            black_data = ~black_data;
+            color_data = ~color_data;
+          }
+        }
+        for (int16_t k = 0; k < 2; k++)
+        {
+          uint8_t out_data = 0x00;
+          for (int16_t l = 0; l < 4; l++)
+          {
+            out_data <<= 2;
+            if (!(color_data & 0x80)) out_data |= 0x03; // red
+            else out_data |= black_data & 0x80 ? 0x01 : 0x00; // white or black
+            black_data <<= 1;
+            color_data <<= 1;
+          }
+          _transfer(out_data);
+        }
+      }
+    }
+    _endTransfer();
+  }
+  delay(1); // yield() to avoid WDT on ESP8266 and ESP32
+}
+
+void GxEPD2_290c_GDEY029F51::writeNative(const uint8_t* data1, const uint8_t* data2, int16_t x, int16_t y, int16_t w, int16_t h, bool invert, bool mirror_y, bool pgm)
+{
+  if (!data1) return;
+  //Serial.print("writeNative("); Serial.print(x); Serial.print(", "); Serial.print(y); Serial.print(", ");
+  //Serial.print(w); Serial.print(", "); Serial.print(h); Serial.println(")");
+  delay(1); // yield() to avoid WDT on ESP8266 and ESP32
+  if (!_init_display_done) _InitDisplay();
+  if (_initial_write) writeScreenBuffer();
+  if (hasPartialUpdate)
+  {
+    int16_t wb = (w + 3) / 4; // width bytes, bitmaps are padded
+    x -= x % 4; // byte boundary
+    w = wb * 4; // byte boundary
+    int16_t x1 = x < 0 ? 0 : x; // limit
+    int16_t y1 = y < 0 ? 0 : y; // limit
+    int16_t w1 = x + w < int16_t(WIDTH) ? w : int16_t(WIDTH) - x; // limit
+    int16_t h1 = y + h < int16_t(HEIGHT) ? h : int16_t(HEIGHT) - y; // limit
+    int16_t dx = x1 - x;
+    int16_t dy = y1 - y;
+    w1 -= dx;
+    h1 -= dy;
+    if ((w1 <= 0) || (h1 <= 0)) return;
+    _setPartialRamArea(x1, y1, w1, h1);
+    _writeCommand(0x10);
+    _startTransfer();
+    for (int16_t i = 0; i < h1; i++)
+    {
+      for (int16_t j = 0; j < w1 / 4; j++)
+      {
+        uint8_t data;
+        // use wb, h of bitmap for index!
+        uint32_t idx = mirror_y ? j + dx / 4 + uint32_t((h - 1 - (i + dy))) * wb : j + dx / 4 + uint32_t(i + dy) * wb;
+        if (pgm)
+        {
+#if defined(__AVR) || defined(ESP8266) || defined(ESP32)
+          data = pgm_read_byte(&data1[idx]);
+#else
+          data = data1[idx];
+#endif
+        }
+        else
+        {
+          data = data1[idx];
+        }
+        if (invert) data = ~data;
+        _transfer(data);
+      }
+    }
+    _endTransfer();
+  }
+  else
+  {
+    if (_paged && (x == 0) && (w == int16_t(WIDTH)) && (h < int16_t(HEIGHT)))
+    {
+      //Serial.println("paged");
+      _startTransfer();
+      for (uint32_t i = 0; i < uint32_t(WIDTH) * uint32_t(h) / 4; i++)
+      {
+        uint8_t data = data1[i];
+        _transfer(data);
+      }
+      _endTransfer();
+      if (y + h == HEIGHT) // last page
+      {
+        //Serial.println("paged ended");
+        _paged = false;
+      }
+    }
+    else
+    {
+      //Serial.println("not paged");
+      _paged = false;
+      int16_t wb = (w + 3) / 4; // width bytes, bitmaps are padded
+      x -= x % 4; // byte boundary
+      w = wb * 4; // byte boundary
+      if ((w <= 0) || (h <= 0)) return;
+      _writeCommand(0x10);
+      _startTransfer();
+      for (int16_t i = 0; i < int16_t(HEIGHT); i++)
+      {
+        for (int16_t j = 0; j < int16_t(WIDTH); j += 4)
+        {
+          uint8_t data = 0x55;
+          if (data1)
+          {
+            if ((j >= x) && (j < x + w) && (i >= y) && (i < y + h))
+            {
+              uint32_t idx = mirror_y ? (j - x) / 4 + uint32_t((h - 1 - (i - y))) * wb : (j - x) / 4 + uint32_t(i - y) * wb;
+              if (pgm)
+              {
+#if defined(__AVR) || defined(ESP8266) || defined(ESP32)
+                data = pgm_read_byte(&data1[idx]);
+#else
+                data = data1[idx];
+#endif
+              }
+              else
+              {
+                data = data1[idx];
+              }
+              if (invert) data = ~data;
+            }
+          }
+          _transfer(data);
+        }
+      }
+      _endTransfer();
+    }
+  }
+  delay(1); // yield() to avoid WDT on ESP8266 and ESP32
+}
+
+void GxEPD2_290c_GDEY029F51::writeNativePart(const uint8_t* data1, const uint8_t* data2, int16_t x_part, int16_t y_part, int16_t w_bitmap, int16_t h_bitmap,
+    int16_t x, int16_t y, int16_t w, int16_t h, bool invert, bool mirror_y, bool pgm)
+{
+  if (!data1) return;
+  delay(1); // yield() to avoid WDT on ESP8266 and ESP32
+  if (!_init_display_done) _InitDisplay();
+  if (_initial_write) writeScreenBuffer();
+  if ((w_bitmap < 0) || (h_bitmap < 0) || (w < 0) || (h < 0)) return;
+  if ((x_part < 0) || (x_part >= w_bitmap)) return;
+  if ((y_part < 0) || (y_part >= h_bitmap)) return;
+  int16_t wb_bitmap = (w_bitmap + 3) / 4; // width bytes, bitmaps are padded
+  x_part -= x_part % 4; // byte boundary
+  w = w_bitmap - x_part < w ? w_bitmap - x_part : w; // limit
+  h = h_bitmap - y_part < h ? h_bitmap - y_part : h; // limit
+  w += x % 4; // adjust for byte boundary of x
+  x -= x % 4; // byte boundary
+  w = 4 * ((w + 3) / 4); // byte boundary, bitmaps are padded
+  int16_t x1 = x < 0 ? 0 : x; // limit
+  int16_t y1 = y < 0 ? 0 : y; // limit
+  int16_t w1 = x + w < int16_t(WIDTH) ? w : int16_t(WIDTH) - x; // limit
+  int16_t h1 = y + h < int16_t(HEIGHT) ? h : int16_t(HEIGHT) - y; // limit
+  int16_t dx = x1 - x;
+  int16_t dy = y1 - y;
+  w1 -= dx;
+  h1 -= dy;
+  if ((w1 <= 0) || (h1 <= 0)) return;
+  if (hasPartialUpdate)
+  {
+    _setPartialRamArea(x1, y1, w1, h1);
+    _writeCommand(0x10);
+    _startTransfer();
+    for (int16_t i = 0; i < h1; i++)
+    {
+      for (int16_t j = 0; j < w1 / 4; j++)
+      {
+        uint8_t data;
+        // use wb_bitmap, h_bitmap of bitmap for index!
+        uint32_t idx = mirror_y ? x_part / 4 + j + dx / 4 + uint32_t((h_bitmap - 1 - (y_part + i + dy))) * wb_bitmap : x_part / 4 + j + dx / 4 + uint32_t(y_part + i + dy) * wb_bitmap;
+        if (pgm)
+        {
+#if defined(__AVR) || defined(ESP8266) || defined(ESP32)
+          data = pgm_read_byte(&data1[idx]);
+#else
+          data = data1[idx];
+#endif
+        }
+        else
+        {
+          data = data1[idx];
+        }
+        if (invert) data = ~data;
+        _transfer(data);
+      }
+    }
+    _endTransfer();
+  }
+  else
+  {
+    _writeCommand(0x10);
+    _startTransfer();
+    for (int16_t i = 0; i < int16_t(HEIGHT); i++)
+    {
+      for (int16_t j = 0; j < int16_t(WIDTH); j += 4)
+      {
+        uint8_t data = 0x55;
+        if ((j >= x1) && (j < x1 + w) && (i >= y1) && (i < y1 + h))
+        {
+          // use wb_bitmap, h_bitmap of bitmap for index!
+          uint32_t idx = mirror_y ? (x_part + j - x1) / 4 + uint32_t((h_bitmap - 1 - (y_part + i - y1))) * wb_bitmap : (x_part + j - x1) / 4 + uint32_t(y_part + i - y1) * wb_bitmap;
+          if (pgm)
+          {
+#if defined(__AVR) || defined(ESP8266) || defined(ESP32)
+            data = pgm_read_byte(&data1[idx]);
+#else
+            data = data1[idx];
+#endif
+          }
+          else
+          {
+            data = data1[idx];
+          }
+          if (invert) data = ~data;
+        }
+        _transfer(data);
+      }
+    }
+    _endTransfer();
+  }
+  delay(1); // yield() to avoid WDT on ESP8266 and ESP32
+}
+
+void GxEPD2_290c_GDEY029F51::drawImage(const uint8_t bitmap[], int16_t x, int16_t y, int16_t w, int16_t h, bool invert, bool mirror_y, bool pgm)
+{
+  writeImage(bitmap, x, y, w, h, invert, mirror_y, pgm);
+  refresh(x, y, w, h);
+}
+
+void GxEPD2_290c_GDEY029F51::drawImagePart(const uint8_t bitmap[], int16_t x_part, int16_t y_part, int16_t w_bitmap, int16_t h_bitmap,
+    int16_t x, int16_t y, int16_t w, int16_t h, bool invert, bool mirror_y, bool pgm)
+{
+  writeImagePart(bitmap, x_part, y_part, w_bitmap, h_bitmap, x, y, w, h, invert, mirror_y, pgm);
+  refresh(x, y, w, h);
+}
+
+void GxEPD2_290c_GDEY029F51::drawImage(const uint8_t* black, const uint8_t* color, int16_t x, int16_t y, int16_t w, int16_t h, bool invert, bool mirror_y, bool pgm)
+{
+  writeImage(black, color, x, y, w, h, invert, mirror_y, pgm);
+  refresh(x, y, w, h);
+}
+
+void GxEPD2_290c_GDEY029F51::drawImagePart(const uint8_t* black, const uint8_t* color, int16_t x_part, int16_t y_part, int16_t w_bitmap, int16_t h_bitmap,
+    int16_t x, int16_t y, int16_t w, int16_t h, bool invert, bool mirror_y, bool pgm)
+{
+  writeImagePart(black, color, x_part, y_part, w_bitmap, h_bitmap, x, y, w, h, invert, mirror_y, pgm);
+  refresh(x, y, w, h);
+}
+
+void GxEPD2_290c_GDEY029F51::drawNative(const uint8_t* data1, const uint8_t* data2, int16_t x, int16_t y, int16_t w, int16_t h, bool invert, bool mirror_y, bool pgm)
+{
+  writeNative(data1, data2, x, y, w, h, invert, mirror_y, pgm);
+  refresh(x, y, w, h);
+}
+
+void GxEPD2_290c_GDEY029F51::refresh(bool partial_update_mode)
+{
+  if (hasPartialUpdate) _setPartialRamArea(0, 0, WIDTH, HEIGHT);
+  _refresh(partial_update_mode);
+}
+
+void GxEPD2_290c_GDEY029F51::refresh(int16_t x, int16_t y, int16_t w, int16_t h)
+{
+  // intersection with screen
+  int16_t w1 = x < 0 ? w + x : w; // reduce
+  int16_t h1 = y < 0 ? h + y : h; // reduce
+  int16_t x1 = x < 0 ? 0 : x; // limit
+  int16_t y1 = y < 0 ? 0 : y; // limit
+  w1 = x1 + w1 < int16_t(WIDTH) ? w1 : int16_t(WIDTH) - x1; // limit
+  h1 = y1 + h1 < int16_t(HEIGHT) ? h1 : int16_t(HEIGHT) - y1; // limit
+  if ((w1 <= 0) || (h1 <= 0)) return;
+  // make x1, w1 multiple of 4
+  w1 += x1 % 4;
+  if (w1 % 4 > 0) w1 += 4 - w1 % 4;
+  x1 -= x1 % 4;
+  bool fullscreen = ((x1 == 0) && (y1 == 0) && (w1 == WIDTH) && (h1 == HEIGHT));
+  if (hasPartialUpdate) _setPartialRamArea(x1, y1, w1, h1, !fullscreen);
+  _refresh(!fullscreen);
+}
+
+void GxEPD2_290c_GDEY029F51::powerOff()
+{
+  _PowerOff();
+}
+
+void GxEPD2_290c_GDEY029F51::hibernate()
+{
+  _PowerOff();
+  if (_rst >= 0)
+  {
+    _writeCommand(0x07); // deep sleep
+    _writeData(0xA5);    // control code
+    _hibernating = true;
+    _init_display_done = false;
+  }
+}
+
+void GxEPD2_290c_GDEY029F51::setPaged()
+{
+  if (!hasPartialUpdate)
+  {
+    _paged = true;
+    _InitDisplay();
+    _writeCommand(0x10);
+  }
+}
+
+void GxEPD2_290c_GDEY029F51::_refresh(bool partial_update_mode)
+{
+  _writeCommand(0x50); // VCOM and Data Interval Setting
+  _writeData(partial_update_mode ? 0x97 : 0x37); // floating or white
+  _writeCommand(0x12); // Display Refresh
+  _writeData(0x00);
+  delay(1);
+  _waitWhileBusy("_refresh", full_refresh_time);
+  //_power_is_on = false; // not needed
+  _init_display_done = false; // needed
+}
+
+void GxEPD2_290c_GDEY029F51::_setPartialRamArea(uint16_t x, uint16_t y, uint16_t w, uint16_t h, bool partial_mode)
+{
+  //Serial.print("_setPartialRamArea("); Serial.print(x); Serial.print(", "); Serial.print(y); Serial.print(", ");
+  //Serial.print(w); Serial.print(", "); Serial.print(h); Serial.println(")");
+  _writeCommand(0x83);
+  _writeData(x / 256);
+  _writeData(x % 256);
+  _writeData((x + w - 1) / 256);
+  _writeData((x + w - 1) % 256);
+  _writeData(y / 256);
+  _writeData(y % 256);
+  _writeData((y + h - 1) / 256);
+  _writeData((y + h - 1) % 256);
+  _writeData(partial_mode ? 0x01 : 0x00);
+}
+
+void GxEPD2_290c_GDEY029F51::_PowerOn()
+{
+  if (!_power_is_on)
+  {
+    _writeCommand(0x04);
+    _waitWhileBusy("_PowerOn", power_on_time);
+  }
+  _power_is_on = true;
+}
+
+void GxEPD2_290c_GDEY029F51::_PowerOff()
+{
+  if (_power_is_on)
+  {
+    _writeCommand(0x02);
+    _writeData(0x00);
+    _waitWhileBusy("_PowerOff", power_off_time);
+  }
+  _power_is_on = false;
+}
+
+void GxEPD2_290c_GDEY029F51::_InitDisplay()
+{
+  //Serial.println("_InitDisplay");
+  // initcode adapted from GDEY029F51H (same JD79667 controller), TRES set to this panel's 128x296
+  if ((_rst >= 0) && (_hibernating || _initial_write))
+  {
+    digitalWrite(_rst, HIGH);
+    delay(20); // At least 20ms delay
+    digitalWrite(_rst, LOW); // Module reset
+    delay(2);  // At least 40ms delay, 2ms for WS "clever" reset
+    digitalWrite(_rst, HIGH);
+    delay(2); // At least 50ms delay (32ms measured)
+    _waitWhileBusy("_InitDisplay reset", power_on_time);
+    _hibernating = false;
+    _power_is_on = false;
+  }
+  _writeCommand(0x4D); // ??
+  _writeData(0x78);
+  _writeCommand(0x00); // PSR
+  _writeData(0x0F);    // default res (176x296)), scan up, shift left, booster on, no effect (no RST)
+  _writeData(0x29);    // LUT from MPT, no add scan, VCOM default, TS_AUTO, VGN default, VCOM default, VCOM floating after refresh
+  _writeCommand(0x01); // PWRR
+  _writeData(0x07);    // VMODE default, VSPL internal, VSP/VSN internal, VGP/VGN internal
+  _writeData(0x00);    // VGP/VGN 20V
+  _writeCommand(0x03); // POFS
+  _writeData(0x10);    // T_VDGP_OFF 40ms, T_VDS_OFF 20ms
+  _writeData(0x54);    // VGP_LEN 2500ms, VGP_EXT 2000ms
+  _writeData(0x44);    // XON_DLY 2000ms, XON_LEN 2000ms
+  _writeCommand(0x06); // BTST Booster Soft Start
+  _writeData(0x05);    // PHB_SFT, PHA_SFT
+  _writeData(0x00);    // PHA_ON
+  _writeData(0x3F);    // PHA_OFF
+  _writeData(0x0A);    // PHB_ON
+  _writeData(0x25);    // PHB_OFF
+  _writeData(0x12);    // PHC_ON
+  _writeData(0x1A);    // PHC_OFF
+  _writeCommand(0x50); // CDI
+  _writeData(0x37);    // (VBD 1, DDX 1) Gray1, 10hsync
+  //_writeData(0x17); // black border
+  //_writeData(0x37); // white border (default)
+  //_writeData(0x57); // yellow border
+  //_writeData(0x77); // red border
+  //_writeData(0x97); // floating border
+  _writeCommand(0x60); // TCON
+  _writeData(0x02);    // ?
+  _writeData(0x02);    // ?
+  _writeCommand(0x61);      // TRES
+  _writeData(WIDTH / 256);  // Source_BITS_H
+  _writeData(WIDTH % 256);  // Source_BITS_L
+  _writeData(HEIGHT / 256); // Gate_BITS_H
+  _writeData(HEIGHT % 256); // Gate_BITS_L
+  _writeCommand(0xE7); // ??
+  _writeData(0x1C);
+  _writeCommand(0xE3); // PWS
+  _writeData(0x22);
+  _writeCommand(0xB4); // LVD
+  _writeData(0xD0);
+  _writeCommand(0xB5); // ??
+  _writeData(0x03);
+  _writeCommand(0xE9); // ??
+  _writeData(0x01);
+  _writeCommand(0x30); // PLL
+  _writeData(0x08);    // Dynamic frame rate enabled
+  _PowerOn();
+  _init_display_done = true;
+}

components/gxepd2/vendor/src/epd4c/GxEPD2_290c_GDEY029F51.h

@@ -0,0 +1,78 @@
+// Display Library for SPI e-paper panels from Dalian Good Display and boards from Waveshare.
+// Requires HW SPI and Adafruit_GFX. Caution: the e-paper panels require 3.3V supply AND data lines!
+//
+// init code adapted from GDEY029F51H (same JD79667 controller), and cross-checked against the
+// JD79667 driver in https://github.com/Seeed-Studio/Seeed_GFX2 (src/driver/epaper/Driver_JD79667.cpp)
+// Panel: GDEY029F51 (128x296, BWRY)
+// Controller: JD79667, no specs, see GDEY0266F51H panel specs for command list subset
+//
+// Author: Jean-Marc Zingg
+//
+// Version: see library.properties
+//
+// Library: https://github.com/ZinggJM/GxEPD2
+
+#ifndef _GxEPD2_290c_GDEY029F51_H_
+#define _GxEPD2_290c_GDEY029F51_H_
+
+#include "../GxEPD2_EPD.h"
+
+class GxEPD2_290c_GDEY029F51 : public GxEPD2_EPD
+{
+  public:
+    // attributes
+    static const uint16_t WIDTH = 128;
+    static const uint16_t WIDTH_VISIBLE = WIDTH;
+    static const uint16_t HEIGHT = 296;
+    static const GxEPD2::Panel panel = GxEPD2::GDEY029F51;
+    static const bool hasColor = true;
+    static const bool hasPartialUpdate = true; // can be switched off
+    static const bool hasFastPartialUpdate = false;
+    static const uint16_t power_on_time = 200; // ms, e.g. 157485us
+    static const uint16_t power_off_time = 100; // ms, e.g. 81338us
+    static const uint16_t full_refresh_time = 25000; // ms, e.g. 21428295us
+    static const uint16_t partial_refresh_time = 25000; // ms, e.g. 21428295us
+    // constructor
+    GxEPD2_290c_GDEY029F51(int16_t cs, int16_t dc, int16_t rst, int16_t busy);
+    // methods (virtual)
+    //  Support for Bitmaps (Sprites) to Controller Buffer and to Screen
+    void clearScreen(uint8_t value = 0xFF); // init controller memory and screen (default white)
+    void clearScreen(uint8_t black_value, uint8_t color_value); // init controller memory and screen
+    void writeScreenBuffer(uint8_t value = 0xFF); // init controller memory (default white)
+    void writeScreenBuffer(uint8_t black_value, uint8_t color_value); // init controller memory
+    // write to controller memory, without screen refresh; x and w should be multiple of 8
+    void writeImage(const uint8_t bitmap[], int16_t x, int16_t y, int16_t w, int16_t h, bool invert = false, bool mirror_y = false, bool pgm = false);
+    void writeImagePart(const uint8_t bitmap[], int16_t x_part, int16_t y_part, int16_t w_bitmap, int16_t h_bitmap,
+                        int16_t x, int16_t y, int16_t w, int16_t h, bool invert = false, bool mirror_y = false, bool pgm = false);
+    void writeImage(const uint8_t* black, const uint8_t* color, int16_t x, int16_t y, int16_t w, int16_t h, bool invert = false, bool mirror_y = false, bool pgm = false);
+    void writeImagePart(const uint8_t* black, const uint8_t* color, int16_t x_part, int16_t y_part, int16_t w_bitmap, int16_t h_bitmap,
+                        int16_t x, int16_t y, int16_t w, int16_t h, bool invert = false, bool mirror_y = false, bool pgm = false);
+    // write sprite of native data to controller memory, without screen refresh; x and w should be multiple of 8
+    void writeNative(const uint8_t* data1, const uint8_t* data2, int16_t x, int16_t y, int16_t w, int16_t h, bool invert = false, bool mirror_y = false, bool pgm = false);
+    void writeNativePart(const uint8_t* data1, const uint8_t* data2, int16_t x_part, int16_t y_part, int16_t w_bitmap, int16_t h_bitmap,
+                        int16_t x, int16_t y, int16_t w, int16_t h, bool invert = false, bool mirror_y = false, bool pgm = false);
+    // write to controller memory, with screen refresh; x and w should be multiple of 8
+    void drawImage(const uint8_t bitmap[], int16_t x, int16_t y, int16_t w, int16_t h, bool invert = false, bool mirror_y = false, bool pgm = false);
+    void drawImagePart(const uint8_t bitmap[], int16_t x_part, int16_t y_part, int16_t w_bitmap, int16_t h_bitmap,
+                       int16_t x, int16_t y, int16_t w, int16_t h, bool invert = false, bool mirror_y = false, bool pgm = false);
+    void drawImage(const uint8_t* black, const uint8_t* color, int16_t x, int16_t y, int16_t w, int16_t h, bool invert = false, bool mirror_y = false, bool pgm = false);
+    void drawImagePart(const uint8_t* black, const uint8_t* color, int16_t x_part, int16_t y_part, int16_t w_bitmap, int16_t h_bitmap,
+                       int16_t x, int16_t y, int16_t w, int16_t h, bool invert = false, bool mirror_y = false, bool pgm = false);
+    // write sprite of native data to controller memory, with screen refresh; x and w should be multiple of 8
+    void drawNative(const uint8_t* data1, const uint8_t* data2, int16_t x, int16_t y, int16_t w, int16_t h, bool invert = false, bool mirror_y = false, bool pgm = false);
+    void refresh(bool partial_update_mode = false); // screen refresh from controller memory to full screen
+    void refresh(int16_t x, int16_t y, int16_t w, int16_t h); // screen refresh from controller memory, partial screen
+    void powerOff(); // turns off generation of panel driving voltages, avoids screen fading over time
+    void hibernate(); // turns powerOff() and sets controller to deep sleep for minimum power use, ONLY if wakeable by RST (rst >= 0)
+    void setPaged(); // for GxEPD2_154c paged workaround, also for 4-color for use with hasPartialUpdate = false
+  private:
+    void _refresh(bool partial_update_mode);
+    void _setPartialRamArea(uint16_t x, uint16_t y, uint16_t w, uint16_t h, bool partial_mode = true);
+    void _PowerOn();
+    void _PowerOff();
+    void _InitDisplay();
+  private:
+    bool _paged;
+};
+
+#endif

tools/gxepd2_catalog/GxEPD2_display_selection.h

@@ -104,6 +104,7 @@
 //GxEPD2_4C<GxEPD2_213c_GDEY0213F51, GxEPD2_213c_GDEY0213F51::HEIGHT> display(GxEPD2_213c_GDEY0213F51(/*CS=D8*/ SS, /*DC=D3*/ 0, /*RST=D4*/ 2, /*BUSY=D2*/ 4)); // GDEY0213F51 122x250, JD79661 (FPC-A002 20.04.08)
 //GxEPD2_4C<GxEPD2_266c_GDEY0266F51H, GxEPD2_266c_GDEY0266F51H::HEIGHT> display(GxEPD2_266c_GDEY0266F51H(/*CS=D8*/ SS, /*DC=D3*/ 0, /*RST=D4*/ 2, /*BUSY=D2*/ 4)); // GDEY0266F51H 184x360, JD79667 (FPC-H006 22.04.02)
 //GxEPD2_4C<GxEPD2_290c_GDEY029F51H, GxEPD2_290c_GDEY029F51H::HEIGHT> display(GxEPD2_290c_GDEY029F51H(/*CS=D8*/ SS, /*DC=D3*/ 0, /*RST=D4*/ 2, /*BUSY=D2*/ 4)); // GDEY029F51H 168x384, JD79667 (FPC-H004 22.03.24)
+//GxEPD2_4C<GxEPD2_290c_GDEY029F51, GxEPD2_290c_GDEY029F51::HEIGHT> display(GxEPD2_290c_GDEY029F51(/*CS=D8*/ SS, /*DC=D3*/ 0, /*RST=D4*/ 2, /*BUSY=D2*/ 4)); // GDEY029F51 128x296, JD79667 (BWRY)
 //GxEPD2_4C<GxEPD2_300c, GxEPD2_300c::HEIGHT> display(GxEPD2_300c(/*CS=D8*/ SS, /*DC=D3*/ 0, /*RST=D4*/ 2, /*BUSY=D2*/ 4)); // Waveshare 3.00" 4-color
 //GxEPD2_4C<GxEPD2_350c_GDEM035F51, GxEPD2_350c_GDEM035F51::HEIGHT> display(GxEPD2_350c_GDEM035F51(/*CS=D8*/ SS, /*DC=D3*/ 0, /*RST=D4*/ 2, /*BUSY=D2*/ 4)); // GDEM035F51 184x384, JD79667 (FPC-8500)
 //GxEPD2_4C<GxEPD2_397c_GDEM0397F81, GxEPD2_397c_GDEM0397F81::HEIGHT> display(GxEPD2_397c_GDEM0397F81(/*CS=D8*/ SS, /*DC=D3*/ 0, /*RST=D4*/ 2, /*BUSY=D2*/ 4)); // GDEM0397F81 800x480, SSD2677 (FPC7750)
@@ -212,6 +213,7 @@
 //GxEPD2_4C<GxEPD2_213c_GDEY0213F51, GxEPD2_213c_GDEY0213F51::HEIGHT> display(GxEPD2_213c_GDEY0213F51(/*CS=15*/ SS, /*DC=4*/ 4, /*RST=2*/ 2, /*BUSY=5*/ 5)); // GDEY0213F51 122x250, JD79661 (FPC-A002 20.04.08)
 //GxEPD2_4C<GxEPD2_266c_GDEY0266F51H, GxEPD2_266c_GDEY0266F51H::HEIGHT> display(GxEPD2_266c_GDEY0266F51H(/*CS=15*/ SS, /*DC=4*/ 4, /*RST=2*/ 2, /*BUSY=5*/ 5)); // GDEY0266F51H 184x360, JD79667 (FPC-H006 22.04.02)
 //GxEPD2_4C<GxEPD2_290c_GDEY029F51H, GxEPD2_290c_GDEY029F51H::HEIGHT> display(GxEPD2_290c_GDEY029F51H(/*CS=15*/ SS, /*DC=4*/ 4, /*RST=2*/ 2, /*BUSY=5*/ 5)); // GDEY029F51H 168x384, JD79667 (FPC-H004 22.03.24)
+//GxEPD2_4C<GxEPD2_290c_GDEY029F51, GxEPD2_290c_GDEY029F51::HEIGHT> display(GxEPD2_290c_GDEY029F51(/*CS=15*/ SS, /*DC=4*/ 4, /*RST=2*/ 2, /*BUSY=5*/ 5)); // GDEY029F51 128x296, JD79667 (BWRY)
 //GxEPD2_4C<GxEPD2_300c, GxEPD2_300c::HEIGHT> display(GxEPD2_300c(/*CS=15*/ SS, /*DC=4*/ 4, /*RST=2*/ 2, /*BUSY=5*/ 5)); // Waveshare 3.00" 4-color
 //GxEPD2_4C<GxEPD2_350c_GDEM035F51, GxEPD2_350c_GDEM035F51::HEIGHT> display(GxEPD2_350c_GDEM035F51(/*CS=15*/ SS, /*DC=4*/ 4, /*RST=2*/ 2, /*BUSY=5*/ 5)); // GDEM035F51 184x384, JD79667 (FPC-8500)
 //GxEPD2_4C<GxEPD2_397c_GDEM0397F81, GxEPD2_397c_GDEM0397F81::HEIGHT> display(GxEPD2_397c_GDEM0397F81(/*CS=15*/ SS, /*DC=4*/ 4, /*RST=2*/ 2, /*BUSY=5*/ 5)); // GDEM0397F81 800x480, SSD2677 (FPC7750)
@@ -314,6 +316,7 @@
 //GxEPD2_4C<GxEPD2_213c_GDEY0213F51, GxEPD2_213c_GDEY0213F51::HEIGHT> display(GxEPD2_213c_GDEY0213F51(/*CS=5*/ SS, /*DC=*/ 17, /*RST=*/ 16, /*BUSY=*/ 4)); // GDEY0213F51 122x250, JD79661 (FPC-A002 20.04.08)
 //GxEPD2_4C<GxEPD2_266c_GDEY0266F51H, GxEPD2_266c_GDEY0266F51H::HEIGHT> display(GxEPD2_266c_GDEY0266F51H(/*CS=5*/ SS, /*DC=*/ 17, /*RST=*/ 16, /*BUSY=*/ 4)); // GDEY0266F51H 184x360, JD79667 (FPC-H006 22.04.02)
 //GxEPD2_4C<GxEPD2_290c_GDEY029F51H, GxEPD2_290c_GDEY029F51H::HEIGHT> display(GxEPD2_290c_GDEY029F51H(/*CS=5*/ SS, /*DC=*/ 17, /*RST=*/ 16, /*BUSY=*/ 4)); // GDEY029F51H 168x384, JD79667 (FPC-H004 22.03.24)
+//GxEPD2_4C<GxEPD2_290c_GDEY029F51, GxEPD2_290c_GDEY029F51::HEIGHT> display(GxEPD2_290c_GDEY029F51(/*CS=5*/ SS, /*DC=*/ 17, /*RST=*/ 16, /*BUSY=*/ 4)); // GDEY029F51 128x296, JD79667 (BWRY)
 //GxEPD2_4C<GxEPD2_300c, GxEPD2_300c::HEIGHT> display(GxEPD2_300c(/*CS=5*/ SS, /*DC=*/ 17, /*RST=*/ 16, /*BUSY=*/ 4)); // Waveshare 3.00" 4-color
 //GxEPD2_4C<GxEPD2_350c_GDEM035F51, GxEPD2_350c_GDEM035F51::HEIGHT> display(GxEPD2_350c_GDEM035F51(/*CS=5*/ SS, /*DC=*/ 17, /*RST=*/ 16, /*BUSY=*/ 4)); // GDEM035F51 184x384, JD79667 (FPC-8500)
 //GxEPD2_4C<GxEPD2_397c_GDEM0397F81, GxEPD2_397c_GDEM0397F81::HEIGHT> display(GxEPD2_397c_GDEM0397F81(/*CS=5*/ SS, /*DC=*/ 17, /*RST=*/ 16, /*BUSY=*/ 4)); // GDEM0397F81 800x480, SSD2677 (FPC7750)
@@ -435,6 +438,7 @@
 //GxEPD2_4C<GxEPD2_213c_GDEY0213F51, GxEPD2_213c_GDEY0213F51::HEIGHT> display(GxEPD2_213c_GDEY0213F51(/*CS=*/ 15, /*DC=*/ 27, /*RST=*/ 26, /*BUSY=*/ 25)); // GDEY0213F51 122x250, JD79661 (FPC-A002 20.04.08)
 //GxEPD2_4C<GxEPD2_266c_GDEY0266F51H, GxEPD2_266c_GDEY0266F51H::HEIGHT> display(GxEPD2_266c_GDEY0266F51H(/*CS=*/ 15, /*DC=*/ 27, /*RST=*/ 26, /*BUSY=*/ 25)); // GDEY0266F51H 184x360, JD79667 (FPC-H006 22.04.02)
 //GxEPD2_4C<GxEPD2_290c_GDEY029F51H, GxEPD2_290c_GDEY029F51H::HEIGHT> display(GxEPD2_290c_GDEY029F51H(/*CS=*/ 15, /*DC=*/ 27, /*RST=*/ 26, /*BUSY=*/ 25)); // GDEY029F51H 168x384, JD79667 (FPC-H004 22.03.24)
+//GxEPD2_4C<GxEPD2_290c_GDEY029F51, GxEPD2_290c_GDEY029F51::HEIGHT> display(GxEPD2_290c_GDEY029F51(/*CS=*/ 15, /*DC=*/ 27, /*RST=*/ 26, /*BUSY=*/ 25)); // GDEY029F51 128x296, JD79667 (BWRY)
 //GxEPD2_4C<GxEPD2_300c, GxEPD2_300c::HEIGHT> display(GxEPD2_300c(/*CS=*/ 15, /*DC=*/ 27, /*RST=*/ 26, /*BUSY=*/ 25)); // Waveshare 3.00" 4-color
 //GxEPD2_4C<GxEPD2_350c_GDEM035F51, GxEPD2_350c_GDEM035F51::HEIGHT> display(GxEPD2_350c_GDEM035F51(/*CS=*/ 15, /*DC=*/ 27, /*RST=*/ 26, /*BUSY=*/ 25)); // GDEM035F51 184x384, JD79667 (FPC-8500)
 //GxEPD2_4C<GxEPD2_397c_GDEM0397F81, GxEPD2_397c_GDEM0397F81::HEIGHT> display(GxEPD2_397c_GDEM0397F81(/*CS=*/ 15, /*DC=*/ 27, /*RST=*/ 26, /*BUSY=*/ 25)); // GDEM0397F81 800x480, SSD2677 (FPC7750)
@@ -543,6 +547,7 @@
 //GxEPD2_4C<GxEPD2_213c_GDEY0213F51, MAX_HEIGHT_3C((GxEPD2_213c_GDEY0213F51)> display(GxEPD2_213c_GDEY0213F51(/*CS=PA4*/ SS, /*DC=*/ PA3, /*RST=*/ PA2, /*BUSY=*/ PA1)); // GDEY0213F51 122x250, JD79661 (FPC-A002 20.04.08)
 //GxEPD2_4C<GxEPD2_266c_GDEY0266F51H, MAX_HEIGHT_3C(GxEPD2_266c_GDEY0266F51H)> display(GxEPD2_266c_GDEY0266F51H(/*CS=PA4*/ SS, /*DC=*/ PA3, /*RST=*/ PA2, /*BUSY=*/ PA1)); // GDEY0266F51H 184x360, JD79667 (FPC-H006 22.04.02)
 //GxEPD2_4C<GxEPD2_290c_GDEY029F51H, MAX_HEIGHT_3C(GxEPD2_290c_GDEY029F51H)> display(GxEPD2_290c_GDEY029F51H(/*CS=PA4*/ SS, /*DC=*/ PA3, /*RST=*/ PA2, /*BUSY=*/ PA1)); // GDEY029F51H 168x384, JD79667 (FPC-H004 22.03.24)
+//GxEPD2_4C<GxEPD2_290c_GDEY029F51, MAX_HEIGHT_3C(GxEPD2_290c_GDEY029F51)> display(GxEPD2_290c_GDEY029F51(/*CS=PA4*/ SS, /*DC=*/ PA3, /*RST=*/ PA2, /*BUSY=*/ PA1)); // GDEY029F51 128x296, JD79667 (BWRY)
 //GxEPD2_4C<GxEPD2_300c, MAX_HEIGHT_3C(GxEPD2_300c)> display(GxEPD2_300c(/*CS=PA4*/ SS, /*DC=*/ PA3, /*RST=*/ PA2, /*BUSY=*/ PA1)); // Waveshare 3.00" 4-color
 //GxEPD2_4C<GxEPD2_350c_GDEM035F51, MAX_HEIGHT_3C(GxEPD2_350c_GDEM035F51)> display(GxEPD2_350c_GDEM035F51(/*CS=PA4*/ SS, /*DC=*/ PA3, /*RST=*/ PA2, /*BUSY=*/ PA1)); // GDEM035F51 184x384, JD79667 (FPC-8500)
 //GxEPD2_4C<GxEPD2_397c_GDEM0397F81, MAX_HEIGHT_3C(GxEPD2_397c_GDEM0397F81)> display(GxEPD2_397c_GDEM0397F81(/*CS=PA4*/ SS, /*DC=*/ PA3, /*RST=*/ PA2, /*BUSY=*/ PA1)); // GDEM0397F81 800x480, SSD2677 (FPC7750)
@@ -656,6 +661,7 @@
 //GxEPD2_4C<GxEPD2_213c_GDEY0213F51, MAX_HEIGHT_3C(GxEPD2_213c_GDEY0213F51)> display(GxEPD2_213c_GDEY0213F51(/*CS=*/ SS, /*DC=*/ 8, /*RST=*/ 9, /*BUSY=*/ 7)); // GDEY0213F51 122x250, JD79661 (FPC-A002 20.04.08)
 //GxEPD2_4C<GxEPD2_266c_GDEY0266F51H, MAX_HEIGHT_3C(GxEPD2_266c_GDEY0266F51H)> display(GxEPD2_266c_GDEY0266F51H(/*CS=*/ SS, /*DC=*/ 8, /*RST=*/ 9, /*BUSY=*/ 7)); // GDEY0266F51H 184x360, JD79667 (FPC-H006 22.04.02)
 //GxEPD2_4C<GxEPD2_290c_GDEY029F51H, MAX_HEIGHT_3C(GxEPD2_290c_GDEY029F51H)> display(GxEPD2_290c_GDEY029F51H(/*CS=*/ SS, /*DC=*/ 8, /*RST=*/ 9, /*BUSY=*/ 7)); // GDEY029F51H 168x384, JD79667 (FPC-H004 22.03.24)
+//GxEPD2_4C<GxEPD2_290c_GDEY029F51, MAX_HEIGHT_3C(GxEPD2_290c_GDEY029F51)> display(GxEPD2_290c_GDEY029F51(/*CS=*/ SS, /*DC=*/ 8, /*RST=*/ 9, /*BUSY=*/ 7)); // GDEY029F51 128x296, JD79667 (BWRY)
 //GxEPD2_4C<GxEPD2_300c, MAX_HEIGHT_3C(GxEPD2_300c)> display(GxEPD2_300c(/*CS=*/ SS, /*DC=*/ 8, /*RST=*/ 9, /*BUSY=*/ 7)); // Waveshare 3.00" 4-color
 //GxEPD2_4C<GxEPD2_350c_GDEM035F51, MAX_HEIGHT_3C(GxEPD2_350c_GDEM035F51)> display(GxEPD2_350c_GDEM035F51(/*CS=*/ SS, /*DC=*/ 8, /*RST=*/ 9, /*BUSY=*/ 7)); // GDEM035F51 184x384, JD79667 (FPC-8500)
 //GxEPD2_4C<GxEPD2_397c_GDEM0397F81, MAX_HEIGHT_3C(GxEPD2_397c_GDEM0397F81)> display(GxEPD2_397c_GDEM0397F81(/*CS=*/ SS, /*DC=*/ 8, /*RST=*/ 9, /*BUSY=*/ 7)); // GDEM0397F81 800x480, SSD2677 (FPC7750)
@@ -759,6 +765,7 @@
 //GxEPD2_4C<GxEPD2_213c_GDEY0213F51, MAX_HEIGHT_3C((GxEPD2_213c_GDEY0213F51)> display(GxEPD2_213c_GDEY0213F51(/*CS=10*/ SS, /*DC=*/ 9, /*RST=*/ 8, /*BUSY=*/ 7)); // GDEY0213F51 122x250, JD79661 (FPC-A002 20.04.08)
 //GxEPD2_4C<GxEPD2_266c_GDEY0266F51H, MAX_HEIGHT_3C(GxEPD2_266c_GDEY0266F51H)> display(GxEPD2_266c_GDEY0266F51H(/*CS=10*/ SS, /*DC=*/ 9, /*RST=*/ 8, /*BUSY=*/ 7)); // GDEY0266F51H 184x360, JD79667 (FPC-H006 22.04.02)
 //GxEPD2_4C<GxEPD2_290c_GDEY029F51H, MAX_HEIGHT_3C(GxEPD2_290c_GDEY029F51H)> display(GxEPD2_290c_GDEY029F51H(/*CS=10*/ SS, /*DC=*/ 9, /*RST=*/ 8, /*BUSY=*/ 7)); // GDEY029F51H 168x384, JD79667 (FPC-H004 22.03.24)
+//GxEPD2_4C<GxEPD2_290c_GDEY029F51, MAX_HEIGHT_3C(GxEPD2_290c_GDEY029F51)> display(GxEPD2_290c_GDEY029F51(/*CS=10*/ SS, /*DC=*/ 9, /*RST=*/ 8, /*BUSY=*/ 7)); // GDEY029F51 128x296, JD79667 (BWRY)
 //GxEPD2_4C<GxEPD2_300c, MAX_HEIGHT_3C(GxEPD2_300c)> display(GxEPD2_300c(/*CS=10*/ SS, /*DC=*/ 9, /*RST=*/ 8, /*BUSY=*/ 7)); // Waveshare 3.00" 4-color
 //GxEPD2_4C<GxEPD2_350c_GDEM035F51, MAX_HEIGHT_3C(GxEPD2_350c_GDEM035F51)> display(GxEPD2_350c_GDEM035F51(/*CS=10*/ SS, /*DC=*/ 9, /*RST=*/ 8, /*BUSY=*/ 7)); // GDEM035F51 184x384, JD79667 (FPC-8500)
 //GxEPD2_4C<GxEPD2_397c_GDEM0397F81, MAX_HEIGHT_3C(GxEPD2_397c_GDEM0397F81)> display(GxEPD2_397c_GDEM0397F81(/*CS=10*/ SS, /*DC=*/ 9, /*RST=*/ 8, /*BUSY=*/ 7)); // GDEM0397F81 800x480, SSD2677 (FPC7750)

tools/gxepd2_catalog/GxEPD2_display_selection_added.h

@@ -100,6 +100,7 @@
 //GxEPD2_4C<GxEPD2_213c_GDEY0213F51, MAX_HEIGHT(GxEPD2_213c_GDEY0213F51)> display(GxEPD2_213c_GDEY0213F51(/*CS=10*/ SS, /*DC=*/ 8, /*RST=*/ 9, /*BUSY=*/ 7)); // GDEY0213F51 122x250, JD79661 (FPC-A002 20.04.08)
 //GxEPD2_4C<GxEPD2_266c_GDEY0266F51H, MAX_HEIGHT_3C(GxEPD2_266c_GDEY0266F51H)> display(GxEPD2_266c_GDEY0266F51H(/*CS=10*/ SS, /*DC=*/ 8, /*RST=*/ 9, /*BUSY=*/ 7)); // GDEY0266F51H 184x360, JD79667 (FPC-H006 22.04.02)
 //GxEPD2_4C<GxEPD2_290c_GDEY029F51H, MAX_HEIGHT_3C(GxEPD2_290c_GDEY029F51H)> display(GxEPD2_290c_GDEY029F51H(/*CS=10*/ SS, /*DC=*/ 8, /*RST=*/ 9, /*BUSY=*/ 7)); // GDEY029F51H 168x384, JD79667 (FPC-H004 22.03.24)
+//GxEPD2_4C<GxEPD2_290c_GDEY029F51, MAX_HEIGHT_3C(GxEPD2_290c_GDEY029F51)> display(GxEPD2_290c_GDEY029F51(/*CS=10*/ SS, /*DC=*/ 8, /*RST=*/ 9, /*BUSY=*/ 7)); // GDEY029F51 128x296, JD79667 (BWRY)
 //GxEPD2_4C<GxEPD2_300c, MAX_HEIGHT_3C(GxEPD2_300c)> display(GxEPD2_300c(/*CS=10*/ SS, /*DC=*/ 8, /*RST=*/ 9, /*BUSY=*/ 7)); // Waveshare 3.00" 4-color
 //GxEPD2_4C<GxEPD2_420c_GDEY0420F51, MAX_HEIGHT_3C(GxEPD2_420c_GDEY0420F51)> display(GxEPD2_420c_GDEY0420F51(/*CS=10*/ SS, /*DC=*/ 8, /*RST=*/ 9, /*BUSY=*/ 7)); // GDEY0420F51 400x300, HX8717 (no inking)
 //GxEPD2_4C <GxEPD2_437c, MAX_HEIGHT_3C(GxEPD2_437c)> display(GxEPD2_437c(/*CS=10*/ SS, /*DC=*/ 8, /*RST=*/ 9, /*BUSY=*/ 7)); // Waveshare 4.37" 4-color
@@ -207,6 +208,7 @@
 //GxEPD2_4C<GxEPD2_213c_GDEY0213F51, MAX_HEIGHT(GxEPD2_213c_GDEY0213F51)> display(GxEPD2_213c_GDEY0213F51(/*CS=4*/ 4, /*DC=*/ 7, /*RST=*/ 6, /*BUSY=*/ 5)); // GDEY0213F51 122x250, JD79661 (FPC-A002 20.04.08)
 //GxEPD2_4C<GxEPD2_266c_GDEY0266F51H, MAX_HEIGHT_3C(GxEPD2_266c_GDEY0266F51H)> display(GxEPD2_266c_GDEY0266F51H(/*CS=4*/ 4, /*DC=*/ 7, /*RST=*/ 6, /*BUSY=*/ 5)); // GDEY0266F51H 184x360, JD79667 (FPC-H006 22.04.02)
 //GxEPD2_4C<GxEPD2_290c_GDEY029F51H, MAX_HEIGHT_3C(GxEPD2_290c_GDEY029F51H)> display(GxEPD2_290c_GDEY029F51H(/*CS=4*/ 4, /*DC=*/ 7, /*RST=*/ 6, /*BUSY=*/ 5)); // GDEY029F51H 168x384, JD79667 (FPC-H004 22.03.24)
+//GxEPD2_4C<GxEPD2_290c_GDEY029F51, MAX_HEIGHT_3C(GxEPD2_290c_GDEY029F51)> display(GxEPD2_290c_GDEY029F51(/*CS=4*/ 4, /*DC=*/ 7, /*RST=*/ 6, /*BUSY=*/ 5)); // GDEY029F51 128x296, JD79667 (BWRY)
 //GxEPD2_4C<GxEPD2_300c, MAX_HEIGHT_3C(GxEPD2_300c)> display(GxEPD2_300c(/*CS=4*/ 4, /*DC=*/ 7, /*RST=*/ 6, /*BUSY=*/ 5)); // Waveshare 3.00" 4-color
 //GxEPD2_4C<GxEPD2_420c_GDEY0420F51, MAX_HEIGHT_3C(GxEPD2_420c_GDEY0420F51)> display(GxEPD2_420c_GDEY0420F51(/*CS=4*/ 4, /*DC=*/ 7, /*RST=*/ 6, /*BUSY=*/ 5)); // GDEY0420F51 400x300, HX8717 (no inking)
 //GxEPD2_4C <GxEPD2_437c, MAX_HEIGHT_3C(GxEPD2_437c)> display(GxEPD2_437c(/*CS=4*/ 4, /*DC=*/ 7, /*RST=*/ 6, /*BUSY=*/ 5)); // Waveshare 4.37" 4-color
@@ -309,6 +311,7 @@
 //GxEPD2_4C<GxEPD2_213c_GDEY0213F51, GxEPD2_213c_GDEY0213F51::HEIGHT> display(GxEPD2_213c_GDEY0213F51(/*CS=5*/ 5, /*DC=*/ 0, /*RST=*/ 2, /*BUSY=*/ 15)); // GDEY0213F51 122x250, JD79661 (FPC-A002 20.04.08)
 //GxEPD2_4C<GxEPD2_266c_GDEY0266F51H, GxEPD2_266c_GDEY0266F51H::HEIGHT> display(GxEPD2_266c_GDEY0266F51H(/*CS=5*/ 5, /*DC=*/ 0, /*RST=*/ 2, /*BUSY=*/ 15)); // GDEY0266F51H 184x360, JD79667 (FPC-H006 22.04.02)
 //GxEPD2_4C<GxEPD2_290c_GDEY029F51H, GxEPD2_290c_GDEY029F51H::HEIGHT> display(GxEPD2_290c_GDEY029F51H(/*CS=5*/ 5, /*DC=*/ 0, /*RST=*/ 2, /*BUSY=*/ 15)); // GDEY029F51H 168x384, JD79667 (FPC-H004 22.03.24)
+//GxEPD2_4C<GxEPD2_290c_GDEY029F51, GxEPD2_290c_GDEY029F51::HEIGHT> display(GxEPD2_290c_GDEY029F51(/*CS=5*/ 5, /*DC=*/ 0, /*RST=*/ 2, /*BUSY=*/ 15)); // GDEY029F51 128x296, JD79667 (BWRY)
 //GxEPD2_4C<GxEPD2_300c, GxEPD2_300c::HEIGHT> display(GxEPD2_300c(/*CS=5*/ 5, /*DC=*/ 0, /*RST=*/ 2, /*BUSY=*/ 15)); // Waveshare 3.00" 4-color
 //GxEPD2_4C<GxEPD2_420c_GDEY0420F51, GxEPD2_420c_GDEY0420F51::HEIGHT> display(GxEPD2_420c_GDEY0420F51(/*CS=5*/ 5, /*DC=*/ 0, /*RST=*/ 2, /*BUSY=*/ 15)); // GDEY0420F51 400x300, HX8717 (no inking)
 //GxEPD2_4C < GxEPD2_437c, GxEPD2_437c::HEIGHT / 4 > display(GxEPD2_437c(/*CS=5*/ 5, /*DC=*/ 0, /*RST=*/ 2, /*BUSY=*/ 15)); // Waveshare 4.37" 4-color
@@ -406,6 +409,7 @@
 //GxEPD2_4C<GxEPD2_213c_GDEY0213F51, GxEPD2_213c_GDEY0213F51::HEIGHT> display(GxEPD2_213c_GDEY0213F51(/*CS=5*/ 5, /*DC=*/ 2, /*RST=*/ 0, /*BUSY=*/ 4)); // GDEY0213F51 122x250, JD79661 (FPC-A002 20.04.08)
 //GxEPD2_4C<GxEPD2_266c_GDEY0266F51H, GxEPD2_266c_GDEY0266F51H::HEIGHT> display(GxEPD2_266c_GDEY0266F51H(/*CS=5*/ 5, /*DC=*/ 2, /*RST=*/ 0, /*BUSY=*/ 4)); // GDEY0266F51H 184x360, JD79667 (FPC-H006 22.04.02)
 //GxEPD2_4C<GxEPD2_290c_GDEY029F51H, GxEPD2_290c_GDEY029F51H::HEIGHT> display(GxEPD2_290c_GDEY029F51H(/*CS=5*/ 5, /*DC=*/ 2, /*RST=*/ 0, /*BUSY=*/ 4)); // GDEY029F51H 168x384, JD79667 (FPC-H004 22.03.24)
+//GxEPD2_4C<GxEPD2_290c_GDEY029F51, GxEPD2_290c_GDEY029F51::HEIGHT> display(GxEPD2_290c_GDEY029F51(/*CS=5*/ 5, /*DC=*/ 2, /*RST=*/ 0, /*BUSY=*/ 4)); // GDEY029F51 128x296, JD79667 (BWRY)
 //GxEPD2_4C<GxEPD2_300c, GxEPD2_300c::HEIGHT> display(GxEPD2_300c(/*CS=5*/ 5, /*DC=*/ 2, /*RST=*/ 0, /*BUSY=*/ 4)); // Waveshare 3.00" 4-color
 //GxEPD2_4C<GxEPD2_420c_GDEY0420F51, GxEPD2_420c_GDEY0420F51::HEIGHT> display(GxEPD2_420c_GDEY0420F51(/*CS=5*/ 5, /*DC=*/ 2, /*RST=*/ 0, /*BUSY=*/ 4)); // GDEY0420F51 400x300, HX8717 (no inking)
 //GxEPD2_4C < GxEPD2_437c, GxEPD2_437c::HEIGHT / 4 > display(GxEPD2_437c(/*CS=5*/ 5, /*DC=*/ 2, /*RST=*/ 0, /*BUSY=*/ 4)); // Waveshare 4.37" 4-color
@@ -506,6 +510,7 @@
 //GxEPD2_4C<GxEPD2_213c_GDEY0213F51, GxEPD2_213c_GDEY0213F51::HEIGHT> display(GxEPD2_213c_GDEY0213F51(/*CS=15*/ SS, /*DC=4*/ 4, /*RST=5*/ 5, /*BUSY=16*/ 16)); // GDEY0213F51 122x250, JD79661 (FPC-A002 20.04.08)
 //GxEPD2_4C<GxEPD2_266c_GDEY0266F51H, GxEPD2_266c_GDEY0266F51H::HEIGHT> display(GxEPD2_266c_GDEY0266F51H(/*CS=15*/ SS, /*DC=4*/ 4, /*RST=5*/ 5, /*BUSY=16*/ 16)); // GDEY0266F51H 184x360, JD79667 (FPC-H006 22.04.02)
 //GxEPD2_4C<GxEPD2_290c_GDEY029F51H, GxEPD2_290c_GDEY029F51H::HEIGHT> display(GxEPD2_290c_GDEY029F51H(/*CS=15*/ SS, /*DC=4*/ 4, /*RST=5*/ 5, /*BUSY=16*/ 16)); // GDEY029F51H 168x384, JD79667 (FPC-H004 22.03.24)
+//GxEPD2_4C<GxEPD2_290c_GDEY029F51, GxEPD2_290c_GDEY029F51::HEIGHT> display(GxEPD2_290c_GDEY029F51(/*CS=15*/ SS, /*DC=4*/ 4, /*RST=5*/ 5, /*BUSY=16*/ 16)); // GDEY029F51 128x296, JD79667 (BWRY)
 //GxEPD2_4C<GxEPD2_300c, GxEPD2_300c::HEIGHT> display(GxEPD2_300c(/*CS=15*/ SS, /*DC=4*/ 4, /*RST=5*/ 5, /*BUSY=16*/ 16)); // Waveshare 3.00" 4-color
 //GxEPD2_4C<GxEPD2_420c_GDEY0420F51, GxEPD2_420c_GDEY0420F51::HEIGHT> display(GxEPD2_420c_GDEY0420F51(/*CS=15*/ SS, /*DC=4*/ 4, /*RST=5*/ 5, /*BUSY=16*/ 16)); // GDEY0420F51 400x300, HX8717 (no inking)
 //GxEPD2_4C < GxEPD2_437c, GxEPD2_437c::HEIGHT / 4 > display(GxEPD2_437c(/*CS=15*/ SS, /*DC=4*/ 4, /*RST=5*/ 5, /*BUSY=16*/ 16)); // Waveshare 4.37" 4-color
@@ -596,6 +601,7 @@
 //GxEPD2_4C<GxEPD2_213c_GDEY0213F51, MAX_HEIGHT(GxEPD2_213c_GDEY0213F51)> display(GxEPD2_213c_GDEY0213F51(/*CS=*/ SS, /*DC=*/ 8, /*RST=*/ 9, /*BUSY=*/ 7)); // GDEY0213F51 122x250, JD79661 (FPC-A002 20.04.08)
 //GxEPD2_4C<GxEPD2_266c_GDEY0266F51H, MAX_HEIGHT_3C(GxEPD2_266c_GDEY0266F51H)> display(GxEPD2_266c_GDEY0266F51H(/*CS=*/ SS, /*DC=*/ 8, /*RST=*/ 9, /*BUSY=*/ 7)); // GDEY0266F51H 184x360, JD79667 (FPC-H006 22.04.02)
 //GxEPD2_4C<GxEPD2_290c_GDEY029F51H, MAX_HEIGHT_3C(GxEPD2_290c_GDEY029F51H)> display(GxEPD2_290c_GDEY029F51H(/*CS=*/ SS, /*DC=*/ 8, /*RST=*/ 9, /*BUSY=*/ 7)); // GDEY029F51H 168x384, JD79667 (FPC-H004 22.03.24)
+//GxEPD2_4C<GxEPD2_290c_GDEY029F51, MAX_HEIGHT_3C(GxEPD2_290c_GDEY029F51)> display(GxEPD2_290c_GDEY029F51(/*CS=*/ SS, /*DC=*/ 8, /*RST=*/ 9, /*BUSY=*/ 7)); // GDEY029F51 128x296, JD79667 (BWRY)
 //GxEPD2_4C<GxEPD2_300c, MAX_HEIGHT_3C(GxEPD2_300c)> display(GxEPD2_300c(/*CS=*/ SS, /*DC=*/ 8, /*RST=*/ 9, /*BUSY=*/ 7)); // Waveshare 3.00" 4-color
 //GxEPD2_4C<GxEPD2_420c_GDEY0420F51, MAX_HEIGHT_3C(GxEPD2_420c_GDEY0420F51)> display(GxEPD2_420c_GDEY0420F51(/*CS=*/ SS, /*DC=*/ 8, /*RST=*/ 9, /*BUSY=*/ 7)); // GDEY0420F51 400x300, HX8717 (no inking)
 //GxEPD2_4C <GxEPD2_437c, MAX_HEIGHT_3C(GxEPD2_437c)> display(GxEPD2_437c(/*CS=*/ SS, /*DC=*/ 8, /*RST=*/ 9, /*BUSY=*/ 7)); // Waveshare 4.37" 4-color