Struct InputPin

pub struct InputPin { /* private fields */ }

Provides the embedded_hal::digital and embedded_hal_async::digital::Wait traits for a gpiocdev::Request containing a single input pin using the async-io reactor.

Holding the InputPin grants exclusive access to the pin.

Do NOT drop the InputPin until you are completely done with it. Dropping and re-requesting the line is far more expensive than getting the value.

Implementations

impl InputPin

pub fn new<P>(chip: P, offset: u32) -> Result<Self, Error>

where P: AsRef<Path>,

Creates a new input pin for the given offset on the given chip.

use embedded_hal::digital::InputPin;
use embedded_hal_async::digital::Wait;

let mut pin = gpiocdev_embedded_hal::async_io::InputPin::new("/dev/gpiochip0", 4)?;
if pin.is_high()? {
    println!("Input is high.");
}
pin.wait_for_falling_edge().await?;

pub fn into_output_pin(self, state: PinState) -> Result<OutputPin, Error>

Set this pin to output mode.

Trait Implementations

impl ErrorType for InputPin

type Error = Error

Errors returned by the InputPin.

impl From<InputPin> for InputPin

fn from(pin: InputPin) -> Self

Convert a synchronous InputPin into an async_io InputPin.

impl From<InputPin> for InputPin

fn from(pin: InputPin) -> Self

Convert an async_io InputPin into a synchronous InputPin.

impl From<InputPin> for Request

fn from(pin: InputPin) -> Self

Convert the InputPin into the contained Request.

impl InputPin for 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 Wait for InputPin

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

Wait for the pin to go high.

Note

The implementation is event driven, and only looks for events when waiting for the level to change. If the returned future resolves then subsequent calls are effectively a no-op. Wait on an edge or the pin to go low instead.

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

Wait for the pin to go low.

Note

The implementation is event driven, and only looks for events when waiting for the level to change. If the returned future resolves then subsequent calls are effectively a no-op. Wait on an edge or the pin to go high instead.

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.