Struct Ticktimer

pub struct Ticktimer { /* private fields */ }

Implementations

impl Ticktimer

pub fn new() -> Result<Self, Error>

pub fn elapsed_ms(&self) -> u64

Return the number of milliseconds that have elapsed since boot. The returned value is guaranteed to always be the same or greater than the previous value, even through suspend/resume cycles. During suspend, the counter does not advance, so loops which rely on this value will not perceive any extra time passing through a suspend/resume cycle.

This call is expected to be infalliable, and removing the error handling path makes it a little more efficient in a tight loop.

Returns:

* A `u64` that is the number of milliseconds elapsed since boot.

pub fn sleep_ms(&self, ms: usize) -> Result<(), Error>

Sleep for at least ms milliseconds. Blocks until the requested time has passed.

Arguments:

* ms: A `usize` specifying how many milliseconds to sleep for

pub fn ping_wdt(&self)

Ping the watchdog timer. Processes may use this to periodically ping the WDT to prevent the system from resetting itself. Note that every call to sleep_ms() also implicitly pings the WDT, so in more complicated systems an explicit call is not needed.

pub fn get_version(&self) -> String

Query version information embedded in this implementation crate by the build system.

Returns:

* A `String` containing the version information of the latest build

pub fn get_version_semver(&self) -> SemVer

pub fn lock_mutex(&self, mtx: usize)

Lock the given Mutex. Blocks until the Mutex is locked.

Note that Mutexes start out in a Locked state and move into an Unlocked state by calling Unlock on their pointer. For example, the following will probably block forever:

`TickTimer.lock_mutex(1)`

In order to create a new Mutex, you must first Unlock it. For example, the following is allowed:

`TickTimer.unlock_mutex(1)`
`TickTimer.lock_mutex(1)`
`TickTimer.unlock_mutex(1)`

Arguments:

* mtx: A `usize` referring to the Mutex. This is probably a pointer, but can be any `usize`

pub fn unlock_mutex(&self, mtx: usize)

Unlock the given Mutex. Does not block. If the Mutex is not locked, then it will be “doubly-unlocked”. That is, if you Unlock a mutex twice, then you can Lock it twice without blocking.

Arguments:

* mtx: A `usize` referring to the Mutex. This is probably a pointer, but can be any `usize`

pub fn wait_condition(&self, condvar: usize, duration: Option<Duration>) -> bool

Wait for a Condition on the given condvar, with an optional Duration

Arguments:

* condvar: A `usize` referring to the Condvar. This is probably a pointer, but can be any `usize`
* duration: The amount of time to wait for a signal, if any

Returns:

* true: the condition was successfully received
* false: the condition was not received and the operation itmed out

pub fn notify_condition(&self, condvar: usize, count: usize)

Notify a condition to one or more Waiters

Arguments:

* condvar: A `usize` referring to the Condvar. This is probably a pointer, but can be any `usize`
* count: The number of Waiters to wake up

Trait Implementations

impl Debug for Ticktimer

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for Ticktimer

fn drop(&mut self)

Executes the destructor for this type.