Crate async_std_gpiod

Expand description

§libgpiod in Rust for async-std

Rust crate for interfacing with Linux GPIO character devices. This crate supports async-std async runtime.

It provides an interface to the Linux GPIO using the chardev module. This interface involves calling ioctl funcions which are unsafe and require some unintuitive variable mapping. To ease this process, this crate provides a Chip struct which encapsulates the interface in safe Rust functions. The functionality provided here is highly inspired by libgpiod.

Since all functionality is dependent on Linux function calls, this crate only compiles for Linux systems.

§ABI compatibility

Both v1 (>= 4.0) and v2 (>= v5.10) ABI currently supported but edge detection implemented for v2 only. Sysfs-based API (< 4.0) does not supported.

§Crates

gpiod-core - core abstractions and low level interface (not for end users)
gpiod - sync interface which supports synchronous operation only
tokio-gpiod - async interface for tokio fans
async-std-gpiod - async interface for async-std fans

§Usage examples

Input values:

use async_std_gpiod::{Chip, Options};

#[async_std::main]
async fn main() -> std::io::Result<()> {
    let chip = Chip::new("gpiochip0").await?; // open chip

    let opts = Options::input([27, 3, 11]) // configure lines offsets
        .consumer("my-inputs"); // optionally set consumer string

    let inputs = chip.request_lines(opts).await?;

    let values = inputs.get_values([false; 3]).await?;

    println!("values: {:?}", values);

    Ok(())
}

Output values:

use async_std_gpiod::{Chip, Options};

#[async_std::main]
async fn main() -> std::io::Result<()> {
    let chip = Chip::new("gpiochip0").await?; // open chip

    let opts = Options::output([9, 21]) // configure lines offsets
        .values([false, true]) // optionally set initial values
        .consumer("my-outputs"); // optionally set consumer string

    let outputs = chip.request_lines(opts).await?;

    outputs.set_values([true, false]).await?;

    Ok(())
}

Monitor values:

use async_std_gpiod::{Chip, Options, EdgeDetect};

#[async_std::main]
async fn main() -> std::io::Result<()> {
    let chip = Chip::new("gpiochip0").await?; // open chip

    let opts = Options::input([4, 7]) // configure lines offsets
        .edge(EdgeDetect::Both) // configure edges to detect
        .consumer("my-inputs"); // optionally set consumer string

    let mut inputs = chip.request_lines(opts).await?;

    loop {
        let event = inputs.read_event().await?;

        println!("event: {:?}", event);
    }

    Ok(())
}

Structs§

Chip: A Linux chardev GPIO chip interface
ChipInfo: GPIO chip interface info
Event: Signal edge detection event
Input: Input direction
LineInfo: The information of a specific GPIO line
Lines: The interface for getting the values of GPIO lines configured for input
Masked: Line values with mask
Options: GPIO line values request options
Output: Output direction
ValuesInfo: GPIO lines values interface info

Enums§

Active: Active state condition of a line
Bias: Input bias of a GPIO line
Direction: Direction of a GPIO line
Drive: Output drive mode of a GPIO line
Edge: Signal edge or level transition of a GPIO line
EdgeDetect: Edge detection setting for GPIO line

Constants§

MAX_BITS: Maximum number of bits which can be get or set per time
MAX_VALUES: Maximum number of values which can be get or set per time

Traits§

AsValues: Something that can be used to get GPIO line values
AsValuesMut: Something that can be used to get and set GPIO line values
DirectionType: Direction trait

Type Aliases§

BitId: Bit offset
LineId: Line offset
Values: Default values representation

Crate async_std_gpiodCopy item path