定时器防抖动

比眉伴天荒 2022-07-24 09:12 146阅读 0赞

/\*功能:使用定时器防抖动  
\*2016年5月14日20:35:13  
\*/  
\#include <linux/module.h>  
\#include <linux/kernel.h>  
\#include <linux/fs.h>  
\#include <linux/init.h>  
\#include <linux/delay.h>  
\#include <asm/uaccess.h>  
\#include <asm/irq.h>  
\#include <linux/irq.h>  
\#include <asm/io.h>  
\#include <asm/arch/regs-gpio.h>  
\#include <asm/hardware.h>  
  
  
  
  
static struct class \*seventhdrv\_class;  
static struct class\_device \*seventhdrv\_class\_devs\[4\];  
  
  
volatile unsigned long \* gpfcon;  
volatile unsigned long \* gpfdat;  
  
  
volatile unsigned long \* gpgcon;  
volatile unsigned long \* gpgdat;  
  
  
  
  
/\*  
\*  
确定按键值 s3c2410\_gpio\_getpin  
\*/  
  
  
struct pin\_desc\{  
unsigned int pin;  
unsigned int key\_val;  
\};  
  
  
/\*键值:按下时:0x01,0x02,0x03x0x04\*/  
/\*键值:松开时:0x81,0x82,0x83,0x84\*/  
  
  
  
  
struct pin\_desc pins\_desc\[4\] = \{  
\{S3C2410\_GPF0,0x01\},   
\{S3C2410\_GPF2,0x01\},  
\{S3C2410\_GPG3,0x01\},  
\{S3C2410\_GPG11,0x01\},  
  
  
\};  
  
  
/\*发生中断时的引脚描述\*/  
static struct pin\_desc \* irq\_pd;  
/\*定义定时器结构体\*/  
static struct timer\_list buttons\_timer;  
  
  
static unsigned char key\_val;  
  
  
//static int canopen = 1;  对应open函数中if方法  
//atomic\_t canopen = ATOMIC\_INIT(1);     //定义原子变量v并初始化为0  
  
  
static DECLARE\_MUTEX(button\_lock);     // 定义一个名称为button\_lock的信号量，并将信号量初始化为1 。定义互斥锁   
  
  
  
  
static struct fasync\_struct \*button\_async;  
  
  
static DECLARE\_WAIT\_QUEUE\_HEAD(button\_waitq);  
  
  
/\* 中断事件标志, 中断服务程序将它置1，seventh\_drv\_read将它清0 \*/  
static volatile int ev\_press = 0;  
  
  
  
  
static irqreturn\_t buttons\_irq(int irq, void \*dev\_id)  
\{  
/\* 记录下引脚描述 \*/  
irq\_pd = (struct pin\_desc \*)dev\_id;  
/\* 10ms后启动定时器 ，定时器其实是在定时器链表中存放的，  
每一个时钟中断都会检查链表中的哪个定时器时间到了，并执行相应的定时器处理函数\*/  
/\*修改定时器的超时时间expires\*/  
mod\_timer(&buttons\_timer, jiffies+HZ/100);//HZ可以将理解为1秒  
/\*闹钟什么时候到，是基于jiffies这个值的，这个值是个全局变量，这个值每隔十毫秒就会有个系统时钟中断  
在系统时钟中断里面，jiffies这个值就会累加 HZ是用来定义每一秒有几次timer interrupts。  
Jiffies为Linux核心变数(unsigned long)，它被用来记录系统自开机以来，已经过了多少tick。每发生一次  
timer interrupt，Jiffies变数会被加一\*/  
/\*  
LINUX系统时钟频率是一个常数HZ来决定的，通常HZ＝100，那么他的精度度就是10ms  
（毫秒）。也就是说每10ms一次中断。所以一般来说Linux的精确度是10毫秒  
\*/  
  
return IRQ\_HANDLED;  
\}  
  
  
static int seventh\_drv\_open(struct inode \* inode, struct file \* file)  
\{  
  
  
\#if  0   
/\*第一次执行open函数时，--canopen!=0不成立，所以执行if后面的函数  
从第二次以后 --canopen!=0 都成立，所以会返回错误，即表示不能第二次打开  
该方法有BUG，因为linux是多任务操作系统，在 执行--canopen != 0期间的取值时，  
cpu可能会被切换出去，去执行另一个程序打开open函数后，再返回继续执行--canopen != 0  
接下来的程序，结果是两个应用程序都成功打开了设备\*/.  
  
if(--canopen != 0)  
\{  
canopen ++;  
return -EBUSY;  
  
  
\}  
\#endif  
  
  
/\*获取信号量,如果是第一次执行open函数的话，就可以获得信号量，当第二个程序在执行open函数时，就无法获得信号量，  
就会进入不可中断的休眠状态，只有第一个应用程序把button\_lock这个信号量释放的时候，第二个应用程序才会被唤醒  
继续执行。  
down系列函数会使信号量的值减1  
up会使信号量的值加1  
调用down的进程不允许被中断，\*/  
  
  
/\*对open函数传入的O\_NONBLOCK标志位的处理，在file这个结构体中，这个结构是内核给我们提供的\*/  
if(file->f\_flags & O\_NONBLOCK)  
\{  
/\*如果打不开这个设备就会立刻返回错误\*/  
if(down\_trylock(&button\_lock))  
return -EBUSY;  
  
  
\}  
else  
\{  
  
down(&button\_lock);  
\}  
  
  
\#if 0  
/\*  
int atomic\_dec\_and\_test(atomic\_t \*v); //自减操作后测试其是否为0，为0则返回true，否则返回false。  
atomic\_t v = ATOMIC\_INIT(0);     //定义原子变量v并初始化为0  
atomic\_read(atomic\_t \*v);        //返回原子变量的值  
void atomic\_inc(atomic\_t \*v);    //原子变量增加1  
void atomic\_dec(atomic\_t \*v);    //原子变量减少1  
\*/  
  
  
if(!atomic\_dec\_and\_test(&canopen))   /\*被执行过一次之后，canopen变为0\*/  
\{  
atomic\_inc(&canopen);  
return -EBUSY;  
  
\}  
  
  
\#endif  
  
  
/\*配置GPF0,2  位输入引脚 \*/  
/\*配置GPG3,11为输入引脚 \*/  
/\*  
IRQ\_EINT0是在irqs.h中定义的  
IRQT\_BOTHEDGE是在s3c\_irqext\_type函数中找到，在irq.h中定义  
\*/  
  
  
//向内核注册中断处理函数  
request\_irq(IRQ\_EINT0,buttons\_irq,IRQT\_BOTHEDGE,"s2",&pins\_desc\[0\]);  
request\_irq(IRQ\_EINT2,buttons\_irq,IRQT\_BOTHEDGE,"s3",&pins\_desc\[1\]);  
request\_irq(IRQ\_EINT11,buttons\_irq,IRQT\_BOTHEDGE,"s4",&pins\_desc\[2\]);  
request\_irq(IRQ\_EINT19,buttons\_irq,IRQT\_BOTHEDGE,"s5",&pins\_desc\[3\]);  
  
  
  
  
  
return 0;  
\}  
  
  
  
  
  
  
  
  
  
  
/\*函数的参数是用户空间的函数的参数\*/  
static ssize\_t seventh\_drv\_read(struct file \*file, const \_\_user char \*buffer,size\_t count, loff\_t \*ppos)  
\{  
if(count != 1)  
return -EINVAL;//返回错误值  
  
  
  
  
if (file->f\_flags & O\_NONBLOCK)  
\{  
/\*判断有没有按键按下，没有按键按下的话\*/  
if (!ev\_press)  
return -EAGAIN;/\*如果你连续做read操作而没有数据可读。此时程序不会阻塞起来等待数据准备就绪返回，  
read函数会返回一个错误EAGAIN，提示你的应用程序现在没有数据可读请稍后再试,再次执行\*/  
\}  
else  
\{  
  
/\*如果没有按键按下:进入休眠(让出CPU，不返回)\*/  
wait\_event\_interruptible(button\_waitq,ev\_press);  
  
\}  
  
  
  
  
  
/\*如果休眠的程序被唤醒，则会从wait\_event\_interruptible继续往下执行\*/  
  
  
  
  
/\*如果有按键动作发生，则直接返回键值\*/  
copy\_to\_user(buffer ,&key\_val,1);  
ev\_press = 0;  
return 1;  
  
  
  
  
  
\}  
  
  
  
  
  
  
static void buttons\_timer\_function(unsigned long data)  
\{  
/\*利用设备号来传递引脚号和值\*/  
struct pin\_desc \* pindesc = irq\_pd;  
unsigned int pinval ;  
if(!pindesc)  
return;  
  
pinval = s3c2410\_gpio\_getpin(pindesc->pin);//系统提供的读取引脚状态的函数  
  
  
if(pinval)  
\{  
/\*按键松开\*/  
key\_val = 0x80 | pindesc->key\_val;  
  
\}  
else  
\{  
/\*按键按下\*/  
  
key\_val = pindesc->key\_val;  
  
  
\}  
  
  
ev\_press = 1;                  /\* 表示中断发生了 \*/  
  
  
/\*由kill\_fasync函数发出SIGIO信号，发给谁，是在button\_async这个结构中定义的  
button\_async这个结构要在seventh\_drv\_fasync函数中进行初始化  
在内核里面一般向应用程序发出的是SIGIO信号，表示有数据可供读写\*/  
\*/   
kill\_fasync(&button\_async, SIGIO, POLL\_IN);  
  
    wake\_up\_interruptible(&button\_waitq);   /\* 唤醒休眠的进程 \*/  
  
  
\}  
  
  
/\*入口函数\*/  
int major;  
static int seventh\_drv\_init (void)  
\{  
/\*初始化定时器,没有设置超时时间，则超时时间就是0\*/  
init\_timer(&buttons\_timer);  
buttons\_timer.function = buttons\_timer\_function;  
/\*告诉内核，启动定时器，当定时器的超时时间一到就会调用buttons\_timer\_function\*/  
/\*当启动定时器到达第一个时钟中断时，jiffies>=0,则会立刻调用定时器处理函数，此时还没有按键产生，则要在  
定时器处理函数中判断一下是否有中断\*/  
add\_timer(&buttons\_timer);  
  
major = register\_chrdev(0,"secod\_drv",&seventh\_drv\_fops);  
  
  
seventhdrv\_class = class\_create(THIS\_MODULE, "secod\_drv");//创建个类  
  
seventhdrv\_class\_devs = class\_device\_create(seventhdrv\_class, NULL, MKDEV(major, 0), NULL, "buttons"); /\* /dev/buttons \*/  
  
  
  
gpfcon = (volatile unsigned long \*)ioremap(0x56000050,16);  
gpfdat = gpfcon + 1;//指向0x56000054  
  
  
gpgcon = (volatile unsigned long \*)ioremap(0x56000060,16);  
gpgdat = gpgcon + 1;//指向0x56000064  
  
  
return 0;  
  
  
\}  
  
  
  
  
  
  
/\*出口函数\*/  
int major;  
static int seventh\_drv\_exit (void)  
\{  
unregister\_chrdev(major,"secod\_drv");  
  
class\_device\_unregister(seventhdrv\_class\_devs);  
   
class\_destroy(seventhdrv\_class);  
  
  
  
iounmap(gpfcon);   
iounmap(gpgcon);  
return 0;  
  
  
\}  
  
  
int seventh\_drv\_close (struct inode \* inode, struct file \* file)  
\{  
/\* canopen ++;是配合只能一次打开open函数?当open函数真正被打开后，  
canopen的值为0，此时不能在被任何应用程序打开，当打开的open函数被关闭时canopen  
的值变为1，以便下次再被应用程序打开\*/  
  
  
//canopen ++;  对应于open函数中的if语句  
  
  
//atomic\_inc(&canopen);  
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\]);  
up(&button\_lock);/\*第一个程序运行完后，释放掉信号量\*/  
return 0;  
  
  
\}  
  
  
  
  
/\*如果seventh\_drv\_poll函数返回的是0，则当前进程会进入休眠状态，直到超时被唤醒，返回到用户态,  
用户态的poll函数返回0，或者是seventh\_drv\_poll函数返回非0，返回到用户态\*/  
static unsigned int seventh\_drv\_poll(struct file \*file, poll\_table \*wait)  
\{  
unsigned int mask = 0;  
/\*poll\_wait函数是将当前进程挂到button\_waitq队列中，不会使当前进程立即进入休眠  
使当前进程进入休眠是在其他的内核中的函数中实现的\*/  
poll\_wait(file, &button\_waitq, wait); // 不会立即休眠  
  
  
if (ev\_press)  
mask |= POLLIN | POLLRDNORM;  
  
  
return mask;  
  
  
\}  
f\_owner  
static int seventh\_drv\_fasync (int fd, struct file \*filp, int on)  
\{  
printk("driver: seventh\_drv\_fasync\\n");  
/\*  
fasync\_helper函数初始化button\_async这个结构体，初始化后，  
kill\_fasync(&button\_async, SIGIO, POLL\_IN);这个函数就能给应用程序发送信号了  
  
  
\*/  
return fasync\_helper (fd, filp, on, &button\_async);  
\}  
  
  
  
  
static struct file\_operations seventh\_drv\_fops = \{  
    .owner   =   THIS\_MODULE,    /\* 这是一个宏，推向编译模块时自动创建的\_\_this\_module变量 \*/  
    .open    =   seventh\_drv\_open,    //表示将first\_drv\_open函数的地址赋给file\_operations结构体中open函数，  
.read = seventh\_drv\_read, //以后执行 first\_drv\_open函数时会自动调用file\_operations结构体中的open函数  
.release =  seventh\_drv\_close,//关闭设备的时候，释放open函数中注册中断处理函数的irq  
.poll    =  seventh\_drv\_poll,  
.fasync  =  seventh\_drv\_fasync,  
\};  
  
  
/\*修饰\*/  
modules\_init(seventh\_drv\_init);  
modules\_exit(seventh\_drv\_exit);

MODULE\_LICENSE("GPL");

//测试函数

/\*功能:使用定时器防抖动  
2016年5月14日20:35:35\*/  
\#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>  
  
  
  
  
/\*  
阻塞操作  
是指在执行设备操作时若不能获得资源则挂起进程，直到满足可操作的条件后再进行操作  
被挂起的进程进入休眠状态，被从调度器的运行队列移走，直到等待的条件被满足  
非阻塞操作  
进程在不能进行设备操作时并不挂起，它或者放弃，或者不停地查询，直至可以进行操作.  
\*/  
  
  
  
  
/\* sixthdrvtest   
  \*/  
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这个信号挂接处理函数  
在内核里面一般向应用程序发出的是SIGIO信号\*/  
signal(SIGIO, my\_signal\_fun);  
  
  
/\*默认为非阻塞 \*/  
fd = open("/dev/buttons", O\_RDWR );  
if (fd < 0)  
\{  
printf("can't open!\\n");  
return -1;  
\}  
  
\#if 0   
  
  
/\*buttons这个设备就是驱动程序\*/  
/\*F\_GETFL ：读取文件状态标志。\*/  
/\*可以用fcntl 函数改变一个已打开的文件的属性,可以重新设置读、写、追加、非阻塞等标志\*/  
/\*F\_SETFL 将文件状态标志设置为第三个参数的值 (取为整型值)。\*/  
/\* fcntl的F\_SETOWN指令设置当前进程为设备文件owner\*/  
  
  
  
  
/\* fcntl(fd, F\_SETOWN, getpid());告诉驱动程序当前PID进程号  
\*/  
fcntl(fd, F\_SETOWN, getpid());  
  
  
/\*读取fd的文件状态标志位\*/  
Oflags = fcntl(fd, F\_GETFL);   
  
  
/\*   
设置fd的文件状态标志位为Oflags | FASYNC  即异步通知  
调用fcntl(fd, F\_SETFL, Oflags | FASYNC);函数时，会进入驱动程序的file\_operations结构体执行fasync函数  
  
  
\*/  
  
  
/\*  
每当FASYNC标志改变时，驱动程序中的fasync()函数将得以执行。  
驱动中应该实现fasync()函数。  
  
  
\*/  
fcntl(fd, F\_SETFL, Oflags | FASYNC);  
  
  
\#endif  
  
  
while (1)  
\{  
/\*判断返回值，非阻塞的话一读就会返回一个值，\*/  
ret = read(fd, &key\_val, 1);  
printf("key\_val: 0x%x, ret = %d\\n", key\_val, ret);  
\}  
  
return 0;  
\}  
  
  
  
  
/\*  
fcnt1函数返回值说明  
返回说明：     
成功执行时，对于不同的操作，有不同的返回值   
F\_DUPFD： 新文件描述词   
F\_GETFD：  标志值   
F\_GETFL：  标志值   
F\_GETOWN： 文件描述词属主   
F\_GETSIG： 读写变得可行时将要发送的通告信号，或者0对于传统的SIGIO行为   
  
  
\*/  
  
  
/\*  
getpid（）用来取得目前进程的进程识别码，许多程序利用取到的  
此值来建立临时文件，以避免临时文件相同带来的问题。\*/