preliminary

examples/GxEPD2_SD_Example/GxEPD2_SD_Example.ino

@@ -42,8 +42,19 @@
 #include <GxEPD2_3C.h>
 #include <Fonts/FreeMonoBold9pt7b.h>
 
-#include <SPI.h>
+// include SdFat for FAT32 support with long filenames; available through Library Manager
+#include <SdFat.h>
+
+#if defined(SdFat_h)
+SdFat SD;
+#define FileClass SdFile
+#define position curPosition
+#define seek seekSet
+#else
 #include <SD.h>
+#define FileClass File
+#undef SdFat_h
+#endif
 
 #if defined (ESP8266)
 #define SD_CS SS  // e.g. for RobotDyn Wemos D1 mini SD board
@@ -163,11 +174,32 @@ void setup()
   Serial.println("SD OK!");
 
   drawBitmapFromSD("parrot.bmp", 0, 0);
-  delay(5000);
+  delay(2000);
   drawBitmapFromSD("betty_1.bmp", 0, 0);
-  delay(5000);
-  //drawBitmapFromSD("logo.bmp", 0, 0);
-  //delay(5000);
+  delay(2000);
+#if defined(SdFat_h)
+  drawBitmapFromSD("logo200x200.bmp", 0, 0);
+  delay(2000);
+  drawBitmapFromSD("first200x200.bmp", 0, 0);
+  delay(2000);
+  drawBitmapFromSD("second200x200.bmp", 0, 0);
+  delay(2000);
+  drawBitmapFromSD("third200x200.bmp", 0, 0);
+  delay(2000);
+  drawBitmapFromSD("fourth200x200.bmp", 0, 0);
+  delay(2000);
+  drawBitmapFromSD("fifth200x200.bmp", 0, 0);
+  delay(2000);
+  drawBitmapFromSD("sixth200x200.bmp", 0, 0);
+  delay(2000);
+  drawBitmapFromSD("senventh200x200.bmp", 0, 0);
+  delay(2000);
+  drawBitmapFromSD("eighth200x200.bmp", 0, 0);
+  delay(2000);
+#else
+  drawBitmapFromSD("logo.bmp", 0, 0);
+  delay(2000);
+#endif
 }
 
 void loop(void)
@@ -178,7 +210,7 @@ void loop(void)
 
 void drawBitmapFromSD(const char *filename, uint8_t x, uint8_t y)
 {
-  File file;
+  FileClass file;
   uint8_t buffer[3 * SD_BUFFER_PIXELS]; // pixel buffer, size for r,g,b
   bool valid = false; // valid format to be handled
   bool flip = true; // bitmap is stored bottom-to-top
@@ -189,12 +221,20 @@ void drawBitmapFromSD(const char *filename, uint8_t x, uint8_t y)
   Serial.print("Loading image '");
   Serial.print(filename);
   Serial.println('\'');
+#if defined(SdFat_h)
+  if (!file.open(filename, FILE_READ))
+  {
+    Serial.print("File not found");
+    return;
+  }
+#else
   file = SD.open(filename);
   if (!file)
   {
     Serial.print("File not found");
     return;
   }
+#endif
   // Parse BMP header
   if (read16(file) == 0x4D42) // BMP signature
   {
@@ -217,6 +257,14 @@ void drawBitmapFromSD(const char *filename, uint8_t x, uint8_t y)
       Serial.print(width);
       Serial.print('x');
       Serial.println(height);
+      //      Serial.print("first position "); Serial.println(file.position());
+      //      for (uint32_t i = file.position(); i < imageOffset; i++)
+      //      {
+      //        uint8_t data = file.read();// remaining header bytes
+      //        Serial.print("0x"); Serial.print(data, HEX); Serial.print(", ");
+      //      }
+      //      Serial.println();
+      //      Serial.print("start position "); Serial.println(file.position());
       // BMP rows are padded (if needed) to 4-byte boundary
       uint32_t rowSize = (width * depth / 8 + 3) & ~3;
       if (height < 0)
@@ -300,6 +348,7 @@ void drawBitmapFromSD(const char *filename, uint8_t x, uint8_t y)
       }
     }
   }
+  //Serial.print("end position  "); Serial.println(file.position());
   file.close();
   if (valid)
   {
@@ -313,7 +362,7 @@ void drawBitmapFromSD(const char *filename, uint8_t x, uint8_t y)
   }
 }
 
-uint16_t read16(File f)
+uint16_t read16(FileClass& f)
 {
   // BMP data is stored little-endian, same as Arduino.
   uint16_t result;
@@ -322,7 +371,7 @@ uint16_t read16(File f)
   return result;
 }
 
-uint32_t read32(File f)
+uint32_t read32(FileClass& f)
 {
   // BMP data is stored little-endian, same as Arduino.
   uint32_t result;

examples/GxEPD2_SD_WriteBitmap/GxEPD2_SD_WriteBitmap.ino

@@ -0,0 +1,215 @@
+// GxEPD2_SD_WriteBitmap: utility for Display Library for SPI e-paper panels from Dalian Good Display and boards from Waveshare.
+//
+// based on Demo Example from Good Display: http://www.good-display.com/download_list/downloadcategoryid=34&isMode=false.html
+//
+// Author: Jean-Marc Zingg
+//
+// Version: see library.properties
+//
+// Library: https://github.com/ZinggJM/GxEPD2
+
+#include <GxEPD2_BW.h>
+#include <GxEPD2_3C.h>
+#include <Fonts/FreeMonoBold9pt7b.h>
+
+#include "bitmaps/Bitmaps200x200.h" // 1.54" b/w
+//#include "bitmaps/Bitmaps128x250.h" // 2.13" b/w
+//#include "bitmaps/Bitmaps128x296.h" // 2.9"  b/w
+//#include "bitmaps/Bitmaps176x264.h" // 2.7"  b/w
+//#include "bitmaps/Bitmaps400x300.h" // 4.2"  b/w
+//#include "bitmaps/Bitmaps640x384.h" // 7.5"  b/w
+// 3-color
+//#include "bitmaps/Bitmaps3c200x200.h" // 1.54" b/w/r
+//#include "bitmaps/Bitmaps3c104x212.h" // 2.13" b/w/r
+//#include "bitmaps/Bitmaps3c128x296.h" // 2.9"  b/w/r
+//#include "bitmaps/Bitmaps3c176x264.h" // 2.7"  b/w/r
+//#include "bitmaps/Bitmaps3c400x300.h" // 4.2"  b/w/r
+
+// include SdFat for FAT32 support with long filenames; available through Library Manager
+#include <SdFat.h>
+
+#if defined(SdFat_h)
+SdFat SD;
+#define FileClass SdFile
+#define position curPosition
+#define seek seekSet
+#else
+#include <SD.h>
+#define FileClass File
+#undef SdFat_h
+#endif
+
+void setup()
+{
+  Serial.begin(115200);
+  Serial.print("Initializing SD card...");
+  if (!SD.begin(SS))
+  {
+    Serial.println("initialization failed!");
+    while (1) yield();
+  }
+  Serial.println("initialization done.");
+  writeBitmaps();
+}
+
+void loop()
+{
+}
+
+void writeBitmap(const char filename[], const uint8_t bitmap[], int16_t w, int16_t h, uint16_t depth = 1);
+uint8_t filldata[] = {0x0, 0x23, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xFF, 0xFF, 0xFF, 0x0};
+
+void writeBitmaps()
+{
+#ifdef _GxBitmaps200x200_H_
+  writeBitmap("logo.bmp", logo200x200, 200, 200);
+  writeBitmap("logo200x200.bmp", logo200x200, 200, 200);
+  writeBitmap("first200x200.bmp", first200x200, 200, 200);
+  writeBitmap("second200x200.bmp", second200x200, 200, 200);
+  writeBitmap("third200x200.bmp", third200x200, 200, 200);
+  writeBitmap("fourth200x200.bmp", fourth200x200, 200, 200);
+  writeBitmap("fifth200x200.bmp", fifth200x200, 200, 200);
+  writeBitmap("sixth200x200.bmp", sixth200x200, 200, 200);
+  writeBitmap("senventh200x200.bmp", senventh200x200, 200, 200);
+  writeBitmap("eighth200x200.bmp", eighth200x200, 200, 200);
+#endif
+#ifdef _GxBitmaps128x250_H_
+  writeBitmap("Bitmap128x250_1.bmp", Bitmap128x250_1, 128, 250);
+  writeBitmap("logo128x250.bmp", logo128x250, 128, 250);
+  writeBitmap("first128x250.bmp", first128x250, 128, 250);
+  writeBitmap("second128x250.bmp", second128x250, 128, 250);
+  writeBitmap("third128x250.bmp", third128x250, 128, 250);
+#endif
+#ifdef _GxBitmaps128x296_H_
+  writeBitmap("Bitmap128x296_1.bmp", Bitmap128x296_1, 128, 296);
+  writeBitmap("logo128x296.bmp", logo128x296, 128, 296);
+  writeBitmap("first128x296.bmp", first128x296, 128, 296);
+  writeBitmap("second128x296.bmp", second128x296, 128, 296);
+  writeBitmap("third128x296.bmp", third128x296, 128, 296);
+#endif
+#ifdef _GxBitmaps176x264_H_
+  writeBitmap("Bitmap176x264_1.bmp", Bitmap176x264_1, 176, 264);
+  writeBitmap("Bitmap176x264_2.bmp", Bitmap176x264_2, 176, 264);
+#endif
+#ifdef _GxBitmaps400x300_H_
+  writeBitmap("Bitmap400x300_1.bmp", Bitmap400x300_1, 400, 300);
+  writeBitmap("Bitmap400x300_2.bmp", Bitmap400x300_2, 400, 300);
+#endif
+#ifdef _GxBitmaps640x384_H_
+  writeBitmap("Bitmap640x384_1.bmp", Bitmap640x384_1, 640, 384);
+  writeBitmap("Bitmap640x384_2.bmp", Bitmap640x384_2, 640, 384);
+#endif
+  // 3-color
+#ifdef _GxBitmaps3c200x200_H_
+  writeBitmap("Bitmap3c200x200_black.bmp", Bitmap3c200x200_black, 200, 200);
+  writeBitmap("Bitmap3c200x200_red.bmp", Bitmap3c200x200_red, 200, 200);
+  writeBitmap("WS_Bitmap3c200x200_black.bmp", WS_Bitmap3c200x200_black, 200, 200);
+  writeBitmap("WS_Bitmap3c200x200_red.bmp", WS_Bitmap3c200x200_red, 200, 200);
+#endif
+#ifdef _GxBitmaps3c104x212_H_
+  writeBitmap("Bitmap3c104x212_1_black.bmp", Bitmap3c104x212_1_black, 104, 212);
+  writeBitmap("Bitmap3c104x212_1_red.bmp", Bitmap3c104x212_1_red, 104, 212);
+  writeBitmap("Bitmap3c104x212_2_black.bmp", Bitmap3c104x212_2_black, 104, 212);
+  writeBitmap("Bitmap3c104x212_2_red.bmp", Bitmap3c104x212_2_red, 104, 212);
+  writeBitmap("WS_Bitmap3c104x212_black.bmp", WS_Bitmap3c104x212_black, 104, 212);
+  writeBitmap("WS_Bitmap3c104x212_red.bmp", WS_Bitmap3c104x212_red, 104, 212);
+#endif
+#ifdef _GxBitmaps3c128x296_H_
+  writeBitmap("Bitmap3c128x296_1_black.bmp", Bitmap3c128x296_1_black, 128, 296);
+  writeBitmap("Bitmap3c128x296_1_red.bmp", Bitmap3c128x296_1_red, 128, 296);
+  writeBitmap("Bitmap3c128x296_2_black.bmp", Bitmap3c128x296_2_black, 128, 296);
+  writeBitmap("Bitmap3c128x296_2_red.bmp", Bitmap3c128x296_2_red, 128, 296);
+  writeBitmap("WS_Bitmap3c128x296_black.bmp", WS_Bitmap3c128x296_black, 128, 296);
+  writeBitmap("WS_Bitmap3c128x296_red.bmp", WS_Bitmap3c128x296_red, 128, 296);
+#endif
+#ifdef _GxBitmaps3c176x264_H_
+  writeBitmap("Bitmap3c176x264_black.bmp", Bitmap3c176x264_black, 176, 264);
+  writeBitmap("Bitmap3c176x264_red.bmp", Bitmap3c176x264_red, 176, 264);
+#endif
+#ifdef _GxBitmaps3c400x300_H_
+  writeBitmap("Bitmap3c400x300_1_black.bmp", Bitmap3c400x300_1_black, 400, 300);
+  writeBitmap("Bitmap3c400x300_1_red.bmp", Bitmap3c400x300_1_red, 400, 300);
+  writeBitmap("Bitmap3c400x300_2_black.bmp", Bitmap3c400x300_2_black, 400, 300);
+  writeBitmap("Bitmap3c400x300_2_red.bmp", Bitmap3c400x300_2_red, 400, 300);
+  writeBitmap("WS_Bitmap3c400x300_black.bmp", WS_Bitmap3c400x300_black, 400, 300);
+  writeBitmap("WS_Bitmap3c400x300_red.bmp", WS_Bitmap3c400x300_red, 400, 300);
+#endif
+}
+
+void writeBitmap(const char filename[], const uint8_t bitmap[], int16_t w, int16_t h, uint16_t depth)
+{
+  FileClass bitmapFile;
+  uint32_t rowSizeCode = (w + 8 - depth) * depth / 8;
+  // BMP rows are padded (if needed) to 4-byte boundary
+  uint32_t rowSizeBMP = (w * depth / 8 + 3) & ~3;
+  Serial.print("writeBitmap(\""); Serial.print(filename); Serial.println("\")");
+  Serial.print("rowSizeCode "); Serial.println(rowSizeCode);
+  Serial.print("rowSizeBMP  "); Serial.println(rowSizeBMP);
+  uint32_t headerSize = 40;
+  uint32_t imageOffset = 62;
+  uint32_t fileSize = imageOffset + h * rowSizeBMP;
+#if defined(SdFat_h)
+  if (bitmapFile.open(filename, FILE_WRITE))
+#else
+  bitmapFile = SD.open(filename, FILE_WRITE);
+  if (bitmapFile)
+#endif
+  {
+    bitmapFile.seek(0);
+    write16(bitmapFile, 0x4D42); // BMP signature
+    write32(bitmapFile, fileSize); // fileSize
+    write32(bitmapFile, 0); // creator bytes
+    write32(bitmapFile, imageOffset); // image offset
+    write32(bitmapFile, headerSize); // Header size
+    write32(bitmapFile, w); // image width
+    write32(bitmapFile, h); // image height
+    write16(bitmapFile, 1); // # planes
+    write16(bitmapFile, depth); // // bits per pixel
+    write32(bitmapFile, 0); // format uncompressed
+
+    //Serial.print("first position "); Serial.println(bitmapFile.position());
+    uint32_t j = 0;
+    for (uint32_t i = bitmapFile.position(); i < imageOffset; i++)
+    {
+      //bitmapFile.write(uint8_t(0)); // remaining header bytes
+      bitmapFile.write(filldata[j++]); // remaining header bytes
+    }
+    //Serial.print("start position "); Serial.println(bitmapFile.position());
+    uint32_t rowidx = 0;
+    for (uint16_t row = 0; row < h; row++) // for each line
+    {
+      uint32_t colidx;
+      for (colidx = 0; colidx < rowSizeCode; colidx++)
+      {
+#if defined(__AVR) || defined(ESP8266) || defined(ESP32)
+        uint8_t data = pgm_read_byte(&bitmap[rowidx + colidx]);
+#else
+        uint8_t data = bitmap[rowidx + colidx];
+#endif
+        bitmapFile.write(data);
+      }
+      rowidx += rowSizeCode;
+      while (colidx++ < rowSizeBMP) bitmapFile.write(uint8_t (0)); // padding
+      //Serial.println(bitmapFile.position());
+    }
+    bitmapFile.close();
+    Serial.println("done");
+  }
+  else Serial.print("open file for write failed!");
+}
+
+void write16(FileClass& f, uint16_t v)
+{
+  f.write(uint8_t(v));
+  f.write(uint8_t(v >> 8));
+}
+
+void write32(FileClass& f, uint32_t v)
+{
+  f.write(uint8_t(v));
+  f.write(uint8_t(v >> 8));
+  f.write(uint8_t(v >> 16));
+  f.write(uint8_t(v >> 24));
+}
+
+