WT32 SC01 PLUS - ESP32 S3 8bits Parallel - Candidate for User Setup

[TangerineDreamer]

Here's another one interesting that works good with lovyang GFX,but missing in the TFT_e_SPI setups,
the WT32 SC 01 is ESP32 but the WT32 SC 01 PLUS (8 bits parallel) is ESP32 S3.

Here is the lovyang GFX settings i use in every example from LovyanGFX :
https://github.com/lovyan03/LovyanGFX

//----------------------------------------------------

#define LGFX_USE_V1 // set to use new version of library
#include <LovyanGFX.hpp> // main library

class LGFX : public lgfx::LGFX_Device
{

lgfx::Panel_ST7796 _panel_instance; // ST7796UI
lgfx::Bus_Parallel8 _bus_instance; // MCU8080 8B
lgfx::Light_PWM _light_instance;
lgfx::Touch_FT5x06 _touch_instance;

public:
LGFX(void)
{
{
auto cfg = _bus_instance.config();
cfg.freq_write = 20000000;
cfg.pin_wr = 47;
cfg.pin_rd = -1;
cfg.pin_rs = 0;

  // LCD data interface, 8bit MCU (8080)
  cfg.pin_d0 = 9;              
  cfg.pin_d1 = 46;             
  cfg.pin_d2 = 3;              
  cfg.pin_d3 = 8;              
  cfg.pin_d4 = 18;             
  cfg.pin_d5 = 17;             
  cfg.pin_d6 = 16;             
  cfg.pin_d7 = 15;             

  _bus_instance.config(cfg);   
  _panel_instance.setBus(&_bus_instance);      
}

{ 
  auto cfg = _panel_instance.config();    

  cfg.pin_cs           =    -1;  
  cfg.pin_rst          =    4;  
  cfg.pin_busy         =    -1; 

  cfg.panel_width      =   320;
  cfg.panel_height     =   480;
  cfg.offset_x         =     0;
  cfg.offset_y         =     0;
  cfg.offset_rotation  =     0;
  cfg.dummy_read_pixel =     8;
  cfg.dummy_read_bits  =     1;
  cfg.readable         =  true;
  cfg.invert           = true;
  cfg.rgb_order        = false;
  cfg.dlen_16bit       = false;
  cfg.bus_shared       =  true;

  _panel_instance.config(cfg);
}

{
  auto cfg = _light_instance.config();    

  cfg.pin_bl = 45;              
  cfg.invert = false;           
  cfg.freq   = 44100;           
  cfg.pwm_channel = 7;          

  _light_instance.config(cfg);
  _panel_instance.setLight(&_light_instance);  
}

{ 
  auto cfg = _touch_instance.config();

  cfg.x_min      = 0;
  cfg.x_max      = 319;
  cfg.y_min      = 0;  
  cfg.y_max      = 479;
  cfg.pin_int    = 7;  
  cfg.bus_shared = true; 
  cfg.offset_rotation = 0;

  cfg.i2c_port = 1;
  cfg.i2c_addr = 0x38;
  cfg.pin_sda  = 6;   
  cfg.pin_scl  = 5;   
  cfg.freq = 400000;  

  _touch_instance.config(cfg);
  _panel_instance.setTouch(&_touch_instance);  
}
setPanel(&_panel_instance); 

}
};

static LGFX lcd; // declare display variable

//---------------------------------------------------------

Hey bodmer can you do an adaptation for TFT_e_SPI?

[elgerg]

I'd also like to +1 on this as I have one of the Plus screens, I dont really like having to use 2 different libs depending on if I am writing for the normal and plus screens..

However see previous comment here
#2078

[TangerineDreamer]

Hi,elgerb,
You're right,i didn't look at this this discussion,but funny because lovyang gfx is an adaptation of tft_espi,a new kind of homecoming
if bodmer adapt it back,but the lovyang gfx examples are great.
Can you comfirm it's impossible to have the arduino monitor working with the simple usb-C plug because no TX out on it?

[elgerg]

I can confirm serial output (serial.println if thats what you mean?) does work.

If memory serves me right you need to set the correct options though

NB the above is from my config using another ESP32 S3 so might be slightly off.. Either way it wont flash unless you change it from UART0. Hope that helps.

[TangerineDreamer]

I don't have serial.print...working on my monitor so i will try your tip :),i thought is was only on the debug pins.
I'm thinking also that i put the lovyang gfx settings in a : include "SC01_PLUS_CONFIG.h" on top of my sketches
and that's works fine in all examples,why couldn't we do the same with tft_e_spi?

[Miso72]

Hallo
I try this configuration for WT32-SC01+
////////////////////////////////////////////////////
// Setup for WT32-SC01+ with ST7796UI display //
////////////////////////////////////////////////////
#define USER_SETUP_ID 31

// See SetupX_Template.h for all options available

// Define STM32 to invoke optimised processor support
//#define ESP32
#define ESP32_S3

// Tell the library to use 8 bit parallel mode(otherwise SPI is assumed)
#define TFT_PARALLEL_8_BIT

// Define the display driver chip type
#define ST7796_DRIVER
//#define ILI9481_DRIVER

// Define the Nucleo 64/144 pins used for the parallel interface TFT
// The pins can be changed here but these are the ones used by the
// common "MCUfriend" shields
#define TFT_BL 45 // LED back-light control pin
#define TFT_BACKLIGHT_ON HIGH // Level to turn ON back-light (HIGH or LOW)

#define TFT_CS -1 // Chip select control pin
#define TFT_DC 0 // Data Command control pin
#define TFT_RST 4 // Reset pin

#define TFT_WR 47 // Write strobe control pin
#define TFT_RD -1 // Read pin
//LCD_TE | GPIO 48 | Frame sync

#define TFT_D0 9 // 8 bit parallel bus to TFT
#define TFT_D1 46
#define TFT_D2 3
#define TFT_D3 8
#define TFT_D4 18
#define TFT_D5 17
#define TFT_D6 16
#define TFT_D7 15
/*
TP_INT | GPIO 7 | Touch interrupt
TP_SDA | GPIO 6 | Touch IIC data
TP_SCL | GPIO 5 | Touch IIC clock
TP_RST | GPIO 4 | Touch reset, multiplexed with LCD reset
*/
//#define TOUCH_CS -1 // Chip select pin (T_CS) of touch screen

// Fonts to be available
#define LOAD_GLCD // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH
#define LOAD_FONT2 // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters
#define LOAD_FONT4 // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters
#define LOAD_FONT6 // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm
#define LOAD_FONT7 // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:.
#define LOAD_FONT8 // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-.
#define LOAD_GFXFF // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts

// STM32 support for smooth fonts via program memory (FLASH) arrays
#define SMOOTH_FONT

but only the backlight gos on.

[Bodmer]

See #2078

[dkalliv]

Hi TangerineDreamer, I have added support for the WT32-SC01 Plus module and created a pull request (3423). While it is being reviewed you can give it a spin using my fork.

[TangerineDreamer]

Hi,dkalliv
You've made a great job!
it strange you use 14 for the D1 pin,instead of LovyanGFX and ArduinoGFX wich use 46, i thought it was universal settings.
Not yet ready for the touch? (edit,my bad that's FT5x06 with I2C control)
Is it possible to integrate the214 setup and FT5x06 with I2C control inside the sketch?
Thanks to you :)

[dkalliv]

Well actually I'm using GPIO46 as well. In an attempt to keep things as efficient as possible I "virtually" sacrificed GPIO14 which is on the exact same spot on the lower register. This way it is just a matter of using a bit-mask to do the rest. Obviously any other free pin could have been used, but I kind of liked the coincidence that GPIO14 was available ;-)

The touch panel actually works fine with a patched version of Adafruit_FT6206_Library. The main problem is the vendor or chip ID the touch controller reports. My fix is a bit crude (disabling the check altogether), but at some point I will do this properly and submit a pull request. For the time being you can find my fork here

[TangerineDreamer]

Have you seen on mooonourstation,there is a WT32 SC01 PLUS configuration posted,with a touch.h in the sketch
edit:
moononournation/Arduino_GFX#495

[dkalliv]

I opted for the Adafruit library because in my specific use case I am not using LVGL and TFT_eSPI only provides native touch support for XPT2046 based touch panels. I'm not sure if Bodmer wants to integrate support for other touch drivers into the TFT_eSPI (as far as I understand, support for XPT2046 will eventually be removed)...

Just to avoid confusion: even with LVGL you will need a touch driver, but you will access touch data through a wrapper function...

[TangerineDreamer]

Hi, dkalliv,
i'm not using LVGL,too complicated for me,
As i see the bodmer's keypad example and the marvellous button constructor "TFT_eSPI_Button key[];"
is there a possibility to wrap it for the XPT2046 and make this keypad example possible for WT32 SC01 PLUS?

[dkalliv]

TFT_eSPI_Button_key is not used for reading the touch panel (this would be tft.getTouch() ). Here is a basic adaptation of the keypad example for the WT32-SC01-Plus using the patched Adafruit FT6206 library referenced in my earlier post:

/*
  The TFT_eSPI library incorporates an Adafruit_GFX compatible
  button handling class, this sketch is based on the Arduin-o-phone
  example.

  This example displays a keypad where numbers can be entered and
  sent to the Serial Monitor window.

  The sketch has been tested on the ESP8266 (which supports SPIFFS)

  The minimum screen size is 320 x 240 as that is the keypad size.

  TOUCH_CS and SPI_TOUCH_FREQUENCY must be defined in the User_Setup.h file
  for the touch functions to do anything.
*/

#include <SPI.h>
#include <TFT_eSPI.h>  // Hardware-specific library
#include <Adafruit_FT6206.h>
#include <Wire.h>

TFT_eSPI tft = TFT_eSPI();  // Invoke custom library
Adafruit_FT6206 ts = Adafruit_FT6206();

// This is the file name used to store the calibration data
// You can change this to create new calibration files.
// The SPIFFS file name must start with "/".
#define CALIBRATION_FILE "/TouchCalData2"

// Set REPEAT_CAL to true instead of false to run calibration
// again, otherwise it will only be done once.
// Repeat calibration if you change the screen rotation.
#define REPEAT_CAL false

// Keypad start position, key sizes and spacing
#define KEY_X 40  // Centre of key
#define KEY_Y 96
#define KEY_W 62  // Width and height
#define KEY_H 30
#define KEY_SPACING_X 18  // X and Y gap
#define KEY_SPACING_Y 20
#define KEY_TEXTSIZE 1  // Font size multiplier

// Using two fonts since numbers are nice when bold
#define LABEL1_FONT &FreeSansOblique12pt7b  // Key label font 1
#define LABEL2_FONT &FreeSansBold12pt7b     // Key label font 2

// Numeric display box size and location
#define DISP_X 1
#define DISP_Y 10
#define DISP_W 238
#define DISP_H 50
#define DISP_TSIZE 3
#define DISP_TCOLOR TFT_CYAN

// Number length, buffer for storing it and character index
#define NUM_LEN 12
char numberBuffer[NUM_LEN + 1] = "";
uint8_t numberIndex = 0;

// We have a status line for messages
#define STATUS_X 120  // Centred on this
#define STATUS_Y 65

// Create 15 keys for the keypad
char keyLabel[15][5] = { "New", "Del", "Send", "1", "2", "3", "4", "5", "6", "7", "8", "9", ".", "0", "#" };
uint16_t keyColor[15] = { TFT_RED, TFT_DARKGREY, TFT_DARKGREEN,
                          TFT_BLUE, TFT_BLUE, TFT_BLUE,
                          TFT_BLUE, TFT_BLUE, TFT_BLUE,
                          TFT_BLUE, TFT_BLUE, TFT_BLUE,
                          TFT_BLUE, TFT_BLUE, TFT_BLUE };

// Invoke the TFT_eSPI button class and create all the button objects
TFT_eSPI_Button key[15];

//------------------------------------------------------------------------------------------

void setup() {
  // Use serial port
  Serial.begin(9600);
  Wire.begin(6,5);
  ts.begin(100);
  // Initialise the TFT screen
  tft.init();

  // Set the rotation before we calibrate
  tft.setRotation(1);

  // Clear the screen
  tft.fillScreen(TFT_BLACK);

  // Draw keypad background
  tft.fillRect(0, 0, 240, 320, TFT_DARKGREY);

  // Draw number display area and frame
  tft.fillRect(DISP_X, DISP_Y, DISP_W, DISP_H, TFT_BLACK);
  tft.drawRect(DISP_X, DISP_Y, DISP_W, DISP_H, TFT_WHITE);

  // Draw keypad
  drawKeypad();
}

//------------------------------------------------------------------------------------------

void loop(void) {
  uint16_t t_x = 0, t_y = 0;  // To store the touch coordinates

  // Pressed will be set true is there is a valid touch on the screen
  bool pressed;
  if (ts.touched()) {
    // Retrieve a point
    TS_Point p = ts.getPoint();
    // rotate coordinate system
    // flip it around to match the screen.
    t_y = map(p.x, 0, 320, 320, 0);
    t_x = map(p.y, 0, 480, 0, 480);
    pressed = true;
  }

  // / Check if any key coordinate boxes contain the touch coordinates
  for (uint8_t b = 0; b < 15; b++) {
    if (pressed && key[b].contains(t_x, t_y)) {
      key[b].press(true);  // tell the button it is pressed
    } else {
      key[b].press(false);  // tell the button it is NOT pressed
    }
  }

  // Check if any key has changed state
  for (uint8_t b = 0; b < 15; b++) {

    if (b < 3) tft.setFreeFont(LABEL1_FONT);
    else tft.setFreeFont(LABEL2_FONT);

    if (key[b].justReleased()) key[b].drawButton();  // draw normal

    if (key[b].justPressed()) {
      key[b].drawButton(true);  // draw invert

      // if a numberpad button, append the relevant # to the numberBuffer
      if (b >= 3) {
        if (numberIndex < NUM_LEN) {
          numberBuffer[numberIndex] = keyLabel[b][0];
          numberIndex++;
          numberBuffer[numberIndex] = 0;  // zero terminate
        }
        status("");  // Clear the old status
      }

      // Del button, so delete last char
      if (b == 1) {
        numberBuffer[numberIndex] = 0;
        if (numberIndex > 0) {
          numberIndex--;
          numberBuffer[numberIndex] = 0;  //' ';
        }
        status("");  // Clear the old status
      }

      if (b == 2) {
        status("Sent value to serial port");
        Serial.println(numberBuffer);
      }
      // we dont really check that the text field makes sense
      // just try to call
      if (b == 0) {
        status("Value cleared");
        numberIndex = 0;                // Reset index to 0
        numberBuffer[numberIndex] = 0;  // Place null in buffer
      }

      // Update the number display field
      tft.setTextDatum(TL_DATUM);        // Use top left corner as text coord datum
      tft.setFreeFont(&FreeSans18pt7b);  // Choose a nice font that fits box
      tft.setTextColor(DISP_TCOLOR);     // Set the font colour

      // Draw the string, the value returned is the width in pixels
      int xwidth = tft.drawString(numberBuffer, DISP_X + 4, DISP_Y + 12);

      // Now cover up the rest of the line up by drawing a black rectangle.  No flicker this way
      // but it will not work with italic or oblique fonts due to character overlap.
      tft.fillRect(DISP_X + 4 + xwidth, DISP_Y + 1, DISP_W - xwidth - 5, DISP_H - 2, TFT_BLACK);

      delay(10);  // UI debouncing
    }
  }
}

//------------------------------------------------------------------------------------------

void drawKeypad() {
  // Draw the keys
  for (uint8_t row = 0; row < 5; row++) {
    for (uint8_t col = 0; col < 3; col++) {
      uint8_t b = col + row * 3;

      if (b < 3) tft.setFreeFont(LABEL1_FONT);
      else tft.setFreeFont(LABEL2_FONT);

      key[b].initButton(&tft, KEY_X + col * (KEY_W + KEY_SPACING_X),
                        KEY_Y + row * (KEY_H + KEY_SPACING_Y),  // x, y, w, h, outline, fill, text
                        KEY_W, KEY_H, TFT_WHITE, keyColor[b], TFT_WHITE,
                        keyLabel[b], KEY_TEXTSIZE);
      key[b].drawButton();
    }
  }
}


// Print something in the mini status bar
void status(const char *msg) {
  tft.setTextPadding(240);
  //tft.setCursor(STATUS_X, STATUS_Y);
  tft.setTextColor(TFT_WHITE, TFT_DARKGREY);
  tft.setTextFont(0);
  tft.setTextDatum(TC_DATUM);
  tft.setTextSize(1);
  tft.drawString(msg, STATUS_X, STATUS_Y);
}

//------------------------------------------------------------------------------------------
``

[TangerineDreamer]

Hello dkalliv,
Thank you very much,it worked the first time,good job :)
It seems that the calibration is not necessary with FT6206,maybe i'm wrong,is it safe to take it off the sketch?

[dkalliv]

Hi TangerineDreamer,
Capacitive touch panels don't require the kind of calibration that resistive touch panels do. This is why I removed the corresponding code from the example.

[TangerineDreamer]

Ok,i didn't know that
thank you again!

[TangerineDreamer]

Hi again dkalliv,
maybe you can help me with this:
i'm searching all the net to get an adaptation of the keypad sketch from bodmer with tft_espi,but
for RA8875 and FT6206,and without using the tft_espi library, i know arduino_GFX has a button stuff and it's possible to do it,
i have a problem with the term "key[b]" to determine wich button "b" is touched,i don't know where it comes from.
I'm on teensy and i use a buy display 7" SPI 4 wires.

[TangerineDreamer]

Ok,I've found some more clearance with using : Adafruit_GFX_Button key[15];
but i'm facing an error that stops me:

no matching function for call to 'Adafruit_GFX_Button::initButton(RA8875*, int, int, int, int, const uint16_t&, uint16_t&, const uint16_t&, char [5], int)'

My full sketch adapted to RA8875 and FT6206:

#include <SPI.h>
#include <Wire.h>  
#include "Adafruit_GFX.h"
#include <SD.h>
#include <SerialFlash.h>
#include <RA8875.h>
#include <Adafruit_FT6206.h>



// The FT6206 uses hardware I2C1 (SCL 17/SDA 16)
Adafruit_FT6206 ts = Adafruit_FT6206();


#define RA8875_CS         36 
#define RA8875_RESET      255                 
#define RA8875_INT        41//22



RA8875 tft = RA8875(RA8875_CS, RA8875_RESET);

boolean wastouched = true;


// Keypad start position, key sizes and spacing
#define KEY_X 40 // Centre of key
#define KEY_Y 96
#define KEY_W 62 // Width and height
#define KEY_H 30
#define KEY_SPACING_X 18 // X and Y gap
#define KEY_SPACING_Y 20
#define KEY_TEXTSIZE 1   // Font size multiplier

// Using two fonts since numbers are nice when bold
//#define LABEL1_FONT &FreeSansOblique12pt7b // Key label font 1
//#define LABEL2_FONT &FreeSansBold12pt7b    // Key label font 2

// Numeric display box size and location
#define DISP_X 1
#define DISP_Y 10
#define DISP_W 238
#define DISP_H 50
#define DISP_TSIZE 3
#define DISP_TCOLOR RA8875_CYAN

// Number length, buffer for storing it and character index
#define NUM_LEN 12
char numberBuffer[NUM_LEN + 1] = "";
uint8_t numberIndex = 0;

// We have a status line for messages
#define STATUS_X 120 // Centred on this
#define STATUS_Y 65


/* create 15 buttons, in classic candybar phone style */
char keyLabel[15][5] = {"Send", "Clr", "End", "1", "2", "3", "4", "5", "6", "7", "8", "9", "*", "0", "#" };
uint16_t keyColor[15] = {RA8875_GREEN, RA8875_YELLOW, RA8875_RED, 
                             RA8875_BLUE, RA8875_BLUE, RA8875_BLUE, 
                             RA8875_BLUE, RA8875_BLUE, RA8875_BLUE, 
                             RA8875_BLUE, RA8875_BLUE, RA8875_BLUE, 
                             RA8875_RED, RA8875_BLUE, RA8875_RED};
Adafruit_GFX_Button key[15];


void setup() {
  Serial.begin(9600);  
  
  // clear the screen
  tft.begin(RA8875_800x480); 
  tft.fillScreen(RA8875_BLACK);

  
  // Draw keypad background
  tft.fillRect(0, 0, 240, 320, RA8875_YELLOW);

  // Draw number display area and frame
  tft.fillRect(DISP_X, DISP_Y, DISP_W, DISP_H, RA8875_BLACK);
  tft.drawRect(DISP_X, DISP_Y, DISP_W, DISP_H, RA8875_WHITE);

  // Draw keypad
  drawKeypad();
  
  if (!ts.begin(40)) { 
    Serial.println("Unable to start touchscreen.");
  } 
  else { 
    Serial.println("Touchscreen started."); 
  }
        
  
}


void loop(void) {
  boolean istouched = ts.touched();
  
  if (istouched) {
    TS_Point p = ts.getPoint();

    // rotate coordinate system
    // flip it around to match the screen.
    p.x = map(p.x, 0, 800,0,800);
    p.y = map(p.y, 0, 480, 480,0);
    //int y = tft.height() - p.y;    
    //int x = p.x;

    int y = tft.height() - p.y;    
    int x = p.x;
    
    if (!wastouched) {
     
      //tft.fillWindow(RA8875_BLACK);//fill window black 
      //tft.setTextColor(RA8875_YELLOW);      
      
    }
    
    // go thru all the buttons, checking if they were pressed
  for (uint8_t b=0; b<15; b++) {
    if (key[b].contains(p.x, p.y)) {
      //Serial.print("Pressing: "); Serial.println(b);
      key[b].press(true);  // tell the button it is pressed
    } else {
      key[b].press(false);  // tell the button it is NOT pressed
    }
  }

  // now we can ask the buttons if their state has changed
  for (uint8_t b=0; b<15; b++) {
    if (key[b].justReleased()) {
      // Serial.print("Released: "); Serial.println(b);
      key[b].drawButton();  // draw normal
    }
    
    if (key[b].justPressed()) {
        key[b].drawButton(true);  // draw invert!
        
        /// if a numberpad button, append the relevant # to the numberBuffer
      if (b >= 3) {
        if (numberIndex < NUM_LEN) {
          numberBuffer[numberIndex] = keyLabel[b][0];
          numberIndex++;
          numberBuffer[numberIndex] = 0; // zero terminate
        }
        status(""); // Clear the old status
      }

        // Del button, so delete last char
      if (b == 1) {
        numberBuffer[numberIndex] = 0;
        if (numberIndex > 0) {
          numberIndex--;
          numberBuffer[numberIndex] = 0;//' ';
        }
        status(""); // Clear the old status
      }

        if (b == 2) {
        status("Sent value to serial port");
        Serial.println(numberBuffer);
      }
      // we dont really check that the text field makes sense
      // just try to call
      if (b == 0) {
        status("Value cleared");
        numberIndex = 0; // Reset index to 0
        numberBuffer[numberIndex] = 0; // Place null in buffer
      }

      // Update the number display field
      //tft.setTextDatum(TL_DATUM);        // Use top left corner as text coord datum
      tft.setFontScale(1);  // Choose a nicefont that fits box
      tft.setTextColor(DISP_TCOLOR);     // Set the font colour

      // Draw the string, the value returned is the width in pixels
      //int xwidth = tft.drawString(numberBuffer, DISP_X + 4, DISP_Y + 12);
      int xwidth;
      // Now cover up the rest of the line up by drawing a black rectangle.  No flicker this way
      // but it will not work with italic or oblique fonts due to character overlap.
      tft.fillRect(DISP_X + 4 + xwidth, DISP_Y + 1, DISP_W - xwidth - 5, DISP_H - 2, RA8875_BLACK);

     
}
}
/*
else {
    
    if (wastouched) {
             
    }
    Serial.println("no touch");
  }
 */ 
  wastouched = istouched;
  delay(100);
}
}

void drawKeypad()
{
  // Draw the keys
  for (uint8_t row = 0; row < 5; row++) {
    for (uint8_t col = 0; col < 3; col++) {
      uint8_t b = col + row * 3;

      if (b < 3) tft.setFontScale(1);
      else tft.setFontScale(1);

      key[b].initButton(&tft, KEY_X + col * (KEY_W + KEY_SPACING_X),
                        KEY_Y + row * (KEY_H + KEY_SPACING_Y), // x, y, w, h, outline, fill, text
                        KEY_W, KEY_H, RA8875_WHITE, keyColor[b], RA8875_WHITE,
                        keyLabel[b], KEY_TEXTSIZE);
      key[b].drawButton();
    }
  }
}

// Print something in the mini status bar
void status(const char *msg) {
  //tft.setTextPadding(240);
  //tft.setCursor(STATUS_X, STATUS_Y);
  tft.setTextColor(TFT_WHITE, TFT_DARKGREY);
  //tft.setTextFont(0);
  tft.setFontScale(1);
  //tft.setTextDatum(TC_DATUM);
  tft.setTextSize(1);
  //tft.drawString(msg, STATUS_X, STATUS_Y);
}

If i use tft_espi with a regular ILI9341 and Co,it works,but with a RA8875 and FT6206,there is nothing to discover on the net !!

Maybe someday you enter this thread...