diff --git a/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/KermiBindingConstants.java b/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/KermiBindingConstants.java
index f5618aa165bac..b9bea78bb4571 100644
--- a/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/KermiBindingConstants.java
+++ b/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/KermiBindingConstants.java
@@ -30,7 +30,47 @@ public class KermiBindingConstants {
     // Supported Thing Types
     public static final ThingTypeUID THING_TYPE_KERMI_XCENTER = new ThingTypeUID(BINDING_ID, "kermi-xcenter");
 
-    // Channels for State Block
+    // Channels for State
     public static final String GLOBAL_STATE_CHANNEL = "global-state";
     public static final String GLOBAL_STATE_ID_CHANNEL = "global-state-id";
+
+    // Alarm State
+    public static final String ALARM_STATE_CHANNEL = "alarm-state";
+
+    // Energy Source
+    public static final String FLOW_TEMPERATURE_CHANNEL = "flow-temperature";
+    public static final String RETURN_TEMPERATURE_CHANNEL = "return-temperature";
+    public static final String FLOW_SPEED_CHANNEL = "flow-speed";
+
+    // Charging Circuit
+    public static final String EXIT_TEMPERATURE_CHANNEL = "exit-temperature";
+    public static final String INCOMING_TEMPERATURE_CHANNEL = "incoming-temperature";
+    public static final String TEMPERATURE_SENSOR_OUTSIDE_CHANNEL = "temperature-sensor-outside";
+
+    // Power
+    public static final String COP_CHANNEL = "cop";
+    public static final String COP_HEATING_CHANNEL = "cop-heating";
+    public static final String COP_DRINKINGWATER_CHANNEL = "cop-drinkingwater";
+    public static final String COP_COOLING_CHANNEL = "cop-cooling";
+
+    public static final String POWER_CHANNEL = "power";
+    public static final String POWER_HEATING_CHANNEL = "power-heating";
+    public static final String POWER_DRINKINGWATER_CHANNEL = "power-drinkingwater";
+    public static final String POWER_COOLING_CHANNEL = "power-cooling";
+
+    public static final String ELECTRIC_POWER_CHANNEL = "electric-power";
+    public static final String ELECTRIC_POWER_HEATING_CHANNEL = "electric-power-heating";
+    public static final String ELECTRIC_POWER_DRINKINGWATER_CHANNEL = "electric-power-drinkingwater";
+    public static final String ELECTRIC_POWER_COOLING_CHANNEL = "electric-power-cooling";
+
+    // Work hours
+    public static final String WORKHOURS_FAN_CHANNEL = "workhours-fan";
+    public static final String WORKHOURS_STORAGE_LOADING_PUMP_CHANNEL = "workhours-storage-loading-pump";
+    public static final String WORKHOURS_COMPRESSOR_CHANNEL = "workhours-compressor";
+
+    // PV
+    public static final String PV_STATE_CHANNEL = "pv-state";
+    public static final String PV_POWER_CHANNEL = "pv-power";
+    public static final String PV_TARGET_TEMPERATURE_HEATING_CHANNEL = "pv-target-temperature-heating";
+    public static final String PV_TARGET_TEMPERATURE_DRINKINGWATER_CHANNEL = "pv-target-temperature-drinkingwater";
 }
diff --git a/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/KermiConfiguration.java b/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/KermiConfiguration.java
index dab20b767bf1d..f1401dc218f0e 100644
--- a/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/KermiConfiguration.java
+++ b/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/KermiConfiguration.java
@@ -23,4 +23,5 @@
 public class KermiConfiguration {
 
     public int refresh = 5000;
+    public boolean pvEnabled = false;
 }
diff --git a/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/dto/AlarmDTO.java b/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/dto/AlarmDTO.java
new file mode 100644
index 0000000000000..06109bc2f6100
--- /dev/null
+++ b/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/dto/AlarmDTO.java
@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.modbus.kermi.internal.dto;
+
+import static org.openhab.binding.modbus.kermi.internal.modbus.KermiModbusConstans.ALARM_REG_SIZE;
+
+import org.openhab.binding.modbus.kermi.internal.modbus.Data;
+import org.openhab.core.io.transport.modbus.ModbusBitUtilities;
+import org.openhab.core.library.types.OnOffType;
+
+/**
+ * The {@link AlarmDTO} Data object for Kermi Xcenter
+ *
+ * @author Kai Neuhaus - Initial contribution
+ */
+public class AlarmDTO implements Data {
+
+    public OnOffType alarmIsActive;
+
+    public AlarmDTO(byte[] bArray) {
+        int status = ModbusBitUtilities.extractBit(bArray, ALARM_REG_SIZE);
+        alarmIsActive = status == 0 ? OnOffType.OFF : OnOffType.ON;
+    }
+}
diff --git a/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/dto/ChargingCircuitDTO.java b/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/dto/ChargingCircuitDTO.java
new file mode 100644
index 0000000000000..57aa0af7a8445
--- /dev/null
+++ b/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/dto/ChargingCircuitDTO.java
@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.modbus.kermi.internal.dto;
+
+import static org.openhab.core.library.unit.Units.LITRE_PER_MINUTE;
+
+import javax.measure.quantity.Temperature;
+
+import org.openhab.binding.modbus.kermi.internal.modbus.Data;
+import org.openhab.core.io.transport.modbus.ValueBuffer;
+import org.openhab.core.library.dimension.VolumetricFlowRate;
+import org.openhab.core.library.types.QuantityType;
+import org.openhab.core.library.unit.SIUnits;
+
+/**
+ * The {@link ChargingCircuitDTO} Data object for Kermi Xcenter
+ *
+ * @author Kai Neuhaus - Initial contribution
+ */
+public class ChargingCircuitDTO implements Data {
+
+    public QuantityType<Temperature> flowTemperature;
+    public QuantityType<Temperature> returnFlowTemperature;
+    public QuantityType<VolumetricFlowRate> flowSpeed;
+
+    public ChargingCircuitDTO(byte[] bArray) {
+        ValueBuffer wrap = ValueBuffer.wrap(bArray);
+        flowTemperature = QuantityType.valueOf(DataConverter.getUDoubleValue(wrap, 0.1), SIUnits.CELSIUS);
+        returnFlowTemperature = QuantityType.valueOf(DataConverter.getUDoubleValue(wrap, 0.1), SIUnits.CELSIUS);
+        flowSpeed = QuantityType.valueOf(DataConverter.getUDoubleValue(wrap, 0.1), LITRE_PER_MINUTE);
+    }
+}
diff --git a/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/dto/EnergySourceDTO.java b/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/dto/EnergySourceDTO.java
new file mode 100644
index 0000000000000..d55893670618c
--- /dev/null
+++ b/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/dto/EnergySourceDTO.java
@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.modbus.kermi.internal.dto;
+
+import javax.measure.quantity.Temperature;
+
+import org.openhab.binding.modbus.kermi.internal.modbus.Data;
+import org.openhab.core.io.transport.modbus.ValueBuffer;
+import org.openhab.core.library.types.QuantityType;
+import org.openhab.core.library.unit.SIUnits;
+
+/**
+ * The {@link EnergySourceDTO} Data object for Kermi Xcenter
+ *
+ * @author Kai Neuhaus - Initial contribution
+ */
+public class EnergySourceDTO implements Data {
+
+    public QuantityType<Temperature> exitTemperature;
+    public QuantityType<Temperature> incomingTemperature;
+    public QuantityType<Temperature> outsideTemperature;
+
+    public EnergySourceDTO(byte[] bArray) {
+        ValueBuffer wrap = ValueBuffer.wrap(bArray);
+        exitTemperature = QuantityType.valueOf(DataConverter.getUDoubleValue(wrap, 0.1), SIUnits.CELSIUS);
+        incomingTemperature = QuantityType.valueOf(DataConverter.getUDoubleValue(wrap, 0.1), SIUnits.CELSIUS);
+        outsideTemperature = QuantityType.valueOf(DataConverter.getUDoubleValue(wrap, 0.1), SIUnits.CELSIUS);
+    }
+}
diff --git a/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/dto/PowerDTO.java b/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/dto/PowerDTO.java
new file mode 100644
index 0000000000000..2ce4bba818053
--- /dev/null
+++ b/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/dto/PowerDTO.java
@@ -0,0 +1,64 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.modbus.kermi.internal.dto;
+
+import javax.measure.quantity.Power;
+
+import org.openhab.binding.modbus.kermi.internal.modbus.Data;
+import org.openhab.core.io.transport.modbus.ValueBuffer;
+import org.openhab.core.library.types.DecimalType;
+import org.openhab.core.library.types.QuantityType;
+import org.openhab.core.library.unit.Units;
+
+/**
+ * The {@link PowerDTO} Data object for Kermi Xcenter State Block
+ *
+ * @author Kai Neuhaus - Initial contribution
+ */
+public class PowerDTO implements Data {
+
+    public DecimalType cop;
+    public DecimalType copHeating;
+    public DecimalType copDrinkingwater;
+    public DecimalType copCooling;
+
+    public QuantityType<Power> power;
+    public QuantityType<Power> powerHeating;
+    public QuantityType<Power> powerDrinkingwater;
+    public QuantityType<Power> powerCooling;
+
+    public QuantityType<Power> electricPower;
+    public QuantityType<Power> electricPowerHeating;
+    public QuantityType<Power> electricPowerDrinkingwater;
+    public QuantityType<Power> electricPowerCooling;
+
+    public PowerDTO(byte[] bArray) {
+
+        ValueBuffer wrap = ValueBuffer.wrap(bArray);
+
+        cop = new DecimalType(DataConverter.getUDoubleValue(wrap, 0.1));
+        copHeating = new DecimalType(DataConverter.getUDoubleValue(wrap, 0.1));
+        copDrinkingwater = new DecimalType(DataConverter.getUDoubleValue(wrap, 0.1));
+        copCooling = new DecimalType(DataConverter.getUDoubleValue(wrap, 0.1));
+
+        power = QuantityType.valueOf(DataConverter.getUDoubleValue(wrap, 100), Units.WATT);
+        powerHeating = QuantityType.valueOf(DataConverter.getUDoubleValue(wrap, 100), Units.WATT);
+        powerDrinkingwater = QuantityType.valueOf(DataConverter.getUDoubleValue(wrap, 100), Units.WATT);
+        powerCooling = QuantityType.valueOf(DataConverter.getUDoubleValue(wrap, 100), Units.WATT);
+
+        electricPower = QuantityType.valueOf(DataConverter.getUDoubleValue(wrap, 100), Units.WATT);
+        electricPowerHeating = QuantityType.valueOf(DataConverter.getUDoubleValue(wrap, 100), Units.WATT);
+        electricPowerDrinkingwater = QuantityType.valueOf(DataConverter.getUDoubleValue(wrap, 100), Units.WATT);
+        electricPowerCooling = QuantityType.valueOf(DataConverter.getUDoubleValue(wrap, 100), Units.WATT);
+    }
+}
diff --git a/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/dto/PvDTO.java b/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/dto/PvDTO.java
new file mode 100644
index 0000000000000..f6da0ab9da781
--- /dev/null
+++ b/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/dto/PvDTO.java
@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.modbus.kermi.internal.dto;
+
+import javax.measure.quantity.Power;
+import javax.measure.quantity.Temperature;
+
+import org.openhab.binding.modbus.kermi.internal.modbus.Data;
+import org.openhab.core.io.transport.modbus.ModbusBitUtilities;
+import org.openhab.core.io.transport.modbus.ValueBuffer;
+import org.openhab.core.library.types.OnOffType;
+import org.openhab.core.library.types.QuantityType;
+import org.openhab.core.library.unit.SIUnits;
+import org.openhab.core.library.unit.Units;
+
+/**
+ * The {@link PvDTO} Data object for Kermi Xcenter
+ *
+ * @author Kai Neuhaus - Initial contribution
+ */
+public class PvDTO implements Data {
+
+    public OnOffType pvModulationActive;
+    public QuantityType<Power> pvModulationPower;
+    public QuantityType<Temperature> pvTargetTemperatureHeating;
+    public QuantityType<Temperature> pvTargetTemperatureDrinkingwater;
+
+    public PvDTO(byte[] bArray) {
+
+        int modActive = ModbusBitUtilities.extractBit(bArray, 0);
+        pvModulationActive = modActive == 0 ? OnOffType.OFF : OnOffType.ON;
+
+        ValueBuffer wrap = ValueBuffer.wrap(bArray);
+        // skip first bit -> modActive-Value
+        wrap.position(2);
+
+        pvModulationPower = QuantityType.valueOf(DataConverter.getUDoubleValue(wrap, 0.1), Units.WATT);
+        pvTargetTemperatureHeating = QuantityType.valueOf(DataConverter.getUDoubleValue(wrap, 0.1), SIUnits.CELSIUS);
+        pvTargetTemperatureDrinkingwater = QuantityType.valueOf(DataConverter.getUDoubleValue(wrap, 0.1),
+                SIUnits.CELSIUS);
+    }
+}
diff --git a/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/dto/StateDTO.java b/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/dto/StateDTO.java
index 6e63eb339e7f3..e9ad4adad100f 100644
--- a/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/dto/StateDTO.java
+++ b/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/dto/StateDTO.java
@@ -18,14 +18,14 @@
 import org.openhab.core.library.types.StringType;
 
 /**
- * The {@link StateDTO} Data object for Kermi Xcenter State Block
+ * The {@link StateDTO} Data object for Kermi Xcenter
  *
  * @author Kai Neuhaus - Initial contribution
  */
 public class StateDTO implements Data {
 
-    public StringType globalState = STATE_UNKOWN;
-    public DecimalType globalStateId = new DecimalType(-1);
+    public StringType globalState;
+    public DecimalType globalStateId;
 
     // State definitions
     public static final StringType STATE_STANDBY = StringType.valueOf("Standby");
@@ -45,7 +45,7 @@ public class StateDTO implements Data {
 
     public StateDTO(byte[] bArray) {
 
-        int status = ModbusBitUtilities.extractUInt16(bArray, 0);
+        int status = ModbusBitUtilities.extractBit(bArray, 0);
 
         globalStateId = new DecimalType(status);
 
@@ -54,11 +54,5 @@ public StateDTO(byte[] bArray) {
         } else {
             globalState = STATE_UNKOWN;
         }
-        //
-        // // index handling to calculate the correct start index
-        // ValueBuffer wrap = ValueBuffer.wrap(bArray);
-        //
-        // // int32_swap value = 4 byte
-        // int globalState = wrap.getUInt16();
     }
 }
diff --git a/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/dto/WorkHoursDTO.java b/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/dto/WorkHoursDTO.java
new file mode 100644
index 0000000000000..f3bb44d99616a
--- /dev/null
+++ b/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/dto/WorkHoursDTO.java
@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.modbus.kermi.internal.dto;
+
+import javax.measure.quantity.Time;
+
+import org.openhab.binding.modbus.kermi.internal.modbus.Data;
+import org.openhab.core.io.transport.modbus.ValueBuffer;
+import org.openhab.core.library.types.QuantityType;
+import org.openhab.core.library.unit.Units;
+
+/**
+ * The {@link WorkHoursDTO} Data object for Kermi Xcenter State Block
+ *
+ * @author Kai Neuhaus - Initial contribution
+ */
+public class WorkHoursDTO implements Data {
+
+    public QuantityType<Time> workHoursFan;
+    public QuantityType<Time> workHoursStorageLoadingPump;
+    public QuantityType<Time> workHoursCompressor;
+
+    public WorkHoursDTO(byte[] bArray) {
+
+        ValueBuffer wrap = ValueBuffer.wrap(bArray);
+
+        workHoursFan = QuantityType.valueOf(DataConverter.getUDoubleValue(wrap, 0.1), Units.HOUR);
+        workHoursStorageLoadingPump = QuantityType.valueOf(DataConverter.getUDoubleValue(wrap, 0.1), Units.HOUR);
+        workHoursCompressor = QuantityType.valueOf(DataConverter.getUDoubleValue(wrap, 0.1), Units.HOUR);
+    }
+}
diff --git a/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/handler/KermiXcenterThingHandler.java b/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/handler/KermiXcenterThingHandler.java
index b898f8f768a2a..f4039762e7215 100644
--- a/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/handler/KermiXcenterThingHandler.java
+++ b/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/handler/KermiXcenterThingHandler.java
@@ -12,12 +12,53 @@
  */
 package org.openhab.binding.modbus.kermi.internal.handler;
 
+import static org.openhab.binding.modbus.kermi.internal.KermiBindingConstants.ALARM_STATE_CHANNEL;
+import static org.openhab.binding.modbus.kermi.internal.KermiBindingConstants.COP_CHANNEL;
+import static org.openhab.binding.modbus.kermi.internal.KermiBindingConstants.COP_COOLING_CHANNEL;
+import static org.openhab.binding.modbus.kermi.internal.KermiBindingConstants.COP_DRINKINGWATER_CHANNEL;
+import static org.openhab.binding.modbus.kermi.internal.KermiBindingConstants.COP_HEATING_CHANNEL;
+import static org.openhab.binding.modbus.kermi.internal.KermiBindingConstants.ELECTRIC_POWER_CHANNEL;
+import static org.openhab.binding.modbus.kermi.internal.KermiBindingConstants.ELECTRIC_POWER_COOLING_CHANNEL;
+import static org.openhab.binding.modbus.kermi.internal.KermiBindingConstants.ELECTRIC_POWER_DRINKINGWATER_CHANNEL;
+import static org.openhab.binding.modbus.kermi.internal.KermiBindingConstants.ELECTRIC_POWER_HEATING_CHANNEL;
+import static org.openhab.binding.modbus.kermi.internal.KermiBindingConstants.EXIT_TEMPERATURE_CHANNEL;
+import static org.openhab.binding.modbus.kermi.internal.KermiBindingConstants.FLOW_SPEED_CHANNEL;
+import static org.openhab.binding.modbus.kermi.internal.KermiBindingConstants.FLOW_TEMPERATURE_CHANNEL;
 import static org.openhab.binding.modbus.kermi.internal.KermiBindingConstants.GLOBAL_STATE_CHANNEL;
 import static org.openhab.binding.modbus.kermi.internal.KermiBindingConstants.GLOBAL_STATE_ID_CHANNEL;
+import static org.openhab.binding.modbus.kermi.internal.KermiBindingConstants.INCOMING_TEMPERATURE_CHANNEL;
+import static org.openhab.binding.modbus.kermi.internal.KermiBindingConstants.POWER_CHANNEL;
+import static org.openhab.binding.modbus.kermi.internal.KermiBindingConstants.POWER_COOLING_CHANNEL;
+import static org.openhab.binding.modbus.kermi.internal.KermiBindingConstants.POWER_DRINKINGWATER_CHANNEL;
+import static org.openhab.binding.modbus.kermi.internal.KermiBindingConstants.POWER_HEATING_CHANNEL;
+import static org.openhab.binding.modbus.kermi.internal.KermiBindingConstants.PV_POWER_CHANNEL;
+import static org.openhab.binding.modbus.kermi.internal.KermiBindingConstants.PV_STATE_CHANNEL;
+import static org.openhab.binding.modbus.kermi.internal.KermiBindingConstants.PV_TARGET_TEMPERATURE_DRINKINGWATER_CHANNEL;
+import static org.openhab.binding.modbus.kermi.internal.KermiBindingConstants.PV_TARGET_TEMPERATURE_HEATING_CHANNEL;
+import static org.openhab.binding.modbus.kermi.internal.KermiBindingConstants.RETURN_TEMPERATURE_CHANNEL;
+import static org.openhab.binding.modbus.kermi.internal.KermiBindingConstants.TEMPERATURE_SENSOR_OUTSIDE_CHANNEL;
+import static org.openhab.binding.modbus.kermi.internal.KermiBindingConstants.WORKHOURS_COMPRESSOR_CHANNEL;
+import static org.openhab.binding.modbus.kermi.internal.KermiBindingConstants.WORKHOURS_FAN_CHANNEL;
+import static org.openhab.binding.modbus.kermi.internal.KermiBindingConstants.WORKHOURS_STORAGE_LOADING_PUMP_CHANNEL;
+import static org.openhab.binding.modbus.kermi.internal.modbus.KermiModbusConstans.ALARM_REG_SIZE;
+import static org.openhab.binding.modbus.kermi.internal.modbus.KermiModbusConstans.ALARM_REG_START;
+import static org.openhab.binding.modbus.kermi.internal.modbus.KermiModbusConstans.CHARGING_CIRCUIT_REG_SIZE;
+import static org.openhab.binding.modbus.kermi.internal.modbus.KermiModbusConstans.CHARGING_CIRCUIT_REG_START;
+import static org.openhab.binding.modbus.kermi.internal.modbus.KermiModbusConstans.ENERGY_SOURCE_REG_SIZE;
+import static org.openhab.binding.modbus.kermi.internal.modbus.KermiModbusConstans.ENERGY_SOURCE_REG_START;
+import static org.openhab.binding.modbus.kermi.internal.modbus.KermiModbusConstans.POWER_REG_SIZE;
+import static org.openhab.binding.modbus.kermi.internal.modbus.KermiModbusConstans.POWER_REG_START;
+import static org.openhab.binding.modbus.kermi.internal.modbus.KermiModbusConstans.PV_MODULATION_REG_SIZE;
+import static org.openhab.binding.modbus.kermi.internal.modbus.KermiModbusConstans.PV_MODULATION_REG_START;
+import static org.openhab.binding.modbus.kermi.internal.modbus.KermiModbusConstans.SLOW_POLL_REFRESH_TIME_MS;
 import static org.openhab.binding.modbus.kermi.internal.modbus.KermiModbusConstans.STATE_POLL_REFRESH_TIME_MS;
 import static org.openhab.binding.modbus.kermi.internal.modbus.KermiModbusConstans.STATE_REG_SIZE;
 import static org.openhab.binding.modbus.kermi.internal.modbus.KermiModbusConstans.STATE_REG_START;
+import static org.openhab.binding.modbus.kermi.internal.modbus.KermiModbusConstans.WORK_HOURS_REG_SIZE;
+import static org.openhab.binding.modbus.kermi.internal.modbus.KermiModbusConstans.WORK_HOURS_REG_START;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Optional;
 
 import org.eclipse.jdt.annotation.NonNullByDefault;
@@ -25,7 +66,13 @@
 import org.openhab.binding.modbus.handler.EndpointNotInitializedException;
 import org.openhab.binding.modbus.handler.ModbusEndpointThingHandler;
 import org.openhab.binding.modbus.kermi.internal.KermiConfiguration;
+import org.openhab.binding.modbus.kermi.internal.dto.AlarmDTO;
+import org.openhab.binding.modbus.kermi.internal.dto.ChargingCircuitDTO;
+import org.openhab.binding.modbus.kermi.internal.dto.EnergySourceDTO;
+import org.openhab.binding.modbus.kermi.internal.dto.PowerDTO;
+import org.openhab.binding.modbus.kermi.internal.dto.PvDTO;
 import org.openhab.binding.modbus.kermi.internal.dto.StateDTO;
+import org.openhab.binding.modbus.kermi.internal.dto.WorkHoursDTO;
 import org.openhab.binding.modbus.kermi.internal.modbus.Data;
 import org.openhab.binding.modbus.kermi.internal.modbus.Parser;
 import org.openhab.core.io.transport.modbus.AsyncModbusFailure;
@@ -52,30 +99,99 @@
  */
 @NonNullByDefault
 public class KermiXcenterThingHandler extends BaseBridgeHandler {
+
     public enum ReadStatus {
         NOT_RECEIVED,
         READ_SUCCESS,
         READ_FAILED
     }
 
-    static final String INFO_DATA_READ_ERROR = "Information And Data Modbus Read Errors";
-    static final String INFO_READ_ERROR = "Information Modbus Read Error";
+    static final String STATE_AND_ALARM_READ_ERRORS = "Status And Alarm Modbus Read Errors";
+    static final String STATE_READ_ERROR = "Information Modbus Read Error";
     static final String DATA_READ_ERROR = "Data Modbus Read Error";
+    static final String PV_READ_ERROR = "PV Modbus Read Error";
 
+    static final String ALARM_GROUP = "xcenter-alarm";
     static final String STATE_GROUP = "xcenter-state";
-
+    static final String ENERGYSOURCE_GROUP = "xcenter-energysource";
+    static final String CHARGINGCIRCUIT_GROUP = "xcenter-chargingcircuit";
+    static final String POWER_GROUP = "xcenter-power";
+    static final String WORKHOURS_GROUP = "xcenter-workhours";
+    static final String PV_GROUP = "xcenter-pvmodulation";
+
+    // Energy source
+    private ChannelUID exitTemperatureChannel;
+    private ChannelUID incomingTemperatureChannel;
+    private ChannelUID outsideTemperatureChannel;
+
+    // Charging circuit
+    private ChannelUID flowTemperatureChannel;
+    private ChannelUID returnFlowTemperatureChannel;
+    private ChannelUID flowSpeedChannel;
+
+    // Power
+    private ChannelUID copChannel;
+    private ChannelUID copHeatingChannel;
+    private ChannelUID copDrinkingWaterChannel;
+    private ChannelUID copCoolingChannel;
+
+    private ChannelUID powerChannel;
+    private ChannelUID powerHeatingChannel;
+    private ChannelUID powerDrinkingWaterChannel;
+    private ChannelUID powerCoolingChannel;
+
+    private ChannelUID electricPowerChannel;
+    private ChannelUID electricPowerHeatingChannel;
+    private ChannelUID electricPowerDrinkingWaterChannel;
+    private ChannelUID electricPowerCoolingChannel;
+
+    // Global State
     private ChannelUID globalStateChannel;
     private ChannelUID globalStateIdChannel;
-    // private ChannelUID globalAlarmChannel;
+
+    // Alarm State
+    private ChannelUID alarmStateChannel;
+
+    // Work hours
+    private ChannelUID workHoursFanChannel;
+    private ChannelUID workHoursStorageLoadingPumpChannel;
+    private ChannelUID workHoursCompressorChannel;
+
+    // PV Modulation
+    private ChannelUID pvStateChannel;
+    private ChannelUID pvPowerChannel;
+    private ChannelUID pvTargetTemperatureHeatingChannel; // READ-WRITE
+    private ChannelUID pvTargetTemperatureDrinkingWaterChannel; // READ-WRITE
 
     // private final ArrayList<E3DCWallboxThingHandler> listeners = new ArrayList<>();
     private final Logger logger = LoggerFactory.getLogger(KermiXcenterThingHandler.class);
-    private final Parser dataParser = new Parser(Data.DataType.DATA);
-    private ReadStatus dataRead = ReadStatus.NOT_RECEIVED;
-    private final Parser infoParser = new Parser(Data.DataType.INFO);
-    private ReadStatus infoRead = ReadStatus.NOT_RECEIVED;
-    private @Nullable PollTask infoPoller;
-    private @Nullable PollTask dataPoller;
+
+    private final Parser alarmParser = new Parser(Data.DataType.ALARM_STATE);
+    private ReadStatus alarmRead = ReadStatus.NOT_RECEIVED;
+    private final Parser chargingCircuitParser = new Parser(Data.DataType.CHARGING_CIRCUIT);
+    private ReadStatus chargingCircuitRead = ReadStatus.NOT_RECEIVED;
+    private final Parser energySourceParser = new Parser(Data.DataType.ENERGY_SOURCE);
+    private ReadStatus energySourceRead = ReadStatus.NOT_RECEIVED;
+    private final Parser powerParser = new Parser(Data.DataType.POWER);
+    private ReadStatus powerRead = ReadStatus.NOT_RECEIVED;
+    private final Parser pvParser = new Parser(Data.DataType.PV);
+    private ReadStatus pvRead = ReadStatus.NOT_RECEIVED;
+    private final Parser stateParser = new Parser(Data.DataType.STATE);
+    private ReadStatus stateRead = ReadStatus.NOT_RECEIVED;
+    private final Parser workHoursParser = new Parser(Data.DataType.WORK_HOURS);
+    private ReadStatus workHoursRead = ReadStatus.NOT_RECEIVED;
+
+    private @Nullable PollTask alarmPoller;
+    private @Nullable PollTask chargingCircuitPoller;
+    private @Nullable PollTask energySourcePoller;
+    private @Nullable PollTask powerPoller;
+    private @Nullable PollTask pvPoller;
+    private @Nullable PollTask statePoller;
+    private @Nullable PollTask workHourPoller;
+
+    private List<@Nullable PollTask> pollTasks = new ArrayList<>();
+
+    // private @Nullable PollTask testPoller;
     private @Nullable KermiConfiguration config;
 
     /**
@@ -87,8 +203,49 @@ public enum ReadStatus {
     public KermiXcenterThingHandler(Bridge thing) {
         super(thing);
 
+        // STATE
         globalStateChannel = channelUID(thing, STATE_GROUP, GLOBAL_STATE_CHANNEL);
         globalStateIdChannel = channelUID(thing, STATE_GROUP, GLOBAL_STATE_ID_CHANNEL);
+
+        alarmStateChannel = channelUID(thing, ALARM_GROUP, ALARM_STATE_CHANNEL);
+
+        // Energy source
+        exitTemperatureChannel = channelUID(thing, ENERGYSOURCE_GROUP, EXIT_TEMPERATURE_CHANNEL);
+        incomingTemperatureChannel = channelUID(thing, ENERGYSOURCE_GROUP, INCOMING_TEMPERATURE_CHANNEL);
+        outsideTemperatureChannel = channelUID(thing, ENERGYSOURCE_GROUP, TEMPERATURE_SENSOR_OUTSIDE_CHANNEL);
+
+        // Loading circuit
+        flowTemperatureChannel = channelUID(thing, CHARGINGCIRCUIT_GROUP, FLOW_TEMPERATURE_CHANNEL);
+        returnFlowTemperatureChannel = channelUID(thing, CHARGINGCIRCUIT_GROUP, RETURN_TEMPERATURE_CHANNEL);
+        flowSpeedChannel = channelUID(thing, CHARGINGCIRCUIT_GROUP, FLOW_SPEED_CHANNEL);
+
+        // Power
+        copChannel = channelUID(thing, POWER_GROUP, COP_CHANNEL);
+        copHeatingChannel = channelUID(thing, POWER_GROUP, COP_HEATING_CHANNEL);
+        copDrinkingWaterChannel = channelUID(thing, POWER_GROUP, COP_DRINKINGWATER_CHANNEL);
+        copCoolingChannel = channelUID(thing, POWER_GROUP, COP_COOLING_CHANNEL);
+
+        powerChannel = channelUID(thing, POWER_GROUP, POWER_CHANNEL);
+        powerHeatingChannel = channelUID(thing, POWER_GROUP, POWER_HEATING_CHANNEL);
+        powerDrinkingWaterChannel = channelUID(thing, POWER_GROUP, POWER_DRINKINGWATER_CHANNEL);
+        powerCoolingChannel = channelUID(thing, POWER_GROUP, POWER_COOLING_CHANNEL);
+
+        electricPowerChannel = channelUID(thing, POWER_GROUP, ELECTRIC_POWER_CHANNEL);
+        electricPowerHeatingChannel = channelUID(thing, POWER_GROUP, ELECTRIC_POWER_HEATING_CHANNEL);
+        electricPowerDrinkingWaterChannel = channelUID(thing, POWER_GROUP, ELECTRIC_POWER_DRINKINGWATER_CHANNEL);
+        electricPowerCoolingChannel = channelUID(thing, POWER_GROUP, ELECTRIC_POWER_COOLING_CHANNEL);
+
+        // Work hours
+        workHoursFanChannel = channelUID(thing, WORKHOURS_GROUP, WORKHOURS_FAN_CHANNEL);
+        workHoursStorageLoadingPumpChannel = channelUID(thing, WORKHOURS_GROUP, WORKHOURS_STORAGE_LOADING_PUMP_CHANNEL);
+        workHoursCompressorChannel = channelUID(thing, WORKHOURS_GROUP, WORKHOURS_COMPRESSOR_CHANNEL);
+
+        // PV Modulation
+        pvStateChannel = channelUID(thing, PV_GROUP, PV_STATE_CHANNEL);
+        pvPowerChannel = channelUID(thing, PV_GROUP, PV_POWER_CHANNEL);
+        pvTargetTemperatureHeatingChannel = channelUID(thing, PV_GROUP, PV_TARGET_TEMPERATURE_HEATING_CHANNEL); // READ-WRITE
+        pvTargetTemperatureDrinkingWaterChannel = channelUID(thing, PV_GROUP,
+                PV_TARGET_TEMPERATURE_DRINKINGWATER_CHANNEL); // READ-WRITE
     }
 
     public @Nullable ModbusCommunicationInterface getComms() {
@@ -110,24 +267,78 @@ public void initialize() {
         scheduler.execute(() -> {
             KermiConfiguration localConfig = getConfigAs(KermiConfiguration.class);
             config = localConfig;
+
+            if (config == null) {
+                updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.CONFIGURATION_ERROR, "Kermi Configuration missing");
+                return;
+            }
             ModbusCommunicationInterface localComms = connectEndpoint();
             if (localComms != null) {
-                // register low speed info poller
-                ModbusReadRequestBlueprint infoRequest = new ModbusReadRequestBlueprint(slaveId,
+
+                // very slow requests
+                ModbusReadRequestBlueprint workHoursRequest = new ModbusReadRequestBlueprint(slaveId,
+                        ModbusReadFunctionCode.READ_MULTIPLE_REGISTERS, WORK_HOURS_REG_START, WORK_HOURS_REG_SIZE, 3);
+                workHourPoller = localComms.registerRegularPoll(workHoursRequest, SLOW_POLL_REFRESH_TIME_MS, 0,
+                        this::handleWorkHoursResult, this::handleWorkHoursFailure);
+
+                pollTasks.add(workHourPoller);
+
+                // register low speed state & alarm poller
+                ModbusReadRequestBlueprint alarmRequest = new ModbusReadRequestBlueprint(slaveId,
+                        ModbusReadFunctionCode.READ_MULTIPLE_REGISTERS, ALARM_REG_START, ALARM_REG_SIZE, 3);
+                alarmPoller = localComms.registerRegularPoll(alarmRequest, STATE_POLL_REFRESH_TIME_MS, 0,
+                        this::handleAlarmResult, this::handleAlarmFailure);
+
+                pollTasks.add(alarmPoller);
+
+                ModbusReadRequestBlueprint stateRequest = new ModbusReadRequestBlueprint(slaveId,
                         ModbusReadFunctionCode.READ_MULTIPLE_REGISTERS, STATE_REG_START, STATE_REG_SIZE, 3);
-                infoPoller = localComms.registerRegularPoll(infoRequest, STATE_POLL_REFRESH_TIME_MS, 0,
-                        this::handleInfoResult, this::handleInfoFailure);
-
-                // ModbusReadRequestBlueprint dataRequest = new ModbusReadRequestBlueprint(slaveId,
-                // ModbusReadFunctionCode.READ_MULTIPLE_REGISTERS, POWER_REG_START,
-                // REGISTER_LENGTH - INFO_REG_SIZE, 3);
-                // if (config != null) {
-                // dataPoller = localComms.registerRegularPoll(dataRequest, localConfig.refresh, 0,
-                // this::handleDataResult, this::handleDataFailure);
-                // } else {
-                // updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.CONFIGURATION_ERROR,
-                // "E3DC Configuration missing");
-                // }
+                statePoller = localComms.registerRegularPoll(stateRequest, STATE_POLL_REFRESH_TIME_MS, 0,
+                        this::handleStateResult, this::handleStateFailure);
+
+                pollTasks.add(statePoller);
+
+                // default polling speed
+                ModbusReadRequestBlueprint chargingcircuitRequest = new ModbusReadRequestBlueprint(slaveId,
+                        ModbusReadFunctionCode.READ_MULTIPLE_REGISTERS, CHARGING_CIRCUIT_REG_START,
+                        CHARGING_CIRCUIT_REG_SIZE, 3);
+                chargingCircuitPoller = localComms.registerRegularPoll(chargingcircuitRequest, localConfig.refresh, 0,
+                        this::handleChargingCircuitResult, this::handleChargingCircuitFailure);
+
+                pollTasks.add(chargingCircuitPoller);
+
+                ModbusReadRequestBlueprint energySourceRequest = new ModbusReadRequestBlueprint(slaveId,
+                        ModbusReadFunctionCode.READ_MULTIPLE_REGISTERS, ENERGY_SOURCE_REG_START, ENERGY_SOURCE_REG_SIZE,
+                        3);
+                energySourcePoller = localComms.registerRegularPoll(energySourceRequest, localConfig.refresh, 0,
+                        this::handleEnergySourceResult, this::handleEnergySourceFailure);
+
+                pollTasks.add(energySourcePoller);
+
+                ModbusReadRequestBlueprint powerRequest = new ModbusReadRequestBlueprint(slaveId,
+                        ModbusReadFunctionCode.READ_MULTIPLE_REGISTERS, POWER_REG_START, POWER_REG_SIZE, 3);
+                powerPoller = localComms.registerRegularPoll(powerRequest, localConfig.refresh, 0,
+                        this::handlePowerResult, this::handlePowerFailure);
+
+                pollTasks.add(powerPoller);
+
+                if (localConfig.pvEnabled) {
+                    ModbusReadRequestBlueprint pvRequest = new ModbusReadRequestBlueprint(slaveId,
+                            ModbusReadFunctionCode.READ_MULTIPLE_REGISTERS, PV_MODULATION_REG_START,
+                            PV_MODULATION_REG_SIZE, 3);
+                    pvPoller = localComms.registerRegularPoll(pvRequest, localConfig.refresh, 0, this::handlePvResult,
+                            this::handlePvFailure);
+
+                    pollTasks.add(pvPoller);
+                }
+
+                /*
+                 * ModbusReadRequestBlueprint testPollerRequest = new ModbusReadRequestBlueprint(slaveId,
+                 * ModbusReadFunctionCode.READ_MULTIPLE_REGISTERS, 1, 111, 3);
+                 * testPoller = localComms.registerRegularPoll(testPollerRequest, SLOW_POLL_REFRESH_TIME_MS, 0,
+                 * this::handleTestPollerResult, this::handleTestPollerFailure);
+                 */
+
             } // else state handling performed in connectEndPoint function
         });
     }
@@ -201,121 +412,127 @@ public void initialize() {
     /**
      * Returns the channel UID for the specified group and channel id
      *
-     * @param string the channel group
-     * @param string the channel id in that group
+     * @param group String of channel group
+     * @param id String the channel id in that group
      * @return the globally unique channel uid
      */
     private ChannelUID channelUID(Thing t, String group, String id) {
         return new ChannelUID(t.getUID(), group, id);
     }
 
-    void handleInfoResult(AsyncModbusReadResult result) {
-        if (infoRead != ReadStatus.READ_SUCCESS) {
+    /******** Start ResultHandler *****************/
+
+    private void handleAlarmResult(AsyncModbusReadResult result) {
+        if (alarmRead != ReadStatus.READ_SUCCESS) {
+            // update status only if bit switches
+            alarmRead = ReadStatus.READ_SUCCESS;
+            updateStatus();
+        }
+        alarmParser.handle(result);
+        Optional<Data> dtoOpt = alarmParser.parse(Data.DataType.ALARM_STATE);
+        if (dtoOpt.isPresent()) {
+            AlarmDTO alarmDTO = (AlarmDTO) dtoOpt.get();
+            updateState(alarmStateChannel, alarmDTO.alarmIsActive);
+        } else {
+            logger.debug("Unable to get {} from provider {}", Data.DataType.ALARM_STATE, alarmParser.toString());
+        }
+    }
+
+    private void handleAlarmFailure(AsyncModbusFailure<ModbusReadRequestBlueprint> result) {
+        if (alarmRead != ReadStatus.READ_FAILED) {
+            // update status only if bit switches
+            alarmRead = ReadStatus.READ_FAILED;
+            logger.debug("Cause of failure: {}", result.getCause().getMessage());
+            updateStatus();
+        }
+    }
+
+    private void handleChargingCircuitResult(AsyncModbusReadResult result) {
+        if (chargingCircuitRead != ReadStatus.READ_SUCCESS) {
             // update status only if bit switches
-            infoRead = ReadStatus.READ_SUCCESS;
+            chargingCircuitRead = ReadStatus.READ_SUCCESS;
             updateStatus();
         }
-        infoParser.handle(result);
-        Optional<Data> dtoOpt = infoParser.parse(Data.DataType.INFO);
+        chargingCircuitParser.handle(result);
+        Optional<Data> dtoOpt = chargingCircuitParser.parse(Data.DataType.CHARGING_CIRCUIT);
         if (dtoOpt.isPresent()) {
-            StateDTO dto = (StateDTO) dtoOpt.get();
-            updateState(globalStateChannel, dto.globalState);
-            updateState(globalStateIdChannel, dto.globalStateId);
-            // updateState(modbusVersionChannel, dto.modbusVersion);
-            // updateState(supportedRegistersChannel, dto.supportedRegisters);
-            // updateState(manufacturerChannel, dto.manufacturer);
-            // updateState(modelNameChannel, dto.modelName);
-            // updateState(serialNumberChannel, dto.serialNumber);
-            // updateState(firmwareChannel, dto.firmware);
+            ChargingCircuitDTO chargingCircuitDTO = (ChargingCircuitDTO) dtoOpt.get();
+            updateState(flowTemperatureChannel, chargingCircuitDTO.flowTemperature);
+            updateState(returnFlowTemperatureChannel, chargingCircuitDTO.returnFlowTemperature);
+            updateState(flowSpeedChannel, chargingCircuitDTO.flowSpeed);
+        } else {
+            logger.debug("Unable to get {} from provider {}", Data.DataType.CHARGING_CIRCUIT,
+                    chargingCircuitParser.toString());
+        }
+    }
+
+    private void handleChargingCircuitFailure(AsyncModbusFailure<ModbusReadRequestBlueprint> result) {
+        if (chargingCircuitRead != ReadStatus.READ_FAILED) {
+            // update status only if bit switches
+            chargingCircuitRead = ReadStatus.READ_FAILED;
+            logger.debug("Cause of failure: {}", result.getCause().getMessage());
+            updateStatus();
+        }
+    }
+
+    private void handleEnergySourceResult(AsyncModbusReadResult result) {
+        if (energySourceRead != ReadStatus.READ_SUCCESS) {
+            // update status only if bit switches
+            energySourceRead = ReadStatus.READ_SUCCESS;
+            updateStatus();
+        }
+        energySourceParser.handle(result);
+        Optional<Data> dtoOpt = energySourceParser.parse(Data.DataType.ENERGY_SOURCE);
+        if (dtoOpt.isPresent()) {
+            EnergySourceDTO energySourceDTO = (EnergySourceDTO) dtoOpt.get();
+            updateState(exitTemperatureChannel, energySourceDTO.exitTemperature);
+            updateState(incomingTemperatureChannel, energySourceDTO.incomingTemperature);
+            updateState(outsideTemperatureChannel, energySourceDTO.outsideTemperature);
         } else {
-            logger.debug("Unable to get {} from provider {}", Data.DataType.INFO, dataParser.toString());
+            logger.debug("Unable to get {} from provider {}", Data.DataType.ENERGY_SOURCE,
+                    energySourceParser.toString());
         }
     }
 
-    void handleInfoFailure(AsyncModbusFailure<ModbusReadRequestBlueprint> result) {
-        if (infoRead != ReadStatus.READ_FAILED) {
+    private void handleEnergySourceFailure(AsyncModbusFailure<ModbusReadRequestBlueprint> result) {
+        if (energySourceRead != ReadStatus.READ_FAILED) {
             // update status only if bit switches
-            infoRead = ReadStatus.READ_FAILED;
+            energySourceRead = ReadStatus.READ_FAILED;
+            logger.debug("Cause of failure: {}", result.getCause().getMessage());
             updateStatus();
         }
     }
 
-    void handleDataResult(AsyncModbusReadResult result) {
-        if (dataRead != ReadStatus.READ_SUCCESS) {
+    private void handlePowerResult(AsyncModbusReadResult result) {
+        if (powerRead != ReadStatus.READ_SUCCESS) {
             // update status only if bit switches
-            dataRead = ReadStatus.READ_SUCCESS;
+            powerRead = ReadStatus.READ_SUCCESS;
             updateStatus();
         }
-        dataParser.handle(result);
-        // Update channels in emergency group
-        // {
-        // Optional<Data> blockOpt = dataParser.parse(DataType.EMERGENCY);
-        // if (blockOpt.isPresent()) {
-        // EmergencyBlock block = (EmergencyBlock) blockOpt.get();
-        // updateState(epStatusChannel, block.epStatus);
-        // updateState(batteryChargingLockedChannel, block.batteryChargingLocked);
-        // updateState(batteryDischargingLockedChannel, block.batteryDischargingLocked);
-        // updateState(epPossibleChannel, block.epPossible);
-        // updateState(weatherPredictedChargingChannel, block.weatherPredictedCharging);
-        // updateState(regulationStatusChannel, block.regulationStatus);
-        // updateState(chargeLockTimeChannel, block.chargeLockTime);
-        // updateState(dischargeLockTimeChannel, block.dischargeLockTime);
-        // } else {
-        // logger.debug("Unable to get {} from provider {}", DataType.EMERGENCY, dataParser.toString());
-        // }
-        // }
-
-        // Update channels in power group
-        // {
-        // Optional<Data> blockOpt = dataParser.parse(DataType.POWER);
-        // if (blockOpt.isPresent()) {
-        // PowerBlock block = (PowerBlock) blockOpt.get();
-        // updateState(pvPowerSupplyChannel, block.pvPowerSupply);
-        // updateState(batteryPowerSupplyChannel, block.batteryPowerSupply);
-        // updateState(batteryPowerConsumptionChannel, block.batteryPowerConsumption);
-        // updateState(householdPowerConsumptionChannel, block.householdPowerConsumption);
-        // updateState(gridPowerConsumpitionChannel, block.gridPowerConsumpition);
-        // updateState(gridPowerSupplyChannel, block.gridPowerSupply);
-        // updateState(externalPowerSupplyChannel, block.externalPowerSupply);
-        // updateState(wallboxPowerConsumptionChannel, block.wallboxPowerConsumption);
-        // updateState(wallboxPVPowerConsumptionChannel, block.wallboxPVPowerConsumption);
-        // updateState(autarkyChannel, block.autarky);
-        // updateState(selfConsumptionChannel, block.selfConsumption);
-        // updateState(batterySOCChannel, block.batterySOC);
-        // if (config != null) {
-        // if (config.batteryCapacity > 0) {
-        // double soc = block.batterySOC.doubleValue();
-        // QuantityType<Energy> charged = QuantityType.valueOf(soc * config.batteryCapacity / 100,
-        // Units.KILOWATT_HOUR);
-        // updateState(batteryChargedChannel, charged);
-        // QuantityType<Energy> uncharged = QuantityType
-        // .valueOf((100 - soc) * config.batteryCapacity / 100, Units.KILOWATT_HOUR);
-        // updateState(batteryUnchargedChannel, uncharged);
-        // }
-        // }
-        // } else {
-        // logger.debug("Unable to get {} from provider {}", DataType.POWER, dataParser.toString());
-        // }
-        // }
-
-        // Update channels in strings group
-        // {
-        // Optional<Data> blockOpt = dataParser.parse(DataType.STRINGS);
-        // if (blockOpt.isPresent()) {
-        // StringBlock block = (StringBlock) blockOpt.get();
-        // updateState(string1AmpereChannel, block.string1Ampere);
-        // updateState(string1VoltChannel, block.string1Volt);
-        // updateState(string1WattChannel, block.string1Watt);
-        // updateState(string2AmpereChannel, block.string2Ampere);
-        // updateState(string2VoltChannel, block.string2Volt);
-        // updateState(string2WattChannel, block.string2Watt);
-        // updateState(string3AmpereChannel, block.string3Ampere);
-        // updateState(string3VoltChannel, block.string3Volt);
-        // updateState(string3WattChannel, block.string3Watt);
-        // } else {
-        // logger.debug("Unable to get {} from provider {}", DataType.STRINGS, dataParser.toString());
-        // }
-        // }
+        powerParser.handle(result);
+        Optional<Data> dtoOpt = powerParser.parse(Data.DataType.POWER);
+        if (dtoOpt.isPresent()) {
+            PowerDTO powerDTO = (PowerDTO) dtoOpt.get();
+
+            // TODO Implement power
+            updateState(copChannel, powerDTO.cop);
+            updateState(copHeatingChannel, powerDTO.copHeating);
+            updateState(copDrinkingWaterChannel, powerDTO.copDrinkingwater);
+            updateState(copCoolingChannel, powerDTO.copCooling);
+
+            updateState(powerChannel, powerDTO.power);
+            updateState(powerHeatingChannel, powerDTO.powerHeating);
+            updateState(powerDrinkingWaterChannel, powerDTO.powerDrinkingwater);
+            updateState(powerCoolingChannel, powerDTO.powerCooling);
+
+            updateState(electricPowerChannel, powerDTO.electricPower);
+            updateState(electricPowerHeatingChannel, powerDTO.electricPowerHeating);
+            updateState(electricPowerDrinkingWaterChannel, powerDTO.electricPowerDrinkingwater);
+            updateState(electricPowerCoolingChannel, powerDTO.electricPowerCooling);
+
+        } else {
+            logger.debug("Unable to get {} from provider {}", Data.DataType.POWER, powerParser.toString());
+        }
 
         // Reactivate when KermiKomponents are included / implemented
         // listeners.forEach(l -> {
@@ -323,10 +540,11 @@ void handleDataResult(AsyncModbusReadResult result) {
         // });
     }
 
-    void handleDataFailure(AsyncModbusFailure<ModbusReadRequestBlueprint> result) {
-        if (dataRead != ReadStatus.READ_FAILED) {
+    private void handlePowerFailure(AsyncModbusFailure<ModbusReadRequestBlueprint> result) {
+        if (powerRead != ReadStatus.READ_FAILED) {
             // update status only if bit switches
-            dataRead = ReadStatus.READ_FAILED;
+            powerRead = ReadStatus.READ_FAILED;
+            logger.debug("Cause of failure: {}", result.getCause().getMessage());
             updateStatus();
         }
         // Reactivate when KermiKomponents are included / implemented
@@ -335,46 +553,132 @@ void handleDataFailure(AsyncModbusFailure<ModbusReadRequestBlueprint> result) {
         // });
     }
 
+    private void handlePvResult(AsyncModbusReadResult result) {
+        if (pvRead != ReadStatus.READ_SUCCESS) {
+            // update status only if bit switches
+            pvRead = ReadStatus.READ_SUCCESS;
+            updateStatus();
+        }
+        pvParser.handle(result);
+        Optional<Data> dtoOpt = pvParser.parse(Data.DataType.PV);
+        if (dtoOpt.isPresent()) {
+            PvDTO pvDTO = (PvDTO) dtoOpt.get();
+            updateState(pvStateChannel, pvDTO.pvModulationActive);
+            updateState(pvPowerChannel, pvDTO.pvModulationPower);
+            updateState(pvTargetTemperatureHeatingChannel, pvDTO.pvTargetTemperatureHeating);
+            updateState(pvTargetTemperatureDrinkingWaterChannel, pvDTO.pvTargetTemperatureDrinkingwater);
+        } else {
+            logger.debug("Unable to get {} from provider {}", Data.DataType.PV, pvParser.toString());
+        }
+    }
+
+    private void handlePvFailure(AsyncModbusFailure<ModbusReadRequestBlueprint> result) {
+        if (pvRead != ReadStatus.READ_FAILED) {
+            // update status only if bit switches
+            pvRead = ReadStatus.READ_FAILED;
+            logger.debug("Cause of failure: {}", result.getCause().getMessage());
+            updateStatus();
+        }
+    }
+
+    void handleStateResult(AsyncModbusReadResult result) {
+        if (stateRead != ReadStatus.READ_SUCCESS) {
+            // update status only if bit switches
+            stateRead = ReadStatus.READ_SUCCESS;
+            updateStatus();
+        }
+        stateParser.handle(result);
+        Optional<Data> dtoOpt = stateParser.parse(Data.DataType.STATE);
+        if (dtoOpt.isPresent()) {
+            StateDTO dto = (StateDTO) dtoOpt.get();
+            updateState(globalStateChannel, dto.globalState);
+            updateState(globalStateIdChannel, dto.globalStateId);
+        } else {
+            logger.debug("Unable to get {} from provider {}", Data.DataType.STATE, stateParser.toString());
+        }
+    }
+
+    void handleStateFailure(AsyncModbusFailure<ModbusReadRequestBlueprint> result) {
+        if (stateRead != ReadStatus.READ_FAILED) {
+            // update status only if bit switches
+            stateRead = ReadStatus.READ_FAILED;
+            logger.debug("Cause of failure: {}", result.getCause().getMessage());
+            updateStatus();
+        }
+    }
+
+    private void handleWorkHoursResult(AsyncModbusReadResult result) {
+        workHoursParser.handle(result);
+        Optional<Data> dtoOpt = workHoursParser.parse(Data.DataType.WORK_HOURS);
+        if (dtoOpt.isPresent()) {
+            WorkHoursDTO dto = (WorkHoursDTO) dtoOpt.get();
+            updateState(workHoursFanChannel, dto.workHoursFan);
+            updateState(workHoursStorageLoadingPumpChannel, dto.workHoursStorageLoadingPump);
+            updateState(workHoursCompressorChannel, dto.workHoursCompressor);
+        } else {
+            logger.debug("Unable to get {} from provider {}", Data.DataType.WORK_HOURS, workHoursParser.toString());
+        }
+    }
+
+    private void handleWorkHoursFailure(AsyncModbusFailure<ModbusReadRequestBlueprint> result) {
+        if (workHoursRead != ReadStatus.READ_FAILED) {
+            // update status only if bit switches
+            workHoursRead = ReadStatus.READ_FAILED;
+            logger.debug("Cause of failure: {}", result.getCause().getMessage());
+            updateStatus();
+        }
+    }
+
     @Override
     public void dispose() {
         ModbusCommunicationInterface localComms = comms;
         if (localComms != null) {
-            PollTask localInfoPoller = infoPoller;
-            if (localInfoPoller != null) {
-                localComms.unregisterRegularPoll(localInfoPoller);
-            }
-            PollTask localDataPoller = dataPoller;
-            if (localDataPoller != null) {
-                localComms.unregisterRegularPoll(localDataPoller);
+            for (PollTask p : pollTasks) {
+                PollTask localPoller = p;
+                if (localPoller != null) {
+                    localComms.unregisterRegularPoll(localPoller);
+                }
             }
+            /*
+             * PollTask localInfoPoller = statePoller;
+             * if (localInfoPoller != null) {
+             * localComms.unregisterRegularPoll(localInfoPoller);
+             * }
+             * PollTask localDataPoller = dataPoller;
+             * if (localDataPoller != null) {
+             * localComms.unregisterRegularPoll(localDataPoller);
+             * }
+             */
         }
         // Comms will be close()'d by endpoint thing handler
         comms = null;
     }
 
     private void updateStatus() {
-        logger.debug("Status update: Info {} Data {} ", infoRead, dataRead);
-        if (infoRead != ReadStatus.NOT_RECEIVED) { // && dataRead != ReadStatus.NOT_RECEIVED
-            if (infoRead == ReadStatus.READ_SUCCESS) {
+        logger.debug("Status update: State {} Data {} WorkHours {} PV {} ", stateRead, powerRead, workHoursRead,
+                pvRead);
+        if (stateRead != ReadStatus.NOT_RECEIVED) { // && dataRead != ReadStatus.NOT_RECEIVED
+            if (stateRead == ReadStatus.READ_SUCCESS) {
                 updateStatus(ThingStatus.ONLINE);
             } else {
-                updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR, INFO_READ_ERROR);
+                updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR, STATE_READ_ERROR);
+            }
+            if (stateRead == alarmRead) {
+                // both reads are ok or else both failed
+                if (stateRead == ReadStatus.READ_SUCCESS) {
+                    updateStatus(ThingStatus.ONLINE);
+                } else {
+                    updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR,
+                            STATE_AND_ALARM_READ_ERRORS);
+                }
+            } else {
+                // either info or data read failed - update status with details
+                if (stateRead == ReadStatus.READ_FAILED) {
+                    updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR, STATE_READ_ERROR);
+                } else {
+                    updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR, DATA_READ_ERROR);
+                }
             }
-            // if (infoRead == dataRead) {
-            // // both reads are ok or else both failed
-            // if (infoRead == ReadStatus.READ_SUCCESS) {
-            // updateStatus(ThingStatus.ONLINE);
-            // } else {
-            // updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR, INFO_DATA_READ_ERROR);
-            // }
-            // } else {
-            // // either info or data read failed - update status with details
-            // if (infoRead == ReadStatus.READ_FAILED) {
-            // updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR, INFO_READ_ERROR);
-            // } else {
-            // updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR, DATA_READ_ERROR);
-            // }
-            // }
         } // else - one status isn't received yet - wait until both Modbus polls returns either success or error
     }
 
diff --git a/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/modbus/Data.java b/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/modbus/Data.java
index 401f4a09291c8..152274d044a6a 100644
--- a/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/modbus/Data.java
+++ b/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/modbus/Data.java
@@ -22,7 +22,13 @@
 @NonNullByDefault
 public interface Data {
     enum DataType {
-        INFO,
-        DATA // marks all types besides INFO
+        STATE,
+        ALARM_STATE,
+        ENERGY_SOURCE,
+        CHARGING_CIRCUIT,
+        POWER,
+        WORK_HOURS,
+        PV,
+        DATA // marks all types besides INFO/STATE
     }
 }
diff --git a/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/modbus/KermiModbusConstans.java b/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/modbus/KermiModbusConstans.java
index 63ca2f6ed30b8..e87fcecf6a6bc 100644
--- a/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/modbus/KermiModbusConstans.java
+++ b/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/modbus/KermiModbusConstans.java
@@ -19,18 +19,21 @@
  * The numbers are taken from Kermi ExcelChart for Modbus
  * (Registers start from 0 (not 1!) so from the documented registers subtract 1)
  *
- * @author Kai Neuhaus - adapted for Kermi
+ * @author Kai Neuhaus - Initial contribution
  */
 @NonNullByDefault
 public class KermiModbusConstans {
     // "String" registers at the beginning shall be read with very low frequency - 1 hour
-    public static final int INFO_POLL_REFRESH_TIME_MS = 60 * 60 * 1000;
+    public static final int SLOW_POLL_REFRESH_TIME_MS = 60 * 60 * 1000;
 
     // poll every 30 seconds
     public static final int STATE_POLL_REFRESH_TIME_MS = 30 * 1000;
 
     // Constants where a certain Block starts and block size. Note: General offset is -1 so INFO_REG from E3DC Modbus
     // Spec starts at 1 but it's Register 0!
+    public static final int XCENTER_DATA_REG_START = 1;
+    public static final int XCENTER_DATA_REG_SIZE = 111;
+
     public static final int ENERGY_SOURCE_REG_START = 1;
     public static final int ENERGY_SOURCE_REG_SIZE = 3;
 
@@ -40,6 +43,7 @@ public class KermiModbusConstans {
     public static final int POWER_REG_START = 100;
     public static final int POWER_REG_SIZE = 12;
 
+    /** INFO BLOCK **/
     public static final int WORK_HOURS_REG_START = 150;
     public static final int WORK_HOURS_REG_SIZE = 3;
 
@@ -48,9 +52,11 @@ public class KermiModbusConstans {
 
     public static final int ALARM_REG_START = 250;
     public static final int ALARM_REG_SIZE = 1;
+    /** END INFO BLOCK **/
 
+    /** PV BLOCK **/
     public static final int PV_MODULATION_REG_START = 300;
     public static final int PV_MODULATION_REG_SIZE = 4;
 
-    public static final int REGISTER_LENGTH = 104;
+    public static final int DATA_REGISTER_LENGTH = 111;
 }
diff --git a/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/modbus/Parser.java b/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/modbus/Parser.java
index 324156e7d188b..c0bef26d767f5 100644
--- a/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/modbus/Parser.java
+++ b/bundles/org.openhab.binding.modbus.kermi/src/main/java/org/openhab/binding/modbus/kermi/internal/modbus/Parser.java
@@ -12,15 +12,25 @@
  */
 package org.openhab.binding.modbus.kermi.internal.modbus;
 
+import static org.openhab.binding.modbus.kermi.internal.modbus.KermiModbusConstans.ALARM_REG_SIZE;
+import static org.openhab.binding.modbus.kermi.internal.modbus.KermiModbusConstans.CHARGING_CIRCUIT_REG_SIZE;
+import static org.openhab.binding.modbus.kermi.internal.modbus.KermiModbusConstans.DATA_REGISTER_LENGTH;
+import static org.openhab.binding.modbus.kermi.internal.modbus.KermiModbusConstans.ENERGY_SOURCE_REG_SIZE;
 import static org.openhab.binding.modbus.kermi.internal.modbus.KermiModbusConstans.POWER_REG_SIZE;
-import static org.openhab.binding.modbus.kermi.internal.modbus.KermiModbusConstans.REGISTER_LENGTH;
+import static org.openhab.binding.modbus.kermi.internal.modbus.KermiModbusConstans.PV_MODULATION_REG_SIZE;
 import static org.openhab.binding.modbus.kermi.internal.modbus.KermiModbusConstans.STATE_REG_SIZE;
+import static org.openhab.binding.modbus.kermi.internal.modbus.KermiModbusConstans.WORK_HOURS_REG_SIZE;
 
-import java.util.Arrays;
 import java.util.Optional;
 
 import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.openhab.binding.modbus.kermi.internal.dto.AlarmDTO;
+import org.openhab.binding.modbus.kermi.internal.dto.ChargingCircuitDTO;
+import org.openhab.binding.modbus.kermi.internal.dto.EnergySourceDTO;
+import org.openhab.binding.modbus.kermi.internal.dto.PowerDTO;
+import org.openhab.binding.modbus.kermi.internal.dto.PvDTO;
 import org.openhab.binding.modbus.kermi.internal.dto.StateDTO;
+import org.openhab.binding.modbus.kermi.internal.dto.WorkHoursDTO;
 import org.openhab.binding.modbus.kermi.internal.modbus.Data.DataType;
 import org.openhab.core.io.transport.modbus.AsyncModbusReadResult;
 import org.openhab.core.io.transport.modbus.ModbusRegisterArray;
@@ -47,14 +57,32 @@ public class Parser {
 
     public Parser(DataType type) {
         callbackType = type;
-        if (type.equals(DataType.INFO)) {
-            size = STATE_REG_SIZE * 2;
+        if (type.equals(DataType.STATE)) {
+            size = (STATE_REG_SIZE) * 2;
             bArray = new byte[size];
-        } else if (type.equals(DataType.DATA)) {
+        } else if (type.equals(DataType.ENERGY_SOURCE)) {
+            size = ENERGY_SOURCE_REG_SIZE * 2;
+            bArray = new byte[size];
+        } else if (type.equals(DataType.CHARGING_CIRCUIT)) {
+            size = CHARGING_CIRCUIT_REG_SIZE * 2;
+            bArray = new byte[size];
+        } else if (type.equals(DataType.POWER)) {
             size = POWER_REG_SIZE * 2;
             bArray = new byte[size];
+        } else if (type.equals(DataType.ALARM_STATE)) {
+            size = ALARM_REG_SIZE * 2;
+            bArray = new byte[size];
+            // } else if (type.equals(DataType.DATA)) {
+            // size = XCENTER_DATA_REG_SIZE * 2;
+            // bArray = new byte[size];
+        } else if (type.equals(DataType.PV)) {
+            size = PV_MODULATION_REG_SIZE * 2;
+            bArray = new byte[size];
+        } else if (type.equals(DataType.WORK_HOURS)) {
+            size = WORK_HOURS_REG_SIZE * 2;
+            bArray = new byte[size];
         } else {
-            size = (REGISTER_LENGTH - STATE_REG_SIZE) * 2;
+            size = DATA_REGISTER_LENGTH * 2;
             bArray = new byte[size];
         }
     }
@@ -90,8 +118,20 @@ public synchronized void setArray(byte[] b) {
 
     public Optional<Data> parse(DataType type) {
         synchronized (bArray) {
-            if (type.equals(DataType.INFO) && callbackType.equals(DataType.INFO)) {
-                return Optional.of(new StateDTO(Arrays.copyOfRange(bArray, 0, STATE_REG_SIZE * 2)));
+            if (type.equals(DataType.STATE) && callbackType.equals(DataType.STATE)) {
+                return Optional.of(new StateDTO(bArray));
+            } else if (type.equals(DataType.ENERGY_SOURCE) && callbackType.equals(DataType.ENERGY_SOURCE)) {
+                return Optional.of(new EnergySourceDTO(bArray));
+            } else if (type.equals(DataType.CHARGING_CIRCUIT) && callbackType.equals(DataType.CHARGING_CIRCUIT)) {
+                return Optional.of(new ChargingCircuitDTO(bArray));
+            } else if (type.equals(DataType.POWER) && callbackType.equals(DataType.POWER)) {
+                return Optional.of(new PowerDTO(bArray));
+            } else if (type.equals(DataType.PV) && callbackType.equals(DataType.PV)) {
+                return Optional.of(new PvDTO(bArray));
+            } else if (type.equals(DataType.ALARM_STATE) && callbackType.equals(DataType.ALARM_STATE)) {
+                return Optional.of(new AlarmDTO(bArray));
+            } else if (type.equals(DataType.WORK_HOURS) && callbackType.equals(DataType.WORK_HOURS)) {
+                return Optional.of(new WorkHoursDTO(bArray));
             }
         }
         logger.warn("Wrong Block requested. Request is {} but type is {}", type, callbackType);
diff --git a/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/bridge-kermi-xcenter.xml b/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/bridge-kermi-xcenter.xml
index 440db563f849b..3827b035103ce 100644
--- a/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/bridge-kermi-xcenter.xml
+++ b/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/bridge-kermi-xcenter.xml
@@ -11,6 +11,12 @@
 		<description>Provide Energy values, String Details and general Information of your Kermi Heat Pump</description>
 		<channel-groups>
 			<channel-group id="xcenter-state" typeId="xcenter-state-values"/>
+			<channel-group id="xcenter-energysource" typeId="xcenter-energysource-values"/>
+			<channel-group id="xcenter-chargingcircuit" typeId="xcenter-chargingcircuit-values"/>
+			<channel-group id="xcenter-power" typeId="xcenter-power-values"/>
+			<channel-group id="xcenter-workhours" typeId="xcenter-workhours-values"/>
+			<channel-group id="xcenter-alarm" typeId="xcenter-alarm-values"/>
+			<channel-group id="xcenter-pvmodulation" typeId="xcenter-pvmodulation-values"/>
 		</channel-groups>
 		<config-description>
 			<parameter name="refresh" type="integer" min="1000" unit="ms">
@@ -18,6 +24,11 @@
 				<description>Refresh Rate of Xcenter values in Milliseconds</description>
 				<default>5000</default>
 			</parameter>
+			<parameter name="pvEnabled" type="boolean">
+				<label>Read PV-Modulation States</label>
+				<description>Enabled reading of PV-Modulation (disable to skip reading)</description>
+				<default>false</default>
+			</parameter>
 		</config-description>
 	</bridge-type>
 </thing:thing-descriptions>
diff --git a/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-alarm-channel-groups.xml b/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-alarm-channel-groups.xml
new file mode 100644
index 0000000000000..fc1b2fae727e1
--- /dev/null
+++ b/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-alarm-channel-groups.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<thing:thing-descriptions bindingId="modbus"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xmlns:thing="https://openhab.org/schemas/thing-description/v1.0.0"
+	xsi:schemaLocation="https://openhab.org/schemas/thing-description/v1.0.0 https://openhab.org/schemas/thing-description-1.0.0.xsd">
+	<channel-group-type id="xcenter-alarm-values">
+		<label>Alarm</label>
+		<description>Alarm State of your Kermi Heatpump X-Center</description>
+		<channels>
+			<channel id="alarm-state" typeId="alarm-state-channel"/>
+		</channels>
+	</channel-group-type>
+</thing:thing-descriptions>
diff --git a/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-alarm-channel-types.xml b/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-alarm-channel-types.xml
new file mode 100644
index 0000000000000..901fbe23ffb67
--- /dev/null
+++ b/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-alarm-channel-types.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<thing:thing-descriptions bindingId="modbus"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xmlns:thing="https://openhab.org/schemas/thing-description/v1.0.0"
+	xsi:schemaLocation="https://openhab.org/schemas/thing-description/v1.0.0 https://openhab.org/schemas/thing-description-1.0.0.xsd">
+	<channel-type id="alarm-state-channel">
+		<item-type>Boolean</item-type>
+		<label>Alarm State</label>
+		<description>Current alarm-state of your heat pump</description>
+	</channel-type>
+</thing:thing-descriptions>
diff --git a/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-chargingcircuit-channel-groups.xml b/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-chargingcircuit-channel-groups.xml
new file mode 100644
index 0000000000000..e3fbd19ee4b05
--- /dev/null
+++ b/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-chargingcircuit-channel-groups.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<thing:thing-descriptions bindingId="modbus"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xmlns:thing="https://openhab.org/schemas/thing-description/v1.0.0"
+	xsi:schemaLocation="https://openhab.org/schemas/thing-description/v1.0.0 https://openhab.org/schemas/thing-description-1.0.0.xsd">
+	<channel-group-type id="xcenter-chargingcircuit-values">
+		<label>Charging Circuit</label>
+		<description>Information about the charging circuit</description>
+		<channels>
+			<channel id="flow-temperature" typeId="flow-temperature-channel"/>
+			<channel id="return-temperature" typeId="return-temperature-channel"/>
+			<channel id="flow-speed" typeId="flow-speed-channel"/>
+		</channels>
+	</channel-group-type>
+</thing:thing-descriptions>
diff --git a/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-chargingcircuit-channel-types.xml b/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-chargingcircuit-channel-types.xml
new file mode 100644
index 0000000000000..e56ab33359206
--- /dev/null
+++ b/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-chargingcircuit-channel-types.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<thing:thing-descriptions bindingId="modbus"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xmlns:thing="https://openhab.org/schemas/thing-description/v1.0.0"
+	xsi:schemaLocation="https://openhab.org/schemas/thing-description/v1.0.0 https://openhab.org/schemas/thing-description-1.0.0.xsd">
+	<channel-type id="flow-temperature-channel">
+		<item-type>Number</item-type>
+		<label>Flow temperature</label>
+		<description>B16 - Vorlauftemperatur WP</description>
+	</channel-type>
+	<channel-type id="return-temperature-channel">
+		<item-type>Number</item-type>
+		<label>Return temperature</label>
+		<description>B17 - Rücklauftemperatur WP</description>
+	</channel-type>
+	<channel-type id="flow-speed-channel">
+		<item-type>Number</item-type>
+		<label>Flow speed </label>
+		<description>P13 - Durchfluss WP</description>
+	</channel-type>
+</thing:thing-descriptions>
diff --git a/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-energysource-channel-groups.xml b/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-energysource-channel-groups.xml
new file mode 100644
index 0000000000000..93e4c4d8fd0ae
--- /dev/null
+++ b/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-energysource-channel-groups.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<thing:thing-descriptions bindingId="modbus"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xmlns:thing="https://openhab.org/schemas/thing-description/v1.0.0"
+	xsi:schemaLocation="https://openhab.org/schemas/thing-description/v1.0.0 https://openhab.org/schemas/thing-description-1.0.0.xsd">
+	<channel-group-type id="xcenter-energysource-values">
+		<label>Energy-Source</label>
+		<description>Information about the energy-source</description>
+		<channels>
+			<channel id="exit-temperature" typeId="exit-temperature-channel"/>
+			<channel id="incoming-temperature" typeId="incoming-temperature-channel"/>
+			<channel id="temperature-sensor-outside" typeId="temperature-sensor-outside-channel"/>
+		</channels>
+	</channel-group-type>
+</thing:thing-descriptions>
diff --git a/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-energysource-channel-types.xml b/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-energysource-channel-types.xml
new file mode 100644
index 0000000000000..78cf909f33b4b
--- /dev/null
+++ b/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-energysource-channel-types.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<thing:thing-descriptions bindingId="modbus"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xmlns:thing="https://openhab.org/schemas/thing-description/v1.0.0"
+	xsi:schemaLocation="https://openhab.org/schemas/thing-description/v1.0.0 https://openhab.org/schemas/thing-description-1.0.0.xsd">
+	<channel-type id="exit-temperature-channel">
+		<item-type>Number</item-type>
+		<label>Exit temperature</label>
+		<description>B14 - Energiequelle Austrittstemperatur</description>
+	</channel-type>
+	<channel-type id="incoming-temperature-channel">
+		<item-type>Number</item-type>
+		<label>Incoming temperature</label>
+		<description>B15 - Energiequelle Eintrittstemperatur</description>
+	</channel-type>
+	<channel-type id="temperature-sensor-outside-channel">
+		<item-type>Number</item-type>
+		<label>Temperature Outside</label>
+		<description>BOT - Außentemperaturfühler</description>
+	</channel-type>
+</thing:thing-descriptions>
diff --git a/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-power-channel-groups.xml b/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-power-channel-groups.xml
new file mode 100644
index 0000000000000..4ef6ce54035b5
--- /dev/null
+++ b/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-power-channel-groups.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<thing:thing-descriptions bindingId="modbus"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xmlns:thing="https://openhab.org/schemas/thing-description/v1.0.0"
+	xsi:schemaLocation="https://openhab.org/schemas/thing-description/v1.0.0 https://openhab.org/schemas/thing-description-1.0.0.xsd">
+	<channel-group-type id="xcenter-power-values">
+		<label>Power and efficency</label>
+		<description>Information about power and efficency</description>
+		<channels>
+			<channel id="cop" typeId="cop-channel"/>
+			<channel id="cop-heating" typeId="cop-heating-channel"/>
+			<channel id="cop-drinkingwater" typeId="cop-drinkingwater-channel"/>
+			<channel id="cop-cooling" typeId="cop-cooling-channel"/>
+			<channel id="power" typeId="power-channel"/>
+			<channel id="power-heating" typeId="power-heating-channel"/>
+			<channel id="power-drinkingwater" typeId="power-drinkingwater-channel"/>
+			<channel id="power-cooling" typeId="power-cooling-channel"/>
+			<channel id="electric-power" typeId="electric-power-channel"/>
+			<channel id="electric-power-heating" typeId="electric-power-heating-channel"/>
+			<channel id="electric-power-drinkingwater" typeId="electric-power-drinkingwater-channel"/>
+			<channel id="electric-power-cooling" typeId="electric-power-cooling-channel"/>
+		</channels>
+	</channel-group-type>
+</thing:thing-descriptions>
diff --git a/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-power-channel-types.xml b/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-power-channel-types.xml
new file mode 100644
index 0000000000000..b469f954ea176
--- /dev/null
+++ b/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-power-channel-types.xml
@@ -0,0 +1,68 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<thing:thing-descriptions bindingId="modbus"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xmlns:thing="https://openhab.org/schemas/thing-description/v1.0.0"
+	xsi:schemaLocation="https://openhab.org/schemas/thing-description/v1.0.0 https://openhab.org/schemas/thing-description-1.0.0.xsd">
+	<channel-type id="cop-channel">
+		<item-type>Number</item-type>
+		<label>Current COP</label>
+		<description></description>
+	</channel-type>
+	<channel-type id="cop-heating-channel">
+		<item-type>Number</item-type>
+		<label>Current COP heating</label>
+		<description></description>
+	</channel-type>
+	<channel-type id="cop-drinkingwater-channel">
+		<item-type>Number</item-type>
+		<label>Current COP drinking water</label>
+		<description></description>
+	</channel-type>
+	<channel-type id="cop-cooling-channel">
+		<item-type>Number</item-type>
+		<label>Current COP cooling</label>
+		<description></description>
+	</channel-type>
+
+	<channel-type id="power-channel">
+		<item-type>Number</item-type>
+		<label>Current power</label>
+		<description></description>
+	</channel-type>
+	<channel-type id="power-heating-channel">
+		<item-type>Number</item-type>
+		<label>Current power heating</label>
+		<description></description>
+	</channel-type>
+	<channel-type id="power-drinkingwater-channel">
+		<item-type>Number</item-type>
+		<label>Current power drinking water</label>
+		<description></description>
+	</channel-type>
+	<channel-type id="power-cooling-channel">
+		<item-type>Number</item-type>
+		<label>Current power cooling</label>
+		<description></description>
+	</channel-type>
+
+	<channel-type id="electric-power-channel">
+		<item-type>Number</item-type>
+		<label>Current electric power</label>
+		<description></description>
+	</channel-type>
+	<channel-type id="electric-power-heating-channel">
+		<item-type>Number</item-type>
+		<label>Current electric power heating</label>
+		<description></description>
+	</channel-type>
+	<channel-type id="electric-power-drinkingwater-channel">
+		<item-type>Number</item-type>
+		<label>Current electric power drinking water</label>
+		<description></description>
+	</channel-type>
+	<channel-type id="electric-power-cooling-channel">
+		<item-type>Number</item-type>
+		<label>Current electric power cooling</label>
+		<description></description>
+	</channel-type>
+</thing:thing-descriptions>
diff --git a/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-pvmodulation-channel-groups.xml b/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-pvmodulation-channel-groups.xml
new file mode 100644
index 0000000000000..5504826a9ce6f
--- /dev/null
+++ b/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-pvmodulation-channel-groups.xml
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<thing:thing-descriptions bindingId="modbus"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xmlns:thing="https://openhab.org/schemas/thing-description/v1.0.0"
+	xsi:schemaLocation="https://openhab.org/schemas/thing-description/v1.0.0 https://openhab.org/schemas/thing-description-1.0.0.xsd">
+	<channel-group-type id="xcenter-pvmodulation-values">
+		<label>PV Modulation</label>
+		<description>PV Modulation Information and Settings for Kermi Heatpump X-Center</description>
+		<channels>
+			<channel id="pv-state" typeId="pv-state-channel"/>
+			<channel id="pv-power" typeId="pv-power-channel"/>
+			<!-- R/W -->
+			<channel id="pv-target-temperature-heating" typeId="pv-target-temperature-heating-channel"/>
+			<!-- R/W -->
+			<channel id="pv-target-temperature-drinkingwater" typeId="pv-target-temperature-drinkingwater-channel"/>
+		</channels>
+	</channel-group-type>
+</thing:thing-descriptions>
diff --git a/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-pvmodulation-channel-types.xml b/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-pvmodulation-channel-types.xml
new file mode 100644
index 0000000000000..2a9ddafe67e1e
--- /dev/null
+++ b/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-pvmodulation-channel-types.xml
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<thing:thing-descriptions bindingId="modbus"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xmlns:thing="https://openhab.org/schemas/thing-description/v1.0.0"
+	xsi:schemaLocation="https://openhab.org/schemas/thing-description/v1.0.0 https://openhab.org/schemas/thing-description-1.0.0.xsd">
+	<channel-type id="pv-state-channel">
+		<item-type>Boolean</item-type>
+		<label>PV Modulation Active</label>
+		<description>State of PV-Modulation</description>
+	</channel-type>
+	<channel-type id="pv-power-channel">
+		<item-type>Number</item-type>
+		<label>PV Power</label>
+		<description></description>
+	</channel-type>
+	<channel-type id="pv-target-temperature-heating-channel">
+		<item-type>Number</item-type>
+		<label>PV Target temperature heating</label>
+		<description></description>
+	</channel-type>
+	<channel-type id="pv-target-temperature-drinkingwater-channel">
+		<item-type>Number</item-type>
+		<label>PV Target temperature drinking water</label>
+		<description></description>
+	</channel-type>
+</thing:thing-descriptions>
diff --git a/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-state-channel-groups.xml b/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-state-channel-groups.xml
index 3c13e10009222..ff70ee1db58c8 100644
--- a/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-state-channel-groups.xml
+++ b/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-state-channel-groups.xml
@@ -9,7 +9,6 @@
 		<channels>
 			<channel id="global-state" typeId="global-state-channel"/>
 			<channel id="global-state-id" typeId="global-state-id-channel"/>
-			<channel id="global-alarm" typeId="global-alarm-channel"/>
 		</channels>
 	</channel-group-type>
 </thing:thing-descriptions>
diff --git a/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-workhours-channel-groups.xml b/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-workhours-channel-groups.xml
new file mode 100644
index 0000000000000..8adab2dfcbed8
--- /dev/null
+++ b/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-workhours-channel-groups.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<thing:thing-descriptions bindingId="modbus"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xmlns:thing="https://openhab.org/schemas/thing-description/v1.0.0"
+	xsi:schemaLocation="https://openhab.org/schemas/thing-description/v1.0.0 https://openhab.org/schemas/thing-description-1.0.0.xsd">
+	<channel-group-type id="xcenter-workhours-values">
+		<label>Workhours</label>
+		<description>Basic Information of workhours</description>
+		<channels>
+			<channel id="workhours-fan" typeId="workhours-fan-channel"/>
+			<channel id="workhours-storage-loading-pump" typeId="workhours-storage-loading-pump-channel"/>
+			<channel id="workhours-compressor" typeId="workhours-compressor-channel"/>
+		</channels>
+	</channel-group-type>
+</thing:thing-descriptions>
diff --git a/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-workhours-channel-types.xml b/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-workhours-channel-types.xml
new file mode 100644
index 0000000000000..52ec780924615
--- /dev/null
+++ b/bundles/org.openhab.binding.modbus.kermi/src/main/resources/OH-INF/thing/xcenter-workhours-channel-types.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<thing:thing-descriptions bindingId="modbus"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xmlns:thing="https://openhab.org/schemas/thing-description/v1.0.0"
+	xsi:schemaLocation="https://openhab.org/schemas/thing-description/v1.0.0 https://openhab.org/schemas/thing-description-1.0.0.xsd">
+	<channel-type id="workhours-fan-channel">
+		<item-type>Number</item-type>
+		<label>Fan workhours</label>
+		<description>Work hours of the fan</description>
+	</channel-type>
+	<channel-type id="workhours-storage-loading-pump-channel">
+		<item-type>Number</item-type>
+		<label>StorageLoadingPump workhours</label>
+		<description>Work hours of the storage loading pump</description>
+	</channel-type>
+	<channel-type id="workhours-compressor-channel">
+		<item-type>Number</item-type>
+		<label>Compressor workhours</label>
+		<description>Work hours of the compressor</description>
+	</channel-type>
+</thing:thing-descriptions>
diff --git a/bundles/org.openhab.binding.modbus.kermi/src/test/java/org/openhab/binding/modbus/kermi/internal/dto/StateDTOTest.java b/bundles/org.openhab.binding.modbus.kermi/src/test/java/org/openhab/binding/modbus/kermi/internal/dto/StateDTOTest.java
index 2a1b5a6f7fa8b..b8e3c93df2cd3 100644
--- a/bundles/org.openhab.binding.modbus.kermi/src/test/java/org/openhab/binding/modbus/kermi/internal/dto/StateDTOTest.java
+++ b/bundles/org.openhab.binding.modbus.kermi/src/test/java/org/openhab/binding/modbus/kermi/internal/dto/StateDTOTest.java
@@ -20,7 +20,7 @@
 /**
  * Test for {@link StateDTO} class
  * 
- * @author Kai Neuhaus
+ * @author Kai Neuhaus - Initial contribution
  */
 public class StateDTOTest {