Struct rppal::gpio::InputPin[−][src]

pub struct InputPin { /* fields omitted */ }

Expand description

GPIO pin configured as input.

InputPins are constructed by converting a Pin using Pin::into_input, Pin::into_input_pullup or Pin::into_input_pulldown. The pin’s mode is automatically set to Input.

An InputPin can be used to read a pin’s logic level, or (a)synchronously poll for interrupt trigger events.

The unproven embedded-hal digital::InputPin trait implementation for InputPin can be enabled by specifying the optional hal-unproven feature in the dependency declaration for the rppal crate.

Implementations

[src]

impl InputPin

[src]

pub fn pin(&self) -> u8

Returns the GPIO pin number.

Pins are addressed by their BCM numbers, rather than their physical location.

[src]

pub fn read(&self) -> Level

Reads the pin’s logic level.

[src]

pub fn is_low(&self) -> bool

Reads the pin’s logic level, and returns true if it’s set to Low.

[src]

pub fn is_high(&self) -> bool

Reads the pin’s logic level, and returns true if it’s set to High.

[src]

pub fn set_interrupt(&mut self, trigger: Trigger) -> Result<()>

Configures a synchronous interrupt trigger.

After configuring a synchronous interrupt trigger, call poll_interrupt or Gpio::poll_interrupts to block while waiting for a trigger event.

Any previously configured (a)synchronous interrupt triggers will be cleared.

[src]

pub fn clear_interrupt(&mut self) -> Result<()>

Removes a previously configured synchronous interrupt trigger.

[src]

pub fn poll_interrupt(
 &mut self,
 reset: bool,
 timeout: Option<Duration>
) -> Result<Option<Level>>

Blocks until an interrupt is triggered on the pin, or a timeout occurs.

This only works after the pin has been configured for synchronous interrupts using set_interrupt. Asynchronous interrupt triggers are automatically polled on a separate thread.

Calling poll_interrupt blocks any other calls to poll_interrupt (including on other InputPins) or Gpio::poll_interrupts until it returns. If you need to poll multiple pins simultaneously, use Gpio::poll_interrupts to block while waiting for any of the interrupts to trigger, or switch to using asynchronous interrupts with set_async_interrupt.

Setting reset to false returns any cached interrupt trigger events if available. Setting reset to true clears all cached events before polling for new events.

The timeout duration indicates how long the call will block while waiting for interrupt trigger events, after which an Ok(None)) is returned. timeout can be set to None to wait indefinitely.

[src]

pub fn set_async_interrupt<C>(
 &mut self,
 trigger: Trigger,
 callback: C
) -> Result<()> where
 C: FnMut(Level) + Send + 'static,

Configures an asynchronous interrupt trigger, which executes the callback on a separate thread when the interrupt is triggered.

The callback closure or function pointer is called with a single Level argument.

Any previously configured (a)synchronous interrupt triggers for this pin are cleared when set_async_interrupt is called, or when InputPin goes out of scope.

[src]

pub fn clear_async_interrupt(&mut self) -> Result<()>

Removes a previously configured asynchronous interrupt trigger.

[src]

pub fn reset_on_drop(&self) -> bool

Returns the value of reset_on_drop.

[src]

pub fn set_reset_on_drop(&mut self, reset_on_drop: bool)

When enabled, resets the pin’s mode to its original state and disables the built-in pull-up/pull-down resistors when the pin goes out of scope. By default, this is set to true.

Note

Drop methods aren’t called when a process is abnormally terminated, for instance when a user presses Ctrl + C, and the SIGINT signal isn’t caught. You can catch those using crates such as simple_signal.