ETM-Schurig
/
nymea-plugins-modbus
mirror of https://github.com/nymea/nymea-plugins-modbus.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
nymea-plugins-modbus/libnymea-sunspec/models/sunspecbatterymodel.cpp

1605 lines
68 KiB
C++
Raw Blame History

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* Copyright 2013 - 2021, nymea GmbH
* Contact: contact@nymea.io
*
* This fileDescriptor is part of nymea.
* This project including source code and documentation is protected by
* copyright law, and remains the property of nymea GmbH. All rights, including
* reproduction, publication, editing and translation, are reserved. The use of
* this project is subject to the terms of a license agreement to be concluded
* with nymea GmbH in accordance with the terms of use of nymea GmbH, available
* under https://nymea.io/license
*
* GNU Lesser General Public License Usage
* Alternatively, this project may be redistributed and/or modified under the
* terms of the GNU Lesser General Public License as published by the Free
* Software Foundation; version 3. This project is distributed in the hope that
* it will be useful, but WITHOUT ANY WARRANTY; without even the implied
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this project. If not, see <https://www.gnu.org/licenses/>.
*
* For any further details and any questions please contact us under
* contact@nymea.io or see our FAQ/Licensing Information on
* https://nymea.io/license/faq
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#include "sunspecbatterymodel.h"
#include "sunspecconnection.h"
SunSpecBatteryModel::SunSpecBatteryModel(SunSpecConnection *connection, quint16 modbusStartRegister, quint16 modelLength, SunSpecDataPoint::ByteOrder byteOrder, QObject *parent) :
SunSpecModel(connection, modbusStartRegister, 802, modelLength, byteOrder, parent)
{
m_modelBlockType = SunSpecModel::ModelBlockTypeFixed;
initDataPoints();
}
SunSpecBatteryModel::~SunSpecBatteryModel()
{
}
QString SunSpecBatteryModel::name() const
{
return "battery";
}
QString SunSpecBatteryModel::description() const
{
return QString();
}
QString SunSpecBatteryModel::label() const
{
return "Battery Base Model";
}
float SunSpecBatteryModel::nameplateChargeCapacity() const
{
return m_nameplateChargeCapacity;
}
float SunSpecBatteryModel::nameplateEnergyCapacity() const
{
return m_nameplateEnergyCapacity;
}
float SunSpecBatteryModel::nameplateMaxChargeRate() const
{
return m_nameplateMaxChargeRate;
}
float SunSpecBatteryModel::nameplateMaxDischargeRate() const
{
return m_nameplateMaxDischargeRate;
}
float SunSpecBatteryModel::selfDischargeRate() const
{
return m_selfDischargeRate;
}
float SunSpecBatteryModel::nameplateMaxSoC() const
{
return m_nameplateMaxSoC;
}
float SunSpecBatteryModel::nameplateMinSoC() const
{
return m_nameplateMinSoC;
}
float SunSpecBatteryModel::maxReservePercent() const
{
return m_maxReservePercent;
}
QModbusReply *SunSpecBatteryModel::setMaxReservePercent(float maxReservePercent)
{
if (!m_initialized)
return nullptr;
SunSpecDataPoint dp = m_dataPoints.value("SocRsvMax");
QVector<quint16> registers = SunSpecDataPoint::convertFromFloatWithSSF(maxReservePercent, m_soC_SF, dp.dataType());
QModbusDataUnit request = QModbusDataUnit(QModbusDataUnit::RegisterType::HoldingRegisters, m_modbusStartRegister + dp.addressOffset(), registers.length());
request.setValues(registers);
return m_connection->modbusTcpClient()->sendWriteRequest(request, m_connection->slaveId());
}
float SunSpecBatteryModel::minReservePercent() const
{
return m_minReservePercent;
}
QModbusReply *SunSpecBatteryModel::setMinReservePercent(float minReservePercent)
{
if (!m_initialized)
return nullptr;
SunSpecDataPoint dp = m_dataPoints.value("SoCRsvMin");
QVector<quint16> registers = SunSpecDataPoint::convertFromFloatWithSSF(minReservePercent, m_soC_SF, dp.dataType());
QModbusDataUnit request = QModbusDataUnit(QModbusDataUnit::RegisterType::HoldingRegisters, m_modbusStartRegister + dp.addressOffset(), registers.length());
request.setValues(registers);
return m_connection->modbusTcpClient()->sendWriteRequest(request, m_connection->slaveId());
}
float SunSpecBatteryModel::stateOfCharge() const
{
return m_stateOfCharge;
}
float SunSpecBatteryModel::depthOfDischarge() const
{
return m_depthOfDischarge;
}
float SunSpecBatteryModel::stateOfHealth() const
{
return m_stateOfHealth;
}
quint32 SunSpecBatteryModel::cycleCount() const
{
return m_cycleCount;
}
SunSpecBatteryModel::Chast SunSpecBatteryModel::chargeStatus() const
{
return m_chargeStatus;
}
SunSpecBatteryModel::Locremctl SunSpecBatteryModel::controlMode() const
{
return m_controlMode;
}
quint16 SunSpecBatteryModel::batteryHeartbeat() const
{
return m_batteryHeartbeat;
}
quint16 SunSpecBatteryModel::controllerHeartbeat() const
{
return m_controllerHeartbeat;
}
QModbusReply *SunSpecBatteryModel::setControllerHeartbeat(quint16 controllerHeartbeat)
{
if (!m_initialized)
return nullptr;
SunSpecDataPoint dp = m_dataPoints.value("CtrlHb");
QVector<quint16> registers = SunSpecDataPoint::convertFromUInt16(controllerHeartbeat);
QModbusDataUnit request = QModbusDataUnit(QModbusDataUnit::RegisterType::HoldingRegisters, m_modbusStartRegister + dp.addressOffset(), registers.length());
request.setValues(registers);
return m_connection->modbusTcpClient()->sendWriteRequest(request, m_connection->slaveId());
}
quint16 SunSpecBatteryModel::alarmReset() const
{
return m_alarmReset;
}
QModbusReply *SunSpecBatteryModel::setAlarmReset(quint16 alarmReset)
{
if (!m_initialized)
return nullptr;
SunSpecDataPoint dp = m_dataPoints.value("AlmRst");
QVector<quint16> registers = SunSpecDataPoint::convertFromUInt16(alarmReset);
QModbusDataUnit request = QModbusDataUnit(QModbusDataUnit::RegisterType::HoldingRegisters, m_modbusStartRegister + dp.addressOffset(), registers.length());
request.setValues(registers);
return m_connection->modbusTcpClient()->sendWriteRequest(request, m_connection->slaveId());
}
SunSpecBatteryModel::Typ SunSpecBatteryModel::batteryType() const
{
return m_batteryType;
}
SunSpecBatteryModel::State SunSpecBatteryModel::stateOfTheBatteryBank() const
{
return m_stateOfTheBatteryBank;
}
quint16 SunSpecBatteryModel::vendorBatteryBankState() const
{
return m_vendorBatteryBankState;
}
quint32 SunSpecBatteryModel::warrantyDate() const
{
return m_warrantyDate;
}
SunSpecBatteryModel::Evt1Flags SunSpecBatteryModel::batteryEvent1Bitfield() const
{
return m_batteryEvent1Bitfield;
}
quint32 SunSpecBatteryModel::batteryEvent2Bitfield() const
{
return m_batteryEvent2Bitfield;
}
quint32 SunSpecBatteryModel::vendorEventBitfield1() const
{
return m_vendorEventBitfield1;
}
quint32 SunSpecBatteryModel::vendorEventBitfield2() const
{
return m_vendorEventBitfield2;
}
float SunSpecBatteryModel::externalBatteryVoltage() const
{
return m_externalBatteryVoltage;
}
float SunSpecBatteryModel::maxBatteryVoltage() const
{
return m_maxBatteryVoltage;
}
float SunSpecBatteryModel::minBatteryVoltage() const
{
return m_minBatteryVoltage;
}
float SunSpecBatteryModel::maxCellVoltage() const
{
return m_maxCellVoltage;
}
quint16 SunSpecBatteryModel::maxCellVoltageString() const
{
return m_maxCellVoltageString;
}
quint16 SunSpecBatteryModel::maxCellVoltageModule() const
{
return m_maxCellVoltageModule;
}
float SunSpecBatteryModel::minCellVoltage() const
{
return m_minCellVoltage;
}
quint16 SunSpecBatteryModel::minCellVoltageString() const
{
return m_minCellVoltageString;
}
quint16 SunSpecBatteryModel::minCellVoltageModule() const
{
return m_minCellVoltageModule;
}
float SunSpecBatteryModel::averageCellVoltage() const
{
return m_averageCellVoltage;
}
float SunSpecBatteryModel::totalDcCurrent() const
{
return m_totalDcCurrent;
}
float SunSpecBatteryModel::maxChargeCurrent() const
{
return m_maxChargeCurrent;
}
float SunSpecBatteryModel::maxDischargeCurrent() const
{
return m_maxDischargeCurrent;
}
float SunSpecBatteryModel::totalPower() const
{
return m_totalPower;
}
SunSpecBatteryModel::Reqinvstate SunSpecBatteryModel::inverterStateRequest() const
{
return m_inverterStateRequest;
}
float SunSpecBatteryModel::batteryPowerRequest() const
{
return m_batteryPowerRequest;
}
SunSpecBatteryModel::Setop SunSpecBatteryModel::setOperation() const
{
return m_setOperation;
}
QModbusReply *SunSpecBatteryModel::setSetOperation(Setop setOperation)
{
if (!m_initialized)
return nullptr;
SunSpecDataPoint dp = m_dataPoints.value("SetOp");
QVector<quint16> registers = SunSpecDataPoint::convertFromUInt16(static_cast<quint16>(setOperation));
QModbusDataUnit request = QModbusDataUnit(QModbusDataUnit::RegisterType::HoldingRegisters, m_modbusStartRegister + dp.addressOffset(), registers.length());
request.setValues(registers);
return m_connection->modbusTcpClient()->sendWriteRequest(request, m_connection->slaveId());
}
SunSpecBatteryModel::Setinvstate SunSpecBatteryModel::setInverterState() const
{
return m_setInverterState;
}
QModbusReply *SunSpecBatteryModel::setSetInverterState(Setinvstate setInverterState)
{
if (!m_initialized)
return nullptr;
SunSpecDataPoint dp = m_dataPoints.value("SetInvState");
QVector<quint16> registers = SunSpecDataPoint::convertFromUInt16(static_cast<quint16>(setInverterState));
QModbusDataUnit request = QModbusDataUnit(QModbusDataUnit::RegisterType::HoldingRegisters, m_modbusStartRegister + dp.addressOffset(), registers.length());
request.setValues(registers);
return m_connection->modbusTcpClient()->sendWriteRequest(request, m_connection->slaveId());
}
qint16 SunSpecBatteryModel::aHRtg_SF() const
{
return m_aHRtg_SF;
}
qint16 SunSpecBatteryModel::wHRtg_SF() const
{
return m_wHRtg_SF;
}
qint16 SunSpecBatteryModel::wChaDisChaMax_SF() const
{
return m_wChaDisChaMax_SF;
}
qint16 SunSpecBatteryModel::disChaRte_SF() const
{
return m_disChaRte_SF;
}
qint16 SunSpecBatteryModel::soC_SF() const
{
return m_soC_SF;
}
qint16 SunSpecBatteryModel::doD_SF() const
{
return m_doD_SF;
}
qint16 SunSpecBatteryModel::soH_SF() const
{
return m_soH_SF;
}
qint16 SunSpecBatteryModel::v_SF() const
{
return m_v_SF;
}
qint16 SunSpecBatteryModel::cellV_SF() const
{
return m_cellV_SF;
}
qint16 SunSpecBatteryModel::a_SF() const
{
return m_a_SF;
}
qint16 SunSpecBatteryModel::aMax_SF() const
{
return m_aMax_SF;
}
qint16 SunSpecBatteryModel::w_SF() const
{
return m_w_SF;
}
void SunSpecBatteryModel::initDataPoints()
{
SunSpecDataPoint modelIdDataPoint;
modelIdDataPoint.setName("ID");
modelIdDataPoint.setLabel("Model ID");
modelIdDataPoint.setDescription("Model identifier");
modelIdDataPoint.setMandatory(true);
modelIdDataPoint.setSize(1);
modelIdDataPoint.setAddressOffset(0);
modelIdDataPoint.setSunSpecDataType("uint16");
modelIdDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(modelIdDataPoint.name(), modelIdDataPoint);
SunSpecDataPoint modelLengthDataPoint;
modelLengthDataPoint.setName("L");
modelLengthDataPoint.setLabel("Model Length");
modelLengthDataPoint.setDescription("Model length");
modelLengthDataPoint.setMandatory(true);
modelLengthDataPoint.setSize(1);
modelLengthDataPoint.setAddressOffset(1);
modelLengthDataPoint.setSunSpecDataType("uint16");
modelLengthDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(modelLengthDataPoint.name(), modelLengthDataPoint);
SunSpecDataPoint nameplateChargeCapacityDataPoint;
nameplateChargeCapacityDataPoint.setName("AHRtg");
nameplateChargeCapacityDataPoint.setLabel("Nameplate Charge Capacity");
nameplateChargeCapacityDataPoint.setDescription("Nameplate charge capacity in amp-hours.");
nameplateChargeCapacityDataPoint.setUnits("Ah");
nameplateChargeCapacityDataPoint.setMandatory(true);
nameplateChargeCapacityDataPoint.setSize(1);
nameplateChargeCapacityDataPoint.setAddressOffset(2);
nameplateChargeCapacityDataPoint.setBlockOffset(0);
nameplateChargeCapacityDataPoint.setScaleFactorName("AHRtg_SF");
nameplateChargeCapacityDataPoint.setSunSpecDataType("uint16");
nameplateChargeCapacityDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(nameplateChargeCapacityDataPoint.name(), nameplateChargeCapacityDataPoint);
SunSpecDataPoint nameplateEnergyCapacityDataPoint;
nameplateEnergyCapacityDataPoint.setName("WHRtg");
nameplateEnergyCapacityDataPoint.setLabel("Nameplate Energy Capacity");
nameplateEnergyCapacityDataPoint.setDescription("Nameplate energy capacity in DC watt-hours.");
nameplateEnergyCapacityDataPoint.setUnits("Wh");
nameplateEnergyCapacityDataPoint.setMandatory(true);
nameplateEnergyCapacityDataPoint.setSize(1);
nameplateEnergyCapacityDataPoint.setAddressOffset(3);
nameplateEnergyCapacityDataPoint.setBlockOffset(1);
nameplateEnergyCapacityDataPoint.setScaleFactorName("WHRtg_SF");
nameplateEnergyCapacityDataPoint.setSunSpecDataType("uint16");
nameplateEnergyCapacityDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(nameplateEnergyCapacityDataPoint.name(), nameplateEnergyCapacityDataPoint);
SunSpecDataPoint nameplateMaxChargeRateDataPoint;
nameplateMaxChargeRateDataPoint.setName("WChaRteMax");
nameplateMaxChargeRateDataPoint.setLabel("Nameplate Max Charge Rate");
nameplateMaxChargeRateDataPoint.setDescription("Maximum rate of energy transfer into the storage device in DC watts.");
nameplateMaxChargeRateDataPoint.setUnits("W");
nameplateMaxChargeRateDataPoint.setMandatory(true);
nameplateMaxChargeRateDataPoint.setSize(1);
nameplateMaxChargeRateDataPoint.setAddressOffset(4);
nameplateMaxChargeRateDataPoint.setBlockOffset(2);
nameplateMaxChargeRateDataPoint.setScaleFactorName("WChaDisChaMax_SF");
nameplateMaxChargeRateDataPoint.setSunSpecDataType("uint16");
nameplateMaxChargeRateDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(nameplateMaxChargeRateDataPoint.name(), nameplateMaxChargeRateDataPoint);
SunSpecDataPoint nameplateMaxDischargeRateDataPoint;
nameplateMaxDischargeRateDataPoint.setName("WDisChaRteMax");
nameplateMaxDischargeRateDataPoint.setLabel("Nameplate Max Discharge Rate");
nameplateMaxDischargeRateDataPoint.setDescription("Maximum rate of energy transfer out of the storage device in DC watts.");
nameplateMaxDischargeRateDataPoint.setUnits("W");
nameplateMaxDischargeRateDataPoint.setMandatory(true);
nameplateMaxDischargeRateDataPoint.setSize(1);
nameplateMaxDischargeRateDataPoint.setAddressOffset(5);
nameplateMaxDischargeRateDataPoint.setBlockOffset(3);
nameplateMaxDischargeRateDataPoint.setScaleFactorName("WChaDisChaMax_SF");
nameplateMaxDischargeRateDataPoint.setSunSpecDataType("uint16");
nameplateMaxDischargeRateDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(nameplateMaxDischargeRateDataPoint.name(), nameplateMaxDischargeRateDataPoint);
SunSpecDataPoint selfDischargeRateDataPoint;
selfDischargeRateDataPoint.setName("DisChaRte");
selfDischargeRateDataPoint.setLabel("Self Discharge Rate");
selfDischargeRateDataPoint.setDescription("Self discharge rate. Percentage of capacity (WHRtg) discharged per day.");
selfDischargeRateDataPoint.setUnits("%WHRtg");
selfDischargeRateDataPoint.setSize(1);
selfDischargeRateDataPoint.setAddressOffset(6);
selfDischargeRateDataPoint.setBlockOffset(4);
selfDischargeRateDataPoint.setScaleFactorName("DisChaRte_SF");
selfDischargeRateDataPoint.setSunSpecDataType("uint16");
selfDischargeRateDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(selfDischargeRateDataPoint.name(), selfDischargeRateDataPoint);
SunSpecDataPoint nameplateMaxSoCDataPoint;
nameplateMaxSoCDataPoint.setName("SoCMax");
nameplateMaxSoCDataPoint.setLabel("Nameplate Max SoC");
nameplateMaxSoCDataPoint.setDescription("Manufacturer maximum state of charge, expressed as a percentage.");
nameplateMaxSoCDataPoint.setUnits("%WHRtg");
nameplateMaxSoCDataPoint.setSize(1);
nameplateMaxSoCDataPoint.setAddressOffset(7);
nameplateMaxSoCDataPoint.setBlockOffset(5);
nameplateMaxSoCDataPoint.setScaleFactorName("SoC_SF");
nameplateMaxSoCDataPoint.setSunSpecDataType("uint16");
nameplateMaxSoCDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(nameplateMaxSoCDataPoint.name(), nameplateMaxSoCDataPoint);
SunSpecDataPoint nameplateMinSoCDataPoint;
nameplateMinSoCDataPoint.setName("SoCMin");
nameplateMinSoCDataPoint.setLabel("Nameplate Min SoC");
nameplateMinSoCDataPoint.setDescription("Manufacturer minimum state of charge, expressed as a percentage.");
nameplateMinSoCDataPoint.setUnits("%WHRtg");
nameplateMinSoCDataPoint.setSize(1);
nameplateMinSoCDataPoint.setAddressOffset(8);
nameplateMinSoCDataPoint.setBlockOffset(6);
nameplateMinSoCDataPoint.setScaleFactorName("SoC_SF");
nameplateMinSoCDataPoint.setSunSpecDataType("uint16");
nameplateMinSoCDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(nameplateMinSoCDataPoint.name(), nameplateMinSoCDataPoint);
SunSpecDataPoint maxReservePercentDataPoint;
maxReservePercentDataPoint.setName("SocRsvMax");
maxReservePercentDataPoint.setLabel("Max Reserve Percent");
maxReservePercentDataPoint.setDescription("Setpoint for maximum reserve for storage as a percentage of the nominal maximum storage.");
maxReservePercentDataPoint.setUnits("%WHRtg");
maxReservePercentDataPoint.setSize(1);
maxReservePercentDataPoint.setAddressOffset(9);
maxReservePercentDataPoint.setBlockOffset(7);
maxReservePercentDataPoint.setScaleFactorName("SoC_SF");
maxReservePercentDataPoint.setSunSpecDataType("uint16");
maxReservePercentDataPoint.setAccess(SunSpecDataPoint::AccessReadWrite);
maxReservePercentDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(maxReservePercentDataPoint.name(), maxReservePercentDataPoint);
SunSpecDataPoint minReservePercentDataPoint;
minReservePercentDataPoint.setName("SoCRsvMin");
minReservePercentDataPoint.setLabel("Min Reserve Percent");
minReservePercentDataPoint.setDescription("Setpoint for minimum reserve for storage as a percentage of the nominal maximum storage.");
minReservePercentDataPoint.setUnits("%WHRtg");
minReservePercentDataPoint.setSize(1);
minReservePercentDataPoint.setAddressOffset(10);
minReservePercentDataPoint.setBlockOffset(8);
minReservePercentDataPoint.setScaleFactorName("SoC_SF");
minReservePercentDataPoint.setSunSpecDataType("uint16");
minReservePercentDataPoint.setAccess(SunSpecDataPoint::AccessReadWrite);
minReservePercentDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(minReservePercentDataPoint.name(), minReservePercentDataPoint);
SunSpecDataPoint stateOfChargeDataPoint;
stateOfChargeDataPoint.setName("SoC");
stateOfChargeDataPoint.setLabel("State of Charge");
stateOfChargeDataPoint.setDescription("State of charge, expressed as a percentage.");
stateOfChargeDataPoint.setUnits("%WHRtg");
stateOfChargeDataPoint.setMandatory(true);
stateOfChargeDataPoint.setSize(1);
stateOfChargeDataPoint.setAddressOffset(11);
stateOfChargeDataPoint.setBlockOffset(9);
stateOfChargeDataPoint.setScaleFactorName("SoC_SF");
stateOfChargeDataPoint.setSunSpecDataType("uint16");
stateOfChargeDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(stateOfChargeDataPoint.name(), stateOfChargeDataPoint);
SunSpecDataPoint depthOfDischargeDataPoint;
depthOfDischargeDataPoint.setName("DoD");
depthOfDischargeDataPoint.setLabel("Depth of Discharge");
depthOfDischargeDataPoint.setDescription("Depth of discharge, expressed as a percentage.");
depthOfDischargeDataPoint.setUnits("%");
depthOfDischargeDataPoint.setSize(1);
depthOfDischargeDataPoint.setAddressOffset(12);
depthOfDischargeDataPoint.setBlockOffset(10);
depthOfDischargeDataPoint.setScaleFactorName("DoD_SF");
depthOfDischargeDataPoint.setSunSpecDataType("uint16");
depthOfDischargeDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(depthOfDischargeDataPoint.name(), depthOfDischargeDataPoint);
SunSpecDataPoint stateOfHealthDataPoint;
stateOfHealthDataPoint.setName("SoH");
stateOfHealthDataPoint.setLabel("State of Health");
stateOfHealthDataPoint.setDescription("Percentage of battery life remaining.");
stateOfHealthDataPoint.setUnits("%");
stateOfHealthDataPoint.setSize(1);
stateOfHealthDataPoint.setAddressOffset(13);
stateOfHealthDataPoint.setBlockOffset(11);
stateOfHealthDataPoint.setScaleFactorName("SoH_SF");
stateOfHealthDataPoint.setSunSpecDataType("uint16");
stateOfHealthDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(stateOfHealthDataPoint.name(), stateOfHealthDataPoint);
SunSpecDataPoint cycleCountDataPoint;
cycleCountDataPoint.setName("NCyc");
cycleCountDataPoint.setLabel("Cycle Count");
cycleCountDataPoint.setDescription("Number of cycles executed in the battery.");
cycleCountDataPoint.setSize(2);
cycleCountDataPoint.setAddressOffset(14);
cycleCountDataPoint.setBlockOffset(12);
cycleCountDataPoint.setSunSpecDataType("uint32");
cycleCountDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(cycleCountDataPoint.name(), cycleCountDataPoint);
SunSpecDataPoint chargeStatusDataPoint;
chargeStatusDataPoint.setName("ChaSt");
chargeStatusDataPoint.setLabel("Charge Status");
chargeStatusDataPoint.setDescription("Charge status of storage device. Enumeration.");
chargeStatusDataPoint.setSize(1);
chargeStatusDataPoint.setAddressOffset(16);
chargeStatusDataPoint.setBlockOffset(14);
chargeStatusDataPoint.setSunSpecDataType("enum16");
chargeStatusDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(chargeStatusDataPoint.name(), chargeStatusDataPoint);
SunSpecDataPoint controlModeDataPoint;
controlModeDataPoint.setName("LocRemCtl");
controlModeDataPoint.setLabel("Control Mode");
controlModeDataPoint.setDescription("Battery control mode. Enumeration.");
controlModeDataPoint.setMandatory(true);
controlModeDataPoint.setSize(1);
controlModeDataPoint.setAddressOffset(17);
controlModeDataPoint.setBlockOffset(15);
controlModeDataPoint.setSunSpecDataType("enum16");
controlModeDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(controlModeDataPoint.name(), controlModeDataPoint);
SunSpecDataPoint batteryHeartbeatDataPoint;
batteryHeartbeatDataPoint.setName("Hb");
batteryHeartbeatDataPoint.setLabel("Battery Heartbeat");
batteryHeartbeatDataPoint.setDescription("Value is incremented every second with periodic resets to zero.");
batteryHeartbeatDataPoint.setSize(1);
batteryHeartbeatDataPoint.setAddressOffset(18);
batteryHeartbeatDataPoint.setBlockOffset(16);
batteryHeartbeatDataPoint.setSunSpecDataType("uint16");
batteryHeartbeatDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(batteryHeartbeatDataPoint.name(), batteryHeartbeatDataPoint);
SunSpecDataPoint controllerHeartbeatDataPoint;
controllerHeartbeatDataPoint.setName("CtrlHb");
controllerHeartbeatDataPoint.setLabel("Controller Heartbeat");
controllerHeartbeatDataPoint.setDescription("Value is incremented every second with periodic resets to zero.");
controllerHeartbeatDataPoint.setSize(1);
controllerHeartbeatDataPoint.setAddressOffset(19);
controllerHeartbeatDataPoint.setBlockOffset(17);
controllerHeartbeatDataPoint.setSunSpecDataType("uint16");
controllerHeartbeatDataPoint.setAccess(SunSpecDataPoint::AccessReadWrite);
controllerHeartbeatDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(controllerHeartbeatDataPoint.name(), controllerHeartbeatDataPoint);
SunSpecDataPoint alarmResetDataPoint;
alarmResetDataPoint.setName("AlmRst");
alarmResetDataPoint.setLabel("Alarm Reset");
alarmResetDataPoint.setDescription("Used to reset any latched alarms. 1 = Reset.");
alarmResetDataPoint.setMandatory(true);
alarmResetDataPoint.setSize(1);
alarmResetDataPoint.setAddressOffset(20);
alarmResetDataPoint.setBlockOffset(18);
alarmResetDataPoint.setSunSpecDataType("uint16");
alarmResetDataPoint.setAccess(SunSpecDataPoint::AccessReadWrite);
alarmResetDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(alarmResetDataPoint.name(), alarmResetDataPoint);
SunSpecDataPoint batteryTypeDataPoint;
batteryTypeDataPoint.setName("Typ");
batteryTypeDataPoint.setLabel("Battery Type");
batteryTypeDataPoint.setDescription("Type of battery. Enumeration.");
batteryTypeDataPoint.setMandatory(true);
batteryTypeDataPoint.setSize(1);
batteryTypeDataPoint.setAddressOffset(21);
batteryTypeDataPoint.setBlockOffset(19);
batteryTypeDataPoint.setSunSpecDataType("enum16");
batteryTypeDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(batteryTypeDataPoint.name(), batteryTypeDataPoint);
SunSpecDataPoint stateOfTheBatteryBankDataPoint;
stateOfTheBatteryBankDataPoint.setName("State");
stateOfTheBatteryBankDataPoint.setLabel("State of the Battery Bank");
stateOfTheBatteryBankDataPoint.setDescription("State of the battery bank. Enumeration.");
stateOfTheBatteryBankDataPoint.setMandatory(true);
stateOfTheBatteryBankDataPoint.setSize(1);
stateOfTheBatteryBankDataPoint.setAddressOffset(22);
stateOfTheBatteryBankDataPoint.setBlockOffset(20);
stateOfTheBatteryBankDataPoint.setSunSpecDataType("enum16");
stateOfTheBatteryBankDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(stateOfTheBatteryBankDataPoint.name(), stateOfTheBatteryBankDataPoint);
SunSpecDataPoint vendorBatteryBankStateDataPoint;
vendorBatteryBankStateDataPoint.setName("StateVnd");
vendorBatteryBankStateDataPoint.setLabel("Vendor Battery Bank State");
vendorBatteryBankStateDataPoint.setDescription("Vendor specific battery bank state. Enumeration.");
vendorBatteryBankStateDataPoint.setSize(1);
vendorBatteryBankStateDataPoint.setAddressOffset(23);
vendorBatteryBankStateDataPoint.setBlockOffset(21);
vendorBatteryBankStateDataPoint.setSunSpecDataType("enum16");
vendorBatteryBankStateDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(vendorBatteryBankStateDataPoint.name(), vendorBatteryBankStateDataPoint);
SunSpecDataPoint warrantyDateDataPoint;
warrantyDateDataPoint.setName("WarrDt");
warrantyDateDataPoint.setLabel("Warranty Date");
warrantyDateDataPoint.setDescription("Date the device warranty expires.");
warrantyDateDataPoint.setSize(2);
warrantyDateDataPoint.setAddressOffset(24);
warrantyDateDataPoint.setBlockOffset(22);
warrantyDateDataPoint.setSunSpecDataType("uint32");
warrantyDateDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(warrantyDateDataPoint.name(), warrantyDateDataPoint);
SunSpecDataPoint batteryEvent1BitfieldDataPoint;
batteryEvent1BitfieldDataPoint.setName("Evt1");
batteryEvent1BitfieldDataPoint.setLabel("Battery Event 1 Bitfield");
batteryEvent1BitfieldDataPoint.setDescription("Alarms and warnings. Bit flags.");
batteryEvent1BitfieldDataPoint.setMandatory(true);
batteryEvent1BitfieldDataPoint.setSize(2);
batteryEvent1BitfieldDataPoint.setAddressOffset(26);
batteryEvent1BitfieldDataPoint.setBlockOffset(24);
batteryEvent1BitfieldDataPoint.setSunSpecDataType("bitfield32");
batteryEvent1BitfieldDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(batteryEvent1BitfieldDataPoint.name(), batteryEvent1BitfieldDataPoint);
SunSpecDataPoint batteryEvent2BitfieldDataPoint;
batteryEvent2BitfieldDataPoint.setName("Evt2");
batteryEvent2BitfieldDataPoint.setLabel("Battery Event 2 Bitfield");
batteryEvent2BitfieldDataPoint.setDescription("Alarms and warnings. Bit flags.");
batteryEvent2BitfieldDataPoint.setMandatory(true);
batteryEvent2BitfieldDataPoint.setSize(2);
batteryEvent2BitfieldDataPoint.setAddressOffset(28);
batteryEvent2BitfieldDataPoint.setBlockOffset(26);
batteryEvent2BitfieldDataPoint.setSunSpecDataType("bitfield32");
batteryEvent2BitfieldDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(batteryEvent2BitfieldDataPoint.name(), batteryEvent2BitfieldDataPoint);
SunSpecDataPoint vendorEventBitfield1DataPoint;
vendorEventBitfield1DataPoint.setName("EvtVnd1");
vendorEventBitfield1DataPoint.setLabel("Vendor Event Bitfield 1");
vendorEventBitfield1DataPoint.setDescription("Vendor defined events.");
vendorEventBitfield1DataPoint.setMandatory(true);
vendorEventBitfield1DataPoint.setSize(2);
vendorEventBitfield1DataPoint.setAddressOffset(30);
vendorEventBitfield1DataPoint.setBlockOffset(28);
vendorEventBitfield1DataPoint.setSunSpecDataType("bitfield32");
vendorEventBitfield1DataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(vendorEventBitfield1DataPoint.name(), vendorEventBitfield1DataPoint);
SunSpecDataPoint vendorEventBitfield2DataPoint;
vendorEventBitfield2DataPoint.setName("EvtVnd2");
vendorEventBitfield2DataPoint.setLabel("Vendor Event Bitfield 2");
vendorEventBitfield2DataPoint.setDescription("Vendor defined events.");
vendorEventBitfield2DataPoint.setMandatory(true);
vendorEventBitfield2DataPoint.setSize(2);
vendorEventBitfield2DataPoint.setAddressOffset(32);
vendorEventBitfield2DataPoint.setBlockOffset(30);
vendorEventBitfield2DataPoint.setSunSpecDataType("bitfield32");
vendorEventBitfield2DataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(vendorEventBitfield2DataPoint.name(), vendorEventBitfield2DataPoint);
SunSpecDataPoint externalBatteryVoltageDataPoint;
externalBatteryVoltageDataPoint.setName("V");
externalBatteryVoltageDataPoint.setLabel("External Battery Voltage");
externalBatteryVoltageDataPoint.setDescription("DC Bus Voltage.");
externalBatteryVoltageDataPoint.setUnits("V");
externalBatteryVoltageDataPoint.setMandatory(true);
externalBatteryVoltageDataPoint.setSize(1);
externalBatteryVoltageDataPoint.setAddressOffset(34);
externalBatteryVoltageDataPoint.setBlockOffset(32);
externalBatteryVoltageDataPoint.setScaleFactorName("V_SF");
externalBatteryVoltageDataPoint.setSunSpecDataType("uint16");
externalBatteryVoltageDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(externalBatteryVoltageDataPoint.name(), externalBatteryVoltageDataPoint);
SunSpecDataPoint maxBatteryVoltageDataPoint;
maxBatteryVoltageDataPoint.setName("VMax");
maxBatteryVoltageDataPoint.setLabel("Max Battery Voltage");
maxBatteryVoltageDataPoint.setDescription("Instantaneous maximum battery voltage.");
maxBatteryVoltageDataPoint.setUnits("V");
maxBatteryVoltageDataPoint.setSize(1);
maxBatteryVoltageDataPoint.setAddressOffset(35);
maxBatteryVoltageDataPoint.setBlockOffset(33);
maxBatteryVoltageDataPoint.setScaleFactorName("V_SF");
maxBatteryVoltageDataPoint.setSunSpecDataType("uint16");
maxBatteryVoltageDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(maxBatteryVoltageDataPoint.name(), maxBatteryVoltageDataPoint);
SunSpecDataPoint minBatteryVoltageDataPoint;
minBatteryVoltageDataPoint.setName("VMin");
minBatteryVoltageDataPoint.setLabel("Min Battery Voltage");
minBatteryVoltageDataPoint.setDescription("Instantaneous minimum battery voltage.");
minBatteryVoltageDataPoint.setUnits("V");
minBatteryVoltageDataPoint.setSize(1);
minBatteryVoltageDataPoint.setAddressOffset(36);
minBatteryVoltageDataPoint.setBlockOffset(34);
minBatteryVoltageDataPoint.setScaleFactorName("V_SF");
minBatteryVoltageDataPoint.setSunSpecDataType("uint16");
minBatteryVoltageDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(minBatteryVoltageDataPoint.name(), minBatteryVoltageDataPoint);
SunSpecDataPoint maxCellVoltageDataPoint;
maxCellVoltageDataPoint.setName("CellVMax");
maxCellVoltageDataPoint.setLabel("Max Cell Voltage");
maxCellVoltageDataPoint.setDescription("Maximum voltage for all cells in the bank.");
maxCellVoltageDataPoint.setUnits("V");
maxCellVoltageDataPoint.setSize(1);
maxCellVoltageDataPoint.setAddressOffset(37);
maxCellVoltageDataPoint.setBlockOffset(35);
maxCellVoltageDataPoint.setScaleFactorName("CellV_SF");
maxCellVoltageDataPoint.setSunSpecDataType("uint16");
maxCellVoltageDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(maxCellVoltageDataPoint.name(), maxCellVoltageDataPoint);
SunSpecDataPoint maxCellVoltageStringDataPoint;
maxCellVoltageStringDataPoint.setName("CellVMaxStr");
maxCellVoltageStringDataPoint.setLabel("Max Cell Voltage String");
maxCellVoltageStringDataPoint.setDescription("String containing the cell with maximum voltage.");
maxCellVoltageStringDataPoint.setSize(1);
maxCellVoltageStringDataPoint.setAddressOffset(38);
maxCellVoltageStringDataPoint.setBlockOffset(36);
maxCellVoltageStringDataPoint.setSunSpecDataType("uint16");
maxCellVoltageStringDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(maxCellVoltageStringDataPoint.name(), maxCellVoltageStringDataPoint);
SunSpecDataPoint maxCellVoltageModuleDataPoint;
maxCellVoltageModuleDataPoint.setName("CellVMaxMod");
maxCellVoltageModuleDataPoint.setLabel("Max Cell Voltage Module");
maxCellVoltageModuleDataPoint.setDescription("Module containing the cell with maximum voltage.");
maxCellVoltageModuleDataPoint.setSize(1);
maxCellVoltageModuleDataPoint.setAddressOffset(39);
maxCellVoltageModuleDataPoint.setBlockOffset(37);
maxCellVoltageModuleDataPoint.setSunSpecDataType("uint16");
maxCellVoltageModuleDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(maxCellVoltageModuleDataPoint.name(), maxCellVoltageModuleDataPoint);
SunSpecDataPoint minCellVoltageDataPoint;
minCellVoltageDataPoint.setName("CellVMin");
minCellVoltageDataPoint.setLabel("Min Cell Voltage");
minCellVoltageDataPoint.setDescription("Minimum voltage for all cells in the bank.");
minCellVoltageDataPoint.setUnits("V");
minCellVoltageDataPoint.setSize(1);
minCellVoltageDataPoint.setAddressOffset(40);
minCellVoltageDataPoint.setBlockOffset(38);
minCellVoltageDataPoint.setScaleFactorName("CellV_SF");
minCellVoltageDataPoint.setSunSpecDataType("uint16");
minCellVoltageDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(minCellVoltageDataPoint.name(), minCellVoltageDataPoint);
SunSpecDataPoint minCellVoltageStringDataPoint;
minCellVoltageStringDataPoint.setName("CellVMinStr");
minCellVoltageStringDataPoint.setLabel("Min Cell Voltage String");
minCellVoltageStringDataPoint.setDescription("String containing the cell with minimum voltage.");
minCellVoltageStringDataPoint.setSize(1);
minCellVoltageStringDataPoint.setAddressOffset(41);
minCellVoltageStringDataPoint.setBlockOffset(39);
minCellVoltageStringDataPoint.setSunSpecDataType("uint16");
minCellVoltageStringDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(minCellVoltageStringDataPoint.name(), minCellVoltageStringDataPoint);
SunSpecDataPoint minCellVoltageModuleDataPoint;
minCellVoltageModuleDataPoint.setName("CellVMinMod");
minCellVoltageModuleDataPoint.setLabel("Min Cell Voltage Module");
minCellVoltageModuleDataPoint.setDescription("Module containing the cell with minimum voltage.");
minCellVoltageModuleDataPoint.setSize(1);
minCellVoltageModuleDataPoint.setAddressOffset(42);
minCellVoltageModuleDataPoint.setBlockOffset(40);
minCellVoltageModuleDataPoint.setSunSpecDataType("uint16");
minCellVoltageModuleDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(minCellVoltageModuleDataPoint.name(), minCellVoltageModuleDataPoint);
SunSpecDataPoint averageCellVoltageDataPoint;
averageCellVoltageDataPoint.setName("CellVAvg");
averageCellVoltageDataPoint.setLabel("Average Cell Voltage");
averageCellVoltageDataPoint.setDescription("Average cell voltage for all cells in the bank.");
averageCellVoltageDataPoint.setUnits("V");
averageCellVoltageDataPoint.setSize(1);
averageCellVoltageDataPoint.setAddressOffset(43);
averageCellVoltageDataPoint.setBlockOffset(41);
averageCellVoltageDataPoint.setScaleFactorName("CellV_SF");
averageCellVoltageDataPoint.setSunSpecDataType("uint16");
averageCellVoltageDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(averageCellVoltageDataPoint.name(), averageCellVoltageDataPoint);
SunSpecDataPoint totalDcCurrentDataPoint;
totalDcCurrentDataPoint.setName("A");
totalDcCurrentDataPoint.setLabel("Total DC Current");
totalDcCurrentDataPoint.setDescription("Total DC current flowing to/from the battery bank.");
totalDcCurrentDataPoint.setUnits("A");
totalDcCurrentDataPoint.setMandatory(true);
totalDcCurrentDataPoint.setSize(1);
totalDcCurrentDataPoint.setAddressOffset(44);
totalDcCurrentDataPoint.setBlockOffset(42);
totalDcCurrentDataPoint.setScaleFactorName("A_SF");
totalDcCurrentDataPoint.setSunSpecDataType("int16");
totalDcCurrentDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(totalDcCurrentDataPoint.name(), totalDcCurrentDataPoint);
SunSpecDataPoint maxChargeCurrentDataPoint;
maxChargeCurrentDataPoint.setName("AChaMax");
maxChargeCurrentDataPoint.setLabel("Max Charge Current");
maxChargeCurrentDataPoint.setDescription("Instantaneous maximum DC charge current.");
maxChargeCurrentDataPoint.setUnits("A");
maxChargeCurrentDataPoint.setSize(1);
maxChargeCurrentDataPoint.setAddressOffset(45);
maxChargeCurrentDataPoint.setBlockOffset(43);
maxChargeCurrentDataPoint.setScaleFactorName("AMax_SF");
maxChargeCurrentDataPoint.setSunSpecDataType("uint16");
maxChargeCurrentDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(maxChargeCurrentDataPoint.name(), maxChargeCurrentDataPoint);
SunSpecDataPoint maxDischargeCurrentDataPoint;
maxDischargeCurrentDataPoint.setName("ADisChaMax");
maxDischargeCurrentDataPoint.setLabel("Max Discharge Current");
maxDischargeCurrentDataPoint.setDescription("Instantaneous maximum DC discharge current.");
maxDischargeCurrentDataPoint.setUnits("A");
maxDischargeCurrentDataPoint.setSize(1);
maxDischargeCurrentDataPoint.setAddressOffset(46);
maxDischargeCurrentDataPoint.setBlockOffset(44);
maxDischargeCurrentDataPoint.setScaleFactorName("AMax_SF");
maxDischargeCurrentDataPoint.setSunSpecDataType("uint16");
maxDischargeCurrentDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(maxDischargeCurrentDataPoint.name(), maxDischargeCurrentDataPoint);
SunSpecDataPoint totalPowerDataPoint;
totalPowerDataPoint.setName("W");
totalPowerDataPoint.setLabel("Total Power");
totalPowerDataPoint.setDescription("Total power flowing to/from the battery bank.");
totalPowerDataPoint.setUnits("W");
totalPowerDataPoint.setMandatory(true);
totalPowerDataPoint.setSize(1);
totalPowerDataPoint.setAddressOffset(47);
totalPowerDataPoint.setBlockOffset(45);
totalPowerDataPoint.setScaleFactorName("W_SF");
totalPowerDataPoint.setSunSpecDataType("int16");
totalPowerDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(totalPowerDataPoint.name(), totalPowerDataPoint);
SunSpecDataPoint inverterStateRequestDataPoint;
inverterStateRequestDataPoint.setName("ReqInvState");
inverterStateRequestDataPoint.setLabel("Inverter State Request");
inverterStateRequestDataPoint.setDescription("Request from battery to start or stop the inverter. Enumeration.");
inverterStateRequestDataPoint.setSize(1);
inverterStateRequestDataPoint.setAddressOffset(48);
inverterStateRequestDataPoint.setBlockOffset(46);
inverterStateRequestDataPoint.setSunSpecDataType("enum16");
inverterStateRequestDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(inverterStateRequestDataPoint.name(), inverterStateRequestDataPoint);
SunSpecDataPoint batteryPowerRequestDataPoint;
batteryPowerRequestDataPoint.setName("ReqW");
batteryPowerRequestDataPoint.setLabel("Battery Power Request");
batteryPowerRequestDataPoint.setDescription("AC Power requested by battery.");
batteryPowerRequestDataPoint.setUnits("W");
batteryPowerRequestDataPoint.setSize(1);
batteryPowerRequestDataPoint.setAddressOffset(49);
batteryPowerRequestDataPoint.setBlockOffset(47);
batteryPowerRequestDataPoint.setScaleFactorName("W_SF");
batteryPowerRequestDataPoint.setSunSpecDataType("int16");
batteryPowerRequestDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(batteryPowerRequestDataPoint.name(), batteryPowerRequestDataPoint);
SunSpecDataPoint setOperationDataPoint;
setOperationDataPoint.setName("SetOp");
setOperationDataPoint.setLabel("Set Operation");
setOperationDataPoint.setDescription("Instruct the battery bank to perform an operation such as connecting. Enumeration.");
setOperationDataPoint.setMandatory(true);
setOperationDataPoint.setSize(1);
setOperationDataPoint.setAddressOffset(50);
setOperationDataPoint.setBlockOffset(48);
setOperationDataPoint.setSunSpecDataType("enum16");
setOperationDataPoint.setAccess(SunSpecDataPoint::AccessReadWrite);
setOperationDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(setOperationDataPoint.name(), setOperationDataPoint);
SunSpecDataPoint setInverterStateDataPoint;
setInverterStateDataPoint.setName("SetInvState");
setInverterStateDataPoint.setLabel("Set Inverter State");
setInverterStateDataPoint.setDescription("Set the current state of the inverter.");
setInverterStateDataPoint.setMandatory(true);
setInverterStateDataPoint.setSize(1);
setInverterStateDataPoint.setAddressOffset(51);
setInverterStateDataPoint.setBlockOffset(49);
setInverterStateDataPoint.setSunSpecDataType("enum16");
setInverterStateDataPoint.setAccess(SunSpecDataPoint::AccessReadWrite);
setInverterStateDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(setInverterStateDataPoint.name(), setInverterStateDataPoint);
SunSpecDataPoint aHRtg_SFDataPoint;
aHRtg_SFDataPoint.setName("AHRtg_SF");
aHRtg_SFDataPoint.setDescription("Scale factor for charge capacity.");
aHRtg_SFDataPoint.setMandatory(true);
aHRtg_SFDataPoint.setSize(1);
aHRtg_SFDataPoint.setAddressOffset(52);
aHRtg_SFDataPoint.setBlockOffset(50);
aHRtg_SFDataPoint.setSunSpecDataType("sunssf");
aHRtg_SFDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(aHRtg_SFDataPoint.name(), aHRtg_SFDataPoint);
SunSpecDataPoint wHRtg_SFDataPoint;
wHRtg_SFDataPoint.setName("WHRtg_SF");
wHRtg_SFDataPoint.setDescription("Scale factor for energy capacity.");
wHRtg_SFDataPoint.setMandatory(true);
wHRtg_SFDataPoint.setSize(1);
wHRtg_SFDataPoint.setAddressOffset(53);
wHRtg_SFDataPoint.setBlockOffset(51);
wHRtg_SFDataPoint.setSunSpecDataType("sunssf");
wHRtg_SFDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(wHRtg_SFDataPoint.name(), wHRtg_SFDataPoint);
SunSpecDataPoint wChaDisChaMax_SFDataPoint;
wChaDisChaMax_SFDataPoint.setName("WChaDisChaMax_SF");
wChaDisChaMax_SFDataPoint.setDescription("Scale factor for maximum charge and discharge rate.");
wChaDisChaMax_SFDataPoint.setMandatory(true);
wChaDisChaMax_SFDataPoint.setSize(1);
wChaDisChaMax_SFDataPoint.setAddressOffset(54);
wChaDisChaMax_SFDataPoint.setBlockOffset(52);
wChaDisChaMax_SFDataPoint.setSunSpecDataType("sunssf");
wChaDisChaMax_SFDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(wChaDisChaMax_SFDataPoint.name(), wChaDisChaMax_SFDataPoint);
SunSpecDataPoint disChaRte_SFDataPoint;
disChaRte_SFDataPoint.setName("DisChaRte_SF");
disChaRte_SFDataPoint.setDescription("Scale factor for self discharge rate.");
disChaRte_SFDataPoint.setSize(1);
disChaRte_SFDataPoint.setAddressOffset(55);
disChaRte_SFDataPoint.setBlockOffset(53);
disChaRte_SFDataPoint.setSunSpecDataType("sunssf");
disChaRte_SFDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(disChaRte_SFDataPoint.name(), disChaRte_SFDataPoint);
SunSpecDataPoint soC_SFDataPoint;
soC_SFDataPoint.setName("SoC_SF");
soC_SFDataPoint.setDescription("Scale factor for state of charge values.");
soC_SFDataPoint.setMandatory(true);
soC_SFDataPoint.setSize(1);
soC_SFDataPoint.setAddressOffset(56);
soC_SFDataPoint.setBlockOffset(54);
soC_SFDataPoint.setSunSpecDataType("sunssf");
soC_SFDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(soC_SFDataPoint.name(), soC_SFDataPoint);
SunSpecDataPoint doD_SFDataPoint;
doD_SFDataPoint.setName("DoD_SF");
doD_SFDataPoint.setDescription("Scale factor for depth of discharge.");
doD_SFDataPoint.setSize(1);
doD_SFDataPoint.setAddressOffset(57);
doD_SFDataPoint.setBlockOffset(55);
doD_SFDataPoint.setSunSpecDataType("sunssf");
doD_SFDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(doD_SFDataPoint.name(), doD_SFDataPoint);
SunSpecDataPoint soH_SFDataPoint;
soH_SFDataPoint.setName("SoH_SF");
soH_SFDataPoint.setDescription("Scale factor for state of health.");
soH_SFDataPoint.setSize(1);
soH_SFDataPoint.setAddressOffset(58);
soH_SFDataPoint.setBlockOffset(56);
soH_SFDataPoint.setSunSpecDataType("sunssf");
soH_SFDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(soH_SFDataPoint.name(), soH_SFDataPoint);
SunSpecDataPoint v_SFDataPoint;
v_SFDataPoint.setName("V_SF");
v_SFDataPoint.setDescription("Scale factor for DC bus voltage.");
v_SFDataPoint.setMandatory(true);
v_SFDataPoint.setSize(1);
v_SFDataPoint.setAddressOffset(59);
v_SFDataPoint.setBlockOffset(57);
v_SFDataPoint.setSunSpecDataType("sunssf");
v_SFDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(v_SFDataPoint.name(), v_SFDataPoint);
SunSpecDataPoint cellV_SFDataPoint;
cellV_SFDataPoint.setName("CellV_SF");
cellV_SFDataPoint.setDescription("Scale factor for cell voltage.");
cellV_SFDataPoint.setMandatory(true);
cellV_SFDataPoint.setSize(1);
cellV_SFDataPoint.setAddressOffset(60);
cellV_SFDataPoint.setBlockOffset(58);
cellV_SFDataPoint.setSunSpecDataType("sunssf");
cellV_SFDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(cellV_SFDataPoint.name(), cellV_SFDataPoint);
SunSpecDataPoint a_SFDataPoint;
a_SFDataPoint.setName("A_SF");
a_SFDataPoint.setDescription("Scale factor for DC current.");
a_SFDataPoint.setMandatory(true);
a_SFDataPoint.setSize(1);
a_SFDataPoint.setAddressOffset(61);
a_SFDataPoint.setBlockOffset(59);
a_SFDataPoint.setSunSpecDataType("sunssf");
a_SFDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(a_SFDataPoint.name(), a_SFDataPoint);
SunSpecDataPoint aMax_SFDataPoint;
aMax_SFDataPoint.setName("AMax_SF");
aMax_SFDataPoint.setDescription("Scale factor for instantaneous DC charge/discharge current.");
aMax_SFDataPoint.setMandatory(true);
aMax_SFDataPoint.setSize(1);
aMax_SFDataPoint.setAddressOffset(62);
aMax_SFDataPoint.setBlockOffset(60);
aMax_SFDataPoint.setSunSpecDataType("sunssf");
aMax_SFDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(aMax_SFDataPoint.name(), aMax_SFDataPoint);
SunSpecDataPoint w_SFDataPoint;
w_SFDataPoint.setName("W_SF");
w_SFDataPoint.setDescription("Scale factor for AC power request.");
w_SFDataPoint.setSize(1);
w_SFDataPoint.setAddressOffset(63);
w_SFDataPoint.setBlockOffset(61);
w_SFDataPoint.setSunSpecDataType("sunssf");
w_SFDataPoint.setByteOrder(m_byteOrder);
m_dataPoints.insert(w_SFDataPoint.name(), w_SFDataPoint);
}
void SunSpecBatteryModel::processBlockData()
{
// Scale factors
if (m_dataPoints.value("AHRtg_SF").isValid())
m_aHRtg_SF = m_dataPoints.value("AHRtg_SF").toInt16();
if (m_dataPoints.value("WHRtg_SF").isValid())
m_wHRtg_SF = m_dataPoints.value("WHRtg_SF").toInt16();
if (m_dataPoints.value("WChaDisChaMax_SF").isValid())
m_wChaDisChaMax_SF = m_dataPoints.value("WChaDisChaMax_SF").toInt16();
if (m_dataPoints.value("DisChaRte_SF").isValid())
m_disChaRte_SF = m_dataPoints.value("DisChaRte_SF").toInt16();
if (m_dataPoints.value("SoC_SF").isValid())
m_soC_SF = m_dataPoints.value("SoC_SF").toInt16();
if (m_dataPoints.value("DoD_SF").isValid())
m_doD_SF = m_dataPoints.value("DoD_SF").toInt16();
if (m_dataPoints.value("SoH_SF").isValid())
m_soH_SF = m_dataPoints.value("SoH_SF").toInt16();
if (m_dataPoints.value("V_SF").isValid())
m_v_SF = m_dataPoints.value("V_SF").toInt16();
if (m_dataPoints.value("CellV_SF").isValid())
m_cellV_SF = m_dataPoints.value("CellV_SF").toInt16();
if (m_dataPoints.value("A_SF").isValid())
m_a_SF = m_dataPoints.value("A_SF").toInt16();
if (m_dataPoints.value("AMax_SF").isValid())
m_aMax_SF = m_dataPoints.value("AMax_SF").toInt16();
if (m_dataPoints.value("W_SF").isValid())
m_w_SF = m_dataPoints.value("W_SF").toInt16();
// Update properties according to the data point type
if (m_dataPoints.value("AHRtg").isValid())
m_nameplateChargeCapacity = m_dataPoints.value("AHRtg").toFloatWithSSF(m_aHRtg_SF);
if (m_dataPoints.value("WHRtg").isValid())
m_nameplateEnergyCapacity = m_dataPoints.value("WHRtg").toFloatWithSSF(m_wHRtg_SF);
if (m_dataPoints.value("WChaRteMax").isValid())
m_nameplateMaxChargeRate = m_dataPoints.value("WChaRteMax").toFloatWithSSF(m_wChaDisChaMax_SF);
if (m_dataPoints.value("WDisChaRteMax").isValid())
m_nameplateMaxDischargeRate = m_dataPoints.value("WDisChaRteMax").toFloatWithSSF(m_wChaDisChaMax_SF);
if (m_dataPoints.value("DisChaRte").isValid())
m_selfDischargeRate = m_dataPoints.value("DisChaRte").toFloatWithSSF(m_disChaRte_SF);
if (m_dataPoints.value("SoCMax").isValid())
m_nameplateMaxSoC = m_dataPoints.value("SoCMax").toFloatWithSSF(m_soC_SF);
if (m_dataPoints.value("SoCMin").isValid())
m_nameplateMinSoC = m_dataPoints.value("SoCMin").toFloatWithSSF(m_soC_SF);
if (m_dataPoints.value("SocRsvMax").isValid())
m_maxReservePercent = m_dataPoints.value("SocRsvMax").toFloatWithSSF(m_soC_SF);
if (m_dataPoints.value("SoCRsvMin").isValid())
m_minReservePercent = m_dataPoints.value("SoCRsvMin").toFloatWithSSF(m_soC_SF);
if (m_dataPoints.value("SoC").isValid())
m_stateOfCharge = m_dataPoints.value("SoC").toFloatWithSSF(m_soC_SF);
if (m_dataPoints.value("DoD").isValid())
m_depthOfDischarge = m_dataPoints.value("DoD").toFloatWithSSF(m_doD_SF);
if (m_dataPoints.value("SoH").isValid())
m_stateOfHealth = m_dataPoints.value("SoH").toFloatWithSSF(m_soH_SF);
if (m_dataPoints.value("NCyc").isValid())
m_cycleCount = m_dataPoints.value("NCyc").toUInt32();
if (m_dataPoints.value("ChaSt").isValid())
m_chargeStatus = static_cast<Chast>(m_dataPoints.value("ChaSt").toUInt16());
if (m_dataPoints.value("LocRemCtl").isValid())
m_controlMode = static_cast<Locremctl>(m_dataPoints.value("LocRemCtl").toUInt16());
if (m_dataPoints.value("Hb").isValid())
m_batteryHeartbeat = m_dataPoints.value("Hb").toUInt16();
if (m_dataPoints.value("CtrlHb").isValid())
m_controllerHeartbeat = m_dataPoints.value("CtrlHb").toUInt16();
if (m_dataPoints.value("AlmRst").isValid())
m_alarmReset = m_dataPoints.value("AlmRst").toUInt16();
if (m_dataPoints.value("Typ").isValid())
m_batteryType = static_cast<Typ>(m_dataPoints.value("Typ").toUInt16());
if (m_dataPoints.value("State").isValid())
m_stateOfTheBatteryBank = static_cast<State>(m_dataPoints.value("State").toUInt16());
if (m_dataPoints.value("StateVnd").isValid())
m_vendorBatteryBankState = m_dataPoints.value("StateVnd").toUInt16();
if (m_dataPoints.value("WarrDt").isValid())
m_warrantyDate = m_dataPoints.value("WarrDt").toUInt32();
if (m_dataPoints.value("Evt1").isValid())
m_batteryEvent1Bitfield = static_cast<Evt1Flags>(m_dataPoints.value("Evt1").toUInt32());
if (m_dataPoints.value("Evt2").isValid())
m_batteryEvent2Bitfield = m_dataPoints.value("Evt2").toUInt32();
if (m_dataPoints.value("EvtVnd1").isValid())
m_vendorEventBitfield1 = m_dataPoints.value("EvtVnd1").toUInt32();
if (m_dataPoints.value("EvtVnd2").isValid())
m_vendorEventBitfield2 = m_dataPoints.value("EvtVnd2").toUInt32();
if (m_dataPoints.value("V").isValid())
m_externalBatteryVoltage = m_dataPoints.value("V").toFloatWithSSF(m_v_SF);
if (m_dataPoints.value("VMax").isValid())
m_maxBatteryVoltage = m_dataPoints.value("VMax").toFloatWithSSF(m_v_SF);
if (m_dataPoints.value("VMin").isValid())
m_minBatteryVoltage = m_dataPoints.value("VMin").toFloatWithSSF(m_v_SF);
if (m_dataPoints.value("CellVMax").isValid())
m_maxCellVoltage = m_dataPoints.value("CellVMax").toFloatWithSSF(m_cellV_SF);
if (m_dataPoints.value("CellVMaxStr").isValid())
m_maxCellVoltageString = m_dataPoints.value("CellVMaxStr").toUInt16();
if (m_dataPoints.value("CellVMaxMod").isValid())
m_maxCellVoltageModule = m_dataPoints.value("CellVMaxMod").toUInt16();
if (m_dataPoints.value("CellVMin").isValid())
m_minCellVoltage = m_dataPoints.value("CellVMin").toFloatWithSSF(m_cellV_SF);
if (m_dataPoints.value("CellVMinStr").isValid())
m_minCellVoltageString = m_dataPoints.value("CellVMinStr").toUInt16();
if (m_dataPoints.value("CellVMinMod").isValid())
m_minCellVoltageModule = m_dataPoints.value("CellVMinMod").toUInt16();
if (m_dataPoints.value("CellVAvg").isValid())
m_averageCellVoltage = m_dataPoints.value("CellVAvg").toFloatWithSSF(m_cellV_SF);
if (m_dataPoints.value("A").isValid())
m_totalDcCurrent = m_dataPoints.value("A").toFloatWithSSF(m_a_SF);
if (m_dataPoints.value("AChaMax").isValid())
m_maxChargeCurrent = m_dataPoints.value("AChaMax").toFloatWithSSF(m_aMax_SF);
if (m_dataPoints.value("ADisChaMax").isValid())
m_maxDischargeCurrent = m_dataPoints.value("ADisChaMax").toFloatWithSSF(m_aMax_SF);
if (m_dataPoints.value("W").isValid())
m_totalPower = m_dataPoints.value("W").toFloatWithSSF(m_w_SF);
if (m_dataPoints.value("ReqInvState").isValid())
m_inverterStateRequest = static_cast<Reqinvstate>(m_dataPoints.value("ReqInvState").toUInt16());
if (m_dataPoints.value("ReqW").isValid())
m_batteryPowerRequest = m_dataPoints.value("ReqW").toFloatWithSSF(m_w_SF);
if (m_dataPoints.value("SetOp").isValid())
m_setOperation = static_cast<Setop>(m_dataPoints.value("SetOp").toUInt16());
if (m_dataPoints.value("SetInvState").isValid())
m_setInverterState = static_cast<Setinvstate>(m_dataPoints.value("SetInvState").toUInt16());
if (m_dataPoints.value("AHRtg_SF").isValid())
m_aHRtg_SF = m_dataPoints.value("AHRtg_SF").toInt16();
if (m_dataPoints.value("WHRtg_SF").isValid())
m_wHRtg_SF = m_dataPoints.value("WHRtg_SF").toInt16();
if (m_dataPoints.value("WChaDisChaMax_SF").isValid())
m_wChaDisChaMax_SF = m_dataPoints.value("WChaDisChaMax_SF").toInt16();
if (m_dataPoints.value("DisChaRte_SF").isValid())
m_disChaRte_SF = m_dataPoints.value("DisChaRte_SF").toInt16();
if (m_dataPoints.value("SoC_SF").isValid())
m_soC_SF = m_dataPoints.value("SoC_SF").toInt16();
if (m_dataPoints.value("DoD_SF").isValid())
m_doD_SF = m_dataPoints.value("DoD_SF").toInt16();
if (m_dataPoints.value("SoH_SF").isValid())
m_soH_SF = m_dataPoints.value("SoH_SF").toInt16();
if (m_dataPoints.value("V_SF").isValid())
m_v_SF = m_dataPoints.value("V_SF").toInt16();
if (m_dataPoints.value("CellV_SF").isValid())
m_cellV_SF = m_dataPoints.value("CellV_SF").toInt16();
if (m_dataPoints.value("A_SF").isValid())
m_a_SF = m_dataPoints.value("A_SF").toInt16();
if (m_dataPoints.value("AMax_SF").isValid())
m_aMax_SF = m_dataPoints.value("AMax_SF").toInt16();
if (m_dataPoints.value("W_SF").isValid())
m_w_SF = m_dataPoints.value("W_SF").toInt16();
qCDebug(dcSunSpecModelData()) << this;
}
QDebug operator<<(QDebug debug, SunSpecBatteryModel *model)
{
debug.nospace().noquote() << "SunSpecBatteryModel(Model: " << model->modelId() << ", Register: " << model->modbusStartRegister() << ", Length: " << model->modelLength() << ")\n";
debug.nospace().noquote() << " - " << model->dataPoints().value("AHRtg") << "-->";
if (model->dataPoints().value("AHRtg").isValid()) {
debug.nospace().noquote() << model->nameplateChargeCapacity() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("WHRtg") << "-->";
if (model->dataPoints().value("WHRtg").isValid()) {
debug.nospace().noquote() << model->nameplateEnergyCapacity() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("WChaRteMax") << "-->";
if (model->dataPoints().value("WChaRteMax").isValid()) {
debug.nospace().noquote() << model->nameplateMaxChargeRate() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("WDisChaRteMax") << "-->";
if (model->dataPoints().value("WDisChaRteMax").isValid()) {
debug.nospace().noquote() << model->nameplateMaxDischargeRate() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("DisChaRte") << "-->";
if (model->dataPoints().value("DisChaRte").isValid()) {
debug.nospace().noquote() << model->selfDischargeRate() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("SoCMax") << "-->";
if (model->dataPoints().value("SoCMax").isValid()) {
debug.nospace().noquote() << model->nameplateMaxSoC() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("SoCMin") << "-->";
if (model->dataPoints().value("SoCMin").isValid()) {
debug.nospace().noquote() << model->nameplateMinSoC() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("SocRsvMax") << "-->";
if (model->dataPoints().value("SocRsvMax").isValid()) {
debug.nospace().noquote() << model->maxReservePercent() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("SoCRsvMin") << "-->";
if (model->dataPoints().value("SoCRsvMin").isValid()) {
debug.nospace().noquote() << model->minReservePercent() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("SoC") << "-->";
if (model->dataPoints().value("SoC").isValid()) {
debug.nospace().noquote() << model->stateOfCharge() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("DoD") << "-->";
if (model->dataPoints().value("DoD").isValid()) {
debug.nospace().noquote() << model->depthOfDischarge() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("SoH") << "-->";
if (model->dataPoints().value("SoH").isValid()) {
debug.nospace().noquote() << model->stateOfHealth() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("NCyc") << "-->";
if (model->dataPoints().value("NCyc").isValid()) {
debug.nospace().noquote() << model->cycleCount() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("ChaSt") << "-->";
if (model->dataPoints().value("ChaSt").isValid()) {
debug.nospace().noquote() << model->chargeStatus() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("LocRemCtl") << "-->";
if (model->dataPoints().value("LocRemCtl").isValid()) {
debug.nospace().noquote() << model->controlMode() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("Hb") << "-->";
if (model->dataPoints().value("Hb").isValid()) {
debug.nospace().noquote() << model->batteryHeartbeat() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("CtrlHb") << "-->";
if (model->dataPoints().value("CtrlHb").isValid()) {
debug.nospace().noquote() << model->controllerHeartbeat() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("AlmRst") << "-->";
if (model->dataPoints().value("AlmRst").isValid()) {
debug.nospace().noquote() << model->alarmReset() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("Typ") << "-->";
if (model->dataPoints().value("Typ").isValid()) {
debug.nospace().noquote() << model->batteryType() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("State") << "-->";
if (model->dataPoints().value("State").isValid()) {
debug.nospace().noquote() << model->stateOfTheBatteryBank() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("StateVnd") << "-->";
if (model->dataPoints().value("StateVnd").isValid()) {
debug.nospace().noquote() << model->vendorBatteryBankState() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("WarrDt") << "-->";
if (model->dataPoints().value("WarrDt").isValid()) {
debug.nospace().noquote() << model->warrantyDate() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("Evt1") << "-->";
if (model->dataPoints().value("Evt1").isValid()) {
debug.nospace().noquote() << model->batteryEvent1Bitfield() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("Evt2") << "-->";
if (model->dataPoints().value("Evt2").isValid()) {
debug.nospace().noquote() << model->batteryEvent2Bitfield() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("EvtVnd1") << "-->";
if (model->dataPoints().value("EvtVnd1").isValid()) {
debug.nospace().noquote() << model->vendorEventBitfield1() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("EvtVnd2") << "-->";
if (model->dataPoints().value("EvtVnd2").isValid()) {
debug.nospace().noquote() << model->vendorEventBitfield2() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("V") << "-->";
if (model->dataPoints().value("V").isValid()) {
debug.nospace().noquote() << model->externalBatteryVoltage() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("VMax") << "-->";
if (model->dataPoints().value("VMax").isValid()) {
debug.nospace().noquote() << model->maxBatteryVoltage() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("VMin") << "-->";
if (model->dataPoints().value("VMin").isValid()) {
debug.nospace().noquote() << model->minBatteryVoltage() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("CellVMax") << "-->";
if (model->dataPoints().value("CellVMax").isValid()) {
debug.nospace().noquote() << model->maxCellVoltage() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("CellVMaxStr") << "-->";
if (model->dataPoints().value("CellVMaxStr").isValid()) {
debug.nospace().noquote() << model->maxCellVoltageString() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("CellVMaxMod") << "-->";
if (model->dataPoints().value("CellVMaxMod").isValid()) {
debug.nospace().noquote() << model->maxCellVoltageModule() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("CellVMin") << "-->";
if (model->dataPoints().value("CellVMin").isValid()) {
debug.nospace().noquote() << model->minCellVoltage() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("CellVMinStr") << "-->";
if (model->dataPoints().value("CellVMinStr").isValid()) {
debug.nospace().noquote() << model->minCellVoltageString() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("CellVMinMod") << "-->";
if (model->dataPoints().value("CellVMinMod").isValid()) {
debug.nospace().noquote() << model->minCellVoltageModule() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("CellVAvg") << "-->";
if (model->dataPoints().value("CellVAvg").isValid()) {
debug.nospace().noquote() << model->averageCellVoltage() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("A") << "-->";
if (model->dataPoints().value("A").isValid()) {
debug.nospace().noquote() << model->totalDcCurrent() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("AChaMax") << "-->";
if (model->dataPoints().value("AChaMax").isValid()) {
debug.nospace().noquote() << model->maxChargeCurrent() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("ADisChaMax") << "-->";
if (model->dataPoints().value("ADisChaMax").isValid()) {
debug.nospace().noquote() << model->maxDischargeCurrent() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("W") << "-->";
if (model->dataPoints().value("W").isValid()) {
debug.nospace().noquote() << model->totalPower() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("ReqInvState") << "-->";
if (model->dataPoints().value("ReqInvState").isValid()) {
debug.nospace().noquote() << model->inverterStateRequest() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("ReqW") << "-->";
if (model->dataPoints().value("ReqW").isValid()) {
debug.nospace().noquote() << model->batteryPowerRequest() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("SetOp") << "-->";
if (model->dataPoints().value("SetOp").isValid()) {
debug.nospace().noquote() << model->setOperation() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
debug.nospace().noquote() << " - " << model->dataPoints().value("SetInvState") << "-->";
if (model->dataPoints().value("SetInvState").isValid()) {
debug.nospace().noquote() << model->setInverterState() << "\n";
} else {
debug.nospace().noquote() << "NaN\n";
}
return debug.space().quote();
}
Reference in New Issue View Git Blame Copy Permalink