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

1. 更新所有文件版本号至V1.1.26，同步固件版本寄存器值
2. 修复Sink角色往返时初始化上下文残留问题，切换回Sink时重新执行完整初始化
3. 优化Sink配置生效逻辑，同角色仅复制PC可写配置，保留运行状态
4. 增加初始化阶段入队标记，避免沿用旧成功结果跳过未执行命令
5. 停止入队失败时由北向轮询重试，不依赖On_work或通道使能
6. 新增Sink初始化回归测试套件，覆盖14种场景验证流程正确性

apps/chrg/applications/thread/chrg_comm.c

@@ -1,7 +1,7 @@
 /****************************************************************************
 文件名称   : chrg_comm.c
 完成日期   : 
-当前版本号 : V1.1.24
+当前版本号 : V1.1.26
 主要功能   : 实现对外通讯协议 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
-函数描述： 处理COM参数生效后的同角色负载启停、测试和差异更新
-输入参数： ch:通道 pReal:运行参数 pShadow:待生效影子参数
-输出参数： 更新pReal并按需提交南向命令
-返回说明： MB_EX_NONE:成功 MB_EX_SLAVE_BUSY:命令提交失败
-其它说明： 角色切换不在本函数处理，由chrg_mb_write_sys统一调度
+函数描述： 应用同角色负载配置；相同初始化请求继续等待，不取消退出Short批次
+返回说明： 初始化期间不同配置返回忙，PC需重试；停止请求不受此限制
 *****************************************************************/
 static eMBException chrg_comm_apply_sink_effect(rt_uint8_t ch,
 	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;
 	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);
 	/*
 	 * 协议类型、CC和协议组号变化需要完整握手；协议电压和协议电流
@@ -2605,7 +2673,7 @@ static eMBException chrg_comm_apply_sink_effect(rt_uint8_t ch,
 			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) {
 		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;
 	eIDX_ID old_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;
 
 	(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;
 		new_id = pSW->id;
 		g_shadow_dirty[ch] = 0;
-		/*
-		 * 使每次COM参数生效拥有独立版本。北向线程等待回码期间如果版本变化，
-		 * 必须放弃旧请求，防止旧回码把新配置的sub错误推进到下一步。
-		 */
-		pNOR->config_version[ch]++;
-
 		if (old_id != new_id) {
+			pNOR->config_version[ch]++;
 			/* 角色切换时清除旧Source协议切换的等待上下文。 */
 			chrg_roll_nor_source_switch_reset(ch);
 			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;
 		} 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);
+			/* 重复请求或初始化期间被拒绝的新配置不能作废正在等待的北向
+			 * 回码；只有配置确实应用或控制入口改变时才递增版本。
+			 * 即使南向暂时入队失败，已接受的新配置也必须隔离旧回码。 */
+			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 {
+			pNOR->config_version[ch]++;
 			status = chrg_comm_apply_source_effect(ch, pReal, pSW);
 		}
 

apps/chrg/applications/thread/chrg_roll_nor.c

@@ -1,7 +1,7 @@
 /****************************************************************************
 文件名称   : 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) &&
 				((pSW->sink.work_mode == SINK_WORK_INIT) ||
 				 (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_LOW) ||
 					 (pSW->sink.work_mode == SINK_WORK_LOW_AUX_WAIT) ||

apps/chrg/applications/utils/chrg_def.h

@@ -1,7 +1,7 @@
 /****************************************************************************
 文件名称   : chrg_def.h
 完成日期   : 
-当前版本号 : V1.1.24
+当前版本号 : V1.1.26
 主要功能   : 全局宏定义，常量，及结构体。
 版本历史   : 创建原始版本
 说明      : 
@@ -15,8 +15,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       24U
-#define CHRG_VERSION_STRING      "V1.1.24"
+#define CHRG_VERSION_PATCH       26U
+#define CHRG_VERSION_STRING      "V1.1.26"
 /* Modbus version encoding: major<<8 + minor<<4 + patch. */
 #define CHRG_FIRMWARE_VERSION    ((CHRG_VERSION_MAJOR << 8) + \
 	(CHRG_VERSION_MINOR << 4) + CHRG_VERSION_PATCH)

apps/chrg/applications/utils/chrg_sink.c

@@ -1,7 +1,7 @@
 /****************************************************************************
 文件名称   : chrg_sink.c
 完成日期   : 
-当前版本号 : V1.1.24
+当前版本号 : V1.1.26
 主要功能   : 北向数据sink请求数据填充及发送。
 版本历史   : 创建原始版本
 说明      : 
@@ -34,6 +34,8 @@
 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_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=未闭合/已断开。
  * 用于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 start;
 	rt_uint8_t count;
+	int ret;
 
 	if ((idx >= TOTAL_SOU_CHS) || (pSW == RT_NULL)) {
 		return -1;
 	}
+	g_sink_init_stage_submitted[idx] = RT_FALSE;
 	total = chrg_sink_init_build_commands(pSW, regs, vals);
 
 	switch (g_sink_init_stage[idx]) {
@@ -313,7 +317,11 @@ static int chrg_sink_init_submit_stage(eIDX_SOU_CH idx,
 	default:
 		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_stage[idx] = SINK_INIT_STAGE_CLEAR_RELAY;
 	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.work_mode = SINK_WORK_INIT_AUX_WAIT;
-	return 0;
+	return chrg_sink_init_submit_stage(idx, pSW);
 }
 
 /*****************************************************************
 函数名称： chrg_sink_work_init_aux_wait
 函数描述： 后台等待整组南向初始化命令完成，不阻塞北向协议握手
 输入参数： idx:南向功率通道编号 pSW:当前通道控制结构体
-输出参数： 初始化完成后进入SINK_WORK_WAIT，失败时重提整个初始化批次
+输出参数： 初始化完成后进入SINK_WORK_WAIT，失败时重提当前阶段
 返回说明： 0:继续等待或初始化完成 <0:参数错误
 其它说明： 重试时保留当前北向sub，禁止把正在执行的协议/CC事务拉回起点
 *****************************************************************/
@@ -383,6 +388,10 @@ static int chrg_sink_work_init_aux_wait(eIDX_SOU_CH idx,
 		}
 		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);
 	if (batch_result <= 0) {
 		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或电压查询，此处只更新南向完成状态。 */
 	g_sink_init_in_progress[idx] = RT_FALSE;
+	g_sink_init_stage_submitted[idx] = RT_FALSE;
 	pSOU->online[idx] = 1;
 	pSW->sink.test.test_mode_old = 0;
 	pSW->sink.work_mode = SINK_WORK_WAIT;
@@ -636,6 +646,7 @@ static int chrg_sink_work_stop_prepare(eIDX_SOU_CH idx,
 		return -1;
 	}
 	g_sink_init_in_progress[idx] = RT_FALSE;
+	g_sink_init_stage_submitted[idx] = RT_FALSE;
 	if (chrg_sou_com_batch_cancel(idx) != 0) {
 		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;
 	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);
 	if (ret != 0) {
 		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] ||
 		(pSW->sink.work_mode == SINK_WORK_INIT) ||
 		(pSW->sink.work_mode == SINK_WORK_INIT_AUX_WAIT)) {
-		if (g_sink_init_in_progress[idx] &&
-			(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。 */
 		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;
 	workmode = work_mode;
-	/* 初始化事务独占该通道，防止其它路径改成RUNING后追加普通启动命令。 */
+	/* 已开始的初始化只能继续等待，重复INIT也不能被last_state去重卡住。
+	 * 停止、掉电保护和角色切换必须能抢占初始化，不能改回等待状态。 */
 	if (g_sink_init_in_progress[idx] &&
-		(work_mode != SINK_WORK_INIT) &&
-		(work_mode != SINK_WORK_INIT_AUX_WAIT)) {
+		(work_mode != SINK_WORK_STOP) &&
+		(work_mode != SINK_WORK_LOW) &&
+		(work_mode != SINK_WORK_SWITCH)) {
 		pSW->sink.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]) &&
+		(work_mode != SINK_WORK_INIT) &&
+		(work_mode != SINK_WORK_STOP) &&
 		(work_mode != SINK_WORK_ON_TEST_SHORT) &&
 		(work_mode != SINK_WORK_INIT_AUX_WAIT) &&
 		(work_mode != SINK_WORK_STOP_WAIT) &&

docs/修改日志.md

@@ -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
 
 ### 统一应用版本定义

tests/sink_init/README.md

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

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

@@ -0,0 +1 @@
+#include "rtthread.h"

tests/sink_init/rthw.h

@@ -0,0 +1 @@
+#include "rtthread.h"

tests/sink_init/rtthread.h

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

@@ -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});
+}