'weak_dry': '低温烘',
'rinse_spin': '漂+脱',
'spin': '单脱水',
'drumclean': '筒清洁',
'cottons': '棉织物',
'down': '羽绒服',
'wool': '羊毛',
'shirt': '衬衣',
'jeans': '牛仔',
'underwears': '内衣',
}
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_HOST):
cv.string,
vol.Required(CONF_TOKEN):
vol.All(cv.string, vol.Length(min=32, max=32)),
vol.Optional(CONF_NAME):
cv.string,
})
async def async_setup_platform(hass,
config,
async_add_entities,
discovery_info=None):
"""Set up the light from config."""
host = config[CONF_HOST]
token = config[CONF_TOKEN]
name = config.get(CONF_NAME)
async_add_entities([VioMiWasher(name, host, token)], True)
DEFAULT_NAME = "SmartIR Fan"
DEFAULT_DELAY = 0.5
CONF_UNIQUE_ID = 'unique_id'
CONF_DEVICE_CODE = 'device_code'
CONF_CONTROLLER_DATA = "controller_data"
CONF_DELAY = "delay"
CONF_POWER_SENSOR = 'power_sensor'
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Optional(CONF_UNIQUE_ID):
cv.string,
vol.Optional(CONF_NAME, default=DEFAULT_NAME):
cv.string,
vol.Required(CONF_DEVICE_CODE):
cv.positive_int,
vol.Required(CONF_CONTROLLER_DATA):
cv.string,
vol.Optional(CONF_DELAY, default=DEFAULT_DELAY):
cv.string,
vol.Optional(CONF_POWER_SENSOR):
cv.entity_id
})
async def async_setup_platform(hass,
config,
async_add_entities,
discovery_info=None):
"""Set up the IR Fan platform."""
device_code = config.get(CONF_DEVICE_CODE)
device_files_subdir = os.path.join('codes', 'fan')
CONF_MODEL = 'model'
MODEL_AIRPURIFIER_PRO = 'zhimi.airpurifier.v6'
MODEL_AIRPURIFIER_V3 = 'zhimi.airpurifier.v3'
MODEL_AIRHUMIDIFIER_V1 = 'zhimi.humidifier.v1'
MODEL_AIRHUMIDIFIER_CA = 'zhimi.humidifier.ca1'
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_HOST): cv.string,
vol.Required(CONF_TOKEN): vol.All(cv.string, vol.Length(min=32, max=32)),
vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
vol.Optional(CONF_MODEL): vol.In(
['zhimi.airpurifier.m1',
'zhimi.airpurifier.m2',
'zhimi.airpurifier.ma1',
'zhimi.airpurifier.ma2',
'zhimi.airpurifier.sa1',
'zhimi.airpurifier.sa2',
'zhimi.airpurifier.v1',
'zhimi.airpurifier.v2',
'zhimi.airpurifier.v3',
'zhimi.airpurifier.v5',
'zhimi.airpurifier.v6',
'zhimi.humidifier.v1',
'zhimi.humidifier.ca1']),
})
REQUIREMENTS = ['python-miio==0.3.9', 'construct==2.9.41']
ATTR_MODEL = 'model'
# Air Purifier
ICON = "mdi:air-purifier"
SPEED_LIST = [
"Auto Mode",
"Allergen Mode",
"Sleep Mode",
"Speed 1",
"Speed 2",
"Speed 3",
"Turbo",
]
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_HOST):
cv.string,
vol.Optional(CONF_NAME, default=DEFAULT_NAME):
cv.string,
vol.Optional(CONF_PROTOCOL, default=DEFAULT_PROTOCOL):
cv.string,
})
### Setup Platform ###
def setup_platform(hass, config, add_devices, discovery_info=None):
add_devices([PhilipsAirPurifierFan(hass, config)])
class PhilipsAirPurifierFan(FanEntity):
def __init__(self, hass, config):
self.hass = hass
self._host = config[CONF_HOST]
SPEED_LOW, SPEED_MEDIUM, SPEED_HIGH, FanEntity, SUPPORT_SET_SPEED,
PLATFORM_SCHEMA)
from homeassistant.components.velbus import DOMAIN
from homeassistant.const import CONF_NAME, CONF_DEVICES, STATE_OFF
import homeassistant.helpers.config_validation as cv
DEPENDENCIES = ['velbus']
_LOGGER = logging.getLogger(__name__)
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_DEVICES): vol.All(cv.ensure_list, [
{
vol.Required('module'): cv.positive_int,
vol.Required('channel_low'): cv.positive_int,
vol.Required('channel_medium'): cv.positive_int,
vol.Required('channel_high'): cv.positive_int,
vol.Required(CONF_NAME): cv.string,
}
])
})
def setup_platform(hass, config, add_devices, discovery_info=None):
"""Set up Fans."""
velbus = hass.data[DOMAIN]
add_devices(VelbusFan(fan, velbus) for fan in config[CONF_DEVICES])
class VelbusFan(FanEntity):
"""Representation of a Velbus Fan."""
from homeassistant.components.fan import (
FanEntity,
SPEED_OFF,
SUPPORT_SET_SPEED,
SUPPORT_PRESET_MODE,
PLATFORM_SCHEMA,
DOMAIN,
)
from miio import DeviceException
from miio.device import Device
_LOGGER = logging.getLogger(__name__)
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_NAME): cv.string,
vol.Required(CONF_HOST): cv.string,
vol.Required(CONF_TOKEN): cv.string,
})
AVAILABLE_PROPERTIES = [
"state",
"process",
"cycle",
"time_remain",
"child_lock",
"volume",
]
PRESET_MODES = [
'pause',
'start',
import logging
import voluptuous as vol
from homeassistant.components.fan import (FanEntity, SPEED_OFF, SPEED_LOW,
SPEED_MEDIUM, SPEED_HIGH,
SUPPORT_SET_SPEED, PLATFORM_SCHEMA)
from homeassistant.const import CONF_HOST
import homeassistant.helpers.config_validation as cv
_LOGGER = logging.getLogger(__name__)
# Validation of the user's configuration
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({vol.Required(CONF_HOST): cv.string})
async def async_setup_platform(hass,
config,
async_add_entities,
discovery_info=None):
import quietcool
host = config.get(CONF_HOST)
_LOGGER.info(f"Calling get fans for hub: {host}")
hub = await quietcool.Hub.create(host)
fans = await hub.get_fans()
async_add_entities(QuietcoolFan(fan) for fan in fans)
class QuietcoolFan(FanEntity):
def __init__(self, fan) -> None:
self._fan = fan
@property
SPEED_LOW,
SPEED_MEDIUM,
SPEED_HIGH,
SUPPORT_SET_SPEED,
SUPPORT_OSCILLATE,
SUPPORT_DIRECTION,
)
from homeassistant.const import CONF_ID, CONF_FRIENDLY_NAME, STATE_OFF
import homeassistant.helpers.config_validation as cv
from . import BASE_PLATFORM_SCHEMA, prepare_setup_entities, import_from_yaml
from .pytuya import TuyaDevice
_LOGGER = logging.getLogger(__name__)
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(BASE_PLATFORM_SCHEMA)
def flow_schema(dps):
"""Return schema used in config flow."""
return {}
async def async_setup_entry(hass, config_entry, async_add_entities):
"""Setup a Tuya fan based on a config entry."""
device, entities_to_setup = prepare_setup_entities(config_entry, DOMAIN)
if not entities_to_setup:
return
fans = []
CONF_TYPE = 'type'
DEVICE_SCHEMA = vol.Schema({
vol.Required(CONF_C4ID): cv.positive_int,
vol.Optional(CONF_TYPE, default="fan"): cv.string,
vol.Optional(CONF_DESC, default=""): cv.string,
vol.Optional(CONF_LATITUDE, default=0): cv.latitude,
vol.Optional(CONF_LONGITUDE, default=0): cv.longitude,
vol.Optional(CONF_DIMMABLE, default=True): cv.boolean,
vol.Optional(CONF_C4VAR_FAN_SPEED, default=1001): cv.positive_int,
vol.Optional(CONF_C4VAR_STATUS, default=1000): cv.positive_int,
vol.Optional(CONF_SCAN_INTERVAL, default=10): vol.All(vol.Coerce(int), vol.Range(min=1))
})
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Optional(CONF_DEVICES, default={}): {cv.string: DEVICE_SCHEMA}
})
async def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
"""Set up Control4 fans"""
_LOGGER.debug('async_setup_platform: %s, %s', str(config), str(discovery_info))
switch = hass.data[DATA_CONTROL4].control4
devices = [Control4Fan(device_name, device, switch) for device_name, device in config[CONF_DEVICES].items()]
async_add_devices(devices, True)
async def async_setup_entry(hass, entry, async_add_devices):
"""Set up Control4 fans"""
SPEED_OFF,
SUPPORT_SET_SPEED,
FanEntity,
PLATFORM_SCHEMA,
)
from homeassistant.components.switch import SwitchEntity
_LOGGER = logging.getLogger(__name__)
DOMAIN = "dl_4112_fan"
# Validation of the user's configuration
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_HOST):
cv.string,
vol.Required("fans"):
vol.All(cv.ensure_list, [cv.string]),
})
def setup_platform(hass, config, add_entities, discovery_info=None):
"""Set up the Awesome Light platform."""
# Assign configuration variables.
# The configuration check takes care they are present.
host = config[CONF_HOST]
fans = config["fans"]
d = DeviceApi(host)
try:
d.ping()
except APIError as e:
import homeassistant.helpers.config_validation as cv
import voluptuous as vol
from miio import Device, DeviceException
_LOGGER = logging.getLogger(__name__)
DEFAULT_NAME = "Xiaomi Miio Device"
DATA_KEY = "fan.xiaomi_airpurifierProH"
REQUIREMENTS = ['python-miio>=0.4.8']
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
{
vol.Required(CONF_HOST): cv.string,
vol.Required(CONF_TOKEN): vol.All(str, vol.Length(min=32, max=32)),
vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
},
extra=vol.ALLOW_EXTRA,
)
# Air Purifier
ATTR_POWER = "power"
ATTR_SPEED = "speed"
ATTR_TEMPERATURE = "temperature"
ATTR_HUMIDITY = "humidity"
ATTR_AIR_QUALITY_INDEX = "aqi"
ATTR_FILTER_HOURS_USED = "filter_hours_used"
ATTR_FILTER_LIFE = "filter_life_remaining"
ATTR_FAVORITE_LEVEL = "favorite_level"
ATTR_BUZZER = "buzzer"
ATTR_CHILD_LOCK = "child_lock"
int_states_in_range,
ranged_value_to_percentage,
percentage_to_ranged_value,
)
from . import AIRSCAPE_DOMAIN
from .const import fan_to_hass_attr, DEFAULT_TIMEOUT, DEFAULT_MINIMUM
_LOGGER = logging.getLogger(__name__)
# Validation of the user's configuration
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_HOST):
cv.string,
vol.Required(CONF_NAME):
cv.string,
vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT):
cv.positive_int,
vol.Optional(CONF_MINIMUM, default=DEFAULT_MINIMUM):
cv.positive_int,
})
def setup_platform(hass, config, add_entities, discovery_info=None):
"""Set up the Airscape Fan platform."""
# Setup connection to the fan
host = config.get(CONF_HOST)
name = config.get(CONF_NAME)
minimum = config.get(CONF_MINIMUM)
timeout = config.get(CONF_TIMEOUT)
try:
DEFAULT_NAME = 'Broadlink Fan'
DEFAULT_TIMEOUT = 10
DEFAULT_RETRY = 3
DEFAULT_SPEED_LIST = [STATE_OFF, SPEED_LOW, SPEED_MEDIUM, SPEED_HIGH]
DEFAULT_SPEED = SPEED_MEDIUM
DEFAULT_DIRECTION = DIRECTION_ANTICLOCKWISE
CUSTOMIZE_SCHEMA = vol.Schema({
vol.Optional(CONF_SPEEDS): vol.All(cv.ensure_list, [cv.string])
})
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
vol.Required(CONF_HOST): cv.string,
vol.Required(CONF_MAC): cv.string,
vol.Required(CONF_RFCODES_INI): cv.string,
vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): cv.positive_int,
vol.Optional(CONF_CUSTOMIZE, default={}): CUSTOMIZE_SCHEMA,
vol.Optional(CONF_DEFAULT_SPEED, default=DEFAULT_SPEED): cv.string,
vol.Optional(CONF_DEFAULT_DIRECTION, default=DEFAULT_DIRECTION): cv.string
})
# pylint: disable=unused-argument
def setup_platform(hass, config, add_devices_callback, discovery_info=None):
"""Set up the Broadlink-controlled fan platform."""
name = config.get(CONF_NAME)
ip_addr = config.get(CONF_HOST)
mac_addr = binascii.unhexlify(config.get(CONF_MAC).encode().replace(b':', b''))
speed_list = config.get(CONF_CUSTOMIZE).get(CONF_SPEEDS, []) or DEFAULT_SPEED_LIST
if not STATE_OFF in speed_list:
speed_list.insert(0, STATE_OFF)
default_speed = config.get(CONF_DEFAULT_SPEED)
MODEL_FAN_SA1 = "zhimi.fan.sa1"
MODEL_FAN_ZA1 = "zhimi.fan.za1"
MODEL_FAN_ZA3 = "zhimi.fan.za3"
MODEL_FAN_ZA4 = "zhimi.fan.za4"
MODEL_FAN_P5 = "dmaker.fan.p5"
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_HOST):
cv.string,
vol.Required(CONF_TOKEN):
vol.All(cv.string, vol.Length(min=32, max=32)),
vol.Optional(CONF_NAME, default=DEFAULT_NAME):
cv.string,
vol.Optional(CONF_MODEL):
vol.In([
MODEL_FAN_V2,
MODEL_FAN_V3,
MODEL_FAN_SA1,
MODEL_FAN_ZA1,
MODEL_FAN_ZA3,
MODEL_FAN_ZA4,
MODEL_FAN_P5,
]),
vol.Optional(CONF_RETRIES, default=DEFAULT_RETRIES):
cv.positive_int,
})
ATTR_MODEL = "model"
ATTR_BRIGHTNESS = "brightness"
ATTR_TEMPERATURE = "temperature"
ATTR_HUMIDITY = "humidity"
SPEED_MEDIUM, SPEED_HIGH)
from homeassistant.const import (CONF_NAME, STATE_ON)
from homeassistant.helpers.restore_state import RestoreEntity
from homeassistant.util.percentage import ordered_list_item_to_percentage, percentage_to_ordered_list_item
from .const import DEFAULT_NAME, CONF_REMOTE_ENTITY, CONF_COMMAND_ON_OFF, CONF_COMMAND_SPEED, CONF_COMMAND_OSCILLATE, CONF_COMMAND_DEVICE, \
DEFAULT_DELAY
_LOGGER = logging.getLogger(__name__)
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Optional(CONF_NAME, default=DEFAULT_NAME):
cv.string,
vol.Required(CONF_REMOTE_ENTITY):
cv.string,
vol.Required(CONF_COMMAND_DEVICE):
cv.string,
vol.Required(CONF_COMMAND_ON_OFF):
cv.string,
vol.Required(CONF_COMMAND_SPEED):
cv.string,
vol.Required(CONF_COMMAND_OSCILLATE):
cv.string,
})
FAN_SPEEDS = [SPEED_LOW, SPEED_MEDIUM, SPEED_HIGH]
async def async_setup_platform(hass,
config,
async_add_entities,
discovery_info=None):
"""Set up the IR Fan platform."""
MINIMUM_DELAY_BETWEEN_STATE_CHANGES = 15.0
# FIXME: support enabling exhaust-only mode
VENTILATION_NORMAL = "normal"
VENTILATION_SUMMER = "summer"
VENTILATION_EXHAUST = "exhaust-only"
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
{
vol.Optional(
CONF_NAME
): cv.string, # NOTE: we default the name later based on logic
vol.Optional(CONF_RELAY_W1): cv.string, # cv.entity_id
vol.Optional(CONF_RELAY_W2): cv.string, # cv.entity_id
vol.Optional(CONF_DEFAULT_SPEED, default=DEFAULT_SPEED): vol.In(SPEED_LIST),
# vol.Optional(CONF_CONTROLLER_CODING, default='e2-usa'): cv.string,
vol.Optional(CONF_CONTROLLER_CODING, default="e2-usa"): vol.In(
LUNOS_CODING_CONFIG.keys()
),
vol.Optional(CONF_FAN_COUNT): vol.In(
[1, 2, 3, 4]
), # default is based on how controller is coded (see below)
}
)
# pylint: disable=unused-argument
async def async_setup_platform(hass, config, async_add_entities, discovery_info=None):
"""Initialize the LUNOS fans from config."""
name = config.get(CONF_NAME)
if not name:
name = DEFAULT_LUNOS_NAME
CONF_DEVICE_ID = 'device_id'
CONF_LOCAL_KEY = 'local_key'
CONF_PROTOCOL_VERSION = 'protocol_version'
DEFAULT_ID = '1'
DEFAULT_PROTOCOL_VERSION = 3.3
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Optional(CONF_ICON):
cv.icon,
vol.Required(CONF_HOST):
cv.string,
vol.Required(CONF_DEVICE_ID):
cv.string,
vol.Required(CONF_LOCAL_KEY):
cv.string,
vol.Required(CONF_NAME):
cv.string,
vol.Required(CONF_FRIENDLY_NAME):
cv.string,
vol.Required(CONF_PROTOCOL_VERSION, default=DEFAULT_PROTOCOL_VERSION):
vol.Coerce(float),
vol.Optional(CONF_ID, default=DEFAULT_ID):
cv.string,
})
def setup_platform(hass, config, add_entities, discovery_info=None):
"""Set up of the Tuya switch."""
from . import pytuya
fans = []
localtuyadevice = pytuya.FanDevice(config.get(CONF_DEVICE_ID),
MODEL_AIRHUMIDIFIER_CA = 'zhimi.humidifier.ca1'
MODEL_AIRFRESH_VA2 = 'zhimi.airfresh.va2'
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_HOST): cv.string,
vol.Required(CONF_TOKEN): vol.All(cv.string, vol.Length(min=32, max=32)),
vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
vol.Optional(CONF_MODEL): vol.In(
[MODEL_AIRPURIFIER_V1,
MODEL_AIRPURIFIER_V2,
MODEL_AIRPURIFIER_V3,
MODEL_AIRPURIFIER_V5,
MODEL_AIRPURIFIER_PRO,
MODEL_AIRPURIFIER_PRO_V7,
MODEL_AIRPURIFIER_M1,
MODEL_AIRPURIFIER_M2,
MODEL_AIRPURIFIER_MA1,
MODEL_AIRPURIFIER_MA2,
MODEL_AIRPURIFIER_SA1,
MODEL_AIRPURIFIER_SA2,
MODEL_AIRPURIFIER_2S,
MODEL_AIRHUMIDIFIER_V1,
MODEL_AIRHUMIDIFIER_CA,
MODEL_AIRFRESH_VA2,
]),
})
ATTR_MODEL = 'model'
# Air Purifier
)
# mypy: allow-untyped-calls, allow-untyped-defs, no-check-untyped-defs
SERVICES = {
switch.DOMAIN: (switch.SERVICE_TURN_ON, switch.SERVICE_TURN_OFF),
light.DOMAIN: (light.SERVICE_TURN_ON, light.SERVICE_TURN_OFF)
}
_LOGGER = logging.getLogger(__name__)
DEFAULT_NAME = "Fan Switch"
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Optional(CONF_NAME, default=DEFAULT_NAME):
cv.string,
vol.Required(CONF_ENTITY_ID):
cv.string,
})
async def async_setup_platform(
hass: HomeAssistantType,
config: ConfigType,
async_add_entities: Callable[[Sequence[Entity], bool], None],
discovery_info: Optional[DiscoveryInfoType] = None,
) -> None:
"""Initialize Fan Switch platform."""
async_add_entities(
[FanSwitch(cast(str, config.get(CONF_NAME)), config[CONF_ENTITY_ID])],
True)
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_HOST):
cv.string,
vol.Required(CONF_TOKEN):
vol.All(cv.string, vol.Length(min=32, max=32)),
vol.Optional(CONF_NAME, default=DEFAULT_NAME):
cv.string,
vol.Optional(CONF_MODEL):
vol.In([
MODEL_FAN_V2,
MODEL_FAN_V3,
MODEL_FAN_SA1,
MODEL_FAN_ZA1,
MODEL_FAN_ZA3,
MODEL_FAN_ZA4,
MODEL_FAN_ZA5,
MODEL_FAN_P5,
MODEL_FAN_P8,
MODEL_FAN_P9,
MODEL_FAN_P10,
MODEL_FAN_P11,
MODEL_FAN_P15,
MODEL_FAN_LESHOW_SS4,
MODEL_FAN_1C,
]),
vol.Optional(CONF_RETRIES, default=DEFAULT_RETRIES):
cv.positive_int,
vol.Optional(CONF_PRESET_MODES_OVERRIDE, default=None):
vol.Any(None, [cv.string]),
})
SUPPORTED_FLAGS = {
FanEntityFeature.SET_SPEED,
FanEntityFeature.DIRECTION,
FanEntityFeature.OSCILLATE,
}
DEFAULT_NAME = "Fan Group"
# No limit on parallel updates to enable a group calling another group
PARALLEL_UPDATES = 0
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_ENTITIES):
cv.entities_domain(DOMAIN),
vol.Optional(CONF_NAME, default=DEFAULT_NAME):
cv.string,
vol.Optional(CONF_UNIQUE_ID):
cv.string,
})
_LOGGER = logging.getLogger(__name__)
async def async_setup_platform(
hass: HomeAssistant,
config: ConfigType,
async_add_entities: AddEntitiesCallback,
discovery_info: DiscoveryInfoType | None = None,
) -> None:
"""Set up the Fan Group platform."""
async_add_entities([
DEFAULT_NAME = "Generic MIoT fan"
DATA_KEY = "fan.xiaomi_miot_raw"
CONF_UPDATE_INSTANT = "update_instant"
CONF_MAPPING = 'mapping'
CONF_CONTROL_PARAMS = 'params'
ATTR_STATE_VALUE = "state_value"
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_HOST):
cv.string,
vol.Required(CONF_TOKEN):
vol.All(cv.string, vol.Length(min=32, max=32)),
vol.Optional(CONF_NAME, default=DEFAULT_NAME):
cv.string,
vol.Optional(CONF_UPDATE_INSTANT, default=True):
cv.boolean,
vol.Required(CONF_MAPPING):
vol.All(),
vol.Required(CONF_CONTROL_PARAMS):
vol.All(),
})
ATTR_MODEL = "model"
ATTR_FIRMWARE_VERSION = "firmware_version"
ATTR_HARDWARE_VERSION = "hardware_version"
# pylint: disable=unused-argument
@asyncio.coroutine
def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
FULL_SUPPORT = SUPPORT_SET_SPEED | SUPPORT_OSCILLATE | SUPPORT_DIRECTION
LIMITED_SUPPORT = SUPPORT_SET_SPEED
REQUIREMENTS = ['pytuya==7.0.2', 'pyaes==1.6.1']
CONF_DEVICE_ID = 'device_id'
CONF_LOCAL_KEY = 'local_key'
DEFAULT_ID = 1
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_NAME):
cv.string,
vol.Required(CONF_HOST):
cv.string,
vol.Required(CONF_DEVICE_ID):
cv.string,
vol.Required(CONF_LOCAL_KEY):
cv.string,
vol.Optional(CONF_ID, default=DEFAULT_ID):
cv.string,
})
def setup_platform(hass, config, add_devices, discovery_info=None):
"""Set up of the Tuya switch."""
import pytuya
add_devices([
TuyaLocalFan(
pytuya.OutletDevice(
config.get(CONF_DEVICE_ID),
ATTR_HARDWARE_VERSION,
SCHEMA,
MAP,
DUMMY_IP,
DUMMY_TOKEN,
)
import copy
TYPE = 'fan'
_LOGGER = logging.getLogger(__name__)
DEFAULT_NAME = "Generic MIoT " + TYPE
DATA_KEY = TYPE + '.' + DOMAIN
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
SCHEMA
)
SCAN_INTERVAL = timedelta(seconds=10)
NEW_FAN = True if StrictVersion(current_version.replace(".dev","a")) >= StrictVersion("2021.2.9") else False
SUPPORT_PRESET_MODE = 8
# pylint: disable=unused-argument
@asyncio.coroutine
async def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
await async_generic_setup_platform(
hass,
config,
async_add_devices,
discovery_info,
DEFAULT_SPEED_LIST = [STATE_OFF, SPEED_LOW, SPEED_MEDIUM, SPEED_HIGH]
DEFAULT_SPEED = SPEED_MEDIUM
DEFAULT_DIRECTION = DIRECTION_ANTICLOCKWISE
CUSTOMIZE_SCHEMA = vol.Schema(
{vol.Optional(CONF_SPEEDS): vol.All(cv.ensure_list, [cv.string])})
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Optional(CONF_NAME, default=DEFAULT_NAME):
cv.string,
vol.Required(CONF_HOST):
cv.string,
vol.Required(CONF_MAC):
cv.string,
vol.Required(CONF_RFCODES_INI):
cv.string,
vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT):
cv.positive_int,
vol.Optional(CONF_CUSTOMIZE, default={}):
CUSTOMIZE_SCHEMA,
vol.Optional(CONF_DEFAULT_SPEED, default=DEFAULT_SPEED):
cv.string,
vol.Optional(CONF_DEFAULT_DIRECTION, default=DEFAULT_DIRECTION):
cv.string
})
# pylint: disable=unused-argument
def setup_platform(hass, config, add_devices_callback, discovery_info=None):
"""Set up the Broadlink-controlled fan platform."""
name = config.get(CONF_NAME)
ip_addr = config.get(CONF_HOST)
MODEL_AIRFRESH_VA2 = "zhimi.airfresh.va2"
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_HOST):
cv.string,
vol.Required(CONF_TOKEN):
vol.All(cv.string, vol.Length(min=32, max=32)),
vol.Optional(CONF_NAME, default=DEFAULT_NAME):
cv.string,
vol.Optional(CONF_MODEL):
vol.In([
MODEL_AIRPURIFIER_V1,
MODEL_AIRPURIFIER_V2,
MODEL_AIRPURIFIER_V3,
MODEL_AIRPURIFIER_V5,
MODEL_AIRPURIFIER_PRO,
MODEL_AIRPURIFIER_PRO_V7,
MODEL_AIRPURIFIER_M1,
MODEL_AIRPURIFIER_M2,
MODEL_AIRPURIFIER_MA1,
MODEL_AIRPURIFIER_MA2,
MODEL_AIRPURIFIER_SA1,
MODEL_AIRPURIFIER_SA2,
MODEL_AIRPURIFIER_2S,
MODEL_AIRHUMIDIFIER_V1,
MODEL_AIRHUMIDIFIER_CA,
MODEL_AIRFRESH_VA2,
]),
})
ATTR_MODEL = "model"
from homeassistant.components.fan import (PLATFORM_SCHEMA, FanEntity, DOMAIN,
SPEED_OFF, SUPPORT_SET_SPEED)
from datetime import datetime
from .const import (
DOMAIN,
CONF_ADDRESS,
)
from .snooz_device import SnoozeDevice
_LOGGER = logging.getLogger(__name__)
VALID_SPEEDS = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"]
SIGNAL_STATE_UPDATED = f"{DOMAIN}.updated"
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Optional(CONF_NAME): cv.string,
vol.Required(CONF_ADDRESS): cv.string
})
async def async_setup_platform(hass,
config,
async_add_entities,
discovery_info=None):
def on_state_change(id: str):
hass.helpers.dispatcher.async_dispatcher_send(SIGNAL_STATE_UPDATED)
device = SnoozeDevice(hass.loop, on_state_change)
address = config[CONF_ADDRESS]
name = config.get(CONF_NAME)
@callback
)
import homeassistant.helpers.config_validation as cv
from dukaonesdk.device import Device, Mode, Speed
from dukaonesdk.dukaclient import DukaClient
from . import DukaEntityComponent
from .const import (ATTR_MANUAL_SPEED, ATTR_MODE, DOMAIN, MODE_IN, MODE_INOUT,
MODE_OUT, SPEED_MANUAL)
_LOGGER = logging.getLogger(__name__)
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_DEVICE_ID):
cv.string,
vol.Optional(CONF_PASSWORD, default="1111"):
cv.string,
vol.Optional(CONF_IP_ADDRESS, default="<broadcast>"):
cv.string,
})
VALID_MODE = vol.Any(vol.All(vol.Coerce(int), vol.Clamp(min=0, max=2)),
cv.string)
SET_MODE_SCHEMA = vol.Schema({
vol.Required(ATTR_ENTITY_ID): cv.entity_ids,
vol.Required(ATTR_MODE): VALID_MODE
})
RESET_FILTER_TIMER_SCHEMA = vol.Schema(
{vol.Required(ATTR_ENTITY_ID): cv.entity_ids})
SET_MANUAL_SPEED_SCHEMA = vol.Schema({
vol.Required(ATTR_ENTITY_ID): cv.entity_ids,
vol.Required(ATTR_MANUAL_SPEED): int
CONFIG_PAYLOAD_VENTILATE = 'payload_ventilate'
CONFIG_PAYLOAD_COOL = 'payload_cool'
CONFIG_PAYLOAD_DRY = 'payload_dry'
DEFAULT_SPEED = 'Heat'
SPEED_LIST = ['Heat', 'Ventilate', 'Cool', 'Dry']
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_NAME):
cv.string,
vol.Optional(CONFIG_DEFAULT_SPEED, default=DEFAULT_SPEED):
cv.string,
vol.Required(CONFIG_TOPIC):
cv.string,
vol.Required(CONFIG_PAYLOAD_CLOSE):
cv.string,
vol.Required(CONFIG_PAYLOAD_HEAT):
cv.string,
vol.Required(CONFIG_PAYLOAD_VENTILATE):
cv.string,
vol.Required(CONFIG_PAYLOAD_COOL):
cv.string,
vol.Required(CONFIG_PAYLOAD_DRY):
cv.string,
})
def setup_platform(hass, config, add_devices_callback, discovery_info=None):
name = config.get(CONF_NAME)
mqtt_topic = config.get(CONFIG_TOPIC)
default_speed = config.get(CONFIG_DEFAULT_SPEED)
PRESET_MODE_TURBO,
)
_LOGGER = logging.getLogger(__name__)
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_HOST):
cv.string,
vol.Required(CONF_MODEL):
vol.In([
MODEL_AC1214,
MODEL_AC2729,
MODEL_AC2889,
MODEL_AC2939,
MODEL_AC2958,
MODEL_AC3033,
MODEL_AC3059,
MODEL_AC3829,
MODEL_AC3858,
MODEL_AC4236,
]),
vol.Optional(CONF_NAME, default=DEFAULT_NAME):
cv.string,
vol.Optional(CONF_ICON, default=DEFAULT_ICON):
cv.icon,
})
async def async_setup_platform(
hass: HomeAssistantType,
config: ConfigType,
SERVICE_SET_VOLUME,
)
from .device import XiaomiMiioEntity
_LOGGER = logging.getLogger(__name__)
DEFAULT_NAME = "Xiaomi Miio Device"
DATA_KEY = "fan.xiaomi_miio"
CONF_MODEL = "model"
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
{
vol.Required(CONF_HOST): cv.string,
vol.Required(CONF_TOKEN): vol.All(cv.string, vol.Length(min=32, max=32)),
vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
vol.Optional(CONF_MODEL): vol.In(MODELS_FAN),
}
)
ATTR_MODEL = "model"
# Air Purifier
ATTR_HUMIDITY = "humidity"
ATTR_AIR_QUALITY_INDEX = "aqi"
ATTR_FILTER_HOURS_USED = "filter_hours_used"
ATTR_FILTER_LIFE = "filter_life_remaining"
ATTR_FAVORITE_LEVEL = "favorite_level"
ATTR_BUZZER = "buzzer"
ATTR_CHILD_LOCK = "child_lock"
ATTR_LED = "led"
from homeassistant.components.fan import (FanEntity, PLATFORM_SCHEMA,
SUPPORT_SET_SPEED, DOMAIN)
from homeassistant.config import load_yaml_config_file
from homeassistant.const import (CONF_NAME, CONF_HOST, CONF_TOKEN,
ATTR_ENTITY_ID, )
from homeassistant.exceptions import PlatformNotReady
import homeassistant.helpers.config_validation as cv
_LOGGER = logging.getLogger(__name__)
DEFAULT_NAME = 'Xiaomi Air Purifier'
PLATFORM = 'xiaomi_miio'
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_HOST): cv.string,
vol.Required(CONF_TOKEN): vol.All(cv.string, vol.Length(min=32, max=32)),
vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
})
REQUIREMENTS = ['python-miio==0.3.1']
ATTR_TEMPERATURE = 'temperature'
ATTR_HUMIDITY = 'humidity'
ATTR_AIR_QUALITY_INDEX = 'aqi'
ATTR_MODE = 'mode'
ATTR_FILTER_HOURS_USED = 'filter_hours_used'
ATTR_FILTER_LIFE = 'filter_life_remaining'
ATTR_FAVORITE_LEVEL = 'favorite_level'
ATTR_BUZZER = 'buzzer'
ATTR_CHILD_LOCK = 'child_lock'
ATTR_LED = 'led'
TUNE_DIRECTION_UP, TUNE_DIRECTION_DOWN, TUNE_DIRECTION_REVERSE)
_LOGGER = logging.getLogger(__name__)
_LOGGER.setLevel(LOG_LEVEL)
SERVICE_FAN_START_SPEED_TUNE = 'fan_start_speed_tune'
SERVICE_FAN_STOP_SPEED_TUNE = 'fan_stop_speed_tune'
SERVICE_FAN_LOAD_PRESET = 'fan_load_preset'
SERVICE_FAN_SAVE_PRESET = 'fan_save_preset'
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Optional(CONF_BROADCAST, default=False): cv.boolean,
vol.Optional(CONF_SCAN_INTERVAL, default=SCAN_INTERVAL): cv.time_period,
vol.Optional(CONF_SPEED_ENABLED, default=False): cv.boolean,
vol.Optional(CONF_SPEED_COUNT, default=100): cv.positive_int,
vol.Required(CONF_NAME): cv.string,
vol.Required(CONF_CHANNEL): cv.positive_int,
vol.Required(CONF_MODE, default=MODE_NOOLITE_F): vol.In(MODES_NOOLITE),
})
async def async_setup_platform(hass, config, add_devices, discovery_info=None):
_LOGGER.info(config)
add_devices([NooLiteFan(config, hass.data[DOMAIN])], should_pull_on_start(config))
platform = entity_platform.async_get_current_platform()
platform.async_register_entity_service(SERVICE_FAN_START_SPEED_TUNE, TUNE_SCHEMA, _start_speed_tune)
platform.async_register_entity_service(SERVICE_FAN_STOP_SPEED_TUNE, {}, _stop_speed_tune)
platform.async_register_entity_service(SERVICE_FAN_LOAD_PRESET, {}, _load_preset)
platform.async_register_entity_service(SERVICE_FAN_SAVE_PRESET, {}, _save_preset)