Struct Gpt

pub struct Gpt<'a, S> { /* private fields */ }

Implementations

impl<'a> Gpt<'a, _1>

pub const fn new_gpt1(ccm: &'a Ccm) -> Self

impl<'a> Gpt<'a, _2>

pub const fn new_gpt2(ccm: &'a Ccm) -> Self

impl<'a, S> Gpt<'a, S>

pub fn is_enabled_clock(&self) -> bool

pub fn enable_clock(&self)

pub fn disable_clock(&self)

pub fn handle_interrupt(&self)

pub fn start(&self, selection: PerclkClockSel, divider: u8)

Start the GPT, specifying the peripheral clock selection and the peripheral clock divider

If you select the crystal oscillator as the periodic clock root, the GPT will divide the input clock by 3.

divider must be non-zero.

Trait Implementations

impl<'a, F: Frequency> Alarm<'a> for Gpt<'a, F>

fn set_alarm_client(&self, client: &'a dyn AlarmClient)

Specify the callback for when the counter reaches the alarm value. If there was a previously installed callback this call replaces it.

fn set_alarm(&self, reference: Self::Ticks, dt: Self::Ticks)

Specify when the callback should be called and enable it. The callback will be enqueued when Time::now() == reference + dt. The callback itself may not run exactly at this time, due to delays. However, it it assured to execute after reference + dt: it can be delayed but will never fire early. The method takes reference and dt rather than a single value denoting the counter value so it can distinguish between alarms which have very recently already passed and those in the far far future (see #1651).

fn get_alarm(&self) -> Self::Ticks

Return the current alarm value. This is undefined at boot and otherwise returns now + dt from the last call to set_alarm.

fn disarm(&self) -> Result<(), ErrorCode>

Disable the alarm and stop it from firing in the future. Valid Result<(), ErrorCode> codes are:

fn is_armed(&self) -> bool

Returns whether the alarm is currently armed. Note that this does not reliably indicate whether there will be a future callback: it is possible that the alarm has triggered (and disarmed) and a callback is pending and has not been called yet. In this case it possible for is_armed to return false yet to receive a callback.

fn minimum_dt(&self) -> Self::Ticks

Return the minimum dt value that is supported. Any dt smaller than this will automatically be increased to this minimum value.

impl<F: Frequency> Time for Gpt<'_, F>

type Frequency = F

The number of ticks per second

type Ticks = Ticks32

The width of a time value

fn now(&self) -> Ticks32

Returns a timestamp. Depending on the implementation of Time, this could represent either a static timestamp or a sample of a counter; if an implementation relies on it being constant or changing it should use Timestamp or Counter.