Rust 2026 经验谈 - 嵌入式 Rust 概览

1
#![no_std]
2
#![no_main]
3

4
use cortex_m_rt::entry;
5

6
#[entry]
7
fn main() -> ! {
8
    // 嵌入式程序永不返回
9
    let dp = pac::Peripherals::take().unwrap();
10
    // 配置硬件...
11
    loop {
12
        // 主循环
13
    }
14
}
15

16
// panic handler：嵌入式没有 std，必须自己提供
17
#[panic_handler]
18
fn panic(_info: &core::panic::PanicInfo) -> ! {
19
    cortex_m::asm::bkpt(); // 断点
20
    loop {}
21
}

1
#![no_std]
2
#![no_main]
3
extern crate alloc;
4

5
use alloc::boxed::Box;
6
use alloc::vec::Vec;
7

8
// bump 分配器：适合嵌入式的简单堆
9
use bumpalo::Bump;
10

11
// 或 linked-list 分配器
12
use linked_list_allocator::LockedHeap;
13

14
#[global_allocator]
15
static HEAP: LockedHeap = LockedHeap::empty();
16

17
fn init_heap() {
18
    // 从 RAM 中划分堆区域
19
    unsafe extern "C" {
20
        static __heap_start: u32;
21
        static __heap_end: u32;
22
    }
23
    unsafe {
24
        let start = &__heap_start as *const u32 as usize;
25
        let end = &__heap_end as *const u32 as usize;
26
        HEAP.lock().init(start as *mut u8, end - start);
27
    }
28
}
29

30
#[entry]
31
fn main() -> ! {
32
    init_heap();
33

34
    // 现在可以用 Box 和 Vec 了
35
    let v: Vec<u32> = alloc::vec![1, 2, 3];
36
    let b = Box::new(42u32);
37

38
    loop {}
39
}

1
// ❌ 在 no_std 中不小心用了 std 特性
2
#![no_std]
3

4
fn bad() {
5
    // println! 需要 std::io
6
    // String 需要 alloc
7
    // Vec::new() 需要 alloc
8
    // std::thread::spawn 需要 OS
9
}
10

11
// ✓ 条件编译：同时支持 std 和 no_std
12
#![cfg_attr(not(feature = "std"), no_std)]
13

14
#[cfg(feature = "std")]
15
use std::collections::HashMap;
16

17
#[cfg(not(feature = "std"))]
18
use heapless::FnvIndexMap as HashMap; // no_std 的 map
19

20
pub fn process() {
21
    // 根据特性选择不同的实现
22
}

1
#![no_std]
2
#![no_main]
3

4
use cortex_m_rt::entry;
5
use stm32f4::pac::GPIOD; // PAC：最小封装
6

7
#[entry]
8
fn main() -> ! {
9
    let dp = stm32f4::pac::Peripherals::take().unwrap();
10

11
    // PAC 层：直接操作寄存器
12
    // 启用 GPIOD 时钟
13
    dp.RCC.ahb1enr.write(|w| w.gpioden().set_bit());
14

15
    // 设置 PD12 为输出
16
    dp.GPIOD.moder.write(|w| w.moder12().output());
17

18
    // 设置 PD12 高电平
19
    dp.GPIOD.odr.write(|w| w.odr12().set_bit());
20

21
    loop {}
22
}

1
#![no_std]
2
#![no_main]
3

4
use cortex_m_rt::entry;
5
use stm32f4xx_hal::{
6
    pac,
7
    prelude::*,
8
    gpio::{Output, PushPull},
9
};
10

11
#[entry]
12
fn main() -> ! {
13
    let dp = pac::Peripherals::take().unwrap();
14
    let rcc = dp.RCC.constrain();
15
    let clocks = rcc.cfgr.sysclk(84.MHz()).freeze();
16

17
    let gpioa = dp.GPIOA.split();
18
    let mut led = gpioa.pa5.into_push_pull_output();
19

20
    // HAL 层：高级抽象
21
    led.set_high();
22
    led.set_low();
23
    led.toggle();
24

25
    loop {}
26
}

1
#![no_std]
2
#![no_main]
3

4
use embassy_executor::Spawner;
5
use embassy_stm32::Config;
6

7
#[embassy_executor::main]
8
async fn main(spawner: Spawner) {
9
    let config = Config::default();
10
    let p = embassy_stm32::init(config);
11

12
    // 启动异步任务
13
    spawner.spawn(blink_led(p.PA5)).ok();
14
    spawner.spawn(read_button(p.PC13)).ok();
15
}
16

17
#[embassy_executor::task]
18
async fn blink_led(pin: embassy_stm32::gpio::AnyPin) {
19
    use embassy_stm32::gpio::{Level, Output};
20
    let mut led = Output::new(pin, Level::Low, embassy_stm32::gpio::Speed::Low);
21

22
    loop {
23
        led.set_high();
24
        embassy_time::Timer::after_millis(500).await;
25
        led.set_low();
26
        embassy_time::Timer::after_millis(500).await;
27
    }
28
}
29

30
#[embassy_executor::task]
31
async fn read_button(pin: embassy_stm32::gpio::AnyPin) {
32
    use embassy_stm32::gpio::{Input, Pull};
33
    let button = Input::new(pin, Pull::Up);
34

35
    loop {
36
        if button.is_low() {
37
            defmt::info!("Button pressed!");
38
        }
39
        embassy_time::Timer::after_millis(10).await;
40
    }
41
}

1
use embassy_stm32::usart::{Config, Uart};
2
use embassy_stm32::mode::Async;
3

4
#[embassy_executor::task]
5
async fn uart_task(
6
    tx: embassy_stm32::usart::Tx<'static, Async>,
7
    rx: embassy_stm32::usart::Rx<'static, Async>,
8
) {
9
    let config = Config::default();
10
    let mut uart = Uart::new(peri, rx, tx, irqs, config);
11

12
    loop {
13
        // 异步读取——不阻塞其他任务
14
        let mut buf = [0u8; 64];
15
        match uart.read(&mut buf).await {
16
            Ok(n) => {
17
                defmt::info!("Received {} bytes", n);
18
                // Echo back
19
                uart.write(&buf[..n]).await.ok();
20
            }
21
            Err(e) => {
22
                defmt::error!("UART error: {:?}", e);
23
            }
24
        }
25
    }
26
}

1
use embassy_stm32::interrupt::InterruptExt;
2

3
// embassy 的中断驱动模式：中断唤醒 executor
4
#[embassy_executor::task]
5
async fn spi_task(
6
    spi: embassy_stm32::spi::Spi<'static, Async>,
7
) {
8
    let mut spi = spi;
9

10
    // SPI 读写自动挂起当前任务，直到中断触发
11
    let mut buf = [0u8; 32];
12
    spi.read(&mut buf).await.ok();
13
    spi.write(&buf).await.ok();
14
}
15

16
// 配置中断
17
fn setup_interrupts() {
18
    use embassy_stm32::interrupt::SPI1;
19
    SPI1::set_priority(embassy_stm32::interrupt::Priority::P3);
20
}

1
use embassy_sync::channel::Channel;
2
use embassy_time::Timer;
3

4
static CHANNEL: Channel<CriticalSectionRawMutex, u32, 1> = Channel::new();
5

6
#[embassy_executor::task]
7
async fn producer() {
8
    let mut counter = 0u32;
9
    loop {
10
        CHANNEL.send(counter).await;
11
        defmt::info!("Sent: {}", counter);
12
        counter += 1;
13
        Timer::after_secs(1).await;
14
    }
15
}
16

17
#[embassy_executor::task]
18
async fn consumer() {
19
    loop {
20
        let value = CHANNEL.receive().await;
21
        defmt::info!("Received: {}", value);
22
    }
23
}

1
use defmt::{info, warn, error, trace, debug};
2

3
fn process_sensor(value: u16) {
4
    trace!("Entering process_sensor");  // 零运行时开销（如果编译时过滤掉）
5

6
    if value > 1000 {
7
        warn!("Sensor value high: {}", value); // 只传输 value 的 2 字节
8
    }
9

10
    info!("Sensor reading: {}", value);
11

12
    if value == 0 {
13
        error!("Sensor failure!");
14
    }
15
}

1
// defmt 的格式化语法与 std 不同
2
// ✓ defmt 使用 {=u8}、{=?} 等显式类型标注
3
defmt::info!("Value: {=u8}, Hex: {=u8:#x}", value, value);
4

5
// ✓ 实现 Format trait 自定义格式
6
use defmt::Format;
7

8
#[derive(Format)]
9
struct SensorData {
10
    id: u8,
11
    value: u16,
12
    timestamp: u32,
13
}
14

15
defmt::info!("Sensor: {:?}", SensorData { id: 1, value: 42, timestamp: 1000 });

1
常见问题：
2
  1. Windows 上 ST-Link 驱动冲突
3
     → 安装 Zadig，替换 ST-Link 的 WinUSB 驱动
4
     → 或用 CMSIS-DAP 探针（免驱动）
5

6
  2. Linux 上权限不足
7
     → 添加 udev 规则：
8
     sudo cp probe-rs/udev/70-probe-rs.rules /etc/udev/rules.d/
9
     sudo udevadm control --reload
10

11
  3. macOS 上无需额外驱动
12

13
  4. 多探针同时连接
14
     → probe-rs list 查看序列号
15
     → probe-rs run --probe <serial> --chip ...

1
#![no_std]
2
#![no_main]
3

4
use rtic::app;
5

6
#[app(device = stm32f4xx_hal::pac, peripherals = true)]
7
mod app {
8
    use stm32f4xx_hal::{
9
        prelude::*,
10
        gpio::{Output, PushPull, PA5},
11
        timer::Timer,
12
    };
13

14
    #[shared]
15
    struct Shared {
16
        counter: u32,
17
    }
18

19
    #[local]
20
    struct Local {
21
        led: PA5<Output<PushPull>>,
22
    }
23

24
    #[init]
25
    fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) {
26
        let dp = cx.device;
27
        let rcc = dp.RCC.constrain();
28
        let clocks = rcc.cfgr.sysclk(84.MHz()).freeze();
29
        let gpioa = dp.GPIOA.split();
30
        let led = gpioa.pa5.into_push_pull_output();
31

32
        // 启动定时器中断
33
        let mut timer = Timer::new(dp.TIM2, &clocks);
34
        timer.start(1.Hz());
35
        timer.listen();
36

37
        (Shared { counter: 0 }, Local { led }, init::Monotonics())
38
    }
39

40
    #[task(binds = TIM2, shared = [counter], local = [led])]
41
    fn timer_tick(cx: timer_tick::Context) {
42
        cx.shared.counter.lock(|c| *c += 1);
43
        cx.local.led.toggle();
44
    }
45
}

1
#![no_std]
2
#![no_main]
3

4
use embassy_executor::Spawner;
5
use embassy_stm32::Config;
6

7
#[embassy_executor::main]
8
async fn main(spawner: Spawner) {
9
    let p = embassy_stm32::init(Config::default());
10
    spawner.spawn(led_task(p.PA5)).ok();
11
}
12

13
#[embassy_executor::task]
14
async fn led_task(pin: embassy_stm32::gpio::AnyPin) {
15
    use embassy_stm32::gpio::{Level, Output};
16
    let mut led = Output::new(pin, Level::Low, embassy_stm32::gpio::Speed::Low);
17
    loop {
18
        led.set_high();
19
        embassy_time::Timer::after_millis(500).await;
20
        led.set_low();
21
        embassy_time::Timer::after_millis(500).await;
22
    }
23
}