Calculate the maximum charging duration at the time of the minimum as in this case, it is more likely that the upcoming energy rates are available

Author: felixschndr

source/inverter_charge_controller.py

@@ -142,6 +142,12 @@ def _do_iteration(self, current_energy_rate: EnergyRate) -> EnergyRate:
         next_price_minimum = self._get_next_price_minimum()
         self.log.info(f"The next price minimum is at {next_price_minimum}")
 
+        self.tibber_api_handler.set_maximum_charging_duration_of_current_energy_rate(current_energy_rate)
+        self.log.info(
+            f"The maximum charging duration of the current energy rate is "
+            f"{current_energy_rate.maximum_charging_duration}"
+        )
+
         if next_price_minimum.rate > current_energy_rate.rate:
             # Information is unused at the moment
             self.log.info("The price of the upcoming minimum is higher than the current energy rate")
@@ -249,16 +255,18 @@ def _do_iteration(self, current_energy_rate: EnergyRate) -> EnergyRate:
 
     def _charge_inverter(self, target_state_of_charge: int, maximum_charging_duration: timedelta) -> None:
         """
-        Charges the inverter until a given state of charge is reached.
-        Checks every few minutes the current state of charge and compares to the target value.
-        Charges the inverter for a maximum of one hour. If consecutive_energy_rate_is_cheap is True it charges for a
-        maximum of two hours.
-        --> Stops when the target state of charge or the maximum charge time is reached (whichever comes first)
+        Charges the inverter battery to the target state of charge within a specified maximum charging duration.
+        Monitors the charging progress at regular intervals and stops the charging process if specific conditions are
+        met:
+         - Charging limit reached
+         - Maximum charging duration reached (at this point the energy prices would be to high to charge)
+         - The state of the inverter was changed manually
+         - Too many errors occurred while trying to communicate with the inverter
 
         Args:
-            target_state_of_charge: The desired state of charge percentage to reach before stopping the charging process.
-            maximum_charging_duration: The maximum duration for which charging is feasible under given energy rate
-                constraints.
+            target_state_of_charge: The desired battery state of charge percentage to reach during the
+                charging process.
+            maximum_charging_duration: The maximum duration allowed for the charging process to complete.
         """
         charging_progress_check_interval = timedelta(minutes=5)
 

source/tibber_api_handler.py

@@ -23,6 +23,8 @@ def __init__(self):
 
         self.database_handler = DatabaseHandler("energy_prices")
 
+        self.upcoming_energy_rates_cache = []
+
     def get_next_price_minimum(self, first_iteration: bool = False) -> EnergyRate:
         """
         This method performs a series of operations to determine the most cost-effective time to charge by analyzing
@@ -57,6 +59,7 @@ def get_next_price_minimum(self, first_iteration: bool = False) -> EnergyRate:
         all_energy_rates = self._extract_energy_rates_from_api_response(api_result)
         self.write_energy_rates_to_database(all_energy_rates)
         upcoming_energy_rates = self._remove_energy_rates_from_the_past(all_energy_rates)
+        self.upcoming_energy_rates_cache = upcoming_energy_rates
         if first_iteration and not self._check_if_next_three_prices_are_greater_than_current_one(
             upcoming_energy_rates
         ):
@@ -80,44 +83,29 @@ def get_next_price_minimum(self, first_iteration: bool = False) -> EnergyRate:
         ):
             minimum_of_energy_rates.has_to_be_rechecked = True
 
-        minimum_of_energy_rates.maximum_charging_duration = self._calculate_maximum_charging_duration(
-            minimum_of_energy_rates, upcoming_energy_rates
-        )
-
         return minimum_of_energy_rates
 
-    @staticmethod
-    def _calculate_maximum_charging_duration(
-        minimum_of_energy_rates: EnergyRate, upcoming_energy_rates: list[EnergyRate]
-    ) -> timedelta:
+    def set_maximum_charging_duration_of_current_energy_rate(self, current_energy_rate: EnergyRate) -> None:
         """
-        Calculates the maximum duration for which charging is feasible under given energy rate constraints.
+        It takes the current energy rate from the InverterChargeController and compares it against the upcoming energy
+        rates. It then calculates and sets the maximum possible charging duration based on the comparison of the current
+        price and the consecutive ones.
 
-        This method computes the maximum charging duration based on the minimum energy rate within the list of upcoming
-        energy rates and MAXIMUM_THRESHOLD. This ensures that charging only continues while subsequent energy rates
-        remain within the allowed threshold of the minimum energy rate.
+        We have to provide the current energy rate as the upcoming energy rates (which are saved as an instance
+        variable) only include the **upcoming** energy rates and not the current one.
 
         Args:
-            minimum_of_energy_rates: The energy rate which is considered as the minimum acceptable
-                rate for initiating or continuing charging.
-            upcoming_energy_rates: A list of energy rates representing projected energy pricing
-                in subsequent time periods.
-
-        Returns:
-            A timedelta object representing the maximum charging duration under the given energy rate constraints.
+            current_energy_rate (EnergyRate): The current energy rate for comparison against upcoming energy rates.
         """
-        index = upcoming_energy_rates.index(minimum_of_energy_rates)
         charging_duration = timedelta(hours=1)
-        if index + 1 >= len(upcoming_energy_rates):
-            return charging_duration
 
-        for energy_rate in upcoming_energy_rates[index + 1 :]:
-            if energy_rate.rate <= minimum_of_energy_rates.rate + TibberAPIHandler.MAXIMUM_THRESHOLD:
+        for energy_rate in self.upcoming_energy_rates_cache:
+            if energy_rate.rate <= current_energy_rate.rate + TibberAPIHandler.MAXIMUM_THRESHOLD:
                 charging_duration += timedelta(hours=1)
-                continue
-            break
+            else:
+                break
 
-        return charging_duration
+        current_energy_rate.maximum_charging_duration = charging_duration
 
     @staticmethod
     def _check_if_next_three_prices_are_greater_than_current_one(all_upcoming_energy_rates: list[EnergyRate]) -> bool:
@@ -168,8 +156,6 @@ def _fetch_upcoming_prices_from_api(self) -> dict:
             }
         """
         )
-        # Note: Sometimes we only get the prices for today from the tibber api and the prices for tomorrow stay empty
-        # I guess they are not determined yet...?
         self.log.debug("Crawling the Tibber API for the electricity prices")
         response = self.client.execute(query)
         self.log.trace(f"Retrieved data: {response}")