Merge branch 'embassy-rs:main' into ticker_send_sync

17 files changed, 620 insertions, 1165 deletions

diff --git a/embassy-time/CHANGELOG.md b/embassy-time/CHANGELOG.md
index d8c0c7d08..df093949f 100644
--- a/embassy-time/CHANGELOG.md
+++ b/embassy-time/CHANGELOG.md
@@ -5,6 +5,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 0.3.0 - 2024-01-11
+
+- Update `embedded-hal-async` to `1.0.0`
+- Update `embedded-hal v1` to `1.0.0`
+- Split the time driver to a separate `embassy-time-driver` crate.
+
 ## 0.2.0 - 2023-12-04
 
 - Added tick rates in multiples of 10 kHz
diff --git a/embassy-time/Cargo.toml b/embassy-time/Cargo.toml
index 94e79382f..6b0a0f22d 100644
--- a/embassy-time/Cargo.toml
+++ b/embassy-time/Cargo.toml
@@ -1,9 +1,10 @@
 [package]
 name = "embassy-time"
-version = "0.2.0"
+version = "0.3.0"
 edition = "2021"
 description = "Instant and Duration for embedded no-std systems, with async timer support"
 repository = "https://github.com/embassy-rs/embassy"
+documentation = "https://docs.embassy.dev/embassy-time"
 readme = "README.md"
 license = "MIT OR Apache-2.0"
 categories = [
@@ -13,12 +14,6 @@ categories = [
     "asynchronous",
 ]
 
-# Prevent multiple copies of this crate in the same binary.
-# Needed because different copies might get different tick rates, causing
-# wrong delays if the time driver is using one copy and user code is using another.
-# This is especially common when mixing crates from crates.io and git.
-links = "embassy-time"
-
 [package.metadata.embassy_docs]
 src_base = "https://github.com/embassy-rs/embassy/blob/embassy-time-v$VERSION/embassy-time/src/"
 src_base_git = "https://github.com/embassy-rs/embassy/blob/$COMMIT/embassy-time/src/"
@@ -32,217 +27,394 @@ features = ["defmt", "std"]
 std = ["tick-hz-1_000_000", "critical-section/std"]
 wasm = ["dep:wasm-bindgen", "dep:js-sys", "dep:wasm-timer", "tick-hz-1_000_000"]
 
-# Display a timestamp of the number of seconds since startup next to defmt log messages
-# To use this you must have a time driver provided.
+## Display a timestamp of the number of seconds since startup next to defmt log messages
+## To use this you must have a time driver provided.
 defmt-timestamp-uptime = ["defmt"]
 
-# Create a global, generic queue that can be used with any executor
-# To use this you must have a time driver provided.
+## Create a `MockDriver` that can be manually advanced for testing purposes.
+mock-driver = ["tick-hz-1_000_000"]
+
+#! ### Generic Queue
+
+## Create a global, generic queue that can be used with any executor.
+## To use this you must have a time driver provided.
 generic-queue = []
 
-# Set the number of timers for the generic queue.
-#
-# At most 1 `generic-queue-*` feature can be enabled. If none is enabled, a default of 64 timers is used.
-# 
-# When using embassy-time from libraries, you should *not* enable any `generic-queue-*` feature, to allow the
-# end user to pick.
+#! The following features set how many timers are used for the generic queue. At most one
+#! `generic-queue-*` feature can be enabled. If none is enabled, a default of 64 timers is used.
+#! 
+#! When using embassy-time from libraries, you should *not* enable any `generic-queue-*` feature, to allow the
+#! end user to pick.
+
+## Generic Queue with 8 timers
 generic-queue-8 = ["generic-queue"]
+## Generic Queue with 16 timers
 generic-queue-16 = ["generic-queue"]
+## Generic Queue with 32 timers
 generic-queue-32 = ["generic-queue"]
+## Generic Queue with 64 timers
 generic-queue-64 = ["generic-queue"]
+## Generic Queue with 128 timers
 generic-queue-128 = ["generic-queue"]
 
-# Create a `MockDriver` that can be manually advanced for testing purposes.
-mock-driver = ["tick-hz-1_000_000"]
-
-# Set the `embassy_time` tick rate.
-#
-# At most 1 `tick-*` feature can be enabled. If none is enabled, a default of 1MHz is used.
-# 
-# If the time driver in use supports using arbitrary tick rates, you can enable one `tick-*`
-# feature from your binary crate to set the tick rate. The driver will use configured tick rate.
-# If the time driver supports a fixed tick rate, it will enable one feature itself, so you should
-# not enable one. Check the time driver documentation for details.
-#
-# When using embassy-time from libraries, you should *not* enable any `tick-*` feature, to allow the
-# end user or the driver to pick.
+#! ### Tick Rate
+#!
+#! At most 1 `tick-*` feature can be enabled. If none is enabled, a default of 1MHz is used.
+#! 
+#! If the time driver in use supports using arbitrary tick rates, you can enable one `tick-*`
+#! feature from your binary crate to set the tick rate. The driver will use configured tick rate.
+#! If the time driver supports a fixed tick rate, it will enable one feature itself, so you should
+#! not enable one. Check the time driver documentation for details.
+#!
+#! When using embassy-time from libraries, you should *not* enable any `tick-*` feature, to allow the
+#! end user or the driver to pick.
+#! <details>
+#!   <summary>Available tick rates:</summary>
+#! <!-- Next line must be left empty for the features to render correctly! -->
+#! 
 
 # BEGIN TICKS
 # Generated by gen_tick.py. DO NOT EDIT.
-tick-hz-1 = []
-tick-hz-10 = []
-tick-hz-100 = []
-tick-hz-1_000 = []
-tick-hz-10_000 = []
-tick-hz-100_000 = []
-tick-hz-1_000_000 = []
-tick-hz-10_000_000 = []
-tick-hz-100_000_000 = []
-tick-hz-1_000_000_000 = []
-tick-hz-2 = []
-tick-hz-4 = []
-tick-hz-8 = []
-tick-hz-16 = []
-tick-hz-32 = []
-tick-hz-64 = []
-tick-hz-128 = []
-tick-hz-256 = []
-tick-hz-512 = []
-tick-hz-1_024 = []
-tick-hz-2_048 = []
-tick-hz-4_096 = []
-tick-hz-8_192 = []
-tick-hz-16_384 = []
-tick-hz-32_768 = []
-tick-hz-65_536 = []
-tick-hz-131_072 = []
-tick-hz-262_144 = []
-tick-hz-524_288 = []
-tick-hz-1_048_576 = []
-tick-hz-2_097_152 = []
-tick-hz-4_194_304 = []
-tick-hz-8_388_608 = []
-tick-hz-16_777_216 = []
-tick-hz-2_000 = []
-tick-hz-4_000 = []
-tick-hz-8_000 = []
-tick-hz-16_000 = []
-tick-hz-32_000 = []
-tick-hz-64_000 = []
-tick-hz-128_000 = []
-tick-hz-256_000 = []
-tick-hz-512_000 = []
-tick-hz-1_024_000 = []
-tick-hz-2_048_000 = []
-tick-hz-4_096_000 = []
-tick-hz-8_192_000 = []
-tick-hz-16_384_000 = []
-tick-hz-32_768_000 = []
-tick-hz-65_536_000 = []
-tick-hz-131_072_000 = []
-tick-hz-262_144_000 = []
-tick-hz-524_288_000 = []
-tick-hz-20_000 = []
-tick-hz-40_000 = []
-tick-hz-80_000 = []
-tick-hz-160_000 = []
-tick-hz-320_000 = []
-tick-hz-640_000 = []
-tick-hz-1_280_000 = []
-tick-hz-2_560_000 = []
-tick-hz-5_120_000 = []
-tick-hz-10_240_000 = []
-tick-hz-20_480_000 = []
-tick-hz-40_960_000 = []
-tick-hz-81_920_000 = []
-tick-hz-163_840_000 = []
-tick-hz-327_680_000 = []
-tick-hz-655_360_000 = []
-tick-hz-1_310_720_000 = []
-tick-hz-2_621_440_000 = []
-tick-hz-5_242_880_000 = []
-tick-hz-2_000_000 = []
-tick-hz-3_000_000 = []
-tick-hz-4_000_000 = []
-tick-hz-6_000_000 = []
-tick-hz-8_000_000 = []
-tick-hz-9_000_000 = []
-tick-hz-12_000_000 = []
-tick-hz-16_000_000 = []
-tick-hz-18_000_000 = []
-tick-hz-24_000_000 = []
-tick-hz-32_000_000 = []
-tick-hz-36_000_000 = []
-tick-hz-48_000_000 = []
-tick-hz-64_000_000 = []
-tick-hz-72_000_000 = []
-tick-hz-96_000_000 = []
-tick-hz-128_000_000 = []
-tick-hz-144_000_000 = []
-tick-hz-192_000_000 = []
-tick-hz-256_000_000 = []
-tick-hz-288_000_000 = []
-tick-hz-384_000_000 = []
-tick-hz-512_000_000 = []
-tick-hz-576_000_000 = []
-tick-hz-768_000_000 = []
-tick-hz-20_000_000 = []
-tick-hz-30_000_000 = []
-tick-hz-40_000_000 = []
-tick-hz-50_000_000 = []
-tick-hz-60_000_000 = []
-tick-hz-70_000_000 = []
-tick-hz-80_000_000 = []
-tick-hz-90_000_000 = []
-tick-hz-110_000_000 = []
-tick-hz-120_000_000 = []
-tick-hz-130_000_000 = []
-tick-hz-140_000_000 = []
-tick-hz-150_000_000 = []
-tick-hz-160_000_000 = []
-tick-hz-170_000_000 = []
-tick-hz-180_000_000 = []
-tick-hz-190_000_000 = []
-tick-hz-200_000_000 = []
-tick-hz-210_000_000 = []
-tick-hz-220_000_000 = []
-tick-hz-230_000_000 = []
-tick-hz-240_000_000 = []
-tick-hz-250_000_000 = []
-tick-hz-260_000_000 = []
-tick-hz-270_000_000 = []
-tick-hz-280_000_000 = []
-tick-hz-290_000_000 = []
-tick-hz-300_000_000 = []
-tick-hz-320_000_000 = []
-tick-hz-340_000_000 = []
-tick-hz-360_000_000 = []
-tick-hz-380_000_000 = []
-tick-hz-400_000_000 = []
-tick-hz-420_000_000 = []
-tick-hz-440_000_000 = []
-tick-hz-460_000_000 = []
-tick-hz-480_000_000 = []
-tick-hz-500_000_000 = []
-tick-hz-520_000_000 = []
-tick-hz-540_000_000 = []
-tick-hz-560_000_000 = []
-tick-hz-580_000_000 = []
-tick-hz-600_000_000 = []
-tick-hz-620_000_000 = []
-tick-hz-640_000_000 = []
-tick-hz-660_000_000 = []
-tick-hz-680_000_000 = []
-tick-hz-700_000_000 = []
-tick-hz-720_000_000 = []
-tick-hz-740_000_000 = []
-tick-hz-760_000_000 = []
-tick-hz-780_000_000 = []
-tick-hz-800_000_000 = []
-tick-hz-820_000_000 = []
-tick-hz-840_000_000 = []
-tick-hz-860_000_000 = []
-tick-hz-880_000_000 = []
-tick-hz-900_000_000 = []
-tick-hz-920_000_000 = []
-tick-hz-940_000_000 = []
-tick-hz-960_000_000 = []
-tick-hz-980_000_000 = []
+## 1Hz Tick Rate
+tick-hz-1 = ["embassy-time-driver/tick-hz-1"]
+## 2Hz Tick Rate
+tick-hz-2 = ["embassy-time-driver/tick-hz-2"]
+## 4Hz Tick Rate
+tick-hz-4 = ["embassy-time-driver/tick-hz-4"]
+## 8Hz Tick Rate
+tick-hz-8 = ["embassy-time-driver/tick-hz-8"]
+## 10Hz Tick Rate
+tick-hz-10 = ["embassy-time-driver/tick-hz-10"]
+## 16Hz Tick Rate
+tick-hz-16 = ["embassy-time-driver/tick-hz-16"]
+## 32Hz Tick Rate
+tick-hz-32 = ["embassy-time-driver/tick-hz-32"]
+## 64Hz Tick Rate
+tick-hz-64 = ["embassy-time-driver/tick-hz-64"]
+## 100Hz Tick Rate
+tick-hz-100 = ["embassy-time-driver/tick-hz-100"]
+## 128Hz Tick Rate
+tick-hz-128 = ["embassy-time-driver/tick-hz-128"]
+## 256Hz Tick Rate
+tick-hz-256 = ["embassy-time-driver/tick-hz-256"]
+## 512Hz Tick Rate
+tick-hz-512 = ["embassy-time-driver/tick-hz-512"]
+## 1.0kHz Tick Rate
+tick-hz-1_000 = ["embassy-time-driver/tick-hz-1_000"]
+## 1.024kHz Tick Rate
+tick-hz-1_024 = ["embassy-time-driver/tick-hz-1_024"]
+## 2.0kHz Tick Rate
+tick-hz-2_000 = ["embassy-time-driver/tick-hz-2_000"]
+## 2.048kHz Tick Rate
+tick-hz-2_048 = ["embassy-time-driver/tick-hz-2_048"]
+## 4.0kHz Tick Rate
+tick-hz-4_000 = ["embassy-time-driver/tick-hz-4_000"]
+## 4.096kHz Tick Rate
+tick-hz-4_096 = ["embassy-time-driver/tick-hz-4_096"]
+## 8.0kHz Tick Rate
+tick-hz-8_000 = ["embassy-time-driver/tick-hz-8_000"]
+## 8.192kHz Tick Rate
+tick-hz-8_192 = ["embassy-time-driver/tick-hz-8_192"]
+## 10.0kHz Tick Rate
+tick-hz-10_000 = ["embassy-time-driver/tick-hz-10_000"]
+## 16.0kHz Tick Rate
+tick-hz-16_000 = ["embassy-time-driver/tick-hz-16_000"]
+## 16.384kHz Tick Rate
+tick-hz-16_384 = ["embassy-time-driver/tick-hz-16_384"]
+## 20.0kHz Tick Rate
+tick-hz-20_000 = ["embassy-time-driver/tick-hz-20_000"]
+## 32.0kHz Tick Rate
+tick-hz-32_000 = ["embassy-time-driver/tick-hz-32_000"]
+## 32.768kHz Tick Rate
+tick-hz-32_768 = ["embassy-time-driver/tick-hz-32_768"]
+## 40.0kHz Tick Rate
+tick-hz-40_000 = ["embassy-time-driver/tick-hz-40_000"]
+## 64.0kHz Tick Rate
+tick-hz-64_000 = ["embassy-time-driver/tick-hz-64_000"]
+## 65.536kHz Tick Rate
+tick-hz-65_536 = ["embassy-time-driver/tick-hz-65_536"]
+## 80.0kHz Tick Rate
+tick-hz-80_000 = ["embassy-time-driver/tick-hz-80_000"]
+## 100.0kHz Tick Rate
+tick-hz-100_000 = ["embassy-time-driver/tick-hz-100_000"]
+## 128.0kHz Tick Rate
+tick-hz-128_000 = ["embassy-time-driver/tick-hz-128_000"]
+## 131.072kHz Tick Rate
+tick-hz-131_072 = ["embassy-time-driver/tick-hz-131_072"]
+## 160.0kHz Tick Rate
+tick-hz-160_000 = ["embassy-time-driver/tick-hz-160_000"]
+## 256.0kHz Tick Rate
+tick-hz-256_000 = ["embassy-time-driver/tick-hz-256_000"]
+## 262.144kHz Tick Rate
+tick-hz-262_144 = ["embassy-time-driver/tick-hz-262_144"]
+## 320.0kHz Tick Rate
+tick-hz-320_000 = ["embassy-time-driver/tick-hz-320_000"]
+## 512.0kHz Tick Rate
+tick-hz-512_000 = ["embassy-time-driver/tick-hz-512_000"]
+## 524.288kHz Tick Rate
+tick-hz-524_288 = ["embassy-time-driver/tick-hz-524_288"]
+## 640.0kHz Tick Rate
+tick-hz-640_000 = ["embassy-time-driver/tick-hz-640_000"]
+## 1.0MHz Tick Rate
+tick-hz-1_000_000 = ["embassy-time-driver/tick-hz-1_000_000"]
+## 1.024MHz Tick Rate
+tick-hz-1_024_000 = ["embassy-time-driver/tick-hz-1_024_000"]
+## 1.048576MHz Tick Rate
+tick-hz-1_048_576 = ["embassy-time-driver/tick-hz-1_048_576"]
+## 1.28MHz Tick Rate
+tick-hz-1_280_000 = ["embassy-time-driver/tick-hz-1_280_000"]
+## 2.0MHz Tick Rate
+tick-hz-2_000_000 = ["embassy-time-driver/tick-hz-2_000_000"]
+## 2.048MHz Tick Rate
+tick-hz-2_048_000 = ["embassy-time-driver/tick-hz-2_048_000"]
+## 2.097152MHz Tick Rate
+tick-hz-2_097_152 = ["embassy-time-driver/tick-hz-2_097_152"]
+## 2.56MHz Tick Rate
+tick-hz-2_560_000 = ["embassy-time-driver/tick-hz-2_560_000"]
+## 3.0MHz Tick Rate
+tick-hz-3_000_000 = ["embassy-time-driver/tick-hz-3_000_000"]
+## 4.0MHz Tick Rate
+tick-hz-4_000_000 = ["embassy-time-driver/tick-hz-4_000_000"]
+## 4.096MHz Tick Rate
+tick-hz-4_096_000 = ["embassy-time-driver/tick-hz-4_096_000"]
+## 4.194304MHz Tick Rate
+tick-hz-4_194_304 = ["embassy-time-driver/tick-hz-4_194_304"]
+## 5.12MHz Tick Rate
+tick-hz-5_120_000 = ["embassy-time-driver/tick-hz-5_120_000"]
+## 6.0MHz Tick Rate
+tick-hz-6_000_000 = ["embassy-time-driver/tick-hz-6_000_000"]
+## 8.0MHz Tick Rate
+tick-hz-8_000_000 = ["embassy-time-driver/tick-hz-8_000_000"]
+## 8.192MHz Tick Rate
+tick-hz-8_192_000 = ["embassy-time-driver/tick-hz-8_192_000"]
+## 8.388608MHz Tick Rate
+tick-hz-8_388_608 = ["embassy-time-driver/tick-hz-8_388_608"]
+## 9.0MHz Tick Rate
+tick-hz-9_000_000 = ["embassy-time-driver/tick-hz-9_000_000"]
+## 10.0MHz Tick Rate
+tick-hz-10_000_000 = ["embassy-time-driver/tick-hz-10_000_000"]
+## 10.24MHz Tick Rate
+tick-hz-10_240_000 = ["embassy-time-driver/tick-hz-10_240_000"]
+## 12.0MHz Tick Rate
+tick-hz-12_000_000 = ["embassy-time-driver/tick-hz-12_000_000"]
+## 16.0MHz Tick Rate
+tick-hz-16_000_000 = ["embassy-time-driver/tick-hz-16_000_000"]
+## 16.384MHz Tick Rate
+tick-hz-16_384_000 = ["embassy-time-driver/tick-hz-16_384_000"]
+## 16.777216MHz Tick Rate
+tick-hz-16_777_216 = ["embassy-time-driver/tick-hz-16_777_216"]
+## 18.0MHz Tick Rate
+tick-hz-18_000_000 = ["embassy-time-driver/tick-hz-18_000_000"]
+## 20.0MHz Tick Rate
+tick-hz-20_000_000 = ["embassy-time-driver/tick-hz-20_000_000"]
+## 20.48MHz Tick Rate
+tick-hz-20_480_000 = ["embassy-time-driver/tick-hz-20_480_000"]
+## 24.0MHz Tick Rate
+tick-hz-24_000_000 = ["embassy-time-driver/tick-hz-24_000_000"]
+## 30.0MHz Tick Rate
+tick-hz-30_000_000 = ["embassy-time-driver/tick-hz-30_000_000"]
+## 32.0MHz Tick Rate
+tick-hz-32_000_000 = ["embassy-time-driver/tick-hz-32_000_000"]
+## 32.768MHz Tick Rate
+tick-hz-32_768_000 = ["embassy-time-driver/tick-hz-32_768_000"]
+## 36.0MHz Tick Rate
+tick-hz-36_000_000 = ["embassy-time-driver/tick-hz-36_000_000"]
+## 40.0MHz Tick Rate
+tick-hz-40_000_000 = ["embassy-time-driver/tick-hz-40_000_000"]
+## 40.96MHz Tick Rate
+tick-hz-40_960_000 = ["embassy-time-driver/tick-hz-40_960_000"]
+## 48.0MHz Tick Rate
+tick-hz-48_000_000 = ["embassy-time-driver/tick-hz-48_000_000"]
+## 50.0MHz Tick Rate
+tick-hz-50_000_000 = ["embassy-time-driver/tick-hz-50_000_000"]
+## 60.0MHz Tick Rate
+tick-hz-60_000_000 = ["embassy-time-driver/tick-hz-60_000_000"]
+## 64.0MHz Tick Rate
+tick-hz-64_000_000 = ["embassy-time-driver/tick-hz-64_000_000"]
+## 65.536MHz Tick Rate
+tick-hz-65_536_000 = ["embassy-time-driver/tick-hz-65_536_000"]
+## 70.0MHz Tick Rate
+tick-hz-70_000_000 = ["embassy-time-driver/tick-hz-70_000_000"]
+## 72.0MHz Tick Rate
+tick-hz-72_000_000 = ["embassy-time-driver/tick-hz-72_000_000"]
+## 80.0MHz Tick Rate
+tick-hz-80_000_000 = ["embassy-time-driver/tick-hz-80_000_000"]
+## 81.92MHz Tick Rate
+tick-hz-81_920_000 = ["embassy-time-driver/tick-hz-81_920_000"]
+## 90.0MHz Tick Rate
+tick-hz-90_000_000 = ["embassy-time-driver/tick-hz-90_000_000"]
+## 96.0MHz Tick Rate
+tick-hz-96_000_000 = ["embassy-time-driver/tick-hz-96_000_000"]
+## 100.0MHz Tick Rate
+tick-hz-100_000_000 = ["embassy-time-driver/tick-hz-100_000_000"]
+## 110.0MHz Tick Rate
+tick-hz-110_000_000 = ["embassy-time-driver/tick-hz-110_000_000"]
+## 120.0MHz Tick Rate
+tick-hz-120_000_000 = ["embassy-time-driver/tick-hz-120_000_000"]
+## 128.0MHz Tick Rate
+tick-hz-128_000_000 = ["embassy-time-driver/tick-hz-128_000_000"]
+## 130.0MHz Tick Rate
+tick-hz-130_000_000 = ["embassy-time-driver/tick-hz-130_000_000"]
+## 131.072MHz Tick Rate
+tick-hz-131_072_000 = ["embassy-time-driver/tick-hz-131_072_000"]
+## 140.0MHz Tick Rate
+tick-hz-140_000_000 = ["embassy-time-driver/tick-hz-140_000_000"]
+## 144.0MHz Tick Rate
+tick-hz-144_000_000 = ["embassy-time-driver/tick-hz-144_000_000"]
+## 150.0MHz Tick Rate
+tick-hz-150_000_000 = ["embassy-time-driver/tick-hz-150_000_000"]
+## 160.0MHz Tick Rate
+tick-hz-160_000_000 = ["embassy-time-driver/tick-hz-160_000_000"]
+## 163.84MHz Tick Rate
+tick-hz-163_840_000 = ["embassy-time-driver/tick-hz-163_840_000"]
+## 170.0MHz Tick Rate
+tick-hz-170_000_000 = ["embassy-time-driver/tick-hz-170_000_000"]
+## 180.0MHz Tick Rate
+tick-hz-180_000_000 = ["embassy-time-driver/tick-hz-180_000_000"]
+## 190.0MHz Tick Rate
+tick-hz-190_000_000 = ["embassy-time-driver/tick-hz-190_000_000"]
+## 192.0MHz Tick Rate
+tick-hz-192_000_000 = ["embassy-time-driver/tick-hz-192_000_000"]
+## 200.0MHz Tick Rate
+tick-hz-200_000_000 = ["embassy-time-driver/tick-hz-200_000_000"]
+## 210.0MHz Tick Rate
+tick-hz-210_000_000 = ["embassy-time-driver/tick-hz-210_000_000"]
+## 220.0MHz Tick Rate
+tick-hz-220_000_000 = ["embassy-time-driver/tick-hz-220_000_000"]
+## 230.0MHz Tick Rate
+tick-hz-230_000_000 = ["embassy-time-driver/tick-hz-230_000_000"]
+## 240.0MHz Tick Rate
+tick-hz-240_000_000 = ["embassy-time-driver/tick-hz-240_000_000"]
+## 250.0MHz Tick Rate
+tick-hz-250_000_000 = ["embassy-time-driver/tick-hz-250_000_000"]
+## 256.0MHz Tick Rate
+tick-hz-256_000_000 = ["embassy-time-driver/tick-hz-256_000_000"]
+## 260.0MHz Tick Rate
+tick-hz-260_000_000 = ["embassy-time-driver/tick-hz-260_000_000"]
+## 262.144MHz Tick Rate
+tick-hz-262_144_000 = ["embassy-time-driver/tick-hz-262_144_000"]
+## 270.0MHz Tick Rate
+tick-hz-270_000_000 = ["embassy-time-driver/tick-hz-270_000_000"]
+## 280.0MHz Tick Rate
+tick-hz-280_000_000 = ["embassy-time-driver/tick-hz-280_000_000"]
+## 288.0MHz Tick Rate
+tick-hz-288_000_000 = ["embassy-time-driver/tick-hz-288_000_000"]
+## 290.0MHz Tick Rate
+tick-hz-290_000_000 = ["embassy-time-driver/tick-hz-290_000_000"]
+## 300.0MHz Tick Rate
+tick-hz-300_000_000 = ["embassy-time-driver/tick-hz-300_000_000"]
+## 320.0MHz Tick Rate
+tick-hz-320_000_000 = ["embassy-time-driver/tick-hz-320_000_000"]
+## 327.68MHz Tick Rate
+tick-hz-327_680_000 = ["embassy-time-driver/tick-hz-327_680_000"]
+## 340.0MHz Tick Rate
+tick-hz-340_000_000 = ["embassy-time-driver/tick-hz-340_000_000"]
+## 360.0MHz Tick Rate
+tick-hz-360_000_000 = ["embassy-time-driver/tick-hz-360_000_000"]
+## 380.0MHz Tick Rate
+tick-hz-380_000_000 = ["embassy-time-driver/tick-hz-380_000_000"]
+## 384.0MHz Tick Rate
+tick-hz-384_000_000 = ["embassy-time-driver/tick-hz-384_000_000"]
+## 400.0MHz Tick Rate
+tick-hz-400_000_000 = ["embassy-time-driver/tick-hz-400_000_000"]
+## 420.0MHz Tick Rate
+tick-hz-420_000_000 = ["embassy-time-driver/tick-hz-420_000_000"]
+## 440.0MHz Tick Rate
+tick-hz-440_000_000 = ["embassy-time-driver/tick-hz-440_000_000"]
+## 460.0MHz Tick Rate
+tick-hz-460_000_000 = ["embassy-time-driver/tick-hz-460_000_000"]
+## 480.0MHz Tick Rate
+tick-hz-480_000_000 = ["embassy-time-driver/tick-hz-480_000_000"]
+## 500.0MHz Tick Rate
+tick-hz-500_000_000 = ["embassy-time-driver/tick-hz-500_000_000"]
+## 512.0MHz Tick Rate
+tick-hz-512_000_000 = ["embassy-time-driver/tick-hz-512_000_000"]
+## 520.0MHz Tick Rate
+tick-hz-520_000_000 = ["embassy-time-driver/tick-hz-520_000_000"]
+## 524.288MHz Tick Rate
+tick-hz-524_288_000 = ["embassy-time-driver/tick-hz-524_288_000"]
+## 540.0MHz Tick Rate
+tick-hz-540_000_000 = ["embassy-time-driver/tick-hz-540_000_000"]
+## 560.0MHz Tick Rate
+tick-hz-560_000_000 = ["embassy-time-driver/tick-hz-560_000_000"]
+## 576.0MHz Tick Rate
+tick-hz-576_000_000 = ["embassy-time-driver/tick-hz-576_000_000"]
+## 580.0MHz Tick Rate
+tick-hz-580_000_000 = ["embassy-time-driver/tick-hz-580_000_000"]
+## 600.0MHz Tick Rate
+tick-hz-600_000_000 = ["embassy-time-driver/tick-hz-600_000_000"]
+## 620.0MHz Tick Rate
+tick-hz-620_000_000 = ["embassy-time-driver/tick-hz-620_000_000"]
+## 640.0MHz Tick Rate
+tick-hz-640_000_000 = ["embassy-time-driver/tick-hz-640_000_000"]
+## 655.36MHz Tick Rate
+tick-hz-655_360_000 = ["embassy-time-driver/tick-hz-655_360_000"]
+## 660.0MHz Tick Rate
+tick-hz-660_000_000 = ["embassy-time-driver/tick-hz-660_000_000"]
+## 680.0MHz Tick Rate
+tick-hz-680_000_000 = ["embassy-time-driver/tick-hz-680_000_000"]
+## 700.0MHz Tick Rate
+tick-hz-700_000_000 = ["embassy-time-driver/tick-hz-700_000_000"]
+## 720.0MHz Tick Rate
+tick-hz-720_000_000 = ["embassy-time-driver/tick-hz-720_000_000"]
+## 740.0MHz Tick Rate
+tick-hz-740_000_000 = ["embassy-time-driver/tick-hz-740_000_000"]
+## 760.0MHz Tick Rate
+tick-hz-760_000_000 = ["embassy-time-driver/tick-hz-760_000_000"]
+## 768.0MHz Tick Rate
+tick-hz-768_000_000 = ["embassy-time-driver/tick-hz-768_000_000"]
+## 780.0MHz Tick Rate
+tick-hz-780_000_000 = ["embassy-time-driver/tick-hz-780_000_000"]
+## 800.0MHz Tick Rate
+tick-hz-800_000_000 = ["embassy-time-driver/tick-hz-800_000_000"]
+## 820.0MHz Tick Rate
+tick-hz-820_000_000 = ["embassy-time-driver/tick-hz-820_000_000"]
+## 840.0MHz Tick Rate
+tick-hz-840_000_000 = ["embassy-time-driver/tick-hz-840_000_000"]
+## 860.0MHz Tick Rate
+tick-hz-860_000_000 = ["embassy-time-driver/tick-hz-860_000_000"]
+## 880.0MHz Tick Rate
+tick-hz-880_000_000 = ["embassy-time-driver/tick-hz-880_000_000"]
+## 900.0MHz Tick Rate
+tick-hz-900_000_000 = ["embassy-time-driver/tick-hz-900_000_000"]
+## 920.0MHz Tick Rate
+tick-hz-920_000_000 = ["embassy-time-driver/tick-hz-920_000_000"]
+## 940.0MHz Tick Rate
+tick-hz-940_000_000 = ["embassy-time-driver/tick-hz-940_000_000"]
+## 960.0MHz Tick Rate
+tick-hz-960_000_000 = ["embassy-time-driver/tick-hz-960_000_000"]
+## 980.0MHz Tick Rate
+tick-hz-980_000_000 = ["embassy-time-driver/tick-hz-980_000_000"]
+## 1.0GHz Tick Rate
+tick-hz-1_000_000_000 = ["embassy-time-driver/tick-hz-1_000_000_000"]
+## 1.31072GHz Tick Rate
+tick-hz-1_310_720_000 = ["embassy-time-driver/tick-hz-1_310_720_000"]
+## 2.62144GHz Tick Rate
+tick-hz-2_621_440_000 = ["embassy-time-driver/tick-hz-2_621_440_000"]
+## 5.24288GHz Tick Rate
+tick-hz-5_242_880_000 = ["embassy-time-driver/tick-hz-5_242_880_000"]
 # END TICKS
 
+#! </details>
+
 [dependencies]
+embassy-time-driver = { version = "0.1.0", path = "../embassy-time-driver" }
+embassy-time-queue-driver = { version = "0.1.0", path = "../embassy-time-queue-driver" }
+
 defmt = { version = "0.3", optional = true }
 log = { version = "0.4.14", optional = true }
 
 embedded-hal-02 = { package = "embedded-hal", version = "0.2.6" }
-embedded-hal-1 = { package = "embedded-hal", version = "=1.0.0-rc.2" }
-embedded-hal-async = { version = "=1.0.0-rc.2" }
+embedded-hal-1 = { package = "embedded-hal", version = "1.0" }
+embedded-hal-async = { version = "1.0" }
 
 futures-util = { version = "0.3.17", default-features = false }
 critical-section = "1.1"
 cfg-if = "1.0.0"
 heapless = "0.8"
 
+document-features = "0.2.7"
+
 # WASM dependencies
 wasm-bindgen = { version = "0.2.81", optional = true }
 js-sys = { version = "0.3", optional = true }
@@ -251,4 +423,4 @@ wasm-timer = { version = "0.2.5", optional = true }
 [dev-dependencies]
 serial_test = "0.9"
 critical-section = { version = "1.1", features = ["std"] }
-embassy-executor = { version = "0.4.0", path = "../embassy-executor" }
+embassy-executor = { version = "0.5.0", path = "../embassy-executor" }
diff --git a/embassy-time/README.md b/embassy-time/README.md
index 2be80ff9c..f5d46df7b 100644
--- a/embassy-time/README.md
+++ b/embassy-time/README.md
@@ -3,25 +3,40 @@
 Timekeeping, delays and timeouts.
 
 Timekeeping is done with elapsed time since system boot. Time is represented in
-ticks, where the tick rate is defined by the current driver, usually to match
-the tick rate of the hardware.
+ticks, where the tick rate is defined either by the driver (in the case of a fixed-rate
+tick) or chosen by the user with a [tick rate](#tick-rate) feature. The chosen
+tick rate applies to everything in `embassy-time` and thus determines the maximum 
+timing resolution of <code>(1 / tick_rate) seconds</code>.
 
-Tick counts are 64 bits. At the highest supported tick rate of 1Mhz this supports
+Tick counts are 64 bits. The default tick rate of 1Mhz supports
 representing time spans of up to ~584558 years, which is big enough for all practical
 purposes and allows not having to worry about overflows.
 
+## Global time driver
+
+The `time` module is backed by a global "time driver" specified at build time.
+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
+requiring generic parameters.
+
+For more details, check the [`embassy_time_driver`](https://crates.io/crates/embassy-time-driver) crate.
+
+## Instants and Durations
+
 [`Instant`] represents a given instant of time (relative to system boot), and [`Duration`]
 represents the duration of a span of time. They implement the math operations you'd expect,
 like addition and substraction.
 
-# Delays and timeouts
+## Delays and timeouts
 
 [`Timer`] allows performing async delays. [`Ticker`] allows periodic delays without drifting over time.
 
 An implementation of the `embedded-hal` delay traits is provided by [`Delay`], for compatibility
 with libraries from the ecosystem.
 
-# Wall-clock time
+## Wall-clock time
 
 The `time` module deals exclusively with a monotonically increasing tick count.
 Therefore it has no direct support for wall-clock time ("real life" datetimes
@@ -30,14 +45,3 @@ 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"
 and "seconds since unix epoch".
-
-# Time driver
-
-The `time` module is backed by a global "time driver" specified at build time.
-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
-requiring generic parameters.
-
-For more details, check the [`driver`] module.
diff --git a/embassy-time/build.rs b/embassy-time/build.rs
deleted file mode 100644
index 78bd27ec7..000000000
--- a/embassy-time/build.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-use std::env;
-use std::ffi::OsString;
-use std::process::Command;
-
-fn main() {
-    println!("cargo:rerun-if-changed=build.rs");
-
-    let rustc = env::var_os("RUSTC").unwrap_or_else(|| OsString::from("rustc"));
-
-    let output = Command::new(rustc)
-        .arg("--version")
-        .output()
-        .expect("failed to run `rustc --version`");
-
-    if String::from_utf8_lossy(&output.stdout).contains("nightly") {
-        println!("cargo:rustc-cfg=nightly");
-    }
-}
diff --git a/embassy-time/gen_tick.py b/embassy-time/gen_tick.py
deleted file mode 100644
index d4a175914..000000000
--- a/embassy-time/gen_tick.py
+++ /dev/null
@@ -1,60 +0,0 @@
-import os
-import toml
-from glob import glob
-
-abspath = os.path.abspath(__file__)
-dname = os.path.dirname(abspath)
-os.chdir(dname)
-
-ticks = []
-for i in range(10):
-    ticks.append(10**i)
-for i in range(1, 25):
-    ticks.append(2**i)
-for i in range(1, 20):
-    ticks.append(2**i * 1000)
-for i in range(1, 20):
-    ticks.append(2**i * 10000)
-for i in range(1, 10):
-    ticks.append(2**i * 1000000)
-    ticks.append(2**i * 9 // 8 * 1000000)
-    ticks.append(2**i * 3 // 2 * 1000000)
-for i in range(1, 30):
-    ticks.append(10 * i * 1_000_000)
-for i in range(15, 50):
-    ticks.append(20 * i * 1_000_000)
-
-seen = set()
-ticks = [x for x in ticks if not (x in seen or seen.add(x))]
-
-# ========= Update Cargo.toml
-
-things = {f'tick-hz-{hz:_}': [] for hz in ticks}
-
-SEPARATOR_START = '# BEGIN TICKS\n'
-SEPARATOR_END = '# END TICKS\n'
-HELP = '# Generated by gen_tick.py. DO NOT EDIT.\n'
-with open('Cargo.toml', 'r') as f:
-    data = f.read()
-before, data = data.split(SEPARATOR_START, maxsplit=1)
-_, after = data.split(SEPARATOR_END, maxsplit=1)
-data = before + SEPARATOR_START + HELP + \
-    toml.dumps(things) + SEPARATOR_END + after
-with open('Cargo.toml', 'w') as f:
-    f.write(data)
-
-# ========= Update src/tick.rs
-
-with open('src/tick.rs', 'w') as f:
-
-    f.write('// Generated by gen_tick.py. DO NOT EDIT.\n\n')
-    for hz in ticks:
-        f.write(
-            f'#[cfg(feature = "tick-hz-{hz:_}")] pub const TICK_HZ: u64 = {hz:_};\n')
-    f.write('#[cfg(not(any(\n')
-    for hz in ticks:
-        f.write(f'feature = "tick-hz-{hz:_}",\n')
-    f.write(')))] pub const TICK_HZ: u64 = 1_000_000;')
-
-
-os.system('rustfmt src/tick.rs')
diff --git a/embassy-time/src/delay.rs b/embassy-time/src/delay.rs
index 7ef5961f0..f77859d4a 100644
--- a/embassy-time/src/delay.rs
+++ b/embassy-time/src/delay.rs
@@ -13,6 +13,7 @@ pub fn block_for(duration: Duration) {
 /// the amount provided, but accuracy can be affected by many factors, including interrupt usage.
 /// Make sure to use a suitable tick rate for your use case. The tick rate is defined by the currently
 /// active driver.
+#[derive(Clone)]
 pub struct Delay;
 
 impl embedded_hal_1::delay::DelayNs for Delay {
diff --git a/embassy-time/src/driver.rs b/embassy-time/src/driver.rs
deleted file mode 100644
index 5fe7becaf..000000000
--- a/embassy-time/src/driver.rs
+++ /dev/null
@@ -1,175 +0,0 @@
-//! Time driver interface
-//!
-//! This module defines the interface a driver needs to implement to power the `embassy_time` module.
-//!
-//! # Implementing a driver
-//!
-//! - Define a struct `MyDriver`
-//! - Implement [`Driver`] for it
-//! - Register it as the global driver with [`time_driver_impl`](crate::time_driver_impl).
-//! - Enable the Cargo features `embassy-executor/time` and one of `embassy-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-*`.
-//!
-//! # Linkage details
-//!
-//! Instead of the usual "trait + generic params" approach, calls from embassy to the driver are done via `extern` functions.
-//!
-//! `embassy` internally defines the driver functions as `extern "Rust" { fn _embassy_time_now() -> u64; }` and calls them.
-//! The driver crate defines the functions as `#[no_mangle] fn _embassy_time_now() -> u64`. The linker will resolve the
-//! calls from the `embassy` crate to call into the driver crate.
-//!
-//! If there is none or multiple drivers in the crate tree, linking will fail.
-//!
-//! This method has a few key advantages for something as foundational as timekeeping:
-//!
-//! - The time driver is available everywhere easily, without having to thread the implementation
-//!   through generic parameters. This is especially helpful for libraries.
-//! - It means comparing `Instant`s will always make sense: if there were multiple drivers
-//!   active, one could compare an `Instant` from driver A to an `Instant` from driver B, which
-//!   would yield incorrect results.
-//!
-//! # Example
-//!
-//! ```
-//! use embassy_time::driver::{Driver, AlarmHandle};
-//!
-//! struct MyDriver{} // not public!
-//! embassy_time::time_driver_impl!(static DRIVER: MyDriver = MyDriver{});
-//!
-//! impl Driver for MyDriver {
-//!     fn now(&self) -> u64 {
-//!         todo!()
-//!     }
-//!     unsafe fn allocate_alarm(&self) -> Option<AlarmHandle> {
-//!         todo!()
-//!     }
-//!     fn set_alarm_callback(&self, alarm: AlarmHandle, callback: fn(*mut ()), ctx: *mut ()) {
-//!         todo!()
-//!     }
-//!     fn set_alarm(&self, alarm: AlarmHandle, timestamp: u64) -> bool {
-//!         todo!()
-//!     }
-//! }
-//! ```
-
-/// Alarm handle, assigned by the driver.
-#[derive(Clone, Copy)]
-pub struct AlarmHandle {
-    id: u8,
-}
-
-impl AlarmHandle {
-    /// Create an AlarmHandle
-    ///
-    /// Safety: May only be called by the current global Driver impl.
-    /// The impl is allowed to rely on the fact that all `AlarmHandle` instances
-    /// are created by itself in unsafe code (e.g. indexing operations)
-    pub unsafe fn new(id: u8) -> Self {
-        Self { id }
-    }
-
-    /// Get the ID of the AlarmHandle.
-    pub fn id(&self) -> u8 {
-        self.id
-    }
-}
-
-/// Time driver
-pub trait Driver: Send + Sync + 'static {
-    /// Return the current timestamp in ticks.
-    ///
-    /// Implementations MUST ensure that:
-    /// - This is guaranteed to be monotonic, i.e. a call to now() will always return
-    ///   a greater or equal value than earler calls. Time can't "roll backwards".
-    /// - It "never" overflows. It must not overflow in a sufficiently long time frame, say
-    ///   in 10_000 years (Human civilization is likely to already have self-destructed
-    ///   10_000 years from now.). This means if your hardware only has 16bit/32bit timers
-    ///   you MUST extend them to 64-bit, for example by counting overflows in software,
-    ///   or chaining multiple timers together.
-    fn now(&self) -> u64;
-
-    /// Try allocating an alarm handle. Returns None if no alarms left.
-    /// Initially the alarm has no callback set, and a null `ctx` pointer.
-    ///
-    /// # Safety
-    /// It is UB to make the alarm fire before setting a callback.
-    unsafe fn allocate_alarm(&self) -> Option<AlarmHandle>;
-
-    /// Sets the callback function to be called when the alarm triggers.
-    /// The callback may be called from any context (interrupt or thread mode).
-    fn set_alarm_callback(&self, alarm: AlarmHandle, callback: fn(*mut ()), ctx: *mut ());
-
-    /// Sets an alarm at the given timestamp. When the current timestamp reaches the alarm
-    /// timestamp, the provided callback function will be called.
-    ///
-    /// The `Driver` implementation should guarantee that the alarm callback is never called synchronously from `set_alarm`.
-    /// Rather - if `timestamp` is already in the past - `false` should be returned and alarm should not be set,
-    /// or alternatively, the driver should return `true` and arrange to call the alarm callback as soon as possible, but not synchronously.
-    ///
-    /// When callback is called, it is guaranteed that now() will return a value greater or equal than timestamp.
-    ///
-    /// Only one alarm can be active at a time for each AlarmHandle. This overwrites any previously-set alarm if any.
-    fn set_alarm(&self, alarm: AlarmHandle, timestamp: u64) -> bool;
-}
-
-extern "Rust" {
-    fn _embassy_time_now() -> u64;
-    fn _embassy_time_allocate_alarm() -> Option<AlarmHandle>;
-    fn _embassy_time_set_alarm_callback(alarm: AlarmHandle, callback: fn(*mut ()), ctx: *mut ());
-    fn _embassy_time_set_alarm(alarm: AlarmHandle, timestamp: u64) -> bool;
-}
-
-/// See [`Driver::now`]
-pub fn now() -> u64 {
-    unsafe { _embassy_time_now() }
-}
-
-/// See [`Driver::allocate_alarm`]
-///
-/// Safety: it is UB to make the alarm fire before setting a callback.
-pub unsafe fn allocate_alarm() -> Option<AlarmHandle> {
-    _embassy_time_allocate_alarm()
-}
-
-/// See [`Driver::set_alarm_callback`]
-pub fn set_alarm_callback(alarm: AlarmHandle, callback: fn(*mut ()), ctx: *mut ()) {
-    unsafe { _embassy_time_set_alarm_callback(alarm, callback, ctx) }
-}
-
-/// See [`Driver::set_alarm`]
-pub fn set_alarm(alarm: AlarmHandle, timestamp: u64) -> bool {
-    unsafe { _embassy_time_set_alarm(alarm, timestamp) }
-}
-
-/// Set the time Driver implementation.
-///
-/// See the module documentation for an example.
-#[macro_export]
-macro_rules! time_driver_impl {
-    (static $name:ident: $t: ty = $val:expr) => {
-        static $name: $t = $val;
-
-        #[no_mangle]
-        fn _embassy_time_now() -> u64 {
-            <$t as $crate::driver::Driver>::now(&$name)
-        }
-
-        #[no_mangle]
-        unsafe fn _embassy_time_allocate_alarm() -> Option<$crate::driver::AlarmHandle> {
-            <$t as $crate::driver::Driver>::allocate_alarm(&$name)
-        }
-
-        #[no_mangle]
-        fn _embassy_time_set_alarm_callback(alarm: $crate::driver::AlarmHandle, callback: fn(*mut ()), ctx: *mut ()) {
-            <$t as $crate::driver::Driver>::set_alarm_callback(&$name, alarm, callback, ctx)
-        }
-
-        #[no_mangle]
-        fn _embassy_time_set_alarm(alarm: $crate::driver::AlarmHandle, timestamp: u64) -> bool {
-            <$t as $crate::driver::Driver>::set_alarm(&$name, alarm, timestamp)
-        }
-    };
-}
diff --git a/embassy-time/src/driver_mock.rs b/embassy-time/src/driver_mock.rs
index c255615c7..8587f9172 100644
--- a/embassy-time/src/driver_mock.rs
+++ b/embassy-time/src/driver_mock.rs
@@ -1,14 +1,14 @@
-use core::cell::Cell;
+use core::cell::RefCell;
 
 use critical_section::Mutex as CsMutex;
+use embassy_time_driver::{AlarmHandle, Driver};
 
-use crate::driver::{AlarmHandle, Driver};
 use crate::{Duration, Instant};
 
 /// A mock driver that can be manually advanced.
 /// This is useful for testing code that works with [`Instant`] and [`Duration`].
 ///
-/// This driver cannot currently be used to test runtime functionality, such as
+/// This driver can also be used to test runtime functionality, such as
 /// timers, delays, etc.
 ///
 /// # Example
@@ -26,43 +26,196 @@ use crate::{Duration, Instant};
 ///     assert_eq!(true, has_a_second_passed(reference));
 /// }
 /// ```
-pub struct MockDriver {
-    now: CsMutex<Cell<Instant>>,
-}
+pub struct MockDriver(CsMutex<RefCell<InnerMockDriver>>);
 
-crate::time_driver_impl!(static DRIVER: MockDriver = MockDriver {
-    now: CsMutex::new(Cell::new(Instant::from_ticks(0))),
-});
+embassy_time_driver::time_driver_impl!(static DRIVER: MockDriver = MockDriver::new());
 
 impl MockDriver {
+    /// Creates a new mock driver.
+    pub const fn new() -> Self {
+        Self(CsMutex::new(RefCell::new(InnerMockDriver::new())))
+    }
+
     /// Gets a reference to the global mock driver.
     pub fn get() -> &'static MockDriver {
         &DRIVER
     }
 
-    /// Advances the time by the specified [`Duration`].
-    pub fn advance(&self, duration: Duration) {
+    /// Resets the internal state of the mock driver
+    /// This will clear and deallocate all alarms, and reset the current time to 0.
+    pub fn reset(&self) {
         critical_section::with(|cs| {
-            let now = self.now.borrow(cs).get().as_ticks();
-            self.now.borrow(cs).set(Instant::from_ticks(now + duration.as_ticks()));
+            self.0.borrow(cs).replace(InnerMockDriver::new());
         });
     }
+
+    /// Advances the time by the specified [`Duration`].
+    /// Calling any alarm callbacks that are due.
+    pub fn advance(&self, duration: Duration) {
+        let notify = {
+            critical_section::with(|cs| {
+                let mut inner = self.0.borrow_ref_mut(cs);
+
+                inner.now += duration;
+
+                let now = inner.now.as_ticks();
+
+                inner
+                    .alarm
+                    .as_mut()
+                    .filter(|alarm| alarm.timestamp <= now)
+                    .map(|alarm| {
+                        alarm.timestamp = u64::MAX;
+
+                        (alarm.callback, alarm.ctx)
+                    })
+            })
+        };
+
+        if let Some((callback, ctx)) = notify {
+            (callback)(ctx);
+        }
+    }
 }
 
 impl Driver for MockDriver {
     fn now(&self) -> u64 {
-        critical_section::with(|cs| self.now.borrow(cs).get().as_ticks() as u64)
+        critical_section::with(|cs| self.0.borrow_ref(cs).now).as_ticks()
     }
 
     unsafe fn allocate_alarm(&self) -> Option<AlarmHandle> {
-        unimplemented!("MockDriver does not support runtime features that require an executor");
+        critical_section::with(|cs| {
+            let mut inner = self.0.borrow_ref_mut(cs);
+
+            if inner.alarm.is_some() {
+                None
+            } else {
+                inner.alarm.replace(AlarmState::new());
+
+                Some(AlarmHandle::new(0))
+            }
+        })
     }
 
-    fn set_alarm_callback(&self, _alarm: AlarmHandle, _callback: fn(*mut ()), _ctx: *mut ()) {
-        unimplemented!("MockDriver does not support runtime features that require an executor");
+    fn set_alarm_callback(&self, _alarm: AlarmHandle, callback: fn(*mut ()), ctx: *mut ()) {
+        critical_section::with(|cs| {
+            let mut inner = self.0.borrow_ref_mut(cs);
+
+            let Some(alarm) = inner.alarm.as_mut() else {
+                panic!("Alarm not allocated");
+            };
+
+            alarm.callback = callback;
+            alarm.ctx = ctx;
+        });
     }
 
-    fn set_alarm(&self, _alarm: AlarmHandle, _timestamp: u64) -> bool {
-        unimplemented!("MockDriver does not support runtime features that require an executor");
+    fn set_alarm(&self, _alarm: AlarmHandle, timestamp: u64) -> bool {
+        critical_section::with(|cs| {
+            let mut inner = self.0.borrow_ref_mut(cs);
+
+            if timestamp <= inner.now.as_ticks() {
+                false
+            } else {
+                let Some(alarm) = inner.alarm.as_mut() else {
+                    panic!("Alarm not allocated");
+                };
+
+                alarm.timestamp = timestamp;
+                true
+            }
+        })
+    }
+}
+
+struct InnerMockDriver {
+    now: Instant,
+    alarm: Option<AlarmState>,
+}
+
+impl InnerMockDriver {
+    const fn new() -> Self {
+        Self {
+            now: Instant::from_ticks(0),
+            alarm: None,
+        }
+    }
+}
+
+struct AlarmState {
+    timestamp: u64,
+    callback: fn(*mut ()),
+    ctx: *mut (),
+}
+
+impl AlarmState {
+    const fn new() -> Self {
+        Self {
+            timestamp: u64::MAX,
+            callback: Self::noop,
+            ctx: core::ptr::null_mut(),
+        }
+    }
+
+    fn noop(_ctx: *mut ()) {}
+}
+
+unsafe impl Send for AlarmState {}
+
+#[cfg(test)]
+mod tests {
+    use serial_test::serial;
+
+    use super::*;
+
+    fn setup() {
+        DRIVER.reset();
+    }
+
+    #[test]
+    #[serial]
+    fn test_advance() {
+        setup();
+
+        let driver = MockDriver::get();
+        let reference = driver.now();
+        driver.advance(Duration::from_secs(1));
+        assert_eq!(Duration::from_secs(1).as_ticks(), driver.now() - reference);
+    }
+
+    #[test]
+    #[serial]
+    fn test_set_alarm_not_in_future() {
+        setup();
+
+        let driver = MockDriver::get();
+        let alarm = unsafe { AlarmHandle::new(0) };
+        assert_eq!(false, driver.set_alarm(alarm, driver.now()));
+    }
+
+    #[test]
+    #[serial]
+    fn test_alarm() {
+        setup();
+
+        let driver = MockDriver::get();
+        let alarm = unsafe { driver.allocate_alarm() }.expect("No alarms available");
+        static mut CALLBACK_CALLED: bool = false;
+        let ctx = &mut () as *mut ();
+        driver.set_alarm_callback(alarm, |_| unsafe { CALLBACK_CALLED = true }, ctx);
+        driver.set_alarm(alarm, driver.now() + 1);
+        assert_eq!(false, unsafe { CALLBACK_CALLED });
+        driver.advance(Duration::from_secs(1));
+        assert_eq!(true, unsafe { CALLBACK_CALLED });
+    }
+
+    #[test]
+    #[serial]
+    fn test_allocate_alarm() {
+        setup();
+
+        let driver = MockDriver::get();
+        assert!(unsafe { driver.allocate_alarm() }.is_some());
+        assert!(unsafe { driver.allocate_alarm() }.is_none());
     }
 }
diff --git a/embassy-time/src/driver_std.rs b/embassy-time/src/driver_std.rs
index 32db47a37..d182f8331 100644
--- a/embassy-time/src/driver_std.rs
+++ b/embassy-time/src/driver_std.rs
@@ -6,8 +6,7 @@ use std::time::{Duration as StdDuration, Instant as StdInstant};
 use std::{mem, ptr, thread};
 
 use critical_section::Mutex as CsMutex;
-
-use crate::driver::{AlarmHandle, Driver};
+use embassy_time_driver::{AlarmHandle, Driver};
 
 const ALARM_COUNT: usize = 4;
 
@@ -45,7 +44,7 @@ struct TimeDriver {
 }
 
 const ALARM_NEW: AlarmState = AlarmState::new();
-crate::time_driver_impl!(static DRIVER: TimeDriver = TimeDriver {
+embassy_time_driver::time_driver_impl!(static DRIVER: TimeDriver = TimeDriver {
     alarm_count: AtomicU8::new(0),
 
     once: Once::new(),
diff --git a/embassy-time/src/driver_wasm.rs b/embassy-time/src/driver_wasm.rs
index 0f672dc75..ad884f060 100644
--- a/embassy-time/src/driver_wasm.rs
+++ b/embassy-time/src/driver_wasm.rs
@@ -4,11 +4,10 @@ use std::mem::MaybeUninit;
 use std::ptr;
 use std::sync::{Mutex, Once};
 
+use embassy_time_driver::{AlarmHandle, Driver};
 use wasm_bindgen::prelude::*;
 use wasm_timer::Instant as StdInstant;
 
-use crate::driver::{AlarmHandle, Driver};
-
 const ALARM_COUNT: usize = 4;
 
 struct AlarmState {
@@ -42,7 +41,7 @@ struct TimeDriver {
 }
 
 const ALARM_NEW: AlarmState = AlarmState::new();
-crate::time_driver_impl!(static DRIVER: TimeDriver = TimeDriver {
+embassy_time_driver::time_driver_impl!(static DRIVER: TimeDriver = TimeDriver {
     alarm_count: AtomicU8::new(0),
     once: Once::new(),
     alarms: UninitCell::uninit(),
diff --git a/embassy-time/src/fmt.rs b/embassy-time/src/fmt.rs
index 78e583c1c..2ac42c557 100644
--- a/embassy-time/src/fmt.rs
+++ b/embassy-time/src/fmt.rs
@@ -1,5 +1,5 @@
 #![macro_use]
-#![allow(unused_macros)]
+#![allow(unused)]
 
 use core::fmt::{Debug, Display, LowerHex};
 
@@ -229,7 +229,6 @@ impl<T, E> Try for Result<T, E> {
     }
 }
 
-#[allow(unused)]
 pub(crate) struct Bytes<'a>(pub &'a [u8]);
 
 impl<'a> Debug for Bytes<'a> {
diff --git a/embassy-time/src/instant.rs b/embassy-time/src/instant.rs
index 5571cdd15..909f1b173 100644
--- a/embassy-time/src/instant.rs
+++ b/embassy-time/src/instant.rs
@@ -1,7 +1,7 @@
 use core::fmt;
 use core::ops::{Add, AddAssign, Sub, SubAssign};
 
-use super::{driver, Duration, GCD_1K, GCD_1M, TICK_HZ};
+use super::{Duration, GCD_1K, GCD_1M, TICK_HZ};
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
@@ -18,7 +18,9 @@ impl Instant {
 
     /// Returns an Instant representing the current time.
     pub fn now() -> Instant {
-        Instant { ticks: driver::now() }
+        Instant {
+            ticks: embassy_time_driver::now(),
+        }
     }
 
     /// Create an Instant from a tick count since system boot.
diff --git a/embassy-time/src/lib.rs b/embassy-time/src/lib.rs
index 82a7ee0df..3c8575ee9 100644
--- a/embassy-time/src/lib.rs
+++ b/embassy-time/src/lib.rs
@@ -1,20 +1,18 @@
 #![cfg_attr(not(any(feature = "std", feature = "wasm", test)), no_std)]
-#![cfg_attr(nightly, feature(async_fn_in_trait, impl_trait_projections))]
-#![cfg_attr(nightly, allow(stable_features, unknown_lints))]
 #![allow(async_fn_in_trait)]
 #![doc = include_str!("../README.md")]
 #![allow(clippy::new_without_default)]
 #![warn(missing_docs)]
 
+//! ## Feature flags
+#![doc = document_features::document_features!(feature_label = r#"<span class="stab portability"><code>{feature}</code></span>"#)]
+
 // This mod MUST go first, so that the others see its macros.
 pub(crate) mod fmt;
 
 mod delay;
-pub mod driver;
 mod duration;
 mod instant;
-pub mod queue;
-mod tick;
 mod timer;
 
 #[cfg(feature = "mock-driver")]
@@ -32,16 +30,9 @@ mod queue_generic;
 
 pub use delay::{block_for, Delay};
 pub use duration::Duration;
+pub use embassy_time_driver::TICK_HZ;
 pub use instant::Instant;
-pub use timer::{with_timeout, Ticker, TimeoutError, Timer};
-
-/// Ticks per second of the global timebase.
-///
-/// This value is specified by the `tick-*` Cargo features, which
-/// should be set by the time driver. Some drivers support a fixed tick rate, others
-/// allow you to choose a tick rate with Cargo features of their own. You should not
-/// set the `tick-*` features for embassy yourself as an end user.
-pub const TICK_HZ: u64 = tick::TICK_HZ;
+pub use timer::{with_deadline, with_timeout, Ticker, TimeoutError, Timer};
 
 const fn gcd(a: u64, b: u64) -> u64 {
     if b == 0 {
diff --git a/embassy-time/src/queue.rs b/embassy-time/src/queue.rs
deleted file mode 100644
index c6f8b440a..000000000
--- a/embassy-time/src/queue.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-//! Timer queue implementation
-//!
-//! This module defines the interface a timer queue needs to implement to power the `embassy_time` module.
-//!
-//! # Implementing a timer queue
-//!
-//! - Define a struct `MyTimerQueue`
-//! - Implement [`TimerQueue`] for it
-//! - Register it as the global timer queue with [`timer_queue_impl`](crate::timer_queue_impl).
-//!
-//! # Linkage details
-//!
-//! Check the documentation of the [`driver`](crate::driver) module for more information.
-//!
-//! Similarly to driver, if there is none or multiple timer queues in the crate tree, linking will fail.
-//!
-//! # Example
-//!
-//! ```
-//! use core::task::Waker;
-//!
-//! use embassy_time::Instant;
-//! use embassy_time::queue::{TimerQueue};
-//!
-//! struct MyTimerQueue{}; // not public!
-//! embassy_time::timer_queue_impl!(static QUEUE: MyTimerQueue = MyTimerQueue{});
-//!
-//! impl TimerQueue for MyTimerQueue {
-//!     fn schedule_wake(&'static self, at: Instant, waker: &Waker) {
-//!         todo!()
-//!     }
-//! }
-//! ```
-use core::task::Waker;
-
-use crate::Instant;
-
-/// Timer queue
-pub trait TimerQueue {
-    /// Schedules a waker in the queue to be awoken at moment `at`.
-    /// If this moment is in the past, the waker might be awoken immediately.
-    fn schedule_wake(&'static self, at: Instant, waker: &Waker);
-}
-
-/// Set the TimerQueue implementation.
-///
-/// See the module documentation for an example.
-#[macro_export]
-macro_rules! timer_queue_impl {
-    (static $name:ident: $t: ty = $val:expr) => {
-        static $name: $t = $val;
-
-        #[no_mangle]
-        fn _embassy_time_schedule_wake(at: $crate::Instant, waker: &core::task::Waker) {
-            <$t as $crate::queue::TimerQueue>::schedule_wake(&$name, at, waker);
-        }
-    };
-}
diff --git a/embassy-time/src/queue_generic.rs b/embassy-time/src/queue_generic.rs
index 77947ab29..cf7a986d5 100644
--- a/embassy-time/src/queue_generic.rs
+++ b/embassy-time/src/queue_generic.rs
@@ -3,10 +3,10 @@ use core::cmp::{min, Ordering};
 use core::task::Waker;
 
 use critical_section::Mutex;
+use embassy_time_driver::{allocate_alarm, set_alarm, set_alarm_callback, AlarmHandle};
+use embassy_time_queue_driver::TimerQueue;
 use heapless::Vec;
 
-use crate::driver::{allocate_alarm, set_alarm, set_alarm_callback, AlarmHandle};
-use crate::queue::TimerQueue;
 use crate::Instant;
 
 #[cfg(feature = "generic-queue-8")]
@@ -167,111 +167,25 @@ impl Queue {
 }
 
 impl TimerQueue for Queue {
-    fn schedule_wake(&'static self, at: Instant, waker: &Waker) {
-        Queue::schedule_wake(self, at, waker);
+    fn schedule_wake(&'static self, at: u64, waker: &Waker) {
+        Queue::schedule_wake(self, Instant::from_ticks(at), waker);
     }
 }
 
-crate::timer_queue_impl!(static QUEUE: Queue = Queue::new());
+embassy_time_queue_driver::timer_queue_impl!(static QUEUE: Queue = Queue::new());
 
 #[cfg(test)]
+#[cfg(feature = "mock-driver")]
 mod tests {
     use core::cell::Cell;
     use core::task::{RawWaker, RawWakerVTable, Waker};
     use std::rc::Rc;
-    use std::sync::Mutex;
 
     use serial_test::serial;
 
-    use crate::driver::{AlarmHandle, Driver};
+    use crate::driver_mock::MockDriver;
     use crate::queue_generic::QUEUE;
-    use crate::Instant;
-
-    struct InnerTestDriver {
-        now: u64,
-        alarm: u64,
-        callback: fn(*mut ()),
-        ctx: *mut (),
-    }
-
-    impl InnerTestDriver {
-        const fn new() -> Self {
-            Self {
-                now: 0,
-                alarm: u64::MAX,
-                callback: Self::noop,
-                ctx: core::ptr::null_mut(),
-            }
-        }
-
-        fn noop(_ctx: *mut ()) {}
-    }
-
-    unsafe impl Send for InnerTestDriver {}
-
-    struct TestDriver(Mutex<InnerTestDriver>);
-
-    impl TestDriver {
-        const fn new() -> Self {
-            Self(Mutex::new(InnerTestDriver::new()))
-        }
-
-        fn reset(&self) {
-            *self.0.lock().unwrap() = InnerTestDriver::new();
-        }
-
-        fn set_now(&self, now: u64) {
-            let notify = {
-                let mut inner = self.0.lock().unwrap();
-
-                if inner.now < now {
-                    inner.now = now;
-
-                    if inner.alarm <= now {
-                        inner.alarm = u64::MAX;
-
-                        Some((inner.callback, inner.ctx))
-                    } else {
-                        None
-                    }
-                } else {
-                    panic!("Going back in time?");
-                }
-            };
-
-            if let Some((callback, ctx)) = notify {
-                (callback)(ctx);
-            }
-        }
-    }
-
-    impl Driver for TestDriver {
-        fn now(&self) -> u64 {
-            self.0.lock().unwrap().now
-        }
-
-        unsafe fn allocate_alarm(&self) -> Option<AlarmHandle> {
-            Some(AlarmHandle::new(0))
-        }
-
-        fn set_alarm_callback(&self, _alarm: AlarmHandle, callback: fn(*mut ()), ctx: *mut ()) {
-            let mut inner = self.0.lock().unwrap();
-
-            inner.callback = callback;
-            inner.ctx = ctx;
-        }
-
-        fn set_alarm(&self, _alarm: AlarmHandle, timestamp: u64) -> bool {
-            let mut inner = self.0.lock().unwrap();
-
-            if timestamp <= inner.now {
-                false
-            } else {
-                inner.alarm = timestamp;
-                true
-            }
-        }
-    }
+    use crate::{Duration, Instant};
 
     struct TestWaker {
         pub awoken: Rc<Cell<bool>>,
@@ -312,10 +226,8 @@ mod tests {
         }
     }
 
-    crate::time_driver_impl!(static DRIVER: TestDriver = TestDriver::new());
-
     fn setup() {
-        DRIVER.reset();
+        MockDriver::get().reset();
         critical_section::with(|cs| *QUEUE.inner.borrow_ref_mut(cs) = None);
     }
 
@@ -382,13 +294,13 @@ mod tests {
 
         assert!(!waker.awoken.get());
 
-        DRIVER.set_now(Instant::from_secs(99).as_ticks());
+        MockDriver::get().advance(Duration::from_secs(99));
 
         assert!(!waker.awoken.get());
 
         assert_eq!(queue_len(), 1);
 
-        DRIVER.set_now(Instant::from_secs(100).as_ticks());
+        MockDriver::get().advance(Duration::from_secs(1));
 
         assert!(waker.awoken.get());
 
@@ -404,7 +316,7 @@ mod tests {
 
         QUEUE.schedule_wake(Instant::from_secs(100), &waker.waker);
 
-        DRIVER.set_now(Instant::from_secs(50).as_ticks());
+        MockDriver::get().advance(Duration::from_secs(50));
 
         let waker2 = TestWaker::new();
 
diff --git a/embassy-time/src/tick.rs b/embassy-time/src/tick.rs
deleted file mode 100644
index 834e7c095..000000000
--- a/embassy-time/src/tick.rs
+++ /dev/null
@@ -1,482 +0,0 @@
-// Generated by gen_tick.py. DO NOT EDIT.
-
-#[cfg(feature = "tick-hz-1")]
-pub const TICK_HZ: u64 = 1;
-#[cfg(feature = "tick-hz-10")]
-pub const TICK_HZ: u64 = 10;
-#[cfg(feature = "tick-hz-100")]
-pub const TICK_HZ: u64 = 100;
-#[cfg(feature = "tick-hz-1_000")]
-pub const TICK_HZ: u64 = 1_000;
-#[cfg(feature = "tick-hz-10_000")]
-pub const TICK_HZ: u64 = 10_000;
-#[cfg(feature = "tick-hz-100_000")]
-pub const TICK_HZ: u64 = 100_000;
-#[cfg(feature = "tick-hz-1_000_000")]
-pub const TICK_HZ: u64 = 1_000_000;
-#[cfg(feature = "tick-hz-10_000_000")]
-pub const TICK_HZ: u64 = 10_000_000;
-#[cfg(feature = "tick-hz-100_000_000")]
-pub const TICK_HZ: u64 = 100_000_000;
-#[cfg(feature = "tick-hz-1_000_000_000")]
-pub const TICK_HZ: u64 = 1_000_000_000;
-#[cfg(feature = "tick-hz-2")]
-pub const TICK_HZ: u64 = 2;
-#[cfg(feature = "tick-hz-4")]
-pub const TICK_HZ: u64 = 4;
-#[cfg(feature = "tick-hz-8")]
-pub const TICK_HZ: u64 = 8;
-#[cfg(feature = "tick-hz-16")]
-pub const TICK_HZ: u64 = 16;
-#[cfg(feature = "tick-hz-32")]
-pub const TICK_HZ: u64 = 32;
-#[cfg(feature = "tick-hz-64")]
-pub const TICK_HZ: u64 = 64;
-#[cfg(feature = "tick-hz-128")]
-pub const TICK_HZ: u64 = 128;
-#[cfg(feature = "tick-hz-256")]
-pub const TICK_HZ: u64 = 256;
-#[cfg(feature = "tick-hz-512")]
-pub const TICK_HZ: u64 = 512;
-#[cfg(feature = "tick-hz-1_024")]
-pub const TICK_HZ: u64 = 1_024;
-#[cfg(feature = "tick-hz-2_048")]
-pub const TICK_HZ: u64 = 2_048;
-#[cfg(feature = "tick-hz-4_096")]
-pub const TICK_HZ: u64 = 4_096;
-#[cfg(feature = "tick-hz-8_192")]
-pub const TICK_HZ: u64 = 8_192;
-#[cfg(feature = "tick-hz-16_384")]
-pub const TICK_HZ: u64 = 16_384;
-#[cfg(feature = "tick-hz-32_768")]
-pub const TICK_HZ: u64 = 32_768;
-#[cfg(feature = "tick-hz-65_536")]
-pub const TICK_HZ: u64 = 65_536;
-#[cfg(feature = "tick-hz-131_072")]
-pub const TICK_HZ: u64 = 131_072;
-#[cfg(feature = "tick-hz-262_144")]
-pub const TICK_HZ: u64 = 262_144;
-#[cfg(feature = "tick-hz-524_288")]
-pub const TICK_HZ: u64 = 524_288;
-#[cfg(feature = "tick-hz-1_048_576")]
-pub const TICK_HZ: u64 = 1_048_576;
-#[cfg(feature = "tick-hz-2_097_152")]
-pub const TICK_HZ: u64 = 2_097_152;
-#[cfg(feature = "tick-hz-4_194_304")]
-pub const TICK_HZ: u64 = 4_194_304;
-#[cfg(feature = "tick-hz-8_388_608")]
-pub const TICK_HZ: u64 = 8_388_608;
-#[cfg(feature = "tick-hz-16_777_216")]
-pub const TICK_HZ: u64 = 16_777_216;
-#[cfg(feature = "tick-hz-2_000")]
-pub const TICK_HZ: u64 = 2_000;
-#[cfg(feature = "tick-hz-4_000")]
-pub const TICK_HZ: u64 = 4_000;
-#[cfg(feature = "tick-hz-8_000")]
-pub const TICK_HZ: u64 = 8_000;
-#[cfg(feature = "tick-hz-16_000")]
-pub const TICK_HZ: u64 = 16_000;
-#[cfg(feature = "tick-hz-32_000")]
-pub const TICK_HZ: u64 = 32_000;
-#[cfg(feature = "tick-hz-64_000")]
-pub const TICK_HZ: u64 = 64_000;
-#[cfg(feature = "tick-hz-128_000")]
-pub const TICK_HZ: u64 = 128_000;
-#[cfg(feature = "tick-hz-256_000")]
-pub const TICK_HZ: u64 = 256_000;
-#[cfg(feature = "tick-hz-512_000")]
-pub const TICK_HZ: u64 = 512_000;
-#[cfg(feature = "tick-hz-1_024_000")]
-pub const TICK_HZ: u64 = 1_024_000;
-#[cfg(feature = "tick-hz-2_048_000")]
-pub const TICK_HZ: u64 = 2_048_000;
-#[cfg(feature = "tick-hz-4_096_000")]
-pub const TICK_HZ: u64 = 4_096_000;
-#[cfg(feature = "tick-hz-8_192_000")]
-pub const TICK_HZ: u64 = 8_192_000;
-#[cfg(feature = "tick-hz-16_384_000")]
-pub const TICK_HZ: u64 = 16_384_000;
-#[cfg(feature = "tick-hz-32_768_000")]
-pub const TICK_HZ: u64 = 32_768_000;
-#[cfg(feature = "tick-hz-65_536_000")]
-pub const TICK_HZ: u64 = 65_536_000;
-#[cfg(feature = "tick-hz-131_072_000")]
-pub const TICK_HZ: u64 = 131_072_000;
-#[cfg(feature = "tick-hz-262_144_000")]
-pub const TICK_HZ: u64 = 262_144_000;
-#[cfg(feature = "tick-hz-524_288_000")]
-pub const TICK_HZ: u64 = 524_288_000;
-#[cfg(feature = "tick-hz-20_000")]
-pub const TICK_HZ: u64 = 20_000;
-#[cfg(feature = "tick-hz-40_000")]
-pub const TICK_HZ: u64 = 40_000;
-#[cfg(feature = "tick-hz-80_000")]
-pub const TICK_HZ: u64 = 80_000;
-#[cfg(feature = "tick-hz-160_000")]
-pub const TICK_HZ: u64 = 160_000;
-#[cfg(feature = "tick-hz-320_000")]
-pub const TICK_HZ: u64 = 320_000;
-#[cfg(feature = "tick-hz-640_000")]
-pub const TICK_HZ: u64 = 640_000;
-#[cfg(feature = "tick-hz-1_280_000")]
-pub const TICK_HZ: u64 = 1_280_000;
-#[cfg(feature = "tick-hz-2_560_000")]
-pub const TICK_HZ: u64 = 2_560_000;
-#[cfg(feature = "tick-hz-5_120_000")]
-pub const TICK_HZ: u64 = 5_120_000;
-#[cfg(feature = "tick-hz-10_240_000")]
-pub const TICK_HZ: u64 = 10_240_000;
-#[cfg(feature = "tick-hz-20_480_000")]
-pub const TICK_HZ: u64 = 20_480_000;
-#[cfg(feature = "tick-hz-40_960_000")]
-pub const TICK_HZ: u64 = 40_960_000;
-#[cfg(feature = "tick-hz-81_920_000")]
-pub const TICK_HZ: u64 = 81_920_000;
-#[cfg(feature = "tick-hz-163_840_000")]
-pub const TICK_HZ: u64 = 163_840_000;
-#[cfg(feature = "tick-hz-327_680_000")]
-pub const TICK_HZ: u64 = 327_680_000;
-#[cfg(feature = "tick-hz-655_360_000")]
-pub const TICK_HZ: u64 = 655_360_000;
-#[cfg(feature = "tick-hz-1_310_720_000")]
-pub const TICK_HZ: u64 = 1_310_720_000;
-#[cfg(feature = "tick-hz-2_621_440_000")]
-pub const TICK_HZ: u64 = 2_621_440_000;
-#[cfg(feature = "tick-hz-5_242_880_000")]
-pub const TICK_HZ: u64 = 5_242_880_000;
-#[cfg(feature = "tick-hz-2_000_000")]
-pub const TICK_HZ: u64 = 2_000_000;
-#[cfg(feature = "tick-hz-3_000_000")]
-pub const TICK_HZ: u64 = 3_000_000;
-#[cfg(feature = "tick-hz-4_000_000")]
-pub const TICK_HZ: u64 = 4_000_000;
-#[cfg(feature = "tick-hz-6_000_000")]
-pub const TICK_HZ: u64 = 6_000_000;
-#[cfg(feature = "tick-hz-8_000_000")]
-pub const TICK_HZ: u64 = 8_000_000;
-#[cfg(feature = "tick-hz-9_000_000")]
-pub const TICK_HZ: u64 = 9_000_000;
-#[cfg(feature = "tick-hz-12_000_000")]
-pub const TICK_HZ: u64 = 12_000_000;
-#[cfg(feature = "tick-hz-16_000_000")]
-pub const TICK_HZ: u64 = 16_000_000;
-#[cfg(feature = "tick-hz-18_000_000")]
-pub const TICK_HZ: u64 = 18_000_000;
-#[cfg(feature = "tick-hz-24_000_000")]
-pub const TICK_HZ: u64 = 24_000_000;
-#[cfg(feature = "tick-hz-32_000_000")]
-pub const TICK_HZ: u64 = 32_000_000;
-#[cfg(feature = "tick-hz-36_000_000")]
-pub const TICK_HZ: u64 = 36_000_000;
-#[cfg(feature = "tick-hz-48_000_000")]
-pub const TICK_HZ: u64 = 48_000_000;
-#[cfg(feature = "tick-hz-64_000_000")]
-pub const TICK_HZ: u64 = 64_000_000;
-#[cfg(feature = "tick-hz-72_000_000")]
-pub const TICK_HZ: u64 = 72_000_000;
-#[cfg(feature = "tick-hz-96_000_000")]
-pub const TICK_HZ: u64 = 96_000_000;
-#[cfg(feature = "tick-hz-128_000_000")]
-pub const TICK_HZ: u64 = 128_000_000;
-#[cfg(feature = "tick-hz-144_000_000")]
-pub const TICK_HZ: u64 = 144_000_000;
-#[cfg(feature = "tick-hz-192_000_000")]
-pub const TICK_HZ: u64 = 192_000_000;
-#[cfg(feature = "tick-hz-256_000_000")]
-pub const TICK_HZ: u64 = 256_000_000;
-#[cfg(feature = "tick-hz-288_000_000")]
-pub const TICK_HZ: u64 = 288_000_000;
-#[cfg(feature = "tick-hz-384_000_000")]
-pub const TICK_HZ: u64 = 384_000_000;
-#[cfg(feature = "tick-hz-512_000_000")]
-pub const TICK_HZ: u64 = 512_000_000;
-#[cfg(feature = "tick-hz-576_000_000")]
-pub const TICK_HZ: u64 = 576_000_000;
-#[cfg(feature = "tick-hz-768_000_000")]
-pub const TICK_HZ: u64 = 768_000_000;
-#[cfg(feature = "tick-hz-20_000_000")]
-pub const TICK_HZ: u64 = 20_000_000;
-#[cfg(feature = "tick-hz-30_000_000")]
-pub const TICK_HZ: u64 = 30_000_000;
-#[cfg(feature = "tick-hz-40_000_000")]
-pub const TICK_HZ: u64 = 40_000_000;
-#[cfg(feature = "tick-hz-50_000_000")]
-pub const TICK_HZ: u64 = 50_000_000;
-#[cfg(feature = "tick-hz-60_000_000")]
-pub const TICK_HZ: u64 = 60_000_000;
-#[cfg(feature = "tick-hz-70_000_000")]
-pub const TICK_HZ: u64 = 70_000_000;
-#[cfg(feature = "tick-hz-80_000_000")]
-pub const TICK_HZ: u64 = 80_000_000;
-#[cfg(feature = "tick-hz-90_000_000")]
-pub const TICK_HZ: u64 = 90_000_000;
-#[cfg(feature = "tick-hz-110_000_000")]
-pub const TICK_HZ: u64 = 110_000_000;
-#[cfg(feature = "tick-hz-120_000_000")]
-pub const TICK_HZ: u64 = 120_000_000;
-#[cfg(feature = "tick-hz-130_000_000")]
-pub const TICK_HZ: u64 = 130_000_000;
-#[cfg(feature = "tick-hz-140_000_000")]
-pub const TICK_HZ: u64 = 140_000_000;
-#[cfg(feature = "tick-hz-150_000_000")]
-pub const TICK_HZ: u64 = 150_000_000;
-#[cfg(feature = "tick-hz-160_000_000")]
-pub const TICK_HZ: u64 = 160_000_000;
-#[cfg(feature = "tick-hz-170_000_000")]
-pub const TICK_HZ: u64 = 170_000_000;
-#[cfg(feature = "tick-hz-180_000_000")]
-pub const TICK_HZ: u64 = 180_000_000;
-#[cfg(feature = "tick-hz-190_000_000")]
-pub const TICK_HZ: u64 = 190_000_000;
-#[cfg(feature = "tick-hz-200_000_000")]
-pub const TICK_HZ: u64 = 200_000_000;
-#[cfg(feature = "tick-hz-210_000_000")]
-pub const TICK_HZ: u64 = 210_000_000;
-#[cfg(feature = "tick-hz-220_000_000")]
-pub const TICK_HZ: u64 = 220_000_000;
-#[cfg(feature = "tick-hz-230_000_000")]
-pub const TICK_HZ: u64 = 230_000_000;
-#[cfg(feature = "tick-hz-240_000_000")]
-pub const TICK_HZ: u64 = 240_000_000;
-#[cfg(feature = "tick-hz-250_000_000")]
-pub const TICK_HZ: u64 = 250_000_000;
-#[cfg(feature = "tick-hz-260_000_000")]
-pub const TICK_HZ: u64 = 260_000_000;
-#[cfg(feature = "tick-hz-270_000_000")]
-pub const TICK_HZ: u64 = 270_000_000;
-#[cfg(feature = "tick-hz-280_000_000")]
-pub const TICK_HZ: u64 = 280_000_000;
-#[cfg(feature = "tick-hz-290_000_000")]
-pub const TICK_HZ: u64 = 290_000_000;
-#[cfg(feature = "tick-hz-300_000_000")]
-pub const TICK_HZ: u64 = 300_000_000;
-#[cfg(feature = "tick-hz-320_000_000")]
-pub const TICK_HZ: u64 = 320_000_000;
-#[cfg(feature = "tick-hz-340_000_000")]
-pub const TICK_HZ: u64 = 340_000_000;
-#[cfg(feature = "tick-hz-360_000_000")]
-pub const TICK_HZ: u64 = 360_000_000;
-#[cfg(feature = "tick-hz-380_000_000")]
-pub const TICK_HZ: u64 = 380_000_000;
-#[cfg(feature = "tick-hz-400_000_000")]
-pub const TICK_HZ: u64 = 400_000_000;
-#[cfg(feature = "tick-hz-420_000_000")]
-pub const TICK_HZ: u64 = 420_000_000;
-#[cfg(feature = "tick-hz-440_000_000")]
-pub const TICK_HZ: u64 = 440_000_000;
-#[cfg(feature = "tick-hz-460_000_000")]
-pub const TICK_HZ: u64 = 460_000_000;
-#[cfg(feature = "tick-hz-480_000_000")]
-pub const TICK_HZ: u64 = 480_000_000;
-#[cfg(feature = "tick-hz-500_000_000")]
-pub const TICK_HZ: u64 = 500_000_000;
-#[cfg(feature = "tick-hz-520_000_000")]
-pub const TICK_HZ: u64 = 520_000_000;
-#[cfg(feature = "tick-hz-540_000_000")]
-pub const TICK_HZ: u64 = 540_000_000;
-#[cfg(feature = "tick-hz-560_000_000")]
-pub const TICK_HZ: u64 = 560_000_000;
-#[cfg(feature = "tick-hz-580_000_000")]
-pub const TICK_HZ: u64 = 580_000_000;
-#[cfg(feature = "tick-hz-600_000_000")]
-pub const TICK_HZ: u64 = 600_000_000;
-#[cfg(feature = "tick-hz-620_000_000")]
-pub const TICK_HZ: u64 = 620_000_000;
-#[cfg(feature = "tick-hz-640_000_000")]
-pub const TICK_HZ: u64 = 640_000_000;
-#[cfg(feature = "tick-hz-660_000_000")]
-pub const TICK_HZ: u64 = 660_000_000;
-#[cfg(feature = "tick-hz-680_000_000")]
-pub const TICK_HZ: u64 = 680_000_000;
-#[cfg(feature = "tick-hz-700_000_000")]
-pub const TICK_HZ: u64 = 700_000_000;
-#[cfg(feature = "tick-hz-720_000_000")]
-pub const TICK_HZ: u64 = 720_000_000;
-#[cfg(feature = "tick-hz-740_000_000")]
-pub const TICK_HZ: u64 = 740_000_000;
-#[cfg(feature = "tick-hz-760_000_000")]
-pub const TICK_HZ: u64 = 760_000_000;
-#[cfg(feature = "tick-hz-780_000_000")]
-pub const TICK_HZ: u64 = 780_000_000;
-#[cfg(feature = "tick-hz-800_000_000")]
-pub const TICK_HZ: u64 = 800_000_000;
-#[cfg(feature = "tick-hz-820_000_000")]
-pub const TICK_HZ: u64 = 820_000_000;
-#[cfg(feature = "tick-hz-840_000_000")]
-pub const TICK_HZ: u64 = 840_000_000;
-#[cfg(feature = "tick-hz-860_000_000")]
-pub const TICK_HZ: u64 = 860_000_000;
-#[cfg(feature = "tick-hz-880_000_000")]
-pub const TICK_HZ: u64 = 880_000_000;
-#[cfg(feature = "tick-hz-900_000_000")]
-pub const TICK_HZ: u64 = 900_000_000;
-#[cfg(feature = "tick-hz-920_000_000")]
-pub const TICK_HZ: u64 = 920_000_000;
-#[cfg(feature = "tick-hz-940_000_000")]
-pub const TICK_HZ: u64 = 940_000_000;
-#[cfg(feature = "tick-hz-960_000_000")]
-pub const TICK_HZ: u64 = 960_000_000;
-#[cfg(feature = "tick-hz-980_000_000")]
-pub const TICK_HZ: u64 = 980_000_000;
-#[cfg(not(any(
-    feature = "tick-hz-1",
-    feature = "tick-hz-10",
-    feature = "tick-hz-100",
-    feature = "tick-hz-1_000",
-    feature = "tick-hz-10_000",
-    feature = "tick-hz-100_000",
-    feature = "tick-hz-1_000_000",
-    feature = "tick-hz-10_000_000",
-    feature = "tick-hz-100_000_000",
-    feature = "tick-hz-1_000_000_000",
-    feature = "tick-hz-2",
-    feature = "tick-hz-4",
-    feature = "tick-hz-8",
-    feature = "tick-hz-16",
-    feature = "tick-hz-32",
-    feature = "tick-hz-64",
-    feature = "tick-hz-128",
-    feature = "tick-hz-256",
-    feature = "tick-hz-512",
-    feature = "tick-hz-1_024",
-    feature = "tick-hz-2_048",
-    feature = "tick-hz-4_096",
-    feature = "tick-hz-8_192",
-    feature = "tick-hz-16_384",
-    feature = "tick-hz-32_768",
-    feature = "tick-hz-65_536",
-    feature = "tick-hz-131_072",
-    feature = "tick-hz-262_144",
-    feature = "tick-hz-524_288",
-    feature = "tick-hz-1_048_576",
-    feature = "tick-hz-2_097_152",
-    feature = "tick-hz-4_194_304",
-    feature = "tick-hz-8_388_608",
-    feature = "tick-hz-16_777_216",
-    feature = "tick-hz-2_000",
-    feature = "tick-hz-4_000",
-    feature = "tick-hz-8_000",
-    feature = "tick-hz-16_000",
-    feature = "tick-hz-32_000",
-    feature = "tick-hz-64_000",
-    feature = "tick-hz-128_000",
-    feature = "tick-hz-256_000",
-    feature = "tick-hz-512_000",
-    feature = "tick-hz-1_024_000",
-    feature = "tick-hz-2_048_000",
-    feature = "tick-hz-4_096_000",
-    feature = "tick-hz-8_192_000",
-    feature = "tick-hz-16_384_000",
-    feature = "tick-hz-32_768_000",
-    feature = "tick-hz-65_536_000",
-    feature = "tick-hz-131_072_000",
-    feature = "tick-hz-262_144_000",
-    feature = "tick-hz-524_288_000",
-    feature = "tick-hz-20_000",
-    feature = "tick-hz-40_000",
-    feature = "tick-hz-80_000",
-    feature = "tick-hz-160_000",
-    feature = "tick-hz-320_000",
-    feature = "tick-hz-640_000",
-    feature = "tick-hz-1_280_000",
-    feature = "tick-hz-2_560_000",
-    feature = "tick-hz-5_120_000",
-    feature = "tick-hz-10_240_000",
-    feature = "tick-hz-20_480_000",
-    feature = "tick-hz-40_960_000",
-    feature = "tick-hz-81_920_000",
-    feature = "tick-hz-163_840_000",
-    feature = "tick-hz-327_680_000",
-    feature = "tick-hz-655_360_000",
-    feature = "tick-hz-1_310_720_000",
-    feature = "tick-hz-2_621_440_000",
-    feature = "tick-hz-5_242_880_000",
-    feature = "tick-hz-2_000_000",
-    feature = "tick-hz-3_000_000",
-    feature = "tick-hz-4_000_000",
-    feature = "tick-hz-6_000_000",
-    feature = "tick-hz-8_000_000",
-    feature = "tick-hz-9_000_000",
-    feature = "tick-hz-12_000_000",
-    feature = "tick-hz-16_000_000",
-    feature = "tick-hz-18_000_000",
-    feature = "tick-hz-24_000_000",
-    feature = "tick-hz-32_000_000",
-    feature = "tick-hz-36_000_000",
-    feature = "tick-hz-48_000_000",
-    feature = "tick-hz-64_000_000",
-    feature = "tick-hz-72_000_000",
-    feature = "tick-hz-96_000_000",
-    feature = "tick-hz-128_000_000",
-    feature = "tick-hz-144_000_000",
-    feature = "tick-hz-192_000_000",
-    feature = "tick-hz-256_000_000",
-    feature = "tick-hz-288_000_000",
-    feature = "tick-hz-384_000_000",
-    feature = "tick-hz-512_000_000",
-    feature = "tick-hz-576_000_000",
-    feature = "tick-hz-768_000_000",
-    feature = "tick-hz-20_000_000",
-    feature = "tick-hz-30_000_000",
-    feature = "tick-hz-40_000_000",
-    feature = "tick-hz-50_000_000",
-    feature = "tick-hz-60_000_000",
-    feature = "tick-hz-70_000_000",
-    feature = "tick-hz-80_000_000",
-    feature = "tick-hz-90_000_000",
-    feature = "tick-hz-110_000_000",
-    feature = "tick-hz-120_000_000",
-    feature = "tick-hz-130_000_000",
-    feature = "tick-hz-140_000_000",
-    feature = "tick-hz-150_000_000",
-    feature = "tick-hz-160_000_000",
-    feature = "tick-hz-170_000_000",
-    feature = "tick-hz-180_000_000",
-    feature = "tick-hz-190_000_000",
-    feature = "tick-hz-200_000_000",
-    feature = "tick-hz-210_000_000",
-    feature = "tick-hz-220_000_000",
-    feature = "tick-hz-230_000_000",
-    feature = "tick-hz-240_000_000",
-    feature = "tick-hz-250_000_000",
-    feature = "tick-hz-260_000_000",
-    feature = "tick-hz-270_000_000",
-    feature = "tick-hz-280_000_000",
-    feature = "tick-hz-290_000_000",
-    feature = "tick-hz-300_000_000",
-    feature = "tick-hz-320_000_000",
-    feature = "tick-hz-340_000_000",
-    feature = "tick-hz-360_000_000",
-    feature = "tick-hz-380_000_000",
-    feature = "tick-hz-400_000_000",
-    feature = "tick-hz-420_000_000",
-    feature = "tick-hz-440_000_000",
-    feature = "tick-hz-460_000_000",
-    feature = "tick-hz-480_000_000",
-    feature = "tick-hz-500_000_000",
-    feature = "tick-hz-520_000_000",
-    feature = "tick-hz-540_000_000",
-    feature = "tick-hz-560_000_000",
-    feature = "tick-hz-580_000_000",
-    feature = "tick-hz-600_000_000",
-    feature = "tick-hz-620_000_000",
-    feature = "tick-hz-640_000_000",
-    feature = "tick-hz-660_000_000",
-    feature = "tick-hz-680_000_000",
-    feature = "tick-hz-700_000_000",
-    feature = "tick-hz-720_000_000",
-    feature = "tick-hz-740_000_000",
-    feature = "tick-hz-760_000_000",
-    feature = "tick-hz-780_000_000",
-    feature = "tick-hz-800_000_000",
-    feature = "tick-hz-820_000_000",
-    feature = "tick-hz-840_000_000",
-    feature = "tick-hz-860_000_000",
-    feature = "tick-hz-880_000_000",
-    feature = "tick-hz-900_000_000",
-    feature = "tick-hz-920_000_000",
-    feature = "tick-hz-940_000_000",
-    feature = "tick-hz-960_000_000",
-    feature = "tick-hz-980_000_000",
-)))]
-pub const TICK_HZ: u64 = 1_000_000;
diff --git a/embassy-time/src/timer.rs b/embassy-time/src/timer.rs
index a123c1d01..757c3ff00 100644
--- a/embassy-time/src/timer.rs
+++ b/embassy-time/src/timer.rs
@@ -1,6 +1,6 @@
 use core::future::{poll_fn, Future};
 use core::pin::Pin;
-use core::task::{Context, Poll, Waker};
+use core::task::{Context, Poll};
 
 use futures_util::future::{select, Either};
 use futures_util::stream::FusedStream;
@@ -8,7 +8,7 @@ use futures_util::{pin_mut, Stream};
 
 use crate::{Duration, Instant};
 
-/// Error returned by [`with_timeout`] on timeout.
+/// Error returned by [`with_timeout`] and [`with_deadline`] on timeout.
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub struct TimeoutError;
@@ -26,6 +26,19 @@ pub async fn with_timeout<F: Future>(timeout: Duration, fut: F) -> Result<F::Out
     }
 }
 
+/// Runs a given future with a deadline time.
+///
+/// If the future completes before the deadline, its output is returned. Otherwise, on timeout,
+/// work on the future is stopped (`poll` is no longer called), the future is dropped and `Err(TimeoutError)` is returned.
+pub async fn with_deadline<F: Future>(at: Instant, fut: F) -> Result<F::Output, TimeoutError> {
+    let timeout_fut = Timer::at(at);
+    pin_mut!(fut);
+    match select(fut, timeout_fut).await {
+        Either::Left((r, _)) => Ok(r),
+        Either::Right(_) => Err(TimeoutError),
+    }
+}
+
 /// A future that completes at a specified [Instant](struct.Instant.html).
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct Timer {
@@ -47,9 +60,6 @@ impl Timer {
     ///
     /// Example:
     /// ``` no_run
-    /// # #![feature(type_alias_impl_trait)]
-    /// #
-    /// # fn foo() {}
     /// use embassy_time::{Duration, Timer};
     ///
     /// #[embassy_executor::task]
@@ -119,7 +129,7 @@ impl Future for Timer {
         if self.yielded_once && self.expires_at <= Instant::now() {
             Poll::Ready(())
         } else {
-            schedule_wake(self.expires_at, cx.waker());
+            embassy_time_queue_driver::schedule_wake(self.expires_at.as_ticks(), cx.waker());
             self.yielded_once = true;
             Poll::Pending
         }
@@ -132,8 +142,6 @@ impl Future for Timer {
 ///
 /// For instance, consider the following code fragment.
 /// ``` no_run
-/// # #![feature(type_alias_impl_trait)]
-/// #
 /// use embassy_time::{Duration, Timer};
 /// # fn foo() {}
 ///
@@ -152,8 +160,6 @@ impl Future for Timer {
 /// Example using ticker, which will consistently call `foo` once a second.
 ///
 /// ``` no_run
-/// # #![feature(type_alias_impl_trait)]
-/// #
 /// use embassy_time::{Duration, Ticker};
 /// # fn foo(){}
 ///
@@ -184,6 +190,18 @@ impl Ticker {
         self.expires_at = Instant::now() + self.duration;
     }
 
+    /// Reset the ticker at the deadline.
+    /// If the deadline is in the past, the ticker will fire instantly.
+    pub fn reset_at(&mut self, deadline: Instant) {
+        self.expires_at = deadline + self.duration;
+    }
+
+    /// Resets the ticker, after the specified duration has passed.
+    /// If the specified duration is zero, the next tick will be after the duration of the ticker.
+    pub fn reset_after(&mut self, after: Duration) {
+        self.expires_at = Instant::now() + after + self.duration;
+    }
+
     /// Waits for the next tick.
     pub fn next(&mut self) -> impl Future<Output = ()> + Send + Sync + '_ {
         poll_fn(|cx| {
@@ -192,7 +210,7 @@ impl Ticker {
                 self.expires_at += dur;
                 Poll::Ready(())
             } else {
-                schedule_wake(self.expires_at, cx.waker());
+                embassy_time_queue_driver::schedule_wake(self.expires_at.as_ticks(), cx.waker());
                 Poll::Pending
             }
         })
@@ -209,7 +227,7 @@ impl Stream for Ticker {
             self.expires_at += dur;
             Poll::Ready(Some(()))
         } else {
-            schedule_wake(self.expires_at, cx.waker());
+            embassy_time_queue_driver::schedule_wake(self.expires_at.as_ticks(), cx.waker());
             Poll::Pending
         }
     }
@@ -221,11 +239,3 @@ impl FusedStream for Ticker {
         false
     }
 }
-
-extern "Rust" {
-    fn _embassy_time_schedule_wake(at: Instant, waker: &Waker);
-}
-
-fn schedule_wake(at: Instant, waker: &Waker) {
-    unsafe { _embassy_time_schedule_wake(at, waker) }
-}