ST7789 Display: A Comprehensive Guide to Features, Development, and Applications

In the landscape of small-to-medium-sized display controllers, the ST7789 has emerged as a versatile and widely adopted solution, powering countless LCD and TFT displays used in consumer electronics, industrial devices, and IoT terminals. As a single-chip driver IC (Integrated Circuit), it is specifically designed to control 240×320 resolution displays (and compatible with lower resolutions) by managing pixel data, color rendering, and display timing—eliminating the need for complex external circuitry.

Unlike older display controllers that require extensive external components to function, the ST7789 integrates key features such as a built-in graphics accelerator, adjustable color depth, and multiple interface options, making it ideal for space-constrained and cost-sensitive projects. From smart wearables and portable test equipment to home automation dashboards and handheld gaming devices, the ST7789’s balance of performance, flexibility, and ease of use has solidified its position as a go-to choice for engineers and hobbyists alike. This guide will explore the ST7789’s core capabilities, technical specifications, development workflows across popular platforms, and real-world applications, providing a complete resource for anyone working with displays powered by this controller.

To fully leverage the ST7789’s capabilities, it is essential to understand its key technical parameters, which dictate compatibility with displays, performance limits, and integration requirements. Below is a detailed breakdown of the controller’s critical specifications:

• Resolution Support: The ST7789 is optimized for 240×320 pixel displays (a common "QVGA+" format), but it also supports lower resolutions (e.g., 128×128, 160×128) through software configuration. This flexibility allows it to be used with a wide range of display sizes, typically from 1.2 inches to 2.8 inches—making it suitable for compact devices like smartwatches and larger portable screens.
• Display Type: Designed for TFT (Thin-Film Transistor) LCD displays, which offer faster response times and better color reproduction than traditional STN (Super Twisted Nematic) LCDs. The controller works with both transmissive and transflective TFT panels, adapting to different lighting conditions (e.g., outdoor vs. indoor use).
• Color Depth: Supports up to 16-bit color (65,536 colors), which balances vibrant color reproduction with memory efficiency. It also offers lower color depth options (8-bit, 4-bit) for applications where power consumption or data transfer speed is a priority (e.g., battery-powered IoT sensors).

The ST7789 provides multiple interface options to connect with microcontrollers (MCUs) or processors, catering to different project requirements for speed, pin count, and complexity:

• SPI (Serial Peripheral Interface): The most common interface for the ST7789, available in 3-line (SCLK, MOSI, CS) or 4-line (adding DC for data/command selection) configurations. SPI offers high data transfer speeds (up to 60 MHz), making it ideal for applications that require smooth video playback or fast screen updates (e.g., gaming devices).
• MCU 8/16-Bit Parallel Interface: For scenarios where maximum data throughput is critical (e.g., high-frame-rate video), the ST7789 supports 8-bit or 16-bit parallel interfaces. This interface directly connects to the MCU’s data bus, enabling faster pixel data transfer but requiring more GPIO pins (16 for 16-bit mode) than SPI.
• I2C Interface: Some variants of the ST7789 include I2C support, which uses only two pins (SDA, SCL) for communication. While I2C is simpler to wire and uses fewer pins, its lower speed (typically up to 400 kHz for Fast Mode) makes it better suited for static displays (e.g., status dashboards) rather than dynamic content.

• Operating Voltage: The ST7789 operates on a core voltage of 1.8V to 3.3V, with an I/O voltage range of 1.8V to 3.3V—compatible with most modern MCUs and processors (e.g., Arduino, ESP32, Raspberry Pi Pico) without the need for level shifters.
• Power Consumption: Features multiple low-power modes to extend battery life in portable devices:
• Sleep Mode: Disables the display driver and reduces power consumption to less than 10 µA, ideal for devices that activate the display only on user input (e.g., smart thermostats).
• Partial Display Mode: Lights only a specific region of the screen (e.g., a status bar), reducing power use by limiting active pixels.
• Idle Mode: Pauses pixel updates while maintaining display content, consuming approximately 50 µA.
• Response Time: Supports a maximum pixel clock of 60 MHz, enabling a refresh rate of up to 60 FPS (Frames Per Second)—sufficient for smooth video playback and fast-moving graphics (e.g., portable gaming).

• Graphics Accelerator: Includes built-in functions for drawing basic shapes (lines, rectangles, circles) and text, reducing the MCU’s workload by offloading graphics processing to the controller.
• Color Correction: Offers adjustable gamma correction and color temperature settings, allowing developers to fine-tune display colors for different applications (e.g., warm tones for consumer devices, accurate colors for industrial measurement tools).
• Display Rotation: Supports software-controlled display rotation (0°, 90°, 180°, 270°), eliminating the need to physically rotate the display panel to match the device’s form factor.
• Partial and Scroll Modes: Enables partial display updates (updating only changed pixels) to reduce data transfer and power use, as well as vertical/horizontal scrolling for content like text feeds or menus.

The ST7789 controller acts as a bridge between the MCU/processor and the TFT display panel, managing all aspects of pixel activation and data processing. To effectively work with the ST7789, it is important to understand its internal architecture and how it interacts with external components.

• Command Decoder: Interprets commands sent by the MCU (e.g., "set display rotation," "update pixel data") and coordinates other internal components to execute the requested action.
• Frame Buffer: A small on-chip memory buffer that temporarily stores pixel data for the current display frame. While the ST7789’s internal frame buffer is limited (typically enough for a single row or column of pixels), it works with the MCU’s external memory to handle full-screen data—reducing the controller’s overall memory footprint.
• Timing Controller (T-Con): Generates the timing signals (horizontal sync, vertical sync, pixel clock) required to synchronize pixel updates with the display panel’s refresh rate, ensuring smooth, flicker-free images.
• Gamma Correction Engine: Adjusts the brightness and color response of the display to match human visual perception, preventing washed-out colors or overly dark regions.
• Voltage Regulator: Converts the input voltage (1.8V–3.3V) to the specific voltage levels required by the display panel (e.g., VCOM voltage for liquid crystal alignment, gate/source driver voltages).

1. MCU/Processor: Sends commands and pixel data to the ST7789 via the selected interface (SPI, parallel, I2C). The MCU also handles higher-level tasks like graphics rendering (if not using the ST7789’s built-in accelerator) and user input.
2. TFT Display Panel: The physical display module connected to the ST7789. The panel includes:

• Gate Drivers: Control the horizontal rows of pixels, activating each row sequentially.
• Source Drivers: Control the vertical columns of pixels, setting the color of each activated pixel.
• Liquid Crystal Layer: Adjusts light transmission based on voltage signals from the source drivers, creating the visible image.
• Backlight: Illuminates the liquid crystal layer (for transmissive panels), typically using an LED array.

1. Power Supply: Provides stable voltage to the ST7789 and the display panel. For portable devices, this is often a lithium-ion battery; for stationary devices, it may be a regulated DC power supply.

The process of displaying an image on an ST7789-powered display involves four key steps:

1. Command Initialization: The MCU sends initialization commands to the ST7789 to configure display settings (e.g., resolution, color depth, rotation). These commands include setting the display area (X/Y coordinates), gamma correction parameters, and power mode.
2. Pixel Data Transfer: The MCU sends pixel data to the ST7789, either as a continuous stream (for full-screen updates) or as partial updates (for changed regions). For SPI, data is sent serially via the MOSI pin; for parallel interfaces, data is sent in 8-bit or 16-bit chunks via the data bus.
3. Internal Processing: The ST7789 processes the pixel data, applying gamma correction and converting it to the voltage levels required by the display panel. The timing controller synchronizes the data with the panel’s refresh rate to ensure pixels are updated at the correct time.
4. Pixel Activation: The ST7789 sends signals to the panel’s gate and source drivers, activating each row and column of pixels to display the processed data. This process repeats at the display’s refresh rate (e.g., 60 times per second) to maintain the image.

Developing for the ST7789 requires configuring the controller via an MCU/processor and writing code to send commands and pixel data. Below are step-by-step guides for three popular development platforms: Arduino (beginner-friendly), ESP32 (IoT-focused), and Raspberry Pi Pico (low-power MCU).

The Arduino ecosystem offers easy-to-use libraries for the ST7789, making it ideal for beginners.

• Components Needed: Arduino Uno/Nano, ST7789-powered TFT display (e.g., 2.4-inch 240×320), jumper wires, 3.3V power supply (optional, for displays requiring more power than Arduino’s 3.3V pin).
• Wiring (SPI Interface):

1. Install the ST7789 Library: Open the Arduino IDE, go to "Sketch" → "Include Library" → "Manage Libraries," search for "Adafruit ST7735 and ST7789 Library," and install it. This library supports both ST7735 and ST7789 controllers.
2. Verify Library Compatibility: Ensure the library version is up-to-date (v1.9.0 or later) to support all ST7789 features.

#include <Adafruit_GFX.h>#include <Adafruit_ST7789.h>// Define pin connections#define TFT_CS    10#define TFT_DC     9#define TFT_RST    8#define TFT_BL     7// Initialize ST7789 display (240x320 resolution)Adafruit_ST7789 tft = Adafruit_ST7789(TFT_CS, TFT_DC, TFT_RST);void setup() {  Serial.begin(9600);    // Initialize display  tft.init(240, 320);  // 240x320 resolution  tft.setRotation(1);  // Rotate display 90° (0 = 0°, 1 = 90°, 2 = 180°, 3 = 270°)    // Turn on backlight  pinMode(TFT_BL, OUTPUT);  digitalWrite(TFT_BL, HIGH);    // Clear screen with black  tft.fillScreen(ST77XX_BLACK);    // Set text properties  tft.setTextSize(2);  tft.setTextColor(ST77XX_WHITE);  tft.setCursor(10, 10);    // Display text  tft.println("ST7789 Display");  tft.println("240x320 Resolution");    // Draw a rectangle  tft.drawRect(10, 50, 220, 100, ST77XX_RED);  tft.fillRect(20, 60, 200, 80, ST77XX_BLUE);    // Draw a circle  tft.drawCircle(120, 200, 40, ST77XX_GREEN);  tft.fillCircle(120, 200, 30, ST77XX_YELLOW);}void loop() {  // Blink backlight every 2 seconds  digitalWrite(TFT_BL, LOW);  delay(1000);  digitalWrite(TFT_BL, HIGH);  delay(1000);}

The ESP32 is a powerful IoT MCU with built-in Wi-Fi and Bluetooth, making it ideal for connected ST7789 display projects (e.g., smart home dashboards).

• Components Needed: ESP32 DevKitC, ST7789-powered TFT display (240×320), jumper wires.
• Wiring (SPI Interface):

1. Install ESP32 Board Package: In the Arduino IDE, go to "File" → "Preferences," add the ESP32 board URL (https://dl.espressif.com/dl/package_esp32_index.json) to "Additional Boards Manager URLs," then install the "esp32" package via "Tools" → "Board" → "Boards Manager."
2. Install ST7789 Library: Use the same "Adafruit ST7735 and ST7789 Library" as the Arduino platform.

#include <WiFi.h>#include <Adafruit_GFX.h>#include <Adafruit_ST7789.h>// Wi-Fi credentials (replace with your network)const char* ssid = "YOUR_WIFI_SSID";const char* password = "YOUR_WIFI_PASSWORD";// Pin definitions#define TFT_CS    5#define TFT_DC    2#define TFT_RST   4#define TFT_BL    15// Initialize displayAdafruit_ST7789 tft = Adafruit_ST7789(TFT_CS, TFT_DC, TFT_RST);void setup() {  Serial.begin(115200);    // Initialize display  tft.init(240, 320);  tft.setRotation(1);  tft.fillScreen(ST77XX_BLACK);    // Turn on backlight  pinMode(TFT_BL, OUTPUT);  digitalWrite(TFT_BL, HIGH);    // Connect to Wi-Fi  tft.setTextSize(2);  tft.setTextColor(ST77XX_WHITE);  tft.setCursor(10, 10);  tft.println("Connecting to Wi-Fi:");  tft.println(ssid);    WiFi.begin(ssid, password);  while (WiFi.status() != WL_CONNECTED) {    delay(500);    Serial.print(".");  }    // Display Wi-Fi connection details  tft.fillScreen(ST77XX_BLACK);  tft.setCursor(10, 10);  tft.println("Wi-Fi Connected!");  tft.println("IP Address:");  tft.setTextSize(1);  tft.println(WiFi</doubaocanvas>