Put the aux i2c bus on the MPU-6050 in bypass mode, thus connecting it to the main i2c bus directly

        Dont forget to use wakeup() or else the slave bus is unavailable
        :param enable:
        :return:
356095
def set_slave_bus_bypass(self, enable):
        
        current = self.i2c_read_register(0x37, 1)[0]
        if enable:
            current |= 0b00000010
        else:
            current &= 0b11111101
        self.i2c_write_register(0x37, current)
1102492
public function enable()
    {
        if ($this->driver !== null) {
            $this->pool->setDriver($this->driver);
        }
        $this->enabled = true;
    }
596650
def _server_enable():
    
    prev = None if "enabled" not in db else db["enabled"]
    if args["disable"]:
        db["enabled"] = False
        okay("Disabled the CI server. No pull requests will be processed.")

    if args["enable"]:
        db["enabled"] = True
        okay("Enabled the CI server. Pull request monitoring online.")

    #Only perform the save if something actually changed.
    if prev != db["enabled"]:
        _save_db()
258463
def setAutoDetachKernelDriver(self, enable):
        
        mayRaiseUSBError(libusb1.libusb_set_auto_detach_kernel_driver(
            self.__handle, bool(enable),
        ))
1348896
def _get_slave_enabled(self, dpid, port):
        """"""
        slave = self._get_slave(dpid, port)
        if slave:
            return slave['enabled']
        else:
            return False
270631
def enable(self):
        
        logger.debug('enable()')
        self.options.enabled = True
        logger.info('cache enabled')
351636
def enable_gui(gui=None, app=None):
        
        # Deferred import
        from pydev_ipython.inputhook import enable_gui as real_enable_gui
        try:
            return real_enable_gui(gui, app)
        except ValueError as e:
            raise UsageError("%s" % e)
500642
def enable(self, cmd="enable-admin", pattern="ssword", re_flags=re.IGNORECASE):
        """"""
        return super(AlcatelSrosSSH, self).enable(
            cmd=cmd, pattern=pattern, re_flags=re_flags
        )
7401
def standby(self):
        
        register = self.MMA8452Q_Register['CTRL_REG1']
        self.board.i2c_read_request(self.address, register, 1,
                                    Constants.I2C_READ | Constants.I2C_END_TX_MASK,
                                    self.data_val, Constants.CB_TYPE_DIRECT)


        ctrl1 = self.wait_for_read_result()

        ctrl1 = (ctrl1[self.data_start]) & ~0x01
        self.callback_data = []

        self.board.i2c_write_request(self.address, [register, ctrl1])
713700
def pullup(self, pin, enabled):
        
        self._validate_channel(pin)
        if enabled:
            self.gppu[int(pin/8)] |= 1 << (int(pin%8))
        else:
            self.gppu[int(pin/8)] &= ~(1 << (int(pin%8)))
        self._write_gppu()
757832
def set_enable(self, channel, value):
        '''
        '''
        try:
            bit = self._ch_map[channel]['GPIOEN']['bit']
        except KeyError:
            raise ValueError('set_enable() not supported for channel %s' % channel)
        self._set_power_gpio_value(bit=bit, value=value)
16845
def enable_lldp(self):
        
        if self.is_ncb:
            self.run_lldptool(["-L", "-i", self.port_name, "-g", "ncb",
                               "adminStatus=rxtx"])
        if self.is_nb:
            self.run_lldptool(["-L", "-i", self.port_name, "-g", "nb",
                               "adminStatus=rxtx"])
809834
def set_mode_flag(self, flag, enable):
        '''
        
        '''
        if self.mavlink10():
            mode = self.base_mode
            if (enable == True):
                mode = mode | flag
            elif (enable == False):
                mode = mode & ~flag
            self.mav.command_long_send(self.target_system, self.target_component,
                                           mavlink.MAV_CMD_DO_SET_MODE, 0,
                                           mode,
                                           0, 0, 0, 0, 0, 0)
        else:
            print("Set mode flag not supported")
599922
def available(self):
        
        register = self.MMA8452Q_Register['STATUS']
        self.board.i2c_read_request(self.address, register, 1,
                                    Constants.I2C_READ | Constants.I2C_END_TX_MASK,
                                    self.data_val, Constants.CB_TYPE_DIRECT)


        avail = self.wait_for_read_result()
        avail = (avail[self.data_start] & 0x08) >> 3

        return avail
453963
def enable():
    
    Benchmark.enable = True
    ComparisonBenchmark.enable = True
    BenchmarkedFunction.enable = True
    BenchmarkedClass.enable = True
1052055
public static base_response enable(nitro_service client) throws Exception {
		ntpsync enableresource = new ntpsync();
		return enableresource.perform_operation(client,"enable");
	}
680813
def enable(self):
        
        core_napps_manager = CoreNAppsManager(base_path=self._enabled)
        core_napps_manager.enable(self.user, self.napp)