fix pro+ error handling

packages/helpermodules/update_config.py

@@ -112,6 +112,7 @@ class UpdateConfig:
         "^openWB/chargepoint/[0-9]+/get/currents$",
         "^openWB/chargepoint/[0-9]+/get/current_branch$",
         "^openWB/chargepoint/[0-9]+/get/current_commit$",
+        "^openWB/chargepoint/[0-9]+/get/error_timestamp$",
         "^openWB/chargepoint/[0-9]+/get/evse_current$",
         "^openWB/chargepoint/[0-9]+/get/fault_state$",
         "^openWB/chargepoint/[0-9]+/get/fault_str$",
@@ -256,6 +257,7 @@ class UpdateConfig:
         "^openWB/internal_chargepoint/[0-1]/get/currents$",
         "^openWB/internal_chargepoint/[0-1]/get/current_branch$",
         "^openWB/internal_chargepoint/[0-1]/get/current_commit$",
+        "^openWB/internal_chargepoint/[0-1]/get/error_timestamp$",
         "^openWB/internal_chargepoint/[0-1]/get/evse_current$",
         "^openWB/internal_chargepoint/[0-1]/get/fault_state$",
         "^openWB/internal_chargepoint/[0-1]/get/fault_str$",

packages/modules/chargepoints/external_openwb/chargepoint_module.py

@@ -103,6 +103,10 @@ def on_message(client, userdata, message):
                         max_evse_current=received_topics.get(f"{topic_prefix}max_evse_current"),
                     )
                     self.store.set(chargepoint_state)
+                    if received_topics.get(f"{topic_prefix}fault_state") == 2:
+                        self.fault_state.error(received_topics.get(f"{topic_prefix}fault_str"))
+                    elif received_topics.get(f"{topic_prefix}fault_state") == 1:
+                        self.fault_state.warning(received_topics.get(f"{topic_prefix}fault_str"))
                 else:
                     self.fault_state.warning(f"Keine MQTT-Daten für Ladepunkt {self.config.name} empfangen. Noch keine "
                                              "Daten nach dem Start oder Ladepunkt nicht erreichbar.")

packages/modules/chargepoints/openwb_pro/chargepoint_module.py

@@ -12,6 +12,7 @@
 from modules.common.store import get_chargepoint_value_store
 from modules.common.component_state import ChargepointState
 from modules.common import req
+from modules.internal_chargepoint_handler.internal_chargepoint_handler_config import InternalChargepoint
 
 log = logging.getLogger(__name__)
 
@@ -36,15 +37,16 @@ def __init__(self, config: OpenWBPro) -> None:
                     'http://' + self.config.configuration.ip_address + '/connect.php',
                     data={'heartbeatenabled': '1'})
 
-    def set_internal_context_handlers(self, parent_cp, parent_hostname):
+    def set_internal_context_handlers(self, internal_cp: InternalChargepoint, parent_hostname: str):
         self.fault_state = FaultState(ComponentInfo(
             self.config.id,
             "Ladepunkt "+str(self.config.id),
-            "chargepoint",
-            parent_id=parent_cp,
+            "internal_chargepoint",
+            parent_id=internal_cp.data.parent_cp,
             parent_hostname=parent_hostname))
         self.client_error_context = ErrorTimerContext(
             f"openWB/set/internal_chargepoint/{self.config.id}/get/error_timestamp", CP_ERROR, hide_exception=True)
+        self.client_error_context.error_timestamp = internal_cp.get.error_timestamp
 
     def set_current(self, current: float) -> None:
         if self.client_error_context.error_counter_exceeded():

packages/modules/common/component_context.py

@@ -93,7 +93,7 @@ def override_subcomponent_state(fault_state: FaultState, exception, update_alway
 
         if exception:
             fault_state.from_exception(exception)
-        elif update_always is False:
+        elif update_always is False and fault_state.fault_state == 0:
             # Fehlerstatus nicht überschreiben
             return
         fault_state.store_error()

packages/modules/internal_chargepoint_handler/chargepoint_module.py

@@ -11,6 +11,7 @@
 from modules.common.store import get_internal_chargepoint_value_store, get_chargepoint_value_store
 from modules.internal_chargepoint_handler.clients import ClientHandler
 from helpermodules.subdata import SubData
+from modules.internal_chargepoint_handler.internal_chargepoint_handler_config import InternalChargepoint
 
 log = logging.getLogger(__name__)
 
@@ -26,21 +27,22 @@ class ChargepointModule(AbstractChargepoint):
     def __init__(self, local_charge_point_num: int,
                  client_handler: ClientHandler,
                  parent_hostname: str,
-                 parent_cp: int,
+                 internal_cp: InternalChargepoint,
                  hierarchy_id: int) -> None:
         self.local_charge_point_num = local_charge_point_num
         self.fault_state = FaultState(ComponentInfo(
             hierarchy_id,
             "Ladepunkt "+str(local_charge_point_num),
-            "chargepoint",
-            parent_id=parent_cp,
+            "internal_chargepoint",
+            parent_id=internal_cp.data.parent_cp,
             parent_hostname=parent_hostname))
         self.store_internal = get_internal_chargepoint_value_store(local_charge_point_num)
         self.store = get_chargepoint_value_store(hierarchy_id)
         self.client_error_context = ErrorTimerContext(
             f"openWB/set/internal_chargepoint/{local_charge_point_num}/get/error_timestamp",
             CP_ERROR,
             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()

packages/modules/internal_chargepoint_handler/internal_chargepoint_handler.py

@@ -239,24 +239,27 @@ def __init__(self,
                  local_charge_point_num: int,
                  mode: InternalChargepointMode,
                  global_data: GlobalHandlerData,
-                 parent_cp: str,
+                 internal_cp: InternalChargepoint,
                  hierarchy_id: int) -> None:
         self.local_charge_point_num = local_charge_point_num
         self.mode = mode
         if local_charge_point_num == 0:
             if mode == InternalChargepointMode.SOCKET.value:
                 self.module = Socket(local_charge_point_num, client_handler,
-                                     global_data.parent_ip, parent_cp, hierarchy_id)
+                                     global_data.parent_ip, internal_cp, hierarchy_id)
             elif mode == InternalChargepointMode.PRO_PLUS.value:
-                self.module = ProPlus(local_charge_point_num, global_data.parent_ip, parent_cp, hierarchy_id)
+                self.module = ProPlus(local_charge_point_num, global_data.parent_ip, internal_cp, hierarchy_id)
             else:
                 self.module = chargepoint_module.ChargepointModule(
-                    local_charge_point_num, client_handler, global_data.parent_ip, parent_cp, hierarchy_id)
+                    local_charge_point_num, client_handler, global_data.parent_ip, internal_cp, hierarchy_id)
         else:
             self.module = chargepoint_module.ChargepointModule(
-                local_charge_point_num, client_handler, global_data.parent_ip, parent_cp, hierarchy_id)
+                local_charge_point_num, client_handler, global_data.parent_ip, internal_cp, hierarchy_id)
         with SingleComponentUpdateContext(self.module.fault_state):
-            self.update_values = UpdateValues(local_charge_point_num, global_data.parent_ip, parent_cp, hierarchy_id)
+            self.update_values = UpdateValues(local_charge_point_num,
+                                              global_data.parent_ip,
+                                              internal_cp.data.parent_cp,
+                                              hierarchy_id)
             self.update_state = UpdateState(self.module, hierarchy_id)
             self.old_plug_state = False
 
@@ -317,9 +320,9 @@ def handler(self):
                     self.internal_chargepoint_handler = InternalChargepointHandler(
                         mode,
                         data["global_data"],
-                        data["cp0"].data.parent_cp,
+                        data["cp0"],
                         hierarchy_id_cp0,
-                        data["cp1"].data.parent_cp,
+                        data["cp1"],
                         hierarchy_id_cp1,
                         self.event_start,
                         self.event_stop)

packages/modules/internal_chargepoint_handler/internal_chargepoint_handler_config.py

@@ -41,6 +41,7 @@ class Get:
     rfid_timestamp: Optional[str] = None
     rfid: Optional[str] = None
     voltages: List[float] = field(default_factory=voltages_list_factory)
+    error_timestamp: float = None
 
 
 def get_factory() -> Get:

packages/modules/internal_chargepoint_handler/pro_plus.py

@@ -4,19 +4,21 @@
 from modules.common.component_state import ChargepointState
 from modules.common.store._chargepoint import get_chargepoint_value_store
 from modules.common.store._chargepoint_internal import get_internal_chargepoint_value_store
+from modules.internal_chargepoint_handler.internal_chargepoint_handler_config import InternalChargepoint
 
 
 class ProPlus(ChargepointModule):
     def __init__(self, local_charge_point_num: int,
                  parent_hostname: str,
-                 parent_cp: int,
+                 internal_cp: InternalChargepoint,
                  hierarchy_id: int) -> None:
         self.local_charge_point_num = local_charge_point_num
         self.store_internal = get_internal_chargepoint_value_store(local_charge_point_num)
         self.store = get_chargepoint_value_store(hierarchy_id)
+        self.old_chargepoint_state = None
 
         super().__init__(OpenWBPro(configuration=OpenWBProConfiguration(ip_address="192.168.192.50")))
-        super().set_internal_context_handlers(parent_cp, parent_hostname)
+        super().set_internal_context_handlers(internal_cp, parent_hostname)
 
     def get_values(self, phase_switch_cp_active: bool, last_tag: str) -> ChargepointState:
         def store_state(chargepoint_state: ChargepointState) -> None:
@@ -27,12 +29,18 @@ def store_state(chargepoint_state: ChargepointState) -> None:
 
         try:
             chargepoint_state = super().request_values()
-            if last_tag is not None and last_tag != "":
+            if chargepoint_state is not None and last_tag is not None and last_tag != "":
                 chargepoint_state.rfid = last_tag
         except (requests.exceptions.ConnectTimeout, requests.exceptions.ConnectionError):
             raise Exception("Interner Ladepunkt ist nicht erreichbar.")
 
+        if chargepoint_state is None:
+            if self.old_chargepoint_state is None:
+                raise Exception("Keine erfolgreiche Auslesung der Daten seit dem Start möglich.")
+            # bei Fehler, aber Fehlerzähler noch nicht abgelaufen
+            chargepoint_state = self.old_chargepoint_state
         store_state(chargepoint_state)
+        self.old_chargepoint_state = chargepoint_state
         return chargepoint_state
 
     def perform_phase_switch(self, phases_to_use: int, duration: int) -> None:

packages/modules/internal_chargepoint_handler/socket.py

@@ -10,6 +10,7 @@
 from modules.common.component_state import ChargepointState
 from modules.internal_chargepoint_handler.chargepoint_module import ChargepointModule
 from modules.internal_chargepoint_handler.clients import ClientHandler
+from modules.internal_chargepoint_handler.internal_chargepoint_handler_config import InternalChargepoint
 
 
 log = logging.getLogger(__name__)
@@ -51,12 +52,12 @@ def __init__(self,
                  local_charge_point_num: int,
                  client_handler: ClientHandler,
                  parent_hostname: str,
-                 parent_cp: int,
+                 internal_cp: InternalChargepoint,
                  hierarchy_id: int) -> None:
         self.socket_max_current = get_hardware_configuration_setting("max_c_socket")
         with ModifyLoglevelContext(log, logging.DEBUG):
             log.info(f"Konfiguration als Buchse mit maximal {self.socket_max_current}A Ladestrom je Phase.")
-        super().__init__(local_charge_point_num, client_handler, parent_hostname, parent_cp, hierarchy_id)
+        super().__init__(local_charge_point_num, client_handler, parent_hostname, internal_cp, hierarchy_id)
 
     def set_current(self, current: float) -> None:
         with SingleComponentUpdateContext(self.fault_state, update_always=False):