Struct ExtInt

pub struct ExtInt<P, Id, F = NoneT>
where
    P: EicPin,
    Id: ChId,
{ /* private fields */ }

A numbered external interrupt, which can be used to sense state changes on its pin.

Implementations

impl<P, Id> ExtInt<P, Id, NoneT>

where P: EicPin, Id: ChId,

pub fn into_future<I>(self, _irq: I) -> ExtInt<P, Id, EicFuture>

where I: Binding<P::InterruptSource, InterruptHandler>, InterruptHandler: Handler<P::InterruptSource>,

Turn an EIC pin into a pin usable as a Future. The correct interrupt source is needed.

impl<P, Id> ExtInt<P, Id, EicFuture>

where P: EicPin, Self: InputPin<Error = Infallible>, Id: ChId,

pub async fn wait(&mut self, sense: Sense)

impl<P, Id, F> ExtInt<P, Id, F>

where P: EicPin, Id: ChId,

pub fn enable_event(&mut self)

pub fn enable_interrupt(&mut self)

pub fn disable_interrupt(&mut self)

pub fn is_interrupt(&mut self) -> bool

pub fn state(&mut self) -> bool

pub fn clear_interrupt(&mut self)

pub fn sense(&mut self, sense: Sense)

pub fn filter(&mut self, filter: bool)

pub fn debounce(&mut self)

Enable debouncing for this pin, with a configuration appropriate for debouncing physical buttons.

impl<P, Id, F> ExtInt<P, Id, F>

where P: EicPin, Id: ChId,

pub fn free(self) -> (Pin<P::Id, P::Mode>, Channel<Id, F>)

Release the underlying resources: Pin and Channel.

Trait Implementations

impl<P, Id, F> ErrorType for ExtInt<P, Id, F>

where P: EicPin, Id: ChId,

type Error = Infallible

Error type

impl<P, C, Id, F> InputPin for ExtInt<P, Id, F>

where P: EicPin + AnyPin<Mode = Interrupt<C>>, C: InterruptConfig, Id: ChId,

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, Id, F> InputPin for ExtInt<P, Id, F>

where Self: ErrorType, P: EicPin, Id: ChId,

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, Id> Wait for ExtInt<P, Id, EicFuture>

where P: EicPin, Self: InputPin<Error = Infallible>, Id: ChId,

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.