标题: MAX487+51单片机实现RS485通信程序Proteus仿真（实测通过） [打印本页]

---

作者: 美琴的备胎    时间: 2021-5-13 12:08
标题: MAX487+51单片机实现RS485通信程序Proteus仿真（实测通过）
   RS-485总线标准规定了总线接口的电气特性标准即对于2个逻辑状态的定义：正电平在+2V～+6V之间，表示一个逻辑状态；负电平在-2V～-6V之间，则表示另一个逻辑状态；数字信号采用差分传输方式，能够有效减少噪声信号的干扰。RS-485工业总线标准能够有效支持多个分节点和通信距离远，并且对于信息的接收灵敏度较高等特性。在工业通信网络中，RS-485总线一般主要用于与外部各种工业设备进行信息传输和数据交换，所具备的对于噪声的有效抑制能力、高效的数据传输速率与良好的数据传输的可靠性能以及可扩展的通信电缆的长度是其他的许多工业通信标准所无法比拟的。因此，RS-485总线在诸多个领域得到了广泛的应用，比如在工业控制领域、交通的自动化控制领域和现场总线通信网络等。
   RS-485接口的最大传输距离标准值为4000英尺，实际上可达 3000米(理论上的数据，在实际操作中，极限距离仅达1200米左右），另外RS-232-C接口在总线上只允许连接1个收发器，即单站能力。RS485接口在总线上是允许连接多达128个收发器。即具有多站能力,这样用户可以利用单一的RS-485接口方便地建立起设备网络。
本例程为STC89C52+RS485模块组成的“一主两从”模型。从机可拓展多位，修改主、从机地址即可。
本资料包含源文件、仿真程序。实测通过。

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

代码片段（主机）

1. #include<reg51.h>
   
2. #include<string.h>
   
3. #include "lcd.h"
   
4. #define _SUCC_   0x0f//数据传送成功
   
5. #define _ERR_    0xf0//数据传送失败
   
6. unsigned char aa=0xff;//主机与从机之间通信标志
   
7. unsigned char temp=0xff;
   
8. unsigned char Buff[20];//数据缓冲区
   
9. unsigned char recive[6];     //用于保存从机发送的数据
   
10. sbit KEY1=P1^3;
    
11. sbit KEY2=P1^2;
    
12. sbit KEY3=P1^1;
    
13. sbit KEY4=P1^0;
    
14. sbit KEY5=P3^2;
    
15. sbit KEY6=P3^3;
    
16. 
    
17. //sbit KEY5=P1^4;
    
18. //sbit KEY6=P1^5;
    
19. //延时1ms函数
    
20. void delay_1ms(unsigned int i)
    
21. {
    
22.      unsigned int x,y;
    
23.      for(x=i;x>0;x--)
    
24.          for(y=110;y>0;y--);
    
25. }
    
26. //串口初始化函数
    
27. void init()
    
28. {
    
29.      TMOD=0x20; //定时器1工作于方式2
    
30.      TH1=0xfd;  
    
31.      TL1=0xfd; //波特率为9600
    
32.      PCON=0;
    
33.      SCON=0xd0;  //串口工作于方式3
    
34.      TR1=1;  //开启定时器
    
35.      TI=0;
    
36.      RI=0;
    
37. }
    
38. 
    
39. 
    
40. //发送数据函数
    
41. void SEND_data(unsigned char *Buff)
    
42. {
    
43.      unsigned char i,lenth,check;
    
44.      lenth=strlen(Buff);      //计算数据长度
    
45.      check=lenth;
    
46.      TI=0;         //发送数据长度
    
47.      TB8=0;       //发送数据帧
    
48.      SBUF=lenth;
    
49.      while(!TI);
    
50.      TI=0;
    
51.          
    
52.      for(i=0;i<lenth;i++)  //发送数据
    
53.     {
    
54.         check=check^Buff[i];
    
55.         TB8=0;
    
56.         SBUF=Buff[i];      
    
57.         while(!TI);
    
58.         TI=0;
    
59.     }
    
60.       TB8=0;      //发送校验字节
    
61.       SBUF=check;   
    
62.       while(!TI);
    
63.       TI=0;     
    
64. }
    
65. 
    
66. //接收数据函数
    
67. unsigned char RECE_data(unsigned char *Buff)
    
68. {
    
69.      unsigned char i;
    
70.      unsigned char lenth;
    
71.      unsigned char check;
    
72.      RI=0;     //接收数据长度
    
73.      while(!RI);
    
74.      if(RB8==1)
    
75.      {
    
76.          RI = 0;   
    
77.          return 0xfe;  //若接收到地址帧，则返回0xfe
    
78.      }
    
79.      lenth=SBUF;
    
80.      RI=0;     
    
81.      check=lenth;
    
82.      for(i=0;i<lenth;i++) //接收数据
    
83.     {
    
84.         while(!RI);
    
85.         if(RB8==1)   //若接收到地址帧，则返回0xfe
    
86.         return 0xfe;
    
87.         Buff[i]=SBUF;   
    
88.         check=check^(Buff[i]);
    
89.         RI=0;
    
90.     }
    
91.      while(!RI);    //接收校验字节
    
92.      if(RB8==1)    //若接收到地址帧，则返回0xfe
    
93.      return 0xfe;
    
94.      temp=SBUF;
    
95.      RI=0;
    
96.      check=temp^check;  //将从主机接收到的校验码与自己计算的校验码比对
    
97.      if(check!=0)   //校验码不一致，表明数据接收错误，向主机发送错误信号，函数返回0xff
    
98.      {
    
99.         TI=0;
    
100.         TB8=0;
     
101.         SBUF=_ERR_;
     
102.         while(!TI);
     
103.         TI=0;
     
104.         return 0xff;
     
105.      }
     
106.      TI=0;           //校验码一致，表明数据接收正确，向主机发送成功信号，函数返回0x00
     
107.      TB8=0;
     
108.      SBUF=_SUCC_;         
     
109.      while(!TI);
     
110.      TI=0;
     
111.      return 0;
     
112. }                 
     
113. 
     
114. //发送从机地址
     
115. void ADDR_data(unsigned addr)
     
116. {
     
117. while(temp!=addr) //主机等待从机返回其地址作为应答信号
     
118. {
     
119.   TI=0;    //发送从机地址
     
120.   TB8=1;    //发送地址帧
     
121.   SBUF=addr;
     
122.   while(!TI);
     
123.   TI=0;
     
124.   
     
125.   RI=0;
     
126.   while(!RI);
     
127.   temp=SBUF;
     
128.   RI=0;
     
129. }
     
130. }
     
131. 
     
132. void keyscan()
     
133. {
     
134.   
     
135.   if(KEY1==0)
     
136.   {
     
137.      LcdWriteCom(0x01);  //清屏
     
138.      delay_1ms(5);
     
139.      if(KEY1==0)
     
140.     {
     
141.       while(!KEY1);
     
142.       ADDR_data(0x01);//发送从机地址
     
143.       temp=_ERR_;   //主机等待从机数据接收成功信号
     
144.       while(temp!=_SUCC_)
     
145.       {
     
146.           unsigned char Buff[]={0xfe};
     
147.           SEND_data(Buff);//发送数据
     
148.           RI=0;
     
149.           while(!RI);
     
150.           temp=SBUF;
     
151.           RI=0;
     
152.       }
     
153.       SM2=0;       //接收数据帧
     
154.       aa=0xff;    //从机接收数据，并将数据保存到数据缓冲区
     
155.       while(aa==0xff)
     
156.       {
     
157.           aa=RECE_data(Buff);
     
158.           P0 = 0xff;
     
159.       }
     
160.       P0 = 0xfe;
     
161.       recive[0] = Buff[0];
     
162.       recive[1] = Buff[1];
     
163.       recive[2] = Buff[2];
     
164.      
     
165.     }
     
166.   }
     
167. 
     
168.   if(KEY2==0)
     
169.   {
     
170.      LcdWriteCom(0x01);  //清屏
     
171.      delay_1ms(5);
     
172.      if(KEY2==0)
     
173.      {
     
174.         while(!KEY2);
     
175.         ADDR_data(0x01);
     
176.         temp=_ERR_;   //主机等待从机数据接收成功信号
     
177.         while(temp!=_SUCC_)
     
178.        {
     
179.           unsigned char Buff[]={0xff};
     
180.           SEND_data(Buff);
     
181.           RI=0;
     
182.           while(!RI);  
     
183.           RI=0;
     
184.           temp=SBUF;
     
185.        }
     
186.      }
     
187.   }
     
188. 
     
189.   if(KEY3==0)
     
190.   {
     
191.      LcdWriteCom(0x01);  //清屏
     
192.      delay_1ms(5);
     
193.      if(KEY3==0)
     
194.      {
     
195.          while(!KEY3);
     
196.          ADDR_data(0x02);
     
197.          temp=_ERR_;   //主机等待从机数据接收成功信号
     
198.          while(temp!=_SUCC_)
     
199.         {
     
200.            unsigned char Buff[]={0xfe};
     
201.            SEND_data(Buff);
     
202.            RI=0;
     
203.            while(!RI);
     
204.            temp=SBUF;
     
205.            RI=0;
     
206.         }
     
207.         SM2=0;       //接收数据帧
     
208.         aa=0xff;    //从机接收数据，并将数据保存到数据缓冲区
     
209.         while(aa==0xff)
     
210.         {
     
211.             aa=RECE_data(Buff);
     
212.             P0 = 0xff;
     
213.         }
     
214.         P0 = 0xfe;
     
215.         /*
     
216.         recive[3] = Buff[0];
     
217.         recive[4] = Buff[1];
     
218.         recive[5] = Buff[2];
     
219.         */
     
220.         recive[0] = Buff[0];
     
221.         recive[1] = Buff[1];
     
222.         recive[2] = Buff[2];
     
223.      }
     
224.   }
     
225. 
     
226.   if(KEY4==0)
     
227.   {
     
228.       LcdWriteCom(0x01);  //清屏
     
229.       delay_1ms(5);
     
230.       if(KEY4==0)
     
231.      {
     
232.          while(!KEY4);
     
233.          ADDR_data(0x02);
     
234.           temp=_ERR_;   //主机等待从机数据接收成功信号
     
235.          while(temp!=_SUCC_)
     
236.         {
     
237.              unsigned char Buff[]={0xff};
     
238.              SEND_data(Buff);
     
239.              RI=0;
     
240.              while(!RI);
     
241.              temp=SBUF;
     
242.              RI=0;
     
243.         }
     
244.      }
     
245.   }
     
246.   if(KEY5==0)
     
247.   {
     
248.       LcdWriteCom(0x01);  //清屏
     
249.       delay_1ms(5);
     
250.       if(KEY5==0)
     
251.      {
     
252.          while(!KEY5);
     
253.          ADDR_data(0x01);
     
254.           temp=_ERR_;   //主机等待从机数据接收成功信号
     
255.          while(temp!=_SUCC_)
     
256.         {
     
257.              unsigned char Buff[]={0xff};
     
258.              SEND_data(Buff);
     
259.              RI=0;
     
260.              while(!RI);
     
261.              temp=SBUF;
     
262.              RI=0;
     
263.         }
     
264.          ADDR_data(0x02);
     
265.           temp=_ERR_;   //主机等待从机数据接收成功信号
     
266.          while(temp!=_SUCC_)
     
267.         {
     
268.              unsigned char Buff[]={0xff};
     
269.              SEND_data(Buff);
     
270.              RI=0;
     
271.              while(!RI);
     
272.              temp=SBUF;
     
273.              RI=0;
     
274.         }
     
275.      }
     
276.   }
     
277.   if(KEY6==0)
     
278.   {
     
279.       LcdWriteCom(0x01);  //清屏
     
280.       delay_1ms(5);
     
281.       if(KEY6==0)
     
282.      {
     
283.          while(!KEY6);
     
284.          ADDR_data(0x01);
     
285.           temp=_ERR_;   //主机等待从机数据接收成功信号
     
286.          while(temp!=_SUCC_)
     
287.         {
     
288.              unsigned char Buff[]={0xff};
     
289.              SEND_data(Buff);
     
290.              RI=0;
     
291.              while(!RI);
     
292.              temp=SBUF;
     
293.              RI=0;
     
294.         }
     
295.          ADDR_data(0x02);
     
296.           temp=_ERR_;   //主机等待从机数据接收成功信号
     
297.          while(temp!=_SUCC_)
     
298.         {
     
299.              unsigned char Buff[]={0xff};
     
300.              SEND_data(Buff);
     
301.              RI=0;
     
302.              while(!RI);
     
303.              temp=SBUF;
     
304.              RI=0;
     
305.         }
     
306.      }
     
307.   }
     
308. 
     
309. }      
     
310. void main()
     
311. {
     
312.      init();
     
313.      LcdInit();             //初始化LCD1602
     
314.      LcdWriteCom(0x01);
     
315.      while(1)
     
316.      {
     
317.         keyscan();
     
318.         LcdWriteData(recive[0]);
     
319.         LcdWriteData(recive[1]);
     
320.         LcdWriteData(recive[2]);
     
321.         /*
     
322.         LcdWriteData(recive[3]);
     
323.         LcdWriteData(recive[4]);
     
324.         LcdWriteData(recive[5]);
     
325.         */
     
326.         LcdWriteCom(0x80);
     
327.      }
     
328. }
     

复制代码

51hei.png (6.3 KB, 下载次数: 210)

下载附件

2021-5-13 17:28 上传

RS485多机通信-1602显示从机信息.zip

2021-5-13 12:08 上传

点击文件名下载附件

下载积分: 黑币 -5

180.8 KB, 下载次数: 242, 下载积分: 黑币 -5

---

作者: bouyei    时间: 2021-6-8 11:48
正在做RS485，希望有帮助。

---

作者: hbkjdxsh    时间: 2022-6-30 16:13
不明白定时器方式2存在的意义是什么啊

---

作者: 新昌小徐    时间: 2022-7-1 07:50

hbkjdxsh 发表于 2022-6-30 16:13
不明白定时器方式2存在的意义是什么啊

自动重载定时器模式，如果是模式0，1溢出后需要在中断程序中手工添加赋初值语句。如果是模式2，系统直接把THx的值赋给TLx

---

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

Powered by Discuz! X3.1