用30个按键来控制5个电平输出,单片机程序哪里出错了?

你的显示程序和数组写的都有问题，4*8矩阵键盘扫描程序也繁琐，不是很清楚你的用途，
给你改了一下，不影响P1高4位另做他用，直接用P0短暂显示键值1~32，经仿真无误。你可
以按需自行修改。

1. #include <reg52.h>
   
2. #include <intrins.h>
   
3. #define uchar unsigned char
   
4. #define uint unsigned int
   
5. /*
   
6. uchar code tab[]={0xfe,0xfd,0xfc,0xfb,0xfa,0xf9,0xf8,0xf7,
   
7.                   0xf6,0xf5,0xf4,0xf3,0xf2,0xf1,0xf0,0xef,
   
8.                   0xee,0xed,0xec,0xeb,0xea,0xfe9,0xe8,0xe7,
   
9.                   0xe6,0xe5,0xe4,0xeb3,0xe2,0xe1,0xeff};//输出二进制库
   
10.                   //输出为11110 11101 到00001
    
11. */
    
12. uint  temp=0;//计数变量
    
13. uchar key=0xff;//键值变量
    
14. bit key_yes=0;//
    
15. 
    
16. //void display();
    
17. //void keyscan();
    
18. /*
    
19. void delay(uchar z)
    
20. {
    
21.         uchar x,y;
    
22.         for(x=z;x>0;x--)
    
23.                 for(y=100;y>0;y--);
    
24. }*/
    
25. void keyscan()    //4*8矩阵键盘扫描程序
    
26. {
    
27.         static bit sign=0;                        //按键自锁标志
    
28.         static uint count=0;                //消抖计数变量        
    
29.         uint num,num1;
    
30.         P1|=0x0f;//保持P1高4位不变，操作低4位1111
    
31.         P1&=0xf0;//保持P1高4位不变，操作低4位0000
    
32.         P2=0xff;//P2全高
    
33.         num=(P1&0x00)<<8|P2;
    
34.         if(num!=0x00ff)//判断有键按下
    
35.         {
    
36.                 if((++count>=250)&&(sign==0))//消抖与判断自锁
    
37.                 {
    
38.                         sign=1;                        //按键自锁标志置1
    
39.                         P1|=0x0f;                //保持P1高4位不变，操作低4位1111                        
    
40.                         P2=0x00;                        //P2全低
    
41.                         num1=(P1&0x0f)<<8|P2;
    
42.                         num|=num1;
    
43.                         switch(num)
    
44.                         {
    
45.                                 case 0x0efe: key= 1; break;
    
46.                                 case 0x0efd: key= 2; break;
    
47.                                 case 0x0efb: key= 3; break;
    
48.                                 case 0x0ef7: key= 4; break;
    
49.                                 case 0x0eef: key= 5; break;
    
50.                                 case 0x0edf: key= 6; break;
    
51.                                 case 0x0ebf: key= 7; break;
    
52.                                 case 0x0e7f: key= 8; break;
    
53.                                 case 0x0dfe: key= 9; break;
    
54.                                 case 0x0dfd: key=10; break;
    
55.                                 case 0x0dfb: key=11; break;
    
56.                                 case 0x0df7: key=12; break;
    
57.                                 case 0x0def: key=13; break;
    
58.                                 case 0x0ddf: key=14; break;
    
59.                                 case 0x0dbf: key=15; break;
    
60.                                 case 0x0d7f: key=16; break;
    
61.                                 case 0x0bfe: key=17; break;
    
62.                                 case 0x0bfd: key=18; break;
    
63.                                 case 0x0bfb: key=19; break;
    
64.                                 case 0x0bf7: key=20; break;
    
65.                                 case 0x0bef: key=21; break;
    
66.                                 case 0x0bdf: key=22; break;
    
67.                                 case 0x0bbf: key=23; break;
    
68.                                 case 0x0b7f: key=24; break;
    
69.                                 case 0x07fe: key=25; break;
    
70.                                 case 0x07fd: key=26; break;
    
71.                                 case 0x07fb: key=27; break;
    
72.                                 case 0x07f7: key=28; break;
    
73.                                 case 0x07ef: key=29; break;
    
74.                                 case 0x07df: key=30; break;
    
75.                                 case 0x07bf: key=31; break;
    
76.                                 case 0x077f: key=32; break;
    
77.                         }
    
78.                         key_yes=1;
    
79.                 }
    
80.         }
    
81.         else                                                //键抬起
    
82.         {
    
83.                 sign=0;                                        //按键自锁标志清0
    
84.                 count=0;                                //消抖计数清0
    
85.         }
    
86. }
    
87. /*
    
88. void display()
    
89. {
    
90.         {
    
91.                 P0=tab[n1];
    
92.         }
    
93. }
    
94. */
    
95. void main()
    
96. {
    
97.         while(1)
    
98.         {
    
99.                 keyscan();
    
100.                 if(key_yes==1)
     
101.                 {
     
102.                         P0=key;//读键值P0显示
     
103.                         temp++;
     
104.                         if(temp>=10000)//延时时间可调
     
105.                         {
     
106.                                 temp=0;
     
107.                                 key_yes=0;
     
108.                                 P0=0xff;
     
109.                         }
     
110.                 }
     
111.         }
     
112. }
     

复制代码