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.

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.
| Display | Resolutie | Typisch gebruik |
|---|---|---|
| 1,14 inch | 135x240 | ESP32-boards met ingebouwd scherm, zoals de TTGO T-Display |
| 1,3 inch en 1,54 inch | 240x240 | Smartwatches, kleine meters, vierkante interfaces |
| 1,69 inch | 240x280 | Horlogeschermen met afgeronde hoeken |
| 1,9 inch | 170x320 | Lange, smalle statusbalken |
| 2,0 inch | 240x320 | Menu's, grafieken en kleine gameschermen |
| Eigenschap | Waarde |
|---|---|
| Driverchip | ST7789 (Sitronix) |
| Panel | IPS, brede kijkhoek |
| Kleuren | 65.000 (RGB565), de chip ondersteunt tot 262.000 |
| Interface | 4-draads SPI (SCK, MOSI, DC, CS) plus RESET |
| Voeding | 3,3 V op de meeste modules |
| Logisch niveau | 3,3 V |
| Stroom | Ongeveer 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.
| Modulepin | Functie | ESP32 (TFT_eSPI) | Arduino Uno (Adafruit) | Raspberry Pi Pico |
|---|---|---|---|---|
| GND | Massa | GND | GND | GND |
| VCC | Voeding | 3V3 | 3.3V | 3V3 (OUT) |
| SCL | SPI-klok (SCK) | GPIO 18 | D13 | GP18 |
| SDA | SPI-data (MOSI) | GPIO 23 | D11 | GP19 |
| RES | Reset | GPIO 4 | D8 | GP21 |
| DC | Keuze tussen data of commando | GPIO 2 | D9 | GP20 |
| CS | Chipselectie (indien aanwezig) | GPIO 5 | D10 | GP17 |
| BLK | Achtergrondverlichting | GPIO 32 | 3.3V | GP22 |
TFT_eSPI installeren en User_Setup.h instellen

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:
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- Installeer de TFT_eSPI-bibliotheek en vervang User_Setup.h door de regels hierboven.
- Heb je een display van 240x320, zet dan TFT_HEIGHT op 320; zet bij een module zonder CS-pin TFT_CS op -1.
- 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.
- Sluit de Arduino IDE en open hem opnieuw; de bibliotheekinstellingen worden tijdens het compileren gelezen.
- Upload de eerste testsketch hieronder; je zou tekst en gekleurde vormen op het scherm moeten zien.
Eerste test: tekst, vormen en kleuren
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).
| Functie | Wat doet ze? |
|---|---|
| fillScreen(kleur) | Vult het hele scherm |
| drawPixel(x, y, kleur) | Eén enkele pixel |
| drawLine / drawWideLine | Dunne of dikke lijn |
| drawRect / fillRect / fillRoundRect | Rechthoek, gevuld en met afgeronde hoeken |
| drawCircle / fillCircle | Cirkel |
| fillTriangle | Gevulde driehoek |
| drawString / drawNumber / drawFloat | Tekst, 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.
| Spritegrootte | 16-bits | 8-bits |
|---|---|---|
| 240x240 (volledig scherm) | 115,2 KB | 57,6 KB |
| 240x320 (volledig scherm) | 153,6 KB | 76,8 KB |
| 220x120 (klokgebied) | 52,8 KB | 26,4 KB |
| 100x50 (enkele waarde) | 10 KB | 5 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.
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.
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.
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.
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 = -dxDe 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
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| Scherm helemaal zwart, geen achtergrondverlichting | BLK niet aangesloten of LOW | Sluit BLK aan op 3,3 V of op de TFT_BL-pin, met TFT_BACKLIGHT_ON op HIGH |
| Achtergrondverlichting aan maar geen beeld | User_Setup.h staat nog op ILI9341 of is door een update teruggezet | Controleer de regel ST7789_DRIVER en de pins opnieuw |
| Achtergrondverlichting aan, geen beeld (module zonder CS) | Verkeerde SPI-modus | Zet TFT_CS op -1; gebruik bij Adafruit init(240, 240, SPI_MODE3) |
| Er gebeurt helemaal niets | SCL 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 niet | Resetpin zweeft, lange draden of SPI te snel | Sluit RES aan, kort de draden in, verlaag SPI_FREQUENCY naar 27 MHz |
| Kleuren zien eruit als een negatief | Instelling voor kleurinversie past niet bij het paneel | Probeer TFT_INVERSION_OFF of TFT_INVERSION_ON |
| Rood en blauw verwisseld | Het paneel gebruikt BGR-volgorde | Schakel de regel TFT_RGB_ORDER TFT_BGR in |
| Een ruisende band op een deel van het scherm | Verkeerde hoogte (320 op een paneel van 240x240) of rotatie-offset | Stel TFT_HEIGHT juist in, test met setRotation |
| ESP32 crasht bij tft.init() | Gemelde incompatibiliteit met ESP32-core 3.x | Probeer een 2.0.x-core uit de Boards Manager of stap over op de bibliotheek LovyanGFX |
| Display wordt heet of gaat kapot op de Uno | Logisch niveau van 5 V | Gebruik een niveauconverter |
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.
Projecten om hierna te bouwen
Alle projecten bekijken
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.

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).

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.

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.

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.

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.

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.

Paddleballspel - SSD1306
Een bal, twee batjes en jij: op een klein OLED-scherm speel je tafeltennis, een van de allereerste videogames.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

