标题: 51单片机CRC串行通信仿真与源码 [打印本页]
作者: 留在夏天    时间: 2018-3-19 17:05
标题: 51单片机CRC串行通信仿真与源码
    我做的是两个单片机之间进行串行通信，用的89c52.通过按主机p27口"启动键",主机向从机发送一个四位数据，LED显示。从机经过CRC校验，如果接收到正确数据，与其相连的LED显示所接收的数据。如果经校验后接收错误，则四位LED显示0xFFFF。
    仿真时从机一点反应也没有，也许是我程序有问题，或通信协议编的不行。

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


主机单片机源码：
  1. #define        _PPDATAT_H

  3. #include <reg51.h>
  4. #include <string.h>

  6. #define uchar unsigned char
  7. #define uint unsigned int

  9. /* 握手信号宏定义 */
  10. #define CALL 0x24                // 主机呼叫
  11. #define OK 0x00                        // 从机准备好

  13. #define MAXLEN 64                // 缓冲区最大长度

  15. uchar buf[MAXLEN];

  17. sbit  p00 = P0^0; sbit  p01 = P0^1; sbit  p02 = P0^2; sbit  p03 = P0^3;
  18. sbit p10=P1^0; sbit p11=P1^1; sbit p12=P1^2; sbit p13=P1^3;
  19. sbit p14=P1^4; sbit p15=P1^5; sbit p16=P1^6; sbit p17=P1^7;
  20. sbit p23 = P2^3;sbit p25 = P2^5;sbit p27 = P2^7;

  22. unsigned char a;
  23. unsigned char b;
  24. unsigned char c;
  25. unsigned char d;
  26. unsigned char in1,in2,in3,count;
  27. unsigned char j1,j2;
  28. unsigned char z1,z2,z3;
  29. unsigned int x=1234;
  30. bit qidong;

  32. void delay();

  34. //********************八段码*************************//
  35. code unsigned char LEDMAP[] = {
  36. 0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07,
  37. 0x7f, 0x6f, 0x00,0x71//共阳显示码，分别显示0、1、2、3、4、5、6、7、8、9、灭、F。
  38. };
  39. //***********************显示码选择**********************//
  40. int DisplayLED(unsigned char j)
  41. {
  42.         unsigned int i=0;
  43.         unsigned int x1;
  44.         x1= LEDMAP[(i+j) & 0x0f];
  45.         return  x1;
  46. }
  47. //***********************转换*************************//
  48. void si()
  49. {
  50.     unsigned int M;
  51.         a=x%10;
  52.         M=x/10;
  53.         b=M%10;
  54.         M=M/10;
  55.         c=M%10;
  56.         d=M/10;//a取出第四位,b取出第三位,c取出第二位,d取出第一位
  57. }
  58. //***********************显示**********************//
  59. void  display()
  60. {
  61.     si();
  62.         P0=0xf7;
  63.         P1=DisplayLED(a);
  64.         delay();
  65.         P0=0xfb;
  66.         P1=DisplayLED(b);
  67.         delay();
  68.         P0=0xfd;
  69.         P1=DisplayLED(c);
  70.         delay();
  71.         P0=0xfe;
  72.         P1=DisplayLED(d);
  73.         delay();       
  74. }
  75. //************************扫描按键**********************//
  76. void timer0() interrupt 1 using 1
  77. {
  78.         in1=p23;
  79.         in2=p25;
  80.         in3=p27;
  81.         TH0=0xc3;
  82.         TL0=0x50;
  83.         count++;

  85.         if(in1==0)
  86.                 z1++;
  87.         if(in2==0)
  88.                 z2++;
  89.         if(in3==0)
  90.                 z3++;
  91.         if(count==40)
  92.         {
  93. //*************************x+***********************//
  94.         if((0<z1)&(z1<40))
  95.                         x++;
  96.                 if (z1==40)
  97.                         j1++;
  98.                 count=0;
  99.                 z1=0;
  100.                 if((0<j1)&(j1<6))
  101.                         x++;
  102.                 if((5<j1)&(j1<11))
  103.                         x=x+10;
  104.                 if(10<j1)
  105.                         x=x+100;
  106.                 if(in1==1)
  107.                         j1=0;
  108. //************************x-*******************//
  109.                 if((0<z2)&(z2<40))
  110.                         x--;
  111.                 if (z2==40)
  112.                         j2++;
  113.                 z2=0;
  114.                 if((0<j2)&(j2<6))
  115.                         x--;
  116.                 if((5<j2)&(j2<11))
  117.                         x=x-10;
  118.                 if(10<j2)
  119.                         x=x-100;
  120.                 if(in1==1)
  121.                         j2=0;
  122. //************************启动*******************//
  123.                 if(z3>5)
  124.                   qidong=1;
  125.          }  
  126. }
  127. void init()
  128. {
  129.      TMOD=0x21;                          //定时器0工作于方式1，定时器1工作于方式2
  130.         TH1 = 250;                          // 设置初值
  131.             TL1 = 250;

  133.             PCON = 0x80;                        // SMOD = 1
  134.             SCON = 0x50;                        //工作方式1，波特率9600bps，允许接收

  136.             ET0=1;                              //允许定时器0中断
  137.             TR0=1;                              //定时器0开始工作
  138.             TR1 = 1;                            //定时器1开始工作
  139.             EA=1;                               //打开所有中断

  141. }
  142. //*************************delay*********************//
  143. void delay()
  144. {
  145.         unsigned int i,n;
  146.         n=100;
  147.         for (i=0; i<n; i++) {}
  148. }
  149. //************************CRC计算****************************************//
  150. uint getcrc(uchar *s,uchar len)
  151. {
  152.   uint acc=0,i,j=0;
  153. while(len--)
  154. {
  155.     acc=acc^(*s++<<8);
  156.     for(i=0;i++<8;)
  157.       if(acc&0x8000)
  158.         acc=(acc<<1)^0x1021;
  159.       else
  160.         acc=acc<<1;
  161. }
  162. return(acc);
  163. }


  166. //************************串口通信程序****************************************//

  168. /* 发送数据函数 */
  169. void senddata(uchar *buf)
  170. {
  171.         uchar i;
  172.         uchar len;                                        // 保存数据长度
  173.         uint ecc;                                        // 保存校验字节

  175.         len = strlen(buf);                        // 计算要发送数据的长度

  177.         /* 发送数据长度 */
  178.         TI = 0;
  179.         SBUF = len;                                        // 发送长度
  180.         while(!TI);
  181.         TI = 0;
  182.     /* 发送数据和校验字节 */
  183.     ecc=getcrc(buf,len);
  184.     buf[len]=ecc/256;
  185.     buf[len+1]=ecc%256;
  186.         for (i=0;i<len+2;i++)
  187.         {
  188.                 SBUF = *buf;
  189.                 buf++;
  190.                 while(!TI);
  191.                 TI = 0;
  192.         }
  193. }       
  194. void tongxin()
  195. {
  196.         uchar i = 0;
  197.         uchar tmp;
  198.         /* 发送呼叫信号CALL并接收应答信息，如果没有接收到从机准备好的信号，则重新发送呼叫帧 */
  199.         while(tmp!=OK)                       
  200.         {
  201.                 /* 发送呼叫信号CALL */
  202.                 TI = 0;
  203.                 SBUF = CALL;
  204.                 while(!TI);
  205.                 TI = 0;

  207.                 /* 接收从机应答 */
  208.                 RI = 0;
  209.                 while(!RI);
  210.                 tmp = SBUF;
  211.                 RI = 0;               
  212.         }

  214.        
  215. }


  218. //*************************主函数***********************//
  219. void  main()
  220. {
  221.            init();
  222.            while(1)
  223.            {
  224.              display();
  225.              if(qidong==1)
  226.               {
  227.                si();
  228.                buf[0]=a;buf[1]=b;            
  229.                buf[2]=c;buf[3]=d;
  230.                senddata(buf);
  231.                tongxin();
  232.                qidong=0;     
  233.               }
  234.            }  
  235. }  
复制代码

丛机单片机源程序如下:
  1. #define        _PPDATAR_H

  3. #include <reg51.h>
  4. #include <string.h>

  6. #define uchar unsigned char
  7. #define uint unsigned int

  9. /* 握手信号宏定义 */
  10. #define CALL 0x24                // 主机呼叫
  11. #define OK 0x00                        // 从机准备好
  12. #define MAXLEN 64            // 缓冲区最大长度
  13. uchar buf[MAXLEN];
  14. sbit  p00 = P0^0; sbit  p01 = P0^1; sbit  p02 = P0^2; sbit  p03 = P0^3;
  15. sbit p10=P1^0; sbit p11=P1^1; sbit p12=P1^2; sbit p13=P1^3;
  16. sbit p14=P1^4; sbit p15=P1^5; sbit p16=P1^6; sbit p17=P1^7;
  17. bit err;
  18. void delay();

  20. //********************八段码*************************//
  21. code unsigned char LEDMAP[] = {
  22. 0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07,
  23. 0x7f, 0x6f, 0x00,0x71//共阳显示码，分别显示0、1、2、3、4、5、6、7、8、9、灭、F。
  24. };
  25. //***********************显示码选择**********************//
  26. int DisplayLED(unsigned char j)
  27. {
  28.         unsigned int i=0;
  29.         unsigned int x1;
  30.         x1= LEDMAP[(i+j) & 0x0f];
  31.         return  x1;
  32. }

  34. //***********************显示**********************//
  35. void  display()
  36. {
  37.         P0=0xf7;
  38.         P1=DisplayLED(buf[0]);
  39.         delay();
  40.         P0=0xfb;
  41.         P1=DisplayLED(buf[1]);
  42.         delay();
  43.         P0=0xfd;
  44.         P1=DisplayLED(buf[2]);
  45.         delay();
  46.         P0=0xfe;
  47.         P1=DisplayLED(buf[3]);
  48.         delay();
  49. }
  50. //////////////////////显示FFFF//////////////////////////////
  51. void  display_f()
  52. {
  53.         P0=0xfe;
  54.         P1=DisplayLED(11);
  55.         delay();
  56.         P0=0xfd;
  57.         P1=DisplayLED(11);
  58.         delay();
  59.         P0=0xfb;
  60.         P1=DisplayLED(11);
  61.         delay();
  62.         P0=0xf7;
  63.         P1=DisplayLED(11);
  64.         delay();
  65. }
  66. //************************CRC计算****************************************//
  67. uint getcrc(uchar *s,uchar len)
  68. {
  69.   uint acc=0,i,j=0;
  70. while(len--)
  71. {
  72.     acc=acc^(*s++<<8);
  73.     for(i=0;i++<8;)
  74.       if(acc&0x8000)
  75.         acc=(acc<<1)^0x1021;
  76.       else
  77.         acc=acc<<1;
  78. }
  79. return(acc);
  80. }
  81. //*************************delay*********************//
  82. void delay()
  83. {
  84.         unsigned int i,n;
  85.         n=100;
  86.         for (i=0; i<n; i++) {}
  87. }
  88. //************************进行数据校验****************************************//
  89. int chkcrc(uchar *buf,uchar len)
  90.         {
  91.           uint strcrc;
  92.            strcrc=getcrc(buf,len);   //生成接收数据的CRC码
  93.            if(((0xff&buf[len])==(0xff&(strcrc/256)))&&((0xff&buf[len+1])==(0xff&(strcrc%256))))
  94.                                    //接收的CRC码和生成的CRC码进行比较
  95.              return(0);
  96.            else
  97.              return(-1);
  98.         }

  100. /* 接收数据函数 */
  101. bit recvdata(uchar *buf)
  102. {
  103.         uchar i;
  104.         uchar len;                                        // 保存数据长度
  105.         int ecc;                                        // 保存校验字节
  106.        
  107.         /* 接收数据长度字节 */
  108.         RI = 0;
  109.         while(!RI);
  110.         len = SBUF;
  111.         RI = 0;

  113.         /* 接收数据及校验字节 */
  114.         for (i=0;i<len+2;i++)
  115.         {
  116.                 while(!RI);
  117.                 *buf = SBUF;       
  118.                 RI = 0;       
  119.                 buf++;               
  120.         }
  121.         *buf = 0;                                        // 表示接收结束       
  122.       
  123.          /* 进行数据校验 */
  124.         ecc = chkcrc(buf,len);
  125.         if (ecc!=0)                                        // 如果校验错误
  126.        
  127.                       return 1;                        // 返回1表示校验错误
  128.         else
  129.                return 0;                                        // 校验成功，返回0
  130.       
  131. }

  133. void init_serial()
  134. {
  135.         TMOD = 0x20;                                // 定时器T1使用工作方式2
  136.         TH1 = 250;
  137.         TL1 = 250;
  138.         TR1 = 1;                                        // 开始计时
  139.         PCON = 0x80;                                // SMOD = 1
  140.         SCON = 0x50;                                // 工作方式1，波特率9600kbit/s，允许接收
  141. }

  143. /*串口通信程序 */
  144. void tongxin()
  145. {
  146.         uchar tmp=0;
  147.         init_serial();
  148.         EA = 0;                                        // 关闭所有中断

  150.        /* 如果接收到的数据不是CALL，则继续等待 */
  151.                 while (tmp!=CALL)
  152.                 {
  153.                         RI = 0;
  154.                         while(!RI)
  155.                         tmp = SBUF;
  156.                         RI = 0;
  157.                 }
  158.        
  159.                 /* 发送OK信号，表示从机可以接收数据 */
  160.                 TI = 0;                               
  161.                 SBUF = OK;
  162.                 while(!TI);
  163. ……………………

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

所有资料51hei提供下载:
CRC串行通信.zip (86.14 KB, 下载次数: 41)


作者: wangtianbao    时间: 2018-7-18 16:40
谢谢楼主      
作者: 011010    时间: 2018-8-10 11:52
我想看看的
作者: 011010    时间: 2018-8-10 11:54
为什么不让下栽



欢迎光临 (http://www.51hei.com/bbs/) Powered by Discuz! X3.1