climate.py

Go to the documentation of this file.

"""Support for AVM FRITZ!SmartHome thermostat devices."""
 
from __future__ import annotations
 
from typing import Any
 
from homeassistant.components.climate import (
    ATTR_HVAC_MODE,
    PRESET_COMFORT,
    PRESET_ECO,
    ClimateEntity,
    ClimateEntityFeature,
    HVACMode,
)
from homeassistant.const import (
    ATTR_BATTERY_LEVEL,
    ATTR_TEMPERATURE,
    PRECISION_HALVES,
    UnitOfTemperature,
)
from homeassistant.core import HomeAssistant, callback
from homeassistant.exceptions import HomeAssistantError
from homeassistant.helpers.entity_platform import AddEntitiesCallback
 
from .const import (
    ATTR_STATE_BATTERY_LOW,
    ATTR_STATE_HOLIDAY_MODE,
    ATTR_STATE_SUMMER_MODE,
    ATTR_STATE_WINDOW_OPEN,
    DOMAIN,
    LOGGER,
)
from .coordinator import FritzboxConfigEntry, FritzboxDataUpdateCoordinator
from .entity import FritzBoxDeviceEntity
from .model import ClimateExtraAttributes
from .sensor import value_scheduled_preset
 
HVAC_MODES = [HVACMode.HEAT, HVACMode.OFF]
PRESET_HOLIDAY = "holiday"
PRESET_SUMMER = "summer"
PRESET_MODES = [PRESET_ECO, PRESET_COMFORT]
SUPPORTED_FEATURES = (
    ClimateEntityFeature.TARGET_TEMPERATURE
    | ClimateEntityFeature.PRESET_MODE
    | ClimateEntityFeature.TURN_OFF
    | ClimateEntityFeature.TURN_ON
)
 
MIN_TEMPERATURE = 8
MAX_TEMPERATURE = 28
 
# special temperatures for on/off in Fritz!Box API (modified by pyfritzhome)
ON_API_TEMPERATURE = 127.0
OFF_API_TEMPERATURE = 126.5
ON_REPORT_SET_TEMPERATURE = 30.0
OFF_REPORT_SET_TEMPERATURE = 0.0
 
 
async def async_setup_entry(
    hass: HomeAssistant,
    entry: FritzboxConfigEntry,
    async_add_entities: AddEntitiesCallback,
) -> None:
    """Set up the FRITZ!SmartHome thermostat from ConfigEntry."""
    coordinator = entry.runtime_data
 
    @callback
    def _add_entities(devices: set[str] | None = None) -> None:
        """Add devices."""
        if devices is None:
            devices = coordinator.new_devices
        if not devices:
            return
        async_add_entities(
            FritzboxThermostat(coordinator, ain)
            for ain in devices
            if coordinator.data.devices[ain].has_thermostat
        )
 
    entry.async_on_unload(coordinator.async_add_listener(_add_entities))
 
    _add_entities(set(coordinator.data.devices))
 
 
class FritzboxThermostat(FritzBoxDeviceEntity, ClimateEntity):
    """The thermostat class for FRITZ!SmartHome thermostats."""
 
    _attr_precision = PRECISION_HALVES
    _attr_temperature_unit = UnitOfTemperature.CELSIUS
    _attr_translation_key = "thermostat"
    _enable_turn_on_off_backwards_compatibility = False
 
    def __init__(
        self,
        coordinator: FritzboxDataUpdateCoordinator,
        ain: str,
    ) -> None:
        """Initialize the thermostat."""
        self._attr_supported_features_attr_supported_features = SUPPORTED_FEATURES
        self._attr_hvac_modes_attr_hvac_modes = HVAC_MODES
        self._attr_preset_modes_attr_preset_modes = PRESET_MODES
        super().__init__(coordinator, ain)
 
    @callback
    def async_write_ha_state(self) -> None:
        """Write the state to the HASS state machine."""
        if self.datadatadatadatadata.holiday_active:
            self._attr_supported_features_attr_supported_features = ClimateEntityFeature.PRESET_MODE
            self._attr_hvac_modes_attr_hvac_modes = [HVACMode.HEAT]
            self._attr_preset_modes_attr_preset_modes = [PRESET_HOLIDAY]
        elif self.datadatadatadatadata.summer_active:
            self._attr_supported_features_attr_supported_features = ClimateEntityFeature.PRESET_MODE
            self._attr_hvac_modes_attr_hvac_modes = [HVACMode.OFF]
            self._attr_preset_modes_attr_preset_modes = [PRESET_SUMMER]
        else:
            self._attr_supported_features_attr_supported_features = SUPPORTED_FEATURES
            self._attr_hvac_modes_attr_hvac_modes = HVAC_MODES
            self._attr_preset_modes_attr_preset_modes = PRESET_MODES
        return super().async_write_ha_state()
 
    @property
    def current_temperature(self) -> float:
        """Return the current temperature."""
        if self.datadatadatadatadata.has_temperature_sensor and self.datadatadatadatadata.temperature is not None:
            return self.datadatadatadatadata.temperature  # type: ignore [no-any-return]
        return self.datadatadatadatadata.actual_temperature  # type: ignore [no-any-return]
 
    @property
    def target_temperature(self) -> float:
        """Return the temperature we try to reach."""
        if self.datadatadatadatadata.target_temperature == ON_API_TEMPERATURE:
            return ON_REPORT_SET_TEMPERATURE
        if self.datadatadatadatadata.target_temperature == OFF_API_TEMPERATURE:
            return OFF_REPORT_SET_TEMPERATURE
        return self.datadatadatadatadata.target_temperature  # type: ignore [no-any-return]
 
    async def async_set_temperature(self, **kwargs: Any) -> None:
        """Set new target temperature."""
        target_temp = kwargs.get(ATTR_TEMPERATURE)
        hvac_mode = kwargs.get(ATTR_HVAC_MODE)
        if hvac_mode == HVACMode.OFF:
            await self.async_set_hvac_modeasync_set_hvac_modeasync_set_hvac_mode(hvac_mode)
        elif target_temp is not None:
            await self.hasshasshass.async_add_executor_job(
                self.datadatadatadatadata.set_target_temperature, target_temp
            )
        else:
            return
        await self.coordinator.async_refresh()
 
    @property
    def hvac_mode(self) -> HVACMode:
        """Return the current operation mode."""
        if self.datadatadatadatadata.holiday_active:
            return HVACMode.HEAT
        if self.datadatadatadatadata.summer_active:
            return HVACMode.OFF
        if self.datadatadatadatadata.target_temperature in (
            OFF_REPORT_SET_TEMPERATURE,
            OFF_API_TEMPERATURE,
        ):
            return HVACMode.OFF
 
        return HVACMode.HEAT
 
    async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
        """Set new operation mode."""
        if self.datadatadatadatadata.holiday_active or self.datadatadatadatadata.summer_active:
            raise HomeAssistantError(
                translation_domain=DOMAIN,
                translation_key="change_hvac_while_active_mode",
            )
        if self.hvac_modehvac_modehvac_modehvac_modehvac_mode == hvac_mode:
            LOGGER.debug(
                "%s is already in requested hvac mode %s", self.namenamename, hvac_mode
            )
            return
        if hvac_mode == HVACMode.OFF:
            await self.async_set_temperatureasync_set_temperatureasync_set_temperature(temperature=OFF_REPORT_SET_TEMPERATURE)
        else:
            if value_scheduled_preset(self.datadatadatadatadata) == PRESET_ECO:
                target_temp = self.datadatadatadatadata.eco_temperature
            else:
                target_temp = self.datadatadatadatadata.comfort_temperature
            await self.async_set_temperatureasync_set_temperatureasync_set_temperature(temperature=target_temp)
 
    @property
    def preset_mode(self) -> str | None:
        """Return current preset mode."""
        if self.datadatadatadatadata.holiday_active:
            return PRESET_HOLIDAY
        if self.datadatadatadatadata.summer_active:
            return PRESET_SUMMER
        if self.datadatadatadatadata.target_temperature == self.datadatadatadatadata.comfort_temperature:
            return PRESET_COMFORT
        if self.datadatadatadatadata.target_temperature == self.datadatadatadatadata.eco_temperature:
            return PRESET_ECO
        return None
 
    async def async_set_preset_mode(self, preset_mode: str) -> None:
        """Set preset mode."""
        if self.datadatadatadatadata.holiday_active or self.datadatadatadatadata.summer_active:
            raise HomeAssistantError(
                translation_domain=DOMAIN,
                translation_key="change_preset_while_active_mode",
            )
        if preset_mode == PRESET_COMFORT:
            await self.async_set_temperatureasync_set_temperatureasync_set_temperature(temperature=self.datadatadatadatadata.comfort_temperature)
        elif preset_mode == PRESET_ECO:
            await self.async_set_temperatureasync_set_temperatureasync_set_temperature(temperature=self.datadatadatadatadata.eco_temperature)
 
    @property
    def min_temp(self) -> int:
        """Return the minimum temperature."""
        return MIN_TEMPERATURE
 
    @property
    def max_temp(self) -> int:
        """Return the maximum temperature."""
        return MAX_TEMPERATURE
 
    @property
    def extra_state_attributes(self) -> ClimateExtraAttributes:
        """Return the device specific state attributes."""
        attrs: ClimateExtraAttributes = {
            ATTR_STATE_BATTERY_LOW: self.datadatadatadatadata.battery_low,
        }
 
        # the following attributes are available since fritzos 7
        if self.datadatadatadatadata.battery_level is not None:
            attrs[ATTR_BATTERY_LEVEL] = self.datadatadatadatadata.battery_level
        if self.datadatadatadatadata.holiday_active is not None:
            attrs[ATTR_STATE_HOLIDAY_MODE] = self.datadatadatadatadata.holiday_active
        if self.datadatadatadatadata.summer_active is not None:
            attrs[ATTR_STATE_SUMMER_MODE] = self.datadatadatadatadata.summer_active
        if self.datadatadatadatadata.window_open is not None:
            attrs[ATTR_STATE_WINDOW_OPEN] = self.datadatadatadatadata.window_open
 
        return attrs