标题: 51单片机计算器程序状态图与Proteus仿真 [打印本页]

---

作者: wmj123    时间: 2020-12-4 15:23
标题: 51单片机计算器程序状态图与Proteus仿真
仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）


单片机源程序如下:

1. #include "led_seg.h"
   
2. #include "key.h"
   
3. #include "mymath.h"
   
4. 
   
5. typedef enum
   
6. {
   
7.         OPERATOR_EMPTY,
   
8.         OPERATOR_PLUS,
   
9.         OPERATOR_MINUS,
   
10.         OPERATOR_MULTIPLY,
    
11.         OPERATOR_DIVIDE,
    
12.         OPERATOR_EQUAL
    
13. } OPERATOR;
    
14. 
    
15. 
    
16. typedef enum
    
17. {
    
18.         STATE_INIT,
    
19.         STATE_INPUT_FIRST_NUM,
    
20.         STATE_INPUT_SECOND_NUM,
    
21.         STATE_CALC_SIGN,
    
22.         STATE_EQUAL
    
23. } STATE;
    
24. 
    
25. u8 timer = 0;
    
26. double show_number = 0;
    
27. 
    
28. // 用来标记小数点是否按下
    
29. bit is_dot_press = 0;
    
30. // 用来记录小数点按下后键盘按下的数的数量
    
31. u8 after_dot_press_number = 0;
    
32. 
    
33. 
    
34. // (float) 等价于 (double) 6位有效数字
    
35. void Timer0Init(void);
    
36. void Timer0Interrupt(void);
    
37. void update_show_number(u8);
    
38. void update_calc_sign(OPERATOR);
    
39. 
    
40. double first_number = 0;
    
41. double second_number = 0;
    
42. 
    
43. 
    
44. 
    
45. OPERATOR myoperator = OPERATOR_EMPTY;
    
46. STATE state = STATE_INIT;
    
47. void main()
    
48. {
    
49.         Timer0Init();
    
50.         while(1)
    
51.         {
    
52.                
    
53.                 keyscan();
    
54.                
    
55.                 if(NO_KEY_PRESS != key_state)
    
56.                 {
    
57.                         switch(key_state)
    
58.                         {
    
59.                                 // 1
    
60.                                 case 0:
    
61.                                         update_show_number(1);
    
62.                                         break;
    
63.                                 // 2
    
64.                                 case 1:
    
65.                                         update_show_number(2);
    
66.                                         break;
    
67.                                 // 3
    
68.                                 case 2:
    
69.                                         update_show_number(3);
    
70.                                         break;
    
71.                                 // +
    
72.                                 case 3:
    
73.                                         update_calc_sign(OPERATOR_PLUS);
    
74.                                         break;
    
75.                                 // 4
    
76.                                 case 4:
    
77.                                         update_show_number(4);
    
78.                                         break;
    
79.                                 // 5
    
80.                                 case 5:
    
81.                                         update_show_number(5);
    
82.                                         break;
    
83.                                 // 6
    
84.                                 case 6:
    
85.                                         update_show_number(6);
    
86.                                         break;
    
87.                                 // -
    
88.                                 case 7:
    
89.                                         update_calc_sign(OPERATOR_MINUS);
    
90.                                         break;
    
91.                                 // 7
    
92.                                 case 8:
    
93.                                         update_show_number(7);
    
94.                                         break;
    
95.                                 // 8
    
96.                                 case 9:
    
97.                                         update_show_number(8);
    
98.                                         break;
    
99.                                 // 9
    
100.                                 case 10:
     
101.                                         update_show_number(9);
     
102.                                         break;
     
103.                                 // ×
     
104.                                 case 11:
     
105.                                         update_calc_sign(OPERATOR_MULTIPLY);
     
106.                                         break;
     
107.                                 // .
     
108.                                 case 12:
     
109.                                         is_dot_press = 1;
     
110.                                         break;
     
111.                                 // 0
     
112.                                 case 13:
     
113.                                         update_show_number(0);
     
114.                                         break;
     
115.                                 // =
     
116.                                 case 14:
     
117.                                                 switch(state)
     
118.                                                 {
     
119.                                                         case STATE_INIT:
     
120.                                                         case STATE_EQUAL:
     
121.                                                         case STATE_INPUT_FIRST_NUM:
     
122.                                                                 first_number = show_number;
     
123.                                                                 state = STATE_EQUAL;
     
124.                                                                 myoperator = OPERATOR_EMPTY;                                
     
125.                                                                 break;
     
126.                                                         case STATE_INPUT_SECOND_NUM:
     
127.                                                                 second_number = show_number;
     
128.                                                                 switch(myoperator)
     
129.                                                                 {
     
130.                                                                         case OPERATOR_PLUS:
     
131.                                                                                 show_number = first_number + second_number;
     
132.                                                                                 break;
     
133.                                                                         case OPERATOR_MINUS:
     
134.                                                                                 show_number = first_number - second_number;
     
135.                                                                                 break;
     
136.                                                                         case OPERATOR_MULTIPLY:
     
137.                                                                                 show_number = first_number * second_number;
     
138.                                                                                 break;
     
139.                                                                         case OPERATOR_DIVIDE:
     
140.                                                                                 
     
141.                                                                                 if(0.000000 != second_number)
     
142.                                                                                 {
     
143.                                                                                         show_number = first_number / second_number;
     
144.                                                                                 }
     
145.                                                                                 else
     
146.                                                                                 {
     
147.                                                                                         // warning
     
148.                                                                                         show_number = 0;
     
149. 
     
150.                                                                                 }
     
151.                                                                                        
     
152.                                                                                 break;
     
153.                                                                         default:
     
154.                                                                                 break;
     
155.                                                                 }
     
156.                                                                 is_dot_press = 0;
     
157.                                                                 after_dot_press_number = 0;
     
158.                                                                 first_number = 0;
     
159.                                                                 second_number = 0;
     
160.                                                                 state = STATE_EQUAL;
     
161.                                                                 myoperator = OPERATOR_EMPTY;
     
162.                                                                 break;
     
163.                                                         case STATE_CALC_SIGN:
     
164.                                                                 break;
     
165.                                                         default:
     
166.                                                                 break;
     
167.                                                 }
     
168.                                         break;
     
169.                                 // ÷
     
170.                                 case 15:
     
171.                                         update_calc_sign(OPERATOR_DIVIDE);
     
172.                                         break;
     
173.                                 //意外情况的处理
     
174.                                 default:
     
175.                                         break;
     
176.                         }
     
177.                         key_state = NO_KEY_PRESS;
     
178.                 }
     
179.         }
     
180. }
     
181. 
     
182. 
     
183. void Timer0Init(void)                //100微秒@12.000MHz
     
184. {
     
185.         TMOD &= 0xF0;                //设置定时器模式
     
186.         TMOD |= 0x02;                //设置定时器模式
     
187.         TL0 = 0x9C;                //设置定时初值
     
188.         TH0 = 0x9C;                //设置定时重载值
     
189.         TF0 = 0;                //清除TF0标志
     
190.         TR0 = 1;                //定时器0开始计时
     
191.         ET0 = 1;
     
192.         EA = 1;
     
193. }
     
194. 
     
195. void Timer0Interrupt(void) interrupt 1
     
196. {
     
197.         timer++;
     
198.         if(10 == timer)
     
199.         {
     
200.                 LedShowByNum(show_number);
     
201.                 timer = 0;
     
202.         }
     
203.         keyrescan();
     
204. }
     
205. 
     
206. 
     
207. void update_show_number(u8 number)
     
208. {
     
209. 
     
210.         switch(state)
     
211.         {
     
212.                 case STATE_INIT:
     
213.                 case STATE_EQUAL:
     
214.                         show_number = 0;
     
215.                         first_number = 0;
     
216.                         second_number = 0;
     
217.                         myoperator = OPERATOR_EMPTY;
     
218.                         state = STATE_INPUT_FIRST_NUM;
     
219.                         break;
     
220.                 case STATE_INPUT_FIRST_NUM:
     
221.                         break;
     
222.                 case STATE_INPUT_SECOND_NUM:
     
223.                         break;
     
224.                 case STATE_CALC_SIGN:
     
225.                         second_number = show_number = 0;
     
226.                         state = STATE_INPUT_SECOND_NUM;
     
227.                         break;
     
228.                 default:
     
229.                         break;
     
230.         }
     
231.         if(is_dot_press)
     
232.         {
     
233.                 after_dot_press_number++;
     
234.                 show_number += number / ((double)mypow(10,after_dot_press_number));
     
235.         }
     
236.         else
     
237.         {
     
238.                 show_number *= 10;
     
239.                 show_number += number;
     
240.         }
     
241.         switch(state)
     
242.         {
     
243.                 case STATE_INPUT_FIRST_NUM:
     
244.                         first_number = show_number;
     
245.                         break;
     
246.                 case STATE_INPUT_SECOND_NUM:
     
247.                         second_number = show_number;
     
248.                         break;
     
249.                 default:
     
250.                         break;
     
251.         }
     
252.         
     
253. }
     
254. 
     
255. void update_calc_sign(OPERATOR opr)
     
256. {
     
257.         switch(state)
     
258.         {
     
259.                 case STATE_INIT:
     
260.                         first_number = 0;
     
261.                         myoperator = opr;
     
262.                         state = STATE_CALC_SIGN;
     
263.                         break;
     
264.                 case STATE_EQUAL:
     
265.                 case STATE_INPUT_FIRST_NUM:
     
266.                         first_number = show_number;
     
267.                         state = STATE_CALC_SIGN;
     
268.                         myoperator = opr;
     
269.                         break;
     
270.                 case STATE_INPUT_SECOND_NUM:
     
271.                         second_number = show_number;
     
272.                         is_dot_press = 0;
     
273.                         after_dot_press_number = 0;
     
274.                         switch(myoperator)
     
275.                         {
     
276.                                 case OPERATOR_PLUS:
     
277.                                         show_number = first_number + second_number;
     
278.                                         break;
     
279.                                 case OPERATOR_MINUS:
     
280.                                         show_number = first_number - second_number;
     
281.                                         break;
     
282.                                 case OPERATOR_MULTIPLY:
     
283.                                         show_number = first_number * second_number;
     
284.                                         break;
     
285.                                 case OPERATOR_DIVIDE:
     
286.                                         if(0.000000 != second_number)
     
287.                                         {
     
288.                                                 show_number = first_number / second_number;
     
289.                                         }
     
290.                                         else
     
291.                                         {
     
292.                                                 is_dot_press = 0;
     
293.                                                 after_dot_press_number = 0;
     
294.                                                 // warning
     
295.                                                 show_number = 0;
     
296.                                                 first_number = 0;
     
297.                                                 second_number = 0;
     
298.                                                 myoperator = OPERATOR_EMPTY;
     
299.                                                 state = STATE_INIT;
     
300.                                                 return;
     
301.                                         }
     
302.                                                 
     
303.                                         break;
     
304.                                 default:
     
305.                                         break;
     
306.                         }
     
307.                         first_number = show_number;
     
308.                         state = STATE_CALC_SIGN;
     
309.                         myoperator = opr;
     
310.                         break;
     
311.                 case STATE_CALC_SIGN:
     
312.                         break;
     
313.         }
     
314. }

复制代码

全部资料51hei下载地址(仿真+程序)：
09-实现一个简便的计算器.7z (116.72 KB, 下载次数: 47)

2020-12-4 15:23 上传

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

---

作者: 泰兴电子    时间: 2023-4-9 16:29
第一次输入数不能带小数，否则运算符后的第二次输入数出错。比如7.1+2＝9.2 。但是显示为7.1+0.02＝7.12 。不知什么原因？楼主能不能查一下，更正后我再来下载一下。

---

作者: 泰兴电子    时间: 2023-4-13 15:57
已解决了第一次输入不能是小数的问题。但是出现了第二个问题，就是不能及时显示小数点及小数点后面的零，只有小数点后面是除零外的数才能及时显示。一直没有找到原因，楼主帮一下，谢谢！

---

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

Powered by Discuz! X3.1