Merge #439

439: inherent Pwm r=therealprof a=burrbull



Co-authored-by: Andrey Zgarbul <[email protected]>

Author: bors[bot]

CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Changed
 
+- Add inherent impl of `embedded_hal::Pwm` methods on `Pwm`s [#439]
 - Use `embedded-dma` v0.2 [#440]
 - Add LSI support for `Rtc` [#438]
 - Use `time` for `Rtc` instead of `rtcc`, add `rtc` example [#436]
@@ -45,6 +46,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 [#434]: https://github.com/stm32-rs/stm32f4xx-hal/pull/434
 [#436]: https://github.com/stm32-rs/stm32f4xx-hal/pull/436
 [#438]: https://github.com/stm32-rs/stm32f4xx-hal/pull/438
+[#439]: https://github.com/stm32-rs/stm32f4xx-hal/pull/439
 [#440]: https://github.com/stm32-rs/stm32f4xx-hal/pull/440
 
 ### Changed

src/fugit/hal_02.rs

@@ -1,4 +1,4 @@
-use super::{Counter, Delay, Error, Instance, SysCounter};
+use super::{Channel, Counter, Delay, Error, Instance, Pins, Pwm, SysCounter, WithPwm};
 
 use embedded_hal::blocking::delay::{DelayMs, DelayUs};
 use fugit::{ExtU32, MicrosDurationU32, TimerDurationU32};
@@ -86,3 +86,45 @@ impl Cancel for SysCounter {
         self.cancel()
     }
 }
+
+impl<TIM, P, PINS, const FREQ: u32> embedded_hal::Pwm for Pwm<TIM, P, PINS, FREQ>
+where
+    TIM: Instance + WithPwm,
+    PINS: Pins<TIM, P>,
+{
+    type Channel = Channel;
+    type Duty = u16;
+    type Time = TimerDurationU32<FREQ>;
+
+    fn enable(&mut self, channel: Self::Channel) {
+        self.enable(channel)
+    }
+
+    fn disable(&mut self, channel: Self::Channel) {
+        self.disable(channel)
+    }
+
+    fn get_duty(&self, channel: Self::Channel) -> Self::Duty {
+        self.get_duty(channel)
+    }
+
+    fn set_duty(&mut self, channel: Self::Channel, duty: Self::Duty) {
+        self.set_duty(channel, duty)
+    }
+
+    /// If `0` returned means max_duty is 2^16
+    fn get_max_duty(&self) -> Self::Duty {
+        self.get_max_duty()
+    }
+
+    fn get_period(&self) -> Self::Time {
+        self.get_period()
+    }
+
+    fn set_period<T>(&mut self, period: T)
+    where
+        T: Into<Self::Time>,
+    {
+        self.set_period(period.into())
+    }
+}

src/fugit/pwm.rs

@@ -135,44 +135,37 @@ impl<TIM: Instance + WithPwm, const FREQ: u32> Timer<TIM, FREQ> {
     }
 }
 
-impl<TIM, P, PINS, const FREQ: u32> embedded_hal::Pwm for Pwm<TIM, P, PINS, FREQ>
+impl<TIM, P, PINS, const FREQ: u32> Pwm<TIM, P, PINS, FREQ>
 where
     TIM: Instance + WithPwm,
     PINS: Pins<TIM, P>,
 {
-    type Channel = Channel;
-    type Duty = u16;
-    type Time = TimerDurationU32<FREQ>;
-
-    fn enable(&mut self, channel: Self::Channel) {
+    pub fn enable(&mut self, channel: Channel) {
         TIM::enable_channel(PINS::check_used(channel) as u8, true)
     }
 
-    fn disable(&mut self, channel: Self::Channel) {
+    pub fn disable(&mut self, channel: Channel) {
         TIM::enable_channel(PINS::check_used(channel) as u8, false)
     }
 
-    fn get_duty(&self, channel: Self::Channel) -> Self::Duty {
+    pub fn get_duty(&self, channel: Channel) -> u16 {
         TIM::read_cc_value(PINS::check_used(channel) as u8) as u16
     }
 
-    fn set_duty(&mut self, channel: Self::Channel, duty: Self::Duty) {
+    pub fn set_duty(&mut self, channel: Channel, duty: u16) {
         TIM::set_cc_value(PINS::check_used(channel) as u8, duty.into())
     }
 
     /// If `0` returned means max_duty is 2^16
-    fn get_max_duty(&self) -> Self::Duty {
+    pub fn get_max_duty(&self) -> u16 {
         (TIM::read_auto_reload() as u16).wrapping_add(1)
     }
 
-    fn get_period(&self) -> Self::Time {
-        Self::Time::from_ticks(TIM::read_auto_reload() + 1)
+    pub fn get_period(&self) -> TimerDurationU32<FREQ> {
+        TimerDurationU32::from_ticks(TIM::read_auto_reload() + 1)
     }
 
-    fn set_period<T>(&mut self, period: T)
-    where
-        T: Into<Self::Time>,
-    {
-        self.tim.set_auto_reload(period.into().ticks() - 1).unwrap();
+    pub fn set_period(&mut self, period: TimerDurationU32<FREQ>) {
+        self.tim.set_auto_reload(period.ticks() - 1).unwrap();
     }
 }

src/prelude.rs

@@ -51,7 +51,6 @@ pub use embedded_hal::watchdog::Watchdog as _embedded_hal_watchdog_Watchdog;
 pub use embedded_hal::watchdog::WatchdogDisable as _embedded_hal_watchdog_WatchdogDisable;
 pub use embedded_hal::watchdog::WatchdogEnable as _embedded_hal_watchdog_WatchdogEnable;
 pub use embedded_hal::Capture as _embedded_hal_Capture;
-pub use embedded_hal::Pwm as _embedded_hal_Pwm;
 pub use embedded_hal::Qei as _embedded_hal_Qei;
 pub use fugit::ExtU32 as _fugit_ExtU32;
 

src/pwm.rs

@@ -209,37 +209,33 @@ where
     }
 }
 
-impl<TIM, P, PINS> embedded_hal::Pwm for Pwm<TIM, P, PINS>
+impl<TIM, P, PINS> Pwm<TIM, P, PINS>
 where
     TIM: Instance + WithPwm,
     PINS: Pins<TIM, P>,
 {
-    type Channel = Channel;
-    type Duty = u16;
-    type Time = Hertz;
-
-    fn enable(&mut self, channel: Self::Channel) {
+    pub fn enable(&mut self, channel: Channel) {
         TIM::enable_channel(PINS::check_used(channel) as u8, true)
     }
 
-    fn disable(&mut self, channel: Self::Channel) {
+    pub fn disable(&mut self, channel: Channel) {
         TIM::enable_channel(PINS::check_used(channel) as u8, false)
     }
 
-    fn get_duty(&self, channel: Self::Channel) -> Self::Duty {
+    pub fn get_duty(&self, channel: Channel) -> u16 {
         TIM::read_cc_value(PINS::check_used(channel) as u8) as u16
     }
 
-    fn set_duty(&mut self, channel: Self::Channel, duty: Self::Duty) {
+    pub fn set_duty(&mut self, channel: Channel, duty: u16) {
         TIM::set_cc_value(PINS::check_used(channel) as u8, duty as u32)
     }
 
     /// If `0` returned means max_duty is 2^16
-    fn get_max_duty(&self) -> Self::Duty {
+    pub fn get_max_duty(&self) -> u16 {
         (TIM::read_auto_reload() as u16).wrapping_add(1)
     }
 
-    fn get_period(&self) -> Self::Time {
+    pub fn get_period(&self) -> Hertz {
         let clk = self.clk;
         let psc = self.tim.read_prescaler() as u32;
         let arr = TIM::read_auto_reload();
@@ -248,9 +244,9 @@ where
         (clk.0 / (psc * arr)).hz()
     }
 
-    fn set_period<T>(&mut self, period: T)
+    pub fn set_period<T>(&mut self, period: T)
     where
-        T: Into<Self::Time>,
+        T: Into<Hertz>,
     {
         let clk = self.clk;
 
@@ -259,3 +255,45 @@ where
         self.tim.set_auto_reload(arr).unwrap();
     }
 }
+
+impl<TIM, P, PINS> embedded_hal::Pwm for Pwm<TIM, P, PINS>
+where
+    TIM: Instance + WithPwm,
+    PINS: Pins<TIM, P>,
+{
+    type Channel = Channel;
+    type Duty = u16;
+    type Time = Hertz;
+
+    fn enable(&mut self, channel: Self::Channel) {
+        self.enable(channel)
+    }
+
+    fn disable(&mut self, channel: Self::Channel) {
+        self.disable(channel)
+    }
+
+    fn get_duty(&self, channel: Self::Channel) -> Self::Duty {
+        self.get_duty(channel)
+    }
+
+    fn set_duty(&mut self, channel: Self::Channel, duty: Self::Duty) {
+        self.set_duty(channel, duty)
+    }
+
+    /// If `0` returned means max_duty is 2^16
+    fn get_max_duty(&self) -> Self::Duty {
+        self.get_max_duty()
+    }
+
+    fn get_period(&self) -> Self::Time {
+        self.get_period()
+    }
+
+    fn set_period<T>(&mut self, period: T)
+    where
+        T: Into<Self::Time>,
+    {
+        self.set_period(period)
+    }
+}