Struct LowResolutionTime

Source

pub struct LowResolutionTime { /* private fields */ }

Expand description

A timestamp recorded by the Brain’s low-resolution private timer.

This type is not in sync with Instant, which instead uses the brain’s global high-resolution timer.

§Precision

This type has a precision of 1 millisecond.

Implementations§

Source §

impl LowResolutionTime

Source

pub const EPOCH: LowResolutionTime

An anchor in time which represents the start of the clock.

In practice, the epoch represents the start of the Brain’s user processor, meaning the start of the current user program.

Source

pub fn now() -> Self

Returns a low-resolution timestamp corresponding to “now”.

§Examples

use vexide::time::LowResolutionTime;

let now = LowResolutionTime::now();

Source

pub const fn from_millis_since_epoch(millis: u32) -> Self

Creates a new timestamp at the provided number of milliseconds since LowResolutionTime::EPOCH.

§Use this sparingly.

This method generally only exists for compatibility with FFI and system APIs. The only clock measurement that should be provided to millis should be measurements derived from the CPU1 private timer (e.g. vexSystemTimeGet) to ensure that clock drift is not a factor.

When possible, prefer using LowResolutionTime::now.

§Examples

use vexide::time::LowResolutionTime;

// Equivalent to `LowResolutionTime::now()`.
let now = LowResolutionTime::from_millis_since_epoch(unsafe { vex_sdk::vexSystemTimeGet() });

Source

pub fn duration_since(&self, earlier: LowResolutionTime) -> Duration

Returns the amount of time elapsed from another timestamp to this one, or zero duration if that timestamp is later than this one.

§Examples

use std::time::Duration;

use vexide::{prelude::*, time::LowResolutionTime};

#[vexide::main]
async fn main(_peripherals: Peripherals) {
    let now = LowResolutionTime::now();
    sleep(Duration::new(1, 0)).await;

    let new_now = LowResolutionTime::now();
    println!("{:?}", new_now.duration_since(now));
    println!("{:?}", now.duration_since(new_now)); // 0ns
}

Source

pub const fn checked_duration_since( &self, earlier: LowResolutionTime, ) -> Option<Duration>

Returns the amount of time elapsed from another timestamp to this one, or None if that timestamp is later than this one.

§Examples

use std::time::Duration;

use vexide::{prelude::*, time::LowResolutionTime};

#[vexide::main]
async fn main(_peripherals: Peripherals) {
    let now = LowResolutionTime::now();
    sleep(Duration::new(1, 0)).await;

    let new_now = LowResolutionTime::now();
    println!("{:?}", new_now.checked_duration_since(now));
    println!("{:?}", now.checked_duration_since(new_now)); // None
}

Source

pub fn saturating_duration_since(&self, earlier: LowResolutionTime) -> Duration

Returns the amount of time elapsed from another timestamp to this one, or zero duration if that timestamp is later than this one.

§Examples

use std::time::Duration;

use vexide::{prelude::*, time::LowResolutionTime};

#[vexide::main]
async fn main(_peripherals: Peripherals) {
    let now = LowResolutionTime::now();
    sleep(Duration::new(1, 0)).await;
    let new_now = LowResolutionTime::now();
    println!("{:?}", new_now.saturating_duration_since(now));
    println!("{:?}", now.saturating_duration_since(new_now)); // 0ns
}

Source

pub fn elapsed(&self) -> Duration

Returns the amount of time elapsed since this timestamp.

§Examples

use std::time::Duration;

use vexide::{prelude::*, time::LowResolutionTime};

#[vexide::main]
async fn main(_peripherals: Peripherals) {
    let start = LowResolutionTime::now();
    let three_secs = Duration::from_secs(3);
    sleep(three_secs).await;
    assert!(start.elapsed() >= three_secs);
}

Source

pub fn checked_add(self, rhs: Duration) -> Option<LowResolutionTime>

Returns Some(t) where t is the time self + duration if t can be represented as LowResolutionTime (which means it’s inside the bounds of the underlying data structure), None otherwise.

Source

pub fn checked_sub(self, rhs: Duration) -> Option<LowResolutionTime>

Returns Some(t) where t is the time self - duration if t can be represented as LowResolutionTime (which means it’s inside the bounds of the underlying data structure), None otherwise.

Trait Implementations§

Source §

impl Add<Duration> for LowResolutionTime

Source §

fn add(self, rhs: Duration) -> Self::Output

§Panics

This function may panic if the resulting point in time cannot be represented by the underlying data structure. See LowResolutionTime::checked_add for a version without panic.

Source §