旁观者 发表于 2021-3-6 16:40
我的思路是这样的，判断按键按下在while循环自加一个变量，松开后用if判断自加变量是否大于你定的时间变量 ...

必须加计数器 而且要设定计数器的时长或者间隔 不然以单片机的速度 瞬间你这个变量就溢出了 然后重新计数 最后得到值未知 即 不一定是你需要的值

假设你定义个int变量 那么最大范围是65535 如果不加计数器 int变量从0到65535也就是毫秒级别 等你松手的时候int的值可能是0~65535之间任意一个数值

简单的流程应该是这样

用计数器设定一个20~50ms计数器 即每一次中断是20~50ms
然后设置一个变量 变量=计时器中断次数 即 每20~50ms这个变量被＋一次
按下按键后防抖 确认按下时 清零变量
松开按键后防抖 确认松开时 检察变量的值
如果变量>阀值=长按 否则是短按

我的思路是这样的，判断按键按下在while循环自加一个变量，松开后用if判断自加变量是否大于你定的时间变量，大于LED取反，自加变量置０.

1. #include <reg51.h>
   
2. 
   
3. sbit key = P3^0;
   
4. sbit led1 = P2^0;
   
5. sbit led2 = P2^1;
   
6. sbit led3 = P2^2;
   
7. 
   
8. unsigned char x = 0;
   
9. 
   
10. void init(void); //初始化定时器0
    
11. void delay(unsigned int a); //延时
    
12. void key_main(void); //按键事件判断
    
13. 
    
14. void main()
    
15. {
    
16.                 init();
    
17.                 key_main();
    
18. }
    
19. 
    
20. void init(void) //初始化定时器0
    
21. {
    
22.                 TMOD = 0x01;
    
23. //                IT0 = 1;      //低电平有效
    
24.                 TH0 = (65536-50000)/256;
    
25.                 TL0 = (65536-50000)%256;
    
26.                 EA = 1;
    
27.                 ET0 = 1;             //允许定时器t0中断
    
28. //                EX0 = 1;
    
29.                 key = 1;
    
30.                 P2 = 0x00;
    
31. }
    
32. 
    
33. void key_main(void) //按键事件判断
    
34. {
    
35.                 while(1)
    
36.                 {
    
37.                                 new:if(key == 0)
    
38.                                 {
    
39.                                                 delay(10);
    
40.                                                 if(key == 0)
    
41.                                                 {
    
42.                                                                 TR0 = 1;
    
43.                                                                 while(key == 0);       //第一次按键释放
    
44.                                                                 TR0 = 0;
    
45.                                                           
    
46.                                                                 if(x>16)        //判断是否为长按
    
47.                                                                 {
    
48.                                                                                 x = 0;
    
49.                                                                                 led3 = 1;
    
50. 
    
51.                                                                                 goto new;
    
52.                                                                 }
    
53.                                                                
    
54.                                                                 x = 0;
    
55.                                                                 TR0 = 1;
    
56. 
    
57.                                                                 while(x<=6) //在第一次按键事件完成后，若0.5秒内无按键事件，则为单击，否则是双击
    
58.                                                                 {
    
59.                                                                                 if(key == 0)
    
60.                                                                                 {
    
61.                                                                                                 delay(10);
    
62.                                                                                                        
    
63.                                                                                                 if(key == 0)
    
64.                                                                                                 {
    
65.                                                                                                                         TR0 = 0;
    
66.                                                                                                                         x = 0;
    
67.                                                                                                                         while(key == 0);
    
68.                                                                                                                         led2 = 1;
    
69. 
    
70.                                                                                                                         goto new;
    
71.                                                                                                 }
    
72.                                                                                         }
    
73.                                                                 }
    
74.                                                                
    
75.                                                                 TR0 = 0;
    
76. 
    
77.                                                                 if(x != 0)
    
78.                                                                 {
    
79.                                                                                 x = 0;
    
80.                                                                                 led1 = 1;
    
81. 
    
82.                                                                                 goto new;
    
83.                                                                 }
    
84.                                                 }
    
85.                                 }
    
86.                 }
    
87. }
    
88. 
    
89. 
    
90. void delay(unsigned int a) //延时
    
91. {
    
92.                 unsigned int i;
    
93.                 for(a;a>0;a--)
    
94.                 for(i=110;i>0;i--);
    
95. }
    
96. 
    
97. void time0(void) interrupt 1 //定时器0
    
98. {
    
99. //                ET0 = 0;
    
100.                 {
     
101.                                 TH0 = (65536-50000)/256;
     
102.                                 TL0 = (65536-50000)%256;
     
103.                                 x += 1;
     
104.                 }
     
105. //                ET0 = 1;
     
106. }
     
107. 
     
108. //void over(void) interrupt 0 //外部中断           触发后亮的指示灯灭
     
109. //{
     
110. //                ET0 = 0;
     
111. //                {
     
112. //                                if(led1 == 1)
     
113. //                                led1 = 0;
     
114. //                                if(led2 == 1)
     
115. //                                led2 = 0;
     
116. //                                if(led3 == 1)
     
117. //                                led3 = 0;
     
118. //                }
     
119. //                ET0 = 1;
     
120. //}
     

复制代码

单击，双击，长按，是一类一起学习吧

wulin 发表于 2021-2-26 16:50
//适用于STC8
#include

终于看到高手了，这才是真确的按键处理思路。不像有些菜鸟，按键处理程序里面有delay（）；

这是基本功，你不是会中断扫描处理按键了吗，定时器的中断时间是很准确的，比如你的定时器中断时间是10ms，在中断中加一句：time++;这个time就是10ms计时，第一次按键变1后，将time=0;等按键再一次变0后，time*10ms就是按键按下的准确时间。

用定时器计数呗，
或者每过一小段时间读一次进行采样，按照采样次数来确定是否长按

P3.0读到0后f计数，
P3.0变成1后看f的值，
若f大于某一树，则认为是长按，否则判定位短按或未按。

非STC得芯片？

wulin 发表于 2021-2-26 16:50
//适用于STC8
#include

谢谢，我就是苦恼在了计数怎么计的问题

坛子里有详细讲解的代码，上面找找看看，很容易

定时中断采样键盘，键盘按下就计数+1，若判断键盘松开，读取键盘按下的计数，根据大小判断长短按。

//适用于STC8
#include <reg52.h>

sbit key=P3^0;
sbit LED=P3^3;
long count;//计数变量
bit  key_sign;//按键状态标志

void main()
{
        while(1)
        {
                if(!key)//长按大约0.6秒响应，增加count值就可增加延时
                {
                        if(++count>=100000 && key_sign==0)
                        {
                                key_sign=1;//记忆按键状态
                                LED=~LED;//LED取反
                        }
                }
                else//松手
                {
                        count=0;//计数变量清0
                        key_sign=0;//按键状态复位
                }
        }
}

统计按下的时间应该可以，就是时间超过2S认为长按，才开灯！