linux驱动程序之定时器防按键抖动

时间：2021-10-30 23:36:12

前提：按键按下通过中断方式进行处理。本博文基于上一个博文改写：上一篇博文

目的：


使用定时器防止按键抖动产生中断。

方法：


每次发生按键中断后，推迟10ms进行处理，最终将会只执行一次定时器中断处理函数。这样就避免了按键抖动引起的误中断。

步骤：


1、定义一个定时器结构体

static struct timer_list button_timer;//定义一个定时器，用于按键消抖功能

2、在init函数中初始化这个定时器

init_timer(&button_timer);
button_timer.function = buttons_timer_function;
//button_timer.expires = 0;  //没有配置时默认值是0
add_timer(&button_timer);
其中：

init_timer初始化这个定时器

button_timer.function 告诉内核定时器中断发生后调用的处理函数为：buttons_timer_function

add_timer  将这个定时器告诉内核，可以开始了

3、定义定时器处理函数：

static void buttons_timer_function(unsigned long data)
这个函数的功能在本例子中就是都取按键键值，并发送信号，可将上一篇博文中的中断处理函数中的内容直接交给这个函数，即： 

static void buttons_timer_function(unsigned long data)
{
struct pin_desc * pindesc = irq_pd;
unsigned int pinval;



pinval = s3c2410_gpio_getpin(pindesc -> pin);
if(pinval)//松开
{
keyval = 0x80|pindesc->key_value;
}
else
{
keyval = pindesc->key_value;
}
ev_press =1;//中断发生
wake_up_interruptible(&button_wait_q);
kill_fasync(&button_async,SIGIO,POLL_IN);
}

注意：

设备描述符是从中断服务程序中获得，即irq_pd要从中断服务程序中获得（可定义一个全局变量）

4、修改按键中断服务程序

按键中断服务程序主要负责将到来的中断推迟10ms执行要进行的动作。

static irqreturn_t buttons_irq(int irq,void *dev_id)
{
irq_pd = (struct pin_desc *)dev_id;
 /*10ms后启动定时器*/
mod_timer(&button_timer,jiffies+HZ/100);
return IRQ_HANDLED;
}
irq_pd = (struct pin_desc *)dev_id; 即获得设备描述符

mod_timer 修改定时器目的值，这个值是以jiffies为基准，即现在时刻的值是jiffies，程序要在10ms后进行处理，所以 +HZ/200  1HZ=1s  

5、在定时器服务程序中增加一个条件：

if(!pindesc)//防止初始化时add_timer后立即执行定时器中断
return;
防止在init函数中进行addtimer后，系统会马上执行定时器服务程序，这与我们想要的是不符的


完整驱动驱动程序：

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <asm/io.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/irq.h>
#include <asm/uaccess.h>
#include <asm/irq.h>
#include <mach/regs-gpio.h>
#include <mach/irqs.h>//这个在/opt/EmbedSky/linux-2.6.30.4/arch/arm/mach-s3c2410/include/mach 路径
#include <linux/interrupt.h>
#include <linux/poll.h>

MODULE_LICENSE("Dual BSD/GPL");

static struct class *buttondrv_class;
static struct class_devices *buttondrv_class_dev;

/*  */
static DECLARE_WAIT_QUEUE_HEAD(button_wait_q);
/*中断事件标志，中断服务程序将他置1，read函数将他置0*/
static volatile int ev_press =0;

volatile unsigned long *gpfcon = NULL;
volatile unsigned long *gpfdat = NULL;

static struct timer_list button_timer;//定义一个定时器，用于按键消抖功能

static unsigned keyval;
static struct fasync_struct *button_async;

struct pin_desc{
unsigned int pin;
unsigned int key_value;
};
/*按键按下时是：0x01 0x02 0x03 0x04*/
/*按键松开时是：0x81 0x82 0x83 0x84*/
struct pin_desc pins_desc[4] =
{
{S3C2410_GPF1,0x01},
{S3C2410_GPF4,0x02},
{S3C2410_GPF2,0x03},
{S3C2410_GPF0,0x04},
};

static DECLARE_MUTEX(button_lock);//定义互斥锁

static struct pin_desc *irq_pd;

/*
 * 确定按键值
 */
static irqreturn_t buttons_irq(int irq,void *dev_id)
{
irq_pd = (struct pin_desc *)dev_id;
 /*10ms后启动定时器*/
mod_timer(&button_timer,jiffies+HZ/200);
return IRQ_HANDLED;
}
static int button_dev_open(struct inode *inode ,struct file* file)
{
if(file->f_flags & O_NONBLOCK)
{
//非阻塞
if(down_trylock(&button_lock))//如果无法获取这个信号量
{
return EBUSY;
}
}
else
{
//阻塞
down(&button_lock);
}

//配置按键的引脚 GPF0,1,2,4为输入引脚
request_irq(IRQ_EINT1,buttons_irq, IRQ_TYPE_EDGE_BOTH,"key1",&pins_desc[0]);
request_irq(IRQ_EINT4,buttons_irq, IRQ_TYPE_EDGE_BOTH,"key2",&pins_desc[1]);
request_irq(IRQ_EINT2,buttons_irq, IRQ_TYPE_EDGE_BOTH,"key3",&pins_desc[2]);
request_irq(IRQ_EINT0,buttons_irq, IRQ_TYPE_EDGE_BOTH,"key4",&pins_desc[3]);

return 0;
}
ssize_t button_dev_read(struct file *file,char __user *buf,size_t size,loff_t *ppos)
{
if(size !=1)
{
return -EINVAL;
}
if(file->f_flags & O_NONBLOCK)//阻塞
{
if(!ev_press)
return -EAGAIN;
}
else//阻塞
{
/*如果没有按键动作发生  就休眠*/
wait_event_interruptible(button_wait_q,ev_press);
}

/*如果有按键动作发生，直接返回*/
copy_to_user(buf,&keyval,1);
ev_press = 0;
return 0;
}
int button_dev_close(struct inode* inode ,struct file *file)
{
free_irq(IRQ_EINT1,&pins_desc[0]);
free_irq(IRQ_EINT4,&pins_desc[1]);
free_irq(IRQ_EINT2,&pins_desc[2]);
free_irq(IRQ_EINT0,&pins_desc[3]);

/*释放信号量*/
up(&button_lock);
return 0;
}

static int button_dev_fasync(int fd,struct file *filp,int on)
{
printk("button_dev_fasync  \n");
return fasync_helper(fd,filp,on,&button_async);
}
static struct file_operations button_sdv_fops =
{
.owner = THIS_MODULE,
.open  = button_dev_open,
.read = button_dev_read,
.release = button_dev_close,
.fasync= button_dev_fasync,
};
int major;

static void buttons_timer_function(unsigned long data)
{
struct pin_desc * pindesc = irq_pd;
unsigned int pinval;

if(!pindesc)//防止初始化时add_timer后立即执行定时器中断
return;

pinval = s3c2410_gpio_getpin(pindesc -> pin);
if(pinval)//松开
{
keyval = 0x80|pindesc->key_value;
}
else
{
keyval = pindesc->key_value;
}
ev_press =1;//中断发生
wake_up_interruptible(&button_wait_q);
kill_fasync(&button_async,SIGIO,POLL_IN);
}

static int button_dev_init(void)//入口函数
{
init_timer(&button_timer);
button_timer.function = buttons_timer_function;
//button_timer.expires = 0;  //没有配置时默认值是0
add_timer(&button_timer);

major = register_chrdev(0,"button_drv",&button_sdv_fops);

buttondrv_class = class_create(THIS_MODULE,"button_drv");
if(IS_ERR(buttondrv_class))
return PTR_ERR(buttondrv_class);
buttondrv_class_dev= device_create(buttondrv_class,NULL,MKDEV(major,0),NULL,"wq_button");
if(unlikely(IS_ERR(buttondrv_class_dev)))
return PTR_ERR(buttondrv_class_dev);

/*映射物理地址*/
gpfcon = (volatile unsigned long *) ioremap(0x56000050 ,16);
gpfdat = gpfcon + 1;

return 0;
}
static void button_dev_exit(void)
{
unregister_chrdev(major,"button_drv");
device_unregister(buttondrv_class_dev);
class_destroy(buttondrv_class);

iounmap(gpfcon);
}
module_init(button_dev_init);
module_exit(button_dev_exit);

完整测试程序：

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

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)
{
int ret=0;
int Oflags;
unsigned char key_val;
signal(SIGIO,my_signal_fun);
fd = open("/dev/wq_button",O_RDWR);//默认以阻塞方式打开
if(fd<0)
{
printf("can't open \n");
}


while(1)
{
unsigned char key_val;
ret = read(fd,&key_val,1);
printf("key_val: 0x%x  ret=%d\n",key_val,ret);
}
return 0;
}





标签：

相关文章