class YeetBulb:
def __init__(self, name, ip):
self.name = name
self.ip = ip
self.bulb = Bulb(self.ip, effect="smooth", duration=750, auto_on=True)
self.properties = self.bulb.get_properties()
def __getitem__(self, key):
return getattr(self, key)
def turnoff(self):
self.bulb.turn_off()
def turnon(self):
self.bulb.turn_on()
def toggle(self):
self.bulb.toggle()
def loadPreset(self, preset):
if os.path.isfile(preset):
with open(preset, 'r') as f:
config = json.load(f)
if 'preset' in config:
preset = config['preset']
if ('rgb' in preset):
try:
self.bulb.set_rgb(preset['rgb'][0], preset['rgb'][1],
preset['rgb'][2])
except:
print('not supported by bulb')
if ('hsv' in preset):
try:
self.bulb.set_hsv(preset['hsv'][0], preset['hsv'][1],
preset['hsv'][2])
except:
print('not supported by bulb')
if ('color_temp' in preset):
try:
self.bulb.set_color_temp(preset['color_temp'])
except:
print('not supported by bulb')
if ('brightness' in preset):
try:
self.bulb.set_brightness(preset['brightness'])
except:
print('not supported by bulb')
if ('color_temp' in preset):
try:
self.bulb.set_color_temp(preset['color_temp'])
except:
print('not supported by bulb')
else:
print('File not found: ' + preset)
def updateProperties(self):
self.properties = self.bulb.get_properties()
class WhiteBulb:
def __init__(self, ip):
self.bulb = Bulb(ip)
def power_on(self):
self.bulb.turn_on()
print("Turning the light on...")
def power_off(self):
self.bulb.turn_off()
print("Turning the light off...")
def power_toggle(self):
self.bulb.toggle()
print("Toggling the light...")
def set_brightness(self, bright):
self.bulb.set_brightness(bright)
print("Setting the brightness to ", bright, "%...")
def set_temperature(self, temp):
self.bulb.set_color_temp(temp)
print("Setting the temperature to ", temp, "K...")
def get_status(self):
status = self.bulb.get_properties()
power = status['power']
bright = status['bright']
temp = status['ct']
rgb = status['rgb']
r, g, b = [rgb[i:i + 3] for i in range(0, len(rgb), 3)]
rgb = "(" + r + ", " + g + ", " + b + ")"
print("Power: {}\nBrighness: {}%\nTemperature: {}K\nRGB: {}".format(
power, bright, temp, rgb))
def main():
print "Started..."
time.sleep(1)
#pygame.mixer.init()
#pygame.mixer.music.load("/home/pi/Yeelight/tma.mp3")
#pygame.mixer.music.set_volume(1.0)
#pygame.mixer.music.play()
#pygame.mixer.music.pause()
bulb = Bulb("10.0.0.1", auto_on=True)
bulb.turn_on()
time.sleep(1)
bulb.turn_off()
#bulb.start_music(666, "10.0.0.2")
#bulb.start_music()
print(bulb.get_properties())
ser = serial.Serial(
"/dev/ttyACM0",
9600) #change ACM number as found from ls /dev/tty/ACM*
ser.baudrate = 9600
window = []
while True:
percentage = ser.readline()
sanitized = re.sub("[^0-9]", "", percentage)
if sanitized:
window = avg_brightness(bulb, int(sanitized), window, 5)
time.sleep(0.200)
def test_ip(i):
try:
ip = f'192.168.1.{i}'
b = Bulb(ip)
print(b.get_properties())
return ip
except BulbException as e:
return None
def discover(self, command=None):
if self.devlist:
LOGGER.info("Using manually specified device list")
for bulb_info in self.devlist:
LOGGER.debug(bulb_info)
address = bulb_info['address'][:14]
try:
bulb = Bulb(bulb_info['ip'])
bulb_properties = bulb.get_properties()
except Exception as ex:
LOGGER.error(
'Failed to connect to the bulb at {} {}'.format(
bulb_info['ip'], ex))
continue
name = bulb_info['name']
if name is None:
name = 'YeeLight ' + address[10:14]
if not address in self.nodes:
LOGGER.info('Adding YeeLight bulb id: {}, name: {}'.format(
address, name))
self.addNode(
YeeColorBulb(self, self.address, address, name, bulb))
else:
for bulb_info in discover_bulbs():
LOGGER.debug(bulb_info)
address = str(bulb_info['capabilities']['id'])[-14:]
try:
bulb = Bulb(bulb_info['ip'])
bulb_properties = bulb.get_properties()
except Exception as ex:
LOGGER.error(
'Failed to connect to the bulb at {} {}'.format(
bulb_info['ip'], ex))
continue
name = bulb_properties['name']
if name is None:
name = 'YeeLight ' + address[10:14]
if not address in self.nodes:
LOGGER.info('Adding YeeLight bulb id: {}, name: {}'.format(
bulb_info['capabilities']['id'], name))
self.addNode(
YeeColorBulb(self, self.address, address, name, bulb))
def control_yeelight(status):
# 当前局域网存在灯设备
if len(discover_bulbs()):
# 连接到yeelight
bulb = Bulb(bulb_ip)
dic = bulb.get_properties()
# {'sat': '100', 'color_mode': '2', 'ct': '6500', 'delayoff': '0', 'power': 'on', 'rgb': '16711680', 'hue': '359', 'music_on': '0', 'bright': '82', 'name': None, 'flowing': '0'}
if dic.has_key('power'):
power = dic.get('power')
if bulb and status == True and power == 'off':
bulb.turn_on()
else:
print("未找到灯")
def bulb_finder():
global bulb_data, b_ip, b_port, b_bulb
while True:
try:
bulb_data = discover_bulbs()
if bulb_data:
b_ip = bulb_data[-1]['ip']
b_port = bulb_data[-1]['port']
b_bulb = Bulb(b_ip, effect="smooth", duration=1000)
if b_bulb:
print('Connected')
print(b_bulb.get_properties())
break
print('cannot find')
time.sleep(5)
except Exception as e:
print('Error discovering bulbs', e)
def blend_hsv(h: int, s: int, v: int, this_bulb: yeelight.Bulb):
"""Doesn't work, get_properties always returns the same hsv"""
old_hsv = this_bulb.get_properties(
requested_properties=['hue', 'sat', 'bright', 'rgb'])
old_h: int = int(old_hsv['hue'])
old_s: int = int(old_hsv['sat'])
old_v: int = int(old_hsv['bright'])
logging.info(f'Old hsv: {old_h}, {old_s}, {old_v}')
if old_h > 128:
blended_h: int = int((h + old_h) / 2)
else:
blended_h = h # new/old value has probably rolled over to 0, don't bother calculating average
blended_s: int = int((s + old_s) / 2)
blended_v: int = int((v + old_v) / 2)
logging.info(f'Blended hsv: {blended_h}, {blended_s}, {blended_v}')
return int(blended_h), int(blended_s), int(blended_v)
def main():
print('Welcome to fluxee by davidramiro')
print('Reading config...')
config = configparser.ConfigParser()
config.read('config.ini')
global static_brightness
bulb_count = int(config.get('general', 'LampCount'))
check_state = config.getboolean('general', 'CheckLampState')
static_brightness = config.getboolean('general', 'StaticBrightness')
default_brightness = int(config.get('general', 'BrightnessValue'))
for n in range(1, (bulb_count + 1)):
bulbs.append(config.get(str(n), 'ip'))
if config.get(str(n), 'MaxColorTemperature') == '':
maxtemps.append(6500)
else:
maxtemps.append(config.get(str(n), 'MaxColorTemperature'))
if config.get(str(n), 'MinColorTemperature') == '':
mintemps.append(1700)
else:
mintemps.append(config.get(str(n), 'MinColorTemperature'))
print('Initializing...')
for init_bulb in bulbs:
if init_bulb != '':
print('Initializing Yeelight at %s' % init_bulb)
bulb = Bulb(init_bulb)
if check_state is True:
state = bulb.get_properties(requested_properties=['power'])
if 'off' in state['power']:
print('Powered off. Ignoring Yeelight at %s' % init_bulb)
elif static_brightness is True:
print('Changing brightness of', init_bulb)
bulb.set_brightness(default_brightness)
else:
print('Turning on Yeelight at %s' % init_bulb)
bulb.turn_on()
if static_brightness is True:
bulb.set_brightness(default_brightness)
else:
bulb.set_brightness(100)
run(host='127.0.0.1', port=8080)
print('Thank you for using fluxee. Have a good one!')
collection = db["collection"]
arp_packet = scapy.ARP(pdst='192.168.0.1/24')
broadcast_packet = scapy.Ether(dst="ff:ff:ff:ff:ff:ff")
arp_broadcast_packet = broadcast_packet / arp_packet
answered_list = scapy.srp(arp_broadcast_packet, timeout=30, verbose=False)[0]
for element in answered_list:
client_dict = {"ip": element[1].psrc, "mac": element[1].hwsrc}
client_list.append(client_dict)
for client in client_list:
if (client["mac"][0:8] == '5c:e5:0c'):
check_status = Bulb(client["ip"])
power_status = check_status.get_properties()['power']
if power_status == 'on':
status = True
elif power_status == 'off':
status = False
bulbInDatabase = collection.find({"_id": client["ip"]})
publishOnce = bulbInDatabase.count() > 0
level = random.randint(1, 2)
if (publishOnce == False):
identified_bulbs = {
"_id": client["ip"],
"mac_address": client["mac"],
"status": status,
class Device(BaseDevice):
typesDevice = ["light"]
name = DEVICE_NAME
addConfig = AddDevice(
fields=False,
description=
"1. Through the original application, you must enable device management over the local network.\n2. Enter the ip-address of the device (it can be viewed in the same application)."
)
editConfig = EditDevice(address=True, fields=EditField(icon=True))
def __init__(self, *args, **kwargs):
super().__init__(**kwargs)
self.device = Bulb(self.coreAddress)
try:
values = self.device.get_properties()
self.minmaxValue = self.device.get_model_specs()
if (not look_for_param(self.values, "state")
and "power" in values):
val = "0"
if (values["power"] == "on"):
val = "1"
self.values.append(
DeviceElement(name="state",
systemName=self.systemName,
control=True,
high=1,
low=0,
type="binary",
icon="fas fa-power-off",
value=val))
if (not look_for_param(self.values, "brightness")
and "current_brightness" in values):
self.values.append(
DeviceElement(name="brightness",
systemName=self.systemName,
control=True,
high=100,
low=0,
type="number",
icon="far fa-sun",
value=values["current_brightness"]))
if (not look_for_param(self.values, "night_light")
and self.minmaxValue["night_light"] != False):
self.values.append(
DeviceElement(name="night_light",
systemName=self.systemName,
control=True,
high="1",
low=0,
type="binary",
icon="fab fa-moon",
value=values["active_mode"]))
if (not look_for_param(self.values, "color")
and values["hue"] != None):
self.values.append(
DeviceElement(name="color",
systemName=self.systemName,
control=True,
high=360,
low=0,
type="number",
icon="fab fa-medium-m",
value=values["hue"]))
if (not look_for_param(self.values, "saturation")
and values["sat"] != None):
self.values.append(
DeviceElement(name="saturation",
systemName=self.systemName,
control=True,
high=100,
low=0,
type="number",
icon="fab fa-medium-m",
value=values["sat"]))
if (not look_for_param(self.values, "temp") and "ct" in values):
self.values.append(
DeviceElement(name="temp",
systemName=self.systemName,
control=True,
high=self.minmaxValue["color_temp"]["max"],
low=self.minmaxValue["color_temp"]["min"],
type="number",
icon="fas fa-adjust",
value=values["ct"]))
super().save()
except Exception as e:
logger.warning(f"yeelight initialize error. {e}")
self.device = None
def update_value(self, *args, **kwargs):
values = self.device.get_properties()
state = look_for_param(self.values, "state")
if (state and "power" in values):
val = "0"
if (values["power"] == "on"):
val = "1"
saveNewDate(state, val)
brightness = look_for_param(self.values, "brightness")
if (brightness and "current_brightness" in values):
saveNewDate(brightness, values["current_brightness"])
mode = look_for_param(self.values, "night_light")
if (mode and "active_mode" in values):
saveNewDate(mode, values["active_mode"])
temp = look_for_param(self.values, "temp")
if (temp and "ct" in values):
saveNewDate(temp, values["ct"])
color = look_for_param(self.values, "color")
if (color and "hue" in values):
saveNewDate(color, values["hue"])
saturation = look_for_param(self.values, "saturation")
if (saturation and "sat" in values):
saveNewDate(saturation, values["sat"])
def get_value(self, name):
self.update_value()
return super().get_value(name)
def get_values(self):
self.update_value()
return super().get_values()
def set_value(self, name, status):
status = super().set_value(name, status)
if (name == "state"):
if (int(status) == 1):
self.device.turn_on()
else:
self.device.turn_off()
if (name == "brightness"):
self.device.set_brightness(int(status))
if (name == "temp"):
self.device.set_power_mode(PowerMode.NORMAL)
self.device.set_color_temp(int(status))
if (name == "night_light"):
if (int(status) == 1):
self.device.set_power_mode(PowerMode.MOONLIGHT)
if (int(status) == 0):
self.device.set_power_mode(PowerMode.NORMAL)
if (name == "color"):
self.device.set_power_mode(PowerMode.HSV)
saturation = look_for_param(self.values, "saturation")
self.device.set_hsv(int(status), int(saturation.get()))
if (name == "saturation"):
self.device.set_power_mode(PowerMode.HSV)
color = look_for_param(self.values, "color")
self.device.set_hsv(int(color.get()), int(status))
def get_All_Info(self):
self.update_value()
return super().get_All_Info()
import paho.mqtt.client as mqtt
from yeelight import Bulb
from pynput import keyboard
import time
import ssl
### Setting the lamps
lamp_1 = Bulb("192.168.1.16")
lamp_2 = Bulb("192.168.1.17")
lamp_1.set_name("Lamp 1")
lamp_2.set_name("Lamp 2")
lamp_1_properties = lamp_1.get_properties(
requested_properties=["power", "bright", "rgb", "name"])
lamp_2_properties = lamp_2.get_properties(
requested_properties=["power", "bright", "rgb", "name"])
### Logging function
def on_log(client, userdata, level, buf):
print("log : " + buf)
### Information about connection
### ==> OK or KO with returned code
def on_connect(client, userdata, flags, rc):
if rc == 0:
print("Connected OK")
else:
print("Bad connection, returned code : " + str(rc))
async def getLightStatus(self, light):
bulb = Bulb(self.lights[0]['ip'])
bulbProps = bulb.get_properties()
return bulbProps
class Yeelight(AbstractLight):
def __init__(self, ip: str, supports: List[str]) -> None:
"""
@type ip: The ip of the light bulb
@type supports: A list of all methods this light bulb supports
"""
super().__init__(1)
self.bulb = Bulb(ip)
self.bulb.effect = "smooth"
self.bulb.duration = 1000
self.bulb.turn_on()
self.supports = supports
properties = self.bulb.get_properties()
# We could also parse rgb from properties, however the encoding does not seem trivial.
self.previous_rgb = [0, 0, 0]
self.previous_brightness = float(properties["current_brightness"]) / 100 # Scale from [0, 100] to [0, 1]
self.previous_power = properties["power"]
self.next_message = 0 # Tracks the last time we send a message, used for rate limiting
def write(self):
# Check if we should back off
if time.time() < self.next_message:
return
[red, green, blue, brightness] = self.leds[0] # Get the desired light state values.
send_messages_count = 0 # Track the amount of messages we send during this write.
try:
# Only update the brightness if the difference is more than one percent
if abs(self.previous_brightness - brightness) > 0.01:
# Turn the light off when brightness approaches zero and it is turned on
if brightness < 0.01:
if self.previous_power == "on":
self.bulb.turn_off()
self.previous_power = "off"
send_messages_count += 1
else:
# Turn the light on in case it was previously turned off
if self.previous_power == "off":
self.bulb.turn_on()
self.previous_power = "on"
send_messages_count += 1
# Update the brightness
self.bulb.set_brightness(brightness * 100) # Scale from [0, 1] to [0, 100]
send_messages_count += 1
# Always update the brightness, even in case we turned it off, as the light will
# do this internally.
self.previous_brightness = brightness
rgb = [int(255 * c) for c in [red, green, blue]]
# Prevent updating the color if it either didn't change or we're backing off
if self.previous_rgb != rgb and "set_rgb" in self.supports:
self.previous_rgb = rgb
self.bulb.set_rgb(*rgb)
send_messages_count += 1
except BulbException as e:
print(e)
finally:
# Make sure we back off for #send_messages seconds to prevent hitting the rate limiting cap.
if send_messages_count > 0:
self.next_message = time.time() + send_messages_count
@staticmethod
def from_discover_bulbs_dict(dict: dict):
return Yeelight(dict["ip"], dict["capabilities"]["support"])
from yeelight import Bulb import sys ip = sys.argv[1] bulb = Bulb(ip) result = bulb.get_properties() print(result)
if blink_red < 0:
blink_red = 0
if blink_green < 0:
blink_green = 0
for x in range(7):
stick.set_color(channel=0, red=blink_red, green=blink_green, blue=blink_blue, index=x)
except:
pass
if __name__ == '__main__':
yeelight = Bulb('10.70.2.8', duration=300)
properties = yeelight.get_properties()
if properties['music_on'] == '0':
yeelight.start_music()
while True:
try:
color = get_color()
darkness_ratio = color['dark_ratio']
color = color['rgb']
# hue
_thread.start_new_thread(update_hue, (color, darkness_ratio))
# Yeelight
_thread.start_new_thread(update_yeelight, (yeelight, color, darkness_ratio))
def status(self, address):
ip = self.getIP(address)
bulb = Bulb(ip)
prp = bulb.get_properties()
return prp['power']
def do_REQUEST(self):
parsed = urlparse(self.path)
qs = parse_qs(parsed.query)
try:
action = qs['action']
if (action[0] == "set"):
state = qs['state']
pin = qs['pin']
delay = qs['delay']
elif (action[0] == "get"):
pin = qs['pin']
elif (action[0] == "get_bulb_state"):
id = qs['id']
elif (action[0] == "set_bulb_state"):
id = qs['id']
state = qs['state']
elif (action[0] == "bulb_color"):
id = qs['id']
red = qs['r']
green = qs['g']
blue = qs['b']
elif (action[0] == 'set_rel_state'):
id = qs['id']
pin = qs['pin']
state = qs['state']
dat = qs['dat']
except KeyError:
message = "<p>No commands processed</p>"
else:
message = "."
if (action[0] == "set" and state in (["1"], ["0"])
and int(pin[0]) in (GPIO_OUT_LIST) and int(delay[0]) == 0):
GPIO.output(int(pin[0]), state == ["1"])
message = "OK|SET|%d|%d" % (int(pin[0]), int(state[0]))
elif (action[0] == "set" and state in (["1"], ["0"])
and int(pin[0]) in (GPIO_OUT_LIST) and int(delay[0]) > 0):
message = "OK|SETDELAY|%d|%d|%d" % (int(pin[0]), int(
state[0]), int(delay[0]))
GPIO.output(int(pin[0]), state == ["1"])
time.sleep(int(delay[0]))
GPIO.output(int(pin[0]), state == ["0"])
message = "OK|SETDELAY|%d|%d" % (int(pin[0]), int(state[0]))
elif (action[0] == "get" and int(pin[0]) in (GPIO_OUT_LIST)):
message = "OK|GET|%d|%s" % (int(pin[0]), GPIO.input(int(
pin[0])))
elif (action[0] == "bulb" and state[0] == "1"
and id[0] in (BULB_DICT)):
bulb = Bulb(BULB_DICT[id[0]])
bulb.turn_on()
message = "OK|BULB_ON|%s" % (id[0])
elif (action[0] == "get_bulb_state" and id[0] in (BULB_DICT)):
bulb = Bulb(BULB_DICT[id[0]])
status = bulb.get_properties()
message = "OK|%s|%s" % (id[0], status.get('power'))
elif (action[0] == "set_bulb_state" and state[0] == "0"
and id[0] in (BULB_DICT)):
bulb = Bulb(BULB_DICT[id[0]])
bulb.turn_off()
message = "OK|BULB_OFF|%s" % (id[0])
elif (action[0] == "bulb_color" and id[0] in (BULB_DICT)):
bulb = Bulb(BULB_DICT[id[0]])
bulb.set_rgb(int(red[0]), int(green[0]), int(blue[0]))
elif (action[0] == "get_rel"):
message = sel_tab(SQL_GET_REL)
elif (action[0] == "get_temp"):
message = sel_tab(SQL_GET_TEMP)
elif (action[0] == "set_rel_state"):
message = upd_rel_state(state, dat, id, pin)
else:
message = "ERR|NO_ACTION|NO_PIN"
self.send_response(200)
# Custom headers, if need be
self.send_header('Content-type', 'text/html')
self.end_headers()
# Custom body
self.wfile.write(bytes(message, "utf8"))
return
parser.add_argument('-b', '--brightness', help='set the brightness', type=int)
onoff = parser.add_mutually_exclusive_group()
onoff.add_argument('--on', help='turn on the light', action="store_true")
onoff.add_argument('--off', help='turn off the light', action="store_true")
colors = parser.add_mutually_exclusive_group()
colors.add_argument('-t', '--temp', help='set the white color temp', type=int)
colors.add_argument('-c',
'--color',
help='set the rgb color',
type=valid_color)
args = parser.parse_args()
for bulbaddr in args.bulbs:
bulb = Bulb(bulbaddr)
if args.switch:
status = bulb.get_properties()
if status['power'] == "off":
bulb.turn_on()
else:
bulb.turn_off()
if args.on:
bulb.turn_on()
elif args.off:
bulb.turn_off()
if args.brightness is not None:
bulb.set_brightness(args.brightness)
if args.temp is not None:
bulb.set_color_temp(args.temp)
elif args.color is not None:
bulb.set_rgb(args.color[0], args.color[1], args.color[2])
Version: 0.0.1
https://github.com/Blahnacles
"""
# Setup
# Imports
from tkinter import *
# Hardcoding IP for now, as discover_bulbs() does not work
bedroom_ip = "192.168.1.122"
update_rate = 2000 # UI refresh rate in ms
# TODO set static ip
import yeelight
from yeelight import Bulb
global bedroom
bedroom = Bulb(bedroom_ip)
bedroom.start_music(port=5555)
bedroom_data = bedroom.get_properties()
# setup window
window = Tk()
window.title("PySwitch")
#window.geometry('800x480')
# setup buttons & labels
switch_text = "+"
switch_bg = "black"
switch_fg = "orange"
if bedroom_data['power'] == 'on':
switch_text = "-"
switch_bg = "orange"
switch_fg = "black"
class LedLightYeeLight(LedLight):
def __init__(self, name, ipAddrOrName=None):
if ipAddrOrName is None:
ipAddrOrName = name
self.bulb = Bulb(ipAddrOrName)
self.name = name
try:
self.bulb.set_name(name)
except Exception as exc:
print "Caught exception socket.error : %s" % exc
# Send an RGB message
def sendRGB(self, red, green, blue):
try:
self.bulb.set_rgb(red, green, blue)
except Exception as exc:
print "Caught exception socket.error : %s" % exc
# Send a white message
def sendWhite(self, white):
try:
self.bulb.set_color_temp(5000)
self.bulb.set_brightness(white)
except Exception as exc:
print "Caught exception socket.error : %s" % exc
def turnOff(self):
try:
return self.bulb.turn_off()
except Exception as exc:
print "Caught exception socket.error : %s" % exc
def turnOn(self):
try:
self.bulb.turn_on()
except Exception as exc:
print "Caught exception socket.error : %s" % exc
def isOn(self):
try:
return self.bulb.get_properties()['power'] == 'on'
except Exception as exc:
print "Caught exception socket.error : %s" % exc
def getWhite(self):
try:
properties = self.bulb.get_properties()
if (properties['color_mode'] == '2'):
return int(properties['bright'])
else:
return -1
except Exception as exc:
print "Caught exception socket.error : %s" % exc
# comment
def getRGB(self):
try:
properties = self.bulb.get_properties()
if (properties['color_mode'] == '1'):
rgb = int(properties['rgb'])
return [(rgb >> 16) & 255, (rgb >> 8) & 255, rgb & 255]
else:
return -1
except Exception as exc:
print "Caught exception socket.error : %s" % exc
class YeelightDevice(Device):
"""Yeelight device type."""
def __init__(self, adapter, _id, dev_dict):
"""
Initialize the object.
adapter -- the Adapter managing this device
_id -- ID of this device
dev_dict -- the device object to initialize from
"""
Device.__init__(self, adapter, _id)
self._type = ['OnOffSwitch', 'Light']
self.bulb = Bulb(dev_dict['ip'])
self.description = dev_dict['capabilities']['model']
self.name = dev_dict['capabilities']['name']
if not self.name:
self.name = self.description
self.support = dev_dict['capabilities']['support'].split(' ')
self.update_properties()
if self.is_color():
self._type.append('ColorControl')
self.properties['color'] = YeelightProperty(
self, 'color', {
'@type': 'ColorProperty',
'label': 'Color',
'type': 'string',
}, self.color())
elif self.is_variable_color_temp():
self._type.append('ColorControl')
self.properties['colorTemperature'] = YeelightProperty(
self, 'colorTemperature', {
'@type': 'ColorTemperatureProperty',
'label': 'Color Temperature',
'type': 'integer',
'unit': 'kelvin',
'minimum': 1700,
'maximum': 6500,
}, self.color_temp())
if self.is_dimmable() and not self.is_color():
self.properties['level'] = YeelightProperty(
self, 'level', {
'@type': 'BrightnessProperty',
'label': 'Brightness',
'type': 'integer',
'unit': 'percent',
'minimum': 0,
'maximum': 100,
}, self.brightness())
self.properties['on'] = YeelightProperty(self, 'on', {
'@type': 'OnOffProperty',
'label': 'On/Off',
'type': 'boolean',
}, self.is_on())
if self.is_color():
self.type = 'onOffColorLight'
elif self.is_variable_color_temp():
if self.is_dimmable():
self.type = 'dimmableColorLight'
else:
self.type = 'onOffColorLight'
elif self.is_dimmable():
self.type = 'dimmableLight'
else:
self.type = 'onOffLight'
t = threading.Thread(target=self.poll)
t.daemon = True
t.start()
def poll(self):
"""Poll the device for changes."""
while True:
time.sleep(_POLL_INTERVAL)
self.update_properties()
for prop in self.properties.values():
prop.update()
def update_properties(self):
"""Update the cached properties."""
try:
self.bulb_properties = self.bulb.get_properties()
except socket.error:
pass
def is_dimmable(self):
"""Determine whether or not the light is dimmable."""
return 'set_bright' in self.support
def is_color(self):
"""Determine whether or not the light is color-changing."""
return 'set_rgb' in self.support and 'set_hsv' in self.support
def is_variable_color_temp(self):
"""Determine whether or not the light is color-temp-changing."""
return 'set_ct_abx' in self.support
def is_on(self):
"""Determine whether or not the light is on."""
return self.bulb_properties['power'] == 'on'
def color_temp(self):
"""Determine the current color temperature."""
return int(self.bulb_properties['ct'])
def color(self):
"""Determine the current color of the light."""
mode = int(self.bulb_properties['color_mode'])
if mode == 1:
# RGB mode
return '#{:06X}'.format(int(self.bulb_properties['rgb']))
elif mode == 3:
# HSV mode
return hsv_to_rgb(int(self.bulb_properties['hue']),
int(self.bulb_properties['sat']),
int(self.bulb_properties['bright']))
else:
# Color temperature mode
return '#000000'
def brightness(self):
"""Determine the current brightness of the light."""
return int(self.bulb_properties['bright'])
Updated: 12/02/2020
Version: 0.0.1
https://github.com/Blahnacles
To access on local machine: http://192.168.1.106:5000/api
"""
# imports
from flask import Flask, jsonify, request, escape
import yeelight, json
from yeelight import Bulb
# setup
# Hardcoding IP for now, as discover_bulbs() does not work
bedroom_ip = "192.168.1.122"
bedroom = Bulb(bedroom_ip)
if bedroom.get_properties()['music_on']== '0':
try:
bedroom.start_music(port=5555)
except yeelight.BulbException:
pass
app = Flask(__name__)
@app.route("/api", methods=['GET','POST','PUT','DELETE'])
def handle():
responseBool = False
if request.method == 'GET':
return json.dumps(Bulb(bedroom_ip).get_properties())
elif request.method == 'POST':
try:
bright = int(request.form['brightness'])
