Implement more general GPIO pins (#115)

* Implement more general GPIO pins

* Add changelog entry

* Downgrade directly to Pxx

* Make downgrade function downgrade to Pxx and make into_generic private

* Add example of generic pin usage

Author: TheZoq2

CHANGELOG.md

@@ -28,6 +28,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 ### Changed
 
 - DMA traits now require AsSlice instead of AsRef
+- GPIO `downgrade` function now returns a `Pxx` instead of a type specific to a
+  GPIO port
 
 ## [v0.4.0] - 2019-08-09
 

examples/blinky_generic.rs

@@ -0,0 +1,53 @@
+//! Blinks several LEDs stored in an array
+
+#![deny(unsafe_code)]
+#![no_std]
+#![no_main]
+
+use panic_halt as _;
+
+use nb::block;
+
+use stm32f1xx_hal::{
+    prelude::*,
+    pac,
+    timer::Timer,
+};
+use cortex_m_rt::entry;
+use embedded_hal::digital::v2::OutputPin;
+
+#[entry]
+fn main() -> ! {
+    let cp = cortex_m::Peripherals::take().unwrap();
+    let dp = pac::Peripherals::take().unwrap();
+
+    let mut flash = dp.FLASH.constrain();
+    let mut rcc = dp.RCC.constrain();
+
+    let clocks = rcc.cfgr.freeze(&mut flash.acr);
+
+    // Acquire the GPIO peripherals
+    let mut gpioa = dp.GPIOA.split(&mut rcc.apb2);
+    let mut gpioc = dp.GPIOC.split(&mut rcc.apb2);
+
+    // Configure the syst timer to trigger an update every second
+    let mut timer = Timer::syst(cp.SYST, &clocks).start_count_down(1.hz());
+
+    // Create an array of LEDS to blink
+    let mut leds = [
+        gpioc.pc13.into_push_pull_output(&mut gpioc.crh).downgrade(),
+        gpioa.pa1.into_push_pull_output(&mut gpioa.crl).downgrade()
+    ];
+
+    // Wait for the timer to trigger an update and change the state of the LED
+    loop {
+        block!(timer.wait()).unwrap();
+        for led in leds.iter_mut() {
+            led.set_high().unwrap();
+        }
+        block!(timer.wait()).unwrap();
+        for led in leds.iter_mut() {
+            led.set_low().unwrap();
+        }
+    }
+}

src/gpio.rs

@@ -95,6 +95,7 @@ macro_rules! gpio {
                 State,
                 Active,
                 Debugger,
+                Pxx
             };
 
             /// GPIO parts
@@ -150,13 +151,19 @@ macro_rules! gpio {
                 }
             }
 
-            /// Partially erased pin
-            pub struct $PXx<MODE> {
+            /// Partially erased pin. Only used in the Pxx enum
+            pub struct Generic<MODE> {
                 i: u8,
                 _mode: PhantomData<MODE>,
             }
 
-            impl<MODE> OutputPin for $PXx<Output<MODE>> {
+            impl<MODE> Generic<MODE> {
+                pub fn downgrade(self) -> Pxx<MODE> {
+                    Pxx::$PXx(self)
+                }
+            }
+
+            impl<MODE> OutputPin for Generic<Output<MODE>> {
                 type Error = Void;
                 fn set_high(&mut self) -> Result<(), Self::Error> {
                     // NOTE(unsafe) atomic write to a stateless register
@@ -169,7 +176,7 @@ macro_rules! gpio {
                 }
             }
 
-            impl<MODE> InputPin for $PXx<Input<MODE>> {
+            impl<MODE> InputPin for Generic<Input<MODE>> {
                 type Error = Void;
                 fn is_high(&self) -> Result<bool, Self::Error> {
                     self.is_low().map(|b| !b)
@@ -181,7 +188,7 @@ macro_rules! gpio {
                 }
             }
 
-            impl <MODE> StatefulOutputPin for $PXx<Output<MODE>> {
+            impl <MODE> StatefulOutputPin for Generic<Output<MODE>> {
                 fn is_set_high(&self) -> Result<bool, Self::Error> {
                     self.is_set_low().map(|b| !b)
                 }
@@ -192,9 +199,9 @@ macro_rules! gpio {
                 }
             }
 
-            impl <MODE> toggleable::Default for $PXx<Output<MODE>> {}
+            impl <MODE> toggleable::Default for Generic<Output<MODE>> {}
 
-            impl InputPin for $PXx<Output<OpenDrain>> {
+            impl InputPin for Generic<Output<OpenDrain>> {
                 type Error = Void;
                 fn is_high(&self) -> Result<bool, Self::Error> {
                     self.is_low().map(|b| !b)
@@ -206,6 +213,10 @@ macro_rules! gpio {
                 }
             }
 
+            pub type $PXx<MODE> = Pxx<MODE>;
+
+
+
             $(
                 /// Pin
                 pub struct $PXi<MODE> {
@@ -442,15 +453,20 @@ macro_rules! gpio {
 
                 impl<MODE> $PXi<MODE> where MODE: Active {
                     /// Erases the pin number from the type
-                    ///
-                    /// This is useful when you want to collect the pins into an array where you
-                    /// need all the elements to have the same type
-                    pub fn downgrade(self) -> $PXx<MODE> {
-                        $PXx {
+                    fn into_generic(self) -> Generic<MODE> {
+                        Generic {
                             i: $i,
                             _mode: self._mode,
                         }
                     }
+
+                    /// Erases the pin number and port from the type
+                    ///
+                    /// This is useful when you want to collect the pins into an array where you
+                    /// need all the elements to have the same type
+                    pub fn downgrade(self) -> Pxx<MODE> {
+                        self.into_generic().downgrade()
+                    }
                 }
 
                 impl<MODE> OutputPin for $PXi<Output<MODE>> {
@@ -507,6 +523,71 @@ macro_rules! gpio {
     }
 }
 
+macro_rules! impl_pxx {
+    ($(($port:ident :: $pin:ident)),*) => {
+        use void::Void;
+        use embedded_hal::digital::v2::{InputPin, StatefulOutputPin, OutputPin};
+
+        pub enum Pxx<MODE> {
+            $(
+                $pin($port::Generic<MODE>)
+            ),*
+        }
+
+        impl<MODE> OutputPin for Pxx<Output<MODE>> {
+            type Error = Void;
+            fn set_high(&mut self) -> Result<(), Void> {
+                match self {
+                    $(Pxx::$pin(pin) => pin.set_high()),*
+                }
+            }
+
+            fn set_low(&mut self) -> Result<(), Void> {
+                match self {
+                    $(Pxx::$pin(pin) => pin.set_low()),*
+                }
+            }
+        }
+
+        impl<MODE> StatefulOutputPin for Pxx<Output<MODE>> {
+            fn is_set_high(&self) -> Result<bool, Self::Error> {
+                match self {
+                    $(Pxx::$pin(pin) => pin.is_set_high()),*
+                }
+            }
+
+            fn is_set_low(&self) -> Result<bool, Self::Error> {
+                match self {
+                    $(Pxx::$pin(pin) => pin.is_set_low()),*
+                }
+            }
+        }
+
+        impl<MODE> InputPin for Pxx<Input<MODE>> {
+            type Error = Void;
+            fn is_high(&self) -> Result<bool, Void> {
+                match self {
+                    $(Pxx::$pin(pin) => pin.is_high()),*
+                }
+            }
+
+            fn is_low(&self) -> Result<bool, Void> {
+                match self {
+                    $(Pxx::$pin(pin) => pin.is_low()),*
+                }
+            }
+        }
+    }
+}
+
+impl_pxx!{
+    (gpioa::PAx),
+    (gpiob::PBx),
+    (gpioc::PCx),
+    (gpiod::PDx),
+    (gpioe::PEx)
+}
+
 gpio!(GPIOA, gpioa, gpioa, PAx, [
     PA0: (pa0, 0, Input<Floating>, CRL),
     PA1: (pa1, 1, Input<Floating>, CRL),