Struct Input

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

Digital input.

This driver configures the GPIO pin to be an input. Input drivers read the voltage of their pins and convert it to a logical Level.

Implementations

impl<P> Input<'_, 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> Input<'d>

pub fn new(pin: impl Peripheral<P = impl InputPin> + 'd, pull: Pull) -> Self

Creates a new, type-erased GPIO input.

The pull parameter configures internal pull-up or pull-down resistors.

Example

The following example configures GPIO5 to read a button press. The example assumes that the button is connected such that the pin is low when the button is pressed.

use esp_hal::gpio::{Level, Input, Pull};
use esp_hal::delay::Delay;

fn print_when_pressed(button: &mut Input<'_>, delay: &mut Delay) {
    let mut was_pressed = false;
    loop {
        let is_pressed = button.is_low();
        if is_pressed && !was_pressed {
            println!("Button pressed!");
        }
        was_pressed = is_pressed;
        delay.delay_millis(100);
    }
}

let mut button = Input::new(
    peripherals.GPIO5,
    Pull::Up,
);
let mut delay = Delay::new();

print_when_pressed(&mut button, &mut delay);

impl<'d, P> Input<'d, P>

where P: InputPin,

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

Creates a new, typed GPIO input.

The pull parameter configures internal pull-up or pull-down resistors.

This constructor is useful when you want to limit which GPIO pin can be used for a particular function.

Example

The following example configures GPIO5 to read a button press. The example assumes that the button is connected such that the pin is low when the button is pressed.

use esp_hal::gpio::{GpioPin, Level, Input, Pull};
use esp_hal::delay::Delay;

fn print_when_pressed(
    button: &mut Input<'_, GpioPin<5>>,
    delay: &mut Delay,
) {
    let mut was_pressed = false;
    loop {
        let is_pressed = button.is_low();
        if is_pressed && !was_pressed {
            println!("Button pressed!");
        }
        was_pressed = is_pressed;
        delay.delay_millis(100);
    }
}

let mut button = Input::new_typed(
    peripherals.GPIO5,
    Pull::Up,
);
let mut delay = Delay::new();

print_when_pressed(&mut button, &mut delay);

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.

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> Input<'_, P>

where P: InputPin + OutputPin,

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 Input<'_, P>

where P: InputPin,

type Error = Infallible

Error type

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

where P: InputPin,

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 Input<'_, 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<'d, P> Peripheral for Input<'d, P>

type P = Flex<'d, 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> Wait for Input<'_, 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.