ESP32Intermedio

ESP32 CYD: pantalla, touchscreen y microSD funcionando juntos sin conflictos

Aprende a usar pantalla, touchscreen y tarjeta microSD al mismo tiempo en la placa ESP32 CYD evitando los conflictos del bus SPI.

17 de mayo de 202660 min de armado~CLP $35.170

ESP32 CYD: pantalla, touchscreen y microSD funcionando juntos sin conflictos

Necesitas

Lista de materiales

ESP32-2432S028R (CYD - Cheap Yellow Display 2.8")
core
$24.990Agregar →
Tarjeta microSD 8GB o más (formato FAT32)
almacenamiento
$7.990Agregar →
Cable USB Tipo C a USB Tipo A 1m
alimentación y programación
$2.190Agregar →
PC con Arduino IDE 2.x instalado
entorno de desarrollo
no disponible

Introducción

¿Tienes una placa ESP32 CYD y al intentar usar la pantalla, el touch y la microSD a la vez todo se cae? No es tu código: es el bus SPI peleándose consigo mismo. En esta guía vas a resolver ese conflicto de raíz y dejar las tres funciones operando en paralelo.

La placa ESP32 CYD (Cheap Yellow Display), también conocida por su código ESP32-2432S028R, integra en un solo módulo un ESP32 WROOM, una pantalla TFT de 2.8" con resolución 240x320, un touchscreen resistivo y una ranura para tarjeta microSD. El problema aparece cuando quieres las tres cosas a la vez: todas hablan por SPI y se disputan los mismos pines.

El ejemplo que vas a montar muestra en pantalla las coordenadas del punto que tocas y, al mismo tiempo, las guarda en un archivo dentro de la microSD. Es la base perfecta para construir después loggers de datos con interfaz, paneles que recuerden su configuración o juegos que guarden el puntaje.

Probado en: ESP32-2432S028R 2.8" 240x320 con touchscreen resistivo. Si recién partes con esta placa, te conviene revisar primero un tutorial introductorio del CYD antes de seguir.

Por qué se produce el conflicto SPI

El ESP32 cuenta con dos buses SPI por hardware: VSPI y HSPI. Los pines por defecto son:

SPI	MOSI	MISO	SCLK	CS
VSPI	GPIO 23	GPIO 19	GPIO 18	GPIO 5
HSPI	GPIO 13	GPIO 12	GPIO 14	GPIO 15

En el CYD la microSD usa los pines por defecto de VSPI (MOSI 23, MISO 19, SCLK 18, CS 5). En los ejemplos típicos la pantalla se configura en HSPI y el touchscreen queda también en VSPI. Ahí está el nudo: el touchscreen escucha eventos de toque de forma continua, así que no es buena idea desactivarlo cada vez que escribes en la microSD. Y aunque en teoría varios dispositivos pueden compartir un mismo bus SPI usando distintos pines CS, en la práctica ese enfoque falla seguido.

Vista trasera de la placa ESP32 CYD con la ranura microSD y el conector USB

La solución: Software SPI para el touchscreen

El truco es sacar al touchscreen del bus VSPI por hardware y hacer que se comunique vía Software SPI (SoftSPI) sobre pines libres. Para eso usamos una versión modificada de la librería XPT2046_Touchscreen, que se llama XPT2046_TouchscreenSOFTSPI, junto con una librería auxiliar SoftSPI.

De esa forma cada periférico queda aislado:

La pantalla sigue en HSPI.
La microSD se queda con los pines hardware de VSPI.
El touchscreen corre por software, sin tocar ningún bus por hardware.

En el código, la microSD se declara explícitamente sobre VSPI y el touch se mueve a sus propios pines. Así se ve el bloque de defines en el Arduino IDE:

Código en el Arduino IDE con los pines de la microSD en VSPI y las pestañas de la librería SoftSPI

Prerrequisitos

Antes de avanzar, deja todo listo:

Arduino IDE 2.x instalado.
Placas ESP32 agregadas al Arduino IDE (vía Board Manager).
Librería TFT_eSPI instalada y configurada con el User_Setup.h correcto para el CYD. No uses los User_Setup que circulan por internet: usa el de la guía oficial de Random Nerd Tutorials.
Librería LVGL 9.x de kisvegabor instalada, con su lv_conf.h adaptado.
Librerías XPT2046_TouchscreenSOFTSPI y SoftSPI: descarga el .zip con los 4 archivos (.cpp y .h de ambas librerías) desde el repositorio que dejamos en la sección Recursos.

Paso 1: preparar la carpeta del sketch

Las librerías SoftSPI y la versión modificada del touchscreen las vamos a instalar localmente en la carpeta del sketch, no de forma global.

Abre el Arduino IDE y guarda un sketch nuevo (Archivo > Guardar como…) en la ubicación que prefieras.
Ve a Programa > Mostrar carpeta del programa para abrirla en el explorador.
Copia ahí los 4 archivos:
- XPT2046_TouchscreenSOFTSPI.cpp
- XPT2046_TouchscreenSOFTSPI.h
- SoftSPI.cpp
- SoftSPI.h
Reinicia el Arduino IDE. Los archivos deberían aparecer como pestañas adicionales del proyecto.

Carpeta del sketch en el explorador con los 4 archivos de la librería SoftSPI y XPT2046 modificada

Paso 2: conexiones físicas

En la placa CYD no necesitas cablear nada externo: pantalla, touchscreen y lector microSD ya vienen integrados en el PCB. Solo necesitas:

CYD conectada al PC con un cable USB (micro USB o tipo C según versión).
Tarjeta microSD formateada en FAT32 insertada en la ranura trasera de la placa.

Los pines internos quedan así:

Función	Pin GPIO	Notas
MicroSD MOSI	23	VSPI hardware
MicroSD MISO	19	VSPI hardware
MicroSD SCLK	18	VSPI hardware
MicroSD CS	5	VSPI hardware
Touch T_DIN	32	SoftSPI MOSI
Touch T_OUT	39	SoftSPI MISO
Touch T_CLK	25	SoftSPI CLK
Touch T_CS	33	Chip Select
Touch T_IRQ	36	Interrupción touch

Paso 3: subir el sketch

Con todo en su lugar, sube el código a la placa CYD. El sketch hace tres cosas:

Inicializa la microSD en VSPI y crea un archivo /touch_points.txt con encabezado x,y,z si todavía no existe.
Inicializa el touchscreen con SoftSPI usando los pines T_DIN, T_OUT y T_CLK.
Inicializa la pantalla TFT vía TFT_eSPI más LVGL para mostrar una etiqueta con la posición tocada.

Cada vez que tocas el touchscreen, el callback touchscreen_read() lee las coordenadas calibradas, las muestra en pantalla y las agrega como una nueva línea al archivo de la microSD.

Paso 4: probar

Después de subir el código:

Abre el Monitor Serial a 115200 baudios para ver el log de inicialización (tipo de tarjeta, capacidad y archivos existentes).
Toca varios puntos en la pantalla. Verás las coordenadas X, Y y la presión Z actualizándose en vivo.
Apaga la placa, extrae la microSD e insértala en tu PC.
Abre touch_points.txt: deberías ver todas las coordenadas guardadas en formato CSV.

Pantalla del CYD mostrando en vivo las coordenadas X, Y y Z del punto tocado con el dedo

Al revisar la tarjeta en el PC, el archivo de texto contiene cada toque registrado como una fila CSV, listo para procesar después en una planilla o un script:

Archivo touch_points.txt abierto en el PC con las coordenadas x, y, z guardadas en formato CSV

¿Cuándo NO necesitas la librería modificada?

Solo necesitas usar XPT2046_TouchscreenSOFTSPI cuando vas a operar las tres funciones a la vez (pantalla, touch y microSD). Si tu proyecto solo combina pantalla con touchscreen, o pantalla con microSD, puedes seguir usando la librería estándar XPT2046_Touchscreen sin problemas.

Variantes y mejoras

Una vez que tengas el ejemplo base funcionando, puedes llevarlo más lejos:

Logger con marca de tiempo: agrega un módulo RTC DS3231 por I2C y guarda cada toque con su fecha y hora exactas. Ideal si quieres registrar interacciones a lo largo del día.
Pantalla de inicio desde la microSD: carga una imagen o un logo guardado en la tarjeta y muéstralo al arrancar, así personalizas la interfaz sin recompilar el firmware.
Calibración guardada en la tarjeta: en vez de hardcodear los valores de calibración del touch, guárdalos en un archivo de la microSD y léelos al inicio. Así cada placa conserva su propia calibración aunque cambies de equipo.

Personalización para Chile

En Chile puedes conseguir todo lo necesario en MechatronicStore:

ESP32 WROOM con pantalla LCD táctil 2.8" LVGL (CYD) (SKU D-517): la misma placa ESP32-2432S028R del tutorial, con pantalla, touch y ranura microSD integrados.
Tarjeta microSD Kingston Clase 10 (SKU B-450V1): cualquier capacidad de 8GB en adelante sirve; formatéala en FAT32 antes de usarla.
Cable USB tipo C a USB tipo A 1m (SKU B-101): para alimentar y programar la placa desde el PC (revisa si tu versión del CYD usa micro USB o tipo C).

Recursos

Tutorial original (inglés): ESP32 CYD: Use Display, Touchscreen and MicroSD Card Simultaneously
Repositorio GitHub (librería XPT2046 modificada + SoftSPI + sketch): RuiSantosdotme/ESP32-TFT-Touchscreen
Archivos del proyecto (.zip): ESP32_CYD_Micro_SD_Card_Display_Touchscreen.zip

Versión chilena con componentes en stock local en MechatronicStore. Tutorial inspirado en el trabajo de Random Nerd Tutorials.

Paso a paso

Cómo armarlo

Preparar entorno y librerías
Instala las placas ESP32 en Arduino IDE, la librería TFT_eSPI de Bodmer con el User_Setup.h específico para CYD, y la librería LVGL 9.x. Descarga el .zip con los archivos de XPT2046_TouchscreenSOFTSPI y SoftSPI.
Copiar librerías a la carpeta del sketch
Guarda un sketch nuevo, abre su carpeta vía Programa > Mostrar carpeta del programa, y copia ahí los 4 archivos: XPT2046_TouchscreenSOFTSPI.cpp/.h y SoftSPI.cpp/.h. Reinicia Arduino IDE.
Insertar microSD y conectar la CYD
Formatea una tarjeta microSD en FAT32, insértala en la ranura trasera de la CYD y conecta la placa al PC mediante el cable USB correspondiente.
Cargar el sketch principal
Pega el código del ejemplo, selecciona la placa ESP32 Dev Module en Arduino IDE y sube el sketch. El código inicializa microSD, touchscreen vía SoftSPI y pantalla TFT con LVGL.
Probar y verificar guardado
Abre el Monitor Serial a 115200 baudios y toca puntos en la pantalla. Las coordenadas X, Y, Z se mostrarán en pantalla y se guardarán en /touch_points.txt. Extrae la microSD y abre el archivo en tu PC para confirmar.

Código fuente

Los snippets que necesitas

C++ · Sketch completo: pantalla + touchscreen (SoftSPI) + microSD en CYD

#include <SPI.h>
#include <TFT_eSPI.h>
#include <XPT2046_TouchscreenSOFTSPI.h>

// Pines del touchscreen (SoftSPI)
#define XPT2046_IRQ 36   // T_IRQ
#define XPT2046_MOSI 32  // T_DIN
#define XPT2046_MISO 39  // T_OUT
#define XPT2046_CLK 25   // T_CLK
#define XPT2046_CS 33    // T_CS

SoftSPI *tsSoftSpi;
XPT2046_TouchscreenSOFTSPI touchscreen(XPT2046_CS, XPT2046_IRQ);

#include <lvgl.h>
#include "FS.h"
#include "SD.h"

// Pines de la microSD (VSPI hardware)
#define SD_MISO  19
#define SD_MOSI  23
#define SD_SCK   18
#define SD_CS    5
SPIClass Sd_spi = SPIClass(VSPI);

#define SCREEN_WIDTH 240
#define SCREEN_HEIGHT 320

int x, y, z;

#define DRAW_BUF_SIZE (SCREEN_WIDTH * SCREEN_HEIGHT / 10 * (LV_COLOR_DEPTH / 8))
uint32_t draw_buf[DRAW_BUF_SIZE / 4];

static lv_obj_t * text_label_touch;

void appendFile(fs::FS &fs, const char * path, const char * message){
  File file = fs.open(path, FILE_APPEND);
  if(!file){ Serial.println("Failed to open file for appending"); return; }
  file.print(message);
  file.close();
}

void writeFile(fs::FS &fs, const char * path, const char * message){
  File file = fs.open(path, FILE_WRITE);
  if(!file){ Serial.println("Failed to open file for writing"); return; }
  file.print(message);
  file.close();
}

void touchscreen_read(lv_indev_t * indev, lv_indev_data_t * data) {
  if(touchscreen.tirqTouched() && touchscreen.touched(tsSoftSpi)) {
    TS_Point p = touchscreen.getPoint(tsSoftSpi);
    x = map(p.x, 200, 3700, 1, SCREEN_WIDTH);
    y = map(p.y, 240, 3800, 1, SCREEN_HEIGHT);
    z = p.z;
    data->state = LV_INDEV_STATE_PRESSED;
    data->point.x = x;
    data->point.y = y;

    String touch_data = "X = " + String(x) + "\nY = " + String(y) + "\nZ = " + String(z);
    lv_label_set_text(text_label_touch, touch_data.c_str());

    String sdMessage = String(x) + "," + String(y) + "," + String(z) + "\n";
    appendFile(SD, "/touch_points.txt", sdMessage.c_str());
  } else {
    data->state = LV_INDEV_STATE_RELEASED;
  }
}

void lv_create_main_gui(void) {
  text_label_touch = lv_label_create(lv_screen_active());
  lv_label_set_text(text_label_touch, "Toca la pantalla para probar");
  lv_obj_align(text_label_touch, LV_ALIGN_CENTER, 0, 0);

  static lv_style_t style_text_label;
  lv_style_init(&style_text_label);
  lv_style_set_text_font(&style_text_label, &lv_font_montserrat_18);
  lv_obj_add_style(text_label_touch, &style_text_label, 0);
}

void setup() {
  Serial.begin(115200);
  delay(1000);

  // Inicializa microSD en VSPI hardware
  Sd_spi.begin(SD_SCK, SD_MISO, SD_MOSI, SD_CS);
  if (!SD.begin(SD_CS, Sd_spi, 55000000)) {
    Serial.println("Card Mount Failed");
  }

  uint8_t cardType = SD.cardType();
  if(cardType == CARD_NONE){ Serial.println("No SD card attached"); return; }

  // Crea archivo si no existe
  File file = SD.open("/touch_points.txt");
  if(!file) {
    writeFile(SD, "/touch_points.txt", "x,y,z\r\n");
  }
  file.close();

  // Inicializa LVGL
  lv_init();

  // Touchscreen vía SoftSPI (la clave para evitar el conflicto con microSD)
  tsSoftSpi = new SoftSPI(XPT2046_MOSI, XPT2046_MISO, XPT2046_CLK);
  touchscreen.begin(tsSoftSpi);
  touchscreen.setRotation(2);

  // Pantalla TFT vía LVGL
  lv_display_t * disp = lv_tft_espi_create(SCREEN_WIDTH, SCREEN_HEIGHT, draw_buf, sizeof(draw_buf));
  lv_display_set_rotation(disp, LV_DISPLAY_ROTATION_270);

  lv_indev_t * indev = lv_indev_create();
  lv_indev_set_type(indev, LV_INDEV_TYPE_POINTER);
  lv_indev_set_read_cb(indev, touchscreen_read);

  lv_create_main_gui();
}

void loop() {
  lv_task_handler();
  lv_tick_inc(5);
  delay(5);
}

🔗Descargas

Etiquetas

#esp32 #cyd #touchscreen #microsd #lvgl #tft #softspi

Compartir este tutorial

WhatsApp X Email

Tutorial adaptado al español chileno desde el original en fuente original. Hicimos reescritura editorial + adaptación de precios CLP + linkeo con productos disponibles en MechatronicStore.

Más sobre ESP32

Tutoriales relacionados

Ver todos →

ESP32 CYD: pantalla, touchscreen y microSD funcionando juntos sin conflictos

Lista de materiales

Introducción

Por qué se produce el conflicto SPI

La solución: Software SPI para el touchscreen

Prerrequisitos

Paso 1: preparar la carpeta del sketch

Paso 2: conexiones físicas

Paso 3: subir el sketch

Paso 4: probar

¿Cuándo NO necesitas la librería modificada?

Variantes y mejoras

Personalización para Chile

Recursos

Cómo armarlo

Preparar entorno y librerías

Copiar librerías a la carpeta del sketch

Insertar microSD y conectar la CYD

Cargar el sketch principal

Probar y verificar guardado

Los snippets que necesitas

🔗Descargas

Tutoriales relacionados

Qué es M5Stack: la familia ESP32 modular que arma proyectos IoT sin protoboard

Kit de percepción física para un LLM con ESP32 y sensores con feedback

ESP32 Data Logger Web: gráficos históricos con BME280 y microSD

Control remoto IR para ESP32: módulo HX1838 y librería en modo NEC optimizado

Comentarios