Crate tokio_gpiod

Source
Expand description

§libgpiod in Rust for tokio

github crate docs MIT CI

Rust crate for interfacing with Linux GPIO character devices. This crate supports tokio 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 ABI v1 (linux >= 4.0) and v2 (linux >= v5.10) supported but edge detection implemented for v2 only. Deprecated sysfs-based API (linux < 4.0) currently is not supported at all.

§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-gpiod - async interface to use with non-tokio async runtimes

§Usage examples

Input values:

use tokio_gpiod::{Chip, Options};

#[tokio::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 tokio_gpiod::{Chip, Options};

#[tokio::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 tokio_gpiod::{Chip, Options, EdgeDetect};

#[tokio::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