Componenti · 8 min di lettura

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.

Modulo display TFT da 2,8 pollici con driver ILI9341
Un modulo TFT ILI9341 venduto a parte: il display da 2,8 pollici del CYD usa lo stesso driver; la differenza è che l'ESP32 e il circuito touch stanno sulla stessa scheda.

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.

CaratteristicaValore
Modulo processoreESP32-WROOM-32 (dual core, 240 MHz)
Memoria520 KB SRAM, 4 MB flash, niente PSRAM
DisplayTFT da 2,8 pollici, 240×320 pixel, colore a 16 bit (RGB565)
Driver del displayILI9341 (sulla versione con due USB di solito ST7789)
TouchPannello resistivo, controller XPT2046
Memoria esternaSlot per scheda microSD (SPI)
ExtraLED RGB, sensore di luce LDR, uscita altoparlante (amplificatore SC8002B)
USB e alimentazioneMicro-USB, chip USB-seriale CH340, 5 V
PulsantiBOOT (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.

SchedaDisplayCome riconoscerlaAttenzione
ESP32-2432S028R (un USB)2,8" 240×320, ILI9341Solo presa micro-USBLa versione su cui si basano la maggior parte degli esempi e questa guida
ESP32-2432S028R (due USB)2,8" 240×320, di solito ST7789Micro-USB e USB-C affiancateI colori possono apparire invertiti; serve cambiare driver o usare invertDisplay
ESP32-2432S0242,4" 240×320Schermo più piccoloPin e chip touch possono essere diversi
ESP32-2432S0323,2" 240×320Scheda più grandeLa versione capacitiva legge il touch via I2C
ESP32-3248S0353,5" 320×480, ST7796Risoluzione più altaRichiede una propria configurazione TFT_eSPI
Sui CYD con due porte USB (micro-USB + USB-C) il display ha di solito un driver ST7789. Con l'impostazione ILI9341 lo schermo può accendersi, ma i colori sembrano un negativo: bianco al posto del nero, giallo al posto del blu. In questo caso scegli ST7789_DRIVER in User_Setup.h oppure aggiungi tft.invertDisplay(1) subito dopo tft.init().

Pinout del CYD

ComponenteSegnale e GPIONota
Display (ILI9341)MOSI 13, MISO 12, SCK 14, CS 15, DC 2Bus HSPI; RST collegato a EN
RetroilluminazioneGPIO 21HIGH = accesa; regolabile in PWM
Touch (XPT2046)CLK 25, MOSI 32, MISO 39, CS 33, IRQ 36Bus VSPI, separato dal display
microSDSCK 18, MISO 19, MOSI 23, CS 5Pin VSPI predefiniti
LED RGBRosso 4, verde 16, blu 17Anodo comune: LOW = acceso
Sensore di luce LDRGPIO 34Solo ingresso, si legge con analogRead
AltoparlanteGPIO 26Amplificatore SC8002B, connettore SPEAK
Pulsante BOOTGPIO 0Si può leggere anche come pulsante nello sketch
Porta seriale (P1)TX 1, RX 3Condivisa con il chip USB-seriale
Pin liberiGPIO 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.

Il GPIO 21 del connettore P3 comanda anche la retroilluminazione; se ci colleghi qualcosa e porti il pin a LOW, lo schermo si spegne. Il GPIO 35 funziona solo come ingresso e non può pilotare né LED né relè. Se alimenti un componente esterno dal pin 3,3 V di CN1, non chiedergli centinaia di milliampere: la scheda consuma già parecchia corrente per display e Wi-Fi.

Configurare l'Arduino IDE: scheda e librerie

  1. Installa il pacchetto schede ESP32 nell'Arduino IDE (esp32 by Espressif nel Gestore schede) e scegli ESP32 Dev Module come scheda.
  2. 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.
  3. Installa TFT_eSPI (Bodmer) e XPT2046_Touchscreen (Paul Stoffregen) dal Gestore librerie.
  4. Sostituisci il contenuto di User_Setup.h nella cartella di TFT_eSPI con le impostazioni della sezione successiva.
  5. 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.

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

Primo test: testo sul display e disegno con il touch

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

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}

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.

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}
Il controller touch e la scheda SD usano entrambi la periferica VSPI, ma su pin diversi. Se ti servono tutti e due nello stesso sketch, scegli una libreria che legga il touch via SPI software (per esempio XPT2046_Bitbang) oppure riavvia il bus SPI con i pin giusti prima e dopo ogni accesso alla scheda. Altrimenti uno smette di rispondere mentre l'altro lavora.

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.

  1. Installa la libreria lvgl (versione 9.x) dal Gestore librerie.
  2. Copia lv_conf_template.h dalla cartella libraries/lvgl un livello più in alto, accanto alla cartella lvgl, e rinominalo lv_conf.h.
  3. Cambia #if 0 all'inizio del file in #if 1 e imposta LV_USE_TFT_ESPI a 1.
  4. Per caratteri più grandi imposta a 1 anche righe come LV_FONT_MONTSERRAT_20; ogni font occupa memoria 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}

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

SintomoCausa probabileSoluzione
Schermo bianco o neroUser_Setup.h non configurato o driver sbagliatoCopia le impostazioni di questa guida; sulla scheda a due USB prova ST7789
Colori come un negativoDriver o inversione colori non corrispondonoAggiungi tft.invertDisplay(1) o cambia driver
Il touch non rispondeTouch ritenuto sullo stesso bus SPI del displayUsa touchSpi(VSPI) con i pin 25, 32, 39, 33
Tocco e disegno sfasatiValori di calibrazione non adatti alla schedaMisura i valori grezzi degli angoli e aggiorna le righe map()
Sfarfallio o linee distorteClock SPI troppo altoAbbassa SPI_FREQUENCY a 27000000
Si riavvia quando parte il Wi-FiPorta USB o cavo non danno abbastanza correnteUsa un cavo corto e di qualità e un alimentatore da almeno 1 A
Il caricamento non parteManca il driver CH340 o la scheda non è in modalità downloadInstalla il driver e premi BOOT all'avvio del caricamento
Se la scheda si riavvia di continuo mentre si connette al Wi-Fi e il Monitor seriale mostra "Brownout detector was triggered", il problema è l'alimentazione, non il codice; trovi i dettagli in errori brownout e Guru Meditation dell'ESP32.

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.

Vedi tutti i progetti
Lettura dell'intensità luminosa con il modulo LDR ESP32
ES-11Principiante

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.

4.6(36)
55
ESP32 HTTPClient + API meteo (con display OLED SSD1306)
ES-32Avanzato
Premium

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.

4.3(10)
22
ESP32 HTTPClient + API meteo (con schermo LCD)
ES-31Avanzato
Premium

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.

4.7(13)
20
ESP32: ora reale da Internet tramite NTP
ES-26Avanzato
Premium

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.

4.5(13)
22
Server web asincrono ESP32 (con indicazione dell'IP sul display LCD)
ES-27Avanzato

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

4.8(16)
26
Data Logger di Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avanzato
Premium

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.

4.7(7)
12
Controllo LED RGB ESP32
ES-9Principiante

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.

4.6(29)
52
ESP32 Riproduzione di melodia con cicalino
ES-12Principiante
Premium

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

4.8(30)
55