GNU/Linux - 使用字符设备来操作GPIO

从 4.8 版开始，Linux 内核引入了基于字符设备的新用户空间 API，用于管理和控制 GPIO（通用输入/输出）。这篇文章介绍了新接口的基本原理，并通过一个简单的教程/示例演示了如何使用新 API 控制 GPIO。

教程中使用的硬件是 Raspberry Pi 3B，但代码是通用的，可用于任何嵌入式硬件。

From the version 4.8, the Linux kernel introduces a new user space API based on character devices for managing and controlling GPIOs ( General-Purpose Input/Output). This post presents the basic of the new interface as well as a simple tutorial/example to demonstrate how to use the new API to control GPIOs.

The hardware used in the tutorial is the Raspberry Pi 3B but the code is generic and can be used on any embedded hardware.

The old user space interface

在 Linux 内核 4.8 之前，在用户空间管理 GPIO 的唯一接口是 sysfs 接口。GPIO 通过 /sys/class/gpio 中的导出文件进行配置和控制。可通过该接口执行 GPIO 的基本操作：

  • 通过 /sys/class/gpio/export 导出 GPIO

  • 通过 /sys/class/gpio/export 配置 GPIO 方向（输入/输出）： 通过： /sys/class/gpio/gpioX/direction 配置 GPIO 方向（输入/输出

  • 通过 /sys/class/gpio/gpioX/value 读写 GPIO 值

该接口简单易用，但也有一些缺点：

  • 缺乏批量 GPIO 读写功能，GPIO 配置选项有限（例如：无法将 GPIO 配置为低电平有效、漏极开路、开源等）。

  • 当两个或多个进程同时访问同一个 GPIO 时，可能会出现竞赛条件问题。

  • 从 GPIO 轮询事件不可靠

  • 等等。

Before the Linux kernel 4.8, the only interface to manage GPIO in user space is the sysfs interface. GPIOs are configured and controlled via exported files in /sys/class/gpio. Basic GPIO operations that can be performed via this interface:

* Export a GPIO via /sys/class/gpio/export

* Configure the GPIO direction (input/output) via: /sys/class/gpio/gpioX/direction

* Read/write GPIO value via /sys/class/gpio/gpioX/value

This interface is simple and easy to use but it has some drawbacks:

* Lack of bulk GPIO reads and writes, GPIO configuration options are limited (for example: unable to configure a GPIO as Active low, open drain, open source etc.)

* Race condition problems may occur when two or more processes accessing the same GPIO at the same time.

* Polling event from GPIO is not reliable

* etc.

The new Character Device interface

自 4.8 版起，Linux 内核引入了基于字符设备的新用户空间 GPIO 接口。用户空间的 GPIO 控制器接口以字符设备的形式提供： /dev/gpiochipX。基本的文件操作，如 open()、read()、write()、ioctl()、poll()、close()，都可以用来与 GPIO 控制器交互。

本节将详细介绍如何使用这一新 API，通过 ioctl 接口配置和控制 GPIO。

基本上，要与 GPIO 控制器交互，我们首先需要使用传统的文件打开操作打开字符设备：

Since version 4.8, Linux kernel introduces a new user-space GPIO interface based on character device. Interface to the GPIO controller is available in user space in form of a character device: /dev/gpiochipX. Basic file operations such as open(), read(), write(), ioctl(), poll(), close() can be used to interact with the GPIO controller.

This section will detail on how to use this new API to configure and control GPIO via the ioctl interface.

Basically, to interact with the GPIO controller, we first need to open character device using the traditional file open operation:

// include API header for the new interface

#include <linux/gpio.h>

#include <unistd.h>

#include <fcntl.h>

#include <string.h>

#include <errno.h>

#include <sys/ioctl.h>

#include <stdint.h>

#include <stdlib.h>

#define DEV_NAME "/dev/gpiochip0"

void func()

{

    int fd, ret;

    fd = open(DEV_NAME, O_RDONLY);

    if (fd < 0)

    {

        printf("Unabled to open %%s: %%s", dev_name, strerror(errno));

        return;

    }

    /*

        control GPIO here, such as:

        - configure

        - read

        - write

        - polling

    */

    (void)close(fd);

}

请注意，我们以只读模式打开字符设备 /dev/gpiochip0，所有 GPIO 控制操作都将在打开的文件描述符 fd 上执行。

Note that we open the character device /dev/gpiochip0 in read only mode, all GPIO control operations will be performed on the opened file descriptor fd.

本教程包括以下操作：

  • 读取 GPIO 芯片和线路信息

  • GPIO 读写操作（批量模式）。

  • GPIO 事件轮询

This tutorial covers the following operations:

* GPIO chip and lines information reading

* GPIO read and write operations (in bulk mode).

* GPIO event polling

通过 IOCTL 接口获取 GPIO 芯片信息

GPIO 芯片信息存储在一个结构类型为 gpiochip_info 的结构中，可通过 IOCTL GPIO_GET_CHIPINFO_IOCTL 请求进行查询：

Get GPIO chip information via the IOCTL interface

GPIO chip information is stored in a structure of type struct gpiochip_info and can be queried via the IOCTL GPIO_GET_CHIPINFO_IOCTL request:

struct gpiochip_info info;

struct gpioline_info line_info;

int fd, ret;

// open the device

fd = open(DEV_NAME, O_RDONLY);

if (fd < 0)

{

    printf("Unabled to open %%s: %%s", dev_name, strerror(errno));

    return;

}

// Query GPIO chip information

ret = ioctl(fd, GPIO_GET_CHIPINFO_IOCTL, &info);

if (ret == -1)

{

    printf("Unable to get chip info from ioctl: %%s", strerror(errno));

    close(fd);

    return;

}

printf("Chip name: %%s\n", info.name);

printf("Chip label: %%s\n", info.label);

printf("Number of lines: %%d\n", info.lines);

在第 13 行，我们使用 IOCTL 接口（GPIO_GET_CHIPINFO_IOCTL 请求）从内核中查询芯片信息。结构信息包含芯片名称、芯片标签，以及重要的 GPIO 线路数。在此基础上，我们可以通过对文件描述符发出 IOCTL GPIO_GET_LINEINFO_IOCTL 请求，进一步查询各 GPIO 线路的状态。每个 GPIO 的线路信息都存储在一个结构类型为 struct gpioline_info 的结构中：

On line 13 we query the chip info from the kernel using the IOCTL interface (GPIO_GET_CHIPINFO_IOCTL request). The structure info contains the chip name, the chip label, and importantly the number of GPIO lines. From here, we can further query the state of each GPIO lines by issuing the IOCTL GPIO_GET_LINEINFO_IOCTL request on the file descriptor. The line information for each GPIO is stored in a structure of type: struct gpioline_info:

struct gpioline_info line_info;

for (int i = 0; i < info.lines; i++)

{

    line_info.line_offset = i;

    ret = ioctl(fd, GPIO_GET_LINEINFO_IOCTL, &line_info);

    if (ret == -1)

    {

        printf("Unable to get line info from offset %%d: %%s", i, strerror(errno));

    }

    else

    {

        printf("offset: %%d, name: %%s, consumer: %%s. Flags:\t[%%s]\t[%%s]\t[%%s]\t[%%s]\t[%%s]\n",

               i,

               line_info.name,

               line_info.consumer,

               (line_info.flags & GPIOLINE_FLAG_IS_OUT) ? "OUTPUT" : "INPUT",

               (line_info.flags & GPIOLINE_FLAG_ACTIVE_LOW) ? "ACTIVE_LOW" : "ACTIVE_HIGHT",

               (line_info.flags & GPIOLINE_FLAG_OPEN_DRAIN) ? "OPEN_DRAIN" : "...",

               (line_info.flags & GPIOLINE_FLAG_OPEN_SOURCE) ? "OPENSOURCE" : "...",

               (line_info.flags & GPIOLINE_FLAG_KERNEL) ? "KERNEL" : "");

    }

}

在第 4 行，我们将 line_info 结构的 line_offset 属性设置为要查询的 GPIO 线路/偏移量，然后通过 GPIO_GET_LINEINFO_IOCTL 请求调用 ioctl 函数。

下面是在 Raspberry Pi 3B+ 上执行代码的输出示例：

On line 4, we set the line_offset property of the structure line_info to the GPIO line/offset that we want to query before calling the ioctl function with the GPIO_GET_LINEINFO_IOCTL request.

Below is the example output of the code executed on a Raspberry Pi 3B+:

Chip name: gpiochip0

Chip label: pinctrl-bcm2835

Number of lines: 54

offset: 0, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 1, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 2, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 3, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 4, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 5, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 6, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 7, name: , consumer: spi0 CS1. Flags:    [OUTPUT]    [ACTIVE_LOW]    [...]    [...]    [KERNEL]

offset: 8, name: , consumer: spi0 CS0. Flags:    [OUTPUT]    [ACTIVE_LOW]    [...]    [...]    [KERNEL]

offset: 9, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 10, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 11, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 12, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 13, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 14, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 15, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 16, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 17, name: , consumer: ads7846_pendown. Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    [KERNEL]

offset: 18, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 19, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 20, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 21, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 22, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 23, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 24, name: , consumer: dc. Flags:    [OUTPUT]    [ACTIVE_HIGHT]    [...]    [...]    [KERNEL]

offset: 25, name: , consumer: reset. Flags:    [OUTPUT]    [ACTIVE_LOW]    [...]    [...]    [KERNEL]

offset: 26, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 27, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 28, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 29, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 30, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 31, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 32, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 33, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 34, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 35, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 36, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 37, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 38, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 39, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 40, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 41, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 42, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 43, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 44, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 45, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 46, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 47, name: , consumer: . Flags:    [OUTPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 48, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 49, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 50, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 51, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 52, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

offset: 53, name: , consumer: . Flags:    [INPUT]    [ACTIVE_HIGHT]    [...]    [...]    []

问题：GPIO 偏移（bcm2835）与 raspberry Pi 的物理引脚输出之间的映射关系是什么？

如果我们看一下树莓派的引脚布局：

这里的偏移量对应于上述模式中的 BCMx 引脚。例如，偏移量 17 对应 BCM 17（物理引脚 11）。

Question: what is exactly the mapping between GPIO offsets (bcm2835) and the physical pinout of the raspberry Pi ?

Well, if we look at the Raspberry pinout:

The offsets here correspond to the BCMx pins on the schema above. For example the offset 17 correspond to the BCM 17 (physical pin 11)

(批量）通过 IOCTL 接口向输出 GPIO 写值

假设我们要将引脚 11 和 13（BCM 17 和 BCM 27）配置为 OUTPUT，并在引脚 11 上写入高电平 (1)，在引脚 13 上写入低电平 (0)。

新的 API 允许以批量模式执行配置、读取和写入操作，它可以在单个 IOCTL 请求中处理多个 GPIO 线路。

(Bulk) Writing values to output GPIOs via the IOCTL interface

Let say we want to configure pin 11 and 13 (BCM 17 and BCM 27) as OUTPUT and we want to write HIGH (1) on pin 11 and LOW (0) on pin 13.

The new API allows to perform configuration, read and write operation in bulk mode, it can handle multiple GPIO lines in a single IOCTL request.

基本上，要向 GPIO 写入数值，我们首先需要将其配置为 OUTPUT。具体方法如下：

  • 在结构类型为 struct gpiohandle_request 的结构中填写配置值

  • 通过 IOCTL 接口向 GPIO 控制器发出 GPIO_GET_LINEHANDLE_IOCTL，请求获得已配置 GPIO 的线路句柄

Basically, to write values to GPIOs, we first need to configured them as OUTPUTs. This can be done by :

* Filling configuration values in a struct of type struct gpiohandle_request

* Issuing a GPIO_GET_LINEHANDLE_IOCTL to the GPIO controller via the IOCTL interface to request a lines handle of the configured GPIOs

// open the device

fd = ...

...

struct gpiohandle_request rq;

rq.lineoffsets[0] = 17;

rq.lineoffsets[1] = 27;

rq.lines = 2;

rq.flags = GPIOHANDLE_REQUEST_OUTPUT;

ret = ioctl(fd, GPIO_GET_LINEHANDLE_IOCTL, &rq);

close(fd);

if (ret == -1)

{

    printf("Unable to line handle from ioctl : %%s", strerror(errno));

    close(fd);

    return;

}

在 rq 结构中，我们需要指定要配置的行数（偏移 17 和偏移 27）以及行标志。在本例中，我们使用 GPIOHANDLE_REQUEST_OUTPUT 标志将两行（17 和 27）配置为输出。

如果 IOCTL GPIO_GET_LINEHANDLE_IOCTL 请求成功，单行句柄将以文件描述符（rq.fd）的形式设置到结构 rq（struct gpiohandle_request）的属性 fd 中。该文件描述符用于向配置的 GPIO 写入值。现在可以安全关闭设备文件 (fd) 描述符。

要向两个 GPIO 写入数值，只需将数值填入一个 struct gpiohandle_data 类型的结构，然后在行句柄文件描述符上使用该结构执行一个 IOCTL GPIOHANDLE_SET_LINE_VALUES_IOCTL请求

In the structure rq, we need to specify which lines (offset 17, offset 27) and the number of lines we want to configured as well as the lines flags. In this case we use the flag GPIOHANDLE_REQUEST_OUTPUT to configure the two lines (17 and 27) as outputs.

If the IOCTL GPIO_GET_LINEHANDLE_IOCTL request successes, a single lines handle is set to the property fd of the structure rq (struct gpiohandle_request) in form of a file descriptor (rq.fd). This file descriptor should be used to write values to the configured GPIOs. The device file (fd) descriptor can now be safety closed.

To write values to the two GPIOs, simply fill the values to a structure of type struct gpiohandle_data, then perform a IOCTL GPIOHANDLE_SET_LINE_VALUES_IOCTL request with this structure on the lines handle file descriptor

struct gpiohandle_data data;

data.values[0] = 1; // HIGH offset 17

data.values[1] = 0; // LOW offset 27

ret = ioctl(rq.fd, GPIOHANDLE_SET_LINE_VALUES_IOCTL, &data);

if (ret == -1)

{

    printf("Unable to set line value using ioctl : %%s", strerror(errno));

}

// do something else

close(rq.fd);

(Bulk) reading input GPIOs values via the IOCTL interface [(批量）通过 IOCTL 接口读取输入 GPIO 值]

GPIO 的读取操作遵循与写入操作相同的原则。所需的修改如下:

  • 用 GPIOHANDLE_REQUEST_INPUT 代替 GPIOHANDLE_REQUEST_OUTPUT

  • 用 GPIOHANDLE_GET_LINE_VALUES_IOCTL 代替 GPIOHANDLE_SET_LINE_VALUES_IOCTL

The GPIOs reading operation follows the same principle as the writing operation. The modifications necessary are to:

* Replace GPIOHANDLE_REQUEST_OUTPUT with GPIOHANDLE_REQUEST_INPUT

* Replace GPIOHANDLE_SET_LINE_VALUES_IOCTL with GPIOHANDLE_GET_LINE_VALUES_IOCTL

struct gpiohandle_request rq;

struct gpiohandle_data data;

int fd, ret;

// open the device

fd = ...

...

rq.lineoffsets[0] = 17;

rq.lineoffsets[1] = 27;

rq.flags = GPIOHANDLE_REQUEST_INPUT;

rq.lines = 2;

ret = ioctl(fd, GPIO_GET_LINEHANDLE_IOCTL, &rq);

close(fd);

if (ret == -1)

{

    printf("Unable to get line handle from ioctl : %%s", strerror(errno));

    return;

}

ret = ioctl(rq.fd, GPIOHANDLE_GET_LINE_VALUES_IOCTL, &data);

if (ret == -1)

{

    printf("Unable to get line value using ioctl : %%s", strerror(errno));

}

else

{

    printf("Value of GPIO at offset 17: %%d and offset 27: %%d\n", data.values[0], data.values[1]);

}

close(rq.fd);

GPIO event polling

新 API 为使用传统轮询 API（文件描述符）轮询 GPIO 事件（如上升沿、下降沿或两个沿）提供了一种方便的方法。GPIO 事件轮询有两个基本步骤：

  • 以文件描述符的形式（通过 IOCTL 接口）请求 GPIO 线路上的事件句柄

  • 对该文件描述符执行传统轮询

下面的代码段请求偏移量 17（BCM 17）处 GPIO 的事件句柄。

The new API provides a convenient way to poll GPIO events such as raising edge, falling edge or both edges using the traditional polling API (on file descriptors). Two basic steps for GPIO event polling:

* Request the event handle on a GPIO line in form of a file descriptor (via the IOCTL interface)

* Perform traditional polling on that file descriptor

The following snippet requests a event handle on the GPIO at offset 17 (BCM 17).

#include <sys/poll.h>

...

struct gpioevent_request rq;

int fd, ret;

// open the device

fd = ...

rq.lineoffset = 17;

rq.eventflags = GPIOEVENT_EVENT_RISING_EDGE;

ret = ioctl(fd, GPIO_GET_LINEEVENT_IOCTL, &rq);

close(fd);

if (ret == -1)

{

    printf("Unable to get line event from ioctl : %%s", strerror(errno));

    close(fd);

    return;

}

请注意，在第 10 行和第 11 行，我们配置了事件句柄，以监听偏移 17 处 GPIO 上的上升沿事件 (GPIOEVENT_EVENT_RISING_EDGE)。

如果请求成功，行事件文件描述符将被设置为结构 rq（struct gpioevent_request）的 fd 属性。可以对该文件描述符 (rq.fd) 执行传统的轮询操作。

Note that on lines 10 and 11, we configure the event handle to listen to the rising edge event (GPIOEVENT_EVENT_RISING_EDGE) on the GPIO at offset 17.

If the request successes, the line event file descriptor is set to the fd property of the structure rq (struct gpioevent_request). The traditional polling operation can the be performed on this file descriptor (rq.fd).

struct pollfd pfd;

pfd.fd = rq.fd;

pfd.events = POLLIN;

ret = poll(&pfd, 1, -1);

if (ret == -1)

{

    printf("Error while polling event from GPIO: %%s", strerror(errno));

}

else if (pfd.revents & POLLIN)

{

    printf("Rising edge event on GPIO offset: %%d, of %%s\n", offset, dev_name);

}

close(rq.fd);

上面的代码只是简单地阻塞，直到事件被触发（轮询超时设置为-1）。请注意，轮询 API 可以同时轮询多个文件描述符，因此可以轮询多个 GPIO 线路上的事件。

The code above simply blocks until the event is triggered (polling timeout set to -1). Note that the polling API can poll multiple file descriptors at the same time, thus, it is able to poll events on multiple GPIO lines.

Final code

下面是本帖中介绍的所有 GPIO 操作的完整工作代码：

Bellow is the complete working code of all GPIO operations presented in this post:

#include <linux/gpio.h>

#include <unistd.h>

#include <fcntl.h>

#include <string.h>

#include <errno.h>

#include <sys/ioctl.h>

#include <stdio.h>

#include <stdint.h>

#include <getopt.h>

#include <stdlib.h>

#include <sys/poll.h>

typedef enum

{

    APP_OPT_GPIO_LIST,

    APP_OPT_GPIO_READ,

    APP_OPT_GPIO_WRITE,

    APP_OPT_GPIO_POLL,

    APP_OPT_UNKNOWN

} app_mode_t;

typedef struct

{

    char *dev;

    int offset;

    uint8_t val;

    app_mode_t mode;

} app_opt_t;

static void gpio_list(const char *dev_name)

{

    struct gpiochip_info info;

    struct gpioline_info line_info;

    int fd, ret;

    fd = open(dev_name, O_RDONLY);

    if (fd < 0)

    {

        printf("Unabled to open %%s: %%s", dev_name, strerror(errno));

        return;

    }

    ret = ioctl(fd, GPIO_GET_CHIPINFO_IOCTL, &info);

    if (ret == -1)

    {

        printf("Unable to get chip info from ioctl: %%s", strerror(errno));

        close(fd);

        return;

    }

    printf("Chip name: %%s\n", info.name);

    printf("Chip label: %%s\n", info.label);

    printf("Number of lines: %%d\n", info.lines);

    for (int i = 0; i < info.lines; i++)

    {

        line_info.line_offset = i;

        ret = ioctl(fd, GPIO_GET_LINEINFO_IOCTL, &line_info);

        if (ret == -1)

        {

            printf("Unable to get line info from offset %%d: %%s", i, strerror(errno));

        }

        else

        {

            printf("offset: %%d, name: %%s, consumer: %%s. Flags:\t[%%s]\t[%%s]\t[%%s]\t[%%s]\t[%%s]\n",

                   i,

                   line_info.name,

                   line_info.consumer,

                   (line_info.flags & GPIOLINE_FLAG_IS_OUT) ? "OUTPUT" : "INPUT",

                   (line_info.flags & GPIOLINE_FLAG_ACTIVE_LOW) ? "ACTIVE_LOW" : "ACTIVE_HIGHT",

                   (line_info.flags & GPIOLINE_FLAG_OPEN_DRAIN) ? "OPEN_DRAIN" : "...",

                   (line_info.flags & GPIOLINE_FLAG_OPEN_SOURCE) ? "OPENSOURCE" : "...",

                   (line_info.flags & GPIOLINE_FLAG_KERNEL) ? "KERNEL" : "");

        }

    }

    close(fd);

}

static void gpio_write(const char *dev_name, int offset, uint8_t value)

{

    struct gpiohandle_request rq;

    struct gpiohandle_data data;

    int fd, ret;

    printf("Write value %%d to GPIO at offset %%d (OUTPUT mode) on chip %%s\n", value, offset, dev_name);

    fd = open(dev_name, O_RDONLY);

    if (fd < 0)

    {

        printf("Unabled to open %%s: %%s", dev_name, strerror(errno));

        return;

    }

    rq.lineoffsets[0] = offset;

    rq.flags = GPIOHANDLE_REQUEST_OUTPUT;

    rq.lines = 1;

    ret = ioctl(fd, GPIO_GET_LINEHANDLE_IOCTL, &rq);

    close(fd);

    if (ret == -1)

    {

        printf("Unable to line handle from ioctl : %%s", strerror(errno));

        return;

    }

    data.values[0] = value;

    ret = ioctl(rq.fd, GPIOHANDLE_SET_LINE_VALUES_IOCTL, &data);

    if (ret == -1)

    {

        printf("Unable to set line value using ioctl : %%s", strerror(errno));

    }

    else

    {

         usleep(2000000);

    }

    close(rq.fd);

}

static void gpio_read(const char *dev_name, int offset)

{

    struct gpiohandle_request rq;

    struct gpiohandle_data data;

    int fd, ret;

    fd = open(dev_name, O_RDONLY);

    if (fd < 0)

    {

        printf("Unabled to open %%s: %%s", dev_name, strerror(errno));

        return;

    }

    rq.lineoffsets[0] = offset;

    rq.flags = GPIOHANDLE_REQUEST_INPUT;

    rq.lines = 1;

    ret = ioctl(fd, GPIO_GET_LINEHANDLE_IOCTL, &rq);

    close(fd);

    if (ret == -1)

    {

        printf("Unable to get line handle from ioctl : %%s", strerror(errno));

        return;

    }

    ret = ioctl(rq.fd, GPIOHANDLE_GET_LINE_VALUES_IOCTL, &data);

    if (ret == -1)

    {

        printf("Unable to get line value using ioctl : %%s", strerror(errno));

    }

    else

    {

        printf("Value of GPIO at offset %%d (INPUT mode) on chip %%s: %%d\n", offset, dev_name, data.values[0]);

    }

    close(rq.fd);

}

static void gpio_poll(const char *dev_name, int offset)

{

    struct gpioevent_request rq;

    struct pollfd pfd;

    int fd, ret;

    fd = open(dev_name, O_RDONLY);

    if (fd < 0)

    {

        printf("Unabled to open %%s: %%s", dev_name, strerror(errno));

        return;

    }

    rq.lineoffset = offset;

    rq.eventflags = GPIOEVENT_EVENT_RISING_EDGE;

    ret = ioctl(fd, GPIO_GET_LINEEVENT_IOCTL, &rq);

    close(fd);

    if (ret == -1)

    {

        printf("Unable to get line event from ioctl : %%s", strerror(errno));

        close(fd);

        return;

    }

    pfd.fd = rq.fd;

    pfd.events = POLLIN;

    ret = poll(&pfd, 1, -1);

    if (ret == -1)

    {

        printf("Error while polling event from GPIO: %%s", strerror(errno));

    }

    else if (pfd.revents & POLLIN)

    {

        printf("Rising edge event on GPIO offset: %%d, of %%s\n", offset, dev_name);

    }

    close(rq.fd);

}

static void help(const char *app)

{

    fprintf(stderr,

            "Usage: %%s options dev_name.\n"

            "Options:\n"

            "\t -i: print gpio chip info\n"

            "\t -r <offset>: Read GPIO value at offset (INPUT mode)\n"

            "\t -w <offset>: Write GPIO value at offset (OUTPUT mode). Option -v should be set\n"

            "\t -v <0|1>: value that should be written to the GPIO, used only with option -w\n"

            "\t -p <offset>: Polling raising event on the GPIO at offset\n",

            app);

}

int main(int argc, char *const *argv)

{

    int ret;

    app_opt_t opt;

    opt.val = 0;

    opt.dev = NULL;

    opt.mode = APP_OPT_UNKNOWN;

    while ((ret = getopt(argc, argv, "lr:w:p:v:")) != -1)

    {

        switch (ret)

        {

        case 'l':

            opt.mode = APP_OPT_GPIO_LIST;

            break;

        case 'r':

            opt.mode = APP_OPT_GPIO_READ;

            opt.offset = atoi(optarg);

            break;

        case 'w':

            opt.mode = APP_OPT_GPIO_WRITE;

            opt.offset = atoi(optarg);

            break;

        case 'v':

            opt.val = (uint8_t)atoi(optarg);

            break;

        case 'p':

            opt.mode = APP_OPT_GPIO_POLL;

            opt.offset = atoi(optarg);

            break;

        default:

            help(argv[0]);

            return -1;

        }

    }

    if (optind >= argc || opt.mode == APP_OPT_UNKNOWN)

    {

        help(argv[0]);

        return -1;

    }

    opt.dev = argv[optind];

    switch (opt.mode)

    {

    case APP_OPT_GPIO_LIST:

        gpio_list(opt.dev);

        break;

    case APP_OPT_GPIO_WRITE:

        gpio_write(opt.dev, opt.offset, opt.val);

        break;

    case APP_OPT_GPIO_READ:

        gpio_read(opt.dev, opt.offset);

        break;

    case APP_OPT_GPIO_POLL:

        gpio_poll(opt.dev, opt.offset);

        break;

    default:

        help(argv[0]);

        return -1;

    }

    return 0;

}

参考；

Control GPIO using the new Linux user space GPIO API (lxsang.me)

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/pingmian/27008.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

一篇文章教你学会如何用云服务器搭建https网站

一篇文章教你学会如何用云服务器搭建https网站

首先我们要明白为什么要通过云服务器来搭建https网站&#xff0c;这是因为通过使用云服务器搭建 HTTPS 网站&#xff0c;可以为我们提供更高的安全性和信任度。 一&#xff0c;前期的准备工作分为三大类&#xff1a;一台云服务器&#xff0c;域名&#xff0c;SSL证书&#xff1…
阅读更多...
ESP8266发送WOL幻数据包实现电脑远程唤醒

ESP8266发送WOL幻数据包实现电脑远程唤醒

计算机远程唤醒&#xff08;Wake-on-LAN, WOL&#xff09; 计算机远程唤醒&#xff08;Wake-on-LAN&#xff0c;简称 WOL&#xff09;是一种局域网唤醒技术&#xff0c;可以将局域网内处于关机或休眠状态的计算机唤醒至引导&#xff08;Boot Loader&#xff09;或运行状态。无…
阅读更多...
RAG 实践-Ollama+AnythingLLM 搭建本地知识库

RAG 实践-Ollama+AnythingLLM 搭建本地知识库

什么是 RAG RAG&#xff0c;即检索增强生成&#xff08;Retrieval-Augmented Generation&#xff09;&#xff0c;是一种先进的自然语言处理技术架构&#xff0c;它旨在克服传统大型语言模型&#xff08;LLMs&#xff09;在处理开放域问题时的信息容量限制和时效性不足。RAG的…
阅读更多...
pg——psql命令行交互式客户端工具

pg——psql命令行交互式客户端工具

1、启动数据库 ./pg_ctl -D /usr/local/pgsql/data/ -l /usr/local/pgsql/log 2、登录数据库 psql template1 3、查看所有数据库 \l 4、创建数据库 create database testdb; 5、连接某数据库 \c 数据库 6、查看数据下的表 \d 7、 查看数据库下的所有schema \dn 8、查看表的结构…
阅读更多...
BSV及BTC减半来袭，Teranode如何确保节点未来依然有足够的收入

BSV及BTC减半来袭，Teranode如何确保节点未来依然有足够的收入

​​发表时间&#xff1a;2024年4月12日 随着BTC第四次区块奖励减半的完成&#xff0c;加密资产行业正处于某种程度的狂热之中。这使得与扩容以及经济可持续性相关的讨论日益增加。 BTC价格的波动性强是众所周知的&#xff0c;经常几分钟内价格突然飙升或急速下跌&#xff0c;…
阅读更多...
wmv转换mp4怎么操作？3个格式转换方法分享

wmv转换mp4怎么操作？3个格式转换方法分享

wmv转换mp4怎么操作&#xff1f;将WMV转换为MP4格式&#xff0c;可以方便我们在多种设备和平台上流畅播放视频。MP4格式具有广泛的兼容性和优化过的编码&#xff0c;使其在各种媒体播放器、智能手机、平板电脑以及电视上都能得到良好的支持。此外&#xff0c;MP4格式的视频文件…
阅读更多...
Spring Boot集成tablesaw插件快速入门Demo

Spring Boot集成tablesaw插件快速入门Demo

1 什么是tablesaw&#xff1f; Tablesaw是一款Java的数据可视化库&#xff0c;主要包括两部分&#xff1a; 数据解析库&#xff0c;主要用于加载数据&#xff0c;对数据进行操作(转化&#xff0c;过滤&#xff0c;汇总等)&#xff0c;类比Python中的Pandas库&#xff1b; 数据…
阅读更多...
网络安全（补充）

网络安全（补充）

针对网络信息系统的容灾恢复问题&#xff0c;国家制定和颁布了《信息安全技术信息系统灾难恢复规范&#xff08;GB/T 20988-2007&#xff09;》&#xff0c;该规范定义了六个灾难恢复等级和技术要求&#xff1a;第一级基本支持&#xff08;要求至少每周做一次完全数据备份&…
阅读更多...
linux yum 安装mysql

linux yum 安装mysql

安装过程 yum -y install mysql mysql-server mysql-devel systemctl start mysqld.service 启动 netstat -lnp|grep 3306 查看端口 systemctl status mysqld.service 查看状态 mysql -uroot -p 登录mysql&#xff0c;输入密码可以直接回车&#xff0c;如果登录在失败在查找…
阅读更多...
上海晋名室外危废品暂存柜助力储能电站行业危废品安全储存

上海晋名室外危废品暂存柜助力储能电站行业危废品安全储存

近日又有一台SAVEST室外危废暂存柜项目成功验收交付使用&#xff0c;此次项目主要用于储能电站行业废油、废锂电池等危废品的安全储存。 用户单位在日常工作运营中涉及到废油、废锂电池等危废品的室外安全储存问题。4月中旬用户技术总工在寻找解决方案的过程中搜索到上海晋名的…
阅读更多...
深入剖析ReentrantLock的FairSync：公平锁机制的源码之旅

深入剖析ReentrantLock的FairSync：公平锁机制的源码之旅

1. 引言 在Java并发编程中，ReentrantLock作为一种功能强大的可重入锁，提供了公平与非公平两种锁机制。其中，FairSync作为ReentrantLock内部实现公平锁机制的关键组件，其设计理念和源码实现都值得深入探讨。 2. NonfairSync概述 ReentrantLock是Java提供的一个互斥锁，具有…
阅读更多...
华为wlan实验

华为wlan实验

分为三步&#xff1a;1、网络互通&#xff0c;2、AP上线&#xff0c;3、wlan业务 1、网络互通 crow-sw: vlan batch 20 100 dhcp enable int vlan 20 ip add 192.168.20.1 24 dhcp select interfaceinterface GigabitEthernet0/0/2port link-type accessport default vlan 100…
阅读更多...
matlab 任意二维图像转点云

matlab 任意二维图像转点云

目录 一、概述二、代码实现三、结果展示本文由CSDN点云侠原创，原文链接。如果你不是在点云侠的博客中看到该文章，那么此处便是不要脸的爬虫。 一、概述 给定任意一张图片，通过代码操作将图片转成点云。图像中包含大量可用信息，其中必不可少的信息为像素坐标和像素值，将像…
阅读更多...
FastDFS简介与调优

FastDFS简介与调优

背景&#xff1a;FastDFS在公司使用多年&#xff0c;一直作为主要文件存储服务使用。经过多场景、多项目实战检验。稳定性、性能均满足实战要求。相关使用介绍及调优给大家分享一下。 1.简介 FastDFS是淘宝架构师_余庆用C语言编写的一款开源的分布式文件系统&#xff0c;源码目…
阅读更多...
汇编：EFLAGS寄存器

汇编：EFLAGS寄存器

EFLAGS寄存器是x86架构处理器中的一个状态寄存器&#xff0c;用于存储当前处理器状态和控制特定操作&#xff1b;寄存器中的各个标志位可以影响指令执行&#xff0c;并且指令执行过程中也可以修改这些标志位&#xff0c;每个位都有特定的含义。 EFLAGS寄存器图示&#xff1a; …
阅读更多...
代码随想录——电话号码的字母组合（Leetcode17）

代码随想录——电话号码的字母组合（Leetcode17）

题目链接 回溯 class Solution {List<String> res new ArrayList<String>();StringBuilder str new StringBuilder();HashMap<String, String> Sites new HashMap<String, String>();public List<String> letterCombinations(String digit…
阅读更多...
警报！警报！APP推荐风暴再次来袭！

警报！警报！APP推荐风暴再次来袭！

AI视频生成&#xff1a;小说文案智能分镜智能识别角色和场景批量Ai绘图自动配音添加音乐一键合成视频https://aitools.jurilu.com/ 1.中医古今经典方剂—中药方剂 中药方剂是一款集成了中医古今经典方剂的知识检索库产品,收录了上万种中医中药偏方,及当代名老中医的自创验方,是…
阅读更多...
深入探索如何在 MoonBit 中实现 Haskell 求值语义（三）

深入探索如何在 MoonBit 中实现 Haskell 求值语义（三）

本期文章为在MoonBit中实现惰性求值的第三篇。在上一篇中&#xff0c;我们了解了let表达式的编译方法以及如何实现基本的算术比较操作。这一篇文章中&#xff0c;我们将实现一种基于上下文的优化方法&#xff0c;并添加对数据结构的支持。 追踪上下文 回顾一下我们之前实现pr…
阅读更多...
Python酷库之旅-比翼双飞情侣库(05)

Python酷库之旅-比翼双飞情侣库(05)

目录 一、xlrd库的由来 二、xlrd库优缺点 1、优点 1-1、支持多种Excel文件格式 1-2、高效性 1-3、开源性 1-4、简单易用 1-5、良好的兼容性 2、缺点 2-1、对.xlsx格式支持有限 2-2、功能相对单一 2-3、更新和维护频率低 2-4、依赖外部资源 三、xlrd库的版本说明 …
阅读更多...
数据中心精密空调与普通空调差异

数据中心精密空调与普通空调差异

数据中心精密空调与普通空调差异&#xff0c;除了结构差异之后&#xff0c;还有直接反应在性能上的差异。 1、显热比率&#xff08;显热比率 (SHR) 显热冷却/总冷却&#xff09; 热负荷包含两个独立的部分&#xff1a;显热和潜热。显热是机房电子设备产生的热量。潜热与空气…
阅读更多...
最新文章

Copyright @ 2022~2023