|
@@ -24,21 +24,39 @@ use core::{fmt, ops};
|
|
|
#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
|
|
|
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
|
|
|
pub struct Instant {
|
|
|
- pub millis: i64,
|
|
|
+ micros: i64,
|
|
|
}
|
|
|
|
|
|
impl Instant {
|
|
|
+ /// Create a new `Instant` from a number of microseconds.
|
|
|
+ pub fn from_micros<T: Into<i64>>(micros: T) -> Instant {
|
|
|
+ Instant {
|
|
|
+ micros: micros.into(),
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ pub const fn from_micros_const(micros: i64) -> Instant {
|
|
|
+ Instant { micros }
|
|
|
+ }
|
|
|
+
|
|
|
/// Create a new `Instant` from a number of milliseconds.
|
|
|
pub fn from_millis<T: Into<i64>>(millis: T) -> Instant {
|
|
|
Instant {
|
|
|
- millis: millis.into(),
|
|
|
+ micros: millis.into() * 1000,
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Create a new `Instant` from a number of milliseconds.
|
|
|
+ pub const fn from_millis_const(millis: i64) -> Instant {
|
|
|
+ Instant {
|
|
|
+ micros: millis * 1000,
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// Create a new `Instant` from a number of seconds.
|
|
|
pub fn from_secs<T: Into<i64>>(secs: T) -> Instant {
|
|
|
Instant {
|
|
|
- millis: secs.into() * 1000,
|
|
|
+ micros: secs.into() * 1000000,
|
|
|
}
|
|
|
}
|
|
|
|
|
@@ -56,25 +74,30 @@ impl Instant {
|
|
|
/// The fractional number of milliseconds that have passed
|
|
|
/// since the beginning of time.
|
|
|
pub const fn millis(&self) -> i64 {
|
|
|
- self.millis % 1000
|
|
|
+ self.micros % 1000000 / 1000
|
|
|
}
|
|
|
|
|
|
/// The fractional number of microseconds that have passed
|
|
|
/// since the beginning of time.
|
|
|
pub const fn micros(&self) -> i64 {
|
|
|
- self.millis % 1000 * 1000
|
|
|
+ self.micros % 1000000
|
|
|
}
|
|
|
|
|
|
/// The number of whole seconds that have passed since the
|
|
|
/// beginning of time.
|
|
|
pub const fn secs(&self) -> i64 {
|
|
|
- self.millis / 1000
|
|
|
+ self.micros / 1000000
|
|
|
}
|
|
|
|
|
|
/// The total number of milliseconds that have passed since
|
|
|
/// the biginning of time.
|
|
|
pub const fn total_millis(&self) -> i64 {
|
|
|
- self.millis
|
|
|
+ self.micros / 1000
|
|
|
+ }
|
|
|
+ /// The total number of milliseconds that have passed since
|
|
|
+ /// the biginning of time.
|
|
|
+ pub const fn total_micros(&self) -> i64 {
|
|
|
+ self.micros
|
|
|
}
|
|
|
}
|
|
|
|
|
@@ -82,7 +105,7 @@ impl Instant {
|
|
|
impl From<::std::time::Instant> for Instant {
|
|
|
fn from(other: ::std::time::Instant) -> Instant {
|
|
|
let elapsed = other.elapsed();
|
|
|
- Instant::from_millis((elapsed.as_secs() * 1_000) as i64 + elapsed.subsec_millis() as i64)
|
|
|
+ Instant::from_millis((elapsed.as_secs() * 1_000000) as i64 + elapsed.subsec_micros() as i64)
|
|
|
}
|
|
|
}
|
|
|
|
|
@@ -92,14 +115,14 @@ impl From<::std::time::SystemTime> for Instant {
|
|
|
let n = other
|
|
|
.duration_since(::std::time::UNIX_EPOCH)
|
|
|
.expect("start time must not be before the unix epoch");
|
|
|
- Self::from_millis(n.as_secs() as i64 * 1000 + n.subsec_millis() as i64)
|
|
|
+ Self::from_millis(n.as_secs() as i64 * 1000000 + n.subsec_micros() as i64)
|
|
|
}
|
|
|
}
|
|
|
|
|
|
#[cfg(feature = "std")]
|
|
|
impl From<Instant> for ::std::time::SystemTime {
|
|
|
fn from(val: Instant) -> Self {
|
|
|
- ::std::time::UNIX_EPOCH + ::std::time::Duration::from_millis(val.millis as u64)
|
|
|
+ ::std::time::UNIX_EPOCH + ::std::time::Duration::from_micros(val.micros as u64)
|
|
|
}
|
|
|
}
|
|
|
|
|
@@ -113,13 +136,13 @@ impl ops::Add<Duration> for Instant {
|
|
|
type Output = Instant;
|
|
|
|
|
|
fn add(self, rhs: Duration) -> Instant {
|
|
|
- Instant::from_millis(self.millis + rhs.total_millis() as i64)
|
|
|
+ Instant::from_micros(self.micros + rhs.total_micros() as i64)
|
|
|
}
|
|
|
}
|
|
|
|
|
|
impl ops::AddAssign<Duration> for Instant {
|
|
|
fn add_assign(&mut self, rhs: Duration) {
|
|
|
- self.millis += rhs.total_millis() as i64;
|
|
|
+ self.micros += rhs.total_micros() as i64;
|
|
|
}
|
|
|
}
|
|
|
|
|
@@ -127,13 +150,13 @@ impl ops::Sub<Duration> for Instant {
|
|
|
type Output = Instant;
|
|
|
|
|
|
fn sub(self, rhs: Duration) -> Instant {
|
|
|
- Instant::from_millis(self.millis - rhs.total_millis() as i64)
|
|
|
+ Instant::from_micros(self.micros - rhs.total_micros() as i64)
|
|
|
}
|
|
|
}
|
|
|
|
|
|
impl ops::SubAssign<Duration> for Instant {
|
|
|
fn sub_assign(&mut self, rhs: Duration) {
|
|
|
- self.millis -= rhs.total_millis() as i64;
|
|
|
+ self.micros -= rhs.total_micros() as i64;
|
|
|
}
|
|
|
}
|
|
|
|
|
@@ -141,7 +164,7 @@ impl ops::Sub<Instant> for Instant {
|
|
|
type Output = Duration;
|
|
|
|
|
|
fn sub(self, rhs: Instant) -> Duration {
|
|
|
- Duration::from_millis((self.millis - rhs.millis).abs() as u64)
|
|
|
+ Duration::from_micros((self.micros - rhs.micros).abs() as u64)
|
|
|
}
|
|
|
}
|
|
|
|
|
@@ -149,35 +172,53 @@ impl ops::Sub<Instant> for Instant {
|
|
|
#[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
|
|
|
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
|
|
|
pub struct Duration {
|
|
|
- pub millis: u64,
|
|
|
+ micros: u64,
|
|
|
}
|
|
|
|
|
|
impl Duration {
|
|
|
+ pub const ZERO: Duration = Duration::from_micros(0);
|
|
|
+ /// Create a new `Duration` from a number of microeconds.
|
|
|
+ pub const fn from_micros(micros: u64) -> Duration {
|
|
|
+ Duration { micros }
|
|
|
+ }
|
|
|
+
|
|
|
/// Create a new `Duration` from a number of milliseconds.
|
|
|
pub const fn from_millis(millis: u64) -> Duration {
|
|
|
- Duration { millis }
|
|
|
+ Duration {
|
|
|
+ micros: millis * 1000,
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
/// Create a new `Instant` from a number of seconds.
|
|
|
pub const fn from_secs(secs: u64) -> Duration {
|
|
|
Duration {
|
|
|
- millis: secs * 1000,
|
|
|
+ micros: secs * 1000000,
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// The fractional number of milliseconds in this `Duration`.
|
|
|
pub const fn millis(&self) -> u64 {
|
|
|
- self.millis % 1000
|
|
|
+ self.micros / 1000 % 1000
|
|
|
+ }
|
|
|
+
|
|
|
+ /// The fractional number of milliseconds in this `Duration`.
|
|
|
+ pub const fn micros(&self) -> u64 {
|
|
|
+ self.micros % 1000000
|
|
|
}
|
|
|
|
|
|
/// The number of whole seconds in this `Duration`.
|
|
|
pub const fn secs(&self) -> u64 {
|
|
|
- self.millis / 1000
|
|
|
+ self.micros / 1000000
|
|
|
}
|
|
|
|
|
|
/// The total number of milliseconds in this `Duration`.
|
|
|
pub const fn total_millis(&self) -> u64 {
|
|
|
- self.millis
|
|
|
+ self.micros / 1000
|
|
|
+ }
|
|
|
+
|
|
|
+ /// The total number of microseconds in this `Duration`.
|
|
|
+ pub const fn total_micros(&self) -> u64 {
|
|
|
+ self.micros
|
|
|
}
|
|
|
}
|
|
|
|
|
@@ -191,13 +232,13 @@ impl ops::Add<Duration> for Duration {
|
|
|
type Output = Duration;
|
|
|
|
|
|
fn add(self, rhs: Duration) -> Duration {
|
|
|
- Duration::from_millis(self.millis + rhs.total_millis())
|
|
|
+ Duration::from_micros(self.micros + rhs.total_micros())
|
|
|
}
|
|
|
}
|
|
|
|
|
|
impl ops::AddAssign<Duration> for Duration {
|
|
|
fn add_assign(&mut self, rhs: Duration) {
|
|
|
- self.millis += rhs.total_millis();
|
|
|
+ self.micros += rhs.total_micros();
|
|
|
}
|
|
|
}
|
|
|
|
|
@@ -205,9 +246,9 @@ impl ops::Sub<Duration> for Duration {
|
|
|
type Output = Duration;
|
|
|
|
|
|
fn sub(self, rhs: Duration) -> Duration {
|
|
|
- Duration::from_millis(
|
|
|
- self.millis
|
|
|
- .checked_sub(rhs.total_millis())
|
|
|
+ Duration::from_micros(
|
|
|
+ self.micros
|
|
|
+ .checked_sub(rhs.total_micros())
|
|
|
.expect("overflow when subtracting durations"),
|
|
|
)
|
|
|
}
|
|
@@ -215,9 +256,9 @@ impl ops::Sub<Duration> for Duration {
|
|
|
|
|
|
impl ops::SubAssign<Duration> for Duration {
|
|
|
fn sub_assign(&mut self, rhs: Duration) {
|
|
|
- self.millis = self
|
|
|
- .millis
|
|
|
- .checked_sub(rhs.total_millis())
|
|
|
+ self.micros = self
|
|
|
+ .micros
|
|
|
+ .checked_sub(rhs.total_micros())
|
|
|
.expect("overflow when subtracting durations");
|
|
|
}
|
|
|
}
|
|
@@ -226,13 +267,13 @@ impl ops::Mul<u32> for Duration {
|
|
|
type Output = Duration;
|
|
|
|
|
|
fn mul(self, rhs: u32) -> Duration {
|
|
|
- Duration::from_millis(self.millis * rhs as u64)
|
|
|
+ Duration::from_micros(self.micros * rhs as u64)
|
|
|
}
|
|
|
}
|
|
|
|
|
|
impl ops::MulAssign<u32> for Duration {
|
|
|
fn mul_assign(&mut self, rhs: u32) {
|
|
|
- self.millis *= rhs as u64;
|
|
|
+ self.micros *= rhs as u64;
|
|
|
}
|
|
|
}
|
|
|
|
|
@@ -240,13 +281,13 @@ impl ops::Div<u32> for Duration {
|
|
|
type Output = Duration;
|
|
|
|
|
|
fn div(self, rhs: u32) -> Duration {
|
|
|
- Duration::from_millis(self.millis / rhs as u64)
|
|
|
+ Duration::from_micros(self.micros / rhs as u64)
|
|
|
}
|
|
|
}
|
|
|
|
|
|
impl ops::DivAssign<u32> for Duration {
|
|
|
fn div_assign(&mut self, rhs: u32) {
|
|
|
- self.millis /= rhs as u64;
|
|
|
+ self.micros /= rhs as u64;
|
|
|
}
|
|
|
}
|
|
|
|
|
@@ -254,13 +295,13 @@ impl ops::Shl<u32> for Duration {
|
|
|
type Output = Duration;
|
|
|
|
|
|
fn shl(self, rhs: u32) -> Duration {
|
|
|
- Duration::from_millis(self.millis << rhs)
|
|
|
+ Duration::from_micros(self.micros << rhs)
|
|
|
}
|
|
|
}
|
|
|
|
|
|
impl ops::ShlAssign<u32> for Duration {
|
|
|
fn shl_assign(&mut self, rhs: u32) {
|
|
|
- self.millis <<= rhs;
|
|
|
+ self.micros <<= rhs;
|
|
|
}
|
|
|
}
|
|
|
|
|
@@ -268,25 +309,25 @@ impl ops::Shr<u32> for Duration {
|
|
|
type Output = Duration;
|
|
|
|
|
|
fn shr(self, rhs: u32) -> Duration {
|
|
|
- Duration::from_millis(self.millis >> rhs)
|
|
|
+ Duration::from_micros(self.micros >> rhs)
|
|
|
}
|
|
|
}
|
|
|
|
|
|
impl ops::ShrAssign<u32> for Duration {
|
|
|
fn shr_assign(&mut self, rhs: u32) {
|
|
|
- self.millis >>= rhs;
|
|
|
+ self.micros >>= rhs;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
impl From<::core::time::Duration> for Duration {
|
|
|
fn from(other: ::core::time::Duration) -> Duration {
|
|
|
- Duration::from_millis(other.as_secs() * 1000 + other.subsec_millis() as u64)
|
|
|
+ Duration::from_micros(other.as_secs() * 1000000 + other.subsec_micros() as u64)
|
|
|
}
|
|
|
}
|
|
|
|
|
|
impl From<Duration> for ::core::time::Duration {
|
|
|
fn from(val: Duration) -> Self {
|
|
|
- ::core::time::Duration::from_millis(val.total_millis())
|
|
|
+ ::core::time::Duration::from_micros(val.total_micros())
|
|
|
}
|
|
|
}
|
|
|
|
|
@@ -353,7 +394,7 @@ mod test {
|
|
|
// std::ops::Mul
|
|
|
assert_eq!(Duration::from_millis(13) * 22, Duration::from_millis(286));
|
|
|
// std::ops::Div
|
|
|
- assert_eq!(Duration::from_millis(53) / 4, Duration::from_millis(13));
|
|
|
+ assert_eq!(Duration::from_millis(53) / 4, Duration::from_micros(13250));
|
|
|
}
|
|
|
|
|
|
#[test]
|
|
@@ -366,7 +407,7 @@ mod test {
|
|
|
duration *= 4;
|
|
|
assert_eq!(duration, Duration::from_millis(20936));
|
|
|
duration /= 5;
|
|
|
- assert_eq!(duration, Duration::from_millis(4187));
|
|
|
+ assert_eq!(duration, Duration::from_micros(4187200));
|
|
|
}
|
|
|
|
|
|
#[test]
|