Struct stm32f4xx_hal::timer::CountDownTimer

pub struct CountDownTimer<TIM> { /* fields omitted */ }

Hardware timers

Implementations

impl CountDownTimer<SYST>

pub fn listen(&mut self, event: Event)

Starts listening for an event

pub fn unlisten(&mut self, event: Event)

Stops listening for an event

impl CountDownTimer<TIM1>

pub fn listen(&mut self, event: Event)

Starts listening for an event

Note, you will also have to enable the TIM2 interrupt in the NVIC to start receiving events.

pub fn clear_interrupt(&mut self, event: Event)

Clears interrupt associated with event.

If the interrupt is not cleared, it will immediately retrigger after the ISR has finished.

pub fn unlisten(&mut self, event: Event)

Stops listening for an event

pub fn release(self) -> TIM1

Releases the TIM peripheral

impl CountDownTimer<TIM5>

pub fn listen(&mut self, event: Event)

Starts listening for an event

Note, you will also have to enable the TIM2 interrupt in the NVIC to start receiving events.

pub fn clear_interrupt(&mut self, event: Event)

Clears interrupt associated with event.

If the interrupt is not cleared, it will immediately retrigger after the ISR has finished.

pub fn unlisten(&mut self, event: Event)

Stops listening for an event

pub fn release(self) -> TIM5

Releases the TIM peripheral

impl CountDownTimer<TIM9>

pub fn listen(&mut self, event: Event)

Starts listening for an event

Note, you will also have to enable the TIM2 interrupt in the NVIC to start receiving events.

pub fn clear_interrupt(&mut self, event: Event)

Clears interrupt associated with event.

If the interrupt is not cleared, it will immediately retrigger after the ISR has finished.

pub fn unlisten(&mut self, event: Event)

Stops listening for an event

pub fn release(self) -> TIM9

Releases the TIM peripheral

impl CountDownTimer<TIM11>

pub fn listen(&mut self, event: Event)

Starts listening for an event

Note, you will also have to enable the TIM2 interrupt in the NVIC to start receiving events.

pub fn clear_interrupt(&mut self, event: Event)

Clears interrupt associated with event.

If the interrupt is not cleared, it will immediately retrigger after the ISR has finished.

pub fn unlisten(&mut self, event: Event)

Stops listening for an event

pub fn release(self) -> TIM11

Releases the TIM peripheral

impl CountDownTimer<TIM2>

pub fn listen(&mut self, event: Event)

Starts listening for an event

Note, you will also have to enable the TIM2 interrupt in the NVIC to start receiving events.

pub fn clear_interrupt(&mut self, event: Event)

Clears interrupt associated with event.

If the interrupt is not cleared, it will immediately retrigger after the ISR has finished.

pub fn unlisten(&mut self, event: Event)

Stops listening for an event

pub fn release(self) -> TIM2

Releases the TIM peripheral

impl CountDownTimer<TIM3>

pub fn listen(&mut self, event: Event)

Starts listening for an event

Note, you will also have to enable the TIM2 interrupt in the NVIC to start receiving events.

pub fn clear_interrupt(&mut self, event: Event)

Clears interrupt associated with event.

If the interrupt is not cleared, it will immediately retrigger after the ISR has finished.

pub fn unlisten(&mut self, event: Event)

Stops listening for an event

pub fn release(self) -> TIM3

Releases the TIM peripheral

impl CountDownTimer<TIM4>

pub fn listen(&mut self, event: Event)

Starts listening for an event

Note, you will also have to enable the TIM2 interrupt in the NVIC to start receiving events.

pub fn clear_interrupt(&mut self, event: Event)

Clears interrupt associated with event.

If the interrupt is not cleared, it will immediately retrigger after the ISR has finished.

pub fn unlisten(&mut self, event: Event)

Stops listening for an event

pub fn release(self) -> TIM4

Releases the TIM peripheral

impl CountDownTimer<TIM10>

pub fn listen(&mut self, event: Event)

Starts listening for an event

Note, you will also have to enable the TIM2 interrupt in the NVIC to start receiving events.

pub fn clear_interrupt(&mut self, event: Event)

Clears interrupt associated with event.

If the interrupt is not cleared, it will immediately retrigger after the ISR has finished.

pub fn unlisten(&mut self, event: Event)

Stops listening for an event

pub fn release(self) -> TIM10

Releases the TIM peripheral

impl CountDownTimer<TIM6>

pub fn listen(&mut self, event: Event)

Starts listening for an event

Note, you will also have to enable the TIM2 interrupt in the NVIC to start receiving events.

pub fn clear_interrupt(&mut self, event: Event)

Clears interrupt associated with event.

If the interrupt is not cleared, it will immediately retrigger after the ISR has finished.

pub fn unlisten(&mut self, event: Event)

Stops listening for an event

pub fn release(self) -> TIM6

Releases the TIM peripheral

impl CountDownTimer<TIM7>

pub fn listen(&mut self, event: Event)

Starts listening for an event

Note, you will also have to enable the TIM2 interrupt in the NVIC to start receiving events.

pub fn clear_interrupt(&mut self, event: Event)

Clears interrupt associated with event.

If the interrupt is not cleared, it will immediately retrigger after the ISR has finished.

pub fn unlisten(&mut self, event: Event)

Stops listening for an event

pub fn release(self) -> TIM7

Releases the TIM peripheral

impl CountDownTimer<TIM8>

pub fn listen(&mut self, event: Event)

Starts listening for an event

Note, you will also have to enable the TIM2 interrupt in the NVIC to start receiving events.

pub fn clear_interrupt(&mut self, event: Event)

Clears interrupt associated with event.

If the interrupt is not cleared, it will immediately retrigger after the ISR has finished.

pub fn unlisten(&mut self, event: Event)

Stops listening for an event

pub fn release(self) -> TIM8

Releases the TIM peripheral

impl CountDownTimer<TIM12>

pub fn listen(&mut self, event: Event)

Starts listening for an event

Note, you will also have to enable the TIM2 interrupt in the NVIC to start receiving events.

pub fn clear_interrupt(&mut self, event: Event)

Clears interrupt associated with event.

If the interrupt is not cleared, it will immediately retrigger after the ISR has finished.

pub fn unlisten(&mut self, event: Event)

Stops listening for an event

pub fn release(self) -> TIM12

Releases the TIM peripheral

impl CountDownTimer<TIM13>

pub fn listen(&mut self, event: Event)

Starts listening for an event

Note, you will also have to enable the TIM2 interrupt in the NVIC to start receiving events.

pub fn clear_interrupt(&mut self, event: Event)

Clears interrupt associated with event.

If the interrupt is not cleared, it will immediately retrigger after the ISR has finished.

pub fn unlisten(&mut self, event: Event)

Stops listening for an event

pub fn release(self) -> TIM13

Releases the TIM peripheral

impl CountDownTimer<TIM14>

pub fn listen(&mut self, event: Event)

Starts listening for an event

Note, you will also have to enable the TIM2 interrupt in the NVIC to start receiving events.

pub fn clear_interrupt(&mut self, event: Event)

Clears interrupt associated with event.

If the interrupt is not cleared, it will immediately retrigger after the ISR has finished.

pub fn unlisten(&mut self, event: Event)

Stops listening for an event

pub fn release(self) -> TIM14

Releases the TIM peripheral

Trait Implementations

impl Cancel for CountDownTimer<SYST>

type Error = Error

Error returned when a countdown can’t be canceled.

fn cancel(&mut self) -> Result<(), Self::Error>

Tries to cancel this countdown.

impl Cancel for CountDownTimer<TIM1>

type Error = Error

Error returned when a countdown can’t be canceled.

fn cancel(&mut self) -> Result<(), Self::Error>

Tries to cancel this countdown.

impl Cancel for CountDownTimer<TIM7>

type Error = Error

Error returned when a countdown can’t be canceled.

fn cancel(&mut self) -> Result<(), Self::Error>

Tries to cancel this countdown.

impl Cancel for CountDownTimer<TIM8>

type Error = Error

Error returned when a countdown can’t be canceled.

fn cancel(&mut self) -> Result<(), Self::Error>

Tries to cancel this countdown.

impl Cancel for CountDownTimer<TIM12>

type Error = Error

Error returned when a countdown can’t be canceled.

fn cancel(&mut self) -> Result<(), Self::Error>

Tries to cancel this countdown.

impl Cancel for CountDownTimer<TIM13>

type Error = Error

Error returned when a countdown can’t be canceled.

fn cancel(&mut self) -> Result<(), Self::Error>

Tries to cancel this countdown.

impl Cancel for CountDownTimer<TIM14>

type Error = Error

Error returned when a countdown can’t be canceled.

fn cancel(&mut self) -> Result<(), Self::Error>

Tries to cancel this countdown.

impl Cancel for CountDownTimer<TIM5>

type Error = Error

Error returned when a countdown can’t be canceled.

fn cancel(&mut self) -> Result<(), Self::Error>

Tries to cancel this countdown.

impl Cancel for CountDownTimer<TIM9>

type Error = Error

Error returned when a countdown can’t be canceled.

fn cancel(&mut self) -> Result<(), Self::Error>

Tries to cancel this countdown.

impl Cancel for CountDownTimer<TIM11>

type Error = Error

Error returned when a countdown can’t be canceled.

fn cancel(&mut self) -> Result<(), Self::Error>

Tries to cancel this countdown.

impl Cancel for CountDownTimer<TIM2>

type Error = Error

Error returned when a countdown can’t be canceled.

fn cancel(&mut self) -> Result<(), Self::Error>

Tries to cancel this countdown.

impl Cancel for CountDownTimer<TIM3>

type Error = Error

Error returned when a countdown can’t be canceled.

fn cancel(&mut self) -> Result<(), Self::Error>

Tries to cancel this countdown.

impl Cancel for CountDownTimer<TIM4>

type Error = Error

Error returned when a countdown can’t be canceled.

fn cancel(&mut self) -> Result<(), Self::Error>

Tries to cancel this countdown.

impl Cancel for CountDownTimer<TIM10>

type Error = Error

Error returned when a countdown can’t be canceled.

fn cancel(&mut self) -> Result<(), Self::Error>

Tries to cancel this countdown.

impl Cancel for CountDownTimer<TIM6>

type Error = Error

Error returned when a countdown can’t be canceled.

fn cancel(&mut self) -> Result<(), Self::Error>

Tries to cancel this countdown.

impl CountDown for CountDownTimer<SYST>

type Time = Hertz

The unit of time used by this timer

fn start<T>(&mut self, timeout: T) where
    T: Into<Hertz>, 

Starts a new count down

fn wait(&mut self) -> Result<(), Void>

Non-blockingly “waits” until the count down finishes

impl CountDown for CountDownTimer<TIM1>

type Time = Hertz

The unit of time used by this timer

fn start<T>(&mut self, timeout: T) where
    T: Into<Hertz>, 

Starts a new count down

fn wait(&mut self) -> Result<(), Void>

Non-blockingly “waits” until the count down finishes

impl CountDown for CountDownTimer<TIM7>

type Time = Hertz

The unit of time used by this timer

fn start<T>(&mut self, timeout: T) where
    T: Into<Hertz>, 

Starts a new count down

fn wait(&mut self) -> Result<(), Void>

Non-blockingly “waits” until the count down finishes

impl CountDown for CountDownTimer<TIM8>

type Time = Hertz

The unit of time used by this timer

fn start<T>(&mut self, timeout: T) where
    T: Into<Hertz>, 

Starts a new count down

fn wait(&mut self) -> Result<(), Void>

Non-blockingly “waits” until the count down finishes

impl CountDown for CountDownTimer<TIM12>

type Time = Hertz

The unit of time used by this timer

fn start<T>(&mut self, timeout: T) where
    T: Into<Hertz>, 

Starts a new count down

fn wait(&mut self) -> Result<(), Void>

Non-blockingly “waits” until the count down finishes

impl CountDown for CountDownTimer<TIM13>

type Time = Hertz

The unit of time used by this timer

fn start<T>(&mut self, timeout: T) where
    T: Into<Hertz>, 

Starts a new count down

fn wait(&mut self) -> Result<(), Void>

Non-blockingly “waits” until the count down finishes

impl CountDown for CountDownTimer<TIM14>

type Time = Hertz

The unit of time used by this timer

fn start<T>(&mut self, timeout: T) where
    T: Into<Hertz>, 

Starts a new count down

fn wait(&mut self) -> Result<(), Void>

Non-blockingly “waits” until the count down finishes

impl CountDown for CountDownTimer<TIM5>

type Time = Hertz

The unit of time used by this timer

fn start<T>(&mut self, timeout: T) where
    T: Into<Hertz>, 

Starts a new count down

fn wait(&mut self) -> Result<(), Void>

Non-blockingly “waits” until the count down finishes

impl CountDown for CountDownTimer<TIM9>

type Time = Hertz

The unit of time used by this timer

fn start<T>(&mut self, timeout: T) where
    T: Into<Hertz>, 

Starts a new count down

fn wait(&mut self) -> Result<(), Void>

Non-blockingly “waits” until the count down finishes

impl CountDown for CountDownTimer<TIM11>

type Time = Hertz

The unit of time used by this timer

fn start<T>(&mut self, timeout: T) where
    T: Into<Hertz>, 

Starts a new count down

fn wait(&mut self) -> Result<(), Void>

Non-blockingly “waits” until the count down finishes

impl CountDown for CountDownTimer<TIM2>

type Time = Hertz

The unit of time used by this timer

fn start<T>(&mut self, timeout: T) where
    T: Into<Hertz>, 

Starts a new count down

fn wait(&mut self) -> Result<(), Void>

Non-blockingly “waits” until the count down finishes

impl CountDown for CountDownTimer<TIM3>

type Time = Hertz

The unit of time used by this timer

fn start<T>(&mut self, timeout: T) where
    T: Into<Hertz>, 

Starts a new count down

fn wait(&mut self) -> Result<(), Void>

Non-blockingly “waits” until the count down finishes

impl CountDown for CountDownTimer<TIM4>

type Time = Hertz

The unit of time used by this timer

fn start<T>(&mut self, timeout: T) where
    T: Into<Hertz>, 

Starts a new count down

fn wait(&mut self) -> Result<(), Void>

Non-blockingly “waits” until the count down finishes

impl CountDown for CountDownTimer<TIM10>

type Time = Hertz

The unit of time used by this timer

fn start<T>(&mut self, timeout: T) where
    T: Into<Hertz>, 

Starts a new count down

fn wait(&mut self) -> Result<(), Void>

Non-blockingly “waits” until the count down finishes

impl CountDown for CountDownTimer<TIM6>

type Time = Hertz

The unit of time used by this timer

fn start<T>(&mut self, timeout: T) where
    T: Into<Hertz>, 

Starts a new count down

fn wait(&mut self) -> Result<(), Void>

Non-blockingly “waits” until the count down finishes

impl<TIM> Periodic for CountDownTimer<TIM>