fix ...

Author: ckvsoft

core/conditions.py

@@ -215,7 +215,9 @@ def add_additional_discharging_conditions(self):
     def add_abort_conditions(self):
 
         required_capacity = self._calculate_required_capacity_for_period()
-        available_soc_wh, _, min_soc_wh = self._calculate_current_soc_wh()
+        available_soc_wh = self.essunit.get_battery_current_wh()
+        min_soc_wh = self.essunit.get_battery_min_wh()
+
         available_soc_wh -= min_soc_wh
         additional_prices = self.items.get_lowest_prices(self.config.number_of_lowest_prices_for_charging)
 
@@ -327,43 +329,9 @@ def _calculate_required_capacity(self, upcoming_hours):
         self.logger.log.debug(f"Required capacity: {required_capacity:.2f} Wh")
         return required_capacity
 
-    def _calculate_current_soc_wh(self):
-        try:
-            # Check if the relevant data is present and valid
-            if self.solardata.soc is None or self.solardata.soc < 0:
-                raise ValueError("SOC value is missing or invalid.")
-            if self.solardata.battery_capacity is None or self.solardata.battery_capacity <= 0:
-                raise ValueError("Battery capacity is missing or invalid.")
-            if self.solardata.battery_minimum_soc_limit is None or self.solardata.battery_minimum_soc_limit < 0:
-                raise ValueError("Minimum SOC limit is missing or invalid.")
-
-            efficiency = self.config.converter_efficiency[0]
-
-            # Calculate the full capacity
-            full_capacity = (
-                                    self.solardata.battery_capacity / self.solardata.soc) * 100 * efficiency if self.solardata.soc > 0 else 0.0
-            battery_capacity_wh = full_capacity * 54.20 * efficiency # Battery capacity in Wh
-
-            # Calculate the current SOC in Wh
-            current_soc_wh = ((self.solardata.soc or 0) / 100) * battery_capacity_wh
-
-            # Calculate the minimum SOC in Wh (including the minimum SOC limit)
-            min_soc_wh = (self.solardata.battery_minimum_soc_limit / 100) * battery_capacity_wh
-
-            return current_soc_wh, battery_capacity_wh, min_soc_wh
-
-        except ZeroDivisionError:
-            # Error handling for division by zero when SOC is 0
-            self.logger.log.error("Division by zero during the calculation of full capacity.")
-            return 0.0, 0.0, 0.0
-
-        except ValueError as e:
-            # Error handling for invalid or missing inputs
-            self.logger.log.error(f"Error during SOC calculation: {str(e)}")
-            return 0.0, 0.0, 0.0
-
     def _calculate_available_surplus(self, upcoming_high_prices):
-        current_soc_wh, akkukapazitaet_wh, min_soc_wh = self._calculate_current_soc_wh()
+        current_soc_wh = self.essunit.get_battery_current_wh()
+        min_soc_wh = self.essunit.get_battery_min_wh()
 
         required_capacity = self._calculate_required_capacity(len(upcoming_high_prices))
 
@@ -497,7 +465,7 @@ def _calculate_required_capacity_for_period(self):
 
         self.logger.log.info(f"Required capacity for period: {required_capacity:.2f} Wh {remaining_description} "
                              f"/ current SOC {self.solardata.soc}% "
-                             f"({self._calculate_current_soc_wh()[0]:.2f} Wh)")
+                             f"({self.essunit.get_battery_current_wh():.2f} Wh)")
 
         return required_capacity
 
@@ -530,8 +498,9 @@ def _check_for_cheaper_hours(self, additional_prices):
         current_hour_start = now.replace(minute=0, second=0, microsecond=0)
 
         current_soc = self.essunit.get_soc()
-        if current_soc > 99.0:
-            self.logger.log.debug(f"SoC is {current_soc:.2f}%, charging is unnecessary.")
+        scheduler_soc = self.essunit.get_scheduler_soc()
+        if current_soc >= scheduler_soc:
+            self.logger.log.debug(f"SoC is {current_soc:.2f}%, Sheduler Soc is {scheduler_soc}, charging is unnecessary.")
             return True
 
         #        additional_prices = [

core/mqttclient.py

@@ -346,7 +346,7 @@ def subscribe_multiple(self, subscribers_instance, query_topics):
                 self.logger.log.error("Failed to connect to the MQTT broker.")
                 return 1
 
-            self.client.loop_start()
+            # self.client.loop_start()
 
             # Abonnements für die angegebenen Themen einrichten
             for query_topic in query_topics:
@@ -390,7 +390,7 @@ def subscribe_multiple(self, subscribers_instance, query_topics):
             self.logger.log.debug("Finish subcribe ...")
             # Ressourcen freigeben
             self.client.unsubscribe("#")
-            self.client.loop_stop()
+            # self.client.loop_stop()
             # self.disconnect()
 
         return result
@@ -408,7 +408,7 @@ def subscribe(self, mqtt_result, query_topic):
             if not self.connect():
                 return 1
 
-            self.client.loop_start()
+            # self.client.loop_start()
 
             start_time = time.time()
             while not self.flag_connected:
@@ -443,7 +443,7 @@ def subscribe(self, mqtt_result, query_topic):
         finally:
             self.logger.log.debug("Finish subcribe ...")
             self.client.unsubscribe("#")
-            self.client.loop_stop()
+            # self.client.loop_stop()
             # self.disconnect()
 
         return result
@@ -459,7 +459,7 @@ def publish(self, query_topic, query_message):
             if not self.connect():
                 return 1
 
-            self.client.loop_start()
+            # self.client.loop_start()
 
             start_time = time.time()
 
@@ -482,7 +482,7 @@ def publish(self, query_topic, query_message):
 
         finally:
             self.logger.log.debug("Finish subcribe ...")
-            self.client.loop_stop()
+            # self.client.loop_stop()
             # self.disconnect()
 
         return result
@@ -492,6 +492,7 @@ def connect(self):
             self.logger.log.debug(f"connect to: {self.mqtt_broker}:{self.mqtt_port}")
             if self.client.is_connected(): return True
             self.client.connect(self.mqtt_broker, self.mqtt_port, 60)
+            self.client.loop_start()
             return True
         except ConnectionRefusedError:
             self.logger.log.error(
@@ -503,4 +504,5 @@ def connect(self):
 
     def disconnect(self):
         if self.client:
-            self.client.disconnect()
+            self.client.loop_stop()
+            self.client.disconnect()

essunit/abstract_classes/essunit.py

@@ -57,6 +57,12 @@ def get_battery_current_voltage(self):
     def get_battery_current_wh(self):
         pass
 
+    def get_battery_full_wh(self):
+        pass
+
+    def get_battery_min_wh(self):
+        pass
+
     def get_battery_minimum_soc_limit(self):
         pass
 

essunit/victron.py

@@ -104,13 +104,25 @@ def get_battery_current_voltage(self):
             return currentvoltage
 
     def get_battery_current_wh(self):
-        soc = self.get_soc()
+        soc = self.get_soc() or 0
         full_capacity = (self.get_battery_capacity() / soc) * 100 if soc > 0 else 0.0
         battery_capacity_wh = full_capacity * 55.20
         battery_current_wh = ((soc or 0) / 100) * battery_capacity_wh
         self.logger.log.debug(f"{self._name} Batterie Current wh: {battery_current_wh}Wh")
         return battery_current_wh
 
+    def get_battery_full_wh(self):
+        soc = self.get_soc() or 0
+        full_capacity = (self.get_battery_capacity() / soc) * 100 if soc > 0 else 0.0
+        battery_capacity_wh = full_capacity * 55.20
+        self.logger.log.debug(f"{self._name} Batterie Full wh: {battery_capacity_wh}Wh")
+        return battery_capacity_wh
+
+    def get_battery_min_wh(self):
+        min_soc_limit = self.get_battery_minimum_soc_limit() or 0
+        battery_capacity_wh = self.get_battery_full_wh()
+        return min_soc_limit / 100 * battery_capacity_wh
+
     def get_battery_minimum_soc_limit(self):
         minimumsoclimit = self._process_result(self.subsribers.get('Battery', 'MinimumSocLimit'))
         self.logger.log.debug(f"{self._name} Batterie MinimumSocLimit: {minimumsoclimit}%")
@@ -128,12 +140,12 @@ def get_battery_installed_capacity(self):
 
     def get_soc(self):
         soc = self._process_result(self.subsribers.get('Battery', 'Soc'))
-        self.logger.log.info(f"{self._name} SOC: {soc}%")
+        self.logger.log.debug(f"{self._name} SOC: {soc}%")
         return soc
 
     def get_active_soc_limit(self):
         soc = self._process_result(self.subsribers.get('Control', 'ActiveSocLimit'))
-        self.logger.log.info(f"{self._name} ActiveSocLimit: {soc}%")
+        self.logger.log.debug(f"{self._name} ActiveSocLimit: {soc}%")
         return soc
 
     def get_scheduler_soc(self):
@@ -190,19 +202,15 @@ def get_version(self):
         version = self._process_result(self.subsribers.get('Firmware', 'Version'))
         return version
 
-    def _gridmeters(self):
-        with MqttClient(
-                self.mqtt_config) as mqtt:  # Hier wird die Verbindung hergestellt und im Anschluss automatisch geschlossen
-            base_topic = f'N/{self.unit_id}/grid'
-            discovery_topic = f"{base_topic}/#"
-            mqtt.subscribe(self.gridmeters, discovery_topic)
+    def _gridmeters(self, mqtt):
+        base_topic = f'N/{self.unit_id}/grid'
+        discovery_topic = f"{base_topic}/#"
+        mqtt.subscribe(self.gridmeters, discovery_topic)
 
-    def _inverters(self):
-        with MqttClient(
-                self.mqtt_config) as mqtt:  # Hier wird die Verbindung hergestellt und im Anschluss automatisch geschlossen
-            base_topic = f'N/{self.unit_id}/pvinverter'
-            discovery_topic = f"{base_topic}/#"
-            mqtt.subscribe(self.inverters, discovery_topic)
+    def _inverters(self, mqtt):
+        base_topic = f'N/{self.unit_id}/pvinverter'
+        discovery_topic = f"{base_topic}/#"
+        mqtt.subscribe(self.inverters, discovery_topic)
 
     def _get_battery_instance(self, mqtt):
         try:
@@ -269,10 +277,16 @@ def _get_vrm_broker_url(self):
         return "mqtt{}.victronenergy.com".format(broker_index)
 
     def _get_data(self):
-        self._inverters()
-        self._gridmeters()
         with MqttClient(
-                self.mqtt_config) as mqtt:  # Hier wird die Verbindung hergestellt und im Anschluss automatisch geschlossen
+                self.mqtt_config) as mqtt:
+            self._gridmeters(mqtt)
+        with MqttClient(
+                self.mqtt_config) as mqtt:
+            self._inverters(mqtt)
+
+        with MqttClient(
+                self.mqtt_config) as mqtt:
+
             instance = self._get_battery_instance(mqtt)
             topics_to_subscribe = [
                 f"Schedule:N/{self.unit_id}/settings/0/Settings/CGwacs/BatteryLife/Schedule/Charge/0/Day",

powerconsumption/powerconsumptionmqtt.py

@@ -58,7 +58,7 @@ def update_config(self, mqtt_config=None):
         self.data_topics = mqtt_config.get("topics")
 
         # Initialize the new MQTT client
-        self.client = mqtt.Client(client_id=f"seuss-power-consumption-{Utils.generate_random_hex(8)}", protocol=mqtt.MQTTv5)
+        self.client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id=f"seuss-power-consumption-{Utils.generate_random_hex(8)}", protocol=mqtt.MQTTv5)
         self.client.on_message = self.on_message
         self.client.on_disconnect = self.on_disconnect
         if port == 8883:

spotmarket/abstract_classes/item.py

@@ -41,7 +41,7 @@ def __init__(self, starttime, endtime, price, fee_str, potency=14):
         self.logger = CustomLogger()
 
     def is_expired(self, check_time=False):
-        now = datetime.utcnow().replace(tzinfo=timezone.utc)
+        now = datetime.now(timezone.utc)
         now_local = TimeUtilities.convert_utc_to_local(now, False)
         item_local = TimeUtilities.convert_utc_to_local(self.starttime, False)
 

spotmarket/abstract_classes/itemlist.py

@@ -171,7 +171,7 @@ def get_price_hour_lists(item_list):
         return today_data, list(today_data.keys()), tomorrow_data, list(tomorrow_data.keys())
 
     def get_current_price(self, convert=False):
-        now = datetime.utcnow().replace(tzinfo=timezone.utc)
+        now = datetime.now(timezone.utc)
 
         for item in self._item_list:
             start_datetime = item.get_start_datetime().replace(tzinfo=timezone.utc)