#linux-gpio #tokio #gpio #linux #libgpiod #async

tokio-gpiod

Linux GPIO character device interfacing with tokio

4 releases

0.3.0 May 11, 2024
0.2.3 Jan 21, 2023
0.2.2 Oct 15, 2022
0.2.1 Sep 15, 2022
0.2.0 Jul 31, 2022

#507 in Unix APIs

Download history 508/week @ 2024-01-30 644/week @ 2024-02-06 974/week @ 2024-02-13 1048/week @ 2024-02-20 1034/week @ 2024-02-27 476/week @ 2024-03-05 902/week @ 2024-03-12 922/week @ 2024-03-19 568/week @ 2024-03-26 1195/week @ 2024-04-02 650/week @ 2024-04-09 415/week @ 2024-04-16 533/week @ 2024-04-23 521/week @ 2024-04-30 478/week @ 2024-05-07 715/week @ 2024-05-14

2,357 downloads per month
Used in boardswarm

MIT license

83KB
2K SLoC

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(())
}

Dependencies

~4–16MB
~150K SLoC