166 lines
6.0 KiB
Python
166 lines
6.0 KiB
Python
"""Support for ADS covers."""
|
|
import logging
|
|
|
|
import voluptuous as vol
|
|
|
|
from homeassistant.components.cover import (
|
|
PLATFORM_SCHEMA, SUPPORT_OPEN, SUPPORT_CLOSE, SUPPORT_STOP,
|
|
SUPPORT_SET_POSITION, ATTR_POSITION, DEVICE_CLASSES_SCHEMA,
|
|
CoverDevice)
|
|
from homeassistant.const import (
|
|
CONF_NAME, CONF_DEVICE_CLASS)
|
|
import homeassistant.helpers.config_validation as cv
|
|
|
|
from . import CONF_ADS_VAR, CONF_ADS_VAR_POSITION, DATA_ADS, \
|
|
AdsEntity, STATE_KEY_STATE, STATE_KEY_POSITION
|
|
|
|
_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)
|
|
ads_var_close = config.get(CONF_ADS_VAR_CLOSE)
|
|
ads_var_stop = config.get(CONF_ADS_VAR_STOP)
|
|
name = config[CONF_NAME]
|
|
device_class = config.get(CONF_DEVICE_CLASS)
|
|
|
|
add_entities([AdsCover(ads_hub,
|
|
ads_var_is_closed,
|
|
ads_var_position,
|
|
ads_var_pos_set,
|
|
ads_var_open,
|
|
ads_var_close,
|
|
ads_var_stop,
|
|
name,
|
|
device_class)])
|
|
|
|
|
|
class AdsCover(AdsEntity, CoverDevice):
|
|
"""Representation of ADS cover."""
|
|
|
|
def __init__(self, ads_hub,
|
|
ads_var_is_closed, ads_var_position,
|
|
ads_var_pos_set, ads_var_open,
|
|
ads_var_close, ads_var_stop, name, device_class):
|
|
"""Initialize AdsCover entity."""
|
|
super().__init__(ads_hub, name, ads_var_is_closed)
|
|
if self._ads_var is None:
|
|
if ads_var_position is not None:
|
|
self._unique_id = ads_var_position
|
|
elif ads_var_pos_set is not None:
|
|
self._unique_id = ads_var_pos_set
|
|
elif ads_var_open is not None:
|
|
self._unique_id = ads_var_open
|
|
|
|
self._state_dict[STATE_KEY_POSITION] = None
|
|
self._ads_var_position = ads_var_position
|
|
self._ads_var_pos_set = ads_var_pos_set
|
|
self._ads_var_open = ads_var_open
|
|
self._ads_var_close = ads_var_close
|
|
self._ads_var_stop = ads_var_stop
|
|
self._device_class = device_class
|
|
|
|
async def async_added_to_hass(self):
|
|
"""Register device notification."""
|
|
if self._ads_var is not None:
|
|
await self.async_initialize_device(self._ads_var,
|
|
self._ads_hub.PLCTYPE_BOOL)
|
|
|
|
if self._ads_var_position is not None:
|
|
await self.async_initialize_device(self._ads_var_position,
|
|
self._ads_hub.PLCTYPE_BYTE,
|
|
STATE_KEY_POSITION)
|
|
|
|
@property
|
|
def device_class(self):
|
|
"""Return the class of this cover."""
|
|
return self._device_class
|
|
|
|
@property
|
|
def is_closed(self):
|
|
"""Return if the cover is closed."""
|
|
if self._ads_var is not None:
|
|
return self._state_dict[STATE_KEY_STATE]
|
|
if self._ads_var_position is not None:
|
|
return self._state_dict[STATE_KEY_POSITION] == 0
|
|
return None
|
|
|
|
@property
|
|
def current_cover_position(self):
|
|
"""Return current position of cover."""
|
|
return self._state_dict[STATE_KEY_POSITION]
|
|
|
|
@property
|
|
def supported_features(self):
|
|
"""Flag supported features."""
|
|
supported_features = SUPPORT_OPEN | SUPPORT_CLOSE
|
|
|
|
if self._ads_var_stop is not None:
|
|
supported_features |= SUPPORT_STOP
|
|
|
|
if self._ads_var_pos_set is not None:
|
|
supported_features |= SUPPORT_SET_POSITION
|
|
|
|
return supported_features
|
|
|
|
def stop_cover(self, **kwargs):
|
|
"""Fire the stop action."""
|
|
if self._ads_var_stop:
|
|
self._ads_hub.write_by_name(self._ads_var_stop, True,
|
|
self._ads_hub.PLCTYPE_BOOL)
|
|
|
|
def set_cover_position(self, **kwargs):
|
|
"""Set cover position."""
|
|
position = kwargs[ATTR_POSITION]
|
|
if self._ads_var_pos_set is not None:
|
|
self._ads_hub.write_by_name(self._ads_var_pos_set, position,
|
|
self._ads_hub.PLCTYPE_BYTE)
|
|
|
|
def open_cover(self, **kwargs):
|
|
"""Move the cover up."""
|
|
if self._ads_var_open is not None:
|
|
self._ads_hub.write_by_name(self._ads_var_open, True,
|
|
self._ads_hub.PLCTYPE_BOOL)
|
|
elif self._ads_var_pos_set is not None:
|
|
self.set_cover_position(position=100)
|
|
|
|
def close_cover(self, **kwargs):
|
|
"""Move the cover down."""
|
|
if self._ads_var_close is not None:
|
|
self._ads_hub.write_by_name(self._ads_var_close, True,
|
|
self._ads_hub.PLCTYPE_BOOL)
|
|
elif self._ads_var_pos_set is not None:
|
|
self.set_cover_position(position=0)
|
|
|
|
@property
|
|
def available(self):
|
|
"""Return False if state has not been updated yet."""
|
|
if self._ads_var is not None or self._ads_var_position is not None:
|
|
return self._state_dict[STATE_KEY_STATE] is not None or \
|
|
self._state_dict[STATE_KEY_POSITION] is not None
|
|
return True
|