Guition GUITION-ESP32-4848S040 examples of connection to LVGL 9.3

[brightproject]

Hello @lovyan03 and @tobozo 🙂
I use the GUITION-ESP32-4848S040 device, previously I output graphics via Arduino GFX.
I decided to try LovyanGFX and ran into a problem with examples and settings for connecting my display.
There is an old topic

#562 (comment)

Where the code of the example with the connection is indicated, but only for the LVGL version 8

https://github.com/lovyan03/LovyanGFX/blob/master/examples/Advanced/LVGL_PlatformIO/src/main.cpp

Why does the new version of LovyanGFX 1.2.7 not have examples for working with the LVGL version 9?
Here is my code, which can serve as this example:

// This file was created by e.vlad.engineer
// LVGL version: 9.3
// LovyanGFX version: 1.2.7

#include "Arduino.h"
#include <lvgl.h>
#include <LovyanGFX.h>
#include <lgfx/v1/platforms/esp32s3/Panel_RGB.hpp>
#include <lgfx/v1/platforms/esp32s3/Bus_RGB.hpp>
#include <driver/i2c.h>

uint32_t screenWidth;
uint32_t screenHeight;
uint32_t drawBufSize;
lv_display_t *disp;

class LGFX : public lgfx::LGFX_Device
{
public:

  lgfx::Bus_RGB      _bus_instance;
  lgfx::Panel_ST7701_guition_esp32_4848S040 _panel_instance;
  lgfx::Touch_GT911  _touch_instance;
  lgfx::Light_PWM   _light_instance;

  LGFX(void)
  {
    {
      auto cfg = _panel_instance.config();

      cfg.memory_width  = 480;
      cfg.memory_height = 480;
      cfg.panel_width  = 480;
      cfg.panel_height = 480;

      cfg.offset_x = 0;
      cfg.offset_y = 0;

      _panel_instance.config(cfg);
    }

    {
      auto cfg = _panel_instance.config_detail();

      cfg.pin_cs = 39; // CS
      cfg.pin_sclk = 48; // SCK
      cfg.pin_mosi = 47; // SDA or MOSI

      _panel_instance.config_detail(cfg);
    }

    {
      auto cfg = _bus_instance.config();
      cfg.panel = &_panel_instance;
      cfg.pin_d0  = GPIO_NUM_4;  // B0
      cfg.pin_d1  = GPIO_NUM_5;  // B1
      cfg.pin_d2  = GPIO_NUM_6; // B2
      cfg.pin_d3  = GPIO_NUM_7; // B3
      cfg.pin_d4  = GPIO_NUM_15;  // B4
      cfg.pin_d5  = GPIO_NUM_8;  // G0
      cfg.pin_d6  = GPIO_NUM_20;  // G1
      cfg.pin_d7  = GPIO_NUM_3; // G2
      cfg.pin_d8  = GPIO_NUM_46; // G3
      cfg.pin_d9  = GPIO_NUM_9; // G4
      cfg.pin_d10 = GPIO_NUM_10;  // G5
      cfg.pin_d11 = GPIO_NUM_11; // R0
      cfg.pin_d12 = GPIO_NUM_12; // R1
      cfg.pin_d13 = GPIO_NUM_13; // R2
      cfg.pin_d14 = GPIO_NUM_14; // R3
      cfg.pin_d15 = GPIO_NUM_0; // R4

      cfg.pin_henable = GPIO_NUM_18; // DE
      cfg.pin_vsync   = GPIO_NUM_17;
      cfg.pin_hsync   = GPIO_NUM_16;
      cfg.pin_pclk    = GPIO_NUM_21;
      cfg.freq_write  = 14000000;
      // cfg.freq_write  = 15000000;

      cfg.hsync_polarity    = 1;
      cfg.vsync_polarity    = 1;
      cfg.hsync_front_porch = 10;
      cfg.vsync_front_porch = 10;
      cfg.hsync_pulse_width = 8;
      cfg.vsync_pulse_width = 8;
      cfg.hsync_back_porch  = 50;
      cfg.vsync_back_porch  = 20;
      cfg.pclk_idle_high    = 0;
      cfg.de_idle_high      = 1;
      _bus_instance.config(cfg);
    }
    _panel_instance.setBus(&_bus_instance);

    {
      auto cfg = _light_instance.config();
      cfg.pin_bl = GPIO_NUM_38;
      // cfg.pin_bl = GPIO_NUM_NC;
      _light_instance.config(cfg);
    }
    _panel_instance.light(&_light_instance);

    {
      auto cfg = _touch_instance.config();
      cfg.x_min      = 0;
      cfg.x_max      = 480;
      cfg.y_min      = 0;
      cfg.y_max      = 480;
      cfg.bus_shared = false;
      // cfg.readable = true;
      // cfg.invert = false;
      cfg.offset_rotation = 0;
      // cfg.rgb_order = false;
      // cfg.dlen_16bit = true;

      // cfg.i2c_port   = I2C_NUM_0;
      cfg.i2c_port   = I2C_NUM_1;

      cfg.pin_int    = GPIO_NUM_NC; // -1
      cfg.pin_sda    = GPIO_NUM_19;
      cfg.pin_scl    = GPIO_NUM_45;
      cfg.pin_rst    = GPIO_NUM_NC;

      cfg.freq       = 400000;
      _touch_instance.config(cfg);
      _panel_instance.setTouch(&_touch_instance);
    }

    // {
    //   auto cfg = _light_instance.config();
    //   cfg.pin_bl = GPIO_NUM_44;
    //   _light_instance.config(cfg);
    // }
    // _panel_instance.light(&_light_instance);

    setPanel(&_panel_instance);
  }
};

LGFX gfx;

#if LV_USE_LOG != 0
void my_print(lv_log_level_t level, const char *buf)
{
  LV_UNUSED(level);
  Serial.println(buf);
  Serial.flush();
}
#endif

uint32_t millis_cb(void)
{
  return millis();
}


  void my_disp_flush( lv_display_t *disp, const lv_area_t *area, uint8_t * px_map ) {
    uint32_t w = ( area->x2 - area->x1 + 1 );
    uint32_t h = ( area->y2 - area->y1 + 1 );

    gfx.startWrite();
    gfx.setAddrWindow( area->x1, area->y1, w, h );
    gfx.pushPixelsDMA( ( uint16_t * ) px_map, w * h, true);
    gfx.endWrite();

    lv_disp_flush_ready( disp );
  }

// The picture crumbles into stripes
// void my_disp_flush(lv_display_t* display, const lv_area_t* area, unsigned char* data) {

//   uint32_t w = lv_area_get_width(area);
//   uint32_t h = lv_area_get_height(area);
//   lv_draw_sw_rgb565_swap(data, w*h);
//   if (gfx.getStartCount() == 0) {   // Processing if not yet started
    
//     gfx.startWrite();
//   }
//   gfx.pushImageDMA( area->x1
//                 , area->y1
//                 , area->x2 - area->x1 + 1
//                 , area->y2 - area->y1 + 1
//                 ,(uint16_t*) data); 

//   lv_disp_flush_ready(display);
// }

lv_obj_t *spinner;

void spinner_1() {
  // main_scr = lv_obj_create(NULL);
  // lv_obj_clear_flag(main_scr, LV_OBJ_FLAG_SCROLLABLE);      /// Flags
  // lv_obj_set_pos(main_scr, 0, 0);
  // lv_obj_set_size(main_scr, 480, 480);

  // spinner = lv_spinner_create(main_scr, 1000, 200);
  // lv_obj_set_size(spinner, 240, 240);
  // lv_obj_center(spinner);

  /*Create a spinner*/
  spinner = lv_spinner_create(lv_screen_active());
  lv_obj_set_size(spinner, 380, 380);
  lv_obj_center(spinner);
  lv_spinner_set_anim_params(spinner, 10000, 200);
  
  // lv_disp_load_scr(main_scr);

}

void setup()
{
  Serial.begin(115200);
  // while (!Serial);

  String LVGL_Arduino = "LVGL start";
  LVGL_Arduino += String(" ver-") + lv_version_major() + "." + lv_version_minor() + "." + lv_version_minor();
  Serial.println(LVGL_Arduino);

  // Init Display
  if (!gfx.begin())
  {
    Serial.println("gfx.begin() failed!");
  }

gfx.fillScreen(0x00FF00U); // GREEN color

// INIT display
  lv_init();
  // Serial.println("lv_init");

/*Set a tick source so that LVGL will know how much time elapsed. */
  lv_tick_set_cb(millis_cb);
  
  /* register print function for debugging */
  #if LV_USE_LOG != 0
  lv_log_register_print_cb(my_print);
  #endif

  screenWidth = gfx.width();
  screenHeight = gfx.height();

  drawBufSize = screenWidth * screenHeight;

  disp = lv_display_create(screenWidth, screenHeight);
  lv_display_set_flush_cb(disp, my_disp_flush);

  // static void* buf1 = (lv_color_t*)heap_caps_malloc(drawBufSize, MALLOC_CAP_SPIRAM);
  // static void* buf2 = (lv_color_t*)heap_caps_malloc(drawBufSize, MALLOC_CAP_SPIRAM);
  
  static void* buf1 = (lv_color_t*)heap_caps_malloc(drawBufSize, MALLOC_CAP_DMA);
  static void* buf2 = (lv_color_t*)heap_caps_malloc(drawBufSize, MALLOC_CAP_DMA);

  // static lv_color_t* buf1 = (lv_color_t*)heap_caps_aligned_alloc(32, ((480 * 480) * 2) / 10, MALLOC_CAP_DMA);
  // static lv_color_t* buf2 = (lv_color_t*)heap_caps_aligned_alloc(32, ((480 * 480) * 2) / 10, MALLOC_CAP_DMA);

  // lv_display_set_3rd_draw_buffer(disp, buf3);
  
  // lv_display_set_color_format(disp, LV_COLOR_FORMAT_NATIVE);

  // lv_display_set_buffers(disp, buf1, NULL, sizeof(buf1), LV_DISPLAY_RENDER_MODE_PARTIAL);
  lv_display_set_buffers(disp, buf1, buf2, drawBufSize, LV_DISPLAY_RENDER_MODE_PARTIAL);
  // lv_display_set_buffers(disp, buf1, NULL, drawBufSize, LV_DISPLAY_RENDER_MODE_PARTIAL);
  // lv_display_set_buffers(disp, buf1, NULL, drawBufSize, LV_DISPLAY_RENDER_MODE_DIRECT);
  // lv_display_set_buffers(disp, buf1, buf2, drawBufSize, LV_DISPLAY_RENDER_MODE_DIRECT);
  // lv_display_set_buffers(disp, buf1, buf2, drawBufSize, LV_DISPLAY_RENDER_MODE_FULL);

spinner_1();

  lv_obj_t *label = lv_label_create(lv_scr_act());
  lv_label_set_text(label, "LovyanGFX version: 1.2.7");
  lv_obj_align(label, LV_ALIGN_TOP_MID, 0, 10);
  // lv_obj_align(label, LV_ALIGN_CENTER, 0, 10);
  lv_obj_set_style_text_color(label, lv_color_hex(0xFF0000), 0);
  lv_obj_set_style_text_font(label, &lv_font_montserrat_22, 0);

} // SETUP

void loop()
{

  lv_timer_handler(); /* let the GUI do its work */
  delay(5);
  // vTaskDelay(pdMS_TO_TICKS(2));
  // vTaskDelay(5 / portTICK_PERIOD_MS);

} // LOOP

There are many commented sections in the code, I tried to find the optimal buffer size and tried to use DMA, but I did not notice any significant difference from using

MALLOC_CAP_SPIRAM

or

MALLOC_CAP_DMA

Similar confusion as in the topic

#665

[brightproject]

Small addition:
Changed the parameter

// uint32_t freq = 1200; // Squeak of throttles
uint32_t freq = 200;

LovyanGFX/src/lgfx/v1/platforms/esp32/Light_PWM.hpp

Line 33 in 5438181

uint32_t freq = 1200;

Also, I haven't been able to get the touch sensor to work yet.
For the library I used the file touch.h

/*******************************************************************************
 * Touch libraries:
 * FT6X36: https://github.com/strange-v/FT6X36.git
 * GT911: https://github.com/TAMCTec/gt911-arduino.git
 * XPT2046: https://github.com/PaulStoffregen/XPT2046_Touchscreen.git
 ******************************************************************************/

/* uncomment for FT6X36 */
// #define TOUCH_FT6X36
// #define TOUCH_FT6X36_SCL 19
// #define TOUCH_FT6X36_SDA 18
// #define TOUCH_FT6X36_INT 39
// #define TOUCH_SWAP_XY
// #define TOUCH_MAP_X1 480
// #define TOUCH_MAP_X2 0
// #define TOUCH_MAP_Y1 0
// #define TOUCH_MAP_Y2 320

/* uncomment for GT911 */
#define TOUCH_GT911
#define TOUCH_GT911_SCL 45
#define TOUCH_GT911_SDA 19
#define TOUCH_GT911_INT -1
#define TOUCH_GT911_RST -1
#define TOUCH_GT911_ROTATION ROTATION_NORMAL
#define TOUCH_MAP_X1 480
#define TOUCH_MAP_X2 0
#define TOUCH_MAP_Y1 480
#define TOUCH_MAP_Y2 0

/* uncomment for XPT2046 */
// #define TOUCH_XPT2046
// #define TOUCH_XPT2046_SCK 12
// #define TOUCH_XPT2046_MISO 13
// #define TOUCH_XPT2046_MOSI 11
// #define TOUCH_XPT2046_CS 10
// #define TOUCH_XPT2046_INT 18
// #define TOUCH_XPT2046_ROTATION 0
// #define TOUCH_MAP_X1 4000
// #define TOUCH_MAP_X2 100
// #define TOUCH_MAP_Y1 100
// #define TOUCH_MAP_Y2 4000

int touch_last_x = 0, touch_last_y = 0;

#if defined(TOUCH_FT6X36)
#include <Wire.h>
#include <FT6X36.h>
FT6X36 ts(&Wire, TOUCH_FT6X36_INT);
bool touch_touched_flag = true, touch_released_flag = true;

#elif defined(TOUCH_GT911)
#include <Wire.h>
// #include <TAMC_GT911.h>
#include <Touch_GT911.h>
// TAMC_GT911 ts = TAMC_GT911(TOUCH_GT911_SDA, TOUCH_GT911_SCL, TOUCH_GT911_INT, TOUCH_GT911_RST, max(TOUCH_MAP_X1, TOUCH_MAP_X2), max(TOUCH_MAP_Y1, TOUCH_MAP_Y2));
Touch_GT911 ts = Touch_GT911(TOUCH_GT911_SDA, TOUCH_GT911_SCL, TOUCH_GT911_INT, TOUCH_GT911_RST, max(TOUCH_MAP_X1, TOUCH_MAP_X2), max(TOUCH_MAP_Y1, TOUCH_MAP_Y2));

#elif defined(TOUCH_XPT2046)
#include <XPT2046_Touchscreen.h>
#include <SPI.h>
XPT2046_Touchscreen ts(TOUCH_XPT2046_CS, TOUCH_XPT2046_INT);

#endif

#if defined(TOUCH_FT6X36)
void touch(TPoint p, TEvent e)
{
  if (e != TEvent::Tap && e != TEvent::DragStart && e != TEvent::DragMove && e != TEvent::DragEnd)
  {
    return;
  }
  // translation logic depends on screen rotation
#if defined(TOUCH_SWAP_XY)
  touch_last_x = map(p.y, TOUCH_MAP_X1, TOUCH_MAP_X2, 0, gfx->width());
  touch_last_y = map(p.x, TOUCH_MAP_Y1, TOUCH_MAP_Y2, 0, gfx->height());
#else
  touch_last_x = map(p.x, TOUCH_MAP_X1, TOUCH_MAP_X2, 0, gfx->width());
  touch_last_y = map(p.y, TOUCH_MAP_Y1, TOUCH_MAP_Y2, 0, gfx->height());
#endif
  switch (e)
  {
  case TEvent::Tap:
    Serial.println("Tap");
    touch_touched_flag = true;
    touch_released_flag = true;
    break;
  case TEvent::DragStart:
    Serial.println("DragStart");
    touch_touched_flag = true;
    break;
  case TEvent::DragMove:
    Serial.println("DragMove");
    touch_touched_flag = true;
    break;
  case TEvent::DragEnd:
    Serial.println("DragEnd");
    touch_released_flag = true;
    break;
  default:
    Serial.println("UNKNOWN");
    break;
  }
}
#endif

void touch_init()
{
#if defined(TOUCH_FT6X36)
  Wire.begin(TOUCH_FT6X36_SDA, TOUCH_FT6X36_SCL);
  ts.begin();
  ts.registerTouchHandler(touch);

#elif defined(TOUCH_GT911)
  Wire.begin(TOUCH_GT911_SDA, TOUCH_GT911_SCL);
  ts.begin();
  ts.setRotation(TOUCH_GT911_ROTATION);

#elif defined(TOUCH_XPT2046)
  SPI.begin(TOUCH_XPT2046_SCK, TOUCH_XPT2046_MISO, TOUCH_XPT2046_MOSI, TOUCH_XPT2046_CS);
  ts.begin();
  ts.setRotation(TOUCH_XPT2046_ROTATION);

#endif
}

bool touch_has_signal()
{
#if defined(TOUCH_FT6X36)
  ts.loop();
  return touch_touched_flag || touch_released_flag;

#elif defined(TOUCH_GT911)
  return true;

#elif defined(TOUCH_XPT2046)
  return ts.tirqTouched();

#else
  return false;
#endif
}

bool touch_touched()
{
#if defined(TOUCH_FT6X36)
  if (touch_touched_flag)
  {
    touch_touched_flag = false;
    return true;
  }
  else
  {
    return false;
  }

#elif defined(TOUCH_GT911)
  ts.read();
  if (ts.isTouched)
  {
#if defined(TOUCH_SWAP_XY)
    touch_last_x = map(ts.points[0].y, TOUCH_MAP_X1, TOUCH_MAP_X2, 0, gfx->width() - 1);
    touch_last_y = map(ts.points[0].x, TOUCH_MAP_Y1, TOUCH_MAP_Y2, 0, gfx->height() - 1);
#else
    touch_last_x = map(ts.points[0].x, TOUCH_MAP_X1, TOUCH_MAP_X2, 0, gfx->width() - 1);
    touch_last_y = map(ts.points[0].y, TOUCH_MAP_Y1, TOUCH_MAP_Y2, 0, gfx->height() - 1);
#endif
    return true;
  }
  else
  {
    return false;
  }

#elif defined(TOUCH_XPT2046)
  if (ts.touched())
  {
    TS_Point p = ts.getPoint();
#if defined(TOUCH_SWAP_XY)
    touch_last_x = map(p.y, TOUCH_MAP_X1, TOUCH_MAP_X2, 0, gfx->width() - 1);
    touch_last_y = map(p.x, TOUCH_MAP_Y1, TOUCH_MAP_Y2, 0, gfx->height() - 1);
#else
    touch_last_x = map(p.x, TOUCH_MAP_X1, TOUCH_MAP_X2, 0, gfx->width() - 1);
    touch_last_y = map(p.y, TOUCH_MAP_Y1, TOUCH_MAP_Y2, 0, gfx->height() - 1);
#endif
    return true;
  }
  else
  {
    return false;
  }

#else
  return false;
#endif
}

bool touch_released()
{
#if defined(TOUCH_FT6X36)
  if (touch_released_flag)
  {
    touch_released_flag = false;
    return true;
  }
  else
  {
    return false;
  }

#elif defined(TOUCH_GT911)
  return true;

#elif defined(TOUCH_XPT2046)
  return true;

#else
  return false;
#endif
}

I would also like to discuss in this discussion the acceleration of graphics on this device, using DMA and freeRTOS for LVGL.