708 lines
24 KiB
Python
708 lines
24 KiB
Python
"""Midea Climate entries."""
|
|
|
|
import logging
|
|
from typing import Any, ClassVar, cast
|
|
|
|
from homeassistant.components.climate import (
|
|
ATTR_HVAC_MODE,
|
|
FAN_AUTO,
|
|
FAN_HIGH,
|
|
FAN_LOW,
|
|
FAN_MEDIUM,
|
|
PRESET_AWAY,
|
|
PRESET_BOOST,
|
|
PRESET_COMFORT,
|
|
PRESET_ECO,
|
|
PRESET_NONE,
|
|
PRESET_SLEEP,
|
|
SWING_BOTH,
|
|
SWING_HORIZONTAL,
|
|
SWING_OFF,
|
|
SWING_ON,
|
|
SWING_VERTICAL,
|
|
ClimateEntity,
|
|
ClimateEntityFeature,
|
|
HVACMode,
|
|
)
|
|
from homeassistant.config_entries import ConfigEntry
|
|
from homeassistant.const import (
|
|
ATTR_TEMPERATURE,
|
|
CONF_DEVICE_ID,
|
|
CONF_SWITCHES,
|
|
MAJOR_VERSION,
|
|
MINOR_VERSION,
|
|
PRECISION_HALVES,
|
|
PRECISION_WHOLE,
|
|
Platform,
|
|
UnitOfTemperature,
|
|
)
|
|
from homeassistant.core import HomeAssistant
|
|
from homeassistant.helpers.entity_platform import AddEntitiesCallback
|
|
from midealocal.device import DeviceType
|
|
from midealocal.devices.ac import DeviceAttributes as ACAttributes
|
|
from midealocal.devices.ac import MideaACDevice
|
|
from midealocal.devices.c3 import DeviceAttributes as C3Attributes
|
|
from midealocal.devices.c3 import MideaC3Device
|
|
from midealocal.devices.cc import DeviceAttributes as CCAttributes
|
|
from midealocal.devices.cc import MideaCCDevice
|
|
from midealocal.devices.cf import DeviceAttributes as CFAttributes
|
|
from midealocal.devices.cf import MideaCFDevice
|
|
from midealocal.devices.fb import DeviceAttributes as FBAttributes
|
|
from midealocal.devices.fb import MideaFBDevice
|
|
|
|
from .const import DEVICES, DOMAIN, FanSpeed
|
|
from .midea_devices import MIDEA_DEVICES
|
|
from .midea_entity import MideaEntity
|
|
|
|
_LOGGER = logging.getLogger(__name__)
|
|
|
|
|
|
TEMPERATURE_MAX = 30
|
|
TEMPERATURE_MIN = 16
|
|
|
|
FAN_SILENT = "silent"
|
|
FAN_FULL_SPEED = "full"
|
|
|
|
|
|
async def async_setup_entry(
|
|
hass: HomeAssistant,
|
|
config_entry: ConfigEntry,
|
|
async_add_entities: AddEntitiesCallback,
|
|
) -> None:
|
|
"""Set up climate entries."""
|
|
device_id = config_entry.data.get(CONF_DEVICE_ID)
|
|
device = hass.data[DOMAIN][DEVICES].get(device_id)
|
|
extra_switches = config_entry.options.get(CONF_SWITCHES, [])
|
|
devs: list[
|
|
MideaACClimate
|
|
| MideaCCClimate
|
|
| MideaCFClimate
|
|
| MideaC3Climate
|
|
| MideaFBClimate
|
|
] = []
|
|
for entity_key, config in cast(
|
|
"dict",
|
|
MIDEA_DEVICES[device.device_type]["entities"],
|
|
).items():
|
|
if config["type"] == Platform.CLIMATE and (
|
|
config.get("default") or entity_key in extra_switches
|
|
):
|
|
if device.device_type == DeviceType.AC:
|
|
# add config_entry args to fix indoor_humidity error bug
|
|
devs.append(MideaACClimate(device, entity_key, config_entry))
|
|
elif device.device_type == DeviceType.CC:
|
|
devs.append(MideaCCClimate(device, entity_key))
|
|
elif device.device_type == DeviceType.CF:
|
|
devs.append(MideaCFClimate(device, entity_key))
|
|
elif device.device_type == DeviceType.C3:
|
|
devs.append(MideaC3Climate(device, entity_key, config["zone"]))
|
|
elif device.device_type == DeviceType.FB:
|
|
devs.append(MideaFBClimate(device, entity_key))
|
|
async_add_entities(devs)
|
|
|
|
|
|
type MideaClimateDevice = (
|
|
MideaACDevice | MideaCCDevice | MideaCFDevice | MideaC3Device | MideaFBDevice
|
|
)
|
|
|
|
|
|
class MideaClimate(MideaEntity, ClimateEntity):
|
|
"""Midea Climate Entries Base Class."""
|
|
|
|
# https://developers.home-assistant.io/blog/2024/01/24/climate-climateentityfeatures-expanded
|
|
_enable_turn_on_off_backwards_compatibility: bool = (
|
|
False # maybe remove after 2025.1
|
|
)
|
|
|
|
_device: MideaClimateDevice
|
|
|
|
_attr_max_temp: float = TEMPERATURE_MAX
|
|
_attr_min_temp: float = TEMPERATURE_MIN
|
|
_attr_target_temperature_high: float | None = TEMPERATURE_MAX
|
|
_attr_target_temperature_low: float | None = TEMPERATURE_MIN
|
|
_attr_temperature_unit: str = UnitOfTemperature.CELSIUS
|
|
|
|
def __init__(self, device: MideaClimateDevice, entity_key: str) -> None:
|
|
"""Midea Climate entity init."""
|
|
super().__init__(device, entity_key)
|
|
|
|
@property
|
|
def supported_features(self) -> ClimateEntityFeature:
|
|
"""Midea Climate supported features."""
|
|
features = (
|
|
ClimateEntityFeature.TARGET_TEMPERATURE
|
|
| ClimateEntityFeature.FAN_MODE
|
|
| ClimateEntityFeature.PRESET_MODE
|
|
| ClimateEntityFeature.SWING_MODE
|
|
)
|
|
if (MAJOR_VERSION, MINOR_VERSION) >= (2024, 2):
|
|
features |= ClimateEntityFeature.TURN_OFF | ClimateEntityFeature.TURN_ON
|
|
return features
|
|
|
|
@property
|
|
def hvac_mode(self) -> HVACMode:
|
|
"""Midea Climate hvac mode."""
|
|
if self._device.get_attribute("power"):
|
|
mode = cast("int", self._device.get_attribute("mode"))
|
|
return self.hvac_modes[mode]
|
|
return HVACMode.OFF
|
|
|
|
@property
|
|
def target_temperature(self) -> float:
|
|
"""Midea Climate target temperature."""
|
|
return cast("float", self._device.get_attribute("target_temperature"))
|
|
|
|
@property
|
|
def current_temperature(self) -> float | None:
|
|
"""Midea Climate current temperature."""
|
|
return cast("float | None", self._device.get_attribute("indoor_temperature"))
|
|
|
|
@property
|
|
def preset_mode(self) -> str:
|
|
"""Midea Climate preset mode."""
|
|
if self._device.get_attribute("comfort_mode"):
|
|
mode = PRESET_COMFORT
|
|
elif self._device.get_attribute("eco_mode"):
|
|
mode = PRESET_ECO
|
|
elif self._device.get_attribute("boost_mode"):
|
|
mode = PRESET_BOOST
|
|
elif self._device.get_attribute("sleep_mode"):
|
|
mode = PRESET_SLEEP
|
|
elif self._device.get_attribute("frost_protect"):
|
|
mode = PRESET_AWAY
|
|
else:
|
|
mode = PRESET_NONE
|
|
return str(mode)
|
|
|
|
@property
|
|
def extra_state_attributes(self) -> dict:
|
|
"""Midea Climate extra state attributes."""
|
|
return cast("dict", self._device.attributes)
|
|
|
|
def turn_on(self, **kwargs: Any) -> None: # noqa: ANN401, ARG002
|
|
"""Midea Climate turn on."""
|
|
self._device.set_attribute(attr="power", value=True)
|
|
|
|
def turn_off(self, **kwargs: Any) -> None: # noqa: ANN401, ARG002
|
|
"""Midea Climate turn off."""
|
|
self._device.set_attribute(attr="power", value=False)
|
|
|
|
def set_temperature(self, **kwargs: Any) -> None: # noqa: ANN401
|
|
"""Midea Climate set temperature."""
|
|
if ATTR_TEMPERATURE not in kwargs:
|
|
return
|
|
temperature = float(int((float(kwargs[ATTR_TEMPERATURE]) * 2) + 0.5)) / 2
|
|
hvac_mode = kwargs.get(ATTR_HVAC_MODE)
|
|
if hvac_mode == HVACMode.OFF:
|
|
self.turn_off()
|
|
else:
|
|
try:
|
|
mode = self.hvac_modes.index(hvac_mode.lower()) if hvac_mode else None
|
|
self._device.set_target_temperature(
|
|
target_temperature=temperature,
|
|
mode=mode,
|
|
zone=None,
|
|
)
|
|
except ValueError:
|
|
_LOGGER.exception("Error setting temperature with: %s", kwargs)
|
|
|
|
def set_hvac_mode(self, hvac_mode: HVACMode) -> None:
|
|
"""Midea Climate set hvac mode."""
|
|
if hvac_mode == HVACMode.OFF:
|
|
self.turn_off()
|
|
else:
|
|
self._device.set_attribute(
|
|
attr="mode",
|
|
value=self.hvac_modes.index(hvac_mode),
|
|
)
|
|
|
|
def set_preset_mode(self, preset_mode: str) -> None:
|
|
"""Midea Climate set preset mode."""
|
|
old_mode = self.preset_mode
|
|
preset_mode = preset_mode.lower()
|
|
if preset_mode == PRESET_AWAY:
|
|
self._device.set_attribute(attr="frost_protect", value=True)
|
|
elif preset_mode == PRESET_COMFORT:
|
|
self._device.set_attribute(attr="comfort_mode", value=True)
|
|
elif preset_mode == PRESET_SLEEP:
|
|
self._device.set_attribute(attr="sleep_mode", value=True)
|
|
elif preset_mode == PRESET_ECO:
|
|
self._device.set_attribute(attr="eco_mode", value=True)
|
|
elif preset_mode == PRESET_BOOST:
|
|
self._device.set_attribute(attr="boost_mode", value=True)
|
|
elif old_mode == PRESET_AWAY:
|
|
self._device.set_attribute(attr="frost_protect", value=False)
|
|
elif old_mode == PRESET_COMFORT:
|
|
self._device.set_attribute(attr="comfort_mode", value=False)
|
|
elif old_mode == PRESET_SLEEP:
|
|
self._device.set_attribute(attr="sleep_mode", value=False)
|
|
elif old_mode == PRESET_ECO:
|
|
self._device.set_attribute(attr="eco_mode", value=False)
|
|
elif old_mode == PRESET_BOOST:
|
|
self._device.set_attribute(attr="boost_mode", value=False)
|
|
|
|
def update_state(self, status: Any) -> None: # noqa: ANN401, ARG002
|
|
"""Midea Climate update state."""
|
|
if not self.hass:
|
|
_LOGGER.warning(
|
|
"Climate update_state skipped for %s [%s]: HASS is None",
|
|
self.name,
|
|
type(self),
|
|
)
|
|
return
|
|
self.schedule_update_ha_state()
|
|
|
|
|
|
class MideaACClimate(MideaClimate):
|
|
"""Midea AC Climate Entries."""
|
|
|
|
_device: MideaACDevice
|
|
|
|
def __init__(
|
|
self,
|
|
device: MideaACDevice,
|
|
entity_key: str,
|
|
config_entry: ConfigEntry,
|
|
) -> None:
|
|
"""Midea AC Climate entity init."""
|
|
super().__init__(device, entity_key)
|
|
self._attr_hvac_modes = [
|
|
HVACMode.OFF,
|
|
HVACMode.AUTO,
|
|
HVACMode.COOL,
|
|
HVACMode.DRY,
|
|
HVACMode.HEAT,
|
|
HVACMode.FAN_ONLY,
|
|
]
|
|
self._fan_speeds: dict[str, int] = {
|
|
FAN_SILENT: 20,
|
|
FAN_LOW: 40,
|
|
FAN_MEDIUM: 60,
|
|
FAN_HIGH: 80,
|
|
FAN_FULL_SPEED: 100,
|
|
FAN_AUTO: 102,
|
|
}
|
|
self._attr_swing_modes: list[str] = [
|
|
SWING_OFF,
|
|
SWING_VERTICAL,
|
|
SWING_HORIZONTAL,
|
|
SWING_BOTH,
|
|
]
|
|
self._attr_preset_modes = [
|
|
PRESET_NONE,
|
|
PRESET_COMFORT,
|
|
PRESET_ECO,
|
|
PRESET_BOOST,
|
|
PRESET_SLEEP,
|
|
PRESET_AWAY,
|
|
]
|
|
self._attr_fan_modes = list(self._fan_speeds.keys())
|
|
# fix error humidity value, disable indoor_humidity
|
|
# add config_entry args to fix indoor_humidity error bug
|
|
self._indoor_humidity_enabled = (
|
|
"sensors" in config_entry.options
|
|
and "indoor_humidity" in config_entry.options["sensors"]
|
|
)
|
|
|
|
@property
|
|
def fan_mode(self) -> str:
|
|
"""Midea AC Climate fan mode."""
|
|
fan_speed = cast("int", self._device.get_attribute(ACAttributes.fan_speed))
|
|
if fan_speed > FanSpeed.AUTO:
|
|
return str(FAN_AUTO)
|
|
if fan_speed > FanSpeed.FULL_SPEED:
|
|
return str(FAN_FULL_SPEED)
|
|
if fan_speed > FanSpeed.HIGH:
|
|
return str(FAN_HIGH)
|
|
if fan_speed > FanSpeed.MEDIUM:
|
|
return str(FAN_MEDIUM)
|
|
if fan_speed > FanSpeed.LOW:
|
|
return str(FAN_LOW)
|
|
return str(FAN_SILENT)
|
|
|
|
@property
|
|
def target_temperature_step(self) -> float:
|
|
"""Midea AC Climate target temperature step."""
|
|
return float(
|
|
PRECISION_WHOLE if self._device.temperature_step == 1 else PRECISION_HALVES,
|
|
)
|
|
|
|
@property
|
|
def swing_mode(self) -> str:
|
|
"""Midea AC Climate swing mode."""
|
|
swing_mode = (
|
|
1 if self._device.get_attribute(ACAttributes.swing_vertical) else 0
|
|
) + (2 if self._device.get_attribute(ACAttributes.swing_horizontal) else 0)
|
|
return self._attr_swing_modes[swing_mode]
|
|
|
|
@property
|
|
def current_humidity(self) -> float | None:
|
|
"""Return the current indoor humidity, or None if unavailable."""
|
|
# fix error humidity, disable indoor_humidity in web UI
|
|
# https://github.com/wuwentao/midea_ac_lan/pull/641
|
|
if not self._indoor_humidity_enabled:
|
|
return None
|
|
raw = self._device.get_attribute("indoor_humidity")
|
|
if isinstance(raw, (int, float)) and raw not in {0, 0xFF}:
|
|
return float(raw)
|
|
# indoor_humidity is 0 or 255, return None
|
|
# https://github.com/wuwentao/midea_ac_lan/pull/614
|
|
return None
|
|
|
|
@property
|
|
def outdoor_temperature(self) -> float:
|
|
"""Midea AC Climate outdoor temperature."""
|
|
return cast(
|
|
"float",
|
|
self._device.get_attribute(ACAttributes.outdoor_temperature),
|
|
)
|
|
|
|
def set_fan_mode(self, fan_mode: str) -> None:
|
|
"""Midea AC Climate set fan mode."""
|
|
fan_speed = self._fan_speeds.get(fan_mode)
|
|
if fan_speed:
|
|
self._device.set_attribute(attr=ACAttributes.fan_speed, value=fan_speed)
|
|
|
|
def set_swing_mode(self, swing_mode: str) -> None:
|
|
"""Midea AC Climate set swing mode."""
|
|
swing = self._attr_swing_modes.index(swing_mode)
|
|
swing_vertical = swing & 1 > 0
|
|
swing_horizontal = swing & 2 > 0
|
|
self._device.set_swing(
|
|
swing_vertical=swing_vertical,
|
|
swing_horizontal=swing_horizontal,
|
|
)
|
|
|
|
|
|
class MideaCCClimate(MideaClimate):
|
|
"""Midea CC Climate Entries Base Class."""
|
|
|
|
_device: MideaCCDevice
|
|
|
|
def __init__(self, device: MideaCCDevice, entity_key: str) -> None:
|
|
"""Midea CC Climate entity init."""
|
|
super().__init__(device, entity_key)
|
|
self._attr_hvac_modes = [
|
|
HVACMode.OFF,
|
|
HVACMode.FAN_ONLY,
|
|
HVACMode.DRY,
|
|
HVACMode.HEAT,
|
|
HVACMode.COOL,
|
|
HVACMode.AUTO,
|
|
]
|
|
self._attr_swing_modes = [SWING_OFF, SWING_ON]
|
|
self._attr_preset_modes = [PRESET_NONE, PRESET_SLEEP, PRESET_ECO]
|
|
|
|
@property
|
|
def fan_modes(self) -> list[str] | None:
|
|
"""Midea CC Climate fan modes."""
|
|
return cast("list", self._device.fan_modes)
|
|
|
|
@property
|
|
def fan_mode(self) -> str:
|
|
"""Midea CC Climate fan mode."""
|
|
return cast("str", self._device.get_attribute(CCAttributes.fan_speed))
|
|
|
|
@property
|
|
def target_temperature_step(self) -> float:
|
|
"""Midea CC Climate target temperature step."""
|
|
return cast(
|
|
"float",
|
|
self._device.get_attribute(CCAttributes.temperature_precision),
|
|
)
|
|
|
|
@property
|
|
def swing_mode(self) -> str:
|
|
"""Midea CC Climate swing mode."""
|
|
return str(
|
|
SWING_ON if self._device.get_attribute(CCAttributes.swing) else SWING_OFF,
|
|
)
|
|
|
|
def set_fan_mode(self, fan_mode: str) -> None:
|
|
"""Midea CC Climate set fan mode."""
|
|
self._device.set_attribute(attr=CCAttributes.fan_speed, value=fan_mode)
|
|
|
|
def set_swing_mode(self, swing_mode: str) -> None:
|
|
"""Midea CC Climate set swing mode."""
|
|
self._device.set_attribute(
|
|
attr=CCAttributes.swing,
|
|
value=swing_mode == SWING_ON,
|
|
)
|
|
|
|
|
|
class MideaCFClimate(MideaClimate):
|
|
"""Midea CF Climate Entries."""
|
|
|
|
_device: MideaCFDevice
|
|
|
|
_attr_target_temperature_step: float | None = PRECISION_WHOLE
|
|
|
|
def __init__(self, device: MideaCFDevice, entity_key: str) -> None:
|
|
"""Midea CF Climate entity init."""
|
|
super().__init__(device, entity_key)
|
|
self._attr_hvac_modes = [
|
|
HVACMode.OFF,
|
|
HVACMode.AUTO,
|
|
HVACMode.COOL,
|
|
HVACMode.HEAT,
|
|
]
|
|
|
|
@property
|
|
def supported_features(self) -> ClimateEntityFeature:
|
|
"""Midea CF Climate supported features."""
|
|
features = ClimateEntityFeature.TARGET_TEMPERATURE
|
|
if (MAJOR_VERSION, MINOR_VERSION) >= (2024, 2):
|
|
features |= ClimateEntityFeature.TURN_OFF | ClimateEntityFeature.TURN_ON
|
|
return features
|
|
|
|
@property
|
|
def min_temp(self) -> float:
|
|
"""Midea CF Climate min temperature."""
|
|
return cast("float", self._device.get_attribute(CFAttributes.min_temperature))
|
|
|
|
@property
|
|
def max_temp(self) -> float:
|
|
"""Midea CF Climate max temperature."""
|
|
return cast("float", self._device.get_attribute(CFAttributes.max_temperature))
|
|
|
|
@property
|
|
def target_temperature_low(self) -> float:
|
|
"""Midea CF Climate target temperature."""
|
|
return cast("float", self._device.get_attribute(CFAttributes.min_temperature))
|
|
|
|
@property
|
|
def target_temperature_high(self) -> float:
|
|
"""Midea CF Climate target temperature high."""
|
|
return cast("float", self._device.get_attribute(CFAttributes.max_temperature))
|
|
|
|
@property
|
|
def current_temperature(self) -> float:
|
|
"""Midea CF Climate current temperature."""
|
|
return cast(
|
|
"float",
|
|
self._device.get_attribute(CFAttributes.current_temperature),
|
|
)
|
|
|
|
|
|
class MideaC3Climate(MideaClimate):
|
|
"""Midea C3 Climate Entries."""
|
|
|
|
_device: MideaC3Device
|
|
|
|
_powers: ClassVar[list[C3Attributes]] = [
|
|
C3Attributes.zone1_power,
|
|
C3Attributes.zone2_power,
|
|
]
|
|
|
|
def __init__(self, device: MideaC3Device, entity_key: str, zone: int) -> None:
|
|
"""Midea C3 Climate entity init."""
|
|
super().__init__(device, entity_key)
|
|
self._zone = zone
|
|
self._attr_hvac_modes = [
|
|
HVACMode.OFF,
|
|
HVACMode.AUTO,
|
|
HVACMode.COOL,
|
|
HVACMode.HEAT,
|
|
]
|
|
self._power_attr = MideaC3Climate._powers[zone]
|
|
|
|
def _temperature(self, minimum: bool) -> list[str]:
|
|
"""Midea C3 Climate temperature.
|
|
|
|
Returns
|
|
-------
|
|
List of temperatures
|
|
|
|
"""
|
|
# fmt: off
|
|
value = (C3Attributes.temperature_min
|
|
if minimum
|
|
else C3Attributes.temperature_max)
|
|
# fmt: on
|
|
return cast("list[str]", self._device.get_attribute(value))
|
|
|
|
@property
|
|
def supported_features(self) -> ClimateEntityFeature:
|
|
"""Midea C3 Climate supported features."""
|
|
features = ClimateEntityFeature.TARGET_TEMPERATURE
|
|
if (MAJOR_VERSION, MINOR_VERSION) >= (2024, 2):
|
|
features |= ClimateEntityFeature.TURN_OFF | ClimateEntityFeature.TURN_ON
|
|
return features
|
|
|
|
@property
|
|
def target_temperature_step(self) -> float:
|
|
"""Midea C3 Climate target temperature step."""
|
|
zone_temp_type = cast(
|
|
"list[str]",
|
|
self._device.get_attribute(C3Attributes.zone_temp_type),
|
|
)
|
|
return float(
|
|
PRECISION_WHOLE if zone_temp_type[self._zone] else PRECISION_HALVES,
|
|
)
|
|
|
|
@property
|
|
def min_temp(self) -> float:
|
|
"""Midea C3 Climate min temperature."""
|
|
return cast(
|
|
"float",
|
|
self._temperature(True)[self._zone],
|
|
)
|
|
|
|
@property
|
|
def max_temp(self) -> float:
|
|
"""Midea C3 Climate max temperature."""
|
|
return cast(
|
|
"float",
|
|
self._temperature(False)[self._zone],
|
|
)
|
|
|
|
@property
|
|
def target_temperature_low(self) -> float:
|
|
"""Midea C3 Climate target temperature low."""
|
|
return cast(
|
|
"float",
|
|
self._temperature(True)[self._zone],
|
|
)
|
|
|
|
@property
|
|
def target_temperature_high(self) -> float:
|
|
"""Midea C3 Climate target temperature high."""
|
|
return cast(
|
|
"float",
|
|
self._temperature(False)[self._zone],
|
|
)
|
|
|
|
def turn_on(self, **kwargs: Any) -> None: # noqa: ANN401, ARG002
|
|
"""Midea C3 Climate turn on."""
|
|
self._device.set_attribute(attr=self._power_attr, value=True)
|
|
|
|
def turn_off(self, **kwargs: Any) -> None: # noqa: ANN401, ARG002
|
|
"""Midea C3 Climate turn off."""
|
|
self._device.set_attribute(attr=self._power_attr, value=False)
|
|
|
|
@property
|
|
def hvac_mode(self) -> HVACMode:
|
|
"""Midea C3 Climate hvac mode."""
|
|
mode = self._device.get_attribute(C3Attributes.mode)
|
|
if self._device.get_attribute(self._power_attr) and isinstance(mode, int):
|
|
return self.hvac_modes[mode]
|
|
return HVACMode.OFF
|
|
|
|
@property
|
|
def target_temperature(self) -> float:
|
|
"""Midea C3 Climate target temperature."""
|
|
target_temperature = cast(
|
|
"list[str]",
|
|
self._device.get_attribute(C3Attributes.target_temperature),
|
|
)
|
|
return cast(
|
|
"float",
|
|
target_temperature[self._zone],
|
|
)
|
|
|
|
@property
|
|
def current_temperature(self) -> float | None:
|
|
"""Midea C3 Climate current temperature."""
|
|
return None
|
|
|
|
def set_temperature(self, **kwargs: Any) -> None: # noqa: ANN401
|
|
"""Midea C3 Climate set temperature."""
|
|
if ATTR_TEMPERATURE not in kwargs:
|
|
return
|
|
temperature = float(int((float(kwargs[ATTR_TEMPERATURE]) * 2) + 0.5)) / 2
|
|
hvac_mode = kwargs.get(ATTR_HVAC_MODE)
|
|
if hvac_mode == HVACMode.OFF:
|
|
self.turn_off()
|
|
else:
|
|
try:
|
|
mode = self.hvac_modes.index(hvac_mode.lower()) if hvac_mode else None
|
|
self._device.set_target_temperature(
|
|
target_temperature=temperature,
|
|
mode=mode,
|
|
zone=self._zone,
|
|
)
|
|
except ValueError:
|
|
_LOGGER.exception("Error setting temperature with: %s", kwargs)
|
|
|
|
def set_hvac_mode(self, hvac_mode: HVACMode) -> None:
|
|
"""Midea C3 Climate set hvac mode."""
|
|
if hvac_mode == HVACMode.OFF:
|
|
self.turn_off()
|
|
else:
|
|
self._device.set_mode(self._zone, self.hvac_modes.index(hvac_mode))
|
|
|
|
|
|
class MideaFBClimate(MideaClimate):
|
|
"""Midea FB Climate Entries."""
|
|
|
|
_device: MideaFBDevice
|
|
|
|
_attr_max_temp: float = 35
|
|
_attr_min_temp: float = 5
|
|
_attr_target_temperature_high: float | None = 35
|
|
_attr_target_temperature_low: float | None = 5
|
|
_attr_target_temperature_step: float | None = PRECISION_WHOLE
|
|
|
|
def __init__(self, device: MideaFBDevice, entity_key: str) -> None:
|
|
"""Midea FB Climate entity init."""
|
|
super().__init__(device, entity_key)
|
|
self._attr_hvac_modes = [HVACMode.OFF, HVACMode.HEAT]
|
|
self._attr_preset_modes: list[str] = self._device.modes
|
|
|
|
@property
|
|
def supported_features(self) -> ClimateEntityFeature:
|
|
"""Midea FB Climate supported features."""
|
|
features = (
|
|
ClimateEntityFeature.TARGET_TEMPERATURE | ClimateEntityFeature.PRESET_MODE
|
|
)
|
|
if (MAJOR_VERSION, MINOR_VERSION) >= (2024, 2):
|
|
features |= ClimateEntityFeature.TURN_OFF | ClimateEntityFeature.TURN_ON
|
|
return features
|
|
|
|
@property
|
|
def preset_mode(self) -> str:
|
|
"""Midea FB Climate preset mode."""
|
|
return cast("str", self._device.get_attribute(attr=FBAttributes.mode))
|
|
|
|
@property
|
|
def hvac_mode(self) -> HVACMode:
|
|
"""Midea FB Climate hvac mode."""
|
|
return (
|
|
HVACMode.HEAT
|
|
if self._device.get_attribute(attr=FBAttributes.power)
|
|
else HVACMode.OFF
|
|
)
|
|
|
|
@property
|
|
def current_temperature(self) -> float:
|
|
"""Midea FB Climate current temperature."""
|
|
return cast(
|
|
"float",
|
|
self._device.get_attribute(FBAttributes.current_temperature),
|
|
)
|
|
|
|
def set_temperature(self, **kwargs: Any) -> None: # noqa: ANN401
|
|
"""Midea FB Climate set temperature."""
|
|
if ATTR_TEMPERATURE not in kwargs:
|
|
return
|
|
temperature = float(int((float(kwargs[ATTR_TEMPERATURE]) * 2) + 0.5)) / 2
|
|
hvac_mode = kwargs.get(ATTR_HVAC_MODE)
|
|
if hvac_mode == HVACMode.OFF:
|
|
self.turn_off()
|
|
else:
|
|
self._device.set_target_temperature(
|
|
target_temperature=temperature,
|
|
mode=None,
|
|
)
|
|
|
|
def set_hvac_mode(self, hvac_mode: HVACMode) -> None:
|
|
"""Midea FB Climate set hvac mode."""
|
|
if hvac_mode == HVACMode.OFF:
|
|
self.turn_off()
|
|
else:
|
|
self.turn_on()
|
|
|
|
def set_preset_mode(self, preset_mode: str) -> None:
|
|
"""Midea FB Climate set preset mode."""
|
|
self._device.set_attribute(attr=FBAttributes.mode, value=preset_mode)
|