标题: 单片机多机通信互传数据仿真+代码(1602显示从机信息) [打印本页]

---

作者: Vence    时间: 2019-3-11 16:43
标题: 单片机多机通信互传数据仿真+代码(1602显示从机信息)
功能说明：主机功能：按下key1，从机1灯亮,lcd显示从机1发送的数据，按下key2，从机1灯。按下key3，从机2灯亮，lcd显示从机2发送的数据；按下key4，从机2灯灭，按下key5，从机1和从机2灯灭；按下key6，从机1和从机2灯灭；
proteus仿真图：


主机部分单片机代码：

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

复制代码

从机1部分代码：

1. #include<reg51.h>
   
2. #include<string.h>
   
3. #define addr     0x01//从机1的地址
   
4. #define _SUCC_   0x0f//数据传送成功
   
5. #define _ERR_    0xf0//数据传送失败
   
6. unsigned char aa=0xff;//主机与从机之间通信标志
   
7. unsigned char Buff[20];//数据缓冲区
   
8. unsigned char ceshi[] = {0x77,0x78,0x56};                //传递给主机的信息
   
9. unsigned char tp;
   
10. //串口初始化函数
    
11. void init()
    
12. {
    
13.      TMOD=0x20; //定时器1工作于方式2
    
14.      TH1=0xfd;  
    
15.      TL1=0xfd; //波特率为9600
    
16.      PCON=0;
    
17.      SCON=0xd0;  //串口工作于方式3
    
18.      TR1=1;  //开启定时器         
    
19.      TI=0;
    
20.      RI=0;
    
21. }
    
22. 
    
23. //发送数据函数
    
24. void SEND_data(unsigned char *Buff)
    
25. {
    
26.      unsigned char i,lenth,check;
    
27.      lenth=strlen(Buff);      //计算数据长度
    
28.      check=lenth;
    
29.      TI=0;         //发送数据长度
    
30.      TB8=0;       //发送数据帧
    
31.      SBUF=lenth;
    
32.      while(!TI);
    
33.      TI=0;
    
34.          
    
35.      for(i=0;i<lenth;i++)  //发送数据
    
36.     {
    
37.         check=check^Buff[i];
    
38.         TB8=0;
    
39.         SBUF=Buff[i];      
    
40.         while(!TI);
    
41.         TI=0;
    
42.     }
    
43.       TB8=0;      //发送校验字节
    
44.       SBUF=check;   
    
45.       while(!TI);
    
46.       TI=0;     
    
47. }
    
48. 
    
49. //接收数据函数
    
50. unsigned char RECE_data(unsigned char *Buff)
    
51. {
    
52.      unsigned char i,temp;
    
53.      unsigned char lenth;
    
54.      unsigned char check;
    
55.      RI=0;     //接收数据长度
    
56.      while(!RI);
    
57.      if(RB8==1)
    
58.          {
    
59.                  RI = 0;   
    
60.              return 0xfe;  //若接收到地址帧，则返回0xfe
    
61.          }
    
62.      lenth=SBUF;
    
63.      RI=0;     
    
64.      check=lenth;
    
65.      for(i=0;i<lenth;i++) //接收数据
    
66.     {
    
67.         while(!RI);
    
68.         if(RB8==1)   //若接收到地址帧，则返回0xfe
    
69.         return 0xfe;
    
70.         Buff[i]=SBUF;   
    
71.         check=check^(Buff[i]);
    
72.         RI=0;
    
73.     }
    
74.      while(!RI);    //接收校验字节
    
75.      if(RB8==1)    //若接收到地址帧，则返回0xfe
    
76.      return 0xfe;
    
77.      temp=SBUF;
    
78.      RI=0;
    
79.      check=temp^check;  //将从主机接收到的校验码与自己计算的校验码比对
    
80.      if(check!=0)   //校验码不一致，表明数据接收错误，向主机发送错误信号，函数返回0xff
    
81.      {
    
82.         TI=0;
    
83.         TB8=0;
    
84.         SBUF=_ERR_;
    
85.         while(!TI);
    
86.         TI=0;
    
87.         return 0xff;
    
88.      }
    
89.      TI=0;           //校验码一致，表明数据接收正确，向主机发送成功信号，函数返回0x00
    
90.      TB8=0;
    
91.      SBUF=_SUCC_;            
    
92.      while(!TI);
    
93.      TI=0;
    
94.      return 0;
    
95. }                                 
    
96. void main()
    
97. {
    
98.     init();
    
99.     while(1)
    
100.    {
     
101.        SM2=1;              //处于接收地址帧状态
     
102.        while(aa!=addr)  //从机等待主机请求自己的地址
     
103.       {
     
104.            RI=0;
     
105.            while(!RI);
     
106.            aa=SBUF;
     
107.            RI=0;
     
108.       }
     
109.       TI=0;     //一旦被请求，从机返回自己的地址作为应答，等待接收数据
     
110.       TB8=0;
     
111.       SBUF=addr;
     
112.       while(!TI);
     
113.       TI=0;
     
114.       SM2=0;       //接收数据帧
     
115.       aa=0xff;    //从机接收数据，并将数据保存到数据缓冲区
     
116.       while(aa==0xff)
     
117.       {
     
118.           aa=RECE_data(Buff);
     
119.       }
     
120.       if(aa==0xfe)
     
121.          continue;
     
122.       P2=Buff[0];      //查看接收到的数据
     
123.           tp = _ERR_;
     
124.           if(Buff[0] == 0xfe)
     
125.           {
     
126.                   while(tp!=_SUCC_)
     
127.                   {
     
128.                           SEND_data(ceshi);
     
129.                         RI=0;
     
130.                         while(!RI);  
     
131.                         RI=0;
     
132.                         tp=SBUF;
     
133.                   }
     
134.           }
     
135.    }
     
136. }

复制代码

从机2部分代码：

1. #include<reg51.h>
   
2. #include<string.h>
   
3. #define addr     0x02//从机2的地址
   
4. #define _SUCC_   0x0f//数据传送成功
   
5. #define _ERR_    0xf0//数据传送失败
   
6. unsigned char aa=0xff;//主机与从机之间通信标志
   
7. unsigned char ceshi[] = {0x6b,0x6c,0x2b};
   
8. unsigned char tp;
   
9. unsigned char Buff[20];//数据缓冲区
   
10. //串口初始化函数
    
11. void init()
    
12. {
    
13.      TMOD=0x20; //定时器1工作于方式2
    
14.      TH1=0xfd;  
    
15.      TL1=0xfd; //波特率为9600
    
16.      PCON=0;
    
17.      SCON=0xd0;  //串口工作于方式3
    
18.      TR1=1;  //开启定时器
    
19.      TI=0;
    
20.      RI=0;
    
21. }
    
22. 
    
23. //发送数据函数
    
24. void SEND_data(unsigned char *Buff)
    
25. {
    
26.      unsigned char i,lenth,check;
    
27.      lenth=strlen(Buff);      //计算数据长度
    
28.      check=lenth;
    
29.      TI=0;         //发送数据长度
    
30.      TB8=0;       //发送数据帧
    
31.      SBUF=lenth;
    
32.      while(!TI);
    
33.      TI=0;
    
34.          
    
35.      for(i=0;i<lenth;i++)  //发送数据
    
36.     {
    
37.         check=check^Buff[i];
    
38.         TB8=0;
    
39.         SBUF=Buff[i];      
    
40.         while(!TI);
    
41.         TI=0;
    
42.     }
    
43.       TB8=0;      //发送校验字节
    
44.       SBUF=check;   
    
45.       while(!TI);
    
46.       TI=0;     
    
47. }
    
48. 
    
49. //接收数据函数
    
50. unsigned char RECE_data(unsigned char *Buff)
    
51. {
    
52.      unsigned char i,temp;
    
53.      unsigned char lenth;
    
54.      unsigned char check;
    
55.      RI=0;     //接收数据长度
    
56.      while(!RI);
    
57.      if(RB8==1)    //若接收到地址帧，则返回0xfe
    
58.      return 0xfe;
    
59.      lenth=SBUF;
    
60.      RI=0;     
    
61.      check=lenth;
    
62.      for(i=0;i<lenth;i++) //接收数据
    
63.     {
    
64.         while(!RI);
    
65.         if(RB8==1)   //若接收到地址帧，则返回0xfe
    
66.         return 0xfe;
    
67.         Buff[i]=SBUF;   
    
68.         check=check^(Buff[i]);
    
69.         RI=0;
    
70.     }
    
71.      while(!RI);    //接收校验字节
    
72.      if(RB8==1)    //若接收到地址帧，则返回0xfe
    
73.      return 0xfe;
    
74.      temp=SBUF;
    
75.      RI=0;
    
76.      check=temp^check;  //将从主机接收到的校验码与自己计算的校验码比对
    
77.      if(check!=0)   //校验码不一致，表明数据接收错误，向主机发送错误信号，函数返回0xff
    
78.      {
    
79.         TI=0;
    
80.         TB8=0;
    
81.         SBUF=_ERR_;
    
82.         while(!TI);
    
83.         TI=0;
    
84.         return 0xff;
    
85.      }
    
86.      TI=0;           //校验码一致，表明数据接收正确，向主机发送成功信号，函数返回0x00
    
87.      TB8=0;
    
88.      SBUF=_SUCC_;
    
89.      while(!TI);
    
90.      TI=0;
    
91.      return 0;
    
92. }
    
93. void main()
    
94. {
    
95.     init();
    
96.     while(1)
    
97.    {
    
98.        SM2=1;              //接收地址帧
    
99.        while(aa!=addr)  //从机等待主机请求自己的地址
    
100.       {
     
101.            RI=0;
     
102.            while(!RI);
     
103.            aa=SBUF;
     
104.            RI=0;
     
105.       }
     
106.       TI=0;     //一旦被请求，从机返回自己的地址作为应答，等待接收数据
     
107.       TB8=0;
     
108.       SBUF=addr;
     
109.       while(!TI);
     
110.       TI=0;
     
111.       SM2=0;                  //接收数据帧
     
112.       aa=0xff;    //从机接收数据，并将数据保存到数据缓冲区
     
113.       while(aa==0xff)
     
114.       {
     
115.           aa=RECE_data(Buff);
     
116.       }
     
117.       if(aa==0xfe)
     
118.          continue;
     
119.       P2=Buff[0];      //查看接收到的数据
     
120.           tp = _ERR_;
     
121.           if(Buff[0] == 0xfe)
     
122.           {
     
123.                   while(tp!=_SUCC_)
     
124.                   {
     
125.                           SEND_data(ceshi);
     
126.                         RI=0;
     
127.                         while(!RI);  
     
128.                         RI=0;
     
129.                         tp=SBUF;
     
130.                   }
     
131.           }
     
132.    }
     
133. }

复制代码

全套代码可以下载附件


注意这个仿真只能用Proteus7.8版本打开,经过测试其他版本均无反应:
多机通信-1602显示从机信息.zip (194.84 KB, 下载次数: 137)

2019-3-11 16:43 上传

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

---

作者: zhaotianyi    时间: 2019-4-27 17:14
请问下如果我不进行校验的话代码可以怎么改？比如说我只接受两个从机的八位数据

---

作者: wlhuang    时间: 2023-1-24 16:23
反馈：8.13版本运行，按下任何按钮均无反应。

---

作者: playboy11    时间: 2023-5-8 15:49
效果不行

---

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

Powered by Discuz! X3.1