def setup_platform(hass, config, add_entities, discovery_info=None):
"""Set up the Flux lights."""
lights = []
light_ips = []
for ipaddr, device_config in config.get(CONF_DEVICES, {}).items():
device = {}
device["name"] = device_config[CONF_NAME]
device["ipaddr"] = ipaddr
device[CONF_PROTOCOL] = device_config.get(CONF_PROTOCOL)
device[ATTR_MODE] = device_config[ATTR_MODE]
device[CONF_CUSTOM_EFFECT] = device_config.get(CONF_CUSTOM_EFFECT)
light = FluxLight(device)
lights.append(light)
light_ips.append(ipaddr)
if not config.get(CONF_AUTOMATIC_ADD, False):
add_entities(lights, True)
return
# Find the bulbs on the LAN
scanner = BulbScanner()
scanner.scan(timeout=10)
for device in scanner.getBulbInfo():
ipaddr = device["ipaddr"]
if ipaddr in light_ips:
continue
device["name"] = f"{device['id']} {ipaddr}"
device[ATTR_MODE] = None
device[CONF_PROTOCOL] = None
device[CONF_CUSTOM_EFFECT] = None
light = FluxLight(device)
lights.append(light)
add_entities(lights, True)
def main():
# init logger
logger = logging.getLogger('homekit-flux-led')
formatter = logging.Formatter('[%(levelname)s %(asctime)s]: %(message)s')
ch = logging.StreamHandler()
ch.setFormatter(formatter)
logger.addHandler(ch)
# parse cli-arguments
parser = argparse.ArgumentParser()
parser.add_argument(
'-v',
'--verbose',
help='DEBUG logging mode',
action='store_true',
)
args = parser.parse_args()
# set loggin level
if args.verbose:
logger.setLevel(logging.DEBUG)
logger.info('Logging level: DEBUG')
else:
logger.setLevel(logging.INFO)
logger.info('Logging level: INFO')
# scan for bulbs
logger.debug('Scanning for lightbulbs')
scanner = BulbScanner()
scanner.scan()
logger.debug(f'Found lightbulbs:')
logger.debug(scanner.found_bulbs)
# initialize AccessoryServer
logger.debug('Create HomeKit-AccessoryServer...')
driver = AccessoryDriver()
bridge = Bridge(driver, 'MagicHome')
logger.debug('HomeKit-AccessoryServer created successful.')
for bulb in scanner.found_bulbs:
# add bulbs to bridge
logger
bridge.add_accessory(
FluxLED(
driver,
bulb['id'],
bulb['ipaddr'],
logger=logger,
), )
# add bridge to the driver
driver.add_accessory(bridge)
try:
# start the server
logger.info('Start server...')
driver.start()
except KeyboardInterrupt:
logger.info('Stopping server...')
driver.stop()
def scan_bulb():
scanner = BulbScanner()
scanner.scan()
print scanner.found_bulbs
ipaddr = scanner.found_bulbs[0]['ipaddr']
return ipaddr
def main():
# Find the bulb on the LAN
scanner = BulbScanner()
scanner.scan(timeout=4)
# Specific ID/MAC of the bulb to set
bulb_info = scanner.getBulbInfoByID('ACCF235FFFFF')
if bulb_info:
bulb = WifiLedBulb(bulb_info['ipaddr'])
color_time = 5 # seconds on each color
red = (255, 0, 0)
orange = (255, 125, 0)
yellow = (255, 255, 0)
springgreen = (125, 255, 0)
green = (0, 255, 0)
turquoise = (0, 255, 125)
cyan = (0, 255, 255)
ocean = (0, 125, 255)
blue = (0, 0, 255)
violet = (125, 0, 255)
magenta = (255, 0, 255)
raspberry = (255, 0, 125)
colorwheel = [
red, orange, yellow, springgreen, green, turquoise, cyan, ocean,
blue, violet, magenta, raspberry
]
# use cycle() to treat the list in a circular fashion
colorpool = cycle(colorwheel)
# get the first color before the loop
color = next(colorpool)
while True:
bulb.refreshState()
# set to color and wait
# (use non-persistent mode to help preserve flash)
bulb.setRgb(*color, persist=False)
time.sleep(color_time)
#fade from color to next color
next_color = next(colorpool)
crossFade(bulb, color, next_color)
# ready for next loop
color = next_color
else:
print "Can't find bulb"
def discover(self, *args, **kwargs):
_success = False
try:
LOGGER.info('Discovering MagicHome LED Controllers...')
_scanner = BulbScanner()
_scanner.scan(timeout=5)
_devices = _scanner.getBulbInfo()
LOGGER.info('%i bulbs found. Checking status and adding to ISY', len(_devices))
for d in _devices:
self._addNode(d)
_success = True
except Exception as ex:
LOGGER.error('Error running magichome discovery (%s)', str(ex))
try:
_items = 0
self.discoveryTries = 0
_params = self.polyConfig['customParams']
for key,value in _params.items():
_key = key.lower()
if _key.startswith('led'):
_items += 1
try:
if 'ip' in value and 'mac' in value:
_value = json.loads(value)
_ip = _value['ip']
_mac = _value['mac'].lower().replace(':','')
d = {'ipaddr': _ip, 'id': _mac}
self._addNode(d)
except Exception as ex:
LOGGER.error('Error adding node from Polyglot configuration (%s): %s', str(value), str(ex))
if _items == 0:
LOGGER.info('NOTE: LED Controllers can be specified for addition even if not detected via discovery. Add a custom configuration parameter to Polyglot for each LED controller with a key starting with "LED". The value should be in the following format, note the use of double quotes: {"ip":"192.168.0.84", "mac":"F0FEAF241937"} "mac" is the MAC address without colons.')
except Exception as ex:
LOGGER.error('Error processing custom node addition from Polyglot configuration: %s', str(ex))
try:
_params = self.polyConfig['customParams']
global UPDATE_DELAY
if 'delay' in _params:
UPDATE_DELAY = float(_params['delay'])
else:
LOGGER.info("NOTE: A delay can be specified to wait a bit for the LED controller to process commands before querying them to update the controller's state in the ISY. Defaults to %s sec.", str(UPDATE_DELAY))
except Exception as ex:
LOGGER.error('Error obtaining device delay value from Polyglot configuration: %s',str(ex))
try:
_params = self.polyConfig['customParams']
global QUERY_BEFORE_CMD
if 'query_before_cmd' in _params:
QUERY_BEFORE_CMD = bool(_params['query_before_cmd'])
except Exception as ex:
LOGGER.error('Error obtaining query_before_cmd flag from Polyglot configuration: %s',str(ex))
self.firstRun = False
return _success
def __init__(self, sensorId, sensorName, macAddr):
super().__init__(sensorId, sensorName)
self.sensorType = "led"
self.brightness = 0.0
self.macAddr = macAddr
self.ledDevice = None
# Find the bulb on the LAN
self.scanner = BulbScanner()
self.connect()
def __init__(self, bulb_map, period, fake=False):
self._bulb_map = bulb_map
self._period = period
self._fake = fake
self._thread = None
self._lock = threading.Lock()
self._stop = threading.Event()
self._scanner = BulbScanner()
self._lights = {}
self._thread = threading.Thread(target=self._scan)
self._thread.start()
def scan():
global choices
scanner = BulbScanner()
scanner.scan(timeout=4)
scanner_results = []
for found_bulb in scanner.found_bulbs:
print("Found a bulb: " + found_bulb['ipaddr'] + " with MAC: " +
found_bulb['id'])
scanner_results.append(found_bulb['ipaddr'])
# Connect to the LED controller
if len(scanner.found_bulbs) == 0:
scanner_results.append("No controllers found :(")
choices = scanner_results
print(choices)
def __init__(self,
mode: LEDControlMode = LEDControlMode.AUDIO_STEREO_MIX,
rgb_buffer_len: int = 8,
alpha_buffer_length=8,
silence_buffer_length=1.5):
self.mode = mode
if self.mode == LEDControlMode.AUDIO_STEREO_MIX:
self.controller = AudioController()
self.audio_stream = AudioStream(
audio_device=AudioInputDevices.STEREO_MIX,
chunk=self.controller.nperseg)
elif self.mode == LEDControlMode.MONITOR_COLOR:
self.controller = MonitorColorController()
rgb_buffer_len = 2
self.hue_buffer = deque([0 for _ in range(rgb_buffer_len)],
maxlen=rgb_buffer_len)
self.alpha_buffer = deque([2 for _ in range(alpha_buffer_length)],
maxlen=alpha_buffer_length)
self.silence_buffer = deque(
[
'music' for _ in range(
int(silence_buffer_length / self.controller.nperseg *
self.controller.fs))
],
maxlen=int(silence_buffer_length / self.controller.nperseg *
self.controller.fs))
self.state = 'music'
# scan available LED devices
scanner = BulbScanner()
scanner.scan(timeout=4)
print("Found LED controllers:")
[print(bulb) for bulb in scanner.found_bulbs]
self.bulbs = []
for bulb in scanner.found_bulbs:
bulb_info = scanner.getBulbInfoByID(bulb['id'])
self.bulbs.append(WifiLedBulb(bulb_info['ipaddr']))
def start_pairing(self, timeout):
"""
Start the pairing process.
timeout -- Timeout in seconds at which to quit pairing
"""
if self.pairing:
return
self.pairing = True
self._add_from_config()
scanner = BulbScanner()
for device in scanner.scan(timeout=min(timeout, _TIMEOUT)):
if not self.pairing:
break
self._add_device(device)
self.pairing = False
def command_handler(sentence, info):
scanner = BulbScanner()
coms, classify = commands()
msg = sentence + " is not a know flux lightbulb command"
function = None
print("scanner scan: ", end="")
print(scanner.scan(timeout=4))
try:
#specific ID/MAC of bulb
my_light = scanner.getBulbInfoByID("D8F15BA2EE72")
except:
msg = "flux lightbulb not detected!"
return msg, function
print("success!")
bulb = WifiLedBulb(my_light["ipaddr"])
for i in coms[0]: #lightbulb color changer
res = parse(i, sentence)
if res:
msg, function = colorChanger(bulb, res[0])
return msg, function
if sentence in coms[1]: #turn lightbulb off
msg = "turning the flux lightbulb off"
function = bulb.turnOff()
return msg, function
if sentence in coms[2]: #turn the lightbulb on
msg = "turning the flux lightbulb on"
function = bulb.turnOn()
return msg, function
for i in coms[3]: #change brightness of lightbulb
res = parse(i, sentence)
if res:
msg, function = brightnessChanger(bulb, res[0])
return msg, function
return msg, function
def __init__(self,
mode: LEDControlMode = LEDControlMode.AUDIO_STEREO_MIX,
rgb_buffer_len: int = 5):
self.mode = mode
if self.mode == LEDControlMode.AUDIO_STEREO_MIX:
self.controller = AudioController()
self.audio_stream = AudioStream(
audio_device=AudioInputDevices.STEREO_MIX,
chunk=self.controller.nperseg)
elif self.mode == LEDControlMode.MONITOR_COLOR:
self.controller = MonitorColorController()
rgb_buffer_len = 2
self.rgb_buffer = {
'r': deque([255 for _ in range(rgb_buffer_len)],
maxlen=rgb_buffer_len),
'g': deque([255 for _ in range(rgb_buffer_len)],
maxlen=rgb_buffer_len),
'b': deque([255 for _ in range(rgb_buffer_len)],
maxlen=rgb_buffer_len)
}
# scan available LED devices
scanner = BulbScanner()
scanner.scan(timeout=4)
print("Found LED controllers:")
[print(bulb) for bulb in scanner.found_bulbs]
self.bulbs = []
for bulb in scanner.found_bulbs:
bulb_info = scanner.getBulbInfoByID(bulb['id'])
self.bulbs.append(WifiLedBulb(bulb_info['ipaddr']))
between. Assumes the bulb is already on.
The python file with the Flux LED wrapper classes should live in
the same folder as this script
"""
import os
import sys
import time
from itertools import cycle
this_folder = os.path.dirname(os.path.realpath(__file__))
sys.path.append(this_folder)
from flux_led import WifiLedBulb, BulbScanner, LedTimer
scanner = BulbScanner()
scanner.scan(timeout=4)
# Specific ID/MAC of the bulb to set
bulb_info = scanner.getBulbInfoByID('6001948A4F89')
print "bulb_info: " + str(bulb_info)
bulb = WifiLedBulb(bulb_info['ipaddr'])
color_time = 2 # seconds on each color
red = (255, 0, 0)
orange = (255, 125, 0)
yellow = (255, 255, 0)
springgreen = (125, 255, 0)
green = (0, 255, 0)
def main():
syslog.openlog(sys.argv[0])
# Change location to nearest city.
location = 'San Diego'
# Get the local sunset/sunrise times
a = Astral()
a.solar_depression = 'civil'
city = a[location]
timezone = city.timezone
sun = city.sun(date=datetime.datetime.now(), local=True)
if debug:
print 'Information for {}/{}\n'.format(location, city.region)
print 'Timezone: {}'.format(timezone)
print 'Latitude: {:.02f}; Longitude: {:.02f}\n'.format(
city.latitude, city.longitude)
print('Dawn: {}'.format(sun['dawn']))
print('Sunrise: {}'.format(sun['sunrise']))
print('Noon: {}'.format(sun['noon']))
print('Sunset: {}'.format(sun['sunset']))
print('Dusk: {}'.format(sun['dusk']))
# Find the bulbs on the LAN
scanner = BulbScanner()
scanner.scan(timeout=4)
# Specific ID/MAC of the bulbs to set
porch_info = scanner.getBulbInfoByID('ACCF235FFFEE')
livingroom_info = scanner.getBulbInfoByID('ACCF235FFFAA')
if porch_info:
bulb = WifiLedBulb(porch_info['ipaddr'])
bulb.refreshState()
timers = bulb.getTimers()
# Set the porch bulb to turn on at dusk using timer idx 0
syslog.syslog(
syslog.LOG_ALERT,
"Setting porch light to turn on at {}:{:02d}".format(
sun['dusk'].hour, sun['dusk'].minute))
dusk_timer = LedTimer()
dusk_timer.setActive(True)
dusk_timer.setRepeatMask(LedTimer.Everyday)
dusk_timer.setModeWarmWhite(35)
dusk_timer.setTime(sun['dusk'].hour, sun['dusk'].minute)
timers[0] = dusk_timer
# Set the porch bulb to turn off at dawn using timer idx 1
syslog.syslog(
syslog.LOG_ALERT,
"Setting porch light to turn off at {}:{:02d}".format(
sun['dawn'].hour, sun['dawn'].minute))
dawn_timer = LedTimer()
dawn_timer.setActive(True)
dawn_timer.setRepeatMask(LedTimer.Everyday)
dawn_timer.setModeTurnOff()
dawn_timer.setTime(sun['dawn'].hour, sun['dawn'].minute)
timers[1] = dawn_timer
bulb.sendTimers(timers)
else:
print "Can't find porch bulb"
if livingroom_info:
bulb = WifiLedBulb(livingroom_info['ipaddr'])
bulb.refreshState()
timers = bulb.getTimers()
# Set the living room bulb to turn on at sunset using timer idx 0
syslog.syslog(
syslog.LOG_ALERT,
"Setting LR light to turn on at {}:{:02d}".format(
sun['sunset'].hour, sun['sunset'].minute))
sunset_timer = LedTimer()
sunset_timer.setActive(True)
sunset_timer.setRepeatMask(LedTimer.Everyday)
sunset_timer.setModeWarmWhite(50)
sunset_timer.setTime(sun['sunset'].hour, sun['sunset'].minute)
timers[0] = sunset_timer
# Set the living room bulb to turn off at a fixed time
off_timer = LedTimer()
off_timer.setActive(True)
off_timer.setRepeatMask(LedTimer.Everyday)
off_timer.setModeTurnOff()
off_timer.setTime(23, 30)
timers[1] = off_timer
bulb.sendTimers(timers)
else:
print "Can't find living room bulb"
def autoScan():
scanner = BulbScanner()
scanner.scan(timeout=4)
bulb_info = scanner.getBulbInfoByID('ACCF235FFFFF')
return bulb_info
def _scan_with_timeout() -> list[dict[str, str]]:
scanner = BulbScanner()
discovered: list[dict[str, str]] = scanner.scan(timeout=timeout)
return discovered
