Guía Completa del Módulo de Desarrollo ESP32 TTGO LILYGO

Tabla de Contenidos

1. Introducción
2. Características Principales
3. Especificaciones Técnicas
4. Hardware y Componentes
5. Pinout y Conectividad
6. Configuración del Entorno de Desarrollo
7. Programación con Arduino IDE
8. Librerías Recomendadas
9. Ejemplos de Código
10. Aplicaciones y Proyectos
11. Consejos y Buenas Prácticas
12. Recursos Adicionales
13. Conclusión

Introducción

El TTGO T-Display de LILYGO es una placa de desarrollo basada en el microcontrolador ESP32 de Espressif Systems, que integra una pantalla IPS de 1.14 pulgadas con controlador ST7789V. Este módulo representa una solución todo-en-uno ideal para proyectos de IoT (Internet de las Cosas), prototipado rápido y aplicaciones que requieren una interfaz gráfica compacta.

Con su diseño compacto de 51.52 x 25.04 x 8.54 mm y un peso de apenas 7.81 gramos, el T-Display combina la potencia del ESP32 con doble núcleo a 240 MHz, conectividad Wi-Fi y Bluetooth, con una pantalla de color de bajo consumo energético. La inclusión de un puerto USB-C y soporte para alimentación por batería lo convierte en una opción versátil para proyectos portátiles y embarcados.

Este módulo es especialmente popular en la comunidad maker y entre desarrolladores de IoT debido a su relación calidad-precio, facilidad de programación mediante Arduino IDE y la amplia disponibilidad de bibliotecas y recursos de código abierto.

Características Principales

Ventajas del T-Display ESP32

• Todo en uno: Integra microcontrolador ESP32, pantalla LCD y conectividad inalámbrica en un solo módulo
• Pantalla IPS de alta calidad: 1.14 pulgadas con controlador ST7789V y resolución de 240 x 135 píxeles
• Conectividad dual: Wi-Fi 802.11 b/g/n y Bluetooth v4.2BR/EDR con BLE
• USB-C moderno: Puerto USB Tipo-C para programación y alimentación
• Bajo consumo: Ideal para proyectos alimentados por batería con corrientes de reposo de aproximadamente 350 µA
• Dos botones programables: Para interacción del usuario sin componentes adicionales
• Compatibilidad amplia: Funciona con Arduino IDE, MicroPython, ESP-IDF y PlatformIO
• Extensa comunidad: Gran cantidad de recursos, tutoriales y librerías disponibles

Casos de Uso Típicos

• Dispositivos IoT con interfaz gráfica
• Monitores de sensores portátiles
• Controladores remotos con visualización
• Relojes inteligentes y wearables
• Estaciones meteorológicas
• Sistemas de monitoreo de datos
• Interfaces HMI compactas
• Proyectos de domótica

Especificaciones Técnicas

Especificaciones de Hardware

Especificaciones de la Fuente de Alimentación

Especificaciones de Wi-Fi

Especificaciones de Bluetooth

Especificaciones de Software

Hardware y Componentes

Descripción de Componentes Principales

Microcontrolador ESP32

El corazón del T-Display es el ESP32 de Espressif Systems, un sistema en chip (SoC) altamente integrado que combina:

• Doble núcleo Xtensa LX6: Permite procesamiento multitarea eficiente
• 240 MHz de frecuencia: Potencia de procesamiento significativa para aplicaciones embebidas
• 520 kB de SRAM: Memoria interna para variables y operaciones
• 4 MB de Flash: Almacenamiento para el firmware y datos
• Múltiples interfaces: UART, SPI, SDIO, I²C, I²S, PWM, ADC, DAC

Pantalla IPS ST7789V

La pantalla integrada es uno de los puntos fuertes del T-Display:

• Tecnología IPS: Mejores ángulos de visión y reproducción de colores que las pantallas TFT tradicionales
• 1.14 pulgadas: Tamaño compacto ideal para dispositivos portátiles
• Resolución 240 x 135: Suficiente para interfaces gráficas claras y legibles
• Controlador ST7789V: Driver ampliamente soportado por librerías populares
• Bajo consumo: Optimizada para aplicaciones con batería

Conectividad y Periféricos

• Puerto USB-C: Moderno y reversible, facilita la conexión y programación
• Conector JST para batería: Permite alimentación portátil con baterías de litio
• Dos botones programables: GPIO35 (BOT1) y GPIO0 (BOT2) para interacción
• Pines GPIO expuestos: Para conectar sensores, actuadores y otros periféricos

Pinout y Conectividad

Asignación de Pines del T-Display

Conectores Disponibles

1. USB Tipo-C: Programación, alimentación y comunicación serial
2. Conector JST 2P 1.25mm: Para conexión de batería de litio 3.7V
3. Pines GPIO header: Dos filas de pines macho (o hembra en versiones sin soldar) para conexión de periféricos

Diagrama de Conexiones

┌─────────────────────────────────────────────────┐
│              TTGO T-Display ESP32               │
│                                                 │
│  ┌─────────────────────────────────────────┐   │
│  │           Pantalla IPS 1.14"            │   │
│  │           240x135 ST7789V               │   │
│  └─────────────────────────────────────────┘   │
│                                                 │
│  [BOT1] GPIO35    [BOT2] GPIO0                 │
│                                                 │
│  ┌─────────────────────────────────────────┐   │
│  │  Pines GPIO Expuestos                   │   │
│  │  32 31 30 29 28 27 26 25 24 23 22 21    │   │
│  │  12 13 14 15 16 17 18 19 20 05 04 00    │   │
│  └─────────────────────────────────────────┘   │
│                                                 │
│  [USB-C]    [JST Batería]                       │
└─────────────────────────────────────────────────┘

Configuración del Entorno de Desarrollo

Instalación de Drivers USB

Antes de comenzar, es necesario instalar los drivers adecuados para la comunicación USB:

Para Windows:

1. Driver CH343/CH340 (para placas con chip WCH):

   • Descargar desde: http://www.wch-ic.com/downloads/CH343SER_ZIP.html
   • Ejecutar el instalador como administrador
   • Reiniciar el sistema si es necesario

2. Driver CP21xx (alternativa):

   • Descargar desde: https://www.silabs.com/developers/usb-to-uart-bridge-vcp-drivers

Para macOS:

• Driver CH34x: http://www.wch-ic.com/downloads/CH34XSER_MAC_ZIP.html

Para Linux:

Los drivers CH340/CH343 generalmente están incluidos en el kernel de Linux. Si no funcionan, pueden instalarse desde los repositorios.

Instalación de Arduino IDE

1. Descargar la última versión de Arduino IDE
2. Instalar siguiendo las instrucciones del sistema operativo
3. Abrir Arduino IDE después de la instalación

Configuración de Arduino IDE para ESP32

1. Agregar URL de Board Manager:

   • Ir a Archivo > Preferencias
   • En "URLs de administración de tarjetas adicionales", agregar:

     https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
     

2. Instalar el soporte ESP32:

   • Ir a Herramientas > Placa > Administrador de placas
   • Buscar "esp32"
   • Instalar la plataforma "esp32 by Espressif Systems"
   • Nota importante: Para compatibilidad máxima con TFT_eSPI, se recomienda la versión 2.0.14

3. Seleccionar la placa:

   • Herramientas > Placa > ESP32 Arduino > ESP32 Dev Module

4. Configuraciones recomendadas:

   • Upload Speed: 921600
   • CPU Frequency: 240MHz
   • Flash Size: 4MB (32Mb)
   • PSRAM: Disabled (desactivado para T-Display original)
   • Partition Scheme: Default 4MB with spiffs

Instalación de la Librería TFT_eSPI

La biblioteca TFT_eSPI es esencial para controlar la pantalla:

1. Descargar TFT_eSPI desde GitHub

2. Extraer el archivo ZIP

3. Copiar la carpeta TFT_eSPI a la carpeta libraries de Arduino:

   • Windows: C:\Users\<TuUsuario>\Documents\Arduino\libraries\
   • macOS: /Users/<TuUsuario>/Documents/Arduino/libraries/
   • Linux: /home/<TuUsuario>/Arduino/libraries/

4. Configurar User_Setup.h:

   • Abrir el archivo TFT_eSPI/User_Setup.h
   • O bien, usar uno de los setups preconfigurados para T-Display
   • Para T-Display ESP32, se recomienda configurar:

     #define USER_SETUP_ID 21
     #define ST7789_DRIVER
     #define TFT_WIDTH  135
     #define TFT_HEIGHT 240
     #define CGRAM_OFFSET
     #define TFT_MOSI 19
     #define TFT_SCLK 18
     #define TFT_CS   5
     #define TFT_DC   16
     #define TFT_RST  23
     #define TFT_BL   4
     #define TFT_BACKLIGHT_ON HIGH
     #define LOAD_GLCD
     #define LOAD_FONT2
     #define LOAD_FONT4
     #define LOAD_FONT6
     #define LOAD_FONT7
     #define LOAD_FONT8
     #define LOAD_GFXFF
     #define SMOOTH_FONT
     #define SPI_FREQUENCY  40000000
     #define SPI_READ_FREQUENCY  20000000
     #define SPI_TOUCH_FREQUENCY  2500000
     

Programación con Arduino IDE

Primer Programa: Encender Retroiluminación

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

TFT_eSPI tft = TFT_eSPI();

void setup() {
  tft.init();
  tft.setRotation(1);
  tft.fillScreen(TFT_BLACK);
  
  // Encender retroiluminación
  tft.setSwapBytes(true);
  
  // Mostrar texto de prueba
  tft.setTextColor(TFT_WHITE, TFT_BLACK);
  tft.setTextSize(2);
  tft.setCursor(10, 10);
  tft.println("¡Hola T-Display!");
}

void loop() {
  // Programa vacío, todo ocurre en setup
}

Configuración de los Botones

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

TFT_eSPI tft = TFT_eSPI();

#define BUTTON_1 35
#define BUTTON_2 0

bool button1State = false;
bool button2State = false;

void setup() {
  Serial.begin(115200);
  
  // Configurar botones como entradas con pull-up interno
  pinMode(BUTTON_1, INPUT_PULLUP);
  pinMode(BUTTON_2, INPUT_PULLUP);
  
  tft.init();
  tft.setRotation(1);
  tft.fillScreen(TFT_BLACK);
  
  tft.setTextColor(TFT_WHITE, TFT_BLACK);
  tft.setTextSize(2);
  tft.setCursor(10, 10);
  tft.println("T-Display Test");
  tft.setTextSize(1);
  tft.setCursor(10, 40);
  tft.println("Boton 1: GPIO35");
  tft.setCursor(10, 55);
  tft.println("Boton 2: GPIO0");
}

void loop() {
  // Leer estado de botones (activan en LOW)
  bool currentButton1 = digitalRead(BUTTON_1);
  bool currentButton2 = digitalRead(BUTTON_2);
  
  // Detectar cambio en Botón 1
  if (currentButton1 != button1State) {
    button1State = currentButton1;
    if (!button1State) {
      Serial.println("Botón 1 presionado");
      tft.setTextColor(TFT_GREEN, TFT_BLACK);
      tft.setCursor(10, 80);
      tft.println("Boton 1 ON");
    } else {
      tft.setTextColor(TFT_WHITE, TFT_BLACK);
      tft.setCursor(10, 80);
      tft.println("Boton 1 OFF");
    }
  }
  
  // Detectar cambio en Botón 2
  if (currentButton2 != button2State) {
    button2State = currentButton2;
    if (!button2State) {
      Serial.println("Botón 2 presionado");
      tft.setTextColor(TFT_BLUE, TFT_BLACK);
      tft.setCursor(10, 100);
      tft.println("Boton 2 ON");
    } else {
      tft.setTextColor(TFT_WHITE, TFT_BLACK);
      tft.setCursor(10, 100);
      tft.println("Boton 2 OFF");
    }
  }
  
  delay(50);
}

Bibliotecas Recomendadas

Bibliotecas Esenciales

Bibliotecas Útiles Adicionales

Instalación de bibliotecas en Arduino IDE

1. Ir a Programa > Incluir biblioteca > Administrar bibliotecas
2. Buscar el nombre de la librería
3. Hacer clic en "Instalar"

Ejemplos de Código

Ejemplo 1: Mostrar Imagen en la Pantalla

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

TFT_eSPI tft = TFT_eSPI();

// Imagen bitmap simple (8x8 píxeles)
const unsigned char logo[] = {
  0xFF, 0xFF, 0xFF, 0xFF, 0x81, 0xFF, 0x81, 0xFF,
  0x81, 0xFF, 0x81, 0xFF, 0x81, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

void setup() {
  tft.init();
  tft.setRotation(1);
  tft.fillScreen(TFT_BLACK);
  
  // Dibujar imagen
  tft.drawBitmap(58, 40, logo, 8, 8, TFT_RED);
  
  tft.setTextColor(TFT_WHITE, TFT_BLACK);
  tft.setTextSize(2);
  tft.setCursor(20, 60);
  tft.println("Imagen Bitmap");
}

void loop() {
  // No hacer nada
}

Ejemplo 2: Conectar a Wi-Fi y Mostrar IP

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

TFT_eSPI tft = TFT_eSPI();

const char* ssid = "TU_SSID";
const char* password = "TU_PASSWORD";

void setup() {
  Serial.begin(115200);
  
  tft.init();
  tft.setRotation(1);
  tft.fillScreen(TFT_BLACK);
  
  tft.setTextColor(TFT_WHITE, TFT_BLACK);
  tft.setTextSize(2);
  tft.setCursor(10, 10);
  tft.println("Conectando...");
  
  WiFi.begin(ssid, password);
  
  int attempts = 0;
  while (WiFi.status() != WL_CONNECTED && attempts < 30) {
    delay(500);
    Serial.print(".");
    tft.fillRect(10, 30, 200, 20, TFT_BLACK);
    tft.setCursor(10, 30);
    tft.print("Intento: ");
    tft.print(attempts + 1);
    attempts++;
  }
  
  if (WiFi.status() == WL_CONNECTED) {
    tft.fillRect(10, 30, 200, 80, TFT_BLACK);
    tft.setCursor(10, 30);
    tft.setTextColor(TFT_GREEN, TFT_BLACK);
    tft.println("¡Conectado!");
    tft.setTextSize(1);
    tft.setCursor(10, 50);
    tft.print("IP: ");
    tft.println(WiFi.localIP());
    tft.setCursor(10, 65);
    tft.print("Señal: ");
    tft.print(WiFi.RSSI());
    tft.println(" dBm");
  } else {
    tft.setTextColor(TFT_RED, TFT_BLACK);
    tft.setCursor(10, 30);
    tft.println("Error de conexión");
  }
}

void loop() {
  // Mantener conexión
  delay(1000);
}

Ejemplo 3: Lectura de Sensor y Visualización

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

TFT_eSPI tft = TFT_eSPI();

#define SENSOR_PIN 34  // ADC_IN

void setup() {
  Serial.begin(115200);
  
  tft.init();
  tft.setRotation(1);
  tft.fillScreen(TFT_BLACK);
  
  tft.setTextColor(TFT_WHITE, TFT_BLACK);
  tft.setTextSize(2);
  tft.setCursor(10, 10);
  tft.println("Lectura ADC");
  tft.setTextSize(1);
}

void loop() {
  // Leer valor analógico (0-4095)
  int sensorValue = analogRead(SENSOR_PIN);
  
  // Convertir a voltaje (3.3V reference)
  float voltage = sensorValue * (3.3 / 4095.0);
  
  // Limpiar área de lectura
  tft.fillRect(10, 40, 200, 60, TFT_BLACK);
  
  // Mostrar valores
  tft.setTextColor(TFT_CYAN, TFT_BLACK);
  tft.setTextSize(2);
  tft.setCursor(10, 40);
  tft.print("Valor: ");
  tft.print(sensorValue);
  
  tft.setTextSize(1);
  tft.setCursor(10, 65);
  tft.print("Voltaje: ");
  tft.print(voltage, 2);
  tft.println(" V");
  
  // Barra de progreso
  int barWidth = map(sensorValue, 0, 4095, 0, 220);
  tft.fillRect(10, 90, 220, 20, TFT_DARKGREY);
  tft.fillRect(10, 90, barWidth, 20, TFT_GREEN);
  
  delay(500);
}

Ejemplo 4: Cliente MQTT Básico

#include <TFT_eSPI.h>
#include <SPI.h>
#include <WiFi.h>
#include <PubSubClient.h>

TFT_eSPI tft = TFT_eSPI();

const char* ssid = "TU_SSID";
const char* password = "TU_PASSWORD";
const char* mqtt_server = "broker.hivemq.com";
const int mqtt_port = 1883;

WiFiClient espClient;
PubSubClient client(espClient);

int messageCount = 0;

void setup_wifi() {
  delay(10);
  WiFi.begin(ssid, password);
  
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
  }
}

void callback(char* topic, byte* payload, unsigned int length) {
  tft.fillRect(10, 80, 200, 40, TFT_BLACK);
  tft.setCursor(10, 80);
  tft.setTextColor(TFT_YELLOW, TFT_BLACK);
  tft.print("Msg recibido!");
}

void reconnect() {
  while (!client.connected()) {
    if (client.connect("TDisplayClient")) {
      client.subscribe("tdisplay/test");
    } else {
      delay(5000);
    }
  }
}

void setup() {
  tft.init();
  tft.setRotation(1);
  tft.fillScreen(TFT_BLACK);
  
  tft.setTextColor(TFT_WHITE, TFT_BLACK);
  tft.setTextSize(2);
  tft.setCursor(10, 10);
  tft.println("MQTT Client");
  
  setup_wifi();
  client.setServer(mqtt_server, mqtt_port);
  client.setCallback(callback);
}

void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();
  
  // Publicar mensaje cada 10 segundos
  static unsigned long lastPublish = 0;
  if (millis() - lastPublish > 10000) {
    messageCount++;
    String topic = "tdisplay/test";
    String message = "Mensaje #" + String(messageCount);
    client.publish(topic.c_str(), message.c_str());
    
    tft.fillRect(10, 50, 200, 20, TFT_BLACK);
    tft.setCursor(10, 50);
    tft.setTextColor(TFT_GREEN, TFT_BLACK);
    tft.print("Publicado: ");
    tft.print(messageCount);
    
    lastPublish = millis();
  }
}

Aplicaciones y Proyectos

Proyectos Recomendados para Principiantes

1. Reloj Digital con NTP

   • Sincronización automática de hora mediante NTP
   • Visualización de hora, fecha y temperatura
   • Actualización cada segundo

2. Monitor de Sensores I²C

   • Conexión de sensores como BME280, MPU6050
   • Visualización de datos en tiempo real
   • Gráficos simples de tendencias

3. Controlador Wi-Fi

   • Encendido/apagado de dispositivos mediante Wi-Fi
   • Interfaz web simple o control por app
   • Feedback visual en pantalla

4. Estación Meteorológica

   • Lectura de sensores de temperatura, humedad, presión
   • Visualización de datos y pronósticos
   • Conexión a API meteorológica

Proyectos Intermedios

1. Dashboard IoT

   • Visualización de múltiples sensores
   • Conexión a plataforma IoT (Blynk, ThingSpeak, etc.)
   • Gráficos y estadísticas

2. Control Remoto con Pantalla

   • Control de dispositivos mediante IR o Wi-Fi
   • Estado visual en pantalla
   • Botones programables para funciones

3. Monitor de Batería

   • Lectura de voltaje de batería
   • Indicador de nivel de carga
   • Alertas de bajo voltaje

4. Reproductor de RSS/Noticias

   • Lectura de feeds RSS
   • Visualización de titulares
   • Navegación con botones

Proyectos Avanzados

1. Sistema de Home Automation

   • Control centralizado de dispositivos smart home
   • Integración con Home Assistant
   • Escenas y automatizaciones

2. Terminal MQTT Completo

   • Publicación y suscripción a múltiples temas
   • Visualización de mensajes en tiempo real
   • Configuración mediante pantalla

3. Web Server con Configuración

   • Servidor web para configuración
   • Captura de credenciales Wi-Fi
   • Actualización OTA

4. Dispositivo Meshtastic

   • Comunicación mesh con LoRa (con módulo adicional)
   • Mensajería descentralizada
   • Integración con red Meshtastic

Consejos y Buenas Prácticas

Optimización de Energía

1. Modo Deep Sleep:

   // Ejemplo de configuración de Deep Sleep
   esp_sleep_enable_timer_wakeup(60000000); // 60 segundos
   esp_deep_sleep_start();
   

2. Control de Retroiluminación:

   • Apagar la pantalla cuando no se use
   • Reducir brillo en condiciones de poca luz
   • Usar detección de proximidad si es posible

3. Gestión de Wi-Fi:

   • Conectar solo cuando sea necesario
   • Usar modos de bajo consumo del ESP32
   • Considerar usar BLE en lugar de Wi-Fi para algunas aplicaciones

Mejoras de Rendimiento

1. SPI Frequency: Aumentar la frecuencia SPI de la pantalla para mejor rendimiento
2. Double Buffering: Usar buffering para animaciones más fluidas
3. Optimizar Código: Minimizar operaciones en el loop principal

Solución de Problemas Comunes

Recursos Adicionales

Documentación Oficial

• Repositorio GitHub: Xinyuan-LilyGO/TTGO-T-Display
• Biblioteca TFT_eSPI: Bodmer/TFT_eSPI
• Documentación ESP32: Espressif Documentation

Tutoriales y Guías

• Arduino ESP32 Tutorial: Random Nerd Tutorials
• TFT_eSPI Examples: TFT_eSPI Examples
• ESP32 Projects: ESP32 Projects Hub

Comunidades

• Foro ESP32: ESP32 Forum
• Reddit r/esp32: Reddit ESP32
• Arduino Forum: Arduino ESP32

Herramientas Útiles

• ESP32 Pinout Reference: Pinout Reference
• Online JSON Formatter: Para pruebas con ArduinoJson
• MQTT Broker Online: HiveMQ Broker

Conclusión

El TTGO T-Display ESP32 representa una excelente opción para desarrolladores que buscan una solución compacta y completa para proyectos IoT con interfaz gráfica. Su combinación de un potente microcontrolador ESP32, pantalla IPS de calidad, conectividad inalámbrica y facilidad de programación lo convierte en una herramienta versátil para una amplia gama de aplicaciones.

Puntos Clave a Recordar

1. Facilidad de uso: Con Arduino IDE y la librería TFT_eSPI, el desarrollo es accesible incluso para principiantes
2. Versatilidad: Adecuado para proyectos desde simples displays hasta sistemas IoT complejos
3. Bajo costo: Excelente relación calidad-precio comparado con soluciones similares
4. Comunidad activa: Amplio soporte y recursos disponibles en línea
5. Consumo eficiente: Opciones de bajo consumo para aplicaciones portátiles

Próximos Pasos

Si estás comenzando con el T-Display:

1. Configura tu entorno de desarrollo siguiendo esta guía
2. Prueba los ejemplos básicos de pantalla y botones
3. Explora la librería TFT_eSPI para conocer sus capacidades
4. Comienza con un proyecto simple y aumenta la complejidad gradualmente
5. Únete a las comunidades para compartir tus proyectos y aprender de otros

El T-Display es una plataforma excelente para aprender sobre desarrollo embebido, IoT y programación de interfaces gráficas. ¡Las únicas limitaciones son tu imaginación y creatividad!

Nota: Este documento se basa en la información disponible del producto TTGO T-Display con ESP32 original (no S3). Las especificaciones pueden variar ligeramente entre diferentes lotes de producción. Siempre verifica las especificaciones de tu dispositivo específico antes de comenzar un proyecto.

Última actualización: Julio 2026