climate.py

Go to the documentation of this file.

"""Support for HomematicIP Cloud climate devices."""
 
from __future__ import annotations
 
from typing import Any
 
from homematicip.aio.device import (
    AsyncHeatingThermostat,
    AsyncHeatingThermostatCompact,
    AsyncHeatingThermostatEvo,
)
from homematicip.aio.group import AsyncHeatingGroup
from homematicip.base.enums import AbsenceType
from homematicip.device import Switch
from homematicip.functionalHomes import IndoorClimateHome
from homematicip.group import HeatingCoolingProfile
 
from homeassistant.components.climate import (
    PRESET_AWAY,
    PRESET_BOOST,
    PRESET_ECO,
    PRESET_NONE,
    ClimateEntity,
    ClimateEntityFeature,
    HVACAction,
    HVACMode,
)
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import ATTR_TEMPERATURE, UnitOfTemperature
from homeassistant.core import HomeAssistant
from homeassistant.helpers.device_registry import DeviceInfo
from homeassistant.helpers.entity_platform import AddEntitiesCallback
 
from .const import DOMAIN
from .entity import HomematicipGenericEntity
from .hap import HomematicipHAP
 
HEATING_PROFILES = {"PROFILE_1": 0, "PROFILE_2": 1, "PROFILE_3": 2}
COOLING_PROFILES = {"PROFILE_4": 3, "PROFILE_5": 4, "PROFILE_6": 5}
NICE_PROFILE_NAMES = {
    "PROFILE_1": "Default",
    "PROFILE_2": "Alternative 1",
    "PROFILE_3": "Alternative 2",
    "PROFILE_4": "Cooling 1",
    "PROFILE_5": "Cooling 2",
    "PROFILE_6": "Cooling 3",
}
 
ATTR_PRESET_END_TIME = "preset_end_time"
PERMANENT_END_TIME = "permanent"
 
HMIP_AUTOMATIC_CM = "AUTOMATIC"
HMIP_MANUAL_CM = "MANUAL"
HMIP_ECO_CM = "ECO"
 
 
async def async_setup_entry(
    hass: HomeAssistant,
    config_entry: ConfigEntry,
    async_add_entities: AddEntitiesCallback,
) -> None:
    """Set up the HomematicIP climate from a config entry."""
    hap = hass.data[DOMAIN][config_entry.unique_id]
 
    async_add_entities(
        HomematicipHeatingGroup(hap, device)
        for device in hap.home.groups
        if isinstance(device, AsyncHeatingGroup)
    )
 
 
class HomematicipHeatingGroup(HomematicipGenericEntity, ClimateEntity):
    """Representation of the HomematicIP heating group.
 
    Heat mode is supported for all heating devices incl. their defined profiles.
    Boost is available for radiator thermostats only.
    Cool mode is only available for floor heating systems, if basically enabled in the hmip app.
    """
 
    _attr_supported_features = (
        ClimateEntityFeature.PRESET_MODE | ClimateEntityFeature.TARGET_TEMPERATURE
    )
    _attr_temperature_unit = UnitOfTemperature.CELSIUS
    _enable_turn_on_off_backwards_compatibility = False
 
    def __init__(self, hap: HomematicipHAP, device: AsyncHeatingGroup) -> None:
        """Initialize heating group."""
        device.modelType = "HmIP-Heating-Group"
        super().__init__(hap, device)
        self._simple_heating_simple_heating = None
        if device.actualTemperature is None:
            self._simple_heating_simple_heating = self._first_radiator_thermostat_first_radiator_thermostat
 
    @property
    def device_info(self) -> DeviceInfo:
        """Return device specific attributes."""
        return DeviceInfo(
            identifiers={(DOMAIN, self._device_device.id)},
            manufacturer="eQ-3",
            model=self._device_device.modelType,
            name=self._device_device.label,
            via_device=(DOMAIN, self._device_device.homeId),
        )
 
    @property
    def target_temperature(self) -> float:
        """Return the temperature we try to reach."""
        return self._device_device.setPointTemperature
 
    @property
    def current_temperature(self) -> float:
        """Return the current temperature."""
        if self._simple_heating_simple_heating:
            return self._simple_heating_simple_heating.valveActualTemperature
        return self._device_device.actualTemperature
 
    @property
    def current_humidity(self) -> int:
        """Return the current humidity."""
        return self._device_device.humidity
 
    @property
    def hvac_mode(self) -> HVACMode:
        """Return hvac operation ie."""
        if self._disabled_by_cooling_mode_disabled_by_cooling_mode and not self._has_switch_has_switch:
            return HVACMode.OFF
        if self._device_device.boostMode:
            return HVACMode.HEAT
        if self._device_device.controlMode == HMIP_MANUAL_CM:
            return HVACMode.HEAT if self._heat_mode_enabled_heat_mode_enabled else HVACMode.COOL
 
        return HVACMode.AUTO
 
    @property
    def hvac_modes(self) -> list[HVACMode]:
        """Return the list of available hvac operation modes."""
        if self._disabled_by_cooling_mode_disabled_by_cooling_mode and not self._has_switch_has_switch:
            return [HVACMode.OFF]
 
        if self._heat_mode_enabled_heat_mode_enabled:
            return [HVACMode.AUTO, HVACMode.HEAT]
        return [HVACMode.AUTO, HVACMode.COOL]
 
    @property
    def hvac_action(self) -> HVACAction | None:
        """Return the current hvac_action.
 
        This is only relevant for radiator thermostats.
        """
        if (
            self._device_device.floorHeatingMode == "RADIATOR"
            and self._has_radiator_thermostat_has_radiator_thermostat
            and self._heat_mode_enabled_heat_mode_enabled
        ):
            return HVACAction.HEATING if self._device_device.valvePosition else HVACAction.IDLE
 
        return None
 
    @property
    def preset_mode(self) -> str | None:
        """Return the current preset mode."""
        if self._device_device.boostMode:
            return PRESET_BOOST
        if self.hvac_modehvac_modehvac_modehvac_mode in (HVACMode.COOL, HVACMode.HEAT, HVACMode.OFF):
            return PRESET_NONE
        if self._device_device.controlMode == HMIP_ECO_CM:
            if self._indoor_climate_indoor_climate.absenceType == AbsenceType.VACATION:
                return PRESET_AWAY
            if self._indoor_climate_indoor_climate.absenceType in [
                AbsenceType.PARTY,
                AbsenceType.PERIOD,
                AbsenceType.PERMANENT,
            ]:
                return PRESET_ECO
 
        return (
            self._get_qualified_profile_name_get_qualified_profile_name(self._device_device.activeProfile)
            if self._get_qualified_profile_name_get_qualified_profile_name(self._device_device.activeProfile)
            in self._device_profile_names_device_profile_names
            else None
        )
 
    @property
    def preset_modes(self) -> list[str]:
        """Return a list of available preset modes incl. hmip profiles."""
        # Boost is only available if a radiator thermostat is in the room,
        # and heat mode is enabled.
        profile_names = self._device_profile_names_device_profile_names
 
        presets = []
        if (
            self._heat_mode_enabled_heat_mode_enabled and self._has_radiator_thermostat_has_radiator_thermostat
        ) or self._has_switch_has_switch:
            if not profile_names:
                presets.append(PRESET_NONE)
            presets.extend([PRESET_BOOST, PRESET_ECO])
 
        presets.extend(profile_names)
 
        return presets
 
    @property
    def min_temp(self) -> float:
        """Return the minimum temperature."""
        return self._device_device.minTemperature
 
    @property
    def max_temp(self) -> float:
        """Return the maximum temperature."""
        return self._device_device.maxTemperature
 
    async def async_set_temperature(self, **kwargs: Any) -> None:
        """Set new target temperature."""
        if (temperature := kwargs.get(ATTR_TEMPERATURE)) is None:
            return
 
        if self.min_tempmin_tempmin_temp <= temperature <= self.max_tempmax_tempmax_temp:
            await self._device_device.set_point_temperature(temperature)
 
    async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
        """Set new target hvac mode."""
        if hvac_mode not in self.hvac_modeshvac_modeshvac_modes:
            return
 
        if hvac_mode == HVACMode.AUTO:
            await self._device_device.set_control_mode(HMIP_AUTOMATIC_CM)
        else:
            await self._device_device.set_control_mode(HMIP_MANUAL_CM)
 
    async def async_set_preset_mode(self, preset_mode: str) -> None:
        """Set new preset mode."""
        if self._device_device.boostMode and preset_mode != PRESET_BOOST:
            await self._device_device.set_boost(False)
        if preset_mode == PRESET_BOOST:
            await self._device_device.set_boost()
        if preset_mode == PRESET_ECO:
            await self._device_device.set_control_mode(HMIP_ECO_CM)
        if preset_mode in self._device_profile_names_device_profile_names:
            profile_idx = self._get_profile_idx_by_name_get_profile_idx_by_name(preset_mode)
            if self._device_device.controlMode != HMIP_AUTOMATIC_CM:
                await self.async_set_hvac_modeasync_set_hvac_modeasync_set_hvac_mode(HVACMode.AUTO)
            await self._device_device.set_active_profile(profile_idx)
 
    @property
    def extra_state_attributes(self) -> dict[str, Any]:
        """Return the state attributes of the access point."""
        state_attr = super().extra_state_attributes
 
        if self._device_device.controlMode == HMIP_ECO_CM:
            if self._indoor_climate_indoor_climate.absenceType in [
                AbsenceType.PARTY,
                AbsenceType.PERIOD,
                AbsenceType.VACATION,
            ]:
                state_attr[ATTR_PRESET_END_TIME] = self._indoor_climate_indoor_climate.absenceEndTime
            elif self._indoor_climate_indoor_climate.absenceType == AbsenceType.PERMANENT:
                state_attr[ATTR_PRESET_END_TIME] = PERMANENT_END_TIME
 
        return state_attr
 
    @property
    def _indoor_climate(self) -> IndoorClimateHome:
        """Return the hmip indoor climate functional home of this group."""
        return self._home.get_functionalHome(IndoorClimateHome)
 
    @property
    def _device_profiles(self) -> list[HeatingCoolingProfile]:
        """Return the relevant profiles."""
        return [
            profile
            for profile in self._device_device.profiles
            if profile.visible and profile.index in self._relevant_profile_group_relevant_profile_group
        ]
 
    @property
    def _device_profile_names(self) -> list[str]:
        """Return a collection of profile names."""
        return [
            self._get_qualified_profile_name_get_qualified_profile_name(profile)
            for profile in self._device_profiles_device_profiles
        ]
 
    def _get_qualified_profile_name(self, profile: HeatingCoolingProfile) -> str:
        """Get a name for the given profile. If exists, this is the name of the profile."""
        if profile.name != "":
            return profile.name
        if profile.index in NICE_PROFILE_NAMES:
            return NICE_PROFILE_NAMES[profile.index]
 
        return profile.index
 
    def _get_profile_idx_by_name(self, profile_name: str) -> int:
        """Return a profile index by name."""
        relevant_index = self._relevant_profile_group_relevant_profile_group
        index_name = [
            profile.index
            for profile in self._device_profiles_device_profiles
            if self._get_qualified_profile_name_get_qualified_profile_name(profile) == profile_name
        ]
 
        return relevant_index[index_name[0]]
 
    @property
    def _heat_mode_enabled(self) -> bool:
        """Return, if heating mode is enabled."""
        return not self._device_device.cooling
 
    @property
    def _disabled_by_cooling_mode(self) -> bool:
        """Return, if group is disabled by the cooling mode."""
        return self._device_device.cooling and (
            self._device_device.coolingIgnored or not self._device_device.coolingAllowed
        )
 
    @property
    def _relevant_profile_group(self) -> dict[str, int]:
        """Return the relevant profile groups."""
        if self._disabled_by_cooling_mode_disabled_by_cooling_mode:
            return {}
 
        return HEATING_PROFILES if self._heat_mode_enabled_heat_mode_enabled else COOLING_PROFILES
 
    @property
    def _has_switch(self) -> bool:
        """Return, if a switch is in the hmip heating group."""
        return any(isinstance(device, Switch) for device in self._device_device.devices)
 
    @property
    def _has_radiator_thermostat(self) -> bool:
        """Return, if a radiator thermostat is in the hmip heating group."""
        return bool(self._first_radiator_thermostat_first_radiator_thermostat)
 
    @property
    def _first_radiator_thermostat(
        self,
    ) -> (
        AsyncHeatingThermostat
        | AsyncHeatingThermostatCompact
        | AsyncHeatingThermostatEvo
        | None
    ):
        """Return the first radiator thermostat from the hmip heating group."""
        for device in self._device_device.devices:
            if isinstance(
                device,
                (
                    AsyncHeatingThermostat,
                    AsyncHeatingThermostatCompact,
                    AsyncHeatingThermostatEvo,
                ),
            ):
                return device
 
        return None