标题: 求大神帮忙看一下，哪里出问题了，为什么不能完成双机通讯 [打印本页]

---

作者: asho2017    时间: 2017-5-24 15:07
标题: 求大神帮忙看一下，哪里出问题了，为什么不能完成双机通讯
超声波检测停车位信息，传给另一个单片机显示信息，为什么仿真不出来，代码有问题吗？主机代码

1. #include <REGX52.H>
   
2. #include <stdio.h>
   
3. #include<intrins.h>
   
4. 
   
5. sbit csb=P1^0;                        // 第一路 Trig
   
6. sbit csbint=P1^1;                // 第一路 Echo
   
7. sbit csb1=P1^3;                   //  第二路 Trig
   
8. sbit csbint1=P1^2;           //  第二路 Echo
   
9. sbit csb2=P1^5;                   //  第三路 Trig
   
10. sbit csbint2=P1^4;           //  第三路 Echo
    
11. sbit csb3=P1^7;                   //  第四路 Trig
    
12. sbit csbint3=P1^6;           //  第四路 Echo
    
13. 
    
14. sbit RS = P0^7;   //定义端口
    
15. sbit RW = P0^6;
    
16. sbit EN = P0^5;
    
17. 
    
18. #define RS_CLR RS=0
    
19. #define RS_SET RS=1
    
20. 
    
21. #define RW_CLR RW=0
    
22. #define RW_SET RW=1
    
23. 
    
24. #define EN_CLR EN=0
    
25. #define EN_SET EN=1
    
26.        
    
27. unsigned char cc[]={' ',' ',' ',' ','T','o','t','a','l',':','4',' ',' ',' ',' ',' '};
    
28. unsigned char dd[]={'F','r','e','e',':',' ',' ',' ',' ','B','u','s','y',':',' ',' '};
    
29.                                          
    
30. unsigned int a1,a2,a3,a4,s,j,s1,s2,s3,s4,kw;
    
31. float csbc;
    
32. 
    
33. void DelayUs2x(unsigned char t)
    
34. {   
    
35.         while(--t);
    
36. }
    
37. 
    
38. void DelayMs(unsigned char t)
    
39. {
    
40.           while(t--)                 //大致延时1mS
    
41.         {
    
42.              DelayUs2x(245);
    
43.                  DelayUs2x(245);
    
44.         }
    
45. }
    
46. void MasterUART_init(void)
    
47. {
    
48.     SCON = 0x50;
    
49.     TMOD = 0x20;
    
50.     TH1  = 0xFD;
    
51.     TL1  = 0xFD;
    
52.     TR1  = 1;
    
53. }
    
54. void Send(unsigned char dat)
    
55. 
    
56. {
    
57. 
    
58.         SBUF=dat;
    
59.    while(TI==0)
    
60.       ;                        //等待
    
61.     TI=0;
    
62. }
    
63. void write_com(unsigned char com) //写命令
    
64. {
    
65.         RS_CLR;
    
66.         RW_CLR;
    
67.         P2=com;
    
68.         DelayMs(2);
    
69.         EN_SET;
    
70.         DelayMs(2);
    
71.         EN_CLR;
    
72. }
    
73. 
    
74. void write_data(unsigned char date)         //写一个字符
    
75. {
    
76.         RS_SET;
    
77.         RW_CLR;
    
78.         P2=date;
    
79.         DelayMs(2);
    
80.         EN_SET;
    
81.         DelayMs(2);
    
82.         EN_CLR;
    
83. }
    
84. 
    
85. void init()                        //初始化
    
86. {
    
87.         write_com(0x38);
    
88.         write_com(0x0c);
    
89.         write_com(0x06);
    
90.         write_com(0x01);
    
91. }
    
92. 
    
93. /*------------------------------------------------
    
94.               写入字符串函数
    
95. ------------------------------------------------*/
    
96. void LCD_Write_String(unsigned char x,unsigned char y,unsigned char *s)
    
97. {     
    
98.         if (y == 0)
    
99.         {     
    
100.                  write_com(0x80 + x);     
     
101.         }
     
102.         else
     
103.         {     
     
104.                 write_com(0xC0 + x);     
     
105.         }        
     
106.         while (*s)
     
107.         {     
     
108.                 write_data( *s);     
     
109.                 s ++;     
     
110.         }
     
111. }
     
112. main()
     
113. {
     
114.         TH0=0;
     
115.         TL0=0;
     
116.         TMOD=0X11;        //T1,T0为16位定时器
     
117.         EA=0;
     
118.         init();
     
119.           while(1)
     
120.         {
     
121.                
     
122. ///////////////////////////////////////////
     
123. //                    第一路        测距模块                         //
     
124. ///////////////////////////////////////////
     
125.                   csb=0;                                             //启动一次模块
     
126.                   _nop_();
     
127.                   _nop_();
     
128.                   _nop_();
     
129.                   _nop_();
     
130.                   _nop_();
     
131.                   _nop_();
     
132.                   _nop_();
     
133.                   _nop_();
     
134.                   _nop_();
     
135.                   _nop_();
     
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.                   csb=1;
     
152.                 ET0=1;        //启动计数器T0，用以计时
     
153.                 TR0=1;
     
154.                 EA=1;
     
155.                 j=150;        //延时                 
     
156.             while(j--)
     
157.                 {
     
158.                 }
     
159.                 csbint=1;
     
160.         j=0;
     
161.                    while(csbint)                        //判断接收回路是否收到超声波的回波
     
162.                 {
     
163.                         j++;
     
164.                         if(j>=2500)                        //如果达到一定时间没有收到回波,则将csbint置零,退出接收回波处理程序
     
165.                         csbint=0;
     
166.                 }
     
167.                 TR0=0;
     
168.                 s1=TH0*256+TL0;                        //读取时间数据
     
169.                 TH0=0;
     
170.                 TL0=0;
     
171.                 csbc=0.034;
     
172.                 csbc=csbc/2;
     
173.                 s1=s1*csbc-8;
     
174. 
     
175. ///////////////////////////////////////////
     
176. //                    第二路        测距模块                         //
     
177. ///////////////////////////////////////////
     
178.                   csb1=0;                                             //启动一次模块
     
179.                   _nop_();
     
180.                   _nop_();
     
181.                   _nop_();
     
182.                   _nop_();
     
183.                   _nop_();
     
184.                   _nop_();
     
185.                   _nop_();
     
186.                   _nop_();
     
187.                   _nop_();
     
188.                   _nop_();
     
189.                   _nop_();
     
190.                   _nop_();
     
191.                   _nop_();
     
192.                   _nop_();
     
193.                   _nop_();
     
194.                   _nop_();
     
195.                   _nop_();
     
196.                   _nop_();
     
197.                   _nop_();
     
198.                   _nop_();
     
199.                   _nop_();
     
200.                   _nop_();
     
201.                   _nop_();
     
202.                   _nop_();
     
203.                   _nop_();
     
204.                   csb1=1;
     
205.                 ET0=1;        //启动计数器T0，用以计时
     
206.                 TR0=1;
     
207.                 EA=1;
     
208.                 j=150;        //延时                 
     
209.             while(j--)
     
210.                 {
     
211.                 }
     
212.                 csbint1=1;
     
213.         j=0;
     
214.                    while(csbint1)                        //判断接收回路是否收到超声波的回波
     
215.                 {
     
216.                         j++;
     
217.                         if(j>=2500)                        //如果达到一定时间没有收到回波,则将csbint置零,退出接收回波处理程序
     
218.                         csbint1=0;
     
219.                 }
     
220.                 TR0=0;
     
221.                 s2=TH0*256+TL0;                        //读取时间数据
     
222.                 TH0=0;
     
223.                 TL0=0;
     
224.                 csbc=0.034;
     
225.                 csbc=csbc/2;
     
226.                 s2=s2*csbc-8;
     
227. 
     
228. ///////////////////////////////////////////
     
229. //                    第三路        测距模块                         //
     
230. ///////////////////////////////////////////
     
231. 
     
232.                   csb2=0;                                             //启动一次模块
     
233.                   _nop_();
     
234.                   _nop_();
     
235.                   _nop_();
     
236.                   _nop_();
     
237.                   _nop_();
     
238.                   _nop_();
     
239.                   _nop_();
     
240.                   _nop_();
     
241.                   _nop_();
     
242.                   _nop_();
     
243.                   _nop_();
     
244.                   _nop_();
     
245.                   _nop_();
     
246.                   _nop_();
     
247.                   _nop_();
     
248.                   _nop_();
     
249.                   _nop_();
     
250.                   _nop_();
     
251.                   _nop_();
     
252.                   _nop_();
     
253.                   _nop_();
     
254.                   _nop_();
     
255.                   _nop_();
     
256.                   _nop_();
     
257.                   _nop_();
     
258.                   csb2=1;
     
259.                 ET0=1;        //启动计数器T0，用以计时
     
260.                 TR0=1;
     
261.                 EA=1;
     
262.                 j=150;        //延时                 
     
263.             while(j--)
     
264.                 {
     
265.                 }
     
266.                 csbint2=1;
     
267.         j=0;
     
268.                    while(csbint2)                        //判断接收回路是否收到超声波的回波
     
269.                 {
     
270.                         j++;
     
271.                         if(j>=2500)                        //如果达到一定时间没有收到回波,则将csbint置零,退出接收回波处理程序
     
272.                         csbint2=0;
     
273.                 }
     
274.                 TR0=0;
     
275.                 s3=TH0*256+TL0;                        //读取时间数据
     
276.                 TH0=0;
     
277.                 TL0=0;
     
278.                 csbc=0.034;
     
279.                 csbc=csbc/2;
     
280.                 s3=s3*csbc-8;
     
281. ///////////////////////////////////////////
     
282. //                    第四路        测距模块                         //
     
283. ///////////////////////////////////////////
     
284. 
     
285.                   csb3=0;                                             //启动一次模块
     
286.                   _nop_();
     
287.                   _nop_();
     
288.                   _nop_();
     
289.                   _nop_();
     
290.                   _nop_();
     
291.                   _nop_();
     
292.                   _nop_();
     
293.                   _nop_();
     
294.                   _nop_();
     
295.                   _nop_();
     
296.                   _nop_();
     
297.                   _nop_();
     
298.                   _nop_();
     
299.                   _nop_();
     
300.                   _nop_();
     
301.                   _nop_();
     
302.                   _nop_();
     
303.                   _nop_();
     
304.                   _nop_();
     
305.                   _nop_();
     
306.                   _nop_();
     
307.                   _nop_();
     
308.                   _nop_();
     
309.                   _nop_();
     
310.                   _nop_();
     
311.                   csb3=1;
     
312.                 ET0=1;        //启动计数器T0，用以计时
     
313.                 TR0=1;
     
314.                 EA=1;
     
315.                 j=150;        //延时                 
     
316.             while(j--)
     
317.                 {
     
318.                 }
     
319.                 csbint3=1;
     
320.         j=0;
     
321.                    while(csbint3)                        //判断接收回路是否收到超声波的回波
     
322.                 {
     
323.                         j++;
     
324.                         if(j>=2500)                        //如果达到一定时间没有收到回波,则将csbint置零,退出接收回波处理程序
     
325.                         csbint2=0;
     
326.                 }
     
327.                 TR0=0;
     
328.                 s4=TH0*256+TL0;                        //读取时间数据
     
329.                 TH0=0;
     
330.                 TL0=0;
     
331.                 csbc=0.034;
     
332.                 csbc=csbc/2;
     
333.                 s4=s4*csbc-8;
     
334. 
     
335.                 if(s1>100) //测量值小于下限
     
336.                 {
     
337.                         a1=0;
     
338.                 }
     
339.                 else
     
340.                 {
     
341.                         a1=1;
     
342.                 }
     
343. 
     
344. 
     
345.                 if(s2>100) //测量值小于下限
     
346.                 {
     
347.                         a2=0;
     
348.                 }
     
349.                 else
     
350.                 {
     
351.                         a2=1;
     
352.                 }
     
353. 
     
354.                 if(s3>100) //测量值小于下限
     
355.                 {
     
356.                         a3=0;
     
357.                 }
     
358.                 else
     
359.                 {
     
360.                         a3=1;
     
361.                 }
     
362. 
     
363. 
     
364.                 if(s4>100) //测量值小于下限
     
365.                 {
     
366.                         a4=0;
     
367.                 }
     
368.                 else
     
369.                 {
     
370.                         a4=1;
     
371.                 }
     
372. 
     
373.                 kw=a1+a2+a3+a4;
     
374.                 dd[14]=kw+'0';
     
375.                 dd[5]=4-kw+'0';
     
376.                 LCD_Write_String(0,0,cc);
     
377.                 LCD_Write_String(0,1,dd);
     
378.         }
     
379.         MasterUART_init();
     
380.         while(1)
     
381.         {
     
382.            Send(kw);        //发送数据i
     
383.        DelayMs(2);
     
384.          }
     
385. }

复制代码

从机代码

1. #include<reg51.h>
   
2. #include<intrins.h>
   
3. #define uchar  unsigned char
   
4. #define uint    unsigned int
   
5. uchar code DSY_CODE[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x00};
   
6. void delay_ms(uint t)
   
7. {
   
8.   uint m,n;
   
9.   for (m=0;m<t;m++)
   
10.    for (n=0;n<1000;n++);
    
11. 
    
12. }
    
13. void SlaveUART_init(void)
    
14. {
    
15.     SCON = 0x50;
    
16.     TMOD = 0x20;
    
17.     TH1  = 0xFD;
    
18.     TL1  = 0xFD;
    
19.     TR1  = 1;
    
20. }
    
21. unsigned char Receive(void)
    
22. {
    
23.           unsigned char dat;
    
24.           while(RI==0)  
    
25.          ;      //等待，直至接收完毕（RI=1）
    
26.         RI=0;      //为了接收下一帧数据，需将RI清0
    
27.     dat=SBUF;  //将接收缓冲器中的数据存于dat
    
28.         return dat;
    
29. }
    
30. 
    
31. main()
    
32. {
    
33.     unsigned char tmp;
    
34.     SlaveUART_init();
    
35.     while(1);
    
36.         {
    
37.             tmp=Receive();
    
38.                 P0=DSY_CODE[tmp];
    
39.         }
    
40. }
    

复制代码

电路图

QQ截图20170524150421.png (20.19 KB, 下载次数: 70)

下载附件

2017-5-24 15:04 上传

---

作者: cjjcjj1    时间: 2017-5-24 20:25
提示: 作者被禁止或删除 内容自动屏蔽

---

作者: asho2017    时间: 2017-5-25 12:42

cjjcjj1 发表于 2017-5-24 20:25
你好！你现在仿真的情况是怎么样？实现了什么，还存在什么问题

您好 情况已经解决了 谢谢

---

作者: BYYTL    时间: 2017-5-26 10:40
这么快就解决了

---

作者: dengyifenzhong    时间: 2017-5-27 13:23
超声波检测在protues用的是哪个器件，请楼主分享一下，谢谢

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1