def rebuild_bulbs(self): found_bulb_ips = sorted(bulb['ip'] for bulb in yeelight.discover_bulbs(3) if bulb['ip'] in room_to_ips[self.name]) current_bulb_ips = sorted(bulb._ip for bulb in self.bulbs) if current_bulb_ips != found_bulb_ips: logger.info('Different bulbs!') logger.info('Found bulbs: %s', ', '.join(found_bulb_ips)) # Clear out the bulbs, since they don't like having multiple # connections to the same machine. del self.bulbs[:] if YEELIGHT_STATIC_REBUILD: logger.info('Statically rebuilding bulb list') self.bulbs = [ yeelight.Bulb(ip) for ip in room_to_ips[self.name] ] else: self.bulbs = [ yeelight.Bulb(found_ip) for found_ip in found_bulb_ips ] try: self.resetFromLoggedState() except Exception: logger.exception( 'Got exception when restting bulbs in rebuild_bulbs')
def __init__(self, ip): self.clients = [ yeelight.Bulb( ip, effect="smooth", duration=100, auto_on=False, model=yeelight.BulbType.WhiteTempMood, ), yeelight.Bulb( ip, effect="smooth", duration=100, auto_on=False, model=yeelight.BulbType.WhiteTempMood, ), yeelight.Bulb( ip, effect="smooth", duration=100, auto_on=False, model=yeelight.BulbType.WhiteTempMood, ), ] self.index = 0
def get_bulb(): def get_parameters(bulb_dict): capabilities = bulb_dict.get('capabilities') return \ bulb_dict.get('ip'), \ bulb_dict.get('port'), \ capabilities.get('model'), \ capabilities.get('name'), \ capabilities.get('power') bulbs_discovered = yeelight.discover_bulbs() log_message = 'ip = {0}, port = {1}, model = {2}, name = {3}, power = {4}' if len(bulbs_discovered) == 1: ip, port, model, name, power = get_parameters(bulbs_discovered.pop()) logging.info('One bulb found, proceeding: ' + log_message.format(ip, port, model, name, power)) return yeelight.Bulb(ip) elif len(bulbs_discovered) == 0: raise Exception( 'No bulbs found nearby. ' 'Make sure you\'re running the script using the same local network your bulb connected to.' ) else: # more than one bulb found bulbs_found_msg = '' for index, bulb in enumerate(bulbs_discovered): ip, port, model, name, power = get_parameters(bulb) bulbs_found_msg += f'\t#{index}:\t\t{log_message.format(ip, port, model, name, power)}\n' logging.info(f'More than one bulb found:\n {bulbs_found_msg}') while True: try: chosen_index = int( input('Please input the # of the bulb you want to use ' f'(0-{len(bulbs_discovered) - 1}): ')) except ValueError: logging.error('Input must be an integer!\n') continue if chosen_index in range(len(bulbs_discovered)): ip, port, model, name, power = get_parameters( bulbs_discovered[chosen_index]) logging.info('Proceeding: ' + log_message.format(ip, port, model, name, power)) return yeelight.Bulb(ip) else: logging.error( f'The bulb # should be in range [0-{len(bulbs_discovered) - 1}]\n' )
def main(): global bulb, alarm cparse = argparse.ArgumentParser( prog = 'yeelight-alarm-clock', description = 'Turn on yeelight at certain time, like an alarm clock') cparse.add_argument('time', help = 'time to turn on the clock', type = parse_time) cargs = cparse.parse_args() alarm = get_next_time(cargs.time) bulb = yeelight.Bulb(ip) bulb.turn_on() #print(bulb.get_properties()) bulb.start_flow(blink_flow) time.sleep(5) # Bulb will reconnect on next command, we do not want to maintain the socket the whole night disconnect_bulb(bulb) wait_until(alarm) print('Alarm on') try: d = 5 bulb.effect = 'sudden' bulb.turn_on() bulb.start_flow(alarm_flow) while True: time.sleep(100) except KeyboardInterrupt: bulb.turn_off() print('Alarm off')
def build_bulb(bulb, yee_effect): port = 55443 if 'port' in bulb: port = bulb['port'] effect = 'sudden' if 'effect' in yee_effect: effect = yee_effect['effect'] elif 'effect' in bulb: effect = bulb['effect'] duration = 500 if 'duration' in yee_effect: duration = yee_effect['duration'] elif 'duration' in bulb: duration = bulb['duration'] auto_on = True if 'auto_on' in yee_effect: auto_on = yee_effect['auto_on'] elif 'auto_on' in bulb: auto_on = bulb['auto_on'] return yeelight.Bulb( ip=bulb['ip'], port=port, effect=effect, duration=duration, auto_on=auto_on, )
async def _async_try_connect(self, host): """Set up with options.""" for entry in self._async_current_entries(): if entry.data.get(CONF_HOST) == host: raise AlreadyConfigured bulb = yeelight.Bulb(host) try: capabilities = await self.hass.async_add_executor_job( bulb.get_capabilities) if capabilities is None: # timeout _LOGGER.debug("Failed to get capabilities from %s: timeout", host) else: _LOGGER.debug("Get capabilities: %s", capabilities) await self.async_set_unique_id(capabilities["id"]) self._abort_if_unique_id_configured() return except OSError as err: _LOGGER.debug("Failed to get capabilities from %s: %s", host, err) # Ignore the error since get_capabilities uses UDP discovery packet # which does not work in all network environments # Fallback to get properties try: await self.hass.async_add_executor_job(bulb.get_properties) except yeelight.BulbException as err: _LOGGER.error("Failed to get properties from %s: %s", host, err) raise CannotConnect from err _LOGGER.debug("Get properties: %s", bulb.last_properties)
def add_device(name, ip): sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.settimeout(1) try: response = sock.connect_ex((ip, 55443)) if response == 0: bulb = yeelight.Bulb(ip, duration=500) bulb_info = bulb.get_capabilities() if len(name) == 0: if len(bulb_info['name']) != 0: name = bulb_info['name'] else: name = bulb_info['model'] bulb.set_name(name) cursor.execute( '''INSERT INTO lights ( id, ip, name, model ) VALUES ( ?, ?, ?, ? )''', (int(bulb_info['id'][2:], 16), ip, name, bulb_info['model'])) db.commit() print(int(bulb_info['id'][2:], 16), ip, name, bulb_info['model']) return True except Exception as e: print(e) return False
def __init__(self, settings, not_used): self.setting = settings self._find_lamp_ip() self._try_connect() self.lamp_bulb = yeelight.Bulb(self.setting["lamp_ip"], auto_on=True) self.proterius = None super().__init__(settings, not_used)
def cli(ip, port, effect, duration, bulb, auto_on): """ yeecli is a command-line utility for controlling the YeeLight RGB LED lightbulb. """ config = ConfigParser.SafeConfigParser() config.read([os.path.expanduser('~/.config/yeecli/yeecli.cfg')]) ip = param_or_config(ip, config, bulb, "ip", None) port = param_or_config(port, config, bulb, "port", 55443) effect = param_or_config(effect, config, bulb, "effect", "sudden") duration = param_or_config(duration, config, bulb, "duration", 500) if not ip: click.echo("No IP address specified.") sys.exit(1) BULBS.append( yeelight.Bulb( ip=ip, port=port, effect=effect, duration=duration, auto_on=auto_on, ))
async def _async_try_connect(self, host): """Set up with options.""" self._async_abort_entries_match({CONF_HOST: host}) bulb = yeelight.Bulb(host) try: capabilities = await self.hass.async_add_executor_job( bulb.get_capabilities) if capabilities is None: # timeout _LOGGER.debug("Failed to get capabilities from %s: timeout", host) else: _LOGGER.debug("Get capabilities: %s", capabilities) await self.async_set_unique_id(capabilities["id"]) return capabilities["model"] except OSError as err: _LOGGER.debug("Failed to get capabilities from %s: %s", host, err) # Ignore the error since get_capabilities uses UDP discovery packet # which does not work in all network environments # Fallback to get properties try: await self.hass.async_add_executor_job(bulb.get_properties) except yeelight.BulbException as err: _LOGGER.error("Failed to get properties from %s: %s", host, err) raise CannotConnect from err _LOGGER.debug("Get properties: %s", bulb.last_properties) return MODEL_UNKNOWN
def __init__(self, group_name, names, loadfile=None): self.group_name = group_name self.names = names # store in case you want to reconnect or something idk self.loadfile = loadfile self.bulbs = [] bulb_dicts = yl.discover_bulbs() for bulb_dict in bulb_dicts: if bulb_dict['capabilities']['name'] in names: self.bulbs.append(Bulb(yl.Bulb(bulb_dict['ip']))) self.prev_t = time.time() if loadfile: self.load_state() else: self.loadfile = group_name + '_latest.txt' self.turn_on() self.on = True self.h = 0 self.s = 0 self.brightness = 100 self.degrees = 3800 self.r = 255 self.g = 255 self.b = 255 self.set_mode(yl.PowerMode.NORMAL)
def __init__(self, parent=None): super(TabletSampleWindow, self).__init__(parent) self.MAX_CLICK = 10. self.MOVE_CHUNK = 40 self.BRIGHT_INC = 5 self.CT_INC = 250 self.MAX_PRESSURE = 50 self.text = "" self.pen_pressure = 0 self.max_pressure = 0 self.mode = None self.moved = False # Resizing the sample window to full desktop size: frame_rect = app.desktop().frameGeometry() width, height = frame_rect.width(), frame_rect.height() self.resize(width, height) self.move(-9, 0) self.setWindowTitle("Yeelight Control Center") self.width = width self.height = height # discover all light bulbs and setup first one bulbs = yeelight.discover_bulbs() if len(bulbs) == 0: print("No Yeelight Bulbs discovered! exiting...") sys.exit(0) self.bulb = yeelight.Bulb(ip=bulbs[0]['ip']) print(f"Connected to bulb on ip {bulbs[0]['ip']}") self.specs = self.bulb.get_model_specs() self.min_ct = self.specs['color_temp']['min'] self.max_ct = self.specs['color_temp']['max'] self.sync_bulb() schedule.every(5).minutes.do(self.sync_bulb)
def toggle(ip): bulb = yeelight.Bulb(ip, duration=TRANSITION_DURATION) bulb.toggle() try: state = bulb.get_capabilities()['power'] except: state = 'Offline' return state
def connect(light): ip = light.protocol_cfg["ip"] if ip in Connections: c = Connections[ip] else: c = yeelight.Bulb(ip) Connections[ip] = c return c
def __init__(self, mqtt, device): self.bulb = yeelight.Bulb(device["ip"], effect='smooth', duration=device["duration"], power_mode=yeelight.PowerMode.LAST) self.mqtt = mqtt self.topic = device["topic"] self.report = config["types"][device["type"]]["report"] self.actions = config["types"][device["type"]]["actions"]
def discover_lights(): global lights_available while len(lights_available) == 0: lights_available = dict() for light in yeelight.discover_bulbs(): prefix = light["capabilities"]["name"] + '-' name = (prefix if prefix != '-' else '') + light["ip"] lights_available[name] = yeelight.Bulb( light["ip"], effect=config.lightingMode.lightTransitions) return lights_available
def toggle(systray): var = y.discover_bulbs() if len(var) < 1: var = "192.168.1.3" else: var = var[0]["ip"] bulb = y.Bulb(var) bulb.toggle()
def __init__(self, ip, new_light=True, **kwargs): global lights super().__init__(**kwargs) self.ip = ip self.light = len(lights) lights.append(yeelight.Bulb(self.ip)) lights[self.light].auto_on = True if new_light: light_data.append({"ip": self.ip, "name": self.name}) with open(__file__[:-11] + "lights.json", "w") as f: json.dump(light_data, f)
def get_bulbs(timeout=0.2): 'Get a list of bulbs that are reachable' # TODO return BULBS bulbs = [ yeelight.Bulb(blb['ip']) for blb in yeelight.discover_bulbs(timeout) if blb['ip'] in BULB_IPS ] if len(bulbs) != len(BULB_IPS): logger.info('Found %d bulbs, expected %d', len(bulbs), len(BULB_IPS)) return bulbs
def assert_connect_bulbs(): infos = yeelight.discover_bulbs() bulbs = [] for info in infos: bulbs.append(yeelight.Bulb(info['ip'])) if(len(bulbs) == 0): raise yeelight.BulbException(ERROR_STR) return bulbs
def do_set_hsv(address, hue, saturation, value, lighttype): try: bulb = yeelight.Bulb(address) if value and lighttype: bulb.set_hsv(hue, saturation, value, lighttype) elif value: bulb.set_hsv(hue, saturation, value) elif lighttype: bulb.set_hsv(hue, saturation, None, lighttype) else: bulb.set_hsv(hue, saturation) except Exception as e: log.error(e)
def _bulb(self) -> 'yeelight.Bulb': import yeelight if self._bulb_device is None: try: self._bulb_device = yeelight.Bulb(self._ipaddr) self._bulb_device.get_properties() # force init for type self._available = True except yeelight.BulbException as ex: self._available = False _LOGGER.error("Failed to connect to bulb %s, %s: %s", self._ipaddr, self._name, ex) return self._bulb_device
def getBulb(): global bulb_connected if (len(yee.discover_bulbs())): for bulb_meta in yee.discover_bulbs(): if bulb_meta['capabilities']['id'] == bulb_id: bulb_connected = True bulb = yee.Bulb(bulb_meta['ip']) bulb.set_brightness(BRIGHTNESS) return bulb else: bulb_connected = False print("unable to connect to bulb... Retrying!..") time.sleep(10) return getBulb()
def bulb(self): """Return bulb device.""" if self._bulb_device is None: import yeelight try: self._bulb_device = yeelight.Bulb(self._ipaddr, model=self._model) # force init for type self.update() self._available = True except yeelight.BulbException as ex: self._available = False _LOGGER.error("Failed to connect to bulb %s, %s: %s", self._ipaddr, self._name, ex) return self._bulb_device
async def _async_try_connect(self, host): """Set up with options.""" bulb = yeelight.Bulb(host) try: capabilities = await self.hass.async_add_executor_job( bulb.get_capabilities) if capabilities is None: # timeout _LOGGER.error("Failed to get capabilities from %s: timeout", host) raise CannotConnect except OSError as err: _LOGGER.error("Failed to get capabilities from %s: %s", host, err) raise CannotConnect from err _LOGGER.debug("Get capabilities: %s", capabilities) self._capabilities = capabilities await self.async_set_unique_id(capabilities["id"]) self._abort_if_unique_id_configured()
def _bulb(self) -> object: import yeelight if self._bulb_device is None: try: self._bulb_device = yeelight.Bulb(self._ipaddr) self._bulb_device.get_properties() # force init for type btype = self._bulb_device.bulb_type if btype == yeelight.BulbType.Color: self._supported_features |= SUPPORT_YEELIGHT_RGB self._available = True except yeelight.BulbException as ex: self._available = False _LOGGER.error("Failed to connect to bulb %s, %s: %s", self._ipaddr, self._name, ex) return self._bulb_device
def get_lights(): cursor.execute('''SELECT * FROM lights;''') result = cursor.fetchall() lights = [] for id, ip, name, model in result: bulb = yeelight.Bulb(ip) try: state = bulb.get_capabilities()['power'] except: state = 'Offline' lights.append({ 'id': id, 'ip': ip, 'name': name, 'model': model, 'state': state }) return lights
def control_init(): # bulb and sonos init sonos = soco.SoCo('192.168.3.159') # bulb = yeelight.Bulb(yeelight.discover_bulbs(timeout=10)[0].get('ip')) bulb = yeelight.Bulb('192.168.3.155') print(sonos) if sonos: sonos.play_mode = 'REPEAT_ONE' sonos.play_uri( 'http://img.tukuppt.com/newpreview_music/09/01/52/5c89f044e48f61497.mp3' ) sonos.volumn = 6 sonos.mute = False print(bulb) if bulb: bulb.turn_off() # bulb.set_brightness(10) return sonos, bulb
def rebuild_bulbs(): "Rebuild the bulb list." if YEELIGHT_ROOM_HANDLES_REBUILD: for room in ROOMS.values(): room.rebuild_bulbs() else: global bulbs found_bulbs_ip = sorted(bulb['ip'] for bulb in yeelight.discover_bulbs(1)) current_bulbs_ips = sorted(bulb._ip for bulb in bulbs) if current_bulbs_ips != found_bulbs_ip: new_ips = set(found_bulbs_ip) - set(current_bulbs_ips) missing_ips = set(current_bulbs_ips) - set(found_bulbs_ip) for new_ip in new_ips: logger.info('Found new bulb at ip addr: %s', new_ip) for missing_ip in missing_ips: logger.info('Missing bulb at ip addr: %s', missing_ip) bulbs = [yeelight.Bulb(found_ip) for found_ip in found_bulbs_ip] for room in ROOMS.values(): room.rebuild_bulbs()
def main(): get_saved_lights() check_ip_change() try: while True: menu() scelta = int_input(0, 4) if scelta == 1: print("Scegli quale luce vuoi controllare:") get_saved_lights() sc = int_input(0, ((len(saved_lights) - 1) / 2)) print("Ciao") ####Controllare la luce elif scelta == 2: luci = yee.discover_bulbs() if len(luci) == 0: print("Non ho trovato luci nella tua rete") else: print_lights(luci) sc = int_input(0, len(luci) - 1) add_light(luci[sc]) get_saved_lights() elif scelta == 3: del_file() print("Luci associate eliminate") get_saved_lights() elif scelta == 4: for light in saved_lights: luce = yee.Bulb(light["ip"]) luce.toggle() print("Toggle di {}".format(light["name"])) elif scelta == 0: raise KeyboardInterrupt else: print("La scelta corrispondente non esiste") except KeyboardInterrupt: print("\n\nHai terminato il programma.") exit()