在不同任务间共享外设

在多任务环境中，经常会有多个任务需要访问同一资源（如引脚、通信接口等）。Embassy在 embassy-sync crate中提供了多种同步原语（primitive）。

以下示例展示了在树莓派Pico板上，两个任务同时使用板载LED。

使用互斥锁（Mutex）共享

互斥锁是共享外设最简单的方式。

use defmt::*;
use embassy_executor::Spawner;
use embassy_rp::gpio;
use embassy_sync::blocking_mutex::raw::ThreadModeRawMutex;
use embassy_sync::mutex::Mutex;
use embassy_time::{Duration, Ticker};
use gpio::{AnyPin, Level, Output};
use {defmt_rtt as _, panic_probe as _};

type LedType = Mutex<ThreadModeRawMutex, Option<Output<'static, AnyPin>>>;
static LED: LedType = Mutex::new(None);

#[embassy_executor::main]
async fn main(spawner: Spawner) {
    let p = embassy_rp::init(Default::default());
    // 设置全局LED引用到真正的LED引脚
    let led = Output::new(AnyPin::from(p.PIN_25), Level::High);
    // 内部作用域是这样的:互斥锁被写入之后，MutexGuard就会被回收，
    // 从而释放互斥锁
    {
        *(LED.lock().await) = Some(led);
    }
    let dt = 100 * 1_000_000;
    let k = 1.003;

    unwrap!(spawner.spawn(toggle_led(&LED, Duration::from_nanos(dt))));
    unwrap!(spawner.spawn(toggle_led(&LED, Duration::from_nanos((dt as f64 * k) as u64))));
}

// 这个池（Pool）的大小是2，意味着你可以创建两个任务实例。
#[embassy_executor::task(pool_size = 2)]
async fn toggle_led(led: &'static LedType, delay: Duration) {
    let mut ticker = Ticker::every(delay);
    loop {
        {
            let mut led_unlocked = led.lock().await;
            if let Some(pin_ref) = led_unlocked.as_mut() {
                pin_ref.toggle();
            }
        }
        ticker.next().await;
    }
}

便于访问资源的结构体被定义为 LedType 。

为什么这么复杂

让我们逐层展开，看看为什么每一层都是必需的。

Mutex<RawMutexType, T>

互斥锁的存在是为了确保当一个任务首先获取资源并开始修改它时，其他想要写入的任务必须等待（如果没有任务锁定互斥锁， led.lock().await 会立即返回；如果在其他地方访问了它，则会产生阻塞）。

Option<T>

LED 变量需要在主任务外部定义，因为任务接受的引用需要 'static 生命周期。但是，如果它在主任务外部，它在初始化时不能指向任何引脚，因为引脚本身尚未初始化。因此，它被设置为 None 。

Output<AnyPin>

这表示引脚将被设置为输出。 AnyPin 可以是`embassy_rp::peripherals::PIN_25`，但是不这样做使 toggle_led 函数更通用。

使用通道（Channel）共享

通道是另一种确保对资源独占访问的方式。在不必须立即访问的情况下使用通道是个不错的选择，因为可以在排队时做其他事情。

use defmt::*;
use embassy_executor::Spawner;
use embassy_rp::gpio;
use embassy_sync::blocking_mutex::raw::ThreadModeRawMutex;
use embassy_sync::channel::{Channel, Sender};
use embassy_time::{Duration, Ticker};
use gpio::{AnyPin, Level, Output};
use {defmt_rtt as _, panic_probe as _};

enum LedState {
     Toggle,
}
static CHANNEL: Channel<ThreadModeRawMutex, LedState, 64> = Channel::new();

#[embassy_executor::main]
async fn main(spawner: Spawner) {
    let p = embassy_rp::init(Default::default());
    let mut led = Output::new(AnyPin::from(p.PIN_25), Level::High);

    let dt = 100 * 1_000_000;
    let k = 1.003;

    unwrap!(spawner.spawn(toggle_led(CHANNEL.sender(), Duration::from_nanos(dt))));
    unwrap!(spawner.spawn(toggle_led(CHANNEL.sender(), Duration::from_nanos((dt as f64 * k) as u64))));

    loop {
        match CHANNEL.receive().await {
            LedState::Toggle => led.toggle(),
        }
    }
}

// 这个池（Pool）的大小是2，意味着你可以创建两个任务实例。
#[embassy_executor::task(pool_size = 2)]
async fn toggle_led(control: Sender<'static, ThreadModeRawMutex, LedState, 64>, delay: Duration) {
    let mut ticker = Ticker::every(delay);
    loop {
        control.send(LedState::Toggle).await;
        ticker.next().await;
    }
}

这个示例用通道替换了互斥锁，并使用另一个任务（主循环，main loop）来控制LED。这种方法的优势在于只有一个任务引用外设，分离了关注点。然而，使用互斥锁的开销更小，如果你需要确保该操作在继续执行任务中的其他工作之前完成，那么可能需要使用互斥锁。