Add handler for MUST PV/PH solar system inverters (#2)

Author: BlueManCZ

dependencies.txt

@@ -1,6 +1,7 @@
 python3-eventlet
 python3-flask
 python3-flask-socketio
+python3-minimalmodbus
 python3-pony
 python3-requests
 python3-serial

modules/handlers/__init__.py

@@ -1,8 +1,16 @@
 from modules.handlers.serial_handler import SerialHandler
 from modules.handlers.http_handler import HttpHandler
 from modules.handlers.bms_serial_handler import BmsSerialHandler
+from modules.handlers.must_pv_ph_inverter_modbus_handler import (
+    MustPVPHInverterModbusHandler,
+)
 
-loaded_handlers = [SerialHandler, HttpHandler, BmsSerialHandler]
+loaded_handlers = [
+    SerialHandler,
+    HttpHandler,
+    BmsSerialHandler,
+    MustPVPHInverterModbusHandler,
+]
 
 
 def get_handler_class(handler_type):

modules/handlers/must_pv_ph_inverter_modbus_handler.py

@@ -0,0 +1,159 @@
+from minimalmodbus import Instrument, NoResponseError, InvalidResponseError
+from os import path
+from serial import SerialException
+from threading import Thread
+from time import sleep
+
+from modules.logging.logger import logger
+from .abstract_handler import AbstractHandler
+
+
+class MustPVPHInverterModbusHandler(AbstractHandler):
+    """Class for handling MUST PV/PH solar system inverters."""
+
+    type = "must_pv_ph_modbus"
+    icon = "inverter"
+    name = "MUST PV/PH solar inverter"
+    config_fields = {
+        "port": ["string", "Device port (e.g., /dev/ttyUSB0)"],
+        "slave-address": ["int", "Device slave address", 4],
+        "interval": ["int", "Fetching interval in seconds", 10],
+        "timeout": ["float", "Timeout in seconds", 0.1],
+        "auto-reconnect": ["bool", "Auto reconnect", True],
+    }
+
+    registers = {
+        "charger": {
+            "pv-voltage": [15205, 1],
+            "battery-voltage": [15206, 1],
+            "current": [15207, 1],
+            "power": [15208, 0],
+        },
+        "inverter": {
+            "battery-voltage": [25205, 1],
+            "power": [25213, 0],
+            "power-grid": [25214, 0],
+            "power-load": [25215, 0],
+        },
+    }
+
+    def _read_message(self):
+        if not self.first_tick():
+            self.wait_for_interval(self.config("interval"))
+
+        result = {"charger": {}, "inverter": {}}
+
+        for section_type in self.registers.keys():
+            for key, data in self.registers[section_type].items():
+                result[section_type][key] = self.connection.read_register(
+                    data[0], data[1]
+                )
+                sleep(0.05)
+
+        return result
+
+    def _message_watcher(self):
+        self.log.debug("Starting message watcher")
+        while self.active:
+            if path.exists(self.connection.serial.port):
+                try:
+                    message = self._read_message()
+                    if message:
+                        self.add_message(message)
+                except SerialException as error:
+                    self._handle_error(error, "Failed to read from device")
+                    break
+                except UnicodeDecodeError as error:
+                    self.log.warning(error)
+                    sleep(0.1)
+                except NoResponseError as error:
+                    self._handle_error(error, "Communication error")
+                    break
+                except InvalidResponseError as error:
+                    self._handle_error(error, "Invalid response error")
+                    break
+            else:
+                self.log.info("Lost connection with device")
+                self.connection.serial.close()
+                self.add_changed("handlers")
+                if self.config("auto-reconnect"):
+                    Thread(target=self._reconnect_watcher).start()
+                else:
+                    self.suspended = True
+                break
+        self.log.debug("Stopping message watcher")
+
+    def _handle_error(self, error, message):
+        # print(error)
+        self.log.warning(message)
+        self.log.error(error)
+        self.success = False
+        self.add_changed("handlers")
+        Thread(target=self._reconnect_watcher).start()
+
+    def _reconnect_watcher(self):
+        self.log.debug("Starting reconnect watcher")
+        while self.active:
+            if path.exists(self.connection.serial.port):
+                if self._reconnect():
+                    Thread(target=self._message_watcher).start()
+                    break
+            sleep(1)
+        self.log.debug("Stopping reconnect watcher")
+
+    def _reconnect(self):
+        try:
+            self.connection.serial.open()
+            self.log.info("Established connection with device")
+            self.add_changed("handlers")
+            return True
+        except SerialException:
+            if path.exists(self.connection.serial.port):
+                self.log.warning("Failed to establish connection - Permission denied")
+            else:
+                self.log.warning(
+                    "Failed to establish connection - Device does not exist"
+                )
+            self.connection.serial.close()
+            return False
+        except NoResponseError:
+            return False
+        except InvalidResponseError:
+            return False
+
+    def __init__(self, settings):
+        super().__init__(settings)
+        self.log = logger(
+            f"SerialDevice {self.config('port')}:{self.config('slave-address')}"
+        )
+
+        self.connection = Instrument(self.config("port"), self.config("slave-address"))
+        self.connection.serial.timeout = self.config("timeout")
+
+        self.active = True
+        self.suspended = False
+        self.add_changed("handlers")
+
+        Thread(target=self._reconnect_watcher).start()
+
+    def update_config(self, new_config):
+        super().update_config(new_config)
+
+        # TODO: Semaphore may be required
+
+        self.connection.serial.close()
+        self.connection.serial.port = self.config("port")
+        self.connection.serial.timeout = self.config("timeout")
+        self.connection.address = self.config("slave-address")
+        self.connection.serial.close()
+
+        if self.suspended:
+            Thread(target=self._reconnect_watcher).start()
+
+        self.add_changed("handlers")
+
+    def get_description(self):
+        return self.connection.serial.port
+
+    def is_connected(self):
+        return self.connection.serial.is_open

modules/web_server/static/images/icons/types/inverter.png

@@ -1,6 +1,7 @@
 eventlet
 flask
 flask-socketio
+minimalmodbus
 pony
 pyserial
 requests