单片机计算器代码Proteus仿真 可实现加减乘除运算 lcd1602显示

单片机源程序如下:

1. /****************************************
   
2.         计算器五位数以内+，-，*，/                  
   
3.         c：删除一个数或一个运算符
   
4.         lcd1602显示
   
5. 
   
6. 
   
7. *****************************************/
   
8. #include<reg52.h>
   
9. #define uchar unsigned char
   
10. #define uint unsigned int
    
11. sbit rs=P2^0;//指令0，数据1
    
12. sbit rw=P2^1;//读0，写1，引脚
    
13. sbit lcden=P2^2;//使能端
    
14. uchar temp,num,flag,i,j,k,n,m,aa[10]={0},bb[11]={0};
    
15. uint sum[20]={0},count;
    
16. /**********************************************
    
17.     延时函数  ms
    
18. *********************************************/        
    
19. void delayms(uint t)
    
20. {
    
21.     uint x,y;
    
22.         for(x=t;x>0;x--)
    
23.         for(y=110;y>0;y--);
    
24. }
    
25. /**********************************************
    
26.     1602指令，数据，初始化
    
27. *********************************************/
    
28. void write_1602com(uchar com)
    
29. {
    
30.     P0=com;
    
31.         rs=0;//指令
    
32.         rw=0;//写
    
33.         lcden=0;
    
34.         delayms(20);
    
35.         lcden=1;
    
36.         delayms(20);
    
37.         lcden=0;
    
38. }
    
39. void write_1602date(uchar date)
    
40. {
    
41.     P0=date;
    
42.         rs=1;//数据
    
43.         rw=0;//写
    
44.         lcden=0;
    
45.         delayms(20);
    
46.         lcden=1;
    
47.         delayms(20);
    
48.         lcden=0;
    
49. }
    
50. void init_lcd1602()
    
51. {
    
52.         write_1602com(0x38);//选择16x2显示，5x7点阵
    
53.         delayms(20);
    
54.         write_1602com(0x0f);//开显示，开光标，光标闪烁
    
55.         delayms(20);
    
56.         write_1602com(0x06);//读或写后，指针加一，光标加一
    
57.         delayms(20);
    
58.         write_1602com(0x01);//清屏
    
59.         delayms(20);
    
60. }
    
61. /*****************************************
    
62.         检测按键并输出
    
63. ******************************************/
    
64. uchar keyscan()                           
    
65. {
    
66.         P3=0xfe;
    
67.         temp=P3;
    
68.         while(temp!=0xfe)
    
69.         {
    
70.                 delayms(5);
    
71.                 temp=P3;
    
72.                 while(temp!=0xfe)
    
73.                 {
    
74.                         switch(temp)
    
75.                         {
    
76.                                 case 0xee:num=7;
    
77.                                         break;
    
78.                                 case 0xde:num=8;
    
79.                                         break;
    
80.                                 case 0xbe:num=9;
    
81.                                         break;
    
82.                                 case 0x7e:num='/';
    
83.                                         break;
    
84.                         }
    
85.                         while(temp!=0xfe)
    
86.                         {
    
87.                                 flag=1;
    
88.                                 temp=P3;
    
89.                         }
    
90.                 }
    
91.         }
    
92.         P3=0xfd;
    
93.         temp=P3;
    
94.         while(temp!=0xfd)
    
95.         {
    
96.                 delayms(5);
    
97.                 temp=P3;
    
98.                 while(temp!=0xfd)
    
99.                 {
    
100.                         switch(temp)
     
101.                         {
     
102.                                 case 0xed:num=4;
     
103.                                         break;
     
104.                                 case 0xdd:num=5;
     
105.                                         break;
     
106.                                 case 0xbd:num=6;
     
107.                                         break;
     
108.                                 case 0x7d:num='*';
     
109.                                         break;
     
110.                         }
     
111.                         while(temp!=0xfd)
     
112.                         {
     
113.                                 flag=1;
     
114.                                 temp=P3;
     
115.                         }
     
116.                 }
     
117.         }
     
118.         
     
119.         P3=0xfb;
     
120.         temp=P3;
     
121.         while(temp!=0xfb)
     
122.         {
     
123.                 delayms(5);
     
124.                 temp=P3;
     
125.                 while(temp!=0xfb)
     
126.                 {
     
127.                         switch(temp)
     
128.                         {
     
129.                                 case 0xeb:num=1;
     
130.                                         break;
     
131.                                 case 0xdb:num=2;
     
132.                                         break;
     
133.                                 case 0xbb:num=3;
     
134.                                         break;
     
135.                                 case 0x7b:num='-';
     
136.                                         break;
     
137.                         }
     
138.                         while(temp!=0xfb)
     
139.                         {
     
140.                                 flag=1;
     
141.                                 temp=P3;
     
142.                         }
     
143.                 }
     
144.         }
     
145.         P3=0xf7;
     
146.         temp=P3;
     
147.         while(temp!=0xf7)
     
148.         {
     
149.                 delayms(5);
     
150.                 temp=P3;
     
151.                 while(temp!=0xf7)
     
152.                 {
     
153.                         switch(temp)
     
154.                         {
     
155.                                 case 0xe7:num='c';
     
156.                                         break;
     
157.                                 case 0xd7:num=0;
     
158.                                         break;
     
159.                                 case 0xb7:num='=';
     
160.                                         break;
     
161.                                 case 0x77:num='+';
     
162.                                         break;
     
163.                         }
     
164.                         while(temp!=0xf7)
     
165.                         {
     
166.                                 flag=1;
     
167.                                 temp=P3;
     
168.                         }
     
169.                 }
     
170.         }
     
171.         return num;
     
172. }
     
173. /*********************************************
     
174.         将逐个输入数 aa[] 转化为整数
     
175. *********************************************/
     
176. void zuan_shu()                                   
     
177. {
     
178.          switch(n)
     
179.         {
     
180.                 case 0:sum[j++]=0;break;
     
181.                 case 1:sum[j++]=aa[0];break;
     
182.                 case 2:sum[j++]=aa[0]*10+aa[1];break;
     
183.                 case 3:sum[j++]=aa[0]*100+aa[1]*10+aa[2];break;
     
184.                 case 4:sum[j++]=aa[0]*1000+aa[1]*100+aa[2]*10+aa[3];break;
     
185. /*                case 5:sum[j++]=aa[0]*10000+aa[1]*1000+aa[2]*100+aa[3]*10+aa[4];break;
     
186.                 case 6:sum[j++]=aa[0]*100000+aa[1]*10000+aa[2]*1000+aa[3]*100+aa[4]*10+aa[5];break;
     
187.                 case 7:sum[j++]=aa[0]*1000000+aa[1]*100000+aa[2]*10000+aa[3]*1000+aa[4]*100+aa[5]*10+aa[6];break;
     
188.                 case 8:sum[j++]=aa[0]*10000000+aa[1]*1000000+aa[2]*100000+aa[3]*10000+aa[4]*1000+aa[5]*100+aa[6]*10+aa[7];break;
     
189. */               
     
190.         }                                
     
191. }
     
192. /****************************************************
     
193.         液晶显示函数
     
194. ******************************************************/
     
195. void lcd1602_display(uint count)                                   
     
196. {
     
197.          uchar a,b,c,d,e;  //f,g,h;
     
198.         a=count%10;
     
199.         b=count/10%10;
     
200.         c=count/100%10;
     
201.         d=count/1000%10;
     
202.         e=count/10000%10;
     
203. /*        f=count/100000%10;
     
204.         g=count/1000000%10;
     
205.         h=count/10000000%10;
     
206. 
     
207.         write_date(0x30+h);
     
208.         write_date(0x30+g);
     
209.         write_date(0x30+f);
     
210. */
     
211.         if(e!=0)
     
212.         write_1602date(0x30+e);
     
213.         if((e==0&&d!=0)||e!=0)
     
214.         write_1602date(0x30+d);
     
215.         if((e==0&&d==0&&c!=0)||e!=0||d!=0)
     
216.         write_1602date(0x30+c);
     
217.         if((e==0&&d==0&&c==0&&b!=0)||e!=0||d!=0||c!=0)
     
218.         write_1602date(0x30+b);
     
219.         write_1602date(0x30+a);        
     
220. }
     
221. /*************************************************
     
222.         运算结果函数并保存至   sum[k]
     
223. **************************************************/
     
224. void yunsuan()                                                   
     
225. {
     
226.          uchar m;
     
227.         for(k=0;bb[k]!=0&&k<10;k++)                                  //先找出高级运算符运算
     
228.         {
     
229.                 if(bb[k]=='*')
     
230.                 {
     
231.                         sum[k+1]=sum[k]*sum[k+1];
     
232.                         sum[k]='N';
     
233.                 }
     
234.                 if(bb[k]=='/')
     
235.                 {
     
236.                         sum[k+1]=sum[k]/sum[k+1];
     
237.                         sum[k]='N';
     
238.                 }
     
239.         }
     
240.         for(k=0;bb[k]!=0&&k<10;k++)
     
241.         {
     
242.                  if(bb[k]=='+')
     
243.                 {
     
244.                         for(m=1;sum[k+m]=='N';)
     
245.                         {
     
246.                                  m++;        
     
247.                         }
     
248.                         sum[k+m]=sum[k]+sum[k+m];
     
249.                 }
     
250.                 if(bb[k]=='-')
     
251.                 {
     
252.                         for(m=1;sum[k+m]=='N';)
     
253.                         {
     
254.                                  m++;        
     
255.                         }
     
256.                         sum[k+m]=sum[k]-sum[k+m];
     
257.                 }
     
258.         }
     
259. }
     
260. /*************************************************  
     
261.         main函数
     
262. ***************************************************/
     
263. void main()
     
264. {
     
265.     init_lcd1602();
     
266.         while(1)
     
267.         {         
     
268.             flag=0;
     
269.                  keyscan();
     
270.                 if(flag!=0)
     
271.                 {
     
272.                         if(num>=0&&num<=9)
     
273.                         {
     
274.                                  aa[i++]=num;
     
275.                                 write_1602date(0x30+num);
     
276.                                 n++;
     
277.                         }
     
278.                         if(num=='+')
     
279.                         {
     
280.                                 write_1602date(0x20+11);//1602   '+'符
     
281.                                 bb[k++]=num;
     
282.                                 zuan_shu();
     
283.                                 for(i=0;i<n;i++)
     
284.                                 aa[i]=0;
     
285.                                 i=0;
     
286.                                 n=0;
     
287.                         }
     
288.                         if(num=='-')
     
289.                         {
     
290.                                 write_1602date(0x20+13);//1602   '-'符
     
291.                                 bb[k++]=num;
     
292.                                 zuan_shu();
     
293.                                 for(i=0;i<n;i++)
     
294.                                 aa[i]=0;
     
295.                                 i=0;
     
296.                                 n=0;
     
297.                         }
     
298.                         if(num=='*')
     
299.                         {
     
300.                                 write_1602date(0x20+10);//1602   '*'符
     
301.                                 bb[k++]=num;
     
302.                                 zuan_shu();
     
303.                                 for(i=0;i<n;i++)
     
304.                                 aa[i]=0;
     
305.                                 i=0;
     
306.                                 n=0;
     
307.                         }
     
308.                         if(num=='/')
     
309.                         {
     
310.                                 write_1602date(0xf0+13);//1602   '/'符
     
311.                                 bb[k++]=num;
     
312.                                 zuan_shu();
     
313.                                 for(i=0;i<n;i++)
     
314.                                 aa[i]=0;
     
315.                                 i=0;
     
316.                                 n=0;
     
317.                         }
     
318.                         if(num=='c'&&m==0)                                 //删除一个数或一个运算符
     
319.                         {
     
320.                                 write_1602com(0x04);//读或写后，指针减一，光标减一
     
321.                                 write_1602date(' ');//1602   空符                        
     
322.                                 write_1602com(0x06);//读或写后，指针加一，光标加一
     
323.                                 if(n!=0)
     
324.                                 {
     
325.                                          n--;
     
326.                                         aa[--i]=0;
     
327.                                 }
     
328.                                 else
     
329.                                 {
     
330.                                          bb[--k]=0;
     
331.                                 }
     
332.                         }
     
333.                         if(num=='=')
     
334.                         {
     
335.                                 m=1;
     
336.                                 write_1602com(0xc0);
     
337.                                 write_1602date(0x30+13);//1602   '='符
     
338.                                 zuan_shu();
     
339.                                 yunsuan();
     
340.                                 count=sum[k];
     
341.                                 lcd1602_display(count);
     
342.                                 write_1602com(0x0c);
     
343.                         }        
     
344.                 }        
     
345.         }
     
346. }
     

复制代码

Keil代码与Proteus8.13仿真下载:
源文件.zip (111.39 KB, 下载次数: 49)

2023-6-19 10:09 上传

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

怎么清屏?

怎么清屏?