ChatGPT – LVGL ESP32 UI

Saved on 28/1/2026, 17:50:26

Esta conversación con Chat GPT fue para intentar resolver el problema de la tarjeta china amarilla (es que es amarilla) ESP32 TFT Touch SD. Pero que no pude usar en toda su extensión.
Quizá es un problema de voltaje de alimentación, y más que de voltaje, de intensidad suficiente, para mantener el consumo total.
Pero claramente he perdido mucho tiempo buscando los pines de configuración para indicarle en el código arduino que pines eran los que usaba la TFT, el panel Táctil y la Tarjera micro SD.

https://chatgpt.com/share/6979d6bf-9a10-8003-9ffd-9eea9e35befe

Si tengo solución, lo actualizaré.
Dejo todo esto porque hay un montón de código propuestas y estrategias y no quiero que se pierdan para poder estudiarlas.

USER

Tengo una pantalla TFT en una ESP32 con un panel touch.
El panel touch comparte algunos pines del SPI del TFT, ahora quiero conectar la tarjeta SD que tiene también la tarjeta.

Te pongo el código que funciona con el TFT y el TOUCH

Este codigo funciona:

/***
Test táctil para ESP32 JC2432W328 con XPT2046

Esta placa tiene el táctil en un bus SPI separado de la pantalla.

PANTALLA ST7789 (HSPI):
- TFT_MOSI: 13
- TFT_MISO: 12
- TFT_SCLK: 14
- TFT_CS: 15
- TFT_DC: 2
- TFT_BL: 27

TÁCTIL XPT2046 (Bus SPI separado):
- TP_CLK: 25
- TP_MOSI (DIN): 32
- TP_MISO (OUT): 39
- TP_CS: 33
- TP_IRQ: 36

***/

include 

include 

include 

// ----------------------------
// Pines del táctil XPT2046
// ----------------------------

define XPT2046_IRQ 36

define XPT2046_MOSI 32

define XPT2046_MISO 39

define XPT2046_CLK 25

define XPT2046_CS 33

// Crear instancia SPI para el táctil (usar VSPI)
SPIClass touchSPI = SPIClass(VSPI);

// Crear instancia del táctil
XPT2046_Touchscreen ts(XPT2046_CS, XPT2046_IRQ);

// Crear instancia de la pantalla
TFT_eSPI tft = TFT_eSPI();

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

Serial.println("n=================================");
Serial.println("Test Táctil JC2432W328 XPT2046");
Serial.println("=================================n");

// Inicializar el bus SPI para el táctil
Serial.println("Inicializando SPI para táctil...");
touchSPI.begin(XPT2046_CLK, XPT2046_MISO, XPT2046_MOSI, XPT2046_CS);

// Inicializar el táctil con el bus SPI
Serial.println("Inicializando XPT2046...");

// IMPORTANTE: Asegúrate de tener XPT2046_Touchscreen versión >= 1.4
// Si tu versión no tiene begin(SPIClass&), actualiza la biblioteca
ts.begin(touchSPI);
ts.setRotation(1); // Ajusta según la orientación de tu pantalla

Serial.println("Táctil inicializado!");

// Inicializar la pantalla
Serial.println("Inicializando pantalla TFT...");
tft.init();
tft.setRotation(1); // Modo paisaje
tft.fillScreen(TFT_BLACK);

// Mostrar mensaje en pantalla
tft.setTextColor(TFT_WHITE, TFT_BLACK);
tft.setTextSize(2);
tft.setCursor(20, 100);
tft.println("Toca la pantalla!");

tft.setCursor(20, 130);
tft.println("Mira el Serial Monitor");

Serial.println("n--- Listo para detectar toques ---");
Serial.println("Toca la pantalla y observa los valores aqui.n");
}

void loop() {
// Verificar si hay toque usando tirqTouched() primero (más eficiente)
if (ts.tirqTouched()) {
if (ts.touched()) {
TS_Point p = ts.getPoint();

  // Mostrar en Serial
  Serial.print("TOQUE DETECTADO! -> ");
  Serial.print("X = ");
  Serial.print(p.x);
  Serial.print(" | Y = ");
  Serial.print(p.y);
  Serial.print(" | Presion = ");
  Serial.println(p.z);

  // Mostrar en pantalla
  tft.fillRect(0, 180, 320, 60, TFT_BLACK);  // Limpiar área
  tft.setCursor(20, 180);
  tft.setTextColor(TFT_GREEN, TFT_BLACK);

  String coords = "X:" + String(p.x) + " Y:" + String(p.y);
  tft.println(coords);

  tft.setCursor(20, 200);
  tft.setTextColor(TFT_YELLOW, TFT_BLACK);
  tft.println("Z:" + String(p.z));

  delay(50);  // Pequeño delay para evitar lecturas múltiples
}

}
}

Me gustaría añadir los pines del SD que desconozco, puede que vayan compartidos con el SPI del TFT y Touch, para probarlo, me puedes hacer un sencillo programa, que puede ser este mismo añadiendo en el loop la prueba de conexión al SD?

ASSISTANT

Vale — vamos a convertir tu sketch en un “detective de SD”: mantiene TFT + táctil tal cual, y además prueba a montar la microSD probando varios pines CS candidatos (porque lo normal es que comparta MOSI/MISO/SCLK con el TFT y lo único “nuevo” sea el CS de la SD).

La idea es simple y práctica:

el bus del táctil sigue en VSPI (como ya lo tienes)
para la SD usamos HSPI con los mismos pines del TFT (13/12/14)
probamos varios pines típicos como CS hasta que uno “agarre”

Sketch (TFT + Touch + Autodetección de CS de SD)

Cambia/añade pines en sdCsCandidates[] si hace falta. En el Serial Monitor te dirá con cuál monta.

/*******************************************************************
  TFT + Touch (XPT2046) + Test SD (autodetecta CS probando candidatos)

  TFT ST7789 (según tu setup de TFT_eSPI, HSPI por pines):
  - MOSI: 13
  - MISO: 12
  - SCLK: 14
  - CS  : 15
  - DC  : 2
  - BL  : 27

  Touch XPT2046 (SPI separado, VSPI):
  - TP_CLK : 25
  - TP_MOSI: 32
  - TP_MISO: 39
  - TP_CS  : 33
  - TP_IRQ : 36

  SD: normalmente comparte SPI con TFT (13/12/14) y tiene su propio CS (desconocido)
*******************************************************************/

#include <SPI.h>
#include <SD.h>
#include <XPT2046_Touchscreen.h>
#include <TFT_eSPI.h>

// ----------------------------
// Pines del táctil XPT2046
// ----------------------------
#define XPT2046_IRQ   36
#define XPT2046_MOSI  32
#define XPT2046_MISO  39
#define XPT2046_CLK   25
#define XPT2046_CS    33

// ----------------------------
// Pines SPI del TFT (para usar también con SD)
// ----------------------------
#define TFT_SCLK_PIN  14
#define TFT_MISO_PIN  12
#define TFT_MOSI_PIN  13
#define TFT_CS_PIN    15   // CS de la pantalla (para “desactivarla” al hablar con SD)

// Crear instancia SPI para el táctil (VSPI)
SPIClass touchSPI = SPIClass(VSPI);
XPT2046_Touchscreen ts(XPT2046_CS, XPT2046_IRQ);

// SPI para SD (HSPI, compartido con TFT en muchos módulos)
SPIClass sdSPI = SPIClass(HSPI);

// Pantalla
TFT_eSPI tft = TFT_eSPI();

// ------------------------------------
// Candidatos típicos de CS para SD
// (edita esta lista: añade/quita pines)
// ------------------------------------
uint8_t sdCsCandidates[] = {
  5, 4, 22, 21, 26, 25, 33, 32, 27, 2, 15
  // Ojo: algunos aquí chocan con cosas que ya usas (25 es CLK del touch, 33 es CS del touch, 27 BL, 2 DC, 15 CS TFT)
  // Pero a veces el fabricante hace estas gamberradas. Si algo se pone raro, quítalos de la lista.
};

bool sdMounted = false;
int  sdCsFound = -1;

unsigned long lastSdTryMs = 0;
unsigned long lastSdHeartbeatMs = 0;

void listRoot() {
  File root = SD.open("/");
  if (!root) {
    Serial.println("No pude abrir /");
    return;
  }
  Serial.println("Contenido de / :");
  while (true) {
    File f = root.openNextFile();
    if (!f) break;
    Serial.print("  ");
    Serial.print(f.name());
    if (!f.isDirectory()) {
      Serial.print("  (");
      Serial.print(f.size());
      Serial.println(" bytes)");
    } else {
      Serial.println("/");
    }
    f.close();
  }
  root.close();
}

bool tryMountSD(uint8_t csPin) {
  // “Desactiva” TFT mientras probamos SD (muy útil cuando comparten bus)
  pinMode(TFT_CS_PIN, OUTPUT);
  digitalWrite(TFT_CS_PIN, HIGH);

  pinMode(csPin, OUTPUT);
  digitalWrite(csPin, HIGH); // reposo

  // Intento de montaje
  // frecuencia moderada primero (más compatible)
  if (!SD.begin(csPin, sdSPI, 8000000)) {
    return false;
  }

  // Validación básica
  uint8_t type = SD.cardType();
  if (type == CARD_NONE) {
    SD.end();
    return false;
  }

  return true;
}

bool scanForSD() {
  Serial.println("nBuscando SD... probando CS candidatos.");
  for (size_t i = 0; i < sizeof(sdCsCandidates) / sizeof(sdCsCandidates[0]); i++) {
    uint8_t cs = sdCsCandidates[i];

    // Evita probar el mismo CS del TFT si no quieres líos (lo dejo, por si acaso)
    Serial.print("  Probando CS = GPIO ");
    Serial.print(cs);
    Serial.print(" ... ");

    // A veces conviene “resetear” intentos
    SD.end();

    if (tryMountSD(cs)) {
      sdMounted = true;
      sdCsFound = cs;

      Serial.println("OK ✅");
      Serial.print("SD montada con CS=GPIO ");
      Serial.println(sdCsFound);

      Serial.print("Tipo: ");
      switch (SD.cardType()) {
        case CARD_MMC:  Serial.println("MMC"); break;
        case CARD_SD:   Serial.println("SDSC"); break;
        case CARD_SDHC: Serial.println("SDHC/SDXC"); break;
        default:        Serial.println("Desconocida"); break;
      }

      uint64_t sizeMB = SD.cardSize() / (1024ULL * 1024ULL);
      Serial.print("Tamaño: ");
      Serial.print(sizeMB);
      Serial.println(" MB");

      listRoot();

      // Mensaje en TFT
      tft.fillRect(0, 0, 320, 30, TFT_BLACK);
      tft.setCursor(10, 5);
      tft.setTextColor(TFT_CYAN, TFT_BLACK);
      tft.setTextSize(2);
      tft.print("SD OK  CS=");
      tft.print(sdCsFound);

      return true;
    } else {
      Serial.println("no");
    }
  }

  Serial.println("No encontré SD con esos CS 😅");
  tft.fillRect(0, 0, 320, 30, TFT_BLACK);
  tft.setCursor(10, 5);
  tft.setTextColor(TFT_RED, TFT_BLACK);
  tft.setTextSize(2);
  tft.println("SD NO MONTADA");

  sdMounted = false;
  sdCsFound = -1;
  return false;
}

void sdHeartbeat() {
  // escribe un log sencillo para confirmar que lee/escribe
  File f = SD.open("/sd_test.txt", FILE_APPEND);
  if (!f) {
    Serial.println("SD: fallo abriendo /sd_test.txt (¿se desmontó?)");
    sdMounted = false;
    sdCsFound = -1;
    SD.end();
    return;
  }
  f.print("latido ms=");
  f.println(millis());
  f.close();
  Serial.println("SD: OK (escritura en /sd_test.txt)");

  tft.fillRect(0, 30, 320, 25, TFT_BLACK);
  tft.setCursor(10, 33);
  tft.setTextColor(TFT_GREEN, TFT_BLACK);
  tft.setTextSize(2);
  tft.print("SD write OK ");
  tft.print(millis() / 1000);
  tft.print("s");
}

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

  Serial.println("n=================================");
  Serial.println("TFT + Touch + SD Detective");
  Serial.println("=================================n");

  // Touch SPI (VSPI)
  touchSPI.begin(XPT2046_CLK, XPT2046_MISO, XPT2046_MOSI, XPT2046_CS);
  ts.begin(touchSPI);
  ts.setRotation(1);

  // TFT
  tft.init();
  tft.setRotation(1);
  tft.fillScreen(TFT_BLACK);
  tft.setTextColor(TFT_WHITE, TFT_BLACK);
  tft.setTextSize(2);
  tft.setCursor(20, 100);
  tft.println("Toca la pantalla!");
  tft.setCursor(20, 130);
  tft.println("y mira el Serial");

  // SD SPI (HSPI) con pines del TFT
  sdSPI.begin(TFT_SCLK_PIN, TFT_MISO_PIN, TFT_MOSI_PIN, -1);

  // Primer escaneo al arrancar
  scanForSD();
}

void loop() {
  // ---- TOUCH ----
  if (ts.tirqTouched()) {
    if (ts.touched()) {
      TS_Point p = ts.getPoint();

      Serial.print("TOQUE -> X=");
      Serial.print(p.x);
      Serial.print(" Y=");
      Serial.print(p.y);
      Serial.print(" Z=");
      Serial.println(p.z);

      tft.fillRect(0, 180, 320, 60, TFT_BLACK);
      tft.setCursor(20, 180);
      tft.setTextColor(TFT_GREEN, TFT_BLACK);
      tft.setTextSize(2);
      tft.print("X:");
      tft.print(p.x);
      tft.print(" Y:");
      tft.print(p.y);

      tft.setCursor(20, 205);
      tft.setTextColor(TFT_YELLOW, TFT_BLACK);
      tft.print("Z:");
      tft.print(p.z);

      delay(40);
    }
  }

  // ---- SD TEST ----
  // Si no está montada, reintenta cada 5s
  if (!sdMounted && millis() - lastSdTryMs > 5000) {
    lastSdTryMs = millis();
    scanForSD();
  }

  // Si está montada, prueba lectura/escritura cada 10s
  if (sdMounted && millis() - lastSdHeartbeatMs > 10000) {
    lastSdHeartbeatMs = millis();
    sdHeartbeat();
  }
}

Si esto no monta nada…

No pasa nada: a veces la ranura SD en ciertas placas va por SD_MMC (modo 4-bit) en lugar de SPI, y entonces SD.h no ve nada aunque el cableado esté perfecto. Si sospechas eso, prueba este mini-test (sin TFT) en otro sketch:

#include "SD_MMC.h"

void setup() {
  Serial.begin(115200);
  if (!SD_MMC.begin("/sdcard", true)) { // true = modo 1-bit (más compatible)
    Serial.println("SD_MMC: fallo");
    return;
  }
  Serial.println("SD_MMC: OK");
  Serial.printf("Size MB: %llun", SD_MMC.cardSize() / (1024ULL*1024ULL));
}

void loop() {}

Si me dices el modelo exacto de la placa (o una foto por delante/detrás donde se vea el slot SD), te canto los pines casi con una bola de cristal… pero de las que se alimentan por SPI 😄.

USER

El primero da fallo, y el segundo también:
E (10041) sdmmc_periph: sdmmc_host_clock_update_command(215): sdmmc_host_start_command returned 0x107
E (10041) sdmmc_common: sdmmc_init_ocr: send_op_cond (1) returned 0x107
E (10045) vfs_fat_sdmmc: sdmmc_card_init failed (0x107).
SD_MMC: fallo

ASSISTANT

Ese 0x107 es el ESP32 diciendo “le he hablado a la SD y la SD me ha dejado en visto” 😅. En tu log sale sdmmc_* porque estás intentando SD_MMC (modo SDMMC), pero en estas placas tipo ESP32-2432S028R / CYD la ranura suele ir en SPI, no en SDMMC, y por eso SD_MMC falla con timeout. Random Nerd Tutorials

Además, en tu placa concreta hay una “maldición práctica”: TFT, Touch y SD están cableados a GPIO distintos, y el ESP32 solo tiene 2 buses SPI hardware (HSPI/VSPI). Para tenerlo todo a la vez, lo más limpio es dejar la SD en SPI hardware y pasar el táctil a bit-banging (software SPI). Esto mismo lo resume gente que se peleó con lo mismo en CYD. Arduino Forum+1

Pines típicos (tu mapeo cuadra 100% con CYD)

TFT (HSPI): MOSI 13, MISO 12, SCK 14, CS 15, DC 2 (como ya usas). Random Nerd Tutorials
Touch (XPT2046): CLK 25, MOSI 32, MISO 39, CS 33, IRQ 36 (como ya usas). Random Nerd Tutorials
microSD (SPI): SCK 18, MISO 19, MOSI 23, CS 5. Random Nerd Tutorials

Sketch “todo en uno”: TFT + Touch + SD (SD por SPI hardware, Touch por bitbang)

Necesitas instalar la librería XPT2046_Bitbang_Slim (TheNitek). GitHub

(Arduino IDE → Sketch > Include Library > Add .ZIP Library… o por el gestor si te aparece).

Esto te deja la SD estable, sin pelearse con el SPI del táctil.

/*******************************************************************
  CYD / ESP32-2432S028R (o muy similar a tu pinout)
  - TFT con TFT_eSPI (tu config actual)
  - TOUCH XPT2046 por bit-banging (software SPI)
  - microSD por SPI hardware (VSPI) en: SCK 18, MISO 19, MOSI 23, CS 5
*******************************************************************/

#include <SPI.h>
#include <SD.h>
#include <TFT_eSPI.h>
#include <XPT2046_Bitbang.h>

// -------- TOUCH (XPT2046) ----------
#define XPT_IRQ   36
#define XPT_MOSI  32
#define XPT_MISO  39
#define XPT_CLK   25
#define XPT_CS    33

XPT2046_Bitbang touch(XPT_MOSI, XPT_MISO, XPT_CLK, XPT_CS);

// -------- SD (microSD SPI) ----------
#define SD_CS    5
#define SD_SCK   18
#define SD_MISO  19
#define SD_MOSI  23

SPIClass sdSPI(VSPI);
bool sd_ok = false;

// -------- TFT ----------
TFT_eSPI tft = TFT_eSPI();

unsigned long lastSdTest = 0;
uint32_t sdWrites = 0;

void printOnTftStatus(const String& line1, const String& line2 = "") {
  tft.fillRect(0, 0, tft.width(), 60, TFT_BLACK);
  tft.setCursor(10, 10);
  tft.setTextColor(TFT_WHITE, TFT_BLACK);
  tft.setTextSize(2);
  tft.println(line1);
  if (line2.length()) {
    tft.setCursor(10, 32);
    tft.println(line2);
  }
}

void sdTestOnce() {
  if (!sd_ok) return;

  // Escribe un “latido” en un archivo
  File f = SD.open("/cyd_test.txt", FILE_APPEND);
  if (!f) {
    Serial.println("SD: no puedo abrir /cyd_test.txt");
    printOnTftStatus("SD: open FAIL", "/cyd_test.txt");
    return;
  }

  sdWrites++;
  String msg = "Hola SD #" + String(sdWrites) + " ms=" + String(millis()) + "n";
  f.print(msg);
  f.close();

  Serial.print("SD OK, write #"); Serial.println(sdWrites);
  printOnTftStatus("SD OK", "writes: " + String(sdWrites));
}

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

  // TFT
  tft.init();
  tft.setRotation(1);
  tft.fillScreen(TFT_BLACK);

  printOnTftStatus("Arrancando...", "TFT + Touch + SD");

  // Touch (bitbang)
  pinMode(XPT_IRQ, INPUT);
  touch.begin();

  // SD (SPI)
  sdSPI.begin(SD_SCK, SD_MISO, SD_MOSI, SD_CS);

  // Empieza conservador en frecuencia (si va bien, subes a 20-25MHz)
  sd_ok = SD.begin(SD_CS, sdSPI, 10000000);

  if (!sd_ok) {
    Serial.println("SD: fallo al montar (SD.begin)");
    printOnTftStatus("SD: fallo", "revisa FAT32/pines");
  } else {
    uint8_t cardType = SD.cardType();
    uint64_t cardSize = SD.cardSize() / (1024ULL * 1024ULL);
    Serial.printf("SD montada. Tipo=%u Size=%lluMBn", cardType, cardSize);
    printOnTftStatus("SD montada", String(cardSize) + " MB");
  }

  // Mensaje fijo abajo
  tft.fillRect(0, 70, tft.width(), 40, TFT_BLACK);
  tft.setCursor(10, 80);
  tft.setTextColor(TFT_GREEN, TFT_BLACK);
  tft.println("Toca la pantalla...");
}

void loop() {
  // TOUCH: si IRQ está activa (normalmente LOW al tocar), leemos
  if (digitalRead(XPT_IRQ) == LOW) {
    TouchPoint p = touch.getTouch();
    if (p.zRaw != 0) {
      Serial.printf("TOUCH: x=%d y=%d z=%d (rawx=%d rawy=%d)n",
                    p.x, p.y, p.zRaw, p.xRaw, p.yRaw);

      tft.fillRect(0, 120, tft.width(), 80, TFT_BLACK);
      tft.setCursor(10, 120);
      tft.setTextColor(TFT_YELLOW, TFT_BLACK);
      tft.printf("X:%d  Y:%dn", p.x, p.y);
      tft.setTextColor(TFT_CYAN, TFT_BLACK);
      tft.printf("Z:%dn", p.zRaw);
    }
  }

  // SD test cada 3 segundos
  if (sd_ok && millis() - lastSdTest > 3000) {
    lastSdTest = millis();
    sdTestOnce();
  }
}

Si aún falla (sin dramatismos, con calma de monje y sonrisa de hacker)

Formatea la microSD en FAT32 (y prueba una de 2–16GB si tienes).
Prueba a bajar velocidad: cambia 10000000 a 4000000.
Asegúrate de que CS=5 no está “ocupado” por algo raro en tu sketch/placa. (En CYD suele ser ese). Random Nerd Tutorials

Si me pegas tu sketch SD que da fallo (el “primero” y el “segundo” que mencionas) te lo ajusto con bisturí: pines, bus SPI correcto y orden de inicialización, sin que el TFT/Touch se te pongan celosos.

USER

Te paso fotos de la placa:

A ver si esto te ayuda a caonfirmar los pines que mencionas, mientras voy probando con tu codigo.
Tiene una tarjeta de 8Gb formateada como FAT32

¿porque cambiar la librería a XPT2046_Bitbang?
Si la otra XPT2046 que tenía cargada ya iba bien?
He hecho el cambio a ver si funciona.

Pues no, me da error.
Estos son los mensajes:

/private/var/folders/gw/nspwq32s2w764ky2yxdzk7s80000gp/T/.arduinoIDE-unsaved2026027-3294-mnlanh.14pip/sketch_jan27e/sketch_jan27e.ino: In function 'void loop()':
/private/var/folders/gw/nspwq32s2w764ky2yxdzk7s80000gp/T/.arduinoIDE-unsaved2026027-3294-mnlanh.14pip/sketch_jan27e/sketch_jan27e.ino:110:5: error: 'TouchPoint' was not declared in this scope
110 | TouchPoint p = touch.getTouch();
| ^~~~~~
/private/var/folders/gw/nspwq32s2w764ky2yxdzk7s80000gp/T/.arduinoIDE-unsaved2026027-3294-mnlanh.14pip/sketch_jan27e/sketch_jan27e.ino:111:9: error: 'p' was not declared in this scope
111 | if (p.zRaw != 0) {
| ^
Multiple libraries were found for "TFT_eSPI.h"
Used: /Users/devtasinghkhalsa/Documents/Arduino/libraries/TFT_eSPI
Not used: /Users/devtasinghkhalsa/Documents/Arduino/libraries/TFT_eSPI_ES32Lab
exit status 1

Compilation error: 'TouchPoint' was not declared in this scope

ASSISTANT

Vale, las fotos ayudan mucho: tu placa pone ESP32-024 y lleva XPT2046 + ranura microSD “a bordo”. Y por lo que se ve (y por cómo se comporta), la SD no va por SD_MMC, sino por SPI.

Y aquí está el “duende”: tú ya estás usando VSPI para el táctil con pines 25/32/39/33, pero en estas placas la microSD suele colgar de VSPI “clásico” (SCK 18 / MISO 19 / MOSI 23) con CS normalmente en GPIO5.

Eso significa: un mismo VSPI, pero con dos juegos de pines distintos → no pueden vivir “montados” a la vez sin pelearse.

¿Por qué te propuse XPT2046_Bitbang?

Porque es una forma de sacar el táctil de VSPI (software SPI) y dejar VSPI libre para la SD.

Peeeero: no estás obligado. Si tu librería XPT2046_Touchscreen te iba fina, podemos hacer una jugada elegante:

Plan B (mejor para ti ahora): mantener tu XPT2046_Touchscreen y “cambiarle el traje” al VSPI cuando toque SD

Es decir:

normalmente, VSPI con pines del táctil (tu configuración actual)
cada X segundos: paramos VSPI, lo arrancamos con pines de SD, hacemos una lectura/escritura, y volvemos al táctil.

Suena a malabarista de circo… pero funciona sorprendentemente bien para tests y para uso real si no escribes SD cada milisegundo.

Sketch: TFT (HSPI) + Touch (VSPI) + SD (VSPI con cambio de pines)

Suposición típica de estas placas: SD_CS = 5, SCK=18, MISO=19, MOSI=23.

Si no monta, te digo abajo cómo ampliar el escaneo de CS.

#include <SPI.h>
#include <SD.h>
#include <XPT2046_Touchscreen.h>
#include <TFT_eSPI.h>

// ----------------------------
// TOUCH XPT2046 (TU PINOUT)
// ----------------------------
#define XPT2046_IRQ   36
#define XPT2046_MOSI  32
#define XPT2046_MISO  39
#define XPT2046_CLK   25
#define XPT2046_CS    33

// ----------------------------
// SD (pinout típico en estas placas)
// ----------------------------
#define SD_SCK   18
#define SD_MISO  19
#define SD_MOSI  23
#define SD_CS    5   // candidato principal

// ----------------------------
// TFT (lo maneja TFT_eSPI con su config, normalmente HSPI en tu setup)
// ----------------------------
TFT_eSPI tft = TFT_eSPI();

// Un solo VSPI para TOUCH y SD (lo iremos “reconfigurando”)
SPIClass vspi(VSPI);

XPT2046_Touchscreen ts(XPT2046_CS, XPT2046_IRQ);

bool sdMounted = false;
unsigned long lastSdTry = 0;

void vspiToTouch() {
  // Desmonta SD si estuviera montada (para evitar que se quede agarrada al bus)
  if (sdMounted) {
    SD.end();
    sdMounted = false;
  }

  vspi.end();
  delay(5);

  // Inicia VSPI con pines del táctil
  vspi.begin(XPT2046_CLK, XPT2046_MISO, XPT2046_MOSI, XPT2046_CS);

  // Re-inicializa el táctil en este bus
  ts.begin(vspi);
  ts.setRotation(1);
}

bool vspiToSD_andMount(uint8_t cs) {
  // “Desactiva” el táctil por CS alto
  pinMode(XPT2046_CS, OUTPUT);
  digitalWrite(XPT2046_CS, HIGH);

  vspi.end();
  delay(5);

  // Inicia VSPI con pines de SD
  vspi.begin(SD_SCK, SD_MISO, SD_MOSI, cs);

  pinMode(cs, OUTPUT);
  digitalWrite(cs, HIGH);

  // Frecuencia conservadora para compatibilidad
  if (!SD.begin(cs, vspi, 4000000)) {
    SD.end();
    return false;
  }

  if (SD.cardType() == CARD_NONE) {
    SD.end();
    return false;
  }

  sdMounted = true;
  return true;
}

void showTop(const String& msg, uint16_t color) {
  tft.fillRect(0, 0, 320, 30, TFT_BLACK);
  tft.setCursor(10, 5);
  tft.setTextSize(2);
  tft.setTextColor(color, TFT_BLACK);
  tft.println(msg);
}

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

  // TFT
  tft.init();
  tft.setRotation(1);
  tft.fillScreen(TFT_BLACK);

  tft.setTextColor(TFT_WHITE, TFT_BLACK);
  tft.setTextSize(2);
  tft.setCursor(20, 80);
  tft.println("TFT + TOUCH + SD");
  tft.setCursor(20, 110);
  tft.println("Mirar Serial");

  // Arranca en modo TOUCH
  vspiToTouch();
  showTop("TOUCH listo", TFT_GREEN);

  Serial.println("Arrancado. Touch OK. Probando SD en loop...");
}

void loop() {
  // ---- TOUCH ----
  if (ts.tirqTouched()) {
    if (ts.touched()) {
      TS_Point p = ts.getPoint();

      Serial.printf("TOUCH -> X=%d Y=%d Z=%dn", p.x, p.y, p.z);

      tft.fillRect(0, 180, 320, 60, TFT_BLACK);
      tft.setCursor(20, 180);
      tft.setTextColor(TFT_GREEN, TFT_BLACK);
      tft.printf("X:%d Y:%dn", p.x, p.y);
      tft.setTextColor(TFT_YELLOW, TFT_BLACK);
      tft.printf("Z:%dn", p.z);

      delay(40);
    }
  }

  // ---- SD TEST cada 4s ----
  if (millis() - lastSdTry > 4000) {
    lastSdTry = millis();

    Serial.println("n[SD] Intentando montar SD...");

    // Cambia a SD y monta
    if (vspiToSD_andMount(SD_CS)) {
      uint64_t sizeMB = SD.cardSize() / (1024ULL * 1024ULL);
      Serial.printf("[SD] OK ✅  CS=%d  Size=%llu MBn", SD_CS, sizeMB);
      showTop("SD OK CS=5", TFT_CYAN);

      // Escribe un “latido”
      File f = SD.open("/sd_test.txt", FILE_APPEND);
      if (f) {
        f.printf("latido ms=%lun", (unsigned long)millis());
        f.close();
        Serial.println("[SD] write OK -> /sd_test.txt");
      } else {
        Serial.println("[SD] open FAIL /sd_test.txt");
      }

      // Vuelve a TOUCH
      vspiToTouch();
      showTop("TOUCH listo", TFT_GREEN);

    } else {
      Serial.println("[SD] fallo montar con CS=5");
      showTop("SD FAIL (CS=5)", TFT_RED);

      // Vuelve a TOUCH sí o sí
      vspiToTouch();
      showTop("TOUCH listo", TFT_GREEN);
    }
  }
}

Sobre tu error de compilación (“TouchPoint no existe”)

Eso es porque la estructura/typedef cambia según la librería. En mi ejemplo con Bitbang usé un tipo que tu versión no trae. Por eso petó.

Con el sketch de arriba no tocamos tu librería del táctil, así que ese error desaparece.

Si con CS=5 sigue fallando

Te dejo un “mini upgrade” rápido: prueba CS candidatos (4, 5, 13, 15, 21, 22).

Si quieres, te lo meto en el sketch en 2 líneas: una lista csCandidates[] y un for… y listo, como un tarot de GPIOs.

Si me dices:

qué board has seleccionado en Arduino IDE (ESP32 Dev Module / etc.), y
qué versión del core ESP32 estás usando (2.x / 3.x),

te lo ajusto fino para que el bus no haga “claqué” al cambiar de modo. Aquí estamos domando serpientes SPI, con flauta y paciencia 😄.

USER

El TFT va, el touch no parece responder, las coordenadas no cambian en la pantalla.
no se si va el SD, en el serial sale esto:

���GQ�j�GQ���@�����j�)����TOUCH -> X=0 Y=0 Z=4095
TOUCH -> X=0 Y=0 Z=4095
TOUCH -> X=0 Y=0 Z=4095
TOUCH -> X=0 Y=0 Z=4095

ASSISTANT

Vale, esto ya huele clarito: el táctil se ha “desafinando” cuando cambiamos el VSPI.

Y ese patrón X=0 Y=0 Z=4095 suele significar: “estoy leyendo basura / MISO flotante / el chip no está realmente hablando”. Vamos, que el XPT2046 no está en el bus que cree estar.

La buena noticia: tu touch funcionaba perfecto antes con VSPI en 25/32/39/33. Así que no necesitamos hacer malabares cambiando pines del VSPI.

La jugada más limpia aquí es:

✅ Deja el TOUCH en VSPI como lo tenías

✅ Mete la SD en HSPI usando los pines típicos de SD en estas placas: SCK=18, MISO=19, MOSI=23, CS=5

(El ESP32 puede mapear HSPI a esos pines sin problema.)

Así no se pelean ni TFT ni Touch ni SD. Cada cual con su autobús.

1) Mini aviso del “serial con jeroglíficos”

Esa línea rara ��GQ... es casi siempre baud rate distinto.

Asegúrate de que el Monitor Serie está en 115200 (y sin “Both NL & CR” si te mete ruido).

2) Sketch: TFT + Touch (igual que tuyo) + SD por HSPI

Pruébalo tal cual:

cpp`#include &lt;SPI.h>
#include &lt;SD.h>
#include &lt;XPT2046_Touchscreen.h>
#include &lt;TFT_eSPI.h>

// ----------------------------
// TOUCH XPT2046 (como tu sketch bueno)
// ----------------------------
#define XPT2046_IRQ   36
#define XPT2046_MOSI  32
#define XPT2046_MISO  39
#define XPT2046_CLK   25
#define XPT2046_CS    33

SPIClass touchSPI(VSPI);
XPT2046_Touchscreen ts(XPT2046_CS, XPT2046_IRQ);

// ----------------------------
// SD por HSPI (pines típicos en estas placas)
// ----------------------------
#define SD_SCK   18
#define SD_MISO  19
#define SD_MOSI  23
#define SD_CS     5

SPIClass sdSPI(HSPI);

// TFT
TFT_eSPI tft = TFT_eSPI();

bool sdOK = false;
unsigned long lastSdBeat = 0;

void sdHeartbeat() {
  if (!sdOK) return;

  File f = SD.open("/sd_test.txt", FILE_APPEND);
  if (!f) {
    Serial.println("SD: no puedo abrir /sd_test.txt");
    sdOK = false;
    SD.end();
    return;
  }
  f.printf("latido ms=%lun", (unsigned long)millis());
  f.close();
  Serial.println("SD: write OK (/sd_test.txt)");

  tft.fillRect(0, 0, 320, 25, TFT_BLACK);
  tft.setCursor(10, 5);
  tft.setTextSize(2);
  tft.setTextColor(TFT_CYAN, TFT_BLACK);
  tft.print("SD OK  ");
  tft.print(millis() / 1000);
  tft.print("s");
}

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

  // TOUCH
  touchSPI.begin(XPT2046_CLK, XPT2046_MISO, XPT2046_MOSI, XPT2046_CS);
  ts.begin(touchSPI);
  ts.setRotation(1);

  // TFT
  tft.init();
  tft.setRotation(1);
  tft.fillScreen(TFT_BLACK);
  tft.setTextColor(TFT_WHITE, TFT_BLACK);
  tft.setTextSize(2);
  tft.setCursor(20, 90);
  tft.println("Touch + SD test");

  // SD (HSPI mapeado a 18/19/23)
  sdSPI.begin(SD_SCK, SD_MISO, SD_MOSI, SD_CS);

  Serial.println("[SD] intentando montar...");
  sdOK = SD.begin(SD_CS, sdSPI, 4000000); // 4MHz = muy compatible

  if (!sdOK || SD.cardType() == CARD_NONE) {
    Serial.println("[SD] FAIL");
    tft.setCursor(20, 130);
    tft.setTextColor(TFT_RED, TFT_BLACK);
    tft.println("SD FAIL");
    sdOK = false;
    SD.end();
  } else {
    uint64_t sizeMB = SD.cardSize() / (1024ULL * 1024ULL);
    Serial.printf("[SD] OK, size=%llu MBn", sizeMB);
    tft.setCursor(20, 130);
    tft.setTextColor(TFT_GREEN, TFT_BLACK);
    tft.print("SD OK ");
    tft.print((uint32_t)sizeMB);
    tft.println("MB");
  }

  Serial.println("Listo. Toca pantalla.");
}

void loop() {
  // TOUCH
  if (ts.tirqTouched() &amp;&amp; ts.touched()) {
    TS_Point p = ts.getPoint();

    Serial.printf("TOUCH -> X=%d Y=%d Z=%dn", p.x, p.y, p.z);

    tft.fillRect(0, 180, 320, 60, TFT_BLACK);
    tft.setCursor(20, 180);
    tft.setTextColor(TFT_GREEN, TFT_BLACK);
    tft.printf("X:%d  Y:%dn", p.x, p.y);
    tft.setTextColor(TFT_YELLOW, TFT_BLACK);
    tft.printf("Z:%dn", p.z);

    delay(40);
  }

  // SD latido cada 5s
  if (sdOK &amp;&amp; millis() - lastSdBeat > 5000) {
    lastSdBeat = millis();
    sdHeartbeat();
  }
}
`

Si con esto el Touch vuelve y la SD no…

Entonces la SD no usa CS=5 (pero suele). Te lo ajusto con un “escáner de CS” sin tocar touch: probamos 4/5/13/15/21/22 y listo.

Pero lo primero: prueba este sketch y dime solo dos cosas del Serial:

¿[SD] OK o FAIL?
¿Las coordenadas del touch cambian ya?

Vamos paso a paso, como quien cruza un río saltando piedras: si miras dos a la vez, te mojas 😄

USER

El board seleccionado es en efecto: ESP32 Dev Module y el serial generado por el USB (no hay otro en USB)

El script que me has dado Muestra el TFT, y si muestra las coordenadas cambiantes del Touch.

Pero da fallo: SD FAIL

Quizá si me das el script de un par de lineas que me dijiste antes para probar los distintos pines para el SD en el loop, podemos detectarlo (sin estropear lo que ya funciona)

ASSISTANT

Perfecto: Touch vivo, TFT feliz… solo falta que la SD deje de hacerse la interesante 😄.

Vamos a hacer justo lo que pides: sin tocar nada del Touch, y probando CS en bucle, con el bus SD ya fijo en HSPI (18/19/23).

Aquí tienes un sketch “detective CS” (mínimos cambios respecto al que ya te funciona).

Mantiene tu Touch en VSPI tal cual.
SD en HSPI con SCK=18 MISO=19 MOSI=23.
Prueba una lista de CS candidatos, solo hasta encontrar uno.
Cuando lo encuentra, escribe /sd_test.txt.

Nota: evita probar CS que ya usas (33 del touch, 15 del TFT, 2 DC, 27 BL…), pero por si el fabricante fue gamberro, igual los he dejado fuera por prudencia.

#include <SPI.h>
#include <SD.h>
#include <XPT2046_Touchscreen.h>
#include <TFT_eSPI.h>

// ---------- TOUCH (como te funciona) ----------
#define XPT2046_IRQ   36
#define XPT2046_MOSI  32
#define XPT2046_MISO  39
#define XPT2046_CLK   25
#define XPT2046_CS    33

SPIClass touchSPI(VSPI);
XPT2046_Touchscreen ts(XPT2046_CS, XPT2046_IRQ);

// ---------- SD por HSPI ----------
#define SD_SCK   18
#define SD_MISO  19
#define SD_MOSI  23

SPIClass sdSPI(HSPI);

bool sdOK = false;
int  sdCSfound = -1;

// Lista de CS candidatos (ajústala si quieres)
uint8_t csCandidates[] = { 5, 4, 21, 22, 26, 14, 13, 12, 25, 32, 16, 17 };

// TFT
TFT_eSPI tft = TFT_eSPI();

bool tryMountSD(uint8_t cs) {
  SD.end();                 // limpia intentos previos
  pinMode(cs, OUTPUT);
  digitalWrite(cs, HIGH);

  // 4MHz: súper compatible. Si monta, luego subimos.
  if (!SD.begin(cs, sdSPI, 4000000)) return false;
  if (SD.cardType() == CARD_NONE) { SD.end(); return false; }
  return true;
}

void scanSD() {
  Serial.println("n[SD] Escaneando CS...");
  for (size_t i = 0; i < sizeof(csCandidates); i++) {
    uint8_t cs = csCandidates[i];
    Serial.printf("  probando CS=GPIO %d ... ", cs);

    if (tryMountSD(cs)) {
      sdOK = true;
      sdCSfound = cs;

      uint64_t sizeMB = SD.cardSize() / (1024ULL * 1024ULL);
      Serial.printf("OK ✅  size=%lluMBn", sizeMB);

      tft.fillRect(0, 0, 320, 30, TFT_BLACK);
      tft.setCursor(10, 5);
      tft.setTextSize(2);
      tft.setTextColor(TFT_CYAN, TFT_BLACK);
      tft.printf("SD OK  CS=%d", sdCSfound);

      // prueba escritura
      File f = SD.open("/sd_test.txt", FILE_APPEND);
      if (f) {
        f.printf("CS=%d  ms=%lun", sdCSfound, (unsigned long)millis());
        f.close();
        Serial.println("  write OK -> /sd_test.txt");
      } else {
        Serial.println("  open FAIL /sd_test.txt");
      }
      return;
    } else {
      Serial.println("no");
    }
  }

  Serial.println("[SD] No encontrado con esa lista 😅");
  tft.fillRect(0, 0, 320, 30, TFT_BLACK);
  tft.setCursor(10, 5);
  tft.setTextSize(2);
  tft.setTextColor(TFT_RED, TFT_BLACK);
  tft.println("SD NO MONTADA");
}

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

  // TFT
  tft.init();
  tft.setRotation(1);
  tft.fillScreen(TFT_BLACK);
  tft.setTextSize(2);
  tft.setTextColor(TFT_WHITE, TFT_BLACK);
  tft.setCursor(20, 90);
  tft.println("Touch OK + SD scan");

  // TOUCH
  touchSPI.begin(XPT2046_CLK, XPT2046_MISO, XPT2046_MOSI, XPT2046_CS);
  ts.begin(touchSPI);
  ts.setRotation(1);

  // SD bus fijo
  sdSPI.begin(SD_SCK, SD_MISO, SD_MOSI, -1);

  // primer escaneo
  scanSD();
}

unsigned long lastRescan = 0;

void loop() {
  // ---- TOUCH (sigue funcionando igual) ----
  if (ts.tirqTouched() && ts.touched()) {
    TS_Point p = ts.getPoint();
    tft.fillRect(0, 180, 320, 60, TFT_BLACK);
    tft.setCursor(20, 180);
    tft.setTextColor(TFT_GREEN, TFT_BLACK);
    tft.printf("X:%d  Y:%dn", p.x, p.y);
    tft.setTextColor(TFT_YELLOW, TFT_BLACK);
    tft.printf("Z:%dn", p.z);
    delay(40);
  }

  // ---- si NO está montada, reintenta cada 6s ----
  if (!sdOK && millis() - lastRescan > 6000) {
    lastRescan = millis();
    scanSD();
  }
}

Qué mirar en el Serial

Te debería salir algo como:

probando CS=GPIO 5 ... OK ✅

Si aparece, ya tenemos el pin.

Si NO encuentra nada con esa lista

Dos posibilidades típicas (y las dos tienen arreglo):

La SD comparte bus con el TFT (o sea: no está en 18/19/23).

Entonces en vez de HSPI con 18/19/23, hay que probar SD en el mismo SPI del TFT (13/12/14) con un CS distinto.

La línea CS no está en un GPIO “normal” o la SD está cableada de forma rara.

Si el escaneo falla, dime qué ves impreso en la serigrafía cerca del lector SD (a veces pone “CLK / CMD / D0” etc.) o pásame una foto más pegada al lector por debajo/arriba, y te digo qué bus está usando con más certeza.

Mientras tanto… dale al upload, abre Serial a 115200, y que empiece el bingo de GPIOs 🧙‍♂️🎛️

USER

Creo que no va, no la encuentra…

Este es el resultado del serial:

no
probando CS=GPIO 16 ... no
probando CS=GPIO 17 ... no
[SD] No encontrado con esa lista 😅

[SD] Escaneando CS...
probando CS=GPIO 5 ... no
probando CS=GPIO 4 ... no

ASSISTANT

Ok, entonces ya no es “CS equivocado”… es BUS equivocado (o la SD está colgando del mismo SPI que el TFT).

Tu placa ESP32-024 suele tener 2 posibilidades reales:

microSD en SPI “clásico”: SCK=18 MISO=19 MOSI=23 (y CS variable)
microSD compartiendo el SPI del TFT: SCK=14 MISO=12 MOSI=13 (y CS variable), y hay que poner TFT_CS en HIGH mientras hablas con la SD.

Vamos a hacer un escáner que prueba ambos buses sin romper tu Touch (que ya va perfecto) ✅

Solo escanea SD cada 6s, y si la encuentra, se queda con ese bus+CS.

Sketch: Touch fijo + SD “doble bus” (18/19/23 y 14/12/13)

Importante: ajusta TFT_CS_PIN si tu TFT_eSPI usa otro CS (en tu caso es 15).

#include <SPI.h>
#include <SD.h>
#include <XPT2046_Touchscreen.h>
#include <TFT_eSPI.h>

// ---- TOUCH (como ya te funciona) ----
#define XPT2046_IRQ   36
#define XPT2046_MOSI  32
#define XPT2046_MISO  39
#define XPT2046_CLK   25
#define XPT2046_CS    33
SPIClass touchSPI(VSPI);
XPT2046_Touchscreen ts(XPT2046_CS, XPT2046_IRQ);

// ---- TFT CS (para “desactivar” TFT mientras probamos SD si comparten bus) ----
#define TFT_CS_PIN 15

// ---- SD: usamos HSPI pero lo mapeamos a los pines que toque ----
SPIClass sdSPI(HSPI);

// Candidatos de CS (incluyo algunos “incómodos” al final, por si el fabricante fue troll)
uint8_t csCandidates[] = { 5, 4, 21, 22, 16, 17, 26, 0, 2, 15, 27, 33 };

// Dos configuraciones de bus posibles para SD
struct BusPins { int sck, miso, mosi; const char* name; };
BusPins buses[] = {
  { 18, 19, 23, "SD bus (18/19/23)" },
  { 14, 12, 13, "TFT bus (14/12/13)" }  // comparte con TFT típico
};

TFT_eSPI tft = TFT_eSPI();

bool sdOK = false;
int sdCSfound = -1;
const char* sdBusFound = nullptr;

bool tryMountSD(uint8_t cs) {
  SD.end();

  // Ojo: si cs coincide con TFT_CS o TOUCH_CS, lo ponemos HIGH y probamos igual
  pinMode(cs, OUTPUT);
  digitalWrite(cs, HIGH);

  // Muy compatible
  if (!SD.begin(cs, sdSPI, 4000000)) return false;
  if (SD.cardType() == CARD_NONE) { SD.end(); return false; }
  return true;
}

bool scanSD() {
  // “desactiva” TFT y touch por CS alto para evitar que molesten
  pinMode(TFT_CS_PIN, OUTPUT); digitalWrite(TFT_CS_PIN, HIGH);
  pinMode(XPT2046_CS, OUTPUT); digitalWrite(XPT2046_CS, HIGH);

  Serial.println("n[SD] Escaneando bus + CS...");

  for (auto &bus : buses) {
    Serial.printf("[SD] Probando BUS: %sn", bus.name);

    sdSPI.end();
    delay(5);
    sdSPI.begin(bus.sck, bus.miso, bus.mosi, -1);

    for (size_t i = 0; i < sizeof(csCandidates); i++) {
      uint8_t cs = csCandidates[i];
      Serial.printf("  probando CS=GPIO %d ... ", cs);

      if (tryMountSD(cs)) {
        sdOK = true;
        sdCSfound = cs;
        sdBusFound = bus.name;

        uint64_t sizeMB = SD.cardSize() / (1024ULL * 1024ULL);
        Serial.printf("OK ✅  (%s) size=%lluMBn", bus.name, sizeMB);

        tft.fillRect(0, 0, 320, 30, TFT_BLACK);
        tft.setCursor(10, 5);
        tft.setTextSize(2);
        tft.setTextColor(TFT_CYAN, TFT_BLACK);
        tft.printf("SD OK CS=%d", sdCSfound);

        File f = SD.open("/sd_test.txt", FILE_APPEND);
        if (f) { f.printf("BUS=%s CS=%d ms=%lun", bus.name, cs, (unsigned long)millis()); f.close(); }
        Serial.println("  write OK -> /sd_test.txt");
        return true;
      } else {
        Serial.println("no");
      }
    }
  }

  Serial.println("[SD] No encontrado en ninguno de los dos buses 😅");
  tft.fillRect(0, 0, 320, 30, TFT_BLACK);
  tft.setCursor(10, 5);
  tft.setTextSize(2);
  tft.setTextColor(TFT_RED, TFT_BLACK);
  tft.println("SD NO MONTADA");
  return false;
}

unsigned long lastScan = 0;

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

  // TFT
  tft.init();
  tft.setRotation(1);
  tft.fillScreen(TFT_BLACK);
  tft.setTextSize(2);
  tft.setTextColor(TFT_WHITE, TFT_BLACK);
  tft.setCursor(20, 90);
  tft.println("Touch OK + SD scan");

  // TOUCH (tu setup ganador)
  touchSPI.begin(XPT2046_CLK, XPT2046_MISO, XPT2046_MOSI, XPT2046_CS);
  ts.begin(touchSPI);
  ts.setRotation(1);

  // Primer escaneo
  scanSD();

  // Reactiva touch CS (por si acaso)
  pinMode(XPT2046_CS, OUTPUT);
  digitalWrite(XPT2046_CS, LOW);
}

void loop() {
  // TOUCH sigue funcionando igual
  if (ts.tirqTouched() && ts.touched()) {
    TS_Point p = ts.getPoint();
    tft.fillRect(0, 180, 320, 60, TFT_BLACK);
    tft.setCursor(20, 180);
    tft.setTextColor(TFT_GREEN, TFT_BLACK);
    tft.printf("X:%d  Y:%dn", p.x, p.y);
    tft.setTextColor(TFT_YELLOW, TFT_BLACK);
    tft.printf("Z:%dn", p.z);
    delay(40);
  }

  // Reintenta scan cada 6s si no hay SD
  if (!sdOK && millis() - lastScan > 6000) {
    lastScan = millis();
    scanSD();

    // vuelve a habilitar touch CS por si algún intento lo dejó alto
    pinMode(XPT2046_CS, OUTPUT);
    digitalWrite(XPT2046_CS, LOW);
  }

  // Si ya hay SD, no escaneamos más; si quieres, puedes hacer latidos aquí.
}

Si esto tampoco encuentra nada…

Entonces hay 3 sospechosos típicos (y no es “tú”, es la placa 😄):

La SD necesita un pin de “power enable” (un transistor que la alimenta) y está apagada por defecto.
La SD está cableada en modo SDMMC pero con pines no estándar / o sin pullups, y por eso SD_MMC da 0x107.
La ranura o la tarjeta: algunas microSD dan guerra con ciertos lectores (prueba otra, ideal 2–16GB).

Si puedes, hazme una foto muy cerca de la ranura SD por ambos lados (zona de pistas que salen del lector). Con eso te digo si esas pistas van hacia GPIO18/19/23, hacia 13/12/14, o hacia otras patas raras.

Mientras tanto, este escáner “doble bus” suele cazarla si está viva.

USER

Me temo que no lo encuentra:

probando CS=GPIO 4 ... no
probando CS=GPIO 21 ... no
probando CS=GPIO 22 ... no
probando CS=GPIO 16 ... no
probando CS=GPIO 17 ... no
probando CS=GPIO 26 ... no
probando CS=GPIO 0 ... no
probando CS=GPIO 2 ... no
probando CS=GPIO 15 ... no

ASSISTANT

Uff… vale. Si ya has probado CS por media docena de GPIOs en dos buses distintos y sigue “no, no, no”… entonces la SD no está “ocultando” el CS: o está en otro bus/pines completamente distintos, o no está alimentada/conectada como creemos.

Vamos a acotar el misterio sin romper lo que ya funciona (TFT + Touch).

1) Prueba rápida que te falta (y a veces es la clave): SD_MMC en 4-bit (no 1-bit)

Tú probaste SD_MMC.begin(..., true) (1-bit). En algunas placas el lector está cableado a 4-bit y el 1-bit no llega.

Prueba ESTE sketch tal cual:

#include "SD_MMC.h"

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

  // false = 4-bit mode (muchas placas lo llevan así)
  if (!SD_MMC.begin("/sdcard", false)) {
    Serial.println("SD_MMC: fallo (4-bit)");
    return;
  }

  Serial.println("SD_MMC: OK ✅");
  Serial.printf("Size MB: %llun", SD_MMC.cardSize() / (1024ULL * 1024ULL));
}

void loop() {}

Si esto funciona, ya está: la SD va por SDMMC y listo.

2) Si SD_MMC 4-bit también falla, entonces: casi seguro SPI pero con pines raros (o SD sin alimentación)

Aquí hay una forma “de herrero zen” que no falla: continuidad con multímetro (modo pitido).

Porque el código puede adivinar… pero el cobre nunca miente.

Cómo hacerlo en 3 minutos

En el lector microSD, los pines importantes (mirando estándar SD) son:

CLK → pin SD 5
CMD / MOSI → pin SD 2
DAT0 / MISO → pin SD 7
DAT3 / CS (en SPI) → pin SD 1

Lo ideal es:

Pon una punta del multímetro en el pin del lector (si no puedes, en un componente conectado a esa pista).
Con la otra punta, toca pads/pines cercanos del ESP32 o resistencias en serie hasta que pite.
Anota: “CLK va a GPIO”, “MISO va a GPIO”, etc.

Con eso, te doy el pinout definitivo en 1 mensaje y se acaba el drama.

Si no tienes multímetro, también sirve una foto MUY cercana del lector por ambas caras, enfocando las pistas que salen del conector.

3) Mientras tanto: un escáner más “bruto” (por si la SD va en SPI pero en pines no típicos)

Sin tocar tu Touch, podemos probar varios sets de pines SPI además de los dos típicos.

Te dejo un “scanner” que prueba 4 buses candidatos (solo SD, nada de touch), para que veas si al menos alguno responde.

#include <SPI.h>
#include <SD.h>

SPIClass sdSPI(HSPI);

struct BusPins { int sck, miso, mosi; const char* name; };
BusPins buses[] = {
  {18, 19, 23, "VSPI clasico (18/19/23)"},
  {14, 12, 13, "TFT tipico (14/12/13)"},
  {25, 39, 32, "Touch bus (25/39/32)"},
  {27, 12, 13, "raro (27/12/13)"} // por si el fabricante hizo magia negra
};

uint8_t csCandidates[] = {5,4,15,2,21,22,26,27,33,32,0,16,17};

bool tryMount(uint8_t cs){
  SD.end();
  pinMode(cs, OUTPUT);
  digitalWrite(cs, HIGH);
  if(!SD.begin(cs, sdSPI, 4000000)) return false;
  if(SD.cardType() == CARD_NONE){ SD.end(); return false; }
  return true;
}

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

  Serial.println("n--- SD scanner ---");

  for (auto &bus : buses) {
    Serial.printf("nBUS: %sn", bus.name);
    sdSPI.end();
    delay(10);
    sdSPI.begin(bus.sck, bus.miso, bus.mosi, -1);

    for (size_t i=0;i<sizeof(csCandidates);i++){
      uint8_t cs = csCandidates[i];
      Serial.printf("  CS=%d ... ", cs);
      if(tryMount(cs)){
        Serial.println("OK ✅");
        Serial.printf("FOUND! BUS=%s CS=%dn", bus.name, cs);
        Serial.printf("Size MB: %llun", SD.cardSize()/(1024ULL*1024ULL));
        return;
      } else {
        Serial.println("no");
      }
    }
  }

  Serial.println("nNada encontrado 😅");
}

void loop() {}

Si ni con esto responde, entonces casi seguro es alimentación/lectora o SDMMC cableado pero sin pullups.

USER

Ok, tendré que probar la vía electrónica. Midiendo continuidad para ver las pistas que van de un sitio a otro.

Pero te paso los mensajes del serial:

Message (Enter to send message to 'ESP32 Dev Module' on '/dev/cu.usbserial-130')
New Line
115200 baud
E (1528) sdmmc_periph: sdmmc_host_clock_update_command(215): sdmmc_host_start_command returned 0x107
E (5529) sdmmc_periph: sdmmc_host_clock_update_command(215): sdmmc_host_start_command returned 0x107
E (6529) sdmmc_periph: sdmmc_host_clock_update_command(215): sdmmc_host_start_command returned 0x107
E (6529) sdmmc_req: handle_idle_state_events unhandled: 00001000 00000000
E (6533) sdmmc_req: handle_idle_state_events unhandled: 00001000 00000000
E (10540) sdmmc_periph: sdmmc_host_clock_update_command(215): sdmmc_host_start_command returned 0x107
E (10540) sdmmc_common: sdmmc_init_ocr: send_op_cond (1) returned 0x107
E (10544) vfs_fat_sdmmc: sdmmc_card_init failed (0x107).

ASSISTANT

Gracias por pasar el log: ese 0x107 es prácticamente un “silencio de radio” entre el ESP32 y la SD en modo SDMMC. En cristiano: no está llegando ninguna respuesta válida (timeout / línea mal / bus no es el que crees / falta pull-up / falta alimentación). Y como ya hemos escaneado SPI sin éxito… sí: la vía del cobre (continuidad) es la que corta el nudo gordiano.

Te dejo el mapa mental y el procedimiento muy concreto, para que en 10–15 min tengas los GPIO reales.

Qué significa ese 0x107 (en tu caso)

El driver intenta mandar comandos SDMMC (CMD0/CMD8/ACMD41…)
falla en send_op_cond y en init OCR → la tarjeta ni contesta
Esto suele pasar por:
No es SDMMC (es SPI)
Es SDMMC pero en pines distintos/no conectados
Faltan pull-ups en CMD/DAT (típico si el módulo está mal diseñado o el modo está mal)
La SD no está alimentada (algún “EN”/transistor) o el socket está mal.

Como en SPI tampoco la pillamos con dos buses típicos… mi apuesta (sin jurarlo por mi vida) es: o la SD está en pines no estándar, o hay un pin de “enable power”.

Cómo medir continuidad (modo “pitido y victoria”)

Necesitas multímetro en continuidad, una aguja/punta fina, y paciencia de monje con café ☕️🧘‍♂️

1) Identifica los pines del lector microSD

En un conector microSD estándar (vista del lector por la cara de soldaduras), los contactos relevantes son:

DAT3 (en SPI es CS)
CMD (en SPI es MOSI)
CLK (SCK)
DAT0 (en SPI es MISO)
VDD (3V3) y GND

No hace falta que memorices el orden exacto si no estás seguro: busca las pistas:

CLK suele ir a una pista “directa” y a veces pasa por una resistencia serie pequeña.
VDD irá a 3V3 con un condensador cerca.
GND a plano de masa (pitido con cualquier GND grande).

2) Busca primero VDD y GND (para descartar “SD apagada”)

Con SD metida, mide continuidad entre:
una pata del lector que vaya a 3V3 (o a un condensador) y el pin 3V3 del ESP32 / algún punto 3V3.
y otra pata a GND.

Si NO encuentras 3V3 claro, o ves que el 3V3 del lector pasa por un transistor, ahí está el “power enable”.

Truco: mide tensión (DC) con la placa encendida:

entre el supuesto VDD del lector y GND deberían ser ~3.3V.
si ves 0V o algo muy bajo → la SD no está alimentada.

3) Encuentra CLK, MOSI, MISO, CS por continuidad hacia resistencias

Casi siempre esas líneas pasan por resistencias en serie (22–100Ω) cerca del lector.

Pon una punta en una resistencia cercana al lector.
La otra punta en los pines del ESP32 (o en pads etiquetados si los hay).
Anota qué resistencia corresponde a qué GPIO.

Con 4 líneas identificadas, ya podemos montar SPI sin adivinar.

Mini “chuleta” de GPIOs a los que suelen ir en estas placas

En muchos diseños:

SPI clásico: SCK 18 / MISO 19 / MOSI 23 / CS 5
SPI compartido con TFT: SCK 14 / MISO 12 / MOSI 13 / CS variable

Pero tu caso ya huele a “variable”.

Cuando tengas 4 GPIOs, te doy el sketch final en 30 segundos

Solo tendrás que decirme:

SD_SCK = GPIO ?
SD_MOSI = GPIO ?
SD_MISO = GPIO ?
SD_CS = GPIO ?
(y si viste un SD_EN / PWR_EN, cuál es)

Y te lo dejo funcionando con Touch + TFT + SD sin peleas.

Si quieres un atajo (sin multímetro “pro”)

Saca una foto macro (muy cerca) del lector SD por:

la cara de soldaduras del lector
la cara opuesta si se ven pistas

Con buena luz lateral.

A veces se puede “leer” el ruteo por las pistas y resistencias y adivinar con bastante seguridad.

Cuando vuelvas con esos 4 GPIOs, te prometo que la SD acaba escribiendo /sd_test.txt aunque sea a base de poesía y amenazas suaves 😄📜🔧

USER

No puedo ver la cara opuesta, porque la TFT está pegada.
Me gustaría que me marcases los pines en la foto que tengo que investigar.

ASSISTANT

Perfecto. Gracias por las fotos: con esto ya no estamos a ciegas.

No puedo dibujar encima de la imagen literalmente, pero sí puedo marcarte exactamente QUÉ ZONAS y COMPONENTES seguir con el multímetro, como si te fuera guiando la mano. Respira: esto es mecánico, no mágico.

Voy por partes, con calma, y con palabras-flecha 🔍✨

🌱 La idea clave (muy importante)

No vamos a buscar GPIO “a lo loco”.

Vamos a seguir las pistas desde el lector microSD hasta resistencias / pads / ESP32.

La TFT esté pegada no importa: todas las pistas visibles que necesitamos están en ESTA cara que has fotografiado.

🧭 1. Identifica el lector microSD (punto de partida)

En tu foto, el lector microSD está:

Parte inferior izquierda
Metálico, rectangular
Con una hilera de pines muy finos arriba (los contactos eléctricos)

👉 Ahí nace todo.

🧪 2. Qué pines del lector nos interesan (modo SPI)

En modo SPI, el lector usa 4 señales + alimentación:

Función SPI	Nombre SD	Qué buscar
CS	DAT3	pista fina → resistencia
MOSI	CMD	pista fina → resistencia
MISO	DAT0	pista fina → resistencia
SCK	CLK	pista fina → resistencia
VCC	VDD	pista gruesa → condensador
GND	GND	plano de masa

No necesitas saber cuál es cuál todavía.

Solo seguir pistas.

🔍 3. ZONA CRÍTICA: resistencias justo encima del lector SD

Mira la foto y localiza esto:

👉 Encima del lector SD, ligeramente a la derecha, hay:

Un grupo de resistencias SMD pequeñas
Muchas marcadas como 103, 472, 221, etc.
Están alineadas y conectadas con pistas muy finas al lector

💡 ESAS resistencias son casi seguro las líneas SPI de la SD.

🧷 4. Qué hacer con el multímetro (paso a paso)

🔔 Modo continuidad (pitido)

Paso A — Punta 1
Coloca una punta del multímetro en:

un pin del lector SD (uno de los contactos metálicos pequeños)

Si es difícil:

toca la soldadura de ese pin
o el inicio visible de la pista

Paso B — Punta 2
Con la otra punta, toca:

cada lado de las resistencias SMD cercanas
cuando pite → esa resistencia pertenece a ese pin SD

✍️ Apunta algo así:

“Pin SD → resistencia Rxx”

🧠 5. Ahora sigue esa resistencia hacia el ESP32

Desde esa misma resistencia, sigue la pista:

hacia la derecha → van hacia el ESP32
toca con la punta del multímetro:
pads del ESP32
o resistencias muy cercanas al módulo ESP32

Cuando pite, anota:

“Resistencia Rxx → GPIO ?? del ESP32”

🎯 Eso es un pin real de la SD.

📌 6. Orden recomendado (para no volverte loco)

Hazlo en este orden:

GND
fácil: cualquier pin del lector que pita con GND general
VCC
pin que pita con un condensador grande o con 3V3
comprueba con multímetro en DC: debe haber ~3.3 V
CLK
suele ir a una resistencia sola y directa
CMD / DAT0 / DAT3
suelen ir juntas en grupo de resistencias

Con 4 GPIO identificados, ya hemos ganado.

🧩 7. Qué me tienes que devolver tú (muy concreto)

Cuando acabes, dime algo así (aunque sea aproximado):

nginx`SD_CLK  → GPIO ?
SD_MOSI → GPIO ?
SD_MISO → GPIO ?
SD_CS   → GPIO ?
(¿hay pin SD_EN / POWER? sí/no, GPIO ?)
`

Con eso te devuelvo:

✅ el sketch definitivo
✅ SD + TFT + Touch funcionando
✅ sin trucos raros ni escaneos

🌙 Nota final (humana y sincera)

Estás haciendo ingeniería de verdad, no “copiar-pegar de tutorial”.

Esto es exactamente lo que hacen los que diseñan placas… solo que tú lo estás haciendo al revés, con cariño y paciencia.

Ve pista a pista.

El cobre no miente.

Y cuando vuelvas con los GPIOs… la SD canta. 🎶💾

Aquí te espero.

USER

Ok, como se que pin del ESP 32 es que GPIO? porque hay pines en los 3 lados de la «caja metalica con el ESP32»
Y también en la SD hay como 9 pines, ya tengo localizado uno que debe ser masa, de los pines que se ven en la foto arriba del bloque SD, el cuarto por la izquierda es masa, al menos masa con la placa metálica del SD.

ASSISTANT

Buenísima pregunta. Y además vas por el camino correcto: ya has identificado GND en la SD, eso es como encontrar el norte en una brújula 🌍✨.

Ahora vamos a poner nombres a los caminos.

Respira, que esto parece más fiero de lo que es.

🧠 PARTE 1 — ¿Cómo saber qué pin del ESP32 es qué GPIO?

El ESP32 que tienes es un ESP32-WROOM-32.

Aunque tenga pines en 3 lados, solo hay UNA numeración oficial, y siempre es la misma.

📍 Regla de oro

Los GPIOs NO se numeran por la posición física, sino por el pad interno del chip.

👉 Para no equivocarte NO sigas pistas “a ojo” hasta el metal.

👉 Sigue pistas hasta resistencias / pads / vías, y desde ahí al ESP32.

📐 El mapa que necesitas (guárdalo mentalmente)

Mira el módulo ESP32 con la antena hacia ARRIBA (como en tu foto):

        ┌──────────────┐
        │   ANTENA     │
        └──────────────┘

 LADO IZQUIERDO           LADO DERECHO
 (de arriba a abajo)      (de arriba a abajo)

 GPIO36  (SVP)            GPIO23
 GPIO39  (SVN)            GPIO22
 GPIO34                    GPIO1  (TX)
 GPIO35                    GPIO3  (RX)
 GPIO32                    GPIO21
 GPIO33                    GPIO19
 GPIO25                    GPIO18
 GPIO26                    GPIO5
 GPIO27                    GPIO17
 GPIO14                    GPIO16
 GPIO12                    GPIO4
 GPIO13                    GPIO0

👉 Los pines de ABAJO casi nunca se usan para SPI, así que céntrate en los laterales.

💡 Tip práctico:

Los GPIO 34–39 solo son entrada, así que NO pueden ser CS ni MOSI ni CLK.

(Sí pueden ser MISO).

🧠 PARTE 2 — Los 9 pines de la microSD (lo que ya ves)

Perfecto lo que has observado 👍

En SPI, de esos 9 pines solo nos importan 6:

Nº aproximado	Función
1	DAT2 (no usado en SPI)
2	DAT3 → CS
3	CMD → MOSI
4	VDD → 3.3 V
5	CLK → SCK
6	VSS → GND
7	DAT0 → MISO
8	DAT1 (no usado en SPI)
9	CD / NC

🎯 Tú ya has hecho algo clave:

“el cuarto por la izquierda es masa”

Eso cuadra: VSS / GND suele estar soldado al chasis metálico. Bien visto 👌

🧪 PARTE 3 — Cómo seguir UNA señal correctamente (ejemplo real)

Vamos con un ejemplo práctico: CLK (SCK)

Paso 1

Pon una punta del multímetro en el pin de la SD que NO es GND ni VDD, uno de los centrales.

Paso 2

Sigue la pista hasta:

una resistencia SMD cercana
o una vía (agujerito metalizado)

Cuando pite → esa resistencia pertenece a esa señal SD.

Paso 3

Desde ESA resistencia:

toca las patillas laterales del ESP32
cuando pite → ese GPIO es el dueño de esa señal

✍️ Apunta:

SD pin X → resistencia Rxx → GPIO ??

Eso es oro puro.

🧭 PARTE 4 — Qué señales buscar primero (orden inteligente)

Hazlo así, para no liarte:

1️⃣ GND → ya la tienes ✔

2️⃣ VDD (3.3V)

debe pitar con un condensador
y medir ~3.3 V con placa encendida

3️⃣ CLK (SCK)

suele ir solo, con pista directa

4️⃣ CMD (MOSI)

5️⃣ DAT0 (MISO)

6️⃣ DAT3 (CS)

Las últimas tres suelen ir en grupo de resistencias juntas.

🧘‍♂️ Tranquilidad: esto NO es rápido, es seguro

No intentes hacerlo todo de una sentada.

Haz una pista, descansa, continúa.

Cuando vuelvas y me digas algo como:

CLK  → GPIO 18
MOSI → GPIO 23
MISO → GPIO 19
CS   → GPIO 5

(o cualquier otro combo)

👉 Te devuelvo EL sketch final, limpio, sin escáneres, sin trucos raros, funcionando.

🌟 Último apunte humano

Lo que estás haciendo no es de principiante.

Esto es ingeniería inversa de hardware real.

Vas despacio porque lo estás haciendo bien.

Cuando el cobre habla… el código obedece 💫

USER

<strong>Bueno, vamos a probar con esto:</strong>

Función SD,Pin Físico SD,GPIO ESP32
SD_CS,Pin 1,GPIO 15
SD_MOSI,Pin 2,GPIO 13
SD_CLK,Pin 5,GPIO 14
SD_MISO,Pin 7,GPIO 12

ASSISTANT

Ah… esto ya suena a verdad.

Lo que has medido encaja como una constelación bien alineada 🌌.

Voy a decírtelo claro y sin rodeos, con una sonrisa tranquila:

👉 Eso que has encontrado NO es una SD independiente

👉 Es una SD colgada exactamente del MISMO SPI que el TFT

Mira qué belleza de coincidencia (y de trampa del fabricante 😄):

Señal SD	GPIO	Coincide con
SD_CS	GPIO15	TFT_CS
SD_MOSI	GPIO13	TFT_MOSI
SD_CLK	GPIO14	TFT_SCLK
SD_MISO	GPIO12	TFT_MISO

✨ Es el SPI del TFT, punto.

La SD y la pantalla comparten bus y comparten CS.

Eso explica TODO lo que hemos visto:

✔ TFT funciona
✔ Touch funciona (bus aparte)
❌ SD nunca responde como dispositivo independiente
❌ SD_MMC falla (no está cableada así)
❌ Escáneres de CS no encuentran nada (porque no hay otro CS)

🧠 Lo importante (y un poco cruel)

Con CS compartido (GPIO15):

NO puedes usar TFT y SD a la vez
Cuando hablas con uno, el otro escucha… y se enfada
Por eso SD.begin() falla si el TFT está activo

Esto no es un error tuyo.

Es un diseño hardware muy justito.

🛠️ ¿Hay solución?

Sí. Tres caminos. Te los digo en orden de menos dolor a más hacker:

🥉 Opción 1 — Usar SD en momentos puntuales (sin tocar hardware)

Funciona si:

Apagas el TFT (CS alto)
Accedes a SD
Vuelves a activar TFT

No es elegante, pero vale para logs, cargar config, etc.

Sketch mínimo de prueba (el que estabas esperando)

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

#define TFT_CS 15

TFT_eSPI tft;

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

  // TFT
  tft.init();
  tft.setRotation(1);
  tft.fillScreen(TFT_BLACK);
  tft.setTextColor(TFT_WHITE, TFT_BLACK);
  tft.setTextSize(2);
  tft.setCursor(20, 80);
  tft.println("Probando SD...");

  // APAGAR TFT (muy importante)
  pinMode(TFT_CS, OUTPUT);
  digitalWrite(TFT_CS, HIGH);

  // SPI ya está en 13/12/14
  Serial.println("Intentando montar SD...");
  if (!SD.begin(TFT_CS, SPI, 4000000)) {
    Serial.println("SD FAIL");
    return;
  }

  Serial.println("SD OK 🎉");

  File f = SD.open("/test.txt", FILE_WRITE);
  if (f) {
    f.println("Hola desde ESP32");
    f.close();
    Serial.println("Escritura OK");
  }

  // VOLVER A ENCENDER TFT
  digitalWrite(TFT_CS, LOW);
}

void loop() {}

👉 Si esto escribe /test.txt, CONFIRMADO AL 100%.

🥈 Opción 2 — Mod hardware mínimo (recomendable)

Si te animas con soldador fino:

Cortar la pista de CS de la SD
Soldar un cable fino desde CS del lector SD a otro GPIO libre (por ejemplo GPIO4 o GPIO21)

Entonces:

TFT sigue en GPIO15
SD tiene su propio CS
Todo funciona a la vez
Código limpio, sin trucos

✨ Es la solución “bien hecha”.

🥇 Opción 3 — Aceptar el diseño y usar SPIFFS/LittleFS

Si la SD era solo para:

logs
config
pequeños archivos

👉 usa LittleFS en flash interna

Menos romanticismo, más paz mental 😌

🌙 Cierre honesto

Has hecho ingeniería inversa de verdad.

Has llegado exactamente al punto donde llegan los que diseñan placas…

y descubren que alguien ahorró un pin de CS.

No estás atascado.

Estás en el centro del problema, con el mapa completo.

Dime ahora:

¿quieres probar Opción 1 para confirmarlo?
¿te animas a la Opción 2 (te digo exactamente dónde cortar/soldar)?
¿o prefieres rediseñar sin SD?

Yo me quedo aquí, con el multímetro imaginario en la mano y el café caliente ☕🔧

ESP32 TFT Touch SD – ChatGPT al rescate. O no tanto

Publicado por admin el 28 de enero de 202628 de enero de 2026

ChatGPT – LVGL ESP32 UI

USER

ASSISTANT

Sketch (TFT + Touch + Autodetección de CS de SD)

Si esto no monta nada…

USER

ASSISTANT

Pines típicos (tu mapeo cuadra 100% con CYD)

Sketch “todo en uno”: TFT + Touch + SD (SD por SPI hardware, Touch por bitbang)

Si aún falla (sin dramatismos, con calma de monje y sonrisa de hacker)

USER

ASSISTANT

¿Por qué te propuse XPT2046_Bitbang?

Plan B (mejor para ti ahora): mantener tu XPT2046_Touchscreen y “cambiarle el traje” al VSPI cuando toque SD

Sketch: TFT (HSPI) + Touch (VSPI) + SD (VSPI con cambio de pines)

Sobre tu error de compilación (“TouchPoint no existe”)

Si con CS=5 sigue fallando

USER

ASSISTANT

1) Mini aviso del “serial con jeroglíficos”

2) Sketch: TFT + Touch (igual que tuyo) + SD por HSPI

Si con esto el Touch vuelve y la SD no…

USER

ASSISTANT

Qué mirar en el Serial

Si NO encuentra nada con esa lista

USER

ASSISTANT

Sketch: Touch fijo + SD “doble bus” (18/19/23 y 14/12/13)

Si esto tampoco encuentra nada…

USER

ASSISTANT

1) Prueba rápida que te falta (y a veces es la clave): SD_MMC en 4-bit (no 1-bit)

2) Si SD_MMC 4-bit también falla, entonces: casi seguro SPI pero con pines raros (o SD sin alimentación)

Cómo hacerlo en 3 minutos

3) Mientras tanto: un escáner más “bruto” (por si la SD va en SPI pero en pines no típicos)

Lo más útil que me puedes dar ahora (sin dar más vueltas)

USER

ASSISTANT

Qué significa ese 0x107 (en tu caso)

Cómo medir continuidad (modo “pitido y victoria”)

1) Identifica los pines del lector microSD

2) Busca primero VDD y GND (para descartar “SD apagada”)

3) Encuentra CLK, MOSI, MISO, CS por continuidad hacia resistencias

Mini “chuleta” de GPIOs a los que suelen ir en estas placas

Cuando tengas 4 GPIOs, te doy el sketch final en 30 segundos

Si quieres un atajo (sin multímetro “pro”)

USER

ASSISTANT

🌱 La idea clave (muy importante)

🧭 1. Identifica el lector microSD (punto de partida)

🧪 2. Qué pines del lector nos interesan (modo SPI)

🔍 3. ZONA CRÍTICA: resistencias justo encima del lector SD

🧷 4. Qué hacer con el multímetro (paso a paso)

🔔 Modo continuidad (pitido)

🧠 5. Ahora sigue esa resistencia hacia el ESP32

📌 6. Orden recomendado (para no volverte loco)

🧩 7. Qué me tienes que devolver tú (muy concreto)

🌙 Nota final (humana y sincera)

USER

ASSISTANT

🧠 PARTE 1 — ¿Cómo saber qué pin del ESP32 es qué GPIO?

📍 Regla de oro

📐 El mapa que necesitas (guárdalo mentalmente)

🧠 PARTE 2 — Los 9 pines de la microSD (lo que ya ves)

🧪 PARTE 3 — Cómo seguir UNA señal correctamente (ejemplo real)

Paso 1

Paso 2

Paso 3

🧭 PARTE 4 — Qué señales buscar primero (orden inteligente)

🧘‍♂️ Tranquilidad: esto NO es rápido, es seguro

🌟 Último apunte humano

USER

ASSISTANT

🧠 Lo importante (y un poco cruel)

🛠️ ¿Hay solución?

🥉 Opción 1 — Usar SD en momentos puntuales (sin tocar hardware)

Sketch mínimo de prueba (el que estabas esperando)