Setup & Development

This guide walks through connecting the board, configuring your development environment, and verifying everything works with a test sketch. The ESP32-S3-Touch-LCD-4.3 supports both the Arduino framework and Espressif’s ESP-IDF toolchain — choose whichever fits your project.

Prerequisites

Before starting, gather the following:

• ESP32-S3-Touch-LCD-4.3 (Type B) board
• USB Type-C cable with data lines (not a charge-only cable)
• Computer running Windows, macOS, or Linux with one of:
  • Arduino IDE 1.8 or later (2.x recommended)
  • VS Code with the Espressif IDF extension

Connecting the Board

The board has two USB Type-C ports that serve different purposes. Type-C2 (the top-edge port) connects to the CH343P USB-to-UART bridge and is the primary programming and serial monitor interface. Type-C1 (the side port) provides USB Host/OTG functionality and is not used for flashing. Use Type-C2 for all initial development work.

1. Connect USB Type-C2 (top port) to your computer using a data-capable USB-C cable.

2. Install CH343 drivers if your operating system does not recognize the device automatically. Linux kernels 5.14 and later include built-in CH343 support, and recent versions of Windows typically auto-detect the device through Windows Update. On macOS, download and install the CH34XSER_MAC driver from WCH.

3. Verify the connection by checking that a new serial port appears on your system. On Linux this will typically be /dev/ttyACM0 or /dev/ttyUSB0, on macOS /dev/cu.wchusbserial*, and on Windows a new COM port in Device Manager.

Boot Mode

The ESP32-S3 must be placed into download mode before flashing new firmware. This is only necessary if automatic reset via the serial DTR/RTS lines fails (which is rare with the CH343P bridge, but good to know).

1. Press and hold the BOOT button on the board.

2. While still holding BOOT, press and release the RESET button.

3. Release the BOOT button. The ESP32-S3 is now in download mode, ready to accept firmware over the USB serial connection.

Tip

In most cases, the Arduino IDE and ESP-IDF toolchains will automatically trigger download mode through the serial control lines. Manual boot mode entry is a fallback for situations where auto-reset does not work, such as with certain USB hubs or cables.

Development Environment Setup

Arduino IDE

The Arduino framework provides a familiar and accessible entry point, especially for projects focused on the display, touch input, and communication interfaces.

1. Install Arduino IDE version 1.8 or later. The 2.x series is recommended for improved board manager handling and a more responsive editor.

2. Add the ESP32 board manager URL. Navigate to File > Preferences (or Arduino IDE > Settings on macOS) and add the following URL to the “Additional boards manager URLs” field:

   https://espressif.github.io/arduino-esp32/package_esp32_index.json

3. Install the ESP32 board package. Open Tools > Board > Boards Manager, search for “esp32”, and install esp32 by Espressif Systems version 3.0.0 or later. Version 3.0.6 and above include a direct board selection for this module.

4. Configure board settings under Tools:

   Setting	Value
   Board	ESP32S3 Dev Module
   Flash Size	16MB (128Mb)
   PSRAM	OPI PSRAM
   USB CDC On Boot	Enabled
   Upload Speed	921600
   Partition Scheme	16M Flash (3MB APP/9.9MB FATFS)

5. Install required libraries through the Arduino Library Manager (Sketch > Include Library > Manage Libraries):

   Library	Minimum Version	Purpose
   ESP32_Display_Panel	0.1.4	Display driver and panel abstraction
   ESP32_IO_Expander	0.0.4	CH422G I/O expander driver
   lvgl	8.4.0	Embedded graphics framework

   For LVGL, you will also need to copy lv_conf.h from the library’s root into your Arduino libraries folder and enable it by setting #if 0 to #if 1 at the top of the file. Waveshare’s demo projects include a pre-configured lv_conf.h as a starting point.

6. Select the serial port corresponding to your board under Tools > Port and click Upload to flash.

ESP-IDF

ESP-IDF gives full access to the ESP32-S3’s capabilities, including fine-grained control over FreeRTOS tasks, memory allocation, and peripheral configuration. This is the recommended path for production firmware and projects that need features beyond what the Arduino abstraction provides.

1. Install VS Code and the Espressif IDF extension from the VS Code marketplace. The extension bundles a guided setup wizard that handles toolchain installation.

2. Install ESP-IDF version 5.1.4 or later. Version 5.5.2 is recommended as it includes important fixes for RS-485 half-duplex timing and TWAI (CAN) driver stability. The VS Code extension can install ESP-IDF automatically, or you can follow Espressif’s manual installation guide.

3. Configure your project’s sdkconfig. The following settings are critical for this board:

   # FreeRTOS tick rate — 1000 Hz for responsive LVGL timers
   CONFIG_FREERTOS_HZ=1000
   
   # CPU at full 240 MHz
   CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_240=y
   
   # Enable OPI PSRAM
   CONFIG_SPIRAM=y
   CONFIG_SPIRAM_MODE_OCT=y
   CONFIG_SPIRAM_SPEED_80M=y
   
   # Place frequently accessed data in PSRAM
   CONFIG_SPIRAM_USE_MALLOC=y
   
   # Flash configuration — QIO, 80 MHz, 16 MB
   CONFIG_ESPTOOLPY_FLASHMODE_QIO=y
   CONFIG_ESPTOOLPY_FLASHFREQ_80M=y
   CONFIG_ESPTOOLPY_FLASHSIZE_16MB=y
   
   # Partition table — use custom CSV for 16MB flash
   CONFIG_PARTITION_TABLE_CUSTOM=y

4. Build and flash your project from the VS Code command palette or the terminal:

   idf.py set-target esp32s3
   idf.py build
   idf.py -p /dev/ttyACM0 flash monitor

   Replace /dev/ttyACM0 with your actual serial port. The monitor argument opens a serial console immediately after flashing, which is useful for watching boot logs and debug output.

Verifying Your Setup

The quickest way to confirm that the board, toolchain, and all peripherals are functioning is to flash the I2C Bus Scan demo. This sketch scans every address on the I2C bus and reports which devices respond — a straightforward hardware validation that exercises the I2C bus without requiring display or touch driver configuration.

A successful scan on the Type B board should find devices at the following addresses:

Address	Device
0x14 or 0x5D	GT911 touch controller (address depends on reset timing)
0x24	CH422G I/O expander
0x51	PCF85063A real-time clock

If all three devices appear, the I2C bus, touch controller, I/O expander, and RTC are wired correctly and communicating. From here, proceed to the display and touch demos in Waveshare’s example repository to bring the screen to life.

PSRAM is required for display operation

The 800x480 RGB565 framebuffer consumes 750 KB of memory — far more than the ESP32-S3’s internal SRAM can spare. If the display remains blank or the board crashes on initialization, verify that PSRAM is enabled in your board configuration. In Arduino, set Tools > PSRAM > OPI PSRAM. In ESP-IDF, ensure CONFIG_SPIRAM=y and CONFIG_SPIRAM_MODE_OCT=y are set in your sdkconfig.

GT911 address variability

The GT911 touch controller’s I2C address is determined by the state of its reset and interrupt pins during power-on. Depending on the CH422G initialization sequence, the GT911 may appear at address 0x14 or 0x5D. Both addresses are valid — the display driver libraries handle this automatically. If the touch controller does not appear in an I2C scan, ensure the CH422G is initialized first to properly release the GT911 from reset.