bidi

packages/control/algorithm/algorithm.py

@@ -4,6 +4,7 @@
 from control import data
 from control.algorithm import common
 from control.algorithm.additional_current import AdditionalCurrent
+from control.algorithm.bidi_charging import Bidi
 from control.algorithm.min_current import MinCurrent
 from control.algorithm.no_current import NoCurrent
 from control.algorithm.surplus_controlled import SurplusControlled
@@ -14,6 +15,7 @@
 class Algorithm:
     def __init__(self):
         self.additional_current = AdditionalCurrent()
+        self.bidi = Bidi()
         self.min_current = MinCurrent()
         self.no_current = NoCurrent()
         self.surplus_controlled = SurplusControlled()
@@ -32,14 +34,17 @@ def calc_current(self) -> None:
             log.info("**Soll-Strom setzen**")
             common.reset_current_to_target_current()
             self.additional_current.set_additional_current()
+            self.surplus_controlled.set_required_current_to_max()
+            log.info("**PV-geführten Strom setzen**")
             counter.limit_raw_power_left_to_surplus(self.evu_counter.calc_raw_surplus())
             if self.evu_counter.data.set.surplus_power_left > 0:
-                log.info("**PV-geführten Strom setzen**")
                 common.reset_current_to_target_current()
-                self.surplus_controlled.set_required_current_to_max()
                 self.surplus_controlled.set_surplus_current()
             else:
-                log.info("**Keine Leistung für PV-geführtes Laden übrig.**")
+                log.info("Keine Leistung für PV-geführtes Laden übrig.")
+            log.info("**Bidi-(Ent-)Lade-Strom setzen**")
+            counter.set_raw_surplus_power_left()
+            self.bidi.set_bidi()
             self.no_current.set_no_current()
             self.no_current.set_none_current()
         except Exception:

packages/control/algorithm/bidi_charging.py

@@ -0,0 +1,45 @@
+import logging
+from control import data
+from control.algorithm.chargemodes import CONSIDERED_CHARGE_MODES_BIDI_DISCHARGE
+from control.algorithm.filter_chargepoints import get_chargepoints_by_mode
+
+log = logging.getLogger(__name__)
+
+
+class Bidi:
+    def __init__(self):
+        pass
+
+    def set_bidi(self):
+        grid_counter = data.data.counter_all_data.get_evu_counter()
+        log.debug(f"Nullpunktanpassung {grid_counter.data.set.surplus_power_left}W")
+        zero_point_adjustment = grid_counter
+        for mode_tuple in CONSIDERED_CHARGE_MODES_BIDI_DISCHARGE:
+            preferenced_cps = get_chargepoints_by_mode(mode_tuple)
+            if preferenced_cps:
+                log.info(
+                    f"Mode-Tuple {mode_tuple[0]} - {mode_tuple[1]} - {mode_tuple[2]}, Zähler {grid_counter.num}")
+                while len(preferenced_cps):
+                    cp = preferenced_cps[0]
+                    zero_point_adjustment = grid_counter.data.set.surplus_power_left / len(preferenced_cps)
+                    log.debug(f"Nullpunktanpassung für LP{cp.num}: verbleibende Leistung {zero_point_adjustment}W")
+                    missing_currents = [zero_point_adjustment / cp.data.get.phases_in_use /
+                                        230 for i in range(0, cp.data.get.phases_in_use)]
+                    missing_currents += [0] * (3 - len(missing_currents))
+                    if zero_point_adjustment > 0:
+                        if cp.data.set.charging_ev_data.charge_template.bidi_charging_allowed(
+                                cp.data.control_parameter.current_plan, cp.data.set.charging_ev_data.data.get.soc):
+                            for index in range(0, 3):
+                                missing_currents[index] = min(cp.data.control_parameter.required_current,
+                                                              missing_currents[index])
+                        else:
+                            log.info(f"LP{cp.num}: Nur bidirektional entladen erlaubt, da SoC-Limit erreicht.")
+                            missing_currents = [0, 0, 0]
+                    else:
+                        for index in range(0, 3):
+                            missing_currents[index] = cp.check_min_max_current(missing_currents[index],
+                                                                               cp.data.get.phases_in_use)
+                    grid_counter.update_surplus_values_left(missing_currents, cp.data.get.voltages)
+                    cp.data.set.current = missing_currents[0]
+                    log.info(f"LP{cp.num}: Stromstärke {missing_currents}A")
+                    preferenced_cps.pop(0)

packages/control/algorithm/chargemodes.py

@@ -18,12 +18,16 @@
                (Chargemode.ECO_CHARGING, Chargemode.PV_CHARGING, False),
                (Chargemode.PV_CHARGING, Chargemode.PV_CHARGING, True),
                (Chargemode.PV_CHARGING, Chargemode.PV_CHARGING, False),
+               # niedrigere Priorität soll nachrangig geladen, aber zuerst entladen werden
+               (Chargemode.SCHEDULED_CHARGING, Chargemode.BIDI_CHARGING, False),
+               (Chargemode.SCHEDULED_CHARGING, Chargemode.BIDI_CHARGING, True),
                (None, Chargemode.STOP, True),
                (None, Chargemode.STOP, False))
 
 CONSIDERED_CHARGE_MODES_SURPLUS = CHARGEMODES[0:2] + CHARGEMODES[6:16]
 CONSIDERED_CHARGE_MODES_PV_ONLY = CHARGEMODES[10:16]
 CONSIDERED_CHARGE_MODES_ADDITIONAL_CURRENT = CHARGEMODES[0:10]
-CONSIDERED_CHARGE_MODES_MIN_CURRENT = CHARGEMODES[0:-1]
-CONSIDERED_CHARGE_MODES_NO_CURRENT = CHARGEMODES[16:18]
+CONSIDERED_CHARGE_MODES_MIN_CURRENT = CHARGEMODES[0:-4]
+CONSIDERED_CHARGE_MODES_NO_CURRENT = CHARGEMODES[18:20]
+CONSIDERED_CHARGE_MODES_BIDI_DISCHARGE = CHARGEMODES[16:18]
 CONSIDERED_CHARGE_MODES_CHARGING = CHARGEMODES[0:16]

packages/control/algorithm/integration_test/bidi_charging_test.py

@@ -0,0 +1,59 @@
+import pytest
+from unittest.mock import Mock
+
+from control import data
+from control.algorithm.algorithm import Algorithm
+from control.chargemode import Chargemode
+
+
+@pytest.fixture()
+def bidi_cps():
+    def _setup(*cps):
+        for cp in cps:
+            data.data.cp_data[cp].data.get.max_discharge_power = -11000
+            data.data.cp_data[cp].data.get.max_charge_power = 11000
+            data.data.cp_data[cp].data.get.phases_in_use = 3
+            control_parameter = data.data.cp_data[cp].data.control_parameter
+            control_parameter.min_current = data.data.cp_data[cp].data.set.charging_ev_data.ev_template.data.min_current
+            control_parameter.phases = 3
+            control_parameter.required_currents = [16]*3
+            control_parameter.required_current = 16
+            control_parameter.chargemode = Chargemode.SCHEDULED_CHARGING
+            control_parameter.submode = Chargemode.BIDI_CHARGING
+    return _setup
+
+
+@pytest.mark.parametrize("grid_power, expected_current",
+                         [pytest.param(-2000, 2.898550724637681, id="bidi charge"),
+                          pytest.param(2000, -2.898550724637681, id="bidi discharge")])
+def test_cp3_bidi(grid_power: float, expected_current: float, bidi_cps, all_cp_not_charging, monkeypatch):
+    # setup
+    bidi_cps("cp3")
+    data.data.counter_data["counter0"].data.get.power = grid_power
+    return_mock = Mock(reurn_value=True)
+    monkeypatch.setattr(
+        data.data.cp_data["cp3"].data.set.charging_ev_data.charge_template, "bidi_charging_allowed", return_mock)
+
+    # execution
+    Algorithm().calc_current()
+
+    # evaluation
+    assert data.data.cp_data["cp3"].data.set.current == expected_current
+    assert data.data.cp_data["cp4"].data.set.current == 0
+    assert data.data.cp_data["cp5"].data.set.current == 0
+    assert data.data.counter_data["counter0"].data.set.surplus_power_left == 0
+
+
+def test_cp3_cp4_bidi_discharge(bidi_cps, all_cp_not_charging, monkeypatch):
+    # setup
+    bidi_cps("cp3", "cp4")
+    data.data.counter_data["counter0"].data.get.power = 4000
+
+    # execution
+    Algorithm().calc_current()
+
+    # evaluation
+    assert data.data.cp_data["cp3"].data.set.current == -2.898550724637681
+    assert data.data.cp_data["cp4"].data.set.current == -2.898550724637681
+    assert data.data.cp_data["cp5"].data.set.current == 0
+    assert data.data.counter_data["counter0"].data.set.surplus_power_left == 0

packages/control/algorithm/integration_test/conftest.py

@@ -7,6 +7,7 @@
 from control.bat import Bat
 from control.bat_all import BatAll
 from control.chargepoint.chargepoint import Chargepoint
+from control.chargepoint.chargepoint_template import CpTemplate
 from control.counter_all import CounterAll
 from control.counter import Counter
 from control.ev.ev import Ev
@@ -24,6 +25,7 @@ def data_() -> None:
         "cp4": Chargepoint(4, None),
         "cp5": Chargepoint(5, None)}
     for i in range(3, 6):
+        data.data.cp_data[f"cp{i}"].template = CpTemplate()
         data.data.cp_data[f"cp{i}"].data.config.phase_1 = i-2
         data.data.cp_data[f"cp{i}"].data.set.charging_ev = i
         data.data.cp_data[f"cp{i}"].data.set.charging_ev_data = Ev(i)

packages/control/algorithm/integration_test/pv_charging_test.py

@@ -133,7 +133,7 @@ def test_start_pv_delay(all_cp_pv_charging_3p, all_cp_not_charging, monkeypatch)
     assert data.data.cp_data[
         "cp5"].data.control_parameter.timestamp_switch_on_off == 1652683252.0
     assert data.data.counter_data["counter0"].data.set.raw_power_left == 31975
-    assert data.data.counter_data["counter0"].data.set.surplus_power_left == 10090.0
+    assert data.data.counter_data["counter0"].data.set.surplus_power_left == -690
     assert data.data.counter_data["counter0"].data.set.reserved_surplus == 9000
 
 
@@ -170,7 +170,7 @@ def test_pv_delay_expired(all_cp_pv_charging_3p, all_cp_not_charging, monkeypatc
     assert data.data.cp_data[
         "cp5"].data.control_parameter.timestamp_switch_on_off is None
     assert data.data.counter_data["counter0"].data.set.raw_power_left == 24300
-    assert data.data.counter_data["counter0"].data.set.surplus_power_left == 2415
+    assert data.data.counter_data["counter0"].data.set.surplus_power_left == -690
     assert data.data.counter_data["counter0"].data.set.reserved_surplus == 0
 
 
@@ -184,7 +184,7 @@ def test_pv_delay_expired(all_cp_pv_charging_3p, all_cp_not_charging, monkeypatc
                   expected_current_cp4=8,
                   expected_current_cp5=8,
                   expected_raw_power_left=34820,
-                  expected_surplus_power_left=6035.0,
+                  expected_surplus_power_left=1090,
                   expected_reserved_surplus=0,
                   expected_released_surplus=0),
     ParamsSurplus(name="reduce current",
@@ -196,7 +196,7 @@ def test_pv_delay_expired(all_cp_pv_charging_3p, all_cp_not_charging, monkeypatc
                   expected_current_cp4=7.8731884057971016,
                   expected_current_cp5=7.8731884057971016,
                   expected_raw_power_left=24470,
-                  expected_surplus_power_left=0,
+                  expected_surplus_power_left=1090,
                   expected_reserved_surplus=0,
                   expected_released_surplus=0),
     ParamsSurplus(name="switch off delay for two of three charging",
@@ -208,7 +208,7 @@ def test_pv_delay_expired(all_cp_pv_charging_3p, all_cp_not_charging, monkeypatc
                   expected_current_cp4=6,
                   expected_current_cp5=6,
                   expected_raw_power_left=5635,
-                  expected_surplus_power_left=-16250.0,
+                  expected_surplus_power_left=-8200,
                   expected_reserved_surplus=0,
                   expected_released_surplus=11040),
 ]
@@ -247,7 +247,7 @@ def test_surplus(params: ParamsSurplus, all_cp_pv_charging_3p, all_cp_charging_3
                       expected_current_cp4=6,
                       expected_current_cp5=6,
                       expected_raw_power_left=17400,
-                      expected_surplus_power_left=-4485,
+                      expected_surplus_power_left=-690,
                       expected_reserved_surplus=0,
                       expected_released_surplus=0),
     ParamsPhaseSwitch(name="phase switch 1p->3p",
@@ -261,7 +261,7 @@ def test_surplus(params: ParamsSurplus, all_cp_pv_charging_3p, all_cp_charging_3
                       expected_current_cp4=6,
                       expected_current_cp5=6,
                       expected_raw_power_left=37520.0,
-                      expected_surplus_power_left=10575.0,
+                      expected_surplus_power_left=3000,
                       expected_reserved_surplus=0,
                       expected_released_surplus=0)
 ]

packages/control/algorithm/surplus_controlled.py

@@ -3,7 +3,8 @@
 
 from control import data
 from control.algorithm import common
-from control.algorithm.chargemodes import CONSIDERED_CHARGE_MODES_PV_ONLY, CONSIDERED_CHARGE_MODES_SURPLUS
+from control.algorithm.chargemodes import (CONSIDERED_CHARGE_MODES_BIDI_DISCHARGE, CONSIDERED_CHARGE_MODES_PV_ONLY,
+                                           CONSIDERED_CHARGE_MODES_SURPLUS)
 from control.algorithm.filter_chargepoints import (get_chargepoints_by_chargemodes,
                                                    get_chargepoints_by_mode_and_counter,
                                                    get_preferenced_chargepoint_charging)
@@ -76,7 +77,7 @@ def _set(self,
 
             current = common.get_current_to_set(cp.data.set.current, current, cp.data.set.target_current)
             self._set_loadmangement_message(current, limit, cp)
-            limited_current = self._limit_adjust_current(cp, current)
+            limited_current = limit_adjust_current(cp, current)
             common.set_current_counterdiff(
                 cp.data.control_parameter.min_current,
                 limited_current,
@@ -105,35 +106,6 @@ def filter_by_feed_in_limit(self, chargepoints: List[Chargepoint]) -> Tuple[List
                                          pv_charging.feed_in_limit is False, chargepoints))
         return cp_with_feed_in, cp_without_feed_in
 
-    # tested
-    def _limit_adjust_current(self, chargepoint: Chargepoint, new_current: float) -> float:
-        if chargepoint.template.data.charging_type == ChargingType.AC.value:
-            MAX_CURRENT = 5
-        else:
-            MAX_CURRENT = 30
-        msg = None
-        nominal_difference = chargepoint.data.set.charging_ev_data.ev_template.data.nominal_difference
-        if chargepoint.chargemode_changed or chargepoint.data.get.charge_state is False:
-            return new_current
-        else:
-            # Um max. +/- 5A pro Zyklus regeln
-            if (-MAX_CURRENT-nominal_difference
-                    < new_current - get_medium_charging_current(chargepoint.data.get.currents)
-                    < MAX_CURRENT+nominal_difference):
-                current = new_current
-            else:
-                if new_current < get_medium_charging_current(chargepoint.data.get.currents):
-                    current = get_medium_charging_current(chargepoint.data.get.currents) - MAX_CURRENT
-                    msg = f"Es darf um max {MAX_CURRENT}A unter den aktuell genutzten Strom geregelt werden."
-
-                else:
-                    current = get_medium_charging_current(chargepoint.data.get.currents) + MAX_CURRENT
-                    msg = f"Es darf um max {MAX_CURRENT}A über den aktuell genutzten Strom geregelt werden."
-            chargepoint.set_state_and_log(msg)
-            return max(current,
-                       chargepoint.data.control_parameter.min_current,
-                       chargepoint.data.set.target_current)
-
     def _fix_deviating_evse_current(self, chargepoint: Chargepoint) -> float:
         """Wenn Autos nicht die volle Ladeleistung nutzen, wird unnötig eingespeist. Dann kann um den noch nicht
         genutzten Soll-Strom hochgeregelt werden. Wenn Fahrzeuge entgegen der Norm mehr Ladeleistung beziehen, als
@@ -182,7 +154,8 @@ def phase_switch_necessary() -> bool:
                 log.exception(f"Fehler in der PV-gesteuerten Ladung bei {cp.num}")
 
     def set_required_current_to_max(self) -> None:
-        for cp in get_chargepoints_by_chargemodes(CONSIDERED_CHARGE_MODES_SURPLUS):
+        for cp in get_chargepoints_by_chargemodes(CONSIDERED_CHARGE_MODES_SURPLUS +
+                                                  CONSIDERED_CHARGE_MODES_BIDI_DISCHARGE):
             try:
                 charging_ev_data = cp.data.set.charging_ev_data
                 required_currents = cp.data.control_parameter.required_currents
@@ -206,3 +179,33 @@ def set_required_current_to_max(self) -> None:
                 control_parameter.required_current = max_current
             except Exception:
                 log.exception(f"Fehler in der PV-gesteuerten Ladung bei {cp.num}")
+
+
+# tested
+def limit_adjust_current(chargepoint: Chargepoint, new_current: float) -> float:
+    if chargepoint.template.data.charging_type == ChargingType.AC.value:
+        MAX_CURRENT = 5
+    else:
+        MAX_CURRENT = 30
+    msg = None
+    nominal_difference = chargepoint.data.set.charging_ev_data.ev_template.data.nominal_difference
+    if chargepoint.chargemode_changed or chargepoint.data.get.charge_state is False:
+        return new_current
+    else:
+        # Um max. +/- 5A pro Zyklus regeln
+        if (-MAX_CURRENT-nominal_difference
+                < new_current - get_medium_charging_current(chargepoint.data.get.currents)
+                < MAX_CURRENT+nominal_difference):
+            current = new_current
+        else:
+            if new_current < get_medium_charging_current(chargepoint.data.get.currents):
+                current = get_medium_charging_current(chargepoint.data.get.currents) - MAX_CURRENT
+                msg = f"Es darf um max {MAX_CURRENT}A unter den aktuell genutzten Strom geregelt werden."
+
+            else:
+                current = get_medium_charging_current(chargepoint.data.get.currents) + MAX_CURRENT
+                msg = f"Es darf um max {MAX_CURRENT}A über den aktuell genutzten Strom geregelt werden."
+        chargepoint.set_state_and_log(msg)
+        return max(current,
+                   chargepoint.data.control_parameter.min_current,
+                   chargepoint.data.set.target_current)

packages/control/algorithm/surplus_controlled_test.py

@@ -5,7 +5,8 @@
 from control import data
 from control.algorithm import surplus_controlled
 from control.algorithm.filter_chargepoints import get_chargepoints_by_chargemodes
-from control.algorithm.surplus_controlled import CONSIDERED_CHARGE_MODES_PV_ONLY, SurplusControlled
+from control.algorithm.surplus_controlled import (CONSIDERED_CHARGE_MODES_PV_ONLY, SurplusControlled,
+                                                  limit_adjust_current)
 from control.chargemode import Chargemode
 from control.chargepoint.chargepoint import Chargepoint, ChargepointData
 from control.chargepoint.chargepoint_data import Get, Set
@@ -66,7 +67,7 @@ def test_limit_adjust_current(new_current: float, expected_current: float, monke
     monkeypatch.setattr(Chargepoint, "set_state_and_log", Mock())
 
     # execution
-    current = SurplusControlled()._limit_adjust_current(cp, new_current)
+    current = limit_adjust_current(cp, new_current)
     # evaluation
     assert current == expected_current
 

packages/control/bat_all.py

@@ -209,6 +209,7 @@ def _get_charging_power_left(self):
                 else:
                     charging_power_left = 0
                 self.data.set.regulate_up = True if self.data.get.soc < 100 else False
+            #  ev wird nach Speicher geladen
             elif config.bat_mode == BatConsiderationMode.EV_MODE.value:
                 # Speicher sollte weder ge- noch entladen werden.
                 charging_power_left = self.data.get.power

packages/control/chargemode.py

@@ -7,4 +7,5 @@ class Chargemode(Enum):
     INSTANT_CHARGING = "instant_charging"
     PV_CHARGING = "pv_charging"
     ECO_CHARGING = "eco_charging"
+    BIDI_CHARGING = "bidi_charging"
     STOP = "stop"