alternative to stm32-rs#176

Author: burrbull

src/pwm.rs

@@ -72,6 +72,7 @@ use crate::afio::MAPR;
 use crate::bb;
 use crate::gpio::{self, Alternate, PushPull};
 use crate::time::Hertz;
+use crate::time::U32Ext;
 use crate::timer::Timer;
 
 pub trait Pins<REMAP, P> {
@@ -93,7 +94,7 @@ macro_rules! pins_impl {
                 $($PINX: $TRAIT<REMAP> + gpio::Mode<Alternate<PushPull>>,)+
             {
                 $(const $ENCHX: bool = true;)+
-                type Channels = ($(Pwm<TIM, $ENCHX>),+);
+                type Channels = ($(PwmChannel<TIM, $ENCHX>),+);
             }
         )+
     };
@@ -128,7 +129,7 @@ impl Timer<TIM1> {
         _pins: PINS,
         mapr: &mut MAPR,
         freq: T,
-    ) -> PINS::Channels
+    ) -> Pwm<TIM1, REMAP, P, PINS>
     where
         REMAP: Remap<Periph = TIM1>,
         PINS: Pins<REMAP, P>,
@@ -147,7 +148,7 @@ impl Timer<TIM2> {
         _pins: PINS,
         mapr: &mut MAPR,
         freq: T,
-    ) -> PINS::Channels
+    ) -> Pwm<TIM2, REMAP, P, PINS>
     where
         REMAP: Remap<Periph = TIM2>,
         PINS: Pins<REMAP, P>,
@@ -166,7 +167,7 @@ impl Timer<TIM3> {
         _pins: PINS,
         mapr: &mut MAPR,
         freq: T,
-    ) -> PINS::Channels
+    ) -> Pwm<TIM3, REMAP, P, PINS>
     where
         REMAP: Remap<Periph = TIM3>,
         PINS: Pins<REMAP, P>,
@@ -186,7 +187,7 @@ impl Timer<TIM4> {
         _pins: PINS,
         mapr: &mut MAPR,
         freq: T,
-    ) -> PINS::Channels
+    ) -> Pwm<TIM4, REMAP, P, PINS>
     where
         REMAP: Remap<Periph = TIM4>,
         PINS: Pins<REMAP, P>,
@@ -199,7 +200,26 @@ impl Timer<TIM4> {
     }
 }
 
-pub struct Pwm<TIM, CHANNEL> {
+pub struct Pwm<TIM, REMAP, P, PINS>
+where
+    REMAP: Remap<Periph = TIM>,
+    PINS: Pins<REMAP, P>
+{
+    clk: Hertz,
+    _pins: PhantomData<(TIM, REMAP, P, PINS)>,
+}
+
+impl<TIM, REMAP, P, PINS> Pwm<TIM, REMAP, P, PINS>
+where
+    REMAP: Remap<Periph = TIM>,
+    PINS: Pins<REMAP, P>
+{
+    pub fn split() -> PINS::Channels {
+        unsafe { mem::MaybeUninit::uninit().assume_init() }
+    }
+}
+
+pub struct PwmChannel<TIM, CHANNEL> {
     _channel: PhantomData<CHANNEL>,
     _tim: PhantomData<TIM>,
 }
@@ -217,7 +237,7 @@ macro_rules! hal {
                 _pins: PINS,
                 freq: Hertz,
                 clk: Hertz,
-            ) -> PINS::Channels
+            ) -> Pwm<$TIMX, REMAP, P, PINS>
             where
                 REMAP: Remap<Periph = $TIMX>,
                 PINS: Pins<REMAP, P>,
@@ -258,10 +278,114 @@ macro_rules! hal {
                         .set_bit()
                 );
 
-                unsafe { mem::MaybeUninit::uninit().assume_init() }
+                Pwm {
+                    clk,
+                    _pins: PhantomData,
+                }
+            }
+
+            impl<REMAP, P, PINS> hal::Pwm for Pwm<$TIMX, REMAP, P, PINS> where
+                REMAP: Remap<Periph = $TIMX>,
+                PINS: Pins<REMAP, P>,
+            {
+                type Channel = u8;
+                type Duty = u16;
+                type Time = Hertz;
+
+                fn enable(&mut self, channel: Self::Channel) {
+                    if channel == 1 && PINS::C1 {
+                        unsafe { bb::set(&(*$TIMX::ptr()).ccer, 0) }
+                    }
+                    if channel == 2 && PINS::C2 {
+                        unsafe { bb::set(&(*$TIMX::ptr()).ccer, 4) }
+                    }
+                    if channel == 3 && PINS::C3 {
+                        unsafe { bb::set(&(*$TIMX::ptr()).ccer, 8) }
+                    }
+                    if channel == 4 && PINS::C4 {
+                        unsafe { bb::set(&(*$TIMX::ptr()).ccer, 12) }
+                    }
+                }
+
+                fn disable(&mut self, channel: Self::Channel) {
+                    if PINS::C1 {
+                        unsafe { bb::clear(&(*$TIMX::ptr()).ccer, 0) }
+                    }
+                    if PINS::C2 {
+                        unsafe { bb::clear(&(*$TIMX::ptr()).ccer, 4) }
+                    }
+                    if PINS::C3 {
+                        unsafe { bb::clear(&(*$TIMX::ptr()).ccer, 8) }
+                    }
+                    if PINS::C4 {
+                        unsafe { bb::clear(&(*$TIMX::ptr()).ccer, 12) }
+                    }
+                }
+
+                fn get_duty(&self, channel: Self::Channel) -> Self::Duty {
+                    if channel == 1 && PINS::C1 {
+                        unsafe { (*$TIMX::ptr()).ccr1.read().ccr().bits() }
+                    } else if channel == 2 && PINS::C2 {
+                        unsafe { (*$TIMX::ptr()).ccr2.read().ccr().bits() }
+                    } else if channel == 3 && PINS::C3 {
+                        unsafe { (*$TIMX::ptr()).ccr3.read().ccr().bits() }
+                    } else if channel == 4 && PINS::C4 {
+                        unsafe { (*$TIMX::ptr()).ccr4.read().ccr().bits() }
+                    } else {
+                        0
+                    }
+                }
+
+                fn set_duty(&mut self, channel: Self::Channel, duty: Self::Duty) {
+                    if PINS::C1 {
+                        unsafe { (*$TIMX::ptr()).ccr1.write(|w| w.ccr().bits(duty)) }
+                    }
+                    if PINS::C2 {
+                        unsafe { (*$TIMX::ptr()).ccr2.write(|w| w.ccr().bits(duty)) }
+                    }
+                    if PINS::C3 {
+                        unsafe { (*$TIMX::ptr()).ccr3.write(|w| w.ccr().bits(duty)) }
+                    }
+                    if PINS::C4 {
+                        unsafe { (*$TIMX::ptr()).ccr4.write(|w| w.ccr().bits(duty)) }
+                    }
+                }
+
+                fn get_max_duty(&self) -> Self::Duty {
+                    unsafe { (*$TIMX::ptr()).arr.read().arr().bits() }
+                }
+
+                fn get_period(&self) -> Self::Time {
+                    let clk = self.clk;
+                    let mut psc: u16 = 0;
+                    let mut arr: u16 = 0;
+                    unsafe {
+                        psc = (*$TIMX::ptr()).psc.read().psc().bits();
+                        arr = (*$TIMX::ptr()).arr.read().arr().bits();
+                    }
+
+                    // Length in ms of an internal clock pulse
+                    (clk.0 / u32(psc * arr)).hz()
+//                    (((psc as u32) / clk.0) * (1_000_000 as u32) * (arr as u32)).ms()
+                }
+
+                fn set_period<T>(&mut self, period: T) where
+                    T: Into<Self::Time> {
+                        let clk = self.clk;
+
+//                        let freq = u16(1 / period.into());
+
+                        let ticks = clk.0 / period.into().0;
+                        let psc = u16(ticks / (1 << 16)).unwrap();
+                        let arr = u16(ticks / u32(psc + 1)).unwrap();
+                        unsafe {
+                            (*$TIMX::ptr()).psc.write(|w| w.psc().bits(psc));
+                            (*$TIMX::ptr()).arr.write(|w| w.arr().bits(arr));
+                        }
+                }
             }
 
-            impl hal::PwmPin for Pwm<$TIMX, C1> {
+            impl hal::PwmPin for PwmChannel<$TIMX, C1> {
                 type Duty = u16;
 
                 fn disable(&mut self) {
@@ -285,7 +409,7 @@ macro_rules! hal {
                 }
             }
 
-            impl hal::PwmPin for Pwm<$TIMX, C2> {
+            impl hal::PwmPin for PwmChannel<$TIMX, C2> {
                 type Duty = u16;
 
                 fn disable(&mut self) {
@@ -309,7 +433,7 @@ macro_rules! hal {
                 }
             }
 
-            impl hal::PwmPin for Pwm<$TIMX, C3> {
+            impl hal::PwmPin for PwmChannel<$TIMX, C3> {
                 type Duty = u16;
 
                 fn disable(&mut self) {
@@ -333,7 +457,7 @@ macro_rules! hal {
                 }
             }
 
-            impl hal::PwmPin for Pwm<$TIMX, C4> {
+            impl hal::PwmPin for PwmChannel<$TIMX, C4> {
                 type Duty = u16;
 
                 fn disable(&mut self) {