异步嵌入式 embassy

关键概念

执行器如何调度：一根栈跑多个任务

这是理解 embassy 的关键。它不给每个任务分栈，而是把每个任务编译成状态机，在同一根栈上轮流推进，空闲即睡眠：

多任务示例：闪灯 + 按键 + 传感器并发

三件事同时进行：LED 每 500ms 闪一次、按键按下打印、每秒读一次传感器。用三个独立 async 任务，代码像同步一样直白：

#![no_std]
#![no_main]
use panic_probe as _;
use defmt_rtt as _;
use embassy_executor::Spawner;
use embassy_time::{Timer, Duration};
use embassy_stm32::gpio::{Level, Output, Speed, Input, Pull};

// 独立任务：闪灯。#[task] 让它可被 spawn，静态分配无堆。
#[embassy_executor::task]
async fn blink(mut led: Output<'static>) {
    loop {
        led.toggle();
        // 异步延时：期间 CPU 让给别的任务 / 睡眠
        Timer::after(Duration::from_millis(500)).await;
    }
}

// 独立任务：等按键下降沿，即时响应无需轮询
#[embassy_executor::task]
async fn watch_button(mut button: Input<'static>) {
    loop {
        button.wait_for_falling_edge().await;  // 挂起直到按下
        defmt::info!("button pressed!");
        Timer::after(Duration::from_millis(50)).await;  // 消抖
    }
}

// 异步 main：拿到 Spawner 后启动各任务
#[embassy_executor::main]
async fn main(spawner: Spawner) {
    let p = embassy_stm32::init(Default::default());

    let led = Output::new(p.PC13, Level::High, Speed::Low);
    let button = Input::new(p.PA0, Pull::Up);

    // 启动两个独立任务；它们各自并发运行
    spawner.spawn(blink(led)).unwrap();
    spawner.spawn(watch_button(button)).unwrap();

    // main 自己也可以是个"任务"，这里每秒打印心跳
    loop {
        defmt::info!("heartbeat");
        Timer::after(Duration::from_secs(1)).await;
    }
}

select：带超时的异步 I/O

"等串口来数据，但最多等 1 秒"是嵌入式极常见的需求。用 select 让两个 Future 竞速：

use embassy_futures::select::{select, Either};
use embassy_time::{Timer, Duration};

async fn read_with_timeout(uart: &mut Uart<'static>, buf: &mut [u8]) {
    let recv = uart.read(buf);                              // Future A：收数据
    let timeout = Timer::after(Duration::from_secs(1));      // Future B：超时

    match select(recv, timeout).await {
        Either::First(_)  => defmt::info!("got data"),   // A 先完成
        Either::Second(_) => defmt::warn!("timeout"),    // B 先完成
    }
    // 未完成的那个 Future 被丢弃（drop），自动取消，无泄漏
}

embassy vs RTIC vs RTOS