Merge branch 'embassy-rs:main' into ticker_send_sync

12 files changed, 229 insertions, 878 deletions

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) }
-}