示例#1
0
    def set_effect(self, effect) -> None:
        """Activate effect."""
        if not effect:
            return

        if effect == EFFECT_STOP:
            self._bulb.stop_flow(light_type=self.light_type)
            return

        if effect in self.custom_effects_names:
            flow = Flow(**self.custom_effects[effect])
        elif effect in EFFECTS_MAP:
            flow = EFFECTS_MAP[effect]()
        elif effect == EFFECT_FAST_RANDOM_LOOP:
            flow = flows.random_loop(duration=250)
        elif effect == EFFECT_WHATSAPP:
            flow = Flow(count=2,
                        transitions=yee_transitions.pulse(37, 211, 102))
        elif effect == EFFECT_FACEBOOK:
            flow = Flow(count=2,
                        transitions=yee_transitions.pulse(59, 89, 152))
        elif effect == EFFECT_TWITTER:
            flow = Flow(count=2,
                        transitions=yee_transitions.pulse(0, 172, 237))
        else:
            return

        try:
            self._bulb.start_flow(flow, light_type=self.light_type)
            self._effect = effect
        except BulbException as ex:
            _LOGGER.error("Unable to set effect: %s", ex)
def command_preset(event):
    event.print_line()
    preset = event.name
    uhc.say(preset)
    if context == "MUSIC":
        if preset == "PRESET 1":
            uri = 'x-rincon-mp3radio://http://94.23.51.96:8001/'  # CINEMIX
        elif preset == "PRESET 2":
            uri = 'x-rincon-mp3radio://http://strm112.1.fm:80/bossanova_mobile_mp3'  # 1.FM Bossa Nova
        elif preset == "PRESET 3":
            uri = 'x-rincon-mp3radio://http://streams.calmradio.com:6828/stream'  # Calm Radio J.S. Bach
        sonos.play_uri(uri=uri)
    elif context == "LIGHT":
        if preset == "PRESET 1":
            rgb = (255, 255, 255)
            bulb.set_rgb(*rgb)
        elif preset == "PRESET 2":
            rgb = (255, 0, 0)
            bulb.set_rgb(*rgb)
        elif preset == "PRESET 3":
            rgb = (0, 0, 255)
            bulb.set_rgb(*rgb)
        elif preset == "PRESET 4":
            flow = Flow(count=0, transitions=transitions.disco())
            bulb.start_flow(flow)
    elif context == "TV":
        tempo = 0.6
        if preset == "PRESET 1":
            rm3.send_command(["2", "sleep 0.5", "1", "sleep 0.5", "ok"])
        elif preset == "PRESET 2":
            rm3.send_command(["1", "sleep 0.5", "6", "sleep 0.5", "ok"])
        elif preset == "PRESET 3":
            rm3.send_command(["5", "sleep 0.5", "ok"])
示例#3
0
    def set_flash(self, flash) -> None:
        """Activate flash."""
        if flash:
            from yeelight import (RGBTransition, SleepTransition, Flow,
                                  BulbException)
            if self._bulb.last_properties["color_mode"] != 1:
                _LOGGER.error("Flash supported currently only in RGB mode.")
                return

            transition = int(self.config[CONF_TRANSITION])
            if flash == FLASH_LONG:
                count = 1
                duration = transition * 5
            if flash == FLASH_SHORT:
                count = 1
                duration = transition * 2

            red, green, blue = self.rgb_color

            transitions = list()
            transitions.append(
                RGBTransition(255, 0, 0, brightness=10, duration=duration))
            transitions.append(SleepTransition(duration=transition))
            transitions.append(
                RGBTransition(red,
                              green,
                              blue,
                              brightness=self.brightness,
                              duration=duration))

            flow = Flow(count=count, transitions=transitions)
            try:
                self._bulb.start_flow(flow)
            except BulbException as ex:
                _LOGGER.error("Unable to set flash: %s", ex)
示例#4
0
    async def async_set_effect(self, effect) -> None:
        """Activate effect."""
        if not effect:
            return

        if effect == EFFECT_STOP:
            await self._bulb.async_stop_flow(light_type=self.light_type)
            return

        if effect in self.custom_effects_names:
            flow = Flow(**self.custom_effects[effect])
        elif effect in EFFECTS_MAP:
            flow = EFFECTS_MAP[effect]()
        elif effect == EFFECT_FAST_RANDOM_LOOP:
            flow = flows.random_loop(duration=250)
        elif effect == EFFECT_WHATSAPP:
            flow = flows.pulse(37, 211, 102, count=2)
        elif effect == EFFECT_FACEBOOK:
            flow = flows.pulse(59, 89, 152, count=2)
        elif effect == EFFECT_TWITTER:
            flow = flows.pulse(0, 172, 237, count=2)
        else:
            return

        await self._bulb.async_start_flow(flow, light_type=self.light_type)
        self._effect = effect
示例#5
0
 def set_effect(self, command):
     val = int(command.get('value'))
     if val < 0 or val > 12:
         LOGGER.error('Invalid effect number {}'.format(val))
         return
     if val > 0:
         LOGGER.debug('{} starting effect {}'.format(self.name, val - 1))
     if not self.power:
         if val == 0:
             LOGGER.error('{} is off, can\'t stop the effect'.format(
                 self.name))
         self._power_on()
     if val == 0:
         LOGGER.info('{} stopping effect'.format(self.name))
         try:
             self.bulb.stop_flow()
         except Exception as ex:
             LOGGER.error('{} failed to stop effect {}'.format(
                 self.name, ex))
         return
     flow = Flow(count=0, transitions=EFFECT_MAP[val - 1]())
     try:
         self.bulb.start_flow(flow)
     except Exception as ex:
         LOGGER.error('{} failed to start effect {}'.format(self.name, ex))
示例#6
0
 def service_set_color_flow_scene(target_device, params):
     flow = Flow(
         count=params[ATTR_COUNT],
         action=Flow.actions[params[ATTR_ACTION]],
         transitions=_transitions_config_parser(params[ATTR_TRANSITIONS]),
     )
     target_device.set_scene(SceneClass.CF, flow)
示例#7
0
    async def async_set_flash(self, flash) -> None:
        """Activate flash."""
        if not flash:
            return
        if int(self._bulb.last_properties["color_mode"]) != 1:
            _LOGGER.error("Flash supported currently only in RGB mode")
            return

        transition = int(self.config[CONF_TRANSITION])
        if flash == FLASH_LONG:
            count = 1
            duration = transition * 5
        if flash == FLASH_SHORT:
            count = 1
            duration = transition * 2

        red, green, blue = color_util.color_hs_to_RGB(*self.hs_color)

        transitions = []
        transitions.append(
            RGBTransition(255, 0, 0, brightness=10, duration=duration))
        transitions.append(SleepTransition(duration=transition))
        transitions.append(
            RGBTransition(red,
                          green,
                          blue,
                          brightness=self.brightness,
                          duration=duration))

        flow = Flow(count=count, transitions=transitions)
        await self._bulb.async_start_flow(flow, light_type=self.light_type)
示例#8
0
文件: light.py 项目: 2Fake/core
 async def _async_set_color_flow_scene(entity, service_call):
     flow = Flow(
         count=service_call.data[ATTR_COUNT],
         action=Flow.actions[service_call.data[ATTR_ACTION]],
         transitions=_transitions_config_parser(service_call.data[ATTR_TRANSITIONS]),
     )
     await entity.async_set_scene(SceneClass.CF, flow)
示例#9
0
 def heart_beat_flow(self, rate):
     down_duration = (60000 / rate) - 100
     transitions = [
         RGBTransition(255, 0, 0, duration=50, brightness=100),
         SleepTransition(duration=50),
         RGBTransition(255, 0, 0, duration=down_duration, brightness=1)
     ]
     return Flow(count=0, action=Flow.actions.off, transitions=transitions)
示例#10
0
 async def async_start_flow(self,
                            transitions,
                            count=0,
                            action=ACTION_RECOVER):
     """Start flow."""
     flow = Flow(count=count,
                 action=Flow.actions[action],
                 transitions=transitions)
     await self._bulb.async_start_flow(flow, light_type=self.light_type)
示例#11
0
文件: lights.py 项目: mr1e14/iot-proj
    def start_disco(self, *bulbs):
        logging.info('Starting disco')

        flow = Flow(count=0, transitions=disco())

        if len(bulbs) == 0:
            bulbs = [self.__default]

        for bulb in bulbs:
            bulb.start_flow(flow)
示例#12
0
 def test_start_flow(self):
     transitions = [
         TemperatureTransition(1700, duration=40000),
         TemperatureTransition(6500, duration=40000)
     ]
     flow = Flow(count=1, action=Action.stay, transitions=transitions)
     self.bulb.start_flow(flow)
     self.assertEqual(self.socket.sent["method"], "start_cf")
     self.assertEqual(self.socket.sent["params"],
                      [2, 1, "40000, 2, 1700, 100, 40000, 2, 6500, 100"])
示例#13
0
    def set_effect(self, effect) -> None:
        """Activate effect."""
        if effect:
            from yeelight import (Flow, BulbException)
            from yeelight.transitions import (disco, temp, strobe, pulse,
                                              strobe_color, alarm, police,
                                              police2, christmas, rgb,
                                              randomloop, lsd, slowdown)
            if effect == EFFECT_STOP:
                self._bulb.stop_flow()
                return

            effects_map = {
                EFFECT_DISCO: disco,
                EFFECT_TEMP: temp,
                EFFECT_STROBE: strobe,
                EFFECT_STROBE_COLOR: strobe_color,
                EFFECT_ALARM: alarm,
                EFFECT_POLICE: police,
                EFFECT_POLICE2: police2,
                EFFECT_CHRISTMAS: christmas,
                EFFECT_RGB: rgb,
                EFFECT_RANDOM_LOOP: randomloop,
                EFFECT_LSD: lsd,
                EFFECT_SLOWDOWN: slowdown,
            }

            if effect in effects_map:
                flow = Flow(count=0, transitions=effects_map[effect]())
            if effect == EFFECT_FAST_RANDOM_LOOP:
                flow = Flow(count=0, transitions=randomloop(duration=250))
            if effect == EFFECT_WHATSAPP:
                flow = Flow(count=2, transitions=pulse(37, 211, 102))
            if effect == EFFECT_FACEBOOK:
                flow = Flow(count=2, transitions=pulse(59, 89, 152))
            if effect == EFFECT_TWITTER:
                flow = Flow(count=2, transitions=pulse(0, 172, 237))

            try:
                self._bulb.start_flow(flow)
            except BulbException as ex:
                _LOGGER.error("Unable to set effect: %s", ex)
 def showFlow(self, transactions, count):
     try:
         flow = Flow(count=count,
                     action=Flow.actions.recover,
                     transitions=transactions)
         self.bulb.start_flow(flow)
     except:
         self.showAlert(
             "Warning",
             "Your bulb is probably turn off from internet or your ip is badly formatted"
         )
示例#15
0
文件: lights.py 项目: mr1e14/iot-proj
    def notify(self, level=NotificationLevel.INFO, *bulbs):
        logging.info('Flashing notification ({})'.format(level))

        red, green, blue = level
        flow = Flow(count=3, transitions=pulse(red, green, blue, duration=400))

        if len(bulbs) == 0:
            bulbs = [self.__default]

        for bulb in bulbs:
            bulb.start_flow(flow)
示例#16
0
 def test_set_scene_color_flow(self):
     transitions = [
         TemperatureTransition(1700, duration=40000),
         TemperatureTransition(6500, duration=40000)
     ]
     flow = Flow(count=1, action=Action.stay, transitions=transitions)
     self.bulb.set_scene(SceneClass.CF, flow)
     self.assertEqual(self.socket.sent["method"], "set_scene")
     self.assertEqual(
         self.socket.sent["params"],
         ["cf", 2, 1, "40000, 2, 1700, 100, 40000, 2, 6500, 100"])
示例#17
0
    def start_flow(self, transitions, count=0, action=ACTION_RECOVER):
        """Start flow."""
        try:
            flow = Flow(count=count,
                        action=Flow.actions[action],
                        transitions=transitions)

            self._bulb.start_flow(flow, light_type=self.light_type)
            self.device.update()
        except BulbException as ex:
            _LOGGER.error("Unable to set effect: %s", ex)
示例#18
0
def toggleFlow():
    global listOfBulbs
    global isFlow
    isFlow = not isFlow
    if isFlow:
        for bulb in listOfBulbs:
            bulb.start_flow(
                Flow(0, Flow.actions.recover,
                     preMadeTransitions[flowOption.get()]))
    else:
        for bulb in listOfBulbs:
            bulb.stop_flow()
示例#19
0
    async def async_start_flow(self,
                               transitions,
                               count=0,
                               action=ACTION_RECOVER):
        """Start flow."""
        try:
            flow = Flow(count=count,
                        action=Flow.actions[action],
                        transitions=transitions)

            await self._bulb.async_start_flow(flow, light_type=self.light_type)
        except BULB_EXCEPTIONS as ex:
            _LOGGER.error("Unable to set effect: %s", ex)
示例#20
0
 async def _async_set_color_flow_scene(entity, service_call):
     flow = Flow(
         count=service_call.data[ATTR_COUNT],
         action=Flow.actions[service_call.data[ATTR_ACTION]],
         transitions=_transitions_config_parser(
             service_call.data[ATTR_TRANSITIONS]),
     )
     await opp.async_add_executor_job(
         partial(
             entity.set_scene,
             SceneClass.CF,
             flow,
         ))
示例#21
0
 def zone_flow(self, zone):
     colour = self.colour_from_zone(zone)
     speed = self.speed_from_zone(zone)
     transitions = [
         RGBTransition(colour['red'],
                       colour['green'],
                       colour['blue'],
                       duration=self.up_duration * speed,
                       brightness=100),
         RGBTransition(colour['red'],
                       colour['green'],
                       colour['blue'],
                       duration=self.down_duration * speed,
                       brightness=10),
     ]
     return Flow(count=0, action=Flow.actions.off, transitions=transitions)
示例#22
0
def start_flow_yeelight(id_bulb=None):
    
    flow = Flow(
        count=0,  # Cycle forever.
        transitions=transitions.christmas()
    )

    if id_bulb != None:
        if id_bulb == 0:
            bulb0.start_flow(flow)
        elif id_bulb == 1:
            bulb1.start_flow(flow)
        elif id_bulb == 2:
            bulb0.start_flow(flow)
            bulb1.start_flow(flow)
    return ('', 204)
示例#23
0
 async def disco(self, ctx):
     flow = Flow(
         count=10,
         transitions=disco(),
     )
     names = []
     for light in self.lights:
         try:
             Bulb(light['ip'], effect="smooth",
                  duration=1500).start_flow(flow)
         except AssertionError as err:
             await ctx.send(err)
             return
         names.append(light['name'])
     successMsg = ", ".join(names)
     await self.lightEventMsg(ctx,
                              f'Enabled party mode on **{successMsg}**')
示例#24
0
def update_yeelight_beacon(beacon, temperature_color, condition_color):
    '''
    Updates a Yeelight beacon
    '''
    brightness = config['lightshow']['brightness']
    duration = config['lightshow']['transition']['duration'] * 1000
    delay = config['lightshow']['transition']['delay'] * 1000

    flow = Flow(0, Flow.actions.recover, [
        RGBTransition(*temperature_color, duration, brightness),
        SleepTransition(delay),
        RGBTransition(*condition_color, duration, brightness),
        SleepTransition(delay)
    ])

    bulb = SmartBulb(beacon['ip'])
    bulb.start_flow(flow)
示例#25
0
 def send(self):
     from yeelight import Flow
     from yeelight import transitions
     bulb = self.get_bulb()
     state = self.state
     if state == 'TOGGLE':
         state = {
             'off': 'ON',
             'on': 'OFF'
         }[bulb.get_properties(['power'])['power']]
     if state == 'ON':
         bulb.turn_on(effect=self.effect, duration=self.effect_duration)
     elif state == 'OFF':
         bulb.turn_off(effect=self.effect, duration=self.effect_duration)
     if self.flow_transition:
         trans = getattr(transitions, self.flow_transition)
         if self.flow_transition == 'pulse':
             trans = trans(*self._color, self.flow_duration or 250,
                           self.brightness or 100)
         else:
             kwargs = {
                 'duration': self.flow_duration,
                 'brightness': self.brightness,
                 'sleep': self.flow_sleep
             }
             spec = inspect.getargspec(trans)
             kwargs = {
                 key: value
                 for key, value in kwargs.items()
                 if key in spec.args and value is not None
             }
             trans = trans(**kwargs)
         bulb.start_flow(Flow(count=self.flow_count, transitions=trans))
     elif self._color:
         bulb.set_rgb(*self._color)
     elif self.brightness:
         bulb.set_brightness(self.brightness)
     elif self.temperature:
         bulb.set_color_temp(self.temperature)
示例#26
0
    def set_effect(self, effect) -> None:
        """Activate effect."""
        if effect:
            if effect == EFFECT_STOP:
                self._bulb.stop_flow(light_type=self.light_type)
                return

            effects_map = {
                EFFECT_DISCO: yee_transitions.disco,
                EFFECT_TEMP: yee_transitions.temp,
                EFFECT_STROBE: yee_transitions.strobe,
                EFFECT_STROBE_COLOR: yee_transitions.strobe_color,
                EFFECT_ALARM: yee_transitions.alarm,
                EFFECT_POLICE: yee_transitions.police,
                EFFECT_POLICE2: yee_transitions.police2,
                EFFECT_CHRISTMAS: yee_transitions.christmas,
                EFFECT_RGB: yee_transitions.rgb,
                EFFECT_RANDOM_LOOP: yee_transitions.randomloop,
                EFFECT_LSD: yee_transitions.lsd,
                EFFECT_SLOWDOWN: yee_transitions.slowdown,
            }

            if effect in self.custom_effects_names:
                flow = Flow(**self.custom_effects[effect])
            elif effect in effects_map:
                flow = Flow(count=0, transitions=effects_map[effect]())
            elif effect == EFFECT_FAST_RANDOM_LOOP:
                flow = Flow(
                    count=0,
                    transitions=yee_transitions.randomloop(duration=250))
            elif effect == EFFECT_WHATSAPP:
                flow = Flow(count=2,
                            transitions=yee_transitions.pulse(37, 211, 102))
            elif effect == EFFECT_FACEBOOK:
                flow = Flow(count=2,
                            transitions=yee_transitions.pulse(59, 89, 152))
            elif effect == EFFECT_TWITTER:
                flow = Flow(count=2,
                            transitions=yee_transitions.pulse(0, 172, 237))

            try:
                self._bulb.start_flow(flow, light_type=self.light_type)
            except BulbException as ex:
                _LOGGER.error("Unable to set effect: %s", ex)
示例#27
0
    def flow_bulb(self):
        transitions = [RGBTransition(255, 0, 255, duration=1000)]

        flow = Flow(count=0, transitions=transitions)
        self.bulb.start_flow(flow)
示例#28
0
    def set_effect(self, effect) -> None:
        """Activate effect."""
        if effect:
            from yeelight import (RGBTransition, TemperatureTransition,
                                  SleepTransition, Flow, BulbException)
            transition = int(self.config[CONF_TRANSITION])
            if effect == EFFECT_ALARM:
                count = 0
                duration = 100

                transitions = list()
                transitions.append(
                    RGBTransition(255, 0, 0, brightness=100,
                                  duration=duration))
                transitions.append(
                    RGBTransition(255, 0, 0, brightness=60, duration=duration))
                flow = Flow(count=count, transitions=transitions)

            if effect == EFFECT_DISCO:
                count = 0
                duration = 300

                transitions = list()
                transitions.append(
                    RGBTransition(255,
                                  0,
                                  0,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(255, 0, 0, brightness=1, duration=duration))
                transitions.append(
                    RGBTransition(128,
                                  255,
                                  0,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(128, 255, 0, brightness=1,
                                  duration=duration))
                transitions.append(
                    RGBTransition(0,
                                  255,
                                  255,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(0, 255, 255, brightness=1,
                                  duration=duration))
                transitions.append(
                    RGBTransition(128,
                                  0,
                                  255,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(128, 0, 255, brightness=1,
                                  duration=duration))
                flow = Flow(count=count, transitions=transitions)

            if effect == EFFECT_STROBE:
                count = 0
                duration = 50

                transitions = list()
                transitions.append(
                    RGBTransition(255,
                                  255,
                                  255,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(255,
                                  255,
                                  255,
                                  brightness=1,
                                  duration=duration))
                flow = Flow(count=count, transitions=transitions)

            if effect == EFFECT_COLOR_STROBE:
                count = 0
                duration = 50

                transitions = list()
                transitions.append(
                    RGBTransition(0,
                                  0,
                                  255,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(255,
                                  255,
                                  0,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(255,
                                  0,
                                  127,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(255,
                                  0,
                                  0,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(0,
                                  255,
                                  255,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(255,
                                  128,
                                  0,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(0,
                                  255,
                                  0,
                                  brightness=self.brightness,
                                  duration=duration))
                flow = Flow(count=count, transitions=transitions)

            if effect == EFFECT_POLICE:
                count = 0
                duration = 300

                transitions = list()
                transitions.append(
                    RGBTransition(255,
                                  0,
                                  0,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(0,
                                  0,
                                  255,
                                  brightness=self.brightness,
                                  duration=duration))
                flow = Flow(count=count, transitions=transitions)

            if effect == EFFECT_POLICE2:
                count = 0
                duration = 200

                transitions = list()
                transitions.append(
                    RGBTransition(255,
                                  0,
                                  0,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(255, 0, 0, brightness=1, duration=duration))
                transitions.append(
                    RGBTransition(255,
                                  0,
                                  0,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(SleepTransition(duration=duration))
                transitions.append(
                    RGBTransition(0,
                                  0,
                                  255,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(0, 0, 255, brightness=1, duration=duration))
                transitions.append(
                    RGBTransition(0,
                                  0,
                                  255,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(SleepTransition(duration=duration))
                flow = Flow(count=count, transitions=transitions)

            if effect == EFFECT_CHRISTMAS:
                count = 0
                duration = 300

                transitions = list()
                transitions.append(
                    RGBTransition(255,
                                  0,
                                  0,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(SleepTransition(duration=3000))
                transitions.append(
                    RGBTransition(0,
                                  255,
                                  0,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(SleepTransition(duration=3000))
                flow = Flow(count=count, transitions=transitions)

            if effect == EFFECT_RGB:
                count = 0
                duration = 300

                transitions = list()
                transitions.append(
                    RGBTransition(255,
                                  0,
                                  0,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(SleepTransition(duration=3000))
                transitions.append(
                    RGBTransition(0,
                                  255,
                                  0,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(SleepTransition(duration=3000))
                transitions.append(
                    RGBTransition(0,
                                  0,
                                  255,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(SleepTransition(duration=3000))
                flow = Flow(count=count, transitions=transitions)

            if effect == EFFECT_RGB_TRANS:
                count = 0
                duration = 10000

                transitions = list()
                transitions.append(
                    RGBTransition(255,
                                  0,
                                  0,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(0,
                                  255,
                                  0,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(0,
                                  0,
                                  255,
                                  brightness=self.brightness,
                                  duration=duration))
                flow = Flow(count=count, transitions=transitions)

            if effect == EFFECT_ENJOY:
                count = 0
                duration = 40000

                transitions = list()
                transitions.append(
                    TemperatureTransition(1700, duration=duration))
                transitions.append(
                    TemperatureTransition(6500, duration=duration))
                flow = Flow(count=count, transitions=transitions)

            if effect == EFFECT_RANDOM_LOOP:
                count = 0
                duration = 3000

                transitions = list()
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=duration))
                flow = Flow(count=count, transitions=transitions)

            if effect == EFFECT_RANDOM_FASTLOOP:
                count = 0
                duration = 800

                transitions = list()
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=duration))
                flow = Flow(count=count, transitions=transitions)

            if effect == EFFECT_SLOWDOWN:
                count = 0

                transitions = list()
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=250))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=500))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=1000))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=200))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=3000))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=4000))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=5000))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=6000))
                flow = Flow(count=count, transitions=transitions)

            if effect == EFFECT_WHATSAPP_NOTIFY:
                count = 1
                duration = 250

                transitions = list()
                transitions.append(
                    RGBTransition(37,
                                  211,
                                  102,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(SleepTransition(duration=transition))
                transitions.append(
                    RGBTransition(37,
                                  211,
                                  102,
                                  brightness=10,
                                  duration=duration))
                transitions.append(
                    RGBTransition(37,
                                  211,
                                  102,
                                  brightness=self.brightness,
                                  duration=duration))
                flow = Flow(count=count, transitions=transitions)

            if effect == EFFECT_FACEBOOK_NOTIFY:
                count = 1
                duration = 250

                transitions = list()
                transitions.append(
                    RGBTransition(59,
                                  89,
                                  152,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(SleepTransition(duration=transition))
                transitions.append(
                    RGBTransition(59,
                                  89,
                                  152,
                                  brightness=10,
                                  duration=duration))
                transitions.append(
                    RGBTransition(59,
                                  89,
                                  152,
                                  brightness=self.brightness,
                                  duration=duration))
                flow = Flow(count=count, transitions=transitions)

            if effect == EFFECT_TWITTER_NOTIFY:
                count = 1
                duration = 250

                transitions = list()
                transitions.append(
                    RGBTransition(0,
                                  172,
                                  237,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(SleepTransition(duration=transition))
                transitions.append(
                    RGBTransition(0,
                                  172,
                                  237,
                                  brightness=10,
                                  duration=duration))
                transitions.append(
                    RGBTransition(0,
                                  172,
                                  237,
                                  brightness=self.brightness,
                                  duration=duration))
                flow = Flow(count=count, transitions=transitions)

            if effect == EFFECT_STOP:
                self._bulb.stop_flow()
                return
            try:
                self._bulb.start_flow(flow)
            except BulbException as ex:
                _LOGGER.error("Unable to set effect: %s", ex)
示例#29
0
    def load_transition(self, transition):
        # LOG.info("transition: " & transition)
#        flow = Flow(
#            count=10,
#            transitions=strobe(),  # Call the transition preset to get the
#            # transitions you like.
#        )

        if transition == "alarm":
            bulbLHS.start_flow(Flow(transitions=alarm()))
            bulbRHS.start_flow(Flow(transitions=alarm()))
        if transition == "christmas":
            bulbLHS.start_flow(Flow(transitions=christmas()))
            sleep(3)
            bulbRHS.start_flow(Flow(transitions=christmas()))
        if transition == "disco":
            bulbLHS.start_flow(Flow(transitions=disco()))
            bulbRHS.start_flow(Flow(transitions=disco()))
        if transition == "lsd":
            bulbLHS.start_flow(Flow(transitions=lsd()))
            bulbRHS.start_flow(Flow(transitions=lsd()))
        if transition == "police":
            bulbLHS.start_flow(Flow(transitions=police()))
            bulbRHS.start_flow(Flow(transitions=police()))
        if transition == "pulse":
            bulbLHS.start_flow(Flow(transitions=pulse()))
            bulbRHS.start_flow(Flow(transitions=pulse()))
        if transition == "random":
            bulbLHS.start_flow(Flow(transitions=randomloop()))
            bulbRHS.start_flow(Flow(transitions=randomloop()))
        if transition == "strobe":
            if random.random() < 0.7:
                bulbLHS.start_flow(Flow(transitions=strobe()))
                bulbRHS.start_flow(Flow(transitions=strobe()))
            else:
                bulbLHS.start_flow(Flow(transitions=strobe_color()))
                bulbRHS.start_flow(Flow(transitions=strobe_color()))
示例#30
0
#!/usr/bin/env python3

from yeelight import RGBTransition, Flow
from bulb_ip import B
from state import get_state

color = int(get_state(props=['rgb'])['rgb'])
b = color & 0xff
color >>= 8
g = color & 0xff
color >>= 8
r = color & 0xff

pink = RGBTransition(0xff, 0x16, 0x94, 500, 100)
pink = RGBTransition(0xff, 0x00, 0xff, 500, 100)
current = RGBTransition(r, g, b, 500, 100)
transitions = [pink if i % 2 == 0 else current for i in range(9)]

flow = Flow(count=1, transitions=transitions)

B.start_flow(flow)