设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 单片机多机通信互传数据仿真+代码(1602显示从机信息)
返回列表 发新帖
查看: 4201|回复: 3
打印 上一主题 下一主题
收起左侧

单片机多机通信互传数据仿真+代码(1602显示从机信息)

[复制链接]
跳转到指定楼层
楼主
ID:372961 发表于 2019-3-11 16:43 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
功能说明：主机功能：按下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;

  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. }


  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. }

  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. }                                 

  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. }

  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.   }

  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.   }

  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.   }

  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.   }

  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. }

  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. }

  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. }

  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. }

  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, 下载次数: 134)

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励！

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏3 分享淘帖 顶顶2 踩踩
回复

使用道具 举报

沙发
ID:509233 发表于 2019-4-27 17:14 | 只看该作者
请问下如果我不进行校验的话代码可以怎么改？比如说我只接受两个从机的八位数据
回复

使用道具 举报

板凳
ID:289218 发表于 2023-1-24 16:23 | 只看该作者
反馈：8.13版本运行，按下任何按钮均无反应。
回复

使用道具 举报

地板
ID:717459 发表于 2023-5-8 15:49 | 只看该作者
效果不行
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表