1. Shared SPI Pins:
   • CLK (Clock): Connect U1:U1:D18 to the CLK pin of all three TFT displays.
   • MOSI (Master Out Slave In): Connect U1:U1:D23 to the MOSI pin of all three TFT displays.
   • MISO (Master In Slave Out): Connect U1:U1:D19 to the MISO pin of all three TFT displays.
2. TFT Display 1:
   • CS (Chip Select): Connect U1:U1:D5 (TFT_CS1) to the CS pin of TFT display 1.
   • DC (Data/Command): Connect U1:U1:D15 (TFT_DC1) to the DC pin of TFT display 1.
3. TFT Display 2:
   • CS (Chip Select): Connect U1:U1:D16 (TFT_CS2) to the CS pin of TFT display 2.
   • DC (Data/Command): Connect U1:U1:D14 (TFT_DC2) to the DC pin of TFT display 2.
4. TFT Display 3:
   • CS (Chip Select): Connect U1:U1:D17 (TFT_CS3) to the CS pin of TFT display 3.
   • DC (Data/Command): Connect U1:U1:D13 (TFT_DC3) to the DC pin of TFT display 3.
5. SD Card Module:
   • CS (Chip Select): Connect U1:U1:D2 (SD_CS) to the CS pin of the SD card module.
6. Power Supply:
   • 3.3V Power: Connect U1:3V3 to the VCC (or 3.3V) pin of all TFT displays and the SD card module.
   • Ground: Connect U1:GND to the GND pin of all TFT displays and the SD card module.

• Connect U1:U1:D18 to CLK pin of all TFT displays.
• Connect U1:U1:D23 to MOSI pin of all TFT displays.
• Connect U1:U1:D19 to MISO pin of all TFT displays.
• Connect U1:U1:D5 to CS pin of TFT display 1.
• Connect U1:U1:D15 to DC pin of TFT display 1.
• Connect U1:U1:D16 to CS pin of TFT display 2.
• Connect U1:U1:D14 to DC pin of TFT display 2.
• Connect U1:U1:D17 to CS pin of TFT display 3.
• Connect U1:U1:D13 to DC pin of TFT display 3.
• Connect U1:U1:D2 to CS pin of SD card module.
• Connect U1:3V3 to VCC pins of all components.
• Connect U1:GND to GND pins of all components.

• Conectar U1:U1:D18 al pin CLK de todas las pantallas TFT.
• Conectar U1:U1:D23 al pin MOSI de todas las pantallas TFT.
• Conectar U1:U1:D19 al pin MISO de todas las pantallas TFT.

• Conectar U1:U1:D5 $(TFT\_CS1)$ al pin CS de la pantalla TFT 1.
• Conectar U1:U1:D15 $(TFT\_DC1)$ al pin DC de la pantalla TFT 1.

• Conectar U1:U1:D16 $(TFT\_CS2)$ al pin CS de la pantalla TFT 2.
• Conectar U1:U1:D14 $(TFT\_DC2)$ al pin DC de la pantalla TFT 2.

• Conectar U1:U1:D17 $(TFT\_CS3)$ al pin CS de la pantalla TFT 3.
• Conectar U1:U1:D13 $(TFT\_DC3)$ al pin DC de la pantalla TFT 3.

• Conectar U1:U1:D2 $(SD\_CS)$ al pin CS del módulo de tarjeta SD.

• Conectar U1:3V3 al pin VCC de todas las componentes.
• Conectar U1:GND al pin GND de todas las componentes.

1. Colocar Componentes:
   • Coloca el ESP32-DEVKIT-V1 como U1.
   • Coloca tres GC9A01A como U2, U3, y U4.
   • Coloca un módulo de tarjeta SD.
2. Realizar Conexiones de Datos:
   • Conecta U1:U1:D18 al pin CLK de U2, U3, y U4.
   • Conecta U1:U1:D23 al pin MOSI de U2, U3, y U4.
   • Conecta U1:U1:D19 al pin MISO de U2, U3, y U4.
3. Realizar Conexiones de Control:
   • Conecta U1:U1:D5 al pin CS de U2.
   • Conecta U1:U1:D15 al pin DC de U2.
   • Conecta U1:U1:D16 al pin CS de U3.
   • Conecta U1:U1:D14 al pin DC de U3.
   • Conecta U1:U1:D17 al pin CS de U4.
   • Conecta U1:U1:D13 al pin DC de U4.
4. Conexiones de Control para Tarjeta SD:
   • Conecta U1:U1:D2 al pin CS del módulo de tarjeta SD.
5. Conexiones de Alimentación:
   • Conecta U1:3V3 al pin VCC de todas las pantallas TFT y del módulo de tarjeta SD.
   • Conecta U1:GND al pin GND de todas las pantallas TFT y del módulo de tarjeta SD.

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

// Definir pines compartidos del SPI para todas las pantallas TFT
#define TFT_SPI_CLK 18
#define TFT_SPI_MOSI 23
#define TFT_SPI_MISO 19

// Definir pines individualizados CS para cada pantalla TFT
#define TFT_CS1 5
#define TFT_CS2 16
#define TFT_CS3 17

// Definir pines individualizados DC para cada pantalla TFT
#define TFT_DC1 15
#define TFT_DC2 14
#define TFT_DC3 13

// Definir pin de la tarjeta SD
#define SD_CS 2

// Crear instancias de las pantallas TFT
TFT_eSPI tft1 = TFT_eSPI(TFT_CS1, TFT_DC1, TFT_SPI_CLK, TFT_SPI_MISO);
TFT_eSPI tft2 = TFT_eSPI(TFT_CS2, TFT_DC2, TFT_SPI_CLK, TFT_SPI_MISO);
TFT_eSPI tft3 = TFT_eSPI(TFT_CS3, TFT_DC3, TFT_SPI_CLK, TFT_SPI_MISO);

// Inicializar la librería LVGL
lv_disp_buf_t disp_buf;
static lv_color_t buf[LV_HOR_RES_MAX * 10];

// Función para inicializar una pantalla TFT individual
void initTFT(TFT_eSPI &tft) {
  tft.begin();
  tft.setRotation(0);
}

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

  // Inicializar las pantallas TFT
  initTFT(tft1);
  initTFT(tft2);
  initTFT(tft3);

  // Inicializar la tarjeta SD
  if (!SD.begin(SD_CS)) {
    Serial.println("¡Fallo en la inicialización de la tarjeta SD!");
    return;
  }

  // Inicializar la librería LVGL
  lv_init();

  // Configuración del buffer de pantalla
  lv_disp_buf_init(&disp_buf, buf, NULL, LV_HOR_RES_MAX * 10);
}

void loop() {
  // Cargar imágenes desde la tarjeta SD
  File imageFile1 = SD.open("/image1.dat");
  if (!imageFile1) {
    Serial.println("Error al abrir el archivo de imagen 1");
    return;
  }
  
  File imageFile2 = SD.open("/image2.dat");
  if (!imageFile2) {
    Serial.println("Error al abrir el archivo de imagen 2");
    imageFile1.close();
    return;
  }
  
  File imageFile3 = SD.open("/image3.dat");
  if (!imageFile3) {
    Serial.println("Error al abrir el archivo de imagen 3");
    imageFile1.close();
    imageFile2.close();
    return;
  }

  uint16_t* img1 = (uint16_t*) malloc(sizeof(uint16_t) * 160 * 80);
  uint16_t* img2 = (uint16_t*) malloc(sizeof(uint16_t) * 160 * 80);
  uint16_t* img3 = (uint16_t*) malloc(sizeof(uint16_t) * 160 * 80);

  // Aquí iría el código para cargar las imágenes en las matrices img1, img2, img3

  // Mostrar las imágenes en cada pantalla TFT
  tft1.pushImage(0, 0, 160, 80, img1);
  tft2.pushImage(0, 0, 160, 80, img2);
  tft3.pushImage(0, 0, 160, 80, img3);

  // Liberar memoria y cerrar archivos de imágenes
  free(img1);
  free(img2);
  free(img3);

  imageFile1.close();
  imageFile2.close();
  imageFile3.close();

  delay(1000); // esperar 1 segundo antes de actualizar las imágenes nuevamente
}

void load_image(File &file, uint16_t* img) {
  // Implementar función para leer los datos de la imagen
}

1. Instalar el Soporte para ESP32 en Arduino IDE:
   • Abre el Arduino IDE.
   • Ve a File > Preferences.
   • En el campo Additional Board Manager URLs, agrega https://dl.espressif.com/dl/package_esp32_index.json.
   • Abre el Boards Manager desde Tools > Board > Boards Manager.
   • Busca “ESP32” e instala el paquete esp32 por Espressif Systems.
2. Seleccionar la Placa y el Puerto:
   • Ve a Tools > Board, selecciona ESP32 Dev Module.
   • Ve a Tools > Port y selecciona el puerto correspondiente a tu ESP32.

1. Abre el Arduino IDE.
2. Copia y pega el código anteriormente proporcionado en un nuevo sketch.
3. Guarda el sketch.
4. Conecta el ESP32 a tu computadora mediante un cable USB.
5. Haz clic en el botón Upload en la esquina superior izquierda del Arduino IDE para cargar el código en el ESP32.

1. Documentar el Código:
   • Es una buena práctica incluir tu código como un archivo adjunto o comentario en tu proyecto Flux para mantener todo bien documentado.
2. Adjuntar el Código al ESP32:
   • En el diagrama de Flux, selecciona el ESP32 (U1) y agrega una opción o comentario que indique que este componente utiliza el código. No es necesario cargar el código directamente a través de Flux, pero puedes incluir un enlace o nombre del archivo de tu sketch.

1. Asegúrate de que Todas las Conexiones sean Correctas:
   • Antes de subir el código, verifica dos veces todas tus conexiones físicas según el diagrama hecho en Flux.
2. Probar el Sistema Completo:
   • Una vez cargado el código y conectadas todas las piezas, enciende tu sistema y revisa la salida.