按键驱动程序抖动问题会造成多次中断发生，实则可能是一次按下或释放的操作。本驱动程序就是在按键驱动程序（中断方式） 的基础之上，用定时器来去抖动。
当一次按键按下的时候，可能产生多个脉冲，我们可以等到最后一个脉冲平稳时再真正地做按下或释放的处理。所以，在中断中我们可以不断修改定时器的值，当最后稳定下来，没有中断产生了，就会调用超时函数，再在超时函数里面判断按键状态，返回值给用户空间等。
定时器的操作：
1.定义timer_list结构体。
2.定义超时函数。
3.在初始化函数绑定定时器结构体和超时函数，初始化定时器结构体等操作。用到
#define setup_timer(timer, fn, data)     \
 do {        \
  static struct lock_class_key __key;   \
  setup_timer_key((timer), #timer, &__key, (fn), (data));\
 } while (0)
这个是在2.6.32内核里面进行的初始化设置，在低版本中可能包括init和add等操作。
4.在中断函数里修改定时器。用到
int mod_timer(struct timer_list *timer, unsigned long expires)
详细驱动程序如下：

点击(此处)折叠或打开

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/fs.h>
  4. #include <linux/init.h>
  5. #include <linux/delay.h>
  6. #include <linux/irq.h>
  7. #include <asm/uaccess.h>
  8. #include <linux/cdev.h>
  9. #include <linux/interrupt.h>
  10. #include <linux/device.h>
  11. #include <linux/sched.h>
  12. #include <linux/gpio.h>

  14. #define SEVENTHDEV MKDEV(250, 0)
  15. struct cdev seventhdrv_cdev;

  17. static struct class *seventhdrv_class;

  19. struct button {
  20.     int irq;
  21.     char *name;
  22.     int pin;
  23.     int val;
  24. };

  26. static volatile int pressed = 0;
  27. static unsigned char key_val;

  29. struct fasync_struct *button_async;
  30. static struct timer_list seventh_timer;
  31. static struct button *buttonp = NULL;
  32. DECLARE_WAIT_QUEUE_HEAD(button_wqh);

  34. /* 六个按键的相关定义整合到结构体 */
  35. static struct button buttons[6] = {
  36.         {IRQ_EINT8, "K1", S3C2410_GPG(0), 0x1},
  37.         {IRQ_EINT11, "K2", S3C2410_GPG(3), 0x2},
  38.         {IRQ_EINT13, "K3", S3C2410_GPG(5), 0x3},
  39.         {IRQ_EINT14, "K4", S3C2410_GPG(6), 0x4},
  40.         {IRQ_EINT15, "K5", S3C2410_GPG(7), 0x5},
  41.         {IRQ_EINT19, "K6", S3C2410_GPG(11),0x6},
  42. };


  45. static DECLARE_MUTEX(button_lock);

  47. /* 中断处理函数 */
  48. static irqreturn_t seventhdrv_intr(int irq, void *data)
  49. {
  50.     buttonp = (struct button*)data;
  51.     mod_timer(&seventh_timer, jiffies+HZ/100);
  52.     return IRQ_RETVAL(IRQ_HANDLED);
  53. }

  55. static int seventhdrv_open(struct inode * inode, struct file * file)
  56. {
  57.     int i=6;
  58.      if (file->f_flags & O_NONBLOCK) {
  59.         if(down_trylock(&button_lock))
  60.             return -EBUSY;
  61.         } else {
  62.            down(&button_lock);
  63.         }
  64.     while(i--){
  65.         request_irq(buttons[i].irq, &seventhdrv_intr, IRQ_TYPE_EDGE_BOTH,
  66.                     buttons[i].name, &buttons[i]);
  67.     }
  68.     return 0;
  69.     
  70. }

  72. static ssize_t seventhdrv_read(struct file *file, char __user *user, size_t size,loff_t*o)
  73. {
  74.     int sz = sizeof(key_val) ;
  75.     
  76.     if (sz != size) {
  77.         return -EINVAL;
  78.     }
  79.     
  80.     if (file->f_flags & O_NONBLOCK)
  81.     {
  82.         if (!pressed)
  83.             return -EAGAIN;
  84.     }
  85.     else
  86.     {
  87.         /* 如果没有按键动作, 休眠 */
  88.         wait_event_interruptible(button_wqh, pressed);
  89.     }
  90.     copy_to_user(user, &key_val, sz);

  92.     /* 重新清除按下标志 */
  93.     pressed = 0;

  95.     return sz;
  96. }

  98. static int seventhdrv_close(struct inode *inode, struct file *file)
  99. {
  100.     int i=6;
  101.     
  102.     while(i--) {
  103.         free_irq(buttons[i].irq, &buttons[i]);
  104.     }
  105.     up(&button_lock);
  106.     return 0;
  107. }

  109. static struct file_operations seventhdrv_ops = {
  110.     .owner = THIS_MODULE,
  111.     .open = seventhdrv_open,
  112.     .read = seventhdrv_read,
  113.     .release = seventhdrv_close,
  114. };

  116. static void button_timer(unsigned long data)
  117. {
  118.     int val;
  119.     if (buttonp == NULL) {
  120.         printk(KERN_INFO "No button pressed!\n");
  121.         return ;
  122.     }
  123.     
  124.     val = s3c2410_gpio_getpin(buttonp->pin);
  125.     
  126.     if (!val) {/* 按下按键*/
  127.         key_val = buttonp->val;    
  128.     } else { /* 释放按键*/
  129.         key_val = buttonp->val | 0x10; //将第4位置1，做标记
  130.     }

  132.     pressed = 1; //此处改变按下标志，以使队列不继续睡眠
  133.     wake_up_interruptible(&button_wqh);

  135.     buttonp = NULL;
  136. }

  138. static int seventhdrv_init(void)
  139. {
  140.     int ret;
  141.     int devt = SEVENTHDEV;
  142.     
  143.     ret = register_chrdev_region(devt, 1, "seventhdrv");
  144.     if (ret) {
  145.         printk(KERN_ERR "Unable to register minors for seventhdrv\n");
  146.         goto fail;
  147.     }
  148.     seventhdrv_class = class_create(THIS_MODULE, "seventhdrv_class");
  149.     if (IS_ERR(seventhdrv_class)) {
  150.         printk(KERN_ERR "can't register device class\n");
  151.         return PTR_ERR(seventhdrv_class);
  152.     }
  153.     device_create(seventhdrv_class, NULL, devt, NULL, "buttons");
  154.     cdev_init(&seventhdrv_cdev, &seventhdrv_ops);
  155.     ret = cdev_add(&seventhdrv_cdev, devt, 1);
  156.     if (ret < 0)
  157.         goto fail_cdev;
  158.     setup_timer(&seventh_timer, button_timer, (unsigned long)&buttons);
  159.     return 0;
  160.     
  161. fail_cdev:
  162.     class_unregister(seventhdrv_class);
  163.     device_destroy(seventhdrv_class, devt);
  164.     cdev_del(&seventhdrv_cdev);
  165. fail:
  166.     unregister_chrdev_region(devt, 1);
  167.     
  168.     return 0;
  169. }

  171. static void seventhdrv_exit(void)
  172. {
  173.     class_unregister(seventhdrv_class);
  174.     device_destroy(seventhdrv_class, SEVENTHDEV);
  175.     cdev_del(&seventhdrv_cdev);
  176.     unregister_chrdev_region(SEVENTHDEV, 1);
  177. }

  179. module_init(seventhdrv_init);
  180. module_exit(seventhdrv_exit);
  181. MODULE_LICENSE("GPL");
应用程序为：

点击(此处)折叠或打开

  1. #include <sys/types.h>
  2. #include <sys/stat.h>
  3. #include <fcntl.h>
  4. #include <stdio.h>
  5. #include <signal.h>

  7. int main(int argc, char *argv[])
  8. {
  9.     int fd, cnt=1;
  10.     unsigned char val;
  11.     
  12.     fd = open("/dev/buttons", O_RDWR);
  13.     
  14.     if (fd < 0)
  15.     {
  16.         printf("Can not open device\n");
  17.         return -1;
  18.     }

  20.     while(1)
  21.     {
  22.         read(fd, &val, sizeof(unsigned char));
  23.         printf("cnt:%d, val:0x%x\n", cnt++, val);
  24.     }
  25.     
  26.     return 0;
  27. }

# linux
Logo
Linux

更多推荐

网卡速率和双工模式的配置

http://linux.chinaitlab.com/system/792187.html1、mii-tool 配置网络设备协商方式的工具；    1.1 mii-tool 介绍；    mii-tool - view, manipulate media-independent interface status （mii-tool 是查看，管理介质的网络接口的状态）

avatar Linux

Linux虚拟文件系统之文件系统卸载（sys_umount())

Linux中卸载文件系统由umount系统调用实现，入口函数为sys_umount()。较于文件系统的安装较为简单，下面是具体的实现。1. /*sys_umont系统调用*/2. SYSCALL_DEFINE2(umount, char __user *, name, int, flags)3. {4.struct path path;

avatar Linux

Linux系统下超级终端Minicom的使用方法（例如：连接交换机，路由器等）转http://baike.baidu.com/view/2911642.htm?fr=ala0_1

<br />　　Linux系统下超级终端Minicom的使用方法 <br />　　Linux下的Minicom的功能与下的超级终端功能相似，适于在通过超级终端对设备的管理以及对嵌入操作系统的升级，现写出Minicom的使用手册： <br />　　1． 启动minicom <br />　　以root权限登录系统 <br />　　使用命令 <br />　　minicom –s 则minicom启动，屏

avatar Linux