Reimplements simple PWM for some atmega MCUs

Author: dalpil

arduino-hal/src/lib.rs

@@ -112,6 +112,10 @@ pub use delay::{delay_ms, delay_us, Delay};
 
 #[cfg(feature = "board-selected")]
 pub mod port;
+
+#[cfg(feature = "board-selected")]
+pub mod simple_pwm;
+
 #[doc(no_inline)]
 #[cfg(feature = "board-selected")]
 pub use port::Pins;

arduino-hal/src/simple_pwm.rs

@@ -0,0 +1,10 @@
+//! Simple PWM output for supported Pins.
+//!
+//! This module implements simple (FastPWM) PWM output for supported Pins.
+//!
+//! Check the documentation for each of the TimerXPwm-structs for usage
+//! examples.
+
+pub use avr_hal_generic::simple_pwm::IntoPwmPin;
+pub use avr_hal_generic::simple_pwm::Prescaler;
+pub use atmega_hal::simple_pwm::*;

avr-hal-generic/src/lib.rs

@@ -22,7 +22,7 @@ pub mod usart;
 pub mod i2c;
 pub mod spi;
 pub mod adc;
-pub mod pwm;
+pub mod simple_pwm;
 pub mod wdt;
 
 /// Prelude containing all HAL traits

avr-hal-generic/src/port.rs

@@ -24,6 +24,12 @@ pub mod mode {
     impl Io for OpenDrain {}
     impl crate::Sealed for OpenDrain {}
 
+    pub struct PwmOutput<TC> {
+        pub(crate) _timer: PhantomData<TC>
+    }
+    impl<TC> super::PinMode for PwmOutput<TC> {}
+    impl<TC> crate::Sealed for PwmOutput<TC> {}
+
     pub trait InputMode: crate::Sealed {}
 
     /// Pin is configured as digital input (floating or pulled-up).

avr-hal-generic/src/pwm.rs renamed to avr-hal-generic/src/simple_pwm.rs

@@ -1,5 +1,10 @@
 //! PWM Implementation
 
+use core::marker::PhantomData;
+
+use crate::port::Pin;
+use crate::port::mode;
+
 /// Clock prescaler for PWM
 ///
 /// The prescaler dictates the PWM frequency, together with the IO clock.  The formula is as
@@ -31,15 +36,61 @@ pub enum Prescaler {
 }
 
 /// Implement traits and types for PWM timers
+pub trait PwmPinOps<TC> {
+    type Duty;
+
+    fn enable(&mut self);
+    fn disable(&mut self);
+    fn get_duty(&self) -> Self::Duty;
+    fn get_max_duty(&self) -> Self::Duty;
+
+    fn set_duty(&mut self, value: u8);
+}
+
+pub trait IntoPwmPin<TC, PIN> {
+    fn into_pwm(self, timer: &TC) -> Pin<mode::PwmOutput<TC>, PIN>;
+}
+
+impl<TC, PIN: PwmPinOps<TC>> IntoPwmPin<TC, PIN> for Pin<mode::Output, PIN> {
+    fn into_pwm(self, _timer: &TC) -> Pin<mode::PwmOutput<TC>, PIN> {
+        Pin {
+            pin: self.pin,
+            _mode: PhantomData
+        }
+    }
+}
+
+impl<TC, PIN: PwmPinOps<TC>> Pin<mode::PwmOutput<TC>, PIN> {
+    pub fn enable(&mut self) {
+        self.pin.enable();
+    }
+
+    pub fn disable(&mut self) {
+        self.pin.disable();
+    }
+
+    pub fn get_duty(&self) -> <PIN as PwmPinOps<TC>>::Duty {
+        self.pin.get_duty()
+    }
+
+    pub fn get_max_duty(&self) -> <PIN as PwmPinOps<TC>>::Duty {
+        self.pin.get_max_duty()
+    }
+
+    pub fn set_duty(&mut self, duty: u8) {
+        self.pin.set_duty(duty);
+    }
+}
+
 #[macro_export]
-macro_rules! impl_pwm {
+macro_rules! impl_simple_pwm {
     (
         $(#[$timer_pwm_attr:meta])*
         pub struct $TimerPwm:ident {
             timer: $TIMER:ty,
             init: |$init_timer:ident, $prescaler:ident| $init_block:block,
             pins: {$(
-                $port:ident::$PXi:ident: {
+                $PXi:ident: {
                     ocr: $ocr:ident,
                     $into_pwm:ident: |$pin_timer:ident| if enable
                         $pin_enable_block:block else $pin_disable_block:block,
@@ -53,7 +104,7 @@ macro_rules! impl_pwm {
         }
 
         impl $TimerPwm {
-            pub fn new(timer: $TIMER, prescaler: $crate::pwm::Prescaler) -> $TimerPwm {
+            pub fn new(timer: $TIMER, prescaler: $crate::simple_pwm::Prescaler) -> $TimerPwm {
                 let mut t = $TimerPwm { timer };
 
                 {
@@ -67,15 +118,7 @@ macro_rules! impl_pwm {
         }
 
         $(
-            impl $port::$PXi<$crate::port::mode::Output> {
-                pub fn $into_pwm(self, pwm_timer: &mut $TimerPwm)
-                    -> $port::$PXi<$crate::port::mode::Pwm<$TimerPwm>>
-                {
-                    $port::$PXi { _mode: core::marker::PhantomData }
-                }
-            }
-
-            impl $crate::hal::PwmPin for $port::$PXi<$crate::port::mode::Pwm<$TimerPwm>> {
+            impl avr_hal_generic::simple_pwm::PwmPinOps<$TimerPwm> for $PXi {
                 type Duty = u8;
 
                 fn enable(&mut self) {
@@ -85,7 +128,7 @@ macro_rules! impl_pwm {
                     $crate::avr_device::interrupt::free(|_| {
                         let $pin_timer = unsafe { &*<$TIMER>::ptr() };
                         $pin_enable_block
-                    })
+                    });
                 }
 
                 fn disable(&mut self) {
@@ -95,7 +138,7 @@ macro_rules! impl_pwm {
                     $crate::avr_device::interrupt::free(|_| {
                         let $pin_timer = unsafe { &*<$TIMER>::ptr() };
                         $pin_disable_block
-                    })
+                    });
                 }
 
                 fn get_duty(&self) -> Self::Duty {
@@ -109,9 +152,9 @@ macro_rules! impl_pwm {
                 fn set_duty(&mut self, duty: Self::Duty) {
                     // SAFETY: This register is exclusively used here so there are no concurrency
                     // issues.
-                    unsafe { (&*<$TIMER>::ptr()).$ocr.write(|w| w.bits(duty.into())) };
+                    unsafe { (&*<$TIMER>::ptr()).$ocr.write(|w| w.bits(duty.into())); };
                 }
             }
         )+
     }
-}
+}

mcu/atmega-hal/src/lib.rs

@@ -90,6 +90,9 @@ pub mod port;
 #[cfg(feature = "device-selected")]
 pub use port::Pins;
 
+#[cfg(feature = "device-selected")]
+pub mod simple_pwm;
+
 #[cfg(feature = "device-selected")]
 pub mod usart;
 #[cfg(feature = "device-selected")]