第十六节:矩阵键盘的组合按键触发

转载 2017年01月03日 06:36:53


开场白:
上一节讲了矩阵键盘单个触发的压缩代码编程。这节讲矩阵键盘的组合按键触发。要教会大家三个知识点:
第一点:如何把矩阵键盘翻译成独立按盘的处理方式。然后按独立按键的方式来实现组合按键的功能。
第二点:要提醒大家在设计矩阵键盘时,很容易犯的一个错误。任意两个组合按键不能处于同一行,否则触发性能大打折扣。在做产品的时候,硬件电路设计中,除了四路行输入的要加上拉电阻,四路列输出也应该串入一个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灯的基本驱动程序。

相关文章推荐

矩阵按键原理和BUG

当我们的电路有很多按键时,一般会采用矩阵方式与单片机相连来减少对单片机IO的浪费,如下图方式。 这个电路的原理: 1、比如检测S13是否按下,单片机把Line4设为输出,并输出低电平,而L...

复合键在4×4 矩阵式键盘中的应用方法

同时按下两个按键,是应该叫“组合键”,还是应该叫“复合键”?做而论道虽然很自大,但是也不得不承认搞不清楚这个。在网上查,两种叫法都存在。相信大家都用过组合键,比较著名的用法就是:Ctrl+C、Ctrl...

AVR单片机(ATMEGA16)矩阵键盘扫描程序

程序思路与缺陷参考:51单片机(AT89C52)矩阵键盘检测程序 #include typedef unsigned char uchar; typedef unsigned int uint;...

第十四节:矩阵键盘的单个触发

第十四节:矩阵键盘的单个触发。 开场白: 上一节讲了按键的加速匀速触发。这节开始讲矩阵键盘的单个触发。 具体内容,请看源代码讲解。 (1)硬件平台:基于朱兆祺51单片机学习板。。 ...

ARM开发(6) 基于STM32的矩阵键盘按键触发外部中断引起蜂鸣器鸣叫

基于STM32的矩阵键盘按键触发外部中断引起蜂鸣器鸣叫 一 矩阵键盘按键触发外部中断引起蜂鸣器鸣叫原理:1.1 本实验实现矩阵键盘某一列按键触发外部中断实现蜂鸣器鸣叫。1.2 实验思路:根据电路图原理...
  • wzpcsdn
  • wzpcsdn
  • 2017年07月28日 15:00
  • 175

单片机C语言实现独立按键检测与矩阵键盘操作

本文是笔者在学习51单片机的笔记心得。这篇着重介绍C51单片机是如何检测独立按键以及矩阵键盘操作。...

51单片机之独立按键和矩阵键盘(概念及原理)

一、基本知识   1.按键分类与输入原理 按键按照结构原理科分为两类,一类是触点式开关按键,如机械式开关、导电橡胶式开关灯;另一类是无触点式开关按键,如电气式按键,磁感应按键等。前者造价低,后者寿命长...
  • fanyuqa
  • fanyuqa
  • 2015年08月27日 22:06
  • 17202

矩阵键盘按键显示数值

  • 2014年07月28日 20:29
  • 1KB
  • 下载

按键及矩阵键盘程序------/* 自己实验确认并总结 */

新型的按键扫描程序 不过入式处理器上面我在网上游逛了很久,也看过不少源程序了,没有发现这种按键处理办法的踪迹,所以,我将他共享出来,和广大同僚们共勉。我非常坚信这种按键处理办法的便捷和高效,你可以移...

ARM开发(4)基于STM32的矩阵键盘按键控制TM1629A LED显示

一 矩阵键盘按键控制TM1629ALED显示原理: 1.1 本实验实现矩阵键盘按键控制TM1629ALED显示 1.2 实验思路:共阴极数码管,掌握数码管段选位选原理 熟悉TM1629A...
  • wzpcsdn
  • wzpcsdn
  • 2017年07月26日 17:38
  • 275
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:第十六节:矩阵键盘的组合按键触发
举报原因:
原因补充:

(最多只允许输入30个字)