remove obsolet phase_switch_pause

packages/control/chargepoint/chargepoint.py

@@ -408,20 +408,7 @@ def check_phase_switch_completed(self):
             charging_ev = self.data.set.charging_ev_data
             # Umschaltung im Gange
             if self.data.control_parameter.state == ChargepointState.PERFORMING_PHASE_SWITCH:
-                phase_switch_pause = charging_ev.ev_template.data.phase_switch_pause
-                # Umschaltung abgeschlossen
-                try:
-                    timestamp_not_expired = timecheck.check_timestamp(
-                        self.data.control_parameter.timestamp_last_phase_switch,
-                        6 + phase_switch_pause - 1)
-                except TypeError:
-                    # so wird in jedem Fall die erforderliche Zeit abgewartet
-                    self.data.control_parameter.timestamp_last_phase_switch = create_timestamp()
-                    timestamp_not_expired = timecheck.check_timestamp(
-                        self.data.control_parameter.timestamp_last_phase_switch,
-                        6 + phase_switch_pause - 1)
-                if not timestamp_not_expired:
-                    log.debug("phase switch running")
+                if phase_switch.phase_switch_thread_alive(self.num) is False:
                     # Aktuelle Ladeleistung und Differenz wieder freigeben.
                     if self.data.set.phases_to_use == 1:
                         evu_counter.data.set.reserved_surplus -= charging_ev.ev_template. \

packages/control/ev/ev_template.py

@@ -9,7 +9,6 @@ class EvTemplateData:
     name: str = "Fahrzeug-Profil"
     max_current_multi_phases: int = 16
     max_phases: int = 3
-    phase_switch_pause: int = 2
     prevent_phase_switch: bool = False
     prevent_charge_stop: bool = False
     control_pilot_interruption: bool = False

packages/control/phase_switch.py

@@ -2,9 +2,7 @@
 """
 import logging
 from threading import Thread
-import time
 
-from control.ev.ev import Ev
 from helpermodules.utils._thread_handler import is_thread_alive, thread_handler
 from modules.common.abstract_chargepoint import AbstractChargepoint
 
@@ -20,24 +18,20 @@ def thread_phase_switch(cp) -> None:
         return thread_handler(Thread(
             target=_perform_phase_switch,
             args=(cp.chargepoint_module,
-                  cp.data.control_parameter.phases,
-                  cp.data.set.charging_ev_data,
-                  cp.data.get.charge_state),
+                  cp.data.control_parameter.phases),
             name=f"phase switch cp{cp.chargepoint_module.config.id}"))
     except Exception:
         log.exception("Fehler im Phasenumschaltungs-Modul")
 
 
-def _perform_phase_switch(chargepoint_module: AbstractChargepoint, phases: int, ev: Ev, charge_state: bool) -> None:
+def _perform_phase_switch(chargepoint_module: AbstractChargepoint, phases: int) -> None:
     """ ruft das Modul zur Phasenumschaltung für das jeweilige Modul auf.
     """
     # Stoppen der Ladung wird in start_charging bei gesetztem phase_switch_timestamp durchgeführt.
     # Wenn gerade geladen wird, muss vor der Umschaltung eine Pause von 5s gemacht werden.
     try:
-        if charge_state:
-            time.sleep(5)
         # Phasenumschaltung entsprechend Modul
-        chargepoint_module.switch_phases(phases, ev.ev_template.data.phase_switch_pause)
+        chargepoint_module.switch_phases(phases)
     except Exception:
         log.exception("Fehler im Phasenumschaltungs-Modul")
 

packages/modules/chargepoints/external_openwb/chargepoint_module.py

@@ -134,7 +134,7 @@ def on_message(client, userdata, message):
                                                      power=0)
                 self.store.set(chargepoint_state)
 
-    def switch_phases(self, phases_to_use: int, duration: int) -> None:
+    def switch_phases(self, phases_to_use: int) -> None:
         with SingleComponentUpdateContext(self.fault_state, update_always=False):
             with self.client_error_context:
                 pub.pub_single(
@@ -147,7 +147,6 @@ def switch_phases(self, phases_to_use: int, duration: int) -> None:
                     self.config.configuration.ip_address)
                 pub.pub_single("openWB/set/isss/U1p3p", phases_to_use,
                                self.config.configuration.ip_address)
-                time.sleep(6+duration-1)
 
     def interrupt_cp(self, duration: int) -> None:
         with SingleComponentUpdateContext(self.fault_state, update_always=False):

packages/modules/chargepoints/mqtt/chargepoint_module.py

@@ -98,7 +98,7 @@ def on_message(client, userdata, message):
                                          "veraltete, abwärtskompatible Topics verwendet. Bitte die Doku in den "
                                          "Einstellungen beachten.")
 
-    def switch_phases(self, phases_to_use: int, duration: int) -> None:
+    def switch_phases(self, phases_to_use: int) -> None:
         Pub().pub(f"openWB/mqtt/chargepoint/{self.config.id}/set/phases_to_use", phases_to_use)
 
 

packages/modules/chargepoints/openwb_pro/chargepoint_module.py

@@ -1,6 +1,5 @@
 
 import logging
-import time
 
 from helpermodules.utils.error_handling import CP_ERROR, ErrorTimerContext
 from modules.chargepoints.openwb_pro.config import OpenWBPro
@@ -133,14 +132,13 @@ def validate_values(self, chargepoint_state: ChargepointState) -> None:
         if chargepoint_state.plug_state is False and chargepoint_state.power > 20:
             raise ValueError(self.WRONG_PLUG_STATE)
 
-    def switch_phases(self, phases_to_use: int, duration: int) -> None:
+    def switch_phases(self, phases_to_use: int) -> None:
         with SingleComponentUpdateContext(self.fault_state, update_always=False):
             with self.client_error_context:
                 response = self.__session.get(f'http://{self.config.configuration.ip_address}/connect.php')
                 if response.json()["phases_target"] != phases_to_use:
                     self.__session.post(f'http://{self.config.configuration.ip_address}/connect.php',
                                         data={'phasetarget': str(1 if phases_to_use == 1 else 3)})
-                    time.sleep(duration)
 
     def clear_rfid(self) -> None:
         pass

packages/modules/chargepoints/openwb_series2_satellit/chargepoint_module.py

@@ -132,12 +132,14 @@ def set_current(self, current: float) -> None:
                         self._create_client()
                         self._validate_version()
 
-    def switch_phases(self, phases_to_use: int, duration: int) -> None:
+    def switch_phases(self, phases_to_use: int) -> None:
         if self.version is not None:
             with SingleComponentUpdateContext(self.fault_state, update_always=False):
                 with self.client_error_context:
                     try:
                         with self._client.client:
+                            self._client.evse_client.set_current(0)
+                            time.sleep(5)
                             if phases_to_use == 1:
                                 self._client.client.delegate.write_register(
                                     0x0001, 256, unit=self.ID_PHASE_SWITCH_UNIT)

packages/modules/common/abstract_chargepoint.py

@@ -18,7 +18,7 @@ def get_values(self) -> None:
         pass
 
     @abstractmethod
-    def switch_phases(self, phases_to_use: int, duration: int) -> None:
+    def switch_phases(self, phases_to_use: int) -> None:
         pass
 
     @abstractmethod

packages/modules/internal_chargepoint_handler/chargepoint_module.py

@@ -141,16 +141,16 @@ def store_state(chargepoint_state: ChargepointState) -> None:
         self.old_chargepoint_state = chargepoint_state
         return chargepoint_state
 
-    def perform_phase_switch(self, phases_to_use: int, duration: int) -> None:
+    def perform_phase_switch(self, phases_to_use: int) -> None:
         gpio_cp, gpio_relay = self._client.get_pins_phase_switch(phases_to_use)
         with SingleComponentUpdateContext(self.fault_state, update_always=False):
             self._client.evse_client.set_current(0)
-        time.sleep(1)
+        time.sleep(5)
         GPIO.output(gpio_cp, GPIO.HIGH)  # CP off
         GPIO.output(gpio_relay, GPIO.HIGH)  # 3 on/off
-        time.sleep(duration)
+        time.sleep(5)
         GPIO.output(gpio_relay, GPIO.LOW)  # 3 on/off
-        time.sleep(duration)
+        time.sleep(5)
         GPIO.output(gpio_cp, GPIO.LOW)  # CP on
         time.sleep(1)
 

packages/modules/internal_chargepoint_handler/internal_chargepoint_handler.py

@@ -68,7 +68,7 @@ def update_state(self, data: InternalChargepoint, heartbeat_expired: bool) -> No
 
     def __thread_phase_switch(self, phases_to_use: int) -> None:
         self.phase_switch_thread = Thread(
-            target=self.cp_module.perform_phase_switch, args=(phases_to_use, 5),
+            target=self.cp_module.perform_phase_switch, args=(phases_to_use,),
             name=f"perform phase switch {self.cp_module.local_charge_point_num}")
         self.phase_switch_thread.start()
         log.debug("Thread zur Phasenumschaltung an LP"+str(self.cp_module.local_charge_point_num)+" gestartet.")

packages/modules/internal_chargepoint_handler/pro_plus.py

@@ -71,8 +71,8 @@ def store_state(chargepoint_state: ChargepointState) -> None:
                 store_state(self.old_chargepoint_state)
                 return self.old_chargepoint_state
 
-    def perform_phase_switch(self, phases_to_use: int, duration: int) -> None:
-        super().switch_phases(phases_to_use, duration)
+    def perform_phase_switch(self, phases_to_use: int) -> None:
+        super().switch_phases(phases_to_use)
 
     def perform_cp_interruption(self, duration: int) -> None:
         pass