Componenten · 10 min leestijd

ST7789 ESP32: IPS-kleurendisplay met TFT_eSPI, sprites en klok

ST7789 ESP32-gids: TFT_eSPI en User_Setup.h, SPI-pins met label SCL/SDA, flikkervrije sprite-meter en klok, Adafruit op de Uno, Pico en oplossingen voor een zwart scherm.

Het duo ST7789 ESP32 is de goedkoopste manier om een klein project een kleureninterface te geven met de kwaliteit van een telefoonscherm. De ST7789 is een TFT-driverchip van Sitronix en zit in de meeste IPS-displays van 1,3 inch 240x240, 1,54 inch 240x240, 1,69 inch 240x280 en 2,0 inch 240x320 die te koop zijn. Dankzij het IPS-paneel zien de kleuren er vanuit elke hoek levendig uit; met 65.000 kleuren, een hoge resolutie en een snelle SPI-verbinding teken je meters, grafieken en animaties die met een OLED of tekst-LCD niet kunnen.

In deze gids zie je stap voor stap hoe je de ST7789 met de TFT_eSPI-bibliotheek op een ESP32 aansluit, hoe je User_Setup.h instelt (het verwarrendste deel van de bibliotheek), waarom de module SPI is en geen I2C, ook al staat er SCL en SDA, hoe je zonder flikkering animeert met een sprite, en hoe je een analoge sensormeter en een klokinterface op basis van NTP bouwt. We behandelen ook de Adafruit_ST7789-bibliotheek voor de Arduino Uno, een MicroPython-driver zonder bibliotheek voor de Raspberry Pi Pico en alle oorzaken van een zwart scherm.

ST7789 kleuren-TFT-displaymodule
ST7789 IPS TFT-module: 240x240 pixels, 65.000 kleuren en een SPI-verbinding; met een ESP32 tekent hij vloeiende graphics.

Wat is de ST7789 en welke displays gebruiken hem?

De ST7789 is een driverchip die elke pixel van het display aanstuurt en commando's van de microcontroller omzet in beeld. Binnenin zit een framegeheugen van 240x320 pixels; kleinere displays gebruiken maar een deel daarvan. Kleuren worden meestal verstuurd in RGB565-formaat, dat is 16 bits per pixel (5 bits rood, 6 bits groen, 5 bits blauw). De communicatie loopt via 4-draads SPI en de chip kan klokfrequenties van ongeveer 60 MHz aan; in de praktijk is 40 MHz een veilige waarde met de ESP32. Bij die snelheid is een volledig 240x240-frame 921.600 bits en wordt het in ongeveer 23 ms verstuurd, dus je kunt boven de 40 frames per seconde uitkomen.

DisplayResolutieTypisch gebruik
1,14 inch135x240ESP32-boards met ingebouwd scherm, zoals de TTGO T-Display
1,3 inch en 1,54 inch240x240Smartwatches, kleine meters, vierkante interfaces
1,69 inch240x280Horlogeschermen met afgeronde hoeken
1,9 inch170x320Lange, smalle statusbalken
2,0 inch240x320Menu's, grafieken en kleine gameschermen
EigenschapWaarde
DriverchipST7789 (Sitronix)
PanelIPS, brede kijkhoek
Kleuren65.000 (RGB565), de chip ondersteunt tot 262.000
Interface4-draads SPI (SCK, MOSI, DC, CS) plus RESET
Voeding3,3 V op de meeste modules
Logisch niveau3,3 V
StroomOngeveer 20–40 mA inclusief achtergrondverlichting

Pins: er staat SCL en SDA, maar dit display is SPI

Goedkope ST7789-modules van 1,3 inch hebben de labels GND, VCC, SCL, SDA, RES, DC, BLK; sommige hebben ook CS. De labels SCL en SDA verwarren beginners meer dan iets anders: dit display gebruikt geen I2C, maar SPI. SCL is eigenlijk de SPI-kloklijn (SCK) en SDA is de datalijn (MOSI). Als je ze op de I2C-pins van de ESP32 aansluit, GPIO 21 en 22, werkt het display nooit. Hoe SPI werkt leggen we uit in de gids wat is SPI.

ModulepinFunctieESP32 (TFT_eSPI)Arduino Uno (Adafruit)Raspberry Pi Pico
GNDMassaGNDGNDGND
VCCVoeding3V33.3V3V3 (OUT)
SCLSPI-klok (SCK)GPIO 18D13GP18
SDASPI-data (MOSI)GPIO 23D11GP19
RESResetGPIO 4D8GP21
DCKeuze tussen data of commandoGPIO 2D9GP20
CSChipselectie (indien aanwezig)GPIO 5D10GP17
BLKAchtergrondverlichtingGPIO 323.3VGP22
De ST7789 is een chip van 3,3 V. De ESP32 en Pico sluit je direct aan, maar de pins van de Arduino Uno geven 5 V af, wat het display geleidelijk of meteen kan beschadigen. Gebruik je hem met een Uno, zet dan een niveauconverter zoals een 74HC4050 op de lijnen SCL, SDA, RES, DC en CS. Modules zonder CS-pin hebben bovendien SPI-modus 3 nodig; TFT_eSPI stelt dit automatisch in voor de ST7789, maar bij de Adafruit-bibliotheek moet je SPI_MODE3 aan init() meegeven.

TFT_eSPI installeren en User_Setup.h instellen

ESP32-ontwikkelboard
ESP32: met zijn snelle SPI en veel RAM is dit het beste board voor de ST7789.

TFT_eSPI, geschreven door Bodmer, is een van de snelste TFT-bibliotheken voor de ESP32. Zoek in de Library Manager naar TFT_eSPI en installeer hem. Anders dan bij andere bibliotheken stel je het displaytype en de pins niet in je sketch in, maar in het bestand User_Setup.h in de bibliotheekmap. Het bestand staat in Documents > Arduino > libraries > TFT_eSPI en is standaard ingesteld voor een ILI9341-display. Open het in een teksteditor en vervang de inhoud door het volgende:

C++ (Arduino IDE)
1// User_Setup.h: ST7789 240x240 + ESP32 (dosyanın tamamını bununla değiştir / replace the whole file with this)
2#define ST7789_DRIVER                // sürücü yonga / driver chip
3#define TFT_WIDTH  240
4#define TFT_HEIGHT 240               // 240x320 ekranda 320 / 320 for a 240x320 panel
5
6#define TFT_MOSI 23                  // modüldeki SDA / SDA on the module
7#define TFT_SCLK 18                  // modüldeki SCL / SCL on the module
8#define TFT_CS    5                  // CS pini yoksa -1 / -1 if the module has no CS pin
9#define TFT_DC    2                  // veri-komut / data-command
10#define TFT_RST   4                  // reset (RES)
11#define TFT_BL   32                  // arka ışık (BLK) / backlight (BLK)
12#define TFT_BACKLIGHT_ON HIGH
13
14// #define TFT_RGB_ORDER TFT_BGR     // kırmızı ve mavi yer değiştirmişse aç / enable if red and blue are swapped
15// #define TFT_INVERSION_OFF         // renkler negatif görünüyorsa aç / enable if colours look inverted
16
17#define LOAD_GLCD                    // 8 px yazı tipi / 8 px font
18#define LOAD_FONT2                   // 16 px
19#define LOAD_FONT4                   // 26 px
20#define LOAD_FONT7                   // 48 px 7 segment rakam / 48 px 7-segment digits
21#define LOAD_GFXFF                   // Adafruit GFX yazı tipleri / Adafruit GFX fonts
22#define SMOOTH_FONT
23
24#define SPI_FREQUENCY 40000000       // 40 MHz; sorun olursa 27000000 / 40 MHz; drop to 27000000 if unstable
  1. Installeer de TFT_eSPI-bibliotheek en vervang User_Setup.h door de regels hierboven.
  2. Heb je een display van 240x320, zet dan TFT_HEIGHT op 320; zet bij een module zonder CS-pin TFT_CS op -1.
  3. Sluit het display aan zoals in de tabel: SCL op GPIO 18, SDA op GPIO 23, RES op GPIO 4, DC op GPIO 2, CS op GPIO 5, BLK op GPIO 32.
  4. Sluit de Arduino IDE en open hem opnieuw; de bibliotheekinstellingen worden tijdens het compileren gelezen.
  5. Upload de eerste testsketch hieronder; je zou tekst en gekleurde vormen op het scherm moeten zien.
Als je de bibliotheek bijwerkt, wordt User_Setup.h ook teruggezet en op een dag blijft je display ineens donker. Bewaar een kopie van je instellingenbestand in je projectmap, of voeg je eigen bestand toe aan de map User_Setups en selecteer het in User_Setup_Select.h. Dan hoef je na een update maar één regel te wijzigen.

Eerste test: tekst, vormen en kleuren

C++ (Arduino IDE)
1#include <TFT_eSPI.h>                // ayarlar User_Setup.h içinde / settings live in User_Setup.h
2
3TFT_eSPI tft = TFT_eSPI();
4
5void setup() {
6  tft.init();
7  tft.setRotation(0);                // 0-3: ekranı 90'ar derece döndürür / rotates in 90° steps
8  tft.fillScreen(TFT_BLACK);
9
10  tft.setTextDatum(MC_DATUM);        // metni ortadan hizala / centre-align text
11  tft.setTextColor(TFT_WHITE, TFT_BLACK);
12  tft.drawString("BlueGrays", 120, 30, 4);        // metin, x, y, yazı tipi / text, x, y, font
13  tft.drawString("ST7789 240x240", 120, 60, 2);
14
15  tft.fillRect(20, 90, 60, 60, TFT_RED);           // dolu kare / filled square
16  tft.fillCircle(120, 120, 30, TFT_GREEN);         // dolu daire / filled circle
17  tft.fillTriangle(170, 150, 200, 90, 230, 150, TFT_BLUE);
18  tft.drawRoundRect(10, 170, 220, 50, 10, TFT_YELLOW);
19
20  uint16_t orange = tft.color565(255, 140, 0);     // kendi rengin (RGB565) / your own colour (RGB565)
21  tft.setTextColor(orange, TFT_BLACK);
22  tft.drawString("R  G  B", 120, 195, 4);
23}
24
25void loop() {
26}

In TFT_eSPI beginnen de coördinaten linksboven bij (0, 0), en de rechterbenedenhoek van een display van 240x240 is (239, 239). Het laatste getal in drawString(text, x, y, font) kiest het lettertype: 1 is een klein font van 8 pixels, 2 is 16 pixels, 4 is 26 pixels en 7 is een 7-segmentcijferfont van 48 pixels. setTextDatum(MC_DATUM) centreert de tekst op het opgegeven punt, wat erg handig is voor meters en klokken. Kleuren geef je op met kant-en-klare namen zoals TFT_RED en TFT_GREEN, of met eigen tinten via color565(r, g, b).

FunctieWat doet ze?
fillScreen(kleur)Vult het hele scherm
drawPixel(x, y, kleur)Eén enkele pixel
drawLine / drawWideLineDunne of dikke lijn
drawRect / fillRect / fillRoundRectRechthoek, gevuld en met afgeronde hoeken
drawCircle / fillCircleCirkel
fillTriangleGevulde driehoek
drawString / drawNumber / drawFloatTekst, geheel getal en decimaal getal
setRotation(0-3)Draait het scherm in stappen van 90°

Flikkervrije animatie met sprites

Als je direct op het scherm tekent, moet je om iets bij te werken eerst de oude versie wissen en dan de nieuwe tekenen. Tussen die twee stappen is het scherm even leeg, en het oog ziet dat als flikkering. Een sprite lost het probleem op: je tekent eerst op een onzichtbaar canvas in het RAM van de ESP32, en als het frame helemaal klaar is, stuur je het in één keer naar het scherm met pushSprite(). Een half afgemaakte tekening verschijnt nooit op het display.

De enige prijs van een sprite is geheugen. Een sprite met 16-bits kleur gebruikt 2 bytes per pixel: een sprite van 240x240 over het hele scherm neemt 115.200 bytes in beslag en eentje van 240x320 neemt 153.600 bytes. De ESP32 heeft in totaal 520 KB RAM, maar het grootste blok dat in één stuk kan worden gereserveerd is vaak zo'n 110 KB, dus een schermvullende 16-bits sprite past mogelijk niet op een board zonder PSRAM. De oplossing is terugschakelen naar 8-bits kleur met setColorDepth(8) (57,6 KB voor 240x240) of alleen het veranderende gebied tekenen, bijvoorbeeld de klokcijfers, als kleine sprite. createSprite() geeft nullptr terug als het geen geheugen vindt; dit controleren voorkomt stille fouten.

Spritegrootte16-bits8-bits
240x240 (volledig scherm)115,2 KB57,6 KB
240x320 (volledig scherm)153,6 KB76,8 KB
220x120 (klokgebied)52,8 KB26,4 KB
100x50 (enkele waarde)10 KB5 KB

Project: een analoge sensormeter

De sketch hieronder zet een potmeter op GPIO 34 om in een waarde van 0 tot 100 en toont die met een naald op een boog van 270 graden, zoals een meter op het dashboard van een auto. Schaalstreepjes boven 80 zijn rood. In plaats van de potmeter kun je dezelfde functie een temperatuur, luchtvochtigheid, gas- of bodemvochtmeting geven. Omdat de sprite elk frame helemaal opnieuw wordt gewist en getekend, beweegt de naald soepel en flikkert hij nooit.

C++ (Arduino IDE)
1#include <TFT_eSPI.h>
2
3TFT_eSPI tft = TFT_eSPI();
4TFT_eSprite spr = TFT_eSprite(&tft);  // bellekteki çizim alanı / off-screen drawing area
5
6const int POT_PIN = 34;               // potansiyometre ya da sensör / potentiometer or sensor
7const int CX = 120, CY = 130, R = 100;
8float smooth = 0;
9
10void pointAt(float v, int radius, int &x, int &y) {   // 0-100 değeri yay üzerindeki noktaya çevir / value to a point on the arc
11  float a = radians(225 - v * 2.7);   // 270 derecelik yay / 270-degree arc
12  x = CX + cos(a) * radius;
13  y = CY - sin(a) * radius;
14}
15
16void drawGauge(int value) {
17  spr.fillSprite(TFT_BLACK);          // her kare temiz başlar / every frame starts clean
18  for (int v = 0; v <= 100; v += 5) { // ölçek çizgileri / scale ticks
19    int x0, y0, x1, y1;
20    pointAt(v, R, x0, y0);
21    pointAt(v, (v % 10 == 0) ? R - 14 : R - 7, x1, y1);
22    spr.drawLine(x0, y0, x1, y1, v >= 80 ? TFT_RED : TFT_LIGHTGREY);
23  }
24  int nx, ny;
25  pointAt(value, R - 20, nx, ny);
26  spr.drawWideLine(CX, CY, nx, ny, 4, TFT_ORANGE);  // ibre / needle
27  spr.fillCircle(CX, CY, 8, TFT_DARKGREY);
28
29  spr.setTextDatum(MC_DATUM);
30  spr.setTextColor(TFT_WHITE);
31  spr.drawNumber(value, CX, CY + 55, 7);            // 7 segment rakam / 7-segment digits
32  spr.drawString("%", CX + 62, CY + 62, 4);
33  spr.pushSprite(0, 0);               // tek seferde ekrana bas / push to the screen in one go
34}
35
36void setup() {
37  tft.init();
38  tft.fillScreen(TFT_BLACK);
39  spr.setColorDepth(8);               // 8 bit: 57,6 KB, 16 bit olsa 115 KB / 8-bit: 57.6 KB instead of 115 KB
40  if (spr.createSprite(240, 240) == nullptr) {      // bellek yetmezse / if memory runs out
41    tft.drawString("Sprite RAM yok", 10, 10, 2);
42    while (true) delay(100);
43  }
44}
45
46void loop() {
47  float raw = analogRead(POT_PIN) * 100.0 / 4095.0; // 0-100 aralığı / 0-100 range
48  smooth += (raw - smooth) * 0.2;                   // titremeyi yumuşat / smooth out jitter
49  drawGauge((int)smooth);
50  delay(20);                                        // yaklaşık 40 kare/sn / about 40 frames per second
51}

De functie pointAt() in de code zet een waarde van 0 tot 100 om in een punt op de boog: 0 komt overeen met 225 graden (linksonder) en 100 met −45 graden (rechtsonder). Omdat de y-as op het scherm naar beneden groeit, staat er een minteken voor de sinus. De variabele smooth filtert kleine schommelingen van de ADC weg; verlaag de factor 0.2 en de naald beweegt trager, verhoog hem en hij reageert sneller. Meer over de ADC van de ESP32 lees je in de gids wat is ADC.

Project: een klokinterface op basis van NTP

Een van de populairste toepassingen van de ST7789 is een bureauklok. De sketch hieronder verbindt de ESP32 met Wi-Fi, haalt de tijd op bij NTP-servers op internet in de Turkse tijd en toont hem in grote 7-segmentcijfers. Dit keer gebruiken we in plaats van een schermvullende sprite een sprite van 220x120 die alleen het klokgebied beslaat; de dagnaam schrijven we direct naar het scherm, omdat die maar één keer per dag verandert. Pas TZ_INFO aan voor je eigen tijdzone; de details over NTP en tijdzone-instellingen staan in de gids ESP32 NTP-tijd.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <time.h>
3#include <TFT_eSPI.h>
4
5const char* WIFI_SSID = "AgAdi";
6const char* WIFI_PASS = "Sifre123";
7const char* TZ_INFO   = "<+03>-3";               // Türkiye UTC+3 / Turkey UTC+3
8const char* DAYS[] = {"Pazar", "Pazartesi", "Sali", "Carsamba", "Persembe", "Cuma", "Cumartesi"};
9
10TFT_eSPI tft = TFT_eSPI();
11TFT_eSprite clockSpr = TFT_eSprite(&tft);        // yalnız saat bölgesi / clock area only
12int lastSecond = -1;
13
14void setup() {
15  tft.init();
16  tft.fillScreen(TFT_NAVY);
17  tft.setTextDatum(MC_DATUM);
18  tft.setTextColor(TFT_WHITE, TFT_NAVY);
19  tft.drawString("Wi-Fi...", 120, 120, 4);
20
21  WiFi.begin(WIFI_SSID, WIFI_PASS);
22  while (WiFi.status() != WL_CONNECTED) delay(300);
23  configTzTime(TZ_INFO, "pool.ntp.org", "time.cloudflare.com");
24
25  tft.fillScreen(TFT_NAVY);
26  clockSpr.createSprite(220, 120);               // 16 bit: 52,8 KB / 16-bit: 52.8 KB
27  clockSpr.setTextDatum(MC_DATUM);
28}
29
30void loop() {
31  struct tm t;
32  if (!getLocalTime(&t, 100) || t.tm_sec == lastSecond) return;   // saniye değişince çiz / draw on each new second
33  lastSecond = t.tm_sec;
34
35  char hm[6], sec[3], date[11];
36  strftime(hm, sizeof(hm), "%H:%M", &t);
37  strftime(sec, sizeof(sec), "%S", &t);
38  strftime(date, sizeof(date), "%d.%m.%Y", &t);
39
40  clockSpr.fillSprite(TFT_NAVY);
41  clockSpr.fillRoundRect(0, 0, 220, 120, 14, TFT_BLACK);
42  clockSpr.setTextColor(TFT_CYAN);
43  clockSpr.drawString(hm, 95, 45, 7);            // büyük saat:dakika / big hours:minutes
44  clockSpr.setTextColor(TFT_ORANGE);
45  clockSpr.drawString(sec, 195, 55, 4);          // saniye / seconds
46  clockSpr.setTextColor(TFT_WHITE);
47  clockSpr.drawString(date, 110, 100, 4);
48  clockSpr.pushSprite(10, 40);                   // titremeden güncelle / update without flicker
49
50  tft.setTextColor(TFT_YELLOW, TFT_NAVY);
51  tft.fillRect(0, 175, 240, 30, TFT_NAVY);
52  tft.drawString(DAYS[t.tm_wday], 120, 190, 4);  // gün adı / day name
53}

De klok wordt alleen opnieuw getekend als de seconde verandert, dus terwijl loop() rondgaat heeft de processor tijd voor andere taken. De ingebouwde TFT_eSPI-fonts hebben geen tekens met accenten, daarom zijn de Turkse dagnamen in de code zonder speciale letters geschreven; vertaal ze gerust naar je eigen taal. Wil je letters met accenten, dan kun je met de functie smooth font van TFT_eSPI je eigen font maken en laden. Om een weerregel aan deze klok toe te voegen combineer je hem gewoon met de Open-Meteo-code uit de gids ESP32-weer-API.

ST7789 met de Arduino Uno: Adafruit_ST7789

TFT_eSPI werkt niet op de Arduino Uno; hier gebruik je de Adafruit ST7735 and ST7789 Library samen met Adafruit GFX. De 2 KB RAM van de Uno is niet genoeg voor zelfs maar één sprite, dus alles wordt direct op het scherm getekend en dat is merkbaar trager dan op de ESP32. Voor menu's, cijfers en eenvoudige graphics is het nog steeds prima. De hardware-SPI-pins liggen vast: SDA (MOSI) gaat naar D11 en SCL (SCK) naar D13; voor CS, DC en RST kies je zelf digitale pins.

C++ (Arduino IDE)
1#include <Adafruit_GFX.h>
2#include <Adafruit_ST7789.h>
3#include <SPI.h>
4
5#define TFT_CS   10                  // CS pini yoksa -1 / -1 if there is no CS pin
6#define TFT_DC    9
7#define TFT_RST   8
8// SDA (MOSI) -> D11, SCL (SCK) -> D13: donanım SPI / hardware SPI
9
10Adafruit_ST7789 tft = Adafruit_ST7789(TFT_CS, TFT_DC, TFT_RST);
11
12void setup() {
13  tft.init(240, 240);                // CS'siz modülde: tft.init(240, 240, SPI_MODE3) / without CS
14  tft.setRotation(0);
15  tft.fillScreen(ST77XX_BLACK);
16  tft.setTextColor(ST77XX_WHITE);
17  tft.setTextSize(3);
18  tft.setCursor(20, 20);
19  tft.print(F("BlueGrays"));
20  tft.setTextSize(2);
21  tft.setCursor(20, 70);
22  tft.print(F("A0 degeri:"));
23}
24
25void loop() {
26  int value = analogRead(A0);
27  tft.setTextColor(ST77XX_YELLOW, ST77XX_BLACK);   // arka plan rengi eski rakamı siler / background colour erases old digits
28  tft.setTextSize(5);
29  tft.setCursor(20, 110);
30  if (value < 1000) tft.print(' ');                 // basamak sayısı değişince boşluk / pad when digits shrink
31  if (value < 100)  tft.print(' ');
32  if (value < 10)   tft.print(' ');
33  tft.print(value);
34  delay(200);
35}

Deze sketch laat de Uno-vriendelijke manier zien om flikkering te voorkomen: als setTextColor(tekstkleur, achtergrondkleur) met twee kleuren wordt aangeroepen, wordt elk teken samen met zijn eigen achtergrond getekend en overschrijft het het oude cijfer. Het scherm hoeft niet gewist te worden en het getal verandert zonder flikkeren. Vooraan worden spaties toegevoegd zodat er geen resten van oude cijfers blijven staan als het getal korter wordt. Wil je een vergelijkbaar display op een aanraakscherm van 2,4 inch, dan volgt de gids ILI9341 TFT-display dezelfde logica.

ST7789 met de Raspberry Pi Pico (MicroPython)

MicroPython heeft geen ingebouwde ST7789-driver, maar de commando's van de chip zijn eenvoudig genoeg om zelf een kleine driver te schrijven. De 264 KB RAM van de Pico is genoeg voor een framebuffer van 115 KB die het hele display van 240x240 dekt. De code hieronder initialiseert het display, tekent tekst en vormen in de buffer met de module framebuf van MicroPython en verstuurt de buffer in één keer via SPI; een bewegend vierkant laat zien hoe je animeert. De bedrading gebruikt de SPI0-bus: SCL naar GP18 en SDA naar GP19.

MicroPython
1from machine import Pin, SPI
2import framebuf
3import time
4
5W, H = 240, 240
6spi = SPI(0, baudrate=40_000_000, polarity=1, phase=1, sck=Pin(18), mosi=Pin(19))  # SPI mod 3 / SPI mode 3
7cs = Pin(17, Pin.OUT, value=1)           # CS'siz modülde boşta kalır / unused on modules without CS
8dc = Pin(20, Pin.OUT)
9rst = Pin(21, Pin.OUT, value=1)
10bl = Pin(22, Pin.OUT, value=1)           # arka ışık açık / backlight on
11
12def cmd(c, data=None):                   # komut + isteğe bağlı veri / command + optional data
13    cs(0)
14    dc(0)
15    spi.write(bytes([c]))
16    if data:
17        dc(1)
18        spi.write(data)
19    cs(1)
20
21def init():
22    rst(0); time.sleep_ms(50); rst(1); time.sleep_ms(150)
23    cmd(0x01); time.sleep_ms(150)        # SWRESET: yazılım reseti / software reset
24    cmd(0x11); time.sleep_ms(120)        # SLPOUT: uykudan çık / exit sleep
25    cmd(0x3A, b'\x55')                   # COLMOD: 16 bit RGB565
26    cmd(0x36, b'\x00')                   # MADCTL: yön, RGB sırası / orientation, RGB order
27    cmd(0x21)                            # INVON: IPS paneller için / for IPS panels
28    cmd(0x13)                            # NORON: normal mod / normal mode
29    cmd(0x29); time.sleep_ms(50)         # DISPON: ekranı aç / display on
30
31def show(buf):
32    cmd(0x2A, bytes([0, 0, 0, W - 1]))   # CASET: sütun 0-239 / columns 0-239
33    cmd(0x2B, bytes([0, 0, 0, H - 1]))   # RASET: satır 0-239 / rows 0-239
34    cmd(0x2C, buf)                       # RAMWR: tamponu gönder / send the buffer
35
36def rgb(r, g, b):                        # RGB565, bayt sırası ekrana göre çevrilmiş / byte-swapped for the panel
37    c = ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3)
38    return ((c & 0xFF) << 8) | (c >> 8)
39
40init()
41buf = bytearray(W * H * 2)               # 115.200 bayt / 115,200 bytes
42fb = framebuf.FrameBuffer(buf, W, H, framebuf.RGB565)
43
44x, dx = 0, 4
45while True:
46    fb.fill(rgb(0, 0, 40))
47    fb.text("BlueGrays", 84, 20, rgb(255, 255, 255))
48    fb.text("Pico + ST7789", 68, 40, rgb(0, 200, 255))
49    fb.rect(20, 200, 200, 20, rgb(255, 255, 0))
50    fb.fill_rect(20 + x, 100, 40, 40, rgb(255, 60, 0))   # kayan kare / moving square
51    show(buf)                            # tüm kareyi tek seferde gönder / send the whole frame at once
52    x += dx
53    if x <= 0 or x >= 160:
54        dx = -dx

De functie rgb() in de code lost een belangrijk detail op: framebuf slaat kleuren in het geheugen op met de lage byte eerst, terwijl de ST7789 de hoge byte eerst verwacht. Als je de bytes niet omwisselt, ziet rood er blauw uit en blauw groenig. Het commando 0x36 (MADCTL) stelt de displayoriëntatie en de RGB- of BGR-volgorde in; als je het beeld op een paneel van 240x240 180 graden draait, schuift het beeld naar het onderste deel van het geheugen, dus je moet een offset van 80 pixels bij het rijadres optellen. Geef je de voorkeur aan de Arduino IDE, installeer dan de arduino-pico-core op de Pico en gebruik TFT_eSPI met de RP2040-instellingen. Ben je nieuw met MicroPython, begin dan met de gids basis van MicroPython.

Zwart scherm en andere problemen: tabel om problemen op te lossen

SymptoomWaarschijnlijke oorzaakOplossing
Scherm helemaal zwart, geen achtergrondverlichtingBLK niet aangesloten of LOWSluit BLK aan op 3,3 V of op de TFT_BL-pin, met TFT_BACKLIGHT_ON op HIGH
Achtergrondverlichting aan maar geen beeldUser_Setup.h staat nog op ILI9341 of is door een update teruggezetControleer de regel ST7789_DRIVER en de pins opnieuw
Achtergrondverlichting aan, geen beeld (module zonder CS)Verkeerde SPI-modusZet TFT_CS op -1; gebruik bij Adafruit init(240, 240, SPI_MODE3)
Er gebeurt helemaal nietsSCL en SDA aangesloten op de I2C-pins (21, 22)Sluit SCL aan op GPIO 18 en SDA op GPIO 23
Werkt af en toe wel, af en toe nietResetpin zweeft, lange draden of SPI te snelSluit RES aan, kort de draden in, verlaag SPI_FREQUENCY naar 27 MHz
Kleuren zien eruit als een negatiefInstelling voor kleurinversie past niet bij het paneelProbeer TFT_INVERSION_OFF of TFT_INVERSION_ON
Rood en blauw verwisseldHet paneel gebruikt BGR-volgordeSchakel de regel TFT_RGB_ORDER TFT_BGR in
Een ruisende band op een deel van het schermVerkeerde hoogte (320 op een paneel van 240x240) of rotatie-offsetStel TFT_HEIGHT juist in, test met setRotation
ESP32 crasht bij tft.init()Gemelde incompatibiliteit met ESP32-core 3.xProbeer een 2.0.x-core uit de Boards Manager of stap over op de bibliotheek LovyanGFX
Display wordt heet of gaat kapot op de UnoLogisch niveau van 5 VGebruik een niveauconverter
Verander bij een zwart scherm steeds maar één ding tegelijk. Controleer eerst of de achtergrondverlichting aangaat met alleen VCC, GND en BLK aangesloten; voer dan de eerste testsketch hierboven uit. Is de achtergrondverlichting aan en het scherm nog steeds zwart, dan zit het probleem bijna altijd in de driver-, formaat- of pindefinities in User_Setup.h.

Projectideeën met de ST7789

  • Slimme bureauklok: Toon de NTP-tijd, de kamertemperatuur van een BME280 en het weer van vandaag van internet op één scherm.
  • Sensordashboard: Presenteer temperatuur, luchtvochtigheid en gasmetingen op kleurrijke meters; laat de achtergrond rood worden als de drempel van de MQ-2 wordt overschreden.
  • Mini-spelcomputer: Speel snake, Pong of een ruimtespel met een joystick; sprites houden het spel soepel.
  • Interface voor een muziekspeler: Toon de titel van het nummer, het volume en een voortgangsbalk voor een DFPlayer Mini.
  • Grafiek in oscilloscoopstijl: Teken analogRead-waarden als een scrollende grafiek en bekijk de vorm van het signaal.
  • Display voor een kaartlezer: Toon de naam en toegangsstatus van een kaart die door een RFID RC522 is gelezen op een kleurrijke kaart.

In combinatie met een ESP32 verandert de ST7789 een display van een paar dollar in een interface die er professioneel uitziet. Als je User_Setup.h goed instelt en het idee van sprites doorhebt, kun je klokken, meters, menu's, games en elke andere interface zonder flikkering tekenen. Welk display bij jouw project past, zie je in de gids soorten Arduino-displays. In de BlueGrays-app vind je projecten met ESP32-weer, klok, kleurenmixer en parkeersensor met OLED- en LCD-displays, met stapsgewijze schakelschema's en code, en dezelfde projecten kun je met de ST7789 omzetten naar kleurenversies.

Veelgestelde vragen

Is de ST7789 I2C of SPI?

De ST7789 gebruikt SPI. De labels SCL en SDA op de module zijn misleidend: SCL is de SPI-kloklijn (SCK) en SDA is de datalijn (MOSI). Sluit ze op een ESP32 aan op GPIO 18 en GPIO 23, niet op de I2C-pins 21 en 22.

Waarom blijft mijn ST7789-display zwart?

De meest voorkomende oorzaken zijn een niet aangesloten achtergrondverlichting (BLK), User_Setup.h die nog de ILI9341-driver kiest, SCL en SDA die op de I2C-pins zijn aangesloten, en de verkeerde SPI-modus bij een module zonder CS. Controleer eerst of de achtergrondverlichting aan is en controleer dan de regels ST7789_DRIVER, TFT_WIDTH, TFT_HEIGHT en de pins in User_Setup.h.

Werkt de ST7789 op 5 V?

De ST7789-chip werkt op 3,3 V en zijn pins zijn niet 5V-tolerant. De ESP32 en Pico kun je direct aansluiten; voed de module bij een Arduino Uno met 3,3 V en zet een niveauconverter op de signaallijnen. Sommige modules hebben een regelaar, maar de datalijnen blijven 3,3 V.

Waar staat het bestand User_Setup.h van TFT_eSPI?

User_Setup.h staat in de map TFT_eSPI in je Arduino-bibliotheekmap, meestal Documents > Arduino > libraries > TFT_eSPI. De displaydriver, resolutie, pins en SPI-snelheid worden in dit bestand vastgelegd. Het wordt teruggezet als de bibliotheek wordt bijgewerkt, dus bewaar een kopie van je instellingen.

Wat is een sprite en waarom voorkomt hij flikkering?

Een sprite is een onzichtbaar tekengebied in het RAM van de ESP32. Je doet daar eerst al het tekenwerk en stuurt het als het klaar is in één keer met pushSprite() naar het scherm, zodat het tussenliggende gewiste beeld nooit verschijnt. De prijs is geheugen: bij 16-bits kleur neemt elke pixel 2 bytes in beslag.

Kan de ST7789 met een Arduino Uno worden gebruikt?

Ja, met de bibliotheken Adafruit ST7789 en Adafruit GFX, maar het tekenen is traag omdat de 2 KB RAM van de Uno niet genoeg is voor een sprite. De pins zijn 5 V, dus je hebt een niveauconverter ertussen nodig. Wil je een soepele kleureninterface, dan is de ESP32 een veel betere keuze.

Alle projecten bekijken
ESP32 HTTPClient + weer-API (met SSD1306 OLED-display)
ES-32Gevorderd
Premium

ESP32 HTTPClient + weer-API (met SSD1306 OLED-display)

In dit project doet de ESP32 via internet een REST API-aanroep naar een weer-API (wttr.in) met HTTPClient.h. Anders dan bij de I2C-LCD-versie gebruiken we hier een SSD1306 OLED-display (128×64), met grote tekst en vectoricoontjes voor een rijkere weergave. Zeven weericonen (zonnig, regenachtig, sneeuw en meer) worden direct getekend, zonder bitmapbestanden.

4.3(10)
22
ESP32 I2C-LCD-display (16x2)
ES-17Gemiddeld
Premium

ESP32 I2C-LCD-display (16x2)

In dit project sluit je een 16x2-tekens-LCD via I2C aan op de ESP32 en toon je tekst. Met I2C bedien je het scherm met slechts 2 datapinnen (SDA en SCL), in plaats van de 6+ pinnen die een klassieke parallelle aansluiting verspilt. De code toont op de eerste regel een vaste tekst en op de tweede regel een teller die elke seconde oploopt. Bij het opstarten schrijft een I2C-scanner ook het adres van het display naar de Serial Monitor (meestal 0x27 of 0x3F).

4.9(23)
40
ESP32 TM1637 4-cijferig 7-segmentdisplay
ES-23Gemiddeld
Premium

ESP32 TM1637 4-cijferig 7-segmentdisplay

We sturen met een ESP32 een 4-cijferige 7-segmentdisplaymodule met TM1637-driver aan. Met slechts 2 GPIO-pins (CLK en DIO) laten we een teller van 0 tot 9999 lopen, stellen we de helderheid in en tonen we de dubbele punt (:) in klokformaat. Dankzij de TM1637Display-bibliotheek is het aansturen van getallen, hexwaarden, segmenten en strings heel eenvoudig.

4.7(20)
32
ESP32 Deep Sleep: batterij sparen (OLED + RTC RAM-teller)
ES-33Gevorderd
Premium

ESP32 Deep Sleep: batterij sparen (OLED + RTC RAM-teller)

De Deep Sleep-modus van de ESP32 schakelt de CPU en de meeste randapparatuur uit, waardoor het stroomverbruik daalt tot ongeveer 10µA; dat is cruciaal voor IoT-apparaten op batterijen. Dit project gebruikt drie wekbronnen: een timer (15 s), een externe pin (EXT0, de knop op GPIO 33) en een touchpin (T0/GPIO 4). Tellers met RTC_DATA_ATTR blijven behouden tijdens deep sleep.

4.3(10)
16
ESP32 gebedsrakat-teller (HC-SR04 + SSD1306 OLED + 2 knoppen)
ES-34Gevorderd
Premium

ESP32 gebedsrakat-teller (HC-SR04 + SSD1306 OLED + 2 knoppen)

Weet je tijdens het gebed soms niet meer bij welke rakat je bent? Dit project is een rakat-teller die naast je gebedskleed ligt en je knielbuigingen telt als je je hand dichtbij brengt. De HC-SR04 ultrasone afstandssensor detecteert je hand, het SSD1306 OLED-display toont het aantal en met twee knoppen kies je 2, 3 of 4 rakats en reset je. Een contactdender van 2,5 seconde en een controle op "hand weg" zorgen dat geen enkele knielbuiging dubbel wordt geteld.

4.8(11)
14
ESP32 kleurenmixlamp (3 potmeters + RGB-led + OLED)
ES-36Gevorderd
Premium

ESP32 kleurenmixlamp (3 potmeters + RGB-led + OLED)

Een slimme kleurenmixlamp: draai aan 3 potmeters op de ESP32 en mix elke kleur die je wilt! Terwijl je aan de rode, groene en blauwe potmeter draait, verandert de RGB-led met gemeenschappelijke kathode meteen van kleur. Het SSD1306 OLED-display toont per kanaal de waarde van 0-255, vulbalken en de HEX-webkleurcode (zoals #FF8040) live.

4.7(6)
10
ESP32 parkeersensor (HC-SR04 + 5-ledbalk + buzzer + OLED)
ES-38Gevorderd
Premium

ESP32 parkeersensor (HC-SR04 + 5-ledbalk + buzzer + OLED)

De ESP32-versie van een parkeersensor voor auto's! De HC-SR04-ultrasoonsensor meet de afstand tot het voorwerp ervoor. Naarmate je dichterbij komt, vult een balk van 5 leds zich (groen → geel → rood) en piept de buzzer sneller. Heel dichtbij (onder 10 cm) klinkt een continu alarm en branden alle leds. Het SSD1306 OLED-display toont de live afstand in cm in grote tekst, plus een statusbericht.

14
Paddleballspel - SSD1306
AR-86Gemiddeld
Premium

Paddleballspel - SSD1306

Een bal, twee batjes en jij: op een klein OLED-scherm speel je tafeltennis, een van de allereerste videogames.

4.5(47)
65