网站导航： 首页 ＞ 设计参考 ＞ 正文 文章搜索
51单片机C语言编程基础及实例
  
文章编号：
090106102159
 文章分类： 单片机 ＞ 51系列
点 击：
...
关 键 词： C语言,基础,实例
文章来源：
网络
摘 要：
基础知识：51单片机编程基础。第一节：单数码管按键显示。第二节：双数码管可调秒表。第三节：十字路口交通灯。第四节：数码管驱动。第五节：键盘驱动。第六节：低频频率计。第七节：电子表。第八节：串行口应用。

第五节：键盘驱动
指提供一些函数给任务调用，获取按键信息，或读取按键值。
定义一个头文档 <KEY.H>，描述可用函数，如下：

 
  1. #ifndef _KEY_H_  //防止重复引用该文档，如果没有定义过符号 _KEY_H_，则编译下面语句       
  2. #define _KEY_H_  //只要引用过一次，即 #include <key.h>，则定义符号 _KEY_H_       
  3. unsigned char keyHit( void ); //如果按键，则返回非０，否则返回０       
  4. unsigned char keyGet( void ); //读取按键值，如果没有按键则等待到按键为止       
  5. void keyPut( unsigned char ucKeyVal ); //保存按键值ucKeyVal到按键缓冲队列末       
  6. void keyBack( unsigned char ucKeyVal ); //退回键值ucKeyVal到按键缓冲队列首       
  7. #endif      

定义函数体文档 KEY.C，如下：

 
 
  1. #include “key.h”       
  2. #define KeyBufSize 16 //定义按键缓冲队列字节数       
  3. unsigned char KeyBuf[ KeyBufSize ]; //定义一个无符号字符数组作为按键缓冲队列。该队列为先进       
  4. //先出，循环存取，下标从０到 KeyBufSize-1       
  5. unsigned char KeyBufWp=0; //作为数组下标变量，记录存入位置       
  6. unsigned char KeyBufRp=0; //作为数组下标变量，记录读出位置       
  7. //如果存入位置与读出位置相同，则表明队列中无按键数据       
  8. unsigned char keyHit( void )       
  9. {    
  10.     if( KeyBufWp == KeyBufRp )    
  11.         return( 0 );    
  12.     else  
  13.         return( 1 );    
  14. }       
  15.   
  16. unsigned char keyGet( void )       
  17. {    
  18.     unsigned char retVal; //暂存读出键值       
  19.     while( keyHit()==0 ); //等待按键，因为函数keyHit()的返回值为 0 表示无按键       
  20.     retVal = KeyBuf[ KeyBufRp ]; //从数组中读出键值       
  21.     if( ++KeyBufRp >= KeyBufSize )    
  22.         KeyBufRp=0; //读位置加１，超出队列则循环回初始位置       
  23.     return( retVal );       
  24. }       
  25.   
  26. void keyPut( unsigned char ucKeyVal )       
  27. {    
  28.     KeyBuf[ KeyBufWp ] = ucKeyVal; //键值存入数组       
  29.     if( ++KeyBufWp >= KeyBufSize )   
  30.         KeyBufWp=0;  //存入位置加１，超出队列则循环回初始位置       
  31. }       
  32. /*****************************************************************************************     
  33. 由于某种原因，读出的按键，没有用，但其它任务要用该按键，但传送又不方便。此时可以退回按键队列。就如取错了信件，有必要退回一样     
  34. ******************************************************************************************/      
  35. void keyBack( unsigned char ucKeyVal )       
  36. {       
  37. /*     
  38. 如果KeyBufRp=0; 减1后则为FFH，大于KeyBufSize，即从数组头退回到数组尾。或者由于干扰使得KeyBufRp超出队列位置，也要调整回到正常位置，     
  39.     */      
  40.     if( --KeyBufRp >= KeyBufSize )   
  41.         KeyBufRp=KeyBufSize-1;        
  42.     KeyBuf[ KeyBufRp ] = ucKeyVal; //回存键值       
  43. }      

下面渐进讲解键盘物理层的驱动。
电路共同点：P2端口接一共阴数码管，共阴极接GND，P2.0接a段、P2.1接b段、…、P2.7接h段。
软件共同点：code unsigned char Seg7Code[10] 是七段数码管共阴编码表。
 
  1. Code unsigned char Seg7Code[16]=   
  2. // 0     1    2     3     4    5     6     7     8     9     A     b     C     d    E    F   
  3. {0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f, 0x77, 0x7c, 0x39, 0x5e, 0x79, 0x71};   

例一：P1.0接一按键到GND，键编号为‘６’，显示按键。

 
 
  1. #include <at89x52.h>       
  2. #include "KEY.H"       
  3. void main( void )       
  4. {    
  5.     P1_0 = 1;  //作为输入引脚，必须先输出高电平       
  6.     while( 1 ) //永远为真，即死循环       
  7.     {    
  8.         if( P1_0 == 0 ) //如果按键，则为低电平       
  9.         {    
  10.             keyPut( 6 ); //保存按键编号值为按键队列       
  11.             while( P1_0 == 0 ); //如果一直按着键，则不停地执行该循环，实际是等待松键       
  12.         }       
  13.         if( keyHit() != 0 ) //如果队列中有按键       
  14.             P2=Seg7Code[ keyGet() ]; //从队列中取出按键值，并显示在数码管上       
  15.     }       
  16. }   

例二：在例一中考虑按键20ms抖动问题。
 
  1. #include <at89x52.h>       
  2. #include “KEY.H”       
  3. void main( void )       
  4. {    
  5.     P1_0 = 1;  //作为输入引脚，必须先输出高电平       
  6.     while( 1 ) //永远为真，即死循环       
  7.     {    
  8.         if( P1_0 == 0 ) //如果按键，则为低电平       
  9.         {    
  10.             delay20ms(); //延时20ms，跳过接下抖动       
  11.             keyPut( 6 ); //保存按键编号值为按键队列       
  12.             while( P1_0 == 0 ); //如果一直按着键，则不停地执行该循环，实际是等待松键       
  13.             delay20ms(); //延时20ms，跳过松开抖动       
  14.         }       
  15.         if( keyHit() != 0 ) //如果队列中有按键       
  16.             P2=Seg7Code[ keyGet() ]; //从队列中取出按键值，并显示在数码管上       
  17.     }       
  18. }       

例三：在例二中考虑干扰问题。即小于20ms的负脉冲干扰。
 
  1. #include <at89x52.h>       
  2. #include “KEY.H”       
  3. void main( void )       
  4. {    
  5.     P1_0 = 1;  //作为输入引脚，必须先输出高电平       
  6.     while( 1 ) //永远为真，即死循环       
  7.     {    
  8.         if( P1_0 == 0 ) //如果按键，则为低电平       
  9.         {    
  10.             delay20ms(); //延时20ms，跳过接下抖动       
  11.             if( P1_0 == 1 ) continue; //假按键       
  12.             keyPut( 6 ); //保存按键编号值为按键队列       
  13.             while( P1_0 == 0 ); //如果一直按着键，则不停地执行该循环，实际是等待松键       
  14.             delay20ms(); //延时20ms，跳过松开抖动       
  15.         }       
  16.         if( keyHit() != 0 ) //如果队列中有按键       
  17.             P2=Seg7Code[ keyGet() ]; //从队列中取出按键值，并显示在数码管上       
  18.     }       
  19. }      

例四：状态图编程法。通过20ms周期中断，扫描按键。
 
  1. /****************************************************************************************     
  2. 采用晶体为12KHz时，指令周期为1ms（即主频为1KHz），这样T0工作在定时器方式2，8位自动重载。计数值为20，即可产生20ms的周期性中断，在中断服务程序中实现按键扫描     
  3. *****************************************************************************************/      
  4. #include <at89x52.h>       
  5. #include “KEY.H”       
  6. void main( void )       
  7. {        
  8.     TMOD = (TMOD & 0xf0 ) | 0x02; //不改变T1的工作方式，T0为定时器方式2       
  9.     TH0 = -20;     //计数周期为20个主频脉，即20ms       
  10.     TL0=TH0;      //先软加载一次计数值       
  11.     TR0=1;      //允许T0开始计数       
  12.     ET0=1;      //允许T0计数溢出时产生中断请求       
  13.     EA=1;      //允许CPU响应中断请求       
  14.     while( 1 ) //永远为真，即死循环       
  15.     {       
  16.         if( keyHit() != 0 ) //如果队列中有按键       
  17.             P2=Seg7Code[ keyGet() ]; //从队列中取出按键值，并显示在数码管上       
  18.     }       
  19. }       
  20. void timer0int( void ) interrupt 1 //20ms；T0的中断号为1       
  21. {    
  22.     static unsigned char sts=0;       
  23.     P1_0 = 1;  //作为输入引脚，必须先输出高电平       
  24.     switch( sts )       
  25.     {       
  26.     case 0:    
  27.         if( P1_0==0 )    
  28.             sts=1;    
  29.         break; //按键则转入状态1       
  30.     case 1:       
  31.         if( P1_0==1 )    
  32.         {   
  33.             sts=0;  //假按错，或干扰，回状态0       
  34.         }   
  35.         else  
  36.         {    
  37.             sts=2; keyPut( 6 );    
  38.         } //确实按键，键值入队列，并转状态2       
  39.         break;       
  40.     case 2:    
  41.         if( P1_0==1 )    
  42.             sts=3;    
  43.         break; //如果松键，则转状态3       
  44.     case 3:       
  45.         if( P1_0==0 )   
  46.             sts=2;  //假松键，回状态2       
  47.         else sts=0;    //真松键，回状态0，等待下一次按键过程        
  48.     }       
  49. }       

例五：状态图编程法。
 
  1. /****************************************************************************************     
  2. 如果采用晶体为12MHz时，指令周期为1us（即主频为1MHz），要产生20ms左右的计时，则计数值达到20000，T0工作必须为定时器方式1，16位非自动重载，即可产生20ms的周期性中断，在中断服务程序中实现按键扫描     
  3. *****************************************************************************************/      
  4. #include <at89x52.h>       
  5. #include “KEY.H”       
  6. void main( void )       
  7. {        
  8.     TMOD = (TMOD & 0xf0 ) | 0x01; //不改变T1的工作方式，T0为定时器方式1       
  9.     TL0 = -20000;     //计数周期为20000个主频脉，自动取低8位       
  10.     TH0 = (-20000)>>8;    //右移8位，实际上是取高8位       
  11.     TR0=1;      //允许T0开始计数       
  12.     ET0=1;      //允许T0计数溢出时产生中断请求       
  13.     EA=1;      //允许CPU响应中断请求       
  14.     while( 1 ) //永远为真，即死循环       
  15.     {       
  16.         if( keyHit() != 0 ) //如果队列中有按键       
  17.             P2=Seg7Code[ keyGet() ]; //从队列中取出按键值，并显示在数码管上       
  18.     }       
  19. }       
  20. void timer0int( void ) interrupt 1 //20ms；T0的中断号为1       
  21. {    
  22.     static unsigned char sts=0;       
  23.     TL0 = -20000;     //方式1为软件重载       
  24.     TH0 = (-20000)>>8;    //右移8位，实际上是取高8位       
  25.     P1_0 = 1;  //作为输入引脚，必须先输出高电平       
  26.     switch( sts )       
  27.     {       
  28.     case 0:    
  29.         if( P1_0==0 )   
  30.             sts=1;    
  31.         break; //按键则转入状态1       
  32.     case 1:       
  33.         if( P1_0==1 )    
  34.         {   
  35.             sts=0;  //假按错，或干扰，回状态0      
  36.         }   
  37.         else  
  38.         {    
  39.             sts=2; keyPut( 6 );    
  40.         } //确实按键，键值入队列，并转状态2       
  41.         break;       
  42.     case 2:    
  43.         if( P1_0==1 )    
  44.             sts=3;    
  45.         break; //如果松键，则转状态3       
  46.     case 3:       
  47.         if( P1_0==0 )    
  48.             sts=2;  //假松键，回状态2       
  49.         else    
  50.             sts=0;    //真松键，回状态0，等待下一次按键过程        
  51.     }       
  52. }       

例六：4X4按键。
 
 
  1. /****************************************************************************************     
  2. 由P1端口的高4位和低4位构成4X4的矩阵键盘，本程序只认为单键操作为合法，同时按多键时无效。     
  3. 这样下面的X，Y的合法值为0x7, 0xb, 0xd, 0xe, 0xf，通过表keyCode影射变换可得按键值     
  4. *****************************************************************************************/      
  5. #include <at89x52.h>       
  6. #include “KEY.H”       
  7. unsigned char keyScan( void ) //返回0表示无按键，或无效按键，其它值为按键编码值       
  8. {    
  9.     code unsigned char keyCode[16]=       
  10.         //0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF       
  11.     { 0,   0,   0,   0,   0,   0,   0,   1,   0,   0,   0,   2,   0,   3,   4,   0 };        
  12.     unsigned char x, y, retVal;       
  13.     P1=0x0f;    //低四位输入，高四位输出0       
  14.     x=P1&0x0f;   //P1输入后，清高四位，作为X值       
  15.     P1=0xf0;    //高四位输入，低四位输出0       
  16.     y=(P1 >> 4) & 0x0f; //P1输入后移位到低四位，并清高四位，作为Y值       
  17.     retVal = keyCode[x]*4 + keyCode[y]; //根据本公式倒算按键编码       
  18.     if( retVal==0 )   
  19.         return(0);    
  20.     else    
  21.         return( retVal-4 );         
  22. }       
  23. //比如按键‘1’，得X=0x7，Y=0x7，算得retVal= 5，所以返回函数值1。       
  24. //双如按键‘7’，得X=0xb，Y=0xd，算得retVal=11，所以返回函数值7。       
  25. void main( void )       
  26. {        
  27.     TMOD = (TMOD & 0xf0 ) | 0x01; //不改变T1的工作方式，T0为定时器方式1       
  28.     TL0 = -20000;     //计数周期为20000个主频脉，自动取低8位       
  29.     TH0 = (-20000)>>8;    //右移8位，实际上是取高8位       
  30.     TR0=1;      //允许T0开始计数       
  31.     ET0=1;      //允许T0计数溢出时产生中断请求       
  32.     EA=1;      //允许CPU响应中断请求       
  33.     while( 1 ) //永远为真，即死循环       
  34.     {       
  35.         if( keyHit() != 0 ) //如果队列中有按键       
  36.             P2=Seg7Code[ keyGet() ]; //从队列中取出按键值，并显示在数码管上       
  37.     }       
  38. }       
  39. void timer0int( void ) interrupt 1 //20ms；T0的中断号为1       
  40. {    
  41.     static unsigned char sts=0;       
  42.     TL0 = -20000;     //方式1为软件重载       
  43.     TH0 = (-20000)>>8;    //右移8位，实际上是取高8位       
  44.     P1_0 = 1;  //作为输入引脚，必须先输出高电平       
  45.     switch( sts )       
  46.     {       
  47.     case 0:    
  48.         if( keyScan()!=0 )    
  49.             sts=1;    
  50.         break; //按键则转入状态1       
  51.     case 1:       
  52.         if( keyScan()==0 )    
  53.         {   
  54.             sts=0;  //假按错，或干扰，回状态0       
  55.         }   
  56.         else  
  57.         {    
  58.             sts=2;    
  59.             keyPut( keyScan() );    
  60.         } //确实按键，键值入队列，并转状态2       
  61.         break;       
  62.     case 2:    
  63.         if(keyScan()==0 )   
  64.             sts=3;   
  65.         break; //如果松键，则转状态3       
  66.     case 3:       
  67.         if( keyScan()!=0 )    
  68.             sts=2;  //假松键，回状态2       
  69.         else  
  70.             sts=0;    //真松键，回状态0，等待下一次按键过程        
  71.     }       
  72. }       
 
 
相关文章:

上一页 123456789 下一页
 
最新开源项目
 
 
  查看更多...  
 
本站相关产品   淘宝网店
 
 
  查看更多...  

 

本站程序由百合电子工作室开发和维护
Copyright @ baihe electric studio
渝ICP备09006681号-4