Merge branch 'openWB:master' into master

packages/control/algorithm/additional_current.py

@@ -28,6 +28,7 @@ def set_additional_current(self, mode_range: List[int]) -> None:
                     cp = preferenced_chargepoints[0]
                     missing_currents, counts = common.get_missing_currents_left(preferenced_chargepoints)
                     available_currents, limit = Loadmanagement().get_available_currents(missing_currents, counter)
+                    cp.data.control_parameter.limit = limit
                     available_for_cp = common.available_current_for_cp(cp, counts, available_currents, missing_currents)
                     current = common.get_current_to_set(
                         cp.data.set.current, available_for_cp, cp.data.set.target_current)
@@ -51,6 +52,6 @@ def _set_loadmangement_message(self,
         if (current != max(chargepoint.data.set.target_current, chargepoint.data.set.current or 0) and
                 # Strom erreicht nicht die vorgegebene Stromstärke
                 current != max(
-                    chargepoint.data.set.charging_ev_data.data.control_parameter.required_currents)):
+                    chargepoint.data.control_parameter.required_currents)):
             chargepoint.set_state_and_log(f"Es kann nicht mit der vorgegebenen Stromstärke geladen werden"
                                           f"{limit.value.format(get_component_name_by_id(counter.num))}")

packages/control/algorithm/additional_current_test.py

@@ -3,6 +3,7 @@
 
 from control.algorithm import additional_current
 from control.chargepoint.chargepoint import Chargepoint, ChargepointData, Set
+from control.chargepoint.control_parameter import ControlParameter
 from control.ev import ChargeTemplate, Ev
 from control.loadmanagement import LimitingValue
 
@@ -28,9 +29,9 @@ def test_set_loadmangement_message(set_current, limit, expected_msg, monkeypatch
     # setup
     ev = Ev(0)
     ev.charge_template = ChargeTemplate(0)
-    ev.data.control_parameter.required_currents = [7]*3
     cp1 = Chargepoint(1, None)
-    cp1.data = ChargepointData(set=Set(current=set_current))
+    cp1.data = ChargepointData(set=Set(current=set_current),
+                               control_parameter=ControlParameter(required_currents=[8]*3))
     mockget_component_name_by_id = Mock(return_value="Garage")
     monkeypatch.setattr(additional_current, "get_component_name_by_id", mockget_component_name_by_id)
 

packages/control/algorithm/algorithm.py

@@ -7,7 +7,7 @@
 from control.algorithm.min_current import MinCurrent
 from control.algorithm.no_current import NoCurrent
 from control.algorithm.surplus_controlled import SurplusControlled
-from helpermodules.pub import Pub
+
 log = logging.getLogger(__name__)
 
 
@@ -55,29 +55,27 @@ def _check_auto_phase_switch_delay(self) -> None:
             try:
                 if cp.data.set.charging_ev != -1:
                     charging_ev = cp.data.set.charging_ev_data
-                    control_parameter = charging_ev.data.control_parameter
+                    control_parameter = cp.data.control_parameter
                     if cp.cp_ev_chargemode_support_phase_switch():
                         # Gibt die Stromstärke und Phasen zurück, mit denen nach der Umschaltung geladen werden
                         # soll. Falls keine Umschaltung erforderlich ist, werden Strom und Phasen, die übergeben
                         # wurden, wieder zurückgegeben.
                         log.debug(f"Ladepunkt {cp.num}: Prüfen, ob Phasenumschaltung durchgeführt werden soll.")
                         phases, current, message = charging_ev.auto_phase_switch(
+                            cp.data.control_parameter,
                             cp.num,
                             cp.data.get.currents,
                             cp.data.get.power,
                             cp.template.data.max_current_single_phase,
-                            cp.get_max_phase_hw())
+                            cp.get_max_phase_hw(),
+                            cp.data.control_parameter.limit)
                         if message is not None:
                             cp.data.get.state_str = message
                         # Nachdem im Automatikmodus die Anzahl Phasen bekannt ist, Einhaltung des Maximalstroms
                         # prüfen.
                         required_current = cp.check_min_max_current(current, control_parameter.phases)
-                        charging_ev.data.control_parameter.required_current = required_current
-                        Pub().pub("openWB/set/vehicle/"+str(charging_ev.num) +
-                                  "/control_parameter/required_current", required_current)
-                        charging_ev.data.control_parameter.phases = phases
-                        Pub().pub("openWB/set/vehicle/"+str(charging_ev.num) +
-                                  "/control_parameter/phases", phases)
+                        cp.data.control_parameter.required_current = required_current
+                        cp.data.control_parameter.phases = phases
                         cp.set_required_currents(required_current)
             except Exception:
                 log.exception(f"Fehler im Algorithmus-Modul für Ladepunkt{cp.num}")

packages/control/algorithm/common.py

@@ -68,7 +68,7 @@ def get_min_current(chargepoint: Chargepoint) -> Tuple[List[float], List[int]]:
     min_currents = [0.0]*3
     counts = [0]*3
     charging_ev_data = chargepoint.data.set.charging_ev_data
-    required_currents = charging_ev_data.data.control_parameter.required_currents
+    required_currents = chargepoint.data.control_parameter.required_currents
     for i in range(3):
         if required_currents[i] != 0:
             counts[i] += 1
@@ -81,7 +81,7 @@ def get_min_current(chargepoint: Chargepoint) -> Tuple[List[float], List[int]]:
 
 
 def set_current_counterdiff(diff: float, current: float, chargepoint: Chargepoint, surplus: bool = False) -> None:
-    required_currents = chargepoint.data.set.charging_ev_data.data.control_parameter.required_currents
+    required_currents = chargepoint.data.control_parameter.required_currents
     diffs = [diff if required_currents[i] != 0 else 0 for i in range(3)]
     if max(diffs) > 0:
         counters = data.data.counter_all_data.get_counters_to_check(chargepoint.num)
@@ -116,7 +116,7 @@ def available_current_for_cp(chargepoint: Chargepoint,
                              counts: List[int],
                              available_currents: List[float],
                              missing_currents: List[float]) -> float:
-    control_parameter = chargepoint.data.set.charging_ev_data.data.control_parameter
+    control_parameter = chargepoint.data.control_parameter
     available_current = float("inf")
     missing_current_cp = control_parameter.required_current - chargepoint.data.set.target_current
     for i in range(0, 3):
@@ -137,7 +137,7 @@ def update_raw_data(preferenced_chargepoints: List[Chargepoint],
         if consider_not_charging_chargepoint_in_loadmanagement(chargepoint):
             continue
         charging_ev_data = chargepoint.data.set.charging_ev_data
-        required_currents = charging_ev_data.data.control_parameter.required_currents
+        required_currents = chargepoint.data.control_parameter.required_currents
         max_target_set_current = max(chargepoint.data.set.target_current, chargepoint.data.set.current or 0)
 
         if diff_to_zero is False:
@@ -172,7 +172,7 @@ def get_missing_currents_left(preferenced_chargepoints: List[Chargepoint]) -> Tu
     counts = [0]*3
     for chargepoint in preferenced_chargepoints:
         charging_ev_data = chargepoint.data.set.charging_ev_data
-        required_currents = charging_ev_data.data.control_parameter.required_currents
+        required_currents = chargepoint.data.control_parameter.required_currents
         for i in range(0, 3):
             if required_currents[i] != 0:
                 counts[i] += 1

packages/control/algorithm/common_test.py

@@ -47,7 +47,7 @@ def test_set_current_counterdiff(diff: float,
     # setup
     cp = Chargepoint(4, None)
     ev = Ev(0)
-    ev.data.control_parameter.required_currents = required_currents
+    cp.data.control_parameter.required_currents = required_currents
     cp.data.set.charging_ev_data = ev
     cp.data.set.current = 6
     get_counters_to_check_mock = Mock(return_value=["cp0", "cp6"])
@@ -74,7 +74,7 @@ def test_get_min_current(required_currents: List[float], expected_mins_counts: T
     # setup
     cp = Chargepoint(4, None)
     ev = Ev(0)
-    ev.data.control_parameter.required_currents = required_currents
+    cp.data.control_parameter.required_currents = required_currents
     cp.data.set.charging_ev_data = ev
 
     # evaluation
@@ -114,8 +114,8 @@ def test_available_currents_for_cp(counts: List[int],
     # setup
     cp = Chargepoint(4, None)
     ev = Ev(0)
-    ev.data.control_parameter.required_currents = [16]*3
-    ev.data.control_parameter.required_current = 16
+    cp.data.control_parameter.required_currents = [16]*3
+    cp.data.control_parameter.required_current = 16
     cp.data.set.charging_ev_data = ev
     cp.data.set.target_current = 10
 
@@ -139,7 +139,7 @@ def test_get_missing_currents_left(required_currents_1: List[float],
     def setup_cp(num: int, required_currents) -> Chargepoint:
         ev = Ev(0)
         cp = Chargepoint(num, None)
-        ev.data.control_parameter.required_currents = required_currents
+        cp.data.control_parameter.required_currents = required_currents
         cp.data.set.charging_ev_data = ev
         return cp
 

packages/control/algorithm/filter_chargepoints.py

@@ -28,11 +28,10 @@ def get_chargepoints_by_mode(mode_tuple: Tuple[Optional[str], str, bool]) -> Lis
     valid_chargepoints = []
     for cp in data.data.cp_data.values():
         if cp.data.set.charging_ev != -1:
-            charging_ev = cp.data.set.charging_ev_data
-            if ((charging_ev.data.control_parameter.prio == prio) and
-                (charging_ev.data.control_parameter.chargemode == mode or
+            if ((cp.data.control_parameter.prio == prio) and
+                (cp.data.control_parameter.chargemode == mode or
                     mode is None) and
-                    (charging_ev.data.control_parameter.submode == submode)):
+                    (cp.data.control_parameter.submode == submode)):
                 valid_chargepoints.append(cp)
     return valid_chargepoints
 
@@ -90,7 +89,7 @@ def _get_preferenced_chargepoint(valid_chargepoints: List[Chargepoint]) -> List:
                 # entsprechend der Bedingung die Values im Dictionary füllen
                 if condition_types[condition] == "min_current":
                     chargepoints.update(
-                        (cp, cp.data.set.charging_ev_data.data.control_parameter.required_current)
+                        (cp, cp.data.control_parameter.required_current)
                         for cp in chargepoints.keys())
                 elif condition_types[condition] == "soc":
                     chargepoints.update(

packages/control/algorithm/filter_chargepoints_test.py

@@ -64,11 +64,11 @@ def test_get_preferenced_chargepoint(params: PreferencedParams):
     # setup
     def mock_cp(cp: Chargepoint, num: int):
         ev = Ev(0)
-        ev.data = EvData(control_parameter=ControlParameter(
-            required_current=getattr(params, f"required_current_{num}")),
-            get=Get(soc=getattr(params, f"soc_{num}")))
+        ev.data = EvData(get=Get(soc=getattr(params, f"soc_{num}")))
         cp.data = ChargepointData(set=Set(plug_time=getattr(params, f"plug_time_{num}"), log=Log(
-            imported_since_plugged=getattr(params, f"imported_since_plugged_{num}")), charging_ev_data=ev))
+            imported_since_plugged=getattr(params, f"imported_since_plugged_{num}")), charging_ev_data=ev),
+            control_parameter=ControlParameter(
+            required_current=getattr(params, f"required_current_{num}")))
         cp.num = num
         return cp
 
@@ -124,10 +124,9 @@ def test_get_chargepoints_by_mode(set_mode_tuple: Tuple[Optional[str], str, bool
     # setup
     def setup_cp(cp: Chargepoint, charging_ev: int, mode_tuple: Tuple[str, str, bool]) -> Chargepoint:
         cp.data.set.charging_ev = charging_ev
-        charging_ev_data = cp.data.set.charging_ev_data
-        charging_ev_data.data.control_parameter.prio = mode_tuple[2]
-        charging_ev_data.data.control_parameter.chargemode = mode_tuple[0]
-        charging_ev_data.data.control_parameter.submode = mode_tuple[1]
+        cp.data.control_parameter.prio = mode_tuple[2]
+        cp.data.control_parameter.chargemode = mode_tuple[0]
+        cp.data.control_parameter.submode = mode_tuple[1]
         return cp
     data.data.cp_data = {"cp1": setup_cp(mock_cp1, charging_ev_1, mode_tuple_1),
                          "cp2": setup_cp(mock_cp2, charging_ev_2, mode_tuple_2)}
@@ -178,8 +177,7 @@ def test_get_chargepoints_submode_pv_charging(submode_1: Chargemode,
     # setup
     def setup_cp(cp: Chargepoint, submode: str) -> Chargepoint:
         cp.data.set.charging_ev = Ev(0)
-        charging_ev_data = cp.data.set.charging_ev_data
-        charging_ev_data.data.control_parameter.submode = submode
+        cp.data.control_parameter.submode = submode
         return cp
     data.data.cp_data = {"cp1": setup_cp(mock_cp1, submode_1),
                          "cp2": setup_cp(mock_cp2, submode_2)}

packages/control/algorithm/integration_test/conftest.py

@@ -62,7 +62,6 @@ def assert_expected_current(params: ParamsExpectedSetCurrent):
 @pytest.fixture()
 def all_cp_not_charging():
     for i in range(3, 6):
-        charging_ev_data = data.data.cp_data[f"cp{i}"].data.set.charging_ev_data
         data.data.cp_data[f"cp{i}"].data.get.currents = [0]*3
         data.data.cp_data[f"cp{i}"].data.get.charge_state = False
-        charging_ev_data.data.control_parameter.state = ChargepointState.NO_CHARGING_ALLOWED
+        data.data.cp_data[f"cp{i}"].data.control_parameter.state = ChargepointState.NO_CHARGING_ALLOWED

packages/control/algorithm/integration_test/instant_charging_test.py

@@ -8,14 +8,14 @@
 from control.chargemode import Chargemode
 from control import data
 from control.algorithm.algorithm import Algorithm
-from control.loadmanagement import LimitingValue
+from control.limiting_value import LimitingValue
 from dataclass_utils.factories import currents_list_factory
 
 
 @pytest.fixture()
 def all_cp_instant_charging_1p():
     for i in range(3, 6):
-        control_parameter = data.data.cp_data[f"cp{i}"].data.set.charging_ev_data.data.control_parameter
+        control_parameter = data.data.cp_data[f"cp{i}"].data.control_parameter
         control_parameter.required_currents = [0]*3
         control_parameter.required_currents[i-3] = 16
         control_parameter.required_current = 16
@@ -33,7 +33,7 @@ def all_cp_charging_1p():
 @pytest.fixture()
 def all_cp_instant_charging_3p():
     for i in range(3, 6):
-        control_parameter = data.data.cp_data[f"cp{i}"].data.set.charging_ev_data.data.control_parameter
+        control_parameter = data.data.cp_data[f"cp{i}"].data.control_parameter
         control_parameter.required_currents = [16]*3
         control_parameter.required_current = 16
         control_parameter.chargemode = Chargemode.INSTANT_CHARGING
@@ -88,7 +88,8 @@ class ParamsLimit(ParamsExpectedSetCurrent, ParamsExpectedCounterSet):
                 raw_power_left=21310,
                 raw_currents_left_counter0=[14, 30, 31],
                 raw_currents_left_counter6=[16, 12, 14],
-                expected_state_str=LimitingValue.CURRENT,
+                expected_state_str=(f"Es kann nicht mit der vorgegebenen Stromstärke geladen werden"
+                                    f"{LimitingValue.CURRENT.value.format('Garage')}"),
                 expected_current_cp3=14,
                 expected_current_cp4=12,
                 expected_current_cp5=14,
@@ -97,15 +98,16 @@ class ParamsLimit(ParamsExpectedSetCurrent, ParamsExpectedCounterSet):
                 expected_raw_currents_left_counter6=[16, 0, 0]),
     ParamsLimit(name="limit by power",
                 raw_power_left=5520,
-                raw_currents_left_counter0=[14, 30, 31],
-                raw_currents_left_counter6=[16, 12, 14],
-                expected_state_str=LimitingValue.POWER,
-                expected_current_cp3=10.333333333333334,
-                expected_current_cp4=6.833333333333333,
-                expected_current_cp5=6.833333333333333,
+                raw_currents_left_counter0=[32]*3,
+                raw_currents_left_counter6=[16]*3,
+                expected_state_str=(f"Es kann nicht mit der vorgegebenen Stromstärke geladen werden"
+                                    f"{LimitingValue.POWER.value.format('Garage')}"),
+                expected_current_cp3=10.461538461538462,
+                expected_current_cp4=6.769230769230769,
+                expected_current_cp5=6.769230769230769,
                 expected_raw_power_left=0,
-                expected_raw_currents_left_counter0=[3.666666666666666, 23.166666666666668, 24.166666666666668],
-                expected_raw_currents_left_counter6=[16, 5.166666666666667, 7.166666666666667]),
+                expected_raw_currents_left_counter0=[21.53846153846154, 25.23076923076923, 25.23076923076923],
+                expected_raw_currents_left_counter6=[16, 9.23076923076923, 9.23076923076923]),
     # limit by unbalanced load
 ]
 
@@ -125,8 +127,7 @@ def test_instant_charging_limit(params: ParamsLimit, all_cp_instant_charging_1p,
     assert_expected_current(params)
     for i in range(3, 6):
         assert data.data.cp_data[
-            f"cp{i}"].data.get.state_str == (f"Es kann nicht mit der vorgegebenen Stromstärke geladen werden"
-                                             f"{params.expected_state_str.value.format('Garage')}")
+            f"cp{i}"].data.get.state_str.replace("\n", "") == params.expected_state_str.replace("\n", "")
     assert_counter_set(params)
 
 
@@ -185,12 +186,12 @@ class ParamsControlParameter(ParamsExpectedSetCurrent, ParamsExpectedCounterSet)
 @pytest.mark.parametrize("params", cases_control_parameter, ids=[c.name for c in cases_control_parameter])
 def test_control_parameter_instant_charging(params: ParamsControlParameter, all_cp_instant_charging_3p, monkeypatch):
     # setup
-    data.data.cp_data["cp3"].data.set.charging_ev_data.data.control_parameter.prio = params.prio_cp3
-    data.data.cp_data["cp3"].data.set.charging_ev_data.data.control_parameter.submode = params.submode_cp3
-    data.data.cp_data["cp4"].data.set.charging_ev_data.data.control_parameter.prio = params.prio_cp4
-    data.data.cp_data["cp4"].data.set.charging_ev_data.data.control_parameter.submode = params.submode_cp4
-    data.data.cp_data["cp5"].data.set.charging_ev_data.data.control_parameter.prio = params.prio_cp5
-    data.data.cp_data["cp5"].data.set.charging_ev_data.data.control_parameter.submode = params.submode_cp5
+    data.data.cp_data["cp3"].data.control_parameter.prio = params.prio_cp3
+    data.data.cp_data["cp3"].data.control_parameter.submode = params.submode_cp3
+    data.data.cp_data["cp4"].data.control_parameter.prio = params.prio_cp4
+    data.data.cp_data["cp4"].data.control_parameter.submode = params.submode_cp4
+    data.data.cp_data["cp5"].data.control_parameter.prio = params.prio_cp5
+    data.data.cp_data["cp5"].data.control_parameter.submode = params.submode_cp5
     data.data.counter_data["counter0"].data.set.raw_power_left = 22080
     data.data.counter_data["counter0"].data.set.raw_currents_left = [32]*3
     data.data.counter_data["counter6"].data.set.raw_currents_left = [16]*3