/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Copyright 2013 - 2025, 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 . * * 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 "sunspecmeterthreephasemodel.h" #include "sunspecconnection.h" SunSpecMeterThreePhaseModel::SunSpecMeterThreePhaseModel(SunSpecConnection *connection, quint16 modbusStartRegister, quint16 modelLength, SunSpecDataPoint::ByteOrder byteOrder, QObject *parent) : SunSpecModel(connection, modbusStartRegister, 203, modelLength, byteOrder, parent) { m_modelBlockType = SunSpecModel::ModelBlockTypeFixed; initDataPoints(); } SunSpecMeterThreePhaseModel::~SunSpecMeterThreePhaseModel() { } QString SunSpecMeterThreePhaseModel::name() const { return "ac_meter"; } QString SunSpecMeterThreePhaseModel::description() const { return QString(); } QString SunSpecMeterThreePhaseModel::label() const { return "Meter (Three Phase)"; } float SunSpecMeterThreePhaseModel::amps() const { return m_amps; } float SunSpecMeterThreePhaseModel::ampsPhaseA() const { return m_ampsPhaseA; } float SunSpecMeterThreePhaseModel::ampsPhaseB() const { return m_ampsPhaseB; } float SunSpecMeterThreePhaseModel::ampsPhaseC() const { return m_ampsPhaseC; } qint16 SunSpecMeterThreePhaseModel::a_SF() const { return m_a_SF; } float SunSpecMeterThreePhaseModel::voltageLn() const { return m_voltageLn; } float SunSpecMeterThreePhaseModel::phaseVoltageAn() const { return m_phaseVoltageAn; } float SunSpecMeterThreePhaseModel::phaseVoltageBn() const { return m_phaseVoltageBn; } float SunSpecMeterThreePhaseModel::phaseVoltageCn() const { return m_phaseVoltageCn; } float SunSpecMeterThreePhaseModel::voltageLl() const { return m_voltageLl; } float SunSpecMeterThreePhaseModel::phaseVoltageAb() const { return m_phaseVoltageAb; } float SunSpecMeterThreePhaseModel::phaseVoltageBc() const { return m_phaseVoltageBc; } float SunSpecMeterThreePhaseModel::phaseVoltageCa() const { return m_phaseVoltageCa; } qint16 SunSpecMeterThreePhaseModel::v_SF() const { return m_v_SF; } float SunSpecMeterThreePhaseModel::hz() const { return m_hz; } qint16 SunSpecMeterThreePhaseModel::hz_SF() const { return m_hz_SF; } float SunSpecMeterThreePhaseModel::watts() const { return m_watts; } float SunSpecMeterThreePhaseModel::wattsPhaseA() const { return m_wattsPhaseA; } float SunSpecMeterThreePhaseModel::wattsPhaseB() const { return m_wattsPhaseB; } float SunSpecMeterThreePhaseModel::wattsPhaseC() const { return m_wattsPhaseC; } qint16 SunSpecMeterThreePhaseModel::w_SF() const { return m_w_SF; } float SunSpecMeterThreePhaseModel::va() const { return m_va; } float SunSpecMeterThreePhaseModel::vaPhaseA() const { return m_vaPhaseA; } float SunSpecMeterThreePhaseModel::vaPhaseB() const { return m_vaPhaseB; } float SunSpecMeterThreePhaseModel::vaPhaseC() const { return m_vaPhaseC; } qint16 SunSpecMeterThreePhaseModel::vA_SF() const { return m_vA_SF; } float SunSpecMeterThreePhaseModel::var() const { return m_var; } float SunSpecMeterThreePhaseModel::varPhaseA() const { return m_varPhaseA; } float SunSpecMeterThreePhaseModel::varPhaseB() const { return m_varPhaseB; } float SunSpecMeterThreePhaseModel::varPhaseC() const { return m_varPhaseC; } qint16 SunSpecMeterThreePhaseModel::vAR_SF() const { return m_vAR_SF; } float SunSpecMeterThreePhaseModel::pf() const { return m_pf; } float SunSpecMeterThreePhaseModel::pfPhaseA() const { return m_pfPhaseA; } float SunSpecMeterThreePhaseModel::pfPhaseB() const { return m_pfPhaseB; } float SunSpecMeterThreePhaseModel::pfPhaseC() const { return m_pfPhaseC; } qint16 SunSpecMeterThreePhaseModel::pF_SF() const { return m_pF_SF; } quint32 SunSpecMeterThreePhaseModel::totalWattHoursExported() const { return m_totalWattHoursExported; } quint32 SunSpecMeterThreePhaseModel::totalWattHoursExportedPhaseA() const { return m_totalWattHoursExportedPhaseA; } quint32 SunSpecMeterThreePhaseModel::totalWattHoursExportedPhaseB() const { return m_totalWattHoursExportedPhaseB; } quint32 SunSpecMeterThreePhaseModel::totalWattHoursExportedPhaseC() const { return m_totalWattHoursExportedPhaseC; } quint32 SunSpecMeterThreePhaseModel::totalWattHoursImported() const { return m_totalWattHoursImported; } quint32 SunSpecMeterThreePhaseModel::totalWattHoursImportedPhaseA() const { return m_totalWattHoursImportedPhaseA; } quint32 SunSpecMeterThreePhaseModel::totalWattHoursImportedPhaseB() const { return m_totalWattHoursImportedPhaseB; } quint32 SunSpecMeterThreePhaseModel::totalWattHoursImportedPhaseC() const { return m_totalWattHoursImportedPhaseC; } qint16 SunSpecMeterThreePhaseModel::totWh_SF() const { return m_totWh_SF; } quint32 SunSpecMeterThreePhaseModel::totalVaHoursExported() const { return m_totalVaHoursExported; } quint32 SunSpecMeterThreePhaseModel::totalVaHoursExportedPhaseA() const { return m_totalVaHoursExportedPhaseA; } quint32 SunSpecMeterThreePhaseModel::totalVaHoursExportedPhaseB() const { return m_totalVaHoursExportedPhaseB; } quint32 SunSpecMeterThreePhaseModel::totalVaHoursExportedPhaseC() const { return m_totalVaHoursExportedPhaseC; } quint32 SunSpecMeterThreePhaseModel::totalVaHoursImported() const { return m_totalVaHoursImported; } quint32 SunSpecMeterThreePhaseModel::totalVaHoursImportedPhaseA() const { return m_totalVaHoursImportedPhaseA; } quint32 SunSpecMeterThreePhaseModel::totalVaHoursImportedPhaseB() const { return m_totalVaHoursImportedPhaseB; } quint32 SunSpecMeterThreePhaseModel::totalVaHoursImportedPhaseC() const { return m_totalVaHoursImportedPhaseC; } qint16 SunSpecMeterThreePhaseModel::totVAh_SF() const { return m_totVAh_SF; } quint32 SunSpecMeterThreePhaseModel::totalVarHoursImportedQ1() const { return m_totalVarHoursImportedQ1; } quint32 SunSpecMeterThreePhaseModel::totalVArHoursImportedQ1PhaseA() const { return m_totalVArHoursImportedQ1PhaseA; } quint32 SunSpecMeterThreePhaseModel::totalVArHoursImportedQ1PhaseB() const { return m_totalVArHoursImportedQ1PhaseB; } quint32 SunSpecMeterThreePhaseModel::totalVArHoursImportedQ1PhaseC() const { return m_totalVArHoursImportedQ1PhaseC; } quint32 SunSpecMeterThreePhaseModel::totalVArHoursImportedQ2() const { return m_totalVArHoursImportedQ2; } quint32 SunSpecMeterThreePhaseModel::totalVArHoursImportedQ2PhaseA() const { return m_totalVArHoursImportedQ2PhaseA; } quint32 SunSpecMeterThreePhaseModel::totalVArHoursImportedQ2PhaseB() const { return m_totalVArHoursImportedQ2PhaseB; } quint32 SunSpecMeterThreePhaseModel::totalVArHoursImportedQ2PhaseC() const { return m_totalVArHoursImportedQ2PhaseC; } quint32 SunSpecMeterThreePhaseModel::totalVArHoursExportedQ3() const { return m_totalVArHoursExportedQ3; } quint32 SunSpecMeterThreePhaseModel::totalVArHoursExportedQ3PhaseA() const { return m_totalVArHoursExportedQ3PhaseA; } quint32 SunSpecMeterThreePhaseModel::totalVArHoursExportedQ3PhaseB() const { return m_totalVArHoursExportedQ3PhaseB; } quint32 SunSpecMeterThreePhaseModel::totalVArHoursExportedQ3PhaseC() const { return m_totalVArHoursExportedQ3PhaseC; } quint32 SunSpecMeterThreePhaseModel::totalVArHoursExportedQ4() const { return m_totalVArHoursExportedQ4; } quint32 SunSpecMeterThreePhaseModel::totalVArHoursExportedQ4ImportedPhaseA() const { return m_totalVArHoursExportedQ4ImportedPhaseA; } quint32 SunSpecMeterThreePhaseModel::totalVArHoursExportedQ4ImportedPhaseB() const { return m_totalVArHoursExportedQ4ImportedPhaseB; } quint32 SunSpecMeterThreePhaseModel::totalVArHoursExportedQ4ImportedPhaseC() const { return m_totalVArHoursExportedQ4ImportedPhaseC; } qint16 SunSpecMeterThreePhaseModel::totVArh_SF() const { return m_totVArh_SF; } SunSpecMeterThreePhaseModel::EvtFlags SunSpecMeterThreePhaseModel::events() const { return m_events; } void SunSpecMeterThreePhaseModel::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 ampsDataPoint; ampsDataPoint.setName("A"); ampsDataPoint.setLabel("Amps"); ampsDataPoint.setDescription("Total AC Current"); ampsDataPoint.setUnits("A"); ampsDataPoint.setMandatory(true); ampsDataPoint.setSize(1); ampsDataPoint.setAddressOffset(2); ampsDataPoint.setBlockOffset(0); ampsDataPoint.setScaleFactorName("A_SF"); ampsDataPoint.setSunSpecDataType("int16"); ampsDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(ampsDataPoint.name(), ampsDataPoint); SunSpecDataPoint ampsPhaseADataPoint; ampsPhaseADataPoint.setName("AphA"); ampsPhaseADataPoint.setLabel("Amps PhaseA"); ampsPhaseADataPoint.setDescription("Phase A Current"); ampsPhaseADataPoint.setUnits("A"); ampsPhaseADataPoint.setMandatory(true); ampsPhaseADataPoint.setSize(1); ampsPhaseADataPoint.setAddressOffset(3); ampsPhaseADataPoint.setBlockOffset(1); ampsPhaseADataPoint.setScaleFactorName("A_SF"); ampsPhaseADataPoint.setSunSpecDataType("int16"); ampsPhaseADataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(ampsPhaseADataPoint.name(), ampsPhaseADataPoint); SunSpecDataPoint ampsPhaseBDataPoint; ampsPhaseBDataPoint.setName("AphB"); ampsPhaseBDataPoint.setLabel("Amps PhaseB"); ampsPhaseBDataPoint.setDescription("Phase B Current"); ampsPhaseBDataPoint.setUnits("A"); ampsPhaseBDataPoint.setMandatory(true); ampsPhaseBDataPoint.setSize(1); ampsPhaseBDataPoint.setAddressOffset(4); ampsPhaseBDataPoint.setBlockOffset(2); ampsPhaseBDataPoint.setScaleFactorName("A_SF"); ampsPhaseBDataPoint.setSunSpecDataType("int16"); ampsPhaseBDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(ampsPhaseBDataPoint.name(), ampsPhaseBDataPoint); SunSpecDataPoint ampsPhaseCDataPoint; ampsPhaseCDataPoint.setName("AphC"); ampsPhaseCDataPoint.setLabel("Amps PhaseC"); ampsPhaseCDataPoint.setDescription("Phase C Current"); ampsPhaseCDataPoint.setUnits("A"); ampsPhaseCDataPoint.setMandatory(true); ampsPhaseCDataPoint.setSize(1); ampsPhaseCDataPoint.setAddressOffset(5); ampsPhaseCDataPoint.setBlockOffset(3); ampsPhaseCDataPoint.setScaleFactorName("A_SF"); ampsPhaseCDataPoint.setSunSpecDataType("int16"); ampsPhaseCDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(ampsPhaseCDataPoint.name(), ampsPhaseCDataPoint); SunSpecDataPoint a_SFDataPoint; a_SFDataPoint.setName("A_SF"); a_SFDataPoint.setDescription("Current scale factor"); a_SFDataPoint.setMandatory(true); a_SFDataPoint.setSize(1); a_SFDataPoint.setAddressOffset(6); a_SFDataPoint.setBlockOffset(4); a_SFDataPoint.setSunSpecDataType("sunssf"); a_SFDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(a_SFDataPoint.name(), a_SFDataPoint); SunSpecDataPoint voltageLnDataPoint; voltageLnDataPoint.setName("PhV"); voltageLnDataPoint.setLabel("Voltage LN"); voltageLnDataPoint.setDescription("Line to Neutral AC Voltage (average of active phases)"); voltageLnDataPoint.setUnits("V"); voltageLnDataPoint.setMandatory(true); voltageLnDataPoint.setSize(1); voltageLnDataPoint.setAddressOffset(7); voltageLnDataPoint.setBlockOffset(5); voltageLnDataPoint.setScaleFactorName("V_SF"); voltageLnDataPoint.setSunSpecDataType("int16"); voltageLnDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(voltageLnDataPoint.name(), voltageLnDataPoint); SunSpecDataPoint phaseVoltageAnDataPoint; phaseVoltageAnDataPoint.setName("PhVphA"); phaseVoltageAnDataPoint.setLabel("Phase Voltage AN"); phaseVoltageAnDataPoint.setDescription("Phase Voltage AN"); phaseVoltageAnDataPoint.setUnits("V"); phaseVoltageAnDataPoint.setMandatory(true); phaseVoltageAnDataPoint.setSize(1); phaseVoltageAnDataPoint.setAddressOffset(8); phaseVoltageAnDataPoint.setBlockOffset(6); phaseVoltageAnDataPoint.setScaleFactorName("V_SF"); phaseVoltageAnDataPoint.setSunSpecDataType("int16"); phaseVoltageAnDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(phaseVoltageAnDataPoint.name(), phaseVoltageAnDataPoint); SunSpecDataPoint phaseVoltageBnDataPoint; phaseVoltageBnDataPoint.setName("PhVphB"); phaseVoltageBnDataPoint.setLabel("Phase Voltage BN"); phaseVoltageBnDataPoint.setDescription("Phase Voltage BN"); phaseVoltageBnDataPoint.setUnits("V"); phaseVoltageBnDataPoint.setMandatory(true); phaseVoltageBnDataPoint.setSize(1); phaseVoltageBnDataPoint.setAddressOffset(9); phaseVoltageBnDataPoint.setBlockOffset(7); phaseVoltageBnDataPoint.setScaleFactorName("V_SF"); phaseVoltageBnDataPoint.setSunSpecDataType("int16"); phaseVoltageBnDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(phaseVoltageBnDataPoint.name(), phaseVoltageBnDataPoint); SunSpecDataPoint phaseVoltageCnDataPoint; phaseVoltageCnDataPoint.setName("PhVphC"); phaseVoltageCnDataPoint.setLabel("Phase Voltage CN"); phaseVoltageCnDataPoint.setDescription("Phase Voltage CN"); phaseVoltageCnDataPoint.setUnits("V"); phaseVoltageCnDataPoint.setMandatory(true); phaseVoltageCnDataPoint.setSize(1); phaseVoltageCnDataPoint.setAddressOffset(10); phaseVoltageCnDataPoint.setBlockOffset(8); phaseVoltageCnDataPoint.setScaleFactorName("V_SF"); phaseVoltageCnDataPoint.setSunSpecDataType("int16"); phaseVoltageCnDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(phaseVoltageCnDataPoint.name(), phaseVoltageCnDataPoint); SunSpecDataPoint voltageLlDataPoint; voltageLlDataPoint.setName("PPV"); voltageLlDataPoint.setLabel("Voltage LL"); voltageLlDataPoint.setDescription("Line to Line AC Voltage (average of active phases)"); voltageLlDataPoint.setUnits("V"); voltageLlDataPoint.setMandatory(true); voltageLlDataPoint.setSize(1); voltageLlDataPoint.setAddressOffset(11); voltageLlDataPoint.setBlockOffset(9); voltageLlDataPoint.setScaleFactorName("V_SF"); voltageLlDataPoint.setSunSpecDataType("int16"); voltageLlDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(voltageLlDataPoint.name(), voltageLlDataPoint); SunSpecDataPoint phaseVoltageAbDataPoint; phaseVoltageAbDataPoint.setName("PhVphAB"); phaseVoltageAbDataPoint.setLabel("Phase Voltage AB"); phaseVoltageAbDataPoint.setDescription("Phase Voltage AB"); phaseVoltageAbDataPoint.setUnits("V"); phaseVoltageAbDataPoint.setMandatory(true); phaseVoltageAbDataPoint.setSize(1); phaseVoltageAbDataPoint.setAddressOffset(12); phaseVoltageAbDataPoint.setBlockOffset(10); phaseVoltageAbDataPoint.setScaleFactorName("V_SF"); phaseVoltageAbDataPoint.setSunSpecDataType("int16"); phaseVoltageAbDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(phaseVoltageAbDataPoint.name(), phaseVoltageAbDataPoint); SunSpecDataPoint phaseVoltageBcDataPoint; phaseVoltageBcDataPoint.setName("PhVphBC"); phaseVoltageBcDataPoint.setLabel("Phase Voltage BC"); phaseVoltageBcDataPoint.setDescription("Phase Voltage BC"); phaseVoltageBcDataPoint.setUnits("V"); phaseVoltageBcDataPoint.setMandatory(true); phaseVoltageBcDataPoint.setSize(1); phaseVoltageBcDataPoint.setAddressOffset(13); phaseVoltageBcDataPoint.setBlockOffset(11); phaseVoltageBcDataPoint.setScaleFactorName("V_SF"); phaseVoltageBcDataPoint.setSunSpecDataType("int16"); phaseVoltageBcDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(phaseVoltageBcDataPoint.name(), phaseVoltageBcDataPoint); SunSpecDataPoint phaseVoltageCaDataPoint; phaseVoltageCaDataPoint.setName("PhVphCA"); phaseVoltageCaDataPoint.setLabel("Phase Voltage CA"); phaseVoltageCaDataPoint.setDescription("Phase Voltage CA"); phaseVoltageCaDataPoint.setUnits("V"); phaseVoltageCaDataPoint.setMandatory(true); phaseVoltageCaDataPoint.setSize(1); phaseVoltageCaDataPoint.setAddressOffset(14); phaseVoltageCaDataPoint.setBlockOffset(12); phaseVoltageCaDataPoint.setScaleFactorName("V_SF"); phaseVoltageCaDataPoint.setSunSpecDataType("int16"); phaseVoltageCaDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(phaseVoltageCaDataPoint.name(), phaseVoltageCaDataPoint); SunSpecDataPoint v_SFDataPoint; v_SFDataPoint.setName("V_SF"); v_SFDataPoint.setDescription("Voltage scale factor"); v_SFDataPoint.setMandatory(true); v_SFDataPoint.setSize(1); v_SFDataPoint.setAddressOffset(15); v_SFDataPoint.setBlockOffset(13); v_SFDataPoint.setSunSpecDataType("sunssf"); v_SFDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(v_SFDataPoint.name(), v_SFDataPoint); SunSpecDataPoint hzDataPoint; hzDataPoint.setName("Hz"); hzDataPoint.setLabel("Hz"); hzDataPoint.setDescription("Frequency"); hzDataPoint.setUnits("Hz"); hzDataPoint.setMandatory(true); hzDataPoint.setSize(1); hzDataPoint.setAddressOffset(16); hzDataPoint.setBlockOffset(14); hzDataPoint.setScaleFactorName("Hz_SF"); hzDataPoint.setSunSpecDataType("int16"); hzDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(hzDataPoint.name(), hzDataPoint); SunSpecDataPoint hz_SFDataPoint; hz_SFDataPoint.setName("Hz_SF"); hz_SFDataPoint.setDescription("Frequency scale factor"); hz_SFDataPoint.setSize(1); hz_SFDataPoint.setAddressOffset(17); hz_SFDataPoint.setBlockOffset(15); hz_SFDataPoint.setSunSpecDataType("sunssf"); hz_SFDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(hz_SFDataPoint.name(), hz_SFDataPoint); SunSpecDataPoint wattsDataPoint; wattsDataPoint.setName("W"); wattsDataPoint.setLabel("Watts"); wattsDataPoint.setDescription("Total Real Power"); wattsDataPoint.setUnits("W"); wattsDataPoint.setMandatory(true); wattsDataPoint.setSize(1); wattsDataPoint.setAddressOffset(18); wattsDataPoint.setBlockOffset(16); wattsDataPoint.setScaleFactorName("W_SF"); wattsDataPoint.setSunSpecDataType("int16"); wattsDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(wattsDataPoint.name(), wattsDataPoint); SunSpecDataPoint wattsPhaseADataPoint; wattsPhaseADataPoint.setName("WphA"); wattsPhaseADataPoint.setLabel("Watts phase A"); wattsPhaseADataPoint.setUnits("W"); wattsPhaseADataPoint.setSize(1); wattsPhaseADataPoint.setAddressOffset(19); wattsPhaseADataPoint.setBlockOffset(17); wattsPhaseADataPoint.setScaleFactorName("W_SF"); wattsPhaseADataPoint.setSunSpecDataType("int16"); wattsPhaseADataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(wattsPhaseADataPoint.name(), wattsPhaseADataPoint); SunSpecDataPoint wattsPhaseBDataPoint; wattsPhaseBDataPoint.setName("WphB"); wattsPhaseBDataPoint.setLabel("Watts phase B"); wattsPhaseBDataPoint.setUnits("W"); wattsPhaseBDataPoint.setSize(1); wattsPhaseBDataPoint.setAddressOffset(20); wattsPhaseBDataPoint.setBlockOffset(18); wattsPhaseBDataPoint.setScaleFactorName("W_SF"); wattsPhaseBDataPoint.setSunSpecDataType("int16"); wattsPhaseBDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(wattsPhaseBDataPoint.name(), wattsPhaseBDataPoint); SunSpecDataPoint wattsPhaseCDataPoint; wattsPhaseCDataPoint.setName("WphC"); wattsPhaseCDataPoint.setLabel("Watts phase C"); wattsPhaseCDataPoint.setUnits("W"); wattsPhaseCDataPoint.setSize(1); wattsPhaseCDataPoint.setAddressOffset(21); wattsPhaseCDataPoint.setBlockOffset(19); wattsPhaseCDataPoint.setScaleFactorName("W_SF"); wattsPhaseCDataPoint.setSunSpecDataType("int16"); wattsPhaseCDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(wattsPhaseCDataPoint.name(), wattsPhaseCDataPoint); SunSpecDataPoint w_SFDataPoint; w_SFDataPoint.setName("W_SF"); w_SFDataPoint.setDescription("Real Power scale factor"); w_SFDataPoint.setMandatory(true); w_SFDataPoint.setSize(1); w_SFDataPoint.setAddressOffset(22); w_SFDataPoint.setBlockOffset(20); w_SFDataPoint.setSunSpecDataType("sunssf"); w_SFDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(w_SFDataPoint.name(), w_SFDataPoint); SunSpecDataPoint vaDataPoint; vaDataPoint.setName("VA"); vaDataPoint.setLabel("VA"); vaDataPoint.setDescription("AC Apparent Power"); vaDataPoint.setUnits("VA"); vaDataPoint.setSize(1); vaDataPoint.setAddressOffset(23); vaDataPoint.setBlockOffset(21); vaDataPoint.setScaleFactorName("VA_SF"); vaDataPoint.setSunSpecDataType("int16"); vaDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(vaDataPoint.name(), vaDataPoint); SunSpecDataPoint vaPhaseADataPoint; vaPhaseADataPoint.setName("VAphA"); vaPhaseADataPoint.setLabel("VA phase A"); vaPhaseADataPoint.setUnits("VA"); vaPhaseADataPoint.setSize(1); vaPhaseADataPoint.setAddressOffset(24); vaPhaseADataPoint.setBlockOffset(22); vaPhaseADataPoint.setScaleFactorName("VA_SF"); vaPhaseADataPoint.setSunSpecDataType("int16"); vaPhaseADataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(vaPhaseADataPoint.name(), vaPhaseADataPoint); SunSpecDataPoint vaPhaseBDataPoint; vaPhaseBDataPoint.setName("VAphB"); vaPhaseBDataPoint.setLabel("VA phase B"); vaPhaseBDataPoint.setUnits("VA"); vaPhaseBDataPoint.setSize(1); vaPhaseBDataPoint.setAddressOffset(25); vaPhaseBDataPoint.setBlockOffset(23); vaPhaseBDataPoint.setScaleFactorName("VA_SF"); vaPhaseBDataPoint.setSunSpecDataType("int16"); vaPhaseBDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(vaPhaseBDataPoint.name(), vaPhaseBDataPoint); SunSpecDataPoint vaPhaseCDataPoint; vaPhaseCDataPoint.setName("VAphC"); vaPhaseCDataPoint.setLabel("VA phase C"); vaPhaseCDataPoint.setUnits("VA"); vaPhaseCDataPoint.setSize(1); vaPhaseCDataPoint.setAddressOffset(26); vaPhaseCDataPoint.setBlockOffset(24); vaPhaseCDataPoint.setScaleFactorName("VA_SF"); vaPhaseCDataPoint.setSunSpecDataType("int16"); vaPhaseCDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(vaPhaseCDataPoint.name(), vaPhaseCDataPoint); SunSpecDataPoint vA_SFDataPoint; vA_SFDataPoint.setName("VA_SF"); vA_SFDataPoint.setDescription("Apparent Power scale factor"); vA_SFDataPoint.setSize(1); vA_SFDataPoint.setAddressOffset(27); vA_SFDataPoint.setBlockOffset(25); vA_SFDataPoint.setSunSpecDataType("sunssf"); vA_SFDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(vA_SFDataPoint.name(), vA_SFDataPoint); SunSpecDataPoint varDataPoint; varDataPoint.setName("VAR"); varDataPoint.setLabel("VAR"); varDataPoint.setDescription("Reactive Power"); varDataPoint.setUnits("var"); varDataPoint.setSize(1); varDataPoint.setAddressOffset(28); varDataPoint.setBlockOffset(26); varDataPoint.setScaleFactorName("VAR_SF"); varDataPoint.setSunSpecDataType("int16"); varDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(varDataPoint.name(), varDataPoint); SunSpecDataPoint varPhaseADataPoint; varPhaseADataPoint.setName("VARphA"); varPhaseADataPoint.setLabel("VAR phase A"); varPhaseADataPoint.setUnits("var"); varPhaseADataPoint.setSize(1); varPhaseADataPoint.setAddressOffset(29); varPhaseADataPoint.setBlockOffset(27); varPhaseADataPoint.setScaleFactorName("VAR_SF"); varPhaseADataPoint.setSunSpecDataType("int16"); varPhaseADataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(varPhaseADataPoint.name(), varPhaseADataPoint); SunSpecDataPoint varPhaseBDataPoint; varPhaseBDataPoint.setName("VARphB"); varPhaseBDataPoint.setLabel("VAR phase B"); varPhaseBDataPoint.setUnits("var"); varPhaseBDataPoint.setSize(1); varPhaseBDataPoint.setAddressOffset(30); varPhaseBDataPoint.setBlockOffset(28); varPhaseBDataPoint.setScaleFactorName("VAR_SF"); varPhaseBDataPoint.setSunSpecDataType("int16"); varPhaseBDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(varPhaseBDataPoint.name(), varPhaseBDataPoint); SunSpecDataPoint varPhaseCDataPoint; varPhaseCDataPoint.setName("VARphC"); varPhaseCDataPoint.setLabel("VAR phase C"); varPhaseCDataPoint.setUnits("var"); varPhaseCDataPoint.setSize(1); varPhaseCDataPoint.setAddressOffset(31); varPhaseCDataPoint.setBlockOffset(29); varPhaseCDataPoint.setScaleFactorName("VAR_SF"); varPhaseCDataPoint.setSunSpecDataType("int16"); varPhaseCDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(varPhaseCDataPoint.name(), varPhaseCDataPoint); SunSpecDataPoint vAR_SFDataPoint; vAR_SFDataPoint.setName("VAR_SF"); vAR_SFDataPoint.setDescription("Reactive Power scale factor"); vAR_SFDataPoint.setSize(1); vAR_SFDataPoint.setAddressOffset(32); vAR_SFDataPoint.setBlockOffset(30); vAR_SFDataPoint.setSunSpecDataType("sunssf"); vAR_SFDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(vAR_SFDataPoint.name(), vAR_SFDataPoint); SunSpecDataPoint pfDataPoint; pfDataPoint.setName("PF"); pfDataPoint.setLabel("PF"); pfDataPoint.setDescription("Power Factor"); pfDataPoint.setUnits("Pct"); pfDataPoint.setSize(1); pfDataPoint.setAddressOffset(33); pfDataPoint.setBlockOffset(31); pfDataPoint.setScaleFactorName("PF_SF"); pfDataPoint.setSunSpecDataType("int16"); pfDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(pfDataPoint.name(), pfDataPoint); SunSpecDataPoint pfPhaseADataPoint; pfPhaseADataPoint.setName("PFphA"); pfPhaseADataPoint.setLabel("PF phase A"); pfPhaseADataPoint.setUnits("Pct"); pfPhaseADataPoint.setSize(1); pfPhaseADataPoint.setAddressOffset(34); pfPhaseADataPoint.setBlockOffset(32); pfPhaseADataPoint.setScaleFactorName("PF_SF"); pfPhaseADataPoint.setSunSpecDataType("int16"); pfPhaseADataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(pfPhaseADataPoint.name(), pfPhaseADataPoint); SunSpecDataPoint pfPhaseBDataPoint; pfPhaseBDataPoint.setName("PFphB"); pfPhaseBDataPoint.setLabel("PF phase B"); pfPhaseBDataPoint.setUnits("Pct"); pfPhaseBDataPoint.setSize(1); pfPhaseBDataPoint.setAddressOffset(35); pfPhaseBDataPoint.setBlockOffset(33); pfPhaseBDataPoint.setScaleFactorName("PF_SF"); pfPhaseBDataPoint.setSunSpecDataType("int16"); pfPhaseBDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(pfPhaseBDataPoint.name(), pfPhaseBDataPoint); SunSpecDataPoint pfPhaseCDataPoint; pfPhaseCDataPoint.setName("PFphC"); pfPhaseCDataPoint.setLabel("PF phase C"); pfPhaseCDataPoint.setUnits("Pct"); pfPhaseCDataPoint.setSize(1); pfPhaseCDataPoint.setAddressOffset(36); pfPhaseCDataPoint.setBlockOffset(34); pfPhaseCDataPoint.setScaleFactorName("PF_SF"); pfPhaseCDataPoint.setSunSpecDataType("int16"); pfPhaseCDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(pfPhaseCDataPoint.name(), pfPhaseCDataPoint); SunSpecDataPoint pF_SFDataPoint; pF_SFDataPoint.setName("PF_SF"); pF_SFDataPoint.setDescription("Power Factor scale factor"); pF_SFDataPoint.setSize(1); pF_SFDataPoint.setAddressOffset(37); pF_SFDataPoint.setBlockOffset(35); pF_SFDataPoint.setSunSpecDataType("sunssf"); pF_SFDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(pF_SFDataPoint.name(), pF_SFDataPoint); SunSpecDataPoint totalWattHoursExportedDataPoint; totalWattHoursExportedDataPoint.setName("TotWhExp"); totalWattHoursExportedDataPoint.setLabel("Total Watt-hours Exported"); totalWattHoursExportedDataPoint.setDescription("Total Real Energy Exported"); totalWattHoursExportedDataPoint.setUnits("Wh"); totalWattHoursExportedDataPoint.setMandatory(true); totalWattHoursExportedDataPoint.setSize(2); totalWattHoursExportedDataPoint.setAddressOffset(38); totalWattHoursExportedDataPoint.setBlockOffset(36); totalWattHoursExportedDataPoint.setScaleFactorName("TotWh_SF"); totalWattHoursExportedDataPoint.setSunSpecDataType("acc32"); totalWattHoursExportedDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(totalWattHoursExportedDataPoint.name(), totalWattHoursExportedDataPoint); SunSpecDataPoint totalWattHoursExportedPhaseADataPoint; totalWattHoursExportedPhaseADataPoint.setName("TotWhExpPhA"); totalWattHoursExportedPhaseADataPoint.setLabel("Total Watt-hours Exported phase A"); totalWattHoursExportedPhaseADataPoint.setUnits("Wh"); totalWattHoursExportedPhaseADataPoint.setSize(2); totalWattHoursExportedPhaseADataPoint.setAddressOffset(40); totalWattHoursExportedPhaseADataPoint.setBlockOffset(38); totalWattHoursExportedPhaseADataPoint.setScaleFactorName("TotWh_SF"); totalWattHoursExportedPhaseADataPoint.setSunSpecDataType("acc32"); totalWattHoursExportedPhaseADataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(totalWattHoursExportedPhaseADataPoint.name(), totalWattHoursExportedPhaseADataPoint); SunSpecDataPoint totalWattHoursExportedPhaseBDataPoint; totalWattHoursExportedPhaseBDataPoint.setName("TotWhExpPhB"); totalWattHoursExportedPhaseBDataPoint.setLabel("Total Watt-hours Exported phase B"); totalWattHoursExportedPhaseBDataPoint.setUnits("Wh"); totalWattHoursExportedPhaseBDataPoint.setSize(2); totalWattHoursExportedPhaseBDataPoint.setAddressOffset(42); totalWattHoursExportedPhaseBDataPoint.setBlockOffset(40); totalWattHoursExportedPhaseBDataPoint.setScaleFactorName("TotWh_SF"); totalWattHoursExportedPhaseBDataPoint.setSunSpecDataType("acc32"); totalWattHoursExportedPhaseBDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(totalWattHoursExportedPhaseBDataPoint.name(), totalWattHoursExportedPhaseBDataPoint); SunSpecDataPoint totalWattHoursExportedPhaseCDataPoint; totalWattHoursExportedPhaseCDataPoint.setName("TotWhExpPhC"); totalWattHoursExportedPhaseCDataPoint.setLabel("Total Watt-hours Exported phase C"); totalWattHoursExportedPhaseCDataPoint.setUnits("Wh"); totalWattHoursExportedPhaseCDataPoint.setSize(2); totalWattHoursExportedPhaseCDataPoint.setAddressOffset(44); totalWattHoursExportedPhaseCDataPoint.setBlockOffset(42); totalWattHoursExportedPhaseCDataPoint.setScaleFactorName("TotWh_SF"); totalWattHoursExportedPhaseCDataPoint.setSunSpecDataType("acc32"); totalWattHoursExportedPhaseCDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(totalWattHoursExportedPhaseCDataPoint.name(), totalWattHoursExportedPhaseCDataPoint); SunSpecDataPoint totalWattHoursImportedDataPoint; totalWattHoursImportedDataPoint.setName("TotWhImp"); totalWattHoursImportedDataPoint.setLabel("Total Watt-hours Imported"); totalWattHoursImportedDataPoint.setDescription("Total Real Energy Imported"); totalWattHoursImportedDataPoint.setUnits("Wh"); totalWattHoursImportedDataPoint.setMandatory(true); totalWattHoursImportedDataPoint.setSize(2); totalWattHoursImportedDataPoint.setAddressOffset(46); totalWattHoursImportedDataPoint.setBlockOffset(44); totalWattHoursImportedDataPoint.setScaleFactorName("TotWh_SF"); totalWattHoursImportedDataPoint.setSunSpecDataType("acc32"); totalWattHoursImportedDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(totalWattHoursImportedDataPoint.name(), totalWattHoursImportedDataPoint); SunSpecDataPoint totalWattHoursImportedPhaseADataPoint; totalWattHoursImportedPhaseADataPoint.setName("TotWhImpPhA"); totalWattHoursImportedPhaseADataPoint.setLabel("Total Watt-hours Imported phase A"); totalWattHoursImportedPhaseADataPoint.setUnits("Wh"); totalWattHoursImportedPhaseADataPoint.setSize(2); totalWattHoursImportedPhaseADataPoint.setAddressOffset(48); totalWattHoursImportedPhaseADataPoint.setBlockOffset(46); totalWattHoursImportedPhaseADataPoint.setScaleFactorName("TotWh_SF"); totalWattHoursImportedPhaseADataPoint.setSunSpecDataType("acc32"); totalWattHoursImportedPhaseADataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(totalWattHoursImportedPhaseADataPoint.name(), totalWattHoursImportedPhaseADataPoint); SunSpecDataPoint totalWattHoursImportedPhaseBDataPoint; totalWattHoursImportedPhaseBDataPoint.setName("TotWhImpPhB"); totalWattHoursImportedPhaseBDataPoint.setLabel("Total Watt-hours Imported phase B"); totalWattHoursImportedPhaseBDataPoint.setUnits("Wh"); totalWattHoursImportedPhaseBDataPoint.setSize(2); totalWattHoursImportedPhaseBDataPoint.setAddressOffset(50); totalWattHoursImportedPhaseBDataPoint.setBlockOffset(48); totalWattHoursImportedPhaseBDataPoint.setScaleFactorName("TotWh_SF"); totalWattHoursImportedPhaseBDataPoint.setSunSpecDataType("acc32"); totalWattHoursImportedPhaseBDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(totalWattHoursImportedPhaseBDataPoint.name(), totalWattHoursImportedPhaseBDataPoint); SunSpecDataPoint totalWattHoursImportedPhaseCDataPoint; totalWattHoursImportedPhaseCDataPoint.setName("TotWhImpPhC"); totalWattHoursImportedPhaseCDataPoint.setLabel("Total Watt-hours Imported phase C"); totalWattHoursImportedPhaseCDataPoint.setUnits("Wh"); totalWattHoursImportedPhaseCDataPoint.setSize(2); totalWattHoursImportedPhaseCDataPoint.setAddressOffset(52); totalWattHoursImportedPhaseCDataPoint.setBlockOffset(50); totalWattHoursImportedPhaseCDataPoint.setScaleFactorName("TotWh_SF"); totalWattHoursImportedPhaseCDataPoint.setSunSpecDataType("acc32"); totalWattHoursImportedPhaseCDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(totalWattHoursImportedPhaseCDataPoint.name(), totalWattHoursImportedPhaseCDataPoint); SunSpecDataPoint totWh_SFDataPoint; totWh_SFDataPoint.setName("TotWh_SF"); totWh_SFDataPoint.setDescription("Real Energy scale factor"); totWh_SFDataPoint.setMandatory(true); totWh_SFDataPoint.setSize(1); totWh_SFDataPoint.setAddressOffset(54); totWh_SFDataPoint.setBlockOffset(52); totWh_SFDataPoint.setSunSpecDataType("sunssf"); totWh_SFDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(totWh_SFDataPoint.name(), totWh_SFDataPoint); SunSpecDataPoint totalVaHoursExportedDataPoint; totalVaHoursExportedDataPoint.setName("TotVAhExp"); totalVaHoursExportedDataPoint.setLabel("Total VA-hours Exported"); totalVaHoursExportedDataPoint.setDescription("Total Apparent Energy Exported"); totalVaHoursExportedDataPoint.setUnits("VAh"); totalVaHoursExportedDataPoint.setSize(2); totalVaHoursExportedDataPoint.setAddressOffset(55); totalVaHoursExportedDataPoint.setBlockOffset(53); totalVaHoursExportedDataPoint.setScaleFactorName("TotVAh_SF"); totalVaHoursExportedDataPoint.setSunSpecDataType("acc32"); totalVaHoursExportedDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(totalVaHoursExportedDataPoint.name(), totalVaHoursExportedDataPoint); SunSpecDataPoint totalVaHoursExportedPhaseADataPoint; totalVaHoursExportedPhaseADataPoint.setName("TotVAhExpPhA"); totalVaHoursExportedPhaseADataPoint.setLabel("Total VA-hours Exported phase A"); totalVaHoursExportedPhaseADataPoint.setUnits("VAh"); totalVaHoursExportedPhaseADataPoint.setSize(2); totalVaHoursExportedPhaseADataPoint.setAddressOffset(57); totalVaHoursExportedPhaseADataPoint.setBlockOffset(55); totalVaHoursExportedPhaseADataPoint.setScaleFactorName("TotVAh_SF"); totalVaHoursExportedPhaseADataPoint.setSunSpecDataType("acc32"); totalVaHoursExportedPhaseADataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(totalVaHoursExportedPhaseADataPoint.name(), totalVaHoursExportedPhaseADataPoint); SunSpecDataPoint totalVaHoursExportedPhaseBDataPoint; totalVaHoursExportedPhaseBDataPoint.setName("TotVAhExpPhB"); totalVaHoursExportedPhaseBDataPoint.setLabel("Total VA-hours Exported phase B"); totalVaHoursExportedPhaseBDataPoint.setUnits("VAh"); totalVaHoursExportedPhaseBDataPoint.setSize(2); totalVaHoursExportedPhaseBDataPoint.setAddressOffset(59); totalVaHoursExportedPhaseBDataPoint.setBlockOffset(57); totalVaHoursExportedPhaseBDataPoint.setScaleFactorName("TotVAh_SF"); totalVaHoursExportedPhaseBDataPoint.setSunSpecDataType("acc32"); totalVaHoursExportedPhaseBDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(totalVaHoursExportedPhaseBDataPoint.name(), totalVaHoursExportedPhaseBDataPoint); SunSpecDataPoint totalVaHoursExportedPhaseCDataPoint; totalVaHoursExportedPhaseCDataPoint.setName("TotVAhExpPhC"); totalVaHoursExportedPhaseCDataPoint.setLabel("Total VA-hours Exported phase C"); totalVaHoursExportedPhaseCDataPoint.setUnits("VAh"); totalVaHoursExportedPhaseCDataPoint.setSize(2); totalVaHoursExportedPhaseCDataPoint.setAddressOffset(61); totalVaHoursExportedPhaseCDataPoint.setBlockOffset(59); totalVaHoursExportedPhaseCDataPoint.setScaleFactorName("TotVAh_SF"); totalVaHoursExportedPhaseCDataPoint.setSunSpecDataType("acc32"); totalVaHoursExportedPhaseCDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(totalVaHoursExportedPhaseCDataPoint.name(), totalVaHoursExportedPhaseCDataPoint); SunSpecDataPoint totalVaHoursImportedDataPoint; totalVaHoursImportedDataPoint.setName("TotVAhImp"); totalVaHoursImportedDataPoint.setLabel("Total VA-hours Imported"); totalVaHoursImportedDataPoint.setDescription("Total Apparent Energy Imported"); totalVaHoursImportedDataPoint.setUnits("VAh"); totalVaHoursImportedDataPoint.setSize(2); totalVaHoursImportedDataPoint.setAddressOffset(63); totalVaHoursImportedDataPoint.setBlockOffset(61); totalVaHoursImportedDataPoint.setScaleFactorName("TotVAh_SF"); totalVaHoursImportedDataPoint.setSunSpecDataType("acc32"); totalVaHoursImportedDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(totalVaHoursImportedDataPoint.name(), totalVaHoursImportedDataPoint); SunSpecDataPoint totalVaHoursImportedPhaseADataPoint; totalVaHoursImportedPhaseADataPoint.setName("TotVAhImpPhA"); totalVaHoursImportedPhaseADataPoint.setLabel("Total VA-hours Imported phase A"); totalVaHoursImportedPhaseADataPoint.setUnits("VAh"); totalVaHoursImportedPhaseADataPoint.setSize(2); totalVaHoursImportedPhaseADataPoint.setAddressOffset(65); totalVaHoursImportedPhaseADataPoint.setBlockOffset(63); totalVaHoursImportedPhaseADataPoint.setScaleFactorName("TotVAh_SF"); totalVaHoursImportedPhaseADataPoint.setSunSpecDataType("acc32"); totalVaHoursImportedPhaseADataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(totalVaHoursImportedPhaseADataPoint.name(), totalVaHoursImportedPhaseADataPoint); SunSpecDataPoint totalVaHoursImportedPhaseBDataPoint; totalVaHoursImportedPhaseBDataPoint.setName("TotVAhImpPhB"); totalVaHoursImportedPhaseBDataPoint.setLabel("Total VA-hours Imported phase B"); totalVaHoursImportedPhaseBDataPoint.setUnits("VAh"); totalVaHoursImportedPhaseBDataPoint.setSize(2); totalVaHoursImportedPhaseBDataPoint.setAddressOffset(67); totalVaHoursImportedPhaseBDataPoint.setBlockOffset(65); totalVaHoursImportedPhaseBDataPoint.setScaleFactorName("TotVAh_SF"); totalVaHoursImportedPhaseBDataPoint.setSunSpecDataType("acc32"); totalVaHoursImportedPhaseBDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(totalVaHoursImportedPhaseBDataPoint.name(), totalVaHoursImportedPhaseBDataPoint); SunSpecDataPoint totalVaHoursImportedPhaseCDataPoint; totalVaHoursImportedPhaseCDataPoint.setName("TotVAhImpPhC"); totalVaHoursImportedPhaseCDataPoint.setLabel("Total VA-hours Imported phase C"); totalVaHoursImportedPhaseCDataPoint.setUnits("VAh"); totalVaHoursImportedPhaseCDataPoint.setSize(2); totalVaHoursImportedPhaseCDataPoint.setAddressOffset(69); totalVaHoursImportedPhaseCDataPoint.setBlockOffset(67); totalVaHoursImportedPhaseCDataPoint.setScaleFactorName("TotVAh_SF"); totalVaHoursImportedPhaseCDataPoint.setSunSpecDataType("acc32"); totalVaHoursImportedPhaseCDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(totalVaHoursImportedPhaseCDataPoint.name(), totalVaHoursImportedPhaseCDataPoint); SunSpecDataPoint totVAh_SFDataPoint; totVAh_SFDataPoint.setName("TotVAh_SF"); totVAh_SFDataPoint.setDescription("Apparent Energy scale factor"); totVAh_SFDataPoint.setSize(1); totVAh_SFDataPoint.setAddressOffset(71); totVAh_SFDataPoint.setBlockOffset(69); totVAh_SFDataPoint.setSunSpecDataType("sunssf"); totVAh_SFDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(totVAh_SFDataPoint.name(), totVAh_SFDataPoint); SunSpecDataPoint totalVarHoursImportedQ1DataPoint; totalVarHoursImportedQ1DataPoint.setName("TotVArhImpQ1"); totalVarHoursImportedQ1DataPoint.setLabel("Total VAR-hours Imported Q1"); totalVarHoursImportedQ1DataPoint.setDescription("Total Reactive Energy Imported Quadrant 1"); totalVarHoursImportedQ1DataPoint.setUnits("varh"); totalVarHoursImportedQ1DataPoint.setSize(2); totalVarHoursImportedQ1DataPoint.setAddressOffset(72); totalVarHoursImportedQ1DataPoint.setBlockOffset(70); totalVarHoursImportedQ1DataPoint.setScaleFactorName("TotVArh_SF"); totalVarHoursImportedQ1DataPoint.setSunSpecDataType("acc32"); totalVarHoursImportedQ1DataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(totalVarHoursImportedQ1DataPoint.name(), totalVarHoursImportedQ1DataPoint); SunSpecDataPoint totalVArHoursImportedQ1PhaseADataPoint; totalVArHoursImportedQ1PhaseADataPoint.setName("TotVArhImpQ1PhA"); totalVArHoursImportedQ1PhaseADataPoint.setLabel("Total VAr-hours Imported Q1 phase A"); totalVArHoursImportedQ1PhaseADataPoint.setUnits("varh"); totalVArHoursImportedQ1PhaseADataPoint.setSize(2); totalVArHoursImportedQ1PhaseADataPoint.setAddressOffset(74); totalVArHoursImportedQ1PhaseADataPoint.setBlockOffset(72); totalVArHoursImportedQ1PhaseADataPoint.setScaleFactorName("TotVArh_SF"); totalVArHoursImportedQ1PhaseADataPoint.setSunSpecDataType("acc32"); totalVArHoursImportedQ1PhaseADataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(totalVArHoursImportedQ1PhaseADataPoint.name(), totalVArHoursImportedQ1PhaseADataPoint); SunSpecDataPoint totalVArHoursImportedQ1PhaseBDataPoint; totalVArHoursImportedQ1PhaseBDataPoint.setName("TotVArhImpQ1PhB"); totalVArHoursImportedQ1PhaseBDataPoint.setLabel("Total VAr-hours Imported Q1 phase B"); totalVArHoursImportedQ1PhaseBDataPoint.setUnits("varh"); totalVArHoursImportedQ1PhaseBDataPoint.setSize(2); totalVArHoursImportedQ1PhaseBDataPoint.setAddressOffset(76); totalVArHoursImportedQ1PhaseBDataPoint.setBlockOffset(74); totalVArHoursImportedQ1PhaseBDataPoint.setScaleFactorName("TotVArh_SF"); totalVArHoursImportedQ1PhaseBDataPoint.setSunSpecDataType("acc32"); totalVArHoursImportedQ1PhaseBDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(totalVArHoursImportedQ1PhaseBDataPoint.name(), totalVArHoursImportedQ1PhaseBDataPoint); SunSpecDataPoint totalVArHoursImportedQ1PhaseCDataPoint; totalVArHoursImportedQ1PhaseCDataPoint.setName("TotVArhImpQ1PhC"); totalVArHoursImportedQ1PhaseCDataPoint.setLabel("Total VAr-hours Imported Q1 phase C"); totalVArHoursImportedQ1PhaseCDataPoint.setUnits("varh"); totalVArHoursImportedQ1PhaseCDataPoint.setSize(2); totalVArHoursImportedQ1PhaseCDataPoint.setAddressOffset(78); totalVArHoursImportedQ1PhaseCDataPoint.setBlockOffset(76); totalVArHoursImportedQ1PhaseCDataPoint.setScaleFactorName("TotVArh_SF"); totalVArHoursImportedQ1PhaseCDataPoint.setSunSpecDataType("acc32"); totalVArHoursImportedQ1PhaseCDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(totalVArHoursImportedQ1PhaseCDataPoint.name(), totalVArHoursImportedQ1PhaseCDataPoint); SunSpecDataPoint totalVArHoursImportedQ2DataPoint; totalVArHoursImportedQ2DataPoint.setName("TotVArhImpQ2"); totalVArHoursImportedQ2DataPoint.setLabel("Total VAr-hours Imported Q2"); totalVArHoursImportedQ2DataPoint.setDescription("Total Reactive Power Imported Quadrant 2"); totalVArHoursImportedQ2DataPoint.setUnits("varh"); totalVArHoursImportedQ2DataPoint.setSize(2); totalVArHoursImportedQ2DataPoint.setAddressOffset(80); totalVArHoursImportedQ2DataPoint.setBlockOffset(78); totalVArHoursImportedQ2DataPoint.setScaleFactorName("TotVArh_SF"); totalVArHoursImportedQ2DataPoint.setSunSpecDataType("acc32"); totalVArHoursImportedQ2DataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(totalVArHoursImportedQ2DataPoint.name(), totalVArHoursImportedQ2DataPoint); SunSpecDataPoint totalVArHoursImportedQ2PhaseADataPoint; totalVArHoursImportedQ2PhaseADataPoint.setName("TotVArhImpQ2PhA"); totalVArHoursImportedQ2PhaseADataPoint.setLabel("Total VAr-hours Imported Q2 phase A"); totalVArHoursImportedQ2PhaseADataPoint.setUnits("varh"); totalVArHoursImportedQ2PhaseADataPoint.setSize(2); totalVArHoursImportedQ2PhaseADataPoint.setAddressOffset(82); totalVArHoursImportedQ2PhaseADataPoint.setBlockOffset(80); totalVArHoursImportedQ2PhaseADataPoint.setScaleFactorName("TotVArh_SF"); totalVArHoursImportedQ2PhaseADataPoint.setSunSpecDataType("acc32"); totalVArHoursImportedQ2PhaseADataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(totalVArHoursImportedQ2PhaseADataPoint.name(), totalVArHoursImportedQ2PhaseADataPoint); SunSpecDataPoint totalVArHoursImportedQ2PhaseBDataPoint; totalVArHoursImportedQ2PhaseBDataPoint.setName("TotVArhImpQ2PhB"); totalVArHoursImportedQ2PhaseBDataPoint.setLabel("Total VAr-hours Imported Q2 phase B"); totalVArHoursImportedQ2PhaseBDataPoint.setUnits("varh"); totalVArHoursImportedQ2PhaseBDataPoint.setSize(2); totalVArHoursImportedQ2PhaseBDataPoint.setAddressOffset(84); totalVArHoursImportedQ2PhaseBDataPoint.setBlockOffset(82); totalVArHoursImportedQ2PhaseBDataPoint.setScaleFactorName("TotVArh_SF"); totalVArHoursImportedQ2PhaseBDataPoint.setSunSpecDataType("acc32"); totalVArHoursImportedQ2PhaseBDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(totalVArHoursImportedQ2PhaseBDataPoint.name(), totalVArHoursImportedQ2PhaseBDataPoint); SunSpecDataPoint totalVArHoursImportedQ2PhaseCDataPoint; totalVArHoursImportedQ2PhaseCDataPoint.setName("TotVArhImpQ2PhC"); totalVArHoursImportedQ2PhaseCDataPoint.setLabel("Total VAr-hours Imported Q2 phase C"); totalVArHoursImportedQ2PhaseCDataPoint.setUnits("varh"); totalVArHoursImportedQ2PhaseCDataPoint.setSize(2); totalVArHoursImportedQ2PhaseCDataPoint.setAddressOffset(86); totalVArHoursImportedQ2PhaseCDataPoint.setBlockOffset(84); totalVArHoursImportedQ2PhaseCDataPoint.setScaleFactorName("TotVArh_SF"); totalVArHoursImportedQ2PhaseCDataPoint.setSunSpecDataType("acc32"); totalVArHoursImportedQ2PhaseCDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(totalVArHoursImportedQ2PhaseCDataPoint.name(), totalVArHoursImportedQ2PhaseCDataPoint); SunSpecDataPoint totalVArHoursExportedQ3DataPoint; totalVArHoursExportedQ3DataPoint.setName("TotVArhExpQ3"); totalVArHoursExportedQ3DataPoint.setLabel("Total VAr-hours Exported Q3"); totalVArHoursExportedQ3DataPoint.setDescription("Total Reactive Power Exported Quadrant 3"); totalVArHoursExportedQ3DataPoint.setUnits("varh"); totalVArHoursExportedQ3DataPoint.setSize(2); totalVArHoursExportedQ3DataPoint.setAddressOffset(88); totalVArHoursExportedQ3DataPoint.setBlockOffset(86); totalVArHoursExportedQ3DataPoint.setScaleFactorName("TotVArh_SF"); totalVArHoursExportedQ3DataPoint.setSunSpecDataType("acc32"); totalVArHoursExportedQ3DataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(totalVArHoursExportedQ3DataPoint.name(), totalVArHoursExportedQ3DataPoint); SunSpecDataPoint totalVArHoursExportedQ3PhaseADataPoint; totalVArHoursExportedQ3PhaseADataPoint.setName("TotVArhExpQ3PhA"); totalVArHoursExportedQ3PhaseADataPoint.setLabel("Total VAr-hours Exported Q3 phase A"); totalVArHoursExportedQ3PhaseADataPoint.setUnits("varh"); totalVArHoursExportedQ3PhaseADataPoint.setSize(2); totalVArHoursExportedQ3PhaseADataPoint.setAddressOffset(90); totalVArHoursExportedQ3PhaseADataPoint.setBlockOffset(88); totalVArHoursExportedQ3PhaseADataPoint.setScaleFactorName("TotVArh_SF"); totalVArHoursExportedQ3PhaseADataPoint.setSunSpecDataType("acc32"); totalVArHoursExportedQ3PhaseADataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(totalVArHoursExportedQ3PhaseADataPoint.name(), totalVArHoursExportedQ3PhaseADataPoint); SunSpecDataPoint totalVArHoursExportedQ3PhaseBDataPoint; totalVArHoursExportedQ3PhaseBDataPoint.setName("TotVArhExpQ3PhB"); totalVArHoursExportedQ3PhaseBDataPoint.setLabel("Total VAr-hours Exported Q3 phase B"); totalVArHoursExportedQ3PhaseBDataPoint.setUnits("varh"); totalVArHoursExportedQ3PhaseBDataPoint.setSize(2); totalVArHoursExportedQ3PhaseBDataPoint.setAddressOffset(92); totalVArHoursExportedQ3PhaseBDataPoint.setBlockOffset(90); totalVArHoursExportedQ3PhaseBDataPoint.setScaleFactorName("TotVArh_SF"); totalVArHoursExportedQ3PhaseBDataPoint.setSunSpecDataType("acc32"); totalVArHoursExportedQ3PhaseBDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(totalVArHoursExportedQ3PhaseBDataPoint.name(), totalVArHoursExportedQ3PhaseBDataPoint); SunSpecDataPoint totalVArHoursExportedQ3PhaseCDataPoint; totalVArHoursExportedQ3PhaseCDataPoint.setName("TotVArhExpQ3PhC"); totalVArHoursExportedQ3PhaseCDataPoint.setLabel("Total VAr-hours Exported Q3 phase C"); totalVArHoursExportedQ3PhaseCDataPoint.setUnits("varh"); totalVArHoursExportedQ3PhaseCDataPoint.setSize(2); totalVArHoursExportedQ3PhaseCDataPoint.setAddressOffset(94); totalVArHoursExportedQ3PhaseCDataPoint.setBlockOffset(92); totalVArHoursExportedQ3PhaseCDataPoint.setScaleFactorName("TotVArh_SF"); totalVArHoursExportedQ3PhaseCDataPoint.setSunSpecDataType("acc32"); totalVArHoursExportedQ3PhaseCDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(totalVArHoursExportedQ3PhaseCDataPoint.name(), totalVArHoursExportedQ3PhaseCDataPoint); SunSpecDataPoint totalVArHoursExportedQ4DataPoint; totalVArHoursExportedQ4DataPoint.setName("TotVArhExpQ4"); totalVArHoursExportedQ4DataPoint.setLabel("Total VAr-hours Exported Q4"); totalVArHoursExportedQ4DataPoint.setDescription("Total Reactive Power Exported Quadrant 4"); totalVArHoursExportedQ4DataPoint.setUnits("varh"); totalVArHoursExportedQ4DataPoint.setSize(2); totalVArHoursExportedQ4DataPoint.setAddressOffset(96); totalVArHoursExportedQ4DataPoint.setBlockOffset(94); totalVArHoursExportedQ4DataPoint.setScaleFactorName("TotVArh_SF"); totalVArHoursExportedQ4DataPoint.setSunSpecDataType("acc32"); totalVArHoursExportedQ4DataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(totalVArHoursExportedQ4DataPoint.name(), totalVArHoursExportedQ4DataPoint); SunSpecDataPoint totalVArHoursExportedQ4ImportedPhaseADataPoint; totalVArHoursExportedQ4ImportedPhaseADataPoint.setName("TotVArhExpQ4PhA"); totalVArHoursExportedQ4ImportedPhaseADataPoint.setLabel("Total VAr-hours Exported Q4 Imported phase A"); totalVArHoursExportedQ4ImportedPhaseADataPoint.setUnits("varh"); totalVArHoursExportedQ4ImportedPhaseADataPoint.setSize(2); totalVArHoursExportedQ4ImportedPhaseADataPoint.setAddressOffset(98); totalVArHoursExportedQ4ImportedPhaseADataPoint.setBlockOffset(96); totalVArHoursExportedQ4ImportedPhaseADataPoint.setScaleFactorName("TotVArh_SF"); totalVArHoursExportedQ4ImportedPhaseADataPoint.setSunSpecDataType("acc32"); totalVArHoursExportedQ4ImportedPhaseADataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(totalVArHoursExportedQ4ImportedPhaseADataPoint.name(), totalVArHoursExportedQ4ImportedPhaseADataPoint); SunSpecDataPoint totalVArHoursExportedQ4ImportedPhaseBDataPoint; totalVArHoursExportedQ4ImportedPhaseBDataPoint.setName("TotVArhExpQ4PhB"); totalVArHoursExportedQ4ImportedPhaseBDataPoint.setLabel("Total VAr-hours Exported Q4 Imported phase B"); totalVArHoursExportedQ4ImportedPhaseBDataPoint.setUnits("varh"); totalVArHoursExportedQ4ImportedPhaseBDataPoint.setSize(2); totalVArHoursExportedQ4ImportedPhaseBDataPoint.setAddressOffset(100); totalVArHoursExportedQ4ImportedPhaseBDataPoint.setBlockOffset(98); totalVArHoursExportedQ4ImportedPhaseBDataPoint.setScaleFactorName("TotVArh_SF"); totalVArHoursExportedQ4ImportedPhaseBDataPoint.setSunSpecDataType("acc32"); totalVArHoursExportedQ4ImportedPhaseBDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(totalVArHoursExportedQ4ImportedPhaseBDataPoint.name(), totalVArHoursExportedQ4ImportedPhaseBDataPoint); SunSpecDataPoint totalVArHoursExportedQ4ImportedPhaseCDataPoint; totalVArHoursExportedQ4ImportedPhaseCDataPoint.setName("TotVArhExpQ4PhC"); totalVArHoursExportedQ4ImportedPhaseCDataPoint.setLabel("Total VAr-hours Exported Q4 Imported phase C"); totalVArHoursExportedQ4ImportedPhaseCDataPoint.setUnits("varh"); totalVArHoursExportedQ4ImportedPhaseCDataPoint.setSize(2); totalVArHoursExportedQ4ImportedPhaseCDataPoint.setAddressOffset(102); totalVArHoursExportedQ4ImportedPhaseCDataPoint.setBlockOffset(100); totalVArHoursExportedQ4ImportedPhaseCDataPoint.setScaleFactorName("TotVArh_SF"); totalVArHoursExportedQ4ImportedPhaseCDataPoint.setSunSpecDataType("acc32"); totalVArHoursExportedQ4ImportedPhaseCDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(totalVArHoursExportedQ4ImportedPhaseCDataPoint.name(), totalVArHoursExportedQ4ImportedPhaseCDataPoint); SunSpecDataPoint totVArh_SFDataPoint; totVArh_SFDataPoint.setName("TotVArh_SF"); totVArh_SFDataPoint.setDescription("Reactive Energy scale factor"); totVArh_SFDataPoint.setSize(1); totVArh_SFDataPoint.setAddressOffset(104); totVArh_SFDataPoint.setBlockOffset(102); totVArh_SFDataPoint.setSunSpecDataType("sunssf"); totVArh_SFDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(totVArh_SFDataPoint.name(), totVArh_SFDataPoint); SunSpecDataPoint eventsDataPoint; eventsDataPoint.setName("Evt"); eventsDataPoint.setLabel("Events"); eventsDataPoint.setDescription("Meter Event Flags"); eventsDataPoint.setMandatory(true); eventsDataPoint.setSize(2); eventsDataPoint.setAddressOffset(105); eventsDataPoint.setBlockOffset(103); eventsDataPoint.setSunSpecDataType("bitfield32"); eventsDataPoint.setByteOrder(m_byteOrder); m_dataPoints.insert(eventsDataPoint.name(), eventsDataPoint); } void SunSpecMeterThreePhaseModel::processBlockData() { // Scale factors if (m_dataPoints.value("A_SF").isValid()) m_a_SF = m_dataPoints.value("A_SF").toInt16(); if (m_dataPoints.value("V_SF").isValid()) m_v_SF = m_dataPoints.value("V_SF").toInt16(); if (m_dataPoints.value("Hz_SF").isValid()) m_hz_SF = m_dataPoints.value("Hz_SF").toInt16(); if (m_dataPoints.value("W_SF").isValid()) m_w_SF = m_dataPoints.value("W_SF").toInt16(); if (m_dataPoints.value("VA_SF").isValid()) m_vA_SF = m_dataPoints.value("VA_SF").toInt16(); if (m_dataPoints.value("VAR_SF").isValid()) m_vAR_SF = m_dataPoints.value("VAR_SF").toInt16(); if (m_dataPoints.value("PF_SF").isValid()) m_pF_SF = m_dataPoints.value("PF_SF").toInt16(); if (m_dataPoints.value("TotWh_SF").isValid()) m_totWh_SF = m_dataPoints.value("TotWh_SF").toInt16(); if (m_dataPoints.value("TotVAh_SF").isValid()) m_totVAh_SF = m_dataPoints.value("TotVAh_SF").toInt16(); if (m_dataPoints.value("TotVArh_SF").isValid()) m_totVArh_SF = m_dataPoints.value("TotVArh_SF").toInt16(); // Update properties according to the data point type if (m_dataPoints.value("A").isValid()) m_amps = m_dataPoints.value("A").toFloatWithSSF(m_a_SF); if (m_dataPoints.value("AphA").isValid()) m_ampsPhaseA = m_dataPoints.value("AphA").toFloatWithSSF(m_a_SF); if (m_dataPoints.value("AphB").isValid()) m_ampsPhaseB = m_dataPoints.value("AphB").toFloatWithSSF(m_a_SF); if (m_dataPoints.value("AphC").isValid()) m_ampsPhaseC = m_dataPoints.value("AphC").toFloatWithSSF(m_a_SF); if (m_dataPoints.value("A_SF").isValid()) m_a_SF = m_dataPoints.value("A_SF").toInt16(); if (m_dataPoints.value("PhV").isValid()) m_voltageLn = m_dataPoints.value("PhV").toFloatWithSSF(m_v_SF); if (m_dataPoints.value("PhVphA").isValid()) m_phaseVoltageAn = m_dataPoints.value("PhVphA").toFloatWithSSF(m_v_SF); if (m_dataPoints.value("PhVphB").isValid()) m_phaseVoltageBn = m_dataPoints.value("PhVphB").toFloatWithSSF(m_v_SF); if (m_dataPoints.value("PhVphC").isValid()) m_phaseVoltageCn = m_dataPoints.value("PhVphC").toFloatWithSSF(m_v_SF); if (m_dataPoints.value("PPV").isValid()) m_voltageLl = m_dataPoints.value("PPV").toFloatWithSSF(m_v_SF); if (m_dataPoints.value("PhVphAB").isValid()) m_phaseVoltageAb = m_dataPoints.value("PhVphAB").toFloatWithSSF(m_v_SF); if (m_dataPoints.value("PhVphBC").isValid()) m_phaseVoltageBc = m_dataPoints.value("PhVphBC").toFloatWithSSF(m_v_SF); if (m_dataPoints.value("PhVphCA").isValid()) m_phaseVoltageCa = m_dataPoints.value("PhVphCA").toFloatWithSSF(m_v_SF); if (m_dataPoints.value("V_SF").isValid()) m_v_SF = m_dataPoints.value("V_SF").toInt16(); if (m_dataPoints.value("Hz").isValid()) m_hz = m_dataPoints.value("Hz").toFloatWithSSF(m_hz_SF); if (m_dataPoints.value("Hz_SF").isValid()) m_hz_SF = m_dataPoints.value("Hz_SF").toInt16(); if (m_dataPoints.value("W").isValid()) m_watts = m_dataPoints.value("W").toFloatWithSSF(m_w_SF); if (m_dataPoints.value("WphA").isValid()) m_wattsPhaseA = m_dataPoints.value("WphA").toFloatWithSSF(m_w_SF); if (m_dataPoints.value("WphB").isValid()) m_wattsPhaseB = m_dataPoints.value("WphB").toFloatWithSSF(m_w_SF); if (m_dataPoints.value("WphC").isValid()) m_wattsPhaseC = m_dataPoints.value("WphC").toFloatWithSSF(m_w_SF); if (m_dataPoints.value("W_SF").isValid()) m_w_SF = m_dataPoints.value("W_SF").toInt16(); if (m_dataPoints.value("VA").isValid()) m_va = m_dataPoints.value("VA").toFloatWithSSF(m_vA_SF); if (m_dataPoints.value("VAphA").isValid()) m_vaPhaseA = m_dataPoints.value("VAphA").toFloatWithSSF(m_vA_SF); if (m_dataPoints.value("VAphB").isValid()) m_vaPhaseB = m_dataPoints.value("VAphB").toFloatWithSSF(m_vA_SF); if (m_dataPoints.value("VAphC").isValid()) m_vaPhaseC = m_dataPoints.value("VAphC").toFloatWithSSF(m_vA_SF); if (m_dataPoints.value("VA_SF").isValid()) m_vA_SF = m_dataPoints.value("VA_SF").toInt16(); if (m_dataPoints.value("VAR").isValid()) m_var = m_dataPoints.value("VAR").toFloatWithSSF(m_vAR_SF); if (m_dataPoints.value("VARphA").isValid()) m_varPhaseA = m_dataPoints.value("VARphA").toFloatWithSSF(m_vAR_SF); if (m_dataPoints.value("VARphB").isValid()) m_varPhaseB = m_dataPoints.value("VARphB").toFloatWithSSF(m_vAR_SF); if (m_dataPoints.value("VARphC").isValid()) m_varPhaseC = m_dataPoints.value("VARphC").toFloatWithSSF(m_vAR_SF); if (m_dataPoints.value("VAR_SF").isValid()) m_vAR_SF = m_dataPoints.value("VAR_SF").toInt16(); if (m_dataPoints.value("PF").isValid()) m_pf = m_dataPoints.value("PF").toFloatWithSSF(m_pF_SF); if (m_dataPoints.value("PFphA").isValid()) m_pfPhaseA = m_dataPoints.value("PFphA").toFloatWithSSF(m_pF_SF); if (m_dataPoints.value("PFphB").isValid()) m_pfPhaseB = m_dataPoints.value("PFphB").toFloatWithSSF(m_pF_SF); if (m_dataPoints.value("PFphC").isValid()) m_pfPhaseC = m_dataPoints.value("PFphC").toFloatWithSSF(m_pF_SF); if (m_dataPoints.value("PF_SF").isValid()) m_pF_SF = m_dataPoints.value("PF_SF").toInt16(); if (m_dataPoints.value("TotWhExp").isValid()) m_totalWattHoursExported = m_dataPoints.value("TotWhExp").toFloatWithSSF(m_totWh_SF); if (m_dataPoints.value("TotWhExpPhA").isValid()) m_totalWattHoursExportedPhaseA = m_dataPoints.value("TotWhExpPhA").toFloatWithSSF(m_totWh_SF); if (m_dataPoints.value("TotWhExpPhB").isValid()) m_totalWattHoursExportedPhaseB = m_dataPoints.value("TotWhExpPhB").toFloatWithSSF(m_totWh_SF); if (m_dataPoints.value("TotWhExpPhC").isValid()) m_totalWattHoursExportedPhaseC = m_dataPoints.value("TotWhExpPhC").toFloatWithSSF(m_totWh_SF); if (m_dataPoints.value("TotWhImp").isValid()) m_totalWattHoursImported = m_dataPoints.value("TotWhImp").toFloatWithSSF(m_totWh_SF); if (m_dataPoints.value("TotWhImpPhA").isValid()) m_totalWattHoursImportedPhaseA = m_dataPoints.value("TotWhImpPhA").toFloatWithSSF(m_totWh_SF); if (m_dataPoints.value("TotWhImpPhB").isValid()) m_totalWattHoursImportedPhaseB = m_dataPoints.value("TotWhImpPhB").toFloatWithSSF(m_totWh_SF); if (m_dataPoints.value("TotWhImpPhC").isValid()) m_totalWattHoursImportedPhaseC = m_dataPoints.value("TotWhImpPhC").toFloatWithSSF(m_totWh_SF); if (m_dataPoints.value("TotWh_SF").isValid()) m_totWh_SF = m_dataPoints.value("TotWh_SF").toInt16(); if (m_dataPoints.value("TotVAhExp").isValid()) m_totalVaHoursExported = m_dataPoints.value("TotVAhExp").toFloatWithSSF(m_totVAh_SF); if (m_dataPoints.value("TotVAhExpPhA").isValid()) m_totalVaHoursExportedPhaseA = m_dataPoints.value("TotVAhExpPhA").toFloatWithSSF(m_totVAh_SF); if (m_dataPoints.value("TotVAhExpPhB").isValid()) m_totalVaHoursExportedPhaseB = m_dataPoints.value("TotVAhExpPhB").toFloatWithSSF(m_totVAh_SF); if (m_dataPoints.value("TotVAhExpPhC").isValid()) m_totalVaHoursExportedPhaseC = m_dataPoints.value("TotVAhExpPhC").toFloatWithSSF(m_totVAh_SF); if (m_dataPoints.value("TotVAhImp").isValid()) m_totalVaHoursImported = m_dataPoints.value("TotVAhImp").toFloatWithSSF(m_totVAh_SF); if (m_dataPoints.value("TotVAhImpPhA").isValid()) m_totalVaHoursImportedPhaseA = m_dataPoints.value("TotVAhImpPhA").toFloatWithSSF(m_totVAh_SF); if (m_dataPoints.value("TotVAhImpPhB").isValid()) m_totalVaHoursImportedPhaseB = m_dataPoints.value("TotVAhImpPhB").toFloatWithSSF(m_totVAh_SF); if (m_dataPoints.value("TotVAhImpPhC").isValid()) m_totalVaHoursImportedPhaseC = m_dataPoints.value("TotVAhImpPhC").toFloatWithSSF(m_totVAh_SF); if (m_dataPoints.value("TotVAh_SF").isValid()) m_totVAh_SF = m_dataPoints.value("TotVAh_SF").toInt16(); if (m_dataPoints.value("TotVArhImpQ1").isValid()) m_totalVarHoursImportedQ1 = m_dataPoints.value("TotVArhImpQ1").toFloatWithSSF(m_totVArh_SF); if (m_dataPoints.value("TotVArhImpQ1PhA").isValid()) m_totalVArHoursImportedQ1PhaseA = m_dataPoints.value("TotVArhImpQ1PhA").toFloatWithSSF(m_totVArh_SF); if (m_dataPoints.value("TotVArhImpQ1PhB").isValid()) m_totalVArHoursImportedQ1PhaseB = m_dataPoints.value("TotVArhImpQ1PhB").toFloatWithSSF(m_totVArh_SF); if (m_dataPoints.value("TotVArhImpQ1PhC").isValid()) m_totalVArHoursImportedQ1PhaseC = m_dataPoints.value("TotVArhImpQ1PhC").toFloatWithSSF(m_totVArh_SF); if (m_dataPoints.value("TotVArhImpQ2").isValid()) m_totalVArHoursImportedQ2 = m_dataPoints.value("TotVArhImpQ2").toFloatWithSSF(m_totVArh_SF); if (m_dataPoints.value("TotVArhImpQ2PhA").isValid()) m_totalVArHoursImportedQ2PhaseA = m_dataPoints.value("TotVArhImpQ2PhA").toFloatWithSSF(m_totVArh_SF); if (m_dataPoints.value("TotVArhImpQ2PhB").isValid()) m_totalVArHoursImportedQ2PhaseB = m_dataPoints.value("TotVArhImpQ2PhB").toFloatWithSSF(m_totVArh_SF); if (m_dataPoints.value("TotVArhImpQ2PhC").isValid()) m_totalVArHoursImportedQ2PhaseC = m_dataPoints.value("TotVArhImpQ2PhC").toFloatWithSSF(m_totVArh_SF); if (m_dataPoints.value("TotVArhExpQ3").isValid()) m_totalVArHoursExportedQ3 = m_dataPoints.value("TotVArhExpQ3").toFloatWithSSF(m_totVArh_SF); if (m_dataPoints.value("TotVArhExpQ3PhA").isValid()) m_totalVArHoursExportedQ3PhaseA = m_dataPoints.value("TotVArhExpQ3PhA").toFloatWithSSF(m_totVArh_SF); if (m_dataPoints.value("TotVArhExpQ3PhB").isValid()) m_totalVArHoursExportedQ3PhaseB = m_dataPoints.value("TotVArhExpQ3PhB").toFloatWithSSF(m_totVArh_SF); if (m_dataPoints.value("TotVArhExpQ3PhC").isValid()) m_totalVArHoursExportedQ3PhaseC = m_dataPoints.value("TotVArhExpQ3PhC").toFloatWithSSF(m_totVArh_SF); if (m_dataPoints.value("TotVArhExpQ4").isValid()) m_totalVArHoursExportedQ4 = m_dataPoints.value("TotVArhExpQ4").toFloatWithSSF(m_totVArh_SF); if (m_dataPoints.value("TotVArhExpQ4PhA").isValid()) m_totalVArHoursExportedQ4ImportedPhaseA = m_dataPoints.value("TotVArhExpQ4PhA").toFloatWithSSF(m_totVArh_SF); if (m_dataPoints.value("TotVArhExpQ4PhB").isValid()) m_totalVArHoursExportedQ4ImportedPhaseB = m_dataPoints.value("TotVArhExpQ4PhB").toFloatWithSSF(m_totVArh_SF); if (m_dataPoints.value("TotVArhExpQ4PhC").isValid()) m_totalVArHoursExportedQ4ImportedPhaseC = m_dataPoints.value("TotVArhExpQ4PhC").toFloatWithSSF(m_totVArh_SF); if (m_dataPoints.value("TotVArh_SF").isValid()) m_totVArh_SF = m_dataPoints.value("TotVArh_SF").toInt16(); if (m_dataPoints.value("Evt").isValid()) m_events = static_cast(m_dataPoints.value("Evt").toUInt32()); qCDebug(dcSunSpecModelData()) << this; } QDebug operator<<(QDebug debug, SunSpecMeterThreePhaseModel *model) { debug.nospace().noquote() << "SunSpecMeterThreePhaseModel(Model: " << model->modelId() << ", Register: " << model->modbusStartRegister() << ", Length: " << model->modelLength() << ")\n"; debug.nospace().noquote() << " - " << model->dataPoints().value("A") << "-->"; if (model->dataPoints().value("A").isValid()) { debug.nospace().noquote() << model->amps() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("AphA") << "-->"; if (model->dataPoints().value("AphA").isValid()) { debug.nospace().noquote() << model->ampsPhaseA() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("AphB") << "-->"; if (model->dataPoints().value("AphB").isValid()) { debug.nospace().noquote() << model->ampsPhaseB() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("AphC") << "-->"; if (model->dataPoints().value("AphC").isValid()) { debug.nospace().noquote() << model->ampsPhaseC() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("PhV") << "-->"; if (model->dataPoints().value("PhV").isValid()) { debug.nospace().noquote() << model->voltageLn() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("PhVphA") << "-->"; if (model->dataPoints().value("PhVphA").isValid()) { debug.nospace().noquote() << model->phaseVoltageAn() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("PhVphB") << "-->"; if (model->dataPoints().value("PhVphB").isValid()) { debug.nospace().noquote() << model->phaseVoltageBn() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("PhVphC") << "-->"; if (model->dataPoints().value("PhVphC").isValid()) { debug.nospace().noquote() << model->phaseVoltageCn() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("PPV") << "-->"; if (model->dataPoints().value("PPV").isValid()) { debug.nospace().noquote() << model->voltageLl() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("PhVphAB") << "-->"; if (model->dataPoints().value("PhVphAB").isValid()) { debug.nospace().noquote() << model->phaseVoltageAb() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("PhVphBC") << "-->"; if (model->dataPoints().value("PhVphBC").isValid()) { debug.nospace().noquote() << model->phaseVoltageBc() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("PhVphCA") << "-->"; if (model->dataPoints().value("PhVphCA").isValid()) { debug.nospace().noquote() << model->phaseVoltageCa() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("Hz") << "-->"; if (model->dataPoints().value("Hz").isValid()) { debug.nospace().noquote() << model->hz() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("W") << "-->"; if (model->dataPoints().value("W").isValid()) { debug.nospace().noquote() << model->watts() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("WphA") << "-->"; if (model->dataPoints().value("WphA").isValid()) { debug.nospace().noquote() << model->wattsPhaseA() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("WphB") << "-->"; if (model->dataPoints().value("WphB").isValid()) { debug.nospace().noquote() << model->wattsPhaseB() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("WphC") << "-->"; if (model->dataPoints().value("WphC").isValid()) { debug.nospace().noquote() << model->wattsPhaseC() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("VA") << "-->"; if (model->dataPoints().value("VA").isValid()) { debug.nospace().noquote() << model->va() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("VAphA") << "-->"; if (model->dataPoints().value("VAphA").isValid()) { debug.nospace().noquote() << model->vaPhaseA() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("VAphB") << "-->"; if (model->dataPoints().value("VAphB").isValid()) { debug.nospace().noquote() << model->vaPhaseB() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("VAphC") << "-->"; if (model->dataPoints().value("VAphC").isValid()) { debug.nospace().noquote() << model->vaPhaseC() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("VAR") << "-->"; if (model->dataPoints().value("VAR").isValid()) { debug.nospace().noquote() << model->var() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("VARphA") << "-->"; if (model->dataPoints().value("VARphA").isValid()) { debug.nospace().noquote() << model->varPhaseA() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("VARphB") << "-->"; if (model->dataPoints().value("VARphB").isValid()) { debug.nospace().noquote() << model->varPhaseB() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("VARphC") << "-->"; if (model->dataPoints().value("VARphC").isValid()) { debug.nospace().noquote() << model->varPhaseC() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("PF") << "-->"; if (model->dataPoints().value("PF").isValid()) { debug.nospace().noquote() << model->pf() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("PFphA") << "-->"; if (model->dataPoints().value("PFphA").isValid()) { debug.nospace().noquote() << model->pfPhaseA() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("PFphB") << "-->"; if (model->dataPoints().value("PFphB").isValid()) { debug.nospace().noquote() << model->pfPhaseB() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("PFphC") << "-->"; if (model->dataPoints().value("PFphC").isValid()) { debug.nospace().noquote() << model->pfPhaseC() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("TotWhExp") << "-->"; if (model->dataPoints().value("TotWhExp").isValid()) { debug.nospace().noquote() << model->totalWattHoursExported() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("TotWhExpPhA") << "-->"; if (model->dataPoints().value("TotWhExpPhA").isValid()) { debug.nospace().noquote() << model->totalWattHoursExportedPhaseA() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("TotWhExpPhB") << "-->"; if (model->dataPoints().value("TotWhExpPhB").isValid()) { debug.nospace().noquote() << model->totalWattHoursExportedPhaseB() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("TotWhExpPhC") << "-->"; if (model->dataPoints().value("TotWhExpPhC").isValid()) { debug.nospace().noquote() << model->totalWattHoursExportedPhaseC() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("TotWhImp") << "-->"; if (model->dataPoints().value("TotWhImp").isValid()) { debug.nospace().noquote() << model->totalWattHoursImported() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("TotWhImpPhA") << "-->"; if (model->dataPoints().value("TotWhImpPhA").isValid()) { debug.nospace().noquote() << model->totalWattHoursImportedPhaseA() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("TotWhImpPhB") << "-->"; if (model->dataPoints().value("TotWhImpPhB").isValid()) { debug.nospace().noquote() << model->totalWattHoursImportedPhaseB() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("TotWhImpPhC") << "-->"; if (model->dataPoints().value("TotWhImpPhC").isValid()) { debug.nospace().noquote() << model->totalWattHoursImportedPhaseC() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("TotVAhExp") << "-->"; if (model->dataPoints().value("TotVAhExp").isValid()) { debug.nospace().noquote() << model->totalVaHoursExported() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("TotVAhExpPhA") << "-->"; if (model->dataPoints().value("TotVAhExpPhA").isValid()) { debug.nospace().noquote() << model->totalVaHoursExportedPhaseA() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("TotVAhExpPhB") << "-->"; if (model->dataPoints().value("TotVAhExpPhB").isValid()) { debug.nospace().noquote() << model->totalVaHoursExportedPhaseB() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("TotVAhExpPhC") << "-->"; if (model->dataPoints().value("TotVAhExpPhC").isValid()) { debug.nospace().noquote() << model->totalVaHoursExportedPhaseC() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("TotVAhImp") << "-->"; if (model->dataPoints().value("TotVAhImp").isValid()) { debug.nospace().noquote() << model->totalVaHoursImported() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("TotVAhImpPhA") << "-->"; if (model->dataPoints().value("TotVAhImpPhA").isValid()) { debug.nospace().noquote() << model->totalVaHoursImportedPhaseA() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("TotVAhImpPhB") << "-->"; if (model->dataPoints().value("TotVAhImpPhB").isValid()) { debug.nospace().noquote() << model->totalVaHoursImportedPhaseB() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("TotVAhImpPhC") << "-->"; if (model->dataPoints().value("TotVAhImpPhC").isValid()) { debug.nospace().noquote() << model->totalVaHoursImportedPhaseC() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("TotVArhImpQ1") << "-->"; if (model->dataPoints().value("TotVArhImpQ1").isValid()) { debug.nospace().noquote() << model->totalVarHoursImportedQ1() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("TotVArhImpQ1PhA") << "-->"; if (model->dataPoints().value("TotVArhImpQ1PhA").isValid()) { debug.nospace().noquote() << model->totalVArHoursImportedQ1PhaseA() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("TotVArhImpQ1PhB") << "-->"; if (model->dataPoints().value("TotVArhImpQ1PhB").isValid()) { debug.nospace().noquote() << model->totalVArHoursImportedQ1PhaseB() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("TotVArhImpQ1PhC") << "-->"; if (model->dataPoints().value("TotVArhImpQ1PhC").isValid()) { debug.nospace().noquote() << model->totalVArHoursImportedQ1PhaseC() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("TotVArhImpQ2") << "-->"; if (model->dataPoints().value("TotVArhImpQ2").isValid()) { debug.nospace().noquote() << model->totalVArHoursImportedQ2() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("TotVArhImpQ2PhA") << "-->"; if (model->dataPoints().value("TotVArhImpQ2PhA").isValid()) { debug.nospace().noquote() << model->totalVArHoursImportedQ2PhaseA() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("TotVArhImpQ2PhB") << "-->"; if (model->dataPoints().value("TotVArhImpQ2PhB").isValid()) { debug.nospace().noquote() << model->totalVArHoursImportedQ2PhaseB() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("TotVArhImpQ2PhC") << "-->"; if (model->dataPoints().value("TotVArhImpQ2PhC").isValid()) { debug.nospace().noquote() << model->totalVArHoursImportedQ2PhaseC() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("TotVArhExpQ3") << "-->"; if (model->dataPoints().value("TotVArhExpQ3").isValid()) { debug.nospace().noquote() << model->totalVArHoursExportedQ3() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("TotVArhExpQ3PhA") << "-->"; if (model->dataPoints().value("TotVArhExpQ3PhA").isValid()) { debug.nospace().noquote() << model->totalVArHoursExportedQ3PhaseA() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("TotVArhExpQ3PhB") << "-->"; if (model->dataPoints().value("TotVArhExpQ3PhB").isValid()) { debug.nospace().noquote() << model->totalVArHoursExportedQ3PhaseB() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("TotVArhExpQ3PhC") << "-->"; if (model->dataPoints().value("TotVArhExpQ3PhC").isValid()) { debug.nospace().noquote() << model->totalVArHoursExportedQ3PhaseC() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("TotVArhExpQ4") << "-->"; if (model->dataPoints().value("TotVArhExpQ4").isValid()) { debug.nospace().noquote() << model->totalVArHoursExportedQ4() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("TotVArhExpQ4PhA") << "-->"; if (model->dataPoints().value("TotVArhExpQ4PhA").isValid()) { debug.nospace().noquote() << model->totalVArHoursExportedQ4ImportedPhaseA() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("TotVArhExpQ4PhB") << "-->"; if (model->dataPoints().value("TotVArhExpQ4PhB").isValid()) { debug.nospace().noquote() << model->totalVArHoursExportedQ4ImportedPhaseB() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("TotVArhExpQ4PhC") << "-->"; if (model->dataPoints().value("TotVArhExpQ4PhC").isValid()) { debug.nospace().noquote() << model->totalVArHoursExportedQ4ImportedPhaseC() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } debug.nospace().noquote() << " - " << model->dataPoints().value("Evt") << "-->"; if (model->dataPoints().value("Evt").isValid()) { debug.nospace().noquote() << model->events() << "\n"; } else { debug.nospace().noquote() << "NaN\n"; } return debug.space().quote(); }