FerrousPath

Nivel 3 · Sistemas· Lección 11 de 11 · 25 min

no_std y Rust embebido

Rust sin sistema operativo — core y alloc, manejadores de pánico, registros mapeados en memoria, HAL y async en microcontroladores.

Las capas de la biblioteca estándar

Crate Necesita Proporciona
core nada primitivas, Option, Result, iteradores, slices, str, atómicos, Cell, traits, fmt
alloc un asignador global Box, Vec, String, Rc, Arc, BTreeMap
std un sistema operativo archivos, red, hilos, HashMap, tiempo, procesos

#![no_std] en la raíz del crate enlaza solo core. El lenguaje en sí —propiedad, traits, genéricos, clausuras, async— queda completamente intacto. Muchas bibliotecas son compatibles con no_std y ofrecen std y alloc como características opcionales; escribir así tus propias bibliotecas amplía los sitios donde pueden ejecutarse.

Un programa sobre el metal desnudo

Sin sistema operativo no hay nadie que llame a main, imprima los pánicos ni proporcione un heap. Esas piezas las pones tú:

// src/main.rs — para un microcontrolador Cortex-M (thumbv7em-none-eabihf)
#![no_std]
#![no_main]

use core::panic::PanicInfo;
use cortex_m_rt::entry;

#[entry]
fn main() -> ! {
    // `!`: esta función no retorna nunca. No hay nada a lo que retornar.
    let mut counter: u32 = 0;
    loop {
        counter = counter.wrapping_add(1);
    }
}

#[panic_handler]
fn panic(_info: &PanicInfo) -> ! {
    // Decide qué significa un pánico en tu dispositivo: detenerse, reiniciar, hacer parpadear un LED, registrar por una sonda de depuración…
    loop {}
}

El crate cortex-m-rt proporciona el vector de reset, inicializa la RAM y llama a tu función #[entry]; un script del enlazador (memory.x) describe dónde están la flash y la RAM. Compila con cargo build --target thumbv7em-none-eabihf y graba el programa con probe-rs.

Hablar con el hardware

Los periféricos se controlan mediante registros mapeados en memoria: direcciones fijas en las que leer y escribir tiene efectos secundarios.

use core::ptr::{read_volatile, write_volatile};

/// Un sustituto de un registro de dispositivo real para que este ejemplo funcione en cualquier parte.
static mut FAKE_GPIO_ODR: u32 = 0;

struct Register(*mut u32);

impl Register {
    fn read(&self) -> u32 {
        // SAFETY: el puntero se refiere a un u32 válido y alineado durante toda la vida del programa.
        unsafe { read_volatile(self.0) }
    }
    fn modify(&self, f: impl FnOnce(u32) -> u32) {
        // SAFETY: igual que arriba.
        unsafe { write_volatile(self.0, f(read_volatile(self.0))) }
    }
}

fn main() {
    // En un chip real sería una dirección fija tomada de la hoja de datos, p. ej. 0x4002_0014.
    let odr = Register(&raw mut FAKE_GPIO_ODR);
    odr.modify(|v| v | (1 << 5));  // pone el pin 5 a nivel alto
    odr.modify(|v| v | (1 << 13)); // pone el pin 13 a nivel alto
    odr.modify(|v| v & !(1 << 5)); // pone el pin 5 a nivel bajo
    println!("{:#018b}", odr.read());
}

Nadie escribe a mano las direcciones de los registros. El ecosistema está organizado en capas:

  1. Crates de acceso a periféricos (PAC): generados por svd2rust a partir de los archivos de descripción del fabricante; una API tipada para cada registro y cada campo de bits.
  2. Crates HAL: drivers seguros por familia de chips: stm32f4xx-hal, rp2040-hal, esp-hal, nrf52840-hal.
  3. embedded-hal: traits (OutputPin, SpiBus, I2c, DelayNs) que los HAL implementan, de modo que un driver para un sensor o una pantalla funciona en cualquier chip.

La propiedad como herramienta de seguridad del hardware

Aquí es donde el sistema de tipos de Rust rinde de forma más visible. Los periféricos son singletons que puedes tomar una sola vez; configurar un pin lo consume y devuelve un tipo distinto. Lo siguiente se ejecuta en tu ordenador, pero tiene la forma de cualquier HAL:

use core::marker::PhantomData;

struct Input;
struct Output;

struct Pin<Mode> {
    number: u8,
    _mode: PhantomData<Mode>,
}

struct Peripherals {
    pin5: Pin<Input>,
}

impl Peripherals {
    /// En un HAL real esto devuelve `Some` exactamente una vez.
    fn take() -> Peripherals {
        Peripherals { pin5: Pin { number: 5, _mode: PhantomData } }
    }
}

impl Pin<Input> {
    fn is_high(&self) -> bool { false }
    fn into_output(self) -> Pin<Output> {
        println!("configuring pin {} as output", self.number);
        Pin { number: self.number, _mode: PhantomData }
    }
}

impl Pin<Output> {
    fn set_high(&mut self) { println!("pin {} high", self.number); }
}

fn main() {
    let p = Peripherals::take();
    println!("input reads high? {}", p.pin5.is_high());
    let mut led = p.pin5.into_output(); // mueve pin5: ya nada más puede usarlo
    led.set_high();
    // p.pin5.is_high();   // ❌ no compilaría: pin5 se movió
    // led.is_high();      // ❌ no compilaría: ese método no existe en Pin<Output>
}

Excitar un pin de entrada, compartir un pin entre dos drivers, usar un periférico antes de activar su reloj: toda una clase de errores eléctricos se convierte en errores de tipos. PhantomData<Mode> registra el estado sin ocupar memoria. El nivel 4 lo generaliza como el patrón typestate.

Concurrencia sin sistema operativo

Los manejadores de interrupción interrumpen tu bucle principal en cualquier instrucción, lo que es exactamente un riesgo de carrera de datos. Se aplican las mismas reglas de Send/Sync:

  • Secciones críticas: critical_section::with(|cs| …) desactiva las interrupciones brevemente; un Mutex<RefCell<T>> del crate critical-section hace que el estado compartido solo sea accesible dentro de una.
  • Atómicos para banderas y contadores.
  • RTIC: un framework que analiza las prioridades de las tareas en tiempo de compilación y concede acceso sin cerrojos allí donde no puede haber interrupción.
  • Embassy: un ejecutor async para microcontroladores. async/await resulta encajar de maravilla: cada tarea es una máquina de estados de tamaño conocido estáticamente, sin heap ni pila por tarea, y la CPU duerme siempre que todas las tareas están esperando.
// crate: embassy (runs on a microcontroller)
#[embassy_executor::task]
async fn blink(mut led: Output<'static>) {
    loop {
        led.toggle();
        Timer::after_millis(500).await; // el núcleo duerme aquí
    }
}

Trabajar sin heap

  • Colecciones de capacidad fija: heapless::Vec<T, N>, heapless::String<N>, búferes circulares y colas.
  • core::fmt::Write funciona sin reservar memoria; defmt ofrece un registro muy compacto a través de una sonda de depuración.
  • Si quieres alloc, registra un #[global_allocator] como embedded-alloc, y decide qué significa quedarse sin memoria.
  • Vigila el uso de la pila; la recursión y los arrays grandes en la pila son un peligro cuando tienes unos pocos kilobytes.

Punto de control del nivel 3

Estás listo para el nivel 4 si puedes:

  • Explicar Send y Sync y decir por qué Rc<RefCell<T>> no es ninguna de las dos cosas.
  • Escribir un programa async con tareas lanzadas, un tiempo de espera y un select!, y explicar la cancelación.
  • Escribir una macro macro_rules! con repetición, y esbozar cómo funciona una macro derive.
  • Envolver una operación unsafe en una función segura y argumentar que es correcta.
  • Exponer una función de Rust a C o a JavaScript, con una historia de propiedad clara para cada puntero.

Ejercicios

  1. Haz que un crate de biblioteca pequeño sea #![no_std] con una característica std opcional (#![cfg_attr(not(feature = "std"), no_std)]). ¿Qué se rompe cuando usas Vec? Arréglalo con extern crate alloc;.
  2. Amplía el pin con typestate con Pin<Analog> y una conversión into_analog válida solo desde Input.
  3. Escribe un búfer circular de capacidad fija struct Ring<T, const N: usize> con un push que devuelva Err(T) cuando esté lleno, usando solo core.
  4. Si tienes una placa de desarrollo (una Raspberry Pi Pico o una STM32 Nucleo son ideales), sigue The Embedded Rust Book y haz parpadear un LED con embassy.

Comprueba lo que has entendido

Elige una respuesta para ver la explicación.

  1. 1.¿Qué elimina #![no_std]?

  2. 2.¿Por qué hay que acceder a los registros de hardware con read_volatile y write_volatile?

  3. 3.¿Cómo usan la propiedad los crates HAL de embebidos para impedir que dos drivers usen el mismo pin?

Términos clave de esta lección

¿Has terminado la lección y los ejercicios?