1382 lines
72 KiB
C++
1382 lines
72 KiB
C++
#include "SQLiteDB.h"
|
|
#include <iostream>
|
|
#include <ctime>
|
|
#include <json/json.h>
|
|
#include <sys/stat.h>
|
|
|
|
SQLiteDB::SQLiteDB(const std::string& dbPath) {
|
|
if (sqlite3_open(dbPath.c_str(), &m_db) != SQLITE_OK) {
|
|
std::cerr << "Error opening database: " << sqlite3_errmsg(m_db) << std::endl;
|
|
m_db = nullptr;
|
|
}
|
|
m_dbPath = dbPath;
|
|
}
|
|
|
|
template<typename T>
|
|
bool SQLiteDB::bindParameters(sqlite3_stmt* stmt, const T& data) {
|
|
// 需要为每个具体类型特化实现
|
|
return false;
|
|
}
|
|
|
|
template<>
|
|
bool SQLiteDB::bindParameters<DriverTable>(sqlite3_stmt* stmt, const DriverTable& data)
|
|
{
|
|
int index = 1;
|
|
sqlite3_bind_int(stmt, index++, data.depth1);
|
|
sqlite3_bind_int(stmt, index++, data.depth2);
|
|
sqlite3_bind_int(stmt, index++, data.depth3);
|
|
sqlite3_bind_int(stmt, index++, data.overDeep1);
|
|
sqlite3_bind_int(stmt, index++, data.overDeep2);
|
|
sqlite3_bind_int(stmt, index++, data.ctd1);
|
|
sqlite3_bind_int(stmt, index++, data.ctd2);
|
|
sqlite3_bind_int(stmt, index++, data.soundVeloc);
|
|
sqlite3_bind_int(stmt, index++, data.commMast);
|
|
sqlite3_bind_int(stmt, index++, data.ins);
|
|
sqlite3_bind_int(stmt, index++, data.ntp);
|
|
sqlite3_bind_int(stmt, index++, data.inputWaterSensor1);
|
|
sqlite3_bind_int(stmt, index++, data.inputWaterSensor2);
|
|
sqlite3_bind_int(stmt, index++, data.inputWaterSensor3);
|
|
sqlite3_bind_int(stmt, index++, data.singleBeamSonar1);
|
|
sqlite3_bind_int(stmt, index++, data.singleBeamSonar2);
|
|
sqlite3_bind_int(stmt, index++, data.singleBeamSonar3);
|
|
sqlite3_bind_int(stmt, index++, data.singleBeamSonar4);
|
|
sqlite3_bind_int(stmt, index++, data.singleBeamSonar5);
|
|
sqlite3_bind_int(stmt, index++, data.singleBeamSonar6);
|
|
sqlite3_bind_int(stmt, index++, data.singleBeamSonar7);
|
|
sqlite3_bind_int(stmt, index++, data.singleBeamSonar8);
|
|
sqlite3_bind_int(stmt, index++, data.forwardSonar);
|
|
sqlite3_bind_int(stmt, index++, data.DVL);
|
|
sqlite3_bind_int(stmt, index++, data.lowFreqSonar);
|
|
sqlite3_bind_int(stmt, index++, data.USBL);
|
|
sqlite3_bind_int(stmt, index++, data.bowWaterlnet1);
|
|
sqlite3_bind_int(stmt, index++, data.bowWaterlnet2);
|
|
sqlite3_bind_int(stmt, index++, data.bowWaterlnet3);
|
|
sqlite3_bind_int(stmt, index++, data.bowWaterlnet4);
|
|
sqlite3_bind_int(stmt, index++, data.bowWaterlnet5);
|
|
sqlite3_bind_int(stmt, index++, data.bowWaterlnet6);
|
|
sqlite3_bind_int(stmt, index++, data.bowWaterlnet7);
|
|
sqlite3_bind_int(stmt, index++, data.bowWaterlnet8);
|
|
sqlite3_bind_int(stmt, index++, data.bowRudderDeploy);
|
|
sqlite3_bind_int(stmt, index++, data.bowRudderServo1);
|
|
sqlite3_bind_int(stmt, index++, data.bowRudderServo2);
|
|
sqlite3_bind_int(stmt, index++, data.bowCover1);
|
|
sqlite3_bind_int(stmt, index++, data.bowCover2);
|
|
sqlite3_bind_int(stmt, index++, data.bowCover3);
|
|
sqlite3_bind_int(stmt, index++, data.bowCover4);
|
|
sqlite3_bind_int(stmt, index++, data.bowCover5);
|
|
sqlite3_bind_int(stmt, index++, data.bowCover6);
|
|
sqlite3_bind_int(stmt, index++, data.waterInject);
|
|
sqlite3_bind_int(stmt, index++, data.mastLiftingServo);
|
|
sqlite3_bind_int(stmt, index++, data.buoyancyAdjust1);
|
|
sqlite3_bind_int(stmt, index++, data.buoyancyAdjust2);
|
|
sqlite3_bind_int(stmt, index++, data.buoyancyAdjust3);
|
|
sqlite3_bind_int(stmt, index++, data.buoyancyAdjust4);
|
|
sqlite3_bind_int(stmt, index++, data.buoyancyAdjust5);
|
|
sqlite3_bind_int(stmt, index++, data.sternRudderServo1);
|
|
sqlite3_bind_int(stmt, index++, data.sternRudderServo2);
|
|
sqlite3_bind_int(stmt, index++, data.sternRudderServo3);
|
|
sqlite3_bind_int(stmt, index++, data.sternRudderServo4);
|
|
sqlite3_bind_int(stmt, index++, data.thruster);
|
|
sqlite3_bind_int(stmt, index++, data.bowThrow);
|
|
sqlite3_bind_int(stmt, index++, data.sternThrow);
|
|
sqlite3_bind_int(stmt, index++, data.photoSensor);
|
|
sqlite3_bind_int(stmt, index++, data.electSensor);
|
|
sqlite3_bind_int(stmt, index++, data.launchControler);
|
|
sqlite3_bind_int(stmt, index++, data.sideSonar);
|
|
sqlite3_bind_int(stmt, index++, data.buoyage);
|
|
return true;
|
|
}
|
|
|
|
// 为ccuState特化实现
|
|
template<>
|
|
bool SQLiteDB::bindParameters<ccuState>(sqlite3_stmt* stmt, const ccuState& data) {
|
|
int index = 1;
|
|
sqlite3_bind_int(stmt, index++, data.currentWorkCondition);
|
|
sqlite3_bind_int(stmt, index++, data.fcuState);
|
|
sqlite3_bind_int(stmt, index++, data.fcuFaultLeve);
|
|
sqlite3_bind_double(stmt, index++, data.powerLimit);
|
|
sqlite3_bind_double(stmt, index++, data.totalPowerGeneration);
|
|
sqlite3_bind_double(stmt, index++, data.ch4o);
|
|
sqlite3_bind_double(stmt, index++, data.o2);
|
|
sqlite3_bind_double(stmt, index++, data.fcuVoltage);
|
|
sqlite3_bind_double(stmt, index++, data.fcuCurrent);
|
|
sqlite3_bind_double(stmt, index++, data.o2Level);
|
|
sqlite3_bind_double(stmt, index++, data.placeholder1);
|
|
sqlite3_bind_double(stmt, index++, data.exchangerTemperature);
|
|
sqlite3_bind_double(stmt, index++, data.fcuOutPower);
|
|
sqlite3_bind_double(stmt, index++, data.fcuOutIns);
|
|
sqlite3_bind_double(stmt, index++, data.fcuVoltageIns);
|
|
sqlite3_bind_double(stmt, index++, data.fcuVoltagePower);
|
|
sqlite3_bind_double(stmt, index++, data.fcuCurrentIns);
|
|
sqlite3_bind_double(stmt, index++, data.fcuCurrentPower);
|
|
sqlite3_bind_double(stmt, index++, data.h2Concentration1);
|
|
sqlite3_bind_double(stmt, index++, data.h2Concentration2);
|
|
sqlite3_bind_double(stmt, index++, data.o2Concentration1);
|
|
sqlite3_bind_double(stmt, index++, data.o2Concentration2);
|
|
sqlite3_bind_double(stmt, index++, data.ch4oConcentration1);
|
|
sqlite3_bind_double(stmt, index++, data.ch4oConcentration2);
|
|
sqlite3_bind_double(stmt, index++, data.backpressure1);
|
|
sqlite3_bind_double(stmt, index++, data.backpressure2);
|
|
sqlite3_bind_int(stmt, index++, data.flameDetection);
|
|
sqlite3_bind_int(stmt, index++, data.fcuGZ_1L);
|
|
sqlite3_bind_int(stmt, index++, data.fcuGZ_1H);
|
|
sqlite3_bind_int(stmt, index++, data.fcuGZ_2L);
|
|
sqlite3_bind_int(stmt, index++, data.fcuGZ_2H);
|
|
sqlite3_bind_int(stmt, index++, data.fcuGZ_3L);
|
|
sqlite3_bind_int(stmt, index++, data.fcuGZ_3H);
|
|
sqlite3_bind_int(stmt, index++, data.insPosRelayState);
|
|
sqlite3_bind_int(stmt, index++, data.insNegRelayState);
|
|
sqlite3_bind_int(stmt, index++, data.powerPosRelayState);
|
|
sqlite3_bind_int(stmt, index++, data.powerNegRelayState);
|
|
sqlite3_bind_int(stmt, index++, data.insBatLimit);
|
|
sqlite3_bind_int(stmt, index++, data.powerBatLimit);
|
|
sqlite3_bind_int(stmt, index++, data.insBatSoc);
|
|
sqlite3_bind_int(stmt, index++, data.powerBatSoc);
|
|
sqlite3_bind_int(stmt, index++, data.insBatTotalElectricity);
|
|
sqlite3_bind_int(stmt, index++, data.powerBatTotalElectricity);
|
|
sqlite3_bind_int(stmt, index++, data.insBatCurrentElectricity);
|
|
sqlite3_bind_int(stmt, index++, data.powerBatCurrentElectricity);
|
|
sqlite3_bind_int(stmt, index++, data.insChargeState);
|
|
sqlite3_bind_int(stmt, index++, data.powerChargeState);
|
|
sqlite3_bind_int(stmt, index++, data.insLinkVoltage);
|
|
sqlite3_bind_int(stmt, index++, data.insPackVoltage);
|
|
sqlite3_bind_int(stmt, index++, data.insCurrent);
|
|
sqlite3_bind_int(stmt, index++, data.insPosInsulationResistance);
|
|
sqlite3_bind_int(stmt, index++, data.insNegInsulationResistance);
|
|
sqlite3_bind_int(stmt, index++, data.powerLinkVoltage);
|
|
sqlite3_bind_int(stmt, index++, data.powerPackVoltage);
|
|
sqlite3_bind_int(stmt, index++, data.powerCurrent);
|
|
sqlite3_bind_int(stmt, index++, data.powerPosInsulationResistance);
|
|
sqlite3_bind_int(stmt, index++, data.powerNegInsulationResistance);
|
|
sqlite3_bind_int(stmt, index++, data.insEmergencyStatusWord);
|
|
sqlite3_bind_int(stmt, index++, data.powerEmergencyStatusWord);
|
|
sqlite3_bind_int(stmt, index++, data.insAlarmIdentificationWord);
|
|
sqlite3_bind_int(stmt, index++, data.powerAlarmIdentificationWord);
|
|
sqlite3_bind_int(stmt, index++, data.insCurrentSocHold1);
|
|
sqlite3_bind_int(stmt, index++, data.insCurrentSocHold2);
|
|
sqlite3_bind_int(stmt, index++, data.insCurrentSocHold3);
|
|
sqlite3_bind_int(stmt, index++, data.fcuCurrentToInsLimit1);
|
|
sqlite3_bind_int(stmt, index++, data.fcuCurrentToinsLimit2);
|
|
sqlite3_bind_int(stmt, index++, data.powerCurrentSocHold1);
|
|
sqlite3_bind_int(stmt, index++, data.powerCurrentSocHold2);
|
|
sqlite3_bind_int(stmt, index++, data.powerCurrentSocHold3);
|
|
sqlite3_bind_int(stmt, index++, data.powerCurrentToInsLimit1);
|
|
sqlite3_bind_int(stmt, index++, data.powerCurrentToinsLimit2);
|
|
sqlite3_bind_double(stmt, index++, data.placeholder2);
|
|
sqlite3_bind_double(stmt, index++, data.placeholder3);
|
|
sqlite3_bind_double(stmt, index++, data.placeholder4);
|
|
sqlite3_bind_double(stmt, index++, data.placeholder5);
|
|
return true;
|
|
}
|
|
|
|
// 为disHighVolBusState特化实现
|
|
template<>
|
|
bool SQLiteDB::bindParameters<disHighVolBusState>(sqlite3_stmt* stmt, const disHighVolBusState& data) {
|
|
int index = 1;
|
|
sqlite3_bind_int(stmt, index++, data.fuelCellCircuitBreaker);
|
|
sqlite3_bind_int(stmt, index++, data.powerLithiumBatteryCircuitBreaker);
|
|
sqlite3_bind_int(stmt, index++, data.propulsionMotorCircuitBreaker);
|
|
sqlite3_bind_int(stmt, index++, data.lithiumBatteryGroupInstrumentCircuitBreaker);
|
|
sqlite3_bind_int(stmt, index++, data.dcDc5ModuleCircuitBreaker);
|
|
sqlite3_bind_int(stmt, index++, data.bowHighVoltageDistributionBoxCircuitBreaker);
|
|
sqlite3_bind_int(stmt, index++, data.sternFTDevice45CircuitBreaker);
|
|
sqlite3_bind_int(stmt, index++, data.sternRudderSwitch1CircuitBreaker);
|
|
sqlite3_bind_int(stmt, index++, data.sternRudderSwitch2CircuitBreaker);
|
|
sqlite3_bind_int(stmt, index++, data.fbReservedCircuitBreaker);
|
|
sqlite3_bind_int(stmt, index++, data.tyzReservedCircuitBreaker);
|
|
sqlite3_bind_int(stmt, index++, data.reservedCircuitBreaker);
|
|
sqlite3_bind_int(stmt, index++, data.busInsulationLow);
|
|
sqlite3_bind_int(stmt, index++, data.busAInsulationHigh);
|
|
sqlite3_bind_int(stmt, index++, data.lostPower);
|
|
sqlite3_bind_int(stmt, index++, data.lostEmerPower);
|
|
sqlite3_bind_int(stmt, index++, data.powerBusVoltage);
|
|
sqlite3_bind_int(stmt, index++, data.dcDc5ModuleCurrent);
|
|
sqlite3_bind_int(stmt, index++, data.powerBusCurrent);
|
|
sqlite3_bind_int(stmt, index++, data.busbarAVoltage);
|
|
sqlite3_bind_int(stmt, index++, data.propulsionMotorControlBoxCurrent);
|
|
sqlite3_bind_int(stmt, index++, data.busbarACurrent);
|
|
sqlite3_bind_int(stmt, index++, data.lithiumBatteryGroupMeterCurrent);
|
|
sqlite3_bind_int(stmt, index++, data.bowHighVoltageDistributionBoxCurrent);
|
|
sqlite3_bind_int(stmt, index++, data.sternFTDevice45Current);
|
|
sqlite3_bind_int(stmt, index++, data.tyzReservedSwitchCurrent);
|
|
sqlite3_bind_int(stmt, index++, data.sternRudderSwitch1Current);
|
|
sqlite3_bind_int(stmt, index++, data.reservedCurrent1);
|
|
sqlite3_bind_int(stmt, index++, data.sternRudderSwitch2Current);
|
|
sqlite3_bind_int(stmt, index++, data.reservedCurrent2);
|
|
sqlite3_bind_int(stmt, index++, data.fbReservedSwitchCurrent);
|
|
sqlite3_bind_int(stmt, index++, data.reservedCurrent3);
|
|
return true;
|
|
}
|
|
|
|
// 为disHighAVolBusState特化实现
|
|
template<>
|
|
bool SQLiteDB::bindParameters<disHighAVolBusState>(sqlite3_stmt* stmt, const disHighAVolBusState& data) {
|
|
int index = 1;
|
|
sqlite3_bind_int(stmt, index++, data.bowFTDevice123CircuitBreaker);
|
|
sqlite3_bind_int(stmt, index++, data.actuatorCircuitBreaker);
|
|
sqlite3_bind_int(stmt, index++, data.mastSteeringGearControlBoxCircuitBreaker);
|
|
sqlite3_bind_int(stmt, index++, data.xczCircuitBreaker);
|
|
sqlite3_bind_int(stmt, index++, data.bowRudderControlBoxCircuitBreaker);
|
|
sqlite3_bind_int(stmt, index++, data.openWaterCoverStartCylinderCircuitBreaker);
|
|
sqlite3_bind_int(stmt, index++, data.instrumentPowerFailureSignal);
|
|
sqlite3_bind_int(stmt, index++, data.emergencyPowerFailureSignal);
|
|
sqlite3_bind_int(stmt, index++, data.waterIngressionAlarm);
|
|
sqlite3_bind_int(stmt, index++, data.busbarBVoltage);
|
|
sqlite3_bind_int(stmt, index++, data.busbarBCurrent);
|
|
sqlite3_bind_int(stmt, index++, data.bowFTDevice123Current);
|
|
sqlite3_bind_int(stmt, index++, data.actuatorCurrent);
|
|
sqlite3_bind_int(stmt, index++, data.mastSteeringGearControlBoxCurrent);
|
|
sqlite3_bind_int(stmt, index++, data.xczCurrent);
|
|
sqlite3_bind_int(stmt, index++, data.bowRudderControlBoxCurrent);
|
|
sqlite3_bind_int(stmt, index++, data.openWaterCoverStartCylinderCurrent);
|
|
return true;
|
|
}
|
|
|
|
// 为disHighBVolBusState特化实现
|
|
template<>
|
|
bool SQLiteDB::bindParameters<disHighBVolBusState>(sqlite3_stmt* stmt, const disHighBVolBusState& data) {
|
|
int index = 1;
|
|
sqlite3_bind_int(stmt, index++, data.lithiumBatteryGroupInstrumentCircuitBreaker);
|
|
sqlite3_bind_int(stmt, index++, data.bowLowVoltageDistributionBoxCircuitBreaker);
|
|
sqlite3_bind_int(stmt, index++, data.unit4InstrumentDC48VCircuitBreaker);
|
|
sqlite3_bind_int(stmt, index++, data.dcC1DCDistributionPanelCircuitBreaker);
|
|
sqlite3_bind_int(stmt, index++, data.reservedCircuitBreaker1);
|
|
sqlite3_bind_int(stmt, index++, data.reservedCircuitBreaker2);
|
|
sqlite3_bind_int(stmt, index++, data.emergencyLithiumBatteryGroup2CircuitBreaker);
|
|
sqlite3_bind_int(stmt, index++, data.instrumentPowerFailureSignal);
|
|
sqlite3_bind_int(stmt, index++, data.emergencyPowerFailureSignal);
|
|
sqlite3_bind_int(stmt, index++, data.instrumentBusbarInsulationLow);
|
|
sqlite3_bind_int(stmt, index++, data.instrumentBusbarVoltage);
|
|
sqlite3_bind_int(stmt, index++, data.bowLowVoltageDistributionBoxCurrent);
|
|
sqlite3_bind_int(stmt, index++, data.dcC1InstrumentDC48VCurrent);
|
|
sqlite3_bind_int(stmt, index++, data.reservedCurrent1);
|
|
sqlite3_bind_int(stmt, index++, data.emergencyLithiumBatteryGroup2Current);
|
|
sqlite3_bind_int(stmt, index++, data.lithiumBatteryGroupInstrumentCurrent);
|
|
sqlite3_bind_int(stmt, index++, data.unit4InstrumentDC48VCurrent);
|
|
sqlite3_bind_int(stmt, index++, data.reservedCurrent2);
|
|
sqlite3_bind_int(stmt, index++, data.emergency2BusbarVoltage);
|
|
sqlite3_bind_int(stmt, index++, data.compositeEnergyManagementSystemEmergencyDC48VCurrent);
|
|
sqlite3_bind_int(stmt, index++, data.fuelCellSecuritySystemEmergencyDC48VCurrent);
|
|
sqlite3_bind_int(stmt, index++, data.plcControlPowerCurrent);
|
|
return true;
|
|
}
|
|
|
|
// 为disLowBusState特化实现
|
|
template<>
|
|
bool SQLiteDB::bindParameters<disLowBusState>(sqlite3_stmt* stmt, const disLowBusState& data) {
|
|
int index = 1;
|
|
sqlite3_bind_int(stmt, index++, data.unit1CircuitBreaker);
|
|
sqlite3_bind_int(stmt, index++, data.unit2CircuitBreaker);
|
|
sqlite3_bind_int(stmt, index++, data.unit3CircuitBreaker);
|
|
sqlite3_bind_int(stmt, index++, data.unit5CircuitBreaker);
|
|
sqlite3_bind_int(stmt, index++, data.bowPZDeviceCircuitBreaker);
|
|
sqlite3_bind_int(stmt, index++, data.reservedCircuitBreaker1);
|
|
sqlite3_bind_int(stmt, index++, data.reservedCircuitBreaker2);
|
|
sqlite3_bind_int(stmt, index++, data.emergencyLithiumBatteryGroup1CircuitBreaker);
|
|
sqlite3_bind_int(stmt, index++, data.powerFailureSignal);
|
|
sqlite3_bind_int(stmt, index++, data.waterIngressionAlarm);
|
|
sqlite3_bind_int(stmt, index++, data.instrumentBusbarVoltage);
|
|
sqlite3_bind_int(stmt, index++, data.instrumentBusbarCurrent);
|
|
sqlite3_bind_int(stmt, index++, data.unit1Current);
|
|
sqlite3_bind_int(stmt, index++, data.unit2Current);
|
|
sqlite3_bind_int(stmt, index++, data.unit3Current);
|
|
sqlite3_bind_int(stmt, index++, data.unit5Current);
|
|
sqlite3_bind_int(stmt, index++, data.bowPZDeviceCurrent);
|
|
sqlite3_bind_int(stmt, index++, data.emergencyLithiumBatteryGroup1Current);
|
|
sqlite3_bind_int(stmt, index++, data.emergency1BusbarVoltage);
|
|
return true;
|
|
}
|
|
template<>
|
|
bool SQLiteDB::bindParameters<ccuColCmd>(sqlite3_stmt* stmt, const ccuColCmd& data) {
|
|
int index = 1;
|
|
sqlite3_bind_int(stmt, index++, data.workCondition);
|
|
sqlite3_bind_int(stmt, index++, data.fcuCmd);
|
|
sqlite3_bind_int(stmt, index++, data.fcuPowerEfficiency);
|
|
sqlite3_bind_int(stmt, index++, data.fcuInsEfficiency);
|
|
sqlite3_bind_int(stmt, index++, data.insBatCmd);
|
|
sqlite3_bind_int(stmt, index++, data.powerBatCmd);
|
|
sqlite3_bind_int(stmt, index++, data.powerBatEfficiency);
|
|
sqlite3_bind_int(stmt, index++, data.heartbeat);
|
|
sqlite3_bind_int(stmt, index++, data.masterState);
|
|
return true;
|
|
}
|
|
|
|
template<>
|
|
bool SQLiteDB::bindParameters<disHighVolBusCmd>(sqlite3_stmt* stmt, const disHighVolBusCmd& data) {
|
|
int index = 1;
|
|
sqlite3_bind_int(stmt, index++, static_cast<int>(data.fuelCellCircuitBreaker));
|
|
sqlite3_bind_int(stmt, index++, static_cast<int>(data.powerLithiumBatteryCircuitBreaker));
|
|
sqlite3_bind_int(stmt, index++, static_cast<int>(data.propulsionMotorCircuitBreaker));
|
|
sqlite3_bind_int(stmt, index++, static_cast<int>(data.lithiumBatteryGroupInstrumentCircuitBreaker));
|
|
sqlite3_bind_int(stmt, index++, static_cast<int>(data.dcDc5ModuleCircuitBreaker));
|
|
sqlite3_bind_int(stmt, index++, static_cast<int>(data.bowHighVoltageDistributionBoxCircuitBreaker));
|
|
sqlite3_bind_int(stmt, index++, static_cast<int>(data.sternFTDevice45CircuitBreaker));
|
|
sqlite3_bind_int(stmt, index++, static_cast<int>(data.sternRudderSwitch1CircuitBreaker));
|
|
sqlite3_bind_int(stmt, index++, static_cast<int>(data.sternRudderSwitch2CircuitBreaker));
|
|
sqlite3_bind_int(stmt, index++, static_cast<int>(data.fbReservedCircuitBreaker));
|
|
sqlite3_bind_int(stmt, index++, static_cast<int>(data.tyzReservedCircuitBreaker));
|
|
sqlite3_bind_int(stmt, index++, static_cast<int>(data.reservedCircuitBreaker));
|
|
sqlite3_bind_int(stmt, index++, static_cast<int>(data.dcdc5Module));
|
|
sqlite3_bind_int(stmt, index++, static_cast<int>(data.inputWater));
|
|
sqlite3_bind_int(stmt, index++, static_cast<int>(data.outputWater));
|
|
return true;
|
|
|
|
}
|
|
template<>
|
|
bool SQLiteDB::bindParameters<disHighAVolBusCmd>(sqlite3_stmt* stmt, const disHighAVolBusCmd& data) {
|
|
int index = 1;
|
|
sqlite3_bind_int(stmt, index++, static_cast<int>(data.bowFTDevice123CircuitBreaker));
|
|
sqlite3_bind_int(stmt, index++, static_cast<int>(data.actuatorCircuitBreaker));
|
|
sqlite3_bind_int(stmt, index++, static_cast<int>(data.mastSteeringGearControlBoxCircuitBreaker));
|
|
sqlite3_bind_int(stmt, index++, static_cast<int>(data.xczCircuitBreaker));
|
|
sqlite3_bind_int(stmt, index++, static_cast<int>(data.bowRudderControlBoxCircuitBreaker));
|
|
sqlite3_bind_int(stmt, index++, static_cast<int>(data.openWaterCoverStartCylinderCircuitBreaker));
|
|
return true;
|
|
}
|
|
|
|
template<>
|
|
bool SQLiteDB::bindParameters<disHighBVolBusCmd>(sqlite3_stmt* stmt, const disHighBVolBusCmd& data) {
|
|
int index = 1;
|
|
sqlite3_bind_int(stmt, index++, static_cast<int>(data.lithiumBatteryGroupInstrumentCircuitBreaker));
|
|
sqlite3_bind_int(stmt, index++, static_cast<int>(data.bowLowVoltageDistributionBoxCircuitBreaker));
|
|
sqlite3_bind_int(stmt, index++, static_cast<int>(data.unit4InstrumentDC48VCircuitBreaker));
|
|
sqlite3_bind_int(stmt, index++, static_cast<int>(data.dcC1DCDistributionPanelCircuitBreaker));
|
|
sqlite3_bind_int(stmt, index++, static_cast<int>(data.reservedCircuitBreaker1));
|
|
sqlite3_bind_int(stmt, index++, static_cast<int>(data.reservedCircuitBreaker2));
|
|
sqlite3_bind_int(stmt, index++, static_cast<int>(data.emergencyLithiumBatteryGroup2CircuitBreaker));
|
|
return true;
|
|
}
|
|
|
|
template<>
|
|
bool SQLiteDB::bindParameters<disLowBusCmd>(sqlite3_stmt* stmt, const disLowBusCmd& data) {
|
|
int index = 1;
|
|
sqlite3_bind_int(stmt, index++, static_cast<int>(data.unit1CircuitBreaker));
|
|
sqlite3_bind_int(stmt, index++, static_cast<int>(data.unit2CircuitBreaker));
|
|
sqlite3_bind_int(stmt, index++, static_cast<int>(data.unit3CircuitBreaker));
|
|
sqlite3_bind_int(stmt, index++, static_cast<int>(data.unit5CircuitBreaker));
|
|
sqlite3_bind_int(stmt, index++, static_cast<int>(data.bowPZDeviceCircuitBreaker));
|
|
sqlite3_bind_int(stmt, index++, static_cast<int>(data.reservedCircuitBreaker1));
|
|
sqlite3_bind_int(stmt, index++, static_cast<int>(data.reservedCircuitBreaker2));
|
|
sqlite3_bind_int(stmt, index++, static_cast<int>(data.emergencyLithiumBatteryGroup1CircuitBreaker));
|
|
return true;
|
|
}
|
|
|
|
SQLiteDB::~SQLiteDB() {
|
|
if (m_db) {
|
|
sqlite3_close(m_db);
|
|
}
|
|
}
|
|
|
|
bool SQLiteDB::createPowerDataTables() {
|
|
if (!m_db) return false;
|
|
|
|
const char* sql = "CREATE TABLE IF NOT EXISTS power_data ("
|
|
"timestamp DATETIME DEFAULT (strftime('%Y-%m-%d %H:%M:%f', 'now')),"
|
|
"voltage REAL NOT NULL,"
|
|
"current REAL NOT NULL,"
|
|
"power REAL NOT NULL,"
|
|
"temperature REAL NOT NULL,"
|
|
"PRIMARY KEY(timestamp, voltage, current));";
|
|
|
|
char* errMsg = nullptr;
|
|
if (sqlite3_exec(m_db, sql, nullptr, nullptr, &errMsg) != SQLITE_OK) {
|
|
std::cerr << "SQL error: " << errMsg << std::endl;
|
|
sqlite3_free(errMsg);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool SQLiteDB::createDriversTables(string tableName)
|
|
{
|
|
if (!m_db) return false;
|
|
|
|
string createTableSQL = "CREATE TABLE IF NOT EXISTS " + tableName + " ("
|
|
"timestamp DATETIME DEFAULT (strftime('%Y-%m-%d %H:%M:%f', 'now')), "
|
|
"DVL INTEGER DEFAULT 0, "
|
|
"USBL INTEGER DEFAULT 0, "
|
|
"bowCover1 INTEGER DEFAULT 0, "
|
|
"bowCover2 INTEGER DEFAULT 0, "
|
|
"bowCover3 INTEGER DEFAULT 0, "
|
|
"bowCover4 INTEGER DEFAULT 0, "
|
|
"bowCover5 INTEGER DEFAULT 0, "
|
|
"bowCover6 INTEGER DEFAULT 0, "
|
|
"bowRudderDeploy INTEGER DEFAULT 0, "
|
|
"bowRudderServo1 INTEGER DEFAULT 0, "
|
|
"bowRudderServo2 INTEGER DEFAULT 0, "
|
|
"bowThrow INTEGER DEFAULT 0, "
|
|
"bowWaterlnet1 INTEGER DEFAULT 0, "
|
|
"bowWaterlnet2 INTEGER DEFAULT 0, "
|
|
"bowWaterlnet3 INTEGER DEFAULT 0, "
|
|
"bowWaterlnet4 INTEGER DEFAULT 0, "
|
|
"bowWaterlnet5 INTEGER DEFAULT 0, "
|
|
"bowWaterlnet6 INTEGER DEFAULT 0, "
|
|
"bowWaterlnet7 INTEGER DEFAULT 0, "
|
|
"bowWaterlnet8 INTEGER DEFAULT 0, "
|
|
"buoyage INTEGER DEFAULT 0, "
|
|
"buoyancyAdjust1 INTEGER DEFAULT 0, "
|
|
"buoyancyAdjust2 INTEGER DEFAULT 0, "
|
|
"buoyancyAdjust3 INTEGER DEFAULT 0, "
|
|
"buoyancyAdjust4 INTEGER DEFAULT 0, "
|
|
"buoyancyAdjust5 INTEGER DEFAULT 0, "
|
|
"commMast INTEGER DEFAULT 0, "
|
|
"ctd1 INTEGER DEFAULT 0, "
|
|
"ctd2 INTEGER DEFAULT 0, "
|
|
"depth1 INTEGER DEFAULT 0, "
|
|
"depth2 INTEGER DEFAULT 0, "
|
|
"depth3 INTEGER DEFAULT 0, "
|
|
"electSensor INTEGER DEFAULT 0, "
|
|
"forwardSonar INTEGER DEFAULT 0, "
|
|
"inputWaterSensor1 INTEGER DEFAULT 0, "
|
|
"inputWaterSensor2 INTEGER DEFAULT 0, "
|
|
"inputWaterSensor3 INTEGER DEFAULT 0, "
|
|
"ins INTEGER DEFAULT 0, "
|
|
"launchControler INTEGER DEFAULT 0, "
|
|
"lowFreqSonar INTEGER DEFAULT 0, "
|
|
"mastLiftingServo INTEGER DEFAULT 0, "
|
|
"ntp INTEGER DEFAULT 0, "
|
|
"overDeep1 INTEGER DEFAULT 0, "
|
|
"overDeep2 INTEGER DEFAULT 0, "
|
|
"photoSensor INTEGER DEFAULT 0, "
|
|
"sideSonar INTEGER DEFAULT 0, "
|
|
"singleBeamSonar1 INTEGER DEFAULT 0, "
|
|
"singleBeamSonar2 INTEGER DEFAULT 0, "
|
|
"singleBeamSonar3 INTEGER DEFAULT 0, "
|
|
"singleBeamSonar4 INTEGER DEFAULT 0, "
|
|
"singleBeamSonar5 INTEGER DEFAULT 0, "
|
|
"singleBeamSonar6 INTEGER DEFAULT 0, "
|
|
"singleBeamSonar7 INTEGER DEFAULT 0, "
|
|
"singleBeamSonar8 INTEGER DEFAULT 0, "
|
|
"soundVeloc INTEGER DEFAULT 0, "
|
|
"sternRudderServo1 INTEGER DEFAULT 0, "
|
|
"sternRudderServo2 INTEGER DEFAULT 0, "
|
|
"sternRudderServo3 INTEGER DEFAULT 0, "
|
|
"sternRudderServo4 INTEGER DEFAULT 0, "
|
|
"sternThrow INTEGER DEFAULT 0, "
|
|
"thruster INTEGER DEFAULT 0, "
|
|
"waterInject INTEGER DEFAULT 0"
|
|
");";
|
|
char* errMsg = nullptr;
|
|
if (sqlite3_exec(m_db, createTableSQL.c_str(), nullptr, nullptr, &errMsg) != SQLITE_OK) {
|
|
std::cerr << "SQL error: " << errMsg << std::endl;
|
|
sqlite3_free(errMsg);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool SQLiteDB::createStateTables() {
|
|
if (!m_db) return false;
|
|
|
|
const char* sql = "CREATE TABLE IF NOT EXISTS state_data ("
|
|
"id INTEGER PRIMARY KEY AUTOINCREMENT,"
|
|
"state_id INTEGER NOT NULL,"
|
|
"timestamp DATETIME DEFAULT (strftime('%Y-%m-%d %H:%M:%f', 'now')),"
|
|
"state_name TEXT NOT NULL,"
|
|
"event TEXT NOT NULL,"
|
|
"event_id INTEGER NOT NULL,"
|
|
"fault_code INTEGER DEFAULT 0,"
|
|
"note TEXT NOT NULL);";
|
|
char* errMsg = nullptr;
|
|
if (sqlite3_exec(m_db, sql, nullptr, nullptr, &errMsg) != SQLITE_OK) {
|
|
std::cerr << "SQL error: " << errMsg << std::endl;
|
|
sqlite3_free(errMsg);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool SQLiteDB::insertPowerData(const PowerData& powerData) {
|
|
if (!m_db) return false;
|
|
|
|
const char* sql = "INSERT INTO power_data (voltage, current, power, temperature) VALUES (?, ?, ?, ?);";
|
|
sqlite3_stmt* stmt;
|
|
bool result = true;
|
|
|
|
if (sqlite3_prepare_v2(m_db, sql, -1, &stmt, nullptr) == SQLITE_OK) {
|
|
sqlite3_bind_double(stmt, 1, powerData.voltage);
|
|
sqlite3_bind_double(stmt, 2, powerData.current);
|
|
sqlite3_bind_double(stmt, 3, powerData.power);
|
|
sqlite3_bind_double(stmt, 4, powerData.temperature);
|
|
|
|
if (sqlite3_step(stmt) != SQLITE_DONE) {
|
|
std::cerr << "Error inserting data: " << sqlite3_errmsg(m_db) << std::endl;
|
|
result = false;
|
|
}
|
|
sqlite3_finalize(stmt);
|
|
} else {
|
|
std::cerr << "Error preparing statement: " << sqlite3_errmsg(m_db) << std::endl;
|
|
result = false;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
bool SQLiteDB::insertStateData(StateData stateData,bool filter) {
|
|
if (!m_db) return false;
|
|
if(filter){
|
|
StateData lastStateData;
|
|
if(getStateData(lastStateData)){
|
|
if(lastStateData.state_id==stateData.state_id &&
|
|
lastStateData.event_id==stateData.event_id &&
|
|
lastStateData.fault_code==stateData.fault_code &&
|
|
lastStateData.note==stateData.note &&
|
|
lastStateData.state_name==stateData.state_name &&
|
|
lastStateData.event==stateData.event){
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
const char* sql = "INSERT INTO state_data (state_id, state_name, event, event_id, fault_code, note) VALUES (?, ?, ?, ?, ?, ?);";
|
|
sqlite3_stmt* stmt;
|
|
|
|
if (sqlite3_prepare_v2(m_db, sql, -1, &stmt, nullptr) == SQLITE_OK) {
|
|
sqlite3_bind_int(stmt, 1, stateData.state_id);
|
|
sqlite3_bind_text(stmt, 2, stateData.state_name.c_str(), -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 3, stateData.event.c_str(), -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_int(stmt, 4, stateData.event_id);
|
|
sqlite3_bind_int(stmt, 5, stateData.fault_code);
|
|
sqlite3_bind_text(stmt, 6, stateData.note.c_str(), -1, SQLITE_TRANSIENT);
|
|
|
|
if (sqlite3_step(stmt) != SQLITE_DONE) {
|
|
std::cerr << "Error inserting data: " << sqlite3_errmsg(m_db) << std::endl;
|
|
return false;
|
|
}
|
|
|
|
sqlite3_finalize(stmt);
|
|
} else {
|
|
std::cerr << "Error preparing statement: " << sqlite3_errmsg(m_db) << std::endl;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool SQLiteDB::getStateData(StateData &stateData) {
|
|
if (!m_db) {
|
|
std::cerr << "Database not initialized" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
const char* sql = "SELECT * FROM state_data ORDER BY timestamp DESC LIMIT 1;";
|
|
sqlite3_stmt* stmt = nullptr;
|
|
bool result = false;
|
|
|
|
try {
|
|
if (sqlite3_prepare_v2(m_db, sql, -1, &stmt, nullptr) != SQLITE_OK) {
|
|
throw std::runtime_error(sqlite3_errmsg(m_db));
|
|
}
|
|
|
|
int stepResult = sqlite3_step(stmt);
|
|
if (stepResult == SQLITE_ROW) {
|
|
stateData.state_id = sqlite3_column_int(stmt, 1);
|
|
|
|
const char* stateName = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 3));
|
|
stateData.state_name = stateName ? stateName : "";
|
|
|
|
const char* event = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 4));
|
|
stateData.event = event ? event : "";
|
|
|
|
stateData.event_id = sqlite3_column_int(stmt, 5);
|
|
stateData.fault_code = sqlite3_column_int(stmt, 6);
|
|
|
|
const char* note = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 7));
|
|
stateData.note = note ? note : "";
|
|
|
|
result = true;
|
|
} else if (stepResult != SQLITE_DONE) {
|
|
throw std::runtime_error(sqlite3_errmsg(m_db));
|
|
}
|
|
} catch (const std::exception& e) {
|
|
std::cerr << "Error retrieving state data: " << e.what() << std::endl;
|
|
}
|
|
|
|
if (stmt) {
|
|
sqlite3_finalize(stmt);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
bool SQLiteDB::getStateData(StateData &stateData, string &time) {
|
|
if (!m_db) {
|
|
std::cerr << "Database not initialized" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
const char* sql = "SELECT * FROM state_data ORDER BY timestamp DESC LIMIT 1;";
|
|
sqlite3_stmt* stmt = nullptr;
|
|
bool result = false;
|
|
|
|
try {
|
|
if (sqlite3_prepare_v2(m_db, sql, -1, &stmt, nullptr) != SQLITE_OK) {
|
|
throw std::runtime_error(sqlite3_errmsg(m_db));
|
|
}
|
|
|
|
int stepResult = sqlite3_step(stmt);
|
|
if (stepResult == SQLITE_ROW) {
|
|
stateData.state_id = sqlite3_column_int(stmt, 1);
|
|
|
|
const char* timestamp = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 2));
|
|
time = timestamp ? timestamp : "";
|
|
|
|
const char* stateName = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 3));
|
|
stateData.state_name = stateName ? stateName : "";
|
|
|
|
const char* event = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 4));
|
|
stateData.event = event ? event : "";
|
|
|
|
stateData.event_id = sqlite3_column_int(stmt, 5);
|
|
stateData.fault_code = sqlite3_column_int(stmt, 6);
|
|
|
|
const char* note = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 7));
|
|
stateData.note = note ? note : "";
|
|
|
|
result = true;
|
|
} else if (stepResult != SQLITE_DONE) {
|
|
throw std::runtime_error(sqlite3_errmsg(m_db));
|
|
}
|
|
} catch (const std::exception& e) {
|
|
std::cerr << "Error retrieving state data: " << e.what() << std::endl;
|
|
}
|
|
|
|
if (stmt) {
|
|
sqlite3_finalize(stmt);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
bool SQLiteDB::isDatabaseConnected(const std::string& path, const std::string& dbName) {
|
|
if (!m_db) return false;
|
|
|
|
// 尝试执行简单查询验证连接
|
|
const char* sql = "SELECT name FROM sqlite_master WHERE type='table';";
|
|
char* errMsg = nullptr;
|
|
|
|
int rc = sqlite3_exec(m_db, sql, nullptr, nullptr, &errMsg);
|
|
if (rc != SQLITE_OK) {
|
|
std::cerr << "Database connection check failed: " << errMsg << std::endl;
|
|
sqlite3_free(errMsg);
|
|
return false;
|
|
}
|
|
|
|
// 检查数据库路径和名称是否匹配
|
|
std::string fullPath = path + "/" + dbName;
|
|
const char* dbPath = sqlite3_db_filename(m_db, "main");
|
|
|
|
if (!dbPath || fullPath != dbPath) {
|
|
std::cerr << "Database path mismatch: expected " << fullPath << ", got " << (dbPath ? dbPath : "null") << std::endl;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
string SQLiteDB::getDBPatch(){
|
|
return m_dbPath;
|
|
}
|
|
|
|
long SQLiteDB::getDatabaseSize() {
|
|
if (m_dbPath.empty()) {
|
|
return -1;
|
|
}
|
|
|
|
struct stat stat_buf;
|
|
int rc = stat(m_dbPath.c_str(), &stat_buf);
|
|
if (rc != 0) {
|
|
return -1;
|
|
}
|
|
|
|
return stat_buf.st_size;
|
|
}
|
|
|
|
bool SQLiteDB::clearPowerData() {
|
|
if (!m_db) return false;
|
|
|
|
const char* sql = "DELETE FROM power_data;";
|
|
char* errMsg = nullptr;
|
|
if (sqlite3_exec(m_db, sql, nullptr, nullptr, &errMsg) != SQLITE_OK) {
|
|
std::cerr << "SQL error: " << errMsg << std::endl;
|
|
sqlite3_free(errMsg);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool SQLiteDB::clearStateData() {
|
|
if (!m_db) return false;
|
|
|
|
const char* sql = "DELETE FROM state_data;";
|
|
char* errMsg = nullptr;
|
|
if (sqlite3_exec(m_db, sql, nullptr, nullptr, &errMsg) != SQLITE_OK) {
|
|
std::cerr << "SQL error: " << errMsg << std::endl;
|
|
sqlite3_free(errMsg);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
bool SQLiteDB::insertDisCcuData(pmState s, bool filter) {
|
|
if (!m_db) return false;
|
|
|
|
// 检查是否需要过滤
|
|
if (filter) {
|
|
// TODO: 实现过滤逻辑，检查是否与上一条记录相同
|
|
}
|
|
// 插入ccu_state表
|
|
const char* ccuSql = "INSERT INTO ccu_state ("
|
|
"currentWorkCondition, fcuState, fcuFaultLeve, powerLimit, totalPowerGeneration, "
|
|
"ch4o, o2, fcuVoltage, fcuCurrent, o2Level, placeholder1, exchangerTemperature, "
|
|
"fcuOutPower, fcuOutIns, fcuVoltageIns, fcuVoltagePower, fcuCurrentIns, fcuCurrentPower, "
|
|
"h2Concentration1, h2Concentration2, o2Concentration1, o2Concentration2, "
|
|
"ch4oConcentration1, ch4oConcentration2, backpressure1, backpressure2, flameDetection, "
|
|
"fcuGZ_1L, fcuGZ_1H, fcuGZ_2L, fcuGZ_2H, fcuGZ_3L, fcuGZ_3H, insPosRelayState, "
|
|
"insNegRelayState, powerPosRelayState, powerNegRelayState, insBatLimit, powerBatLimit, "
|
|
"insBatSoc, powerBatSoc, insBatTotalElectricity, powerBatTotalElectricity, "
|
|
"insBatCurrentElectricity, powerBatCurrentElectricity, insChargeState, powerChargeState, "
|
|
"insLinkVoltage, insPackVoltage, insCurrent, insPosInsulationResistance, "
|
|
"insNegInsulationResistance, powerLinkVoltage, powerPackVoltage, powerCurrent, "
|
|
"powerPosInsulationResistance, powerNegInsulationResistance, insEmergencyStatusWord, "
|
|
"powerEmergencyStatusWord, insAlarmIdentificationWord, powerAlarmIdentificationWord, "
|
|
"insCurrentSocHold1, insCurrentSocHold2, insCurrentSocHold3, fcuCurrentToInsLimit1, "
|
|
"fcuCurrentToinsLimit2, powerCurrentSocHold1, powerCurrentSocHold2, powerCurrentSocHold3, "
|
|
"powerCurrentToInsLimit1, powerCurrentToinsLimit2, placeholder2, placeholder3, "
|
|
"placeholder4, placeholder5) "
|
|
"VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, "
|
|
"?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, "
|
|
"?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);";
|
|
|
|
// 插入dis_high_vol_bus_state表
|
|
const char* bus1Sql = "INSERT INTO dis_high_vol_bus_state ("
|
|
"fuelCellCircuitBreaker, powerLithiumBatteryCircuitBreaker, propulsionMotorCircuitBreaker, "
|
|
"lithiumBatteryGroupInstrumentCircuitBreaker, dcDc5ModuleCircuitBreaker, "
|
|
"bowHighVoltageDistributionBoxCircuitBreaker, sternFTDevice45CircuitBreaker, "
|
|
"sternRudderSwitch1CircuitBreaker, sternRudderSwitch2CircuitBreaker, fbReservedCircuitBreaker, "
|
|
"tyzReservedCircuitBreaker, reservedCircuitBreaker, busInsulationLow, busAInsulationHigh, "
|
|
"lostPower, lostEmerPower, powerBusVoltage, dcDc5ModuleCurrent, powerBusCurrent, "
|
|
"busbarAVoltage, propulsionMotorControlBoxCurrent, busbarACurrent, "
|
|
"lithiumBatteryGroupMeterCurrent, bowHighVoltageDistributionBoxCurrent, "
|
|
"sternFTDevice45Current, tyzReservedSwitchCurrent, sternRudderSwitch1Current, "
|
|
"reservedCurrent1, sternRudderSwitch2Current, reservedCurrent2, fbReservedSwitchCurrent, "
|
|
"reservedCurrent3) "
|
|
"VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, "
|
|
"?, ?, ?, ?, ?, ?);";
|
|
|
|
// 插入dis_high_a_vol_bus_state表
|
|
const char* bus2Sql = "INSERT INTO dis_high_a_vol_bus_state ("
|
|
"bowFTDevice123CircuitBreaker, actuatorCircuitBreaker, mastSteeringGearControlBoxCircuitBreaker, "
|
|
"xczCircuitBreaker, bowRudderControlBoxCircuitBreaker, openWaterCoverStartCylinderCircuitBreaker, "
|
|
"instrumentPowerFailureSignal, emergencyPowerFailureSignal, waterIngressionAlarm, "
|
|
"busbarBVoltage, busbarBCurrent, bowFTDevice123Current, actuatorCurrent, "
|
|
"mastSteeringGearControlBoxCurrent, xczCurrent, bowRudderControlBoxCurrent, "
|
|
"openWaterCoverStartCylinderCurrent) "
|
|
"VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);";
|
|
|
|
// 插入dis_high_b_vol_bus_state表
|
|
const char* bus3Sql = "INSERT INTO dis_high_b_vol_bus_state ("
|
|
"lithiumBatteryGroupInstrumentCircuitBreaker, bowLowVoltageDistributionBoxCircuitBreaker, "
|
|
"unit4InstrumentDC48VCircuitBreaker, dcC1DCDistributionPanelCircuitBreaker, "
|
|
"reservedCircuitBreaker1, reservedCircuitBreaker2, emergencyLithiumBatteryGroup2CircuitBreaker, "
|
|
"instrumentPowerFailureSignal, emergencyPowerFailureSignal, instrumentBusbarInsulationLow, "
|
|
"instrumentBusbarVoltage, bowLowVoltageDistributionBoxCurrent, dcC1InstrumentDC48VCurrent, "
|
|
"reservedCurrent1, emergencyLithiumBatteryGroup2Current, lithiumBatteryGroupInstrumentCurrent, "
|
|
"unit4InstrumentDC48VCurrent, reservedCurrent2, emergency2BusbarVoltage, "
|
|
"compositeEnergyManagementSystemEmergencyDC48VCurrent, fuelCellSecuritySystemEmergencyDC48VCurrent, "
|
|
"plcControlPowerCurrent) "
|
|
"VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?,?);";
|
|
|
|
// 插入dis_low_bus_state表
|
|
const char* bus4Sql = "INSERT INTO dis_low_bus_state ("
|
|
"unit1CircuitBreaker, unit2CircuitBreaker, unit3CircuitBreaker, unit5CircuitBreaker, "
|
|
"bowPZDeviceCircuitBreaker, reservedCircuitBreaker1, reservedCircuitBreaker2, "
|
|
"emergencyLithiumBatteryGroup1CircuitBreaker, powerFailureSignal, waterIngressionAlarm, "
|
|
"instrumentBusbarVoltage, instrumentBusbarCurrent, unit1Current, unit2Current, "
|
|
"unit3Current, unit5Current, bowPZDeviceCurrent, emergencyLithiumBatteryGroup1Current, "
|
|
"emergency1BusbarVoltage) "
|
|
"VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);";
|
|
|
|
// 执行所有插入操作
|
|
bool result = true;
|
|
result = result && executeInsert(ccuSql, s.ccustate);
|
|
result = result && executeInsert(bus1Sql, s.bus1State);
|
|
result = result && executeInsert(bus2Sql, s.bus2State);
|
|
result = result && executeInsert(bus3Sql, s.bus3State);
|
|
result = result && executeInsert(bus4Sql, s.bus4State);
|
|
|
|
return result;
|
|
}
|
|
bool SQLiteDB::insertCcuSysCmd(ccuColCmd cmd)
|
|
{
|
|
if (!m_db) return false;
|
|
|
|
// 插入ccu_sys_cmd表
|
|
const char* ccuSysCmdSql = "INSERT INTO ccu_sys_cmd ("
|
|
"workCondition, fcuCmd, fcuPowerEfficiency, fcuInsEfficiency, "
|
|
"insBatCmd, powerBatCmd, powerBatEfficiency, heartbeat, masterState) "
|
|
"VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?);";
|
|
|
|
// 执行插入操作
|
|
bool result = executeInsert(ccuSysCmdSql, cmd);
|
|
return result;
|
|
}
|
|
|
|
bool SQLiteDB::insertDisSysCmd(disHighVolBusCmd cmd)
|
|
{
|
|
if (!m_db) return false;
|
|
|
|
// 插入dis_sys_cmd表，根据结构体完善SQL语句
|
|
const char* disSysCmdSql = "INSERT INTO dis_high_vol_bus_cmd ("
|
|
"fuelCellCircuitBreaker, powerLithiumBatteryCircuitBreaker, propulsionMotorCircuitBreaker, "
|
|
"lithiumBatteryGroupInstrumentCircuitBreaker, dcDc5ModuleCircuitBreaker, "
|
|
"bowHighVoltageDistributionBoxCircuitBreaker, sternFTDevice45CircuitBreaker, "
|
|
"sternRudderSwitch1CircuitBreaker, sternRudderSwitch2CircuitBreaker, "
|
|
"fbReservedCircuitBreaker, tyzReservedCircuitBreaker, reservedCircuitBreaker, "
|
|
"dcdc5Module, inputWater, outputWater) "
|
|
"VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);";
|
|
|
|
// 执行插入操作
|
|
bool result = executeInsert(disSysCmdSql, cmd);
|
|
return result;
|
|
}
|
|
|
|
bool SQLiteDB::insertDisSysCmd(disHighAVolBusCmd cmd)
|
|
{
|
|
if (!m_db) return false;
|
|
|
|
// 插入dis_sys_cmd表，根据结构体完善SQL语句
|
|
const char* disSysCmdSql = "INSERT INTO dis_high_a_vol_bus_cmd ("
|
|
"bowFTDevice123CircuitBreaker, actuatorCircuitBreaker, mastSteeringGearControlBoxCircuitBreaker, "
|
|
"xczCircuitBreaker, bowRudderControlBoxCircuitBreaker, openWaterCoverStartCylinderCircuitBreaker) "
|
|
"VALUES (?, ?, ?, ?, ?, ?);";
|
|
|
|
// 执行插入操作
|
|
bool result = executeInsert(disSysCmdSql, cmd);
|
|
return result;
|
|
}
|
|
|
|
bool SQLiteDB::insertDisSysCmd(disHighBVolBusCmd cmd)
|
|
{
|
|
if (!m_db) return false;
|
|
// 插入dis_sys_cmd表，根据结构体完善SQL语句
|
|
const char* disSysCmdSql = "INSERT INTO dis_high_b_vol_bus_cmd ("
|
|
"lithiumBatteryGroupInstrumentCircuitBreaker, "
|
|
"bowLowVoltageDistributionBoxCircuitBreaker, "
|
|
"unit4InstrumentDC48VCircuitBreaker, "
|
|
"dcC1DCDistributionPanelCircuitBreaker, "
|
|
"reservedCircuitBreaker1, "
|
|
"reservedCircuitBreaker2, "
|
|
"emergencyLithiumBatteryGroup2CircuitBreaker) "
|
|
"VALUES (?, ?, ?, ?, ?, ?, ?);";
|
|
|
|
// 执行插入操作
|
|
bool result = executeInsert(disSysCmdSql, cmd);
|
|
return result;
|
|
}
|
|
|
|
bool SQLiteDB::insertDisSysCmd(disLowBusCmd cmd)
|
|
{
|
|
if (!m_db) return false;
|
|
|
|
// 插入dis_sys_cmd表，根据结构体完善SQL语句
|
|
const char* disSysCmdSql = "INSERT INTO dis_low_bus_cmd ("
|
|
"unit1CircuitBreaker, unit2CircuitBreaker, unit3CircuitBreaker, unit5CircuitBreaker, "
|
|
"bowPZDeviceCircuitBreaker, reservedCircuitBreaker1, reservedCircuitBreaker2, "
|
|
"emergencyLithiumBatteryGroup1CircuitBreaker) "
|
|
"VALUES (?, ?, ?, ?, ?, ?, ?, ?);";
|
|
|
|
// 执行插入操作
|
|
bool result = executeInsert(disSysCmdSql, cmd);
|
|
return result;
|
|
}
|
|
|
|
bool SQLiteDB::insertCcuData(ccuState s)
|
|
{
|
|
if (!m_db) return false;
|
|
// 插入ccu_state表
|
|
const char* ccuSql = "INSERT INTO ccu_state ("
|
|
"currentWorkCondition, fcuState, fcuFaultLeve, powerLimit, totalPowerGeneration, "
|
|
"ch4o, o2, fcuVoltage, fcuCurrent, o2Level, placeholder1, exchangerTemperature, "
|
|
"fcuOutPower, fcuOutIns, fcuVoltageIns, fcuVoltagePower, fcuCurrentIns, fcuCurrentPower, "
|
|
"h2Concentration1, h2Concentration2, o2Concentration1, o2Concentration2, "
|
|
"ch4oConcentration1, ch4oConcentration2, backpressure1, backpressure2, flameDetection, "
|
|
"fcuGZ_1L, fcuGZ_1H, fcuGZ_2L, fcuGZ_2H, fcuGZ_3L, fcuGZ_3H, insPosRelayState, "
|
|
"insNegRelayState, powerPosRelayState, powerNegRelayState, insBatLimit, powerBatLimit, "
|
|
"insBatSoc, powerBatSoc, insBatTotalElectricity, powerBatTotalElectricity, "
|
|
"insBatCurrentElectricity, powerBatCurrentElectricity, insChargeState, powerChargeState, "
|
|
"insLinkVoltage, insPackVoltage, insCurrent, insPosInsulationResistance, "
|
|
"insNegInsulationResistance, powerLinkVoltage, powerPackVoltage, powerCurrent, "
|
|
"powerPosInsulationResistance, powerNegInsulationResistance, insEmergencyStatusWord, "
|
|
"powerEmergencyStatusWord, insAlarmIdentificationWord, powerAlarmIdentificationWord, "
|
|
"insCurrentSocHold1, insCurrentSocHold2, insCurrentSocHold3, fcuCurrentToInsLimit1, "
|
|
"fcuCurrentToinsLimit2, powerCurrentSocHold1, powerCurrentSocHold2, powerCurrentSocHold3, "
|
|
"powerCurrentToInsLimit1, powerCurrentToinsLimit2, placeholder2, placeholder3, "
|
|
"placeholder4, placeholder5) "
|
|
"VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, "
|
|
"?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, "
|
|
"?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);";
|
|
// 执行所有插入操作
|
|
bool result = true;
|
|
result = executeInsert(ccuSql, s);
|
|
return result;
|
|
}
|
|
bool SQLiteDB::insertDisHighVolBusData(disHighVolBusState s)
|
|
{
|
|
if (!m_db) return false;
|
|
|
|
// 插入dis_high_vol_bus_state表
|
|
const char* bus1Sql = "INSERT INTO dis_high_vol_bus_state ("
|
|
"fuelCellCircuitBreaker, powerLithiumBatteryCircuitBreaker, propulsionMotorCircuitBreaker, "
|
|
"lithiumBatteryGroupInstrumentCircuitBreaker, dcDc5ModuleCircuitBreaker, "
|
|
"bowHighVoltageDistributionBoxCircuitBreaker, sternFTDevice45CircuitBreaker, "
|
|
"sternRudderSwitch1CircuitBreaker, sternRudderSwitch2CircuitBreaker, fbReservedCircuitBreaker, "
|
|
"tyzReservedCircuitBreaker, reservedCircuitBreaker, busInsulationLow, busAInsulationHigh, "
|
|
"lostPower, lostEmerPower, powerBusVoltage, dcDc5ModuleCurrent, powerBusCurrent, "
|
|
"busbarAVoltage, propulsionMotorControlBoxCurrent, busbarACurrent, "
|
|
"lithiumBatteryGroupMeterCurrent, bowHighVoltageDistributionBoxCurrent, "
|
|
"sternFTDevice45Current, tyzReservedSwitchCurrent, sternRudderSwitch1Current, "
|
|
"reservedCurrent1, sternRudderSwitch2Current, reservedCurrent2, fbReservedSwitchCurrent, "
|
|
"reservedCurrent3) "
|
|
"VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, "
|
|
"?, ?, ?, ?, ?, ?);";
|
|
|
|
// 执行所有插入操作
|
|
bool result = true;
|
|
result = executeInsert(bus1Sql, s);
|
|
|
|
return result;
|
|
}
|
|
bool SQLiteDB::insertDisHighAVolBusData(disHighAVolBusState s)
|
|
{
|
|
if (!m_db) return false;
|
|
|
|
// 插入dis_high_a_vol_bus_state表
|
|
const char* bus2Sql = "INSERT INTO dis_high_a_vol_bus_state ("
|
|
"bowFTDevice123CircuitBreaker, actuatorCircuitBreaker, mastSteeringGearControlBoxCircuitBreaker, "
|
|
"xczCircuitBreaker, bowRudderControlBoxCircuitBreaker, openWaterCoverStartCylinderCircuitBreaker, "
|
|
"instrumentPowerFailureSignal, emergencyPowerFailureSignal, waterIngressionAlarm, "
|
|
"busbarBVoltage, busbarBCurrent, bowFTDevice123Current, actuatorCurrent, "
|
|
"mastSteeringGearControlBoxCurrent, xczCurrent, bowRudderControlBoxCurrent, "
|
|
"openWaterCoverStartCylinderCurrent) "
|
|
"VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);";
|
|
|
|
// 执行所有插入操作
|
|
bool result = true;
|
|
result = executeInsert(bus2Sql, s);
|
|
|
|
return result;
|
|
}
|
|
bool SQLiteDB::insertDisHighBVolBusData(disHighBVolBusState s)
|
|
{
|
|
if (!m_db) return false;
|
|
|
|
const char* bus3Sql = "INSERT INTO dis_high_b_vol_bus_state ("
|
|
"lithiumBatteryGroupInstrumentCircuitBreaker, bowLowVoltageDistributionBoxCircuitBreaker, "
|
|
"unit4InstrumentDC48VCircuitBreaker, dcC1DCDistributionPanelCircuitBreaker, "
|
|
"reservedCircuitBreaker1, reservedCircuitBreaker2, emergencyLithiumBatteryGroup2CircuitBreaker, "
|
|
"instrumentPowerFailureSignal, emergencyPowerFailureSignal, instrumentBusbarInsulationLow, "
|
|
"instrumentBusbarVoltage, bowLowVoltageDistributionBoxCurrent, dcC1InstrumentDC48VCurrent, "
|
|
"reservedCurrent1, emergencyLithiumBatteryGroup2Current, lithiumBatteryGroupInstrumentCurrent, "
|
|
"unit4InstrumentDC48VCurrent, reservedCurrent2, emergency2BusbarVoltage, "
|
|
"compositeEnergyManagementSystemEmergencyDC48VCurrent, fuelCellSecuritySystemEmergencyDC48VCurrent, "
|
|
"plcControlPowerCurrent) "
|
|
"VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?,?);";
|
|
|
|
// 执行所有插入操作
|
|
bool result = true;
|
|
result = executeInsert(bus3Sql, s);
|
|
|
|
return result;
|
|
}
|
|
bool SQLiteDB::insertDisLowBusData(disLowBusState s)
|
|
{
|
|
if (!m_db) return false;
|
|
|
|
// 插入dis_low_bus_state表
|
|
const char* bus4Sql = "INSERT INTO dis_low_bus_state ("
|
|
"unit1CircuitBreaker, unit2CircuitBreaker, unit3CircuitBreaker, unit5CircuitBreaker, "
|
|
"bowPZDeviceCircuitBreaker, reservedCircuitBreaker1, reservedCircuitBreaker2, "
|
|
"emergencyLithiumBatteryGroup1CircuitBreaker, powerFailureSignal, waterIngressionAlarm, "
|
|
"instrumentBusbarVoltage, instrumentBusbarCurrent, unit1Current, unit2Current, "
|
|
"unit3Current, unit5Current, bowPZDeviceCurrent, emergencyLithiumBatteryGroup1Current, "
|
|
"emergency1BusbarVoltage) "
|
|
"VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);";
|
|
|
|
// 执行所有插入操作
|
|
bool result = true;
|
|
result = executeInsert(bus4Sql, s);
|
|
|
|
return result;
|
|
}
|
|
|
|
bool SQLiteDB::insertDriverTables(DriverTable driverTable,string tableName)
|
|
{
|
|
if (!m_db) return false;
|
|
|
|
// 构建插入语句
|
|
std::string insertSql = "INSERT INTO " + tableName + " ("
|
|
"depth1, depth2, depth3, overDeep1, overDeep2, ctd1, ctd2, soundVeloc, commMast, ins, ntp, "
|
|
"inputWaterSensor1, inputWaterSensor2, inputWaterSensor3, "
|
|
"singleBeamSonar1, singleBeamSonar2, singleBeamSonar3, singleBeamSonar4, singleBeamSonar5, "
|
|
"singleBeamSonar6, singleBeamSonar7, singleBeamSonar8, forwardSonar, DVL, lowFreqSonar, USBL, "
|
|
"bowWaterlnet1, bowWaterlnet2, bowWaterlnet3, bowWaterlnet4, bowWaterlnet5, bowWaterlnet6, "
|
|
"bowWaterlnet7, bowWaterlnet8, bowRudderDeploy, bowRudderServo1, bowRudderServo2, "
|
|
"bowCover1, bowCover2, bowCover3, bowCover4, bowCover5, bowCover6, waterInject, "
|
|
"mastLiftingServo, buoyancyAdjust1, buoyancyAdjust2, buoyancyAdjust3, buoyancyAdjust4, "
|
|
"buoyancyAdjust5, sternRudderServo1, sternRudderServo2, sternRudderServo3, sternRudderServo4, "
|
|
"thruster, bowThrow, sternThrow, "
|
|
"photoSensor, electSensor, launchControler, sideSonar, buoyage) "
|
|
"VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, "
|
|
"?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, "
|
|
"?, ?, ?, ?, ?, ?, ?, ?);";
|
|
|
|
// 执行插入操作
|
|
bool result = executeInsert(insertSql.c_str(), driverTable);
|
|
return result;
|
|
}
|
|
|
|
template<typename T>
|
|
bool SQLiteDB::executeInsert(const char* sql, const T& data) {
|
|
sqlite3_stmt* stmt;
|
|
if (sqlite3_prepare_v2(m_db, sql, -1, &stmt, nullptr) != SQLITE_OK) {
|
|
std::cerr << "Error preparing statement: " << sqlite3_errmsg(m_db) << std::endl;
|
|
return false;
|
|
}
|
|
|
|
// 绑定参数
|
|
if (!bindParameters(stmt, data)) {
|
|
sqlite3_finalize(stmt);
|
|
return false;
|
|
}
|
|
|
|
if (sqlite3_step(stmt) != SQLITE_DONE) {
|
|
std::cerr << "Error inserting data: " << sqlite3_errmsg(m_db) << std::endl;
|
|
sqlite3_finalize(stmt);
|
|
return false;
|
|
}
|
|
|
|
sqlite3_finalize(stmt);
|
|
return true;
|
|
}
|
|
|
|
|
|
bool SQLiteDB::createDisCcuSysTables() {
|
|
if (!m_db) return false;
|
|
|
|
// 创建ccu_state表
|
|
const char* ccuStateSql = "CREATE TABLE IF NOT EXISTS ccu_state ("
|
|
"timestamp DATETIME DEFAULT (strftime('%Y-%m-%d %H:%M:%f', 'now')),"
|
|
"currentWorkCondition INTEGER NOT NULL,"
|
|
"fcuState INTEGER NOT NULL,"
|
|
"fcuFaultLeve INTEGER NOT NULL,"
|
|
"powerLimit REAL NOT NULL,"
|
|
"totalPowerGeneration REAL NOT NULL,"
|
|
"ch4o REAL NOT NULL,"
|
|
"o2 REAL NOT NULL,"
|
|
"fcuVoltage REAL NOT NULL,"
|
|
"fcuCurrent REAL NOT NULL,"
|
|
"o2Level REAL NOT NULL,"
|
|
"placeholder1 REAL NOT NULL,"
|
|
"exchangerTemperature REAL NOT NULL,"
|
|
"fcuOutPower REAL NOT NULL,"
|
|
"fcuOutIns REAL NOT NULL,"
|
|
"fcuVoltageIns REAL NOT NULL,"
|
|
"fcuVoltagePower REAL NOT NULL,"
|
|
"fcuCurrentIns REAL NOT NULL,"
|
|
"fcuCurrentPower REAL NOT NULL,"
|
|
"h2Concentration1 REAL NOT NULL,"
|
|
"h2Concentration2 REAL NOT NULL,"
|
|
"o2Concentration1 REAL NOT NULL,"
|
|
"o2Concentration2 REAL NOT NULL,"
|
|
"ch4oConcentration1 REAL NOT NULL,"
|
|
"ch4oConcentration2 REAL NOT NULL,"
|
|
"backpressure1 REAL NOT NULL,"
|
|
"backpressure2 REAL NOT NULL,"
|
|
"flameDetection INTEGER NOT NULL,"
|
|
"fcuGZ_1L INTEGER NOT NULL,"
|
|
"fcuGZ_1H INTEGER NOT NULL,"
|
|
"fcuGZ_2L INTEGER NOT NULL,"
|
|
"fcuGZ_2H INTEGER NOT NULL,"
|
|
"fcuGZ_3L INTEGER NOT NULL,"
|
|
"fcuGZ_3H INTEGER NOT NULL,"
|
|
"insPosRelayState INTEGER NOT NULL,"
|
|
"insNegRelayState INTEGER NOT NULL,"
|
|
"powerPosRelayState INTEGER NOT NULL,"
|
|
"powerNegRelayState INTEGER NOT NULL,"
|
|
"insBatLimit INTEGER NOT NULL,"
|
|
"powerBatLimit INTEGER NOT NULL,"
|
|
"insBatSoc INTEGER NOT NULL,"
|
|
"powerBatSoc INTEGER NOT NULL,"
|
|
"insBatTotalElectricity INTEGER NOT NULL,"
|
|
"powerBatTotalElectricity INTEGER NOT NULL,"
|
|
"insBatCurrentElectricity INTEGER NOT NULL,"
|
|
"powerBatCurrentElectricity INTEGER NOT NULL,"
|
|
"insChargeState INTEGER NOT NULL,"
|
|
"powerChargeState INTEGER NOT NULL,"
|
|
"insLinkVoltage INTEGER NOT NULL,"
|
|
"insPackVoltage INTEGER NOT NULL,"
|
|
"insCurrent INTEGER NOT NULL,"
|
|
"insPosInsulationResistance INTEGER NOT NULL,"
|
|
"insNegInsulationResistance INTEGER NOT NULL,"
|
|
"powerLinkVoltage INTEGER NOT NULL,"
|
|
"powerPackVoltage INTEGER NOT NULL,"
|
|
"powerCurrent INTEGER NOT NULL,"
|
|
"powerPosInsulationResistance INTEGER NOT NULL,"
|
|
"powerNegInsulationResistance INTEGER NOT NULL,"
|
|
"insEmergencyStatusWord INTEGER NOT NULL,"
|
|
"powerEmergencyStatusWord INTEGER NOT NULL,"
|
|
"insAlarmIdentificationWord INTEGER NOT NULL,"
|
|
"powerAlarmIdentificationWord INTEGER NOT NULL,"
|
|
"insCurrentSocHold1 INTEGER NOT NULL,"
|
|
"insCurrentSocHold2 INTEGER NOT NULL,"
|
|
"insCurrentSocHold3 INTEGER NOT NULL,"
|
|
"fcuCurrentToInsLimit1 INTEGER NOT NULL,"
|
|
"fcuCurrentToinsLimit2 INTEGER NOT NULL,"
|
|
"powerCurrentSocHold1 INTEGER NOT NULL,"
|
|
"powerCurrentSocHold2 INTEGER NOT NULL,"
|
|
"powerCurrentSocHold3 INTEGER NOT NULL,"
|
|
"powerCurrentToInsLimit1 INTEGER NOT NULL,"
|
|
"powerCurrentToinsLimit2 INTEGER NOT NULL,"
|
|
"placeholder2 REAL NOT NULL,"
|
|
"placeholder3 REAL NOT NULL,"
|
|
"placeholder4 REAL NOT NULL,"
|
|
"placeholder5 REAL NOT NULL);";
|
|
|
|
// 创建dis_high_vol_bus_state表
|
|
const char* disHighVolBusStateSql = "CREATE TABLE IF NOT EXISTS dis_high_vol_bus_state ("
|
|
"timestamp DATETIME DEFAULT (strftime('%Y-%m-%d %H:%M:%f', 'now')),"
|
|
"fuelCellCircuitBreaker INTEGER NOT NULL,"
|
|
"powerLithiumBatteryCircuitBreaker INTEGER NOT NULL,"
|
|
"propulsionMotorCircuitBreaker INTEGER NOT NULL,"
|
|
"lithiumBatteryGroupInstrumentCircuitBreaker INTEGER NOT NULL,"
|
|
"dcDc5ModuleCircuitBreaker INTEGER NOT NULL,"
|
|
"bowHighVoltageDistributionBoxCircuitBreaker INTEGER NOT NULL,"
|
|
"sternFTDevice45CircuitBreaker INTEGER NOT NULL,"
|
|
"sternRudderSwitch1CircuitBreaker INTEGER NOT NULL,"
|
|
"sternRudderSwitch2CircuitBreaker INTEGER NOT NULL,"
|
|
"fbReservedCircuitBreaker INTEGER NOT NULL,"
|
|
"tyzReservedCircuitBreaker INTEGER NOT NULL,"
|
|
"reservedCircuitBreaker INTEGER NOT NULL,"
|
|
"busInsulationLow INTEGER NOT NULL,"
|
|
"busAInsulationHigh INTEGER NOT NULL,"
|
|
"lostPower INTEGER NOT NULL,"
|
|
"lostEmerPower INTEGER NOT NULL,"
|
|
"powerBusVoltage INTEGER NOT NULL,"
|
|
"dcDc5ModuleCurrent INTEGER NOT NULL,"
|
|
"powerBusCurrent INTEGER NOT NULL,"
|
|
"busbarAVoltage INTEGER NOT NULL,"
|
|
"propulsionMotorControlBoxCurrent INTEGER NOT NULL,"
|
|
"busbarACurrent INTEGER NOT NULL,"
|
|
"lithiumBatteryGroupMeterCurrent INTEGER NOT NULL,"
|
|
"bowHighVoltageDistributionBoxCurrent INTEGER NOT NULL,"
|
|
"sternFTDevice45Current INTEGER NOT NULL,"
|
|
"tyzReservedSwitchCurrent INTEGER NOT NULL,"
|
|
"sternRudderSwitch1Current INTEGER NOT NULL,"
|
|
"reservedCurrent1 INTEGER NOT NULL,"
|
|
"sternRudderSwitch2Current INTEGER NOT NULL,"
|
|
"reservedCurrent2 INTEGER NOT NULL,"
|
|
"fbReservedSwitchCurrent INTEGER NOT NULL,"
|
|
"reservedCurrent3 INTEGER NOT NULL);";
|
|
|
|
// 创建dis_high_a_vol_bus_state表
|
|
const char* disHighAVolBusStateSql = "CREATE TABLE IF NOT EXISTS dis_high_a_vol_bus_state ("
|
|
"timestamp DATETIME DEFAULT (strftime('%Y-%m-%d %H:%M:%f', 'now')),"
|
|
"bowFTDevice123CircuitBreaker INTEGER NOT NULL,"
|
|
"actuatorCircuitBreaker INTEGER NOT NULL,"
|
|
"mastSteeringGearControlBoxCircuitBreaker INTEGER NOT NULL,"
|
|
"xczCircuitBreaker INTEGER NOT NULL,"
|
|
"bowRudderControlBoxCircuitBreaker INTEGER NOT NULL,"
|
|
"openWaterCoverStartCylinderCircuitBreaker INTEGER NOT NULL,"
|
|
"instrumentPowerFailureSignal INTEGER NOT NULL,"
|
|
"emergencyPowerFailureSignal INTEGER NOT NULL,"
|
|
"waterIngressionAlarm INTEGER NOT NULL,"
|
|
"busbarBVoltage INTEGER NOT NULL,"
|
|
"busbarBCurrent INTEGER NOT NULL,"
|
|
"bowFTDevice123Current INTEGER NOT NULL,"
|
|
"actuatorCurrent INTEGER NOT NULL,"
|
|
"mastSteeringGearControlBoxCurrent INTEGER NOT NULL,"
|
|
"xczCurrent INTEGER NOT NULL,"
|
|
"bowRudderControlBoxCurrent INTEGER NOT NULL,"
|
|
"openWaterCoverStartCylinderCurrent INTEGER NOT NULL);";
|
|
|
|
// 创建dis_high_b_vol_bus_state表
|
|
const char* disHighBVolBusStateSql = "CREATE TABLE IF NOT EXISTS dis_high_b_vol_bus_state ("
|
|
"timestamp DATETIME DEFAULT (strftime('%Y-%m-%d %H:%M:%f', 'now')),"
|
|
"lithiumBatteryGroupInstrumentCircuitBreaker INTEGER NOT NULL,"
|
|
"bowLowVoltageDistributionBoxCircuitBreaker INTEGER NOT NULL,"
|
|
"unit4InstrumentDC48VCircuitBreaker INTEGER NOT NULL,"
|
|
"dcC1DCDistributionPanelCircuitBreaker INTEGER NOT NULL,"
|
|
"reservedCircuitBreaker1 INTEGER NOT NULL,"
|
|
"reservedCircuitBreaker2 INTEGER NOT NULL,"
|
|
"emergencyLithiumBatteryGroup2CircuitBreaker INTEGER NOT NULL,"
|
|
"instrumentPowerFailureSignal INTEGER NOT NULL,"
|
|
"emergencyPowerFailureSignal INTEGER NOT NULL,"
|
|
"instrumentBusbarInsulationLow INTEGER NOT NULL,"
|
|
"instrumentBusbarVoltage INTEGER NOT NULL,"
|
|
"bowLowVoltageDistributionBoxCurrent INTEGER NOT NULL,"
|
|
"dcC1InstrumentDC48VCurrent INTEGER NOT NULL,"
|
|
"reservedCurrent1 INTEGER NOT NULL,"
|
|
"emergencyLithiumBatteryGroup2Current INTEGER NOT NULL,"
|
|
"lithiumBatteryGroupInstrumentCurrent INTEGER NOT NULL,"
|
|
"unit4InstrumentDC48VCurrent INTEGER NOT NULL,"
|
|
"reservedCurrent2 INTEGER NOT NULL,"
|
|
"emergency2BusbarVoltage INTEGER NOT NULL,"
|
|
"compositeEnergyManagementSystemEmergencyDC48VCurrent INTEGER NOT NULL,"
|
|
"fuelCellSecuritySystemEmergencyDC48VCurrent INTEGER NOT NULL,"
|
|
"plcControlPowerCurrent INTEGER NOT NULL);";
|
|
|
|
// 创建dis_low_bus_state表
|
|
const char* disLowBusStateSql = "CREATE TABLE IF NOT EXISTS dis_low_bus_state ("
|
|
"timestamp DATETIME DEFAULT (strftime('%Y-%m-%d %H:%M:%f', 'now')),"
|
|
"unit1CircuitBreaker INTEGER NOT NULL,"
|
|
"unit2CircuitBreaker INTEGER NOT NULL,"
|
|
"unit3CircuitBreaker INTEGER NOT NULL,"
|
|
"unit5CircuitBreaker INTEGER NOT NULL,"
|
|
"bowPZDeviceCircuitBreaker INTEGER NOT NULL,"
|
|
"reservedCircuitBreaker1 INTEGER NOT NULL,"
|
|
"reservedCircuitBreaker2 INTEGER NOT NULL,"
|
|
"emergencyLithiumBatteryGroup1CircuitBreaker INTEGER NOT NULL,"
|
|
"powerFailureSignal INTEGER NOT NULL,"
|
|
"waterIngressionAlarm INTEGER NOT NULL,"
|
|
"instrumentBusbarVoltage INTEGER NOT NULL,"
|
|
"instrumentBusbarCurrent INTEGER NOT NULL,"
|
|
"unit1Current INTEGER NOT NULL,"
|
|
"unit2Current INTEGER NOT NULL,"
|
|
"unit3Current INTEGER NOT NULL,"
|
|
"unit5Current INTEGER NOT NULL,"
|
|
"bowPZDeviceCurrent INTEGER NOT NULL,"
|
|
"emergencyLithiumBatteryGroup1Current INTEGER NOT NULL,"
|
|
"emergency1BusbarVoltage INTEGER NOT NULL);";
|
|
|
|
|
|
// 创建ccu命令表
|
|
const char* ccuCmdSql = "CREATE TABLE IF NOT EXISTS ccu_sys_cmd ("
|
|
"timestamp DATETIME DEFAULT (strftime('%Y-%m-%d %H:%M:%f', 'now')),"
|
|
"workCondition INTEGER NOT NULL,"
|
|
"fcuCmd INTEGER NOT NULL,"
|
|
"fcuPowerEfficiency INTEGER NOT NULL,"
|
|
"fcuInsEfficiency INTEGER NOT NULL,"
|
|
"insBatCmd INTEGER NOT NULL,"
|
|
"powerBatCmd INTEGER NOT NULL,"
|
|
"powerBatEfficiency INTEGER NOT NULL,"
|
|
"heartbeat INTEGER NOT NULL,"
|
|
"masterState INTEGER NOT NULL);";
|
|
|
|
// 创建dis命令表
|
|
const char* disHighVolBusCmdSql = "CREATE TABLE IF NOT EXISTS dis_high_vol_bus_cmd ("
|
|
"timestamp DATETIME DEFAULT (strftime('%Y-%m-%d %H:%M:%f', 'now')),"
|
|
"fuelCellCircuitBreaker INTEGER NOT NULL,"
|
|
"powerLithiumBatteryCircuitBreaker INTEGER NOT NULL,"
|
|
"propulsionMotorCircuitBreaker INTEGER NOT NULL,"
|
|
"lithiumBatteryGroupInstrumentCircuitBreaker INTEGER NOT NULL,"
|
|
"dcDc5ModuleCircuitBreaker INTEGER NOT NULL,"
|
|
"bowHighVoltageDistributionBoxCircuitBreaker INTEGER NOT NULL,"
|
|
"sternFTDevice45CircuitBreaker INTEGER NOT NULL,"
|
|
"sternRudderSwitch1CircuitBreaker INTEGER NOT NULL,"
|
|
"sternRudderSwitch2CircuitBreaker INTEGER NOT NULL,"
|
|
"fbReservedCircuitBreaker INTEGER NOT NULL,"
|
|
"tyzReservedCircuitBreaker INTEGER NOT NULL,"
|
|
"reservedCircuitBreaker INTEGER NOT NULL,"
|
|
"dcdc5Module INTEGER NOT NULL,"
|
|
"inputWater INTEGER NOT NULL,"
|
|
"outputWater INTEGER NOT NULL);";
|
|
|
|
const char* disHighAVolBusCmdSql = "CREATE TABLE IF NOT EXISTS dis_high_a_vol_bus_cmd ("
|
|
"timestamp DATETIME DEFAULT (strftime('%Y-%m-%d %H:%M:%f', 'now')),"
|
|
"bowFTDevice123CircuitBreaker INTEGER NOT NULL,"
|
|
"actuatorCircuitBreaker INTEGER NOT NULL,"
|
|
"mastSteeringGearControlBoxCircuitBreaker INTEGER NOT NULL,"
|
|
"xczCircuitBreaker INTEGER NOT NULL,"
|
|
"bowRudderControlBoxCircuitBreaker INTEGER NOT NULL,"
|
|
"openWaterCoverStartCylinderCircuitBreaker INTEGER NOT NULL);";
|
|
|
|
const char* disHighBVolBusCmdSql = "CREATE TABLE IF NOT EXISTS dis_high_b_vol_bus_cmd ("
|
|
"timestamp DATETIME DEFAULT (strftime('%Y-%m-%d %H:%M:%f', 'now')),"
|
|
"lithiumBatteryGroupInstrumentCircuitBreaker INTEGER NOT NULL,"
|
|
"bowLowVoltageDistributionBoxCircuitBreaker INTEGER NOT NULL,"
|
|
"unit4InstrumentDC48VCircuitBreaker INTEGER NOT NULL,"
|
|
"dcC1DCDistributionPanelCircuitBreaker INTEGER NOT NULL,"
|
|
"reservedCircuitBreaker1 INTEGER NOT NULL,"
|
|
"reservedCircuitBreaker2 INTEGER NOT NULL,"
|
|
"emergencyLithiumBatteryGroup2CircuitBreaker INTEGER NOT NULL);";
|
|
|
|
const char* disLowBusCmdSql = "CREATE TABLE IF NOT EXISTS dis_low_bus_cmd ("
|
|
"timestamp DATETIME DEFAULT (strftime('%Y-%m-%d %H:%M:%f', 'now')),"
|
|
"unit1CircuitBreaker INTEGER NOT NULL,"
|
|
"unit2CircuitBreaker INTEGER NOT NULL,"
|
|
"unit3CircuitBreaker INTEGER NOT NULL,"
|
|
"unit5CircuitBreaker INTEGER NOT NULL,"
|
|
"bowPZDeviceCircuitBreaker INTEGER NOT NULL,"
|
|
"reservedCircuitBreaker1 INTEGER NOT NULL,"
|
|
"reservedCircuitBreaker2 INTEGER NOT NULL,"
|
|
"emergencyLithiumBatteryGroup1CircuitBreaker INTEGER NOT NULL);";
|
|
|
|
|
|
|
|
char* errMsg = nullptr;
|
|
bool result = true;
|
|
|
|
// 执行所有表创建语句
|
|
if (sqlite3_exec(m_db, ccuStateSql, nullptr, nullptr, &errMsg) != SQLITE_OK) {
|
|
std::cerr << "SQL error creating ccu_state table: " << errMsg << std::endl;
|
|
sqlite3_free(errMsg);
|
|
result = false;
|
|
}
|
|
|
|
if (sqlite3_exec(m_db, disHighVolBusStateSql, nullptr, nullptr, &errMsg) != SQLITE_OK) {
|
|
std::cerr << "SQL error creating dis_high_vol_bus_state table: " << errMsg << std::endl;
|
|
sqlite3_free(errMsg);
|
|
result = false;
|
|
}
|
|
|
|
if (sqlite3_exec(m_db, disHighAVolBusStateSql, nullptr, nullptr, &errMsg) != SQLITE_OK) {
|
|
std::cerr << "SQL error creating dis_high_a_vol_bus_state table: " << errMsg << std::endl;
|
|
sqlite3_free(errMsg);
|
|
result = false;
|
|
}
|
|
|
|
if (sqlite3_exec(m_db, disHighBVolBusStateSql, nullptr, nullptr, &errMsg) != SQLITE_OK) {
|
|
std::cerr << "SQL error creating dis_high_b_vol_bus_state table: " << errMsg << std::endl;
|
|
sqlite3_free(errMsg);
|
|
result = false;
|
|
}
|
|
|
|
if (sqlite3_exec(m_db, disLowBusStateSql, nullptr, nullptr, &errMsg) != SQLITE_OK) {
|
|
std::cerr << "SQL error creating dis_low_bus_state table: " << errMsg << std::endl;
|
|
sqlite3_free(errMsg);
|
|
result = false;
|
|
}
|
|
|
|
if (sqlite3_exec(m_db, ccuCmdSql, nullptr, nullptr, &errMsg)!= SQLITE_OK) {
|
|
std::cerr << "SQL error creating ccu_cmd table: " << errMsg << std::endl;
|
|
sqlite3_free(errMsg);
|
|
result = false;
|
|
}
|
|
|
|
if (sqlite3_exec(m_db, disHighVolBusCmdSql, nullptr, nullptr, &errMsg)!= SQLITE_OK) {
|
|
std::cerr << "SQL error creating dis_high_vol_bus_cmd table: " << errMsg << std::endl;
|
|
sqlite3_free(errMsg);
|
|
result = false;
|
|
}
|
|
|
|
if (sqlite3_exec(m_db, disHighAVolBusCmdSql, nullptr, nullptr, &errMsg)!= SQLITE_OK) {
|
|
std::cerr << "SQL error creating dis_high_a_vol_bus_cmd table: " << errMsg << std::endl;
|
|
sqlite3_free(errMsg);
|
|
result = false;
|
|
}
|
|
|
|
if (sqlite3_exec(m_db, disHighBVolBusCmdSql, nullptr, nullptr, &errMsg)!= SQLITE_OK) {
|
|
std::cerr << "SQL error creating dis_high_b_vol_bus_cmd table: " << errMsg << std::endl;
|
|
sqlite3_free(errMsg);
|
|
result = false;
|
|
}
|
|
|
|
if (sqlite3_exec(m_db, disLowBusCmdSql, nullptr, nullptr, &errMsg)!= SQLITE_OK) {
|
|
std::cerr << "SQL error creating dis_low_bus_cmd table: " << errMsg << std::endl;
|
|
sqlite3_free(errMsg);
|
|
result = false;
|
|
}
|
|
|
|
return result;
|
|
}
|