Bauteile · 9 Min. Lesezeit

ST7789 ESP32: Farbiges IPS-Display mit TFT_eSPI, Sprites, Uhr

ST7789 ESP32 Anleitung: TFT_eSPI und User_Setup.h, SPI-Pins mit SCL/SDA-Aufdruck, flimmerfreie Anzeige und Uhr per Sprite, Adafruit am Uno, Pico, Schwarzbild.

Das Duo ST7789 ESP32 ist der günstigste Weg, einem kleinen Projekt eine farbige Oberfläche in Handyqualität zu geben. Der ST7789 ist ein TFT-Treiberchip von Sitronix und steckt in den meisten IPS-Displays im Handel mit 1,3 Zoll 240x240, 1,54 Zoll 240x240, 1,69 Zoll 240x280 und 2,0 Zoll 240x320. Dank des IPS-Panels wirken die Farben aus jedem Blickwinkel kräftig; mit 65.000 Farben, hoher Auflösung und schnellem SPI zeichnest du Anzeigen, Diagramme und Animationen, die ein OLED oder ein Zeichen-LCD nicht schaffen.

In dieser Anleitung siehst du Schritt für Schritt, wie du den ST7789 mit der Bibliothek TFT_eSPI an den ESP32 anschließt, wie du User_Setup.h einrichtest, den verwirrendsten Teil der Bibliothek, warum das Modul trotz SCL- und SDA-Aufdruck SPI und nicht I2C nutzt, wie du mit einem Sprite flimmerfrei animierst und wie eine analoge Sensoranzeige und eine NTP-Uhr entstehen. Außerdem geht es um die Bibliothek Adafruit_ST7789 für den Arduino Uno, einen bibliotheksfreien MicroPython-Treiber für den Raspberry Pi Pico und alle Ursachen für ein schwarzes Display.

ST7789-TFT-Farbdisplaymodul
ST7789-IPS-TFT-Modul: 240x240 Pixel, 65.000 Farben und SPI-Anschluss; mit dem ESP32 zeichnet es flüssige Grafiken.

Was ist der ST7789 und in welchen Displays steckt er?

Der ST7789 ist ein Treiberchip, der jedes Pixel des Displays steuert und Befehle des Mikrocontrollers in ein Bild umsetzt. Er enthält einen Bildspeicher für 240x320 Pixel; kleinere Displays nutzen nur einen Teil davon. Farben werden meist im Format RGB565 gesendet, also mit 16 Bit pro Pixel (5 Bit Rot, 6 Bit Grün, 5 Bit Blau). Die Verbindung läuft über 4-Draht-SPI, und der Chip verträgt Taktraten um 60 MHz; mit dem ESP32 sind 40 MHz in der Praxis ein sicherer Wert. Bei diesem Takt sind ein komplettes 240x240-Bild 921.600 Bit, die in etwa 23 ms übertragen werden, also sind über 40 Bilder pro Sekunde möglich.

DisplayAuflösungTypischer Einsatz
1,14 Zoll135x240ESP32-Boards mit eingebautem Display wie das TTGO T-Display
1,3 Zoll und 1,54 Zoll240x240Smartwatches, kleine Anzeigen, quadratische Oberflächen
1,69 Zoll240x280Uhrendisplays mit abgerundeten Ecken
1,9 Zoll170x320Lange, schmale Statusleisten
2,0 Zoll240x320Menüs, Diagramme und kleine Spiele
MerkmalWert
TreiberchipST7789 (Sitronix)
PanelIPS, großer Blickwinkel
Farben65.000 (RGB565), der Chip kann bis 262.000
Schnittstelle4-Draht-SPI (SCK, MOSI, DC, CS) und RESET
VersorgungBei den meisten Modulen 3,3 V
Logikpegel3,3 V
StromEtwa 20–40 mA inklusive Hintergrundbeleuchtung

Pins: SCL und SDA steht drauf, aber das Display ist SPI

Günstige 1,3-Zoll-Module mit ST7789 tragen die Aufschrift GND, VCC, SCL, SDA, RES, DC, BLK; manche haben zusätzlich CS. Die Beschriftung SCL und SDA verwirrt Einsteiger am meisten: Dieses Display nutzt nicht I2C, sondern SPI. SCL ist in Wahrheit die SPI-Taktleitung (SCK), SDA die Datenleitung (MOSI). Schließt du sie an die I2C-Pins des ESP32, GPIO 21 und 22, an, wird das Display nie funktionieren. Wie SPI funktioniert, erklären wir in der Anleitung Was ist SPI.

ModulpinAufgabeESP32 (TFT_eSPI)Arduino Uno (Adafruit)Raspberry Pi Pico
GNDMasseGNDGNDGND
VCCVersorgung3V33.3V3V3 (OUT)
SCLSPI-Takt (SCK)GPIO 18D13GP18
SDASPI-Daten (MOSI)GPIO 23D11GP19
RESResetGPIO 4D8GP21
DCDaten- oder BefehlsauswahlGPIO 2D9GP20
CSChipauswahl (falls vorhanden)GPIO 5D10GP17
BLKHintergrundbeleuchtungGPIO 323.3VGP22
Der ST7789 ist ein 3,3-V-Chip. ESP32 und Pico werden direkt angeschlossen, aber die Pins des Arduino Uno liefern 5 V, und diese Spannung kann das Display nach und nach oder sofort beschädigen. Am Uno gehört ein Pegelwandler wie der 74HC4050 in die Leitungen SCL, SDA, RES, DC und CS. Außerdem brauchen Module ohne CS-Pin SPI-Modus 3; TFT_eSPI stellt das für den ST7789 automatisch ein, bei der Adafruit-Bibliothek musst du init() SPI_MODE3 übergeben.

TFT_eSPI installieren und User_Setup.h einrichten

ESP32-Entwicklungsboard
ESP32: Mit schnellem SPI und viel RAM ist er das passende Board für den ST7789.

TFT_eSPI von Bodmer ist eine der schnellsten TFT-Bibliotheken für den ESP32. Suche im Bibliotheksverwalter nach TFT_eSPI und installiere sie. Anders als bei anderen Bibliotheken werden Displaytyp und Pins nicht im Sketch festgelegt, sondern in der Datei User_Setup.h im Bibliotheksordner. Die Datei liegt unter Dokumente > Arduino > libraries > TFT_eSPI und ist standardmäßig auf ein ILI9341-Display eingestellt. Öffne sie mit einem Texteditor und ersetze den Inhalt durch Folgendes:

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. Installiere TFT_eSPI und ersetze User_Setup.h durch die Zeilen oben.
  2. Hast du ein 240x320-Display, setze TFT_HEIGHT auf 320; bei einem Modul ohne CS-Pin setze TFT_CS auf -1.
  3. Verdrahte das Display wie in der Tabelle: SCL an GPIO 18, SDA an GPIO 23, RES an GPIO 4, DC an GPIO 2, CS an GPIO 5, BLK an GPIO 32.
  4. Schließe die Arduino IDE und öffne sie neu; die Bibliothekseinstellungen werden beim Kompilieren gelesen.
  5. Lade den ersten Testsketch unten hoch; auf dem Display sollten Text und farbige Formen erscheinen.
Aktualisierst du die Bibliothek, wird auch User_Setup.h zurückgesetzt, und eines Tages bleibt dein Display plötzlich dunkel. Bewahre eine Kopie deiner Einstellungsdatei im Projektordner auf oder lege eine eigene Datei im Ordner User_Setups an und wähle sie in User_Setup_Select.h aus. Dann musst du nach einem Update nur eine Zeile ändern.

Erster Test: Text, Formen und Farben

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}

Bei TFT_eSPI beginnen die Koordinaten in der linken oberen Ecke (0, 0), die rechte untere Ecke eines 240x240-Displays ist (239, 239). Die letzte Zahl in drawString(Text, x, y, Schrift) wählt die Schrift: 1 ist eine kleine 8-Pixel-Schrift, 2 hat 16 Pixel, 4 hat 26 Pixel und 7 ist eine 48-Pixel-Siebensegmentschrift für Ziffern. setTextDatum(MC_DATUM) zentriert den Text auf den angegebenen Punkt, sehr praktisch für Anzeigen und Uhren. Farben gibst du mit fertigen Namen wie TFT_RED und TFT_GREEN an oder mit eigenen Tönen über color565(r, g, b).

FunktionWas macht sie?
fillScreen(Farbe)Füllt den ganzen Bildschirm
drawPixel(x, y, Farbe)Ein einzelnes Pixel
drawLine / drawWideLineDünne oder dicke Linie
drawRect / fillRect / fillRoundRectRechteck, gefüllt und mit runden Ecken
drawCircle / fillCircleKreis
fillTriangleGefülltes Dreieck
drawString / drawNumber / drawFloatText, Ganzzahl und Dezimalzahl
setRotation(0-3)Dreht das Bild in 90-Grad-Schritten

Flimmerfreie Animation mit Sprites

Zeichnest du direkt auf das Display, musst du zum Aktualisieren erst das Alte löschen und dann das Neue zeichnen. Zwischen diesen beiden Schritten ist das Bild kurz leer, und das Auge nimmt das als Flimmern wahr. Ein Sprite löst das Problem: Du zeichnest zuerst auf eine unsichtbare Leinwand im RAM des ESP32 und schickst das fertige Bild mit pushSprite() in einem Rutsch aufs Display. Eine halbfertige Zeichnung ist so nie zu sehen.

Der einzige Preis eines Sprites ist Speicher. Ein 16-Bit-Sprite braucht 2 Byte pro Pixel: Ein bildschirmfüllendes 240x240-Sprite belegt 115.200 Byte, eines mit 240x320 153.600 Byte. Der ESP32 hat zwar insgesamt 520 KB RAM, doch der größte am Stück reservierbare Block liegt oft nur bei etwa 110 KB; auf einem Board ohne PSRAM lässt sich ein bildschirmfüllendes 16-Bit-Sprite daher eventuell nicht anlegen. Die Lösung: entweder mit setColorDepth(8) auf 8-Bit-Farbe gehen (57,6 KB für 240x240) oder nur den Bereich, der sich ändert, etwa die Ziffern einer Uhr, als kleines Sprite zeichnen. createSprite() gibt nullptr zurück, wenn kein Speicher frei ist; diese Prüfung verhindert stille Fehler.

Sprite-Größe16 Bit8 Bit
240x240 (ganzer Bildschirm)115,2 KB57,6 KB
240x320 (ganzer Bildschirm)153,6 KB76,8 KB
220x120 (Uhrbereich)52,8 KB26,4 KB
100x50 (ein einzelner Wert)10 KB5 KB

Projekt: eine analoge Sensoranzeige

Der folgende Sketch macht aus einem Potentiometer an GPIO 34 einen Wert von 0 bis 100 und zeigt ihn mit einem Zeiger auf einem 270-Grad-Bogen an, wie ein Tachometer im Auto. Skalenstriche über 80 sind rot. Statt des Potentiometers kannst du derselben Funktion auch einen Temperatur-, Feuchte-, Gas- oder Bodenfeuchtewert übergeben. Weil das Sprite in jedem Bild gelöscht und neu gezeichnet wird, bewegt sich der Zeiger flüssig und flimmert nie.

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}

Die Funktion pointAt() im Code wandelt einen Wert von 0 bis 100 in einen Punkt auf dem Bogen um: 0 entspricht 225 Grad (unten links), 100 entspricht −45 Grad (unten rechts). Weil die y-Achse auf dem Display nach unten wächst, steht vor dem Sinus ein Minuszeichen. Die Variable smooth filtert kleine Schwankungen des ADC heraus; verkleinerst du den Faktor 0,2, bewegt sich der Zeiger träger, vergrößerst du ihn, reagiert er schneller. Mehr zum ADC des ESP32 findest du in der Anleitung Was ist ein ADC.

Projekt: eine Uhr mit NTP

Eine der beliebtesten Anwendungen des ST7789 ist eine Tischuhr. Der folgende Sketch verbindet den ESP32 mit dem WLAN, holt die Uhrzeit von NTP-Servern im Internet, hier für die türkische Zeitzone, und zeigt sie in großen Siebensegmentziffern an. Diesmal nutzen wir statt eines bildschirmfüllenden Sprites eines mit 220x120 Pixeln, das nur den Uhrbereich abdeckt; der Wochentag wird direkt aufs Display geschrieben, weil er sich nur einmal am Tag ändert. Für Deutschland setzt du TZ_INFO auf "CET-1CEST,M3.5.0,M10.5.0/3"; die Details zu NTP und Zeitzonen stehen in der Anleitung ESP32 NTP-Uhrzeit.

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}

Die Uhr wird nur neu gezeichnet, wenn sich die Sekunde ändert; während loop() leer läuft, hat der Prozessor Zeit für anderes. Die eingebauten Schriften von TFT_eSPI enthalten keine Umlaute, deshalb sind die türkischen Wochentage im Code ohne Sonderzeichen geschrieben; ersetze sie gern durch deutsche Namen wie "Montag" oder "Dienstag". Willst du Umlaute, kannst du mit der Smooth-Font-Funktion von TFT_eSPI eine eigene Schrift erstellen und laden. Für eine Wetterzeile kombinierst du diese Uhr einfach mit dem Open-Meteo-Code aus der Anleitung ESP32 Wetter-API.

ST7789 am Arduino Uno: Adafruit_ST7789

Am Arduino Uno läuft TFT_eSPI nicht; hier nimmst du die Adafruit ST7735 and ST7789 Library zusammen mit Adafruit GFX. Die 2 KB RAM des Uno reichen nicht einmal für ein Sprite, deshalb wird alles direkt aufs Display gezeichnet, und es ist deutlich langsamer als am ESP32. Für Menüs, Zahlen und einfache Grafiken genügt es trotzdem. Die Hardware-SPI-Pins sind fest: SDA (MOSI) an D11, SCL (SCK) an D13; für CS, DC und RST kannst du beliebige Digitalpins wählen.

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}

Dieser Sketch zeigt den Uno-tauglichen Weg gegen Flimmern: Wird setTextColor(Textfarbe, Hintergrundfarbe) mit zwei Farben aufgerufen, zeichnet die Bibliothek jedes Zeichen mitsamt Hintergrund und überschreibt so die alte Ziffer. Der Bildschirm muss nicht gelöscht werden, und die Zahl wechselt ohne Flimmern. Vorangestellte Leerzeichen sorgen dafür, dass keine Reste alter Ziffern stehen bleiben, wenn die Zahl kürzer wird. Möchtest du ein ähnliches Display mit 2,4-Zoll-Touchpanel nutzen, folgt die Anleitung ILI9341-TFT-Display derselben Logik.

ST7789 am Raspberry Pi Pico (MicroPython)

MicroPython bringt keinen eingebauten ST7789-Treiber mit, aber die Befehle des Chips sind einfach genug für einen eigenen kleinen Treiber. Die 264 KB RAM des Pico reichen für einen 115-KB-Bildpuffer über das ganze 240x240-Display. Der folgende Code initialisiert das Display, zeichnet mit dem MicroPython-Modul framebuf Text und Formen in den Puffer und schickt den Puffer in einem Rutsch per SPI; ein wanderndes Quadrat zeigt, wie Animation funktioniert. Angeschlossen wird am Bus SPI0: SCL an GP18, SDA an 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

Die Funktion rgb() im Code löst ein wichtiges Detail: framebuf speichert Farben mit dem niederwertigen Byte zuerst, der ST7789 erwartet aber das höherwertige Byte zuerst. Ohne Tausch der Bytes wird Rot blau und Blau grünlich. Der Befehl 0x36 (MADCTL) legt Ausrichtung und RGB- oder BGR-Reihenfolge fest; drehst du das Bild auf einem 240x240-Panel um 180 Grad, rutscht es in den unteren Teil des Speichers, und du musst die Zeilenadresse um 80 Pixel verschieben. Arbeitest du lieber mit der Arduino IDE, installiere auf dem Pico den arduino-pico-Core und nutze TFT_eSPI mit den RP2040-Einstellungen. Bist du neu bei MicroPython, fang mit der Anleitung MicroPython-Grundlagen an.

Schwarzes Display und andere Probleme: Lösungstabelle

SymptomWahrscheinliche UrsacheLösung
Display komplett schwarz, keine HintergrundbeleuchtungBLK nicht angeschlossen oder LOWBLK an 3,3 V oder den TFT_BL-Pin, TFT_BACKLIGHT_ON auf HIGH
Beleuchtung an, aber kein BildUser_Setup.h noch auf ILI9341 oder durch ein Update zurückgesetztZeile ST7789_DRIVER und Pins erneut prüfen
Beleuchtung an, kein Bild (Modul ohne CS)Falscher SPI-ModusTFT_CS auf -1; bei Adafruit init(240, 240, SPI_MODE3)
Es passiert gar nichtsSCL und SDA an den I2C-Pins (21, 22)SCL an GPIO 18, SDA an GPIO 23
Funktioniert mal, mal nichtReset-Pin offen, lange Kabel oder SPI zu schnellRES anschließen, Kabel kürzen, SPI_FREQUENCY auf 27 MHz senken
Farben wie ein NegativFarbinvertierung passt nicht zum PanelTFT_INVERSION_OFF oder TFT_INVERSION_ON ausprobieren
Rot und Blau vertauschtDas Panel nutzt die BGR-ReihenfolgeZeile TFT_RGB_ORDER TFT_BGR aktivieren
Verrauschter Streifen auf einem Teil des BildesFalsche Höhe (320 bei einem 240x240-Panel) oder Versatz beim DrehenTFT_HEIGHT richtig setzen, mit setRotation testen
ESP32 stürzt bei tft.init() abGemeldete Inkompatibilität mit ESP32-Core 3.xIm Boardverwalter einen 2.0.x-Core probieren oder auf LovyanGFX wechseln
Display wird am Uno heiß oder stirbt5-V-LogikpegelPegelwandler verwenden
Ändere bei einem schwarzen Display immer nur eine Sache auf einmal. Prüfe zuerst, ob die Hintergrundbeleuchtung angeht, wenn nur VCC, GND und BLK verbunden sind; lass dann den ersten Testsketch oben laufen. Leuchtet die Beleuchtung und das Bild bleibt schwarz, liegt das Problem fast immer bei Treiber, Größe oder Pins in User_Setup.h.

Projektideen mit dem ST7789

  • Smarte Tischuhr: Zeige NTP-Zeit, die Raumtemperatur eines BME280 und das Tageswetter aus dem Internet auf einem Bildschirm.
  • Sensor-Dashboard: Stelle Temperatur, Feuchte und Gaswerte auf farbigen Anzeigen dar; wird die Schwelle des MQ-2 überschritten, färbt sich der Hintergrund rot.
  • Mini-Spielkonsole: Spiele Snake, Pong oder ein Weltraumspiel mit einem Joystick; Sprites halten das Spiel flüssig.
  • Oberfläche für einen Musikplayer: Zeige Liedtitel, Lautstärke und Fortschrittsbalken eines DFPlayer Mini.
  • Oszilloskop-Diagramm: Zeichne analogRead-Werte als laufende Kurve und beobachte die Signalform.
  • Kartenleser-Display: Zeige Name und Zugangsstatus einer mit dem RFID RC522 gelesenen Karte auf einer farbigen Kachel.

Zusammen mit einem ESP32 macht der ST7789 aus einem Display für wenige Euro eine professionell wirkende Oberfläche. Hast du User_Setup.h richtig eingerichtet und das Sprite-Prinzip verstanden, zeichnest du Uhren, Anzeigen, Menüs, Spiele und jede andere Oberfläche ohne Flimmern. Welches Display zu deinem Projekt passt, vergleichst du in der Anleitung Arduino-Displayarten. In der BlueGrays-App findest du ESP32-Projekte zu Wetter, Uhr, Farbmischer und Einparkhilfe mit OLED- und LCD-Display, mit Schaltplan und Code Schritt für Schritt, und kannst dieselben Projekte mit dem ST7789 in Farbe umsetzen.

Häufige Fragen

Ist der ST7789 I2C oder SPI?

Der ST7789 nutzt SPI. Die Aufschrift SCL und SDA auf dem Modul ist irreführend: SCL ist die SPI-Taktleitung (SCK), SDA die Datenleitung (MOSI). Am ESP32 gehören sie an GPIO 18 und GPIO 23, nicht an die I2C-Pins 21 und 22.

Warum bleibt mein ST7789-Display schwarz?

Die häufigsten Ursachen sind eine nicht angeschlossene Hintergrundbeleuchtung (BLK), eine User_Setup.h, in der noch der ILI9341-Treiber ausgewählt ist, SCL und SDA an den I2C-Pins und der falsche SPI-Modus bei einem Modul ohne CS. Prüfe zuerst, ob die Beleuchtung leuchtet, und kontrolliere dann die Zeilen ST7789_DRIVER, TFT_WIDTH, TFT_HEIGHT und die Pins in User_Setup.h.

Funktioniert der ST7789 mit 5 V?

Der ST7789 arbeitet mit 3,3 V, und seine Pins sind nicht 5-V-tolerant. ESP32 und Pico lassen sich direkt anschließen; am Arduino Uno versorgst du das Modul mit 3,3 V und setzt einen Pegelwandler in die Signalleitungen. Manche Module haben einen Spannungsregler, die Datenleitungen bleiben aber 3,3 V.

Wo finde ich die User_Setup.h von TFT_eSPI?

User_Setup.h liegt im Ordner TFT_eSPI in deinem Arduino-Bibliotheksordner, meist unter Dokumente > Arduino > libraries > TFT_eSPI. Displaytreiber, Auflösung, Pins und SPI-Takt werden in dieser Datei festgelegt. Bei einem Bibliotheksupdate wird sie zurückgesetzt, also bewahre eine Kopie deiner Einstellungen auf.

Was ist ein Sprite und warum verhindert es Flimmern?

Ein Sprite ist eine unsichtbare Zeichenfläche im RAM des ESP32. Du zeichnest zuerst alles dort hinein und schickst es fertig mit pushSprite() in einem Rutsch aufs Display, sodass das gelöschte Zwischenbild nie zu sehen ist. Der Preis ist Speicher: Bei 16-Bit-Farbe belegt jedes Pixel 2 Byte.

Kann man den ST7789 mit dem Arduino Uno nutzen?

Ja, mit den Bibliotheken Adafruit ST7789 und Adafruit GFX, allerdings ist das Zeichnen langsam, weil die 2 KB RAM des Uno für kein Sprite reichen. Seine Pins führen 5 V, deshalb brauchst du einen Pegelwandler dazwischen. Für eine flüssige Farboberfläche ist der ESP32 die deutlich bessere Wahl.

Alle Projekte ansehen
ESP32 HTTPClient + Wetter-API (mit SSD1306-OLED-Display)
ES-32Fortgeschritten
Premium

ESP32 HTTPClient + Wetter-API (mit SSD1306-OLED-Display)

Der ESP32 ruft über das Internet mit HTTPClient.h eine Wetter-API (wttr.in) per REST auf. Anders als die I2C-LCD-Version nutzt dieses Projekt ein SSD1306-OLED (128×64) mit großer Schrift und Vektor-Icons für eine reichere Darstellung. Sieben Wetter-Icons (sonnig, Regen, Schnee und mehr) werden ohne Bitmap-Dateien direkt gezeichnet.

4.3(10)
22
ESP32 I2C-LCD-Display (16×2)
ES-17Mittel
Premium

ESP32 I2C-LCD-Display (16×2)

In diesem Projekt schließen wir ein 16x2-Zeichen-LCD über I2C an den ESP32 an und zeigen Text an. Dank I2C reichen 2 Datenpins (SDA und SCL) statt der 6+ Pins einer klassischen Parallelverbindung. Der Code schreibt eine feste Nachricht in die erste Zeile und einen sekündlich steigenden Zähler in die zweite. Beim Start gibt ein I2C-Scanner die Adresse des Displays im Serial Monitor aus (meist 0x27 oder 0x3F).

4.9(23)
40
ESP32 TM1637 4-stellige 7-Segment-Anzeige
ES-23Mittel
Premium

ESP32 TM1637 4-stellige 7-Segment-Anzeige

Wir steuern das 4-stellige 7-Segment-Anzeigemodul mit TM1637-Treiber über einen ESP32. Mit nur 2 GPIO-Pins (CLK und DIO) betreiben wir einen Zähler im Bereich von 0 bis 9999, stellen die Helligkeit ein und zeigen das Zeichen „:“ (zwei Punkte) in der Mitte im Uhrzeitformat an. Dank der TM1637Display-Bibliothek ist die Steuerung von Zahlen, Hexadezimalwerten, Segmenten und Zeichenfolgen sehr einfach.

4.7(20)
32
ESP32 Deep Sleep – Batteriesparmodus (OLED + RTC-RAM-Zähler)
ES-33Fortgeschritten
Premium

ESP32 Deep Sleep – Batteriesparmodus (OLED + RTC-RAM-Zähler)

Im Deep-Sleep-Modus schaltet der ESP32 die CPU und die meisten Peripheriegeräte ab und senkt den Strom auf etwa 10µA, entscheidend für batteriebetriebene IoT-Geräte. Das Projekt nutzt drei Weckquellen: einen Timer (15 s), einen externen Pin (EXT0, Taster an GPIO 33) und einen Touch-Pin (T0/GPIO 4). Mit RTC_DATA_ATTR markierte Zähler bleiben im Deep Sleep erhalten.

4.3(10)
16
ESP32-Gebets-Rakat-Zähler (HC-SR04 + SSD1306-OLED + 2 Tasten)
ES-34Fortgeschritten
Premium

ESP32-Gebets-Rakat-Zähler (HC-SR04 + SSD1306-OLED + 2 Tasten)

Verlierst du beim Gebet manchmal den Überblick über die Rakat? Dieser Rakat-Zähler steht neben deinem Gebetsteppich und zählt die Niederwerfungen, wenn du die Hand annäherst. Der Ultraschallsensor HC-SR04 erkennt die Hand, das SSD1306-OLED zeigt die Zahl, und mit zwei Tastern wählst du 2, 3 oder 4 Rakat und setzt zurück. 2,5 Sekunden Entprellung und eine Prüfung, ob die Hand weg ist, verhindern doppeltes Zählen.

4.8(11)
14
ESP32-Farbmischerlampe (3 Potentiometer + RGB-LED + OLED)
ES-36Fortgeschritten
Premium

ESP32-Farbmischerlampe (3 Potentiometer + RGB-LED + OLED)

Eine smarte Farbmischer-Lampe: Dreh an 3 Potentiometern am ESP32 und misch dir jede Farbe! Während du die Potis für Rot, Grün und Blau drehst, wechselt die RGB-LED mit gemeinsamer Kathode sofort die Farbe. Das SSD1306-OLED zeigt live für jede Farbe den Wert von 0-255, Füllbalken und den HEX-Webfarbcode (etwa #FF8040).

4.7(6)
10
ESP32-Parksensor (HC-SR04 + 5-LED-Leiste + Summer + OLED)
ES-38Fortgeschritten
Premium

ESP32-Parksensor (HC-SR04 + 5-LED-Leiste + Summer + OLED)

Die ESP32-Version einer Einparkhilfe! Der Ultraschallsensor HC-SR04 misst den Abstand zum Objekt davor. Je näher es kommt, desto weiter füllt sich eine Leiste aus 5 LEDs (grün → gelb → rot) und desto schneller piept der Summer. Ganz nah (unter 10 cm) ertönt ein Daueralarm und alle LEDs leuchten. Das SSD1306-OLED zeigt den aktuellen Abstand in cm groß an, dazu einen Statustext.

14
Paddle-Ball-Spiel - SSD1306
AR-86Mittel
Premium

Paddle-Ball-Spiel - SSD1306

Ein Ball, zwei Schläger und du: Du spielst Tischtennis, eines der allerersten Videospiele, auf einem kleinen OLED-Display.

4.5(47)
65