Merge master into Release

data/config/boot_config.txt

@@ -1,5 +1,5 @@
 # openwb - begin
-# openwb-version:2
+# openwb-version:3
 # Do not edit this section! We need begin/end and version for proper updates!
 [all]
 gpio=4,5,7,11,17,22,23,24,25,26,27=op,dl
@@ -8,4 +8,5 @@ gpio=6,8,9,10,12,13,16,21=ip,pu
 # this also requires to disable Bluetooth
 dtoverlay=disable-bt
 enable_uart=1
+avoid_warnings=1
 # openwb - end

docs/Ladung nur nach Freischaltung.md

@@ -1,11 +1,22 @@
-Nach Abstecken des Fahrzeugs soll der Ladepunkte gesperrt werden und eine Ladung erst nach Eingeben einer PIN, Vorhalten eines RFID-Tags oder Auswahl eines Fahrzeugs im User Interface gestartet werden.
+Nach Abstecken des Fahrzeugs soll der Ladepunkt gesperrt werden und eine neue Ladung erst nach Freischalten durch:
 
-* für jedes physische Fahrzeug unter _Einstellungen->Konfiguration->Fahrzeuge_ zusätzlich zum Standardprofil ein Fahrzeug anlegen
-* Lademodus des Standardfahrzeugs auf `Stop`
-* in jedem Ladeprofil: `Standard nach Abstecken` aktivieren
+- Eingeben einer PIN am openWB-Display (sofern mit Touchdisplay) oder
+- Vorhalten eines RFID-Tags an der openWB mit RFID-Reader oder
+- Direkt-tagging über den Ladestecker mit der openWB-Pro oder
+- Auswahl eines Fahrzeugs im User Interface
 
-Wenn die Freischaltung mittels RFID oder Pin erfolgen soll:
+gestartet werden.
 
-* _Einstellungen -> Optional_: RFID aktivieren
-* im Fahrzeug: Tag zuweisen
-* in dem Ladepunkt-Profil: Freischaltung mit RFID aktivieren und die gültigen Tags eintragen
+Hierzu ist folgendes zu konfigurieren:
+
+1. für jedes Fahrzeug mit Freischaltwunsch unter Einstellungen -> Konfiguration -> Fahrzeuge zusätzlich zum Standard-Fahrzeug **ein separates Fahrzeug** anlegen
+2. unter Lade-Profile -> **Standard-Lade-Profil** (wird nur dem Standard-Fahrzeug zugeordnet) -> **Lademodus auf Stop** stellen
+3. ein **neues Lade-Profil** für Fahrzeuge mit Freischaltwunsch anlegen (z.B. RFID-Lade-Profil) und dort -> **Standard nach Abstecken** aktivieren sowie bevorzugten Lademodus wählen
+4. den Fahrzeugen mit Freischaltwunsch **das Lade-Profil** für Fahrzeuge mit Freischaltwunsch **zuweisen** (z.B. RFID-Lade-Profil)
+5. **Speichern** nicht vergessen
+
+Wenn die Freischaltung mittels PIN, RFID oder MAC-Adresse erfolgen soll:
+
+- Einstellungen -> Optionale Hardware: **RFID aktivieren** + Speichern
+- unter Konfiguration -> Fahrzeuge -> gewünschtes Fahrzeug -> Zugeordnete Tags: dem jeweiligen Fahrzeug **den Tag (PIN/RFID-Tag/MAC-Adresse) zuweisen** + Speichern
+- unter Konfiguration -> Ladepunkte -> Ladepunkt-Profile -> im gewünschten Ladepunkt-Profil: **Freischaltung mit RFID aktivieren und die gültigen Tags eintragen** + Speichern

packages/control/algorithm/algorithm.py

@@ -65,7 +65,8 @@ def _check_auto_phase_switch_delay(self) -> None:
                             cp.num,
                             cp.data.get.currents,
                             cp.data.get.power,
-                            cp.template.data.max_current_single_phase)
+                            cp.template.data.max_current_single_phase,
+                            cp.get_max_phase_hw())
                         if message is not None:
                             cp.data.get.state_str = message
                         # Nachdem im Automatikmodus die Anzahl Phasen bekannt ist, Einhaltung des Maximalstroms

packages/control/auto_phase_switch_test.py

@@ -62,18 +62,18 @@ def __init__(self,
 
 cases = [
     Params("1to3, enough power, start timer", max_current_single_phase=16, timestamp_auto_phase_switch=None,
-           phases_to_use=1, required_current=6, evu_surplus=800, reserved_evu_overhang=0, get_currents=[15.6, 0, 0],
+           phases_to_use=1, required_current=6, evu_surplus=-800, reserved_evu_overhang=0, get_currents=[15.6, 0, 0],
            get_power=3450, state=ChargepointState.CHARGING_ALLOWED, expected_phases_to_use=1, expected_current=6,
            expected_message="Umschaltverzögerung von 1 auf 3 Phasen für 7.0 Min aktiv.",
            expected_timestamp_auto_phase_switch="05/16/2022, 08:40:52",
            expected_state=ChargepointState.PHASE_SWITCH_DELAY),
     Params("1to3, not enough power, start timer", max_current_single_phase=16, timestamp_auto_phase_switch=None,
-           phases_to_use=1, required_current=6, evu_surplus=300, reserved_evu_overhang=0, get_currents=[15.6, 0, 0],
+           phases_to_use=1, required_current=6, evu_surplus=-300, reserved_evu_overhang=0, get_currents=[15.6, 0, 0],
            get_power=3450, state=ChargepointState.CHARGING_ALLOWED, expected_phases_to_use=1, expected_current=6,
            expected_state=ChargepointState.CHARGING_ALLOWED),
     Params("1to3, enough power, timer not expired", max_current_single_phase=16,
            timestamp_auto_phase_switch="05/16/2022, 08:35:52", phases_to_use=1, required_current=6,
-           evu_surplus=1200, reserved_evu_overhang=460, get_currents=[15.6, 0, 0], get_power=3450,
+           evu_surplus=-1200, reserved_evu_overhang=460, get_currents=[15.6, 0, 0], get_power=3450,
            state=ChargepointState.PHASE_SWITCH_DELAY, expected_phases_to_use=1, expected_current=6,
            expected_message="Umschaltverzögerung von 1 auf 3 Phasen für 7.0 Min aktiv.",
            expected_timestamp_auto_phase_switch="05/16/2022, 08:40:52",
@@ -87,7 +87,7 @@ def __init__(self,
            expected_state=ChargepointState.CHARGING_ALLOWED),
     Params("1to3, enough power, timer expired", max_current_single_phase=16,
            timestamp_auto_phase_switch="05/16/2022, 08:32:52", phases_to_use=1, required_current=6,
-           evu_surplus=1200, reserved_evu_overhang=460, get_currents=[15.6, 0, 0], get_power=3450,
+           evu_surplus=-1200, reserved_evu_overhang=460, get_currents=[15.6, 0, 0], get_power=3450,
            state=ChargepointState.PHASE_SWITCH_DELAY,
            expected_phases_to_use=3, expected_current=6, expected_state=ChargepointState.PHASE_SWITCH_DELAY_EXPIRED),
 
@@ -108,7 +108,7 @@ def __init__(self,
            expected_state=ChargepointState.PHASE_SWITCH_DELAY),
     Params("3to1, enough power, timer not expired", max_current_single_phase=16,
            timestamp_auto_phase_switch="05/16/2022, 08:35:52", phases_to_use=3, required_current=6,
-           evu_surplus=860, reserved_evu_overhang=0, get_currents=[4.5, 4.4, 5.8],
+           evu_surplus=-860, reserved_evu_overhang=0, get_currents=[4.5, 4.4, 5.8],
            get_power=3381, state=ChargepointState.PHASE_SWITCH_DELAY, expected_phases_to_use=3, expected_current=6,
            expected_message=f"Umschaltverzögerung von 3 auf 1 Phasen abgebrochen{Ev.ENOUGH_POWER}",
            expected_timestamp_auto_phase_switch="05/16/2022, 08:40:52",
@@ -139,7 +139,7 @@ def test_auto_phase_switch(monkeypatch, vehicle: Ev, params: Params):
     vehicle.data.control_parameter.state = params.state
 
     # execution
-    phases_to_use, current, message = vehicle.auto_phase_switch(0, params.get_currents, params.get_power, 32)
+    phases_to_use, current, message = vehicle.auto_phase_switch(0, params.get_currents, params.get_power, 32, 3)
 
     # evaluation
     assert phases_to_use == params.expected_phases_to_use

packages/control/bat_all.py

@@ -101,15 +101,15 @@ def calc_power_for_all_components(self):
                         self.data.get.power += battery.data.get.power
                         self.data.get.imported += battery.data.get.imported
                         self.data.get.exported += battery.data.get.exported
-                        self.data.get.daily_exported += battery.data.get.daily_exported
-                        self.data.get.daily_imported += battery.data.get.daily_imported
                         soc_sum += battery.data.get.soc
                         soc_count += 1
                     except Exception:
                         log.exception(f"Fehler im Bat-Modul {battery.num}")
                 self.data.get.soc = int(soc_sum / soc_count)
-                # Alle Summen-Topics im Dict veröffentlichen
-                {Pub().pub("openWB/set/bat/get/"+k, v) for (k, v) in asdict(self.data.get).items()}
+                Pub().pub("openWB/set/bat/get/power", self.data.get.power)
+                Pub().pub("openWB/set/bat/get/exported", self.data.get.exported)
+                Pub().pub("openWB/set/bat/get/imported", self.data.get.imported)
+                Pub().pub("openWB/set/bat/get/soc", self.data.get.soc)
             else:
                 self.data.config.configured = False
                 Pub().pub("openWB/set/bat/config/configured", self.data.config.configured)

packages/control/chargepoint/chargepoint.py

@@ -363,10 +363,6 @@ def _is_ev_plugged(self) -> Tuple[bool, Optional[str]]:
         if not state:
             message = "Keine Ladung, da kein Auto angesteckt ist."
         else:
-            if self.data.set.plug_time is None:
-                self.data.set.plug_time = timecheck.create_timestamp()
-                Pub().pub("openWB/set/chargepoint/"+str(self.num)+"/set/plug_time",
-                          self.data.set.plug_time)
             message = None
         return state, message
 
@@ -431,9 +427,19 @@ def _process_charge_stop(self) -> None:
         self.data.set.energy_to_charge = 0
         Pub().pub("openWB/set/chargepoint/"+str(self.num)+"/set/energy_to_charge", 0)
 
-    def reset_values_at_start(self):
+    def setup_values_at_start(self):
+        self._reset_values_at_start()
+        self._set_values_at_start()
+
+    def _reset_values_at_start(self):
         self.data.set.loadmanagement_available = True
 
+    def _set_values_at_start(self):
+        if self.data.get.plug_state and self.data.set.plug_time is None:
+            self.data.set.plug_time = timecheck.create_timestamp()
+            Pub().pub("openWB/set/chargepoint/"+str(self.num)+"/set/plug_time",
+                      self.data.set.plug_time)
+
     def remember_previous_values(self):
         self.data.set.plug_state_prev = self.data.get.plug_state
         Pub().pub("openWB/set/chargepoint/"+str(self.num)+"/set/plug_state_prev", self.data.set.plug_state_prev)
@@ -445,12 +451,12 @@ def prepare_cp(self) -> Tuple[int, Optional[str]]:
             self.__validate_rfid()
             charging_possible, message = self.is_charging_possible()
             if charging_possible:
-                num, message_ev = self.template.get_ev(self.data.get.rfid or self.data.set.rfid, self.data.config.ev)
+                if self.data.get.rfid is not None:
+                    self._link_rfid_to_cp()
+                num, message_ev = self.template.get_ev(self.data.set.rfid, self.data.config.ev)
                 if message_ev:
                     message = message_ev
                 if num != -1:
-                    if self.data.get.rfid is not None:
-                        self.__link_rfid_to_cp()
                     return num, message
                 else:
                     self.data.get.state_str = message
@@ -510,6 +516,8 @@ def _is_phase_switch_required(self, charging_ev: Ev) -> bool:
             return True
         return False
 
+    STOP_CHARGING = ", dafür wird die Ladung unterbrochen."
+
     def initiate_phase_switch(self):
         """prüft, ob eine Phasenumschaltung erforderlich ist und führt diese durch.
         """
@@ -549,9 +557,9 @@ def initiate_phase_switch(self):
                 else:
                     # Wenn eine Umschaltung im Gange ist, muss erst gewartet werden, bis diese fertig ist.
                     if self.data.set.phases_to_use == 1:
-                        message = "Umschaltung von 3 auf 1 Phase."
+                        message = f"Umschaltung von {self.get_max_phase_hw()} auf 1 Phase{self.STOP_CHARGING}"
                     else:
-                        message = "Umschaltung von 1 auf 3 Phasen."
+                        message = f"Umschaltung von 1 auf {self.get_max_phase_hw()} Phasen{self.STOP_CHARGING}"
                     self.set_state_and_log(message)
                 return
             if charging_ev.data.control_parameter.state == ChargepointState.WAIT_FOR_USING_PHASES:
@@ -580,12 +588,12 @@ def initiate_phase_switch(self):
                                       "control_parameter phases " +
                                       str(charging_ev.data.control_parameter.phases))
                             if charging_ev.data.control_parameter.phases == 1:
-                                message = "Umschaltung von 3 auf 1 Phase."
+                                message = f"Umschaltung von {self.get_max_phase_hw()} auf 1 Phase{self.STOP_CHARGING}"
                                 # Ladeleistung reservieren, da während der Umschaltung die Ladung pausiert wird.
                                 evu_counter.data.set.reserved_surplus += charging_ev. \
                                     ev_template.data.max_current_single_phase * 230
                             else:
-                                message = "Umschaltung von 1 auf 3 Phasen."
+                                message = f"Umschaltung von 1 auf {self.get_max_phase_hw()} Phasen{self.STOP_CHARGING}"
                                 # Ladeleistung reservieren, da während der Umschaltung die Ladung pausiert wird.
                                 evu_counter.data.set.reserved_surplus += charging_ev. \
                                     ev_template.data.max_current_single_phase * 3 * 230
@@ -701,18 +709,22 @@ def check_min_max_current(self, required_current: float, phases: int, pv: bool =
         self.set_state_and_log(msg)
         return required_current
 
-    def __link_rfid_to_cp(self) -> None:
+    def _link_rfid_to_cp(self) -> None:
         """ Wenn der Tag einem EV zugeordnet worden ist, wird der Tag unter set/rfid abgelegt und muss der Timer
         zurückgesetzt werden.
         """
         rfid = self.data.get.rfid
         cp2_num = self.find_duo_partner()
         # Tag wird diesem LP der Duo zugewiesen oder es ist keine Duo
-        if not (cp2_num is not None and
-                self.data.get.rfid == data.data.cp_data[f"cp{cp2_num}"].data.get.rfid and
-                data.data.cp_data[f"cp{cp2_num}"].data.get.plug_state and
-                timecheck.get_difference(self.data.set.plug_time,
-                                         data.data.cp_data[f"cp{cp2_num}"].data.set.plug_time) < 0):
+        if ((cp2_num is not None and
+                # EV am anderen Ladepunkt, am eigenen wurde zuerst angesteckt
+             ((data.data.cp_data[f"cp{cp2_num}"].data.get.plug_state and
+               timecheck.get_difference(self.data.set.plug_time,
+                                        data.data.cp_data[f"cp{cp2_num}"].data.set.plug_time) > 0) or
+              # kein EV am anderen Duo-Ladepunkt
+              data.data.cp_data[f"cp{cp2_num  }"].data.get.plug_state is False)) or
+                # keine Duo
+                cp2_num is None):
             self.data.set.rfid = rfid
             Pub().pub("openWB/chargepoint/"+str(self.num)+"/set/rfid", rfid)
             self.chargepoint_module.clear_rfid()
@@ -760,7 +772,8 @@ def find_duo_partner(self) -> Optional[int]:
             if self.data.config.type == "external_openwb" or self.data.config.type == "internal_openwb":
                 for cp2 in data.data.cp_data.values():
                     if (cp2.num != self.num and
-                            self.data.config.configuration.ip_address == cp2.data.config.configuration.ip_address):
+                            self.data.config.configuration["ip_address"] == cp2.data.config.configuration[
+                                "ip_address"]):
                         return cp2.num
             return None
         except Exception:
@@ -807,7 +820,7 @@ def update(self, ev_list: Dict[str, Ev]) -> None:
                     charging_ev.data.control_parameter.phases = min(
                         self.get_phases_by_selected_chargemode(), max_phase_hw)
                     state, message_ev, submode, required_current, phases = charging_ev.get_required_current(
-                        self.data.set.log.imported_since_mode_switch,
+                        self.data.get.imported,
                         max_phase_hw,
                         self.cp_ev_support_phase_switch())
                     phases = self.set_phases(phases)

packages/control/chargepoint/chargepoint_state_update.py

@@ -27,7 +27,7 @@ def __init__(self,
         self.ev_data = ev_data
         self.ev_charge_template_data = ev_charge_template_data
         self.ev_template_data = ev_template_data
-        Thread(target=self.update, args=()).start()
+        Thread(target=self.update, args=(), name=f"ChargepointStateUpdate cp {index}").start()
 
     def update(self):
         self.event_global_data_initialized.wait()

packages/control/chargepoint/chargepoint_test.py

@@ -1,6 +1,7 @@
-from typing import List
+from typing import List, Optional
 from unittest.mock import Mock
 import pytest
+from control import data
 
 from control.chargepoint.chargepoint import Chargepoint
 from control.chargepoint.chargepoint_template import CpTemplate
@@ -49,3 +50,43 @@ def test_check_min_max_current(required_current, phases, expected_required_curre
 
     # assertion
     assert ret == expected_required_current
+
+
+@pytest.fixture()
+def mock_data() -> None:
+    data.data_init(Mock())
+    data.data.cp_data["cp1"] = Chargepoint(1, None)
+    data.data.cp_data["cp1"].data.get.rfid = "1234"
+
+
+@pytest.mark.parametrize("partner_id, cp1_plug_state, cp0_plug_time, cp1_plug_time, expected_set_rfid",
+                         [
+                             pytest.param(None, False, None, None, "1234", id="no duo"),
+                             pytest.param(1, False, None, None, "1234", id="second cp not plugged"),
+                             pytest.param(1, True, "08/08/2023, 11:36:00",
+                                          "08/08/2023, 11:37:00", None, id="self first plugged"),
+                             pytest.param(1, True, "08/08/2023, 11:37:00",
+                                          "08/08/2023, 11:36:00", "1234", id="second first plugged"),
+                         ])
+def test_link_rfid_to_cp(partner_id: Optional[int],
+                         cp1_plug_state: bool,
+                         cp0_plug_time: Optional[str],
+                         cp1_plug_time: Optional[str],
+                         expected_set_rfid: Optional[str],
+                         mock_data,
+                         monkeypatch):
+    # setup
+    cp = Chargepoint(0, None)
+    cp.chargepoint_module = Mock()
+    cp.data.get.rfid = "1234"
+    cp.data.set.plug_time = cp0_plug_time
+    data.data.cp_data["cp1"].data.get.plug_state = cp1_plug_state
+    data.data.cp_data["cp1"].data.set.plug_time = cp1_plug_time
+    mock_find_duo_partner = Mock(return_value=partner_id)
+    monkeypatch.setattr(Chargepoint, "find_duo_partner", mock_find_duo_partner)
+
+    # execution
+    cp._link_rfid_to_cp()
+
+    # evaluation
+    assert cp.data.set.rfid == expected_set_rfid

packages/control/counter.py

@@ -193,7 +193,7 @@ def calc_surplus(self):
         # eingeschaltet werden. Es darf bloß nicht für zu viele zB die Einschaltverzögerung gestartet werden.
         evu_counter = data.data.counter_all_data.get_evu_counter()
         bat_surplus = data.data.bat_all_data.power_for_bat_charging()
-        surplus = - evu_counter.data.get.power + bat_surplus
+        surplus = evu_counter.data.get.power - bat_surplus
         ranged_surplus = self._control_range(surplus)
         log.info(f"Überschuss zur PV-geführten Ladung: {ranged_surplus}W")
         return ranged_surplus
@@ -356,7 +356,7 @@ def calc_switch_off_threshold(self, chargepoint: Chargepoint) -> Tuple[float, fl
         return threshold, feed_in_yield
 
     def calc_switch_off(self, chargepoint: Chargepoint) -> Tuple[float, float]:
-        switch_off_power = - self.calc_surplus() - self.data.set.released_surplus
+        switch_off_power = self.calc_surplus() - self.data.set.released_surplus
         threshold, feed_in_yield = self.calc_switch_off_threshold(chargepoint)
         log.debug(f'LP{chargepoint.num} Switch-Off-Threshold prüfen: {switch_off_power}W, Schwelle: {threshold}W, '
                   f'freigegebener Überschuss {self.data.set.released_surplus}W, Einspeisegrenze {feed_in_yield}W')