ESP32 Cheap Yellow Display (CYD) : brochage, réglages et LVGL
ESP32 Cheap Yellow Display (ESP32-2432S028R) : brochage complet, réglage de TFT_eSPI et du tactile XPT2046, calibration, carte SD, haut-parleur et LVGL.
L'ESP32 Cheap Yellow Display (CYD en abrégé), vendu sous la référence ESP32-2432S028R, est une carte de développement prête à l'emploi qui réunit un ESP32, un écran tactile couleur de 2,8 pouces, un lecteur microSD, une LED RGB, un capteur de lumière et une sortie haut-parleur sur un seul circuit imprimé jaune. Le surnom dit tout : la carte est jaune, bon marché et possède un écran. Tu branches un câble USB, tu téléverses ton programme et tu obtiens une interface tactile sans souder ni brancher le moindre fil.
Dans ce guide, tu verras ce que contient la carte, comment distinguer les versions et le brochage complet. Ensuite, tu configureras dans l'Arduino IDE les bibliothèques TFT_eSPI et XPT2046_Touchscreen, tu afficheras du texte, tu calibreras le tactile, tu piloteras la LED RGB avec des boutons à l'écran, tu enregistreras des données sur une carte microSD et tu créeras ta première vraie interface avec LVGL. Les dernières parties proposent des idées de projets, comme une station météo ou un panneau domotique, ainsi que les solutions aux problèmes les plus fréquents.

Qu'est-ce que l'ESP32 Cheap Yellow Display et que contient la carte ?
Au cœur de la carte se trouve un module ESP32-WROOM-32 : processeur double cœur jusqu'à 240 MHz, 520 Ko de SRAM, 4 Mo de flash, Wi-Fi 2,4 GHz et Bluetooth. Tout ce que tu as appris dans Qu'est-ce que l'ESP32 ? s'applique donc ici. L'écran est relié au bus HSPI de l'ESP32, tandis que la puce XPT2046, qui lit la dalle tactile résistive, est branchée avec ses propres broches sur le second bus SPI (VSPI). Ce détail compte, car les exemples TFT génériques supposent que le tactile partage le bus de l'écran et ne fonctionnent pas sur le CYD. Il n'y a pas de PSRAM : au lieu de garder toute l'image en mémoire, on la dessine par morceaux.
| Caractéristique | Valeur |
|---|---|
| Module processeur | ESP32-WROOM-32 (double cœur, 240 MHz) |
| Mémoire | 520 Ko SRAM, 4 Mo flash, pas de PSRAM |
| Écran | TFT 2,8 pouces, 240×320 pixels, couleur 16 bits (RGB565) |
| Contrôleur d'écran | ILI9341 (souvent ST7789 sur la version à deux USB) |
| Tactile | Dalle résistive, contrôleur XPT2046 |
| Stockage | Lecteur de carte microSD (SPI) |
| Extras | LED RGB, capteur de lumière LDR, sortie haut-parleur (amplificateur SC8002B) |
| USB et alimentation | Micro-USB, puce USB-série CH340, 5 V |
| Boutons | BOOT (GPIO 0) et RST |
Les versions de la carte : que signifie ESP32-2432S028R ?
La référence est un résumé : 2432 désigne la résolution (240×320), S028 la taille de l'écran (2,8 pouces) et le R final un tactile résistif. La même famille comprend aussi des cartes se terminant par C (tactile capacitif) et N (sans tactile). Comme les vendeurs appellent toutes ces cartes "Cheap Yellow Display", vérifie la référence exacte avant de commander : le brochage et le contrôleur d'écran peuvent changer d'une version à l'autre.
| Carte | Écran | Comment la reconnaître | Attention |
|---|---|---|---|
| ESP32-2432S028R (un USB) | 2,8" 240×320, ILI9341 | Prise micro-USB seule | La version sur laquelle reposent la plupart des exemples et ce guide |
| ESP32-2432S028R (deux USB) | 2,8" 240×320, souvent ST7789 | Micro-USB et USB-C côte à côte | Couleurs parfois inversées ; changer le contrôleur ou utiliser invertDisplay |
| ESP32-2432S024 | 2,4" 240×320 | Écran plus petit | Broches et puce tactile parfois différentes |
| ESP32-2432S032 | 3,2" 240×320 | Carte plus grande | La version capacitive lit le tactile en I2C |
| ESP32-3248S035 | 3,5" 320×480, ST7796 | Résolution plus élevée | Demande sa propre configuration TFT_eSPI |
Brochage du CYD
| Composant | Signal et GPIO | Remarque |
|---|---|---|
| Écran (ILI9341) | MOSI 13, MISO 12, SCK 14, CS 15, DC 2 | Bus HSPI ; RST relié à EN |
| Rétroéclairage | GPIO 21 | HIGH = allumé ; réglable en PWM |
| Tactile (XPT2046) | CLK 25, MOSI 32, MISO 39, CS 33, IRQ 36 | Bus VSPI, séparé de l'écran |
| microSD | SCK 18, MISO 19, MOSI 23, CS 5 | Broches VSPI par défaut |
| LED RGB | Rouge 4, vert 16, bleu 17 | Anode commune : LOW = allumée |
| Capteur de lumière LDR | GPIO 34 | Entrée seulement, lecture avec analogRead |
| Haut-parleur | GPIO 26 | Amplificateur SC8002B, connecteur SPEAK |
| Bouton BOOT | GPIO 0 | Peut aussi servir de bouton dans ton programme |
| Port série (P1) | TX 1, RX 3 | Partagé avec la puce USB-série |
| Broches libres | GPIO 22, 27 (CN1), GPIO 35 (P3) | La 35 est en entrée seulement |
Les petits connecteurs JST (pas de 1,25 mm) sur le bord sont ta porte vers l'extérieur. CN1 fournit GND, GPIO 22, GPIO 27 et 3,3 V, parfait pour un capteur I2C : écris Wire.begin(27, 22) et branche directement un capteur comme le BME280. P3 donne accès aux GPIO 35, 22 et 21, et P1 porte l'entrée 5 V ainsi que les lignes série TX/RX. Pour vérifier ces broches avec les contraintes générales de l'ESP32, ouvre l'outil de brochage.
Configurer l'Arduino IDE : carte et bibliothèques
- Installe le paquet de cartes ESP32 dans l'Arduino IDE (esp32 by Espressif dans le gestionnaire de cartes) et choisis ESP32 Dev Module comme carte.
- Branche la carte avec un câble USB. Si aucun port n'apparaît, installe le pilote CH340 et vérifie que ton câble transmet bien les données et pas seulement la charge.
- Installe TFT_eSPI (Bodmer) et XPT2046_Touchscreen (Paul Stoffregen) depuis le gestionnaire de bibliothèques.
- Remplace le contenu de User_Setup.h dans le dossier TFT_eSPI par les réglages de la section suivante.
- Si le téléversement s'arrête sur "Failed to connect", maintiens le bouton BOOT au démarrage du téléversement ; détails dans ESP32 Failed to connect.
Configurer TFT_eSPI : User_Setup.h
TFT_eSPI est une bibliothèque très rapide, et cette vitesse vient de réglages de broches fixés à la compilation. Ils se trouvent dans le fichier User_Setup.h du dossier de la bibliothèque (Documents > Arduino > libraries > TFT_eSPI). Fais une copie de sauvegarde, efface tout son contenu et colle les lignes ci-dessous. Une mise à jour de la bibliothèque remet ce fichier à zéro : garde ta version ailleurs et recopie-la après chaque mise à jour.
1// TFT_eSPI/User_Setup.h: CYD (ESP32-2432S028R) ayarı / setup for the CYD
2#define ILI9341_2_DRIVER // iki USB'li kartta ST7789_DRIVER / two-USB board: ST7789_DRIVER
3#define TFT_WIDTH 240
4#define TFT_HEIGHT 320
5#define TFT_BL 21 // arka ışık / backlight
6#define TFT_BACKLIGHT_ON HIGH
7#define TFT_MISO 12
8#define TFT_MOSI 13
9#define TFT_SCLK 14
10#define TFT_CS 15
11#define TFT_DC 2
12#define TFT_RST -1 // EN'e bağlı / tied to EN
13#define USE_HSPI_PORT // ekran HSPI hattında / display on the HSPI bus
14
15#define LOAD_GLCD
16#define LOAD_FONT2
17#define LOAD_FONT4
18#define LOAD_FONT6
19#define LOAD_FONT7
20#define LOAD_FONT8
21#define LOAD_GFXFF
22#define SMOOTH_FONT
23
24#define SPI_FREQUENCY 55000000 // sorun olursa 27000000 / use 27000000 if unstable
25#define SPI_READ_FREQUENCY 20000000
26#define SPI_TOUCH_FREQUENCY 2500000Premier test : du texte à l'écran et du dessin au doigt
1#include <SPI.h>
2#include <TFT_eSPI.h>
3#include <XPT2046_Touchscreen.h>
4
5// Dokunmatik (XPT2046) kendi SPI hattında / touch (XPT2046) on its own SPI bus
6#define XPT2046_IRQ 36
7#define XPT2046_MOSI 32
8#define XPT2046_MISO 39
9#define XPT2046_CLK 25
10#define XPT2046_CS 33
11
12SPIClass touchSpi(VSPI);
13XPT2046_Touchscreen ts(XPT2046_CS, XPT2046_IRQ);
14TFT_eSPI tft;
15
16void setup() {
17 Serial.begin(115200);
18 touchSpi.begin(XPT2046_CLK, XPT2046_MISO, XPT2046_MOSI, XPT2046_CS);
19 ts.begin(touchSpi);
20 ts.setRotation(1); // ekranla aynı yön / same orientation as the screen
21
22 tft.init();
23 tft.setRotation(1); // yatay 320x240 / landscape 320x240
24 tft.fillScreen(TFT_BLACK);
25 tft.setTextColor(TFT_WHITE, TFT_BLACK);
26 tft.drawCentreString("BlueGrays CYD", 160, 10, 4);
27 tft.drawCentreString("Ekrana dokun / Touch the screen", 160, 40, 2);
28}
29
30void loop() {
31 if (ts.tirqTouched() && ts.touched()) {
32 TS_Point p = ts.getPoint();
33 // Ham değerleri piksele çevir / convert raw values to pixels
34 int x = map(p.x, 200, 3700, 0, 319);
35 int y = map(p.y, 240, 3800, 0, 239);
36 x = constrain(x, 0, 319);
37 y = constrain(y, 0, 239);
38 tft.fillCircle(x, y, 3, TFT_YELLOW);
39 Serial.printf("ham/raw x=%d y=%d z=%d -> piksel/pixel %d,%d\n", p.x, p.y, p.z, x, y);
40 }
41}La ligne essentielle est SPIClass touchSpi(VSPI) : elle place le contrôleur tactile sur le second bus SPI avec ses propres broches, indépendamment de l'écran. ts.setRotation(1) et tft.setRotation(1) doivent avoir la même valeur ; sinon, l'endroit touché et le point dessiné ne correspondent pas. En paysage, les coordonnées vont de 0 à 319 pour x et de 0 à 239 pour y. Après le téléversement, essaie d'écrire sur l'écran avec un stylet ; si les traits suivent ta main, l'écran et le tactile sont bien réglés.
Calibration de l'écran tactile (XPT2046)
Le XPT2046 ne renvoie pas des pixels mais des valeurs brutes entre 0 et 4095. Les nombres 200, 3700 et 240, 3800 du code correspondent à la partie de cette plage qui coïncide avec les bords de l'écran, et ils varient légèrement d'une carte à l'autre. Pour calibrer, ouvre le moniteur série à 115200 bauds, touche les quatre coins avec un stylet et note les valeurs brutes minimales et maximales de x et y. Reporte ces quatre nombres dans les lignes map() et le décalage entre ton doigt et le point dessiné tombe à quelques pixels. La dalle résistive mesure aussi la pression : touched() ne renvoie true que pour un appui suffisant, mais si tu vois des valeurs instables près des bords, tu peux fixer un seuil plus élevé pour p.z.
LED RGB, LDR et haut-parleur : un panneau de commande tactile
La LED RGB, la LDR et la sortie haut-parleur au dos de la carte suffisent pour un premier projet. Le code ci-dessous dessine trois grands boutons ; en touchant un bouton, tu allumes ou éteins la couleur correspondante de la LED et le haut-parleur émet un court clic. La barre jaune en bas affiche la valeur du capteur de lumière et se met à jour toutes les demi-secondes.
1#include <SPI.h>
2#include <TFT_eSPI.h>
3#include <XPT2046_Touchscreen.h>
4
5#define XPT2046_IRQ 36
6#define XPT2046_MOSI 32
7#define XPT2046_MISO 39
8#define XPT2046_CLK 25
9#define XPT2046_CS 33
10
11const int LED_PINS[3] = {4, 16, 17}; // RGB LED: kırmızı, yeşil, mavi (LOW = yanar) / red, green, blue (LOW = on)
12const int LDR_PIN = 34; // ışık sensörü / light sensor
13const int SPEAKER_PIN = 26; // hoparlör yükselticisi / speaker amplifier
14const char* NAMES[3] = {"RED", "GREEN", "BLUE"};
15const uint16_t COLORS[3] = {TFT_RED, TFT_GREEN, TFT_BLUE};
16
17SPIClass touchSpi(VSPI);
18XPT2046_Touchscreen ts(XPT2046_CS, XPT2046_IRQ);
19TFT_eSPI tft;
20
21bool ledOn[3] = {false, false, false};
22bool wasTouched = false;
23unsigned long lastLdr = 0;
24
25void drawButton(int i) {
26 int x = 8 + i * 104; // 3 düğme yan yana / 3 buttons side by side
27 tft.fillRoundRect(x, 60, 96, 80, 10, ledOn[i] ? COLORS[i] : TFT_DARKGREY);
28 tft.setTextColor(TFT_WHITE);
29 tft.drawCentreString(NAMES[i], x + 48, 92, 2);
30}
31
32void setup() {
33 for (int i = 0; i < 3; i++) {
34 pinMode(LED_PINS[i], OUTPUT);
35 digitalWrite(LED_PINS[i], HIGH); // HIGH = sönük / HIGH = off
36 }
37 touchSpi.begin(XPT2046_CLK, XPT2046_MISO, XPT2046_MOSI, XPT2046_CS);
38 ts.begin(touchSpi);
39 ts.setRotation(1);
40 tft.init();
41 tft.setRotation(1);
42 tft.fillScreen(TFT_BLACK);
43 tft.setTextColor(TFT_WHITE, TFT_BLACK);
44 tft.drawString("BlueGrays panel", 8, 12, 4);
45 for (int i = 0; i < 3; i++) drawButton(i);
46}
47
48void loop() {
49 bool touchedNow = ts.tirqTouched() && ts.touched();
50 if (touchedNow && !wasTouched) { // yalnız ilk dokunuşta / only on the first touch
51 TS_Point p = ts.getPoint();
52 int x = map(p.x, 200, 3700, 0, 319);
53 int y = map(p.y, 240, 3800, 0, 239);
54 if (y > 60 && y < 140) {
55 int i = constrain((x - 8) / 104, 0, 2);
56 ledOn[i] = !ledOn[i];
57 digitalWrite(LED_PINS[i], ledOn[i] ? LOW : HIGH);
58 drawButton(i);
59 tone(SPEAKER_PIN, 2000, 30); // kısa tık sesi / short click sound
60 }
61 }
62 wasTouched = touchedNow;
63
64 if (millis() - lastLdr > 500) { // yarım saniyede bir / every half second
65 lastLdr = millis();
66 int light = analogRead(LDR_PIN); // 0-4095
67 tft.fillRect(8, 170, 304, 20, TFT_BLACK);
68 tft.fillRect(8, 170, map(light, 0, 4095, 0, 304), 20, TFT_YELLOW);
69 tft.setTextColor(TFT_WHITE, TFT_BLACK);
70 tft.drawString("LDR: " + String(light) + " ", 8, 200, 2);
71 }
72}Comme la LED RGB est câblée en anode commune, la logique est inversée : écrire LOW allume une couleur et HIGH l'éteint ; c'est pourquoi setup() met d'abord les trois broches à HIGH. La variable wasTouched empêche un bouton de basculer sans arrêt tant que ton doigt reste sur l'écran ; seul le début de l'appui compte. La valeur de la LDR peut rester dans une plage étroite à cause de la résistance du pont diviseur de la carte ; mesure les valeurs dans le noir et en pleine lumière dans ta pièce et choisis le seuil en fonction. Sur le connecteur haut-parleur, tu peux brancher un petit haut-parleur de 8 Ω et jouer des bips et des mélodies simples avec tone().
Enregistrer des données sur la carte microSD
Le lecteur utilise les broches VSPI par défaut de l'ESP32 (18, 19, 23 et 5 pour CS) : SD.begin(5) suffit. Formate la carte en FAT32 ; les cartes jusqu'à 32 Go fonctionnent sans souci. L'exemple ci-dessous ajoute toutes les cinq secondes le temps et le niveau de lumière au fichier log.csv, que tu pourras ouvrir ensuite dans un tableur. Pour l'utilisation générale des cartes SD, consulte le guide du module carte SD.
1#include <SPI.h>
2#include <SD.h>
3
4const int SD_CS = 5; // microSD: SCK 18, MISO 19, MOSI 23, CS 5
5const int LDR_PIN = 34;
6
7void setup() {
8 Serial.begin(115200);
9 if (!SD.begin(SD_CS)) { // varsayılan SPI pinleri / default SPI pins
10 Serial.println("SD kart yok / no SD card");
11 return;
12 }
13 Serial.printf("SD: %llu MB\n", SD.cardSize() / (1024 * 1024));
14}
15
16void loop() {
17 File f = SD.open("/log.csv", FILE_APPEND); // dosyanın sonuna ekle / append to the file
18 if (f) {
19 f.printf("%lu,%d\n", millis() / 1000, analogRead(LDR_PIN));
20 f.close();
21 }
22 delay(5000);
23}Ta première interface avec LVGL
Dessiner boutons, curseurs et graphiques un fillRect à la fois devient vite fastidieux. LVGL est une bibliothèque graphique libre qui propose des widgets comme sur un smartphone (boutons, curseurs, listes, graphiques, onglets) et qui gère le tactile pour toi. Depuis la version 9, elle intègre la prise en charge de TFT_eSPI : plus besoin d'écrire ta propre fonction d'envoi vers l'écran.
- Installe la bibliothèque lvgl (version 9.x) depuis le gestionnaire de bibliothèques.
- Copie lv_conf_template.h du dossier libraries/lvgl un niveau plus haut, à côté du dossier lvgl, sous le nom lv_conf.h.
- Remplace #if 0 en haut du fichier par #if 1 et mets LV_USE_TFT_ESPI à 1.
- Pour des polices plus grandes, mets aussi à 1 des lignes comme LV_FONT_MONTSERRAT_20 ; chaque police occupe de la mémoire flash.
1#include <SPI.h>
2#include <lvgl.h>
3#include <TFT_eSPI.h>
4#include <XPT2046_Touchscreen.h>
5
6#define XPT2046_IRQ 36
7#define XPT2046_MOSI 32
8#define XPT2046_MISO 39
9#define XPT2046_CLK 25
10#define XPT2046_CS 33
11#define SCREEN_WIDTH 240
12#define SCREEN_HEIGHT 320
13#define DRAW_BUF_SIZE (SCREEN_WIDTH * SCREEN_HEIGHT / 10 * (LV_COLOR_DEPTH / 8))
14
15SPIClass touchSpi(VSPI);
16XPT2046_Touchscreen ts(XPT2046_CS, XPT2046_IRQ);
17uint32_t drawBuf[DRAW_BUF_SIZE / 4]; // ekranın 1/10'u kadar tampon / buffer for 1/10 of the screen
18lv_obj_t* valueLabel;
19
20// LVGL'e dokunuşu bildir / report touches to LVGL
21void touchRead(lv_indev_t* indev, lv_indev_data_t* data) {
22 if (ts.tirqTouched() && ts.touched()) {
23 TS_Point p = ts.getPoint();
24 data->point.x = map(p.x, 200, 3700, 1, SCREEN_WIDTH);
25 data->point.y = map(p.y, 240, 3800, 1, SCREEN_HEIGHT);
26 data->state = LV_INDEV_STATE_PRESSED;
27 } else {
28 data->state = LV_INDEV_STATE_RELEASED;
29 }
30}
31
32uint32_t tickMs() { return millis(); } // LVGL'in saat kaynağı / LVGL time source
33
34void onLedButton(lv_event_t* e) {
35 lv_obj_t* btn = lv_event_get_target_obj(e);
36 bool on = lv_obj_has_state(btn, LV_STATE_CHECKED);
37 digitalWrite(4, on ? LOW : HIGH); // kırmızı LED / red LED
38}
39
40void onSlider(lv_event_t* e) {
41 lv_obj_t* slider = lv_event_get_target_obj(e);
42 lv_label_set_text_fmt(valueLabel, "%d %%", (int)lv_slider_get_value(slider));
43}
44
45void lvglSetup() {
46 pinMode(4, OUTPUT);
47 digitalWrite(4, HIGH);
48 touchSpi.begin(XPT2046_CLK, XPT2046_MISO, XPT2046_MOSI, XPT2046_CS);
49 ts.begin(touchSpi);
50 ts.setRotation(2);
51
52 lv_init();
53 lv_tick_set_cb(tickMs);
54 lv_display_t* disp = lv_tft_espi_create(SCREEN_WIDTH, SCREEN_HEIGHT, drawBuf, sizeof(drawBuf));
55 lv_display_set_rotation(disp, LV_DISPLAY_ROTATION_270); // yatay kullanım / landscape
56 lv_indev_t* indev = lv_indev_create();
57 lv_indev_set_type(indev, LV_INDEV_TYPE_POINTER);
58 lv_indev_set_read_cb(indev, touchRead);
59
60 lv_obj_t* title = lv_label_create(lv_screen_active());
61 lv_label_set_text(title, "BlueGrays + LVGL");
62 lv_obj_align(title, LV_ALIGN_TOP_MID, 0, 10);
63
64 lv_obj_t* btn = lv_button_create(lv_screen_active());
65 lv_obj_set_size(btn, 120, 50);
66 lv_obj_align(btn, LV_ALIGN_CENTER, 0, -30);
67 lv_obj_add_flag(btn, LV_OBJ_FLAG_CHECKABLE); // aç-kapa düğmesi / toggle button
68 lv_obj_add_event_cb(btn, onLedButton, LV_EVENT_VALUE_CHANGED, NULL);
69 lv_obj_t* btnLabel = lv_label_create(btn);
70 lv_label_set_text(btnLabel, "LED");
71 lv_obj_center(btnLabel);
72
73 lv_obj_t* slider = lv_slider_create(lv_screen_active());
74 lv_obj_set_width(slider, 220);
75 lv_obj_align(slider, LV_ALIGN_CENTER, 0, 40);
76 lv_obj_add_event_cb(slider, onSlider, LV_EVENT_VALUE_CHANGED, NULL);
77 valueLabel = lv_label_create(lv_screen_active());
78 lv_label_set_text(valueLabel, "0 %");
79 lv_obj_align_to(valueLabel, slider, LV_ALIGN_OUT_BOTTOM_MID, 0, 10);
80}
81
82void lvglLoop() {
83 lv_timer_handler(); // LVGL çizim ve olayları / LVGL drawing and events
84 delay(5);
85}Ajoute setup() et loop() à la fin de ce code : dans setup(), appelle uniquement lvglSetup(), et dans loop(), uniquement lvglLoop(). L'image est dessinée par morceaux avec un tampon d'un dixième de l'écran (environ 15 Ko), un bon compromis pour un CYD sans PSRAM. Comme LVGL gère lui-même la rotation, les coordonnées tactiles sont fournies en portrait (240×320) et LVGL les convertit pour l'écran en paysage. Le bouton est basculable (checkable) : chaque appui inverse la LED rouge, et le curseur écrit son pourcentage dans l'étiquette en dessous.
Idées de projets avec le CYD : météo et panneau domotique
- Écran météo : utilise l'API météo avec l'ESP32 pour afficher température, humidité et prévisions du jour avec des icônes.
- Panneau domotique : commande lampes et prises avec des boutons à l'écran via MQTT et Home Assistant.
- Horloge de bureau : affiche l'heure Internet par NTP en grands chiffres et baisse le rétroéclairage la nuit grâce à la LDR.
- Tableau de bord capteurs : trace en direct température, humidité et pression d'un capteur I2C branché sur CN1.
- Enregistreur de données : écris les mesures sur la carte microSD et affiche un graphique des dernières 24 heures.
- Jeux tactiles : crée un morpion, un snake ou un jeu de mémoire à jouer au stylet.
Erreurs fréquentes et solutions
| Symptôme | Cause probable | Solution |
|---|---|---|
| Écran blanc ou noir | User_Setup.h non configuré ou mauvais contrôleur | Copie les réglages de ce guide ; sur une carte à deux USB, essaie ST7789 |
| Couleurs en négatif | Contrôleur ou inversion des couleurs inadaptés | Ajoute tft.invertDisplay(1) ou change de contrôleur |
| Le tactile ne réagit pas | Tactile supposé sur le bus SPI de l'écran | Utilise touchSpi(VSPI) avec les broches 25, 32, 39, 33 |
| Décalage entre appui et dessin | Valeurs de calibration inadaptées à la carte | Mesure les valeurs brutes des coins et corrige les lignes map() |
| Scintillement ou lignes déformées | Horloge SPI trop élevée | Baisse SPI_FREQUENCY à 27000000 |
| Redémarrage au lancement du Wi-Fi | Port USB ou câble trop faible en courant | Utilise un câble court de qualité et un chargeur d'au moins 1 A |
| Le téléversement ne démarre pas | Pas de pilote CH340 ou carte hors mode téléchargement | Installe le pilote et appuie sur BOOT au début du téléversement |
L'ESP32 Cheap Yellow Display est le chemin le plus court vers un projet ESP32 avec écran : pas de fils dans tous les sens, pas de soudure, juste du code. Si tu préfères travailler avec des modules séparés sur une plaque d'essai, le guide de l'écran TFT ILI9341 présente le même contrôleur. Dans l'application BlueGrays, tu trouveras les projets météo, horloge NTP, serveur web et LDR avec schémas et code pas à pas, prêts à être portés sur l'écran du CYD.
Questions fréquentes
Quelle carte choisir dans l'Arduino IDE pour le Cheap Yellow Display ?
Choisis ESP32 Dev Module, car le CYD embarque un module ESP32-WROOM-32 standard. Laisse la flash à 4 Mo et, si le téléversement échoue, baisse la vitesse à 115200. Si aucun port n'apparaît, installe le pilote CH340.
Pourquoi l'écran de mon CYD reste-t-il blanc ?
Un écran blanc signifie que le rétroéclairage fonctionne mais que le contrôleur ne reçoit pas de données valides. Presque toujours, le fichier User_Setup.h de TFT_eSPI n'est pas configuré pour le CYD ou le mauvais contrôleur est sélectionné. Vérifie les broches et, sur les cartes à deux USB, essaie le contrôleur ST7789 au lieu de l'ILI9341.
Quelles broches sont libres sur l'ESP32 Cheap Yellow Display ?
Les broches utilisables sont les GPIO 22 et 27 du connecteur CN1 et le GPIO 35 de P3, ce dernier en entrée seulement. Pour un capteur I2C, écris Wire.begin(27, 22) et alimente-le par les broches 3,3 V et GND de CN1. N'utilise pas le GPIO 21, qui commande le rétroéclairage.
LVGL fonctionne-t-il sur le CYD sans PSRAM ?
Oui, LVGL 9 tourne de façon fluide sur le CYD. Faute de PSRAM, on utilise un tampon de dessin d'un dixième de l'écran (environ 15 Ko) au lieu d'une image complète. Avec beaucoup de grandes polices ou d'images, la flash et la RAM deviennent la vraie limite ; désactive dans lv_conf.h les polices inutiles.
Peut-on utiliser le tactile et la carte SD en même temps ?
Oui, mais avec une configuration supplémentaire, car les deux utilisent le périphérique VSPI de l'ESP32 sur des broches différentes. Le plus simple est une bibliothèque tactile en SPI logiciel. Sinon, redémarre le bus SPI avec les broches de la SD avant chaque accès, puis avec celles du tactile.
Le CYD peut-il fonctionner sur batterie ?
La carte fonctionne en 5 V et consomme généralement 100 à 250 mA avec le rétroéclairage et le Wi-Fi actifs. Sur batterie, utilise une cellule Li-ion avec un module de charge TP4056 et un convertisseur élévateur 5 V, ou tout simplement une batterie externe. Pour gagner en autonomie, éteins l'écran et le Wi-Fi au repos et mets l'ESP32 en veille.
Projets à réaliser après cet article
Voir tous les projets
Mesure de l'intensité lumineuse avec le module LDR ESP32
Suivi en temps réel sur le moniteur série de la valeur brute de l'ADC du module LDR et du pourcentage relatif de luminosité calculé à partir de références dans l'obscurité et à la lumière. Ce pourcentage n'est pas une mesure en lux. Permet de comprendre le principe de calibrage du module. Il est préférable de réaliser cet exercice avant le projet 10, car il sert à déterminer la valeur seuil.

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.

ESP32 HTTPClient + API météo (avec écran LCD)
L'ESP32 appelle par Internet une API météo (wttr.in) en REST avec HTTPClient.h. La réponse JSON est analysée avec ArduinoJson v7, puis la ville, la température, l'humidité, la météo et le vent s'affichent sur un LCD I2C. wttr.in ne demande aucune clé d'API : il suffit de taper le nom de n'importe quelle ville.

ESP32 : heure réelle depuis Internet via NTP
L'ESP32 se connecte au Wi-Fi et récupère l'heure exacte auprès de serveurs NTP (Network Time Protocol) à la milliseconde près. Avec configTzTime(), le fuseau horaire de la Turquie (TRT, UTC+3) s'applique automatiquement, et dans les pays à heure d'été, le changement (DST) est géré tout seul par une chaîne POSIX TZ. L'heure s'affiche dans le Serial Monitor et sur un LCD I2C en option.

Serveur Web asynchrone ESP32 (avec affichage de l'adresse IP sur l'écran LCD)
On transforme l'ESP32 en serveur web asynchrone que tu pilotes depuis ton téléphone ou ton ordinateur sur le même réseau Wi-Fi. Grâce à la bibliothèque ESPAsyncWebServer, le serveur traite plusieurs requêtes à la fois (il ne bloque pas sur une seule requête comme le WebServer.h classique). Ouvre l'adresse IP de l'ESP32 dans le navigateur et allume ou éteins la LED sur GPIO 5 avec les boutons ON/OFF (adresses /on et /off).

Enregistreur de Température ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
Construis avec l'ESP32 un enregistreur de température et d'humidité horodaté ! Un capteur DHT22 mesure la température et l'humidité une fois par minute, et chaque mesure est enregistrée sur une carte microSD au format CSV avec l'heure réelle du module RTC DS1307. L'écran OLED affiche en direct, en grands caractères, la dernière température, l'humidité, l'horodatage et le nombre d'enregistrements.

Contrôle d'une LED RVB avec ESP32
Génération illimitée de couleurs avec une seule LED RVB au lieu de 3 LED séparées. Comme dans Arduino, nous réalisons une transition arc-en-ciel en réglant les valeurs R/G/B avec analogWrite(). La théorie des couleurs (telle que rouge+vert=jaune) est mise en pratique.

ESP32 Lecture de mélodies avec buzzer
Jouer une mélodie simple (Twinkle Twinkle Little Star) avec un buzzer passif. Nous jouons les notes avec les fonctions tone() et noTone() comme dans Arduino - la même syntaxe fonctionne avec ESP32 Arduino Core 3.0+. Un buzzer passif doit être utilisé (un buzzer actif ne joue pas la mélodie).
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

