Merge branch 'openWB:master' into master

Author: Brett-S-OWB

packages/modules/common/sdm.py

@@ -1,5 +1,6 @@
 #!/usr/bin/env python3
 from enum import IntEnum
+import logging
 import time
 from typing import List, Tuple
 
@@ -10,11 +11,14 @@
 from modules.common.hardware_check import check_meter_values
 from modules.common.modbus import ModbusDataType
 
+log = logging.getLogger(__name__)
+
 
 class Sdm(AbstractCounter):
     def __init__(self, modbus_id: int, client: modbus.ModbusTcpClient_) -> None:
         self.client = client
         self.id = modbus_id
+        self.fast_mode = True
         with client:
             self.serial_number = str(self.client.read_holding_registers(0xFC00, ModbusDataType.UINT_32, unit=self.id))
 
@@ -64,16 +68,48 @@ def get_voltages(self) -> Tuple[List[float], float]:
 
     def get_counter_state(self) -> CounterState:
         # entgegen der Doku können nicht bei allen SDM72 80 Register auf einmal gelesen werden,
-        # manche können auch nur 20
-        time.sleep(0.1)
-        bulk_1 = self.client.read_input_registers_bulk(
-            SdmRegister.VOLTAGE_L1, 20, mapping=self.REG_MAPPING_BULK_1, unit=self.id)
-        time.sleep(0.1)
-        power_factors = self.client.read_input_registers(0x1E, [ModbusDataType.FLOAT_32]*3, unit=self.id)
-        time.sleep(0.1)
-        bulk_2 = self.client.read_input_registers_bulk(
-            SdmRegister.FREQUENCY, 8, mapping=self.REG_MAPPING_BULK_2, unit=self.id)
-        resp = {**bulk_1, **bulk_2}
+        # manche können auch nur 10
+        if self.fast_mode:
+            try:
+                time.sleep(0.1)
+                bulk_1 = self.client.read_input_registers_bulk(
+                    SdmRegister.VOLTAGE_L1, 18, mapping=self.REG_MAPPING_BULK_1, unit=self.id)
+                time.sleep(0.1)
+                power_factors = self.client.read_input_registers(
+                    SdmRegister.POWER_FACTOR_L1, [ModbusDataType.FLOAT_32]*3, unit=self.id)
+                time.sleep(0.1)
+                bulk_2 = self.client.read_input_registers_bulk(
+                    SdmRegister.FREQUENCY, 6, mapping=self.REG_MAPPING_BULK_2, unit=self.id)
+                resp = {**bulk_1, **bulk_2}
+            except Exception:
+                log.exception("Fehler beim Auslesen des Zählers")
+                self.client.read_input_registers(
+                    SdmRegister.VOLTAGE_L1, [ModbusDataType.FLOAT_32]*3, unit=self.id)
+                self.fast_mode = False
+        if self.fast_mode is False:
+            # im gleichen Durchlauf noch im slow mode versuchen, sonst schlägt der Hardware-Check fehl
+            log.debug("Auslesung des Zählers im Kompatibilitäts-Modus")
+            resp = {}
+            time.sleep(0.1)
+            resp[SdmRegister.VOLTAGE_L1] = self.client.read_input_registers(
+                SdmRegister.VOLTAGE_L1, [ModbusDataType.FLOAT_32]*3, unit=self.id)
+            time.sleep(0.1)
+            resp[SdmRegister.CURRENT_L1] = self.client.read_input_registers(
+                SdmRegister.CURRENT_L1, [ModbusDataType.FLOAT_32]*3, unit=self.id)
+            time.sleep(0.1)
+            resp[SdmRegister.POWER_L1] = self.client.read_input_registers(
+                SdmRegister.POWER_L1, [ModbusDataType.FLOAT_32]*3, unit=self.id)
+            time.sleep(0.1)
+            power_factors = self.client.read_input_registers(
+                SdmRegister.POWER_FACTOR_L1, [ModbusDataType.FLOAT_32]*3, unit=self.id)
+            time.sleep(0.1)
+            # frequency noch mit auslesen klappt nicht
+            resp[SdmRegister.IMPORTED], resp[SdmRegister.EXPORTED] = self.client.read_input_registers(
+                SdmRegister.IMPORTED, [ModbusDataType.FLOAT_32]*2, unit=self.id)
+            time.sleep(0.1)
+            resp[SdmRegister.FREQUENCY] = self.client.read_input_registers(
+                SdmRegister.FREQUENCY, ModbusDataType.FLOAT_32, unit=self.id)
+
         frequency = resp[SdmRegister.FREQUENCY]
         if frequency > 100:
             frequency = frequency / 10
@@ -123,7 +159,7 @@ def get_counter_state(self) -> CounterState:
         power_factor = self.client.read_input_registers(0x1E, ModbusDataType.FLOAT_32, unit=self.id)
         time.sleep(0.1)
         bulk_2 = self.client.read_input_registers_bulk(
-            SdmRegister.FREQUENCY, 8, mapping=self.REG_MAPPING_BULK_2, unit=self.id)
+            SdmRegister.FREQUENCY, 6, mapping=self.REG_MAPPING_BULK_2, unit=self.id)
         resp = {**bulk_1, **bulk_2}
         frequency = resp[SdmRegister.FREQUENCY]
         if frequency > 100:

packages/modules/devices/elgris/elgris/bat.py

@@ -29,8 +29,7 @@ def initialize(self) -> None:
         self.store = get_bat_value_store(self.component_config.id)
 
     def update(self):
-        with self.__tcp_client:
-            counter_state = self.elgris.get_counter_state()
+        counter_state = self.elgris.get_counter_state()
         bat_state = BatState(
             exported=counter_state.exported,
             imported=counter_state.imported,

packages/modules/devices/elgris/elgris/counter.py

@@ -28,8 +28,7 @@ def initialize(self) -> None:
         self.store = get_counter_value_store(self.component_config.id)
 
     def update(self):
-        with self.__tcp_client:
-            counter_state = self.elgris.get_counter_state()
+        counter_state = self.elgris.get_counter_state()
         self.store.set(counter_state)
 
 

packages/modules/devices/elgris/elgris/elgris.py

@@ -9,3 +9,4 @@ def __init__(self, modbus_id: int, client: modbus.ModbusTcpClient_, fault_state:
         self.id = modbus_id
         self.serial_number = ""
         self.fault_state = fault_state
+        self.fast_mode = True

packages/modules/devices/elgris/elgris/elgris_test.py

@@ -0,0 +1,89 @@
+from unittest.mock import Mock
+
+from modules.common.component_state import BatState, CounterState, InverterState
+from modules.common.modbus import ModbusTcpClient_
+
+from modules.common.sdm import SdmRegister
+from modules.devices.elgris.elgris.config import Elgris, ElgrisBatSetup, ElgrisCounterSetup, ElgrisInverterSetup
+from modules.devices.elgris.elgris.device import create_device
+
+
+def setup_modbus_mocks(monkeypatch):
+    """Setup common Modbus mocks für alle Tests"""
+    mock_read_input_registers_bulk = Mock(side_effect=[
+        {SdmRegister.VOLTAGE_L1: [231]*3, SdmRegister.CURRENT_L1: [0.5]*3, SdmRegister.POWER_L1: [115]*3},
+        {SdmRegister.IMPORTED: 100, SdmRegister.EXPORTED: 200, SdmRegister.FREQUENCY: 50}])
+    mock_read_input_registers = Mock(side_effect=[[0.99]*3])
+
+    monkeypatch.setattr(ModbusTcpClient_, "__enter__", Mock())
+    monkeypatch.setattr(ModbusTcpClient_, "__exit__", Mock())
+    monkeypatch.setattr(ModbusTcpClient_, "read_input_registers_bulk", mock_read_input_registers_bulk)
+    monkeypatch.setattr(ModbusTcpClient_, "read_input_registers", mock_read_input_registers)
+
+
+def test_elgris_bat(monkeypatch):
+    setup_modbus_mocks(monkeypatch)
+
+    device = create_device(Elgris())
+    device.add_component(ElgrisBatSetup())
+
+    store_bat_mock = Mock()
+    monkeypatch.setattr(device.components["component0"], "store", store_bat_mock)
+
+    # execution
+    device.update()
+
+    # evaluation
+    assert vars(store_bat_mock.set.call_args[0][0]) == vars(BatState(
+        exported=200000,
+        imported=100000,
+        power=345,
+        currents=[0.5]*3,
+    ))
+
+
+def test_elgris_counter(monkeypatch):
+    setup_modbus_mocks(monkeypatch)
+
+    device = create_device(Elgris())
+    device.add_component(ElgrisCounterSetup(id=1))
+
+    store_counter_mock = Mock()
+    monkeypatch.setattr(device.components["component1"], "store", store_counter_mock)
+
+    # execution
+    device.update()
+
+    # evaluation
+    assert vars(store_counter_mock.set.call_args[0][0]) == vars(CounterState(
+        exported=200000,
+        imported=100000,
+        power=345,
+        voltages=[231]*3,
+        currents=[0.5]*3,
+        powers=[115]*3,
+        power_factors=[0.99]*3,
+        frequency=50,
+        serial_number=""
+    ))
+
+
+def test_elgris_inverter(monkeypatch):
+    setup_modbus_mocks(monkeypatch)
+
+    device = create_device(Elgris())
+    device.add_component(ElgrisInverterSetup(id=2))
+
+    store_inverter_mock = Mock()
+    monkeypatch.setattr(device.components["component2"], "store", store_inverter_mock)
+
+    # execution
+    device.update()
+
+    # evaluation
+    assert vars(store_inverter_mock.set.call_args[0][0]) == vars(InverterState(
+        exported=200000,
+        imported=100000,
+        power=345,
+        currents=[0.5]*3,
+    ))

packages/modules/devices/elgris/elgris/inverter.py

@@ -29,8 +29,7 @@ def initialize(self) -> None:
         self.store = get_inverter_value_store(self.component_config.id)
 
     def update(self):
-        with self.__tcp_client:
-            counter_state = self.elgris.get_counter_state()
+        counter_state = self.elgris.get_counter_state()
         inverter_state = InverterState(
             exported=counter_state.exported,
             imported=counter_state.imported,

packages/modules/web_themes/colors/config.py

@@ -1,12 +1,39 @@
 from helpermodules.auto_str import auto_str
-
 from modules.common.abstract_device import DeviceDescriptor
 
 
 @auto_str
 class ColorsWebThemeConfiguration:
-    def __init__(self) -> None:
-        pass
+    def __init__(self,
+                 displayMode: str = 'dark',
+                 smartHomeColors: str = 'normal',
+                 liveGraphDuration: int = 3600,
+                 showGrid: bool = False,
+                 decimalPlaces: int = 1,
+                 showRelativeArcs: bool = False,
+                 showInverters: bool = True,
+                 showVehicles: bool = False,
+                 showCounters: bool = False,
+                 showPrices: bool = False,
+                 alternativeEnergy: bool = False,
+                 showStandardVehicle: bool = False,
+                 lowerPriceBound: float = 0.0,
+                 upperPriceBound: float = 0.0
+                 ) -> None:
+        self.displayMode = displayMode
+        self.smartHomeColors = smartHomeColors
+        self.liveGraphDuration = liveGraphDuration
+        self.showGrid = showGrid
+        self.decimalPlaces = decimalPlaces
+        self.showRelativeArcs = showRelativeArcs
+        self.showInverters = showInverters
+        self.showVehicles = showVehicles
+        self.showCounters = showCounters
+        self.showPrices = showPrices
+        self.alternativeEnergy = alternativeEnergy
+        self.showStandardVehicle = showStandardVehicle
+        self.lowerPriceBound = lowerPriceBound
+        self.upperPriceBound = upperPriceBound
 
 
 @auto_str

packages/modules/web_themes/colors/source/README.md

@@ -1,4 +1,5 @@
 # wbcolortheme2
+
 Ein Theme für die openWB2 (http://openwb.de)
 
 Alpha version, basierend auf der Alpha der openwb2.