climate.py

Go to the documentation of this file.

"""AirTouch 4 component to control of AirTouch 4 Climate Devices."""
 
from __future__ import annotations
 
import logging
from typing import Any
 
from homeassistant.components.climate import (
    FAN_AUTO,
    FAN_DIFFUSE,
    FAN_FOCUS,
    FAN_HIGH,
    FAN_LOW,
    FAN_MEDIUM,
    ClimateEntity,
    ClimateEntityFeature,
    HVACMode,
)
from homeassistant.const import ATTR_TEMPERATURE, UnitOfTemperature
from homeassistant.core import HomeAssistant, callback
from homeassistant.helpers.device_registry import DeviceInfo
from homeassistant.helpers.entity_platform import AddEntitiesCallback
from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
from . import AirTouch4ConfigEntry
from .const import DOMAIN
 
AT_TO_HA_STATE = {
    "Heat": HVACMode.HEAT,
    "Cool": HVACMode.COOL,
    "AutoHeat": HVACMode.AUTO,  # airtouch reports either autoheat or autocool
    "AutoCool": HVACMode.AUTO,
    "Auto": HVACMode.AUTO,
    "Dry": HVACMode.DRY,
    "Fan": HVACMode.FAN_ONLY,
}
 
HA_STATE_TO_AT = {
    HVACMode.HEAT: "Heat",
    HVACMode.COOL: "Cool",
    HVACMode.AUTO: "Auto",
    HVACMode.DRY: "Dry",
    HVACMode.FAN_ONLY: "Fan",
    HVACMode.OFF: "Off",
}
 
AT_TO_HA_FAN_SPEED = {
    "Quiet": FAN_DIFFUSE,
    "Low": FAN_LOW,
    "Medium": FAN_MEDIUM,
    "High": FAN_HIGH,
    "Powerful": FAN_FOCUS,
    "Auto": FAN_AUTO,
    "Turbo": "turbo",
}
 
AT_GROUP_MODES = [HVACMode.OFF, HVACMode.FAN_ONLY]
 
HA_FAN_SPEED_TO_AT = {value: key for key, value in AT_TO_HA_FAN_SPEED.items()}
 
_LOGGER = logging.getLogger(__name__)
 
 
async def async_setup_entry(
    hass: HomeAssistant,
    config_entry: AirTouch4ConfigEntry,
    async_add_entities: AddEntitiesCallback,
) -> None:
    """Set up the Airtouch 4."""
    coordinator = config_entry.runtime_data
    info = coordinator.data
    entities: list[ClimateEntity] = [
        AirtouchGroup(coordinator, group["group_number"], info)
        for group in info["groups"]
    ]
    entities.extend(
        AirtouchAC(coordinator, ac["ac_number"], info) for ac in info["acs"]
    )
 
    _LOGGER.debug(" Found entities %s", entities)
 
    async_add_entities(entities)
 
 
class AirtouchAC(CoordinatorEntity, ClimateEntity):
    """Representation of an AirTouch 4 ac."""
 
    _attr_has_entity_name = True
    _attr_name = None
 
    _attr_supported_features = (
        ClimateEntityFeature.TARGET_TEMPERATURE
        | ClimateEntityFeature.FAN_MODE
        | ClimateEntityFeature.TURN_OFF
        | ClimateEntityFeature.TURN_ON
    )
    _attr_temperature_unit = UnitOfTemperature.CELSIUS
    _enable_turn_on_off_backwards_compatibility = False
 
    def __init__(self, coordinator, ac_number, info):
        """Initialize the climate device."""
        super().__init__(coordinator)
        self._ac_number_ac_number = ac_number
        self._airtouch_airtouch = coordinator.airtouch
        self._info_info = info
        self._unit_unit = self._airtouch_airtouch.GetAcs()[ac_number]
        self._attr_unique_id_attr_unique_id = f"ac_{ac_number}"
        self._attr_device_info_attr_device_info = DeviceInfo(
            identifiers={(DOMAIN, f"ac_{ac_number}")},
            name=f"AC {ac_number}",
            manufacturer="Airtouch",
            model="Airtouch 4",
        )
 
    @callback
    def _handle_coordinator_update(self):
        self._unit_unit = self._airtouch_airtouch.GetAcs()[self._ac_number_ac_number]
        return super()._handle_coordinator_update()
 
    @property
    def current_temperature(self):
        """Return the current temperature."""
        return self._unit_unit.Temperature
 
    @property
    def fan_mode(self):
        """Return fan mode of the AC this group belongs to."""
        return AT_TO_HA_FAN_SPEED[self._airtouch_airtouch.acs[self._ac_number_ac_number].AcFanSpeed]
 
    @property
    def fan_modes(self):
        """Return the list of available fan modes."""
        airtouch_fan_speeds = self._airtouch_airtouch.GetSupportedFanSpeedsForAc(self._ac_number_ac_number)
        return [AT_TO_HA_FAN_SPEED[speed] for speed in airtouch_fan_speeds]
 
    @property
    def hvac_mode(self):
        """Return hvac target hvac state."""
        is_off = self._unit_unit.PowerState == "Off"
        if is_off:
            return HVACMode.OFF
 
        return AT_TO_HA_STATE[self._airtouch_airtouch.acs[self._ac_number_ac_number].AcMode]
 
    @property
    def hvac_modes(self):
        """Return the list of available operation modes."""
        airtouch_modes = self._airtouch_airtouch.GetSupportedCoolingModesForAc(self._ac_number_ac_number)
        modes = [AT_TO_HA_STATE[mode] for mode in airtouch_modes]
        modes.append(HVACMode.OFF)
        return modes
 
    async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
        """Set new operation mode."""
        if hvac_mode not in HA_STATE_TO_AT:
            raise ValueError(f"Unsupported HVAC mode: {hvac_mode}")
 
        if hvac_mode == HVACMode.OFF:
            await self.async_turn_offasync_turn_offasync_turn_off()
            return
        await self._airtouch_airtouch.SetCoolingModeForAc(
            self._ac_number_ac_number, HA_STATE_TO_AT[hvac_mode]
        )
        # in case it isn't already, unless the HVAC mode was off, then the ac should be on
        await self.async_turn_onasync_turn_onasync_turn_on()
        self._unit_unit = self._airtouch_airtouch.GetAcs()[self._ac_number_ac_number]
        _LOGGER.debug("Setting operation mode of %s to %s", self._ac_number_ac_number, hvac_mode)
        self.async_write_ha_stateasync_write_ha_state()
 
    async def async_set_fan_mode(self, fan_mode: str) -> None:
        """Set new fan mode."""
        if fan_mode not in self.fan_modesfan_modesfan_modes:
            raise ValueError(f"Unsupported fan mode: {fan_mode}")
 
        _LOGGER.debug("Setting fan mode of %s to %s", self._ac_number_ac_number, fan_mode)
        await self._airtouch_airtouch.SetFanSpeedForAc(
            self._ac_number_ac_number, HA_FAN_SPEED_TO_AT[fan_mode]
        )
        self._unit_unit = self._airtouch_airtouch.GetAcs()[self._ac_number_ac_number]
        self.async_write_ha_stateasync_write_ha_state()
 
    async def async_turn_on(self) -> None:
        """Turn on."""
        _LOGGER.debug("Turning %s on", self.unique_idunique_id)
        # in case ac is not on. Airtouch turns itself off if no groups are turned on
        # (even if groups turned back on)
        await self._airtouch_airtouch.TurnAcOn(self._ac_number_ac_number)
 
    async def async_turn_off(self) -> None:
        """Turn off."""
        _LOGGER.debug("Turning %s off", self.unique_idunique_id)
        await self._airtouch_airtouch.TurnAcOff(self._ac_number_ac_number)
        self.async_write_ha_stateasync_write_ha_state()
 
 
class AirtouchGroup(CoordinatorEntity, ClimateEntity):
    """Representation of an AirTouch 4 group."""
 
    _attr_has_entity_name = True
    _attr_name = None
    _attr_supported_features = (
        ClimateEntityFeature.TARGET_TEMPERATURE
        | ClimateEntityFeature.TURN_OFF
        | ClimateEntityFeature.TURN_ON
    )
    _attr_temperature_unit = UnitOfTemperature.CELSIUS
    _attr_hvac_modes = AT_GROUP_MODES
    _enable_turn_on_off_backwards_compatibility = False
 
    def __init__(self, coordinator, group_number, info):
        """Initialize the climate device."""
        super().__init__(coordinator)
        self._group_number_group_number = group_number
        self._attr_unique_id_attr_unique_id = group_number
        self._airtouch_airtouch = coordinator.airtouch
        self._info_info = info
        self._unit_unit = self._airtouch_airtouch.GetGroupByGroupNumber(group_number)
        self._attr_device_info_attr_device_info = DeviceInfo(
            identifiers={(DOMAIN, group_number)},
            manufacturer="Airtouch",
            model="Airtouch 4",
            name=self._unit_unit.GroupName,
        )
 
    @callback
    def _handle_coordinator_update(self):
        self._unit_unit = self._airtouch_airtouch.GetGroupByGroupNumber(self._group_number_group_number)
        return super()._handle_coordinator_update()
 
    @property
    def min_temp(self):
        """Return Minimum Temperature for AC of this group."""
        return self._airtouch_airtouch.acs[self._unit_unit.BelongsToAc].MinSetpoint
 
    @property
    def max_temp(self):
        """Return Max Temperature for AC of this group."""
        return self._airtouch_airtouch.acs[self._unit_unit.BelongsToAc].MaxSetpoint
 
    @property
    def current_temperature(self):
        """Return the current temperature."""
        return self._unit_unit.Temperature
 
    @property
    def target_temperature(self):
        """Return the temperature we are trying to reach."""
        return self._unit_unit.TargetSetpoint
 
    @property
    def hvac_mode(self):
        """Return hvac target hvac state."""
        # there are other power states that aren't 'on' but still count as on (eg. 'Turbo')
        is_off = self._unit_unit.PowerState == "Off"
        if is_off:
            return HVACMode.OFF
 
        return HVACMode.FAN_ONLY
 
    async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
        """Set new operation mode."""
        if hvac_mode not in HA_STATE_TO_AT:
            raise ValueError(f"Unsupported HVAC mode: {hvac_mode}")
 
        if hvac_mode == HVACMode.OFF:
            await self.async_turn_offasync_turn_offasync_turn_off()
            return
        if self.hvac_modehvac_modehvac_modehvac_modehvac_mode == HVACMode.OFF:
            await self.async_turn_onasync_turn_onasync_turn_on()
        self._unit_unit = self._airtouch_airtouch.GetGroups()[self._group_number_group_number]
        _LOGGER.debug(
            "Setting operation mode of %s to %s", self._group_number_group_number, hvac_mode
        )
        self.async_write_ha_stateasync_write_ha_state()
 
    @property
    def fan_mode(self):
        """Return fan mode of the AC this group belongs to."""
        return AT_TO_HA_FAN_SPEED[self._airtouch_airtouch.acs[self._unit_unit.BelongsToAc].AcFanSpeed]
 
    @property
    def fan_modes(self):
        """Return the list of available fan modes."""
        airtouch_fan_speeds = self._airtouch_airtouch.GetSupportedFanSpeedsByGroup(
            self._group_number_group_number
        )
        return [AT_TO_HA_FAN_SPEED[speed] for speed in airtouch_fan_speeds]
 
    async def async_set_temperature(self, **kwargs: Any) -> None:
        """Set new target temperatures."""
        if (temp := kwargs.get(ATTR_TEMPERATURE)) is None:
            _LOGGER.debug("Argument `temperature` is missing in set_temperature")
            return
 
        _LOGGER.debug("Setting temp of %s to %s", self._group_number_group_number, str(temp))
        self._unit_unit = await self._airtouch_airtouch.SetGroupToTemperature(
            self._group_number_group_number, int(temp)
        )
        self.async_write_ha_stateasync_write_ha_state()
 
    async def async_set_fan_mode(self, fan_mode: str) -> None:
        """Set new fan mode."""
        if fan_mode not in self.fan_modesfan_modesfan_modes:
            raise ValueError(f"Unsupported fan mode: {fan_mode}")
 
        _LOGGER.debug("Setting fan mode of %s to %s", self._group_number_group_number, fan_mode)
        self._unit_unit = await self._airtouch_airtouch.SetFanSpeedByGroup(
            self._group_number_group_number, HA_FAN_SPEED_TO_AT[fan_mode]
        )
        self.async_write_ha_stateasync_write_ha_state()
 
    async def async_turn_on(self) -> None:
        """Turn on."""
        _LOGGER.debug("Turning %s on", self.unique_idunique_id)
        await self._airtouch_airtouch.TurnGroupOn(self._group_number_group_number)
 
        # in case ac is not on. Airtouch turns itself off if no groups are turned on
        # (even if groups turned back on)
        await self._airtouch_airtouch.TurnAcOn(
            self._airtouch_airtouch.GetGroupByGroupNumber(self._group_number_group_number).BelongsToAc
        )
        # this might cause the ac object to be wrong, so force the shared data
        # store to update
        await self.coordinator.async_request_refresh()
        self.async_write_ha_stateasync_write_ha_state()
 
    async def async_turn_off(self) -> None:
        """Turn off."""
        _LOGGER.debug("Turning %s off", self.unique_idunique_id)
        await self._airtouch_airtouch.TurnGroupOff(self._group_number_group_number)
        # this will cause the ac object to be wrong
        # (ac turns off automatically if no groups are running)
        # so force the shared data store to update
        await self.coordinator.async_request_refresh()
        self.async_write_ha_stateasync_write_ha_state()