单片机4*4矩阵键盘接口电路程序 Proteus仿真图

设计一个单片机键盘接口电路，实现4*4矩阵键盘，用数码管显示相应按键内容，当指定某一个按键连续被按三次时，显示“口”字符号，按键有去抖动功能，数码管可以通过清零键清零。

仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）



单片机源程序如下:

1. 
   
2. //0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07, 0x7F, 0x6F, 0x77, 0x7C, 0x39, 0x5E, 0x79, 0x71 共阴
   
3. //0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8, 0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E 共杨
   
4. 
   
5. #include <reg52.h>
   
6. 
   
7. #define GPIO_DIG    P0   //段选数码管
   
8. #define GPIO_KEY     P2      //矩阵按键
   
9. sbit led = P1^0;
   
10. typedef unsigned char uchar;
    
11. typedef unsigned int uint;
    
12. 
    
13. uint keynum = 0;
    
14. 
    
15. uint count=0;
    
16. 
    
17. uchar code table[]={0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07, 0x7F, 0x6F, 0x77, 0x7C, 0x39, 0x5E, 0x79, 0x71};
    
18. 
    
19. uchar code table0[]={0x5c};
    
20. 
    
21. void delay( uchar i ){
    
22.     while( i-- );
    
23. }
    
24. 
    
25. 
    
26. 
    
27. void key44scan(void)//键盘扫描函数
    
28. {               
    
29. //                uint count=0;
    
30.     uint t;
    
31.     P2=0xfe;
    
32.     t=P2;
    
33.     t=t&0xf0;
    
34.                 if(t!=0xf0){
    
35.                         delay(100);
    
36.                         if(t!=0xf0)
    
37.                         {
    
38.                                        
    
39.                                         t=P2;
    
40.                                         count++;
    
41.                                         switch(t)
    
42.                                         {
    
43.                                                                 case 0xee:keynum=1; break;
    
44.                                                                 case 0xde:keynum=5; break;
    
45.                                                                 case 0xbe:keynum=9; break;
    
46.                                                                 case 0x7e:keynum=13; break;            
    
47.                                         }
    
48.                                         P0=table[keynum];
    
49.                                         while(t!=0xf0)
    
50.                                         {
    
51.                                                          t=P2;
    
52.                                                          t=t&0xf0;
    
53.                                         }
    
54.                         }
    
55.                 }
    
56.                
    
57. 
    
58.                 P2=0xfd;
    
59.                 t=P2;
    
60.                 t=t&0xf0;
    
61.                 if(t!=0xf0){
    
62.                         delay(100);
    
63.                         if(t!=0xf0)
    
64.                         {
    
65.                                        
    
66.                                         t=P2;
    
67.                                         count++;
    
68.                                         switch(t)
    
69.                                         {
    
70.                                                                 case 0xed:keynum=2; break;
    
71.                                                                 case 0xdd:keynum=6; break;
    
72.                                                                 case 0xbd:keynum=10; break;
    
73.                                                                 case 0x7d:keynum=14; break;            
    
74.                                         }
    
75.                                         P0=table[keynum];
    
76.                                         while(t!=0xf0)
    
77.                                         {            
    
78.                                                          t=P2;
    
79.                                                          t=t&0xf0;
    
80.                                         }
    
81.                         }
    
82.                 }
    
83. 
    
84.                 P2=0xfb;
    
85.                 t=P2;
    
86.                 t=t&0xf0;
    
87.                 if(t!=0xf0){
    
88.                         delay(100);
    
89.                         if(t!=0xf0)
    
90.                         {
    
91.                                        
    
92.                                         t=P2;
    
93.                                         count++;
    
94.                                         switch(t)
    
95.                                         {
    
96.                                                                 case 0xeb:keynum=3; break;
    
97.                                                                 case 0xdb:keynum=7; break;
    
98.                                                                 case 0xbb:keynum=11; break;
    
99.                                                                 case 0x7b:keynum=15; break;            
    
100.                                         }
     
101.                                         P0=table[keynum];
     
102.                                                         while(t!=0xf0)
     
103.                                         {            
     
104.                                                          t=P2;
     
105.                                                          t=t&0xf0;
     
106.                                         }
     
107.                         }
     
108.                 }
     
109.                 P2=0xf7;
     
110.                 t=P2;
     
111.                 t=t&0xf0;
     
112.                 if(t!=0xf0){
     
113.                         delay(100);
     
114.                         if(t!=0xf0)
     
115.                         {
     
116.                                        
     
117.                                         t=P2;
     
118.                                         count++;
     
119.                                         switch(t)
     
120.                                         {
     
121.                                                                 case 0xe7:keynum=4; break;
     
122.                                                                 case 0xd7:keynum=8; break;
     
123.                                                                 case 0xb7:keynum=12; break;
     
124.                                                                 case 0x77:keynum=0; break;            
     
125.                                         }
     
126.                                         P0=table[keynum];
     
127.                                         while(t!=0xf0)
     
128.                                         {            
     
129.                                                          t=P2;
     
130.                                                          t=t&0xf0;
     
131.                                         }
     
132.                         }
     
133.                 }
     
134. //                        if(count==3){
     
135. //                                                count = 0;
     
136. //                                                led =~ led;
     
137. //                                                P0=table0[0];
     
138. //                                                delay(1000);
     
139. //                                        }
     
140.                
     
141. }
     
142. 
     
143. 
     
144. void main (){
     
145.                 led = 0;
     
146.     while(1) {
     
147.                                         key44scan();
     
148.         
     
149.                                         if(count==3){
     
150.                                                 //count = 0;
     
151.                                                 led =~ led;
     
152.                                                 P0=table0[0];
     
153.                                         //        delay(1000);
     
154.                                         }
     
155.                                         if(count==4){
     
156.                                                 count = 0;
     
157.                                                 led =~ led;
     
158.                                                 P0=table[0];
     
159.                                         //        delay(1000);
     
160.                                         }
     
161.     }
     
162. }

复制代码

Keil代码与Proteus仿真下载:
实验2.7z (65.26 KB, 下载次数: 47)

2022-4-8 16:14 上传

点击文件名下载附件
下载积分: 黑币 -5

请问一下那个排阻需要多大的？10k 还是 1k