optional reset of the manual SoC

packages/control/chargepoint/chargepoint.py

@@ -188,14 +188,21 @@ def _process_charge_stop(self) -> None:
         if self.data.get.plug_state is False and self.data.set.plug_state_prev is True:
             chargelog.save_and_reset_data(self, data.data.ev_data["ev"+str(self.data.config.ev)])
             self.data.control_parameter = control_parameter_factory()
+            # VOR Standard nach Abstecken
+            if (self.data.set.charging_ev_data.soc_module is not None and
+                self.data.set.charging_ev_data.soc_module.vehicle_config.type == "manual" and
+                    self.data.set.charging_ev_data.soc_module.vehicle_config.configuration.reset_after_unplug):
+                Pub().pub(f"openWB/set/vehicle/{self.data.config.ev}/soc_module/calculated_soc_state/manual_soc", 0)
             if self.data.set.charge_template.data.load_default:
                 self.data.config.ev = 0
             if self.template.data.disable_after_unplug:
                 self.data.set.manual_lock = True
                 log.debug("/set/manual_lock True")
+            # NACH Standard nach Abstecken
             if data.data.general_data.data.temporary_charge_templates_active:
                 self.update_charge_template(
                     data.data.ev_data["ev"+str(self.data.config.ev)].charge_template)
+
             self.data.set.rfid = None
             self.data.set.plug_time = None
             self.data.set.phases_to_use = self.data.get.phases_in_use
@@ -616,12 +623,12 @@ def update(self, ev_list: Dict[str, Ev]) -> None:
             vehicle, message_ev = self.template.get_ev(self.data.set.rfid or self.data.get.rfid,
                                                        self.data.get.vehicle_id,
                                                        self.data.config.ev)
+            charging_ev = self._get_charging_ev(vehicle, ev_list)
             if message_ev:
                 message += message_ev
 
             if charging_possible:
                 try:
-                    charging_ev = self._get_charging_ev(vehicle, ev_list)
                     state, message_ev, submode, required_current, template_phases = charging_ev.get_required_current(
                         self.data.set.charge_template,
                         self.data.control_parameter,

packages/control/chargepoint/chargepoint_test.py

@@ -1,13 +1,25 @@
 from dataclasses import dataclass
-from typing import List
+from typing import List, Optional
 from unittest.mock import Mock
 import pytest
 
 from control import data
+from control.chargelog import chargelog
 from control.chargepoint.chargepoint import Chargepoint
 from control.chargepoint.chargepoint_state import ChargepointState
 from control.chargepoint.chargepoint_template import CpTemplate
+from control.counter import Counter
 from control.ev.ev import Ev
+from modules.common.configurable_vehicle import ConfigurableVehicle
+from modules.vehicles.manual.config import ManualSoc
+from modules.vehicles.manual.soc import create_vehicle as create_manual_vehicle
+from modules.vehicles.tesla.config import TeslaSoc
+from modules.vehicles.tesla.soc import create_vehicle as create_tesla_vehicle
+
+
+@pytest.fixture()
+def mock_data() -> None:
+    data.data_init(Mock())
 
 
 @pytest.mark.parametrize("phase_1, phases, expected_required_currents",
@@ -144,3 +156,43 @@ def test_is_phase_switch_required(params: Params):
 
     # assertion
     assert ret == params.phase_switch_required
+
+
+@pytest.mark.parametrize(
+    "soc_module, reset_after_unplug, expected_calls, expected_pub_call",
+    [
+        pytest.param(None, None, 0, None, id="kein SoC-Modul"),
+        pytest.param(create_manual_vehicle(ManualSoc(), 0), True, 1,
+                     ("openWB/set/vehicle/0/soc_module/calculated_soc_state/manual_soc", 0),
+                     id="manuelles SoC-Modul, Reset nach Abstecken"),
+        pytest.param(create_manual_vehicle(ManualSoc(), 0), False, 0, None,
+                     id="manuelles SoC-Modul, kein Reset nach Abstecken"),
+        pytest.param(create_tesla_vehicle(TeslaSoc(), 0), None, 0, None, id="Tesla SoC-Modul"),
+    ])
+def test_process_charge_stop_reset_manual_soc(soc_module: Optional[ConfigurableVehicle],
+                                              reset_after_unplug: Optional[bool],
+                                              expected_calls: int,
+                                              expected_pub_call: Optional[tuple],
+                                              mock_pub: Mock, mock_data, monkeypatch):
+    # setup
+    cp = Chargepoint(0, None)
+    cp.template = CpTemplate()
+    cp.data.config.ev = 0
+    cp.data.set.plug_state_prev = True
+    ev = Ev(0)
+    ev.soc_module = soc_module
+    if soc_module and soc_module.vehicle_config.type == "manual":
+        ev.soc_module.vehicle_config.configuration.reset_after_unplug = reset_after_unplug
+    cp.data.set.charging_ev_data = ev
+    data.data.ev_data["ev0"] = ev
+    monkeypatch.setattr(chargelog, "save_and_reset_data", Mock())
+    monkeypatch.setattr(data.data.counter_all_data, "get_evu_counter", Mock(
+        return_value=Mock(spec=Counter, reset_switch_on_off=Mock())))
+
+    # execution
+    cp._process_charge_stop()
+
+    # evaluation
+    assert len(mock_pub.method_calls) - 1 == expected_calls
+    if expected_calls > 0:
+        assert mock_pub.method_calls[1].args == expected_pub_call

packages/control/ocpp_test.py

@@ -19,6 +19,7 @@ def mock_data() -> None:
 
 def test_start_transaction(mock_data, monkeypatch):
     cp = Chargepoint(1, None)
+    cp.data.config.ev = 0
     cp.data.config.ocpp_chargebox_id = "cp1"
     cp.data.get.plug_state = True
     cp.template = CpTemplate()
@@ -29,7 +30,7 @@ def test_start_transaction(mock_data, monkeypatch):
     _pub_configured_ev_mock = Mock()
     monkeypatch.setattr(cp, "_pub_configured_ev", _pub_configured_ev_mock)
 
-    cp.update([])
+    cp.update({"ev0": Ev(0)})
 
     assert start_transaction_mock.call_args == (("cp1", cp.chargepoint_module.fault_state, 1, None, 0),)
 

packages/helpermodules/update_config.py

@@ -57,7 +57,7 @@
 
 class UpdateConfig:
 
-    DATASTORE_VERSION = 112
+    DATASTORE_VERSION = 113
 
     valid_topic = [
         "^openWB/bat/config/bat_control_permitted$",
@@ -2858,3 +2858,13 @@ def upgrade(topic: str, payload) -> Optional[dict]:
         run_command(['pip', 'uninstall', 'bimmer_connected', '-y'], process_exception=True)
         self._loop_all_received_topics(upgrade)
         self._append_datastore_version(112)
+
+    def upgrade_datastore_113(self) -> None:
+        def upgrade(topic: str, payload) -> Optional[dict]:
+            if re.search("openWB/vehicle/[0-9]+/soc_module/config", topic) is not None:
+                payload = decode_payload(payload)
+                if payload.get("type") == "manual" and payload["configuration"].get("reset_after_unplug") is None:
+                    payload["configuration"]["reset_after_unplug"] = False
+                    return {topic: payload}
+        self._loop_all_received_topics(upgrade)
+        self._append_datastore_version(113)

packages/modules/vehicles/manual/config.py

@@ -1,6 +1,6 @@
 class ManualSocConfiguration:
-    def __init__(self) -> None:
-        pass
+    def __init__(self, reset_after_unplug: bool = False) -> None:
+        self.reset_after_unplug = reset_after_unplug
 
 
 class ManualSoc: