246 lines
11 KiB
Python
246 lines
11 KiB
Python
"""Class to hold all thermostat accessories."""
|
|
import logging
|
|
|
|
from homeassistant.components.climate import (
|
|
ATTR_CURRENT_TEMPERATURE, ATTR_TEMPERATURE,
|
|
ATTR_TARGET_TEMP_HIGH, ATTR_TARGET_TEMP_LOW,
|
|
ATTR_OPERATION_MODE, ATTR_OPERATION_LIST,
|
|
STATE_HEAT, STATE_COOL, STATE_AUTO)
|
|
from homeassistant.const import (
|
|
ATTR_ENTITY_ID, ATTR_UNIT_OF_MEASUREMENT,
|
|
TEMP_CELSIUS, TEMP_FAHRENHEIT)
|
|
from homeassistant.helpers.event import async_track_state_change
|
|
|
|
from . import TYPES
|
|
from .accessories import HomeAccessory, add_preload_service
|
|
from .const import (
|
|
SERV_THERMOSTAT, CHAR_CURRENT_HEATING_COOLING,
|
|
CHAR_TARGET_HEATING_COOLING, CHAR_CURRENT_TEMPERATURE,
|
|
CHAR_TARGET_TEMPERATURE, CHAR_TEMP_DISPLAY_UNITS,
|
|
CHAR_COOLING_THRESHOLD_TEMPERATURE, CHAR_HEATING_THRESHOLD_TEMPERATURE)
|
|
|
|
_LOGGER = logging.getLogger(__name__)
|
|
|
|
STATE_OFF = 'off'
|
|
UNIT_HASS_TO_HOMEKIT = {TEMP_CELSIUS: 0, TEMP_FAHRENHEIT: 1}
|
|
UNIT_HOMEKIT_TO_HASS = {c: s for s, c in UNIT_HASS_TO_HOMEKIT.items()}
|
|
HC_HASS_TO_HOMEKIT = {STATE_OFF: 0, STATE_HEAT: 1,
|
|
STATE_COOL: 2, STATE_AUTO: 3}
|
|
HC_HOMEKIT_TO_HASS = {c: s for s, c in HC_HASS_TO_HOMEKIT.items()}
|
|
|
|
|
|
@TYPES.register('Thermostat')
|
|
class Thermostat(HomeAccessory):
|
|
"""Generate a Thermostat accessory for a climate."""
|
|
|
|
def __init__(self, hass, entity_id, display_name, support_auto=False):
|
|
"""Initialize a Thermostat accessory object."""
|
|
super().__init__(display_name, entity_id, 'THERMOSTAT')
|
|
|
|
self._hass = hass
|
|
self._entity_id = entity_id
|
|
self._call_timer = None
|
|
|
|
self.heat_cool_flag_target_state = False
|
|
self.temperature_flag_target_state = False
|
|
self.coolingthresh_flag_target_state = False
|
|
self.heatingthresh_flag_target_state = False
|
|
|
|
extra_chars = None
|
|
# Add additional characteristics if auto mode is supported
|
|
if support_auto:
|
|
extra_chars = [CHAR_COOLING_THRESHOLD_TEMPERATURE,
|
|
CHAR_HEATING_THRESHOLD_TEMPERATURE]
|
|
|
|
# Preload the thermostat service
|
|
self.service_thermostat = add_preload_service(self, SERV_THERMOSTAT,
|
|
extra_chars)
|
|
|
|
# Current and target mode characteristics
|
|
self.char_current_heat_cool = self.service_thermostat. \
|
|
get_characteristic(CHAR_CURRENT_HEATING_COOLING)
|
|
self.char_current_heat_cool.value = 0
|
|
self.char_target_heat_cool = self.service_thermostat. \
|
|
get_characteristic(CHAR_TARGET_HEATING_COOLING)
|
|
self.char_target_heat_cool.value = 0
|
|
self.char_target_heat_cool.setter_callback = self.set_heat_cool
|
|
|
|
# Current and target temperature characteristics
|
|
self.char_current_temp = self.service_thermostat. \
|
|
get_characteristic(CHAR_CURRENT_TEMPERATURE)
|
|
self.char_current_temp.value = 21.0
|
|
self.char_target_temp = self.service_thermostat. \
|
|
get_characteristic(CHAR_TARGET_TEMPERATURE)
|
|
self.char_target_temp.value = 21.0
|
|
self.char_target_temp.setter_callback = self.set_target_temperature
|
|
|
|
# Display units characteristic
|
|
self.char_display_units = self.service_thermostat. \
|
|
get_characteristic(CHAR_TEMP_DISPLAY_UNITS)
|
|
self.char_display_units.value = 0
|
|
|
|
# If the device supports it: high and low temperature characteristics
|
|
if support_auto:
|
|
self.char_cooling_thresh_temp = self.service_thermostat. \
|
|
get_characteristic(CHAR_COOLING_THRESHOLD_TEMPERATURE)
|
|
self.char_cooling_thresh_temp.value = 23.0
|
|
self.char_cooling_thresh_temp.setter_callback = \
|
|
self.set_cooling_threshold
|
|
|
|
self.char_heating_thresh_temp = self.service_thermostat. \
|
|
get_characteristic(CHAR_HEATING_THRESHOLD_TEMPERATURE)
|
|
self.char_heating_thresh_temp.value = 19.0
|
|
self.char_heating_thresh_temp.setter_callback = \
|
|
self.set_heating_threshold
|
|
else:
|
|
self.char_cooling_thresh_temp = None
|
|
self.char_heating_thresh_temp = None
|
|
|
|
def run(self):
|
|
"""Method called be object after driver is started."""
|
|
state = self._hass.states.get(self._entity_id)
|
|
self.update_thermostat(new_state=state)
|
|
|
|
async_track_state_change(self._hass, self._entity_id,
|
|
self.update_thermostat)
|
|
|
|
def set_heat_cool(self, value):
|
|
"""Move operation mode to value if call came from HomeKit."""
|
|
if value in HC_HOMEKIT_TO_HASS:
|
|
_LOGGER.debug("%s: Set heat-cool to %d", self._entity_id, value)
|
|
self.heat_cool_flag_target_state = True
|
|
hass_value = HC_HOMEKIT_TO_HASS[value]
|
|
self._hass.services.call('climate', 'set_operation_mode',
|
|
{ATTR_ENTITY_ID: self._entity_id,
|
|
ATTR_OPERATION_MODE: hass_value})
|
|
|
|
def set_cooling_threshold(self, value):
|
|
"""Set cooling threshold temp to value if call came from HomeKit."""
|
|
_LOGGER.debug("%s: Set cooling threshold temperature to %.2f",
|
|
self._entity_id, value)
|
|
self.coolingthresh_flag_target_state = True
|
|
low = self.char_heating_thresh_temp.get_value()
|
|
self._hass.services.call(
|
|
'climate', 'set_temperature',
|
|
{ATTR_ENTITY_ID: self._entity_id,
|
|
ATTR_TARGET_TEMP_HIGH: value,
|
|
ATTR_TARGET_TEMP_LOW: low})
|
|
|
|
def set_heating_threshold(self, value):
|
|
"""Set heating threshold temp to value if call came from HomeKit."""
|
|
_LOGGER.debug("%s: Set heating threshold temperature to %.2f",
|
|
self._entity_id, value)
|
|
self.heatingthresh_flag_target_state = True
|
|
# Home assistant always wants to set low and high at the same time
|
|
high = self.char_cooling_thresh_temp.get_value()
|
|
self._hass.services.call(
|
|
'climate', 'set_temperature',
|
|
{ATTR_ENTITY_ID: self._entity_id,
|
|
ATTR_TARGET_TEMP_LOW: value,
|
|
ATTR_TARGET_TEMP_HIGH: high})
|
|
|
|
def set_target_temperature(self, value):
|
|
"""Set target temperature to value if call came from HomeKit."""
|
|
_LOGGER.debug("%s: Set target temperature to %.2f",
|
|
self._entity_id, value)
|
|
self.temperature_flag_target_state = True
|
|
self._hass.services.call(
|
|
'climate', 'set_temperature',
|
|
{ATTR_ENTITY_ID: self._entity_id,
|
|
ATTR_TEMPERATURE: value})
|
|
|
|
def update_thermostat(self, entity_id=None,
|
|
old_state=None, new_state=None):
|
|
"""Update security state after state changed."""
|
|
if new_state is None:
|
|
return
|
|
|
|
# Update current temperature
|
|
current_temp = new_state.attributes.get(ATTR_CURRENT_TEMPERATURE)
|
|
if isinstance(current_temp, (int, float)):
|
|
self.char_current_temp.set_value(current_temp)
|
|
|
|
# Update target temperature
|
|
target_temp = new_state.attributes.get(ATTR_TEMPERATURE)
|
|
if isinstance(target_temp, (int, float)):
|
|
if not self.temperature_flag_target_state:
|
|
self.char_target_temp.set_value(target_temp,
|
|
should_callback=False)
|
|
else:
|
|
self.temperature_flag_target_state = False
|
|
|
|
# Update cooling threshold temperature if characteristic exists
|
|
if self.char_cooling_thresh_temp is not None:
|
|
cooling_thresh = new_state.attributes.get(ATTR_TARGET_TEMP_HIGH)
|
|
if cooling_thresh is not None:
|
|
if not self.coolingthresh_flag_target_state:
|
|
self.char_cooling_thresh_temp.set_value(
|
|
cooling_thresh, should_callback=False)
|
|
else:
|
|
self.coolingthresh_flag_target_state = False
|
|
|
|
# Update heating threshold temperature if characteristic exists
|
|
if self.char_heating_thresh_temp is not None:
|
|
heating_thresh = new_state.attributes.get(ATTR_TARGET_TEMP_LOW)
|
|
if heating_thresh is not None:
|
|
if not self.heatingthresh_flag_target_state:
|
|
self.char_heating_thresh_temp.set_value(
|
|
heating_thresh, should_callback=False)
|
|
else:
|
|
self.heatingthresh_flag_target_state = False
|
|
|
|
# Update display units
|
|
display_units = new_state.attributes.get(ATTR_UNIT_OF_MEASUREMENT)
|
|
if display_units is not None \
|
|
and display_units in UNIT_HASS_TO_HOMEKIT:
|
|
self.char_display_units.set_value(
|
|
UNIT_HASS_TO_HOMEKIT[display_units])
|
|
|
|
# Update target operation mode
|
|
operation_mode = new_state.attributes.get(ATTR_OPERATION_MODE)
|
|
if operation_mode is not None \
|
|
and operation_mode in HC_HASS_TO_HOMEKIT:
|
|
if not self.heat_cool_flag_target_state:
|
|
self.char_target_heat_cool.set_value(
|
|
HC_HASS_TO_HOMEKIT[operation_mode], should_callback=False)
|
|
else:
|
|
self.heat_cool_flag_target_state = False
|
|
|
|
# Set current operation mode based on temperatures and target mode
|
|
if operation_mode == STATE_HEAT:
|
|
if current_temp < target_temp:
|
|
current_operation_mode = STATE_HEAT
|
|
else:
|
|
current_operation_mode = STATE_OFF
|
|
elif operation_mode == STATE_COOL:
|
|
if current_temp > target_temp:
|
|
current_operation_mode = STATE_COOL
|
|
else:
|
|
current_operation_mode = STATE_OFF
|
|
elif operation_mode == STATE_AUTO:
|
|
# Check if auto is supported
|
|
if self.char_cooling_thresh_temp is not None:
|
|
lower_temp = self.char_heating_thresh_temp.get_value()
|
|
upper_temp = self.char_cooling_thresh_temp.get_value()
|
|
if current_temp < lower_temp:
|
|
current_operation_mode = STATE_HEAT
|
|
elif current_temp > upper_temp:
|
|
current_operation_mode = STATE_COOL
|
|
else:
|
|
current_operation_mode = STATE_OFF
|
|
else:
|
|
# Check if heating or cooling are supported
|
|
heat = STATE_HEAT in new_state.attributes[ATTR_OPERATION_LIST]
|
|
cool = STATE_COOL in new_state.attributes[ATTR_OPERATION_LIST]
|
|
if current_temp < target_temp and heat:
|
|
current_operation_mode = STATE_HEAT
|
|
elif current_temp > target_temp and cool:
|
|
current_operation_mode = STATE_COOL
|
|
else:
|
|
current_operation_mode = STATE_OFF
|
|
else:
|
|
current_operation_mode = STATE_OFF
|
|
|
|
self.char_current_heat_cool.set_value(
|
|
HC_HASS_TO_HOMEKIT[current_operation_mode])
|