关于单片机阵列按钮的检测问题

看到郭天祥新概念51单片机C语言教程的按钮阵列时，我完全被弄晕了，先上代码

我写的是用键盘阵列去改变P3管脚的电平，通过电平的改变去改变P2管脚从而驱动LED小灯，功能都实现了，但是我现在唯一搞不懂的地方就是检测矩阵键盘的地方

1. 比如说我现在已经按下了矩阵键盘第2行的第2列，那么这个时候P3管脚的电平应该是11011101也就是0xDD

复制代码

哪位大神帮小弟解决一下这个问题啊，这个问题已经困扰我两天了

1. #include <reg52.h>
   
2. 
   
3. #define uchar unsigned char
   
4. #define uint  unsigned int
   
5.         
   
6. uchar key;
   
7. 
   
8. 
   
9. void delayms(uint xms) {
   
10.         uint i, j;
    
11.         for(i = xms; i > 0; i--)
    
12.                 for(j = 110; j > 0; j--);
    
13. }
    
14. 
    
15. void matrixKeyScan() {
    
16.         
    
17.         uchar _temp;
    
18.         
    
19.         //检测第一行
    
20.         P3    = 0xFE;
    
21.         _temp = P3;
    
22.         _temp = _temp & 0xF0;
    
23.         if(_temp != 0xF0){
    
24.                 delayms(10);
    
25.                 _temp = P3;
    
26.                 _temp = _temp & 0xF0;
    
27.                 if(_temp != 0xF0){
    
28.                         _temp = P3;
    
29.                         switch(_temp) {
    
30.                                 case 0xEE:
    
31.                                         key = 0;
    
32.                                         break;
    
33.                                 case 0xDE:
    
34.                                         key = 1;
    
35.                                         break;
    
36.                                 case 0xBE:
    
37.                                         key = 2;
    
38.                                         break;
    
39.                                 case 0x7E:
    
40.                                         key = 3;
    
41.                                         break;
    
42.                         }
    
43.                         while(_temp != 0xF0){
    
44.                                 _temp = P3;
    
45.                                 _temp = _temp & 0xF0;
    
46.                         }
    
47.                 }
    
48.         }
    
49.         
    
50.         //检测第二行
    
51.         P3 = 0xFD;
    
52.         _temp = P3;
    
53.         _temp = _temp & 0xF0;
    
54.         if(_temp != 0xF0){
    
55.                 delayms(10);
    
56.                 _temp = P3;
    
57.                 _temp = _temp & 0xF0;
    
58.                 if(_temp != 0xF0){
    
59.                         _temp = P3;
    
60.                         switch(_temp) {
    
61.                                 case 0xED:
    
62.                                         key = 4;
    
63.                                         break;
    
64.                                 case 0xDD:
    
65.                                         key = 5;
    
66.                                         break;
    
67.                                 case 0xBD:
    
68.                                         key = 6;
    
69.                                         break;
    
70.                                 case 0x7D:
    
71.                                         key = 7;
    
72.                                         break;
    
73.                         }
    
74.                         while(_temp != 0xF0){
    
75.                                 _temp = P3;
    
76.                                 _temp = _temp & 0xF0;
    
77.                         }
    
78.                 }
    
79.         }
    
80.         
    
81.         //检测第三行
    
82.         P3 = 0xFB;
    
83.         _temp = P3;
    
84.         _temp = _temp & 0xF0;
    
85.         if(_temp != 0xF0){
    
86.                 delayms(10);
    
87.                 _temp = P3;
    
88.                 _temp = _temp & 0xF0;
    
89.                 if(_temp != 0xF0){
    
90.                         _temp = P3;
    
91.                         switch(_temp) {
    
92.                                 case 0xEB:
    
93.                                         key = 8;
    
94.                                         break;
    
95.                                 case 0xDB:
    
96.                                         key = 9;
    
97.                                         break;
    
98.                                 case 0xBB:
    
99.                                         key = 10;
    
100.                                         break;
     
101.                                 case 0x7B:
     
102.                                         key = 11;
     
103.                                         break;
     
104.                         }
     
105.                         while(_temp != 0xF0){
     
106.                                 _temp = P3;
     
107.                                 _temp = _temp & 0xF0;
     
108.                         }
     
109.                 }
     
110.         }
     
111.         
     
112.         //检测第四行
     
113.         P3 = 0xF7;
     
114.         _temp = P3;
     
115.         _temp = _temp & 0xF0;
     
116.         if(_temp != 0xF0){
     
117.                 delayms(10);
     
118.                 _temp = P3;
     
119.                 _temp = _temp & 0xF0;
     
120.                 if(_temp != 0xF0){
     
121.                         _temp = P3;
     
122.                         switch(_temp) {
     
123.                                 case 0xE7:
     
124.                                         key = 12;
     
125.                                         break;
     
126.                                 case 0xD7:
     
127.                                         key = 13;
     
128.                                         break;
     
129.                                 case 0xB7:
     
130.                                         key = 14;
     
131.                                         break;
     
132.                                 case 0x77:
     
133.                                         key = 15;
     
134.                                         break;
     
135.                         }
     
136.                         while(_temp != 0xF0){
     
137.                                 _temp = P3;
     
138.                                 _temp = _temp & 0xF0;
     
139.                         }
     
140.                 }
     
141.         }
     
142.         
     
143. }
     
144. 
     
145. 
     
146. void main() {
     
147.         
     
148.         key = 99;
     
149.         
     
150.         while(1) {
     
151.                 matrixKeyScan();
     
152.                
     
153.                 switch(key) {
     
154.                         case 0:
     
155.                                 P2 = 0xFE;
     
156.                                 break;
     
157.                         case 1:
     
158.                                 P2 = 0xFD;
     
159.                                 break;
     
160.                         case 2:
     
161.                                 P2 = 0xFB;
     
162.                                 break;
     
163.                         case 3:
     
164.                                 P2 = 0xF7;
     
165.                                 break;
     
166.                         case 4:
     
167.                                 P2 = 0xEF;
     
168.                                 break;
     
169.                         case 5:
     
170.                                 P2 = 0xDF;
     
171.                                 break;
     
172.                         case 6:
     
173.                                 P2 = 0xBF;
     
174.                                 break;
     
175.                         case 7:
     
176.                                 P2 = 0x7F;
     
177.                 }
     
178.         }
     
179. 
     
180. }

复制代码

给你一个例子程序吧，比你的程序好、实用。
/*
本实例为矩阵键盘的实验
1、按不同的键，显示所按的键的数字。其实主要是实验出按的哪个键，程序判断对不对
   完全可以通过按键执行其它任务
2、矩阵键盘得到所按哪个键的过程相对复杂一点，注意理解。
*/

#include<reg51.h>

#define GPIO_DIG P0//数码管
#define GPIO_KEY P1//矩阵键盘

sbit LSA=P2^2;//数码管位码CBA分别为000第一位，001第二位，010第三位
sbit LSB=P2^3;//                   011第四位，100第五位，101第六位
sbit LSC=P2^4;//                                   110第七位，111第八位

unsigned char code DIG_CODE[17]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,
0x77,0x7c,0x39,0x5e,0x79,0x71};//0、1、2、3、4、5、6、7、8、9、A、b、C、d、E、F的显示码

unsigned char KeyValue;//用来存放读取到的键值

bit KeyState;        //记录按键的状态，0没有，1有

unsigned char DisplayData[8];//用来存放要显示的8位数的值，一个管分配一个数组

void Delay10ms();   //延时10ms
void KeyDown();                 //检测按键函数
void DigDisplay(); //动态显示函数

void main(void)
{
        KeyState=0;//初始化按键
        while(1)
        {
                KeyDown();//检测按键
                 if(KeyState==1)//有键按下才执行
                {
                        DisplayData[7]=DisplayData[6];//显示的内容左移一位
                        DisplayData[6]=DisplayData[5];
                        DisplayData[5]=DisplayData[4];
                        DisplayData[4]=DisplayData[3];
                        DisplayData[3]=DisplayData[2];
                        DisplayData[2]=DisplayData[1];
                        DisplayData[1]=DisplayData[0];
                        DisplayData[0]=DIG_CODE[KeyValue];
                       
                        KeyState=0;//显示完毕要初始化
                }
                DigDisplay();//显示
        }                               
}
/*******************************************************************************
* 函 数 名         : DigDisplay
* 函数功能                   : 使用数码管显示
* 输    入         : 无
* 输    出         : 无
*******************************************************************************/
void DigDisplay()
{
        unsigned char i;
        unsigned int j;
        for(i=0;i<8;i++)//只有8个数码管
        {
                switch(i)         //位选，选择点亮的数码管，
                {
                        case(0):
                                LSA=0;LSB=0;LSC=0; break;//显示第0位
                        case(1):
                                LSA=1;LSB=0;LSC=0; break;//显示第1位
                        case(2):
                                LSA=0;LSB=1;LSC=0; break;//显示第2位
                        case(3):
                                LSA=1;LSB=1;LSC=0; break;//显示第3位
                        case(4):
                                LSA=0;LSB=0;LSC=1; break;//显示第4位
                        case(5):
                                LSA=1;LSB=0;LSC=1; break;//显示第5位
                        case(6):
                                LSA=0;LSB=1;LSC=1; break;//显示第6位
                        case(7):
                                LSA=1;LSB=1;LSC=1; break;//显示第7位       
                }
                GPIO_DIG=DisplayData[i];//发送段码
                j=10;                                                 //扫描间隔时间设定
                while(j--);       
                GPIO_DIG=0x00;//消隐
        }
}
/*******************************************************************************
* 函 数 名         : KeyDown
* 函数功能                   : 检测有按键按下并读取键值
* 输    入         : 无
* 输    出         : 无
*******************************************************************************/
void KeyDown(void)//其实最简单的就是逐行扫描，就不难懂了。这里的行列扫描法有点
                                  //难理解，程序也复杂。
{
        unsigned char a=0;
        GPIO_KEY=0x0f;//测试列
        if(GPIO_KEY!=0x0f)
        {
                Delay10ms();//此处按键消抖，不可在测试列之后，那样显示时间不对，亮度很小
                if(GPIO_KEY!=0x0f)
                {
                        KeyState=1;//有按键按下
                        switch(GPIO_KEY)
                        {
                                case(0X07):        KeyValue=0;break;
                                case(0X0b):        KeyValue=1;break;
                                case(0X0d): KeyValue=2;break;
                                case(0X0e):        KeyValue=3;break;
                        }
                        //测试行
                        GPIO_KEY=0Xf0;
                        Delay10ms();//此处延时为了消抖
                        switch(GPIO_KEY)
                        {
                                case(0X70):        KeyValue=KeyValue;break;
                                case(0Xb0):        KeyValue=KeyValue+4;break;
                                case(0Xd0): KeyValue=KeyValue+8;break;
                                case(0Xe0):        KeyValue=KeyValue+12;break;
                        }
                        while((a<200)&&(GPIO_KEY!=0xf0))//按键松手检测，a的值太小，就会在按下不松
                                                                                        //手时，产生多次按键的结果，现在有2s时间
                        {
                                Delay10ms();
                                a++;
                        }
                        a=0;
                }
        }
}


/*******************************************************************************
* 函 数 名         : Delay10ms
* 函数功能                   : 延时函数，延时10ms
* 输    入         : 无
* 输    出         : 无
*******************************************************************************/
void Delay10ms(void)   //误差 0us
{
    unsigned char a,b,c;
    for(c=1;c>0;c--)
        for(b=38;b>0;b--)
            for(a=130;a>0;a--);
}

通过按键进行扫描矩阵的处理

列扫描和竖扫描