定时器去抖动

最新推荐文章于 2023-06-26 10:50:15 发布
最新推荐文章于 2023-06-26 10:50:15 发布
阅读量1.1k 收藏
点赞数
分类专栏： 嵌入式系统 文章标签： 字符设备驱动 c语言 定时器 linux内核 中断
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ychongx/article/details/29943217
版权

前面程序按键速度较快时出现按下打印几个相同值的情况，这个和机械的抖动有关,现在使用定时器去抖动

#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>


static struct class *sevendrv_class;
static struct class_device	*sevendrv_class_dev;

volatile unsigned long *gpfcon;
volatile unsigned long *gpfdat;

volatile unsigned long *gpgcon;
volatile unsigned long *gpgdat;

static struct timer_list buttons_timer;/*第一步:定义一个定时器结构体buttons_timer*/

static DECLARE_WAIT_QUEUE_HEAD(button_waitq);

/* 中断事件标志, 中断服务程序将它置1，seven_drv_read将它清0 */
static volatile int ev_press = 0;

static struct fasync_struct *button_async;


struct pin_desc{
	unsigned int pin;
	unsigned int key_val;
};


/* 键值: 按下时, 0x01, 0x02, 0x03, 0x04 */
/* 键值: 松开时, 0x81, 0x82, 0x83, 0x84 */
static unsigned char key_val;

struct pin_desc pins_desc[4] = {
	{S3C2410_GPF0, 0x01},
	{S3C2410_GPF2, 0x02},
	{S3C2410_GPG3, 0x03},
	{S3C2410_GPG11, 0x04},
};

//static atomic_t canopen = ATOMIC_INIT(1);     //定义原子变量并初始化为1

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

static struct pin_desc *irq_pd =NULL;

static irqreturn_t buttons_irq(int irq, void *dev_id)
{
	/*保存键值*/
	irq_pd = (struct pin_desc *)dev_id;
	
	/*第三步:修改定时器，消抖动，最后一次时调用超时函数
	  *buttons_timer_function
	 *修改定时器10ms,按键有抖动，而抖动时间肯定小于10ms,所以
	 *第一次抖动修改定时器，定时器延后抖动发生 的10ms
	 *第N-1次抖动修改定时器，定时器延后抖动发生 的10ms
	 *最后一次(第N次)抖动发生，定时器修改到抖动发生后10ms
	 *N次抖动后10ms，即N次的定时器超时时间10ms到后，调用定时器
	 *处理函数buttons_timer_function
	 */
	mod_timer(&buttons_timer, jiffies+HZ/100);
	return IRQ_RETVAL(IRQ_HANDLED);
}

static int seven_drv_open(struct inode *inode, struct file *file)
{
#if 0	
	if (!atomic_dec_and_test(&canopen))
	{
		atomic_inc(&canopen);
		return -EBUSY;
	}
#endif		

	if (file->f_flags & O_NONBLOCK)
	{
		if (down_trylock(&button_lock))
			return -EBUSY;
	}
	else
	{
		/* 获取信号量 */
		down(&button_lock);
	}

	/* 配置GPF0,2为输入引脚 */
	/* 配置GPG3,11为输入引脚 */
	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;
}

ssize_t seven_drv_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_waitq, ev_press);
	}

	/* 如果有按键动作, 返回键值 */
	copy_to_user(buf, &key_val, 1);
	ev_press = 0;
	
	return 1;
}


int seven_drv_close(struct inode *inode, struct file *file)
{
	//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;
}

static unsigned seven_drv_poll(struct file *file, poll_table *wait)
{
	unsigned int mask = 0;
	poll_wait(file, &button_waitq, wait); // 不会立即休眠

	if (ev_press)
		mask |= POLLIN | POLLRDNORM;

	return mask;
}

static int seven_drv_fasync (int fd, struct file *filp, int on)
{
	printk("driver: seven_drv_fasync\n");
	return fasync_helper (fd, filp, on, &button_async);
}


static struct file_operations sencod_drv_fops = {
    .owner   =  THIS_MODULE,    /* 这是一个宏，推向编译模块时自动创建的__this_module变量 */
    .open    =  seven_drv_open,     
	.read	 =	seven_drv_read,	   
	.release =  seven_drv_close,
	.poll    =  seven_drv_poll,
	.fasync	 =  seven_drv_fasync,
};

/*第四步:最后一次抖动的上升沿或下降沿10ms后调用buttons_timer_function*/
static void buttons_timer_function(unsigned date)
{
	struct pin_desc * pindesc = irq_pd;
	unsigned int pinval;
	
	/*add_timer添加时就产生了定时器超时，所以需要判断*/
	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;                  /* 表示中断发生了 */
    wake_up_interruptible(&button_waitq);   /* 唤醒休眠的进程 */
	
	kill_fasync (&button_async, SIGIO, POLL_IN);
	
}

int major;
static int seven_drv_init(void)
{
	/*第二步:初始化buttons_timer, 并启用定时器*/
	/*buttons_timer为结构体双向链表，我只需要填充一个项，第一次将定时器加入链表，需要初始化整个链表*/
	init_timer(&buttons_timer);
	/*初始化定时器结构体成员function,function为定时器超时后调用的函数buttons_timer_function*/
	buttons_timer.function = buttons_timer_function;
	/*注册定时器并运行*/
	add_timer(&buttons_timer);
	
	
	major = register_chrdev(0, "seven_drv", &sencod_drv_fops);

	sevendrv_class = class_create(THIS_MODULE, "seven_drv");

	sevendrv_class_dev = class_device_create(sevendrv_class, NULL, MKDEV(major, 0), NULL, "buttons"); /* /dev/buttons */

	gpfcon = (volatile unsigned long *)ioremap(0x56000050, 16);
	gpfdat = gpfcon + 1;

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

	return 0;
}

static void seven_drv_exit(void)
{
	unregister_chrdev(major, "seven_drv");
	class_device_unregister(sevendrv_class_dev);
	class_destroy(sevendrv_class);
	iounmap(gpfcon);
	iounmap(gpgcon);
	return 0;
}


module_init(seven_drv_init);

module_exit(seven_drv_exit);

MODULE_LICENSE("GPL");

mod_timer(&buttons_timer, jiffies+HZ/100);jiffies表示系统启动到现在的tick数，比如jiffies=50,过了一段时间jiffies=55则产生了55-50个系统定时器中断,现在HZ=100，即产生一个定时器中断,1个tick的时间产生了一个定时器中断，而tick为HZ的倒数，即1秒产生100个定时器中断，一个定时器中断为10ms


测试代码:

#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>


/* sevendrvtest 
  */


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

	//signal(SIGIO, my_signal_fun);
	
	fd = open("/dev/buttons", 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)
	{
		ret = read(fd, &key_val, 1);
		printf("key_val: 0x%x, ret = %d\n", key_val, ret);
		//sleep(5);
	}

测试结果: 

# insmod seven_drv.ko 
# lsmod
Module                  Size  Used by    Not tainted
seven_drv               4740  0 
# ./sevendrvtest &
# ./sevendrvtest &
# ./sevendrvtest &
# ./sevendrvtest &
# ps
  PID  Uid        VSZ Stat Command
    1 0          3092 S   init     
    2 0               SW< [kthreadd]
    3 0               SWN [ksoftirqd/0]
    4 0               SW< [watchdog/0]
    5 0               SW< [events/0]
    6 0               SW< [khelper]
   55 0               SW< [kblockd/0]
   56 0               SW< [ksuspend_usbd]
   59 0               SW< [khubd]
   61 0               SW< [kseriod]
   73 0               SW  [pdflush]
   74 0               SW  [pdflush]
   75 0               SW< [kswapd0]
   76 0               SW< [aio/0]
  710 0               SW< [mtdblockd]
  745 0               SW< [kmmcd]
  762 0               SW< [rpciod/0]
  770 0          3096 S   -sh 
  776 0          1308 S   ./sevendrvtest 
  777 0          1308 D   ./sevendrvtest 
  778 0          1308 D   ./sevendrvtest 
  779 0          1308 D   ./sevendrvtest 
  780 0          3096 R   ps 
# key_val: 0x1, ret = 1
key_val: 0x81, ret = 1
key_val: 0x1, ret = 1
key_val: 0x81, ret = 1
key_val: 0x1, ret = 1
key_val: 0x81, ret = 1
key_val: 0x1, ret = 1
key_val: 0x81, ret = 1
key_val: 0x1, ret = 1
key_val: 0x81, ret = 1
key_val: 0x1, ret = 1
key_val: 0x81, ret = 1
key_val: 0x1, ret = 1
key_val: 0x81, ret = 1
key_val: 0x1, ret = 1
key_val: 0x81, ret = 1
key_val: 0x1, ret = 1
key_val: 0x81, ret = 1
key_val: 0x1, ret = 1
key_val: 0x81, ret = 1
key_val: 0x1, ret = 1
key_val: 0x81, ret = 1
key_val: 0x1, ret = 1
key_val: 0x81, ret = 1
key_val: 0x1, ret = 1
key_val: 0x81, ret = 1
key_val: 0x1, ret = 1
key_val: 0x81, ret = 1
key_val: 0x1, ret = 1
key_val: 0x81, ret = 1
key_val: 0x1, ret = 1
key_val: 0x81, ret = 1
key_val: 0x1, ret = 1
key_val: 0x81, ret = 1
key_val: 0x1, ret = 1
key_val: 0x81, ret = 1
key_val: 0x1, ret = 1
key_val: 0x81, ret = 1
key_val: 0x1, ret = 1
key_val: 0x81, ret = 1
key_val: 0x1, ret = 1
key_val: 0x81, ret = 1
key_val: 0x1, ret = 1
key_val: 0x81, ret = 1

也可以用异步通知，驱动程序不变，测试源码改为:


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

int fd;
void my_signal_func(int signum)
{
	unsigned char key_val;
//	printf("signum = %d\n", signum);	
	read(fd, &key_val, 1);
	printf("key_val = 0x%x\n", key_val);
}	

int main(int argc, char **argv)
{
	int O_FLAGS,ret=0;
	unsigned char key_val=0;
	signal( SIGIO, my_signal_func); /*安装信号处理函数*/
	
	fd = open("/dev/buttons", O_RDWR);
	if (fd < 0)
	{
		printf("can't open!, fd = %d\n", fd);
		return -1;
	}

	fcntl( fd, F_SETOWN, getpid());
	
	O_FLAGS = fcntl(fd, F_GETFL);
	fcntl(fd, F_SETFL, O_FLAGS|O_ASYNC);
	
	while (1)
	{
		sleep(5);  //屏蔽掉，因为read没有按键产生，six_drv_read会休眠
	}
	
	return 0;
}

测试结果:

# ps
  PID  Uid        VSZ Stat Command
    1 0          3092 S   init     
    2 0               SW< [kthreadd]
    3 0               SWN [ksoftirqd/0]
    4 0               SW< [watchdog/0]
    5 0               SW< [events/0]
    6 0               SW< [khelper]
   55 0               SW< [kblockd/0]
   56 0               SW< [ksuspend_usbd]
   59 0               SW< [khubd]
   61 0               SW< [kseriod]
   73 0               SW  [pdflush]
   74 0               SW  [pdflush]
   75 0               SW< [kswapd0]
   76 0               SW< [aio/0]
  710 0               SW< [mtdblockd]
  745 0               SW< [kmmcd]
  762 0               SW< [rpciod/0]
  770 0          3096 S   -sh 
  776 0          1312 S   ./sevendrvtest 
  777 0          1308 D   ./sevendrvtest 
  778 0          1308 D   ./sevendrvtest 
  779 0          1308 D   ./sevendrvtest 
  781 0          3096 R   ps 
# kill -9 776 777 778 779
# 
[4] + Killed                     ./sevendrvtest
[3] + Killed                     ./sevendrvtest
[2] + Killed                     ./sevendrvtest
[1] + Killed                     ./sevendrvtest
# 
# ./sevendrvtest &
# driver: sixth_drv_fasync
# ./sevendrvtest &
# ./sevendrvtest &
# ./sevendrvtest &
# ps
  PID  Uid        VSZ Stat Command
    1 0          3092 S   init     
    2 0               SW< [kthreadd]
    3 0               SWN [ksoftirqd/0]
    4 0               SW< [watchdog/0]
    5 0               SW< [events/0]
    6 0               SW< [khelper]
   55 0               SW< [kblockd/0]
   56 0               SW< [ksuspend_usbd]
   59 0               SW< [khubd]
   61 0               SW< [kseriod]
   73 0               SW  [pdflush]
   74 0               SW  [pdflush]
   75 0               SW< [kswapd0]
   76 0               SW< [aio/0]
  710 0               SW< [mtdblockd]
  745 0               SW< [kmmcd]
  762 0               SW< [rpciod/0]
  770 0          3096 S   -sh 
  782 0          1308 S   ./sevendrvtest 
  783 0          1308 D   ./sevendrvtest 
  784 0          1308 D   ./sevendrvtest 
  785 0          1308 D   ./sevendrvtest 
  786 0          3096 R   ps 
# key_val = 0x1
key_val = 0x81
key_val = 0x1
key_val = 0x81
key_val = 0x1
key_val = 0x81
key_val = 0x1
key_val = 0x81
key_val = 0x1
key_val = 0x81
key_val = 0x1
key_val = 0x81
key_val = 0x1
key_val = 0x81
key_val = 0x1
key_val = 0x81
key_val = 0x1
key_val = 0x81
key_val = 0x1
key_val = 0x81
key_val = 0x1
key_val = 0x81
key_val = 0x1
key_val = 0x81
key_val = 0x1
key_val = 0x81
key_val = 0x2
key_val = 0x82
key_val = 0x2
key_val = 0x82
key_val = 0x2
key_val = 0x82
key_val = 0x2
key_val = 0x82
key_val = 0x2
key_val = 0x82
key_val = 0x2
key_val = 0x82
key_val = 0x1
key_val = 0x81
key_val = 0x1
key_val = 0x81
key_val = 0x1
key_val = 0x81
key_val = 0x1
key_val = 0x81
key_val = 0x1
key_val = 0x81
key_val = 0x1
key_val = 0x81
key_val = 0x1
key_val = 0x81
key_val = 0x1
key_val = 0x81
key_val = 0x1
key_val = 0x81
key_val = 0x1
key_val = 0x81
key_val = 0x1
key_val = 0x81
key_val = 0x1
key_val = 0x81
key_val = 0x1

计时5sS3C2410 Timer Tick由965663变为966585,966585-965663=922,可知大约5s ,1000此定时器中断，即HZ=200，而在本实验中在HZ上ctrl+鼠标左键,HZ=100,和内核的并不相同

# cat proc/interrupts 
           CPU0
 16:        179    s3c-ext0  S2
 18:        194    s3c-ext0  S3
 30:     965663         s3c  S3C2410 Timer Tick
 32:          0         s3c  s3c2410-lcd
 33:          0         s3c  s3c-mci
 34:          0         s3c  I2SSDI
 35:          0         s3c  I2SSDO
 37:         12         s3c  s3c-mci
 42:          0         s3c  ohci_hcd:usb1
 43:          0         s3c  s3c2440-i2c
 51:       1613     s3c-ext  eth0
 55:          0     s3c-ext  S4
 60:          0     s3c-ext  s3c-mci
 63:          0     s3c-ext  S5
 70:        176   s3c-uart0  s3c2440-uart
 71:       1067   s3c-uart0  s3c2440-uart
 79:         20     s3c-adc  s3c2410_action
 80:      20332     s3c-adc  s3c2410_action
 83:          0           -  s3c2410-wdt
Err:          0
# cat proc/interrupts 
           CPU0
 16:        179    s3c-ext0  S2
 18:        194    s3c-ext0  S3
 30:     966585         s3c  S3C2410 Timer Tick
 32:          0         s3c  s3c2410-lcd
 33:          0         s3c  s3c-mci
 34:          0         s3c  I2SSDI
 35:          0         s3c  I2SSDO
 37:         12         s3c  s3c-mci
 42:          0         s3c  ohci_hcd:usb1
 43:          0         s3c  s3c2440-i2c
 51:       1623     s3c-ext  eth0
 55:          0     s3c-ext  S4
 60:          0     s3c-ext  s3c-mci
 63:          0     s3c-ext  S5
 70:        178   s3c-uart0  s3c2440-uart
 71:       1104   s3c-uart0  s3c2440-uart
 79:         20     s3c-adc  s3c2410_action


ychongx
关注
专栏目录
定时器消抖实验
qq_66545503的博客
07-31 890
但是t1~t2和t2~t3这两个时间段是小于我们设置的定时器中断周期(也就是消抖时间，比如10ms)，所以虽然t1开启了定时器，但是定时器定时时间还没到呢t2时刻就重置了定时器，最终只有t3时刻开启的定时器能完整的完成整个定时周期并触发中断，我们就可以在中断处理函数里面做按键处理了，这就是定时器实现按键防抖的原理，Linux里面的按键驱动用的就是这个原理！上一章我们学习了EPIT定时器，定时器设置好定时时间，然后CPU就可以做其他事情去了，定时时间到了以后就会触发中断，然后在中断中做相应的处理即可。....
Linux用户进程高精度定时器去抖动
gunterwe的博客
08-26 927
Linux用户进程高精度定时器去抖动【新手自学APUE】。通过实践 itimer定时器去抖动 总结的几点注意事项： 定时器精度要支持较高精度，定时器设置值要大于 【上确界】(最大值)（每 两次 抖动的时间间隔），这样定时器就不会因为超时而把抖动数据当做第一次有效数据读取；同时定时器设置值要小于用户 最短的【下确界】（驱动每 两次 向缓冲区写数据的时间的间隔） 对于第一次读取有效数据要造
GD32VF103_定时器中断
weifengdq的专栏
10-29 9411
文章目录前言新建工程定时器定时器中断代码工程代码 前言 上节我们讲了 GD32VF103CBT6的点灯与按键的外部中断的NucleiStudio工程: GD32VF103_环境配置_GPIO_外部中断 本节我们继续点灯, 只不过用定时器中断的方式2s翻转一次灯的状态. 新建工程 File -> New -> C/C++ Project, 选择C Managed Build 选择Gi...
5.按键定时器去抖动
ashe9657的博客
02-14 260
按键定时器去抖动 按键所用开关为机械弹性开关，当机械触点断开、闭合时，由于机械触点的弹性作用，开关不会马上稳定地接通或断开。因而在闭合及断开的瞬间总是伴有一连串的抖动的。按键去抖动的方法主要有两种，一种是硬件电路去抖动；另一种就是软件延时去抖动。而延时又一般分为了两种，一种是for循环等待，另一种是定时器延时。在操作系统中，由于效率方面的原因，一般不允许使用for循环来等待，只能使用...
使用定时器去抖
一棵小草的空间
08-29 555
按键抖动：按键所用开关为机械弹性开关，当机械触点断开、闭合时，由于机械触点的弹性作用，开关不会马上稳定地接通或断开。因而在闭合及断开的瞬间总是伴随有一连串的抖动。
32. EPIT定时器实验
TrueLink的博客
03-23 345
一、EPIT简介 1、EPIT是32位的一个向下计数器。 2、EPIT的时钟源可以选择，我们选择ipg_clk=66MHz。 3、可以对时钟源进行分频，12位的分频器，04095分别代表14096分频。 4、开启定时器以后，计数寄存器会每个时钟减1，如果和比较寄存器里面的值相等的话就会触发中断。 EPIT有两种工作模式： Set-add-forget，一个是free-runing 5、6ULL有两个EPIT定时器。 EPIT_CR寄存器用于配置EPIT。 二、实验原理简介 EPIT_CR bit0为1，设置
按键定时器去抖
01-31 162
linux中使用定时器去抖主要是因为性能问题，for循环也可以去抖，但是会影响机器性能，所以linux中都使用定时器去抖，解决机械按键的抖动问题。 linux内核中使用struct  timer_list来描述一个定时器： struct  timer_list { sturct  list_head  entry; unsigned  long  expires; void  
016.C#VS2017利用定时器去抖动问题.rar
06-30
总之，C# VS2017中的去抖动技术主要依赖于定时器组件，通过控制定时器的启动、停止和重置来实现对用户操作的延迟响应，从而避免频繁的处理调用。这种技术在WPF应用中特别有用，特别是在处理用户输入和响应事件时，...
两个linux按键驱动之二 read（定时器去抖动）
09-29
根据提供的文件信息，本文将对Linux按键驱动中的定时器去抖动机制进行深入解析，并结合具体代码示例来探讨其实现细节。 ### Linux按键驱动概述 在Linux内核中，按键驱动程序通常用于处理硬件上的按钮事件。这些...
linux字符驱动之定时器去抖动按键驱动
lwj103862095的专栏
12-26 7041
上一节里，实现同一时刻只能有一个进程使用同一个设备，例如：只能有一个进程，在同一时刻里使用/dev/buttons这个设备。 上一节文章链接：http://blog.csdn.net/lwj103862095/article/details/17563953 相信大家在写单片机的按键程序时，也必将会涉及一点，就去按键去抖动。按键去抖动的方法无非有二种，一种是硬件电路去抖动，这种在要求不是特别高
Arduino按键消抖类，以极简单的代码实现消抖。
05-05
详细请参阅我的博客。http://blog.csdn.net/flexitime
51单片机用定时器进行按键去抖
12-27
相比于常见的延时去抖方法，定时器去抖更加高效且精确。延时去抖是通过在按键检测到变化后等待一段固定的时间（如几毫秒）再进行一次检测，如果状态保持不变，则认为按键动作稳定。这种方法简单但不够灵活，且可能...
驱动学习笔记8 定时器去抖动，内核空间地址映射操作寄存器
m0_62089823的博客
12-03 279
8
定时器消抖，延时消抖处理按键事件
我的博客
03-31 1915
定时器消抖与软件延时消抖处理按键响应
stm32 利用定时器中断消除按键抖动
kuniqiw的博客
12-20 3570
button.c int iButtonCount;//i代表int型变量，ButtonCount表示按键计数变量 int iButtonFlag;//i代表int型变量，ButtonFlag表示重按键标志，1代表重新按键，0为没有重新按键 int g_iButtonState;//g是globle代表全局变量，会在其他地方引用；i代表int型变量，ButtonState表示按键标...
7. 使用定时器去掉按键输入中产生抖动
weixin_40683279的博客
08-30 321
1. 电路图 2. Linux内核中使用定时器的步骤 static struct timer_list xxx_timer; /* 定义全局的定时器 */ init_timer(&xxx_timer); /* 初始化定时器 */ buttons_timer.function = xxx_function; /* 设置超时调用函数 */ buttons_timer.expires ...
定时器按键消抖
weixin_59349642的博客
12-29 760
冲
使用定时器进行按键消抖
yilongdashi的博客
04-22 4227
.如何消去按键抖动 通过定时器延时10ms,然后每当按键进入中断时就更新定时器延时10ms,若延时10ms到了说明已经过了抖动范围,然后再打印按键电平信息 两个全局变量: jiffies: 是系统时钟,全局变量,默认每隔10ms加1 HZ:是每S的频率,通过系统时钟换算出来,比如每隔10ms加1,那么HZ就等于100， 1s等于HZ，jiffies+HZ/100意思jiffies+1s/...
【裸机开发】EPIT 定时器 —— 按键消抖
最新发布
challenglistic的博客
06-26 1677
【裸机开发】EPIT 定时器 —— 按键消抖
单片机与DSP软件去抖动技术解析
软件去抖动方法借助单片机的定时中断功能，通过计算逻辑表达式来实现，既高效又节省资源。这种方法适用于各种类型的控制系统，特别是那些需要处理按键输入的系统。文章详细介绍了具体的实现过程，包括逻辑表达式的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值