Struct LiteXTimer

pub struct LiteXTimer<'a, R: LiteXSoCRegisterConfiguration, F: Frequency> { /* private fields */ }

LiteX hardware timer core

Defined in litex/soc/cores/timer.py.

This peripheral supports counting down a certain interval, either as a oneshot timer or in a repeated fashion.

Uptime extension

LiteX timers can optionally be extended to feature an uptime register integrated into the timer peripheral, monotonically counting the clock ticks and wrapping at the maximum value.

The uptime register may have a different width as the Timer peripheral itself, hence it must be implemented using a separate type. The type must contain a reference to this Timer instance, since the register is located on this register bank.

Since this extension is not always configured, the Timer features an unsafe function to read the uptime. It must only be called by LiteXTimerUptime struct and only if the uptime has been configured.

Implementations

impl<R: LiteXSoCRegisterConfiguration, F: Frequency> LiteXTimer<'_, R, F>

pub fn new(base: StaticRef<LiteXTimerRegisters<R>>) -> Self

pub fn service_interrupt(&self)

Trait Implementations

impl<R: LiteXSoCRegisterConfiguration, F: Frequency> Time for LiteXTimer<'_, R, F>

type Frequency = F

The number of ticks per second

type Ticks = Ticks32

The width of a time value

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

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.

impl<'a, R: LiteXSoCRegisterConfiguration, F: Frequency> Timer<'a> for LiteXTimer<'a, R, F>

fn set_timer_client(&self, client: &'a dyn TimerClient)

Specify the callback to invoke when the timer interval expires. If there was a previously installed callback this call replaces it.

fn oneshot(&self, interval: Self::Ticks) -> Self::Ticks

Start a one-shot timer that will invoke the callback at least interval ticks in the future. If there is a timer currently pending, calling this cancels that previous timer. After a callback is invoked for a one shot timer, the timer MUST NOT invoke the callback again unless a new timer is started (either with repeating or one shot). Returns the actual interval for the timer that was registered. This MUST NOT be smaller than interval but MAY be larger.

fn repeating(&self, interval: Self::Ticks) -> Self::Ticks

Start a repeating timer that will invoke the callback every interval ticks in the future. If there is a timer currently pending, calling this cancels that previous timer. Returns the actual interval for the timer that was registered. This MUST NOT be smaller than interval but MAY be larger.

fn interval(&self) -> Option<Self::Ticks>

Return the interval of the last requested timer.

fn is_repeating(&self) -> bool

Return if the last requested timer is a repeating timer.

fn is_oneshot(&self) -> bool

Return if the last requested timer is a one-shot timer.

fn time_remaining(&self) -> Option<Self::Ticks>

Return how many ticks are remaining until the next callback, or None if the timer is disabled. This call is useful because there may be non-negligible delays between when a timer was requested and it was actually scheduled. Therefore, since a timer’s start might be delayed slightly, the time remaining might be slightly higher than one would expect if one calculated it right before the call to start the timer.

fn is_enabled(&self) -> bool

Returns whether there is currently a timer enabled and so a callback will be expected in the future. If is_enabled returns false then the implementation MUST NOT invoke a callback until a call to oneshot or repeating restarts the timer.

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

Cancel the current timer, if any. Value Result<(), ErrorCode> values are: