标题: 关于51单片机计算器实现连续计算功能如何实现? [打印本页]

---

作者: 1196383236    时间: 2021-10-6 16:30
标题: 关于51单片机计算器实现连续计算功能如何实现?
    刚学习51单片机一段时间，写了一个计算器，请问该怎么实现计算器的连续计算功能呢，现在只能进行正常的正整数运算。

单片机源程序如下:

1. #include <reg52.h>
   
2. 
   
3. typedef unsigned int u16;
   
4. typedef unsigned char u8;
   
5. 
   
6. unsigned long int count = 0, sum = 0;
   
7. unsigned char symbol;   //加减乘除
   
8. unsigned  char KeyValue;//按下键的序号
   
9. unsigned  char KeyState;//按键按下标志位，按下为1，松开为0
   
10. 
    
11. #define GPIO_KEY P1
    
12. 
    
13. sbit LSA = P2 ^ 2;
    
14. sbit LSB = P2 ^ 3;
    
15. sbit LSC = P2 ^ 4;
    
16. 
    
17. u16 a, point;
    
18. u8 DisplayData[8];
    
19. u8 code smgduan[11] = { 0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f, 0x00 };
    
20. 
    
21. 
    
22. void delay();      //延时
    
23. void KeyDown();    //按键扫描
    
24. void DigDisplay(); //数码管显示
    
25. void conversion(); //计算过程
    
26. 
    
27. void main()
    
28. {
    
29.     while (1)
    
30.     {
    
31.         KeyDown();
    
32.         if (KeyState == 1)
    
33.         {
    
34.             DisplayData[7] = DisplayData[6];
    
35.             DisplayData[6] = DisplayData[5];
    
36.             DisplayData[5] = DisplayData[4];
    
37.             DisplayData[4] = DisplayData[3];
    
38.             DisplayData[3] = DisplayData[2];
    
39.             DisplayData[2] = DisplayData[1];
    
40.             DisplayData[1] = DisplayData[0];
    
41.             DisplayData[0] = smgduan[KeyValue];
    
42.             KeyState = 0;
    
43.         }
    
44.         DigDisplay();
    
45.     }
    
46. }
    
47. 
    
48. void KeyDown()        //按键扫描
    
49. {
    
50.     GPIO_KEY = 0x0f;
    
51.     if (GPIO_KEY != 0x0f)
    
52.     {
    
53.         delay();
    
54.         if (GPIO_KEY != 0x0f)
    
55.         {
    
56.             KeyState = 1;              //有按键按下
    
57.             GPIO_KEY = 0x0F;           //测试列
    
58.             switch (GPIO_KEY)
    
59.             {
    
60.             case(0X07):
    
61.                 KeyValue = 1;
    
62.                 break;
    
63.             case(0X0b):
    
64.                 KeyValue = 2;
    
65.                 break;
    
66.             case(0X0d):
    
67.                 KeyValue = 3;
    
68.                 break;
    
69.             case(0X0e):
    
70.                 KeyValue = 4;
    
71.                 break;
    
72.             }
    
73.             GPIO_KEY = 0XF0;           //测试行
    
74.             delay();
    
75.             switch (GPIO_KEY)
    
76.             {
    
77.             case(0X70):
    
78.                 KeyValue = KeyValue;
    
79.                 break;
    
80.             case(0Xb0):
    
81.                 KeyValue = KeyValue + 4;
    
82.                 break;
    
83.             case(0Xd0):
    
84.                 KeyValue = KeyValue + 8;
    
85.                 break;
    
86.             case(0Xe0):
    
87.                 KeyValue = KeyValue + 12;
    
88.                 break;
    
89.             }
    
90.             while ((a < 500) && (GPIO_KEY != 0xf0))//按键松手检测
    
91.             {
    
92.                 delay();
    
93.                 a++;
    
94.             }
    
95.             a = 0;
    
96.             conversion();
    
97.         }
    
98.     }
    
99. }
    
100. 
     
101. void conversion()
     
102. {
     
103.     unsigned char KeyValue_count;
     
104.     if (KeyValue % 4 != 0) //else进入加减乘除
     
105.     {
     
106.         if (KeyValue != 15) //  15是等于号
     
107.         {
     
108.             switch (KeyValue)
     
109.             {
     
110.             case 1:
     
111.             case 2:
     
112.             case 3:
     
113.                 KeyValue_count = KeyValue;
     
114.                 break;
     
115.             case 5:
     
116.             case 6:
     
117.             case 7:
     
118.                 KeyValue_count = KeyValue - 1;
     
119.                 break;
     
120.             case 9:
     
121.             case 10:
     
122.             case 11:
     
123.                 KeyValue_count = KeyValue - 2;
     
124.                 break;
     
125.             case 13:
     
126.             {
     
127.                 count = 0;    //count = 0; sum = 0;KeyValue_count = 0;  清零
     
128.                 sum = 0;
     
129.                 KeyValue_count = 0;
     
130.                 break;
     
131.             }
     
132.             case 14:
     
133.                 KeyValue_count = 0;
     
134.                 break;
     
135.             default:
     
136.                 break;
     
137.             }
     
138.             count = count * 10 + KeyValue_count;    //往前进一位
     
139.         }
     
140.         else    //等于结果
     
141.         {
     
142.             if (symbol == '+')
     
143.                 sum = sum + count;
     
144.             if (symbol == '-')
     
145.                 sum = sum - count;
     
146.             if (symbol == '*')
     
147.                 sum = sum * count;
     
148.             if (symbol == '/')
     
149.                 sum = sum / count;
     
150.             count = sum;
     
151.         }
     
152. 
     
153.     }
     
154.     else
     
155.     {
     
156.         switch (KeyValue)
     
157.         {
     
158.         case 4:
     
159.             symbol = '+';
     
160. 
     
161.             break;
     
162.         case 8:
     
163.             symbol = '-';
     
164. 
     
165.             break;
     
166.         case 12:
     
167.             symbol = '*';
     
168. 
     
169.             break;
     
170.         case 16:
     
171.             symbol = '/';
     
172. 
     
173.             break;
     
174.         }
     
175.         sum = count;
     
176.         count = 0;
     
177.     }
     
178. }
     
179. 
     
180. void DigDisplay()
     
181. {
     
182.     unsigned char j;
     
183.     unsigned int i;
     
184.     for (j = 0; j < 8; j++)
     
185.     {
     
186.         switch (j)
     
187.         {
     
188.         case(0):
     
189.             LSA = 0;
     
190.             LSB = 0;
     
191.             LSC = 0;
     
192.             P0 = smgduan[count % 10];
     
193.             break;
     
194.         case(1):
     
195.             LSA = 1;
     
196.             LSB = 0;
     
197.             LSC = 0;
     
198.             if (count >= 10)
     
199.                 P0 = smgduan[count % 100 / 10];
     
200.             else
     
201.                 P0 = 0x00;
     
202.             break;
     
203.         case(2):
     
204.             LSA = 0;
     
205.             LSB = 1;
     
206.             LSC = 0;
     
207.             if (count >= 100)
     
208.                 P0 = smgduan[count % 1000 / 100];
     
209.             else
     
210.                 P0 = 0x00;
     
211.             break;
     
212.         case(3):
     
213.             LSA = 1;
     
214.             LSB = 1;
     
215.             LSC = 0;
     
216.             if (count >= 1000)
     
217.                 P0 = smgduan[count % 10000 / 1000];
     
218.             else
     
219.                 P0 = 0x00;
     
220.             break;
     
221.         case(4):
     
222.             LSA = 0;
     
223.             LSB = 0;
     
224.             LSC = 1;
     
225.             if (count >= 10000)
     
226.                 P0 = smgduan[count % 100000 / 10000];
     
227.             else
     
228.                 P0 = 0x00;
     
229.             break;
     
230.         case(5):
     
231.             LSA = 1;
     
232.             LSB = 0;
     
233.             LSC = 1;
     
234.             if (count >= 100000)
     
235.                 P0 = smgduan[count % 1000000 / 100000];
     
236.             else
     
237.                 P0 = 0x00;
     
238.             break;
     
239.         case(6):
     
240.             LSA = 0;
     
241.             LSB = 1;
     
242.             LSC = 1;
     
243.             if (count >= 1000000)
     
244.                 P0 = smgduan[count % 10000000 / 1000000];
     
245.             else
     
246.                 P0 = 0x00;
     
247.             break;
     
248.         case(7):
     
249.             LSA = 1;
     
250.             LSB = 1;
     
251.             LSC = 1;
     
252.             if (count >= 10000000)
     
253.                 P0 = smgduan[count % 100000000 / 10000000];
     
254.             else
     
255.                 P0 = 0x00;
     
256.             break;
     
257.         }
     
258.         i = 10;
     
259.         while (i--);
     
260.         P0 = 0x00;
     
261.     }
     
262. }
     
263. 
     
264. void delay()    //延时10ms
     
265. {
     
266.     unsigned char a, b, c;
     
267.     for (c = 1; c > 0; c--)
     
268.         for (b = 38; b > 0; b--)
     
269.             for (a = 130; a > 0; a--);
     
270. }

复制代码

---

作者: 创造生活    时间: 2021-10-6 17:47
你是想进行小数运算，还是其他特殊功能，没明白什么是计算器的连续计算功能，干什么事用什么变量，这是必需的也是首先应该做的

---

作者: xianfajushi    时间: 2021-10-6 17:56
https://blog.csdn.net/xianfajush ... 1018.2226.3001.4450

---

作者: 1196383236    时间: 2021-10-6 19:12

创造生活 发表于 2021-10-6 17:47
你是想进行小数运算，还是其他特殊功能，没明白什么是计算器的连续计算功能，干什么事用什么变量，这是必需 ...

就想要单纯的进行正整数连续计算功能，例如按了1之后按+，再按1，再按+，数码管可以显示2，再按1，再按＋可以显示三这种

---

作者: 1196383236    时间: 2021-10-6 19:13

xianfajushi 发表于 2021-10-6 17:56
https://blog.csdn.net/xianfajushi/article/details/80885105?ops_request_misc=%257B%2522request%255Fid ...

好的好的，我看看，谢谢

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1