Embassy: async/await en el metal, sin heap y sin RTOS

Un microcontrolador se pasa la vida esperando: a que venza un temporizador, a que llegue un byte por el bus, a que un DMA termine de mover un bloque, a que un pin cambie de flanco. Su trabajo es reaccionar a eventos, no calcular sin descanso. Y “espera a que ocurra esto y sigue” es, letra por letra, lo que expresa un .await. Por eso el modelo asíncrono de Rust —el trait Future, el poll, el waker que ya diseccionaste en la concurrencia async— encaja en el metal con una naturalidad que los hilos nunca tuvieron. Embassy es el framework que lo trae al embebido: un ejecutor cooperativo que sintetiza máquinas de estados a partir de código de aspecto secuencial, funciona sin heap y sin sistema operativo, duerme el núcleo cuando no hay nada que hacer y despierta cada tarea desde la interrupción que la concierne. La tesis de esta lección es que el async de Rust no fue nunca una función de servidores: fue siempre un modelo universal de concurrencia por E/S, y el microcontrolador es donde su promesa de coste cero se ve con más claridad.

Por qué async encaja en un microcontrolador

Recupera el modelo async: una async fn no ejecuta nada al llamarla, sino que devuelve un Future, una máquina de estados que el compilador genera a partir de tu código; cada .await es un punto donde la máquina puede suspenderse, cediendo el control, y reanudarse después. En un servidor, ese diseño brilla porque el cuello de botella es la E/S de red: miles de conexiones que pasan el rato esperando. Un microcontrolador es el mismo problema llevado al extremo. Casi todo lo que hace es esperar a un periférico, y esa espera, en código bloqueante, se paga girando en un bucle ocupado —quemando ciclos y batería— o hilando a mano una maraña de manejadores de interrupción y banderas globales.

Async disuelve esa disyuntiva. Escribes la lógica como si fuera secuencial, y el .await marca dónde el trabajo se detiene a esperar un evento del hardware sin bloquear a nadie:

// Aspecto secuencial; por dentro, una maquina de estados que se suspende en cada await
async fn medir(i2c: &mut impl embedded_hal_async::i2c::I2c) -> Result<i16, ()> {
    i2c.write(0x48, &[0x01]).await.map_err(|_| ())?; // arranca la conversion y espera
    Timer::after_millis(10).await;                    // espera sin quemar ciclos
    let mut buf = [0u8; 2];
    i2c.read(0x48, &mut buf).await.map_err(|_| ())?;  // espera el DMA por interrupcion
    Ok(i16::from_be_bytes(buf))
}

Ese código parece que bloquea tres veces, pero no gasta un ciclo esperando: en cada .await la tarea se aparta y deja el núcleo libre para otras. La máquina de estados que hace posible ese ir y venir la escribe el compilador, no tú. Es el fin de la falsa elección entre el bucle ocupado que malgasta energía y el laberinto de interrupciones que malgasta cordura.

Async sin heap: una máquina de estados de tamaño fijo

Aquí está la propiedad que hace a Embassy viable en un chip diminuto. Un Future es una máquina de estados cuyo tamaño se conoce en compilación: ocupa exactamente lo que necesitan las variables locales que sobreviven a través de sus puntos de .await, ni un byte más. El macro #[embassy_executor::task] reserva para cada tarea una ranura estática de ese tamaño, de una vez y para siempre. No hay heap, no hay asignación dinámica, no hay pila por tarea.

Contrasta con un RTOS clásico. Allí cada tarea es un hilo, y cada hilo necesita su propia pila dimensionada para el peor caso —a menudo kilobytes— reservada esté o no en uso; con diez tareas, decenas de KB comprometidos por si acaso. El Future de Embassy invierte el trato: en vez de una pila del peor caso reservada de antemano, guarda solo el estado que de verdad cruza cada suspensión. En un dispositivo con 64 KB de RAM, esa diferencia es la que decide si tu diseño cabe.

El ejecutor que duerme el núcleo

El ejecutor de Embassy es un planificador cooperativo, no preemptivo: cada tarea corre hasta que se topa con un .await cuyo evento aún no ha ocurrido, momento en que devuelve el control. El ejecutor pasa a la siguiente tarea lista. Y cuando todas están a la espera, hace lo que ningún bucle ocupado haría: ejecuta una instrucción WFE o WFI y duerme el núcleo, dejándolo en bajo consumo hasta que una interrupción lo despierte. Para un dispositivo a pilas, eso es la diferencia entre semanas y años de autonomía.

El puente entre el hardware y el software es el mismo waker de la teoría async, con el reactor cambiado: donde en un servidor era epoll, aquí es el controlador de interrupciones. Cuando el periférico que una tarea esperaba dispara su interrupción, el manejador invoca el waker de esa tarea; el ejecutor la marca como lista y, al despertar, la vuelve a sondear con poll, y la máquina de estados avanza hasta el siguiente .await.

flowchart TD
RUN[Una tarea corre] --> AW[Llega a un await pendiente]
AW --> YIELD[Cede el control al ejecutor]
YIELD --> MORE[Queda alguna tarea lista]
MORE -->|Si| RUN
MORE -->|No| SLEEP[WFI y el nucleo duerme en bajo consumo]
IRQ[Interrupcion del periferico] --> WAKER[Dispara el waker de la tarea]
SLEEP --> WAKER
WAKER --> POLL[El ejecutor sondea la tarea con poll]
POLL --> RUN
style SLEEP fill:#89b4fa,color:#11111b
style WAKER fill:#fab387,color:#11111b
style RUN fill:#a6e3a1,color:#11111b

En la práctica, el programa se escribe con dos macros. #[embassy_executor::main] arranca el ejecutor y te entrega un Spawner; #[embassy_executor::task] marca cada tarea concurrente, que lanzas con spawner.spawn(...). Los HAL de Embassy —embassy-stm32, embassy-nrf, embassy-rp— son asíncronos de raíz: su I2C, su SPI y su UART usan DMA e interrupciones por debajo, implementando los traits de embedded-hal-async.

#![no_std]
#![no_main]

use embassy_executor::Spawner;
use embassy_stm32::gpio::{Level, Output, Speed};
use embassy_time::Timer;
use {defmt_rtt as _, panic_probe as _};

#[embassy_executor::task]
async fn parpadeo(mut led: Output<'static>) {
    loop {
        led.toggle();
        Timer::after_millis(250).await; // aqui el nucleo puede dormir
    }
}

#[embassy_executor::main]
async fn main(spawner: Spawner) {
    let p = embassy_stm32::init(Default::default());
    let led = Output::new(p.PC13, Level::High, Speed::Low);
    spawner.spawn(parpadeo(led)).unwrap();  // lanza la tarea concurrente
    // main queda libre para atender otras tareas a la vez
}