even more eev hrtim

Author: usbalbin

src/hrtim/external_event.rs

@@ -227,22 +227,21 @@ where
     }
 }
 
-pub trait BuilderToEventSourceBuilder {
-    fn finalize<PSCL, TIM>(self, _calibrated: &mut HrTimCalibrated) -> ExternalEventSourceBuilder<TIM>;
+pub trait ToExternalEventSource {
+    fn finalize<PSCL, TIM>(self, _calibrated: &mut HrTimCalibrated) -> ExternalEventSource;
 }
 
-This is something every (timerX, eevY) pair should have....
-struct ExternalEventSourceBuilder<TIM> {
-    filter: u8,
-    is_latching: bool,
+#[derive(Copy, Clone)]
+struct ExternalEventMuxOut<const N: u8> {
+    _x: PhantomData<()>,
 }
 
 macro_rules! impl_eev1_5_to_es {
     ($eev:ident, $N:literal, $eeXsrc:ident, $eeXpol:ident, $eeXsns:ident, $eeXfast:ident) => {
         impl<const IS_FAST: bool> ExternalEventBuilder1To5 for SourceBuilder<$N, IS_FAST> {}
 
-        impl<const IS_FAST: bool> BuilderToEventSourceBuilder for SourceBuilder<$N, IS_FAST> {
-            fn finalize<PSCL, TIM>(self, _calibrated: &mut HrTimCalibrated) -> ExternalEventSourceBuilder {
+        impl<const IS_FAST: bool> ToExternalEventSource for SourceBuilder<$N, IS_FAST> {
+            fn finalize<PSCL, TIM>(self, _calibrated: &mut HrTimCalibrated) -> ExternalEventSource {
                 let SourceBuilder {
                     src_bits,
                     edge_or_polarity_bits,
@@ -277,7 +276,7 @@ macro_rules! impl_eev6_10_to_es {
     ($eev:ident, $N:literal, $eeXsrc:ident, $eeXpol:ident, $eeXsns:ident, $eeXf:ident) => {
         impl ExternalEventBuilder6To10 for SourceBuilder<$N, false> {}
 
-        impl ExternalEventToEventSource for SourceBuilder<$N, false> {
+        impl ToExternalEventSource for SourceBuilder<$N, false> {
             fn finalize<PSCL, TIM>(self, _calibrated: &mut HrTimCalibrated) -> ExternalEventSource {
                 let SourceBuilder {
                     src_bits,

src/hrtim/mod.rs

@@ -6,6 +6,7 @@ pub mod external_event;
 pub mod fault;
 pub mod output;
 pub mod timer;
+pub mod timer_eev_cfg;
 
 use core::marker::PhantomData;
 use core::mem::MaybeUninit;
@@ -195,6 +196,7 @@ pub struct HrPwmBuilder<TIM, PSCL, PS, OUT> {
     repetition_counter: u8,
     deadtime: Option<DeadtimeConfig>,
     enable_repetition_interrupt: bool,
+    eev_cfg: EevCfg,
     out1_polarity: Polarity,
     out2_polarity: Polarity,
 }
@@ -413,6 +415,7 @@ macro_rules! hrtim_common_methods {
                 repetition_counter,
                 deadtime,
                 enable_repetition_interrupt,
+                eev_cfg,
                 out1_polarity,
                 out2_polarity,
             } = self;
@@ -441,6 +444,7 @@ macro_rules! hrtim_common_methods {
                 repetition_counter,
                 deadtime,
                 enable_repetition_interrupt,
+                eev_cfg,
                 out1_polarity,
                 out2_polarity,
             }
@@ -479,6 +483,12 @@ macro_rules! hrtim_common_methods {
 
             self
         }
+
+        pub fn eev_cfg(mut self, eev_cfg: Stuff) -> Self {
+            self.eev_cfg = eev_cfg;
+
+            self
+        }
     };
 }
 
@@ -554,7 +564,10 @@ macro_rules! hrtim_hal {
                 OUT: ToHrOut,
             {
                 pub fn finalize(self, _control: &mut HrPwmControl) -> (HrTim<$TIMX, PSCL>, (HrCr1<$TIMX, PSCL>, HrCr2<$TIMX, PSCL>, HrCr3<$TIMX, PSCL>, HrCr4<$TIMX, PSCL>), OUT) {
-                    hrtim_finalize_body!(self, PreloadSource, $TIMX: ($timXcr, ck_pscx, $perXr, perx, $tXcen, $rep, $repx, $dier, $repie, $timXcr2, $fltXr, $outXr, $dtXr),)
+                    hrtim_finalize_body!(
+                        self, PreloadSource,
+                        $TIMX: ($timXcr, ck_pscx, $perXr, perx, $tXcen, $rep, $repx, $dier, $repie, $timXcr2, $fltXr, $outXr, $dtXr),
+                    )
                 }
 
                 hrtim_common_methods!($TIMX, PreloadSource);

src/hrtim/timer_eev_cfg.rs

@@ -0,0 +1,79 @@
+use core::marker::PhantomData;
+
+struct EevCfgs<TIM> {
+    eev1: EevCfg<TIM>,
+    eev2: EevCfg<TIM>,
+    eev3: EevCfg<TIM>,
+    eev4: EevCfg<TIM>,
+    eev5: EevCfg<TIM>,
+    eev6: EevCfg<TIM>,
+    eev7: EevCfg<TIM>,
+    eev8: EevCfg<TIM>,
+    eev9: EevCfg<TIM>,
+    eev10: EevCfg<TIM>,
+}
+
+#[derive(Default)]
+struct EevCfg<TIM> {
+    _x: PhantomData<TIM>,
+    filter_bits: u8,
+    latch_bit: u8,
+}
+
+impl<TIM> EevCfg<TIM> {
+    pub fn filter(mut self, stuff: u8) {
+        self.filter_bits = stuff;
+        self
+    }
+
+    /// NOTE: This can not be set if eev is in fast mode AND using a 
+    pub fn latching(mut self) -> Self {
+        self.latch_bit = true;
+        self
+    }
+}
+
+/// Note: Whenever a compare register is used for filtering, the value must be strictly above 0.
+pub enum EventFilter {
+    None = 0b0000,
+    
+    /// Blanking from reset/rollover to Cmp1
+    BlankingResetToCmp1 = 0b0001,
+    
+    /// This depends on counter mode:
+    /// * Up-counting mode: Blanking from reset/rollover to Cmp2
+    /// * Up-down mode: Blanking from Cmp1 to Cmp2(only during up counting)
+    BlankingResetToCmp2OrCmp1ToCmp2InUdm = 0b0010,
+
+    /// Blanking from reset/rollover to Cmp3
+    BlankingResetToCmp3 = 0b0011,
+
+    /// This depends on counter mode:
+    /// * Up-counting mode: Blanking from reset/rollover to Cmp4
+    /// * Up-down mode: Blanking from Cmp3 to Cmp4(only during up counting)
+    BlankingResetToCmp4OrCmp3ToCmp4InUdm = 0b0100,
+
+    BlankingSource1 = 0b0101,
+    BlankingSource2 = 0b0110,
+    BlankingSource3 = 0b0111,
+    BlankingSource4 = 0b1000,
+    BlankingSource5 = 0b1001,
+    BlankingSource6 = 0b1010,
+    BlankingSource7 = 0b1011,
+    BlankingSource8 = 0b1100,
+
+    /// This depends on counter mode:
+    /// * Up-counting mode: Windowing from reset/rollover to Cmp2
+    /// * Up-down mode: Windowing from Cmp2 to Cmp3(only during up counting)
+    WindowingResetToCmp2OrCmp2ToCmp3InUdm = 0b1101,
+
+    /// This depends on counter mode:
+    /// * Up-counting mode: Windowing from reset/rollover to Cmp3
+    /// * Up-down mode: Windowing from Cmp2 to Cmp3(only during down counting)
+    WindowingResetToCmp3OrCmp2ToCmp3InUdm = 0b1110,
+
+    Windowing from another timing unit: TIMWIN source (see Table 227 for details) in upcounting mode (UDM bit reset)
+In up-down counting mode (UDM bit set): windowing from compare 2 during the up-counting
+phase to compare 3 during the down-counting phase.
+    Windowing
+}