Rust y Embassy: una combinación perfecta para sistemas integrados

Rust & Embassy: A Great Match for Embedded Systems

Embedded development often means working under tight constraints—limited memory, strict timing, power usage, and reliability demands.

Rust has emerged as a strong choice for these environments, thanks to its memory safety, zero-cost abstractions, and strong compile-time guarantees. hexavik.github.io+3Developer Portal+3Systemscape+3 The Embassy framework builds upon those strengths, offering an async runtime designed specifically for embedded Rust. With Embassy, you can write asynchronous code using async/await even on microcontrollers—and do this without dynamic memory allocation, using a single stack, and with cooperative multitasking. That means you get much of what you need for concurrency and responsiveness without the complexity or overhead of a full RTOS. Embassy+2mbedded.ninja+2

Why It’s Easier to Get Started

1. Good tooling and examples Embassy provides plenty of example code for popular microcontrollers (STM32, nRF, RP2040, etc.), which makes it realistic to take a dev-kit, flash a "blinky" or button-press example, and immediately see something working. embassy-rs.github.io+1
2. Hardware Abstraction Layers (HALs) You don’t have to write low-level register manipulation from scratch. Embassy and its associated HAL crates (e.g. embassy-stm32, embassy-nrf) offer safe, idiomatic APIs. That cuts down boilerplate and risk of bugs. Embassy+2GitHub+2
3. Async without complexity With Embassy, many tasks—waiting for GPIO events, timers, or handling peripherals—can be written in async style. Instead of manually managing interrupts or polling loops everywhere, async/await style makes code easier to reason about and chain together. Also, because tasks are cooperative, power usage can be optimized (idle time can let the MCU sleep) and determinism is easier. Embassy+1
4. Stable support and ecosystem Embassy works with stable Rust (recent versions) and aligns with established crates like embedded-hal. Embassy+1 This helps avoid breaking changes and ensures many microcontrollers are already supported.

In short, using Rust + Embassy for embedded work lets engineers get productive quickly, while gaining safety, efficiency, and modern concurrency. If you already have a microcontroller board, you can often clone or adapt an example, flash it, then build up functionality, without wrestling endlessly with toolchains or RTOS configuration.

<pre><code class="language-rust">
#![no_std]
#![no_main]
use embassy_executor::Spawner;
use embassy_time::{Duration, Timer};
use embassy_stm32::gpio::{Output, Level, Speed};
#[embassy_executor::main]
async fn main(spawner: Spawner) {
let mut led = Output::new(p.PA5, Level::Low, Speed::Low);
loop {
led.set_high();
Timer::after(Duration::from_millis(500)).await;
led.set_low();
Timer::after(Duration::from_millis(500)).await;
}
}
</code></pre>