Phasenumschaltung unter Beachtung der Schieflast (#1121)

* move control parameter to Chargepoint class

* draft

* fix test

* fix

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)

packages/control/algorithm/algorithm.py

@@ -67,7 +67,8 @@ def _check_auto_phase_switch_delay(self) -> None:
                             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

packages/control/algorithm/integration_test/instant_charging_test.py

@@ -8,7 +8,7 @@
 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
 
 
@@ -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)
 
 

packages/control/algorithm/min_current.py

@@ -22,6 +22,7 @@ def set_min_current(self) -> None:
                     missing_currents, counts = common.get_min_current(cp)
                     if max(missing_currents) > 0:
                         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(

packages/control/algorithm/surplus_controlled.py

@@ -47,6 +47,7 @@ def _set(self,
             available_currents, limit = Loadmanagement().get_available_currents_surplus(missing_currents,
                                                                                         counter,
                                                                                         feed_in_yield)
+            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)
             self._set_loadmangement_message(current, limit, cp, counter)

packages/control/auto_phase_switch_test.py

@@ -146,7 +146,8 @@ def test_auto_phase_switch(monkeypatch, vehicle: Ev, params: Params):
                                                                 params.get_currents,
                                                                 params.get_power,
                                                                 32,
-                                                                3)
+                                                                3,
+                                                                None)
 
     # evaluation
     assert phases_to_use == params.expected_phases_to_use

packages/control/chargepoint/chargepoint.py

@@ -274,7 +274,10 @@ def __init__(self, index: int, event: Optional[threading.Event]):
     def set_state_and_log(self, message: str) -> None:
         if message:
             log.info(f"LP {self.num}: {message}")
-            self.data.get.state_str = message
+            if self.data.get.state_str is None:
+                self.data.get.state_str = message
+            elif message not in self.data.get.state_str:
+                self.data.get.state_str += f" {message}"
 
     def _is_grid_protection_inactive(self) -> Tuple[bool, Optional[str]]:
         """ prüft, ob der Netzschutz inaktiv ist oder ob alle Ladepunkt gestoppt werden müssen.

packages/control/chargepoint/control_parameter.py

@@ -3,6 +3,7 @@
 
 from control.chargepoint.chargepoint_state import ChargepointState
 from control.chargemode import Chargemode as Chargemode_enum
+from control.limiting_value import LimitingValue
 from dataclass_utils.factories import currents_list_factory
 
 
@@ -20,6 +21,9 @@ class ControlParameter:
     imported_instant_charging: Optional[float] = field(
         default=None,
         metadata={"topic": "control_parameter/imported_instant_charging", "mutable_by_algorithm": True})
+    limit: Optional[LimitingValue] = field(
+        default=None,
+        metadata={"topic": "control_parameter/limit", "mutable_by_algorithm": True})
     phases: int = field(
         default=0,
         metadata={"topic": "control_parameter/phases", "mutable_by_algorithm": True})

packages/control/ev.py

@@ -15,6 +15,7 @@
 from control.bat_all import SwitchOnBatState
 from control.chargepoint.chargepoint_state import ChargepointState, PHASE_SWITCH_STATES
 from control.chargepoint.control_parameter import ControlParameter
+from control.limiting_value import LimitingValue
 from dataclass_utils.factories import empty_dict_factory, empty_list_factory
 from helpermodules.abstract_plans import Limit, limit_factory, ScheduledChargingPlan, TimeChargingPlan
 from helpermodules import timecheck
@@ -365,7 +366,8 @@ def _check_phase_switch_conditions(self,
                                        control_parameter: ControlParameter,
                                        get_currents: List[float],
                                        get_power: float,
-                                       max_current_cp: int) -> Tuple[bool, Optional[str]]:
+                                       max_current_cp: int,
+                                       limit: LimitingValue) -> Tuple[bool, Optional[str]]:
         # Manche EV laden mit 6.1A bei 6A Sollstrom
         min_current = self.ev_template.data.min_current + self.ev_template.data.nominal_difference
         max_current = (min(self.ev_template.data.max_current_single_phase, max_current_cp)
@@ -381,9 +383,9 @@ def _check_phase_switch_conditions(self,
         # verbleibender EVU-Überschuss unter Berücksichtigung der Einspeisegrenze und Speicherleistung
         all_surplus = (-evu_counter.calc_surplus() - evu_counter.data.set.released_surplus +
                        evu_counter.data.set.reserved_surplus - feed_in_yield)
-        condition_1_to_3 = (max(get_currents) > max_current and
+        condition_1_to_3 = (((max(get_currents) > max_current and
                             all_surplus > self.ev_template.data.min_current * max_phases_ev * 230
-                            - get_power and
+                            - get_power) or limit == LimitingValue.UNBALANCED_LOAD.value) and
                             phases_in_use == 1)
         condition_3_to_1 = max(get_currents) < min_current and all_surplus <= 0 and phases_in_use > 1
         if condition_1_to_3 or condition_3_to_1:
@@ -404,7 +406,8 @@ def auto_phase_switch(self,
                           get_currents: List[float],
                           get_power: float,
                           max_current_cp: int,
-                          max_phases: int) -> Tuple[int, float, Optional[str]]:
+                          max_phases: int,
+                          limit: LimitingValue) -> Tuple[int, float, Optional[str]]:
         message = None
         current = control_parameter.required_current
         timestamp_auto_phase_switch = control_parameter.timestamp_auto_phase_switch
@@ -442,7 +445,8 @@ def auto_phase_switch(self,
             condition, condition_msg = self._check_phase_switch_conditions(control_parameter,
                                                                            get_currents,
                                                                            get_power,
-                                                                           max_current_cp)
+                                                                           max_current_cp,
+                                                                           limit)
             if control_parameter.state not in PHASE_SWITCH_STATES:
                 if condition:
                     # Umschaltverzögerung starten

packages/control/limiting_value.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+
+class LimitingValue(Enum):
+    CURRENT = ", da der Maximal-Strom an Zähler {} erreicht ist."
+    POWER = ", da die maximale Leistung an Zähler {} erreicht ist."
+    UNBALANCED_LOAD = ", da die maximale Schieflast an Zähler {} erreicht ist."

packages/control/loadmanagement.py

@@ -1,21 +1,15 @@
-from enum import Enum
 import logging
 import operator
 from typing import List, Optional, Tuple
 
 from control import data
 from control.counter import Counter
+from control.limiting_value import LimitingValue
 
 
 log = logging.getLogger(__name__)
 
 
-class LimitingValue(Enum):
-    CURRENT = ", da der Maximal-Strom an Zähler {} erreicht ist."
-    POWER = ", da die maximale Leistung an Zähler {} erreicht ist."
-    UNBALANCED_LOAD = ", da die maximale Schieflast an Zähler {} erreicht ist."
-
-
 class Loadmanagement:
     def get_available_currents(self,
                                missing_currents: List[float],

packages/helpermodules/setdata.py

@@ -536,6 +536,7 @@ def process_chargepoint_topic(self, msg: mqtt.MQTTMessage):
                 elif "/control_parameter/phases" in msg.topic:
                     self._validate_value(msg, int, [(0, 3)])
                 elif ("/control_parameter/submode" in msg.topic or
+                        "/control_parameter/limit" in msg.topic or
                         "/control_parameter/chargemode" in msg.topic):
                     self._validate_value(msg, str)
                 elif "/control_parameter/prio" in msg.topic: