代码:

1. #include<reg52.h>
   
2. 
   
3. sbit ADDR0 = P1^0;
   
4. sbit ADDR1 = P1^1;
   
5. sbit ADDR2 = P1^2;
   
6. sbit ADDR3 = P1^3;
   
7. sbit ENLED = P1^4;
   
8. 
   
9. sbit KEY_IN_1 = P2^4;
   
10. sbit KEY_IN_2 = P2^5;
    
11. sbit KEY_IN_3 = P2^6;
    
12. sbit KEY_IN_4 = P2^7;
    
13. sbit KEY_OUT_1 = P2^3;
    
14. sbit KEY_OUT_2 = P2^2;
    
15. sbit KEY_OUT_3 = P2^1;
    
16. sbit KEY_OUT_4 = P2^0;
    
17. 
    
18. unsigned char code LedChar[]={
    
19.         0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8,
    
20.         0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E
    
21.         };
    
22. unsigned char KeySta[4][4] = {
    
23.         {1,1,1,1},{1,1,1,1},{1,1,1,1},{1,1,1,1}
    
24.         };
    
25. unsigned char LedBuff[6] = {
    
26.         0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
    
27.         };
    
28. unsigned char code KeyCodeMap[4][4] = { //矩阵按键编号到标准键盘键码的映射表
    
29.     { 0x31, 0x32, 0x33, 0x26 }, //数字键1、数字键2、数字键3、向上键
    
30.     { 0x34, 0x35, 0x36, 0x25 }, //数字键4、数字键5、数字键6、向左键
    
31.     { 0x37, 0x38, 0x39, 0x28 }, //数字键7、数字键8、数字键9、向下键
    
32.     { 0x30, 0x1B, 0x0D, 0x27 }  //数字键0、ESC键、  回车键、 向右键
    
33.         };
    
34. void  KeyDriver();
    
35. void main()
    
36. {
    
37.     EA = 1;       //使能总中断
    
38.     ENLED = 0;    //选择数码管进行显示
    
39.     ADDR3 = 1;
    
40.     TMOD = 0x01;  //设置T0为模式1
    
41.     TH0  = 0xFC;  //为T0赋初值0xFC67，定时1ms
    
42.     TL0  = 0x67;
    
43.     ET0  = 1;     //使能T0中断
    
44.     TR0  = 1;     //启动T0
    
45.     LedBuff[0] = LedChar[0];  //上电显示0
    
46.         
    
47.     while (1)
    
48.     {
    
49.         KeyDriver();   //调用按键驱动函数
    
50.     }
    
51. }
    
52. 
    
53. void ShowNumber(unsigned long num)
    
54. {
    
55.         signed char i;
    
56.         unsigned char buf[6];
    
57. 
    
58.         for(i=0; i<6; i++)
    
59.         {
    
60.                 buf[i] = num % 10;
    
61.                 num = num / 10;
    
62.         }
    
63. 
    
64.         for(i=5; i>=1; i--)  \\gaoweibuxianshi
    
65.         {
    
66.                 if(buf[i] == 0)
    
67.                 {
    
68.                         LedBuff[i] = 0xFF;
    
69.                 }
    
70.                 else
    
71.                         break;
    
72.         }
    
73.         
    
74.         for(; i>=0; i--) \\
    
75.         {
    
76.                 LedBuff[i] = LedChar[buf[i]];        
    
77.         }
    
78. 
    
79. }
    
80. void KeyAction(unsigned char keycode)
    
81. {
    
82.         static unsigned long result = 0;
    
83.         static unsigned long addend = 0;
    
84.         
    
85.         if((keycode >= 0x30) &&(keycode <= 0x39))
    
86.         {
    
87.                 addend = (addend *10) + (keycode - 0x30);   
    
88.                 ShowNumber(addend);
    
89.         }
    
90.         
    
91.         else if(keycode == 0x26)
    
92.         {
    
93.                 result += addend;
    
94.                 addend = 0;
    
95.                 ShowNumber(result);
    
96.         }
    
97.         else if(keycode == 0x0D)
    
98.         {
    
99.                 result += addend;
    
100.                 addend = 0;
     
101.                 ShowNumber(result);
     
102.         }
     
103.         else if(keycode == 0x1B)
     
104.         {
     
105.                 addend = 0;
     
106.                 result = 0;
     
107.                 ShowNumber(addend);         
     
108.         }        
     
109.          
     
110. }
     
111. void  KeyDriver()
     
112. {
     
113.         unsigned char i, j;
     
114.         static        unsigned char backup [4][4] = {
     
115.         {1,1,1,1},{1,1,1,1},{1,1,1,1},{1,1,1,1}
     
116.         };
     
117. 
     
118.         for(i=0; i<4; i++)
     
119.                 {
     
120.                         for(j=0; j<4; j++)
     
121.                         {
     
122.                                 if(backup[i][j] != KeySta[i][j])
     
123.                                 {
     
124.                                         if(backup[i][j] == 0)
     
125.                                         {
     
126.                                                 KeyAction(KeyCodeMap[i][j]);
     
127.                                         }
     
128.                                         backup[i][j] = KeySta[i][j];
     
129.                                 }
     
130.                         }        
     
131.                 }
     
132. 
     
133.         
     
134. }
     
135. 
     
136. /* 按键扫描函数，需在定时中断中调用，推荐调用间隔1ms */
     
137. void KeyScan()
     
138. {
     
139.     unsigned char i;
     
140.     static unsigned char keyout = 0;   //矩阵按键扫描输出索引
     
141.     static unsigned char keybuf[4][4] = {  //矩阵按键扫描缓冲区
     
142.         {0xFF, 0xFF, 0xFF, 0xFF},  {0xFF, 0xFF, 0xFF, 0xFF},
     
143.         {0xFF, 0xFF, 0xFF, 0xFF},  {0xFF, 0xFF, 0xFF, 0xFF}
     
144.     };
     
145. 
     
146.     //将一行的4个按键值移入缓冲区
     
147.     keybuf[keyout][0] = (keybuf[keyout][0] << 1) | KEY_IN_1;
     
148.     keybuf[keyout][1] = (keybuf[keyout][1] << 1) | KEY_IN_2;
     
149.     keybuf[keyout][2] = (keybuf[keyout][2] << 1) | KEY_IN_3;
     
150.     keybuf[keyout][3] = (keybuf[keyout][3] << 1) | KEY_IN_4;
     
151.     //消抖后更新按键状态
     
152.     for (i=0; i<4; i++)  //每行4个按键，所以循环4次
     
153.     {
     
154.         if ((keybuf[keyout][i] & 0x0F) == 0x00)
     
155.         {   //连续4次扫描值为0，即4*4ms内都是按下状态时，可认为按键已稳定的按下
     
156.             KeySta[keyout][i] = 0;
     
157.         }
     
158.         else if ((keybuf[keyout][i] & 0x0F) == 0x0F)
     
159.         {   //连续4次扫描值为1，即4*4ms内都是弹起状态时，可认为按键已稳定的弹起
     
160.             KeySta[keyout][i] = 1;
     
161.         }
     
162.     }
     
163.     //执行下一次的扫描输出
     
164.     keyout++;                //输出索引递增
     
165.     keyout = keyout & 0x03;  //索引值加到4即归零
     
166.     switch (keyout)          //根据索引，释放当前输出引脚，拉低下次的输出引脚
     
167.     {
     
168.         case 0: KEY_OUT_4 = 1; KEY_OUT_1 = 0; break;
     
169.         case 1: KEY_OUT_1 = 1; KEY_OUT_2 = 0; break;
     
170.         case 2: KEY_OUT_2 = 1; KEY_OUT_3 = 0; break;
     
171.         case 3: KEY_OUT_3 = 1; KEY_OUT_4 = 0; break;
     
172.         default: break;
     
173.     }
     
174. }
     
175. /* 数码管动态扫描刷新函数，需在定时中断中调用 */
     
176. void LedScan()
     
177. {
     
178.     static unsigned char i = 0;  //动态扫描的索引
     
179. 
     
180.     P0 = 0xFF;   //显示消隐
     
181.     switch (i)
     
182.     {
     
183.         case 0: ADDR2=0; ADDR1=0; ADDR0=0; i++; P0=LedBuff[0]; break;
     
184.         case 1: ADDR2=0; ADDR1=0; ADDR0=1; i++; P0=LedBuff[1]; break;
     
185.         case 2: ADDR2=0; ADDR1=1; ADDR0=0; i++; P0=LedBuff[2]; break;
     
186.         case 3: ADDR2=0; ADDR1=1; ADDR0=1; i++; P0=LedBuff[3]; break;
     
187.         case 4: ADDR2=1; ADDR1=0; ADDR0=0; i++; P0=LedBuff[4]; break;
     
188.         case 5: ADDR2=1; ADDR1=0; ADDR0=1; i=0; P0=LedBuff[5]; break;
     
189.         default: break;
     
190.     }
     
191. }
     
192. 
     
193. /* T0中断服务函数，用于数码管显示扫描与按键扫描 */
     
194. void InterruptTimer0() interrupt 1
     
195. {
     
196.         TH0 = 0xFC;
     
197.         TL0 = 0x67;
     
198.         LedScan();
     
199.         KeyScan();
     
200. }