Merge branch 'ref/monotonic' into 'master'

atsamv71_xult: use Monotonic timers instead of asm::delay

Closes atsams-rs#21

See merge request embedded-rust/atsamx7x-hal!12

Author: tmplt

boards/atsamv71_xult/Cargo.toml

@@ -14,6 +14,7 @@ panic-rtt-target = { version = "0.1.2", features = ["cortex-m"] }
 rtt-target = { version = "0.3.1", features = ["cortex-m"] }
 heapless = "0.7"
 usbd-serial = "0.1.1"
+dwt-systick-monotonic = "1"
 
 [dependencies.atsamx7x-hal]
 version = "0.1.0"

boards/atsamv71_xult/examples/blinky.rs

@@ -4,13 +4,20 @@
 
 use panic_rtt_target as _;
 
-#[rtic::app(device = hal::target_device, peripherals = true)]
+#[rtic::app(device = hal::target_device, peripherals = true, dispatchers = [UART0])]
 mod app {
     use atsamx7x_hal as hal;
+    use dwt_systick_monotonic::{DwtSystick, ExtU32};
+    use hal::efc::*;
     use hal::ehal::digital::v2::ToggleableOutputPin;
+    use hal::fugit::RateExtU32;
     use hal::pio::*;
+    use hal::pmc::*;
     use rtt_target::{rprintln, rtt_init_print};
 
+    #[monotonic(binds = SysTick, default = true)]
+    type Mono = DwtSystick<12_000_000>;
+
     #[shared]
     struct Shared {}
 
@@ -20,26 +27,43 @@ mod app {
     }
 
     #[init]
-    fn init(ctx: init::Context) -> (Shared, Local, init::Monotonics) {
+    fn init(mut ctx: init::Context) -> (Shared, Local, init::Monotonics) {
         rtt_init_print!();
-        rprintln!("init");
 
-        // Disable the watchdog.
-        let wd = hal::watchdog::Watchdog::new(ctx.device.WDT).disable();
+        let mut pmc = Pmc::new(ctx.device.PMC, &ctx.device.WDT.into());
+        let mainck = pmc
+            .get_mainck(MainCkSource::ExternalNormal(12.MHz()))
+            .unwrap();
+        let (hclk, _mck) = pmc
+            .get_hclk(
+                HostClockConfig {
+                    pres: MckPrescaler::CLK_1,
+                    div: MckDivider::EQ_PCK,
+                },
+                &mainck,
+                &mut Efc::new(ctx.device.EFC, VddioLevel::V3),
+            )
+            .unwrap();
+
+        let mono = DwtSystick::new(
+            &mut ctx.core.DCB,
+            ctx.core.DWT,
+            ctx.core.SYST,
+            hclk.systick_freq().to_Hz(),
+        );
 
-        let mut pmc = hal::pmc::Pmc::new(ctx.device.PMC, &wd);
         let banka = hal::pio::BankA::new(ctx.device.PIOA, &mut pmc, BankConfiguration::default());
         let led = banka.pa23.into_output();
 
-        (Shared {}, Local { led }, init::Monotonics())
+        toggle_led::spawn().unwrap();
+
+        (Shared {}, Local { led }, init::Monotonics(mono))
     }
 
-    #[idle(local = [led])]
-    fn idle(ctx: idle::Context) -> ! {
-        loop {
-            ctx.local.led.toggle().unwrap();
-            rprintln!("LED0 toggled");
-            cortex_m::asm::delay(12_000_000);
-        }
+    #[task(local = [led])]
+    fn toggle_led(ctx: toggle_led::Context) {
+        ctx.local.led.toggle().unwrap();
+        rprintln!("LED0 toggled");
+        toggle_led::spawn_after(1.secs()).unwrap();
     }
 }

boards/atsamv71_xult/examples/periodic_adc_sample.rs

@@ -4,16 +4,20 @@
 
 use panic_rtt_target as _;
 
-#[rtic::app(device = hal::target_device, peripherals = true)]
+#[rtic::app(device = hal::target_device, peripherals = true, dispatchers = [UART0])]
 mod app {
     use atsamx7x_hal as hal;
+    use dwt_systick_monotonic::{DwtSystick, ExtU32};
     use hal::afec::*;
     use hal::efc::*;
     use hal::ehal::adc::OneShot;
     use hal::pio::*;
     use hal::pmc::*;
     use rtt_target::{rprintln, rtt_init_print};
 
+    #[monotonic(binds = SysTick, default = true)]
+    type Mono = DwtSystick<12_000_000>;
+
     #[shared]
     struct Shared {}
 
@@ -24,7 +28,7 @@ mod app {
     }
 
     #[init]
-    fn init(ctx: init::Context) -> (Shared, Local, init::Monotonics) {
+    fn init(mut ctx: init::Context) -> (Shared, Local, init::Monotonics) {
         rtt_init_print!();
         rprintln!("init");
 
@@ -34,7 +38,7 @@ mod app {
         let mainck = pmc
             .get_mainck(MainCkSource::InternalRC(MainRcFreq::_12_MHZ))
             .unwrap();
-        let (_, mck) = pmc
+        let (hclk, mck) = pmc
             .get_hclk(
                 HostClockConfig {
                     pres: MckPrescaler::CLK_1,
@@ -45,20 +49,29 @@ mod app {
             )
             .unwrap();
 
+        let mono = DwtSystick::new(
+            &mut ctx.core.DCB,
+            ctx.core.DWT,
+            ctx.core.SYST,
+            hclk.systick_freq().to_Hz(),
+        );
+
         let banka = hal::pio::BankA::new(ctx.device.PIOA, &mut pmc, BankConfiguration::default());
         let afec = Afec::new_afec0(ctx.device.AFEC0, &mut pmc, &mck).unwrap();
         let pin = banka.pa17.into_input(PullDir::PullUp);
 
-        (Shared {}, Local { afec, pin }, init::Monotonics())
+        adc_sample::spawn().unwrap();
+
+        (Shared {}, Local { afec, pin }, init::Monotonics(mono))
     }
 
-    #[idle(local = [afec, pin])]
-    fn idle(ctx: idle::Context) -> ! {
-        let idle::LocalResources { afec, pin } = ctx.local;
-        loop {
-            let v: f32 = afec.read(pin).unwrap();
-            rprintln!("PA17 (channel 6) = {:.2}V", v);
-            cortex_m::asm::delay(12_000_000);
-        }
+    #[task(local = [afec, pin])]
+    fn adc_sample(ctx: adc_sample::Context) {
+        let adc_sample::LocalResources { afec, pin } = ctx.local;
+
+        let v: f32 = afec.read(pin).unwrap();
+        rprintln!("PA17 (channel 6) = {:.2}V", v);
+
+        adc_sample::spawn_after(1.secs()).unwrap();
     }
 }

hal/src/pmc.rs

@@ -206,7 +206,21 @@ impl HostClock {
 }
 
 /// HCLK token
-pub struct ProcessorClock {}
+pub struct ProcessorClock {
+    freq: Hertz,
+}
+
+impl ProcessorClock {
+    pub fn freq(&self) -> Hertz {
+        self.freq
+    }
+
+    pub fn systick_freq(&self) -> Hertz {
+        // §31.3 would suggest that SysTick is HCLK/2, but experiments
+        // show that it is equal to HCLK.
+        self.freq
+    }
+}
 
 pub trait PckId {
     const ID: u8;
@@ -626,7 +640,9 @@ impl Pmc {
         }
 
         Ok((
-            ProcessorClock {},
+            ProcessorClock {
+                freq: freq / pres.value(),
+            },
             HostClock {
                 freq: freq / pres.value() / div.value(),
             },