Updated for ESP-IDF 6.0, added missing print() functions for ESP and enabled anti-aliased characters in 2-bit mode

Author: bitbank2

src/FastEPD.cpp

@@ -466,6 +466,106 @@ uint8_t FASTEPD::ioRead(uint8_t u8Pin)
     return val;
 }
 
+// Implement missing print functions
+#ifndef ARDUINO
+void FASTEPD::print(int value, int format)
+{
+char c, ucTemp[32];
+char *d = &ucTemp[31];
+
+   if (value) {
+   d[0] = 0;
+   switch(format) {
+      case DEC:
+         while (value) {
+             d--;
+             *d = '0' + (value % 10);
+             value /= 10;
+         }
+         break;
+      case HEX:
+         while (value) {
+            d--;
+            c = value & 0xf;
+            if (c < 10)
+                    *d = '0' + c;
+            else
+                    *d = 'A' + (c-10);
+            value >>= 4;
+         }
+         break;
+      case OCT:
+         while (value) {
+            d--;
+            *d = '0' + (value & 7);
+            value >>= 3;
+         }
+         break;
+      case BIN:
+         while (value) {
+            d--;
+            *d = '0' + (value & 1);
+            value >>= 1;
+         }
+         break;
+      default:
+         break;
+      }
+   } else { // if zero value
+     d--;
+     *d = '0';
+   }
+   print((const char *)d);
+} /* print() */
+
+void FASTEPD::println(int value, int format)
+{
+char ucTemp[4];
+
+        print(value, format);
+        ucTemp[0] = '\n';
+        ucTemp[1] = '\r';
+        ucTemp[2] = 0;
+        print((const char *)ucTemp);
+} /* println() */
+
+void FASTEPD::print(const std::string &str)
+{
+   print(str.c_str());
+} /* print() */
+
+void FASTEPD::println(const char *pString)
+{
+char ucTemp[4];
+
+    print(pString);
+    ucTemp[0] = '\n';
+    ucTemp[1] = '\r';
+    ucTemp[2] = 0;
+    print((const char *)ucTemp);
+} /* println() */
+void FASTEPD::println(const std::string &str)
+{
+char ucTemp[4];
+
+   print(str);
+   ucTemp[0] = '\n';
+   ucTemp[1] = '\r';
+   ucTemp[2] = 0;
+   print((const char *)ucTemp);
+} /* println() */
+
+void FASTEPD::print(const char *pString)
+{
+uint8_t *s = (uint8_t *)pString;
+
+   while (*s != 0) {
+      write(*s++);
+   }
+} /* print() */
+
+#endif // !ARDUINO
+
 void FASTEPD::setBitBang(bool bBitBang)
 {
     _state.bit_bang = (uint8_t)bBitBang;
@@ -487,7 +587,9 @@ void FASTEPD::setFont(const void *pFont, bool bAntiAlias)
 {
     _state.iFont = -1;
     _state.pFont = (void *)pFont;
-    if (_state.mode != BB_MODE_4BPP) bAntiAlias = false; // only works in grayscale mode
+    if (_state.mode == BB_MODE_1BPP) {
+        bAntiAlias = false; // only works in 2 or 4-bit grayscale mode
+    }
     _state.anti_alias = (uint8_t)bAntiAlias;
 } /* setFont() */
 
@@ -582,8 +684,13 @@ static uint8_t u8Unicode0, u8Unicode1;
         pGlyphSmall = &pBBFS->glyphs[c - first]; pGlyph = NULL;
       }
     if (c == '\n') {
+      h = (pBBF) ? pBBF->height : pBBFS->height;
       _state.iCursorX = 0;
-      _state.iCursorY += (pBBF) ? pBBF->height : pBBFS->height;
+      if (_state.anti_alias) { 
+          _state.iCursorY += h/2;
+      } else {
+          _state.iCursorY += h;
+      }
     } else if (c != '\r') {
       if (c >= first && c <= last) {
         if (pBBF) {
@@ -597,7 +704,11 @@ static uint8_t u8Unicode0, u8Unicode1;
           w += (pBBF) ? pGlyph->xOffset : pGlyphSmall->xOffset;
           if (_state.wrap && (_state.iCursorX + w) > _state.width) {
             _state.iCursorX = 0;
-            _state.iCursorY += h;
+            if (_state.anti_alias) {
+                _state.iCursorY += h/2;
+            } else {
+                _state.iCursorY += h;
+            }
           }
           bbepWriteStringCustom(&_state, _state.pFont, -1, -1, szTemp, _state.iFG);
         }

src/FastEPD.h

@@ -24,15 +24,15 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-// for Print support
-#ifdef __LINUX__
+#ifdef __cplusplus
 #include <string>
+#endif // __cplusplus
+// for Print support
 using namespace std;
 #define DEC 10
 #define HEX 16
 #define OCT 8
 #define BIN 2
-#endif // __LINUX__
 #endif
 
 #define BB_PANEL_FLAG_NONE     0x00
@@ -320,8 +320,8 @@ class FASTEPD
     void println(const char *pString);
     void print(int, int);
     void println(int, int);
-    void print(const string &);
-    void println(const string &);
+    void print(const std::string &);
+    void println(const std::string &);
 #endif
 
   protected:

src/FastEPD.inl

@@ -288,17 +288,21 @@ static bool s3_notify_dma_ready(esp_lcd_panel_io_handle_t panel_io, esp_lcd_pane
 // Maximum line width = 1024 * 4 = 4096 pixels
 #define MAX_TX_SIZE 1024
 static esp_lcd_i80_bus_config_t s3_bus_config = {
-    .dc_gpio_num = 0,
-    .wr_gpio_num = 0,
+    .dc_gpio_num = (gpio_num_t)0,
+    .wr_gpio_num = (gpio_num_t)0,
     .clk_src = /*LCD_CLK_SRC_DEFAULT,*/ LCD_CLK_SRC_PLL160M,
-    .data_gpio_nums = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
+    .data_gpio_nums = {(gpio_num_t)0},
     .bus_width = 0,
     .max_transfer_bytes = MAX_TX_SIZE, 
+#if ESP_IDF_VERSION <= ESP_IDF_VERSION_VAL(5, 0, 0)
     .psram_trans_align = 0, // 0 = use default values
     .sram_trans_align = 0,
+#else
+    .dma_burst_size = 32,
+#endif
 };
 static esp_lcd_panel_io_i80_config_t s3_io_config = {
-        .cs_gpio_num = 0,
+        .cs_gpio_num = (gpio_num_t)0,
         .pclk_hz = 12000000,
         .trans_queue_depth = 4,
         .on_color_trans_done = s3_notify_dma_ready,
@@ -1429,15 +1433,15 @@ int bbepIOInit(FASTEPDSTATE *pState)
     s3_bus_config.wr_gpio_num = (gpio_num_t)pState->panelDef.ioCL;
     s3_bus_config.bus_width = pState->panelDef.bus_width;
     for (int i=0; i<pState->panelDef.bus_width; i++) {
-        s3_bus_config.data_gpio_nums[i] = pState->panelDef.data[i];
+        s3_bus_config.data_gpio_nums[i] = (gpio_num_t)pState->panelDef.data[i];
     }   
     ESP_ERROR_CHECK(esp_lcd_new_i80_bus(&s3_bus_config, &i80_bus));
     s3_io_config.pclk_hz = pState->panelDef.bus_speed;
     if (pState->panelDef.flags & BB_PANEL_FLAG_SLOW_SPH) {
         bSlowSPH = 1;
         u8SPH = (gpio_num_t)pState->panelDef.ioSPH;
         u8CKV = (gpio_num_t)pState->panelDef.ioCKV;
-        s3_io_config.cs_gpio_num = -1; // disable hardware CS
+        s3_io_config.cs_gpio_num = (gpio_num_t)-1; // disable hardware CS
     } else {
         s3_io_config.cs_gpio_num = (gpio_num_t)pState->panelDef.ioSPH;
     }

src/arduino_io.inl

@@ -32,7 +32,9 @@ static int iDelay = 0; //1;
 #ifndef ARDUINO
 #include "driver/gpio.h"
 #include "esp_timer.h"
-
+#include "driver/i2c_master.h"
+i2c_master_bus_handle_t bus_handle;
+i2c_master_dev_handle_t dev_handle;
 // GPIO modes
 #define memcpy_P memcpy
 #define pgm_read_byte(a) (*(uint8_t *)a)
@@ -273,6 +275,17 @@ int bbepI2CInit(uint8_t sda, uint8_t scl, int bb)
         Wire.setClock(400000);
         Wire.setTimeout(100);
 #else
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
+    i2c_master_bus_config_t conf;
+
+    conf.i2c_port = I2C_NUM_0;
+    conf.sda_io_num = (gpio_num_t)sda;
+    conf.scl_io_num = (gpio_num_t)scl;
+    conf.clk_source = I2C_CLK_SRC_DEFAULT;
+    conf.glitch_ignore_cnt = 7;
+    conf.flags.enable_internal_pullup = true;
+    ESP_ERROR_CHECK(i2c_new_master_bus(&conf, &bus_handle));
+#else // older esp-idff
     i2c_config_t conf;
     ESP_ERROR_CHECK(i2c_driver_delete());
     conf.mode = I2C_MODE_MASTER;
@@ -281,9 +294,10 @@ int bbepI2CInit(uint8_t sda, uint8_t scl, int bb)
     conf.sda_pullup_en = GPIO_PULLUP_ENABLE;
     conf.scl_pullup_en = GPIO_PULLUP_ENABLE;
     conf.master.clk_speed = 400000;
-    conf.clk_flags = 0; 
+    conf.clk_flags = 0;
     ESP_ERROR_CHECK(i2c_param_config(I2C_NUM_0, &conf));
     ESP_ERROR_CHECK(i2c_driver_install(I2C_NUM_0, I2C_MODE_MASTER, 0, 0, 0));
+#endif // older IDF
 #endif // ARDUINO
     } // !BitBang
     return BBEP_SUCCESS;
@@ -302,6 +316,16 @@ int bbepI2CWrite(unsigned char iAddr, unsigned char *pData, int iLen)
     rc = !Wire.endTransmission();
     return rc;
 #else
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
+    i2c_device_config_t dev_config;
+    dev_config.dev_addr_length = I2C_ADDR_BIT_LEN_7;
+    dev_config.device_address = iAddr; 
+    dev_config.scl_speed_hz = 400000;
+    ESP_ERROR_CHECK(i2c_master_bus_add_device(bus_handle, &dev_config, &dev_handle));
+    esp_err_t ret = i2c_master_transmit(dev_handle, pData, iLen, 1000); // 1-second timeout
+    i2c_master_bus_rm_device(dev_handle);
+    return (ret == ESP_OK);
+#else // older idf version
     i2c_cmd_handle_t cmd = i2c_cmd_link_create();
     if (cmd == NULL) {
        // ESP_LOGE("bb_epdiy", "insufficient memory for I2C transaction");
@@ -313,6 +337,7 @@ int bbepI2CWrite(unsigned char iAddr, unsigned char *pData, int iLen)
     esp_err_t ret = i2c_master_cmd_begin(I2C_NUM_0, cmd, 1000 / portTICK_PERIOD_MS);
     i2c_cmd_link_delete(cmd);
     return (ret == ESP_OK);
+#endif // older esp-idf
 #endif // ARDUINO
     } // !BitBang
 }
@@ -330,6 +355,16 @@ int i = 0;
     }
 #else
     esp_err_t ret;
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
+    i2c_device_config_t dev_config;
+    dev_config.dev_addr_length = I2C_ADDR_BIT_LEN_7;
+    dev_config.device_address = iAddr;
+    dev_config.scl_speed_hz = 400000;
+    ESP_ERROR_CHECK(i2c_master_bus_add_device(bus_handle, &dev_config, &dev_handle));
+    ret = i2c_master_transmit_receive(dev_handle, NULL, 0, pData, iLen, 1000); // 1-second timeout
+    i2c_master_bus_rm_device(dev_handle);
+    return (ret == ESP_OK);
+#else // older ESP-IDF
     i2c_cmd_handle_t cmd = i2c_cmd_link_create();
     if (cmd == NULL) {
        // ESP_LOGE("epdiy", "insufficient memory for I2C transaction");
@@ -347,6 +382,7 @@ int i = 0;
         i = iLen;
     }
     i2c_cmd_link_delete(cmd);
+#endif // older esp-idf version
 #endif // ARDUINO
     } // !BitBang
     return i;

src/bb_ep_gfx.inl

@@ -1141,9 +1141,16 @@ int bbepWriteStringCustom(FASTEPDSTATE *pBBEP, const void *pFont, int x, int y,
             }
             tw = w;
             if (pBBEP->anti_alias) { // draw half-size anti-aliased characters
-                const uint8_t grayColors[4] = {0xf, 0xc, 0x6, 0};
-                const uint8_t invertedGrays[4] = {0, 0x6, 0xc, 0xf};
-                uint8_t *pGrays = (iBG == 0) ? (uint8_t*)invertedGrays : (uint8_t*)grayColors;
+                const uint8_t grayColors4bpp[4] = {0xf, 0xc, 0x6, 0};
+                const uint8_t invertedGrays4bpp[4] = {0, 0x6, 0xc, 0xf};
+                const uint8_t grayColors2bpp[4] = {3, 2, 1, 0};
+                const uint8_t invertedGrays2bpp[4] = {0, 1, 2, 3};
+                uint8_t *pGrays;
+                if (pBBEP->mode == BB_MODE_4BPP) {
+                    pGrays = (iBG == 0) ? (uint8_t*)invertedGrays4bpp : (uint8_t*)grayColors4bpp;
+                } else { // must be 2bpp
+                    pGrays = (iBG == 0) ? (uint8_t*)invertedGrays2bpp : (uint8_t*)grayColors2bpp;
+                }
                 int iLineSize = (tw+7)/8;
                 memset(u8Cache, 0, iLineSize*2); // start with 2 lines of white (gray table is inverted)
                 for (ty=dy; ty<end_y+1 && ty+1 < height; ty++) {