标题: STC15单片机—矩阵键盘程序的写法 [打印本页]
作者: Methadone    时间: 2020-6-23 10:58
标题: STC15单片机—矩阵键盘程序的写法
矩阵键盘Proteus仿真
一、Proteus仿真STC15的问题
> 据说P0口存在BUG,不会被正常拉低，而是产生短路。二、原理图1、CPU

2、矩阵键盘

3、显示部分


程序
一、矩阵键盘_单行扫描_普通写法
  1. #include<STC15.H>
  2. #include<intrins.h>

  4. #define uchar unsigned char
  5. #define uint unsigned int
  6. #define KeyBus P6    //定义矩阵键盘接口

  8. uchar Key_res =0;
  9. uchar i=0;

  11. void GPIO(void);    //IO口初始化函数
  12. void Delay10ms();                //@12.000MHz
  13. void Delay5ms();                //@12.000MHz
  14. void Delay1ms();          //@12.000MHz
  15. uchar Key16_Scan(void);//矩阵键盘扫描函数子程序
  16. void Key16_Function(void); //矩阵键盘服务(功能)子函数

  18. void main(void)
  19. {
  20.     GPIO();

  22.         while(1)
  23.         {
  24.                 Key_res =0;
  25.                 i=Key16_Scan();   //矩阵键盘扫描函数子程序
  26.         Key16_Function(); //矩阵键盘服务(功能)子函数
  27.         }
  28. }

  30. //-----------------------------------IO口初始化函数-----------------------------//
  31. void GPIO(void)
  32. {
  33.         P0M1=0;
  34.         P0M0=0;
  35.         P1M1=0;
  36.         P1M0=0;
  37.         P2M1=0;
  38.         P2M0=0;
  39.         P3M1=0;
  40.         P3M0=0;
  41.         P4M1=0;
  42.         P4M0=0;
  43.         P5M1=0;
  44.         P5M0=0;
  45. }

  47. //------------------------------------软件延时---------------------------------------//
  48. void Delay10ms()                //@12.000MHz
  49. {
  50.         unsigned char i, j;

  52.         i = 117;
  53.         j = 184;
  54.         do
  55.         {
  56.                 while (--j);
  57.         } while (--i);
  58. }

  60. void Delay5ms()                //@12.000MHz
  61. {
  62.         unsigned char i, j;

  64.         i = 59;
  65.         j = 90;
  66.         do
  67.         {
  68.                 while (--j);
  69.         } while (--i);
  70. }

  72. void Delay1ms()                //@12.000MHz
  73. {
  74.         unsigned char i, j;

  76.         i = 12;
  77.         j = 169;
  78.         do
  79.         {
  80.                 while (--j);
  81.         } while (--i);
  82. }



  86. //---------------------------------------矩阵键盘扫描函数子程序-------------------------//

  88. uchar Key16_Scan(void)
  89. {
  90.         uchar temp = 0;
  91.         uchar Key_res = 0;
  92.         
  93.     KeyBus = 0XFF;        
  94.         KeyBus = 0X7F;         //0111 1111 扫描第一行
  95.          temp=KeyBus;
  96.         temp=temp&0X0F;
  97.         if(temp!=0X0F)
  98.         {
  99.           Delay10ms();   //按键消抖
  100.           temp=KeyBus;
  101.           temp=temp&0X0F;
  102.           if(temp!=0X0F)
  103.                 {
  104.                         temp=temp&0X0F;
  105.                         switch(temp)
  106.                         {
  107.                                 case 0X0E: Key_res=16;break;
  108.                                 case 0X0D: Key_res=15;break;
  109.                                 case 0X0B: Key_res=14;break;
  110.                                 case 0X07: Key_res=13;break;
  111.                                 default: break;
  112.                         }
  113.                         while(temp!=0X0F)     //松手检测
  114.                         {
  115.                                 temp=KeyBus;
  116.                                 temp=temp&0X0F;
  117.                         }        
  118.                 }
  119.         }
  120.         
  121.         KeyBus = 0XFF;
  122.         KeyBus = 0XBF;         //1011 1111  扫描第二行
  123.          temp=KeyBus;
  124.         temp=temp&0X0F;
  125.         if(temp!=0X0F)
  126.         {
  127.           Delay10ms();
  128.           temp=KeyBus;
  129.           temp=temp&0X0F;
  130.           if(temp!=0X0F)
  131.                 {
  132.                         temp=temp&0X0F;
  133.                         switch(temp)
  134.                         {
  135.                                 case 0X0E: Key_res=12;break;
  136.                                 case 0X0D: Key_res=11;break;
  137.                                 case 0X0B: Key_res=10;break;
  138.                                 case 0X07: Key_res=9;break;
  139.                                 default: break;
  140.                         }
  141.                         while(temp!=0X0F)     //松手检测
  142.                         {
  143.                                 temp=KeyBus;
  144.                                 temp=temp&0X0F;
  145.                         }        
  146.                 }
  147.         }

  149.         KeyBus = 0XFF;        
  150.         KeyBus = 0XDF;         //1101 1111  扫描第三行
  151.          temp=KeyBus;
  152.         temp=temp&0X0F;
  153.         if(temp!=0X0F)
  154.         {
  155.           Delay10ms();
  156.           temp=KeyBus;
  157.           temp=temp&0X0F;
  158.           if(temp!=0X0F)
  159.                 {
  160.                         temp=temp&0X0F;
  161.                         switch(temp)
  162.                         {
  163.                                 case 0X0E: Key_res=8;break;
  164.                                 case 0X0D: Key_res=7;break;
  165.                                 case 0X0B: Key_res=6;break;
  166.                                 case 0X07: Key_res=5;break;
  167.                                 default: break;
  168.                         }
  169.                         while(temp!=0X0F)    //松手检测
  170.                         {
  171.                                 temp=KeyBus;
  172.                                 temp=temp&0X0F;
  173.                         }        
  174.                 }
  175.         }

  177.         KeyBus = 0XFF;        
  178.         KeyBus = 0XEF;         //1110 1111  扫描第四行
  179.          temp=KeyBus;
  180.         temp=temp&0X0F;
  181.         if(temp!=0X0F)
  182.         {
  183.           Delay10ms();
  184.           temp=KeyBus;
  185.           temp=temp&0X0F;
  186.           if(temp!=0X0F)
  187.                 {
  188.                         temp=temp&0X0F;
  189.                         switch(temp)
  190.                         {
  191.                                 case 0X0E: Key_res=4;break;
  192.                                 case 0X0D: Key_res=3;break;
  193.                                 case 0X0B: Key_res=2;break;
  194.                                 case 0X07: Key_res=1;break;
  195.                                 default: break;
  196.                         }
  197.                         while(temp!=0X0F)     //松手检测
  198.                         {
  199.                                 temp=KeyBus;
  200.                                 temp=temp&0X0F;
  201.                         }        
  202.                 }
  203.         }
  204.         return Key_res;
  205. }


  208. //-----------------------------------矩阵键盘服务(功能)子函数-------------------//
  209. void Key16_Function(void)
  210. {
  211.         if(i != 0)
  212.                 {
  213.                         switch(i)
  214.                         {
  215.                           case  1: P1=0XFE;P2=0XFF;break;
  216.                           case  2: P1=0XFD;P2=0XFF;break;
  217.                       case  3: P1=0XFB;P2=0XFF;break;
  218.                       case  4: P1=0XF7;P2=0XFF;break;
  219.                           case  5: P1=0XEF;P2=0XFF;break;
  220.                           case  6: P1=0XDF;P2=0XFF;break;
  221.                           case  7: P1=0XBF;P2=0XFF;break;
  222.                           case  8: P1=0X7F;P2=0XFF;break;
  223.                           case  9: P1=0XFF;P2=0XFE;break;
  224.                           case 10: P1=0XFF;P2=0XFD;break;
  225.                           case 11: P1=0XFF;P2=0XFB;break;
  226.                           case 12: P1=0XFF;P2=0XF7;break;
  227.                           case 13: P1=0XFF;P2=0XEF;break;
  228.                           case 14: P1=0XFF;P2=0XDF;break;
  229.                           case 15: P1=0XFF;P2=0XBF;break;
  230.                           case 16: P1=0XFF;P2=0X7F;break;
  231.                           default:P1=0X00;P2=0X00;break;
  232.                         }
  233.         }
  234. }
复制代码
二、矩阵键盘_单行扫描_外部中断

(代码未能实现，改进ing)


  1. #include<STC15.H>
  2. #include<intrins.h>


  5. #define uchar unsigned char
  6. #define uint unsigned int
  7. #define KeyBus P6    //定义矩阵键盘接口

  9. uchar Key_res =0;
  10. uchar i=0;

  12. void GPIO(void);    //IO口初始化函数
  13. void Delay10ms();                //@12.000MHz
  14. void Delay5ms();                //@12.000MHz
  15. void Delay1ms();          //@12.000MHz
  16. void INT1_INIT(void);    //外部中断1初始化函数
  17. uchar Key16_Scan(void);//矩阵键盘扫描函数子程序
  18. void Key16_Function(void); //矩阵键盘服务(功能)子函数

  20. void main(void)
  21. {
  22.   GPIO();
  23.   INT1_INIT();
  24.         while(1)
  25.         {
  26.            KeyBus=0X0F;               
  27.        Key16_Function(); //矩阵键盘服务(功能)子函数
  28.         }
  29. }

  31. //-----------------------------------IO口初始化函数-----------------------------//
  32. void GPIO(void)
  33. {
  34.         P0M1=0;
  35.         P0M0=0;
  36.         P1M1=0;
  37.         P1M0=0;
  38.         P2M1=0;
  39.         P2M0=0;
  40.         P3M1=0;
  41.         P3M0=0;
  42.         P4M1=0;
  43.         P4M0=0;
  44.         P5M1=0;
  45.         P5M0=0;

  47. }

  49. //------------------------------------软件延时---------------------------------------//
  50. void Delay10ms()                //@12.000MHz
  51. {
  52.         unsigned char i, j;

  54.         i = 117;
  55.         j = 184;
  56.         do
  57.         {
  58.                 while (--j);
  59.         } while (--i);
  60. }

  62. void Delay5ms()                //@12.000MHz
  63. {
  64.         unsigned char i, j;

  66.         i = 59;
  67.         j = 90;
  68.         do
  69.         {
  70.                 while (--j);
  71.         } while (--i);
  72. }

  74. void Delay1ms()                //@12.000MHz
  75. {
  76.         unsigned char i, j;

  78.         i = 12;
  79.         j = 169;
  80.         do
  81.         {
  82.                 while (--j);
  83.         } while (--i);
  84. }

  86. //---------------------------------------外部中断1初始化函数-----------------------------//
  87. void INT1_INIT(void)
  88. {
  89.         IT1=1;
  90.         EX1=1;
  91.   EA=1;

  93. }

  95. //---------------------------------------矩阵键盘扫描函数子程序-------------------------//

  97. uchar Key16_Scan(void)
  98. {
  99.         uchar temp = 0;
  100.         uchar Key_res = 0;
  101.         
  102.     KeyBus = 0XFF;        
  103.         KeyBus = 0X7F;         //0111 1111
  104.          temp=KeyBus;
  105.         temp=temp&0X0F;
  106.         if(temp!=0X0F)
  107.         {
  108.           Delay10ms();
  109.           temp=KeyBus;
  110.           temp=temp&0X0F;
  111.           if(temp!=0X0F)
  112.                 {
  113.                         temp=temp&0X0F;
  114.                         switch(temp)
  115.                         {
  116.                                 case 0X0E: Key_res=16;break;
  117.                                 case 0X0D: Key_res=15;break;
  118.                                 case 0X0B: Key_res=14;break;
  119.                                 case 0X07: Key_res=13;break;
  120.                                 default: break;
  121.                         }
  122.                         while(temp!=0X0F)     //松手检测
  123.                         {
  124.                                 temp=KeyBus;
  125.                                 temp=temp&0X0F;
  126.                         }        
  127.                 }
  128.         }
  129.         
  130.         KeyBus = 0XFF;
  131.         KeyBus = 0XBF;         //1011 1111
  132.          temp=KeyBus;
  133.         temp=temp&0X0F;
  134.         if(temp!=0X0F)
  135.         {
  136.           Delay10ms();
  137.           temp=KeyBus;
  138.           temp=temp&0X0F;
  139.           if(temp!=0X0F)
  140.                 {
  141.                         temp=temp&0X0F;
  142.                         switch(temp)
  143.                         {
  144.                                 case 0X0E: Key_res=12;break;
  145.                                 case 0X0D: Key_res=11;break;
  146.                                 case 0X0B: Key_res=10;break;
  147.                                 case 0X07: Key_res=9;break;
  148.                                 default: break;
  149.                         }
  150.                         while(temp!=0X0F)     //松手检测
  151.                         {
  152.                                 temp=KeyBus;
  153.                                 temp=temp&0X0F;
  154.                         }        
  155.                 }
  156.         }

  158.         KeyBus = 0XFF;        
  159.         KeyBus = 0XDF;         //1101 1111
  160.          temp=KeyBus;
  161.         temp=temp&0X0F;
  162.         if(temp!=0X0F)
  163.         {
  164.           Delay10ms();
  165.       temp=KeyBus;
  166.           temp=temp&0X0F;
  167.           if(temp!=0X0F)
  168.                 {
  169.                         temp=temp&0X0F;
  170.                         switch(temp)
  171.                         {
  172.                                 case 0X0E: Key_res=8;break;
  173.                                 case 0X0D: Key_res=7;break;
  174.                                 case 0X0B: Key_res=6;break;
  175.                                 case 0X07: Key_res=5;break;
  176.                                 default: break;
  177.                         }
  178.                         while(temp!=0X0F)    //松手检测
  179.                         {
  180.                                 temp=KeyBus;
  181.                                 temp=temp&0X0F;
  182.                         }        
  183.                 }
  184.         }

  186.         KeyBus = 0XFF;        
  187.         KeyBus = 0XEF;         //1110 1111
  188.          temp=KeyBus;
  189.         temp=temp&0X0F;
  190.         if(temp!=0X0F)
  191.         {
  192.       Delay10ms();
  193.           temp=KeyBus;
  194.           temp=temp&0X0F;
  195.           if(temp!=0X0F)
  196.                 {
  197.                         temp=temp&0X0F;
  198.                         switch(temp)
  199.                         {
  200.                                 case 0X0E: Key_res=4;break;
  201.                                 case 0X0D: Key_res=3;break;
  202.                                 case 0X0B: Key_res=2;break;
  203.                                 case 0X07: Key_res=1;break;
  204.                                 default: break;
  205.                         }
  206.                         while(temp!=0X0F)     //松手检测
  207.                         {
  208.                                 temp=KeyBus;
  209.                                 temp=temp&0X0F;
  210.                         }        
  211.                 }
  212.         }
  213.         return Key_res;
  214. }

  216. //--------------------------------------外部中断1服务函数-----------------------------//
  217. void INT1_ISR() interrupt 2
  218. {
  219.                 i = Key16_Scan();   //矩阵键盘扫描函数子程序
  220. }



  224. //-----------------------------------矩阵键盘服务(功能)子函数-------------------//
  225. void Key16_Function(void)
  226. {
  227.         if(i != 0)
  228.                 {
  229.                         switch(i)
  230.                         {
  231.                           case  1: P1=0XFE;P2=0XFF;break;
  232.                           case  2: P1=0XFD;P2=0XFF;break;
  233.                       case  3: P1=0XFB;P2=0XFF;break;
  234.                       case  4: P1=0XF7;P2=0XFF;break;
  235.                           case  5: P1=0XEF;P2=0XFF;break;
  236.                           case  6: P1=0XDF;P2=0XFF;break;
  237.                           case  7: P1=0XBF;P2=0XFF;break;
  238.                           case  8: P1=0X7F;P2=0XFF;break;
  239.                           case  9: P1=0XFF;P2=0XFE;break;
  240.                           case 10: P1=0XFF;P2=0XFD;break;
  241.                           case 11: P1=0XFF;P2=0XFB;break;
  242.                           case 12: P1=0XFF;P2=0XF7;break;
  243.                           case 13: P1=0XFF;P2=0XEF;break;
  244.                           case 14: P1=0XFF;P2=0XDF;break;
  245.                           case 15: P1=0XFF;P2=0XBF;break;
  246.                           case 16: P1=0XFF;P2=0X7F;break;
  247.                           default:P1=0X00;P2=0X00;break;
  248.                         }
  249.         }
  250. }

复制代码


三、矩阵键盘_多行扫描_普通写法
  1. #include<STC15.H>
  2. #include<intrins.h>

  4. #define uchar unsigned char
  5. #define uint unsigned int
  6. #define KeyBus P6    //定义矩阵键盘接口

  8. uchar Key_res =0;
  9. uchar i=0;

  11. void GPIO(void);    //IO口初始化函数
  12. void Delay10ms();                //@12.000MHz
  13. void Delay5ms();                //@12.000MHz
  14. void Delay1ms();          //@12.000MHz
  15. uchar Key16_Scan(void);//矩阵键盘扫描函数子程序
  16. void Key16_Function(void); //矩阵键盘服务(功能)子函数

  18. void main(void)
  19. {
  20.   GPIO();    //IO口初始化函数

  22.         while(1)
  23.         {
  24.                 Key_res =0;
  25.                 i=Key16_Scan();   //矩阵键盘扫描函数子程序
  26.     Key16_Function(); //矩阵键盘服务(功能)子函数
  27.         }
  28. }

  30. //-----------------------------------IO口初始化函数-----------------------------//
  31. void GPIO(void)
  32. {
  33.         P0M1=0;
  34.         P0M0=0;
  35.         P1M1=0;
  36.         P1M0=0;
  37.         P2M1=0;
  38.         P2M0=0;
  39.         P3M1=0;
  40.         P3M0=0;
  41.         P4M1=0;
  42.         P4M0=0;
  43.         P5M1=0;
  44.         P5M0=0;

  46. }

  48. //------------------------------------软件延时---------------------------------------//
  49. void Delay10ms()                //@12.000MHz
  50. {
  51.         unsigned char i, j;

  53.         i = 117;
  54.         j = 184;
  55.         do
  56.         {
  57.                 while (--j);
  58.         } while (--i);
  59. }

  61. void Delay5ms()                //@12.000MHz
  62. {
  63.         unsigned char i, j;

  65.         i = 59;
  66.         j = 90;
  67.         do
  68.         {
  69.                 while (--j);
  70.         } while (--i);
  71. }

  73. void Delay1ms()                //@12.000MHz
  74. {
  75.         unsigned char i, j;

  77.         i = 12;
  78.         j = 169;
  79.         do
  80.         {
  81.                 while (--j);
  82.         } while (--i);
  83. }



  87. //---------------------------------------矩阵键盘扫描函数子程序-------------------------//

  89. uchar Key16_Scan(void)
  90. {
  91.         uchar X_temp = 0,Y_temp = 0;
  92.         uchar Key_down = 0;
  93.         
  94.         KeyBus = 0XFF;        
  95.         KeyBus = 0X0F;        //高4位置0，低4位置1，此时有按键按下时，低四位的某一位会被拉低，由此定位按下的按键在第几列
  96.         Y_temp = KeyBus&0X0F;
  97.         
  98.         if(Y_temp!=0X0F)        //如果检测到某列有按键按下（有按键按下时，低四位会有一位被拉低）
  99.         {
  100.                 Delay5ms();    //按键消抖(不知道有无必要)
  101.                 KeyBus = 0X0F;         
  102.             Y_temp = KeyBus&0X0F;//将KeyBus低四位的按键信息赋值给Y_temp
  103.                 if(Y_temp!=0X0F)
  104.                 {
  105.                         KeyBus = 0X0F;
  106.                         Y_temp = KeyBus&0X0F;  //将KeyBus低四位的按键信息赋值给Y_temp,反应列信息
  107.                         KeyBus = 0XF0;
  108.                         X_temp = KeyBus&0XF0;  //将KeyBus高四位的按键信息赋值给X_temp,反应行信息
  109.                         if(Key_down == 0)      //按键抬起检测，        
  110.                         {
  111.                           switch(Y_temp)    //判断列
  112.                           {
  113.                                   case 0X07: Key_res=1; break;
  114.                                   case 0X0B: Key_res=2; break;
  115.                                   case 0X0D: Key_res=3; break;
  116.                                   case 0X0E: Key_res=4; break;
  117.                                   default: return 0;    //无按键按下，返回0
  118.                           }
  119.                          switch(X_temp)    //判断行
  120.                           {
  121.                                 case 0X70: return Key_res+12;break;
  122.                              case 0XB0: return Key_res+ 8;break;
  123.                 case 0XD0: return Key_res+ 4;break;
  124.                 case 0XE0: return Key_res;   break;
  125.                 default: return 0;         //无按键按下，返回0        
  126.                          }
  127.                  }
  128.          }
  129.         }
  130.         else
  131.                 Key_down = 0;        //按键被松开
  132.         
  133.         if(Key_res)
  134.                 Key_down = 1;        //标志按键被按下，防止重入

  136.         return Key_res;
  137. }
  138.    

  140. //-----------------------------------矩阵键盘服务(功能)子函数-------------------//
  141. void Key16_Function(void)
  142. {
  143.         if(i != 0)    //按键按下
  144.                 {
  145.                         switch(i)
  146.                         {
  147.                           case  1: P1=0XFE;P2=0XFF;break;
  148.                           case  2: P1=0XFD;P2=0XFF;break;
  149.                       case  3: P1=0XFB;P2=0XFF;break;
  150.                       case  4: P1=0XF7;P2=0XFF;break;
  151.                           case  5: P1=0XEF;P2=0XFF;break;
  152.                           case  6: P1=0XDF;P2=0XFF;break;
  153.                           case  7: P1=0XBF;P2=0XFF;break;
  154.                           case  8: P1=0X7F;P2=0XFF;break;
  155.                           case  9: P1=0XFF;P2=0XFE;break;
  156.                           case 10: P1=0XFF;P2=0XFD;break;
  157.                           case 11: P1=0XFF;P2=0XFB;break;
  158.                           case 12: P1=0XFF;P2=0XF7;break;
  159.                           case 13: P1=0XFF;P2=0XEF;break;
  160.                           case 14: P1=0XFF;P2=0XDF;break;
  161.                           case 15: P1=0XFF;P2=0XBF;break;
  162.                           case 16: P1=0XFF;P2=0X7F;break;
  163.                           default:P1=0X00;P2=0X00;break;
  164.                         }
  165.         }
  166. }
复制代码



四、矩阵键盘_多行扫描_外部中断

(仅能检测到列，检测不到行，改进ing)


  1. #include<STC15.H>
  2. #include<intrins.h>

  4. #define uchar unsigned char
  5. #define uint unsigned int
  6. #define KeyBus P6    //定义矩阵键盘接口

  8. uchar Key_res =0;
  9. uchar i=0;

  11. void GPIO(void);    //IO口初始化函数
  12. void Delay10ms();                //@12.000MHz
  13. void Delay5ms();                //@12.000MHz
  14. void Delay1ms();          //@12.000MHz
  15. void INT1_INIT(void); //外部中断1初始化函数
  16. uchar Key16_Scan(void);//矩阵键盘扫描函数子程序
  17. void Key16_Function(void); //矩阵键盘服务(功能)子函数

  19. void main(void)
  20. {
  21.    GPIO();    //IO口初始化函数
  22.    INT1_INIT();
  23.         while(1)
  24.         {
  25.           KeyBus = 0X0F;
  26.       Key16_Function(); //矩阵键盘服务(功能)子函数
  27.         }
  28. }

  30. //-----------------------------------IO口初始化函数-----------------------------//
  31. void GPIO(void)
  32. {
  33.         P0M1=0;
  34.         P0M0=0;
  35.         P1M1=0;
  36.         P1M0=0;
  37.         P2M1=0;
  38.         P2M0=0;
  39.         P3M1=0;
  40.         P3M0=0;
  41.         P4M1=0;
  42.         P4M0=0;
  43.         P5M1=0;
  44.         P5M0=0;

  46. }

  48. //------------------------------------软件延时---------------------------------------//
  49. void Delay10ms()                //@12.000MHz
  50. {
  51.         unsigned char i, j;

  53.         i = 117;
  54.         j = 184;
  55.         do
  56.         {
  57.                 while (--j);
  58.         } while (--i);
  59. }

  61. void Delay5ms()                //@12.000MHz
  62. {
  63.         unsigned char i, j;

  65.         i = 59;
  66.         j = 90;
  67.         do
  68.         {
  69.                 while (--j);
  70.         } while (--i);
  71. }

  73. void Delay1ms()                //@12.000MHz
  74. {
  75.         unsigned char i, j;

  77.         i = 12;
  78.         j = 169;
  79.         do
  80.         {
  81.                 while (--j);
  82.         } while (--i);
  83. }

  85. //---------------------------------------外部中断1初始化函数-----------------------------//
  86. void INT1_INIT(void)
  87. {
  88.         IT1=1;
  89.         EX1=1;
  90.     EA=1;

  92. }

  94. //---------------------------------------矩阵键盘扫描函数子程序-------------------------//

  96. uchar Key16_Scan(void)
  97. {

  99.         uchar X_temp = 0,Y_temp = 0;
  100.         uchar Key_down = 0;
  101.         
  102.         KeyBus = 0XFF;        
  103.         KeyBus = 0X0F;        //高4位置0，低4位置1，此时有按键按下时，低四位的某一位会被拉低，由此定位按下的按键在第几列
  104.         Y_temp = KeyBus&0X0F;
  105.         
  106.         if(Y_temp!=0X0F)        //如果检测到某列有按键按下（有按键按下时，低四位会有一位被拉低）
  107.         {
  108.                 Delay1ms();    //按键消抖(不知道有无必要)
  109.                 KeyBus = 0X0F;         
  110.             Y_temp = KeyBus&0X0F;//将KeyBus低四位的按键信息赋值给Y_temp
  111.                 if(Y_temp!=0X0F)
  112.                 {
  113.                         KeyBus = 0X0F;
  114.                         Y_temp = KeyBus&0X0F;  //将KeyBus低四位的按键信息赋值给Y_temp,反应列信息
  115.                         KeyBus = 0XF0;
  116.                         X_temp = KeyBus&0XF0;  //将KeyBus高四位的按键信息赋值给X_temp,反应行信息
  117.                         if(Key_down == 0)      //按键抬起检测，        
  118.                         {
  119.                           switch(Y_temp)    //判断列
  120.                           {
  121.                                   case 0X07: Key_res=1; break;
  122.                                   case 0X0B: Key_res=2; break;
  123.                                   case 0X0D: Key_res=3; break;
  124.                                   case 0X0E: Key_res=4; break;
  125.                                   default: return 0;    //无按键按下，返回0
  126.                           }
  127.                          switch(X_temp)    //判断行
  128.                           {
  129.                                 case 0X70: return Key_res+12;break;
  130.                                    case 0XB0: return Key_res+ 8;break;
  131.                 case 0XD0: return Key_res+ 4;break;
  132.                 case 0XE0: return Key_res;   break;
  133.                 default: return 0;         //无按键按下，返回0        
  134.                          }
  135.                  }
  136.          }
  137.         }
  138.         else
  139.                 Key_down = 0;        //按键被松开
  140.         
  141.         if(Key_res)
  142.                 Key_down = 1;        //标志按键被按下，防止重入

  144.         return Key_res;
  145. }
  146.    
  147. //--------------------------------------外部中断1服务函数-----------------------------//
  148. void INT1_ISR() interrupt 2
  149. {
  150.                 i = Key16_Scan();   //矩阵键盘扫描函数子程序
  151. }

  153. //-----------------------------------矩阵键盘服务(功能)子函数-------------------//
  154. void Key16_Function(void)
  155. {
  156.         EX1=0;
  157.         if(i != 0)    //按键按下
  158.                 {
  159.                         switch(i)
  160.                         {
  161.                           case  1: P1=0XFE;P2=0XFF;break;
  162.                           case  2: P1=0XFD;P2=0XFF;break;
  163.                       case  3: P1=0XFB;P2=0XFF;break;
  164.                       case  4: P1=0XF7;P2=0XFF;break;
  165.                           case  5: P1=0XEF;P2=0XFF;break;                                    
  166.                           case  6: P1=0XDF;P2=0XFF;break;
  167.                           case  7: P1=0XBF;P2=0XFF;break;
  168.                           case  8: P1=0X7F;P2=0XFF;break;
  169.                           case  9: P1=0XFF;P2=0XFE;break;
  170.                           case 10: P1=0XFF;P2=0XFD;break;
  171.                           case 11: P1=0XFF;P2=0XFB;break;
  172.                           case 12: P1=0XFF;P2=0XF7;break;
  173.                           case 13: P1=0XFF;P2=0XEF;break;
  174.                           case 14: P1=0XFF;P2=0XDF;break;
  175.                           case 15: P1=0XFF;P2=0XBF;break;
  176.                           case 16: P1=0XFF;P2=0X7F;break;
  177.                           default:P1=0X00;P2=0X00;break;
  178.                         }
  179.         }
  180.         EX1=1;
  181. }

复制代码





欢迎光临 (http://www.51hei.com/bbs/) Powered by Discuz! X3.1