Merge pull request #44 from plugwise/release_dot_2

Release 0.2.0

Author: bouwew

README.md

@@ -21,22 +21,24 @@ A fully asynchronous approach to supporting Plugwise devices. This repository is
 
 ## What do we support (in short)?
 
-  - Adam (firmware 2.3 + 3.0) - we don't have a `Koen` yet in our testers suite
+  - Adam (firmware 2.3 + 3.0)
   - Smile & Anna (firmware 1.8, 3.1 and 4.0)
   - Smile P1 (firmware 2.5 and 3.3)
 
 ## What can I expect in HA from this component
 
-  - `climate`: A (number of) thermostat(s) visible in HA, including temperature, presets and heating-demand status, per thermostat. Also, setting of temperature, preset and switching the active schedule on and off.
-  - `sensor` and `binary_sensor`: A number of sensoric values depending on your hardware (Outdoor temperature, Anna's illuminance, Plug power-usage, P1 values)
-  - `switch`: Plugs are available as switches, also switching them on/off is supported.
-  - `water_heater`: When your heating system connected to the Smile/Adam supports heating of tap-water, the status of this function is shown via the water_heater entity icon, next to the status of the normal heating function (idle/heating/hot_water) - **note** this is not available on all platforms (there is logic in place deciding if you need this as a seperate entity)
+  - `climate`: A (number of) thermostat(s) visible in HA, including temperature, presets and heating-demand status, per thermostat. Also, setting of temperature, preset and switching the active schedule on and off. Cooling is only supported in combination with an Anna (fw 3.1 and 4.0).
+  - `sensor` and `binary_sensor`: A number of sensoric values depending on your hardware: outdoor temperature, Anna's illuminance, Tom's valve postion, Plug's power-values, P1 power- and gas-values
+  - `switch`: The switch-parts of Plugs are available as switches, also switching them on/off is supported.
+
+The `water_heater`-device present in previous releases has been replaced by a state-sensor. This sensor will only show up when there are more (than one) thermostats present in your climate-system.
 
 ## How to set-up?
 
  - Use [HACS](https://hacs.xyz) 
- - Use the link to this page and add it on the `custom repo` page 
+ - Use the link to this page and add it on the `custom repo` page .
  - Look for `Plugwise beta custom component ` in `integrations` and install it!
+ - If you need an pre-release for testing, click the three dots and mark the 'beta' check to see pre-releases.
 
 ## When installed
 

custom_components/plugwise-beta/binary_sensor.py

@@ -19,7 +19,7 @@
 )
 
 BINARY_SENSOR_LIST = [
-    "domestic_hot_water_state",
+    "dhw_state",
     "slave_boiler_state",
     "valve_position",
 ]
@@ -143,7 +143,7 @@ def device_info(self) -> Dict[str, any]:
     @property
     def icon(self):
         """Return the icon to use in the frontend."""
-        if self._binary_sensor == "domestic_hot_water_state":
+        if self._binary_sensor == "dhw_state":
             return WATER_ICON
         if self._binary_sensor == "slave_boiler_state":
             return FLAME_ICON
@@ -162,7 +162,7 @@ def update(self):
         _LOGGER.debug("Update binary_sensor called")
         data = self._api.get_device_data(self._dev_id)
 
-        if data is None:
+        if not data:
             _LOGGER.error("Received no data for device %s.", self._binary_sensor)
         else:
             if self._binary_sensor in data:

custom_components/plugwise-beta/climate.py

@@ -16,6 +16,7 @@
 )
 from homeassistant.const import ATTR_TEMPERATURE, TEMP_CELSIUS
 from homeassistant.core import callback
+from Plugwise_Smile.Smile import Smile
 
 from .const import (
     DOMAIN,
@@ -91,14 +92,14 @@ def __init__(self, api, updater, name, dev_id, loc_id, model, min_temp, max_temp
         self._presets = None
         self._presets_list = None
         self._boiler_state = None
-        self._central_heating_state = None
+        self._heating_state = None
         self._cooling_state = None
-        self._domestic_hot_water_state = None
+        self._dhw_state = None
         self._hvac_mode = None
         self._schema_names = None
         self._schema_status = None
         self._temperature = None
-        self._thermostat = None
+        self._setpoint = None
         self._water_pressure = None
         self._schedule_temp = None
         self._hvac_mode = None
@@ -128,12 +129,12 @@ def _update_callback(self):
     def hvac_action(self):
         """Return the current action."""
         if self._single_thermostat:
-            if self._central_heating_state or self._boiler_state:
+            if self._heating_state or self._boiler_state:
                 return CURRENT_HVAC_HEAT
             if self._cooling_state:
                 return CURRENT_HVAC_COOL
             return CURRENT_HVAC_IDLE
-        if self._central_heating_state is not None or self._boiler_state is not None:
+        if self._heating_state is not None or self._boiler_state is not None:
             if self._thermostat > self._temperature:
                 return CURRENT_HVAC_HEAT
         return CURRENT_HVAC_IDLE
@@ -192,7 +193,7 @@ def preset_modes(self):
     @property
     def hvac_modes(self):
         """Return the available hvac modes list."""
-        if self._central_heating_state is not None or self._boiler_state is not None:
+        if self._heating_state is not None or self._boiler_state is not None:
             if self._cooling_state is not None:
                 return HVAC_MODES_2
             return HVAC_MODES_1
@@ -205,7 +206,7 @@ def hvac_mode(self):
     @property
     def target_temperature(self):
         """Return the target_temperature."""
-        return self._thermostat
+        return self._setpoint
 
     @property
     def preset_mode(self):
@@ -241,9 +242,12 @@ async def async_set_temperature(self, **kwargs):
             self._min_temp < temperature < self._max_temp
         ):
             _LOGGER.debug("Set temp to %sºC", temperature)
-            await self._api.set_temperature(self._loc_id, temperature)
-            self._thermostat = temperature
-            self.async_write_ha_state()
+            try:
+                await self._api.set_temperature(self._loc_id, temperature)
+                self._setpoint = temperature
+                self.async_write_ha_state()
+            except Smile.PlugwiseError:
+                _LOGGER.error("Error while communicating to device")
         else:
             _LOGGER.error("Invalid temperature requested")
 
@@ -253,34 +257,43 @@ async def async_set_hvac_mode(self, hvac_mode):
         state = "false"
         if hvac_mode == HVAC_MODE_AUTO:
             state = "true"
-            await self._api.set_temperature(self._loc_id, self._schedule_temp)
-            self._thermostat = self._schedule_temp
-        await self._api.set_schedule_state(
-            self._loc_id, self._last_active_schema, state
-        )
-        self._hvac_mode = hvac_mode
-        self.async_write_ha_state()
+            try:
+                await self._api.set_temperature(self._loc_id, self._schedule_temp)
+                self._setpoint = self._schedule_temp
+            except Smile.PlugwiseError:
+                _LOGGER.error("Error while communicating to device")
+        try:
+            await self._api.set_schedule_state(
+                self._loc_id, self._last_active_schema, state
+            )
+            self._hvac_mode = hvac_mode
+            self.async_write_ha_state()
+        except Smile.PlugwiseError:
+            _LOGGER.error("Error while communicating to device")
 
     async def async_set_preset_mode(self, preset_mode):
         """Set the preset mode."""
         _LOGGER.debug("Set preset mode to %s.", preset_mode)
-        await self._api.set_preset(self._loc_id, preset_mode)
-        self._preset_mode = preset_mode
-        self._thermostat = self._presets.get(self._preset_mode, "none")[0]
-        self.async_write_ha_state()
+        try:
+            await self._api.set_preset(self._loc_id, preset_mode)
+            self._preset_mode = preset_mode
+            self._setpoint = self._presets.get(self._preset_mode, "none")[0]
+            self.async_write_ha_state()
+        except Smile.PlugwiseError:
+            _LOGGER.error("Error while communicating to device")
 
     def update(self):
         """Update the data for this climate device."""
         _LOGGER.info("Updating climate...")
         climate_data = self._api.get_device_data(self._dev_id)
         heater_central_data = self._api.get_device_data(self._api.heater_id)
 
-        if climate_data is None:
+        if not climate_data:
             _LOGGER.error("Received no climate_data for device %s.", self._name)
         else:
             _LOGGER.debug("Climate_data collected from Plugwise API")
-            if "thermostat" in climate_data:
-                self._thermostat = climate_data["thermostat"]
+            if "setpoint" in climate_data:
+                self._thermostat = climate_data["setpoint"]
             if "temperature" in climate_data:
                 self._temperature = climate_data["temperature"]
             if "schedule_temperature" in climate_data:
@@ -302,31 +315,29 @@ def update(self):
             if "active_preset" in climate_data:
                 self._preset_mode = climate_data["active_preset"]
 
-        if heater_central_data is None:
+        if not heater_central_data:
             _LOGGER.error("Received no heater_central_data for device %s.", self._name)
         else:
             _LOGGER.debug("Heater_central_data collected from Plugwise API")
             if "boiler_state" in heater_central_data:
                 if heater_central_data["boiler_state"] is not None:
                     self._boiler_state = heater_central_data["boiler_state"]
-            if "central_heating_state" in heater_central_data:
-                if heater_central_data["central_heating_state"] is not None:
-                    self._central_heating_state = heater_central_data[
-                        "central_heating_state"
-                    ]
+            if "heating_state" in heater_central_data:
+                if heater_central_data["heating_state"] is not None:
+                    self._heating_state = heater_central_data["heating_state" ]
             if "cooling_state" in heater_central_data:
                 if heater_central_data["cooling_state"] is not None:
                     self._cooling_state = heater_central_data["cooling_state"]
 
         if self._schema_status:
             self._hvac_mode = HVAC_MODE_AUTO
-        elif self._central_heating_state is not None or self._boiler_state is not None:
+        elif self._heating_state is not None or self._boiler_state is not None:
             if self._cooling_state is not None:
                 self._hvac_mode = HVAC_MODE_HEAT_COOL
             self._hvac_mode = HVAC_MODE_HEAT
         elif self._cooling_state is not None:
             if (
-                self._central_heating_state is not None
+                self._heating_state is not None
                 or self._boiler_state is not None
             ):
                 self._hvac_mode = HVAC_MODE_HEAT_COOL

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.24"],
+  "requirements": ["Plugwise_Smile==0.2.0"],
   "dependencies": [],
   "codeowners": ["@CoMPaTech","@bouwew"],
   "config_flow": true

custom_components/plugwise-beta/manifest.json.ha-core

@@ -40,10 +40,10 @@
 ]
 ATTR_PRESSURE = ["Pressure", PRESSURE_BAR, DEVICE_CLASS_PRESSURE, "mdi:water"]
 SENSOR_MAP = {
-    "thermostat": ATTR_TEMPERATURE,
+    "setpoint": ATTR_TEMPERATURE,
     "temperature": ATTR_TEMPERATURE,
     "battery": ATTR_BATTERY_LEVEL,
-    "central_heater_water_pressure": ATTR_PRESSURE,
+    "water_pressure": ATTR_PRESSURE,
     "temperature_difference": ATTR_TEMPERATURE,
     "electricity_consumed": [
         "Current Consumed Power",
@@ -71,7 +71,7 @@
     ],
     "outdoor_temperature": ATTR_TEMPERATURE,
     "illuminance": ATTR_ILLUMINANCE,
-    "boiler_temperature": ATTR_TEMPERATURE,
+    "water_temperature": ATTR_TEMPERATURE,
     "electricity_consumed_off_peak_point": [
         "Current Consumed Power (off peak)",
         "W",
@@ -152,6 +152,7 @@
     "flame_state",
 ]
 
+
 async def async_setup_entry(hass, config_entry, async_add_entities):
     """Set up the Smile sensors from a config entry."""
     _LOGGER.debug("Plugwise hass data %s", hass.data[DOMAIN])
@@ -209,20 +210,14 @@ async def async_setup_entry(hass, config_entry, async_add_entities):
                         _LOGGER.debug("Plugwise aux sensor Dev %s", device["name"])
                         devices.append(
                             PwThermostatSensor(
-                                api,
-                                updater,
-                                device["name"],
-                                dev_id,
-                                "state",
-                                None,
+                                api, updater, device["name"], dev_id, "state", None,
                             )
                         )
                         _LOGGER.info(
                             "Added sensor.%s_state", "{}".format(device["name"])
                         )
                         idx += 1
 
-
     async_add_entities(devices, True)
 
 
@@ -247,7 +242,7 @@ def __init__(self, api, updater, name, dev_id, sensor, sensor_type):
         self._class = self._device
         self._state = None
         self._boiler_state = False
-        self._central_heating_state = False
+        self._heating_state = False
         self._cooling_state = False
 
         if self._dev_id == self._api.heater_id:
@@ -320,7 +315,7 @@ def unit_of_measurement(self):
     def icon(self):
         """Icon for the sensor."""
         if self._sensor_type is None:
-            if self._boiler_state or self._central_heating_state:
+            if self._boiler_state or self._heating_state:
                 return FLAME_ICON
             if self._cooling_state:
                 return COOL_ICON
@@ -332,7 +327,7 @@ def update(self):
         _LOGGER.debug("Update sensor called")
         data = self._api.get_device_data(self._dev_id)
 
-        if data is None:
+        if not data:
             _LOGGER.error("Received no data for device %s.", self._name)
         else:
             if self._sensor in data:
@@ -347,20 +342,20 @@ def update(self):
             if "boiler_state" in data:
                 if data["boiler_state"] is not None:
                     self._boiler_state = data["boiler_state"]
-            if "central_heating_state" in data:
-                if data["central_heating_state"] is not None:
-                    self._central_heating_state = data["central_heating_state"]
+            if "heating_state" in data:
+                if data["heating_state"] is not None:
+                    self._heating_state = data["heating_state"]
             if "cooling_state" in data:
                 if data["cooling_state"] is not None:
                     self._cooling_state = data["cooling_state"]
             if self._sensor == "state":
-                if self._boiler_state or self._central_heating_state:
+                if self._boiler_state or self._heating_state:
                     self._state = "heating"
                 elif self._cooling_state:
                     self._state = "cooling"
                 else:
                     self._state = "idle"
-                    
+
 
 class PwPowerSensor(Entity):
     """Power sensor devices."""
@@ -453,7 +448,7 @@ def update(self):
         _LOGGER.debug("Update sensor called")
         data = self._api.get_device_data(self._dev_id)
 
-        if data is None:
+        if not data:
             _LOGGER.error("Received no data for device %s.", self._name)
         else:
             if self._sensor in data: