DEPENDENCIES = ['rpi_gpio'] _COVERS_SCHEMA = vol.All(cv.ensure_list, [ vol.Schema({ CONF_NAME: cv.string, CONF_RELAY_PIN: cv.positive_int, CONF_STATE_PIN: cv.positive_int, }) ]) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_COVERS): _COVERS_SCHEMA, vol.Optional(CONF_STATE_PULL_MODE, default=DEFAULT_STATE_PULL_MODE): cv.string, vol.Optional(CONF_RELAY_TIME, default=DEFAULT_RELAY_TIME): cv.positive_int, vol.Optional(CONF_INVERT_STATE, default=DEFAULT_INVERT_STATE): cv.boolean, vol.Optional(CONF_INVERT_RELAY, default=DEFAULT_INVERT_RELAY): cv.boolean, }) # pylint: disable=unused-argument def setup_platform(hass, config, add_devices, discovery_info=None): """Set up the RPi cover platform.""" relay_time = config.get(CONF_RELAY_TIME) state_pull_mode = config.get(CONF_STATE_PULL_MODE) invert_state = config.get(CONF_INVERT_STATE) invert_relay = config.get(CONF_INVERT_RELAY) covers = []
"open": STATE_OPEN, "opening": STATE_OPENING, "closed": STATE_CLOSED, "closing": STATE_CLOSING, "stopped": STATE_STOPPED, } COVER_SCHEMA = vol.Schema({ vol.Optional(CONF_ACCESS_TOKEN): cv.string, vol.Optional(CONF_DEVICE): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_PASSWORD): cv.string, vol.Optional(CONF_USERNAME): cv.string, }) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( {vol.Required(CONF_COVERS): cv.schema_with_slug_keys(COVER_SCHEMA)}) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the Garadget covers.""" covers = [] devices = config.get(CONF_COVERS) for device_id, device_config in devices.items(): args = { "name": device_config.get(CONF_NAME), "device_id": device_config.get(CONF_DEVICE, device_id), "username": device_config.get(CONF_USERNAME), "password": device_config.get(CONF_PASSWORD), "access_token": device_config.get(CONF_ACCESS_TOKEN), }
SERVICE_SET_COVER_POSITION, SERVICE_SET_COVER_TILT_POSITION, SERVICE_STOP_COVER, SERVICE_STOP_COVER_TILT, SUPPORT_CLOSE, SUPPORT_CLOSE_TILT, SUPPORT_OPEN, SUPPORT_OPEN_TILT, SUPPORT_SET_POSITION, SUPPORT_SET_TILT_POSITION, SUPPORT_STOP, SUPPORT_STOP_TILT, CoverDevice) _LOGGER = logging.getLogger(__name__) KEY_OPEN_CLOSE = 'open_close' KEY_STOP = 'stop' KEY_POSITION = 'position' DEFAULT_NAME = 'Cover Group' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Required(CONF_ENTITIES): cv.entities_domain(DOMAIN), }) async def async_setup_platform(hass, config, async_add_entities, discovery_info=None): """Set up the Group Cover platform.""" async_add_entities([CoverGroup(config[CONF_NAME], config[CONF_ENTITIES])]) class CoverGroup(CoverDevice): """Representation of a CoverGroup.""" def __init__(self, name, entities):
_LOGGER = logging.getLogger(__name__) NOTIFICATION_ID = "aladdin_notification" NOTIFICATION_TITLE = "Aladdin Connect Cover Setup" STATES_MAP = { "open": STATE_OPEN, "opening": STATE_OPENING, "closed": STATE_CLOSED, "closing": STATE_CLOSING, } SUPPORTED_FEATURES = SUPPORT_OPEN | SUPPORT_CLOSE PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( {vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_PASSWORD): cv.string} ) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the Aladdin Connect platform.""" username = config[CONF_USERNAME] password = config[CONF_PASSWORD] acc = AladdinConnectClient(username, password) try: if not acc.login(): raise ValueError("Username or Password is incorrect") add_entities(AladdinDevice(acc, door) for door in acc.get_doors()) except (TypeError, KeyError, NameError, ValueError) as ex:
"closing": STATE_CLOSING, "stopped": STATE_STOPPED } # Validation of the user's configuration COVER_SCHEMA = vol.Schema({ vol.Optional(CONF_DEVICE): cv.string, vol.Optional(CONF_USERNAME): cv.string, vol.Optional(CONF_PASSWORD): cv.string, vol.Optional(CONF_ACCESS_TOKEN): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string }) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_COVERS): vol.Schema({cv.slug: COVER_SCHEMA}), }) _LOGGER = logging.getLogger(__name__) def setup_platform(hass, config, add_devices, discovery_info=None): """Setup the Demo covers.""" covers = [] devices = config.get(CONF_COVERS, {}) _LOGGER.debug(devices) for device_id, device_config in devices.items(): args = { "name": device_config.get(CONF_NAME),
CONF_SIGNAL_REPETITIONS, DEFAULT_SIGNAL_REPETITIONS, RECEIVED_EVT_SUBSCRIBERS, RfxtrxDevice, apply_received_command, get_devices_from_config, get_new_device, ) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_DEVICES, default={}): { cv.string: vol.Schema({ vol.Required(CONF_NAME): cv.string, vol.Optional(CONF_FIRE_EVENT, default=False): cv.boolean, }) }, vol.Optional(CONF_AUTOMATIC_ADD, default=False): cv.boolean, vol.Optional(CONF_SIGNAL_REPETITIONS, default=DEFAULT_SIGNAL_REPETITIONS): vol.Coerce(int), }) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the RFXtrx cover.""" covers = get_devices_from_config(config, RfxtrxCover) add_entities(covers) def cover_update(event): """Handle cover updates from the RFXtrx gateway."""
cv.string, vol.Optional(CONF_COMMAND_STOP, default=None): cv.string, vol.Optional(CONF_TRIGGER_TIME, default=DEFAULT_TIMEOUT): cv.positive_int, vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): cv.positive_int, vol.Optional(CONF_FRIENDLY_NAME, default=DEFAULT_NAME): cv.string }) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_IP_ADDRESS): cv.string, vol.Required(CONF_MAC): cv.string, vol.Required(CONF_COVERS): vol.Schema({cv.slug: COVER_SCHEMA}), vol.Optional(CONF_FRIENDLY_NAME, default=DEFAULT_NAME): cv.string }) def setup_platform(hass, config, add_devices, discovery_info=None): """Set up the broadlink covers.""" covers = [] devices = config.get(CONF_COVERS) ip_addr = config.get(CONF_IP_ADDRESS) mac_addr = config.get(CONF_MAC) for object_id, device_config in devices.items():
CONF_AUTOMATIC_ADD = 'automatic_add' CONF_FIRE_EVENT = 'fire_event' CONF_IGNORE_DEVICES = 'ignore_devices' CONF_RECONNECT_INTERVAL = 'reconnect_interval' CONF_SIGNAL_REPETITIONS = 'signal_repetitions' CONF_WAIT_FOR_ACK = 'wait_for_ack' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_DEVICE_DEFAULTS, default=DEVICE_DEFAULTS_SCHEMA({})): DEVICE_DEFAULTS_SCHEMA, vol.Optional(CONF_DEVICES, default={}): vol.Schema({ cv.string: { vol.Optional(CONF_NAME): cv.string, vol.Optional(CONF_ALIASES, default=[]): vol.All(cv.ensure_list, [cv.string]), vol.Optional(CONF_GROUP_ALIASES, default=[]): vol.All(cv.ensure_list, [cv.string]), vol.Optional(CONF_NOGROUP_ALIASES, default=[]): vol.All(cv.ensure_list, [cv.string]), vol.Optional(CONF_FIRE_EVENT, default=False): cv.boolean, vol.Optional(CONF_SIGNAL_REPETITIONS): vol.Coerce(int), vol.Optional(CONF_GROUP, default=True): cv.boolean, }, }), }) def devices_from_config(domain_config, hass=None): """Parse configuration and add Rflink cover devices.""" devices = [] for device_id, config in domain_config[CONF_DEVICES].items(): device_config = dict(domain_config[CONF_DEVICE_DEFAULTS], **config)
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 Tuya cover devices.""" from . import pytuya covers = []
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_DEVICE_DEFAULTS, default=DEVICE_DEFAULTS_SCHEMA({})): DEVICE_DEFAULTS_SCHEMA, vol.Optional(CONF_DEVICES, default={}): vol.Schema({ cv.string: { vol.Optional(CONF_NAME): cv.string, vol.Optional(CONF_ALIASES, default=[]): vol.All(cv.ensure_list, [cv.string]), vol.Optional(CONF_GROUP_ALIASES, default=[]): vol.All(cv.ensure_list, [cv.string]), vol.Optional(CONF_NOGROUP_ALIASES, default=[]): vol.All(cv.ensure_list, [cv.string]), vol.Optional(CONF_FIRE_EVENT, default=False): cv.boolean, vol.Optional(CONF_SIGNAL_REPETITIONS): vol.Coerce(int), vol.Optional(CONF_GROUP, default=True): cv.boolean, vol.Optional(CONF_MY_POSITION): vol.All(vol.Coerce(int), vol.Range(min=0, max=100)), vol.Optional(CONF_TRAVELLING_TIME_DOWN, default=DEFAULT_TRAVEL_TIME): cv.positive_int, vol.Optional(CONF_TRAVELLING_TIME_UP, default=DEFAULT_TRAVEL_TIME): cv.positive_int, } }), })
import ssl import websockets import json from .laresToolbox import * import homeassistant.helpers.config_validation as cv from homeassistant.components.cover import SUPPORT_CLOSE, PLATFORM_SCHEMA, SUPPORT_OPEN, SUPPORT_STOP, STATE_CLOSED, STATE_OPEN, CoverEntity from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME _LOGGER = logging.getLogger(__name__) # Validation of the user's configuration PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Optional(CONF_PASSWORD): cv.string, }) ssl_context = ssl.SSLContext() ssl_context.verify_mode = ssl.CERT_NONE ssl_context.options = (ssl.OP_ALL | ssl.OP_NO_SSLv2 | ssl.OP_NO_SSLv3 | ssl.OP_NO_RENEGOTIATION) laresHost = "" laresPassword = "" async def async_setup_platform(hass, config, async_add_entities,
_VALID_STATES = [STATE_OPEN, STATE_CLOSED, "true", "false"] CLOSED_POSITION = 0 OPEN_POSITION = 100 COVER_SCHEMA = vol.Schema( { vol.Optional(CONF_FRIENDLY_NAME): cv.string, vol.Required(CONF_CHANNEL): cv.string, vol.Optional(CONF_VALUE_TEMPLATE): cv.template, } ) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Required(CONF_COVERS): cv.schema_with_slug_keys(COVER_SCHEMA), vol.Optional(CONF_DEVICE): cv.string, } ) async def async_setup_platform(hass, config, async_add_entities, discovery_info=None): """Set up the becker platform.""" covers = [] stick_path = config.get(CONF_DEVICE) PyBecker.setup(stick_path) # To be sure the connexion is well established send 3 commands for x in range(0, 2): PyBecker.becker.stop("1")
HS_COVER_TCP_PORT = 23 HS_COVER_DIRECTION = 'default' SOCKET_BUFSIZE = 1024 SOCKET_TIMEOUT = 30.0 DISCOVER_TIMEOUT = 20 ATTRIBUTION = 'A HASSMART Product' CONF_PORT = 'port' CONF_DIRECTION = 'direction' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Optional(CONF_PORT, default=HS_COVER_TCP_PORT): cv.port, vol.Optional(CONF_DIRECTION, default=HS_COVER_DIRECTION): vol.In(['default', 'reverse']), }) class HASSmartHub(object): '''hassmart hub init''' def __init__(self, tcp_ip, tcp_port, direction): self._tcp_ip = tcp_ip self._tcp_port = tcp_port self._conf_motor_direction = direction self._socket = None self._timeout_number = 0 self._check_state = False self._threads = []
"""Support for SCSGate covers.""" import logging import voluptuous as vol from homeassistant.components import scsgate from homeassistant.components.cover import (CoverDevice, PLATFORM_SCHEMA) from homeassistant.const import (CONF_DEVICES, CONF_NAME) import homeassistant.helpers.config_validation as cv _LOGGER = logging.getLogger(__name__) DEPENDENCIES = ['scsgate'] PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_DEVICES): cv.schema_with_slug_keys(scsgate.SCSGATE_SCHEMA), }) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the SCSGate cover.""" devices = config.get(CONF_DEVICES) covers = [] logger = logging.getLogger(__name__) if devices: for _, entity_info in devices.items(): if entity_info[scsgate.CONF_SCS_ID] in scsgate.SCSGATE.devices: continue name = entity_info[CONF_NAME]
CoverEntity, PLATFORM_SCHEMA, ATTR_POSITION, SUPPORT_SET_POSITION, SUPPORT_OPEN, SUPPORT_CLOSE) from homeassistant.components.group.cover import CoverGroup import homeassistant.helpers.config_validation as cv from homeassistant.helpers.entity import generate_entity_id from homeassistant.helpers.event import track_point_in_utc_time, track_time_interval from homeassistant.util import Throttle, utcnow from functools import wraps _LOGGER = logging.getLogger(__name__) CONF_INCLUDE_ROOMS = 'include_rooms' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Optional(CONF_INCLUDE_ROOMS, default=False): cv.boolean, }) POSITION_BATCHING_DELAY_SEC = 0.25 POLLING_INTERVAL_MINUTES = 5 ATTR_RSSI_LEVEL = 'rssi_level' def timed(func): @contextmanager def timing(): start_ts = datetime.now() yield elapsed = datetime.now() - start_ts _LOGGER.debug('{}() took {:.2f} seconds'.format(func.__name__, elapsed.total_seconds()))
CONF_TRAVELLING_TIME_UP = 'travelling_time_up' CONF_INVERT_POSITION = 'invert_position' CONF_INVERT_ANGLE = 'invert_angle' DEFAULT_TRAVEL_TIME = 25 DEFAULT_NAME = 'KNX Cover' DEPENDENCIES = ['knx'] PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_MOVE_LONG_ADDRESS): cv.string, vol.Optional(CONF_MOVE_SHORT_ADDRESS): cv.string, vol.Optional(CONF_POSITION_ADDRESS): cv.string, vol.Optional(CONF_POSITION_STATE_ADDRESS): cv.string, vol.Optional(CONF_ANGLE_ADDRESS): cv.string, vol.Optional(CONF_ANGLE_STATE_ADDRESS): cv.string, vol.Optional(CONF_TRAVELLING_TIME_DOWN, default=DEFAULT_TRAVEL_TIME): cv.positive_int, vol.Optional(CONF_TRAVELLING_TIME_UP, default=DEFAULT_TRAVEL_TIME): cv.positive_int, vol.Optional(CONF_INVERT_POSITION, default=False): cv.boolean, vol.Optional(CONF_INVERT_ANGLE, default=False): cv.boolean, }) async def async_setup_platform(hass, config, async_add_entities, discovery_info=None): """Set up cover(s) for KNX platform.""" if discovery_info is not None: async_add_entities_discovery(hass, discovery_info, async_add_entities) else:
import voluptuous import homeassistant.helpers.config_validation # Import the device class from the component that you want to support from homeassistant.components.cover import PLATFORM_SCHEMA, CoverEntity, DEVICE_CLASS_WINDOW, ATTR_POSITION from homeassistant.components.cover import SUPPORT_OPEN, SUPPORT_CLOSE, SUPPORT_SET_POSITION from homeassistant.const import CONF_HOSTS from homeassistant.core import HomeAssistant from homeassistant.config_entries import ConfigEntry from .smarwi_control import SmarwiControl, SmarwiControlItem _LOGGER = logging.getLogger(__name__) # Validation of the user's configuration PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ voluptuous.Required(CONF_HOSTS): homeassistant.helpers.config_validation.string, }) # noinspection PyUnusedLocal def setup_platform(hass, config, add_entities, discovery_info=None): host = config[CONF_HOSTS] ctl = SmarwiControl(host) _LOGGER.error(f"=== {ctl.list()}") add_entities([VektivaSmarwi(host) for host in ctl.list()]) async def async_setup_entry(hass:HomeAssistant, config_entry:ConfigEntry, async_add_entities): ctl = SmarwiControl(config_entry.data["hosts"]) async_add_entities([VektivaSmarwi(ctli) for ctli in ctl.list()], True) return True
_COVERS_SCHEMA = vol.All( cv.ensure_list, [ vol.Schema({ CONF_NAME: cv.string, CONF_RELAY_PIN: cv.positive_int, CONF_STATE_PIN: cv.positive_int, }) ] ) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_COVERS): _COVERS_SCHEMA, vol.Optional(CONF_STATE_PULL_MODE, default=DEFAULT_STATE_PULL_MODE): cv.string, vol.Optional(CONF_RELAY_TIME, default=DEFAULT_RELAY_TIME): cv.positive_int, vol.Optional(CONF_INVERT_STATE, default=DEFAULT_INVERT_STATE): cv.boolean, vol.Optional(CONF_INVERT_RELAY, default=DEFAULT_INVERT_RELAY): cv.boolean, }) # pylint: disable=unused-argument def setup_platform(hass, config, add_devices, discovery_info=None): """Set up the RPi cover platform.""" relay_time = config.get(CONF_RELAY_TIME) state_pull_mode = config.get(CONF_STATE_PULL_MODE) invert_state = config.get(CONF_INVERT_STATE) invert_relay = config.get(CONF_INVERT_RELAY) covers = [] covers_conf = config.get(CONF_COVERS)
) from homeassistant.helpers import config_validation as cv _LOGGER = logging.getLogger(__name__) supported_features = SUPPORT_OPEN | SUPPORT_CLOSE | SUPPORT_STOP # api call is http://{ip address}:8838/neo/v1/transmit?command={blind id}-{command}&id={controller id (24 chars)}' # commands are up (UP), dn (DOWN) and sp (STOP) ############ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Required(CONF_ID): cv.string, vol.Optional(CONF_DEVICES, default={}): { cv.string: vol.Schema({ vol.Required(CONF_NAME): cv.string, }) }, }) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the NEOSMARTBLINDS global variables.""" controller_host = config.get(CONF_HOST) controller_id = config.get(CONF_ID) """Set up the NEOSMARTBLINDS covers.""" covers = [] devices = config.get(CONF_DEVICES) if devices: for _, entity_info in devices.items():
CONF_INVERT_ANGLE = 'invert_angle' DEFAULT_NAME = 'KNX Cover' DEPENDENCIES = ['knx'] PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_UPDOWN): cv.string, vol.Required(CONF_STOP): cv.string, vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA, vol.Optional(CONF_GETPOSITION_ADDRESS): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_SETPOSITION_ADDRESS): cv.string, vol.Optional(CONF_INVERT_POSITION, default=False): cv.boolean, vol.Inclusive(CONF_GETANGLE_ADDRESS, 'angle'): cv.string, vol.Inclusive(CONF_SETANGLE_ADDRESS, 'angle'): cv.string, vol.Optional(CONF_INVERT_ANGLE, default=False): cv.boolean, }) def setup_platform(hass, config, add_devices, discovery_info=None): """Create and add an entity based on the configuration.""" add_devices([KNXCover(hass, KNXConfig(config))])
from homeassistant.helpers import aiohttp_client, config_validation as cv _LOGGER = logging.getLogger(__name__) MYQ_TO_HASS = { "closed": STATE_CLOSED, "closing": STATE_CLOSING, "open": STATE_OPEN, "opening": STATE_OPENING, } PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_PASSWORD): cv.string, # This parameter is no longer used; keeping it to avoid a breaking change in # a hotfix, but in a future main release, this should be removed: vol.Optional(CONF_TYPE): cv.string, } ) async def async_setup_platform(hass, config, async_add_entities, discovery_info=None): """Set up the platform.""" websession = aiohttp_client.async_get_clientsession(hass) username = config[CONF_USERNAME] password = config[CONF_PASSWORD] try: myq = await login(username, password, websession)
from homeassistant.const import ( CONF_NAME, CONF_HOST, STATE_CLOSED, STATE_OPEN, STATE_OPENING, STATE_UNKNOWN, ATTR_BATTERY_LEVEL) import homeassistant.helpers.config_validation as cv from base64 import b64decode _LOGGER = logging.getLogger(__name__) DEFAULT_NAME = 'PowerView' CONF_VERSION = 'version' VERSIONS = {1,2} PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_VERSION, default=2): vol.In(VERSIONS), }) ############ async def async_setup_platform(hass, config, async_add_entities, discovery_info=None): """Set up the PowerView covers.""" ip_address = config[CONF_HOST] hub_vers = config[CONF_VERSION] pv = PowerView(ip_address) cover_ids = pv.get_shades() covers = [] for cover_id in cover_ids:
SUPPORT_OPEN, SUPPORT_CLOSE) from homeassistant.const import (CONF_USERNAME, CONF_PASSWORD, STATE_UNKNOWN, STATE_CLOSED) """REQUIREMENTS = ['py-ryobi-gdo==0.0.27']""" DOMAIN = "ryobi_gdo3" _LOGGER = logging.getLogger(__name__) SCAN_INTERVAL = timedelta(seconds=60) CONF_DEVICE_ID = 'device_id' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_DEVICE_ID): vol.All(cv.ensure_list, [cv.string]), vol.Required(CONF_PASSWORD): cv.string, vol.Required(CONF_USERNAME): cv.string, }) SUPPORTED_FEATURES = (SUPPORT_OPEN | SUPPORT_CLOSE) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the Ryobi covers.""" from .py_ryobi_gdo import RyobiGDO as ryobi_door covers = [] username = config.get(CONF_USERNAME) password = config.get(CONF_PASSWORD) devices = config.get(CONF_DEVICE_ID)
1: STATE_OPEN, } COVER_SCHEMA = vol.Schema({ vol.Required(CONF_DEVICE_KEY): cv.string, vol.Required(CONF_HOST): cv.string, vol.Optional(CONF_NAME): cv.string, vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port, }) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_COVERS): vol.Schema({cv.slug: COVER_SCHEMA}), }) def setup_platform(hass, config, add_devices, discovery_info=None): """Set up the OpenGarage covers.""" covers = [] devices = config.get(CONF_COVERS) for device_id, device_config in devices.items(): args = { CONF_NAME: device_config.get(CONF_NAME), CONF_HOST: device_config.get(CONF_HOST), CONF_PORT: device_config.get(CONF_PORT), CONF_DEVICE_ID: device_config.get(CONF_DEVICE, device_id), CONF_DEVICE_KEY: device_config.get(CONF_DEVICE_KEY)
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST, description="hostname / IP of hub"): cv.string, vol.Required(CONF_NAME, description="name of blind to appear in HA"): cv.string, vol.Required(CONF_DEVICE, description="ID Code of blind in app"): cv.string, vol.Required(CONF_CLOSE_TIME, description="Time (seconds) it takes for blind to move from fully open to closed", default=20): cv.positive_int, vol.Required(CONF_ID, description="ID of hub"): cv.string, vol.Required(CONF_PROTOCOL, description="Either http or tcp", default="http"): cv.string, vol.Required(CONF_PORT, description="port of hub (usually: http=8838, tcp=8839)", default=8838): cv.port, vol.Required(CONF_RAIL, description="rail to move", default=1): cv.positive_int, vol.Required(CONF_PERCENT_SUPPORT, description="0=favourite positioning only, 1=send percent positioning commands to hub, 2=use up / down commands to estimate position", default=0): cv.positive_int, vol.Required(CONF_MOTOR_CODE, description="ID Code of motor in app", default=''): cv.string, vol.Optional(CONF_START_POSITION, description="If percent positioning mode is enabled, this value will be used as the starting position else it will be restored from the last run"): cv.positive_int, })
_LOGGER = logging.getLogger(__name__) DEFAULT_NAME = "ADS Cover" CONF_ADS_VAR_SET_POS = "adsvar_set_position" CONF_ADS_VAR_OPEN = "adsvar_open" CONF_ADS_VAR_CLOSE = "adsvar_close" CONF_ADS_VAR_STOP = "adsvar_stop" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Optional(CONF_ADS_VAR): cv.string, vol.Optional(CONF_ADS_VAR_POSITION): cv.string, vol.Optional(CONF_ADS_VAR_SET_POS): cv.string, vol.Optional(CONF_ADS_VAR_CLOSE): cv.string, vol.Optional(CONF_ADS_VAR_OPEN): cv.string, vol.Optional(CONF_ADS_VAR_STOP): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA, } ) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the cover platform for ADS.""" ads_hub = hass.data[DATA_ADS] ads_var_is_closed = config.get(CONF_ADS_VAR) ads_var_position = config.get(CONF_ADS_VAR_POSITION) ads_var_pos_set = config.get(CONF_ADS_VAR_SET_POS) ads_var_open = config.get(CONF_ADS_VAR_OPEN)
DATA_KEY = "switch.xiaomi_miot_raw" ATTR_MODEL = "model" ATTR_FIRMWARE_VERSION = "firmware_version" ATTR_HARDWARE_VERSION = "hardware_version" CONF_MAPPING = 'mapping' CONF_CONTROL_PARAMS = 'params' CONF_CLOUD = 'update_from_cloud' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Required(CONF_HOST): cv.string, vol.Required(CONF_TOKEN): vol.All(cv.string, vol.Length(min=32, max=32)), vol.Required(CONF_MAPPING): vol.All(), vol.Required(CONF_CONTROL_PARAMS): vol.All(), vol.Optional(CONF_CLOUD): vol.All(), }) SCAN_INTERVAL = timedelta(seconds=1) # pylint: disable=unused-argument @asyncio.coroutine def async_setup_platform(hass, config, async_add_devices, discovery_info=None): """Set up the sensor from config."""
CONF_RECONNECT_INTERVAL = 'reconnect_interval' CONF_SIGNAL_REPETITIONS = 'signal_repetitions' CONF_WAIT_FOR_ACK = 'wait_for_ack' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_DEVICE_DEFAULTS, default=DEVICE_DEFAULTS_SCHEMA({})): DEVICE_DEFAULTS_SCHEMA, vol.Optional(CONF_DEVICES, default={}): vol.Schema({ cv.string: { vol.Optional(CONF_NAME): cv.string, vol.Optional(CONF_ALIASES, default=[]): vol.All(cv.ensure_list, [cv.string]), vol.Optional(CONF_GROUP_ALIASES, default=[]): vol.All(cv.ensure_list, [cv.string]), vol.Optional(CONF_NOGROUP_ALIASES, default=[]): vol.All(cv.ensure_list, [cv.string]), vol.Optional(CONF_FIRE_EVENT, default=False): cv.boolean, vol.Optional(CONF_SIGNAL_REPETITIONS): vol.Coerce(int), vol.Optional(CONF_GROUP, default=True): cv.boolean, }, }), }) def devices_from_config(domain_config, hass=None): """Parse configuration and add Rflink cover devices."""
""" import logging import voluptuous as vol from homeassistant.components import scsgate from homeassistant.components.cover import (CoverDevice, PLATFORM_SCHEMA) from homeassistant.const import (CONF_DEVICES, CONF_NAME) import homeassistant.helpers.config_validation as cv _LOGGER = logging.getLogger(__name__) DEPENDENCIES = ['scsgate'] PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_DEVICES): vol.Schema({cv.slug: scsgate.SCSGATE_SCHEMA}), }) def setup_platform(hass, config, add_devices, discovery_info=None): """Set up the SCSGate cover.""" devices = config.get(CONF_DEVICES) covers = [] logger = logging.getLogger(__name__) if devices: for _, entity_info in devices.items(): if entity_info[scsgate.CONF_SCS_ID] in scsgate.SCSGATE.devices: continue name = entity_info[CONF_NAME]
""" import logging import voluptuous as vol import homeassistant.components.scsgate as scsgate from homeassistant.components.cover import (CoverDevice, PLATFORM_SCHEMA) from homeassistant.const import (CONF_DEVICES, CONF_NAME) import homeassistant.helpers.config_validation as cv _LOGGER = logging.getLogger(__name__) DEPENDENCIES = ['scsgate'] PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_DEVICES): vol.Schema({cv.slug: scsgate.SCSGATE_SCHEMA}), }) def setup_platform(hass, config, add_devices, discovery_info=None): """Setup the SCSGate cover.""" devices = config.get(CONF_DEVICES) covers = [] logger = logging.getLogger(__name__) if devices: for _, entity_info in devices.items(): if entity_info[scsgate.CONF_SCS_ID] in scsgate.SCSGATE.devices: continue name = entity_info[CONF_NAME]
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 = "cover.xiaomi_cover" 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, ) SUCCESS = ["ok"] SERVICE_SCHEMA = vol.Schema({vol.Optional(ATTR_ENTITY_ID): cv.entity_ids}) SERVICE_TO_METHOD = { SERVICE_SET_COVER_POSITION: { "method": "async_set_cover_position" }, SERVICE_OPEN_COVER: { "method": "async_open_cover" },
SERVICE_SET_COVER_POSITION, SERVICE_SET_COVER_TILT_POSITION, SERVICE_STOP_COVER, SERVICE_STOP_COVER_TILT, SUPPORT_CLOSE, SUPPORT_CLOSE_TILT, SUPPORT_OPEN, SUPPORT_OPEN_TILT, SUPPORT_SET_POSITION, SUPPORT_SET_TILT_POSITION, SUPPORT_STOP, SUPPORT_STOP_TILT, CoverDevice) _LOGGER = logging.getLogger(__name__) KEY_OPEN_CLOSE = 'open_close' KEY_STOP = 'stop' KEY_POSITION = 'position' DEFAULT_NAME = 'Cover Group' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Required(CONF_ENTITIES): cv.entities_domain(DOMAIN), }) async def async_setup_platform(hass, config, async_add_entities, discovery_info=None): """Set up the Group Cover platform.""" async_add_entities( [CoverGroup(config[CONF_NAME], config[CONF_ENTITIES])]) class CoverGroup(CoverDevice): """Representation of a CoverGroup.""" def __init__(self, name, entities): """Initialize a CoverGroup entity."""
SERVICE_SET_KNOWN_POSITION = 'set_known_position' SERVICE_SET_KNOWN_ACTION = 'set_known_action' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_DEVICES, default={}): vol.Schema({ cv.string: { vol.Required(CONF_NAME): cv.string, vol.Required(CONF_OPEN_SCRIPT_ENTITY_ID): cv.entity_id, vol.Required(CONF_CLOSE_SCRIPT_ENTITY_ID): cv.entity_id, vol.Required(CONF_STOP_SCRIPT_ENTITY_ID): cv.entity_id, vol.Optional(CONF_ALIASES, default=[]): vol.All(cv.ensure_list, [cv.string]), vol.Optional(CONF_TRAVELLING_TIME_DOWN, default=DEFAULT_TRAVEL_TIME): cv.positive_int, vol.Optional(CONF_TRAVELLING_TIME_UP, default=DEFAULT_TRAVEL_TIME): cv.positive_int, vol.Optional(CONF_SEND_STOP_AT_ENDS, default=DEFAULT_SEND_STOP_AT_ENDS): cv.boolean, } }), }) POSITION_SCHEMA = vol.Schema({ vol.Required(ATTR_ENTITY_ID):
from homeassistant.components import rfxtrx from homeassistant.components.cover import CoverDevice, PLATFORM_SCHEMA from homeassistant.const import CONF_NAME from homeassistant.components.rfxtrx import ( CONF_AUTOMATIC_ADD, CONF_FIRE_EVENT, DEFAULT_SIGNAL_REPETITIONS, CONF_SIGNAL_REPETITIONS, CONF_DEVICES) from homeassistant.helpers import config_validation as cv DEPENDENCIES = ['rfxtrx'] PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_DEVICES, default={}): { cv.string: vol.Schema({ vol.Required(CONF_NAME): cv.string, vol.Optional(CONF_FIRE_EVENT, default=False): cv.boolean }) }, vol.Optional(CONF_AUTOMATIC_ADD, default=False): cv.boolean, vol.Optional(CONF_SIGNAL_REPETITIONS, default=DEFAULT_SIGNAL_REPETITIONS): vol.Coerce(int), }) def setup_platform(hass, config, add_devices, discovery_info=None): """Set up the RFXtrx cover.""" import RFXtrx as rfxtrxmod covers = rfxtrx.get_devices_from_config(config, RfxtrxCover) add_devices(covers) def cover_update(event):
DEFAULT_TRAVEL_TIME = 25 DEFAULT_NAME = 'XKNX Cover' DEPENDENCIES = ['xknx'] PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_MOVE_LONG_ADDRESS): cv.string, vol.Optional(CONF_MOVE_SHORT_ADDRESS): cv.string, vol.Optional(CONF_POSITION_ADDRESS): cv.string, vol.Optional(CONF_POSITION_STATE_ADDRESS): cv.string, vol.Optional(CONF_ANGLE_ADDRESS): cv.string, vol.Optional(CONF_ANGLE_STATE_ADDRESS): cv.string, vol.Optional(CONF_TRAVELLING_TIME_DOWN, default=DEFAULT_TRAVEL_TIME): cv.positive_int, vol.Optional(CONF_TRAVELLING_TIME_UP, default=DEFAULT_TRAVEL_TIME): cv.positive_int, vol.Optional(CONF_INVERT_POSITION, default=False): cv.boolean, vol.Optional(CONF_INVERT_ANGLE, default=False): cv.boolean, }) @asyncio.coroutine def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
import homeassistant.helpers.config_validation as cv from homeassistant.components.cover import ( CoverDevice, PLATFORM_SCHEMA, SUPPORT_OPEN, SUPPORT_CLOSE) from homeassistant.const import ( CONF_USERNAME, CONF_PASSWORD, STATE_UNKNOWN, STATE_CLOSED) REQUIREMENTS = ['py_ryobi_gdo==0.0.10'] _LOGGER = logging.getLogger(__name__) CONF_DEVICE_ID = 'device_id' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_DEVICE_ID): vol.All(cv.ensure_list, [cv.string]), vol.Required(CONF_PASSWORD): cv.string, vol.Required(CONF_USERNAME): cv.string, }) SUPPORTED_FEATURES = (SUPPORT_OPEN | SUPPORT_CLOSE) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the Ryobi covers.""" from py_ryobi_gdo import RyobiGDO as ryobi_door covers = [] username = config.get(CONF_USERNAME) password = config.get(CONF_PASSWORD) devices = config.get(CONF_DEVICE_ID)
"""Support for SCSGate covers.""" import logging import voluptuous as vol from homeassistant.components import scsgate from homeassistant.components.cover import CoverDevice, PLATFORM_SCHEMA from homeassistant.const import CONF_DEVICES, CONF_NAME import homeassistant.helpers.config_validation as cv _LOGGER = logging.getLogger(__name__) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_DEVICES): cv.schema_with_slug_keys(scsgate.SCSGATE_SCHEMA) }) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the SCSGate cover.""" devices = config.get(CONF_DEVICES) covers = [] logger = logging.getLogger(__name__) if devices: for _, entity_info in devices.items(): if entity_info[scsgate.CONF_SCS_ID] in scsgate.SCSGATE.devices: continue name = entity_info[CONF_NAME] scs_id = entity_info[scsgate.CONF_SCS_ID]
STATE_STOPPED = 'stopped' STATES_MAP = { 0: STATE_CLOSED, 1: STATE_OPEN, } COVER_SCHEMA = vol.Schema({ vol.Required(CONF_DEVICE_KEY): cv.string, vol.Required(CONF_HOST): cv.string, vol.Optional(CONF_NAME): cv.string, vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port, }) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_COVERS): cv.schema_with_slug_keys(COVER_SCHEMA), }) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the OpenGarage covers.""" covers = [] devices = config.get(CONF_COVERS) for device_id, device_config in devices.items(): args = { CONF_NAME: device_config.get(CONF_NAME), CONF_HOST: device_config.get(CONF_HOST), CONF_PORT: device_config.get(CONF_PORT), CONF_DEVICE_ID: device_config.get(CONF_DEVICE, device_id), CONF_DEVICE_KEY: device_config.get(CONF_DEVICE_KEY)
ATTR_MODEL, ATTR_FIRMWARE_VERSION, ATTR_HARDWARE_VERSION, SCHEMA, MAP, DUMMY_IP, DUMMY_TOKEN, ) TYPE = 'cover' _LOGGER = logging.getLogger(__name__) DEFAULT_NAME = "Generic MIoT " + TYPE DATA_KEY = TYPE + '.' + DOMAIN PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( SCHEMA ) SCAN_INTERVAL = timedelta(seconds=2) # pylint: disable=unused-argument @asyncio.coroutine async def async_setup_platform(hass, config, async_add_devices, discovery_info=None): """Set up the sensor from config.""" if DATA_KEY not in hass.data: hass.data[DATA_KEY] = {} host = config.get(CONF_HOST) token = config.get(CONF_TOKEN) mapping = config.get(CONF_MAPPING)
STATE_OPEN, STATE_OPENING) from homeassistant.helpers import aiohttp_client, config_validation as cv REQUIREMENTS = ['pymyq==1.1.0'] _LOGGER = logging.getLogger(__name__) MYQ_TO_HASS = { 'closed': STATE_CLOSED, 'closing': STATE_CLOSING, 'open': STATE_OPEN, 'opening': STATE_OPENING } PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_TYPE): cv.string, vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_PASSWORD): cv.string }) async def async_setup_platform( hass, config, async_add_entities, discovery_info=None): """Set up the platform.""" from pymyq import login from pymyq.errors import MyQError, UnsupportedBrandError websession = aiohttp_client.async_get_clientsession(hass) username = config[CONF_USERNAME] password = config[CONF_PASSWORD] brand = config[CONF_TYPE]
vol.Optional(CONF_COMMAND_CLOSE, default=None): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_TRAVEL_TIME, default=None): cv.positive_int, # vol.Optional(CONF_POS_SENSOR, default=None): cv.entity_id, vol.Optional(CONF_POS_SENSOR, ): cv.entity_id, }) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_COVERS, default={}): vol.Schema({cv.slug: COVERS_SCHEMA}), vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): cv.positive_int, vol.Required(CONF_HOST): cv.string, vol.Required(CONF_MAC): cv.string, }) @asyncio.coroutine def async_setup_platform(hass, config, async_add_devices, discovery_info=None): import broadlink devices = config.get(CONF_COVERS) ip_addr = config.get(CONF_HOST) mac_addr = binascii.unhexlify( config.get(CONF_MAC).encode().replace(b':', b''))