ext

Author: burrbull

.zed/settings.json

@@ -0,0 +1,15 @@
+{
+  "lsp": {
+    "rust-analyzer": {
+      "initialization_options": {
+        "cargo": {
+          "features": ["stm32g474"]
+        },
+        "check": {
+          "allTargets": false,
+          "targets": "thumbv7em-none-eabihf"
+        }
+      }
+    }
+  }
+}

Cargo.toml

@@ -4,10 +4,11 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-
 stm32f3 = { git = "https://github.com/stm32-rs/stm32-rs-nightlies", optional = true }
-stm32h7 = { git = "https://github.com/stm32-rs/stm32-rs-nightlies", fatures = ["critical-section"], optional = true }
-#stm32g4 = { git = "", optional = true }
+stm32h7 = { git = "https://github.com/stm32-rs/stm32-rs-nightlies", features = [
+    "critical-section",
+], optional = true }
+stm32g4 = { version = "0.21.1", package = "stm32g4-staging" }
 
 #stm32f3xx-hal = { version = "0.10.0", optional = true }
 stm32f3xx-hal = { git = "https://github.com/usbalbin/stm32f3xx-hal", branch = "update_for_new_pac", optional = true }
@@ -115,4 +116,4 @@ path = "examples/stm32g4/master.rs"
 [[example]]
 name = "stm32h7"
 required-features = ["stm32h7"]
-path = "examples/stm32h7/hrtim.rs"
+path = "examples/stm32h7/hrtim.rs"

src/capture.rs

@@ -1,19 +1,6 @@
-use crate::stm32;
-
-use super::timer;
-
-#[cfg(feature = "stm32g4")]
-use crate::hal::dma::PeripheralToMemory;
-#[cfg(feature = "stm32g4")]
-use crate::mcu::DmaMuxResources;
-
+use super::timer::{self, Ch1, Ch2, ChExt, InstanceX};
+use crate::ext::{Cptcr, MasterExt, TimExt};
 use core::marker::PhantomData;
-#[cfg(feature = "hrtim_v2")]
-use stm32::HRTIM_TIMF;
-use stm32::{HRTIM_TIMA, HRTIM_TIMB, HRTIM_TIMC, HRTIM_TIMD, HRTIM_TIME};
-
-pub struct Ch1;
-pub struct Ch2;
 
 pub struct Dma;
 pub struct NoDma;
@@ -168,121 +155,101 @@ pub fn dma_value_to_signed(x: u32, #[allow(unused_variables)] period: u16) -> i3
     }
 }
 
-macro_rules! impl_capture {
-    ($($TIMX:ident),+) => {$(
-        impl_capture!($TIMX: Ch1, cpt1r, cpt1cr, cpt1, cpt1ie, cpt1de, cpt1c);
-        impl_capture!($TIMX: Ch2, cpt2r, cpt2cr, cpt2, cpt2ie, cpt2de, cpt2c);
-    )+};
-
-    ($TIMX:ident: $CH:ident, $cptXr:ident, $cptXcr:ident, $cptX:ident, $cptXie:ident, $cptXde:ident, $cptXc:ident) => {
-        impl<PSCL> HrCapt<$TIMX, PSCL, $CH, NoDma> {
-            /// Add event to capture
-            ///
-            /// If multiple events are added, they will be ORed together meaning
-            /// that a capture will be trigger if any one of the events triggers
-            pub fn add_event<E: CaptureEvent<$TIMX, PSCL>>(&mut self, _event: &E) {
-                let tim = unsafe { &*$TIMX::ptr() };
-
-                // SAFETY: We are the only one with access to cptXYcr
-                unsafe {
-                    tim.$cptXcr().modify(|r, w| w.bits(r.bits() | E::BITS));
-                }
-            }
-
-            /// Remove event to capture
-            pub fn remove_event<E: CaptureEvent<$TIMX, PSCL>>(&mut self, _event: &E) {
-                let tim = unsafe { &*$TIMX::ptr() };
-
-                // SAFETY: We are the only one with access to cptXYcr
-                unsafe {
-                    tim.$cptXcr().modify(|r, w| w.bits(r.bits() & !E::BITS));
-                }
-            }
-
-            /// Force capture trigger now
-            pub fn trigger_now(&mut self) {
-                // SAFETY: We are the only one with access to cptXYcr
-                let tim = unsafe { &*$TIMX::ptr() };
-
-                tim.$cptXcr().modify(|_, w| w.swcpt().set_bit());
-            }
-
-            // TODO: It would be sufficient to instead of hr_control only require exclusive access to the owning timer
-            // however that would be hard to do since typically the capture device is a field of that same timer.
-            // Would it make more sense to have this method direcly on HrTim instead?
-            pub fn enable_interrupt(&mut self, enable: bool, _hr_control: &mut super::HrPwmControl) {
-                let tim = unsafe { &*$TIMX::ptr() };
-
-                tim.dier().modify(|_r, w| w.$cptXie().bit(enable));
-            }
-
-            pub fn enable_dma(self, _ch: timer::DmaChannel<$TIMX>) -> HrCapt<$TIMX, PSCL, $CH, Dma> {
-                // SAFETY: We own the only insance of this timers dma channel, no one else can do this
-                let tim = unsafe { &*$TIMX::ptr() };
-                tim.dier().modify(|_r, w| w.$cptXde().set_bit());
-                HrCapt {
-                    _x: PhantomData
-                }
-            }
+impl<TIM: InstanceX, CH: ChExt, PSCL> HrCapt<TIM, PSCL, CH, NoDma> {
+    /// Add event to capture
+    ///
+    /// If multiple events are added, they will be ORed together meaning
+    /// that a capture will be trigger if any one of the events triggers
+    pub fn add_event<E: CaptureEvent<TIM, PSCL>>(&mut self, _event: &E) {
+        let tim = unsafe { &*TIM::ptr() };
+
+        // SAFETY: We are the only one with access to cptXYcr
+        unsafe {
+            tim.cptcr(CH::CH).modify(|r, w| w.bits(r.bits() | E::BITS));
+        }
+    }
+
+    /// Remove event to capture
+    pub fn remove_event<E: CaptureEvent<TIM, PSCL>>(&mut self, _event: &E) {
+        let tim = unsafe { &*TIM::ptr() };
+
+        // SAFETY: We are the only one with access to cptXYcr
+        unsafe {
+            tim.cptcr(CH::CH).modify(|r, w| w.bits(r.bits() & !E::BITS));
         }
+    }
+
+    /// Force capture trigger now
+    pub fn trigger_now(&mut self) {
+        // SAFETY: We are the only one with access to cptXYcr
+        let tim = unsafe { &*TIM::ptr() };
+
+        tim.cptcr(CH::CH)
+            .modify(|_, w| <TIM::RB as TimExt>::CPT1CRrs::set_swcpt(w));
+    }
 
-        impl<PSCL, DMA> HrCapture for HrCapt<$TIMX, PSCL, $CH, DMA> {
-            fn get_last(&self) -> (u16, CountingDirection) {
-                let tim = unsafe { &*$TIMX::ptr() };
-                let data = tim.$cptXr().read();
+    // TODO: It would be sufficient to instead of hr_control only require exclusive access to the owning timer
+    // however that would be hard to do since typically the capture device is a field of that same timer.
+    // Would it make more sense to have this method direcly on HrTim instead?
+    pub fn enable_interrupt(&mut self, enable: bool, _hr_control: &mut super::HrPwmControl) {
+        let tim = unsafe { &*TIM::ptr() };
 
-                #[cfg(feature = "hrtim_v2")]
-                let dir = match data.dir().bit() {
-                    true => CountingDirection::Down,
-                    false => CountingDirection::Up,
-                };
-                #[cfg(any(feature = "hrtim_v1", feature = "hrtim_v1_1"))]
-                let dir = CountingDirection::Up;
+        tim.dier().modify(|_r, w| w.cptie(CH::CH as _).bit(enable));
+    }
 
-                let value = data.cpt().bits();
+    pub fn enable_dma(self, _ch: timer::DmaChannel<TIM>) -> HrCapt<TIM, PSCL, CH, Dma> {
+        // SAFETY: We own the only insance of this timers dma channel, no one else can do this
+        let tim = unsafe { &*TIM::ptr() };
+        tim.dier().modify(|_r, w| w.cptde(CH::CH as _).set_bit());
+        HrCapt { _x: PhantomData }
+    }
+}
 
-                (value, dir)
-            }
+impl<TIM: InstanceX, CH: ChExt, PSCL, DMA> HrCapture for HrCapt<TIM, PSCL, CH, DMA> {
+    fn get_last(&self) -> (u16, CountingDirection) {
+        let tim = unsafe { &*TIM::ptr() };
+        let data = tim.cptr(CH::CH).read();
 
-            fn clear_interrupt(&mut self) {
-                let tim = unsafe { &*$TIMX::ptr() };
+        #[cfg(feature = "hrtim_v2")]
+        let dir = match data.dir().bit() {
+            true => CountingDirection::Down,
+            false => CountingDirection::Up,
+        };
+        #[cfg(any(feature = "hrtim_v1", feature = "hrtim_v1_1"))]
+        let dir = CountingDirection::Up;
 
-                // No need for exclusive access since this is a write only register
-                tim.icr().write(|w| w.$cptXc().clear());
-            }
+        let value = data.cpt().bits();
 
-            fn is_pending(&self) -> bool {
-                let tim = unsafe { &*$TIMX::ptr() };
+        (value, dir)
+    }
 
-                // No need for exclusive access since this is a read only register
-                tim.isr().read().$cptX().bit()
-            }
-        }
+    fn clear_interrupt(&mut self) {
+        let tim = unsafe { &*TIM::ptr() };
 
-        #[cfg(feature = "stm32g4")]
-        unsafe impl<PSCL> crate::hal::dma::traits::TargetAddress<PeripheralToMemory> for HrCapt<$TIMX, PSCL, $CH, Dma> {
-            #[inline(always)]
-            fn address(&self) -> u32 {
-                let tim = unsafe { &*$TIMX::ptr() };
-                &tim.$cptXr() as *const _ as u32
-            }
+        // No need for exclusive access since this is a write only register
+        tim.icr().write(|w| w.cptc(CH::CH as _).clear());
+    }
 
-            type MemSize = u32;
+    fn is_pending(&self) -> bool {
+        let tim = unsafe { &*TIM::ptr() };
 
-            const REQUEST_LINE: Option<u8> = Some(DmaMuxResources::$TIMX as u8);
-        }
-    };
+        // No need for exclusive access since this is a read only register
+        tim.isr().read().cpt(CH::CH as _).bit()
+    }
 }
 
-impl_capture! {
-    HRTIM_TIMA,
-    HRTIM_TIMB,
-    HRTIM_TIMC,
-    HRTIM_TIMD,
-    HRTIM_TIME
-}
+#[cfg(feature = "stm32g4")]
+unsafe impl<TIM: InstanceX, CH: ChExt, PSCL>
+    crate::hal::dma::traits::TargetAddress<crate::hal::dma::PeripheralToMemory>
+    for HrCapt<TIM, PSCL, CH, Dma>
+{
+    #[inline(always)]
+    fn address(&self) -> u32 {
+        let tim = unsafe { &*TIM::ptr() };
+        &tim.cptr(CH::CH) as *const _ as u32
+    }
+
+    type MemSize = u32;
 
-#[cfg(feature = "hrtim_v2")]
-impl_capture! {
-    HRTIM_TIMF
+    const REQUEST_LINE: Option<u8> = Some(TIM::DMA_MUX as u8);
 }