class Switch(Device):
"""Class for managing a switch."""
def __init__(self,
xknx,
name,
group_address=None,
group_address_state=None,
device_updated_cb=None):
"""Initialize Switch class."""
# pylint: disable=too-many-arguments
super().__init__(xknx, name, device_updated_cb)
self.switch = RemoteValueSwitch(xknx,
group_address,
group_address_state,
device_name=self.name,
after_update_cb=self.after_update)
@classmethod
def from_config(cls, xknx, name, config):
"""Initialize object from configuration structure."""
group_address = \
config.get('group_address')
group_address_state = \
config.get('group_address_state')
return cls(xknx,
name,
group_address=group_address,
group_address_state=group_address_state)
def has_group_address(self, group_address):
"""Test if device has given group address."""
return self.switch.has_group_address(group_address)
@property
def state(self):
"""Return the current switch state of the device."""
# None will return False
return bool(self.switch.value)
async def set_on(self):
"""Switch on switch."""
await self.switch.on()
async def set_off(self):
"""Switch off switch."""
await self.switch.off()
async def do(self, action):
"""Execute 'do' commands."""
if action == "on":
await self.set_on()
elif action == "off":
await self.set_off()
else:
self.xknx.logger.warning(
"Could not understand action %s for device %s", action,
self.get_name())
def state_addresses(self):
"""Return group addresses which should be requested to sync state."""
return self.switch.state_addresses()
async def process_group_write(self, telegram):
"""Process incoming GROUP WRITE telegram."""
await self.switch.process(telegram)
def __str__(self):
"""Return object as readable string."""
return '<Switch name="{0}" switch="{1}" />' \
.format(self.name,
self.switch.group_addr_str())
def __eq__(self, other):
"""Equal operator."""
return self.__dict__ == other.__dict__
class Climate(Device):
"""Class for managing the climate."""
# pylint: disable=too-many-instance-attributes,invalid-name
def __init__(self,
xknx,
name,
group_address_temperature=None,
group_address_target_temperature=None,
group_address_target_temperature_state=None,
group_address_setpoint_shift=None,
group_address_setpoint_shift_state=None,
setpoint_shift_mode=DEFAULT_SETPOINT_SHIFT_MODE,
setpoint_shift_step=DEFAULT_SETPOINT_SHIFT_STEP,
setpoint_shift_max=DEFAULT_SETPOINT_SHIFT_MAX,
setpoint_shift_min=DEFAULT_SETPOINT_SHIFT_MIN,
group_address_on_off=None,
group_address_on_off_state=None,
on_off_invert=False,
min_temp=None,
max_temp=None,
mode=None,
device_updated_cb=None):
"""Initialize Climate class."""
# pylint: disable=too-many-arguments, too-many-locals, too-many-branches, too-many-statements
super().__init__(xknx, name, device_updated_cb)
if isinstance(group_address_on_off, (str, int)):
group_address_on_off = GroupAddress(group_address_on_off)
if isinstance(group_address_on_off_state, (str, int)):
group_address_on_off_state = GroupAddress(
group_address_on_off_state)
self.group_address_on_off = group_address_on_off
self.group_address_on_off_state = group_address_on_off_state
self.min_temp = min_temp
self.max_temp = max_temp
self.setpoint_shift_step = setpoint_shift_step
self.setpoint_shift_min = setpoint_shift_min
self.setpoint_shift_max = setpoint_shift_max
self.temperature = RemoteValueTemp(
xknx,
group_address_state=group_address_temperature,
device_name=self.name,
after_update_cb=self.after_update)
self.target_temperature = RemoteValueTemp(
xknx,
group_address_target_temperature,
group_address_target_temperature_state,
device_name=self.name,
after_update_cb=self.after_update)
if setpoint_shift_mode == SetpointShiftMode.DPT9002:
self._setpoint_shift = RemoteValueTemp(
xknx,
group_address_setpoint_shift,
group_address_setpoint_shift_state,
device_name=self.name,
after_update_cb=self.after_update)
else:
self._setpoint_shift = RemoteValueSetpointShift(
xknx,
group_address_setpoint_shift,
group_address_setpoint_shift_state,
device_name=self.name,
after_update_cb=self.after_update,
setpoint_shift_step=setpoint_shift_step)
self.supports_on_off = \
group_address_on_off is not None or \
group_address_on_off_state is not None
self.on = RemoteValueSwitch(xknx,
group_address_on_off,
group_address_on_off_state,
device_name=self.name,
after_update_cb=self.after_update,
invert=on_off_invert)
self.mode = mode
@classmethod
def from_config(cls, xknx, name, config):
"""Initialize object from configuration structure."""
# pylint: disable=too-many-locals
group_address_temperature = \
config.get('group_address_temperature')
group_address_target_temperature = \
config.get('group_address_target_temperature')
group_address_target_temperature_state = \
config.get('group_address_target_temperature_state')
group_address_setpoint_shift = \
config.get('group_address_setpoint_shift')
group_address_setpoint_shift_state = \
config.get('group_address_setpoint_shift_state')
setpoint_shift_mode = \
config.get('setpoint_shift_mode', DEFAULT_SETPOINT_SHIFT_MODE)
setpoint_shift_step = \
config.get('setpoint_shift_step', DEFAULT_SETPOINT_SHIFT_STEP)
setpoint_shift_max = \
config.get('setpoint_shift_max', DEFAULT_SETPOINT_SHIFT_MAX)
setpoint_shift_min = \
config.get('setpoint_shift_min', DEFAULT_SETPOINT_SHIFT_MIN)
group_address_on_off = \
config.get('group_address_on_off')
group_address_on_off_state = \
config.get('group_address_on_off_state')
on_off_invert = \
config.get('on_off_invert', False)
min_temp = config.get('min_temp')
max_temp = config.get('max_temp')
climate_mode = None
if "mode" in config:
climate_mode = ClimateMode.from_config(xknx=xknx,
name=None,
config=config['mode'])
return cls(
xknx,
name,
group_address_temperature=group_address_temperature,
group_address_target_temperature=group_address_target_temperature,
group_address_target_temperature_state=
group_address_target_temperature_state,
group_address_setpoint_shift=group_address_setpoint_shift,
group_address_setpoint_shift_state=
group_address_setpoint_shift_state,
setpoint_shift_mode=setpoint_shift_mode,
setpoint_shift_step=setpoint_shift_step,
setpoint_shift_max=setpoint_shift_max,
setpoint_shift_min=setpoint_shift_min,
group_address_on_off=group_address_on_off,
group_address_on_off_state=group_address_on_off_state,
on_off_invert=on_off_invert,
min_temp=min_temp,
max_temp=max_temp,
mode=climate_mode)
def has_group_address(self, group_address):
"""Test if device has given group address."""
if self.mode is not None and self.mode.has_group_address(
group_address):
return True
return self.temperature.has_group_address(group_address) or \
self.target_temperature.has_group_address(group_address) or \
self._setpoint_shift.has_group_address(group_address) or \
self.on.has_group_address(group_address)
@property
def is_on(self):
"""Return power status."""
# None will return False
return bool(self.on.value)
async def turn_on(self):
"""Set power status to on."""
await self.on.on()
async def turn_off(self):
"""Set power status to off."""
await self.on.off()
@property
def initialized_for_setpoint_shift_calculations(self):
"""Test if object is initialized for setpoint shift calculations."""
if not self._setpoint_shift.initialized:
return False
if self._setpoint_shift.value is None:
return False
if not self.target_temperature.initialized:
return False
if self.target_temperature.value is None:
return False
return True
@property
def temperature_step(self):
"""Return smallest possible temperature step."""
if self._setpoint_shift.initialized:
return self.setpoint_shift_step
return DEFAULT_TEMPERATURE_STEP
async def set_target_temperature(self, target_temperature):
"""Send new target temperature or setpoint_shift to KNX bus."""
if self.initialized_for_setpoint_shift_calculations:
temperature_delta = target_temperature - self.base_temperature
await self.set_setpoint_shift(temperature_delta)
else:
validated_temp = self.validate_value(target_temperature,
self.min_temp, self.max_temp)
await self.target_temperature.set(validated_temp)
@property
def base_temperature(self):
"""
Return the base temperature.
Base temperature is the default temperature (setpoint-shift=0) for the active climate mode.
As this value is usually not available via KNX, we have to derive this from the current
target temperature and the current set point shift.
"""
if self.initialized_for_setpoint_shift_calculations:
return self.target_temperature.value - self.setpoint_shift
return None
@property
def setpoint_shift(self):
"""Return current offset from base temperature in Kelvin."""
return self._setpoint_shift.value
def validate_value(self, value, min_value, max_value):
"""Check boundaries of temperature and return valid temperature value."""
if (min_value is not None) and (value < min_value):
self.xknx.logger.warning("min value exceeded at %s: %s", self.name,
value)
return min_value
if (max_value is not None) and (value > max_value):
self.xknx.logger.warning("max value exceeded at %s: %s", self.name,
value)
return max_value
return value
async def set_setpoint_shift(self, offset):
"""Send new temperature offset to KNX bus."""
validated_offset = self.validate_value(offset, self.setpoint_shift_min,
self.setpoint_shift_max)
base_temperature = self.base_temperature
await self._setpoint_shift.set(validated_offset)
# broadcast new target temperature and set internally
if self.target_temperature.writable and \
base_temperature is not None:
await self.target_temperature.set(base_temperature +
self.setpoint_shift)
@property
def target_temperature_max(self):
"""Return the highest possible target temperature."""
if self.max_temp is not None:
return self.max_temp
if self.initialized_for_setpoint_shift_calculations:
return self.base_temperature + self.setpoint_shift_max
return None
@property
def target_temperature_min(self):
"""Return the lowest possible target temperature."""
if self.min_temp is not None:
return self.min_temp
if self.initialized_for_setpoint_shift_calculations:
return self.base_temperature + self.setpoint_shift_min
return None
async def process_group_write(self, telegram):
"""Process incoming GROUP WRITE telegram."""
await self.temperature.process(telegram)
await self.target_temperature.process(telegram)
await self._setpoint_shift.process(telegram)
await self.on.process(telegram)
if self.mode is not None:
await self.mode.process_group_write(telegram)
def state_addresses(self):
"""Return group addresses which should be requested to sync state."""
state_addresses = []
state_addresses.extend(self.temperature.state_addresses())
state_addresses.extend(self.target_temperature.state_addresses())
state_addresses.extend(self._setpoint_shift.state_addresses())
if self.supports_on_off:
state_addresses.extend(self.on.state_addresses())
if self.mode is not None:
state_addresses.extend(self.mode.state_addresses())
return state_addresses
def __str__(self):
"""Return object as readable string."""
return '<Climate name="{0}" ' \
'temperature="{1}" ' \
'target_temperature="{2}" ' \
'setpoint_shift="{3}" ' \
'setpoint_shift_step="{4}" ' \
'setpoint_shift_max="{5}" ' \
'setpoint_shift_min="{6}" ' \
'group_address_on_off="{7}" ' \
'/>' \
.format(
self.name,
self.temperature.group_addr_str(),
self.target_temperature.group_addr_str(),
self._setpoint_shift.group_addr_str(),
self._setpoint_shift.setpoint_shift_step,
self.setpoint_shift_max,
self.setpoint_shift_min,
self.on.group_addr_str())
def __eq__(self, other):
"""Equal operator."""
return self.__dict__ == other.__dict__
class Light(Device):
"""Class for managing a light."""
# pylint: disable=too-many-locals
DEFAULT_MIN_KELVIN = 2700 # 370 mireds
DEFAULT_MAX_KELVIN = 6000 # 166 mireds
def __init__(self,
xknx,
name,
group_address_switch=None,
group_address_switch_state=None,
group_address_brightness=None,
group_address_brightness_state=None,
group_address_color=None,
group_address_color_state=None,
group_address_rgbw=None,
group_address_rgbw_state=None,
group_address_tunable_white=None,
group_address_tunable_white_state=None,
group_address_color_temperature=None,
group_address_color_temperature_state=None,
min_kelvin=None,
max_kelvin=None,
device_updated_cb=None):
"""Initialize Light class."""
# pylint: disable=too-many-arguments
super().__init__(xknx, name, device_updated_cb)
self.switch = RemoteValueSwitch(xknx,
group_address_switch,
group_address_switch_state,
device_name=self.name,
after_update_cb=self.after_update)
self.brightness = RemoteValueScaling(xknx,
group_address_brightness,
group_address_brightness_state,
device_name=self.name,
after_update_cb=self.after_update,
range_from=0,
range_to=255)
self.color = RemoteValueColorRGB(xknx,
group_address_color,
group_address_color_state,
device_name=self.name,
after_update_cb=self.after_update)
self.rgbw = RemoteValueColorRGBW(xknx,
group_address_rgbw,
group_address_rgbw_state,
device_name=self.name,
after_update_cb=self.after_update)
self.tunable_white = RemoteValueScaling(
xknx,
group_address_tunable_white,
group_address_tunable_white_state,
device_name=self.name,
after_update_cb=self.after_update,
range_from=0,
range_to=255)
self.color_temperature = RemoteValueDpt2ByteUnsigned(
xknx,
group_address_color_temperature,
group_address_color_temperature_state,
device_name=self.name,
after_update_cb=self.after_update)
self.min_kelvin = min_kelvin
self.max_kelvin = max_kelvin
@property
def supports_brightness(self):
"""Return if light supports brightness."""
return self.brightness.initialized
@property
def supports_color(self):
"""Return if light supports color."""
return self.color.initialized
@property
def supports_rgbw(self):
"""Return if light supports RGBW."""
return self.rgbw.initialized
@property
def supports_tunable_white(self):
"""Return if light supports tunable white / relative color temperature."""
return self.tunable_white.initialized
@property
def supports_color_temperature(self):
"""Return if light supports absolute color temperature."""
return self.color_temperature.initialized
@classmethod
def from_config(cls, xknx, name, config):
"""Initialize object from configuration structure."""
group_address_switch = \
config.get('group_address_switch')
group_address_switch_state = \
config.get('group_address_switch_state')
group_address_brightness = \
config.get('group_address_brightness')
group_address_brightness_state = \
config.get('group_address_brightness_state')
group_address_color = \
config.get('group_address_color')
group_address_color_state = \
config.get('group_address_color_state')
group_address_rgbw = \
config.get('group_address_rgbw')
group_address_rgbw_state = \
config.get('group_address_rgbw_state')
group_address_tunable_white = \
config.get('group_address_tunable_white')
group_address_tunable_white_state = \
config.get('group_address_tunable_white_state')
group_address_color_temperature = \
config.get('group_address_color_temperature')
group_address_color_temperature_state = \
config.get('group_address_color_temperature_state')
min_kelvin = \
config.get('min_kelvin', Light.DEFAULT_MIN_KELVIN)
max_kelvin = \
config.get('max_kelvin', Light.DEFAULT_MAX_KELVIN)
return cls(
xknx,
name,
group_address_switch=group_address_switch,
group_address_switch_state=group_address_switch_state,
group_address_brightness=group_address_brightness,
group_address_brightness_state=group_address_brightness_state,
group_address_color=group_address_color,
group_address_color_state=group_address_color_state,
group_address_rgbw=group_address_rgbw,
group_address_rgbw_state=group_address_rgbw_state,
group_address_tunable_white=group_address_tunable_white,
group_address_tunable_white_state=group_address_tunable_white_state,
group_address_color_temperature=group_address_color_temperature,
group_address_color_temperature_state=
group_address_color_temperature_state,
min_kelvin=min_kelvin,
max_kelvin=max_kelvin)
def has_group_address(self, group_address):
"""Test if device has given group address."""
return (self.switch.has_group_address(group_address)
or self.brightness.has_group_address(group_address)
or self.color.has_group_address(group_address)
or self.rgbw.has_group_address(group_address)
or self.tunable_white.has_group_address(group_address)
or self.color_temperature.has_group_address(group_address))
def __str__(self):
"""Return object as readable string."""
str_brightness = '' if not self.supports_brightness else \
' brightness="{0}"'.format(
self.brightness.group_addr_str())
str_color = '' if not self.supports_color else \
' color="{0}"'.format(
self.color.group_addr_str())
str_rgbw = '' if not self.supports_rgbw else \
' rgbw="{0}"'.format(
self.rgbw.group_addr_str())
str_tunable_white = '' if not self.supports_tunable_white else \
' tunable white="{0}"'.format(
self.tunable_white.group_addr_str())
str_color_temperature = '' if not self.supports_color_temperature else \
' color temperature="{0}"'.format(
self.color_temperature.group_addr_str())
return '<Light name="{0}" ' \
'switch="{1}"{2}{3}{4}{5}{6} />' \
.format(
self.name,
self.switch.group_addr_str(),
str_brightness,
str_color,
str_rgbw,
str_tunable_white,
str_color_temperature)
@property
def state(self):
"""Return the current switch state of the device."""
# None will return False
return bool(self.switch.value)
async def set_on(self):
"""Switch light on."""
await self.switch.on()
async def set_off(self):
"""Switch light off."""
await self.switch.off()
@property
def current_brightness(self):
"""Return current brightness of light."""
return self.brightness.value
async def set_brightness(self, brightness):
"""Set brightness of light."""
if not self.supports_brightness:
self.xknx.logger.warning("Dimming not supported for device %s",
self.get_name())
return
await self.brightness.set(brightness)
@property
def current_color(self):
"""
Return current color of light.
If the device supports RGBW, get the current RGB+White values instead.
"""
if self.supports_rgbw:
if not self.rgbw.value:
return None, None
return self.rgbw.value[:3], self.rgbw.value[3]
return self.color.value, None
async def set_color(self, color, white=None):
"""
Set color of a light device.
If also the white value is given and the device supports RGBW,
set all four values.
"""
if white is not None:
if self.supports_rgbw:
await self.rgbw.set(list(color) + [white])
return
self.xknx.logger.warning("RGBW not supported for device %s",
self.get_name())
else:
if self.supports_color:
await self.color.set(color)
return
self.xknx.logger.warning("Colors not supported for device %s",
self.get_name())
@property
def current_tunable_white(self):
"""Return current relative color temperature of light."""
return self.tunable_white.value
async def set_tunable_white(self, tunable_white):
"""Set relative color temperature of light."""
if not self.supports_tunable_white:
self.xknx.logger.warning(
"Tunable white not supported for device %s", self.get_name())
return
await self.tunable_white.set(tunable_white)
@property
def current_color_temperature(self):
"""Return current absolute color temperature of light."""
return self.color_temperature.value
async def set_color_temperature(self, color_temperature):
"""Set absolute color temperature of light."""
if not self.supports_color_temperature:
self.xknx.logger.warning(
"Absolute Color Temperature not supported for device %s",
self.get_name())
return
await self.color_temperature.set(color_temperature)
async def do(self, action):
"""Execute 'do' commands."""
if action == "on":
await self.set_on()
elif action == "off":
await self.set_off()
elif action.startswith("brightness:"):
await self.set_brightness(int(action[11:]))
elif action.startswith("tunable_white:"):
await self.set_tunable_white(int(action[14:]))
elif action.startswith("color_temperature:"):
await self.set_color_temperature(int(action[18:]))
else:
self.xknx.logger.warning(
"Could not understand action %s for device %s", action,
self.get_name())
def state_addresses(self):
"""Return group addresses which should be requested to sync state."""
state_addresses = []
state_addresses.extend(self.switch.state_addresses())
state_addresses.extend(self.color.state_addresses())
state_addresses.extend(self.rgbw.state_addresses())
state_addresses.extend(self.brightness.state_addresses())
state_addresses.extend(self.tunable_white.state_addresses())
state_addresses.extend(self.color_temperature.state_addresses())
return state_addresses
async def process_group_write(self, telegram):
"""Process incoming GROUP WRITE telegram."""
await self.switch.process(telegram)
await self.color.process(telegram)
await self.rgbw.process(telegram)
await self.brightness.process(telegram)
await self.tunable_white.process(telegram)
await self.color_temperature.process(telegram)
def __eq__(self, other):
"""Equal operator."""
return self.__dict__ == other.__dict__
