LiZongdi
/
robot
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

【待测试】移植ymodem

master
Lizongdi 2 hours ago
parent
c7d5b67741
commit
ffbbf79f41
5 changed files with 983 additions and 3 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 7
      RBcore/drv_interface.c
  2. 33
      bspMCU/l_uart.c
  3. 142
      peripheral/include/ymodem.h
  4. 244
      peripheral/ry_sy.c
  5. 560
      peripheral/ymodem.c

7
RBcore/drv_interface.c
View File

@ -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)

33
bspMCU/l_uart.c
View File

@ -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;

142
peripheral/include/ymodem.h
View File

@ -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 <string.h>
#include <stdint.h>
#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

244
peripheral/ry_sy.c
View File

@ -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 <stdlib.h>
#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;
}

560
peripheral/ymodem.c
View File

@ -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;
}
Write Preview
Loading…
Cancel
Save