954 lines
50 KiB
C++
954 lines
50 KiB
C++
#ifndef SYSTEMDATA_H
|
|
#define SYSTEMDATA_H
|
|
#include "pmSysvariable.h"
|
|
#include "sqlit3/SQLite.h"
|
|
#include <set>
|
|
#include <mutex>
|
|
#define DEBUFG
|
|
class SystemData
|
|
{
|
|
private:
|
|
SQLite* m_db;
|
|
std::set<unsigned int> sysFaultCodes;
|
|
mutable std::mutex sysFaultCodesMutex;
|
|
public:
|
|
/**
|
|
* @brief 向系统故障码集合中插入一个故障码
|
|
* @param faultCode 要插入的故障码
|
|
*/
|
|
void insertFaultCode(unsigned int faultCode) {
|
|
std::lock_guard<std::mutex> lock(sysFaultCodesMutex);
|
|
sysFaultCodes.insert(faultCode);
|
|
}
|
|
/**
|
|
* @brief 从系统故障码集合中消除一个故障码
|
|
* @param faultCode 要消除的故障码
|
|
*/
|
|
void eraseFaultCode(unsigned int faultCode) {
|
|
std::lock_guard<std::mutex> lock(sysFaultCodesMutex);
|
|
sysFaultCodes.erase(faultCode);
|
|
}
|
|
/**
|
|
* @brief 获取系统当前的故障等级
|
|
* @return uint8_t 故障等级，00H-无故障, 10H-一级, 20H-二级, 30H-三级, 40H-四级
|
|
*/
|
|
uint8_t getFaultCodeLevel() const {
|
|
uint8_t maxLevel = 0;
|
|
// 遍历 sysFaultCodes 集合中的每个故障码
|
|
for (auto code : sysFaultCodes) {
|
|
// 提取0xabcd中的b位 (右移8位后取低4位)
|
|
uint8_t level = (code >> 8) & 0xF;
|
|
if (level > maxLevel) {
|
|
maxLevel = level;
|
|
}
|
|
}
|
|
return maxLevel;
|
|
}
|
|
/**
|
|
* @brief 获取系统当前的故障码集合
|
|
* @return std::set<unsigned int>& 系统当前的故障码集合
|
|
*/
|
|
const std::set<unsigned int>& getFaultCode() const {
|
|
return sysFaultCodes;
|
|
}
|
|
//燃料电池系统参数
|
|
uint8_t fc_mode; // 燃料电池系统运行模式：00H-无效, 01H-调试, 02H-自动, 03H-补给
|
|
uint8_t fc_status; // 燃料电池状态：00H-无效, 01H-初始化, ..., 0DH-维护完成
|
|
uint8_t fc_fault_level; // 燃料电池故障等级：00H-无故障, 10H-一级, 20H-二级, 30H-三级, 40H-四级
|
|
|
|
//功率和时间参数
|
|
float output_power_limit; // 系统输出功率限制值，单位：W
|
|
float total_generation_time; // 系统累计发电时间，单位：0.1小时
|
|
float total_generation_power; // 系统累计发电总功率，单位：W
|
|
|
|
//故障信息
|
|
uint16_t fc_fault_level_1; // 一级故障位
|
|
uint16_t fc_fault_level_2; // 二级故障位
|
|
uint16_t fc_fault_level_3; // 三级故障位
|
|
uint16_t fc_fault_level_4; // 四级故障位
|
|
|
|
//燃料容量
|
|
float hydrogen_capacity; // 储氢罐剩余容量百分比，单位：%
|
|
float liquid_oxygen_capacity; // 液氧罐剩余容量百分比，单位：%
|
|
|
|
//温度压力参数
|
|
float palladium_temp; // 钯膜最高温度，单位：℃
|
|
float main_pipe_pressure; // 主水路压力，单位：0.01kPa
|
|
float aux_pipe_pressure; // 辅水路压力，单位：0.01kPa
|
|
|
|
//舱室环境参数
|
|
float cabin_pressure1; // 舱室1压力，单位：0.01kPa
|
|
float cabin_pressure2; // 舱室2压力，单位：0.01kPa
|
|
float cabin_temp1; // 舱室1温度，单位：0.01℃
|
|
float cabin_temp2; // 舱室2温度，单位：0.01℃
|
|
float cabin_humidity1; // 舱室1湿度，单位：0.01%RH
|
|
float cabin_humidity2; // 舱室2湿度，单位：0.01%RH
|
|
|
|
//火焰探测器
|
|
uint8_t flame_detector1; // 火焰探测器1状态：00H-无效, 01H-报警, 02H-故障
|
|
uint8_t flame_detector2; // 火焰探测器2状态：00H-无效, 01H-报警, 02H-故障
|
|
|
|
//气体浓度
|
|
float h2_concentration1; // 舱室H2浓度1，单位：0.01% LEL
|
|
float h2_concentration2; // 舱室H2浓度2，单位：0.01% LEL
|
|
float h2_concentration3; // 舱室H2浓度3，单位：0.01% LEL
|
|
float o2_concentration1; // 舱室O2浓度1，单位：0.01% LEL
|
|
float o2_concentration2; // 舱室O2浓度2，单位：0.01% LEL
|
|
float ch3oh_concentration1; // 舱室甲醇气体浓度1，单位：0.01% LEL
|
|
float ch3oh_concentration2; // 舱室甲醇气体浓度2，单位：0.01% LEL
|
|
|
|
//保留字段
|
|
float reserved1[10]; // 保留字段
|
|
float cabin_ox_concentration; // 仪表舱内氧气浓度，单位：0.1%
|
|
float cabin_temperature; // 仪表舱内温度，单位：0.1℃
|
|
float cabin_humidity; // 仪表舱内湿度，单位：0.1%RH
|
|
float cabin_pressure; // 仪表舱内大气压，单位：0.2kPa
|
|
|
|
//动力舱参数
|
|
float power_cabin_ox_concentration; // 动力舱内氧气浓度，单位：0.1%
|
|
float power_cabin_temperature; // 动力舱内温度，单位：0.1℃
|
|
float power_cabin_humidity; // 动力舱内湿度，单位：0.1%RH
|
|
float power_cabin_pressure; // 动力舱内大气压，单位：0.2kPa
|
|
uint8_t reserved2[2]; // 保留字段
|
|
|
|
//电池报警标志
|
|
uint8_t dyn_alarm_flag[6]; // 动力锂电池报警标志
|
|
uint8_t ins_alarm_flag[6]; // 仪表锂电池报警标志
|
|
|
|
//继电器状态
|
|
uint8_t ins_relay_status1; // 仪表电池继电器状态
|
|
uint8_t ins_relay_status2; // 仪表电池预充继电器和负极继电器状态
|
|
uint8_t dyn_relay_status1; // 动力电池正极与充电继电器状态
|
|
uint8_t dyn_relay_status2; // 动力电池预充与负极继电器状态
|
|
|
|
//仪表电池继电器状态
|
|
uint8_t ins_pos_relay_status; // 仪表电池正极继电器状态 (X0H:无效 X1H:接通 X2H:断开)
|
|
uint8_t ins_charge_relay_status; // 仪表电池充电继电器状态 (0XH:无效 1XH:接通 2XH:断开)
|
|
uint8_t ins_precharge_relay_status; // 仪表电池预充继电器状态 (X0H:无效 X1H:接通 X2H:断开)
|
|
uint8_t ins_neg_relay_status; // 仪表电池负极继电器状态 (0XH:无效 1XH:接通 2XH:断开)
|
|
|
|
//动力电池继电器状态
|
|
uint8_t dyn_pos_relay_status; // 动力电池正极继电器状态 (X0H:无效 X1H:接通 X2H:断开)
|
|
uint8_t dyn_charge_relay_status; // 动力电池充电继电器状态 (0XH:无效 1XH:接通 2XH:断开)
|
|
uint8_t dyn_precharge_relay_status; // 动力电池预充继电器状态 (X0H:无效 X1H:接通 X2H:断开)
|
|
uint8_t dyn_neg_relay_status; // 动力电池负极继电器状态 (0XH:无效 1XH:接通 2XH:断开)
|
|
|
|
//电池功率参数
|
|
float ins_max_discharge_power; // 仪表电池最大允许放电功率，单位：0.05kW
|
|
float dyn_max_discharge_power; // 动力电池最大允许放电功率，单位：0.05kW
|
|
|
|
//电池SOC
|
|
int ins_soc; // 仪表锂电池荷电状态SOC，范围：0~100
|
|
int dyn_soc; // 动力锂电池荷电状态SOC，范围：0~100
|
|
|
|
//电池能量
|
|
float ins_total_energy; // 仪表电池总能量，单位：0.1kWh
|
|
float dyn_total_energy; // 动力电池总能量，单位：0.1kWh
|
|
|
|
//电池输入功率
|
|
float ins_power_input; // 仪表电池输入功率，单位：0.1kW
|
|
float dyn_power_input; // 动力电池输入功率，单位：0.1kW
|
|
|
|
//电池充放电状态
|
|
uint8_t ins_charge_status; // 仪表电池充放电状态：00H-无效，10H-充电，20H-放电
|
|
uint8_t dyn_charge_status; // 动力电池充放电状态：00H-无效，10H-充电，20H-放电
|
|
|
|
//电池电压电流
|
|
float ins_voltage_link; // 仪表电池LINK端电压，单位：0.01V
|
|
float ins_voltage_pack; // 仪表电池PACK端电压，单位：0.01V
|
|
float ins_current; // 仪表电池电流，单位：0.01A
|
|
float ins_resistance_pos; // 仪表电池正极绝缘电阻，单位：kΩ
|
|
float ins_resistance_neg; // 仪表电池负极绝缘电阻，单位：kΩ
|
|
float dyn_voltage_link; // 动力电池LINK端电压，单位：0.01V
|
|
float dyn_voltage_pack; // 动力电池PACK端电压，单位：0.01V
|
|
float dyn_current; // 动力电池电流，单位：0.05A
|
|
float dyn_resistance_pos; // 动力电池正极绝缘电阻，单位：kΩ
|
|
float dyn_resistance_neg; // 动力电池负极绝缘电阻，单位：kΩ
|
|
|
|
//紧急状态
|
|
uint8_t ins_emergency_status; // 仪表电池紧急状态
|
|
uint8_t dyn_emergency_status; // 动力电池紧急状态
|
|
|
|
//保留字段
|
|
uint8_t reserved3[2]; // 保留字段
|
|
float ins_soc_threshold1; // 仪表电池1 SOC门限
|
|
float ins_soc_threshold2; // 仪表电池2 SOC门限
|
|
float ins_soc_threshold3; // 仪表电池3 SOC门限
|
|
float dyn_soc_threshold1; // 动力电池1 SOC门限
|
|
float dyn_soc_threshold2; // 动力电池2 SOC门限
|
|
float dyn_soc_threshold3; // 动力电池3 SOC门限
|
|
float ins_power_limit1; // 仪表电池1功率限制值
|
|
float ins_power_limit2; // 仪表电池2功率限制值
|
|
float dyn_power_limit1; // 动力电池1功率限制值
|
|
float dyn_power_limit2; // 动力电池2功率限制值
|
|
|
|
//设备在线状态
|
|
uint32_t device_online_flag1; // 设备在线状态标志1
|
|
uint32_t device_online_flag2; // 设备在线状态标志2
|
|
|
|
//其他锂电池状态
|
|
uint8_t dyn_charge_level; // 动力电池充电状态：01H-1级(不限), 02H-2级(限功率), 03H-3级(关闭)
|
|
uint8_t dyn_water_leak_status; // 动力漏水状态：0XH-正常, 1XH-异常漏水
|
|
uint8_t ins_water_leak_dcdc_status; // 仪表漏水状态与DCDC状态：低4位-漏水状态(0XH正常,1XH异常),高4位-DCDC状态(X0H正常,X1H故障)
|
|
uint8_t reserved4;
|
|
|
|
unsigned char water_leak_status_from_insbat; // 仪表漏水状态
|
|
unsigned char water_leak_status_from_dynbat; // 动力漏水状态
|
|
unsigned char dcdc_status_from_insbat; // 仪表DCDC状态
|
|
|
|
//保留字段
|
|
// uint32_t reserved4; // 保留字段
|
|
uint32_t heartbeat; // 主机心跳计数器
|
|
|
|
//锂电池故障字段
|
|
unsigned char powfaultCode;
|
|
unsigned char insfaultCode;
|
|
|
|
|
|
//应急电池
|
|
double emergency_battery1_voltage; // 应急电池1总电压 [V]
|
|
double emergency_battery1_current; // 应急电池1总电流 [A]
|
|
double emergency_battery1_max_temp; // 应急电池1最高温度 [°C]
|
|
uint16_t emergency_battery1_fault_word; // 应急电池1故障字
|
|
double emergency_battery2_voltage; // 应急电池2总电压 [V]
|
|
double emergency_battery2_current; // 应急电池2总电流 [A]
|
|
double emergency_battery2_max_temp; // 应急电池2最高温度 [°C]
|
|
uint16_t emergency_battery2_fault_word; // 应急电池2故障字
|
|
|
|
// MOOSD 状态
|
|
bool moosd_status;
|
|
//配电系统状态
|
|
//DC/DC状态字
|
|
struct DcdcStatus
|
|
{
|
|
// DC/DC5故障字低
|
|
union {
|
|
unsigned char lowFaultWord;
|
|
struct {
|
|
bool overTemperatureShutdown : 1; // Bit0: DC/DC模块过温关机
|
|
bool outputOverCurrent : 1; // Bit1: 输出过流
|
|
bool outputOverVoltage : 1; // Bit2: 输出过压
|
|
bool outputUnderVoltage : 1; // Bit3: 输出欠压
|
|
bool inputOverVoltage : 1; // Bit4: 输入过压
|
|
bool inputUnderVoltage : 1; // Bit5: 输入欠压
|
|
bool outputShortCircuit : 1; // Bit6: 输出短路保护
|
|
bool internalFault : 1; // Bit7: 内部故障
|
|
};
|
|
};
|
|
// DC/DC5故障字高
|
|
union {
|
|
unsigned char highFaultWord;
|
|
struct {
|
|
bool communicationFault : 1; // Bit0: 通讯故障报警
|
|
bool workingStatus : 1; // Bit1: 工作状态(1:启动, 0:关闭)
|
|
bool coolingPump1Fault : 1; // Bit2: 冷却泵1故障
|
|
bool coolingPump2Fault : 1; // Bit3: 冷却泵2故障
|
|
bool coolingWaterLeak : 1; // Bit4: 冷却水泄露
|
|
bool coolingPump1Running : 1; // Bit5: 冷却泵1运行状态
|
|
bool coolingPump2Running : 1; // Bit6: 冷却泵2运行状态
|
|
bool reserved : 1; // Bit7: 保留位
|
|
};
|
|
};
|
|
|
|
// 构造函数，初始化所有状态为正常
|
|
DcdcStatus() : lowFaultWord(0x00), highFaultWord(0x00) {}
|
|
} m_dcdcStatus;
|
|
|
|
|
|
//动力母线状态
|
|
struct POWER_BUS_STATUS
|
|
{
|
|
// 5: 燃料电池断路器 0 断开 1 闭合 2 故障
|
|
unsigned char fuelCellCircuitBreaker;
|
|
// 6: 动力锂电池断路器 0 断开 1 闭合 2 故障
|
|
unsigned char powerLithiumBatteryCircuitBreaker;
|
|
// 7: 推进电机断路器 0 断开 1 闭合 2 故障
|
|
unsigned char propulsionMotorCircuitBreaker;
|
|
// 8: 锂电池组仪表断路器 0 断开 1 闭合 2 故障
|
|
unsigned char lithiumBatteryGroupInstrumentCircuitBreaker;
|
|
// 9: DC/DC5模块断路器 0 断开 1 闭合 2 故障
|
|
unsigned char dcDc5ModuleCircuitBreaker;
|
|
// 10: 艏部高压配电箱断路器 0 断开 1 闭合 2 故障
|
|
unsigned char bowHighVoltageDistributionBoxCircuitBreaker;
|
|
// 11: 艉部FT装置4/5断路器 0 断开 1 闭合 2 故障
|
|
unsigned char sternFTDevice45CircuitBreaker;
|
|
// 12: 艉舵开关1断路器 0 断开 1 闭合 2 故障
|
|
unsigned char sternRudderSwitch1CircuitBreaker;
|
|
// 13: 艉舵开关2断路器 0 断开 1 闭合 2 故障
|
|
unsigned char sternRudderSwitch2CircuitBreaker;
|
|
// 14: FB预留断路器 0 断开 1 闭合 2 故障
|
|
unsigned char fbReservedCircuitBreaker;
|
|
// 15: TYZ预留断路器 0 断开 1 闭合 2 故障
|
|
unsigned char tyzReservedCircuitBreaker;
|
|
// 16: 预留断路器 0 断开 1 闭合 2 故障
|
|
unsigned char reservedCircuitBreaker;
|
|
// 17: DC/DC5模块状态 0 未运行；1 运行；2 DC/DC模块过温关机；3 输出过流；4 输出过压；5 输出欠压；6 输入过压；7 输入欠压；8 输出短路保护；9 内部故障
|
|
unsigned char dcDcModuleStatus;
|
|
// 18：冷却系统状态 0 未运行 1 运行 2 冷却泵1故障 3 冷却泵2故障 4 冷却水泄露
|
|
unsigned char coolingSystemStatus;
|
|
// 19: 动力母排绝缘状态 0 正常 1 绝缘低
|
|
unsigned char powerBusInsulationStatus;
|
|
// 20: A汇流排绝缘状态 0 正常 1 绝缘低
|
|
unsigned char aBusInsulationStatus;
|
|
// 21: 仪表电源状态 0 正常 1 故障
|
|
unsigned char meterPowerLossSignal;
|
|
// 22: 应急电源状态 0 正常 1 故障
|
|
unsigned char emergencyPowerLossSignal;
|
|
// 22: dc/dc温度
|
|
float dcDcTemperature;
|
|
// 23: 动力汇流排电压
|
|
float powerBusVoltage;
|
|
// 24: DC/DC5模块电流
|
|
float dcDc5ModuleCurrent;
|
|
// 25: 动力汇流排电流
|
|
float powerBusCurrent;
|
|
// 26: A汇流排电压
|
|
float busbarAVoltage;
|
|
// 27: 推进电机控制箱电流
|
|
float propulsionMotorControlBoxCurrent;
|
|
// 28: A汇流排电流
|
|
float busbarACurrent;
|
|
// 29: 锂电池组(仪表)电流
|
|
float lithiumBatteryGroupMeterCurrent;
|
|
// 30: 艏部高压配电箱电流
|
|
float bowHighVoltageDistributionBoxCurrent;
|
|
// 31: 艉部FT装置4/5电流
|
|
float sternFTDevice45Current;
|
|
// 32: TYZ预留开关电流
|
|
float tyzReservedSwitchCurrent;
|
|
// 33: 艉舵开关1电流
|
|
float sternRudderSwitch1Current;
|
|
// 34: 预留电流
|
|
float reservedCurrent1; // 改为 reservedCurrent1 以避免重名
|
|
// 35: 艉舵开关2电流
|
|
float sternRudderSwitch2Current;
|
|
// 36: 预留电流2
|
|
float reservedCurrent2; // 改为 reservedCurrent2 以避免重名
|
|
// 37: FB预留电流
|
|
float fbReservedSwitchCurrent;
|
|
// 38: 预留电流3
|
|
float reservedCurrent3; // 改为 reservedCurrent3 以避免重名
|
|
// 39: 冷却水压力
|
|
float coolWaterPressure;
|
|
}power_bus_status;
|
|
|
|
struct POWER_A_BUS_STATUS
|
|
{
|
|
//动力汇流排状态
|
|
//5. 艏部FT装置1/2/3断路器 0 断开 1 闭合 2 故障
|
|
unsigned char bowFTDevice123CircuitBreaker;
|
|
//6. 启闭机构断路器 0 断开 1 闭合 2 故障
|
|
unsigned char actuatorCircuitBreaker;
|
|
//7. 桅杆舵机控制箱断路器 0 断开 1 闭合 2 故障
|
|
unsigned char mastSteeringGearControlBoxCircuitBreaker;
|
|
//8. XCZ断路器 0 断开 1 闭合 2 故障
|
|
unsigned char xczCircuitBreaker;
|
|
//9. 艏舵控制箱断路器 0 断开 1 闭合 2 故障
|
|
unsigned char bowRudderControlBoxCircuitBreaker;
|
|
//10. 敞水盖启动电缸断路器 0 断开 1 闭合 2 故障
|
|
unsigned char openWaterCoverStartCylinderCircuitBreaker;
|
|
//11. 仪表电源失电信号 0 正常 1 故障
|
|
unsigned char instrumentPowerFailureSignal;
|
|
//12. 应急电源失电信号 0 正常 1 故障
|
|
unsigned char emergencyPowerFailureSignal;
|
|
//13. 浸水报警 0 无 1 有
|
|
unsigned char waterIngressionAlarm;
|
|
//14. 汇流排B电压
|
|
float busbarBVoltage;
|
|
//15. 汇流排B电流
|
|
float busbarBCurrent;
|
|
//16. 艏部FT装置1/2/3电流
|
|
float bowFTDevice123Current;
|
|
//17. 启闭机构电流
|
|
float actuatorCurrent;
|
|
//18. 桅杆舵机控制箱电流
|
|
float mastSteeringGearControlBoxCurrent;
|
|
//19. XCZ电流
|
|
float xczCurrent;
|
|
//20. 艏舵控制箱电流
|
|
float bowRudderControlBoxCurrent;
|
|
//21. 敞水盖启动电缸电流
|
|
float openWaterCoverStartCylinderCurrent;
|
|
} power_a_bus_status;
|
|
|
|
//仪表主母线状态
|
|
struct INSTRUMENT_MAIN_BUS_STATUS
|
|
{
|
|
//5. 锂电池组（仪表）断路器 0 断开 1 闭合 2 故障
|
|
unsigned char lithiumBatteryGroupInstrumentCircuitBreaker;
|
|
//6. 艏部低压配电箱断路器 0 断开 1 闭合 2 故障
|
|
unsigned char bowLowVoltageDistributionBoxCircuitBreaker;
|
|
//7. UNIT4仪表DC48V断路器 0 断开 1 闭合 2 故障
|
|
unsigned char unit4InstrumentDC48VCircuitBreaker;
|
|
//8. DC-C1直流配电板断路器 0 断开 1 闭合 2 故障
|
|
unsigned char dcC1DCDistributionPanelCircuitBreaker;
|
|
//9. 预留断路器1 0 断开 1 闭合 2 故障
|
|
unsigned char reservedCircuitBreaker1; // 为了区分，添加了数字后缀
|
|
//10. 预留断路器2 0 断开 1 闭合 2 故障
|
|
unsigned char reservedCircuitBreaker2; // 为了区分，添加了数字后缀
|
|
//11. 应急锂电池组2断路器 0 断开 1 闭合 2 故障
|
|
unsigned char emergencyLithiumBatteryGroup2CircuitBreaker;
|
|
//12. 仪表电源失电信号 0 正常 1 故障
|
|
unsigned char instrumentPowerFailureSignal;
|
|
//13. 应急电源失电信号 0 正常 1 故障
|
|
unsigned char emergencyPowerFailureSignal;
|
|
//14. 仪表汇流排绝缘低 0 正常 1 绝缘低
|
|
unsigned char instrumentBusbarInsulationLow;
|
|
//15. 仪表母排电压
|
|
float instrumentBusbarVoltage;
|
|
//16. 艏部低压配电箱电流
|
|
float bowLowVoltageDistributionBoxCurrent;
|
|
//17. DC-C1（直流配电板1）仪表DC48V电流
|
|
float dcC1InstrumentDC48VCurrent;
|
|
//18. 预留电流
|
|
float reservedCurrent1; // 为了区分，添加了数字后缀
|
|
//19. 应急锂电池组2电流
|
|
float emergencyLithiumBatteryGroup2Current;
|
|
//20. 锂电池组（仪表）电流
|
|
float lithiumBatteryGroupInstrumentCurrent;
|
|
//21. UNIT4仪表DC48V电流
|
|
float unit4InstrumentDC48VCurrent;
|
|
//22. Ushort 预留电流
|
|
float reservedCurrent2; // 为了区分，添加了数字后缀
|
|
//23. 应急2汇流排电压
|
|
float emergency2BusbarVoltage;
|
|
//24. 复合能源管控系统应急DC48V电流
|
|
float compositeEnergyManagementSystemEmergencyDC48VCurrent;
|
|
//25. 燃料电池安全系统应急DC48V电流
|
|
float fuelCellSecuritySystemEmergencyDC48VCurrent;
|
|
//26. PLC控制电源电流
|
|
float plcControlPowerCurrent;
|
|
} instrument_main_bus_status;
|
|
|
|
//仪表汇流排状态
|
|
struct INSTRUMENT_BUS_STATUS
|
|
{
|
|
//5. UNIT1断路器 0 断开 1 闭合 2 故障
|
|
unsigned char unit1CircuitBreaker;
|
|
//6. UNIT2断路器 0 断开 1 闭合 2 故障
|
|
unsigned char unit2CircuitBreaker;
|
|
//7. UNIT3断路器 0 断开 1 闭合 2 故障
|
|
unsigned char unit3CircuitBreaker;
|
|
//8. UNIT5断路器 0 断开 1 闭合 2 故障
|
|
unsigned char unit5CircuitBreaker;
|
|
//9. 艏部PZ装置断路器 0 断开 1 闭合 2 故障
|
|
unsigned char bowPZDeviceCircuitBreaker;
|
|
//10. 预留断路器1 0 断开 1 闭合 2 故障
|
|
unsigned char reservedCircuitBreaker1; // 为了区分，添加了数字后缀
|
|
//11. 预留断路器2 0 断开 1 闭合 2 故障
|
|
unsigned char reservedCircuitBreaker2; // 为了区分，添加了数字后缀
|
|
//12. 应急锂电池组1断路器 0 断开 1 闭合 2 故障
|
|
unsigned char emergencyLithiumBatteryGroup1CircuitBreaker;
|
|
//13. 仪表电源失电信号 0 正常 1 故障
|
|
unsigned char powerFailureSignal;
|
|
//14. 应急电源失电信号 0 正常 1 故障
|
|
unsigned char emergencyPowerFailureSignal;
|
|
//15. 浸水报警 0 无 1 有
|
|
unsigned char waterIngressionAlarm;
|
|
//16. 仪表母排电压
|
|
float instrumentBusbarVoltage;
|
|
//17. 仪表母排电流
|
|
float instrumentBusbarCurrent;
|
|
//18. UNIT1电流
|
|
float unit1Current;
|
|
//19. UNIT2电流
|
|
float unit2Current;
|
|
//20. UNIT3电流
|
|
float unit3Current;
|
|
//21. UNIT5电流
|
|
float unit5Current;
|
|
//22. 艏部PZ装置电流
|
|
float bowPZDeviceCurrent;
|
|
//23. 应急锂电池组1电流
|
|
float emergencyLithiumBatteryGroup1Current;
|
|
//24. 应急1汇流排电压
|
|
float emergency1BusbarVoltage;
|
|
} instrument_bus_status;
|
|
|
|
struct COMMON_STATUS
|
|
{
|
|
//超时状态
|
|
bool isTimeout;
|
|
//最后更新时间
|
|
double lastUpdateTime;
|
|
};
|
|
|
|
struct DeviceCommonStatus
|
|
{
|
|
COMMON_STATUS ccu_status;
|
|
COMMON_STATUS dis_hv_c1;
|
|
COMMON_STATUS dis_hv_c2;
|
|
COMMON_STATUS dis_lv_c1;
|
|
COMMON_STATUS dis_lv_c2;
|
|
} device_common_status;
|
|
|
|
struct DeviceOnlineStatus
|
|
{
|
|
//在线状态
|
|
//0x00: 未上线
|
|
//0x01: 在线
|
|
//0x02: 上线后掉线
|
|
uint8_t ins_online_state; //仪表锂电在线标志位
|
|
uint8_t dyn_online_state; //动力锂电在线标志位
|
|
uint8_t fuel_online_state; //燃电锂电在线标志位
|
|
uint8_t high_voltage_online_state; //高压配电板在线标志位
|
|
uint8_t low_voltage_online_state; //低压配电板在线标志位
|
|
uint8_t composite_online_state; //复合管控主机在线标志位
|
|
uint8_t composite_backup_online_state; //复合管控备机在线标志位
|
|
} device_online_status;
|
|
|
|
enum LeakageStatus {
|
|
LEAKAGE_BOW_EMERGENCY = 0, // 艏部应急漏水 (0x01)
|
|
LEAKAGE_BOW_HIGH_VOLTAGE, // 艏高压漏水 (0x02)
|
|
LEAKAGE_BOW_LOW_VOLTAGE, // 艏低压漏水 (0x04)
|
|
LEAKAGE_FUEL_CELL, // 燃电舱漏水 (0x08)
|
|
LEAKAGE_LI_BATTERY, // 锂电池舱漏水 (0x10)
|
|
LEAKAGE_STERN_EMERGENCY, // 艉应急漏水 (0x20)
|
|
LEAKAGE_FUEL_CELL_CABIN, // 燃料电池舱漏水 (0x40)
|
|
LEAKAGE_BOW_EMERGENCY2 // 艏部应急漏水2 (0x80)
|
|
};
|
|
|
|
unsigned char leakageCode = 0;
|
|
bool leakStatus[8] = {false};
|
|
|
|
unsigned char generateLeakageCode() {
|
|
unsigned char code = 0;
|
|
if(leakStatus[LEAKAGE_BOW_EMERGENCY]) code |= 0x01;
|
|
if(leakStatus[LEAKAGE_BOW_HIGH_VOLTAGE]) code |= 0x02;
|
|
if(leakStatus[LEAKAGE_BOW_LOW_VOLTAGE]) code |= 0x04;
|
|
if(leakStatus[LEAKAGE_FUEL_CELL]) code |= 0x08;
|
|
if(leakStatus[LEAKAGE_LI_BATTERY]) code |= 0x10;
|
|
if(leakStatus[LEAKAGE_STERN_EMERGENCY]) code |= 0x20;
|
|
if(leakStatus[LEAKAGE_FUEL_CELL_CABIN]) code |= 0x40;
|
|
if(leakStatus[LEAKAGE_BOW_EMERGENCY2]) code |= 0x80;
|
|
return code;
|
|
}
|
|
public:
|
|
SystemData(){
|
|
//初始化变量全部为0
|
|
memset(this, 0, sizeof(SystemData));
|
|
disSysFaultCode.clear();
|
|
sysFaultCodes.clear();
|
|
};
|
|
~SystemData(){};
|
|
|
|
void updateCommonStatus(double time_out=10){
|
|
//更新时间
|
|
double currentTime = MOOSTime();
|
|
//判断是否超时
|
|
device_common_status.ccu_status.isTimeout = abs(currentTime - device_common_status.ccu_status.lastUpdateTime) > time_out;
|
|
device_common_status.dis_hv_c1.isTimeout = abs(currentTime - device_common_status.dis_hv_c1.lastUpdateTime) > time_out;
|
|
device_common_status.dis_hv_c2.isTimeout = abs(currentTime - device_common_status.dis_hv_c2.lastUpdateTime) > time_out;
|
|
device_common_status.dis_lv_c1.isTimeout = abs(currentTime - device_common_status.dis_lv_c1.lastUpdateTime) > time_out;
|
|
device_common_status.dis_lv_c2.isTimeout = abs(currentTime - device_common_status.dis_lv_c2.lastUpdateTime) > time_out;
|
|
};
|
|
|
|
void updateSystemData(ccuState data){
|
|
|
|
fc_mode = data.fc_mode;
|
|
fc_status = data.fc_status;
|
|
fc_fault_level = data.fc_fault_level;
|
|
|
|
//功率和时间参数
|
|
output_power_limit = data.output_power_limit;
|
|
total_generation_time = data.total_generation_time * 0.1;
|
|
total_generation_power = data.total_generation_power;
|
|
|
|
//故障信息
|
|
#ifdef DEBUG
|
|
fc_fault_level_1 = data.fault_level_1;
|
|
fc_fault_level_2 = data.fault_level_2;
|
|
fc_fault_level_3 = data.fault_level_3;
|
|
fc_fault_level_4 = data.fault_level_4;
|
|
#endif
|
|
|
|
//燃料容量
|
|
hydrogen_capacity = static_cast<int>(data.hydrogen_capacity);
|
|
liquid_oxygen_capacity = static_cast<int>(data.liquid_oxygen_capacity);
|
|
|
|
//温度压力参数
|
|
palladium_temp = data.palladium_temp;
|
|
main_pipe_pressure = data.main_pipe_pressure * 0.01;
|
|
aux_pipe_pressure = data.aux_pipe_pressure * 0.01;
|
|
|
|
//舱室环境参数
|
|
cabin_pressure1 = data.cabin_pressure1 * 0.01;
|
|
cabin_pressure2 = data.cabin_pressure2 * 0.01;
|
|
cabin_temp1 = data.cabin_temp1 * 0.01;
|
|
cabin_temp2 = data.cabin_temp2 * 0.01;
|
|
cabin_humidity1 = data.cabin_humidity1 * 0.01;
|
|
cabin_humidity2 = data.cabin_humidity2 * 0.01;
|
|
|
|
//火焰探测器
|
|
flame_detector1 = data.flame_detector1;
|
|
flame_detector2 = data.flame_detector2;
|
|
|
|
//气体浓度
|
|
h2_concentration1 = data.h2_concentration1 * 0.01;
|
|
h2_concentration2 = data.h2_concentration2 * 0.01;
|
|
h2_concentration3 = data.h2_concentration3 * 0.01;
|
|
o2_concentration1 = data.o2_concentration1 * 0.01;
|
|
o2_concentration2 = data.o2_concentration2 * 0.01;
|
|
ch3oh_concentration1 = data.ch3oh_concentration1 * 0.01;
|
|
ch3oh_concentration2 = data.ch3oh_concentration2 * 0.01;
|
|
|
|
//保留字段
|
|
for(int i=0; i<10; i++) {
|
|
reserved1[i] = data.reserved1[i];
|
|
}
|
|
|
|
//仪表舱参数
|
|
cabin_ox_concentration = data.cabin_ox_concentration * 0.1;
|
|
cabin_temperature = static_cast<int16_t>(data.cabin_temperature) * 0.1;
|
|
cabin_humidity = data.cabin_humidity * 0.1;
|
|
cabin_pressure = data.cabin_pressure * 0.2;
|
|
|
|
//动力舱参数
|
|
power_cabin_ox_concentration = data.power_cabin_ox_concentration * 0.1;
|
|
power_cabin_temperature = static_cast<int16_t>(data.power_cabin_temperature) * 0.1;
|
|
power_cabin_humidity = data.power_cabin_humidity * 0.1;
|
|
power_cabin_pressure = data.power_cabin_pressure * 0.2;
|
|
|
|
//电池报警标志
|
|
for(int i=0; i<6; i++) {
|
|
dyn_alarm_flag[i] = data.dyn_alarm_flag[i];
|
|
ins_alarm_flag[i] = data.ins_alarm_flag[i];
|
|
}
|
|
|
|
//继电器状态
|
|
ins_relay_status1 = data.ins_relay_status1;
|
|
ins_relay_status2 = data.ins_relay_status2;
|
|
dyn_relay_status1 = data.dyn_relay_status1;
|
|
dyn_relay_status2 = data.dyn_relay_status2;
|
|
|
|
//继电器状态
|
|
ins_pos_relay_status = (data.ins_relay_status1 ) & 0x0F; // 取高4位作为正极继电器状态
|
|
ins_charge_relay_status = ( data.ins_relay_status1 >> 4)& 0x0F; // 取低4位作为充电继电器状态
|
|
ins_precharge_relay_status = (data.ins_relay_status2 ) & 0x0F; // 取高4位作为预充继电器状态
|
|
ins_neg_relay_status = (data.ins_relay_status2 >> 4) & 0x0F; // 取低4位作为负极继电器状态
|
|
|
|
dyn_pos_relay_status = (data.dyn_relay_status1 ) & 0x0F; // 取高4位作为正极继电器状态
|
|
dyn_charge_relay_status = (data.dyn_relay_status1 >> 4) & 0x0F; // 取低4位作为充电继电器状态
|
|
dyn_precharge_relay_status = (data.dyn_relay_status2) & 0x0F; // 取高4位作为预充继电器状态
|
|
dyn_neg_relay_status = (data.dyn_relay_status2 >> 4) & 0x0F; // 取低4位作为负极继电器状态
|
|
|
|
//电池功率参数
|
|
ins_max_discharge_power = data.ins_max_discharge_power * 0.05;
|
|
dyn_max_discharge_power = data.dyn_max_discharge_power * 0.05;
|
|
|
|
//电池SOC
|
|
ins_soc = static_cast<int>(data.ins_soc);
|
|
dyn_soc = static_cast<int>(data.dyn_soc);
|
|
|
|
//电池能量
|
|
ins_total_energy = data.ins_total_energy * 0.1;
|
|
dyn_total_energy = data.dyn_total_energy * 0.1;
|
|
|
|
//电池输入功率
|
|
ins_power_input = data.ins_power_input ;
|
|
dyn_power_input = data.dyn_power_input ;
|
|
|
|
//电池充放电状态
|
|
ins_charge_status = data.ins_charge_status;
|
|
dyn_charge_status = data.dyn_charge_status;
|
|
|
|
//电池电压电流
|
|
ins_voltage_link = data.ins_voltage_link * 0.1;
|
|
ins_voltage_pack = data.ins_voltage_pack * 0.1;
|
|
ins_current = static_cast<int16_t>(data.ins_current) * 0.05;
|
|
ins_resistance_pos = data.ins_resistance_pos;
|
|
ins_resistance_neg = data.ins_resistance_neg;
|
|
dyn_voltage_link = data.dyn_voltage_link * 0.1;
|
|
dyn_voltage_pack = data.dyn_voltage_pack * 0.1;
|
|
dyn_current = static_cast<int16_t>(data.dyn_current) * 0.05;
|
|
dyn_resistance_pos = data.dyn_resistance_pos;
|
|
dyn_resistance_neg = data.dyn_resistance_neg;
|
|
|
|
//紧急状态
|
|
ins_emergency_status = data.ins_emergency_status;
|
|
dyn_emergency_status = data.dyn_emergency_status;
|
|
|
|
//保留字段
|
|
for(int i=0; i<2; i++) {
|
|
reserved2[i] = data.reserved2[i];
|
|
}
|
|
|
|
//SOC门限值
|
|
ins_soc_threshold1 = data.ins_soc_threshold1;
|
|
ins_soc_threshold2 = data.ins_soc_threshold2;
|
|
ins_soc_threshold3 = data.ins_soc_threshold3;
|
|
|
|
//功率限制值
|
|
ins_power_limit1 = data.ins_power_limit1;
|
|
ins_power_limit2 = data.ins_power_limit2;
|
|
|
|
//设备在线状态
|
|
device_online_flag1 = data.device_online_flag1;
|
|
device_online_flag2 = data.device_online_flag2;
|
|
|
|
//更新设备在线状态
|
|
device_online_status.ins_online_state = (data.device_online_flag1 >> 0) & 0xFF; // byte0：仪表锂电在线标志位
|
|
device_online_status.dyn_online_state = (data.device_online_flag1 >> 8) & 0xFF; // byte1：动力锂电在线标志位
|
|
device_online_status.fuel_online_state = (data.device_online_flag1 >> 16) & 0xFF; // byte2：燃电锂电在线标志位
|
|
device_online_status.high_voltage_online_state = (data.device_online_flag1 >> 24) & 0xFF; // byte3：高压配电板在线标志位
|
|
|
|
device_online_status.low_voltage_online_state = (data.device_online_flag2 >> 0) & 0xFF; // byte0：低压配电板在线标志位
|
|
device_online_status.composite_online_state = (data.device_online_flag2 >> 8) & 0xFF; // byte1：复合管控主机在线标志位
|
|
device_online_status.composite_backup_online_state = (data.device_online_flag2 >> 16) & 0xFF; // byte2：复合管控备机在线标志位
|
|
|
|
// 更新锂电池其他状态
|
|
dyn_water_leak_status = data.dyn_water_leak_status;
|
|
ins_water_leak_dcdc_status = data.ins_water_leak_dcdc_status;
|
|
|
|
dyn_charge_level = data.dyn_charge_level; //01H：1级（不限）02H：2级（限功率）03H：3级（关闭）
|
|
water_leak_status_from_insbat = ( data.ins_water_leak_dcdc_status >> 4) & 0x0F; // 00 正常，01 异常漏水
|
|
water_leak_status_from_dynbat = (data.dyn_water_leak_status >> 4) & 0x0F; // 00 正常，01 异常漏水
|
|
dcdc_status_from_insbat = (data.ins_water_leak_dcdc_status) & 0x0F; // 00 正常，01 故障
|
|
//更新漏水状态
|
|
if(water_leak_status_from_insbat == 0x01)
|
|
{
|
|
leakStatus[LEAKAGE_LI_BATTERY] = true;
|
|
}
|
|
else
|
|
{
|
|
leakStatus[LEAKAGE_LI_BATTERY] = false;
|
|
}
|
|
if(water_leak_status_from_dynbat == 0x01)
|
|
{
|
|
leakStatus[LEAKAGE_LI_BATTERY] = true;
|
|
}
|
|
else
|
|
{
|
|
leakStatus[LEAKAGE_LI_BATTERY] = false;
|
|
}
|
|
//应急电池
|
|
emergency_battery1_voltage = data.emergency_battery1_voltage * 0.1;
|
|
emergency_battery1_current = data.emergency_battery1_current * 0.05;
|
|
emergency_battery1_max_temp = data.emergency_battery1_max_temp * 0.1;
|
|
emergency_battery1_fault_word = data.emergency_battery1_fault_word;
|
|
emergency_battery2_voltage = data.emergency_battery2_voltage * 0.1;
|
|
emergency_battery2_current = data.emergency_battery2_current * 0.05;
|
|
emergency_battery2_max_temp = data.emergency_battery2_max_temp * 0.1;
|
|
emergency_battery2_fault_word = data.emergency_battery2_fault_word;
|
|
//心跳计数器
|
|
heartbeat = data.heartbeat;
|
|
}
|
|
std::set<unsigned int> disSysFaultCode;
|
|
mutable std::mutex faultCodeMutex;
|
|
void updateBreakerFault(unsigned char& breakerStatus, unsigned char rawStatus, unsigned int faultCode)
|
|
{
|
|
std::lock_guard<std::mutex> lock(faultCodeMutex);
|
|
unsigned char newStatus = rawStatus == 0x55 ? 1 : (rawStatus == 0xAA ? 0 : 2);
|
|
breakerStatus = newStatus; // 保证状态更新也是原子的
|
|
|
|
if(newStatus == 2) {
|
|
disSysFaultCode.insert(faultCode);
|
|
} else {
|
|
disSysFaultCode.erase(faultCode);
|
|
}
|
|
}
|
|
void updateBreakerFault(unsigned char& breakerStatus, unsigned char rawStatus)
|
|
{
|
|
std::lock_guard<std::mutex> lock(faultCodeMutex);
|
|
unsigned char newStatus = rawStatus == 0x55 ? 1 : (rawStatus == 0xAA ? 0 : 2);
|
|
breakerStatus = newStatus; // 保证状态更新也是原子的
|
|
}
|
|
void updateSystemData(disHighVolBusState data){
|
|
updateBreakerFault(power_bus_status.fuelCellCircuitBreaker, data.fuelCellCircuitBreaker, 1);
|
|
updateBreakerFault(power_bus_status.powerLithiumBatteryCircuitBreaker, data.powerLithiumBatteryCircuitBreaker, 2);
|
|
updateBreakerFault(power_bus_status.propulsionMotorCircuitBreaker, data.propulsionMotorCircuitBreaker, 3);
|
|
updateBreakerFault(power_bus_status.lithiumBatteryGroupInstrumentCircuitBreaker, data.lithiumBatteryGroupInstrumentCircuitBreaker, 4);
|
|
updateBreakerFault(power_bus_status.dcDc5ModuleCircuitBreaker, data.dcDc5ModuleCircuitBreaker, 5);
|
|
updateBreakerFault(power_bus_status.bowHighVoltageDistributionBoxCircuitBreaker, data.bowHighVoltageDistributionBoxCircuitBreaker, 6);
|
|
updateBreakerFault(power_bus_status.sternFTDevice45CircuitBreaker, data.sternFTDevice45CircuitBreaker, 7);
|
|
updateBreakerFault(power_bus_status.sternRudderSwitch1CircuitBreaker, data.sternRudderSwitch1CircuitBreaker, 8);
|
|
updateBreakerFault(power_bus_status.sternRudderSwitch2CircuitBreaker, data.sternRudderSwitch2CircuitBreaker, 9);
|
|
updateBreakerFault(power_bus_status.fbReservedCircuitBreaker, data.fbReservedCircuitBreaker);
|
|
updateBreakerFault(power_bus_status.tyzReservedCircuitBreaker, data.tyzReservedCircuitBreaker);
|
|
updateBreakerFault(power_bus_status.reservedCircuitBreaker, data.reservedCircuitBreaker);
|
|
//模块状态
|
|
power_bus_status.dcDcModuleStatus = data.dcDcFaultWord1;
|
|
power_bus_status.coolingSystemStatus = data.dcDcFaultWord2;
|
|
|
|
m_dcdcStatus.lowFaultWord = data.dcDcFaultWord1;
|
|
m_dcdcStatus.highFaultWord = data.dcDcFaultWord2;
|
|
|
|
//绝缘状态
|
|
power_bus_status.powerBusInsulationStatus = data.powerBusInsulationStatus == 0x55 ? 0 : 1;
|
|
// if(power_bus_status.powerBusInsulationStatus == 1) disSysFaultCode.insert(34); else disSysFaultCode.erase(34);
|
|
|
|
power_bus_status.aBusInsulationStatus = data.aBusInsulationStatus == 0x55 ? 0 : 1;
|
|
// if(power_bus_status.aBusInsulationStatus == 1) disSysFaultCode.insert(35); else disSysFaultCode.erase(35);
|
|
|
|
//电源状态
|
|
power_bus_status.meterPowerLossSignal = data.meterPowerLossSignal == 0x55 ? 0 : 1;
|
|
// if(power_bus_status.meterPowerLossSignal == 1) disSysFaultCode.insert(36); else disSysFaultCode.erase(36);
|
|
|
|
power_bus_status.emergencyPowerLossSignal = data.emergencyPowerLossSignal == 0x55 ? 0 : 1;
|
|
|
|
// if(power_bus_status.emergencyPowerLossSignal == 1) disSysFaultCode.insert(37); else disSysFaultCode.erase(37);
|
|
{
|
|
std::lock_guard<std::mutex> lock(faultCodeMutex);
|
|
if(power_bus_status.emergencyPowerLossSignal == 1) disSysFaultCode.insert(37); else disSysFaultCode.erase(37);
|
|
if(power_bus_status.meterPowerLossSignal == 1) disSysFaultCode.insert(36); else disSysFaultCode.erase(36);
|
|
if(power_bus_status.aBusInsulationStatus == 1) disSysFaultCode.insert(35); else disSysFaultCode.erase(35);
|
|
if(power_bus_status.powerBusInsulationStatus == 1) disSysFaultCode.insert(34); else disSysFaultCode.erase(34);
|
|
}
|
|
|
|
//温度
|
|
power_bus_status.dcDcTemperature = data.dcDcTemperature-40;
|
|
|
|
//电压电流参数
|
|
power_bus_status.powerBusVoltage = data.powerBusVoltage * 0.1;
|
|
power_bus_status.dcDc5ModuleCurrent = data.dcDc5ModuleCurrent * 0.1;
|
|
power_bus_status.powerBusCurrent = data.powerBusCurrent * 0.1;
|
|
power_bus_status.busbarAVoltage = data.busbarAVoltage * 0.1;
|
|
power_bus_status.propulsionMotorControlBoxCurrent = data.propulsionMotorControlBoxCurrent * 0.1;
|
|
power_bus_status.busbarACurrent = data.busbarACurrent * 0.1;
|
|
power_bus_status.lithiumBatteryGroupMeterCurrent = data.lithiumBatteryGroupMeterCurrent * 0.1;
|
|
power_bus_status.bowHighVoltageDistributionBoxCurrent = data.bowHighVoltageDistributionBoxCurrent * 0.1;
|
|
power_bus_status.sternFTDevice45Current = data.sternFTDevice45Current * 0.1;
|
|
power_bus_status.tyzReservedSwitchCurrent = data.tyzReservedSwitchCurrent * 0.1;
|
|
power_bus_status.sternRudderSwitch1Current = data.sternRudderSwitch1Current * 0.1;
|
|
power_bus_status.reservedCurrent1 = data.reservedCurrent1 * 0.1;
|
|
power_bus_status.sternRudderSwitch2Current = data.sternRudderSwitch2Current * 0.1;
|
|
power_bus_status.reservedCurrent2 = data.reservedCurrent2 * 0.1;
|
|
power_bus_status.fbReservedSwitchCurrent = data.fbReservedSwitchCurrent * 0.1;
|
|
power_bus_status.reservedCurrent3 = data.reservedCurrent3 * 0.1;
|
|
|
|
//冷却水压力
|
|
power_bus_status.coolWaterPressure = data.coolWaterPressure * 0.1;
|
|
};
|
|
void updateSystemData(disHighAVolBusState data){
|
|
//断路器状态 (0x55 1 0xAA 0 0x5A 2)
|
|
updateBreakerFault(power_a_bus_status.bowFTDevice123CircuitBreaker, data.bowFTDevice123CircuitBreaker, 13);
|
|
updateBreakerFault(power_a_bus_status.actuatorCircuitBreaker, data.actuatorCircuitBreaker, 14);
|
|
updateBreakerFault(power_a_bus_status.mastSteeringGearControlBoxCircuitBreaker, data.mastSteeringGearControlBoxCircuitBreaker, 15);
|
|
updateBreakerFault(power_a_bus_status.xczCircuitBreaker, data.xczCircuitBreaker, 16);
|
|
updateBreakerFault(power_a_bus_status.bowRudderControlBoxCircuitBreaker, data.bowRudderControlBoxCircuitBreaker, 17);
|
|
updateBreakerFault(power_a_bus_status.openWaterCoverStartCylinderCircuitBreaker, data.openWaterCoverStartCylinderCircuitBreaker, 18);
|
|
|
|
//电源状态
|
|
power_a_bus_status.instrumentPowerFailureSignal = data.instrumentPowerFailureSignal == 0x55 ? 0 : 1;
|
|
// if(power_a_bus_status.instrumentPowerFailureSignal == 1) disSysFaultCode.insert(38); else disSysFaultCode.erase(38);
|
|
|
|
power_a_bus_status.emergencyPowerFailureSignal = data.emergencyPowerFailureSignal == 0x55 ? 0 : 1;
|
|
// if(power_a_bus_status.emergencyPowerFailureSignal == 1) disSysFaultCode.insert(39); else disSysFaultCode.erase(39);
|
|
{
|
|
std::lock_guard<std::mutex> lock(faultCodeMutex);
|
|
if(power_a_bus_status.emergencyPowerFailureSignal == 1) disSysFaultCode.insert(39); else disSysFaultCode.erase(39);
|
|
if(power_a_bus_status.instrumentPowerFailureSignal == 1) disSysFaultCode.insert(38); else disSysFaultCode.erase(38);
|
|
}
|
|
|
|
//浸水报警
|
|
power_a_bus_status.waterIngressionAlarm = data.waterIngressionAlarm == 0x55 ? 0 : 1;
|
|
//更新漏水状态
|
|
if(power_a_bus_status.waterIngressionAlarm == 1)
|
|
{
|
|
leakStatus[LEAKAGE_BOW_HIGH_VOLTAGE] = true;
|
|
}
|
|
else
|
|
{
|
|
leakStatus[LEAKAGE_BOW_HIGH_VOLTAGE] = false;
|
|
}
|
|
|
|
|
|
//电压电流参数
|
|
power_a_bus_status.busbarBVoltage = data.busbarBVoltage * 0.1;
|
|
power_a_bus_status.busbarBCurrent = data.busbarBCurrent * 0.1;
|
|
power_a_bus_status.bowFTDevice123Current = data.bowFTDevice123Current * 0.1;
|
|
power_a_bus_status.actuatorCurrent = data.actuatorCurrent * 0.1;
|
|
power_a_bus_status.mastSteeringGearControlBoxCurrent = data.mastSteeringGearControlBoxCurrent * 0.1;
|
|
power_a_bus_status.xczCurrent = data.xczCurrent * 0.1;
|
|
power_a_bus_status.bowRudderControlBoxCurrent = data.bowRudderControlBoxCurrent * 0.1;
|
|
power_a_bus_status.openWaterCoverStartCylinderCurrent = data.openWaterCoverStartCylinderCurrent * 0.1;
|
|
};
|
|
void updateSystemData(disLowMainBusState data){
|
|
//断路器状态 (0x55 1 0xAA 0 0x5A 2)
|
|
updateBreakerFault(instrument_main_bus_status.lithiumBatteryGroupInstrumentCircuitBreaker, data.lithiumBatteryGroupInstrumentCircuitBreaker, 19);
|
|
updateBreakerFault(instrument_main_bus_status.bowLowVoltageDistributionBoxCircuitBreaker,data.bowLowVoltageDistributionBoxCircuitBreaker, 20);
|
|
updateBreakerFault(instrument_main_bus_status.unit4InstrumentDC48VCircuitBreaker,data.unit4InstrumentDC48VCircuitBreaker, 21);
|
|
updateBreakerFault(instrument_main_bus_status.dcC1DCDistributionPanelCircuitBreaker, data.dcC1DCDistributionPanelCircuitBreaker, 22);
|
|
updateBreakerFault(instrument_main_bus_status.reservedCircuitBreaker1, data.reservedCircuitBreaker1);
|
|
updateBreakerFault(instrument_main_bus_status.reservedCircuitBreaker2, data.reservedCircuitBreaker2);
|
|
updateBreakerFault(instrument_main_bus_status.emergencyLithiumBatteryGroup2CircuitBreaker, data.emergencyLithiumBatteryGroup2CircuitBreaker, 25);
|
|
|
|
//电源状态
|
|
instrument_main_bus_status.instrumentPowerFailureSignal = data.instrumentPowerFailureSignal == 0x55 ? 0 : 1;
|
|
// if(instrument_main_bus_status.instrumentPowerFailureSignal == 1) disSysFaultCode.insert(40); else disSysFaultCode.erase(41);
|
|
|
|
instrument_main_bus_status.emergencyPowerFailureSignal = data.emergencyPowerFailureSignal == 0x55 ? 0 : 1;
|
|
// if(instrument_main_bus_status.emergencyPowerFailureSignal == 1) disSysFaultCode.insert(41); else disSysFaultCode.erase(42);
|
|
|
|
//绝缘状态
|
|
instrument_main_bus_status.instrumentBusbarInsulationLow = data.instrumentBusbarInsulationLow == 0x55 ? 0 : 1;
|
|
// if(instrument_main_bus_status.instrumentBusbarInsulationLow == 1) disSysFaultCode.insert(42); else disSysFaultCode.erase(43);
|
|
{
|
|
std::lock_guard<std::mutex> lock(faultCodeMutex);
|
|
if(instrument_main_bus_status.instrumentPowerFailureSignal == 1) disSysFaultCode.insert(41); else disSysFaultCode.erase(41);
|
|
if(instrument_main_bus_status.emergencyPowerFailureSignal == 1) disSysFaultCode.insert(42); else disSysFaultCode.erase(42);
|
|
if(instrument_main_bus_status.instrumentBusbarInsulationLow == 1) disSysFaultCode.insert(43); else disSysFaultCode.erase(43);
|
|
}
|
|
|
|
//电压电流参数
|
|
instrument_main_bus_status.instrumentBusbarVoltage = data.instrumentBusbarVoltage * 0.1;
|
|
instrument_main_bus_status.bowLowVoltageDistributionBoxCurrent = data.bowLowVoltageDistributionBoxCurrent * 0.1;
|
|
instrument_main_bus_status.dcC1InstrumentDC48VCurrent = data.dcC1InstrumentDC48VCurrent * 0.1;
|
|
instrument_main_bus_status.reservedCurrent1 = data.reservedCurrent1 * 0.1;
|
|
instrument_main_bus_status.emergencyLithiumBatteryGroup2Current = data.emergencyLithiumBatteryGroup2Current * 0.1;
|
|
instrument_main_bus_status.lithiumBatteryGroupInstrumentCurrent = data.lithiumBatteryGroupInstrumentCurrent * 0.1;
|
|
instrument_main_bus_status.unit4InstrumentDC48VCurrent = data.unit4InstrumentDC48VCurrent * 0.1;
|
|
instrument_main_bus_status.reservedCurrent2 = data.reservedCurrent2 * 0.1;
|
|
instrument_main_bus_status.emergency2BusbarVoltage = data.emergency2BusbarVoltage * 0.1;
|
|
instrument_main_bus_status.compositeEnergyManagementSystemEmergencyDC48VCurrent = data.compositeEnergyManagementSystemEmergencyDC48VCurrent * 0.1;
|
|
instrument_main_bus_status.fuelCellSecuritySystemEmergencyDC48VCurrent = data.fuelCellSecuritySystemEmergencyDC48VCurrent * 0.1;
|
|
instrument_main_bus_status.plcControlPowerCurrent = data.plcControlPowerCurrent * 0.1;
|
|
}
|
|
void updateSystemData(disLowBusState data){
|
|
//断路器状态 (0x55 1 0xAA 0 0x5A 2)
|
|
updateBreakerFault(instrument_bus_status.unit1CircuitBreaker, data.unit1CircuitBreaker, 26);
|
|
updateBreakerFault(instrument_bus_status.unit2CircuitBreaker, data.unit2CircuitBreaker, 27);
|
|
updateBreakerFault(instrument_bus_status.unit3CircuitBreaker, data.unit3CircuitBreaker, 28);
|
|
updateBreakerFault(instrument_bus_status.unit5CircuitBreaker, data.unit5CircuitBreaker, 29);
|
|
updateBreakerFault(instrument_bus_status.bowPZDeviceCircuitBreaker, data.bowPZDeviceCircuitBreaker);
|
|
updateBreakerFault(instrument_bus_status.reservedCircuitBreaker1, data.reservedCircuitBreaker1);
|
|
updateBreakerFault(instrument_bus_status.reservedCircuitBreaker2, data.reservedCircuitBreaker2);
|
|
updateBreakerFault(instrument_bus_status.emergencyLithiumBatteryGroup1CircuitBreaker, data.emergencyLithiumBatteryGroup1CircuitBreaker, 33);
|
|
|
|
//电源状态
|
|
instrument_bus_status.powerFailureSignal = data.powerFailureSignal == 0x55 ? 0 : 1;
|
|
// if(instrument_bus_status.powerFailureSignal == 1) disSysFaultCode.insert(44); else disSysFaultCode.erase(44);
|
|
|
|
instrument_bus_status.emergencyPowerFailureSignal = data.emergencyPowerFailureSignal == 0x55 ? 0 : 1;
|
|
// if(instrument_bus_status.emergencyPowerFailureSignal == 1) disSysFaultCode.insert(45); else disSysFaultCode.erase(45);
|
|
{
|
|
std::lock_guard<std::mutex> lock(faultCodeMutex);
|
|
if(instrument_bus_status.emergencyPowerFailureSignal == 1) disSysFaultCode.insert(45); else disSysFaultCode.erase(45);
|
|
if(instrument_bus_status.powerFailureSignal == 1) disSysFaultCode.insert(44); else disSysFaultCode.erase(44);
|
|
}
|
|
|
|
//浸水报警
|
|
instrument_bus_status.waterIngressionAlarm = data.waterIngressionAlarm == 0x55 ? 0 : 1;
|
|
//更新漏水状态
|
|
if(instrument_bus_status.waterIngressionAlarm == 1)
|
|
{
|
|
leakStatus[LEAKAGE_BOW_LOW_VOLTAGE] = true;
|
|
}
|
|
else
|
|
{
|
|
leakStatus[LEAKAGE_BOW_LOW_VOLTAGE] = false;
|
|
}
|
|
//电压电流参数
|
|
instrument_bus_status.instrumentBusbarVoltage = data.instrumentBusbarVoltage * 0.1;
|
|
instrument_bus_status.instrumentBusbarCurrent = data.instrumentBusbarCurrent * 0.1;
|
|
instrument_bus_status.unit1Current = data.unit1Current * 0.1;
|
|
instrument_bus_status.unit2Current = data.unit2Current * 0.1;
|
|
instrument_bus_status.unit3Current = data.unit3Current * 0.1;
|
|
instrument_bus_status.unit5Current = data.unit5Current * 0.1;
|
|
instrument_bus_status.bowPZDeviceCurrent = data.bowPZDeviceCurrent * 0.1;
|
|
instrument_bus_status.emergencyLithiumBatteryGroup1Current = data.emergencyLithiumBatteryGroup1Current * 0.1;
|
|
instrument_bus_status.emergency1BusbarVoltage = data.emergency1BusbarVoltage * 0.1;
|
|
}
|
|
};
|
|
#endif
|