From 5cc5961c94568db768c241e8e8bf91a692c1803e Mon Sep 17 00:00:00 2001 From: Dario Nieuwenhuis Date: Sat, 9 Jul 2022 02:12:17 +0200 Subject: rp/gpio: add Flex. --- embassy-rp/src/gpio.rs | 376 +++++++++++++++++++++++++++++++++++-------------- 1 file changed, 272 insertions(+), 104 deletions(-) diff --git a/embassy-rp/src/gpio.rs b/embassy-rp/src/gpio.rs index ae771e849..131330e79 100644 --- a/embassy-rp/src/gpio.rs +++ b/embassy-rp/src/gpio.rs @@ -30,156 +30,147 @@ pub enum Bank { } pub struct Input<'d, T: Pin> { - pin: T, - phantom: PhantomData<&'d mut T>, + pin: Flex<'d, T>, } impl<'d, T: Pin> Input<'d, T> { pub fn new(pin: impl Unborrow + 'd, pull: Pull) -> Self { - unborrow!(pin); - - unsafe { - pin.pad_ctrl().write(|w| { - w.set_ie(true); - match pull { - Pull::Up => w.set_pue(true), - Pull::Down => w.set_pde(true), - Pull::None => {} - } - }); - - // disable output in SIO, to use it as input - pin.sio_oe().value_clr().write_value(1 << pin.pin()); - - pin.io().ctrl().write(|w| { - w.set_funcsel(pac::io::vals::Gpio0CtrlFuncsel::SIO_0.0); - }); - } - - Self { - pin, - phantom: PhantomData, - } + let mut pin = Flex::new(pin); + pin.set_as_input(); + pin.set_pull(pull); + Self { pin } } pub fn is_high(&self) -> bool { - !self.is_low() + self.pin.is_high() } pub fn is_low(&self) -> bool { - let val = 1 << self.pin.pin(); - unsafe { self.pin.sio_in().read() & val == 0 } - } -} - -impl<'d, T: Pin> Drop for Input<'d, T> { - fn drop(&mut self) { - // todo + self.pin.is_low() } } pub struct Output<'d, T: Pin> { - pin: T, - phantom: PhantomData<&'d mut T>, + pin: Flex<'d, T>, } impl<'d, T: Pin> Output<'d, T> { + #[inline] pub fn new(pin: impl Unborrow + 'd, initial_output: Level) -> Self { - unborrow!(pin); - - unsafe { - match initial_output { - Level::High => pin.sio_out().value_set().write_value(1 << pin.pin()), - Level::Low => pin.sio_out().value_clr().write_value(1 << pin.pin()), - } - pin.sio_oe().value_set().write_value(1 << pin.pin()); - - pin.io().ctrl().write(|w| { - w.set_funcsel(pac::io::vals::Gpio0CtrlFuncsel::SIO_0.0); - }); + let mut pin = Flex::new(pin); + match initial_output { + Level::High => pin.set_high(), + Level::Low => pin.set_low(), } - Self { - pin, - phantom: PhantomData, - } + pin.set_as_output(); + Self { pin } } /// Set the output as high. + #[inline] pub fn set_high(&mut self) { - let val = 1 << self.pin.pin(); - unsafe { self.pin.sio_out().value_set().write_value(val) }; + self.pin.set_high() } /// Set the output as low. + #[inline] pub fn set_low(&mut self) { - let val = 1 << self.pin.pin(); - unsafe { self.pin.sio_out().value_clr().write_value(val) }; + self.pin.set_low() } /// Is the output pin set as high? + #[inline] pub fn is_set_high(&self) -> bool { - !self.is_set_low() + self.pin.is_set_high() } /// Is the output pin set as low? + #[inline] pub fn is_set_low(&self) -> bool { - // Reading from SIO: GPIO_OUT gives the last value written. - let val = 1 << self.pin.pin(); - unsafe { (self.pin.sio_out().value().read() & val) == 0 } + self.pin.is_set_low() } /// Toggle pin output #[inline] pub fn toggle(&mut self) { - let val = 1 << self.pin.pin(); - unsafe { - self.pin.sio_out().value_xor().write_value(val); - } + self.pin.toggle() } } -impl<'d, T: Pin> Drop for Output<'d, T> { - fn drop(&mut self) { - let val = 1 << self.pin.pin(); - unsafe { - self.pin.sio_out().value_clr().write_value(val); - self.pin.sio_oe().value_clr().write_value(val); - self.pin.io().ctrl().write(|w| { - w.set_funcsel(pac::io::vals::Gpio0CtrlFuncsel::NULL.0); - }); - }; +/// GPIO output open-drain. +pub struct OutputOpenDrain<'d, T: Pin> { + pin: Flex<'d, T>, +} + +impl<'d, T: Pin> OutputOpenDrain<'d, T> { + #[inline] + pub fn new(pin: impl Unborrow + 'd, initial_output: Level) -> Self { + let mut pin = Flex::new(pin); + pin.set_low(); + match initial_output { + Level::High => pin.set_as_input(), + Level::Low => pin.set_as_output(), + } + Self { pin } + } + + /// Set the output as high. + #[inline] + pub fn set_high(&mut self) { + // For Open Drain High, disable the output pin. + self.pin.set_as_input() + } + + /// Set the output as low. + #[inline] + pub fn set_low(&mut self) { + // For Open Drain Low, enable the output pin. + self.pin.set_as_output() + } + + /// Is the output level high? + #[inline] + pub fn is_set_high(&self) -> bool { + !self.is_set_low() + } + + /// Is the output level low? + #[inline] + pub fn is_set_low(&self) -> bool { + self.pin.is_set_as_output() + } + + /// Toggle pin output + #[inline] + pub fn toggle(&mut self) { + self.pin.toggle_set_as_output() } } -/// GPIO output open-drain. -pub struct OutputOpenDrain<'d, T: Pin> { +/// GPIO flexible pin. +/// +/// This pin can be either an input or output pin. The output level register bit will remain +/// set while not in output mode, so the pin's level will be 'remembered' when it is not in output +/// mode. +pub struct Flex<'d, T: Pin> { pin: T, phantom: PhantomData<&'d mut T>, } -impl<'d, T: Pin> OutputOpenDrain<'d, T> { +impl<'d, T: Pin> Flex<'d, T> { #[inline] - pub fn new(pin: impl Unborrow + 'd, initial_output: Level) -> Self { + pub fn new(pin: impl Unborrow + 'd) -> Self { unborrow!(pin); unsafe { - let val = 1 << pin.pin(); + pin.pad_ctrl().write(|w| { + w.set_ie(true); + }); + pin.io().ctrl().write(|w| { w.set_funcsel(pac::io::vals::Gpio0CtrlFuncsel::SIO_0.0); }); - pin.sio_out().value_clr().write_value(val); - - match initial_output { - Level::High => { - // For Open Drain High, disable the output pin. - pin.sio_oe().value_clr().write_value(val); - } - Level::Low => { - // For Open Drain Low, enable the output pin. - pin.sio_oe().value_set().write_value(val); - } - } } Self { @@ -188,29 +179,79 @@ impl<'d, T: Pin> OutputOpenDrain<'d, T> { } } - /// Set the output as high. #[inline] - pub fn set_high(&mut self) { - // For Open Drain High, disable the output pin. + fn bit(&self) -> u32 { + 1 << self.pin.pin() + } + + /// Set the pin's pull. + #[inline] + pub fn set_pull(&mut self, pull: Pull) { unsafe { - self.pin.sio_oe().value_clr().write_value(1 << self.pin.pin()); + self.pin.pad_ctrl().write(|w| { + w.set_ie(true); + match pull { + Pull::Up => w.set_pue(true), + Pull::Down => w.set_pde(true), + Pull::None => {} + } + }); } } + /// Put the pin into input mode. + /// + /// The pull setting is left unchanged. + #[inline] + pub fn set_as_input(&mut self) { + unsafe { self.pin.sio_oe().value_clr().write_value(self.bit()) } + } + + /// Put the pin into output mode. + /// + /// The pin level will be whatever was set before (or low by default). If you want it to begin + /// at a specific level, call `set_high`/`set_low` on the pin first. + #[inline] + pub fn set_as_output(&mut self) { + unsafe { self.pin.sio_oe().value_set().write_value(self.bit()) } + } + + #[inline] + fn is_set_as_output(&self) -> bool { + unsafe { (self.pin.sio_oe().value().read() & self.bit()) != 0 } + } + + #[inline] + pub fn toggle_set_as_output(&mut self) { + unsafe { self.pin.sio_oe().value_xor().write_value(self.bit()) } + } + + #[inline] + pub fn is_high(&self) -> bool { + !self.is_low() + } + + #[inline] + pub fn is_low(&self) -> bool { + unsafe { self.pin.sio_in().read() & self.bit() == 0 } + } + + /// Set the output as high. + #[inline] + pub fn set_high(&mut self) { + unsafe { self.pin.sio_out().value_set().write_value(self.bit()) } + } + /// Set the output as low. #[inline] pub fn set_low(&mut self) { - // For Open Drain Low, enable the output pin. - unsafe { - self.pin.sio_oe().value_set().write_value(1 << self.pin.pin()); - } + unsafe { self.pin.sio_out().value_clr().write_value(self.bit()) } } /// Is the output level high? #[inline] pub fn is_set_high(&self) -> bool { - let val = 1 << self.pin.pin(); - unsafe { (self.pin.sio_oe().value().read() & val) == 0 } + unsafe { (self.pin.sio_out().value().read() & self.bit()) == 0 } } /// Is the output level low? @@ -222,9 +263,18 @@ impl<'d, T: Pin> OutputOpenDrain<'d, T> { /// Toggle pin output #[inline] pub fn toggle(&mut self) { - let val = 1 << self.pin.pin(); + unsafe { self.pin.sio_out().value_xor().write_value(self.bit()) } + } +} + +impl<'d, T: Pin> Drop for Flex<'d, T> { + #[inline] + fn drop(&mut self) { unsafe { - self.pin.sio_out().value_xor().write_value(val); + self.pin.pad_ctrl().write(|_| {}); + self.pin.io().ctrl().write(|w| { + w.set_funcsel(pac::io::vals::Gpio0CtrlFuncsel::NULL.0); + }); } } } @@ -428,6 +478,48 @@ mod eh02 { Ok(self.toggle()) } } + + impl<'d, T: Pin> embedded_hal_02::digital::v2::InputPin for Flex<'d, T> { + type Error = Infallible; + + fn is_high(&self) -> Result { + Ok(self.is_high()) + } + + fn is_low(&self) -> Result { + Ok(self.is_low()) + } + } + + impl<'d, T: Pin> embedded_hal_02::digital::v2::OutputPin for Flex<'d, T> { + type Error = Infallible; + + fn set_high(&mut self) -> Result<(), Self::Error> { + Ok(self.set_high()) + } + + fn set_low(&mut self) -> Result<(), Self::Error> { + Ok(self.set_low()) + } + } + + impl<'d, T: Pin> embedded_hal_02::digital::v2::StatefulOutputPin for Flex<'d, T> { + fn is_set_high(&self) -> Result { + Ok(self.is_set_high()) + } + + fn is_set_low(&self) -> Result { + Ok(self.is_set_low()) + } + } + + impl<'d, T: Pin> embedded_hal_02::digital::v2::ToggleableOutputPin for Flex<'d, T> { + type Error = Infallible; + #[inline] + fn toggle(&mut self) -> Result<(), Self::Error> { + Ok(self.toggle()) + } + } } #[cfg(feature = "unstable-traits")] @@ -471,4 +563,80 @@ mod eh1 { Ok(self.is_set_low()) } } + + impl<'d, T: Pin> embedded_hal_1::digital::blocking::ToggleableOutputPin for Output<'d, T> { + fn toggle(&mut self) -> Result<(), Self::Error> { + Ok(self.toggle()) + } + } + + impl<'d, T: Pin> embedded_hal_1::digital::ErrorType for OutputOpenDrain<'d, T> { + type Error = Infallible; + } + + impl<'d, T: Pin> embedded_hal_1::digital::blocking::OutputPin for OutputOpenDrain<'d, T> { + fn set_high(&mut self) -> Result<(), Self::Error> { + Ok(self.set_high()) + } + + fn set_low(&mut self) -> Result<(), Self::Error> { + Ok(self.set_low()) + } + } + + impl<'d, T: Pin> embedded_hal_1::digital::blocking::StatefulOutputPin for OutputOpenDrain<'d, T> { + fn is_set_high(&self) -> Result { + Ok(self.is_set_high()) + } + + fn is_set_low(&self) -> Result { + Ok(self.is_set_low()) + } + } + + impl<'d, T: Pin> embedded_hal_1::digital::blocking::ToggleableOutputPin for OutputOpenDrain<'d, T> { + fn toggle(&mut self) -> Result<(), Self::Error> { + Ok(self.toggle()) + } + } + + impl<'d, T: Pin> embedded_hal_1::digital::ErrorType for Flex<'d, T> { + type Error = Infallible; + } + + impl<'d, T: Pin> embedded_hal_1::digital::blocking::InputPin for Flex<'d, T> { + fn is_high(&self) -> Result { + Ok(self.is_high()) + } + + fn is_low(&self) -> Result { + Ok(self.is_low()) + } + } + + impl<'d, T: Pin> embedded_hal_1::digital::blocking::OutputPin for Flex<'d, T> { + fn set_high(&mut self) -> Result<(), Self::Error> { + Ok(self.set_high()) + } + + fn set_low(&mut self) -> Result<(), Self::Error> { + Ok(self.set_low()) + } + } + + impl<'d, T: Pin> embedded_hal_1::digital::blocking::StatefulOutputPin for Flex<'d, T> { + fn is_set_high(&self) -> Result { + Ok(self.is_set_high()) + } + + fn is_set_low(&self) -> Result { + Ok(self.is_set_low()) + } + } + + impl<'d, T: Pin> embedded_hal_1::digital::blocking::ToggleableOutputPin for Flex<'d, T> { + fn toggle(&mut self) -> Result<(), Self::Error> { + Ok(self.toggle()) + } + } } -- cgit