Linux 按键输入实验-基于正点原子IMX6ULL开发板

最新推荐文章于 2023-02-01 09:32:15 发布

supersmart@

最新推荐文章于 2023-02-01 09:32:15 发布

阅读量369

点赞数

文章标签： arm linux c++ vscode 功能测试

本文链接：https://blog.csdn.net/shengnan89/article/details/124017839

版权

I.MX6U-ALPHA 开发板上有一个按键，我们就使用此按键来完成 GPIO 输入驱动程序，同时利用第四十七章讲的原子操作来对按键值进行保护。

1 Linux 下按键驱动原理

按键驱动和 LED 驱动原理上来讲基本都是一样的，都是操作 GPIO ，只不过一个是读取

GPIO 的高低电平，一个是从 GPIO 输出高低电平。本章我们实现按键输入，在驱动程序中使用

一个整形变量来表示按键值，应用程序通过 read 函数来读取按键值，判断按键有没有按下。在

这里，这个保存按键值的变量就是个共享资源，驱动程序要向其写入按键值，应用程序要读取

按键值。所以我们要对其进行保护，对于整形变量而言我们首选的就是原子操作，使用原子操

作对变量进行赋值以及读取。 Linux 下的按键驱动原理很简单，接下来开始编写驱动。

注意，本章例程只是为了演示 Linux 下 GPIO 输入驱动的编写，实际中的按键驱动并不会

采用本章中所讲解的方法， Linux 下的 input 子系统专门用于输入设备！

2 硬件原理图分析

3 实验程序编写

3.1 修改设备树文件

1 、添加 pinctrl 节点

打开 imx6ull-alientek-emmc.dts，在 iomuxc 节点的 imx6ul-evk 子节点下创建一个名为“ pinctrl_key ”的子节点，节点内容如下所示：

		pinctrl_key: keepprp{
			fsl,pins = <
				MX6UL_PAD_UART1_CTS_B__GPIO1_IO18 0xF080
			>;
		};

2、添加 KEY 设备节点

在根节点“/”下创建 KEY 节点，节点名为“ key ”，节点内容如下：

    key{
        compatible = "alientek,key";
        pinctrl-names = "default";
        pinctrl-0 = <&pinctrl_key>;
        key-gpios = <&gpio1 18 GPIO_ACTIVE_LOW>;//此处gpio1_io18作为输入，电平可随便输入，可为高，也可为低
        status= "okay";
        interrupt-parent = <&gpio1>;
        interrupts = <18 IRQ_TYPE_EDGE_BOTH>;
    };

3 、检查 PIN 是否被其他外设使用

先检查 PIN 为 UART1_CTS_B 这个 PIN 有没有被其他的 pinctrl 节点使用，如果有使用的话就要屏蔽掉，然后再检查 GPIO1_IO18 这个 GPIO 有没有被其他外设使用，如果有的话也要屏蔽掉。

编译设备树，然后使用新编译出来的imx6ull-alientek-emmc.dtb 文件启动 Linux 系统。

进入“/proc/device-tree”目录中查看“key ”节点是否存在。

3.2 按键驱动程序编写

新建工程，在 key.c 里面输入如下内容：

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/slab.h>

#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/cdev.h>

#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>

#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/atomic.h>


#define KEY_CNT 1
#define KEY_NAME "key"

#define KEY0VALUE 0xF0
#define INVAKEY 0x00

/*key 设备结构体*/
struct key_dev
{
    dev_t devid;
    int major;
    int minor;
    struct cdev cdev;
    struct class *class;
    struct device *device;
    struct device_node *nd;
    int key_gpio;
    atomic_t keyvalue;
};

struct key_dev key; /*KEY*/

static int key_open(struct inode *inode, struct file *filp)
{
    filp->private_data = &key;
    return 0;
}

static int key_release(struct inode *inode, struct file *filp)
{

    return 0;
}

static ssize_t key_write(struct file *filp, const char __user *buf,
                         size_t count, loff_t *ppos)
{

    return 0;
}
static ssize_t key_read(struct file *filp, char __user *buf,
                        size_t count, loff_t *ppos)
{
    int value;
    struct key_dev *dev = filp->private_data;
    int ret = 0;
    if (gpio_get_value(dev->key_gpio) == 0) /* key0 按下 */
    {
        while (!gpio_get_value(dev->key_gpio))/* 等待按键释放 */
            ;
        atomic_set(&dev->keyvalue, KEY0VALUE);
    }
    else /* 无效的按键值 */
    {
        atomic_set(&dev->keyvalue, INVAKEY);
    }

    value= atomic_read(&dev->keyvalue);

    ret = copy_to_user(buf,&value,sizeof(value));
    return ret;
}

/*操作集*/
static const struct file_operations key_fops = {
    .owner = THIS_MODULE,
    .read = key_read,
    .open = key_open,
    .release = key_release,
};

/*key io初始化*/
static int keyio_init(struct key_dev *dev)
{
    int ret = 0;
    dev->nd = of_find_node_by_path("/key");
    if (dev->nd == NULL)
    {
        ret = -EINVAL;
        goto fail_nd;
    }

    dev->key_gpio = of_get_named_gpio(dev->nd, "key-gpios", 0);

    if (dev->key_gpio < 0)
    {
        ret = -EINVAL;
        goto fail_gpio;
    }

    ret = gpio_request(dev->key_gpio, "key0");
    if (ret)
    {
        ret = -EBUSY;
        printk("IO %d can't request!\r\n", dev->key_gpio);
        goto fail_request;
    }

    ret = gpio_direction_input(dev->key_gpio);
    if (ret < 0)
    {
        ret = -EINVAL;
        goto fail_input;
    }
    return 0;

fail_input:
    gpio_free(dev->key_gpio);
fail_request:

fail_gpio:

fail_nd:

    return ret;
}

/*驱动入口函数*/
static int __init key_init(void)
{
    int ret = 0;

    atomic_set(&key.keyvalue, INVAKEY);

    /*1,注册字符设备驱动*/
    key.major = 0;
    if (key.major)
    { /*给定主设备号*/
        key.devid = MKDEV(key.major, 0);
        ret = register_chrdev_region(key.devid, KEY_CNT, "KEY_NAME");
    }
    else
    {
        ret = alloc_chrdev_region(&key.devid, 0, KEY_CNT, "KEY_NAME");
        key.major = MAJOR(key.devid);
        key.minor = MINOR(key.devid);
    }

    if (ret < 0)
    {
        goto fail_devid;
    }

    printk("key major =%d, minor =%d \r\n", key.major, key.minor);

    /*2,初始化cdev*/
    key.cdev.owner = THIS_MODULE;
    cdev_init(&key.cdev, &key_fops);

    /*3,添加cdev*/
    ret = cdev_add(&key.cdev, key.devid, KEY_CNT);
    if (ret)
    {
        goto fail_cdevadd;
    }
    /*4,创建类*/
    key.class = class_create(THIS_MODULE, KEY_NAME);
    if (IS_ERR(key.class))
    {
        ret = PTR_ERR(key.class);
        goto fail_class;
    }
    /*5,创建设备*/
    key.device = device_create(key.class, NULL, key.devid, NULL, KEY_NAME);
    if (IS_ERR(key.device))
    {
        ret = PTR_ERR(key.device);
        goto fail_device;
    }

    ret = keyio_init(&key);
    if (ret < 0)
    {
        goto fail_device;
    }

    return 0;

fail_device:
    class_destroy(key.class);
fail_class:
    cdev_del(&key.cdev);
fail_cdevadd:
    unregister_chrdev_region(key.devid, KEY_CNT);
fail_devid:

    return ret;
}

/*驱动出口函数*/
static void __exit key_exit(void)
{

    /*注销字符设备驱动*/
    cdev_del(&key.cdev);
    unregister_chrdev_region(key.devid, KEY_CNT);
    device_destroy(key.class, key.devid);
    class_destroy(key.class);

    /*释放IO*/
    gpio_free(key.key_gpio);
}

module_init(key_init);
module_exit(key_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("supersmart");

第一步：atomic_set 函数初始化原子变量默认为无效值。

第二步：函数 keyio_init 用于初始化按键，从设备树中获取按键的 gpio 信息，然后设置为输入。

第三步：key_read 函数，应用程序通过 read 函数读取按键值的时候此函数就会执行。首先读取按键 IO 的电平，如果为 0 的话就表示按键按下了，如果按键按下的话等待按键释放。按键释放以后标记按键值为 KEY0VALUE。

key.c 文件代码很简单，重点就是 key_read 函数读取按键值，要对 keyvalue 进行保护。

3.3 编写测试 APP

测试APP文件 keyAPP.c 内容如下

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

/*
 *argc:应用程序参数个数
 * argv[]:具体的参数内容，字符串形式
 * ./keyAPP <filename> <0:1> 0 关灯，1 开灯
 * ./keyAPP /dev/key
 */

#define KEY0VALUE 0xF0
#define INVAKEY 0x00

int main(int argc, char *argv[])
{
    int value;
    int fd, retvalue;
    char *filename;

    unsigned char cnt;

    if (argc != 2)
    {
        printf("Error Usage!\r\n");
        return -1;
    }

    filename = argv[1];

    fd = open(filename, O_RDWR);
    if (fd < 0)
    {
        printf("file %s open failed!\r\n", filename);
        return -1;
    }

    /*循环读取*/
    while(1)
    {
        read(fd,&value,sizeof(value));
        if(value==KEY0VALUE)
        {
            printf("KEY0 Press,value=%d\r\n",value);
        }
    }
    close(fd);
    return 0;
}

该测试程序循环读取 /dev/key 文件，也就是循环读取按键值，并且将按键值打印出来。

4 运行测试

4.1 编译驱动程序和测试 APP (略)

4.2 运行测试

加载驱动