HRTIM - Fix bugs in capture module with get_signed and some restructurings

Author: usbalbin

src/hrtim/adc_trigger.rs

@@ -16,5 +16,8 @@ pub trait Adc6810Trigger {
     const BITS: u32;
 }
 
+/// Handle to timers reset/roll-over event
 pub struct TimerReset<T>(pub(crate) PhantomData<T>);
+
+/// Handle to timers period event
 pub struct TimerPeriod<T>(pub(crate) PhantomData<T>);

src/hrtim/capture.rs

@@ -31,8 +31,72 @@ pub trait CaptureEvent<TIM, PSCL> {
     const BITS: u32;
 }
 
+/// Trait for capture channels used for capturing edges
+///
+/// ```
+/// let capture: HrCapt<_, _, _> = todo!();
+/// if capture.is_pending() {
+///     let (value, dir) = capture.get_last();
+///     capture.clear_interrupt();
+///     defmt::info!("Edge captured at counter value: {}, with: {}", value, dir);
+/// }
+/// ```
+///
+/// or alternatively
+///
+/// ```
+/// let capture: HrCapt<_, _, _> = todo!();
+/// if let Some((value, dir)) = capture.get() {
+///     defmt::info!("Edge captured at counter value: {}, with: {}", value, dir);
+/// }
+/// ```
 pub trait HrCapture {
-    fn get(&self) -> (u16, CountingDirection);
+    /// Try to get the capture value
+    ///
+    /// Returns none if edge has been captured since last time
+    ///
+    /// NOTE: This function will use [`Self::is_pending`] to chech if there is a value available and
+    /// [`Self::clear_interrupt`] to clear it.
+    fn get(&mut self) -> Option<(u16, CountingDirection)> {
+        if self.is_pending() {
+            let value = self.get_last();
+            self.clear_interrupt();
+            Some(value)
+        } else {
+            None
+        }
+    }
+
+    /// Get number of ticks relative to beginning of upcounting
+    ///
+    /// where captures during down counting count as negative (before the upcount)
+    ///
+    /// ```txt
+    ///              Counter
+    /// ----------------------------------   <--- period
+    /// \               ^               /
+    ///    \            |            /
+    ///       \         |         /
+    ///          \      |      /
+    /// Down count  \   |   /   Up count
+    ///                \|/
+    /// <-------------- 0 --------------> t
+    /// Negative result | positive result
+    /// ```
+    ///
+    /// NOTE: This function will use [`Self::is_pending`] to chech if there is a value available and
+    /// [`Self::clear_interrupt`] to clear it.
+    fn get_signed(&mut self, period: u16) -> Option<i32> {
+        if self.is_pending() {
+            let value = self.get_last_signed(period);
+            self.clear_interrupt();
+            Some(value)
+        } else {
+            None
+        }
+    }
+
+    fn get_last(&self) -> (u16, CountingDirection);
 
     /// Get number of ticks relative to beginning of upcounting
     ///
@@ -50,12 +114,13 @@ pub trait HrCapture {
     /// <-------------- 0 --------------> t
     /// Negative result | positive result
     /// ````
-    fn get_signed(&self, period: u16) -> i32 {
-        let (value, dir) = self.get();
+    fn get_last_signed(&self, period: u16) -> i32 {
+        let (value, dir) = self.get_last();
 
+        // The capture counter always counts up and restarts at period
         match dir {
             CountingDirection::Up => i32::from(value),
-            CountingDirection::Down => i32::from(period) - i32::from(value),
+            CountingDirection::Down => i32::from(value) - i32::from(period),
         }
     }
 
@@ -75,9 +140,10 @@ pub fn dma_value_to_dir_and_value(x: u32) -> (u16, CountingDirection) {
 pub fn dma_value_to_signed(x: u32, period: u16) -> i32 {
     let (value, dir) = dma_value_to_dir_and_value(x);
 
+    // The capture counter always counts up and restarts at period
     match dir {
         CountingDirection::Up => i32::from(value),
-        CountingDirection::Down => i32::from(period) - i32::from(value),
+        CountingDirection::Down => i32::from(value) - i32::from(period),
     }
 }
 
@@ -135,7 +201,7 @@ macro_rules! impl_capture {
         }
 
         impl<PSCL, DMA> HrCapture for HrCapt<$TIMX, PSCL, $CH, DMA> {
-            fn get(&self) -> (u16, CountingDirection) {
+            fn get_last(&self) -> (u16, CountingDirection) {
                 let tim = unsafe { &*$TIMX::ptr() };
                 let data = tim.$cptXYr.read();
 

src/hrtim/timer.rs

@@ -4,7 +4,7 @@ use crate::stm32::{
 use core::marker::PhantomData;
 
 use super::{
-    capture::{self, HrCapt},
+    capture::{self, HrCapt, HrCapture},
     control::HrPwmControl,
     HrtimPrescaler,
 };
@@ -52,16 +52,16 @@ pub trait HrTimer {
 
     fn clear_repetition_interrupt(&mut self);
 
-    /// Make a handle to this timers reset event to use as adc trigger
+    /// Make a handle to this timers reset/roll-over event to use as adc trigger
     fn as_reset_adc_trigger(&self) -> super::adc_trigger::TimerReset<Self::Timer>;
 
     /// Make a handle to this timers period event to use as adc trigger
     fn as_period_adc_trigger(&self) -> super::adc_trigger::TimerPeriod<Self::Timer>;
 }
 
 pub trait HrSlaveTimer: HrTimer {
-    type CaptureCh1;
-    type CaptureCh2;
+    type CptCh1;
+    type CptCh2;
 
     /// Start listening to the specified event
     fn enable_reset_event<E: super::event::TimerResetEventSource<Self::Timer, Self::Prescaler>>(
@@ -78,8 +78,11 @@ pub trait HrSlaveTimer: HrTimer {
 
 /// Trait for unsplit slave timer which still contains its capture modules
 pub trait HrSlaveTimerCpt: HrSlaveTimer {
-    fn capture_ch1(&mut self) -> &mut <Self as HrSlaveTimer>::CaptureCh1;
-    fn capture_ch2(&mut self) -> &mut <Self as HrSlaveTimer>::CaptureCh2;
+    type CaptureCh1: HrCapture;
+    type CaptureCh2: HrCapture;
+
+    fn capture_ch1(&mut self) -> &mut <Self as HrSlaveTimerCpt>::CaptureCh1;
+    fn capture_ch2(&mut self) -> &mut <Self as HrSlaveTimerCpt>::CaptureCh2;
     fn split_capture(
         self,
     ) -> (
@@ -179,8 +182,8 @@ macro_rules! hrtim_timer {
 
         $(
             impl<PSCL: HrtimPrescaler, CPT1, CPT2> HrSlaveTimer for HrTim<$TIMX, PSCL, CPT1, CPT2> {
-                type CaptureCh1 = HrCapt<Self::Timer, Self::Prescaler, capture::Ch1, capture::NoDma>;
-                type CaptureCh2 = HrCapt<Self::Timer, Self::Prescaler, capture::Ch2, capture::NoDma>;
+                type CptCh1 = HrCapt<Self::Timer, Self::Prescaler, capture::Ch1, capture::NoDma>;
+                type CptCh2 = HrCapt<Self::Timer, Self::Prescaler, capture::Ch2, capture::NoDma>;
 
                 /// Reset this timer every time the specified event occurs
                 ///
@@ -212,6 +215,9 @@ macro_rules! hrtim_timer {
             }
 
             impl<PSCL: HrtimPrescaler> HrSlaveTimerCpt for HrTim<$TIMX, PSCL, HrCapt<$TIMX, PSCL, capture::Ch1, capture::NoDma>, HrCapt<$TIMX, PSCL, capture::Ch2, capture::NoDma>> {
+                type CaptureCh1 = <Self as HrSlaveTimer>::CptCh1;
+                type CaptureCh2 = <Self as HrSlaveTimer>::CptCh2;
+
                 /// Access the timers first capture channel
                 fn capture_ch1(&mut self) -> &mut Self::CaptureCh1 {
                     &mut self.capture_ch1