Added in household view.

Some TODOs left.

Author: jmattsson

custom_components/powersensor/PowersensorHouseholdEntity.py

@@ -0,0 +1,111 @@
+from datetime import date, datetime
+from dataclasses import dataclass
+from enum import Enum
+from typing import Callable
+
+from homeassistant.components.sensor import SensorEntity, SensorDeviceClass, SensorStateClass
+from homeassistant.const import UnitOfPower, UnitOfEnergy
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.typing import StateType
+
+from powersensor_local import VirtualHousehold
+
+from .const import DOMAIN
+
+class HouseholdMeasurements(Enum):
+    POWER_HOME_USE = 1
+    POWER_FROM_GRID = 2
+    POWER_TO_GRID = 3
+    POWER_SOLAR_GENERATION = 4
+    ENERGY_HOME_USE = 5
+    ENERGY_FROM_GRID = 6
+    ENERGY_TO_GRID = 7
+    ENERGY_SOLAR_GENERATION = 8
+
+class UnitType(Enum):
+    WATT = UnitOfPower.WATT
+    KWH = UnitOfEnergy.KILO_WATT_HOUR
+
+@dataclass
+class EntityConfig:
+    name : str
+    device_class : SensorDeviceClass
+    state_class : SensorStateClass | None
+    unit : UnitType
+    formatter: Callable
+    precision: int
+    event: str
+
+FMT_INT = lambda f: int(f)
+FMT_WS_TO_KWH = lambda f: float(f)/3600000
+
+class PowersensorHouseholdEntity(SensorEntity):
+    """Powersensor Virtual Household entity"""
+
+    should_poll = False
+    _attr_has_entity_name = True
+    _attr_available = True
+
+    _ENTITY_CONFIGS  = {
+        HouseholdMeasurements.POWER_HOME_USE : EntityConfig(
+            "Power - Home use", SensorDeviceClass.POWER, None, UnitType.WATT, FMT_INT, 0, "home_usage"),
+        HouseholdMeasurements.POWER_FROM_GRID : EntityConfig(
+            "Power - From grid", SensorDeviceClass.POWER, None, UnitType.WATT, FMT_INT, 0, "from_grid"),
+        HouseholdMeasurements.POWER_TO_GRID : EntityConfig(
+            "Power - To grid", SensorDeviceClass.POWER, None, UnitType.WATT, FMT_INT, 0, "to_grid"),
+        HouseholdMeasurements.POWER_SOLAR_GENERATION : EntityConfig(
+            "Power - Solar generation", SensorDeviceClass.POWER, None, UnitType.WATT, FMT_INT, 0, "solar_generation"),
+
+        HouseholdMeasurements.ENERGY_HOME_USE : EntityConfig(
+            "Energy - Home usage", SensorDeviceClass.ENERGY, SensorStateClass.TOTAL, UnitType.KWH, FMT_WS_TO_KWH, 3, "home_usage_summation"),
+        HouseholdMeasurements.ENERGY_FROM_GRID : EntityConfig(
+            "Energy - From grid", SensorDeviceClass.ENERGY, SensorStateClass.TOTAL, UnitType.KWH, FMT_WS_TO_KWH, 3, "from_grid_summation"),
+        HouseholdMeasurements.ENERGY_TO_GRID : EntityConfig(
+            "Energy - To grid", SensorDeviceClass.ENERGY, SensorStateClass.TOTAL, UnitType.KWH, FMT_WS_TO_KWH, 3, "to_grid_summation"),
+        HouseholdMeasurements.ENERGY_SOLAR_GENERATION : EntityConfig(
+            "Energy - Solar generation", SensorDeviceClass.ENERGY, SensorStateClass.TOTAL, UnitType.KWH, FMT_WS_TO_KWH, 3, "solar_generation_summation"),
+    }
+
+    def __init__(self, vhh: VirtualHousehold, measurement_type: HouseholdMeasurements):
+        """Initialize the entity."""
+        self._vhh = vhh
+        self._config = self._ENTITY_CONFIGS[measurement_type]
+
+        self._attr_name = self._config.name
+        self._attr_unique_id = f"{DOMAIN}_vhh_{self._config.event}"
+        self._attr_device_class = self._config.device_class
+        self._attr_state_class = self._config.state_class
+        self._attr_native_unit_of_measurement = self._config.unit
+        self._attr_suggested_display_precision = self._config.precision
+
+    @property
+    def device_info(self) -> DeviceInfo:
+        return {
+            'identifiers': {(DOMAIN, "vhh")},
+            'manufacturer': "Powersensor",
+            'model': "Virtual",
+            'name': "Powersensor Household View",
+        }
+
+    async def async_added_to_hass(self):
+        self._vhh.subscribe(self._config.event, self._on_event)
+
+    async def async_will_remove_from_hass(self):
+        self._vhh.unsubscribe(self._config.event, self._on_event)
+
+    async def _on_event(self, _, msg):
+        val = None
+        if self._config.unit == UnitType.WATT:
+            key = "watts"
+            if key in msg:
+                val = msg[key]
+        elif self._config.unit == UnitType.KWH:
+            key = "summation_joules"
+            if key in msg:
+                val = msg[key]
+            key = "summation_resettime_utc"
+            if key in msg:
+                self._attr_last_reset = datetime.fromtimestamp(msg[key])
+        if val is not None:
+            self._attr_native_value = self._config.formatter(val)
+            self.async_write_ha_state()

custom_components/powersensor/coordinator.py

@@ -8,8 +8,7 @@
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
-from powersensor_local import PlugApi
-
+from powersensor_local import PlugApi, VirtualHousehold
 
 from .const import DEFAULT_SCAN_INTERVAL, DOMAIN
 
@@ -84,6 +83,7 @@ def __init__(
                 PlugMeasurements.SUMMATION_ENERGY: 0.0,
             }
 
+        self._vhh = VirtualHousehold(True) # FIXME needs to track whether we have seen solar or not
 
     async def stop(self):
         """stop listening to plug"""
@@ -104,6 +104,12 @@ async def _async_update_data(self):
         return self.plug_data
 
     async def handle_message(self, event, message):
+        # Drive household calculation
+        if event == "average_power":
+            await self._vhh.process_average_power_event(message)
+        elif event == "summation_energy":
+            await self._vhh.process_summation_event(message)
+
         mac = message['mac']
         if mac in self.plug_data.keys():
             # handle plugs
@@ -141,6 +147,7 @@ async def handle_message(self, event, message):
 
     async def handle_device_discovery(self, message):
         if message['mac'] not in self.sensor_data.keys():
+            # TODO this should really check the device_type in the message
             self.sensor_data[message['mac']] = dict({
                 SensorMeasurements.Battery : 0.0
             })

custom_components/powersensor/sensor.py

@@ -7,6 +7,7 @@
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 
+from .PowersensorHouseholdEntity import HouseholdMeasurements, PowersensorHouseholdEntity
 from .PowersensorPlugEntity import PowersensorPlugEntity
 from .const import DOMAIN
 from .coordinator import PlugMeasurements
@@ -32,6 +33,17 @@ async def async_setup_entry(
                     PowersensorPlugEntity(hass, plug_update_coordinator, plug, PlugMeasurements.SUMMATION_ENERGY)])
 
     async_add_entities(plug_sensors, True)
+
+    # Register household entities
+    vhh = plug_update_coordinator._vhh # TODO tidy up
+    household_entities = []
+    for measurement_type in HouseholdMeasurements:
+        # TODO: only include to_grid/solar if have solar?
+        # Should we dynamically register the household only in response to
+        # getting role:house-net and role:solar messages, maybe?
+        household_entities.append(PowersensorHouseholdEntity(vhh, measurement_type))
+    async_add_entities(household_entities)
+
     plug_update_coordinator.async_add_sensor_entities  = async_add_entities