Replace systemd logging of solar forecast with threading to streamline the programm execution flow and not clutter up the system

Author: felixschndr

README.md

@@ -193,20 +193,6 @@ You can use the [inverter script](./inverter) to control the inverter manually o
 The logs of the application are stored in `<path to repository>/logs/`. They are rolled over once a logfile reaches `1 MB` in size. The current log and a maximum of `7` rolled over logfiles are saved.
 See also the environment variables `DIRECTORY_OF_LOGS` and `LOGLEVEL`.
 
-#### Only log the solar forecast
-
-If you pass in `--solar-forecast` as an argument to `main.py` the programm just logs the expected solar forecast of the day.
-
-This can also be used to log the solar prediction after the sun has set to see how far off the solar prediction was and get a sense of how good the predication was (→ not as a *forecast* but as a *review*). To correctly display the log message use `--solar-review` in this case.
-
-#### Monitor solar forecast prediction and power buy
-
-You can monitor how far the prediction of the solar forecast was off and how much power was bought with the script [solar_forecast_logger.sh](solar_forecast_logger.sh).
-
-It saves the following data:
-- `<directory> of logs>/power_buy.log`: `<timestamp of start of charging>\t<timestamp of end of charging>\t<power bought in Wh>`
-- `<directory> of logs>/solar_forecast_difference.log`: `<date>\t<prediction at start of day in Wh>\t<prediction at end of day in Wh>`
-
 ## InfluxDB commands
 
 - Create bucket: `influx bucket create -org default -token ${INFLUXDB_TOKEN} --name default`

solar_forecast_logger.sh

@@ -1,5 +1,6 @@
 import os
 import socket
+import sys
 from datetime import datetime, timedelta
 
 import pause
@@ -107,7 +108,7 @@ def _start(self) -> None:
 
             finally:
                 self.log.critical("An unexpected error occurred. Exiting now...", exc_info=True)
-                exit(1)
+                sys.exit(1)
 
     def _do_iteration(self, current_energy_rate: EnergyRate) -> EnergyRate:
         """

source/inverter_charge_controller.py

@@ -1,30 +1,59 @@
 import signal
 import sys
-from datetime import timedelta
+import threading
+from datetime import datetime, time, timedelta
 from types import FrameType
 
+import pause
 from inverter_charge_controller import InverterChargeController
 from logger import LoggerMixin
 from sun_forecast_handler import SunForecastHandler
 from time_handler import TimeHandler
 
+logger = LoggerMixin()
 
-def log_solar_forecast(log_as_review: bool = False) -> None:
+
+def log_solar_forecast() -> None:
     sun_forecast_handler = SunForecastHandler()
+    morning_time = time(hour=5, minute=0, second=0, microsecond=0, tzinfo=TimeHandler.get_timezone())
+    evening_time = time(hour=23, minute=0, second=0, microsecond=0, tzinfo=TimeHandler.get_timezone())
+    while True:
+        next_wakeup_time = _get_next_wakeup_time(morning_time, evening_time)
+        logger.log.info(f"Next wakeup time to log solar forecast data is at {next_wakeup_time}")
+        pause.until(next_wakeup_time)
+
+        start, end = _get_morning_and_evening_timestamp_of_today(morning_time, evening_time)
+        logger.log.info(f"Waking up to log solar forecast data from {start} to {end}")
+        if TimeHandler.get_time().hour == morning_time.hour:
+            start += timedelta(minutes=2)
+        else:
+            end -= timedelta(minutes=2)
+
+        sun_forecast_handler.get_solar_output_in_timeframe(start, end)
+
 
+def _get_morning_and_evening_timestamp_of_today(morning_time: time, evening_time: time) -> tuple[datetime, datetime]:
+    today = TimeHandler.get_date()
+    return (
+        datetime.combine(today, morning_time),
+        datetime.combine(today, evening_time),
+    )
+
+
+def _get_next_wakeup_time(morning_time: time, evening_time: time) -> datetime:
     now = TimeHandler.get_time()
-    start = now.replace(hour=5, minute=0, second=0, microsecond=0)
-    end = now.replace(hour=23, minute=0, second=0, microsecond=0)
-    if log_as_review:
-        end -= timedelta(minutes=2)
-    else:
-        start += timedelta(minutes=2)
+    next_morning_wakeup_time, next_evening_wakeup_time = _get_morning_and_evening_timestamp_of_today(
+        morning_time, evening_time
+    )
+    if now >= next_morning_wakeup_time:
+        next_morning_wakeup_time += timedelta(days=1)
+    if now >= next_evening_wakeup_time:
+        next_evening_wakeup_time += timedelta(days=1)
 
-    solar_output_today = sun_forecast_handler.get_solar_output_in_timeframe(start, end)
-    if log_as_review:
-        sun_forecast_handler.log.info(f"The actual solar output of today was {solar_output_today}")
+    if next_morning_wakeup_time - now < next_evening_wakeup_time - now:
+        return next_morning_wakeup_time
     else:
-        sun_forecast_handler.log.info(f"The expected solar output of today is {solar_output_today}")
+        return next_evening_wakeup_time
 
 
 def handle_stop_signal(signal_number: int, _frame: FrameType) -> None:
@@ -35,30 +64,22 @@ def handle_stop_signal(signal_number: int, _frame: FrameType) -> None:
         signal_number: The number representing the signal received.
         _frame: The current stack frame when the signal was received.
     """
-    logger = LoggerMixin()
     logger.log.info(f"Received {signal.Signals(signal_number).name}. Exiting now...")
     inverter_charge_controller.unlock()
-    exit(0)
+    sys.exit(0)
 
 
 for signal_to_catch in [signal.SIGINT, signal.SIGTERM]:
     signal.signal(signal_to_catch, handle_stop_signal)
 
 if __name__ == "__main__":
-    if len(sys.argv) > 1:
-        if sys.argv[1] == "--solar-forecast":
-            """
-            This allows you to simply log today's solar forecast and do nothing else.
-            This can also be used to log the solar prediction after the sun has set to see how far off the solar prediction
-            from before the sun has risen was. See below.
-            """
-            log_solar_forecast()
-            exit(0)
-        if sys.argv[1] == "--solar-review":
-            log_solar_forecast(log_as_review=True)
-            exit(0)
-
-        raise RuntimeError(f"Unknown argument {sys.argv[1]}!")
+    solar_forecast_logging_thread = threading.Thread(target=log_solar_forecast, daemon=True)
+    solar_forecast_logging_thread.start()
+    # Let the solar forecast calculate and log its next wakeup time before logging all the info of the
+    # InverterChargeController
+    pause.seconds(1)
 
     inverter_charge_controller = InverterChargeController()
-    inverter_charge_controller.start()
+    inverter_charge_controller_thread = threading.Thread(target=inverter_charge_controller.start)
+    inverter_charge_controller_thread.start()
+    inverter_charge_controller_thread.join()