ARM Linux 驱动开发篇--- Linux 按键输入实验--- Ubuntu20.04互斥体实验
🎬 渡水无言：个人主页渡水无言
❄专栏传送门： 《linux专栏》《嵌入式linux驱动开发》《linux系统移植专栏》
❄专栏传送门： 《freertos专栏》《STM32 HAL库专栏》《linux裸机开发专栏》
⭐️流水不争先，争的是滔滔不绝
📚博主简介：第二十届中国研究生电子设计竞赛全国二等奖 |国家奖学金 | 省级三好学生
| 省级优秀毕业生获得者 | ZEEKLOG新星杯TOP18 | 半导纵横专栏博主 | 211在读研究生
在这里主要分享自己学习的linux嵌入式领域知识；有分享错误或者不足的地方欢迎大佬指导，也欢迎各位大佬互相三连
目录
3.3.2、GPIO 初始化函数（51-69 行：keyio_init）
3. write/release 函数（125-138 行）
3.3.5、驱动入口函数（154-190 行：mykey_init）
3.3.6、驱动出口函数（197-206 行：mykey_exit）
前言
前面几期博客我们使用的 基本都是使用GPIO 输出功能，还没有用过 GPIO 输入功能，本期博客我们就来学习一下如何在 Linux 下编写 GPIO 输入驱动程序，我们就使用此按键来完成功能。同时使用原子操作来对按价值进行保护。
一、Linux下按键驱动原理
按键驱动和 LED 驱动本质都是操作 GPIO，区别仅在于：
LED：GPIO 输出高低电平；
按键：GPIO 读取高低电平.
在 Linux 驱动中实现按键输入功能：
驱动层读取 GPIO 电平判断按键状态；
应用层通过read函数获取按键值；
用原子操作保护按键值这个 “共享资源”（驱动写、应用读）
二、硬件原理图分析
1） LED 灯 LED0。
2）1 个按键 KEY0
按键 KEY0 的原理图如下：
图中可以看出，按键 KEY0 是连接到 I.MX6U 的 UART1_CTS 这个 IO 上的，KEY0接了一个 10K 的上拉电阻，因此 KEY0 没有按下的时候 UART1_CTS 应该是高电平，当 KEY0按下以后 UART1_CTS 就是低电平。
三、实验程序编写
3.1、修改设备树文件
3.1.1、添加 pinctrl 节点（引脚复用配置）
在iomuxc节点的imx6ul-evk子节点下，添加按键的 pinctrl 配置：
pinctrl_key: keygrp { fsl,pins = < MX6UL_PAD_UART1_CTS_B__GPIO1_IO18 0xF080 /* KEY0 */ >; };第 3 行，将 GPIO_IO18 这个 PIN 复用为 GPIO1_IO18。
3.1.2、添加 KEY 设备节点
在根节点/下创建key节点：
key { #address-cells = <1>; #size-cells = <1>; compatible = "atkalpha-key"; // 驱动匹配标识 pinctrl-names = "default"; pinctrl-0 = <&pinctrl_key>; // 关联上面的pinctrl节点 key-gpio = <&gpio1 18 GPIO_ACTIVE_LOW>; /* KEY0：GPIO1_IO18，低电平有效 */ status = "okay"; };第 6 行，pinctrl-0 属性设置 KEY 所使用的 PIN 对应的 pinctrl 节点。第 7 行，key-gpio 属性指定了 KEY 所使用的 GPIO。
3.1.3、检查 PIN 是否被其他外设使用
在本章实验中蜂鸣器使用的 PIN 为 UART1_CTS_B，因此先检查 PIN 为 UART1_CTS_B 这
个 PIN 有没有被其他的 pinctrl 节点使用，如果有使用的话就要屏蔽掉，然后再检查 GPIO1_IO18
这个 GPIO 有没有被其他外设使用，如果有的话也要屏蔽掉。
3.1.4、编译设备树
设备树编写完成以后使用如下命令重新编译设备树：
make dtbs # 重新编译设备树将新生成的imx6ull-alientek-emmc.dtb替换开发板的设备树文件，重启动成功以后进入“/proc/device-tree”目录中。使用如下命令：
cd /proc/device-tree ls | grep key # 能看到key节点则说明配置成功查看“key”节点是否存在，如果存在的话就说明设备树基本修改成功(具体还要驱动验证)。
3.2、按键驱动程序编写（key.c）
<linux/types.h> 2<linux/kernel.h> 3<linux/delay.h> 4<linux/ide.h> 5<linux/init.h> 6<linux/module.h> 7<linux/errno.h> 8<linux/gpio.h> 9<linux/cdev.h> 10<linux/device.h> 11<linux/of.h> 12<linux/of_address.h> 1<linux/of_gpio.h> 14 #include <linux/semaphore.h> 15 #include<asm/mach/map.h> 16<asm/uaccess.h> 17<asm/io.h> 18 /*************************************************************** 19 文件名 : key.c 20 版本 : V1.0 21 描述 : Linux按键输入驱动实验 22 ***************************************************************/ 23 #define KEY_CNT 1 /* 设备号个数 */ 24 #define KEY_NAME "key" /* 名字 */ 25 26 /* 定义按键值 */ 27 #define KEY0VALUE 0XF0 /* 按键值 */ 28 #define INVAKEY 0X00 /* 无效的按键值 */ 29 30 /* key设备结构体 */ 31 struct key_dev{ 32 dev_t devid; /* 设备号 */ 33 struct cdev cdev; /* cdev */ 34 struct class *class; /* 类 */ 35 struct device *device; /* 设备 */ 36 int major; /* 主设备号 */ 37 int minor; /* 次设备号 */ 38 struct device_node *nd; /* 设备节点 */ 39 int key_gpio; /* key所使用的GPIO编号 */ 40 atomic_t keyvalue; /* 按键值 */ 41 }; 42 43 struct key_dev keydev; /* key设备 */ 44 45 /* 46 * @description : 初始化按键IO，open函数打开驱动的时候 47 * 初始化按键所使用的GPIO引脚。 48 * @param : 无 49 * @return : 无 50 */ 51 static int keyio_init(void) 52 { 53 keydev.nd = of_find_node_by_path("/key"); 54 if (keydev.nd== NULL) { 55 return -EINVAL; 56 } 57 58 keydev.key_gpio = of_get_named_gpio(keydev.nd ,"key-gpio", 0); 59 if (keydev.key_g< 0) { 60 printk("can't get key0\r\n"); 61 return -EINVAL; 62 } 63 printk("key_gpio=%d\r\n", keydev.key_gpio); 64 65 /* 初始化key所使用的IO */ 66 gpio_request(keydev.key_gpio, "key0"); /* 请求IO */ 67 gpio_direction_input(keydev.key_gpio); /* 设置为输入 */ 68 return 0; 69 } 70 71 /* 72 * @description : 打开设备 73 * @param - inode : 传递给驱动的inode 74 * @param - filp : 设备文件，file结构体有个叫做private_data的成员变量 75 * 一般在open的时候将private_data指向设备结构体。 76 * @return : 0 成功;其他 失败 77 */ 78 static int key_open(struct inode *inode, struct file *filp) 79 { 80 int ret = 0; 81 filp->private_data = &keydev; /* 设置私有数据 */ 82 83 ret = keyio_init(); /* 初始化按键IO */ 84 if (ret< 0) { 85 return ret; 86 } 87 88 return 0; 89 } 90 91 /* 92 * @description : 从设备读取数据 93 * @param - filp : 要打开的设备文件(文件描述符) 94 * @param - buf : 返回给用户空间的数据缓冲区 95 * @param - cnt : 要读取的数据长度 96 * @param - offt : 相对于文件首地址的偏移 97 * @return : 读取的字节数，如果为负值，表示读取失败 98 */ 99 static ssize_t key_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt) 100 { 101 int ret = 0; 102 int value; 103 struct key_dev *dev = filp->private_data; 104 105 if (gpio_get_value(dev->key_gpio) == 0) { /* key0按下 */ 106 while(!gpio_get_value(dev->key_gpio)); /* 等待按键释放 */ 107 atomic_set(&dev->keyvalue, KEY0VALUE); 108 } else { 109 atomic_set(&dev->keyvalue, INVAKEY); /* 无效的按键值 */ 110 } 111 112 value = atomic_read(&dev->keyvalue); 113 ret = copy_to_user(buf, &value, sizeof(value)); 114 return ret; 115 } 116 117 /* 118 * @description : 向设备写数据 119 * @param - filp : 设备文件，表示打开的文件描述符 120 * @param - buf : 要写给设备写入的数据 121 * @param - cnt : 要写入的数据长度 122 * @param - offt : 相对于文件首地址的偏移 123 * @return : 写入的字节数，如果为负值，表示写入失败 124 */ 125 static ssize_t key_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt) 126 { 127 return 0; 128 } 129 130 /* 131 * @description : 关闭/释放设备 132 * @param - filp : 要关闭的设备文件(文件描述符) 133 * @return : 0 成功;其他 失败 134 */ 135 static int key_release(struct inode *inode, struct file *filp) 136 { 137 return 0; 138 } 139 140 /* 设备操作函数 */ 141 static struct file_operations key_fops = { 142 .owner = THIS_MODULE, 143 .open = key_open, 144 .read = key_read, 145 .write = key_write, 146 .release = key_release, 147 }; 148 149 /* 150 * @description : 驱动入口函数 151 * @param : 无 152 * @return : 无 153 */ 154 static int __init mykey_init(void) 155 { 156 /* 初始化原子变量 */ 157 atomic_set(&keydev.keyvalue, INVAKEY); 158 159 /* 注册字符设备驱动 */ 160 /* 1、创建设备号 */ 161 if (keydev.major) { /* 定义了设备号 */ 162 keydev.devid = MKDEV(keydev.major, 0); 163 register_chrdev_region(keydev.devid, KEY_CNT, KEY_NAME); 164 } else { /* 没有定义设备号 */ 165 alloc_chrdev_region(&keydev.devid, 0, KEY_CNT, KEY_NAME); /* 申请设备号 */ 166 keydev.major = MAJOR(keydev.devid); /* 获取分配号的主设备号 */ 167 keydev.minor = MINOR(keydev.devid); /* 获取分配号的次设备号 */ 168 } 169 170 /* 2、初始化cdev */ 171 keydev.cdev.owner = THIS_MODULE; 172 cdev_init(&keydev.cdev, &key_fops); 173 174 /* 3、添加一个cdev */ 175 cdev_add(&keydev.cdev, keydev.devid, KEY_CNT); 176 177 /* 4、创建类 */ 178 keydev.class = class_create(THIS_MODULE, KEY_NAME); 179 if (IS_ERR(keydev.class)) { 180 return PTR_ERR(keydev.class); 181 } 182 183 /* 5、创建设备 */ 184 keydev.device = device_create(keydev.class, NULL, keydev.devid, NULL, KEY_NAME); 185 if (IS_ERR(keydev.device)) { 186 return PTR_ERR(keydev.device); 187 } 188 189 return 0; 190 } 191 192 /* 193 * @description : 驱动出口函数 194 * @param : 无 195 * @return : 无 196 */ 197 static void __exit mykey_exit(void) 198 { 199 /* 注销字符设备驱动 */ 200 gpio_free(keydev.key_gpio); 201 cdev_del(&keydev.cdev);/* 删除cdev */ 202 unregister_chrdev_region(keydev.devid, KEY_CNT); /* 注销设备号 */ 203 204 device_destroy(keydev.class, keydev.devid); 205 class_destroy(keydev.class); 206 } 207 208 module_init(mykey_init); 209 module_exit(mykey_exit); 210 MODULE_LICENSE("GPL"); 211 MODULE_AUTHOR("duan");3.3 驱动代码逐段解析
3.3.1、设备结构体定义（30-43行）
将驱动所有相关资源（设备号、GPIO、原子变量等）封装到结构体，便于管理和传递，代码解析如下：
struct key_dev{ dev_t devid; // 设备号（主+次，内核唯一标识） struct cdev cdev; // 字符设备核心对象（关联文件操作集） struct class *class; // 驱动类（自动创建设备节点用） struct device *device; // 设备节点（最终生成/dev/key） int major; // 主设备号（手动指定或动态分配） int minor; // 次设备号（配合主设备号使用） struct device_node *nd; // 设备树节点（解析key节点的硬件信息） int key_gpio; // 按键对应的GPIO编号（如GPIO1_IO18） atomic_t keyvalue; // 按键值（原子变量，保护共享资源） }; struct key_dev keydev; // 定义全局设备实例（简化版，实际可动态分配）3.3.2、GPIO 初始化函数（51-69 行：keyio_init）
该函数负责从设备树解析 GPIO 信息，并初始化 GPIO 为输入模式，是按键驱动的硬件初始化核心，逐行解析：
static int keyio_init(void) 52 { 53 keydev.nd = of_find_node_by_path("/key"); 54 if (keydev.nd== NULL) { 55 return -EINVAL; 56 } 57 58 keydev.key_gpio = of_get_named_gpio(keydev.nd ,"key-gpio", 0); 59 if (keydev.key_g< 0) { 60 printk("can't get key0\r\n"); 61 return -EINVAL; 62 } 63 printk("key_gpio=%d\r\n", keydev.key_gpio); 64 65 /* 初始化key所使用的IO */ 66 gpio_request(keydev.key_gpio, "key0"); /* 请求IO */ 67 gpio_direction_input(keydev.key_gpio); /* 设置为输入 */ 68 return 0; 69 }| 行号 | 代码逻辑 | 关键说明 |
|---|---|---|
53-56 |
| 从设备树中查找路径为 |
58-62 |
| 从 |
63 |
| 打印 GPIO 编号，调试用（确认设备树解析成功，方便排查问题）。 |
66 |
| 向内核申请 GPIO 资源，避免引脚冲突；"key0" 是 GPIO 名称（调试用，可自定义）。 |
67 |
| 将 GPIO 配置为输入模式（按键核心：读取电平判断状态） |
3.3.3、文件操作接口（78-138 行）
static int key_open(struct inode *inode, struct file *filp) 79 { 80 int ret = 0; 81 filp->private_data = &keydev; /* 设置私有数据 */ 82 83 ret = keyio_init(); /* 初始化按键IO */ 84 if (ret< 0) { 85 return ret; 86 } 87 88 return 0; 89 } 90 91 /* 92 * @description : 从设备读取数据 93 * @param - filp : 要打开的设备文件(文件描述符) 94 * @param - buf : 返回给用户空间的数据缓冲区 95 * @param - cnt : 要读取的数据长度 96 * @param - offt : 相对于文件首地址的偏移 97 * @return : 读取的字节数，如果为负值，表示读取失败 98 */ 99 static ssize_t key_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt) 100 { 101 int ret = 0; 102 int value; 103 struct key_dev *dev = filp->private_data; 104 105 if (gpio_get_value(dev->key_gpio) == 0) { /* key0按下 */ 106 while(!gpio_get_value(dev->key_gpio)); /* 等待按键释放 */ 107 atomic_set(&dev->keyvalue, KEY0VALUE); 108 } else { 109 atomic_set(&dev->keyvalue, INVAKEY); /* 无效的按键值 */ 110 } 111 112 value = atomic_read(&dev->keyvalue); 113 ret = copy_to_user(buf, &value, sizeof(value)); 114 return ret; 115 } 116 117 /* 118 * @description : 向设备写数据 119 * @param - filp : 设备文件，表示打开的文件描述符 120 * @param - buf : 要写给设备写入的数据 121 * @param - cnt : 要写入的数据长度 122 * @param - offt : 相对于文件首地址的偏移 123 * @return : 写入的字节数，如果为负值，表示写入失败 124 */ 125 static ssize_t key_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt) 126 { 127 return 0; 128 } 129 130 /* 131 * @description : 关闭/释放设备 132 * @param - filp : 要关闭的设备文件(文件描述符) 133 * @return : 0 成功;其他 失败 134 */ 135 static int key_release(struct inode *inode, struct file *filp) 136 { 137 return 0; 138 }1. open 函数（78-89 行：key_open）
static int key_open(struct inode *inode, struct file *filp) 79 { 80 int ret = 0; 81 filp->private_data = &keydev; /* 设置私有数据 */ 82 83 ret = keyio_init(); /* 初始化按键IO */ 84 if (ret< 0) { 85 return ret; 86 } 87 88 return 0; 89 }| 行号 | 核心逻辑 | 关键说明 |
|---|---|---|
| 81 | filp->private_data = &keydev | 将设备结构体赋值给file的私有数据，后续read/write可直接通过私有数据获取设备信息，是驱动层通用写法。 |
| 83-86 | 调用keyio_init() | 打开驱动时初始化 GPIO。 |
2. read 函数（99-115 行：key_read）
应用层调用read函数时，该函数执行，负责读取按键状态、设置按键值，并将值拷贝到用户空间，逐行解析：
91 /* 92 * @description : 从设备读取数据 93 * @param - filp : 要打开的设备文件(文件描述符) 94 * @param - buf : 返回给用户空间的数据缓冲区 95 * @param - cnt : 要读取的数据长度 96 * @param - offt : 相对于文件首地址的偏移 97 * @return : 读取的字节数，如果为负值，表示读取失败 98 */ 99 static ssize_t key_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt) 100 { 101 int ret = 0; 102 int value; 103 struct key_dev *dev = filp->private_data; 104 105 if (gpio_get_value(dev->key_gpio) == 0) { /* key0按下 */ 106 while(!gpio_get_value(dev->key_gpio)); /* 等待按键释放 */ 107 atomic_set(&dev->keyvalue, KEY0VALUE); 108 } else { 109 atomic_set(&dev->keyvalue, INVAKEY); /* 无效的按键值 */ 110 } 111 112 value = atomic_read(&dev->keyvalue); 113 ret = copy_to_user(buf, &value, sizeof(value)); 114 return ret; 115 }| 行号 | 代码逻辑 | 关键说明 |
|---|---|---|
| 103 | struct key_dev*dev=filp>private_data | 从私有数据中获取设备结构体，避免全局变量的滥用，规范写法。 |
| 105 | gpio_get_value(dev->key_gpio) == 0 | 读取 GPIO 电平 0 = 按键按下（低电平有效） 1 = 未按下，与硬件电平逻辑对应。 |
| 106 | while(!gpio_get_value(dev->key_gpio)) | 等待按键释放（阻塞式，直到电平变为 1）； 缺点：无消抖，按键机械抖动可能导致多次触发。 |
| 107 | atomic_set(&dev->keyvalue, KEY0VALUE) | 原子操作设置按键值为 0XF0（按下），保证赋值原子性，避免多线程访问冲突。 |
| 109 | atomic_set(&dev->keyvalue, INVAKEY) | 未按下时，原子操作设置为无效值 0X00，区分 “按下” 和 “未按下” 状态。 |
| 112 | value = atomic_read(&dev->keyvalue) | 原子操作读取按键值（避免读写冲突），确保读取到的是完整、正确的值。 |
| 113 | copy_to_user(buf, &value, sizeof(value)) | 将按键值从内核空间拷贝到用户空间（应用层 read 的核心）； 返回 0 表示成功，负数表示失败（如拷贝失败）。 |
3. write/release 函数（125-138 行）
/* 118 * @description : 向设备写数据 119 * @param - filp : 设备文件，表示打开的文件描述符 120 * @param - buf : 要写给设备写入的数据 121 * @param - cnt : 要写入的数据长度 122 * @param - offt : 相对于文件首地址的偏移 123 * @return : 写入的字节数，如果为负值，表示写入失败 124 */ 125 static ssize_t key_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt) 126 { 127 return 0; 128 } 129 130 /* 131 * @description : 关闭/释放设备 132 * @param - filp : 要关闭的设备文件(文件描述符) 133 * @return : 0 成功;其他 失败 134 */ 135 static int key_release(struct inode *inode, struct file *filp) 136 { 137 return 0; 138 }key_write（125-128 行）：返回 0，无实际功能（按键是输入设备，无需写操作，预留接口可后续扩展）；
key_release（135-138 行）：返回 0，无资源释放（GPIO 释放移到驱动出口，避免重复释放）。
3.3.4、设备操作集（140-147 行）
Linux 字符设备驱动的 “接口映射表”，内核通过该结构体调用驱动的具体函数，代码解析：
static struct file_operations key_fops = { .owner = THIS_MODULE, // 归属本模块（内核安全机制，防止模块被意外卸载） .open = key_open, // 关联open函数（应用层open时调用） .read = key_read, // 关联read函数（应用层read时调用） .write = key_write, // 关联write函数（应用层write时调用） .release = key_release, // 关联release函数（应用层close时调用） };3.3.5、驱动入口函数（154-190 行：mykey_init）
驱动加载时执行（insmod/modprobe），完成字符设备驱动的注册流程，是驱动的 “启动入口”，步骤清晰：
150 * @description : 驱动入口函数 151 * @param : 无 152 * @return : 无 153 */ 154 static int __init mykey_init(void) 155 { 156 /* 初始化原子变量 */ 157 atomic_set(&keydev.keyvalue, INVAKEY); 158 159 /* 注册字符设备驱动 */ 160 /* 1、创建设备号 */ 161 if (keydev.major) { /* 定义了设备号 */ 162 keydev.devid = MKDEV(keydev.major, 0); 163 register_chrdev_region(keydev.devid, KEY_CNT, KEY_NAME); 164 } else { /* 没有定义设备号 */ 165 alloc_chrdev_region(&keydev.devid, 0, KEY_CNT, KEY_NAME); /* 申请设备号 */ 166 keydev.major = MAJOR(keydev.devid); /* 获取分配号的主设备号 */ 167 keydev.minor = MINOR(keydev.devid); /* 获取分配号的次设备号 */ 168 } 169 170 /* 2、初始化cdev */ 171 keydev.cdev.owner = THIS_MODULE; 172 cdev_init(&keydev.cdev, &key_fops); 173 174 /* 3、添加一个cdev */ 175 cdev_add(&keydev.cdev, keydev.devid, KEY_CNT); 176 177 /* 4、创建类 */ 178 keydev.class = class_create(THIS_MODULE, KEY_NAME); 179 if (IS_ERR(keydev.class)) { 180 return PTR_ERR(keydev.class); 181 } 182 183 /* 5、创建设备 */ 184 keydev.device = device_create(keydev.class, NULL, keydev.devid, NULL, KEY_NAME); 185 if (IS_ERR(keydev.device)) { 186 return PTR_ERR(keydev.device); 187 } 188 189 return 0; 190 }| 步骤 | 行号 | 代码逻辑 | 关键说明 |
|---|---|---|---|
初始化原子变量 | 157 |
| 初始化为无效按键值（未按下），避免初始值异常。 |
1. 创建设备号 | 161-168 | ① 静态注册： 若指定了 ② 动态注册： 未指定则用 ③ | 字符设备驱动第一步：申请设备号（内核唯一标识，应用层通过设备号访问驱动）。 |
2. 初始化 cdev | 171-172 |
| 将 |
3. 添加 cdev | 175 |
| 将 cdev 添加到内核，完成字符设备注册，内核开始识别该设备。 |
4. 创建类 | 178-181 |
| 创建驱动类（/sys/class/key），失败则返回错误码，类用于自动创建设备节点。 |
5. 创建设备 | 184-187 |
| 基于类自动创建 |
3.3.6、驱动出口函数（197-206 行：mykey_exit）
驱动卸载时执行（rmmod），释放所有资源（反向流程），避免内存泄漏，逐行解析：
| 行号 | 代码逻辑 | 关键说明 |
|---|---|---|
| 200 | gpio_free(keydev.key_gpio) | 释放申请的 GPIO 资源（避免内存泄漏，必须与 gpio_request 对应）。 |
| 201 | cdev_del(&keydev.cdev) | 从内核删除 cdev 对象，注销字符设备操作接口。 |
| 202 | unregister_chrdev_region | 注销设备号（归还内核，避免设备号占用）。 |
| 204 | device_destroy | 删除/dev/key设备节点（与 device_create 对应）。 |
| 205 | class_destroy | 删除驱动类（/sys/class/key），与 class_create 对应。 |
3.4、编写测试 APP
新建名为 keyApp.c 的文件，然后输入如下所示内容：
#include <stdio.h> // 标准输入输出（printf） #include <unistd.h> // 系统调用（read/write/close） #include <sys/types.h> // 类型定义（如pid_t） #include <sys/stat.h> // 文件状态（open函数参数） #include <fcntl.h> // 文件控制（O_RDWR等宏） #include <stdlib.h> // 标准库（exit/atoi等） #include <string.h> // 字符串操作（本文未用到，预留） /* 按键值定义（和驱动一致！必须与驱动中KEY0VALUE/INVAKEY宏匹配） */ #define KEY0VALUE 0XF0 // 按键按下的标识值（对应驱动22行） #define INVAKEY 0X00 // 无效按键值（对应驱动23行） /* * @brief 主函数：应用层核心逻辑，与驱动交互读取按键值 * @param argc: 参数个数 * @param argv: 参数列表（需传入/dev/key设备节点路径） * @return 0:成功; 其他:失败 */ int main(int argc, char *argv[]) { int fd, ret; // fd：文件描述符；ret：函数返回值 char *filename; // 存储设备节点路径（如/dev/key） unsigned char keyvalue; // 存储从驱动读取的按键值 /* 步骤1：校验命令行参数 */ if(argc != 2){ // 必须传入1个参数（设备节点路径） printf("Usage: %s /dev/key\r\n", argv[0]); // 提示正确用法 return -1; // 参数错误，返回-1退出 } filename = argv[1]; // 保存传入的设备节点路径（如/dev/key） /* 步骤2：打开驱动设备节点 */ fd = open(filename, O_RDWR); // 以读写模式打开设备节点 if(fd < 0){ // 打开失败（如驱动未加载、节点不存在） printf("open %s failed!\r\n", filename); return -1; // 打开失败，返回-1退出 } /* 步骤3：循环读取按键值（核心逻辑） */ printf("Start read key value...\r\n"); // 提示开始读取 while(1) { // 死循环，持续检测按键 // 从驱动读取1字节数据（按键值）到keyvalue变量 read(fd, &keyvalue, sizeof(keyvalue)); // 判断是否读取到有效按键值（对应驱动68行设置的KEY0VALUE） if (keyvalue == KEY0VALUE) { printf("KEY0 Press, value = 0x%X\r\n", keyvalue); // 打印按键按下信息 } // 若为INVAKEY（未按键），无输出，继续循环 } /* 步骤4：关闭设备（实际不会执行到，因为上面是死循环） */ ret = close(fd); // 关闭文件描述符 if(ret < 0){ // 关闭失败 printf("close %s failed!\r\n", filename); return -1; } return 0; // 程序正常退出（实际不会执行） }| 行号 | 核心代码 | 关键说明 |
|---|---|---|
| 18-22 | if(argc != 2) | 校验命令行参数： ✅ 运行命令必须是 ✅ 若直接运行 |
| 25-30 | fd = open(filename, O_RDWR) | 打开设备节点的核心注意点： ✅ |
| 行号 | 核心代码 | 关键说明 |
|---|---|---|
| 37 | read(fd,&keyvalue,sizeof(keyvalue)) | 应用层与驱动层交互的核心 ✅ 调用 ✅ 参数说明：
✅ 驱动层通过 |
| 40 | if (keyvalue == KEY0VALUE) | 按键检测逻辑： ✅ 仅当读取到驱动设置的 ✅ 若为 ✅ 死循环 |
3.5、应用层与驱动层的交互流程
四、运行测试
4.1、编译驱动程序和测试 APP
编写 Makefile 文件，本次实验的 Makefile 文件和之前的led实验基本一样，只是将 obj-m 变量的值改为key.o，Makefile 内容如下所示：
KERNELDIR := /home/duan/linux/linux-imx-rel_imx_4.1.15_2.1.1_ga_alientek_v2.2 CURRENT_PATH := $(shell pwd) obj-m :=key.o build: kernel_modules kernel_modules: $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules clean: $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean 第 4 行，设置 obj-m 变量的值为key.o。
输入如下命令编译出驱动模块文件：
make -j32编译成功以后就会生成一个名为“key.ko”的驱动模块文件。
编译测试 APP
输入如下命令编译测试试keyApp.c这个测试程序：
arm-linux-gnueabihf-gcc keyApp.c -o keyApp编译成功以后就会生成 keyApp 这个应用程序。
4.2、运行测试
将上一小节编译出来的key.ko 和 keyApp这两个文件拷贝到 rootfs/lib/modules/4.1.15 目录中。
sudo cp key.ko /home/duan/linux/nfs/rootfs/lib/modules/4.1.15/ -fsudo cp keyApp /home/duan/linux/nfs/rootfs/lib/modules/4.1.15/ -f进入到目录 lib/modules/4.1.15 中，输入如下命令加载key.ko驱动模块：
depmod //第一次加载驱动的时候需要运行此命令 modprobe key.ko//加载驱动驱动加载成功以后如下命令来测试：
./keyApp /dev/key如下图所示：
按下开发板上的 KEY0 按键，keyApp 就会获取并且输出按键信息，如下图所示：
从上图可以看出，当我们按下 KEY0 以后就会打印出“KEY0 Press, value = 0XF0”，
表示按键按下。但是大家可能会发现，有时候按下一次 KEY0 但是会输出好几行“KEY0 Press,
value = 0XF0”，这是因为我们的代码没有做按键消抖处理。
如果要卸载驱动的话输入如下命令即可：
rmmod key.ko总结
本期博客完成了如何在 Linux 下编写 GPIO 输入驱动程序，我们就使用此按键来完成功能。同时使用原子操作来对按价值进行保护。
