def __init__(self, i2c_bus, *, address=_GPSI2C_DEFAULT_ADDRESS, debug=False, timeout=5): import adafruit_bus_device.i2c_device as i2c_device # pylint: disable=import-outside-toplevel super().__init__(None, debug) # init the parent with no UART self._i2c = i2c_device.I2CDevice(i2c_bus, address) self._lastbyte = None self._charbuff = bytearray(1) self._internalbuffer = [] self._timeout = timeout
def __init__(self, i2c_bus, address=_LIS3MDL_DEFAULT_ADDRESS): # pylint: disable=no-member self.i2c_device = i2c_device.I2CDevice(i2c_bus, address) if self._chip_id != _LIS3MDL_CHIP_ID: raise RuntimeError("Failed to find LIS3MDL - check your wiring!") self.reset() self.performance_mode = PerformanceMode.MODE_ULTRA self.data_rate = Rate.RATE_155_HZ self.range = Range.RANGE_4_GAUSS self.operation_mode = OperationMode.CONTINUOUS sleep(0.010)
def __init__(self, i2c_bus, address=0x40): self.i2c_device = i2cdevice.I2CDevice(i2c_bus, address) if self._manufacturer_id != self.TEXAS_INSTRUMENT_ID: raise RuntimeError( "Failed to find Texas Instrument ID, read {} while expected {}" " - check your wiring!".format(self._manufacturer_id, self.TEXAS_INSTRUMENT_ID)) if self._device_id != self.INA260_ID: raise RuntimeError( "Failed to find INA260 ID, read {} while expected {}" " - check your wiring!".format(self._device_id, self.INA260_ID))
def __init__(self, i2c, address=_STMPE_ADDR): """ Check the STMPE610 was founnd Default address is 0x41 but another address can be passed in as an argument """ import adafruit_bus_device.i2c_device as i2cdev # pylint: disable=import-outside-toplevel self._i2c = i2cdev.I2CDevice(i2c, address) # Check device version. version = self.get_version if _STMPE_VERSION != version: raise RuntimeError("Failed to find STMPE610! Chip Version 0x%x" % version) super().__init__()
def __init__(self, i2c: busio.I2C, address: int = MPR121_I2CADDR_DEFAULT) -> None: """Creates a new ``MPR121`` instance. :param i2c: An I2C driver. :type i2c: class:`busio.I2C` :param address: The address of the touch sensor (0x5A - 0x5D). :type address: int """ self._i2c = i2c_device.I2CDevice(i2c, address) self._buffer = bytearray(2) self._channels = [None] * 12 self.reset()
def __init__( self, i2c: I2C, address: Union[int, Tuple, List] = 0x70, auto_write: bool = True, brightness: float = 1.0, ) -> None: if isinstance(address, (tuple, list)): self.i2c_device = [] for addr in address: self.i2c_device.append(i2c_device.I2CDevice(i2c, addr)) else: self.i2c_device = [i2c_device.I2CDevice(i2c, address)] self._temp = bytearray(1) self._buffer_size = 17 self._buffer = bytearray((self._buffer_size) * len(self.i2c_device)) self._auto_write = auto_write self.fill(0) for i, _ in enumerate(self.i2c_device): self._write_cmd(_HT16K33_OSCILATOR_ON, i) self._blink_rate = None self._brightness = None self.blink_rate = 0 self.brightness = brightness
def __init__(self, i2c, address=0x70, auto_write=True, brightness=1.0): self.i2c_device = i2c_device.I2CDevice(i2c, address) self._ram_buffer = bytearray(17) self._mv_buffer = memoryview(self._ram_buffer) self._display_ram = self._mv_buffer[1:] self._content = [None] * 4 self._auto_write = auto_write self._write_cmd(_HT16K33_OSCILATOR_ON) self.clear() self._blink_rate = None self._brightness = None self.blink_rate = 0 self.brightness = brightness
def __init__(self, i2c, address=0x60): self.i2c_device = i2cdevice.I2CDevice(i2c, address) if self._device_id != 0x186: raise RuntimeError("Failed to find VCNL4040 - check wiring!") self.cached_interrupt_state = { self.ALS_IF_L: False, self.ALS_IF_H: False, self.PS_IF_CLOSE: False, self.PS_IF_AWAY: False, } self.proximity_shutdown = False self.light_shutdown = False self.white_shutdown = False
def __init__(self, i2c, *, address=_SI4710_ADDR1, reset=None, timeout_s=0.1): self._timeout_s = timeout_s self._device = i2c_device.I2CDevice(i2c, address) # Configure reset line if it was provided. self._reset = reset if self._reset is not None: self._reset.switch_to_output(value=True) self.reset() # Check product ID. if self._get_product_number() != 13: raise RuntimeError('Failed to find SI4713, check wiring!')
def set_address(self, new_address): """Set a new I2C address to the instantaited object. This is only called when using multiple VL53L0X sensors on the same I2C bus (SDA & SCL pins). See also the `example <examples.html#multiple-vl53l0x-on-same-i2c-bus>`_ for proper usage. :param int new_address: The 7-bit `int` that is to be assigned to the VL53L0X sensor. The address that is assigned should NOT be already in use by another device on the I2C bus. .. important:: To properly set the address to an individual VL53L0X sensor, you must first ensure that all other VL53L0X sensors (using the default address of ``0x29``) on the same I2C bus are in their off state by pulling the "SHDN" pins LOW. When the "SHDN" pin is pulled HIGH again the default I2C address is ``0x29``. """ self._write_u8(_I2C_SLAVE_DEVICE_ADDRESS, new_address & 0x7F) self._device = i2c_device.I2CDevice(self._i2c, new_address)
def __init__(self, i2c_bus, mpu_addr=_MPU6500_DEFAULT_ADDRESS, akm_addr=_AK8963_DEFAULT_ADDRESS): self.i2c_device = i2c_device.I2CDevice(i2c_bus, mpu_addr) if self._device_id != _MPU9250_DEVICE_ID: raise RuntimeError("Failed to find MPU9250 - check your wiring!") self._mpu = MPU6500(i2c_bus, mpu_addr) self._bypass = 1 self._ready = 1 sleep(0.100) self._akm = AK8963(i2c_bus, akm_addr)
def __init__(self, i2c_bus, address=_TLV493D_DEFAULT_ADDRESS, addr_reg=0): self.i2c_device = i2cdevice.I2CDevice(i2c_bus, address) self.read_buffer = bytearray(10) self.write_buffer = bytearray(4) # read in data from sensor, including data that must be set on a write self._setup_write_buffer() # write correct i2c address self._set_write_key("ADDR", addr_reg) # setup MASTERCONTROLLEDMODE which takes a measurement for every read self._set_write_key("PARITY", 1) self._set_write_key("FAST", 1) self._set_write_key("LOWPOWER", 1) self._write_i2c()
def __init__(self, i2c_bus, address=_MPU6050_DEFAULT_ADDRESS): self.i2c_device = i2c_device.I2CDevice(i2c_bus, address) if self._device_id != _MPU6050_DEVICE_ID: raise RuntimeError("Failed to find MPU6050 - check your wiring!") self.reset() self._sample_rate_divisor = 0 self._filter_bandwidth = Bandwidth.BAND_260_HZ self._gyro_range = GyroRange.RANGE_500_DPS self._accel_range = Range.RANGE_2_G sleep(0.100) self._clock_source = 1 # set to use gyro x-axis as reference sleep(0.100) self.sleep = False sleep(0.010)
def __init__(self, i2c, gain=CONST_GAIN_1X, integration=CONST_INT_100, rate=CONST_RATE_500): import adafruit_bus_device.i2c_device as i2c_device self._i2c = i2c_device.I2CDevice(i2c, LTR_ADDRESS) self._buffer = bytearray(2) self._gain = gain self._integration = integration self._rate = rate self._active = 0x01 # just in case it we are just starting, choip needs 10ms after boot time.sleep(0.1) self._write_register_byte( REG_ALS_MEAS_RATE, self._get_meas_rate(integration, rate)) self._write_register_byte( REG_ALS_CONTR, self._get_contr(gain) | self._active) time.sleep(0.01)
def __init__(self, i2c_bus, ambient_pressure=0, address=SCD30_DEFAULT_ADDR): if ambient_pressure != 0: if ambient_pressure < 700 or ambient_pressure > 1200: raise AttributeError("`ambient_pressure` must be from 700-1200 mBar") self.i2c_device = i2c_device.I2CDevice(i2c_bus, address) self._buffer = bytearray(18) self._crc_buffer = bytearray(2) # set continuous measurement interval in seconds self.measurement_interval = 2 # trigger continuous measurements with optional ambient pressure compensation self.ambient_pressure = ambient_pressure # cached readings self._temperature = None self._relative_humidity = None self._co2 = None
def __init__(self, bus, address=0x40): self.config_data = None self._bus = i2c_device.I2CDevice(bus, address) if self.device_id == b"\x01\x2B\xa0\x43": # Mach XO2 1200 pass elif self.device_id == b"\x61\x2B\xd0\x43": # Mach XO3 6900 pass elif self.device_id == b"\x01\x2B\x50\x43": # Mach X02 7000 pass else: print([hex(x) for x in self.device_id]) raise ValueError("Unable to confirm Mach XO device id") self._erased = False self._config_mode = False
def __init__(self, i2c_bus, address=_LSM6DSOX_DEFAULT_ADDRESS): self.i2c_device = i2c_device.I2CDevice(i2c_bus, address) if self._chip_id not in [_LSM6DSOX_CHIP_ID, _ISM330DHCX_CHIP_ID]: raise RuntimeError( "Failed to find LSM6DSOX or ISM330DHCX - check your wiring!") self.reset() self._bdu = True self._i3c_disable = True self._if_inc = True self._accel_data_rate = Rate.RATE_104_HZ #pylint: disable=no-member self._gyro_data_rate = Rate.RATE_104_HZ #pylint: disable=no-member self._accel_range = AccelRange.RANGE_4G #pylint: disable=no-member self._cached_accel_range = self._accel_range self._gyro_range = GyroRange.RANGE_250_DPS #pylint: disable=no-member self._cached_gyro_range = self._gyro_range
def __init__(self, i2c, *, address=_MMA8451_DEFAULT_ADDRESS): self._device = i2c_device.I2CDevice(i2c, address) # Verify device ID. if self._read_u8(_MMA8451_REG_WHOAMI) != 0x1A: raise RuntimeError('Failed to find MMA8451, check wiring!') # Reset and wait for chip to be ready. self._write_u8(_MMA8451_REG_CTRL_REG2, 0x40) while self._read_u8(_MMA8451_REG_CTRL_REG2) & 0x40 > 0: pass # Enable 4G range. self._write_u8(_MMA8451_REG_XYZ_DATA_CFG, RANGE_4G) # High resolution mode. self._write_u8(_MMA8451_REG_CTRL_REG2, 0x02) # DRDY on INT1 self._write_u8(_MMA8451_REG_CTRL_REG4, 0x01) self._write_u8(_MMA8451_REG_CTRL_REG5, 0x01) # Turn on orientation config self._write_u8(_MMA8451_REG_PL_CFG, 0x40) # Activate at max rate, low noise mode self._write_u8(_MMA8451_REG_CTRL_REG1, 0x01 | 0x04)
def __init__( self, width, height, i2c, *, addr=0x3C, external_vcc=False, reset=None ): self.i2c_device = i2c_device.I2CDevice(i2c, addr) self.addr = addr self.temp = bytearray(2) # Add an extra byte to the data buffer to hold an I2C data/command byte # to use hardware-compatible I2C transactions. A memoryview of the # buffer is used to mask this byte from the framebuffer operations # (without a major memory hit as memoryview doesn't copy to a separate # buffer). self.buffer = bytearray(((height // 8) * width) + 1) self.buffer[0] = 0x40 # Set first byte of data buffer to Co=0, D/C=1 super().__init__( memoryview(self.buffer)[1:], width, height, external_vcc=external_vcc, reset=reset, )
def __init__(self, i2c_bus, address=_LSM6DS_DEFAULT_ADDRESS): self._cached_accel_range = None self._cached_gyro_range = None self.i2c_device = i2c_device.I2CDevice(i2c_bus, address) if self.CHIP_ID is None: raise AttributeError( "LSM6DS Parent Class cannot be directly instantiated") if self._chip_id != self.CHIP_ID: raise RuntimeError("Failed to find %s - check your wiring!" % self.__class__.__name__) self.reset() self._bdu = True self.accelerometer_data_rate = Rate.RATE_104_HZ # pylint: disable=no-member self.gyro_data_rate = Rate.RATE_104_HZ # pylint: disable=no-member self.accelerometer_range = AccelRange.RANGE_4G # pylint: disable=no-member self.gyro_range = GyroRange.RANGE_250_DPS # pylint: disable=no-member
def __init__(self, i2c, *, address=_MPL3115A2_ADDRESS): self._device = i2c_device.I2CDevice(i2c, address) # Validate the chip ID. if self._read_u8(_MPL3115A2_WHOAMI) != 0xC4: raise RuntimeError('Failed to find MPL3115A2, check your wiring!') # Reset. Note the chip immediately resets and won't send an I2C back # so we need to catch the OSError and swallow it (otherwise this fails # expecting an ACK that never comes). try: self._write_u8(_MPL3115A2_CTRL_REG1, _MPL3115A2_CTRL_REG1_RST) except OSError: pass time.sleep(0.01) # Poll for the reset to finish. self._poll_reg1(_MPL3115A2_CTRL_REG1_RST) # Configure the chip registers with default values. self._ctrl_reg1 = _MPL3115A2_CTRL_REG1_OS128 | _MPL3115A2_CTRL_REG1_ALT self._write_u8(_MPL3115A2_CTRL_REG1, self._ctrl_reg1) self._write_u8(_MPL3115A2_PT_DATA_CFG, _MPL3115A2_PT_DATA_CFG_TDEFE | \ _MPL3115A2_PT_DATA_CFG_PDEFE | \ _MPL3115A2_PT_DATA_CFG_DREM)
def __init__(self, i2c_bus, address=_DPS310_DEFAULT_ADDRESS): self.i2c_device = i2c_device.I2CDevice(i2c_bus, address) if self._device_id != _DPS310_DEVICE_ID: raise RuntimeError("Failed to find DPS310 - check your wiring!") self._pressure_scale = None self._temp_scale = None self._c0 = None self._c1 = None self._c00 = None self._c00 = None self._c10 = None self._c10 = None self._c01 = None self._c11 = None self._c20 = None self._c21 = None self._c30 = None self._oversample_scalefactor = (524288, 1572864, 3670016, 7864320, 253952, 516096, 1040384, 2088960) self.initialize()
def __init__(self, i2c_interface=None, busnum=1, address=0x0c, mode=MODE_CONTINUOUS_MEASURE_2, output=OUTPUT_16_BIT, offset=(0, 0, 0), scale=(1, 1, 1)): self.i2c = i2c_device.I2CDevice(i2c_interface, address) self.address = address self._offset = offset self._scale = scale if 0x48 != self.read_whoami(): raise RuntimeError("AK8963 not found in I2C bus.") # Sensitivity adjustment values self._write_u8(_CNTL1, _MODE_FUSE_ROM_ACCESS) asax = self._read_u8(_ASAX) asay = self._read_u8(_ASAY) asaz = self._read_u8(_ASAZ) self._write_u8(_CNTL1, _MODE_POWER_DOWN) # Should wait at least 100us before next mode time.sleep(100e-6) self._adjustment = ((0.5 * (asax - 128)) / 128 + 1, (0.5 * (asay - 128)) / 128 + 1, (0.5 * (asaz - 128)) / 128 + 1) # Power on self._write_u8(_CNTL1, (mode | output)) if output is OUTPUT_16_BIT: self._so = _SO_16BIT else: self._so = _SO_14BIT
def __init__(self, i2c, *, address=_SI5351_ADDRESS): self._device = i2c_device.I2CDevice(i2c, address) # Setup the SI5351. # Disable all outputs setting CLKx_DIS high. self._write_u8(_SI5351_REGISTER_3_OUTPUT_ENABLE_CONTROL, 0xFF) # Power down all output drivers self._write_u8(_SI5351_REGISTER_16_CLK0_CONTROL, 0x80) self._write_u8(_SI5351_REGISTER_17_CLK1_CONTROL, 0x80) self._write_u8(_SI5351_REGISTER_18_CLK2_CONTROL, 0x80) self._write_u8(_SI5351_REGISTER_19_CLK3_CONTROL, 0x80) self._write_u8(_SI5351_REGISTER_20_CLK4_CONTROL, 0x80) self._write_u8(_SI5351_REGISTER_21_CLK5_CONTROL, 0x80) self._write_u8(_SI5351_REGISTER_22_CLK6_CONTROL, 0x80) self._write_u8(_SI5351_REGISTER_23_CLK7_CONTROL, 0x80) # Initialize PLL A and B objects. self.pll_a = self._PLL(self, 26, 0) self.pll_b = self._PLL(self, 34, (1 << 5)) # Initialize the 3 clock outputs. self.clock_0 = self._Clock( self, _SI5351_REGISTER_42_MULTISYNTH0_PARAMETERS_1, _SI5351_REGISTER_16_CLK0_CONTROL, _SI5351_REGISTER_44_MULTISYNTH0_PARAMETERS_3, ) self.clock_1 = self._Clock( self, _SI5351_REGISTER_50_MULTISYNTH1_PARAMETERS_1, _SI5351_REGISTER_17_CLK1_CONTROL, _SI5351_REGISTER_52_MULTISYNTH1_PARAMETERS_3, ) self.clock_2 = self._Clock( self, _SI5351_REGISTER_58_MULTISYNTH2_PARAMETERS_1, _SI5351_REGISTER_18_CLK2_CONTROL, _SI5351_REGISTER_60_MULTISYNTH2_PARAMETERS_3, )
def __init__(self, i2c, address=_FXOS8700_ADDRESS, accel_range=ACCEL_RANGE_2G): assert accel_range in (ACCEL_RANGE_2G, ACCEL_RANGE_4G, ACCEL_RANGE_8G) self._accel_range = accel_range self._device = i2c_dev.I2CDevice(i2c, address) # Check for chip ID value. if self._read_u8(_FXOS8700_REGISTER_WHO_AM_I) != _FXOS8700_ID: raise RuntimeError("Failed to find FXOS8700, check wiring!") # Set to standby mode (required to make changes to this register) self._write_u8(_FXOS8700_REGISTER_CTRL_REG1, 0) if accel_range == ACCEL_RANGE_2G: self._write_u8(_FXOS8700_REGISTER_XYZ_DATA_CFG, 0x00) elif accel_range == ACCEL_RANGE_4G: self._write_u8(_FXOS8700_REGISTER_XYZ_DATA_CFG, 0x01) elif accel_range == ACCEL_RANGE_8G: self._write_u8(_FXOS8700_REGISTER_XYZ_DATA_CFG, 0x02) # High resolution self._write_u8(_FXOS8700_REGISTER_CTRL_REG2, 0x02) # Active, Normal Mode, Low Noise, 100Hz in Hybrid Mode self._write_u8(_FXOS8700_REGISTER_CTRL_REG1, 0x15) # Configure the magnetometer # Hybrid Mode, Over Sampling Rate = 16 self._write_u8(_FXOS8700_REGISTER_MCTRL_REG1, 0x1F) # Jump to reg 0x33 after reading 0x06 self._write_u8(_FXOS8700_REGISTER_MCTRL_REG2, 0x20)
def __init__(self, i2c, *, address=_SI4710_ADDR1, reset=None, timeout_s=0.1): self._timeout_s = timeout_s # Configure reset line if it was provided. self._reset = reset if self._reset is not None: self._reset.switch_to_output(value=True) # Toggle reset line low to reset the chip and then wait a bit for # startup - this is necessary before initializing as an i2c device # on at least the Raspberry Pi, and potentially elsewhere: self._reset.value = True time.sleep(0.01) self._reset.value = False time.sleep(0.01) self._reset.value = True time.sleep(0.25) self._device = i2c_device.I2CDevice(i2c, address) self.reset() # Check product ID. if self._get_product_number() != 13: raise RuntimeError('Failed to find SI4713, check wiring!')
def __init__( self, i2c_interface=None, busnum=1, address=0x68, accel_fs=ACCEL_FS_SEL_2G, gyro_fs=GYRO_FS_SEL_500DPS, accel_sf=SF_M_S2, gyro_sf=_GYRO_SO_500DPS, gyro_offset=(0, 0, 0) ): self.i2c = i2c_device.I2CDevice(i2c_interface, address) self.address = address if 0x71 != self.read_whoami(): raise RuntimeError("MPU6500 not found in I2C bus.") self._accel_so = self._accel_fs(accel_fs) self._gyro_so = self._gyro_fs(gyro_fs) self._accel_sf = accel_sf self._gyro_sf = gyro_sf self._gyro_offset = gyro_offset # Enable I2C bypass to access for MPU9250 magnetometer access. char = self._read_u8(_INT_PIN_CFG) char &= ~_I2C_BYPASS_MASK # clear I2C bits char |= _I2C_BYPASS_EN self._write_u8(_INT_PIN_CFG, char)
def __init__(self, i2c, rng=L3DS20_RANGE_250DPS, address=0x6B): import adafruit_bus_device.i2c_device as i2c_device self.i2c_device = i2c_device.I2CDevice(i2c, address) self.buffer = bytearray(2) super().__init__(rng)
def __init__(self, i2c, address=_MPL115A2_ADDRESS): self._i2c = i2c_device.I2CDevice(i2c, address) self._buf = bytearray(4) self._read_coefficients()
def __init__(self, i2c, *, address=0x18, int1=None, int2=None): import adafruit_bus_device.i2c_device as i2c_device self._i2c = i2c_device.I2CDevice(i2c, address) self._buffer = bytearray(6) super().__init__(int1=int1, int2=int2)