From ffbbf79f419c15b5bc309c6e752fa922a36acc45 Mon Sep 17 00:00:00 2001 From: Lizongdi <1210855344@qq.com> Date: Wed, 30 Sep 2026 14:55:18 +0800 Subject: [PATCH] =?UTF-8?q?=E3=80=90=E5=BE=85=E6=B5=8B=E8=AF=95=E3=80=91?= =?UTF-8?q?=E7=A7=BB=E6=A4=8Dymodem?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- RBcore/drv_interface.c | 7 +- bspMCU/l_uart.c | 33 ++- peripheral/include/ymodem.h | 142 +++++++++ peripheral/ry_sy.c | 244 ++++++++++++++++ peripheral/ymodem.c | 560 ++++++++++++++++++++++++++++++++++++ 5 files changed, 983 insertions(+), 3 deletions(-) create mode 100644 peripheral/include/ymodem.h create mode 100644 peripheral/ry_sy.c create mode 100644 peripheral/ymodem.c diff --git a/RBcore/drv_interface.c b/RBcore/drv_interface.c index 2feeb34..74e865d 100644 --- a/RBcore/drv_interface.c +++ b/RBcore/drv_interface.c @@ -145,7 +145,12 @@ void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) #ifdef USE_PRINT UART_RX_IRQHandler(g_ptUartCtrl); #else - UART_RX_IRQHandler(g_apstUart[COM_RS485_2]); +#ifdef USE_LUA_ST_UART + extern TComCtrl *g_ptCom1; + UART_RX_IRQHandler(g_ptCom1); +#else + UART_RX_IRQHandler(g_apstUart[COM_RS485_2]); +#endif #endif } else if (huart->Instance == UART4) diff --git a/bspMCU/l_uart.c b/bspMCU/l_uart.c index c7d7854..da96a22 100644 --- a/bspMCU/l_uart.c +++ b/bspMCU/l_uart.c @@ -2,6 +2,7 @@ #ifdef USE_LUA_ST_UART #include "lua_base.h" #include "bsp_uart.h" +#include "ymodem.h" #ifdef PRINT_ID #ifdef USE_USB #include "bsp_usb.h" @@ -20,7 +21,10 @@ TComCtrl *g_ptCom0; int COM1_Send(char *_pBuffer, uint32_t _iSize) { TUartUserData *ptUartUserData = (TUartUserData *)g_ptCom1->m_pUserData; - return 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_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; } int COM0_Send(char *_pBuffer, uint32_t _iSize) @@ -33,7 +37,7 @@ int COM0_Send(char *_pBuffer, uint32_t _iSize) static int l_com_new(lua_State *L) { int id = luaL_checkinteger(L, 1); - int baudrate = luaL_optinteger(L, 2, 9600); // 默认波特率9600 + int baudrate = luaL_optinteger(L, 2, 115200); // 默认波特率9600 // 创建 userdata stm32_com_t *u = (stm32_com_t*)lua_newuserdata(L, sizeof(stm32_com_t)); @@ -126,6 +130,29 @@ static int l_com_read(lua_State *L) return 1; } +// 方法: COM:ry(filepath) — YMODEM 接收文件 +static int l_com_ry(lua_State *L) +{ + stm32_com_t *u = (stm32_com_t*)luaL_checkudata(L, 1, "stm32.COMMT"); + const char *path = luaL_checkstring(L, 2); + + lua_print("ry: receiving '%s' ...\n", path); + int res = rym_download_file(u->m_ptComCtrl, path); + lua_pushinteger(L, res); + return 1; +} + +// 方法: COM:sy(filepath) — YMODEM 发送文件 +static int l_com_sy(lua_State *L) +{ + stm32_com_t *u = (stm32_com_t*)luaL_checkudata(L, 1, "stm32.COMMT"); + const char *path = luaL_checkstring(L, 2); + + lua_print("sy: sending '%s' ...\n", path); + int res = rym_upload_file(u->m_ptComCtrl, path); + lua_pushinteger(L, res); + return 1; +} // 模块注册 int luaopen_stm32_com(lua_State *L) @@ -140,6 +167,8 @@ int luaopen_stm32_com(lua_State *L) { {"write", l_com_write}, {"read", l_com_read}, + {"ry", l_com_ry}, + {"sy", l_com_sy}, {NULL, NULL} }; const luaL_Reg *l; diff --git a/peripheral/include/ymodem.h b/peripheral/include/ymodem.h new file mode 100644 index 0000000..6fa23e8 --- /dev/null +++ b/peripheral/include/ymodem.h @@ -0,0 +1,142 @@ +/* + * COPYRIGHT (C) 2011-2023, Real-Thread Information Technology Ltd + * All rights reserved + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2013-04-14 Grissiom initial implementation + * 2019-12-09 Steven Liu add YMODEM send protocol + * 2022-08-04 Meco Man move error codes to rym_code to silence warnings + * + * Radkil adapted in 2026: 移除 RT-Thread 依赖, 使用 rd_time 抽象 + */ + +#ifndef __YMODEM_H__ +#define __YMODEM_H__ + +#include +#include +#include "common.h" +#include "rd_time.h" +#include "com.h" + +/* The word "RYM" is stand for "Real-YModem". */ +enum rym_code +{ + RYM_CODE_NONE = 0x00, + RYM_CODE_SOH = 0x01, + RYM_CODE_STX = 0x02, + RYM_CODE_EOT = 0x04, + RYM_CODE_ACK = 0x06, + RYM_CODE_NAK = 0x15, + RYM_CODE_CAN = 0x18, + RYM_CODE_C = 0x43, + + /* RYM error code */ + RYM_ERR_TMO = 0x70, + RYM_ERR_CODE = 0x71, + RYM_ERR_SEQ = 0x72, + RYM_ERR_CRC = 0x73, + RYM_ERR_DSZ = 0x74, + RYM_ERR_CAN = 0x75, + RYM_ERR_ACK = 0x76, + RYM_ERR_FILE = 0x77, +}; + +/* 超时改为毫秒 */ +#ifndef RYM_WAIT_CHR_MS +#define RYM_WAIT_CHR_MS 3000 +#endif +#ifndef RYM_WAIT_PKG_MS +#define RYM_WAIT_PKG_MS 3000 +#endif +#ifndef RYM_CHD_INTV_MS +#define RYM_CHD_INTV_MS 3000 +#endif + +#ifndef RYM_END_SESSION_SEND_CAN_NUM +#define RYM_END_SESSION_SEND_CAN_NUM 0x07 +#endif + +#ifndef RYM_MAX_ERRORS +#define RYM_MAX_ERRORS ((size_t)5) +#endif + +enum rym_stage +{ + RYM_STAGE_NONE = 0, + RYM_STAGE_ESTABLISHING, + RYM_STAGE_ESTABLISHED, + RYM_STAGE_TRANSMITTING, + RYM_STAGE_FINISHING, + RYM_STAGE_FINISHED, +}; + +struct rym_ctx; + +typedef enum rym_code(*rym_callback)(struct rym_ctx *ctx, uint8_t *buf, size_t len); + +/* + * rym_device: 串口设备抽象层 + * + * 使用者提供 read/write/set_rx_indicate 回调, ymodem 协议层不再依赖 + * 任何具体 OS 或驱动框架. + * + * set_rx_indicate(opaque, callback, arg): + * 注册接收通知回调. 当串口收到数据时, 驱动应调用 callback(arg). + * callback 可以为 NULL (取消注册). + */ +typedef struct +{ + /* 读串口: 返回实际读到的字节数, 无数据返回 0 */ + size_t (*read)(void *opaque, uint8_t *buf, size_t len); + /* 写串口: 返回实际写入的字节数 */ + size_t (*write)(void *opaque, const uint8_t *buf, size_t len); + /* 透传指针 (如 TComCtrl*) */ + void *opaque; +} rym_device_t; + +struct rym_ctx +{ + rym_callback on_data; + rym_callback on_begin; + rym_callback on_end; + enum rym_stage stage; + uint8_t *buf; + + rym_device_t dev; +}; + +int rym_recv_on_device(struct rym_ctx *ctx, + rym_device_t *dev, + rym_callback on_begin, + rym_callback on_data, + rym_callback on_end, + int handshake_timeout_sec); + +int rym_send_on_device(struct rym_ctx *ctx, + rym_device_t *dev, + rym_callback on_begin, + rym_callback on_data, + rym_callback on_end, + int handshake_timeout_sec); + +/** + * @brief YMODEM 接收文件 + * @param ptCom 串口 TComCtrl (需已创建且 recv 线程已启动) + * @param file_path 本地保存路径, 如 "C:/fw.bin" + * @return 0 成功, <0 失败 (参见 enum rym_code) + */ +int rym_download_file(TComCtrl *ptCom, const char *file_path); + +/** + * @brief YMODEM 发送文件 + * @param ptCom 串口 TComCtrl + * @param file_path 待发送的本地文件路径 + * @return 0 成功, <0 失败 + */ +int rym_upload_file(TComCtrl *ptCom, const char *file_path); + +#endif \ No newline at end of file diff --git a/peripheral/ry_sy.c b/peripheral/ry_sy.c new file mode 100644 index 0000000..22e39cd --- /dev/null +++ b/peripheral/ry_sy.c @@ -0,0 +1,244 @@ +/* + * Copyright (c) 2019 Fuzhou Rockchip Electronics Co., Ltd + * + * SPDX-License-Identifier: Apache-2.0 + * + * Radkil adapted in 2026: 移除 RT-Thread 依赖, 对接 rd_stdio + TComCtrl + */ + +#include "ymodem.h" +#include "rd_stdio.h" +#include + +#ifndef YMODEM_PATH_MAX +#define YMODEM_PATH_MAX 256 +#endif + +struct custom_ctx +{ + struct rym_ctx parent; + void *fp; /* Rd_Fopen 返回的文件句柄 */ + int flen; /* 剩余待接收字节数 */ + char fpath[YMODEM_PATH_MAX]; +}; + +/* ═══════════════════════════════════════════════════════════════════════ * + * TComCtrl → rym_device_t 桥接 * + * 读: rd_ComRead (内部自带信号量等待, 无协议回调时直接返回原始字节) * + * 写: rd_ComSend * + * 无需额外维护信号量 * + * ═══════════════════════════════════════════════════════════════════════ */ + +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; + + int ret = rd_ComRead(ptCom, (char *)buf, (uint32_t)len); + return (ret > 0) ? (size_t)ret : 0; +} + +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); +} + +static void ymodem_build_device(TComCtrl *ptCom, rym_device_t *dev) +{ + RD_MEMSET(dev, 0, sizeof(*dev)); + dev->read = serial_rym_read; + dev->write = serial_rym_write; + dev->opaque = ptCom; +} + +/* ═══════════════════════════════════════════════════════════════════════ * + * YMODEM 接收回调 (文件写入) * + * ═══════════════════════════════════════════════════════════════════════ */ + +static enum rym_code _rym_recv_begin(struct rym_ctx *ctx, uint8_t *buf, size_t len) +{ + struct custom_ctx *cctx = (struct custom_ctx *)ctx; + char *ret; + + ret = strchr(cctx->fpath, '\0'); + if (ret == NULL) + { + log_w("No end character"); + return RYM_ERR_ACK; + } + *ret = '/'; + RD_STRNCPY(ret + 1, (const char *)buf, len - 1); + ret[1 + len - 1] = '\0'; + + cctx->fp = Rd_Fopen(cctx->fpath, "wb"); + if (cctx->fp == NULL) + { + log_e("error creating file: %s", cctx->fpath); + return RYM_CODE_CAN; + } + + cctx->flen = atoi(1 + (const char *)buf + strnlen((const char *)buf, len - 1)); + if (cctx->flen == 0) + cctx->flen = -1; + + 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; + + if (cctx->fp == NULL) + return RYM_CODE_CAN; + + if (cctx->flen == -1) + { + 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); + cctx->flen -= wlen; + } + + return RYM_CODE_ACK; +} + +static enum rym_code _rym_recv_end(struct rym_ctx *ctx, uint8_t *buf, size_t len) +{ + struct custom_ctx *cctx = (struct custom_ctx *)ctx; + (void)buf; + (void)len; + + if (cctx->fp != NULL) + { + Rd_Mclose(cctx->fp); + cctx->fp = NULL; + } + return RYM_CODE_ACK; +} + +/* ═══════════════════════════════════════════════════════════════════════ * + * YMODEM 发送回调 (文件读取) * + * ═══════════════════════════════════════════════════════════════════════ */ + +static const char *_get_path_lastname(const char *path) +{ + char *ptr = strrchr(path, '/'); + if (ptr == NULL) return path; + return ++ptr; +} + +static enum rym_code _rym_send_begin(struct rym_ctx *ctx, uint8_t *buf, size_t len) +{ + struct custom_ctx *cctx = (struct custom_ctx *)ctx; + + cctx->fp = Rd_Fopen(cctx->fpath, "rb"); + if (cctx->fp == NULL) + { + log_e("error open file: %s", cctx->fpath); + return RYM_ERR_FILE; + } + + Rd_Mseek(cctx->fp, 0, SEEK_END); + long file_size = Rd_Mtell(cctx->fp); + Rd_Mseek(cctx->fp, 0, SEEK_SET); + + RD_MEMSET(buf, 0, len); + const char *fname = _get_path_lastname(cctx->fpath); + RD_SPRINTF((char *)buf, "%s%c%ld", fname, '\0', file_size); + + return RYM_CODE_SOH; +} + +static enum rym_code _rym_send_data(struct rym_ctx *ctx, uint8_t *buf, size_t len) +{ + struct custom_ctx *cctx = (struct custom_ctx *)ctx; + size_t read_size = 0; + int retry; + + for (retry = 0; retry < 10; retry++) + { + ssize_t n = Rd_Mread(buf + read_size, len - read_size, cctx->fp); + if (n > 0) read_size += (size_t)n; + if (read_size == len) break; + } + + if (read_size < len) + { + RD_MEMSET(buf + read_size, 0x1A, len - read_size); + ctx->stage = RYM_STAGE_FINISHING; + } + + return (read_size > 128) ? RYM_CODE_STX : RYM_CODE_SOH; +} + +static enum rym_code _rym_send_end(struct rym_ctx *ctx, uint8_t *buf, size_t len) +{ + struct custom_ctx *cctx = (struct custom_ctx *)ctx; + RD_MEMSET(buf, 0, len); + + if (cctx->fp != NULL) + { + Rd_Mclose(cctx->fp); + cctx->fp = NULL; + } + return RYM_CODE_SOH; +} + +/* ═══════════════════════════════════════════════════════════════════════ * + * 公开 API * + * ═══════════════════════════════════════════════════════════════════════ */ + +int rym_download_file(TComCtrl *ptCom, const char *file_path) +{ + int res; + rym_device_t dev; + + struct custom_ctx *ctx = RD_CALLOC(1, sizeof(*ctx)); + if (!ctx) + { + log_e("RD_MALLOC failed"); + return RD_FAILURE; + } + ctx->fp = NULL; + RD_STRNCPY(ctx->fpath, file_path, YMODEM_PATH_MAX); + + ymodem_build_device(ptCom, &dev); + res = rym_recv_on_device(&ctx->parent, &dev, + _rym_recv_begin, _rym_recv_data, _rym_recv_end, + 10); + + if (ctx->fp != NULL) + Rd_Mclose(ctx->fp); + RD_FREE(ctx); + return res; +} + +int rym_upload_file(TComCtrl *ptCom, const char *file_path) +{ + int res; + rym_device_t dev; + + struct custom_ctx *ctx = RD_CALLOC(1, sizeof(*ctx)); + if (!ctx) + { + log_e("RD_MALLOC failed"); + return RD_FAILURE; + } + ctx->fp = NULL; + RD_STRNCPY(ctx->fpath, file_path, YMODEM_PATH_MAX); + + ymodem_build_device(ptCom, &dev); + res = rym_send_on_device(&ctx->parent, &dev, + _rym_send_begin, _rym_send_data, _rym_send_end, + 10); + + if (ctx->fp != NULL) + Rd_Mclose(ctx->fp); + RD_FREE(ctx); + return res; +} diff --git a/peripheral/ymodem.c b/peripheral/ymodem.c new file mode 100644 index 0000000..9f3a8c0 --- /dev/null +++ b/peripheral/ymodem.c @@ -0,0 +1,560 @@ +/* + * COPYRIGHT (C) 2011-2023, Real-Thread Information Technology Ltd + * All rights reserved + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2013-04-14 Grissiom initial implementation + * 2019-12-09 Steven Liu add YMODEM send protocol + * + * Radkil adapted in 2026: 移除 RT-Thread 依赖, 使用 rd_time/Rd_Delay + */ + +#include "ymodem.h" + +#ifdef YMODEM_USING_CRC_TABLE +static const uint16_t ccitt_table[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 +}; +static uint16_t CRC16(unsigned char *q, int len) +{ + uint16_t crc = 0; + + while (len-- > 0) + crc = (crc << 8) ^ ccitt_table[((crc >> 8) ^ *q++) & 0xff]; + return crc; +} +#else +static uint16_t CRC16(unsigned char *q, int len) +{ + uint16_t crc; + char i; + + crc = 0; + while (--len >= 0) + { + crc = crc ^ (int) * q++ << 8; + i = 8; + do + { + if (crc & 0x8000) + crc = crc << 1 ^ 0x1021; + else + crc = crc << 1; + } + while (--i); + } + + return (crc); +} +#endif + +/* SOH/STX + seq + payload + crc */ +#define _RYM_SOH_PKG_SZ (1+2+128+2) +#define _RYM_STX_PKG_SZ (1+2+1024+2) + +static enum rym_code _rym_read_code(struct rym_ctx *ctx, uint32_t timeout_ms) +{ + uint32_t start = Rd_GetTime(); + while (Rd_GetTime() - start < timeout_ms) + { + size_t rsz = ctx->dev.read(ctx->dev.opaque, ctx->buf, 1); + if (rsz == 1) + return (enum rym_code)(*ctx->buf); + Rd_Delay(1); + } + return RYM_CODE_NONE; +} + +static ssize_t _rym_read_data(struct rym_ctx *ctx, size_t len) +{ + uint8_t *buf = ctx->buf + 1; + size_t readlen = 0; + uint32_t start = Rd_GetTime(); + + 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; + Rd_Delay(1); + } + return readlen; +} + +static int _rym_send_packet(struct rym_ctx *ctx, enum rym_code code, uint8_t index) +{ + uint16_t send_crc; + uint8_t index_inv = ~index; + size_t packetlen = 0; + + switch (code) + { + case RYM_CODE_SOH: + packetlen = _RYM_SOH_PKG_SZ; + break; + case RYM_CODE_STX: + packetlen = _RYM_STX_PKG_SZ; + break; + default: + return RD_FAILURE; + } + + send_crc = CRC16(ctx->buf + 3, packetlen - 5); + ctx->buf[0] = code; + ctx->buf[1] = index; + ctx->buf[2] = index_inv; + ctx->buf[packetlen - 2] = (uint8_t)(send_crc >> 8); + ctx->buf[packetlen - 1] = (uint8_t)send_crc & 0xff; + + size_t writelen = 0; + do + { + size_t n = ctx->dev.write(ctx->dev.opaque, ctx->buf + writelen, packetlen - writelen); + writelen += n; + } + while (writelen < packetlen); + + return RD_SUCCESS; +} + +static void _rym_putchar(struct rym_ctx *ctx, uint8_t code) +{ + ctx->dev.write(ctx->dev.opaque, &code, 1); +} + +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; +} + +static int _rym_do_handshake(struct rym_ctx *ctx, int tm_sec) +{ + enum rym_code code; + size_t i; + uint16_t recv_crc, cal_crc; + size_t data_sz = 0; + uint32_t start, deadline; + + ctx->stage = RYM_STAGE_ESTABLISHING; + for (i = 0; i < (size_t)tm_sec; i++) + { + _rym_putchar(ctx, RYM_CODE_C); + code = _rym_read_code(ctx, RYM_CHD_INTV_MS); + if (code == RYM_CODE_SOH) + { + data_sz = _RYM_SOH_PKG_SZ; + break; + } + else if (code == RYM_CODE_STX) + { + data_sz = _RYM_STX_PKG_SZ; + break; + } + } + 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); + } + + if (i != (data_sz - 1)) + return -RYM_ERR_DSZ; + + if (ctx->buf[1] != 0 || ctx->buf[2] != 0xFF) + 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) + return -RYM_ERR_CRC; + + if (ctx->on_begin && ctx->on_begin(ctx, ctx->buf + 3, data_sz - 5) != RYM_CODE_ACK) + return -RYM_ERR_CAN; + + return RD_SUCCESS; +} + +static int _rym_do_send_handshake(struct rym_ctx *ctx, int tm_sec) +{ + enum rym_code code; + size_t i; + size_t data_sz; + uint8_t getc_ack; + + ctx->stage = RYM_STAGE_ESTABLISHING; + data_sz = _RYM_SOH_PKG_SZ; + + 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 (i == (size_t)tm_sec) + return -RYM_ERR_TMO; + + if (ctx->on_begin && ctx->on_begin(ctx, ctx->buf + 3, data_sz - 5) != RYM_CODE_SOH) + return -RYM_ERR_CODE; + + _rym_send_packet(ctx, RYM_CODE_SOH, 0); + + getc_ack = _rym_getchar(ctx); + if (getc_ack != RYM_CODE_ACK) + return -RYM_ERR_ACK; + + getc_ack = _rym_getchar(ctx); + if (getc_ack != RYM_CODE_C) + return -RYM_ERR_ACK; + + ctx->stage = RYM_STAGE_ESTABLISHED; + return RD_SUCCESS; +} + +static int _rym_trans_data(struct rym_ctx *ctx, size_t data_sz, enum rym_code *code) +{ + const size_t tsz = 2 + data_sz + 2; + uint16_t recv_crc; + + size_t i = _rym_read_data(ctx, tsz); + if (i != tsz) + return -RYM_ERR_DSZ; + + if ((ctx->buf[1] + ctx->buf[2]) != 0xFF) + return -RYM_ERR_SEQ; + + if (ctx->stage == RYM_STAGE_ESTABLISHED && ctx->buf[1] == 0x00) + { + *code = RYM_CODE_NONE; + return RD_SUCCESS; + } + + ctx->stage = RYM_STAGE_TRANSMITTING; + + recv_crc = (uint16_t)(*(ctx->buf + tsz - 1) << 8) | *(ctx->buf + tsz); + if (recv_crc != CRC16(ctx->buf + 3, data_sz)) + return -RYM_ERR_CRC; + + if (ctx->on_data) + *code = ctx->on_data(ctx, ctx->buf + 3, data_sz); + else + *code = RYM_CODE_ACK; + + return RD_SUCCESS; +} + +static int _rym_do_trans(struct rym_ctx *ctx) +{ + _rym_putchar(ctx, RYM_CODE_ACK); + _rym_putchar(ctx, RYM_CODE_C); + ctx->stage = RYM_STAGE_ESTABLISHED; + size_t errors = 0; + + while (1) + { + int err; + enum rym_code code; + size_t data_sz, i; + + code = _rym_read_code(ctx, RYM_WAIT_PKG_MS); + switch (code) + { + case RYM_CODE_SOH: + data_sz = 128; + break; + case RYM_CODE_STX: + data_sz = 1024; + break; + case RYM_CODE_EOT: + return RD_SUCCESS; + default: + errors++; + if (errors > RYM_MAX_ERRORS) + return -RYM_ERR_CODE; + _rym_putchar(ctx, RYM_CODE_NAK); + continue; + } + + err = _rym_trans_data(ctx, data_sz, &code); + if (err != RD_SUCCESS) + { + errors++; + if (errors > RYM_MAX_ERRORS) + return err; + _rym_putchar(ctx, RYM_CODE_NAK); + continue; + } + errors = 0; + + switch (code) + { + case RYM_CODE_CAN: + for (i = 0; i < RYM_END_SESSION_SEND_CAN_NUM; i++) + _rym_putchar(ctx, RYM_CODE_CAN); + return -RYM_ERR_CAN; + case RYM_CODE_ACK: + _rym_putchar(ctx, RYM_CODE_ACK); + break; + default: + break; + } + } +} + +static int _rym_do_send_trans(struct rym_ctx *ctx) +{ + ctx->stage = RYM_STAGE_TRANSMITTING; + enum rym_code code; + uint32_t index = 1; + uint8_t getc_ack; + size_t data_sz = _RYM_STX_PKG_SZ; + + while (1) + { + if (!ctx->on_data) + return -RYM_ERR_CODE; + + code = ctx->on_data(ctx, ctx->buf + 3, data_sz - 5); + _rym_send_packet(ctx, code, index); + index++; + + getc_ack = _rym_getchar(ctx); + if (getc_ack != RYM_CODE_ACK) + return -RYM_ERR_ACK; + + if (ctx->stage == RYM_STAGE_FINISHING) + break; + } + + return RD_SUCCESS; +} + +static int _rym_do_fin(struct rym_ctx *ctx) +{ + enum rym_code code; + uint16_t recv_crc; + size_t i; + size_t data_sz; + + ctx->stage = RYM_STAGE_FINISHING; + if (ctx->on_end) + ctx->on_end(ctx, ctx->buf + 3, 128); + + _rym_putchar(ctx, RYM_CODE_NAK); + code = _rym_read_code(ctx, RYM_WAIT_PKG_MS); + if (code != RYM_CODE_EOT) + return -RYM_ERR_CODE; + + _rym_putchar(ctx, RYM_CODE_ACK); + _rym_putchar(ctx, RYM_CODE_C); + + code = _rym_read_code(ctx, RYM_WAIT_PKG_MS); + if (code == RYM_CODE_SOH) + data_sz = _RYM_SOH_PKG_SZ; + else if (code == RYM_CODE_STX) + data_sz = _RYM_STX_PKG_SZ; + else + return -RYM_ERR_CODE; + + i = _rym_read_data(ctx, data_sz - 1); + if (i != (data_sz - 1)) + return -RYM_ERR_DSZ; + + if (ctx->buf[1] != 0 || ctx->buf[2] != 0xFF) + return -RYM_ERR_SEQ; + + recv_crc = (uint16_t)(*(ctx->buf + data_sz - 2) << 8) | *(ctx->buf + data_sz - 1); + if (recv_crc != CRC16(ctx->buf + 3, data_sz - 5)) + return -RYM_ERR_CRC; + + /* 多文件传输 */ + if (ctx->buf[3] != 0) + { + if (ctx->on_begin && ctx->on_begin(ctx, ctx->buf + 3, data_sz - 5) != RYM_CODE_ACK) + return -RYM_ERR_CAN; + return RD_SUCCESS; + } + + ctx->stage = RYM_STAGE_FINISHED; + _rym_putchar(ctx, RYM_CODE_ACK); + return RD_SUCCESS; +} + +static int _rym_do_send_fin(struct rym_ctx *ctx) +{ + size_t data_sz; + uint8_t index = 0; + 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; + + _rym_putchar(ctx, RYM_CODE_EOT); + getc_ack = _rym_getchar(ctx); + if (getc_ack != RYM_CODE_ACK) + return -RYM_ERR_ACK; + + getc_ack = _rym_getchar(ctx); + if (getc_ack != RYM_CODE_C) + return -RYM_ERR_ACK; + + 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); + ctx->stage = RYM_STAGE_FINISHED; + return RD_SUCCESS; +} + +static int _rym_do_recv(struct rym_ctx *ctx, int handshake_timeout) +{ + int err; + + ctx->stage = RYM_STAGE_NONE; + ctx->buf = RD_MALLOC(_RYM_STX_PKG_SZ); + if (ctx->buf == NULL) + return RD_FAILURE; + + err = _rym_do_handshake(ctx, handshake_timeout); + if (err != RD_SUCCESS) + { + RD_FREE(ctx->buf); + ctx->buf = NULL; + return err; + } + + while (1) + { + err = _rym_do_trans(ctx); + err = _rym_do_fin(ctx); + if (err != RD_SUCCESS) + { + RD_FREE(ctx->buf); + ctx->buf = NULL; + return err; + } + if (ctx->stage == RYM_STAGE_FINISHED) + break; + } + + RD_FREE(ctx->buf); + ctx->buf = NULL; + return err; +} + +static int _rym_do_send(struct rym_ctx *ctx, int handshake_timeout) +{ + int err; + + ctx->stage = RYM_STAGE_NONE; + ctx->buf = RD_MALLOC(_RYM_STX_PKG_SZ); + if (ctx->buf == NULL) + return RD_FAILURE; + + err = _rym_do_send_handshake(ctx, handshake_timeout); + if (err != RD_SUCCESS) goto __exit; + + err = _rym_do_send_trans(ctx); + if (err != RD_SUCCESS) goto __exit; + + err = _rym_do_send_fin(ctx); + +__exit: + RD_FREE(ctx->buf); + ctx->buf = NULL; + return err; +} + +int rym_recv_on_device( + struct rym_ctx *ctx, + rym_device_t *dev, + rym_callback on_begin, + rym_callback on_data, + rym_callback on_end, + int handshake_timeout_sec) +{ + int res; + + RD_MEMSET(ctx, 0, sizeof(*ctx)); + ctx->on_begin = on_begin; + ctx->on_data = on_data; + ctx->on_end = on_end; + RD_MEMCPY(&ctx->dev, dev, sizeof(rym_device_t)); + + res = _rym_do_recv(ctx, handshake_timeout_sec); + + return res; +} + +int rym_send_on_device( + struct rym_ctx *ctx, + rym_device_t *dev, + rym_callback on_begin, + rym_callback on_data, + rym_callback on_end, + int handshake_timeout_sec) +{ + int res; + + RD_MEMSET(ctx, 0, sizeof(*ctx)); + ctx->on_begin = on_begin; + ctx->on_data = on_data; + ctx->on_end = on_end; + RD_MEMCPY(&ctx->dev, dev, sizeof(rym_device_t)); + + res = _rym_do_send(ctx, handshake_timeout_sec); + + return res; +} \ No newline at end of file