296 lines
11 KiB
Python
296 lines
11 KiB
Python
"""
|
|
Support for Rflink lights.
|
|
|
|
For more details about this platform, please refer to the documentation at
|
|
https://home-assistant.io/components/light.rflink/
|
|
"""
|
|
import asyncio
|
|
import logging
|
|
|
|
from homeassistant.components.light import (
|
|
ATTR_BRIGHTNESS, SUPPORT_BRIGHTNESS, Light)
|
|
from homeassistant.components.rflink import (
|
|
CONF_ALIASES, CONF_ALIASSES, CONF_AUTOMATIC_ADD, CONF_DEVICE_DEFAULTS,
|
|
CONF_DEVICES, CONF_FIRE_EVENT, CONF_GROUP, CONF_GROUP_ALIASES,
|
|
CONF_GROUP_ALIASSES, CONF_IGNORE_DEVICES, CONF_NOGROUP_ALIASES,
|
|
CONF_NOGROUP_ALIASSES, CONF_SIGNAL_REPETITIONS, DATA_DEVICE_REGISTER,
|
|
DATA_ENTITY_GROUP_LOOKUP, DATA_ENTITY_LOOKUP, DEVICE_DEFAULTS_SCHEMA,
|
|
DOMAIN, EVENT_KEY_COMMAND, EVENT_KEY_ID, SwitchableRflinkDevice, cv,
|
|
remove_deprecated, vol)
|
|
from homeassistant.const import (
|
|
CONF_NAME, CONF_PLATFORM, CONF_TYPE, STATE_UNKNOWN)
|
|
from homeassistant.helpers.deprecation import get_deprecated
|
|
|
|
DEPENDENCIES = ['rflink']
|
|
|
|
_LOGGER = logging.getLogger(__name__)
|
|
|
|
TYPE_DIMMABLE = 'dimmable'
|
|
TYPE_SWITCHABLE = 'switchable'
|
|
TYPE_HYBRID = 'hybrid'
|
|
TYPE_TOGGLE = 'toggle'
|
|
|
|
PLATFORM_SCHEMA = vol.Schema({
|
|
vol.Required(CONF_PLATFORM): DOMAIN,
|
|
vol.Optional(CONF_IGNORE_DEVICES): vol.All(cv.ensure_list, [cv.string]),
|
|
vol.Optional(CONF_DEVICE_DEFAULTS, default=DEVICE_DEFAULTS_SCHEMA({})):
|
|
DEVICE_DEFAULTS_SCHEMA,
|
|
vol.Optional(CONF_AUTOMATIC_ADD, default=True): cv.boolean,
|
|
vol.Optional(CONF_DEVICES, default={}): vol.Schema({
|
|
cv.string: {
|
|
vol.Optional(CONF_NAME): cv.string,
|
|
vol.Optional(CONF_TYPE):
|
|
vol.Any(TYPE_DIMMABLE, TYPE_SWITCHABLE,
|
|
TYPE_HYBRID, TYPE_TOGGLE),
|
|
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): cv.boolean,
|
|
vol.Optional(CONF_SIGNAL_REPETITIONS): vol.Coerce(int),
|
|
vol.Optional(CONF_GROUP, default=True): cv.boolean,
|
|
# deprecated config options
|
|
vol.Optional(CONF_ALIASSES):
|
|
vol.All(cv.ensure_list, [cv.string]),
|
|
vol.Optional(CONF_GROUP_ALIASSES):
|
|
vol.All(cv.ensure_list, [cv.string]),
|
|
vol.Optional(CONF_NOGROUP_ALIASSES):
|
|
vol.All(cv.ensure_list, [cv.string]),
|
|
},
|
|
}),
|
|
})
|
|
|
|
|
|
def entity_type_for_device_id(device_id):
|
|
"""Return entity class for protocol of a given device_id.
|
|
|
|
Async friendly.
|
|
"""
|
|
entity_type_mapping = {
|
|
# KlikAanKlikUit support both dimmers and on/off switches on the same
|
|
# protocol
|
|
'newkaku': TYPE_HYBRID,
|
|
}
|
|
protocol = device_id.split('_')[0]
|
|
return entity_type_mapping.get(protocol, None)
|
|
|
|
|
|
def entity_class_for_type(entity_type):
|
|
"""Translate entity type to entity class.
|
|
|
|
Async friendly.
|
|
"""
|
|
entity_device_mapping = {
|
|
# sends only 'dim' commands not compatible with on/off switches
|
|
TYPE_DIMMABLE: DimmableRflinkLight,
|
|
# sends only 'on/off' commands not advices with dimmers and signal
|
|
# repetition
|
|
TYPE_SWITCHABLE: RflinkLight,
|
|
# sends 'dim' and 'on' command to support both dimmers and on/off
|
|
# switches. Not compatible with signal repetition.
|
|
TYPE_HYBRID: HybridRflinkLight,
|
|
# sends only 'on' commands for switches which turn on and off
|
|
# using the same 'on' command for both.
|
|
TYPE_TOGGLE: ToggleRflinkLight,
|
|
}
|
|
|
|
return entity_device_mapping.get(entity_type, RflinkLight)
|
|
|
|
|
|
def devices_from_config(domain_config, hass=None):
|
|
"""Parse configuration and add Rflink light devices."""
|
|
devices = []
|
|
for device_id, config in domain_config[CONF_DEVICES].items():
|
|
# Determine which kind of entity to create
|
|
if CONF_TYPE in config:
|
|
# Remove type from config to not pass it as and argument to entity
|
|
# instantiation
|
|
entity_type = config.pop(CONF_TYPE)
|
|
else:
|
|
entity_type = entity_type_for_device_id(device_id)
|
|
entity_class = entity_class_for_type(entity_type)
|
|
|
|
device_config = dict(domain_config[CONF_DEVICE_DEFAULTS], **config)
|
|
remove_deprecated(device_config)
|
|
|
|
is_hybrid = entity_class is HybridRflinkLight
|
|
|
|
# Make user aware this can cause problems
|
|
repetitions_enabled = device_config[CONF_SIGNAL_REPETITIONS] != 1
|
|
if is_hybrid and repetitions_enabled:
|
|
_LOGGER.warning(
|
|
"Hybrid type for %s not compatible with signal "
|
|
"repetitions. Please set 'dimmable' or 'switchable' "
|
|
"type explicitly in configuration", device_id)
|
|
|
|
device = entity_class(device_id, hass, **device_config)
|
|
devices.append(device)
|
|
|
|
# Register entity (and aliases) to listen to incoming rflink events
|
|
|
|
# Device id and normal aliases respond to normal and group command
|
|
hass.data[DATA_ENTITY_LOOKUP][
|
|
EVENT_KEY_COMMAND][device_id].append(device)
|
|
if config[CONF_GROUP]:
|
|
hass.data[DATA_ENTITY_GROUP_LOOKUP][
|
|
EVENT_KEY_COMMAND][device_id].append(device)
|
|
for _id in get_deprecated(config, CONF_ALIASES, CONF_ALIASSES):
|
|
hass.data[DATA_ENTITY_LOOKUP][
|
|
EVENT_KEY_COMMAND][_id].append(device)
|
|
hass.data[DATA_ENTITY_GROUP_LOOKUP][
|
|
EVENT_KEY_COMMAND][_id].append(device)
|
|
# group_aliases only respond to group commands
|
|
for _id in get_deprecated(
|
|
config, CONF_GROUP_ALIASES, CONF_GROUP_ALIASSES):
|
|
hass.data[DATA_ENTITY_GROUP_LOOKUP][
|
|
EVENT_KEY_COMMAND][_id].append(device)
|
|
# nogroup_aliases only respond to normal commands
|
|
for _id in get_deprecated(
|
|
config, CONF_NOGROUP_ALIASES, CONF_NOGROUP_ALIASSES):
|
|
hass.data[DATA_ENTITY_LOOKUP][
|
|
EVENT_KEY_COMMAND][_id].append(device)
|
|
|
|
return devices
|
|
|
|
|
|
@asyncio.coroutine
|
|
def async_setup_platform(hass, config, async_add_entities,
|
|
discovery_info=None):
|
|
"""Set up the Rflink light platform."""
|
|
async_add_entities(devices_from_config(config, hass))
|
|
|
|
@asyncio.coroutine
|
|
def add_new_device(event):
|
|
"""Check if device is known, otherwise add to list of known devices."""
|
|
device_id = event[EVENT_KEY_ID]
|
|
|
|
entity_type = entity_type_for_device_id(event[EVENT_KEY_ID])
|
|
entity_class = entity_class_for_type(entity_type)
|
|
|
|
device_config = config[CONF_DEVICE_DEFAULTS]
|
|
device = entity_class(device_id, hass, **device_config)
|
|
async_add_entities([device])
|
|
|
|
# Register entity to listen to incoming Rflink events
|
|
hass.data[DATA_ENTITY_LOOKUP][
|
|
EVENT_KEY_COMMAND][device_id].append(device)
|
|
|
|
# Schedule task to process event after entity is created
|
|
hass.async_add_job(device.handle_event, event)
|
|
|
|
if config[CONF_AUTOMATIC_ADD]:
|
|
hass.data[DATA_DEVICE_REGISTER][EVENT_KEY_COMMAND] = add_new_device
|
|
|
|
|
|
class RflinkLight(SwitchableRflinkDevice, Light):
|
|
"""Representation of a Rflink light."""
|
|
|
|
pass
|
|
|
|
|
|
class DimmableRflinkLight(SwitchableRflinkDevice, Light):
|
|
"""Rflink light device that support dimming."""
|
|
|
|
_brightness = 255
|
|
|
|
@asyncio.coroutine
|
|
def async_turn_on(self, **kwargs):
|
|
"""Turn the device on."""
|
|
if ATTR_BRIGHTNESS in kwargs:
|
|
# rflink only support 16 brightness levels
|
|
self._brightness = int(kwargs[ATTR_BRIGHTNESS] / 17) * 17
|
|
|
|
# Turn on light at the requested dim level
|
|
yield from self._async_handle_command('dim', self._brightness)
|
|
|
|
@property
|
|
def brightness(self):
|
|
"""Return the brightness of this light between 0..255."""
|
|
return self._brightness
|
|
|
|
@property
|
|
def supported_features(self):
|
|
"""Flag supported features."""
|
|
return SUPPORT_BRIGHTNESS
|
|
|
|
|
|
class HybridRflinkLight(SwitchableRflinkDevice, Light):
|
|
"""Rflink light device that sends out both dim and on/off commands.
|
|
|
|
Used for protocols which support lights that are not exclusively on/off
|
|
style. For example KlikAanKlikUit supports both on/off and dimmable light
|
|
switches using the same protocol. This type allows unconfigured
|
|
KlikAanKlikUit devices to support dimming without breaking support for
|
|
on/off switches.
|
|
|
|
This type is not compatible with signal repetitions as the 'dim' and 'on'
|
|
command are send sequential and multiple 'on' commands to a dimmable
|
|
device can cause the dimmer to switch into a pulsating brightness mode.
|
|
Which results in a nice house disco :)
|
|
"""
|
|
|
|
_brightness = 255
|
|
|
|
@asyncio.coroutine
|
|
def async_turn_on(self, **kwargs):
|
|
"""Turn the device on and set dim level."""
|
|
if ATTR_BRIGHTNESS in kwargs:
|
|
# rflink only support 16 brightness levels
|
|
self._brightness = int(kwargs[ATTR_BRIGHTNESS] / 17) * 17
|
|
|
|
# if receiver supports dimming this will turn on the light
|
|
# at the requested dim level
|
|
yield from self._async_handle_command('dim', self._brightness)
|
|
|
|
# if the receiving device does not support dimlevel this
|
|
# will ensure it is turned on when full brightness is set
|
|
if self._brightness == 255:
|
|
yield from self._async_handle_command('turn_on')
|
|
|
|
@property
|
|
def brightness(self):
|
|
"""Return the brightness of this light between 0..255."""
|
|
return self._brightness
|
|
|
|
@property
|
|
def supported_features(self):
|
|
"""Flag supported features."""
|
|
return SUPPORT_BRIGHTNESS
|
|
|
|
|
|
class ToggleRflinkLight(SwitchableRflinkDevice, Light):
|
|
"""Rflink light device which sends out only 'on' commands.
|
|
|
|
Some switches like for example Livolo light switches use the
|
|
same 'on' command to switch on and switch off the lights.
|
|
If the light is on and 'on' gets sent, the light will turn off
|
|
and if the light is off and 'on' gets sent, the light will turn on.
|
|
"""
|
|
|
|
@property
|
|
def entity_id(self):
|
|
"""Return entity id."""
|
|
return "light.{}".format(self.name)
|
|
|
|
def _handle_event(self, event):
|
|
"""Adjust state if Rflink picks up a remote command for this device."""
|
|
self.cancel_queued_send_commands()
|
|
|
|
command = event['command']
|
|
if command == 'on':
|
|
# if the state is unknown or false, it gets set as true
|
|
# if the state is true, it gets set as false
|
|
self._state = self._state in [STATE_UNKNOWN, False]
|
|
|
|
@asyncio.coroutine
|
|
def async_turn_on(self, **kwargs):
|
|
"""Turn the device on."""
|
|
yield from self._async_handle_command('toggle')
|
|
|
|
@asyncio.coroutine
|
|
def async_turn_off(self, **kwargs):
|
|
"""Turn the device off."""
|
|
yield from self._async_handle_command('toggle')
|