415 lines
14 KiB
Python
415 lines
14 KiB
Python
"""Support for Climate devices of (EMEA/EU-based) Honeywell TCC systems."""
|
|
from datetime import datetime
|
|
import logging
|
|
from typing import Any, Dict, Optional, List
|
|
|
|
from homeassistant.components.climate import ClimateDevice
|
|
from homeassistant.components.climate.const import (
|
|
CURRENT_HVAC_HEAT,
|
|
CURRENT_HVAC_IDLE,
|
|
CURRENT_HVAC_OFF,
|
|
HVAC_MODE_AUTO,
|
|
HVAC_MODE_HEAT,
|
|
HVAC_MODE_OFF,
|
|
PRESET_AWAY,
|
|
PRESET_ECO,
|
|
PRESET_HOME,
|
|
PRESET_NONE,
|
|
SUPPORT_TARGET_TEMPERATURE,
|
|
SUPPORT_PRESET_MODE,
|
|
)
|
|
from homeassistant.const import PRECISION_TENTHS
|
|
from homeassistant.helpers.typing import ConfigType, HomeAssistantType
|
|
from homeassistant.util.dt import parse_datetime
|
|
|
|
from . import CONF_LOCATION_IDX, EvoDevice
|
|
from .const import (
|
|
DOMAIN,
|
|
EVO_RESET,
|
|
EVO_AUTO,
|
|
EVO_AUTOECO,
|
|
EVO_AWAY,
|
|
EVO_CUSTOM,
|
|
EVO_DAYOFF,
|
|
EVO_HEATOFF,
|
|
EVO_FOLLOW,
|
|
EVO_TEMPOVER,
|
|
EVO_PERMOVER,
|
|
)
|
|
|
|
_LOGGER = logging.getLogger(__name__)
|
|
|
|
PRESET_RESET = "Reset" # reset all child zones to EVO_FOLLOW
|
|
PRESET_CUSTOM = "Custom"
|
|
|
|
HA_HVAC_TO_TCS = {HVAC_MODE_OFF: EVO_HEATOFF, HVAC_MODE_HEAT: EVO_AUTO}
|
|
|
|
TCS_PRESET_TO_HA = {
|
|
EVO_AWAY: PRESET_AWAY,
|
|
EVO_CUSTOM: PRESET_CUSTOM,
|
|
EVO_AUTOECO: PRESET_ECO,
|
|
EVO_DAYOFF: PRESET_HOME,
|
|
EVO_RESET: PRESET_RESET,
|
|
} # EVO_AUTO: None,
|
|
|
|
HA_PRESET_TO_TCS = {v: k for k, v in TCS_PRESET_TO_HA.items()}
|
|
|
|
EVO_PRESET_TO_HA = {
|
|
EVO_FOLLOW: PRESET_NONE,
|
|
EVO_TEMPOVER: "temporary",
|
|
EVO_PERMOVER: "permanent",
|
|
}
|
|
HA_PRESET_TO_EVO = {v: k for k, v in EVO_PRESET_TO_HA.items()}
|
|
|
|
|
|
async def async_setup_platform(
|
|
hass: HomeAssistantType, config: ConfigType, async_add_entities, discovery_info=None
|
|
) -> None:
|
|
"""Create the evohome Controller, and its Zones, if any."""
|
|
if discovery_info is None:
|
|
return
|
|
|
|
broker = hass.data[DOMAIN]["broker"]
|
|
loc_idx = broker.params[CONF_LOCATION_IDX]
|
|
|
|
_LOGGER.debug(
|
|
"Found Location/Controller, id=%s [%s], name=%s (location_idx=%s)",
|
|
broker.tcs.systemId,
|
|
broker.tcs.modelType,
|
|
broker.tcs.location.name,
|
|
loc_idx,
|
|
)
|
|
|
|
# special case of RoundThermostat (is single zone)
|
|
if broker.config["zones"][0]["modelType"] == "RoundModulation":
|
|
zone = list(broker.tcs.zones.values())[0]
|
|
_LOGGER.debug(
|
|
"Found %s, id=%s [%s], name=%s",
|
|
zone.zoneType,
|
|
zone.zoneId,
|
|
zone.modelType,
|
|
zone.name,
|
|
)
|
|
|
|
async_add_entities([EvoThermostat(broker, zone)], update_before_add=True)
|
|
return
|
|
|
|
controller = EvoController(broker, broker.tcs)
|
|
|
|
zones = []
|
|
for zone in broker.tcs.zones.values():
|
|
_LOGGER.debug(
|
|
"Found %s, id=%s [%s], name=%s",
|
|
zone.zoneType,
|
|
zone.zoneId,
|
|
zone.modelType,
|
|
zone.name,
|
|
)
|
|
zones.append(EvoZone(broker, zone))
|
|
|
|
async_add_entities([controller] + zones, update_before_add=True)
|
|
|
|
|
|
class EvoClimateDevice(EvoDevice, ClimateDevice):
|
|
"""Base for a Honeywell evohome Climate device."""
|
|
|
|
def __init__(self, evo_broker, evo_device) -> None:
|
|
"""Initialize the evohome Climate device."""
|
|
super().__init__(evo_broker, evo_device)
|
|
|
|
self._preset_modes = None
|
|
|
|
async def _set_temperature(
|
|
self, temperature: float, until: Optional[datetime] = None
|
|
) -> None:
|
|
"""Set a new target temperature for the Zone.
|
|
|
|
until == None means indefinitely (i.e. PermanentOverride)
|
|
"""
|
|
await self._call_client_api(
|
|
self._evo_device.set_temperature(temperature, until)
|
|
)
|
|
|
|
async def _set_zone_mode(self, op_mode: str) -> None:
|
|
"""Set a Zone to one of its native EVO_* operating modes.
|
|
|
|
Zones inherit their _effective_ operating mode from the Controller.
|
|
|
|
Usually, Zones are in 'FollowSchedule' mode, where their setpoints are
|
|
a function of their own schedule and the Controller's operating mode,
|
|
e.g. 'AutoWithEco' mode means their setpoint is (by default) 3C less
|
|
than scheduled.
|
|
|
|
However, Zones can _override_ these setpoints, either indefinitely,
|
|
'PermanentOverride' mode, or for a period of time, 'TemporaryOverride',
|
|
after which they will revert back to 'FollowSchedule'.
|
|
|
|
Finally, some of the Controller's operating modes are _forced_ upon the
|
|
Zones, regardless of any override mode, e.g. 'HeatingOff', Zones to
|
|
(by default) 5C, and 'Away', Zones to (by default) 12C.
|
|
"""
|
|
if op_mode == EVO_FOLLOW:
|
|
await self._call_client_api(self._evo_device.cancel_temp_override())
|
|
return
|
|
|
|
temperature = self._evo_device.setpointStatus["targetHeatTemperature"]
|
|
until = None # EVO_PERMOVER
|
|
|
|
if op_mode == EVO_TEMPOVER and self._schedule["DailySchedules"]:
|
|
await self._update_schedule()
|
|
if self._schedule["DailySchedules"]:
|
|
until = parse_datetime(self.setpoints["next"]["from"])
|
|
|
|
await self._set_temperature(temperature, until=until)
|
|
|
|
async def _set_tcs_mode(self, op_mode: str) -> None:
|
|
"""Set the Controller to any of its native EVO_* operating modes."""
|
|
await self._call_client_api(
|
|
self._evo_tcs._set_status(op_mode) # pylint: disable=protected-access
|
|
)
|
|
|
|
@property
|
|
def hvac_modes(self) -> List[str]:
|
|
"""Return the list of available hvac operation modes."""
|
|
return list(HA_HVAC_TO_TCS)
|
|
|
|
@property
|
|
def preset_modes(self) -> Optional[List[str]]:
|
|
"""Return a list of available preset modes."""
|
|
return self._preset_modes
|
|
|
|
|
|
class EvoZone(EvoClimateDevice):
|
|
"""Base for a Honeywell evohome Zone."""
|
|
|
|
def __init__(self, evo_broker, evo_device) -> None:
|
|
"""Initialize the evohome Zone."""
|
|
super().__init__(evo_broker, evo_device)
|
|
|
|
self._name = evo_device.name
|
|
self._icon = "mdi:radiator"
|
|
|
|
self._precision = self._evo_device.setpointCapabilities["valueResolution"]
|
|
self._state_attributes = [
|
|
"zoneId",
|
|
"activeFaults",
|
|
"setpointStatus",
|
|
"temperatureStatus",
|
|
"setpoints",
|
|
]
|
|
|
|
self._supported_features = SUPPORT_PRESET_MODE | SUPPORT_TARGET_TEMPERATURE
|
|
self._preset_modes = list(HA_PRESET_TO_EVO)
|
|
|
|
@property
|
|
def available(self) -> bool:
|
|
"""Return True if entity is available."""
|
|
return self._evo_device.temperatureStatus["isAvailable"]
|
|
|
|
@property
|
|
def hvac_mode(self) -> str:
|
|
"""Return the current operating mode of the evohome Zone."""
|
|
if self._evo_tcs.systemModeStatus["mode"] in [EVO_AWAY, EVO_HEATOFF]:
|
|
return HVAC_MODE_AUTO
|
|
is_off = self.target_temperature <= self.min_temp
|
|
return HVAC_MODE_OFF if is_off else HVAC_MODE_HEAT
|
|
|
|
@property
|
|
def hvac_action(self) -> Optional[str]:
|
|
"""Return the current running hvac operation if supported."""
|
|
if self._evo_tcs.systemModeStatus["mode"] == EVO_HEATOFF:
|
|
return CURRENT_HVAC_OFF
|
|
if self.target_temperature <= self.min_temp:
|
|
return CURRENT_HVAC_OFF
|
|
if self.target_temperature < self.current_temperature:
|
|
return CURRENT_HVAC_IDLE
|
|
return CURRENT_HVAC_HEAT
|
|
|
|
@property
|
|
def current_temperature(self) -> Optional[float]:
|
|
"""Return the current temperature of the evohome Zone."""
|
|
return (
|
|
self._evo_device.temperatureStatus["temperature"]
|
|
if self._evo_device.temperatureStatus["isAvailable"]
|
|
else None
|
|
)
|
|
|
|
@property
|
|
def target_temperature(self) -> float:
|
|
"""Return the target temperature of the evohome Zone."""
|
|
if self._evo_tcs.systemModeStatus["mode"] == EVO_HEATOFF:
|
|
return self._evo_device.setpointCapabilities["minHeatSetpoint"]
|
|
return self._evo_device.setpointStatus["targetHeatTemperature"]
|
|
|
|
@property
|
|
def preset_mode(self) -> Optional[str]:
|
|
"""Return the current preset mode, e.g., home, away, temp."""
|
|
if self._evo_tcs.systemModeStatus["mode"] in [EVO_AWAY, EVO_HEATOFF]:
|
|
return TCS_PRESET_TO_HA.get(self._evo_tcs.systemModeStatus["mode"])
|
|
return EVO_PRESET_TO_HA.get(
|
|
self._evo_device.setpointStatus["setpointMode"], "follow"
|
|
)
|
|
|
|
@property
|
|
def min_temp(self) -> float:
|
|
"""Return the minimum target temperature of a evohome Zone.
|
|
|
|
The default is 5, but is user-configurable within 5-35 (in Celsius).
|
|
"""
|
|
return self._evo_device.setpointCapabilities["minHeatSetpoint"]
|
|
|
|
@property
|
|
def max_temp(self) -> float:
|
|
"""Return the maximum target temperature of a evohome Zone.
|
|
|
|
The default is 35, but is user-configurable within 5-35 (in Celsius).
|
|
"""
|
|
return self._evo_device.setpointCapabilities["maxHeatSetpoint"]
|
|
|
|
async def async_set_temperature(self, **kwargs) -> None:
|
|
"""Set a new target temperature."""
|
|
until = kwargs.get("until")
|
|
if until:
|
|
until = parse_datetime(until)
|
|
|
|
await self._set_temperature(kwargs["temperature"], until)
|
|
|
|
async def async_set_hvac_mode(self, hvac_mode: str) -> None:
|
|
"""Set an operating mode for the Zone."""
|
|
if hvac_mode == HVAC_MODE_OFF:
|
|
await self._set_temperature(self.min_temp, until=None)
|
|
|
|
else: # HVAC_MODE_HEAT
|
|
await self._set_zone_mode(EVO_FOLLOW)
|
|
|
|
async def async_set_preset_mode(self, preset_mode: Optional[str]) -> None:
|
|
"""Set a new preset mode.
|
|
|
|
If preset_mode is None, then revert to following the schedule.
|
|
"""
|
|
await self._set_zone_mode(HA_PRESET_TO_EVO.get(preset_mode, EVO_FOLLOW))
|
|
|
|
|
|
class EvoController(EvoClimateDevice):
|
|
"""Base for a Honeywell evohome Controller (hub).
|
|
|
|
The Controller (aka TCS, temperature control system) is the parent of all
|
|
the child (CH/DHW) devices. It is also a Climate device.
|
|
"""
|
|
|
|
def __init__(self, evo_broker, evo_device) -> None:
|
|
"""Initialize the evohome Controller (hub)."""
|
|
super().__init__(evo_broker, evo_device)
|
|
|
|
self._name = evo_device.location.name
|
|
self._icon = "mdi:thermostat"
|
|
|
|
self._precision = PRECISION_TENTHS
|
|
self._state_attributes = ["systemId", "activeFaults", "systemModeStatus"]
|
|
|
|
self._supported_features = SUPPORT_PRESET_MODE
|
|
self._preset_modes = list(HA_PRESET_TO_TCS)
|
|
|
|
@property
|
|
def hvac_mode(self) -> str:
|
|
"""Return the current operating mode of the evohome Controller."""
|
|
tcs_mode = self._evo_tcs.systemModeStatus["mode"]
|
|
return HVAC_MODE_OFF if tcs_mode == EVO_HEATOFF else HVAC_MODE_HEAT
|
|
|
|
@property
|
|
def current_temperature(self) -> Optional[float]:
|
|
"""Return the average current temperature of the heating Zones.
|
|
|
|
Controllers do not have a current temp, but one is expected by HA.
|
|
"""
|
|
temps = [
|
|
z.temperatureStatus["temperature"]
|
|
for z in self._evo_tcs.zones.values()
|
|
if z.temperatureStatus["isAvailable"]
|
|
]
|
|
return round(sum(temps) / len(temps), 1) if temps else None
|
|
|
|
@property
|
|
def preset_mode(self) -> Optional[str]:
|
|
"""Return the current preset mode, e.g., home, away, temp."""
|
|
return TCS_PRESET_TO_HA.get(self._evo_tcs.systemModeStatus["mode"])
|
|
|
|
async def async_set_temperature(self, **kwargs) -> None:
|
|
"""Do nothing.
|
|
|
|
The evohome Controller doesn't have a target temperature.
|
|
"""
|
|
return
|
|
|
|
async def async_set_hvac_mode(self, hvac_mode: str) -> None:
|
|
"""Set an operating mode for the Controller."""
|
|
await self._set_tcs_mode(HA_HVAC_TO_TCS.get(hvac_mode))
|
|
|
|
async def async_set_preset_mode(self, preset_mode: Optional[str]) -> None:
|
|
"""Set a new preset mode.
|
|
|
|
If preset_mode is None, then revert to 'Auto' mode.
|
|
"""
|
|
await self._set_tcs_mode(HA_PRESET_TO_TCS.get(preset_mode, EVO_AUTO))
|
|
|
|
async def async_update(self) -> None:
|
|
"""Get the latest state data."""
|
|
return
|
|
|
|
|
|
class EvoThermostat(EvoZone):
|
|
"""Base for a Honeywell Round Thermostat.
|
|
|
|
Implemented as a combined Controller/Zone.
|
|
"""
|
|
|
|
def __init__(self, evo_broker, evo_device) -> None:
|
|
"""Initialize the Round Thermostat."""
|
|
super().__init__(evo_broker, evo_device)
|
|
|
|
self._name = evo_broker.tcs.location.name
|
|
self._preset_modes = [PRESET_AWAY, PRESET_ECO]
|
|
|
|
@property
|
|
def device_state_attributes(self) -> Dict[str, Any]:
|
|
"""Return the device-specific state attributes."""
|
|
status = super().device_state_attributes["status"]
|
|
|
|
status["systemModeStatus"] = self._evo_tcs.systemModeStatus
|
|
status["activeFaults"] += self._evo_tcs.activeFaults
|
|
|
|
return {"status": status}
|
|
|
|
@property
|
|
def hvac_mode(self) -> str:
|
|
"""Return the current operating mode."""
|
|
if self._evo_tcs.systemModeStatus["mode"] == EVO_HEATOFF:
|
|
return HVAC_MODE_OFF
|
|
|
|
return super().hvac_mode
|
|
|
|
@property
|
|
def preset_mode(self) -> Optional[str]:
|
|
"""Return the current preset mode, e.g., home, away, temp."""
|
|
if (
|
|
self._evo_tcs.systemModeStatus["mode"] == EVO_AUTOECO
|
|
and self._evo_device.setpointStatus["setpointMode"] == EVO_FOLLOW
|
|
):
|
|
return PRESET_ECO
|
|
|
|
return super().preset_mode
|
|
|
|
async def async_set_hvac_mode(self, hvac_mode: str) -> None:
|
|
"""Set an operating mode."""
|
|
await self._set_tcs_mode(HA_HVAC_TO_TCS.get(hvac_mode))
|
|
|
|
async def async_set_preset_mode(self, preset_mode: Optional[str]) -> None:
|
|
"""Set a new preset mode.
|
|
|
|
If preset_mode is None, then revert to following the schedule.
|
|
"""
|
|
if preset_mode in list(HA_PRESET_TO_TCS):
|
|
await self._set_tcs_mode(HA_PRESET_TO_TCS.get(preset_mode))
|
|
else:
|
|
await self._set_zone_mode(HA_PRESET_TO_EVO.get(preset_mode, EVO_FOLLOW))
|