Add second downgrade function that removes both pin and port from the type.

Author: dimpolo

CHANGELOG.md

@@ -106,13 +106,15 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Added support for CAN on additional models: STM32F412, STM32F413, STM32F415,
   STM32F417, STM32F423, STM32F427, STM32F429, STM32F437, STM32F439, STM32F469,
   and STM32F479 [#262]
+- Added `gpio::gpiox::Pxi::downgrade2` method [#272]
 
 [#231]: https://github.com/stm32-rs/stm32f4xx-hal/pull/231
 [#262]: https://github.com/stm32-rs/stm32f4xx-hal/pull/262
 [#263]: https://github.com/stm32-rs/stm32f4xx-hal/pull/263
 [#278]: https://github.com/stm32-rs/stm32f4xx-hal/issues/278
 [#273]: https://github.com/stm32-rs/stm32f4xx-hal/pull/273
 [#286]: https://github.com/stm32-rs/stm32f4xx-hal/pull/286
+[#272]: https://github.com/stm32-rs/stm32f4xx-hal/issues/272
 
 ### Fixed
 

src/gpio.rs

@@ -2,6 +2,8 @@
 
 use core::marker::PhantomData;
 
+use embedded_hal::digital::v2::{toggleable, InputPin, OutputPin, StatefulOutputPin};
+
 use crate::pac::EXTI;
 use crate::syscfg::SysCfg;
 
@@ -745,6 +747,14 @@ macro_rules! gpio {
                             _mode: self._mode,
                         }
                     }
+
+                    /// Erases the pin number and the 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 downgrade2(self) -> super::Pin<MODE>{
+                        super::Pin::new($port_id, $i)
+                    }
                 }
 
                 impl<MODE> OutputPin for $PXi<Output<MODE>> {
@@ -1037,3 +1047,109 @@ gpio!(GPIOK, gpiok, PK, 10, [
     PK6: (pk6, 6, Input<Floating>),
     PK7: (pk7, 7, Input<Floating>),
 ]);
+
+/// Fully erased pin
+pub struct Pin<MODE> {
+    // Bits 0-3: Pin, Bits 4-7: Port
+    pin_port: u8,
+    _mode: PhantomData<MODE>,
+}
+
+impl<MODE> PinExt for Pin<MODE> {
+    type Mode = MODE;
+
+    #[inline(always)]
+    fn pin_id(&self) -> u8 {
+        self.pin_port & 0x0f
+    }
+    #[inline(always)]
+    fn port_id(&self) -> u8 {
+        self.pin_port >> 4
+    }
+}
+
+impl<MODE> Pin<MODE> {
+    fn new(port: u8, pin: u8) -> Self {
+        Self {
+            pin_port: port << 4 | pin,
+            _mode: PhantomData,
+        }
+    }
+
+    #[inline]
+    fn block(&self) -> &crate::pac::gpioa::RegisterBlock {
+        // This function uses pointer arithmetic instead of branching to be more efficient
+
+        // The logic relies on the following assumptions:
+        // - GPIOA register is available on all chips
+        // - all gpio register blocks have the same layout
+        // - consecutive gpio register blocks have the same offset between them, namely 0x0400
+        // - Pin::new was called with a valid port
+
+        // FIXME could be calculated after const_raw_ptr_to_usize_cast stabilization #51910
+        const GPIO_REGISTER_OFFSET: usize = 0x0400;
+
+        let offset = GPIO_REGISTER_OFFSET * self.port_id() as usize;
+        let block_ptr =
+            (crate::pac::GPIOA::ptr() as usize + offset) as *const crate::pac::gpioa::RegisterBlock;
+
+        unsafe { &*block_ptr }
+    }
+}
+
+impl<MODE> OutputPin for Pin<Output<MODE>> {
+    type Error = core::convert::Infallible;
+
+    fn set_low(&mut self) -> Result<(), Self::Error> {
+        // NOTE(unsafe) atomic write to a stateless register
+        unsafe {
+            self.block()
+                .bsrr
+                .write(|w| w.bits(1 << (self.pin_id() + 16)))
+        };
+        Ok(())
+    }
+
+    fn set_high(&mut self) -> Result<(), Self::Error> {
+        // NOTE(unsafe) atomic write to a stateless register
+        unsafe { self.block().bsrr.write(|w| w.bits(1 << self.pin_id())) };
+        Ok(())
+    }
+}
+
+impl<MODE> StatefulOutputPin for Pin<Output<MODE>> {
+    fn is_set_high(&self) -> Result<bool, Self::Error> {
+        self.is_set_low().map(|v| !v)
+    }
+
+    fn is_set_low(&self) -> Result<bool, Self::Error> {
+        // NOTE(unsafe) atomic read with no side effects
+        Ok(self.block().odr.read().bits() & (1 << self.pin_id()) == 0)
+    }
+}
+
+impl<MODE> toggleable::Default for Pin<Output<MODE>> {}
+
+impl<MODE> InputPin for Pin<Output<MODE>> {
+    type Error = core::convert::Infallible;
+
+    fn is_high(&self) -> Result<bool, Self::Error> {
+        self.is_low().map(|v| !v)
+    }
+
+    fn is_low(&self) -> Result<bool, Self::Error> {
+        Ok(self.block().idr.read().bits() & (1 << self.pin_id()) == 0)
+    }
+}
+
+impl<MODE> InputPin for Pin<Input<MODE>> {
+    type Error = core::convert::Infallible;
+
+    fn is_high(&self) -> Result<bool, Self::Error> {
+        self.is_low().map(|v| !v)
+    }
+
+    fn is_low(&self) -> Result<bool, Self::Error> {
+        Ok(self.block().idr.read().bits() & (1 << self.pin_id()) == 0)
+    }
+}