Test: embassy on host??

Author: puddly

crates/ziggurat-driver/Cargo.toml

@@ -21,3 +21,20 @@ parking_lot = "0.12.4"
 rand = "0.10.1"
 thiserror = "2.0.12"
 tokio = { version = "1.43.0", features = ["rt", "macros", "time", "sync", "io-util"] }
+
+# The embassy runtime adapter, host-runnable via arch-std so it can stand in for tokio.
+embassy-executor = { version = "0.7", features = [
+    "arch-std",
+    "executor-thread",
+], optional = true }
+embassy-time = { version = "0.4", features = ["std"], optional = true }
+embassy-sync = { version = "0.6", optional = true }
+spin = { version = "0.9", default-features = false, features = [
+    "spin_mutex",
+], optional = true }
+
+[features]
+default = []
+# Select the embassy runtime adapter (and its no_std-friendly sync primitives) instead of
+# the default tokio one. Mutually overrides tokio at the `sync`/`runtime` seam.
+embassy = ["dep:embassy-executor", "dep:embassy-time", "dep:embassy-sync", "dep:spin"]

crates/ziggurat-driver/src/runtime.rs

@@ -153,3 +153,92 @@ impl Spawn for TokioSpawner {
         while tasks.join_next().await.is_some() {}
     }
 }
+
+/// The embassy runtime adapter. Host-runnable through `arch-std` so it can stand in for
+/// tokio, and the same impl drives the MCU once an esp PHY backs it.
+#[cfg(feature = "embassy")]
+pub use embassy_impl::{EmbassyRuntime, EmbassySpawner};
+
+#[cfg(feature = "embassy")]
+mod embassy_impl {
+    use super::{RtInstant, Runtime, Spawn, SpawnedTask};
+    use core::future::Future;
+    use core::ops::Add;
+    use core::time::Duration;
+
+    const fn to_embassy(duration: Duration) -> embassy_time::Duration {
+        embassy_time::Duration::from_micros(duration.as_micros() as u64)
+    }
+
+    const fn from_embassy(duration: embassy_time::Duration) -> Duration {
+        Duration::from_micros(duration.as_micros())
+    }
+
+    /// Wraps `embassy_time::Instant` so the trait's `core::time::Duration` arithmetic
+    /// works against embassy's own `Duration` type.
+    #[derive(Copy, Clone)]
+    pub struct EmbassyInstant(embassy_time::Instant);
+
+    impl Add<Duration> for EmbassyInstant {
+        type Output = Self;
+
+        fn add(self, rhs: Duration) -> Self {
+            Self(self.0 + to_embassy(rhs))
+        }
+    }
+
+    impl RtInstant for EmbassyInstant {
+        fn saturating_duration_since(self, earlier: Self) -> Duration {
+            from_embassy(self.0.saturating_duration_since(earlier.0))
+        }
+    }
+
+    pub struct EmbassyRuntime;
+
+    impl Runtime for EmbassyRuntime {
+        type Instant = EmbassyInstant;
+        type Spawner = EmbassySpawner;
+
+        fn now() -> Self::Instant {
+            EmbassyInstant(embassy_time::Instant::now())
+        }
+
+        fn sleep(duration: Duration) -> impl Future<Output = ()> + Send {
+            embassy_time::Timer::after(to_embassy(duration))
+        }
+
+        fn sleep_until(deadline: Self::Instant) -> impl Future<Output = ()> + Send {
+            embassy_time::Timer::at(deadline.0)
+        }
+    }
+
+    /// Each detached task runs in one slot of this fixed pool — embassy has no dynamic
+    /// spawn, so the size bounds the stack's concurrent background tasks (long-lived
+    /// reactors plus the transient ZDP/indirect/route-request ones).
+    #[embassy_executor::task(pool_size = 24)]
+    async fn task_runner(task: SpawnedTask) {
+        task.await;
+    }
+
+    /// Spawns into the embassy executor. Holds a [`SendSpawner`](embassy_executor::SendSpawner)
+    /// so it is `Send + Sync`; obtained from the executor at startup.
+    pub struct EmbassySpawner(embassy_executor::SendSpawner);
+
+    impl EmbassySpawner {
+        pub const fn new(spawner: embassy_executor::SendSpawner) -> Self {
+            Self(spawner)
+        }
+    }
+
+    impl Spawn for EmbassySpawner {
+        fn spawn(&self, task: SpawnedTask) {
+            if self.0.spawn(task_runner(task)).is_err() {
+                tracing::error!("embassy task pool exhausted; background task dropped");
+            }
+        }
+
+        // Embassy cannot cancel spawned tasks; the MCU stack is never replaced, so there
+        // is nothing to stop.
+        async fn shutdown(&self) {}
+    }
+}

crates/ziggurat-driver/src/sync.rs

@@ -1,10 +1,60 @@
-//! The synchronization primitives the stack rests on: a blocking [`Mutex`] and an async
-//! [`Notify`].
+//! The synchronization primitives the stack rests on: a blocking [`Mutex`], an async
+//! [`AsyncMutex`], and an [`Notify`].
+//!
+//! Everything in the driver imports these from here rather than naming `parking_lot`,
+//! `tokio`, `spin`, or `embassy-sync` directly, so this module is the single seam where
+//! the implementation is chosen by the `embassy` feature. The blocking [`Mutex`] must
+//! never be held across an `.await` (the protocol core's
+//! [`CoreGuard`](crate::zigbee_stack::CoreGuard) enforces this by being `!Send`); use
+//! [`AsyncMutex`] for the few guards that genuinely outlive an await point.
 
-pub use parking_lot::{Mutex, MutexGuard};
-pub use tokio::sync::Notify;
+#[cfg(not(feature = "embassy"))]
+mod imp {
+    pub use parking_lot::{Mutex, MutexGuard};
+    pub use tokio::sync::Mutex as AsyncMutex;
+    pub use tokio::sync::Notify;
+}
 
-/// An async mutex, for the few places a guard is held across an `.await` (the radio
-/// stream and reset receivers). Distinct from the blocking [`Mutex`], which must never
-/// span a yield; reach for this only when the guard genuinely outlives an await point.
-pub use tokio::sync::Mutex as AsyncMutex;
+#[cfg(feature = "embassy")]
+mod imp {
+    use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+
+    // A spinlock is a guard-returning, `Sync`, no_std mutex; on the cooperative
+    // single-core MCU executor it never actually spins, and the stack never holds a guard
+    // across an `.await`, so the lock window is always brief.
+    pub use spin::{Mutex, MutexGuard};
+
+    /// The async mutex, for guards held across an `.await` (the radio stream + reset
+    /// receivers). Pinned to the critical-section raw mutex.
+    pub type AsyncMutex<T> = embassy_sync::mutex::Mutex<CriticalSectionRawMutex, T>;
+
+    /// A parameterless wake matching `tokio::sync::Notify`'s surface.
+    ///
+    /// Built over embassy's single-slot [`Signal`](embassy_sync::signal::Signal):
+    /// `notify_one` stores one permit and coalesces repeats; `notified` consumes it — the
+    /// same single-waiter contract every wake in the stack relies on.
+    #[derive(Default)]
+    pub struct Notify(embassy_sync::signal::Signal<CriticalSectionRawMutex, ()>);
+
+    impl Notify {
+        pub const fn new() -> Self {
+            Self(embassy_sync::signal::Signal::new())
+        }
+
+        pub fn notify_one(&self) {
+            self.0.signal(());
+        }
+
+        pub async fn notified(&self) {
+            self.0.wait().await;
+        }
+    }
+
+    impl core::fmt::Debug for Notify {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+            f.write_str("Notify")
+        }
+    }
+}
+
+pub use imp::*;