12.6重寫按鍵驅動——定時器防抖

學過單片機的都知道，按鍵可能會出現抖動現象。linux也一樣。

如下，出現兩次按下的輸出值

按鍵由於他的物理特性，可能會在按鍵鬆開時產生多次脈衝，每次脈衝都可能產生中斷。關鍵是消除多次讀取脈衝，只讀一次。引入定時器，每隔多少時間之後讀取（錯過抖動時序）。

 

一.內核定時器

參考《linux設備驅動程序p196》

如果我們需要在將來的某個時間點調度執行某個動作，同時在該時間點到達之前不會阻塞當前進程，則可以使用內核定時器。

 

頭文件和實現文件：<linux/timer.h>  <kernel/timer.c>

 

定時器API

struct timer_list {

    /*....*/

    unsigned long expires;

    void (*function)(unsigned long);

    unsigned long data;

    /*....*/

};

struct timer_list TIMER_INITIALIZER(_function,_expires,_data);  //定義結構體變量

void  init_timer(struct timer_list *timer);   //初始化

void add_timer(struct timer_list *timer);   //

int del_timer(struct timer_list *timer);

int mod_timer(struct timer_list *timer,unsigned long expires); //更新某個定時器的到期時間

 

 

全局變量jiffies_64就和HZ有關，它是一個64位整型變量，記錄了系統啓動以來時鐘中斷的個數（也就是tick數）。我們知道HZ是每秒鐘產生的時鐘中斷的個數，那麼jiffies_64每秒鐘就增加HZ大小的值，例如，如果HZ=250，那jiffies_64在一秒後會變爲jiffies_64+250，也就是精度爲1000/HZ毫秒。在timer_list定時器中設置到期時間時，我們會用 (jiffies + 5 * HZ) 來表示5秒後到期就是這個道理。

 

二.修改代碼支持定時器防抖

以前在中斷處理函數裏，我們做的是讀取按鍵值，異步通知。現在把這些代碼搬過去定時器的function中，實現按下按鍵後隔10ms後再讀取按鍵值。

步驟：

1.定義定時器結構體

2.初始化

 

3.把中斷處理函數的代碼搬過去定時器fuction中並修改，修改中斷處理函數

jiffies參考：Linux中的jiffies介紹

在中斷處理函數裏使用mod_timer，當發生中斷時，會更新超時時間，比如當前滴答時鐘爲100，設置110後就會去調用定時器的fuction函數。

 

4.釋放定時器

    del_timer(&mybuttons_timer);

 

三.代碼

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/irq.h>
#include <asm/uaccess.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <asm/arch/regs-gpio.h>
#include <asm/hardware.h>
#include <linux/poll.h>

#include <linux/timer.h>
static struct class *seconddrv_buttons_class;
static struct class_device *seconddrv_buttons_class_dev;
static struct fasync_struct *button_async;
volatile unsigned long *gpfcon;
volatile unsigned long *gpfdat;
volatile unsigned long *gpgcon;
volatile unsigned long *gpgdat;

struct timer_list mybuttons_timer;


static DECLARE_WAIT_QUEUE_HEAD(button_waitq); //定義並初始化等待隊列

//static int canopen=1;
static DECLARE_MUTEX(button_lock);     //定義互斥鎖

/* 中斷事件標誌, 中斷服務程序將它置1，third_drv_read將它清0 */
static volatile int ev_press = 0;

struct pin_desc{
    unsigned int pin;
    unsigned int key_val;
};
/* 鍵值: 按下時, 0x01, 0x02, 0x03, 0x04 */
/* 鍵值: 鬆開時, 0x81, 0x82, 0x83, 0x84 */
struct pin_desc pins_desc[4] = {
    {S3C2410_GPF0, 0x01},
    {S3C2410_GPF2, 0x02},
    {S3C2410_GPG3, 0x03},
    {S3C2410_GPG11, 0x04},
};
struct pin_desc *irq_dev;

static unsigned char key_val;

static irqreturn_t mybuttons_irq(int irq, void *dev_id)
{
    irq_dev=(struct pin_desc *)dev_id;
    mod_timer(&mybuttons_timer,jiffies+HZ/100);//jiffies是當前的tick，HZ代表1s,HZ/100=10ms.jiffies會++到jiffies+10ms後產生定時器中斷
    return IRQ_RETVAL(IRQ_HANDLED);
}
static int seconddrv_buttons_open(struct inode *inode, struct file *file)
{
    /*獲取信號量,只有第一個應用程序纔可以獲得，其餘應用程序會在這裏陷入休眠*/
    down(&button_lock);


    /*配置GPF0,2爲輸入引腳，中斷號參考arch\arm\plat-s3c24xx\Irq.c的s3c24xx_init_irq*/
    /*配置GPG3,11爲輸入引腳*/
    request_irq(IRQ_EINT0,  mybuttons_irq, IRQT_BOTHEDGE, "S1", &pins_desc[0]);
    request_irq(IRQ_EINT2,  mybuttons_irq, IRQT_BOTHEDGE, "S2", &pins_desc[1]);
    request_irq(IRQ_EINT11, mybuttons_irq, IRQT_BOTHEDGE, "S3", &pins_desc[2]);
    request_irq(IRQ_EINT19, mybuttons_irq, IRQT_BOTHEDGE, "S4", &pins_desc[3]);    
    //printk("seconddrv_open\n");
    return 0;
}
ssize_t seconddrv_buttons_read(struct file *file, char __user *buf,size_t size, loff_t *ppos)
{
    if (size != 1)
        return -EINVAL;
    // 沒有按鍵按下時，休眠
    //wait_event_interruptible(button_waitq, ev_press);
    
    //按鍵按下時
    copy_to_user(buf, &key_val,1);
    
    //ev_press = 0;
    return 1;
}
static int seconddrv_buttons_close(struct inode * inode, struct file * file)
{
    /*應用程序用完後，釋放信號量*/    
    up(&button_lock);

    free_irq(IRQ_EINT0, &pins_desc[0]);
    free_irq(IRQ_EINT2, &pins_desc[1]);
    free_irq(IRQ_EINT11, &pins_desc[2]);
    free_irq(IRQ_EINT19, &pins_desc[3]);
    return 0;
}
static unsigned int secondddrv_butttons_poll(struct file *file, struct poll_table_struct *wait)
{
  unsigned int mask = 0;
  
  poll_wait(file, &button_waitq, wait); // 不會立即休眠
    if (ev_press)                        //ev_press 不爲 0 時，poll 休眠直到time_out後break循環體 ，爲1時，break
        mask |= POLLIN | POLLRDNORM;
      return mask;
}
static int secondddrv_butttons_fasync(int fd, struct file *filp, int on)
{
    printk("secondddrv_butttons_fasync\n");
    return fasync_helper (fd, filp, on, &button_async);
}

static struct file_operations seconddrv_buttons_fops = {
    .owner  =   THIS_MODULE,    /* 這是一個宏，推向編譯模塊時自動創建的__this_module變量 */
    .open   =   seconddrv_buttons_open,           
    .read    =    seconddrv_buttons_read,  
    .release=   seconddrv_buttons_close,
    .poll   =   secondddrv_butttons_poll,
    .fasync =     secondddrv_butttons_fasync,
};

static void mybuttons_timerfun(unsigned long p)
{
    unsigned int pinval;
    struct pin_desc *pindesc =irq_dev;
    if(!pindesc)
        return;
    
    pinval = s3c2410_gpio_getpin(pindesc->pin);   //內核提供的讀取引腳值的函數
    if(pinval) // 1爲鬆開
    {
        key_val =0x80 | pindesc->key_val;
    }
    else
    {
        key_val =pindesc->key_val;
    }
    //ev_press = 1;                  /* 中斷標誌位=1，表示中斷髮生了 */
    //wake_up_interruptible(&button_waitq);   /* 喚醒休眠的進程 */\

    kill_fasync (&button_async, SIGIO, POLL_IN);

}


int major;
int seconddrv_buttons_init(void)
{

    init_timer(&mybuttons_timer); //初始化定時器
    //mybuttons_timer.data     = (unsigned long) SCpnt;  //function的傳參，不用可省略
    //mybuttons_timer.expires  = jiffies + 100*HZ;   /* 超時時間，放在中斷處理函數使用,沒有設置默認=0，即fuction會立即執行 */
    mybuttons_timer.function = mybuttons_timerfun;
    add_timer(&mybuttons_timer);


    major = register_chrdev(0,"seconddrv",&seconddrv_buttons_fops);
    seconddrv_buttons_class = class_create(THIS_MODULE,"buttons");
    seconddrv_buttons_class_dev = class_device_create(seconddrv_buttons_class,NULL,MKDEV(major,0),NULL,"mybuttons");
    
    gpfcon = (volatile unsigned long *)ioremap(0x56000050,16);
    gpfdat = gpfcon + 1;

    gpgcon = (volatile unsigned long *)ioremap(0x56000060,16);
    gpgdat = gpgcon +1;


    return 0;
}

void seconddrv_buttons_exit(void)
{
    unregister_chrdev(major,"seconddrv");
    class_destroy(seconddrv_buttons_class);
    class_device_unregister(seconddrv_buttons_class_dev);

    iounmap(gpfcon);
    iounmap(gpgcon);
    del_timer(&mybuttons_timer);
    return 0;
}
module_init(seconddrv_buttons_init);
module_exit(seconddrv_buttons_exit);
MODULE_LICENSE("GPL");

測試代碼：

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <poll.h>
#include <signal.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>


/* fifthdrvtest
  */
int fd;

void my_signal_fun(int signum)
{
    unsigned char key_val;
    read(fd, &key_val, 1);
    printf("key_val: 0x%x\n", key_val);
}

int main(int argc, char **argv)
{
    unsigned char key_val;
    int ret;
    int Oflags;

    signal(SIGIO, my_signal_fun);
    
    fd = open("/dev/mybuttons", O_RDWR);
    if (fd < 0)
    {
        printf("can't open!\n");
        return -1;
    }

    fcntl(fd, F_SETOWN, getpid());
    
    Oflags = fcntl(fd, F_GETFL);
    
    fcntl(fd, F_SETFL, Oflags | FASYNC);


    while (1)
    {
        sleep(1000);
    }
    
    return 0;
}

測試結果：