欧美极品高清xxxxhd,国产日产欧美最新,无码AV国产东京热AV无码,国产精品人与动性XXX,国产传媒亚洲综合一区二区,四库影院永久国产精品,毛片免费免费高清视频,福利所导航夜趣136

標題: 單片機多機通信互傳數據仿真+代碼(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.raoushi.com/bbs/)

Powered by Discuz! X3.1

感谢您访问我们的网站，您可能还对以下资源感兴趣：

1024手机基地看电影