186 files

custom_components/versatile_thermostat/feature_power_manager.py

@@ -9,6 +9,7 @@ from homeassistant.const import (
     STATE_OFF,
     STATE_UNAVAILABLE,
     STATE_UNKNOWN,
+    UnitOfEnergy,
 )
 
 from homeassistant.core import (
@@ -43,6 +44,7 @@ class FeaturePowerManager(BaseFeatureManager):
         self._overpowering_state: str | None = None
         self._is_configured: bool = False
         self._device_power: float = 0
+        self._power_unit: str = POWER_UNIT_WATT
         self._use_power_feature: bool = False
 
     @overrides
@@ -52,7 +54,19 @@ class FeaturePowerManager(BaseFeatureManager):
         # Power management
         self._power_temp = entry_infos.get(CONF_PRESET_POWER)
 
-        self._device_power = entry_infos.get(CONF_DEVICE_POWER) or 0
+        configured_power_unit = to_internal_power_unit(entry_infos.get(CONF_POWER_UNIT))
+        if configured_power_unit not in (POWER_UNIT_WATT, POWER_UNIT_KILO_WATT):
+            _LOGGER.warning(
+                "%s - Unsupported power unit %s. Falling back to W",
+                self,
+                entry_infos.get(CONF_POWER_UNIT),
+            )
+            self._power_unit = POWER_UNIT_WATT
+        else:
+            self._power_unit = configured_power_unit
+        # Normalize device_power to internal Watts based on configured unit
+        raw_device_power = entry_infos.get(CONF_DEVICE_POWER)
+        self._device_power = (power_to_watts(raw_device_power, self._power_unit) or 0.0) if raw_device_power else 0.0
         self._use_power_feature = entry_infos.get(CONF_USE_POWER_FEATURE, False)
         self._is_configured = False
 
@@ -92,26 +106,35 @@ class FeaturePowerManager(BaseFeatureManager):
             }
         )
         if self._is_configured:
+            central = vtherm_api.central_power_manager
+            power_unit = self.power_unit
+            central_power_unit = central.power_unit
             extra_state_attributes.update(
                 {
                     "power_manager": {
-                        "power_sensor_entity_id": vtherm_api.central_power_manager.power_sensor_entity_id,
-                        "max_power_sensor_entity_id": vtherm_api.central_power_manager.max_power_sensor_entity_id,
+                        "power_sensor_entity_id": central.power_sensor_entity_id,
+                        "max_power_sensor_entity_id": central.max_power_sensor_entity_id,
                         "overpowering_state": self.overpowering_state,
-                        "device_power": self._device_power,
+                        "device_power": self.from_watts(self._device_power, power_unit),
                         "power_temp": self._power_temp,
-                        "current_power": vtherm_api.central_power_manager.current_power,
-                        "current_max_power": vtherm_api.central_power_manager.current_max_power,
-                        "mean_cycle_power": self.mean_cycle_power,
+                        "current_power": central.from_watts(central.current_power, central_power_unit),
+                        "current_max_power": central.from_watts(central.current_max_power, central_power_unit),
+                        "mean_cycle_power": self.from_watts(self.mean_cycle_power, power_unit),
+                        "power_unit": power_unit,
+                        "energy_unit": self.energy_unit,
+                        "central_power_unit": central_power_unit,
                     }
                 }
             )
         else:
+            power_unit = self.power_unit
             extra_state_attributes.update(
                 {
                     "power_manager": {
-                        "device_power": self._device_power,
-                        "mean_cycle_power": self.mean_cycle_power,
+                        "device_power": self.from_watts(self._device_power, power_unit),
+                        "mean_cycle_power": self.from_watts(self.mean_cycle_power, power_unit),
+                        "power_unit": power_unit,
+                        "energy_unit": self.energy_unit,
                     }
                 }
             )
@@ -135,9 +158,7 @@ class FeaturePowerManager(BaseFeatureManager):
         current_power = vtherm_api.central_power_manager.current_power
         current_max_power = vtherm_api.central_power_manager.current_max_power
         started_vtherm_total_power = vtherm_api.central_power_manager.started_vtherm_total_power
-        current_started_power = vtherm_api.central_power_manager.get_started_vtherm_power(
-            effective_reservation_key
-        )
+        current_started_power = vtherm_api.central_power_manager.get_started_vtherm_power(effective_reservation_key)
         if (
             current_power is None
             or current_max_power is None
@@ -334,9 +355,20 @@ class FeaturePowerManager(BaseFeatureManager):
 
     @property
     def device_power(self) -> float:
-        """Return the device power"""
+        """Return the device power (normalized in Watts)"""
+
         return self._device_power
 
+    @property
+    def power_unit(self) -> str:
+        """Return the configured power unit of the VTherm ("W" or "kW")"""
+        return to_legal_power_unit(self._power_unit)
+
+    @property
+    def energy_unit(self) -> str:
+        """Return the energy unit matching the configured power unit"""
+        return UnitOfEnergy.WATT_HOUR if self._power_unit == POWER_UNIT_WATT else UnitOfEnergy.KILO_WATT_HOUR
+
     @property
     def mean_cycle_power(self) -> float | None:
         """Returns the mean power consumption during the cycle"""
@@ -359,5 +391,13 @@ class FeaturePowerManager(BaseFeatureManager):
         """Return a stable fallback key for temporary power reservations."""
         return getattr(self._vtherm, "entity_id", None) or self._vtherm.name
 
+    def to_watts(self, power: float | None, unit: str | None) -> float | None:
+        """Convert a power value to Watts"""
+        return power_to_watts(power, unit)
+
+    def from_watts(self, power_w: float | None, target_unit: str | None) -> float | None:
+        """Convert a Watts value to the target power unit"""
+        return power_from_watts(power_w, target_unit)
+
     def __str__(self):
         return f"PowerManager-{self.name}"