Lo que queremos
Este proyecto continúa el artículo Hacer que un control de videojuegos chino obedezca a un ESP32, que estableció una conexión inalámbrica confiable entre la tarjeta y su control. Los ojos se apoyan en ella. Esto es lo que esperamos de ellos:
- dos ojos vivos: la mirada se mueve sola, los párpados parpadean, la pupila respira un poco;
- expresiones: neutral, feliz, triste, enojado, sorprendido, dormido, receloso, un guiño, lágrimas, y lluvia sobre el vidrio con su limpiaparabrisas;
- el control al mando: los botones superiores para pasar de una expresión a otra, las palancas para dirigir la mirada, los gatillos para cerrar los párpados;
- el cableado del robot, y no un cableado de prueba: los dos ojos y la pantalla de información comparten el mismo bus;
- cifras para el robot final: lo que cuestan los ojos en procesador, en memoria y en tiempo de bus, medido aparte de lo que cuesta la conexión Bluetooth.
El último punto pesa más que los otros. El robot también tendrá que manejar cuatro motores, leer sus sensores y vigilar su batería, con el mismo chip. Unos ojos espectaculares que le roben tiempo de cálculo a los motores serían un mal negocio.
El hardware
La tarjeta es la misma que para el control: una ESP32-S31 Function-CoreBoard-1 de Espressif, la tarjeta de desarrollo que lleva el microcontrolador del robot. Una tarjeta de desarrollo es una pequeña tarjeta que vende el fabricante de un microcontrolador: lleva el chip, su alimentación, sus puertos USB y un conector que da acceso a sus pines, para escribir y probar un programa antes de que exista la tarjeta definitiva. Su microcontrolador, el ESP32-S31, tiene dos núcleos RISC-V a 320 MHz: dos procesadores completos en el mismo chip, capaces de trabajar al mismo tiempo. También tiene 512 KB de memoria RAM interna y, en esta tarjeta, 16 MB de PSRAM (una memoria RAM externa, más lenta pero mucho más grande). Estos dos detalles van a servir.
Se le conectan tres pantallas:
| Pantalla | Chip | Tamaño | Función |
|---|---|---|---|
| Pantalla de información | ST7789 | 1,9 pulgadas, 170 × 320 píxeles | el estado de la conexión, la expresión, las mediciones, las instrucciones |
| Ojo izquierdo | ST7735S | 1,44 pulgadas, 128 × 128 píxeles | el ojo |
| Ojo derecho | ST7735S | 1,44 pulgadas, 128 × 128 píxeles | el ojo |
Las tres hablan SPI, una conexión serial con reloj: la tarjeta envía sus órdenes y sus píxeles por un cable de datos, al ritmo de un cable de reloj. Los ojos del robot tendrán el mismo tamaño, 128 × 128 píxeles, con el mismo chip.
Las decisiones tomadas antes de escribir una línea
1. Las señales son comunes, salvo la selección. En el bus SPI, varias pantallas pueden compartir el reloj, los datos y el pin que distingue una orden de un píxel (DC). Cada una conserva su propio pin de selección (CS, chip select): la tarjeta pone en nivel bajo la selección de la pantalla a la que le habla, y solo esa pantalla escucha. El robot lleva el reparto más lejos: el reinicio (RES) y la retroiluminación (BLK) también son comunes. Así, tres pantallas caben en ocho pines del microcontrolador en lugar de dieciocho.
| Pin del módulo | Señal | Pin del ESP32 | ¿Común a las tres pantallas? |
|---|---|---|---|
| SCL | reloj SPI | IO42 | sí |
| SDA | datos SPI | IO43 | sí |
| DC | orden o píxel | IO46 | sí |
| RES | reinicio | IO48 | sí |
| BLK | retroiluminación | IO37 | sí |
| CS | selección del ojo izquierdo | IO44 | no |
| CS | selección del ojo derecho | IO45 | no |
| CS | selección de la pantalla de información | IO49 | no |
SCL y SDA son los nombres que los vendedores de módulos les dan al reloj y a los datos SPI; a pesar de los nombres, no es un bus I²C. Como el reinicio es común, se hace una sola vez, al arrancar, y luego cada pantalla se reinicializa con una orden que solo la afecta a ella. Como la retroiluminación es común, las tres pantallas se encienden y bajan su brillo juntas.
2. Primero dibujar en el computador. Antes de tocar el microcontrolador, dibujamos los ojos como un SVG animado: un archivo de imagen vectorial que también contiene un pequeño programa y que se anima solo en un navegador. El objetivo era elegir el dibujo: el estilo del ojo, las expresiones, la velocidad de los parpadeos. Cambiar una línea y recargar la página toma un segundo; recompilar y cargar un programa toma un minuto.
3. Un ojo realista, con pistas de circuito impreso. El estilo de partida es el de los ojos animados que popularizó Adafruit: un globo, un iris con textura, una pupila, unos párpados. Le agregamos expresiones y reemplazamos las venas rojas por pistas de cobre que giran a 45° y terminan en una vía. Es un robot; sus ojos bien pueden decirlo.
4. Calcular en lugar de guardar, y medir antes de decidir. La primera decisión del proyecto guardaba las imágenes de los ojos en la tarjeta microSD. Suponía imágenes. Cuando el dibujo se quedó con unos ojos que se mueven todo el tiempo, decidimos probar el cálculo y medirlo.
5. El Bluetooth en un núcleo, los ojos en el otro. Cada núcleo hace un solo oficio, y su carga se lee por separado. El primero lleva la radio, la conexión con el control y la pantalla de información; el segundo solo hace los ojos.
La maqueta: elegir la mirada en un navegador
Esta es la maqueta tal como la usamos para decidir el dibujo. Está viva: los ojos miran, parpadean y cambian de expresión cada siete segundos. Los botones eligen una expresión; «Píxeles reales» muestra el ojo con la resolución de una pantalla de 160 × 80.
Todo cabe en un solo archivo: el dibujo, el pequeño programa que lo anima y los botones. Puede descargarlo y abrirlo en cualquier navegador; su código se lee con un simple editor de texto. Varias decisiones se tomaron viéndola funcionar: los cambios de expresión más lentos, que parecían sobresaltos; el guiño rehecho como un gesto de verdad (cierre rápido, un instante cerrado, apertura más lenta); y la vista de «píxeles reales», que mostró que un detalle invisible a este tamaño no vale la pena calcularlo.
De la maqueta a la tarjeta: calcular cada píxel
El navegador dibuja la maqueta con curvas, degradados y desenfoques: para eso tiene un motor gráfico completo. El microcontrolador no lo tiene. Solo sabe llenar una tabla de números, un número por píxel, y enviarla a la pantalla. La traducción consiste entonces en rehacer, para cada píxel de cada ojo, el cálculo que el navegador hacía por nosotros: ¿estoy en el iris? ¿sobre una de sus fibras? ¿en la pupila? ¿bajo la sombra de un párpado? ¿en el párpado? Cada respuesta colorea un poco el píxel, encima de la anterior.
Dos técnicas dejan la imagen limpia. El antialiasing (el suavizado de los bordes, que evita los escalones): un borde que atraviesa un píxel solo lo colorea en parte, según la distancia del centro del píxel al borde. El tramado (dithering, una repartición regular de los errores de redondeo): la pantalla solo tiene 32 niveles de rojo y de azul, y sin él el degradado del blanco del ojo se vería en bandas. Además, el programa traza sus pistas y las fibras del iris con el mismo generador de números aleatorios que la maqueta, con la misma semilla: los ojos de la tarjeta tienen exactamente el dibujo de los del computador.
Tres componentes hacen el trabajo, separados para volver a servir en el robot:
yeux(ojos): el dibujo y la vida de los ojos. No conoce ningún hardware: llena tablas de píxeles, y nada más;ecran_st7735: el controlador de las pantallas de los ojos. ESP-IDF, el entorno de desarrollo de Espressif, trae un controlador para el ST7789 de la pantalla de información, pero ninguno para el ST7735S; hubo que escribirlo;liaison_manette(conexión del control): la conexión del artículo anterior, sacada del programa de la prueba 04 a un componente de ESP-IDF, es decir, una carpeta de código reutilizable que varios programas incluyen sin copiarla. El programa solo ve tres funciones:manette::demarrer()arranca la conexión,manette::situation()dice en qué estado está, ymanette::commandes()devuelve los botones, las palancas y los gatillos. Dos copias de un mismo código siempre terminan siendo distintas, la primera vez que se corrige una; un componente existe una sola vez.
En qué nos atascamos
Primer encendido: ruido
Con las tres pantallas cableadas, la pantalla de información se encendió normalmente. Los dos ojos mostraron esto.

Algo se movía cuando tocábamos el control: el programa corría y las pantallas recibían píxeles. Los cables de selección estaban bien. La respuesta estaba escrita en los módulos: el controlador estaba configurado para las pantallas de 0,96 pulgadas previstas al principio para el robot, y los módulos del banco eran de 1,44 pulgadas. El chip, eso sí, es el mismo.

Mismo chip, otro panel: ese es todo el problema. El ST7735S tiene una memoria de 132 × 162 píxeles, y un panel solo muestra una parte, en una posición que depende del modelo. El controlador escribía en el lugar equivocado y pedía la inversión de colores que necesitan los paneles IPS, y que este no necesita. El truco que después volvió legible cada prueba: al arrancar, el controlador pone en negro toda la memoria del chip, y no solo la zona que cree visible. Un ajuste equivocado desplaza o recorta entonces la imagen, pero ya no deja ruido que la tape. Una cuadrícula numerada, que se muestra hasta que se presiona A, dice luego al píxel exacto lo que muestra la pantalla.

Cuadrada, aunque no lo parezca
La imagen de control, unas bandas de color dentro de un marco, solo ocupaba una parte de la pantalla.

La pantalla nos parecía rectangular. Entonces intentamos tratarla como 160 × 128, para que el ojo de la maqueta cupiera entero.

La imagen de control sale doblada sobre sí misma: el panel sí es cuadrado, 128 × 128, y lo que se escribe más allá se pierde. De ahí la decisión que cambió el dibujo: calcular los ojos al tamaño de la pantalla, en lugar de reducir o recortar el ojo de la maqueta. Lo que se ubica en la pantalla (los párpados, la posición del iris, los reflejos) sigue a la pantalla, en ancho y en alto por separado. Lo que tiene una forma (el iris, la pupila, las gotas, el limpiaparabrisas, el grosor de las pistas) sigue una escala única, la media geométrica de las dos. En la pantalla cuadrada, el ojo se abre entonces más alto, y el iris crece sin aplastarse. El mismo programa se adapta a cualquier otro tamaño de pantalla.
Demasiado lento: 8 imágenes por segundo
Con el ojo ya en pantalla, la pantalla de información dio las primeras cifras.

| Medición | Primera lectura | Versión final |
|---|---|---|
| Imágenes por segundo | 8 a 14 | 31 |
| Cálculo de los dos ojos, por imagen | 66 a 136 ms | 17 a 28 ms |
| Píxeles calculados por imagen | 2 × 12.800 | 2 × 16.384 |
| Núcleo de los ojos | 98 a 100 % | 56 a 89 % |
| Núcleo de la radio y de la pantalla de información | 1 a 2 % | 3 % |
La primera lectura decía tres cosas. El cálculo era de dos a cuatro veces demasiado lento: para sostener treinta imágenes por segundo hay 33 ms como máximo. El bus no tenía nada que ver: nunca esperaba. El Bluetooth casi no cuesta nada: 2 % de un núcleo, lo que la separación de los núcleos debía permitir ver. Los trucos que nos llevaron de la primera columna a la segunda caben en una sola idea: calcular una sola vez lo que no cambia, y calcular una sola vez lo que los dos ojos tienen en común.
- El iris está precalculado. Su textura (120 fibras, 14 manchitas, una collareta, dos anillos) no se mueve con él: se calcula al arrancar como una pequeña imagen por ojo, que se pone en lugar del iris en cada imagen. En vivo solo quedan la pupila, que respira, y el color, que se vuelve rojo con la rabia.
- Todas las capas de un dibujo se resumen en dos números. Pintar un color encima de otro con transparencia es una operación lineal: encadenadas, las capas del iris se resumen en «lo de abajo × m + a». m y a se encuentran componiendo una vez sobre negro y una vez sobre blanco, y luego el iris se pone con una multiplicación y una suma por píxel. El mismo procedimiento sirve para las gotas de lluvia y para el limpiaparabrisas.
// Componer sobre negro da a; sobre blanco, 255·m + a.
const Couleur noir = composer(dx, dy, NOIR, 0), blanc = composer(dx, dy, BLANC, 0);
p.m = octet(blanc.r - noir.r); // la parte de lo de abajo que se conserva
p.a_calme[0] = octet(noir.r); // lo que agrega el iris (y lo mismo en verde y en azul)
// En cada imagen, para cada píxel del iris:
c = {c.r * m + p.a_calme[0] + (p.a_colere[0] - p.a_calme[0]) * colere, /* … */};
- Los dos ojos se dibujan en una sola pasada. Miran en la misma dirección: la posición del iris, la pupila, el halo de rabia y los reflejos son los mismos, y se calculan una sola vez para los dos. El limpiaparabrisas también: solo se recalcula cuando se mueve, y solo cerca de su brazo.
- Solo se pinta lo que toca el píxel. Lejos del borde de los párpados, la sombra, el ribete y el párpado no cambian nada: una prueba los salta. El desenfoque de las sombras se lee en una tabla en lugar de pedir dos exponenciales por píxel.
- La PSRAM recibe los dibujos precalculados (fondos, iris, capas, unos 250 KB), y deja la memoria interna para el Bluetooth y los envíos a las pantallas.
La trampa de la espera que gira en vacío
Después de estos aligeramientos, el núcleo de los ojos seguía al 100 %. El cálculo de los dos ojos había terminado, pero el envío del ojo derecho tenía que esperar a que el bus terminara de enviar el ojo izquierdo, unos quince milisegundos. Se sumaban dos sorpresas.
La primera: esa espera bloqueaba la tarea de los ojos, que no podía empezar la imagen siguiente. El envío pasó entonces a una tarea aparte, que espera el bus mientras los ojos calculan; el controlador copia primero cada imagen en su propio búfer, para que el programa pueda volver a dibujar la suya enseguida.
La segunda: el controlador SPI de ESP-IDF envía las órdenes «por sondeo» (polling), es decir, espera el final del bus dando vueltas, revisando sin parar si está libre. Mientras tanto, el núcleo parece lleno aunque no hace nada útil. La tarea de envío ahora espera el final del ojo izquierdo con una señal, dormida, y solo después lanza el ojo derecho. La propia medición engañaba: contaba esa espera dentro del cálculo, y mostraba «33,6 ms de cálculo» con un núcleo medio libre. El cálculo y el envío ahora se miden por separado.

Esta pantalla también muestra la lista de expresiones, que no se alcanzaba a leer a dos pasos. En la versión final, le cedió el lugar a una sola línea: la expresión elegida en letras grandes negras sobre fondo amarillo.
Escalones en los párpados
Los párpados que parpadeaban mostraban escalones en su borde cuando se movían rápido. Es un desgarro de imagen (tearing): la pantalla se redibuja sola, a su propio ritmo, mientras se le escribe la imagen siguiente. Durante un barrido muestra, entonces, un pedazo de la imagen vieja y un pedazo de la nueva. La solución habitual es una señal de la pantalla que anuncia el inicio de cada barrido, pero estos módulos de ocho pines no la sacan.

Lo que funcionó es de una sencillez casi ofensiva: montar el panel en su sentido original. Un panel se redibuja a lo largo de SUS propias filas. Las pantallas estaban montadas de lado, con la imagen girada un cuarto de vuelta por el programa: sus filas eran entonces verticales para nosotros, y el corte entre imagen vieja e imagen nueva atravesaba el borde de un párpado que sube o baja. En su sentido, el corte queda paralelo al borde del párpado, y el escalón desaparece.

En el robot, las pantallas tendrán que montarse en ese mismo sentido, con los pines arriba.
La mirada que no volvía
Un último defecto apareció jugando con la versión final: al soltar la palanca de golpe, la pupila se quedaba cerca del borde del ojo en lugar de volver al centro. Había dos sospechosos. Primero el control: ¿de verdad envía la posición de reposo cuando la palanca vuelve bruscamente? Para saberlo sin adivinar, la pantalla de información ahora muestra los valores en bruto de las dos palancas, en naranja apenas una sale de la zona muerta (la pequeña zona alrededor del centro donde se considera que la palanca está suelta). Después, el programa. El culpable era él. Cuando la palanca entra en su zona muerta, la mirada deja de estar impuesta, pero su objetivo seguía siendo la última posición recibida. Si se suelta despacio, esa última lectura está casi en el centro y no se nota nada; si se suelta rápido, todavía está cerca del borde. Bastó con devolver el objetivo al centro en el instante en que se suelta la palanca; la vida automática se reanuda 0,8 segundos después. Que la pupila ahora vuelva al centro demuestra, de paso, que el control sí enviaba su posición de reposo.
El programa final
Se compila con ESP-IDF 6.1 (opción --preview, porque el ESP32-S31 todavía está en versión preliminar): yeux-esp32-s31.zip. Los nombres y comentarios del programa están en francés. El archivo contiene:
main/essai_yeux.cpp: el programa, con sus dos tareas (los ojos en el núcleo 1, la pantalla de información en el núcleo 0) y la tarea de envío;components/yeux: el dibujo y la vida de los ojos, al tamaño de la pantalla que se le dé;components/ecran_st7735: el controlador de los ojos, con los ajustes de los dos paneles en su encabezado (DALLE_0_96_POUCE,DALLE_1_44_POUCE);components/ecran_st7789ycomponents/liaison_manette: la pantalla de información y la conexión del artículo anterior;sdkconfig.defaults: el Bluetooth en el núcleo 0, la PSRAM y la medición del tiempo que pasa cada tarea.
Cablee como en la tabla de las decisiones, con las pantallas de 1,44 pulgadas montadas con los pines arriba. Al arrancar, aparece una cuadrícula en los dos ojos hasta que se presiona A. Después:
| Mando | Efecto |
|---|---|
| LB, RB | la expresión anterior, la siguiente; la pantalla de información la muestra en grande |
| A, B, X, Y, cruceta arriba y abajo | feliz, enojado, sorprendido, triste, neutral, dormido |
| L3, R3 (palancas presionadas) | lágrimas, lluvia |
| palancas | la mirada; al final del recorrido, la mitad del iris pasa por debajo del borde |
| gatillos LT, RT | cierran el ojo izquierdo, el ojo derecho, en proporción a la presión |
| cruceta izquierda y derecha | el brillo, de 5 a 100 % |
| SEL | el cambio automático, una expresión cada 7 s |
| START (sostenido) | la cuadrícula de ajuste |
La versión final de los ojos
Para terminar, aquí están los ojos tal como los dibuja la tarjeta: pantalla cuadrada, pistas más visibles, el iris que pasa a medias por debajo del borde al final de su recorrido (botón «Mirada»), lluvia de gotas grandes y el limpiaparabrisas siempre en su sitio. Es la maqueta rehecha a partir del programa final; puede descargarla igual que la primera.
Los ojos sostienen sus treinta imágenes por segundo, con un núcleo ocupado entre la mitad y las nueve décimas partes del tiempo según la expresión, y la radio casi desocupada al lado. Queda una pregunta para el robot: solo tiene dos núcleos, y el segundo está prometido a los motores. ¿Pasarán los ojos al primero, junto a la radio, aligerados una vez más, o encontrarán ayuda en el acelerador gráfico del chip? Ese es el próximo trabajo.
Fuentes y filiación
El estilo de los ojos se inspira en los ojos animados que popularizó Adafruit en sus tarjetas (proyecto «Uncanny Eyes»).
Los ajustes de partida de las pantallas de 0,96 pulgadas vienen del programa de demostración de LCDWiki para ese módulo; los del módulo de 1,44 pulgadas se encontraron en el banco, con la cuadrícula de ajuste.
El chip ST7735S: hoja de datos de Sitronix, para las órdenes (sentido de barrido MADCTL, ventana de escritura, frecuencia de refresco).
Los programas de los archivos se publican bajo la licencia PolyForm Noncommercial 1.0.0: puede usarlos, modificarlos y compartirlos para un uso personal, educativo, de investigación o sin ánimo de lucro; cualquier uso comercial requiere la autorización escrita del autor. Los archivos de Espressif que contienen conservan su propia licencia.
© Sébastien Debucquoi — Todos los derechos reservados.