Xmodem源代码

最新推荐文章于 2024-06-01 18:20:53 发布
最新推荐文章于 2024-06-01 18:20:53 发布
阅读量6.6k 收藏 18
点赞数 4
分类专栏： C语言 文章标签： Xmodem Xmodem协议


1、研究Xmodem协议必看的11个问题

Xmodem协议作为串口数据传输主要的方式之一，恐怕只有做过bootloader的才有机会 接触一下，网上有关该协议的内容要么是英语要么讲解不详细。笔者以前写bootloader时研究过1k-Xmodem，参考了不少相关资料。这里和大家交流一下我对Xmodem的理解，多多指教！


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协议代码
        看了以上说明，再参考代码，应该很容易会理解代码编写者的思路。


2.1、Xmodem源代码 

<span style="font-family: Arial, Helvetica, sans-serif;">#include "crc16.h"</span>

#define SOH  0x01
#define STX  0x02
#define EOT  0x04
#define ACK  0x06
#define NAK  0x15
#define CAN  0x18
#define CTRLZ 0x1A

#define DLY_1S 1000
#define MAXRETRANS 25
static int last_error = 0;

#include "string.h"

void port_outbyte(unsigned char trychar)
{
    unsigned char buf[2];
    buf[0] = trychar;
    lowLevel_write(buf,1);
}

unsigned char port_inbyte(unsigned int time_out)
{
    unsigned char ch;
    int i;
    last_error = 0;

    if(lowLevel_read(&ch,1) == 1)
        return ch;

    last_error = 1;
    return ch;
}

static int check(int crc, const unsigned char *buf, int sz)
{
    if (crc)
    {
        unsigned short crc = crc16_ccitt(buf, sz);
        unsigned short tcrc = (buf[sz]<<8)+buf[sz+1];
        if (crc == tcrc)
            return 1;
    }
    else
    {
        int i;
        unsigned char cks = 0;
        for (i = 0; i < sz; ++i)
        {
            cks += buf[i];
        }
        if (cks == buf[sz])
            return 1;
    }
    return 0;
}

static void flushinput(void)
{
 //while (port_inbyte(((DLY_1S)*3)>>1) >= 0)
    ;
}

int xmodemReceive(unsigned char *dest, int destsz)
{
    unsigned char xbuff[1030];
    unsigned char *p;
    int bufsz, crc = 0;
    unsigned char trychar = 'C';
    unsigned char packetno = 1;
    int i, c, len = 0;
    int retry, retrans = MAXRETRANS;

    for(;;)
    {
        for( retry = 0; retry < 16; ++retry)
        {
            if (trychar)
                port_outbyte(trychar);
            c = port_inbyte((DLY_1S)<<1);
            if (last_error == 0)
            {
                switch (c)
                {
                case SOH:
                    bufsz = 128;
                    goto start_recv;
                case STX:
                    bufsz = 1024;
                    goto start_recv;
                case EOT:
                    flushinput();
                    port_outbyte(ACK);
                    return len;
                case CAN:
                    c = port_inbyte(DLY_1S);

                    if (c == CAN)
                    {
                        flushinput();
                        port_outbyte(ACK);
                        return -1;
                    }
                    break;
                default:
                    break;
                }
            }
        }
        if (trychar == 'C')
        {
            trychar = NAK;
            continue;
        }
        flushinput();
        port_outbyte(CAN);
        port_outbyte(CAN);
        port_outbyte(CAN);
        return -2;
start_recv:
        if (trychar == 'C') crc = 1;
            trychar = 0;
        p = xbuff;
        *p++ = c;
        for (i = 0;  i < (bufsz+(crc?1:0)+3); ++i)
        {
            c = port_inbyte(DLY_1S);

            if (last_error != 0)
                goto reject;
            *p++ = c;
        }

        if (xbuff[1] == (unsigned char)(~xbuff[2]) &&
            (xbuff[1] == packetno || xbuff[1] == (unsigned char)packetno-1) &&
            check(crc, &xbuff[3], bufsz))
        {
            if (xbuff[1] == packetno) 
            {
                int count = destsz - len;
                if (count > bufsz)
                    count = bufsz;
                if (count > 0)
                {
                    memcpy (&dest[len], &xbuff[3], count);
                    len += count;
                }
                ++packetno;
                retrans = MAXRETRANS+1;
            }
            if (--retrans <= 0)
            {
                flushinput();
                port_outbyte(CAN);
                port_outbyte(CAN);
                port_outbyte(CAN);
                return -3;
            }
            port_outbyte(ACK);
            continue;
        }
reject:
        flushinput();
        port_outbyte(NAK);
    }
}

int xmodemTransmit(unsigned char *src, int srcsz)
{
    unsigned char xbuff[1030];
    int bufsz, crc = -1;
    unsigned char packetno = 1;
    int i, c, len = 0;
    int retry;

    for(;;) 
    {
        for( retry = 0; retry < 16; ++retry)
        {
            c = port_inbyte((DLY_1S)<<1);
            if (last_error == 0)
            {
                switch (c)
                {
                case 'C':
                    crc = 1;
                    goto start_trans;
                case NAK:
                    crc = 0;
                    goto start_trans;
                case CAN:
                    c = port_inbyte(DLY_1S);
                    if (c == CAN)
                    {
                        port_outbyte(ACK);
                        flushinput();
                        return -1;
                    }
                    break;
                default:
                    break;
                }
            }
        }
        port_outbyte(CAN);
        port_outbyte(CAN);
        port_outbyte(CAN);
        flushinput();
        return -2;

        for(;;)
        {
start_trans:
            xbuff[0] = SOH; bufsz = 128;
            xbuff[1] = packetno;
            xbuff[2] = ~packetno;
            c = srcsz - len;
            if (c > bufsz) 
                c = bufsz;
            if (c >= 0)
            {
                memset (&xbuff[3], 0, bufsz);
                if (c == 0)
                {
                    xbuff[3] = CTRLZ;
                }
                else
                {
                    memcpy (&xbuff[3], &src[len], c);
                    if (c < bufsz) 
                        xbuff[3+c] = CTRLZ;
                }
                if (crc)
                {
                    unsigned short ccrc = crc16_ccitt(&xbuff[3], bufsz);
                    xbuff[bufsz+3] = (ccrc>>8) & 0xFF;
                    xbuff[bufsz+4] = ccrc & 0xFF;
                }
                else
                {
                    unsigned char ccks = 0;
                    for (i = 3; i < bufsz+3; ++i)
                    {
                        ccks += xbuff[i];
                    }
                    xbuff[bufsz+3] = ccks;
                }
                for (retry = 0; retry < MAXRETRANS; ++retry)
                {
                    for (i = 0; i < bufsz+4+(crc?1:0); ++i)
                    {
                        port_outbyte(xbuff[i]);
                    }
                    c = port_inbyte(DLY_1S);
                    if (last_error == 0 )
                    {
                        switch (c)
                        {
                        case ACK:
                            ++packetno;
                            len += bufsz;
                            goto start_trans;
                        case CAN:
                            c = port_inbyte(DLY_1S);
                            if ( c == CAN)
                            {
                                port_outbyte(ACK);
                                flushinput();
                                return -1;
                            }
                            break;
                        case NAK:
                        default:
                            break;
                        }
                    }
                }
                port_outbyte(CAN);
                port_outbyte(CAN);
                port_outbyte(CAN);
                flushinput();
                return -4;
            }
            else
            {
                for (retry = 0; retry < 10; ++retry)
                {
                    port_outbyte(EOT);
                    c = port_inbyte((DLY_1S)<<1);
                    if (c == ACK) 
                        break;
                }
                flushinput();
                return (c == ACK)?len:-5;
            }
        }
    }
}
2.2、CRC16-CCITT 

crc16.c

＃include "crc16.h"

static const unsigned short crc16tab[256]= {
 0x0000,0x1021,0x2042,0x3063,0x4084,0x50a5,0x60c6,0x70e7,
 0x8108,0x9129,0xa14a,0xb16b,0xc18c,0xd1ad,0xe1ce,0xf1ef,
 0x1231,0x0210,0x3273,0x2252,0x52b5,0x4294,0x72f7,0x62d6,
 0x9339,0x8318,0xb37b,0xa35a,0xd3bd,0xc39c,0xf3ff,0xe3de,
 0x2462,0x3443,0x0420,0x1401,0x64e6,0x74c7,0x44a4,0x5485,
 0xa56a,0xb54b,0x8528,0x9509,0xe5ee,0xf5cf,0xc5ac,0xd58d,
 0x3653,0x2672,0x1611,0x0630,0x76d7,0x66f6,0x5695,0x46b4,
 0xb75b,0xa77a,0x9719,0x8738,0xf7df,0xe7fe,0xd79d,0xc7bc,
 0x48c4,0x58e5,0x6886,0x78a7,0x0840,0x1861,0x2802,0x3823,
 0xc9cc,0xd9ed,0xe98e,0xf9af,0x8948,0x9969,0xa90a,0xb92b,
 0x5af5,0x4ad4,0x7ab7,0x6a96,0x1a71,0x0a50,0x3a33,0x2a12,
 0xdbfd,0xcbdc,0xfbbf,0xeb9e,0x9b79,0x8b58,0xbb3b,0xab1a,
 0x6ca6,0x7c87,0x4ce4,0x5cc5,0x2c22,0x3c03,0x0c60,0x1c41,
 0xedae,0xfd8f,0xcdec,0xddcd,0xad2a,0xbd0b,0x8d68,0x9d49,
 0x7e97,0x6eb6,0x5ed5,0x4ef4,0x3e13,0x2e32,0x1e51,0x0e70,
 0xff9f,0xefbe,0xdfdd,0xcffc,0xbf1b,0xaf3a,0x9f59,0x8f78,
 0x9188,0x81a9,0xb1ca,0xa1eb,0xd10c,0xc12d,0xf14e,0xe16f,
 0x1080,0x00a1,0x30c2,0x20e3,0x5004,0x4025,0x7046,0x6067,
 0x83b9,0x9398,0xa3fb,0xb3da,0xc33d,0xd31c,0xe37f,0xf35e,
 0x02b1,0x1290,0x22f3,0x32d2,0x4235,0x5214,0x6277,0x7256,
 0xb5ea,0xa5cb,0x95a8,0x8589,0xf56e,0xe54f,0xd52c,0xc50d,
 0x34e2,0x24c3,0x14a0,0x0481,0x7466,0x6447,0x5424,0x4405,
 0xa7db,0xb7fa,0x8799,0x97b8,0xe75f,0xf77e,0xc71d,0xd73c,
 0x26d3,0x36f2,0x0691,0x16b0,0x6657,0x7676,0x4615,0x5634,
 0xd94c,0xc96d,0xf90e,0xe92f,0x99c8,0x89e9,0xb98a,0xa9ab,
 0x5844,0x4865,0x7806,0x6827,0x18c0,0x08e1,0x3882,0x28a3,
 0xcb7d,0xdb5c,0xeb3f,0xfb1e,0x8bf9,0x9bd8,0xabbb,0xbb9a,
 0x4a75,0x5a54,0x6a37,0x7a16,0x0af1,0x1ad0,0x2ab3,0x3a92,
 0xfd2e,0xed0f,0xdd6c,0xcd4d,0xbdaa,0xad8b,0x9de8,0x8dc9,
 0x7c26,0x6c07,0x5c64,0x4c45,0x3ca2,0x2c83,0x1ce0,0x0cc1,
 0xef1f,0xff3e,0xcf5d,0xdf7c,0xaf9b,0xbfba,0x8fd9,0x9ff8,
 0x6e17,0x7e36,0x4e55,0x5e74,0x2e93,0x3eb2,0x0ed1,0x1ef0
};
 
unsigned short crc16_ccitt(const char *buf, int len)
{
    register int counter;
    register unsigned short crc = 0;
    for( counter = 0; counter < len; counter++)
        crc = (crc<<8) ^ crc16tab[((crc>>8) ^ *(char *)buf++)&0x00FF];
    return crc;
}



fandelxin
关注
  • 4
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Xmodem接收的代码
hearing1982的专栏
06-10 2690
    Xmodem的程序可以在linux或者各种Bootloader里找到.    但是下面这个是我自己写的----2年多以前,我还没接触或"开源"的时候,想写一个自动升级程序的程序.当时主要的原因是没有烧录器,公司好几个人,就一台烧录器----感觉搬来搬去的太麻烦,效率很低,于是找了Xmodem的资料,就有了下面的程序. --------Xmodem.h-------- #
xModem 单片机代码
10-04
《xModem 单片机代码详解》 ...通过理解xModem协议的工作原理，结合提供的源代码，开发者可以快速地在不同单片机平台上实现本地升级功能。这份代码资源对于从事单片机开发的工程师来说，无疑是一份宝贵的参考资料。
串口通信----XModem协议协议（文件传输）
MQ0522的博客
03-19 1551
串口通信----XModem协议协议（文件传输）
XMODEM源代码
06-13
C语言实现XMODEM协议
XModem协议介绍
最新发布
robin__su的博客
06-01 1396
YMODEM协议的传输过程如下图所示（摘自YMODEM协议手册其中“sb foo.*<CR>”指的是Linux中的sb命令，可在Linux终端执行 sb --help查看使用方法上图中YMODEM协议传输的数据块是128字节，其实YMODEM协议还支持1024字节的数据块，或者128字节和1024字节混合模式。详情请查阅YMODEM协议手册。SOH 表示本数据块大小为128字节STX 表示本数据块大小为1024字节本文中EOT指令仅有一次会话，即上图中的最后一次。
xmodem协议
weixin_41273591的博客
10-09 2418
单片机通信协议整理
串口X-modem协议
weixin_42525096的博客
09-05 667
参考： https://blog.csdn.net/Whistle0602/article/details/108182286 https://blog.csdn.net/tuyerv/article/details/85811212?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnP...
介绍X-MODEM协议
tuyerv的博客
08-27 1129
&#13; 研究Xmodem协议必看的11个问题Xmodem协议作为串口数据传输主要的方式之一，恐怕只有做过bootloader的才有机会 接触一下，网上有关该协议的内容要么是英语要么讲解不详细。笔者以前写bootloader时研究过1k-Xmodem，参考了不少相关资料。这里和大家交流一下我对Xmodem的理解，多多指教！1．Xmodem协议是什么？　　XMODEM协...
X-modem协议
Whistle0602的博客
08-23 1181
研究Xmodem协议必看的11个问题 Xmodem协议作为串口数据传输主要的方式之一，恐怕只有做过bootloader的才有机会 接触一下，网上有关该协议的内容要么是英语要么讲解不详细。笔者以前写bootloader时研究过1k-Xmodem，参考了不少相关资料。这里和大家交流一下我对Xmodem的理解，多多指教！ 1．Xmodem协议是什么？ 　　XMODEM协议是一种串口通信中广泛用到的异步文件传输协议。分为标准Xmodem和1k-Xmodem两种，前者以128字节块的形式传输数据，后者字节块为1k即1
xmodem上位机代码
03-16
它可能包含源代码、编译脚本、测试用例等，用于验证和调试Xmodem功能。 总之，Xmodem协议虽然在现代高速网络中已不再主流，但对于了解早期计算机通信历史和技术发展是有价值的。"xmodem上位机代码"的项目可能是一个...
Xmodem协议详解以及源代码.doc
09-11
此文章收录纯属是从完善本xmodem题目以其系统性考虑。由于下面代码只有发送部分，所以供 读者参考程序设计的框架更有意义
x-modem上位机
03-16
xmodem上位机
C++ XModem和YModem文件传输源码
04-21
XModem和YModem文件传输源码。C++程序实现，供C程序员参考研究。
x-modem上位机 ，win32控制台程序
03-16
x-modem上位机 ，win32控制台程序
Xmodem/Ymodem 协议说明（完整版）
07-27
Xmodem/Ymodem 完整版协议说明，STM32 官方 IAP Demo 所使用协议 XMODEM/YMODEM PROTOCOL REFERENCE A compendium of documents describing the XMODEM and YMODEM File Transfer Protocols
xmodem C语言，单片机 串口中断方式
12-06
xmodem C语言，单片机 串口中断方式接收，使用SecureCRT，Tera Term等工具已通过
linux xmodem C代码
03-15
这个压缩包可能包含两个C源代码文件，一个用于文件上传（发送），另一个用于文件下载（接收）。在这些代码中，你可能会看到以下关键函数和结构： - `send_block()`：用于打包128字节的数据块并附加CRC。 - `recv_...
xmodem源码 程序
jibcy的专栏
01-17 2529
＃i nclude "crc16.h" #define SOH  0x01 #define STX  0x02 #define EOT  0x04 #define ACK  0x06 #define NAK  0x15 #define CAN  0x18 #define CTRLZ 0x1A #define DLY_1S 1000 #define MAXRETRANS 2
X-Modem 协议接收端的实现 For RVDS
RaymondAmos的技术专栏
09-02 1489
前段时间搞ARM实验平台的开发，需要经常实时调试程序。但是烧写一次Flash又太麻烦，后来想到一个最经典的解决方法，就是通过串口下载到内存实时运行调试。本来不想写太多，所以选择了最最古老但又最最有效的一个传输协议：X-Modem。X-Modem协议是 1977 年 Ward Christensen 所发明的。这个协议使用最简单的“等待/重传”算法，对于ARM这一类嵌入式系统来说，由于通常外
xmodem-1k源代码
01-10
xmodem-1k是一种传输协议，用于在计算机之间进行文件传输。下面是xmodem-1k源代码的简要说明： xmodem-1k源代码是用C语言编写的程序，主要包含了数据包的发送和接收功能。 发送端的源代码中，首先会检查待发送文件的大小，并将文件分割成小数据包。每个数据包都包含一个包标识、数据块、错误检验和结束标识。发送端使用串行通信接口发送数据包给接收端。 接收端的源代码负责接收数据包，并进行错误检验和数据解码。接收端从发送端接收数据包，首先检查数据包的完整性，然后对数据包进行解码，将数据块提取出来，并保存到目标文件中。在接收过程中，如果出现错误检验失败或者接收超时等问题，接收端会请求发送端重发数据包。 除了数据包的发送和接收功能外，xmodem-1k源代码还包含了一些错误处理和状态控制机制。例如，如果发送端发送超时，则接收端会提醒发送端重新发送数据包；如果接收端接收超时，则会发送接收确认信号。 总的来说，xmodem-1k源代码实现了一种简单而可靠的文件传输协议。通过将文件分割成小数据包，并使用错误检验和重传机制，xmodem-1k可以确保在不可靠的串行通信环境下进行可靠的文件传输。这种源代码的实现非常重要，并被广泛应用于许多计算机系统中。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值