Merge pull request #54 from jonas-schievink/lptim

Low-Power Timer support

Author: arkorobotics

examples/lptim.rs

@@ -0,0 +1,151 @@
+//! Low-Power Timer wakeup.
+
+#![no_main]
+#![no_std]
+
+
+extern crate panic_semihosting;
+
+use nb::block;
+use cortex_m::{asm, peripheral::NVIC};
+use cortex_m_rt::entry;
+use stm32l0xx_hal::{
+    prelude::*,
+    exti,
+    gpio::{
+        self,
+        Output,
+        PushPull,
+        gpiob::PB,
+    },
+    lptim::{
+        self,
+        LpTimer,
+        ClockSrc,
+    },
+    pac,
+    pwr::{
+        self,
+        PWR,
+    },
+    rcc,
+    syscfg::SYSCFG,
+};
+
+
+#[entry]
+fn main() -> ! {
+    let cp = pac::CorePeripherals::take().unwrap();
+    let dp = pac::Peripherals::take().unwrap();
+
+    let mut scb   = cp.SCB;
+    let mut rcc   = dp.RCC.freeze(rcc::Config::msi(rcc::MSIRange::Range0));
+    let mut exti  = dp.EXTI;
+    let mut pwr   = PWR::new(dp.PWR, &mut rcc);
+    let     gpiob = dp.GPIOB.split(&mut rcc);
+
+    let mut led = gpiob.pb2.into_push_pull_output().downgrade();
+
+    let mut syscfg = SYSCFG::new(dp.SYSCFG, &mut rcc);
+    let mut lptim = LpTimer::init_periodic(dp.LPTIM, &mut pwr, &mut rcc, ClockSrc::Lse);
+
+    let exti_line = 29; // LPTIM1 wakeup
+
+    lptim.enable_interrupts(lptim::Interrupts {
+        autoreload_match: true,
+        ..lptim::Interrupts::default()
+    });
+    exti.listen(
+        &mut syscfg,
+        gpio::Port::PA, // argument ignored; next argument is not a GPIO line
+        exti_line,
+        exti::TriggerEdge::Rising,
+    );
+
+    // Blink twice to signal the start of the program
+    blink(&mut led);
+    blink(&mut led);
+
+    // 1 seconds of regular run mode
+    lptim.start(1.hz());
+    block!(lptim.wait()).unwrap();
+
+    exti.clear_irq(exti_line);
+    NVIC::unpend(pac::Interrupt::LPTIM1);
+
+    blink(&mut led);
+
+    // 1 seconds of low-power run mode
+    pwr.enter_low_power_run_mode(rcc.clocks);
+    block!(lptim.wait()).unwrap();
+    pwr.exit_low_power_run_mode();
+    exti.clear_irq(exti_line);
+    cortex_m::peripheral::NVIC::unpend(pac::Interrupt::LPTIM1);
+
+    blink(&mut led);
+
+    // 1 seconds of sleep mode
+    exti.wait_for_irq(
+        exti_line,
+        pwr.sleep_mode(&mut scb),
+    );
+    lptim.wait().unwrap(); // returns immediately; we just got the interrupt
+    exti.clear_irq(exti_line);
+    cortex_m::peripheral::NVIC::unpend(pac::Interrupt::LPTIM1);
+
+    blink(&mut led);
+
+    // 1 seconds of low-power sleep mode
+    exti.wait_for_irq(
+        exti_line,
+        pwr.low_power_sleep_mode(&mut scb, &mut rcc),
+    );
+    lptim.wait().unwrap(); // returns immediately; we just got the interrupt
+    exti.clear_irq(exti_line);
+    cortex_m::peripheral::NVIC::unpend(pac::Interrupt::LPTIM1);
+
+    blink(&mut led);
+
+    // 1 seconds of stop mode
+    exti.wait_for_irq(
+        exti_line,
+        pwr.stop_mode(
+            &mut scb,
+            &mut rcc,
+            pwr::StopModeConfig {
+                ultra_low_power: true,
+            },
+        ),
+    );
+    lptim.wait().unwrap(); // returns immediately; we just got the interrupt
+
+    blink(&mut led);
+
+    // 1 second of standby mode
+    cortex_m::peripheral::NVIC::unpend(pac::Interrupt::LPTIM1);
+    exti.wait_for_irq(
+        exti_line,
+        pwr.standby_mode(&mut scb),
+    );
+
+    // The microcontroller resets after leaving standby mode. We should never
+    // reach this point.
+    loop {
+        blink(&mut led);
+    }
+}
+
+
+fn blink(led: &mut PB<Output<PushPull>>) {
+    led.set_high().unwrap();
+    delay();
+    led.set_low().unwrap();
+    delay();
+}
+
+fn delay() {
+    // We can't use `Delay`, as that requires a frequency of at least one MHz.
+    // Given our clock selection, the following loop should give us a nice delay
+    // when compiled in release mode.
+    for _ in 0 .. 1_000 { asm::nop() }
+}

src/exti.rs

@@ -34,13 +34,12 @@ pub fn line_is_triggered(reg: u32, line: u8) -> bool {
 }
 
 impl ExtiExt for EXTI {
-    // `port`, `line` and `edge` are almost always constants, so make sure they can be
-    // constant-propagated by marking the function as `#[inline]`. This saves ~600 Bytes in some
-    // simple apps (eg. the `pwr.rs` example).
+
+    // `port` and `line` are almost always constants, so make sure they can get constant-propagated
+    // by inlining the method. Saves ~600 Bytes in the `lptim.rs` example.
     #[inline]
     fn listen(&self, syscfg: &mut SYSCFG, port: gpio::Port, line: u8, edge: TriggerEdge) {
-        assert!(line <= 22);
-        assert_ne!(line, 18);
+        assert_line_valid(line);
 
         // translate port into bit values for EXTIn registers
         let port_bm = match port {
@@ -120,17 +119,15 @@ impl ExtiExt for EXTI {
     }
 
     fn unlisten(&self, line: u8) {
-        assert!(line <= 22);
-        assert_ne!(line, 18);
+        assert_line_valid(line);
 
         bb::clear(&self.rtsr, line);
         bb::clear(&self.ftsr, line);
         bb::clear(&self.imr, line);
     }
 
     fn pend_interrupt(&self, line: u8) {
-        assert!(line <= 22);
-        assert_ne!(line, 18);
+        assert_line_valid(line);
 
         bb::set(&self.swier, line);
     }
@@ -140,8 +137,7 @@ impl ExtiExt for EXTI {
     }
 
     fn clear_irq(&self, line: u8) {
-        assert!(line <= 22);
-        assert_ne!(line, 18);
+        assert_line_valid(line);
 
         self.pr.modify(|_, w| unsafe { w.bits(0b1 << line) });
     }
@@ -161,7 +157,14 @@ impl ExtiExt for EXTI {
             0..=1 => pac::Interrupt::EXTI0_1,
             2..=3 => pac::Interrupt::EXTI2_3,
             4..=15 => pac::Interrupt::EXTI4_15,
-            20 => pac::Interrupt::RTC,
+            16 => pac::Interrupt::PVD,
+            17 | 19 | 20 => pac::Interrupt::RTC,  // also LSE CSS
+            21 | 22 => pac::Interrupt::ADC_COMP,
+            23 => pac::Interrupt::I2C1,
+            25 => pac::Interrupt::USART1,
+            26 => pac::Interrupt::USART2,
+            28 => pac::Interrupt::AES_RNG_LPUART1,
+            29 => pac::Interrupt::LPTIM1,
             line => panic!("Line {} not supported", line),
         };
 
@@ -178,3 +181,12 @@ impl ExtiExt for EXTI {
         });
     }
 }
+
+fn assert_line_valid(line: u8) {
+    assert!(line <= 29);
+    assert_ne!(line, 27);
+
+    // Line 18 is used by the USB peripheral. On the l0x1, it is reserved.
+    #[cfg(feature = "stm32l0x1")]
+    assert_ne!(line, 18);
+}

src/lib.rs

@@ -1,4 +1,4 @@
-#![no_std]
+#![cfg_attr(not(test), no_std)]
 #![allow(non_camel_case_types)]
 
 #[cfg(not(any(feature = "stm32l0x1", feature = "stm32l0x2", feature = "stm32l0x3")))]
@@ -27,6 +27,7 @@ pub mod dma;
 pub mod exti;
 pub mod gpio;
 pub mod i2c;
+pub mod lptim;
 pub mod prelude;
 pub mod pwm;
 pub mod pwr;