Domain Embedded

by actionbook5c40d3ad7851No license1.5K starsListed Oct 8, 2026Updated Oct 8, 2026Repository updated 6 weeks ago

Use when developing embedded/no_std Rust. Keywords: embedded, no_std, microcontroller, MCU, ARM, RISC-V, bare metal, firmware, HAL, PAC, RTIC, embassy, interrupt, DMA, peripheral, GPIO, SPI, I2C, UART, embedded-hal, cortex-m, esp32, stm32, nrf, 嵌入式, 单片机, 固件, 裸机

Instructions onlySoftware Development

AI-generated overview

Guides Rust embedded and no_std development, covering constraints, frameworks, crates and hardware patterns.

What it does: This skill supplies domain guidance for writing embedded and no_std Rust, such as firmware for microcontrollers. It lays out constraints like no heap allocation, interrupt safety and peripheral ownership, and maps them to Rust patterns including heapless collections, critical sections and HAL singletons. It also compares frameworks (RTIC, Embassy, bare metal), lists key crates and shows a static peripheral code pattern with common mistakes. It produces advisory reference material rather than files or scripts.
When to use it: Use it when developing embedded or bare-metal Rust, including no_std firmware for MCUs such as ARM, RISC-V, STM32, ESP32 or nRF. It is relevant when working with HALs, PACs, interrupts, DMA or peripherals, or when choosing between RTIC, Embassy and bare-metal approaches.
Requirements: No scripts or tooling are required; it is instructions only. It assumes a Rust embedded project context, and its injected context reads .cargo/config.toml when present.

Project Context (Auto-Injected)

Target configuration: !cat .cargo/config.toml 2>/dev/null || echo "No .cargo/config.toml found"

Embedded Domain

Layer 3: Domain Constraints

Domain Constraints → Design Implications

Domain Rule	Design Constraint	Rust Implication
No heap	Stack allocation	heapless, no Box/Vec
No std	Core only	#![no_std]
Real-time	Predictable timing	No dynamic alloc
Resource limited	Minimal memory	Static buffers
Hardware safety	Safe peripheral access	HAL + ownership
Interrupt safe	No blocking in ISR	Atomic, critical sections

Critical Constraints

No Dynamic Allocation

RULE: Cannot use heap (no allocator)WHY: Deterministic memory, no OOMRUST: heapless::Vec<T, N>, arrays

RULE: Cannot use heap (no allocator)WHY: Deterministic memory, no OOMRUST: heapless::Vec<T, N>, arrays

Interrupt Safety

RULE: Shared state must be interrupt-safeWHY: ISR can preempt at any timeRUST: Mutex<RefCell<T>> + critical section

RULE: Shared state must be interrupt-safeWHY: ISR can preempt at any timeRUST: Mutex<RefCell<T>> + critical section

Hardware Ownership

RULE: Peripherals must have clear ownershipWHY: Prevent conflicting accessRUST: HAL takes ownership, singletons

RULE: Peripherals must have clear ownershipWHY: Prevent conflicting accessRUST: HAL takes ownership, singletons

Trace Down ↓

From constraints to design (Layer 2):

"Need no_std compatible data structures"    ↓ m02-resource: heapless collections    ↓ Static sizing: heapless::Vec<T, N>
"Need interrupt-safe state"    ↓ m03-mutability: Mutex<RefCell<Option<T>>>    ↓ m07-concurrency: Critical sections
"Need peripheral ownership"    ↓ m01-ownership: Singleton pattern    ↓ m12-lifecycle: RAII for hardware

"Need no_std compatible data structures"    ↓ m02-resource: heapless collections    ↓ Static sizing: heapless::Vec<T, N>
"Need interrupt-safe state"    ↓ m03-mutability: Mutex<RefCell<Option<T>>>    ↓ m07-concurrency: Critical sections
"Need peripheral ownership"    ↓ m01-ownership: Singleton pattern    ↓ m12-lifecycle: RAII for hardware

Layer Stack

Framework Comparison

Key Crates

Design Patterns

Code Pattern: Static Peripheral

rust

#![no_std]#![no_main]
use cortex_m::interrupt::{self, Mutex};use core::cell::RefCell;
static LED: Mutex<RefCell<Option<Led>>> = Mutex::new(RefCell::new(None));
#[entry]fn main() -> ! {    let dp = pac::Peripherals::take().unwrap();    let led = Led::new(dp.GPIOA);
    interrupt::free(|cs| {        LED.borrow(cs).replace(Some(led));    });
    loop {        interrupt::free(|cs| {            if let Some(led) = LED.borrow(cs).borrow_mut().as_mut() {                led.toggle();            }        });    }}

#![no_std]#![no_main]
use cortex_m::interrupt::{self, Mutex};use core::cell::RefCell;
static LED: Mutex<RefCell<Option<Led>>> = Mutex::new(RefCell::new(None));
#[entry]fn main() -> ! {    let dp = pac::Peripherals::take().unwrap();    let led = Led::new(dp.GPIOA);
    interrupt::free(|cs| {        LED.borrow(cs).replace(Some(led));    });
    loop {        interrupt::free(|cs| {            if let Some(led) = LED.borrow(cs).borrow_mut().as_mut() {                led.toggle();            }        });    }}

Common Mistakes

Mistake	Domain Violation	Fix
Using Vec	Heap allocation	heapless::Vec
No critical section	Race with ISR	Mutex + interrupt::free
Blocking in ISR	Missed interrupts	Defer to main loop
Unsafe peripheral	Hardware conflict	HAL ownership

Trace to Layer 1

Constraint	Layer 2 Pattern	Layer 1 Implementation
No heap	Static collections	heapless::Vec<T, N>
ISR safety	Critical sections	Mutex<RefCell<T>>
Hardware ownership	Singleton	take().unwrap()
no_std	Core-only	#![no_std], #![no_main]

Related Skills

Source and attribution

Source:actionbook/rust-skillsinskills/domain-embeddedat commit5c40d3a

License: No license

Content belongs to its original authors. SourceWeft indexes it from a public repository.

Report or request removal

Layer	Examples	Purpose
PAC	stm32f4, esp32c3	Register access
HAL	stm32f4xx-hal	Hardware abstraction
Framework	RTIC, Embassy	Concurrency
Traits	embedded-hal	Portable drivers

Framework	Style	Best For
RTIC	Priority-based	Interrupt-driven apps
Embassy	Async	Complex state machines
Bare metal	Manual	Simple apps

Purpose	Crate
Runtime (ARM)	cortex-m-rt
Panic handler	panic-halt, panic-probe
Collections	heapless
HAL traits	embedded-hal
Logging	defmt
Flash/debug	probe-run

Pattern	Purpose	Implementation
no_std setup	Bare metal	`#![no_std]` + `#![no_main]`
Entry point	Startup	`#[entry]` or embassy
Static state	ISR access	`Mutex<RefCell<Option<T>>>`
Fixed buffers	No heap	`heapless::Vec<T, N>`

When	See
Static memory	m02-resource
Interior mutability	m03-mutability
Interrupt patterns	m07-concurrency
Unsafe for hardware	unsafe-checker

Domain Embedded

Project Context (Auto-Injected)

Embedded Domain

Domain Constraints → Design Implications

Critical Constraints

No Dynamic Allocation

Interrupt Safety

Hardware Ownership

Trace Down ↓

Layer Stack

Framework Comparison

Key Crates

Design Patterns

Code Pattern: Static Peripheral

Common Mistakes

Trace to Layer 1

Related Skills

Source and attribution

More from actionbook/rust-skills

Rust Trait Explorer

Rust Symbol Analyzer

Rust Skill Creator

Rust Router

Rust Refactor Helper

Rust Daily

More in Software Development

Playground

M5 Onboard

Cardputer Buddy

Web Design Guidelines

Vercel React Native Skills

Vercel React Best Practices