Merge branch main into n6

4 files changed, 36 insertions, 17 deletions

diff --git a/embassy-time/src/duration.rs b/embassy-time/src/duration.rs
index 5b140eeff..b2bfd6de9 100644
--- a/embassy-time/src/duration.rs
+++ b/embassy-time/src/duration.rs
@@ -37,6 +37,11 @@ impl Duration {
         self.ticks * (1_000_000 / GCD_1M) / (TICK_HZ / GCD_1M)
     }
 
+    /// Convert the `Duration` to nanoseconds, rounding down.
+    pub const fn as_nanos(&self) -> u64 {
+        self.ticks * (1_000_000_000 / GCD_1G) / (TICK_HZ / GCD_1G)
+    }
+
     /// Creates a duration from the specified number of clock ticks
     pub const fn from_ticks(ticks: u64) -> Duration {
         Duration { ticks }
@@ -170,13 +175,7 @@ impl Duration {
     /// NOTE: Giving this function a hz >= the TICK_HZ of your platform will clamp the Duration to 1
     /// tick. Doing so will not deadlock, but will certainly not produce the desired output.
     pub const fn from_hz(hz: u64) -> Duration {
-        let ticks = {
-            if hz >= TICK_HZ {
-                1
-            } else {
-                (TICK_HZ + hz / 2) / hz
-            }
-        };
+        let ticks = { if hz >= TICK_HZ { 1 } else { (TICK_HZ + hz / 2) / hz } };
         Duration { ticks }
     }
 
diff --git a/embassy-time/src/instant.rs b/embassy-time/src/instant.rs
index 6571bea62..de5ebebf8 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::{Duration, GCD_1K, GCD_1M, TICK_HZ};
+use super::{Duration, GCD_1G, GCD_1K, GCD_1M, TICK_HZ};
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
@@ -29,6 +29,13 @@ impl Instant {
         Self { ticks }
     }
 
+    /// Create an Instant from a nanosecond count since system boot.
+    pub const fn from_nanos(nanos: u64) -> Self {
+        Self {
+            ticks: nanos * (TICK_HZ / GCD_1G) / (1_000_000_000 / GCD_1G),
+        }
+    }
+
     /// Create an Instant from a microsecond count since system boot.
     pub const fn from_micros(micros: u64) -> Self {
         Self {
@@ -50,6 +57,17 @@ impl Instant {
         }
     }
 
+    /// Try to create an Instant from a nanosecond count since system boot.
+    /// Fails if the number of nanoseconds is too large.
+    pub const fn try_from_nanos(nanos: u64) -> Option<Self> {
+        let Some(value) = nanos.checked_mul(TICK_HZ / GCD_1G) else {
+            return None;
+        };
+        Some(Self {
+            ticks: value / (1_000_000_000 / GCD_1G),
+        })
+    }
+
     /// Try to create an Instant from a microsecond count since system boot.
     /// Fails if the number of microseconds is too large.
     pub const fn try_from_micros(micros: u64) -> Option<Self> {
@@ -101,6 +119,11 @@ impl Instant {
         self.ticks * (1_000_000 / GCD_1M) / (TICK_HZ / GCD_1M)
     }
 
+    /// Nanoseconds since system boot.
+    pub const fn as_nanos(&self) -> u64 {
+        self.ticks * (1_000_000_000 / GCD_1G) / (TICK_HZ / GCD_1G)
+    }
+
     /// Duration between this Instant and another Instant
     /// Panics on over/underflow.
     pub fn duration_since(&self, earlier: Instant) -> Duration {
diff --git a/embassy-time/src/lib.rs b/embassy-time/src/lib.rs
index 77f4b344d..e375fe93e 100644
--- a/embassy-time/src/lib.rs
+++ b/embassy-time/src/lib.rs
@@ -1,5 +1,6 @@
 #![cfg_attr(not(any(feature = "std", feature = "wasm", test)), no_std)]
 #![allow(async_fn_in_trait)]
+#![allow(unsafe_op_in_unsafe_fn)]
 #![doc = include_str!("../README.md")]
 #![allow(clippy::new_without_default)]
 #![warn(missing_docs)]
@@ -27,18 +28,14 @@ mod driver_std;
 #[cfg(feature = "wasm")]
 mod driver_wasm;
 
-pub use delay::{block_for, Delay};
+pub use delay::{Delay, block_for};
 pub use duration::Duration;
 pub use embassy_time_driver::TICK_HZ;
 pub use instant::Instant;
-pub use timer::{with_deadline, with_timeout, Ticker, TimeoutError, Timer, WithTimeout};
+pub use timer::{Ticker, TimeoutError, Timer, WithTimeout, with_deadline, with_timeout};
 
 const fn gcd(a: u64, b: u64) -> u64 {
-    if b == 0 {
-        a
-    } else {
-        gcd(b, a % b)
-    }
+    if b == 0 { a } else { gcd(b, a % b) }
 }
 
 pub(crate) const GCD_1K: u64 = gcd(TICK_HZ, 1_000);
diff --git a/embassy-time/src/timer.rs b/embassy-time/src/timer.rs
index fcf79f58e..2f5967c63 100644
--- a/embassy-time/src/timer.rs
+++ b/embassy-time/src/timer.rs
@@ -1,9 +1,9 @@
-use core::future::{poll_fn, Future};
+use core::future::{Future, poll_fn};
 use core::pin::Pin;
 use core::task::{Context, Poll};
 
-use futures_core::stream::FusedStream;
 use futures_core::Stream;
+use futures_core::stream::FusedStream;
 
 use crate::{Duration, Instant};