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 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 Group(Device): """Class for managing a light.""" # pylint: disable=too-many-locals def __init__( self, xknx, name, addr, sw_cb=None, # val_cb=None, val_dim_cb=None, # clr_rgb_cb=None, clr_rgb_dim=None, # clr_r_cb=None, clr_r_dim_cb=None, clr_r_sw_cb=None, # clr_g_cb=None, clr_g_dim_cb=None, clr_g_sw_cb=None, # clr_b_cb=None, clr_b_dim_cb=None, clr_b_sw_cb=None, # clr_cct_cb=None, clr_cct_dim_cb=None, # clr_h_cb=None, clr_h_dim_cb=None, # clr_s_cb=None, clr_s_dim_cb=None, ): """Initialize Group class.""" # pylint: disable=too-many-arguments super().__init__(xknx, name) self.xknx = xknx self.sw = RV_SWITCH(xknx, addr["SW"], None, self.name, sw_cb) self.sw_stat = RV_SWITCH(xknx, addr["SW_STAT"], None, self.name) self.val = RV_SCALE( xknx, addr["VAL"], None, self.name, val_cb, 0, 255, ) self.val_dim = RV_DIM(xknx, addr["VAL_DIM"], None, self.name, val_dim_cb) self.val_stat = RV_SCALE(xknx, addr["VAL_STAT"], None, self.name, None, 0, 255) # self.clr_xyy = RV_XYY(xknx, addr["CLR_xyY"], None, self.name) self.clr_xyy_stat = RV_XYY(xknx, addr["CLR_xyY_STAT"], None, self.name) self.clr_cct_abs = RV_ABS(xknx, addr["CLR_CCT_ABS"], None, self.name) # self.clr_rgb = RV_RGB(xknx, addr["CLR_RGB"], None, self.name, clr_rgb_cb) self.clr_rgb_dim = RV_DIM(xknx, addr["CLR_RGB_DIM"], None, self.name, val_dim_cb) self.clr_rgb_stat = RV_RGB(xknx, addr["CLR_RGB_STAT"], None, self.name) # self.clr_r = RV_SCALE(xknx, addr["CLR_R"], None, self.name, clr_r_cb, 0, 255) self.clr_r_dim = RV_DIM(xknx, addr["CLR_R_DIM"], None, self.name, clr_r_dim_cb) self.clr_r_stat = RV_SCALE(xknx, addr["CLR_R_STAT"], None, self.name, None, 0, 255) self.clr_r_sw = RV_SWITCH(xknx, addr["CLR_R_SW"], None, self.name, clr_r_sw_cb) self.clr_r_sw_stat = RV_SWITCH(xknx, addr["CLR_R_SW_STAT"], None, self.name) # self.clr_g = RV_SCALE(xknx, addr["CLR_G"], None, self.name, clr_g_cb, 0, 255) self.clr_g_dim = RV_DIM(xknx, addr["CLR_G_DIM"], None, self.name, clr_g_dim_cb) self.clr_g_stat = RV_SCALE(xknx, addr["CLR_G_STAT"], None, self.name, None, 0, 255) self.clr_g_sw = RV_SWITCH(xknx, addr["CLR_G_SW"], None, self.name, clr_g_sw_cb) self.clr_g_sw_stat = RV_SWITCH(xknx, addr["CLR_G_SW_STAT"], None, self.name) # self.clr_b = RV_SCALE(xknx, addr["CLR_B"], None, self.name, clr_b_cb, 0, 255) self.clr_b_dim = RV_DIM(xknx, addr["CLR_B_DIM"], None, self.name, clr_b_dim_cb) self.clr_b_stat = RV_SCALE(xknx, addr["CLR_B_STAT"], None, self.name, None, 0, 255) self.clr_b_sw = RV_SWITCH(xknx, addr["CLR_B_SW"], None, self.name, clr_b_sw_cb) self.clr_b_sw_stat = RV_SWITCH(xknx, addr["CLR_B_SW_STAT"], None, self.name) # self.clr_cct = RV_SCALE(xknx, addr["CLR_CCT"], None, self.name, clr_cct_cb, 0, 255) self.clr_cct_dim = RV_DIM(xknx, addr["CLR_CCT_DIM"], None, self.name, clr_cct_dim_cb) self.clr_cct_stat = RV_SCALE(xknx, addr["CLR_CCT_STAT"], None, self.name, None, 0, 255) # self.clr_h = RV_SCALE( xknx, addr["CLR_H"], None, self.name, clr_h_cb, 0, 360, ) self.clr_h_dim = RV_DIM(xknx, addr["CLR_H_DIM"], None, self.name, clr_h_dim_cb) self.clr_h_stat = RV_SCALE( xknx, addr["CLR_H_STAT"], None, self.name, None, 0, 360, ) # self.clr_s = RV_SCALE(xknx, addr["CLR_S"], None, self.name, clr_s_cb, 0, 255) self.clr_s_dim = RV_DIM(xknx, addr["CLR_S_DIM"], None, self.name, clr_s_dim_cb) self.clr_s_stat = RV_SCALE(xknx, addr["CLR_S_STAT"], None, self.name, None, 0, 255) def update(self, addresses): self.sw.group_addresses = addresses["SW"] self.sw_stat.group_addresses = addresses["SW_STAT"] # self.val.group_addresses = addresses["VAL"] self.val_dim.group_addresses = addresses["VAL_DIM"] self.val_stat.group_addresses = addresses["VAL_STAT"] # self.clr_xyy.group_addresses = addresses["CLR_xyY"] self.clr_xyy_stat.group_addresses = addresses["CLR_xyY_STAT"] self.clr_cct_abs.group_addresses = addresses["CLR_CCT_ABS"] # self.clr_rgb.group_addresses = addresses["CLR_RGB"] self.clr_rgb_dim.group_addresses = addresses["CLR_RGB"] self.clr_rgb_stat.group_addresses = addresses["CLR_RGB_STAT"] # self.clr_r.group_addresses = addresses["CLR_R"] self.clr_r_dim.group_addresses = addresses["CLR_R_DIM"] self.clr_r_stat.group_addresses = addresses["CLR_R_STAT"] self.clr_r_sw.group_addresses = addresses["CLR_R_SW"] self.clr_r_sw_stat.group_addresses = addresses["CLR_R_SW_STAT"] # self.clr_g.group_addresses = addresses["CLR_G"] self.clr_g_dim.group_addresses = addresses["CLR_G_DIM"] self.clr_g_stat.group_addresses = addresses["CLR_G_STAT"] self.clr_g_sw.group_addresses = addresses["CLR_G_SW"] self.clr_g_sw_stat.group_addresses = addresses["CLR_G_SW_STAT"] # self.clr_b.group_addresses = addresses["CLR_B"] self.clr_b_dim.group_addresses = addresses["CLR_B_DIM"] self.clr_b_stat.group_addresses = addresses["CLR_B_STAT"] self.clr_b_sw.group_addresses = addresses["CLR_B_SW"] self.clr_b_sw_stat.group_addresses = addresses["CLR_B_SW_STAT"] # self.clr_cct.group_addresses = addresses["CLR_CCT"] self.clr_cct_dim.group_addresses = addresses["CLR_CCT_DIM"] self.clr_cct_stat.group_addresses = addresses["CLR_CCT_STAT"] # self.clr_h.group_addresses = addresses["CLR_H"] self.clr_h_dim.group_addresses = addresses["CLR_H_DIM"] self.clr_h_stat.group_addresses = addresses["CLR_H_STAT"] # self.clr_s.group_addresses = addresses["CLR_S"] self.clr_s_dim.group_addresses = addresses["CLR_S_DIM"] self.clr_s_stat.group_addresses = addresses["CLR_S_STAT"] @property def supports_dimming(self): return self.dimming_val.initialized @property def supports_brightness(self): return self.brightness.initialized @property def supports_color(self): return self.color_rgb.initialized @property def supports_color_xyY(self): return self.color_xyY.initialized def has_group_address(self, group_address): """Test if device has given group address. Not used for Status""" return ( self.sw.has_group_address(group_address) or self.val.has_group_address(group_address) # noqa W503 or self.val_dim.has_group_address(group_address) # noqa W503 # or self.clr_xyy.has_group_address(group_address) # noqa W503 or self.clr_cct_abs.has_group_address(group_address) # noqa W503 # or self.clr_rgb.has_group_address(group_address) # noqa W503 or self.clr_rgb_dim.has_group_address(group_address) # noqa W503 # or self.clr_r.has_group_address(group_address) # noqa W503 or self.clr_r_dim.has_group_address(group_address) # noqa W503 or self.clr_r_sw.has_group_address(group_address) # noqa W503 # or self.clr_g.has_group_address(group_address) # noqa W503 or self.clr_g_dim.has_group_address(group_address) # noqa W503 or self.clr_g_sw.has_group_address(group_address) # noqa W503 # or self.clr_b.has_group_address(group_address) # noqa W503 or self.clr_b_dim.has_group_address(group_address) # noqa W503 or self.clr_b_sw.has_group_address(group_address) # noqa W503 # or self.clr_h.has_group_address(group_address) # noqa W503 or self.clr_h_dim.has_group_address(group_address) # noqa W503 # or self.clr_s.has_group_address(group_address) # noqa W503 or self.clr_s_dim.has_group_address(group_address) # noqa W503 # or self.clr_cct.has_group_address(group_address) # noqa W503 or self.clr_cct_dim.has_group_address(group_address) # noqa W503 ) def __repr__(self): """Return object as readable string.""" return ( f"KNX_Group(name={self.name}, sw:{self.sw.group_address}" f", sw_stat: {self.sw_stat.group_address}" f", val_dim:{self.val_dim.group_address}, val:{self.val.group_address}" f", clr_xyy: {self.clr_xyy.group_address}, clr_rgb: {self.clr_rgb.group_address}" f", clr_rgb_stat:{self.clr_rgb_stat.group_address}") async def process_group_write(self, telegram): """Process incoming GROUP WRITE telegram.""" await self.sw.process(telegram) await self.val_dim.process(telegram) await self.val.process(telegram) # # await self.clr_xyy.process(telegram) # await self.clr_rgb.process(telegram) await self.clr_rgb_dim.process(telegram) # await self.clr_r.process(telegram) await self.clr_r_dim.process(telegram) await self.clr_r_sw.process(telegram) # await self.clr_g.process(telegram) await self.clr_g_dim.process(telegram) await self.clr_g_sw.process(telegram) # await self.clr_b.process(telegram) await self.clr_b_dim.process(telegram) await self.clr_b_sw.process(telegram) # await self.clr_h.process(telegram) await self.clr_h_dim.process(telegram) # await self.clr_s.process(telegram) await self.clr_s_dim.process(telegram) # await self.clr_cct.process(telegram) await self.clr_cct_dim.process(telegram) 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__