ST7789 ESP32 : écran IPS couleur avec TFT_eSPI, sprites, horloge
Guide ST7789 ESP32 : TFT_eSPI et User_Setup.h, broches SPI marquées SCL/SDA, jauge et horloge sans scintillement, Adafruit sur l'Uno, Pico et écran noir.
Le duo ST7789 ESP32 est la façon la moins chère d'offrir à un petit projet une interface couleur de qualité smartphone. Le ST7789 est une puce de pilotage TFT fabriquée par Sitronix ; on la trouve dans la plupart des écrans IPS du marché : 1,3 pouce 240x240, 1,54 pouce 240x240, 1,69 pouce 240x280 et 2,0 pouces 240x320. Grâce à la dalle IPS, les couleurs restent éclatantes sous tous les angles ; avec 65 000 couleurs, une haute résolution et une liaison SPI rapide, tu dessines des jauges, des graphiques et des animations qu'un OLED ou un LCD à caractères ne savent pas afficher.
Dans ce guide, tu verras pas à pas comment brancher le ST7789 sur un ESP32 avec la bibliothèque TFT_eSPI, comment régler User_Setup.h, la partie la plus déroutante de la bibliothèque, pourquoi le module est en SPI et non en I2C malgré les marquages SCL et SDA, comment animer sans scintillement avec un sprite, et comment réaliser une jauge analogique pour un capteur et une horloge pilotée par NTP. Nous verrons aussi la bibliothèque Adafruit_ST7789 pour l'Arduino Uno, un pilote MicroPython sans bibliothèque pour le Raspberry Pi Pico et toutes les causes de l'écran noir.

Qu'est-ce que le ST7789 et dans quels écrans le trouve-t-on ?
Le ST7789 est une puce de pilotage qui commande chaque pixel de l'écran et transforme les commandes du microcontrôleur en image. Elle contient une mémoire d'image de 240x320 pixels ; les écrans plus petits n'en utilisent qu'une partie. Les couleurs sont le plus souvent envoyées au format RGB565, soit 16 bits par pixel (5 bits de rouge, 6 de vert, 5 de bleu). La communication passe par un SPI 4 fils et la puce accepte une horloge d'environ 60 MHz ; en pratique, 40 MHz est une valeur sûre avec l'ESP32. À cette vitesse, une image complète de 240x240 représente 921 600 bits envoyés en 23 ms environ, ce qui permet de dépasser 40 images par seconde.
| Écran | Résolution | Usage typique |
|---|---|---|
| 1,14 pouce | 135x240 | Cartes ESP32 avec écran intégré comme la TTGO T-Display |
| 1,3 et 1,54 pouce | 240x240 | Montres connectées, petites jauges, interfaces carrées |
| 1,69 pouce | 240x280 | Écrans de montre aux coins arrondis |
| 1,9 pouce | 170x320 | Barres d'état longues et étroites |
| 2,0 pouces | 240x320 | Menus, graphiques et petits jeux |
| Caractéristique | Valeur |
|---|---|
| Puce de pilotage | ST7789 (Sitronix) |
| Dalle | IPS, grand angle de vision |
| Couleurs | 65 000 (RGB565), la puce en gère jusqu'à 262 000 |
| Interface | SPI 4 fils (SCK, MOSI, DC, CS) et RESET |
| Alimentation | 3,3 V sur la plupart des modules |
| Niveau logique | 3,3 V |
| Consommation | Environ 20–40 mA rétroéclairage compris |
Broches : il est écrit SCL et SDA, mais cet écran est en SPI
Les modules ST7789 bon marché de 1,3 pouce portent le marquage GND, VCC, SCL, SDA, RES, DC, BLK ; certains ont en plus une broche CS. Les marquages SCL et SDA trompent les débutants plus que tout : cet écran n'utilise pas l'I2C mais le SPI. SCL est en réalité l'horloge SPI (SCK) et SDA la ligne de données (MOSI). Si tu les branches sur les broches I2C de l'ESP32, GPIO 21 et 22, l'écran ne fonctionnera jamais. Nous expliquons le SPI dans le guide qu'est-ce que le SPI.
| Broche du module | Rôle | ESP32 (TFT_eSPI) | Arduino Uno (Adafruit) | Raspberry Pi Pico |
|---|---|---|---|---|
| GND | Masse | GND | GND | GND |
| VCC | Alimentation | 3V3 | 3.3V | 3V3 (OUT) |
| SCL | Horloge SPI (SCK) | GPIO 18 | D13 | GP18 |
| SDA | Données SPI (MOSI) | GPIO 23 | D11 | GP19 |
| RES | Reset | GPIO 4 | D8 | GP21 |
| DC | Choix données ou commande | GPIO 2 | D9 | GP20 |
| CS | Sélection de puce (si présente) | GPIO 5 | D10 | GP17 |
| BLK | Rétroéclairage | GPIO 32 | 3.3V | GP22 |
Installer TFT_eSPI et régler User_Setup.h

TFT_eSPI, écrite par Bodmer, est l'une des bibliothèques TFT les plus rapides pour l'ESP32. Cherche TFT_eSPI dans le gestionnaire de bibliothèques et installe-la. Contrairement aux autres bibliothèques, le type d'écran et les broches ne se règlent pas dans le sketch mais dans le fichier User_Setup.h du dossier de la bibliothèque. Il se trouve dans Documents > Arduino > libraries > TFT_eSPI et il est réglé par défaut pour un écran ILI9341. Ouvre-le avec un éditeur de texte et remplace son contenu par ceci :
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- Installe TFT_eSPI et remplace User_Setup.h par les lignes ci-dessus.
- Si ton écran fait 240x320, mets TFT_HEIGHT à 320 ; sur un module sans broche CS, mets TFT_CS à -1.
- Câble l'écran comme dans le tableau : SCL sur GPIO 18, SDA sur GPIO 23, RES sur GPIO 4, DC sur GPIO 2, CS sur GPIO 5, BLK sur GPIO 32.
- Ferme puis rouvre l'Arduino IDE ; les réglages de la bibliothèque sont lus à la compilation.
- Téléverse le premier sketch de test ci-dessous ; tu dois voir du texte et des formes colorées à l'écran.
Premier test : texte, formes et couleurs
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}Dans TFT_eSPI, les coordonnées partent du coin supérieur gauche (0, 0) et le coin inférieur droit d'un écran 240x240 est (239, 239). Le dernier nombre de drawString(texte, x, y, police) choisit la police : 1 est une petite police de 8 pixels, 2 fait 16 pixels, 4 fait 26 pixels et 7 est une police de chiffres 7 segments de 48 pixels. setTextDatum(MC_DATUM) centre le texte sur le point donné, très pratique pour les jauges et les horloges. Les couleurs s'indiquent avec des noms prêts à l'emploi comme TFT_RED et TFT_GREEN ou avec tes propres teintes grâce à color565(r, g, b).
| Fonction | Que fait-elle ? |
|---|---|
| fillScreen(couleur) | Remplit tout l'écran |
| drawPixel(x, y, couleur) | Un seul pixel |
| drawLine / drawWideLine | Ligne fine ou épaisse |
| drawRect / fillRect / fillRoundRect | Rectangle, plein et à coins arrondis |
| drawCircle / fillCircle | Cercle |
| fillTriangle | Triangle plein |
| drawString / drawNumber / drawFloat | Texte, nombre entier et décimal |
| setRotation(0-3) | Fait pivoter l'écran par pas de 90 degrés |
Animation sans scintillement avec les sprites
Quand tu dessines directement à l'écran, mettre quelque chose à jour oblige à effacer l'ancien puis à dessiner le nouveau. Entre ces deux étapes, l'écran est vide un instant et l'œil le perçoit comme un scintillement. Le sprite règle le problème : tu dessines d'abord sur une toile invisible dans la RAM de l'ESP32, puis, quand l'image est entièrement prête, tu l'envoies à l'écran d'un seul coup avec pushSprite(). Aucun dessin à moitié fini n'apparaît jamais.
Le seul prix d'un sprite, c'est la mémoire. Un sprite en couleur 16 bits utilise 2 octets par pixel : un sprite plein écran de 240x240 occupe 115 200 octets et un de 240x320, 153 600 octets. Même si l'ESP32 dispose de 520 Ko de RAM au total, le plus gros bloc allouable d'un seul tenant tourne souvent autour de 110 Ko ; sur une carte sans PSRAM, un sprite plein écran 16 bits peut donc échouer. La solution consiste soit à passer en couleur 8 bits avec setColorDepth(8) (57,6 Ko pour 240x240), soit à ne dessiner en petit sprite que la zone qui change, par exemple les chiffres de l'horloge. createSprite() renvoie nullptr s'il ne trouve pas la mémoire ; le vérifier évite les pannes silencieuses.
| Taille du sprite | 16 bits | 8 bits |
|---|---|---|
| 240x240 (plein écran) | 115,2 Ko | 57,6 Ko |
| 240x320 (plein écran) | 153,6 Ko | 76,8 Ko |
| 220x120 (zone de l'horloge) | 52,8 Ko | 26,4 Ko |
| 100x50 (une seule valeur) | 10 Ko | 5 Ko |
Projet : une jauge analogique pour capteur
Le sketch ci-dessous convertit un potentiomètre branché sur GPIO 34 en une valeur de 0 à 100 et l'affiche avec une aiguille sur un arc de 270 degrés, comme un compteur de voiture. Les graduations au-dessus de 80 sont rouges. À la place du potentiomètre, tu peux donner à la même fonction une température, une humidité, un taux de gaz ou l'humidité du sol. Comme le sprite est effacé et redessiné à chaque image, l'aiguille bouge de façon fluide et ne scintille jamais.
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}La fonction pointAt() du code transforme une valeur de 0 à 100 en un point de l'arc : 0 correspond à 225 degrés (en bas à gauche) et 100 à −45 degrés (en bas à droite). Comme l'axe y augmente vers le bas à l'écran, le sinus est précédé d'un signe moins. La variable smooth filtre les petites fluctuations de l'ADC ; si tu diminues le facteur 0,2, l'aiguille devient plus lente, si tu l'augmentes elle réagit plus vite. Pour en savoir plus sur l'ADC de l'ESP32, consulte le guide qu'est-ce qu'un CAN (ADC).
Projet : une horloge pilotée par NTP
L'un des usages préférés du ST7789 est l'horloge de bureau. Le sketch ci-dessous connecte l'ESP32 au Wi-Fi, récupère l'heure auprès des serveurs NTP d'internet, ici pour le fuseau horaire de la Turquie, et l'affiche en grands chiffres 7 segments. Cette fois, au lieu d'un sprite plein écran, nous utilisons un sprite de 220x120 qui ne couvre que la zone de l'horloge ; le nom du jour est écrit directement à l'écran, car il ne change qu'une fois par jour. Pour la France, mets TZ_INFO à "CET-1CEST,M3.5.0,M10.5.0/3" ; les détails sur NTP et les fuseaux horaires sont dans le guide heure NTP avec l'ESP32.
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}L'horloge n'est redessinée que lorsque la seconde change ; pendant que loop() tourne à vide, le processeur a du temps pour d'autres tâches. Les polices intégrées de TFT_eSPI n'ont pas d'accents, c'est pourquoi les noms des jours en turc sont écrits sans caractères spéciaux dans le code ; remplace-les si tu veux par "Lundi", "Mardi" et ainsi de suite. Pour afficher des accents, tu peux créer et charger ta propre police grâce à la fonction smooth font de TFT_eSPI. Pour ajouter une ligne météo à cette horloge, il suffit de la combiner avec le code Open-Meteo du guide API météo avec l'ESP32.
ST7789 avec l'Arduino Uno : Adafruit_ST7789
TFT_eSPI ne fonctionne pas sur l'Arduino Uno ; on utilise ici la Adafruit ST7735 and ST7789 Library avec Adafruit GFX. Les 2 Ko de RAM de l'Uno ne suffisent même pas pour un sprite, donc tout est dessiné directement à l'écran et c'est nettement plus lent qu'avec l'ESP32. Cela reste suffisant pour des menus, des nombres et des graphiques simples. Les broches du SPI matériel sont fixes : SDA (MOSI) va sur D11 et SCL (SCK) sur D13 ; pour CS, DC et RST, tu choisis les broches numériques que tu veux.
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}Ce sketch montre la méthode anti-scintillement adaptée à l'Uno : quand setTextColor(couleurTexte, couleurFond) est appelée avec deux couleurs, chaque caractère est dessiné avec son propre fond et écrase l'ancien chiffre. Inutile d'effacer l'écran, le nombre change sans scintiller. Des espaces ajoutés devant évitent que des restes des anciens chiffres subsistent quand le nombre raccourcit. Si tu veux un écran semblable sur une dalle tactile de 2,4 pouces, le guide écran TFT ILI9341 suit la même logique.
ST7789 avec le Raspberry Pi Pico (MicroPython)
MicroPython n'intègre pas de pilote ST7789, mais les commandes de la puce sont assez simples pour écrire ton propre petit pilote. Les 264 Ko de RAM du Pico suffisent pour une mémoire d'image de 115 Ko couvrant tout l'écran 240x240. Le code ci-dessous initialise l'écran, dessine du texte et des formes dans la mémoire avec le module framebuf de MicroPython et envoie le tout en SPI d'un seul coup ; un carré qui se déplace montre comment animer. Le câblage utilise le bus SPI0 : SCL sur GP18 et SDA sur 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 = -dxLa fonction rgb() du code règle un détail important : framebuf range les couleurs en mémoire octet de poids faible en premier, alors que le ST7789 attend l'octet de poids fort en premier. Sans échanger les octets, le rouge paraît bleu et le bleu verdâtre. La commande 0x36 (MADCTL) fixe l'orientation de l'écran et l'ordre RGB ou BGR ; si tu fais pivoter l'image de 180 degrés sur une dalle 240x240, l'image glisse dans la partie basse de la mémoire et il faut ajouter un décalage de 80 pixels à l'adresse de ligne. Si tu préfères l'Arduino IDE, installe le cœur arduino-pico sur le Pico et utilise TFT_eSPI avec ses réglages RP2040. Si tu débutes en MicroPython, commence par le guide les bases de MicroPython.
Écran noir et autres problèmes : tableau des solutions
| Symptôme | Cause probable | Solution |
|---|---|---|
| Écran complètement noir, pas de rétroéclairage | BLK non branchée ou à LOW | Relie BLK au 3,3 V ou à la broche TFT_BL, avec TFT_BACKLIGHT_ON à HIGH |
| Rétroéclairage allumé mais pas d'image | User_Setup.h encore réglé sur ILI9341 ou réinitialisé par une mise à jour | Revérifie la ligne ST7789_DRIVER et les broches |
| Rétroéclairage allumé, pas d'image (module sans CS) | Mauvais mode SPI | Mets TFT_CS à -1 ; avec Adafruit, utilise init(240, 240, SPI_MODE3) |
| Rien ne se passe | SCL et SDA branchées sur les broches I2C (21, 22) | Relie SCL à GPIO 18 et SDA à GPIO 23 |
| Marche par intermittence | Broche reset en l'air, fils longs ou SPI trop rapide | Branche RES, raccourcis les fils, baisse SPI_FREQUENCY à 27 MHz |
| Couleurs comme un négatif | Le réglage d'inversion ne correspond pas à la dalle | Essaie TFT_INVERSION_OFF ou TFT_INVERSION_ON |
| Rouge et bleu inversés | La dalle utilise l'ordre BGR | Active la ligne TFT_RGB_ORDER TFT_BGR |
| Bande parasitée sur une partie de l'écran | Mauvaise hauteur (320 sur une dalle 240x240) ou décalage en rotation | Règle correctement TFT_HEIGHT, teste avec setRotation |
| L'ESP32 plante sur tft.init() | Incompatibilité signalée avec le cœur ESP32 3.x | Essaie un cœur 2.0.x via le gestionnaire de cartes ou passe à la bibliothèque LovyanGFX |
| L'écran chauffe ou meurt avec l'Uno | Niveau logique 5 V | Utilise un convertisseur de niveau |
Idées de projets avec le ST7789
- Horloge de bureau connectée : Affiche l'heure NTP, la température de la pièce mesurée par un BME280 et la météo du jour récupérée sur internet sur un seul écran.
- Tableau de bord de capteurs : Présente température, humidité et gaz sur des jauges colorées ; le fond passe au rouge quand le seuil du MQ-2 est dépassé.
- Mini console de jeux : Joue au serpent, à Pong ou à un jeu spatial avec un joystick ; les sprites gardent le jeu fluide.
- Interface de lecteur de musique : Affiche le titre, le volume et une barre de progression pour un DFPlayer Mini.
- Graphique façon oscilloscope : Trace les valeurs d'analogRead sous forme de courbe défilante et observe la forme du signal.
- Écran de lecteur de badges : Affiche le nom et l'autorisation d'un badge lu par un RFID RC522 sur une carte colorée.
Associé à un ESP32, le ST7789 transforme un écran de quelques euros en une interface d'allure professionnelle. Une fois User_Setup.h bien réglé et le principe du sprite compris, tu peux dessiner horloges, jauges, menus, jeux et toute autre interface sans scintillement. Pour comparer les écrans adaptés à ton projet, consulte le guide les types d'écrans pour Arduino. Dans l'application BlueGrays, tu trouveras des projets ESP32 de météo, d'horloge, de mélangeur de couleurs et de radar de recul avec écrans OLED et LCD, avec schéma et code pas à pas, et tu pourras passer ces mêmes projets en couleur avec le ST7789.
Questions fréquentes
Le ST7789 est-il en I2C ou en SPI ?
Le ST7789 fonctionne en SPI. Les marquages SCL et SDA du module sont trompeurs : SCL est l'horloge SPI (SCK) et SDA la ligne de données (MOSI). Sur un ESP32, branche-les sur GPIO 18 et GPIO 23, pas sur les broches I2C 21 et 22.
Pourquoi mon écran ST7789 reste-t-il noir ?
Les causes les plus fréquentes sont un rétroéclairage (BLK) non branché, un User_Setup.h où le pilote ILI9341 est encore sélectionné, SCL et SDA branchées sur les broches I2C et un mauvais mode SPI sur un module sans CS. Vérifie d'abord que le rétroéclairage s'allume, puis contrôle les lignes ST7789_DRIVER, TFT_WIDTH, TFT_HEIGHT et les broches dans User_Setup.h.
Le ST7789 fonctionne-t-il en 5 V ?
La puce ST7789 fonctionne en 3,3 V et ses broches ne tolèrent pas le 5 V. L'ESP32 et le Pico se branchent directement ; avec un Arduino Uno, alimente le module en 3,3 V et place un convertisseur de niveau sur les lignes de signal. Certains modules ont un régulateur, mais les lignes de données restent en 3,3 V.
Où se trouve le fichier User_Setup.h de TFT_eSPI ?
User_Setup.h se trouve dans le dossier TFT_eSPI de ton dossier de bibliothèques Arduino, généralement Documents > Arduino > libraries > TFT_eSPI. Le pilote d'écran, la résolution, les broches et la vitesse SPI y sont définis. Il est réinitialisé à chaque mise à jour de la bibliothèque, alors garde une copie de tes réglages.
Qu'est-ce qu'un sprite et pourquoi évite-t-il le scintillement ?
Un sprite est une zone de dessin invisible conservée dans la RAM de l'ESP32. Tu y dessines tout d'abord, puis tu l'envoies à l'écran d'un seul coup avec pushSprite() quand elle est prête, si bien que l'image intermédiaire effacée n'apparaît jamais. Le prix, c'est la mémoire : en couleur 16 bits, chaque pixel occupe 2 octets.
Peut-on utiliser le ST7789 avec un Arduino Uno ?
Oui, avec les bibliothèques Adafruit ST7789 et Adafruit GFX, mais le dessin est lent car les 2 Ko de RAM de l'Uno ne suffisent pas pour un sprite. Ses broches sont en 5 V, il faut donc un convertisseur de niveau entre les deux. Pour une interface couleur fluide, l'ESP32 est un bien meilleur choix.
Projets à réaliser après cet article
Voir tous les projets
ESP32 HTTPClient + API météo (avec écran OLED SSD1306)
L'ESP32 appelle par Internet une API météo (wttr.in) en REST avec HTTPClient.h. Contrairement à la version LCD I2C, on utilise ici un écran OLED SSD1306 (128×64), avec un grand texte et des icônes vectorielles pour un affichage plus riche. Sept icônes météo (soleil, pluie, neige et plus) sont dessinées à la volée, sans fichier bitmap.

Écran LCD I2C ESP32 (16x2)
Dans ce projet, on relie un écran LCD 16x2 caractères à l'ESP32 en I2C pour afficher du texte. Grâce à l'I2C, 2 broches de données (SDA et SCL) suffisent, au lieu des 6+ broches d'un branchement parallèle classique. Le code affiche un message fixe sur la première ligne et un compteur qui augmente chaque seconde sur la deuxième. Au démarrage, un scanner I2C écrit l'adresse de l'écran dans le Serial Monitor (souvent 0x27 ou 0x3F).

ESP32 TM1637 Affichage à 7 segments à 4 chiffres
Nous contrôlons un module d'affichage à 7 segments à 4 chiffres équipé d'un pilote TM1637 à l'aide d'un ESP32. En utilisant seulement 2 GPIO (CLK et DIO), nous faisons fonctionner un compteur de 0 à 9999, réglons le niveau de luminosité et affichons le caractère « : » au milieu sous forme d'horloge. Grâce à la bibliothèque TM1637Display, le contrôle des nombres, des valeurs hexadécimales, des segments et des chaînes de caractères est très simple.

Mode veille profonde de l'ESP32 — Économie de batterie (OLED + compteur RAM RTC)
Le mode Deep Sleep de l'ESP32 coupe le CPU et la plupart des périphériques et réduit la consommation à environ 10µA, un point clé pour les objets IoT sur batterie. Ce projet utilise trois sources de réveil : un minuteur (15 s), une broche externe (EXT0, le bouton sur GPIO 33) et une broche tactile (T0/GPIO 4). Les compteurs marqués RTC_DATA_ATTR sont conservés pendant le deep sleep.

Compteur de rak'ahs pour la prière avec ESP32 (HC-SR04 + écran OLED SSD1306 + 2 boutons)
Il t'arrive de ne plus savoir à quelle rakat tu en es pendant la prière ? Ce compteur se pose près de ton tapis et compte les prosternations quand tu approches la main. Le capteur à ultrasons HC-SR04 détecte ta main, l'écran OLED SSD1306 affiche le nombre et deux boutons servent à choisir 2, 3 ou 4 rakats et à remettre à zéro. Un anti-rebond de 2,5 secondes et un contrôle du retrait de la main évitent de compter deux fois.

Lampe à mélangeur de couleurs ESP32 (3 potentiomètres + LED RVB + écran OLED)
Une lampe mélangeuse de couleurs intelligente : tourne 3 potentiomètres sur l'ESP32 et mélange la couleur de ton choix ! Quand tu tournes les potentiomètres rouge, vert et bleu, la LED RGB à cathode commune change de couleur aussitôt. L'écran OLED SSD1306 affiche en direct la valeur 0-255 de chaque couleur, des barres de remplissage et le code couleur web HEX (comme #FF8040).

Capteur de stationnement ESP32 (HC-SR04 + barre à 5 LED + buzzer + écran OLED)
La version ESP32 d'un radar de recul ! Le capteur à ultrasons HC-SR04 mesure la distance jusqu'à l'objet devant lui. Plus il se rapproche, plus une barre de 5 LED se remplit (vert → jaune → rouge) et plus le buzzer bipe vite. Tout près (moins de 10 cm), une alarme continue retentit et toutes les LED s'allument. L'écran OLED SSD1306 affiche la distance en cm en grands caractères, avec un message d'état.

Jeu de Raquettes - SSD1306
Une balle, deux raquettes et toi : tu joues au tennis de table, l'un des tout premiers jeux vidéo, sur un petit écran OLED.
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

