Struct Regular 

pub struct Regular<'r> { /* private fields */ }

Regular sleep mode

Provides a Sleep implementation for the regular sleep mode and uses the WKT to wake the microcontroller up again, at the right time. Only clocks that the WKT supports can be used. See wkt::Clock for more details.

Examples

use lpc8xx_hal::{
    prelude::*,
    Peripherals,
    clock::Ticks,
    pac::CorePeripherals,
    sleep,
};

let mut cp = CorePeripherals::take().unwrap();
let mut p = Peripherals::take().unwrap();

let mut pmu    = p.PMU.split();
let mut syscon = p.SYSCON.split();
let mut wkt    = p.WKT.enable(&mut syscon.handle);

let clock = syscon.iosc_derived_clock;

let mut sleep = sleep::Regular::prepare(
    &mut pmu.handle,
    &mut cp.SCB,
    &mut wkt,
);

let delay = Ticks { value: 750_000, clock: &clock }; // 1000 ms

// This will put the microcontroller into sleep mode.
sleep.sleep(delay);

Implementations

impl<'r> Regular<'r>

pub fn prepare(pmu: &'r mut Handle, scb: &'r mut SCB, wkt: &'r mut WKT) -> Self

Prepare regular sleep mode

Returns an instance of sleep::Regular, which implements Sleep and can therefore be used to put the microcontroller to sleep.

Requires references to various peripherals, which will be borrowed for as long as the sleep::Regular instance exists, as they will be needed for every call to Sleep::sleep.

Trait Implementations

impl<'r, Clock> Sleep<Clock> for Regular<'r>

where Clock: Enabled + Clock,

fn sleep<'clock, T>(&mut self, ticks: T)

where Clock: 'clock, T: Into<Ticks<'clock, Clock>>,

Puts the processor to sleep for the given number of ticks of the clock