# TinyTuya Bulb Device # -*- coding: utf-8 -*- """ Python module to interface with Tuya WiFi smart devices Author: Jason A. Cox For more information see https://github.com/jasonacox/tinytuya Local Control Classes BulbDevice(...) See OutletDevice() for constructor arguments Functions BulbDevice Class methods rgb_to_hexvalue(r, g, b, hexformat): hsv_to_hexvalue(h, s, v, hexformat): hexvalue_to_rgb(hexvalue, hexformat=None): hexvalue_to_hsv(hexvalue, hexformat=None): BulbDevice set_mode(self, mode="white", nowait=False): set_scene(self, scene, scene_data=None, nowait=False): set_timer(self, num_secs, nowait=False): set_musicmode(self, transition, modify_settings=True, nowait=False): unset_musicmode( self ): set_music_colour( self, red, green, blue, brightness=None, colourtemp=None, transition=None, nowait=False ): set_colour(r, g, b, nowait): set_hsv(h, s, v, nowait): set_white_percentage(brightness=100, colourtemp=0, nowait): set_brightness_percentage(brightness=100, nowait): set_colourtemp_percentage(colourtemp=100, nowait): result = get_value(self, feature, state=None, nowait=False): result = get_mode(self, state=None, nowait=False): result = get_brightness_percentage(self, state=None, nowait=False): result = get_colourtemp_percentage(self, state=None, nowait=False): (r, g, b) = colour_rgb(): (h,s,v) = colour_hsv() result = state(): bool = bulb_has_capability( self, feature, nowait=False ): detect_bulb(self, response=None, nowait=False): set_bulb_type(self, bulb_type=None, mapping=None): set_bulb_capabilities(self, mapping): Inherited Every device function from core.py """ import colorsys from .core import Device, log from .core import error_json, ERR_JSON, ERR_FUNCTION # ERR_RANGE, ERR_STATE, ERR_TIMEOUT # pylint: disable=R0904 class BulbDevice(Device): """ Represents a Tuya based Smart Light/Bulb. """ DPS_MODE_WHITE = "white" DPS_MODE_COLOUR = "colour" DPS_MODE_SCENE = "scene" DPS_MODE_MUSIC = "music" DPS_MODE_SCENE_1 = "scene_1" # nature DPS_MODE_SCENE_2 = "scene_2" DPS_MODE_SCENE_3 = "scene_3" # rave DPS_MODE_SCENE_4 = "scene_4" # rainbow BULB_FEATURE_MODE = 'mode' BULB_FEATURE_BRIGHTNESS = 'brightness' BULB_FEATURE_COLOURTEMP = 'colourtemp' BULB_FEATURE_COLOUR = 'colour' BULB_FEATURE_SCENE = 'scene' BULB_FEATURE_SCENE_DATA = 'scene_data' BULB_FEATURE_TIMER = 'timer' BULB_FEATURE_MUSIC = 'music' MUSIC_TRANSITION_JUMP = 0 MUSIC_TRANSITION_FADE = 1 DEFAULT_DPSET = {} DEFAULT_DPSET['A'] = { 'switch': 1, 'mode': 2, 'brightness': 3, 'colourtemp': 4, 'colour': 5, 'scene': 6, 'scene_data': None, # Type A sets mode to 'scene_N' 'timer': 7, 'music': 8, 'value_min': 25, 'value_max': 255, 'value_hexformat': 'rgb8', } DEFAULT_DPSET['B'] = { 'switch': 20, 'mode': 21, 'brightness': 22, 'colourtemp': 23, 'colour': 24, 'scene': 25, 'scene_data': 25, # Type B prefixes scene data with idx 'timer': 26, 'music': 28, 'value_min': 10, 'value_max': 1000, 'value_hexformat': 'hsv16', } DEFAULT_DPSET['C'] = { 'switch': 1, 'mode': None, 'brightness': 2, 'colourtemp': 3, 'colour': None, 'scene': None, 'scene_data': None, 'timer': None, 'music': None, 'value_min': 25, 'value_max': 255, 'value_hexformat': 'rgb8', } DEFAULT_DPSET['None'] = { 'switch': 1, 'mode': None, 'brightness': None, 'colourtemp': None, 'colour': None, 'scene': None, 'scene_data': None, 'timer': None, 'music': None, 'value_min': 0, 'value_max': 255, 'value_hexformat': 'rgb8', } # These attributes are obsolete and only kept for backwards compatibility DPS_INDEX_SETS = [20, 1] # starts at either DP 20 (Type B) or 1 (all others) DPS_INDEX_ON = {"A": "1", "B": "20", "C": "1"} DPS_INDEX_MODE = {"A": "2", "B": "21", "C": "1"} DPS_INDEX_BRIGHTNESS = {"A": "3", "B": "22", "C": "2"} DPS_INDEX_COLOURTEMP = {"A": "4", "B": "23", "C": None} DPS_INDEX_COLOUR = {"A": "5", "B": "24", "C": None} DPS_INDEX_SCENE = {"A": "2", "B": "25", "C": None} DPS_INDEX_TIMER = {"A": None, "B": "26", "C": None} DPS_INDEX_MUSIC = {"A": None, "B": "27", "C": None} DPS = "dps" def __init__(self, *args, **kwargs): # Set Default Bulb Types self.bulb_configured = False self.bulb_type = None self.has_brightness = None self.has_colourtemp = None self.has_colour = None self.tried_status = False self.dpset = { 'switch': None, 'mode': None, 'brightness': None, 'colourtemp': None, 'colour': None, 'scene': None, 'scene_data': None, 'timer': None, 'music': None, 'value_min': -1, 'value_max': -1, 'value_hexformat': 'hsv16', } # set the default version to None so we do not immediately connect and call status() if 'version' not in kwargs or not kwargs['version']: kwargs['version'] = None super(BulbDevice, self).__init__(*args, **kwargs) def status(self, nowait=False): result = super(BulbDevice, self).status(nowait=nowait) self.tried_status = True if result and (not self.bulb_configured) and ('dps' in result): self.detect_bulb(result, nowait=nowait) return result @staticmethod def rgb_to_hexvalue(r, g, b, hexformat): """ Convert an RGB value to the hex representation expected by Tuya Bulb. While r, g and b are just hexadecimal values of the corresponding Red, Green and Blue values, the h, s and v values (which are values between 0 and 1) are scaled: hexformat="rgb8": 360 (h) and 255 (s and v) hexformat="hsv16": 360 (h) and 1000 (s and v) Args: r(int): Value for the colour red as int from 0-255. g(int): Value for the colour green as int from 0-255. b(int): Value for the colour blue as int from 0-255. hexformat(str): Selects the return format "rgb8": rrggbb0hhhssvv "hsv16": hhhhssssvvvv """ err = '' if not 0 <= r <= 255.0: err += '/red' if not 0 <= g <= 255.0: err += '/green' if not 0 <= b <= 255.0: err += '/blue' if err: raise ValueError('rgb_to_hexvalue: The value for %s needs to be between 0 and 255.' % err[1:]) hsv = colorsys.rgb_to_hsv(r / 255.0, g / 255.0, b / 255.0) if hexformat == 'rgb8': # r:0-255,g:0-255,b:0-255|rgb| hexvalue = '%02x%02x%02x' % (r, g, b) # h:0-360,s:0-255,v:0-255|hsv| hexvalue += '%04x%02x%02x' % (int(hsv[0] * 360), int(hsv[1] * 255), int(hsv[2] * 255)) elif hexformat == 'hsv16': # h:0-360,s:0-1000,v:0-1000|hsv| hexvalue = '%04x%04x%04x' % (int(hsv[0] * 360), int(hsv[1] * 1000), int(hsv[2] * 1000)) else: raise ValueError('rgb_to_hexvalue: hexformat must be either "rgb8" or "hsv16"') return hexvalue # Deprecated. Kept for backwards compatibility @staticmethod def _rgb_to_hexvalue(r, g, b, bulb="A"): if bulb == "A": hexformat = 'rgb8' elif bulb == "B": hexformat = 'hsv16' else: # Unsupported bulb type raise ValueError("Unsupported bulb type %r - unable to determine hexvalue." % bulb) return BulbDevice.rgb_to_hexvalue(r, g, b, hexformat) @staticmethod def hsv_to_hexvalue(h, s, v, hexformat): """ Convert an HSV value to the hex representation expected by Tuya Bulb. Args: h(float): colour Hue as float from 0-1 s(float): colour Saturation as float from 0-1 v(float): colour Value as float from 0-1 hexformat(str): Selects the return format "rgb8": rrggbb0hhhssvv "hsv16": hhhhssssvvvv """ err = '' if not 0 <= h <= 1.0: err += '/Hue' if not 0 <= s <= 1.0: err += '/Saturation' if not 0 <= v <= 1.0: err += '/Value' if err: raise ValueError( 'hsv_to_hexvalue: The value for %s needs to be between 0 and 1.' % err[1:]) if hexformat == 'rgb8': (r, g, b) = colorsys.hsv_to_rgb(h, s, v) return BulbDevice.rgb_to_hexvalue( r * 255.0, g * 255.0, b * 255.0, hexformat ) elif hexformat == 'hsv16': # h:0-360,s:0-1000,v:0-1000|hsv| hexvalue = '%04x%04x%04x' % (int(h * 360), int(s * 1000), int(v * 1000)) return hexvalue else: raise ValueError('hsv_to_hexvalue: hexformat must be either "rgb8" or "hsv16"') @staticmethod def hexvalue_to_rgb(hexvalue, hexformat=None): """ Converts the hexvalue used by Tuya for colour representation into an RGB value. Args: hexvalue(string): The hex representation generated by BulbDevice.rgb_to_hexvalue() hexformat(str or None): "rgb8": The hex is in rrggbb0hhhssvv format "hsv16": The hex is in hhhhssssvvvv format None: Try to auto-detect the format """ hexvalue_len = len(hexvalue) if not hexformat: if hexvalue_len == 6 or hexvalue_len == 14: hexformat = 'rgb8' elif hexvalue_len == 12: hexformat = 'hsv16' else: # Unsupported bulb type raise ValueError("Unable to detect hexvalue format. Value string must have 6, 12 or 14 hex digits.") if hexformat == 'rgb8': if hexvalue_len < 6: raise ValueError("RGB value string must have 6 or 14 hex digits.") r = int(hexvalue[0:2], 16) g = int(hexvalue[2:4], 16) b = int(hexvalue[4:6], 16) elif hexformat == 'hsv16': # hexvalue is in hsv if hexvalue_len < 12: raise ValueError("HSV value string must have 12 hex digits.") h = float(int(hexvalue[0:4], 16) / 360.0) s = float(int(hexvalue[4:8], 16) / 1000.0) v = float(int(hexvalue[8:12], 16) / 1000.0) rgb = colorsys.hsv_to_rgb(h, s, v) r = int(rgb[0] * 255) g = int(rgb[1] * 255) b = int(rgb[2] * 255) else: raise ValueError('hexvalue_to_rgb: hexformat must be None, "rgb8" or "hsv16"') return (r, g, b) # Deprecated. Kept for backwards compatibility @staticmethod def _hexvalue_to_rgb(hexvalue, bulb="A"): if bulb == "A": hexformat = 'rgb8' elif bulb == "B": hexformat = 'hsv16' else: # Unsupported bulb type, attempt to auto-detect format hexformat = None return BulbDevice.hexvalue_to_rgb(hexvalue, hexformat) @staticmethod def hexvalue_to_hsv(hexvalue, hexformat=None): """ Converts the hexvalue used by Tuya for colour representation into an HSV value. Args: hexvalue(string): The hex representation generated by BulbDevice.rgb_to_hexvalue() hexformat(str or None): "rgb8": The hex is in rrggbb0hhhssvv format "hsv16": The hex is in hhhhssssvvvv format None: Try to auto-detect the format """ hexvalue_len = len(hexvalue) if not hexformat: if hexvalue_len == 6 or hexvalue_len == 14: hexformat = 'rgb8' elif hexvalue_len == 12: hexformat = 'hsv16' else: # Unsupported bulb type raise ValueError("Unable to detetect hexvalue format. Value string must have 6, 12 or 14 hex digits.") if hexformat == 'rgb8': if hexvalue_len < 6: raise ValueError("RGB[HSV] value string must have 6 or 14 hex digits.") if hexvalue_len < 14: # hexvalue is in rgb rgb = BulbDevice.hexvalue_to_rgb(hexvalue, 'rgb8') h, s, v = colorsys.rgb_to_hsv(rgb[0] / 255.0, rgb[1] / 255.0, rgb[2] / 255.0) else: # hexvalue is in rgb+hsv h = int(hexvalue[7:10], 16) / 360.0 s = int(hexvalue[10:12], 16) / 255.0 v = int(hexvalue[12:14], 16) / 255.0 elif hexformat == 'hsv16': # hexvalue is in hsv if hexvalue_len < 12: raise ValueError("HSV value string must have 12 hex digits.") h = int(hexvalue[0:4], 16) / 360.0 s = int(hexvalue[4:8], 16) / 1000.0 v = int(hexvalue[8:12], 16) / 1000.0 else: raise ValueError('hexvalue_to_hsv: hexformat must be None, "rgb8" or "hsv16"') return (h, s, v) # Deprecated. Kept for backwards compatibility @staticmethod def _hexvalue_to_hsv(hexvalue, bulb="A"): if bulb == "A": hexformat = 'rgb8' elif bulb == "B": hexformat = 'hsv16' else: # Unsupported bulb type, attempt to auto-detect format hexformat = None return BulbDevice.hexvalue_to_hsv(hexvalue, hexformat) def _set_values_check( self, check_values, nowait=False ): dps_values = {} # check to see which DPs need to be set state = self.cached_status(nowait=nowait) if state and 'dps' in state and state['dps']: # last state is cached, so check to see if 'mode' needs to be set for k in check_values: dp = self.dpset[k] if dp and ((dp not in state['dps']) or (state['dps'][dp] != check_values[k])): dps_values[dp] = check_values[k] elif not dp: log.debug('Device does not support capability, skipping: %r:%r', k, check_values[k]) if dps_values: log.debug('Only sending changed DPs: %r', dps_values) else: # last state not cached or everything already set, so send them all for k in check_values: if self.dpset[k]: dps_values[self.dpset[k]] = check_values[k] else: log.debug('Device does not support capability, skipping: %r:%r', k, check_values[k]) log.debug('No DPs have changed, sending full update to refresh: %r', dps_values) return self.set_multiple_values( dps_values, nowait=nowait ) def turn_onoff(self, on, switch=0, nowait=False): """Turn the device on or off""" if not switch: if not self.tried_status: self.detect_bulb( nowait=nowait ) # some people may use BulbDevice as the default even for non-bulb # devices, so default to '1' if we can't detect it switch = self.dpset['switch'] if self.dpset['switch'] else 1 return self.set_status(on, switch, nowait=nowait) def turn_on(self, switch=0, nowait=False): """Turn the device on""" return self.turn_onoff( True, switch=switch, nowait=nowait ) def turn_off(self, switch=0, nowait=False): """Turn the device off""" return self.turn_onoff( False, switch=switch, nowait=nowait ) def set_mode(self, mode="white", nowait=False): """ Set bulb mode Args: mode(string): white,colour,scene,music nowait(bool): True to send without waiting for response. """ if not self.bulb_has_capability( 'mode', nowait=nowait ): return error_json(ERR_FUNCTION, 'Bulb does not support mode setting.') check_values = { 'mode': mode, 'switch': True, } return self._set_values_check( check_values, nowait=nowait ) def set_scene(self, scene, scene_data=None, nowait=False): """ Set to scene mode Args: scene(int): Value for the scene as int from 1-4 (Type A bulbs) or 1-N (Type B bulbs). nowait(bool): True to send without waiting for response. """ if not self.bulb_has_capability( 'scene', nowait=nowait ): return error_json(ERR_FUNCTION, 'set_scene: Bulb does not support scenes.') # Type A, scene idx is part of the mode if (not self.dpset['scene_data']) or (self.dpset['scene_data'] == self.dpset['mode']): if (not 1 <= scene <= 4): raise ValueError('set_scene: The value for scene needs to be between 1 and 4.') dps_values = { self.dpset['mode']: self.DPS_MODE_SCENE + '_' + str(scene) } else: scene = '%02x' % int(scene) dps_values = { 'scene': scene, 'mode': self.DPS_MODE_SCENE, } if scene_data: if (self.dpset['scene_data'] is True) or (self.dpset['scene_data'] == self.dpset['scene']): dps_values['scene'] += scene_data else: dps_values['scene_data'] = scene_data return self._set_values_check( dps_values, nowait=nowait ) def set_timer(self, num_secs, dps_id=0, nowait=False): """ Set the timer Args: num_secs: data to send to bulb dps_id: do not use, kept for compatibility with Device.set_timer() """ if dps_id: return self.set_value(dps_id, num_secs, nowait=nowait) if not self.bulb_has_capability( 'timer', nowait=nowait ): return error_json(ERR_FUNCTION, 'set_timer: Bulb does not support timer.') return self.set_value(self.dpset['timer'], num_secs, nowait=nowait) def set_music_colour( self, transition, red, green, blue, brightness=None, colourtemp=None, nowait=False ): """ Set a colour while in music mode Args: red(float): red value, 0.0 - 255.0 green(float): green value, 0.0 - 255.0 blue(float): blue value, 0.0 - 255.0 brightness(float): optional white light brightness colourtemp(float): optional white light colourtemp transition(int): optional transition. will use transition provided in set_musicmode() if not provided """ if not self.bulb_has_capability( 'music', nowait=nowait ): return error_json(ERR_FUNCTION, "set_music_colour: Device does not support music mode.") colour = '%x' % transition colour += self.rgb_to_hexvalue( red, green, blue, self.dpset['value_hexformat'] ) if (not brightness) or (brightness < 0): brightness = 0 brightness = int(self.dpset['value_max'] * brightness // 100) if (not colourtemp) or (colourtemp < 0): colourtemp = 0 colourtemp = int(self.dpset['value_max'] * colourtemp // 100) fmt = '%02x' if self.dpset['value_hexformat'] == 'rgb8' else '%04x' colour += fmt % brightness colour += fmt % colourtemp return self.set_value(self.dpset['music'], colour, nowait=nowait) def set_colour(self, r, g, b, nowait=False): """ Set colour of an rgb bulb. Args: r(float): Value for the colour Red from 0.0-255.0. g(float): Value for the colour Green from 0.0-255.0. b(float): Value for the colour Blue from 0.0-255.0. nowait(bool): True to send without waiting for response. """ if not self.bulb_has_capability( 'colour', nowait=nowait ): return error_json(ERR_FUNCTION, "set_colour: Device does not support color.") check_values = { 'colour': self.rgb_to_hexvalue(r, g, b, self.dpset['value_hexformat']), 'mode': self.DPS_MODE_COLOUR, 'switch': True } return self._set_values_check( check_values, nowait=nowait ) def set_hsv(self, h, s, v, nowait=False): """ Set colour of an rgb bulb using h, s, v. Args: h(float): colour Hue as float from 0-1 s(float): colour Saturation as float from 0-1 v(float): colour Value as float from 0-1 nowait(bool): True to send without waiting for response. """ if not self.bulb_has_capability( 'colour', nowait=nowait ): return error_json(ERR_FUNCTION, "set_colour: Device does not support color.") check_values = { 'colour': self.hsv_to_hexvalue( h, s, v, self.dpset['value_hexformat'] ), 'mode': self.DPS_MODE_COLOUR, 'switch': True } return self._set_values_check( check_values, nowait=nowait ) def set_white_percentage(self, brightness=100, colourtemp=0, nowait=False): """ Set white coloured theme of an rgb bulb. Args: brightness(int): Value for the brightness in percent (0-100) colourtemp(int): Value for the colour temperature in percent (0-100) nowait(bool): True to send without waiting for response. Note: unlike set_colourtemp(), the colour temp will be silently ignored if the bulb does not support it """ err = '' if not 0 <= brightness <= 100: err += '/Brightness' if not 0 <= colourtemp <= 100: err += '/Colourtemp' if err: raise ValueError( 'set_white_percentage: %s percentage needs to be between 0 and 100.' % err[1:]) b = int(self.dpset['value_max'] * brightness // 100) c = int(self.dpset['value_max'] * colourtemp // 100) return self.set_white( b, c, nowait=nowait ) # Deprecated. Please use set_white_percentage() instead. def set_white(self, brightness=-1, colourtemp=-1, nowait=False): """ DEPRECATED Set white coloured theme of an rgb bulb. Args: brightness(int): Value for the brightness (A:25-255 or B:10-1000) colourtemp(int): Value for the colour temperature (A:0-255, B:0-1000). nowait(bool): True to send without waiting for response. Default: Max Brightness and Min Colourtemp Note: unlike set_colourtemp(), the colour temp will be silently ignored if the bulb does not support it """ if not self.bulb_has_capability( 'brightness', nowait=nowait ): return error_json(ERR_FUNCTION, 'set_white: Device does not support brightness.') # Brightness (default: Max) brightness = int(brightness) if brightness < 0: brightness = self.dpset['value_max'] elif brightness > self.dpset['value_max']: raise ValueError('set_white: The brightness needs to be between %d and %d.' % (self.dpset['value_min'], self.dpset['value_max'])) # Colourtemp (default: Min) # It will be silently ignored if the bulb does not support it if colourtemp is not None: colourtemp = int(colourtemp) if colourtemp < 0: colourtemp = 0 if colourtemp > self.dpset['value_max']: raise ValueError('set_white: The colour temperature needs to be between 0 and %d.' % self.dpset['value_max']) # do this the hard way as brightness=0 means we should turn off, but if colourtemp is set then # turn_on() should turn it on at that colourtemp check_values = {} if brightness >= self.dpset['value_min']: check_values['brightness'] = brightness if colourtemp is not None: check_values['colourtemp'] = colourtemp if check_values: # we're setting brightness and/or colourtemp check_values['mode'] = self.DPS_MODE_WHITE check_values['switch'] = bool(brightness >= self.dpset['value_min']) # _set_values_check() will skip colourtemp if the bulb does not have it return self._set_values_check( check_values, nowait=nowait ) def set_brightness_percentage(self, brightness=100, nowait=False): """ Set the brightness value of an rgb bulb. Args: brightness(int): Value for the brightness in percent (0-100) nowait(bool): True to send without waiting for response. """ if not 0 <= brightness <= 100: raise ValueError('set_brightness_percentage: The brightness needs to be between 0 and 100.') b = int(self.dpset['value_max'] * brightness // 100) return self.set_brightness(b, nowait=nowait) # Deprecated. Please use set_brightness_percentage() instead. def set_brightness(self, brightness, nowait=False): """ DEPRECATED Set the brightness value of an rgb bulb. Args: brightness(int): Value for the brightness (25-255). nowait(bool): True to send without waiting for response. """ if not self.bulb_has_capability( 'brightness', nowait=nowait ): return error_json(ERR_FUNCTION, 'set_brightness: Device does not support brightness.') # Brightness (default Max) if brightness < 0: brightness = self.dpset['value_max'] elif brightness < self.dpset['value_min']: return self.turn_off(0, nowait=nowait) elif brightness > self.dpset['value_max']: raise ValueError('set_brightness: The brightness needs to be between %d and %d.' % (self.dpset['value_min'], self.dpset['value_max'])) # Determine which mode bulb is in and adjust accordingly state = self.state(nowait=nowait) if ('Error' in state) or ('mode' not in state): return state if state['mode'] != self.DPS_MODE_COLOUR: # use white mode, changing to it if needed return self.set_white(brightness=brightness, colourtemp=None, nowait=nowait) else: # for colour mode use hsv to increase brightness value = brightness / float(self.dpset['value_max']) (h, s, v) = self.colour_hsv(state=state, nowait=nowait) return self.set_hsv(h, s, value, nowait=nowait) def set_colourtemp_percentage(self, colourtemp=100, nowait=False): """ Set the colour temperature of an rgb bulb. Args: colourtemp(int): Value for the colour temperature in percentage (0-100). nowait(bool): True to send without waiting for response. """ if not 0 <= colourtemp <= 100: raise ValueError( 'set_colourtemp_percentage: Colourtemp percentage needs to be between 0 and 100.') c = int(self.dpset['value_max'] * colourtemp // 100) return self.set_colourtemp( c, nowait=nowait ) # Deprecated. Please use set_white_percentage() instead. def set_colourtemp(self, colourtemp, nowait=False): """ DEPRECATED Set the colour temperature of an rgb bulb. Args: colourtemp(int): Value for the colour temperature (0-255). nowait(bool): True to send without waiting for response. """ if not self.bulb_has_capability( self.BULB_FEATURE_COLOURTEMP, nowait=nowait ): return error_json(ERR_FUNCTION, 'set_colourtemp: Device does not support colourtemp.') if not 0 <= colourtemp <= self.dpset['value_max']: raise ValueError('set_colourtemp: The colour temperature needs to be between 0 and %d.' % self.dpset['value_max']) check_values = { 'colourtemp': colourtemp, 'mode': self.DPS_MODE_WHITE, 'switch': True, } return self._set_values_check( check_values, nowait=nowait ) def get_value(self, feature, state=None, nowait=False): if not state: state = self.state(nowait=nowait) if 'Error' in state: raise RuntimeError('Error getting device current state.') if feature not in state: raise ValueError("Unknown parameter %r." % feature) return state[feature] def get_mode(self, state=None, nowait=False): """Return current working mode""" return self.get_value('mode', state=state, nowait=nowait) def white_percentage(self, state=None, nowait=False): if not state: state = self.state(nowait=nowait) return (self.brightness_percentage(state=state, nowait=nowait), self.colourtemp_percentage(state=state, nowait=nowait)) #def white(self, state=None, nowait=False): # pass def get_brightness_percentage(self, state=None, nowait=False): if (not self.dpset['value_max']) or (self.dpset['value_max'] < 1): raise RuntimeError("Bulb capabilitiy 'value_max' not set, unable to calculate percentage.") return self.brightness(state=state, nowait=nowait) / self.dpset['value_max'] * 100.0 def brightness(self, state=None, nowait=False): """Return brightness value""" return self.get_value('brightness', state=state, nowait=nowait) def get_colourtemp_percentage(self, state=None, nowait=False): if (not self.dpset['value_max']) or (self.dpset['value_max'] < 1): raise RuntimeError("Bulb capabilitiy 'value_max' not set, unable to calculate percentage.") return self.colourtemp(state=state, nowait=nowait) / self.dpset['value_max'] * 100.0 def colourtemp(self, state=None, nowait=False): """Return colour temperature""" return self.get_value('colourtemp', state=state, nowait=nowait) def colour_rgb(self, state=None, nowait=False): """Return colour as RGB value""" hexvalue = self.get_value('colour', state=state, nowait=nowait) if isinstance( hexvalue, dict ): return hexvalue # Error return BulbDevice.hexvalue_to_rgb(hexvalue, self.dpset['value_hexformat']) def colour_hsv(self, state=None, nowait=False): """Return colour as HSV value""" hexvalue = self.get_value('colour', state=state, nowait=nowait) if isinstance( hexvalue, dict ): return hexvalue # Error return BulbDevice.hexvalue_to_hsv(hexvalue, self.dpset['value_hexformat']) def state(self, nowait=False): """Return state of Bulb""" if not self.bulb_configured: self.detect_bulb(nowait=nowait) if not self.bulb_configured: raise RuntimeError('Bulb not configured, cannot get device current state.') status = self.cached_status(nowait=nowait) state = {} if not status: return error_json(ERR_JSON, "state: empty response") if "Error" in status: return error_json(ERR_JSON, status["Error"]) if 'dps' not in status: return error_json(ERR_JSON, "state: no data points") for key in self.dpset: dp = self.dpset[key] if '_' in key: # skip scene_data, value_min, value_max, etc state[key] = None elif dp in status['dps']: state[key] = status['dps'][dp] else: state[key] = None if 'switch' in state: state['is_on'] = state['switch'] #print( 'state:', state ) return state def bulb_has_capability( self, feature, nowait=False ): if not self.bulb_configured: self.detect_bulb( nowait=nowait ) if not self.bulb_configured: raise RuntimeError('Bulb not configured, cannot get device capabilities.') return bool( self.dpset[feature] ) def detect_bulb(self, response=None, nowait=False): """ Attempt to determine BulbDevice Type A, B or C based on: Type A has keys 1-9 Type B has keys 20-28 Type C is basic (non-CCT) and only has 1-2 (i.e Feit type bulbs from Costco) Example status data: Sylvania BR30 [v3.3, RGB+CCT]: {'20': True, '21': 'colour', '22': 750, '23': 278, '24': '00f003e803e8', '25': '000e0d0000000000000000c803e8', '26': 0} Geeni BW229 Smart Filament Bulb [v3.3, CCT only]: {'1': True, '2': 25, '3': 0} 1: switch, 2: brightness, 3: colour temperature No-name RGB+CCT (LED BULB W5K) [v3.5, RGB+CCT]: {'20': True, '21': 'white', '22': 10, '23': 0, '24': '000003e803e8', '25': '000e0d0000000000000000c80000', '26': 0, '34': False} Feit soft white Filament [v3.5, 2700K only]: {'20': True, '21': 'white', '22': 60, '25': '000e0d0000000000000000c803e8', '26': 0, '34': False, '41': True} (No CCT (23) or colour (24), but does support scenes (25) and music mode (28)) Feit dimmer switch [v3.3, not a bulb]: {'1': True, '2': 10, '3': 10, '4': 'incandescent'} Note: after a power cycle, only DP 2 is returned! The rest are not returned until after they are set 1: switch, 2: brightness, 3: minimum dim %, 4: installed bulb type (LED/incandescent) """ if not response: response = self.cached_status(historic=True, nowait=nowait) if (not response) or ('dps' not in response): if nowait: log.debug('No cached status, but nowait set! detect_bulb() exiting without detecting bulb!') else: response = self.status() # return here as self.status() will call us again return if response and 'dps' in response and isinstance(response['dps'], dict): # Try to determine type of BulbDevice Type based on DPS indexes # 1+2 or 20+21 are required per https://developer.tuya.com/en/docs/iot/product-function-definition?id=K9tp155s4th6b # The rest are optional if '20' in response['dps'] and '1' in response['dps']: # both 1 and 20 in response, this probably isn't a bulb self.bulb_configured = True self.bulb_type = 'None' elif '20' in response['dps'] and '21' in response['dps']: self.bulb_configured = True self.bulb_type = 'B' elif '1' in response['dps'] and '2' in response['dps']: self.bulb_configured = True # if DP 2 is a string, it is the mode (Type A). If it is an int, it is the brightness (Type C) self.bulb_type = 'A' if isinstance(response['dps']['2'], str) else 'C' if self.bulb_type and self.bulb_type in self.DEFAULT_DPSET: # The 'music' DP is not returned in status(), so use the default value self.dpset['music'] = self.DEFAULT_DPSET[self.bulb_type]['music'] self.dpset['value_min'] = self.DEFAULT_DPSET[self.bulb_type]['value_min'] self.dpset['value_max'] = self.DEFAULT_DPSET[self.bulb_type]['value_max'] self.dpset['value_hexformat'] = self.DEFAULT_DPSET[self.bulb_type]['value_hexformat'] for k in self.DEFAULT_DPSET[self.bulb_type]: if k[:6] == 'value_': continue if not self.DEFAULT_DPSET[self.bulb_type][k]: continue dp = str( self.DEFAULT_DPSET[self.bulb_type][k] ) if dp in response['dps']: self.dpset[k] = dp # set has_* attributes for backwards compatibility for k in ('brightness', 'colourtemp', 'colour'): setattr( self, 'has_'+k, bool(self.dpset[k]) ) log.debug("Bulb type set to %r. has brightness: %r, has colourtemp: %r, has colour: %r", self.bulb_type, self.dpset['brightness'], self.dpset['colourtemp'], self.dpset['colour'] ) elif not self.bulb_configured: # response has no dps log.debug("No DPs in response, cannot detect bulb type!") def set_bulb_type(self, bulb_type=None, mapping=None): self.bulb_type = bulb_type self.set_bulb_capabilities(mapping) def set_bulb_capabilities(self, mapping): if self.bulb_type in self.DEFAULT_DPSET: default_dpset = self.DEFAULT_DPSET[self.bulb_type] else: default_dpset = {} if not isinstance( mapping, dict ): mapping = {} for k in self.dpset: if k in mapping: self.dpset[k] = mapping[k] elif self.dpset[k] is None: dp = default_dpset.get(k, None) self.dpset[k] = str(dp) if (dp and k[:6] != 'value_') else dp if self.dpset['switch'] and self.dpset['brightness']: self.bulb_configured = True