factories for components

packages/modules/kostal_plenticore/bat.py

@@ -4,19 +4,26 @@
 from modules.common.component_type import ComponentDescriptor
 from modules.common.modbus import ModbusDataType
 from modules.common.fault_state import ComponentInfo
+from modules.common.simcount import SimCounter
 from modules.common.store import get_bat_value_store
 from modules.kostal_plenticore.config import KostalPlenticoreBatSetup
 
 
 class KostalPlenticoreBat:
-    def __init__(self, component_config: KostalPlenticoreBatSetup) -> None:
+    def __init__(self,
+                 device_id: int,
+                 component_config: KostalPlenticoreBatSetup,
+                 reader: Callable[[int, ModbusDataType], Any]) -> None:
         self.component_config = component_config
-        self.__store = get_bat_value_store(self.component_config.id)
+        self.__reader = reader
+        self.store = get_bat_value_store(self.component_config.id)
+        self.sim_counter = SimCounter(device_id, self.component_config.id, prefix="speicher")
         self.component_info = ComponentInfo.from_component_config(self.component_config)
 
-    def update(self, reader: Callable[[int, ModbusDataType], Any]) -> BatState:
-        power = reader(582, ModbusDataType.INT_16)
-        soc = reader(514, ModbusDataType.INT_16)
+    def update(self) -> BatState:
+        power = self.__reader(582, ModbusDataType.INT_16)
+        soc = self.__reader(514, ModbusDataType.INT_16)
+        imported, exported = self.sim_counter.sim_count(power)
 
         return BatState(
             power=power,
@@ -26,11 +33,7 @@ def update(self, reader: Callable[[int, ModbusDataType], Any]) -> BatState:
         )
 
     def set(self, state):
-        self.__store.set(state)
-
-
-def create_component(component_config: KostalPlenticoreBatSetup):
-    return KostalPlenticoreBat(component_config)
+        self.store.set(state)
 
 
 component_descriptor = ComponentDescriptor(configuration_factory=KostalPlenticoreBatSetup)

packages/modules/kostal_plenticore/config.py

@@ -43,7 +43,7 @@ class KostalPlenticoreCounterSetup(ComponentSetup[KostalPlenticoreCounterConfigu
     def __init__(self,
                  name: str = "Kostal Plenticore Zähler",
                  type: str = "counter",
-                 id: int = 0,
+                 id: Optional[int] = 0,
                  configuration: KostalPlenticoreCounterConfiguration = None) -> None:
         super().__init__(name, type, id, configuration or KostalPlenticoreCounterConfiguration())
 

packages/modules/kostal_plenticore/counter.py

@@ -4,23 +4,30 @@
 from modules.common.component_type import ComponentDescriptor
 from modules.common.fault_state import ComponentInfo
 from modules.common.modbus import ModbusDataType
+from modules.common.simcount import SimCounter
 from modules.common.store import get_counter_value_store
 from modules.kostal_plenticore.config import KostalPlenticoreCounterSetup
 
 
 class KostalPlenticoreCounter:
-    def __init__(self, component_config: KostalPlenticoreCounterSetup) -> None:
+    def __init__(self,
+                 device_id: int,
+                 component_config: KostalPlenticoreCounterSetup,
+                 reader: Callable[[int, ModbusDataType], Any]) -> None:
         self.component_config = component_config
-        self.__store = get_counter_value_store(self.component_config.id)
+        self.__reader = reader
+        self.store = get_counter_value_store(self.component_config.id)
+        self.sim_counter = SimCounter(device_id, self.component_config.id, prefix="bezug")
         self.component_info = ComponentInfo.from_component_config(self.component_config)
 
-    def update(self, reader: Callable[[int, ModbusDataType], Any]) -> None:
-        power_factor = reader(150, ModbusDataType.FLOAT_32)
-        currents = [reader(register, ModbusDataType.FLOAT_32) for register in [222, 232, 242]]
-        voltages = [reader(register, ModbusDataType.FLOAT_32) for register in [230, 240, 250]]
-        powers = [reader(register, ModbusDataType.FLOAT_32) for register in [224, 234, 244]]
-        power = reader(252, ModbusDataType.FLOAT_32)
-        frequency = reader(220, ModbusDataType.FLOAT_32)
+    def update(self) -> None:
+        power_factor = self.__reader(150, ModbusDataType.FLOAT_32)
+        currents = [self.__reader(register, ModbusDataType.FLOAT_32) for register in [222, 232, 242]]
+        voltages = [self.__reader(register, ModbusDataType.FLOAT_32) for register in [230, 240, 250]]
+        powers = [self.__reader(register, ModbusDataType.FLOAT_32) for register in [224, 234, 244]]
+        power = self.__reader(252, ModbusDataType.FLOAT_32)
+        frequency = self.__reader(220, ModbusDataType.FLOAT_32)
+        imported, exported = self.sim_counter.sim_count(power)
 
         counter_state = CounterState(
             powers=powers,
@@ -32,7 +39,7 @@ def update(self, reader: Callable[[int, ModbusDataType], Any]) -> None:
             power_factors=[power_factor]*3,
             frequency=frequency
         )
-        self.__store.set(counter_state)
+        self.store.set(counter_state)
 
 
 def create_component(component_config: KostalPlenticoreCounterSetup):

packages/modules/kostal_plenticore/device.py

@@ -2,7 +2,7 @@
 import logging
 from ipparser import ipparser
 from pymodbus.constants import Endian
-from typing import Any, Callable, List, Optional
+from typing import Any, Callable, Iterable, List, Union
 
 from helpermodules.cli import run_using_positional_cli_args
 from modules.common import modbus
@@ -18,23 +18,20 @@
 log = logging.getLogger(__name__)
 
 
-def update_components(components_todo, tcp_client: modbus.ModbusTcpClient_):
-    def little_endian_wordorder_reader(register: int, data_type: modbus.ModbusDataType):
-        return tcp_client.read_holding_registers(
-            register, data_type, unit=71, wordorder=Endian.Little)
-    reader = little_endian_wordorder_reader
+def update_components(
+        components: Iterable[Union[KostalPlenticoreBat, KostalPlenticoreCounter, KostalPlenticoreInverter]]):
     with tcp_client:
-        for component in components_todo:
+        for component in components:
             if isinstance(component, KostalPlenticoreBat):
-                bat_state = component.update(reader)
+                bat_state = component.update()
         else:
             bat_state = None
-        for component in components_todo:
+        for component in components:
             if isinstance(component, KostalPlenticoreInverter):
-                inverter_state = component.update(reader)
+                inverter_state = component.update()
                 if bat_state:
-                    dc_in = component.dc_in_string_1_2(reader)
-                    home_consumption = component.home_consumption(reader)
+                    dc_in = component.dc_in_string_1_2()
+                    home_consumption = component.home_consumption()
                     if dc_in >= 0:
                         if bat_state.power > 0:
                             raw_inv_power = inverter_state.power
@@ -44,21 +41,34 @@ def little_endian_wordorder_reader(register: int, data_type: modbus.ModbusDataTy
                             inverter_state.power -= bat_state.power
                 component.set(inverter_state)
             else:
-                component.update(reader)
+                component.update()
         if bat_state:
-            for component in components_todo:
+            for component in components:
                 if isinstance(component, KostalPlenticoreBat):
                     component.set(bat_state)
 
 
 def create_device(device_config: KostalPlenticore):
+    def create_bat_component(component_config):
+        return KostalPlenticoreBat(device_config.id, component_config, reader)
+
+    def create_counter_component(component_config):
+        return KostalPlenticoreCounter(device_config.id, component_config, reader)
+
+    def create_inverter_component(component_config):
+        return KostalPlenticoreInverter(component_config, reader)
+
+    def little_endian_wordorder_reader(register: int, data_type: modbus.ModbusDataType):
+        return tcp_client.read_holding_registers(
+            register, data_type, unit=71, wordorder=Endian.Little)
+    reader = little_endian_wordorder_reader
+
     tcp_client = modbus.ModbusTcpClient_(device_config.configuration.ip_address, 1502)
     return ConfigurableDevice(
         device_config=device_config,
         component_factory=ComponentFactoryByType(
-            bat=bat.create_component, counter=counter.create_component, inverter=inverter.create_component),
-        component_updater=MultiComponentUpdater(
-            lambda update_components: update_components(components_todo, tcp_client)),
+            bat=create_bat_component, counter=create_counter_component, inverter=create_inverter_component),
+        component_updater=MultiComponentUpdater(update_components),
     )
 
 

packages/modules/kostal_plenticore/inverter.py

@@ -9,32 +9,31 @@
 
 
 class KostalPlenticoreInverter:
-    def __init__(self, component_config: KostalPlenticoreInverterSetup) -> None:
+    def __init__(self,
+                 component_config: KostalPlenticoreInverterSetup,
+                 reader: Callable[[int, ModbusDataType], Any]) -> None:
         self.component_config = component_config
+        self.__reader = reader
         self.__store = get_inverter_value_store(self.component_config.id)
         self.component_info = ComponentInfo.from_component_config(self.component_config)
 
-    def update(self, reader: Callable[[int, ModbusDataType], Any]) -> InverterState:
-        power = min(0, reader(575, ModbusDataType.INT_16))
-        exported = reader(320, ModbusDataType.FLOAT_32)
+    def update(self) -> InverterState:
+        power = min(0, self.__reader(575, ModbusDataType.INT_16))
+        exported = self.__reader(320, ModbusDataType.FLOAT_32)
 
         return InverterState(
             power=power,
             exported=exported
         )
 
-    def dc_in_string_1_2(self, reader):
-        return reader(260, ModbusDataType.FLOAT_32) + reader(270, ModbusDataType.FLOAT_32)
+    def dc_in_string_1_2(self):
+        return self.__reader(260, ModbusDataType.FLOAT_32) + self.__reader(270, ModbusDataType.FLOAT_32)
 
-    def home_consumption(self, reader):
-        return reader(106, ModbusDataType.FLOAT_32)
+    def home_consumption(self):
+        return self.__reader(106, ModbusDataType.FLOAT_32)
 
     def set(self, state):
         self.__store.set(state)
 
 
-def create_component(component_config: KostalPlenticoreInverterSetup):
-    return KostalPlenticoreInverter(component_config)
-
-
 component_descriptor = ComponentDescriptor(configuration_factory=KostalPlenticoreInverterSetup)