Service: write_holding_register/write_holding_registers allow selecting device

Service: add read_holding_register/read_holding_registers

Log only first failed connection break as 'warning', susquence tries to connect only as 'debug'. Reduced Log-File flooding as inverters are usally down >= 12 hours a day

Author: Dummy0815

custom_components/solarman/manifest.json

@@ -7,7 +7,7 @@
   "documentation": "https://github.com/StephanJoubert/home_assistant_solarman/blob/main/README.md",
   "iot_class": "local_polling",
   "issue_tracker": "https://github.com/StephanJoubert/home_assistant_solarman/issues",
-  "requirements": ["pyyaml", "umodbus"],
+  "requirements": ["pyyaml","pysolarmanv5"],
   "version": "1.0.0"
 }
 

custom_components/solarman/pysolarmanv5_local.py

@@ -132,7 +132,9 @@ def _v5_frame_def(self):
         self.v5_offsettime = bytes.fromhex("00000000")
         self.v5_checksum = bytes.fromhex("00")  # placeholder value
         self.v5_end = bytes.fromhex("15")
-        self.v5_header_len = 12 # v5_start(1) + v5_length(2) + v5_controlcode(2) + v5_serial(2) + v5_loggerserial(4) + v5_frametype(1)
+        self.v5_header_len = 11 # v5_start(1) + v5_length(2) + v5_controlcode(2) + v5_serial(2) + v5_loggerserial(4)
+        self.v5_frame_len_without_payload = self.v5_header_len + 2 #Header + v5_checksum(1) + v5_end(1)
+        self.v5_payloadheader_len = 14 # frametype(1) + status(1) + totalWorkingTime(4) + powerOnTime(4) + offsetTime(4)
 
     @staticmethod
     def _calculate_v5_frame_checksum(frame, length):
@@ -235,7 +237,6 @@ def _v5_frame_decoder(self, v5_frame):
         """
 
         modbus_frame = b""
-        frame_len_without_payload_len = 13
         v5_start = int.from_bytes(self.v5_start, byteorder="big")
 
         self.log.debug("_v5_frame_decoder: Check frame buffer len: %i", len(v5_frame))
@@ -273,27 +274,27 @@ def _v5_frame_decoder(self, v5_frame):
                 continue
 
             (payload_len,) = struct.unpack("<H", v5_frame[1:3])
-            if frame_len < (frame_len_without_payload_len + payload_len + 3):
-                self.log.debug("_v5_frame_decoder: V5 frame not complete.")
+            if frame_len < (self.v5_frame_len_without_payload + payload_len):
+                self.log.debug(f"_v5_frame_decoder: V5 frame not complete. frame length={frame_len} expected length={self.v5_frame_len_without_payload + payload_len}")
                 return b"" #need to wait for more bytes to be received
 
-            if (v5_frame[frame_len_without_payload_len + payload_len - 1] != int.from_bytes(self.v5_end, byteorder="big")):
+            if (v5_frame[self.v5_frame_len_without_payload + payload_len - 1] != int.from_bytes(self.v5_end, byteorder="big")):
                 self.log.debug("_v5_frame_decoder: V5 frame contains invalid end value")
                 v5_frame.pop()
                 continue
 
-            if v5_frame[frame_len_without_payload_len + payload_len - 2] != self._calculate_v5_frame_checksum(v5_frame, frame_len_without_payload_len + payload_len):
+            if v5_frame[self.v5_frame_len_without_payload + payload_len - 2] != self._calculate_v5_frame_checksum(v5_frame, self.v5_frame_len_without_payload + payload_len):
                 self.log.debug("_v5_frame_decoder: V5 frame contains invalid V5 checksumd")
                 v5_frame.pop()
                 continue
 
-            if ((payload_len - frame_len_without_payload_len) <= 5):
-                self.log.debug("_v5_frame_decoder: V5 frame no RTU frame (too short)")
-                v5_frame.pop()
-                continue
-
-            modbus_frame = v5_frame[25 : frame_len_without_payload_len + payload_len - 2]
-            self.log.debug("_v5_frame_decoder: V5 frame found:" + modbus_frame.hex(" "))
+            if ((payload_len-self.v5_payloadheader_len) < 5):
+                self.log.debug("_v5_frame_decoder: V5 frame contains invalid RTU (to small)- > create RTU error frame")
+                modbus_frame = b'\x01\x80\x02\xC0\x01'
+            else:                
+                modbus_frame = v5_frame[self.v5_header_len + self.v5_payloadheader_len : self.v5_frame_len_without_payload + payload_len - 2]
+            
+            self.log.debug("_v5_frame_decoder: V5 frame found (hex): " + modbus_frame.hex(" "))
             break
 
         return modbus_frame

custom_components/solarman/sensor.py

@@ -38,7 +38,7 @@ def _do_setup_platform(hass: HomeAssistant, config, async_add_entities : AddEnti
     inverter_sn = config.get(CONF_INVERTER_SERIAL)
     if inverter_sn == 0:
         inverter_sn = _inverter_scanner.get_serialno()
-    
+
     inverter_mb_slaveid = config.get(CONF_INVERTER_MB_SLAVEID)
     if not inverter_mb_slaveid:
         inverter_mb_slaveid = DEFAULT_INVERTER_MB_SLAVEID
@@ -70,10 +70,10 @@ def _do_setup_platform(hass: HomeAssistant, config, async_add_entities : AddEnti
     _LOGGER.debug(hass_sensors)
 
     async_add_entities(hass_sensors)
-    # Register the services with home assistant.    
-    register_services (hass, inverter)
-    
-    
+    # Register the services with home assistant.
+    register_services (hass)
+
+
 
 
 
@@ -156,6 +156,10 @@ def unique_id(self):
     def state(self):
         #  Return the state of the sensor.
         return self.p_state
+    
+    def inverter(self):
+        #  Return the inverter of the sensor. """
+        return self.inverter
 
     def update(self):
         self.p_state = getattr(self.inverter, self._field_name, None)

custom_components/solarman/services.py

@@ -1,56 +1,190 @@
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers import config_validation as cv
+from homeassistant.core import HomeAssistant, SupportsResponse
+from homeassistant.helpers import config_validation as cv, entity_registry, entity
+from homeassistant.helpers.entity_component import EntityComponent
+from homeassistant.exceptions import ServiceValidationError
 import voluptuous as vol
 from .const import *
 from .solarman import Inverter
+import logging
 
+log = logging.getLogger(__name__)
 
-SERVICE_WRITE_REGISTER = 'write_holding_register'
-SERVICE_WRITE_MULTIPLE_REGISTERS = 'write_multiple_holding_registers'
+SERVICE_READ_HOLDING_REGISTER            = 'read_holding_register'
+SERVICE_READ_MULTIPLE_HOLDING_REGISTERS  = 'read_multiple_holding_registers'
+SERVICE_WRITE_HOLDING_REGISTER           = 'write_holding_register'
+SERVICE_WRITE_MULTIPLE_HOLDING_REGISTERS = 'write_multiple_holding_registers'
+PARAM_DEVICE   = 'device'
 PARAM_REGISTER = 'register'
-PARAM_VALUE = 'value'
-PARAM_VALUES = 'values'
-
+PARAM_COUNT    = 'count'
+PARAM_VALUE    = 'value'
+PARAM_VALUES   = 'values'
 
 
 # Register the services one can invoke on the inverter.
 # Apart from this, it also need to be defined in the file 
 # services.yaml for the Home Assistant UI in "Developer Tools"
 
+SERVICE_READ_REGISTER_SCHEMA = vol.Schema(
+    {
+        vol.Required(PARAM_DEVICE): vol.All(vol.Coerce(str)),
+        vol.Required(PARAM_REGISTER): vol.All(vol.Coerce(int), vol.Range(min=0, max=65535))
+    }
+)
+
+SERVICE_READ_MULTIPLE_REGISTERS_SCHEMA = vol.Schema(
+    {
+        vol.Required(PARAM_DEVICE): vol.All(vol.Coerce(str)),
+        vol.Required(PARAM_REGISTER): vol.All(vol.Coerce(int), vol.Range(min=0, max=65535)),
+        vol.Required(PARAM_COUNT): vol.All(vol.Coerce(int), vol.Range(min=0, max=65535))
+    }
+)
 
 SERVICE_WRITE_REGISTER_SCHEMA = vol.Schema(
     {
+        vol.Required(PARAM_DEVICE): vol.All(vol.Coerce(str)),
         vol.Required(PARAM_REGISTER): vol.All(vol.Coerce(int), vol.Range(min=0, max=65535)),
         vol.Required(PARAM_VALUE): vol.All(vol.Coerce(int), vol.Range(min=0, max=65535)),
     }
 )
 
 SERVICE_WRITE_MULTIPLE_REGISTERS_SCHEMA = vol.Schema(
     {
+        vol.Required(PARAM_DEVICE): vol.All(vol.Coerce(str)),
         vol.Required(PARAM_REGISTER): vol.All(vol.Coerce(int), vol.Range(min=0, max=65535)),
         vol.Required(PARAM_VALUES): vol.All(cv.ensure_list, [vol.All(vol.Coerce(int), vol.Range(min=0, max=65535))]),
     }
 )
 
-def register_services (hass: HomeAssistant, inverter: Inverter ):
+def register_services (hass: HomeAssistant ):
+
+    def getInverter(device_id):
+        inverter: Inverter | None
+        entity_comp: EntityComponent[entity.Entity] | None       
+        registry = entity_registry.async_get(hass)
+        entries = entity_registry.async_entries_for_device(registry, device_id)
+        for entity_reg in entries:
+            entity_id = entity_reg.entity_id
+            domain = entity_id.partition(".")[0]
+            entity_comp = hass.data.get("entity_components", {}).get(domain)
+            if entity_comp is None:
+                log.info(f'read_holding_register: Component for {entity_id} not loaded')
+                continue
+
+            if (entity_obj := entity_comp.get_entity(entity_id)) is None:
+                log.info(f'read_holding_register: Entity {entity_id} not found')
+                continue
+
+            if (inverter := entity_obj.inverter) is None:
+                log.info(f'read_holding_register: Entity {entity_id} has no inverter')
+                continue
+
+            break
+
+        return inverter
+
+
+    async def read_holding_register(call) -> int:
+        if (inverter := getInverter(call.data.get(PARAM_DEVICE))) is None:
+            raise ServiceValidationError(
+                "No communication interface for device found",
+                translation_domain=DOMAIN,
+                translation_key="no_interface_found"
+            )
+        
+        try:
+            response = inverter.service_read_holding_register( register=call.data.get(PARAM_REGISTER) )
+        except Exception as e:
+            raise ServiceValidationError(
+                e,
+                translation_domain=DOMAIN,
+                translation_key="call_failed"
+            )
+        
+        result = {call.data.get(PARAM_REGISTER): response[0]}
+        return result
+    
+    async def read_multiple_holding_registers(call) -> int:
+        if (inverter := getInverter(call.data.get(PARAM_DEVICE))) is None:
+            raise ServiceValidationError(
+                "No communication interface for device found",
+                translation_domain=DOMAIN,
+                translation_key="no_interface_found"
+            )
+        
+        try:
+            response = inverter.service_read_multiple_holding_registers( 
+                register=call.data.get(PARAM_REGISTER),
+                 count=call.data.get(PARAM_COUNT) )
+        except Exception as e:
+            raise ServiceValidationError(
+                e,
+                translation_domain=DOMAIN,
+                translation_key="call_failed"
+            )
+        
+        result = {}
+        register=call.data.get(PARAM_REGISTER)
+        for i in range(0,call.data.get(PARAM_COUNT)):
+            result[register+i] = response[i]
+        return result
 
     async def write_holding_register(call) -> None:
-        inverter.service_write_holding_register(
-            register=call.data.get(PARAM_REGISTER), 
-            value=call.data.get(PARAM_VALUE))
+        log.debug(f'write_holding_register: call={call}')
+        if (inverter := getInverter(call.data.get(PARAM_DEVICE))) is None:
+            raise ServiceValidationError(
+                "No communication interface for device found",
+                translation_domain=DOMAIN,
+                translation_key="no_interface_found",
+            )
+
+        try:
+            inverter.service_write_holding_register(
+                register=call.data.get(PARAM_REGISTER), 
+                value=call.data.get(PARAM_VALUE))
+        except Exception as e:
+            raise ServiceValidationError(
+                e,
+                translation_domain=DOMAIN,
+                translation_key="call_failed"
+            )
+
         return
 
     async def write_multiple_holding_registers(call) -> None:
-        inverter.service_write_multiple_holding_registers(
-            register=call.data.get(PARAM_REGISTER),
-            values=call.data.get(PARAM_VALUES))
+        log.debug(f'write_holding_register: call={call}')
+        if (inverter := getInverter(call.data.get(PARAM_DEVICE))) is None:
+            raise ServiceValidationError(
+                "No communication interface for device found",
+                translation_domain=DOMAIN,
+                translation_key="no_interface_found",
+            )
+
+        try:
+            inverter.service_write_multiple_holding_registers(
+                register=call.data.get(PARAM_REGISTER),
+                values=call.data.get(PARAM_VALUES))
+        except Exception as e:
+            raise ServiceValidationError(
+                e,
+                translation_domain=DOMAIN,
+                translation_key="call_failed"
+            )
+        
         return
 
     hass.services.async_register(
-        DOMAIN, SERVICE_WRITE_REGISTER, write_holding_register, schema=SERVICE_WRITE_REGISTER_SCHEMA
+        DOMAIN, SERVICE_READ_HOLDING_REGISTER, read_holding_register, schema=SERVICE_READ_REGISTER_SCHEMA, supports_response=SupportsResponse.OPTIONAL
+    )
+
+    hass.services.async_register(
+        DOMAIN, SERVICE_READ_MULTIPLE_HOLDING_REGISTERS, read_multiple_holding_registers, schema=SERVICE_READ_MULTIPLE_REGISTERS_SCHEMA, supports_response=SupportsResponse.OPTIONAL
+    )
+
+    hass.services.async_register(
+        DOMAIN, SERVICE_WRITE_HOLDING_REGISTER, write_holding_register, schema=SERVICE_WRITE_REGISTER_SCHEMA
     )
 
     hass.services.async_register(
-        DOMAIN, SERVICE_WRITE_MULTIPLE_REGISTERS, write_multiple_holding_registers, schema=SERVICE_WRITE_MULTIPLE_REGISTERS_SCHEMA
+        DOMAIN, SERVICE_WRITE_MULTIPLE_HOLDING_REGISTERS, write_multiple_holding_registers, schema=SERVICE_WRITE_MULTIPLE_REGISTERS_SCHEMA
     )
     return