Add device role as diagnostic entity

Author: jmattsson

custom_components/powersensor/PlugMeasurements.py

@@ -7,3 +7,4 @@ class PlugMeasurements(Enum):
     ACTIVE_CURRENT = 4
     REACTIVE_CURRENT = 5
     SUMMATION_ENERGY = 6
+    ROLE = 7

custom_components/powersensor/PowersensorEntity.py

@@ -6,7 +6,7 @@
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers import entity_registry as er
-from homeassistant.helpers.dispatcher import async_dispatcher_connect
+from homeassistant.helpers.dispatcher import async_dispatcher_connect, async_dispatcher_send
 from homeassistant.helpers.event import async_track_point_in_utc_time
 from homeassistant.util.dt import utcnow
 from .PlugMeasurements import PlugMeasurements
@@ -36,15 +36,15 @@ def __init__(self, hass: HomeAssistant, mac : str,
         self.measurement_type = measurement_type
         config = input_config[measurement_type]
         self._attr_unique_id = f"powersensor_{mac}_{measurement_type}"
-        self._attr_device_class = config["device_class"]
-        self._attr_native_unit_of_measurement = config["unit"]
+        self._attr_device_class = config.get("device_class", None)
+        self._attr_native_unit_of_measurement = config.get("unit", None)
         self._attr_device_info = self.device_info
-        self._attr_suggested_display_precision = config["precision"]
-        self._attr_entity_registry_visible_default = config['visible'] if 'visible' in config.keys() else True
+        self._attr_suggested_display_precision = config.get("precision", None)
+        self._attr_entity_registry_visible_default = config.get('visible', True)
+        self._attr_entity_category = config.get('category', None)
+        self._attr_state_class = config.get('state_class', None)
 
         self._signal = f"{POWER_SENSOR_UPDATE_SIGNAL}_{self._mac}_{config['event']}"
-        if 'state_class' in config.keys():
-            self._attr_state_class = config['state_class']
         self._message_key = config.get('message_key', None)
         self._message_callback = config.get('callback', None)
 
@@ -98,10 +98,11 @@ def _handle_update(self, event, message):
 
         name_updated = False
         self._has_recently_received_update_message = True
-        if not self.role:
-            if 'role' in message.keys():
-                self.role = message['role']
-                name_updated = self._rename_based_on_role()
+        role = message.get('role', None)
+        if role is not None and role != self.role:
+            self.role = role
+            name_updated = self._rename_based_on_role()
+            async_dispatcher_send(self._hass, f"{DOMAIN}_update_role", self._mac, role)
 
 
         if self._message_key in message.keys():

custom_components/powersensor/PowersensorMessageDispatcher.py

@@ -185,6 +185,8 @@ async def handle_message(self, event: str, message: dict):
                     _LOGGER.debug("Notifying integration that solar is present.")
                     async_dispatcher_send(self._hass, f"{DOMAIN}_solar_sensor_detected")
         async_dispatcher_send(self._hass, f"{POWER_SENSOR_UPDATE_SIGNAL}_{mac}_{event}", event, message)
+        if role is not None:
+            async_dispatcher_send(self._hass, f"{POWER_SENSOR_UPDATE_SIGNAL}_{mac}_role", 'role', { 'role': role })
 
     async def disconnect(self):
         for _ in range(len(self.plugs)):

custom_components/powersensor/PowersensorPlugEntity.py

@@ -1,7 +1,7 @@
 import logging
 
 from homeassistant.components.sensor import SensorDeviceClass, SensorStateClass
-from homeassistant.const import UnitOfPower, UnitOfElectricPotential, UnitOfElectricCurrent, UnitOfEnergy
+from homeassistant.const import EntityCategory, UnitOfPower, UnitOfElectricPotential, UnitOfElectricCurrent, UnitOfEnergy
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.device_registry import DeviceInfo
 
@@ -67,6 +67,12 @@
         'message_key': 'summation_joules',
         'callback' : lambda v : v/3600000.0
     },
+    PlugMeasurements.ROLE: {
+        'name': 'Device Role',
+        'category': EntityCategory.DIAGNOSTIC,
+        'event': 'role',
+        'message_key': 'role',
+    },
 }
 
 

custom_components/powersensor/PowersensorSensorEntity.py

@@ -1,5 +1,5 @@
 from homeassistant.components.sensor import SensorDeviceClass, SensorStateClass
-from homeassistant.const import UnitOfPower, UnitOfEnergy, PERCENTAGE
+from homeassistant.const import EntityCategory, UnitOfPower, UnitOfEnergy, PERCENTAGE
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.device_registry import DeviceInfo
 
@@ -39,7 +39,13 @@
         'event': 'summation_energy',
         'message_key': 'summation_joules',
         'callback': lambda v: v / 3600000.0
-    }
+    },
+    SensorMeasurements.ROLE: {
+        'name': 'Device Role',
+        'category': EntityCategory.DIAGNOSTIC,
+        'event': 'role',
+        'message_key': 'role',
+    },
 }
 
 class PowersensorSensorEntity(PowersensorEntity):

custom_components/powersensor/SensorMeasurements.py

@@ -5,3 +5,4 @@ class SensorMeasurements(Enum):
     Battery  =1
     WATTS = 2
     SUMMATION_ENERGY = 3
+    ROLE = 4

custom_components/powersensor/__init__.py

@@ -26,6 +26,7 @@
 #         mac =,
 #         host =,
 #         port =,
+#         role =,
 #     }
 #     with_solar =,
 #   }

custom_components/powersensor/sensor.py

@@ -1,6 +1,7 @@
 """Sensor platform for the integration."""
 from __future__ import annotations
 
+import copy
 import logging
 
 from homeassistant.config_entries import ConfigEntry
@@ -15,7 +16,7 @@
 from .PowersensorPlugEntity import PowersensorPlugEntity
 from .PowersensorSensorEntity import PowersensorSensorEntity
 from .SensorMeasurements import SensorMeasurements
-from .const import DOMAIN
+from .const import POWER_SENSOR_UPDATE_SIGNAL, DOMAIN
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -30,22 +31,60 @@ async def async_setup_entry(
 
 
     async def create_plug(plug_mac_address: str):
-        this_plug_sensors = [PowersensorPlugEntity(hass, plug_mac_address, PlugMeasurements.WATTS),
-                             PowersensorPlugEntity(hass, plug_mac_address, PlugMeasurements.VOLTAGE),
-                             PowersensorPlugEntity(hass, plug_mac_address, PlugMeasurements.APPARENT_CURRENT),
-                             PowersensorPlugEntity(hass, plug_mac_address, PlugMeasurements.ACTIVE_CURRENT),
-                             PowersensorPlugEntity(hass, plug_mac_address, PlugMeasurements.REACTIVE_CURRENT),
-                             PowersensorPlugEntity(hass, plug_mac_address, PlugMeasurements.SUMMATION_ENERGY)]
+        this_plug_sensors = [
+            PowersensorPlugEntity(hass, plug_mac_address, PlugMeasurements.WATTS),
+            PowersensorPlugEntity(hass, plug_mac_address, PlugMeasurements.VOLTAGE),
+            PowersensorPlugEntity(hass, plug_mac_address, PlugMeasurements.APPARENT_CURRENT),
+            PowersensorPlugEntity(hass, plug_mac_address, PlugMeasurements.ACTIVE_CURRENT),
+            PowersensorPlugEntity(hass, plug_mac_address, PlugMeasurements.REACTIVE_CURRENT),
+            PowersensorPlugEntity(hass, plug_mac_address, PlugMeasurements.SUMMATION_ENERGY),
+            PowersensorPlugEntity(hass, plug_mac_address, PlugMeasurements.ROLE),
+        ]
 
         async_add_entities(this_plug_sensors, True)
 
     for plug_mac in dispatcher.plugs.keys():
         await create_plug(plug_mac)
 
+
+    # Role update support
+    async def handle_role_update(mac_address: str, new_role: str):
+        persist_entry = False
+        new_data = copy.deepcopy({ **entry.data })
+
+        if new_role is not None:
+            devices = new_data['devices']
+            if mac_address in devices.keys():
+                info = devices[mac_address]
+                have_role = True if 'role' in info.keys() else False
+                old_role = info['role'] if have_role else None
+                if (not have_role) or (have_role and info['role'] != new_role):
+                    _LOGGER.debug(f"Updating role for {mac_address} from {old_role} to {new_role}")
+                    info['role'] = new_role
+                    persist_entry = True
+
+        if new_role == 'solar':
+            new_data['with_solar'] = True  # Remember for next time we start
+            persist_entry = True
+
+        if persist_entry:
+            hass.config_entries.async_update_entry(entry, data=new_data)
+
+    # These events are sent by the entities when their cached role updates
+    entry.async_on_unload(
+        async_dispatcher_connect(
+            hass, f"{DOMAIN}_update_role", handle_role_update
+        )
+    )
+
+
+    # Automatic plug discovery
     async def handle_discovered_plug(plug_mac_address: str, host: str, port: int, name: str):
         await create_plug(plug_mac_address)
         async_dispatcher_send(hass, f"{DOMAIN}_plug_added_to_homeassistant",
                               plug_mac_address, host, port, name)
+        async_dispatcher_send(hass, f"{DOMAIN}_update_role",
+                              plug_mac_address, "appliance") # default role
 
     entry.async_on_unload(
         async_dispatcher_connect(
@@ -54,19 +93,19 @@ async def handle_discovered_plug(plug_mac_address: str, host: str, port: int, na
     )
     await dispatcher.process_plug_queue()
 
-    async def handle_discovered_sensor(sensor_mac: str, sensor_role: str):
-        if sensor_role == 'solar':
-            new_data = { **entry.data }
-            new_data['with_solar'] = True  # Remember for next time we start
-            hass.config_entries.async_update_entry(entry, data=new_data)
 
+    # Automatic sensor discovery
+    async def handle_discovered_sensor(sensor_mac: str, sensor_role: str):
         new_sensors = [
             PowersensorSensorEntity(hass, sensor_mac, SensorMeasurements.Battery),
             PowersensorSensorEntity(hass, sensor_mac, SensorMeasurements.WATTS),
             PowersensorSensorEntity(hass, sensor_mac, SensorMeasurements.SUMMATION_ENERGY),
+            PowersensorSensorEntity(hass, sensor_mac, SensorMeasurements.ROLE),
         ]
         async_add_entities(new_sensors, True)
         async_dispatcher_send(hass, f"{DOMAIN}_sensor_added_to_homeassistant", sensor_mac, sensor_role)
+        # Trigger initial entity role update
+        async_dispatcher_send(hass, f"{POWER_SENSOR_UPDATE_SIGNAL}_{sensor_mac}_role", 'role', { 'role': sensor_role })
 
     entry.async_on_unload(
         async_dispatcher_connect(