单片机超声波程序(带详细注释)Proteus仿真图

这是我之前做的基于STM32的超声波测距系统，
附件里面包含了keil仿真代码以及Proteus仿真工程
请大家多多指教



单片机源程序如下:

1. //头文件包含
   
2. #include <reg52.h>                //提供单片机寄存器地址
   
3. #include <intrins.h>        //提供_nop_()函数
   
4. 
   
5. unsigned int code duan_ma[16] = {0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,                //0~9
   
6.                                                                  0x77,0x7c,0x39,0x5e,0x79,0x71};        //A~F
   
7. unsigned int dis_buf[4];                        //显示缓存的数组
   
8. unsigned int S = 0;                                        //距离缓存变量
   
9. unsigned long time = 0;                                //时间缓存变量
   
10. unsigned int S_H = 400, S_L = 10;        //S_H：报警上限值，默认400cm，S_L：报警下限值，默认10cm
    
11. 
    
12. //引脚定义
    
13. sbit BEEP = P3^7;                //蜂鸣器控制端口，低电平有效，无源蜂鸣器
    
14.                                                                  
    
15. #define digDuan                P0                //数码管段控制端口，高电平有效
    
16. sbit digWei1 = P2^4;                //第1位数码管控制端口，低电平有效
    
17. sbit digWei2 = P2^5;                //第2位数码管控制端口，低电平有效
    
18. sbit digWei3 = P2^6;                //第3位数码管控制端口，低电平有效
    
19. sbit digWei4 = P2^7;                //第4位数码管控制端口，低电平有效                                                                 
    
20.        
    
21. sbit KEY1 = P1^0;                        //设置键
    
22. sbit KEY2 = P1^1;                        //加键
    
23. sbit KEY3 = P1^2;                        //减键                                                                 
    
24.                        
    
25. sbit Ttig = P1^3;                //触发信号控制端口
    
26. sbit Echo = P1^4;                //回响信号接收端口
    
27.                                                                  
    
28. /* 定时器0和1初始化，定时1ms */
    
29. void InitTimer0(void)
    
30. {
    
31.   TMOD = 0x11;        //配置定时器0为工作方式1，定时器1位工作方式1
    
32.         TH0 = 0;
    
33.   TL0 = 0;
    
34.         TH1 = 0x0EC;        //定时5ms
    
35.   TL1 = 0x78;
    
36.         EA = 1;                        //打开总中断
    
37.         ET1 = 1;                //打开定时器0中断
    
38.         TR1 = 1;                //打开定时器1
    
39.   TR0 = 0;                //打开定时器0
    
40. }
    
41. 
    
42. /*
    
43. * 数码管扫描
    
44. * *dat：以数组的方式传值，使用的时候直接填入数组名即可
    
45. */  
    
46. void dig_scan(unsigned int *dat)
    
47. {
    
48.         static unsigned char i = 0;        //循环变量
    
49. 
    
50.         /* 数码管扫描处理 */
    
51.         digDuan = 0x00;                //消隐
    
52.         digWei1 = 1;                       
    
53.         digWei2 = 1;                        
    
54.         digWei3 = 1;
    
55.         digWei4 = 1;
    
56.         switch(i)
    
57.         {
    
58.                 case 0:
    
59.                 {
    
60.                         digWei1 = 0;                        //选通第1位数码管
    
61.                         digDuan = dat[0];                //显示第1位数码管的内容
    
62.                         break;
    
63.                 }
    
64.                 case 1:
    
65.                 {
    
66.                         digWei2 = 0;                        //选通第2位数码管
    
67.                         digDuan = dat[1];                //显示第2位数码管的内容
    
68.                         break;
    
69.                 }
    
70.                 case 2:
    
71.                 {
    
72.                         digWei3 = 0;                                //选通第3位数码管
    
73.                         digDuan = dat[2] + 0x80;        //显示第3位数码管的内容，顺便也显示小数点
    
74.                         break;
    
75.                 }
    
76.                 case 3:
    
77.                 {
    
78.                         digWei4 = 0;                        //选通第4位数码管
    
79.                          digDuan = dat[3];                //显示第4位数码管的内容
    
80.                         break;       
    
81.                 }
    
82.                 default: break;
    
83.         }
    
84.         ++i;                //数码管位选变量循环
    
85.         if(i >= 4)
    
86.                 i = 0;                               
    
87. }
    
88. 
    
89. /* 按键延时函数，单位：ms */
    
90. static void key_delayms(unsigned int ms)
    
91. {
    
92.         unsigned char a,b,c;
    
93.         while(--ms)
    
94.         {
    
95.             for(c=1;c>0;c--)
    
96.                 for(b=142;b>0;b--)
    
97.                     for(a=2;a>0;a--);
    
98.         }
    
99. }
    
100. /* 按键扫描 */
     
101. unsigned char key_scan(void)
     
102. {
     
103.         if(KEY1 == 0)                        //如果按键1按下
     
104.         {
     
105.                 key_delayms(10);        //延时10ms,去除按键抖动
     
106.                 if(KEY1 == 0)                //再判断一次按键按下
     
107.                 {
     
108.                         return 1;                 //输出键值1
     
109.                 }       
     
110.         }
     
111.         if(KEY2 == 0)                //如果按键2按下
     
112.         {
     
113.                 key_delayms(10);        //延时10ms,去除按键抖动
     
114.                 if(KEY2 == 0)                //再判断一次按键按下
     
115.                 {
     
116.                         return 2;                 //输出键值2
     
117.                 }
     
118.         }
     
119.         if(KEY3 == 0)                //如果按键3按下
     
120.         {
     
121.                 key_delayms(10);        //延时10ms,去除按键抖动
     
122.                 if(KEY3 == 0)                //再判断一次按键按下
     
123.                 {
     
124.                         return 3;                 //输出键值3
     
125.                 }
     
126.         }
     
127. 
     
128.         return 0;                                //如果没有按键按下，则输出0
     
129. }
     
130. 
     
131. /* 启动超声波程序 */
     
132. void StartModule(void)
     
133. {
     
134.         Ttig = 1;                        //启动一次模块
     
135.         _nop_();                        //延时一段时间，至少10us以上
     
136.         _nop_();                        
     
137.         _nop_();
     
138.         _nop_();
     
139.         _nop_();
     
140.         _nop_();
     
141.         _nop_();
     
142.         _nop_();
     
143.         _nop_();
     
144.         _nop_();
     
145.         _nop_();
     
146.         _nop_();
     
147.         _nop_();
     
148.         _nop_();
     
149.         _nop_();
     
150.         _nop_();
     
151.         _nop_();
     
152.         _nop_();
     
153.         _nop_();
     
154.         _nop_();
     
155.         _nop_();
     
156.         Ttig = 0;
     
157. }
     
158. 
     
159. /* 延时，单位：ms */
     
160. void delayms(unsigned int ms)
     
161. {
     
162.         unsigned char a,b,c;
     
163. 
     
164.         while(--ms)
     
165.         {
     
166.             for(c=1;c>0;c--)
     
167.                 for(b=142;b>0;b--)
     
168.                     for(a=2;a>0;a--);       
     
169.         }
     
170. }
     
171. 
     
172. 
     
173. 
     
174. /* 计算测距 */
     
175. void count(void)
     
176. {
     
177.         StartModule();        //启动一次超声波
     
178.         while(!Echo);                //等待超声波模块输出IO拉高
     
179.         TR0 = 1;                        //开启定时器计时
     
180.         while(Echo);                //等待超声波模块输出IO拉低
     
181.         TR0 = 0;                         //关闭定时器计时
     
182.        
     
183.         /* 计算距离 */
     
184.         time = TH0 * 256 + TL0;        //得到的时间，专业写法应该是这样：time = TH0 << 8 | TL0
     
185.         TH0 = 0;                                //定时计数器清零       
     
186.         TL0 = 0;
     
187.        
     
188.         S = (time * 1.7) / 100; //算出来是M                               
     
189. }
     
190. /* 显示距离 */
     
191. void dis_distance(void)
     
192. {
     
193.         dis_buf[3] = 0x00;
     
194.         dis_buf[2] = duan_ma[S / 100 %10];         //取出百位数，并在数码管的第3位显示，从右往左数
     
195.         dis_buf[1] = duan_ma[S / 10 %10];        //取出十位数，并在数码管的第2位显示，从右往左数
     
196.         dis_buf[0] = duan_ma[S % 10];                 //取出个位数，并在数码管的第1位显示，从右往左数       
     
197. }
     
198. /* 设置报警功能 */
     
199. void key_fuction(void)
     
200. {
     
201.         unsigned char mode_flag = 1;        //模式切换标记位，1：设置上限值，2：设置下限值，3：退出
     
202. 
     
203.         while(1)
     
204.         {
     
205.                 if(key_scan() == 1)       
     
206.                 {
     
207.                         BEEP = 0;                        //按键提示音
     
208.                         delayms(50);
     
209.                         BEEP = 1;
     
210.                         delayms(1000);
     
211.                         ++mode_flag;
     
212.                         if(mode_flag >= 3)        //如果满3了，则退出
     
213.                                 break;               
     
214.                 }
     
215.                 if(key_scan() == 2)                //如果加键按下
     
216.                 {
     
217.                         BEEP = 0;                        //按键提示音
     
218.                         delayms(50);
     
219.                         BEEP = 1;
     
220.                         delayms(1000);
     
221.                         if(mode_flag == 1)        //设置上限值
     
222.                         {
     
223.                                 ++S_H;
     
224.                                 if(S_H > 400)
     
225.                                         S_H = 2;       
     
226.                         }
     
227.                         if(mode_flag == 2)        //设置下限值
     
228.                         {
     
229.                                 ++S_L;
     
230.                                 if(S_L > 400)
     
231.                                         S_L = 2;       
     
232.                         }
     
233.                 }
     
234.                 if(key_scan() == 3)                //如果减键按下
     
235.                 {
     
236.                         BEEP = 0;                        //按键提示音
     
237.                         delayms(50);
     
238.                         BEEP = 1;
     
239.                         delayms(1000);
     
240.                         if(mode_flag == 1)        //设置上限值
     
241.                         {
     
242.                                 --S_H;
     
243.                                 if(S_H < 2)
     
244.                                         S_H = 400;       
     
245.                         }
     
246.                         if(mode_flag == 2)        //设置下限值
     
247.                         {
     
248.                                 --S_L;
     
249.                                 if(S_L < 2)
     
250.                                         S_L = 400;       
     
251.                         }
     
252.                 }
     
253. 
     
254.                 /* 报警设置显示 */
     
255.                 if(mode_flag == 1)         //显示设置上限值内容
     
256.                 {
     
257.                         dis_buf[3] = 0x76;                                                //第4位数码管显示字母 H
     
258.                         dis_buf[2] = duan_ma[S_H / 100 % 10];         //显示百位数
     
259.                         dis_buf[1] = duan_ma[S_H / 10 % 10];        //显示十位数
     
260.                         dis_buf[0] = duan_ma[S_H % 10];                        //显示个位数
     
261.                 }
     
262.                 if(mode_flag == 2)                 //显示设置下限值内容
     
263.                 {
     
264.                         dis_buf[3] = 0x38;        //第4位数码管显示字母 L
     
265.                         dis_buf[2] = duan_ma[S_L / 100 % 10];         //显示百位数
     
266.                         dis_buf[1] = duan_ma[S_L / 10 % 10];        //显示十位数
     
267.                         dis_buf[0] = duan_ma[S_L % 10];                        //显示个位数
     
268.                 }               
     
269.         }
     
270. }
     
271. 
     
272. /* 主函数 */
     
273. void main(void)
     
274. {
     
275.         digDuan = 0x40;                //显示"----"
     
276.         digWei1 = 0;
     
277.         digWei2 = 0;
     
278.         digWei3 = 0;
     
279.         digWei4 = 0;
     
280.         delayms(1000);                //延时大约1s
     
281.         InitTimer0();                //定时器0初始化
     
282. 
     
283.         while(1)
     
284.         {
     
285.                 count();                                        //计算距离
     
286.                 if(S>=S_H || S<=S_L)                //如果超出设定的范围，则显示"---"
     
287.                 {
     
288.                         dis_buf[3] = 0x00;
     
289.                         dis_buf[2] = 0x40;                 //显示"---"
     
290.                         dis_buf[1] = 0x40;
     
291.                         dis_buf[0] = 0x40;       
     
292.                         BEEP = 0;                        //蜂鸣器鸣叫
     
293.                         delayms(1000);
     
294.                 }
     
295.                 else
     
296.                 {
     
297.                         BEEP = 1;                        //关闭蜂鸣器
     
298.                         dis_distance();                //显示距离
     
299.                 }
     
300. 
     
301.                 if(key_scan() == 1)                //如果按下设置键，则进入设置报警功能
     
302.                 {
     
303.                         BEEP = 0;                        //按键提示音
     
304.                         delayms(50);
     
305.                         BEEP = 1;
     
306.                         delayms(100);
     
307.                          key_fuction();                //进入设置报警功能
     
308.                 }                       
     
309.         }
     
310. }
     
311. 
     
312. 
     
313. /* 定时器0中断服务函数，5ms进一次本中断，用于数码管扫描 */
     
314. void Timer1Interrupt(void) interrupt 3
     
315. {
     
316.                 TH1 = 0x0EC;                //定时5ms，重新赋值
     
317.     TL1 = 0x78;
     
318. 
     
319.                 dig_scan(dis_buf);        //数码管显示距离
     
320. }
     
321. 
     
322. 
     

复制代码

Proteus8.17仿真程序: 单片机超声波.zip (149.3 KB, 下载次数: 0)

2025-1-5 11:07 上传

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

这是51单片机，不是STM32单片机。