Use timer in adc example

Author: Sh3Rm4n

examples/adc.rs

@@ -6,13 +6,35 @@
 use defmt_rtt as _;
 use panic_probe as _;
 
-use defmt;
+use core::cell::RefCell;
 
 use cortex_m::asm;
+use cortex_m::interrupt::Mutex;
 use cortex_m_rt::entry;
 
 use embedded_hal::adc::OneShot;
-use stm32f3xx_hal::{adc, pac, prelude::*};
+use stm32f3xx_hal::{
+    adc,
+    pac::{self, interrupt},
+    prelude::*,
+    timer,
+};
+
+/// That's a mouthful, so explain it:
+///
+/// 1. Wrap the Timer in a Mutex, so it can be safely shared between
+///    main loop and interrupt or rather used in functions, which could theoretically
+///    be preempted.
+/// 2. Wrap the Timer in a RefCell to be able obtain a mutable reference to the Timer itself.
+///    E.g. the interrupt can't take ownership of the timer, it is shared between main-loop and
+///    interrupt context.
+/// 3. Wrap the Timer in an Option, so that it can be "lazily initialized". Statics have to be
+///    initialized with const values, which the timer itself is obviously not, but None is.
+///
+/// This could all be done just with a static mut && unsafe as
+/// the usecase it pretty clear, but this is to show the definitely safe
+/// alternative.
+static TIMER: Mutex<RefCell<Option<timer::Timer<pac::TIM2>>>> = Mutex::new(RefCell::new(None));
 
 #[entry]
 fn main() -> ! {
@@ -21,12 +43,26 @@ fn main() -> ! {
     let mut rcc = dp.RCC.constrain();
     let clocks = rcc.cfgr.freeze(&mut dp.FLASH.constrain().acr);
 
+    // This is a workaround, so that the debugger will not disconnect imidiatly on asm::wfi();
+    // https://github.com/probe-rs/probe-rs/issues/350#issuecomment-740550519
+    dp.DBGMCU.cr.modify(|_, w| {
+        w.dbg_sleep().set_bit();
+        w.dbg_standby().set_bit();
+        w.dbg_stop().set_bit()
+    });
+
+    // Create a Common ADC instance, which is shared between ADC1 and ADC2 in this case,
+    // and for example is in control of the clock of both of these peripherals.
     let mut adc_common = adc::CommonAdc::new(dp.ADC1_2, &clocks, &mut rcc.ahb);
 
+    // We have to pack these peripherals in a tuple, so that `TemperatureSensor` can
+    // get a mutable reference to both of these as a singular argument.
+    //
+    // This is needed, as both ADC1 and ADC2 have to be of to enable the `TemperatureSensor`.
     let mut tuple = (dp.ADC1, dp.ADC2);
     let mut ts = adc::TemperatureSensor::new(&mut adc_common, &mut tuple);
 
-    // set up adc1
+    // Set up ADC1
     let mut adc = adc::Adc::new(
         tuple.0, // The ADC we are going to control
         adc::config::Config::default(),
@@ -54,6 +90,19 @@ fn main() -> ! {
     let mut gpioa = dp.GPIOA.split(&mut rcc.ahb);
     let mut analog_pin = gpioa.pa0.into_analog(&mut gpioa.moder, &mut gpioa.pupdr);
 
+    let mut timer = timer::Timer::new(dp.TIM2, clocks, &mut rcc.apb1);
+
+    unsafe {
+        cortex_m::peripheral::NVIC::unmask(timer.interrupt());
+    }
+    timer.enable_interrupt(timer::Event::Update);
+    // Start a timer which fires regularly to wake up from `asm::wfi`
+    timer.start(500.milliseconds());
+    // Put the timer in the global context.
+    cortex_m::interrupt::free(|cs| {
+        TIMER.borrow(cs).replace(Some(timer));
+    });
+
     // Be aware that the values in the table below depend on the input of VREF.
     // To have a stable VREF input, put a condensator and a volt limiting diode in front of it.
     //
@@ -77,8 +126,24 @@ fn main() -> ! {
         defmt::trace!("PA0 reads {}", adc_data);
         let adc_data: u16 = adc.read(&mut ts).unwrap();
         defmt::trace!("TemperatureSensor reads {}", adc_data);
-        asm::delay(2_000_000);
+        asm::wfi();
     }
 }
 
-// TODO: Add adc example, which uses Continuous or Discontinous and interrupts.
+#[interrupt]
+fn TIM2() {
+    // Just handle the pending interrupt event.
+    cortex_m::interrupt::free(|cs| {
+        TIMER
+            // Unlock resource for use in critical section
+            .borrow(cs)
+            // Get a mutable reference from the RefCell
+            .borrow_mut()
+            // Make the inner Option<T> -> Option<&mut T>
+            .as_mut()
+            // Unwrap the option, we know, that it has Some()!
+            .unwrap()
+            // Finally operate on the timer itself.
+            .clear_event(timer::Event::Update);
+    })
+}

src/timer.rs

@@ -3,8 +3,12 @@
 //! Abstractions of the internal timer peripherals
 //! The timer modules implements the [`CountDown`] and [`Periodic`] traits.
 //!
-//! [Read]: embedded_hal::timer::CountDown
-//! [Write]: embedded_hal::timer::Periodic
+//! ## Examples
+//!
+//! Check out [examples/adc.rs], where a [`Periodic`] timer is used to wake
+//! up the main-loop regularly.
+//!
+//! [examples/adc.rs]: https://github.com/stm32-rs/stm32f3xx-hal/blob/v0.8.1/examples/adc.rs
 
 use core::convert::{From, TryFrom};