refactor: 重构电源通道控制逻辑,引入状态机管理

1. 删除apps/chrg/applications/thread/chrg_lcd.h中的chrg_sou_work函数声明
2. 移除chrg_source.h中冗余的状态标志定义,新增电源工作状态机枚举
3. 重构chrg_lcd.c,删除旧的启动/停止流程代码和冗余标志位操作
4. 重写chrg_roll_nor.c的协议设置和通道控制逻辑,替换为状态机处理
5. 重写chrg_source.c,新增统一的电源工作状态机实现,替换旧的协议设置函数
6. 重构chrg_north.c的电源解析逻辑,移除旧的停止流程和冗余标志位
7. 简化chrg_comm.c的Modbus协议处理逻辑,改为通过状态机控制电源通道
This commit is contained in:
wrh
2026-07-21 20:56:36 +08:00
parent a6621a304a
commit 660aaa5a7a
7 changed files with 160 additions and 595 deletions
+7 -377
View File
@@ -1022,378 +1022,6 @@ eMBException funcWriteMultipleCoils (rt_uint8_t *reqFrame, rt_uint16_t reqLen,
return eStatus;
}
static void parse_load_no_group(rt_uint8_t protoCmd, rt_uint8_t *pData, rt_uint16_t reqLen, struct chrg_switch_t *pSW)
{
rt_uint16_t volt_mv = 0; // 协议请求电压(mV)
rt_uint16_t curr_ma = 0; // 负载电流(mA)
// 数据区索引:0=状态+通道,1=CC线,2,选择恒压恒流模式3-4=电压,5-6=电流,6-7=保留
volt_mv = u8v_to_u16(&pData[3]); // 电压(mV,大端)
curr_ma = u8v_to_u16(&pData[5]); // 电流(mA,大端)
// 按协议命令码赋值
switch (protoCmd)
{
case 0x11: // QC2.0
pSW->sink.protocol = LOAD_PRO_QC20;
break;
case 0x12: // QC3.0
pSW->sink.protocol = LOAD_PRO_QC30;
break;
case 0x13: // FCP
pSW->sink.protocol = LOAD_PRO_FCP;
break;
case 0x14: // AFC
pSW->sink.protocol = LOAD_PRO_AFC;
break;
case 0x15: // SCP
pSW->sink.protocol = LOAD_PRO_SCP;
break;
case 0x16: // VIVO
pSW->sink.protocol = LOAD_PRO_VIVO;
break;
case 0x17: // TFC
pSW->sink.protocol = LOAD_PRO_TFC_RFC;
break;
default:
rt_kprintf("无组号负载协议不支持:0x%02X\n", protoCmd);
return;
}
// 赋值通用参数
pSW->sink.loadv = volt_mv;
pSW->sink.loadc = curr_ma;
pSW->sink.Pro_Group = 0; // 无组号
rt_kprintf("pro=%d,volt_mv=%d,curr=%d",pSW->sink.protocol,volt_mv,curr_ma);
}
static void parse_load_with_group(rt_uint8_t protoCmd, rt_uint8_t *pData, rt_uint16_t reqLen, struct chrg_switch_t *pSW)
{
rt_uint8_t group_num = 0; // 组号
rt_uint16_t volt_mv = 0; // 协议请求电压(mV)
rt_uint16_t curr_ma = 0; // 负载电流(mA)
// 数据区索引:0=状态+通道,1=CC线,2=恒压恒流模式,3=组号
group_num = pData[3];
pSW->sink.Pro_Group = group_num;
// 按协议命令码分支
switch (protoCmd)
{
case CMD_LOAD_PD0_MAN: // PD0(手动)
pSW->sink.protocol = LOAD_PRO_PDO_MANUAL;
// PD0特殊:组号后为3个保留2字节,无电压电流
volt_mv = 0;
curr_ma = 0;
break;
case CMD_LOAD_PD0_AUTO: // PDO自动
pSW->sink.protocol = LOAD_PRO_PDO_AUTO;
volt_mv = u8v_to_u16(&pData[4]); // 4-5=电压
curr_ma = u8v_to_u16(&pData[6]); // 6-7=电流
break;
case CMD_LOAD_PPS_MAN: // PPS(手动)
pSW->sink.protocol = LOAD_PRO_PPS_MANUAL;
volt_mv = u8v_to_u16(&pData[4]);
curr_ma = u8v_to_u16(&pData[6]);
break;
case CMD_LOAD_PPS_AUTO: // PPS(自动)
pSW->sink.protocol = LOAD_PRO_PPS_AUTO;
volt_mv = u8v_to_u16(&pData[4]);
curr_ma = u8v_to_u16(&pData[6]);
break;
case CMD_LOAD_PD31: // PD3.1
pSW->sink.protocol = LOAD_PRO_PD31AVS;
volt_mv = u8v_to_u16(&pData[4]);
curr_ma = u8v_to_u16(&pData[6]);
break;
case CMD_LOAD_UFCS: // UFCS
pSW->sink.protocol = LOAD_PRO_UFCS;
volt_mv = u8v_to_u16(&pData[4]);
curr_ma = u8v_to_u16(&pData[6]);
break;
case CMD_LOAD_VOOC: // VOOC
pSW->sink.protocol = LOAD_PRO_VOOC;
volt_mv = 0;
curr_ma = 0;
break;
case CMD_LOAD_AVS: // AVS
pSW->sink.protocol = LOAD_PRO_AVS;
volt_mv = u8v_to_u16(&pData[4]);
curr_ma = u8v_to_u16(&pData[6]);
break;
default:
rt_kprintf("有组号负载协议不支持:0x%02X\n", protoCmd);
return;
}
rt_kprintf("volt_mv=%d,curr_ma=%d\n",volt_mv,curr_ma);
// 赋值通用参数
pSW->sink.loadv = volt_mv;
pSW->sink.loadc = curr_ma;
}
// //sink开机函数
// rt_uint8_t chrg_com_sink_on(rt_uint8_t ch, struct chrg_switch_t *pSW, rt_uint8_t *enable){
// *enable = 1;
// pSW->id = ID_SINK;
// pSW->sub = IDX_SET_SINK_CURR;
// pSW->change_flag = 0x01;
// pSW->sink.work_on_step = 0;
// return 0;
// }
//source开机函数
rt_uint8_t chrg_com_source_on(rt_uint8_t ch, rt_uint8_t protoCmd, struct chrg_switch_t *pSW, rt_uint8_t *enable){
*enable = 1;
pSW->id = ID_SOURCE;
pSW->source.LCD_Set_Pro_Flag=3;
pSW->sub = IDX_SET_SOURCE_ID;
pSW->change_flag = 0x01;
pSW->continue_flag = 1;
return 0;
}
/*****************************************************************
函数名称: funcWriteProtoCal
函数描述: 写入协议
输入参数: reqFrame: 请求数据 reqLen: 请求长度 resFrame:响应数据 resLen:响应长度
输出参数: -
返回说明: -
其它说明: -
*****************************************************************/
eMBException funcWriteProtoCal (rt_uint8_t *reqFrame, rt_uint16_t reqLen,
rt_uint8_t *resFrame, rt_uint16_t *resLen)
{
/************ 局部变量定义 ************/
struct chrg_north_t *pNOR = &chrgnorth;
struct chrg_south_t *pSOU = &chrgsouth;
struct chrg_switch_t *pSW = RT_NULL;
rt_uint8_t slaveAddr = 0; // 从机地址(0x01~0xFF)
rt_uint8_t protoCmd = 0; // 协议命令码(0x11~0x1F/0x22~0x2C/0x2F)
rt_uint16_t regAddress = 0; // 寄存器起始地址
rt_uint8_t *pData = RT_NULL; // 协议数据区起始指针(状态+通道字段开始)
rt_uint8_t statusChByte = 0;// 状态+通道字节(reqFrame[5])
eIDX_SOU_CH ch = IDX_SOU_CH1;// 通道号(1~4)
rt_uint8_t chNum = 0; // 通道号数值(1~4)
rt_uint8_t devStatus = 0; // 设备状态(0=不变,1=开机,2=关机)
rt_uint8_t ccSel = 0; // CC线选择(0=CC1+CC2,1=CC1,2=CC2,3=断开)
// *g_proto_pData = RT_NULL;
g_proto_reqLen = 0;
// Modbus异常码
eMBException eStatus = MB_EX_NONE;
eMBErrorCode eRegStatus;
rt_uint16_t reg_offset = 0;
rt_uint16_t sout_reg = 0;
rt_uint16_t sou_value = 0;
/************ 校验 ************/
// 最小帧长度:地址(1)+命令码(1)+寄存器(2)+数据区(至少1)+校验(2) = 7字节
if (reqLen < 7) {
rt_kprintf("The long error:%d must more 7\n", reqLen);
return MB_EX_ILLEGAL_DATA_VALUE;
}
/************ 解析帧 ************/
slaveAddr = reqFrame[0]; // 从机地址(0x01~0xFF)
protoCmd = reqFrame[3]; // 协议命令码(负载0x11~0x1F,电源0x22~0x2C/0x2F)
rt_kprintf("pro=%04x\n",protoCmd);
pData = &reqFrame[4]; // 数据区起始(跳过地址+命令码+寄存器)
statusChByte = pData[0]; // 状态+通道字节(数据区第1字节)
/************ 地址校验 ************/
if (protoCmd < PRO_REG_START || protoCmd >= TOTAL_PROTOCAL_CNT) {
rt_kprintf("Address error:0x%04X\n", protoCmd);
return MB_EX_ILLEGAL_DATA_ADDRESS;
}
/************ 提取通道号和状态 ************/
// bit0-3:状态(0=不变,1=开机,2=关机)
devStatus = statusChByte & 0x0F;
rt_kprintf("status=%d",devStatus);
// bit4-7:通道号(1=CH1,2=CH2,3=CH3,4=CH4)
chNum = (statusChByte >> 4) & 0x0F;
ccSel = pData[1];
rt_uint8_t cv_mode = pData[2];
// 通道号合法性校验
if (chNum < 1 || chNum > 4) {
rt_kprintf("通道号非法:%d(仅支持1~4)\n", chNum);
return MB_EX_ILLEGAL_DATA_ADDRESS;
}
ch = (eIDX_SOU_CH)(chNum - 1); // 转换为枚举类型(IDX_SOU_CH1=0)
/************ 硬件结构体绑定 ************/
if (pNOR == RT_NULL) {
rt_kprintf("ERROR: pNOR is NULL!\n");
return MB_EX_SLAVE_DEVICE_FAILURE;
}
pSW = &pNOR->sw[ch]; // 绑定当前通道的协议配置结构体
pSW->protoCmd = protoCmd; //com端协议命令码
pSW->CV_mode = cv_mode; //恒压恒流模式选择
rt_memcpy(g_proto_pData, pData, reqLen - 4);
g_proto_reqLen = reqLen;
rt_kprintf("com_recitive\n");
/************ 按「负载/电源」分支解析 ************/
// ========== 负载协议解析 (0x11~0x1F) ==========
if (protoCmd >= 0x11 && protoCmd <= 0x1F) {
pSW->sink.cc_set = ccSel; //负载CC线选择
if(pSW->source.On_Flag){ //负载切电源
pSW->source.change_sink_Flag = 1;
chrg_sou_stop(ch,pSW,pNOR);
}else{
if(devStatus==2){ //负载关机
chrg_sou_stop(ch,pSW,pNOR);
}
else if(devStatus==1){ //负载开机
//chrg_com_sink_on(ch,pSW,&pNOR->enable[ch]);
}
}
}
// ==========电源协议解析 (0x22~0x2C/0x2F) ==========
else if ((protoCmd >= 0x22 && protoCmd <= 0x2C) || protoCmd == 0x2F) {
pSW->source.cc_set = ccSel; //电源CC线选择
if(pSW->sink.On_work){ //电源切负载
pSW->sink.change_source_flag = 1;
chrg_sou_stop(ch,pSW,pNOR);
}else{
if(devStatus==2){ //电源关机
chrg_sou_stop(ch,pSW,pNOR);
}else if(devStatus==1){ //电源开机
chrg_com_source_on(ch,pSW->protoCmd,pSW,&pNOR->enable[ch]);
}
}
}
// ========== 非法命令码 ==========
else {
rt_kprintf("非法协议命令码:0x%02X\n", protoCmd);
return MB_EX_ILLEGAL_FUNCTION;
}
// /************ 配置参数写入保持寄存器 ************/
eRegStatus = mb_reg_holding_cb(&reqFrame[4], &resFrame[3], regAddress, 1, MB_REG_WRITE);
if (eRegStatus != MB_ENOERR) {
eStatus = mb_error(eRegStatus);
rt_kprintf("寄存器写入失败:%d\n", eRegStatus);
}
/************ 构建响应帧 ************/
rt_memcpy(resFrame, reqFrame, reqLen);
*resLen = reqLen - 2; // 去掉CRC校验位
/************ 调试输出 ************/
// rt_kprintf("Pro Set OK:Ch=%d,Pro0x%02X,Status%d,CC Set%d\n",
// chNum, protoCmd, devStatus, ccSel);
return eStatus;
}
/*****************************************************************
函数名称: funcSinkTest
函数描述: 负载测试
输入参数: reqFrame: 请求数据 reqLen: 请求长度 resFrame:响应数据 resLen:响应长度
输出参数: -
返回说明: -
其它说明: -
*****************************************************************/
eMBException funcSinkTest (rt_uint8_t *reqFrame, rt_uint16_t reqLen,
rt_uint8_t *resFrame, rt_uint16_t *resLen)
{
/************ 局部变量定义 ************/
struct chrg_north_t *pNOR = &chrgnorth;
struct chrg_south_t *pSOU = &chrgsouth;
struct chrg_switch_t *pSW = RT_NULL;
rt_uint8_t slaveAddr = 0; // 从机地址
rt_uint8_t test_mode = 0; // 测试模式 0x01/0x02/0x03
rt_uint16_t regAddress = 0; // 寄存器地址
rt_uint8_t *pData = RT_NULL; // 数据区指针
rt_uint8_t statusChByte = 0; // 状态+通道字节
eIDX_SOU_CH ch = IDX_SOU_CH1; // 通道枚举
rt_uint8_t chNum = 0; // 通道号 1~4
rt_uint8_t devStatus = 0; // 设备状态 0=启动 1=停止,2=继续,3=结束
// Modbus异常
eMBException eStatus = MB_EX_NONE;
eMBErrorCode eRegStatus;
// /************ 长度校验 ************/
// if (reqLen < 11) {
// rt_kprintf("Len error:%d <11\n", reqLen);
// return MB_EX_ILLEGAL_DATA_VALUE;
// }
/************ 解析帧 ************/
slaveAddr = reqFrame[0];
test_mode = reqFrame[3]; // 测试命令:0x01短路 0x02OCP 0x03动态
pData = &reqFrame[4]; // 数据起始
statusChByte= pData[0]; // 状态通道字节
/************ 地址校验 ************/
if (test_mode < 0x01 || test_mode > 0x03) {
rt_kprintf("Test mode err:0x%02X\n", test_mode);
return MB_EX_ILLEGAL_DATA_ADDRESS;
}
/************ 解析状态 & 通道 ************/
devStatus = statusChByte & 0x0F; // 低4位:状态
chNum = (statusChByte >> 4) & 0x0F; // 高4位:通道
/************ 通道校验 ************/
if (chNum <1 || chNum>4) {
rt_kprintf("Ch err:%d\n", chNum);
return MB_EX_ILLEGAL_DATA_ADDRESS;
}
ch = (eIDX_SOU_CH)(chNum -1);
/************ 绑定结构体 ************/
pSW = &pNOR->sw[ch];
pSW->sink.test.test_mode = test_mode; //测试模式
pSW->sink.test.run_flag = devStatus; //设备状态
pSW->change_flag = 0x01;
struct test *pTset = &pSW->sink.test;
#if SINK_TEST_DEBUG
rt_kprintf("test_mode=%d\n",test_mode);
rt_kprintf("test_flag=%d\n",pTset->test_mode);
#endif
/*********************************************************/
// switch(test_mode)
// {
// case 0x01:
// // 短路测试(OCPC)
// sink_test_short_set(pSW, pData, devStatus);
// break;
// case 0x02:
// // OCP 测试
// sink_test_ocp_set(pSW, pData, devStatus);
// break;
// case 0x03:
// // 动态测试
// sink_test_dynamic_set(pSW, pData, devStatus);
// break;
// default:
// return MB_EX_ILLEGAL_FUNCTION;
// }
/************ 启动 / 停止控制 ************/
if(devStatus == 0) //启动
{
pNOR->enable[ch] = 1;
pSW->id = ID_SINK;
pSW->sink.test.work_step = 0;
pSOU->online[ch] = 1;
}
else if(devStatus == 1) //停止
{
pSW->id = ID_SINK;
pSW->sink.test.stop_step = 0;
rt_kprintf("Sink Test Stop CH%d\n", chNum);
}
/************ 响应帧 ************/
rt_memcpy(resFrame, reqFrame, reqLen-2);
*resLen = reqLen -2;
return eStatus;
}
/*****************************************************************
函数名称: funcWriteMultipleHoldingRegister
函数描述: 写多个保持寄存器(0x10)
@@ -2170,7 +1798,6 @@ static void chrg_mb_write_src(rt_uint8_t ch, rt_uint16_t reg_offset, rt_uint16_t
{
case SRC_REG_PROTOCOL: // 0x00: 协议
pSW->source.protocol = src_proto_lookup(sou_value);
pSW->source.Set_Pro_Flag = 1;
pSW->protoCmd = (rt_uint8_t)sou_value;
// rt_kprintf("[SRC CH%d] Protocol=0x%02X -> 0x%02X\n", ch + 1, sou_value, pSW->source.protocol);
break;
@@ -2228,7 +1855,6 @@ static eMBException chrg_mb_write_sys(rt_uint8_t ch, rt_uint16_t reg_offset, rt_
else if (sou_value == 0x02)
{
pSW->id = ID_SOURCE;
pSW->source.Set_Pro_Flag = 1;
}
break;
@@ -2271,7 +1897,7 @@ static eMBException chrg_mb_write_sys(rt_uint8_t ch, rt_uint16_t reg_offset, rt_
if (sink_work == 0x01) // 负载启动
{
rt_uint8_t curr_test = pReal->sink.test.test_mode;
rt_uint8_t curr_test_old = pReal->sink.test.test_mode_old;
rt_uint8_t curr_test_old = pReal->sink.test.test_mode_old;
// 测试模式状态发生切换:0<->非0
if ((curr_test_old == 0 && curr_test != 0) || (curr_test == 0 && curr_test_old != 0))
{
@@ -2334,11 +1960,15 @@ static eMBException chrg_mb_write_sys(rt_uint8_t ch, rt_uint16_t reg_offset, rt_
}
else if (new_id == ID_SOURCE && source_work == 0x01)
{
chrg_com_source_on(ch, pReal->protoCmd, pReal, &pNOR->enable[ch]);
/* COM只触发状态,初始化命令由Source状态机统一下发。 */
pReal->source.On_Flag = 1;
pReal->source.work_mode = SOURCE_WORK_INIT;
}
else if (new_id == ID_SOURCE && source_work == 0x00)
{
chrg_sou_stop(ch, pReal, pNOR);
/* 停止动作同样交给状态机处理,避免COM直接控制硬件。 */
pReal->source.On_Flag = 0;
pReal->source.work_mode = SOURCE_WORK_STOP;
}
rt_mutex_release(pTHR_NOR->mutex);
}