Struct avr_oxide::devices::masterclock::MasterClock

pub struct MasterClock<'mc, T, S>
where
    T: 'static + TimerControl,
    S: EventSink,
{ /* private fields */ }

Implementations

impl<T, S> MasterClock<'_, T, S>

where T: 'static + TimerControl, S: EventSink,

pub fn using<OT: Into<OwnOrBorrowMut<'static, T>>, const FREQ_HZ: u16>( timer: OT ) -> Self

Create a MasterClock that uses the given AVR TimerControl device to schedule clock events. The desired frequency in Hz is provided as a static parameter. The timer will generate timer events to be consumed by the supervisor, which you can handle with the on_event method.

pub fn static_using<OT: Into<OwnOrBorrowMut<'static, T>>, const FREQ_HZ: u16>( timer: OT ) -> &'static mut Self

pub fn with_timer<const FREQ_HZ: u16>(timer: &'static mut T) -> Self

pub fn static_with_timer<const FREQ_HZ: u16>( timer: &'static mut T ) -> &'static mut Self

pub fn enable_preemption(&mut self)

Configure this MasterClock to drive the pre-emptive scheduling of threads (i.e. this clock will context switch each time it ticks.)

pub fn disable_preemption(&mut self)

Disable the preemption of threads using this clock.

pub fn wait(&self, delay: Duration)

Block the calling thread for (at least) the given duration.

Important

Note that the clock must be running - i.e. the supervisor.listen_handle() method was called already - before you use the wait() method, or you can expect to block forever, , and that this method depends on the main supervisor to be running. In other words, this must be used in threads you have spawn()ed, not the main thread.

Trait Implementations

impl<'mc, T, S> DelayEvents<'mc> for MasterClock<'mc, T, S>

where T: 'static + TimerControl, S: EventSink,

type DelayHandle = DelayQueueHandle

fn after_delay( &self, delay: Duration, bf: Box<dyn DelayCallback + 'mc> ) -> Self::DelayHandle

Call the given callback after /at least/ delay time has passed.

fn cancel_delay(&self, handle: Self::DelayHandle) -> bool

Cancel a given delay event, if possible. Returns true if the event was cancelled, or false if not (because it either never existed, or it has already been executed.)

impl<T, S> EventSource for MasterClock<'_, T, S>

where T: 'static + TimerControl, S: EventSink,

fn listen(&'static self)

fn process_event(&self, evt: OxideEvent)

impl<'mc, T, S> TickEvents<'mc> for MasterClock<'mc, T, S>

where T: 'static + TimerControl, S: EventSink,

fn on_tick(&self, bf: Box<dyn TickCallback + 'mc>)

Call the given closure every time the clock ticks.

impl<T, S> Send for MasterClock<'_, T, S>

where T: 'static + TimerControl, S: EventSink,

impl<T, S> Sync for MasterClock<'_, T, S>

where T: 'static + TimerControl, S: EventSink,