基于单片机的简易八位计算器设计 课程设计报告

基于单片机的简易计算器设计

一、设计任务和性能指标

1.1设计任务
利用单片机及外围接口电路(键盘接口和显示接口电路)设计制作一个计算器，用四位一体数码管显示计算数值及结果。要求用Protel 画出系统的电路原理图（要求以最少组件，实现系统设计所要求的功能），绘出程序流程图，并给出程序清单（要 求思路清晰，尽量简洁，主程序和子程序分开，使程序有较强的可读性）。
1.2性能指标
1加法：能够计算四位以内的数的加法。
2减法：能计算四位数以内的减法。
3乘法：能够计算两位数以内的乘法。
4除法：能够计算四位数的乘法
5有清零功能，能随时对运算结果和数字输入进行清零。


二、系统设计方案
按照系统设计的功能的要求，初步确定设计系统由单片机主控模块、四位一体数码管显示模块、键扫描接口电路共三个主要模块组成。主控芯片使用51系列AT89C51单片机，采用高性能的静态80C51设计，它由先进工艺制造，并带有非易失性Flash程序存储器。它是一种高性能、低功耗的8位COMS微处理芯片，市场应用最多。
键盘电路采用4*4矩阵键盘电路。
显示模块采用四位一体共阳极数码管和SN74LS244锁存芯片构成等器件构成。


三、硬件系统设计
1.单片机最小系统
单片机最小系统就是支持主芯片正常工作的最小电路部分，包括主控芯片、复位电路和晶振电路。
主控芯片选取STC89C51RC芯片，因其具有良好的性能及稳定性，价格便宜应用方便。
晶振选取11.0592MHz，晶振旁电容选取30pF。
采用按键复位电路，电阻分别选取100Ω和10K，电容选取10μF。
单片机最小系统硬件电路图如图（1）所示。

图（1） 单片机最小系统

2．键盘接口电路

计算器所需按键有：

    数字键：’1’,’2’,’3’,’4’,’5’,’6’,’7’,’8’,’9’,’0’

    功能键：’+’, ’-‘, ’*’, ’/ ’ , ’ = ’, ’ C( 清零)’

共计16个按键，采用4*4矩阵键盘，键盘的行和列之间都有公共端相连，四行采用端口P0.0~P0.3,四列采用端口P3.0~P3.3,通过8个端口的的高低电平完成对矩阵键盘的控制。通过对16个按键进行编码，从而得到键盘的口地址，对比P1口德扫描结果和各按键的地址，我们就可以得到是哪个键按下，从而完成键盘的功能。

3．数码管显示电路

采用4位一体的数码管对计算数据和结果进行显示，这里选取共阳数码管，利用NPN三极管对数码管进行驱动，为了节省I/O资源，采取动态显示的方法来显示计算数据及结果。

    利用SN74LS244N锁存器来实现数码管的动态显示，P1口输出显示值，P2.0~P2.3为位选端口。通过锁存器对段选信号的锁存，最终得到对数码管输入数据的控制。

    以下为数码显示电路的硬件电路图，左图为数码管驱动电路，右图为段选信号锁存电路。

四．软件设计部分

根据选题要求，系统编程如下所示：

1. #include "reg51.h"
   
2. sbit P3_0=P3^0;
   
3. sbit P3_1=P3^1;
   
4. sbit P3_2=P3^2;
   
5. sbit P3_3=P3^3;
   
6. sbit P3_4=P3^4;
   
7. sbit P3_5=P3^5;
   
8. sbit P3_6=P3^6;
   
9. sbit P3_7=P3^7;
   
10. unsigned char sz[11],xs1[4],xs2[4],sj;
    
11. int i,cs,bb,t1,t2,fh,s1,s2;
    
12. void chushihua()
    
13. {
    
14.         bb=1;
    
15.         xs1[0]=10;xs1[1]=10;xs1[2]=10;xs1[3]=10;
    
16.         xs2[0]=10;xs2[1]=10;xs2[2]=10;xs2[3]=10;
    
17.         t1=0;t2=0;s1=s2=0;
    
18.         fh=0;
    
19.         cs=1;
    
20.         
    
21. }
    
22. void xianshi(unsigned char xs[4])
    
23. {
    
24.         int i,j;
    
25.         unsigned char zy;
    
26.         zy=0x08;
    
27.         for (i=0;i<4;i++)
    
28.         {
    
29.                 P2=(0xff-zy);  
    
30.                 P1=sz[xs[i]];        
    
31.                 zy=(zy>>1);
    
32.                 for (j=0;j<100;j++)        ;
    
33.                
    
34.         }
    
35. //        for (i=0;i<100;i++);
    
36.         return;
    
37. 
    
38. }
    
39. unsigned char saomiao()
    
40. {
    
41.         int i,j;
    
42.         unsigned char pp;
    
43.         for (i=0;i<1000;i++);
    
44.         P0=0xfe;
    
45.         P3=0x0f;
    
46.         pp=P3;
    
47.         if (P3_0==0)         {P3=0x0f;pp=P3;while (P3_0==0);for (i=0;i<1000;i++);return 7;}
    
48.         if (P3_1==0)         {P3=0x0f;pp=P3;while (P3_1==0);for (i=0;i<1000;i++);return 8;}
    
49.         if (P3_2==0)         {P3=0x0f;pp=P3;while (P3_2==0);for (i=0;i<1000;i++);return 9;}
    
50.         if (P3_3==0)         {P3=0x0f;pp=P3;while (P3_3==0);for (i=0;i<1000;i++);return 11;}
    
51.         //==========1
    
52.         P0=0xfd;
    
53.         P3=0x0f;
    
54.         pp=P3;
    
55.         if (P3_0==0)         {P3=0x0f;pp=P3;while (P3_0==0);for (i=0;i<1000;i++);return 4;}
    
56.         if (P3_1==0)         {P3=0x0f;pp=P3;while (P3_1==0);for (i=0;i<1000;i++);return 5;}
    
57.         if (P3_2==0)         {P3=0x0f;pp=P3;while (P3_2==0);for (i=0;i<1000;i++);return 6;}
    
58.         if (P3_3==0)         {P3=0x0f;pp=P3;while (P3_3==0);for (i=0;i<1000;i++);return 12;}
    
59.         //==========2
    
60.         P0=0xfb;
    
61.         P3=0x0f;
    
62.         pp=P3;
    
63.         if (P3_0==0)         {P3=0x0f;pp=P3;while (P3_0==0);for (i=0;i<1000;i++);return 1;}
    
64.         if (P3_1==0)         {P3=0x0f;pp=P3;while (P3_1==0);for (i=0;i<1000;i++);return 2;}
    
65.         if (P3_2==0)         {P3=0x0f;pp=P3;while (P3_2==0);for (i=0;i<1000;i++);return 3;}
    
66.         if (P3_3==0)         {P3=0x0f;pp=P3;while (P3_3==0);for (i=0;i<1000;i++);return 13;}
    
67.         //==========3
    
68.         P0=0xf7;
    
69.         P3=0x0f;
    
70.         pp=P3;
    
71.         if (P3_0==0)         {P3=0x0f;pp=P3;while (P3_0==0);for (i=0;i<1000;i++);return 16;}
    
72.         if (P3_1==0)         {P3=0x0f;pp=P3;while (P3_1==0);for (i=0;i<1000;i++);return 0;}
    
73.         if (P3_2==0)         {P3=0x0f;pp=P3;while (P3_2==0);for (i=0;i<1000;i++);return 15;}
    
74.         if (P3_3==0)         {P3=0x0f;pp=P3;while (P3_3==0);for (i=0;i<1000;i++);return 14;}
    
75.         //===========4
    
76.         return 10;
    
77. }
    
78. void chuli(unsigned char x)
    
79. {
    
80.         int i;
    
81.         if (x==16)
    
82.         {
    
83.                 cs=0;
    
84.                 return ;
    
85.         }
    
86.         if (x>=0 && x<10)
    
87.         {
    
88.                 if (bb==1)
    
89.                 {
    
90.                         if (s1= =4) {cs=0;return ;}
    
91.                         else
    
92.                         {
    
93.                                 for (i=3;i>0;i--)
    
94.                                 xs1[i]=xs1[i-1];
    
95.                                 xs1[0]=x;
    
96.                                 s1++;
    
97.                                 t1=t1*10+x;
    
98.                         }
    
99.                 }
    
100.                 if (bb==2)
     
101.                 {
     
102.                         if (s2==4) {cs=0;return ;}
     
103.                         else
     
104.                         {
     
105.                                 for (i=3;i>0;i--)
     
106.                                 xs2[i]=xs2[i-1];
     
107.                                 xs2[0]=x;
     
108.                                 s2++;
     
109.                                 t2=t2*10+x;
     
110.                         }
     
111.                 }        
     
112.         }
     
113.         if (x>10)
     
114.         {
     
115.                 if (bb==1) {fh=x;bb=2;return;}
     
116.                 if (bb==2)
     
117.                 {
     
118.                         if (fh==11) t1=t1/t2;
     
119.                         if (fh==12) t1=t1*t2;
     
120.                         if (fh==13) t1=t1-t2;
     
121.                         if (fh==14) t1=t1+t2;
     
122.                         if (t1>=10000) {cs=0;return;}
     
123.                         else
     
124.                         {
     
125.                                 if (t1>=0 && t1<10)         {xs1[0]=t1;xs1[1]=10;xs1[2]=10;xs1[3]=10;}
     
126.                                 if (t1>=10 && t1<100)         {xs1[0]=t1%10;xs1[1]=t1/10;xs1[2]=10;xs1[3]=10;}
     
127.                                 if (t1>=100 && t1<1000)         {xs1[0]=t1%10;xs1[1]=(t1-(t1/100)*100)/10;xs1[2]=t1/100;xs1[3]=10;}
     
128.                                 if (t1>=1000 && t1<10000)         {xs1[0]=t1%10;xs1[1]=t1%100/10;xs1[2]=(t1-(t1/1000)*1000)/100;xs1[3]=t1/1000;}
     
129.                                 bb=2;
     
130.                                 s2=0;
     
131.                                 t2=0;
     
132.                                 xs2[0]=10;xs2[1]=10;xs2[2]=10;xs2[3]=10;
     
133.                                 fh=x;
     
134.                         }
     
135.                 }
     
136.         }
     
137. 
     
138. }
     
139. void main()
     
140. {
     
141.          sz[0]=0xfc;
     
142.         sz[1]=0x60;
     
143.         sz[2]=0xda;
     
144.         sz[3]=0xf2;
     
145.         sz[4]=0x66;
     
146.         sz[5]=0xb6;
     
147.         sz[6]=0xbe;
     
148.         sz[7]=0xe0;
     
149.         sz[8]=0xfe;
     
150.         sz[9]=0xf6;
     
151.         sz[10]=0x00;
     
152.         cs=0;
     
153.         
     
154.         for (;;)
     
155.         {
     
156.                 if (cs==0) chushihua();
     
157.                 if (cs==1) sj=saomiao();
     
158.                 if (cs==1 && sj!=10) chuli(sj);
     
159.                 if (cs==1 &&(bb==1 || bb==2 && s2==0)) xianshi(xs1);
     
160.                 if (cs==1 &&(bb==2 && s2!=0)) xianshi(xs2);
     
161.                
     
162.         }
     
163. }
     
164. 软件设计好后，在KEIL上面进行仿真，把仿真得到的文件下载到Proteus里面进行仿真，得到Proteus仿真电路图如下所示：           
     
165. 
     
166.            图（2）  计算器Proteus仿真电路图
     
167. 
     
168. 五．硬件电路焊接及调试
     
169.     根据电路图纸，焊接好硬件电路，把程序下载到单片机芯片，接通好电源，进行调试。在焊接好器件后，先不要将芯片插在芯片座上，要先验证先板上电源是否好用，有无短路等。接上USB电源，用万用表测量个芯片座对应电源和地之间的电压值，观察电压值是否正常。一切正常后方可将芯片插入芯片座，以继续测试其他功能。
     
170.     将芯片插上后，对各个模块进行调试，按键是否工作正常，数码管是否显示正常等。编写相关部分的测试程序对其进行测试。
     
171.     各部分硬件检测无误后，下载程序进行整体调试，一切正常后，结束调试过程。
     
172.     用所设计的单片机进行数字计算，显示结果与任务要求一致，焊接电路符合要求。
     
173. 六．课程设计心得
     
174. 两周的时间，终于把单片机课程设计搞完了。整个体会还是比较多的。首先是题目的选择，各方面的原因，自己还是想选个简单点的题目，不过最后选来选去，还是选择了计算器。由于自己对单片机编程还不是很熟悉，结果在设计的时候遇到了一系列问题，程序总是调试部处理，不过还好，最后在同学的帮助下终于把程序调试出来了，虽然程序设计实现的功能与老师要求的不尽相同，不过勉强还算可以。从这里我知道了基本知识的重要性。其实进行程序设计的时候主要是对各功能模块的把握。计算器里面最难的一部分是矩阵键盘的扫描和编码，那个费了很大力气。
     
175. 另外一点就是硬件焊接调试部分。焊接的时候到时轻松，一个下午就焊接好了，然后是调试部分。调试花费的时间还是比较长的。不过有了上个学期数字电路焊接调试的经验，这次单片机调试还算是比较顺利。我也是从电路板的正负电源检测起，一步一步来，最终得到了想要的结果。调试的时候主要遇到了两个问题。一个是键盘总是没有反应，为了这个自己调试了很久，前前后后把电路板检查了几次，最后才发现是键盘本身的问题，和同学们换了个好键盘才行。另一个问题是总是显示不出来1、4、7这三个数字。检测来检测去，发现来是在测试最小系统时在一个位选端接了高电平，对位选信号产生了影响。当把那个高电平去掉后，终于得到了正确的结果。
     
176. 总的来说这次课程设计达到了完成了基本任务，达到了基本要求。通过亲身对程序设计和电路焊接调试的体会，自己对单片机有了进一步的了解，单片机编程能力也得到了提高。电路板的焊接与调试，使自己电路调试的方法和思想进一步加强了。这次单片机课程设计应该说是比较成功的。
     
177. 
     
178. 参考文献：
     
179.    【1】徐维祥、刘旭敏:，《单片微型机原理及应用》，大连理工大学出版社，1996年。
     
180. 【2】李光飞、楼然苗、胡佳文、谢象佐.，《单片机课程设计与实例指导.》， 北京航空航天大学出版社，2004年。
     
181. 【3】余永权，《89系列FLASH单片机原理及应用.》，电子工业出版社,2002。
     
182. 【4】杨恢先、黄辉先，《单片机原理及应用》，人民邮电出版社，2006年。
     
183. 【5】常敏、王涵、范江波，《单片机应用程序开发与实践》，电子工业出版社，2009年。
     
184. 
     
185. 
     
186. 
     
187. 
     
188. 
     
189. 
     
190. #include   //头文件
     
191. #define uint unsigned int //
     
192. #define uchar unsigned char
     
193. 
     
194. sbit lcden=P2^3; //定义引脚
     
195. sbit rs=P2^4;
     
196. sbit rw=P2^0;
     
197. sbit busy=P0^7;
     
198. 
     
199. char i,j,temp,num,num_1;
     
200. long a,b,c;     //a,第一个数 b,第二个数 c,得数
     
201. float a_c,b_c;
     
202. uchar flag,fuhao;//flag表示是否有符号键按下，fuhao表征按下的是哪个符号
     
203. 
     
204. uchar code table[]={
     
205. 7,8,9,0,
     
206. 4,5,6,0,
     
207. 1,2,3,0,
     
208. 0,0,0,0};
     
209. uchar code table1[]={
     
210. 7,8,9,0x2f-0x30,
     
211. 4,5,6,0x2a-0x30,
     
212. 1,2,3,0x2d-0x30,
     
213. 0x01-0x30,0,0x3d-0x30,0x2b-0x30};
     
214. 
     
215. void delay(uchar z) // 延迟函数
     
216. {
     
217. uchar y;
     
218. for(z;z>0;z--)
     
219.    for(y=0;y<110;y++);
     
220. }
     
221. 
     
222. void check() // 判断忙或空闲
     
223. {
     
224. do{
     
225.     P0=0xFF;
     
226.     rs=0;     //指令
     
227.     rw=1;     //读
     
228.     lcden=0;     //禁止读写
     
229.     delay(1); //等待，液晶显示器处理数据
     
230.     lcden=1;     //允许读写
     
231.     }while(busy==1); //判断是否为空闲，1为忙，0为空闲
     
232. }
     
233. void write_com(uchar com) // 写指令函数
     
234. {
     
235. P0=com;    //com指令付给P0口
     
236. rs=0;
     
237. rw=0;
     
238. lcden=0;
     
239. check();
     
240. lcden=1;
     
241. }
     
242. 
     
243. void write_date(uchar date) // 写数据函数
     
244. {
     
245.     P0=date;
     
246. rs=1;
     
247. rw=0;
     
248. lcden=0;
     
249. check();
     
250. lcden=1;
     
251. }
     
252. 
     
253. void init() //初始化
     
254. {
     
255.     num=-1;
     
256. lcden=1; //使能信号为高电平
     
257. write_com(0x38); //8位，2行
     
258. write_com(0x0c); //显示开，光标关，不闪烁*/
     
259. write_com(0x06); //增量方式不移位 显竟獗暌贫 柚?
     
260. write_com(0x80); //检测忙信号
     
261. write_com(0x01); //显示开，光标关，不闪烁
     
262. num_1=0;
     
263. i=0;
     
264. j=0;
     
265. a=0;     //第一个参与运算的数
     
266. b=0;     //第二个参与运算的数
     
267. c=0;
     
268. flag=0; //flag表示是否有符号键按下，
     
269. fuhao=0; // fuhao表征按下的是哪个符号
     
270. }
     
271. void keyscan() // 键盘扫描程序
     
272. {
     
273. 
     
274. P3=0xfe;
     
275. if(P3!=0xfe)
     
276. {
     
277.    delay(20); 延迟20ms
     
278.    if(P3!=0xfe)
     
279.    {
     
280.     temp=P3&0xf0;
     
281.     switch(temp)
     
282.     {
     
283.      case 0xe0:num=0;
     
284.        break;
     
285.      case 0xd0:num=1;
     
286.        break;
     
287.      case 0xb0:num=2;
     
288.        break;
     
289.      case 0x70:num=3;
     
290.        break;
     
291.     }
     
292.    }
     
293.    while(P3!=0xfe);
     
294.    if(num==0||num==1||num==2)//如果按下的是'7','8'或'9
     
295.    {
     
296.        if(j!=0)
     
297.         {
     
298.           write_com(0x01);
     
299.           j=0;
     
300.          }
     
301.        if(flag==0)//没有按过符号键
     
302.     {
     
303.      a=a*10+table[num];
     
304.     }
     
305.     else//如果按过符号键
     
306.     {
     
307.      b=b*10+table[num];
     
308.     }
     
309.    }
     
310.    else//如果按下的是'/'
     
311.    {
     
312.     flag=1;
     
313.     fuhao=4;//4表示除号已按
     
314.    }
     
315.    i=table1[num];
     
316.    write_date(0x30+i);
     
317. }
     
318. 
     
319. P3=0xfd;
     
320. if(P3!=0xfd)
     
321. {
     
322.    delay(5);
     
323.    if(P3!=0xfd)
     
324.    {
     
325.     temp=P3&0xf0;
     
326.     switch(temp)
     
327.     {
     
328.      case 0xe0:num=4;
     
329.          break;
     
330.       
     
331.      case 0xd0:num=5;
     
332.          break;
     
333.       
     
334.      case 0xb0:num=6;
     
335.          break;
     
336.       
     
337.      case 0x70:num=7;
     
338.          break;
     
339.     }
     
340.    }
     
341.    while(P3!=0xfd);
     
342.    if(num==4||num==5||num==6&&num!=7)//如果按下的是'4','5'或'6'
     
343.    {
     
344.     if(j!=0)
     
345.         {
     
346.           write_com(0x01);
     
347.           j=0;
     
348.          }
     
349.        if(flag==0)//没有按过符号键
     
350.     {
     
351.      a=a*10+table[num];
     
352.     }
     
353.     else//如果按过符号键
     
354.     {
     
355.      b=b*10+table[num];
     
356.     }
     
357.    }
     
358.    else//如果按下的是'/'
     
359.    {
     
360.     flag=1;
     
361.     fuhao=3;//3表示乘号已按
     
362.    }
     
363.    i=table1[num];
     
364.    write_date(0x30+i);
     
365. }
     
366. 
     
367. P3=0xfb;
     
368. if(P3!=0xfb)
     
369. {
     
370.    delay(5);
     
371.    if(P3!=0xfb)
     
372.    {
     
373.     temp=P3&0xf0;
     
374.     switch(temp)
     
375.     {
     
376.      case 0xe0:num=8;
     
377.          break;
     
378.       
     
379.      case 0xd0:num=9;
     
380.          break;
     
381.       
     
382.      case 0xb0:num=10;
     
383.          break;
     
384.       
     
385.      case 0x70:num=11;
     
386.          break;
     
387.     }
     
388.    }
     
389.    while(P3!=0xfb);
     
390.    if(num==8||num==9||num==10)//如果按下的是'1','2'或'3'
     
391.    {
     
392.     if(j!=0)
     
393.         {
     
394.           write_com(0x01);
     
395.           j=0;
     
396.          }
     
397.       if(flag==0)//没有按过符号键
     
398.     {
     
399.      a=a*10+table[num];
     
400.     }
     
401.     else//如果按过符号键
     
402.     {
     
403.      b=b*10+table[num];
     
404.     }
     
405.    }
     
406.    else if(num==11)//如果按下的是'-'
     
407.    {
     
408.     flag=1;
     
409.     fuhao=2;//2表示减号已按
     
410.    }
     
411.    i=table1[num];
     
412.    write_date(0x30+i);
     
413. }
     
414. 
     
415. P3=0xf7;
     
416. if(P3!=0xf7)
     
417. {
     
418.    delay(5);
     
419.    if(P3!=0xf7)
     
420.    {
     
421.     temp=P3&0xf0;
     
422.     switch(temp)
     
423.     {
     
424.      case 0xe0:num=12;
     
425.          break;
     
426.       
     
427.      case 0xd0:num=13;
     
428.          break;
     
429.       
     
430.      case 0xb0:num=14;
     
431.          break;
     
432.       
     
433.      case 0x70:num=15;
     
434.          break;
     
435.     }
     
436.    }
     
437.    while(P3!=0xf7);
     
438.    switch(num)
     
439.    {
     
440.     case 12:{write_com(0x01);a=0;b=0;flag=0;fuhao=0;}//按下的是"清零"
     
441.      break;
     
442.     case 13:{                //按下的是"0"
     
443.        if(flag==0)//没有按过符号键
     
444.        {
     
445.         a=a*10;
     
446.         write_date(0x30);
     
447.         P1=0;
     
448.        }
     
449.        else if(flag==1)//如果按过符号键
     
450.        {
     
451.         b=b*10;
     
452.         write_date(0x30);
     
453.         }
     
454.       }
     
455.      break;
     
456.     case 14:{j=1;
     
457.            if(fuhao==1){write_com(0x80+0x4f);//按下等于键，光标前进至第二行最后一个显示处
     
458.            write_com(0x04);     //设置从后住前写数据，每写完一个数据，光标后退一格
     
459.            c=a+b;
     
460.            while(c!=0)
     
461.            {
     
462.              write_date(0x30+c%10);
     
463.              c=c/10;
     
464.            }
     
465.            write_date(0x3d);     //再写"="
     
466.            a=0;b=0;flag=0;fuhao=0;
     
467.            }
     
468.       else if(fuhao==2){write_com(0x80+0x4f);//光标前进至第二行最后一个显示处
     
469.             write_com(0x04);     //设置从后住前写数据，每写完一个数据，光标后退一格(这个照理说顺序不对，可显示和上段一样)
     
470.            if(a-b>0)
     
471.              c=a-b;
     
472.            else
     
473.              c=b-a;
     
474.            while(c!=0)
     
475.            {
     
476.              write_date(0x30+c%10);
     
477.              c=c/10;
     
478.            }
     
479.            if(a-b<0)
     
480.              write_date(0x2d);
     
481.            write_date(0x3d);     //再写"="           
     
482.            a=0;b=0;flag=0;fuhao=0;
     
483.           }
     
484.       else if(fuhao==3){write_com(0x80+0x4f);
     
485.             write_com(0x04);
     
486.              c=a*b;
     
487.              while(c!=0)
     
488.              {
     
489.              write_date(0x30+c%10);
     
490.              c=c/10;
     
491.              }
     
492.              write_date(0x3d);     
     
493.           a=0;b=0;flag=0;fuhao=0;
     
494.              }
     
495.       else if(fuhao==4){write_com(0x80+0x4f);
     
496.             write_com(0x04);
     
497.             i=0;
     
498.             c=(long)(((float)a/b)*1000);
     
499.             while(c!=0)
     
500.              {
     
501.                write_date(0x30+c%10);
     
502.                c=c/10;
     
503.            i++;
     
504.            if(i==3)
     
505.                write_date(0x2e);
     
506.              }
     
507.             if(a/b<=0)
     
508.               write_date(0x30);
     
509.             write_date(0x3d);                              
     
510.             a=0;b=0;flag=0;fuhao=0;
     
511.                     }
     
512.       }
     
513.      break;
     
514.      case 15:{write_date(0x30+table1[num]);flag=1;fuhao=1;}
     
515.      break;
     
516.    }
     
517. }
     
518. }
     
519. 
     
520. main()
     
521. {
     
522. init();
     
523. 
     
524. ………余下代码请下载附件………
     
525. 
     

复制代码

完整的课程设计报告（论文）下载：
单片机计算器课程设计报告.doc (154 KB, 下载次数: 82)

2017-5-25 13:13 上传

点击文件名下载附件
课设报告
下载积分: 黑币 -5