Merge pull request #218 from plugwise/neg-energy-4

Add support for devices with production enabled - try 4

Author: bouwew

plugwise_usb/api.py

@@ -216,14 +216,10 @@ class EnergyStatistics:
     hour_consumption_reset: datetime | None = None
     day_consumption: float | None = None
     day_consumption_reset: datetime | None = None
-    week_consumption: float | None = None
-    week_consumption_reset: datetime | None = None
     hour_production: float | None = None
     hour_production_reset: datetime | None = None
     day_production: float | None = None
     day_production_reset: datetime | None = None
-    week_production: float | None = None
-    week_production_reset: datetime | None = None
 
 
 class PlugwiseNode(Protocol):

plugwise_usb/nodes/circle.py

@@ -440,27 +440,25 @@ async def get_missing_energy_logs(self) -> None:
         self._energy_counters.update()
         if self._current_log_address is None:
             return None
+
         if self._energy_counters.log_addresses_missing is None:
             _LOGGER.debug(
                 "Start with initial energy request for the last 10 log addresses for node %s.",
                 self._mac_in_str,
             )
             total_addresses = 11
             log_address = self._current_log_address
-            log_update_tasks = []
             while total_addresses > 0:
-                log_update_tasks.append(self.energy_log_update(log_address))
+                await self.energy_log_update(log_address)
                 log_address, _ = calc_log_address(log_address, 1, -4)
                 total_addresses -= 1
 
-            for task in log_update_tasks:
-                await task
-
             if self._cache_enabled:
                 await self._energy_log_records_save_to_cache()
+
             return
-        if self._energy_counters.log_addresses_missing is not None:
-            _LOGGER.debug("Task created to get missing logs of %s", self._mac_in_str)
+
+        _LOGGER.debug("Task created to get missing logs of %s", self._mac_in_str)
         if (
             missing_addresses := self._energy_counters.log_addresses_missing
         ) is not None:
@@ -472,8 +470,12 @@ async def get_missing_energy_logs(self) -> None:
             )
 
             missing_addresses = sorted(missing_addresses, reverse=True)
-            for address in missing_addresses:
-                await self.energy_log_update(address)
+            tasks = [
+                create_task(self.energy_log_update(address))
+                for address in missing_addresses
+            ]
+            for task in tasks:
+                await task
 
         if self._cache_enabled:
             await self._energy_log_records_save_to_cache()
@@ -496,6 +498,7 @@ async def energy_log_update(self, address: int | None) -> bool:
             )
             return False
 
+        _LOGGER.debug("EnergyLogs data from %s, address=%s", self._mac_in_str, address)
         await self._available_update_state(True, response.timestamp)
         energy_record_update = False
 
@@ -504,7 +507,12 @@ async def energy_log_update(self, address: int | None) -> bool:
         # energy pulses collected during the previous hour of given timestamp
         for _slot in range(4, 0, -1):
             log_timestamp, log_pulses = response.log_data[_slot]
-
+            _LOGGER.debug(
+                "In slot=%s: pulses=%s, timestamp=%s",
+                _slot,
+                log_pulses,
+                log_timestamp
+            )
             if log_timestamp is None or log_pulses is None:
                 self._energy_counters.add_empty_log(response.log_address, _slot)
             elif await self._energy_log_record_update_state(
@@ -515,9 +523,11 @@ async def energy_log_update(self, address: int | None) -> bool:
                 import_only=True,
             ):
                 energy_record_update = True
+
         self._energy_counters.update()
         if energy_record_update:
             await self.save_cache()
+
         return True
 
     async def _energy_log_records_load_from_cache(self) -> bool:

plugwise_usb/nodes/helpers/counter.py

@@ -21,17 +21,13 @@ class EnergyType(Enum):
     PRODUCTION_HOUR = auto()
     CONSUMPTION_DAY = auto()
     PRODUCTION_DAY = auto()
-    CONSUMPTION_WEEK = auto()
-    PRODUCTION_WEEK = auto()
 
 
 ENERGY_COUNTERS: Final = (
     EnergyType.CONSUMPTION_HOUR,
     EnergyType.PRODUCTION_HOUR,
     EnergyType.CONSUMPTION_DAY,
     EnergyType.PRODUCTION_DAY,
-    EnergyType.CONSUMPTION_WEEK,
-    EnergyType.PRODUCTION_WEEK,
 )
 ENERGY_HOUR_COUNTERS: Final = (
     EnergyType.CONSUMPTION_HOUR,
@@ -41,20 +37,13 @@ class EnergyType(Enum):
     EnergyType.CONSUMPTION_DAY,
     EnergyType.PRODUCTION_DAY,
 )
-ENERGY_WEEK_COUNTERS: Final = (
-    EnergyType.CONSUMPTION_WEEK,
-    EnergyType.PRODUCTION_WEEK,
-)
-
 ENERGY_CONSUMPTION_COUNTERS: Final = (
     EnergyType.CONSUMPTION_HOUR,
     EnergyType.CONSUMPTION_DAY,
-    EnergyType.CONSUMPTION_WEEK,
 )
 ENERGY_PRODUCTION_COUNTERS: Final = (
     EnergyType.PRODUCTION_HOUR,
     EnergyType.PRODUCTION_DAY,
-    EnergyType.PRODUCTION_WEEK,
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -105,11 +94,8 @@ def add_pulse_stats(
         self, pulses_consumed: int, pulses_produced: int, timestamp: datetime
     ) -> None:
         """Add pulse statistics."""
-        _LOGGER.debug(
-            "add_pulse_stats | consumed=%s, for %s",
-            str(pulses_consumed),
-            self._mac,
-        )
+        _LOGGER.debug("add_pulse_stats for %s with timestamp=%s", self._mac, timestamp)
+        _LOGGER.debug("consumed=%s | produced=%s", pulses_consumed, pulses_produced)
         self._pulse_collection.update_pulse_counter(
             pulses_consumed, pulses_produced, timestamp
         )
@@ -160,9 +146,6 @@ def update(self) -> None:
         self._energy_statistics.log_interval_consumption = (
             self._pulse_collection.log_interval_consumption
         )
-        self._energy_statistics.log_interval_production = (
-            self._pulse_collection.log_interval_production
-        )
         (
             self._energy_statistics.hour_consumption,
             self._energy_statistics.hour_consumption_reset,
@@ -171,23 +154,18 @@ def update(self) -> None:
             self._energy_statistics.day_consumption,
             self._energy_statistics.day_consumption_reset,
         ) = self._counters[EnergyType.CONSUMPTION_DAY].update(self._pulse_collection)
-        (
-            self._energy_statistics.week_consumption,
-            self._energy_statistics.week_consumption_reset,
-        ) = self._counters[EnergyType.CONSUMPTION_WEEK].update(self._pulse_collection)
-
-        (
-            self._energy_statistics.hour_production,
-            self._energy_statistics.hour_production_reset,
-        ) = self._counters[EnergyType.PRODUCTION_HOUR].update(self._pulse_collection)
-        (
-            self._energy_statistics.day_production,
-            self._energy_statistics.day_production_reset,
-        ) = self._counters[EnergyType.PRODUCTION_DAY].update(self._pulse_collection)
-        (
-            self._energy_statistics.week_production,
-            self._energy_statistics.week_production_reset,
-        ) = self._counters[EnergyType.PRODUCTION_WEEK].update(self._pulse_collection)
+        if self._pulse_collection.production_logging:
+            self._energy_statistics.log_interval_production = (
+                self._pulse_collection.log_interval_production
+            )
+            (
+                self._energy_statistics.hour_production,
+                self._energy_statistics.hour_production_reset,
+            ) = self._counters[EnergyType.PRODUCTION_HOUR].update(self._pulse_collection)
+            (
+                self._energy_statistics.day_production,
+                self._energy_statistics.day_production_reset,
+            ) = self._counters[EnergyType.PRODUCTION_DAY].update(self._pulse_collection)
 
     @property
     def timestamp(self) -> datetime | None:
@@ -211,14 +189,13 @@ def __init__(
     ) -> None:
         """Initialize energy counter based on energy id."""
         self._mac = mac
+        self._midnight_reset_passed = False
         if energy_id not in ENERGY_COUNTERS:
             raise EnergyError(f"Invalid energy id '{energy_id}' for Energy counter")
         self._calibration: EnergyCalibration | None = None
         self._duration = "hour"
         if energy_id in ENERGY_DAY_COUNTERS:
             self._duration = "day"
-        elif energy_id in ENERGY_WEEK_COUNTERS:
-            self._duration = "week"
         self._energy_id: EnergyType = energy_id
         self._is_consumption = True
         self._direction = "consumption"
@@ -259,9 +236,16 @@ def energy(self) -> float | None:
         """Total energy (in kWh) since last reset."""
         if self._pulses is None or self._calibration is None:
             return None
+
         if self._pulses == 0:
             return 0.0
-        pulses_per_s = self._pulses / float(HOUR_IN_SECONDS)
+
+        # Handle both positive and negative pulses values
+        negative = False
+        if self._pulses < 0:
+            negative = True
+
+        pulses_per_s = abs(self._pulses) / float(HOUR_IN_SECONDS)
         corrected_pulses = HOUR_IN_SECONDS * (
             (
                 (
@@ -276,8 +260,9 @@ def energy(self) -> float | None:
             + self._calibration.off_tot
         )
         calc_value = corrected_pulses / PULSES_PER_KW_SECOND / HOUR_IN_SECONDS
-        # Guard for minor negative miscalculations
-        calc_value = max(calc_value, 0.0)
+        if negative:
+            calc_value = -calc_value
+
         return calc_value
 
     @property
@@ -297,16 +282,21 @@ def update(
         last_reset = datetime.now(tz=LOCAL_TIMEZONE)
         if self._energy_id in ENERGY_HOUR_COUNTERS:
             last_reset = last_reset.replace(minute=0, second=0, microsecond=0)
-        elif self._energy_id in ENERGY_DAY_COUNTERS:
-            last_reset = last_reset.replace(hour=0, minute=0, second=0, microsecond=0)
-        elif self._energy_id in ENERGY_WEEK_COUNTERS:
-            last_reset = last_reset - timedelta(days=last_reset.weekday())
-            last_reset = last_reset.replace(
-                hour=0,
-                minute=0,
-                second=0,
-                microsecond=0,
-            )
+        if self._energy_id in ENERGY_DAY_COUNTERS:
+            # Postpone the last_reset time-changes at day-end until a device pulsecounter resets
+            if last_reset.hour == 0 and (
+                not pulse_collection.pulse_counter_reset
+                and not self._midnight_reset_passed
+            ):
+                last_reset = (last_reset - timedelta(days=1)).replace(
+                    hour=0, minute=0, second=0, microsecond=0
+                )
+            else:
+                if last_reset.hour == 0 and pulse_collection.pulse_counter_reset:
+                    self._midnight_reset_passed = True
+                if last_reset.hour == 1 and self._midnight_reset_passed:
+                    self._midnight_reset_passed = False
+                last_reset = last_reset.replace(hour=0, minute=0, second=0, microsecond=0)
 
         pulses, last_update = pulse_collection.collected_pulses(
             last_reset, self._is_consumption
@@ -324,5 +314,6 @@ def update(
         self._pulses = pulses
 
         energy = self.energy
-        _LOGGER.debug("energy=%s or last_update=%s", energy, last_update)
+        _LOGGER.debug("energy=%s on last_update=%s", energy, last_update)
         return (energy, last_reset)
+