Merge branch 'dev' of https://github.com/SolderedElectronics/Inkplate-Arduino-library into dev

Author: JosipKuci

src/boards/Inkplate13/Inkplate13Driver.cpp

@@ -197,11 +197,22 @@ void EPDDriver::display(bool _leaveOn)
 void EPDDriver::displayPartial(int16_t x, int16_t y, int16_t w, int16_t h, bool _leaveOn)
 {
     // Clip to the screen bounds for the current rotation.
-    if (x < 0) { w += x; x = 0; }
-    if (y < 0) { h += y; y = 0; }
-    if (x + w > _inkplate->width())  w = _inkplate->width()  - x;
-    if (y + h > _inkplate->height()) h = _inkplate->height() - y;
-    if (w <= 0 || h <= 0) return;
+    if (x < 0)
+    {
+        w += x;
+        x = 0;
+    }
+    if (y < 0)
+    {
+        h += y;
+        y = 0;
+    }
+    if (x + w > _inkplate->width())
+        w = _inkplate->width() - x;
+    if (y + h > _inkplate->height())
+        h = _inkplate->height() - y;
+    if (w <= 0 || h <= 0)
+        return;
 
     // Map user rectangle to panel-native rectangle.
     // Panel native: col = 0..E_INK_WIDTH-1 (1199), row = 0..E_INK_HEIGHT-1 (1599).
@@ -212,100 +223,109 @@ void EPDDriver::displayPartial(int16_t x, int16_t y, int16_t w, int16_t h, bool
     case 0:
         // User space: E_INK_WIDTH × E_INK_HEIGHT.
         // panel_col = (E_INK_WIDTH-1) - x,  panel_row = (E_INK_HEIGHT-1) - y.
-        colStart = (int16_t)E_INK_WIDTH  - x - w;
-        colEnd   = (int16_t)E_INK_WIDTH  - 1 - x;
+        colStart = (int16_t)E_INK_WIDTH - x - w;
+        colEnd = (int16_t)E_INK_WIDTH - 1 - x;
         rowStart = (int16_t)E_INK_HEIGHT - y - h;
-        rowEnd   = (int16_t)E_INK_HEIGHT - 1 - y;
+        rowEnd = (int16_t)E_INK_HEIGHT - 1 - y;
         break;
     case 2:
         // User space: E_INK_WIDTH × E_INK_HEIGHT.
         // panel_col = x,  panel_row = y  (identity — no transform applied in writePixelInternal).
         colStart = x;
-        colEnd   = x + w - 1;
+        colEnd = x + w - 1;
         rowStart = y;
-        rowEnd   = y + h - 1;
+        rowEnd = y + h - 1;
         break;
     case 3:
         // User space: E_INK_HEIGHT × E_INK_WIDTH.
         // panel_col = (E_INK_WIDTH-1) - y,  panel_row = x.
         colStart = (int16_t)E_INK_WIDTH - y - h;
-        colEnd   = (int16_t)E_INK_WIDTH - 1 - y;
+        colEnd = (int16_t)E_INK_WIDTH - 1 - y;
         rowStart = x;
-        rowEnd   = x + w - 1;
+        rowEnd = x + w - 1;
         break;
     default:
     case 1:
         // User space: E_INK_HEIGHT × E_INK_WIDTH.
         // panel_col = y,  panel_row = (E_INK_HEIGHT-1) - x.
         colStart = y;
-        colEnd   = y + h - 1;
+        colEnd = y + h - 1;
         rowStart = (int16_t)E_INK_HEIGHT - x - w;
-        rowEnd   = (int16_t)E_INK_HEIGHT - 1 - x;
+        rowEnd = (int16_t)E_INK_HEIGHT - 1 - x;
         break;
     }
 
     // PTLW alignment requirements (GDEP133C02):
     //   H: colStart and (colEnd+1) must both be multiples of 4.
     //   V: rowStart must be even; (rowEnd+1) must be even.
     colStart = (colStart / 4) * 4;
-    colEnd   = (((colEnd + 4) / 4) * 4) - 1;
-    if (colEnd  >= (int16_t)E_INK_WIDTH)  colEnd  = (int16_t)E_INK_WIDTH  - 1;
-    if (rowStart % 2 != 0) rowStart--;
-    if (rowStart < 0) rowStart = 0;
-    if ((rowEnd + 1) % 2 != 0) rowEnd++;
-    if (rowEnd  >= (int16_t)E_INK_HEIGHT) rowEnd  = (int16_t)E_INK_HEIGHT - 1;
+    colEnd = (((colEnd + 4) / 4) * 4) - 1;
+    if (colEnd >= (int16_t)E_INK_WIDTH)
+        colEnd = (int16_t)E_INK_WIDTH - 1;
+    if (rowStart % 2 != 0)
+        rowStart--;
+    if (rowStart < 0)
+        rowStart = 0;
+    if ((rowEnd + 1) % 2 != 0)
+        rowEnd++;
+    if (rowEnd >= (int16_t)E_INK_HEIGHT)
+        rowEnd = (int16_t)E_INK_HEIGHT - 1;
 
     setPanelState(true);
 
     const int16_t HALF_WIDTH = (int16_t)(E_INK_WIDTH / 2); // 600 pixels per chip
-    const int16_t HALF_BYTES = HALF_WIDTH / 2;              // 300 bytes per row per chip
+    const int16_t HALF_BYTES = HALF_WIDTH / 2;             // 300 bytes per row per chip
 
     bool masterNeeded = (colStart < HALF_WIDTH);
-    bool slaveNeeded  = (colEnd   >= HALF_WIDTH);
+    bool slaveNeeded = (colEnd >= HALF_WIDTH);
 
     // Both chips must receive a full PTLW+DTM cycle before DRF, otherwise the
     // uninvolved chip falls back to a full-panel refresh when DRF fires.
     // For the uninvolved chip, a minimal 4×4 null window is used: it reads the
     // existing framebuffer data (same as what is already on screen) so the
     // refresh produces no visible change on that side.
     static const uint8_t ptlwNull[9] = {
-        0x00, 0x00,  // HRST = 0
-        0x00, 0x07,  // HRED = 7
-        0x00, 0x00,  // VRST = 0
-        0x00, 0x01,  // VRED = 1
-        0x01         // PT   = 1 (enable)
+        0x00, 0x00, // HRST = 0
+        0x00, 0x07, // HRED = 7
+        0x00, 0x00, // VRST = 0
+        0x00, 0x01, // VRED = 1
+        0x01        // PT   = 1 (enable)
     };
 
     // Master chip
     {
-        uint8_t  ptlwData[9];
-        int16_t  bytesPerRow, memColOff, rStart, rEnd;
+        uint8_t ptlwData[9];
+        int16_t bytesPerRow, memColOff, rStart, rEnd;
 
         if (masterNeeded)
         {
-            int16_t lcs     = colStart;
-            int16_t lce     = (colEnd < HALF_WIDTH) ? colEnd : (HALF_WIDTH - 1);
-            uint16_t HRST   = (uint16_t)lcs * 2;
-            uint16_t HRED   = (uint16_t)(lce + 1) * 2 - 1;
-            uint16_t VRST   = (uint16_t)rowStart / 2;
-            uint16_t VRED   = (uint16_t)(rowEnd + 1) / 2 - 1;
-            ptlwData[0] = HRST >> 8; ptlwData[1] = HRST & 0xFF;
-            ptlwData[2] = HRED >> 8; ptlwData[3] = HRED & 0xFF;
-            ptlwData[4] = VRST >> 8; ptlwData[5] = VRST & 0xFF;
-            ptlwData[6] = VRED >> 8; ptlwData[7] = VRED & 0xFF;
+            int16_t lcs = colStart;
+            int16_t lce = (colEnd < HALF_WIDTH) ? colEnd : (HALF_WIDTH - 1);
+            uint16_t HRST = (uint16_t)lcs * 2;
+            uint16_t HRED = (uint16_t)(lce + 1) * 2 - 1;
+            uint16_t VRST = (uint16_t)rowStart / 2;
+            uint16_t VRED = (uint16_t)(rowEnd + 1) / 2 - 1;
+            ptlwData[0] = HRST >> 8;
+            ptlwData[1] = HRST & 0xFF;
+            ptlwData[2] = HRED >> 8;
+            ptlwData[3] = HRED & 0xFF;
+            ptlwData[4] = VRST >> 8;
+            ptlwData[5] = VRST & 0xFF;
+            ptlwData[6] = VRED >> 8;
+            ptlwData[7] = VRED & 0xFF;
             ptlwData[8] = 0x01;
             bytesPerRow = (lce - lcs + 1) / 2;
-            memColOff   = lcs / 2;
-            rStart      = rowStart;
-            rEnd        = rowEnd;
+            memColOff = lcs / 2;
+            rStart = rowStart;
+            rEnd = rowEnd;
         }
         else
         {
             memcpy(ptlwData, ptlwNull, 9);
-            bytesPerRow = 2;          // 4 px / 2 px-per-byte
-            memColOff   = 0;          // top-left corner of master's region
-            rStart      = 0;
-            rEnd        = 3;
+            bytesPerRow = 2; // 4 px / 2 px-per-byte
+            memColOff = 0;   // top-left corner of master's region
+            rStart = 0;
+            rEnd = 3;
         }
 
         SPI.beginTransaction(epdSpiSettings);
@@ -334,34 +354,38 @@ void EPDDriver::displayPartial(int16_t x, int16_t y, int16_t w, int16_t h, bool
     // Slave chip
     waitForBusy();
     {
-        uint8_t  ptlwData[9];
-        int16_t  bytesPerRow, memColOff, rStart, rEnd;
+        uint8_t ptlwData[9];
+        int16_t bytesPerRow, memColOff, rStart, rEnd;
 
         if (slaveNeeded)
         {
-            int16_t lcs     = (colStart >= HALF_WIDTH) ? (colStart - HALF_WIDTH) : 0;
-            int16_t lce     = colEnd - HALF_WIDTH;
-            uint16_t HRST   = (uint16_t)lcs * 2;
-            uint16_t HRED   = (uint16_t)(lce + 1) * 2 - 1;
-            uint16_t VRST   = (uint16_t)rowStart / 2;
-            uint16_t VRED   = (uint16_t)(rowEnd + 1) / 2 - 1;
-            ptlwData[0] = HRST >> 8; ptlwData[1] = HRST & 0xFF;
-            ptlwData[2] = HRED >> 8; ptlwData[3] = HRED & 0xFF;
-            ptlwData[4] = VRST >> 8; ptlwData[5] = VRST & 0xFF;
-            ptlwData[6] = VRED >> 8; ptlwData[7] = VRED & 0xFF;
+            int16_t lcs = (colStart >= HALF_WIDTH) ? (colStart - HALF_WIDTH) : 0;
+            int16_t lce = colEnd - HALF_WIDTH;
+            uint16_t HRST = (uint16_t)lcs * 2;
+            uint16_t HRED = (uint16_t)(lce + 1) * 2 - 1;
+            uint16_t VRST = (uint16_t)rowStart / 2;
+            uint16_t VRED = (uint16_t)(rowEnd + 1) / 2 - 1;
+            ptlwData[0] = HRST >> 8;
+            ptlwData[1] = HRST & 0xFF;
+            ptlwData[2] = HRED >> 8;
+            ptlwData[3] = HRED & 0xFF;
+            ptlwData[4] = VRST >> 8;
+            ptlwData[5] = VRST & 0xFF;
+            ptlwData[6] = VRED >> 8;
+            ptlwData[7] = VRED & 0xFF;
             ptlwData[8] = 0x01;
             bytesPerRow = (lce - lcs + 1) / 2;
-            memColOff   = HALF_BYTES + lcs / 2;
-            rStart      = rowStart;
-            rEnd        = rowEnd;
+            memColOff = HALF_BYTES + lcs / 2;
+            rStart = rowStart;
+            rEnd = rowEnd;
         }
         else
         {
             memcpy(ptlwData, ptlwNull, 9);
-            bytesPerRow = 2;          // 4 px / 2 px-per-byte
-            memColOff   = HALF_BYTES; // top-left corner of slave's region
-            rStart      = 0;
-            rEnd        = 3;
+            bytesPerRow = 2;        // 4 px / 2 px-per-byte
+            memColOff = HALF_BYTES; // top-left corner of slave's region
+            rStart = 0;
+            rEnd = 3;
         }
 
         SPI.beginTransaction(epdSpiSettings);