jeans/core
jeans/core
1
0
Fork 0
mirror of https://github.com/home-assistant/core.git synced 2025-07-21 12:17:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add fan and reduce I/O calls in radiotherm (#10437)

Browse Source 
* Added fan support.  Reduced number of calls to the thermostat to a minimum

* Move temp rounding to config schema

* Fixed pep8 errors

* Fix for review comments.

* removed unneeded if block

* Added missing precision attr back

* Fixed pylint errors

* Code review fixes.  Fan support by model number.

* Defined circulate state
This commit is contained in:
Ted Drain 2017-11-22 14:59:49 -06:00 committed by Martin Hjelmare
parent b668b19543
commit b4635db5ac
1 changed files with 158 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

232
homeassistant/components/climate/radiotherm.py
View File

@ -4,15 +4,17 @@ Support for Radio Thermostat wifi-enabled home thermostats.
For more details about this platform, please refer to the documentation at For more details about this platform, please refer to the documentation at
https://home-assistant.io/components/climate.radiotherm/ https://home-assistant.io/components/climate.radiotherm/
""" """
import asyncio
import datetime import datetime
import logging import logging
import voluptuous as vol import voluptuous as vol
from homeassistant.components.climate import ( from homeassistant.components.climate import (
STATE_AUTO, STATE_COOL, STATE_HEAT, STATE_IDLE, STATE_OFF, STATE_AUTO, STATE_COOL, STATE_HEAT, STATE_IDLE, STATE_ON, STATE_OFF,
ClimateDevice, PLATFORM_SCHEMA) ClimateDevice, PLATFORM_SCHEMA)
from homeassistant.const import CONF_HOST, TEMP_FAHRENHEIT, ATTR_TEMPERATURE from homeassistant.const import (
CONF_HOST, TEMP_FAHRENHEIT, ATTR_TEMPERATURE, PRECISION_HALVES)
import homeassistant.helpers.config_validation as cv import homeassistant.helpers.config_validation as cv
REQUIREMENTS = ['radiotherm==1.3'] REQUIREMENTS = ['radiotherm==1.3']
@ -29,13 +31,51 @@ CONF_AWAY_TEMPERATURE_COOL = 'away_temperature_cool'
DEFAULT_AWAY_TEMPERATURE_HEAT = 60 DEFAULT_AWAY_TEMPERATURE_HEAT = 60
DEFAULT_AWAY_TEMPERATURE_COOL = 85 DEFAULT_AWAY_TEMPERATURE_COOL = 85
STATE_CIRCULATE = "circulate"
OPERATION_LIST = [STATE_AUTO, STATE_COOL, STATE_HEAT, STATE_OFF]
CT30_FAN_OPERATION_LIST = [STATE_ON, STATE_AUTO]
CT80_FAN_OPERATION_LIST = [STATE_ON, STATE_CIRCULATE, STATE_AUTO]
# Mappings from radiotherm json data codes to and from HASS state
# flags. CODE is the thermostat integer code and these map to and
# from HASS state flags.
# Programmed temperature mode of the thermostat.
CODE_TO_TEMP_MODE = {0: STATE_OFF, 1: STATE_HEAT, 2: STATE_COOL, 3: STATE_AUTO}
TEMP_MODE_TO_CODE = {v: k for k, v in CODE_TO_TEMP_MODE.items()}
# Programmed fan mode (circulate is supported by CT80 models)
CODE_TO_FAN_MODE = {0: STATE_AUTO, 1: STATE_CIRCULATE, 2: STATE_ON}
FAN_MODE_TO_CODE = {v: k for k, v in CODE_TO_FAN_MODE.items()}
# Active thermostat state (is it heating or cooling?). In the future
# this should probably made into heat and cool binary sensors.
CODE_TO_TEMP_STATE = {0: STATE_IDLE, 1: STATE_HEAT, 2: STATE_COOL}
# Active fan state. This is if the fan is actually on or not. In the
# future this should probably made into a binary sensor for the fan.
CODE_TO_FAN_STATE = {0: STATE_OFF, 1: STATE_ON}
def round_temp(temperature):
"""Round a temperature to the resolution of the thermostat.
RadioThermostats can handle 0.5 degree temps so the input
temperature is rounded to that value and returned.
"""
return round(temperature * 2.0) / 2.0
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Optional(CONF_HOST): vol.All(cv.ensure_list, [cv.string]), vol.Optional(CONF_HOST): vol.All(cv.ensure_list, [cv.string]),
vol.Optional(CONF_HOLD_TEMP, default=False): cv.boolean, vol.Optional(CONF_HOLD_TEMP, default=False): cv.boolean,
vol.Optional(CONF_AWAY_TEMPERATURE_HEAT, vol.Optional(CONF_AWAY_TEMPERATURE_HEAT,
default=DEFAULT_AWAY_TEMPERATURE_HEAT): vol.Coerce(float), default=DEFAULT_AWAY_TEMPERATURE_HEAT):
vol.All(vol.Coerce(float), round_temp),
vol.Optional(CONF_AWAY_TEMPERATURE_COOL, vol.Optional(CONF_AWAY_TEMPERATURE_COOL,
default=DEFAULT_AWAY_TEMPERATURE_COOL): vol.Coerce(float), default=DEFAULT_AWAY_TEMPERATURE_COOL):
vol.All(vol.Coerce(float), round_temp),
}) })
@ -77,19 +117,34 @@ class RadioThermostat(ClimateDevice):
def __init__(self, device, hold_temp, away_temps): def __init__(self, device, hold_temp, away_temps):
"""Initialize the thermostat.""" """Initialize the thermostat."""
self.device = device self.device = device
self.set_time()
self._target_temperature = None self._target_temperature = None
self._current_temperature = None self._current_temperature = None
self._current_operation = STATE_IDLE self._current_operation = STATE_IDLE
self._name = None self._name = None
self._fmode = None self._fmode = None
self._fstate = None
self._tmode = None self._tmode = None
self._tstate = None self._tstate = None
self._hold_temp = hold_temp self._hold_temp = hold_temp
self._hold_set = False
self._away = False self._away = False
self._away_temps = away_temps self._away_temps = away_temps
self._prev_temp = None self._prev_temp = None
self._operation_list = [STATE_AUTO, STATE_COOL, STATE_HEAT, STATE_OFF]
# Fan circulate mode is only supported by the CT80 models.
import radiotherm
self._is_model_ct80 = isinstance(self.device,
radiotherm.thermostat.CT80)
@asyncio.coroutine
def async_added_to_hass(self):
"""Register callbacks."""
# Set the time on the device. This shouldn't be in the
# constructor because it's a network call. We can't put it in
# update() because calling it will clear any temporary mode or
# temperature in the thermostat. So add it as a future job
# for the event loop to run.
self.hass.async_add_job(self.set_time)
@property @property
def name(self): def name(self):
@ -101,6 +156,11 @@ class RadioThermostat(ClimateDevice):
"""Return the unit of measurement.""" """Return the unit of measurement."""
return TEMP_FAHRENHEIT return TEMP_FAHRENHEIT
@property
def precision(self):
"""Return the precision of the system."""
return PRECISION_HALVES
@property @property
def device_state_attributes(self): def device_state_attributes(self):
"""Return the device specific state attributes.""" """Return the device specific state attributes."""
@ -109,6 +169,25 @@ class RadioThermostat(ClimateDevice):
ATTR_MODE: self._tmode, ATTR_MODE: self._tmode,
} }
@property
def fan_list(self):
"""List of available fan modes."""
if self._is_model_ct80:
return CT80_FAN_OPERATION_LIST
else:
return CT30_FAN_OPERATION_LIST
@property
def current_fan_mode(self):
"""Return whether the fan is on."""
return self._fmode
def set_fan_mode(self, fan):
"""Turn fan on/off."""
code = FAN_MODE_TO_CODE.get(fan, None)
if code is not None:
self.device.fmode = code
@property @property
def current_temperature(self): def current_temperature(self):
"""Return the current temperature.""" """Return the current temperature."""
@ -122,7 +201,7 @@ class RadioThermostat(ClimateDevice):
@property @property
def operation_list(self): def operation_list(self):
"""Return the operation modes list.""" """Return the operation modes list."""
return self._operation_list return OPERATION_LIST
@property @property
def target_temperature(self): def target_temperature(self):
@ -136,53 +215,48 @@ class RadioThermostat(ClimateDevice):
def update(self): def update(self):
"""Update and validate the data from the thermostat.""" """Update and validate the data from the thermostat."""
current_temp = self.device.temp['raw'] # Radio thermostats are very slow, and sometimes don't respond
if current_temp == -1: # very quickly. So we need to keep the number of calls to them
_LOGGER.error("Couldn't get valid temperature reading") # to a bare minimum or we'll hit the HASS 10 sec warning. We
return # have to make one call to /tstat to get temps but we'll try and
self._current_temperature = current_temp # keep the other calls to a minimum. Even with this, these
self._name = self.device.name['raw'] # thermostats tend to time out sometimes when they're actively
try: # heating or cooling.
self._fmode = self.device.fmode['human']
except AttributeError:
_LOGGER.error("Couldn't get valid fan mode reading")
try:
self._tmode = self.device.tmode['human']
except AttributeError:
_LOGGER.error("Couldn't get valid thermostat mode reading")
try:
self._tstate = self.device.tstate['human']
except AttributeError:
_LOGGER.error("Couldn't get valid thermostat state reading")
if self._tmode == 'Cool': # First time - get the name from the thermostat. This is
target_temp = self.device.t_cool['raw'] # normally set in the radio thermostat web app.
if target_temp == -1: if self._name is None:
_LOGGER.error("Couldn't get target reading") self._name = self.device.name['raw']
return
self._target_temperature = target_temp # Request the current state from the thermostat.
self._current_operation = STATE_COOL data = self.device.tstat['raw']
elif self._tmode == 'Heat':
target_temp = self.device.t_heat['raw'] current_temp = data['temp']
if target_temp == -1: if current_temp == -1:
_LOGGER.error("Couldn't get valid target reading") _LOGGER.error('%s (%s) was busy (temp == -1)', self._name,
return self.device.host)
self._target_temperature = target_temp return
self._current_operation = STATE_HEAT
elif self._tmode == 'Auto': # Map thermostat values into various STATE_ flags.
if self._tstate == 'Cool': self._current_temperature = current_temp
target_temp = self.device.t_cool['raw'] self._fmode = CODE_TO_FAN_MODE[data['fmode']]
if target_temp == -1: self._fstate = CODE_TO_FAN_STATE[data['fstate']]
_LOGGER.error("Couldn't get valid target reading") self._tmode = CODE_TO_TEMP_MODE[data['tmode']]
return self._tstate = CODE_TO_TEMP_STATE[data['tstate']]
self._target_temperature = target_temp
elif self._tstate == 'Heat': self._current_operation = self._tmode
target_temp = self.device.t_heat['raw'] if self._tmode == STATE_COOL:
if target_temp == -1: self._target_temperature = data['t_cool']
_LOGGER.error("Couldn't get valid target reading") elif self._tmode == STATE_HEAT:
return self._target_temperature = data['t_heat']
self._target_temperature = target_temp elif self._tmode == STATE_AUTO:
self._current_operation = STATE_AUTO # This doesn't really work - tstate is only set if the HVAC is
# active. If it's idle, we don't know what to do with the target
# temperature.
if self._tstate == STATE_COOL:
self._target_temperature = data['t_cool']
elif self._tstate == STATE_HEAT:
self._target_temperature = data['t_heat']
else: else:
self._current_operation = STATE_IDLE self._current_operation = STATE_IDLE
@ -191,23 +265,32 @@ class RadioThermostat(ClimateDevice):
temperature = kwargs.get(ATTR_TEMPERATURE) temperature = kwargs.get(ATTR_TEMPERATURE)
if temperature is None: if temperature is None:
return return
if self._current_operation == STATE_COOL:
self.device.t_cool = round(temperature * 2.0) / 2.0
elif self._current_operation == STATE_HEAT:
self.device.t_heat = round(temperature * 2.0) / 2.0
elif self._current_operation == STATE_AUTO:
if self._tstate == 'Cool':
self.device.t_cool = round(temperature * 2.0) / 2.0
elif self._tstate == 'Heat':
self.device.t_heat = round(temperature * 2.0) / 2.0
if self._hold_temp or self._away: temperature = round_temp(temperature)
self.device.hold = 1
else: if self._current_operation == STATE_COOL:
self.device.hold = 0 self.device.t_cool = temperature
elif self._current_operation == STATE_HEAT:
self.device.t_heat = temperature
elif self._current_operation == STATE_AUTO:
if self._tstate == STATE_COOL:
self.device.t_cool = temperature
elif self._tstate == STATE_HEAT:
self.device.t_heat = temperature
# Only change the hold if requested or if hold mode was turned
# on and we haven't set it yet.
if kwargs.get('hold_changed', False) or not self._hold_set:
if self._hold_temp or self._away:
self.device.hold = 1
self._hold_set = True
else:
self.device.hold = 0
def set_time(self): def set_time(self):
"""Set device time.""" """Set device time."""
# Calling this clears any local temperature override and
# reverts to the scheduled temperature.
now = datetime.datetime.now() now = datetime.datetime.now()
self.device.time = { self.device.time = {
'day': now.weekday(), 'day': now.weekday(),
@ -217,14 +300,14 @@ class RadioThermostat(ClimateDevice):
def set_operation_mode(self, operation_mode): def set_operation_mode(self, operation_mode):
"""Set operation mode (auto, cool, heat, off).""" """Set operation mode (auto, cool, heat, off)."""
if operation_mode == STATE_OFF: if operation_mode == STATE_OFF or operation_mode == STATE_AUTO:
self.device.tmode = 0 self.device.tmode = TEMP_MODE_TO_CODE[operation_mode]
elif operation_mode == STATE_AUTO:
self.device.tmode = 3 # Setting t_cool or t_heat automatically changes tmode.
elif operation_mode == STATE_COOL: elif operation_mode == STATE_COOL:
self.device.t_cool = round(self._target_temperature * 2.0) / 2.0 self.device.t_cool = self._target_temperature
elif operation_mode == STATE_HEAT: elif operation_mode == STATE_HEAT:
self.device.t_heat = round(self._target_temperature * 2.0) / 2.0 self.device.t_heat = self._target_temperature
def turn_away_mode_on(self): def turn_away_mode_on(self):
"""Turn away on. """Turn away on.
@ -238,10 +321,11 @@ class RadioThermostat(ClimateDevice):
away_temp = self._away_temps[0] away_temp = self._away_temps[0]
elif self._current_operation == STATE_COOL: elif self._current_operation == STATE_COOL:
away_temp = self._away_temps[1] away_temp = self._away_temps[1]
self._away = True self._away = True
self.set_temperature(temperature=away_temp) self.set_temperature(temperature=away_temp, hold_changed=True)
def turn_away_mode_off(self): def turn_away_mode_off(self):
"""Turn away off.""" """Turn away off."""
self._away = False self._away = False
self.set_temperature(temperature=self._prev_temp) self.set_temperature(temperature=self._prev_temp, hold_changed=True)