151 lines
5.7 KiB
Python
151 lines
5.7 KiB
Python
"""Support for humidifier and dehumidifier."""
|
|
import logging
|
|
from bisect import bisect
|
|
|
|
from homeassistant.components.humidifier import (
|
|
DOMAIN as ENTITY_DOMAIN,
|
|
HumidifierEntity as BaseEntity,
|
|
HumidifierEntityFeature, # v2022.5
|
|
HumidifierDeviceClass,
|
|
)
|
|
|
|
from . import (
|
|
DOMAIN,
|
|
XIAOMI_CONFIG_SCHEMA as PLATFORM_SCHEMA, # noqa: F401
|
|
HassEntry,
|
|
XEntity,
|
|
async_setup_config_entry,
|
|
bind_services_to_entries,
|
|
)
|
|
from .core.miot_spec import MiotProperty
|
|
|
|
_LOGGER = logging.getLogger(__name__)
|
|
DATA_KEY = f'{ENTITY_DOMAIN}.{DOMAIN}'
|
|
MODE_OFF = 'Off'
|
|
|
|
|
|
async def async_setup_entry(hass, config_entry, async_add_entities):
|
|
HassEntry.init(hass, config_entry).new_adder(ENTITY_DOMAIN, async_add_entities)
|
|
await async_setup_config_entry(hass, config_entry, async_setup_platform, async_add_entities, ENTITY_DOMAIN)
|
|
|
|
|
|
async def async_setup_platform(hass, config, async_add_entities, discovery_info=None):
|
|
bind_services_to_entries(hass, {})
|
|
|
|
|
|
class HumidifierEntity(XEntity, BaseEntity):
|
|
_attr_mode = None
|
|
_attr_available_modes = None
|
|
_conv_power = None
|
|
_conv_mode = None
|
|
_conv_target_humidity = None
|
|
_conv_current_humidity = None
|
|
_target_humidity_ratio = 1
|
|
_target_humidity_step = None
|
|
|
|
def on_init(self):
|
|
self._attr_available_modes = []
|
|
self._target_humidity_ratio = self.custom_config_number('target_humidity_ratio', 1)
|
|
|
|
for attr in self.conv.attrs:
|
|
conv = self.device.find_converter(attr)
|
|
prop = getattr(conv, 'prop', None) if conv else None
|
|
if not isinstance(prop, MiotProperty):
|
|
continue
|
|
elif prop.in_list(['on']):
|
|
self._conv_power = conv
|
|
self._attr_available_modes.append(MODE_OFF)
|
|
self._attr_supported_features |= HumidifierEntityFeature.MODES
|
|
elif prop.in_list(['mode', 'fan_level']) and not self._conv_mode:
|
|
self._conv_mode = conv
|
|
self._attr_available_modes.extend(prop.list_descriptions())
|
|
self._attr_supported_features |= HumidifierEntityFeature.MODES
|
|
elif prop.in_list(['relative_humidity', 'humidity']):
|
|
self._conv_current_humidity = conv
|
|
elif prop.in_list(['target_humidity']):
|
|
self._conv_target_humidity = conv
|
|
if prop.value_range:
|
|
self._attr_min_humidity = prop.range_min()
|
|
self._attr_max_humidity = prop.range_max()
|
|
self._target_humidity_step = prop.range_step()
|
|
elif prop.value_list:
|
|
vls = prop.list_value(None)
|
|
vls.sort()
|
|
self._attr_min_humidity = vls[0]
|
|
self._attr_max_humidity = vls[-1]
|
|
if self._target_humidity_ratio:
|
|
self._attr_min_humidity = round(self._attr_min_humidity * self._target_humidity_ratio)
|
|
self._attr_max_humidity = round(self._attr_max_humidity * self._target_humidity_ratio)
|
|
|
|
typ = f'{self.model} {self._miot_service.spec.type}'
|
|
if 'dehumidifier' in typ or '.derh.' in typ:
|
|
self._attr_device_class = HumidifierDeviceClass.DEHUMIDIFIER
|
|
else:
|
|
self._attr_device_class = HumidifierDeviceClass.HUMIDIFIER
|
|
|
|
def set_state(self, data: dict):
|
|
if self._conv_mode:
|
|
val = self._conv_mode.value_from_dict(data)
|
|
if val is not None:
|
|
self._attr_mode = val
|
|
if self._conv_power:
|
|
val = self._conv_power.value_from_dict(data)
|
|
if val is not None:
|
|
self._attr_is_on = bool(val)
|
|
if not self._attr_is_on:
|
|
self._attr_mode = MODE_OFF
|
|
if self._conv_target_humidity:
|
|
val = self._conv_target_humidity.value_from_dict(data)
|
|
if val is not None:
|
|
self._attr_target_humidity = round(val * self._target_humidity_ratio)
|
|
if self._conv_current_humidity:
|
|
val = self._conv_current_humidity.value_from_dict(data)
|
|
if val is not None:
|
|
self._attr_current_humidity = val
|
|
|
|
async def async_turn_on(self):
|
|
if not self._conv_power:
|
|
return
|
|
await self.device.async_write({self._conv_power.full_name: True})
|
|
|
|
async def async_turn_off(self):
|
|
if not self._conv_power:
|
|
return
|
|
await self.device.async_write({self._conv_power.full_name: False})
|
|
|
|
async def async_set_mode(self, mode: str):
|
|
if mode == MODE_OFF:
|
|
await self.async_turn_off()
|
|
return
|
|
data = {}
|
|
if not self._attr_is_on and self._conv_power:
|
|
data[self._conv_power.full_name] = True
|
|
if self._conv_mode:
|
|
data[self._conv_mode.full_name] = mode
|
|
if data:
|
|
await self.device.async_write(data)
|
|
|
|
async def async_set_humidity(self, humidity: int):
|
|
if not self._conv_target_humidity:
|
|
return
|
|
data = {}
|
|
if not self._attr_is_on and self._conv_power:
|
|
data[self._conv_power.full_name] = True
|
|
|
|
prop = getattr(self._conv_target_humidity, 'prop', None)
|
|
if self._target_humidity_step:
|
|
humidity = round(humidity / self._target_humidity_step) * self._target_humidity_step
|
|
elif prop and prop.value_list:
|
|
vls = prop.list_value(None)
|
|
vls.sort()
|
|
idx = bisect(vls, humidity)
|
|
humidity = vls[idx - 1] if idx > 0 else vls[0]
|
|
if self._target_humidity_ratio:
|
|
humidity = round(humidity / self._target_humidity_ratio)
|
|
|
|
data[self._conv_target_humidity.full_name] = humidity
|
|
await self.device.async_write(data)
|
|
|
|
|
|
XEntity.CLS[ENTITY_DOMAIN] = HumidifierEntity
|