Chinaunix首页 | 论坛 | 博客

GeneTastedogsun88.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

dogsun88

  • 博客访问： 521723
  • 博文数量： 52
  • 博客积分： 1223
  • 博客等级： 少尉
  • 技术积分： 751
  • 用 户 组： 普通用户
  • 注册时间： 2012-03-23 21:32
文章分类

全部博文（52）

文章存档

2016年（1）

2015年（5）

2013年（1）

2012年（45）

我的朋友
最近访客
推荐博文
相关博文
xmodem 协议

分类： C/C++

2012-03-29 18:42:44

1．Xmodem协议是什么？
　　XMODEM协议是一种串口通信中 广泛用到的异步文件传输协议。分为标准Xmodem和1k-Xmodem两种，前者以128字节块的形式传输数据，后者字节块为1k即1024字节，并且 每个块都使用一个校验和过程来进行错误检测。在校验过程中如果接收方关于一个块的校验和与它在发送方的校验和相同时，接收方就向发送方发送一个确认字节 (ACK)。由于Xmodem需要对每个块都进行认可，这将导致性能有所下降，特别是延时比较长的场合，这种协议显得效率更低。
    除了Xmodem，还有Ymodem，Zmodem协议。他们的协议内容和Xmodem类似，不同的是Ymodem允许批处理文件传输，效率更高；Zmodem则是改进的了Xmodem，它只需要对损坏的块进行重发，其它正确的块不需要发送确认字节。减少了通信量。
2．Xmodem协议相关控制字符
    SOH             0x01
    STX           0x02
    EOT             0x04
    ACK             0x06
    NAK             0x15
    CAN             0x18
    CTRLZ         0x1A
3．标准Xmodem协议（每个数据包含有128字节数据）帧格式
  _______________________________________________________________
|     |            |                   |          |            |
| SOH | 信息包序号   |  信息包序号的补码    | 数据区段  |  校验和      |
|_____|____________|___________________|__________|____________|
4．1k-Xmodem（每个数据包含有1024字节数据）帧格式
  _______________________________________________________________
|     |            |                   |          |            |
| STX | 信息包序号   |  信息包序号的补码    | 数据区段  |  校验和      |
|_____|____________|___________________|__________|____________|
5．数据包说明
    对于标准Xmodem协议来说，如果传送的文件不是128的整数倍，那么最后一个数据包的有效内容肯定小于帧长，不足的部分需要用CTRL- Z(0x1A)来填充。这里可能有人会问，如果我传送的是bootloader工程生成的.bin文件，mcu收到后遇到0x1A字符会怎么处理？其实如 果传送的是文本文件，那么接收方对于接收的内容是很容易识别的，因为CTRL-Z不是前128个ascii码，不是通用可见字符，如果是二进制文件，mcu其实也不会把它当作代码来执行。哪怕是excel文件等，由于其内部会有些结构表示各个字段长度等，所以不会读取多余的填充字符。否则 Xmodem太弱了。对于1k-Xmodem，同上理。
6．如何启动传输？
    传输由接收方启动，方法是向发送方发送"C"或者NAK(注意哦，这里提到的NAK是用来启动传输的。以下我们会看到NAK还可以用来对数据产生重传的机 制)。接收方发送NAK信号表示接收方打算用累加和校验；发送字符"C"则表示接收方想打算使用CRC校验（具体校验规则下文Xmodem源码，源码胜于 雄辩)。
7．传输过程
    当接收方发送的第一个"C"或者NAK到达发送方，发送方认为可以发送第一个数据包，传输已经启动。发送方接着应该将数据以每次128字节的数据加上包头，包号，包号补码，末尾加上校验和，打包成帧格式传送。
发送方发了第一包后就等待接收方的确认字节ACK，收到接收方传来的ACK确认，就认为数据包被接收方正确接收，并且接收方要求发送方继续发送下一个包； 如果发送方收到接收方传来的NAK(这里，NAK用来告诉发送方重传，不是用来启动传输)字节，则表示接收方请求重发刚才的数据包；如果发送方收到接收方 传来的CAN字节，则表示接收方请求无条件停止传输。
8．如何结束传输？
    如果发送方正常传输完全部数据，需要结束传输，正常结束需要发送方发送EOT 字节通知接收方。接收方回以ACK进行确认。当然接收方也可强制停止传输，当接收方发送CAN 字节给发送方，表示接收方想无条件停止传输，发送方收到CAN后，不需要再发送 EOT确认（因为接收方已经不想理它了，呵呵）。
9．特殊处理
    虽然数据包是以 SOH 来标志一个信息包的起始的，但在 SOH 位置上如果出现EOT则表示数据传输结束，再也没有数据传过来。
接收方首先应确认数据包序号的完整性，通过对数据包序号取补，然后和数据包序号的补码异或，结果为0表示正确，结果不为0则发送NAK请求重传。
    接收方确认数据包序号正确后，然后检查是否期望的序号。如果不是期望得到的数据包序号，说明发生严重错误，应该发送一个 CAN 来中止传输。
    如果接收到的数据包的包序号和前一包相同，那么接收方会忽略这个重复包，向发送方发出 ACK ，准备接收下一个包。
    接收方确认了信息包序号的完整性和是正确期望的后，只对 128 字节的数据区段进行算术和校验，结果与帧中最后一个字节（算术校验和）比较，相同发送 ACK，不同发送 NAK。
10．校验和的说明
    Xmodem协议支持2种校验和，它们是累加和与CRC校验。
    当接收方一开始启动传输时发送的是NAK，表示它希望以累加和方式校验。
    当接收方一开始启动传输时发送的是字符“C”，表示它希望以CRC方式校验。
    可能有人会问，接收方想怎么校验发送方都得配合吗，难道发送方必须都支持累加和校验和CRC校验？事实上Xmodem要求支持CRC的就必须同时支持累加 和，如果发送方只支持累加和，而接收方用字符“C”来启动，那么发送方只要不管它，当接收方继续发送“C”，三次后都没收到应答，就自动会改为发送 NAK，因为它已经明白发送方可能不支持CRC校验，现在接收方改为累加和校验和发送方通讯。发送方收到NAK就赶紧发送数据包响应。
11．Xmodem协议代码
        看了以上说明，再参考代码，应该很容易会理解代码编写者的思路。

代码：


 

点击(此处)折叠或打开

  1. #include "crc16.h"
  2. #define SOH 0x01
  3. #define STX 0x02
  4. #define EOT 0x04
  5. #define ACK 0x06
  6. #define NAK 0x15
  7. #define CAN 0x18
  8. #define CTRLZ 0x1A

  10. #define DLY_1S 1000
  11. #define MAXRETRANS 25
  12. static int last_error = 0;


  15. void port_outbyte(unsigned char trychar)
  16. {
  17.     unsigned char buf[2];
  18.     buf[0] = trychar;
  19.     lowLevel_write(buf,1);
  20. }

  22. unsigned char port_inbyte(unsigned int time_out)
  23. {
  24.     unsigned char ch;
  25.     int i;
  26.     last_error = 0;

  28.     if(lowLevel_read(&ch,1) == 1)
  29.         return ch;

  31.     last_error = 1;
  32.     return ch;
  33. }

  35. static int check(int crc, const unsigned char *buf, int sz)
  36. {
  37.     if (crc)
  38.     {
  39.         unsigned short crc = crc16_ccitt(buf, sz);
  40.         unsigned short tcrc = (buf[sz]<<8)+buf[sz+1];
  41.         if (crc == tcrc)
  42.             return 1;
  43.     }
  44.     else
  45.     {
  46.         int i;
  47.         unsigned char cks = 0;
  48.         for (i = 0; i < sz; ++i)
  49.         {
  50.             cks += buf[i];
  51.         }
  52.         if (cks == buf[sz])
  53.             return 1;
  54.     }
  55.     return 0;
  56. }

  58. static void flushinput(void)
  59. {
  60.  //while (port_inbyte(((DLY_1S)*3)>>1) >= 0)
  61.     ;
  62. }

  64. int xmodemReceive(unsigned char *dest, int destsz)
  65. {
  66.     unsigned char xbuff[1030];
  67.     unsigned char *p;
  68.     int bufsz, crc = 0;
  69.     unsigned char trychar = 'C';
  70.     unsigned char packetno = 1;
  71.     int i, c, len = 0;
  72.     int retry, retrans = MAXRETRANS;

  74.     for(;;)
  75.     {
  76.         for( retry = 0; retry < 16; ++retry)
  77.         {
  78.             if (trychar)
  79.                 port_outbyte(trychar);
  80.             c = port_inbyte((DLY_1S)<<1);
  81.             if (last_error == 0)
  82.             {
  83.                 switch (c)
  84.                 {
  85.                 case SOH:
  86.                     bufsz = 128;
  87.                     goto start_recv;
  88.                 case STX:
  89.                     bufsz = 1024;
  90.                     goto start_recv;
  91.                 case EOT:
  92.                     flushinput();
  93.                     port_outbyte(ACK);
  94.                     return len;
  95.                 case CAN:
  96.                     c = port_inbyte(DLY_1S);

  98.                     if (c == CAN)
  99.                     {
  100.                         flushinput();
  101.                         port_outbyte(ACK);
  102.                         return -1;
  103.                     }
  104.                     break;
  105.                 default:
  106.                     break;
  107.                 }
  108.             }
  109.         }
  110.         if (trychar == 'C')
  111.         {
  112.             trychar = NAK;
  113.             continue;
  114.         }
  115.         flushinput();
  116.         port_outbyte(CAN);
  117.         port_outbyte(CAN);
  118.         port_outbyte(CAN);
  119.         return -2;
  120. start_recv:
  121.         if (trychar == 'C') crc = 1;
  122.             trychar = 0;
  123.         p = xbuff;
  124.         *p++ = c;
  125.         for (i = 0; i < (bufsz+(crc?1:0)+3); ++i)
  126.         {
  127.             c = port_inbyte(DLY_1S);

  129.             if (last_error != 0)
  130.                 goto reject;
  131.             *p++ = c;
  132.         }

  134.         if (xbuff[1] == (unsigned char)(~xbuff[2]) &&
  135.             (xbuff[1] == packetno || xbuff[1] == (unsigned char)packetno-1) &&
  136.             check(crc, &xbuff[3], bufsz))
  137.         {
  138.             if (xbuff[1] == packetno)
  139.             {
  140.                 int count = destsz - len;
  141.                 if (count > bufsz)
  142.                     count = bufsz;
  143.                 if (count > 0)
  144.                 {
  145.                     memcpy (&dest[len], &xbuff[3], count);
  146.                     len += count;
  147.                 }
  148.                 ++packetno;
  149.                 retrans = MAXRETRANS+1;
  150.             }
  151.             if (--retrans <= 0)
  152.             {
  153.                 flushinput();
  154.                 port_outbyte(CAN);
  155.                 port_outbyte(CAN);
  156.                 port_outbyte(CAN);
  157.                 return -3;
  158.             }
  159.             port_outbyte(ACK);
  160.             continue;
  161.         }
  162. reject:
  163.         flushinput();
  164.         port_outbyte(NAK);
  165.     }
  166. }

  168. int xmodemTransmit(unsigned char *src, int srcsz)
  169. {
  170.     unsigned char xbuff[1030];
  171.     int bufsz, crc = -1;
  172.     unsigned char packetno = 1;
  173.     int i, c, len = 0;
  174.     int retry;

  176.     for(;;)
  177.     {
  178.         for( retry = 0; retry < 16; ++retry)
  179.         {
  180.             c = port_inbyte((DLY_1S)<<1);
  181.             if (last_error == 0)
  182.             {
  183.                 switch (c)
  184.                 {
  185.                 case 'C':
  186.                     crc = 1;
  187.                     goto start_trans;
  188.                 case NAK:
  189.                     crc = 0;
  190.                     goto start_trans;
  191.                 case CAN:
  192.                     c = port_inbyte(DLY_1S);
  193.                     if (c == CAN)
  194.                     {
  195.                         port_outbyte(ACK);
  196.                         flushinput();
  197.                         return -1;
  198.                     }
  199.                     break;
  200.                 default:
  201.                     break;
  202.                 }
  203.             }
  204.         }
  205.         port_outbyte(CAN);
  206.         port_outbyte(CAN);
  207.         port_outbyte(CAN);
  208.         flushinput();
  209.         return -2;

  211.         for(;;)
  212.         {
  213. start_trans:
  214.             xbuff[0] = SOH; bufsz = 128;
  215.             xbuff[1] = packetno;
  216.             xbuff[2] = ~packetno;
  217.             c = srcsz - len;
  218.             if (c > bufsz)
  219.                 c = bufsz;
  220.             if (c >= 0)
  221.             {
  222.                 memset (&xbuff[3], 0, bufsz);
  223.                 if (c == 0)
  224.                 {
  225.                     xbuff[3] = CTRLZ;
  226.                 }
  227.                 else
  228.                 {
  229.                     memcpy (&xbuff[3], &src[len], c);
  230.                     if (c < bufsz)
  231.                         xbuff[3+c] = CTRLZ;
  232.                 }
  233.                 if (crc)
  234.                 {
  235.                     unsigned short ccrc = crc16_ccitt(&xbuff[3], bufsz);
  236.                     xbuff[bufsz+3] = (ccrc>>8) & 0xFF;
  237.                     xbuff[bufsz+4] = ccrc & 0xFF;
  238.                 }
  239.                 else
  240.                 {
  241.                     unsigned char ccks = 0;
  242.                     for (i = 3; i < bufsz+3; ++i)
  243.                     {
  244.                         ccks += xbuff[i];
  245.                     }
  246.                     xbuff[bufsz+3] = ccks;
  247.                 }
  248.                 for (retry = 0; retry < MAXRETRANS; ++retry)
  249.                 {
  250.                     for (i = 0; i < bufsz+4+(crc?1:0); ++i)
  251.                     {
  252.                         port_outbyte(xbuff[i]);
  253.                     }
  254.                     c = port_inbyte(DLY_1S);
  255.                     if (last_error == 0 )
  256.                     {
  257.                         switch (c)
  258.                         {
  259.                         case ACK:
  260.                             ++packetno;
  261.                             len += bufsz;
  262.                             goto start_trans;
  263.                         case CAN:
  264.                             c = port_inbyte(DLY_1S);
  265.                             if ( c == CAN)
  266.                             {
  267.                                 port_outbyte(ACK);
  268.                                 flushinput();
  269.                                 return -1;
  270.                             }
  271.                             break;
  272.                         case NAK:
  273.                         default:
  274.                             break;
  275.                         }
  276.                     }
  277.                 }
  278.                 port_outbyte(CAN);
  279.                 port_outbyte(CAN);
  280.                 port_outbyte(CAN);
  281.                 flushinput();
  282.                 return -4;
  283.             }
  284.             else
  285.             {
  286.                 for (retry = 0; retry < 10; ++retry)
  287.                 {
  288.                     port_outbyte(EOT);
  289.                     c = port_inbyte((DLY_1S)<<1);
  290.                     if (c == ACK)
  291.                         break;
  292.                 }
  293.                 flushinput();
  294.                 return (c == ACK)?len:-5;
  295.             }
  296.         }
  297.     }
  298. }


 

阅读(2205) | 评论(0) | 转发(0) |
0

上一篇：心情不怎么好

下一篇：ARM cortex-M3 异常处理分析

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6