521 lines
16 KiB
Python
521 lines
16 KiB
Python
"""Support for Wink thermostats and Air Conditioners."""
|
|
import logging
|
|
|
|
import pywink
|
|
|
|
from homeassistant.components.climate import ClimateEntity
|
|
from homeassistant.components.climate.const import (
|
|
ATTR_TARGET_TEMP_HIGH,
|
|
ATTR_TARGET_TEMP_LOW,
|
|
CURRENT_HVAC_COOL,
|
|
CURRENT_HVAC_HEAT,
|
|
CURRENT_HVAC_IDLE,
|
|
CURRENT_HVAC_OFF,
|
|
FAN_AUTO,
|
|
FAN_HIGH,
|
|
FAN_LOW,
|
|
FAN_MEDIUM,
|
|
FAN_ON,
|
|
HVAC_MODE_AUTO,
|
|
HVAC_MODE_COOL,
|
|
HVAC_MODE_FAN_ONLY,
|
|
HVAC_MODE_HEAT,
|
|
HVAC_MODE_OFF,
|
|
PRESET_AWAY,
|
|
PRESET_ECO,
|
|
PRESET_NONE,
|
|
SUPPORT_AUX_HEAT,
|
|
SUPPORT_FAN_MODE,
|
|
SUPPORT_PRESET_MODE,
|
|
SUPPORT_TARGET_TEMPERATURE,
|
|
SUPPORT_TARGET_TEMPERATURE_RANGE,
|
|
)
|
|
from homeassistant.const import ATTR_TEMPERATURE, PRECISION_TENTHS, TEMP_CELSIUS
|
|
from homeassistant.helpers.temperature import display_temp as show_temp
|
|
|
|
from . import DOMAIN, WinkDevice
|
|
|
|
_LOGGER = logging.getLogger(__name__)
|
|
|
|
ATTR_ECO_TARGET = "eco_target"
|
|
ATTR_EXTERNAL_TEMPERATURE = "external_temperature"
|
|
ATTR_OCCUPIED = "occupied"
|
|
ATTR_SCHEDULE_ENABLED = "schedule_enabled"
|
|
ATTR_SMART_TEMPERATURE = "smart_temperature"
|
|
ATTR_TOTAL_CONSUMPTION = "total_consumption"
|
|
|
|
HA_HVAC_TO_WINK = {
|
|
HVAC_MODE_AUTO: "auto",
|
|
HVAC_MODE_COOL: "cool_only",
|
|
HVAC_MODE_FAN_ONLY: "fan_only",
|
|
HVAC_MODE_HEAT: "heat_only",
|
|
HVAC_MODE_OFF: "off",
|
|
}
|
|
|
|
WINK_HVAC_TO_HA = {value: key for key, value in HA_HVAC_TO_WINK.items()}
|
|
|
|
SUPPORT_FLAGS_THERMOSTAT = (
|
|
SUPPORT_TARGET_TEMPERATURE
|
|
| SUPPORT_TARGET_TEMPERATURE_RANGE
|
|
| SUPPORT_FAN_MODE
|
|
| SUPPORT_AUX_HEAT
|
|
)
|
|
SUPPORT_FAN_THERMOSTAT = [FAN_AUTO, FAN_ON]
|
|
SUPPORT_PRESET_THERMOSTAT = [PRESET_AWAY, PRESET_ECO]
|
|
|
|
SUPPORT_FLAGS_AC = SUPPORT_TARGET_TEMPERATURE | SUPPORT_FAN_MODE | SUPPORT_PRESET_MODE
|
|
SUPPORT_FAN_AC = [FAN_HIGH, FAN_LOW, FAN_MEDIUM]
|
|
SUPPORT_PRESET_AC = [PRESET_NONE, PRESET_ECO]
|
|
|
|
|
|
def setup_platform(hass, config, add_entities, discovery_info=None):
|
|
"""Set up the Wink climate devices."""
|
|
for climate in pywink.get_thermostats():
|
|
_id = climate.object_id() + climate.name()
|
|
if _id not in hass.data[DOMAIN]["unique_ids"]:
|
|
add_entities([WinkThermostat(climate, hass)])
|
|
for climate in pywink.get_air_conditioners():
|
|
_id = climate.object_id() + climate.name()
|
|
if _id not in hass.data[DOMAIN]["unique_ids"]:
|
|
add_entities([WinkAC(climate, hass)])
|
|
|
|
|
|
class WinkThermostat(WinkDevice, ClimateEntity):
|
|
"""Representation of a Wink thermostat."""
|
|
|
|
@property
|
|
def supported_features(self):
|
|
"""Return the list of supported features."""
|
|
return SUPPORT_FLAGS_THERMOSTAT
|
|
|
|
async def async_added_to_hass(self):
|
|
"""Call when entity is added to hass."""
|
|
self.hass.data[DOMAIN]["entities"]["climate"].append(self)
|
|
|
|
@property
|
|
def temperature_unit(self):
|
|
"""Return the unit of measurement."""
|
|
# The Wink API always returns temp in Celsius
|
|
return TEMP_CELSIUS
|
|
|
|
@property
|
|
def device_state_attributes(self):
|
|
"""Return the optional device state attributes."""
|
|
data = {}
|
|
if self.external_temperature is not None:
|
|
data[ATTR_EXTERNAL_TEMPERATURE] = show_temp(
|
|
self.hass,
|
|
self.external_temperature,
|
|
self.temperature_unit,
|
|
PRECISION_TENTHS,
|
|
)
|
|
|
|
if self.smart_temperature:
|
|
data[ATTR_SMART_TEMPERATURE] = self.smart_temperature
|
|
|
|
if self.occupied is not None:
|
|
data[ATTR_OCCUPIED] = self.occupied
|
|
|
|
if self.eco_target is not None:
|
|
data[ATTR_ECO_TARGET] = self.eco_target
|
|
|
|
return data
|
|
|
|
@property
|
|
def current_temperature(self):
|
|
"""Return the current temperature."""
|
|
return self.wink.current_temperature()
|
|
|
|
@property
|
|
def current_humidity(self):
|
|
"""Return the current humidity."""
|
|
if self.wink.current_humidity() is not None:
|
|
# The API states humidity will be a float 0-1
|
|
# the only example API response with humidity listed show an int
|
|
# This will address both possibilities
|
|
if self.wink.current_humidity() < 1:
|
|
return self.wink.current_humidity() * 100
|
|
return self.wink.current_humidity()
|
|
return None
|
|
|
|
@property
|
|
def external_temperature(self):
|
|
"""Return the current external temperature."""
|
|
return self.wink.current_external_temperature()
|
|
|
|
@property
|
|
def smart_temperature(self):
|
|
"""Return the current average temp of all remote sensor."""
|
|
return self.wink.current_smart_temperature()
|
|
|
|
@property
|
|
def eco_target(self):
|
|
"""Return status of eco target (Is the thermostat in eco mode)."""
|
|
return self.wink.eco_target()
|
|
|
|
@property
|
|
def occupied(self):
|
|
"""Return status of if the thermostat has detected occupancy."""
|
|
return self.wink.occupied()
|
|
|
|
@property
|
|
def preset_mode(self):
|
|
"""Return the current preset mode, e.g., home, away, temp."""
|
|
mode = self.wink.current_hvac_mode()
|
|
if mode == "eco":
|
|
return PRESET_ECO
|
|
if self.wink.away():
|
|
return PRESET_AWAY
|
|
return None
|
|
|
|
@property
|
|
def preset_modes(self):
|
|
"""Return a list of available preset modes."""
|
|
return SUPPORT_PRESET_THERMOSTAT
|
|
|
|
@property
|
|
def target_humidity(self):
|
|
"""Return the humidity we try to reach."""
|
|
target_hum = None
|
|
if self.wink.current_humidifier_mode() == "on":
|
|
if self.wink.current_humidifier_set_point() is not None:
|
|
target_hum = self.wink.current_humidifier_set_point() * 100
|
|
elif self.wink.current_dehumidifier_mode() == "on":
|
|
if self.wink.current_dehumidifier_set_point() is not None:
|
|
target_hum = self.wink.current_dehumidifier_set_point() * 100
|
|
else:
|
|
target_hum = None
|
|
return target_hum
|
|
|
|
@property
|
|
def target_temperature(self):
|
|
"""Return the temperature we try to reach."""
|
|
if self.hvac_mode != HVAC_MODE_AUTO and not self.wink.away():
|
|
if self.hvac_mode == HVAC_MODE_COOL:
|
|
return self.wink.current_max_set_point()
|
|
if self.hvac_mode == HVAC_MODE_HEAT:
|
|
return self.wink.current_min_set_point()
|
|
return None
|
|
|
|
@property
|
|
def target_temperature_low(self):
|
|
"""Return the lower bound temperature we try to reach."""
|
|
if self.hvac_mode == HVAC_MODE_AUTO:
|
|
return self.wink.current_min_set_point()
|
|
return None
|
|
|
|
@property
|
|
def target_temperature_high(self):
|
|
"""Return the higher bound temperature we try to reach."""
|
|
if self.hvac_mode == HVAC_MODE_AUTO:
|
|
return self.wink.current_max_set_point()
|
|
return None
|
|
|
|
@property
|
|
def is_aux_heat(self):
|
|
"""Return true if aux heater."""
|
|
if "aux" not in self.wink.hvac_modes():
|
|
return None
|
|
if self.wink.current_hvac_mode() == "aux":
|
|
return True
|
|
return False
|
|
|
|
@property
|
|
def hvac_mode(self) -> str:
|
|
"""Return hvac operation ie. heat, cool mode.
|
|
|
|
Need to be one of HVAC_MODE_*.
|
|
"""
|
|
if not self.wink.is_on():
|
|
return HVAC_MODE_OFF
|
|
|
|
wink_mode = self.wink.current_hvac_mode()
|
|
if wink_mode == "aux":
|
|
return HVAC_MODE_HEAT
|
|
if wink_mode == "eco":
|
|
return HVAC_MODE_AUTO
|
|
return WINK_HVAC_TO_HA.get(wink_mode)
|
|
|
|
@property
|
|
def hvac_modes(self):
|
|
"""Return the list of available hvac operation modes.
|
|
|
|
Need to be a subset of HVAC_MODES.
|
|
"""
|
|
hvac_list = [HVAC_MODE_OFF]
|
|
|
|
modes = self.wink.hvac_modes()
|
|
for mode in modes:
|
|
if mode in ("eco", "aux"):
|
|
continue
|
|
try:
|
|
ha_mode = WINK_HVAC_TO_HA[mode]
|
|
hvac_list.append(ha_mode)
|
|
except KeyError:
|
|
_LOGGER.error(
|
|
"Invalid operation mode mapping. %s doesn't map. "
|
|
"Please report this.",
|
|
mode,
|
|
)
|
|
return hvac_list
|
|
|
|
@property
|
|
def hvac_action(self):
|
|
"""Return the current running hvac operation if supported.
|
|
|
|
Need to be one of CURRENT_HVAC_*.
|
|
"""
|
|
if not self.wink.is_on():
|
|
return CURRENT_HVAC_OFF
|
|
if self.wink.cool_on():
|
|
return CURRENT_HVAC_COOL
|
|
if self.wink.heat_on():
|
|
return CURRENT_HVAC_HEAT
|
|
return CURRENT_HVAC_IDLE
|
|
|
|
def set_temperature(self, **kwargs):
|
|
"""Set new target temperature."""
|
|
target_temp = kwargs.get(ATTR_TEMPERATURE)
|
|
target_temp_low = kwargs.get(ATTR_TARGET_TEMP_LOW)
|
|
target_temp_high = kwargs.get(ATTR_TARGET_TEMP_HIGH)
|
|
if target_temp is not None:
|
|
if self.hvac_mode == HVAC_MODE_COOL:
|
|
target_temp_high = target_temp
|
|
if self.hvac_mode == HVAC_MODE_HEAT:
|
|
target_temp_low = target_temp
|
|
self.wink.set_temperature(target_temp_low, target_temp_high)
|
|
|
|
def set_hvac_mode(self, hvac_mode):
|
|
"""Set new target hvac mode."""
|
|
hvac_mode_to_set = HA_HVAC_TO_WINK.get(hvac_mode)
|
|
self.wink.set_operation_mode(hvac_mode_to_set)
|
|
|
|
def set_preset_mode(self, preset_mode):
|
|
"""Set new preset mode."""
|
|
# Away
|
|
if preset_mode != PRESET_AWAY and self.wink.away():
|
|
self.wink.set_away_mode(False)
|
|
elif preset_mode == PRESET_AWAY:
|
|
self.wink.set_away_mode()
|
|
|
|
if preset_mode == PRESET_ECO:
|
|
self.wink.set_operation_mode("eco")
|
|
|
|
@property
|
|
def fan_mode(self):
|
|
"""Return whether the fan is on."""
|
|
if self.wink.current_fan_mode() == "on":
|
|
return FAN_ON
|
|
if self.wink.current_fan_mode() == "auto":
|
|
return FAN_AUTO
|
|
# No Fan available so disable slider
|
|
return None
|
|
|
|
@property
|
|
def fan_modes(self):
|
|
"""List of available fan modes."""
|
|
if self.wink.has_fan():
|
|
return SUPPORT_FAN_THERMOSTAT
|
|
return None
|
|
|
|
def set_fan_mode(self, fan_mode):
|
|
"""Turn fan on/off."""
|
|
self.wink.set_fan_mode(fan_mode.lower())
|
|
|
|
def turn_aux_heat_on(self):
|
|
"""Turn auxiliary heater on."""
|
|
self.wink.set_operation_mode("aux")
|
|
|
|
def turn_aux_heat_off(self):
|
|
"""Turn auxiliary heater off."""
|
|
self.wink.set_operation_mode("heat_only")
|
|
|
|
@property
|
|
def min_temp(self):
|
|
"""Return the minimum temperature."""
|
|
minimum = 7 # Default minimum
|
|
min_min = self.wink.min_min_set_point()
|
|
min_max = self.wink.min_max_set_point()
|
|
if self.hvac_mode == HVAC_MODE_HEAT:
|
|
if min_min:
|
|
return_value = min_min
|
|
else:
|
|
return_value = minimum
|
|
elif self.hvac_mode == HVAC_MODE_COOL:
|
|
if min_max:
|
|
return_value = min_max
|
|
else:
|
|
return_value = minimum
|
|
elif self.hvac_mode == HVAC_MODE_AUTO:
|
|
if min_min and min_max:
|
|
return_value = min(min_min, min_max)
|
|
else:
|
|
return_value = minimum
|
|
else:
|
|
return_value = minimum
|
|
return return_value
|
|
|
|
@property
|
|
def max_temp(self):
|
|
"""Return the maximum temperature."""
|
|
maximum = 35 # Default maximum
|
|
max_min = self.wink.max_min_set_point()
|
|
max_max = self.wink.max_max_set_point()
|
|
if self.hvac_mode == HVAC_MODE_HEAT:
|
|
if max_min:
|
|
return_value = max_min
|
|
else:
|
|
return_value = maximum
|
|
elif self.hvac_mode == HVAC_MODE_COOL:
|
|
if max_max:
|
|
return_value = max_max
|
|
else:
|
|
return_value = maximum
|
|
elif self.hvac_mode == HVAC_MODE_AUTO:
|
|
if max_min and max_max:
|
|
return_value = min(max_min, max_max)
|
|
else:
|
|
return_value = maximum
|
|
else:
|
|
return_value = maximum
|
|
return return_value
|
|
|
|
|
|
class WinkAC(WinkDevice, ClimateEntity):
|
|
"""Representation of a Wink air conditioner."""
|
|
|
|
@property
|
|
def supported_features(self):
|
|
"""Return the list of supported features."""
|
|
return SUPPORT_FLAGS_AC
|
|
|
|
@property
|
|
def temperature_unit(self):
|
|
"""Return the unit of measurement."""
|
|
# The Wink API always returns temp in Celsius
|
|
return TEMP_CELSIUS
|
|
|
|
@property
|
|
def device_state_attributes(self):
|
|
"""Return the optional device state attributes."""
|
|
data = {}
|
|
data[ATTR_TOTAL_CONSUMPTION] = self.wink.total_consumption()
|
|
data[ATTR_SCHEDULE_ENABLED] = self.wink.schedule_enabled()
|
|
|
|
return data
|
|
|
|
@property
|
|
def current_temperature(self):
|
|
"""Return the current temperature."""
|
|
return self.wink.current_temperature()
|
|
|
|
@property
|
|
def preset_mode(self):
|
|
"""Return the current preset mode, e.g., home, away, temp."""
|
|
if not self.wink.is_on():
|
|
return PRESET_NONE
|
|
|
|
mode = self.wink.current_mode()
|
|
if mode == "auto_eco":
|
|
return PRESET_ECO
|
|
return PRESET_NONE
|
|
|
|
@property
|
|
def preset_modes(self):
|
|
"""Return a list of available preset modes."""
|
|
return SUPPORT_PRESET_AC
|
|
|
|
@property
|
|
def hvac_mode(self) -> str:
|
|
"""Return hvac operation ie. heat, cool mode.
|
|
|
|
Need to be one of HVAC_MODE_*.
|
|
"""
|
|
if not self.wink.is_on():
|
|
return HVAC_MODE_OFF
|
|
|
|
wink_mode = self.wink.current_mode()
|
|
if wink_mode == "auto_eco":
|
|
return HVAC_MODE_COOL
|
|
return WINK_HVAC_TO_HA.get(wink_mode)
|
|
|
|
@property
|
|
def hvac_modes(self):
|
|
"""Return the list of available hvac operation modes.
|
|
|
|
Need to be a subset of HVAC_MODES.
|
|
"""
|
|
hvac_list = [HVAC_MODE_OFF]
|
|
|
|
modes = self.wink.modes()
|
|
for mode in modes:
|
|
if mode == "auto_eco":
|
|
continue
|
|
try:
|
|
ha_mode = WINK_HVAC_TO_HA[mode]
|
|
hvac_list.append(ha_mode)
|
|
except KeyError:
|
|
_LOGGER.error(
|
|
"Invalid operation mode mapping. %s doesn't map. "
|
|
"Please report this.",
|
|
mode,
|
|
)
|
|
return hvac_list
|
|
|
|
def set_temperature(self, **kwargs):
|
|
"""Set new target temperature."""
|
|
target_temp = kwargs.get(ATTR_TEMPERATURE)
|
|
self.wink.set_temperature(target_temp)
|
|
|
|
def set_hvac_mode(self, hvac_mode):
|
|
"""Set new target hvac mode."""
|
|
hvac_mode_to_set = HA_HVAC_TO_WINK.get(hvac_mode)
|
|
self.wink.set_operation_mode(hvac_mode_to_set)
|
|
|
|
def set_preset_mode(self, preset_mode):
|
|
"""Set new preset mode."""
|
|
if preset_mode == PRESET_ECO:
|
|
self.wink.set_operation_mode("auto_eco")
|
|
elif self.hvac_mode == HVAC_MODE_COOL and preset_mode == PRESET_NONE:
|
|
self.set_hvac_mode(HVAC_MODE_COOL)
|
|
|
|
@property
|
|
def target_temperature(self):
|
|
"""Return the temperature we try to reach."""
|
|
return self.wink.current_max_set_point()
|
|
|
|
@property
|
|
def fan_mode(self):
|
|
"""
|
|
Return the current fan mode.
|
|
|
|
The official Wink app only supports 3 modes [low, medium, high]
|
|
which are equal to [0.33, 0.66, 1.0] respectively.
|
|
"""
|
|
speed = self.wink.current_fan_speed()
|
|
if speed <= 0.33:
|
|
return FAN_LOW
|
|
if speed <= 0.66:
|
|
return FAN_MEDIUM
|
|
return FAN_HIGH
|
|
|
|
@property
|
|
def fan_modes(self):
|
|
"""Return a list of available fan modes."""
|
|
return SUPPORT_FAN_AC
|
|
|
|
def set_fan_mode(self, fan_mode):
|
|
"""
|
|
Set fan speed.
|
|
|
|
The official Wink app only supports 3 modes [low, medium, high]
|
|
which are equal to [0.33, 0.66, 1.0] respectively.
|
|
"""
|
|
if fan_mode == FAN_LOW:
|
|
speed = 0.33
|
|
elif fan_mode == FAN_MEDIUM:
|
|
speed = 0.66
|
|
elif fan_mode == FAN_HIGH:
|
|
speed = 1.0
|
|
self.wink.set_ac_fan_speed(speed)
|