class HueCommand: def __init__(self, duration, states): self.b = Bridge('********') self.duration = duration self.states = states def get_states(self, ids): lights = [] for light_id in ids: is_on = self.b.get_light(light_id, 'on') bri = self.b.get_light(light_id, 'bri') hue = self.b.get_light(light_id, 'hue') lights.append({ 'id': light_id, 'on': is_on, 'hue': hue, 'bri': bri }) return lights def execute(self): # set hue bulbs self.b.connect() # Get a dictionary with the light ids as the key # lights = self.b.get_light_objects('id') for state in self.states: try: self.b.set_light(state.id, state.cmd) except Exception as e: print e.message continue time.sleep(self.duration)
def config_lights(ip): print('Retrieving lights...') bridge = Bridge(ip) lights = [] for light in bridge.lights: try: bridge.get_light(light.name, 'colormode') except KeyError: pass else: lights.append(light.name) try: title = 'Please use the spacebar to select at least one light from the choices below: ' selectedLights = pick(lights, title, multi_select=True, min_selection_count=1, indicator='->') except: print( 'Sorry, setup was unable to find any color capable hue lights connected to your bridge.' ) return else: goal_lights = {} goal_lights['Lights'] = [] for light in selectedLights: goal_lights['Lights'].append(light[0]) return goal_lights
def get_status(self, log, device_id, address, bridge_ip): while not self._stop.isSet(): data = {} try: b = Bridge( ip=bridge_ip, config_file_path= "/var/lib/domogik/domogik_packages/plugin_hue/data/bridge.config" ) b.connect() status = b.get_light(address, 'on') brightness = b.get_light(address, 'bri') / 254.00 * 100.00 reachable = b.get_light(address, 'reachable') self.log.info( u"==> Device '%s' state '%s', brightness '%s', reachable '%s'" % (device_id, status, brightness, reachable)) self.log.debug(u"Trying to send data sensor...") except: self.log.debug(u"Unable to get device information for id " + str(device_id)) pass data[self.sensors[device_id] ['light']] = self.from_off_on_to_DT_Switch(status) data[self.sensors[device_id]['brightness']] = brightness data[self.sensors[device_id] ['reachable']] = self.from_off_on_to_DT_Switch(reachable) try: self._pub.send_event('client.sensor', data) except: # We ignore the message if some values are not correct self.log.debug( u"Bad MQ message to send. This may happen due to some invalid rainhour data. MQ data is : {0}" .format(data)) pass time.sleep(1)
class AutoHomeHue: hue = None def __init__(self): self.hue = Bridge(ip='10.90.0.106', config_file_path="/var/lib/hue/hue.conf") def lights(self): return self.hue.lights def lights_name(self): return self.hue.get_light_objects('name') def is_locked(self, lamp): return os.path.isfile("/var/lib/hue/locks/{}".format(lamp.light_id)) def lock(self, lamp): open("/var/lib/hue/locks/{}".format(lamp.light_id), 'a').close() def unlock(self, lamp): os.remove("/var/lib/hue/locks/{}".format(lamp.light_id)) def brightness(self, lamp, value, time=100): lamp.on = True self.hue.set_light(lamp.light_id, 'bri', value, transitiontime=time) def color(self, lamp, hue=None, sat=None, xy=None): lamp.on = True if hue: lamp.hue = hue if sat: lamp.sat = sat if xy: lamp.xy = xy def time_based_white(self, light): if not self.hue.get_light(light.name, 'on'): return False if not self.hue.get_light(light.name, 'reachable'): return False hour = datetime.datetime.now().hour # Be nice, show a nice warm light # between 00:00 - 08:00 if hour < 8: hour = 24 ct = 154 + ((500-154)/24) * hour if light.light_id != 13 and light.colortemp != ct: self.hue.set_light(light.name, 'ct', ct) return True return False
def get_office_lights(): ''' Gets the current state of my office lights so I know what values to plug in to presets. ''' from phue import Bridge b = Bridge(settings.HUE_BRIDGE) b.connect() b.get_api() light_index = 9 print b.get_light(light_index, 'on') print b.get_light(light_index, 'hue') print b.get_light(light_index, 'sat')
def main(args): global b b = Bridge(args.ip) if args.id: lid = int(args.id) if args.off: set_light(lid, False) else: set_light(lid, not b.get_light(lid, 'on')) elif args.off: set_light(1, False) else: set_light(1, not b.get_light(1, 'on'))
class CommonHardwareHue(object): """ Class for interfacing with hue """ def __init__(self, ip_addr): self.hue_inst = Bridge(ip_addr, config_file_path='/mediakraken/phue/phue.config') # If the app is not registered and the button is not pressed, # press the button and call connect() (this only needs to be run a single time) self.hue_inst.connect() def com_hardware_hue_get_api(self): # Get the bridge state (This returns the full dictionary that you can explore) return self.hue_inst.get_api() def com_hardware_hue_get_lights(self): return self.com_hardware_hue_get_api()['lights'] def com_hardware_hue_light_info(self, light_num, status_type): # 'on' - wether on/off # 'name' - name of light return self.hue_inst.get_light(light_num, status_type) def com_hardware_hue_light_set(self, light_list, function_type='on', var_value=True): # You can also control multiple lamps by sending a list as lamp_id # 'on' on/off via bool # 'bri' 1-100 value for brightness self.hue_inst.set_light(light_list, function_type, var_value)
def lights_shift_ko(hermes, intent_message): # type: (Hermes, IntentMessage) -> None ip, user, no = read_configuration_file(CONFIG_FILE) bridge = Bridge(ip, user) slot_map = to_slot_map(intent_message) brightness = bridge.get_light(no, "bri") print "brightness", brightness up_down = slot_map.get("up_down")[0] print dir(up_down.slot_value.value.value) if up_down.slot_value.value.value == "up": up = True else: up = False if up: brightness = brightness + 25 if brightness > 254: brightness = 254 message += u"最大値でつけました" else: message += u"明るくしました" print bridge.set_light(no, command(bri=brightness)) else: brightness = brightness - 25 if brightness < 0: brightness = 0 message += u"消しました" else: message += u"暗くしました" print bridge.set_light(no, command(bri=brightness))
def process_request(req): result = req.get('result') if result is None: return {} parameters = result.get('parameters') if parameters is None: return {} state = parameters.get('LightState') if state is None: return {} speech = "" b = Bridge(huehost) b.connect() # b.get_api() # Should take groupname into account when deciding on which lamp to turn on # b.get_group() if state == "on" or state == "On": if not b.get_light(1, 'on'): b.set_light(1, 'on', True) b.set_light(1, 'bri', 254) speech = "Turned lamp on" else: speech = "Lamp was already on." elif state == "off" or state == "Off": if b.get_light(1, 'on'): b.set_light(1, 'on', False) speech = "Turned lamp off" else: speech = "Lamp was already off" else: speech = "I couldn't understand the lampstate: " + state return { "speech": speech, "displayText": speech, # "data": data, # "contextOut": [], "source": "apiai-hue-webhook" }
class PhueOnOffManager: def __init__(self, addr, lightname): self.b = Bridge(addr) self.b.connect() self.lightname = lightname def read(self): value = self.b.get_light(self.lightname, 'on') return str(value) def write(self, value): self.b.set_light(self.lightname, 'on', value)
class LightSkill(object): def __init__(self): self.bridge = Bridge('192.168.1.10') self.bridge.connect() self.intent = 'lightIntent' # define vocabulary self.light_keyword = [ "allume", "éteint", "baisse", "diminue", "augmente", "luminosité" ] self.room_keyword = [ "salon", "cuisine" ] # structure intent self.light_intent = IntentBuilder(self.intent)\ .require("LightKeyword")\ .require("RoomKeyword")\ .optionally("NumericValue")\ .build() def register(self, engine): for wk in self.light_keyword: engine.register_entity(wk, "LightKeyword") for wk in self.room_keyword: engine.register_entity(wk, "RoomKeyword") engine.register_regex_entity("(?P<NumericValue>\d+)") engine.register_intent_parser(self.light_intent) def process(self, json): room = json.get('RoomKeyword') if json.get('LightKeyword') == "allume": self.bridge.set_light(room, 'on', True) return "J'allume '%s'" % room if json.get('LightKeyword') == "éteint": self.bridge.set_light(room, 'on', False) return "J'éteins '%s'" % room if json.get('LightKeyword') == "baisse": bri = self.bridge.get_light(room).get('state').get('bri') self.bridge.set_light(room, 'bri', bri-20) return "J'ai diminué la lumière dans le '%s'" % room
def find_a_light(): """Finds an appropriate light and returns it.""" hue = Bridge('192.168.1.11') # If running for the first time: # press button on bridge and run with b.connect() uncommented # b.connect() lights = hue.get_light_objects('name') # reachable is supposed to be an option but isn't..? # if lights['Bedroom ceiling'].reachable: if (hue.get_light('Bedroom ceiling')['state']['reachable'] and hue.get_light('Bedroom ceiling')['state']['on']): alert_light = lights['Bedroom ceiling'] elif (hue.get_light('Bedroom bed')['state']['reachable'] and hue.get_light('Bedroom bed')['state']['on']): alert_light = lights['Bedroom bed'] elif hue.get_light('Bedroom desk')['state']['reachable']: alert_light = lights['Bedroom desk'] return alert_light
def list_lights(ip): output = "" try: b = Bridge( ip=ip, config_file_path= "/var/lib/domogik/domogik_packages/plugin_hue/data/bridge.config") b.connect() lights = b.get_light() for light in lights: output += "Light ID : " + light[0] + "\n" output += " Name : " + lights[light]["name"] + "\n" output += "\n" except: output = "Error while retrieving Hue lamps... Have you push the bridge button?" return output
class HueControl(): def initBridge(self, ip): self.bridge = Bridge(ip) self.bridge.connect() self.bridge.get_api() def __init__(self, jarvis, hueBridgeIP): self.initBridge(hueBridgeIP) self.jarvis = jarvis def setHue(self, hueValue): """ Set Hue from 0 to 65280 """ self.bridge.set_light(2,'hue', hueValue) def setSaturation(self, satValue): """ Set Saturation from 0 to 254 """ self.bridge.set_light(2,'sat', hueValue) def setBrightness(self, briValue): """ Set brightness from 0 to 254 """ self.bridge.set_light(2,'bri', hueValue) def setCommand(self, command): self.bridge.set_light(2, command) def setState(self, state): self.bridge.set_light(2,'on', state) def getState(self): return self.bridge.get_light(2,'on') def toggleState(self): wantedState = not self.getState() self.setState(wantedState)
class PhueOnOffManager: def __init__(self, addr, lightname): self.b = Bridge(addr) self.b.connect() self.lightname = lightname def read(self): value = self.b.get_light(self.lightname, 'bri') return int(value) def write(self, value): if value > 254: value = 254 elif value < 0: value = 0 self.b.set_light(self.lightname, 'bri', value)
class HueControl(): def initBridge(self, ip): self.bridge = Bridge(ip) self.bridge.connect() self.bridge.get_api() def __init__(self, jarvis, hueBridgeIP): self.initBridge(hueBridgeIP) self.jarvis = jarvis def setHue(self, hueValue): """ Set Hue from 0 to 65280 """ self.bridge.set_light(2, 'hue', hueValue) def setSaturation(self, satValue): """ Set Saturation from 0 to 254 """ self.bridge.set_light(2, 'sat', hueValue) def setBrightness(self, briValue): """ Set brightness from 0 to 254 """ self.bridge.set_light(2, 'bri', hueValue) def setCommand(self, command): self.bridge.set_light(2, command) def setState(self, state): self.bridge.set_light(2, 'on', state) def getState(self): return self.bridge.get_light(2, 'on') def toggleState(self): wantedState = not self.getState() self.setState(wantedState)
class Hue: def __init__(self): self.ip = 'Philips-hue.local' self.bridge = Bridge(self.ip) def pink(self) : self.bridge.set_light('Strip', { 'hue' : 3000, 'bri' : 220 }) def on(self) : self.bridge.set_light('Strip', 'on', True) def off(self) : self.bridge.set_light('Strip', 'on', False) def toggle(self) : if self.bridge.get_light('Strip', 'on') : self.off() else : self.on()
def read_bulb_state(): state = None try: b = Bridge(HUE_BRIGE_IP) # If the app is not registered and the button is not pressed, press the button and call connect() (this only needs to be run a single time) b.connect() bulb_state = b.get_light(HUE_BULB_NAME) if 'name' in bulb_state: print(bulb_state['state']['on']) print(bulb_state['state']['bri']) state = bulb_state['state'] else: print("Error reading bulb state: ", bulb_state[0]['error']) except Exception as e: s = traceback.format_exc() print("unexpected failure, {} ,{}".format(e, s)) return state
def control_light(bridge_ip, key, room_name, light_id, new_state, dry_run=False): assert new_state in (True, False) logger.info("Setting light %s(%s) to %s" % (room_name, light_id, "ON" if new_state else "OFF")) if dry_run: return b = Bridge(bridge_ip, username=key) b.get_api() b.set_light(light_id, {'on': new_state}) result = b.get_light(light_id) if result['state']['on'] == new_state: logger.info(" Set light %s to %s" % (light_id, "ON" if new_state else "OFF")) else: logger.info(" Tried to set light %s to %s, but new state is %s" % (light_id, new_state, result['state']['on']))
def main(): hue_bridge = Bridge(BRIDGE_IP) # If the app is not registered and the button is not pressed, press the button and call connect() # (this only needs to be run a single time) # hue_bridge.connect() # turn the lamp on if it is not already, make note of what color lamp is currently set at hue_bridge.set_light(LIGHT_ID, 'on', True) initial_state = hue_bridge.get_light(LIGHT_ID)['state'] # Get weather Info max_temp, rain_probabilities = get_weather(WEATHER_URL) yday_temp = get_yesterday_temp(TEMPERATURE_FILE) # Change lamp color depending on weather data change_color(yday_temp, max_temp, rain_probabilities, hue_bridge) # delay for 2 hour then set lamp to previous color time.sleep(7200) hue_bridge.set_light(LIGHT_ID, initial_state) save_max_temp(TEMPERATURE_FILE, max_temp)
class HueService(ParentService): def __init__(self, ip=None): self.ip = ip self.id = None self.bridge = Bridge(self.ip) def get_function(self, message=None): api = self.bridge.get_api() for each_light in api['lights']: if (api['lights'][each_light]['name'].lower() == message.get( "bulb_name", "none").lower()): self.id = each_light return self.toggle def toggle(self): self.bridge.connect() curr_state = self.bridge.get_light(int(self.id), 'on') if curr_state: self.bridge.set_light(int(self.id), 'on', False) else: self.bridge.set_light(int(self.id), 'on', True)
class Hue(): def __init__(self, bridge, lightbulb=None): self.bridgeAddress = bridge self.lightsMap = {} if lightbulb: m = re.split('\s*,\s*', lightbulb) self.lightbulbs = m if m else [lightbulb] def connect(self): self.bridge = Bridge(self.bridgeAddress) self.bridge.connect() self.bridge.get_api() for light in self.bridge.lights: self.lightsMap[light.name] = light if not hasattr(self, 'lightbulbs'): self.lightbulbs = [] for light in self.bridge.lights: self.lightbulbs.append(light.name) def setBri(self, bri): if bri == 0: for light in self.lightbulbs: self.bridge.set_light(light, 'on', False) else: for light in self.lightbulbs: if not self.bridge.get_light(light, 'on'): self.bridge.set_light(light, 'on', True) self.bridge.set_light(self.lightbulbs, 'bri', bri) def setSat(self, sat): self.bridge.set_light(self.lightbulbs, 'sat', sat) def setHue(self, hue): self.bridge.set_light(self.lightbulbs, 'hue', hue)
def handle(text, luna, profile): bridge = Bridge('192.168.178.85') xy = bridge.get_light(1, 'xy') print('XY: {}'.format(xy))
class Component(ThreadComponent): MATRIX = matrices.LIGHT_BULB def __init__(self, component_config): super().__init__(component_config) self.bridge = Bridge(component_config['ip_address'], component_config['username']) self.delta_range = range(-254, 254) self.delta = 0 # Extract light IDs, they are stored with format `<bridgeID>-light-<lightID>` light_ids = component_config['device_ids'] light_ids = [i.split('-light-')[1].strip() for i in light_ids] self.lights = self.create_lights(light_ids) self.lights.update_state() self.station_id_1 = component_config.get('station1', None) self.station_id_2 = component_config.get('station2', None) self.station_id_3 = component_config.get('station3', None) # seed random nr generator (used to get random color value) seed() def create_lights(self, light_ids): reachable_lights = self.filter_reachable(light_ids) if not reachable_lights: lights = EmptyLightSet() elif len(reachable_lights) > 10: lights = Group(self.bridge, reachable_lights) else: lights = LightSet(self.bridge, reachable_lights) return lights def filter_reachable(self, light_ids): lights = self.bridge.get_light() reachable = [ i for i in light_ids if i in lights and lights[i]['state']['reachable'] ] logger.debug("lights: %s reachable: %s", list(lights.keys()), reachable) return reachable def on_button_press(self): self.set_light_attributes(on=not self.lights.on) def on_longtouch_left(self): logger.debug("on_longtouch_left()") if self.station_id_1 is not None: self.bridge.activate_scene('0', self.station_id_1) self.nuimo.display_matrix(matrices.STATION1) def on_longtouch_bottom(self): logger.debug("on_longtouch_bottom()") if self.station_id_2 is not None: self.bridge.activate_scene('0', self.station_id_2) self.nuimo.display_matrix(matrices.STATION2) def on_longtouch_right(self): logger.debug("on_longtouch_right()") if self.station_id_3 is not None: self.bridge.activate_scene('0', self.station_id_3) self.nuimo.display_matrix(matrices.STATION3) def set_light_attributes(self, **attributes): response = self.lights.set_attributes(attributes) if 'errors' in response: logger.error("Failed to set light attributes: %s", response['errors']) self.nuimo.display_matrix(matrices.ERROR) return if 'xy' in attributes: if 'bri' in attributes: self.nuimo.display_matrix(matrices.LETTER_W) else: self.nuimo.display_matrix(matrices.SHUFFLE) elif 'on' in attributes and not ('bri_inc' in attributes): if self.lights.on: self.nuimo.display_matrix(matrices.LIGHT_ON) else: self.nuimo.display_matrix(matrices.LIGHT_OFF) elif 'bri' in attributes or 'bri_inc' in attributes: if self.lights.brightness: matrix = matrices.progress_bar(self.lights.brightness / self.delta_range.stop) self.nuimo.display_matrix(matrix, fading=True, ignore_duplicates=True) else: self.set_light_attributes(on=False) def on_swipe_left(self): self.set_light_attributes(on=True, bri=self.lights.brightness, xy=COLOR_WHITE_XY) def on_swipe_right(self): self.set_light_attributes(on=True, xy=(random(), random())) def on_rotation(self, value): self.delta += value def run(self): prev_sync_time = time() prev_update_time = time() while not self.stopped: now = time() if self.delta and now - prev_update_time >= self.lights.update_interval: self.send_updates() self.delta = 0 prev_update_time = now if now - max([prev_sync_time, prev_update_time ]) >= self.lights.sync_interval: self.lights.update_state() prev_sync_time = now sleep(0.05) def send_updates(self): delta = round( clamp_value(self.delta_range.stop * self.delta, self.delta_range)) if self.lights.on: self.set_light_attributes(bri_inc=delta) else: if delta > 0: self.set_light_attributes(on=True) self.set_light_attributes(bri_inc=delta)
b.connect() print("connecting to bridge...") else: print("bridge is connected") print(b.get_group(1, 'lights')) #/BRIDGE SETUP #GET COLOR LIGHTS for room in b.get_group(): for name in rainbowRooms: iRoom = int(room) if b.get_group(iRoom, 'name') == name.__str__(): for light in b.get_group(iRoom, 'lights'): iLight = int(light) if b.get_light(iLight, 'type') == "Extended color light": colorLights.append(b.get_light(iLight, 'name')) b.set_light(iLight, 'on', True) b.set_light(iLight, 'bri', 254) print(colorLights) #/GET COLOR LIGHTS #RAINBOW while playing: for x in my_range(0, 1, .05): for cLight in colorLights: b.set_light(cLight, 'xy', [0, 1 - x]) time.sleep(intervalTime) for x in my_range(0, 1, .05):
#!/usr/bin/python from phue import Bridge import pprint # hard coded ip address, found by looking at the router settings. b = Bridge('10.0.0.44') # only use the first group group = b.get_group(1) # print current status print(f"Any lights on in {group['name']}: {group['state']['any_on']}") light_status = "[" for light in group['lights']: light = b.get_light(int(light)) status = f"{light['state']['bri']:3}" if light['state']['on'] else "off" light_status += f"({light['name']}: {status}), " print(light_status[:-2]+"]") # print available scenes and inputs indexed_scenes = list(enumerate([scene.name for scene in b.scenes])) print("Available scenes:") pprint.pp(indexed_scenes) commands = input("Enter scene index, 'on', 'off', or -brightness value (1-255) (empty cancels): ") # handle the command(s) given for command in commands.split(): if command == "": pass elif command == 'on':
class LightHuePlugin(LightPlugin): """ Philips Hue lights plugin. Requires: * **phue** (``pip install phue``) """ MAX_BRI = 255 MAX_SAT = 255 MAX_HUE = 65535 ANIMATION_CTRL_QUEUE_NAME = 'platypush/light/hue/AnimationCtrl' _BRIDGE_RECONNECT_SECONDS = 5 _MAX_RECONNECT_TRIES = 5 class Animation(Enum): COLOR_TRANSITION = 'color_transition' BLINK = 'blink' def __eq__(self, other): if isinstance(other, str): return self.value == other elif isinstance(other, self.__class__): return self == other def __init__(self, bridge, lights=None, groups=None): """ :param bridge: Bridge address or hostname :type bridge: str :param lights: Default lights to be controlled (default: all) :type lights: list[str] :param groups Default groups to be controlled (default: all) :type groups: list[str] """ super().__init__() self.bridge_address = bridge self.bridge = None self.logger.info('Initializing Hue lights plugin - bridge: "{}"'.format(self.bridge_address)) self.connect() self.lights = []; self.groups = [] if lights: self.lights = lights elif groups: self.groups = groups self._expand_groups() else: self.lights = [l.name for l in self.bridge.lights] self.redis = None self.animation_thread = None self.animations = {} self._init_animations() self.logger.info('Configured lights: "{}"'. format(self.lights)) def _expand_groups(self): groups = [g for g in self.bridge.groups if g.name in self.groups] for g in groups: for l in g.lights: self.lights += [l.name] def _init_animations(self): self.animations = { 'groups': {}, 'lights': {}, } for g in self.bridge.groups: self.animations['groups'][g.group_id] = None for l in self.bridge.lights: self.animations['lights'][l.light_id] = None @action def connect(self): """ Connect to the configured Hue bridge. If the device hasn't been paired yet, uncomment the ``.connect()`` and ``.get_api()`` lines and retry after clicking the pairing button on your bridge. """ # Lazy init if not self.bridge: from phue import Bridge, PhueRegistrationException success = False n_tries = 0 while not success: try: n_tries += 1 self.bridge = Bridge(self.bridge_address) success = True except PhueRegistrationException as e: self.logger.warning('Bridge registration error: {}'. format(str(e))) if n_tries >= self._MAX_RECONNECT_TRIES: self.logger.error(('Bridge registration failed after ' + '{} attempts').format(n_tries)) break time.sleep(self._BRIDGE_RECONNECT_SECONDS) self.logger.info('Bridge connected') self.get_scenes() else: self.logger.info('Bridge already connected') @action def get_scenes(self): """ Get the available scenes on the devices. :returns: The scenes configured on the bridge. Example output:: { "scene-id-1": { "name": "Scene 1", "lights": [ "1", "3" ], "owner": "owner-id", "recycle": true, "locked": false, "appdata": {}, "picture": "", "lastupdated": "2018-06-01T00:00:00", "version": 1 } } """ return self.bridge.get_scene() @action def get_lights(self): """ Get the configured lights. :returns: List of available lights as id->dict. Example:: { "1": { "state": { "on": true, "bri": 254, "hue": 1532, "sat": 215, "effect": "none", "xy": [ 0.6163, 0.3403 ], "ct": 153, "alert": "none", "colormode": "hs", "reachable": true }, "type": "Extended color light", "name": "Lightbulb 1", "modelid": "LCT001", "manufacturername": "Philips", "uniqueid": "00:11:22:33:44:55:66:77-88", "swversion": "5.105.0.21169" } } """ return self.bridge.get_light() @action def get_groups(self): """ Get the list of configured light groups. :returns: List of configured light groups as id->dict. Example:: { "1": { "name": "Living Room", "lights": [ "16", "13", "12", "11", "10", "9", "1", "3" ], "type": "Room", "state": { "all_on": true, "any_on": true }, "class": "Living room", "action": { "on": true, "bri": 241, "hue": 37947, "sat": 221, "effect": "none", "xy": [ 0.2844, 0.2609 ], "ct": 153, "alert": "none", "colormode": "hs" } } } """ return self.bridge.get_group() @action def get_animations(self): """ Get the list of running light animations. :returns: dict. Structure:: { "groups": { "id_1": { "type": "color_transition", "hue_range": [0,65535], "sat_range": [0,255], "bri_range": [0,255], "hue_step": 10, "sat_step": 10, "bri_step": 2, "transition_seconds": 2 } }, "lights": { "id_1": {} } } """ return self.animations def _exec(self, attr, *args, **kwargs): try: self.connect() self.stop_animation() except Exception as e: # Reset bridge connection self.bridge = None raise e lights = []; groups = [] if 'lights' in kwargs: lights = kwargs.pop('lights').split(',').strip() \ if isinstance(lights, str) else kwargs.pop('lights') if 'groups' in kwargs: groups = kwargs.pop('groups').split(',').strip() \ if isinstance(groups, str) else kwargs.pop('groups') if not lights and not groups: lights = self.lights groups = self.groups if not self.bridge: self.connect() try: if attr == 'scene': self.bridge.run_scene(groups[0], kwargs.pop('name')) else: if groups: self.bridge.set_group(groups, attr, *args, **kwargs) if lights: self.bridge.set_light(lights, attr, *args, **kwargs) except Exception as e: # Reset bridge connection self.bridge = None raise e @action def set_light(self, light, **kwargs): """ Set a light (or lights) property. :param light: Light or lights to set. Can be a string representing the light name, a light object, a list of string, or a list of light objects. :param kwargs: key-value list of parameters to set. Example call:: { "type": "request", "target": "hostname", "action": "light.hue.set_light", "args": { "light": "Bulb 1", "sat": 255 } } """ self.connect() self.bridge.set_light(light, **kwargs) @action def set_group(self, group, **kwargs): """ Set a group (or groups) property. :param group: Group or groups to set. Can be a string representing the group name, a group object, a list of strings, or a list of group objects. :param kwargs: key-value list of parameters to set. Example call:: { "type": "request", "target": "hostname", "action": "light.hue.set_group", "args": { "light": "Living Room", "sat": 255 } } """ self.connect() self.bridge.set_group(group, **kwargs) @action def on(self, lights=None, groups=None, **kwargs): """ Turn lights/groups on. :param lights: Lights to turn on (names or light objects). Default: plugin default lights :param groups: Groups to turn on (names or group objects). Default: plugin default groups """ if groups is None: groups = [] if lights is None: lights = [] return self._exec('on', True, lights=lights, groups=groups, **kwargs) @action def off(self, lights=None, groups=None, **kwargs): """ Turn lights/groups off. :param lights: Lights to turn off (names or light objects). Default: plugin default lights :param groups: Groups to turn off (names or group objects). Default: plugin default groups """ if groups is None: groups = [] if lights is None: lights = [] return self._exec('on', False, lights=lights, groups=groups, **kwargs) @action def toggle(self, lights=None, groups=None, **kwargs): """ Toggle lights/groups on/off. :param lights: Lights to turn off (names or light objects). Default: plugin default lights :param groups: Groups to turn off (names or group objects). Default: plugin default groups """ if groups is None: groups = [] if lights is None: lights = [] lights_on = [] lights_off = [] groups_on = [] groups_off = [] if groups: all_groups = self.bridge.get_group().values() groups_on = [ group['name'] for group in all_groups if group['name'] in groups and group['state']['any_on'] is True ] groups_off = [ group['name'] for group in all_groups if group['name'] in groups and group['state']['any_on'] is False ] if not groups and not lights: lights = self.lights if lights: all_lights = self.bridge.get_light().values() lights_on = [ light['name'] for light in all_lights if light['name'] in lights and light['state']['on'] is True ] lights_off = [ light['name'] for light in all_lights if light['name'] in lights and light['state']['on'] is False ] if lights_on or groups_on: self._exec('on', False, lights=lights_on, groups=groups_on, **kwargs) if lights_off or groups_off: self._exec('on', True, lights=lights_off, groups=groups_off, **kwargs) @action def bri(self, value, lights=None, groups=None, **kwargs): """ Set lights/groups brightness. :param lights: Lights to control (names or light objects). Default: plugin default lights :param groups: Groups to control (names or group objects). Default: plugin default groups :param value: Brightness value (range: 0-255) """ if groups is None: groups = [] if lights is None: lights = [] return self._exec('bri', int(value) % (self.MAX_BRI+1), lights=lights, groups=groups, **kwargs) @action def sat(self, value, lights=None, groups=None, **kwargs): """ Set lights/groups saturation. :param lights: Lights to control (names or light objects). Default: plugin default lights :param groups: Groups to control (names or group objects). Default: plugin default groups :param value: Saturation value (range: 0-255) """ if groups is None: groups = [] if lights is None: lights = [] return self._exec('sat', int(value) % (self.MAX_SAT+1), lights=lights, groups=groups, **kwargs) @action def hue(self, value, lights=None, groups=None, **kwargs): """ Set lights/groups color hue. :param lights: Lights to control (names or light objects). Default: plugin default lights :param groups: Groups to control (names or group objects). Default: plugin default groups :param value: Hue value (range: 0-65535) """ if groups is None: groups = [] if lights is None: lights = [] return self._exec('hue', int(value) % (self.MAX_HUE+1), lights=lights, groups=groups, **kwargs) @action def xy(self, value, lights=None, groups=None, **kwargs): """ Set lights/groups XY colors. :param value: xY value :type value: list[float] containing the two values """ if groups is None: groups = [] if lights is None: lights = [] return self._exec('xy', value, lights=lights, groups=groups, **kwargs) @action def ct(self, value, lights=None, groups=None, **kwargs): """ Set lights/groups color temperature. :param value: Temperature value (range: 0-255) :type value: int """ if groups is None: groups = [] if lights is None: lights = [] return self._exec('ct', value, lights=lights, groups=groups, **kwargs) @action def delta_bri(self, delta, lights=None, groups=None, **kwargs): """ Change lights/groups brightness by a delta [-100, 100] compared to the current state. :param lights: Lights to control (names or light objects). Default: plugin default lights :param groups: Groups to control (names or group objects). Default: plugin default groups :param delta: Brightness delta value (range: -100, 100) """ if groups is None: groups = [] if lights is None: lights = [] bri = 0 if lights: bri = statistics.mean([ light['state']['bri'] for light in self.bridge.get_light().values() if light['name'] in lights ]) elif groups: bri = statistics.mean([ group['action']['bri'] for group in self.bridge.get_group().values() if group['name'] in groups ]) else: bri = statistics.mean([ light['state']['bri'] for light in self.bridge.get_light().values() if light['name'] in self.lights ]) delta *= (self.MAX_BRI/100) if bri+delta < 0: bri = 0 elif bri+delta > self.MAX_BRI: bri = self.MAX_BRI else: bri += delta return self._exec('bri', int(bri), lights=lights, groups=groups, **kwargs) @action def delta_sat(self, delta, lights=None, groups=None, **kwargs): """ Change lights/groups saturation by a delta [-100, 100] compared to the current state. :param lights: Lights to control (names or light objects). Default: plugin default lights :param groups: Groups to control (names or group objects). Default: plugin default groups :param delta: Saturation delta value (range: -100, 100) """ if groups is None: groups = [] if lights is None: lights = [] sat = 0 if lights: sat = statistics.mean([ light['state']['sat'] for light in self.bridge.get_light().values() if light['name'] in lights ]) elif groups: sat = statistics.mean([ group['action']['sat'] for group in self.bridge.get_group().values() if group['name'] in groups ]) else: sat = statistics.mean([ light['state']['sat'] for light in self.bridge.get_light().values() if light['name'] in self.lights ]) delta *= (self.MAX_SAT/100) if sat+delta < 0: sat = 0 elif sat+delta > self.MAX_SAT: sat = self.MAX_SAT else: sat += delta return self._exec('sat', int(sat), lights=lights, groups=groups, **kwargs) @action def delta_hue(self, delta, lights=None, groups=None, **kwargs): """ Change lights/groups hue by a delta [-100, 100] compared to the current state. :param lights: Lights to control (names or light objects). Default: plugin default lights :param groups: Groups to control (names or group objects). Default: plugin default groups :param delta: Hue delta value (range: -100, 100) """ if groups is None: groups = [] if lights is None: lights = [] hue = 0 if lights: hue = statistics.mean([ light['state']['hue'] for light in self.bridge.get_light().values() if light['name'] in lights ]) elif groups: hue = statistics.mean([ group['action']['hue'] for group in self.bridge.get_group().values() if group['name'] in groups ]) else: hue = statistics.mean([ light['state']['hue'] for light in self.bridge.get_light().values() if light['name'] in self.lights ]) delta *= (self.MAX_HUE/100) if hue+delta < 0: hue = 0 elif hue+delta > self.MAX_HUE: hue = self.MAX_HUE else: hue += delta return self._exec('hue', int(hue), lights=lights, groups=groups, **kwargs) @action def scene(self, name, lights=None, groups=None, **kwargs): """ Set a scene by name. :param lights: Lights to control (names or light objects). Default: plugin default lights :param groups: Groups to control (names or group objects). Default: plugin default groups :param name: Name of the scene """ if groups is None: groups = [] if lights is None: lights = [] return self._exec('scene', name=name, lights=lights, groups=groups, **kwargs) @action def is_animation_running(self): """ :returns: True if there is an animation running, false otherwise. """ return self.animation_thread is not None @action def stop_animation(self): """ Stop a running animation if any """ if self.animation_thread and self.animation_thread.is_alive(): redis = self._get_redis() redis.rpush(self.ANIMATION_CTRL_QUEUE_NAME, 'STOP') self._init_animations() @action def animate(self, animation, duration=None, hue_range=None, sat_range=None, bri_range=None, lights=None, groups=None, hue_step=1000, sat_step=2, bri_step=1, transition_seconds=1.0): """ Run a lights animation. :param animation: Animation name. Supported types: **color_transition** and **blink** :type animation: str :param duration: Animation duration in seconds (default: None, i.e. continue until stop) :type duration: float :param hue_range: If you selected a color color_transition.html, this will specify the hue range of your color color_transition.html. Default: [0, 65535] :type hue_range: list[int] :param sat_range: If you selected a color color_transition.html, this will specify the saturation range of your color color_transition.html. Default: [0, 255] :type sat_range: list[int] :param bri_range: If you selected a color color_transition.html, this will specify the brightness range of your color color_transition.html. Default: [254, 255] :type bri_range: list[int] :param lights: Lights to control (names, IDs or light objects). Default: plugin default lights :param groups: Groups to control (names, IDs or group objects). Default: plugin default groups :param hue_step: If you selected a color color_transition.html, this will specify by how much the color hue will change between iterations. Default: 1000 :type hue_step: int :param sat_step: If you selected a color color_transition.html, this will specify by how much the saturation will change between iterations. Default: 2 :type sat_step: int :param bri_step: If you selected a color color_transition.html, this will specify by how much the brightness will change between iterations. Default: 1 :type bri_step: int :param transition_seconds: Time between two transitions or blinks in seconds. Default: 1.0 :type transition_seconds: float """ if bri_range is None: bri_range = [self.MAX_BRI - 1, self.MAX_BRI] if sat_range is None: sat_range = [0, self.MAX_SAT] if hue_range is None: hue_range = [0, self.MAX_HUE] if groups: groups = [g for g in self.bridge.groups if g.name in groups or g.group_id in groups] lights = lights or [] for g in groups: lights.extend([l.name for l in g.lights]) elif lights: lights = [l.name for l in self.bridge.lights if l.name in lights or l.light_id in lights] else: lights = self.lights info = { 'type': animation, 'duration': duration, 'hue_range': hue_range, 'sat_range': sat_range, 'bri_range': bri_range, 'hue_step': hue_step, 'sat_step': sat_step, 'bri_step': bri_step, 'transition_seconds': transition_seconds, } if groups: for g in groups: self.animations['groups'][g.group_id] = info for l in self.bridge.lights: if l.name in lights: self.animations['lights'][l.light_id] = info def _initialize_light_attrs(lights): if animation == self.Animation.COLOR_TRANSITION: return { l: { 'hue': random.randint(hue_range[0], hue_range[1]), 'sat': random.randint(sat_range[0], sat_range[1]), 'bri': random.randint(bri_range[0], bri_range[1]), } for l in lights } elif animation == self.Animation.BLINK: return { l: { 'on': True, 'bri': self.MAX_BRI, 'transitiontime': 0, } for l in lights } def _next_light_attrs(lights): if animation == self.Animation.COLOR_TRANSITION: for (light, attrs) in lights.items(): for (attr, value) in attrs.items(): attr_range = [0,0] attr_step = 0 if attr == 'hue': attr_range = hue_range attr_step = hue_step elif attr == 'bri': attr_range = bri_range attr_step = bri_step elif attr == 'sat': attr_range = sat_range attr_step = sat_step lights[light][attr] = ((value - attr_range[0] + attr_step) % (attr_range[1]-attr_range[0]+1)) + \ attr_range[0] elif animation == self.Animation.BLINK: lights = { light: { 'on': False if attrs['on'] else True, 'bri': self.MAX_BRI, 'transitiontime': 0, } for (light, attrs) in lights.items() } return lights def _should_stop(): try: redis = self._get_redis(transition_seconds) redis.blpop(self.ANIMATION_CTRL_QUEUE_NAME) return True except QueueTimeoutError: return False def _animate_thread(lights): set_thread_name('HueAnimate') self.logger.info('Starting {} animation'.format( animation, (lights or groups))) lights = _initialize_light_attrs(lights) animation_start_time = time.time() stop_animation = False while True: if stop_animation or \ (duration and time.time() - animation_start_time > duration): break try: if animation == self.Animation.COLOR_TRANSITION: for (light, attrs) in lights.items(): self.logger.debug('Setting {} to {}'.format(light, attrs)) self.bridge.set_light(light, attrs) stop_animation = _should_stop() if stop_animation: break elif animation == self.Animation.BLINK: conf = lights[list(lights.keys())[0]] self.logger.debug('Setting lights to {}'.format(conf)) if groups: self.bridge.set_group([g.name for g in groups], conf) else: self.bridge.set_light(lights.keys(), conf) stop_animation = _should_stop() if stop_animation: break except Exception as e: self.logger.warning(e) time.sleep(2) lights = _next_light_attrs(lights) self.logger.info('Stopping animation') self.animation_thread = None self.redis = None self.stop_animation() self.animation_thread = Thread(target=_animate_thread, name='HueAnimate', args=(lights,)) self.animation_thread.start() def _get_redis(self, socket_timeout=1.0): if not self.redis: redis_args = get_backend('redis').redis_args redis_args['socket_timeout'] = socket_timeout self.redis = Redis(**redis_args) return self.redis def status(self): # TODO pass
#!/usr/bin/python # Minimal Motion Detection Logic written by Claude Pageau Dec-2014 # Updated by Richard Polzin Mai-2018 import time import datetime import picamera import picamera.array from fractions import Fraction from phue import Bridge b = Bridge('192.168.178.25') b.connect() if b.get_light('Decke Esszimmer')['state']['on']: print("Lights are on - skipping checks") quit() #don't deactive the screen while someone is in there :) # Logging verbose = True # False= Non True=Display showMessage # Motion Settings threshold = 30 # How Much a pixel has to change sensitivity = 300 # How Many pixels need to change for motion detection # Camera Settings testWidth = 128 testHeight = 80 nightShut = 5.5 # seconds Night shutter Exposure Time default = 5.5 Do not exceed 6 since camera may lock up nightISO = 800 if nightShut > 6: nightShut = 5.9 SECONDS2MICRO = 1000000 # Constant for converting Shutter Speed in Seconds to Microseconds
signal.signal(signal.SIGTERM, signal_handler) b = Bridge(get_environment_variable("bridge_ip")) b.connect() groups = get_groups() previous_room_brightnesses = { group_id: None for group_id in groups.keys() } while True: for group_id, light_ids in groups.items(): group = b.get_group(group_id) group_brightness = group['action']['bri'] if previous_room_brightnesses[group_id] != group_brightness: previous_room_brightnesses[group_id] = group_brightness time.sleep(.5) for light_id in light_ids: light = b.get_light(light_id) # if light['state']['bri'] != group_brightness: b.set_light(light_id, "bri", group_brightness) time.sleep(.1)
def main(): import random as random random.seed() from time import sleep from time import time import re import sys from phue import Bridge # b = Bridge() b = Bridge('192.168.1.110') # b.connect() # command-line argument parser import argparse parser = argparse.ArgumentParser( prog = 'ColorCycle', prefix_chars = '-/', description = """This program takes a series of color and brightness inputs and changes bulb charateristics accordingly. It assumes that lights that are on will be used. Lights are tested for 'on' status every transition.""") timinggroup = parser.add_mutually_exclusive_group() timinggroup.add_argument('-t', '--timing', help='Set tempo in seconds, decimal values allowed; positive values produce gradual changes, ' + 'negative values produce flash transitions', type=float) timinggroup.add_argument('-r', '--bpm', '--rate', help='Set tempo as beats per minute, decimal values allowed; positive values produce gradual changes, ' + 'negative values produce flash transitions', type=float) parser.add_argument('-w', '--wait', help='Set wait time separately from transition time (bpm or seconds)', type=float, default=0.0) parser.add_argument('-c', '--hues', '--colors', help='A list of color values the lights will cycle through (0 - 65535)', type=int, nargs='+', default=[-1]) parser.add_argument('-b', '--brightness', help='Set bulb brightness (0 - 254, can be a list)', type=int, nargs='+', default=[254]) parser.add_argument('-s', '--saturation', help='Set bulb color saturation (0 - 254)', type=int, nargs='+', default=[254]) parser.add_argument('-m', '--monochrome', help='Cycle through color list with all lights the same color', action="store_true", default=False) parser.add_argument('-o', '--ordered', help='Cycle through color list in order (do not randomize); apparent ' + 'color "chase" order will be in reverse bulb order', action="store_true", default=False) selectiongroup = parser.add_mutually_exclusive_group() selectiongroup.add_argument('-n', '--names', help='A list of bulb names to cycle through; regex OK; bulbs will be turned on', nargs='+') selectiongroup.add_argument('-i', '--ids', help='A list of bulb id values to cycle through; bulbs will be turned on', type=int, nargs='+') selectiongroup.add_argument('-nx', '--excludednames', help='Cycle through all bulbs except these; regex OK; bulbs will be turned on', nargs='+') selectiongroup.add_argument('-ix', '--excludedids', help='Cycle through all bulbs except these id values; bulbs will be turned on', type=int, nargs='+') parser.add_argument('-d', '--duration', help='Duration for which the pattern should repeat (minutes)', type=float) #, default = 0.0) parser.add_argument('-v', '--verbose', help='Increase output verbosity', action="store_true") parser.add_argument('-x', '--exit', help='Exit by turning bulbs off', action="store_true") # TODO: add option to print list of bulb name/ID combos (with additional option to sort by ID# or name? -d, -di, -dn for 'directory, by id, by name'?) # TODO: add option to print list of 'legal' named colors (green, red, energize) # TODO: add option to specify colors as names # TODO: consider using the data from this page to write color names corresponding to hues: http://en.wikipedia.org/wiki/List_of_colors_(compact) # TODO: add option to specify bridge IP # TODO: design a GUI with checkboxes, etc. for options (Kivy?) # TODO: add option to specify colors (and more?) as ranges, e.g. hues = [0-1000, 5000-6800, 40000-41000] would assign three colors chosen from those ranges (-cr, -br, -sr, -wr, -tr) # TODO: add an option that increases hue/brightness/etc. by an increment of X for each time Y -- this is a maybe # TODO: set up a series of testing comand lines (e.g. 0, 1, 5 bulbs, 0, 1, 5 colors, bad parameter values) args = parser.parse_args() if args.verbose: print('Verbosity set to ON') if args.timing is not None: if args.timing >= 0: print('Transition timing is set to ' + str(abs(args.timing)) + ' seconds with a wait time of ' + str(abs(args.wait)) + ' seconds') if args.timing < 0 and args.wait > 0.0: print('Transition timing is set to 0.0 seconds with a wait time of ' + str(abs(args.wait) + abs(args.timing)) + ' seconds') if args.timing == 0: print('Lights will be set once and program will exit') if args.timing >= 0: print('Transitions will be gradual') else: print('Transitions will be instant') if args.bpm is not None: # For bpm time specification, assume that sum(bpm, wait) = intended total bpm. # So for bpm=10 and wait=20, transitions should begin at a rate of 30 bpm (every 2.0 seconds) netbpm = abs(args.bpm) + abs(args.wait) print('Timing is set to ' + str(netbpm) + ' bpm with a transition/wait split of ' + str(round(abs(args.bpm) / netbpm, 0)) + '/' + str(round(abs(args.wait) / netbpm, 0)) + '%') if args.bpm == 0: print('Lights will be set once and program will exit') if args.bpm >= 0: print('Transitions will be gradual') else: print('Transitions will be instant') print('Hues that will be cycled through: ' + str(args.hues)) if args.ids is not None: print('Bulbs that will be cycled through: ' + str(args.ids)) if args.ordered: print('Colors and lamps will be cycled in the specified order') else: print('Colors and lamps will be cycled in random order') print('Color saturation set to: ' + str(args.saturation)) print('Brightness set to: ' + str(args.brightness)) if args.duration is not None: print('Pattern will be repeated for ' + str(args.duration) + ' minute(s)') # Convert timing/frequency to integer tenths of seconds (transitiontime). # Wait times are handled by sleep(), so wait time is in actual seconds. if args.timing is not None: # Frequency is in seconds if args.timing >= 0: transitiontime = int(round(args.timing * 10, 0)) waittime = args.wait else: # use negative timing to specify flash transitions transitiontime = 0 waittime = -args.timing + args.wait # This arrangement allows a benign but nonsensical combination # (e.g. flash transition of -10 seconds with a wait of 5 seconds). # If a negative timing and a wait time are specified, # the timing and wait times will be added together. # This way, flipping a negative sign does not change the # observed rate of changes. if args.bpm is not None: # Frequency is in bpm; netbpm is the sum of transition and wait values if args.bpm >= 0: transitiontime = int(round(60 / (args.bpm / netbpm) * 10, 0)) waittime = 60 / (args.wait / netbpm) else: # use negative bpm to specify flash transitions transitiontime = 0 waittime = 60 / netbpm if args.timing is None and args.bpm is None: transitiontime = 0 waittime = 0 # Get light names and ID numbers, and choose which lights will be active # Note: Bulb changes are transmitted using ID number. lights_in_play = b.get_light_objects('name') light_ids_in_play = [] for name in lights_in_play: light_ids_in_play.append(int(b.get_light_id_by_name(name))) # Use a selection method: ID #s, names, exclude by #, exclude by name, default = all bulbs if args.ids is not None: # Set bulbs using ID numbers # Filter lights in use so that only specified bulbs are used. # Turn specified bulbs on. light_ids_in_play = [id_ for id_ in light_ids_in_play if id_ in args.ids] b.set_light(light_ids_in_play, 'on', True) lights_in_play = [] for id_ in light_ids_in_play: lights_in_play.append(b.get_light(id_, 'name')) elif args.excludedids is not None: # Exclude bulbs using ID numbers # Filter lights in use so that only specified bulbs are used. # Turn specified bulbs on. light_ids_in_play = [id_ for id_ in light_ids_in_play if id_ not in args.excludedids] b.set_light(light_ids_in_play, 'on', True) lights_in_play = [] for id_ in light_ids_in_play: lights_in_play.append(b.get_light(id_, 'name')) elif args.names is not None: # Set bulbs using names # Filter lights in use so that only specified bulbs are used. # Turn specified bulbs on. regex = re.compile('|'.join(args.names), re.IGNORECASE) # names joined with OR '|' connector # Usage note: '.*' is equivalent to DOS '*', '.' is equivalent to DOS '?' lights_in_play = [a for a in lights_in_play if re.search(regex, a)] light_ids_in_play = [] for name in lights_in_play: light_ids_in_play.append(int(b.get_light_id_by_name(name))) b.set_light(light_ids_in_play, 'on', True) elif args.excludednames is not None: # Exclude bulbs using names # Filter lights in use so that only specified bulbs are used. # Turn specified bulbs on. regex = re.compile('|'.join(args.excludednames), re.IGNORECASE) # names joined with OR '|' connector # Usage note: '.*' is equivalent to DOS '*', '.' is equivalent to DOS '?' lights_in_play = [a for a in lights_in_play if not re.search(regex, a)] light_ids_in_play = [] for name in lights_in_play: light_ids_in_play.append(int(b.get_light_id_by_name(name))) b.set_light(light_ids_in_play, 'on', True) else: pass # All lights will be adjusted as specified, but will not be switched on # randomly assign colors to lights and issue the commands via the hub try: if args.monochrome: # Set all bulbs to the same color; cycle through colors light_ids_on = [] huenum = -1 brinum = -1 satnum = -1 start = time() while True: loopstart = time() if args.duration is not None: if args.duration < (time() - start) / 60: break if args.ordered: # This results in each bulb moving through the parameter list in order. huenum = (huenum + 1) % len(args.hues) brinum = (brinum + 1) % len(args.brightness) satnum = (satnum + 1) % len(args.saturation) hue = args.hues[huenum] bri = args.brightness[brinum] sat = args.saturation[satnum] else: hue = random.choice(args.hues) bri = random.choice(args.brightness) sat = random.choice(args.saturation) hue_verbose = hue # used only for verbose printing if hue == -1: # flag for white sat = 0 # 0 to 254 hue = random.choice([i for i in args.hues if i >= 0]) # choose from non-white values if hue == -2: # flag for black (off) # get light 'on' status and build a list of lights that are on; build fresh every time for id_ in light_ids_in_play: if b.get_light(id_, 'on'): light_ids_on.append(id_) command = {'transitiontime' : transitiontime, 'on' : False} result = b.set_light(light_ids_in_play, command) else: # Set bulbs if len(light_ids_on) > 0: # If any bulbs are in the list, turn them on command = {'on' : True, 'transitiontime' : transitiontime, 'hue' : hue, 'sat' : sat, 'bri' : bri} result = b.set_light(light_ids_on, command) else: # empty list command = {'transitiontime' : transitiontime, 'hue' : hue, 'sat' : sat, 'bri' : bri} result = b.set_light(light_ids_in_play, command) if args.verbose: if len(light_ids_in_play) > 0: # print('Hue Bulb(s) ' + str(light_ids_in_play) + ' set to hue = ' + str(hue) + ', sat = ' + str(sat) + ', bri = ' + str(bri)) print('Bulb(s) {light_id} set to hue = {hue:>5}, sat = {sat:>3}, bri = {bri:>3}'.format(light_id=light_ids_in_play, hue=hue_verbose, sat=sat, bri=bri)) print('-- pass complete, waiting ' + str(transitiontime / 10 + waittime) + ' seconds --') if args.duration is not None: elapsed = time() - start print('-- ' + str(int(args.duration - elapsed/60)) + ' minutes ' + str(round(max((args.duration*60 - elapsed), 0) % 60, 1)) + ' seconds remaining --') if transitiontime + waittime == 0.0: if args.verbose: print('-- lights set, bpm = 0.0, exiting program --') break # end program else: loopelapsed = time() - loopstart sleep(max(transitiontime / 10 + waittime - loopelapsed, 0)) if len(args.hues) == 1 and len(args.brightness) == 1 and len(args.saturation) == 1: if args.verbose: print('-- only one color to cycle, exiting program --') # only one color, no reason to keep changing it break else: # Set bulbs to random colors; wait; repeat light_ids_on = [] huenum = -1 brinum = -1 satnum = -1 start = time() while True: loopstart = time() if args.duration is not None: if args.duration < (time() - start) / 60: break # sat = args.saturation # 0 to 254 if args.ordered: huenum = (huenum + 1) % len(args.hues) brinum = (brinum + 1) % len(args.brightness) satnum = (satnum + 1) % len(args.saturation) else: random.shuffle(light_ids_in_play) for light_index, light_id in enumerate(light_ids_in_play): if args.ordered: # Each bulb is assigned hues in the user-specified order. # The intial hue is set by cycling through the color list in order. # Visual note: the apparent "chase" direction of colors is the reverse # of the order of lights. hue = args.hues[(light_index + huenum) % len(args.hues)] bri = args.brightness[(light_index + brinum) % len(args.brightness)] sat = args.saturation[(light_index + satnum) % len(args.saturation)] else: hue = random.choice(args.hues) bri = random.choice(args.brightness) sat = random.choice(args.saturation) hue_verbose = hue # used only for verbose printing if hue == -1: # flag for white sat = 0 # 0 to 254 if len([i for i in args.hues if i >= 0]) > 0: hue = random.choice([i for i in args.hues if i >= 0]) # choose from non-white/black values else: hue = 0 # no colors available to choose, assume red elif hue == -2: # flag for black light_ids_on.append(light_id) hue = random.choice([i for i in args.hues if i >= 0]) # choose from non-white/black values command = {'on' : False, 'transitiontime' : transitiontime} if hue_verbose != -2: # if not black # Set bulbs if light_id in light_ids_on: command = {'on' : True, 'transitiontime' : transitiontime, 'hue' : hue, 'sat' : sat, 'bri' : bri} light_ids_on.remove(light_id) else: command = {'transitiontime' : transitiontime, 'hue' : hue, 'sat' : sat, 'bri' : bri} result = b.set_light(light_id, command) if args.verbose: if light_id in light_ids_in_play: print('Bulb {light_id:>2} set to hue = {hue:>5}, sat = {sat:>3}, bri = {bri:>3}'.format(light_id=light_id, hue=hue_verbose, sat=sat, bri=bri)) sat = args.saturation # 0 to 254 if args.verbose: print('-- pass complete, waiting ' + str(transitiontime / 10 + waittime) + ' seconds --') if args.duration is not None: elapsed = time() - start # the following command could use some analysis for the max portion. # the following command, with max removed, will result in an incorrect "59.9 seconds remaining" message at the end # c:\python32\python ColorCycle.py -v -t 3.0 -b 1 -c 0 500 1000 1500 2000 63000 63500 64000 64500 65000 65535 -i10 12 15 19 -d 0.2 -s 254 250 245 240 -x # print('-- ' + str(int(args.duration - elapsed/60)) + ' minutes ' + str(round(max((args.duration*60 - elapsed), 0) % 60, 1)) + ' seconds remaining --') if transitiontime + waittime == 0.0: if args.verbose: print('-- lights set, bpm = 0.0, exiting program --') break # end program else: loopelapsed = time() - loopstart len_text = 0 while (transitiontime / 10 + waittime - loopelapsed) > 0: loopelapsed = time() - loopstart elapsed = time() - start len_text = underwrite('-- ' + str(int(args.duration - elapsed/60)) + ' minutes ' + str(round(max((args.duration*60 - elapsed), 0) % 60, 1)) + ' seconds remaining --', len_text) sleep(min(1, max(0, transitiontime / 10 + waittime - loopelapsed))) if args.exit: command = {'transitiontime' : transitiontime, 'on' : False} result = b.set_light(light_ids_in_play, command) print('-- lights off, exiting program --') except KeyboardInterrupt: # Quit if we get a CTRL-C from the user if args.verbose: print('-- CTRL-C received, exiting program --') sys.exit()
class Hue(object): """ Plugin to interact with Philips Hue devices @author: Fabio "BlackLight" Manganiello <*****@*****.**> @depend: Philips Hue phue Python bridge [pip install phue] """ __hue = None __hue_lock = threading.RLock() def __init__(self, lightbulbs=None): """ bridge -- Name or IP address of the Philips Hue bridge host lightbulbs -- Lightbulbs to act on - single lightbulb name or comma separated list. In case nothing is passed, the plugin will act on all the lightbulbs connected to the bridge """ self.__config = Config.get_config() self.__logger = Logger.get_logger(__name__) self.bridge_address = self.__config.get('hue.bridge') self.lightbulbs = self.__config.get('hue.lightbulbs') self.connected = False if self.lightbulbs: m = re.split('\s*,\s*', self.lightbulbs) self.lightbulbs = m or [self.lightbulbs] self.__logger.info({ 'msg_type': 'Hue bridge started', 'bridge': self.bridge_address, 'lightbulbs': self.lightbulbs or None, }) @classmethod def get_hue(cls): """ Static helper used for rules.xml <action> tags of type Python, which are run through eval(). Thread-safe singleton to access or initialize the static default hue object """ cls.__hue_lock.acquire() try: if cls.__hue is None: cls.__hue = Hue() finally: cls.__hue_lock.release() return cls.__hue def connect(self): " Connect to the Philips Hue bridge " if self.connected: return self.__logger.info({ 'msg_type': 'Connecting to the Hue bridge', }) self.bridge = Bridge(self.bridge_address) self.bridge.connect() self.bridge.get_api() if not self.lightbulbs: self.lightbulbs = [] for light in self.bridge.lights: self.lightbulbs.append(light.name) self.__logger.info({ 'msg_type': 'Connected to the Hue bridge', 'lightbulbs': self.lightbulbs, }) self.connected = True return self def is_connected(self): " Return true if we are connected to the bridge " return self.connected def set_on(self, on): """ Set the lightbulbs on status on -- If False, turn the lights off, otherwise turn them on """ self.__logger.info({ 'msg_type': 'Set lightbulbs on', 'on': on, }) for light in self.lightbulbs: self.bridge.set_light(light, 'on', on) if on: self.bridge.set_light(light, 'bri', 255) return self def set_bri(self, bri): """ Set the lightbulbs brightness bri -- Brightness value, in range [0-255] """ self.__logger.info({ 'msg_type': 'Set lightbulbs brightness', 'brightness': bri, }) if bri == 0: for light in self.lightbulbs: self.bridge.set_light(light, 'on', False) else: for light in self.lightbulbs: if not self.bridge.get_light(light, 'on'): self.bridge.set_light(light, 'on', True) self.bridge.set_light(self.lightbulbs, 'bri', bri) return self def set_sat(self, sat): """ Set the lightbulbs saturation sat -- Saturation value, in range [0-500] """ self.__logger.info({ 'msg_type': 'Set lightbulbs saturation', 'saturation': sat, }) self.bridge.set_light(self.lightbulbs, 'sat', sat) return self def set_hue(self, hue): """ Set the lightbulbs hue hue -- Hue/tint value, in range [0-65535] """ self.__logger.info({ 'msg_type': 'Set lightbulbs hue', 'saturation': hue, }) self.bridge.set_light(self.lightbulbs, 'hue', hue) return self
#b.connect() root = Tk() horizontal_frame = Frame(root) horizontal_frame.pack() lights = b.get_light_objects('id') for light_id in lights: channel_frame = Frame(horizontal_frame) channel_frame.pack(side = LEFT) scale_command = lambda x, light_id=light_id: b.set_light(light_id,{'bri': int(x), 'transitiontime': 1}) scale = Scale(channel_frame, from_ = 254, to = 0, command = scale_command, length = 200, showvalue = 0) scale.set(b.get_light(light_id,'bri')) scale.pack() button_var = BooleanVar() button_var.set(b.get_light(light_id, 'on')) button_command = lambda button_var=button_var, light_id=light_id: b.set_light(light_id, 'on', button_var.get()) button = Checkbutton(channel_frame, variable = button_var, command = button_command) button.pack() label = Label(channel_frame) label.config(text = b.get_light(light_id,'name')) label.pack() root.mainloop() ########NEW FILE######## __FILENAME__ = tk_gui_hsb
#!/usr/bin/python from phue import Bridge b = Bridge('10.0.0.137') # If the app is not registered and the button is not pressed, press the button and call connect() (this only needs to be run a single time) b.connect() # Get the bridge state (This returns the full dictionary that you can explore) b.get_api() # Prints if light 1 is on or not b.get_light(1, 'on') # Set brightness of lamp 1 to max b.set_light(1, 'bri', 254) # Set brightness of lamp 2 to 50% b.set_light(2, 'bri', 127) # Turn lamp 2 on b.set_light(2,'on', True) # You can also control multiple lamps by sending a list as lamp_id b.set_light( [1,2], 'on', True) # Get the name of a lamp b.get_light(1, 'name') # You can also use light names instead of the id
conn = sqlite3.connect(dbname) curs = conn.cursor() curs.execute( "SELECT * FROM temps WHERE timestamp>datetime('now','-%s hours')" % 500) rows = curs.fetchall() conn.close() return rows # get data from the database records = get_data() records = str(get_data()) records = records[-10:] number = int(records[records.find(',') + 2:records.find(')')]) print(number) bLight = b.get_light(3, 'on') if number < 620: if bLight: lights[2].xy = [0.96, 0.96] savefile(number) dropbox_upload() log_temperature(number)
# 12 Couch ##Groups # 1 Bedroom Dome # 2 Bathroom Mirror # 3 Closet #Set Target Bulbs and Groups b1 = 2 b2 = 10 b3 = 12 g1 = 2 g2 = 3 #Get Current Status of Bulbs and Groups h1 = b.get_light(b1,'hue') h2 = b.get_light(b2,'hue') h3 = b.get_light(b3,'hue') br1 = b.get_light(b1,'bri') br2 = b.get_light(b2,'bri') br3 = b.get_light(b3,'bri') brg1 = b.get_group(g1,'bri') brg2 = b.get_group(g2,'bri') p1 = b.get_light(b1,'on') p2 = b.get_light(b2,'on') p3 = b.get_light(b3,'on') pg1 = b.get_group(g1,'on') pg2 = b.get_group(g2,'on')
print("Philups hue connecting...") print( "Get ready to enter the ip address of your hue, before you press enter press the connect button on your hue device" ) ip = input("Please enter the IP ADDRESS of your hue: ") light = input("Enter the NAME of the light, caps sensitive: ") bridge = Bridge(ip) bridge.connect() bridge.get_api() print("Connected to " + ip + "'s api") light_real = bridge.get_light(light) light_obj = bridge.get_light_objects(light_real["name"]) print(light_obj) SCREEN_SIZE = (600, 400) fourcc = cv2.VideoWriter_fourcc(*"XVID") print("Starting") converter = rgbxy.Converter(rgbxy.GamutB) while True: img = pyautogui.screenshot() frame = np.array(img) frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
from phue import Bridge # https://github.com/studioimaginaire/phue # in and for meaning: https://www.quora.com/In-Python-what-does-for-return-and-in-mean # https://stackoverflow.com/questions/19845924/python-how-to-generate-list-of-variables-with-new-number-at-end # the hub 192.168.1.107 b = Bridge('192.168.1.107') b.connect() b.get_api() b.get_light(1, 'on') b.get_light(1, 'name') lights = b.lights print( "NOTICE: Only 1 light is supported in this script more will be allowed in the future." ) print( "This script is highly work in progress, contact Yusef (YUZi22) on Github if any errors occur" ) print() print( "Please make sure to input the local ip address of your hue hub, and press the button on it before you run this script" ) print() # Print names of all lights connected to hue hub. for l in lights:
from phue import Bridge import time b = Bridge('192.168.1.80') light = 'Bedroom' # If the app is not registered and the button is not pressed, press the button and call connect() (this only needs to be run a single time) #b.connect() # Get the bridge state (This returns the full dictionary that you can explore) b.get_api() # Prints if light 1 is on or not print b.get_light(1, 'on') print b.get_light(2, 'on') print b.get_light(3, 'on') b.set_light('Bedroom', 'on', True) b.set_light('Bedroom', 'bri', 254) for i in range(0,10): for j in xrange(20,4000,300): b.set_light('Bedroom', 'hue', j) time.sleep(2) print j for j in xrange(4000,20,-300): b.set_light('Bedroom', 'hue', j) time.sleep(2) print j
#!/usr/bin/python from phue import Bridge import os import sys import requests b = Bridge('192.168.1.217') r = (requests.get("http://192.168.1.217/api//sensors/")) lightlevel = r.json()['18']['state']['lightlevel'] if (sys.argv[1] == "Plex for LG (webOS 04.30.06)" or sys.argv[1] == 'LG 43UH6500-UB') and sys.argv[2] == 'agsl': if not os.path.isfile('room_s'): f = open("room_s", "w") print(b.get_light(2), file=f) f.close() if lightlevel < 10500: b.set_light(1, { 'bri': 80, 'xy': [0.1538, 0.0722], 'transitiontime': 20 }) b.set_light([2, 3], {'on': False, 'transitiontime': 20})
signal.signal(signal.SIGINT, self.exit_gracefully) signal.signal(signal.SIGTERM, self.exit_gracefully) def exit_gracefully(self,signum, frame): logger.info(time.strftime('%x %X %Z')+': Going down for a nap...') b.set_light(5, 'on', False) self.kill_now = True if __name__ == '__main__': logger.info(time.strftime('%x %X %Z')+': Starting light sequence') killer = GracefulKiller() while True: # Go white change_white() time.sleep(8) if b.get_light(5, 'on') == False: break elif killer.kill_now: break # Go red change_red() time.sleep(8) if b.get_light(5, 'on') == False: break elif killer.kill_now: break # Go blue change_blue() time.sleep(8)
class LightCommands: """ Object for executing command-line commands associated with Hue Lights. """ # # only numeric for now # attributes = { "transitiontime", "brightness", "colortemp", "colortemp_k", "hue", "saturation" } def __init__(self, parent): self.parent = parent self.bridge = None def _ensure_bridge(self): if not self.bridge: self.bridge = Bridge() # pylint: disable=invalid-name async def do(self, parameters: List[str]): """ Implement light control commands such as the following:: light 4 on light group 3 hue 7712 in which case this function receive the parameters:: ["4","on"] ["group","3","hue","7712"] :param parameters: :return: """ self._ensure_bridge() idx = 0 first = parameters[idx] idx += 1 pattern = re.compile("[0-9]+") if pattern.match(first): light_id = int(first) light = self.bridge.lights[light_id - 1] elif first == "group": second = parameters[idx] idx += 1 group_id = int(second) light = self.bridge.groups[group_id - 1] else: raise ValueError("the light command must be followed by " "a number or by 'group' and then a number") while idx < len(parameters): cmd = parameters[idx] idx += 1 if cmd == "on": light.on = True elif cmd == "off": light.on = False elif cmd in LightCommands.attributes: amount = int(parameters[idx]) idx += 1 setattr(light, cmd, amount) else: raise ValueError(f"Command {cmd} is not available for lights") async def get_unreachable_lights(self, lights, wait_time=10, tries=3): """ Detect unavailable lights. Every so often a ping fails (for instance when there is a lot of Wi-Fi activity) so we will wait and retry to make sure. Default settings are based on a small amount of experience with how rapidly the Hue system seems to respond to lights having the AC power turned on and off :param lights: list or set of integer light ids :param wait_time: how many seconds to wait to try pinging lights a second time :param tries: how many tries to try the ping before giving up :return: set of unavailable lights """ self._ensure_bridge() available = set() lights = set(map(int, lights)) for attempt in range(tries): unavailable = lights - available if not unavailable: return set() if attempt: await sleep(wait_time) for light in lights - available: if self.bridge.get_light(light)['state']['reachable']: available.add(light) return lights - available
#!/usr/bin/python from time import sleep from phue import Bridge b = Bridge('192.168.1.26') hue = b.get_light(2,'hue') bri = b.get_light(2,'bri') pwr = b.get_light(2,'on') # b.set_light(2,'on',True) if pwr == 'False': b.set_light(2,'on',True) for x in range(0, 2): b.set_light(2,'hue',0) sleep(0.4) b.set_light(2,'hue',hue) sleep(0.4) b.set_light(2,'on',pwr) #b.set_light(2,'bri',bri) #b.set_light(2,'hue',hue)
class BridgeContainer(): def __init__(self, transitiontime=50, individual=None, ip=None, dummy=False): if dummy: self.mybridge = DummyBridge() self.individual = 1 self.transitiontime = 50 return self.mybridge = None while not self.mybridge: try: if not ip: # try to find a bridge with meethue api logging.debug("will try finding the hue bridge") print "1111" localbridge = json.loads(urlopen(' /nupnp').read()) ip = localbridge[0]["internalipaddress"] logging.info('connecting to localbridge at ' + str(ip)) print "????" self.mybridge = Bridge(ip) self.mybridge.connect() self.mybridge.get_api() except Exception as e: logging.warn( 'failed to connect to HUE server did you push the button?') self.mybridge = None sleep(10) self.transitiontime = transitiontime self.individual = None if individual: self.individual = int(individual) self.alert() def setTransitionTime(self, value): # this should be the transistion time in seconds self.transitiontime = int(10 * float(value)) def sendAll(self, **options): lamp = self.individual or 0 for k, v in options.iteritems(): if v is None: del (options[k]) if self.transitiontime >= 0: options['transitiontime'] = self.transitiontime if self.individual: self.mybridge.set_light(self.individual, options) else: self.mybridge.set_group(0, options) def getAll(self): # returns dictionary with all values # {"state": {"on":true,"bri":254,"hue":45000,"sat":253,"xy":[0.1914,0.0879],"ct":500,"alert":"select","effect":"none","colormode":"hs","reachable":true}, # "type": "Extended color light", "name": "Hue Lamp", "modelid": "LCT001", "swversion": "66009663", "pointsymbol": { "1":"none", "2":"none", "3":"none", "4":"none", "5":"none", "6":"none", "7":"none", "8":"none" }} return self.mybridge.get_light(self.individual)['state'] def setEffect(self, value): self.sendAll(effect=effect) def setHue(self, value): self.sendAll(hue=value) def setBri(self, value): self.sendAll(bri=value) def setSat(self, value): self.sendAll(sat=value) def get_state(self): if self.individual: logging.debug(str(self.mybridge.get_light(self.individual))) return self.mybridge.get_light(self.individual)['state'] def toggle(self, dummy=None): if self.individual: if self.mybridge.get_light(self.individual)['state']['on']: self.mybridge.set_light(self.individual, {'on': False}) else: self.mybridge.set_light(self.individual, {'on': True}) else: if self.mybridge.get_group(0)['action']['on']: self.mybridge.set_group(0, {'on': False}) else: self.mybridge.set_group(0, {'on': True}) def setOn(self, value): if self.individual: if value: self.mybridge.set_light(self.individual, {'on': True}) else: self.mybridge.set_light(self.individual, {'on': False}) def alert(self, dummy=None): if self.individual: self.mybridge.set_light(self.individual, {'alert': 'select'}) else: self.mybridge.set_group(0, {'alert': 'select'})
# IMPORTANT: If running for the first time: # Uncomment the b.connect() line # Ppress button on bridge # Run the code # This will save your connection details in /home/pi/.python_hue # Delete that file if you change bridges # b.connect() # <<<<<<<<<< # An array of the light name and the light type. # Expand if you have something different - please let me know if you do! lighttype = [] lighttypecolour = 'Extended color light' lighttypedimmable = 'Dimmable light' # Get the type of lights that are connected for light in lights: lighttype.append([light, b.get_light(light, 'type')]) # Hue 'xy' colours - expand at will redxy = (0.675, 0.322) greenxy = (0.4091, 0.518) bluexy = (0.167, 0.04) yellowxy = (0.4325035269415173, 0.5007488105282536) bluevioletxy = (0.2451169740627056, 0.09787810393609737) orangexy = (0.6007303214398861, 0.3767456073628519) whitexy = (0.32272672086556803, 0.3290229095590793) # Alert Patterns # Used to change the status of lights # First two numbers are the number of repeat cycles, and the delay between changes # Followed by dictionaries of the change of light status. # Use any valid HUE setting - e.g. on, bri, xy, ct, sat, hue, transformationtime
#!/usr/bin/python from Tkinter import * from phue import Bridge ''' This example creates a slider that controls the brightness of the first 3 lights. ''' b = Bridge() # Enter bridge IP here. #If running for the first time, press button on bridge and run with b.connect() uncommented #b.connect() b.set_light([1,2,3], 'on', True) def sel(data): b.set_light([1,2,3],{'bri':int(data), 'transitiontime': 1}) root = Tk() scale = Scale( root, from_ = 254, to = 0, command= sel, length = 200 ) scale.set(b.get_light(1,'bri')) scale.pack(anchor=CENTER) root.mainloop()
# If running for the first time, press button on bridge and run with b.connect() uncommented # b.connect() root = Tk() horizontal_frame = Frame(root) horizontal_frame.pack() lights = b.get_light_objects("id") for light_id in lights: channel_frame = Frame(horizontal_frame) channel_frame.pack(side=LEFT) scale_command = lambda x, light_id=light_id: b.set_light(light_id, {"bri": int(x), "transitiontime": 1}) scale = Scale(channel_frame, from_=254, to=0, command=scale_command, length=200, showvalue=0) scale.set(b.get_light(light_id, "bri")) scale.pack() button_var = BooleanVar() button_var.set(b.get_light(light_id, "on")) button_command = lambda button_var=button_var, light_id=light_id: b.set_light(light_id, "on", button_var.get()) button = Checkbutton(channel_frame, variable=button_var, command=button_command) button.pack() label = Label(channel_frame) label.config(text=b.get_light(light_id, "name")) label.pack() root.mainloop()
#!/usr/bin/python from phue import Bridge # https://github.com/studioimaginaire/phue b = Bridge('bridgeipaddress') # If the app is not registered and the button is not pressed, press the button and call connect() (this only needs to be run a single time) b.connect() # Get the bridge state (This returns the full dictionary that you can explore) b.get_api() # Prints if light 1 is on or not b.get_light(1, 'on') # Set brightness of lamp 1 to max b.set_light(1, 'bri', 0) # The set_light method can also take a dictionary as the second argument to do more fancy stuff # This will set some parameters on light 1 with a transition time of 30 seconds command = {'transitiontime' : 300, 'on' : True, 'bri' : 254, 'hue' : 12750} b.set_light(1, command)
#!/usr/bin/python from time import sleep from phue import Bridge b = Bridge('192.168.1.26') hue = b.get_light(2, 'hue') bri = b.get_light(2, 'bri') pwr = b.get_light(2, 'on') # b.set_light(2,'on',True) if pwr == 'False': b.set_light(2, 'on', True) for x in range(0, 2): b.set_light(2, 'hue', 0) sleep(0.4) b.set_light(2, 'hue', hue) sleep(0.4) b.set_light(2, 'on', pwr) #b.set_light(2,'bri',bri) #b.set_light(2,'hue',hue)
}) scale = Scale(frame, from_=254, to=0, activebackground='gray', fg='white', highlightbackground='gray', command=scale_command, length=200, borderwidth=.001, showvalue=0, troughcolor='lightgray', orient='horizontal', bg='gray', label="Brightness") scale.set(b.get_light(light_id, 'bri')) scale.grid(row=rowNum, column=2) button_var = BooleanVar() button_var.set(b.get_light(light_id, 'on')) button_command = lambda button_var=button_var, light_id=light_id: b.set_light( light_id, 'on', button_var.get()) button = Checkbutton(frame, variable=button_var, command=button_command) button.grid(row=rowNum, column=0) label = Label(frame) label.config(text=b.get_light(light_id, 'name')) label.grid(row=rowNum, column=1) rowNum = rowNum + 1
#!/usr/bin/python # AutoAuroDX # hueTesting.py (some simple bits to test API behavior) # Adam J. Bauman # # Real-time Philips Hue light programming based off hue and intensity averages of PC monitor display. import datetime, time import os from phue import Bridge myBridge = Bridge('192.168.1.25') myBridge.connect() myBridge.get_api() myBridge.set_light(1, 'on', True) myBridge.set_light(1, 'bri', 127, transitiontime=0) myBridge.set_light(1, 'effect', 'colorloop', transitiontime=0) raw_input('Press any key to continue... ') myBridge.set_light(1, 'effect', 'none') print(myBridge.get_light(1, 'hue'))
Brightness = 50 # Helligkeit in % DimTimeOn = DimTimeON*10 # in 1/10 sek DimTimeOff = DimTimeOFF*10 # in 1/10 sek bri = Brightness*1000/100*254/1000 commandOn = {'transitiontime' : DimTimeOn, 'on' : True, 'bri' : bri} commandOff = {'transitiontime' : DimTimeOff, 'on' : False} b = Bridge(IP) GPIO.setmode(GPIO.BCM) GPIO.setup(InPin, GPIO.IN, pull_up_down=GPIO.PUD_UP) while True: now = datetime.datetime.now() input_state = GPIO.input(InPin) if input_state == False: if b.get_light(2,'on') == True: StatusL = "An" else: StatusL = "Aus" print "------------------------" print print now.strftime("%d.%m.%Y %H:%M:%S") print "Linker Taster gedrueckt" print "Status : %s" % StatusL print "Aktuelle Helligkeit: %d Prozent, %d Lumen" % ((b.get_light(2,'bri'))*1000/254*100/1000, (b.get_light(2,'bri'))*1000/254*806/1000) if b.get_light(2,'on') == True: b.set_light(2, commandOff) print print "linkes Licht aus in %d Sekunden" % DimTimeOFF elif b.get_light(2,'on') == False or b.get_light(2,'bri') < 1:
label_name.pack() hue_slider = Scale(slider_frame, from_ = 65535, to = 0, command = hue_command) sat_slider = Scale(slider_frame, from_ = 254, to = 0, command = sat_command) bri_slider = Scale(slider_frame, from_ = 254, to = 0, command = bri_command) hue_slider.pack(side=LEFT) sat_slider.pack(side=LEFT) bri_slider.pack(side=LEFT) for light_id in lights: channel_frame = Frame(channels_frame) channel_frame.pack(side = LEFT, padx = 10) button_var = BooleanVar() button_var.set(b.get_light(light_id, 'on')) button_command = lambda button_var=button_var, light_id=light_id: b.set_light(light_id, 'on', button_var.get()) button = Checkbutton(channel_frame, variable = button_var, command = button_command) button.pack() select_button_var = BooleanVar() #select_button_var.set(b.get_light(light_id, 'on')) select_button_callback = curry(select_button_command, light_id, select_button_var) select_button = Checkbutton(channel_frame, variable = select_button_var, command = select_button_callback) select_button.pack() label = Label(channel_frame) label.config(text = b.get_light(light_id,'name')) label.pack() root.mainloop()
class HueCommand: def __init__(self, duration, states): self.b = Bridge('********') self.duration = duration self.states = states def get_states(self, ids): lights =[] for light_id in ids: is_on = self.b.get_light(light_id, 'on') bri = self.b.get_light(light_id, 'bri') hue = self.b.get_light(light_id, 'hue') lights.append({'id': light_id, 'on': is_on, 'hue': hue, 'bri': bri}) return lights def execute(self): # set hue bulbs self.b.connect() # Get a dictionary with the light ids as the key # lights = self.b.get_light_objects('id') for state in self.states: try: self.b.set_light(state.id, state.cmd) except Exception as e: print e.message continue time.sleep(self.duration)