esp32 tft display library supplier

TFT_display_init() Perform display initialization sequence. Sets orientation to landscape; clears the screen. SPI interface must already be setup, tft_disp_type, _width, _height variables must be set.

compile_font_file Function which compiles font c source file to binary font file which can be used in TFT_setFont() function to select external font. Created file has the same name as source file and extension .fnt

TFT_display_init() Perform display initialization sequence. Sets orientation to landscape; clears the screen. SPI interface must already be setup, tft_disp_type, _width, _height variables must be set.

compile_font_file Function which compiles font c source file to font file which can be used in TFT_setFont() function to select external font. Created file have the same name as source file and extension .fnt

This module is the 3.2” version of the ESP32 touchscreen display, based on ESP32-WROVER, with a built-in 2M pixel OV2640 camera. The LCD is 320x240 TFT, with driver is ILI9341, it uses SPI for communication with ESP32, the SPI main clock could be up to 60M~80M, make the display smooth enough for videos; and the camera OV2640 with pixel 2M, with this camera, you can make applications such as remote photography, face recognition…

While the camera not used, you can freely use all these pins with the breakout connectors, to connect the ESP32 display with sensors/ actuators, suitable for IoT applications.

The TFT display is a kind of LCD that is connected to each pixel using a transistor and it features low current consumption, high-quality, high-resolution and backlight. This 2.8-inch full color LCD has a narrow PCB display. The resolution is 320×280 pixels and it has a four-wire SPI interface and white backlight.

//#define ILI9488_DRIVER // WARNING: Do not connect ILI9488 display SDO to MISO if other devices share the SPI bus (TFT SDO does NOT tristate when CS is high)

The content is intended to be updated from time to time, I will add more details if I found new display or library update. You can also help me enrich the content by leaving comments below.

You can run various IoT projects prefectly without any display. But not all IoT project only feed data in single direction (IoT to server), some IoT also gather real time information from the server for displaying.

My previous instructables, ESP32 Photo Clock is am example, it download a current minute photo from the Internet, decode the JPEG photo and display it.

Many Arduino projects use monochrome display, one of the reason is the limited resources of a MCU. 320 pixels width, 240 pixels height and 8 bits color for each RGB color channel means 230 KB for each full screen picture. But normal Arduino (ATmega328) only have 32 KB flash and it is time consuming (over a second) to read data from SD card and draw it to the color display.

ESP32 have changed the game! It have much faster processing power (16 MHz vs 240 MHz dual core), much more RAM (2 KB vs over 200 KB) and much more flash (32 KB vs 4 MB), so it is capable to utilize more color and higher resolution image for displaying. At the same time it is capable to do some RAM hungry process such as Animated GIF, JPEG or PNG file decoding, it is a very important feature for displaying information gathered from the internet.

Color display have many type of interfaces: Serial Peripheral Interface (SPI), 6-bit, 8-bit, 16-bit, 18-bit and 24-bit parallel interfaces and also NeoPixel!

SPI dominate the hobby electronics market, most likely because of fewer wire required to connect. Most display in my drawer only have SPI pins breaking out, so this instructables focus on SPI display and a few 8-bit display.

NeoPixel matrix is a very special type of color display. If you are interested in NeoPixel matrix display, here are some of my instructables using it:

There are various color display for hobby electronics: LCD, IPS LCD, OLED with different resolutions and different driver chips. LCD can have higher image density but OLED have better viewable angle, IPS LCD can have both. OLED have more power efficient for each light up pixel but may have burn-in problems. Color OLED operate in 14 V, it means you need a dedicate step-up circuit, but it is not a problem if you simply use with a break-out board. LCD in most case can direct operate in 3.3 V, the same operating voltage as ESP32, so you can consider not use break out board to make a slimmer product.

Software support on the other side also influence your selection. You can develop ESP32 program with Arduino IDE or direct use ESP-IDF. But since ESP-IDF did not have too much display library and not much display hardware supported, so I will concentrate on Arduino display libraries only.

For the beginner, I think buying adafruit, or similar supportive vendor, hardware and using its Arduino library can have good seamless experience (though I have no budget to try it all). TFT_eSPI library have better performance but configuration require make changes in the library folder. Ucglib and UTFT-ESP run a little bit slow but it support many hardware and it is a popular library, you can find many Arduino projects using it. LovyanGFX library start appear at 2019, it support many dev device such as M5Stack, M5StickC, TTGO T-Watch, ODROID-GO, ESP-WROVER-KIT, WioTerminal and more. I am also writing a new library called Arduino_GFX since 2019.

OLED have a big advantage, the pixel only draw power if it lights up. On the other hand, LCD back light always draw full power even you are displaying a black screen. So OLED can help save some power for the project powered by a battery.

The initial code have some variation, the color order can be RGB or BGR and the y coordinate range also have a few pixels variation. Some library differential it by red, green or black tag but the tag color may not always help. The worst case is alter the tag option one by one until you can see a fine result. The above last picture is an example of using wrong tag option, you can find 3 pixels height noise bar on the top.

Thanks for the popularity of wearable gadget, I can find more small size IPS LCD in the market this year(2018). The above picture is an 0.96" 80x160 IPS color LCD using ST7735 driver chip. As you can see in the 3rd picture, you can treat it as a 128x160 color display in code but only the middle part is actually displaying. The 4th picture is the display without breakout board, it is thin, tiny and very fit for a wearable project!

SSD1283A is 1.6" 130x130 display, it claim only consume 0.1 in sleep mode and backlight turned off. In sleep mode the last drawn screen still readable under sufficient lighting.

ST7789 also a common driver chip in ESP32 community. One of the reason is ESP32 official development kit using it. As same as ILI9341, ST7789 also can drive 240x320 resolution.

This also the highest pixel density color display in my drawer. As same as normal LCD, it can direct operate in 3.3 V, so it is very good for making slim wearable device.

There are many display libraries that can support various hardware. I have picked 4 of most popular Arduino library for comparison:Adafruit GFX Family

The display speed is one of the most important thing we consider to select which library. I have chosen TFT_eSPI PDQ test for this comparison. I have made some effort to rewrite the PDQ test that can run in 4 libraries. All test will run with the same 2.8" ILI9341 LCD.

As I found TFT_eSPI is the most potential display library for ESP32 in this instructables, I have paid some effort to add support for all my display in hand. The newly added display support marked letter M in red at the above picture, here is my enhanced version:

Adafruit sell various display module in hobby electronics market and they also have very good support in software level. Their display libraries all built on a parent class called Adafruit_GFX, so I call it Adafruit GFX Family. This library generally support most Arduino hardware (also ESP32).

In Arduino Library Manager simply search "adafruit display", you can see all the family members. If you want to install it, say ILI9341, simply select "Adafruit ILI9341" and then click install. Remember also install its dependent library "Adafruit GFX Library".

This library method signature is very similar to Adafruit GFX, but it is tailor-made for ESP8266 or ESP32. I think the source code is optimised for ESP32, so the PDQ result is much faster than other libraries.

Note: The most difficult part using this library is you are required to configure this library before you can use it. The configuration file is located at the library folder, it should be "Arduino/libraries/TFT_eSPI/User_setup.h" under you own documents folder. It have many comments help you to do that, please follow the comments step by step to finish the configuration. Here is my User_setup.h for ILI9341:

ESP32 + ILI9341 can run at SPI speed 40 MHz, it require some code change at library folder. The above pictures are the fine tuned result. Here are the code change summary:

ST7735 and ILI9341 are the most popular display, this 2 are better option for the beginner. You may notice LCD have a big weakness, the viewable angle, some color lost outside the viewable angle and the screen become unreadable. If you have enough budget, OLED or IPS LCD have much better viewable angle.

In most case, we study how to use a code library by searching sample on the web. I have tried search four libraries keyword in Github, Adafruit is most popular and UTFT the second.

Only Adafruit GFX Family is fully configurable in user code level, other 3 libraries require some configuration in the library folder. And also Adafruit have very good portal, there are many detailed post teach you how to use their products.

ILI9341 should be most valuable display for the beginner. Adafruit GFX Library should be most easy to use for the beginner, and since TFT_eSPI have very similar method signature, it is very easy to switch to a faster library later on.

OLED require 14 V to light up the pixel so it is not easy to decouple the breakout board. On the other hand, LCD (also IPS LCD) usually operate in 3.3 V, as same as the ESP32. In most case, there are only the LED control circuit required between LCD and ESP32, i.e. a transistor and few resistors. So it relatively easy to make it.

If you read through the data sheet of the color display, you may find most of color display can support 18 bit color depth (6 bit for each RGB channel). 18 bit color depth can have a better image quality that 16 bit color depth (5 bit in red and blue channel, 6 bit for green channel). However, only Ucglib actually run at 18 bit color depth (262,144 colors), other 3 libraries all run at 16 bit color depth (65,536 colors). It is because 18 bit color depth actually require transfer 3 bytes (24 bit) of data for each pixel, it means 50% more data require to transfer and store in memory. It is one of the reason why Ucglib run slower, but it can have a better image quality.

Thank you very much for posting this detailed review of the color display option available for "Duino users. You have saved me hours, maybe days of time wandering the web looking for information.0

Great article! Very interested in round displays. There are available round displays based on st7687s (128 * 128) and st7789 (240 * 240), but I have not found any information on practical use.

Hello! Yes, I purchased this display from keyestudio, connected it to esp32 using this library from dfrobot. It is only necessary to consider that the pinout of the display connectors differs from dfrobot and keyestudio.

I"m wanting to connect a VGA camera, the sort you find as a little module on eBay with OVPxxxx chip, to a screen such as ILxxxx family, which appears to have direct VGA input. I think it will work if I connect the camera directly with no MCU, but I"d also like to add a cross-hair to the display (for a drill targetting system). I wonder is it possible to intercept the serial video data and change individual pixels in a streaming fashion, instead of loading a whole screen into memory, changing it and passing it on? I ask because it seems to me it would need a much less powerful MCU.0

Thank you so much for such a great article. I have been trying to choose the best library to use for a project that will use either a SSD1351 or a ST7735 both being 128x128. The key to my project is to be able to dump a frame buffer in to the display and then recalculate the next frame buffer. :)

Those 2 pins must be dedicated to the display, otherwise the display will get confused without the CS pin. One DAT/CLK to LCD and another DAT/CLK to I2C.

Hello! Thank"s for your instruction. I want to use your 8pin ili9486 320x480 spi display with one of your presented libraries and esp32. 1.) Could you please tell me the connections between the display and the esp32 and 2.) which numbers do I have to write into the line utft myglcd (ili9486,?,?,?,?)?

This board works fine with TFT_eSPI when the ST7789 driver is selected. The pin settings are different and the RGB colour order is reversed compared to other boards so I have added an option to the TFT_eSPI library to set the colour order.

I have set the SPI rate to 80MHz and the ST7789 TFT seems to work perfectly at that clock speed, the higher clock frequency boosts the drawing speed (e.g. clear screen in 18ms as opposed to 33.3ms).

The Grove I2C connector is not soldered in, this is clearly because the pins would poke through the board and damage the back of the display. It would be possible to "surface mount" the connector by bending the pins but I think the solder flowing into the PTH may melt the reflective backlight diffuser screen at the back of the display. One way around this would be to fill the holes with epoxy first.

[Adalbert] ran into these problems when he got his hands on a Toshiba T3200SXC from 1991. As the first laptop ever to feature a color TFT display, it’s very much worth preserving as an historical artifact. Sadly, the original display was no longer working: it only displayed a very faint image and went completely blank soon after. Leaky capacitors then destroyed the power supply board, leaving the laptop completely dead. [Adalbert] then began to ponder his options, which ranged from trying to repair the original components to ripping everything out and turning this into a modern-computer-in-an-old-case project.

In the end he went for an option in between, which we as preservationists can only applaud: he replaced the display with a modern one of the correct size and resolution and built a new custom power supply, keeping the rest of the computer intact as far as possible. [Adalbert] describes the overall process in the video embedded below and goes into lots of detail on his hackaday.io page.

Connecting a modern LCD screen was not as difficult as it might seem: where the old display had an RGB TTL interface with three bits per color, the new one had a very similar system with six bits per color. [Adalbert] made an adapter PCB that simply connected the three bits from the laptop to the highest three bits on the screen. A set of 3D-printed brackets ensured a secure fit of the new screen in the classic case.

To get the screen on the LilyGO TTGO T-display ESP32 running need the TFT_eSPI library. This is a "graphics and fonts library for ESP8266 and ESP32 processors with drivers for ILI9341, ILI9163, ST7735, S6D02A1, ILI9481, ILI9486, ILI9488, HX8357D and ST7789 based TFT displays that support SPI".

Whilst you can install the library with the Library manager of Arduino I would advise you to install the version from Github. In that way you can be sure you get the newest version. You will be able to update the library within the Library manager or overwrite the old files manually. Be sure to check whether the manual changes you have to made are still there after an update (see below at "Configure the TFT_eSPI library to use the ST7789V in the correct way")!

Manually installGo to https://github.com/Bodmer/TFT_eSPI/releases and download the Source code (ZIP) of the newest release or if you want even a newer unreleased version you can download the library by clicking on Clone or download on the upper right corner on https://github.com/Bodmer/TFT_eSPI.

Save the file TTGO_T_Display.h to the folder User_setups of the TFT_eSPI library you just installed. Most likely this will be C:\Users\[username]\Documents\Arduino\libraries\TFT_eSPI-master\User_Setups

This library is only needed for the demo sketch of LilyGO. If you prefer another library for handling the button presses you are free to use so. I personally like the Button 2 library. It does fit my needs quite well.

This tutorial shows how to use the I2C LCD (Liquid Crystal Display) with the ESP32 using Arduino IDE. We’ll show you how to wire the display, install the library and try sample code to write text on the LCD: static text, and scroll long messages. You can also use this guide with the ESP8266.

Before displaying text on the LCD, you need to find the LCD I2C address. With the LCD properly wired to the ESP32, upload the following I2C Scanner sketch.

After uploading the code, open the Serial Monitor at a baud rate of 115200. Press the ESP32 EN button. The I2C address should be displayed in the Serial Monitor.

Displaying static text on the LCD is very simple. All you have to do is select where you want the characters to be displayed on the screen, and then send the message to the display.

In this simple sketch we show you the most useful and important functions from the LiquidCrystal_I2C library. So, let’s take a quick look at how the code works.

The next two lines set the number of columns and rows of your LCD display. If you’re using a display with another size, you should modify those variables.

Then, you need to set the display address, the number of columns and number of rows. You should use the display address you’ve found in the previous step.

To display a message on the screen, first you need to set the cursor to where you want your message to be written. The following line sets the cursor to the first column, first row.

Scrolling text on the LCD is specially useful when you want to display messages longer than 16 characters. The library comes with built-in functions that allows you to scroll text. However, many people experience problems with those functions because:

The messageToScroll variable is displayed in the second row (1 corresponds to the second row), with a delay time of 250 ms (the GIF image is speed up 1.5x).

In a 16×2 LCD there are 32 blocks where you can display characters. Each block is made out of 5×8 tiny pixels. You can display custom characters by defining the state of each tiny pixel. For that, you can create a byte variable to hold  the state of each pixel.

In summary, in this tutorial we’ve shown you how to use an I2C LCD display with the ESP32/ESP8266 with Arduino IDE: how to display static text, scrolling text and custom characters. This tutorial also works with the Arduino board, you just need to change the pin assignment to use the Arduino I2C pins.

We hope you’ve found this tutorial useful. If you like ESP32 and you want to learn more, we recommend enrolling in Learn ESP32 with Arduino IDE course.

A library for driving self-timed digital RGB/RGBW LEDs (WS2812, SK6812, NeoPixel, WS2813, etc.) using the Espressif ESP32 microcontroller"s RMT output peripheral.

LiquidCrystal fork for displays based on HD44780. Uses the IOAbstraction library to work with i2c, PCF8574, MCP23017, Shift registers, Arduino pins and ports interchangably.

The most powerful and popular available library for using 7/14/16 segment display, supporting daisy chaining so you can control mass amounts from your Arduino!

A simple library to display numbers, text and animation on 4 and 6 digit 7-segment TM1637 based display modules. Offers non-blocking animations and scrolling!

Monochrome LCD, OLED and eInk Library. Display controller: SSD1305, SSD1306, SSD1309, SSD1312, SSD1316, SSD1318, SSD1320, SSD1322, SSD1325, SSD1327, SSD1329, SSD1606, SSD1607, SH1106, SH1107, SH1108, SH1122, T6963, RA8835, LC7981, PCD8544, PCF8812, HX1230, UC1601, UC1604, UC1608, UC1610, UC1611, UC1617, UC1638, UC1701, ST7511, ST7528, ST7565, ST7567, ST7571, ST7586, ST7588, ST75160, ST75256, ST75320, NT7534, ST7920, IST3020, IST3088, IST7920, LD7032, KS0108, KS0713, HD44102, T7932, SED1520, SBN1661, IL3820, MAX7219, GP1287, GP1247, GU800. Interfaces: I2C, SPI, Parallel.

True color TFT and OLED library, Up to 18 Bit color depth. Supported display controller: ST7735, ILI9163, ILI9325, ILI9341, ILI9486,LD50T6160, PCF8833, SEPS225, SSD1331, SSD1351, HX8352C.

I have included the specsheet for this chip in case it is removed, the original source location is https://docs.ai-thinker.com/en/12k_development_board_esp32-s2

Alright, now that we have figured out if the touchscreen you have is touch-capable, time to set up the esp32-s2-12k and the ILI9341 display.esp32-s2-12k PinsTFT Pins3V3VCC

Working with TFT_eSPI, you need to edit User_Setup.h it is located in your Arduino folder libraries folder. To find this location check out https://support.arduino.cc/hc/en-us/articles/4411202655634-Find-Arduino-IDE-files-and-folders which has more info on the exact location for your machine.

#defineILI9341_DRIVER#defineTFT_CS10#defineTFT_MOSI11#defineTFT_SCLK12#defineTFT_MISO13#defineTFT_DC14#defineTFT_RST15#defineTOUCH_CS34#defineLOAD_GLCD#defineLOAD_FONT2#defineLOAD_FONT4#defineLOAD_FONT6#defineLOAD_FONT7#defineLOAD_FONT8#defineLOAD_GFXFF#defineSMOOTH_FONT#defineUSE_HSPI_PORT#defineSPI_FREQUENCY40000000#defineSPI_TOUCH_FREQUENCY2500000

Once we have the User_Setup.h configured we can use one of the existing sketches. One of the most intricate examples is the keypad example (https://github.com/Bodmer/TFT_eSPI/blob/master/examples/320%20x%20240/Keypad_240x320/Keypad_240x320.ino). It shows off having a single library handle both touch and rendering provides a lot of out of the box wins.

/*The TFT_eSPI library incorporates an Adafruit_GFX compatiblebutton handling class, this sketch is based on the Arduin-o-phoneexample.This example diplays a keypad where numbers can be entered andsend 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.*/// The SPIFFS (FLASH filing system) is used to hold touch screen// calibration data#include"FS.h"#include#include// Hardware-specific libraryTFT_eSPI tft=TFT_eSPI();// Invoke custom library// 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 "/".#defineCALIBRATION_FILE"/TouchCalData1"// 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.#defineREPEAT_CALfalse// Keypad start position, key sizes and spacing#defineKEY_X40// Centre of key#defineKEY_Y96#defineKEY_W62// Width and height#defineKEY_H30#defineKEY_SPACING_X18// X and Y gap#defineKEY_SPACING_Y20#defineKEY_TEXTSIZE1// Font size multiplier// Using two fonts since numbers are nice when bold#defineLABEL1_FONT&FreeSansOblique12pt7b// Key label font 1#defineLABEL2_FONT&FreeSansBold12pt7b// Key label font 2// Numeric display box size and location#defineDISP_X1#defineDISP_Y10#defineDISP_W238#defineDISP_H50#defineDISP_TSIZE3#defineDISP_TCOLORTFT_CYAN// Number length, buffer for storing it and character index#defineNUM_LEN12charnumberBuffer[NUM_LEN+1]="";uint8_tnumberIndex=0;// We have a status line for messages#defineSTATUS_X120// Centred on this#defineSTATUS_Y65// Create 15 keys for the keypadcharkeyLabel[15][5]={"New","Del","Send","1","2","3","4","5","6","7","8","9",".","0","#"};uint16_tkeyColor[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 objectsTFT_eSPI_Button key[15];//------------------------------------------------------------------------------------------voidsetup(){// Use serial portSerial.begin(9600);// Initialise the TFT screentft.init();// Set the rotation before we calibratetft.setRotation(0);// Calibrate the touch screen and retrieve the scaling factorstouch_calibrate();// Clear the screentft.fillScreen(TFT_BLACK);// Draw keypad backgroundtft.fillRect(0,0,240,320,TFT_DARKGREY);// Draw number display area and frametft.fillRect(DISP_X,DISP_Y,DISP_W,DISP_H,TFT_BLACK);tft.drawRect(DISP_X,DISP_Y,DISP_W,DISP_H,TFT_WHITE);// Draw keypaddrawKeypad();}//------------------------------------------------------------------------------------------voidloop(void){uint16_tt_x=0,t_y=0;// To store the touch coordinates// Pressed will be set true is there is a valid touch on the screenboolpressed=tft.getTouch(&t_x,&t_y);// / Check if any key coordinate boxes contain the touch coordinatesfor(uint8_tb=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 statefor(uint8_tb=0;b<15;b++){if(b<3)tft.setFreeFont(LABEL1_FONT);elsetft.setFreeFont(LABEL2_FONT);if(key[b].justReleased())key[b].drawButton();// draw normalif(key[b].justPressed()){key[b].drawButton(true);// draw invert// if a numberpad button, append the relevant ## to the numberBufferif(b>=3){if(numberIndex0){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 callif(b==0){status("Value cleared");numberIndex=0;// Reset index to 0numberBuffer[numberIndex]=0;// Place null in buffer}// Update the number display fieldtft.setTextDatum(TL_DATUM);// Use top left corner as text coord datumtft.setFreeFont(&FreeSans18pt7b);// Choose a nicefont that fits boxtft.setTextColor(DISP_TCOLOR);// Set the font colour// Draw the string, the value returned is the width in pixelsintxwidth=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}}}//------------------------------------------------------------------------------------------voiddrawKeypad(){// Draw the keysfor(uint8_trow=0;row<5;row++){for(uint8_tcol=0;col<3;col++){uint8_tb=col+row*3;if(b<3)tft.setFreeFont(LABEL1_FONT);elsetft.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, textKEY_W,KEY_H,TFT_WHITE,keyColor[b],TFT_WHITE,keyLabel[b],KEY_TEXTSIZE);key[b].drawButton();}}}//------------------------------------------------------------------------------------------voidtouch_calibrate(){uint16_tcalData[5];uint8_tcalDataOK=0;// check file system existsif(!SPIFFS.begin()){Serial.println("Formating file system");SPIFFS.format();SPIFFS.begin();}// check if calibration file exists and size is correctif(SPIFFS.exists(CALIBRATION_FILE)){if(REPEAT_CAL){// Delete if we want to re-calibrateSPIFFS.remove(CALIBRATION_FILE);}else{File f=SPIFFS.open(CALIBRATION_FILE,"r");if(f){if(f.readBytes((char*)calData,14)==14)calDataOK=1;f.close();}}}if(calDataOK&&!REPEAT_CAL){// calibration data validtft.setTouch(calData);}else{// data not valid so recalibratetft.fillScreen(TFT_BLACK);tft.setCursor(20,0);tft.setTextFont(2);tft.setTextSize(1);tft.setTextColor(TFT_WHITE,TFT_BLACK);tft.println("Touch corners as indicated");tft.setTextFont(1);tft.println();if(REPEAT_CAL){tft.setTextColor(TFT_RED,TFT_BLACK);tft.println("Set REPEAT_CAL to false to stop this running again!");}tft.calibrateTouch(calData,TFT_MAGENTA,TFT_BLACK,15);tft.setTextColor(TFT_GREEN,TFT_BLACK);tft.println("Calibration complete!");// store dataFile f=SPIFFS.open(CALIBRATION_FILE,"w");if(f){f.write((constunsignedchar*)calData,14);f.close();}}}//------------------------------------------------------------------------------------------// Print something in the mini status barvoidstatus(constchar*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);}//------------------------------------------------------------------------------------------

One of the benefits of using TFT_eSPI is having the ability to calibrate your display and having that as a part of your workflow. This does require SPIFFS to store this information, so having something like the esp32 family is a well-suited library for most of your needs.

#include"Adafruit_GFX.h"#include"Adafruit_ILI9341.h"#include#include#defineSCLK_PIN12#defineMISO_PIN13#defineMOSI_PIN11#defineTOUCH_CS34#defineTFT_DC14#defineTFT_CS10#defineTFT_RST15XPT2046_Touchscreents(TOUCH_CS);Adafruit_ILI9341 tft=Adafruit_ILI9341(TFT_CS,TFT_DC,TFT_RST);voidsetup(){Serial.begin(38400);SPI.begin(SCLK_PIN,MISO_PIN,MOSI_PIN);SPI.setFrequency(40000000);tft.begin(4000000);tft.setRotation(1);tft.fillScreen(ILI9341_BLACK);ts.begin();ts.setRotation(1);while(!Serial&&(millis()<=1000));}boolean wastouched=true;voidloop(){boolean istouched=ts.touched();if(istouched){TS_Point p=ts.getPoint();if(!wastouched){tft.fillScreen(ILI9341_BLACK);tft.setTextColor(ILI9341_YELLOW);tft.setCursor(60,80);tft.print("Touch");}tft.fillRect(100,150,140,60,ILI9341_BLACK);tft.setTextColor(ILI9341_GREEN);tft.setCursor(100,150);tft.print("X = ");tft.print(p.x);tft.setCursor(100,180);tft.print("Y = ");tft.print(p.y);Serial.print(", x = ");Serial.print(p.x);Serial.print(", y = ");Serial.println(p.y);}else{if(wastouched){tft.fillScreen(ILI9341_BLACK);tft.setTextColor(ILI9341_RED);tft.setCursor(120,50);tft.print("No");tft.setCursor(80,120);tft.print("Touch");}Serial.println("no touch");}wastouched=istouched;delay(100);}

Picking the right library for your needs is important. There are considerations to be made between XPT2046_Touchscreen and TFT_eSPI such as compatibility and required space to run on your device. I have yet to use either in any real-life application other than some of the two examples provided, when I do I will put my findings here.

Popular Create by 300+ developers, used by 100,000+ people and downloaded in every minute. LVGL is available in Arduino, PlatformIO, ESP32, MCUXpresso, Zephyr, NuttX, RT-Thread, ARM CMSIS-Pack and many more.

Cross-platform Has no external dependencies and can be compiled for any vendor"s any MCU or MPU, and (RT)OS to drive ePaper, OLED or TFT displays, or even monitors.

The NuMaker-HMI-MA35D1-S1 is an evaluation board for Nuvoton NuMicro MA35D1 series microprocessors, and consists of three parts: a NuMaker-SOM-MA35D16A81 SOM board, a NuMaker-BASE-MA35D1B1 base board and a 7” TFT-LCD daughter...

Optional, select the development boardESP32 Dev Module,select Disable in the PSRAM option,select 4-16MB in the Flash Size option, Other keep the default