From b79a055f48964ca617874aea017053df7268ccc5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Simon=20St=C3=BCrz?= Date: Thu, 10 Jun 2021 13:59:22 +0200 Subject: [PATCH] Add thermostat interface, extend values and implement execute action --- mtec/integrationpluginmtec.cpp | 117 ++++++++++++++++++++++++-- mtec/integrationpluginmtec.json | 141 +++++++++++++++++++++++--------- mtec/mtec.cpp | 73 +++++++++++++++-- mtec/mtec.h | 51 +++++++++--- 4 files changed, 317 insertions(+), 65 deletions(-) diff --git a/mtec/integrationpluginmtec.cpp b/mtec/integrationpluginmtec.cpp index eabef90..e1ebbd0 100644 --- a/mtec/integrationpluginmtec.cpp +++ b/mtec/integrationpluginmtec.cpp @@ -106,9 +106,19 @@ void IntegrationPluginMTec::setupThing(ThingSetupInfo *info) thing->setStateValue(mtecConnectedStateTypeId, connected); }); - connect(mtec, &MTec::waterTankTemperatureChanged, thing, [=](double waterTankTemperature){ - qCDebug(dcMTec()) << thing << "Water tank temperature" << waterTankTemperature << "°C"; - thing->setStateValue(mtecWaterTankTemperatureStateTypeId, waterTankTemperature); + connect(mtec, &MTec::roomTemperatureChanged, thing, [=](double roomTemperature){ + qCDebug(dcMTec()) << thing << "Room temperature" << roomTemperature << "°C"; + thing->setStateValue(mtecTemperatureStateTypeId, roomTemperature); + }); + + connect(mtec, &MTec::targetRoomTemperatureChanged, thing, [=](double targetRoomTemperature){ + qCDebug(dcMTec()) << thing << "Target room temperature" << targetRoomTemperature << "°C"; + thing->setStateValue(mtecTargetTemperatureStateTypeId, targetRoomTemperature); + }); + + connect(mtec, &MTec::waterTankTopTemperatureChanged, thing, [=](double waterTankTopTemperature){ + qCDebug(dcMTec()) << thing << "Water tank top temperature" << waterTankTopTemperature << "°C"; + thing->setStateValue(mtecWaterTankTopTemperatureStateTypeId, waterTankTopTemperature); }); connect(mtec, &MTec::bufferTankTemperatureChanged, thing, [=](double bufferTankTemperature){ @@ -116,8 +126,13 @@ void IntegrationPluginMTec::setupThing(ThingSetupInfo *info) thing->setStateValue(mtecBufferTankTemperatureStateTypeId, bufferTankTemperature); }); + connect(mtec, &MTec::totalAccumulatedHeatingEnergyChanged, thing, [=](double totalAccumulatedHeatingEnergy){ + qCDebug(dcMTec()) << thing << "Total accumulated heating energy" << totalAccumulatedHeatingEnergy << "kWh"; + thing->setStateValue(mtecTotalAccumulatedHeatingEnergyStateTypeId, totalAccumulatedHeatingEnergy); + }); + connect(mtec, &MTec::totalAccumulatedElectricalEnergyChanged, thing, [=](double totalAccumulatedElectricalEnergy){ - qCDebug(dcMTec()) << thing << "Total accumulated energy" << totalAccumulatedElectricalEnergy << "kWh"; + qCDebug(dcMTec()) << thing << "Total accumulated electrical energy" << totalAccumulatedElectricalEnergy << "kWh"; thing->setStateValue(mtecTotalAccumulatedElectricalEnergyStateTypeId, totalAccumulatedElectricalEnergy); }); @@ -126,27 +141,43 @@ void IntegrationPluginMTec::setupThing(ThingSetupInfo *info) switch (heatPumpState) { case MTec::HeatpumpStateStandby: thing->setStateValue(mtecHeatPumpStateStateTypeId, "Standby"); + thing->setStateValue(mtecHeatingOnStateTypeId, false); + thing->setStateValue(mtecCoolingOnStateTypeId, false); break; case MTec::HeatpumpStatePreRun: thing->setStateValue(mtecHeatPumpStateStateTypeId, "Pre run"); + thing->setStateValue(mtecHeatingOnStateTypeId, false); + thing->setStateValue(mtecCoolingOnStateTypeId, false); break; case MTec::HeatpumpStateAutomaticHeat: thing->setStateValue(mtecHeatPumpStateStateTypeId, "Automatic heat"); + thing->setStateValue(mtecHeatingOnStateTypeId, true); + thing->setStateValue(mtecCoolingOnStateTypeId, false); break; case MTec::HeatpumpStateDefrost: thing->setStateValue(mtecHeatPumpStateStateTypeId, "Defrost"); + thing->setStateValue(mtecHeatingOnStateTypeId, false); + thing->setStateValue(mtecCoolingOnStateTypeId, false); break; case MTec::HeatpumpStateAutomaticCool: thing->setStateValue(mtecHeatPumpStateStateTypeId, "Automatic cool"); + thing->setStateValue(mtecHeatingOnStateTypeId, false); + thing->setStateValue(mtecCoolingOnStateTypeId, true); break; case MTec::HeatpumpStatePostRun: + thing->setStateValue(mtecHeatingOnStateTypeId, false); thing->setStateValue(mtecHeatPumpStateStateTypeId, "Post run"); + thing->setStateValue(mtecCoolingOnStateTypeId, false); break; case MTec::HeatpumpStateSaftyShutdown: + thing->setStateValue(mtecHeatingOnStateTypeId, false); thing->setStateValue(mtecHeatPumpStateStateTypeId, "Safty shutdown"); + thing->setStateValue(mtecCoolingOnStateTypeId, false); break; case MTec::HeatpumpStateError: + thing->setStateValue(mtecHeatingOnStateTypeId, false); thing->setStateValue(mtecHeatPumpStateStateTypeId, "Error"); + thing->setStateValue(mtecCoolingOnStateTypeId, false); break; } }); @@ -166,6 +197,11 @@ void IntegrationPluginMTec::setupThing(ThingSetupInfo *info) thing->setStateValue(mtecSmartHomeEnergyStateTypeId, actualExcessEnergySmartHome); }); + connect(mtec, &MTec::actualExcessEnergySmartHomeElectricityMeterChanged, thing, [=](double actualExcessEnergySmartHomeElectricityMeter){ + qCDebug(dcMTec()) << thing << "Smart home energy electrical meter" << actualExcessEnergySmartHomeElectricityMeter << "W"; + thing->setStateValue(mtecSmartHomeEnergyElectricityMeterStateTypeId, actualExcessEnergySmartHomeElectricityMeter); + }); + connect(mtec, &MTec::actualOutdoorTemperatureChanged, thing, [=](double actualOutdoorTemperature){ qCDebug(dcMTec()) << thing << "Outdoor temperature" << actualOutdoorTemperature << "°C"; thing->setStateValue(mtecOutdoorTemperatureStateTypeId, actualOutdoorTemperature); @@ -221,9 +257,76 @@ void IntegrationPluginMTec::thingRemoved(Thing *thing) void IntegrationPluginMTec::executeAction(ThingActionInfo *info) { -// Thing *thing = info->thing(); -// Action action = info->action(); - info->finish(Thing::ThingErrorNoError); + Thing *thing = info->thing(); + Action action = info->action(); + + MTec *mtec = m_mtecConnections.value(thing); + if (!mtec) { + qCWarning(dcMTec()) << "Could not execute action because the MTec connection could not be found for" << thing; + info->finish(Thing::ThingErrorHardwareNotAvailable); + return; + } + + // Make sure we are connected + if (!mtec->connected()) { + qCWarning(dcMTec()) << "Could not execute action because the MTec connection is not connected" << thing; + info->finish(Thing::ThingErrorHardwareNotAvailable); + return; + } + + if (action.actionTypeId() == mtecTargetTemperatureActionTypeId) { + double targetTemperature = action.paramValue(mtecTargetTemperatureActionTargetTemperatureParamTypeId).toDouble(); + qCDebug(dcMTec()) << "Setting target temperature" << targetTemperature << "°C"; + QModbusReply *reply = mtec->setTargetRoomTemperature(targetTemperature); + if (!reply) { + qCWarning(dcMTec()) << "Failed to send modbus request" << thing; + info->finish(Thing::ThingErrorHardwareFailure); + return; + } + + connect(reply, &QModbusReply::finished, this, [=]() { + reply->deleteLater(); + if (reply->error() == QModbusDevice::NoError) { + qCDebug(dcMTec()) << "Setting target temperature" << targetTemperature << "°C" << "finished successfully"; + info->finish(Thing::ThingErrorNoError); + } else { + info->finish(Thing::ThingErrorHardwareFailure); + } + }); + + connect(reply, &QModbusReply::errorOccurred, this, [=](QModbusDevice::Error error) { + qCWarning(dcMTec()) << thing << "Action execution finished due to modbus replay error:" << error; + reply->deleteLater(); + info->finish(Thing::ThingErrorHardwareFailure); + }); + } else if (action.actionTypeId() == mtecSmartHomeEnergyActionTypeId) { + quint16 energy = action.paramValue(mtecSmartHomeEnergyActionSmartHomeEnergyParamTypeId).toUInt(); + qCDebug(dcMTec()) << "Setting smart home energy to" << energy << "W"; + QModbusReply *reply = mtec->setSmartHomeEnergy(energy); + if (!reply) { + qCWarning(dcMTec()) << "Failed to send modbus request" << thing; + info->finish(Thing::ThingErrorHardwareFailure); + return; + } + + connect(reply, &QModbusReply::finished, this, [=]() { + reply->deleteLater(); + if (reply->error() == QModbusDevice::NoError) { + qCDebug(dcMTec()) << "Setting smart home energy" << energy << "W" << "finished successfully"; + info->finish(Thing::ThingErrorNoError); + } else { + info->finish(Thing::ThingErrorHardwareFailure); + } + }); + + connect(reply, &QModbusReply::errorOccurred, this, [=](QModbusDevice::Error error) { + qCWarning(dcMTec()) << thing << "Action execution finished due to modbus replay error:" << error; + reply->deleteLater(); + info->finish(Thing::ThingErrorHardwareFailure); + }); + } else { + Q_ASSERT_X(false, "executeAction", QString("Unhandled action: %1").arg(action.actionTypeId().toString()).toUtf8()); + } } void IntegrationPluginMTec::update(Thing *thing) diff --git a/mtec/integrationpluginmtec.json b/mtec/integrationpluginmtec.json index 1ab7f82..dfa068e 100644 --- a/mtec/integrationpluginmtec.json +++ b/mtec/integrationpluginmtec.json @@ -13,7 +13,7 @@ "displayName": "MTec", "id": "451e38d8-50d5-4ae9-8d9f-21af9347128d", "createMethods": ["discovery", "user"], - "interfaces": ["connectable"], + "interfaces": ["thermostat", "connectable"], "paramTypes": [ { "id": "f1c43b1e-cffe-4d30-bda0-c23ed648dd71", @@ -41,43 +41,6 @@ "type": "bool", "defaultValue": false, "cached": false - }, - { - "id": "545f94d6-f4fd-48fe-bf3b-f193e5cb76e7", - "name": "waterTankTemperature", - "displayName": "Water tank temperature", - "displayNameEvent": "Water tank temperature changed", - "unit": "DegreeCelsius", - "type": "double", - "defaultValue": 0 - }, - { - "id": "a98e37f8-dcdc-4c4c-aecf-07f376321849", - "name": "bufferTankTemperature", - "displayName": "Buffer tank temperature", - "displayNameEvent": "Buffer tank temperature changed", - "unit": "DegreeCelsius", - "type": "double", - "defaultValue": 0 - }, - { - "id": "d0c8f168-49b5-47ca-9988-c9922be38dd5", - "name": "outdoorTemperature", - "displayName": "Outdoor temperature", - "displayNameEvent": "Outdoor temperature changed", - "unit": "DegreeCelsius", - "type": "double", - "defaultValue": 0 - }, - { - "id": "c67c79cf-7369-409f-b170-16c4ece9d25a", - "name": "totalAccumulatedElectricalEnergy", - "displayName": "Total accumulated electrical energy", - "displayNameEvent": "Total accumulated electrical energy changed", - "type": "double", - "unit": "KiloWattHour", - "defaultValue": 0, - "suggestLogging": true }, { "id": "1e2037c8-09dc-4396-974c-efa9c486aa65", @@ -98,6 +61,91 @@ "defaultValue": "Standby", "suggestLogging": true }, + { + "id": "9b538cb9-f7a3-471e-8d3b-09f6370a571c", + "name": "targetTemperature", + "displayName": "Target room temperature (heat circuit 0)", + "displayNameEvent": "Target room temperature changed (heat circuit 0=", + "displayNameAction": "Set target room temperature (heat circuit 0)", + "unit": "DegreeCelsius", + "type": "double", + "writable": true, + "minValue": 10, + "maxValue": 30, + "defaultValue": 20 + }, + { + "id": "b22ac9bb-3842-497c-bd93-f8bea6670e32", + "name": "temperature", + "displayName": "Room temperature heat circuit 0", + "displayNameEvent": "Room temperature heat circuit 0 changed", + "unit": "DegreeCelsius", + "type": "double", + "defaultValue": 20 + }, + { + "id": "07465fbb-6949-4bd1-90d5-acf2d80c161d", + "name": "heatingOn", + "displayName": "Heating on", + "displayNameEvent": "Heating turned on/off", + "type": "bool", + "defaultValue": false + }, + { + "id": "8b407c1d-b84f-48d4-9961-b29bc58fff0e", + "name": "coolingOn", + "displayName": "Cooling on", + "displayNameEvent": "Cooling turned on/off", + "type": "bool", + "defaultValue": false + }, + { + "id": "d0c8f168-49b5-47ca-9988-c9922be38dd5", + "name": "outdoorTemperature", + "displayName": "Outdoor temperature", + "displayNameEvent": "Outdoor temperature changed", + "unit": "DegreeCelsius", + "type": "double", + "defaultValue": 0 + }, + { + "id": "545f94d6-f4fd-48fe-bf3b-f193e5cb76e7", + "name": "waterTankTopTemperature", + "displayName": "Water tank top temperature", + "displayNameEvent": "Water tank top temperature changed", + "unit": "DegreeCelsius", + "type": "double", + "defaultValue": 0 + }, + { + "id": "a98e37f8-dcdc-4c4c-aecf-07f376321849", + "name": "bufferTankTemperature", + "displayName": "Buffer tank temperature", + "displayNameEvent": "Buffer tank temperature changed", + "unit": "DegreeCelsius", + "type": "double", + "defaultValue": 0 + }, + { + "id": "7d087af8-cdbe-463e-a9bb-7a7a79471963", + "name": "totalAccumulatedHeatingEnergy", + "displayName": "Total accumulated heating energy", + "displayNameEvent": "Total accumulated heating energy changed", + "type": "double", + "unit": "KiloWattHour", + "defaultValue": 0, + "suggestLogging": true + }, + { + "id": "c67c79cf-7369-409f-b170-16c4ece9d25a", + "name": "totalAccumulatedElectricalEnergy", + "displayName": "Total accumulated electrical energy", + "displayNameEvent": "Total accumulated electrical energy changed", + "type": "double", + "unit": "KiloWattHour", + "defaultValue": 0, + "suggestLogging": true + }, { "id": "581abddc-90d6-4dea-a43c-63b117b335fe", "name": "heatMeterPowerConsumption", @@ -123,14 +171,27 @@ "name": "smartHomeEnergy", "displayName": "Smart home energy", "displayNameEvent": "Smart home energy changed", + "displayNameAction": "Set smart home energy", + "type": "uint", + "unit": "Watt", + "minValue": 0, + "maxValue": 20000, + "defaultValue": 0, + "writable": true, + "suggestLogging": true + }, + { + "id": "a7734474-30db-435c-985a-105fb3ea5a86", + "name": "smartHomeEnergyElectricityMeter", + "displayName": "Smart home energy consumed", + "displayNameEvent": "Smart home energy consumed changed", "type": "double", "unit": "Watt", "defaultValue": 0, "suggestLogging": true } ], - "actionTypes": [ - ] + "actionTypes": [ ] } ] } diff --git a/mtec/mtec.cpp b/mtec/mtec.cpp index c8fd5bb..ac953c5 100644 --- a/mtec/mtec.cpp +++ b/mtec/mtec.cpp @@ -51,6 +51,37 @@ MTec::~MTec() m_modbusMaster->disconnectDevice(); } +QHostAddress MTec::hostAddress() const +{ + return m_hostAddress; +} + +bool MTec::connected() const +{ + return m_modbusMaster->connected(); +} + +QModbusReply *MTec::setTargetRoomTemperature(double targetRoomTemperature) +{ + QVector values; + values << static_cast(qRound(targetRoomTemperature * 10)); + + QModbusDataUnit request = QModbusDataUnit(QModbusDataUnit::RegisterType::HoldingRegisters, RegisterTargetRoomTemperature, values.length()); + request.setValues(values); + QModbusReply *reply = m_modbusMaster->sendWriteRequest(request, MTec::ModbusUnitID); + return reply; +} + +QModbusReply *MTec::setSmartHomeEnergy(quint16 smartHomeEnergy) +{ + QVector values; + values << smartHomeEnergy; + QModbusDataUnit request = QModbusDataUnit(QModbusDataUnit::RegisterType::HoldingRegisters, RegisterActualExcessEnergySmartHome, values.length()); + request.setValues(values); + QModbusReply *reply = m_modbusMaster->sendWriteRequest(request, MTec::ModbusUnitID); + return reply; +} + bool MTec::connectDevice() { return m_modbusMaster->connectDevice(); @@ -67,7 +98,7 @@ void MTec::updateValues() return; } - m_modbusMaster->readHoldingRegister(MTec::ModbusUnitID, RegisterHotWaterTankTemperature, 1); + m_modbusMaster->readHoldingRegister(MTec::ModbusUnitID, RegisterRoomTemperature, 1); } void MTec::onModbusError() @@ -80,10 +111,24 @@ void MTec::onReceivedHoldingRegister(int slaveAddress, int modbusRegister, const Q_UNUSED(slaveAddress); switch (modbusRegister) { + case RegisterRoomTemperature: + if (value.length() == 1) { + m_roomTemperature = value[0] / 10.0; + emit roomTemperatureChanged(m_roomTemperature); + } + m_modbusMaster->readHoldingRegister(MTec::ModbusUnitID, RegisterTargetRoomTemperature, 1); + break; + case RegisterTargetRoomTemperature: + if (value.length() == 1) { + m_targetRoomTemperature = value[0] / 10.0; + emit targetRoomTemperatureChanged(m_targetRoomTemperature); + } + m_modbusMaster->readHoldingRegister(MTec::ModbusUnitID, RegisterHotWaterTankTemperature, 1); + break; case RegisterHotWaterTankTemperature: if (value.length() == 1) { - m_waterTankTemperature = value[0] / 10.0; - emit waterTankTemperatureChanged(m_waterTankTemperature); + m_waterTankTopTemperature = value[0] / 10.0; + emit waterTankTopTemperatureChanged(m_waterTankTopTemperature); } m_modbusMaster->readHoldingRegister(MTec::ModbusUnitID, RegisterBufferTankTemperature, 1); break; @@ -92,11 +137,18 @@ void MTec::onReceivedHoldingRegister(int slaveAddress, int modbusRegister, const m_bufferTankTemperature = value[0] / 10.0; emit bufferTankTemperatureChanged(m_bufferTankTemperature); } + m_modbusMaster->readHoldingRegister(MTec::ModbusUnitID, RegisterTotalAccumulatedHeatingEnergy, 1); + break; + case RegisterTotalAccumulatedHeatingEnergy: + if (value.length() == 1) { + m_totalAccumulatedElectricalEnergy = value[0]; + emit totalAccumulatedElectricalEnergyChanged(m_totalAccumulatedElectricalEnergy); + } m_modbusMaster->readHoldingRegister(MTec::ModbusUnitID, RegisterTotalAccumulatedElectricalEnergy, 1); break; case RegisterTotalAccumulatedElectricalEnergy: if (value.length() == 1) { - m_totalAccumulatedElectricalEnergy = value[0] / 100.0; + m_totalAccumulatedElectricalEnergy = value[0]; emit totalAccumulatedElectricalEnergyChanged(m_totalAccumulatedElectricalEnergy); } m_modbusMaster->readHoldingRegister(MTec::ModbusUnitID, RegisterHeatpumpState, 1); @@ -110,21 +162,28 @@ void MTec::onReceivedHoldingRegister(int slaveAddress, int modbusRegister, const break; case RegisterHeatMeterPowerConsumption: if (value.length() == 1) { - m_heatMeterPowerConsumption = value[0] / 100.0; + m_heatMeterPowerConsumption = value[0]; emit heatMeterPowerConsumptionChanged(m_heatMeterPowerConsumption); } m_modbusMaster->readHoldingRegister(MTec::ModbusUnitID, RegisterEnergyMeterPowerConsumption, 1); break; case RegisterEnergyMeterPowerConsumption: if (value.length() == 1) { - m_energyMeterPowerConsumption = value[0] / 100.0; + m_energyMeterPowerConsumption = value[0]; emit energyMeterPowerConsumptionChanged(m_energyMeterPowerConsumption); } m_modbusMaster->readHoldingRegister(MTec::ModbusUnitID, RegisterActualExcessEnergySmartHome, 1); break; case RegisterActualExcessEnergySmartHome: if (value.length() == 1) { - m_actualExcessEnergySmartHome = value[0] / 100.0; + m_actualExcessEnergySmartHome = value[0]; + emit actualExcessEnergySmartHomeChanged(m_actualExcessEnergySmartHome); + } + m_modbusMaster->readHoldingRegister(MTec::ModbusUnitID, RegisterActualExcessEnergySmartHomeElectricityMeter, 1); + break; + case RegisterActualExcessEnergySmartHomeElectricityMeter: + if (value.length() == 1) { + m_actualExcessEnergySmartHomeElectricityMeter = value[0]; emit actualExcessEnergySmartHomeChanged(m_actualExcessEnergySmartHome); } m_modbusMaster->readHoldingRegister(MTec::ModbusUnitID, RegisterActualOutdoorTemperature, 1); diff --git a/mtec/mtec.h b/mtec/mtec.h index 7b20057..50f1740 100644 --- a/mtec/mtec.h +++ b/mtec/mtec.h @@ -55,8 +55,13 @@ public: explicit MTec(const QHostAddress &address, QObject *parent = nullptr); ~MTec(); - inline QHostAddress hostAddress() const { return m_hostAddress; }; + QHostAddress hostAddress() const; + bool connected() const; + QModbusReply *setTargetRoomTemperature(double targetRoomTemperature); + QModbusReply *setSmartHomeEnergy(quint16 smartHomeEnergy); + +public slots: bool connectDevice(); void disconnectDevice(); @@ -68,34 +73,50 @@ private: /** The following modbus addresses can be read: */ enum Register { - /* APPL.CtrlAppl.sParam.hotWaterTank[0].topTemp.values.actValue + /* R APPL.CtrlAppl.sParam.heatCircuit[0].tempRoom.values.actValue + * Actual room temperature [1/10°C]. */ + RegisterRoomTemperature = 1, + + /* RW APPL.CtrlAppl.sParam.heatCircuit[0].param.normalSetTemp + * Room set temperature for heating circuit [1/10°C]. */ + RegisterTargetRoomTemperature = 4, + + /* R APPL.CtrlAppl.sParam.hotWaterTank[0].topTemp.values.actValue * Hot water tank top temperature [1/10°C]. */ RegisterHotWaterTankTemperature = 401, - /* APPL.CtrlAppl.sParam.bufferTank[0].topTemp.values.actValue + /* R APPL.CtrlAppl.sParam.bufferTank[0].topTemp.values.actValue * Buffer Actual top temperature [1/10°C]. */ RegisterBufferTankTemperature = 601, - /* APPL.CtrlAppl.sStatisticalData.heatpump[0].consumption.electricalenergy + /* R APPL.CtrlAppl.sStatisticalData.heatpump[0].consumption.energy + * Total accumulated heating energy [kWh] */ + RegisterTotalAccumulatedHeatingEnergy = 701, + + /* R APPL.CtrlAppl.sStatisticalData.heatpump[0].consumption.electricalenergy * Total accumulated electrical energy [kWh] */ RegisterTotalAccumulatedElectricalEnergy = 702, - /* APPL.CtrlAppl.sParam.heatpump[0].values.heatpumpState */ + /* R APPL.CtrlAppl.sParam.heatpump[0].values.heatpumpState */ RegisterHeatpumpState = 703, - /* APPL.CtrlAppl.sParam.heatpump[0].HeatMeter.values.power + /* R APPL.CtrlAppl.sParam.heatpump[0].HeatMeter.values.power * Actual power consumtion [W] */ RegisterHeatMeterPowerConsumption = 706, - /* APPL.CtrlAppl.sParam.heatpump[0].ElectricEnergyMeter.values.power + /* R APPL.CtrlAppl.sParam.heatpump[0].ElectricEnergyMeter.values.power * Actual power consumtion [W] */ RegisterEnergyMeterPowerConsumption = 707, - /* APPL.CtrlAppl.sIOModule.Virt[0].param.sensor[0] + /* RW APPL.CtrlAppl.sIOModule.Virt[0].param.sensor[0] * Acutal excess energy given from Smart home System [W] */ RegisterActualExcessEnergySmartHome = 1000, - /* APPL.CtrlAppl.sParam.outdoorTemp.values.actValue + /* R APPL.CtrlAppl.sParam.photovoltaics.ElectricEnergyMeter.values.power + * Acutal excess energy given from Electricity Meter [W] */ + RegisterActualExcessEnergySmartHomeElectricityMeter = 1002, + + /* R APPL.CtrlAppl.sParam.outdoorTemp.values.actValue * Actual exterior temperature [°C] */ RegisterActualOutdoorTemperature = 1502, @@ -104,25 +125,33 @@ private: QHostAddress m_hostAddress; ModbusTCPMaster *m_modbusMaster = nullptr; - double m_waterTankTemperature = 0; + double m_roomTemperature = 0; + double m_targetRoomTemperature = 0; + double m_waterTankTopTemperature = 0; double m_bufferTankTemperature = 0; + double m_totalAccumulatedHeatingEnergy = 0; double m_totalAccumulatedElectricalEnergy = 0; HeatpumpState m_heatPumpState = HeatpumpStateStandby; double m_heatMeterPowerConsumption = 0; double m_energyMeterPowerConsumption = 0; double m_actualExcessEnergySmartHome = 0; + double m_actualExcessEnergySmartHomeElectricityMeter = 0; double m_actualOutdoorTemperature = 0; signals: void connectedChanged(bool connected); - void waterTankTemperatureChanged(double waterTankTemperature); + void roomTemperatureChanged(double roomTemperature); + void targetRoomTemperatureChanged(double targetRoomTemperature); + void waterTankTopTemperatureChanged(double waterTankTopTemperature); void bufferTankTemperatureChanged(double bufferTankTemperature); + void totalAccumulatedHeatingEnergyChanged(double totalAccumulatedHeatingEnergy); void totalAccumulatedElectricalEnergyChanged(double totalAccumulatedElectricalEnergy); void heatPumpStateChanged(HeatpumpState heatPumpState); void heatMeterPowerConsumptionChanged(double heatMeterPowerConsumption); void energyMeterPowerConsumptionChanged(double energyMeterPowerConsumption); void actualExcessEnergySmartHomeChanged(double actualExcessEnergySmartHome); + void actualExcessEnergySmartHomeElectricityMeterChanged(double actualExcessEnergySmartHomeElectricityMeter); void actualOutdoorTemperatureChanged(double actualOutdoorTemperature); private slots: