ESP32 Cheap Yellow Display (CYD): pinout, configurazione e LVGL
ESP32 Cheap Yellow Display (ESP32-2432S028R): pinout completo, configurazione di TFT_eSPI e del touch XPT2046, calibrazione, scheda SD, altoparlante e LVGL.
L'ESP32 Cheap Yellow Display (in breve CYD), venduto con la sigla ESP32-2432S028R, è una scheda di sviluppo pronta all'uso che riunisce un ESP32, un touchscreen a colori da 2,8 pollici, uno slot microSD, un LED RGB, un sensore di luce e un'uscita per altoparlante su un unico circuito stampato giallo. Il soprannome dice tutto: la scheda è gialla, economica e ha un display. Colleghi un cavo USB, carichi lo sketch e hai un'interfaccia touch senza saldare nulla né collegare un solo cavetto jumper.
In questa guida vedrai cosa c'è sulla scheda, come distinguere le versioni e il pinout completo. Poi configurerai nell'Arduino IDE le librerie TFT_eSPI e XPT2046_Touchscreen, scriverai testo sul display, calibrerai il touch, accenderai il LED RGB con pulsanti sullo schermo, salverai dati su una scheda microSD e creerai la tua prima vera interfaccia con LVGL. Nelle ultime sezioni trovi idee di progetto, come una stazione meteo o un pannello domotico, e le soluzioni ai problemi più comuni.

Che cos'è l'ESP32 Cheap Yellow Display e cosa c'è sulla scheda?
Il cuore della scheda è un modulo ESP32-WROOM-32: processore dual core fino a 240 MHz, 520 KB di SRAM, 4 MB di flash, Wi-Fi a 2,4 GHz e Bluetooth. Tutto ciò che hai imparato in Cos'è l'ESP32? vale anche qui. Il display è collegato al bus HSPI dell'ESP32, mentre il chip XPT2046, che legge il pannello touch resistivo, usa pin propri sul secondo bus SPI (VSPI). Questo dettaglio è importante, perché gli esempi TFT generici danno per scontato che il touch condivida il bus del display e sul CYD non funzionano. Non c'è PSRAM, quindi invece di tenere tutta l'immagine in memoria la si disegna a pezzi.
| Caratteristica | Valore |
|---|---|
| Modulo processore | ESP32-WROOM-32 (dual core, 240 MHz) |
| Memoria | 520 KB SRAM, 4 MB flash, niente PSRAM |
| Display | TFT da 2,8 pollici, 240×320 pixel, colore a 16 bit (RGB565) |
| Driver del display | ILI9341 (sulla versione con due USB di solito ST7789) |
| Touch | Pannello resistivo, controller XPT2046 |
| Memoria esterna | Slot per scheda microSD (SPI) |
| Extra | LED RGB, sensore di luce LDR, uscita altoparlante (amplificatore SC8002B) |
| USB e alimentazione | Micro-USB, chip USB-seriale CH340, 5 V |
| Pulsanti | BOOT (GPIO 0) e RST |
Versioni della scheda: cosa significa ESP32-2432S028R?
La sigla è un riassunto: 2432 indica la risoluzione (240×320), S028 la dimensione dello schermo (2,8 pollici) e la R finale il touch resistivo. Nella stessa famiglia ci sono anche schede che finiscono con C (touch capacitivo) e N (senza touch). Poiché i venditori chiamano tutte "Cheap Yellow Display", controlla la sigla esatta prima dell'acquisto: pinout e driver del display possono cambiare da una versione all'altra.
| Scheda | Display | Come riconoscerla | Attenzione |
|---|---|---|---|
| ESP32-2432S028R (un USB) | 2,8" 240×320, ILI9341 | Solo presa micro-USB | La versione su cui si basano la maggior parte degli esempi e questa guida |
| ESP32-2432S028R (due USB) | 2,8" 240×320, di solito ST7789 | Micro-USB e USB-C affiancate | I colori possono apparire invertiti; serve cambiare driver o usare invertDisplay |
| ESP32-2432S024 | 2,4" 240×320 | Schermo più piccolo | Pin e chip touch possono essere diversi |
| ESP32-2432S032 | 3,2" 240×320 | Scheda più grande | La versione capacitiva legge il touch via I2C |
| ESP32-3248S035 | 3,5" 320×480, ST7796 | Risoluzione più alta | Richiede una propria configurazione TFT_eSPI |
Pinout del CYD
| Componente | Segnale e GPIO | Nota |
|---|---|---|
| Display (ILI9341) | MOSI 13, MISO 12, SCK 14, CS 15, DC 2 | Bus HSPI; RST collegato a EN |
| Retroilluminazione | GPIO 21 | HIGH = accesa; regolabile in PWM |
| Touch (XPT2046) | CLK 25, MOSI 32, MISO 39, CS 33, IRQ 36 | Bus VSPI, separato dal display |
| microSD | SCK 18, MISO 19, MOSI 23, CS 5 | Pin VSPI predefiniti |
| LED RGB | Rosso 4, verde 16, blu 17 | Anodo comune: LOW = acceso |
| Sensore di luce LDR | GPIO 34 | Solo ingresso, si legge con analogRead |
| Altoparlante | GPIO 26 | Amplificatore SC8002B, connettore SPEAK |
| Pulsante BOOT | GPIO 0 | Si può leggere anche come pulsante nello sketch |
| Porta seriale (P1) | TX 1, RX 3 | Condivisa con il chip USB-seriale |
| Pin liberi | GPIO 22, 27 (CN1), GPIO 35 (P3) | Il 35 è solo ingresso |
I piccoli connettori JST (passo 1,25 mm) sul bordo sono la tua porta verso l'esterno. CN1 porta GND, GPIO 22, GPIO 27 e 3,3 V, perfetto per un sensore I2C: scrivi Wire.begin(27, 22) e collega direttamente un sensore come il BME280. P3 offre i GPIO 35, 22 e 21, mentre P1 porta l'ingresso a 5 V e le linee seriali TX/RX. Per confrontare questi pin con i vincoli generali dell'ESP32, apri lo strumento pinout.
Configurare l'Arduino IDE: scheda e librerie
- Installa il pacchetto schede ESP32 nell'Arduino IDE (esp32 by Espressif nel Gestore schede) e scegli ESP32 Dev Module come scheda.
- Collega la scheda con un cavo USB. Se non compare nessuna porta, installa il driver CH340 e assicurati che il cavo trasmetta dati e non serva solo alla ricarica.
- Installa TFT_eSPI (Bodmer) e XPT2046_Touchscreen (Paul Stoffregen) dal Gestore librerie.
- Sostituisci il contenuto di User_Setup.h nella cartella di TFT_eSPI con le impostazioni della sezione successiva.
- Se il caricamento si ferma con "Failed to connect", tieni premuto BOOT quando parte l'upload; dettagli in ESP32 Failed to connect.
Configurare TFT_eSPI: User_Setup.h
TFT_eSPI è una libreria molto veloce, e questa velocità deriva da impostazioni dei pin fissate in fase di compilazione. Si trovano nel file User_Setup.h dentro la cartella della libreria (Documenti > Arduino > libraries > TFT_eSPI). Fai un backup del file, cancellane tutto il contenuto e incolla le righe qui sotto. Aggiornando la libreria il file torna quello predefinito, quindi conserva la tua versione altrove e ricopiala dopo ogni aggiornamento.
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 2500000Primo test: testo sul display e disegno con il touch
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 riga chiave è SPIClass touchSpi(VSPI): collega il controller touch al secondo bus SPI con i suoi pin, indipendentemente dal display. ts.setRotation(1) e tft.setRotation(1) devono avere lo stesso valore; altrimenti il punto che tocchi e quello disegnato non coincidono. In orizzontale le coordinate vanno da 0 a 319 per x e da 0 a 239 per y. Dopo il caricamento prova a scrivere sullo schermo con un pennino; se le linee seguono la tua mano, display e touch sono configurati bene.
Calibrazione del touchscreen (XPT2046)
L'XPT2046 non restituisce pixel ma valori grezzi tra 0 e 4095. I numeri 200, 3700 e 240, 3800 nel codice sono la parte di quell'intervallo che corrisponde ai bordi dello schermo e variano leggermente da scheda a scheda. Per calibrare, apri il Monitor seriale a 115200 baud, tocca i quattro angoli con un pennino e annota i valori grezzi minimi e massimi di x e y. Inserisci questi quattro numeri nelle righe map() e lo scarto tra il tocco e il punto disegnato scende a pochi pixel. Il pannello resistivo misura anche la pressione: touched() restituisce true solo con una pressione sufficiente, ma se vedi valori instabili vicino ai bordi puoi impostare una soglia più alta per p.z.
LED RGB, LDR e altoparlante: un pannello di controllo touch
LED RGB, LDR e uscita altoparlante sul retro della scheda bastano per il tuo primo progetto. Il codice qui sotto disegna tre grandi pulsanti; toccandone uno accendi o spegni quel colore del LED e l'altoparlante emette un breve clic. La barra gialla in basso mostra la lettura del sensore di luce e si aggiorna ogni mezzo secondo.
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}Poiché il LED RGB è ad anodo comune, la logica è invertita: scrivere LOW accende un colore e HIGH lo spegne; per questo setup() porta prima i tre pin a HIGH. La variabile wasTouched impedisce a un pulsante di commutare in continuazione finché il dito resta sullo schermo; conta solo l'inizio del tocco. La lettura della LDR può restare in un intervallo stretto a causa della resistenza del partitore sulla scheda; misura nella tua stanza i valori al buio e alla luce e scegli la soglia di conseguenza. Sul connettore dell'altoparlante puoi collegare un piccolo altoparlante da 8 Ω e suonare bip e melodie semplici con tone().
Salvare dati sulla scheda microSD
Lo slot usa i pin VSPI predefiniti dell'ESP32 (18, 19, 23 e 5 per CS), quindi basta SD.begin(5). Formatta la scheda in FAT32; le schede fino a 32 GB funzionano senza problemi. L'esempio qui sotto aggiunge ogni cinque secondi il tempo e il livello di luce al file log.csv, che poi puoi aprire con qualsiasi foglio di calcolo. Per l'uso generale delle schede SD, consulta la guida al modulo scheda 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}La tua prima interfaccia con LVGL
Disegnare pulsanti, slider e grafici uno alla volta con fillRect diventa presto faticoso. LVGL è una libreria grafica open source con widget in stile smartphone (pulsanti, slider, liste, grafici, schede) che gestisce anche il touch al posto tuo. Dalla versione 9 include il supporto a TFT_eSPI, quindi non devi più scrivere una tua funzione di invio al display.
- Installa la libreria lvgl (versione 9.x) dal Gestore librerie.
- Copia lv_conf_template.h dalla cartella libraries/lvgl un livello più in alto, accanto alla cartella lvgl, e rinominalo lv_conf.h.
- Cambia #if 0 all'inizio del file in #if 1 e imposta LV_USE_TFT_ESPI a 1.
- Per caratteri più grandi imposta a 1 anche righe come LV_FONT_MONTSERRAT_20; ogni font occupa memoria 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}Aggiungi setup() e loop() alla fine di questo codice: in setup() chiama solo lvglSetup() e in loop() solo lvglLoop(). L'immagine viene disegnata a pezzi con un buffer pari a un decimo dello schermo (circa 15 KB), un buon compromesso per un CYD senza PSRAM. Poiché LVGL gestisce da sé la rotazione, le coordinate touch vengono passate in verticale (240×320) e LVGL le converte per lo schermo orizzontale. Il pulsante è commutabile (checkable), quindi ogni tocco cambia lo stato del LED rosso, e lo slider scrive la sua percentuale nell'etichetta sottostante.
Idee di progetto con il CYD: meteo e pannello domotico
- Display meteo: usa l'API meteo con ESP32 per mostrare temperatura, umidità e previsioni del giorno con icone.
- Pannello domotico: comanda luci e prese con pulsanti sullo schermo tramite MQTT e Home Assistant.
- Orologio da scrivania: mostra l'ora di Internet via NTP a cifre grandi e abbassa la retroilluminazione di notte in base alla LDR.
- Dashboard sensori: traccia in tempo reale temperatura, umidità e pressione di un sensore I2C collegato a CN1.
- Data logger: salva le misure sulla microSD e mostra un grafico delle ultime 24 ore.
- Giochi touch: crea tris, snake o memory da giocare con il pennino.
Errori comuni e soluzioni
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| Schermo bianco o nero | User_Setup.h non configurato o driver sbagliato | Copia le impostazioni di questa guida; sulla scheda a due USB prova ST7789 |
| Colori come un negativo | Driver o inversione colori non corrispondono | Aggiungi tft.invertDisplay(1) o cambia driver |
| Il touch non risponde | Touch ritenuto sullo stesso bus SPI del display | Usa touchSpi(VSPI) con i pin 25, 32, 39, 33 |
| Tocco e disegno sfasati | Valori di calibrazione non adatti alla scheda | Misura i valori grezzi degli angoli e aggiorna le righe map() |
| Sfarfallio o linee distorte | Clock SPI troppo alto | Abbassa SPI_FREQUENCY a 27000000 |
| Si riavvia quando parte il Wi-Fi | Porta USB o cavo non danno abbastanza corrente | Usa un cavo corto e di qualità e un alimentatore da almeno 1 A |
| Il caricamento non parte | Manca il driver CH340 o la scheda non è in modalità download | Installa il driver e premi BOOT all'avvio del caricamento |
L'ESP32 Cheap Yellow Display è la strada più breve verso un progetto ESP32 con schermo: niente groviglio di cavi, niente saldature, solo codice. Se preferisci lavorare con moduli separati sulla breadboard, la guida al display TFT ILI9341 spiega lo stesso driver. Nell'app BlueGrays trovi i progetti meteo, orologio NTP, web server e LDR con schemi e codice passo passo, pronti da portare sullo schermo del CYD.
Domande frequenti
Quale scheda scelgo nell'Arduino IDE per il Cheap Yellow Display?
Scegli ESP32 Dev Module, perché il CYD monta un normale modulo ESP32-WROOM-32. Lascia la flash a 4 MB e, se il caricamento fallisce, riduci la velocità a 115200. Se non compare la porta, installa il driver CH340.
Perché lo schermo del CYD resta bianco?
Uno schermo bianco indica che la retroilluminazione è accesa ma il driver del display non riceve dati validi. Quasi sempre il file User_Setup.h di TFT_eSPI non è configurato per il CYD o è selezionato il driver sbagliato. Controlla i pin e, sulle schede con due USB, prova il driver ST7789 al posto dell'ILI9341.
Quali pin sono liberi sull'ESP32 Cheap Yellow Display?
I pin utilizzabili sono i GPIO 22 e 27 del connettore CN1 e il GPIO 35 su P3, quest'ultimo solo in ingresso. Per un sensore I2C scrivi Wire.begin(27, 22) e alimentalo dai pin 3,3 V e GND di CN1. Non usare il GPIO 21, perché comanda la retroilluminazione.
LVGL funziona sul CYD senza PSRAM?
Sì, LVGL 9 gira fluido sul CYD. Non essendoci PSRAM, si usa un buffer di disegno pari a un decimo dello schermo (circa 15 KB) invece di un fotogramma intero. Con molti font grandi o immagini, il vero limite diventano flash e RAM; disattiva in lv_conf.h i font che non usi.
Posso usare touch e scheda SD contemporaneamente?
Sì, ma serve una configurazione in più, perché entrambi usano la periferica VSPI dell'ESP32 su pin diversi. La via più semplice è una libreria touch con SPI software. In alternativa riavvia il bus SPI con i pin della SD prima di ogni accesso e poi con quelli del touch.
Il CYD può funzionare a batteria?
La scheda funziona a 5 V e di solito assorbe 100–250 mA con retroilluminazione e Wi-Fi attivi. A batteria usa una cella Li-ion con un modulo di ricarica TP4056 e un convertitore step-up a 5 V, oppure semplicemente un power bank. Per più autonomia spegni schermo e Wi-Fi quando non servono e manda l'ESP32 in sleep.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Lettura dell'intensità luminosa con il modulo LDR ESP32
Monitoraggio in tempo reale sul Serial Monitor del valore grezzo dell'ADC del modulo LDR e della percentuale relativa di luce calcolata dai valori di riferimento al buio e alla luce. Questa percentuale non è una misurazione in lux. Spiega il principio di calibrazione del modulo. È consigliabile eseguirlo prima del Progetto 10, poiché serve a determinare il valore di soglia.

ESP32 HTTPClient + API meteo (con display OLED SSD1306)
L'ESP32 effettua via internet una chiamata REST a un'API meteo (wttr.in) con HTTPClient.h. A differenza della versione con LCD I2C, qui usiamo un display OLED SSD1306 (128×64), con testo grande e icone vettoriali per una resa più ricca. Sette icone meteo (sole, pioggia, neve e altre) vengono disegnate al volo, senza file bitmap.

ESP32 HTTPClient + API meteo (con schermo LCD)
L'ESP32 effettua via internet una chiamata REST a un'API meteo (wttr.in) con HTTPClient.h. La risposta JSON viene analizzata con ArduinoJson v7 e città, temperatura, umidità, condizioni meteo e vento compaiono su un display LCD I2C. wttr.in non richiede una chiave API: basta scrivere il nome di una città qualsiasi.

ESP32: ora reale da Internet tramite NTP
L'ESP32 si collega al Wi-Fi e ottiene l'ora esatta dai server NTP (Network Time Protocol) con precisione al millisecondo. Con configTzTime() si applica in automatico il fuso orario turco (TRT, UTC+3) e, nei paesi con l'ora legale, il cambio (DST) è gestito da una stringa POSIX TZ. L'ora viene stampata sul Serial Monitor e su un display LCD I2C opzionale.

Server web asincrono ESP32 (con indicazione dell'IP sul display LCD)
In questo progetto trasformiamo l'ESP32 in un server web asincrono che potrete controllare dal vostro telefono o computer collegato alla stessa rete Wi-Fi. Grazie alla libreria ESPAsyncWebServer, il server è in grado di elaborare più richieste contemporaneamente (a differenza del classico WebServer.h, che si blocca su una singola richiesta).

Data Logger di Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
Costruisci con l'ESP32 un registratore di temperatura e umidità con orario! Un sensore DHT22 legge temperatura e umidità una volta al minuto e ogni lettura viene salvata su una scheda microSD in formato CSV con l'ora reale del modulo RTC DS1307. Il display OLED mostra in tempo reale, a caratteri grandi, l'ultima temperatura, l'umidità, l'orario e il numero totale di registrazioni.

Controllo LED RGB ESP32
Generazione illimitata di colori con un singolo LED RGB invece di 3 LED separati. La transizione arcobaleno avviene impostando i valori R/G/B con analogWrite() come in Arduino. La teoria dei colori (come rosso+verde=giallo) viene vista in pratica.

ESP32 Riproduzione di melodia con cicalino
Riproduzione di una semplice melodia (Twinkle Twinkle Little Star) con un buzzer passivo. Le note vengono riprodotte con le funzioni tone() e noTone() come in Arduino - la stessa sintassi funziona con ESP32 Arduino Core 3.0+. È necessario utilizzare un cicalino passivo (il cicalino attivo non riproduce la melodia).
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

