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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 多台单片机间网络的实现(互相通信)含源码
返回列表 发新帖
查看: 16941|回复: 2
打印 上一主题 下一主题
收起左侧

多台单片机间网络的实现(互相通信)含源码

[复制链接]
跳转到指定楼层
楼主
ID:205475 发表于 2017-5-27 20:03 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
一、功能
主体功能:三台单片机之间两两互相通信，为此，我们将其拟人化，以三个主人公Jack、Carl、Lily之间的交流来演示。具体过程如下：
①初始状态（从上至下分别为Jack、Lily、Carl）：



②Lily编辑“HELLO！”的字符串准备发送给Jack：

③Lily按下发送后Jack的接收结果：
④Carl编辑“Hi！”发送给Lily同时Lily接收:

⑤Jack编辑“HOW ARE U”发送给Carl同时Carl接收：

⑥特殊情况：当传送过来的数据经奇偶校验出错后给出报错提示：

二、 网络的设计
物理层：
传输介质：
采用两条杜邦线连接单片机的两个io口，一个io口定时变换高低电平输出数据，另一个io口定时检测电平高低来读取数据，实现了全双工通讯。
每台单片机都有2对（4个）io口可以发送接受数据，这为多台机器组成网络提供了基础。
多台单片机连接方式：

我们用3台单片机组成了一条线似的结构，实际上这个网络还可以在边上扩展延长，这个网络中不存在主机，每台机器都是平等的。
每台单片机收到信息后，都会将信息从另一对io口发出。每台单片机发送给信息时候，也会将信息从两对io口同时发出，因此一旦有信息发送，信息会传播到整个网络。
编码技术:采用不归零电平编码方式（NRZ-L）,高电平代表1，低电平代表0，每一bit数据的持续时间是31.108ms。由于每bit的持续时间决定了传输速率，因此传输数据可以通过简单修改宏定义来实现，不过随着传输速率的提高，出错率会增加。


传输协议：采用异步传输方式，每次传输一个bit。传输数据的格式如下
0
X
X
X
X
X
X
X
X
P
起始位
数据位
奇偶校验


数据链路层：
成帧技术采用的是字符计数成帧技术，首部的高4位代表接下来要发送的字符数
3(高四位)
1
3
2
1(高四位)
7
2(高四位)
8
4
计数首部
数据部分
数据部分
数据部分
计数首部
数据部分
计数首部
数据部分
数据部分
数据是由谁发出，数据发给谁：
这部分功能也是由字符首部来完成，首部的结构如下：
0
0
1
0
0
0
0
1
计数
目标地址
源地址
如上图所示，这个首部代表接下来还要发送2个字符，目标地址是0，源地址是1。

三、            部分代码
3台单片机的代码都是相同的，连接外部按键和显示器的引脚差别可以通过修改宏定义来适配。因此只列出一台单片机的代码
1.       main.h
  1. #ifndef _main_h_
  2. #define _main_h_

  4. #define MYNAME "Jack"
  5. #define NAME_NUM 2
  6. #define BUTTON_IO P3
  7. #define PRESS_LEFT 0x0E//k30
  8. #define PRESS_RIGHT 0x0D //k31
  9. #define CHANGE 0x0B                 //k32
  10. #define SEND 0x07                            //k33
  11. #define PRESS_TIME 5000//按键消去抖动时间
  12. #define ASCII 32
  13. #define GPIO_KEY P3  //独立键盘用P1口
  14. //carl Lily Jack Lisa

  16. void send(unsigned char* TxArray,unsigned char sendTo);
  17. void receive(void);
  18. void errorFun(unsigned char a);
  19. unsigned char Key_Scan();
  20. Show_Name(int sendTo);  //显示名字
  21. #endif
复制代码

2.       1602LCD.h
#ifndef _1602LCD_h_
#define _1602LCD_h_
sbit RS = P2 ^ 6;    //寄存器选择位，将RS位定义为P2.0引脚
sbit RW = P2 ^ 5;    //读写选择位，将RW位定义为P2.1引脚
sbit E = P2 ^ 7;     //使能信号位，将E位定义为P2.2引脚
sbit BF = P0 ^ 7;    //忙碌标志位，，将BF位定义为P0.7引脚

bit BusyTest(void);
void Write_com(unsigned char dictate);
void WriteAddress(unsigned char x);
void WriteData(unsigned char y);
void LcdInt(void);

#endif

3.       main.c
  1. #include  //  包含51单片机寄存器定义的头文件
  2. #include"1602LCD.h"
  3. #include"myParity.h"
  4. #include"main.h"

  6. sbit TxPort = P1 ^ 0;
  7. sbit RxPort = P1 ^ 1;
  8. sbit TxPort2 = P1 ^ 2;
  9. sbit RxPort2 = P1 ^ 3;
  10. #define TIMEHIGH 0xD0;
  11. #define TIMELOW 0x00;
  12. unsigned char i;
  13. unsigned int TxData;
  14. unsigned char Ti;
  15. unsigned int RxData;
  16. unsigned char Ri;
  17. unsigned char code tab[] = { 0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92, 0x82, 0xf8, 0x80, 0x90 }; //共阳数码管 0-9


  20. /**************************************************************
  21. 函数功能：主函数
  22. **************************************************************/
  23. void main(void)
  24. {
  25. unsigned char TxArray[13] = {0,0, 0, 0, 0, 0, 0, 0, 0, 0,0,0,0 };
  26.               unsigned char position = 0;
  27.               unsigned char sendTo = 0;

  29.               unsigned char keyNum;                 //获取键值
  30.               char a;                                             //循环变量
  31.               char flag=0;
  32.               RxData = 0;
  33.               TxData = 0;
  34.               Ti = 0;
  35.               Ri = 0;
  36.               i = 0;
  37.               P1 = 0xff;
  38.               P3=0xff;
  39.               P3=0xff;
  40.             
  41.               EA = 1;                  //开总中断
  42.               ET0 = 1;                 //定时器T0中断允许        
  43.               TMOD = 0x01;             //使用定时器T0的模式1
  44.               TH0 = TIMEHIGH;
  45.               TL0 = TIMELOW;
  46.               TR0 = 1;                 //启动定时器T0
  47.               LcdInt();
  48.               delay(1000);

  50.               Write_com(0x01);//清显示：清屏幕指令
  51.               WriteAddress(0x40);
  52.               WriteAddress(0x40);
  53.               for(a=0;a<10;a++)
  54.               {                                                      
  55.                             WriteAddress(0x40+a);
  56.                             WriteData(ASCII+TxArray[a]);                           
  57.               }                           
  58.               WriteAddress(0x4A);
  59.               WriteData('-');            
  60.               WriteAddress(0x4B);
  61.               WriteData('>');            
  62.               WriteAddress(0x40);
  63.               sendTo=NAME_NUM+1;
  64.               if(NAME_NUM>1)
  65.               sendTo=0;            
  66.               Show_Name(sendTo);
  67.               WriteAddress(0x40);
  68.               while (1)//无限循环等待中断
  69.               {
  70.                             keyNum = Key_Scan();  //扫描键盘
  71.                             switch (keyNum&0x0F)
  72.                             {
  73.                                           case(PRESS_LEFT) :               
  74.                                                         if( (position>=0) && (position<10) )
  75.                                                         {                                                                                                
  76.                                                                       WriteAddress(0x40+position);
  77.                                                                       if(TxArray[position]<32)
  78.                                                                                     TxArray[position]=128;
  79.                                                                       else            
  80.                                                                                     TxArray[position]--;
  81.                                                                       WriteData(TxArray[position]);                                                                                   
  82.                                                                       WriteAddress(0x40+position);
  83.                                                         }
  84.                                                         else if( (position==10) || (position==11) )
  85.                                                         {
  86.                                                                       for(a=0;a<10;a++)
  87.                                                                       {                                                      
  88.                                                                                     TxArray[a]=0;
  89.                                                                                     WriteAddress(0x40+a);
  90.                                                                                     WriteData(0);            
  91.                                                                       }                           
  92.                                                                       WriteAddress(0x40);
  93.                                                                       position=0;
  94.                                                         }
  95.                                                         else
  96.                                                         {
  97.                                                                       if(sendTo>0)
  98.                                                                       {
  99.                                                                                     sendTo--;
  100.                                                                       }
  101.                                                                       else
  102.                                                                       {
  103.                                                                                     sendTo=3;
  104.                                                                       }                                                                                       
  105.                                                                       Show_Name(sendTo);
  106.                                                         }
  107.                                                         break;
  108.                                           case(PRESS_RIGHT) :                                                         
  109.                                                         if( (position>=0) && (position<10) )
  110.                                                         {                                                                                                
  111.                                                                       WriteAddress(0x40+position);
  112.                                                                       if(TxArray[position]<32)
  113.                                                                                     TxArray[position]=65;
  114.                                                                       else if(TxArray[position]>128)
  115.                                                                                     TxArray[position]=32;
  116.                                                                       else            
  117.                                                                                     TxArray[position]++;
  118.                                                                       WriteData(TxArray[position]);                                                                                   
  119.                                                                       WriteAddress(0x40+position);
  120.                                                         }
  121.                                                         else if( (position==10) || (position==11) )
  122.                                                         {
  123.                                                                       for(a=0;a<10;a++)
  124.                                                                       {                                                      
  125.                                                                                     TxArray[a]=0;
  126.                                                                                     WriteAddress(0x40+a);
  127.                                                                                     WriteData(ASCII);                           
  128.                                                                       }                                         
  129.                                                                       WriteAddress(0x40);
  130.                                                                       position=0;
  131.                                                         }
  132.                                                         else
  133.                                                         {
  134.                                                                       if(sendTo<3)
  135.                                                                       {
  136.                                                                                     sendTo++;
  137.                                                                       }
  138.                                                                       else
  139.                                                                       {
  140.                                                                                     sendTo=0;
  141.                                                                       }                                                                                      
  142.                                                                       Show_Name(sendTo);
  143.                                                         }
  144.                                                         break;
  145.                                           case(CHANGE) :               
  146.                                                         if(position<12)
  147.                                                         {
  148.                                                                       position++;
  149.                                                         }
  150.                                                         else
  151.                                                         {
  152.                                                                       position=0;
  153.                                                         }
  154.                                                         WriteAddress(0x40+position);
  155.                                                         break;
  156.                                           case(SEND) :
  157.                                                         flag=0;
  158.                                                         for(a=9;a>=0;a--)
  159.                                                         {
  160.                                                                       if(flag==1&&TxArray[a]==0)
  161.                                                                                     TxArray[a]=32;
  162.                                                                       else if(TxArray[a]!=0)
  163.                                                                                     flag=1;
  164.                                                         }            
  165.                                                         send(TxArray,sendTo);
  166.                                                         break;
  167.                                           default:
  168.                                                         break;
  169.                             }
  170.                             receive();
  171.               }

  173. }

  175. Show_Name(int sendTo)
  176. {                                                                                                   
  177.               if(sendTo==0)
  178.               {
  179.                             WriteAddress(0x4C);
  180.                             WriteData('C');            
  181.                             WriteAddress(0x4D);
  182.                             WriteData('a');
  183.                             WriteAddress(0x4E);
  184.                             WriteData('r');            
  185.                             WriteAddress(0x4F);
  186.                             WriteData('l');
  187.                             WriteAddress(0x4C);
  188.               }
  189.               else if(sendTo==1)
  190.               {
  191.                             WriteAddress(0x4C);
  192.                             WriteData('L');            
  193.                             WriteAddress(0x4D);
  194.                             WriteData('i');
  195.                             WriteAddress(0x4E);
  196.                             WriteData('l');            
  197.                             WriteAddress(0x4F);
  198.                             WriteData('y');
  199.                             WriteAddress(0x4C);
  200.               }
  201.               else if(sendTo==2)
  202.               {
  203.                             WriteAddress(0x4C);
  204.                             WriteData('J');            
  205.                             WriteAddress(0x4D);
  206.                             WriteData('a');
  207.                             WriteAddress(0x4E);
  208.                             WriteData('c');            
  209.                             WriteAddress(0x4F);
  210.                             WriteData('k');
  211.                             WriteAddress(0x4C);
  212.               }
  213.               else
  214.               {
  215.                             WriteAddress(0x4C);
  216.                             WriteData('L');            
  217.                             WriteAddress(0x4D);
  218.                             WriteData('i');
  219.                             WriteAddress(0x4E);
  220.                             WriteData('s');            
  221.                             WriteAddress(0x4F);
  222.                             WriteData('a');
  223.                             WriteAddress(0x4C);
  224.               }
  225. }
  226. /*******************************************************************************
  227. * 函 数 名         : Key_Scan()
  228. * 函数功能                               : 扫描键盘
  229. * 输    入         : 无
  230. * 输    出         : 读取到的键值
  231. *******************************************************************************/

  233. unsigned char Key_Scan()
  234. {
  235.               unsigned char keyValue = 0 , i; //保存键值

  237.               //--检测按键1--//
  238.               if (GPIO_KEY != 0xFF)                            //检测按键是否按下
  239.               {
  240.                             delay(PRESS_TIME);              //消除抖动

  242.                             if (GPIO_KEY != 0xFF)              //再次检测按键是否按下
  243.                             {
  244.                                           keyValue = GPIO_KEY;
  245. /*                                          i = 0;
  246.                                           while ((i<50) && (GPIO_KEY != 0xFF))              //检测按键是否松开
  247.                                           {
  248.                                                         delay(PRESS_TIME);
  249.                                                         i++;
  250.                                           }  */
  251.                             }
  252.               }

  254.               return keyValue;   //将读取到键值的值返回
  255. }

  257. /**************************************************************
  258. 函数功能：定时器T0的中断服务程序
  259. **************************************************************/
  260. void Time0(void) interrupt 1 using 0 //“interrupt”声明函数为中断服务函数
  261. //其后的1为定时器T0的中断编号；0表示使用第0组工作寄存器
  262. {
  263.               bit RxTemp;
  264.               /*发送数据*/
  265.               if ((TxData & 0x01) == 1)
  266.               {
  267.                             if (Ti == 9)
  268.                             {
  269.                                           TxPort = (bit)(TxData & 0x8000);
  270.                                           TxPort2 = (bit)(TxData & 0x8000);
  271.                                           Ti = 0;
  272.                                           TxData = TxData & 0xfffe;
  273.                             }
  274.                             else
  275.                             {
  276.                                           TxPort = (bit)(TxData & 0x8000);
  277.                                           TxPort2 = (bit)(TxData & 0x8000);
  278.                                           TxData <<= 1;
  279.                                           TxData = TxData - 1;
  280.                                           Ti++;
  281.                             }
  282.               }
  283.               else
  284.               {
  285.                             TxPort = 1;
  286.                             TxPort2 = 1;
  287.               }
  288.               /*发送数据结束*/

  290.               /*接收数据*/
  291.                             RxTemp=RxPort&RxPort2;
  292.               if ((RxData & 0x8000) == 0x8000)//S1==1?
  293.               {
  294.                             if (Ri != 8)
  295.                             {
  296.                                           Ri++;
  297.                                           RxData <<= 1;
  298.                                           RxData = RxData | 0x8000;//S1置1
  299.                                           RxData = RxData | (unsigned int)RxTemp;
  300.                             }
  301.                             else
  302.                             {
  303.                                           RxData <<= 1;
  304.                                           RxData = RxData | (unsigned int)RxTemp;
  305.                                           Ri = 0;
  306.                                           RxData = RxData & 0x7fff;//S1置0
  307.                                           RxData = RxData | 0x4000;//S2置2
  308.                             }
  309.               }
  310.               else
  311.               {
  312.                             if (RxTemp == 0)
  313.                             {
  314.                                           if ((RxData & 0x4000) == 0)//S2==0?
  315.                                           {
  316.                                                         RxData = RxData | 0x8000;//S1置1
  317.                                           }
  318.                                           else
  319.                                           {
  320.                                                         errorFun(1);
  321.                                           }
  322.                             }
  323.               }
  324.               if(RxPort==0)
  325.                             TxPort2=0;
  326.               if(RxPort2==0)
  327.                             TxPort=0;
  328.               /*接收数据结束*/
  329.               TH0 = TIMEHIGH;
  330.               TL0 = TIMELOW;
  331. }

  333. void errorFun(unsigned char a)
  334. {
  335.               char i,s[]="Error";
  336.               WriteAddress(0x00);
  337.               for(i=0;i<16;i++)
  338.               {
  339.                             WriteData(32);            
  340.               }

  342.               WriteAddress(0x00);
  343.               i=0;
  344.               while(s[i]!=0)
  345.               {
  346.                             WriteData(s[i]);
  347.                             i++;
  348.                             delay(100);
  349.               }
  350.               WriteData('0'+a);
  351.               while(1);
  352. }

  354. void send(unsigned char* TxArray,unsigned char sendTo)
  355. {
  356.               unsigned char Tcount=0,i=0,TxD=0;
  357.               while (TxArray[Tcount] != 0)
  358.               {
  359.                             Tcount++;
  360.               }
  361.               TxD |= Tcount;
  362.               TxD<<=4;
  363.               sendTo <<= 2;
  364.               TxD |= sendTo;
  365.               TxD |= NAME_NUM;
  366.               while ((TxData & 0x0001) == 0x0001)//没发完
  367.                             ;
  368.               TxData = calculateTxData(TxD);
  369.               for (i = 0; i < Tcount; i++)
  370.               {
  371.                             while ((TxData & 0x0001) == 0x0001)//没发完
  372.                                           ;
  373.                             TxData = calculateTxData(TxArray[i]);
  374.               }
  375. }

  377. void receive(void)
  378. {
  379.               unsigned char RxArray[13] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
  380.               unsigned char Rcount = 0, j = 0, sendTo = 0,temp=0;
  381.               if ((RxData & 0x4000) == 0x4000)//S2==1,数据待读取
  382.               {
  383.                             RxArray[0] = checkRxData();
  384.                             Rcount=RxArray[0] & 0xf0;
  385.                             Rcount>>=4;
  386.                             for (j = 1; j < Rcount+1; j++)
  387.                             {
  388.                                           while ((RxData & 0x4000) == 0x0000)//没有数据读取
  389.                                                         ;
  390.                                           RxArray[j] = checkRxData();
  391.                             }
  392.                             sendTo =RxArray[0] & 0x0c;
  393.                             sendTo>>=2;
  394.                             if (sendTo != NAME_NUM)
  395.                                           ;//send(RxArray + 1, sendTo);
  396.                             else
  397.                             {
  398.                                           WriteAddress(0x00);
  399.                                           switch (RxArray[0] & 0x03)
  400.                                           {
  401.                                           case 0:
  402.                                                         WriteData('C');
  403.                                                         WriteData('a');
  404.                                                         WriteData('r');
  405.                                                         WriteData('l');
  406.                                                         break;
  407.                                           case 1:
  408.                                                         WriteData('L');
  409.                                                         WriteData('i');
  410.                                                         WriteData('l');
  411.                                                         WriteData('y');
  412.                                                         break;
  413.                                           case 2:
  414.                                                         WriteData('J');
  415.                                                         WriteData('a');
  416.                                                         WriteData('c');
  417.                                                         WriteData('k');
  418.                                                         break;
  419.                                           case 3:
  420.                                                         WriteData('L');
  421.                                                         WriteData('i');
  422.                                                         WriteData('s');
  423.                                                         WriteData('a');
  424.                                                         break;
  425.                                           }
  426.                                           WriteData(':');
  427.                                           WriteData(32);
  428.                                           WriteData(32);
  429.                                           WriteData(32);
  430.                                           WriteData(32);
  431.                                           WriteData(32);
  432.                                           WriteData(32);
  433.                                           WriteData(32);
  434.                                           WriteData(32);
  435.                                           WriteData(32);
  436.                                           WriteData(32);
  437.                                           WriteData(32);
  438.                                           WriteAddress(0x05);
  439.                                           for (j = 1; j < Rcount + 1;j++)
  440.                                                         WriteData(RxArray[j]);
  441.                             }
  442.               }
  443. }
  444. 4.       parity.h

  446. #include  //  包含51单片机寄存器定义的头文件
  447. #include"myparity.h"
  448. #include"main.h"
  449. extern unsigned int RxData;
  450. //--定义全局变量--//
  451. unsigned char code DIG_PLACE[8] = {
  452.               0xfe, 0xfd, 0xfb, 0xf7, 0xef, 0xdf, 0xbf, 0x7f };//位选控制   查表的方法控制
  453. unsigned char code DIG_CODE[17] = {
  454.               0x50, 0x5c, 0x50, 0x50, 0x79 };
  455. //Error的显示码
  456. unsigned char DisplayData[8];
  457. //用来存放要显示的8位数的值

  459. /*来自安驰的代码如下*/
  460. unsigned char checkRxData()
  461. {
  462.               unsigned int a = 1;  //用于移位后与运算，即为0000 0001
  463.               int i;
  464.               int UsefulData = RxData;
  465.               int bin[9] = { 0 };   //用于记录Rxdata转化为二进制后的数值
  466.               int num1 = 0;    //用于记录Rxdata中1的个数

  468.               UsefulData = UsefulData >> 1;              //先右移一位再与运算提取
  469.               UsefulData = UsefulData & 255;              //出原int型数据中有效的8位

  471.               for (i = 0; i<9; i++)
  472.               {
  473.                             bin[i] = RxData&a;
  474.                             RxData = RxData >> 1; //右移一位
  475.               }
  476.               for (i = 0; i<9; i++)
  477.               {
  478.                             if (bin[i] == 1)
  479.                             {
  480.                                           num1++;
  481.                             }
  482.               }
  483.               if (num1 % 2 == 0)
  484.               {
  485.                             errorFun(2);//奇偶校验错error2
  486.               }
  487.               return (char)UsefulData;
  488. }

  490. unsigned int calculateTxData(unsigned char UsefulData)
  491. {
  492.               unsigned int CutData;
  493.               unsigned int FinalData;
  494.               int flag = 0;   //判断1的个数            
  495.               int bin[8] = { 0 };
  496.               int num1 = 0;
  497.               int num = 0;
  498.               int i;
  499.               CutData = (int)UsefulData;
  500.               num = (int)UsefulData;
  501.               for (i = 0; i<8; i++)
  502.               {
  503.                             bin[i] = CutData & 1;
  504.                             CutData = CutData >> 1; //右移一位
  505.               }
  506.               for (i = 0; i<8; i++)
  507.               {
  508.                             if (bin[i] == 1)
  509. ……………………

  511. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码


详细内容见附件：
多台单片机间网络的实现.docx (1.95 MB, 下载次数: 80)



单片机, 网络
分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏3 分享淘帖 顶顶 踩踩

相关帖子
回复

使用道具 举报

沙发
ID:1 发表于 2017-5-29 03:17 | 只看该作者
好资料，51黑有你更精彩!!!
回复

使用道具 举报

板凳
ID:171028 发表于 2020-3-26 19:05 | 只看该作者
哇！感谢，正在学习多机通信
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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