Merge pull request #883 from embassy-rs/split

Split embassy crate into embassy-executor, embassy-util.

.github/workflows/rust.yml

@@ -69,4 +69,4 @@ jobs:
     steps:
       - uses: actions/checkout@v2
       - name: Test
-        run: cd embassy && cargo test
+        run: cd embassy-util && cargo test

.vscode/settings.json

@@ -12,10 +12,15 @@
     //"embassy-net/medium-ethernet",
     //"embassy-net/tcp",
     //"embassy-net/pool-16",
+    //"time-tick-16mhz",
+    //"defmt-timestamp-uptime",
     "nightly",
+    //"unstable-traits",
   ],
   "rust-analyzer.linkedProjects": [
     // Declare for the target you wish to develop
+    //"embassy-executor/Cargo.toml",
+    //"embassy-util/Cargo.toml",
     "examples/nrf/Cargo.toml",
     // "examples/rp/Cargo.toml",
     // "examples/std/Cargo.toml",

README.md

@@ -16,7 +16,7 @@ Rust's <a href="https://rust-lang.github.io/async-book/">async/await</a> allows
   - <a href="https://docs.embassy.dev/embassy-nrf/">embassy-nrf</a>, for the Nordic Semiconductor nRF52, nRF53, nRF91 series.
 
 - **Time that Just Works** - 
-No more messing with hardware timers. <a href="https://docs.embassy.dev/embassy/git/thumbv7em-none-eabihf/time/index.html">embassy::time</a> provides Instant, Duration and Timer types that are globally available and never overflow.
+No more messing with hardware timers. <a href="https://docs.embassy.dev/embassy/git/thumbv7em-none-eabihf/time/index.html">embassy_executor::time</a> provides Instant, Duration and Timer types that are globally available and never overflow.
 
 - **Real-time ready** - 
 Tasks on the same async executor run cooperatively, but you can create multiple executors with different priorities, so that higher priority tasks preempt lower priority ones. See the <a href="https://github.com/embassy-rs/embassy/blob/master/examples/nrf/src/bin/multiprio.rs">example</a>.
@@ -44,13 +44,13 @@ The <a href="https://github.com/embassy-rs/nrf-softdevice">nrf-softdevice</a> cr
 
 ```rust,ignore
 use defmt::info;
-use embassy::executor::Spawner;
+use embassy_executor::executor::Spawner;
-use embassy::time::{Duration, Timer};
+use embassy_executor::time::{Duration, Timer};
 use embassy_nrf::gpio::{AnyPin, Input, Level, Output, OutputDrive, Pin, Pull};
 use embassy_nrf::Peripherals;
 
 // Declare async tasks
-#[embassy::task]
+#[embassy_executor::task]
 async fn blink(pin: AnyPin) {
     let mut led = Output::new(pin, Level::Low, OutputDrive::Standard);
 
@@ -64,7 +64,7 @@ async fn blink(pin: AnyPin) {
 }
 
 // Main is itself an async task as well.
-#[embassy::main]
+#[embassy_executor::main]
 async fn main(spawner: Spawner, p: Peripherals) {
     // Spawned tasks run in the background, concurrently.
     spawner.spawn(blink(p.P0_13.degrade())).unwrap();
@@ -132,7 +132,7 @@ Embassy is guaranteed to compile on the latest stable Rust version at the time o
 
 Several features require nightly:
 
-- The `#[embassy::main]` and `#[embassy::task]` attribute macros.
+- The `#[embassy_executor::main]` and `#[embassy_executor::task]` attribute macros.
 - Async traits
 
 These are enabled by activating the `nightly` Cargo feature. If you do so, Embassy is guaranteed to compile on the exact nightly version specified in `rust-toolchain.toml`. It might compile with older or newer nightly versions, but that may change in any new patch release.

ci.sh

@@ -32,10 +32,10 @@ rm -rf stm32-metapac
 mv stm32-metapac-gen/out stm32-metapac
 
 cargo batch  \
-    --- build --release --manifest-path embassy/Cargo.toml --target thumbv7em-none-eabi --features nightly \
+    --- build --release --manifest-path embassy-executor/Cargo.toml --target thumbv7em-none-eabi --features nightly \
-    --- build --release --manifest-path embassy/Cargo.toml --target thumbv7em-none-eabi --features nightly,log,executor-agnostic \
+    --- build --release --manifest-path embassy-executor/Cargo.toml --target thumbv7em-none-eabi --features nightly,log \
-    --- build --release --manifest-path embassy/Cargo.toml --target thumbv7em-none-eabi --features nightly,defmt \
+    --- build --release --manifest-path embassy-executor/Cargo.toml --target thumbv7em-none-eabi --features nightly,defmt \
-    --- build --release --manifest-path embassy/Cargo.toml --target thumbv6m-none-eabi --features nightly,defmt \
+    --- build --release --manifest-path embassy-executor/Cargo.toml --target thumbv6m-none-eabi --features nightly,defmt \
     --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv7em-none-eabi --features nightly,nrf52805,gpiote,time-driver-rtc1 \
     --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv7em-none-eabi --features nightly,nrf52810,gpiote,time-driver-rtc1 \
     --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv7em-none-eabi --features nightly,nrf52811,gpiote,time-driver-rtc1 \
@@ -54,27 +54,27 @@ cargo batch  \
     --- build --release --manifest-path embassy-rp/Cargo.toml --target thumbv6m-none-eabi --features nightly,unstable-traits,log \
     --- build --release --manifest-path embassy-rp/Cargo.toml --target thumbv6m-none-eabi --features nightly,unstable-traits \
     --- build --release --manifest-path embassy-rp/Cargo.toml --target thumbv6m-none-eabi --features nightly \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32f410tb,defmt,exti,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32f410tb,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32f411ce,defmt,exti,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32f411ce,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32f429zi,log,exti,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32f429zi,log,exti,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32h755zi-cm7,defmt,exti,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32h755zi-cm7,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32h7b3ai,defmt,exti,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32h7b3ai,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32l476vg,defmt,exti,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32l476vg,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32wb15cc,defmt,exti,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32wb15cc,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv6m-none-eabi --features nightly,stm32l072cz,defmt,exti,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv6m-none-eabi --features nightly,stm32l072cz,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv6m-none-eabi --features nightly,stm32l041f6,defmt,exti,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv6m-none-eabi --features nightly,stm32l041f6,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features nightly,stm32l151cb-a,defmt,exti,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features nightly,stm32l151cb-a,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features nightly,stm32f398ve,defmt,exti,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features nightly,stm32f398ve,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv6m-none-eabi --features nightly,stm32g0c1ve,defmt,exti,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv6m-none-eabi --features nightly,stm32g0c1ve,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features nightly,stm32f217zg,defmt,exti,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features nightly,stm32f217zg,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv8m.main-none-eabihf --features nightly,stm32l552ze,defmt,exti,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv8m.main-none-eabihf --features nightly,stm32l552ze,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv6m-none-eabi --features nightly,stm32wl54jc-cm0p,defmt,exti,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv6m-none-eabi --features nightly,stm32wl54jc-cm0p,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32wle5ub,defmt,exti,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features nightly,stm32wle5ub,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features nightly,stm32f107vc,defmt,exti,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features nightly,stm32f107vc,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features nightly,stm32f103re,defmt,exti,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features nightly,stm32f103re,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features nightly,stm32f100c4,defmt,exti,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features nightly,stm32f100c4,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
     --- build --release --manifest-path embassy-boot/nrf/Cargo.toml --target thumbv7em-none-eabi --features embassy-nrf/nrf52840 \
-    --- build --release --manifest-path embassy-boot/stm32/Cargo.toml --target thumbv7em-none-eabi --features embassy-stm32/stm32wl55jc-cm4,embassy/time-tick-32768hz \
+    --- build --release --manifest-path embassy-boot/stm32/Cargo.toml --target thumbv7em-none-eabi --features embassy-stm32/stm32wl55jc-cm4 \
     --- build --release --manifest-path docs/modules/ROOT/examples/basic/Cargo.toml --target thumbv7em-none-eabi \
     --- build --release --manifest-path docs/modules/ROOT/examples/layer-by-layer/blinky-pac/Cargo.toml --target thumbv7em-none-eabi \
     --- build --release --manifest-path docs/modules/ROOT/examples/layer-by-layer/blinky-hal/Cargo.toml --target thumbv7em-none-eabi \
@@ -106,7 +106,7 @@ cargo batch  \
     --- build --release --manifest-path examples/boot/application/stm32l4/Cargo.toml --target thumbv7em-none-eabi --out-dir out/examples/boot/stm32l4 --bin b \
     --- build --release --manifest-path examples/boot/application/stm32wl/Cargo.toml --target thumbv7em-none-eabihf --out-dir out/examples/boot/stm32wl --bin b \
     --- build --release --manifest-path examples/boot/bootloader/nrf/Cargo.toml --target thumbv7em-none-eabi --features embassy-nrf/nrf52840 \
-    --- build --release --manifest-path examples/boot/bootloader/stm32/Cargo.toml --target thumbv7em-none-eabi --features embassy-stm32/stm32wl55jc-cm4,embassy/time-tick-32768hz \
+    --- build --release --manifest-path examples/boot/bootloader/stm32/Cargo.toml --target thumbv7em-none-eabi --features embassy-stm32/stm32wl55jc-cm4 \
     --- build --release --manifest-path examples/wasm/Cargo.toml --target wasm32-unknown-unknown --out-dir out/examples/wasm \
     --- build --release --manifest-path tests/stm32/Cargo.toml --target thumbv7m-none-eabi --features stm32f103c8 --out-dir out/tests/bluepill-stm32f103c8 \
     --- build --release --manifest-path tests/stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f429zi --out-dir out/tests/nucleo-stm32f429zi \

ci_stable.sh

@@ -9,10 +9,10 @@ export DEFMT_LOG=trace
 sed -i 's/channel.*/channel = "stable"/g' rust-toolchain.toml
 
 cargo batch  \
-    --- build --release --manifest-path embassy/Cargo.toml --target thumbv7em-none-eabi \
+    --- build --release --manifest-path embassy-executor/Cargo.toml --target thumbv7em-none-eabi \
-    --- build --release --manifest-path embassy/Cargo.toml --target thumbv7em-none-eabi --features log,executor-agnostic \
+    --- build --release --manifest-path embassy-executor/Cargo.toml --target thumbv7em-none-eabi --features log \
-    --- build --release --manifest-path embassy/Cargo.toml --target thumbv7em-none-eabi --features defmt \
+    --- build --release --manifest-path embassy-executor/Cargo.toml --target thumbv7em-none-eabi --features defmt \
-    --- build --release --manifest-path embassy/Cargo.toml --target thumbv6m-none-eabi --features defmt \
+    --- build --release --manifest-path embassy-executor/Cargo.toml --target thumbv6m-none-eabi --features defmt \
     --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv7em-none-eabi --features nrf52805,gpiote,time-driver-rtc1 \
     --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv7em-none-eabi --features nrf52810,gpiote,time-driver-rtc1 \
     --- build --release --manifest-path embassy-nrf/Cargo.toml --target thumbv7em-none-eabi --features nrf52811,gpiote,time-driver-rtc1 \
@@ -30,38 +30,38 @@ cargo batch  \
     --- build --release --manifest-path embassy-rp/Cargo.toml --target thumbv6m-none-eabi --features unstable-traits,defmt \
     --- build --release --manifest-path embassy-rp/Cargo.toml --target thumbv6m-none-eabi --features unstable-traits,log \
     --- build --release --manifest-path embassy-rp/Cargo.toml --target thumbv6m-none-eabi \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32g473cc,defmt,exti,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32g473cc,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32g491re,defmt,exti,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32g491re,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32u585zi,defmt,exti,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32u585zi,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32wb55vy,defmt,exti,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32wb55vy,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32wl55uc-cm4,defmt,exti,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32wl55uc-cm4,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32l4r9zi,defmt,exti,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32l4r9zi,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f303vc,defmt,exti,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f303vc,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f411ce,defmt,time-driver-any,embassy/time-tick-32768hz \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f411ce,defmt,time-driver-any,embassy-executor/time-tick-32768hz \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f411ce,defmt,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f411ce,defmt,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f429zi,log,time-driver-any,embassy/time-tick-32768hz \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f429zi,log,time-driver-any,embassy-executor/time-tick-32768hz \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f429zi,log,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f429zi,log,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32h755zi-cm7,defmt,time-driver-any,embassy/time-tick-32768hz \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32h755zi-cm7,defmt,time-driver-any,embassy-executor/time-tick-32768hz \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32h755zi-cm7,defmt,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32h755zi-cm7,defmt,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32l476vg,defmt,time-driver-any,embassy/time-tick-32768hz \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32l476vg,defmt,time-driver-any,embassy-executor/time-tick-32768hz \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32l476vg,defmt,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32l476vg,defmt,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv6m-none-eabi --features stm32l072cz,defmt,time-driver-any,embassy/time-tick-32768hz \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv6m-none-eabi --features stm32l072cz,defmt,time-driver-any,embassy-executor/time-tick-32768hz \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv6m-none-eabi --features stm32l072cz,defmt,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv6m-none-eabi --features stm32l072cz,defmt,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features stm32l151cb-a,defmt,time-driver-any,embassy/time-tick-32768hz \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features stm32l151cb-a,defmt,time-driver-any,embassy-executor/time-tick-32768hz \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features stm32l151cb-a,defmt,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features stm32l151cb-a,defmt,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f410tb,defmt,exti,time-driver-any,embassy/time-tick-32768hz \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f410tb,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f410tb,defmt,exti,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f410tb,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f429zi,log,exti,time-driver-any,embassy/time-tick-32768hz \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f429zi,log,exti,time-driver-any,embassy-executor/time-tick-32768hz \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f429zi,log,exti,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32f429zi,log,exti,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32h755zi-cm7,defmt,exti,time-driver-any,embassy/time-tick-32768hz \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32h755zi-cm7,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32h755zi-cm7,defmt,exti,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32h755zi-cm7,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32l476vg,defmt,exti,time-driver-any,embassy/time-tick-32768hz \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32l476vg,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32l476vg,defmt,exti,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7em-none-eabi --features stm32l476vg,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv6m-none-eabi --features stm32l072cz,defmt,exti,time-driver-any,embassy/time-tick-32768hz \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv6m-none-eabi --features stm32l072cz,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv6m-none-eabi --features stm32l072cz,defmt,exti,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv6m-none-eabi --features stm32l072cz,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features stm32l151cb-a,defmt,exti,time-driver-any,embassy/time-tick-32768hz \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features stm32l151cb-a,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features stm32l151cb-a,defmt,exti,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features stm32l151cb-a,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features stm32f217zg,defmt,exti,time-driver-any,embassy/time-tick-32768hz \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features stm32f217zg,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz \
-    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features stm32f217zg,defmt,exti,time-driver-any,embassy/time-tick-32768hz,unstable-traits \
+    --- build --release --manifest-path embassy-stm32/Cargo.toml --target thumbv7m-none-eabi --features stm32f217zg,defmt,exti,time-driver-any,embassy-executor/time-tick-32768hz,unstable-traits \
     --- build --release --manifest-path examples/nrf/Cargo.toml --target thumbv7em-none-eabi --no-default-features --out-dir out/examples/nrf --bin raw_spawn \
     --- build --release --manifest-path examples/stm32l0/Cargo.toml --target thumbv6m-none-eabi --no-default-features --out-dir out/examples/stm32l0 --bin raw_spawn \

docs/modules/ROOT/examples/basic/Cargo.toml

@@ -5,7 +5,7 @@ name = "embassy-basic-example"
 version = "0.1.0"
 
 [dependencies]
-embassy = { version = "0.1.0", path = "../../../../../embassy", features = ["defmt", "nightly"] }
+embassy-executor = { version = "0.1.0", path = "../../../../../embassy-executor", features = ["defmt", "nightly"] }
 embassy-nrf = { version = "0.1.0", path = "../../../../../embassy-nrf", features = ["defmt", "nrf52840", "time-driver-rtc1", "gpiote", "nightly"] }
 
 defmt = "0.3"

docs/modules/ROOT/examples/basic/src/main.rs

@@ -3,14 +3,14 @@
 #![feature(type_alias_impl_trait)]
 
 use defmt::*;
-use embassy::executor::Spawner;
+use embassy_executor::executor::Spawner;
-use embassy::time::{Duration, Timer};
+use embassy_executor::time::{Duration, Timer};
 use embassy_nrf::gpio::{Level, Output, OutputDrive};
 use embassy_nrf::peripherals::P0_13;
 use embassy_nrf::Peripherals;
 use {defmt_rtt as _, panic_probe as _}; // global logger
 
-#[embassy::task]
+#[embassy_executor::task]
 async fn blinker(mut led: Output<'static, P0_13>, interval: Duration) {
     loop {
         led.set_high();
@@ -20,7 +20,7 @@ async fn blinker(mut led: Output<'static, P0_13>, interval: Duration) {
     }
 }
 
-#[embassy::main]
+#[embassy_executor::main]
 async fn main(spawner: Spawner, p: Peripherals) {
     let led = Output::new(p.P0_13, Level::Low, OutputDrive::Standard);
     unwrap!(spawner.spawn(blinker(led, Duration::from_millis(300))));

docs/modules/ROOT/examples/layer-by-layer/Cargo.toml

@@ -8,7 +8,7 @@ members = [
 ]
 
 [patch.crates-io]
-embassy = { path = "../../../../../embassy" }
+embassy-executor = { path = "../../../../../embassy-executor" }
 embassy-stm32 = { path = "../../../../../embassy-stm32" }
 stm32-metapac = { path = "../../../../../stm32-metapac" }
 

docs/modules/ROOT/examples/layer-by-layer/blinky-async/Cargo.toml

@@ -7,7 +7,7 @@ edition = "2021"
 cortex-m = "0.7"
 cortex-m-rt = "0.7"
 embassy-stm32 = { version = "0.1.0", features = ["stm32l475vg", "memory-x", "exti"], default-features = false  }
-embassy = { version = "0.1.0", default-features = false, features = ["nightly"] }
+embassy-executor = { version = "0.1.0", default-features = false, features = ["nightly"] }
 
 defmt = "0.3.0"
 defmt-rtt = "0.3.0"

docs/modules/ROOT/examples/layer-by-layer/blinky-async/src/main.rs

@@ -2,13 +2,13 @@
 #![no_main]
 #![feature(type_alias_impl_trait)]
 
-use embassy::executor::Spawner;
+use embassy_executor::executor::Spawner;
 use embassy_stm32::exti::ExtiInput;
 use embassy_stm32::gpio::{Input, Level, Output, Pull, Speed};
 use embassy_stm32::Peripherals;
 use {defmt_rtt as _, panic_probe as _};
 
-#[embassy::main]
+#[embassy_executor::main]
 async fn main(_s: Spawner, p: Peripherals) {
     let mut led = Output::new(p.PB14, Level::Low, Speed::VeryHigh);
     let mut button = ExtiInput::new(Input::new(p.PC13, Pull::Up), p.EXTI13);

embassy-boot/boot/Cargo.toml

@@ -9,7 +9,7 @@ description = "Bootloader using Embassy"
 [dependencies]
 defmt = { version = "0.3", optional = true }
 log = { version = "0.4", optional = true  }
-embassy = { path = "../../embassy", default-features = false }
+embassy-util = { version = "0.1.0", path = "../../embassy-util" }
 embedded-storage = "0.3.0"
 embedded-storage-async = "0.3.0"
 

embassy-boot/nrf/Cargo.toml

@@ -9,7 +9,7 @@ description = "Bootloader lib for nRF chips"
 [dependencies]
 defmt = { version = "0.3", optional = true }
 
-embassy = { path = "../../embassy", default-features = false }
+embassy-util = { path = "../../embassy-util" }
 embassy-nrf = { path = "../../embassy-nrf", default-features = false, features = ["nightly"] }
 embassy-boot = { path = "../boot", default-features = false }
 cortex-m = { version = "0.7" }

embassy-boot/stm32/Cargo.toml

@@ -11,7 +11,7 @@ defmt = { version = "0.3", optional = true }
 defmt-rtt = { version = "0.3", optional = true }
 log = { version = "0.4", optional = true }
 
-embassy = { path = "../../embassy", default-features = false }
+embassy-util = { path = "../../embassy-util" }
 embassy-stm32 = { path = "../../embassy-stm32", default-features = false, features = ["nightly"] }
 embassy-boot = { path = "../boot", default-features = false }
 cortex-m = { version = "0.7" }

embassy-cortex-m/Cargo.toml

@@ -35,7 +35,8 @@ prio-bits-8 = []
 defmt = { version = "0.3", optional = true }
 log = { version = "0.4.14", optional = true }
 
-embassy = { version = "0.1.0", path = "../embassy"}
+embassy-util = { version = "0.1.0", path = "../embassy-util" }
+embassy-executor = { version = "0.1.0", path = "../embassy-executor"}
 embassy-macros = { version = "0.1.0", path = "../embassy-macros"}
 embassy-hal-common = { version = "0.1.0", path = "../embassy-hal-common"}
 atomic-polyfill = "0.1.5"

embassy-cortex-m/src/executor.rs

@@ -1,7 +1,7 @@
 //! Executor specific to cortex-m devices.
 use core::marker::PhantomData;
 
-pub use embassy::executor::*;
+pub use embassy_executor::executor::*;
 
 use crate::interrupt::{Interrupt, InterruptExt};
 
@@ -60,18 +60,18 @@ impl<I: Interrupt> InterruptExecutor<I> {
     /// The executor keeps running in the background through the interrupt.
     ///
     /// This returns a [`SendSpawner`] you can use to spawn tasks on it. A [`SendSpawner`]
-    /// is returned instead of a [`Spawner`](embassy::executor::Spawner) because the executor effectively runs in a
+    /// is returned instead of a [`Spawner`](embassy_executor::executor::Spawner) because the executor effectively runs in a
     /// different "thread" (the interrupt), so spawning tasks on it is effectively
     /// sending them.
     ///
-    /// To obtain a [`Spawner`](embassy::executor::Spawner) for this executor, use [`Spawner::for_current_executor()`](embassy::executor::Spawner::for_current_executor()) from
+    /// To obtain a [`Spawner`](embassy_executor::executor::Spawner) for this executor, use [`Spawner::for_current_executor()`](embassy_executor::executor::Spawner::for_current_executor()) from
     /// a task running in it.
     ///
     /// This function requires `&'static mut self`. This means you have to store the
     /// Executor instance in a place where it'll live forever and grants you mutable
     /// access. There's a few ways to do this:
     ///
-    /// - a [Forever](embassy::util::Forever) (safe)
+    /// - a [Forever](embassy_util::Forever) (safe)
     /// - a `static mut` (unsafe)
     /// - a local variable in a function you know never returns (like `fn main() -> !`), upgrading its lifetime with `transmute`. (unsafe)
     pub fn start(&'static mut self) -> SendSpawner {

embassy-embedded-hal/Cargo.toml

@@ -9,7 +9,7 @@ std = []
 nightly = ["embedded-hal-async", "embedded-storage-async"]
 
 [dependencies]
-embassy = { version = "0.1.0", path = "../embassy" }
+embassy-util = { version = "0.1.0", path = "../embassy-util" }
 embedded-hal-02 = { package = "embedded-hal", version = "0.2.6", features = ["unproven"] }
 embedded-hal-1 = { package = "embedded-hal", version = "1.0.0-alpha.8" }
 embedded-hal-async = { version = "0.1.0-alpha.1", optional = true }

embassy-embedded-hal/src/shared_bus/asynch/i2c.rs

@@ -4,8 +4,8 @@
 //!
 //! ```rust
 //! use embassy_embedded_hal::shared_bus::i2c::I2cDevice;
-//! use embassy::mutex::Mutex;
+//! use embassy_util::mutex::Mutex;
-//! use embassy::blocking_mutex::raw::ThreadModeRawMutex;
+//! use embassy_util::blocking_mutex::raw::ThreadModeRawMutex;
 //!
 //! static I2C_BUS: Forever<Mutex::<ThreadModeRawMutex, Twim<TWISPI0>>> = Forever::new();
 //! let config = twim::Config::default();
@@ -24,8 +24,8 @@
 //! ```
 use core::future::Future;
 
-use embassy::blocking_mutex::raw::RawMutex;
+use embassy_util::blocking_mutex::raw::RawMutex;
-use embassy::mutex::Mutex;
+use embassy_util::mutex::Mutex;
 use embedded_hal_async::i2c;
 
 use crate::shared_bus::I2cDeviceError;

embassy-embedded-hal/src/shared_bus/asynch/spi.rs

@@ -4,8 +4,8 @@
 //!
 //! ```rust
 //! use embassy_embedded_hal::shared_bus::spi::SpiDevice;
-//! use embassy::mutex::Mutex;
+//! use embassy_util::mutex::Mutex;
-//! use embassy::blocking_mutex::raw::ThreadModeRawMutex;
+//! use embassy_util::blocking_mutex::raw::ThreadModeRawMutex;
 //!
 //! static SPI_BUS: Forever<Mutex<ThreadModeRawMutex, spim::Spim<SPI3>>> = Forever::new();
 //! let mut config = spim::Config::default();
@@ -27,8 +27,8 @@
 //! ```
 use core::future::Future;
 
-use embassy::blocking_mutex::raw::RawMutex;
+use embassy_util::blocking_mutex::raw::RawMutex;
-use embassy::mutex::Mutex;
+use embassy_util::mutex::Mutex;
 use embedded_hal_1::digital::blocking::OutputPin;
 use embedded_hal_1::spi::ErrorType;
 use embedded_hal_async::spi;

embassy-embedded-hal/src/shared_bus/blocking/i2c.rs

@@ -4,7 +4,7 @@
 //!
 //! ```rust
 //! use embassy_embedded_hal::shared_bus::blocking::i2c::I2cDevice;
-//! use embassy::blocking_mutex::{NoopMutex, raw::NoopRawMutex};
+//! use embassy_util::blocking_mutex::{NoopMutex, raw::NoopRawMutex};
 //!
 //! static I2C_BUS: Forever<NoopMutex<RefCell<Twim<TWISPI0>>>> = Forever::new();
 //! let irq = interrupt::take!(SPIM0_SPIS0_TWIM0_TWIS0_SPI0_TWI0);
@@ -18,8 +18,8 @@
 
 use core::cell::RefCell;
 
-use embassy::blocking_mutex::raw::RawMutex;
+use embassy_util::blocking_mutex::raw::RawMutex;
-use embassy::blocking_mutex::Mutex;
+use embassy_util::blocking_mutex::Mutex;
 use embedded_hal_1::i2c::blocking::{I2c, Operation};
 use embedded_hal_1::i2c::ErrorType;
 

embassy-embedded-hal/src/shared_bus/blocking/spi.rs

@@ -4,7 +4,7 @@
 //!
 //! ```rust
 //! use embassy_embedded_hal::shared_bus::blocking::spi::SpiDevice;
-//! use embassy::blocking_mutex::{NoopMutex, raw::NoopRawMutex};
+//! use embassy_util::blocking_mutex::{NoopMutex, raw::NoopRawMutex};
 //!
 //! static SPI_BUS: Forever<NoopMutex<RefCell<Spim<SPI3>>>> = Forever::new();
 //! let irq = interrupt::take!(SPIM3);
@@ -20,8 +20,8 @@
 
 use core::cell::RefCell;
 
-use embassy::blocking_mutex::raw::RawMutex;
+use embassy_util::blocking_mutex::raw::RawMutex;
-use embassy::blocking_mutex::Mutex;
+use embassy_util::blocking_mutex::Mutex;
 use embedded_hal_1::digital::blocking::OutputPin;
 use embedded_hal_1::spi;
 use embedded_hal_1::spi::blocking::SpiBusFlush;

embassy-executor/Cargo.toml

@@ -1,11 +1,12 @@
 [package]
-name = "embassy"
+name = "embassy-executor"
 version = "0.1.0"
 edition = "2021"
 
+
 [package.metadata.embassy_docs]
-src_base = "https://github.com/embassy-rs/embassy/blob/embassy-v$VERSION/embassy/src/"
+src_base = "https://github.com/embassy-rs/embassy/blob/embassy-executor-v$VERSION/embassy-executor/src/"
-src_base_git = "https://github.com/embassy-rs/embassy/blob/$COMMIT/embassy/src/"
+src_base_git = "https://github.com/embassy-rs/embassy/blob/$COMMIT/embassy-executor/src/"
 features = ["nightly", "defmt", "unstable-traits", "time", "time-tick-1mhz"]
 flavors = [
     { name = "std",                       target = "x86_64-unknown-linux-gnu",   features = ["std"] },
@@ -21,7 +22,7 @@ flavors = [
 
 [features]
 default = []
-std = ["futures/std", "time", "time-tick-1mhz", "embassy-macros/std"]
+std = ["time", "time-tick-1mhz", "embassy-macros/std"]
 wasm = ["wasm-bindgen", "js-sys", "embassy-macros/wasm", "wasm-timer", "time", "time-tick-1mhz"]
 
 # Enable nightly-only features
@@ -35,12 +36,12 @@ unstable-traits = ["embedded-hal-1"]
 # To use this you must have a time driver provided.
 defmt-timestamp-uptime = ["defmt"]
 
-# Enable `embassy::time` module. 
+# Enable `embassy_executor::time` module. 
 # NOTE: This feature is only intended to be enabled by crates providing the time driver implementation.
 # Enabling it directly without supplying a time driver will fail to link.
 time = []
 
-# Set the `embassy::time` tick rate.
+# Set the `embassy_executor::time` tick rate.
 # NOTE: This feature is only intended to be enabled by crates providing the time driver implementation.
 # If you're not writing your own driver, check the driver documentation to customize the tick rate.
 # If you're writing a driver and your tick rate is not listed here, please add it and send a PR!
@@ -49,8 +50,6 @@ time-tick-1000hz = ["time"]
 time-tick-1mhz = ["time"]
 time-tick-16mhz = ["time"]
 
-executor-agnostic = []
-
 [dependencies]
 defmt = { version = "0.3", optional = true }
 log = { version = "0.4.14", optional = true }
@@ -59,37 +58,13 @@ embedded-hal-02 = { package = "embedded-hal", version = "0.2.6" }
 embedded-hal-1 = { package = "embedded-hal", version = "1.0.0-alpha.8", optional = true}
 embedded-hal-async = { version = "0.1.0-alpha.1", optional = true}
 
-futures     = { version = "0.3.17", default-features = false, features = [ "cfg-target-has-atomic", "unstable" ] }
+futures-util = { version = "0.3.17", default-features = false }
-pin-project = { version = "1.0.8", default-features = false }
 embassy-macros  = { version = "0.1.0", path = "../embassy-macros"}
 atomic-polyfill = "0.1.5"
 critical-section = "0.2.5"
-heapless = "0.7.5"
 cfg-if = "1.0.0"
 
 # WASM dependencies
 wasm-bindgen = { version = "0.2.76", features = ["nightly"], optional = true }
 js-sys = { version = "0.3", optional = true }
-wasm-timer = { version = "0.2.5", optional = true }
+wasm-timer = { version = "0.2.5", optional = true }
-
-[target."thumbv6m-none-eabi".dependencies]
-cortex-m = "0.7.3"
-[target."thumbv7m-none-eabi".dependencies]
-cortex-m = "0.7.3"
-[target."thumbv7em-none-eabi".dependencies]
-cortex-m = "0.7.3"
-[target."thumbv7em-none-eabihf".dependencies]
-cortex-m = "0.7.3"
-[target."thumbv8m.base-none-eabi".dependencies]
-cortex-m = "0.7.3"
-[target."thumbv8m.main-none-eabi".dependencies]
-cortex-m = "0.7.3"
-[target."thumbv8m.main-none-eabihf".dependencies]
-cortex-m = "0.7.3"
-
-[dev-dependencies]
-embassy = { path = ".", features = ["executor-agnostic"] }
-futures-executor = { version = "0.3.17", features = [ "thread-pool" ] }
-futures-test = "0.3.17"
-futures-timer = "3.0.2"
-futures-util = { version = "0.3.17", features = [ "channel" ] }

embassy-executor/src/executor/arch/cortex_m.rs

@@ -1,3 +1,4 @@
+use core::arch::asm;
 use core::marker::PhantomData;
 use core::ptr;
 
@@ -22,7 +23,7 @@ impl Executor {
     /// Create a new Executor.
     pub fn new() -> Self {
         Self {
-            inner: raw::Executor::new(|_| cortex_m::asm::sev(), ptr::null_mut()),
+            inner: raw::Executor::new(|_| unsafe { asm!("sev") }, ptr::null_mut()),
             not_send: PhantomData,
         }
     }
@@ -49,8 +50,10 @@ impl Executor {
         init(self.inner.spawner());
 
         loop {
-            unsafe { self.inner.poll() };
+            unsafe {
-            cortex_m::asm::wfe();
+                self.inner.poll();
+                asm!("wfe");
+            };
         }
     }
 }

embassy-executor/src/executor/mod.rs

@@ -10,8 +10,6 @@
 //! - Fair: a task can't monopolize CPU time even if it's constantly being woken. All other tasks get a chance to run before a given task gets polled for the second time.
 //! - Creating multiple executor instances is supported, to run tasks with multiple priority levels. This allows higher-priority tasks to preempt lower-priority tasks.
 
-#![deny(missing_docs)]
-
 cfg_if::cfg_if! {
     if #[cfg(cortex_m)] {
         #[path="arch/cortex_m.rs"]

embassy-executor/src/executor/raw/mod.rs

@@ -5,7 +5,7 @@
 //! ## WARNING: here be dragons!
 //!
 //! Using this module requires respecting subtle safety contracts. If you can, prefer using the safe
-//! executor wrappers in [`executor`](crate::executor) and the [`embassy::task`](embassy_macros::task) macro, which are fully safe.
+//! executor wrappers in [`executor`](crate::executor) and the [`embassy_executor::task`](embassy_macros::task) macro, which are fully safe.
 
 mod run_queue;
 #[cfg(feature = "time")]
@@ -99,7 +99,7 @@ impl TaskHeader {
 /// A `TaskStorage` must live forever, it may not be deallocated even after the task has finished
 /// running. Hence the relevant methods require `&'static self`. It may be reused, however.
 ///
-/// Internally, the [embassy::task](embassy_macros::task) macro allocates an array of `TaskStorage`s
+/// Internally, the [embassy_executor::task](embassy_macros::task) macro allocates an array of `TaskStorage`s
 /// in a `static`. The most common reason to use the raw `Task` is to have control of where
 /// the memory for the task is allocated: on the stack, or on the heap with e.g. `Box::leak`, etc.
 

embassy-executor/src/executor/raw/waker.rs

@@ -40,7 +40,7 @@ pub fn task_from_waker(waker: &Waker) -> NonNull<TaskHeader> {
     // TODO use waker_getters when stable. https://github.com/rust-lang/rust/issues/96992
     let hack: &WakerHack = unsafe { mem::transmute(waker) };
     if hack.vtable != &VTABLE {
-        panic!("Found waker not created by the embassy executor. Consider enabling the `executor-agnostic` feature on the `embassy` crate.")
+        panic!("Found waker not created by the Embassy executor. `embassy_executor::time::Timer` only works with the Embassy executor.")
     }
 
     // safety: we never create a waker with a null data pointer.

embassy-executor/src/executor/spawner.rs

@@ -3,13 +3,13 @@ use core::mem;
 use core::ptr::NonNull;
 use core::task::Poll;
 
-use futures::future::poll_fn;
+use futures_util::future::poll_fn;
 
 use super::raw;
 
 /// Token to spawn a newly-created task in an executor.
 ///
-/// When calling a task function (like `#[embassy::task] async fn my_task() { ... }`), the returned
+/// When calling a task function (like `#[embassy_executor::task] async fn my_task() { ... }`), the returned
 /// value is a `SpawnToken` that represents an instance of the task, ready to spawn. You must
 /// then spawn it into an executor, typically with [`Spawner::spawn()`].
 ///
@@ -56,9 +56,9 @@ impl<S> Drop for SpawnToken<S> {
 pub enum SpawnError {
     /// Too many instances of this task are already running.
     ///
-    /// By default, a task marked with `#[embassy::task]` can only have one instance
+    /// By default, a task marked with `#[embassy_executor::task]` can only have one instance
     /// running at a time. You may allow multiple instances to run in parallel with
-    /// `#[embassy::task(pool_size = 4)]`, at the cost of higher RAM usage.
+    /// `#[embassy_executor::task(pool_size = 4)]`, at the cost of higher RAM usage.
     Busy,
 }
 
@@ -101,7 +101,7 @@ impl Spawner {
 
     /// Spawn a task into an executor.
     ///
-    /// You obtain the `token` by calling a task function (i.e. one marked with `#[embassy::task]`).
+    /// You obtain the `token` by calling a task function (i.e. one marked with `#[embassy_executor::task]`).
     pub fn spawn<S>(&self, token: SpawnToken<S>) -> Result<(), SpawnError> {
         let task = token.raw_task;
         mem::forget(token);
@@ -177,7 +177,7 @@ impl SendSpawner {
 
     /// Spawn a task into an executor.
     ///
-    /// You obtain the `token` by calling a task function (i.e. one marked with `#[embassy::task]`).
+    /// You obtain the `token` by calling a task function (i.e. one marked with `#[embassy_executor::task]`).
     pub fn spawn<S: Send>(&self, token: SpawnToken<S>) -> Result<(), SpawnError> {
         let header = token.raw_task;
         mem::forget(token);

embassy-executor/src/lib.rs

@@ -8,14 +8,9 @@
 // This mod MUST go first, so that the others see its macros.
 pub(crate) mod fmt;
 
-pub mod blocking_mutex;
-pub mod channel;
 pub mod executor;
-pub mod mutex;
 #[cfg(feature = "time")]
 pub mod time;
-pub mod util;
-pub mod waitqueue;
 
 #[cfg(feature = "nightly")]
 pub use embassy_macros::{main, task};

embassy-executor/src/time/delay.rs

@@ -35,7 +35,7 @@ cfg_if::cfg_if! {
     if #[cfg(all(feature = "unstable-traits", feature = "nightly"))] {
         use crate::time::Timer;
         use core::future::Future;
-        use futures::FutureExt;
+        use futures_util::FutureExt;
 
         impl embedded_hal_async::delay::DelayUs for Delay {
             type Error = core::convert::Infallible;

embassy-executor/src/time/driver.rs

@@ -1,17 +1,17 @@
 //! Time driver interface
 //!
-//! This module defines the interface a driver needs to implement to power the `embassy::time` module.
+//! This module defines the interface a driver needs to implement to power the `embassy_executor::time` module.
 //!
 //! # Implementing a driver
 //!
 //! - Define a struct `MyDriver`
 //! - Implement [`Driver`] for it
 //! - Register it as the global driver with [`time_driver_impl`].
-//! - Enable the Cargo features `embassy/time` and one of `embassy/time-tick-*` corresponding to the
+//! - Enable the Cargo features `embassy-executor/time` and one of `embassy-executor/time-tick-*` corresponding to the
 //!   tick rate of your driver.
 //!
 //! If you wish to make the tick rate configurable by the end user, you should do so by exposing your own
-//! Cargo features and having each enable the corresponding `embassy/time-tick-*`.
+//! Cargo features and having each enable the corresponding `embassy-executor/time-tick-*`.
 //!
 //! # Linkage details
 //!
@@ -34,10 +34,10 @@
 //! # Example
 //!
 //! ```
-//! use embassy::time::driver::{Driver, AlarmHandle};
+//! use embassy_executor::time::driver::{Driver, AlarmHandle};
 //!
 //! struct MyDriver{}; // not public!
-//! embassy::time_driver_impl!(static DRIVER: MyDriver = MyDriver{});
+//! embassy_executor::time_driver_impl!(static DRIVER: MyDriver = MyDriver{});
 //!
 //! impl Driver for MyDriver {
 //!     fn now(&self) -> u64 {

embassy-executor/src/time/mod.rs

@@ -26,7 +26,7 @@
 //! like `2021-08-24 13:33:21`).
 //!
 //! If persistence across reboots is not needed, support can be built on top of
-//! `embassy::time` by storing the offset between "seconds elapsed since boot"
+//! `embassy_executor::time` by storing the offset between "seconds elapsed since boot"
 //! and "seconds since unix epoch".
 //!
 //! # Time driver
@@ -35,7 +35,7 @@
 //! Only one driver can be active in a program.
 //!
 //! All methods and structs transparently call into the active driver. This makes it
-//! possible for libraries to use `embassy::time` in a driver-agnostic way without
+//! possible for libraries to use `embassy_executor::time` in a driver-agnostic way without
 //! requiring generic parameters.
 //!
 //! For more details, check the [`driver`] module.

embassy-executor/src/time/timer.rs

@@ -2,8 +2,8 @@ use core::future::Future;
 use core::pin::Pin;
 use core::task::{Context, Poll};
 
-use futures::future::{select, Either};
+use futures_util::future::{select, Either};
-use futures::{pin_mut, Stream};
+use futures_util::{pin_mut, Stream};
 
 use crate::executor::raw;
 use crate::time::{Duration, Instant};
@@ -49,9 +49,9 @@ impl Timer {
     /// # #![feature(type_alias_impl_trait)]
     /// #
     /// # fn foo() {}
-    /// use embassy::time::{Duration, Timer};
+    /// use embassy_executor::time::{Duration, Timer};
     ///
-    /// #[embassy::task]
+    /// #[embassy_executor::task]
     /// async fn demo_sleep_seconds() {
     ///     // suspend this task for one second.
     ///     Timer::after(Duration::from_secs(1)).await;
@@ -88,10 +88,10 @@ impl Future for Timer {
 /// ``` no_run
 /// # #![feature(type_alias_impl_trait)]
 /// #
-/// use embassy::time::{Duration, Timer};
+/// use embassy_executor::time::{Duration, Timer};
 /// # fn foo() {}
 ///
-/// #[embassy::task]
+/// #[embassy_executor::task]
 /// async fn ticker_example_0() {
 ///     loop {
 ///         foo();
@@ -108,11 +108,11 @@ impl Future for Timer {
 /// ``` no_run
 /// # #![feature(type_alias_impl_trait)]
 /// #
-/// use embassy::time::{Duration, Ticker};
+/// use embassy_executor::time::{Duration, Ticker};
 /// use futures::StreamExt;
 /// # fn foo(){}
 ///
-/// #[embassy::task]
+/// #[embassy_executor::task]
 /// async fn ticker_example_1() {
 ///     let mut ticker = Ticker::every(Duration::from_secs(1));
 ///     loop {

embassy-hal-common/Cargo.toml

@@ -6,9 +6,8 @@ edition = "2021"
 [features]
 
 [dependencies]
-embassy = { version = "0.1.0", path = "../embassy" }
-
 defmt = { version = "0.3", optional = true }
 log = { version = "0.4.14", optional = true }
-cortex-m = "0.7.3"
+
+embassy-util = { version = "0.1.0", path = "../embassy-util" }
 num-traits = { version = "0.2.14", default-features = false }

embassy-hal-common/src/lib.rs

@@ -10,13 +10,3 @@ mod peripheral;
 pub mod ratio;
 pub mod ring_buffer;
 pub use peripheral::{Peripheral, PeripheralRef};
-
-/// Low power blocking wait loop using WFE/SEV.
-pub fn low_power_wait_until(mut condition: impl FnMut() -> bool) {
-    while !condition() {
-        // WFE might "eat" an event that would have otherwise woken the executor.
-        cortex_m::asm::wfe();
-    }
-    // Retrigger an event to be transparent to the executor.
-    cortex_m::asm::sev();
-}

embassy-lora/Cargo.toml

@@ -8,8 +8,8 @@ src_base = "https://github.com/embassy-rs/embassy/blob/embassy-lora-v$VERSION/em
 src_base_git = "https://github.com/embassy-rs/embassy/blob/$COMMIT/embassy-lora/src/"
 features = ["time", "defmt"]
 flavors = [
-    { name = "sx127x",  target = "thumbv7em-none-eabihf", features = ["sx127x", "embassy-stm32/stm32wl55jc-cm4", "embassy-stm32/time-driver-any", "embassy/time-tick-32768hz"] },
+    { name = "sx127x",  target = "thumbv7em-none-eabihf", features = ["sx127x", "embassy-stm32/stm32wl55jc-cm4", "embassy-stm32/time-driver-any", "embassy-executor/time-tick-32768hz"] },
-    { name = "stm32wl", target = "thumbv7em-none-eabihf", features = ["stm32wl", "embassy-stm32/stm32wl55jc-cm4", "embassy-stm32/time-driver-any", "embassy/time-tick-32768hz"] },
+    { name = "stm32wl", target = "thumbv7em-none-eabihf", features = ["stm32wl", "embassy-stm32/stm32wl55jc-cm4", "embassy-stm32/time-driver-any", "embassy-executor/time-tick-32768hz"] },
 ]
 
 [lib]
@@ -24,7 +24,8 @@ time = []
 defmt = { version = "0.3", optional = true }
 log = { version = "0.4.14", optional = true }
 
-embassy = { version = "0.1.0", path = "../embassy", default-features = false }
+embassy-executor = { version = "0.1.0", path = "../embassy-executor" }
+embassy-util = { version = "0.1.0", path = "../embassy-util" }
 embassy-stm32 = { version = "0.1.0", path = "../embassy-stm32", default-features = false, optional = true }
 embedded-hal-1 = { package = "embedded-hal", version = "1.0.0-alpha.8" }
 embedded-hal-async = { version = "0.1.0-alpha.1" }

embassy-lora/src/lib.rs

@@ -18,6 +18,6 @@ pub struct LoraTimer;
 impl lorawan_device::async_device::radio::Timer for LoraTimer {
     type DelayFuture<'m> = impl core::future::Future<Output = ()> + 'm;
     fn delay_ms<'m>(&'m mut self, millis: u64) -> Self::DelayFuture<'m> {
-        embassy::time::Timer::after(embassy::time::Duration::from_millis(millis))
+        embassy_executor::time::Timer::after(embassy_executor::time::Duration::from_millis(millis))
     }
 }

embassy-lora/src/stm32wl/mod.rs

@@ -2,7 +2,6 @@
 use core::future::Future;
 use core::mem::MaybeUninit;
 
-use embassy::channel::signal::Signal;
 use embassy_hal_common::{into_ref, PeripheralRef};
 use embassy_stm32::dma::NoDma;
 use embassy_stm32::gpio::{AnyPin, Output};
@@ -13,6 +12,7 @@ use embassy_stm32::subghz::{
     Status, SubGhz, TcxoMode, TcxoTrim, Timeout, TxParams,
 };
 use embassy_stm32::Peripheral;
+use embassy_util::channel::signal::Signal;
 use lorawan_device::async_device::radio::{Bandwidth, PhyRxTx, RfConfig, RxQuality, SpreadingFactor, TxConfig};
 use lorawan_device::async_device::Timings;
 

embassy-lora/src/sx127x/sx127x_lora/mod.rs

@@ -6,7 +6,7 @@
 #![allow(dead_code)]
 
 use bit_field::BitField;
-use embassy::time::{Duration, Timer};
+use embassy_executor::time::{Duration, Timer};
 use embedded_hal::digital::v2::OutputPin;
 use embedded_hal_async::spi::SpiBus;
 

embassy-macros/src/macros/cortex_m_interrupt_take.rs

@@ -16,15 +16,15 @@ pub fn run(name: syn::Ident) -> Result<TokenStream, TokenStream> {
                     static HANDLER: interrupt::Handler;
                 }
 
-                let func = HANDLER.func.load(::embassy::export::atomic::Ordering::Relaxed);
+                let func = HANDLER.func.load(::embassy_executor::export::atomic::Ordering::Relaxed);
-                let ctx = HANDLER.ctx.load(::embassy::export::atomic::Ordering::Relaxed);
+                let ctx = HANDLER.ctx.load(::embassy_executor::export::atomic::Ordering::Relaxed);
                 let func: fn(*mut ()) = ::core::mem::transmute(func);
                 func(ctx)
             }
 
-            static TAKEN: ::embassy::export::atomic::AtomicBool = ::embassy::export::atomic::AtomicBool::new(false);
+            static TAKEN: ::embassy_executor::export::atomic::AtomicBool = ::embassy_executor::export::atomic::AtomicBool::new(false);
 
-            if TAKEN.compare_exchange(false, true, ::embassy::export::atomic::Ordering::AcqRel, ::embassy::export::atomic::Ordering::Acquire).is_err() {
+            if TAKEN.compare_exchange(false, true, ::embassy_executor::export::atomic::Ordering::AcqRel, ::embassy_executor::export::atomic::Ordering::Acquire).is_err() {
                 core::panic!("IRQ Already taken");
             }
 

embassy-macros/src/macros/main.rs

@@ -49,14 +49,14 @@ pub fn run(args: syn::AttributeArgs, f: syn::ItemFn) -> Result<TokenStream, Toke
 
     let embassy_prefix = args.embassy_prefix;
     let embassy_prefix_lit = embassy_prefix.literal();
-    let embassy_path = embassy_prefix.append("embassy").path();
+    let embassy_path = embassy_prefix.append("embassy_executor").path();
     let f_body = f.block;
 
     #[cfg(feature = "wasm")]
     let main = quote! {
         #[wasm_bindgen::prelude::wasm_bindgen(start)]
         pub fn main() -> Result<(), wasm_bindgen::JsValue> {
-            static EXECUTOR: #embassy_path::util::Forever<#embassy_path::executor::Executor> = #embassy_path::util::Forever::new();
+            static EXECUTOR: ::embassy_util::Forever<#embassy_path::executor::Executor> = ::embassy_util::Forever::new();
             let executor = EXECUTOR.put(#embassy_path::executor::Executor::new());
 
             executor.start(|spawner| {

embassy-macros/src/macros/task.rs

@@ -16,7 +16,7 @@ struct Args {
 pub fn run(args: syn::AttributeArgs, f: syn::ItemFn) -> Result<TokenStream, TokenStream> {
     let args = Args::from_list(&args).map_err(|e| e.write_errors())?;
 
-    let embassy_prefix = args.embassy_prefix.append("embassy");
+    let embassy_prefix = args.embassy_prefix.append("embassy_executor");
     let embassy_path = embassy_prefix.path();
 
     let pool_size: usize = args.pool_size.unwrap_or(1);

embassy-net/Cargo.toml

@@ -7,7 +7,7 @@ edition = "2021"
 [package.metadata.embassy_docs]
 src_base = "https://github.com/embassy-rs/embassy/blob/embassy-net-v$VERSION/embassy-net/src/"
 src_base_git = "https://github.com/embassy-rs/embassy/blob/$COMMIT/embassy-net/src/"
-features = [ "pool-4", "defmt", "tcp", "dns", "dhcpv4", "proto-ipv6", "medium-ethernet", "medium-ip", "embassy/time", "embassy/time-tick-1mhz"]
+features = [ "pool-4", "defmt", "tcp", "dns", "dhcpv4", "proto-ipv6", "medium-ethernet", "medium-ip", "embassy-executor/time", "embassy-executor/time-tick-1mhz"]
 flavors = [
     { name = "default", target = "thumbv7em-none-eabihf" },
 ]
@@ -37,7 +37,8 @@ pool-128 = []
 defmt = { version = "0.3", optional = true }
 log = { version = "0.4.14", optional = true }
 
-embassy             = { version = "0.1.0", path = "../embassy" }
+embassy-executor    = { version = "0.1.0", path = "../embassy-executor" }
+embassy-util        = { version = "0.1.0", path = "../embassy-util" }
 embedded-io         = { version = "0.3.0", features = [ "async" ] }
 
 managed             = { version = "0.8.0", default-features = false, features = [ "map" ] }

embassy-net/src/stack.rs

@@ -2,8 +2,8 @@ use core::cell::UnsafeCell;
 use core::future::Future;
 use core::task::{Context, Poll};
 
-use embassy::time::{Instant, Timer};
+use embassy_executor::time::{Instant, Timer};
-use embassy::waitqueue::WakerRegistration;
+use embassy_util::waitqueue::WakerRegistration;
 use futures::future::poll_fn;
 use futures::pin_mut;
 use heapless::Vec;

embassy-nrf/Cargo.toml

@@ -16,12 +16,12 @@ flavors = [
 
 [features]
 
-time = ["embassy/time"]
+time = ["embassy-executor/time"]
 
-defmt = ["dep:defmt", "embassy/defmt", "embassy-usb?/defmt", "embedded-io?/defmt", "embassy-embedded-hal/defmt"]
+defmt = ["dep:defmt", "embassy-executor/defmt", "embassy-util/defmt", "embassy-usb?/defmt", "embedded-io?/defmt", "embassy-embedded-hal/defmt"]
 
 # Enable nightly-only features
-nightly = ["embassy/nightly", "embedded-hal-1", "embedded-hal-async", "embassy-usb", "embedded-storage-async", "dep:embedded-io", "embassy-embedded-hal/nightly"]
+nightly = ["embedded-hal-1", "embedded-hal-async", "embassy-usb", "embedded-storage-async", "dep:embedded-io", "embassy-embedded-hal/nightly"]
 
 # Reexport the PAC for the currently enabled chip at `embassy_nrf::pac`.
 # This is unstable because semver-minor (non-breaking) releases of embassy-nrf may major-bump (breaking) the PAC version.
@@ -57,14 +57,15 @@ _nrf5340-net = ["_nrf5340", "nrf5340-net-pac"]
 _nrf5340 = ["_gpio-p1", "_dppi"]
 _nrf9160 = ["nrf9160-pac", "_dppi"]
 
-_time-driver = ["embassy/time-tick-32768hz", "time"]
+_time-driver = ["embassy-executor/time-tick-32768hz", "time"]
 
 _ppi = []
 _dppi = []
 _gpio-p1 = []
 
 [dependencies]
-embassy = { version = "0.1.0", path = "../embassy" }
+embassy-executor = { version = "0.1.0", path = "../embassy-executor", optional = true }
+embassy-util = { version = "0.1.0", path = "../embassy-util" }
 embassy-cortex-m = { version = "0.1.0", path = "../embassy-cortex-m", features = ["prio-bits-3"]}
 embassy-macros = { version = "0.1.0", path = "../embassy-macros", features = ["nrf"]}
 embassy-hal-common = {version = "0.1.0", path = "../embassy-hal-common" }

embassy-nrf/src/buffered_uarte.rs

@@ -18,10 +18,10 @@ use core::future::Future;
 use core::sync::atomic::{compiler_fence, Ordering};
 use core::task::Poll;
 
-use embassy::waitqueue::WakerRegistration;
 use embassy_cortex_m::peripheral::{PeripheralMutex, PeripheralState, StateStorage};
 use embassy_hal_common::ring_buffer::RingBuffer;
-use embassy_hal_common::{into_ref, low_power_wait_until, PeripheralRef};
+use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_util::waitqueue::WakerRegistration;
 use futures::future::poll_fn;
 // Re-export SVD variants to allow user to directly set values
 pub use pac::uarte0::{baudrate::BAUDRATE_A as Baudrate, config::PARITY_A as Parity};
@@ -450,3 +450,13 @@ impl<'a, U: UarteInstance, T: TimerInstance> PeripheralState for StateInner<'a,
         trace!("irq: end");
     }
 }
+
+/// Low power blocking wait loop using WFE/SEV.
+fn low_power_wait_until(mut condition: impl FnMut() -> bool) {
+    while !condition() {
+        // WFE might "eat" an event that would have otherwise woken the executor.
+        cortex_m::asm::wfe();
+    }
+    // Retrigger an event to be transparent to the executor.
+    cortex_m::asm::sev();
+}

embassy-nrf/src/gpiote.rs

@@ -2,8 +2,8 @@ use core::convert::Infallible;
 use core::future::Future;
 use core::task::{Context, Poll};
 
-use embassy::waitqueue::AtomicWaker;
 use embassy_hal_common::{impl_peripheral, Peripheral, PeripheralRef};
+use embassy_util::waitqueue::AtomicWaker;
 use futures::future::poll_fn;
 
 use crate::gpio::sealed::Pin as _;

embassy-nrf/src/qdec.rs

@@ -2,8 +2,8 @@
 
 use core::task::Poll;
 
-use embassy::waitqueue::AtomicWaker;
 use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_util::waitqueue::AtomicWaker;
 use futures::future::poll_fn;
 
 use crate::gpio::sealed::Pin as _;

embassy-nrf/src/qspi.rs

@@ -512,7 +512,7 @@ cfg_if::cfg_if! {
 }
 
 pub(crate) mod sealed {
-    use embassy::waitqueue::AtomicWaker;
+    use embassy_util::waitqueue::AtomicWaker;
 
     use super::*;
 

embassy-nrf/src/rng.rs

@@ -2,9 +2,9 @@ use core::ptr;
 use core::sync::atomic::{AtomicPtr, Ordering};
 use core::task::Poll;
 
-use embassy::waitqueue::AtomicWaker;
 use embassy_hal_common::drop::OnDrop;
 use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_util::waitqueue::AtomicWaker;
 use futures::future::poll_fn;
 
 use crate::interrupt::InterruptExt;

embassy-nrf/src/saadc.rs

@@ -3,8 +3,8 @@
 use core::sync::atomic::{compiler_fence, Ordering};
 use core::task::Poll;
 
-use embassy::waitqueue::AtomicWaker;
 use embassy_hal_common::{impl_peripheral, into_ref, PeripheralRef};
+use embassy_util::waitqueue::AtomicWaker;
 use futures::future::poll_fn;
 use pac::{saadc, SAADC};
 use saadc::ch::config::{GAIN_A, REFSEL_A, RESP_A, TACQ_A};

embassy-nrf/src/spim.rs

@@ -363,7 +363,7 @@ impl<'d, T: Instance> Drop for Spim<'d, T> {
 }
 
 pub(crate) mod sealed {
-    use embassy::waitqueue::AtomicWaker;
+    use embassy_util::waitqueue::AtomicWaker;
 
     use super::*;
 

embassy-nrf/src/temp.rs

@@ -2,9 +2,9 @@
 
 use core::task::Poll;
 
-use embassy::waitqueue::AtomicWaker;
 use embassy_hal_common::drop::OnDrop;
 use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_util::waitqueue::AtomicWaker;
 use fixed::types::I30F2;
 use futures::future::poll_fn;
 

embassy-nrf/src/time_driver.rs

@@ -3,9 +3,9 @@ use core::sync::atomic::{compiler_fence, AtomicU32, AtomicU8, Ordering};
 use core::{mem, ptr};
 
 use critical_section::CriticalSection;
-use embassy::blocking_mutex::raw::CriticalSectionRawMutex;
+use embassy_executor::time::driver::{AlarmHandle, Driver};
-use embassy::blocking_mutex::CriticalSectionMutex as Mutex;
+use embassy_util::blocking_mutex::raw::CriticalSectionRawMutex;
-use embassy::time::driver::{AlarmHandle, Driver};
+use embassy_util::blocking_mutex::CriticalSectionMutex as Mutex;
 
 use crate::interrupt::{Interrupt, InterruptExt};
 use crate::{interrupt, pac};
@@ -119,7 +119,7 @@ struct RtcDriver {
 }
 
 const ALARM_STATE_NEW: AlarmState = AlarmState::new();
-embassy::time_driver_impl!(static DRIVER: RtcDriver = RtcDriver {
+embassy_executor::time_driver_impl!(static DRIVER: RtcDriver = RtcDriver {
     period: AtomicU32::new(0),
     alarm_count: AtomicU8::new(0),
     alarms: Mutex::const_new(CriticalSectionRawMutex::new(), [ALARM_STATE_NEW; ALARM_COUNT]),

embassy-nrf/src/timer.rs

@@ -3,9 +3,9 @@
 use core::marker::PhantomData;
 use core::task::Poll;
 
-use embassy::waitqueue::AtomicWaker;
 use embassy_hal_common::drop::OnDrop;
 use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_util::waitqueue::AtomicWaker;
 use futures::future::poll_fn;
 
 use crate::interrupt::{Interrupt, InterruptExt};
@@ -40,8 +40,8 @@ macro_rules! impl_timer {
             fn regs() -> &'static pac::timer0::RegisterBlock {
                 unsafe { &*(pac::$pac_type::ptr() as *const pac::timer0::RegisterBlock) }
             }
-            fn waker(n: usize) -> &'static ::embassy::waitqueue::AtomicWaker {
+            fn waker(n: usize) -> &'static ::embassy_util::waitqueue::AtomicWaker {
-                use ::embassy::waitqueue::AtomicWaker;
+                use ::embassy_util::waitqueue::AtomicWaker;
                 const NEW_AW: AtomicWaker = AtomicWaker::new();
                 static WAKERS: [AtomicWaker; $ccs] = [NEW_AW; $ccs];
                 &WAKERS[n]

embassy-nrf/src/twim.rs

@@ -11,11 +11,11 @@ use core::sync::atomic::compiler_fence;
 use core::sync::atomic::Ordering::SeqCst;
 use core::task::Poll;
 
-#[cfg(feature = "time")]
-use embassy::time::{Duration, Instant};
-use embassy::waitqueue::AtomicWaker;
 use embassy_embedded_hal::SetConfig;
+#[cfg(feature = "time")]
+use embassy_executor::time::{Duration, Instant};
 use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_util::waitqueue::AtomicWaker;
 use futures::future::poll_fn;
 
 use crate::chip::{EASY_DMA_SIZE, FORCE_COPY_BUFFER_SIZE};

embassy-nrf/src/uarte.rs

@@ -932,7 +932,7 @@ impl<'d, U: Instance, T: TimerInstance> UarteRxWithIdle<'d, U, T> {
 pub(crate) mod sealed {
     use core::sync::atomic::AtomicU8;
 
-    use embassy::waitqueue::AtomicWaker;
+    use embassy_util::waitqueue::AtomicWaker;
 
     use super::*;
 

embassy-nrf/src/usb.rs

@@ -6,11 +6,11 @@ use core::sync::atomic::{compiler_fence, AtomicBool, AtomicU32, Ordering};
 use core::task::Poll;
 
 use cortex_m::peripheral::NVIC;
-use embassy::waitqueue::AtomicWaker;
 use embassy_hal_common::{into_ref, PeripheralRef};
 pub use embassy_usb;
 use embassy_usb::driver::{self, EndpointError, Event, Unsupported};
 use embassy_usb::types::{EndpointAddress, EndpointInfo, EndpointType, UsbDirection};
+use embassy_util::waitqueue::AtomicWaker;
 use futures::future::poll_fn;
 use futures::Future;
 use pac::usbd::RegisterBlock;

embassy-rp/Cargo.toml

@@ -20,14 +20,15 @@ flavors = [
 unstable-pac = []
 
 # Enable nightly-only features
-nightly = ["embassy/nightly", "embedded-hal-1", "embedded-hal-async", "embassy-embedded-hal/nightly"]
+nightly = ["embassy-executor/nightly", "embedded-hal-1", "embedded-hal-async", "embassy-embedded-hal/nightly"]
 
 # Implement embedded-hal 1.0 alpha traits.
 # Implement embedded-hal-async traits if `nightly` is set as well.
 unstable-traits = ["embedded-hal-1"]
 
 [dependencies]
-embassy = { version = "0.1.0", path = "../embassy", features = [ "time-tick-1mhz" ] }
+embassy-util = { version = "0.1.0", path = "../embassy-util" }
+embassy-executor = { version = "0.1.0", path = "../embassy-executor", features = [ "time-tick-1mhz" ] }
 embassy-cortex-m = { version = "0.1.0", path = "../embassy-cortex-m", features = ["prio-bits-3"]}
 embassy-hal-common = {version = "0.1.0", path = "../embassy-hal-common" }
 embassy-embedded-hal = {version = "0.1.0", path = "../embassy-embedded-hal" }

embassy-rp/src/gpio.rs

@@ -3,9 +3,9 @@ use core::future::Future;
 use core::pin::Pin as FuturePin;
 use core::task::{Context, Poll};
 
-use embassy::waitqueue::AtomicWaker;
 use embassy_cortex_m::interrupt::{Interrupt, InterruptExt};
 use embassy_hal_common::{impl_peripheral, into_ref, PeripheralRef};
+use embassy_util::waitqueue::AtomicWaker;
 
 use crate::pac::common::{Reg, RW};
 use crate::pac::SIO;

embassy-rp/src/timer.rs

@@ -2,9 +2,9 @@ use core::cell::Cell;
 
 use atomic_polyfill::{AtomicU8, Ordering};
 use critical_section::CriticalSection;
-use embassy::blocking_mutex::raw::CriticalSectionRawMutex;
+use embassy_executor::time::driver::{AlarmHandle, Driver};
-use embassy::blocking_mutex::Mutex;
+use embassy_util::blocking_mutex::raw::CriticalSectionRawMutex;
-use embassy::time::driver::{AlarmHandle, Driver};
+use embassy_util::blocking_mutex::Mutex;
 
 use crate::interrupt::{Interrupt, InterruptExt};
 use crate::{interrupt, pac};
@@ -26,7 +26,7 @@ struct TimerDriver {
     next_alarm: AtomicU8,
 }
 
-embassy::time_driver_impl!(static DRIVER: TimerDriver = TimerDriver{
+embassy_executor::time_driver_impl!(static DRIVER: TimerDriver = TimerDriver{
     alarms:  Mutex::const_new(CriticalSectionRawMutex::new(), [DUMMY_ALARM; ALARM_COUNT]),
     next_alarm: AtomicU8::new(0),
 });

embassy-stm32/Cargo.toml

@@ -10,7 +10,7 @@ src_base_git = "https://github.com/embassy-rs/embassy/blob/$COMMIT/embassy-stm32
 # TODO: sdmmc
 # TODO: net
 # TODO: subghz
-features = ["nightly", "defmt", "unstable-pac", "unstable-traits", "exti", "time-driver-any", "embassy/time-tick-32768hz"]
+features = ["nightly", "defmt", "unstable-pac", "unstable-traits", "exti", "time-driver-any", "embassy-executor/time-tick-32768hz"]
 flavors = [
     { regex_feature = "stm32f0.*", target = "thumbv6m-none-eabi" },
     { regex_feature = "stm32f1.*", target = "thumbv7m-none-eabi" },
@@ -31,7 +31,8 @@ flavors = [
 ]
 
 [dependencies]
-embassy = { version = "0.1.0", path = "../embassy" }
+embassy-util = { version = "0.1.0", path = "../embassy-util" }
+embassy-executor = { version = "0.1.0", path = "../embassy-executor" }
 embassy-cortex-m = { version = "0.1.0", path = "../embassy-cortex-m", features = ["prio-bits-4"]}
 embassy-macros = { version = "0.1.0", path = "../embassy-macros", features = ["stm32"] }
 embassy-hal-common = {version = "0.1.0", path = "../embassy-hal-common" }
@@ -72,7 +73,7 @@ quote = "1.0.15"
 stm32-metapac = { version = "0.1.0", path = "../stm32-metapac", default-features = false, features = ["metadata"]}
 
 [features]
-defmt = ["dep:defmt", "bxcan/unstable-defmt", "embassy/defmt", "embassy-embedded-hal/defmt", "embedded-io?/defmt", "embassy-usb?/defmt"]
+defmt = ["dep:defmt", "bxcan/unstable-defmt", "embassy-util/defmt", "embassy-executor/defmt", "embassy-embedded-hal/defmt", "embedded-io?/defmt", "embassy-usb?/defmt"]
 sdmmc-rs = ["embedded-sdmmc"]
 net = ["embassy-net" ]
 memory-x = ["stm32-metapac/memory-x"]
@@ -81,7 +82,7 @@ exti = []
 
 # Features starting with `_` are for internal use only. They're not intended
 # to be enabled by other crates, and are not covered by semver guarantees.
-_time-driver = ["embassy/time"]
+_time-driver = ["embassy-executor/time"]
 time-driver-any = ["_time-driver"]
 time-driver-tim2 = ["_time-driver"]
 time-driver-tim3 = ["_time-driver"]
@@ -91,7 +92,7 @@ time-driver-tim12 = ["_time-driver"]
 time-driver-tim15 = ["_time-driver"]
 
 # Enable nightly-only features
-nightly = ["embassy/nightly", "embedded-hal-1", "embedded-hal-async", "embedded-storage-async", "dep:embedded-io", "dep:embassy-usb", "embassy-embedded-hal/nightly"]
+nightly = ["embassy-executor/nightly", "embedded-hal-1", "embedded-hal-async", "embedded-storage-async", "dep:embedded-io", "dep:embassy-usb", "embassy-embedded-hal/nightly"]
 
 # Reexport stm32-metapac at `embassy_stm32::pac`.
 # This is unstable because semver-minor (non-breaking) releases of embassy-stm32 may major-bump (breaking) the stm32-metapac version.

embassy-stm32/src/dcmi.rs

@@ -1,7 +1,7 @@
 use core::task::Poll;
 
-use embassy::waitqueue::AtomicWaker;
 use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_util::waitqueue::AtomicWaker;
 use futures::future::poll_fn;
 
 use crate::gpio::sealed::AFType;

embassy-stm32/src/dma/bdma.rs

@@ -3,7 +3,7 @@
 use core::sync::atomic::{fence, Ordering};
 use core::task::Waker;
 
-use embassy::waitqueue::AtomicWaker;
+use embassy_util::waitqueue::AtomicWaker;
 
 use super::{TransferOptions, Word, WordSize};
 use crate::_generated::BDMA_CHANNEL_COUNT;

embassy-stm32/src/dma/dma.rs

@@ -1,7 +1,7 @@
 use core::sync::atomic::{fence, Ordering};
 use core::task::Waker;
 
-use embassy::waitqueue::AtomicWaker;
+use embassy_util::waitqueue::AtomicWaker;
 
 use super::{Burst, FlowControl, Request, TransferOptions, Word, WordSize};
 use crate::_generated::DMA_CHANNEL_COUNT;

embassy-stm32/src/dma/gpdma.rs

@@ -1,7 +1,7 @@
 use core::sync::atomic::{fence, Ordering};
 use core::task::Waker;
 
-use embassy::waitqueue::AtomicWaker;
+use embassy_util::waitqueue::AtomicWaker;
 
 use super::{Request, TransferOptions, Word, WordSize};
 use crate::_generated::GPDMA_CHANNEL_COUNT;

embassy-stm32/src/eth/v1/mod.rs

@@ -4,10 +4,10 @@ use core::marker::PhantomData;
 use core::sync::atomic::{fence, Ordering};
 use core::task::Waker;
 
-use embassy::waitqueue::AtomicWaker;
 use embassy_cortex_m::peripheral::{PeripheralMutex, PeripheralState, StateStorage};
 use embassy_hal_common::{into_ref, PeripheralRef};
 use embassy_net::{Device, DeviceCapabilities, LinkState, PacketBuf, MTU};
+use embassy_util::waitqueue::AtomicWaker;
 
 use crate::gpio::sealed::{AFType, Pin as __GpioPin};
 use crate::gpio::{AnyPin, Speed};

embassy-stm32/src/eth/v2/mod.rs

@@ -2,10 +2,10 @@ use core::marker::PhantomData;
 use core::sync::atomic::{fence, Ordering};
 use core::task::Waker;
 
-use embassy::waitqueue::AtomicWaker;
 use embassy_cortex_m::peripheral::{PeripheralMutex, PeripheralState, StateStorage};
 use embassy_hal_common::{into_ref, PeripheralRef};
 use embassy_net::{Device, DeviceCapabilities, LinkState, PacketBuf, MTU};
+use embassy_util::waitqueue::AtomicWaker;
 
 use crate::gpio::sealed::{AFType, Pin as _};
 use crate::gpio::{AnyPin, Speed};

embassy-stm32/src/exti.rs

@@ -3,8 +3,8 @@ use core::marker::PhantomData;
 use core::pin::Pin;
 use core::task::{Context, Poll};
 
-use embassy::waitqueue::AtomicWaker;
 use embassy_hal_common::impl_peripheral;
+use embassy_util::waitqueue::AtomicWaker;
 
 use crate::gpio::{AnyPin, Input, Pin as GpioPin};
 use crate::pac::exti::regs::Lines;

embassy-stm32/src/i2c/v2.rs

@@ -2,10 +2,10 @@ use core::cmp;
 use core::task::Poll;
 
 use atomic_polyfill::{AtomicUsize, Ordering};
-use embassy::waitqueue::AtomicWaker;
 use embassy_embedded_hal::SetConfig;
 use embassy_hal_common::drop::OnDrop;
 use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_util::waitqueue::AtomicWaker;
 use futures::future::poll_fn;
 
 use crate::dma::NoDma;

embassy-stm32/src/rng.rs

@@ -2,8 +2,8 @@
 
 use core::task::Poll;
 
-use embassy::waitqueue::AtomicWaker;
 use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_util::waitqueue::AtomicWaker;
 use futures::future::poll_fn;
 use rand_core::{CryptoRng, RngCore};
 

embassy-stm32/src/sdmmc/mod.rs

@@ -3,9 +3,9 @@
 use core::default::Default;
 use core::task::Poll;
 
-use embassy::waitqueue::AtomicWaker;
 use embassy_hal_common::drop::OnDrop;
 use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_util::waitqueue::AtomicWaker;
 use futures::future::poll_fn;
 use sdio_host::{BusWidth, CardCapacity, CardStatus, CurrentState, SDStatus, CID, CSD, OCR, SCR};
 
@@ -1507,8 +1507,8 @@ foreach_peripheral!(
                 INNER
             }
 
-            fn state() -> &'static ::embassy::waitqueue::AtomicWaker {
+            fn state() -> &'static ::embassy_util::waitqueue::AtomicWaker {
-                static WAKER: ::embassy::waitqueue::AtomicWaker = ::embassy::waitqueue::AtomicWaker::new();
+                static WAKER: ::embassy_util::waitqueue::AtomicWaker = ::embassy_util::waitqueue::AtomicWaker::new();
                 &WAKER
             }
         }

embassy-stm32/src/subghz/mod.rs

@@ -504,7 +504,7 @@ impl<'d> SubGhz<'d, NoDma, NoDma> {
     ///
     /// sg.set_standby(StandbyClk::Rc)?;
     /// unsafe { sg.set_sleep(SleepCfg::default())? };
-    /// embassy::time::Timer::after(embassy::time::Duration::from_micros(500)).await;
+    /// embassy_executor::time::Timer::after(embassy_executor::time::Duration::from_micros(500)).await;
     /// unsafe { wakeup() };
     /// # Ok::<(), embassy_stm32::subghz::Error>(())
     /// ```

embassy-stm32/src/subghz/timeout.rs

@@ -439,9 +439,9 @@ impl From<Timeout> for [u8; 3] {
     }
 }
 
-impl From<Timeout> for embassy::time::Duration {
+impl From<Timeout> for embassy_executor::time::Duration {
     fn from(to: Timeout) -> Self {
-        embassy::time::Duration::from_micros(to.as_micros().into())
+        embassy_executor::time::Duration::from_micros(to.as_micros().into())
     }
 }
 

embassy-stm32/src/subghz/tx_params.rs

@@ -44,17 +44,17 @@ impl From<RampTime> for core::time::Duration {
     }
 }
 
-impl From<RampTime> for embassy::time::Duration {
+impl From<RampTime> for embassy_executor::time::Duration {
     fn from(rt: RampTime) -> Self {
         match rt {
-            RampTime::Micros10 => embassy::time::Duration::from_micros(10),
+            RampTime::Micros10 => embassy_executor::time::Duration::from_micros(10),
-            RampTime::Micros20 => embassy::time::Duration::from_micros(20),
+            RampTime::Micros20 => embassy_executor::time::Duration::from_micros(20),
-            RampTime::Micros40 => embassy::time::Duration::from_micros(40),
+            RampTime::Micros40 => embassy_executor::time::Duration::from_micros(40),
-            RampTime::Micros80 => embassy::time::Duration::from_micros(80),
+            RampTime::Micros80 => embassy_executor::time::Duration::from_micros(80),
-            RampTime::Micros200 => embassy::time::Duration::from_micros(200),
+            RampTime::Micros200 => embassy_executor::time::Duration::from_micros(200),
-            RampTime::Micros800 => embassy::time::Duration::from_micros(800),
+            RampTime::Micros800 => embassy_executor::time::Duration::from_micros(800),
-            RampTime::Micros1700 => embassy::time::Duration::from_micros(1700),
+            RampTime::Micros1700 => embassy_executor::time::Duration::from_micros(1700),
-            RampTime::Micros3400 => embassy::time::Duration::from_micros(3400),
+            RampTime::Micros3400 => embassy_executor::time::Duration::from_micros(3400),
         }
     }
 }

embassy-stm32/src/time_driver.rs

@@ -4,10 +4,10 @@ use core::sync::atomic::{compiler_fence, Ordering};
 use core::{mem, ptr};
 
 use atomic_polyfill::{AtomicU32, AtomicU8};
-use embassy::blocking_mutex::raw::CriticalSectionRawMutex;
+use embassy_executor::time::driver::{AlarmHandle, Driver};
-use embassy::blocking_mutex::Mutex;
+use embassy_executor::time::TICKS_PER_SECOND;
-use embassy::time::driver::{AlarmHandle, Driver};
+use embassy_util::blocking_mutex::raw::CriticalSectionRawMutex;
-use embassy::time::TICKS_PER_SECOND;
+use embassy_util::blocking_mutex::Mutex;
 use stm32_metapac::timer::regs;
 
 use crate::interrupt::{CriticalSection, InterruptExt};
@@ -133,7 +133,7 @@ struct RtcDriver {
 
 const ALARM_STATE_NEW: AlarmState = AlarmState::new();
 
-embassy::time_driver_impl!(static DRIVER: RtcDriver = RtcDriver {
+embassy_executor::time_driver_impl!(static DRIVER: RtcDriver = RtcDriver {
     period: AtomicU32::new(0),
     alarm_count: AtomicU8::new(0),
     alarms: Mutex::const_new(CriticalSectionRawMutex::new(), [ALARM_STATE_NEW; ALARM_COUNT]),

embassy-stm32/src/usart/buffered.rs

@@ -2,9 +2,9 @@ use core::future::Future;
 use core::task::Poll;
 
 use atomic_polyfill::{compiler_fence, Ordering};
-use embassy::waitqueue::WakerRegistration;
 use embassy_cortex_m::peripheral::{PeripheralMutex, PeripheralState, StateStorage};
 use embassy_hal_common::ring_buffer::RingBuffer;
+use embassy_util::waitqueue::WakerRegistration;
 use futures::future::poll_fn;
 
 use super::*;

embassy-stm32/src/usb/usb.rs

@@ -5,11 +5,11 @@ use core::sync::atomic::Ordering;
 use core::task::Poll;
 
 use atomic_polyfill::{AtomicBool, AtomicU8};
-use embassy::time::{block_for, Duration};
+use embassy_executor::time::{block_for, Duration};
-use embassy::waitqueue::AtomicWaker;
 use embassy_hal_common::into_ref;
 use embassy_usb::driver::{self, EndpointAllocError, EndpointError, Event, Unsupported};
 use embassy_usb::types::{EndpointAddress, EndpointInfo, EndpointType, UsbDirection};
+use embassy_util::waitqueue::AtomicWaker;
 use futures::future::poll_fn;
 use futures::Future;
 use pac::common::{Reg, RW};

embassy-usb-hid/Cargo.toml

@@ -6,7 +6,7 @@ edition = "2021"
 [package.metadata.embassy_docs]
 src_base = "https://github.com/embassy-rs/embassy/blob/embassy-usb-hid-v$VERSION/embassy-usb-hid/src/"
 src_base_git = "https://github.com/embassy-rs/embassy/blob/$COMMIT/embassy-usb-hid/src/"
-features = ["defmt", "embassy/time-tick-1mhz"]
+features = ["defmt", "embassy-executor/time-tick-1mhz"]
 flavors = [
     { name = "default", target = "thumbv7em-none-eabihf" },
 ]
@@ -16,7 +16,7 @@ default = ["usbd-hid"]
 usbd-hid = ["dep:usbd-hid", "ssmarshal"]
 
 [dependencies]
-embassy = { version = "0.1.0", path = "../embassy" }
+embassy-util = { version = "0.1.0", path = "../embassy-util" }
 embassy-usb = { version = "0.1.0", path = "../embassy-usb" }
 
 defmt = { version = "0.3", optional = true }

embassy-usb-hid/src/lib.rs

@@ -11,7 +11,6 @@ use core::mem::MaybeUninit;
 use core::ops::Range;
 use core::sync::atomic::{AtomicUsize, Ordering};
 
-use embassy::time::Duration;
 use embassy_usb::control::{ControlHandler, InResponse, OutResponse, Request, RequestType};
 use embassy_usb::driver::{Driver, Endpoint, EndpointError, EndpointIn, EndpointOut};
 use embassy_usb::Builder;
@@ -373,7 +372,7 @@ pub trait RequestHandler {
     /// If `id` is `None`, get the idle rate for all reports. Returning `None`
     /// will reject the control request. Any duration at or above 1.024 seconds
     /// or below 4ms will be returned as an indefinite idle rate.
-    fn get_idle(&self, id: Option<ReportId>) -> Option<Duration> {
+    fn get_idle_ms(&self, id: Option<ReportId>) -> Option<u32> {
         let _ = id;
         None
     }
@@ -381,9 +380,9 @@ pub trait RequestHandler {
     /// Set the idle rate for `id` to `dur`.
     ///
     /// If `id` is `None`, set the idle rate of all input reports to `dur`. If
-    /// an indefinite duration is requested, `dur` will be set to `Duration::MAX`.
+    /// an indefinite duration is requested, `dur` will be set to `u32::MAX`.
-    fn set_idle(&self, id: Option<ReportId>, dur: Duration) {
+    fn set_idle_ms(&self, id: Option<ReportId>, duration_ms: u32) {
-        let _ = (id, dur);
+        let _ = (id, duration_ms);
     }
 }
 
@@ -447,13 +446,9 @@ impl<'d> ControlHandler for Control<'d> {
                     if let Some(handler) = self.request_handler {
                         let id = req.value as u8;
                         let id = (id != 0).then(|| ReportId::In(id));
-                        let dur = u64::from(req.value >> 8);
+                        let dur = u32::from(req.value >> 8);
-                        let dur = if dur == 0 {
+                        let dur = if dur == 0 { u32::MAX } else { 4 * dur };
-                            Duration::MAX
+                        handler.set_idle_ms(id, dur);
-                        } else {
-                            Duration::from_millis(4 * dur)
-                        };
-                        handler.set_idle(id, dur);
                     }
                     OutResponse::Accepted
                 }
@@ -495,8 +490,8 @@ impl<'d> ControlHandler for Control<'d> {
                 if let Some(handler) = self.request_handler {
                     let id = req.value as u8;
                     let id = (id != 0).then(|| ReportId::In(id));
-                    if let Some(dur) = handler.get_idle(id) {
+                    if let Some(dur) = handler.get_idle_ms(id) {
-                        let dur = u8::try_from(dur.as_millis() / 4).unwrap_or(0);
+                        let dur = u8::try_from(dur / 4).unwrap_or(0);
                         buf[0] = dur;
                         InResponse::Accepted(&buf[0..1])
                     } else {

embassy-usb-ncm/Cargo.toml

@@ -12,7 +12,7 @@ flavors = [
 ]
 
 [dependencies]
-embassy = { version = "0.1.0", path = "../embassy" }
+embassy-util = { version = "0.1.0", path = "../embassy-util" }
 embassy-usb = { version = "0.1.0", path = "../embassy-usb" }
 
 defmt = { version = "0.3", optional = true }

embassy-usb-serial/Cargo.toml

@@ -12,7 +12,7 @@ flavors = [
 ]
 
 [dependencies]
-embassy = { version = "0.1.0", path = "../embassy" }
+embassy-util = { version = "0.1.0", path = "../embassy-util" }
 embassy-usb = { version = "0.1.0", path = "../embassy-usb" }
 
 defmt = { version = "0.3", optional = true }

embassy-usb-serial/src/lib.rs

@@ -9,11 +9,11 @@ use core::cell::Cell;
 use core::mem::{self, MaybeUninit};
 use core::sync::atomic::{AtomicBool, Ordering};
 
-use embassy::blocking_mutex::CriticalSectionMutex;
 use embassy_usb::control::{self, ControlHandler, InResponse, OutResponse, Request};
 use embassy_usb::driver::{Driver, Endpoint, EndpointError, EndpointIn, EndpointOut};
 use embassy_usb::types::*;
 use embassy_usb::Builder;
+use embassy_util::blocking_mutex::CriticalSectionMutex;
 
 /// This should be used as `device_class` when building the `UsbDevice`.
 pub const USB_CLASS_CDC: u8 = 0x02;

embassy-usb/Cargo.toml

@@ -12,7 +12,7 @@ flavors = [
 ]
 
 [dependencies]
-embassy = { version = "0.1.0", path = "../embassy" }
+embassy-util = { version = "0.1.0", path = "../embassy-util" }
 
 defmt = { version = "0.3", optional = true }
 log = { version = "0.4.14", optional = true }

embassy-usb/src/lib.rs

@@ -12,7 +12,7 @@ mod descriptor_reader;
 pub mod driver;
 pub mod types;
 
-use embassy::util::{select, Either};
+use embassy_util::{select, Either};
 use heapless::Vec;
 
 pub use self::builder::{Builder, Config};

embassy-util/Cargo.toml

@@ -0,0 +1,28 @@
+[package]
+name = "embassy-util"
+version = "0.1.0"
+edition = "2021"
+
+[package.metadata.embassy_docs]
+src_base = "https://github.com/embassy-rs/embassy/blob/embassy-util-v$VERSION/embassy-util/src/"
+src_base_git = "https://github.com/embassy-rs/embassy/blob/$COMMIT/embassy-util/src/"
+features = ["nightly", "defmt", "unstable-traits", "time", "time-tick-1mhz"]
+flavors = [
+    { name = "default", target = "x86_64-unknown-linux-gnu" },
+]
+
+[dependencies]
+defmt = { version = "0.3", optional = true }
+log = { version = "0.4.14", optional = true }
+
+futures-util = { version = "0.3.17", default-features = false }
+atomic-polyfill = "0.1.5"
+critical-section = "0.2.5"
+heapless = "0.7.5"
+cfg-if = "1.0.0"
+
+[dev-dependencies]
+futures-executor = { version = "0.3.17", features = [ "thread-pool" ] }
+futures-test = "0.3.17"
+futures-timer = "3.0.2"
+futures-util = { version = "0.3.17", features = [ "channel" ] }

embassy-util/build.rs

@@ -0,0 +1,29 @@
+use std::env;
+
+fn main() {
+    let target = env::var("TARGET").unwrap();
+
+    if target.starts_with("thumbv6m-") {
+        println!("cargo:rustc-cfg=cortex_m");
+        println!("cargo:rustc-cfg=armv6m");
+    } else if target.starts_with("thumbv7m-") {
+        println!("cargo:rustc-cfg=cortex_m");
+        println!("cargo:rustc-cfg=armv7m");
+    } else if target.starts_with("thumbv7em-") {
+        println!("cargo:rustc-cfg=cortex_m");
+        println!("cargo:rustc-cfg=armv7m");
+        println!("cargo:rustc-cfg=armv7em"); // (not currently used)
+    } else if target.starts_with("thumbv8m.base") {
+        println!("cargo:rustc-cfg=cortex_m");
+        println!("cargo:rustc-cfg=armv8m");
+        println!("cargo:rustc-cfg=armv8m_base");
+    } else if target.starts_with("thumbv8m.main") {
+        println!("cargo:rustc-cfg=cortex_m");
+        println!("cargo:rustc-cfg=armv8m");
+        println!("cargo:rustc-cfg=armv8m_main");
+    }
+
+    if target.ends_with("-eabihf") {
+        println!("cargo:rustc-cfg=has_fpu");
+    }
+}

embassy-util/src/blocking_mutex/mod.rs

@@ -34,7 +34,6 @@ unsafe impl<R: RawMutex + Sync, T: ?Sized + Send> Sync for Mutex<R, T> {}
 
 impl<R: RawMutex, T> Mutex<R, T> {
     /// Creates a new mutex in an unlocked state ready for use.
-    #[cfg(feature = "nightly")]
     #[inline]
     pub const fn new(val: T) -> Mutex<R, T> {
         Mutex {
@@ -43,16 +42,6 @@ impl<R: RawMutex, T> Mutex<R, T> {
         }
     }
 
-    /// Creates a new mutex in an unlocked state ready for use.
-    #[cfg(not(feature = "nightly"))]
-    #[inline]
-    pub fn new(val: T) -> Mutex<R, T> {
-        Mutex {
-            raw: R::INIT,
-            data: UnsafeCell::new(val),
-        }
-    }
-
     /// Creates a critical section and grants temporary access to the protected data.
     pub fn lock<U>(&self, f: impl FnOnce(&T) -> U) -> U {
         self.raw.lock(|| {

embassy-util/src/blocking_mutex/raw.rs

@@ -141,7 +141,8 @@ mod thread_mode {
         return Some("main") == std::thread::current().name();
 
         #[cfg(not(feature = "std"))]
-        return cortex_m::peripheral::SCB::vect_active() == cortex_m::peripheral::scb::VectActive::ThreadMode;
+        // ICSR.VECTACTIVE == 0
+        return unsafe { (0xE000ED04 as *const u32).read_volatile() } & 0x1FF == 0;
     }
 }
 #[cfg(any(cortex_m, feature = "std"))]