Merge pull request #1468 from infradom/main

Enhanded button autorepeat mechanism; Solax mode 8 power control

Author: infradom

custom_components/solax_modbus/__init__.py

@@ -118,6 +118,12 @@ class CoreModbusHub:
     SLEEPMODE_LASTAWAKE,
     CONF_TIME_OUT,
     DEFAULT_TIME_OUT,
+    BUTTONREPEAT_FIRST,
+    BUTTONREPEAT_LOOP,
+    BUTTONREPEAT_POST,
+    WRITE_MULTI_MODBUS,
+    WRITE_SINGLE_MODBUS,
+    WRITE_MULTISINGLE_MODBUS,
 )
 
 PLATFORMS = [Platform.BUTTON, Platform.NUMBER, Platform.SELECT, Platform.SENSOR, Platform.SWITCH]
@@ -392,7 +398,9 @@ def loadLocalData(self):
         else:
             if loaded.get("_version") == self.DATAFORMAT_VERSION:
                 for desc in self.writeLocals:
-                    self.data[desc] = loaded.get(desc)
+                    val = loaded.get(desc)
+                    if val != None: self.data[desc] = val
+                    else: self.data[desc] = self.writeLocals[desc].initvalue # first time initialisation
             else:
                 _LOGGER.warning(f"local persistent data lost - please reinitialize {self.writeLocals.keys()}")
             fp.close()
@@ -719,13 +727,13 @@ async def async_read_modbus_data(self, group):
         try:
             res = await self.async_read_modbus_registers_all(group)
         except ConnectionException as ex:
-            _LOGGER.error("Reading data failed! Inverter is offline.")
+            _LOGGER.error(f"Reading data failed! Inverter is offline. {ex}")
             res = False
         except ModbusIOException as ex:
             _LOGGER.error(f"ModbusIOError: {ex}")
             res = False
         except Exception as ex:
-            _LOGGER.exception("Something went wrong reading from modbus")
+            _LOGGER.exception(f"Something went wrong reading from modbus: {ex}")
             res = False
         return res
 
@@ -910,7 +918,8 @@ async def async_read_modbus_registers_all(self, group):
         else:
             _LOGGER.debug(f"device group inverter")
 
-        data = {"_repeatUntil": self.data["_repeatUntil"]}
+        data = {"_repeatUntil": self.data["_repeatUntil"]} # remove for issue #1440 but then does not recognize comm errors
+        #data = self.data # add for issue #1440 - is an alias, not a copy - but then does not recognize communication errors anymore
         res = True
         for block in group.holdingBlocks:
             res = res and await self.async_read_modbus_block(data, block, "holding")
@@ -931,8 +940,8 @@ async def async_read_modbus_registers_all(self, group):
                 _LOGGER.warning(f"device group check not success")
                 return True
 
-        for key, value in data.items():
-            self.data[key] = value
+        for key, value in data.items(): # remove for issue #1440, but then does not recognize communication errors anymore
+            self.data[key] = value # remove for issue #1440, but then comm errors are not detected
 
         if res and self.writequeue and self.plugin.isAwake(self.data):  # self.awakeplugin(self.data):
             # process outstanding write requests
@@ -941,20 +950,43 @@ async def async_read_modbus_registers_all(self, group):
                 val = self.writequeue.get(addr)
                 await self.async_write_register(self._modbus_addr, addr, val)
             self.writequeue = {}  # make sure we do not write multiple times
+
+        # execute autorepeat buttons
         self.last_ts = time()
         for (
             k,
             v,
-        ) in self.data["_repeatUntil"].items():
+        ) in list(self.data["_repeatUntil"].items()): # use a list copy because dict may change during iteration
+            buttondescr = self.computedButtons[k]
             if self.last_ts < v:
-                buttondescr = self.computedButtons[k]
-                payload = buttondescr.value_function(0, buttondescr, self.data)
-                _LOGGER.debug(f"ready to repeat button {k} data: {payload}")
-                await self.async_write_registers_multi(
-                    unit=self._modbus_addr,
-                    address=buttondescr.register,
-                    payload=payload,
-                )
+                payload = buttondescr.value_function(BUTTONREPEAT_LOOP, buttondescr, self.data) # initval = 1 means autorepeat run
+                if payload:
+                    reg = payload.get("register", buttondescr.register)
+                    action = payload.get("action")
+                    if not action: __LOGGER.error(f"autorepeat value function for {k} must return dict containing action")
+                    else:
+                        if action == WRITE_MULTI_MODBUS:
+                            _LOGGER.debug(f"**debug** ready to repeat button {k} data: {payload}")
+                            await self.async_write_registers_multi(
+                                unit=self._modbus_addr,
+                                address=reg,
+                                payload=payload.get('data'),
+                            )
+            else: # expired autorepeats
+                if self.data["_repeatUntil"][k] > 0: # expired recently
+                    self.data["_repeatUntil"][k] = 0 # mark as finally expired, no further buttonrepeat post after this one
+                    _LOGGER.info(f"calling final value function POST for {k} with initval {BUTTONREPEAT_POST}")
+                    payload = buttondescr.value_function(BUTTONREPEAT_POST, buttondescr, self.data)  # None means no final call after expiration
+                    if payload:
+                        reg = payload.get("register", buttondescr.register)
+                        action = payload.get("action")
+                        if action == WRITE_MULTI_MODBUS:
+                            _LOGGER.info(f"terminating loop {k} - ready to send final payload data: {payload}")
+                            await self.async_write_registers_multi(
+                                unit=self._modbus_addr,
+                                address=reg,
+                                payload=payload.get('data'),
+                            )
         return res
 
 

custom_components/solax_modbus/button.py

@@ -1,6 +1,6 @@
 from .const import ATTR_MANUFACTURER, DOMAIN, CONF_MODBUS_ADDR, DEFAULT_MODBUS_ADDR
 from .const import WRITE_DATA_LOCAL, WRITE_MULTISINGLE_MODBUS, WRITE_SINGLE_MODBUS, WRITE_MULTI_MODBUS
-from .const import autorepeat_set
+from .const import autorepeat_set, BUTTONREPEAT_FIRST
 from homeassistant.components.button import PLATFORM_SCHEMA, ButtonEntity
 from homeassistant.const import CONF_NAME
 from homeassistant.core import callback
@@ -85,9 +85,16 @@ async def async_press(self) -> None:
                 duration = self._hub.data.get(self.button_info.autorepeat, 0)
                 autorepeat_set(self._hub.data, self.button_info.key, time() + duration - 0.5 )
             if self.button_info.value_function:
-                res = self.button_info.value_function(0, self.button_info, self._hub.data )
+                res = self.button_info.value_function(BUTTONREPEAT_FIRST, self.button_info, self._hub.data ) # initval = 0 means first manual run
                 if res:
+                    if self.button_info.autorepeat: # different return value structure for autorepeat value function
+                        reg    = res.get('register', self._register)
+                        data   = res.get('data', None)
+                        action = res.get('action')
+                        if not action: _LOGGER.error(f"autorepeat value function for {self._key} must return dict containing action")
+                    else: data = res
                     _LOGGER.info(f"writing {self._platform_name} button register {self._register} value {res}")
-                    await self._hub.async_write_registers_multi(
-                        unit=self._modbus_addr, address=self._register, payload=res
-                    )
+                    if action == WRITE_MULTI_MODBUS:
+                        await self._hub.async_write_registers_multi(
+                            unit=self._modbus_addr, address=reg, payload=data
+                        )

custom_components/solax_modbus/const.py

@@ -95,6 +95,11 @@ class UnitOfReactivePower(StrEnum):
 CONF_TIME_OUT = "time_out"
 DEFAULT_TIME_OUT = 5
 
+# ================================= Button autorepeat initval codes for button value_functions ==========================
+BUTTONREPEAT_FIRST = 0  # first manual trigger click
+BUTTONREPEAT_LOOP  = 1  # automated loop
+BUTTONREPEAT_POST = -1 # final call after autoduration expired - no action needed in most cases
+
 # ================================= Definitions for Sensor Declarations =================================================
 
 REG_HOLDING = 1  # modbus holding register
@@ -275,6 +280,8 @@ def autorepeat_set(datadict, entitykey, value):
 def autorepeat_stop(datadict, entitykey):
     datadict["_repeatUntil"][entitykey] = 0
 
+def autorepeat_stop_with_postaction(datadict, entitykey):
+    datadict["_repeatUntil"][entitykey] = 1
 
 def autorepeat_remaining(datadict, entitykey, timestamp):
     remaining = datadict["_repeatUntil"].get(entitykey, 0) - timestamp
@@ -284,7 +291,8 @@ def autorepeat_remaining(datadict, entitykey, timestamp):
 # ================================= Computed sensor value functions  =================================================
 
 
-def value_function_pv_power_total(initval, descr, datadict):
+def value_function_pv_power_total(initval, descr, datadict): # this function can be enhanced to handle undefined values better
+    datadict.pop("pv_power_total", None)
     vals = [v for k, v in datadict.items() if k.startswith("pv_power_")]
     return None if any(p is None for p in vals) else sum(vals)
 

custom_components/solax_modbus/number.py

@@ -148,18 +148,18 @@ def native_value(self) -> float:
             except:
                 val = self._hub.data[self._key]
             return val
-        else:  # first time initialize
-            if descr.initvalue == None:
-                return None
-            else:
-                res = descr.initvalue
-                if self._attr_native_max_value != None:
-                    res = min(res, self._attr_native_max_value)
-                if self._attr_native_min_value != None:
-                    res = max(res, self._attr_native_min_value)
-                self._hub.data[self._key] = res
-                # _LOGGER.warning(f"****** (debug) initializing {self._key}  = {res}")
-                return res
+        #else:  # first time initialize
+        #    if descr.initvalue == None:
+        #        return None
+        #    else:
+        #        res = descr.initvalue
+        #        if self._attr_native_max_value != None:
+        #            res = min(res, self._attr_native_max_value)
+        #        if self._attr_native_min_value != None:
+        #            res = max(res, self._attr_native_min_value)
+        #        self._hub.data[self._key] = res
+        #        # _LOGGER.warning(f"****** (debug) initializing {self._key}  = {res}")
+        #        return res
 
     async def async_set_native_value(self, value: float) -> None:
         """Change the number value."""

custom_components/solax_modbus/payload.py

@@ -455,4 +455,5 @@ def skip_bytes(self, nbytes):
 
         :param nbytes: The number of bytes to skip
         """
-        self._pointer += nbytes
+        self._pointer += nbytes
+