Dim the device one step.
760852
def dim(self):
        """"""
        dim_command = StandardSend(
            self._address, COMMAND_LIGHT_DIM_ONE_STEP_0X16_0X00)
        self._send_method(dim_command)
368094
def mute(self):
        """"""
        response = self.rendering_control.GetMute(InstanceID=1, Channel=1)
        return response.CurrentMute == 1
423707
def blink(self, status):
        """"""
        self._display_control = ByteUtil.apply_flag(self._display_control, Command.BLINKING_ON, status)
        self.command(self._display_control)
618205
def skip(self, steps=1):
        """"""
        for _ in six.moves.range(steps):
            self.next_token()
21056
def _transition(self, duration, brightness, temperature):
        
        # Set initial value.
        b_start = self.brightness
        t_start = self.temperature
        # Compute ideal step amount.
        b_steps = 0
        if brightness is not None:
            b_steps = steps(self.brightness, brightness,
                            self.command_set.brightness_steps)
        t_steps = 0
        if temperature is not None:
            t_steps = steps(self.temperature, temperature,
                            self.command_set.temperature_steps)
        # Compute ideal step amount (at least one).
        total_steps = max(b_steps, t_steps, 1)
        total_commands = b_steps + t_steps
        # Calculate wait.
        wait = self._wait(duration, total_steps, total_commands)
        # Scale down steps if no wait time.
        if wait == 0:
            b_steps, t_steps = self._scale_steps(duration, total_commands,
                                                 b_steps, t_steps)
            total_steps = max(b_steps, t_steps, 1)
        # Perform transition.
        for i in range(total_steps):
            # Brightness.
            if b_steps > 0 and i % (total_steps / b_steps) == 0:
                self.brightness = util.transition(i, total_steps,
                                                  b_start, brightness)
            # Temperature.
            elif t_steps > 0:
                self.temperature = util.transition(i, total_steps,
                                                   t_start, temperature)
            # Wait.
            time.sleep(wait)
1022336
def brighten(self, defer_update=False):
        """"""
        msg = X10Send.unit_code_msg(self.address.x10_housecode,
                                    self.address.x10_unitcode)
        self._send_method(msg)

        msg = X10Send.command_msg(self.address.x10_housecode,
                                  X10_COMMAND_BRIGHT)
        self._send_method(msg, False)
        if not defer_update:
            self._update_subscribers(self._value + 255 / self._steps)
1201223
def home(self, n=1, interval=0, pre_dl=None, post_dl=None):
        
        self.delay(pre_dl)
        self.k.tap_key(self.k.home_key, n, interval)
        self.delay(post_dl)
304444
def set_power(self, sid, state):
    """"""
    sid_mask = 0x01 << (sid - 1)
    return self.set_power_mask(sid_mask, state)
594216
def reset(self):
        """"""
        self.start = 1
        self.count = None
        self.end = None
        self.stride = 1
        self.format = "%d"
1298490
function(_silent) {
        if (this.enableHighlight) {
            if (this.tree.singleNodeHighlight) {
                if (this.tree._currentlyHighlighted) {
                    this.tree._currentlyHighlighted.unhighlight(_silent);
                }
                this.tree._currentlyHighlighted = this;
            }
            this.highlightState = 1;
            this._setHighlightClassName();
            if (!this.tree.singleNodeHighlight) {
				if (this.propagateHighlightDown) {
					for (var i = 0;i < this.children.length;i++) {
						this.children[i].highlight(true);
					}
				}
				if (this.propagateHighlightUp) {
					if (this.parent) {
						this.parent._childrenHighlighted();
					}
				}
			}
            if (!_silent) {
                this.tree.fireEvent('highlightEvent',this);
            }
        }
    }
765809
private void minimize()
    {
        if (timer != null)
        {
            timer.stop();
            timer = null;
        }
        
        currentHeight = getHeight();
        double steps = (double)durationMS / delayMS;
        double delta = currentHeight - minimizedHeight;
        final int stepSize = (int)Math.ceil(delta / steps);
        
        //System.out.println("steps " + steps);
        //System.out.println("currentHeight " + currentHeight);
        //System.out.println("delta " + delta);
        //System.out.println("stepSize " + stepSize);
        
        timer = new Timer(delayMS, new ActionListener()
        {
            @Override
            public void actionPerformed(ActionEvent e)
            {
                currentHeight -= stepSize;
                currentHeight = Math.max(currentHeight, minimizedHeight);
                if (currentHeight <= minimizedHeight)
                {
                    minimized = true;
                    timer.stop();
                    timer = null;
                }
                revalidate();
            }
        });
        timer.setInitialDelay(0);
        timer.start();
    }
960510
def _reset(self):
        
        # Analog pin 0
        self.hw.remote_at(
            dest_addr=self.remote_addr,
            command='D0',
            parameter='\x02')

        # Disengage remote LED, buzzer
        self.deactivate()
        self._set_send_samples(False)
122221
function(brightness, callback) {
    if (brightness < 0 || brightness > 15) {
      throw "Invalid brightness number";
    }
    this._shiftOut(MAX7219._Registers.Intensity, brightness, callback);
  }
519782
def set_all_pwm(self, on, off):
        """"""
        self.i2c.write8(ALL_LED_ON_L, on & 0xFF)
        self.i2c.write8(ALL_LED_ON_H, on >> 8)
        self.i2c.write8(ALL_LED_OFF_L, off & 0xFF)
        self.i2c.write8(ALL_LED_OFF_H, off >> 8)
1174271
def transition(self, duration, brightness=None):
        
        if duration == 0:
            if brightness is not None:
                self.brightness = brightness
            return
        if brightness != self.brightness:
            self._transition(duration, brightness)
226412
def reset(self):
        """"""
        self.v = self.c
        self.u = self.b * self.v
        self.fired = 0.0
        self.current = self.bias
1086511
def set_brightness(self, brightness):
        
        percent = 0
        if brightness > 0:
            percent = round(brightness / 2.55)

        self.set_service_value(
            self.dimmer_service,
            'LoadLevelTarget',
            'newLoadlevelTarget',
            percent)
        self.set_cache_value('level', percent)