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:
- Crates de acceso a periféricos (PAC): generados por
svd2rusta partir de los archivos de descripción del fabricante; una API tipada para cada registro y cada campo de bits. - Crates HAL: drivers seguros por familia de chips:
stm32f4xx-hal,rp2040-hal,esp-hal,nrf52840-hal. 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; unMutex<RefCell<T>>del cratecritical-sectionhace 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/awaitresulta 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::Writefunciona sin reservar memoria;defmtofrece un registro muy compacto a través de una sonda de depuración.- Si quieres
alloc, registra un#[global_allocator]comoembedded-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
SendySyncy 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
- Haz que un crate de biblioteca pequeño sea
#![no_std]con una característicastdopcional (#![cfg_attr(not(feature = "std"), no_std)]). ¿Qué se rompe cuando usasVec? Arréglalo conextern crate alloc;. - Amplía el pin con typestate con
Pin<Analog>y una conversióninto_analogválida solo desdeInput. - Escribe un búfer circular de capacidad fija
struct Ring<T, const N: usize>con unpushque devuelvaErr(T)cuando esté lleno, usando solocore. - 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.¿Qué elimina
#![no_std]?2.¿Por qué hay que acceder a los registros de hardware con
read_volatileywrite_volatile?3.¿Cómo usan la propiedad los crates HAL de embebidos para impedir que dos drivers usen el mismo pin?