Duration u32

Author: diorcety

embassy-executor/Cargo.toml

@@ -58,6 +58,7 @@ trybuild = "1.0"
 embassy-sync = { path = "../embassy-sync" }
 
 [features]
+tick-u32 = []
 
 ## Enable nightly-only features
 nightly = ["embassy-executor-macros/nightly"]

embassy-executor/src/raw/timer_queue.rs

@@ -4,6 +4,12 @@ use core::cell::Cell;
 
 use super::TaskRef;
 
+#[cfg(feature = "tick-u32")]
+pub type TickType = u32;
+
+#[cfg(not(feature = "tick-u32"))]
+pub type TickType = u64;
+
 #[cfg(feature = "_timer-item-payload")]
 macro_rules! define_opaque {
     ($size:tt) => {
@@ -52,7 +58,7 @@ pub struct TimerQueueItem {
     pub next: Cell<Option<TaskRef>>,
 
     /// The time at which this item expires.
-    pub expires_at: Cell<u64>,
+    pub expires_at: Cell<TickType>,
 
     /// Some implementation-defined, zero-initialized piece of data.
     #[cfg(feature = "_timer-item-payload")]

embassy-net/src/time.rs

@@ -1,20 +1,20 @@
 #![allow(unused)]
 
-use embassy_time::{Duration, Instant};
+use embassy_time::{Duration, Instant, TickType};
 use smoltcp::time::{Duration as SmolDuration, Instant as SmolInstant};
 
 pub(crate) fn instant_to_smoltcp(instant: Instant) -> SmolInstant {
     SmolInstant::from_micros(instant.as_micros() as i64)
 }
 
 pub(crate) fn instant_from_smoltcp(instant: SmolInstant) -> Instant {
-    Instant::from_micros(instant.total_micros() as u64)
+    Instant::from_micros(instant.total_micros() as TickType)
 }
 
 pub(crate) fn duration_to_smoltcp(duration: Duration) -> SmolDuration {
-    SmolDuration::from_micros(duration.as_micros())
+    SmolDuration::from_micros(duration.as_micros() as u64)
 }
 
 pub(crate) fn duration_from_smoltcp(duration: SmolDuration) -> Duration {
-    Duration::from_micros(duration.total_micros())
+    Duration::from_micros(duration.total_micros() as TickType)
 }

embassy-stm32/src/adc/mod.rs

@@ -84,7 +84,7 @@ pub(crate) trait SealedAdcChannel<T> {
 #[allow(unused)]
 pub(crate) fn blocking_delay_us(us: u32) {
     #[cfg(feature = "time")]
-    embassy_time::block_for(embassy_time::Duration::from_micros(us as u64));
+    embassy_time::block_for(embassy_time::Duration::from_micros(us as embassy_time::DurationType));
     #[cfg(not(feature = "time"))]
     {
         let freq = unsafe { crate::rcc::get_freqs() }.sys.to_hertz().unwrap().0 as u64;

embassy-stm32/src/eth/generic_phy.rs

@@ -3,7 +3,7 @@
 use core::task::Context;
 
 #[cfg(feature = "time")]
-use embassy_time::{Duration, Timer};
+use embassy_time::{Duration, DurationType, Timer};
 #[cfg(feature = "time")]
 use futures_util::FutureExt;
 
@@ -79,7 +79,7 @@ impl GenericPhy {
 // TODO: Factor out to shared functionality
 fn blocking_delay_us(us: u32) {
     #[cfg(feature = "time")]
-    embassy_time::block_for(Duration::from_micros(us as u64));
+    embassy_time::block_for(Duration::from_micros(us as DurationType));
     #[cfg(not(feature = "time"))]
     {
         let freq = unsafe { crate::rcc::get_freqs() }.sys.to_hertz().unwrap().0 as u64;

embassy-stm32/src/time_driver.rs

@@ -6,7 +6,7 @@ use core::sync::atomic::{compiler_fence, AtomicU32, Ordering};
 use critical_section::CriticalSection;
 use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
 use embassy_sync::blocking_mutex::Mutex;
-use embassy_time_driver::{Driver, TICK_HZ};
+use embassy_time_driver::{Driver, TICK_HZ, TickType};
 use embassy_time_queue_utils::Queue;
 use stm32_metapac::timer::{regs, TimGp16};
 
@@ -190,20 +190,20 @@ fn regs_gp16() -> TimGp16 {
 // corresponds to the next period.
 //
 // `period` is a 32bit integer, so It overflows on 2^32 * 2^15 / 32768 seconds of uptime, which is 136 years.
-fn calc_now(period: u32, counter: u16) -> u64 {
-    ((period as u64) << 15) + ((counter as u32 ^ ((period & 1) << 15)) as u64)
+fn calc_now(period: u32, counter: u16) -> TickType {
+    (((period as u64) << 15) + ((counter as u32 ^ ((period & 1) << 15)) as u64)) as TickType
 }
 
 struct AlarmState {
-    timestamp: Cell<u64>,
+    timestamp: Cell<TickType>,
 }
 
 unsafe impl Send for AlarmState {}
 
 impl AlarmState {
     const fn new() -> Self {
         Self {
-            timestamp: Cell::new(u64::MAX),
+            timestamp: Cell::new(TickType::MAX),
         }
     }
 }
@@ -300,7 +300,7 @@ impl RtcDriver {
         // We only modify the period from the timer interrupt, so we know this can't race.
         let period = self.period.load(Ordering::Relaxed) + 1;
         self.period.store(period, Ordering::Relaxed);
-        let t = (period as u64) << 15;
+        let t = ((period as u64) << 16) as TickType;
 
         critical_section::with(move |cs| {
             r.dier().modify(move |w| {
@@ -445,7 +445,7 @@ impl RtcDriver {
         })
     }
 
-    fn set_alarm(&self, cs: CriticalSection, timestamp: u64) -> bool {
+    fn set_alarm(&self, cs: CriticalSection, timestamp: TickType) -> bool {
         let r = regs_gp16();
 
         let n = 0;
@@ -457,7 +457,7 @@ impl RtcDriver {
             // Disarm the alarm and return `false` to indicate that.
             r.dier().modify(|w| w.set_ccie(n + 1, false));
 
-            self.alarm.borrow(cs).timestamp.set(u64::MAX);
+            self.alarm.borrow(cs).timestamp.set(TickType::MAX);
 
             return false;
         }
@@ -479,7 +479,7 @@ impl RtcDriver {
             // It is the caller's responsibility to handle this ambiguity.
             r.dier().modify(|w| w.set_ccie(n + 1, false));
 
-            self.alarm.borrow(cs).timestamp.set(u64::MAX);
+            self.alarm.borrow(cs).timestamp.set(TickType::MAX);
 
             return false;
         }
@@ -490,7 +490,7 @@ impl RtcDriver {
 }
 
 impl Driver for RtcDriver {
-    fn now(&self) -> u64 {
+    fn now(&self) -> TickType {
         let r = regs_gp16();
 
         let period = self.period.load(Ordering::Relaxed);
@@ -499,7 +499,7 @@ impl Driver for RtcDriver {
         calc_now(period, counter)
     }
 
-    fn schedule_wake(&self, at: u64, waker: &core::task::Waker) {
+    fn schedule_wake(&self, at: TickType, waker: &core::task::Waker) {
         critical_section::with(|cs| {
             let mut queue = self.queue.borrow(cs).borrow_mut();
 

embassy-time-driver/Cargo.toml

@@ -26,6 +26,8 @@ src_base_git = "https://github.com/embassy-rs/embassy/blob/$COMMIT/embassy-time-
 target = "x86_64-unknown-linux-gnu"
 
 [features]
+tick-u32 = []
+
 #! ### Tick Rate
 #!
 #! At most 1 `tick-*` feature can be enabled. If none is enabled, a default of 1MHz is used.

embassy-time-driver/src/lib.rs

@@ -27,11 +27,11 @@
 //! struct MyDriver{} // not public!
 //!
 //! impl Driver for MyDriver {
-//!     fn now(&self) -> u64 {
+//!     fn now(&self) -> TickType {
 //!         todo!()
 //!     }
 //!
-//!     fn schedule_wake(&self, at: u64, waker: &Waker) {
+//!     fn schedule_wake(&self, at: TickType, waker: &Waker) {
 //!         todo!()
 //!     }
 //! }
@@ -62,15 +62,15 @@
 //! }
 //!
 //! impl MyDriver {
-//!    fn set_alarm(&self, cs: &CriticalSection, at: u64) -> bool {
+//!    fn set_alarm(&self, cs: &CriticalSection, at: TickType) -> bool {
 //!        todo!()
 //!    }
 //! }
 //!
 //! impl Driver for MyDriver {
-//!     fn now(&self) -> u64 { todo!() }
+//!     fn now(&self) -> TickType { todo!() }
 //!
-//!     fn schedule_wake(&self, at: u64, waker: &Waker) {
+//!     fn schedule_wake(&self, at: TickType, waker: &Waker) {
 //!         critical_section::with(|cs| {
 //!             let mut queue = self.queue.borrow(cs).borrow_mut();
 //!             if queue.schedule_wake(at, waker) {
@@ -88,8 +88,8 @@
 //!
 //! Instead of the usual "trait + generic params" approach, calls from embassy to the driver are done via `extern` functions.
 //!
-//! `embassy` internally defines the driver function as `extern "Rust" { fn _embassy_time_now() -> u64; }` and calls it.
-//! The driver crate defines the function as `#[no_mangle] fn _embassy_time_now() -> u64`. The linker will resolve the
+//! `embassy` internally defines the driver function as `extern "Rust" { fn _embassy_time_now() -> TickType; }` and calls it.
+//! The driver crate defines the function as `#[no_mangle] fn _embassy_time_now() -> TickType`. 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.
@@ -112,7 +112,8 @@ mod tick;
 /// Ticks per second of the global timebase.
 ///
 /// This value is specified by the [`tick-*` Cargo features](crate#tick-rate)
-pub const TICK_HZ: u64 = tick::TICK_HZ;
+pub const TICK_HZ: TickType = tick::TICK_HZ;
+pub use tick::TickType;
 
 /// Time driver
 pub trait Driver: Send + Sync + 'static {
@@ -126,27 +127,27 @@ pub trait Driver: Send + Sync + 'static {
     ///   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;
+    fn now(&self) -> TickType;
 
     /// Schedules a waker to be awoken at moment `at`.
     /// If this moment is in the past, the waker might be awoken immediately.
-    fn schedule_wake(&self, at: u64, waker: &Waker);
+    fn schedule_wake(&self, at: TickType, waker: &Waker);
 }
 
 extern "Rust" {
-    fn _embassy_time_now() -> u64;
-    fn _embassy_time_schedule_wake(at: u64, waker: &Waker);
+    fn _embassy_time_now() -> TickType;
+    fn _embassy_time_schedule_wake(at: TickType, waker: &Waker);
 }
 
 /// See [`Driver::now`]
 #[inline]
-pub fn now() -> u64 {
+pub fn now() -> TickType {
     unsafe { _embassy_time_now() }
 }
 
 /// Schedule the given waker to be woken at `at`.
 #[inline]
-pub fn schedule_wake(at: u64, waker: &Waker) {
+pub fn schedule_wake(at: TickType, waker: &Waker) {
     unsafe { _embassy_time_schedule_wake(at, waker) }
 }
 
@@ -160,13 +161,13 @@ macro_rules! time_driver_impl {
 
         #[no_mangle]
         #[inline]
-        fn _embassy_time_now() -> u64 {
+        fn _embassy_time_now() -> TickType {
             <$t as $crate::Driver>::now(&$name)
         }
 
         #[no_mangle]
         #[inline]
-        fn _embassy_time_schedule_wake(at: u64, waker: &core::task::Waker) {
+        fn _embassy_time_schedule_wake(at: TickType, waker: &core::task::Waker) {
             <$t as $crate::Driver>::schedule_wake(&$name, at, waker);
         }
     };