原文链接：第十六节：矩阵键盘的组合按键触发。
原文
第十六节：矩阵键盘的组合按键触发。
开场白：
上一节讲了矩阵键盘单个触发的压缩代码编程。这节讲矩阵键盘的组合按键触发。要教会大家三个知识点：
第一点：如何把矩阵键盘翻译成独立按盘的处理方式。然后按独立按键的方式来实现组合按键的功能。
第二点：要提醒大家在设计矩阵键盘时，很容易犯的一个错误。任意两个组合按键不能处于同一行，否则触发性能大打折扣。在做产品的时候，硬件电路设计中，除了四路行输入的要加上拉电阻，四路列输出也应该串入一个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）源代码讲解如下：
#include "REG52.H"
#define const_voice_short 40 //蜂鸣器短叫的持续时间
/* 注释一：
* 注意：组合按键的去抖动延时const_key_time_comb千万不能等于单击按键
* 的去抖动延时const_key_time，否则组合按键会覆盖单击按键的触发。
*/
#define const_key_time 12 //按键去抖动延时的时间
#define const_key_time_comb 14 //组合按键去抖动延时的时间
void initial_myself();
void initial_peripheral();
void delay_long(unsigned int uiDelaylong);
void T0_time(); //定时中断函数
void key_service(); //按键服务的应用程序
void key_scan(); //按键扫描函数 放在定时中断里
/* 注释二：
* 注意：任意两个组合按键不能处于同一行，否则触发性能大打折扣。
* 在做产品的时候，硬件电路设计中，除了四路行输入的要加上拉电阻，
* 四路列输出也应该串入一个470欧左右的限流电阻，否则当同一行的两个
* 按键同时按下时，很容易烧坏单片机IO口。为什么？大家仔细想想原因。
* 因为如果没有限流电阻，同一行的两个按键同时按下时，在某一瞬间，
* 输出的两路高低电平将会直接短接在一起，引起短路。
* 在朱兆祺的学习板中，S1至S4是同一行，S5至S8是同一行，S9至S12是同一行，S13至S16是同一行。
*/
sbit key_sr1=P0^0; //第一行输入
sbit key_sr2=P0^1; //第二行输入
sbit key_sr3=P0^2; //第三行输入
sbit key_sr4=P0^3; //第四行输入
sbit key_dr1=P0^4; //第一列输出
sbit key_dr2=P0^5; //第二列输出
sbit key_dr3=P0^6; //第三列输出
sbit key_dr4=P0^7; //第四列输出
sbit led_dr=P3^5; //LED灯的输出
sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
unsigned char ucKeyStep=1; //按键扫描步骤变量
unsigned char ucKeySec=0; //被触发的按键编号
unsigned int uiKeyTimeCnt[16]=0; //16个按键去抖动延时计数器
unsigned char ucKeyLock[16]=0; //16个按键触发后自锁的变量标志
unsigned int uiKeyTimeCnt_01_16=0; //S1和S16组合按键去抖动延时计数器
unsigned char ucKeyLock_01_16=0; //S1和S16组合按键触发后自锁的变量标志
unsigned int uiKeyTimeCnt_04_13=0; //S4和S13组合按键去抖动延时计数器
unsigned char ucKeyLock_04_13=0; //S4和S13组合按键触发后自锁的变量标志
unsigned char ucRowRecord=1; //记录当前扫描到第几列了
unsigned int uiVoiceCnt=0; //蜂鸣器鸣叫的持续时间计数器
unsigned int uiKeyStatus=0xffff; //此变量每一位代表一个按键的状态，共16个按键。1代表没有被按下，0代表被按下。
void main()
{
initial_myself();
delay_long(100);
initial_peripheral();
while(1)
{
key_service(); //按键服务的应用程序
}
}
void key_scan()//按键扫描函数 放在定时中断里
{
/* 注释三：
* 第一步：先把16个按键翻译成独立按键。
* 第二步: 再按独立按键的去抖动方式进行按键识别。
* 第三步: 本程序把矩阵键盘翻译成独立按键的处理方式后，大家可以按独立按键的方式
* 来实现组合按键，双击，长按和短按，按住连续触发等功能。
* 我本人不再详细介绍这方面的内容。有兴趣的朋友，可以参考一下我前面章节讲的独立按键。
*/
switch(ucKeyStep)
{
case 1: //把16个按键的状态快速记录在uiKeyStatus变量的每一位中,相当于把矩阵键盘翻译成独立按键。
for(ucRowRecord=1;ucRowRecord<5;ucRowRecord++)
{
if(ucRowRecord==1) //第一列输出低电平
{
key_dr1=0;
key_dr2=1;
key_dr3=1;
key_dr4=1;
//如果是薄膜按键或者走线比较长的按键，此处应该加几个空延时，等待列输出信号稳定再判断输入的状态
if(key_sr1==0)
{
uiKeyStatus=uiKeyStatus&0xfffe; //对应朱兆祺学习板的S1键被按下
}
if(key_sr2==0)
{
uiKeyStatus=uiKeyStatus&0xffef; //对应朱兆祺学习板的S5键被按下
}
if(key_sr3==0)
{
uiKeyStatus=uiKeyStatus&0xfeff; //对应朱兆祺学习板的S9键被按下
}
if(key_sr4==0)
{
uiKeyStatus=uiKeyStatus&0xefff; //对应朱兆祺学习板的S13键被按下
}
}
else if(ucRowRecord==2) //第二列输出低电平
{
key_dr1=1;
key_dr2=0;
key_dr3=1;
key_dr4=1;
//如果是薄膜按键或者走线比较长的按键，此处应该加几个空延时，等待列输出信号稳定再判断输入的状态
if(key_sr1==0)
{
uiKeyStatus=uiKeyStatus&0xfffd; //对应朱兆祺学习板的S2键被按下
}
if(key_sr2==0)
{
uiKeyStatus=uiKeyStatus&0xffdf; //对应朱兆祺学习板的S6键被按下
}
if(key_sr3==0)
{
uiKeyStatus=uiKeyStatus&0xfdff; //对应朱兆祺学习板的S10键被按下
}
if(key_sr4==0)
{
uiKeyStatus=uiKeyStatus&0xdfff; //对应朱兆祺学习板的S14键被按下
}
}
else if(ucRowRecord==3) //第三列输出低电平
{
key_dr1=1;
key_dr2=1;
key_dr3=0;
key_dr4=1;
//如果是薄膜按键或者走线比较长的按键，此处应该加几个空延时，等待列输出信号稳定再判断输入的状态
if(key_sr1==0)
{
uiKeyStatus=uiKeyStatus&0xfffb; //对应朱兆祺学习板的S3键被按下
}
if(key_sr2==0)
{
uiKeyStatus=uiKeyStatus&0xffbf; //对应朱兆祺学习板的S7键被按下
}
if(key_sr3==0)
{
uiKeyStatus=uiKeyStatus&0xfbff; //对应朱兆祺学习板的S11键被按下
}
if(key_sr4==0)
{
uiKeyStatus=uiKeyStatus&0xbfff; //对应朱兆祺学习板的S15键被按下
}
}
else //第四列输出低电平
{
key_dr1=1;
key_dr2=1;
key_dr3=1;
key_dr4=0;
//如果是薄膜按键或者走线比较长的按键，此处应该加几个空延时，等待列输出信号稳定再判断输入的状态
if(key_sr1==0)
{
uiKeyStatus=uiKeyStatus&0xfff7; //对应朱兆祺学习板的S4键被按下
}
if(key_sr2==0)
{
uiKeyStatus=uiKeyStatus&0xff7f; //对应朱兆祺学习板的S8键被按下
}
if(key_sr3==0)
{
uiKeyStatus=uiKeyStatus&0xf7ff; //对应朱兆祺学习板的S12键被按下
}
if(key_sr4==0)
{
uiKeyStatus=uiKeyStatus&0x7fff; //对应朱兆祺学习板的S16键被按下
}
}
}
ucKeyStep=2; //切换到下一个运行步骤
break;
case 2: //像独立按键一样进行去抖动和翻译。以下代码相似度很高，大家有兴趣的话还可以加for循环来压缩代码
if((uiKeyStatus&0x0001)==0x0001) //说明1号键没有被按下来
{
uiKeyTimeCnt[0]=0;
ucKeyLock[0]=0;
}
else if(ucKeyLock[0]==0)
{
uiKeyTimeCnt[0]++;
if(uiKeyTimeCnt[0]>const_key_time)
{
uiKeyTimeCnt[0]=0;
ucKeyLock[0]=1; //自锁按键，防止不断触发
ucKeySec=1; //被触发1号键
}
}
if((uiKeyStatus&0x0002)==0x0002) //说明2号键没有被按下来
{
uiKeyTimeCnt[1]=0;
ucKeyLock[1]=0;
}
else if(ucKeyLock[1]==0)
{
uiKeyTimeCnt[1]++;
if(uiKeyTimeCnt[1]>const_key_time)
{
uiKeyTimeCnt[1]=0;
ucKeyLock[1]=1; //自锁按键，防止不断触发
ucKeySec=2; //被触发2号键
}
}
if((uiKeyStatus&0x0004)==0x0004) //说明3号键没有被按下来
{
uiKeyTimeCnt[2]=0;
ucKeyLock[2]=0;
}
else if(ucKeyLock[2]==0)
{
uiKeyTimeCnt[2]++;
if(uiKeyTimeCnt[2]>const_key_time)
{
uiKeyTimeCnt[2]=0;
ucKeyLock[2]=1; //自锁按键，防止不断触发
ucKeySec=3; //被触发3号键
}
}
if((uiKeyStatus&0x0008)==0x0008) //说明4号键没有被按下来
{
uiKeyTimeCnt[3]=0;
ucKeyLock[3]=0;
}
else if(ucKeyLock[3]==0)
{
uiKeyTimeCnt[3]++;
if(uiKeyTimeCnt[3]>const_key_time)
{
uiKeyTimeCnt[3]=0;
ucKeyLock[3]=1; //自锁按键，防止不断触发
ucKeySec=4; //被触发4号键
}
}
if((uiKeyStatus&0x0010)==0x0010) //说明5号键没有被按下来
{
uiKeyTimeCnt[4]=0;
ucKeyLock[4]=0;
}
else if(ucKeyLock[4]==0)
{
uiKeyTimeCnt[4]++;
if(uiKeyTimeCnt[4]>const_key_time)
{
uiKeyTimeCnt[4]=0;
ucKeyLock[4]=1; //自锁按键，防止不断触发
ucKeySec=5; //被触发5号键
}
}
if((uiKeyStatus&0x0020)==0x0020) //说明6号键没有被按下来
{
uiKeyTimeCnt[5]=0;
ucKeyLock[5]=0;
}
else if(ucKeyLock[5]==0)
{
uiKeyTimeCnt[5]++;
if(uiKeyTimeCnt[5]>const_key_time)
{
uiKeyTimeCnt[5]=0;
ucKeyLock[5]=1; //自锁按键，防止不断触发
ucKeySec=6; //被触发6号键
}
}
if((uiKeyStatus&0x0040)==0x0040) //说明7号键没有被按下来
{
uiKeyTimeCnt[6]=0;
ucKeyLock[6]=0;
}
else if(ucKeyLock[6]==0)
{
uiKeyTimeCnt[6]++;
if(uiKeyTimeCnt[6]>const_key_time)
{
uiKeyTimeCnt[6]=0;
ucKeyLock[6]=1; //自锁按键，防止不断触发
ucKeySec=7; //被触发7号键
}
}
if((uiKeyStatus&0x0080)==0x0080) //说明8号键没有被按下来
{
uiKeyTimeCnt[7]=0;
ucKeyLock[7]=0;
}
else if(ucKeyLock[7]==0)
{
uiKeyTimeCnt[7]++;
if(uiKeyTimeCnt[7]>const_key_time)
{
uiKeyTimeCnt[7]=0;
ucKeyLock[7]=1; //自锁按键，防止不断触发
ucKeySec=8; //被触发8号键
}
}
if((uiKeyStatus&0x0100)==0x0100) //说明9号键没有被按下来
{
uiKeyTimeCnt[8]=0;
ucKeyLock[8]=0;
}
else if(ucKeyLock[8]==0)
{
uiKeyTimeCnt[8]++;
if(uiKeyTimeCnt[8]>const_key_time)
{
uiKeyTimeCnt[8]=0;
ucKeyLock[8]=1; //自锁按键，防止不断触发
ucKeySec=9; //被触发9号键
}
}
if((uiKeyStatus&0x0200)==0x0200) //说明10号键没有被按下来
{
uiKeyTimeCnt[9]=0;
ucKeyLock[9]=0;
}
else if(ucKeyLock[9]==0)
{
uiKeyTimeCnt[9]++;
if(uiKeyTimeCnt[9]>const_key_time)
{
uiKeyTimeCnt[9]=0;
ucKeyLock[9]=1; //自锁按键，防止不断触发
ucKeySec=10; //被触发10号键
}
}
if((uiKeyStatus&0x0400)==0x0400) //说明11号键没有被按下来
{
uiKeyTimeCnt[10]=0;
ucKeyLock[10]=0;
}
else if(ucKeyLock[10]==0)
{
uiKeyTimeCnt[10]++;
if(uiKeyTimeCnt[10]>const_key_time)
{
uiKeyTimeCnt[10]=0;
ucKeyLock[10]=1; //自锁按键，防止不断触发
ucKeySec=11; //被触发11号键
}
}
if((uiKeyStatus&0x0800)==0x0800) //说明12号键没有被按下来
{
uiKeyTimeCnt[11]=0;
ucKeyLock[11]=0;
}
else if(ucKeyLock[11]==0)
{
uiKeyTimeCnt[11]++;
if(uiKeyTimeCnt[11]>const_key_time)
{
uiKeyTimeCnt[11]=0;
ucKeyLock[11]=1; //自锁按键，防止不断触发
ucKeySec=12; //被触发12号键
}
}
if((uiKeyStatus&0x0800)==0x0800) //说明12号键没有被按下来
{
uiKeyTimeCnt[11]=0;
ucKeyLock[11]=0;
}
else if(ucKeyLock[11]==0)
{
uiKeyTimeCnt[11]++;
if(uiKeyTimeCnt[11]>const_key_time)
{
uiKeyTimeCnt[11]=0;
ucKeyLock[11]=1; //自锁按键，防止不断触发
ucKeySec=12; //被触发12号键
}
}
if((uiKeyStatus&0x1000)==0x1000) //说明13号键没有被按下来
{
uiKeyTimeCnt[12]=0;
ucKeyLock[12]=0;
}
else if(ucKeyLock[12]==0)
{
uiKeyTimeCnt[12]++;
if(uiKeyTimeCnt[12]>const_key_time)
{
uiKeyTimeCnt[12]=0;
ucKeyLock[12]=1; //自锁按键，防止不断触发
ucKeySec=13; //被触发13号键
}
}
if((uiKeyStatus&0x2000)==0x2000) //说明14号键没有被按下来
{
uiKeyTimeCnt[13]=0;
ucKeyLock[13]=0;
}
else if(ucKeyLock[13]==0)
{
uiKeyTimeCnt[13]++;
if(uiKeyTimeCnt[13]>const_key_time)
{
uiKeyTimeCnt[13]=0;
ucKeyLock[13]=1; //自锁按键，防止不断触发
ucKeySec=14; //被触发14号键
}
}
if((uiKeyStatus&0x4000)==0x4000) //说明15号键没有被按下来
{
uiKeyTimeCnt[14]=0;
ucKeyLock[14]=0;
}
else if(ucKeyLock[14]==0)
{
uiKeyTimeCnt[14]++;
if(uiKeyTimeCnt[14]>const_key_time)
{
uiKeyTimeCnt[14]=0;
ucKeyLock[14]=1; //自锁按键，防止不断触发
ucKeySec=15; //被触发15号键
}
}
if((uiKeyStatus&0x8000)==0x8000) //说明16号键没有被按下来
{
uiKeyTimeCnt[15]=0;
ucKeyLock[15]=0;
}
else if(ucKeyLock[15]==0)
{
uiKeyTimeCnt[15]++;
if(uiKeyTimeCnt[15]>const_key_time)
{
uiKeyTimeCnt[15]=0;
ucKeyLock[15]=1; //自锁按键，防止不断触发
ucKeySec=16; //被触发16号键
}
}
if((uiKeyStatus&0x8001)==0x0000) //S1和S16的组合键盘被按下。
{
if(ucKeyLock_01_16==0)
{
uiKeyTimeCnt_01_16++;
if(uiKeyTimeCnt_01_16>const_key_time_comb)
{
uiKeyTimeCnt_01_16=0;
ucKeyLock_01_16=1;
ucKeySec=17; //被触发17号组合键
}
}
}
else
{
uiKeyTimeCnt_01_16=0; //S1和S16组合按键去抖动延时计数器
ucKeyLock_01_16=0; //S1和S16组合按键触发后自锁的变量标志
}
if((uiKeyStatus&0x1008)==0x0000) //S4和S13的组合键盘被按下。
{
if(ucKeyLock_04_13==0)
{
uiKeyTimeCnt_04_13++;
if(uiKeyTimeCnt_04_13>const_key_time_comb)
{
uiKeyTimeCnt_04_13=0;
ucKeyLock_04_13=1;
ucKeySec=18; //被触发18号组合键
}
}
}
else
{
uiKeyTimeCnt_04_13=0; //S4和S13组合按键去抖动延时计数器
ucKeyLock_04_13=0; //S4和S13组合按键触发后自锁的变量标志
}
uiKeyStatus=0xffff; //及时恢复状态，方便下一次扫描
ucKeyStep=1; //返回到第一个运行步骤重新开始扫描
break;
}
}
void key_service() //第三区 按键服务的应用程序
{
switch(ucKeySec) //按键服务状态切换
{
case 1:// 1号键 对应朱兆祺学习板的S1键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 2:// 2号键 对应朱兆祺学习板的S2键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 3:// 3号键 对应朱兆祺学习板的S3键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 4:// 4号键 对应朱兆祺学习板的S4键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 5:// 5号键 对应朱兆祺学习板的S5键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 6:// 6号键 对应朱兆祺学习板的S6键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 7:// 7号键 对应朱兆祺学习板的S7键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 8:// 8号键 对应朱兆祺学习板的S8键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 9:// 9号键 对应朱兆祺学习板的S9键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 10:// 10号键 对应朱兆祺学习板的S10键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 11:// 11号键 对应朱兆祺学习板的S11键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 12:// 12号键 对应朱兆祺学习板的S12键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 13:// 13号键 对应朱兆祺学习板的S13键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 14:// 14号键 对应朱兆祺学习板的S14键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 15:// 15号键 对应朱兆祺学习板的S15键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 16:// 16号键 对应朱兆祺学习板的S16键
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 17:// 17号组合键 对应朱兆祺学习板的S1和S16键的组合按键
led_dr=1; //LED灯亮
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 18:// 18号组合键 对应朱兆祺学习板的S4和S13键的组合按键
led_dr=0; //LED灯灭
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
}
}
void T0_time() interrupt 1
{
TF0=0; //清除中断标志
TR0=0; //关中断
key_scan(); //按键扫描函数
if(uiVoiceCnt!=0)
{
uiVoiceCnt--; //每次进入定时中断都自减1，直到等于零为止。才停止鸣叫
beep_dr=0; //蜂鸣器是PNP三极管控制，低电平就开始鸣叫。
}
else
{
; //此处多加一个空指令，想维持跟if括号语句的数量对称，都是两条指令。不加也可以。
beep_dr=1; //蜂鸣器是PNP三极管控制，高电平就停止鸣叫。
}
TH0=0xf8; //重装初始值(65535-2000)=63535=0xf82f
TL0=0x2f;
TR0=1; //开中断
}
void delay_long(unsigned int uiDelayLong)
{
unsigned int i;
unsigned int j;
for(i=0;i<uiDelayLong;i++)
{
for(j=0;j<500;j++) //内嵌循环的空指令数量
{
; //一个分号相当于执行一条空语句
}
}
}
void initial_myself() //第一区 初始化单片机
{
led_dr=0; //LED灯灭
beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。
TMOD=0x01; //设置定时器0为工作方式1
TH0=0xf8; //重装初始值(65535-2000)=63535=0xf82f
TL0=0x2f;
}
void initial_peripheral() //第二区 初始化外围
{
EA=1; //开总中断
ET0=1; //允许定时中断
TR0=1; //启动定时中断
}
总结陈词：
这节讲了如何把矩阵键盘翻译成独立按键的处理方式，然后像独立按键一样实现组合按键的功能，关于矩阵按键的双击，长按和短按，按键连续触发等功能我不再详细介绍，有兴趣的朋友可以参考我前面章节讲的独立按键。在实际的项目中，按键可以控制很多外设。为了以后进一步讲按键控制外设等功能，接下来我会讲哪些新内容呢？欲知详情，请听下回分解-----两片联级74HC595驱动16个LED灯的基本驱动程序。【帖子原文】
读后感
代码和上一个实验（矩阵按键单击）相比，变化挺大，因为上一个实验同时只判断一个按键的状态，但本实验要同时判断16个按键的状态，所以用了数组来存放每个按键的消抖计数值和自锁状态。此外，还增加了多个按键的组合判断。
下面是我在练习（下文部分）中写的部分代码，这段代码的功能是实现16个按键的去抖动和设置键值（1~16号按键），以及17号组合按键的去抖动和设置键值。通过读取u16_key_status 的16个位来判断16个按键是否被按下，同时进行相关操作（这些操作和之前的实验相同），组合按键也是如此，只是组合按键需要另外定义消抖计数值u16_key_time_cnt_01_16 （1号键和16号键组合消抖计数值）和自锁状态标志u8_key_lock_01_16，其他的操作和单个按键相同。
...
...
case 2: //像独立按键一样进行去抖动和翻译
for(i = 0; i < 16; i++)
{
if((u16_key_status & (0x1 << i)) != 0) //说明i+1号按键没被按下
{
u16_key_time_cnt[i] = 0;
u8_key_lock[i] = 0;
}
else if(u8_key_lock[i] == 0) //如果i+1号键被按下，且是第一次被按
{
u16_key_time_cnt[i]++;
if(u16_key_time_cnt[i] > CONST_KEY_TIME)
{
u16_key_time_cnt[i] = 0;
u8_key_lock[i] = 1; //自锁按键，防止不断触发
u8_key_num = i + 1; //i+1号键被触发
}
}
}
//17号组合按键检测
if((u16_key_status & 0x8001) != 0) //说明1号和16号按键没被同时按下
{
u16_key_time_cnt_01_16 = 0; //17号组合按键去抖动计数器清零
u8_key_lock_01_16 = 0; //自锁变量标志清零
}
else if(u8_key_lock_01_16 == 0)
{
u16_key_time_cnt_01_16++;
if(u16_key_time_cnt_01_16 > CONST_KEY_TIME_COMB)
{
u16_key_time_cnt_01_16 = 0;
u8_key_lock_01_16 = 1;
u8_key_num = 17; //17号（组合按键）
}
}
.
.
差点忘了读取按键状态的代码，下面是自我练习中读取按键状态的部分代码，
这只是扫描矩阵按键第一列的代码（其他列的原理类似），先把第一列对应的IO置低，其他列置高，然后检测第一列哪些按键被按下了（4个行IO默认上拉，按下后电平为低），按下就把u16_key_status对应位置0，比如按键1被按下，就使用u16_key_status = u16_key_status & 0xfffe; 将最低位置0，其他位保持不变。注意这里都是用if判断行电平高低的，不能用if else，因为本实验支持多按键同时按下。
...
...
case 1: //把16个按键的状态快速记录在u16_key_status变量的每一位中
for(u8_row_record = 1; u8_row_record < 5; u8_row_record++)
{
//按键扫描输出第u8_row_record列低电平
if(u8_row_record == 1) //第一列输出低电平
{
key_out1 = 0, key_out2 = 1, key_out3 = 1, key_out4 = 1;
//如果是薄膜按键或者走线比较长的按键，此处应该加上几个空延时，
//等待列输出信号稳定再判断输入的状态
if(key_in1 == 0)
{
u16_key_status = u16_key_status & 0xfffe; //按键1
}
if(key_in2 == 0)
{
u16_key_status = u16_key_status & 0xffef; //按键5
}
if(key_in3 == 0)
{
u16_key_status = u16_key_status & 0xfeff; //按键9
}
if(key_in4 == 0)
{
u16_key_status = u16_key_status & 0xefff; //按键13
}
}
else if(u8_row_record == 2) //第二列输出低电平
...
...
吴老师的一句话我有些不理解，先记下来，万一以后用的到呢。
要提醒大家在设计矩阵键盘时，很容易犯的一个错误。任意两个组合按键不能处于同一行，否则触发性能大打折扣。在做产品的时候，硬件电路设计中，除了四路行输入的要加上拉电阻，四路列输出也应该串入一个470欧左右的限流电阻，否则当同一行的两个按键同时按下时，很容易烧坏单片机IO口。为什么？大家仔细想想原因。因为如果没有限流电阻，同一行的两个按键同时按下时，在某一瞬间，输出的两路高低电平将会直接短接在一起，引起短路。
[单片机IO输出的高低电平短接会烧IO？]
来源：百度知道
自我练习
参照吴老师代码自己再写一遍，加深印象。
代码：
#include "REG52.h"
/******************************************************************************
* 重定义
******************************************************************************/
typedef unsigned int u16; //51单片机int长度为2Bytes
typedef unsigned char u8;
/******************************************************************************
* 宏定义
******************************************************************************/
#define CONST_VOICE_SHORT 100 //蜂鸣器短叫持续时间
//#define CONST_VOICE_LONG 500 //蜂鸣器长叫持续时间
#define CONST_KEY_TIME 20 //短按的按键去抖动延时时间
#define CONST_KEY_TIME_COMB 25 //组合按键去抖动延时的时间
/* 吴老师注释：
* 注意：组合按键的去抖动延时const_key_time_comb千万不能等于单击按键
* 的去抖动延时const_key_time，否则组合按键会覆盖单击按键的触发。
*/
/******************************************************************************
* 函数声明
******************************************************************************/
void System_Init(); //系统初始化——第一区
void User_Init(); //用户初始化——第二区
void Delay_Long(u16 u16_delay_long); //长延时
void Led_Fliker(); //LED闪烁
void Timer0_ISR(); //定时器0中断服务函数
void Key_Process(); //按键处理应用程序
void Key_Scan(); //按键扫描函数
void Led_Process(); //LED的应用程序
/******************************************************************************
* 全局变量
******************************************************************************/
sbit led_out = P3^5; //LED输出IO
sbit beep_out = P2^7; //Beep输出IO
sbit key_in1 = P1^0; //第一行输入
sbit key_in2 = P1^1; //第二行输入
sbit key_in3 = P1^2; //第三行输入
sbit key_in4 = P1^3; //第四行输入
sbit key_out1 = P1^4; //第一列输出
sbit key_out2 = P1^5; //第二列输出
sbit key_out3 = P1^6; //第三列输出
sbit key_out4 = P1^7; //第四列输出
u8 u8_led_step = 0; //led步骤变量
u16 u16_time_led_cnt = 0; //LED统计循环次数的延时计数器
u16 u16_voice_cnt = 0; //蜂鸣器叫的持续时间计数器
u8 u8_key_step = 1; //按键扫步骤变量
u8 u8_key_num = 0; //被触发的按键编号
u16 u16_key_time_cnt[16] = 0; //16个按键去抖动延时计数器
u8 u8_key_lock[16] = 0; //16个按键触发后自锁的变量标志
u16 u16_key_time_cnt_01_16 = 0; //S1和S16组合按键去抖动延时计数器
u8 u8_key_lock_01_16 = 0; //S1和S16组合按键触发后自锁的变量标志
u16 u16_key_time_cnt_04_13 = 0; //S4和S13组合按键去抖动延时计数器
u8 u8_key_lock_04_13 = 0; //S4和S13组合按键触发后自锁的变量标志
u8 u8_row_record = 1; //记录当前扫描到第几列了
u16 u16_key_status = 0xffff; //此变量每一位代表一个按键的状态，1表示被按下
/******************************************************************************
* @ 函数名 ： main
* @ 功 能 ： 主函数
* @ 参 数 ： 无
* @ 返回值 ： 无
******************************************************************************/
int main()
{
System_Init(); //系统及高速外设初始化——第一区
Delay_Long(100); //延时0.3-2秒——第一区与第二区分隔线
User_Init(); //用户模块初始化/低速外设——第二区
while(1) //while循环——第三区
{
Key_Process(); //按键处理函数
}
}
/******************************************************************************
* @ 函数名 ： Led_Process
* @ 功 能 ： LED处理函数
* @ 参 数 ： 无
* @ 返回值 ： 无
*****************************************************************************/
//void Led_Process()
//{
// if(u16_set_number < 10) //如果被设置的参数小于10，LED灯灭，否则灯亮
// {
// led_out = 0; //LED灭
// }
// else
// {
// led_out = 1; //LED亮
// }
//}
/******************************************************************************
* @ 函数名 ： Key_Scan
* @ 功 能 ： 按键扫描
* @ 参 数 ： 无
* @ 返回值 ： 无
*****************************************************************************/
void Key_Scan()
{
int i = 0;
switch(u8_key_step)
{
case 1: //把16个按键的状态快速记录在u16_key_status变量的每一位中
for(u8_row_record = 1; u8_row_record < 5; u8_row_record++)
{
//按键扫描输出第u8_row_record列低电平
if(u8_row_record == 1) //第一列输出低电平
{
key_out1 = 0, key_out2 = 1, key_out3 = 1, key_out4 = 1;
//如果是薄膜按键或者走线比较长的按键，此处应该加上几个空延时，
//等待列输出信号稳定再判断输入的状态
if(key_in1 == 0)
{
u16_key_status = u16_key_status & 0xfffe; //按键1
}
if(key_in2 == 0)
{
u16_key_status = u16_key_status & 0xffef; //按键5
}
if(key_in3 == 0)
{
u16_key_status = u16_key_status & 0xfeff; //按键9
}
if(key_in4 == 0)
{
u16_key_status = u16_key_status & 0xefff; //按键13
}
}
else if(u8_row_record == 2) //第二列输出低电平
{
key_out1 = 1, key_out2 = 0, key_out3 = 1, key_out4 = 1;
//如果是薄膜按键或者走线比较长的按键，此处应该加上几个空延时，
//等待列输出信号稳定再判断输入的状态
if(key_in1 == 0)
{
u16_key_status = u16_key_status & 0xfffd; //按键2
}
if(key_in2 == 0)
{
u16_key_status = u16_key_status & 0xffdf; //按键6
}
if(key_in3 == 0)
{
u16_key_status = u16_key_status & 0xfdff; //按键10
}
if(key_in4 == 0)
{
u16_key_status = u16_key_status & 0xdfff; //按键14
}
}
else if(u8_row_record == 3) //第三列输出低电平
{
key_out1 = 1, key_out2 = 1, key_out3 = 0, key_out4 = 1;
//如果是薄膜按键或者走线比较长的按键，此处应该加上几个空延时，
//等待列输出信号稳定再判断输入的状态
if(key_in1 == 0)
{
u16_key_status = u16_key_status & 0xfffb; //按键3
}
if(key_in2 == 0)
{
u16_key_status = u16_key_status & 0xffbf; //按键7
}
if(key_in3 == 0)
{
u16_key_status = u16_key_status & 0xfbff; //按键11
}
if(key_in4 == 0)
{
u16_key_status = u16_key_status & 0xbfff; //按键15
}
}
else if(u8_row_record == 4) //第四列输出低电平
{
key_out1 = 1, key_out2 = 1, key_out3 = 1, key_out4 = 0;
//如果是薄膜按键或者走线比较长的按键，此处应该加上几个空延时，
//等待列输出信号稳定再判断输入的状态
if(key_in1 == 0)
{
u16_key_status = u16_key_status & 0xfff7; //按键4
}
if(key_in2 == 0)
{
u16_key_status = u16_key_status & 0xff7f; //按键8
}
if(key_in3 == 0)
{
u16_key_status = u16_key_status & 0xf7ff; //按键12
}
if(key_in4 == 0)
{
u16_key_status = u16_key_status & 0x7fff; //按键16
}
}
}
u8_key_step++; //切换到下一个运行步骤
break;
case 2: //像独立按键一样进行去抖动和翻译
for(i = 0; i < 16; i++)
{
if((u16_key_status & (0x1 << i)) != 0) //说明i+1号按键没被按下
{
u16_key_time_cnt[i] = 0;
u8_key_lock[i] = 0;
}
else if(u8_key_lock[i] == 0) //如果i+1号键被按下，且是第一次被按
{
u16_key_time_cnt[i]++;
if(u16_key_time_cnt[i] > CONST_KEY_TIME)
{
u16_key_time_cnt[i] = 0;
u8_key_lock[i] = 1; //自锁按键，防止不断触发
u8_key_num = 1; //i+1号键被触发
}
}
}
//17号组合按键检测
if((u16_key_status & 0x8001) != 0) //说明1号和16号按键没被同时按下
{
u16_key_time_cnt_01_16 = 0; //17号组合按键去抖动计数器清零
u8_key_lock_01_16 = 0; //自锁变量标志清零
}
else if(u8_key_lock_01_16 == 0)
{
u16_key_time_cnt_01_16++;
if(u16_key_time_cnt_01_16 > CONST_KEY_TIME_COMB)
{
u16_key_time_cnt_01_16 = 0;
u8_key_lock_01_16 = 1;
u8_key_num = 17; //17号（组合按键）
}
}
//18号组合按键检测
if((u16_key_status & 0x1008) != 0) //说明4号和13号按键没被同时按下
{
u16_key_time_cnt_04_13 = 0; //17号组合按键去抖动计数器清零
u8_key_lock_04_13 = 0; //自锁变量标志清零
}
else if(u8_key_lock_04_13 == 0)
{
u16_key_time_cnt_04_13++;
if(u16_key_time_cnt_04_13 > CONST_KEY_TIME_COMB)
{
u16_key_time_cnt_04_13 = 0;
u8_key_lock_04_13 = 1;
u8_key_num = 18; //18号（组合按键）
}
}
u16_key_status = 0xffff; //及时恢复初始状态，方便下一次扫描
u8_key_step = 1; //返回到步骤1，重新扫描
break;
}
}
/******************************************************************************
* @ 函数名 ： Key_Process
* @ 功 能 ： 报警程序
* @ 参 数 ： 无
* @ 返回值 ： 无
*****************************************************************************/
void Key_Process()
{
switch(u8_key_num) //按键编号
{
case 1: //1号键
u16_voice_cnt = CONST_VOICE_SHORT; //按键声音触发，滴一声就停
u8_key_num = 0; //响应按键服务处理程序后，按键编号清零，避免一直触发
break;
case 2: //2号键
u16_voice_cnt = CONST_VOICE_SHORT; //按键声音触发，滴一声就停
u8_key_num = 0; //响应按键服务处理程序后，按键编号清零，避免一直触发
break;
case 3: //3号键
u16_voice_cnt = CONST_VOICE_SHORT; //按键声音触发，滴一声就停
u8_key_num = 0; //响应按键服务处理程序后，按键编号清零，避免一直触发
break;
case 4: //4号键
u16_voice_cnt = CONST_VOICE_SHORT; //按键声音触发，滴一声就停
u8_key_num = 0; //响应按键服务处理程序后，按键编号清零，避免一直触发
break;
case 5: //5号键
u16_voice_cnt = CONST_VOICE_SHORT; //按键声音触发，滴一声就停
u8_key_num = 0; //响应按键服务处理程序后，按键编号清零，避免一直触发
break;
case 6: //6号键
u16_voice_cnt = CONST_VOICE_SHORT; //按键声音触发，滴一声就停
u8_key_num = 0; //响应按键服务处理程序后，按键编号清零，避免一直触发
break;
case 7: //7号键
u16_voice_cnt = CONST_VOICE_SHORT; //按键声音触发，滴一声就停
u8_key_num = 0; //响应按键服务处理程序后，按键编号清零，避免一直触发
break;
case 8: //8号键
u16_voice_cnt = CONST_VOICE_SHORT; //按键声音触发，滴一声就停
u8_key_num = 0; //响应按键服务处理程序后，按键编号清零，避免一直触发
break;
case 9: //9号键
u16_voice_cnt = CONST_VOICE_SHORT; //按键声音触发，滴一声就停
u8_key_num = 0; //响应按键服务处理程序后，按键编号清零，避免一直触发
break;
case 10: //10号键
u16_voice_cnt = CONST_VOICE_SHORT; //按键声音触发，滴一声就停
u8_key_num = 0; //响应按键服务处理程序后，按键编号清零，避免一直触发
break;
case 11: //11号键
u16_voice_cnt = CONST_VOICE_SHORT; //按键声音触发，滴一声就停
u8_key_num = 0; //响应按键服务处理程序后，按键编号清零，避免一直触发
break;
case 12: //12号键
u16_voice_cnt = CONST_VOICE_SHORT; //按键声音触发，滴一声就停
u8_key_num = 0; //响应按键服务处理程序后，按键编号清零，避免一直触发
break;
case 13: //13号键
u16_voice_cnt = CONST_VOICE_SHORT; //按键声音触发，滴一声就停
u8_key_num = 0; //响应按键服务处理程序后，按键编号清零，避免一直触发
break;
case 14: //14号键
u16_voice_cnt = CONST_VOICE_SHORT; //按键声音触发，滴一声就停
u8_key_num = 0; //响应按键服务处理程序后，按键编号清零，避免一直触发
break;
case 15: //15号键
u16_voice_cnt = CONST_VOICE_SHORT; //按键声音触发，滴一声就停
u8_key_num = 0; //响应按键服务处理程序后，按键编号清零，避免一直触发
break;
case 16: //16号键
u16_voice_cnt = CONST_VOICE_SHORT; //按键声音触发，滴一声就停
u8_key_num = 0; //响应按键服务处理程序后，按键编号清零，避免一直触发
break;
case 17: //组合键——按键1+按键16
led_out = 1; //LED灯亮
u16_voice_cnt = CONST_VOICE_SHORT; //按键声音触发，滴一声就停
u8_key_num = 0; //响应按键服务处理程序后，按键编号清零，避免一直触发
break;
case 18: //组合键——按键4+按键13
led_out = 0; //LED灯灭
u16_voice_cnt = CONST_VOICE_SHORT; //按键声音触发，滴一声就停
u8_key_num = 0; //响应按键服务处理程序后，按键编号清零，避免一直触发
break;
}
}
/******************************************************************************
* @ 函数名 ： Delay_Long
* @ 功 能 ： 长延时
* @ 参 数 ： u16_delay_long 延时参数
* @ 返回值 ： 无
*****************************************************************************/
void Delay_Long(u16 u16_delay_long)
{
u16 u16_i = 0;
u16 u16_j = 0;
for(u16_i = 0; u16_i < u16_delay_long; u16_i++)
{
for(u16_j = 0; u16_j < 500; u16_j++)
{
; //空语句
}
}
}
/******************************************************************************
* @ 函数名 ： Tim0_Init
* @ 功 能 ： 定时器0初始化
* @ 参 数 ： 无
* @ 返回值 ： 无
*****************************************************************************/
void Tim0_Init()
{
TMOD = 0x01; //设置定时器0为工作方式1
TH0 = 0xfc; //重装载值为(65535-1000+1)=64536=0xfc18
TL0 = 0x18;
}
/* 注释：
* C51的中断函数格式如下：
* void 函数名() interrupt 中断号
* {
* 中断程序内容
* }
*/
/******************************************************************************
* @ 函数名 ： Timer0_ISR
* @ 功 能 ： 定时器0中断函数
* @ 参 数 ： 无
* @ 返回值 ： 无
*****************************************************************************/
void Timer0_ISR() interrupt 1
{
TF0 = 0; //清除中断标志
TR0 = 0; //关闭中断
Key_Scan(); //按键扫描
if(u16_voice_cnt != 0)
{
u16_voice_cnt--; //累减计数
beep_out = 0; //蜂鸣器低电平有效
}
else
{
; //用于维持if括号语句的对称性
beep_out = 1; //高电平蜂鸣器不响
}
TH0 = 0xfc; //重装载值为(65535-1000+1)=64536=0xfc18
TL0 = 0x18;
TR0 = 1; //开启中断
}
/******************************************************************************
* @ 函数名 ： System_Init
* @ 功 能 ： 系统外设初始化
* @ 参 数 ： 无
* @ 返回值 ： 无
*****************************************************************************/
void System_Init()
{
Tim0_Init(); //定时器0初始化
beep_out = 1; //蜂鸣器关闭
led_out = 0; //LED灯灭
}
/******************************************************************************
* @ 函数名 ： User_Init
* @ 功 能 ： 用户低速外设初始化
* @ 参 数 ： 无
* @ 返回值 ： 无
*****************************************************************************/
void User_Init()
{
EA = 1; //开启中断
ET0 = 1; //允许定时器0中断
TR0 = 1; //启动定时器0中断
}
Proteus仿真：
功能：按下任意单个按键，蜂鸣器短叫；同时按下K0和KF，LED亮，同时按下K3和KC，LED灭。
扫一扫
3127
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
