Ejemplo n.º 1
0
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()
Ejemplo n.º 2
0
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)
Ejemplo n.º 3
0
def scan_bulb():
    scanner = BulbScanner()
    scanner.scan()

    print scanner.found_bulbs

    ipaddr = scanner.found_bulbs[0]['ipaddr']
    return ipaddr
Ejemplo n.º 4
0
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()
			if not bulb.isOn():
				# if the bulb isn't on, don't do anything
				time.sleep(60)
				continue
			
			# set to color and wait
			bulb.setRgb(*color)
			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"                   
Ejemplo n.º 5
0
    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
Ejemplo n.º 6
0
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"
Ejemplo n.º 7
0
    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()
Ejemplo n.º 8
0
    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()
Ejemplo n.º 9
0
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)
Ejemplo n.º 10
0
    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']))
Ejemplo n.º 11
0
    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
Ejemplo n.º 12
0
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
Ejemplo n.º 13
0
    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']))
Ejemplo n.º 14
0
 def _scan_with_timeout() -> list[dict[str, str]]:
     scanner = BulbScanner()
     discovered: list[dict[str, str]] = scanner.scan(timeout=timeout)
     return discovered
Ejemplo n.º 15
0
class Scanner(object):
    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 stop(self):
        self._stop.set()
        self._thread.join()

    def lights(self):
        with self._lock:
            return self._lights

    def lock(self):
        return self._lock

    def _scan(self):
        while not self._stop.is_set():
            with self._lock:
                new_lights = {}
                print('Scanning for bulbs')
                old_names = tuple(self._lights.keys())
                found_names = []
                if not self._fake:
                    self._scanner.scan(timeout=4)

                    for scanned in self._scanner.getBulbInfo():
                        bid = scanned['id']
                        if bid in self._bulb_map:
                            print('Found real bulb: %s' %
                                  (self._bulb_map[bid], ))
                            new_lights[self._bulb_map[bid]] = {'info': scanned}
                            found_names.append(self._bulb_map[bid])
                else:
                    for i, id in enumerate(self._bulb_map):
                        print('Found fake bulb: %s' % (self._bulb_map[id], ))
                        new_lights[self._bulb_map[id]] = {
                            'info': {
                                'ipaddr': '10.0.0.%d' % i
                            }
                        }
                        found_names.append(self._bulb_map[id])

                # Clear out any bulbs that went missing
                for name in old_names:
                    if name not in found_names:
                        print('Removing missing light: ', name)
                for name in found_names:
                    if name not in old_names:
                        print('Adding new bulb: ', name)

                for name, l in new_lights.items():
                    if not l['info']:
                        print('Did not find expected bulb', name)
                        sys.exit(1)
                    if not self._fake:
                        l['bulb'] = WifiLedBulb(l['info']['ipaddr'])
                    else:
                        l['bulb'] = FakeBulb(name)

                if len(new_lights) != len(self._bulb_map):
                    print("Warning: didn't find all the lights")
                self._lights = new_lights

            # Sleep, but keep checking for quit while we do.
            for i in range(0, self._period):
                if self._stop.is_set():
                    return
                time.sleep(1)
Ejemplo n.º 16
0
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)
Ejemplo n.º 17
0
class Led_Strip(switch_base.Switch_Base):
    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 connect(self):
        self.scanner.scan(timeout=4)
        # Specific ID/MAC of the bulb to set
        bulb_info = self.scanner.getBulbInfoByID(self.macAddr)

        if bulb_info:
            self.ledDevice = WifiLedBulb(bulb_info["ipaddr"])
            self.ledDevice.refreshState()

    def reportBrightness(self):
        if self.mqttClient and self.mqttClient.is_connected():
            self.mqttClient.publish(
                self.mqttHeader + self.sensorId + "/aux/brightness",
                self.brightness,
                qos=1,
                retain=True,
            )

    def setBrightness(self, brightness):
        self.brightness = brightness

        newState = brightness > 0.0
        if newState != self.state:
            super().setState(newState)

        self.reportBrightness()

    def setState(self, newState, retry=2):

        if self.ledDevice:
            if not newState:
                self.ledDevice.turnOff()
                self.brightness = 0.0
            else:
                self.ledDevice.turnOn()
            self.state = newState

            self.reportState()
        elif retry:
            self.connect()
            self.setState(newState, retry=(retry - 1))

    def init(self, mqttHeader, mqttClient):
        super().init(mqttHeader, mqttClient)

        self.reportBrightness()

        topic = self.mqttHeader + self.sensorId + "/aux/setBrightness"
        mqttClient.subscribe(topic)

        def on_message(client, obj, msg):
            try:
                brightness = utils.parseFloat(msg.payload)
                assert 0.0 <= brightness <= 1.0
            except:
                logger.error(f"Invalid brightness value: {msg.payload}")
                return
            self.setBrightness(brightness)

        mqttClient.message_callback_add(topic, on_message)
Ejemplo n.º 18
0
def autoScan():
    scanner = BulbScanner()
    scanner.scan(timeout=4)
    bulb_info = scanner.getBulbInfoByID('ACCF235FFFFF')
    return bulb_info
Ejemplo n.º 19
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"                   
Ejemplo n.º 20
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"
Ejemplo n.º 21
0
np.set_printoptions(suppress=True)  # don't use scientific notation

CHUNK = 1024 * 4  # number of data points to read at a time
RATE = 44100  # time resolution of the recording device (Hz)
maxValue = 2**16

p = pyaudio.PyAudio()  # start the PyAudio class
stream = p.open(format=pyaudio.paInt16,
                channels=1,
                rate=RATE,
                input=True,
                frames_per_buffer=CHUNK)  #uses default input device

# Find the bulb on the LAN
scanner = BulbScanner()
scanner.scan(timeout=4)

r = 0
g = 0
b = 0
# Specific ID/MAC of the bulb to set
bulb_info = scanner.getBulbInfoByID('ACCF235FFFFF')
if bulb_info:
    bulb = WifiLedBulb(bulb_info['ipaddr'])
    bulb.setRgb(255, 0, 0, persist=False)
    # create a numpy array holding a single read of audio data
    while True:  #to it a few times just to see
        data = np.fromstring(stream.read(CHUNK), dtype=np.int16)

        dataL = data[0::2]