多功能按键设计——利用一个I/O口，接一个按键，实现3功能操作：单击 + 双击 + 长按

看了一个晚上，结合了马潮老师的书，才搞懂这个程序，确实经典！原文：http://www.amobbs.com/thread-4991902-1-1.html

[cpp]  view plain copy

1. 题目：多功能按键设计。利用一个I/O口，接一个按键，实现3功能操作：单击 + 双击 + 长按。    
2. ============================================================================   
3. 用户基本操作定义：   
4.     1。短按操作：按键按下，按下时间<1s，属于一次短按操作   
5.     2。长按操作：按键按下，按下时间>1s，属于一次长按操作   
6.   
7. 在正常0.5s内无按键操作为启始按键扫描条件下，扫描按键将产生以下3种按键事件：   
8.     1。长按事件：任何1次出现的长按操作都属于长按事件   
9.     2。单击事件：1次短按操作后，间隔0.5内没有短按操作   
10.     3。双击事件：2次短按操作间隔时间<0.5s，则2次短按操作为1次双击事件，且2次短按都取消   
11.   
12. 特别操作情况定义：   
13.     1。短按操作和长按操作间隔<0.5s，以及，长按操作和短按操作间隔<0.5s，均不产生双击事件   
14.     2。连续n次（n为奇数）短按操作，且间隔均<0.5s，产生(n-1)/2次双击事件+1次单击事件   
15.     3。连续n次（n为偶数）短按操作，且间隔均<0.5s，产生n/2次双击事件   
16.   
17. 对按键操作者的建议：       
18.     由于按键的多功能性质，建议操作者每次在单击/长按/双击按键事件发生后，隔0.5s后再进行下一次的按键操作。因为在特别操作情况下，程序是保证按定义进行判断和处理的，主要是怕操作者自己记不清楚导致操作失误。   
19.   
20. 对软件设计者的要求：   
21.     1。应该全面进行分析，给出严格定义和判断条件，如上所示。如果自己都不清楚，你的设计出的系统就不稳定，不可靠。   
22.     2。在1的基础上，编写出符合要求的程序，并进行全面测试。   
23.   
24. /*=============  
25. 低层按键（I/0）扫描函数，即低层按键设备驱动，只返回无键、短按和长按。具体双击不在此处判断。参考本人教材的例9-1，稍微有变化。教材中为连_发。  
26. ===============*/   
27.   
28. #define key_input    PIND.7    // 按键输入口   
29.   
30. #define N_key    0             //无键   
31. #define S_key    1             //单键   
32. #define D_key    2             //双键   
33. #define L_key    3             //长键   
34.   
35. #define key_state_0 0   
36. #define key_state_1 1   
37. #define key_state_2 2   
38.   
39. unsigned char key_driver(void)   
40. {   
41.     static unsigned char key_state = key_state_0, key_time = 0;   
42.     unsigned char key_press, key_return = N_key;   
43.   
44.     key_press = key_input;                    // 读按键I/O电平   
45.   
46.     switch (key_state)   
47.     {   
48.       case key_state_0:                              // 按键初始态   
49.         if (!key_press) key_state = key_state_1;      // 键被按下，状态转换到按键消抖和确认状态   
50.         break;   
51.          
52.       case key_state_1:                      // 按键消抖与确认态   
53.         if (!key_press)   
54.         {   
55.              key_time = 0;                   //    
56.              key_state = key_state_2;   // 按键仍然处于按下，消抖完成，状态转换到按下键时间的计时状态，但返回的还是无键事件   
57.         }   
58.         else   
59.              key_state = key_state_0;   // 按键已抬起，转换到按键初始态。此处完成和实现软件消抖，其实按键的按下和释放都在此消抖的。   
60.         break;   
61.          
62.       case key_state_2:   
63.         if(key_press)   
64.         {   
65.              key_return = S_key;        // 此时按键释放，说明是产生一次短操作，回送S_key   
66.              key_state = key_state_0;   // 转换到按键初始态   
67.         }   
68.         else if (++key_time >= 100)     // 继续按下，计时加10ms（10ms为本函数循环执行间隔）   
69.         {   
70.              key_return = L_key;        // 按下时间>1000ms，此按键为长按操作，返回长键事件   
71.              key_state = key_state_3;   // 转换到等待按键释放状态   
72.         }   
73.         break;   
74.   
75.       case key_state_3:                 // 等待按键释放状态，此状态只返回无按键事件   
76.         if (key_press) key_state = key_state_0; //按键已释放，转换到按键初始态   
77.         break;   
78.     }   
79.     return key_return;   
80. }   
81.   
82. /*=============  
83. 中间层按键处理函数，调用低层函数一次，处理双击事件的判断，返回上层正确的无键、单键、双键、长键4个按键事件。  
84. 本函数由上层循环调用，间隔10ms  
85. ===============*/   
86.   
87. unsigned char key_read(void)   
88. {   
89.     static unsigned char key_m = key_state_0, key_time_1 = 0;   
90.     unsigned char key_return = N_key,key_temp;   
91.        
92.     key_temp = key_driver();   
93.        
94.     switch(key_m)   
95.     {   
96.         case key_state_0:   
97.             if (key_temp == S_key )   
98.             {   
99.                  key_time_1 = 0;               // 第1次单击，不返回，到下个状态判断后面是否出现双击   
100.                  key_m = key_state_1;   
101.             }   
102.             else   
103.                  key_return = key_temp;        // 对于无键、长键，返回原事件   
104.             break;   
105.   
106.         case key_state_1:   
107.             if (key_temp == S_key)             // 又一次单击（间隔肯定<500ms）   
108.             {   
109.                  key_return = D_key;           // 返回双击键事件，回初始状态   
110.                  key_m = key_state_0;   
111.             }   
112.             else                                  
113.             {                                  // 这里500ms内肯定读到的都是无键事件，因为长键>1000ms，在1s前低层返回的都是无键   
114.                  if(++key_time_1 >= 50)   
115.                  {   
116.                       key_return = S_key;      // 500ms内没有再次出现单键事件，返回上一次的单键事件   
117.                       key_m = key_state_0;     // 返回初始状态   
118.                  }   
119.              }   
120.              break;   
121.     }  
122.     return key_return;   
123. }       
124.   
125. 下面，根据程序分析按键事件的反映时间：   
126. 1。对于长键，按下超过1s马上响应，反映最快   
127. 2。对于双键，第2次按键释放后马上得到反映。   
128. 3。对于单键，释放后延时拖后500ms才能响应，反映最慢。这个与需要判断后面是否有双击操作有关，只能这样。实际应用中，可以调整两次单击间隔时间定义，比如为300ms，这样单击的响应回快一点，单按键操作人员需要加快按键的操作过程。如果产品是针对老年人的，这个时间不易太短，因为年纪大的人，反映和动作都比较慢。   
129.   
130.    当然，上面两段可以合在一起。我这样做的目的，是为了可以方便的扩展为N击（当然，需要做修改）。可是最底层的就是最基本的操作处理短按和长按，不用改动的。至于双击，还是N击，在中间层处理。这就是程序设计中分层结构的优点。   
131.   
132. 测试代码环境如下：    
133.   
134.   
135. interrupt [TIM0_COMP] void timer0_comp_isr(void)       // 定时器10ms中断服务   
136. {   
137.        time_10ms_ok = 1;   
138. }   
139.   
140.   
141. main(viod)    
142. {    
143.     .........    
144.   
145.     while    
146.     {    
147.         if (time_10ms_ok)            //每10ms执行一次，    
148.         {    
149.              time_10ms_ok =0;    
150.              key = key_read();       //《====== 10ms一次调用按键中间层函数，根据返回键值，点亮不同的LED灯，全面测试按键操作是否正常    
151.              if (key == L_key)    
152.                  ........//点亮A_LED，关闭B_LED和C_LED    
153.              else if(key == D_key)    
154.                  ........//点亮B_LED，关闭A_LED和C_LED    
155.              else if(key == S_key)    
156.                  ........//点亮C_LED，关闭A_LED和B_LED    
157.          }    
158.      }    
159. }    
160.   
161. =================================================   
162.   
163. 通过以上这个看似简单的按键，看在应用中如何变化，以及如何在实际产品中全面、可靠的进行设计。   
164. =======================================================================================================  

        还是讲手表上的一个键，如果是用户在查询时间方式工作，希望这个按键只有单击的单一功能，响应要快，而用户在设置时间方式工作，希望这个按键是多功能的，有单击和长按连_发的功能，但此时单击的响应要慢点了。
        如何处理这个矛盾？ 
        这个也简单呀。你写2套低层的驱动，一套就是扫描按键的按下，马上响应，另一套是需要等待的。然后增加一个状态判断，如果是上层在查询时间方式，那么使用前一套扫描按键，反映肯定快，如果上层在设置时间方式，就使用第2套扫描按键，此时单击响应要慢一点。这样不就平衡了吗？  

[cpp]  view plain copy

1. <p><strong>下面一个微小改动（见60楼），实现无键、单击、长键立即响应：</strong></p><p></p><pre name="code" class="cpp">“请问马老师，如何用2套底层驱动切换的方式实现类似windows资源管理器对鼠标单双击功能呢？” </pre>  
2. <pre></pre>  
3. <p></p>  
4. <p></p>  
5. <pre name="code" class="cpp">=======================================================  
6. 还是在LZ位的代码上改动，实现“类似windows资源管理器对鼠标单双击功能”  
7.   
8. unsigned char key_read(void)    
9. {    
10.     static unsigned char key_m = key_state_0, key_time_1 = 0;    
11.     unsigned char key_return = N_key,key_temp;    
12.         
13.     key_temp = key_driver();    
14.         
15.     switch(key_m)    
16.     {    
17.         case key_state_0:    
18.             if (key_temp == S_key )    
19.             {    
20.                  key_time_1 = 0;               // 第1次单击，返回事件，并到下个状态判断后面是否出现双击    
21.                  key_m = key_state_1;    
22.             }    
23.             key_return = key_temp;            // 对于无键、单击、长键，返回原事件，都是马上响应    
24.             break;    
25.   
26.         case key_state_1:    
27.             if (key_temp == S_key)             // 又一次单击（间隔肯定<500ms）    
28.             {    
29.                  key_return = D_key;           // 返回双击键事件，回初始状态    
30.                  key_m = key_state_0;    
31.             }    
32.             else                                   
33.             {                        // 这里500ms内肯定读到的都是无键事件，因为长键>1000ms，在1s前低层返回的都是无键    
34.                  if(++key_time_1 >= 50)    
35.                  {    
36.                       key_m = key_state_0;     // 超过500ms，不可能有双击出现，返回初始状态    
37.                  }    
38.              }    
39.              break;    
40.     }   
41.     return key_return;    
42. }</pre><br>