Proteus仿真51单片机4路超声波测距LCD1602显示程序

原件清单

序号	编号	型号、规格	描述	数量	备注
1	R1	10k	1/4W电阻	1	复位电阻
2	R2	4.7k	1/4W电阻	1
3	W1	10k	精密可调调电阻	1
4	BY	BEEP	蜂鸣器	1
5	BG1	9012	PNP	1
6	C1	470uF/16V	电解电容	1
7	C2	104	瓷片电容	1
8	C3	10uF	电解电容	1
7	C4	22pF	瓷片电容	1
10	C5	22pF	瓷片电容	1
11	IC1	AT89S51    AT89S52	单片机	1	AT89C51   AT89C52   STC89C52RC
12	IC座	DIP40	40集成电路座	1
13	Y1	12MHz	晶振	1
14	USB	USB	USB接口	1
15	HC-SR04	HC-SR04	超声波测距模块	4	测量范围2-450厘米
16	D1	1N4007	整流二极管	1
17	ZXZ1	DG7.62-2P	接线端子	1
18	PCB	9*12厘米	9*12厘米以上洞洞板	1
19		1602	1602液晶屏	1
20	K1、		按键开关	1
21		DS18B20	温度传感器	1
			导线		若干
			焊锡丝		若干

仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）

单片机源程序如下:

1. #include <REGX52.H>
   
2. #include <stdio.h>
   
3. #include "LCD.H"
   
4. #include "18B20.H"
   
5. #include "delay.h"
   
6. 
   
7. sbit csb=P1^4;                        // 第一路 Trig
   
8. sbit csbint=P1^5;                // 第一路 Echo
   
9. sbit csb1=P1^6;                   //  第二路 Trig
   
10. sbit csbint1=P1^7;           //  第二路 Echo
    
11. sbit csb2=P3^6;                   //  第三路 Trig
    
12. sbit csbint2=P3^5;           //  第三路 Echo
    
13. sbit csb3=P3^4;                   //  第四路 Trig
    
14. sbit csbint3=P3^3;           //  第四路 Echo
    
15. sbit k1=P1^0;           //  K1
    
16. sbit k2=P1^1;           //  K2
    
17. sbit led=P2^7;           //  指示灯
    
18. 
    
19. 
    
20. sbit fmq=P3^2;                   //蜂鸣器
    
21. 
    
22. unsigned char aa[16]={' ','.',' ',' ','m',' ',' ',' ',' ',' ',' ',' ','.',' ',' ','m'};
    
23. unsigned char bb[16]={' ','.',' ',' ','m',' ','.',' ',' ',' ',' ',' ','.',' ',' ','m'};        
    
24. 
    
25. unsigned char zf;
    
26.                                          
    
27. unsigned int dz,k,s,j,bgz,k,s1,s2,s3,s4;
    
28. int temp;
    
29. float csbc,wdz;
    
30. 
    
31. 
    
32. main()
    
33. {
    
34.         TH0=0;
    
35.         TL0=0;
    
36.         TMOD=0X11;        //T1,T0为16位定时器
    
37.         EA=0;
    
38. 
    
39.          init();
    
40.     Init_DS18B20();
    
41.     dz=100;                  //报警定值
    
42.         LCD_Write_String(0,0,aa);
    
43.         aa[9]=0xdf;
    
44.         while(1)
    
45.         {
    
46.                  temp=ReadTemperature();
    
47. 
    
48.                 DelayMs(100);
    
49.                 if(temp<0)
    
50.                 {
    
51.                            temp=-(temp-1);
    
52.                            zf=1;
    
53.                         aa[12]='-';
    
54.                 }
    
55.                 else
    
56.                 {
    
57.                         zf=0;
    
58.                         aa[12]=' ';
    
59.                 }
    
60.                 wdz=0.00000607*temp;   //温度补偿计算
    
61.                 if(zf==0)
    
62.                 {                                                                                                                                                                                       
    
63.                           csbc=0.03315+wdz;
    
64.                 }
    
65.                 else csbc=0.03315-wdz;
    
66. 
    
67.                 aa[6]=temp/1000+0x30;
    
68.                 aa[7]=temp/100%10+0x30;//显示十位
    
69.                 aa[8]=temp%100/10+0x30;//显示个位
    
70.         if(zf==0)
    
71.             {
    
72.                         if(temp<1000)
    
73.                         {
    
74.                                    aa[6]=' ';
    
75.                                    if(temp<100)
    
76.                                    {
    
77.                                       aa[7]=' ';
    
78.                                 }
    
79.                         }
    
80.                 }
    
81.                 else
    
82.                 {
    
83.                         if(temp<1000)
    
84.                         {
    
85.                                    aa[6]='-';
    
86. //                                   aa[12]=' ';
    
87.                                    if(temp<100)
    
88.                                    {
    
89.                                         aa[6]=' ';
    
90.                                            aa[7]='-';
    
91.                                 }
    
92.                         }
    
93.                 }
    
94. 
    
95. ///////////////////////////////////////////
    
96. //                    第一路        测距模块                         //
    
97. ///////////////////////////////////////////
    
98.                   csb=0;                                             //启动一次模块
    
99.                   _nop_();
    
100.                   _nop_();
     
101.                   _nop_();
     
102.                   _nop_();
     
103.                   _nop_();
     
104.                   _nop_();
     
105.                   _nop_();
     
106.                   _nop_();
     
107.                   _nop_();
     
108.                   _nop_();
     
109.                   _nop_();
     
110.                   _nop_();
     
111.                   _nop_();
     
112.                   _nop_();
     
113.                   _nop_();
     
114.                   _nop_();
     
115.                   _nop_();
     
116.                   _nop_();
     
117.                   _nop_();
     
118.                   _nop_();
     
119.                   _nop_();
     
120.                   _nop_();
     
121.                   _nop_();
     
122.                   _nop_();
     
123.                   _nop_();
     
124.                   csb=1;
     
125.                 ET0=1;        //启动计数器T0，用以计时
     
126.                 TR0=1;
     
127.                 EA=1;
     
128.                 j=50;        //延时                  
     
129.             while(j--)
     
130.                 {
     
131.                 }
     
132.                 csbint=1;
     
133.         j=0;
     
134.                    while(csbint)                        //判断接收回路是否收到超声波的回波
     
135.                 {
     
136.                         j++;
     
137.                         if(j>=2500)                        //如果达到一定时间没有收到回波,则将csbint置零,退出接收回波处理程序
     
138.                         csbint=0;
     
139.                 }
     
140.                 TR0=0;
     
141.                 s1=TH0*256+TL0;                        //读取时间数据
     
142.                 TH0=0;
     
143.                 TL0=0;
     
144.                 csbc=csbc/2;
     
145.                 s1=s1*csbc-4;
     
146. 
     
147. ///////////////////////////////////////////
     
148. //                    第二路        测距模块                         //
     
149. ///////////////////////////////////////////
     
150.                   csb1=0;                                             //启动一次模块
     
151.                   _nop_();
     
152.                   _nop_();
     
153.                   _nop_();
     
154.                   _nop_();
     
155.                   _nop_();
     
156.                   _nop_();
     
157.                   _nop_();
     
158.                   _nop_();
     
159.                   _nop_();
     
160.                   _nop_();
     
161.                   _nop_();
     
162.                   _nop_();
     
163.                   _nop_();
     
164.                   _nop_();
     
165.                   _nop_();
     
166.                   _nop_();
     
167.                   _nop_();
     
168.                   _nop_();
     
169.                   _nop_();
     
170.                   _nop_();
     
171.                   _nop_();
     
172.                   _nop_();
     
173.                   _nop_();
     
174.                   _nop_();
     
175.                   _nop_();
     
176.                   csb1=1;
     
177.                 ET0=1;        //启动计数器T0，用以计时
     
178.                 TR0=1;
     
179.                 EA=1;
     
180.                 j=50;        //延时                  
     
181.             while(j--)
     
182.                 {
     
183.                 }
     
184.                 csbint1=1;
     
185.         j=0;
     
186.                    while(csbint1)                        //判断接收回路是否收到超声波的回波
     
187.                 {
     
188.                         j++;
     
189.                         if(j>=2500)                        //如果达到一定时间没有收到回波,则将csbint置零,退出接收回波处理程序
     
190.                         csbint1=0;
     
191.                 }
     
192.                 TR0=0;
     
193.                 s2=TH0*256+TL0;                        //读取时间数据
     
194.                 TH0=0;
     
195.                 TL0=0;
     
196.                 s2=s2*csbc-4;
     
197. 
     
198. ///////////////////////////////////////////
     
199. //                    第三路        测距模块                         //
     
200. ///////////////////////////////////////////
     
201. 
     
202.                   csb2=0;                                             //启动一次模块
     
203.                   _nop_();
     
204.                   _nop_();
     
205.                   _nop_();
     
206.                   _nop_();
     
207.                   _nop_();
     
208.                   _nop_();
     
209.                   _nop_();
     
210.                   _nop_();
     
211.                   _nop_();
     
212.                   _nop_();
     
213.                   _nop_();
     
214.                   _nop_();
     
215.                   _nop_();
     
216.                   _nop_();
     
217.                   _nop_();
     
218.                   _nop_();
     
219.                   _nop_();
     
220.                   _nop_();
     
221.                   _nop_();
     
222.                   _nop_();
     
223.                   _nop_();
     
224.                   _nop_();
     
225.                   _nop_();
     
226.                   _nop_();
     
227.                   _nop_();
     
228.                   csb2=1;
     
229.                 ET0=1;        //启动计数器T0，用以计时
     
230.                 TR0=1;
     
231.                 EA=1;
     
232.                 j=50;        //延时                  
     
233.             while(j--)
     
234.                 {
     
235.                 }
     
236.                 csbint2=1;
     
237.         j=0;
     
238.                    while(csbint2)                        //判断接收回路是否收到超声波的回波
     
239.                 {
     
240.                         j++;
     
241.                         if(j>=2500)                        //如果达到一定时间没有收到回波,则将csbint置零,退出接收回波处理程序
     
242.                         csbint2=0;
     
243.                 }
     
244.                 TR0=0;
     
245.                 s3=TH0*256+TL0;                        //读取时间数据
     
246.                 TH0=0;
     
247.                 TL0=0;
     
248.                 s3=s3*csbc-4;
     
249. ///////////////////////////////////////////
     
250. //                    第四路        测距模块                         //
     
251. ///////////////////////////////////////////
     
252. 
     
253.                   csb3=0;                                             //启动一次模块
     
254.                   _nop_();
     
255.                   _nop_();
     
256.                   _nop_();
     
257.                   _nop_();
     
258.                   _nop_();
     
259.                   _nop_();
     
260.                   _nop_();
     
261.                   _nop_();
     
262.                   _nop_();
     
263.                   _nop_();
     
264.                   _nop_();
     
265.                   _nop_();
     
266.                   _nop_();
     
267.                   _nop_();
     
268.                   _nop_();
     
269.                   _nop_();
     
270.                   _nop_();
     
271.                   _nop_();
     
272.                   _nop_();
     
273.                   _nop_();
     
274.                   _nop_();
     
275.                   _nop_();
     
276.                   _nop_();
     
277.                   _nop_();
     
278.                   _nop_();
     
279.                   csb3=1;
     
280.                 ET0=1;        //启动计数器T0，用以计时
     
281.                 TR0=1;
     
282.                 EA=1;
     
283.                 j=50;        //延时                  
     
284.             while(j--)
     
285.                 {
     
286.                 }
     
287.                 csbint3=1;
     
288.         j=0;
     
289.                    while(csbint3)                        //判断接收回路是否收到超声波的回波
     
290.                 {
     
291.                         j++;
     
292.                         if(j>=2500)                        //如果达到一定时间没有收到回波,则将csbint置零,退出接收回波处理程序
     
293.                         csbint2=0;
     
294.                 }
     
295.                 TR0=0;
     
296.                 s4=TH0*256+TL0;                        //读取时间数据
     
297.                 TH0=0;
     
298.                 TL0=0;
     
299.                 s4=s4*csbc-2;
     
300. 
     
301.                 if(s1<5) //测量值小于下限
     
302.                 {
     
303.                         aa[0]='-';
     
304.                         aa[2]='-';
     
305.                         aa[3]='-';
     
306.                 }
     
307.                 else if(s1>200)        //测量值大于上限
     
308.                 {
     
309.                         aa[0]='C';
     
310.                         aa[2]='C';
     
311.                         aa[3]='C';
     
312.                 }
     
313.                 else
     
314.                 {
     
315.                         aa[0]=s1/100+'0';
     
316.                         aa[2]=s1/10%10+'0';
     
317.                         aa[3]=s1%10+'0';
     
318.                 }
     
319. 
     
320.                 if(s2<5) //测量值小于下限
     
321.                 {
     
322.                         bb[0]='-';
     
323.                         bb[2]='-';
     
324.                         bb[3]='-';
     
325.                 }
     
326.                 else if(s2>200)        //测量值大于上限
     
327.                 {
     
328.                         bb[0]='C';
     
329.                         bb[2]='C';
     
330.                         bb[3]='C';
     
331.                 }
     
332.                 else
     
333.                 {
     
334.                         bb[0]=s2/100+'0';
     
335.                         bb[2]=s2/10%10+'0';
     
336.                         bb[3]=s2%10+'0';
     
337.                 }
     
338. 
     
339.                 if(s3<5) //测量值小于下限
     
340.                 {
     
341.                         bb[11]='-';
     
342.                         bb[13]='-';
     
343.                         bb[14]='-';
     
344.                 }
     
345.                 else if(s3>200)        //测量值大于上限
     
346.                 {
     
347.                         bb[11]='C';
     
348.                         bb[13]='C';
     
349.                         bb[14]='C';
     
350.                 }
     
351.                 else
     
352.                 {
     
353.                         bb[11]=s3/100+'0';
     
354.                         bb[13]=s3/10%10+'0';
     
355.                         bb[14]=s3%10+'0';
     
356.                 }
     
357. ///////////////////////////////////////////
     
358.                  if(s4<5) //测量值小于下限
     
359.                 {
     
360.                         aa[11]='-';
     
361.                                 aa[12]='.';
     
362.                         aa[13]='-';
     
363.                         aa[14]='-';
     
364.                 }
     
365.                 else if(s4>200)        //测量值大于上限
     
366.                 {
     
367.                         aa[11]='C';
     
368.                         aa[12]='.';
     
369.                         aa[13]='C';
     
370.                         aa[14]='C';
     
371.                 }
     
372.                 else
     
373.                 {
     
374.                         aa[11]=s4/100+'0';
     
375.                         aa[12]='.';
     
376.                         aa[13]=s4/10%10+'0';
     
377.                         aa[14]=s4%10+'0';
     
378.                 }
     
379.             if(k1==0)
     
380.                    {
     
381. //                           while(k1==0);
     
382.                            dz++;
     
383.                         if(dz>200)
     
384.                            {
     
385.                                    dz=200;
     
386.                            }
     
387.                    }
     
388.         if(k2==0)
     
389.                 {
     
390. //                        while(k2==0);
     
391.                         dz--;
     
392.                         if(dz<30)
     
393.                         {
     
394.                                    dz=30;
     
395.                         }
     
396.                 }
     
397.                 bb[6]=dz/100+'0';
     
398.                 bb[7]='.';
     
399.                 bb[8]=dz/10%10+'0';
     
400.                 bb[9]=dz%10+'0';
     
401. 
     
402. 
     
403. 
     
404. ///////////////////////////////////////////
     
405. 
     
406. 
     
407.             if(s1<s2)
     
408.                 {
     
409.                    s=s1;
     
410.                 }
     
411.                 else s=s2;
     
412. 
     
413.             if(s<s3)
     
414.                 {
     
415.                    s=s;
     
416.                 }
     
417.                 else s=s3;
     
418. 
     
419.              if(s<s4)
     
420.                 {
     
421.                    s=s;
     
422.                 }
     
423.                 else s=s4;
     
424. 
     
425.                 if(s<dz)
     
426.                 {
     
427.                         bgz=s*5;
     
428.                           for (k=0;k<bgz;k++)
     
429.                           {
     
430.                             DelayUs2x(150);
     
431.                             fmq=0;       //BEEP
     
432.                                 led=0;
     
433.                           }
     
434.                 }
     
435.                 fmq=1;
     
436.                 led=1;
     
437.                 LCD_Write_String(0,0,aa);
     
438.                 LCD_Write_String(0,1,bb);
     
439.         }
     
440. }
     

复制代码

keil工程文件以及Proteus仿真原理图压缩至附件
LCD1602显示的超声波测距板_四路_按键.zip (621.4 KB, 下载次数: 96)

2020-6-1 15:25 上传

点击文件名下载附件

这种东西就别上传了,论坛里面太多了