Merge master into Beta

packages/control/bat_all.py

@@ -291,40 +291,42 @@ def set_power_limit_controllable(self):
 
     def get_power_limit(self):
         if self.data.config.bat_control_permitted is False:
-            return
-        chargepoint_by_chargemodes = get_chargepoints_by_chargemodes(CONSIDERED_CHARGE_MODES_CHARGING)
-        # Falls aktive Steuerung an und Fahrzeuge laden und kein Überschuss im System ist,
-        # dann Speicherleistung begrenzen.
-        if (self.data.config.power_limit_mode != BatPowerLimitMode.NO_LIMIT.value and
-            len(chargepoint_by_chargemodes) > 0 and
-                data.data.cp_all_data.data.get.power > 100 and
-                self.data.get.power_limit_controllable and
-                self.data.get.power <= 0 and
-                data.data.counter_all_data.get_evu_counter().data.get.power >= -100):
-            if self.data.config.power_limit_mode == BatPowerLimitMode.LIMIT_STOP.value:
-                self.data.set.power_limit = 0
-            elif self.data.config.power_limit_mode == BatPowerLimitMode.LIMIT_TO_HOME_CONSUMPTION.value:
-                self.data.set.power_limit = data.data.counter_all_data.data.set.home_consumption * -1
-            log.debug(f"Speicher-Leistung begrenzen auf {self.data.set.power_limit/1000}kW")
-        else:
             self.data.set.power_limit = None
-            control_range_low = data.data.general_data.data.chargemode_config.pv_charging.control_range[0]
-            control_range_high = data.data.general_data.data.chargemode_config.pv_charging.control_range[1]
-            control_range_center = control_range_high - (control_range_high - control_range_low) / 2
-            if len(chargepoint_by_chargemodes) == 0:
-                log.debug("Speicher-Leistung nicht begrenzen, "
-                          "da keine Ladepunkte in einem Lademodus mit Netzbezug sind.")
-            elif data.data.cp_all_data.data.get.power <= 100:
-                log.debug("Speicher-Leistung nicht begrenzen, da kein Ladepunkt mit Netzbezug lädt.")
-            elif self.data.get.power_limit_controllable is False:
-                log.debug("Speicher-Leistung nicht begrenzen, da keine regelbaren Speicher vorhanden sind.")
-            elif self.data.get.power > 0:
-                log.debug("Speicher-Leistung nicht begrenzen, da kein Speicher entladen wird.")
-            elif data.data.counter_all_data.get_evu_counter().data.get.power < control_range_center + 80:
-                # Wenn der Regelbereich zB auf Bezug steht, darf auch die Leistung des Regelbereichs entladen werden.
-                log.debug("Speicher-Leistung nicht begrenzen, da EVU-Überschuss vorhanden ist.")
+        else:
+            chargepoint_by_chargemodes = get_chargepoints_by_chargemodes(CONSIDERED_CHARGE_MODES_CHARGING)
+            # Falls aktive Steuerung an und Fahrzeuge laden und kein Überschuss im System ist,
+            # dann Speicherleistung begrenzen.
+            if (self.data.config.power_limit_mode != BatPowerLimitMode.NO_LIMIT.value and
+                len(chargepoint_by_chargemodes) > 0 and
+                    data.data.cp_all_data.data.get.power > 100 and
+                    self.data.get.power_limit_controllable and
+                    self.data.get.power <= 0 and
+                    data.data.counter_all_data.get_evu_counter().data.get.power >= -100):
+                if self.data.config.power_limit_mode == BatPowerLimitMode.LIMIT_STOP.value:
+                    self.data.set.power_limit = 0
+                elif self.data.config.power_limit_mode == BatPowerLimitMode.LIMIT_TO_HOME_CONSUMPTION.value:
+                    self.data.set.power_limit = data.data.counter_all_data.data.set.home_consumption * -1
+                log.debug(f"Speicher-Leistung begrenzen auf {self.data.set.power_limit/1000}kW")
             else:
-                log.debug("Speicher-Leistung nicht begrenzen.")
+                self.data.set.power_limit = None
+                control_range_low = data.data.general_data.data.chargemode_config.pv_charging.control_range[0]
+                control_range_high = data.data.general_data.data.chargemode_config.pv_charging.control_range[1]
+                control_range_center = control_range_high - (control_range_high - control_range_low) / 2
+                if len(chargepoint_by_chargemodes) == 0:
+                    log.debug("Speicher-Leistung nicht begrenzen, "
+                              "da keine Ladepunkte in einem Lademodus mit Netzbezug sind.")
+                elif data.data.cp_all_data.data.get.power <= 100:
+                    log.debug("Speicher-Leistung nicht begrenzen, da kein Ladepunkt mit Netzbezug lädt.")
+                elif self.data.get.power_limit_controllable is False:
+                    log.debug("Speicher-Leistung nicht begrenzen, da keine regelbaren Speicher vorhanden sind.")
+                elif self.data.get.power > 0:
+                    log.debug("Speicher-Leistung nicht begrenzen, da kein Speicher entladen wird.")
+                elif data.data.counter_all_data.get_evu_counter().data.get.power < control_range_center + 80:
+                    # Wenn der Regelbereich zB auf Bezug steht, darf auch die Leistung des Regelbereichs entladen
+                    # werden.
+                    log.debug("Speicher-Leistung nicht begrenzen, da EVU-Überschuss vorhanden ist.")
+                else:
+                    log.debug("Speicher-Leistung nicht begrenzen.")
         remaining_power_limit = self.data.set.power_limit
         for bat_component in get_controllable_bat_components():
             if self.data.set.power_limit is None:

packages/control/chargelog/chargelog.py

@@ -2,6 +2,7 @@
 from enum import Enum
 import json
 import logging
+import os
 import pathlib
 from typing import Any, Dict, List, Optional
 
@@ -250,13 +251,18 @@ def write_new_entry(new_entry):
     filepath = str(_get_parent_file() / "data" / "charge_log" /
                    (timecheck.create_timestamp_YYYYMM() + ".json"))
     try:
-        with open(filepath, "r", encoding="utf-8") as json_file:
-            content = json.load(json_file)
+        if os.path.exists(filepath) and os.path.getsize(filepath) == 0:
+            content = []
+        else:
+            with open(filepath, "r", encoding="utf-8") as json_file:
+                try:
+                    content = json.load(json_file)
+                except json.decoder.JSONDecodeError:
+                    corrupt_path = f"{filepath}.unparsable_{timecheck.create_timestamp()}"
+                    os.rename(filepath, corrupt_path)
+                    log.error(f"ChargeLog: Korrupte Datei umbenannt nach {corrupt_path}")
+                    content = []
     except FileNotFoundError:
-        # with open(filepath, "w", encoding="utf-8") as jsonFile:
-        #     json.dump([], jsonFile)
-        # with open(filepath, "r", encoding="utf-8") as jsonFile:
-        #     content = json.load(jsonFile)
         content = []
     content.append(new_entry)
     write_and_check(filepath, content)

packages/control/chargepoint/chargepoint.py

@@ -160,13 +160,15 @@ def _is_manual_lock_inactive(self) -> Tuple[bool, Optional[str]]:
         # Vergleiche werden case-insensitive durchgeführt
         # das vereinfacht die Eingabe, kann aber auch für falsche Treffer sorgen.
         # 'fnmatch()' ist case-insensitive
+        match = False
         for tag_id in self.template.data.valid_tags:
             if ((self.data.get.rfid is not None and fnmatch(self.data.get.rfid, tag_id)) or
                     (self.data.get.vehicle_id is not None and fnmatch(self.data.get.vehicle_id, tag_id)) or
                     (self.data.set.rfid is not None and fnmatch(self.data.set.rfid, tag_id))):
-                Pub().pub(f"openWB/set/chargepoint/{self.num}/set/manual_lock", False)
-        # Wenn der Ladepunkt nach dem Abstecken gesperrt werden soll, und kein Fahrzeug angeschlossen ist wird gesperrt
-        if self.template.data.disable_after_unplug and self.data.get.plug_state is False:
+                match = True
+        if match:
+            Pub().pub(f"openWB/set/chargepoint/{self.num}/set/manual_lock", False)
+        elif self.template.data.disable_after_unplug and self.data.get.plug_state is False:
             Pub().pub(f"openWB/set/chargepoint/{self.num}/set/manual_lock", True)
 
         if self.data.set.manual_lock:
@@ -374,7 +376,7 @@ def _is_phase_switch_required(self) -> bool:
                self.check_deviating_contactor_states(self.data.set.phases_to_use,
                                                      self.data.control_parameter.phases)) and
                 # Wenn der Ladevorgang gestartet wird, muss vor dem ersten Laden umgeschaltet werden.
-                self.data.set.current != 0):
+                self.data.set.current != 0 and self.data.get.charge_state is False):
             phase_switch_required = True
         if phase_switch_required:
             # Umschaltung fehlgeschlagen
@@ -383,18 +385,18 @@ def _is_phase_switch_required(self) -> bool:
                     if self.data.control_parameter.failed_phase_switches > self.MAX_FAILED_PHASE_SWITCHES:
                         phase_switch_required = False
                         self.set_state_and_log(
-                            "Keine Phasenumschaltung, da die maximale Anzahl an Fehlversuchen erreicht wurde. Die "
-                            "aktuelle Phasenzahl wird bis zum Abstecken beibehalten.")
+                            "Keine Phasenumschaltung, da die maximale Anzahl an Fehlversuchen erreicht wurde.")
                     self.data.control_parameter.failed_phase_switches += 1
                 else:
                     # Umschaltung vor Ladestart zulassen
-                    if self.data.set.log.imported_since_plugged != 0:
+                    if (self.data.set.log.imported_since_plugged != 0 and
+                            self.data.control_parameter.failed_phase_switches > 0):
                         phase_switch_required = False
                         self.set_state_and_log(
                             "Keine Phasenumschaltung, da wiederholtes Anstoßen der Umschaltung in den übergreifenden "
                             "Ladeeinstellungen deaktiviert wurde. Die aktuelle "
                             "Phasenzahl wird bis zum Abstecken beibehalten.")
-                        self.data.control_parameter.failed_phase_switches += 1
+                    self.data.control_parameter.failed_phase_switches += 1
         return phase_switch_required
 
     STOP_CHARGING = ", dafür wird die Ladung unterbrochen."
@@ -723,6 +725,8 @@ def update(self, ev_list: Dict[str, Ev]) -> None:
                         data.data.counter_all_data.get_evu_counter().reset_switch_on_off(
                             self, charging_ev)
                         charging_ev.reset_phase_switch(self.data.control_parameter)
+                    if self.chargemode_changed:
+                        self.data.control_parameter.failed_phase_switches = 0
                     message = message_ev if message_ev else message
                     # Ein Eintrag muss nur erstellt werden, wenn vorher schon geladen wurde und auch danach noch
                     # geladen werden soll.
@@ -823,8 +827,9 @@ def _get_charging_ev(self, vehicle: int, ev_list: Dict[str, Ev]) -> Ev:
         if self.data.set.charging_ev_prev != vehicle:
             Pub().pub(f"openWB/set/vehicle/{charging_ev.num}/get/force_soc_update", True)
             log.debug("SoC nach EV-Wechsel")
-            self.update_charge_template(charging_ev.charge_template)
-        if self.data.set.charge_template.data.id != charging_ev.charge_template.data.id:
+        # wenn vorher kein anderes Fahrzeug zugeordnet war, Ladeprofil nicht zurücksetzen
+        if ((self.data.set.charging_ev_prev != vehicle and self.data.set.charging_ev_prev != -1) or
+                (self.data.set.charge_template.data.id != charging_ev.charge_template.data.id)):
             self.update_charge_template(charging_ev.charge_template)
         self.data.set.charging_ev_data = charging_ev
         self.data.set.charging_ev = vehicle
@@ -908,7 +913,8 @@ def cp_ev_chargemode_support_phase_switch(self) -> bool:
     def cp_ev_support_phase_switch(self) -> bool:
         return (self.data.config.auto_phase_switch_hw and
                 self.data.get.evse_signaling != EvseSignaling.HLC and
-                self.data.set.charging_ev_data.ev_template.data.prevent_phase_switch is False)
+                (self.data.set.charging_ev_data.ev_template.data.prevent_phase_switch is False or
+                 self.data.set.log.imported_since_plugged == 0))
 
     def chargemode_support_phase_switch(self) -> bool:
         control_parameter = self.data.control_parameter
@@ -934,7 +940,7 @@ def failed_phase_switches_reached(self) -> bool:
             (data.data.general_data.data.chargemode_config.retry_failed_phase_switches is False and
              self.data.control_parameter.failed_phase_switches == 1)):
             self.set_state_and_log(
-                "Keine automatische Umschaltung, da die maximale Anzahl an Fehlversuchen erreicht wurde. ")
+                "Keine Phasenumschaltung, da die maximale Anzahl an Fehlversuchen erreicht wurde. ")
             return False
         else:
             return True

packages/control/ev/ev.py

@@ -353,11 +353,13 @@ def auto_phase_switch(self,
                                                           waiting_time,
                                                           delay)[1])
                     control_parameter.state = ChargepointState.PHASE_SWITCH_DELAY
-                elif condition_msg:
-                    if condition_msg == self.CURRENT_OUT_OF_NOMINAL_DIFFERENCE:
-                        message = f"Keine Phasenumschaltung{condition_msg}"
-                    else:
-                        log.debug(f"Keine Phasenumschaltung{condition_msg}")
+                else:
+                    if condition_msg:
+                        if condition_msg == self.CURRENT_OUT_OF_NOMINAL_DIFFERENCE:
+                            message = f"Keine Phasenumschaltung{condition_msg}"
+                        else:
+                            log.debug(f"Keine Phasenumschaltung{condition_msg}")
+                    control_parameter.timestamp_phase_switch_buffer_start = None
             else:
                 if condition:
                     # Timer laufen lassen
@@ -379,6 +381,7 @@ def auto_phase_switch(self,
                     ).data.set.reserved_surplus -= max(0, required_reserved_power)
                     message = f"Verzögerung für die {direction_str} Phasen abgebrochen{condition_msg}"
                     control_parameter.state = ChargepointState.CHARGING_ALLOWED
+                    control_parameter.timestamp_phase_switch_buffer_start = None
 
         if message:
             log.info(f"LP {cp_num}: {message}")

packages/control/phase_switch.py

@@ -38,8 +38,6 @@ def _perform_phase_switch(chargepoint_module: AbstractChargepoint, phases: int,
             time.sleep(5)
         # Phasenumschaltung entsprechend Modul
         chargepoint_module.switch_phases(phases, ev.ev_template.data.phase_switch_pause)
-        # Die Ladung wird in start_charging wieder gestartet, wenn phase_switch_timestamp wieder auf None gesetzt wird.
-        time.sleep(ev.ev_template.data.keep_charge_active_duration)
     except Exception:
         log.exception("Fehler im Phasenumschaltungs-Modul")
 

packages/helpermodules/command.py

@@ -461,7 +461,7 @@ def addChargeTemplate(self, connection_id: str, payload: dict) -> None:
             new_charge_template = asdict(new_charge_template)
         else:
             new_charge_template = get_new_charge_template()
-            new_charge_template["id"] = new_id
+        new_charge_template["id"] = new_id
 
         Pub().pub("openWB/set/command/max_id/charge_template", new_id)
         Pub().pub(f"openWB/set/vehicle/template/charge_template/{new_id}", new_charge_template)
@@ -648,8 +648,9 @@ def addEvTemplate(self, connection_id: str, payload: dict) -> None:
         else:
             new_ev_template = dataclass_utils.asdict(EvTemplateData())
         new_id = self.max_id_ev_template + 1
-        Pub().pub(f'openWB/set/vehicle/template/ev_template/{new_id}', new_ev_template)
+        new_ev_template["id"] = new_id
         self.max_id_ev_template = new_id
+        Pub().pub(f'openWB/set/vehicle/template/ev_template/{new_id}', new_ev_template)
         Pub().pub("openWB/set/command/max_id/ev_template", new_id)
         pub_user_message(
             payload, connection_id,