Simpler Channel.

- Allow initializing in a static, without Forever.
- Remove ability to close, since in embedded enviromnents channels usually live forever and don't get closed.
- Remove MPSC restriction, it's MPMC now. Rename "mpsc" to "channel".
- `Sender` and `Receiver` are still available if you want to enforce a piece of code only has send/receive access, but are optional: you can send/receive directly into the Channel if you want.

examples/nrf/src/bin/channel.rs

@@ -0,0 +1,45 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt::unwrap;
+use embassy::blocking_mutex::raw::ThreadModeRawMutex;
+use embassy::channel::channel::Channel;
+use embassy::executor::Spawner;
+use embassy::time::{Duration, Timer};
+use embassy_nrf::gpio::{Level, Output, OutputDrive};
+use embassy_nrf::Peripherals;
+
+use defmt_rtt as _; // global logger
+use panic_probe as _;
+
+enum LedState {
+    On,
+    Off,
+}
+
+static CHANNEL: Channel<ThreadModeRawMutex, LedState, 1> = Channel::new();
+
+#[embassy::task]
+async fn my_task() {
+    loop {
+        CHANNEL.send(LedState::On).await;
+        Timer::after(Duration::from_secs(1)).await;
+        CHANNEL.send(LedState::Off).await;
+        Timer::after(Duration::from_secs(1)).await;
+    }
+}
+
+#[embassy::main]
+async fn main(spawner: Spawner, p: Peripherals) {
+    let mut led = Output::new(p.P0_13, Level::Low, OutputDrive::Standard);
+
+    unwrap!(spawner.spawn(my_task()));
+
+    loop {
+        match CHANNEL.recv().await {
+            LedState::On => led.set_high(),
+            LedState::Off => led.set_low(),
+        }
+    }
+}

examples/nrf/src/bin/channel_sender_receiver.rs

@@ -0,0 +1,52 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt::unwrap;
+use embassy::blocking_mutex::raw::NoopRawMutex;
+use embassy::channel::channel::{Channel, Receiver, Sender};
+use embassy::executor::Spawner;
+use embassy::time::{Duration, Timer};
+use embassy::util::Forever;
+use embassy_nrf::gpio::{AnyPin, Level, Output, OutputDrive, Pin};
+use embassy_nrf::Peripherals;
+
+use defmt_rtt as _; // global logger
+use panic_probe as _;
+
+enum LedState {
+    On,
+    Off,
+}
+
+static CHANNEL: Forever<Channel<NoopRawMutex, LedState, 1>> = Forever::new();
+
+#[embassy::task]
+async fn send_task(sender: Sender<'static, NoopRawMutex, LedState, 1>) {
+    loop {
+        sender.send(LedState::On).await;
+        Timer::after(Duration::from_secs(1)).await;
+        sender.send(LedState::Off).await;
+        Timer::after(Duration::from_secs(1)).await;
+    }
+}
+
+#[embassy::task]
+async fn recv_task(led: AnyPin, receiver: Receiver<'static, NoopRawMutex, LedState, 1>) {
+    let mut led = Output::new(led, Level::Low, OutputDrive::Standard);
+
+    loop {
+        match receiver.recv().await {
+            LedState::On => led.set_high(),
+            LedState::Off => led.set_low(),
+        }
+    }
+}
+
+#[embassy::main]
+async fn main(spawner: Spawner, p: Peripherals) {
+    let channel = CHANNEL.put(Channel::new());
+
+    unwrap!(spawner.spawn(send_task(channel.sender())));
+    unwrap!(spawner.spawn(recv_task(p.P0_13.degrade(), channel.receiver())));
+}

examples/nrf/src/bin/mpsc.rs

@@ -1,60 +0,0 @@
-#![no_std]
-#![no_main]
-#![feature(type_alias_impl_trait)]
-
-use defmt::unwrap;
-use embassy::blocking_mutex::raw::NoopRawMutex;
-use embassy::channel::mpsc::{self, Channel, Sender, TryRecvError};
-use embassy::executor::Spawner;
-use embassy::time::{Duration, Timer};
-use embassy::util::Forever;
-use embassy_nrf::gpio::{Level, Output, OutputDrive};
-use embassy_nrf::Peripherals;
-
-use defmt_rtt as _; // global logger
-use panic_probe as _;
-
-enum LedState {
-    On,
-    Off,
-}
-
-static CHANNEL: Forever<Channel<NoopRawMutex, LedState, 1>> = Forever::new();
-
-#[embassy::task(pool_size = 1)]
-async fn my_task(sender: Sender<'static, NoopRawMutex, LedState, 1>) {
-    loop {
-        let _ = sender.send(LedState::On).await;
-        Timer::after(Duration::from_secs(1)).await;
-        let _ = sender.send(LedState::Off).await;
-        Timer::after(Duration::from_secs(1)).await;
-    }
-}
-
-#[embassy::main]
-async fn main(spawner: Spawner, p: Peripherals) {
-    let mut led = Output::new(p.P0_13, Level::Low, OutputDrive::Standard);
-
-    let channel = CHANNEL.put(Channel::new());
-    let (sender, mut receiver) = mpsc::split(channel);
-
-    unwrap!(spawner.spawn(my_task(sender)));
-
-    // We could just loop on `receiver.recv()` for simplicity. The code below
-    // is optimized to drain the queue as fast as possible in the spirit of
-    // handling events as fast as possible. This optimization is benign when in
-    // thread mode, but can be useful when interrupts are sending messages
-    // with the channel having been created via with_critical_sections.
-    loop {
-        let maybe_message = match receiver.try_recv() {
-            m @ Ok(..) => m.ok(),
-            Err(TryRecvError::Empty) => receiver.recv().await,
-            Err(TryRecvError::Closed) => break,
-        };
-        match maybe_message {
-            Some(LedState::On) => led.set_high(),
-            Some(LedState::Off) => led.set_low(),
-            _ => (),
-        }
-    }
-}

examples/nrf/src/bin/uart_split.rs

@@ -3,10 +3,9 @@
 #![feature(type_alias_impl_trait)]
 
 use defmt::*;
-use embassy::blocking_mutex::raw::NoopRawMutex;
-use embassy::channel::mpsc::{self, Channel, Sender};
+use embassy::blocking_mutex::raw::ThreadModeRawMutex;
+use embassy::channel::channel::Channel;
 use embassy::executor::Spawner;
-use embassy::util::Forever;
 use embassy_nrf::peripherals::UARTE0;
 use embassy_nrf::uarte::UarteRx;
 use embassy_nrf::{interrupt, uarte, Peripherals};
@@ -14,7 +13,7 @@ use embassy_nrf::{interrupt, uarte, Peripherals};
 use defmt_rtt as _; // global logger
 use panic_probe as _;
 
-static CHANNEL: Forever<Channel<NoopRawMutex, [u8; 8], 1>> = Forever::new();
+static CHANNEL: Channel<ThreadModeRawMutex, [u8; 8], 1> = Channel::new();
 
 #[embassy::main]
 async fn main(spawner: Spawner, p: Peripherals) {
@@ -26,14 +25,11 @@ async fn main(spawner: Spawner, p: Peripherals) {
     let uart = uarte::Uarte::new(p.UARTE0, irq, p.P0_08, p.P0_06, config);
     let (mut tx, rx) = uart.split();
 
-    let c = CHANNEL.put(Channel::new());
-    let (s, mut r) = mpsc::split(c);
-
     info!("uarte initialized!");
 
     // Spawn a task responsible purely for reading
 
-    unwrap!(spawner.spawn(reader(rx, s)));
+    unwrap!(spawner.spawn(reader(rx)));
 
     // Message must be in SRAM
     {
@@ -48,19 +44,18 @@ async fn main(spawner: Spawner, p: Peripherals) {
     // back out the buffer we receive from the read
     // task.
     loop {
-        if let Some(buf) = r.recv().await {
-            info!("writing...");
-            unwrap!(tx.write(&buf).await);
-        }
+        let buf = CHANNEL.recv().await;
+        info!("writing...");
+        unwrap!(tx.write(&buf).await);
     }
 }
 
 #[embassy::task]
-async fn reader(mut rx: UarteRx<'static, UARTE0>, s: Sender<'static, NoopRawMutex, [u8; 8], 1>) {
+async fn reader(mut rx: UarteRx<'static, UARTE0>) {
     let mut buf = [0; 8];
     loop {
         info!("reading...");
         unwrap!(rx.read(&mut buf).await);
-        unwrap!(s.send(buf).await);
+        CHANNEL.send(buf).await;
     }
 }