ESP32 CYD: pantalla táctil Cheap Yellow Display paso a paso
Pantalla ESP32 CYD (ESP32-2432S028R): pines, configuración de TFT_eSPI y del táctil XPT2046, calibración, tarjeta SD, altavoz y tu primera interfaz LVGL.
La pantalla ESP32 CYD (Cheap Yellow Display), cuyo nombre de modelo es ESP32-2432S028R, es una placa de desarrollo lista para usar que reúne un ESP32, una pantalla táctil a color de 2,8 pulgadas, una ranura microSD, un LED RGB, un sensor de luz y una salida de altavoz en una sola placa amarilla. El apodo lo dice todo: es amarilla, es barata y trae pantalla. Conectas un cable USB, subes tu código y ya tienes una interfaz táctil sin soldar nada ni conectar un solo cable dupont.
En esta guía verás qué trae la placa, cómo distinguir las versiones y el mapa de pines completo. Después configurarás en el Arduino IDE las librerías TFT_eSPI y XPT2046_Touchscreen, escribirás texto en la pantalla, calibrarás el táctil, encenderás el LED RGB con botones en pantalla, guardarás datos en una tarjeta microSD y armarás tu primera interfaz real con LVGL. Al final encontrarás ideas de proyectos, como una estación del clima o un panel de casa inteligente, y soluciones a los problemas más comunes.

¿Qué es la ESP32 Cheap Yellow Display y qué trae la placa?
El corazón de la placa es un módulo ESP32-WROOM-32: procesador de doble núcleo de hasta 240 MHz, 520 KB de SRAM, 4 MB de flash, Wi-Fi de 2,4 GHz y Bluetooth. Todo lo que aprendiste en ¿Qué es el ESP32? vale también aquí. La pantalla está conectada al bus HSPI del ESP32, mientras que el chip XPT2046, que lee el panel táctil resistivo, va con pines propios en el segundo bus SPI (VSPI). Este detalle importa, porque los ejemplos genéricos de TFT suponen que el táctil comparte el bus de la pantalla y no funcionan en el CYD. No tiene PSRAM, así que en lugar de guardar toda la imagen en memoria se dibuja por partes.
| Característica | Valor |
|---|---|
| Módulo procesador | ESP32-WROOM-32 (doble núcleo, 240 MHz) |
| Memoria | 520 KB SRAM, 4 MB flash, sin PSRAM |
| Pantalla | TFT de 2,8 pulgadas, 240×320 píxeles, color de 16 bits (RGB565) |
| Controlador de pantalla | ILI9341 (en la versión de dos USB suele ser ST7789) |
| Táctil | Panel resistivo, controlador XPT2046 |
| Almacenamiento | Ranura para tarjeta microSD (SPI) |
| Extras | LED RGB, sensor de luz LDR, salida de altavoz (amplificador SC8002B) |
| USB y alimentación | Micro-USB, chip USB-serie CH340, 5 V |
| Botones | BOOT (GPIO 0) y RST |
Versiones de la placa: ¿qué significa ESP32-2432S028R?
El nombre del modelo es un resumen: 2432 indica la resolución (240×320), S028 el tamaño de la pantalla (2,8 pulgadas) y la R final, táctil resistivo. En la misma familia hay placas que terminan en C (táctil capacitivo) y en N (sin táctil). Como los vendedores llaman a todas "Cheap Yellow Display", revisa el modelo exacto antes de comprar: el mapa de pines y el controlador de pantalla pueden cambiar entre versiones.
| Placa | Pantalla | Cómo reconocerla | Ojo |
|---|---|---|---|
| ESP32-2432S028R (un USB) | 2,8" 240×320, ILI9341 | Solo conector micro-USB | La versión en la que se basan la mayoría de los ejemplos y esta guía |
| ESP32-2432S028R (dos USB) | 2,8" 240×320, normalmente ST7789 | Micro-USB y USB-C juntos | Los colores pueden verse invertidos; hay que cambiar el controlador o usar invertDisplay |
| ESP32-2432S024 | 2,4" 240×320 | Pantalla más pequeña | Los pines y el chip táctil pueden ser distintos |
| ESP32-2432S032 | 3,2" 240×320 | Placa más grande | La versión capacitiva lee el táctil por I2C |
| ESP32-3248S035 | 3,5" 320×480, ST7796 | Mayor resolución | Necesita su propia configuración de TFT_eSPI |
Pines del ESP32 CYD
| Componente | Señal y GPIO | Nota |
|---|---|---|
| Pantalla (ILI9341) | MOSI 13, MISO 12, SCK 14, CS 15, DC 2 | Bus HSPI; RST unido a EN |
| Retroiluminación | GPIO 21 | HIGH = encendida; se puede atenuar con PWM |
| Táctil (XPT2046) | CLK 25, MOSI 32, MISO 39, CS 33, IRQ 36 | Bus VSPI, separado de la pantalla |
| microSD | SCK 18, MISO 19, MOSI 23, CS 5 | Pines VSPI por defecto |
| LED RGB | Rojo 4, verde 16, azul 17 | Ánodo común: LOW = encendido |
| Sensor de luz LDR | GPIO 34 | Solo entrada, se lee con analogRead |
| Altavoz | GPIO 26 | Amplificador SC8002B, conector SPEAK |
| Botón BOOT | GPIO 0 | También se puede leer como botón en tu programa |
| Puerto serie (P1) | TX 1, RX 3 | Compartido con el chip USB-serie |
| Pines libres | GPIO 22, 27 (CN1), GPIO 35 (P3) | El 35 es solo entrada |
Los pequeños conectores JST (paso de 1,25 mm) del borde son tu puerta al exterior. CN1 tiene GND, GPIO 22, GPIO 27 y 3,3 V, ideal para un sensor I2C: escribe Wire.begin(27, 22) y conecta directamente un sensor como el BME280. P3 ofrece GPIO 35, 22 y 21, y P1 lleva la entrada de 5 V y las líneas serie TX/RX. Para revisar estos pines junto con las restricciones generales del ESP32, abre la herramienta de pines.
Configuración del Arduino IDE: placa y librerías
- Instala el paquete de placas ESP32 en el Arduino IDE (esp32 by Espressif en el Gestor de placas) y elige ESP32 Dev Module como placa.
- Conecta la placa con un cable USB. Si no aparece ningún puerto, instala el driver CH340 y asegúrate de que el cable transmita datos y no solo carga.
- Instala TFT_eSPI (Bodmer) y XPT2046_Touchscreen (Paul Stoffregen) desde el Gestor de librerías.
- Reemplaza el contenido de User_Setup.h en la carpeta de TFT_eSPI por la configuración de la siguiente sección.
- Si la carga se detiene con "Failed to connect", mantén presionado BOOT cuando empiece la subida; más detalles en ESP32 Failed to connect.
Configurar TFT_eSPI: User_Setup.h
TFT_eSPI es una librería muy rápida, y esa velocidad viene de una configuración de pines fijada al compilar. Se guarda en el archivo User_Setup.h dentro de la carpeta de la librería (Documentos > Arduino > libraries > TFT_eSPI). Haz una copia de seguridad, borra todo su contenido y pega las líneas de abajo. Al actualizar la librería este archivo vuelve a su valor original, así que guarda tu versión aparte y cópiala de nuevo después de cada actualización.
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 2500000Primera prueba: texto en pantalla y dibujo con el táctil
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 línea clave es SPIClass touchSpi(VSPI): pone el controlador táctil en el segundo bus SPI con sus propios pines, independiente de la pantalla. ts.setRotation(1) y tft.setRotation(1) deben tener el mismo valor; si no, el punto que tocas y el que se dibuja no coinciden. En horizontal, las coordenadas van de 0 a 319 en x y de 0 a 239 en y. Después de subir el código, intenta escribir en la pantalla con un lápiz táctil; si las líneas siguen tu mano, la pantalla y el táctil están bien configurados.
Calibración de la pantalla táctil (XPT2046)
El XPT2046 no entrega píxeles, sino valores en bruto entre 0 y 4095. Los números 200, 3700 y 240, 3800 del código son la parte de ese rango que coincide con los bordes de la pantalla y cambian un poco de una placa a otra. Para calibrar, abre el Monitor Serie a 115200 baudios, toca las cuatro esquinas con un lápiz y anota los valores mínimos y máximos de x e y. Pon esos cuatro números en las líneas map() y el desfase entre tu toque y el punto dibujado bajará a unos pocos píxeles. El panel resistivo también mide la presión: touched() solo devuelve true con una presión suficiente, pero si ves valores que tiemblan cerca de los bordes, puedes poner un umbral más alto para p.z.
LED RGB, LDR y altavoz: un panel de control táctil
El LED RGB, el LDR y la salida de altavoz de la parte trasera alcanzan para tu primer proyecto. El siguiente código dibuja tres botones grandes; al tocar uno se enciende o se apaga ese color del LED y el altavoz hace un clic corto. La barra amarilla de abajo muestra la lectura del sensor de luz y se actualiza cada medio segundo.
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}Como el LED RGB es de ánodo común, la lógica está invertida: escribir LOW enciende un color y HIGH lo apaga; por eso setup() pone primero los tres pines en HIGH. La variable wasTouched evita que un botón cambie una y otra vez mientras tu dedo sigue en la pantalla; solo cuenta el momento en que empieza el toque. La lectura del LDR puede moverse en un rango estrecho por la resistencia del divisor de la placa; mide los valores de oscuridad y de luz en tu cuarto y elige el umbral con ellos. En el conector de altavoz puedes poner una bocina pequeña de 8 Ω y tocar pitidos y melodías sencillas con tone().
Guardar datos en la tarjeta microSD
La ranura usa los pines VSPI por defecto del ESP32 (18, 19, 23 y 5 para CS), así que basta con SD.begin(5). Formatea la tarjeta en FAT32; las de hasta 32 GB funcionan sin problemas. El ejemplo de abajo agrega cada cinco segundos el tiempo y el nivel de luz al archivo log.csv, que luego puedes abrir en Excel o en cualquier hoja de cálculo. Para el uso general de tarjetas SD, consulta la guía del módulo de tarjeta 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}Tu primera interfaz con LVGL
Dibujar botones, deslizadores y gráficas uno por uno con fillRect se vuelve pesado rápido. LVGL es una librería gráfica de código abierto con widgets al estilo de un celular (botones, deslizadores, listas, gráficas, pestañas) que además gestiona el táctil por ti. Desde la versión 9 trae soporte integrado para TFT_eSPI, así que ya no tienes que escribir tu propia función de envío a la pantalla.
- Instala la librería lvgl (versión 9.x) desde el Gestor de librerías.
- Copia lv_conf_template.h de la carpeta libraries/lvgl un nivel arriba, junto a la carpeta lvgl, con el nombre lv_conf.h.
- Cambia #if 0 al inicio del archivo por #if 1 y pon LV_USE_TFT_ESPI en 1.
- Si quieres fuentes más grandes, pon también en 1 líneas como LV_FONT_MONTSERRAT_20; cada fuente ocupa 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}Agrega setup() y loop() al final de este código: en setup() llama solo a lvglSetup() y en loop() solo a lvglLoop(). La imagen se dibuja por partes con un búfer de una décima parte de la pantalla (unos 15 KB), un buen equilibrio para un CYD sin PSRAM. Como LVGL hace la rotación por su cuenta, las coordenadas táctiles se entregan en vertical (240×320) y LVGL las convierte a la pantalla horizontal. El botón es conmutable (checkable), así que cada toque cambia el LED rojo, y el deslizador escribe su porcentaje en la etiqueta de abajo.
Ideas de proyectos con el CYD: clima y panel de casa inteligente
- Pantalla del clima: Usa la API del clima con ESP32 para mostrar temperatura, humedad y el pronóstico del día con íconos.
- Panel de casa inteligente: Controla focos y contactos con botones en pantalla mediante MQTT y Home Assistant.
- Reloj de escritorio: Muestra la hora de internet por NTP con dígitos grandes y baja la retroiluminación de noche según el LDR.
- Tablero de sensores: Grafica en vivo temperatura, humedad y presión de un sensor I2C conectado a CN1.
- Registrador de datos: Guarda las mediciones en la microSD y muestra una gráfica de las últimas 24 horas.
- Juegos táctiles: Crea gato (tres en raya), la viborita o un juego de memoria para jugar con el lápiz.
Errores comunes y soluciones
| Síntoma | Causa probable | Solución |
|---|---|---|
| Pantalla en blanco o negra | User_Setup.h sin configurar o controlador incorrecto | Copia la configuración de esta guía; en placas de dos USB prueba ST7789 |
| Colores como un negativo | No coincide el controlador o la inversión de color | Agrega tft.invertDisplay(1) o cambia el controlador |
| El táctil no responde | Se supuso que el táctil comparte el bus SPI de la pantalla | Usa touchSpi(VSPI) con los pines 25, 32, 39, 33 |
| El toque y el dibujo no coinciden | La calibración no corresponde a tu placa | Mide los valores en bruto de las esquinas y actualiza las líneas map() |
| Parpadeo o líneas deformadas | Reloj SPI demasiado alto | Baja SPI_FREQUENCY a 27000000 |
| Se reinicia al encender el Wi-Fi | El puerto USB o el cable no dan suficiente corriente | Usa un cable corto y bueno y un cargador de al menos 1 A |
| La carga no empieza | Falta el driver CH340 o la placa no está en modo descarga | Instala el driver y presiona BOOT al iniciar la carga |
La pantalla ESP32 CYD es el camino más corto hacia un proyecto con ESP32 y pantalla: sin maraña de cables, sin soldar, solo código. Si prefieres trabajar con módulos sueltos en la protoboard, la guía de la pantalla TFT ILI9341 explica el mismo controlador. En la app BlueGrays encontrarás los proyectos de clima, reloj NTP, servidor web y LDR con diagramas y código paso a paso, listos para llevarlos a la pantalla del CYD.
Preguntas frecuentes
¿Qué placa elijo en el Arduino IDE para la ESP32 CYD?
Elige ESP32 Dev Module, porque el CYD lleva un módulo ESP32-WROOM-32 normal. Deja la flash en 4 MB y, si la carga falla, baja la velocidad a 115200. Si no aparece el puerto, instala el driver CH340.
¿Por qué la pantalla del CYD se queda en blanco?
La pantalla blanca indica que la retroiluminación está encendida, pero el controlador no recibe datos válidos. Casi siempre el archivo User_Setup.h de TFT_eSPI no está configurado para el CYD o se eligió el controlador equivocado. Revisa los pines y, en placas con dos USB, prueba el controlador ST7789 en lugar del ILI9341.
¿Qué pines quedan libres en la Cheap Yellow Display?
Los pines disponibles son GPIO 22 y 27 en el conector CN1 y GPIO 35 en P3; el 35 solo funciona como entrada. Para sensores I2C escribe Wire.begin(27, 22) y aliméntalos con los pines de 3,3 V y GND de CN1. No uses el GPIO 21, porque controla la retroiluminación.
¿Funciona LVGL en el ESP32 CYD sin PSRAM?
Sí, LVGL 9 funciona con fluidez en el CYD. Como no hay PSRAM, se usa un búfer de dibujo de una décima parte de la pantalla (unos 15 KB) en lugar de un cuadro completo. Si agregas muchas fuentes grandes o imágenes, el límite real será la flash y la RAM; desactiva en lv_conf.h las fuentes que no uses.
¿Puedo usar el táctil y la tarjeta SD al mismo tiempo?
Sí, pero requiere configuración extra, porque ambos usan el periférico VSPI del ESP32 con pines distintos. Lo más fácil es una librería táctil que use SPI por software. La otra opción es reiniciar el bus SPI con los pines de la SD antes de cada acceso y luego con los del táctil.
¿Se puede alimentar el CYD con batería?
La placa funciona con 5 V y suele consumir entre 100 y 250 mA con la retroiluminación y el Wi-Fi encendidos. Para usarla con batería pon una celda Li-ion con un módulo de carga TP4056 y un elevador a 5 V, o simplemente un power bank. Para que dure más, apaga la pantalla y el Wi-Fi cuando no se usen y pon el ESP32 en modo de bajo consumo.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Lectura de la intensidad luminosa con el módulo LDR del ESP32
Visualización en tiempo real en el monitor serie del valor bruto del ADC del módulo LDR y del porcentaje relativo de luz calculado a partir de referencias de oscuridad y claridad. Este porcentaje no es una medición en lux. Explica el funcionamiento de la calibración del módulo. Es recomendable realizarlo antes del Proyecto 10, ya que se utiliza para determinar el valor umbral.

ESP32 HTTPClient + API del tiempo (con pantalla OLED SSD1306)
El ESP32 hace una llamada REST por internet a una API del tiempo (wttr.in) con HTTPClient.h. A diferencia de la versión con LCD I2C, aquí usamos una pantalla OLED SSD1306 (128×64), con letra grande e iconos vectoriales para una vista más rica. Siete iconos del tiempo (soleado, lluvia, nieve y más) se dibujan al momento, sin archivos bitmap.

ESP32 HTTPClient + API del tiempo (con pantalla LCD)
El ESP32 hace una llamada REST por internet a una API del tiempo (wttr.in) con HTTPClient.h. La respuesta JSON se analiza con ArduinoJson v7, y la ciudad, la temperatura, la humedad, el estado del tiempo y el viento aparecen en una LCD I2C. wttr.in no pide clave de API: basta con escribir el nombre de cualquier ciudad.

ESP32: hora real desde Internet con NTP
El ESP32 se conecta al Wi-Fi y obtiene la hora real de servidores NTP (Network Time Protocol) con precisión de milisegundos. Gracias a configTzTime(), se aplica automáticamente la zona horaria de Turquía (TRT, UTC+3), y en los países con horario de verano el cambio (DST) se gestiona solo mediante una cadena POSIX TZ. La hora se muestra en el Serial Monitor y en una LCD I2C opcional.

Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)
En este proyecto, convertimos el ESP32 en un servidor web asíncrono que puedes controlar desde tu teléfono o tu ordenador, siempre que estén conectados a la misma red Wi-Fi. Gracias a la biblioteca ESPAsyncWebServer, el servidor puede procesar varias solicitudes al mismo tiempo (a diferencia del clásico WebServer.h, que se bloquea con una sola solicitud).

Registrador de Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
¡Monta con el ESP32 un registrador de temperatura y humedad con hora! Un sensor DHT22 lee la temperatura y la humedad una vez por minuto, y cada lectura se guarda en una tarjeta microSD en formato CSV con la hora real del módulo RTC DS1307. La pantalla OLED muestra en vivo y con letra grande la última temperatura, la humedad, la marca de tiempo y el total de registros.

Control de LED RGB con ESP32
Generación ilimitada de colores con un solo LED RGB en lugar de 3 LEDs separados. Hacemos transición arco iris estableciendo valores R/G/B con analogWrite() como en Arduino. La teoría del color (como rojo+verde=amarillo) se ve de forma práctica.

ESP32 Reproducción de melodías con zumbador
Tocando una melodía simple (Twinkle Twinkle Little Star) con un zumbador pasivo. Tocamos las notas con las funciones tone() y noTone() como en Arduino - la misma sintaxis funciona con ESP32 Arduino Core 3.0+. Se debe utilizar un zumbador pasivo (el zumbador activo no reproduce la melodía).
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

