【更适合初学者的开发板ELF 1】+ 按键中断测试

TLLED

学习linux下按键中断程序的测试。

一、硬件部分

按键硬件部分电路


二、程序部分

2.1、修改设备树文件
将设备中，按键这个几个引脚屏蔽掉


2.2、编译设备树

编译设备树，并将编译的文件复制到开发板

2.3、开发板更新设备数据文件
执行命令：
root@ELF1:~# sync
root@ELF1:~# reboot


2.4、驱动程序
key_irq.c

1. #include <linux/module.h>       // 包含模块相关函数的头文件
   
2. #include <linux/fs.h>           // 包含文件系统相关函数的头文件
   
3. #include <linux/uaccess.h>      // 包含用户空间数据访问函数的头文件
   
4. #include <linux/cdev.h>         //包含字符设备头文件
   
5. #include <linux/device.h>
   
6. #include <linux/gpio.h>
   
7. #include <linux/interrupt.h>
   
8. 
   
9. #define DEVICE_NAME "key_irq"  // 设备名称
   
10. #define GPIO_KEY1_PIN_NUM 132   //K1
    
11. #define GPIO_KEY2_PIN_NUM 130   //K1
    
12. #define GPIO_KEY3_PIN_NUM 137   //K3
    
13. #define KEY1_IRQ  gpio_to_irq(GPIO_KEY1_PIN_NUM)
    
14. #define KEY2_IRQ  gpio_to_irq(GPIO_KEY2_PIN_NUM)
    
15. #define KEY3_IRQ  gpio_to_irq(GPIO_KEY3_PIN_NUM)
    
16. 
    
17. static struct workqueue_struct *my_workqueue;
    
18. static struct work_struct my_work;
    
19. 
    
20. static dev_t dev_num;   //分配的设备号
    
21. struct  cdev my_cdev;          //字符设备指针
    
22. int major;  //主设备号
    
23. int minor;  //次设备号
    
24. static struct class *key_irq;
    
25. static struct device *my_device;
    
26. 
    
27. static irqreturn_t key1_interrupt_handler(int irq, void *dev_id)
    
28. {
    
29.     int key1_state = gpio_get_value(GPIO_KEY1_PIN_NUM);
    
30.     if (key1_state) {
    
31.         printk(KERN_INFO "key1 released\n");
    
32.     } else {
    
33.         printk(KERN_INFO "key1 pressed\n");
    
34.     }
    
35.     return IRQ_HANDLED;
    
36. }
    
37. 
    
38. static irqreturn_t key2_interrupt_handler(int irq, void *dev_id)
    
39. {
    
40.     int key2_state = gpio_get_value(GPIO_KEY2_PIN_NUM);
    
41.     if (key2_state) {
    
42.         printk(KERN_INFO "key2 released\n");
    
43.     } else {
    
44.         printk(KERN_INFO "key2 pressed\n");
    
45.     }
    
46.     return IRQ_HANDLED;
    
47. }
    
48. 
    
49. static irqreturn_t key3_interrupt_handler(int irq, void *dev_id)
    
50. {
    
51.     int key3_state = gpio_get_value(GPIO_KEY3_PIN_NUM);
    
52.     if (key3_state) {
    
53.         printk(KERN_INFO "key3 released\n");
    
54.     } else {
    
55.         printk(KERN_INFO "key3 pressed\n");
    
56.     }
    
57.     return IRQ_HANDLED;
    
58. }
    
59. 
    
60. static int device_open(struct inode *inode, struct file *file)
    
61. {
    
62.     gpio_direction_input(GPIO_KEY1_PIN_NUM);
    
63.     gpio_direction_input(GPIO_KEY2_PIN_NUM);
    
64.     gpio_direction_input(GPIO_KEY3_PIN_NUM);
    
65.     printk(KERN_INFO "This is device_open.\n");
    
66.     return 0;
    
67. }
    
68. 
    
69. static int device_release(struct inode *inode, struct file *file)
    
70. {
    
71.     gpio_direction_input(GPIO_KEY1_PIN_NUM);
    
72.     gpio_direction_input(GPIO_KEY2_PIN_NUM);
    
73.     gpio_direction_input(GPIO_KEY3_PIN_NUM);
    
74.     printk(KERN_INFO "This is device_release.\n");
    
75.     return 0;
    
76. }
    
77. 
    
78. static struct file_operations fops =
    
79. {
    
80.     .owner = THIS_MODULE,
    
81.     .open = device_open,
    
82.     .release = device_release,
    
83. };
    
84. 
    
85. static int __init keyirq_init(void)
    
86. {
    
87.     int ret;
    
88.     gpio_free(GPIO_KEY1_PIN_NUM);
    
89.     gpio_free(GPIO_KEY2_PIN_NUM);
    
90.     gpio_free(GPIO_KEY3_PIN_NUM);
    
91.     gpio_request(GPIO_KEY1_PIN_NUM, "key_irq1");
    
92.     gpio_request(GPIO_KEY2_PIN_NUM, "key_irq2");
    
93.     gpio_request(GPIO_KEY3_PIN_NUM, "key_irq3");
    
94.         /*if (gpio_request(GPIO_KEY_PIN_NUM, "key_irq"))
    
95.     {
    
96.                 printk("request %s gpio faile \n", "key_irq");
    
97.                 return -1;
    
98.         }*/
    
99.     gpio_direction_input(GPIO_KEY1_PIN_NUM);
    
100.     gpio_direction_input(GPIO_KEY2_PIN_NUM);
     
101.     gpio_direction_input(GPIO_KEY3_PIN_NUM);
     
102. 
     
103.     request_irq(KEY1_IRQ, key1_interrupt_handler, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "key_irq1", NULL);
     
104.     request_irq(KEY2_IRQ, key2_interrupt_handler, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "key_irq2", NULL);
     
105.     request_irq(KEY3_IRQ, key3_interrupt_handler, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "key_irq3", NULL);
     
106. 
     
107.     // 注册中断处理函数
     
108.     /*ret = request_irq(BUTTON_IRQ, button_interrupt_handler, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "key_irq", NULL);
     
109.     if (ret < 0) {
     
110.         printk(KERN_ALERT "Failed to register interrupt handler\n");
     
111.         gpio_free(GPIO_KEY_PIN_NUM);
     
112.         return ret;
     
113.     }*/
     
114.        
     
115.     // 注册字符设备驱动程序
     
116.     ret = alloc_chrdev_region(&dev_num,0,1,DEVICE_NAME);
     
117.     if (ret < 0)
     
118.     {
     
119.         printk(KERN_ALERT "Failed to allocate device number: %d\n", ret);
     
120.         return ret;
     
121.     }
     
122.     major=MAJOR(dev_num);
     
123.     minor=MINOR(dev_num);
     
124.         printk(KERN_INFO "major number: %d\n",major);
     
125.         printk(KERN_INFO "minor number: %d\n",minor);
     
126. 
     
127.         my_cdev.owner = THIS_MODULE;
     
128.     cdev_init(&my_cdev,&fops);
     
129.     cdev_add(&my_cdev,dev_num,1);
     
130.     // 创建设备类
     
131.     key_irq = class_create(THIS_MODULE, "key_irq");
     
132.     if (IS_ERR(key_irq))
     
133.     {
     
134.         pr_err("Failed to create class\n");
     
135.         return PTR_ERR(key_irq);
     
136.     }
     
137.   // 创建设备节点并关联到设备类
     
138.     my_device = device_create(key_irq, NULL, MKDEV(major, minor), NULL, DEVICE_NAME);
     
139.     if (IS_ERR(my_device))
     
140.     {
     
141.         pr_err("Failed to create device\n");
     
142.         class_destroy(key_irq);
     
143.         return PTR_ERR(my_device);
     
144.     }
     
145.     printk(KERN_INFO "Device registered successfully.\n");
     
146.     return 0;
     
147. }
     
148. 
     
149. static void __exit keyirq_exit(void)
     
150. {
     
151.     // 释放中断
     
152.     free_irq(KEY1_IRQ, NULL);
     
153.     free_irq(KEY2_IRQ, NULL);
     
154.     free_irq(KEY3_IRQ, NULL);
     
155.     // 在这里执行驱动程序的清理操作
     
156.     gpio_free(GPIO_KEY1_PIN_NUM);
     
157.     gpio_free(GPIO_KEY2_PIN_NUM);
     
158.     gpio_free(GPIO_KEY3_PIN_NUM);
     
159.     // 销毁设备节点
     
160.     device_destroy(key_irq, MKDEV(major, minor));
     
161.     // 销毁设备类
     
162.     class_destroy(key_irq);
     
163.     // 删除字符设备
     
164.     cdev_del(&my_cdev);
     
165.     // 注销字符设备驱动程序
     
166.     unregister_chrdev(0, DEVICE_NAME);
     
167.     printk(KERN_INFO "Device unregistered.\n");
     
168. }
     
169. 
     
170. module_init(keyirq_init);
     
171. module_exit(keyirq_exit);
     
172. 
     
173. MODULE_LICENSE("GPL");      // 指定模块的许可证信息
     
174. MODULE_AUTHOR("Your Name"); // 指定模块的作者信息
     
175. MODULE_DESCRIPTION("A simple character device driver"); // 指定模块的描述信息
     

复制代码

2.5、编译

编译完成后，编译的文件复制到开发板

三、运行

3.1、插入模块


3.2、按键测试
按下按键后，打印出相应按键的状态


3.3、卸载模块


以上就是测试按键中断的测试过程。