Seguramente tengas alguno de estos viejos modelos de pantalla que tienen la configuración en formato "sombrero" para los microcontroladores Arduino UNO .
Un display TFT 3,4" de 8 bits conectado en paralelo con el driver ILI9488 y táctil resistivo.
Esta manera de conectar los pines con 8bits más similitudes con un LCD 16x2 que con las modernas pantallas SPI que se manejan con menos hilos de control.
Es decir esta pantalla necesita 8 lineas para la transferencia de datos y otras 5 para la conexiones que manejan la pantalla TFT.
Librería TFT_eSPI
Está diseñada desde cero para exprimir al máximo el hardware, utilizando SPI con DMA, transacciones asíncronas y manipulación directa de registros.
Su configuración manual permite un rendimiento máximo del display.
A diferencia de librerías "plug-and-play", requiere que editemos un archivo de configuración "User_Setup.h" para especificar exactamente tu hardware: tipo de controlador, pines GPIO, frecuencia SPI, etc.
También dispone de configuraciones especificas según el tipo de microcontrolador ubicadas en la carpeta "/Users_Setups".
Es, sin duda, la librería más rápida para pantallas TFT con microcontroladores de tipo ESP32/ESP8266.
El uso directo de SPI DMA y transacciones optimizadas hace que la diferencia sea abismal frente a alternativas como Adafruit_GFX.
Aunque parece complejo, el sistema de archivos de configuración permite afinar hasta el último detalle de tu pantalla específica.
Dispone de un soporte masivo de controladores ya que es compatible con más de 50 controladores TFT diferentes. Desde los comunes ILI9341, ST7789, hasta modelos más exóticos.
Características Avanzadas de TFT_eSPI
- Sprites en memoria para animaciones fluidas
- Fuentes anti-aliadas con calidad profesional
- Rotaciones eficientes de pantalla
- Operaciones de dibujo aceleradas por hardware
ESP32 y TFT ILI9488 paralelo
La conexión de la pantalla con el ESP32 hay que seleccionar las lineas que se describen en la siguiente tabla:
| Señal TFT | GPIO ESP32 |
|---|---|
| LCD_RST | GPIO 15 |
| LCD_CS | GPIO 2 |
| LCD_RS (DC) | GPIO 32 |
| LCD_WR | GPIO 33 |
| LCD_RD | GPIO 4 |
| LCD_D0 | GPIO 12 |
| LCD_D1 | GPIO 13 |
| LCD_D2 | GPIO 26 |
| LCD_D3 | GPIO 25 |
| LCD_D4 | GPIO 17 |
| LCD_D5 | GPIO 16 |
| LCD_D6 | GPIO 27 |
| LCD_D7 | GPIO 14 |
Configuración de la librería TFT_eSPI
Hay que saber que esta librería tiene 2 archivos principales de configuración:
- Setup70d_ILI9488_S3_Parallel.h
Es el archivo de configuración ubicado en la carpeta "/Users_Setups" donde pondremos los pines personalizados tanto del ESP32 como de la pantalla con el controlador ILI9488 que hemos dispuesto en la tabla anterior:
#define USER_SETUP_ID 146 #define TFT_PARALLEL_8_BIT //#define ILI9341_DRIVER //#define ST7796_DRIVER #define ILI9488_DRIVER // ESP32 S3 pins used for the parallel interface TFT #define TFT_CS 2 #define TFT_DC 32 // Data Command control pin - must use a GPIO in the range 0-31 #define TFT_RST 15 #define TFT_WR 33 // Write strobe control pin - must use a GPIO in the range 0-31 #define TFT_RD 4 #define TFT_D0 12 // Must use GPIO in the range 0-31 for the data bus #define TFT_D1 13 // so a single register write sets/clears all bits #define TFT_D2 26 #define TFT_D3 25 #define TFT_D4 17 #define TFT_D5 16 #define TFT_D6 27 #define TFT_D7 14 #define LOAD_GLCD #define LOAD_FONT2 #define LOAD_FONT4 #define LOAD_FONT6 #define LOAD_FONT7 #define LOAD_FONT8 #define LOAD_GFXFF #define SMOOTH_FONT - User_Setup_Select.h
Este es el archivo que maneja las configuraciones de la librería TFT_eSPI y que hará referencia al archivo "Setup70d_ILI9488_S3_Parallel.h" que acabamos de configurar.
tenemos que comentar la linea donde esta la referencia al archivo "User_Setup.h":// Archivo User_Setup_Select.h // #include <User_Setup.h> // Default setup is root library folder #include <User_Setups/Setup70d_ILI9488_S3_Parallel.h> // Setup file for ESP32 S3 with SPI ILI9488
Recuerda que una vez configuradas las conexiones correctamente, el rendimiento es óptimo porque la librería está compilada exactamente para tu hardware.
Ahora ya podemos probar el ejemplo que proporciona la misma librería como puede ser "Demo_3D_Cube.ino"
IMAGEN DEL CUBO 3DProblemas con colores en pantalla TFT
Si se tienes problemas con los colores inserta esta línea en el setup() después de haber inicializado la pantalla (tft.begin())
tft.invertDisplay(true);
Con este comando se invierten los colores que se muestran en la pantalla TFT.
Otro problema que podemos encontrar es que no compile bien la librería, prueba a cambiar la versión de la placa antes de compilar. La versión de placa que estamos utilizando es la versión 2.0.17 de ESPressif Systems.
Librería LittleFS.
Sobre LittleFS ya hemos hablado antes en este blog pero enfocado al microcontroladores ESP8266.
Esta vez la usaremos para subir los iconos que se mostrarán posteriormente en la pantalla en formato .png.
Subir archivos a la memoria flash del ESP32 con Arduino IDE 2
Subiremos los archivos siguiendo unos pocos pasos:
- Primero cerramos el IDE 2 de Arduino.
- Después necesitamos descargar el archivo: arduino-littlefs-upload-1.x.x.vsix desde GitHub
- Ahora nos situamos en la carpeta .ArduinoIDE y creamos un directorio llamado "plugins". Rcuerda que esta carpeta .ArduinoIDE puede estar oculta.
- Finalmente solo tenemos que compiar el archivo "arduino-littlefs-upload-1.x.x.vsix" a la carpeta ".ArduinoIDE/plugins"
Abrimos el IDE de Arduino y pulsamos "Ctrl + Mayus + P" para buscar en la barra "upload", tal y como se muestra en la imagen:
Al pulsar sobre la opción "Upload LittleFS to Pico/ESP8266/ESP32" se copiarán todos los archivos que estén en la carpeta "data" dentro de la carpeta del sketch a la memoria flash del dispositivo ESP32 DOIT DEVKIT V1.
La memoria flash disponible es de 4MB, suficiente para unos cuantos archivos con formato .png con un tamaño reducido.
Librería PNGdec
Esta librería fue una gran sorpresa, de uso sencillo y muy rápida pese a ser una pantalla tft con conexión en paralelo. Puedes encontrar la librería PNGdec en GitHub.
Como siempre no estaría bien que algo funcionará a la primera así que el una vez abierto el ejemplo de la librería llamado LittleFS_PNG.ino podemos compilar y nos aparecerá el siguiente error:
Compilation error:
invalid conversion from 'void (*)(PNGDRAW*)' {aka 'void (*)(png_draw_tag*)'}
to 'int (*)(PNGDRAW*)' {aka 'int (*)(png_draw_tag*)'} [-fpermissive]
Para solucionar este error solo hay que buscar la función "int pngDraw(PNGDRAW *pDraw)" y añadir "return 1; al final tal y como se muestra en el siguiente fragmento de código:
int pngDraw(PNGDRAW *pDraw)
{
uint16_t lineBuffer[MAX_IMAGE_WIDTH];
png.getLineAsRGB565(pDraw, lineBuffer, PNG_RGB565_BIG_ENDIAN, 0xffffffff);
tft.pushImage(xImage, yImage + pDraw->y, pDraw->iWidth, 1, lineBuffer);
return 1;
}
Librería Adafruit TouchScreen
Esta ha sido la parte con la que más tiempo he perdido. Todo se ha complicado por no encontrar los pines que corresponden a XP y XM debido a que cada panel tiene una configuración de pines diferente.
También por que uno de los cabnles estaba en mal estado y, aunque permitia el encendido de la pantalla, no hací un buen contacto al hacer la lectura analógica.
Puedes descargar la librería Adafruit TouchScreen en GitHub.
La solución la encontré gracias a un Arduino UNO junto con la librería MCUFRIEND_kbv y el ejemplo: "TouchScreen_Calibr_native".
Con la pantalla en el Arduino UNO, cargamos el sketch TouchScreen_Calibr_native y esperamos a la salida serial
TouchScreen.h GFX Calibration
Making all control and bus pins INPUT_PULLUP
Typical 30k Analog pullup with corresponding pin
would read low when digital is written LOW
e.g. reads ~25 for 300R X direction
e.g. reads ~30 for 500R Y direction
Testing : (A2, D8) = 35
Testing : (A3, D9) = 25
ID = 0x9488
Nos interesan las lineas "Testing" con la que podemos realizar la siguiente conversión:
| Arduino UNO | TFT | ESP32 | Touch |
|---|---|---|---|
| A2 | RS | GPIO 32 |
YP |
| A3 | CS | GPIO 2 |
XM |
| D8 | D0 | GPIO 12 |
YM |
| D9 | D1 | GPIO 13 |
XP |
Esto datos los pasaremos al programa principal en el apartado "Configuración TouchScreen":
// Configuración TouchScreen
#define YP 32 // Tiene que ser un pin analógico, usa la notación "ADC"
#define XM 2 // Tiene que ser un pin analógico, usa la notación "ADC"
#define YM 12
#define XP 13
Ahora con la certeza de que el panel resistivo funcionaba, sustituimos los 4 cables que le corresponden al panel y volvemos a probar con el ESP32
Esta configuración puede cambiar
Otro de los problemas que surgió fue la lectura de la pulsación Z que corresponde a la variable "p.z" daba lecturas muy "extrañas" debido a la resolución de la lectura analógica del que dispone el ESP32 que es de 12bits frente a los 10bits que tiene, por ejemplo, el Arduino UNO.
| Arduino UNO | ESP32 | |
|---|---|---|
| Resolución ADC | 10 bits | 12 bits |
| Valores Posibles | 0 - 1023 (2¹⁰ = 1024) |
0 - 4095 (2¹² = 4096) |
Una vez tenemos este dato, vamos al archivo "TouchScreen.cpp" que estará en la carpeta de las librerías /Adafruit_TouchScreen y buscamos las siguientes lineas en la función "TSPoint TouchScreen::getPoint(void)" y las sustituimos por esta:
// Función: TSPoint TouchScreen::getPoint(void)
// rtouch /= 1024;
rtouch /= 4096;
y
// z = (1023 - (z2 - z1));
z = (4095 - (z2 - z1));
Y aquí es donde daba el fallo al leer la . Para esta pantalla solo hay que cambiar estos parámetros en la función "TSPoint TouchScreen::getPoint(void)", pero para otras también cambiamos todos los valores 1024 y 1023 por 4095 y 4096 de todas las funciones en las que aparezcan dichos valores.
Ahora sí, la pantalla táctil funciona perfectamente y lo podemos comprobar en el monitor serial
Hasta aquí la primera parte para la configuración de la pantalla TFT y conexión paralela de 8bits con un microcontrolador ESP32, este es un pequeño resumen de lo que hemos realizado hasta ahora:
- Configuración de la librería TFT_eSPI para pantalla de 8 bits.
- Repaso a la librería LittleFS y la instalación de LittleFS upload en el IDE de Arduino.
- Instalación de la librería PNGdec y la solución a posibles problemas.
- Por último la librería Adafruit_TouchScreen y su configuración para el panel resistivo junto con pruebas con MCUFRIEND_kbv
Configuración para la lectura de teclas
Ahora tenemos que configurar el sistema para poder leer los comandos que nos manda el ESP32. La conexión con el PC sera realizada con el Bluetooth que nos proporciona el mismo microcontrolador ESP32.
Una vez que se realice la conexión el sistema leerá los comandos seriales y realizará las pulsaciones del el teclado o la llamada al programa que hayamos designado a dicha aplicación.
Comunicación Bluetooth entre ESP32 y PC
Aquí entran en juego las dos partes, la del microcontrolador y la conexión bluetooth que dispongamos en el PC. Como nota, podemos cambiar la conexión Bluetooth por la conexión serial por USB, pero eso lo dejamos para una actualización.
Librería BluetoothSerial en ESP32
Esta ĺibrería es interna y la proporciona el mismo IDE de Arduino así que la tenemos disponible desde el primer momento. Si necesitas más información este es la documentación de la librería BluetoothSerial.h
#include "BluetoothSerial.h"
void setup()
{
SerialBT.begin("ESP32-ITB"); // Nombre del dispositivo Bluetooth
}
void loop()
{
// Programa principal
Lectura_Tecla_Pantalla()
}
void Lectura_Tecla_Pantalla()
{
SerialBT.println("ACK: COMANDO");
}
Ahora que ya hemos visto como se conectará el microcontrolador vamos con la parte del PC de la mano, por supuesto, del lenguaje de programación Python.
Programa en Python para lectura del bluetooth
Python es la navaja suiza de los lenguajes de programación y gracias a esta versatilidad nos proporciona todas las librerías necesarias para este proyecto.
Estas son las librerías Python que vamos a utilizar.
Librerías externas
- bluetooth
Sera la encargada de comunicarnos con el ESP32. La puedes encontrar en GitHub como Pybluez - keyboard
Esta es la librería encargada de transformar los datos seriales que proporciona el bluetooth a pulsaciones del teclado. Puedes consultar la librería keyboard de Boppreh en GitHub.
Librerías incluidas en Python
- sys
(System) Necesaria para interactuar con el intérprete de Python y el sistema como listar directorios o ejecutar comandos. Viene incluida con Python. - os
(Operating System) Interfaz con el sistema operativo: archivos, directorios, procesos. - subprocess
Ejecutar comandos externos y gestionar sus flujos de entrada/salida. Necesaria para la ejecución de los programas que designemos a las teclas. - time
Realiza las pausas necesarias para no saturar la recepción de datos.
Comunicación ESP32 Bluetooth PC
Para diferenciar entre los comandos que vamos a recibir y el comando que vamos a ejecutar los vamos a almacenar en un diccionario de la siguiente manera:
# Mapeo de teclas (lo que escribes → lo que se simula)
COMANDOS = {
'item1': 'inkscape',
'item2': 'audacity',
'item3': 'subl',
'item4': 'spectacle',
'item5': 'ctrl+z',
'item6': 'ctrl+x',
'item7': 'ctrl+c',
'item8': 'ctrl+v',
'save': 'ctrl+s',
'select all': 'ctrl+a',
'find': 'ctrl+f'
}
De esta manera podemos crear un diccionario con los atajos de teclado, comandos del sistema o aplicaciones del sistema. Así tenemos centralizados los comandos facilitando su modificación.
En la primera parte tenemos el Item que hemos seleccionado en el display. En la segunda parte del diccionario pondremos la aplicación o el atajo de teclado que queramos.
NOTA:
Depende del sistema que estes usando puede que el funcionamiento no sea el correcto. Para este ejemplo se ha utilizado una distribución basada en Debian.
Cargar ESP32 Macro keyborad en el inicio
Para cargar el programa para que se inicie al encender el ordenador tenemos que incluirlo en el crontab de usuario con el siguiente comando:
@reboot sleep 30 && sudo -u YOUR_USER /usr/bin/python3 /home/peyutron/PythonProjects/Comunicacion/Bluetooth/Bluetooth-HID-ESP32/main.py >> /home/YOUR_USER/esp32_cron.log 2>&1
Conclusión del proyecto
Hardware Especializado:
- Microcontrolador ESP32 con Bluetooth integrado.
- Pantalla TFT con interfaz táctil resistiva/capacitiva.
- Comunicación paralela 8 bits para control de pantalla.
Software de Control:
- TFT_eSPI - Librería optimizada para gráficos en ESP32.
- Protocolo Bluetooth RFCOMM - Comunicación serial inalámbrica.
- Sistema de comandos - Diccionario personalizable de acciones.
- Flexibilidad Total - Configuración ilimitada de comandos
Saludos!!!
Puedes visitar los siguiente enlaces relacionados con pantallas y Arduino:
