这种矩阵键盘用反转法比较简单，给你一个参考代码。
{  
  P1 = 0x0f;
//行置低,列置高(读列)
   if(P1!=0x0f)
    {
     // P1 = 0x0f;
      delaym(40);  //延时去抖。约60MS，可根据实际情况修改
      if(P1!=0x0f)
     {
            switch(P1)//扫描列
              {
                     case 0x07:i=3;break;
                     case 0x0b:i=2;break;
                     case 0x0d:i=1;break;
                     case 0x0e:i=0;break;
                     default:break;
             }
         //反转行列电平，读行
       P1 = 0xf0;
            switch(P1)
            {
                   case 0x70:j=3;break;
                   case 0xb0:j=2;break;
                   case 0xd0:j=1;break;
                   case 0xe0:j=0;break;
                   default:break;
            }
   while(P1!=0xf0);   //等待键释放
  return key_word[i][j];//返回键值
}

1. #include<reg51.h>
   
2. 
   
3. unsigned char n[]={
   
4.         0xc0,0xf9,0xa4,0xb0,
   
5.         0x99,0x92,0x82,0xf8,
   
6.         0x80,0x90,0x88,0x83,
   
7.         0xc6,0xa1,0x86,0x81};
   
8. 
   
9. unsigned char k;
   
10. 
    
11. void Timer1Init()   //1毫秒@12.000MHz
    
12. {
    
13.         TMOD= 0x10;                //设置定时器模式
    
14.         TL1 = 0x18;                //设置定时初始值
    
15.         TH1 = 0xFC;                //设置定时初始值
    
16.         TF1 = 0;                //清除TF0标志
    
17.         TR1 = 1;                //定时器0开始计时
    
18. }
    
19. 
    
20. void scan_key(void)
    
21. {
    
22.         static bit sign;
    
23.         static unsigned char count;
    
24.         unsigned char temp;
    
25.         P1=0x0f;
    
26.         if(P1!=0x0f)
    
27.         {
    
28.                 if(++count>=10 && sign==0)
    
29.                 {
    
30.                         sign=1;
    
31.                         temp=P1;
    
32.                         temp|=0xf0;
    
33.                         P1=temp;
    
34.                         switch(P1)
    
35.                         {
    
36.                                 case 0xee:k=1;break;
    
37.                                 case 0xde:k=2;break;
    
38.                                 case 0xbe:k=3;break;
    
39.                                 case 0x7e:k=4;break;
    
40.                                 case 0xed:k=5;break;
    
41.                                 case 0xdd:k=6;break;
    
42.                                 case 0xbd:k=7;break;
    
43.                                 case 0x7d:k=8;break;
    
44.                                 case 0xeb:k=9;break;
    
45.                                 case 0xdb:k=10;break;
    
46.                                 case 0xbb:k=11;break;
    
47.                                 case 0x7b:k=12;break;
    
48.                                 case 0xe7:k=13;break;
    
49.                                 case 0xd7:k=14;break;
    
50.                                 case 0xb7:k=15;break;
    
51.                                 case 0x77:k=16;break;
    
52.                                 default:break;
    
53.                         }
    
54.                 }
    
55.         }
    
56.         else
    
57.         {
    
58.                 sign=0;
    
59.                 count=0;
    
60.         }
    
61. }
    
62. void main()                                                //主函数
    
63. {
    
64.         Timer1Init();
    
65.         while(1)
    
66.         {
    
67.                 if(TF1)
    
68.                 {
    
69.                         TF1=0;
    
70.                         TL1 = 0x18;
    
71.                         TH1 = 0xFC;
    
72.                         scan_key();
    
73.                 }
    
74.                 P2=n[k/10];
    
75.                 P3=~n[k%10];
    
76.         }
    
77. }

复制代码

1. 
   
2.                 #include<reg52.h>
   
3.                 #include<intrins.h>
   
4.                 #define uchar unsigned char
   
5.                 #define uint unsigned int
   
6.                                
   
7.                 sbit DX=P2^6;//(P0为数码管输出端口)
   
8.                 sbit WX=P2^7;
   
9.                 sbit S2=P3^4;
   
10.                
    
11.                                
    
12.                 uchar code Table_D[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71};
    
13.                 uchar code Table_W[]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf};
    
14.                        
    
15.                 void Delay_Us(uchar x);
    
16.                 void Delay_Ms(uchar x);
    
17.                 void Display(uint x);
    
18.                
    
19.                 void Key_Scan();
    
20.                
    
21.                 uchar Display_Num;
    
22.                                
    
23.                 void main()
    
24.                         {
    
25.                                 while(1)
    
26.                                 {
    
27.                                         Key_Scan();
    
28.                                         Display(Display_Num);
    
29.                                 }
    
30.                         }
    
31.                                
    
32.                 void Delay_Us(uchar x)//12MHz_Delay:6x+10us;11.0592MHz=12MHz_Delay*1.085.
    
33.                                 {
    
34.                                          while(x--);
    
35.                                 }
    
36.                
    
37.                 void Delay_Ms(uchar x)//12MHz_Delay:x+0.5~1Ms;11.0592MHz=12MHz_Delay*1.085.
    
38.                                 {
    
39.                                         while(x--)
    
40.                                         {
    
41.                                                 Delay_Us(75);
    
42.                                                 Delay_Us(75);
    
43.                                          }
    
44.                             }
    
45.                                
    
46.                                 void Display(uint x)
    
47.                                  {
    
48.                                         P0=0xff;
    
49.                                         WX=1;
    
50.                                         WX=0;
    
51.                                         P0=Table_D[x/100];
    
52.                                         DX=1;
    
53.                                         DX=0;
    
54.                                         P0=Table_W[0];
    
55.                                         WX=1;
    
56.                                         WX=0;               
    
57.                                         Delay_Ms(5);
    
58.                                        
    
59.                                         P0=0xff;
    
60.                                         WX=1;
    
61.                                         WX=0;
    
62.                                         P0=Table_D[x%100/10];
    
63.                                         DX=1;
    
64.                                         DX=0;
    
65.                                         P0=Table_W[1];
    
66.                                         WX=1;
    
67.                                         WX=0;       
    
68.                                         Delay_Ms(5);
    
69.                                        
    
70.                                         P0=0xff;
    
71.                                         WX=1;
    
72.                                         WX=0;
    
73.                                         P0=Table_D[x%100%10];
    
74.                                         DX=1;
    
75.                                         DX=0;
    
76.                                         P0=Table_W[2];
    
77.                                         WX=1;
    
78.                                         WX=0;
    
79.                                         Delay_Ms(5);
    
80.                                  }
    
81.                                
    
82.                                 void Key_Scan()
    
83.                                 {
    
84.                                         uchar temp,Key;
    
85.                                        
    
86.                                         P3=0xf0;
    
87.                                         temp=P3;
    
88.                                         temp=temp&0xf0;
    
89.                                         if(temp!=0xf0)
    
90.                                         {
    
91.                                                 Delay_Ms(10);
    
92.                                                 if(temp!=0xf0)
    
93.                                                 {
    
94.                                                         temp=P3;
    
95.                                                         temp=temp|0x0f;
    
96.                                                         P3=temp;
    
97.                                                         Key=P3;
    
98.                                                        
    
99.                                                         switch(Key)
    
100.                                                         {
     
101.                                                                 case 0xee:Display_Num=1*1;break;
     
102.                                                                 case 0xde:Display_Num=2*2;break;
     
103.                                                                 case 0xbe:Display_Num=3*3;break;
     
104.                                                                 case 0x7e:Display_Num=4*4;break;
     
105.                                                                
     
106.                                                                 case 0xed:Display_Num=5*5;break;
     
107.                                                                 case 0xdd:Display_Num=6*6;break;
     
108.                                                                 case 0xbd:Display_Num=7*7;break;
     
109.                                                                 case 0x7d:Display_Num=8*8;break;
     
110.                                                                
     
111.                                                                 case 0xeb:Display_Num=9*9;break;
     
112.                                                                 case 0xdb:Display_Num=10*10;break;
     
113.                                                                 case 0xbb:Display_Num=11*11;break;
     
114.                                                                 case 0x7b:Display_Num=12*12;break;
     
115.                                                                
     
116.                                                                 case 0xe7:Display_Num=13*13;break;
     
117.                                                                 case 0xd7:Display_Num=14*14;break;
     
118.                                                                 case 0xb7:Display_Num=15*15;break;
     
119.                                                                 case 0x77:Display_Num=16*16;break;
     
120.                                                         }
     
121.                                                 }
     
122.                                         }
     
123.                                 }
     

复制代码

个人觉得你的代码逻辑有很大的问题，没有理解按键检测的原理。

首先，你定义了一个temp，然后P1=0x0f，怎么突然之间就跳到while(temp!=0x0f)了？中间不应该有个temp=P1的过程？

其次，检测到temp！=0x0f后，为什么让P1=0xfe<<1？这也不会令P1最终得到真实的按键状态啊。最终只会导致P1==0x00。

最后，switch(temp)这，temp并没有得到真实的按键状态（P1口）对应的电平状态，自然会导致switch(temp)下面的语句没起任何作用。

建议找本教材，比如郭天祥的，看看按键检测的原理以及例程。或者看看视频的讲解，理解原理之后再写代码。