goodwe 0.2.32__py3-none-any.whl → 0.3.0__py3-none-any.whl

goodwe/__init__.py

@@ -8,7 +8,6 @@ from .dt import DT
 from .es import ES
 from .et import ET
 from .exceptions import InverterError, RequestFailedException
-from .goodwe import GoodWeXSProcessor, AbstractDataProcessor, GoodWeInverter
 from .inverter import Inverter, OperationMode, Sensor, SensorKind
 from .model import DT_MODEL_TAGS, ES_MODEL_TAGS, ET_MODEL_TAGS
 from .protocol import ProtocolCommand, UdpInverterProtocol, Aa55ProtocolCommand
@@ -70,8 +69,9 @@ async def discover(host: str, timeout: int = 1, retries: int = 3) -> Inverter:
     try:
         logger.debug("Probing inverter at %s.", host)
         response = await DISCOVERY_COMMAND.execute(host, timeout, retries)
-        model_name = response[12:22].decode("ascii").rstrip()
-        serial_number = response[38:54].decode("ascii")
+        response = response.response_data()
+        model_name = response[5:15].decode("ascii").rstrip()
+        serial_number = response[31:47].decode("ascii")
 
         inverter_class: Type[Inverter] | None = None
         for model_tag in ET_MODEL_TAGS:

goodwe/const.py

@@ -70,97 +70,131 @@ WORK_MODES_ES: Dict[int, str] = {
 }
 
 SAFETY_COUNTRIES: Dict[int, str] = {
-    0: "Italy",
-    1: "Czechia",
-    2: "Germany",
-    3: "Spain",
-    4: "Greece Mainland",
-    5: "Denmark",
-    6: "Belgium",
-    7: "Romania",
-    8: "G98",
-    9: "Australia",
-    10: "France",
+    0: "IT CEI 0-21",
+    1: "CZ-A1",
+    2: "DE LV with PV",
+    3: "ES-A",
+    4: "GR",
+    5: "DK2",
+    6: "BE",
+    7: "RO-A",
+    8: "GB G98",
+    9: "Australia A",
+    10: "FR mainland",
     11: "China",
-    12: "60Hz Grid Default",
-    13: "Poland",
+    12: "60Hz 230Vac Default",
+    13: "PL LV",
     14: "South Africa",
-    15: "AustraliaL",
-    16: "Brazil",
+    16: "Brazil 220Vac",
     17: "Thailand MEA",
     18: "Thailand PEA",
     19: "Mauritius",
-    20: "Holland",
-    21: "G99",
-    22: "China Special",
-    23: "French 50Hz",
-    24: "French 60Hz",
+    20: "NL-A",
+    21: "G98/NI",
+    22: "China Higher",
+    23: "FR island 50Hz",
+    24: "FR island 60Hz",
     25: "Australia Ergon",
     26: "Australia Energex",
-    27: "Holland 16/20A",
+    27: "NL 16/20A",
     28: "Korea",
-    29: "China Station",
-    30: "Austria",
+    29: "China Utility",
+    30: "AT-A",
     31: "India",
-    32: "50Hz Grid Default",
+    32: "50Hz 230Vac Default",
     33: "Warehouse",
     34: "Philippines",
-    35: "Ireland",
+    35: "IE-16/25A",
     36: "Taiwan",
-    37: "Bulgaria",
+    37: "BG",
     38: "Barbados",
-    39: "China Special High",
-    40: "G99",
-    41: "Sweden",
-    42: "Chile",
-    43: "Brazil LV",
-    44: "NewZealand",
-    45: "IEEE1547 208VAC",
-    46: "IEEE1547 220VAC",
-    47: "IEEE1547 240VAC",
-    48: "60Hz LV Default",
-    49: "50Hz LV Default",
-    50: "AU_WAPN",
-    51: "AU_MicroGrid",
-    52: "JP_50Hz",
-    53: "JP_60Hz",
+    39: "China Highest",
+    40: "GB G99-A",
+    41: "SE LV",
+    42: "Chile BT",
+    43: "Brazil 127Vac",
+    44: "Newzealand",
+    45: "IEEE1547 208Vac",
+    46: "IEEE1547 220Vac",
+    47: "IEEE1547 240Vac",
+    48: "60Hz 127Vac Default",
+    49: "50Hz 127Vac Default",
+    50: "Australia WAPN",
+    51: "Australia MicroGrid",
+    52: "JP 50Hz",
+    53: "JP 60Hz",
     54: "India Higher",
     55: "DEWA LV",
     56: "DEWA MV",
-    57: "Slovakia",
-    58: "GreenGrid",
-    59: "Hungary",
+    57: "SK",
+    58: "NZ GreenGrid",
+    59: "HU",
     60: "Sri Lanka",
-    61: "Spain Islands",
+    61: "ES island",
     62: "Ergon30K",
     63: "Energex30K",
-    64: "IEEE1547 230/400V",
+    64: "IEEE1547 230/400Vac",
     65: "IEC61727 60Hz",
-    66: "Switzerland",
-    67: "CEI-016",
-    68: "AU_Horizon",
-    69: "Cyprus",
-    70: "AU_SAPN",
-    71: "AU_Ausgrid",
-    72: "AU_Essential",
-    73: "AU_Pwcore&CitiPW",
+    66: "CH",
+    67: "IT CEI 0-16",
+    68: "Australia Horizon",
+    69: "CY",
+    70: "Australia SAPN",
+    71: "Australia Ausgrid",
+    72: "Australia Essential",
+    73: "Australia Victoria",
     74: "Hong Kong",
-    75: "Poland MV",
-    76: "Holland MV",
-    77: "Sweden MV",
-    78: "VDE4110",
-    96: "cUSA_208VacDefault",
-    97: "cUSA_240VacDefault",
-    98: "cUSA_208VacCA_SCE",
-    99: "cUSA_240VacCA_SCE",
+    75: "PL MV",
+    76: "NL-B",
+    77: "SE MV",
+    78: "DE MV",
+    79: "DE LV without PV",
+    80: "ES-D",
+    81: "Australia Endeavour",
+    82: "Argentina",
+    83: "Israel LV",
+    84: "IEC61727 50Hz",
+    85: "Australia B",
+    86: "Australia C",
+    87: "Chile MT-A",
+    88: "Chile MT-B",
+    89: "Vietnam",
+    90: "reserve14",
+    91: "Israel-HV",
+    93: "NewZealand:2015",
+    94: "RO-D",
+    96: "US 208Vac Default",
+    97: "US 240Vac Default",
+    98: "US CA 208Vac",
+    99: "US CA 240Vac",
     100: "cUSA_208VacCA_SDGE",
     101: "cUSA_240VacCA_SDGE",
     102: "cUSA_208VacCA_PGE",
     103: "cUSA_240VacCA_PGE",
-    104: "cUSA_208VacHECO_14HO",
-    105: "cUSA_240VacHECO_14HO0x69",
-    106: "cUSA_208VacHECO_14HM",
-    107: "cUSA_240VacHECO_14HM",
+    104: "US HI 208Vac",
+    105: "US HI 240Vac",
+    106: "USA_208VacHECO_14HM",
+    107: "USA_240VacHECO_14HM",
+    108: "US 480Vac",
+    109: "US CA 480Vac",
+    110: "US HI 480Vac",
+    111: "US Kauai 208Vac",
+    112: "US Kauai 240Vac",
+    113: "US Kauai 480Vac",
+    114: "US ISO-NE 208Vac",
+    115: "US ISO-NE 240Vac",
+    116: "US ISO-NE 480Vac",
+    118: "PR 208Vac",
+    119: "PR 240Vac",
+    120: "PR 480Vac",
+    128: "Poland_B",
+    129: "EE",
+    135: "CZ-A2",
+    136: "CZ-B1",
+    146: "Brazil 208Vac",
+    147: "Brazil 230Vac",
+    148: "Brazil 240Vac",
+    149: "Brazil 254Vac",
 }
 
 ERROR_CODES: Dict[int, str] = {
@@ -263,3 +297,38 @@ BMS_WARNING_CODES: Dict[int, str] = {
     1: 'Discharging under-voltage 1',
     0: 'Charging over-voltage 1',
 }
+
+DERATING_MODE_CODES: Dict[int, str] = {
+    31: '',
+    30: '',
+    29: '',
+    28: '',
+    27: '',
+    26: '',
+    25: '',
+    24: '',
+    23: '',
+    22: '',
+    21: '',
+    20: '',
+    19: '',
+    18: '',
+    17: '',
+    16: '',
+    15: '',
+    14: '',
+    13: '',
+    12: '',
+    11: '',
+    10: 'Power calibration limit power (For ATS)',
+    9: 'Overvoltage derating (For GW)',
+    8: 'Maximum current derating',
+    7: 'Limited power start derating',
+    6: 'DRED derating',
+    5: 'Export power derating',
+    4: 'PU Curve',
+    3: 'Power VS Frequency',
+    2: 'Reactive power derating(PF/QU/FixQ)',
+    1: 'Active power derating',
+    0: 'Overtemperature derating',
+}

goodwe/dt.py

@@ -6,7 +6,7 @@ from .exceptions import InverterError
 from .inverter import Inverter
 from .inverter import OperationMode
 from .inverter import SensorKind as Kind
-from .model import is_3_mptt, is_single_phase
+from .model import is_3_mppt, is_single_phase
 from .protocol import ProtocolCommand, ModbusReadCommand, ModbusWriteCommand, ModbusWriteMultiCommand
 from .sensor import *
 
@@ -15,21 +15,21 @@ class DT(Inverter):
     """Class representing inverter of DT/MS/D-NS/XS or GE's GEP(PSB/PSC) families"""
 
     __all_sensors: Tuple[Sensor, ...] = (
-        Timestamp("timestamp", 0, "Timestamp"),
-        Voltage("vpv1", 6, "PV1 Voltage", Kind.PV),
-        Current("ipv1", 8, "PV1 Current", Kind.PV),
+        Timestamp("timestamp", 30100, "Timestamp"),
+        Voltage("vpv1", 30103, "PV1 Voltage", Kind.PV),
+        Current("ipv1", 30104, "PV1 Current", Kind.PV),
         Calculated("ppv1",
-                   lambda data: round(read_voltage(data, 6) * read_current(data, 8)),
+                   lambda data: round(read_voltage(data, 30103) * read_current(data, 30104)),
                    "PV1 Power", "W", Kind.PV),
-        Voltage("vpv2", 10, "PV2 Voltage", Kind.PV),
-        Current("ipv2", 12, "PV2 Current", Kind.PV),
+        Voltage("vpv2", 30105, "PV2 Voltage", Kind.PV),
+        Current("ipv2", 30106, "PV2 Current", Kind.PV),
         Calculated("ppv2",
-                   lambda data: round(read_voltage(data, 10) * read_current(data, 12)),
+                   lambda data: round(read_voltage(data, 30105) * read_current(data, 30106)),
                    "PV2 Power", "W", Kind.PV),
-        Voltage("vpv3", 14, "PV3 Voltage", Kind.PV),
-        Current("ipv3", 16, "PV3 Current", Kind.PV),
+        Voltage("vpv3", 30107, "PV3 Voltage", Kind.PV),
+        Current("ipv3", 30108, "PV3 Current", Kind.PV),
         Calculated("ppv3",
-                   lambda data: round(read_voltage(data, 14) * read_current(data, 16)),
+                   lambda data: round(read_voltage(data, 30107) * read_current(data, 30108)),
                    "PV3 Power", "W", Kind.PV),
         # Voltage("vpv4", 14, "PV4 Voltage", Kind.PV),
         # Current("ipv4", 16, "PV4 Current", Kind.PV),
@@ -37,72 +37,70 @@ class DT(Inverter):
         # Current("ipv5", 16, "PV5 Current", Kind.PV),
         # Voltage("vpv6", 14, "PV6 Voltage", Kind.PV),
         # Current("ipv6", 16, "PV7 Current", Kind.PV),
-        Voltage("vline1", 30, "On-grid L1-L2 Voltage", Kind.AC),
-        Voltage("vline2", 32, "On-grid L2-L3 Voltage", Kind.AC),
-        Voltage("vline3", 34, "On-grid L3-L1 Voltage", Kind.AC),
-        Voltage("vgrid1", 36, "On-grid L1 Voltage", Kind.AC),
-        Voltage("vgrid2", 38, "On-grid L2 Voltage", Kind.AC),
-        Voltage("vgrid3", 40, "On-grid L3 Voltage", Kind.AC),
-        Current("igrid1", 42, "On-grid L1 Current", Kind.AC),
-        Current("igrid2", 44, "On-grid L2 Current", Kind.AC),
-        Current("igrid3", 46, "On-grid L3 Current", Kind.AC),
-        Frequency("fgrid1", 48, "On-grid L1 Frequency", Kind.AC),
-        Frequency("fgrid2", 50, "On-grid L2 Frequency", Kind.AC),
-        Frequency("fgrid3", 52, "On-grid L3 Frequency", Kind.AC),
+        Voltage("vline1", 30115, "On-grid L1-L2 Voltage", Kind.AC),
+        Voltage("vline2", 30116, "On-grid L2-L3 Voltage", Kind.AC),
+        Voltage("vline3", 30117, "On-grid L3-L1 Voltage", Kind.AC),
+        Voltage("vgrid1", 30118, "On-grid L1 Voltage", Kind.AC),
+        Voltage("vgrid2", 30119, "On-grid L2 Voltage", Kind.AC),
+        Voltage("vgrid3", 30120, "On-grid L3 Voltage", Kind.AC),
+        Current("igrid1", 30121, "On-grid L1 Current", Kind.AC),
+        Current("igrid2", 30122, "On-grid L2 Current", Kind.AC),
+        Current("igrid3", 30123, "On-grid L3 Current", Kind.AC),
+        Frequency("fgrid1", 30124, "On-grid L1 Frequency", Kind.AC),
+        Frequency("fgrid2", 30125, "On-grid L2 Frequency", Kind.AC),
+        Frequency("fgrid3", 30126, "On-grid L3 Frequency", Kind.AC),
         Calculated("pgrid1",
-                   lambda data: round(read_voltage(data, 36) * read_current(data, 42)),
+                   lambda data: round(read_voltage(data, 30118) * read_current(data, 30121)),
                    "On-grid L1 Power", "W", Kind.AC),
         Calculated("pgrid2",
-                   lambda data: round(read_voltage(data, 38) * read_current(data, 44)),
+                   lambda data: round(read_voltage(data, 30119) * read_current(data, 30122)),
                    "On-grid L2 Power", "W", Kind.AC),
         Calculated("pgrid3",
-                   lambda data: round(read_voltage(data, 40) * read_current(data, 46)),
+                   lambda data: round(read_voltage(data, 30120) * read_current(data, 30123)),
                    "On-grid L3 Power", "W", Kind.AC),
-        Integer("xx54", 54, "Unknown sensor@54"),
-        Power("ppv", 56, "PV Power", Kind.PV),
-        Integer("work_mode", 58, "Work Mode code"),
-        Enum2("work_mode_label", 58, WORK_MODES, "Work Mode"),
-        Long("error_codes", 60, "Error Codes"),
-        Integer("warning_code", 64, "Warning code"),
-        Integer("xx66", 66, "Unknown sensor@66"),
-        Integer("xx68", 68, "Unknown sensor@68"),
-        Integer("xx70", 70, "Unknown sensor@70"),
-        Integer("xx72", 72, "Unknown sensor@72"),
-        Integer("xx74", 74, "Unknown sensor@74"),
-        Integer("xx76", 76, "Unknown sensor@76"),
-        Integer("xx78", 78, "Unknown sensor@78"),
-        Integer("xx80", 80, "Unknown sensor@80"),
-        Temp("temperature", 82, "Inverter Temperature", Kind.AC),
-        Integer("xx84", 84, "Unknown sensor@84"),
-        Integer("xx86", 86, "Unknown sensor@86"),
-        Energy("e_day", 88, "Today's PV Generation", Kind.PV),
-        Energy4("e_total", 90, "Total PV Generation", Kind.PV),
-        Long("h_total", 94, "Hours Total", "h", Kind.PV),
-        Integer("safety_country", 98, "Safety Country code", "", Kind.AC),
-        Enum2("safety_country_label", 98, SAFETY_COUNTRIES, "Safety Country", Kind.AC),
-        Integer("xx100", 100, "Unknown sensor@100"),
-        Integer("xx102", 102, "Unknown sensor@102"),
-        Integer("xx104", 104, "Unknown sensor@104"),
-        Integer("xx106", 106, "Unknown sensor@106"),
-        Integer("xx108", 108, "Unknown sensor@108"),
-        Integer("xx110", 110, "Unknown sensor@110"),
-        Integer("xx112", 112, "Unknown sensor@112"),
-        Integer("xx114", 114, "Unknown sensor@114"),
-        Integer("xx116", 116, "Unknown sensor@116"),
-        Integer("xx118", 118, "Unknown sensor@118"),
-        Integer("xx120", 120, "Unknown sensor@120"),
-        Integer("xx122", 122, "Unknown sensor@122"),
-        Integer("funbit", 124, "FunBit", "", Kind.PV),
-        Voltage("vbus", 126, "Bus Voltage", Kind.PV),
-        Voltage("vnbus", 128, "NBus Voltage", Kind.PV),
-        Integer("xx130", 130, "Unknown sensor@130"),
-        Integer("xx132", 132, "Unknown sensor@132"),
-        Integer("xx134", 134, "Unknown sensor@134"),
-        Integer("xx136", 136, "Unknown sensor@136"),
-        Integer("xx138", 138, "Unknown sensor@138"),
-        Integer("xx140", 140, "Unknown sensor@140"),
-        Integer("xx142", 142, "Unknown sensor@142"),
-        Integer("xx144", 144, "Unknown sensor@144"),
+        # 30127 reserved
+        Power("ppv", 30128, "PV Power", Kind.PV),
+        Integer("work_mode", 30129, "Work Mode code"),
+        Enum2("work_mode_label", 30129, WORK_MODES, "Work Mode"),
+        Long("error_codes", 30130, "Error Codes"),
+        Integer("warning_code", 30132, "Warning code"),
+        Apparent4("apparent_power", 30133, "Apparent Power", Kind.AC),
+        Reactive4("reactive_power", 30135, "Reactive Power", Kind.AC),
+        # 30137 reserved
+        # 30138 reserved
+        # 30139 reserved
+        # 30140 reserved
+        Temp("temperature", 30141, "Inverter Temperature", Kind.AC),
+        # 30142 reserved
+        # 30143 reserved
+        Energy("e_day", 30144, "Today's PV Generation", Kind.PV),
+        Energy4("e_total", 30145, "Total PV Generation", Kind.PV),
+        Long("h_total", 30147, "Hours Total", "h", Kind.PV),
+        Integer("safety_country", 30149, "Safety Country code", "", Kind.AC),
+        Enum2("safety_country_label", 30149, SAFETY_COUNTRIES, "Safety Country", Kind.AC),
+        # 30150 reserved
+        # 30151 reserved
+        # 30152 reserved
+        # 30153 reserved
+        # 30154 reserved
+        # 30155 reserved
+        # 30156 reserved
+        # 30157 reserved
+        # 30158 reserved
+        # 30159 reserved
+        # 30160 reserved
+        # 30161 reserved
+        Integer("funbit", 30162, "FunBit", "", Kind.PV),
+        Voltage("vbus", 30163, "Bus Voltage", Kind.PV),
+        Voltage("vnbus", 30164, "NBus Voltage", Kind.PV),
+        Long("derating_mode", 30165, "Derating Mode code"),
+        EnumBitmap4("derating_mode_label", 30165, DERATING_MODE_CODES, "Derating Mode"),
+        # 30167 reserved
+        # 30168 reserved
+        # 30169 reserved
+        # 30170 reserved
+        # 30171 reserved
+        # 30172 reserved
     )
 
     # Modbus registers of inverter settings, offsets are modbus register addresses
@@ -137,7 +135,7 @@ class DT(Inverter):
     @staticmethod
     def _single_phase_only(s: Sensor) -> bool:
         """Filter to exclude phase2/3 sensors on single phase inverters"""
-        return not ((s.id_.endswith('2') or s.id_.endswith('3')) and 'pv' not in s.id_ and not s.id_.startswith('xx'))
+        return not ((s.id_.endswith('2') or s.id_.endswith('3')) and 'pv' not in s.id_)
 
     @staticmethod
     def _pv1_pv2_only(s: Sensor) -> bool:
@@ -146,12 +144,12 @@ class DT(Inverter):
 
     async def read_device_info(self):
         response = await self._read_from_socket(self._READ_DEVICE_VERSION_INFO)
-        response = response[5:-2]
+        response = response.response_data()
         try:
             self.model_name = response[22:32].decode("ascii").rstrip()
         except:
             print("No model name sent from the inverter.")
-        self.serial_number = response[6:22].decode("ascii")
+        self.serial_number = self._decode(response[6:22])
         self.dsp1_version = read_unsigned_int(response, 66)
         self.dsp2_version = read_unsigned_int(response, 68)
         self.arm_version = read_unsigned_int(response, 70)
@@ -164,7 +162,7 @@ class DT(Inverter):
         else:
             self._settings.update({s.id_: s for s in self.__settings_three_phase})
 
-        if is_3_mptt(self):
+        if is_3_mppt(self):
             # this is 3 PV strings inverter, keep all sensors
             pass
         else:
@@ -172,9 +170,9 @@ class DT(Inverter):
             self._sensors = tuple(filter(self._pv1_pv2_only, self._sensors))
         pass
 
-    async def read_runtime_data(self, include_unknown_sensors: bool = False) -> Dict[str, Any]:
-        raw_data = await self._read_from_socket(self._READ_DEVICE_RUNNING_DATA)
-        data = self._map_response(raw_data[5:-2], self._sensors, include_unknown_sensors)
+    async def read_runtime_data(self) -> Dict[str, Any]:
+        response = await self._read_from_socket(self._READ_DEVICE_RUNNING_DATA)
+        data = self._map_response(response, self._sensors)
         return data
 
     async def read_setting(self, setting_id: str) -> Any:
@@ -182,9 +180,8 @@ class DT(Inverter):
         if not setting:
             raise ValueError(f'Unknown setting "{setting_id}"')
         count = (setting.size_ + (setting.size_ % 2)) // 2
-        raw_data = await self._read_from_socket(ModbusReadCommand(self.comm_addr, setting.offset, count))
-        with io.BytesIO(raw_data[5:-2]) as buffer:
-            return setting.read_value(buffer)
+        response = await self._read_from_socket(ModbusReadCommand(self.comm_addr, setting.offset, count))
+        return setting.read_value(response)
 
     async def write_setting(self, setting_id: str, value: Any):
         setting = self._settings.get(setting_id)
@@ -208,7 +205,6 @@ class DT(Inverter):
         return await self.read_setting('grid_export_limit')
 
     async def set_grid_export_limit(self, export_limit: int) -> None:
-        setting = self._settings.get('grid_export_limit')
         if export_limit >= 0:
             return await self.write_setting('grid_export_limit', export_limit)
 

goodwe/es.py

@@ -98,8 +98,8 @@ class ES(Inverter):
                    lambda data: round(read_bytes2(data, 47) + read_bytes2(data, 81)),
                    "Plant Power", "W", Kind.AC),
         Decimal("meter_power_factor", 83, 1000, "Meter Power Factor", "", Kind.GRID),  # modbus 0x531
-        Integer("xx85", 85, "Unknown sensor@85"),
-        Integer("xx87", 87, "Unknown sensor@87"),
+        # Integer("xx85", 85, "Unknown sensor@85"),
+        # Integer("xx87", 87, "Unknown sensor@87"),
         Long("diagnose_result", 89, "Diag Status Code"),
         EnumBitmap4("diagnose_result_label", 89, DIAG_STATUS_CODES, "Diag Status"),
         # Energy4("e_total_exp", 93, "Total Energy (export)", Kind.GRID),
@@ -188,10 +188,11 @@ class ES(Inverter):
 
     async def read_device_info(self):
         response = await self._read_from_socket(self._READ_DEVICE_VERSION_INFO)
-        self.firmware = self._decode(response[7:12]).rstrip()
-        self.model_name = self._decode(response[12:22]).rstrip()
-        self.serial_number = response[38:54].decode("ascii")
-        self.software_version = self._decode(response[58:70])
+        response = response.response_data()
+        self.firmware = self._decode(response[0:5]).rstrip()
+        self.model_name = self._decode(response[5:15]).rstrip()
+        self.serial_number = self._decode(response[31:47])
+        self.software_version = self._decode(response[51:63])
         try:
             if len(self.firmware) >= 2:
                 self.dsp1_version = int(self.firmware[0:2])
@@ -205,9 +206,9 @@ class ES(Inverter):
         if self._supports_eco_mode_v2():
             self._settings.update({s.id_: s for s in self.__settings_arm_fw_14})
 
-    async def read_runtime_data(self, include_unknown_sensors: bool = False) -> Dict[str, Any]:
-        raw_data = await self._read_from_socket(self._READ_DEVICE_RUNNING_DATA)
-        data = self._map_response(raw_data[7:-2], self.__sensors, include_unknown_sensors)
+    async def read_runtime_data(self) -> Dict[str, Any]:
+        response = await self._read_from_socket(self._READ_DEVICE_RUNNING_DATA)
+        data = self._map_response(response, self.__sensors)
         return data
 
     async def read_setting(self, setting_id: str) -> Any:
@@ -221,13 +222,11 @@ class ES(Inverter):
                 raise ValueError(f'Unknown setting "{setting_id}"')
             count = (setting.size_ + (setting.size_ % 2)) // 2
             if self._is_modbus_setting(setting):
-                raw_data = await self._read_from_socket(ModbusReadCommand(self.comm_addr, setting.offset, count))
-                with io.BytesIO(raw_data[5:-2]) as buffer:
-                    return setting.read_value(buffer)
+                response = await self._read_from_socket(ModbusReadCommand(self.comm_addr, setting.offset, count))
+                return setting.read_value(response)
             else:
-                raw_data = await self._read_from_socket(Aa55ReadCommand(setting.offset, count))
-                with io.BytesIO(raw_data[7:-2]) as buffer:
-                    return setting.read_value(buffer)
+                response = await self._read_from_socket(Aa55ReadCommand(setting.offset, count))
+                return setting.read_value(response)
         else:
             all_settings = await self.read_settings_data()
             return all_settings.get(setting_id)
@@ -244,11 +243,11 @@ class ES(Inverter):
             if setting.size_ == 1:
                 # modbus can address/store only 16 bit values, read the other 8 bytes
                 if self._is_modbus_setting(setting):
-                    register_data = await self._read_from_socket(ModbusReadCommand(self.comm_addr, setting.offset, 1))
-                    raw_value = setting.encode_value(value, register_data[5:7])
+                    response = await self._read_from_socket(ModbusReadCommand(self.comm_addr, setting.offset, 1))
+                    raw_value = setting.encode_value(value, response.response_data()[0:2])
                 else:
-                    register_data = await self._read_from_socket(Aa55ReadCommand(setting.offset, 1))
-                    raw_value = setting.encode_value(value, register_data[7:9])
+                    response = await self._read_from_socket(Aa55ReadCommand(setting.offset, 1))
+                    raw_value = setting.encode_value(value, response.response_data()[2:4])
             else:
                 raw_value = setting.encode_value(value)
             if len(raw_value) <= 2:
@@ -264,8 +263,8 @@ class ES(Inverter):
                     await self._read_from_socket(Aa55WriteMultiCommand(setting.offset, raw_value))
 
     async def read_settings_data(self) -> Dict[str, Any]:
-        raw_data = await self._read_from_socket(self._READ_DEVICE_SETTINGS_DATA)
-        data = self._map_response(raw_data[7:-2], self.settings())
+        response = await self._read_from_socket(self._READ_DEVICE_SETTINGS_DATA)
+        data = self._map_response(response, self.settings())
         return data
 
     async def get_grid_export_limit(self) -> int: