Struct tm4c123x_hal::timer::Timer

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

Hardware timers

Implementations

impl Timer<TIMER0>

pub fn timer0<T>(
    tim: TIMER0,
    timeout: T,
    pc: &PowerControl,
    clocks: &Clocks
) -> Self where
    T: Into<Hertz>, 

Configures a TIM peripheral as a periodic count down timer

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

Starts listening for an event

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

Stops listening for an event

pub fn free(self) -> TIMER0

Releases the TIM peripheral

impl Timer<TIMER1>

pub fn timer1<T>(
    tim: TIMER1,
    timeout: T,
    pc: &PowerControl,
    clocks: &Clocks
) -> Self where
    T: Into<Hertz>, 

Configures a TIM peripheral as a periodic count down timer

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

Starts listening for an event

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

Stops listening for an event

pub fn free(self) -> TIMER1

Releases the TIM peripheral

impl Timer<TIMER2>

pub fn timer2<T>(
    tim: TIMER2,
    timeout: T,
    pc: &PowerControl,
    clocks: &Clocks
) -> Self where
    T: Into<Hertz>, 

Configures a TIM peripheral as a periodic count down timer

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

Starts listening for an event

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

Stops listening for an event

pub fn free(self) -> TIMER2

Releases the TIM peripheral

impl Timer<TIMER3>

pub fn timer3<T>(
    tim: TIMER3,
    timeout: T,
    pc: &PowerControl,
    clocks: &Clocks
) -> Self where
    T: Into<Hertz>, 

Configures a TIM peripheral as a periodic count down timer

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

Starts listening for an event

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

Stops listening for an event

pub fn free(self) -> TIMER3

Releases the TIM peripheral

impl Timer<TIMER4>

pub fn timer4<T>(
    tim: TIMER4,
    timeout: T,
    pc: &PowerControl,
    clocks: &Clocks
) -> Self where
    T: Into<Hertz>, 

Configures a TIM peripheral as a periodic count down timer

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

Starts listening for an event

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

Stops listening for an event

pub fn free(self) -> TIMER4

Releases the TIM peripheral

impl Timer<TIMER5>

pub fn timer5<T>(
    tim: TIMER5,
    timeout: T,
    pc: &PowerControl,
    clocks: &Clocks
) -> Self where
    T: Into<Hertz>, 

Configures a TIM peripheral as a periodic count down timer

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

Starts listening for an event

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

Stops listening for an event

pub fn free(self) -> TIMER5

Releases the TIM peripheral

impl Timer<WTIMER0>

pub fn wtimer0<T>(
    tim: WTIMER0,
    timeout: T,
    pc: &PowerControl,
    clocks: &Clocks
) -> Self where
    T: Into<Hertz>, 

Configures a TIM peripheral as a periodic count down timer

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

Starts listening for an event

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

Stops listening for an event

pub fn free(self) -> WTIMER0

Releases the TIM peripheral

impl Timer<WTIMER1>

pub fn wtimer1<T>(
    tim: WTIMER1,
    timeout: T,
    pc: &PowerControl,
    clocks: &Clocks
) -> Self where
    T: Into<Hertz>, 

Configures a TIM peripheral as a periodic count down timer

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

Starts listening for an event

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

Stops listening for an event

pub fn free(self) -> WTIMER1

Releases the TIM peripheral

impl Timer<WTIMER2>

pub fn wtimer2<T>(
    tim: WTIMER2,
    timeout: T,
    pc: &PowerControl,
    clocks: &Clocks
) -> Self where
    T: Into<Hertz>, 

Configures a TIM peripheral as a periodic count down timer

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

Starts listening for an event

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

Stops listening for an event

pub fn free(self) -> WTIMER2

Releases the TIM peripheral

impl Timer<WTIMER3>

pub fn wtimer3<T>(
    tim: WTIMER3,
    timeout: T,
    pc: &PowerControl,
    clocks: &Clocks
) -> Self where
    T: Into<Hertz>, 

Configures a TIM peripheral as a periodic count down timer

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

Starts listening for an event

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

Stops listening for an event

pub fn free(self) -> WTIMER3

Releases the TIM peripheral

impl Timer<WTIMER4>

pub fn wtimer4<T>(
    tim: WTIMER4,
    timeout: T,
    pc: &PowerControl,
    clocks: &Clocks
) -> Self where
    T: Into<Hertz>, 

Configures a TIM peripheral as a periodic count down timer

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

Starts listening for an event

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

Stops listening for an event

pub fn free(self) -> WTIMER4

Releases the TIM peripheral

impl Timer<WTIMER5>

pub fn wtimer5<T>(
    tim: WTIMER5,
    timeout: T,
    pc: &PowerControl,
    clocks: &Clocks
) -> Self where
    T: Into<Hertz>, 

Configures a TIM peripheral as a periodic count down timer

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

Starts listening for an event

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

Stops listening for an event

pub fn free(self) -> WTIMER5

Releases the TIM peripheral

Trait Implementations

impl CountDown for Timer<TIMER0>

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 Timer<TIMER1>

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 Timer<WTIMER4>

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 Timer<WTIMER5>

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 Timer<TIMER2>

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 Timer<TIMER3>

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 Timer<TIMER4>

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 Timer<TIMER5>

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 Timer<WTIMER0>

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 Timer<WTIMER1>

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 Timer<WTIMER2>

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 Timer<WTIMER3>

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 Periodic for Timer<TIMER0>

impl Periodic for Timer<TIMER1>

impl Periodic for Timer<WTIMER4>

impl Periodic for Timer<WTIMER5>

impl Periodic for Timer<TIMER2>

impl Periodic for Timer<TIMER3>

impl Periodic for Timer<TIMER4>

impl Periodic for Timer<TIMER5>

impl Periodic for Timer<WTIMER0>

impl Periodic for Timer<WTIMER1>

impl Periodic for Timer<WTIMER2>

impl Periodic for Timer<WTIMER3>