基于C语言的简单计算器的加法程序

做了个简单的计算器练手
单片机计算器仿真原理图：


单片机源程序预览：

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

复制代码

所有资料打包下载：
简单的计算器加法程序.zip (79.82 KB, 下载次数: 21)

2016-11-30 15:02 上传

点击文件名下载附件

51黑有你更精彩！！！