非常稳定可靠的单片机按键消抖程序，绝对不会产生抖动 -

标题: 非常稳定可靠的单片机按键消抖程序，绝对不会产生抖动 [打印本页]

作者: zouminglu 时间: 2018-5-22 09:15
标题: 非常稳定可靠的单片机按键消抖程序，绝对不会产生抖动
#include<reg52.h>
#define uint unsigned int
#define uchar unsigned char
sbit K1 = P1^0;
void delay1ms(uint n)
{
uchar  a,b,c,d;
for(d=n;d>0;d--)
for(c=1;c>0;c--)
      for(b=222;b>0;b--)
         for(a=12;a>0;a--);
}
void main()
{
uint i;
      if(K1==0)
      {
            delay1ms(10);
            if(K1==0) //
            {
                     for(i=0;i<100;i++)    //此处消抖程序非常经典，怎么按都绝对不会产生抖动。
                     {
                     if(K1==0)
                        i=0;
                     }
            在这儿添加按键按下后要执行的功能。
            }
      }
}

作者: feiji666 时间: 2018-10-29 18:32
非常可以

作者: bhjyqjs 时间: 2018-10-30 15:34
if(K1==0) //
            {
                     for(i=0;i<100;i++)    //此处消抖程序非常经典，怎么按都绝对不会产生抖动。
                     {
                     if(K1==0)
                        i=0;
                     }
            在这儿添加按键按下后要执行的功能。
            }
比较巧妙！

作者: bhjyqjs 时间: 2018-10-30 15:58
说白了就是放手执行动作，但延时消抖有些傻傻的，期间什么也干不了。

作者: bhjyqjs 时间: 2018-10-30 16:02
//非常稳定可靠的单片机按键消抖程序，绝对不会产生抖动
#include<reg52.h>
#define uint unsigned int
#define uchar unsigned char
sbit K1 = P1^4;
sbit K2 = P1^5;
void delay1ms(uint n)
{
uchar  a,b,c,d;
for(d=n;d>0;d--)
for(c=1;c>0;c--)
      for(b=222;b>0;b--)
         for(a=12;a>0;a--);
}
void main()
{
uint i;
      if(K1==0)
      {
            delay1ms(10);
            if(K1==0) //
            {
                     for(i=0;i<100;i++)    //此处消抖程序非常经典，怎么按都绝对不会产生抖动。
                     {
                     if(K1==0)
                        i=0;
                     }

      P0=P0|0x01;    //左移后，最右端自动赋值0，所以需要该语句赋值1
      P0<<=1;
            }
      }
if(K2==0)
      {
            delay1ms(10);
            if(K2==0) //
            {
                     for(i=0;i<100;i++)    //此处消抖程序非常经典，怎么按都绝对不会产生抖动。
                     {
                     if(K2==0)
                        i=0;
                     }

      P0 = 0xff;
            }
      }
}

1.png (68.45 KB, 下载次数: 101)

作者: 快乐眼泪 时间: 2018-10-30 19:11
感谢楼主分享！

作者: hfei 时间: 2018-11-1 13:41
有点儿意思！

作者: 13976778401 时间: 2018-11-5 17:26
学习了！

作者: liuhailan5757 时间: 2018-12-15 20:17

bhjyqjs 发表于 2018-10-30 15:58
说白了就是放手执行动作，但延时消抖有些傻傻的，期间什么也干不了。

兄弟你不能这么想，按照这位楼主的思路，可以搞成不用傻傻的等啊，利用定时器中断不就行了吗是不是

作者: areyouok 时间: 2018-12-16 01:32
加油！抓住每一次灵感，活的当下才精彩！

作者: 1290299464 时间: 2018-12-16 11:00
应该再放一个松手检测

作者: 快乐的小黑 时间: 2019-7-20 09:48

bhjyqjs 发表于 2018-10-30 15:34
if(K1==0) //
{
for(i=0;i

太巧秒了

作者: wardwang 时间: 2019-7-20 14:25
还没学到这么高级，有需要时借鉴借鉴。谢谢分享。

作者: molo 时间: 2019-7-20 17:36
学习学习，谢谢分享！

作者: wangwing 时间: 2019-7-20 22:45
请问此处的FOR循环，与前面的延时10毫秒有什么区别？

作者: rebios 时间: 2019-8-10 08:32
前面检测的是按下
后面检测的松开

作者: 1035510176 时间: 2019-8-14 16:19
怎么感觉很多此一举，小白不是很懂，在第一次按键按下后还是用了延时进行了一次消抖，后面还再来一次消抖的意义在哪里？请各位大佬指点

作者: wcs1668 时间: 2019-9-30 16:49
楼主我今天试了一下加了关键一句按键无法循环，无法做自锁按键，再说你的按下检测，没有松手检测。

作者: mdc9 时间: 2019-11-11 17:13

bhjyqjs 发表于 2018-10-30 15:58
说白了就是放手执行动作，但延时消抖有些傻傻的，期间什么也干不了。

对头！！一语道破！

作者: yuanyijie 时间: 2019-11-26 09:58
#include "Key.h"

u16 Key_Lock;                      //按键锁定
u16 Key_Down;                      //按键被按下
u16 Key_Up;                         //按键释放
u16 Key_Count[16];                   //消抖计数

//消抖次数
code u16 Key_Threshold[] =
{
100,          //0x0001
100,          //0x0002
1,          //0x0004
1,          //0x0008
1,          //0x0010
1,          //0x0020
1,          //0x0040
1,          //0x0080
1,          //0x0100
1,          //0x0200
1,          //0x0400
1,          //0x0800
1,          //0x1000
1,          //0x2000
1,          //0x4000
1          //0x8000
};

/*========================================================
//触摸按键检测  主程序长调用
//
=========================================================*/
void Key_Scan()
{
u8 i;
u16 Loop_Bit = 1;
u16 Key = 0;

if(K1_IO == 0)
{
      Key |= 0x01;
}

if(K2_IO == 0)
{
      Key |= 0x02;
}

for(i = 0; i < 16; i++)
{
      if((Key_Lock & Loop_Bit) == 0)       //如果按键未锁定
      {
         if(Key & Loop_Bit)       //如果按键被按下,把相应位置位
         {
            Key_Count[i]++;
            if(Key_Count[i] >= Key_Threshold[i])
            {
                  Key_Count[i] = 0;
                  Key_Lock |= Loop_Bit;    //锁定按键
                  Key_Down |= Loop_Bit;    //触发按键
            }
         }
         else
         {
            Key_Count[i] = 0;
         }
      }
      else                                     //如果按键被锁定
      {
         if((Key & Loop_Bit) == 0)  //如果按键被释放,把相应为清零
         {
            Key_Count[i]++;
            if(Key_Count[i] >= Key_Threshold[i])
            {
                  Key_Count[i] = 0;
                  Key_Lock &= ~Loop_Bit;
                  Key_Up |= Loop_Bit;
            }
         }
         else
         {
            Key_Count[i] = 0;
         }
      }
      Loop_Bit <<= 1;
}
}

/*
10毫秒调用一次
*/
void Key_Handle()
{
//组合按键
if((Key_Lock & (KEY1 | KEY2)) == (KEY1 | KEY2))
{
}

//任意按键按下
if(Key_Down)
{
}

//按键按下触发--
if(Key_Down & KEY1)
{
      Key_Down &= ~KEY1;
}
//按键释放触发
if(Key_Up & KEY1)
{
      Key_Up &= ~KEY1;
}

//按键按下触发--
if(Key_Down & KEY2)
{
      Key_Down &= ~KEY2;
}
//按键释放触发
if(Key_Up & KEY2)
{
      Key_Up &= ~KEY2;
}

//按键按下触发--
if(Key_Down & KEY3)
{
      Key_Down &= ~KEY3;
}
//按键释放触发
if(Key_Up & KEY3)
{
      Key_Up &= ~KEY3;
}

//按键按下触发--
if(Key_Down & KEY4)
{
      Key_Down &= ~KEY4;
}
//按键释放触发--
if(Key_Up & KEY4)
{
      Key_Up &= ~KEY4;
}

}

作者: hhh402 时间: 2019-11-27 19:28
消抖程序已经淘汰了，根本就不需要消抖，把按键检测程序放到间隔10ms以上的中断中，按键抖动小于10ms，间隔10ms以上的中断意味着抖动期间最多只会检测到一次，无论检测到0还是1都不影响结果。所以根本就不需要消抖，也不需要按键释放。按键释放程序会影响数码管显示，一按键数码管显示就停止了。

作者: life_阳子 时间: 2019-12-25 15:58
非常傻的一种消抖方式，建议不要用，延时消抖，期间什么都干不了

作者: 166864646883 时间: 2019-12-28 14:03
用定时器中断消抖比较好

作者: aking991 时间: 2020-1-20 14:20
很有意思，很有值的学习的地方，下次项目可以试看看如何

作者: li351382858 时间: 2020-1-20 18:50
来学习学习

作者: Angle145 时间: 2020-1-22 06:58
不放手是执行不了的，你的思路很对，但是还有改进的地方

作者: 小阿娜 时间: 2020-4-15 11:12

hhh402 发表于 2019-11-27 19:28
消抖程序已经淘汰了，根本就不需要消抖，把按键检测程序放到间隔10ms以上的中断中，按键抖动小于10ms，间隔 ...

会检测错误吧，假如没有按下，中断的时候检测到了一次抖动是按下的，不就错误了嘛，还得用统计的方法吧

作者: cy009 时间: 2020-4-15 16:37
玩玩可以，没多大意思。

作者: jianuli 时间: 2020-9-7 22:26

rebios 发表于 2019-8-10 08:32
前面检测的是按下
后面检测的松开

怎样检测松开的呢，新手，不是很懂，谢谢

作者: ty417502873 时间: 2020-9-8 17:47

jianuli 发表于 2020-9-7 22:26
怎样检测松开的呢，新手，不是很懂，谢谢

已经是有松手检测了，手不松i=0 for循环出不去。手松开之后经过i从0到100的延时出去执行按下要执行的任务。

作者: luogu 时间: 2020-9-11 16:02
太老了，初学者用延时消抖，工程中基本都是按键状态机了，CPU占用资源少10-20ms调用一次就行

作者: ziyueboy 时间: 2020-9-13 14:46
咋还讨论按键次消抖呢？马师傅按键消抖，吴师傅按键消抖，都是完美的方法，可以添加单触发，多触发，长按等

作者: 7631001 时间: 2020-9-14 17:55
此时不能做其他事情，其应用会有局限性。

作者: yayayunyun 时间: 2022-8-18 15:34
做实验可以，实际应用效果不太好

作者: Materialism 时间: 2022-8-19 18:26
确实很经典，如果将延时函数改为状态机方式进行计时的话，我想会使得代码效率更高。

作者: dyx811 时间: 2022-8-20 13:19
不放手试一试有啥结果没?

作者: 18680365301 时间: 2023-4-7 16:44

hhh402 发表于 2019-11-27 19:28
消抖程序已经淘汰了，根本就不需要消抖，把按键检测程序放到间隔10ms以上的中断中，按键抖动小于10ms，间隔 ...

实际上非常容易二次触发

作者: 15031773670 时间: 2023-4-8 11:29

liuhailan5757 发表于 2018-12-15 20:17
兄弟你不能这么想，按照这位楼主的思路，可以搞成不用傻傻的等啊，利用定时器中断不就行了吗是不是

用电容，并0.1UF电容就可以了

作者: joyb 时间: 2023-4-8 14:17

ziyueboy 发表于 2020-9-13 14:46
咋还讨论按键次消抖呢？马师傅按键消抖，吴师傅按键消抖，都是完美的方法，可以添加单触发，多触发，长按等

把程序贴出来

欢迎光临 (http://www.51hei.com/bbs/)