设为首页收藏本站
开启辅助访问

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 24小时必答区 › 单片机按键的长按和短按 长按一直按下时不断的加 现在的 ...

单片机按键的长按和短按 长按一直按下时不断的加 现在的问题是短按按快一点会没反应

查看数: 7097 | 评论数: 23 | 收藏 3
关灯 | 提示：支持键盘翻页<-左 右->
帖子模式
    组图打开中，请稍候......
如痴百感生
发布时间: 2019-12-2 13:49

正文摘要:

    这是我在51hei论坛里学习出来的 自己修改了一些  论坛上的else好像没有包含在按键确定按下的循环里  我那样试没有达到长按按下连加的功能，我这样改了可以保证按下是连加 &n ...

回复

ID:586438 发表于 2019-12-4 08:06
弄好了   非常感谢各位的帮忙
ID:591676 发表于 2019-12-3 18:20
按键需要消抖否则又是时候会没反应
ID:213173 发表于 2019-12-3 17:33
如痴百感生 发表于 2019-12-3 10:58
这是我的全部代码  长按松开才加一次  为了区分是长按还是短按  我特地把长按和短按加的数值改了  发现 ...

不清楚你短按一次+/-1，长按连续+/-25 的意图，但要注意使用变量的数据类型，最好按数据类型的整除数+/-，否则会出现负数或溢出。给你改成递增/减5。
  1. #include <STC12C5A60S2.H>
  2. #define uchar unsigned char
  3. #define uint unsigned int
  4. sbit key_add=P3^4; //增加的按键 的I/O口
  5. sbit key_dec=P3^3; //减少的按键 的I/O口
  6. //bit flg1=0;
  7. //bit flg2=0;      //按键计数标志位
  8. //bit flag10ms=0;   //10ms时间标志位
  9. uchar  num=0x00;
  10. //unsigned char num1=0;
  11. //typedef enum KeyState{StateInit,StateAffirm,StateSingle,StateRepeat};        //键值状态值

  13. void Timer0Init()        //10毫秒@11.0592MHz
  14. {
  15.         AUXR &= 0x7F;        //定时器时钟12T模式
  16.         TMOD &= 0xF0;        //设置T0自动重装模式
  17.         TL0 = 0x00;                //设置定时初值
  18.         TH0 = 0xDC;                //设置定时初值
  19.         TF0 = 0;                //清除TF0标志
  20.         TR0 = 1;                //定时器0开始计时
  21. }
  22. void PWM_Init()
  23. {
  24.         CCON = 0;                                        //初始化PCA控制寄存器
  25.         CL = 0;                                //复位PCA寄存器
  26.         CH = 0;                         //复位PCA寄存器
  27.         CMOD=0x02;                        //PCA计数脉冲选择为fos/2/256=21.6KHz
  28.         PCA_PWM0 = 0x00;                        //PCA模块0工作于8位PWM
  29.         CCAP0H = CCAP0L = 0x00;                //PWM0的占空比为100%
  30.         CCAPM0 = 0x42;                                //允许CCP0脚用作脉宽调节输出
  31.         CR = 1;                                                //PCA定时器开始工作
  32. }
  33. /*
  34. void init()
  35. {
  36.         TMOD=0X01;     //16位计数模式
  37.         TH0=(65535-1000)/256;
  38.         TL0=(65535-1000)%256;  //定时1ms
  39. //        EA=1;                  //开总中断
  40. //        ET0=1;            
  41.         TR0=1;        

  43.         CCON = 0;                                        //初始化PCA控制寄存器
  44.         CL= 0;                  //清零
  45.         CH= 0;
  46.         CMOD=0x02;                //PCA计数脉冲选择为fos/2

  48.         CCAP0H = CCAP0L = 0x00;   //PWM0的初始占空比为100%
  49.         CCAPM0=0x42;
  50.         CR=1;
  51. }
  52. void time0() interrupt 1
  53. {
  54.         TH0=(65535-1000)/256;
  55.         TL0=(65535-1000)%256;
  56.         num1++;
  57.         if(num1==10)
  58.         {
  59.                 flag10ms=1;
  60.         }
  61. }
  62. */
  63. void keyscan()
  64. {
  65.         static uint count1,count2;        //消抖计数变量                        

  67.         if(!key_add)   
  68.         {  
  69.                 count1++;  
  70.                 if(count1>=150) //长按1.5s
  71.                 {
  72.                         if(num<255)
  73.                                 num+=5;;
  74.                         count1=100; //连+间隔0.25s
  75.                 }
  76.         }  
  77.         else      //按键抬起
  78.         {  
  79.                 if(count1>1 && count1<150)       //短按20ms~0.75s
  80.                 {
  81.                         if(num<255)
  82.                                 num+=5;
  83.                 }
  84.                 count1=0;  //count1清0
  85.         }   
  86.         if(!key_dec)   
  87.         {  
  88.                 count2++;  
  89.                 if(count2>=150)//长按快调0.75s
  90.                 {
  91.                         if(num>0)
  92.                                 num-=5;
  93.                         count2=100;     //连-间隔0.25s
  94.                 }
  95.         }  
  96.         else   //按键抬起
  97.         {  
  98.                 if(count2>1 && count2<150)   //短按20ms~0.75s
  99.                 {
  100.                         if(num>0)
  101.                                 num-=5;
  102.                 }
  103.                 count2=0;  //count2清0
  104.         }   
  105. }
  106. void main()
  107. {
  108.         P3M0 = 0x80;
  109.         P3M1 = 0x00;//P3^7口推挽输出
  110.         Timer0Init();
  111.         PWM_Init();
  112.         while(1)
  113.         {
  114.                 if(TF0==1)//查询中断请求标志
  115.                 {
  116.                         TF0=0;//中断请求标志清0
  117.                         keyscan();
  118.                         CCAP0H=num;
  119.                 }
  120.                 //display();//显示函数
  121.         }
  122. }
复制代码
ID:140489 发表于 2019-12-3 15:59
给你改好了，实验板测试正常
  1. #include <STC12C5A60S2.H>
  2. #define uchar unsigned char
  3. #define uint unsigned int
  4. sbit key_add=P3^0; //增加的按键 的I/O口
  5. sbit key_dec=P3^1; //减少的按键 的I/O口
  6. //bit flg1=0;
  7. //bit flg2=0;      //按键计数标志位
  8. bit flag10ms=0;   //10ms时间标志位
  9. uint num=0x00;
  10. unsigned char num1=0;

  12. void init()
  13. {
  14.         TMOD=0X01;     //16位计数模式
  15.         TH0=(65535-1000)/256;
  16.         TL0=(65535-1000)%256;  //定时1ms
  17.         EA=1;                  //开总中断
  18.         ET0=1;            
  19.         TR0=1;
  20.                
  21.                 PCA_PWM0=0x00;        
  22.         CMOD=0x02;                //PCA计数脉冲选择为fos/2
  23.                 CL=0x00;                  //清零PCA计数器
  24.                 CH=0x00;
  25.                 CCAP0H = CCAP0L = 0x00;  //PWM0的初始占空比为100%
  26.                 CCAPM0=0x42;                         //设置模块0为8位PWM输出模式；PWM无需中断支持；模块0的脉冲在P1.3脚输出
  27.                 CR=1;                                         //启动PCA计数器
  28. }

  30. void time0() interrupt 1
  31. {
  32.         TH0=(65535-1000)/256;
  33.         TL0=(65535-1000)%256;
  34.         num1++;
  35.         if(num1==10)
  36.         {
  37.                 flag10ms=1;
  38.         }
  39. }

  41. void keyscan()
  42. {
  43.         static uint count1,count2;        //消抖计数变量                        

  45.         if(!key_add)   
  46.         {  
  47.                 count1++;  
  48.                 if(count1>=5000) //长按
  49.                 {
  50.                         if(num<255)
  51.                                                 {
  52.                                 num++;
  53.                                                          if(num==255)
  54.                                                         num=255;
  55.                                                 }
  56.                         count1=500; //连+
  57.                 }
  58.         }  
  59.         else      //按键抬起
  60.         {  
  61.                 if(count1>500 && count1<5000)       //短按
  62.                 {
  63.                         if(num<255)
  64.                                                 {
  65.                                  num+=5;
  66.                                                          if(num>=254)
  67.                                                         num=255;
  68.                                                 }
  69.                                                  count1=0;
  70.                 }
  71. //                count1=0;  //count1清0
  72.         }   


  75.         if(!key_dec)   
  76.         {  
  77.                 count2++;  
  78.                 if(count2>=5000)//长按
  79.                 {
  80.                         if(num>0)
  81.                                                 {
  82.                                 num--;
  83.                                                         if(num<=1)
  84.                                                         num=0;
  85.                                                 }
  86.                         count2=500;     //连-
  87.                 }
  88.         }  
  89.         else   //按键抬起
  90.         {  
  91.                 if(count2>500 && count2<5000)   //短按
  92.                 {
  93.                         if(num>0)
  94.                                                 {
  95.                                 num-=5;
  96.                                                         if(num<=0)
  97.                                                         num=0;

  99.                                                 }
  100.                                                 count2=0;
  101.                 }
  102. //                count2=0;  //count2清0
  103.         }   
  104. }
  105. void main()
  106. {
  107. //        P3M0=0X80;
  108. //        P3M1=0X00;//P3^7口推挽输出
  109.         init();
  110.         while(1)
  111.         {
  112. //                if(flag10ms==1)
  113.                 {
  114.                         CCAP0H=num;
  115. //                        flag10ms=0;
  116.                         keyscan();
  117.                 }
  118.         }
  119. }
复制代码
ID:263029 发表于 2019-12-3 14:44
长按没有实现。
ID:140489 发表于 2019-12-3 14:06
这是1T单片机的程序，按键延时做了调整，按键延时要结合硬件来调整到最佳状态
  1. //短按开关灯，开灯状态下，长按调光，开灯状态随时都可以调光         2019/12/3 调试完成
  2. //#include<reg51.h>
  3. #include<STC12C5A60S2.h>
  4. #define uint unsigned int
  5. #define uchar unsigned char


  8. //sfr AUXR = 0x8e;   //Auxiliary register


  11. sbit OUT=P1^1;//  P1.1输出pwm
  12. sbit OUT1=P1^2;//  P1.2输出pwm

  14. sbit KEY1 = P3^0;

  16. #define const_key_time1 50   //短按去抖动延时的时间
  17. #define const_key_time2 3000  //长按延时的时间

  19. uint uiKeyTimeCnt1=0; //按键去抖动延时计数器
  20. uint uiKeyTimeCnt4=0; //按键去抖动延时计数器
  21. uint uiKeyTimeCnt2=0; //调光速度变量
  22. uint uiKeyTimeCnt3=0; //调光速度变量
  23. uchar ucKeyLock1=0;   //按键触发后自锁的变量标志
  24. uchar pwm_t;              //pwm周期
  25. bit flag;                      //调光加减标志
  26. uchar pwm_led_val = 50;//LED占空比值
  27. bit flag1;                                //开关灯标志
  28. bit flag2;                                //短按触发标志
  29. bit flag3;                                //长按调光启停标志
  30. bit flag4;                                //按键延时计数启动标志

  32. void keyscan()
  33. {
  34.         if(KEY1==1)        //按键没按下 要及时清零一些标志
  35.         {

  37.                 ucKeyLock1=0;   //按键自锁标志清零
  38.                 uiKeyTimeCnt4=0;//按键去抖动延时计数器清零
  39.                 flag3=0;                //长按松手，停止调光
  40.                 flag4=0;                //松手，按键延时计数停止
  41.                 if(flag2 == 1)        //短按触发标志
  42.                 {
  43.                         flag2=0;
  44.                         flag1 = !flag1;//开关灯标志，松手后才开灯
  45.                 }
  46.        
  47.         }
  48.         else if(ucKeyLock1==0)//按键按下，且是第一次感应
  49.         {       
  50.                 flag4=1;
  51.                 //++uiKeyTimeCnt1;  //延时计数器
  52.                 if(uiKeyTimeCnt4>const_key_time1)//短按        10ms
  53.                 {       
  54.                         flag2 = 1;   //按键按下，启动计数标志
  55. //                        OUT= OUT1=0; //按下就把灯打开，        不要这句 就是松手后才开灯
  56.                 }               
  57.                 if(uiKeyTimeCnt4>const_key_time2)//长按 1s
  58.                 {
  59.                        
  60.                         flag2=0;                //清除短按标志
  61.                         ucKeyLock1=1; //自锁按键置位,避免一直触发
  62.        
  63.                         uiKeyTimeCnt4=0;
  64.        
  65.                         flag3=1;  //启动调光
  66.                        
  67.                 }
  68.         }
  69. }


  72. void main()
  73. {
  74.        
  75. //        AUXR = 0x80;                //定时器时钟1T模式
  76.         AUXR &= 0x7F;                //定时器时钟12T模式
  77.         TMOD &= 0xF0;                //设置定时器模式
  78.         TMOD |= 0x02;        //设置定时器模式 8为自动重装
  79.         TL0 = 0xF7;                //设置定时初值        10us   @11.0592M
  80.         TH0 = 0xF7;                //设置定时重载值
  81.     EA=1;//开总中断
  82.     ET0=1;//开定时器0中断
  83.     TR0=1;//启动定时器0
  84. //        LED3=0;
  85.     while(1)
  86.     {
  87.                 keyscan();
  88.     }                        
  89. }

  91. void tim0() interrupt 1
  92. {
  93.         if(flag1)

  95.         {
  96.                 pwm_t++;
  97.                 if(pwm_t==100)//周期1ms   频率1000Hz
  98.                 {pwm_t=0;}
  99.                 if( pwm_led_val < pwm_t )
  100.                 {OUT = 0; OUT1 = !OUT;}
  101.                 else {OUT=1; OUT1 = !OUT;}
  102.         }
  103.         else OUT=OUT1=1;

  105. //----------------------------------------------
  106.         if(flag4)
  107.         {
  108.                 ++uiKeyTimeCnt1;
  109.                 if(uiKeyTimeCnt1==100) //1ms到
  110.                 {
  111.                         uiKeyTimeCnt1=0;
  112.                         ++uiKeyTimeCnt4;
  113.                 }
  114.        
  115.         } //延时计数器

  117. //-------------------调光-------------------------
  118.         if(flag3)
  119.         {
  120.                 ++uiKeyTimeCnt2;  //延时计数器
  121.                 if(uiKeyTimeCnt2==100)
  122.                 {
  123.                         uiKeyTimeCnt2=0;
  124.                         ++uiKeyTimeCnt3;
  125.                         if(uiKeyTimeCnt3==30)//30ms调一步，此处调节调光速度，值越大，调光越慢
  126.                         {

  128.                                  uiKeyTimeCnt3=0;
  129.                      if(flag == 0)
  130.                       {
  131.        
  132.                          if(pwm_led_val < 100)
  133.        
  134.                           {
  135.                               pwm_led_val++;        //亮度变暗
  136.        
  137.                               if(pwm_led_val==99)//此处赋值100可以调灭
  138.                                   flag = 1;
  139.                           }
  140.                       }
  141.        
  142.                       if( flag ==1 )
  143.                       {
  144.                           if(pwm_led_val > 0)
  145.                           {
  146.                               pwm_led_val--;        //亮度变亮
  147.                               if(pwm_led_val==0)//
  148.                                   flag = 0;
  149.                           }
  150.                       }               
  151.                          }
  152.                 }
  153.         }

  155. }
复制代码
ID:140489 发表于 2019-12-3 12:27
我写了个一键开关灯加调光的程序，你参考下
  1. //短按开关灯，开灯状态下，长按调光，开灯状态随时都可以调光         2019/10/22 调试完成
  2. #include<reg51.h>
  3. #define uint unsigned int
  4. #define uchar unsigned char


  7. //sfr AUXR = 0x8e;   //Auxiliary register


  10. sbit OUT=P1^1;//  P1.1输出pwm
  11. sbit OUT1=P1^2;//  P1.2输出pwm

  13. sbit KEY1 = P3^0;

  15. #define const_key_time1 10   //短按去抖动延时的时间
  16. #define const_key_time2 500  //长按延时的时间

  18. uint uiKeyTimeCnt1=0; //按键去抖动延时计数器
  19. uint uiKeyTimeCnt4=0; //按键去抖动延时计数器
  20. uint uiKeyTimeCnt2=0; //调光速度变量
  21. uint uiKeyTimeCnt3=0; //调光速度变量
  22. uchar ucKeyLock1=0;   //按键触发后自锁的变量标志
  23. uchar pwm_t;              //pwm周期
  24. bit flag;                      //调光加减标志
  25. uchar pwm_led_val = 50;//LED占空比值
  26. bit flag1;                                //开关灯标志
  27. bit flag2;                                //短按触发标志
  28. bit flag3;                                //长按调光启停标志
  29. bit flag4;                                //按键延时计数启动标志

  31. void keyscan()
  32. {
  33.         if(KEY1==1)        //按键没按下 要及时清零一些标志
  34.         {

  36.                 ucKeyLock1=0;   //按键自锁标志清零
  37.                 uiKeyTimeCnt4=0;//按键去抖动延时计数器清零

  39.                 uiKeyTimeCnt1=0;
  40.                 flag3=0;                //长按松手，停止调光
  41.                 flag4=0;                //松手，按键延时计数停止
  42.                 if(flag2 == 1)        //短按触发标志
  43.                 {
  44.                         flag2=0;
  45.                         flag1 = !flag1;//开关灯标志，松手后才开灯
  46.                 }
  47.        
  48.         }
  49.         else if(ucKeyLock1==0)//按键按下，且是第一次感应
  50.         {       
  51.                 flag4=1;
  52.                 //++uiKeyTimeCnt1;  //延时计数器
  53.                 if(uiKeyTimeCnt4>const_key_time1)//短按        10ms
  54.                 {       
  55.                         flag2 = 1;   //按键按下，启动计数标志
  56. //                        OUT= OUT1=0; //按下就把灯打开，        不要这句 就是松手后才开灯
  57.                 }               
  58.                 if(uiKeyTimeCnt4>const_key_time2)//长按 0.5s
  59.                 {
  60.                        
  61.                         flag2=0;                //清除短按标志
  62.                         ucKeyLock1=1; //自锁按键置位,避免一直触发
  63.        
  64.                         uiKeyTimeCnt4=0;
  65.        
  66.                         flag3=1;  //启动调光
  67.                        
  68.                 }
  69.         }
  70. }


  73. void main()
  74. {
  75.        
  76. //        AUXR &= 0x7F;                //定时器时钟12T模式
  77. //        TMOD &= 0xF0;                //设置定时器模式
  78.         TMOD |= 0x02;        //设置定时器模式 8为自动重装
  79.         TL0 = 0xF7;                //设置定时初值        10us   @11.0592M
  80.         TH0 = 0xF7;                //设置定时重载值
  81.     EA=1;//开总中断
  82.     ET0=1;//开定时器0中断
  83.     TR0=1;//启动定时器0
  84. //        LED3=0;
  85.     while(1)
  86.     {
  87.                 keyscan();
  88.     }                        
  89. }

  91. void tim0() interrupt 1
  92. {
  93.         if(flag1)

  95.         {
  96.                 pwm_t++;
  97.                 if(pwm_t==100)//周期1ms   频率1000Hz
  98.                 {pwm_t=0;}
  99.                 if( pwm_led_val < pwm_t )
  100.                 {OUT = 0; OUT1 = !OUT;}
  101.                 else {OUT=1; OUT1 = !OUT;}
  102.         }
  103.         else OUT=OUT1=1;

  105. //----------------------------------------------
  106.         if(flag4)
  107.         {
  108.                 ++uiKeyTimeCnt1;
  109.                 if(uiKeyTimeCnt1==100) //1ms到
  110.                 {
  111.                         uiKeyTimeCnt1=0;
  112.                         ++uiKeyTimeCnt4;
  113.                 }
  114.        
  115.         } //延时计数器

  117. //-------------------调光-------------------------
  118.         if(flag3)
  119.         {
  120.                 ++uiKeyTimeCnt2;  //延时计数器
  121.                 if(uiKeyTimeCnt2==100)
  122.                 {
  123.                         uiKeyTimeCnt2=0;
  124.                         ++uiKeyTimeCnt3;
  125.                         if(uiKeyTimeCnt3==5)//5ms调一步，此处调节调光速度，值越大，调光越慢
  126.                         {

  128.                                  uiKeyTimeCnt3=0;
  129.                      if(flag == 0)
  130.                       {
  131.        
  132.                          if(pwm_led_val < 100)
  133.        
  134.                           {
  135.                               pwm_led_val++;        //亮度变暗
  136.        
  137.                               if(pwm_led_val==99)//此处赋值100可以调灭
  138.                                   flag = 1;
  139.                           }
  140.                       }
  141.        
  142.                       if( flag ==1 )
  143.                       {
  144.                           if(pwm_led_val > 0)
  145.                           {
  146.                               pwm_led_val--;        //亮度变亮
  147.                               if(pwm_led_val==0)//
  148.                                   flag = 0;
  149.                           }
  150.                       }               
  151.                          }
  152.                 }
  153.         }

  155. }
复制代码
ID:586438 发表于 2019-12-3 10:59
yzwzfyz 发表于 2019-12-2 21:54
要点：做一个计数器CJ来判定长按与短按，CJ的规则如下：
1、CJ计数只发生于定时器的中断服务程序中，每次 ...

有没有范例可以仿照一下  非常感谢
ID:586438 发表于 2019-12-3 10:58
wulin 发表于 2019-12-2 15:52
按你的5ms扫描周期，给你写1个短按+/-，长按连+/-的示例程序
  1. #include <STC12C5A60S2.H>
  2. #define uchar unsigned char
  3. #define uint unsigned int
  4. sbit key_add=P3^4; //增加的按键 的I/O口
  5. sbit key_dec=P3^3; //减少的按键 的I/O口
  6. bit flg1=0;
  7. bit flg2=0;      //按键计数标志位
  8. bit flag10ms=0;   //10ms时间标志位
  9. int num=0x00;
  10. unsigned char num1=0;
  11. //typedef enum KeyState{StateInit,StateAffirm,StateSingle,StateRepeat};        //键值状态值

  13. void init()
  14. {
  15.         TMOD=0X01;     //16位计数模式
  16.         TH0=(65535-1000)/256;
  17.         TL0=(65535-1000)%256;  //定时1ms
  18.         EA=1;                  //开总中断
  19.         ET0=1;            
  20.         TR0=1;       
  21.         CMOD=0x02;                //PCA计数脉冲选择为fos/2
  22.   CL=0x00;                                                                //清零
  23.   CH=0x00;
  24.   CCAP0H = CCAP0L = 0x00;          //PWM0的初始占空比为100%
  25.   CCAPM0=0x42;
  26.   CR=1;
  27. }

  29. void time0() interrupt 1
  30. {
  31.         TH0=(65535-1000)/256;
  32.         TL0=(65535-1000)%256;
  33.         num1++;
  34.         if(num1==10)
  35.         {
  36.                 flag10ms=1;
  37.         }
  38. }

  40. void keyscan()
  41. {
  42.         static uint count1,count2;        //消抖计数变量                        

  44.         if(!key_add)   
  45.         {  
  46.                 count1++;  
  47.                 if(count1>=150) //长按1.5s
  48.                 {
  49.                         if(num<255)
  50.                                         num++;
  51.                         count1=100; //连+间隔0.25s
  52.                 }
  53.         }  
  54.         else      //按键抬起
  55.         {  
  56.                 if(count1>1 && count1<150)       //短按20ms~0.75s
  57.                 {
  58.                         if(num<255)
  59.                                 num+=25;
  60.                 }
  61.                 count1=0;  //count1清0
  62.         }   
  63.         if(!key_dec)   
  64.         {  
  65.                 count2++;  
  66.                 if(count2>=150)//长按快调0.75s
  67.                 {
  68.                         if(num>0)
  69.                                         num--;
  70.                         count2=100;     //连-间隔0.25s
  71.                 }
  72.         }  
  73.         else   //按键抬起
  74.         {  
  75.                 if(count2>1 && count2<150)   //短按20ms~0.75s
  76.                 {
  77.                         if(num>0)
  78.                                 num-=25;
  79.                 }
  80.                 count2=0;  //count2清0
  81.         }   
  82. }
  83. void main()
  84. {
  85.         P3M0=0X80;
  86.         P3M1=0X00;//P3^7口推挽输出
  87.         init();
  88.         while(1)
  89.         {
  90.                 if(flag10ms==1)
  91.                 {
  92.                         CCAP0H=num;
  93.                         flag10ms=0;
  94.                         keyscan();
  95.                 }
  96.                 //display();//显示函数
  97.         }
  98. }
复制代码

这是我的全部代码  长按松开才加一次  为了区分是长按还是短按  我特地把长按和短按加的数值改了  发现长按只是实现了短按的功能  拜托能在指点一下吗  非常感谢
ID:123289 发表于 2019-12-2 21:54
要点：做一个计数器CJ来判定长按与短按，CJ的规则如下：
1、CJ计数只发生于定时器的中断服务程序中，每次中断+1，计满不再计，即不回0。
2、CJ计数只发生于键按下的时候，未按下不计。
3、做一个键状态判定触发标记：B_OK，如果键未按下，但CJ<>0，则置B_OK=1，表示是判断键状态的时候了。
4、当B_OK=1，判断键状态的界定法则是：CJ<某个值为短按，CJ>某个值为长按，某个值是多少由你决定。建议事先将长短两个界定值放置在某个寄存器中，这样可以随意变更界定值。
5、状态界定完成后将：B_OK清0、CJ清0以备下次再界定。
ID:586438 发表于 2019-12-2 21:20
lids 发表于 2019-12-2 16:08
//试一下这样写
void keyscan()
{

非常感谢您的帮忙 我会认真理解的多谢了
ID:586438 发表于 2019-12-2 21:19
wulin 发表于 2019-12-2 15:52
按你的5ms扫描周期，给你写1个短按+/-，长按连+/-的示例程序

非常感谢  这个就是仿照您给别人留言上学习 的  没想到弄成这样   非常感谢您的帮忙   我会认真理解的
ID:586438 发表于 2019-12-2 21:17
SroneBridge 发表于 2019-12-2 15:27
短按，一下就被你清零了。

真是多谢分析了   不问不知道  一问吓一跳   真的非常感谢
ID:650297 发表于 2019-12-2 20:52
count定义1个，num定义两个，程序重写一遍重复一下就是num1
ID:650297 发表于 2019-12-2 20:49
count定义1个，num定义两个，程序重写后重复一遍就是num1
ID:89515 发表于 2019-12-2 17:08
只是在不断实现短按键给你造成了错觉。
ID:89515 发表于 2019-12-2 17:05
逻辑错误，无法实现长按键。
ID:140489 发表于 2019-12-2 16:08
//试一下这样写
void keyscan()
{
        static  uint count1;
        if(key_add==0)
        {
               count1++;
               if（count1>=200)
               {
                    count1=100;//这里调节连加的速度
                   num++；
                  if(num>=255)
                  num=255;
                }
                else if(count1>=1 && count<200)
               {
                     count1=0;
                     num +=25;
                     if(num>=255)
                      num=255;
               }
         }
}
ID:213173 发表于 2019-12-2 15:52
按你的5ms扫描周期，给你写1个短按+/-，长按连+/-的示例程序
  1. void key_scan()
  2. {
  3.         static uint count1,count2;        //消抖计数变量                       

  5.         if(!K1)   
  6.         {  
  7.                 count1++;  
  8.                 if(count1>=150)                        //长按快调0.75s
  9.                 {
  10.                         if(num<255)
  11.                                 num++;
  12.                         count1=100;                        //连+间隔0.25s
  13.                 }
  14.         }  
  15.         else                                                //按键抬起
  16.         {  
  17.                 if(count1>4 && count1<150)//短按20ms~0.75s
  18.                 {
  19.                         if(num<255)
  20.                                 num++;
  21.                 }
  22.                 count1=0;                                //count1清0
  23.         }   
  24.         if(!K2)   
  25.         {  
  26.                 count2++;  
  27.                 if(count2>=150)                        //长按快调0.75s
  28.                 {
  29.                         if(num>0)
  30.                                 num--;
  31.                         count2=100;                        //连-间隔0.25s
  32.                 }
  33.         }  
  34.         else                                                //按键抬起
  35.         {  
  36.                 if(count2>4 && count2<150)        //短按20ms~0.75s
  37.                 {
  38.                         if(num>0)
  39.                                 num--;
  40.                 }
  41.                 count2=0;                                //count2清0
  42.         }   
  43. }
复制代码
ID:396245 发表于 2019-12-2 15:27
短按，一下就被你清零了。
ID:396245 发表于 2019-12-2 15:26

ID:470332 发表于 2019-12-2 14:37
还是好好屡屡逻辑吧，画个流程图
ID:641629 发表于 2019-12-2 14:35
num  在哪里定义与赋值的啊

小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表