Add binary_sensors and cooling to water_heater

Author: bouwew

custom_components/plugwise-beta/__init__.py

@@ -19,7 +19,7 @@
 
 _LOGGER = logging.getLogger(__name__)
 
-PLATFORMS = ["climate", "sensor", "switch", "water_heater"]
+PLATFORMS = ["binart_sensor", "climate", "sensor", "switch", "water_heater"]
 
 
 async def async_setup(hass: HomeAssistant, config: dict):

custom_components/plugwise-beta/binary_sensor.py

@@ -0,0 +1,138 @@
+"""Plugwise Binary Sensor component for Home Assistant."""
+
+import logging
+from typing import Dict
+
+from homeassistant.components.binary_sensor import DEVICE_CLASS_HEAT, BinarySensorDevice
+from homeassistant.const import STATE_OFF, STATE_ON
+from homeassistant.core import callback
+
+from homeassistant.components.climate.const import (
+    CURRENT_HVAC_COOL,
+    CURRENT_HVAC_HEAT,
+    CURRENT_HVAC_IDLE,
+)
+
+from .const import (
+    CURRENT_HVAC_DHW,
+    DOMAIN,
+    COOL_ICON,
+    FLAME_ICON,
+    IDLE_ICON,
+    WATER_ICON,
+)
+
+BINARY_SENSOR_LIST = [
+    "domestic_hot_water_state",
+    "slave_boiler_state",
+]
+
+_LOGGER = logging.getLogger(__name__)
+
+
+async def async_setup_entry(hass, config_entry, async_add_entities):
+    """Set up the Smile binary_sensors from a config entry."""
+    api = hass.data[DOMAIN][config_entry.entry_id]["api"]
+    updater = hass.data[DOMAIN][config_entry.entry_id]["updater"]
+
+    devices = []
+    all_devices = api.get_all_devices()
+    for dev_id, device in all_devices.items():
+        if device["class"] == "heater_central":
+            _LOGGER.debug("Plugwise device_class found")
+            data = api.get_device_data(dev_id)
+            for binary_sensor in BINARY_SENSOR_LIST:
+                _LOGGER.debug("Binary_sensor: %s", binary_sensor)
+                if binary_sensor in data:
+                    _LOGGER.debug("Plugwise binary_sensor Dev %s", device["name"])
+                    devices.append(PwBinarySensor(api, updater, binary_sensor, dev_id))
+                    _LOGGER.info("Added binary_sensor.%s", binary_sensor)
+
+    async_add_entities(devices, True)
+
+
+class PwBinarySensor(BinarySensorDevice):
+    """Representation of a Plugwise binary_sensor."""
+
+    def __init__(self, api, updater, binary_sensor, dev_id):
+        """Set up the Plugwise API."""
+        self._api = api
+        self._updater = updater
+        self._dev_id = dev_id
+        self._binary_sensor = binary_sensor
+        self._is_on = False
+        self._unique_id = f"{dev_id}-binary_sensor"
+
+    @property
+    def unique_id(self):
+        """Return a unique ID."""
+        return self._unique_id
+
+    async def async_added_to_hass(self):
+        """Register callbacks."""
+        self._updater.async_add_listener(self._update_callback)
+
+    async def async_will_remove_from_hass(self):
+        """Disconnect callbacks."""
+        self._updater.async_remove_listener(self._update_callback)
+
+    @callback
+    def _update_callback(self):
+        """Call update method."""
+        self.update()
+        self.async_write_ha_state()
+
+    @property
+    def name(self):
+        """Return the name of the thermostat, if any."""
+        return self._binary_sensor
+
+    @property
+    def device_info(self) -> Dict[str, any]:
+        """Return the device information."""
+        return {
+            "identifiers": {(DOMAIN, self._dev_id)},
+            "name": self._binary_sensor,
+            "manufacturer": "Plugwise",
+            "via_device": (DOMAIN, self._api.gateway_id),
+        }
+
+    @property
+    def should_poll(self):
+        """No need to poll. Coordinator notifies entity of updates."""
+        return False
+
+    @property
+    def is_on(self):
+        """Return true if the binary sensor is on."""
+        return self.is_on
+
+    @property
+    def state(self):
+        """Return the state of the binary sensor."""
+        if self._is_on:
+            return STATE_ON
+        return STATE_OFF
+
+    @property
+    def icon(self):
+        """Return the icon to use in the frontend."""
+        if self._binary_sensor == "domestic_hot_water_state":
+            return WATER_ICON
+        return FLAME_ICON
+
+    @property
+    def device_class(self):
+        """Return the class of this device, from component DEVICE_CLASSES."""
+        return DEVICE_CLASS_HEAT
+
+    def update(self):
+        """Update the entity."""
+        _LOGGER.debug("Update binary_sensor called")
+        data = self._api.get_device_data(self._dev_id)
+
+        if data is None:
+            _LOGGER.error("Received no data for device %s.", self._binary_sensor)
+        else:
+            if self._binary_sensor in data:
+                self._is_on = data[self._binary_sensor]

custom_components/plugwise-beta/const.py

@@ -29,8 +29,9 @@
 # Icons
 SWITCH_ICON = "mdi:electric-switch"
 THERMOSTAT_ICON = "mdi:thermometer"
-WATER_HEATER_ICON = "mdi:water-pump"
+WATER_ICON = "mdi:water-pump"
 FLAME_ICON = "mdi:fire"
+COOL_ICON = "mdi:snowflake"
 IDLE_ICON = "mdi:circle-off-outline"
 GAS_ICON = "mdi:fire"
 POWER_ICON = "mdi:flash"

custom_components/plugwise-beta/manifest.json

@@ -2,7 +2,7 @@
   "domain": "plugwise-beta",
   "name": "Plugwise Beta for Home Assistant",
   "documentation": "https://github.com/plugwise/plugwise-beta",
-  "requirements": ["Plugwise_Smile==0.1.12"],
+  "requirements": ["Plugwise_Smile==0.1.13"],
   "dependencies": [],
   "codeowners": ["@CoMPaTech","@bouwew"],
   "config_flow": true

custom_components/plugwise-beta/water_heater.py

@@ -7,16 +7,17 @@
 from homeassistant.helpers.entity import Entity
 
 from homeassistant.components.climate.const import (
+    CURRENT_HVAC_COOL,
     CURRENT_HVAC_HEAT,
     CURRENT_HVAC_IDLE,
 )
 
 from .const import (
     CURRENT_HVAC_DHW,
     DOMAIN,
+    COOL_ICON,
     FLAME_ICON,
     IDLE_ICON,
-    WATER_HEATER_ICON,
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -50,11 +51,12 @@ def __init__(self, api, updater, name, dev_id):
         self._updater = updater
         self._name = name
         self._dev_id = dev_id
-        self._boiler_state = False
         self._boiler_temp = None
+        self._boiler_state = False
         self._central_heating_state = False
-        self._central_heater_water_pressure = None
+        self._cooling_state = False
         self._domestic_hot_water_state = False
+        self._central_heater_water_pressure = None
         self._unique_id = f"{dev_id}-water_heater"
 
     @property
@@ -94,11 +96,12 @@ def device_info(self) -> Dict[str, any]:
     @property
     def state(self):
         """Return the state of the water_heater."""
-        if self._central_heating_state or self._boiler_state:
+        if self._cooling_state:
+            return CURRENT_HVAC_COOL
+        elif self._central_heating_state or self._boiler_state or self._domestic_hot_water_state:
             return CURRENT_HVAC_HEAT
-        if self._domestic_hot_water_state:
-            return CURRENT_HVAC_DHW
-        return CURRENT_HVAC_IDLE
+        else:
+            return CURRENT_HVAC_IDLE
 
     @property
     def device_state_attributes(self):
@@ -112,11 +115,12 @@ def device_state_attributes(self):
     @property
     def icon(self):
         """Return the icon to use in the frontend."""
-        if self._central_heating_state or self._boiler_state:
+        if self._cooling_state:
+            return COOL_ICON
+        elif self._central_heating_state or self._boiler_state or self._domestic_hot_water_state:
             return FLAME_ICON
-        if self._domestic_hot_water_state:
-            return WATER_HEATER_ICON
-        return IDLE_ICON
+        else:
+            return IDLE_ICON
 
     @property
     def should_poll(self):
@@ -143,5 +147,8 @@ def update(self):
             if "central_heating_state" in data:
                 if data["central_heating_state"] is not None:
                     self._central_heating_state = data["central_heating_state"]
+            if "cooling_state" in data:
+                if data["cooling_state"] is not None:
+                    self._cooling_state = data["boiler_state"]
             if "domestic_hot_water_state" in data:
                 self._domestic_hot_water_state = data["domestic_hot_water_state"]