OpenDevicePartnership · RobertZ2011 · Nov 3, 2025 · Nov 3, 2025 · Nov 3, 2025 · Nov 3, 2025
@@ -21,6 +21,7 @@ defmt = { workspace = true, optional = true }
 document-features.workspace = true
 embassy-sync.workspace = true
 embassy-time.workspace = true
+embassy-futures.workspace = true
 embedded-batteries-async.workspace = true
 embedded-cfu-protocol.workspace = true
 embedded-hal-async.workspace = true
@@ -49,7 +50,6 @@ cortex-m.workspace = true
 
 [dev-dependencies]
 critical-section = { workspace = true, features = ["std"] }
-embassy-futures.workspace = true
 embassy-sync = { workspace = true, features = ["std"] }
 embassy-time = { workspace = true, features = ["std", "generic-queue-8"] }
 embassy-time-driver = { workspace = true }

@@ -0,0 +1,43 @@
+//! Common traits for event senders and receivers
+
+use embassy_sync::channel::{DynamicReceiver, DynamicSender};
-use embassy_sync::channel::{DynamicReceiver, DynamicSender};
+use embassy_sync::channel::{DynamicReceiver, DynamicSender};
+use core::future::Future;
-use embassy_sync::channel::{DynamicReceiver, DynamicSender};
+use embassy_sync::channel::{DynamicReceiver, DynamicSender};
+use core::future::Future;
+
+/// Common event sender trait
+pub trait Sender<E> {
+    /// Attempt to send an event
+    ///
+    /// Return none if the event cannot currently be sent
+    fn try_send(&mut self, event: E) -> Option<()>;
+    /// Send an event
+    fn send(&mut self, event: E) -> impl Future<Output = ()>;
+}
+
+/// Common event receiver trait
+pub trait Receiver<E> {
+    /// Attempt to receive an event
+    ///
+    /// Return none if there are no pending events
+    fn try_next(&mut self) -> Option<E>;
+    /// Receiver an event
-/// Common event sender trait
-pub trait Sender<E> {
-    /// Attempt to send an event
-    ///
-    /// Return none if the event cannot currently be sent
-    fn try_send(&mut self, event: E) -> Option<()>;
-    /// Send an event
-    fn send(&mut self, event: E) -> impl Future<Output = ()>;
-}
-
-/// Common event receiver trait
-pub trait Receiver<E> {
-    /// Attempt to receive an event
-    ///
-    /// Return none if there are no pending events
-    fn try_next(&mut self) -> Option<E>;
-    /// Receiver an event
+/// Abstraction over components that can send events of type `E`.
+///
+/// This trait provides a common interface for event senders backed by
+/// channel-like primitives (for example, [`DynamicSender`]). It allows code
+/// to be written against this trait instead of a concrete channel type.
+///
+/// # Semantics
+///
+/// - [`Sender::try_send`] is **non-blocking**: it attempts to enqueue an
+///   event immediately and returns:
+///   - `Some(())` if the event was successfully enqueued.
+///   - `None` if the event cannot currently be sent. In this crate's
+///     implementations, this covers both the channel being full and the
+///     receiver side being closed.
+/// - [`Sender::send`] returns a future that will **asynchronously** send
+///   the event according to the underlying implementation's semantics.
+pub trait Sender<E> {
+    /// Attempt to send an event without blocking.
+    ///
+    /// Returns `Some(())` on success.
+    ///
+    /// Returns `None` if the event cannot currently be sent. For the
+    /// provided `DynamicSender` implementation, this occurs when the
+    /// underlying channel is full or the receiver side has been closed.
+    fn try_send(&mut self, event: E) -> Option<()>;
+    /// Send an event, waiting asynchronously until it can be enqueued.
+    ///
+    /// The returned future completes once the event has been sent according
+    /// to the semantics of the underlying sender implementation.
+    fn send(&mut self, event: E) -> impl Future<Output = ()>;
+}
+
+/// Abstraction over components that can receive events of type `E`.
+///
+/// This trait provides a common interface for event receivers backed by
+/// channel-like primitives (for example, [`DynamicReceiver`]). It allows
+/// consumers to be written against this trait instead of a concrete channel
+/// type.
+///
+/// # Semantics
+///
+/// - [`Receiver::try_next`] is **non-blocking**: it attempts to receive an
+///   event immediately and returns:
+///   - `Some(event)` if an event is available.
+///   - `None` if no event can currently be received. In this crate's
+///     implementations, this covers both the channel being empty and the
+///     sender side being closed.
+/// - [`Receiver::wait_next`] returns a future that will **asynchronously**
+///   wait for and yield the next event.
+pub trait Receiver<E> {
+    /// Attempt to receive the next event without blocking.
+    ///
+    /// Returns `Some(event)` if an event is immediately available.
+    ///
+    /// Returns `None` if there are no pending events. For the provided
+    /// `DynamicReceiver` implementation, this occurs when the underlying
+    /// channel is empty or the sender side has been closed.
+    fn try_next(&mut self) -> Option<E>;
+    /// Receive the next event, waiting asynchronously until one is available.
-    /// Receiver an event
+    /// Receive an event
-    /// Receiver an event
+    /// Receive an event
-/// Common event sender trait
-pub trait Sender<E> {
-    /// Attempt to send an event
-    ///
-    /// Return none if the event cannot currently be sent
-    fn try_send(&mut self, event: E) -> Option<()>;
-    /// Send an event
-    fn send(&mut self, event: E) -> impl Future<Output = ()>;
-}
-
-/// Common event receiver trait
-pub trait Receiver<E> {
-    /// Attempt to receive an event
-    ///
-    /// Return none if there are no pending events
-    fn try_next(&mut self) -> Option<E>;
-    /// Receiver an event
+/// Abstraction over components that can send events of type `E`.
+///
+/// This trait provides a common interface for event senders backed by
+/// channel-like primitives (for example, [`DynamicSender`]). It allows code
+/// to be written against this trait instead of a concrete channel type.
+///
+/// # Semantics
+///
+/// - [`Sender::try_send`] is **non-blocking**: it attempts to enqueue an
+///   event immediately and returns:
+///   - `Some(())` if the event was successfully enqueued.
+///   - `None` if the event cannot currently be sent. In this crate's
+///     implementations, this covers both the channel being full and the
+///     receiver side being closed.
+/// - [`Sender::send`] returns a future that will **asynchronously** send
+///   the event according to the underlying implementation's semantics.
+pub trait Sender<E> {
+    /// Attempt to send an event without blocking.
+    ///
+    /// Returns `Some(())` on success.
+    ///
+    /// Returns `None` if the event cannot currently be sent. For the
+    /// provided `DynamicSender` implementation, this occurs when the
+    /// underlying channel is full or the receiver side has been closed.
+    fn try_send(&mut self, event: E) -> Option<()>;
+    /// Send an event, waiting asynchronously until it can be enqueued.
+    ///
+    /// The returned future completes once the event has been sent according
+    /// to the semantics of the underlying sender implementation.
+    fn send(&mut self, event: E) -> impl Future<Output = ()>;
+}
+
+/// Abstraction over components that can receive events of type `E`.
+///
+/// This trait provides a common interface for event receivers backed by
+/// channel-like primitives (for example, [`DynamicReceiver`]). It allows
+/// consumers to be written against this trait instead of a concrete channel
+/// type.
+///
+/// # Semantics
+///
+/// - [`Receiver::try_next`] is **non-blocking**: it attempts to receive an
+///   event immediately and returns:
+///   - `Some(event)` if an event is available.
+///   - `None` if no event can currently be received. In this crate's
+///     implementations, this covers both the channel being empty and the
+///     sender side being closed.
+/// - [`Receiver::wait_next`] returns a future that will **asynchronously**
+///   wait for and yield the next event.
+pub trait Receiver<E> {
+    /// Attempt to receive the next event without blocking.
+    ///
+    /// Returns `Some(event)` if an event is immediately available.
+    ///
+    /// Returns `None` if there are no pending events. For the provided
+    /// `DynamicReceiver` implementation, this occurs when the underlying
+    /// channel is empty or the sender side has been closed.
+    fn try_next(&mut self) -> Option<E>;
+    /// Receive the next event, waiting asynchronously until one is available.
-    /// Receiver an event
+    /// Receive an event
-    /// Receiver an event
+    /// Receive an event
+    fn wait_next(&mut self) -> impl Future<Output = E>;
+}
+
+impl<E> Sender<E> for DynamicSender<'_, E> {
+    fn try_send(&mut self, event: E) -> Option<()> {
+        DynamicSender::try_send(self, event).ok()
+    }
+
+    fn send(&mut self, event: E) -> impl Future<Output = ()> {
+        DynamicSender::send(self, event)
+    }
+}
+
+impl<E> Receiver<E> for DynamicReceiver<'_, E> {
+    fn try_next(&mut self) -> Option<E> {
+        self.try_receive().ok()
+    }
+
+    fn wait_next(&mut self) -> impl Future<Output = E> {
+        self.receive()
+    }
+}
@@ -17,6 +17,7 @@ pub mod buffer;
 pub mod cfu;
 pub mod comms;
 pub mod ec_type;
+pub mod event;
 pub mod fmt;
 pub mod hid;
 pub mod init;