协议介绍：

广泛用于异步文件传输协议，分为XModem和1k-XModem两种，前者使用128字节的数据块，后者使用1024字节(即1k字节)的数据块。

XModem校验和协议：

字段定义：

0x01 //Xmodem数据头
0x02 //1K-Xmodem数据头
0x04 //发送结束
0x06 //认可响应
0x15 //不认可响应
0x18 //撤销传送
0x1A //填充数据包

XModem信息包格式

  • 标准XModem协议（每个数据包含128字节数据）帧格式 | SOH | 信息包序号 | 信息包序号的补码 | 数据区段 | 校验和 | | —- | —- | —- | —- | —- |
  1. ---------------------------------------------------------------------------
  2. |     Byte1     |    Byte2    |     Byte3      |Byte4~Byte131|  Byte132   |
  3. |-------------------------------------------------------------------------|
  4. |Start Of Header|Packet Number|~(Packet Number)| Packet Data |  Check Sum |
  5. ---------------------------------------------------------------------------
  • 1k-XModem（每个数据包含1024字节数据）帧格式 | STX | 信息包序号 | 信息包序号的补码 | 数据区段 | 校验和 | | —- | —- | —- | —- | —- |
  1. -----------------------------------------------------------------------------------
  2. |     Byte1     |    Byte2    |     Byte3      |Byte4~Byte131|  Byte132-Byte133   |
  3. |---------------------------------------------------------------------------------|
  4. |Start Of Header|Packet Number|~(Packet Number)| Packet Data |  16-bit CRC        |
  5. -----------------------------------------------------------------------------------

数据包说明：

对于标准XModem协议来说，如果传送的文件不是128得到整数倍，那么最后一个数据包的有效内容肯定小于帧长，不足的部分需要用CTRL-Z(0x1A)来填充。
如果传送的是bootloader工程生成的.bin文件，mcu收到后遇到0x1A字符会怎么处理？其实如果传送的是文本文件，那么接收方对于接收的内容是很容易识别的，因为CTRL-Z不是前128个ascii码，不是通用可见字符，如果是二进制文件，mcu其实也不会把它当作代码来执行。哪怕是excel文件等，由于其内部会有些结构表示各个字段长度等，所以不会读取多余的填充字符。否则 Xmodem太弱了。对于1k-Xmodem，同上理。

如何启动传输：

传输由接收方启动，方法是向发送方发送”C”或者NAK(注意，这里提到的NAK是用来启动传输的。以下我们会看到NAK还可以用来对数据产生重传的机制)。接收方发送NAK信号表示接收方打算用累加和校验；发送字符”C”则表示接收方想打算使用CRC校验(具体校验规则下文XModem源码，源码胜于雄辩)。

传输过程：

当接收方发送的第一个”C”或者NAK到达发送方，发送方认为可以发送第一个数据包，传输已经启动。发送方接着应该将数据以每次128字节的数据加上包头，包号，包号补码，末尾加上校验和，打包成帧格式传送。
发送方发了第一包后就等待接收方的确认字节ACK，收到接收方传来的ACK确认，就认为数据包被接收方正确接收，并且接收方要求发送方继续发送下一个包； 如果发送方收到接收方传来的NAK（这里，NAK用来告诉发送方重传，不是用来启动传输）字节，则表示接收方请求重发刚才的数据包；如果发送方收到接收方传来的CAN字节，则表示接收方请求无条件停止传输。

如何结束传输：

如果发送方正常传输完全部数据，需要结束传输，正常结束需要发送方发送EOT字节通知接收方。接收方回以ACK进行确认。当然接收方也可强制停止传输，当接收方发送CAN字节给发送方，表示接收方想无条件停止传输，发送方收到CAN后，不需要再发送EOT确认（因为接收方已经不想理它了，呵呵）。

特殊处理：

虽然数据包是以SOH 来标志一个信息包的起始的，但在SOH位置上如果出现EOT则表示数据传输结束，再也没有数据传过来。
接收方首先应确认数据包序号的完整性，通过对数据包序号取补，然后和数据包序号的补码异或，结果为0表示正确，结果不为0则发送NAK请求重传。
接收方确认数据包序号正确后，然后检查是否期望的序号。如果不是期望得到的数据包序号，说明发生严重错误，应该发送一个 CAN 来中止传输。
如果接收到的数据包的包序号和前一包相同，那么接收方会忽略这个重复包，向发送方发出 ACK ，准备接收下一个包。
接收方确认了信息包序号的完整性和是正确期望的后，只对128字节的数据区段进行算术和校验，结果与帧中最后一个字节（算术校验和）比较，相同发送 ACK，不同发送NAK。

超时处理：

接收方等待一个信息包的到来所具有的超时时限为10 秒，每个超时后发送 NAK。
当收到包时，接收过程中每个字符的超时间隔为 1 秒。
为保持“接收方驱动”，发送方在等待一个启动字节时不应该采用超时处理。
一旦传输开始，发送方采用单独的 1 分钟超时时限，给接收方充足的时间做发送ACK，NAK，CAN之前的必须处理。

校验和的说明：

Xmodem协议支持2种校验和，它们是累加和与CRC校验。
当接收方一开始启动传输时发送的是NAK，表示它希望以累加和方式校验。
当接收方一开始启动传输时发送的是字符”C”，表示它希望以CRC方式校验。
可能有人会问，接收方想怎么校验发送方都得配合吗，难道发送方必须都支持累加和校验和CRC校验？事实上Xmodem要求支持CRC的就必须同时支持累加和，如果发送方只支持累加和，而接收方用字符”C”来启动，那么发送方只要不管它，当接收方继续发送”C”，三次后都没收到应答，就自动会改为发送 NAK，因为它已经明白发送方可能不支持CRC校验，现在接收方改为累加和校验和发送方通讯。发送方收到NAK就赶紧发送数据包响应。

  • 累加校验和：

对N个字节的数据进行累加和运算，然后对256取余数，此种校验方式的校验数据长度为1个字节。
由于校验和只占一个字节，如果累加的和超过255将从零开始继续累加。
https://blog.csdn.net/m0_37697335/article/details/83867199

  • CRC校验：

对N个字节的数据进行CRC计算，然后取低16位，此种校验方式的校验数据长度为2个字节
**

  • 校验和方式的XModem传输流程 ```matlab

| SENDER | | RECIEVER | | | <—- | NAK | | | | Time out after 3 second | | | <—- | NAK | | SOH|0x01|0xFE|Data[0~127]|CheckSum| | —-> | | | | <—- | ACK | | SOH|0x02|0xFD|Data[0~127]|CheckSum| | —-> | | | | <—- | NAK | | SOH|0x02|0xFD|Data[0~127]|CheckSum| | —-> | | | | <—- | ACK | | SOH|0x03|0xFC|Data[0~127]|CheckSum| | —-> | | | | <—- | ACK | | . | | . | | . | | . | | . | | . | | | <—- | ACK | | EOT | —-> | |

| | <—- | ACK |

  1. <a name="9VeJW"></a>
  2. ### CRC16的计算:
  3. ```c
  4. int calcrc(char *ptr, int count)
  5. {
  6.     int crc;
  7.     char i;
  9.     crc = 0;
  10.     while (--count >= 0)
  11.     {
  12.         crc = crc ^ (int) *ptr++ << 8;
  13.         i = 8;
  14.         do
  15.         {
  16.             if (crc & 0x8000)
  17.                 crc = crc << 1 ^ 0x1021;
  18.             else
  19.                 crc = crc << 1;
  20.         } while (--i);
  21.     }
  23.     return (crc);
  24. }

Xmodem协议代码：

  1. #include "BA_UART_CONFIG.h"  
  2. #include "BA_XModem.h"  
  4. #define SOH 0x01  
  5. #define STX 0x02  
  6. #define EOT 0x04  
  7. #define ACK 0x06  
  8. #define NAK 0x15  
  9. #define CAN 0x18  
  10. #define CTRLZ 0x1A  
  11. #define DLY_1S 1000  
  12. #define MAXRETRANS 25  
  14. static int last_error = 0;  
  16. void out_buff(unsigned char *buff, int size)  
  17. {  
  18.     int arg = 0;  
  19.     UART_HANDLER uart = getUartHandler(5);  
  21.     writeSysUart(uart, buff, size, &arg);  
  22. }  
  24. struct sysUartWaitArgStruct sysXmodemUartArg =   
  25. {  
  26.     OS_OPT_PEND_BLOCKING,  
  27.     1000,  
  28.     NULL,  
  29. };  
  30. int in_buff(unsigned char *buff, int time_out)  
  31. {  
  32.     int arg = 0;  
  33.     int qSize = 0;  
  34.     int readSize = 0;  
  35.     UART_HANDLER uart = getUartHandler(5);  
  37.     last_error = 0;  
  39.     sysXmodemUartArg.timeout = time_out;  
  41.     if(RETURN_RESULT_ERROR_NOERR ==   
  42.         ctrlSysUart(uart, DEVICE_CONTROL_WAIT_EVENT, (UART_ARG)(&sysXmodemUartArg)))  
  43.     {  
  44.         qSize = uart->recvDQ.q.curSize;   
  45.         if(qSize > 0)  
  46.         {  
  47.             readSize = readSysUart(uart, buff, qSize, &arg);  
  48.         }  
  49.     }  
  51.     if(readSize == 0)  
  52.         last_error = 1;  
  54.     return (readSize);  
  55. }  
  56. int calcrc(const unsigned char *ptr, int count)  
  57. {  
  58.     int crc;  
  59.     char i;  
  61.     crc = 0;  
  62.     while (--count >= 0)  
  63.     {  
  64.         crc = crc ^ (int) *ptr++ << 8;  
  65.         i = 8;  
  66.         do  
  67.         {  
  68.             if (crc & 0x8000)  
  69.                 crc = crc << 1 ^ 0x1021;  
  70.             else  
  71.                 crc = crc << 1;  
  72.         } while (--i);  
  73.     }  
  75.     return (crc);  
  76. }  
  77. static int check(int crc, const unsigned char *buf, int sz)  
  78. {    
  79.     if(crc)  
  80.     {  
  81.         unsigned short crc = calcrc(buf, sz);  
  82.         unsigned short tcrc = (buf[sz]<<8)+buf[sz+1];  
  84.         if (crc == tcrc)  
  85.             return 1;  
  86.     }  
  87.     else  
  88.     {  
  89.         int i = 0;  
  90.         unsigned char cks = 0;  
  92.         for(i = 0; i < sz; i ++)  
  93.         {  
  94.             cks += buf[i];   
  95.         }  
  97.         if (cks == buf[sz])  
  98.             return 1;  
  99.     }  
  101.     return 0;   
  103. }  
  104. //recv_buff_size == 384  
  105. int xmodemReceive(unsigned char *dest, int destsz)  
  106. {    
  107.     unsigned char xbuff[140];  
  108.     int bufsz = 0;  
  109.     int crc = 0;  
  110.     unsigned char trychar = 'C';  
  111.     unsigned char packetno = 1;  
  112.     int c = 0;  
  113.     int len = 0;  
  114.     int retry = 0;  
  115.     int retrans = MAXRETRANS;  
  116.     int recvSize = 0;  
  118.     for(;;)   
  119.     {  
  120.         for(retry = 0; retry < 16; retry ++)  
  121.         {  
  122.             if(trychar)  
  123.             {  
  124.                 xbuff[0] = trychar;  
  125.                 out_buff(xbuff, 1);  
  126.             }  
  128.             recvSize = in_buff(xbuff, (DLY_1S)<<1);  
  129.             c = xbuff[0];  
  131.             if (last_error == 0)   
  132.             {  
  133.                 switch(c)  
  134.                 {  
  135.                     case SOH:  
  136.                         bufsz = 128;  
  137.                         goto start_recv;  
  138.                     case STX:  
  140.                     {  
  141.                         xbuff[0] = CAN;  
  142.                         out_buff(xbuff, 1);  
  143.                     }  
  144.                     return -1;  
  145.                     case EOT:  
  147.                         {  
  148.                             xbuff[0] = ACK;  
  149.                             out_buff(xbuff, 1);  
  150.                         }  
  151.                         return len;  
  152.                     case CAN:  
  154.                         in_buff(xbuff, DLY_1S);  
  155.                         c = xbuff[0];  
  156.                         if(c == CAN)  
  157.                         {  
  158.                             {  
  159.                                 xbuff[0] = ACK;  
  160.                                 out_buff(xbuff, 1);  
  161.                             }  
  162.                             return -1;  
  163.                         }  
  164.                         break;  
  165.                     default:  
  166.                         break;  
  167.                 }  
  168.             }  
  169.         }  
  171.         if (trychar == 'C')  
  172.         {  
  173.             trychar = NAK;  
  174.             continue;  
  175.         }  
  177.         {  
  178.             xbuff[0] = CAN;  
  179.             out_buff(xbuff, 1);  
  180.             out_buff(xbuff, 1);  
  181.             out_buff(xbuff, 1);  
  182.         }  
  184.         return -2;  
  186. start_recv:  
  187.         if(trychar == 'C')  
  188.             crc = 1;  
  190.         trychar = 0;  
  192.         if(recvSize != (bufsz + (crc ? 1 : 0) + 4))  
  193.             goto reject;  
  195.         if(xbuff[1] == (unsigned char)(~xbuff[2]) &&   
  196.             (xbuff[1] == packetno || xbuff[1] == (unsigned char)packetno - 1) &&   
  197.             check(crc, &xbuff[3], bufsz))  
  198.         {  
  199.             if(xbuff[1] == packetno)  
  200.             {  
  201.                 int count = destsz - len;  
  203.                 if (count > bufsz)  
  204.                     count = bufsz;  
  206.                 if (count > 0)  
  207.                 {  
  208.                     memcpy(&dest[len], &xbuff[3], count);  
  209.                     len += count;  
  210.                 }  
  212.                 packetno ++;  
  214.                 retrans = MAXRETRANS+1;  
  215.             }  
  217.             if(-- retrans <= 0)  
  218.             {  
  219.                 {  
  220.                     xbuff[0] = CAN;  
  221.                     out_buff(xbuff, 1);  
  222.                     out_buff(xbuff, 1);  
  223.                     out_buff(xbuff, 1);  
  224.                 }  
  225.                 return -3;  
  226.             }  
  228.             {  
  229.                     xbuff[0] = ACK;  
  230.                     out_buff(xbuff, 1);  
  231.             }  
  233.             continue;  
  234.         }  
  236. reject:    
  237.         {  
  238.                 xbuff[0] = NAK;  
  239.                 out_buff(xbuff, 1);  
  240.         }  
  242.     }  
  243. }  
  245. //send_buff_size == 140  
  246. int xmodemTransmit(unsigned char *src, int srcsz)  
  247. {  
  248.     unsigned char xbuff[140];  
  249.     int bufsz = 0;  
  250.     int crc = -1;  
  251.     unsigned char packetno = 1;  
  252.     int i = 0;  
  253.     int c = 0;  
  254.     int len = 0;  
  255.     int retry = 0;  
  257.     for(;;)  
  258.     {  
  259.         for( retry = 0; retry < 16; ++retry)  
  260.         {  
  261.             in_buff(xbuff, (DLY_1S)<<1);  
  262.             c = xbuff[0];  
  264.             if(last_error == 0)  
  265.             {  
  266.                 switch(c)  
  267.                 {  
  268.                     case 'C':  
  269.                         crc = 1;  
  270.                         goto start_trans;  
  271.                     case NAK:  
  272.                         crc = 0;  
  273.                         goto start_trans;  
  274.                     case CAN:  
  275.                         in_buff(xbuff, DLY_1S);  
  276.                         c = xbuff[0];  
  277.                         if(c == CAN)   
  278.                         {  
  279.                             {  
  280.                                     xbuff[0] = ACK;  
  281.                                     out_buff(xbuff, 1);  
  282.                             }  
  283.                             return -1;  
  284.                         }  
  285.                         break;  
  286.                     default:  
  287.                         break;  
  288.                 }  
  289.             }  
  290.         }  
  292.         {  
  293.             xbuff[0] = CAN;  
  294.             out_buff(xbuff, 1);  
  295.             out_buff(xbuff, 1);  
  296.             out_buff(xbuff, 1);  
  297.         }  
  299.         return -2;  
  301.         for(;;)  
  302.         {  
  303. start_trans:    
  304.             xbuff[0] = SOH;  
  305.             bufsz = 128;  
  306.             xbuff[1] = packetno;  
  307.             xbuff[2] = ~packetno;  
  309.             c = srcsz - len;  
  310.             if(c > bufsz)  
  311.                 c = bufsz;  
  313.             if(c >= 0)  
  314.             {  
  315.                 memset(&xbuff[3], 0, bufsz);  
  317.                 if (c == 0)  
  318.                 {  
  319.                     xbuff[3] = CTRLZ;  
  320.                 }  
  321.                 else  
  322.                 {  
  323.                     memcpy(&xbuff[3], &src[len], c);  
  325.                     if (c < bufsz)  
  326.                         xbuff[3 + c] = CTRLZ;  
  327.                 }  
  329.                 if(crc)  
  330.                 {  
  331.                     unsigned short ccrc = calcrc(&xbuff[3], bufsz);  
  333.                     xbuff[bufsz + 3] = (ccrc>>8) & 0xFF;  
  334.                     xbuff[bufsz + 4] = ccrc & 0xFF;   
  335.                 }  
  336.                 else  
  337.                 {  
  338.                     unsigned char ccks = 0;  
  340.                     for(i = 3; i < bufsz + 3; i ++)  
  341.                     {  
  342.                         ccks += xbuff[i];  
  343.                     }  
  345.                     xbuff[bufsz + 3] = ccks;  
  346.                 }  
  348.                 for(retry = 0; retry < MAXRETRANS; retry ++)  
  349.                 {  
  350.                     out_buff(xbuff, bufsz + 4 + (crc ? 1 : 0));  
  352.                     in_buff(xbuff, DLY_1S);  
  353.                     c = xbuff[0];  
  355.                     if(last_error == 0)  
  356.                     {  
  357.                         switch(c)  
  358.                         {  
  359.                             case ACK:  
  360.                                 packetno ++;  
  361.                                 len += bufsz;  
  362.                                 goto start_trans;  
  363.                             case CAN:  
  364.                                 in_buff(xbuff, DLY_1S);  
  365.                                 c = xbuff[0];  
  366.                                 if(c == CAN)  
  367.                                 {  
  368.                                     {  
  369.                                         xbuff[0] = ACK;  
  370.                                         out_buff(xbuff, 1);  
  371.                                     }  
  373.                                     return -1;  
  374.                                 }  
  375.                                 break;  
  376.                             case NAK:  
  377.                                 break;  
  378.                             default:  
  379.                                 break;  
  380.                         }  
  381.                     }  
  382.                 }  
  383.                 {  
  384.                     xbuff[0] = CAN;  
  385.                     out_buff(xbuff, 1);  
  386.                     out_buff(xbuff, 1);  
  387.                     out_buff(xbuff, 1);  
  388.                 }  
  390.                 return -4;  
  391.             }  
  392.             else  
  393.             {  
  394.                 for(retry = 0; retry < 10; retry ++)  
  395.                 {  
  396.                     {  
  397.                         xbuff[0] = EOT;  
  398.                         out_buff(xbuff, 1);  
  399.                     }  
  401.                     in_buff(xbuff, (DLY_1S)<<1);  
  402.                     c = xbuff[0];  
  404.                     if(c == ACK)  
  405.                         break;  
  406.                 }  
  408.                 return ((c == ACK) ? len : -5);  
  409.             }  
  410.         }  
  411.     }  
  412. }

Xmodem.h

/**

**/
#ifndef __XMODEM_H__
#define __XMODEM_H__

#ifdef __cplusplus
extern "C" {
    #endif
    #undef EXTERN
    #ifdef __XMODEM_C__
    #define EXTERN
    #else
    #define EXTERN extern
    #endif

    #include "config.h"
    #ifdef XMODEM_ENABLE

    /* Xmodem协议的相关控制符定义 */
    #define SOH                    0x01
    #define STX                    0x02
    #define EOT                    0x04
    #define ACK                    0x06
    #define NAK                    0x15
    #define CAN                    0x18
    #define CTRLZ                0x1A
    #define TRY_TIMEOUT            0x01

    /*Expoorted types--------------------------------*/
    /*Expoorted macro--------------------------------*/
    /*Expoorted functions--------------------------------*/
    EXTERN void XMODEM_Handler(uint8_t data);

    #endif
    #ifdef __cplusplus
}
#endif
#endif

Xmodem.c

#define __XMODEM_C

#include "Xmodem.h"

#ifdef XMODEM_ENABLE

/*Private define-----------------------------------------------*/

#define XMODEM_RX_STATE_STA            0    /*帧头*/
#define XMODEM_RX_STATE_NUM            0    /*序号*/
#define XMODEM_RX_STATE_DAT            0    /*数据*/
#define XMODEM_RX_STATE_CHK            0    /*校验*/

#define XMODEM_TX_STATE_WAIT_STA    0
#define XMODEM_TX_STATE_WAIT_DAT    1
#define XMODEM_TX_STATE_WAIT_ACK    2
#define XMODEM_TX_STATE_WAIT_EOT    3


/*Private variables-----------------------------------------------*/
uint8_t XmodemData[1025];                    /*Xmodem数据包的有效数据缓存*/
uint16_t XmodemSize = 0;                        /*Xmodem数据包的有效数据长度*/
uint8_t XmodemStart = 0;                    /*Xmodem接收和发送数据的状态*/
uint16_t XmodemIndex = 0;                    /*有效数据的下标或当累计数值用*/
uint8_t XmodemNumber[2];                    /*Xmodem数据包序列号*/
uint8_t XmodemCheckData[2];                    /*Xmodem有效数据的校验值*/
uint8_t XmodemCheckType = 0;                /*Xmodem校验类型：0：CRC, 1:SUM*/

/*Private variables-----------------------------------------------*/
uint8_t XmodemFileBuffer[2000];                /*Xmodem发送测试数据*/
uint16_t XmodemSentLength = 0;                /*Xmodem已发送的有效数据长度*/
uint16_t XmodemFileLength = 2000;            /*Xmodem整个发送的有小数据长度*/



/**
*@bried 对Xmodem接收到的数据包进行CRC校验值的计算
**/
uint16_t XMODEM_CalcCheckCRC(uint8_t *data, uint16_t size)
{
    uint32_t CRC = 0;
    uint16_t length = size + 2;

    while(length--)
    {
        uint8_t dat = (length < 2) ? 0 : *data++;

        for(uint8_t i=0; i<8; i++)
        {
            CRC <<= 1;
            if(dat & 0x00080) CRC += 0x0001;
            dat<<=1;
            if(CRC & 0x10000) CRC ^= 0x1021;
        }
    }

    CRC &= 0xFFFu;
}


// 参考资料
https://mbb.eet-china.com/blog/3889467-415666.html

参考文章：

KERMIT,XMODEM,YMODEM,ZMODEM传输协议小结

Xmodem通信协议实例