El LilyGO TTGO T5-4.7 E-Paper es un módulo de desarrollo integrado que combina una pantalla de papel electrónico (e-ink) de 4,7 pulgadas con un microcontrolador ESP32-S3.
La pantalla de papel electrónico de la placa funciona con una resolución de 540 × 960 píxeles con 16 niveles de escala de grises y solo requiere energía durante las operaciones de actualización, lo que minimiza el consumo de energía para datos que cambian lentamente, como los datos meteorológicos.
En este tutorial aprenderás cómo empezar con la placa LilyGO TTGO T5-4.7 E-Paper. Además, construiremos una estación meteorológica que obtiene sus datos a través de internet desde OpenWeatherMap y los muestra en la pantalla de papel electrónico.
Partes necesarias
Puedes conseguir el LilyGO TTGO T5-4.7 E-Paper en DFRobot o Amazon usando los enlaces a continuación. Si quieres alimentar la pantalla con batería, también necesitarás una batería.
Recomiendo una batería recargable 18650 con el soporte correspondiente. Sin embargo, tendrás que soldar los cables del soporte de la batería al conector de batería del LilyGO E-Paper Display. No es difícil, pero necesitarás un soldador.
LilyGO TTGO T5-4.7 E-Paper
Batería recargable 18650
Soporte para batería 18650
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Hardware del LilyGO TTGO T5-4.7 E-Paper
La plataforma LilyGO TTGO T5-4.7 E-Paper es una placa controladora de pantalla E Ink de 4,7 pulgadas que integra un módulo ESP32-S3 con un panel de papel electrónico en escala de grises adjunto.
El diseño está orientado a aplicaciones que se benefician de información persistente en pantalla y bajo consumo promedio de energía, donde el contenido de la pantalla puede permanecer visible sin actualización continua. La foto a continuación muestra el frente y la parte trasera de la placa LilyGO TTGO T5-4.7 E-Paper.
Procesador y subsistema de memoria
La placa está construida alrededor del módulo ESP32-S3-WROOM-1-N16R18. Esta configuración proporciona 16 MB de flash a bordo para firmware y recursos, y 8 MB de PSRAM para soportar operaciones intensivas en memoria como buffers gráficos, renderizado de fuentes y manejo de datos de red.
El ESP32-S3 también habilita conectividad Wi-Fi y suficiente capacidad de cómputo para adquisición periódica de datos, procesamiento local y actualizaciones de pantalla típicas de cargas de trabajo de estaciones meteorológicas.
Características de la pantalla de papel electrónico
El panel de papel electrónico integrado tiene una resolución de 540 × 960 píxeles en orientación vertical que soporta renderizado en escala de grises de 16 niveles. La pantalla permite actualización parcial, con actualizaciones selectivas de regiones para reducir el tiempo de refresco y el consumo de energía cuando solo cambia una parte del contenido de la pantalla.
Sin embargo, la pantalla no debe ser actualizada parcialmente durante mucho tiempo. ¡De lo contrario, quedarán imágenes residuales irreversibles!
Entrada de usuario y controles integrados
La entrada física se soporta mediante tres botones, incluyendo uno personalizable por el usuario para funciones a nivel de aplicación. Los otros botones son un botón de reset y un botón de arranque.
La placa también expone una interfaz dedicada de 6 pines destinada a conectar un panel táctil, que puede comprarse por separado.
Interfaz de alimentación por batería
Para alimentación por batería, la placa incluye un conector PH 2.0 diseñado para conexión de batería de 3.7 V. La protección de carga y descarga de la batería está proporcionada por un circuito integrado de protección HX6610S.
Encabezado de expansión y compatibilidad con host
Se proporciona un encabezado de 40 pines en la parte superior de la placa compatible con la interfaz BUS de Raspberry Pi. Aquí está el pinout del encabezado:
Ten en cuenta que las interfaces I2C (SDA, SCL) y SPI (MISO, MOSI, CS) son accesibles allí. La imagen a continuación muestra los pinouts de los otros conectores de la placa:
GPIO
La siguiente tabla lista los pines GPIO y su uso interno por el ESP32 incorporado. Solo los pines GPIO 45, 10, 48 y 39 están disponibles para aplicaciones de usuario.
| GPIO del ESP32S3 | Conectado a | Libre |
|---|---|---|
| 13 | 74HCT4094D CFG_DATA | ❌ |
| 12 | 74HCT4094D CFG_CLK | ❌ |
| 0 | 74HCT4094D CFG_STR | ❌ |
| 38 | E-paper CKV | ❌ |
| 40 | E-paper STH | ❌ |
| 41 | E-paper CKH | ❌ |
| 8 | E-paper D0 | ❌ |
| 1 | E-paper D1 | ❌ |
| 2 | E-paper D2 | ❌ |
| 3 | E-paper D3 | ❌ |
| 4 | E-paper D4 | ❌ |
| 5 | E-paper D5 | ❌ |
| 6 | E-paper D6 | ❌ |
| 7 | E-paper D7 | ❌ |
| 21 | Botón | ❌ |
| 14 | ADC de batería | ❌ |
| 16 | SD MISO | ❌* |
| 15 | SD MOSI | ❌* |
| 11 | SD SCK | ❌* |
| 42 | SD CS | ❌* |
| 18 | SDA | ❌ |
| 17 | SCL | ❌ |
| 47 | IRQ del panel táctil | ❌ |
| 45 | No conectado | ✅ |
| 10 | No conectado | ✅ |
| 48 | No conectado | ✅ |
| 39 | No conectado | ✅ |
Especificaciones técnicas
La siguiente tabla resume las especificaciones técnicas de la estación meteorológica con LilyGO TTGO T5-4.7 E-Paper:
| MCU | ESP32-S3-WROOM-1-N16R8 |
| Conectividad inalámbrica | Wi-fi Bluetooth V5.0 |
| Flash | 16MB |
| PSRAM | 8MB |
| Soporte para PCF8563 RTC | Detección de capacidad de batería |
| Driver IC | EDO47TC1 |
| Tamaño | 4.7 pulgadas |
| Niveles de gris | 16 |
| Resolución | 540 x 960 píxeles |
| Corriente en deep-sleep | ~170µA |
Los esquemas de la placa de pantalla se pueden encontrar en github repo.
Versiones
Ten en cuenta que existen al menos tres versiones diferentes del LilyGO TTGO T5-4.7 E-Paper. Hay una versión temprana con cinco botones y un soporte para batería 18650. Mira la foto a continuación:
No tengo esta versión y por lo tanto no puedo decirte si los ejemplos de código en este tutorial funcionarán para esta placa.
Sin embargo, tengo las placas de las dos versiones más nuevas V2.3 de 2021-06-10 y V2.4 de 2024-12-03. Probé el código para ambas placas y funciona. Ten en cuenta que estas placas tienen tres botones y no tienen soporte para batería. La foto a continuación muestra las dos placas con sus números de versión visibles en la parte trasera:
Instalación del núcleo ESP32
El LilyGO TTGO T5-4.7 usa un ESP32 y necesitamos instalar una versión específica (2.017) del núcleo ESP32. Comienza abriendo el diálogo de Preferencias seleccionando “Preferences…” en el menú “File”. Esto abrirá el diálogo de Preferencias mostrado abajo.
En la pestaña Settings encontrarás un cuadro de edición al final del diálogo etiquetado “Additional boards manager URLs“:
En este campo copia la siguiente URL:
https://espressif.github.io/arduino-esp32/package_esp32_dev_index.json
Esto permitirá que el IDE de Arduino sepa dónde encontrar las librerías del núcleo ESP32. Luego instalaremos las placas ESP32 usando el Gestor de Placas.
Abre el Gestor de Placas vía «Tools -> Boards -> Board Manager». Verás el Gestor de Placas en la barra lateral izquierda. Escribe «ESP32» en el campo de búsqueda arriba y deberías ver dos tipos de placas ESP32; las «Arduino ESP32 Boards» y las placas «esp32 por Espressif». Queremos las librerías «esp32 por Espressif».
En el menú desplegable para esp32 selecciona la versión 2.0.17 y luego pulsa el botón INSTALL. Tras una instalación exitosa, deberías ver la siguiente imagen:
Otras versiones (más antiguas) del núcleo ESP32 probablemente funcionen también, pero no lo he probado. Lo que no funciona por ahora son las versiones más nuevas 3.x.
Instalación de librerías
Luego necesitamos instalar librerías específicas y versiones concretas. Primero haz clic en este EPD47 Library enlace de librería y descarga el archivo «EPD47-master.zip».
Descomprime el archivo ZIP para extraer su contenido. Deberías ver los siguientes archivos en una carpeta descomprimida llamada «EPD47-master»:
Necesitamos copiar la carpeta «EPD47-master» dentro de la carpeta «libraries» del IDE de Arduino. En Windows, la carpeta «libraries» suele estar ubicada en:
C:\Users\<username>\OneDrive\Documents\Arduino\libraries
Como esta carpeta ya contiene librerías instaladas, recomiendo renombrarla temporalmente, por ejemplo a «_libraries», y crear una nueva carpeta llamada «libraries». Así evitas conflictos con las librerías ya instaladas y no las pierdes. Luego puedes revertir fácilmente este cambio. La imagen abajo muestra cómo debería verse tu carpeta «Arduino» con las librerías:
Luego copiamos la carpeta «EPD47-master» dentro de la nueva carpeta «libraries» como se muestra abajo:
Finalmente, necesitamos instalar la versión 6.19.0 de la librería Arduinojson por Benoit Blanchon. Abre el LIBRARY MANAGER, escribe «arduinojson» en la barra de búsqueda e instala la librería. Tras una instalación exitosa deberías ver la siguiente imagen:
Si luego miras de nuevo en la carpeta de librerías, ahora encontrarás la librería EPD47-master y la librería ArduinoJson:
Placa ESP32-S3 y configuración
El LilyGO TTGO T5-4.7 E-Paper usa un ESP32-S3, por lo que seleccionamos la placa «ESP32S3 Dev Module». Para ello, haz clic en el menú desplegable y luego en «Select other board and port…»:
Esto abrirá un diálogo donde puedes escribir «esp32s3 dev» en la barra de búsqueda. Verás la placa «ESP32S3 Dev Module» bajo Boards. Haz clic en ella y en el puerto COM para activarla y luego pulsa OK:
Ten en cuenta que necesitas conectar la placa mediante el cable USB a tu ordenador antes de poder seleccionar un puerto COM.
Configuración de herramientas
Antes de poder programar la placa, necesitarás ajustar la configuración. Ve a «Tools» y selecciona las configuraciones mostradas abajo:
Importante son «USB CDC On Boot: Enable» para permitir comunicación serial con la placa, «Flash Size : 16MB(128Mb)», «Partition Scheme: 16M Flash(3M APP/9.9MB FATFS)», y «PSRAM: OPI PSRAM» para configurar la memoria. Las otras configuraciones por defecto deberían estar bien tal como están.
Subida
Normalmente, ahora puedes simplemente subir código vía el IDE de Arduino y la placa cambiará automáticamente a modo de subida. Sin embargo, si la placa está en deep-sleep o atrapada en un bucle de crash, puedes usar la siguiente secuencia para forzarla a modo de subida:
- Mantén presionado el botón BOOT(IO0)
- Mientras sigues presionando BOOT(IO0), presiona RST
- Suelta RST
- Suelta el botón BOOT(IO0)
Ejemplo de código: Botón
En este primer ejemplo de código solo verificamos que podemos programar la placa, detectar la pulsación de un botón y que la comunicación serial funciona:
#define BTN 21
void setup() {
Serial.begin(112500);
pinMode(BTN, INPUT);
Serial.println("running...");
}
void loop() {
if (!digitalRead(BTN)) {
Serial.println("pressed");
delay(100);
}
}
Comenzamos definiendo el pin GPIO 21 para el botón etiquetado SENSOP_VN en la placa.
#define BTN 21
Este es el único botón que podemos usar para entrada de usuario. Es el botón junto a la ranura para tarjeta SD:
En la función setup iniciamos la comunicación serial, declaramos el pin del botón como entrada e imprimimos «running…» en el monitor serial. El botón está cableado internamente con una resistencia pullup, lo que significa que no necesitamos habilitar pullups al configurar el modo del pin.
void setup() {
Serial.begin(112500);
pinMode(BTN, INPUT);
Serial.println("running...");
}
En la función loop leemos el estado actual del botón y si el valor devuelto es falso, sabemos que el botón está presionado e imprimimos el texto «pressed» en el monitor serial.
void loop() {
if (!digitalRead(BTN)) {
Serial.println("pressed");
delay(100);
}
}
Deberías probar este código primero para asegurarte de que puedes programar la placa y ver la salida serial. Si tienes problemas, asegúrate de que la configuración de herramientas sea correcta.
Ejemplo de código: Pantalla
El segundo ejemplo de código muestra cómo controlar la pantalla de papel electrónico. Dibujaremos un círculo y escribiremos el texto «Makerguides» en la pantalla:
Echa un vistazo rápido al código completo primero y luego profundizaremos en sus detalles:
#include "epd_driver.h"
#include "firasans.h"
uint8_t *framebuffer = NULL;
void create_framebuffer() {
size_t framesize = EPD_WIDTH * EPD_HEIGHT / 2;
framebuffer = (uint8_t *)ps_calloc(sizeof(uint8_t), framesize);
if (!framebuffer) {
Serial.println("alloc memory failed !!!");
return;
}
memset(framebuffer, 0xFF, framesize);
}
void init_display() {
create_framebuffer();
epd_init();
epd_poweron();
epd_clear();
}
void setup() {
Serial.begin(115200);
delay(1000);
init_display();
epd_draw_circle(EPD_WIDTH / 2, EPD_HEIGHT / 2, 150, 0, framebuffer);
const char *text= "Makerguides";
int cursor_x = 355;
int cursor_y = 270;
writeln((GFXfont *)&FiraSans, text, &cursor_x, &cursor_y, framebuffer);
epd_draw_grayscale_image(epd_full_screen(), framebuffer);
epd_poweroff_all();
}
void loop() {
}
Importaciones
Comenzamos incluyendo dos archivos de cabecera que proporcionan la API del controlador de pantalla y una definición de fuente. «epd_driver.h» expone funciones como inicialización, control de energía, dibujo de primitivas y volcado de un buffer de píxeles al panel, mientras que «firasans.h» proporciona los datos de glifos usados por la rutina de renderizado de texto.
#include "epd_driver.h" #include "firasans.h"
Estado global
Luego creamos un puntero global llamado framebuffer para almacenar la dirección de un buffer de píxeles asignado dinámicamente en memoria. Las funciones del controlador de pantalla en este sketch dibujan primero en este buffer, y solo después se envía todo el buffer al panel de papel electrónico para mostrarlo.
uint8_t *framebuffer = NULL;
create_framebuffer
La función create_framebuffer() es responsable de asignar RAM para la imagen en escala de grises que se mostrará. La idea clave es que el panel de papel electrónico espera una representación empaquetada, y la expresión EPD_WIDTH * EPD_HEIGHT / 2 refleja cuántos bytes se necesitan cuando cada píxel usa 4 bits (medio byte). Con escala de grises de 4 bits, se pueden almacenar dos píxeles por byte, por eso el total de píxeles se divide por dos.
Después de calcular el tamaño, la función usa ps_calloc para asignar y poner a cero la memoria. En objetivos tipo ESP32, este asignador se usa típicamente para colocar buffers grandes en PSRAM cuando está disponible, lo cual es importante porque un buffer de escala de grises de cuadro completo puede ser demasiado grande para la RAM interna. Si la asignación falla, la función imprime un mensaje diagnóstico en la consola serial y retorna temprano.
Finalmente, el buffer se llena con 0xFF. En muchos formatos de buffer de papel electrónico, 0xFF corresponde a “blanco” o el valor más claro de escala de grises en todo el buffer, así que este paso crea efectivamente un lienzo blanco limpio antes de que ocurra cualquier dibujo.
void create_framebuffer() {
size_t framesize = EPD_WIDTH * EPD_HEIGHT / 2;
framebuffer = (uint8_t *)ps_calloc(sizeof(uint8_t), framesize);
if (!framebuffer) {
Serial.println("alloc memory failed !!!");
return;
}
memset(framebuffer, 0xFF, framesize);
}
init_display
La función init_display() centraliza la secuencia de arranque para el hardware de papel electrónico y asegura que el buffer de cuadro exista antes de hacer llamadas de dibujo. Primero llama a create_framebuffer() para que las funciones de dibujo posteriores tengan un destino válido.
La llamada a epd_init() típicamente inicializa el controlador de pantalla, configura GPIO/SPI y prepara el estado interno del controlador. epd_poweron() habilita las líneas de alimentación del panel y pone el hardware en estado operativo. Y epd_clear() limpia el panel, lo cual es útil en papel electrónico porque el contenido antiguo puede persistir si el panel no se actualiza explícitamente.
void init_display() {
create_framebuffer();
epd_init();
epd_poweron();
epd_clear();
}
setup
La función setup() se ejecuta una vez al arrancar y realiza todo el trabajo en este sketch, por eso loop() está vacío. Comenzamos inicializando el puerto serial a 115200 baudios para permitir salida de depuración. Luego esperamos brevemente para asegurar que la conexión serial esté estable antes de continuar. Después, llamamos a init_display() para asignar el buffer de cuadro y encender y limpiar el panel.
void setup() {
Serial.begin(115200);
delay(1000);
init_display();
Tras la inicialización, dibujamos un círculo en el buffer de cuadro. El círculo está centrado en la pantalla usando la mitad del ancho y alto de la pantalla. El radio es 150, y el valor de color 0 se pasa como nivel de escala de grises. En convenciones típicas de escala de grises de 4 bits usadas por muchos controladores de papel electrónico, valores numéricos bajos suelen mapear a píxeles más oscuros, así que 0 se usa comúnmente para negro. El argumento final es framebuffer, que hace explícito que la operación de dibujo modifica el buffer de memoria en lugar de actualizar la pantalla inmediatamente.
epd_draw_circle(EPD_WIDTH / 2, EPD_HEIGHT / 2, 150, 0, framebuffer);
Luego preparamos una cadena C para renderizar y configuramos las coordenadas del cursor. La llamada a writeln() dibuja la cadena usando la fuente FiraSans en el buffer de cuadro en la posición inicial especificada.
const char *text= "Makerguides"; int cursor_x = 355; int cursor_y = 270; writeln((GFXfont *)&FiraSans, text, &cursor_x, &cursor_y, framebuffer);
Una vez que el círculo y el texto están dibujados en RAM, el sketch realiza la actualización real de la pantalla. La llamada a epd_draw_grayscale_image() envía el buffer a la pantalla. El primer argumento, epd_full_screen(), indica que la región de actualización es toda la pantalla en lugar de un sub-rectángulo, lo que coincide con el hecho de que el sketch preparó un buffer de cuadro completo. Finalmente, epd_poweroff_all() apaga la alimentación del papel electrónico, ya que este puede mantener la imagen sin energía una vez que la actualización está completa.
epd_draw_grayscale_image(epd_full_screen(), framebuffer); epd_poweroff_all(); }
loop
La función loop() está vacía porque el sketch está diseñado como un renderizado único. El dispositivo se inicializa, dibuja en el buffer, actualiza la pantalla una vez, apaga el panel y luego no hace nada más. Este patrón es típico para proyectos de papel electrónico alimentados por batería que se despiertan, actualizan contenido y vuelven a deep-sleep.
Más ejemplos
Para más ejemplos, por ejemplo cómo dibujar líneas, rectángulos e imágenes en escala de grises, consulta la carpeta bajo Xinyuan-LilyGO/LilyGo-EPD47/tree/esp32s3/examples.
Ejemplo de código: Estación meteorológica
En este último ejemplo aprenderás cómo ejecutar una estación meteorológica en el LilyGO TTGO T5-4.7 E-Paper. Los datos meteorológicos se reciben por internet desde el servicio OpenWeatherMap, que es gratuito pero necesitarás registrarte – más sobre eso después.
El código original que uso aquí es de David Bird de 2021 y varias versiones de este código se pueden encontrar en Xinyuan-LilyGO/LilyGo-EPD47/tree/esp32s3, Xinyuan-LilyGO/LilyGo-EPD-4-7-OWM-Weather-Display y DzikuVx/LilyGo-EPD-4-7-OWM-Weather-Display, por ejemplo. Sin embargo, ninguno de esos ejemplos funcionaba bien en mi LilyGO TTGO T5-4.7 E-Paper. Por eso hice algunas modificaciones.
Modificaciones
Primero, corregí algunos problemas con el diseño de los datos meteorológicos mostrados. Si miras la siguiente pantalla creada por el código original, verás que el texto de las temperaturas no está bien alineado:
Así que moví un poco los elementos de texto para mejorar el diseño:
También integré la imagen de la luna y los iconos de puesta y salida del sol del DzikuVx/LilyGo-EPD-4-7-OWM-Weather-Display en el código Xinyuan-LilyGO/LilyGo-EPD-4-7-OWM-Weather-Display.
Carga de batería
Luego noté que la pantalla no funciona ni muestra el icono de carga de batería cuando se alimenta con batería. Esto es porque 1) el código original bloquea hasta que se establece la comunicación serial, lo que no ocurre sin conexión USB a un ordenador:
Serial.begin(115200);
while (!Serial) ;
El código while (!Serial) debe ser eliminado y reemplazado por un breve retardo, por ejemplo delay(1000).
2) El código original lee el voltaje de la batería desde el pin 36, pero en mis pantallas encontré que el voltaje de batería se mide en el pin 14:
float voltage = analogRead(14) / 4096.0 * 6.566 * (vref / 1000.0);
Con estos cambios puedes alimentar tu LilyGO TTGO T5-4.7 E-Paper con batería y el icono de batería te indicará cuánta carga queda.
Ubicación de la ciudad
El código original usa el nombre de una ciudad para obtener la información meteorológica de esa ubicación. Sin embargo, el servicio OpenWeatherMap también permite obtener datos meteorológicos actuales para una ubicación dada por su latitud y longitud:
https://api.openweathermap.org/data/2.5/weather?lat={lat}&lon={lon}&appid={API key}
Potencialmente, esto es más preciso y no tienes que usar el nombre específico de ciudad reconocido por OpenWeatherMap. Encontrar la latitud y longitud de tu ubicación es fácil. Solo ve a Google Maps y haz clic derecho. Aparecerá un diálogo emergente con los números de latitud y longitud en la parte superior. Mira la siguiente captura de pantalla:
Conexión USB
Finalmente, el código original actualiza los datos meteorológicos en la pantalla una vez cada hora y entra en modo deep-sleep entre actualizaciones para preservar la batería. Esto es genial, pero dificulta los cambios de código, ya que la conexión USB se pierde en deep-sleep y no puedes flashear la placa.
Necesitas resetear la placa y cronometrar para que la subida comience mientras la conexión USB aún está activa justo después del reset. Mira la sección de Subida arriba. Como esto es difícil, añadí código que asegura que NO se entre en deep-sleep cuando se presiona el botón programable por el usuario SENSOP_VN:
if(digitalRead(21)) { // SENSOP_VN button NOT pressed
BeginSleep();
}
Esto significa que si quieres flashear nuevo código solo presiona y mantén SENSOP_VN mientras flasheas. La placa no entrará en deep-sleep tras el reset y la conexión USB permanecerá activa. Una vez flasheada, solo presiona RST de nuevo para reiniciar la placa con deep-sleep activo.
Open weather map
El código usa el servicio gratuito OpenWeatherMap para recibir datos meteorológicos de internet. Sin embargo, antes de usar cualquiera de las APIs de OpenWeather necesitas una clave API y para eso necesitas una cuenta. Para crear una cuenta gratuita ve a sign-up page e ingresa tus datos allí.
Después ve a la página de creación de api-key y crea una clave API. La clave API es esa cadena larga «sdfd87fakeby6apikeysf4z» que ves en la captura de pantalla abajo. Tu clave será diferente.
Una vez que tengas tu clave API (y la latitud y longitud de tu ubicación), puedes probarla en tu navegador. Introduce la siguiente URL, con tu clave API, en tu navegador:
https://api.openweathermap.org/data/2.5/weather?lat=44.34&lon=10.99&appid={API key}
Ten en cuenta que el navegador Chrome tiene un botón Pretty Print que puedes pulsar y mostrará los datos meteorológicos recuperados en JSON formateado agradablemente:
Así puedes probar tu clave API y tus valores de latitud y longitud. Si necesitas más ayuda, echa un vistazo a nuestro tutorial: Simple ESP32 Internet Weather Station.
Descargar código y configurar parámetros
Una vez que hayas verificado tu clave API, puedes descargar el código para la estación meteorológica como un archivo ZIP: weather_lilygo_t5_epd.zip . Descomprímelo y abre el archivo «weather_lilygo_t5_epd.ino» en la carpeta «weather_lilygo_t5_epd» en tu IDE de Arduino.
Como último paso necesitas configurar las credenciales Wi-Fi y los parámetros de datos meteorológicos. Haz clic en la pestaña «owm_credentials.h» y configura tu SSID, contraseña, clave API y la información de ubicación:
Dependiendo de tu ubicación también puedes querer cambiar los parámetros de idioma, hemisferio, unidades y zona horaria.
También hay código de ejemplo sobre cómo configurar la estación meteorológica vía una interfaz web: Xinyuan-LilyGO/LilyGo-EPD-4-7-OWM-Weather-Display/tree/web, si prefieres eso en lugar de codificar los ajustes directamente.
Una vez que hayas ajustado la configuración, flashea el código a tu placa LilyGO TTGO T5-4.7 y tras un breve parpadeo deberías ver los datos meteorológicos aparecer en la pantalla:
Conexión de batería 18650
La placa LilyGO TTGO T5-4.7 E-Paper viene con un conector y circuito de carga para una batería LiPo externa. Conecté una batería recargable 18650. También puedes usar una batería LiPo más pequeña (plana), pero suelen ser más caras o tener menos capacidad. La foto abajo muestra cómo conectar la batería 18650:
Tiempo de funcionamiento
Una batería típica 18650 tiene una capacidad de 2300 a 3600mAh y la corriente pico que el ESP32 consume usando Wi-Fi puede llegar a 400mA. La corriente en deep-sleep de la placa LilyGO TTGO T5-4.7 es aparentemente alrededor de 170µA, pero no la medí.
Si usamos una 18650 con 3300mAh, y activamos el Wi-Fi por un segundo una vez cada hora para descargar los datos meteorológicos, obtenemos un tiempo estimado de funcionamiento de más de un año con una sola carga.
Aquí está el cálculo: con una corriente promedio de 400mA × 1s / 3600s = 0.111mA para Wi-Fi y una corriente en deep-sleep de 0.17mA, la corriente promedio total es 0.111mA + 0.17mA = 0.281mA por segundo. Asumiendo una batería de 3300mAh, el tiempo estimado de funcionamiento es entonces 3300mAh / 0.281mA ≈ 11744h ≈ 1.34 años.
Conclusiones
En este tutorial aprendiste cómo construir una estación meteorológica con la pantalla LilyGO TTGO T5-4.7 E-Paper. Para más información sobre el LilyGO TTGO T5, echa un vistazo a Wiki y a los ejemplos de código en Xinyuan-LilyGO/LilyGo-EPD47/tree/esp32s3/examples.
La documentación menciona que la pantalla no debe ser actualizada parcialmente durante mucho tiempo, ya que dejará imágenes residuales irreversibles. Así que ten cuidado al construir aplicaciones que usen Partial Refresh.
Para más ejemplos sobre pantallas de papel electrónico, echa un vistazo a nuestros Weather Station on e-Paper Display, Simple ESP32 Internet Weather Station, Temperature Plotter on e-Paper Display, Monthly Calendar on E-Paper Display y los tutoriales Digital Clock on e-Paper Display.
Si tienes alguna pregunta, no dudes en dejarla en la sección de comentarios.
¡Feliz bricolaje! 😉
