Composants · 9 min de lecture

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.

Module écran TFT 2,8 pouces avec contrôleur ILI9341
Un module TFT ILI9341 vendu seul : l'écran de 2,8 pouces du CYD utilise le même contrôleur ; la différence, c'est que l'ESP32 et le circuit tactile sont sur la même carte.

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éristiqueValeur
Module processeurESP32-WROOM-32 (double cœur, 240 MHz)
Mémoire520 Ko SRAM, 4 Mo flash, pas de PSRAM
ÉcranTFT 2,8 pouces, 240×320 pixels, couleur 16 bits (RGB565)
Contrôleur d'écranILI9341 (souvent ST7789 sur la version à deux USB)
TactileDalle résistive, contrôleur XPT2046
StockageLecteur de carte microSD (SPI)
ExtrasLED RGB, capteur de lumière LDR, sortie haut-parleur (amplificateur SC8002B)
USB et alimentationMicro-USB, puce USB-série CH340, 5 V
BoutonsBOOT (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ÉcranComment la reconnaîtreAttention
ESP32-2432S028R (un USB)2,8" 240×320, ILI9341Prise micro-USB seuleLa version sur laquelle reposent la plupart des exemples et ce guide
ESP32-2432S028R (deux USB)2,8" 240×320, souvent ST7789Micro-USB et USB-C côte à côteCouleurs parfois inversées ; changer le contrôleur ou utiliser invertDisplay
ESP32-2432S0242,4" 240×320Écran plus petitBroches et puce tactile parfois différentes
ESP32-2432S0323,2" 240×320Carte plus grandeLa version capacitive lit le tactile en I2C
ESP32-3248S0353,5" 320×480, ST7796Résolution plus élevéeDemande sa propre configuration TFT_eSPI
Sur les CYD à deux ports USB (micro-USB + USB-C), l'écran utilise généralement un contrôleur ST7789. Avec le réglage ILI9341, l'écran peut s'allumer, mais les couleurs ressemblent à un négatif : blanc au lieu de noir, jaune au lieu de bleu. Dans ce cas, choisis ST7789_DRIVER dans User_Setup.h ou ajoute tft.invertDisplay(1) juste après tft.init().

Brochage du CYD

ComposantSignal et GPIORemarque
Écran (ILI9341)MOSI 13, MISO 12, SCK 14, CS 15, DC 2Bus HSPI ; RST relié à EN
RétroéclairageGPIO 21HIGH = allumé ; réglable en PWM
Tactile (XPT2046)CLK 25, MOSI 32, MISO 39, CS 33, IRQ 36Bus VSPI, séparé de l'écran
microSDSCK 18, MISO 19, MOSI 23, CS 5Broches VSPI par défaut
LED RGBRouge 4, vert 16, bleu 17Anode commune : LOW = allumée
Capteur de lumière LDRGPIO 34Entrée seulement, lecture avec analogRead
Haut-parleurGPIO 26Amplificateur SC8002B, connecteur SPEAK
Bouton BOOTGPIO 0Peut aussi servir de bouton dans ton programme
Port série (P1)TX 1, RX 3Partagé avec la puce USB-série
Broches libresGPIO 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.

Le GPIO 21 du connecteur P3 commande aussi le rétroéclairage ; si tu y branches quelque chose et que la broche passe à LOW, l'écran s'éteint. Le GPIO 35 fonctionne uniquement en entrée et ne peut piloter ni LED ni relais. Si tu alimentes un composant externe par la broche 3,3 V de CN1, n'en tire pas des centaines de milliampères : la carte consomme déjà pas mal de courant pour l'écran et le Wi-Fi.

Configurer l'Arduino IDE : carte et bibliothèques

  1. 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.
  2. 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.
  3. Installe TFT_eSPI (Bodmer) et XPT2046_Touchscreen (Paul Stoffregen) depuis le gestionnaire de bibliothèques.
  4. Remplace le contenu de User_Setup.h dans le dossier TFT_eSPI par les réglages de la section suivante.
  5. 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.

C++ (Arduino IDE)
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  2500000

Premier test : du texte à l'écran et du dessin au doigt

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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}
Le contrôleur tactile et la carte SD utilisent tous deux le périphérique VSPI, mais sur des broches différentes. Si tu as besoin des deux dans le même programme, choisis une bibliothèque qui lit le tactile en SPI logiciel (par exemple XPT2046_Bitbang) ou redémarre le bus SPI avec les bonnes broches avant et après chaque accès à la carte. Sinon, l'un se tait pendant que l'autre travaille.

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.

  1. Installe la bibliothèque lvgl (version 9.x) depuis le gestionnaire de bibliothèques.
  2. Copie lv_conf_template.h du dossier libraries/lvgl un niveau plus haut, à côté du dossier lvgl, sous le nom lv_conf.h.
  3. Remplace #if 0 en haut du fichier par #if 1 et mets LV_USE_TFT_ESPI à 1.
  4. Pour des polices plus grandes, mets aussi à 1 des lignes comme LV_FONT_MONTSERRAT_20 ; chaque police occupe de la mémoire flash.
C++ (Arduino IDE)
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ômeCause probableSolution
Écran blanc ou noirUser_Setup.h non configuré ou mauvais contrôleurCopie les réglages de ce guide ; sur une carte à deux USB, essaie ST7789
Couleurs en négatifContrôleur ou inversion des couleurs inadaptésAjoute tft.invertDisplay(1) ou change de contrôleur
Le tactile ne réagit pasTactile supposé sur le bus SPI de l'écranUtilise touchSpi(VSPI) avec les broches 25, 32, 39, 33
Décalage entre appui et dessinValeurs de calibration inadaptées à la carteMesure les valeurs brutes des coins et corrige les lignes map()
Scintillement ou lignes déforméesHorloge SPI trop élevéeBaisse SPI_FREQUENCY à 27000000
Redémarrage au lancement du Wi-FiPort USB ou câble trop faible en courantUtilise un câble court de qualité et un chargeur d'au moins 1 A
Le téléversement ne démarre pasPas de pilote CH340 ou carte hors mode téléchargementInstalle le pilote et appuie sur BOOT au début du téléversement
Si la carte redémarre sans cesse en se connectant au Wi-Fi et que le moniteur série affiche "Brownout detector was triggered", le problème vient de l'alimentation, pas de ton code ; tous les détails dans les erreurs brownout et Guru Meditation de l'ESP32.

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.

Voir tous les projets
Mesure de l'intensité lumineuse avec le module LDR ESP32
ES-11Débutant

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.

4.6(36)
55
ESP32 HTTPClient + API météo (avec écran OLED SSD1306)
ES-32Avancé
Premium

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.

4.3(10)
22
ESP32 HTTPClient + API météo (avec écran LCD)
ES-31Avancé
Premium

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.

4.7(13)
20
ESP32 : heure réelle depuis Internet via NTP
ES-26Avancé
Premium

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.

4.5(13)
22
Serveur Web asynchrone ESP32 (avec affichage de l'adresse IP sur l'écran LCD)
ES-27Avancé

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

4.8(16)
26
Enregistreur de Température ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avancé
Premium

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.

4.7(7)
12
Contrôle d'une LED RVB avec ESP32
ES-9Débutant

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.

4.6(29)
52
ESP32 Lecture de mélodies avec buzzer
ES-12Débutant
Premium

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

4.8(30)
55