Componentes · 9 min de lectura

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.

Módulo de pantalla TFT de 2,8 pulgadas con controlador ILI9341
Un módulo TFT ILI9341 suelto: la pantalla de 2,8 pulgadas del CYD usa el mismo controlador; la diferencia es que el ESP32 y el circuito táctil van en la misma placa.

¿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ísticaValor
Módulo procesadorESP32-WROOM-32 (doble núcleo, 240 MHz)
Memoria520 KB SRAM, 4 MB flash, sin PSRAM
PantallaTFT de 2,8 pulgadas, 240×320 píxeles, color de 16 bits (RGB565)
Controlador de pantallaILI9341 (en la versión de dos USB suele ser ST7789)
TáctilPanel resistivo, controlador XPT2046
AlmacenamientoRanura para tarjeta microSD (SPI)
ExtrasLED RGB, sensor de luz LDR, salida de altavoz (amplificador SC8002B)
USB y alimentaciónMicro-USB, chip USB-serie CH340, 5 V
BotonesBOOT (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.

PlacaPantallaCómo reconocerlaOjo
ESP32-2432S028R (un USB)2,8" 240×320, ILI9341Solo conector micro-USBLa 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 ST7789Micro-USB y USB-C juntosLos colores pueden verse invertidos; hay que cambiar el controlador o usar invertDisplay
ESP32-2432S0242,4" 240×320Pantalla más pequeñaLos pines y el chip táctil pueden ser distintos
ESP32-2432S0323,2" 240×320Placa más grandeLa versión capacitiva lee el táctil por I2C
ESP32-3248S0353,5" 320×480, ST7796Mayor resoluciónNecesita su propia configuración de TFT_eSPI
En los CYD con dos puertos USB (micro-USB + USB-C) la pantalla suele llevar un controlador ST7789. Con la configuración ILI9341 la pantalla puede encender, pero los colores se ven como un negativo: blanco en lugar de negro, amarillo en lugar de azul. En ese caso elige ST7789_DRIVER en User_Setup.h o agrega tft.invertDisplay(1) justo después de tft.init().

Pines del ESP32 CYD

ComponenteSeñal y GPIONota
Pantalla (ILI9341)MOSI 13, MISO 12, SCK 14, CS 15, DC 2Bus HSPI; RST unido a EN
RetroiluminaciónGPIO 21HIGH = encendida; se puede atenuar con PWM
Táctil (XPT2046)CLK 25, MOSI 32, MISO 39, CS 33, IRQ 36Bus VSPI, separado de la pantalla
microSDSCK 18, MISO 19, MOSI 23, CS 5Pines VSPI por defecto
LED RGBRojo 4, verde 16, azul 17Ánodo común: LOW = encendido
Sensor de luz LDRGPIO 34Solo entrada, se lee con analogRead
AltavozGPIO 26Amplificador SC8002B, conector SPEAK
Botón BOOTGPIO 0También se puede leer como botón en tu programa
Puerto serie (P1)TX 1, RX 3Compartido con el chip USB-serie
Pines libresGPIO 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.

El GPIO 21 del conector P3 también controla la retroiluminación; si conectas algo ahí y pones el pin en LOW, la pantalla se apaga. El GPIO 35 funciona solo como entrada, así que no puede manejar un LED ni un módulo relé. Si alimentas un componente externo desde el pin de 3,3 V de CN1, no le pidas cientos de miliamperios; la placa ya consume bastante corriente con la pantalla y el Wi-Fi.

Configuración del Arduino IDE: placa y librerías

  1. 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.
  2. 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.
  3. Instala TFT_eSPI (Bodmer) y XPT2046_Touchscreen (Paul Stoffregen) desde el Gestor de librerías.
  4. Reemplaza el contenido de User_Setup.h en la carpeta de TFT_eSPI por la configuración de la siguiente sección.
  5. 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.

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

Primera prueba: texto en pantalla y dibujo con el táctil

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

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}

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.

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}
El controlador táctil y la tarjeta SD usan el periférico VSPI, pero con pines diferentes. Si necesitas ambos en el mismo programa, elige una librería que lea el táctil por SPI por software (por ejemplo XPT2046_Bitbang) o reinicia el bus SPI con los pines correctos antes y después de cada acceso a la SD. Si no, uno deja de responder mientras el otro trabaja.

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.

  1. Instala la librería lvgl (versión 9.x) desde el Gestor de librerías.
  2. Copia lv_conf_template.h de la carpeta libraries/lvgl un nivel arriba, junto a la carpeta lvgl, con el nombre lv_conf.h.
  3. Cambia #if 0 al inicio del archivo por #if 1 y pon LV_USE_TFT_ESPI en 1.
  4. Si quieres fuentes más grandes, pon también en 1 líneas como LV_FONT_MONTSERRAT_20; cada fuente ocupa 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}

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íntomaCausa probableSolución
Pantalla en blanco o negraUser_Setup.h sin configurar o controlador incorrectoCopia la configuración de esta guía; en placas de dos USB prueba ST7789
Colores como un negativoNo coincide el controlador o la inversión de colorAgrega tft.invertDisplay(1) o cambia el controlador
El táctil no respondeSe supuso que el táctil comparte el bus SPI de la pantallaUsa touchSpi(VSPI) con los pines 25, 32, 39, 33
El toque y el dibujo no coincidenLa calibración no corresponde a tu placaMide los valores en bruto de las esquinas y actualiza las líneas map()
Parpadeo o líneas deformadasReloj SPI demasiado altoBaja SPI_FREQUENCY a 27000000
Se reinicia al encender el Wi-FiEl puerto USB o el cable no dan suficiente corrienteUsa un cable corto y bueno y un cargador de al menos 1 A
La carga no empiezaFalta el driver CH340 o la placa no está en modo descargaInstala el driver y presiona BOOT al iniciar la carga
Si la placa se reinicia una y otra vez al conectarse al Wi-Fi y el Monitor Serie muestra "Brownout detector was triggered", el problema es la alimentación, no tu código; tienes los detalles en errores brownout y Guru Meditation del ESP32.

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.

Ver todos los proyectos
Lectura de la intensidad luminosa con el módulo LDR del ESP32
ES-11Principiante

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.

4.6(36)
55
ESP32 HTTPClient + API del tiempo (con pantalla OLED SSD1306)
ES-32Avanzado
Premium

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.

4.3(10)
22
ESP32 HTTPClient + API del tiempo (con pantalla LCD)
ES-31Avanzado
Premium

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.

4.7(13)
20
ESP32: hora real desde Internet con NTP
ES-26Avanzado
Premium

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.

4.5(13)
22
Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)
ES-27Avanzado

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

4.8(16)
26
Registrador de Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avanzado
Premium

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.

4.7(7)
12
Control de LED RGB con ESP32
ES-9Principiante

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.

4.6(29)
52
ESP32 Reproducción de melodías con zumbador
ES-12Principiante
Premium

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

4.8(30)
55