Add thermostat interface, extend values and implement execute action

mtec/integrationpluginmtec.cpp

@@ -106,9 +106,19 @@ void IntegrationPluginMTec::setupThing(ThingSetupInfo *info)
             thing->setStateValue(mtecConnectedStateTypeId, connected);
         });
 
-        connect(mtec, &MTec::waterTankTemperatureChanged, thing, [=](double waterTankTemperature){
+        connect(mtec, &MTec::roomTemperatureChanged, thing, [=](double roomTemperature){
-            qCDebug(dcMTec()) << thing << "Water tank temperature" << waterTankTemperature << "°C";
+            qCDebug(dcMTec()) << thing << "Room temperature" << roomTemperature << "°C";
-            thing->setStateValue(mtecWaterTankTemperatureStateTypeId, waterTankTemperature);
+            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();
+    Thing *thing = info->thing();
-//    Action action = info->action();
+    Action action = info->action();
-    info->finish(Thing::ThingErrorNoError);
+
+    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)

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": [ ]
-                    ]
                 }
             ]
         }

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<quint16> values;
+    values << static_cast<quint16>(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<quint16> 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;
+            m_waterTankTopTemperature = value[0] / 10.0;
-            emit waterTankTemperatureChanged(m_waterTankTemperature);
+            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);

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: