Embedded Rust with RP2040

You already know registers, interrupts, DMA, and linker scripts. You want to understand what Rust actually gives you over C in firmware. Each lesson includes a “C vs Rust” sidebar that maps familiar C patterns to their Rust equivalents, so the transition is concrete rather than abstract.

You know ownership, traits, and lifetimes from application Rust. You want to apply those skills to microcontrollers. Each lesson explains the hardware concepts (registers, peripherals, interrupts) alongside the Rust code that drives them, so you build embedded intuition as you go.

Rust HALs encode hardware state in the type system. A GPIO pin configured as an input has a different type than the same pin configured as an output. Try to write to an input pin and the compiler rejects your code. Try to read an ADC channel before configuring the ADC and the code does not compile. This is not runtime error checking; it is compile-time proof of correctness.

Each peripheral is a singleton that can only be owned by one part of your code at a time. No more wondering which module touched the SPI bus last. No more accidental double initialization. The borrow checker enforces exclusive access to hardware the same way it enforces exclusive access to memory.

Embassy provides cooperative async/await on bare-metal Cortex-M0+. You write firmware that looks like multiple concurrent tasks (read sensor, update display, handle buttons) without the RAM overhead of an RTOS. The executor is interrupt-driven, so idle tasks cost zero CPU cycles.

Drivers written against the embedded-hal traits work across any microcontroller. An SSD1306 OLED driver written for STM32 works on RP2040 with zero changes. Your driver code becomes portable while your HAL layer handles chip-specific details.

Rust Toolchain and First Blink. Install Rust, probe-rs, and flip-link. Create your first rp2040 project with Cargo, understand Cargo.toml dependencies, memory.x, and .cargo/config.toml. Build a blinking LED with defmt logging over RTT. Build: Blinking LED with RTT logging. Parts: Raspberry Pi Pico, debug probe, LED, resistor.

Ownership, Borrowing, and Hardware. Learn how Rust’s ownership model maps to hardware peripherals. Typestate GPIO, button debouncing with owned state, error handling with Result, and safe access to shared resources with Mutex and critical sections. Build: Button-toggled LED with debounce. Parts: Push button, LED, resistors.

Timers, PWM, and Interrupts. Configure RP2040 timers, generate servo PWM, handle interrupts with the critical-section crate, and read analog inputs. Build a pot-controlled servo with buzzer feedback. Build: Potentiometer-controlled servo with buzzer. Parts: SG90 servo, potentiometer, piezo buzzer.

I2C, SPI, and embedded-hal Drivers. Use embedded-hal traits to interface a BME280 sensor over I2C and an SSD1306 OLED over I2C/SPI. Understand how trait-based drivers enable cross-platform portability. Build: Environmental sensor dashboard on OLED. Parts: BME280, SSD1306 OLED.

UART, DMA, and Data Pipelines. Parse GPS NMEA sentences over UART, log data to a microSD card over SPI, and use DMA for efficient data movement without CPU polling. Build: GPS data logger with SD storage. Parts: NEO-6M GPS module, microSD module.

Embassy Async Runtime. Transition from polling to async/await with Embassy. Understand the executor, async tasks, timers, and channels. Rebuild earlier projects as concurrent async tasks. Build: Multitask sensor dashboard (async). Parts: Reuse existing.

Embassy Networking with Pico W. Use embassy-net and the CYW43 driver for Wi-Fi connectivity. TCP sockets, HTTP serving, and MQTT publishing. Build a wireless sensor node. Build: Wi-Fi sensor node with MQTT. Parts: Pico W (swap from Pico).

PIO in Rust. Program the RP2040’s Programmable I/O state machines from Rust using pio-rs. Drive WS2812B NeoPixel LEDs and implement custom protocols with PIO programs compiled at build time. Build: NeoPixel LED strip controller. Parts: WS2812B LED strip (8 pixels).

Async Sensor Hub Project. Combine everything into a production-quality firmware: async tasks, sensor reading, display output, wireless reporting, SD card logging, and alarm outputs. Build a complete environmental monitoring station. Build: Wireless environmental monitor with OLED, SD card, MQTT. Parts: Reuse all parts.