yhf/chrg
1
0
Fork 0
forked from chrg/chrg
Code Pull Requests Activity

chore: 发布V1.1.26版本，修复Sink角色切换初始化残留问题

Browse Source 
1. 更新所有文件版本号至V1.1.26，同步固件版本寄存器值
2. 修复Sink角色往返时初始化上下文残留问题，切换回Sink时重新执行完整初始化
3. 优化Sink配置生效逻辑，同角色仅复制PC可写配置，保留运行状态
4. 增加初始化阶段入队标记，避免沿用旧成功结果跳过未执行命令
5. 停止入队失败时由北向轮询重试，不依赖On_work或通道使能
6. 新增Sink初始化回归测试套件，覆盖14种场景验证流程正确性
This commit is contained in:
yhf
2026-09-17 12:01:50 +08:00
parent 9f63dfeaf5
commit c8bfef090a
11 changed files with 489 additions and 33 deletions
Download Patch File Download Diff File Expand all files Collapse all files
apps/chrg/applications/thread/chrg_comm.c
+90 -13
View File
@@ -1,7 +1,7 @@
/**************************************************************************** /****************************************************************************
文件名称 : chrg_comm.c 文件名称 : chrg_comm.c
完成日期 : 完成日期 :
当前版本号 : V1.1.24 当前版本号 : V1.1.26
主要功能 : 实现对外通讯协议 MODBUS 服务端，以独立线程等待处理响应请求数据。 主要功能 : 实现对外通讯协议 MODBUS 服务端，以独立线程等待处理响应请求数据。
版本历史 : 创建原始版本 版本历史 : 创建原始版本
说明 : 说明 :
@@ -2547,13 +2547,62 @@ static void chrg_comm_get_param_diff(eIDX_ID role,
} }
} }
/*****************************************************************
函数名称： chrg_comm_sink_config_equal
函数描述： 只比较PC可写配置，忽略影子区中过期的状态机和量测快照
其它说明： 测试参数子结构仅包含配置；test_mode_old及执行步骤不参与比较
*****************************************************************/
static rt_bool_t chrg_comm_sink_config_equal(const struct chrg_switch_t *a,
const struct chrg_switch_t *b)
{
return (a->CV_mode == b->CV_mode) && (a->protoCmd == b->protoCmd) &&
(a->sink.protocol == b->sink.protocol) &&
(a->sink.Pro_Group == b->sink.Pro_Group) &&
(a->sink.pro_loadv == b->sink.pro_loadv) &&
(a->sink.pro_loadc == b->sink.pro_loadc) &&
(a->sink.cc_set == b->sink.cc_set) &&
(a->sink.loadv == b->sink.loadv) && (a->sink.loadc == b->sink.loadc) &&
(a->sink.volt_on == b->sink.volt_on) &&
(a->sink.Now_State == b->sink.Now_State) &&
(a->sink.test.test_mode == b->sink.test.test_mode) &&
(a->sink.test.short_test.hold_time == b->sink.test.short_test.hold_time) &&
(a->sink.test.short_test.set_mode == b->sink.test.short_test.set_mode) &&
(a->sink.test.short_test.have_curr_flag == b->sink.test.short_test.have_curr_flag) &&
(rt_memcmp(&a->sink.test.OCP_test, &b->sink.test.OCP_test,
sizeof(a->sink.test.OCP_test)) == 0) &&
(rt_memcmp(&a->sink.test.change_test, &b->sink.test.change_test,
sizeof(a->sink.test.change_test)) == 0);
}
/*****************************************************************
函数名称： chrg_comm_copy_sink_config
函数描述： 将PC配置逐项应用到Sink，保留实际运行状态、旧测试模式和量测
其它说明： 禁止复制整个switch/sink/test，避免覆盖初始化及回码推进结果
*****************************************************************/
static void chrg_comm_copy_sink_config(struct chrg_switch_t *pReal,
const struct chrg_switch_t *pShadow)
{
pReal->CV_mode = pShadow->CV_mode;
pReal->protoCmd = pShadow->protoCmd;
pReal->sink.protocol = pShadow->sink.protocol;
pReal->sink.Pro_Group = pShadow->sink.Pro_Group;
pReal->sink.pro_loadv = pShadow->sink.pro_loadv;
pReal->sink.pro_loadc = pShadow->sink.pro_loadc;
pReal->sink.cc_set = pShadow->sink.cc_set;
pReal->sink.loadv = pShadow->sink.loadv;
pReal->sink.loadc = pShadow->sink.loadc;
pReal->sink.volt_on = pShadow->sink.volt_on;
pReal->sink.Now_State = pShadow->sink.Now_State;
pReal->sink.test.test_mode = pShadow->sink.test.test_mode;
pReal->sink.test.short_test = pShadow->sink.test.short_test;
pReal->sink.test.OCP_test = pShadow->sink.test.OCP_test;
pReal->sink.test.change_test = pShadow->sink.test.change_test;
}
/***************************************************************** /*****************************************************************
函数名称： chrg_comm_apply_sink_effect 函数名称： chrg_comm_apply_sink_effect
函数描述： 处理COM参数生效后的同角色负载启停、测试和差异更新 函数描述： 应用同角色负载配置；相同初始化请求继续等待，不取消退出Short批次
输入参数： ch:通道 pReal:运行参数 pShadow:待生效影子参数 返回说明： 初始化期间不同配置返回忙，PC需重试；停止请求不受此限制
输出参数： 更新pReal并按需提交南向命令
返回说明： MB_EX_NONE:成功 MB_EX_SLAVE_BUSY:命令提交失败
其它说明： 角色切换不在本函数处理，由chrg_mb_write_sys统一调度
*****************************************************************/ *****************************************************************/
static eMBException chrg_comm_apply_sink_effect(rt_uint8_t ch, static eMBException chrg_comm_apply_sink_effect(rt_uint8_t ch,
struct chrg_switch_t *pReal, const struct chrg_switch_t *pShadow) struct chrg_switch_t *pReal, const struct chrg_switch_t *pShadow)
@@ -2574,6 +2623,25 @@ static eMBException chrg_comm_apply_sink_effect(rt_uint8_t ch,
rt_uint16_t sink_work = pShadow->sink.Now_State; rt_uint16_t sink_work = pShadow->sink.Now_State;
chrg_param_diff_t diff_info; chrg_param_diff_t diff_info;
/* 初始化是一个完整事务。相同运行请求只推进原事务；不同参数必须
* 等待完成后重试，禁止先部分应用新配置或清掉尚未确认的退出命令。 */
if ((sink_work == 0x01) &&
((old_work_mode == SINK_WORK_INIT) ||
(old_work_mode == SINK_WORK_INIT_AUX_WAIT))) {
if (!chrg_comm_sink_config_equal(pReal, pShadow)) {
return MB_EX_SLAVE_BUSY;
}
return (chrg_sink_work((eIDX_SOU_CH)ch, pReal) == 0) ?
MB_EX_NONE : MB_EX_SLAVE_BUSY;
}
/* 未完成安全停止前不能用新运行请求打断停止批次。 */
if ((sink_work == 0x01) &&
((old_work_mode == SINK_WORK_STOP) ||
(old_work_mode == SINK_WORK_STOP_WAIT) ||
(old_work_mode == SINK_WORK_STOP_RELAY) ||
(old_work_mode == SINK_WORK_STOP_RELAY_WAIT))) {
return MB_EX_SLAVE_BUSY;
}
chrg_comm_get_param_diff(ID_SINK, pReal, pShadow, &diff_info); chrg_comm_get_param_diff(ID_SINK, pReal, pShadow, &diff_info);
/* /*
* 协议类型、CC和协议组号变化需要完整握手；协议电压和协议电流 * 协议类型、CC和协议组号变化需要完整握手；协议电压和协议电流
@@ -2605,7 +2673,7 @@ static eMBException chrg_comm_apply_sink_effect(rt_uint8_t ch,
return MB_EX_SLAVE_BUSY; return MB_EX_SLAVE_BUSY;
} }
} }
rt_memcpy(pReal, pShadow, sizeof(struct chrg_switch_t)); chrg_comm_copy_sink_config(pReal, pShadow);
if (sink_work == 0x01) { if (sink_work == 0x01) {
curr_test = pReal->sink.test.test_mode; curr_test = pReal->sink.test.test_mode;
@@ -2934,6 +3002,9 @@ static eMBException chrg_mb_write_sys(rt_uint8_t ch, rt_uint16_t reg_offset,
struct chrg_thread_t *pTHR_NOR; struct chrg_thread_t *pTHR_NOR;
eIDX_ID old_id; eIDX_ID old_id;
eIDX_ID new_id; eIDX_ID new_id;
rt_bool_t sink_config_changed;
rt_uint8_t old_sink_sub;
rt_uint8_t old_sink_on;
int switch_ret; int switch_ret;
(void)pSOU; (void)pSOU;
@@ -2956,13 +3027,8 @@ static eMBException chrg_mb_write_sys(rt_uint8_t ch, rt_uint16_t reg_offset,
old_id = pReal->id; old_id = pReal->id;
new_id = pSW->id; new_id = pSW->id;
g_shadow_dirty[ch] = 0; g_shadow_dirty[ch] = 0;
/*
* 使每次COM参数生效拥有独立版本。北向线程等待回码期间如果版本变化，
* 必须放弃旧请求，防止旧回码把新配置的sub错误推进到下一步。
*/
pNOR->config_version[ch]++;
if (old_id != new_id) { if (old_id != new_id) {
pNOR->config_version[ch]++;
/* 角色切换时清除旧Source协议切换的等待上下文。 */ /* 角色切换时清除旧Source协议切换的等待上下文。 */
chrg_roll_nor_source_switch_reset(ch); chrg_roll_nor_source_switch_reset(ch);
rt_memcpy(pReal, pSW, sizeof(struct chrg_switch_t)); rt_memcpy(pReal, pSW, sizeof(struct chrg_switch_t));
@@ -2977,8 +3043,19 @@ static eMBException chrg_mb_write_sys(rt_uint8_t ch, rt_uint16_t reg_offset,
} }
status = (switch_ret == 0) ? MB_EX_NONE : MB_EX_SLAVE_BUSY; status = (switch_ret == 0) ? MB_EX_NONE : MB_EX_SLAVE_BUSY;
} else if (new_id == ID_SINK) { } else if (new_id == ID_SINK) {
sink_config_changed = !chrg_comm_sink_config_equal(pReal, pSW);
old_sink_sub = pReal->sub;
old_sink_on = pReal->sink.On_work;
status = chrg_comm_apply_sink_effect(ch, pReal, pSW); status = chrg_comm_apply_sink_effect(ch, pReal, pSW);
/* 重复请求或初始化期间被拒绝的新配置不能作废正在等待的北向
* 回码；只有配置确实应用或控制入口改变时才递增版本。
* 即使南向暂时入队失败，已接受的新配置也必须隔离旧回码。 */
if ((sink_config_changed && chrg_comm_sink_config_equal(pReal, pSW)) ||
(old_sink_sub != pReal->sub) || (old_sink_on != pReal->sink.On_work)) {
pNOR->config_version[ch]++;
}
} else { } else {
pNOR->config_version[ch]++;
status = chrg_comm_apply_source_effect(ch, pReal, pSW); status = chrg_comm_apply_source_effect(ch, pReal, pSW);
} }
apps/chrg/applications/thread/chrg_roll_nor.c
+3 -1
View File
@@ -1,7 +1,7 @@
/**************************************************************************** /****************************************************************************
文件名称 : chrg_roll_nor.c 文件名称 : chrg_roll_nor.c
完成日期 : 完成日期 :
当前版本号 : V1.1.24 当前版本号 : V1.1.26
主要功能 : 实现北向通信轮巡请求命令。以独立线程处理。 主要功能 : 实现北向通信轮巡请求命令。以独立线程处理。
版本历史 : 创建原始版本 版本历史 : 创建原始版本
说明 : 说明 :
@@ -1016,6 +1016,8 @@ void chrg_roll_nor_thread_entry (void *data)
} else if ((pSW->id == ID_SINK) && } else if ((pSW->id == ID_SINK) &&
((pSW->sink.work_mode == SINK_WORK_INIT) || ((pSW->sink.work_mode == SINK_WORK_INIT) ||
(pSW->sink.work_mode == SINK_WORK_INIT_AUX_WAIT) || (pSW->sink.work_mode == SINK_WORK_INIT_AUX_WAIT) ||
/* STOP入队失败时On_work已清零，必须在使能过滤前继续重试。 */
(pSW->sink.work_mode == SINK_WORK_STOP) ||
(pSW->sink.work_mode == SINK_WORK_UNLOAD_WAIT) || (pSW->sink.work_mode == SINK_WORK_UNLOAD_WAIT) ||
(pSW->sink.work_mode == SINK_WORK_LOW) || (pSW->sink.work_mode == SINK_WORK_LOW) ||
(pSW->sink.work_mode == SINK_WORK_LOW_AUX_WAIT) || (pSW->sink.work_mode == SINK_WORK_LOW_AUX_WAIT) ||
apps/chrg/applications/utils/chrg_def.h
+3 -3
View File
@@ -1,7 +1,7 @@
/**************************************************************************** /****************************************************************************
文件名称 : chrg_def.h 文件名称 : chrg_def.h
完成日期 : 完成日期 :
当前版本号 : V1.1.24 当前版本号 : V1.1.26
主要功能 : 全局宏定义，常量，及结构体。 主要功能 : 全局宏定义，常量，及结构体。
版本历史 : 创建原始版本 版本历史 : 创建原始版本
说明 : 说明 :
@@ -15,8 +15,8 @@
/* CHRG application version. Keep this value synchronized with the changelog. */ /* CHRG application version. Keep this value synchronized with the changelog. */
#define CHRG_VERSION_MAJOR 1U #define CHRG_VERSION_MAJOR 1U
#define CHRG_VERSION_MINOR 1U #define CHRG_VERSION_MINOR 1U
#define CHRG_VERSION_PATCH 24U #define CHRG_VERSION_PATCH 26U
#define CHRG_VERSION_STRING "V1.1.24" #define CHRG_VERSION_STRING "V1.1.26"
/* Modbus version encoding: major<<8 + minor<<4 + patch. */ /* Modbus version encoding: major<<8 + minor<<4 + patch. */
#define CHRG_FIRMWARE_VERSION ((CHRG_VERSION_MAJOR << 8) + \ #define CHRG_FIRMWARE_VERSION ((CHRG_VERSION_MAJOR << 8) + \
(CHRG_VERSION_MINOR << 4) + CHRG_VERSION_PATCH) (CHRG_VERSION_MINOR << 4) + CHRG_VERSION_PATCH)
apps/chrg/applications/utils/chrg_sink.c
+34 -16
View File
@@ -1,7 +1,7 @@
/**************************************************************************** /****************************************************************************
文件名称 : chrg_sink.c 文件名称 : chrg_sink.c
完成日期 : 完成日期 :
当前版本号 : V1.1.24 当前版本号 : V1.1.26
主要功能 : 北向数据sink请求数据填充及发送。 主要功能 : 北向数据sink请求数据填充及发送。
版本历史 : 创建原始版本 版本历史 : 创建原始版本
说明 : 说明 :
@@ -34,6 +34,8 @@
static rt_uint8_t g_sink_init_stage[TOTAL_SOU_CHS] = {0}; static rt_uint8_t g_sink_init_stage[TOTAL_SOU_CHS] = {0};
static rt_tick_t g_sink_init_north_relay_tick[TOTAL_SOU_CHS] = {0}; static rt_tick_t g_sink_init_north_relay_tick[TOTAL_SOU_CHS] = {0};
static rt_bool_t g_sink_init_in_progress[TOTAL_SOU_CHS] = {RT_FALSE}; static rt_bool_t g_sink_init_in_progress[TOTAL_SOU_CHS] = {RT_FALSE};
/* 只有当前阶段入队成功后，才允许消费该阶段的南向批次结果。 */
static rt_bool_t g_sink_init_stage_submitted[TOTAL_SOU_CHS] = {RT_FALSE};
/* 主继电器闭合跟踪：1=已提交ALL_REL_ON（主继电器应已闭合） 0=未闭合/已断开。 /* 主继电器闭合跟踪：1=已提交ALL_REL_ON（主继电器应已闭合） 0=未闭合/已断开。
* 用于0V硬保护区分"首次开载/握手恢复"（主继电器未闭合，Now_voltage=0属正常） * 用于0V硬保护区分"首次开载/握手恢复"（主继电器未闭合，Now_voltage=0属正常）
@@ -291,10 +293,12 @@ static int chrg_sink_init_submit_stage(eIDX_SOU_CH idx,
rt_uint8_t total; rt_uint8_t total;
rt_uint8_t start; rt_uint8_t start;
rt_uint8_t count; rt_uint8_t count;
int ret;
if ((idx >= TOTAL_SOU_CHS) || (pSW == RT_NULL)) { if ((idx >= TOTAL_SOU_CHS) || (pSW == RT_NULL)) {
return -1; return -1;
} }
g_sink_init_stage_submitted[idx] = RT_FALSE;
total = chrg_sink_init_build_commands(pSW, regs, vals); total = chrg_sink_init_build_commands(pSW, regs, vals);
switch (g_sink_init_stage[idx]) { switch (g_sink_init_stage[idx]) {
@@ -313,7 +317,11 @@ static int chrg_sink_init_submit_stage(eIDX_SOU_CH idx,
default: default:
return -1; return -1;
} }
return chrg_sou_com_batch_submit(idx, &regs[start], &vals[start], count); ret = chrg_sou_com_batch_submit(idx, &regs[start], &vals[start], count);
if (ret == 0) {
g_sink_init_stage_submitted[idx] = RT_TRUE;
}
return ret;
} }
/***************************************************************** /*****************************************************************
@@ -336,20 +344,17 @@ static int chrg_sink_work_init(eIDX_SOU_CH idx, struct chrg_switch_t *pSW)
g_sink_init_in_progress[idx] = RT_TRUE; g_sink_init_in_progress[idx] = RT_TRUE;
g_sink_init_stage[idx] = SINK_INIT_STAGE_CLEAR_RELAY; g_sink_init_stage[idx] = SINK_INIT_STAGE_CLEAR_RELAY;
g_sink_init_north_relay_tick[idx] = 0U; g_sink_init_north_relay_tick[idx] = 0U;
if (chrg_sink_init_submit_stage(idx, pSW) != 0) { /* 入队失败也保留事务和等待入口，由等待分支持续重提当前阶段。 */
return -1;
}
pSW->sink.On_work = 1; pSW->sink.On_work = 1;
pSW->sink.work_mode = SINK_WORK_INIT_AUX_WAIT; pSW->sink.work_mode = SINK_WORK_INIT_AUX_WAIT;
return 0; return chrg_sink_init_submit_stage(idx, pSW);
} }
/***************************************************************** /*****************************************************************
函数名称： chrg_sink_work_init_aux_wait 函数名称： chrg_sink_work_init_aux_wait
函数描述： 后台等待整组南向初始化命令完成，不阻塞北向协议握手 函数描述： 后台等待整组南向初始化命令完成，不阻塞北向协议握手
输入参数： idx:南向功率通道编号 pSW:当前通道控制结构体 输入参数： idx:南向功率通道编号 pSW:当前通道控制结构体
输出参数： 初始化完成后进入SINK_WORK_WAIT，失败时重提整个初始化批次 输出参数： 初始化完成后进入SINK_WORK_WAIT，失败时重提当前阶段
返回说明： 0:继续等待或初始化完成 <0:参数错误 返回说明： 0:继续等待或初始化完成 <0:参数错误
其它说明： 重试时保留当前北向sub，禁止把正在执行的协议/CC事务拉回起点 其它说明： 重试时保留当前北向sub，禁止把正在执行的协议/CC事务拉回起点
*****************************************************************/ *****************************************************************/
@@ -383,6 +388,10 @@ static int chrg_sink_work_init_aux_wait(eIDX_SOU_CH idx,
} }
return 0; return 0;
} }
/* 上一阶段成功后，新阶段可能因锁/队列满未入队；不能沿用旧成功结果。 */
if (!g_sink_init_stage_submitted[idx]) {
return chrg_sink_init_submit_stage(idx, pSW);
}
batch_result = chrg_sou_com_batch_get_result(idx); batch_result = chrg_sou_com_batch_get_result(idx);
if (batch_result <= 0) { if (batch_result <= 0) {
return chrg_sink_init_submit_stage(idx, pSW); return chrg_sink_init_submit_stage(idx, pSW);
@@ -400,6 +409,7 @@ static int chrg_sink_work_init_aux_wait(eIDX_SOU_CH idx,
/* 北向可能已推进到CC或电压查询，此处只更新南向完成状态。 */ /* 北向可能已推进到CC或电压查询，此处只更新南向完成状态。 */
g_sink_init_in_progress[idx] = RT_FALSE; g_sink_init_in_progress[idx] = RT_FALSE;
g_sink_init_stage_submitted[idx] = RT_FALSE;
pSOU->online[idx] = 1; pSOU->online[idx] = 1;
pSW->sink.test.test_mode_old = 0; pSW->sink.test.test_mode_old = 0;
pSW->sink.work_mode = SINK_WORK_WAIT; pSW->sink.work_mode = SINK_WORK_WAIT;
@@ -636,6 +646,7 @@ static int chrg_sink_work_stop_prepare(eIDX_SOU_CH idx,
return -1; return -1;
} }
g_sink_init_in_progress[idx] = RT_FALSE; g_sink_init_in_progress[idx] = RT_FALSE;
g_sink_init_stage_submitted[idx] = RT_FALSE;
if (chrg_sou_com_batch_cancel(idx) != 0) { if (chrg_sou_com_batch_cancel(idx) != 0) {
return -1; return -1;
} }
@@ -715,6 +726,13 @@ static int chrg_sink_work_switch(eIDX_SOU_CH idx, struct chrg_switch_t *pSW)
rt_uint16_t eload_value = ELOAD_LOAD; rt_uint16_t eload_value = ELOAD_LOAD;
int ret; int ret;
/* Source接管后，旧Sink初始化上下文已失效；返回Sink必须重新初始化，
* 禁止把角色切换批次回码当作上次初始化阶段的完成结果。 */
g_sink_init_in_progress[idx] = RT_FALSE;
g_sink_init_stage_submitted[idx] = RT_FALSE;
g_sink_init_stage[idx] = SINK_INIT_STAGE_CLEAR_RELAY;
g_sink_init_north_relay_tick[idx] = 0U;
ret = chrg_sou_com_batch_submit(idx, &reg, &value, 1); ret = chrg_sou_com_batch_submit(idx, &reg, &value, 1);
if (ret != 0) { if (ret != 0) {
return ret; return ret;
@@ -1007,11 +1025,7 @@ int chrg_sink_volt_judge(eIDX_SOU_CH idx, struct chrg_switch_t *pSW)
if (g_sink_init_in_progress[idx] || if (g_sink_init_in_progress[idx] ||
(pSW->sink.work_mode == SINK_WORK_INIT) || (pSW->sink.work_mode == SINK_WORK_INIT) ||
(pSW->sink.work_mode == SINK_WORK_INIT_AUX_WAIT)) { (pSW->sink.work_mode == SINK_WORK_INIT_AUX_WAIT)) {
if (g_sink_init_in_progress[idx] && /* 统一入口负责恢复等待阶段及停止优先级，不能在这里覆盖STOP。 */
(pSW->sink.work_mode != SINK_WORK_INIT) &&
(pSW->sink.work_mode != SINK_WORK_INIT_AUX_WAIT)) {
pSW->sink.work_mode = SINK_WORK_INIT_AUX_WAIT;
}
return chrg_sink_work(idx, pSW); return chrg_sink_work(idx, pSW);
} }
@@ -1191,10 +1205,12 @@ int chrg_sink_work(eIDX_SOU_CH idx, struct chrg_switch_t *pSW)
} }
work_mode = pSW->sink.work_mode; work_mode = pSW->sink.work_mode;
workmode = work_mode; workmode = work_mode;
/* 初始化事务独占该通道，防止其它路径改成RUNING后追加普通启动命令。 */ /* 已开始的初始化只能继续等待，重复INIT也不能被last_state去重卡住。
* 停止、掉电保护和角色切换必须能抢占初始化，不能改回等待状态。 */
if (g_sink_init_in_progress[idx] && if (g_sink_init_in_progress[idx] &&
(work_mode != SINK_WORK_INIT) && (work_mode != SINK_WORK_STOP) &&
(work_mode != SINK_WORK_INIT_AUX_WAIT)) { (work_mode != SINK_WORK_LOW) &&
(work_mode != SINK_WORK_SWITCH)) {
pSW->sink.work_mode = SINK_WORK_INIT_AUX_WAIT; pSW->sink.work_mode = SINK_WORK_INIT_AUX_WAIT;
work_mode = SINK_WORK_INIT_AUX_WAIT; work_mode = SINK_WORK_INIT_AUX_WAIT;
} }
@@ -1203,6 +1219,8 @@ int chrg_sink_work(eIDX_SOU_CH idx, struct chrg_switch_t *pSW)
} }
/* 异步等待状态需要持续检查批次或新量测，其余相同状态保持去重。 */ /* 异步等待状态需要持续检查批次或新量测，其余相同状态保持去重。 */
if ((work_mode == last_state[idx]) && if ((work_mode == last_state[idx]) &&
(work_mode != SINK_WORK_INIT) &&
(work_mode != SINK_WORK_STOP) &&
(work_mode != SINK_WORK_ON_TEST_SHORT) && (work_mode != SINK_WORK_ON_TEST_SHORT) &&
(work_mode != SINK_WORK_INIT_AUX_WAIT) && (work_mode != SINK_WORK_INIT_AUX_WAIT) &&
(work_mode != SINK_WORK_STOP_WAIT) && (work_mode != SINK_WORK_STOP_WAIT) &&
docs/修改日志.md
+20
View File
@@ -1,5 +1,25 @@
# 修改日志 # 修改日志
## V1.1.26 - 2026-09-17
### 修复Sink角色往返时初始化上下文残留
- Source切回Sink时清除旧Sink初始化阶段、提交标记和延时计时；重新执行清短路及继电器等完整初始化，避免角色切换回码被误判为旧初始化成功。
- 应用版本更新为 `V1.1.26`，对外固件版本寄存器 `0x0300` 为 `0x012A`；Bootloader不变。
## V1.1.25 - 2026-09-17
### 修复Sink重复启动及退出Short时初始化卡住
- 同角色Sink参数生效只复制PC可写配置，不再覆盖实时work_mode、sub、On_work、test_mode_old及量测数据。
- 初始化/退出Short期间，相同运行请求继续原事务，不重复取消批次；不同配置返回Modbus忙（异常码0x06），PC需等待后重新发送参数生效。停止流程未完成时也拒绝新运行请求。
- 已开始的初始化收到重复INIT时恢复到INIT_AUX_WAIT，避免被last_state去重卡住；停止和掉电保护允许抢占初始化。
- 按阶段记录初始化命令是否入队，入队失败或批次失败时重试当前阶段，禁止用上一阶段的成功结果跳过未发送的命令。
- 重复/拒绝的Sink配置不再无条件递增北向配置版本，避免连续参数生效导致有效回码被反复丢弃。
- STOP入队失败后由北向轮询继续重试，不依赖On_work或通道使能。
- 应用版本V1.1.25，对外寄存器0x0300返回0x0129；Bootloader不变。不修改Von门槛、串口超时和南向队列容量。
- 增加主机回归测试tests/sink_init（运行真实状态机及COM生效函数，模拟南向批次和时钟）。硬件仍需验证单/四通道循环启停、反复Short进入退出、通信超时恢复及停止安全性。
## V1.1.24 - 2026-09-15 ## V1.1.24 - 2026-09-15
### 统一应用版本定义 ### 统一应用版本定义
tests/sink_init/README.md
+28
View File
@@ -0,0 +1,28 @@
# Sink 初始化回归验证
## 主机测试
在仓库根目录执行（需要 Node.js 和本机 GCC）：
```powershell
node tests/sink_init/run.cjs C:/Qt/Tools/mingw1310_64/bin/gcc.exe
```
测试编译真实 `chrg_sink.c`、从 COM 提取的配置生效函数和北向状态调度片段；只模拟时钟、南向批次、继电器及无关外设。每个场景独立进程，临时产物自动清理。
14 个用例覆盖：旧影子配置保留实时状态、重复退出 Short、初始化中配置变化返回忙、重复 INIT 恢复、初始化中停止、首批/后续阶段入队失败、批次失败重试、完整初始化后再次退出 Short、重复/拒绝请求不改变配置版本、停止入队失败后台重试、Sink 初始化中切换角色后重新初始化。
主机测试不能验证实际串口回码匹配、线程竞争、继电器时序或功率板执行结果。
## 硬件验收（尚未执行）
使用现有 PC 指令和安全负载，先单通道，再四通道同时重复以下场景：
1. 普通 5V/1A 启停、Short 进入/退出各循环至少 100 次；退出期间重复发送同一参数生效请求。预期退出初始化持续推进，最终可恢复带载。
2. 初始化期间修改配置并生效。预期返回 Modbus 忙（异常码 `0x06`），PC 在初始化完成后重试；旧事务参数及北向回码推进不被覆盖。
3. 在各初始化阶段发送停止；短时断开南向通信后恢复。预期停止优先、未完成阶段重试，不以旧成功结果提前进入 WAIT。
4. 初始化未完成时切 Source，再切回 Sink。预期重新清短路、配置继电器和负载参数，不复用旧初始化阶段。
用 Keil Watch 观察 `sink.work_mode`、`sink.On_work`、`sink.test.test_mode_old`、`g_sink_init_in_progress`、`g_sink_init_stage`、`g_sink_init_stage_submitted`、`sub` 和 `config_version`；避免高频打印。结合南向回码及实测电流确认执行，不能仅以入队成功作为验收依据。
本次应用版本为 **V1.1.26**，对外固件版本寄存器 `0x0300` 为 `0x012A`；Bootloader 不变。
tests/sink_init/cases.c
+210
View File
@@ -0,0 +1,210 @@
/* 本文件由 run.cjs 拼接到真实产品函数后。每个场景独立进程，静态状态不会串扰。 */
#include <stdio.h>
#include <stdlib.h>
struct chrg_north_t chrgnorth;
struct chrg_south_t chrgsouth;
struct chrg_thread_t chrgthr[TOTAL_THRS];
static rt_tick_t now;
static int pending, result, fail_submit, cancel_count, submit_count;
static int queue_capacity = 1;
static rt_uint16_t last_reg, last_val;
static rt_uint32_t sample_seq;
#define CHECK(x) do { if (!(x)) { fprintf(stderr, "line %d: %s\n", __LINE__, #x); exit(1); } } while (0)
rt_tick_t rt_tick_get(void) { return now; }
rt_tick_t rt_tick_from_millisecond(rt_int32_t ms) { return (rt_tick_t)ms; }
int rt_kprintf(const char *format, ...) { (void)format; return 0; }
rt_err_t rt_mutex_take(rt_mutex_t mutex, rt_int32_t timeout)
{ (void)mutex; (void)timeout; return 0; }
rt_err_t rt_mutex_release(rt_mutex_t mutex) { (void)mutex; return 0; }
void chrg_roll_nor_source_switch_reset(rt_uint8_t ch) { (void)ch; CHECK(0); }
int chrg_source_work_state(rt_uint8_t ch, struct chrg_switch_t *p)
{ (void)ch; (void)p; CHECK(0); return -1; }
static eMBException chrg_comm_apply_source_effect(rt_uint8_t ch,
struct chrg_switch_t *p, const struct chrg_switch_t *s)
{ (void)ch; (void)p; (void)s; CHECK(0); return MB_EX_SLAVE_BUSY; }
int chrg_sou_com_batch_submit(eIDX_SOU_CH ch, const rt_uint16_t *regs,
const rt_uint16_t *vals, rt_uint8_t count)
{
(void)ch;
CHECK(count > 0);
if (fail_submit) { fail_submit--; return -1; }
CHECK(pending < queue_capacity); /* 角色切换允许连续两批，其余场景禁止重复提交。 */
submit_count++;
last_reg = regs[0]; last_val = vals[0];
pending++; result = 0;
return 0;
}
int chrg_sou_com_batch_cancel(eIDX_SOU_CH ch)
{ (void)ch; cancel_count++; pending = 0; result = -1; return 0; }
rt_bool_t chrg_sou_com_batch_is_pending(eIDX_SOU_CH ch)
{ (void)ch; return pending; }
int chrg_sou_com_batch_get_result(eIDX_SOU_CH ch)
{ (void)ch; return result; }
int chrg_sou_measure_once_submit(eIDX_SOU_CH ch) { (void)ch; return 0; }
rt_uint32_t chrg_eload_get_sample_seq(rt_uint8_t ch) { (void)ch; return sample_seq; }
void chrg_nor_sw_rel(eIDX_NOR_CH ch, eIDX_ID id) { (void)ch; (void)id; }
/* 北向串口不在这些场景的执行路径中，意外调用立即失败。 */
rt_uint8_t u16_to_u8v(rt_uint16_t value, rt_uint8_t *buf)
{ (void)value; (void)buf; CHECK(0); return 0; }
int chrg_north_pkg_encode(eIDX_ID id, rt_uint8_t cmd, rt_uint8_t *in,
rt_uint8_t len, rt_uint8_t *out, rt_uint16_t *out_len)
{ (void)id; (void)cmd; (void)in; (void)len; (void)out; (void)out_len; CHECK(0); return -1; }
int chrg_north_send(rt_uint8_t *data, rt_size_t length)
{ (void)data; (void)length; CHECK(0); return -1; }
static struct chrg_switch_t *fixture(void)
{
struct chrg_switch_t *p = &chrgnorth.sw[0];
p->id = ID_SINK;
p->CV_mode = MODE_CONSTANT_CURRENT;
p->sink.On_work = 1;
p->sink.Now_State = 1;
p->sink.loadc = 1000;
p->sink.volt_on = 4000;
p->sink.pro_loadv = 5000;
p->sink.pro_loadc = 1000;
p->sink.work_mode = SINK_WORK_ON_TEST_SHORT;
p->sink.test.test_mode = SINK_TEST_SHORT;
p->sink.test.test_mode_old = SINK_TEST_SHORT;
return p;
}
static void exit_short(struct chrg_switch_t *p)
{
struct chrg_switch_t shadow = *p;
shadow.sink.test.test_mode = 0;
CHECK(chrg_comm_apply_sink_effect(0, p, &shadow) == MB_EX_NONE);
CHECK(p->sink.work_mode == SINK_WORK_INIT_AUX_WAIT);
CHECK(pending && last_reg == 0x40 && last_val == 0);
}
static void ack(void) { pending = 0; result = 1; }
static void complete_init(struct chrg_switch_t *p)
{
ack(); CHECK(chrg_sink_work(0, p) == 0);
CHECK(pending && last_reg == REG_REL_ON && last_val == ALL_REL_OFF);
ack(); CHECK(chrg_sink_work(0, p) == 0);
now += 31; CHECK(chrg_sink_work(0, p) == 0);
CHECK(pending && last_reg == REG_REL_ON && last_val == FU_REL_ON);
ack(); CHECK(chrg_sink_work(0, p) == 0);
CHECK(p->sink.work_mode == SINK_WORK_WAIT);
CHECK(!g_sink_init_in_progress[0] && p->sink.test.test_mode_old == 0);
}
int main(int argc, char **argv)
{
struct chrg_switch_t *p = fixture();
struct chrg_switch_t s;
int cancels, submits;
CHECK(argc == 2);
if (!strcmp(argv[1], "preserve_runtime")) {
p->sink.test.test_mode = p->sink.test.test_mode_old = 0;
p->sink.work_mode = SINK_WORK_RUNING;
p->sub = IDX_GET_SINK_VC;
p->Now_voltage = 5010; p->Now_current = 1000;
p->Sink_voltage_seq = 77;
CHECK(chrg_sink_work(0, p) == 0); ack();
s = *p;
s.sink.work_mode = SINK_WORK_INIT; s.sink.On_work = 0;
s.sub = IDX_SET_SINK_CC_BEFORE_PD;
s.Now_voltage = 0; s.Now_current = 0; s.Sink_voltage_seq = 1;
CHECK(chrg_comm_apply_sink_effect(0, p, &s) == MB_EX_NONE);
CHECK(p->sink.work_mode == SINK_WORK_RUNING && p->sink.On_work == 1);
CHECK(p->sub == IDX_GET_SINK_VC && p->Now_voltage == 5010);
CHECK(p->Now_current == 1000 && p->Sink_voltage_seq == 77 && !pending);
} else if (!strcmp(argv[1], "first_submit_failure")) {
s = *p; s.sink.test.test_mode = 0; fail_submit = 1;
CHECK(chrg_comm_apply_sink_effect(0, p, &s) == MB_EX_SLAVE_BUSY);
CHECK(chrg_sink_work(0, p) == 0);
CHECK(pending && last_reg == 0x40);
complete_init(p);
} else {
exit_short(p);
cancels = cancel_count; submits = submit_count; s = *p;
if (!strcmp(argv[1], "duplicate_version") || !strcmp(argv[1], "busy_version")) {
int busy = !strcmp(argv[1], "busy_version");
chrgnorth.config_version[0] = 17;
if (busy) s.sink.loadc = 800;
CHECK(chrg_mb_write_sys(0, SYS_REG_PARAM_EFFECT, 1, &s,
&chrgnorth, &chrgsouth) == (busy ? MB_EX_SLAVE_BUSY : MB_EX_NONE));
CHECK(chrgnorth.config_version[0] == 17);
CHECK(g_shadow_dirty[0] == busy);
CHECK(cancel_count == cancels && pending);
} else if (!strcmp(argv[1], "duplicate_exit")) {
CHECK(chrg_comm_apply_sink_effect(0, p, &s) == MB_EX_NONE);
CHECK(cancel_count == cancels && submit_count == submits);
CHECK(p->sink.work_mode == SINK_WORK_INIT_AUX_WAIT && pending);
complete_init(p);
} else if (!strcmp(argv[1], "busy_changed_config")) {
struct chrg_switch_t before = *p;
s.sink.loadc = 800; s.sink.volt_on = 4500;
CHECK(chrg_comm_apply_sink_effect(0, p, &s) == MB_EX_SLAVE_BUSY);
CHECK(memcmp(p, &before, sizeof(*p)) == 0);
CHECK(cancel_count == cancels && submit_count == submits && pending);
} else if (!strcmp(argv[1], "recover_init")) {
p->sink.work_mode = SINK_WORK_INIT; /* 硬件截图的状态组合。 */
CHECK(chrg_sink_work(0, p) == 0);
CHECK(p->sink.work_mode == SINK_WORK_INIT_AUX_WAIT);
CHECK(cancel_count == cancels && submit_count == submits);
complete_init(p);
} else if (!strcmp(argv[1], "stop_during_init")) {
s.sink.Now_State = 2;
CHECK(chrg_comm_apply_sink_effect(0, p, &s) == MB_EX_NONE);
CHECK(!g_sink_init_in_progress[0] && p->sink.On_work == 0);
CHECK(p->sink.work_mode == SINK_WORK_STOP_WAIT);
CHECK(pending && last_reg == REG_WORK && last_val == WORK_STOP);
} else if (!strcmp(argv[1], "stop_submit_retry")) {
s.sink.Now_State = 2; fail_submit = 1;
CHECK(chrg_comm_apply_sink_effect(0, p, &s) == MB_EX_SLAVE_BUSY);
CHECK(p->sink.work_mode == SINK_WORK_STOP && p->sink.On_work == 0);
CHECK(poll_state(p) == 0);
CHECK(p->sink.work_mode == SINK_WORK_STOP_WAIT);
CHECK(pending && last_reg == REG_WORK && last_val == WORK_STOP);
} else if (!strcmp(argv[1], "role_roundtrip")) {
ack(); CHECK(chrg_sink_work(0, p) == 0);
ack(); CHECK(chrg_sink_work(0, p) == 0);
now += 31; CHECK(chrg_sink_work(0, p) == 0);
CHECK(g_sink_init_stage[0] == SINK_INIT_STAGE_REST);
/* 模拟Source接管时取消旧批次并清On_work，保留真实Sink静态上下文。 */
CHECK(chrg_sou_com_batch_cancel(0) == 0);
p->sink.On_work = 0;
p->source.On_Flag = 1;
p->sink.work_mode = SINK_WORK_SWITCH;
queue_capacity = 2;
CHECK(chrg_sink_work(0, p) == 0);
CHECK(p->sink.work_mode == SINK_WORK_INIT);
ack(); /* 角色切换批次已成功，但不代表新Sink初始化成功。 */
CHECK(chrg_sink_work(0, p) == 0);
CHECK(p->sink.work_mode == SINK_WORK_INIT_AUX_WAIT);
CHECK(p->sink.On_work == 1 && pending && last_reg == 0x40);
complete_init(p);
} else if (!strcmp(argv[1], "rest_submit_failure")) {
ack(); CHECK(chrg_sink_work(0, p) == 0);
ack(); CHECK(chrg_sink_work(0, p) == 0);
now += 31; fail_submit = 1;
CHECK(chrg_sink_work(0, p) != 0);
CHECK(!pending && result == 1);
CHECK(chrg_sink_work(0, p) == 0);
CHECK(pending && last_reg == REG_REL_ON && last_val == FU_REL_ON);
CHECK(g_sink_init_in_progress[0] && p->sink.test.test_mode_old == 1);
ack(); CHECK(chrg_sink_work(0, p) == 0);
CHECK(p->sink.work_mode == SINK_WORK_WAIT);
} else if (!strcmp(argv[1], "stage_submit_failure")) {
ack(); fail_submit = 1;
CHECK(chrg_sink_work(0, p) != 0);
CHECK(!pending && result == 1); /* 故意保留上一阶段成功结果。 */
CHECK(chrg_sink_work(0, p) == 0);
CHECK(pending && last_reg == REG_REL_ON && last_val == ALL_REL_OFF);
CHECK(g_sink_init_stage[0] == SINK_INIT_STAGE_AUX_RELAY);
} else if (!strcmp(argv[1], "failed_batch_retry")) {
pending = 0; result = -1;
CHECK(chrg_sink_work(0, p) == 0);
CHECK(pending && last_reg == 0x40 && p->sink.test.test_mode_old == 1);
complete_init(p);
} else if (!strcmp(argv[1], "complete_then_restart")) {
complete_init(p); s = *p; s.sink.test.test_mode = 1;
CHECK(chrg_comm_apply_sink_effect(0, p, &s) == MB_EX_NONE);
CHECK(p->sink.work_mode == SINK_WORK_ON_TEST_SHORT && pending);
ack(); exit_short(p); complete_init(p);
} else { CHECK(0); }
}
return 0;
}
tests/sink_init/rtdevice.h
+1
View File
@@ -0,0 +1 @@
#include "rtthread.h"
tests/sink_init/rthw.h
+1
View File
@@ -0,0 +1 @@
#include "rtthread.h"
tests/sink_init/rtthread.h
+37
View File
@@ -0,0 +1,37 @@
#ifndef HOST_RTTHREAD_H
#define HOST_RTTHREAD_H
#include <stdint.h>
#include <stddef.h>
#include <string.h>
typedef uint8_t rt_uint8_t;
typedef int8_t rt_int8_t;
typedef uint16_t rt_uint16_t;
typedef int16_t rt_int16_t;
typedef uint32_t rt_uint32_t;
typedef int32_t rt_int32_t;
typedef uintptr_t rt_ubase_t;
typedef intptr_t rt_base_t;
typedef size_t rt_size_t;
typedef int rt_bool_t;
typedef int rt_err_t;
typedef uint32_t rt_tick_t;
typedef void *rt_device_t;
typedef void *rt_mutex_t;
typedef void *rt_event_t;
typedef void *rt_sem_t;
typedef void *rt_mailbox_t;
typedef void *rt_mq_t;
#define RT_NULL NULL
#define RT_TRUE 1
#define RT_FALSE 0
#define RT_WAITING_FOREVER (-1)
#define RT_TICK_PER_SECOND 1000
#define rt_memcpy memcpy
#define rt_memcmp memcmp
#define rt_memset memset
rt_tick_t rt_tick_get(void);
rt_tick_t rt_tick_from_millisecond(rt_int32_t ms);
int rt_kprintf(const char *format, ...);
rt_err_t rt_mutex_take(rt_mutex_t mutex, rt_int32_t timeout);
rt_err_t rt_mutex_release(rt_mutex_t mutex);
#endif
tests/sink_init/run.cjs
+62
View File
@@ -0,0 +1,62 @@
// 使用真实 Sink 实现及 COM 生效函数；仅替换时钟、继电器和南向传输。
// node tests/sink_init/run.cjs [gcc路径]。临时编译产物不写入固件工程。
const fs = require('node:fs');
const os = require('node:os');
const path = require('node:path');
const cp = require('node:child_process');
const root = path.resolve(__dirname, '../..');
const app = path.join(root, 'apps/chrg/applications');
const cc = process.argv[2] || process.env.CC || 'gcc';
if (path.isAbsolute(cc)) process.env.PATH = path.dirname(cc) + path.delimiter + process.env.PATH;
const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'chrg-sink-test-'));
const source = fs.readFileSync(path.join(app, 'thread/chrg_comm.c'), 'utf8');
function definition(name) {
const pattern = new RegExp('static\\s+[\\w]+\\s+' + name + '\\s*\\([^;{]*\\)\\s*\\{', 'g');
const match = pattern.exec(source);
if (!match) return '';
let depth = 1, end = pattern.lastIndex;
while (depth && end < source.length) {
if (source[end] === '{') depth++;
if (source[end] === '}') depth--;
end++;
}
return source.slice(match.index, end);
}
const type = source.match(/typedef struct\s*\{[^}]*\}\s*chrg_param_diff_t;/)[0];
const functions = ['chrg_comm_get_param_diff', 'chrg_comm_sink_config_equal',
'chrg_comm_copy_sink_config', 'chrg_comm_handle_sink_load_current',
'chrg_sink_diff_send_reg', 'chrg_comm_apply_sink_effect', 'chrg_mb_write_sys'];
const roll = fs.readFileSync(path.join(app, 'thread/chrg_roll_nor.c'), 'utf8');
const dispatch = roll.slice(roll.indexOf('void chrg_roll_nor_thread_entry'))
.match(/if \(\(pSW->id == ID_SOURCE\)[\s\S]+?state_work_ret = chrg_sink_work[\s\S]+?\n\t\t\t\}/)[0];
const unit = '#include "' + path.join(app, 'utils/chrg_sink.c').replaceAll('\\', '/') + '"\n' +
'#include "chrg_thread.h"\n#define LOG_E(...) ((void)0)\n' +
'static rt_uint8_t g_shadow_dirty[4], last_pd_pro[4];\n#define SOURCE_PD_STATE_UNKNOWN 255\n' +
'static eMBException chrg_comm_apply_source_effect(rt_uint8_t ch, struct chrg_switch_t *p, const struct chrg_switch_t *s);\n' +
type + '\n' + functions.map(definition).join('\n') + '\n' +
'static int poll_state(struct chrg_switch_t *pSW) { int idx=0, state_work_ret=0;\n' + dispatch + '\nreturn state_work_ret; }\n' +
fs.readFileSync(path.join(__dirname, 'cases.c'), 'utf8');
const scenarios = ['duplicate_exit', 'preserve_runtime', 'busy_changed_config',
'recover_init', 'stop_during_init', 'first_submit_failure', 'stage_submit_failure',
'failed_batch_retry', 'complete_then_restart', 'duplicate_version',
'busy_version', 'stop_submit_retry', 'rest_submit_failure', 'role_roundtrip'];
try {
fs.writeFileSync(path.join(dir, 'test.c'), unit);
const exe = path.join(dir, process.platform === 'win32' ? 'test.exe' : 'test');
const args = ['-std=c99', '-O0', '-ffunction-sections', '-fdata-sections',
'-Werror=implicit-function-declaration', '-Wl,--gc-sections',
'-I' + __dirname, ...['utils', 'thread', 'bsp'].map(p => '-I' + path.join(app, p)),
path.join(dir, 'test.c'), '-o', exe];
const build = cp.spawnSync(cc, args, {encoding: 'utf8'});
if (build.status !== 0) throw Error(build.stderr || String(build.error || build.status));
let failed = 0;
for (const name of scenarios) {
const run = cp.spawnSync(exe, [name], {encoding: 'utf8'});
console.log((run.status === 0 ? 'PASS ' : 'FAIL ') + name);
if (run.status !== 0) { failed++; console.log(run.stdout + run.stderr); }
}
console.log(`${scenarios.length - failed}/${scenarios.length} passed`);
process.exitCode = failed ? 1 : 0;
} finally {
fs.rmSync(dir, {recursive: true, force: true});
}