51单片机超声波测距倒车雷达Proteus仿真+源代码

1） 基本任务
（1） 当车距（HC-SR04 超声波测距的位置）离障碍物小于 1 米，报警器响起， 发出一定
频率的“滴滴” 声音， 报警指示灯闪烁。
（2） LCD1602 液晶屏显示超声波模块安装位置与障碍物之间的距离。
2） 扩展任务：
（1） 随着车距与障碍物的距离的缩小，报警器声音越来越尖锐急促（声音频率越来越高）。
（2） 随着车距与障碍物的距离的缩小， 报警指示灯闪烁频率增加。
（3） 按键调整报警门限距离， 当车距离障碍物小于该值（默认值为 1 米），声音报警。
（4） LCD1602 第一行显示超声波模块安装位置与障碍物之间的距离；第二行实时显示按
键所调整的报警门限距离。  

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

倒车雷达的单片机源程序如下:

1. #include <REGX52.H>
   
2. #include <stdio.h>
   
3. #include "LCD.H"
   
4. #include "delay.h"
   
5. #define  uint unsigned int
   
6. #define  uchar unsigned char        
   
7.         
   
8. //定义引脚
   
9. sbit k1=P3^5;
   
10. sbit k2=P3^6;
    
11. sbit Trig=P2^5;   //trig 发射脉冲
    
12. sbit Echo=P3^2;  //echo 接受脉冲
    
13. sbit bg=P2^6;
    
14. sbit beep=P3^3;  //beep
    
15. sbit led=P1^2;
    
16. //定义固定显示
    
17. uchar juli[5]={'A','.','A','A','m'};
    
18. uchar set_juli[]={'A','.','A','A','m'};
    
19. uchar zifu[]={'D','i','s',':'};           //Distance
    
20. //定义全局变量
    
21. uchar time0_flag=0;  //定时器溢出中断
    
22. uint time=0;        //定时器定时时间
    
23. uchar one_final=0;   //一次测量完成
    
24. uint distance=0.0,set_dis=100;   //距离和设定报警距离
    
25. 
    
26. void display();
    
27. void Trig_SR04();
    
28. void button_choose();
    
29. void judge_baojing();
    
30. void main()
    
31. {
    
32.         
    
33.         EA=1;       //外部中断0下降沿触发  定时器0加门控位 高电平开启
    
34.         TMOD=0x09;  //16位 TR0=1; INT0=1; 开启
    
35.         TR0=1;
    
36.         EX0=1;
    
37.         IT0=1;      //下降沿触发
    
38.         
    
39.         TH0=0;
    
40.         TL0=0;
    
41.         init();     //1602初始化        
    
42.         Trig_SR04();
    
43.         while(1)
    
44.         {
    
45.                 if(one_final)   //一次完成后再次触发
    
46.                 {
    
47.                         Trig_SR04();
    
48.                         one_final=0;
    
49.                 }
    
50.                 judge_baojing();
    
51.                 display();    //液晶显示
    
52.                 button_choose();  //按键调整
    
53.         }
    
54. }
    
55. 
    
56. void INT0_hander() interrupt 0
    
57. {
    
58.         time = TH0*256+TH0;    //  time us
    
59.         distance=time*0.0170;  //cm    34000cm*10e-6*time/2
    
60.         one_final=1;
    
61.         TH0=0;
    
62.         TL0=0;
    
63. }
    
64. 
    
65. void Trig_SR04()  //仿真里是地脉冲触发
    
66. {
    
67.         Trig=0;
    
68.         Trig=1;
    
69.         _nop_();
    
70.         _nop_();
    
71.         _nop_();
    
72.         _nop_();
    
73.         _nop_();
    
74.         _nop_();
    
75.         _nop_();
    
76.         _nop_();
    
77.         _nop_();
    
78.         _nop_();
    
79.         _nop_();
    
80.         _nop_();
    
81.         _nop_();
    
82.         _nop_();
    
83.         _nop_();
    
84.         _nop_();
    
85.         _nop_();
    
86.         _nop_();
    
87.         _nop_();
    
88.         _nop_();
    
89.         _nop_();
    
90.         Trig=0;
    
91. }
    
92. 
    
93. 
    
94. void judge_baojing()
    
95. {
    
96.         uint time_baojing,i;
    
97.         if(distance<set_dis)
    
98.         {
    
99.                         time_baojing=distance*10;
    
100.                           for (i=0;i<time_baojing;i++)
     
101.                           {
     
102.                             DelayUs2x(100);
     
103.                             beep=!beep;       //BEEP取反
     
104.                           }
     
105.                                 for (i=0;i<time_baojing;i++)
     
106.                           {
     
107.                                         led=~led;
     
108.                                         DelayUs2x(time_baojing);
     
109.                           }
     
110.         }
     
111. }
     
112. void display()
     
113. {
     
114.         if(distance<5) //测量值小于下限
     
115.                 {
     
116.                         juli[0]='-';
     
117.                         juli[2]='-';
     
118.                         juli[3]='-';
     
119.                 }
     
120.         else if(distance>500)        //测量值大于上限
     
121.                 {
     
122.                         juli[0]='C';
     
123.                         juli[2]='C';
     
124.                         juli[3]='C';
     
125.                 }
     
126.         else
     
127.         {
     
128.                 juli[0]=distance/100+'0';
     
129.                 juli[2]=distance/10%10+'0';
     
130.                 juli[3]=distance%10+'0';
     
131.         }
     
132.         set_juli[0]=set_dis/100+'0';
     
133.         set_juli[2]=set_dis/10%10+'0';
     
134.         set_juli[3]=set_dis%10+'0';
     
135.         
     
136.         LCD_Write_String(11,0,juli);  //显示测距
     
137.         LCD_Write_String(5,0,zifu);   //显示distance
     
138.         LCD_Write_String(11,1,set_juli); //显示报警距离
     
139. }
     
140. 
     
141. 
     
142. void button_choose()
     
143. {
     
144.         uint k,e,xs;   //e 控制个性化显示 xs显示周期
     
145.         uchar a1,a2,a3,n=0,m=0,z=0;   //按键调整 a1,a2,a3调整设定距离的三位从高到低  nmz控制循环
     
146.                 if(!k1)      //按键处理程序
     
147.                 {
     
148.                         EA=0;
     
149.                         TR0=0;
     
150.                   set_juli[0]='A';
     
151.                         set_juli[1]='.';
     
152.                         set_juli[2]='A';
     
153.                         set_juli[3]='A';
     
154.                         set_juli[4]='m';
     
155.                         LCD_Write_String(11,1,set_juli);
     
156.                         k=500;
     
157.                   while(k)
     
158.                         {
     
159.                                  k--;
     
160.                                 DelayMs(2);
     
161.                         }
     
162.                   set_juli[0]=set_dis/100+'0';
     
163.                         set_juli[2]=set_dis/10%10+'0';
     
164.                         set_juli[3]=set_dis%10+'0';
     
165.                         LCD_Write_String(11,1,set_juli);
     
166.                         a1=set_dis/100;
     
167.                         a2=set_dis/10%10;
     
168.                         a3=set_dis%10;
     
169.                         
     
170.                         
     
171.                         //按键调整最小距离
     
172.                         n=1;
     
173.                   while(n)
     
174.                         {
     
175.                                 if(!k2)
     
176.                                 {
     
177.                                         while(!k2);
     
178.                                         e=1;
     
179.                                         xs=3;
     
180.                                         a1+=1;
     
181.                                         if(a1>5)
     
182.                                         a1=0;
     
183.                                           juli[0]=a1+'0';
     
184.                                 }
     
185. 
     
186.                                 if (e==1)
     
187.                                 {
     
188.                                         xs++;
     
189.                                            juli[0]=a1+'0';
     
190.                                           if(xs>6)
     
191.                                           {
     
192.                                     xs=0;
     
193.                                                                         e=0;
     
194.                                           }
     
195.                                 }
     
196.                                 else
     
197.                                 {
     
198.                                         juli[0]=' ';
     
199.                                         xs++;
     
200.                                         if(xs>3)
     
201.                                         {
     
202.                                                 xs=0;
     
203.                                                 e=1;
     
204.                                         }
     
205.                                 }
     
206.                                 LCD_Write_String(11,1,juli);
     
207.                                 if(!k1)
     
208.                                 {
     
209.                                         while(!k1);
     
210.                                            juli[0]=a1+'0';
     
211.                                         m=1;
     
212.                                         while(m)
     
213.                                         {
     
214.                                                 if(!k2)
     
215.                                                 {
     
216.                                                         while(!k2);
     
217.                                                         e=1;
     
218.                                                         xs=3;
     
219.                                                         a2+=1;
     
220.                                                         if(a2>9)
     
221.                                                         a2=0;
     
222.                                                           juli[2]=a2+'0';
     
223.                                                         LCD_Write_String(11,1,juli);
     
224.                                                 }
     
225. 
     
226.                                                 if (e==1)
     
227.                                                 {
     
228.                                                         xs++;
     
229.                                                            juli[2]=a2+'0';
     
230.                                                           if(xs>6)
     
231.                                                           {
     
232.                                                     xs=0;
     
233.                                                                                         e=0;
     
234.                                                           }
     
235.                                                 }
     
236.                                                 else
     
237.                                                 {
     
238.                                                         juli[2]=' ';
     
239.                                                         xs++;
     
240.                                                         if(xs>3)
     
241.                                                         {
     
242.                                                                 xs=0;
     
243.                                                                 e=1;
     
244.                                                         }
     
245.                                                 }
     
246.                                                 LCD_Write_String(11,1,juli);
     
247.                                                 
     
248.                                                 if(!k1)
     
249.                                                 {
     
250.                                                         while(!k1);
     
251.                                                         juli[2]=a2+'0';
     
252.                                                         z=1;
     
253.                                                         while(z)
     
254.                                                         {
     
255.                                                                 if(!k2)
     
256.                                                                 {
     
257.                                                                         while(!k2);
     
258.                                                                         e=1;
     
259.                                                                         xs=3;
     
260.                                                                         a3+=1;
     
261.                                                                         if(a3>9)
     
262.                                                   a3=0;
     
263.                                                                   juli[3]=a3+'0';
     
264.                                                                         LCD_Write_String(11,1,juli);
     
265.                                                                 }
     
266. 
     
267.                                                                 if (e==1)
     
268.                                                                 {
     
269.                                                                         xs++;
     
270.                                                                            juli[3]=a3+'0';
     
271.                                                                           if(xs>6)
     
272.                                                                           {
     
273.                                                     xs=0;
     
274. ……………………
     
275. 
     
276. …………限于本文篇幅 余下代码请从51黑下载附件…………
     

复制代码

附件如下：带仿真和keil源码 51超声波测距报警.zip (113.86 KB, 下载次数: 352)

2020-11-22 09:23 上传

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

好资料，51黑有你更精彩!!!

楼主，仿真没有反应

GEYI123546 发表于 2021-6-12 15:19
楼主，仿真没有反应

用Proteus7.5打开才有反应,如图

你好，请问为什么我把显示的位置改成第一行0位后就出现了这种情况？

那超声波测距和测速的原理图是不是一样的呢

proteus 8 打开没有显示，改天换个版本试下吧