User_Setup.h for ESP32-8048DS070 (ESP32-S3-WROOM-1, parallel 16 bits)

[TLaren]

I had LVGL working with this display but after awhile of not working on it and then getting an update to LVGL it no longer works.
In my searches I see references to people using TFT_eSPI and having it work. I have asked but I get no reply when asking for information.
The screen uses ILI9341 and touch uses GT911.
If I can get the correct syntax for the file and I have a few pins wrong I can correct it but right now with my attempts I either can't compile or get a crash at tft.init().
I have tried adding 16 data pins but when I enable TFT_PARALLEL_16_BIT I can't compile (RP2040 only)
Here is the pins from LVGL for the screen and touch that I have collected (and worked at one time).

  auto cfg = _bus_instance.config();
  cfg.panel = &_panel_instance;
  cfg.pin_d0  = GPIO_NUM_15;  // B0 *
  cfg.pin_d1  = GPIO_NUM_7;   // B1 *
  cfg.pin_d2  = GPIO_NUM_6;   // B2 *
  cfg.pin_d3  = GPIO_NUM_5;   // B3 *
  cfg.pin_d4  = GPIO_NUM_4;   // B4 *
  cfg.pin_d5  = GPIO_NUM_9;   // G0 *
  cfg.pin_d6  = GPIO_NUM_46;  // G1 *
  cfg.pin_d7  = GPIO_NUM_3;   // G2 *
  cfg.pin_d8  = GPIO_NUM_8;   // G3 *
  cfg.pin_d9  = GPIO_NUM_16;  // G4 *
  cfg.pin_d10 = GPIO_NUM_1;   // G5 *
  cfg.pin_d11 = GPIO_NUM_14;  // R0 *
  cfg.pin_d12 = GPIO_NUM_21;  // R1 *
  cfg.pin_d13 = GPIO_NUM_47;  // R2 *
  cfg.pin_d14 = GPIO_NUM_48;  // R3 *
  cfg.pin_d15 = GPIO_NUM_45;  // R4 *

  cfg.pin_henable = GPIO_NUM_41; // DE *
  cfg.pin_vsync   = GPIO_NUM_40; // *
  cfg.pin_hsync   = GPIO_NUM_39; // *
  cfg.pin_pclk    = GPIO_NUM_42; // *
  cfg.freq_write  = 14000000;  //14000000
  cfg.hsync_polarity    = 0;   // 0
  cfg.hsync_front_porch = 80;  //80, 210
  cfg.hsync_pulse_width = 4;   // 4, 30
  cfg.hsync_back_porch  = 16;  //16
  cfg.vsync_polarity    = 0;   // 0
  cfg.vsync_front_porch = 22;  //22
  cfg.vsync_pulse_width = 13;  // 4
  cfg.vsync_back_porch  = 10;  // 4
  cfg.pclk_idle_high    = 1;   // 1
  _bus_instance.config(cfg);
  _panel_instance.setBus(&_bus_instance);
}
{
  auto cfg = _light_instance.config();
  cfg.pin_bl = GPIO_NUM_2;
  _light_instance.config(cfg);
  _panel_instance.light(&_light_instance);
}
{
  auto cfg = _touch_instance.config();
  cfg.x_min      = 0;
  cfg.x_max      = 800;
  cfg.y_min      = 0;
  cfg.y_max      = 480;
  cfg.pin_int    = GPIO_NUM_NC;
  cfg.bus_shared = false;
  cfg.offset_rotation = 0;
  // I2C接続
  cfg.i2c_port   = I2C_NUM_1;
  cfg.pin_sda    = GPIO_NUM_19;
  cfg.pin_scl    = GPIO_NUM_20;
  cfg.pin_rst    = GPIO_NUM_38;
  cfg.freq       = 400000;
  cfg.i2c_addr   = 0x14;        // 0x5D , 0x14
  _touch_instance.config(cfg);
  _panel_instance.setTouch(&_touch_instance);
}

I did search here, the only post was about a year ago and it didn't seem to really have an answer if it can be done or not.
Now that the ESP32-S3 is available and getting popular I figured there may be more interest and maybe the library now supports this configuration.
Thanks in advance.

[TangerineDreamer]

Thank you,worked for me,be blessed :)

[TLaren]

How did it work for you?
This is a question, how to create the User_Setup.h file.
This is the settings for the module but I still do not know how to add all the necessary parameters to the .h file.
How to you specify TFT_PARALLEL_16_BIT?

If it works, can you supply your User_Setup.h file here?

[TangerineDreamer]

Hey TLaren,

I don't use directly TFT_e_SPI,but a kind of wrapper coming from an lovyangfx example : "TFT_graphicstest_PDQ.ino"

You use first your own setup in the beginning of your sketch : #include "ESP32S3_RGB_8048S070.h"
Then the wrapper: #include <LGFX_TFT_eSPI.hpp>
And then the constructor or so : static TFT_eSPI tft;

That's all!!

I give you my sketch for a touch test sketch

First the sketch.ino:

#include "ESP32S3-8048S070.h"
#include <LGFX_TFT_eSPI.hpp>
static TFT_eSPI tft;
#include "touch.h"

 void setup() {
  Serial.begin(115200);
  tft.begin();
    tft.fillScreen(TFT_BLACK);

/*
#ifdef TFT_BL                                     //  -> comes from arduino gfx setup,but not needed
    pinMode(TFT_BL, OUTPUT);
    digitalWrite(TFT_BL, HIGH);
#endif
*/

tft.fillRect(0, 0, 240, 320,TFT_BLUE);
ts.reset();
ts.begin();
  ts.setRotation(ROTATION_NORMAL);
}

void loop() {
  ts.read();
  if (ts.isTouched){
    for (int i=0; i<ts.touches; i++){
      Serial.print("Touch ");Serial.print(i+1);Serial.print(": ");;
      Serial.print("  x: ");Serial.print(ts.points[i].x);
      Serial.print("  y: ");Serial.print(ts.points[i].y);
      Serial.print("  size: ");Serial.println(ts.points[i].size);
      Serial.println(' ');
    }
  }
}

Then the setup you gave us ESP32S3_RGB_8048S070.h :

#include "hal/gpio_types.h"

#define LGFX_USE_V1
#include <LovyanGFX.hpp>

#include <lgfx/v1/platforms/esp32s3/Panel_RGB.hpp>
#include <lgfx/v1/platforms/esp32s3/Bus_RGB.hpp>

#include <driver/i2c.h>

class LGFX : public lgfx::LGFX_Device
{
public:

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

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

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

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

      _panel_instance.config(cfg);
    }

    {
      auto cfg = _panel_instance.config_detail();

      cfg.use_psram = 1;

      _panel_instance.config_detail(cfg);
    }

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

      cfg.pin_henable = GPIO_NUM_41;
      cfg.pin_vsync   = GPIO_NUM_40;
      cfg.pin_hsync   = GPIO_NUM_39;
      cfg.pin_pclk    = GPIO_NUM_42;
      cfg.freq_write  = 14000000;

      cfg.hsync_polarity    = 0;
      cfg.hsync_front_porch = 80;
      cfg.hsync_pulse_width = 4;
      cfg.hsync_back_porch  = 16;
      cfg.vsync_polarity    = 0;
      cfg.vsync_front_porch = 22;
      cfg.vsync_pulse_width = 13;
      cfg.vsync_back_porch  = 10;
      cfg.pclk_idle_high    = 1;
      _bus_instance.config(cfg);
    }
    _panel_instance.setBus(&_bus_instance);

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

    {
      auto cfg = _touch_instance.config();
      cfg.x_min      = 0;
      cfg.x_max      = 800;
      cfg.y_min      = 0;
      cfg.y_max      = 480;
      cfg.pin_int    = GPIO_NUM_NC;
      cfg.bus_shared = false;
      cfg.offset_rotation = 1;
      // I2C接続
      cfg.i2c_port   = I2C_NUM_1;
      cfg.pin_sda    = GPIO_NUM_19;
      cfg.pin_scl    = GPIO_NUM_20;
      cfg.pin_rst    = GPIO_NUM_38;
      cfg.freq       = 400000;
      cfg.i2c_addr   = 0x14;        // 0x5D , 0x14
      _touch_instance.config(cfg);
      _panel_instance.setTouch(&_touch_instance);
    }

    setPanel(&_panel_instance);
  }
};

Then the 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 20
 #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 800
 #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 38
// #define TOUCH_XPT2046_INT 18
// #define TOUCH_XPT2046_ROTATION 0
// #define TOUCH_MAP_X1 4000//4000
// #define TOUCH_MAP_X2 100 //100
// #define TOUCH_MAP_Y1 100//100
// #define TOUCH_MAP_Y2 4000//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>
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));

#elif defined(TOUCH_XPT2046)
#include <XPT2046_Touchscreen.h>
#include <SPI.h>
XPT2046_Touchscreen ts(TOUCH_XPT2046_CS, TOUCH_XPT2046_INT);
//T2046_Touchscreen ts(TOUCH_XPT2046_CS);  // Param 2 - NULL - No interrupts 



#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, tft.width());
  touch_last_y = map(p.x, TOUCH_MAP_Y1, TOUCH_MAP_Y2, 0, tft.height());
#else
  touch_last_x = map(p.x, TOUCH_MAP_X1, TOUCH_MAP_X2, 0, tft.width());
  touch_last_y = map(p.y, TOUCH_MAP_Y1, TOUCH_MAP_Y2, 0, tft.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, tft.width() - 1);
    touch_last_y = map(ts.points[0].x, TOUCH_MAP_Y1, TOUCH_MAP_Y2, 0, tft.height() - 1);
#else
    touch_last_x = map(ts.points[0].x, TOUCH_MAP_X1, TOUCH_MAP_X2, 0, tft.width() - 1);
    touch_last_y = map(ts.points[0].y, TOUCH_MAP_Y1, TOUCH_MAP_Y2, 0, tft.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, tft.width() - 1);
    touch_last_y = map(p.x, TOUCH_MAP_Y1, TOUCH_MAP_Y2, 0, tft.height() - 1);
#else
    touch_last_x = map(p.x, TOUCH_MAP_X1, TOUCH_MAP_X2, 0, tft.width() - 1);
    touch_last_y = map(p.y, TOUCH_MAP_Y1, TOUCH_MAP_Y2, 0, tft.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
}