ymodem协议！！

最新推荐文章于 2023-10-20 17:25:46 发布
最新推荐文章于 2023-10-20 17:25:46 发布
阅读量1.4k 收藏 8
点赞数 2
分类专栏： 协议 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56058618/article/details/128389243
版权

前言

在实习公司遇到一个需求，需要用到ymodem协议来传输文件（仪表传输到控制器）。在网上找了很多资料，但是符合的不太多
于是写下这个博客来记录一下。

一、ymodem协议是什么？

这个就直接打开浏览器，然后百度或者啥，一搜索就一大推，我就不废话再去讲什么是ymodem协议了。
简单的附上一个图片：
简略协议流程图

二、直接贴代码

#include "ymodem_read_file.h"
#include "ymodem.h"
//#include "ebike_util.h"
//#include "..\..\ebike_uart.h"
#include "string.h"

// #include "..\..\ebike_list.h"

#define UPDATA_FILE_NAME 'u', 'p', 'd', 'a', 't', 'a', '.', 'b', 'i', 'n', 0x00, '1', 'f', '4', 0x00
#define UART_YMODEM_READ_BUFFER_LENGTH 1
#define UART_YMODEM_READ_OK_BUFFER_LENGTH 2
#define UART_YMODEM_WRITE_BUFFER_LENGTH 128
#define UART_YMODEM_ALL_WRITE_BUFFER_LENGTH 133
#define UART_YMODEM_BOOT_SEND_COUNT 120
#define UART_YMODEM_BOOTING_READ_BUFFER_LENGTH 80

static kal_uint8 blockon = 0x00;
static kal_uint8 files_size = 500; // byte

static kal_bool files_over_flag = KAL_FALSE;

static kal_uint8 ymodem_read_buffer[UART_YMODEM_READ_BUFFER_LENGTH] = {0};                 // 装CAN,NAK,ACK,C
static kal_uint8 ymodem_read_OK_signal[UART_YMODEM_READ_OK_BUFFER_LENGTH] = {0};           // 装ok
static kal_uint8 ymodem_booting_read_buffer[UART_YMODEM_BOOTING_READ_BUFFER_LENGTH] = {0}; // 版本号厂家序列号、

static kal_bool first_pkg_flag = KAL_FALSE;
static kal_bool last_pkg_flag = KAL_FALSE;

static ymodem_send_data ymodem_send_data_pkg = {0};
static kal_uint8 ymodem_wrote_len = 0;
static kal_uint8 ymodem_unwrite_len = 0;
static kal_uint8 ymodem_write_buffer[UART_YMODEM_ALL_WRITE_BUFFER_LENGTH] = {0};
static ymodem_crc_chk ymodem_crc_check = {0};
static EBIKE_TIMER_ID boot_timer_id;
static kal_uint8 status = STEP_0;

// kal_bool go_on_read_flag = KAL_FALSE;

// extern kal_uint8 read_buffer[];
extern read_updata_file read_updata_file_info;
extern kal_uint16 *bin_file_size;

// 校验计算crc。
static kal_uint16
YModemCrc(kal_uint8 *pdata, kal_uint16 slen)
{
    kal_uint16 crc = 0;
    kal_uint16 i;
    if (slen)
    {
        crc = crc ^ (kal_uint32)(*pdata++) << 8;
        for (i = 8; i != 0; i--)
        {
            if (crc & 0x8000)
                crc = crc << 1;
            else
                crc = crc << 1;
        }
    }
    return crc;
}

// 发送数据包到串口。
void ymodem_send_pgk(kal_uint8 *data, kal_uint8 data_len)
{
    kal_uint8 unwrite;
    kal_uint8 *ptr = NULL;
    kal_int16 wrote = 0;
    ptr = data;

    unwrite = ymodem_unwrite_len - ymodem_wrote_len;
    if (0 == unwrite)
    {
        wrote = ebike_uart_write_data(ptr, data_len);//这个是向串口发送的函数
        if (wrote < data_len)
        {
            kal_uint8 need_write = data_len - wrote;
            if (ymodem_unwrite_len + need_write <= UART_YMODEM_WRITE_BUFFER_LENGTH)
            {
                memcpy(ymodem_write_buffer + ymodem_unwrite_len, ptr + wrote, need_write);
                ymodem_unwrite_len += need_write;
                DBG("uart writing is not completed.");
            }
            else
            {
                DBG("the write buffer is full.");
            }
        }
    }
    else if (0 < unwrite)
    {
        if (ymodem_unwrite_len + data_len <= UART_YMODEM_WRITE_BUFFER_LENGTH)
        {
            memcpy(ymodem_write_buffer + ymodem_unwrite_len, ptr, data_len);
            ymodem_unwrite_len += data_len;
        }
        else
        {
            DBG("the write buffer is full.");
        }
    }
}

/* memcpy memset 的头文件string.h还没有确定加了没*/

// 发送!@#$ 让从机进入boost。
static void ymodem_send_boot_signal()
{
    kal_uint8 boost_signal[] = {0x21, 0x40, 0x23, 0x24};

    // 每120ms发送一次。
    ymodem_send_pgk(boost_signal, sizeof(boost_signal));

    boot_timer_id = ebike_timer_start(ymodem_send_boot_signal, NULL, UART_YMODEM_BOOT_SEND_COUNT);
}

// 主机接收到ok后发送？。
static void ymodem_send_question_mark()
{
    kal_uint8 question_marksignal[] = {0x3f}; // ?

    ymodem_send_pgk(ymodem_send_question_mark, sizeof(ymodem_send_question_mark));
    return;
}

// 文件传输结束后主机发送EOT
static void ymodem_send_EOT()
{
    kal_uint8 EOTsignal[] = {0x04}; // EOT命令

    ymodem_send_pgk(EOTsignal, sizeof(EOTsignal));
    return;
}

// 接收串口函数
static void ymodem_read_uart_info(kal_uint8 *dptr, kal_uint16 data_size)
{
    kal_uint16 read_length;

    memset(dptr, 0, data_size); // 先clean存放数据的buffer，免得干扰。
    read_length = ebike_uart_read_data(dptr, data_size);
    if (0 >= read_length)
    {
        DBG("dnot read anything\n");
    }
    return;
}

// 发送第1帧
static void ymodem_send_first_pkg()
{
    kal_uint8 blockoff = (~blockon & 0xff);

    // 发送第一帧。初始化。
    memset(&ymodem_send_data_pkg, 0, sizeof(ymodem_send_data)); // clean数据帧。

    ymodem_crc_check.summary = YModemCrc(ymodem_send_data_pkg.data, sizeof(ymodem_send_data_pkg.data)); // 注意大小端。

    ymodem_send_data_pkg.total_bytes = YMODEM_CODE_SOH;
    ymodem_send_data_pkg.block_on = blockon;
    ymodem_send_data_pkg.block_off = blockoff;
    ymodem_send_data_pkg.data[UART_YMODEM_WRITE_BUFFER_LENGTH] = {UPDATA_FILE_NAME}; // 文件名与文件大小具体还需要考虑。
    ymodem_send_data_pkg.crc_h = ymodem_crc_check.crc_h_byte;
    ymodem_send_data_pkg.crc_l = ymodem_crc_check.crc_l_byte;

    // 发送第一帧
    ymodem_send_pgk((kal_uint8 *)&ymodem_send_data_pkg, sizeof(ymodem_send_data_pkg));
}

static void ymodem_send_old_pkg()
{
    ymodem_send_pgk((kal_uint8 *)&ymodem_send_data_pkg, sizeof(ymodem_send_data_pkg));
}

static void ymodem_send_new_pkg()
{
    kal_uint8 blockoff;

    blockon++;
    blockoff = (~blockon & 0xff);

    memset(ymodem_send_data_pkg.data, 0, sizeof(ymodem_send_data_pkg.data));

    ymodem_read_file();

    if (read_updata_file_info.data_filled)//数据填充完成标志位
    {
        ymodem_crc_check.summary = YModemCrc(ymodem_send_data_pkg.data, sizeof(ymodem_send_data_pkg.data));
        ymodem_send_data_pkg.block_on = blockon;
        ymodem_send_data_pkg.block_off = blockoff;
        ymodem_send_data_pkg.data = read_updata_file_info.read_buffer;
        ymodem_send_data_pkg.crc_h = ymodem_crc_check.crc_h_byte;
        ymodem_send_data_pkg.crc_l = ymodem_crc_check.crc_l_byte;
    }

    /*
    if (files_size > UART_YMODEM_WRITE_BUFFER_LENGTH)
    {
        // 判断文件是否发送完成。
        if (blockon * 128 < files_size)
        {
            // 写入：500/128=取整。

            // memset( ymodem_send_data_pkg.data, 0, sizeof( ymodem_send_data_pkg.data));
            memcpy(ymodem_send_data_pkg.data, files_ptr, UART_YMODEM_WRITE_BUFFER_LENGTH);
            ymodem_crc_check.summary = YModemCrc(ymodem_send_data_pkg.data, sizeof(ymodem_send_data_pkg.data));
            ymodem_send_data_pkg.crc_h = ymodem_crc_check.crc_h_byte;
            ymodem_send_data_pkg.crc_l = ymodem_crc_check.crc_l_byte;

            files_ptr = files_ptr + UART_YMODEM_WRITE_BUFFER_LENGTH;
        }
        else
        {

            // 写入的500%128=116,余数。写入的最后一次，可以判断为文件结束。
            memcpy(ymodem_send_data_pkg.data, files_ptr, files_size - (blockon - 1) * 128);
            ymodem_crc_check.summary = YModemCrc(ymodem_send_data_pkg.data, sizeof(ymodem_send_data_pkg.data));
            ymodem_send_data_pkg.crc_h = ymodem_crc_check.crc_h_byte;
            ymodem_send_data_pkg.crc_l = ymodem_crc_check.crc_l_byte;

            files_over_flag = KAL_TRUE;
        }
    }
    else // 文件总共字节数不足128
    {
        memcpy(ymodem_send_data_pkg.data, files_ptr, files_size);
        ymodem_crc_check.summary = YModemCrc(ymodem_send_data_pkg.data, sizeof(ymodem_send_data_pkg.data));
        ymodem_send_data_pkg.crc_h = ymodem_crc_check.crc_h_byte;
        ymodem_send_data_pkg.crc_l = ymodem_crc_check.crc_l_byte;

        files_over_flag = KAL_TRUE; 
    }
    */

    ymodem_send_pgk((kal_uint8 *)&ymodem_send_data_pkg, sizeof(ymodem_send_data_pkg));
}

static void ymodem_send_last_pkg()
{

    memset(&ymodem_send_data_pkg, 0, sizeof(ymodem_send_data)); // 清除数据帧。

    ymodem_crc_check.summary = YModemCrc(ymodem_send_data_pkg.data, sizeof(ymodem_send_data_pkg.data)); // 注意大小端。
    ymodem_send_data_pkg.total_bytes = YMODEM_CODE_SOH;
    ymodem_send_data_pkg.block_on = 0x00;
    ymodem_send_data_pkg.block_off = 0xff;
    ymodem_send_data_pkg.data[UART_YMODEM_WRITE_BUFFER_LENGTH] = {0};
    ymodem_send_data_pkg.crc_h = ymodem_crc_check.crc_h_byte;
    ymodem_send_data_pkg.crc_l = ymodem_crc_check.crc_l_byte;

    // 发送结束帧
    ymodem_send_pgk((kal_uint8 *)&ymodem_send_data_pkg, sizeof(ymodem_send_data_pkg));
}

static void ymodem_recv_signal()
{
    kal_uint16 read_length;
    kal_uint16 pre_read_signl = 0;
    kal_uint16 pre_read_old_signl = 0;

    kal_uint8 OKsignal[] = {0x4f, 0x4b}; // OK
    kal_uint8 cmp_result = 1;

    switch (status)
    {
    case STEP_0:
        ymodem_send_boot_signal();
        status = STEP_1;
        break;

    case STEP_1:
        ymodem_read_uart_info(ymodem_read_OK_signal, sizeof(ymodem_read_OK_signal));
        cmp_result = memcmp(OKsignal, ymodem_read_OK_signal, 2);
        if (cmp_result == 0) // 主机接收到的是OK。
        {
            ebike_timer_stop(boot_timer_id); // 关闭120ms发送的timer。
            ymodem_send_question_mark();
            status = STEP_2;
        }
        break;

    case STEP_2:
        ymodem_read_uart_info(ymodem_booting_read_buffer, sizeof(ymodem_booting_read_buffer)); // 接收从机发送过来的版本号厂家序列号等、
        status = STEP_3;
        break;

    case STEP_3:
        ymodem_read_uart_info(ymodem_read_buffer, sizeof(ymodem_read_buffer));
        pre_read_signl = ymodem_read_buffer[0];
        if (pre_read_signl == YMODEM_CODE_CRC)
        {
            ymodem_send_first_pkg();
            status = STEP_4;
        }
        break;

    case STEP_4:
        ymodem_read_uart_info(ymodem_read_buffer, sizeof(ymodem_read_buffer));
        pre_read_signl = ymodem_read_buffer[0];

        if (pre_read_signl == YMODEM_CODE_CAN)
        {
            return; // 结束通信
        }
        if (pre_read_signl == YMODEM_CODE_CRC || pre_read_signl == YMODEM_CODE_NAK)
        {
            // 重新发送第一帧。
            ymodem_send_first_pkg();
        }
        if (pre_read_signl == YMODEM_CODE_ACK)
        {
            pre_read_old_signl = pre_read_signl;
            status = STEP_5;
        }
        break;

    case STEP_5:
        ymodem_read_uart_info(ymodem_read_buffer, sizeof(ymodem_read_buffer));
        pre_read_signl = ymodem_read_buffer[0];
        if (pre_read_signl == YMODEM_CODE_CAN || pre_read_signl == YMODEM_CODE_ACK)
        {
            return; // 结束通信
        }
        if (pre_read_signl == YMODEM_CODE_CRC && pre_read_old_signl == YMODEM_CODE_ACK) // pre_read_old_signl这里用完后要不要fu0？
        {
            // 发送接下来的帧。
            ymodem_send_new_pkg();
            pre_read_old_signl = 0;
            status = STEP_6;
        }
        break;

    case STEP_6:
        ymodem_read_uart_info(ymodem_read_buffer, sizeof(ymodem_read_buffer));
        pre_read_signl = ymodem_read_buffer[0];

        if (pre_read_signl == YMODEM_CODE_CAN)
        {
            return;
        }
        if (pre_read_signl == YMODEM_CODE_NAK)
        {
            ymodem_send_old_pkg();
        }

        if (pre_read_signl == YMODEM_CODE_ACK)
        {
            if (read_updata_file_info.file_over)
            {

                read_updata_file_info.file_over = KAL_FALSE;
                ymodem_send_EOT();
                status = STEP_7;
            }
            else
            {
                ymodem_send_new_pkg();
                // return;
            }
        }
        break;

    case STEP_7:
        ymodem_read_uart_info(ymodem_read_buffer, sizeof(ymodem_read_buffer));
        pre_read_signl = ymodem_read_buffer[0];
        if (pre_read_signl == YMODEM_CODE_CAN)
        {
            return;
        }
        if (pre_read_signl == YMODEM_CODE_NAK)
        {
            ymodem_send_EOT();
            status = STEP_8;
        }
        break;

    case STEP_8:
        ymodem_read_uart_info(ymodem_read_buffer, sizeof(ymodem_read_buffer));
        pre_read_signl = ymodem_read_buffer[0];
        if (pre_read_signl == YMODEM_CODE_CAN)
        {
            return;
        }
        if (pre_read_signl == YMODEM_CODE_ACK)
        {
            pre_read_old_signl = pre_read_signl;
            status = STEP_9;
        }
        if (pre_read_signl == YMODEM_CODE_NAK)
        {
            ymodem_send_EOT();
        }
        break;

    case STEP_9:
        ymodem_read_uart_info(ymodem_read_buffer, sizeof(ymodem_read_buffer));
        pre_read_signl = ymodem_read_buffer[0];
        if (pre_read_signl == YMODEM_CODE_CAN)
        {
            return;
        }
        if (pre_read_signl == YMODEM_CODE_CRC && pre_read_old_signl == YMODEM_CODE_ACK)
        {
            // 发送最后一帧。
            ymodem_send_last_pkg();
            pre_read_old_signl = 0;
        }
        if (pre_read_signl == YMODEM_CODE_ACK)
            return;

        break;
    }
}

// 升级init.
void controller_upgrade()
{
    ymodem_send_boot_signal();
    ymodem_recv_signal();
}


#ifndef _YMODEM_H_
#define _YMODEM_H_

#include "kal_public_defs.h"

#pragma pack(1)
typedef enum
{
    YMODEM_CODE_NONE = 0x0,
    YMODEM_CODE_SOH = 0x01,  /* start of 128-byte data packet */
    YMODEM_CODE_STX = 0x02,  /* start of 1024-byte data packet */
    YMODEM_CODE_EOT = 0x04,  /* end of transmission */
    YMODEM_CODE_ACK = 0x06,  /* receive OK */
    YMODEM_CODE_NAK = 0x015, /* receiver error; retry */
    YMODEM_CODE_CAN = 0x018, /* two of these in succession aborts transfer */
    YMODEM_CODE_CRC = 0x43,  /* use in place of first NAK for CRC mode */
} ymodem_cmd;

typedef enum
{
    STEP_0,
    STEP_1,
    STEP_2,
    STEP_3,
    STEP_4,
    STEP_5,
    STEP_6,
    STEP_7,
    STEP_8,
    STEP_9,
} ymodem_step;

typedef struct
{
    kal_uint16 total_bytes;
    kal_uint8 block_on;
    kal_uint8 block_off;
    kal_uint8 data[128]; //
    kal_uint8 crc_h;
    kal_uint8 crc_l;
} ymodem_send_data, *ymodem_send_data_ptr;

typedef union
{
    kal_uint16 summary;

    struct
    {
        kal_uint8 crc_h_byte;
        kal_uint8 crc_l_byte;
    } check;
} ymodem_crc_chk;

#pragma pack()

void controller_upgrade();

#endif

读文件操作：（传输这个文件之前要先进行读文件大小和读文件内容）

#include "ymodem_read_file.h"

#include "fs_func.h"

#define EBIKE_YMODEM_UPDATA_PATH L"Z:\\update.bin"
#define READ_UPDATA_FILE_BUF_LENGTH 128

static FS_HANDLE file_handle = -1;
kal_uint16 *bin_file_size = NULL;
read_updata_file read_updata_file_info = {0};
int pos = 0;

void ymodem_open_file()
{

    file_handle = FS_Open(EBIKE_YMODEM_UPDATA_PATH, FS_READ_ONLY);

    if (file_handle == FS_NO_ERROR)
    {
        FS_GetFileSize(file_handle, bin_file_size);
    }
    else if (file_handle == FS_FILE_NOT_FOUND)
    {
        DBG("this uodate file dont find\n");

        FS_Close(file_handle);
        return;
    }
}
void ymodem_read_file()
{
    unsigned int *rely_read_length = NULL;

    memset(&read_updata_file_info, 0, sizeof(read_updata_file_info)); // clean数据帧。

    if (*bin_file_size - pos > 128)
    {
        FS_Seek(file_handle, pos, FS_FILE_BEGIN);
        FS_Read(file_handle, read_updata_file_info.read_buffer, READ_UPDATA_FILE_BUF_LENGTH, rely_read_length);
        pos += 128;
    }
    else
    {
        FS_Seek(file_handle, pos, FS_FILE_BEGIN);
        FS_Read(file_handle, read_updata_file_info.read_buffer, *bin_file_size - pos, rely_read_length);

        // read end.
        read_updata_file_info.file_over = KAL_TRUE;
        FS_Close(file_handle);
    }

    // if (*rely_read_length < READ_UPDATA_FILE_BUF_LENGTH)
    // {
    //     // read end.
    //     read_updata_file_info.file_over = KAL_TRUE;
    //     FS_Close(file_handle);
    // }
}

/*
读bin文件，将文件内容读到一个缓冲区，然后再发送这个缓冲区。再seek后读，在发送。

*/

#ifndef __YMODEM_READ_FILE_H__
#define __YMODEM_READ_FILE_H__

#include "kal_public_defs.h"

#pragma pack(1)
typedef struct
{
    kal_uint16 read_buffer[128];
    kal_bool file_over;
    kal_bool data_filled;
} read_updata_file;
// 文件总共大小，文件128字节的数组（这样就不需要extern这个数组了）,是否文件传输结束，128填充是否完成，
#pragma pack()

void ymodem_open_file();
void ymodem_read_file();
#endif

结束：
希望接下来的事情顺利！！！！

加油油——1
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
基于qt的ymodem协议上位机实现
05-31
《基于Qt的YModem协议上位机实现详解》 在信息技术领域，串行通信和文件传输是基础且重要的环节。YModem协议，作为早期的一种文件传输协议，至今仍在某些特定场景下发挥着作用。本文将深入探讨如何使用Qt框架来实现...
YModem协议上传下载上位机工具
11-21
YModem协议是一种在计算机与计算机之间或者计算机与嵌入式设备之间传输文件的协议，尤其常见于串行通信环境中。这个协议最初由Zmodem协议发展而来，简化了文件传输的过程，使其更适合低带宽和不稳定连接的环境。在本...
Ymodem协议详解
INT_TANG的博客
05-27 3256
———————————————— 版权声明：本文为CSDN博主「圆月山庄」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/huangdenan/article/details/103611081
STM32 Ymodem 协议及代码解析
热门推荐
Jesse_嘉伟的专栏
06-02 1万+
STM32 作为 Ymodem 接收端接收升级固件进行升级。   YModem 协议是由 XModem 协议演变而来的，每包数据可以达到 1024 字节，是一个非常高效的文件传输协议。我们平常所说的 Ymodem 协议是指的 Ymodem-1K，除此还有 Ymodem-g（没有 CRC 校验，不常用）。YModem-1K 协议用 1024 字节数据帧传输取代了标准的 128 字节数据帧传输，发送的数据会使用 CRC 校验，保证数据传输的正确性。它每传输一个信息块时，就会等待接收端返回 ACK 信号，接收到响
YModem协议-嵌入式系统远程升级OTA,BootLoad文件传输轻量化协议
qq_53828053的博客
10-20 2331
Xmodem、Ymodem和Zmodem协议是最常用的三种通信协议。Xmodem协议是最早的，传输128字节信息块。Ymodem是Xmodem的改进版协议，具有传输快速稳定的优点。它可以一次传输1024字节的信息块，同时还支持传输多个文件。平常所说的Ymodem协议是指的Ymodem-1K，除此还有Ymodem-g（没有CRC校验，不常用）。YModem-1K用1024字节信息块传输取代标准的128字节传输，数据的发送回使用CRC校验，保证数据传输的正确性。
YMODEM协议
六角雪的博客
11-05 2468
YMODEM通信协议说明，应用在STM32单片机下载。
YMODEM协议笔记
booksyhay的专栏
08-07 814
基本字符 字符 ASCII码16进制 含义说明 SOH 0x01 STX 0x02 ACK 0x06 接收正确应答 NAK 0x15 重传 EOT 0x04 文件传输结束 CAN 0x18 Cancel，取消传输 C 0x43 帧格式 帧头 包序号 数据包序号只有1字节，因此计算范围是0~255；对于数据包大于255的，序号归零重复计算。 ...
YModem介绍
iot小胡的博客
03-04 9588
YModem介绍 简介 YModem是一种文件传输的协议, 可以参考百度百科 YModem百度百科, 本文主要讲解我个人对这个协议的理解. 协议传输的过程 流程如下图所示: 首先大家先了解几个字符的ASCII码 字符 ASCII码16进制 SOH 0x01 STX 0x02 ACK 0x06 NAK 0x15 EOT 0x04 C 0x43 ...
支持Ymodem协议的串口工具
最新发布
05-24
《深入理解Ymodem协议与VC++实现》 Ymodem协议，作为早期在计算机间进行数据传输的协议之一，至今仍然在某些特定领域发挥着重要作用。尤其在串口通信中，由于其可靠性和效率，Ymodem成为了传输大文件的理想选择。...
Ymodem协议C语言实现
08-11
XMODEM协议是一种使用拨号调制解调器的个人计算机通信中广泛使用的异步文件运输协议。这种协议以128字节块的形式传输数据，并且每个块都使用一个校验和过程来进行错误检测。
ymodem发送代码(c语言)
08-24
1、ymodem发送代码(c语言)，网上大多只有接收代码，有也是写得比较乱，此代码小巧便于移植到小系统。 2、优点：io可自定义，注释清晰，传输效率高，短小精炼。
远程升级Ymodem协议参考手册
11-20
将升级数据从服务器下载到本地时所用Ymodem协议的英文原版参考手册。手册中详细介绍了Ymodem协议的各个版本、通信流程、通信时的注意事项和解决办法。
运用Ymodem协议的串口通讯程序示例
03-14
代码提供了如下功能：Linux平台下的串口通讯通用类实现，Ymodem协议的完整实现。其中的shell脚本中包含有如下功能：检查U盘和挂载U盘等等
Xmodem和Ymodem 传输协议JAVA实现
12-28
Xmodem和Ymodem 传输协议JAVA实现
YModem协议.pdf
12-23
YModem协议是由XModem协议演变而来的，每包数据可以达到1024字节，是一个非常高效的文件传输协议。
Ymodem协议的学习
崔建忠的专栏
04-19 3745
一、Ymodem协议学习的目的 1、Ymodem协议的应用 打开超级终端，在传送主菜单里，有接收文件和发送文件的子菜单。也就是超级终端可以与连接的对象之间相互传送文件。 打开发送文件选项，可知，只需要选择“文件名”和“协议”两个选项，就可以进行文件的传送了。 协议的类型有7中，Xmodem及改进的1k-Xmodem，Ymodem和Ymodem-G，Zmodem及其改进协议，以及Kermit
STM32学习笔记之Bootloader升级Ymodem协议简介
智小星的博客
03-16 3997
YModem协议 YModem协议是由XModem协议演变而来的，每包数据可以达到1024字节，是一个非常高效的文件传输协议 。 下面先看下YModem协议传输的完整的握手过程： SENDER：发送方; RECEIVER：接收方; 第一步先由接收方，发送一个字符’C’; 发送方收到’C’后，发送第一帧数据包，内容如下： SOH 00 FF Foo.c NULL[123] ...
ymodem协议详解
01-31
YModem协议是一种用于在串行通信中进行文件传输的通信协议。它是XModem协议的升级版本，允许一次传输多个文件，提供了更高的数据传输效率。 YModem协议利用了一系列控制字符来进行通信。在文件传输之前，发送端首先发送一个指令给接收端，接收端收到指令后会作出相应的反馈。接着发送端会发送文件名和文件大小等信息给接收端，接收端确认接收后，发送端再发送文件的实际内容。在传输过程中，如果出现错误，YModem协议可以进行错误检测和纠正，确保数据的完整性和正确性。 YModem协议使用了更高效的传输模式，可以将文件分成小块逐一传输，减少了传输的开销，提高了传输效率。此外，YModem协议还支持对文件进行压缩，减小传输的数据量，从而节省传输时间。 总的来说，YModem协议是一种高效可靠的文件传输协议，适用于串行通信环境下的文件传输需求。它采用了一系列控制字符来进行通信，可以进行错误检测和纠正，提高了传输效率。同时，YModem协议还支持文件的压缩，进一步减小了传输的数据量，提高了传输速度。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值