'''
Copyright 2015 (c) Eli Levin
pulse.py - makes a color "pulse" by looping brightness and saturation
'''
from phue import Bridge
import time
import math
b = Bridge('192.168.1.9') # Enter bridge IP here.
b.create_group('myLights', [1,2,3])
lights = b.lights # get a list of all lights
def set_hue(hueVal):
#set hue for a group of lights
b.set_group(1,'hue',hueVal)
def set_bri(briVal):
#set brightness for a group of lights
b.set_group(1,'bri',briVal)
def set_sat(satVal):
#set saturation for a group of lights
b.set_group(1,'sat',satVal)
def set_timing(transVal):
#set transition time for a group of lights
from phue import Bridge
import sys
import spotipy
import spotipy.util as util
import time
from datetime import datetime
from datetime import timedelta
def bright(loud):
return 244.94 * (1.0199 ** loud)
b = Bridge('')
b.connect()
hue = 1
b.create_group('room',[1,2,3,4,5])
#b.set_light(2,'on',True)
b.set_group(1,'on',True)
uri='spotify:track:6CDzDgIUqeDY5g8ujExx2f'
token = util.prompt_for_user_token(username='', scope = 'user-modify-playback-state', client_id="",
client_secret="", redirect_uri="http://localhost:8080")
if token:
sp = spotipy.Spotify(auth=token)
results = uri
if results != None:
#analysis = sp.audio_analysis(results["item"]["uri"])
analysis = sp.audio_analysis(results)
iterator = iter(analysis['segments'])
brightness=32
val = analysis['segments'][0]
time_taken = 0
radius = 6371 #6371 radius of earth in kilometers, 3956 for miles
distance = radius outer
#direction
left = sin(longi) cos(lat2)
right = (cos(lat1) sin(lat2)) - (sin(lat1) cos(lat2) cos(longi))
direction = atan2(left, right)
direction = degrees(direction)
direction = (direction + 360) % 360
card = cardinalDirection(direction)
print(Distance %.2f KilometersnBearing %.2f° (%s) % (distance, direction, card))
# Main
def main()
device = XBeeDevice(PORT, BAUD_RATE)
b.connect()
b.create_group('RGB', [1,2,3])
b.set_group(1, green)
currentTime = time.time()
targetTime = time.time()
try
device.open()
while(True)
#light reset
if targetTime time.time()
b.set_group(1, green)
# Receive Data and Parse
def data_receive_callback(xbee_message)
address = xbee_message.remote_device.get_64bit_addr()
message = xbee_message.data.decode()
if txt =='END':
dict['end'] = linenum
except SyntaxError:
pass
linenum += 1
eval_line_txt = dict['start']
room_num = 0
while eval_line_txt != dict['end'] - 1:
eval_line_txt += 1
evaled_lines = eval(lines[eval_line_txt])
room_num += 1
room_num_txt = 'room' + str(room_num)
dict[room_num_txt] = evaled_lines[1]
b.create_group('room1', dict['room1'])
b.create_group('room2', dict['room2'])
#END DEFINING ROOMS
def check_bat(wm):
#ensure battery is not to low
battery_stat = wm.state['battery']
if battery_stat <= 10:
print 'remote disconnected due to low battery'
wm.close()
dict['timer'] = 0
dict['repeat_cycle'] = False
def rumble(wm):
#make wiimote rumble
wm.rumble = True
class HuePlay(object):
DEFAULT_GROUP = 'Gaming'
GROUP_LIGHTS = [
u'RP Lamp 1',
u'RP Lamp 2',
]
ATTRIBUTES = ['on', 'xy', 'saturation', 'brightness', 'transitiontime']
def __init__(self, address):
self.bridge = Bridge(address)
self.bridge.connect()
self.scenes = {}
def initializeGroups(self, group=DEFAULT_GROUP, lights=GROUP_LIGHTS):
if self.bridge.get_group(self.DEFAULT_GROUP) is not None:
self.bridge.delete_group(self.DEFAULT_GROUP)
self.bridge.create_group(self.DEFAULT_GROUP, self.GROUP_LIGHTS)
def setScene(self, name):
if name in self.scenes.keys():
light_names = self.bridge.get_light_objects('name')
for light in self.GROUP_LIGHTS:
light_names[light].on = True
light_names[light].xy = self.scenes[name].xy
light_names[light].saturation = self.scenes[name].saturation
light_names[light].brightness = self.scenes[name].brightness
self.last_scene = name
def loadScenes(self, scenefile='scenes/scenes.yaml'):
with open(scenefile) as f:
scene_yaml = yaml.load(f)
for s in scene_yaml["scenes"].keys():
temp = scene_yaml["scenes"][s]
scene = HueScene(name=s)
scene.xy = temp["colors"]
scene.saturation = temp["saturation"]
scene.brightness = temp["brightness"]
self.scenes[s] = scene
def setCurrent(self, attribute, value, transition=None):
if attribute in self.ATTRIBUTES:
light_names = self.bridge.get_light_objects('name')
for light in self.GROUP_LIGHTS:
tt = light_names[light].transitiontime
light_names[light].transitiontime = 1
setattr(light_names[light], attribute, value)
light_names[light].transitiontime = tt
def setBrightness(self, value):
light_names = self.bridge.get_light_objects('name')
for light in self.GROUP_LIGHTS:
tt = light_names[light].transitiontime
light_names[light].transitiontime = 1
light_names[light].brightness = value
light_names[light].transitiontime = tt
def setXValue(self, value, maximum=127):
light_names = self.bridge.get_light_objects('name')
for light in self.GROUP_LIGHTS:
xvalue = float(value) / maximum
yvalue = light_names[light].xy[1]
light_names[light].xy = (xvalue, yvalue)
def setYValue(self, value, maximum=127):
light_names = self.bridge.get_light_objects('name')
for light in self.GROUP_LIGHTS:
yvalue = float(value) / maximum
xvalue = light_names[light].xy[1]
light_names[light].xy = (xvalue, yvalue)
def toggleLight(self):
light_names = self.bridge.get_light_objects('name')
for light in self.GROUP_LIGHTS:
tt = light_names[light].transitiontime
light_names[light].transitiontime = 4
light_names[light].on ^= True
light_names[light].transitiontime = tt
return light_names[light].on
class HuePlay(object):
DEFAULT_GROUP = 'Gaming'
GROUP_LIGHTS = [
u'RP Lamp 1',
u'RP Lamp 2',
]
ATTRIBUTES = [ 'on', 'xy', 'saturation', 'brightness', 'transitiontime' ]
def __init__(self, address):
self.bridge = Bridge(address)
self.bridge.connect()
self.scenes = {}
def initializeGroups(self, group=DEFAULT_GROUP, lights=GROUP_LIGHTS):
if self.bridge.get_group(self.DEFAULT_GROUP) is not None:
self.bridge.delete_group(self.DEFAULT_GROUP)
self.bridge.create_group(self.DEFAULT_GROUP, self.GROUP_LIGHTS)
def setScene(self, name):
if name in self.scenes.keys():
light_names = self.bridge.get_light_objects('name')
for light in self.GROUP_LIGHTS:
light_names[light].on = True
light_names[light].xy = self.scenes[name].xy
light_names[light].saturation = self.scenes[name].saturation
light_names[light].brightness = self.scenes[name].brightness
self.last_scene = name
def loadScenes(self, scenefile='scenes/scenes.yaml'):
with open(scenefile) as f:
scene_yaml = yaml.load(f)
for s in scene_yaml["scenes"].keys():
temp = scene_yaml["scenes"][s]
scene = HueScene(name=s)
scene.xy = temp["colors"]
scene.saturation = temp["saturation"]
scene.brightness = temp["brightness"]
self.scenes[s] = scene
def setCurrent(self, attribute, value, transition=None):
if attribute in self.ATTRIBUTES:
light_names = self.bridge.get_light_objects('name')
for light in self.GROUP_LIGHTS:
tt = light_names[light].transitiontime
light_names[light].transitiontime = 1
setattr(light_names[light], attribute, value)
light_names[light].transitiontime = tt
def setBrightness(self, value):
light_names = self.bridge.get_light_objects('name')
for light in self.GROUP_LIGHTS:
tt = light_names[light].transitiontime
light_names[light].transitiontime = 1
light_names[light].brightness = value
light_names[light].transitiontime = tt
def setXValue(self, value, maximum=127):
light_names = self.bridge.get_light_objects('name')
for light in self.GROUP_LIGHTS:
xvalue = float(value)/maximum
yvalue = light_names[light].xy[1]
light_names[light].xy = (xvalue, yvalue)
def setYValue(self, value, maximum=127):
light_names = self.bridge.get_light_objects('name')
for light in self.GROUP_LIGHTS:
yvalue = float(value)/maximum
xvalue = light_names[light].xy[1]
light_names[light].xy = (xvalue, yvalue)
def toggleLight(self):
light_names = self.bridge.get_light_objects('name')
for light in self.GROUP_LIGHTS:
tt = light_names[light].transitiontime
light_names[light].transitiontime = 4
light_names[light].on ^= True
light_names[light].transitiontime = tt
return light_names[light].on
class PartyTime(Thread):
def __init__(self, *args, **kwargs):
super(PartyTime, self).__init__(*args, **kwargs)
self.daemon = True
hue_config = config['Hue']
self.bridge = Bridge(hue_config['bridge-ip'])
self.bridge.connect()
# Setup lights
self.light_group = hue_config['light-group']
self.group_name = hue_config['light-group-name']
self.bridge.create_group(self.group_name, self.light_group)
self.base_light_state = {
'bri': 120,
'sat': 0,
'transitiontime': 10,
'on': True,
}
self.enabled = False
self.base_lights()
self.start()
def base_lights(self):
self.bridge.set_group(self.group_name, self.base_light_state)
time.sleep(1)
def hue_point(self, color):
"""
Splits the spectrum up by the number of lights in the light group to
get an evenly spaced rainbow of colors
"""
color = int(color % len(self.light_group))
hue = 65535 / len(self.light_group)
hue = hue * color
return hue
def party_on(self):
"""
Sets a random light, the next step in the rainbow, defined using the
hue_point method
"""
random.shuffle(self.light_group)
params = {'sat': 254, 'bri': 254, 'transitiontime': 1}
i = 0
while self.enabled:
params['hue'] = self.hue_point(i)
self.bridge.set_light(random.choice(self.light_group), params)
time.sleep(0.05)
i += 1
def party_off(self):
# reset to base state
base = dict(self.base_light_state)
base['transitiontime'] = 3
for light in self.light_group:
self.bridge.set_light(light, base)
time.sleep(0.2)
self.base_lights()
def toggle(self):
self.enabled = not self.enabled
def run(self):
while True:
if self.enabled:
self.party_on()
else:
self.party_off()
time.sleep(0.1)
class PhilipsWrapper:
def __init__(self, core):
bridge_ip = core.local_storage["module_storage"]["philips_hue"][
"Bridge-IP"]
self.bridge = Bridge(bridge_ip)
self.bridge.connect()
self.skills = core.skills
self.core = core
self.lights = self.bridge.lights
self.light_names = self.bridge.get_light_objects('name')
with open(core.path +
"/resources/module_configs.json") as module_config_file:
module_config = json.load(module_config_file)
self.color_adjustment = module_config["philips_hue"][
"color_adjustment"]
if bridge_ip == "":
core.say(
"Um Philips HUE zu nutzen, musst du zuerst die Bridge IP im System eintragen. Besuche dafür die Einrichtungswebsite."
)
return
def wrapper(self, text):
lights = self.Logic.get_lights(text, self)
# self.core.say("Okay.")
if 'aus' in text:
self.light_off(lights)
return
elif 'an' in text:
# toDo: distinguish between different times
self.light_on(lights)
return
elif 'heller' in text:
if 'viel' in text:
self.inc_dec_brightness(lights, 140)
else:
self.inc_dec_brightness(lights, 60)
return
elif 'wärmer' in text:
self.set_light_color_temp(lights, 25)
elif 'kälter' in text:
self.set_light_color_temp(lights, -25)
elif 'dunkler' in text or 'dimm' in text:
if 'viel' in text:
self.inc_dec_brightness(lights, -140)
else:
self.inc_dec_brightness(lights, -60)
return
elif 'hell' in text:
self.set_light_brightness(lights, 254)
return
elif 'prozent' in text or '%' in text:
self.set_light_brightness(
lights, self.Logic.get_percent_as_brightness(text))
return
else:
for item in colors:
if item in text:
self.light_change_color(lights, text)
return
self.core.say(
'Leider habe ich nicht verstanden, was ich mit dem Licht machen soll.'
)
def set_light_powerstate(self, lights, powerstate):
if powerstate is None and (type(lights) is type("")
or len(lights) <= 1):
if self.bridge.get_light(lights, 'on'):
powerstate = 'off'
else:
powerstate = 'on'
if powerstate == 'on':
self.bridge.set_light(lights, 'on', True)
elif powerstate == 'off':
self.bridge.set_light(lights, 'on', False)
else:
return 'err'
def get_light_powerstate(self, light):
if light is None:
light = self.lights[0]
return self.bridge.get_light(light, 'on')
def light_on(self, lights, change_brightness=True):
if type(lights) != type(
[]) and type(lights) != type("") and type(lights) != 1:
lights = self.bridge.get_light(lights)
# toDO: possibility that lights is an array of Objects
self.bridge.set_light(lights, 'on', True)
if change_brightness:
self.bridge.set_light(lights, 'bri', 254)
if self.color_adjustment:
now = datetime.now()
# add sunrise and sunset
self.bridge.set_light(
lights,
'sat',
)
def light_off(self, lights):
self.bridge.set_light(lights, 'on', False)
def light_change_color(self, lights, text):
color = self.Logic.get_named_color(text)
if color is not None:
self.light_on(lights)
self.bridge.set_light(lights, 'xy', [color[0], color[1]])
# self.bridge.set_light(lights, 'bri', 254)
else:
self.core.say(
'Es tut mir leid, leider konnte ich nicht heraus filtern, welche Farbe du wünschst.'
)
def inc_dec_ct(self, lights, value):
for light in lights:
ct = light.ct + value
if ct > 254:
ct = 254
elif ct < 0:
ct = 0
self.bridge.set_light(light, 'ct', ct)
def set_light_color_temp(self, lights, value):
self.bridge.set_light(lights, 'sat', int(value))
def set_light_brightness(self, lights, value):
self.bridge.set_light(lights, 'bri', int(value))
def inc_dec_brightness(self, lights, value):
if type(lights[0]) is not type("") and type(lights[0]) is not type(1):
for i in range(len(lights)):
lights[i] = lights[i].id
for light in lights:
brightness = self.bridge.get_light(light, 'bri') + value
if brightness > 254:
brightness = 254
if brightness < 0:
brightness = 0
self.bridge.set_light(light, 'bri', brightness)
def get_light_in_json(self, light_name):
tempLight = self.bridge.get_light(light_name)
return {
"on": self.bridge.get_light(tempLight["name"], 'on'),
"brightness": self.bridge.get_light(tempLight["name"], 'bri'),
"name": tempLight["name"]
}
def get_lights_in_json(self, order_by_id=False):
output = {}
light_objects = self.bridge.get_light_objects('id')
if order_by_id:
for item in light_objects:
output[item] = {
'id': item,
'name': light_objects[item].name,
'on': light_objects[item].on,
'brightness': light_objects[item].brightness,
'color': light_objects[item].hue,
'saturation': light_objects[item].saturation,
'ct': light_objects[item].ct
}
return output
else:
for item in light_objects:
output[light_objects[item].name] = {
'id': item,
'name': light_objects[item].name,
'on': light_objects[item].on,
'brightness': light_objects[item].brightness,
'color': light_objects[item].hue,
'saturation': light_objects[item].saturation,
'ct': light_objects[item].ct
}
return output
def is_light_in_system(self, light_name):
for light_n in self.light_names:
if light_n == light_name:
return True
return False
def create_group(self, name, lights):
for light in lights:
if format(light) == format("String"):
lights.remove(light)
lights.append(self.bridge.get_light(light).id)
self.bridge.create_group(name, lights)
def rename_group(self, group_name, new_name):
self.bridge.set_group(group_name, 'name', new_name)
def change_lights_in_group(self, group_name, lights):
for light in lights:
if format(light) == format("String"):
lights.remove(light)
lights.append(self.bridge.get_light(light).id)
self.bridge.set_group(group_name, 'lights', lights)
def get_groups(self):
return self.bridge.get_group()
def get_group(self, group_name):
is_on = True
group = self.bridge.get_group(group_name)
for light in group["lights"]:
if not light["on"]:
is_on = False
group["on"] = is_on
print(group)
return group
