这些小活动你都参加了吗?快来围观一下吧!>>
电子产品世界 » 论坛首页 » 嵌入式开发 » MCU » 从业将近十年!手把手教你单片机程序框架(连载)

共146条 2/15 1 2 3 4 5 6 ›| 跳转至
菜鸟
2014-06-06 16:18:12     打赏
11楼
第九节:独立按键的双击按键触发。

开场白:
上一节讲了在定时中断函数里处理独立按键的扫描程序,这种结构的程序我用在了很多项目上。这一节教大家如何实现按键双击触发的功能,这种功能类似鼠标的双击。要教会大家一个知识点:如何在上一节的基础上,略作修改,就可以实现按键的双击功能。

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

(1)硬件平台:基于朱兆祺51单片机学习板。用矩阵键盘中的S1和S5号键作为独立按键,记得把输出线P0.4一直输出低电平,模拟独立按键的触发地GND。

(2)实现功能:有两个独立按键,每双击一个独立按键,蜂鸣器发出“滴”的一声后就停。

(3)源代码讲解如下:

#include "REG52.H"

#define const_voice_short  40   //蜂鸣器短叫的持续时间


/* 注释一:
* 调整抖动时间阀值的大小,可以更改按键的触发灵敏度。
* 去抖动的时间本质上等于累计定时中断次数的时间。
*/
#define const_key_time1  20    //按键去抖动延时的时间
#define const_key_time2  20    //按键去抖动延时的时间

/* 注释二:
* 有效时间差,是指连续两次按键触发的最大有效间隔时间。
* 如果双击的两个按键按下的时间间隔太长,则视为无效双击。
*/
#define const_interval_time1  200     //连续两次按键之间的有效时间差
#define const_interval_time2  200     //连续两次按键之间的有效时间差

void initial_myself();    
void initial_peripheral();
void delay_long(unsigned int uiDelaylong);
void T0_time();  //定时中断函数
void key_service(); //按键服务的应用程序
void key_scan(); //按键扫描函数 放在定时中断里

sbit key_sr1=P0^0; //对应朱兆祺学习板的S1键
sbit key_sr2=P0^1; //对应朱兆祺学习板的S5键
sbit key_gnd_dr=P0^4; //模拟独立按键的地GND,因此必须一直输出低电平

sbit beep_dr=P2^7; //蜂鸣器的驱动IO口

unsigned char ucKeySec=0;   //被触发的按键编号

unsigned int  uiKeyTimeCnt1=0; //按键去抖动延时计数器
unsigned char ucKeyLock1=0; //按键触发后自锁的变量标志
unsigned char ucKeyTouchCnt1=0; //按键按下的次数记录
unsigned int  uiKeyIntervalCnt1=0; //按键间隔的时间计数器

unsigned int  uiKeyTimeCnt2=0; //按键去抖动延时计数器
unsigned char ucKeyLock2=0; //按键触发后自锁的变量标志
unsigned char ucKeyTouchCnt2=0; //按键按下的次数记录
unsigned int  uiKeyIntervalCnt2=0; //按键间隔的时间计数器

unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器

void main() 
  {
   initial_myself();  
   delay_long(100);   
   initial_peripheral(); 
   while(1)  
   { 
       key_service(); //按键服务的应用程序
   }

}

void key_scan()//按键扫描函数 放在定时中断里
{  
/* 注释三:
* 独立双击按键扫描的详细过程:
* 第一步:平时没有按键被触发时,按键的自锁标志,去抖动延时计数器一直被清零。
*         如果之前已经有按键触发过一次,那么启动时间间隔计数器uiKeyIntervalCnt1,
*         在这个允许的时间差范围内,如果一直没有第二次按键触发,则把累加按键触发的
*         次数ucKeyTouchCnt1也清零。
* 第二步:一旦有按键被按下,去抖动延时计数器开始在定时中断函数里累加,在还没累加到
*         阀值const_key_time1时,如果在这期间由于受外界干扰或者按键抖动,而使
*         IO口突然瞬间触发成高电平,这个时候马上把延时计数器uiKeyTimeCnt1
*         清零了,这个过程非常巧妙,非常有效地去除瞬间的杂波干扰。这是我实战中摸索出来的。
*         以后凡是用到开关感应器的时候,都可以用类似这样的方法去干扰。
* 第三步:如果按键按下的时间超过了阀值const_key_time1,马上把自锁标志ucKeyLock1置位,
*         防止按住按键不松手后一直触发。与此同时,累加一次按键次数,如果按键次数累加有两次以上,
*         则认为触发双击按键,并把编号ucKeySec赋值。 
* 第四步:等按键松开后,自锁标志ucKeyLock1及时清零,为下一次自锁做准备。并且累加间隔时间,
*         防止两次按键的间隔时间太长。
* 第五步:以上整个过程,就是识别按键IO口下降沿触发的过程。
*/
  if(key_sr1==1)//IO是高电平,说明按键没有被按下,这时要及时清零一些标志位
  {
         ucKeyLock1=0; //按键自锁标志清零
         uiKeyTimeCnt1=0;//按键去抖动延时计数器清零,此行非常巧妙,是我实战中摸索出来的。      
                 if(ucKeyTouchCnt1>0) //之前已经有按键触发过一次,再来一次就构成双击
                 {
                     uiKeyIntervalCnt1++; //按键间隔的时间计数器累加
                         if(uiKeyIntervalCnt1>const_interval_time1) //超过最大允许的间隔时间
                         {
                            uiKeyIntervalCnt1=0; //时间计数器清零
                            ucKeyTouchCnt1=0; //清零按键的按下的次数
                         }
                 }
  }
  else if(ucKeyLock1==0)//有按键按下,且是第一次被按下
  {
     uiKeyTimeCnt1++; //累加定时中断次数
     if(uiKeyTimeCnt1>const_key_time1)
     {
        uiKeyTimeCnt1=0; 
        ucKeyLock1=1;  //自锁按键置位,避免一直触发
                uiKeyIntervalCnt1=0; //按键有效间隔的时间计数器清零

                ucKeyTouchCnt1++;
                if(ucKeyTouchCnt1>1)  //连续被按了两次以上
                {
                    ucKeyTouchCnt1=0;  //统计按键次数清零
                    ucKeySec=1;    //触发1号键
                }

     }
  }




  if(key_sr2==1)
  {
         ucKeyLock2=0; 
         uiKeyTimeCnt2=0;
                  if(ucKeyTouchCnt2>0)
                 {
                     uiKeyIntervalCnt2++; //按键间隔的时间计数器累加
                         if(uiKeyIntervalCnt2>const_interval_time2) //超过最大允许的间隔时间
                         {
                            uiKeyIntervalCnt2=0; //时间计数器清零
                            ucKeyTouchCnt2=0; //清零按键的按下的次数
                         }
                 }
  }
  else if(ucKeyLock2==0)
  {
     uiKeyTimeCnt2++; //累加定时中断次数
     if(uiKeyTimeCnt2>const_key_time2)
     {
        uiKeyTimeCnt2=0;
        ucKeyLock2=1; 
                uiKeyIntervalCnt2=0; //按键有效间隔的时间计数器清零

                ucKeyTouchCnt2++;
                if(ucKeyTouchCnt2>1)  //连续被按了两次以上
                {
                    ucKeyTouchCnt2=0;  //统计按键次数清零
                    ucKeySec=2;    //触发2号键
                }
     }
  }

}


void key_service() //第三区 按键服务的应用程序
{
  switch(ucKeySec) //按键服务状态切换
  {
    case 1:// 1号键 双击  对应朱兆祺学习板的S1键

              uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
              ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
          break;        
    case 2:// 2号键 双击  对应朱兆祺学习板的S5键

              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()  //第一区 初始化单片机
{
/* 注释四:
* 矩阵键盘也可以做独立按键,前提是把某一根公共输出线输出低电平,
* 模拟独立按键的触发地,本程序中,把key_gnd_dr输出低电平。
* 朱兆祺51学习板的S1和S5两个按键就是本程序中用到的两个独立按键。
*/
  key_gnd_dr=0; //模拟独立按键的地GND,因此必须一直输出低电平


  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;    //启动定时中断

}

 

总结陈词:
假如要两个独立按键实现组合按键的功能,我们该怎么写程序?欲知详情,请听下回分解-----独立按键的组合按键触发。

(未完待续,下节更精彩,不要走开哦)


菜鸟
2014-06-06 16:20:24     打赏
12楼
第十节:两个独立按键的组合按键触发。

开场白:
上一节讲了按键双击触发功能的程序,这一节讲类似电脑键盘组合按键触发的功能,要教会大家一个知识点:如何在上一节的基础上,略作修改,就可以实现两个独立按键的组合按键触发功能。

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

(1)硬件平台:基于朱兆祺51单片机学习板。用矩阵键盘中的S1和S5号键作为独立按键,记得把输出线P0.4一直输出低电平,模拟独立按键的触发地GND。

(2)实现功能:有两个独立按键,当把两个独立按键都按下后,蜂鸣器发出“滴”的一声后就停。直到松开任一个按键后,才能重新进行下一次的组合按键触发。

(3)源代码讲解如下:


#include "REG52.H"

#define const_voice_short  40   //蜂鸣器短叫的持续时间


/* 注释一:
* 调整抖动时间阀值的大小,可以更改按键的触发灵敏度。
* 去抖动的时间本质上等于累计定时中断次数的时间。
*/
#define const_key_time12  20    //按键去抖动延时的时间


void initial_myself();    
void initial_peripheral();
void delay_long(unsigned int uiDelaylong);
void T0_time();  //定时中断函数
void key_service(); //按键服务的应用程序
void key_scan(); //按键扫描函数 放在定时中断里

sbit key_sr1=P0^0; //对应朱兆祺学习板的S1键
sbit key_sr2=P0^1; //对应朱兆祺学习板的S5键
sbit key_gnd_dr=P0^4; //模拟独立按键的地GND,因此必须一直输出低电平

sbit beep_dr=P2^7; //蜂鸣器的驱动IO口

unsigned char ucKeySec=0;   //被触发的按键编号

unsigned int  uiKeyTimeCnt12=0; //按键去抖动延时计数器
unsigned char ucKeyLock12=0; //按键触发后自锁的变量标志


unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器

void main() 
  {
   initial_myself();  
   delay_long(100);   
   initial_peripheral(); 
   while(1)  
   { 
       key_service(); //按键服务的应用程序
   }

}

void key_scan()//按键扫描函数 放在定时中断里
{  
/* 注释二:
* 独立组合按键扫描的详细过程:
* 第一步:平时只要两个按键中有一个没有被按下时,按键的自锁标志,去抖动延时计数器一直被清零。
* 第二步:一旦两个按键都被按下,去抖动延时计数器开始在定时中断函数里累加,在还没累加到
*         阀值const_key_time12时,如果在这期间由于受外界干扰或者按键抖动,而使
*         IO口突然瞬间触发成高电平,这个时候马上把延时计数器uiKeyTimeCnt12
*         清零了,这个过程非常巧妙,非常有效地去除瞬间的杂波干扰。这是我实战中摸索出来的。
*         以后凡是用到开关感应器的时候,都可以用类似这样的方法去干扰。
* 第三步:如果按键按下的时间超过了阀值const_key_time12,马上把自锁标志ucKeyLock12置位,
*         防止按住按键不松手后一直触发。并把编号ucKeySec赋值。 组合按键触发
* 第四步:等按键松开后,自锁标志ucKeyLock12及时清零,为下一次自锁做准备。
* 第五步:以上整个过程,就是识别按键IO口下降沿触发的过程。
*/
  if(key_sr1==1||key_sr2==1)//IO是高电平,说明两个按键没有全部被按下,这时要及时清零一些标志位
  {
         ucKeyLock12=0; //按键自锁标志清零
         uiKeyTimeCnt12=0;//按键去抖动延时计数器清零,此行非常巧妙,是我实战中摸索出来的。      
  }
  else if(ucKeyLock12==0)//有按键按下,且是第一次被按下
  {
     uiKeyTimeCnt12++; //累加定时中断次数
     if(uiKeyTimeCnt12>const_key_time12)
     {
        uiKeyTimeCnt12=0; 
        ucKeyLock12=1;  //自锁按键置位,避免一直触发
        ucKeySec=1;    //触发1号键
              
     }
  }




}


void key_service() //第三区 按键服务的应用程序
{
  switch(ucKeySec) //按键服务状态切换
  {
    case 1:// 1号键 组合按键  对应朱兆祺学习板的S1键和S5键

              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()  //第一区 初始化单片机
{
/* 注释三:
* 矩阵键盘也可以做独立按键,前提是把某一根公共输出线输出低电平,
* 模拟独立按键的触发地,本程序中,把key_gnd_dr输出低电平。
* 朱兆祺51学习板的S1和S5两个按键就是本程序中用到的两个独立按键。
*/
  key_gnd_dr=0; //模拟独立按键的地GND,因此必须一直输出低电平


  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;    //启动定时中断

}

总结陈词:
以前寻呼机流行的时候,寻呼机往往只有一个设置按键,它要求用一个按键来设置不同的参数,这个时候就要用到同一个按键来实现短按和长按的区别触发功能。要现实这种功能,我们该怎么写程序?欲知详情,请听下回分解-----同一个按键短按与长按的区别触发。

(未完待续,下节更精彩,不要走开哦)



菜鸟
2014-06-06 16:24:06     打赏
13楼
第十一节:同一个按键短按与长按的区别触发。

开场白:
上一节讲了类似电脑键盘组合按键触发的功能,这节要教会大家一个知识点:如何在上一节的基础上,略作修改,就可以实现同一个按键短按与长按的区别触发。

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

(1)硬件平台:基于朱兆祺51单片机学习板。用矩阵键盘中的S1和S5号键作为独立按键,记得把输出线P0.4一直输出低电平,模拟独立按键的触发地GND。

(2)实现功能:两个独立按键S1和S5,按住其中一个按键,在短时间内松手,则认为是短按,触发蜂鸣器短鸣一声。如果一直按住这个按键不松手,那么超过规定的长时间内,则认为是长按,触发蜂鸣器长鸣一声。

(3)源代码讲解如下:

#include "REG52.H"

#define const_voice_short  20   //蜂鸣器短叫的持续时间
#define const_voice_long   140   //蜂鸣器长叫的持续时间

/* 注释一:
* 调整抖动时间阀值的大小,可以更改按键的触发灵敏度。
* 去抖动的时间本质上等于累计定时中断次数的时间。
*/
#define const_key_time_short1  20    //短按的按键去抖动延时的时间
#define const_key_time_long1   400     //长按的按键去抖动延时的时间

#define const_key_time_short2  20    //短按的按键去抖动延时的时间
#define const_key_time_long2   400     //长按的按键去抖动延时的时间

void initial_myself();    
void initial_peripheral();
void delay_long(unsigned int uiDelaylong);
void T0_time();  //定时中断函数
void key_service(); //按键服务的应用程序
void key_scan(); //按键扫描函数 放在定时中断里

sbit key_sr1=P0^0; //对应朱兆祺学习板的S1键
sbit key_sr2=P0^1; //对应朱兆祺学习板的S5键
sbit key_gnd_dr=P0^4; //模拟独立按键的地GND,因此必须一直输出低电平

sbit beep_dr=P2^7; //蜂鸣器的驱动IO口

unsigned char ucKeySec=0;   //被触发的按键编号

unsigned int  uiKeyTimeCnt1=0; //按键去抖动延时计数器
unsigned char ucKeyLock1=0; //按键触发后自锁的变量标志
unsigned char ucShortTouchFlag1=0; //短按的触发标志

unsigned int  uiKeyTimeCnt2=0; //按键去抖动延时计数器
unsigned char ucKeyLock2=0; //按键触发后自锁的变量标志
unsigned char ucShortTouchFlag2=0; //短按的触发标志

unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器

void main() 
  {
   initial_myself();  
   delay_long(100);   
   initial_peripheral(); 
   while(1)  
   { 
       key_service(); //按键服务的应用程序
   }

}

void key_scan()//按键扫描函数 放在定时中断里
{  
/* 注释二:
* 长按与短按的按键扫描的详细过程:
* 第一步:平时只要按键没有被按下时,按键的自锁标志,去抖动延时计数器一直被清零。
* 第二步:一旦两个按键都被按下,去抖动延时计数器开始在定时中断函数里累加,在还没累加到
*         阀值const_key_time_short1或者const_key_time_long1时,如果在这期间由于受外界干扰或者按键抖动,而使
*         IO口突然瞬间触发成高电平,这个时候马上把延时计数器uiKeyTimeCnt1
*         清零了,这个过程非常巧妙,非常有效地去除瞬间的杂波干扰。这是我实战中摸索出来的。
*         以后凡是用到开关感应器的时候,都可以用类似这样的方法去干扰。
* 第三步:如果按键按下的时间超过了短按阀值const_key_time_short1,则马上把短按标志ucShortTouchFlag1=1;
*         如果还没有松手,一旦发现按下的时间超过长按阀值const_key_time_long1时,
*         先把短按标志ucShortTouchFlag1清零,然后触发长按。在这段程序里,把自锁标志ucKeyLock1置位,
*         是为了防止按住按键不松手后一直触发。
* 第四步:等按键松开后,自锁标志ucKeyLock12及时清零,为下一次自锁做准备。如果发现ucShortTouchFlag1等于1,
*         说明短按有效,这时触发一次短按。
* 第五步:以上整个过程,就是识别按键IO口下降沿触发的过程。
*/
  if(key_sr1==1)//IO是高电平,说明两个按键没有全部被按下,这时要及时清零一些标志位
  {
      ucKeyLock1=0; //按键自锁标志清零
      uiKeyTimeCnt1=0;//按键去抖动延时计数器清零,此行非常巧妙,是我实战中摸索出来的。    
            if(ucShortTouchFlag1==1)  //短按触发标志
          {
             ucShortTouchFlag1=0;
                 ucKeySec=1;    //触发一号键的短按
          }
  }
  else if(ucKeyLock1==0)//有按键按下,且是第一次被按下
  {
     uiKeyTimeCnt1++; //累加定时中断次数
     if(uiKeyTimeCnt1>const_key_time_short1) 
     {
            ucShortTouchFlag1=1;   //激活按键短按的有效标志  
     }

     if(uiKeyTimeCnt1>const_key_time_long1) 
     {
            ucShortTouchFlag1=0;  //清除按键短按的有效标志

        uiKeyTimeCnt1=0; 
        ucKeyLock1=1;  //自锁按键置位,避免一直触发

        ucKeySec=2;    //触发1号键的长按
              
     }

  }

  if(key_sr2==1)//IO是高电平,说明两个按键没有全部被按下,这时要及时清零一些标志位
  {
      ucKeyLock2=0; //按键自锁标志清零
      uiKeyTimeCnt2=0;//按键去抖动延时计数器清零,此行非常巧妙,是我实战中摸索出来的。    
            if(ucShortTouchFlag2==1)  //短按触发标志
          {
             ucShortTouchFlag2=0;
                 ucKeySec=3;    //触发2号键的短按
          }
  }
  else if(ucKeyLock2==0)//有按键按下,且是第一次被按下
  {
     uiKeyTimeCnt2++; //累加定时中断次数
     if(uiKeyTimeCnt2>const_key_time_short2) 
     {
            ucShortTouchFlag2=1;   //激活按键短按的有效标志  
     }

     if(uiKeyTimeCnt2>const_key_time_long2) 
     {
            ucShortTouchFlag2=0;  //清除按键短按的有效标志

        uiKeyTimeCnt2=0; 
        ucKeyLock2=1;  //自锁按键置位,避免一直触发

        ucKeySec=4;    //触发2号键的长按
              
     }

  }


}


void key_service() //第三区 按键服务的应用程序
{
  switch(ucKeySec) //按键服务状态切换
  {
    case 1:// 1号键的短按  对应朱兆祺学习板的S1键

          uiVoiceCnt=const_voice_short; //按键声音的短触发,滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
          break;        
    case 2:// 1号键的长按  对应朱兆祺学习板的S1键

          uiVoiceCnt=const_voice_long; //按键声音的长触发,滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
          break;       
    case 3:// 2号键的短按  对应朱兆祺学习板的S5键

          uiVoiceCnt=const_voice_short; //按键声音的短触发,滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
          break;        
    case 4:// 2号键的长按  对应朱兆祺学习板的S5键

          uiVoiceCnt=const_voice_long; //按键声音的长触发,滴一声就停。
          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()  //第一区 初始化单片机
{
/* 注释三:
* 矩阵键盘也可以做独立按键,前提是把某一根公共输出线输出低电平,
* 模拟独立按键的触发地,本程序中,把key_gnd_dr输出低电平。
* 朱兆祺51学习板的S1和S5两个按键就是本程序中用到的两个独立按键。
*/
  key_gnd_dr=0; //模拟独立按键的地GND,因此必须一直输出低电平


  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;    //启动定时中断

}

 

总结陈词:
    在很多需要人机交互的项目中,需要用按键来快速加减某个数值,这个时候如果按住一个按键不松手,这个数值要有节奏地快速往上加或者快速往下减。要现实这种功能,我们该怎么写程序?欲知详情,请听下回分解-----按住一个独立按键不松手的连续步进触发。

(未完待续,下节更精彩,不要走开哦)


菜鸟
2014-06-06 16:26:55     打赏
14楼
第十二节:按住一个独立按键不松手的连续步进触发。

开场白:
上一节讲了同一个按键短按与长按的区别触发功能,这节要教会大家两个知识点:
第一个知识点:如何在上一节的基础上,略作修改,就可以实现按住一个独立按键不松手的连续步进触发。
第二个知识点:在单片机的C语言编译器中,当无符号数据0减去1时,就会溢出,变成这个类型数据的最大值。比如是unsigned int类型的0减去1就等于65535(0xffff),unsigned char类型的0减去1就等于255(0xff)。这个常识经常要用在判断数据临界点的地方。比如一个数最大值是20,最小值是0。这个数据一直往下减,当我们发现它突然大于20的时候,就知道它溢出了,这个时候要及时把它赋值成0就达到我们的目的。

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

(1)硬件平台:基于朱兆祺51单片机学习板。用矩阵键盘中的S1和S5号键作为独立按键,记得把输出线P0.4一直输出低电平,模拟独立按键的触发地GND。

(2)实现功能:两个独立按键S1和S5,S1键作为加键。S5键做为减键。每按一次S1键则被设置参数uiSetNumber自加1。如果按住S1键不松手超过1秒钟,被设置参数uiSetNumber以每0.25秒的时间间隔往上自加1,一直加到20为止。每按一次S5键则被设置参数uiSetNumber自减1。如果按住S5键不松手超过1秒钟,被设置参数uiSetNumber以每0.25秒的时间间隔往下自减1,一直减到0为止。当被设置参数uiSetNumber小于10的时候,LED灯灭;当大于或者等于10的时候,LED灯亮。

(3)源代码讲解如下:

#include "REG52.H"

#define const_voice_short  40   //蜂鸣器短叫的持续时间

#define const_key_time1  20    //按键去抖动延时的时间
#define const_key_time2  20    //按键去抖动延时的时间

#define const_time_0_25s  111   //0.25秒钟的时间需要的定时中断次数
#define const_time_1s     444   //1秒钟的时间需要的定时中断次数



void initial_myself();    
void initial_peripheral();
void delay_long(unsigned int uiDelaylong);
void T0_time();  //定时中断函数
void key_service(); //按键服务的应用程序
void key_scan(); //按键扫描函数 放在定时中断里
void led_run();  //led灯的应用程序

sbit key_sr1=P0^0; //对应朱兆祺学习板的S1键
sbit key_sr2=P0^1; //对应朱兆祺学习板的S5键
sbit key_gnd_dr=P0^4; //模拟独立按键的地GND,因此必须一直输出低电平

sbit beep_dr=P2^7; //蜂鸣器的驱动IO口

sbit led_dr=P3^5;  //LED的驱动IO口


unsigned char ucKeySec=0;   //被触发的按键编号

unsigned int  uiKeyTimeCnt1=0; //按键去抖动延时计数器
unsigned int  uiKeyCtntyCnt1=0;  //按键连续触发的间隔延时计数器
unsigned char ucKeyLock1=0; //按键触发后自锁的变量标志


unsigned int  uiKeyTimeCnt2=0; //按键去抖动延时计数器
unsigned int  uiKeyCtntyCnt2=0;  //按键连续触发的间隔延时计数器
unsigned char ucKeyLock2=0; //按键触发后自锁的变量标志

unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器

unsigned int  uiSetNumber=0; //设置的数据

void main() 
  {
   initial_myself();  
   delay_long(100);   
   initial_peripheral(); 
   while(1)  
   { 
       key_service(); //按键服务的应用程序
           led_run();  //led灯的应用程序
   }

}

void led_run()  //led灯的应用程序
{
   if(uiSetNumber<10)  //如果被设置的参数uiSetNumber小于10,LED灯则灭。否则亮。
   {
      led_dr=0;  //灭
   }
   else
   {
      led_dr=1;  //亮
   }
}


void key_scan()//按键扫描函数 放在定时中断里
{  
/* 注释一:
* 独立按键扫描的详细过程:
* 第一步:平时没有按键被触发时,按键的自锁标志,去抖动延时计数器,以及时间间隔延时计数器一直被清零。
* 第二步:一旦有按键被按下,去抖动延时计数器开始在定时中断函数里累加,在还没累加到
*         阀值const_key_time1时,如果在这期间由于受外界干扰或者按键抖动,而使
*         IO口突然瞬间触发成高电平,这个时候马上把延时计数器uiKeyTimeCnt1
*         清零了,这个过程非常巧妙,非常有效地去除瞬间的杂波干扰。这是我实战中摸索出来的。
*         以后凡是用到开关感应器的时候,都可以用类似这样的方法去干扰。
* 第三步:如果按键按下的时间超过了阀值const_key_time1,则触发按键,把编号ucKeySec赋值。
*         同时,马上把自锁标志ucKeyLock1置位,防止按住按键不松手后一直触发。
* 第四步:如果此时触发了一次按键后,一直不松手,去抖动延时计时器继续累加,直到超过了1秒钟。进入连续触发模式的程序
* 第五步:在连续触发模式的程序中,连续累加延时计数器开始累加,每0.25秒就触发一次。
* 第六步:等按键松开后,自锁标志ucKeyLock1和两个延时计时器及时清零,为下一次自锁做准备。
*/
  if(key_sr1==1)//IO是高电平,说明按键没有被按下,这时要及时清零一些标志位
  {
     ucKeyLock1=0; //按键自锁标志清零
     uiKeyTimeCnt1=0;//按键去抖动延时计数器清零,此行非常巧妙,是我实战中摸索出来的。    
     uiKeyCtntyCnt1=0; //连续累加的时间间隔延时计数器清零
  }
  else if(ucKeyLock1==0)//有按键按下,且是第一次被按下
  {
     uiKeyTimeCnt1++; //累加定时中断次数
     if(uiKeyTimeCnt1>const_key_time1)
     {
        uiKeyTimeCnt1=0; 
        ucKeyLock1=1;  //自锁按键置位,避免一直触发
        ucKeySec=1;    //触发1号键
     }
  }
  else if(uiKeyTimeCnt1<const_time_1s) //按住累加到1秒
  {
     uiKeyTimeCnt1++;
  }
  else  //按住累加到1秒后仍然不放手,这个时候进入有节奏的连续触发
  {
     uiKeyCtntyCnt1++; //连续触发延时计数器累加
         if(uiKeyCtntyCnt1>const_time_0_25s)  //按住没松手,每0.25秒就触发一次
         {
             uiKeyCtntyCnt1=0; //
         ucKeySec=1;    //触发1号键
         }
   
  }



  if(key_sr2==1)
  {
     ucKeyLock2=0; 
     uiKeyTimeCnt2=0;
         uiKeyCtntyCnt2=0;
  }
  else if(ucKeyLock2==0)
  {
     uiKeyTimeCnt2++; //累加定时中断次数
     if(uiKeyTimeCnt2>const_key_time2)
     {
        uiKeyTimeCnt2=0;
        ucKeyLock2=1; 
        ucKeySec=2;     //触发2号键
     }
  }
  else if(uiKeyTimeCnt2<const_time_1s)
  {
      uiKeyTimeCnt2++;
  }
  else
  {
      uiKeyCtntyCnt2++;
          if(uiKeyCtntyCnt2>const_time_0_25s)
          {
             uiKeyCtntyCnt2=0;
                 ucKeySec=2;     //触发2号键
          }
  }

}


void key_service() //第三区 按键服务的应用程序
{
  switch(ucKeySec) //按键服务状态切换
  {
    case 1:// 1号键 连续加键  对应朱兆祺学习板的S1键  
              uiSetNumber++; //被设置的参数连续往上加
                          if(uiSetNumber>20) //最大是20
                          {
                            uiSetNumber=20;
                          }
              uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
              ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
          break;        
    case 2:// 2号键 连续减键  对应朱兆祺学习板的S5键
/* 注释二:
* 在单片机的C语言编译器中,当无符号数据0减去1时,就会溢出,变成这个类型数据的最大值。
* 比如是unsigned int的0减去1就等于65535(0xffff),unsigned char的0减去1就等于255(0xff)
*/
              uiSetNumber--; //被设置的参数连续往下减
                          if(uiSetNumber>20) //最小是0.为什么这里用20?因为0减去1就是溢出变成了65535(0xffff)
                          {
                            uiSetNumber=0;
                          }
              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()  //第一区 初始化单片机
{
/* 注释三:
* 矩阵键盘也可以做独立按键,前提是把某一根公共输出线输出低电平,
* 模拟独立按键的触发地,本程序中,把key_gnd_dr输出低电平。
* 朱兆祺51学习板的S1和S5两个按键就是本程序中用到的两个独立按键。
*/
  key_gnd_dr=0; //模拟独立按键的地GND,因此必须一直输出低电平


  beep_dr=1; //用PNP三极管控制蜂鸣器,输出高电平时不叫。
  led_dr=0;  //LED灯灭

  TMOD=0x01;  //设置定时器0为工作方式1


  TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  TL0=0x2f;

}
void initial_peripheral() //第二区 初始化外围
{
  EA=1;     //开总中断
  ET0=1;    //允许定时中断
  TR0=1;    //启动定时中断

}

 

总结陈词:
本程序可以有节奏地快速往上加或者快速往下减。假如被设置数据的范围不是20,而是1000。如果按0.25秒的节奏往上加,那不是累死人了?如果直接把0.25秒的节奏调快到0.01秒,那么到达999的时候,还来不及松手就很容易超过头,不好微调。有没有完整的方案解决这个问题?当然有。欲知详情,请听下回分解-----按住一个独立按键不松手的加速匀速触发。

(未完待续,下节更精彩,不要走开哦)


菜鸟
2014-06-06 16:29:40     打赏
15楼
第十三节:按住一个独立按键不松手的加速匀速触发。

开场白:
上一节讲了按住一个独立按键不松手的连续步进触发功能,这节要教会大家如何在上一节的基础上,略作修改,就可以实现按键的加速匀速触发。

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

(1)硬件平台:基于朱兆祺51单片机学习板。用矩阵键盘中的S1和S5号键作为独立按键,记得把输出线P0.4一直输出低电平,模拟独立按键的触发地GND。

(2)实现功能:两个独立按键S1和S5,S1键作为加键。S5键做为减键。每按一次S1键则被设置参数uiSetNumber自加1。如果按住S1键不松手超过1秒钟,被设置参数uiSetNumber以不断变快的时间间隔往上自加1,这个称为加速触发的功能,直到到达极限值,则以固定的速度加1,这个过程叫匀速。S5作为减法按键,每触发一次,uiSetNumber就减1,其加速和匀速触发功能跟S1按键一样。当被设置参数uiSetNumber小于500的时候,LED灯灭;当大于或者等于500的时候,LED灯亮。需要注意的是:
第一步:每次按下去触发一次单击按键,如果按下去到松手的时间不超过1秒,则不会进入连续加速触发模式。
第二步:如果按下去不松手的时间超过1秒,则进入连续加速触发模式。按键触发节奏不断加快,蜂鸣器鸣叫的节奏也不断加快。直到它们都到达一个极限值,然后以此极限值间隔匀速触发。在刚开始加速的时候,按键触发与蜂鸣器触发的步骤是一致的,等它们任意一个达到极限值的时候,急促的声音跟按键的触发不一致,并不是蜂鸣器每叫一次,按键就触发一次。实际上加速到最后,按键触发的速度远远比蜂鸣器的触发速度快。

(3)源代码讲解如下:


#include "REG52.H"

#define const_voice_short  40   //蜂鸣器短叫的持续时间

#define const_key_time1  20    //按键去抖动延时的时间
#define const_key_time2  20    //按键去抖动延时的时间

#define const_time_1s     444   //1秒钟的时间需要的定时中断次数

#define const_initial_set 160  //连续触发模式的时候,按键刚开始的间隔触发时间
#define const_min_level  30    //连续触发模式的时候,按键经过加速后,如果一旦发现小于这个值,则直接变到最后的间隔触发时间
#define const_sub_dt  10       //按键的"加速度",相当于按键间隔时间每次的变化量

#define const_last_min_set 5    //连续触发模式的时候,按键经过加速后,最后的间隔触发时间

#define const_syn_min_level  45 //产生同步声音的最小阀值 这个时间必须要比蜂鸣器的时间略长一点。


void initial_myself();    
void initial_peripheral();
void delay_long(unsigned int uiDelaylong);
void T0_time();  //定时中断函数
void key_service(); //按键服务的应用程序
void key_scan(); //按键扫描函数 放在定时中断里
void led_run();  //led灯的应用程序

sbit key_sr1=P0^0; //对应朱兆祺学习板的S1键
sbit key_sr2=P0^1; //对应朱兆祺学习板的S5键
sbit key_gnd_dr=P0^4; //模拟独立按键的地GND,因此必须一直输出低电平

sbit beep_dr=P2^7; //蜂鸣器的驱动IO口

sbit led_dr=P3^5;  //LED的驱动IO口


unsigned char ucKeySec=0;   //被触发的按键编号

unsigned int  uiKeyTimeCnt1=0; //按键去抖动延时计数器
unsigned int  uiKeyCtntyCnt1=0;  //按键连续触发的间隔延时计数器
unsigned char ucKeyLock1=0; //按键触发后自锁的变量标志

unsigned int  uiSynCtntyCnt1=0;   //产生按键同步声音的计数器
unsigned int  uiCtntyTimeSet1=const_initial_set; //按键每次触发的时间间隔,这数值不断变小,导致速度不断加快
unsigned int  uiCtntySynSet1=const_initial_set;//同步声音的时间间隔,这数值不断变小,导致速度不断加快
unsigned char ucCtntyFlag1=0;  //是否处于连续加速触发模式的标志位


unsigned int  uiKeyTimeCnt2=0; //按键去抖动延时计数器
unsigned int  uiKeyCtntyCnt2=0;  //按键连续触发的间隔延时计数器
unsigned char ucKeyLock2=0; //按键触发后自锁的变量标志

unsigned int  uiSynCtntyCnt2=0; //产生按键同步声音的计数器
unsigned int  uiCtntyTimeSet2=const_initial_set; //按键每次触发的时间间隔,这数值不断变小,导致速度不断加快
unsigned int  uiCtntySynSet2=const_initial_set; //同步声音的时间间隔,这数值不断变小,导致速度不断加快
unsigned char ucCtntyFlag2=0; //是否处于连续加速触发模式的标志位

unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器

unsigned int  uiSetNumber=0; //设置的数据

void main() 
  {
   initial_myself();  
   delay_long(100);   
   initial_peripheral(); 
   while(1)  
   { 
       key_service(); //按键服务的应用程序
       led_run();  //led灯的应用程序
   }

}

void led_run()  //led灯的应用程序
{
   if(uiSetNumber<500)  //如果被设置的参数uiSetNumber小于500,LED灯则灭。否则亮。
   {
      led_dr=0;  //灭
   }
   else
   {
      led_dr=1;  //亮
   }
}


void key_scan()//按键扫描函数 放在定时中断里
{  
/* 注释一:
* 独立按键连续加速扫描的过程:
* 第一步:每次按下去触发一次单击按键,如果按下去到松手的时间不超过1秒,则不会进入连续加速触发模式。
* 第二步:如果按下去不松手的时间超过1秒,则进入连续加速触发模式。按键触发节奏不断加快,蜂鸣器鸣叫的节奏
*         也不断加快。直到它们都到达一个极限值,然后以此极限值间隔匀速触发。在刚开始加速的时候,按键触发与
*         蜂鸣器触发的步骤是一致的,等它们任意一个达到极限值的时候,急促的声音跟按键的触发不一致,并不是
*         蜂鸣器每叫一次,按键就触发一次。实际上加速到最后,按键触发的速度远远比蜂鸣器的触发速度快。
*/
  if(key_sr1==1)//IO是高电平,说明按键没有被按下,这时要及时清零一些标志位
  {
     ucKeyLock1=0; //按键自锁标志清零
     uiKeyTimeCnt1=0;//按键去抖动延时计数器清零,此行非常巧妙,是我实战中摸索出来的。    
     uiKeyCtntyCnt1=0; //按键连续加速的时间间隔延时计数器清零
         uiSynCtntyCnt1=0;  //蜂鸣器连续加速的时间间隔延时计数器清零
     uiCtntyTimeSet1=const_initial_set; //按键每次触发的时间间隔初始值,这数值不断变小,导致速度不断加快
     uiCtntySynSet1=const_initial_set; //同步声音的时间间隔初始值,这数值不断变小,导致鸣叫的节奏不断加快

  }
  else if(ucKeyLock1==0)//有按键按下,且是第一次被按下
  {
     uiKeyTimeCnt1++; //累加定时中断次数
     if(uiKeyTimeCnt1>const_key_time1)
     {
        uiKeyTimeCnt1=0; 
        ucKeyLock1=1;  //自锁按键置位,避免一直触发
                ucCtntyFlag1=0; //连续加速触发模式标志位 0代表单击  1代表连续加速触发
        ucKeySec=1;    //触发1号键
     }
  }
  else if(uiKeyTimeCnt1<const_time_1s) //按住累加到1秒
  {
     uiKeyTimeCnt1++;
  }
  else  //按住累加到1秒后仍然不放手,这个时候进入有节奏的连续加速触发
  {
         uiKeyCtntyCnt1++; //按键连续触发延时计数器累加

//按住没松手,每隔一段uiCtntyTimeSet1时间按键就触发一次,而且uiCtntyTimeSet1不断减小,速度就越来越快
         if(uiKeyCtntyCnt1>uiCtntyTimeSet1) 
         {
                     if(uiCtntyTimeSet1>const_min_level)
                         {
                            uiCtntyTimeSet1=uiCtntyTimeSet1-const_sub_dt; //uiCtntyTimeSet1不断减小,速度就越来越快
                         }
                         else
                         {
                             uiCtntyTimeSet1=const_last_min_set; //uiCtntyTimeSet1不断减小,到达一个极限值
                         }
             uiKeyCtntyCnt1=0; 
                         ucCtntyFlag1=1;  //进入连续加速触发模式
             ucKeySec=1;    //触发1号键
         }


                 uiSynCtntyCnt1++; //蜂鸣器连续触发延时计数器累加

//按住没松手,每隔一段uiCtntySynSet1时间蜂鸣器就触发一次,而且uiCtntySynSet1不断减小,鸣叫的节奏就越来越快
                 if(uiSynCtntyCnt1>uiCtntySynSet1)
                 {
                uiCtntySynSet1=uiCtntySynSet1-const_sub_dt; //uiCtntySynSet1不断减小,鸣叫的节奏就越来越快
                        if(uiCtntySynSet1<const_syn_min_level)
                        {
                             uiCtntySynSet1=const_syn_min_level; //uiCtntySynSet1不断减小,达到一个极限值
                        }

                        uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
                        uiSynCtntyCnt1=0;
                 
                 }


   
  }


  if(key_sr2==1)
  {
     ucKeyLock2=0; 
     uiKeyTimeCnt2=0;
     uiKeyCtntyCnt2=0; 
         uiSynCtntyCnt2=0;
     uiCtntyTimeSet2=const_initial_set;
     uiCtntySynSet2=const_initial_set;

  }
  else if(ucKeyLock2==0)
  {
     uiKeyTimeCnt2++; 
     if(uiKeyTimeCnt2>const_key_time2)
     {
        uiKeyTimeCnt2=0; 
        ucKeyLock2=1;  
                ucCtntyFlag2=0;
        ucKeySec=2;  
     }
  }
  else if(uiKeyTimeCnt2<const_time_1s) 
  {
     uiKeyTimeCnt2++;
  }
  else  
  {
         uiKeyCtntyCnt2++; 
         if(uiKeyCtntyCnt2>uiCtntyTimeSet2) 
         {
                     if(uiCtntyTimeSet2>const_min_level)
                         {
                            uiCtntyTimeSet2=uiCtntyTimeSet2-const_sub_dt;
                         }
                         else
                         {
                             uiCtntyTimeSet2=const_last_min_set;
                         }
             uiKeyCtntyCnt2=0; 
                         ucCtntyFlag2=1;
             ucKeySec=2;   
         }

                 uiSynCtntyCnt2++;
                 if(uiSynCtntyCnt2>uiCtntySynSet2)
                 {
                uiCtntySynSet2=uiCtntySynSet2-const_sub_dt;
                        if(uiCtntySynSet2<const_syn_min_level)
                        {
                             uiCtntySynSet2=const_syn_min_level;
                        }

                        uiVoiceCnt=const_voice_short; 
                        uiSynCtntyCnt2=0;
                 
                 }


   
  }
}


void key_service() //第三区 按键服务的应用程序
{
  switch(ucKeySec) //按键服务状态切换
  {
    case 1:// 1号键 连续加键  对应朱兆祺学习板的S1键  
              uiSetNumber++; //被设置的参数连续往上加
              if(uiSetNumber>1000) //最大是1000
              {
                   uiSetNumber=1000;
              }

                          if(ucCtntyFlag1==0) //如果是在单击按键的情况下,则蜂鸣器鸣叫,否则蜂鸣器在按键扫描key_scan里鸣叫
                          {
                  uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
                          }
              ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
          break;        
    case 2:// 2号键 连续减键  对应朱兆祺学习板的S5键
/* 注释二:
* 在单片机的C语言编译器中,当无符号数据0减去1时,就会溢出,变成这个类型数据的最大值。
* 比如是unsigned int的0减去1就等于65535(0xffff),unsigned char的0减去1就等于255(0xff)
*/
              uiSetNumber--; //被设置的参数连续往下减
              if(uiSetNumber>1000) //最小是0.为什么这里用1000?因为0减去1就是溢出变成了65535(0xffff)
              {
                  uiSetNumber=0;
              }
                          if(ucCtntyFlag2==0)  //如果是在单击按键的情况下,则蜂鸣器鸣叫,否则蜂鸣器在按键扫描key_scan里鸣叫
                          {
                  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()  //第一区 初始化单片机
{
/* 注释三:
* 矩阵键盘也可以做独立按键,前提是把某一根公共输出线输出低电平,
* 模拟独立按键的触发地,本程序中,把key_gnd_dr输出低电平。
* 朱兆祺51学习板的S1和S5两个按键就是本程序中用到的两个独立按键。
*/
  key_gnd_dr=0; //模拟独立按键的地GND,因此必须一直输出低电平


  beep_dr=1; //用PNP三极管控制蜂鸣器,输出高电平时不叫。
  led_dr=0;  //LED灯灭

  TMOD=0x01;  //设置定时器0为工作方式1


  TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  TL0=0x2f;

}
void initial_peripheral() //第二区 初始化外围
{
  EA=1;     //开总中断
  ET0=1;    //允许定时中断
  TR0=1;    //启动定时中断

}

 

总结陈词:
    到目前为止,前面一共花了8节内容仔细讲解了独立按键的扫描程序,如果是矩阵键盘,我们该怎么写程序?欲知详情,请听下回分解-----矩阵键盘的单个触发。

(未完待续,下节更精彩,不要走开哦)



菜鸟
2014-06-06 16:31:53     打赏
16楼
第十四节:矩阵键盘的单个触发。


开场白:

上一节讲了按键的加速匀速触发。这节开始讲矩阵键盘的单个触发。

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

(1)硬件平台:基于朱兆祺51单片机学习板。。

(2)实现功能:16个按键中,每按一个按键都能触发一次蜂鸣器发出“滴”的一声。

(3)源代码讲解如下:

#include "REG52.H"

#define const_voice_short  40   //蜂鸣器短叫的持续时间

#define const_key_time  20    //按键去抖动延时的时间

void initial_myself();    
void initial_peripheral();
void delay_long(unsigned int uiDelaylong);
void T0_time();  //定时中断函数
void key_service(); //按键服务的应用程序
void key_scan(); //按键扫描函数 放在定时中断里

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 beep_dr=P2^7; //蜂鸣器的驱动IO口

unsigned char ucKeyStep=1;  //按键扫描步骤变量

unsigned char ucKeySec=0;   //被触发的按键编号
unsigned int  uiKeyTimeCnt=0; //按键去抖动延时计数器
unsigned char ucKeyLock=0; //按键触发后自锁的变量标志


unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器

void main() 
  {
   initial_myself();  
   delay_long(100);   
   initial_peripheral(); 
   while(1)  
   { 
       key_service(); //按键服务的应用程序
   }

}

void key_scan()//按键扫描函数 放在定时中断里
{  
/* 注释一:
*  矩阵按键扫描的详细过程:
*  先输出某一列低电平,其它三列输出高电平,这个时候再分别判断输入的四行,
*  如果发现哪一行是低电平,就说明对应的某个按键被触发。依次分别输出另外三列
*  中的某一列为低电平,再分别判断输入的四行,就可以检测完16个按键。内部详细的
*  去抖动处理方法跟我前面讲的独立按键去抖动方法是一样的。
*/

  switch(ucKeyStep)
  {
     case 1:   //按键扫描输出第一列低电平
          key_dr1=0;      
          key_dr2=1;
          key_dr3=1;    
          key_dr4=1;

          uiKeyTimeCnt=0;  //延时计数器清零
          ucKeyStep++;     //切换到下一个运行步骤
              break;

     case 2:     //此处的小延时用来等待刚才列输出信号稳定,再判断输入信号。不是去抖动延时。
          uiKeyTimeCnt++;
                  if(uiKeyTimeCnt>1)
                  {
                     uiKeyTimeCnt=0;
             ucKeyStep++;     //切换到下一个运行步骤
                  }
              break;

     case 3:
          if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==1)
          {  
             ucKeyStep++;  //如果没有按键按下,切换到下一个运行步骤
             ucKeyLock=0;  //按键自锁标志清零
             uiKeyTimeCnt=0; //按键去抖动延时计数器清零,此行非常巧妙        

          }
                  else if(ucKeyLock==0)  //有按键按下,且是第一次触发
                  {
                     if(key_sr1==0&&key_sr2==1&&key_sr3==1&&key_sr4==1)
                         {
                            uiKeyTimeCnt++;  //去抖动延时计数器
                                if(uiKeyTimeCnt>const_key_time)
                                {
                                   uiKeyTimeCnt=0;
                                   ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
                                   ucKeySec=1;  //触发1号键 对应朱兆祺学习板的S1键
                                }
                         
                         }
                     else if(key_sr1==1&&key_sr2==0&&key_sr3==1&&key_sr4==1)
                         {
                            uiKeyTimeCnt++;  //去抖动延时计数器
                                if(uiKeyTimeCnt>const_key_time)
                                {
                                   uiKeyTimeCnt=0;
                                   ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
                                   ucKeySec=5;  //触发5号键 对应朱兆祺学习板的S5键
                                }
                         
                         }
                     else if(key_sr1==1&&key_sr2==1&&key_sr3==0&&key_sr4==1)
                         {
                            uiKeyTimeCnt++;  //去抖动延时计数器
                                if(uiKeyTimeCnt>const_key_time)
                                {
                                   uiKeyTimeCnt=0;
                                   ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
                                   ucKeySec=9;  //触发9号键 对应朱兆祺学习板的S9键
                                }
                         
                         }
                     else if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==0)
                         {
                            uiKeyTimeCnt++;  //去抖动延时计数器
                                if(uiKeyTimeCnt>const_key_time)
                                {
                                   uiKeyTimeCnt=0;
                                   ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
                                   ucKeySec=13;  //触发13号键 对应朱兆祺学习板的S13键
                                }
                         
                         }
                  
                  }
              break;

     case 4:   //按键扫描输出第二列低电平
          key_dr1=1;      
          key_dr2=0;
          key_dr3=1;    
          key_dr4=1;

          uiKeyTimeCnt=0;  //延时计数器清零
          ucKeyStep++;     //切换到下一个运行步骤
              break;

     case 5:     //此处的小延时用来等待刚才列输出信号稳定,再判断输入信号。不是去抖动延时。
          uiKeyTimeCnt++;
                  if(uiKeyTimeCnt>1)
                  {
                     uiKeyTimeCnt=0;
             ucKeyStep++;     //切换到下一个运行步骤
                  }
              break;

     case 6:
          if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==1)
          {  
             ucKeyStep++;  //如果没有按键按下,切换到下一个运行步骤
             ucKeyLock=0;  //按键自锁标志清零
             uiKeyTimeCnt=0; //按键去抖动延时计数器清零,此行非常巧妙        

          }
                  else if(ucKeyLock==0)  //有按键按下,且是第一次触发
                  {
                     if(key_sr1==0&&key_sr2==1&&key_sr3==1&&key_sr4==1)
                         {
                            uiKeyTimeCnt++;  //去抖动延时计数器
                                if(uiKeyTimeCnt>const_key_time)
                                {
                                   uiKeyTimeCnt=0;
                                   ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
                                   ucKeySec=2;  //触发2号键 对应朱兆祺学习板的S2键
                                }
                         
                         }
                     else if(key_sr1==1&&key_sr2==0&&key_sr3==1&&key_sr4==1)
                         {
                            uiKeyTimeCnt++;  //去抖动延时计数器
                                if(uiKeyTimeCnt>const_key_time)
                                {
                                   uiKeyTimeCnt=0;
                                   ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
                                   ucKeySec=6;  //触发6号键 对应朱兆祺学习板的S6键
                                }
                         
                         }
                     else if(key_sr1==1&&key_sr2==1&&key_sr3==0&&key_sr4==1)
                         {
                            uiKeyTimeCnt++;  //去抖动延时计数器
                                if(uiKeyTimeCnt>const_key_time)
                                {
                                   uiKeyTimeCnt=0;
                                   ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
                                   ucKeySec=10;  //触发10号键 对应朱兆祺学习板的S9键
                                }
                         
                         }
                     else if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==0)
                         {
                            uiKeyTimeCnt++;  //去抖动延时计数器
                                if(uiKeyTimeCnt>const_key_time)
                                {
                                   uiKeyTimeCnt=0;
                                   ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
                                   ucKeySec=14;  //触发14号键 对应朱兆祺学习板的S13键
                                }
                         
                         }
                  
                  }
              break;

     case 7:   //按键扫描输出第三列低电平
          key_dr1=1;      
          key_dr2=1;
          key_dr3=0;    
          key_dr4=1;

          uiKeyTimeCnt=0;  //延时计数器清零
          ucKeyStep++;     //切换到下一个运行步骤
              break;

     case 8:     //此处的小延时用来等待刚才列输出信号稳定,再判断输入信号。不是去抖动延时。
          uiKeyTimeCnt++;
                  if(uiKeyTimeCnt>1)
                  {
                     uiKeyTimeCnt=0;
             ucKeyStep++;     //切换到下一个运行步骤
                  }
              break;

     case 9:
          if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==1)
          {  
             ucKeyStep++;  //如果没有按键按下,切换到下一个运行步骤
             ucKeyLock=0;  //按键自锁标志清零
             uiKeyTimeCnt=0; //按键去抖动延时计数器清零,此行非常巧妙        

          }
                  else if(ucKeyLock==0)  //有按键按下,且是第一次触发
                  {
                     if(key_sr1==0&&key_sr2==1&&key_sr3==1&&key_sr4==1)
                         {
                            uiKeyTimeCnt++;  //去抖动延时计数器
                                if(uiKeyTimeCnt>const_key_time)
                                {
                                   uiKeyTimeCnt=0;
                                   ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
                                   ucKeySec=3;  //触发3号键 对应朱兆祺学习板的S3键
                                }
                         
                         }
                     else if(key_sr1==1&&key_sr2==0&&key_sr3==1&&key_sr4==1)
                         {
                            uiKeyTimeCnt++;  //去抖动延时计数器
                                if(uiKeyTimeCnt>const_key_time)
                                {
                                   uiKeyTimeCnt=0;
                                   ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
                                   ucKeySec=7;  //触发7号键 对应朱兆祺学习板的S7键
                                }
                         
                         }
                     else if(key_sr1==1&&key_sr2==1&&key_sr3==0&&key_sr4==1)
                         {
                            uiKeyTimeCnt++;  //去抖动延时计数器
                                if(uiKeyTimeCnt>const_key_time)
                                {
                                   uiKeyTimeCnt=0;
                                   ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
                                   ucKeySec=11;  //触发11号键 对应朱兆祺学习板的S11键
                                }
                         
                         }
                     else if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==0)
                         {
                            uiKeyTimeCnt++;  //去抖动延时计数器
                                if(uiKeyTimeCnt>const_key_time)
                                {
                                   uiKeyTimeCnt=0;
                                   ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
                                   ucKeySec=15;  //触发15号键 对应朱兆祺学习板的S15键
                                }
                         
                         }
                  
                  }
              break;

     case 10:   //按键扫描输出第四列低电平
          key_dr1=1;      
          key_dr2=1;
          key_dr3=1;    
          key_dr4=0;

          uiKeyTimeCnt=0;  //延时计数器清零
          ucKeyStep++;     //切换到下一个运行步骤
              break;

     case 11:     //此处的小延时用来等待刚才列输出信号稳定,再判断输入信号。不是去抖动延时。
          uiKeyTimeCnt++;
                  if(uiKeyTimeCnt>1)
                  {
                     uiKeyTimeCnt=0;
             ucKeyStep++;     //切换到下一个运行步骤
                  }
              break;

     case 12:
          if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==1)
          {  
             ucKeyStep=1;  //如果没有按键按下,返回到第一步,重新开始扫描
             ucKeyLock=0;  //按键自锁标志清零
             uiKeyTimeCnt=0; //按键去抖动延时计数器清零,此行非常巧妙        

          }
                  else if(ucKeyLock==0)  //有按键按下,且是第一次触发
                  {
                     if(key_sr1==0&&key_sr2==1&&key_sr3==1&&key_sr4==1)
                         {
                            uiKeyTimeCnt++;  //去抖动延时计数器
                                if(uiKeyTimeCnt>const_key_time)
                                {
                                   uiKeyTimeCnt=0;
                                   ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
                                   ucKeySec=4;  //触发4号键 对应朱兆祺学习板的S4键
                                }
                         
                         }
                     else if(key_sr1==1&&key_sr2==0&&key_sr3==1&&key_sr4==1)
                         {
                            uiKeyTimeCnt++;  //去抖动延时计数器
                                if(uiKeyTimeCnt>const_key_time)
                                {
                                   uiKeyTimeCnt=0;
                                   ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
                                   ucKeySec=8;  //触发8号键 对应朱兆祺学习板的S8键
                                }
                         
                         }
                     else if(key_sr1==1&&key_sr2==1&&key_sr3==0&&key_sr4==1)
                         {
                            uiKeyTimeCnt++;  //去抖动延时计数器
                                if(uiKeyTimeCnt>const_key_time)
                                {
                                   uiKeyTimeCnt=0;
                                   ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
                                   ucKeySec=12;  //触发12号键 对应朱兆祺学习板的S12键
                                }
                         
                         }
                     else if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==0)
                         {
                            uiKeyTimeCnt++;  //去抖动延时计数器
                                if(uiKeyTimeCnt>const_key_time)
                                {
                                   uiKeyTimeCnt=0;
                                   ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
                                   ucKeySec=16;  //触发16号键 对应朱兆祺学习板的S16键
                                }
                         
                         }
                  
                  }
              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;   
  }                
}



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()  //第一区 初始化单片机
{


  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;    //启动定时中断

}

 

总结陈词:
    在这一节中,有的人咋看我的按键扫描代码,会觉得代码太多了。我一直认为,只要单片机容量够,代码多一点少一点并不重要,只要不影响运行效率就行。而且有时候,代码写多一点,可读性非常强,修改起来也非常方便。如果一味的追求压缩代码,就会刻意用很多循环,数组等元素,代码虽然紧凑了,但是可分离性,可改性,可读性就没那么强。我说那么多并不是因为我技术有限而不懂压缩,就找个借口敷衍大家,不信?我下一节把这节的代码压缩一下分享给大家。凡是相似度高的那部分代码都可以压缩,具体怎么压缩?欲知详情,请听下回分解-----矩阵键盘单个触发的压缩代码编程。


(未完待续,下节更精彩,不要走开哦)


菜鸟
2014-06-06 16:34:51     打赏
17楼
第十五节:矩阵键盘单个触发的压缩代码编程。

开场白:
上一节讲了矩阵键盘的单个触发。这节要教会大家在不改变其它任何性能的情况下,把上一节的按键扫描程序压缩一下容量。经过压缩后,把原来1558个字节压缩到860个字节的程序容量。

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

(1)硬件平台:基于朱兆祺51单片机学习板。。

(2)实现功能:16个按键中,每按一个按键都能触发一次蜂鸣器发出“滴”的一声。

(3)源代码讲解如下:


#include "REG52.H"

#define const_voice_short  40   //蜂鸣器短叫的持续时间

#define const_key_time  20    //按键去抖动延时的时间

void initial_myself();    
void initial_peripheral();
void delay_long(unsigned int uiDelaylong);
void T0_time();  //定时中断函数
void key_service(); //按键服务的应用程序
void key_scan(); //按键扫描函数 放在定时中断里

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 beep_dr=P2^7; //蜂鸣器的驱动IO口

unsigned char ucKeyStep=1;  //按键扫描步骤变量

unsigned char ucKeySec=0;   //被触发的按键编号
unsigned int  uiKeyTimeCnt=0; //按键去抖动延时计数器
unsigned char ucKeyLock=0; //按键触发后自锁的变量标志

unsigned char ucRowRecord=1; //记录当前扫描到第几列了

unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器

void main() 
  {
   initial_myself();  
   delay_long(100);   
   initial_peripheral(); 
   while(1)  
   { 
       key_service(); //按键服务的应用程序
   }

}

void key_scan()//按键扫描函数 放在定时中断里
{  
/* 注释一:
*  矩阵按键扫描的详细过程:
*  先输出某一列低电平,其它三列输出高电平,这个时候再分别判断输入的四行,
*  如果发现哪一行是低电平,就说明对应的某个按键被触发。依次分别输出另外三列
*  中的某一列为低电平,再分别判断输入的四行,就可以检测完16个按键。内部详细的
*  去抖动处理方法跟我前面讲的独立按键去抖动方法是一样的。
*/

  switch(ucKeyStep)
  {
     case 1:   //按键扫描输出第ucRowRecord列低电平
              if(ucRowRecord==1)  //第一列输出低电平
                  {
             key_dr1=0;      
             key_dr2=1;
             key_dr3=1;    
             key_dr4=1;
                  }
              else if(ucRowRecord==2)  //第二列输出低电平
                  {
             key_dr1=1;      
             key_dr2=0;
             key_dr3=1;    
             key_dr4=1;
                  }
              else if(ucRowRecord==3)  //第三列输出低电平
                  {
             key_dr1=1;      
             key_dr2=1;
             key_dr3=0;    
             key_dr4=1;
                  }
              else   //第四列输出低电平
                  {
             key_dr1=1;      
             key_dr2=1;
             key_dr3=1;    
             key_dr4=0;
                  }

          uiKeyTimeCnt=0;  //延时计数器清零
          ucKeyStep++;     //切换到下一个运行步骤
              break;

     case 2:     //此处的小延时用来等待刚才列输出信号稳定,再判断输入信号。不是去抖动延时。
          uiKeyTimeCnt++;
                  if(uiKeyTimeCnt>1)
                  {
                     uiKeyTimeCnt=0;
             ucKeyStep++;     //切换到下一个运行步骤
                  }
              break;

     case 3:
          if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==1)
          {  
             ucKeyStep=1;  //如果没有按键按下,返回到第一个运行步骤重新开始扫描
             ucKeyLock=0;  //按键自锁标志清零
             uiKeyTimeCnt=0; //按键去抖动延时计数器清零,此行非常巧妙     
   
                         ucRowRecord++;  //输出下一列
                         if(ucRowRecord>4)  
                         {
                            ucRowRecord=1; //依次输出完四列之后,继续从第一列开始输出低电平
                         }

          }
                  else if(ucKeyLock==0)  //有按键按下,且是第一次触发
                  {
                     if(key_sr1==0&&key_sr2==1&&key_sr3==1&&key_sr4==1)
                         {
                            uiKeyTimeCnt++;  //去抖动延时计数器
                                if(uiKeyTimeCnt>const_key_time)
                                {
                                   uiKeyTimeCnt=0;
                                   ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零

                       if(ucRowRecord==1)  //第一列输出低电平
                           {
                                      ucKeySec=1;  //触发1号键 对应朱兆祺学习板的S1键
                           }
                       else if(ucRowRecord==2)  //第二列输出低电平
                           {
                                      ucKeySec=2;  //触发2号键 对应朱兆祺学习板的S2键
                           }
                       else if(ucRowRecord==3)  //第三列输出低电平
                           {
                                      ucKeySec=3;  //触发3号键 对应朱兆祺学习板的S3键
                           }
                       else   //第四列输出低电平
                           {
                                      ucKeySec=4;  //触发4号键 对应朱兆祺学习板的S4键
                           }

                                }
                         
                         }
                     else if(key_sr1==1&&key_sr2==0&&key_sr3==1&&key_sr4==1)
                         {
                            uiKeyTimeCnt++;  //去抖动延时计数器
                                if(uiKeyTimeCnt>const_key_time)
                                {
                                   uiKeyTimeCnt=0;
                                   ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
                       if(ucRowRecord==1)  //第一列输出低电平
                           {
                                      ucKeySec=5;  //触发5号键 对应朱兆祺学习板的S5键
                           }
                       else if(ucRowRecord==2)  //第二列输出低电平
                           {
                                      ucKeySec=6;  //触发6号键 对应朱兆祺学习板的S6键
                           }
                       else if(ucRowRecord==3)  //第三列输出低电平
                           {
                                      ucKeySec=7;  //触发7号键 对应朱兆祺学习板的S7键
                           }
                       else   //第四列输出低电平
                           {
                                      ucKeySec=8;  //触发8号键 对应朱兆祺学习板的S8键
                           }
                                }
                         
                         }
                     else if(key_sr1==1&&key_sr2==1&&key_sr3==0&&key_sr4==1)
                         {
                            uiKeyTimeCnt++;  //去抖动延时计数器
                                if(uiKeyTimeCnt>const_key_time)
                                {
                                   uiKeyTimeCnt=0;
                                   ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
                       if(ucRowRecord==1)  //第一列输出低电平
                           {
                                      ucKeySec=9;  //触发9号键 对应朱兆祺学习板的S9键
                           }
                       else if(ucRowRecord==2)  //第二列输出低电平
                           {
                                      ucKeySec=10;  //触发10号键 对应朱兆祺学习板的S10键
                           }
                       else if(ucRowRecord==3)  //第三列输出低电平
                           {
                                      ucKeySec=11;  //触发11号键 对应朱兆祺学习板的S11键
                           }
                       else   //第四列输出低电平
                           {
                                      ucKeySec=12;  //触发12号键 对应朱兆祺学习板的S12键
                           }
                                }
                         
                         }
                     else if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==0)
                         {
                            uiKeyTimeCnt++;  //去抖动延时计数器
                                if(uiKeyTimeCnt>const_key_time)
                                {
                                   uiKeyTimeCnt=0;
                                   ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
                       if(ucRowRecord==1)  //第一列输出低电平
                           {
                                      ucKeySec=13;  //触发13号键 对应朱兆祺学习板的S13键
                           }
                       else if(ucRowRecord==2)  //第二列输出低电平
                           {
                                      ucKeySec=14;  //触发14号键 对应朱兆祺学习板的S14键
                           }
                       else if(ucRowRecord==3)  //第三列输出低电平
                           {
                                      ucKeySec=15;  //触发15号键 对应朱兆祺学习板的S15键
                           }
                       else   //第四列输出低电平
                           {
                                      ucKeySec=16;  //触发16号键 对应朱兆祺学习板的S16键
                           }
                                }
                         
                         }
                  
                  }
              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;   
  }                
}



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()  //第一区 初始化单片机
{


  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;    //启动定时中断

}

 

总结陈词:
    已经花了两节讲矩阵键盘的单个触发程序。那么,矩阵键盘可不可以实现类似独立按键的组合按键功能?当然可以,但是也有一些附加限制条件。欲知详情,请听下回分解-----矩阵键盘的组合按键触发。

(未完待续,下节更精彩,不要走开哦)



菜鸟
2014-06-06 16:37:57     打赏
18楼
第十六节:矩阵键盘的组合按键触发。

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

(未完待续,下节更精彩,不要走开哦)



菜鸟
2014-06-06 16:43:30     打赏
19楼
感谢你的提醒。我这里自称“鸿哥”没高人一等的意思,口头禅而已,也感觉“哥”这个词比较亲切。希望各位牛人不要放在心上。

助工
2014-06-06 17:27:02     打赏
20楼

说的太快了


共146条 2/15 1 2 3 4 5 6 ›| 跳转至

回复

匿名不能发帖!请先 [ 登陆 注册 ]