refactor: 清理旧YMODEM升级代码,更新版本至V1.1.43

- 删除chrg_comm.h和chrg_def.h中的旧YMODEM状态枚举及注释代码
- 删除chrg_comm.c中已废弃的旧YMODEM重发和会话管理代码
- 更新协议板版本寄存器编码为十进制143
- 新增chrg_ymodem_proxy模块的详细中文注释,明确升级代理职责
- 更新changelog记录V1.1.43版本变更
- 删除无用的Allegro日志文件,优化PCB设计相关文档

本次提交将YMODEM升级功能重构为独立代理模块,不再依赖旧版自动重发逻辑,提升升级流程的可维护性和可靠性。
This commit is contained in:
wrh
2026-09-28 20:51:04 +08:00
parent c34c537bfd
commit 9254c82547
13 changed files with 296 additions and 910 deletions
+3 -738
View File
@@ -27,7 +27,7 @@
#include "stm32f4xx_hal.h"
#define HOLD_REG_FIRMWARE_VERSION 0x0300U /* 协议板固件版本,只读 */
#define CHRG_FIRMWARE_VERSION 0x013AU /* 当前协议板版本:V1.1.42 */
#define CHRG_FIRMWARE_VERSION 143U /* 当前协议板版本:V1.1.43,按十进制版本号编码 */
rt_uint8_t ucDiscInBuf[(TOTAL_DISC_REGS+BITS_UCHAR-1)/BITS_UCHAR];
@@ -38,36 +38,6 @@ rt_uint16_t usRegProBuf[TOTAL_HOLD_ALL_REGS]; //北向protcal???
//rt_uint16_t usRegTestBuf[TOTAL_TEST_REGS];
rt_uint8_t g_proto_pData[80] = {0};//上位机协议指令,控制四个通道;二维
rt_uint16_t g_proto_reqLen = 0;
#if 0 /* 旧YMODEM重发状态机已由chrg_ymodem_proxy替代。 */
rt_uint8_t mobude_ymodem_buf[MB_YMODEM_DATA_SIZE] = {0};//南向功率板升级缓冲区
rt_uint8_t mobude_ymodem_buf_2[MB_YMODEM_DATA_SIZE] = {0};//南向功率板升级缓冲区
#define YMODEM_C_PERIOD_MS 1000
#define YMODEM_META_ACK_TIMEOUT_MS 3000
#define YMODEM_DATA_ACK_TIMEOUT_MS 1000
#define YMODEM_RX_FRAME_TIMEOUT_MS 300
#define YMODEM_MAX_RETRIES 3
/* COM侧升级会话状态:接收缓存负责拼帧,备份缓存负责超时/NAK重发。 */
static rt_uint16_t g_ymodem_rx_len = 0;
static rt_uint16_t g_ymodem_expected_len = 0;
static rt_uint16_t g_ymodem_last_len = 0;
static rt_uint8_t g_ymodem_waiting_ack = 0;
static rt_uint8_t g_ymodem_retry_count = 0;
static rt_uint8_t g_ymodem_eot_done = 0;
static rt_tick_t g_ymodem_send_tick = 0;
static rt_tick_t g_ymodem_c_tick = 0;
static rt_tick_t g_ymodem_rx_tick = 0;
static rt_uint8_t g_ymodem_deferred_resp = 0;
static rt_uint32_t g_ymodem_frame_count = 0;
static rt_uint32_t g_ymodem_send_count = 0;
static const rt_uint8_t g_ymodem_update_frame[8] =
{ID_ELOAD, 0x06, 0x00, 0x0F, 0x00, 0xFF, 0xF8, 0x6B};
static const rt_uint8_t g_ymodem_jump_frame[8] =
{ID_ELOAD, 0x06, 0x00, 0x0F, 0x00, 0x0F, 0xF8, 0x2F};
static void chrg_ymodem_session_stop(void);
#endif
/* Modbus 影子寄存器: 0x06/0x10 写操作暂存到此, PARAM_EFFECT 生效后复制到实际 pNOR->sw */
static struct chrg_switch_t g_shadow_sw[TOTAL_NOR_CHS];
static rt_uint8_t g_shadow_dirty[TOTAL_NOR_CHS] = {0}; /* 0=已生效 1=待生效,防止重复覆盖 */
@@ -422,19 +392,6 @@ eMBErrorCode mb_reg_test_cb (rt_uint8_t *req, rt_uint8_t *pucRegBuffer, rt_uint1
return eStatus;
}
/*****************************************************************
函数名称: mb_ymodem_updata_cb
*****************************************************************/
eMBErrorCode mb_ymodem_updata_cb (rt_uint8_t *state, rt_uint8_t *pucRegBuffer)
{
if ((state == RT_NULL) || (pucRegBuffer == RT_NULL)) {
return MB_EINVAL;
}
/* Ymodem_No的枚举值为0xFF,不能用只覆盖0和1的switch生成响应。 */
pucRegBuffer[0] = (*state == Ymodem_No) ? ACK_C : ACK;
return MB_ENOERR;
}
eMBErrorCode mb_reg_coils_cb (rt_uint8_t *req, rt_uint8_t *pucRegBuffer, rt_uint16_t usAddress,
rt_uint16_t usNCoils, eMBRegisterMode eMode)
{
@@ -1417,227 +1374,6 @@ eMBException funcTrimELoad (rt_uint8_t *reqFrame, rt_uint16_t reqLen,
其它说明: -
*****************************************************************/
#if 0 /* 旧YMODEM时序只作参考,禁止编译和运行。 */
Ymodem_state ystate = Ymodem_No;
rt_uint8_t s_first_soh_rcvd = 0;
/*****************************************************************
函数名称: chrg_ymodem_protocol_reset
函数描述: 清空COM侧Ymodem拼帧、重发和握手状态
输入参数: -
输出参数: -
返回说明: -
其它说明: 不改变南向轮询模式和目标通道
*****************************************************************/
static void chrg_ymodem_protocol_reset(void)
{
rt_memset(mobude_ymodem_buf, 0, sizeof(mobude_ymodem_buf));
rt_memset(mobude_ymodem_buf_2, 0, sizeof(mobude_ymodem_buf_2));
g_ymodem_rx_len = 0;
g_ymodem_expected_len = 0;
g_ymodem_last_len = 0;
g_ymodem_waiting_ack = 0;
g_ymodem_retry_count = 0;
g_ymodem_eot_done = 0;
g_ymodem_send_tick = 0;
g_ymodem_c_tick = rt_tick_get();
g_ymodem_rx_tick = 0;
g_ymodem_deferred_resp = 0;
g_ymodem_frame_count = 0;
g_ymodem_send_count = 0;
s_first_soh_rcvd = 0;
}
static const char *chrg_ymodem_state_name(Ymodem_state state)
{
switch (state) {
case Ymodem_Wait:
return "WAIT";
case Ymodem_Rec_Start:
return "START";
case Ymodem_Rec_1024:
return "DATA";
case Ymodem_Rec_End:
return "EOT";
case Ymodem_Rec_Finish:
return "FINISH";
default:
return "IDLE";
}
}
static const char *chrg_ymodem_resp_name(rt_uint8_t response)
{
switch (response) {
case ACK:
return "ACK";
case NAK:
return "NAK";
case ACK_C:
return "C";
case YM_CAN:
return "CAN";
default:
return "NONE";
}
}
static rt_uint8_t chrg_ymodem_take_south_resp(void)
{
rt_uint8_t resp;
if (g_ymodem_deferred_resp != 0) {
resp = g_ymodem_deferred_resp;
g_ymodem_deferred_resp = 0;
return resp;
}
return chrg_eload_get_ymodem_resp();
}
static int chrg_ymodem_wait_south_ack(rt_uint32_t timeout_ms)
{
rt_tick_t start = rt_tick_get();
rt_uint8_t resp;
while ((rt_tick_t)(rt_tick_get() - start) <
rt_tick_from_millisecond(timeout_ms)) {
resp = chrg_eload_get_ymodem_resp();
if (resp == ACK) {
rt_kprintf("[UPG] south=%s state=%s\r\n",
chrg_ymodem_resp_name(resp), chrg_ymodem_state_name(ystate));
return 0;
}
if (resp == NAK || resp == YM_CAN) {
rt_kprintf("[UPG] south=%s state=%s\r\n",
chrg_ymodem_resp_name(resp), chrg_ymodem_state_name(ystate));
return -2;
}
if (resp != 0 && g_ymodem_deferred_resp == 0) {
g_ymodem_deferred_resp = resp;
}
rt_thread_mdelay(1);
}
return -1;
}
static int chrg_ymodem_send_control_frame(const rt_uint8_t *frame)
{
rt_uint8_t retry;
int wait_result;
const char *control_name = (frame[5] == 0xFF) ? "ENTER" : "JUMP";
rt_kprintf("[UPG] CTRL %s begin\r\n", control_name);
for (retry = 0; retry < YMODEM_MAX_RETRIES; retry++) {
int send_result = chrg_send_sou_upadata_data(frame, 8);
rt_kprintf("[UPG] CTRL %s try=%u tx=%d\r\n",
control_name, (unsigned int)(retry + 1), send_result);
if (send_result == 0) {
wait_result = chrg_ymodem_wait_south_ack(YMODEM_META_ACK_TIMEOUT_MS);
if (wait_result == 0) {
rt_kprintf("[UPG] CTRL %s done\r\n", control_name);
return 0;
}
rt_kprintf("[UPG] CTRL %s wait=%d\r\n", control_name, wait_result);
}
}
rt_kprintf("[UPG] CTRL %s failed\r\n", control_name);
return -1;
}
static void chrg_ymodem_session_stop(void);
/*****************************************************************
函数名称: chrg_ymodem_session_start
函数描述: 停止普通南向请求并进入指定通道的升级透传模式
输入参数: ch:需要升级的南向功率板通道
输出参数: -
返回说明: 0:成功 <0:线程互斥锁未就绪或加锁失败
其它说明: 不修改chrgnorth.enable和chrgsouth.enable,升级结束后恢复自动轮询
*****************************************************************/
static int chrg_ymodem_session_start(eIDX_SOU_CH ch)
{
struct chrg_thread_t *pTHR = &chrgthr[IDX_THR_ROLL_SOU];
struct chrg_rollsou_t *pROLL = &chrgrollsou;
struct chrg_south_t *pSOU = &chrgsouth;
if ((ch >= TOTAL_SOU_CHS) || (pTHR->mutex == RT_NULL)) {
return -1;
}
if (rt_mutex_take(pTHR->mutex, rt_tick_from_millisecond(100)) != RT_EOK) {
return -2;
}
/* 先阻止南向线程继续发普通Modbus请求,等待已发请求退出邮箱等待。 */
pROLL->run = RUN_UPDATA;
pROLL->ch = (rt_uint8_t)ch;
pROLL->send_flag = 0;
pROLL->leng = 0;
pROLL->updata_result = 0;
rt_mutex_release(pTHR->mutex);
rt_thread_mdelay(25);
chrg_eload_clear_ymodem_resp();
if (pSOU->rb != RT_NULL) {
rt_ringbuffer_reset(pSOU->rb);
}
chrg_ymodem_protocol_reset();
rt_mutex_take(pTHR->mutex, RT_WAITING_FOREVER);
pROLL->mode = 1;
pROLL->run = RUN_UPDATA;
pROLL->ch = (rt_uint8_t)ch;
rt_mutex_release(pTHR->mutex);
ystate = Ymodem_Wait;
rt_kprintf("[UPG] START ch=%u mode=%u run=%u state=%s\r\n",
(unsigned int)ch, (unsigned int)pROLL->mode,
(unsigned int)pROLL->run, chrg_ymodem_state_name(ystate));
/* 功率板完成擦除后才返回ACK,并立即开始发送C。 */
if (chrg_ymodem_send_control_frame(g_ymodem_update_frame) != 0) {
chrg_ymodem_session_stop();
return -3;
}
return 0;
}
/*****************************************************************
函数名称: chrg_ymodem_session_stop
函数描述: 退出南向升级透传模式并恢复普通自动轮询
输入参数: -
输出参数: -
返回说明: -
其它说明: 清除残留升级应答,避免其被普通Modbus解析器误识别
*****************************************************************/
static void chrg_ymodem_session_stop(void)
{
struct chrg_thread_t *pTHR = &chrgthr[IDX_THR_ROLL_SOU];
struct chrg_rollsou_t *pROLL = &chrgrollsou;
struct chrg_south_t *pSOU = &chrgsouth;
rt_kprintf("[UPG] STOP state=%s rx_frames=%lu tx_frames=%lu retries=%u eot=%u\r\n",
chrg_ymodem_state_name(ystate),
(unsigned long)g_ymodem_frame_count,
(unsigned long)g_ymodem_send_count,
(unsigned int)g_ymodem_retry_count,
(unsigned int)g_ymodem_eot_done);
if (pTHR->mutex != RT_NULL) {
rt_mutex_take(pTHR->mutex, RT_WAITING_FOREVER);
pROLL->mode = 0;
pROLL->send_flag = 0;
pROLL->leng = 0;
pROLL->updata_result = 0;
pROLL->run = RUN_AUTO;
rt_mutex_release(pTHR->mutex);
}
chrg_eload_clear_ymodem_resp();
if (pSOU->rb != RT_NULL) {
rt_ringbuffer_reset(pSOU->rb);
}
chrg_ymodem_protocol_reset();
ystate = Ymodem_No;
}
#endif
eMBException funYmodemUpadata (rt_uint8_t *reqFrame, rt_uint16_t reqLen,
rt_uint8_t *resFrame, rt_uint16_t *resLen)
@@ -1759,450 +1495,6 @@ static int chrg_comm_parse_msg (struct chrg_comm_t *pCOMM)
return ret;
}
#if 0 /* 旧版协议板自动重发实现,禁止编译。 */
/*
* 旧版Ymodem处理代码保留在下方注释中作为历史参考。当前实现使用完整拼帧、
* CRC校验和停止等待重发机制,不再依赖一次串口接收刚好得到一整帧。
*/
/*****************************************************************
函数名称: chrg_ymodem_frame_size
函数描述: 根据Ymodem控制字符取得一帧应接收的总长度
输入参数: header:Ymodem帧头或控制字符
输出参数: -
返回说明: 133:SOH帧 1029:STX帧 1:EOT/CAN 0:无效字符
其它说明: -
*****************************************************************/
static rt_uint16_t chrg_ymodem_frame_size(rt_uint8_t header)
{
if (header == SOH) {
return YMODEM_SOH_SIZE;
}
if (header == STX) {
return YMODEM_STX_SIZE;
}
if ((header == EOT) || (header == YM_CAN)) {
return 1;
}
return 0;
}
/*****************************************************************
函数名称: chrg_ymodem_crc16
函数描述: 计算Ymodem数据区使用的CRC16-XMODEM校验值
输入参数: data:数据区地址 length:数据区长度
输出参数: -
返回说明: CRC16-XMODEM校验值
其它说明: 初值0,多项式0x1021,结果按高字节在前写入Ymodem帧
*****************************************************************/
static rt_uint16_t chrg_ymodem_crc16(const rt_uint8_t *data, rt_uint16_t length)
{
rt_uint16_t crc = 0;
rt_uint16_t i;
rt_uint8_t bit;
for (i = 0; i < length; i++) {
crc ^= (rt_uint16_t)data[i] << 8;
for (bit = 0; bit < 8; bit++) {
crc = (crc & 0x8000) ? (rt_uint16_t)((crc << 1) ^ 0x1021) :
(rt_uint16_t)(crc << 1);
}
}
return crc;
}
/*****************************************************************
函数名称: chrg_ymodem_frame_valid
函数描述: 校验Ymodem数据帧长度、包号反码和数据区CRC
输入参数: frame:完整Ymodem帧 length:帧总长度
输出参数: -
返回说明: RT_TRUE:有效 RT_FALSE:无效
其它说明: EOT和CAN为单字节控制帧,不包含包号与CRC
*****************************************************************/
static rt_bool_t chrg_ymodem_frame_valid(const rt_uint8_t *frame, rt_uint16_t length)
{
rt_uint16_t data_len;
rt_uint16_t frame_crc;
if ((frame == RT_NULL) || (length != chrg_ymodem_frame_size(frame[0]))) {
return RT_FALSE;
}
if ((frame[0] == EOT) || (frame[0] == YM_CAN)) {
return RT_TRUE;
}
if ((rt_uint8_t)(frame[1] + frame[2]) != 0xFF) {
return RT_FALSE;
}
data_len = (frame[0] == SOH) ? 128 : 1024;
frame_crc = ((rt_uint16_t)frame[length - 2] << 8) | frame[length - 1];
return chrg_ymodem_crc16(&frame[YMODEM_DATA_OFFSET], data_len) == frame_crc;
}
/*****************************************************************
函数名称: chrg_ymodem_resend_last
函数描述: 将最近一次完整Ymodem帧重新提交给南向发送线程
输入参数: -
输出参数: -
返回说明: 0:提交成功 -1:无可重发帧 其它:南向提交错误
其它说明: 仅在NAK或等待应答超时时调用,始终使用原帧实际长度
*****************************************************************/
static int chrg_ymodem_resend_last(void)
{
int ret;
if (g_ymodem_last_len == 0) {
return -1;
}
ret = chrg_send_sou_upadata_data(mobude_ymodem_buf_2, g_ymodem_last_len);
if (ret == 0) {
g_ymodem_send_count++;
g_ymodem_retry_count++;
g_ymodem_send_tick = rt_tick_get();
g_ymodem_waiting_ack = 1;
rt_kprintf("[UPG] RETX south frame=%02X pkt=%u len=%u count=%lu retry=%u state=%s\r\n",
mobude_ymodem_buf_2[0], (unsigned int)mobude_ymodem_buf_2[1],
(unsigned int)g_ymodem_last_len,
(unsigned long)g_ymodem_send_count,
(unsigned int)g_ymodem_retry_count,
chrg_ymodem_state_name(ystate));
}
return ret;
}
/*****************************************************************
函数名称: chrg_ymodem_process
函数描述: 累计COM串口分段数据,形成完整Ymodem帧后提交到南向线程
输入参数: data:本次串口数据 length:本次数据长度
输出参数: -
返回说明: 0:处理完成 -2:仍在等待上一帧应答 -3:帧校验失败 -4:提交失败
其它说明: 一帧可由多次串口接收组成,只有完整且校验通过后才会发送到功率板
*****************************************************************/
static int chrg_ymodem_process(const rt_uint8_t *data, rt_uint16_t length)
{
rt_uint16_t offset = 0;
rt_uint16_t copy_len;
int ret;
if ((data == RT_NULL) || (length == 0)) {
return 0;
}
while (offset < length) {
if (g_ymodem_waiting_ack != 0) {
return -2;
}
if (g_ymodem_expected_len == 0) {
g_ymodem_expected_len = chrg_ymodem_frame_size(data[offset]);
if (g_ymodem_expected_len == 0) {
offset++;
continue;
}
g_ymodem_rx_len = 0;
g_ymodem_rx_tick = rt_tick_get();
}
copy_len = g_ymodem_expected_len - g_ymodem_rx_len;
if (copy_len > (length - offset)) {
copy_len = length - offset;
}
rt_memcpy(&mobude_ymodem_buf[g_ymodem_rx_len], &data[offset], copy_len);
g_ymodem_rx_len += copy_len;
offset += copy_len;
if (g_ymodem_rx_len < g_ymodem_expected_len) {
continue;
}
if (!chrg_ymodem_frame_valid(mobude_ymodem_buf, g_ymodem_rx_len)) {
rt_kprintf("[UPG] RX invalid header=0x%02X pkt=%u len=%u state=%s\r\n",
mobude_ymodem_buf[0], (unsigned int)mobude_ymodem_buf[1],
(unsigned int)g_ymodem_rx_len,
chrg_ymodem_state_name(ystate));
g_ymodem_rx_len = 0;
g_ymodem_expected_len = 0;
g_ymodem_rx_tick = 0;
return -3;
}
g_ymodem_last_len = g_ymodem_rx_len;
rt_memcpy(mobude_ymodem_buf_2, mobude_ymodem_buf, g_ymodem_last_len);
if (mobude_ymodem_buf[0] == SOH) {
if (g_ymodem_eot_done != 0) {
/* 第二次EOT之后的0号空SOH是Ymodem收尾帧,只回复ACK。 */
ystate = Ymodem_Rec_Finish;
} else if ((mobude_ymodem_buf[1] == 0) && (s_first_soh_rcvd == 0)) {
/* 只有传输开始时的0号SOH是文件名/大小帧,需要回复ACK+C。 */
ystate = Ymodem_Rec_Start;
s_first_soh_rcvd = 1;
} else {
/* 包号非0的SOH是普通128字节固件数据帧,只回复ACK。 */
ystate = Ymodem_Rec_1024;
}
} else if (mobude_ymodem_buf[0] == STX) {
ystate = Ymodem_Rec_1024;
} else if (mobude_ymodem_buf[0] == EOT) {
ystate = Ymodem_Rec_End;
} else {
ystate = Ymodem_Rec_Finish;
}
g_ymodem_frame_count++;
rt_kprintf("[UPG] RX frame=%02X pkt=%u len=%u total=%lu state=%s\r\n",
mobude_ymodem_buf[0], (unsigned int)mobude_ymodem_buf[1],
(unsigned int)g_ymodem_last_len,
(unsigned long)g_ymodem_frame_count,
chrg_ymodem_state_name(ystate));
ret = chrg_send_sou_upadata_data(mobude_ymodem_buf_2, g_ymodem_last_len);
g_ymodem_rx_len = 0;
g_ymodem_expected_len = 0;
g_ymodem_rx_tick = 0;
if (ret != 0) {
rt_kprintf("[UPG] TX south failed frame=%02X pkt=%u ret=%d\r\n",
mobude_ymodem_buf_2[0], (unsigned int)mobude_ymodem_buf_2[1], ret);
return -4;
}
g_ymodem_send_count++;
rt_kprintf("[UPG] TX south frame=%02X pkt=%u len=%u count=%lu state=%s\r\n",
mobude_ymodem_buf_2[0], (unsigned int)mobude_ymodem_buf_2[1],
(unsigned int)g_ymodem_last_len,
(unsigned long)g_ymodem_send_count,
chrg_ymodem_state_name(ystate));
g_ymodem_retry_count = 0;
g_ymodem_waiting_ack = 1;
g_ymodem_send_tick = rt_tick_get();
}
return 0;
}
/*****************************************************************
函数名称: ymodem_send
函数描述: 处理南向Ymodem应答、生成上位机应答并执行超时重发
输入参数: pCOMM:COM通信对象
输出参数: pCOMM->tx_buf和pCOMM->tx_len
返回说明: 1:需要向上位机发送数据 0:本轮无数据发送
其它说明: 首包前每秒发送一次C;SOH首包和第二次EOT后按Ymodem规则发送ACK+C
*****************************************************************/
static rt_uint8_t ymodem_send(struct chrg_comm_t *pCOMM)
{
rt_uint8_t south_resp;
rt_uint32_t timeout_ms;
rt_tick_t now;
pCOMM->tx_len = 0;
now = rt_tick_get();
if ((g_ymodem_expected_len != 0) && (g_ymodem_rx_tick != 0) &&
((now - g_ymodem_rx_tick) >=
rt_tick_from_millisecond(YMODEM_RX_FRAME_TIMEOUT_MS))) {
g_ymodem_rx_len = 0;
g_ymodem_expected_len = 0;
g_ymodem_rx_tick = 0;
pCOMM->tx_buf[0] = NAK;
pCOMM->tx_len = 1;
rt_kprintf("[UPG] RX timeout -> NAK state=%s\r\n",
chrg_ymodem_state_name(ystate));
return 1;
}
south_resp = chrg_ymodem_take_south_resp();
if (south_resp == ACK) {
g_ymodem_waiting_ack = 0;
g_ymodem_retry_count = 0;
if (ystate == Ymodem_Rec_Start) {
pCOMM->tx_buf[0] = ACK;
pCOMM->tx_len = 1;
} else if (ystate == Ymodem_Rec_End) {
pCOMM->tx_buf[0] = ACK;
pCOMM->tx_len = 1;
g_ymodem_eot_done = 1;
ystate = Ymodem_Rec_Finish;
} else {
pCOMM->tx_buf[0] = ACK;
pCOMM->tx_len = 1;
}
rt_kprintf("[UPG] SOUTH ACK state=%s retries=%u\r\n",
chrg_ymodem_state_name(ystate), (unsigned int)g_ymodem_retry_count);
return 1;
}
if (south_resp == NAK) {
rt_kprintf("[UPG] SOUTH NAK state=%s retry=%u\r\n",
chrg_ymodem_state_name(ystate), (unsigned int)g_ymodem_retry_count);
if (g_ymodem_retry_count >= YMODEM_MAX_RETRIES) {
pCOMM->tx_buf[0] = YM_CAN;
pCOMM->tx_buf[1] = YM_CAN;
pCOMM->tx_len = 2;
chrg_ymodem_session_stop();
return 1;
}
(void)chrg_ymodem_resend_last();
return 0;
}
if (south_resp == ACK_C) {
rt_kprintf("[UPG] SOUTH C state=%s waiting=%u\r\n",
chrg_ymodem_state_name(ystate), (unsigned int)g_ymodem_waiting_ack);
/* 等待当前帧ACK时忽略功率板周期C,避免打乱上位机停止等待握手。 */
if (g_ymodem_waiting_ack != 0) {
return 0;
}
pCOMM->tx_buf[0] = ACK_C;
pCOMM->tx_len = 1;
return 1;
}
if (south_resp == YM_CAN) {
rt_kprintf("[UPG] SOUTH CAN state=%s\r\n",
chrg_ymodem_state_name(ystate));
pCOMM->tx_buf[0] = YM_CAN;
pCOMM->tx_buf[1] = YM_CAN;
pCOMM->tx_len = 2;
chrg_ymodem_session_stop();
return 1;
}
if (g_ymodem_waiting_ack != 0) {
timeout_ms = (ystate == Ymodem_Rec_Start) ?
YMODEM_META_ACK_TIMEOUT_MS : YMODEM_DATA_ACK_TIMEOUT_MS;
if ((now - g_ymodem_send_tick) >= rt_tick_from_millisecond(timeout_ms)) {
rt_kprintf("[UPG] ACK timeout state=%s retry=%u\r\n",
chrg_ymodem_state_name(ystate),
(unsigned int)g_ymodem_retry_count);
if (g_ymodem_retry_count >= YMODEM_MAX_RETRIES) {
pCOMM->tx_buf[0] = YM_CAN;
pCOMM->tx_buf[1] = YM_CAN;
pCOMM->tx_len = 2;
chrg_ymodem_session_stop();
return 1;
}
(void)chrg_ymodem_resend_last();
}
}
return 0;
}
///*****************************************************************
//函数名称: ymodem_send
//函数描述: 每隔一秒发一次0x43告诉上位机准备数据
//输入参数: pCOMM: 消息结构
//输出参数: -
//返回说明: -
//其它说明: 分命令处理对应消息。地址为广播时不应答
//*****************************************************************/
////返回1:需要发送数据;返回0:无需发送
//uint8_t y_time = 0;
//uint8_t ymodem_send(struct chrg_comm_t *pCOMM,uint8_t state){
//
// struct chrg_rollsou_t *pROLL = &chrgrollsou;
// static rt_uint8_t number = 4;
// uint8_t need_tx = 0;
// if(pROLL->send_flag==0)y_time++;
// pCOMM->tx_len = 0; //每次进来先清空发送长度
// /* ======== 尚未收到上位机第一个数据包: 定时发送'C'握手 ======== */
// if (!s_first_soh_rcvd) {
// if (y_time > 20) {
// pCOMM->tx_buf[0] = ACK_C;
// pCOMM->tx_len = 1;
// need_tx = 1;
// y_time = 0;
// }
// return need_tx;
// }
// if(state == Ymodem_Rec_End){
// //if (y_time > 20) {
// pCOMM->tx_buf[0] = ACK;
// pCOMM->tx_buf[1] = ACK_C;
// pCOMM->tx_len = 2;
// need_tx = 1;
// y_time = 0;
// number--;
// if(number == 0)
// {
// state = Ymodem_Wait;
// number = 4;
// }
// state = Ymodem_Wait;
// //}
// }
// /* ======== 已收到上位机数据包: 南向有应答立刻转发给上位机 ======== */
// uint8_t south_resp = chrg_eload_get_ymodem_resp();
// if (south_resp != 0) {
// switch (south_resp) {
// case ACK:
// memset(mobude_ymodem_buf_2,0,sizeof(mobude_ymodem_buf));
// switch(state){
// case Ymodem_Rec_End:
// case Ymodem_Rec_Start:
// pCOMM->tx_buf[0] = ACK;
// pCOMM->tx_buf[1] = ACK_C;
// pCOMM->tx_len = 2;
// break;
// case Ymodem_Rec_1024:
// pCOMM->tx_buf[0] = ACK;
// pCOMM->tx_len = 1;
// }
// need_tx = 1;
// /* Rec_End收到ACK → 南向已完成2次EOT握手,切到收尾阶段 */
// break;
// case NAK:
// chrg_send_sou_upadata_data(mobude_ymodem_buf_2,1029);
// break;
// default:
// break;
// }
// y_time = 0;
// rt_kprintf("REC DATA = %02x\n",south_resp);
// }
//
// return need_tx;
//}
///*****************************************************************
//函数名称: Ymodem_Process
//函数描述: 处理ymodem协议数据
//输入参数: pCOMM: 消息结构
//输出参数: -
//返回说明: -
//其它说明: 分命令处理对应消息。地址为广播时不应答
//*****************************************************************/
//uint16_t len = 0;
//eMBException Ymodem_Process(rt_uint8_t *reqFrame, rt_uint16_t reqLen,
// rt_uint8_t *resFrame, rt_uint16_t *resLen)
//{
// eMBException eStatus = MB_EX_NONE;
// struct chrg_rollsou_t *pROLL = &chrgrollsou;
// rt_kprintf("TX_LEN = %d\n",reqLen);
//// for(int i=0;i<reqLen;i++){
//// rt_kprintf("%02x ",reqFrame[i]);
//// }
// len = reqLen;
// uint8_t data = reqFrame[0];
// switch(data){
// case SOH:
// memset(mobude_ymodem_buf,0,sizeof(mobude_ymodem_buf));
// ystate = Ymodem_Rec_Start;
// memcpy(mobude_ymodem_buf,reqFrame,reqLen);
// memcpy(mobude_ymodem_buf_2,reqFrame,reqLen);
// chrg_send_sou_upadata_data(mobude_ymodem_buf,reqLen);
// pROLL->send_flag = 1;
// s_first_soh_rcvd = 1;
// break;
// case STX:
// ystate = Ymodem_Rec_1024;
// memset(mobude_ymodem_buf,0,sizeof(mobude_ymodem_buf));
// memcpy(mobude_ymodem_buf,reqFrame,reqLen);
// memcpy(mobude_ymodem_buf_2,reqFrame,reqLen);
// chrg_send_sou_upadata_data(mobude_ymodem_buf,reqLen);
// pROLL->send_flag = 1;
// break;
// case EOT:
// ystate = Ymodem_Rec_End;
// memset(mobude_ymodem_buf,0,sizeof(mobude_ymodem_buf));
// memcpy(mobude_ymodem_buf,reqFrame,reqLen);
// memcpy(mobude_ymodem_buf_2,reqFrame,reqLen);
// chrg_send_sou_upadata_data(mobude_ymodem_buf,reqLen);
// pROLL->send_flag = 1;
// break;
// }
// return eStatus;
//}
#endif
/*****************************************************************
函数名称: chrg_comm_updata_north
函数描述: 解析南向程序数据包
@@ -2214,8 +1506,6 @@ static rt_uint8_t ymodem_send(struct chrg_comm_t *pCOMM)
static int chrg_comm_updata_north (struct chrg_comm_t *pCOMM)
{
int ret = 0;
int process_ret;
rt_uint8_t need_tx;
if (pCOMM == RT_NULL) {
return -1;
@@ -2230,40 +1520,15 @@ static int chrg_comm_updata_north (struct chrg_comm_t *pCOMM)
}
if (pCOMM->rx_len > 0) {
process_ret = chrg_ymodem_proxy_feed_north(pCOMM->rx_buf,
(void)chrg_ymodem_proxy_feed_north(pCOMM->rx_buf,
pCOMM->rx_len);
(void)process_ret;
}
pCOMM->tx_len = chrg_ymodem_proxy_poll(pCOMM->tx_buf,
sizeof(pCOMM->tx_buf));
need_tx = (pCOMM->tx_len > 0U) ? 1U : 0U;
if (need_tx != 0U) {
if (pCOMM->tx_len > 0U) {
ret = chrg_tty_send(pCOMM->tty, pCOMM->tx_buf, pCOMM->tx_len);
}
// uint8_t need_tx = 0;
// pCOMM->tx_len = 0; //进来先清空发送缓冲区
// eMBException eStatus = MB_EX_NONE;
// //收到有效数据才解析Ymodem
// if(pCOMM->rx_len == 8 && pCOMM->rx_buf[1]==0x20){
// eStatus = funYmodemUpadata(pCOMM->rx_buf, pCOMM->rx_len, pCOMM->tx_buf, &pCOMM->tx_len);
// }
// else if(pCOMM->rx_len == 8 && pCOMM->rx_buf[1]==0x06){
// eStatus = funcWriteHoldingRegister(pCOMM->rx_buf, pCOMM->rx_len, pCOMM->tx_buf, &pCOMM->tx_len);
// }
// else if(pCOMM->rx_len != 0){
// rt_kprintf("len = %d\n",pCOMM->rx_len);
// Ymodem_Process(pCOMM->rx_buf, pCOMM->rx_len, pCOMM->tx_buf, &pCOMM->tx_len);
// }
// //统一调用定时应答生成
// need_tx = ymodem_send(pCOMM,ystate);
// //只有标志为1且长度有效才发送
// if(need_tx && pCOMM->tx_len > 0){
// ret = chrg_tty_send(pCOMM->tty, pCOMM->tx_buf, pCOMM->tx_len);
// }
return ret;
}
/*****************************************************************
-10
View File
@@ -172,16 +172,6 @@ struct code_func_t {
#define MB_YMODEM_DATA_SIZE (1029)
////升级协议状态
//typedef enum {
// Ymodem_No = 0,
// Ymodem_Wait,
// Ymodem_Rec_Start,
// Ymodem_Rec_1024,
// Ymodem_Rec_End,
// Ymodem_Rec_Finish
//} Ymodem_state;
#define THR_NAME_COMM "thr.comm"
#define DEV_NAME_COMM "uart1"
+2 -12
View File
@@ -14,8 +14,8 @@
/* CHRG application version. Keep this value synchronized with the changelog. */
#define CHRG_VERSION_MAJOR 1U
#define CHRG_VERSION_MINOR 1U
#define CHRG_VERSION_PATCH 42U
#define CHRG_VERSION_STRING "V1.1.42"
#define CHRG_VERSION_PATCH 43U
#define CHRG_VERSION_STRING "V1.1.43"
/*
* Channel polling mode:
@@ -56,16 +56,6 @@ enum {
};
/* ======================== Ymodem 协议常量 (CRC-16/XMODEM) ======================== */
/* Ymodem 协议状态枚举 */
typedef enum {
Ymodem_No = 0xFF, // 非升级模式
Ymodem_Wait = 0, // 空闲等待,定时发送'C'
Ymodem_Rec_Start, // 收到文件名帧(SOH),待CRC校验
Ymodem_Rec_1024, // 数据帧接收中(SOH=128B / STX=1024B)
Ymodem_Rec_End, // 收到EOT,传输结束握手
Ymodem_Rec_Finish // 升级完成,准备收尾
} Ymodem_state;
/* Ymodem 协议控制字符 */
#define SOH 0x01 // 128字节数据包帧头
#define STX 0x02 // 1024字节数据包帧头
@@ -1,3 +1,8 @@
/*
* 功率板YMODEM升级代理。
* 北向负责拼帧和本地校验,南向应答原样转发给PC;
* 本模块不自动重发数据帧或EOT,重发决策统一由PC执行。
*/
#include <string.h>
#include <rtthread.h>
@@ -11,27 +16,27 @@
#define LOG_TAG "chrg.upgrade"
#include <rtdbg.h>
#define YMODEM_RX_FRAME_TIMEOUT_MS 1000U
#define YMODEM_SESSION_IDLE_MS 15000U
#define YMODEM_ENTER_TIMEOUT_MS 15000U
#define YMODEM_RESPONSE_TIMEOUT_MS 10000U
#define YMODEM_RX_FRAME_TIMEOUT_MS 1000U // PC分段数据拼帧超时
#define YMODEM_SESSION_IDLE_MS 15000U // 整个升级会话无有效数据超时
#define YMODEM_ENTER_TIMEOUT_MS 15000U // 功率板进入Boot及擦除等待时间
#define YMODEM_RESPONSE_TIMEOUT_MS 10000U // 南向单帧应答等待时间
typedef struct {
chrg_ymodem_proxy_state_t state;
rt_uint8_t ch;
rt_uint8_t expected_packet;
rt_uint8_t current_packet;
rt_uint8_t meta_ack_seen;
rt_uint8_t eot2_ack_seen;
rt_uint8_t deferred_c;
rt_uint16_t rx_len;
rt_uint16_t expected_len;
rt_tick_t rx_tick;
rt_tick_t response_tick;
rt_tick_t activity_tick;
rt_uint8_t rx_buf[YMODEM_STX_SIZE];
rt_uint8_t north_pending[2];
rt_uint8_t north_pending_len;
chrg_ymodem_proxy_state_t state; // 当前升级阶段
rt_uint8_t ch; // 被锁定的南向功率板通道
rt_uint8_t expected_packet; // PC下一帧应使用的包号
rt_uint8_t current_packet; // 当前已转发帧的包号,仅用于日志
rt_uint8_t meta_ack_seen; // 元数据ACK已收到,后续才接受'C'
rt_uint8_t eot2_ack_seen; // 第二个EOT的ACK已收到
rt_uint8_t deferred_c; // 进入Boot时与ACK同批到达的'C'延后转发
rt_uint16_t rx_len; // 北向当前已拼接字节数
rt_uint16_t expected_len; // 根据SOH/STX计算的完整帧长度
rt_tick_t rx_tick; // 当前半帧起始时间
rt_tick_t response_tick; // 最近一帧提交南向的时间
rt_tick_t activity_tick; // 最近一次有效会话活动时间
rt_uint8_t rx_buf[YMODEM_STX_SIZE]; // 北向最大STX帧拼帧缓冲区
rt_uint8_t north_pending[2]; // 待转发给PC的单字节或CAN CAN
rt_uint8_t north_pending_len; // 北向待发应答长度
} chrg_ymodem_proxy_t;
static chrg_ymodem_proxy_t g_proxy = {
@@ -39,6 +44,7 @@ static chrg_ymodem_proxy_t g_proxy = {
.ch = 0xFFU
};
/* 功率板进入Boot和跳转App的固定Modbus控制帧。 */
static const rt_uint8_t g_enter_frame[8] =
{ID_ELOAD, 0x06, 0x00, 0x0F, 0x00, 0xFF, 0xF8, 0x6B};
static const rt_uint8_t g_exit_frame[8] =
@@ -62,7 +68,6 @@ static const char *chrg_ymodem_proxy_state_name(chrg_ymodem_proxy_state_t state)
case YMODEM_PROXY_WAIT_END_ACK: return "END_ACK";
case YMODEM_PROXY_TRANSFER_DONE: return "DONE";
case YMODEM_PROXY_EXITING: return "EXITING";
case YMODEM_PROXY_VERIFY: return "VERIFY";
default: return "ABORT";
}
}
@@ -171,6 +176,7 @@ static rt_bool_t chrg_ymodem_frame_valid(const rt_uint8_t *frame,
frame_crc) ? RT_TRUE : RT_FALSE;
}
/* 元数据必须是包号0的SOH,文件名以.upk结尾,文件长度为十进制数字。 */
static rt_bool_t chrg_ymodem_metadata_valid(const rt_uint8_t *frame)
{
const rt_uint8_t *data = &frame[YMODEM_DATA_OFFSET];
@@ -192,6 +198,7 @@ static rt_bool_t chrg_ymodem_metadata_valid(const rt_uint8_t *frame)
return digit_seen;
}
/* YMODEM收尾帧必须是包号0的SOH,且数据区128字节全为0。 */
static rt_bool_t chrg_ymodem_end_soh_valid(const rt_uint8_t *frame)
{
rt_uint16_t i;
@@ -202,6 +209,7 @@ static rt_bool_t chrg_ymodem_end_soh_valid(const rt_uint8_t *frame)
return RT_TRUE;
}
/* 向南向线程只提交一次帧,成功后进入真实应答等待状态。 */
static int chrg_ymodem_proxy_submit_frame(const rt_uint8_t *frame,
rt_uint16_t length, chrg_ymodem_proxy_state_t next_state)
{
@@ -217,6 +225,7 @@ static int chrg_ymodem_proxy_submit_frame(const rt_uint8_t *frame,
return 0;
}
/* 锁定南向物理通道,停止普通Modbus轮询并清理历史应答。 */
static int chrg_ymodem_proxy_prepare_channel(rt_uint8_t ch)
{
struct chrg_thread_t *thread = &chrgthr[IDX_THR_ROLL_SOU];
@@ -238,6 +247,13 @@ static int chrg_ymodem_proxy_prepare_channel(rt_uint8_t ch)
return 0;
}
/*****************************************************************
函数名称: chrg_ymodem_proxy_enter
函数描述: 进入指定功率板的Boot升级模式
输入参数: ch:南向通道编号
返回说明: 0:收到功率板ACK <0:进入失败
其它说明: 仅在真实ACK到达后允许COM回复PC成功
*****************************************************************/
int chrg_ymodem_proxy_enter(rt_uint8_t ch)
{
rt_tick_t start;
@@ -270,6 +286,13 @@ int chrg_ymodem_proxy_enter(rt_uint8_t ch)
return -4;
}
/*****************************************************************
函数名称: chrg_ymodem_proxy_exit
函数描述: 跳转功率板App并恢复普通南向轮询
输入参数: ch:当前升级通道
返回说明: 0:收到跳转ACK <0:状态或通信失败
其它说明: 仅TRANSFER_DONE状态可退出,退出后强制刷新版本
*****************************************************************/
int chrg_ymodem_proxy_exit(rt_uint8_t ch)
{
rt_tick_t start;
@@ -297,6 +320,7 @@ int chrg_ymodem_proxy_exit(rt_uint8_t ch)
return -3;
}
/* 根据当前阶段校验完整帧,校验成功才允许提交南向。 */
static int chrg_ymodem_proxy_handle_frame(const rt_uint8_t *frame,
rt_uint16_t length)
{
@@ -344,6 +368,13 @@ static int chrg_ymodem_proxy_handle_frame(const rt_uint8_t *frame,
return -2;
}
/*****************************************************************
函数名称: chrg_ymodem_proxy_feed_north
函数描述: 接收PC分段数据并拼成完整YMODEM帧
输入参数: data:本次北向数据 length:数据长度
返回说明: 0:已接收或提交 <0:状态、帧或提交错误
其它说明: 等待南向应答时拒绝下一帧;CAN在任意阶段优先处理
*****************************************************************/
int chrg_ymodem_proxy_feed_north(const rt_uint8_t *data,
rt_uint16_t length)
{
@@ -394,6 +425,7 @@ int chrg_ymodem_proxy_feed_north(const rt_uint8_t *data,
return 0;
}
/* 仅按当前状态接受功率板ACK/NAK/C/CAN,不伪造成功应答。 */
static void chrg_ymodem_proxy_handle_south(rt_uint8_t response)
{
g_proxy.activity_tick = rt_tick_get();
@@ -468,6 +500,13 @@ static void chrg_ymodem_proxy_handle_south(rt_uint8_t response)
}
}
/*****************************************************************
函数名称: chrg_ymodem_proxy_poll
函数描述: 推进南向应答、半帧超时、单帧超时和会话空闲超时
输入参数: output:北向待发缓冲区 capacity:缓冲区容量
返回说明: 0:无待发数据 >0:需要发给PC的字节数
其它说明: 超时只取消会话,不自动重发已可能写入Flash的帧
*****************************************************************/
rt_uint16_t chrg_ymodem_proxy_poll(rt_uint8_t *output,
rt_uint16_t capacity)
{
@@ -523,18 +562,3 @@ rt_uint16_t chrg_ymodem_proxy_poll(rt_uint8_t *output,
g_proxy.north_pending_len = 0U;
return length;
}
rt_bool_t chrg_ymodem_proxy_active(void)
{
return (g_proxy.state != YMODEM_PROXY_IDLE) ? RT_TRUE : RT_FALSE;
}
rt_uint8_t chrg_ymodem_proxy_channel(void)
{
return g_proxy.ch;
}
chrg_ymodem_proxy_state_t chrg_ymodem_proxy_state(void)
{
return g_proxy.state;
}
@@ -1,35 +1,39 @@
/*
* 功率板YMODEM升级代理接口。
* PC负责重发和包号推进,协议板只校验、转发并透传功率板应答。
*/
#ifndef __CHRG_YMODEM_PROXY_H__
#define __CHRG_YMODEM_PROXY_H__
#include <rtthread.h>
typedef enum {
YMODEM_PROXY_IDLE = 0,
YMODEM_PROXY_ENTERING,
YMODEM_PROXY_WAIT_C,
YMODEM_PROXY_WAIT_META,
YMODEM_PROXY_WAIT_META_RESP,
YMODEM_PROXY_WAIT_DATA,
YMODEM_PROXY_WAIT_DATA_RESP,
YMODEM_PROXY_WAIT_EOT1_RESP,
YMODEM_PROXY_WAIT_EOT2,
YMODEM_PROXY_WAIT_EOT2_RESP,
YMODEM_PROXY_WAIT_END_SOH,
YMODEM_PROXY_WAIT_END_ACK,
YMODEM_PROXY_TRANSFER_DONE,
YMODEM_PROXY_EXITING,
YMODEM_PROXY_VERIFY,
YMODEM_PROXY_ABORT
YMODEM_PROXY_IDLE = 0, // 未进入升级模式
YMODEM_PROXY_ENTERING, // 已发送进入Boot控制帧,等待ACK
YMODEM_PROXY_WAIT_C, // 进入Boot成功,等待功率板'C'
YMODEM_PROXY_WAIT_META, // 等待PC发送包号0元数据SOH
YMODEM_PROXY_WAIT_META_RESP, // 元数据已转发,等待南向ACK和'C'
YMODEM_PROXY_WAIT_DATA, // 等待PC发送下一个数据包或首个EOT
YMODEM_PROXY_WAIT_DATA_RESP, // 数据包已转发,等待南向ACK/NAK
YMODEM_PROXY_WAIT_EOT1_RESP, // 第一个EOT已转发,等待南向NAK
YMODEM_PROXY_WAIT_EOT2, // 等待PC发送第二个EOT
YMODEM_PROXY_WAIT_EOT2_RESP, // 第二个EOT已转发,等待ACK和'C'
YMODEM_PROXY_WAIT_END_SOH, // 等待包号0且数据全零的结束SOH
YMODEM_PROXY_WAIT_END_ACK, // 结束SOH已转发,等待南向ACK
YMODEM_PROXY_TRANSFER_DONE, // YMODEM传输完成,等待0x20退出命令
YMODEM_PROXY_EXITING, // 已发送跳转App控制帧,等待ACK
YMODEM_PROXY_ABORT // 异常取消,等待CAN发送完成
} chrg_ymodem_proxy_state_t;
/* 锁定目标通道并进入功率板Boot,收到真实ACK后才返回成功。 */
extern int chrg_ymodem_proxy_enter(rt_uint8_t ch);
/* 仅传输完成后允许跳转App,收到ACK后恢复普通轮询。 */
extern int chrg_ymodem_proxy_exit(rt_uint8_t ch);
/* 累计PC分段数据,形成完整YMODEM帧后校验并提交南向。 */
extern int chrg_ymodem_proxy_feed_north(const rt_uint8_t *data,
rt_uint16_t length);
/* 推进南向应答和超时状态,返回待发给PC的ACK/NAK/C/CAN。 */
extern rt_uint16_t chrg_ymodem_proxy_poll(rt_uint8_t *output,
rt_uint16_t capacity);
extern rt_bool_t chrg_ymodem_proxy_active(void);
extern rt_uint8_t chrg_ymodem_proxy_channel(void);
extern chrg_ymodem_proxy_state_t chrg_ymodem_proxy_state(void);
#endif
Binary file not shown.