标题: 关于用单片机+红外遥控长按短按设置定时器的问题 [打印本页]

---

作者: nyjm2021    时间: 2021-3-19 15:30
标题: 关于用单片机+红外遥控长按短按设置定时器的问题


我用的是51单片机，想用NEC协议的红外遥控来设置定时器，这个阶段想要实现的功能是这样的：1.数码管前4位显示ds1302芯片设置的时间（已实现）。

2.长按遥控的电源键5s（编码为0x45），定时功能打开，这时数码管前两位显示小时，后两位显示分钟，初始值都为0.（已实现）
3.再按下遥控的电源键（小于5s），代表小时的前两位闪烁。（有问题）
4.再次按下遥控的电源键（小于5s），代表分钟的后两位闪烁。（有问题）
我用计算红外遥控的连发码数量来算电源键长按下的时间，连发码一个约108ms，5s需要达到46个连发码。
最开始按下电源键，达到46个连发码时可以打开定时器，小时和分钟都不闪烁，数码管上显示00：00。再按电源键可以让小时闪烁，再按可以让分钟闪烁。但如果打开定时器后，按下的时间比较长，一直没有松开，按理说闪烁的部分是不应该有变化的，但是实际上在20个连发码的时候，闪烁的小时或者分钟会自动交换一次，等到35个连发码时又会自动交换一次，等到46个连发码时定时器没有再次打开（小时或者分钟还会闪烁），等到50个连发码以上时定时器才会重新打开。
想问下有人知道这是什么原因导致的，怎样才能改掉这个问题吗？谢谢！感觉问题应该出在EX0_ISR()函数或者ir_process()函数：————————————————————————————————————————————————
解决方案：因为每次是在到20个连发码的时候出现这个问题，所以我后来在ir_process（）函数中把短按的最长时间从小于46个连发码改到了小于15个连发码，虽然没有找到这个问题出现的原因，但也让这个问题不再出现了。


下面是我的单片机main.c文件代码：

1. #include "reg52.h"        
   
2. #include "ds1302.h"
   
3. #include <intrins.h>                 //此文件中定义了单片机的一些特殊功能寄存器
   
4. 
   
5. #define uint unsigned int          //对数据类型进行声明定义
   
6. #define uchar unsigned char
   
7. #define ulong unsigned long
   
8. 
   
9. bit timer_on_flag,hour_flash,min_flash;   //定时器开启，时钟闪烁，分钟闪烁
   
10.   
    
11. uint hour,min;            
    
12. 
    
13. sbit lsa = P2^4;          //数码管位选
    
14. sbit lsb = P2^3;
    
15. sbit lsc = P2^2;
    
16. 
    
17. 
    
18. sbit IRIN = P3^2;   //红外遥控
    
19. uint irtime;            //检测红外高电平持续时间
    
20. bit irpro_ok,irok;
    
21. uchar IRcord[4];         //储存数据码
    
22. uchar irdata[33];         //1引导码 8位客户1 8位客户2 8位操作码 8位操作反码
    
23. bit shortpress;   //红外遥控短按和长按
    
24. uint long_press_time;   //红外遥控连发码数量
    
25. 
    
26. uchar code duan[] = {0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71};
    
27. 
    
28. uint flag1ms,flag5ms,flag100ms;
    
29. 
    
30. uchar n4,n5,n6,n7;
    
31. uchar n0,n1,n2,n3;
    
32. bit dig_on;             //数码管打开
    
33. 
    
34. void Ircordpro();
    
35. void ir_process();
    
36. /*------------------------------------------------------------------------------
    
37.                           数码管位选、赋值、闪烁
    
38. ------------------------------------------------------------------------------*/
    
39. void flash_display(uchar seta,uchar setb,uchar setc,uchar num,bit check)                           //数码管闪烁
    
40. {
    
41.          static uchar flash = 0;
    
42.         lsa = seta; lsb = setb; lsc = setc;
    
43.         if(check)
    
44.         {
    
45.                 if(++flash>10) flash = 0;
    
46.                 else if(flash<=4) P0 = duan[num];
    
47.                 else if(flash>4) P0 = 0x00;
    
48.          }else{
    
49.                  P0 = duan[num];
    
50.          }
    
51. }
    
52. 
    
53. /*------------------------------------------------------------------------------
    
54.                                 数码管显示
    
55. ------------------------------------------------------------------------------*/
    
56. void display(){
    
57.     static uchar i = 0;                  
    
58. 
    
59.         if(dig_on)
    
60.         {        
    
61.                 switch(i)
    
62.                 {                        
    
63.                         case 0:        flash_display(1,1,1,n7,hour_flash);break;
    
64.                         case 1:        flash_display(1,1,0,n6,hour_flash);break;
    
65.                         case 2:        flash_display(1,0,1,n5,min_flash);break;
    
66.                         case 3: flash_display(1,0,0,n4,min_flash);break;
    
67.                         case 4: lsa = 0;lsb = 1;lsc = 1;P0 = duan[n3];break;
    
68.                         case 5: lsa = 0;lsb = 1;lsc = 0;P0 = duan[n2];break;
    
69.                         case 6: lsa = 0;lsb = 0;lsc = 1;P0 = duan[n1];break;
    
70.                         case 7: lsa = 0;lsb = 0;lsc = 0;P0 = duan[n0];break;                        
    
71.                 }
    
72.                 i++;
    
73.                 if(i>7)        i=0;
    
74.         }
    
75.         else
    
76.         {
    
77.                 P0 = 0x00;
    
78.         }               
    
79. }
    
80. 
    
81. /*------------------------------------------------------------------------------
    
82.                                 定时器1初始化
    
83. ------------------------------------------------------------------------------*/
    
84. void Timer1Init()
    
85. {
    
86.         TMOD &= 0x0F;                         //清0 T1的控制位
    
87.         TMOD |= 0x10;                     //定时器1的工作方式为1
    
88.         TH1 = (65536-921)/256;         //晶振频率为11.0592MHz，机器周期为12/11059200*1000000 = 1.08506944us，周期为1ms，N为1000/1.08506944 = 921.6
    
89.         TL1 = (65536-921)%256;
    
90. 
    
91.         EA = 1;                                     //打开总中断
    
92.         ET1 = 1;                             //打开定时器1中断
    
93.     TR1 = 1;                             //打开定时器1
    
94. }
    
95. 
    
96. /*------------------------------------------------------------------------------
    
97.                              定时器1中断服务函数
    
98. ------------------------------------------------------------------------------*/
    
99. void timer1() interrupt 3
    
100. {
     
101. 
     
102.          TH1 = (65536-921)/256;
     
103.         TL1 = (65536-921)%256;
     
104.         flag1ms = 1;                                                   //定时器周期为1ms
     
105. 
     
106.         P0 = 0x00;                                  //消抖
     
107. }
     
108. /*------------------------------------------------------------------------------
     
109.                          （红外）定时器0初始化
     
110. ------------------------------------------------------------------------------*/
     
111. void Timer0Init()  //256*（1/11.0592MHz)*12 = 0.278ms
     
112. {
     
113.         TMOD &= 0xF0;  //清零T0的控制位
     
114.         TMOD |= 0x02;  //定时器0工作方式2
     
115.         TH0 = 0x00;           //高位初始化
     
116.         TL0 = 0x00;           //低位初始化
     
117.         ET0 = 1;           //定时器0中断
     
118.         TR0 = 1;           //启动定时器
     
119. }
     
120. 
     
121. /*------------------------------------------------------------------------------
     
122.                          （红外）外部中断0初始化
     
123. ------------------------------------------------------------------------------*/
     
124. void Int0Init()   //外部中断0初始化
     
125. {
     
126.         IT0 = 1;          //设置外部中断0为下降沿触发
     
127.         EX0 = 1;          //启动外部中断0
     
128.         EA = 1;                  //总中断允许
     
129. }
     
130. 
     
131. /*------------------------------------------------------------------------------
     
132.                           （红外）定时器0中断服务函数
     
133. ------------------------------------------------------------------------------*/
     
134. 
     
135. void timer0() interrupt 1
     
136. {
     
137.         irtime++;         //检测脉宽，一次位278us
     
138. }
     
139. 
     
140. /*------------------------------------------------------------------------------
     
141.                           （红外）外部中断0服务函数
     
142. ------------------------------------------------------------------------------*/
     
143. void EX0_ISR() interrupt 0
     
144. {
     
145.         static uchar i;                 //把33次高电平持续时间存入irdata
     
146.         static bit startflag;         //开始存储脉宽标志位
     
147. 
     
148.         if(startflag)                         //开始接收脉宽检测
     
149.         {   
     
150.                 if(irtime<63 && irtime>=45)   //判断是否引导码，低电平9ms+高电平4.5ms         
     
151.                 {
     
152.                         i = 0;                         //如果是存入irdata的第一位
     
153.                         shortpress = 1;
     
154.                         long_press_time = 0;
     
155.                 }
     
156.                 else if(irtime>33 && irtime <45)         //判断是否为连发码，低电平9ms+高电平2.25ms
     
157.                 {
     
158.                         shortpress = 0;
     
159.                         long_press_time++;                          //计算连发码的数量
     
160.                 }
     
161.                 if(shortpress)
     
162.                 {
     
163.                         irdata[i] = irtime;
     
164.                 }
     
165.                 irtime = 0;                        //计数清零，下一个下降沿的时候再存入脉宽
     
166.                 i++;                                //计算脉宽存入的次数
     
167.                 if(i==33)                        //如果存入34次
     
168.                 {
     
169.                         irok = 1;                //脉宽检测完毕
     
170.                         i = 0;                        //脉宽计数清零准备下次存入
     
171.                 }         
     
172.         }
     
173.         else
     
174.         {
     
175.                 irtime = 0;                        //计数清零
     
176.                 startflag = 1;                //开始处理
     
177.         }
     
178. }
     
179. /*------------------------------------------------------------------------------
     
180.                           （红外）码值处理函数
     
181. ------------------------------------------------------------------------------*/
     
182. void Ircordpro()  //提取33次脉宽进行数据解码
     
183. {
     
184.         uchar i, j, k,cord,value;            //k用于33次脉宽中的哪一位
     
185.         k=1;                                            //从第一位开始，丢弃引导码脉宽
     
186.         for(i=0;i<4;i++)                //处理4个字节
     
187.         {
     
188.                 for(j=1;j<=8;j++)       //处理1个字节8位
     
189.                 {
     
190.                         cord=irdata[k];        //把脉宽存入cord
     
191.                         if(cord>5)      //脉宽大于11.0592的T0溢出率位约278us*5=1390那么判断为1
     
192.                         {
     
193.                                                         value=value|0x80;  //接收时先接收最低位
     
194.                                                 }
     
195.                         if(j<8)
     
196.                         {
     
197.                                 value>>=1;           //value位左移依次接收8位数据
     
198.                         }
     
199.                         k++;               //每执行一次脉宽数加一
     
200.                 }
     
201.                 IRcord[i]=value;           //每处理完一个字节把它放入ircord数组中
     
202.                 value=0;                        //清零value方便下次存入数据
     
203.         }
     
204.         irpro_ok=1;  //接受完4个字节后irpro_ok置1表示红外解码完成
     
205. }
     
206. 
     
207. /*------------------------------------------------------------------------------
     
208.                           （红外）功能实现函数
     
209. ------------------------------------------------------------------------------*/
     
210. 
     
211. void ir_process()
     
212. {
     
213.         if(irok)                         //如果红外信号接收完毕
     
214.         {
     
215.                 Ircordpro();        //对红外信号进行解码
     
216.                 irok = 0;
     
217.                 shortpress = 0;
     
218.         }
     
219.         if(irpro_ok)                   //如果对红外信号解码完毕
     
220.         {
     
221.                 if(IRcord[2]==0x45 )           //如果按键是45H
     
222.                 {
     
223.                         if(long_press_time >= 46)          //长按打开定时器
     
224.                         {
     
225.                                 timer_on_flag = 1;                 //打开定时器
     
226.                                 hour = 0;
     
227.                                 min = 0;
     
228.                                 hour_flash = 0;                         //小时不闪烁
     
229.                                 min_flash = 0;                         //分钟不闪烁
     
230.                         }
     
231.                         else if( (1<=long_press_time && long_press_time <46))           //短按对时间进行选择,设置超过20时会自动跳变
     
232.                         {
     
233.                                         if(timer_on_flag)                                   //如果定时器处于打开状态
     
234.                                         {
     
235.                                                 if(!min_flash && !hour_flash)          //小时分钟均不闪烁，让小时闪烁
     
236.                                                 {
     
237.                                                         hour_flash = 1;
     
238.                                                         irpro_ok = 0;
     
239.                                                 }
     
240.                                                 else if(hour_flash && !min_flash)                                   //小时已经在闪烁，短按一下让分钟闪烁
     
241.                                                 {
     
242.                                                         hour_flash = 0;
     
243.                                                         min_flash = 1;
     
244.                                                         irpro_ok = 0;
     
245.                                                 }
     
246.                                                 else if(min_flash && !hour_flash)
     
247.                                                 {
     
248.                                                         hour_flash = 1;                           //小时没有闪烁，短按一下让小时闪烁，分钟不闪烁
     
249.                                                         min_flash = 0;
     
250.                                                         irpro_ok = 0;
     
251.                                                 }
     
252.                                        
     
253.                                         }
     
254.                         }
     
255.                 }         
     
256.         }  
     
257.                
     
258. }
     
259. /*------------------------------------------------------------------------------
     
260.                           数码管显示内容设置函数
     
261. ------------------------------------------------------------------------------*/
     
262. void calculate_num()
     
263. {        
     
264.         
     
265.         n3 = long_press_time / 10;
     
266.         n2 = long_press_time % 10;
     
267.         n1 = IRcord[2]>>4;
     
268.         n0 = IRcord[2]&0x0F;
     
269.         
     
270.         if(timer_on_flag)                    //定时器打开，数码管显示定时的倒计时
     
271.         {
     
272.                 n7 = hour / 10;
     
273.                 n6 = hour % 10;
     
274.                 n5 = min / 10;
     
275.                 n4 = min % 10;
     
276.         }else if(!timer_on_flag)          //定时器未开，数码管显示时钟芯片实时时间
     
277.         {
     
278.                 Ds1302ReadTime();
     
279.                 n7 = TIME[2]/16;                //时
     
280.                 n6 = TIME[2]&0x0f;
     
281. 
     
282.             n5 = TIME[1]/16;                //分
     
283.                 n4 = TIME[1]&0x0f;
     
284.         }
     
285. }
     
286. 
     
287. /*------------------------------------------------------------------------------
     
288.                                 主函数
     
289. ------------------------------------------------------------------------------*/
     
290. void main( )
     
291. {        
     
292.         dig_on = 1;
     
293. 
     
294.         Timer0Init();
     
295.         Timer1Init();
     
296. 
     
297.     Ds1302Init();
     
298.         Int0Init();
     
299. 
     
300.         while(1)
     
301.         {
     
302.                   if(flag1ms)
     
303.                 {
     
304.                         flag1ms = 0;               
     
305.                         display();             //数码管显示
     
306.                         if(++flag5ms>=5)          //1ms * 5 = 5ms
     
307.                         {
     
308.                                 flag5ms = 0;
     
309.                                 ir_process();      //红外控制
     
310.                                 calculate_num();
     
311.                         }
     
312.                 }
     
313.         }        
     
314. }

复制代码

---

作者: lids    时间: 2021-3-19 16:19
用遥控器就多用几个键来设置，，遥控器上那么多的按键不用作什么

---

作者: nyjm2021    时间: 2021-3-19 18:37

lids 发表于 2021-3-19 16:19
用遥控器就多用几个键来设置，，遥控器上那么多的按键不用作什么

不好意思，我在做一个小项目，要求就是这样的，用一个遥控按键实现长按5s开启定时，短按切换小时和分钟闪烁

---

作者: 神蜂    时间: 2021-3-19 21:22
是否可以换个思路，再定义几个变量。

判断在一定时间段里。出现的0x45。

如第一个0X45存在IRcord—one[2]==0x45

后 108ms的0X45存在IRcord—two[2]==0x45

IRcord—two[2] 再后的0X45存在IRcord_three[2]==0x45

然后再分别处理IRcord_three[2]   IRcord—two[2]  IRcord—one[2]

      

---

作者: tyrl800    时间: 2021-3-20 14:30
楼主的程序中long_press_time未复位0；程序应该没有长按功能，只有短按功能

---

作者: nyjm2021    时间: 2021-3-20 16:43

tyrl800 发表于 2021-3-20 14:30
楼主的程序中long_press_time未复位0；程序应该没有长按功能，只有短按功能

长按功能是可以实现的。我这里的长按和短按更准确地说是判断读取到的是11.25ms的连发码还是13.5ms的引导码，long_press_time是在短按，也就是接收到引导码的时候复位0的。每一次有按键按下，最开始发送引导码，执行短按部分的程序，long_press_time归0，读取到的数据码存储在irdata[]中，按键持续按下，没有放开，读取到连发码，long_press_time自增，不存储新的数据。每一次读取到引导码或者连发码时，用Ircordpro()函数进行解码，并用ir_process()函数完成相应的功能。遥控按键放开，下一次又有按键按下时，再对引导码进行处理，long_press_time再次清零。

---

作者: barret.zhang    时间: 2021-3-20 19:40
// =========================== key.c ======================
#include "reg51.h"

#define KEY_INPUT           P1.0    //  按键IO

#define KEY_STATE_0         0       //  按键状态
#define KEY_STATE_1         1
#define KEY_STATE_2         2
#define KEY_STATE_3         3

#define SINGLE_KEY_TIME     3       //  SINGLE_KEY_TIME*10MS = 30MS     判定单击的时间长度，软件消抖
#define KEY_INTERVAL        30      //  KEY_INTERVAL*10MS    = 300MS 判定双击的时间间隔
#define LONG_KEY_TIME       300     //  LONG_KEY_TIME*10MS   = 3S   判定长按的时间长度


#define N_KEY               0       //  no click
#define S_KEY               1       //  single click        单击
#define D_KEY               2       //  double click        双击
#define T_KEY               3       //  Triple click        三击
#define Q_KEY               4       //  Quadruple click     四击
#define L_KEY               10      //  long press          长按

// ----------------------------------- key_driver --------------------------
unsigned char key_driver(void)
{     
    static unsigned char key_state = 0;
    static unsigned int  key_time = 0;
    unsigned char key_press, key_return;

    key_return = N_KEY;                         //  清除 返回按键值

    key_press = key_input;                      //  读取当前键值

    switch (key_state)     
    {      
        case KEY_STATE_0:                       //  按键状态0：判断有无按键按下
            if (!key_press)                     //  有按键按下
            {
                key_time = 0;                   //  清零时间间隔计数
                key_state = KEY_STATE_1;        //  然后进入 按键状态1
            }        
            break;

        case KEY_STATE_1:                       //  按键状态1：软件消抖（确定按键是否有效，而不是误触）。按键有效的定义：按键持续按下超过设定的消抖时间。
            if (!key_press)                     
            {
                key_time++;                     //  一次10ms
                if(key_time>=SINGLE_KEY_TIME)   //  消抖时间为：SINGLE_KEY_TIME*10ms = 30ms;
                {
                    key_state = KEY_STATE_2;    //  如果按键时间超过 消抖时间，即判定为按下的按键有效。按键有效包括两种：单击或者长按，进入 按键状态2， 继续判定到底是那种有效按键
                }
            }         
            else key_state = KEY_STATE_0;       //  如果按键时间没有超过，判定为误触，按键无效，返回 按键状态0，继续等待按键
            break;

        case KEY_STATE_2:                       //  按键状态2：判定按键有效的种类：是单击，还是长按
            if(key_press)                       //  如果按键在 设定的长按时间 内释放，则判定为单击
            {
                 key_return = S_key;            //  返回 有效按键值：单击
                 key_state = KEY_STATE_0;       //  返回 按键状态0，继续等待按键
            }
            else
            {
                key_time++;                     

                if(key_time >= LONG_KEY_TIME)   //  如果按键时间超过 设定的长按时间（LONG_KEY_TIME*10ms=300*10ms=3000ms）, 则判定为 长按
                {
                    key_return = L_KEY;         //  返回 有效键值值：长按
                    key_state = KEY_STATE_3;    //  去状态3，等待按键释放
                }
            }
            break;

      case KEY_STATE_3:                         //  等待按键释放
          if (key_press)
          {
              key_state = KEY_STATE_0;          //  按键释放后，进入 按键状态0 ，进行下一次按键的判定
          }        
          break;

        default:                                //  特殊情况：key_state是其他值得情况，清零key_state。这种情况一般出现在 没有初始化key_state，第一次执行这个函数的时候
            key_state = KEY_STATE_0;
            break;
    }

    return  key_return;                         //  返回 按键值
}

// ----------------------------------- key_read --------------------------------
void key_read(void)                             
{
    static unsigned char key_state1=0, key_time1=0;
    unsigned char key_return,key_temp;

    key_return = N_KEY;                         //  清零 返回按键值

    key_temp = key_driver();                    //  读取键值

    switch(key_state1)
    {         
        case KEY_STATE_0:                       //  按键状态0：等待有效按键（通过 key_driver 返回的有效按键值）
            if (key_temp == S_key )             //  如果是[单击]，不马上返回单击按键值，先进入 按键状态1，判断是否有[双击]的可能
            {
                 key_time1 = 0;                 //  清零计时
                 key_state1 = KEY_STATE_1;
            }            
            else                                //  如果不是[单击]，直接返回按键值。这里的按键值可能是：[长按]，[无效按键]
            {
                 key_return = key_temp;         //  返回 按键值
            }
            break;

        case KEY_STATE_1:                       //  按键状态1：判定是否有[双击]
            if (key_temp == S_key)              //  有[单击]后，如果在 设定的时间间隔（KEY_INTERVAL*10ms=30*10ms=300ms） 内，再次有[单击]，则为[双击]，但是不马上返回 有效按键值为[双击]，先进入 按键状态2，判断是否有[三击]
            {
                key_time1 = 0;                  //  清零 时间间隔
                key_state1 = KEY_STATE_2;       //  改变 按键状态值
            }
            else                                //  有[单击]后，如果在 设定的时间间隔（KEY_INTERVAL*10ms=30*10ms=300ms）内，没有[单击]出现，则判定为 [单击]
            {
                key_time1++;                    //  计数 时间间隔
                if(key_time1 >= KEY_INTERVAL)   //  超过 时间间隔
                 {
                    key_return = S_key;         //  返回 有效按键：[单击]
                    key_state1 = KEY_STATE_0;   //  返回 按键状态0，等待新的有效按键
                 }              
             }              
             break;

        case KEY_STATE_2:                       // 按键状态2：判定是否有[三击]
            if (key_temp == S_key)              // 有[双击]后，如果在 设定的时间间隔（KEY_INTERVAL*10ms=30*10ms=300ms） 内，再次有[单击]，则为[三击]，由于这里只扩展到[三击]，所以马上返回 有效按键值为[三击]
            {
                key_time1 = 0;                  // 清零 时间间隔
                key_state1 = KEY_STATE_3;       // 改变 按键状态值
            }
            else                                // 有[双击]后，如果在 设定的时间间隔（KEY_INTERVAL*10ms=30*10ms=300ms）内，没有[单击]，则判定为 [双击]
            {
                key_time1++;                    // 计数 时间间隔
                if(key_time1 >= KEY_INTERVAL)   // 超过 时间间隔
                 {
                      key_return = D_KEY;       // 返回 有效按键：[双击]
                      key_state1 = KEY_STATE_0; // 返回 按键状态0，等待新的有效按键
                 }
             }
             break;

        case KEY_STATE_3:                       // 按键状态3：等待按键释放
            if (key_temp == S_key)              // 有[三击]后，如果在 设定的时间间隔（KEY_INTERVAL*10ms=30*10ms=300ms） 内，再次有[单击]，则为[四击]，马上返回有效按键值为[四击]，
            {
                 key_return = Q_key;            // 返回 有效按键：[四击]
                 key_state1 = KEY_STATE_0;      // 返回 按键状态0，等待新的有效按键
            }
            else                                
            {                                   // 有[三击]后，如果在 设定的时间间隔（KEY_INTERVAL*10ms=30*10ms=300ms）内，没有[单击]，则判定为 [三击]                 
                key_time1++;                    // 计数 时间间隔
                if(key_time1 >= KEY_INTERVAL)   // 超过 时间间隔
                 {
                      key_return = T_KEY;       // 返回 有效按键：[三击]
                      key_state1 = KEY_STATE_0; // 返回 按键状态0，等待新的有效按键
                 }              
             }            
             break;

        default:                                //  特殊情况：key_state是其他值得情况，清零key_state。这种情况一般出现在 没有初始化key_state，第一次执行这个函数的时候
            key_state1 = KEY_STATE_0;
            break;
    }

    return = key_return;                        // 返回 按键值
}     

---

作者: tyrl800    时间: 2021-3-20 20:36

nyjm2021 发表于 2021-3-20 16:43
长按功能是可以实现的。我这里的长按和短按更准确地说是判断读取到的是11.25ms的连发码还是13.5ms的引导 ...

楼主程序每次都先执行短按，有长按再执行，没有区分开吧

---

作者: Kaiii    时间: 2022-5-1 12:31
获益匪浅

---

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

Powered by Discuz! X3.1