Add systick timeout implement

Author: JalonWong

examples/f103c8/src/led_task.rs

@@ -1,25 +1,19 @@
 use crate::embedded_hal::digital::StatefulOutputPin;
+use crate::hal::os::TimeoutInstance;
 
-pub struct LedTask<P> {
+pub struct LedTask<P, T> {
     led: P,
-    freq: u32,
-    count: u32,
+    timeout: T,
 }
 
-impl<P: StatefulOutputPin> LedTask<P> {
-    pub fn new(led: P, freq: u32) -> Self {
-        Self {
-            led,
-            freq,
-            count: 0,
-        }
+impl<P: StatefulOutputPin, T: TimeoutInstance> LedTask<P, T> {
+    pub fn new(led: P, timeout: T) -> Self {
+        Self { led, timeout }
     }
 
     pub fn poll(&mut self) {
-        self.count += 1;
-        if self.count >= self.freq {
+        if self.timeout.timeout() {
             self.led.toggle().ok();
-            self.count = 0;
         }
     }
 }

examples/f103c8/src/main.rs

@@ -15,11 +15,11 @@ use stm32f1_hal::{
     embedded_io,
     gpio::{Edge, ExtiPin, PinState},
     nvic_scb::PriorityGrouping,
-    os::RetryTimes,
+    os::{RetryTimes, Timeout},
     pac::{self, Interrupt},
     prelude::*,
     rcc,
-    timer::*,
+    timer::{syst::SysTickTimeout, *},
     uart::{self, UartPeriphExt},
 };
 
@@ -105,10 +105,9 @@ fn main() -> ! {
     let mut led = gpiob
         .pb0
         .into_open_drain_output_with_state(&mut gpiob.crl, PinState::High);
-    let mut timer = cp.SYST.counter_hz(&mcu);
-    let freq = 100.Hz();
-    timer.start(freq).unwrap();
-    let mut led_task = LedTask::new(led, freq.raw());
+    cp.SYST.counter_hz(&mcu).start(1000.Hz()).unwrap();
+    let mut timeout = SysTickTimeout::new(1000_000);
+    let mut led_task = LedTask::new(led, timeout.start());
 
     // PWM --------------------------------------
 
@@ -140,9 +139,7 @@ fn main() -> ! {
     });
 
     loop {
-        if timer.wait().is_ok() {
-            led_task.poll();
-        }
+        led_task.poll();
         uart_task.poll();
     }
 }

src/common/os.rs

@@ -19,9 +19,12 @@ pub trait Timeout {
 
 pub trait TimeoutInstance {
     fn timeout(&mut self) -> bool;
+    fn restart(&mut self);
     fn interval(&self);
 }
 
+// Retry ----------------------------------
+
 pub struct RetryTimes {
     retry_times: usize,
 }
@@ -55,6 +58,40 @@ impl TimeoutInstance for RetryTimesInstance {
         }
     }
 
+    #[inline(always)]
+    fn restart(&mut self) {
+        self.count = 0;
+    }
+
+    #[inline(always)]
+    fn interval(&self) {}
+}
+
+// Always ----------------------------------
+
+pub struct AlwaysTimeout {}
+impl AlwaysTimeout {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+impl Timeout for AlwaysTimeout {
+    #[inline]
+    fn start(&mut self) -> impl TimeoutInstance {
+        AlwaysTimeoutInstance {}
+    }
+}
+
+pub struct AlwaysTimeoutInstance {}
+impl TimeoutInstance for AlwaysTimeoutInstance {
+    #[inline(always)]
+    fn timeout(&mut self) -> bool {
+        true
+    }
+
+    #[inline(always)]
+    fn restart(&mut self) {}
+
     #[inline(always)]
     fn interval(&self) {}
 }

src/timer/syst.rs

@@ -1,12 +1,38 @@
 //! SysTick: System Timer
 
 use super::*;
-use crate::{Mcu, time::Hertz};
+use crate::{Mcu, os::*, time::Hertz};
 use core::ops::{Deref, DerefMut};
 use cortex_m::peripheral::{SYST, syst::SystClkSource};
 use embedded_hal::delay::DelayNs;
 use fugit::{ExtU32Ceil, MicrosDurationU32, TimerDurationU32, TimerInstantU32};
 
+pub trait SysTimerInit: Sized {
+    /// Creates timer which takes [Hertz] as Duration
+    fn counter_hz(self, mcu: &Mcu) -> SysCounterHz;
+
+    /// Creates timer with custom precision (core frequency recommended is known)
+    fn counter<const FREQ: u32>(self, mcu: &Mcu) -> SysCounter<FREQ>;
+    /// Creates timer with precision of 1 μs (1 MHz sampling)
+    fn counter_us(self, mcu: &Mcu) -> SysCounterUs {
+        self.counter::<1_000_000>(mcu)
+    }
+    /// Blocking [Delay] with custom precision
+    fn delay(self, mcu: &Mcu) -> SysDelay;
+}
+
+impl SysTimerInit for SYST {
+    fn counter_hz(self, mcu: &Mcu) -> SysCounterHz {
+        SystemTimer::syst(self, mcu).counter_hz()
+    }
+    fn counter<const FREQ: u32>(self, mcu: &Mcu) -> SysCounter<FREQ> {
+        SystemTimer::syst(self, mcu).counter()
+    }
+    fn delay(self, mcu: &Mcu) -> SysDelay {
+        SystemTimer::syst_external(self, mcu).delay()
+    }
+}
+
 pub struct SystemTimer {
     pub(super) syst: SYST,
     pub(super) clk: Hertz,
@@ -56,32 +82,6 @@ impl SystemTimer {
     }
 }
 
-pub trait SysTimerInit: Sized {
-    /// Creates timer which takes [Hertz] as Duration
-    fn counter_hz(self, mcu: &Mcu) -> SysCounterHz;
-
-    /// Creates timer with custom precision (core frequency recommended is known)
-    fn counter<const FREQ: u32>(self, mcu: &Mcu) -> SysCounter<FREQ>;
-    /// Creates timer with precision of 1 μs (1 MHz sampling)
-    fn counter_us(self, mcu: &Mcu) -> SysCounterUs {
-        self.counter::<1_000_000>(mcu)
-    }
-    /// Blocking [Delay] with custom precision
-    fn delay(self, mcu: &Mcu) -> SysDelay;
-}
-
-impl SysTimerInit for SYST {
-    fn counter_hz(self, mcu: &Mcu) -> SysCounterHz {
-        SystemTimer::syst(self, mcu).counter_hz()
-    }
-    fn counter<const FREQ: u32>(self, mcu: &Mcu) -> SysCounter<FREQ> {
-        SystemTimer::syst(self, mcu).counter()
-    }
-    fn delay(self, mcu: &Mcu) -> SysDelay {
-        SystemTimer::syst_external(self, mcu).delay()
-    }
-}
-
 // Counter --------------------------------------------------------------------
 
 impl SystemTimer {
@@ -312,3 +312,80 @@ impl DelayNs for SysDelay {
         self.delay(ms.millis_at_least());
     }
 }
+
+// ----------------------------------------------------------------------------
+
+/// SysTick must be set to 1 kHz frequency
+pub struct SysTickTimeout {
+    timeout_us: usize,
+}
+impl SysTickTimeout {
+    pub fn new(timeout_us: usize) -> Self {
+        Self { timeout_us }
+    }
+}
+impl Timeout for SysTickTimeout {
+    fn start(&mut self) -> impl TimeoutInstance {
+        let now = SYST::get_current() as usize;
+        let reload = SYST::get_reload() as usize;
+        let round = self.timeout_us / 1000;
+        let us = self.timeout_us % 1000;
+
+        SysTickTimeoutInstance {
+            former_tick: now,
+            timeout_tick: us * reload / 1000,
+            elapsed_tick: 0,
+            round_backup: round,
+            round,
+        }
+    }
+}
+
+pub struct SysTickTimeoutInstance {
+    former_tick: usize,
+    timeout_tick: usize,
+    elapsed_tick: usize,
+    round: usize,
+    round_backup: usize,
+}
+impl SysTickTimeoutInstance {
+    fn elapsed(&mut self) -> usize {
+        let now = SYST::get_current() as usize;
+        let elapsed = if now <= self.former_tick {
+            self.former_tick - now
+        } else {
+            self.former_tick + (SYST::get_reload() as usize - now)
+        };
+        self.former_tick = now;
+        elapsed
+    }
+}
+impl TimeoutInstance for SysTickTimeoutInstance {
+    fn timeout(&mut self) -> bool {
+        self.elapsed_tick += self.elapsed();
+
+        if self.round == 0 {
+            if self.elapsed_tick >= self.timeout_tick {
+                self.elapsed_tick -= self.timeout_tick;
+                self.round = self.round_backup;
+                return true;
+            }
+        } else {
+            let reload = SYST::get_reload() as usize;
+            if self.elapsed_tick >= reload {
+                self.elapsed_tick -= reload;
+                self.round -= 1;
+            }
+        }
+        false
+    }
+
+    #[inline(always)]
+    fn restart(&mut self) {
+        self.round = self.round_backup;
+        self.elapsed_tick = 0;
+    }
+
+    #[inline(always)]
+    fn interval(&self) {}
+}