Feature fix phases

packages/control/chargepoint/chargepoint.py

@@ -376,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.get.charge_state is False):
             phase_switch_required = True
         if phase_switch_required:
             # Umschaltung fehlgeschlagen
@@ -386,17 +386,18 @@ def _is_phase_switch_required(self) -> bool:
                         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.")
+                            "aktuelle Phasenzahl wird bis zur nächsten Ladeunterbrechung beibehalten.")
                     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."
@@ -778,6 +779,7 @@ def update(self, ev_list: Dict[str, Ev]) -> None:
                 if self.data.set.charge_state_prev and self.data.get.charge_state is False:
                     Pub().pub(f"openWB/set/vehicle/{self.data.config.ev}/get/force_soc_update", True)
                     log.info(f"SoC-Abfrage nach Ladeunterbrechung, cp{self.num}, ev{self.data.config.ev}")
+                    self.reset_control_parameter_at_charge_stop()
             except Exception:
                 log.exception(f"Fehler bei Ladestop,cp{self.num}")
 
@@ -825,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
@@ -910,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

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/modules/common/store/_chargepoint_internal.py

@@ -24,19 +24,19 @@ def update(self):
         pub_to_broker(f"{topic_prefix}/phases_in_use", self.state.phases_in_use, 2)
         pub_to_broker(f"{topic_prefix}/charge_state", self.state.charge_state, 2)
         pub_to_broker(f"{topic_prefix}/plug_state", self.state.plug_state, 2)
-        pub_to_broker(f"{topic_prefix}/rfid", self.state.rfid)
+        pub_to_broker(f"{topic_prefix}/vehicle_id", self.state.vehicle_id)
         pub_to_broker(f"{topic_prefix}/serial_number", self.state.serial_number)
         pub_to_broker(f"{topic_prefix}/evse_current", self.state.evse_current, 2)
         pub_to_broker(f"{topic_prefix}/max_evse_current", self.state.max_evse_current, 2)
         pub_to_broker(f"{topic_prefix}/version", self.state.version)
         pub_to_broker(f"{topic_prefix}/current_branch", self.state.current_branch)
         pub_to_broker(f"{topic_prefix}/current_commit", self.state.current_commit)
         if self.state.soc is not None:
-            pub_to_broker(f"{topic_prefix}/get/soc", self.state.soc)
+            pub_to_broker(f"{topic_prefix}/soc", self.state.soc)
         if self.state.soc_timestamp is not None:
             pub_to_broker(f"{topic_prefix}/soc_timestamp", self.state.soc_timestamp)
         if self.state.rfid_timestamp is not None:
-            pub_to_broker(f"{topic_prefix}/vehicle_id", self.state.vehicle_id)
+            pub_to_broker(f"{topic_prefix}/rfid", self.state.rfid)
             pub_to_broker(f"{topic_prefix}/rfid_timestamp", self.state.rfid_timestamp)
 
 

packages/modules/internal_chargepoint_handler/chargepoint_module.py

@@ -1,9 +1,12 @@
 import logging
 
 import time
+from helpermodules.broker import BrokerClient
 from helpermodules.logger import ModifyLoglevelContext
 
+from helpermodules.utils import run_command
 from helpermodules.utils.error_handling import CP_ERROR, ErrorTimerContext
+from helpermodules.utils.topic_parser import decode_payload
 from modules.common.abstract_chargepoint import AbstractChargepoint
 from modules.common.component_context import SingleComponentUpdateContext
 from modules.common.component_state import ChargepointState
@@ -42,7 +45,6 @@ def __init__(self, local_charge_point_num: int,
             hide_exception=True)
         self.client_error_context.error_timestamp = internal_cp.get.error_timestamp
         self.old_plug_state = False
-        self.old_phases_in_use = 0
         self.old_chargepoint_state = ChargepointState(plug_state=False,
                                                       charge_state=False,
                                                       imported=None,
@@ -65,6 +67,20 @@ def __init__(self, local_charge_point_num: int,
         self.current_branch = SubData.system_data["system"].data["current_branch"]
         self.current_commit = SubData.system_data["system"].data["current_commit"]
 
+        if float(run_command.run_command(["cat", "/proc/uptime"]).split(" ")[0]) < 180:
+            self.perform_phase_switch(1, 4)
+            self.old_phases_in_use = 1
+        else:
+            def on_connect(client, userdata, flags, rc):
+                client.subscribe(f"openWB/internal_chargepoint/{self.local_charge_point_num}/get/phases_in_use")
+
+            def on_message(client, userdata, message):
+                self.old_phases_in_use = decode_payload(message.payload)
+
+            self.old_phases_in_use = None
+            BrokerClient(f"subscribeInternalCp{self.local_charge_point_num}",
+                         on_connect, on_message).start_finite_loop()
+
     def set_current(self, current: float) -> None:
         with SingleComponentUpdateContext(self.fault_state, update_always=False):
             formatted_current = round(current*100) if self._precise_current else round(current)