Version 1.6.8

- added methods writeImageToPrevious and writeImagePartToPrevious to b/w driver classes
- added partial update support to GDEP073E01

README.md

@@ -175,6 +175,7 @@
 
 ### Version 1.6.8
 - added methods writeImageToPrevious and writeImagePartToPrevious to b/w driver classes
+- added partial update support to GDEP073E01
 #### Version 1.6.7
 - added support for GDEW075Z08 fast b/w refresh in new class GxEPD2_750c_GDEW075Z08
 - GxEPD2_750c_GDEW075Z08 uses a b/w waveform written to registers, none available in OTP

examples/GxEPD2_Example/GxEPD2_Example.ino

@@ -248,7 +248,7 @@ void setup()
     draw7colors();
     delay(4000);
     display.epd2.drawNativeColors(); delay(2000);
-    //return;
+    //display.powerOff(); return;
   }
 #endif
   if (display.epd2.hasPartialUpdate)
@@ -1619,6 +1619,30 @@ void drawBitmaps800x480()
       display.refresh(false); // full update
     }
   }
+#if defined(ESP32) && false
+  if (display.epd2.panel == GxEPD2::GDEP073E01)
+  {
+    int16_t wp = display.epd2.WIDTH / 5;
+    int16_t hp = display.epd2.HEIGHT / 5;
+    int16_t n = 0;
+    for (int16_t k = 0; k < 3; k++)
+    {
+      display.writeScreenBuffer();
+      for (int16_t i = 0; i < 5; i++)
+      {
+        for (int16_t j = 0; j < 5; j++)
+        {
+          if ((n++ % 2) || (k == 2))
+          {
+            display.epd2.writeImagePart(Bitmap800x480_1, 0, i * wp, j * hp, 800, 480, i * wp, j * hp, wp, hp, false, false, true);
+          }
+        }
+      }
+      display.refresh(false);
+      delay(2000);
+    }
+  }
+#endif
 }
 #endif
 
@@ -2080,6 +2104,28 @@ void drawBitmaps3c800x480()
       delay(2000);
     }
   }
+  if ((display.epd2.panel == GxEPD2::GDEP073E01) && false)
+  {
+    int16_t wp = display.epd2.WIDTH / 5;
+    int16_t hp = display.epd2.HEIGHT / 5;
+    int16_t n = 0;
+    for (int16_t k = 0; k < 3; k++)
+    {
+      display.writeScreenBuffer();
+      for (int16_t i = 0; i < 5; i++)
+      {
+        for (int16_t j = 0; j < 5; j++)
+        {
+          if ((n++ % 2) || (k == 2))
+          {
+            display.epd2.writeImagePart(Bitmap3c800x480_1_black, Bitmap3c800x480_1_red, i * wp, j * hp, 800, 480, i * wp, j * hp, wp, hp, true, false, true);
+          }
+        }
+      }
+      display.refresh(false);
+      delay(2000);
+    }
+  }
 }
 #endif
 

src/GxEPD2_7C.h

@@ -218,8 +218,8 @@ class GxEPD2_7C : public GxEPD2_GFX_BASE_CLASS
     }
 
     // setPartialWindow, use parameters according to actual rotation.
-    // x and w should be multiple of 8, for rotation 0 or 2,
-    // y and h should be multiple of 8, for rotation 1 or 3,
+    // x and w should be multiple of 4, for rotation 0 or 2,
+    // y and h should be multiple of 4, for rotation 1 or 3,
     // else window is increased as needed,
     // this is an addressing limitation of the e-paper controllers
     void setPartialWindow(uint16_t x, uint16_t y, uint16_t w, uint16_t h)
@@ -231,10 +231,10 @@ class GxEPD2_7C : public GxEPD2_GFX_BASE_CLASS
       _pw_h = gx_uint16_min(h, height() - _pw_y);
       _rotate(_pw_x, _pw_y, _pw_w, _pw_h);
       _using_partial_mode = true;
-      // make _pw_x, _pw_w multiple of 2
-      _pw_w += _pw_x % 2;
-      if (_pw_w % 2 > 0) _pw_w += 2 - _pw_w % 2;
-      _pw_x -= _pw_x % 2;
+      // make _pw_x, _pw_w multiple of 4, required by Spectra6 controller
+      _pw_w += _pw_x % 4;
+      if (_pw_w % 4 > 0) _pw_w += 4 - _pw_w % 4;
+      _pw_x -= _pw_x % 4;
     }
 
     void firstPage()

src/epd7c/GxEPD2_730c_GDEP073E01.cpp

@@ -16,7 +16,6 @@
 GxEPD2_730c_GDEP073E01::GxEPD2_730c_GDEP073E01(int16_t cs, int16_t dc, int16_t rst, int16_t busy) :
   GxEPD2_EPD(cs, dc, rst, busy, LOW, 20000000, WIDTH, HEIGHT, panel, hasColor, hasPartialUpdate, hasFastPartialUpdate)
 {
-  _paged = false;
 }
 
 void GxEPD2_730c_GDEP073E01::clearScreen(uint8_t value)
@@ -38,6 +37,7 @@ void GxEPD2_730c_GDEP073E01::writeScreenBuffer(uint8_t value)
 void GxEPD2_730c_GDEP073E01::writeScreenBuffer(uint8_t black_value, uint8_t color_value)
 {
   if (!_init_display_done) _InitDisplay();
+  _setPartialRamArea(0, 0, WIDTH, HEIGHT);
   _writeCommand(0x10);
   _startTransfer();
   for (uint32_t i = 0; i < uint32_t(WIDTH) * uint32_t(HEIGHT) / 2; i++)
@@ -54,13 +54,41 @@ void GxEPD2_730c_GDEP073E01::writeImage(const uint8_t bitmap[], int16_t x, int16
   //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 (_paged && (x == 0) && (w == int16_t(WIDTH)) && (h < int16_t(HEIGHT)))
+  if (_initial_write) writeScreenBuffer();
+  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++)
   {
-    //Serial.println("paged");
-    _startTransfer();
-    for (uint32_t i = 0; i < uint32_t(WIDTH) * uint32_t(h) / 8; i++)
+    for (int16_t j = 0; j < w1 / 8; j++)
     {
-      uint8_t data = bitmap[i];
+      uint8_t data;
+      // use wb, h of bitmap for index!
+      int16_t idx = mirror_y ? j + dx / 8 + ((h - 1 - (i + dy))) * wb : j + dx / 8 + (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];
+      }
       for (int16_t k = 0; k < 4; k++)
       {
         uint8_t data2 = (data & 0x80 ? 0x10 : 0x00) | (data & 0x40 ? 0x01 : 0x00);
@@ -68,54 +96,8 @@ void GxEPD2_730c_GDEP073E01::writeImage(const uint8_t bitmap[], int16_t x, int16
         _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 < 4; k++)
-        {
-          uint8_t data2 = (data & 0x80 ? 0x10 : 0x00) | (data & 0x40 ? 0x01 : 0x00);
-          data <<= 2;
-          _transfer(data2);
-        }
-      }
-    }
-    _endTransfer();
   }
+  _endTransfer();
   delay(1); // yield() to avoid WDT on ESP8266 and ESP32
 }
 
@@ -123,18 +105,53 @@ void GxEPD2_730c_GDEP073E01::writeImage(const uint8_t* black, const uint8_t* col
 {
   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("writeImage_3c("); 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 (_paged && (x == 0) && (w == int16_t(WIDTH)) && (h < int16_t(HEIGHT)))
+  if (_initial_write) writeScreenBuffer();
+  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++)
   {
-    //Serial.println("paged");
-    _startTransfer();
-    for (uint32_t i = 0; i < uint32_t(WIDTH) * uint32_t(h) / 8; i++)
+    for (int16_t j = 0; j < w1 / 8; j++)
     {
-      uint8_t black_data = black[i];
-      uint8_t color_data = color[i];
+      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 < 4; k++)
       {
         uint8_t out_data = 0x00;
@@ -149,75 +166,21 @@ void GxEPD2_730c_GDEP073E01::writeImage(const uint8_t* black, const uint8_t* col
         _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 < 4; k++)
-        {
-          uint8_t out_data = 0x00;
-          for (int16_t l = 0; l < 2; l++)
-          {
-            out_data <<= 4;
-            if (!(color_data & 0x80)) out_data |= 0x04;
-            else out_data |= black_data & 0x80 ? 0x01 : 0x00;
-            black_data <<= 1;
-            color_data <<= 1;
-          }
-          _transfer(out_data);
-        }
-      }
-    }
-    _endTransfer();
   }
+  _endTransfer();
   delay(1); // yield() to avoid WDT on ESP8266 and ESP32
 }
 
 void GxEPD2_730c_GDEP073E01::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;
@@ -225,7 +188,9 @@ void GxEPD2_730c_GDEP073E01::writeImagePart(const uint8_t bitmap[], int16_t x_pa
   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
-  x -= x % 8; // byte boundary
+  // 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
@@ -236,32 +201,29 @@ void GxEPD2_730c_GDEP073E01::writeImagePart(const uint8_t bitmap[], int16_t x_pa
   w1 -= dx;
   h1 -= dy;
   if ((w1 <= 0) || (h1 <= 0)) return;
-  if (!_init_display_done) _InitDisplay();
+  _setPartialRamArea(x1, y1, w1, h1);
   _writeCommand(0x10);
   _startTransfer();
-  for (int16_t i = 0; i < int16_t(HEIGHT); i++)
+  for (int16_t i = 0; i < h1; i++)
   {
-    for (int16_t j = 0; j < int16_t(WIDTH); j += 8)
+    for (int16_t j = 0; j < w1 / 8; j++)
     {
-      uint8_t data = 0xFF;
-      if ((j >= x1) && (j < x1 + w) && (i >= y1) && (i < y1 + h))
+      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)
       {
-        // 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]);
+        data = pgm_read_byte(&bitmap[idx]);
 #else
-          data = bitmap[idx];
+        data = bitmap[idx];
 #endif
-        }
-        else
-        {
-          data = bitmap[idx];
-        }
-        if (invert) data = ~data;
       }
+      else
+      {
+        data = bitmap[idx];
+      }
+      if (invert) data = ~data;
       for (int16_t k = 0; k < 4; k++)
       {
         uint8_t data2 = (data & 0x80 ? 0x10 : 0x00) | (data & 0x40 ? 0x01 : 0x00);
@@ -277,12 +239,14 @@ void GxEPD2_730c_GDEP073E01::writeImagePart(const uint8_t bitmap[], int16_t x_pa
 void GxEPD2_730c_GDEP073E01::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("writeImagePart_3c("); 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;
@@ -291,7 +255,9 @@ void GxEPD2_730c_GDEP073E01::writeImagePart(const uint8_t* black, const uint8_t*
   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
-  x -= x % 8; // byte boundary
+  // 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
@@ -302,38 +268,35 @@ void GxEPD2_730c_GDEP073E01::writeImagePart(const uint8_t* black, const uint8_t*
   w1 -= dx;
   h1 -= dy;
   if ((w1 <= 0) || (h1 <= 0)) return;
-  if (!_init_display_done) _InitDisplay();
+  _setPartialRamArea(x1, y1, w1, h1);
   _writeCommand(0x10);
   _startTransfer();
-  for (int16_t i = 0; i < int16_t(HEIGHT); i++)
+  for (int16_t i = 0; i < h1; i++)
   {
-    for (int16_t j = 0; j < int16_t(WIDTH); j += 8)
+    for (int16_t j = 0; j < w1 / 8; j++)
     {
       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 / 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)
       {
-        // 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]);
+        black_data = pgm_read_byte(&black[idx]);
+        color_data = pgm_read_byte(&color[idx]);
 #else
-          black_data = black[idx];
-          color_data = color[idx];
+        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;
-        }
+      }
+      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 < 4; k++)
       {
@@ -356,81 +319,61 @@ void GxEPD2_730c_GDEP073E01::writeImagePart(const uint8_t* black, const uint8_t*
 
 void GxEPD2_730c_GDEP073E01::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)
+  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();
+  uint32_t wb = (w + 1) / 2; // width bytes, bitmaps are padded
+  x -= x % 2; // byte boundary
+  w = wb * 2; // 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++)
   {
-    //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 (_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) / 2; i++)
-      {
-        uint8_t data = data1[i];
-        if (!invert) data = _convert_to_native(data);
-        _transfer(data);
-      }
-      _endTransfer();
-      if (y + h == HEIGHT) // last page
-      {
-        //Serial.println("paged ended");
-        _paged = false;
-      }
-    }
-    else
+    for (int16_t j = 0; j < w1 / 2; j++)
     {
-      _paged = false;
-      int16_t wb = (w + 1) / 2; // width bytes, bitmaps are padded
-      x -= x % 2; // byte boundary
-      w = wb * 2; // byte boundary
-      if ((w <= 0) || (h <= 0)) return;
-      _writeCommand(0x10);
-      _startTransfer();
-      for (int16_t i = 0; i < int16_t(HEIGHT); i++)
+      uint8_t data;
+      // use wb, h of bitmap for index!
+      uint32_t idx = mirror_y ? j + dx / 2 + uint32_t((h - 1 - (i + dy))) * wb : j + dx / 2 + uint32_t(i + dy) * wb;
+      if (pgm)
       {
-        for (int16_t j = 0; j < int16_t(WIDTH); j += 2)
-        {
-          uint8_t data = 0x11;
-          if (data1)
-          {
-            if ((j >= x) && (j < x + w) && (i >= y) && (i < y + h))
-            {
-              uint32_t idx = mirror_y ? (j - x) / 2 + uint32_t((h - 1 - (i - y))) * wb : (j - x) / 2 + uint32_t(i - y) * wb;
-              if (pgm)
-              {
 #if defined(__AVR) || defined(ESP8266) || defined(ESP32)
-                data = pgm_read_byte(&data1[idx]);
+        data = pgm_read_byte(&data1[idx]);
 #else
-                data = data1[idx];
+        data = data1[idx];
 #endif
-              }
-              else
-              {
-                data = data1[idx];
-              }
-              if (!invert) data = _convert_to_native(data);
-            }
-          }
-          _transfer(data);
-        }
       }
-      _endTransfer();
+      else
+      {
+        data = data1[idx];
+      }
+      if (!invert) data = _convert_to_native(data);
+      _transfer(data);
     }
-    delay(1); // yield() to avoid WDT on ESP8266 and ESP32
   }
+  _endTransfer();
+  delay(1); // yield() to avoid WDT on ESP8266 and ESP32
 }
 
 void GxEPD2_730c_GDEP073E01::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)
 {
-  //Serial.print("writeNativePart("); 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 (!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;
@@ -438,6 +381,7 @@ void GxEPD2_730c_GDEP073E01::writeNativePart(const uint8_t* data1, const uint8_t
   x_part -= x_part % 2; // 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 % 2; // adjust for byte boundary of x
   x -= x % 2; // byte boundary
   w = 2 * ((w + 1) / 2); // byte boundary, bitmaps are padded
   int16_t x1 = x < 0 ? 0 : x; // limit
@@ -449,32 +393,29 @@ void GxEPD2_730c_GDEP073E01::writeNativePart(const uint8_t* data1, const uint8_t
   w1 -= dx;
   h1 -= dy;
   if ((w1 <= 0) || (h1 <= 0)) return;
-  if (!_init_display_done) _InitDisplay();
+  _setPartialRamArea(x1, y1, w1, h1);
   _writeCommand(0x10);
   _startTransfer();
-  for (int16_t i = 0; i < int16_t(HEIGHT); i++)
+  for (int16_t i = 0; i < h1; i++)
   {
-    for (int16_t j = 0; j < int16_t(WIDTH); j += 2)
+    for (int16_t j = 0; j < w1 / 2; j++)
     {
-      uint8_t data = 0x11;
-      if ((j >= x1) && (j < x1 + w) && (i >= y1) && (i < y1 + h))
+      uint8_t data;
+      // use wb_bitmap, h_bitmap of bitmap for index!
+      uint32_t idx = mirror_y ? x_part / 2 + j + dx / 2 + uint32_t((h_bitmap - 1 - (y_part + i + dy))) * wb_bitmap : x_part / 2 + j + dx / 2 + uint32_t(y_part + i + dy) * wb_bitmap;
+      if (pgm)
       {
-        // use wb_bitmap, h_bitmap of bitmap for index!
-        uint32_t idx = mirror_y ? (x_part + j - x1) / 2 + uint32_t((h_bitmap - 1 - (y_part + i - y1))) * wb_bitmap : (x_part + j - x1) / 2 + uint32_t(y_part + i - y1) * wb_bitmap;
-        if (pgm)
-        {
 #if defined(__AVR) || defined(ESP8266) || defined(ESP32)
-          data = pgm_read_byte(&data1[idx]);
+        data = pgm_read_byte(&data1[idx]);
 #else
-          data = data1[idx];
+        data = data1[idx];
 #endif
-        }
-        else
-        {
-          data = data1[idx];
-        }
-        if (!invert) data = _convert_to_native(data);
       }
+      else
+      {
+        data = data1[idx];
+      }
+      if (!invert) data = _convert_to_native(data);
       _transfer(data);
     }
   }
@@ -517,6 +458,9 @@ void GxEPD2_730c_GDEP073E01::drawNative(const uint8_t* data1, const uint8_t* dat
 void GxEPD2_730c_GDEP073E01::refresh(bool partial_update_mode)
 {
   _PowerOn();
+  _setPartialRamArea(0, 0, WIDTH, HEIGHT);
+  _writeCommand(0x50);
+  _writeData(0x3F);
   _writeCommand(0x12); // Display Refresh
   _writeData(0x00);
   delay(1);
@@ -526,6 +470,10 @@ void GxEPD2_730c_GDEP073E01::refresh(bool partial_update_mode)
 void GxEPD2_730c_GDEP073E01::refresh(int16_t x, int16_t y, int16_t w, int16_t h)
 {
   _PowerOn();
+  if (usePartialUpdate) _setPartialRamArea(x, y, w, h);
+  else _setPartialRamArea(0, 0, WIDTH, HEIGHT);
+  _writeCommand(0x50);
+  _writeData(0xFF); // border floating
   _writeCommand(0x12); // Display Refresh
   _writeData(0x00);
   delay(1);
@@ -549,11 +497,22 @@ void GxEPD2_730c_GDEP073E01::hibernate()
   }
 }
 
-void GxEPD2_730c_GDEP073E01::setPaged()
+void GxEPD2_730c_GDEP073E01::_setPartialRamArea(uint16_t x, uint16_t y, uint16_t w, uint16_t h)
 {
-  _paged = true;
-  if (!_init_display_done) _InitDisplay();
-  _writeCommand(0x10);
+  //Serial.print("_setPartialRamArea("); Serial.print(x); Serial.print(", "); Serial.print(y); Serial.print(", ");
+  //Serial.print(w); Serial.print(", "); Serial.print(h); Serial.println(")");
+  uint16_t xe = x + w - 1;
+  uint16_t ye = y + h; // controller issue (one more)
+  _writeCommand(0x83); // partial window
+  _writeData(x / 256);
+  _writeData(x % 256);
+  _writeData(xe / 256);
+  _writeData(xe % 256);
+  _writeData(y / 256);
+  _writeData(y % 256);
+  _writeData(ye / 256);
+  _writeData(ye % 256);
+  _writeData(0x01);
 }
 
 void GxEPD2_730c_GDEP073E01::_PowerOn()
@@ -579,6 +538,7 @@ void GxEPD2_730c_GDEP073E01::_PowerOff()
 
 void GxEPD2_730c_GDEP073E01::_InitDisplay()
 {
+  //Serial.println("_InitDisplay");
   if ((_rst >= 0) && (_hibernating || _initial_write))
   {
     pinMode(_rst, OUTPUT); // just in case
@@ -587,8 +547,8 @@ void GxEPD2_730c_GDEP073E01::_InitDisplay()
     digitalWrite(_rst, LOW);
     delay(20);
     digitalWrite(_rst, HIGH);
-    delay(10); // 4ms measured
-    //_waitWhileBusy("_InitDisplay reset", power_on_time); // 4000us
+    delay(10); // 6ms measured
+    //_waitWhileBusy("_InitDisplay reset", power_on_time); // 6000us
     _initial_write = false; // used for initial reset done
     _hibernating = false;
     _power_is_on = false;
@@ -710,51 +670,50 @@ uint8_t GxEPD2_730c_GDEP073E01::_colorOfDemoBitmap(uint8_t from, int16_t mode)
 void GxEPD2_730c_GDEP073E01::writeDemoBitmap(const uint8_t* data1, const uint8_t* data2, int16_t x, int16_t y, int16_t w, int16_t h, int16_t mode, bool mirror_y, bool pgm)
 {
   (void) mode;
-  if (data1)
+  if (!data1) return;
+  //Serial.print("writeDemoBitmap("); 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();
+  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++)
   {
-    //Serial.print("writeNative("); Serial.print(x); Serial.print(", "); Serial.print(y); Serial.print(", ");
-    //Serial.print(w); Serial.print(", "); Serial.print(h); Serial.println(")");
-    if (!_init_display_done) _InitDisplay();
-    delay(1); // yield() to avoid WDT on ESP8266 and ESP32
+    for (int16_t j = 0; j < w1; j += 2)
     {
-      _paged = false;
-      if ((w <= 0) || (h <= 0)) return;
-      _writeCommand(0x10);
-      _startTransfer();
-      for (int16_t i = 0; i < int16_t(HEIGHT); i++)
+      uint8_t data = 0x11;
+      uint32_t idx = mirror_y ? j + dx + uint32_t((h - 1 - (i + dy))) * w : j + dx + uint32_t(i + dy) * w;
+      if (pgm)
       {
-        for (int16_t j = 0; j < int16_t(WIDTH); j += 2)
-        {
-          uint8_t data = 0x11;
-          if (data1)
-          {
-            if ((j >= x) && (j < x + w) && (i >= y) && (i < y + h))
-            {
-              uint32_t idx = mirror_y ? (j - x) + uint32_t((h - 1 - (i - y))) * w : (j - x) + uint32_t(i - y) * w;
-              if (pgm)
-              {
 #if defined(__AVR) || defined(ESP8266) || defined(ESP32)
-                data = _colorOfDemoBitmap(pgm_read_byte(&data1[idx++]), mode) << 4;
-                data |= _colorOfDemoBitmap(pgm_read_byte(&data1[idx]), mode);
+        data = _colorOfDemoBitmap(pgm_read_byte(&data1[idx++]), mode) << 4;
+        data |= _colorOfDemoBitmap(pgm_read_byte(&data1[idx]), mode);
 #else
-                data = _colorOfDemoBitmap(data1[idx++], mode) << 4;
-                data |= _colorOfDemoBitmap(data1[idx], mode);
+        data = _colorOfDemoBitmap(data1[idx++], mode) << 4;
+        data |= _colorOfDemoBitmap(data1[idx], mode);
 #endif
-              }
-              else
-              {
-                data = _colorOfDemoBitmap(data1[idx++], mode) << 4;
-                data |= _colorOfDemoBitmap(data1[idx], mode);
-              }
-            }
-          }
-          _transfer(data);
-        }
       }
-      _endTransfer();
+      else
+      {
+        data = _colorOfDemoBitmap(data1[idx++], mode) << 4;
+        data |= _colorOfDemoBitmap(data1[idx], mode);
+      }
+      _transfer(data);
     }
-    delay(1); // yield() to avoid WDT on ESP8266 and ESP32
   }
+  _endTransfer();
+  delay(1); // yield() to avoid WDT on ESP8266 and ESP32
 }
 
 void GxEPD2_730c_GDEP073E01::drawDemoBitmap(const uint8_t* data1, const uint8_t* data2, int16_t x, int16_t y, int16_t w, int16_t h, int16_t mode, bool mirror_y, bool pgm)
@@ -765,9 +724,8 @@ void GxEPD2_730c_GDEP073E01::drawDemoBitmap(const uint8_t* data1, const uint8_t*
 
 void GxEPD2_730c_GDEP073E01::drawNativeColors()
 {
+#if 0
   const uint16_t colors = 7;
-  //const uint16_t colors = 8; // 7 is white
-  //const uint16_t colors = 16; // repeated for 8..15
   const uint16_t h1 = HEIGHT / colors;
   _writeCommand(0x10);
   _startTransfer();
@@ -780,6 +738,22 @@ void GxEPD2_730c_GDEP073E01::drawNativeColors()
   }
   _endTransfer();
   refresh();
+#else
+  const uint16_t stripes = 7;
+  const uint16_t h1 = (HEIGHT / stripes) - 1;
+  for (uint16_t s = 0; s < stripes; s++)
+  {
+    _setPartialRamArea(0, s * h1, WIDTH, h1);
+    _writeCommand(0x10);
+    _startTransfer();
+    for (uint16_t hnb = 0; hnb < h1 * WIDTH / 2; hnb++)
+    {
+      _transfer((s << 4) | s);
+    }
+    _endTransfer();
+  }
+  refresh();
+#endif
 }
 
 uint8_t GxEPD2_730c_GDEP073E01::_convert_to_native(uint8_t data)

src/epd7c/GxEPD2_730c_GDEP073E01.h

@@ -25,7 +25,8 @@ class GxEPD2_730c_GDEP073E01 : public GxEPD2_EPD
     static const uint16_t HEIGHT = 480;
     static const GxEPD2::Panel panel = GxEPD2::GDEP073E01;
     static const bool hasColor = true;
-    static const bool hasPartialUpdate = false;
+    static const bool hasPartialUpdate = true;
+    static const bool usePartialUpdate = true; // set false to force full screen update
     static const bool hasFastPartialUpdate = false;
     static const uint16_t power_on_time = 200; // ms, e.g. 172000us
     static const uint16_t power_off_time = 150; // ms, e.g. 145000us
@@ -65,9 +66,9 @@ class GxEPD2_730c_GDEP073E01 : public GxEPD2_EPD
     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 and GxEPD2_565c and GxEPD2_730c_GDEP073E01 paged workaround
     void drawNativeColors();
   private:
+    void _setPartialRamArea(uint16_t x, uint16_t y, uint16_t w, uint16_t h);
     uint8_t _colorOfDemoBitmap(uint8_t from, int16_t mode = 0);
     void _PowerOn();
     void _PowerOff();