TinyGo 0.42 lleva Go a 87 variantes del Puya PY32

Nota de CNX Software: esta es una publicación invitada de Pavel Burgr, quien agregó recientemente el soporte para microcontroladores Puya PY32 en TinyGo 0.42, la última versión del compilador de Go para microcontroladores. Cubrimos TinyGo por primera vez en 2019 y el proyecto sigue firme, con 17.700 estrellas, 1.100 forks y 243 personas contribuyendo.

TinyGo 0.42 agrega soporte para la familia Puya PY32 de microcontroladores Arm de 32 bits. El nuevo port incluye código de arranque, definiciones generadas de registros de dispositivo, scripts de enlazado, soporte de GPIO y UART, y objetivos para 87 configuraciones individuales de microcontrolador. También trae definiciones para dos placas de desarrollo EmbedFire económicas disponibles en AliExpress.

El aporte fue de Pavel Burgr y se integró mediante el pull request #5106 de TinyGo. Una de las motivaciones fue establecer una plataforma de firmware sólida y fácil de usar para dispositivos IoT pequeños construidos alrededor del servicio Registry y el protocolo de radio de bajo consumo BleRiot. Esos proyectos son independientes de TinyGo, pero muestran el tipo de aplicación con recursos acotados que los nuevos objetivos buscan habilitar.

¿Qué chips quedan cubiertos?

TinyGo es un compilador de Go para microcontroladores, WebAssembly y otros sistemas restringidos. Usa LLVM para producir binarios nativos compactos y entrega una capa de abstracción de hardware a través de paquetes como machine, conservando la sintaxis y las herramientas habituales de Go. Correr Go en una pieza con apenas 2 KB de SRAM puede sonar a desafío, y es justamente el tipo de desafío para el que se hizo TinyGo.

El port de PY32 cubre dispositivos Cortex-M0+ y Cortex-M4. La tabla de objetivos contiene 87 configuraciones concretas de memoria repartidas en 40 familias de definición de dispositivo, desde partes con 8 KB de flash y 2 KB de SRAM hasta otras con 512 KB de flash y 144 KB de SRAM.

Las series soportadas incluyen:

• PY32F001, F002, F003, F021, F030, F031, F032, F040, F071, F072, F403 y F410
• PY32L020 y L090
• PY32M010, M020, M030, M031 y M070
• PY32MD310, MD320, MD410, MD420 y MD430
• PY32T020, T090 y T092

Cada objetivo de chip selecciona el mapa correcto de flash y SRAM. Las definiciones de periféricos se generan desde los datos CMSIS de Puya a través del repositorio py32-svd, lo que entrega nombres de registro tipados en device/py32 en vez de tablas privadas de direcciones.

La API machine en TinyGo 0.42 cubre arranque de reloj y temporizadores, GPIO y UART, incluida una segunda UART en partes seleccionadas. ADC, I2C, SPI y PWM todavía no tienen controladores portables en machine, pero sus registros generados sí están disponibles para código de bajo nivel.

Las dos placas EmbedFire soportadas

Dos placas de desarrollo Puya32 pequeñas tienen objetivos dedicados y alias de pines, lo que las convierte en la forma más simple de probar el port. Ambas se consiguen por menos de 2 dólares en AliExpress, y la placa PY32F030 se vende desde 7 dólares en Amazon.

La placa PY32F030 mapea LED1, LED2 y LED3 a PA2, PA3 y PA4, y sus dos teclas a PA5 y PA6. Su UART por omisión usa PA7 para TX y PA8 para RX. La placa más pequeña, PY32F002B, mapea los LED a PA1, PA5 y PA4, las teclas a PA3 y PA0, y la UART por omisión a PA6 y PA7.

Ambas placas definen machine.LED como alias del segundo LED integrado. Como manda la tradición del mundo embebido, el mismo primer programa puede hacer el parpadeo ceremonial en cualquiera de los dos objetivos:

package main

import (
	"machine"
	"time"
)

func main() {
	led := machine.LED
	led.Configure(machine.PinConfig{Mode: machine.PinOutput})

	for {
		led.Set(true)
		time.Sleep(500 * time.Millisecond)
		led.Set(false)
		time.Sleep(500 * time.Millisecond)
	}
}

Con una sonda SWD compatible conectada y pyOCD configurado para el dispositivo Puya elegido, el programa se compila y se graba con un solo comando, sin arqueología de Makefiles:

tinygo flash -target=embedfire-py32f030 .

Para la placa más chica, solo cambia el objetivo:

tinygo flash -target=embedfire-py32f002b .

Los objetivos de placa heredan los mapas de memoria exactos py32f030x8 y py32f002bx5, e invocan el objetivo pyOCD correspondiente durante la grabación. También hay objetivos de chip pelado para placas propias. Una plantilla de proyecto TinyGo para PY32 entrega ejemplos adicionales de parpadeo y un Makefile inicial.

¿Para qué sirve en un nodo IoT real?

Con el parpadeo fuera del camino, la motivación práctica detrás del port resulta más interesante. Pavel desarrolló el soporte de PY32 mientras construía BleRiot, un protocolo simple y confiable de solicitud y respuesta para nodos de radiofrecuencia de bajo consumo.

Cada nodo expone registros de 32 bits con signo y entiende apenas dos operaciones, GET y SET. Ese es todo el vocabulario, y es una característica más que una omisión. El concentrador Linux consulta los registros y se hace cargo de nombres, conversión de unidades, reintentos y tiempos de espera. Esa interfaz pequeña y predecible mantiene el firmware compacto, mientras que la recuperación ante un paquete perdido se resuelve una sola vez en el concentrador y no en cada aplicación.

Un concentrador se comunica con muchos nodos a través de un enlace de radio GFSK propio de 250 kbps con tramas compatibles con BLE, aunque no es Bluetooth LE ni GATT. El nodo de referencia combina un PY32F030x8 con una radio PAN211x de 2,4 GHz, mientras que el concentrador usa un simple dongle USB de radio.

BleRiot publica los valores de los nodos en Registry, un servicio local liviano que le da a cada registro un nombre, un valor actual, metadatos opcionales y un tiempo de vida. Los valores obsoletos expiran solos. Las aplicaciones pueden usar su API HTTP/JSON directamente; los nodos de Node-RED incluidos se combinan con nodos MQTT estándar para hacer de puente, y un endpoint Prometheus integrado expone los registros numéricos como métricas listas para tableros de Grafana. Dicho de otro modo, llevar una temperatura a un tablero no exige enseñarle Grafana a un microcontrolador de 3 KB.

Disponibilidad y próximos pasos

El soporte de PY32 está disponible en TinyGo 0.42.0. Los dos objetivos EmbedFire son la puerta de entrada más directa, mientras que la lista más amplia de chips le da a quien desarrolla una base para placas propias, desde nodos sensores diminutos hasta controladores Cortex-M4 más grandes.

TinyGo 0.42 pone el énfasis en estabilidad de ejecución, mapas de memoria correctos, GPIO y comunicación serial, antes que en reclamar cobertura completa de periféricos. Las contribuciones futuras pueden sumar ADC, I2C, SPI y PWM portables, además de definiciones de placa, sobre la capa de registros generada en device/py32. Para quien ya usa Go del lado del anfitrión en un sistema IoT, el port vuelve mucho más accesible a la familia de microcontroladores baratos de Puya.

Para el ecosistema maker de la región el atractivo es el precio por nodo. Un PY32F002B con 3 KB de SRAM no compite con un ESP32 en prestaciones, pero tampoco intenta hacerlo: compite en el lugar donde hoy se pone un microcontrolador de 8 bits porque la conectividad la resuelve otro dispositivo. Con radio propia, protocolo de dos operaciones y un compilador mantenido, ese nicho queda cubierto con la misma sintaxis que ya se usa del lado del servidor.

Nota de CNX Software: al parecer el soporte de TinyGo para microcontroladores AT32 viene enseguida.