开场白：
上一节讲了矩阵键盘单个触发的压缩代码编程。这节讲矩阵键盘的组合按键触发。要教会大家三个知识点：
第一点：如何把矩阵键盘翻译成独立按盘的处理方式。然后按独立按键的方式来实现组合按键的功能。
第二点：要提醒大家在设计矩阵键盘时，很容易犯的一个错误。任意两个组合按键不能处于同一行，否则触发性能大打折扣。在做产品的时候，硬件电路设计中，除了四路行输入的要加上拉电阻，四路列输出也应该串入一个470欧左右的限流电阻，否则当同一行的两个按键同时按下时，很容易烧坏单片机IO口。为什么？大家仔细想想原因。因为如果没有限流电阻，同一行的两个按键同时按下时，在某一瞬间，输出的两路高低电平将会直接短接在一起，引起短路。在朱兆祺的学习板中，S1至S4是同一行，S5至S8是同一行，S9至S12是同一行，S13至S16是同一行。
第三点：在鸿哥矩阵键盘的组合按键处理程序中，组合按键的去抖动延时const_key_time_comb千万不能等于单击按键的去抖动延时const_key_time，否则组合按键会覆盖单击按键的触发。

具体内容，请看源代码讲解。

（1）硬件平台：基于朱兆祺51单片机学习板。

（2）实现功能：16个按键中，每按一个按键都能触发一次蜂鸣器发出“滴”的一声。在同时按下S1和S16按键时，将会点亮一个LED灯。在同时按下S4和S13按键时，将会熄灭一个LED灯。

（3）源代码讲解如下：

1. #include "REG52.H"  
2.   
3. #define const_voice_short  40   //蜂鸣器短叫的持续时间  
4.   
5.   
6. /* 注释一： 
7. *  注意：组合按键的去抖动延时const_key_time_comb千万不能等于单击按键 
8. *  的去抖动延时const_key_time，否则组合按键会覆盖单击按键的触发。 
9. */  
10. #define const_key_time  12    //按键去抖动延时的时间  
11. #define const_key_time_comb  14    //组合按键去抖动延时的时间  
12.   
13. void initial_myself();      
14. void initial_peripheral();  
15. void delay_long(unsigned int uiDelaylong);  
16. void T0_time();  //定时中断函数  
17. void key_service(); //按键服务的应用程序  
18. void key_scan(); //按键扫描函数 放在定时中断里  
19.   
20. /* 注释二： 
21. *  注意：任意两个组合按键不能处于同一行，否则触发性能大打折扣。 
22. *  在做产品的时候，硬件电路设计中，除了四路行输入的要加上拉电阻， 
23. *  四路列输出也应该串入一个470欧左右的限流电阻，否则当同一行的两个 
24. *  按键同时按下时，很容易烧坏单片机IO口。为什么？大家仔细想想原因。 
25. *  因为如果没有限流电阻，同一行的两个按键同时按下时，在某一瞬间， 
26. *  输出的两路高低电平将会直接短接在一起，引起短路。 
27. *  在朱兆祺的学习板中，S1至S4是同一行，S5至S8是同一行，S9至S12是同一行，S13至S16是同一行。 
28. */  
29. sbit key_sr1=P0^0; //第一行输入  
30. sbit key_sr2=P0^1; //第二行输入  
31. sbit key_sr3=P0^2; //第三行输入  
32. sbit key_sr4=P0^3; //第四行输入  
33.   
34. sbit key_dr1=P0^4; //第一列输出  
35. sbit key_dr2=P0^5; //第二列输出  
36. sbit key_dr3=P0^6; //第三列输出  
37. sbit key_dr4=P0^7; //第四列输出  
38.   
39. sbit led_dr=P3^5;  //LED灯的输出  
40.   
41. sbit beep_dr=P2^7; //蜂鸣器的驱动IO口  
42.   
43. unsigned char ucKeyStep=1;  //按键扫描步骤变量  
44.   
45. unsigned char ucKeySec=0;   //被触发的按键编号  
46.   
47. unsigned int  uiKeyTimeCnt[16]=0; //16个按键去抖动延时计数器  
48. unsigned char ucKeyLock[16]=0; //16个按键触发后自锁的变量标志  
49.   
50. unsigned int  uiKeyTimeCnt_01_16=0; //S1和S16组合按键去抖动延时计数器  
51. unsigned char ucKeyLock_01_16=0; //S1和S16组合按键触发后自锁的变量标志  
52.   
53. unsigned int  uiKeyTimeCnt_04_13=0; //S4和S13组合按键去抖动延时计数器  
54. unsigned char ucKeyLock_04_13=0; //S4和S13组合按键触发后自锁的变量标志  
55.   
56. unsigned char ucRowRecord=1; //记录当前扫描到第几列了  
57.   
58. unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器  
59.   
60. unsigned int  uiKeyStatus=0xffff;  //此变量每一位代表一个按键的状态，共16个按键。1代表没有被按下，0代表被按下。  
61.   
62. void main()   
63.   {  
64.    initial_myself();    
65.    delay_long(100);     
66.    initial_peripheral();   
67.    while(1)    
68.    {   
69.        key_service(); //按键服务的应用程序  
70.    }  
71.   
72. }  
73.   
74. void key_scan()//按键扫描函数 放在定时中断里  
75. {    
76. /* 注释三： 
77. *  第一步：先把16个按键翻译成独立按键。 
78. *  第二步: 再按独立按键的去抖动方式进行按键识别。 
79. *  第三步: 本程序把矩阵键盘翻译成独立按键的处理方式后，大家可以按独立按键的方式 
80. *          来实现组合按键，双击，长按和短按，按住连续触发等功能。 
81. *          我本人不再详细介绍这方面的内容。有兴趣的朋友，可以参考一下我前面章节讲的独立按键。 
82. */  
83.   
84.   switch(ucKeyStep)  
85.   {  
86.      case 1:   //把16个按键的状态快速记录在uiKeyStatus变量的每一位中,相当于把矩阵键盘翻译成独立按键。  
87.               for(ucRowRecord=1;ucRowRecord<5;ucRowRecord++)  
88.                     {  
89.                  if(ucRowRecord==1)  //第一列输出低电平  
90.                      {  
91.                key_dr1=0;        
92.                key_dr2=1;  
93.                key_dr3=1;      
94.                key_dr4=1;  
95.                 //如果是薄膜按键或者走线比较长的按键，此处应该加几个空延时，等待列输出信号稳定再判断输入的状态  
96.                        if(key_sr1==0)  
97.                            {  
98.                               uiKeyStatus=uiKeyStatus&0xfffe; //对应朱兆祺学习板的S1键被按下  
99.                            }  
100.                        if(key_sr2==0)  
101.                            {  
102.                               uiKeyStatus=uiKeyStatus&0xffef; //对应朱兆祺学习板的S5键被按下  
103.                            }  
104.                        if(key_sr3==0)  
105.                            {  
106.                               uiKeyStatus=uiKeyStatus&0xfeff; //对应朱兆祺学习板的S9键被按下  
107.                            }  
108.                        if(key_sr4==0)  
109.                            {  
110.                               uiKeyStatus=uiKeyStatus&0xefff; //对应朱兆祺学习板的S13键被按下  
111.                            }  
112.                      }  
113.                  else if(ucRowRecord==2)  //第二列输出低电平  
114.                      {  
115.                 key_dr1=1;        
116.                 key_dr2=0;  
117.                 key_dr3=1;      
118.                 key_dr4=1;  
119.                 //如果是薄膜按键或者走线比较长的按键，此处应该加几个空延时，等待列输出信号稳定再判断输入的状态  
120.                         if(key_sr1==0)  
121.                               {  
122.                               uiKeyStatus=uiKeyStatus&0xfffd; //对应朱兆祺学习板的S2键被按下  
123.                              }  
124.                         if(key_sr2==0)  
125.                             {  
126.                               uiKeyStatus=uiKeyStatus&0xffdf; //对应朱兆祺学习板的S6键被按下  
127.                             }  
128.                         if(key_sr3==0)  
129.                             {  
130.                                uiKeyStatus=uiKeyStatus&0xfdff; //对应朱兆祺学习板的S10键被按下   
131.                             }  
132.                         if(key_sr4==0)  
133.                             {  
134.                                uiKeyStatus=uiKeyStatus&0xdfff; //对应朱兆祺学习板的S14键被按下  
135.                               }  
136.                      }  
137.                  else if(ucRowRecord==3)  //第三列输出低电平  
138.                      {  
139.                 key_dr1=1;        
140.                 key_dr2=1;  
141.                 key_dr3=0;      
142.                 key_dr4=1;  
143.                  //如果是薄膜按键或者走线比较长的按键，此处应该加几个空延时，等待列输出信号稳定再判断输入的状态  
144.                         if(key_sr1==0)  
145.                             {  
146.                                uiKeyStatus=uiKeyStatus&0xfffb; //对应朱兆祺学习板的S3键被按下  
147.                             }  
148.                         if(key_sr2==0)  
149.                             {  
150.                                uiKeyStatus=uiKeyStatus&0xffbf; //对应朱兆祺学习板的S7键被按下  
151.                             }  
152.                         if(key_sr3==0)  
153.                             {  
154.                                uiKeyStatus=uiKeyStatus&0xfbff; //对应朱兆祺学习板的S11键被按下   
155.                               }  
156.                         if(key_sr4==0)  
157.                             {  
158.                                uiKeyStatus=uiKeyStatus&0xbfff; //对应朱兆祺学习板的S15键被按下  
159.                             }  
160.                      }  
161.                  else   //第四列输出低电平  
162.                      {  
163.                 key_dr1=1;        
164.                 key_dr2=1;  
165.                 key_dr3=1;      
166.                 key_dr4=0;  
167.                  //如果是薄膜按键或者走线比较长的按键，此处应该加几个空延时，等待列输出信号稳定再判断输入的状态  
168.                         if(key_sr1==0)  
169.                              {  
170.                                uiKeyStatus=uiKeyStatus&0xfff7; //对应朱兆祺学习板的S4键被按下  
171.                             }  
172.                         if(key_sr2==0)  
173.                             {  
174.                                uiKeyStatus=uiKeyStatus&0xff7f; //对应朱兆祺学习板的S8键被按下  
175.                             }  
176.                         if(key_sr3==0)  
177.                             {  
178.                                uiKeyStatus=uiKeyStatus&0xf7ff; //对应朱兆祺学习板的S12键被按下   
179.                             }  
180.                         if(key_sr4==0)  
181.                             {  
182.                                uiKeyStatus=uiKeyStatus&0x7fff; //对应朱兆祺学习板的S16键被按下  
183.                             }  
184.                      }  
185.           }  
186.   
187.           ucKeyStep=2;     //切换到下一个运行步骤  
188.               break;  
189.   
190.      case 2:  //像独立按键一样进行去抖动和翻译。以下代码相似度很高，大家有兴趣的话还可以加for循环来压缩代码  
191.               if((uiKeyStatus&0x0001)==0x0001)  //说明1号键没有被按下来  
192.                   {  
193.              uiKeyTimeCnt[0]=0;  
194.              ucKeyLock[0]=0;  
195.                   }  
196.                   else if(ucKeyLock[0]==0)  
197.                   {  
198.                      uiKeyTimeCnt[0]++;  
199.                          if(uiKeyTimeCnt[0]>const_key_time)  
200.                          {  
201.                             uiKeyTimeCnt[0]=0;  
202.                             ucKeyLock[0]=1; //自锁按键，防止不断触发  
203.                             ucKeySec=1;   //被触发1号键  
204.                          }  
205.                   }  
206.   
207.               if((uiKeyStatus&0x0002)==0x0002)  //说明2号键没有被按下来  
208.                   {  
209.              uiKeyTimeCnt[1]=0;  
210.              ucKeyLock[1]=0;  
211.                   }  
212.                   else if(ucKeyLock[1]==0)  
213.                   {  
214.                      uiKeyTimeCnt[1]++;  
215.                          if(uiKeyTimeCnt[1]>const_key_time)  
216.                          {  
217.                             uiKeyTimeCnt[1]=0;  
218.                             ucKeyLock[1]=1; //自锁按键，防止不断触发  
219.                             ucKeySec=2;   //被触发2号键  
220.                          }  
221.                   }  
222.   
223.               if((uiKeyStatus&0x0004)==0x0004)  //说明3号键没有被按下来  
224.                   {  
225.              uiKeyTimeCnt[2]=0;  
226.              ucKeyLock[2]=0;  
227.                   }  
228.                   else if(ucKeyLock[2]==0)  
229.                   {  
230.                      uiKeyTimeCnt[2]++;  
231.                          if(uiKeyTimeCnt[2]>const_key_time)  
232.                          {  
233.                             uiKeyTimeCnt[2]=0;  
234.                             ucKeyLock[2]=1; //自锁按键，防止不断触发  
235.                             ucKeySec=3;   //被触发3号键  
236.                          }  
237.                   }  
238.   
239.               if((uiKeyStatus&0x0008)==0x0008)  //说明4号键没有被按下来  
240.                   {  
241.              uiKeyTimeCnt[3]=0;  
242.              ucKeyLock[3]=0;  
243.                   }  
244.                   else if(ucKeyLock[3]==0)  
245.                   {  
246.                      uiKeyTimeCnt[3]++;  
247.                          if(uiKeyTimeCnt[3]>const_key_time)  
248.                          {  
249.                             uiKeyTimeCnt[3]=0;  
250.                             ucKeyLock[3]=1; //自锁按键，防止不断触发  
251.                             ucKeySec=4;   //被触发4号键  
252.                          }  
253.                   }  
254.   
255.               if((uiKeyStatus&0x0010)==0x0010)  //说明5号键没有被按下来  
256.                   {  
257.              uiKeyTimeCnt[4]=0;  
258.              ucKeyLock[4]=0;  
259.                   }  
260.                   else if(ucKeyLock[4]==0)  
261.                   {  
262.                      uiKeyTimeCnt[4]++;  
263.                          if(uiKeyTimeCnt[4]>const_key_time)  
264.                          {  
265.                             uiKeyTimeCnt[4]=0;  
266.                             ucKeyLock[4]=1; //自锁按键，防止不断触发  
267.                             ucKeySec=5;   //被触发5号键  
268.                          }  
269.                   }  
270.   
271.               if((uiKeyStatus&0x0020)==0x0020)  //说明6号键没有被按下来  
272.                   {  
273.              uiKeyTimeCnt[5]=0;  
274.              ucKeyLock[5]=0;  
275.                   }  
276.                   else if(ucKeyLock[5]==0)  
277.                   {  
278.                      uiKeyTimeCnt[5]++;  
279.                          if(uiKeyTimeCnt[5]>const_key_time)  
280.                          {  
281.                             uiKeyTimeCnt[5]=0;  
282.                             ucKeyLock[5]=1; //自锁按键，防止不断触发  
283.                             ucKeySec=6;   //被触发6号键  
284.                          }  
285.                   }  
286.   
287.               if((uiKeyStatus&0x0040)==0x0040)  //说明7号键没有被按下来  
288.                   {  
289.              uiKeyTimeCnt[6]=0;  
290.              ucKeyLock[6]=0;  
291.                   }  
292.                   else if(ucKeyLock[6]==0)  
293.                   {  
294.                      uiKeyTimeCnt[6]++;  
295.                          if(uiKeyTimeCnt[6]>const_key_time)  
296.                          {  
297.                             uiKeyTimeCnt[6]=0;  
298.                             ucKeyLock[6]=1; //自锁按键，防止不断触发  
299.                             ucKeySec=7;   //被触发7号键  
300.                          }  
301.                   }  
302.   
303.               if((uiKeyStatus&0x0080)==0x0080)  //说明8号键没有被按下来  
304.                   {  
305.              uiKeyTimeCnt[7]=0;  
306.              ucKeyLock[7]=0;  
307.                   }  
308.                   else if(ucKeyLock[7]==0)  
309.                   {  
310.                      uiKeyTimeCnt[7]++;  
311.                          if(uiKeyTimeCnt[7]>const_key_time)  
312.                          {  
313.                             uiKeyTimeCnt[7]=0;  
314.                             ucKeyLock[7]=1; //自锁按键，防止不断触发  
315.                             ucKeySec=8;   //被触发8号键  
316.                          }  
317.                   }  
318.   
319.               if((uiKeyStatus&0x0100)==0x0100)  //说明9号键没有被按下来  
320.                   {  
321.              uiKeyTimeCnt[8]=0;  
322.              ucKeyLock[8]=0;  
323.                   }  
324.                   else if(ucKeyLock[8]==0)  
325.                   {  
326.                      uiKeyTimeCnt[8]++;  
327.                          if(uiKeyTimeCnt[8]>const_key_time)  
328.                          {  
329.                             uiKeyTimeCnt[8]=0;  
330.                             ucKeyLock[8]=1; //自锁按键，防止不断触发  
331.                             ucKeySec=9;   //被触发9号键  
332.                          }  
333.                   }  
334.   
335.              

（中http://www.eeskill.com/group/topic_scan/id/491）

（下http://www.eeskill.com/group/topic_scan/id/492）