meter check for kits draft

packages/modules/chargepoints/openwb_pro/chargepoint_module.py

@@ -81,12 +81,11 @@ def request_values(self) -> None:
             )
 
             if json_rsp.get("voltages"):
-                meter_msg = check_meter_values(CounterState(voltages=json_rsp["voltages"],
-                                                            currents=json_rsp["currents"],
-                                                            powers=json_rsp["powers"],
-                                                            power=json_rsp["power_all"]))
-                if meter_msg:
-                    self.fault_state.warning(meter_msg)
+                check_meter_values(CounterState(voltages=json_rsp["voltages"],
+                                                currents=json_rsp["currents"],
+                                                powers=json_rsp["powers"],
+                                                power=json_rsp["power_all"]),
+                                   self.fault_state)
                 chargepoint_state.voltages = json_rsp["voltages"]
             if json_rsp.get("soc_value"):
                 chargepoint_state.soc = json_rsp["soc_value"]

packages/modules/common/hardware_check.py

@@ -23,7 +23,13 @@
 EVSE_BROKEN = "Auslesen der EVSE nicht möglich. Vermutlich ist die EVSE defekt oder hat eine unbekannte Modbus-ID."
 
 
-def check_meter_values(counter_state: CounterState) -> Optional[str]:
+def check_meter_values(counter_state: CounterState, fault_state: Optional[FaultState] = None) -> None:
+    meter_msg = _check_meter_values(counter_state)
+    if fault_state and meter_msg:
+        fault_state.warning(meter_msg)
+
+
+def _check_meter_values(counter_state: CounterState) -> Optional[str]:
     def valid_voltage(voltage) -> bool:
         return 200 < voltage < 250
     voltages = counter_state.voltages
@@ -111,6 +117,6 @@ def check_meter(self: ClientHandlerProtocol) -> Tuple[bool, Optional[str], Count
                 counter_state = self.meter_client.get_counter_state()
             if counter_state.serial_number == "0" or counter_state.serial_number is None:
                 return True, METER_NO_SERIAL_NUMBER, counter_state
-            return True, check_meter_values(counter_state), counter_state
+            return True, _check_meter_values(counter_state), counter_state
         except Exception:
             return False, METER_PROBLEM, None

packages/modules/common/hardware_check_test.py

@@ -9,7 +9,7 @@
 from modules.common.evse import Evse
 from modules.common.hardware_check import (
     EVSE_BROKEN, LAN_ADAPTER_BROKEN, METER_BROKEN_VOLTAGES, METER_NO_SERIAL_NUMBER, METER_PROBLEM,
-    OPEN_TICKET, USB_ADAPTER_BROKEN, SeriesHardwareCheckMixin, check_meter_values)
+    OPEN_TICKET, USB_ADAPTER_BROKEN, SeriesHardwareCheckMixin, _check_meter_values)
 from modules.common.modbus import NO_CONNECTION, ModbusSerialClient_, ModbusTcpClient_
 from modules.conftest import SAMPLE_IP, SAMPLE_PORT
 from modules.internal_chargepoint_handler.clients import ClientHandler
@@ -109,7 +109,7 @@ def test_check_meter_values(voltages, power, expected_msg, monkeypatch):
     # setup
     counter_state = Mock(voltages=voltages, currents=[0, 0, 0], powers=[0, 0, 0], power=power)
     # execution
-    msg = check_meter_values(counter_state)
+    msg = _check_meter_values(counter_state)
 
     # assert
     assert msg == expected_msg if expected_msg is None else expected_msg.format(voltages)

packages/modules/common/lovato.py

@@ -4,13 +4,16 @@
 from typing import List, Tuple
 from modules.common.abstract_counter import AbstractCounter
 from modules.common.component_state import CounterState
+from modules.common.fault_state import FaultState
+from modules.common.hardware_check import check_meter_values
 from modules.common.modbus import ModbusDataType
 
 
 class Lovato(AbstractCounter):
-    def __init__(self, modbus_id: int, client: modbus.ModbusTcpClient_) -> None:
+    def __init__(self, modbus_id: int, client: modbus.ModbusTcpClient_, fault_state: FaultState) -> None:
         self.client = client
         self.id = modbus_id
+        self.fault_state = fault_state
 
     def get_voltages(self) -> List[float]:
         return [val / 100 for val in self.client.read_input_registers(
@@ -40,11 +43,13 @@ def get_currents(self) -> List[float]:
 
     def get_counter_state(self) -> CounterState:
         powers, power = self.get_power()
-        return CounterState(
+        counter_state = CounterState(
             power=power,
             voltages=self.get_voltages(),
             currents=self.get_currents(),
             powers=powers,
             power_factors=self.get_power_factors(),
             frequency=self.get_frequency()
         )
+        check_meter_values(counter_state, self.fault_state)
+        return counter_state

packages/modules/common/mpm3pm.py

@@ -4,13 +4,16 @@
 from modules.common import modbus
 from modules.common.abstract_counter import AbstractCounter
 from modules.common.component_state import CounterState
+from modules.common.fault_state import FaultState
+from modules.common.hardware_check import check_meter_values
 from modules.common.modbus import ModbusDataType
 
 
 class Mpm3pm(AbstractCounter):
-    def __init__(self, modbus_id: int, client: modbus.ModbusTcpClient_) -> None:
+    def __init__(self, modbus_id: int, client: modbus.ModbusTcpClient_, fault_state: FaultState) -> None:
         self.client = client
         self.id = modbus_id
+        self.fault_state = fault_state
 
     def get_voltages(self) -> List[float]:
         return [val / 10 for val in self.client.read_input_registers(
@@ -51,7 +54,7 @@ def get_serial_number(self) -> str:
 
     def get_counter_state(self) -> CounterState:
         powers, power = self.get_power()
-        return CounterState(
+        counter_state = CounterState(
             voltages=self.get_voltages(),
             currents=self.get_currents(),
             powers=powers,
@@ -62,3 +65,5 @@ def get_counter_state(self) -> CounterState:
             frequency=self.get_frequency(),
             serial_number=self.get_serial_number()
         )
+        check_meter_values(counter_state, self.fault_state)
+        return counter_state

packages/modules/common/sdm.py

@@ -4,6 +4,8 @@
 from modules.common import modbus
 from modules.common.abstract_counter import AbstractCounter
 from modules.common.component_state import CounterState
+from modules.common.fault_state import FaultState
+from modules.common.hardware_check import check_meter_values
 from modules.common.modbus import ModbusDataType
 
 
@@ -31,8 +33,9 @@ def get_serial_number(self) -> str:
 
 
 class Sdm630_72(Sdm):
-    def __init__(self, modbus_id: int, client: modbus.ModbusTcpClient_) -> None:
+    def __init__(self, modbus_id: int, client: modbus.ModbusTcpClient_, fault_state: FaultState) -> None:
         super().__init__(modbus_id, client)
+        self.fault_state = fault_state
 
     def get_currents(self) -> List[float]:
         return self.client.read_input_registers(0x06, [ModbusDataType.FLOAT_32]*3, unit=self.id)
@@ -50,7 +53,7 @@ def get_voltages(self) -> List[float]:
 
     def get_counter_state(self) -> CounterState:
         powers, power = self.get_power()
-        return CounterState(
+        counter_state = CounterState(
             imported=self.get_imported(),
             exported=self.get_exported(),
             power=power,
@@ -61,11 +64,14 @@ def get_counter_state(self) -> CounterState:
             frequency=self.get_frequency(),
             serial_number=self.get_serial_number()
         )
+        check_meter_values(counter_state, self.fault_state)
+        return counter_state
 
 
 class Sdm120(Sdm):
-    def __init__(self, modbus_id: int, client: modbus.ModbusTcpClient_) -> None:
+    def __init__(self, modbus_id: int, client: modbus.ModbusTcpClient_, fault_state: FaultState) -> None:
         super().__init__(modbus_id, client)
+        self.fault_state = fault_state
 
     def get_power(self) -> Tuple[List[float], float]:
         power = self.client.read_input_registers(0x0C, ModbusDataType.FLOAT_32, unit=self.id)
@@ -76,7 +82,7 @@ def get_currents(self) -> List[float]:
 
     def get_counter_state(self) -> CounterState:
         powers, power = self.get_power()
-        return CounterState(
+        counter_state = CounterState(
             imported=self.get_imported(),
             exported=self.get_exported(),
             power=power,
@@ -85,3 +91,5 @@ def get_counter_state(self) -> CounterState:
             frequency=self.get_frequency(),
             serial_number=self.get_serial_number()
         )
+        check_meter_values(counter_state, self.fault_state)
+        return counter_state

packages/modules/devices/openwb/openwb_flex/bat.py

@@ -23,14 +23,15 @@ def __init__(self,
                  tcp_client: modbus.ModbusTcpClient_) -> None:
         self.__device_id = device_id
         self.component_config = dataclass_from_dict(BatKitFlexSetup, component_config)
+        self.fault_state = FaultState(ComponentInfo.from_component_config(self.component_config))
         factory = kit_bat_version_factory(
             self.component_config.configuration.version)
         self.__client = factory(self.component_config.configuration.id,
-                                tcp_client)
+                                tcp_client,
+                                self.fault_state)
         self.__tcp_client = tcp_client
         self.sim_counter = SimCounter(self.__device_id, self.component_config.id, prefix="speicher")
         self.store = get_bat_value_store(self.component_config.id)
-        self.fault_state = FaultState(ComponentInfo.from_component_config(self.component_config))
 
     def update(self):
         # TCP-Verbindung schließen möglichst bevor etwas anderes gemacht wird, um im Fehlerfall zu verhindern,

packages/modules/devices/openwb/openwb_flex/counter.py

@@ -21,14 +21,15 @@ def __init__(self,
                  tcp_client: modbus.ModbusTcpClient_) -> None:
         self.__device_id = device_id
         self.component_config = dataclass_from_dict(EvuKitFlexSetup, component_config)
+        self.fault_state = FaultState(ComponentInfo.from_component_config(self.component_config))
         factory = kit_counter_version_factory(
             self.component_config.configuration.version)
         self.__client = factory(self.component_config.configuration.id,
-                                tcp_client)
+                                tcp_client,
+                                self.fault_state)
         self.__tcp_client = tcp_client
         self.sim_counter = SimCounter(self.__device_id, self.component_config.id, prefix="bezug")
         self.store = get_counter_value_store(self.component_config.id)
-        self.fault_state = FaultState(ComponentInfo.from_component_config(self.component_config))
 
     def update(self):
         # TCP-Verbindung schließen möglichst bevor etwas anderes gemacht wird, um im Fehlerfall zu verhindern,

packages/modules/devices/openwb/openwb_flex/inverter.py

@@ -22,14 +22,14 @@ def __init__(self,
                  tcp_client: modbus.ModbusTcpClient_) -> None:
         self.__device_id = device_id
         self.component_config = dataclass_from_dict(PvKitFlexSetup, component_config)
+        self.fault_state = FaultState(ComponentInfo.from_component_config(self.component_config))
         factory = kit_inverter_version_factory(
             self.component_config.configuration.version)
-        self.__client = factory(self.component_config.configuration.id, tcp_client)
+        self.__client = factory(self.component_config.configuration.id, tcp_client, self.fault_state)
         self.__tcp_client = tcp_client
         self.sim_counter = SimCounter(self.__device_id, self.component_config.id, prefix="pv")
         self.simulation = {}
         self.store = get_inverter_value_store(self.component_config.id)
-        self.fault_state = FaultState(ComponentInfo.from_component_config(self.component_config))
 
     def update(self) -> None:
         """ liest die Werte des Moduls aus.

packages/modules/internal_chargepoint_handler/clients.py

@@ -59,9 +59,9 @@ def _evse_factory(self, client: Union[ModbusSerialClient_, ModbusTcpClient_], ev
             return None
 
     @staticmethod
-    def find_meter_client(meters: List[meter_config], client: Union[ModbusSerialClient_, ModbusTcpClient_]) -> METERS:
+    def find_meter_client(meters: List[meter_config], client: Union[ModbusSerialClient_, ModbusTcpClient_], fault_state: FaultState) -> METERS:
         for meter_type, modbus_id in meters:
-            meter_client = meter_type(modbus_id, client)
+            meter_client = meter_type(modbus_id, client, fault_state)
             with client:
                 try:
                     if meter_client.get_voltages()[0] > 200:
@@ -93,12 +93,13 @@ def client_factory(local_charge_point_num: int,
                    fault_state: FaultState,
                    created_client_handler: Optional[ClientHandler] = None) -> ClientHandler:
     serial_client, evse_ids = get_modbus_client(
-        local_charge_point_num, created_client_handler)
+        local_charge_point_num, created_client_handler, fault_state)
     return ClientHandler(local_charge_point_num, serial_client, evse_ids, fault_state)
 
 
 def get_modbus_client(local_charge_point_num: int,
-                      created_client_handler: Optional[ClientHandler] = None):
+                      created_client_handler: Optional[ClientHandler] = None,
+                      fault_state: Optional[FaultState] = None) -> Tuple[Union[ModbusSerialClient_, ModbusTcpClient_], List[int]]:
     tty_devices = list(Path("/dev/serial/by-path").glob("*"))
     log.debug("tty_devices"+str(tty_devices))
     resolved_devices = [str(file.resolve()) for file in tty_devices]
@@ -140,7 +141,7 @@ def get_modbus_client(local_charge_point_num: int,
                 serial_client = ModbusSerialClient_(device)
                 # Source immer an der Modbus-ID des Zählers fest machen, da diese immer fest ist.
                 # Die USB-Anschlüsse können vertauscht sein.
-                detected_device = ClientHandler.find_meter_client(meters, serial_client)
+                detected_device = ClientHandler.find_meter_client(meters, serial_client, fault_state)
                 if detected_device:
                     break
         with ModifyLoglevelContext(log, logging.DEBUG):