def test_get_register(): bus = MockSMBus(1) bus.regs[0:3] = [0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF] device = Device([0x00, 0x01], i2c_dev=bus, registers=( Register('test24', 0x00, fields=(BitField('test', 0xFFF), ), bit_width=24), Register('test32', 0x00, fields=(BitField('test', 0xFFF), ), bit_width=32), Register('test48', 0x00, fields=(BitField('test', 0xFFF), ), bit_width=48), )) assert device.get_register('test24') == 0xAABBCC assert device.get_register('test32') == 0xAABBCCDD assert device.get_register('test48') == 0xAABBCCDDEEFF
def __init__(self, i2c_addr=I2C_ADDR1, i2c_dev=None): self._i2c_addr = i2c_addr self._i2c_dev = i2c_dev self._drv8830 = Device( [I2C_ADDR1, I2C_ADDR2, I2C_ADDR3, I2C_ADDR4], i2c_dev=self._i2c_dev, registers=( Register( 'CONTROL', 0x00, fields=( BitField('voltage', 0b11111100, adapter=VoltageAdapter()), # vset BitField('out2', 0b00000010), # in2 BitField('out1', 0b00000001), # in1 BitField( 'direction', 0b00000011, adapter=LookupAdapter({ # both in2 and in1 :D 'coast': 0b00, 'reverse': 0b01, 'forward': 0b10, 'brake': 0b11 })))), Register( 'FAULT', 0x01, fields=( BitField( 'clear', 0b10000000 ), # Clears fault status bits when written to 1 BitField('current_limit', 0b00010000 ), # Fault caused by external current limit BitField( 'over_temperature', 0b00001000 ), # Fault caused by over-temperature condition BitField('under_voltage', 0b00000100 ), # Fault caused by undervoltage lockout BitField( 'over_current', 0b00000010), # Fault caused by overcurrent event BitField('fault', 0b00000001) # Fault condition exists )))) self._drv8830.select_address(self._i2c_addr)
def test_smbus_io(): sys.modules['smbus'] = SMBus device = Device(0x00, i2c_dev=None, registers=(Register('test', 0x00, fields=(BitField('test', 0xFF), )), )) del device
def test_set_regs(): bus = MockSMBus(1) device = Device(0x00, i2c_dev=bus, registers=(Register('test', 0x00, fields=(BitField('test', 0xFF), )), )) device.set('test', test=123) assert device.get('test').test == 123 assert bus.regs[0] == 123
def test_get_set_field_overflow(): bus = MockSMBus(1) device = Device([0x00, 0x01], i2c_dev=bus, registers=(Register('test', 0x00, fields=(BitField('test', 0xFF), )), )) device.set_field('test', 'test', 9999999) assert device.get_field('test', 'test') == 127 assert bus.regs[0] == 127
def __init__(self, i2c_addr=0x45, i2c_dev=None): self._i2c_addr = i2c_addr self._i2c_dev = i2c_dev self._is_setup = False self.shunt_resistor_value = 0.005 # value in ohms self.shunt_voltage_lsb = 0.00001 # 10 uV per LSB self.bus_voltage_lsb = 0.004 # 4mV per LSB self._ina220 = Device([self._i2c_addr], i2c_dev=self._i2c_dev, bit_width=8, registers=( Register('CONFIG', 0x00, fields=( BitField('reset', 0b1000000000000000), BitField('bus_voltage_range', 0b0010000000000000), BitField('pga_gain', 0b0001100000000000, adapter=LookupAdapter({ '40': 0b00, '80': 0b01, '160': 0b10, '320': 0b11 }), bit_width=16), BitField('bus_adc', 0b0000011110000000, adapter=sadc_badc_adapter, bit_width=16), BitField('shunt_adc', 0b0000000001111000, adapter=sadc_badc_adapter, bit_width=16), BitField('mode', 0b0000000000000111, adapter=LookupAdapter({ 'power_down': 0b000, 'shunt_voltage_triggered': 0b001, 'bus_voltage_triggered': 0b010, 'shunt_and_bus_triggered': 0b011, 'adc_off': 0b100, 'shunt_voltage_continuous': 0b101, 'bus_voltage_continuous': 0b110, 'shunt_and_bus_continuous': 0b111 }), bit_width=16), )), Register('SHUNT_VOLTAGE', 0x01, fields=( BitField('reading', 0xFFFF), ), bit_width=16, read_only=True), Register('BUS_VOLTAGE', 0x02, fields=( BitField('reading', 0b1111111111111000), BitField('conversion_ready', 0b0000000000000010), BitField('math_overflow_flag', 0b0000000000000001) ), bit_width=16, read_only=True), Register('POWER', 0x03, fields=( BitField('reading', 0xFFFF), ), bit_width=16, read_only=True), Register('CURRENT', 0x04, fields=( BitField('reading', 0xFFFF), ), bit_width=16, read_only=True), Register('CALIBARTION', 0x05, fields=( BitField('reading', 0xFFFF), ), bit_width=16, read_only=True), )) self._configuration = self.get_configuration()
def __init__(self, i2c_addr=0x38, i2c_dev=None): self._i2c_addr = i2c_addr self._i2c_dev = i2c_dev self._is_setup = False # Device definition self._pca9554a = Device( self._i2c_addr, i2c_dev=self._i2c_dev, bit_width=8, registers=( Register('INPUT', 0x00, fields=(BitField('value', 0xFF), BitField('switch', 0b00001000), BitField('led', 0b00000001))), Register('OUTPUT', 0x01, fields=(BitField('value', 0xFF), BitField('switch', 0b00001000), BitField('led', 0b00000001))), Register('INVERT', 0x02, fields=(BitField('value', 0xFF), BitField('switch', 0b00001000), BitField('led', 0b00000001))), Register('CONFIG', 0x03, fields=(BitField('value', 0xFF), BitField('switch', 0b00001000), BitField('led', 0b00000001))), )) # Set IO configuration for driving switch and LED self._pca9554a.set('OUTPUT', switch=0, led=1) self._pca9554a.set('CONFIG', switch=0, led=0) self.led_enable = True self.switch_enabled = True self.led_status = False self.switch_status = False
def test_address_select(): bus = MockSMBus(1) device = Device([0x00, 0x01], i2c_dev=bus, registers=(Register('test', 0x00, fields=(BitField('test', 0xFF), )), )) assert device.get_addresses() == [0x00, 0x01] assert device.select_address(0x01) is True with pytest.raises(ValueError): device.select_address(0x02) assert device.next_address() == 0x00 assert device.next_address() == 0x01
def test_missing_regiser(): bus = MockSMBus(1) device = Device( [0x00, 0x01], i2c_dev=bus, registers=( Register( 'test', 0x00, fields=( BitFlag('test', 6), # Sixth bit from the right )), )) with pytest.raises(KeyError): device.get_register('foo')
def test_register_locking(): bus = MockSMBus(1) device = Device(0x00, i2c_dev=bus, registers=(Register('test', 0x00, fields=(BitField('test', 0xFF), )), )) device.test.set_test(77) device.lock_register('test') bus.regs[0] = 11 assert device.test.get_test() == 77 device.unlock_register('test') assert device.test.get_test() == 11
def test_adapters(): bus = MockSMBus(1) device = Device(0x00, i2c_dev=bus, registers=(Register( 'adapter', 0x01, fields=(BitField('test', 0xFFFF, adapter=U16ByteSwapAdapter()), )), )) device.adapter.set_test(0xFF00) assert device.adapter.get_test() == 0xFF00 assert bus.regs[0:2] == [0x00, 0xFF]
def test_field_name_in_adapter_error(): bus = MockSMBus(1) device = Device(0x00, i2c_dev=bus, registers=(Register('test', 0x00, fields=(BitField('test', 0xFF00, adapter=LookupAdapter( {'x': 1})), ), bit_width=16), )) with pytest.raises(ValueError) as e: reg = device.get('test') assert 'test' in e del reg
def test_get_regs(): bus = MockSMBus(1) device = Device(0x00, i2c_dev=bus, registers=(Register('test', 0x00, fields=( BitField('test', 0xFF00), BitField('monkey', 0x00FF), ), bit_width=16), )) device.set('test', test=0x66, monkey=0x77) reg = device.get('test') reg.test == 0x66 reg.monkey == 0x77 assert bus.regs[0] == 0x66 assert bus.regs[1] == 0x77
def test_bitflag(): bus = MockSMBus(1) device = Device( [0x00, 0x01], i2c_dev=bus, registers=( Register( 'test', 0x00, fields=( BitFlag('test', 6), # Sixth bit from the right )), )) device.test.set_test(True) assert bus.regs[0] == 0b01000000 device.test.set_test(False) assert bus.regs[0] == 0b00000000
def test_register_proxy(): bus = MockSMBus(1) device = Device(0x00, i2c_dev=bus, registers=(Register('test', 0x00, fields=(BitField('test', 0xFF), )), )) device.test.set_test(123) assert device.test.get_test() == 123 assert bus.regs[0] == 123 with device.test as test: test.set_test(77) test.write() assert device.test.get_test() == 77 assert bus.regs[0] == 77 assert device.test.read() == 77
def test_register_proxy(): """This API pattern has been depricated in favour of set/get.""" bus = MockSMBus(1) device = Device(0x00, i2c_dev=bus, registers=( Register('test', 0x00, fields=( BitField('test', 0xFF), )), )) device.test.set_test(123) assert device.test.get_test() == 123 assert bus.regs[0] == 123 with device.test as test: test.set_test(77) test.write() assert device.test.get_test() == 77 assert bus.regs[0] == 77 assert device.test.read() == 77
def __init__(self, i2c_addr=0x1D, i2c_dev=None): self._i2c_addr = i2c_addr self._i2c_dev = i2c_dev self._lsm303d = Device( [0x1D, 0x1E], i2c_dev=self._i2c_dev, bit_width=8, registers=( Register('TEMPERATURE', 0x05 | 0x80, fields=(BitField('temperature', 0xFFFF, adapter=TemperatureAdapter()), ), bit_width=16), # Magnetometer interrupt status Register('MAGNETOMETER_STATUS', 0x07, fields=( BitField('xdata', 0b00000001), BitField('ydata', 0b00000010), BitField('zdata', 0b00000100), BitField('data', 0b00001000), BitField('xoverrun', 0b00010000), BitField('yoverrun', 0b00100000), BitField('zoverrun', 0b01000000), BitField('overrun', 0b10000000), )), Register('MAGNETOMETER', 0x08 | 0x80, fields=( BitField('x', 0xFFFF00000000, adapter=S16ByteSwapAdapter()), BitField('y', 0x0000FFFF0000, adapter=S16ByteSwapAdapter()), BitField('z', 0x00000000FFFF, adapter=S16ByteSwapAdapter()), ), bit_width=8 * 6), Register('WHOAMI', 0x0F, fields=(BitField('id', 0xFF), )), Register( 'MAGNETOMETER_INTERRUPT', 0x12, fields=( BitField('enable', 0b00000001), BitField('4d', 0b00000010), BitField('latch', 0b00000100), BitField( 'polarity', 0b00001000), # 0 = active-low, 1 = active-high BitField('pin_config', 0b00010000), # 0 = push-pull, 1 = open-drain BitField('z_enable', 0b00100000), BitField('y_enable', 0b01000000), BitField('x_enable', 0b10000000), )), Register('MAGNETOMETER_INTERRUPT_SOURCE', 0x13, fields=( BitField('event', 0b00000001), BitField('overflow', 0b00000010), BitField('z_negative', 0b00000100), BitField('y_negative', 0b00001000), BitField('x_negative', 0b00010000), BitField('z_positive', 0b00100000), BitField('y_positive', 0b01000000), BitField('x_positive', 0b10000000), )), Register('MAGNETOMETER_INTERRUPT_THRESHOLD', 0x14 | 0x80, fields=(BitField('threshold', 0xFFFF, adapter=U16ByteSwapAdapter()), ), bit_width=16), Register('MAGNETOMETER_OFFSET', 0x16 | 0x80, fields=( BitField('x', 0xFFFF00000000, adapter=S16ByteSwapAdapter()), BitField('y', 0x0000FFFF0000, adapter=S16ByteSwapAdapter()), BitField('z', 0x00000000FFFF, adapter=S16ByteSwapAdapter()), ), bit_width=8 * 6), Register('HP_ACCELEROMETER_REFERENCE', 0x1c | 0x80, fields=( BitField('x', 0xFF0000), BitField('y', 0x00FF00), BitField('z', 0x0000FF), ), bit_width=8 * 3), Register('CONTROL0', 0x1f, fields=( BitField('int2_high_pass', 0b00000001), BitField('int1_high_pass', 0b00000010), BitField('click_high_pass', 0b00000100), BitField('fifo_threshold', 0b00100000), BitField('fifo_enable', 0b01000000), BitField('reboot_memory', 0b10000000), )), Register('CONTROL1', 0x20, fields=( BitField('accel_x_enable', 0b00000001), BitField('accel_y_enable', 0b00000010), BitField('accel_z_enable', 0b00000100), BitField('block_data_update', 0b00001000), BitField('accel_data_rate_hz', 0b11110000, adapter=LookupAdapter({ 0: 0, 3.125: 0b0001, 6.25: 0b0010, 12.5: 0b0011, 25: 0b0100, 50: 0b0101, 100: 0b0110, 200: 0b0111, 400: 0b1000, 800: 0b1001, 1600: 0b1010 })), )), Register('CONTROL2', 0x21, fields=( BitField('serial_interface_mode', 0b00000001), BitField('accel_self_test', 0b00000010), BitField('accel_full_scale_g', 0b00111000, adapter=LookupAdapter({ 2: 0b000, 4: 0b001, 6: 0b010, 8: 0b011, 16: 0b100 })), BitField('accel_antialias_bw_hz', 0b11000000, adapter=LookupAdapter({ 50: 0b11, 362: 0b10, 194: 0b01, 773: 0b00 })), )), # Known in the datasheet as CTRL3 Register('INTERRUPT1', 0x22, fields=( BitField('enable_fifo_empty', 0b00000001), BitField('enable_accel_dataready', 0b00000010), BitField('enable_accelerometer', 0b00000100), BitField('enable_magnetometer', 0b00001000), BitField('enable_ig2', 0b00010000), BitField('enable_ig1', 0b00100000), BitField('enable_click', 0b01000000), BitField('enable_boot', 0b10000000), )), # Known in the datasheet as CTRL4 Register('INTERRUPT2', 0x23, fields=( BitField('enable_fifo', 0b00000001), BitField('enable_fifo_overrun', 0b00000010), BitField('enable_mag_dataready', 0b00000100), BitField('enable_accel_dataready', 0b00001000), BitField('enable_magnetometer', 0b00010000), BitField('enable_ig2', 0b00100000), BitField('enable_ig1', 0b01000000), BitField('enable_click', 0b10000000), )), Register('CONTROL5', 0x24, fields=( BitField('latch_int1', 0b00000001), BitField('latch_int2', 0b00000010), BitField('mag_data_rate_hz', 0b00011100, adapter=LookupAdapter({ 3.125: 0b000, 6.25: 0b001, 12.5: 0b010, 25: 0b011, 50: 0b100, 100: 0b101, })), BitField('mag_resolution', 0b01100000), BitField('enable_temperature', 0b10000000), )), Register('CONTROL6', 0x25, fields=(BitField('mag_full_scale_gauss', 0b01100000, adapter=LookupAdapter({ 2: 0b00, 4: 0b01, 8: 0b10, 12: 0b11 })), )), Register( 'CONTROL7', 0x26, fields=( BitField('mag_mode', 0b00000011, adapter=LookupAdapter({ 'continuous': 0b00, 'single': 0b01, 'off': 0b10 })), BitField('mag_lowpowermode', 0b00000100), BitField('temperature_only', 0b00010000), BitField('filter_accel', 0b00100000), BitField('high_pass_mode_accel', 0b11000000), # See page 39 of lsm303d.pdf )), # Accelerometer interrupt status register Register('ACCELEROMETER_STATUS', 0x27, fields=(BitField('xdata', 0b00000001), BitField('ydata', 0b00000010), BitField('zdata', 0b00000100), BitField('data', 0b00001000), BitField('xoverrun', 0b00010000), BitField('yoverrun', 0b00100000), BitField('zoverrun', 0b01000000), BitField('overrun', 0b10000000))), # X/Y/Z values from accelerometer Register('ACCELEROMETER', 0x28 | 0x80, fields=( BitField('x', 0xFFFF00000000, adapter=S16ByteSwapAdapter()), BitField('y', 0x0000FFFF0000, adapter=S16ByteSwapAdapter()), BitField('z', 0x00000000FFFF, adapter=S16ByteSwapAdapter()), ), bit_width=8 * 6), # FIFO control register Register('FIFO_CONTROL', 0x2e, fields=( BitField('mode', 0b11100000), BitField('threshold', 0b00011111), )), # FIFO status register Register( 'FIFO_STATUS', 0x2f, fields=( BitField('threshold_exceeded', 1 << 7), BitField('overrun', 1 << 6), BitField('empty', 1 << 5), BitField('unread_levels', 0b00011111 ), # Current number of unread FIFO levels )), # 0x30: Internal interrupt generator 1: configuration register # 0x31: Internal interrupt generator 1: status register # 0x32: Internal interrupt generator 1: threshold register # 0x33: Internal interrupt generator 1: duration register Register( 'IG_CONFIG1', 0x30 | 0x80, fields=( # 0x30 BitField('and_or_combination', 1 << 31), BitField('6d_enable', 1 << 30), BitField('z_high_enable', 1 << 29), BitField('z_low_enable', 1 << 28), BitField('y_high_enable', 1 << 27), BitField('y_low_enable', 1 << 26), BitField('x_high_enable', 1 << 25), BitField('x_low_enble', 1 << 24), # 0x31 BitField('interrupt_status', 1 << 23), BitField('z_high', 1 << 22), BitField('z_low', 1 << 21), BitField('y_high', 1 << 20), BitField('y_low', 1 << 19), BitField('x_high', 1 << 18), BitField('x_low', 1 << 17), BitField('status', 1 << 16), # 0x32 BitField('threshold', 0xff << 8), # 0x33 BitField('duration', 0xff), ), bit_width=32), # 0x34: Internal interrupt generator 2: configuration register # 0x35: Internal interrupt generator 2: status register # 0x36: Internal interrupt generator 2: threshold register # 0x37: Internal interrupt generator 2: duration register Register( 'IG_CONFIG1', 0x30 | 0x80, fields=( # 0x34 BitField('and_or_combination', 1 << 31), BitField('6d_enable', 1 << 30), BitField('z_high_enable', 1 << 29), BitField('z_low_enable', 1 << 28), BitField('y_high_enable', 1 << 27), BitField('y_low_enable', 1 << 26), BitField('x_high_enable', 1 << 25), BitField('x_low_enble', 1 << 24), # 0x35 BitField('interrupt_status', 1 << 23), BitField('z_high', 1 << 22), BitField('z_low', 1 << 21), BitField('y_high', 1 << 20), BitField('y_low', 1 << 19), BitField('x_high', 1 << 18), BitField('x_low', 1 << 17), BitField('status', 1 << 16), # 0x36 BitField('threshold', 0xff << 8), # 0x37 BitField('duration', 0xff), ), bit_width=32), # 0x38: Click: configuration register # 0x39: Click: status register # 0x3A: Click: threshold register # 0x3B: Click: time limit register # 0x3C: Click: time latency register # 0x3D: Click: time window register Register( 'CLICK', 0x38 | 0x80, fields=( # 0x38 # bits 1 << 47 and 1 << 46 are unimplemented BitField('z_doubleclick_enable', 1 << 45), BitField('z_click_enable', 1 << 44), BitField('y_doubleclick_enable', 1 << 43), BitField('y_click_enable', 1 << 42), BitField('x_doubleclick_enable', 1 << 41), BitField('x_click_enable', 1 << 40), # 0x39 # bit 1 << 39 is unimplemented BitField('interrupt_enable', 1 << 38), BitField('doubleclick_enable', 1 << 37), BitField('click_enable', 1 << 36), BitField( 'sign', 1 << 35), # 0 positive detection, 1 negative detection BitField('z', 1 << 34), BitField('y', 1 << 33), BitField('x', 1 << 32), # 0x3A BitField('threshod', 0xFF << 24), # 0x3B BitField('time_limit', 0xFF << 16), # 0x3C BitField('time_latency', 0xFF << 8), # 0x3D BitField('time_window', 0xFF), ), bit_width=8 * 6), # Controls the threshold and duration of returning to sleep mode Register( 'ACT', 0x3e | 0x80, fields=( BitField('threshold', 0xFF00), # 1 LSb = 16mg BitField('duration', 0x00FF) # (duration + 1) * 8/output_data_rate ), bit_width=16))) self._is_setup = False self._accel_full_scale_g = 2 self._mag_full_scale_guass = 2
def __init__(self, i2c_addr=I2C_ADDRESS_GND, i2c_dev=None): self.calibration = BME280Calibration() self._is_setup = False self._i2c_addr = i2c_addr self._i2c_dev = i2c_dev self._bme280 = Device( [I2C_ADDRESS_GND, I2C_ADDRESS_VCC], i2c_dev=self._i2c_dev, bit_width=8, registers=( Register('CHIP_ID', 0xD0, fields=(BitField('id', 0xFF), )), Register('RESET', 0xE0, fields=(BitField('reset', 0xFF), )), Register( 'STATUS', 0xF3, fields=( BitField('measuring', 0b00001000), # 1 when conversion is running BitField( 'im_update', 0b00000001), # 1 when NVM data is being copied )), Register( 'CTRL_MEAS', 0xF4, fields=( BitField( 'osrs_t', 0b11100000, # Temperature oversampling adapter=LookupAdapter({ 1: 0b001, 2: 0b010, 4: 0b011, 8: 0b100, 16: 0b101 })), BitField( 'osrs_p', 0b00011100, # Pressure oversampling adapter=LookupAdapter({ 1: 0b001, 2: 0b010, 4: 0b011, 8: 0b100, 16: 0b101 })), BitField( 'mode', 0b00000011, # Power mode adapter=LookupAdapter({ 'sleep': 0b00, 'forced': 0b10, 'normal': 0b11 })), )), Register( 'CTRL_HUM', 0xF2, fields=( BitField( 'osrs_h', 0b00000111, # Humidity oversampling adapter=LookupAdapter({ 1: 0b001, 2: 0b010, 4: 0b011, 8: 0b100, 16: 0b101 })), )), Register( 'CONFIG', 0xF5, fields=( BitField( 't_sb', 0b11100000, # Temp standby duration in normal mode adapter=LookupAdapter({ 0.5: 0b000, 62.5: 0b001, 125: 0b010, 250: 0b011, 500: 0b100, 1000: 0b101, 10: 0b110, 20: 0b111 })), BitField( 'filter', 0b00011100 ), # Controls the time constant of the IIR filter BitField( 'spi3w_en', 0b0000001, read_only=True ), # Enable 3-wire SPI interface when set to 1. IE: Don't set this bit! )), Register('DATA', 0xF7, fields=(BitField('humidity', 0x000000000000FFFF), BitField('temperature', 0x000000FFFFF00000), BitField('pressure', 0xFFFFF00000000000)), bit_width=8 * 8), Register( 'CALIBRATION', 0x88, fields=( BitField('dig_t1', 0xFFFF << 16 * 12, adapter=U16Adapter()), # 0x88 0x89 BitField('dig_t2', 0xFFFF << 16 * 11, adapter=S16Adapter()), # 0x8A 0x8B BitField('dig_t3', 0xFFFF << 16 * 10, adapter=S16Adapter()), # 0x8C 0x8D BitField('dig_p1', 0xFFFF << 16 * 9, adapter=U16Adapter()), # 0x8E 0x8F BitField('dig_p2', 0xFFFF << 16 * 8, adapter=S16Adapter()), # 0x90 0x91 BitField('dig_p3', 0xFFFF << 16 * 7, adapter=S16Adapter()), # 0x92 0x93 BitField('dig_p4', 0xFFFF << 16 * 6, adapter=S16Adapter()), # 0x94 0x95 BitField('dig_p5', 0xFFFF << 16 * 5, adapter=S16Adapter()), # 0x96 0x97 BitField('dig_p6', 0xFFFF << 16 * 4, adapter=S16Adapter()), # 0x98 0x99 BitField('dig_p7', 0xFFFF << 16 * 3, adapter=S16Adapter()), # 0x9A 0x9B BitField('dig_p8', 0xFFFF << 16 * 2, adapter=S16Adapter()), # 0x9C 0x9D BitField('dig_p9', 0xFFFF << 16 * 1, adapter=S16Adapter()), # 0x9E 0x9F BitField('dig_h1', 0x00FF), # 0xA1 uint8 ), bit_width=26 * 8), Register( 'CALIBRATION2', 0xE1, fields=( BitField('dig_h2', 0xFFFF0000000000, adapter=S16Adapter()), # 0xE1 0xE2 BitField('dig_h3', 0x0000FF00000000), # 0xE3 uint8 BitField('dig_h4', 0x000000FFFF0000, adapter=H4Adapter()), # 0xE4 0xE5[3:0] BitField('dig_h5', 0x00000000FFFF00, adapter=H5Adapter()), # 0xE5[7:4] 0xE6 BitField('dig_h6', 0x000000000000FF, adapter=S8Adapter()) # 0xE7 int8 ), bit_width=7 * 8)))
{% set _dummy = template.registersToFields.update({ rkey: [] }) %} {{- template.registersToFields[rkey].append(field) or "" -}} {% endif %} {% endfor %} {% endif %} {% macro values_map(field) %} {% if field.type == 'enum' %} { {% for ekey, enum in field.enum|dictsort %} {{ekey}}: {{enum.value}}{{',' if not loop.last }} {% endfor %} }{% endif %} {%- endmacro %} {% for key,register in registers|dictsort %} {% if key in template.registersToFields %} {{key.upper()}} = Register('{{key.upper()}}', {{register.address}}, fields=( {% for field in template.registersToFields[key] %} BitField('{{field.key}}', {{utils.mask(field.bitStart, field.bitEnd)}}, bitwidth={{field.bitStart - field.bitEnd + 1}}{% if i2c.endian == 'little' %}, values_in=_byte_swap, values_out=_byte_swap{% endif %}{% if field.type == 'enum' %}, values_map={{values_map(field)}}{% endif %}){{',' if not loop.last }} {% endfor %} ), read_only={{register.readWrite == 'R'}}, bitwidth={{register.length}}) {% else %} {{key.upper()}} = Register('{{key.upper()}}', {{register.address}}, read_only={{register.readWrite == 'R'}}, bitwidth={{register.length}}) {% endif %} {% endfor %} {{info.title.lower()}} = Device(I2C_ADDR, registers=( {% for key,register in registers|dictsort %} {{key.upper()}}{{',' if not loop.last}} {% endfor %} ))
def __init__(self, i2c_dev=None): self._as7262 = Device( 0x49, i2c_dev=as7262VirtualRegisterBus(i2c_dev=i2c_dev), bit_width=8, registers=( Register('VERSION', 0x00, fields=( BitField('hw_type', 0xFF000000), BitField('hw_version', 0x00FF0000), BitField('fw_version', 0x0000FFFF, adapter=FWVersionAdapter()), ), bit_width=32, read_only=True), Register('CONTROL', 0x04, fields=( BitField('reset', 0b10000000), BitField('interrupt', 0b01000000), BitField('gain_x', 0b00110000, adapter=LookupAdapter({ 1: 0b00, 3.7: 0b01, 16: 0b10, 64: 0b11 })), BitField('measurement_mode', 0b00001100), BitField('data_ready', 0b00000010), )), Register('INTEGRATION_TIME', 0x05, fields=(BitField( 'ms', 0xFF, adapter=IntegrationTimeAdapter()), )), Register('TEMPERATURE', 0x06, fields=(BitField('degrees_c', 0xFF), )), Register('LED_CONTROL', 0x07, fields=( BitField('illumination_current_limit_ma', 0b00110000, adapter=LookupAdapter({ 12.5: 0b00, 25: 0b01, 50: 0b10, 100: 0b11 })), BitField('illumination_enable', 0b00001000), BitField('indicator_current_limit_ma', 0b00000110, adapter=LookupAdapter({ 1: 0b00, 2: 0b01, 4: 0b10, 8: 0b11 })), BitField('indicator_enable', 0b00000001), )), Register('DATA', 0x08, fields=( BitField('v', 0xFFFF00000000000000000000), BitField('b', 0x0000FFFF0000000000000000), BitField('g', 0x00000000FFFF000000000000), BitField('y', 0x000000000000FFFF00000000), BitField('o', 0x0000000000000000FFFF0000), BitField('r', 0x00000000000000000000FFFF), ), bit_width=96), Register('CALIBRATED_DATA', 0x14, fields=( BitField('v', 0xFFFFFFFF << (32 * 5), adapter=FloatAdapter()), BitField('b', 0xFFFFFFFF << (32 * 4), adapter=FloatAdapter()), BitField('g', 0xFFFFFFFF << (32 * 3), adapter=FloatAdapter()), BitField('y', 0xFFFFFFFF << (32 * 2), adapter=FloatAdapter()), BitField('o', 0xFFFFFFFF << (32 * 1), adapter=FloatAdapter()), BitField('r', 0xFFFFFFFF << (32 * 0), adapter=FloatAdapter()), ), bit_width=192), )) # TODO : Integrate into i2cdevice so that LookupAdapter fields can always be exported to constants # Iterate through all register fields and export their lookup tables to constants for register in self._as7262.registers: register = self._as7262.registers[register] for field in register.fields: field = register.fields[field] if isinstance(field.adapter, LookupAdapter): for key in field.adapter.lookup_table: value = field.adapter.lookup_table[key] name = 'AS7262_{register}_{field}_{key}'.format( register=register.name, field=field.name, key=key).upper() locals()[name] = key self.soft_reset()
I2C_ADDR_28 = 28 I2C_ADDR_29 = 29 I2C_ADDR_30 = 30 I2C_ADDR_31 = 31 I2C_ADDR = [ I2C_ADDR_24, I2C_ADDR_25, I2C_ADDR_26, I2C_ADDR_27, I2C_ADDR_28, I2C_ADDR_29, I2C_ADDR_30, I2C_ADDR_31 ] CONFIGURATION = Register('CONFIGURATION', 1, fields=(BitField('limitHysteresis', 0b0000011000000000, bitwidth=2, values_map={ Temp_0C: 0, Temp_1C5: 1, Temp_3C: 2, Temp_6C: 3 }), BitField('shutdownMode', 0b0000000100000000, bitwidth=1, values_map={ continousConversion: 0, shutdown: 1 })), read_only=False, bitwidth=16) mcp9808 = Device(I2C_ADDR, registers=(CONFIGURATION))
def _decode(self, value): return value >> 1 def _encode(self, value): return value << 1 bus = MockSMBus(1) device = Device(0x00, bus, registers=(Register('status', 0x00, fields=(BitField('interrupt', 0b00000001, read_only=True), BitField('data_ready', 0b00000010), BitField('power', 0b10000000), BitField('monkey', 0b01111100, adapter=x2Adapter()))), Register('measurement_rate', 0x85, fields=(BitField('integration_time_ms', 0b00111000, adapter=LookupAdapter({ 100: 0b000, 50: 0b001, 200: 0b010,
def __init__(self, i2c_addr=0x73, i2c_dev=None): self._i2c_addr = i2c_addr self._i2c_dev = i2c_dev self._is_setup = False # Device definition self._apds9500 = Device( [0x73], i2c_dev=self._i2c_dev, bit_width=8, bank_select=Register('BANK_SELECT', 0xEF), registers=( Register('BANK_SELECT', 0xEF, fields=(BitField('bank', 0b00000001), )), # BANK 0 Registers Register('ID', 0x00, bank=0, fields=(BitField('part', 0xFFFF00), BitField('version', 0x0000FF)), bit_width=8 * 3), Register('SUSPEND', 0x03, bank=0), # CURSOR MODES Register('CURSOR_MODE', 0x32, bank=0, fields=(BitField('mode', 0xFF, adapter=InterruptLookupAdapter({ 'cursor_use_top': 0b00000001, 'cursor_use_bg_model': 0b00000010, 'cursor_invert_y': 0b00000100, 'cursor_invert_x': 0b00001000, 'cursor_top_ratio': 0b00110000 })), )), Register('POS_FILTER_START_SIZE_LSB', 0x33, bank=0), Register('POS_FILTER_START_SIZE_MSB', 0x34, bank=0), Register('PRO_FILTER_START_SIZE_LSB', 0x35, bank=0), Register('PRO_FILTER_START_SIZE_MSB', 0x36, bank=0), Register('CURSOR_CLAMP_LEFT', 0x37, bank=0), Register('CURSOR_CLAMP_RIGHT', 0x38, bank=0), Register('CURSOR_CLAMP_UP', 0x39, bank=0), Register('CURSOR_CLAMP_DOWN', 0x3A, bank=0), Register('CURSOR_CLAMP_CENTER_X_LSB', 0x3B, bank=0), Register('CURSOR_CLAMP_CENTER_X_MSB', 0x3C, bank=0), Register('CURSOR_CLAMP_CENTER_Y_LSB', 0x3D, bank=0), Register('CURSOR_CLAMP_CENTER_Y_MSB', 0x3E, bank=0), Register('CURSOR_OBJECT_SIZE', 0x8B, bank=0), Register('CURSOR_POSITION_RESOLUTION', 0x8C, bank=0), # Proximity Mode Register('PROX_UPPER_BOUND', 0x69, bank=0), Register('PROX_LOWER_BOUND', 0x6A, bank=0), Register('PROX_S_STATE', 0x6B, bank=0), Register('PROX_AGV_Y', 0x6C, bank=0), # Automatic Gain and Exposure Controls BANK 0 Register('AE_LED_OFF_UB', 0x46, bank=0), Register('AE_LED_OFF_LB', 0x47, bank=0), Register('AE_EXPOSURE_UB_LSB', 0x48, bank=0), Register('AE_EXPOSURE_UB_MSB', 0x49, bank=0), Register('AE_EXPOSURE_LB_LSB', 0x4A, bank=0), Register('AE_EXPOSURE_LB_MSB', 0x4B, bank=0), Register('AG_GAIN_UB', 0x4C, bank=0), Register('AG_GAIN_LB', 0x4D, bank=0), Register('AG_GAIN_CONTROL', 0x4E, bank=0, fields=( BitField('step', 0x0F), BitField('wakeup_ae_mode', 0x10), )), Register('AG_GAIN_DEFAULT', 0x4F, bank=0), Register('AE_EXPOSURE_SELECT', 0x50, bank=0), Register('AEAG_MODE', 0x51, bank=0, fields=( BitField('manual_global_gain', 0b00000001), BitField('manual_exposure', 0b00000010), BitField('maunal_exposure_default', 0b00000100), BitField('auto_exposure_enable', 0b00001000), )), Register('AG_GAIN_ANALOGUE', 0x54, bank=0, read_only=True), Register('AE_EXPOSURE_TIME_LSB', 0x55, bank=0, read_only=True), Register('AE_EXPOSURE_TIME_MSB', 0x56, bank=0, read_only=True), Register('AG_GLOBAL_GAIN', 0x57, bank=0, fields=( BitField('ggn', 0b00000011, read_only=True), BitField('global_gain', 0b11110000, read_only=True), )), Register('LED_OFF_FRAME_AVERAGE_BRIGHTNESS', 0x58, bank=0, read_only=True), Register('AE_DIRECTION', 0x59, bank=0, fields=( BitField('decrease', 0b00000001), BitField('increase', 0b00000010), )), # Automatic Gain and Exposure Controls BANK 1 Register('PGA_GAIN_GLOBAL', 0x42, bank=1, read_only=True), Register('PGA_GAIN_GGH', 0x44, bank=1, read_only=True), # Interupt Controls BANK0 Register('INTERUPT_MODE', 0x40, bank=0, fields=( BitField('auto_clear', 0b00000001), BitField('active_high', 0b00010000), )), Register('INT_ENABLE_1', 0x41, bank=0, fields=(BitField('mode', 0xFF, adapter=InterruptLookupAdapter({ 'event_up': 0b00000001, 'event_down': 0b00000010, 'event_left': 0b00000100, 'event_right': 0b00001000, 'event_forward': 0b00010000, 'event_backward': 0b00100000, 'event_clockwise': 0b01000000, 'event_counterclockwise': 0b10000000 })), )), Register('INT_ENABLE_2', 0x42, bank=0, fields=(BitField('mode', 0xFF, adapter=InterruptLookupAdapter({ 'event_wave': 0b00000001, 'event_proximity': 0b00000010, 'event_has_object': 0b00000100, 'event_wake_up': 0b00001000, 'no_object': 0b10000000 })), )), Register('INT_FLAG_1', 0x43, bank=0, fields=(BitField('mode', 0xFF, read_only=True, adapter=InterruptLookupAdapter({ 'event_up': 0b00000001, 'event_down': 0b00000010, 'event_left': 0b00000100, 'event_right': 0b00001000, 'event_forward': 0b00010000, 'event_backward': 0b00100000, 'event_clockwise': 0b01000000, 'event_counterclockwise': 0b10000000 })), )), Register('INT_FLAG_2', 0x44, bank=0, fields=(BitField('mode', 0xFF, read_only=True, adapter=InterruptLookupAdapter({ 'event_wave': 0b00000001, 'event_proximity': 0b00000010, 'event_has_object': 0b00000100, 'event_wake_up': 0b00001000, 'no_object': 0b10000000 })), )), # Gesture Bank 0 Register('GESTURE_LIGHT_THREASHOLD', 0x83, bank=0), Register('GESTURE_START_THREASHOLD_LSB', 0x84, bank=0), Register('GESTURE_START_THREASHOLD_MSB', 0x85, bank=0), Register('GESTURE_END_THREASHOLD_LSB', 0x86, bank=0), Register('GESTURE_END_THREASHOLD_MSB', 0x87, bank=0), Register('GESTURE_OBJECT_Z_MIN', 0x88, bank=0), Register('GESTURE_OBJECT_Z_MAX', 0x89, bank=0), Register('GESTURE_PROCESS_RESOLUTION', 0x8C, bank=0), Register('GESTURE_DETECTION_DELAY', 0x8D, bank=0), Register('GESTURE_45_DEGREE_DETECTION', 0x8E, bank=0, fields=( BitField('disable', 0b00000001), BitField('ratio', 0xF0), )), Register('GESTURE_X_to_Y_GAIN', 0x8F, bank=0, fields=( BitField('enable', 0b00000001), BitField('ratio', 0xF0), )), Register('GESTURE_NO_MOTION_COUNTER_THRS', 0x90, bank=0), Register('GESTURE_NO_OBJECT_COUNTER_THRS', 0x91, bank=0), Register('GESTURE_NORMALIZED_IMAGE_WIDTH', 0x92, bank=0), Register('GESTURE_DETECTION_HORIZONTAL_THRS', 0x93, bank=0), Register('GESTURE_DETECTION_VERTICAL_THRS', 0x94, bank=0), Register('GESTURE_DETECTION_Z_THRS', 0x95, bank=0), Register('GESTURE_DETECTION_XY_THRS', 0x96, bank=0), Register('GESTURE_DETECTION_Z_ANGLE__THRS', 0x97, bank=0), Register('GESTURE_ROTATE_ANGLE_THRS', 0x98, bank=0), Register('GESTURE_CONTINUOUS_ROTATION', 0x99, bank=0, fields=( BitField('enable', 0b00000001), BitField('threshold', 0b00111110), )), Register('GESTURE_ROTATE_XY_THRS', 0x9A, bank=0), Register('GESTURE_ROTATE_Z_THRS', 0x9B, bank=0), Register('GESTURE_IIR_FILTER', 0x9C, bank=0, fields=( BitField('weight', 0b00000011), BitField('distance_threshold', 0b01111100), )), Register('GESTURE_IIR_FILTER_DISTANCE', 0x9D, bank=0, fields=( BitField('start_distance_threashold', 0b00001111), BitField('end_distance_threshold', 0b01110000), )), Register('GESTURE_DETECTION_ENABLE', 0x9D, bank=0, fields=( BitField('rotate_enable', 0b00010000), BitField('z_enable', 0b00100000), BitField('y_enable', 0b01000000), BitField('x_enable', 0b10000000), )), Register('GESTURE_FILTER_IMAGE', 0xA5, bank=0, fields=( BitField('average_mode_enable', 0b00000001), BitField('average_mode', 0b00001100), BitField('use_light_weight', 0b00010000), )), Register('GESTURE_FRAME_EDGE_ACC_THRS', 0xA9, bank=0), Register('GESTURE_OBJECT_CENTER_X_LSB', 0xAC, bank=0, read_only=True), Register('GESTURE_OBJECT_CENTER_X_MSB', 0xAD, bank=0, read_only=True), Register('GESTURE_OBJECT_CENTER_Y_LSB', 0xAE, bank=0, read_only=True), Register('GESTURE_OBJECT_CENTER_Y_MSB', 0xAF, bank=0, read_only=True), Register('GESTURE_OBJECT_BRIGHTNESS', 0xB0, bank=0, read_only=True), Register('GESTURE_OBJECT_SIZE_LSB', 0xB1, bank=0, read_only=True), Register('GESTURE_OBJECT_SIZE_MSB', 0xB2, bank=0, read_only=True), Register('GESTURE_MOVEMENT_X', 0xB3, bank=0, read_only=True), Register('GESTURE_MOVEMENT_Y', 0xB4, bank=0, read_only=True), Register('GESTURE_MOVEMENT_Z', 0xB5, bank=0, read_only=True), Register('GESTURE_RESULT', 0xB6, bank=0, fields=( BitField('result', 0x0F, read_only=True, adapter=InterruptLookupAdapter({ 'up': 1, 'down': 2, 'left': 3, 'right': 4, 'forward': 5, 'backward': 6, 'clockwise': 7, 'counterclockwise': 8, 'wave': 9, 'n/a': 10 })), BitField('state', 0x30, read_only=True, adapter=InterruptLookupAdapter({ 'inital': 0, 'process': 1, 'end': 2, })), )), Register('GESTURE_WAVE_ABORT_COUNTERS', 0xB7, bank=0, fields=( BitField('wave', 0x0F, read_only=True), BitField('abort', 0x70, read_only=True), )), Register('GESTURE_NO_OBJECT_COUNTER', 0xB8, bank=0, read_only=True), Register('GESTURE_NO_MOTION_COUNTER', 0xB9, bank=0, read_only=True), Register('GESTURE_BRIGHT_OBJECT_COUNTER', 0xBA, bank=0, read_only=True), Register('GESTURE_OBJECT_BIRGHTNESS_ACC_LSB', 0xBB, bank=0, read_only=True), Register('GESTURE_OBJECT_BIRGHTNESS_ACC_MSB', 0xBC, bank=0, read_only=True), Register('GESTURE_TIME_PERIOD_LSB', 0xBD, bank=0, read_only=True), Register('GESTURE_TIME_PERIOD_MSB', 0xBE, bank=0, read_only=True), Register('GESTURE_ANGLE_ACC_LSB', 0xC7, bank=0, read_only=True), Register('GESTURE_ANGLE_ACC_MSB', 0xC8, bank=0, read_only=True), Register('GESTURE_GAIN_VALUE_X', 0xCA, bank=0, read_only=True), Register('GESTURE_GAIN_VALUE_Y', 0xCB, bank=0, read_only=True), Register('GESTURE_Y_TO_Z_SUM', 0xCC, bank=0), Register('GESTURE_Y_TO_Z_FACTOR', 0xCD, bank=0), Register('GESTURE_IIR_FILTER_LENGTH', 0xCE, bank=0, fields=( BitField('cursor_object', 0b00000111), BitField('gesture_object', 0b01110000), )), Register('GESTURE_WAVE_THRES', 0xCF, bank=0, fields=( BitField('count_thres', 0b00001111), BitField('angle_thres', 0b11110000), )), Register('GESTURE_ABORT_THRES', 0xD0, bank=0, fields=( BitField('count_thres', 0b00000111), BitField('angle_thres', 0b11111000), )), Register('GESTURE_ABORT_LENGTH', 0xD1, bank=0), Register( 'GESTURE_ABORT_MODE', 0xD2, bank=0, fields=( BitField('interval', 0b00111111), BitField('confirm_mode', 0b01000000), BitField('wave_detection_enable', 0b10000000), # enabling wave detection mode )), Register('GESTURE_TIME_PERIOD_LSB', 0xD3, bank=0, read_only=True), Register('GESTURE_TIME_PERIOD_MSB', 0xD4, bank=0, read_only=True), Register('GESTURE_ANGLE_ACC_LSB', 0xC7, bank=0, read_only=True), Register('GESTURE_ANGLE_ACC_MSB', 0xC8, bank=0, read_only=True), # Gesture Bank 1 # Image Regs BANK 0 Register('IMAGE_HEIGHT', 0xAA, bank=0), Register('IMAGE_WIDTH', 0xAB, bank=0), # Image Regs BANK 1 Register('IMAGE_H_SCALE', 0x00, bank=1), Register('IMAGE_V_SCALE', 0x01, bank=1), Register('IMAGE_H_START', 0x02, bank=1), Register('IMAGE_V_START', 0x03, bank=1), Register('IMAGE_TRANSLATION', 0x09, bank=1, fields=(BitField('translations', 0xFF, adapter=LookupAdapter({ 'a_skip_v': 0b00100000, 'a_skip_h': 0b00010000, 'd_avg_v': 0b0001000, 'v_flip': 0b00000010, 'h_flip': 0b00000001 })), )), ))
# Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # Auto-generated file for ADS1015 v0.1.0. # Generated from peripherals/ADS1015.yaml using Cyanobyte Codegen v0.1.0 from i2cdevice import Device, Register, BitField I2C_ADDR = 73 CONFIG = Register('CONFIG', 1, fields=( BitField('Channel', 0b0011100000000000, bitwidth=3, values_in=_byte_swap, values_out=_byte_swap, values_map={ CHANNEL_1: 0, CHANNEL_2: 1, CHANNEL_3: 2, CHANNEL_4: 3 }) BitField('DeviceOperatingMode', 0b0000000010000000, bitwidth=1, values_in=_byte_swap, values_out=_byte_swap, values_map={ CONTINUOUS_CONVERSION: 0, SINGLE_SHOT: 1 }) BitField('ProgrammableGain', 0b0000011100000000, bitwidth=3, values_in=_byte_swap, values_out=_byte_swap, values_map={ PGA0_256: 5, PGA0_512: 4, PGA1_024V: 3, PGA2_048V: 2, PGA4_096V: 1, PGA6_144V: 0 })
# # Auto-generated file for Example v0.1.0. # Generated from peripherals/example.yaml using Cyanobyte Codegen v0.1.0 from i2cdevice import Device, Register, BitField I2C_ADDR_16 = 16 I2C_ADDR_32 = 32 I2C_ADDR_48 = 48 I2C_ADDR = [I2C_ADDR_16, I2C_ADDR_32, I2C_ADDR_48] REGISTERA = Register('REGISTERA', 0, fields=( BitField('FieldA', 0b0000000011110000, bitwidth=4), BitField('FieldB', 0b0000000000001100, bitwidth=2, values_map={ VAL_1: 1, VAL_2: 2, VAL_3: 4, VAL_4: 8 }), BitField('FieldC', 0b0000000000000010, bitwidth=1), BitField('FieldD', 0b0000000000000001, bitwidth=1) ), read_only=False, bitwidth=8) REGISTERB = Register('REGISTERB', 1, read_only=False, bitwidth=16) REGISTERC = Register('REGISTERC', 2, read_only=False, bitwidth=32) REGISTERD = Register('REGISTERD', 3, read_only=False, bitwidth=0) example = Device(I2C_ADDR, registers=( REGISTERA, REGISTERB, REGISTERC, REGISTERD ))
def __init__(self, i2c_dev=None, enable_interrupts=False, interrupt_pin_polarity=1, timeout=5.0): """Initialise the LTR559. This sets up the LTR559 and checks that the Part Number ID matches 0x09 and that the Revision Number ID matches 0x02. If you come across an unsupported revision you should raise an Issue at https://github.com/pimoroni/ltr559-python Several known-good default values are picked during setup, and the interrupt thresholds are reset to the full range so that interrupts will not fire unless configured manually using `set_light_threshold` and `set_proximity_threshold`. Interrupts are always enabled, since this must be done before the sensor is active. """ self._als0 = 0 self._als1 = 0 self._ps0 = 0 self._lux = 0 self._ratio = 100 # Non default self._gain = 4 # 4x gain = 0.25 to 16k lux self._integration_time = 50 self._ch0_c = (17743, 42785, 5926, 0) self._ch1_c = (-11059, 19548, -1185, 0) self._ltr559 = Device(I2C_ADDR, i2c_dev=i2c_dev, bit_width=8, registers=( Register('ALS_CONTROL', 0x80, fields=( BitField('gain', 0b00011100, adapter=LookupAdapter({ 1: 0b000, 2: 0b001, 4: 0b010, 8: 0b011, 48: 0b110, 96: 0b111})), BitField('sw_reset', 0b00000010), BitField('mode', 0b00000001) )), Register('PS_CONTROL', 0x81, fields=( BitField('saturation_indicator_enable', 0b00100000), BitField('active', 0b00000011, adapter=LookupAdapter({ False: 0b00, True: 0b11})) )), Register('PS_LED', 0x82, fields=( BitField('pulse_freq_khz', 0b11100000, adapter=LookupAdapter({ 30: 0b000, 40: 0b001, 50: 0b010, 60: 0b011, 70: 0b100, 80: 0b101, 90: 0b110, 100: 0b111})), BitField('duty_cycle', 0b00011000, adapter=LookupAdapter({ 0.25: 0b00, 0.5: 0b01, 0.75: 0b10, 1.0: 0b11})), BitField('current_ma', 0b00000111, adapter=LookupAdapter({ 5: 0b000, 10: 0b001, 20: 0b010, 50: 0b011, 100: 0b100})) )), Register('PS_N_PULSES', 0x83, fields=( BitField('count', 0b00001111), )), Register('PS_MEAS_RATE', 0x84, fields=( BitField('rate_ms', 0b00001111, adapter=LookupAdapter({ 10: 0b1000, 50: 0b0000, 70: 0b0001, 100: 0b0010, 200: 0b0011, 500: 0b0100, 1000: 0b0101, 2000: 0b0110})), )), Register('ALS_MEAS_RATE', 0x85, fields=( BitField('integration_time_ms', 0b00111000, adapter=LookupAdapter({ 100: 0b000, 50: 0b001, 200: 0b010, 400: 0b011, 150: 0b100, 250: 0b101, 300: 0b110, 350: 0b111})), BitField('repeat_rate_ms', 0b00000111, adapter=LookupAdapter({ 50: 0b000, 100: 0b001, 200: 0b010, 500: 0b011, 1000: 0b100, 2000: 0b101})) )), Register('PART_ID', 0x86, fields=( BitField('part_number', 0b11110000), # Should be 0x09H BitField('revision', 0b00001111) # Should be 0x02H ), read_only=True, volatile=False), Register('MANUFACTURER_ID', 0x87, fields=( BitField('manufacturer_id', 0b11111111), # Should be 0x05H ), read_only=True), # This will address 0x88, 0x89, 0x8A and 0x8B as a continuous 32bit register Register('ALS_DATA', 0x88, fields=( BitField('ch1', 0xFFFF0000, bit_width=16, adapter=U16ByteSwapAdapter()), BitField('ch0', 0x0000FFFF, bit_width=16, adapter=U16ByteSwapAdapter()) ), read_only=True, bit_width=32), Register('ALS_PS_STATUS', 0x8C, fields=( BitField('als_data_valid', 0b10000000), BitField('als_gain', 0b01110000, adapter=LookupAdapter({ 1: 0b000, 2: 0b001, 4: 0b010, 8: 0b011, 48: 0b110, 96: 0b111})), BitField('als_interrupt', 0b00001000), # True = Interrupt is active BitField('als_data', 0b00000100), # True = New data available BitField('ps_interrupt', 0b00000010), # True = Interrupt is active BitField('ps_data', 0b00000001) # True = New data available ), read_only=True), # The PS data is actually an 11bit value but since B3 is reserved it'll (probably) read as 0 # We could mask the result if necessary Register('PS_DATA', 0x8D, fields=( BitField('ch0', 0xFF0F, adapter=Bit12Adapter()), BitField('saturation', 0x0080) ), bit_width=16, read_only=True), # INTERRUPT allows the interrupt pin and function behaviour to be configured. Register('INTERRUPT', 0x8F, fields=( BitField('polarity', 0b00000100), BitField('mode', 0b00000011, adapter=LookupAdapter({ 'off': 0b00, 'ps': 0b01, 'als': 0b10, 'als+ps': 0b11})) )), Register('PS_THRESHOLD', 0x90, fields=( BitField('upper', 0xFF0F0000, adapter=Bit12Adapter()), BitField('lower', 0x0000FF0F, adapter=Bit12Adapter()) ), bit_width=32), # PS_OFFSET defines the measurement offset value to correct for proximity # offsets caused by device variations, crosstalk and other environmental factors. Register('PS_OFFSET', 0x94, fields=( BitField('offset', 0x03FF), # Last two bits of 0x94, full 8 bits of 0x95 ), bit_width=16), # Defines the upper and lower limits of the ALS reading. # An interrupt is triggered if values fall outside of this range. # See also INTERRUPT_PERSIST. Register('ALS_THRESHOLD', 0x97, fields=( BitField('upper', 0xFFFF0000, adapter=U16ByteSwapAdapter(), bit_width=16), BitField('lower', 0x0000FFFF, adapter=U16ByteSwapAdapter(), bit_width=16) ), bit_width=32), # This register controls how many values must fall outside of the range defined # by upper and lower threshold limits before the interrupt is asserted. # In the case of both PS and ALS, a 0 value indicates that every value outside # the threshold range should be counted. # Values therein map to n+1 , ie: 0b0001 requires two consecutive values. Register('INTERRUPT_PERSIST', 0x9E, fields=( BitField('PS', 0xF0), BitField('ALS', 0x0F) )) )) """Set up the LTR559 sensor""" self.part_id = self._ltr559.get('PART_ID') if self.part_id.part_number != PART_ID or self.part_id.revision != REVISION_ID: raise RuntimeError("LTR559 not found") self._ltr559.set('ALS_CONTROL', sw_reset=1) t_start = time.time() while time.time() - t_start < timeout: status = self._ltr559.get('ALS_CONTROL').sw_reset if status == 0: break time.sleep(0.05) if self._ltr559.get('ALS_CONTROL').sw_reset: raise RuntimeError("Timeout waiting for software reset.") # Interrupt register must be set before device is switched to active mode # see datasheet page 12/40, note #2. if enable_interrupts: self._ltr559.set('INTERRUPT', mode='als+ps', polarity=interrupt_pin_polarity) # FIXME use datasheet defaults or document # No need to run the proximity LED at 100mA, so we pick 50 instead. # Tests suggest this works pretty well. self._ltr559.set('PS_LED', current_ma=50, duty_cycle=1.0, pulse_freq_khz=30) # 1 pulse is the default value self._ltr559.set('PS_N_PULSES', count=1) self._ltr559.set('ALS_CONTROL', mode=1, gain=self._gain) self._ltr559.set('PS_CONTROL', active=True, saturation_indicator_enable=1) self._ltr559.set('PS_MEAS_RATE', rate_ms=100) self._ltr559.set('ALS_MEAS_RATE', integration_time_ms=self._integration_time, repeat_rate_ms=50) self._ltr559.set('ALS_THRESHOLD', lower=0x0000, upper=0xFFFF) self._ltr559.set('PS_THRESHOLD', lower=0x0000, upper=0xFFFF) self._ltr559.set('PS_OFFSET', offset=0)
# Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # Auto-generated file for Example v0.1.0. # Generated from peripherals/example.yaml using Cyanobyte Codegen v0.1.0 from i2cdevice import Device, Register, BitField I2C_ADDR_16 = 16 I2C_ADDR_32 = 32 I2C_ADDR_48 = 48 I2C_ADDR = [I2C_ADDR_16, I2C_ADDR_32, I2C_ADDR_48] REGISTERA = Register('REGISTERA', 0, fields=( BitField('FieldA', 0b0000000001111000, bitwidth=4) BitField('FieldB', 0b0000000000000110, bitwidth=2, values_map={ VAL_1: 1, VAL_2: 2, VAL_3: 4, VAL_4: 8 }) BitField('FieldC', 0b0000000000000001, bitwidth=1) BitField('FieldD', 0b0000000000000000, bitwidth=1) ), read_only=False, bitwidth=8) REGISTERB = Register('REGISTERB', 1, read_only=False, bitwidth=16) REGISTERC = Register('REGISTERC', 2, read_only=False, bitwidth=32) REGISTERD = Register('REGISTERD', 3, read_only=False, bitwidth=0) example = Device(I2C_ADDR, registers=( REGISTERA,
def __init__(self, i2c_addr=0x38, i2c_dev=None): """Initialise sensor. :param i2c_addr: i2c address of sensor :param i2c_dev: SMBus-compatible instance """ self._i2c_addr = i2c_addr self._i2c_dev = i2c_dev self._is_setup = False # Device definition self._bh1745 = Device(I2C_ADDRESSES, i2c_dev=self._i2c_dev, bit_width=8, registers=( # Part ID should be 0b001011 or 0x0B Register('SYSTEM_CONTROL', 0x40, fields=( BitField('sw_reset', 0b10000000), BitField('int_reset', 0b01000000), BitField('part_id', 0b00111111, read_only=True) )), Register('MODE_CONTROL1', 0x41, fields=( BitField('measurement_time_ms', 0b00000111, adapter=LookupAdapter({ 160: 0b000, 320: 0b001, 640: 0b010, 1280: 0b011, 2560: 0b100, 5120: 0b101 })), )), Register('MODE_CONTROL2', 0x42, fields=( BitField('valid', 0b10000000, read_only=True), BitField('rgbc_en', 0b00010000), BitField('adc_gain_x', 0b00000011, adapter=LookupAdapter({ 1: 0b00, 2: 0b01, 16: 0b10})) )), Register('MODE_CONTROL3', 0x44, fields=( BitField('on', 0b11111111, adapter=LookupAdapter({True: 2, False: 0})), )), Register('COLOUR_DATA', 0x50, fields=( BitField('red', 0xFFFF000000000000, adapter=U16ByteSwapAdapter()), BitField('green', 0x0000FFFF00000000, adapter=U16ByteSwapAdapter()), BitField('blue', 0x00000000FFFF0000, adapter=U16ByteSwapAdapter()), BitField('clear', 0x000000000000FFFF, adapter=U16ByteSwapAdapter()) ), bit_width=64, read_only=True), Register('DINT_DATA', 0x58, fields=( BitField('data', 0xFFFF, adapter=U16ByteSwapAdapter()), ), bit_width=16), Register('INTERRUPT', 0x60, fields=( BitField('status', 0b10000000, read_only=True), BitField('latch', 0b00010000, adapter=LookupAdapter({0: 1, 1: 0})), BitField('source', 0b00001100, read_only=True, adapter=LookupAdapter({ 'red': 0b00, 'green': 0b01, 'blue': 0b10, 'clear': 0b11 })), BitField('enable', 0b00000001) )), # 00: Interrupt status is toggled at each measurement end # 01: Interrupt status is updated at each measurement end # 10: Interrupt status is updated if 4 consecutive threshold judgements are the same # 11: Blah blah ditto above except for 8 consecutive judgements Register('PERSISTENCE', 0x61, fields=( BitField('mode', 0b00000011, adapter=LookupAdapter({ 'toggle': 0b00, 'update': 0b01, 'update_on_4': 0b10, 'update_on_8': 0b11 })), )), # High threshold defaults to 0xFFFF # Low threshold defaults to 0x0000 Register('THRESHOLD', 0x62, fields=( BitField('high', 0xFFFF0000, adapter=U16ByteSwapAdapter()), BitField('low', 0x0000FFFF, adapter=U16ByteSwapAdapter()) ), bit_width=32), # Default MANUFACTURER ID is 0xE0h Register('MANUFACTURER', 0x92, fields=( BitField('id', 0xFF), ), read_only=True, volatile=False) )) self._bh1745.select_address(self._i2c_addr) # TODO : Integrate into i2cdevice so that LookupAdapter fields can always be exported to constants # Iterate through all register fields and export their lookup tables to constants for register in self._bh1745.registers: register = self._bh1745.registers[register] for field in register.fields: field = register.fields[field] if isinstance(field.adapter, LookupAdapter): for key in field.adapter.lookup_table: name = 'BH1745_{register}_{field}_{key}'.format( register=register.name, field=field.name, key=key ).upper() globals()[name] = key """ Approximate compensation for the spectral response performance curves """ self._channel_compensation = (2.2, 1.0, 1.8, 10.0) self._enable_channel_compensation = True
""" return ((value & 0xFF00) >> 8) | ((value & 0x000F) << 8) ltr559 = Device( I2C_ADDR, i2c_dev=MockSMBus(0, default_registers={0x86: 0x92}), bit_width=8, registers=( Register('ALS_CONTROL', 0x80, fields=(BitField('gain', 0b00011100, adapter=LookupAdapter({ 1: 0b000, 2: 0b001, 4: 0b011, 8: 0b011, 48: 0b110, 96: 0b111 })), BitField('sw_reset', 0b00000010), BitField('mode', 0b00000001))), Register('PS_CONTROL', 0x81, fields=(BitField('saturation_indicator_enable', 0b00100000), BitField('active', 0b00000011, adapter=LookupAdapter({ False: 0b00, True: 0b11 })))),
# http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # Auto-generated file for LSM303D v0.1.0. # Generated from peripherals/LSM303D.yaml using Cyanobyte Codegen v0.1.0 from i2cdevice import Device, Register, BitField I2C_ADDR = 29 ACCELEROMETERX_HIGH = Register('ACCELEROMETERX_HIGH', 169, read_only=True, bitwidth=8) ACCELEROMETERX_LOW = Register('ACCELEROMETERX_LOW', 168, read_only=True, bitwidth=8) ACCELEROMETERY_HIGH = Register('ACCELEROMETERY_HIGH', 171, read_only=True, bitwidth=8) ACCELEROMETERY_LOW = Register('ACCELEROMETERY_LOW', 170, read_only=True, bitwidth=8) ACCELEROMETERZ_HIGH = Register('ACCELEROMETERZ_HIGH', 173,