Micropython: Usando la placa TTGO T-Display de Lilygo. Parte 1

La placa TTGO T-Display incluye un ESP32 y un display a colores, lo que la transforma en una opción muy interesante para distintos proyectos. Su programación en Micropython tiene algunas características especiales que detallare en este artículo.

Descripción

Esta placa, una entre los varios modelos comercializados por la empresa china Lilygo, incluye un ESP32 con 4 MBytes de memoria Flash y todas sus características junto a un display RGB de 1.14 pulgadas de 135 x 240 puntos con un driver ST7789V, un cargador de baterías de Litio con su correspondiente conector, dos botones de uso general, un pulsador de RESET y un conector USB-C para programación y alimentación.

También incluye dos conectores de 12 pines a ambos lados con distintas señales disponibles para integrar la placa con un circuito externo. La siguiente imagen muestra la distribución de pines del modelo 1.1, que es el que emplearé en este artículo.

El display está conectado al ESP32 a través de 6 pines. Cuatro de ellos están relacionados con la interface SPI: MOSI (Entrada de datos al display. Pin 19 ), SCLK (Señal de Clock. Pin 18), CS (Habilitación del display. Pin 5) y DC (Data/Command. Pin 16). Los otros dos son de control: RST (Reset del Display. Pin 23) y BL (Encendido del backlight. Pin 4).

Librerías y firmware

La placa contiene un ESP32 así que la opción natural sería instalar el último firmware de Micropython para ese módulo, usando el método preferido para grabarlo en la Flash y luego buscar una librería o módulo para controlar el display. Lo cierto es que no hay muchas librerías disponibles. Casi que la única es la de Ivan Belokobylskiy (devbis) que se puede descargar desde este repositorio. Esta librería está escrita en Micropython y se debe descargar y copiar a la memoria de la placa para importarla luego en nuestro código, como hacemos habitualmente.

Sin embargo, al estar escrita en Micropython y como el manejo del display muchas veces supone mover muchos datos para mostrar una imagen, esta librería puede ser un poco lenta.

Si queremos que los gráficos se muevan con fluidez necesitamos mas velocidad, así que deberemos buscar otras opciones.

El mismo devbis nos ofrece otra librería mas optimizada escrita totalmente en C disponible en este repositorio. El inconveniente es que para usarla debemos compilar Micropython incluyendo la librería, lo que puede ser una operación complicada.

Otra opción es emplear un firmware personalizado. Un firmware personalizado (custom firmware) es una variación del firmware “oficial” de Micropython al que se le hacen modificaciones o agregados para adaptarlo a las características específicas de una placa o para agregar funciones que no se incluyeron en la versión oficial.

En el caso particular de la TTGO T-display tenemos al menos dos de estas versiones de firmware que soportan el LCD: La de loboris y la de russhughes. El firmware de loboris no sólo incluye soporte para el driver ST7789 del LCD sino también muchas otras funciones que no están presentes en la versión oficial de Micropython. Lamentablemente es un desarrollo que parece abandonado porque no muestra actualizaciones en los últimos 3 años. Por otro lado, el firmware de russhughes si se muestra activo y está mas enfocado al uso del LCD y si bien está basado en el trabajo original de devbis, incluye otras mejoras y funciones, razones por las que será el que usaremos a continuación.

Instalando el firmware

El firmware que utilizaremos se encuentra en este repositorio. En realidad hay varias versiones, para distintas placas. El que nos interesa está en la carpeta st7789_mpy/firmware/T-DISPLAY/ Pueden navegar hasta esa carpeta y descargar el archivo firmware.bin o descargar todo con el botón Code – Download ZIP y luego buscar el archivo dentro del ZIP ya descargado.

Con el archivo ya descargado, lo grabamos en la placa. En este caso usaré Thonny:

Si todo funciona correctamente, el firmware debe arrancar en la placa:

Llegados a este punto ya tenemos la placa preparada para escribir nuestros programas utilizando el LCD.

Programando la placa

Con el firmware funcionando vamos a escribir un primer programa de ejemplo. Como siempre, lo primero que debemos hacer es importar los módulos que necesitemos, en este caso serán machine por la interfaz SPI y st7789 para el LCD.

from machine import SPI
import st7789

Luego debemos crear una instancia del puerto SPI con el siguiente formato:

spi = SPI(device, baudrate, polarity, phase, sck, mosi)

Donde:
device: Dispositivo SPI (para esta placa debe ser el 1)

baudrate: Velocidad (máximo 40 MHz)

polarity: Comportamiento de la señal SCK (Debe ser 1 para el LCD)

phase: Comportamiento de la señal SCK (Debe ser 1 para el LCD)

sck_pin: Numero de pin de la señal SCK. (Debe ser 18)

mosi_pin: Numero de pin de la señal MOSI (Debe ser 19)

Con estos datos, que están condicionados por las conexiones y funcionamiento del LCD, el código quedaría de la siguiente forma:

spi = SPI(1, baudrate=30000000, polarity=1, phase=1, sck=machine.Pin(18), mosi=machine.Pin(19))

Luego debemos crear una instancia de la clase del display (ST7789) usando un constructor con el siguiente formato:

display = st7789.ST7789(spi, ancho, alto, reset_pin, cs_pin, dc_pin, backlight_pin, rotation)

Donde:

spi: Objeto SPI a utilizar por el LCD

alto: Alto del display en pixeles (135)

ancho: Ancho del display en pixeles (240)

reset_pin: Numero del pin de RESET (Debe ser 23)

cs_pin: Número del pin CS (Debe ser 5)

dc_pin: Número del pin Data/Command (Debe ser 16)

backlight_pin: Número del pin para controla el BL (Debe ser 4)

rotation: 0=0º, 1=90º, 2=180º, 3=270º

Teniendo en cuenta esto, usaremos los siguientes valores:

display = st7789.ST7789(
    spi, 
    135,
    240,
    reset=Pin(23, Pin.OUT),
    cs=Pin(5, Pin.OUT),
    dc=Pin(16, Pin.OUT),
    backlight=Pin(4, Pin.OUT),
    rotation=0)

Una vez creados estos objetos podemos inicializar el display con el método init. Veamos como queda todo junto:

from machine import Pin, SPI
import st7789
spi = SPI(1, baudrate=30000000, polarity=1, phase=1, sck=Pin(18), mosi=Pin(19))
display = st7789.ST7789(
    spi, 
    135,
    240,
    reset=Pin(23, Pin.OUT),
    cs=Pin(5, Pin.OUT),
    dc=Pin(16, Pin.OUT),
    backlight=Pin(4, Pin.OUT),
    rotation=0)
display.init()

La notación RGB565

El driver soporta la notación denominada RGB565 para identificar los colores. Esta notación consiste en representar cada color con dos bytes (16 bits) en los que se almacenan la información de los componentes básicos Rojo (r), Verde (g) y Azul (b) en la siguiente forma: rrrrrggg:gggbbbbb

Si tenemos los valores de los tres componentes R, G, B de un color, podemos “empaquetarlos” en este formato empleando el método color565 (R,G,B) incluido en la librería.

También se pueden usar algunos valores predefinidos identificados como BLACK, BLUE, RED, GREEN, CYAN, MAGENTA, YELLOW, y WHITE

Para terminar este artículo veamos un ejemplo que muestra puntos de colores aleatorios en posiciones también aleatorias:

from machine import Pin, SPI
import st7789
from time import sleep_ms
from random import randint
spi = SPI(1, baudrate=30000000, polarity=1, phase=1, sck=Pin(18), mosi=Pin(19))
display = st7789.ST7789(
    spi, 
    135,
    240,
    reset=Pin(23, Pin.OUT),
    cs=Pin(5, Pin.OUT),
    dc=Pin(16, Pin.OUT),
    backlight=Pin(4, Pin.OUT),
    rotation=0)
display.init ()
while (True):
    posx=randint(0,135)
    posy=randint(0,240)
    display.pixel(posx,posy,st7789.color565(randint (0,255),randint (0,255),randint (0,255)))
    sleep_ms (10)

Conclusión

Vimos en este artículo, el primero dedicado a la placa TTGO T-Display las características generales de la misma y analizamos distintas opciones para programarla en Micropython. De entre estas opciones seleccionamos un firmware personalizado y vimos como instalarlo en la placa. Finalmente, analizamos los métodos para crear los objetos necesarios para comenzar a emplear el display y como inicializarlo.

En el próximo artículo veremos los numerosos métodos que incorpora este firmware entre sus librerías para mostrar distintos objetos gráficos como líneas, figuras e imágenes.

Navegación de la serie

Micropython: Usando la placa TTGO T-Display de Lilygo. Parte 2 >>