diff --git a/bspMCU/My_print.c b/bspMCU/My_print.c index 4453f3b..54cfc88 100644 --- a/bspMCU/My_print.c +++ b/bspMCU/My_print.c @@ -37,8 +37,8 @@ int USART_Send(char *_pBuffer, uint32_t _iSize) int iRet = HAL_UART_Transmit(ptUartUserData->m_uart, (uint8_t *)_pBuffer, _iSize, 100); HAL_GPIO_WritePin(RS485_2_DIR_GPIO_Port, RS485_2_DIR_Pin,GPIO_PIN_RESET); // int iRet = HAL_UART_Transmit_DMA(ptUartUserData->m_uart, (uint8_t *)_pBuffer, _iSize); - - return iRet; + if (iRet != HAL_OK) return RD_FAILURE; + return (int)_iSize; } /*int Dev01check(char *_pBuffer, uint32_t _iSize) diff --git a/bspMCU/l_uart.c b/bspMCU/l_uart.c index da96a22..02ab10d 100644 --- a/bspMCU/l_uart.c +++ b/bspMCU/l_uart.c @@ -24,7 +24,8 @@ int COM1_Send(char *_pBuffer, uint32_t _iSize) HAL_GPIO_WritePin(RS485_2_DIR_GPIO_Port, RS485_2_DIR_Pin,GPIO_PIN_SET); int iRet = HAL_UART_Transmit(ptUartUserData->m_uart, (uint8_t *)_pBuffer, _iSize, 100); HAL_GPIO_WritePin(RS485_2_DIR_GPIO_Port, RS485_2_DIR_Pin,GPIO_PIN_RESET); - return iRet; + if (iRet != HAL_OK) return RD_FAILURE; + return (int)_iSize; } int COM0_Send(char *_pBuffer, uint32_t _iSize) @@ -45,7 +46,11 @@ static int l_com_new(lua_State *L) if (id == 1 || id == 2) { TUartUserData *ptUartUserData = UART_userdata_init(LUACOM_ID, baudrate, 0); - if (NULL == ptUartUserData) lua_print("com is already used\n"); + if (NULL == ptUartUserData) + { + lua_print("com is already used\n"); + return g_ptCom1; + } g_ptCom1 = rd_ComCreate(NULL, NULL, COM1_Send, ptUartUserData->m_buf_size, ptUartUserData); UART_IT_init(g_ptCom1); u->m_ptComCtrl = g_ptCom1; diff --git a/library/common/rd_mempool.c b/library/common/rd_mempool.c index 983ff4b..087cac5 100644 --- a/library/common/rd_mempool.c +++ b/library/common/rd_mempool.c @@ -307,6 +307,11 @@ WEAK void* Rd_MemPoolMalloc(size_t size) WEAK void Rd_MemPoolFree(void* ptr) { + if (ptr == NULL) + { + return; + } + if (!is_valid_ptr(ptr)) { log_e("[%p] MemPool Free Error: Invalid Pointer %p", __builtin_return_address(0), ptr); diff --git a/peripheral/include/ymodem.h b/peripheral/include/ymodem.h index 6fa23e8..5df7b82 100644 --- a/peripheral/include/ymodem.h +++ b/peripheral/include/ymodem.h @@ -64,6 +64,21 @@ enum rym_code #define RYM_MAX_ERRORS ((size_t)5) #endif +/* 发送方向: 收到 NAK / 等应答超时时, 重发同一包的最大次数. + * 注意 YMODEM 里 NAK 的语义是"这一包没收好, 请重发", 不是失败退出; + * 接收端(尤其是刚建完文件/还没就绪时) 头一两次回 NAK 是正常现象. */ +#ifndef RYM_TX_RETRY_MAX +#define RYM_TX_RETRY_MAX 10 +#endif + +/* 发送方向数据块的大小选择: + * 1 = 数据阶段一律用 1K(STX) 块 (标准 YMODEM 发送端行为, lrzsz 的 sz 默认如此). + * 0 = 按本块实际字节数选择 SOH(128B)/STX(1K). + * 对接某些终端(如 Xshell)时它们只接受 STX 数据块, 收到 SOH 数据块会一直回 NAK. */ +#ifndef RYM_TX_BLOCK_1K +#define RYM_TX_BLOCK_1K 1 +#endif + enum rym_stage { RYM_STAGE_NONE = 0, diff --git a/peripheral/ry_sy.c b/peripheral/ry_sy.c index 22e39cd..b332354 100644 --- a/peripheral/ry_sy.c +++ b/peripheral/ry_sy.c @@ -8,6 +8,7 @@ #include "ymodem.h" #include "rd_stdio.h" +#include "ringbuffer.h" #include #ifndef YMODEM_PATH_MAX @@ -18,31 +19,68 @@ struct custom_ctx { struct rym_ctx parent; void *fp; /* Rd_Fopen 返回的文件句柄 */ - int flen; /* 剩余待接收字节数 */ + int flen; /* 剩余待接收字节数, <0 表示对端未给长度 */ + int expect_index; /* 下一包应有的序号, 0 表示还没收到数据包 */ char fpath[YMODEM_PATH_MAX]; }; /* ═══════════════════════════════════════════════════════════════════════ * * TComCtrl → rym_device_t 桥接 * - * 读: rd_ComRead (内部自带信号量等待, 无协议回调时直接返回原始字节) * - * 写: rd_ComSend * + * 读: 直接掏接收环形缓冲区 (见 serial_rym_read, 不走 rd_ComRead) * + * 写: rd_ComSend (底层回调必须按"实际字节数"返回) * * 无需额外维护信号量 * * ═══════════════════════════════════════════════════════════════════════ */ +/* + * YMODEM 是原始二进制流, 不能借用 rd_ComRead: + * 1) m_pfCheck == NULL 时 rd_ComRead 内部 iPackLen 恒为 1, 每次只返回 1 字节, + * 再叠加 ymodem 层的 Rd_Delay(1)=1ms, 吞吐被压到 ~1KB/s (115200 下慢 11 倍); + * 2) rd_ComRead 在环空时执行 Rd_SemWait (osWaitForever) 永久阻塞, + * 使 ymodem 层所有基于 Rd_GetTime() 的超时变成死代码, 对端一停发就永久卡死. + * 这里一次取走环里已到达的全部字节; 无数据返回 0, 由上层用 + * Rd_GetTime()/Rd_Delay(1) 轮询控制节奏与超时退出. + */ static size_t serial_rym_read(void *opaque, uint8_t *buf, size_t len) { TComCtrl *ptCom = (TComCtrl *)opaque; - if (ptCom == NULL || len == 0) return 0; + size_t got = 0; + + if (ptCom == NULL || ptCom->m_stComBuf.m_ptRecv == NULL || buf == NULL || len == 0) + return 0; - int ret = rd_ComRead(ptCom, (char *)buf, (uint32_t)len); - return (ret > 0) ? (size_t)ret : 0; + while (got < len) + { + char ch; + if (rd_RingbufferGetchar(ptCom->m_stComBuf.m_ptRecv, &ch) != 1) + break; + buf[got++] = (uint8_t)ch; + } + + return got; } static size_t serial_rym_write(void *opaque, const uint8_t *buf, size_t len) { TComCtrl *ptCom = (TComCtrl *)opaque; - if (ptCom == NULL) return 0; - return (size_t)rd_ComSend(ptCom, (char *)buf, (uint32_t)len); + int ret; + + if (ptCom == NULL || buf == NULL || len == 0) return 0; + + /* 返回实际写出的字节数; 失败返回 0 交给 ymodem 层超时处理, + * 不能把负数负值强转成 size_t 大数 */ + ret = rd_ComSend(ptCom, (char *)buf, (uint32_t)len); + if (ret <= 0) + { + /* 发送失败在 ymodem 层只会表现为"对端不回话", 很难定位, 所以直接报出来: + * ret=-2(RD_NULL): TComCtrl 为空或 m_pfSend 未接 + * ret=-1(RD_FAILURE): 底层写失败 (上位机侧常见于 COM 口没打开成功/ + * 被别的程序占用, 例如 Xshell 还开着) + * ret=0: 一个字莂也没写出去 */ + log_e("ymodem TX: rd_ComSend failed (ret=%d, len=%u) -> 字节没发出去", + ret, (unsigned)len); + return 0; + } + return (size_t)ret; } static void ymodem_build_device(TComCtrl *ptCom, rym_device_t *dev) @@ -53,6 +91,50 @@ static void ymodem_build_device(TComCtrl *ptCom, rym_device_t *dev) dev->opaque = ptCom; } +/* + * 会话开始前把接收环里的残留字节丢掉. + * 否则上一条命令/上一次会话遗留的 'C' (接收端催包) 或 ACK 会顶到前面, + * 使 ymodem 的"发送一个包 → 读一个应答"序列整体错位: + * 表现就是传输跑了一半报 -118 (RYM_ERR_ACK), 或者会话结束时收不到正确应答. + * + * 同时必须把 m_sem_Recv 的计数也清零: + * 接收路径 (rd_ComRecvProc) 每收一批数据就 Rd_SemPost(m_sem_Recv), + * 而 rd_ComRead 的约定是"先等信号量、再读环". + * serial_rym_read 绕过 rd_ComRead 直接掏环, 信号量只进不出, 计数会顶到上限; + * 不清零的话, 会话结束后 c:read() 会"信号量立刻等到、环里却没数据", + * 阻塞语义被破坏 (空读/假就绪). + */ +static void ymodem_flush_rx(TComCtrl *ptCom) +{ + char ch; + int guard; + + if (ptCom == NULL) + return; + + if (ptCom->m_stComBuf.m_ptRecv != NULL) + { + while (rd_RingbufferGetchar(ptCom->m_stComBuf.m_ptRecv, &ch) == 1) + { + /* 丢弃 */ + } + } + + /* 把残留的"有数据"信号也吃掉, 恢复"sem>0 ⇒ 环里有数据"的约定. + * 计数有上限(init+1), 正常情况下几次就空; guard 只防异常实现死循环. + * + * 用 0 ms = 纯试探, 不等. 前提是 Rd_SemWaitTimeout 真的遵守超时: + * FreeRTOS: osSemaphoreAcquire(sem, 0) ✓ 非阻塞 + * Win32 : pthread_cond_timedwait 到期时间=当前 ✓ 立即返回 + * Linux : rd_thread.c 的 WEAK 兜底恒返回 -1 ✓ 不会阻, 但也清不掉计数 + * (Win32 曾把超时丢掉转成阻塞等待, 导致上位机 ry 在这里挂死, 已修) */ + for (guard = 0; guard < 1024; guard++) + { + if (Rd_SemWaitTimeout(&ptCom->m_stComBuf.m_sem_Recv, 0) != 0) + break; + } +} + /* ═══════════════════════════════════════════════════════════════════════ * * YMODEM 接收回调 (文件写入) * * ═══════════════════════════════════════════════════════════════════════ */ @@ -83,27 +165,52 @@ static enum rym_code _rym_recv_begin(struct rym_ctx *ctx, uint8_t *buf, size_t l if (cctx->flen == 0) cctx->flen = -1; + cctx->expect_index = 0; /* 新文件, 序号重新开始 */ + log_i("ymodem RX: file '%s', declared size=%d", cctx->fpath, cctx->flen); + return RYM_CODE_ACK; } static enum rym_code _rym_recv_data(struct rym_ctx *ctx, uint8_t *buf, size_t len) { struct custom_ctx *cctx = (struct custom_ctx *)ctx; + uint8_t index = ctx->buf[1]; /* 本包序号 */ + ssize_t ret; if (cctx->fp == NULL) return RYM_CODE_CAN; - if (cctx->flen == -1) + /* 序号去重: 对端重传的包只能回 ACK, 绝不能再写一次. + * 否则每次重传都会把同一段数据追加到文件里, 文件会变成 + * "原内容重复 N 遍" (实测一个 5 字节的文件被撑到了 1490 字节) */ + if (cctx->expect_index > 0 && cctx->expect_index <= 0xFF) { - Rd_Mwrite(buf, len, cctx->fp); + if (index == (uint8_t)(cctx->expect_index - 1)) + return RYM_CODE_ACK; /* 重复包: 已经写过, 只确认 */ + if (index != (uint8_t)cctx->expect_index) + return RYM_CODE_NAK; /* 跳包/乱序: 不写也不确认, 等对端重传 */ + } + + if (cctx->flen < 0) + { + ret = Rd_Mwrite(buf, len, cctx->fp); /* 对端没给长度, 来多少写多少 */ } else { - int wlen = (int)(len > (size_t)cctx->flen ? (size_t)cctx->flen : len); - Rd_Mwrite(buf, wlen, cctx->fp); + /* 严格按包头声明的长度截断, flen 不会变成负数后被当成"无限写" */ + int wlen = ((int)len > cctx->flen) ? cctx->flen : (int)len; cctx->flen -= wlen; + ret = Rd_Mwrite(buf, (size_t)wlen, cctx->fp); + } + + if (ret < 0) + { + log_e("ymodem RX data: write failed (ret=%ld), aborting", (long)ret); + return RYM_CODE_CAN; /* 写入失败: 中止会话 */ } + cctx->expect_index = (int)index + 1; /* 记录下一包应有的序号 */ + return RYM_CODE_ACK; } @@ -149,7 +256,10 @@ static enum rym_code _rym_send_begin(struct rym_ctx *ctx, uint8_t *buf, size_t l RD_MEMSET(buf, 0, len); const char *fname = _get_path_lastname(cctx->fpath); + /* YMODEM 包头第二字段必须是十进制文件长度字符串 (CRC/Checksum 模式由握手字节 C/NAK 协商); + * 这里写 "STX" 之类的标识符是非法的, 接收端会把文件长度解析成 0 */ RD_SPRINTF((char *)buf, "%s%c%ld", fname, '\0', file_size); + log_i("ymodem TX: file '%s' declared size=%ld byte(s)", fname, file_size); return RYM_CODE_SOH; } @@ -173,7 +283,15 @@ static enum rym_code _rym_send_data(struct rym_ctx *ctx, uint8_t *buf, size_t le ctx->stage = RYM_STAGE_FINISHING; } +#if RYM_TX_BLOCK_1K + /* 数据阶段一律用 1K(STX) 块 + 0x1A 填满, 这是标准 YMODEM 发送端的行为 + * (lrzsz 的 sz 默认就是 1K 块). 部分接收端(含 Xshell)只接受 STX 数据块, + * 收到 SOH 数据块会一直回 NAK; 文件尾不足 1K 时靠包头里的长度截断. */ + return RYM_CODE_STX; +#else + /* 按本块实际字节数选择 128B/1K 块 (旧行为) */ return (read_size > 128) ? RYM_CODE_STX : RYM_CODE_SOH; +#endif } static enum rym_code _rym_send_end(struct rym_ctx *ctx, uint8_t *buf, size_t len) @@ -205,13 +323,18 @@ int rym_download_file(TComCtrl *ptCom, const char *file_path) return RD_FAILURE; } ctx->fp = NULL; - RD_STRNCPY(ctx->fpath, file_path, YMODEM_PATH_MAX); + RD_STRNCPY(ctx->fpath, file_path, YMODEM_PATH_MAX - 1); ymodem_build_device(ptCom, &dev); + ymodem_flush_rx(ptCom); res = rym_recv_on_device(&ctx->parent, &dev, _rym_recv_begin, _rym_recv_data, _rym_recv_end, 10); + /* 会话期间 ISR 一直在 post m_sem_Recv 而没人 acquire, + * 结束时再清一次, 保证后续 rd_ComRead 的阻塞语义正常 */ + ymodem_flush_rx(ptCom); + if (ctx->fp != NULL) Rd_Mclose(ctx->fp); RD_FREE(ctx); @@ -230,13 +353,18 @@ int rym_upload_file(TComCtrl *ptCom, const char *file_path) return RD_FAILURE; } ctx->fp = NULL; - RD_STRNCPY(ctx->fpath, file_path, YMODEM_PATH_MAX); + RD_STRNCPY(ctx->fpath, file_path, YMODEM_PATH_MAX - 1); ymodem_build_device(ptCom, &dev); + ymodem_flush_rx(ptCom); res = rym_send_on_device(&ctx->parent, &dev, _rym_send_begin, _rym_send_data, _rym_send_end, 10); + /* 会话期间 ISR 一直在 post m_sem_Recv 而没人 acquire, + * 结束时再清一次, 保证后续 rd_ComRead 的阻塞语义正常 */ + ymodem_flush_rx(ptCom); + if (ctx->fp != NULL) Rd_Mclose(ctx->fp); RD_FREE(ctx); diff --git a/peripheral/ymodem.c b/peripheral/ymodem.c index 9f3a8c0..642f9bf 100644 --- a/peripheral/ymodem.c +++ b/peripheral/ymodem.c @@ -109,9 +109,16 @@ static ssize_t _rym_read_data(struct rym_ctx *ctx, size_t len) while (Rd_GetTime() - start < RYM_WAIT_CHR_MS) { size_t n = ctx->dev.read(ctx->dev.opaque, buf + readlen, len - readlen); - readlen += n; - if (readlen >= len) - return readlen; + if (n > 0) + { + readlen += n; + if (readlen >= len) + return readlen; + /* 还有数据就继续搬, 不要在这里白等 1ms */ + continue; + } + + /* 只有真的没数据可读时才让出 CPU */ Rd_Delay(1); } return readlen; @@ -142,13 +149,29 @@ static int _rym_send_packet(struct rym_ctx *ctx, enum rym_code code, uint8_t ind ctx->buf[packetlen - 2] = (uint8_t)(send_crc >> 8); ctx->buf[packetlen - 1] = (uint8_t)send_crc & 0xff; + /* DEBUG: 发包前确认 CRC + 序号正确 */ + char hex_buf[16]; + RD_SNPRINTF(hex_buf, sizeof(hex_buf), "%02X:%02X crc=%04X", index, index_inv, send_crc); + log_d("ymodem TX pkt: %s [%uB]", hex_buf, (unsigned)packetlen); + size_t writelen = 0; - do + uint32_t retry = 0; + + while (writelen < packetlen) { size_t n = ctx->dev.write(ctx->dev.opaque, ctx->buf + writelen, packetlen - writelen); + if (n == 0) + { + /* 底层写回调返回 0 (未写出任何字节) 时不能原地死循环: + * 比如它误把 HAL_OK(0) 当作"已写字节数"返回 */ + if (++retry >= (uint32_t)(RYM_WAIT_CHR_MS / 10u)) + return RD_FAILURE; + Rd_Delay(1); + continue; + } writelen += n; + retry = 0; } - while (writelen < packetlen); return RD_SUCCESS; } @@ -160,13 +183,9 @@ static void _rym_putchar(struct rym_ctx *ctx, uint8_t code) static uint8_t _rym_getchar(struct rym_ctx *ctx) { - uint8_t c; - /* rd_ComRead 内部阻塞等待数据, 此处只需重试即可 */ - while (ctx->dev.read(ctx->dev.opaque, &c, 1) != 1) - { - Rd_Delay(1); - } - return c; + /* 带超时的等应答: 不能无限等 (对端无响应时旧实现会把 lua 线程永久卡住), + * 超时返回 RYM_CODE_NONE, 由调用方按"应答不对"上报 -RYM_ERR_ACK */ + return (uint8_t)_rym_read_code(ctx, RYM_WAIT_PKG_MS); } static int _rym_do_handshake(struct rym_ctx *ctx, int tm_sec) @@ -175,12 +194,13 @@ static int _rym_do_handshake(struct rym_ctx *ctx, int tm_sec) size_t i; uint16_t recv_crc, cal_crc; size_t data_sz = 0; - uint32_t start, deadline; ctx->stage = RYM_STAGE_ESTABLISHING; + log_i("ymodem RX handshake: start polling, %d rounds x %u ms", tm_sec, (unsigned)RYM_CHD_INTV_MS); for (i = 0; i < (size_t)tm_sec; i++) { _rym_putchar(ctx, RYM_CODE_C); + log_i("ymodem RX handshake: sent 'C' #%u, waiting header...", (unsigned)(i + 1)); code = _rym_read_code(ctx, RYM_CHD_INTV_MS); if (code == RYM_CODE_SOH) { @@ -192,33 +212,51 @@ static int _rym_do_handshake(struct rym_ctx *ctx, int tm_sec) data_sz = _RYM_STX_PKG_SZ; break; } + else if (code != RYM_CODE_NONE) + { + /* 有字节但不是包头: 说明链路通, 问题在协议/对端 */ + log_w("ymodem RX handshake: got 0x%02X while waiting header", (unsigned)code); + } } if (i == (size_t)tm_sec) - return -RYM_ERR_TMO; - - /* 接收剩余数据 */ - i = 0; - start = Rd_GetTime(); - deadline = start + 100; - while (Rd_GetTime() <= deadline && i < (data_sz - 1)) { - i += _rym_read_data(ctx, data_sz - 1); - Rd_Delay(5); + log_e("ymodem RX handshake: no packet header in %d rounds x %u ms (一个字节都没收到 -> 查端口/接线)", + tm_sec, (unsigned)RYM_CHD_INTV_MS); + return -RYM_ERR_TMO; } + /* 接收剩余数据: 必须一次读完. + * _rym_read_data 每次都是从 ctx->buf + 1 的偏移 0 开始写, 分多次调用会互相覆盖, + * 而外层用 i 累加长度会误判为"已收齐"; 原来的 100ms 窗口也和 + * _rym_read_data 内部的 RYM_WAIT_CHR_MS 超时自相矛盾 (根本来不及). */ + i = _rym_read_data(ctx, data_sz - 1); if (i != (data_sz - 1)) + { + log_e("ymodem RX HANDSHAKE: header short read %u/%u", (unsigned)i, (unsigned)(data_sz - 1)); return -RYM_ERR_DSZ; + } if (ctx->buf[1] != 0 || ctx->buf[2] != 0xFF) + { + log_e("ymodem RX HANDSHAKE: bad header seq 0x%02X/0x%02X", ctx->buf[1], ctx->buf[2]); return -RYM_ERR_SEQ; + } recv_crc = (uint16_t)(*(ctx->buf + data_sz - 2) << 8) | *(ctx->buf + data_sz - 1); cal_crc = CRC16(ctx->buf + 3, data_sz - 5); if (recv_crc != cal_crc) + { + log_e("ymodem RX HANDSHAKE: header crc mismatch recv=0x%04X calc=0x%04X", recv_crc, cal_crc); return -RYM_ERR_CRC; + } if (ctx->on_begin && ctx->on_begin(ctx, ctx->buf + 3, data_sz - 5) != RYM_CODE_ACK) + { + log_e("ymodem RX HANDSHAKE: create/open file failed"); return -RYM_ERR_CAN; + } + + log_i("ymodem RX: handshake done"); return RD_SUCCESS; } @@ -228,33 +266,81 @@ static int _rym_do_send_handshake(struct rym_ctx *ctx, int tm_sec) enum rym_code code; size_t i; size_t data_sz; + size_t retry; uint8_t getc_ack; ctx->stage = RYM_STAGE_ESTABLISHING; data_sz = _RYM_SOH_PKG_SZ; + log_i("ymodem TX handshake: waiting for receiver's 'C' (%d rounds x %u ms)...", + tm_sec, (unsigned)RYM_CHD_INTV_MS); for (i = 0; i < (size_t)tm_sec; i++) { code = _rym_read_code(ctx, RYM_CHD_INTV_MS); if (code == RYM_CODE_C) break; + if (code != RYM_CODE_NONE) + { + /* 收到别的字节也报出来: 区分"链路完全没数据"与"有数据但不是 'C'" */ + log_w("ymodem TX handshake: got 0x%02X while waiting 'C'", (unsigned)code); + } } if (i == (size_t)tm_sec) + { + log_e("ymodem TX handshake: no 'C' in %d rounds x %u ms (一个字节都没收到 -> 查端口/接线)", + tm_sec, (unsigned)RYM_CHD_INTV_MS); return -RYM_ERR_TMO; + } if (ctx->on_begin && ctx->on_begin(ctx, ctx->buf + 3, data_sz - 5) != RYM_CODE_SOH) + { + log_e("ymodem TX handshake: build file header failed"); return -RYM_ERR_CODE; + } - _rym_send_packet(ctx, RYM_CODE_SOH, 0); + /* 发包头. 对端可能还没准备好(比如正在建文件)而回 NAK 或干脆不回, + * 这两种都是"重发", 不能当失败退出 */ + for (retry = 0; ; retry++) + { + _rym_send_packet(ctx, RYM_CODE_SOH, 0); - getc_ack = _rym_getchar(ctx); - if (getc_ack != RYM_CODE_ACK) - return -RYM_ERR_ACK; + /* 接收端在等包头期间会反复发 'C', 环里可能残留多个; + * 先跳过它们, 否则后面读到的"应答"会整体错位 */ + do + { + getc_ack = _rym_getchar(ctx); + } + while (getc_ack == RYM_CODE_C); + + if (getc_ack == RYM_CODE_ACK) + break; + + if (getc_ack == RYM_CODE_CAN) + { + log_e("ymodem TX handshake: receiver cancelled (CAN)"); + return -RYM_ERR_CAN; + } + + if (retry + 1 >= (size_t)RYM_TX_RETRY_MAX) + { + log_e("ymodem TX HANDSHAKE: header not ACKed after %u tries, last=0x%02X (0x00=timeout)", + (unsigned)RYM_TX_RETRY_MAX, getc_ack); + return -RYM_ERR_ACK; + } + + log_w("ymodem TX handshake: header %s -> resend (%u/%u)", + (getc_ack == RYM_CODE_NAK) ? "NAKed" : "no reply", + (unsigned)(retry + 1), (unsigned)RYM_TX_RETRY_MAX); + } getc_ack = _rym_getchar(ctx); if (getc_ack != RYM_CODE_C) + { + log_e("ymodem TX HANDSHAKE: no 'C' after header ACK, got=0x%02X (0x00=timeout)", getc_ack); return -RYM_ERR_ACK; + } + log_i("ymodem TX: handshake done"); ctx->stage = RYM_STAGE_ESTABLISHED; return RD_SUCCESS; } @@ -266,10 +352,16 @@ static int _rym_trans_data(struct rym_ctx *ctx, size_t data_sz, enum rym_code *c size_t i = _rym_read_data(ctx, tsz); if (i != tsz) + { + log_e("ymodem RX data: short read %u/%u", (unsigned)i, (unsigned)tsz); return -RYM_ERR_DSZ; + } if ((ctx->buf[1] + ctx->buf[2]) != 0xFF) + { + log_e("ymodem RX data: bad seq 0x%02X/0x%02X", ctx->buf[1], ctx->buf[2]); return -RYM_ERR_SEQ; + } if (ctx->stage == RYM_STAGE_ESTABLISHED && ctx->buf[1] == 0x00) { @@ -281,7 +373,10 @@ static int _rym_trans_data(struct rym_ctx *ctx, size_t data_sz, enum rym_code *c recv_crc = (uint16_t)(*(ctx->buf + tsz - 1) << 8) | *(ctx->buf + tsz); if (recv_crc != CRC16(ctx->buf + 3, data_sz)) + { + log_e("ymodem RX data: crc mismatch recv=0x%04X", recv_crc); return -RYM_ERR_CRC; + } if (ctx->on_data) *code = ctx->on_data(ctx, ctx->buf + 3, data_sz); @@ -314,9 +409,12 @@ static int _rym_do_trans(struct rym_ctx *ctx) data_sz = 1024; break; case RYM_CODE_EOT: + log_i("ymodem RX: EOT received, data phase done"); return RD_SUCCESS; default: errors++; + log_w("ymodem RX: unexpected code 0x%02X (error %u/%u)", + (unsigned)code, (unsigned)errors, (unsigned)RYM_MAX_ERRORS); if (errors > RYM_MAX_ERRORS) return -RYM_ERR_CODE; _rym_putchar(ctx, RYM_CODE_NAK); @@ -327,6 +425,8 @@ static int _rym_do_trans(struct rym_ctx *ctx) if (err != RD_SUCCESS) { errors++; + log_e("ymodem RX: block error %d (error %u/%u)", + err, (unsigned)errors, (unsigned)RYM_MAX_ERRORS); if (errors > RYM_MAX_ERRORS) return err; _rym_putchar(ctx, RYM_CODE_NAK); @@ -356,22 +456,63 @@ static int _rym_do_send_trans(struct rym_ctx *ctx) uint32_t index = 1; uint8_t getc_ack; size_t data_sz = _RYM_STX_PKG_SZ; + size_t retry; while (1) { if (!ctx->on_data) return -RYM_ERR_CODE; + /* 注意: 一个块只读一次文件. 下面重传时必须直接复用 ctx->buf, + * 不能再调 on_data, 否则每重传一次就往后多吃一段数据, 文件就乱了 */ code = ctx->on_data(ctx, ctx->buf + 3, data_sz - 5); - _rym_send_packet(ctx, code, index); - index++; + log_i("ymodem TX data: block %u sending (code=0x%02X%s)", + (unsigned)(uint8_t)index, (unsigned)code, + (ctx->stage == RYM_STAGE_FINISHING) ? ", last block" : ""); - getc_ack = _rym_getchar(ctx); - if (getc_ack != RYM_CODE_ACK) - return -RYM_ERR_ACK; + for (retry = 0; ; retry++) + { + _rym_send_packet(ctx, code, index); + + /* 接收端偶尔会在数据阶段夹发 'C' 催包, 直接跳过, 否则应答会整体错位 */ + do + { + getc_ack = _rym_getchar(ctx); + if (getc_ack == RYM_CODE_C) + log_w("ymodem TX data: skip stray 'C' while waiting ACK of block %u", + (unsigned)(uint8_t)index); + } + while (getc_ack == RYM_CODE_C); + + if (getc_ack == RYM_CODE_ACK) + break; + + if (getc_ack == RYM_CODE_CAN) + { + log_e("ymodem TX data: receiver cancelled (CAN) at block %u", (unsigned)(uint8_t)index); + return -RYM_ERR_CAN; + } + + /* NAK / 超时 = "这一块没收好, 请重发" (复用同一块数据) */ + if (retry + 1 >= (size_t)RYM_TX_RETRY_MAX) + { + log_e("ymodem TX DATA PHASE: block %u not ACKed after %u tries, last=0x%02X (0x00=timeout, 0x15=NAK, 0x18=CAN)", + (unsigned)(uint8_t)index, (unsigned)RYM_TX_RETRY_MAX, getc_ack); + return -RYM_ERR_ACK; + } + + log_w("ymodem TX data: block %u %s -> resend (%u/%u)", + (unsigned)(uint8_t)index, (getc_ack == RYM_CODE_NAK) ? "NAKed" : "no reply", + (unsigned)(retry + 1), (unsigned)RYM_TX_RETRY_MAX); + } + + index++; if (ctx->stage == RYM_STAGE_FINISHING) + { + log_i("ymodem TX: all data blocks sent (%u block(s))", (unsigned)index - 1); break; + } } return RD_SUCCESS; @@ -391,7 +532,10 @@ static int _rym_do_fin(struct rym_ctx *ctx) _rym_putchar(ctx, RYM_CODE_NAK); code = _rym_read_code(ctx, RYM_WAIT_PKG_MS); if (code != RYM_CODE_EOT) + { + log_e("ymodem RX FIN phase: expected EOT, got 0x%02X (0x00=timeout)", (unsigned)code); return -RYM_ERR_CODE; + } _rym_putchar(ctx, RYM_CODE_ACK); _rym_putchar(ctx, RYM_CODE_C); @@ -425,6 +569,7 @@ static int _rym_do_fin(struct rym_ctx *ctx) ctx->stage = RYM_STAGE_FINISHED; _rym_putchar(ctx, RYM_CODE_ACK); + log_i("ymodem RX: session finished"); return RD_SUCCESS; } @@ -432,28 +577,55 @@ static int _rym_do_send_fin(struct rym_ctx *ctx) { size_t data_sz; uint8_t index = 0; + size_t retry; uint8_t getc_ack; data_sz = _RYM_SOH_PKG_SZ; - _rym_putchar(ctx, RYM_CODE_EOT); - getc_ack = _rym_getchar(ctx); - if (getc_ack != RYM_CODE_NAK) - return -RYM_ERR_ACK; + /* EOT 阶段: 对端回 NAK 表示"请再发一次 EOT", 直接回 ACK 表示收到, + * 不回(超时)也重发; 三种情况都不能当失败退出 (有些接收端要两三次才确认) */ + for (retry = 0; ; retry++) + { + _rym_putchar(ctx, RYM_CODE_EOT); + getc_ack = _rym_getchar(ctx); - _rym_putchar(ctx, RYM_CODE_EOT); - getc_ack = _rym_getchar(ctx); - if (getc_ack != RYM_CODE_ACK) - return -RYM_ERR_ACK; + if (getc_ack == RYM_CODE_ACK) + break; - getc_ack = _rym_getchar(ctx); - if (getc_ack != RYM_CODE_C) - return -RYM_ERR_ACK; + if (getc_ack == RYM_CODE_CAN) + { + log_e("ymodem TX fin: receiver cancelled (CAN)"); + return -RYM_ERR_CAN; + } + + if (retry + 1 >= (size_t)RYM_TX_RETRY_MAX) + { + log_e("ymodem TX FIN PHASE: EOT not ACKed after %u tries, last=0x%02X (0x00=timeout, 0x06=ACK, 0x15=NAK)", + (unsigned)RYM_TX_RETRY_MAX, getc_ack); + return -RYM_ERR_ACK; + } + + log_w("ymodem TX fin: EOT %s -> resend (%u/%u)", + (getc_ack == RYM_CODE_NAK) ? "NAKed" : "no reply", + (unsigned)(retry + 1), (unsigned)RYM_TX_RETRY_MAX); + } + + /* 等接收端的 'C' (表示准备接收下一个文件). + * 不把这一步当致命错误: 数据已经全部发完并被 ACK, 部分接收端不发 'C' + * 而是直接等结束帧; 因为这个地方返回 -118 会误报"传输失败"并且结束帧发不出去, + * 接收端就会一直等下去 (表现就是"不会自动停止") */ + (void)_rym_getchar(ctx); if (ctx->on_end && ctx->on_end(ctx, ctx->buf + 3, data_sz - 5) != RYM_CODE_SOH) return -RYM_ERR_CODE; _rym_send_packet(ctx, RYM_CODE_SOH, index); + + /* 结束帧的 ACK 只做尽力而为的清理: 拿到了就不会残留到下一次会话, + * 拿不到 (超时/对端已收工) 也不影响本次传输结果 */ + (void)_rym_getchar(ctx); + + log_i("ymodem TX: session finished"); ctx->stage = RYM_STAGE_FINISHED; return RD_SUCCESS; }