Add stateful versions of the output pin temp conversions

Author: TheZoq2

examples/multi_mode_gpio.rs

@@ -6,10 +6,10 @@ use panic_halt as _;
 
 use nb::block;
 
-use cortex_m_semihosting::hprintln;
 use cortex_m_rt::entry;
+use cortex_m_semihosting::hprintln;
 use embedded_hal::digital::v2::{InputPin, OutputPin};
-use stm32f1xx_hal::{pac, prelude::*, timer::Timer};
+use stm32f1xx_hal::{pac, prelude::*, timer::Timer, gpio::State};
 
 #[entry]
 fn main() -> ! {
@@ -44,5 +44,10 @@ fn main() -> ! {
             out.set_low().unwrap();
             block!(timer.wait()).unwrap();
         });
+        pin.as_push_pull_output_with_state(&mut gpioc.crh, State::High, |out| {
+            block!(timer.wait()).unwrap();
+            out.set_low().unwrap();
+            block!(timer.wait()).unwrap();
+        });
     }
 }

src/gpio.rs

@@ -490,17 +490,59 @@ macro_rules! gpio {
                     }
                 }
 
-                // TODO: Add the stateful versions
-                macro_rules! impl_temp_mode {
+                macro_rules! impl_temp_output {
                     (
                         $fn_name:ident,
+                        $stateful_fn_name:ident,
                         $mode:ty
                     ) => {
                         /**
                           Temporarily change the mode of the pin.
 
-                          When changing to an output, the value of the pin is
-                          undefined.
+                          The value of the pin after conversion is undefined. If you
+                          want to control it, use `$stateful_fn_name`
+                        */
+                        pub fn $fn_name(
+                            &mut self,
+                            cr: &mut $CR,
+                            mut f: impl FnMut(&mut $PXi<$mode>)
+                        ) {
+                            let mut temp = unsafe { $PXi::<$mode>::set_mode(cr) };
+                            f(&mut temp);
+                            unsafe {
+                                Self::set_mode(cr);
+                            }
+                        }
+
+                        /**
+                          Temporarily change the mode of the pin.
+
+                          Note that the new state is set slightly before conversion
+                          happens. This can cause a short output glitch if switching
+                          between output modes
+                        */
+                        pub fn $stateful_fn_name(
+                            &mut self,
+                            cr: &mut $CR,
+                            state: State,
+                            mut f: impl FnMut(&mut $PXi<$mode>)
+                        ) {
+                            self.set_state(state);
+                            let mut temp = unsafe { $PXi::<$mode>::set_mode(cr) };
+                            f(&mut temp);
+                            unsafe {
+                                Self::set_mode(cr);
+                            }
+                        }
+                    }
+                }
+                macro_rules! impl_temp_input {
+                    (
+                        $fn_name:ident,
+                        $mode:ty
+                    ) => {
+                        /**
+                          Temporarily change the mode of the pin.
                         */
                         pub fn $fn_name(
                             &mut self,
@@ -517,23 +559,25 @@ macro_rules! gpio {
                 }
 
                 impl<MODE> $PXi<MODE> where MODE: Active, $PXi<MODE>: PinMode<$CR> {
-                    impl_temp_mode!(
+                    impl_temp_output!(
                         as_push_pull_output,
+                        as_push_pull_output_with_state,
                         Output<PushPull>
                     );
-                    impl_temp_mode!(
+                    impl_temp_output!(
                         as_open_drain_output,
+                        as_open_drain_output_with_state,
                         Output<OpenDrain>
                     );
-                    impl_temp_mode!(
+                    impl_temp_input!(
                         as_floating_input,
                         Input<Floating>
                     );
-                    impl_temp_mode!(
+                    impl_temp_input!(
                         as_pull_up_input,
                         Input<PullUp>
                     );
-                    impl_temp_mode!(
+                    impl_temp_input!(
                         as_pull_down_input,
                         Input<PullDown>
                     );