Struct Flex

pub struct Flex<'d, P = AnyPin> { /* private fields */ }

Flexible pin driver.

This driver allows changing the pin mode between input and output.

Implementations

impl<P> Flex<'_, P>

where P: InputPin,

pub async fn wait_for_high(&mut self)

Wait until the pin is high. If it is already high, return immediately.

pub async fn wait_for_low(&mut self)

Wait until the pin is low. If it is already low, return immediately.

pub async fn wait_for_rising_edge(&mut self)

Wait for the pin to undergo a transition from low to high.

pub async fn wait_for_falling_edge(&mut self)

Wait for the pin to undergo a transition from high to low.

pub async fn wait_for_any_edge(&mut self)

Wait for the pin to undergo any transition, i.e low to high OR high to low.

impl<'d> Flex<'d>

pub fn new(pin: impl Peripheral<P = impl Into<AnyPin>> + 'd) -> Self

Create flexible pin driver for a Pin. No mode change happens.

impl<'d, P> Flex<'d, P>

where P: Pin,

pub fn new_typed(pin: impl Peripheral<P = P> + 'd) -> Self

Create flexible pin driver for a Pin. No mode change happens.

pub fn peripheral_input(&self) -> InputSignal

Returns a peripheral input connected to this pin.

The input signal can be passed to peripherals in place of an input pin.

impl<P> Flex<'_, P>

where P: InputPin,

pub fn set_as_input(&mut self, pull: Pull)

Set the GPIO to input mode.

pub fn is_high(&self) -> bool

Get whether the pin input level is high.

pub fn is_low(&self) -> bool

Get whether the pin input level is low.

pub fn level(&self) -> Level

Get the current pin input level.

pub fn listen(&mut self, event: Event)

Listen for interrupts

pub fn unlisten(&mut self)

Stop listening for interrupts

pub fn clear_interrupt(&mut self)

Clear the interrupt status bit for this Pin

pub fn is_interrupt_set(&self) -> bool

Checks if the interrupt status bit for this Pin is set

pub fn wakeup_enable(&mut self, enable: bool, event: WakeEvent)

Enable as a wake-up source.

This will unlisten for interrupts

impl<P> Flex<'_, P>

where P: OutputPin,

pub fn set_as_output(&mut self)

Set the GPIO to output mode.

pub fn set_high(&mut self)

Set the output as high.

pub fn set_low(&mut self)

Set the output as low.

pub fn set_level(&mut self, level: Level)

Set the output level.

pub fn is_set_high(&self) -> bool

Is the output pin set as high?

pub fn is_set_low(&self) -> bool

Is the output pin set as low?

pub fn output_level(&self) -> Level

What level output is set to

pub fn toggle(&mut self)

Toggle pin output

pub fn set_drive_strength(&mut self, strength: DriveStrength)

Configure the DriveStrength of the pin

pub fn set_as_open_drain(&mut self, pull: Pull)

Set the GPIO to open-drain mode.

pub fn split(self) -> (InputSignal, OutputSignal)

Split the pin into an input and output signal.

Peripheral signals allow connecting peripherals together without using external hardware.

pub fn into_peripheral_output(self) -> OutputSignal

Turns the pin object into a peripheral output.

The output signal can be passed to peripherals in place of an output pin.

Trait Implementations

impl<P> ErrorType for Flex<'_, P>

type Error = Infallible

Error type

impl<P> From<Flex<'static, P>> for InputConnection

where P: InputPin,

fn from(pin: Flex<'static, P>) -> Self

Converts to this type from the input type.

impl<P> From<Flex<'static, P>> for InputSignal

where P: InputPin,

fn from(input: Flex<'static, P>) -> Self

Converts to this type from the input type.

impl<P> From<Flex<'static, P>> for OutputConnection

where P: OutputPin,

fn from(pin: Flex<'static, P>) -> Self

Converts to this type from the input type.

impl<P> From<Flex<'static, P>> for OutputSignal

where P: OutputPin,

fn from(input: Flex<'static, P>) -> Self

Converts to this type from the input type.

impl<P> InputPin for Flex<'_, P>

where P: InputPin + OutputPin,

type Error = Infallible

Error type

fn is_high(&self) -> Result<bool, Self::Error>

Is the input pin high?

fn is_low(&self) -> Result<bool, Self::Error>

Is the input pin low?

impl<P> InputPin for Flex<'_, P>

where P: InputPin,

fn is_high(&mut self) -> Result<bool, Self::Error>

Is the input pin high?

fn is_low(&mut self) -> Result<bool, Self::Error>

Is the input pin low?

impl<P> OutputPin for Flex<'_, P>

where P: InputPin + OutputPin,

type Error = Infallible

Error type

fn set_high(&mut self) -> Result<(), Self::Error>

Drives the pin high

fn set_low(&mut self) -> Result<(), Self::Error>

Drives the pin low

fn set_state(&mut self, state: PinState) -> Result<(), Self::Error>

Drives the pin high or low depending on the provided value

impl<P> OutputPin for Flex<'_, P>

where P: OutputPin,

fn set_low(&mut self) -> Result<(), Self::Error>

Drives the pin low.

fn set_high(&mut self) -> Result<(), Self::Error>

Drives the pin high.

fn set_state(&mut self, state: PinState) -> Result<(), Self::Error>

Drives the pin high or low depending on the provided value.

impl<P> Peripheral for Flex<'_, P>

type P = Flex<'_, P>

Peripheral singleton type

unsafe fn clone_unchecked(&self) -> Self::P

Unsafely clone (duplicate) a peripheral singleton.

fn into_ref<'a>(self) -> PeripheralRef<'a, Self::P>

where Self: 'a,

Convert a value into a PeripheralRef.

fn map_into<U>(self) -> U

where Self::P: Into<U>, U: Peripheral<P = U>,

Map the peripheral using Into.

impl<P: Pin> Pin for Flex<'_, P>

fn number(&self) -> u8

GPIO number

fn degrade(self) -> AnyPin

where Self: Sized,

Type-erase (degrade) this pin into an AnyPin.

impl<P: RtcPin> RtcPin for Flex<'_, P>

fn rtc_set_config(&mut self, input_enable: bool, mux: bool, func: RtcFunction)

Configure the pin

fn rtcio_pad_hold(&mut self, enable: bool)

Enable or disable PAD_HOLD

unsafe fn apply_wakeup(&mut self, wakeup: bool, level: u8)

Safety

impl<P: RtcPinWithResistors> RtcPinWithResistors for Flex<'_, P>

fn rtcio_pullup(&mut self, enable: bool)

Enable/disable the internal pull-up resistor

fn rtcio_pulldown(&mut self, enable: bool)

Enable/disable the internal pull-down resistor

impl<P> StatefulOutputPin for Flex<'_, P>

where P: InputPin + OutputPin,

fn is_set_high(&self) -> Result<bool, Self::Error>

Is the pin in drive high mode?

fn is_set_low(&self) -> Result<bool, Self::Error>

Is the pin in drive low mode?

impl<P> StatefulOutputPin for Flex<'_, P>

where P: OutputPin,

fn is_set_high(&mut self) -> Result<bool, Self::Error>

Is the pin in drive high mode?

fn is_set_low(&mut self) -> Result<bool, Self::Error>

Is the pin in drive low mode?

fn toggle(&mut self) -> Result<(), Self::Error>

Toggle pin output.

impl<P> ToggleableOutputPin for Flex<'_, P>

where P: InputPin + OutputPin,

type Error = Infallible

Error type

fn toggle(&mut self) -> Result<(), Self::Error>

Toggle pin output.

impl<P> Wait for Flex<'_, P>

where P: InputPin,

async fn wait_for_high(&mut self) -> Result<(), Self::Error>

Wait until the pin is high. If it is already high, return immediately.

async fn wait_for_low(&mut self) -> Result<(), Self::Error>

Wait until the pin is low. If it is already low, return immediately.

async fn wait_for_rising_edge(&mut self) -> Result<(), Self::Error>

Wait for the pin to undergo a transition from low to high.

async fn wait_for_falling_edge(&mut self) -> Result<(), Self::Error>

Wait for the pin to undergo a transition from high to low.

async fn wait_for_any_edge(&mut self) -> Result<(), Self::Error>

Wait for the pin to undergo any transition, i.e low to high OR high to low.

impl<P: InputPin> PeripheralInput for Flex<'static, P>

impl<P: OutputPin> PeripheralOutput for Flex<'static, P>