ESP32 support

Cargo.toml

@@ -1,7 +1,9 @@
 [workspace]
 resolver = "2"
 members = ["crates/*"]
-exclude = ["fuzz"]
+# ziggurat-phy-esp and ziggurat-esp only build for an ESP32-C6 (riscv32imac) with esp-hal;
+# excluded so host `cargo build` over the workspace doesn't try (and fail) to compile them.
+exclude = ["fuzz", "crates/ziggurat-phy-esp", "crates/ziggurat-esp"]
 
 [workspace.package]
 version = "0.1.0"
@@ -11,6 +13,7 @@ license = "Apache-2.0"
 authors = []
 repository = "https://github.com/zigpy/ziggurat"
 
+
 [workspace.dependencies]
 ziggurat-ieee-802154 = { path = "crates/ziggurat-ieee-802154", version = "0.1.0" }
 ziggurat-phy = { path = "crates/ziggurat-phy", version = "0.1.0" }

README.md

@@ -55,6 +55,19 @@ Ziggurat can be set up as a regular ZHA radio in **Home Assistant 2026.7.0** or
 4. When ZHA asks for the radio type, pick **Ziggurat** and migrate your existing network (or set a new one up).
 5. Done.
 
+### ESP32-C6 firmware
+Ziggurat can also run on-chip on an ESP32-C6, using its built-in 802.15.4 radio and
+exposing the same JSON API over USB-Serial-JTAG: no separate RCP radio or host.
+
+```bash
+cd crates/ziggurat-esp
+cargo build --release
+espflash flash --no-stub --chip esp32c6 --port <PORT> \
+  target/riscv32imac-unknown-none-elf/release/ziggurat-esp
+```
+
+- USB-Serial-JTAG carries the JSON API; UART0 on GPIO16 @ 460800 carries logs, the debug heartbeat, and panic backtraces.
+
 ### Development
 Ziggurat aims to implement the portions of a Zigbee stack used by normal Home Assistant
 users, not the entire binder of Zigbee specification verbatim. It is nearly feature-complete

crates/ziggurat-driver/Cargo.toml

@@ -13,10 +13,45 @@ ziggurat-ieee-802154.workspace = true
 ziggurat-phy.workspace = true
 ziggurat-zigbee.workspace = true
 
-abstract-bits = "0.2.0"
+abstract-bits = { git = "https://github.com/yara-blue/abstract-bits.git", version = "0.2.0" }
 arbitrary-int = "2.1.1"
-tracing = "0.1"
-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"] }
+futures = { version = "0.3", default-features = false }
+tracing = { version = "0.1", default-features = false }
+thiserror = { version = "2.0.12", default-features = false }
+
+# Host (tokio) runtime backend.
+parking_lot = { version = "0.12.4", optional = true }
+rand = { version = "0.10.1", optional = true }
+tokio = { version = "1.43.0", features = [
+    "rt",
+    "macros",
+    "time",
+    "sync",
+    "io-util",
+], optional = true }
+
+# Embassy runtime adapter. The MCU binary provides the executor + arch (via esp-rtos), so
+# the base dependency pulls no arch feature; the `embassy-host` feature adds the std
+# executor so the same adapter can run on the host bridged to tokio.
+embassy-executor = { version = "0.10", optional = true }
+embassy-time = { version = "0.5", optional = true }
+embassy-sync = { version = "0.8", optional = true }
+spin = { version = "0.9", default-features = false, features = [
+    "spin_mutex",
+], optional = true }
+
+[features]
+default = ["tokio"]
+# The host runtime: tokio executor, parking_lot locks, OS randomness.
+tokio = ["dep:tokio", "dep:parking_lot", "dep:rand"]
+# The embassy runtime adapter (and its no_std-friendly sync primitives), for the MCU.
+# Mutually exclusive with `tokio` at the `sync`/`runtime`/`rng` seam.
+embassy = ["dep:embassy-executor", "dep:embassy-time", "dep:embassy-sync", "dep:spin"]
+# Run the embassy adapter on the host, bridged to a tokio reactor (for tests).
+embassy-host = [
+    "embassy",
+    "dep:tokio",
+    "embassy-executor/platform-std",
+    "embassy-executor/executor-thread",
+    "embassy-time/std",
+]

crates/ziggurat-driver/src/lib.rs

@@ -1,3 +1,15 @@
+#![no_std]
+
+extern crate alloc;
+
+// The host bridge spawns an OS thread for the embassy executor; that path alone needs std.
+#[cfg(feature = "embassy-host")]
+extern crate std;
+
+pub mod rng;
+pub mod runtime;
+pub mod signal;
+pub mod sync;
 pub mod zigbee_stack;
 
 pub use ziggurat_ieee_802154;

crates/ziggurat-driver/src/rng.rs

@@ -0,0 +1,53 @@
+//! Randomness crate.
+
+/// A uniform `f32` in `[0, 1)`, for jitter scaling.
+pub fn random_f32() -> f32 {
+    let mut bytes = [0u8; 4];
+    fill_bytes(&mut bytes);
+    // 24-bit mantissa worth of entropy mapped into [0, 1)
+    (u32::from_le_bytes(bytes) >> 8) as f32 / (1u32 << 24) as f32
+}
+
+/// A uniform `u16`, for stochastic address allocation.
+pub fn random_u16() -> u16 {
+    let mut bytes = [0u8; 2];
+    fill_bytes(&mut bytes);
+    u16::from_le_bytes(bytes)
+}
+
+/// `N` random bytes, for key material.
+pub fn random_array<const N: usize>() -> [u8; N] {
+    let mut bytes = [0u8; N];
+    fill_bytes(&mut bytes);
+    bytes
+}
+
+#[cfg(feature = "tokio")]
+fn fill_bytes(buf: &mut [u8]) {
+    use rand::RngExt;
+    rand::rng().fill(buf);
+}
+
+#[cfg(all(feature = "embassy", not(feature = "tokio")))]
+pub use embassy_rng::{fill_bytes, install};
+
+#[cfg(all(feature = "embassy", not(feature = "tokio")))]
+mod embassy_rng {
+    use crate::sync::Mutex;
+    use alloc::boxed::Box;
+
+    type FillFn = Box<dyn FnMut(&mut [u8]) + Send>;
+
+    static FILL: Mutex<Option<FillFn>> = Mutex::new(None);
+
+    /// Install the byte source. The MCU binary backs this with the SoC hardware RNG.
+    pub fn install(fill: FillFn) {
+        *FILL.lock() = Some(fill);
+    }
+
+    pub fn fill_bytes(buf: &mut [u8]) {
+        let mut guard = FILL.lock();
+        let fill = guard.as_mut().expect("rng::install was never called");
+        fill(buf);
+    }
+}