Match embedded-hal api

embassy-stm32/src/timer/simple_pwm.rs

@@ -81,23 +81,45 @@ impl<'d, T: GeneralInstance4Channel> SimplePwmChannel<'d, T> {
     /// Get max duty value.
     ///
     /// This value depends on the configured frequency and the timer's clock rate from RCC.
-    pub fn get_max_duty(&self) -> u32 {
-        self.timer.get_max_compare_value() + 1
+    pub fn max_duty_cycle(&self) -> u16 {
+        unwrap!(self.timer.get_max_compare_value().checked_add(1))
     }
 
     /// Set the duty for a given channel.
     ///
-    /// The value ranges from 0 for 0% duty, to [`get_max_duty`](Self::get_max_duty) for 100% duty, both included.
-    pub fn set_duty(&mut self, duty: u32) {
-        assert!(duty <= self.get_max_duty());
-        self.timer.set_compare_value(self.channel, duty)
+    /// The value ranges from 0 for 0% duty, to [`max_duty_cycle`](Self::max_duty_cycle) for 100% duty, both included.
+    pub fn set_duty_cycle(&mut self, duty: u16) {
+        assert!(duty <= (*self).max_duty_cycle());
+        self.timer.set_compare_value(self.channel, duty.into())
+    }
+
+    fn set_duty_cycle_fully_off(&mut self) {
+        self.set_duty_cycle(0);
+    }
+
+    fn set_duty_cycle_fully_on(&mut self) {
+        self.set_duty_cycle((*self).max_duty_cycle());
+    }
+
+    fn set_duty_cycle_fraction(&mut self, num: u16, denom: u16) {
+        assert!(denom != 0);
+        assert!(num <= denom);
+        let duty = u32::from(num) * u32::from(self.max_duty_cycle()) / u32::from(denom);
+
+        // This is safe because we know that `num <= denom`, so `duty <= self.max_duty_cycle()` (u16)
+        #[allow(clippy::cast_possible_truncation)]
+        self.set_duty_cycle(duty as u16);
+    }
+
+    fn set_duty_cycle_percent(&mut self, percent: u8) {
+        self.set_duty_cycle_fraction(u16::from(percent), 100)
     }
 
     /// Get the duty for a given channel.
     ///
-    /// The value ranges from 0 for 0% duty, to [`get_max_duty`](Self::get_max_duty) for 100% duty, both included.
-    pub fn get_duty(&self) -> u32 {
-        self.timer.get_compare_value(self.channel)
+    /// The value ranges from 0 for 0% duty, to [`max_duty_cycle`](Self::max_duty_cycle) for 100% duty, both included.
+    pub fn get_duty(&self) -> u16 {
+        unwrap!(self.timer.get_compare_value(self.channel).try_into())
     }
 
     /// Set the output polarity for a given channel.
@@ -123,25 +145,6 @@ pub struct SimplePwmChannels<'d, T: GeneralInstance4Channel> {
     pub ch4: SimplePwmChannel<'d, T>,
 }
 
-impl<'d, T: GeneralInstance4Channel> embedded_hal_1::pwm::ErrorType for SimplePwmChannel<'d, T> {
-    type Error = core::convert::Infallible;
-}
-
-impl<'d, T: GeneralInstance4Channel> embedded_hal_1::pwm::SetDutyCycle for SimplePwmChannel<'d, T> {
-    fn max_duty_cycle(&self) -> u16 {
-        // TODO: panics if CCR is 0xFFFF
-        // TODO: rename get_max_duty to max_duty_cycle
-        unwrap!(self.get_max_duty().try_into())
-    }
-
-    fn set_duty_cycle(&mut self, duty: u16) -> Result<(), Self::Error> {
-        self.set_duty(duty.into());
-        Ok(())
-    }
-
-    // TODO: default methods?
-}
-
 /// Simple PWM driver.
 pub struct SimplePwm<'d, T: GeneralInstance4Channel> {
     inner: Timer<'d, T>,
@@ -253,6 +256,7 @@ impl<'d, T: GeneralInstance4Channel> SimplePwm<'d, T> {
     /// Note: when you call this, the max duty value changes, so you will have to
     /// call `set_duty` on all channels with the duty calculated based on the new max duty.
     pub fn set_frequency(&mut self, freq: Hertz) {
+        // TODO: prevent ARR = u16::MAX?
         let multiplier = if self.inner.get_counting_mode().is_center_aligned() {
             2u8
         } else {
@@ -264,8 +268,8 @@ impl<'d, T: GeneralInstance4Channel> SimplePwm<'d, T> {
     /// Get max duty value.
     ///
     /// This value depends on the configured frequency and the timer's clock rate from RCC.
-    pub fn get_max_duty(&self) -> u32 {
-        self.inner.get_max_compare_value() + 1
+    pub fn max_duty_cycle(&self) -> u16 {
+        unwrap!(self.inner.get_max_compare_value().checked_add(1))
     }
 
     /// Generate a sequence of PWM waveform
@@ -323,7 +327,7 @@ impl<'d, T: GeneralInstance4Channel> SimplePwm<'d, T> {
             self.channel(channel).disable();
         }
 
-        self.channel(channel).set_duty(original_duty_state);
+        self.channel(channel).set_duty_cycle(original_duty_state);
 
         // Since DMA is closed before timer update event trigger DMA is turn off,
         // this can almost always trigger a DMA FIFO error.
@@ -399,7 +403,7 @@ macro_rules! impl_waveform_chx {
                     self.channel(cc_channel).disable();
                 }
 
-                self.channel(cc_channel).set_duty(original_duty_state);
+                self.channel(cc_channel).set_duty_cycle(original_duty_state);
 
                 // Since DMA is closed before timer Capture Compare Event trigger DMA is turn off,
                 // this can almost always trigger a DMA FIFO error.
@@ -423,6 +427,41 @@ impl_waveform_chx!(waveform_ch2, Ch2Dma, Ch2);
 impl_waveform_chx!(waveform_ch3, Ch3Dma, Ch3);
 impl_waveform_chx!(waveform_ch4, Ch4Dma, Ch4);
 
+impl<'d, T: GeneralInstance4Channel> embedded_hal_1::pwm::ErrorType for SimplePwmChannel<'d, T> {
+    type Error = core::convert::Infallible;
+}
+
+impl<'d, T: GeneralInstance4Channel> embedded_hal_1::pwm::SetDutyCycle for SimplePwmChannel<'d, T> {
+    fn max_duty_cycle(&self) -> u16 {
+        self.max_duty_cycle()
+    }
+
+    fn set_duty_cycle(&mut self, duty: u16) -> Result<(), Self::Error> {
+        self.set_duty_cycle(duty);
+        Ok(())
+    }
+
+    fn set_duty_cycle_fully_off(&mut self) -> Result<(), Self::Error> {
+        self.set_duty_cycle_fully_off();
+        Ok(())
+    }
+
+    fn set_duty_cycle_fully_on(&mut self) -> Result<(), Self::Error> {
+        self.set_duty_cycle_fully_on();
+        Ok(())
+    }
+
+    fn set_duty_cycle_fraction(&mut self, num: u16, denom: u16) -> Result<(), Self::Error> {
+        self.set_duty_cycle_fraction(num, denom);
+        Ok(())
+    }
+
+    fn set_duty_cycle_percent(&mut self, percent: u8) -> Result<(), Self::Error> {
+        self.set_duty_cycle_percent(percent);
+        Ok(())
+    }
+}
+
 impl<'d, T: GeneralInstance4Channel> embedded_hal_02::Pwm for SimplePwm<'d, T> {
     type Channel = Channel;
     type Time = Hertz;
@@ -449,7 +488,7 @@ impl<'d, T: GeneralInstance4Channel> embedded_hal_02::Pwm for SimplePwm<'d, T> {
     }
 
     fn set_duty(&mut self, channel: Self::Channel, duty: Self::Duty) {
-        assert!(duty <= self.get_max_duty());
+        assert!(duty <= self.max_duty_cycle() as u32);
         self.inner.set_compare_value(channel, duty)
     }