Merge #372

372: DynamicPin r=therealprof a=burrbull



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

Author: bors[bot]

CHANGELOG.md

@@ -12,6 +12,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Added `Counter` with `CountDown<Time=fugit::TimerDuration>` and `atat::Clock` implementations [#381]
 - `Into<serial::Config>` for `Bps` [#387]
 - Added the missing DMA implementations for USART3 [#373]
+- `DynamicPin` with dynamically changed mode, remove `AF` constants [#372]
 - `count_down` constructor for `Timer` -> `CountDownTimer` without start [#382]
 - Implementation of RTIC Monotonic for TIM2 & TIM5 under `rtic` feature [#380] [#390]
 - `IoPin` for `Output<OpenDrain>> <-> Input<Floating>>` [#374]

Cargo.toml

@@ -443,3 +443,8 @@ required-features = ["device-selected"]
 [[example]]
 name = "spi_dma"
 required-features = ["rt", "stm32f411"]
+
+[[example]]
+name = "dynamic_gpio"
+required-features = ["device-selected"]
+

examples/dynamic_gpio.rs

@@ -0,0 +1,46 @@
+#![deny(unsafe_code)]
+#![no_std]
+#![no_main]
+
+use panic_halt as _;
+
+use nb::block;
+
+use cortex_m_rt::entry;
+use cortex_m_semihosting::hprintln;
+use stm32f4xx_hal::{gpio::PinState, pac, prelude::*, timer::Timer};
+
+#[entry]
+fn main() -> ! {
+    // Get access to the core peripherals from the cortex-m crate
+    let cp = cortex_m::Peripherals::take().unwrap();
+    // Get access to the device specific peripherals from the peripheral access crate
+    let dp = pac::Peripherals::take().unwrap();
+
+    // Take ownership over raw device and convert it into the corresponding HAL struct
+    let rcc = dp.RCC.constrain();
+
+    // Freeze the configuration of all the clocks in the system and store the frozen frequencies in
+    // `clocks`
+    let clocks = rcc.cfgr.freeze();
+
+    // Acquire the GPIOC peripheral
+    let gpioc = dp.GPIOC.split();
+
+    let mut pin = gpioc.pc13.into_dynamic();
+    // Configure the syst timer to trigger an update every second
+    let mut timer = Timer::syst(cp.SYST, &clocks).counter();
+    timer.start(1.secs()).unwrap();
+
+    // Wait for the timer to trigger an update and change the state of the LED
+    loop {
+        pin.make_floating_input();
+        block!(timer.wait()).unwrap();
+        hprintln!("{}", pin.is_high().unwrap()).unwrap();
+
+        pin.make_push_pull_output_in_state(PinState::High);
+        block!(timer.wait()).unwrap();
+        pin.set_low().unwrap();
+        block!(timer.wait()).unwrap();
+    }
+}

src/gpio.rs

@@ -24,6 +24,7 @@
 //!
 //! - **Alternate**: Pin mode required when the pin is driven by other peripherals
 //! - **Analog**: Analog input to be used with ADC.
+//! - **Dynamic**: Pin mode is selected at runtime. See changing configurations for more details
 //! - Input
 //!     - **PullUp**: Input connected to high with a weak pull up resistor. Will be high when nothing
 //!     is connected
@@ -42,6 +43,16 @@
 //! If you need a more temporary mode change, and can not use the `into_<mode>` functions for
 //! ownership reasons, you can use the closure based `with_<mode>` functions to temporarily change the pin type, do
 //! some output or input, and then have it change back once done.
+//!
+//! ### Dynamic Mode Change
+//! The above mode change methods guarantee that you can only call input functions when the pin is
+//! in input mode, and output when in output modes, but can lead to some issues. Therefore, there
+//! is also a mode where the state is kept track of at runtime, allowing you to change the mode
+//! often, and without problems with ownership, or references, at the cost of some performance and
+//! the risk of runtime errors.
+//!
+//! To make a pin dynamic, use the `into_dynamic` function, and then use the `make_<mode>` functions to
+//! change the mode
 
 use core::marker::PhantomData;
 
@@ -56,6 +67,8 @@ mod partially_erased;
 pub use partially_erased::{PEPin, PartiallyErasedPin};
 mod erased;
 pub use erased::{EPin, ErasedPin};
+mod dynamic;
+pub use dynamic::{Dynamic, DynamicPin};
 mod hal_02;
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
@@ -98,24 +111,6 @@ pub trait PinExt {
 /// Some alternate mode (type state)
 pub struct Alternate<Otype, const A: u8>(PhantomData<Otype>);
 
-// Compatibility constants
-pub const AF0: u8 = 0;
-pub const AF1: u8 = 1;
-pub const AF2: u8 = 2;
-pub const AF3: u8 = 3;
-pub const AF4: u8 = 4;
-pub const AF5: u8 = 5;
-pub const AF6: u8 = 6;
-pub const AF7: u8 = 7;
-pub const AF8: u8 = 8;
-pub const AF9: u8 = 9;
-pub const AF10: u8 = 10;
-pub const AF11: u8 = 11;
-pub const AF12: u8 = 12;
-pub const AF13: u8 = 13;
-pub const AF14: u8 = 14;
-pub const AF15: u8 = 15;
-
 /// Input mode (type state)
 pub struct Input<MODE> {
     _mode: PhantomData<MODE>,

src/gpio/convert.rs

@@ -436,6 +436,14 @@ impl<MODE, const P: char, const N: u8> Pin<MODE, P, N> {
         Pin::new()
     }
 
+    /// Configures the pin as a pin that can change between input
+    /// and output without changing the type. It starts out
+    /// as a floating input
+    pub fn into_dynamic(self) -> DynamicPin<P, N> {
+        self.into_floating_input();
+        DynamicPin::new(Dynamic::InputFloating)
+    }
+
     /// Puts `self` into mode `M`.
     ///
     /// This violates the type state constraints from `MODE`, so callers must

src/gpio/dynamic.rs

@@ -0,0 +1,121 @@
+use super::*;
+
+/// Pin type with dynamic mode
+///
+/// - `P` is port name: `A` for GPIOA, `B` for GPIOB, etc.
+/// - `N` is pin number: from `0` to `15`.
+pub struct DynamicPin<const P: char, const N: u8> {
+    /// Current pin mode
+    pub(crate) mode: Dynamic,
+}
+
+/// Tracks the current pin state for dynamic pins
+pub enum Dynamic {
+    InputFloating,
+    InputPullUp,
+    InputPullDown,
+    OutputPushPull,
+    OutputOpenDrain,
+}
+
+#[derive(Debug, PartialEq)]
+pub enum PinModeError {
+    IncorrectMode,
+}
+
+impl Dynamic {
+    pub fn is_input(&self) -> bool {
+        use Dynamic::*;
+        match self {
+            InputFloating | InputPullUp | InputPullDown | OutputOpenDrain => true,
+            OutputPushPull => false,
+        }
+    }
+    pub fn is_output(&self) -> bool {
+        use Dynamic::*;
+        match self {
+            InputFloating | InputPullUp | InputPullDown => false,
+            OutputPushPull | OutputOpenDrain => true,
+        }
+    }
+}
+
+// For convertion simplify
+struct Unknown;
+
+impl<const P: char, const N: u8> DynamicPin<P, N> {
+    pub const fn new(mode: Dynamic) -> Self {
+        Self { mode }
+    }
+
+    #[inline]
+    pub fn make_pull_up_input(&mut self) {
+        // NOTE(unsafe), we have a mutable reference to the current pin
+        Pin::<Unknown, P, N>::new().into_pull_up_input();
+        self.mode = Dynamic::InputPullUp;
+    }
+    #[inline]
+    pub fn make_pull_down_input(&mut self) {
+        // NOTE(unsafe), we have a mutable reference to the current pin
+        Pin::<Unknown, P, N>::new().into_pull_down_input();
+        self.mode = Dynamic::InputPullDown;
+    }
+    #[inline]
+    pub fn make_floating_input(&mut self) {
+        // NOTE(unsafe), we have a mutable reference to the current pin
+        Pin::<Unknown, P, N>::new().into_floating_input();
+        self.mode = Dynamic::InputFloating;
+    }
+    #[inline]
+    pub fn make_push_pull_output(&mut self) {
+        // NOTE(unsafe), we have a mutable reference to the current pin
+        Pin::<Unknown, P, N>::new().into_push_pull_output();
+        self.mode = Dynamic::OutputPushPull;
+    }
+    #[inline]
+    pub fn make_push_pull_output_in_state(&mut self, state: PinState) {
+        // NOTE(unsafe), we have a mutable reference to the current pin
+        Pin::<Unknown, P, N>::new().into_push_pull_output_in_state(state);
+        self.mode = Dynamic::OutputPushPull;
+    }
+    #[inline]
+    pub fn make_open_drain_output(&mut self) {
+        // NOTE(unsafe), we have a mutable reference to the current pin
+        Pin::<Unknown, P, N>::new().into_open_drain_output();
+        self.mode = Dynamic::OutputOpenDrain;
+    }
+    #[inline]
+    pub fn make_open_drain_output_in_state(&mut self, state: PinState) {
+        // NOTE(unsafe), we have a mutable reference to the current pin
+        Pin::<Unknown, P, N>::new().into_open_drain_output_in_state(state);
+        self.mode = Dynamic::OutputOpenDrain;
+    }
+
+    pub fn set_high(&mut self) -> Result<(), PinModeError> {
+        if self.mode.is_output() {
+            Pin::<Unknown, P, N>::new()._set_state(PinState::High);
+            Ok(())
+        } else {
+            Err(PinModeError::IncorrectMode)
+        }
+    }
+    pub fn set_low(&mut self) -> Result<(), PinModeError> {
+        if self.mode.is_output() {
+            Pin::<Unknown, P, N>::new()._set_state(PinState::Low);
+            Ok(())
+        } else {
+            Err(PinModeError::IncorrectMode)
+        }
+    }
+
+    pub fn is_high(&self) -> Result<bool, PinModeError> {
+        self.is_low().map(|b| !b)
+    }
+    pub fn is_low(&self) -> Result<bool, PinModeError> {
+        if self.mode.is_input() {
+            Ok(Pin::<Unknown, P, N>::new()._is_low())
+        } else {
+            Err(PinModeError::IncorrectMode)
+        }
+    }
+}

src/gpio/hal_02.rs

@@ -1,8 +1,8 @@
 use core::convert::Infallible;
 
 use super::{
-    ErasedPin, Floating, Input, OpenDrain, Output, PartiallyErasedPin, Pin, PullDown, PullUp,
-    PushPull,
+    dynamic::PinModeError, DynamicPin, ErasedPin, Floating, Input, OpenDrain, Output,
+    PartiallyErasedPin, Pin, PullDown, PullUp, PushPull,
 };
 
 pub use embedded_hal::digital::v2::PinState;
@@ -333,3 +333,25 @@ impl<MODE, const P: char> InputPin for PartiallyErasedPin<Input<MODE>, P> {
         Ok(self.is_low())
     }
 }
+
+// Implementations for `DynamicPin`
+
+impl<const P: char, const N: u8> OutputPin for DynamicPin<P, N> {
+    type Error = PinModeError;
+    fn set_high(&mut self) -> Result<(), Self::Error> {
+        self.set_high()
+    }
+    fn set_low(&mut self) -> Result<(), Self::Error> {
+        self.set_low()
+    }
+}
+
+impl<const P: char, const N: u8> InputPin for DynamicPin<P, N> {
+    type Error = PinModeError;
+    fn is_high(&self) -> Result<bool, Self::Error> {
+        self.is_high()
+    }
+    fn is_low(&self) -> Result<bool, Self::Error> {
+        self.is_low()
+    }
+}