220 lines
7.7 KiB
Python
220 lines
7.7 KiB
Python
"""Support for LCN devices."""
|
|
import logging
|
|
|
|
import voluptuous as vol
|
|
|
|
from homeassistant.const import (
|
|
CONF_ADDRESS, CONF_COVERS, CONF_HOST, CONF_LIGHTS, CONF_NAME,
|
|
CONF_PASSWORD, CONF_PORT, CONF_SENSORS, CONF_SWITCHES,
|
|
CONF_UNIT_OF_MEASUREMENT, CONF_USERNAME)
|
|
import homeassistant.helpers.config_validation as cv
|
|
from homeassistant.helpers.discovery import async_load_platform
|
|
from homeassistant.helpers.entity import Entity
|
|
|
|
from .const import (
|
|
CONF_CONNECTIONS, CONF_DIM_MODE, CONF_DIMMABLE, CONF_MOTOR, CONF_OUTPUT,
|
|
CONF_SK_NUM_TRIES, CONF_SOURCE, CONF_TRANSITION, DATA_LCN, DEFAULT_NAME,
|
|
DIM_MODES, DOMAIN, LED_PORTS, LOGICOP_PORTS, MOTOR_PORTS, OUTPUT_PORTS,
|
|
PATTERN_ADDRESS, RELAY_PORTS, S0_INPUTS, SETPOINTS, THRESHOLDS, VAR_UNITS,
|
|
VARIABLES)
|
|
|
|
_LOGGER = logging.getLogger(__name__)
|
|
|
|
REQUIREMENTS = ['pypck==0.5.9']
|
|
|
|
|
|
def has_unique_connection_names(connections):
|
|
"""Validate that all connection names are unique.
|
|
|
|
Use 'pchk' as default connection_name (or add a numeric suffix if
|
|
pchk' is already in use.
|
|
"""
|
|
for suffix, connection in enumerate(connections):
|
|
connection_name = connection.get(CONF_NAME)
|
|
if connection_name is None:
|
|
if suffix == 0:
|
|
connection[CONF_NAME] = DEFAULT_NAME
|
|
else:
|
|
connection[CONF_NAME] = '{}{:d}'.format(DEFAULT_NAME, suffix)
|
|
|
|
schema = vol.Schema(vol.Unique())
|
|
schema([connection.get(CONF_NAME) for connection in connections])
|
|
return connections
|
|
|
|
|
|
def is_address(value):
|
|
"""Validate the given address string.
|
|
|
|
Examples for S000M005 at myhome:
|
|
myhome.s000.m005
|
|
myhome.s0.m5
|
|
myhome.0.5 ("m" is implicit if missing)
|
|
|
|
Examples for s000g011
|
|
myhome.0.g11
|
|
myhome.s0.g11
|
|
"""
|
|
matcher = PATTERN_ADDRESS.match(value)
|
|
if matcher:
|
|
is_group = (matcher.group('type') == 'g')
|
|
addr = (int(matcher.group('seg_id')),
|
|
int(matcher.group('id')),
|
|
is_group)
|
|
conn_id = matcher.group('conn_id')
|
|
return addr, conn_id
|
|
raise vol.error.Invalid('Not a valid address string.')
|
|
|
|
|
|
COVERS_SCHEMA = vol.Schema({
|
|
vol.Required(CONF_NAME): cv.string,
|
|
vol.Required(CONF_ADDRESS): is_address,
|
|
vol.Required(CONF_MOTOR): vol.All(vol.Upper, vol.In(MOTOR_PORTS))
|
|
})
|
|
|
|
LIGHTS_SCHEMA = vol.Schema({
|
|
vol.Required(CONF_NAME): cv.string,
|
|
vol.Required(CONF_ADDRESS): is_address,
|
|
vol.Required(CONF_OUTPUT): vol.All(vol.Upper,
|
|
vol.In(OUTPUT_PORTS + RELAY_PORTS)),
|
|
vol.Optional(CONF_DIMMABLE, default=False): vol.Coerce(bool),
|
|
vol.Optional(CONF_TRANSITION, default=0):
|
|
vol.All(vol.Coerce(float), vol.Range(min=0., max=486.),
|
|
lambda value: value * 1000),
|
|
})
|
|
|
|
SENSORS_SCHEMA = vol.Schema({
|
|
vol.Required(CONF_NAME): cv.string,
|
|
vol.Required(CONF_ADDRESS): is_address,
|
|
vol.Required(CONF_SOURCE): vol.All(vol.Upper,
|
|
vol.In(VARIABLES + SETPOINTS +
|
|
THRESHOLDS + S0_INPUTS +
|
|
LED_PORTS + LOGICOP_PORTS)),
|
|
vol.Optional(CONF_UNIT_OF_MEASUREMENT, default='native'):
|
|
vol.All(vol.Upper, vol.In(VAR_UNITS))
|
|
})
|
|
|
|
SWITCHES_SCHEMA = vol.Schema({
|
|
vol.Required(CONF_NAME): cv.string,
|
|
vol.Required(CONF_ADDRESS): is_address,
|
|
vol.Required(CONF_OUTPUT): vol.All(vol.Upper,
|
|
vol.In(OUTPUT_PORTS + RELAY_PORTS))
|
|
})
|
|
|
|
CONNECTION_SCHEMA = vol.Schema({
|
|
vol.Required(CONF_HOST): cv.string,
|
|
vol.Required(CONF_PORT): cv.port,
|
|
vol.Required(CONF_USERNAME): cv.string,
|
|
vol.Required(CONF_PASSWORD): cv.string,
|
|
vol.Optional(CONF_SK_NUM_TRIES, default=3): cv.positive_int,
|
|
vol.Optional(CONF_DIM_MODE, default='steps50'): vol.All(vol.Upper,
|
|
vol.In(DIM_MODES)),
|
|
vol.Optional(CONF_NAME): cv.string
|
|
})
|
|
|
|
CONFIG_SCHEMA = vol.Schema({
|
|
DOMAIN: vol.Schema({
|
|
vol.Required(CONF_CONNECTIONS): vol.All(
|
|
cv.ensure_list, has_unique_connection_names, [CONNECTION_SCHEMA]),
|
|
vol.Optional(CONF_COVERS): vol.All(
|
|
cv.ensure_list, [COVERS_SCHEMA]),
|
|
vol.Optional(CONF_LIGHTS): vol.All(
|
|
cv.ensure_list, [LIGHTS_SCHEMA]),
|
|
vol.Optional(CONF_SENSORS): vol.All(
|
|
cv.ensure_list, [SENSORS_SCHEMA]),
|
|
vol.Optional(CONF_SWITCHES): vol.All(
|
|
cv.ensure_list, [SWITCHES_SCHEMA])
|
|
})
|
|
}, extra=vol.ALLOW_EXTRA)
|
|
|
|
|
|
def get_connection(connections, connection_id=None):
|
|
"""Return the connection object from list."""
|
|
if connection_id is None:
|
|
connection = connections[0]
|
|
else:
|
|
for connection in connections:
|
|
if connection.connection_id == connection_id:
|
|
break
|
|
else:
|
|
raise ValueError('Unknown connection_id.')
|
|
return connection
|
|
|
|
|
|
async def async_setup(hass, config):
|
|
"""Set up the LCN component."""
|
|
import pypck
|
|
from pypck.connection import PchkConnectionManager
|
|
|
|
hass.data[DATA_LCN] = {}
|
|
|
|
conf_connections = config[DOMAIN][CONF_CONNECTIONS]
|
|
connections = []
|
|
for conf_connection in conf_connections:
|
|
connection_name = conf_connection.get(CONF_NAME)
|
|
|
|
settings = {'SK_NUM_TRIES': conf_connection[CONF_SK_NUM_TRIES],
|
|
'DIM_MODE': pypck.lcn_defs.OutputPortDimMode[
|
|
conf_connection[CONF_DIM_MODE]]}
|
|
|
|
connection = PchkConnectionManager(hass.loop,
|
|
conf_connection[CONF_HOST],
|
|
conf_connection[CONF_PORT],
|
|
conf_connection[CONF_USERNAME],
|
|
conf_connection[CONF_PASSWORD],
|
|
settings=settings,
|
|
connection_id=connection_name)
|
|
|
|
try:
|
|
# establish connection to PCHK server
|
|
await hass.async_create_task(connection.async_connect(timeout=15))
|
|
connections.append(connection)
|
|
_LOGGER.info('LCN connected to "%s"', connection_name)
|
|
except TimeoutError:
|
|
_LOGGER.error('Connection to PCHK server "%s" failed.',
|
|
connection_name)
|
|
return False
|
|
|
|
hass.data[DATA_LCN][CONF_CONNECTIONS] = connections
|
|
|
|
# load platforms
|
|
for component, conf_key in (('cover', CONF_COVERS),
|
|
('light', CONF_LIGHTS),
|
|
('sensor', CONF_SENSORS),
|
|
('switch', CONF_SWITCHES)):
|
|
if conf_key in config[DOMAIN]:
|
|
hass.async_create_task(
|
|
async_load_platform(hass, component, DOMAIN,
|
|
config[DOMAIN][conf_key], config))
|
|
return True
|
|
|
|
|
|
class LcnDevice(Entity):
|
|
"""Parent class for all devices associated with the LCN component."""
|
|
|
|
def __init__(self, config, address_connection):
|
|
"""Initialize the LCN device."""
|
|
import pypck
|
|
self.pypck = pypck
|
|
self.config = config
|
|
self.address_connection = address_connection
|
|
self._name = config[CONF_NAME]
|
|
|
|
@property
|
|
def should_poll(self):
|
|
"""Lcn device entity pushes its state to HA."""
|
|
return False
|
|
|
|
async def async_added_to_hass(self):
|
|
"""Run when entity about to be added to hass."""
|
|
self.address_connection.register_for_inputs(
|
|
self.input_received)
|
|
|
|
@property
|
|
def name(self):
|
|
"""Return the name of the device."""
|
|
return self._name
|
|
|
|
def input_received(self, input_obj):
|
|
"""Set state/value when LCN input object (command) is received."""
|
|
raise NotImplementedError('Pure virtual function.')
|