class Cover(Device): """Class for managing a cover.""" # pylint: disable=too-many-instance-attributes # pylint: disable=too-many-public-methods # pylint: disable=too-many-locals # Average typical travel time of a cover DEFAULT_TRAVEL_TIME_DOWN = 22 DEFAULT_TRAVEL_TIME_UP = 22 def __init__(self, xknx, name, group_address_long=None, group_address_short=None, group_address_position=None, group_address_position_state=None, group_address_angle=None, group_address_angle_state=None, travel_time_down=DEFAULT_TRAVEL_TIME_DOWN, travel_time_up=DEFAULT_TRAVEL_TIME_UP, invert_position=False, invert_angle=False, device_updated_cb=None): """Initialize Cover class.""" # pylint: disable=too-many-arguments super().__init__(xknx, name, device_updated_cb) self.updown = RemoteValueUpDown(xknx, group_address_long, device_name=self.name, after_update_cb=self.after_update, invert=invert_position) self.step = RemoteValueStep(xknx, group_address_short, device_name=self.name, after_update_cb=self.after_update, invert=invert_position) position_range_from = 0 if invert_position else 100 position_range_to = 100 if invert_position else 0 self.position = RemoteValueScaling(xknx, group_address_position, group_address_position_state, device_name=self.name, after_update_cb=self.after_update, range_from=position_range_from, range_to=position_range_to) angle_range_from = 0 if invert_angle else 100 angle_range_to = 100 if invert_angle else 0 self.angle = RemoteValueScaling(xknx, group_address_angle, group_address_angle_state, device_name=self.name, after_update_cb=self.after_update, range_from=angle_range_from, range_to=angle_range_to) self.travel_time_down = travel_time_down self.travel_time_up = travel_time_up self.travelcalculator = TravelCalculator(travel_time_down, travel_time_up) @classmethod def from_config(cls, xknx, name, config): """Initialize object from configuration structure.""" group_address_long = \ config.get('group_address_long') group_address_short = \ config.get('group_address_short') group_address_position = \ config.get('group_address_position') group_address_position_state = \ config.get('group_address_position_state') group_address_angle = \ config.get('group_address_angle') group_address_angle_state = \ config.get('group_address_angle_state') travel_time_down = \ config.get('travel_time_down', cls.DEFAULT_TRAVEL_TIME_DOWN) travel_time_up = \ config.get('travel_time_up', cls.DEFAULT_TRAVEL_TIME_UP) invert_position = \ config.get('invert_position', False) invert_angle = \ config.get('invert_angle', False) return cls(xknx, name, group_address_long=group_address_long, group_address_short=group_address_short, group_address_position=group_address_position, group_address_position_state=group_address_position_state, group_address_angle=group_address_angle, group_address_angle_state=group_address_angle_state, travel_time_down=travel_time_down, travel_time_up=travel_time_up, invert_position=invert_position, invert_angle=invert_angle) def has_group_address(self, group_address): """Test if device has given group address.""" return self.updown.has_group_address(group_address) \ or self.step.has_group_address(group_address) \ or self.position.has_group_address(group_address) \ or self.angle.has_group_address(group_address) def __str__(self): """Return object as readable string.""" return '<Cover name="{0}" ' \ 'updown="{1}" ' \ 'step="{2}" ' \ 'position="{3}" ' \ 'angle="{4}" '\ 'travel_time_down="{5}" ' \ 'travel_time_up="{6}" />' \ .format( self.name, self.updown.group_addr_str(), self.step.group_addr_str(), self.position.group_addr_str(), self.angle.group_addr_str(), self.travel_time_down, self.travel_time_up) async def set_down(self): """Move cover down.""" await self.updown.down() self.travelcalculator.start_travel_down() async def set_up(self): """Move cover up.""" await self.updown.up() self.travelcalculator.start_travel_up() async def set_short_down(self): """Move cover short down.""" await self.step.increase() async def set_short_up(self): """Move cover short up.""" await self.step.decrease() async def stop(self): """Stop cover.""" # Thats the KNX way of doing this. electrical engineers ... m-) await self.step.increase() self.travelcalculator.stop() async def set_position(self, position): """Move cover to a desginated postion.""" # No direct positioning group address defined if not self.position.group_address: current_position = self.current_position() if position < current_position: await self.updown.down() elif position > current_position: await self.updown.up() self.travelcalculator.start_travel(position) return await self.position.set(position) self.travelcalculator.start_travel(position) async def set_angle(self, angle): """Move cover to designated angle.""" if not self.supports_angle: self.xknx.logger.warning('Angle not supported for device %s', self.get_name()) return await self.angle.set(angle) await self.after_update() async def auto_stop_if_necessary(self): """Do auto stop if necessary.""" # If device does not support auto_positioning, # we have to stop the device when position is reached. # unless device was traveling to fully open # or fully closed state if (not self.position.group_address and self.position_reached() and not self.is_open() and not self.is_closed()): await self.stop() async def do(self, action): """Execute 'do' commands.""" if action == "up": await self.set_up() elif action == "short_up": await self.set_short_up() elif action == "down": await self.set_down() elif action == "short_down": await self.set_short_down() elif action == "stop": await self.stop() 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.""" if self.travelcalculator.is_traveling(): # Cover is traveling, requesting state will return false results return [] state_addresses = [] state_addresses.extend(self.position.state_addresses()) state_addresses.extend(self.angle.state_addresses()) return state_addresses async def process_group_write(self, telegram): """Process incoming GROUP WRITE telegram.""" position_processed = await self.position.process(telegram) if position_processed: self.travelcalculator.set_position(self.position.value) await self.after_update() await self.angle.process(telegram) def current_position(self): """Return current position of cover.""" return self.travelcalculator.current_position() def current_angle(self): """Return current tilt angle of cover.""" return self.angle.value def is_traveling(self): """Return if cover is traveling at the moment.""" return self.travelcalculator.is_traveling() def position_reached(self): """Return if cover has reached its final position.""" return self.travelcalculator.position_reached() def is_open(self): """Return if cover is open.""" return self.travelcalculator.is_open() def is_closed(self): """Return if cover is closed.""" return self.travelcalculator.is_closed() @property def supports_position(self): """Return if cover supports direct positioning.""" return self.position.initialized @property def supports_angle(self): """Return if cover supports tilt angle.""" return self.angle.initialized def __eq__(self, other): """Equal operator.""" return self.__dict__ == other.__dict__
class Fan(Device): """Class for managing a fan.""" # pylint: disable=too-many-instance-attributes # pylint: disable=too-many-public-methods def __init__(self, xknx, name, group_address_speed=None, group_address_speed_state=None, device_updated_cb=None): """Initialize fan class.""" # pylint: disable=too-many-arguments Device.__init__(self, xknx, name, device_updated_cb) self.speed = RemoteValueScaling(xknx, group_address_speed, group_address_speed_state, device_name=self.name, after_update_cb=self.after_update, range_from=0, range_to=100) @classmethod def from_config(cls, xknx, name, config): """Initialize object from configuration structure.""" group_address_speed = \ config.get('group_address_speed') group_address_speed_state = \ config.get('group_address_speed_state') return cls(xknx, name, group_address_speed=group_address_speed, group_address_speed_state=group_address_speed_state) def has_group_address(self, group_address): """Test if device has given group address.""" return self.speed.has_group_address(group_address) def __str__(self): """Return object as readable string.""" return '<Fan name="{0}" ' \ 'speed="{1}" />' \ .format( self.name, self.speed.group_addr_str()) async def set_speed(self, speed): """Set the fan to a desginated speed.""" await self.speed.set(speed) async def do(self, action): """Execute 'do' commands.""" if action.startswith("speed:"): await self.set_speed(int(action[6:])) 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.speed.state_addresses()) return state_addresses async def process_group_write(self, telegram): """Process incoming GROUP WRITE telegram.""" await self.speed.process(telegram) @property def current_speed(self): """Return current speed of fan.""" return self.speed.value 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__