Migrate Thermostat and HVAC component to climate component (#2825)

* First draft for climate

* Updates for thermostats

homeassistant/components/climate/generic_thermostat.py

@@ -0,0 +1,216 @@
+"""
+Adds support for generic thermostat units.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/climate.generic_thermostat/
+"""
+import logging
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.components import switch
+from homeassistant.components.climate import (
+    STATE_HEAT, STATE_COOL, STATE_IDLE, ClimateDevice)
+from homeassistant.const import ATTR_UNIT_OF_MEASUREMENT, STATE_ON, STATE_OFF
+from homeassistant.helpers import condition
+from homeassistant.helpers.event import track_state_change
+
+DEPENDENCIES = ['switch', 'sensor']
+
+TOL_TEMP = 0.3
+
+CONF_NAME = 'name'
+DEFAULT_NAME = 'Generic Thermostat'
+CONF_HEATER = 'heater'
+CONF_SENSOR = 'target_sensor'
+CONF_MIN_TEMP = 'min_temp'
+CONF_MAX_TEMP = 'max_temp'
+CONF_TARGET_TEMP = 'target_temp'
+CONF_AC_MODE = 'ac_mode'
+CONF_MIN_DUR = 'min_cycle_duration'
+
+_LOGGER = logging.getLogger(__name__)
+
+PLATFORM_SCHEMA = vol.Schema({
+    vol.Required("platform"): "generic_thermostat",
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+    vol.Required(CONF_HEATER): cv.entity_id,
+    vol.Required(CONF_SENSOR): cv.entity_id,
+    vol.Optional(CONF_MIN_TEMP): vol.Coerce(float),
+    vol.Optional(CONF_MAX_TEMP): vol.Coerce(float),
+    vol.Optional(CONF_TARGET_TEMP): vol.Coerce(float),
+    vol.Optional(CONF_AC_MODE): vol.Coerce(bool),
+    vol.Optional(CONF_MIN_DUR): vol.All(cv.time_period, cv.positive_timedelta),
+})
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Setup the generic thermostat."""
+    name = config.get(CONF_NAME)
+    heater_entity_id = config.get(CONF_HEATER)
+    sensor_entity_id = config.get(CONF_SENSOR)
+    min_temp = config.get(CONF_MIN_TEMP)
+    max_temp = config.get(CONF_MAX_TEMP)
+    target_temp = config.get(CONF_TARGET_TEMP)
+    ac_mode = config.get(CONF_AC_MODE)
+    min_cycle_duration = config.get(CONF_MIN_DUR)
+
+    add_devices([GenericThermostat(hass, name, heater_entity_id,
+                                   sensor_entity_id, min_temp,
+                                   max_temp, target_temp, ac_mode,
+                                   min_cycle_duration)])
+
+
+# pylint: disable=too-many-instance-attributes, abstract-method
+class GenericThermostat(ClimateDevice):
+    """Representation of a GenericThermostat device."""
+
+    # pylint: disable=too-many-arguments
+    def __init__(self, hass, name, heater_entity_id, sensor_entity_id,
+                 min_temp, max_temp, target_temp, ac_mode, min_cycle_duration):
+        """Initialize the thermostat."""
+        self.hass = hass
+        self._name = name
+        self.heater_entity_id = heater_entity_id
+        self.ac_mode = ac_mode
+        self.min_cycle_duration = min_cycle_duration
+
+        self._active = False
+        self._cur_temp = None
+        self._min_temp = min_temp
+        self._max_temp = max_temp
+        self._target_temp = target_temp
+        self._unit = hass.config.units.temperature_unit
+
+        track_state_change(hass, sensor_entity_id, self._sensor_changed)
+
+        sensor_state = hass.states.get(sensor_entity_id)
+        if sensor_state:
+            self._update_temp(sensor_state)
+
+    @property
+    def should_poll(self):
+        """No polling needed."""
+        return False
+
+    @property
+    def name(self):
+        """Return the name of the thermostat."""
+        return self._name
+
+    @property
+    def unit_of_measurement(self):
+        """Return the unit of measurement."""
+        return self._unit
+
+    @property
+    def current_temperature(self):
+        """Return the sensor temperature."""
+        return self._cur_temp
+
+    @property
+    def operation(self):
+        """Return current operation ie. heat, cool, idle."""
+        if self.ac_mode:
+            cooling = self._active and self._is_device_active
+            return STATE_COOL if cooling else STATE_IDLE
+        else:
+            heating = self._active and self._is_device_active
+            return STATE_HEAT if heating else STATE_IDLE
+
+    @property
+    def target_temperature(self):
+        """Return the temperature we try to reach."""
+        return self._target_temp
+
+    def set_temperature(self, temperature):
+        """Set new target temperature."""
+        self._target_temp = temperature
+        self._control_heating()
+        self.update_ha_state()
+
+    @property
+    def min_temp(self):
+        """Return the minimum temperature."""
+        # pylint: disable=no-member
+        if self._min_temp:
+            return self._min_temp
+        else:
+            # get default temp from super class
+            return ClimateDevice.min_temp.fget(self)
+
+    @property
+    def max_temp(self):
+        """Return the maximum temperature."""
+        # pylint: disable=no-member
+        if self._min_temp:
+            return self._max_temp
+        else:
+            # Get default temp from super class
+            return ClimateDevice.max_temp.fget(self)
+
+    def _sensor_changed(self, entity_id, old_state, new_state):
+        """Called when temperature changes."""
+        if new_state is None:
+            return
+
+        self._update_temp(new_state)
+        self._control_heating()
+        self.update_ha_state()
+
+    def _update_temp(self, state):
+        """Update thermostat with latest state from sensor."""
+        unit = state.attributes.get(ATTR_UNIT_OF_MEASUREMENT)
+
+        try:
+            self._cur_temp = self.hass.config.units.temperature(
+                float(state.state), unit)
+        except ValueError as ex:
+            _LOGGER.error('Unable to update from sensor: %s', ex)
+
+    def _control_heating(self):
+        """Check if we need to turn heating on or off."""
+        if not self._active and None not in (self._cur_temp,
+                                             self._target_temp):
+            self._active = True
+            _LOGGER.info('Obtained current and target temperature. '
+                         'Generic thermostat active.')
+
+        if not self._active:
+            return
+
+        if self.min_cycle_duration:
+            if self._is_device_active:
+                current_state = STATE_ON
+            else:
+                current_state = STATE_OFF
+            long_enough = condition.state(self.hass, self.heater_entity_id,
+                                          current_state,
+                                          self.min_cycle_duration)
+            if not long_enough:
+                return
+
+        if self.ac_mode:
+            too_hot = self._cur_temp - self._target_temp > TOL_TEMP
+            is_cooling = self._is_device_active
+            if too_hot and not is_cooling:
+                _LOGGER.info('Turning on AC %s', self.heater_entity_id)
+                switch.turn_on(self.hass, self.heater_entity_id)
+            elif not too_hot and is_cooling:
+                _LOGGER.info('Turning off AC %s', self.heater_entity_id)
+                switch.turn_off(self.hass, self.heater_entity_id)
+        else:
+            too_cold = self._target_temp - self._cur_temp > TOL_TEMP
+            is_heating = self._is_device_active
+
+            if too_cold and not is_heating:
+                _LOGGER.info('Turning on heater %s', self.heater_entity_id)
+                switch.turn_on(self.hass, self.heater_entity_id)
+            elif not too_cold and is_heating:
+                _LOGGER.info('Turning off heater %s', self.heater_entity_id)
+                switch.turn_off(self.hass, self.heater_entity_id)
+
+    @property
+    def _is_device_active(self):
+        """If the toggleable device is currently active."""
+        return switch.is_on(self.hass, self.heater_entity_id)