Example #1
0
    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()
Example #2
0
def test_lookup_adapter_snap():
    adapter = LookupAdapter({0: 0, 1: 1})
    assert adapter._encode(0) == 0
    assert adapter._encode(1) == 1
    assert adapter._encode(0.1) == 0
    assert adapter._encode(0.9) == 1

    adapter = LookupAdapter({0: 0, 1: 0}, snap=False)
    with pytest.raises(KeyError):
        adapter._encode(0.1)
Example #3
0
 def _decode(self, value):
     # Mask out the "don't care" bit for anything
     # that doesn't have the high bit set
     if value & 0b1000 == 0:
         value &= 0b0011
     # Special case for 0b1000 = 12bit
     if value == 0b1000:
         value = 0b0011
     return LookupAdapter._decode(self, value)
Example #4
0
def test_lookup_adapter():
    adapter = LookupAdapter({'Zero': 0, 'One': 1})
    assert adapter._decode(0) == 'Zero'
    assert adapter._decode(1) == 'One'
    with pytest.raises(ValueError):
        adapter._decode(2)
    with pytest.raises(KeyError):
        adapter._encode('Two')
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
Example #6
0
    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)
Example #7
0
 def __init__(self, i2c_addr=DRV2605_ADDR, i2c_dev=None):
     self._i2c_addr = i2c_addr
     self._i2c_dev = i2c_dev
     self._drv2605 = Device(
         DRV2605_ADDR,
         i2c_dev=self._i2c_dev,
         registers=(
             Register('STATUS',
                      0x00,
                      fields=(
                          BitField('device_id', 0b11100000),
                          BitField('diagnostic', 0b00001000),
                          BitField('over_temp', 0b00000010),
                          BitField('over_current', 0b00000001),
                      )),
             Register(
                 'MODE',
                 0x01,
                 fields=(
                     BitField('reset', 0b10000000),
                     BitField('standby', 0b01000000),
                     BitField(
                         'mode',
                         0b00000111,
                         adapter=LookupAdapter({
                             'Internal Trigger':
                             0,  # Waveforms are fired by setting the GO bit in register 0x0C
                             'Edge Trigger':
                             1,  # A rising edge on INT/TRIG sets the GO bit, a second rising edge cancels the waveform
                             'Level Trigger':
                             2,  # A rising edge on INT/TRIG sets the GO bit, a falling edge cancels the waveform
                             'PWM/Analog In':
                             3,  # A PWM or Analog signal is accepted on INT/TRIG and used as a direct driving source
                             'Audio In':
                             4,  # An AC-coupled audio signal is accepted on INT/TRIG and turned into meaningful vibration
                             # (AC_COUPLE and N_PWM_ANALOG should also be set)
                             'Real-time Playback':
                             5,  # The contents of the REALTIME_PLAYBACK register are used as a waveform
                             'Diagnostics':
                             6,  # Perform a diagnostic test on the actuator- triggered by setting the GO bit
                             'Auto Calibration':
                             7  # Perform an auto-calibration- triggered by setting the GO bit
                         })),
                 )),
             Register('REALTIME_PLAYBACK',
                      0x02,
                      fields=(BitField('input', 0xFF), )),
             Register(
                 'LIBRARY_SELECTION',
                 0x03,
                 fields=(
                     BitField('high_impedance', 0b00010000),
                     BitField(
                         'library',
                         0b00000111,
                         adapter=LookupAdapter({
                             'Empty': 0,
                             'TS2200 A':
                             1,  # Rated 1.3v, Overdrive 3v, 40ms to 60ms rise, 20ms to 40ms brake
                             'TS2200 B':
                             2,  # Rated 3v, Overdrive 3v, 40ms to 60ms rise, 5ms to 15ms brake
                             'TS2200 C':
                             3,  # Rated 3v, Overdrive 3v, 60ms to 80ms rise, 10ms to 20ms brake
                             'TS2200 D':
                             4,  # Rated 3v, Overdrive 3v, 100ms to 140ms rise, 15ms to 25ms brake
                             'TS2200 E':
                             5,  # Rated 3v, Overdrive 3v, > 140ms rise, > 30ms brake
                             'LRA': 6,  # Linear Resonance
                             'TS2200 F':
                             7  # Rated 4.5v, Overdrive 5v, 35ms to 45ms rise, 10ms to 20ms brake
                         })),
                 )),
             # When the wait bit is set, the value of its corresponding
             # waveform becomes a timed delay.
             # Delay time = 10 ms x waveformN
             Register('WAVEFORM_SEQUENCER',
                      0x04,
                      fields=(
                          BitField('step1_wait',
                                   0xFF << 56,
                                   adapter=WaitTimeAdapter()),
                          BitField('step1_waveform', 0xFF << 56),
                          BitField('step2_wait',
                                   0xFF << 48,
                                   adapter=WaitTimeAdapter()),
                          BitField('step2_waveform', 0xFF << 48),
                          BitField('step3_wait',
                                   0xFF << 40,
                                   adapter=WaitTimeAdapter()),
                          BitField('step3_waveform', 0xFF << 40),
                          BitField('step4_wait',
                                   0xFF << 32,
                                   adapter=WaitTimeAdapter()),
                          BitField('step4_waveform', 0xFF << 32),
                          BitField('step5_wait',
                                   0xFF << 24,
                                   adapter=WaitTimeAdapter()),
                          BitField('step5_waveform', 0xFF << 24),
                          BitField('step6_wait',
                                   0xFF << 16,
                                   adapter=WaitTimeAdapter()),
                          BitField('step6_waveform', 0xFF << 16),
                          BitField('step7_wait',
                                   0xFF << 8,
                                   adapter=WaitTimeAdapter()),
                          BitField('step7_waveform', 0xFF << 8),
                          BitField('step8_wait',
                                   0xFF << 0,
                                   adapter=WaitTimeAdapter()),
                          BitField('step8_waveform', 0xFF << 0),
                      ),
                      bit_width=8 * 8),
             Register('GO', 0x0C, fields=(BitField('go', 0b00000001), )),
             Register('TIME_OFFSET',
                      0x0D,
                      fields=(BitField('overdrive', 0xFF000000),
                              BitField('positive_sustain', 0x00FF0000),
                              BitField('negative_sustain', 0x0000FF00),
                              BitField('brake', 0x000000FF)),
                      bit_width=8 * 4),
             Register('AUDIO_CONTROL',
                      0x11,
                      fields=(BitField('peak_detection_time_ms',
                                       0b00001100,
                                       adapter=LookupAdapter({
                                           10: 0,
                                           20: 1,
                                           30: 2,
                                           40: 3
                                       })),
                              BitField('low_pass_filter_hz',
                                       0b00000011,
                                       adapter=LookupAdapter({
                                           100: 0,
                                           125: 1,
                                           150: 2,
                                           200: 3
                                       })))),
             Register(
                 'AUDIO_INPUT_LEVEL',
                 0x12,
                 fields=(
                     BitField(
                         'minimum', 0xFF00
                     ),  # input level v = (minimum * 1.8) / 255 TODO create an adapter
                     BitField(
                         'maximum', 0x00FF
                     )  # input level v = (maximum * 1.8) / 255 TODO create an adapter
                 ),
                 bit_width=8 * 2),
             Register(
                 'AUDIO_OUTPUT_DRIVE',
                 0x14,
                 fields=(
                     BitField(
                         'minimum', 0xFF00
                     ),  # max drive % = (maximum / 255) x 100 TODO create an adapter
                     BitField(
                         'maximum', 0x00FF
                     )  # max drive % = (maximum / 255) x 100 TODO create an adapter
                 ),
                 bit_width=8 * 2),
             Register('VOLTAGE',
                      0x16,
                      fields=(BitField('rated', 0xFF00),
                              BitField('overdrive_clamp', 0x00FF)),
                      bit_width=8 * 2),
             Register(
                 'AUTO_CALIBRATION_RESULT',
                 0x18,
                 fields=(
                     BitField('compensation',
                              0xFF00),  # coef = 1 + compensation / 255
                     BitField(
                         'back_emf', 0x00FF
                     ),  # back-emf v = back_emf / 255 * 1.22 / back_emf_gain
                 ),
                 bit_width=8 * 2),
             Register(
                 'FEEDBACK_CONTROL',
                 0x1A,
                 fields=(
                     BitField('mode',
                              0b10000000,
                              adapter=LookupAdapter({
                                  'ERM': 0,
                                  'LRA': 1
                              })),
                     BitField('feedback_brake_factor',
                              0b01110000,
                              adapter=LookupAdapter({
                                  1: 0,
                                  2: 1,
                                  3: 2,
                                  4: 3,
                                  6: 4,
                                  8: 5,
                                  16: 6,
                                  0: 7
                              })),
                     BitField('loop_gain',
                              0b00001100,
                              adapter=LookupAdapter({
                                  'low': 0,
                                  'medium': 1,
                                  'high': 2,
                                  'very high': 3
                              })),
                     BitField(
                         'back_emf_gain',
                         0b00000011,
                         adapter=LookupAdapter({
                             0.255: 0,  # ERM mode
                             0.7875: 1,
                             1.365: 2,
                             3.0: 3,
                             3.75: 0,  # LRA mode
                             7.5: 1,
                             15.0: 2,
                             22.5: 3
                         })))),
             Register('CONTROL1',
                      0x1B,
                      fields=(BitField('startup_boost', 0b10000000),
                              BitField('ac_couple', 0b00100000),
                              BitField('drive_time', 0b00011111))),
             Register('CONTROL2',
                      0x1C,
                      fields=(BitField('bidir_input', 0b10000000),
                              BitField('brake_stabalize', 0b01000000),
                              BitField('sample_time', 0b00110000),
                              BitField('blanking_time', 0b00001100),
                              BitField('idiss_time', 0b00000011))),
             Register('CONTROL3',
                      0x1D,
                      fields=(BitField('noise_gate_threshold',
                                       0b11000000,
                                       adapter=LookupAdapter({
                                           'Disabled': 0,
                                           '2%': 1,
                                           '4%': 2,
                                           '8%': 3
                                       })),
                              BitField('erm_open_loop',
                                       0b00100000,
                                       adapter=LookupAdapter({
                                           'Closed Loop': 0,
                                           'Open Loop': 1
                                       })),
                              BitField('supply_compensation_disable',
                                       0b00010000,
                                       adapter=LookupAdapter({
                                           'Enabled': 0,
                                           'Disabled': 1
                                       })),
                              BitField('data_format_rtp',
                                       0b00001000,
                                       adapter=LookupAdapter({
                                           'Signed': 0,
                                           'Unsigned': 1
                                       })),
                              BitField('lra_drive_mode',
                                       0b00000100,
                                       adapter=LookupAdapter({
                                           'Once': 0,
                                           'Twice': 1
                                       })),
                              BitField('pwm_input_mode',
                                       0b00000010,
                                       adapter=LookupAdapter({
                                           'PWM': 0,
                                           'Analog': 1
                                       })),
                              BitField('lra_open_loop',
                                       0b00000001,
                                       adapter=LookupAdapter({
                                           'Auto-resonance':
                                           0,
                                           'Open Loop':
                                           1
                                       })))),
             Register(
                 'CONTROL4',
                 0x1E,
                 fields=(
                     BitField('zero_crossing_detection_time',
                              0b11000000,
                              adapter=LookupAdapter({
                                  100: 0,
                                  200: 1,
                                  300: 2,
                                  390: 3
                              })),
                     BitField(
                         'auto_calibration_time',
                         0b00110000,
                         adapter=LookupAdapter({
                             150: 0,  # 150ms to 350ms
                             250: 1,  # 250ms to 450ms
                             500: 2,  # 500ms to 700ms
                             1000: 3  # 1000ms to 1200ms
                         })),
                     # BitField('otp_status', 0b00000100),
                     # BitField('otp_program', 0b0000001)
                 )),
             Register('CONTROL5',
                      0x1F,
                      fields=(BitField('auto_open_loop_attempts',
                                       0b11000000,
                                       adapter=LookupAdapter({
                                           3: 0,
                                           4: 1,
                                           5: 2,
                                           6: 3
                                       })),
                              BitField('auto_open_loop_transition',
                                       0b00100000),
                              BitField('playback_interval_ms',
                                       0b00010000,
                                       adapter=LookupAdapter({
                                           5: 0,
                                           1: 1
                                       })),
                              BitField('blanking_time', 0b00001100),
                              BitField('idiss_time', 0b00000011))),
             Register(
                 'LRA_OPEN_LOOP_PERIOD',
                 0x20,
                 fields=(
                     BitField('period',
                              0x7F),  # period (us) = period * 98.46
                 )),
             Register('VOLTAGE', 0x21, fields=(BitField('vbat', 0xFF), )),
             Register(
                 'LRA_RESONANCE',
                 0x22,
                 fields=(
                     BitField('period',
                              0xFF),  # period (us) = period * 98.46
                 ))))
Example #8
0
    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)))
Example #9
0
    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
                                          })), )),
            ))
Example #10
0
    def __init__(self, i2c_addr=I2C_ADDRESS_DEFAULT, i2c_dev=None):
        self._is_setup = False
        self._i2c_addr = i2c_addr
        self._i2c_dev = i2c_dev
        self._mcp9600 = Device(I2C_ADDRESSES, i2c_dev=self._i2c_dev, bit_width=8, registers=(
            Register('HOT_JUNCTION', 0x00, fields=(
                BitField('temperature', 0xFFFF, adapter=TemperatureAdapter()),
            ), bit_width=16),
            Register('DELTA', 0x01, fields=(
                BitField('value', 0xFFFF, adapter=TemperatureAdapter()),
            ), bit_width=16),
            Register('COLD_JUNCTION', 0x02, fields=(
                BitField('temperature', 0x1FFF, adapter=TemperatureAdapter()),
            ), bit_width=16),
            Register('RAW_DATA', 0x03, fields=(
                BitField('adc', 0xFFFFFF),
            ), bit_width=24),
            Register('STATUS', 0x04, fields=(
                BitField('burst_complete', 0b10000000),
                BitField('updated', 0b01000000),
                BitField('input_range', 0b00010000),
                BitField('alert_4', 0b00001000),
                BitField('alert_3', 0b00000100),
                BitField('alert_2', 0b00000010),
                BitField('alert_1', 0b00000001)
            )),
            Register('THERMOCOUPLE_CONFIG', 0x05, fields=(
                BitField('type_select', 0b01110000, adapter=LookupAdapter({
                    'K': 0b000,
                    'J': 0b001,
                    'T': 0b010,
                    'N': 0b011,
                    'S': 0b100,
                    'E': 0b101,
                    'B': 0b110,
                    'R': 0b111
                })),
                BitField('filter_coefficients', 0b00000111)
            )),
            Register('DEVICE_CONFIG', 0x06, fields=(
                BitField('cold_junction_resolution', 0b10000000, adapter=LookupAdapter({
                    0.0625: 0b0,
                    0.25: 0b1
                })),
                BitField('adc_resolution', 0b01100000, adapter=LookupAdapter({
                    18: 0b00,
                    16: 0b01,
                    14: 0b10,
                    12: 0b11
                })),
                BitField('burst_mode_samples', 0b00011100, adapter=LookupAdapter({
                    1: 0b000,
                    2: 0b001,
                    4: 0b010,
                    8: 0b011,
                    16: 0b100,
                    32: 0b101,
                    64: 0b110,
                    128: 0b111
                })),
                BitField('shutdown_modes', 0b00000011, adapter=LookupAdapter({
                    'Normal': 0b00,
                    'Shutdown': 0b01,
                    'Burst': 0b10
                }))
            )),
            Register('ALERT1_CONFIG', 0x08, fields=(
                BitField('clear_interrupt', 0b10000000),
                BitField('monitor_junction', 0b00010000),  # 1 Cold Junction, 0 Thermocouple
                BitField('rise_fall', 0b00001000),         # 1 rising, 0 cooling
                BitField('state', 0b00000100),             # 1 active high, 0 active low
                BitField('mode', 0b00000010),              # 1 interrupt mode, 0 comparator mode
                BitField('enable', 0b00000001)             # 1 enable, 0 disable
            )),
            Register('ALERT2_CONFIG', 0x09, fields=(
                BitField('clear_interrupt', 0b10000000),
                BitField('monitor_junction', 0b00010000),  # 1 Cold Junction, 0 Thermocouple
                BitField('rise_fall', 0b00001000),         # 1 rising, 0 cooling
                BitField('state', 0b00000100),             # 1 active high, 0 active low
                BitField('mode', 0b00000010),              # 1 interrupt mode, 0 comparator mode
                BitField('enable', 0b00000001)             # 1 enable, 0 disable
            )),
            Register('ALERT3_CONFIG', 0x0A, fields=(
                BitField('clear_interrupt', 0b10000000),
                BitField('monitor_junction', 0b00010000),  # 1 Cold Junction, 0 Thermocouple
                BitField('rise_fall', 0b00001000),         # 1 rising, 0 cooling
                BitField('state', 0b00000100),             # 1 active high, 0 active low
                BitField('mode', 0b00000010),              # 1 interrupt mode, 0 comparator mode
                BitField('enable', 0b00000001)             # 1 enable, 0 disable
            )),
            Register('ALERT4_CONFIG', 0x0B, fields=(
                BitField('clear_interrupt', 0b10000000),
                BitField('monitor_junction', 0b00010000),  # 1 Cold Junction, 0 Thermocouple
                BitField('rise_fall', 0b00001000),         # 1 rising, 0 cooling
                BitField('state', 0b00000100),             # 1 active high, 0 active low
                BitField('mode', 0b00000010),              # 1 interrupt mode, 0 comparator mode
                BitField('enable', 0b00000001)             # 1 enable, 0 disable
            )),
            Register('ALERT1_HYSTERESIS', 0x0C, fields=(
                BitField('value', 0xFF),
            )),
            Register('ALERT2_HYSTERESIS', 0x0D, fields=(
                BitField('value', 0xFF),
            )),
            Register('ALERT3_HYSTERESIS', 0x0E, fields=(
                BitField('value', 0xFF),
            )),
            Register('ALERT4_HYSTERESIS', 0x0F, fields=(
                BitField('value', 0xFF),
            )),
            Register('ALERT1_LIMIT', 0x10, fields=(
                BitField('value', 0xFFFF, adapter=AlertLimitAdapter()),
            ), bit_width=16),
            Register('ALERT2_LIMIT', 0x11, fields=(
                BitField('value', 0xFFFF, adapter=AlertLimitAdapter()),
            ), bit_width=16),
            Register('ALERT3_LIMIT', 0x12, fields=(
                BitField('value', 0xFFFF, adapter=AlertLimitAdapter()),
            ), bit_width=16),
            Register('ALERT4_LIMIT', 0x13, fields=(
                BitField('value', 0xFFFF, adapter=AlertLimitAdapter()),
            ), bit_width=16),
            Register('CHIP_ID', 0x20, fields=(
                BitField('id', 0xFF00),
                BitField('revision', 0x00FF, adapter=RevisionAdapter())
            ), bit_width=16)
        ))

        self.alert_registers = [
            'ALERT1_CONFIG',
            'ALERT2_CONFIG',
            'ALERT3_CONFIG',
            'ALERT4_CONFIG'
        ]
        self.alert_limits = [
            'ALERT1_LIMIT',
            'ALERT2_LIMIT',
            'ALERT3_LIMIT',
            'ALERT4_LIMIT'
        ]
        self.alert_hysteresis = [
            'ALERT1_HYSTERESIS',
            'ALERT2_HYSTERESIS',
            'ALERT3_HYSTERESIS',
            'ALERT4_HYSTERESIS'
        ]

        self._mcp9600.select_address(self._i2c_addr)

        try:
            chip = self._mcp9600.get('CHIP_ID')
            if chip.id != CHIP_ID:
                raise RuntimeError("Unable to find mcp9600 on 0x{:02x}, CHIP_ID returned {:02x}".format(self._i2c_addr, chip.id))
        except IOError:
            raise RuntimeError("Unable to find mcp9600 on 0x{:02x}, IOError".format(self._i2c_addr))
Example #11
0
        return ((value & 0xFF)) << 8 | ((value & 0xF00) >> 8)

    def _decode(self, value):
        """
        Convert the 12-bit input into the correct format for the registers,
        the low byte followed by 4 empty bits and the high nibble:

            0bHHHHLLLLLLLL -> 0bLLLLLLLLXXXXHHHH
        """
        return ((value & 0xFF00) >> 8) | ((value & 0x000F) << 8)


ltr559 = Device(I2C_ADDR, 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}))
    )),

    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}))
    )),
Example #12
0
    def __init__(self, i2c_dev=None):
        """Initialise the TCS3472."""

        self._max_count = 0
        self._integration_time_ms = 0
        self._rgbc_tuple = namedtuple('Colour', (
            'time',
            'red',
            'green',
            'blue',
            'raw_red',
            'raw_green',
            'raw_blue',
            'raw_clear'
        ))

        self._tcs3472 = Device(I2C_ADDR, i2c_dev=i2c_dev, bit_width=8, registers=(
            Register('ENABLE', I2C_COMMAND | 0x00, fields=(
                BitField('power_on', 0b00000001),
                BitField('enable', 0b00000010),
                BitField('wait_enable', 0b00001000),
                BitField('int_enable', 0b00010000)
            )),
            # Actual integration time is (256 - INTEGRATION_TIME) * 2.4
            # Integration time affects the max ADC count, with the max count
            # being (256 - INTEGRATION_TIME) * 1024 up to a limit of 65535.
            # IE: An integration time of 0xF6 (24ms) would limit readings to 0-10240.
            Register('INTEGRATION_TIME', I2C_COMMAND | 0x01, fields=(
                BitField('time_ms', 0xff, adapter=IntegrationTimeAdapter()),  
            )),
            # Actual wait time is (256 - WAIT_TIME) * 2.4
            # if the WLONG bit is set, this value is multiplied by 12
            Register('WAIT_TIME', I2C_COMMAND | 0x03, fields=(
                BitField('time_ms', 0xff, adapter=WaitTimeAdapter()),
            )),
            Register('INTERRUPT_THRESHOLD', I2C_COMMAND | I2C_AUTOINC | 0x04, fields=(
                BitField('low', 0x0000ffff),
                BitField('high', 0xffff0000)
            ), bit_width=8 * 4),
            Register('PERSISTENCE', I2C_COMMAND | 0x0c, fields=(
                BitField('count', 0x0f, adapter=LookupAdapter({
                    0: 0b0000,
                    1: 0b0001,
                    2: 0b0010,
                    3: 0b0011,
                    5: 0b0100,
                    10: 0b0101,
                    15: 0b0110,
                    20: 0b0111,
                    25: 0b1000,
                    30: 0b1001,
                    35: 0b1010,
                    40: 0b1011,
                    45: 0b1100,
                    50: 0b1101,
                    55: 0b1110,
                    60: 0b1111
                })),
            )),
            # wlong multiplies the wait time by 12
            Register('CONFIGURATION', I2C_COMMAND | 0x0d, fields=(
                BitField('wlong', 0b00000010),    
            )),
            Register('CONTROL', I2C_COMMAND | 0x0f, fields=(
                BitField('gain', 0b00000011, adapter=LookupAdapter({
                    1: 0b00,
                    4: 0b01,
                    16: 0b10,
                    60: 0b11
                })),   
            )),
            # Should be either 0x44 (TCS34725) or 0x4D (TCS34727)
            Register('ID', I2C_COMMAND | 0x12, fields=(
                BitField('id', 0xff),    
            )),
            Register('STATUS', I2C_COMMAND | 0x13, fields=(
                BitField('aint', 0b00010000),
                BitField('avalid', 0b00000001)
            )),
            Register('RGBC', I2C_COMMAND | I2C_AUTOINC | 0x14, fields=(
                BitField('clear', 0xffff, adapter=U16ByteSwapAdapter()),
                BitField('red', 0xffff << 16, adapter=U16ByteSwapAdapter()),
                BitField('green', 0xffff << 32, adapter=U16ByteSwapAdapter()),
                BitField('blue', 0xffff << 48, adapter=U16ByteSwapAdapter())
            ), bit_width=8 * 8)
        ))

        chip = self._tcs3472.get('ID')

        if chip.id not in CHIP_ID:
            raise RuntimeError("TCS3472 not found! Chip ID {} not in {}".format(chip.id, CHIP_ID))

        # Enable the sensor and RGBC interface by default
        self._tcs3472.set('ENABLE', power_on=True, enable=True)

        # Aim for 100ms integration time, or 10 readings / second
        # This should give a saturation of ~41984 counts: (256 - 0xd7) * 1024
        # During testing it reached saturation at 41984
        self.set_integration_time_ms(100)
Example #13
0
    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
Example #14
0
    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()
Example #15
0
    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)
Example #16
0
    def __init__(self,
                 i2c_addr=I2C_ADDRESS_DEFAULT,
                 alert_pin=None,
                 i2c_dev=None):
        self._lock = Lock()
        self._is_setup = False
        self._i2c_addr = i2c_addr
        self._i2c_dev = i2c_dev
        self._alert_pin = alert_pin
        self._deprecated_channels = {
            'in0/ref': 'in0/in3',
            'in1/ref': 'in1/in3',
            'in2/ref': 'in2/in3',
            'ref/gnd': 'in3/gnd'
        }
        self._is_ads1115 = False

        self._ads1115 = Device(
            I2C_ADDRESSES,
            i2c_dev=self._i2c_dev,
            bit_width=8,
            registers=(
                Register('CONFIG',
                         0x01,
                         fields=(BitField('data_rate_sps',
                                          0b0000000011100000,
                                          adapter=LookupAdapter({
                                              8: 0b000,
                                              16: 0b001,
                                              32: 0b010,
                                              64: 0b011,
                                              128: 0b100,
                                              475: 0b101,
                                              860: 0b110
                                          })), )),
                Register('CONV',
                         0x00,
                         fields=(BitField('value',
                                          0xFFFF,
                                          adapter=Conv16Adapter()), ),
                         bit_width=16),
            ))
        self._ads1115.select_address(self._i2c_addr)

        self._ads1015 = Device(
            I2C_ADDRESSES,
            i2c_dev=self._i2c_dev,
            bit_width=8,
            registers=(
                Register(
                    'CONFIG',
                    0x01,
                    fields=(
                        BitField('operational_status',
                                 0b1000000000000000,
                                 adapter=LookupAdapter({
                                     'active': 0,
                                     'inactive_start': 1
                                 })),
                        BitField(
                            'multiplexer',
                            0b0111000000000000,
                            adapter=LookupAdapter({
                                'in0/in1':
                                0b000,  # Differential reading between in0 and in1, voltages must not be negative and must not exceed supply voltage
                                'in0/in3':
                                0b001,  # Differential reading between in0 and in3. pimoroni breakout onboard reference connected to in3
                                'in1/in3':
                                0b010,  # Differential reading between in1 and in3. pimoroni breakout onboard reference connected to in3
                                'in2/in3':
                                0b011,  # Differential reading between in2 and in3. pimoroni breakout onboard reference connected to in3
                                'in0/gnd':
                                0b100,  # Single-ended reading between in0 and GND
                                'in1/gnd':
                                0b101,  # Single-ended reading between in1 and GND
                                'in2/gnd':
                                0b110,  # Single-ended reading between in2 and GND
                                'in3/gnd':
                                0b111  # Single-ended reading between in3 and GND. Should always read 1.25v (or reference voltage) on pimoroni breakout
                            })),
                        BitField('programmable_gain',
                                 0b0000111000000000,
                                 adapter=LookupAdapter({
                                     6.144: 0b000,
                                     4.096: 0b001,
                                     2.048: 0b010,
                                     1.024: 0b011,
                                     0.512: 0b100,
                                     0.256: 0b101
                                 })),
                        BitField('mode',
                                 0b0000000100000000,
                                 adapter=LookupAdapter({
                                     'continuous': 0,
                                     'single': 1
                                 })),
                        BitField('data_rate_sps',
                                 0b0000000011100000,
                                 adapter=LookupAdapter({
                                     128: 0b000,
                                     250: 0b001,
                                     490: 0b010,
                                     920: 0b011,
                                     1600: 0b100,
                                     2400: 0b101,
                                     3300: 0b110
                                 })),
                        BitField(
                            'comparator_mode',
                            0b0000000000010000,
                            adapter=LookupAdapter({
                                'traditional':
                                0b0,  # Traditional comparator with hystersis
                                'window': 0b01
                            })),
                        BitField('comparator_polarity',
                                 0b0000000000001000,
                                 adapter=LookupAdapter({
                                     'active_low': 0b0,
                                     'active_high': 0b1
                                 })),
                        BitField('comparator_latching', 0b0000000000000100),
                        BitField('comparator_queue',
                                 0b0000000000000011,
                                 adapter=LookupAdapter({
                                     'one': 0b00,
                                     'two': 0b01,
                                     'four': 0b10,
                                     'disabled': 0b11
                                 }))),
                    bit_width=16),
                Register('CONV',
                         0x00,
                         fields=(BitField('value',
                                          0xFFF0,
                                          adapter=ConvAdapter()), ),
                         bit_width=16),
                Register('THRESHOLD',
                         0x02,
                         fields=(BitField('low', 0xFFFF, adapter=S16Adapter()),
                                 BitField('high', 0xFFFF,
                                          adapter=S16Adapter())),
                         bit_width=32)))
        self._ads1015.select_address(self._i2c_addr)
Example #17
0
 def __init__(self, i2c_addr=I2C_ADDRESS, i2c_dev=None):
     self._is_setup = False
     self._i2c_addr = i2c_addr
     self._i2c_dev = i2c_dev
     self._active_leds = 0
     self._max30105 = Device(
         I2C_ADDRESS,
         i2c_dev=self._i2c_dev,
         bit_width=8,
         registers=(
             Register('INT_STATUS_1',
                      0x00,
                      fields=(BitField('a_full', bit(7)),
                              BitField('data_ready', bit(6)),
                              BitField('alc_overflow', bit(5)),
                              BitField('prox_int', bit(4)),
                              BitField('pwr_ready', bit(0)))),
             Register('INT_STATUS_2',
                      0x01,
                      fields=(BitField('die_temp_ready', bit(1)), )),
             Register('INT_ENABLE_1',
                      0x02,
                      fields=(
                          BitField('a_full_en', bit(7)),
                          BitField('data_ready_en', bit(6)),
                          BitField('alc_overflow_en', bit(5)),
                          BitField('prox_int_en', bit(4)),
                      )),
             Register('INT_ENABLE_2',
                      0x03,
                      fields=(BitField('die_temp_ready_en', bit(1)), )),
             # Points to MAX30105 write location in FIFO
             Register('FIFO_WRITE',
                      0x04,
                      fields=(BitField('pointer', 0b00011111), )),
             # Counts the number of samples lost up to 0xf
             Register('FIFO_OVERFLOW',
                      0x05,
                      fields=(BitField('counter', 0b00011111), )),
             # Points to read location in FIFO
             Register('FIFO_READ',
                      0x06,
                      fields=(BitField('pointer', 0b00011111), )),
             Register('FIFO_CONFIG',
                      0x08,
                      fields=(BitField('sample_average',
                                       0b11100000,
                                       adapter=LookupAdapter({
                                           1: 0b000,
                                           2: 0b001,
                                           4: 0b010,
                                           8: 0b011,
                                           16: 0b100,
                                           32: 0b101
                                       })),
                              BitField('fifo_rollover_en', 0b00010000),
                              BitField('fifo_almost_full', 0b00001111))),
             Register('MODE_CONFIG',
                      0x09,
                      fields=(BitField('shutdown', 0b10000000),
                              BitField('reset', 0b01000000),
                              BitField('mode',
                                       0b00000111,
                                       adapter=LookupAdapter({
                                           'none':
                                           0b00,
                                           'red_only':
                                           0b010,
                                           'red_ir':
                                           0b011,
                                           'green_red_ir':
                                           0b111
                                       })))),
             Register(
                 'SPO2_CONFIG',
                 0x0A,
                 fields=(
                     BitField('adc_range_nA',
                              0b01100000,
                              adapter=LookupAdapter({
                                  2048: 0b00,
                                  4096: 0b01,
                                  8192: 0b10,
                                  16384: 0b11
                              })),
                     BitField('sample_rate_sps',
                              0b00011100,
                              adapter=LookupAdapter({
                                  50: 0b000,
                                  100: 0b001,
                                  200: 0b010,
                                  400: 0b011,
                                  800: 0b100,
                                  1000: 0b101,
                                  1600: 0b110,
                                  3200: 0b111
                              })),
                     BitField(
                         'led_pw_us',
                         0b00000011,
                         adapter=LookupAdapter({
                             69: 0b00,  # 68.95us
                             118: 0b01,  # 117.78us
                             215: 0b10,  # 215.44us
                             411: 0b11  # 410.75us
                         })))),
             Register('LED_PULSE_AMPLITUDE',
                      0x0C,
                      fields=(BitField('led1_mA',
                                       0xff0000,
                                       adapter=PulseAmplitudeAdapter()),
                              BitField('led2_mA',
                                       0x00ff00,
                                       adapter=PulseAmplitudeAdapter()),
                              BitField('led3_mA',
                                       0x0000ff,
                                       adapter=PulseAmplitudeAdapter())),
                      bit_width=24),
             Register('LED_PROX_PULSE_AMPLITUDE',
                      0x10,
                      fields=(BitField('pilot_mA',
                                       0xff,
                                       adapter=PulseAmplitudeAdapter()), )),
             # The below represent 4 timeslots
             Register('LED_MODE_CONTROL',
                      0x11,
                      fields=(BitField('slot2',
                                       0x7000,
                                       adapter=LEDModeAdapter()),
                              BitField('slot1',
                                       0x0700,
                                       adapter=LEDModeAdapter()),
                              BitField('slot4',
                                       0x0070,
                                       adapter=LEDModeAdapter()),
                              BitField('slot3',
                                       0x0007,
                                       adapter=LEDModeAdapter())),
                      bit_width=16),
             Register('DIE_TEMP',
                      0x1f,
                      fields=(BitField('temperature',
                                       0xffff,
                                       adapter=TemperatureAdapter()), ),
                      bit_width=16),
             Register('DIE_TEMP_CONFIG',
                      0x21,
                      fields=(BitField('temp_en', bit(0)), )),
             Register('PROX_INT_THRESHOLD',
                      0x30,
                      fields=(BitField('threshold', 0xff), )),
             Register('PART_ID',
                      0xfe,
                      fields=(BitField('revision',
                                       0xff00), BitField('part', 0x00ff)),
                      bit_width=16)))
Example #18
0
                  BitField('monkey',
                           0b01111100,
                           adapter=x2Adapter()))),
 Register('measurement_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,
Example #19
0
              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,
Example #20
0
    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
Example #21
0
    def __init__(self, i2c_addr=0x26, i2c_dev=None):
        self._i2c_addr = i2c_addr
        self._i2c_dev = i2c_dev
        self._is_setup = False

        self._rv3028 = Device([0x52], i2c_dev=self._i2c_dev, bit_width=8, registers=(
            Register('SECONDS', 0x00, fields=(
                BitField('seconds', 0x7F, adapter=BCDAdapter()),
            )),
            Register('MINUTES', 0x01, fields=(
                BitField('minutes', 0x7F, adapter=BCDAdapter()),
            )),
            Register('HOURS', 0x02, fields=(
                BitField('t24hours', 0b00111111, adapter=BCDAdapter()),
                BitField('t12hours', 0b00011111, adapter=BCDAdapter()),
                BitField('am_pm', 0b00100000),
            )),
            Register('WEEKDAY', 0x03, fields=(
                BitField('weekday', 0b00000111),
            )),
            Register('DATE', 0x04, fields=(
                BitField('date', 0b00111111, adapter=BCDAdapter()),
            )),
            Register('MONTH', 0x05, fields=(
                BitField('month', 0b00011111, adapter=BCDAdapter()),
            )),
            Register('YEAR', 0x06, fields=(
                BitField('year', 0xFF, adapter=BCDAdapter()),
            )),
            Register('ALARM_MINUTES', 0x07, fields=(
                BitField('minutes_alarm_enable', 0b10000000),
                BitField('minutes', 0x7F, adapter=BCDAdapter()),
            )),
            Register('ALARM_HOURS', 0x08, fields=(
                BitField('hours_alarm_enable', 0b10000000, adapter=BCDAdapter()),
                BitField('t24hours', 0b00111111, adapter=BCDAdapter()),
                BitField('t12hours', 0b00011111, adapter=BCDAdapter()),
                BitField('am_pm', 0b00100000),
            )),
            Register('ALARM_WEEKDAY', 0x09, fields=(
                BitField('weekday_alarm_enable', 0b10000000, adapter=BCDAdapter()),
                BitField('weekday', 0b00000111),
                BitField('date', 0b00111111)
            )),
            Register('TIMER_VALUE', 0x0A, fields=(
                BitField('value', 0xFF0F, adapter=U16ByteSwapAdapter()),
            ), bit_width=16),
            Register('TIMER_STATUS', 0x0C, fields=(
                BitField('value', 0xFF0F, adapter=U16ByteSwapAdapter()),
            ), bit_width=16),
            Register('STATUS', 0x0E, fields=(
                BitField('value', 0xFF),
                BitField('eeprom_busy_flag', 0b10000000),
                BitField('clock_output_interrupt_flag', 0b01000000),
                BitField('backup_switch_flag', 0b00100000),
                BitField('periodic_time_update_flag', 0b00010000),
                BitField('periodic_countdown_timer_flag', 0b00001000),
                BitField('alarm_flag', 0b00000100),
                BitField('external_event_flag', 0b00000010),
                BitField('power_on_reset_flag', 0b00000001),
            )),
            Register('CONTROL_1', 0x0F, fields=(
                BitField('value', 0xFF),
                BitField('timer_repeat', 0b10000000),
                BitField('weekday_date_alarm', 0b00100000),
                BitField('update_interrupt', 0b00010000),
                BitField('eeprom_memory_refresh_disable', 0b00001000),
                BitField('periodic_countdown_timer_enable', 0b00000100),
                BitField('timer_frequency_selection', 0b00000011, adapter=LookupAdapter({
                    '4036Hz': 0b00,  # 214.14us
                    '63Hz': 0b01,    # 15.625ms
                    '1Hz': 0b10,     # 1s
                    '0.016Hz': 0b11  # 60s
                })),
            )),
            Register('CONTROL_2', 0x10, fields=(
                BitField('value', 0xFF),
                BitField('timestamp_enable', 0b10000000),
                BitField('interrupt_controlled_output_enable', 0b01000000),
                BitField('periodic_time_update_interupt_enable', 0b00100000),
                BitField('periodic_countdown_timer_interupt_enable', 0b00010000),
                BitField('alarm_interupt_enable', 0b00001000),
                BitField('external_event_interrupt_enable', 0b00000100),
                BitField('select_24_12_hours', 0b00000010),
                BitField('reset', 0b00000001),
            )),
            Register('GENERAL_PURPOSE_STORAGE_REGISTER', 0x11, fields=(
                BitField('value', 0b01111111),
            )),
            Register('CLOCK_INTERRUPT_MASK', 0x12, fields=(
                BitField('value', 0x0F),
                BitField('clock_output_when_event_interrupt', 0b00001000),
                BitField('clock_output_when_alarm_interrupt', 0b00000100),
                BitField('clock_output_when_countdown_interrupt', 0b00000010),
                BitField('clock_output_when_periodic_interrupt', 0b00000001),
            )),
            Register('EVENT_CONTROL', 0x13, fields=(
                BitField('value', 0xFF),
                BitField('event_high_low_detection', 0b01000000),
                BitField('event_filtering_time', 0b00110000, adapter=LookupAdapter({
                    'no_filtering': 0b00,
                    '3.9ms': 0b01,
                    '15.6ms': 0b10,
                    '125ms': 0b11
                })),
                BitField('timestamp_reset', 0b00000100),
                BitField('timestamp_overwrite', 0b00000010),
                BitField('timestamp_source', 0b00000001),
            )),
            Register('TIMESTAMP_COUNT', 0x14, fields=(
                BitField('value', 0xFF),
            )),
            Register('TIMESTAMP_SECONDS', 0x15, fields=(
                BitField('seconds', 0x7F),
            )),
            Register('TIMESTAMP_MINUTES', 0x16, fields=(
                BitField('minutes', 0x7F),
            )),
            Register('TIMESTAMP_HOURS', 0x17, fields=(
                BitField('t24hours', 0b00111111),
                BitField('t12hours', 0b00001111),
                BitField('am_pm', 0x00010000),
            )),
            Register('TIMESTAMP_DATE', 0x18, fields=(
                BitField('date', 0b00011111),
            )),
            Register('TIMESTAMP_MONTH', 0x19, fields=(
                BitField('month', 0b00001111),
            )),
            Register('TIMESTAMP_YEAR', 0x1A, fields=(
                BitField('year', 0xFF),
            )),
            Register('UNIX_TIME', 0x1B, fields=(
                BitField('value', 0xFFFFFFFF, adapter=ReverseBytesAdapter(4)),
            ), bit_width=32),
            Register('USER_RAM', 0x1F, fields=(
                BitField('one', 0x00FF),
                BitField('two', 0xFF00),
            ), bit_width=16),
            Register('PASSWORD', 0x21, fields=(
                BitField('value', 0xFFFFFFFF),
            ), bit_width=32),
            Register('EEPROM_ADDRESS', 0x25, fields=(
                BitField('value', 0xFF),
            )),
            Register('EEPROM_DATA', 0x26, fields=(
                BitField('value', 0xFF),
            )),
            Register('EEPROM_COMMAND', 0x27, fields=(
                BitField('command', 0xFF, adapter=LookupAdapter({
                    'first_command': 0x00,
                    'write_all_configuration_to_eeprom': 0x11,
                    'read_all_configuration_from_eeprom': 0x12,
                    'write_one_byte_to_eeprom_address': 0x21,
                    'read_one_byte_from_eeprom_address': 0x22
                })),
            )),
            Register('PART', 0x28, fields=(
                BitField('id', 0xF0),
                BitField('version', 0x0F)
            )),
            Register('EEPROM_PASSWORD_ENABLE', 0x30, fields=(
                BitField('value', 0xFF),  # Write 0xFF to this register to enable EEPROM password
            )),
            Register('EEPROM_PASSWORD', 0x31, fields=(
                BitField('value', 0xFFFFFFFF),
            ), bit_width=32),
            Register('EEPROM_CLKOUT', 0x35, fields=(
                BitField('value', 0xFF),
                BitField('clkout_output', 0b10000000),
                BitField('clkout_synchronized', 0b01000000),
                BitField('power_on_reset_interrupt_enable', 0b00001000),
                BitField('clkout_frequency_selection', 0b00000111, adapter=LookupAdapter({
                    '32.768kHz': 0b000,
                    '8192Hz': 0b001,
                    '1024Hz': 0b010,
                    '64Hz': 0b011,
                    '32Hz': 0b100,
                    '1Hz': 0b101,
                    'periodic_countdown_timer_interrupt': 0b110,
                    'clkout_low': 0b111,
                })),
            )),
            Register('EEPROM_OFFSET', 0x36, fields=(
                BitField('value', 0xFF),
            )),
            Register('EEPROM_BACKUP', 0x37, fields=(
                BitField('value', 0xFF),
                BitField('ee_offset', 0b10000000),
                BitField('backup_switchover_interrupt_enable', 0b01000000),
                BitField('trickle_charger_enable', 0b00100000),
                BitField('fast_edge_detection', 0b00010000),
                BitField('automatic_battery_switchover', 0b00001100, adapter=LookupAdapter({
                    'switchover_disabled': 0b00,
                    'direct_switching_mode': 0b01,
                    'standby_mode': 0b10,
                    'level_switching_mode': 0b11
                })),
                BitField('trickle_charger_series_resistance', 0b00000011, adapter=LookupAdapter({
                    '1kOhm': 0b00,
                    '3kOhm': 0b01,
                    '6kOhm': 0b10,
                    '11kOhm': 0b11
                })),
            ))


        ))
        self.enable_12hours = self._rv3028.get('CONTROL_2').select_24_12_hours
        self.alarm_frequency = {
            'disabled_weekly': 0b0111,
            'disabled_monthly': 0b1111,
            'hourly_on_minute': 0b110,
            'daily_on_hour': 0b101,
            'daily_on_hour_and_minute': 0b011,
            'weekly': 0b0011,
            'weekly_on_minute': 0b0010,
            'weekly_on_hour': 0b0001,
            'weekly_on_hour_and_minute': 0b0000,
            'monthly': 0b1011,
            'monthly_on_minute': 0b1010,
            'monthly_on_hour': 0b1001,
            'monthly_on_hour_and_minute': 0b1000
        }
Example #22
0
        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
                                  })))),
        Register('PS_LED',
                 0x82,
Example #23
0
    def __init__(self, i2c_addr=0x26, i2c_dev=None):
        self._i2c_addr = i2c_addr
        self._i2c_dev = i2c_dev
        self._is_setup = False
        # Device definition
        self._msa301 = Device([0x26], i2c_dev=self._i2c_dev, bit_width=8, registers=(
            Register('SOFT_RESET', 0x00, fields=(
                BitField('soft_reset', 0b00100000),
                BitField('seft_reset_alt', 0b00000100)
            )),
            Register('PARTID', 0x01, fields=(BitField('id', 0xFF),)),
            Register('ACCEL', 0x02, fields=(
                BitField('x', 0x00000000FFFF, adapter=SensorDataAdapter()),
                BitField('y', 0x0000FFFF0000, adapter=SensorDataAdapter()),
                BitField('z', 0xFFFF00000000, adapter=SensorDataAdapter()),
            ), bit_width=48, read_only=True),
            Register('MOTION_INTERRUPT', 0x09, fields=(
                BitField('interrupts', 0xFF, read_only=True, adapter=InterruptLookupAdapter({
                    'orientation_interrupt': 0b01000000,
                    'single_tap_interrupt': 0b00100000,
                    'double_tap_interrupt': 0b00010000,
                    'active_interrupt': 0b00000100,
                    'freefall_interrupt': 0b00000001
                })),
            )),
            Register('DATA_INTERRUPT', 0x0A, fields=(
                BitField('new_data_interrupt', 0b00000001, read_only=True),
            )),
            Register('TAP_ACTIVE_STATUS', 0x0B, fields=(
                BitField('tap_sign', 0b10000000, read_only=True),
                BitField('tap_triggered_x', 0b01000000, read_only=True),
                BitField('tap_triggered_y', 0b00100000, read_only=True),
                BitField('tap_triggered_z', 0b00010000, read_only=True),
                BitField('active_sign', 0b00001000, read_only=True),
                BitField('active_triggered_x', 0b00000100, read_only=True),
                BitField('active_triggered_y', 0b00000010, read_only=True),
                BitField('active_triggered_z', 0b00000001, read_only=True)
            )),
            Register('ORIENTATION_STATUS', 0x0C, fields=(
                BitField('z_orientation', 0b10000000, read_only=True),
                BitField('x_y_orientation', 0b01100000, read_only=True, adapter=LookupAdapter({
                    'portrait_upright': 0b00,
                    'portrait_upsidedown': 0b01,
                    'landscape_left': 0b10,
                    'landscape_right': 0b11
                }))
            )),
            Register('RESOLUTION_RANGE', 0x0F, fields=(
                BitField('resolution', 0b00001100, adapter=LookupAdapter({
                    14: 0b00,
                    12: 0b01,
                    10: 0b10,
                    8: 0b11
                }, snap=False)),
                BitField('range', 0b00000011, adapter=LookupAdapter({
                    2: 0b00,
                    4: 0b01,
                    8: 0b10,
                    16: 0b11
                }, snap=False))
            )),
            Register('DISABLE_AXIS_ODR', 0x10, fields=(
                BitField('disable_x_axis', 0b10000000),
                BitField('disable_y_axis', 0b01000000),
                BitField('disable_z_axis', 0b00100000),
                BitField('output_data_rate', 0b00001111, adapter=LookupAdapter({
                    '1Hz': 0b0000,     # Not Available in Normal Mode
                    '1.95Hz': 0b0001,  # Not Available in Normal Mode
                    '3.9Hz': 0b0010,
                    '7.81Hz': 0b0011,
                    '15.63Hz': 0b0100,
                    '31.25Hz': 0b0101,
                    '62.5Hz': 0b0110,
                    '125Hz': 0b0111,
                    '250Hz': 0b1000,
                    '500Hz': 0b1001,   # Not Available in Low Power Mode
                    '1000Hz': 0b1010   # Not Available in Low Power Mode
                }))
            )),
            Register('POWER_MODE_BANDWIDTH', 0x11, fields=(
                BitField('power_mode', 0b11000000, adapter=LookupAdapter({
                    'normal': 0b00,
                    'low_power': 0b01,
                    'suspend': 0b10
                })),
                BitField('low_power_bandwidth', 0b00011110, adapter=LookupAdapter({
                    '1.95Hz': 0b0010,
                    '3.9Hz': 0b0011,
                    '7.81Hz': 0b0100,
                    '15.63Hz': 0b0101,
                    '31.25Hz': 0b0110,
                    '62.5Hz': 0b0111,
                    '125Hz': 0b1000,
                    '250Hz': 0b1001,
                    '500Hz': 0b1010
                }))
            )),
            Register('SWAP_POLARITY', 0x12, fields=(
                BitField('x_polariy', 0b00001000),
                BitField('y_polariy', 0b00000100),
                BitField('z_polariy', 0b00000010),
                BitField('x_z_swap', 0b00000001)
            )),
            Register('INTERRUPT_ENABLE', 0x16, fields=(
                BitField('enable', 0xFF),
                BitField('interrupts', 0xFF, adapter=InterruptLookupAdapter({
                    'orientation_interrupt': 0b01000000,
                    'single_tap_interrupt': 0b00100000,
                    'double_tap_interrupt': 0b00010000,
                    'z_active_interrupt': 0b00000100,
                    'y_active_interrupt': 0b00000010,
                    'x_active_interrupt': 0b00000001
                })),
            )),
            Register('INTERRUPT_ENABLE_1', 0x17, fields=(
                BitField('enable', 0xFF),
                BitField('interrupts', 0xFF, adapter=InterruptLookupAdapter({
                    'data_interrupt': 0b00010000,
                    'freefall_interrupt': 0b00001000
                })),
            )),
            Register('INT1_MAPPING_0', 0x19, fields=(
                BitField('map_orientation_int1', 0b01000000),
                BitField('map_single_tap_int1', 0b00100000),
                BitField('map_double_tap_int1', 0b00010000),
                BitField('map_active_int1', 0b00000100),
                BitField('map_freefall_int1', 0b00000001)
            )),
            Register('INT1_MAPPING_1', 0x1A, fields=(
                [BitField('map_new_data_int1', 0b00000001)]
            )),
            Register('INT1_OUTPUT_MODE', 0x20, fields=(
                BitField('mode', 0b00000010, adapter=LookupAdapter({
                    'push_pull': 0b0,
                    'open_drain': 0b1
                })),
                BitField('active_level', 0b00000010, adapter=LookupAdapter({
                    'low': 0b0,
                    'high': 0b1
                })),
            )),
            Register('INT1_LATCH', 0x21, fields=(
                BitField('latch_reset', 0b10000000),
                BitField('latch_setting', 0b00001111, adapter=LookupAdapter({
                    'non_latched': 0b0000,
                    'temp_latch_250ms': 0b0001,
                    'temp_latch_500ms': 0b0010,
                    'temp_latch_1s': 0b0011,
                    'temp_latch_2s': 0b0100,
                    'temp_latch_4s': 0b0101,
                    'temp_latch_8s': 0b0110,
                    'latched': 0b0111,
                    'non_latched_': 0b1000,
                    'temp_latch_1ms': 0b1001,
                    'temp_latch_1ms_': 0b1010,  # TODO allow LookupAdapter to use list value
                    'temp_latch_2ms': 0b1011,
                    'temp_latch_25ms': 0b1100,
                    'temp_latch_50ms': 0b1101,
                    'temp_latch_100ms': 0b1110,
                    'latched_': 0b1111
                }))
            )),
            Register('FREEFALL_DURATION', 0x22, fields=(
                BitField('duration', 0xFF),
            )),
            Register('FREEFALL_THRESHOLD', 0x23, fields=(
                BitField('threshold', 0xFF),
            )),
            Register('FREEFALL_HYSTERESIS', 0x24, fields=(
                BitField('mode', 0x00000100, adapter=LookupAdapter({
                    'single': 0b0,
                    'sum': 0b1
                })),
                BitField('hysteresis_time', 0b00000011)
            )),
            Register('ACTIVE_DURATION', 0x27, fields=(
                BitField('duration', 0b00000011),
            )),
            Register('ACTIVE_THRESHOLD', 0x21, fields=(
                BitField('threshold', 0xFF),
            )),
            Register('TAP_DURATION', 0x28, fields=(
                BitField('tap_quiet', 0x10000000, adapter=LookupAdapter({
                    '30ms': 0b0,
                    '20ms': 0b1
                })),
                BitField('tap_shock', 0x01000000, adapter=LookupAdapter({
                    '50ms': 0b0,
                    '70ms': 0b1
                })),
                BitField('double_tap_window', 0b00000111, adapter=LookupAdapter({
                    '50ms': 0b000,
                    '100ms': 0b001,
                    '150ms': 0b010,
                    '200ms': 0b011,
                    '250ms': 0b100,
                    '375ms': 0b101,
                    '500ms': 0b110,
                    '700ms': 0b111
                }))
            )),
            Register('TAP_THRESHOLD', 0x2B, fields=(
                [BitField('threshold', 0b00011111)]
            )),
            Register('ORIENTATION_HYSTERESIS', 0x2C, fields=(
                BitField('hysteresis', 0b01110000),  # set the hysteresis of the orientation interrupt, 1LSB is 62.5mg
                BitField('orientation_blocking', 0b00001100, adapter=LookupAdapter({
                    'non_blocking': 0b00,
                    'z_axis_blocking': 0b01,
                    'z_axis_any_0.2_slope_blocking': 0b10,
                    'non_blocking_': 0b11  # TODO LookupAdapter needs list value
                })),
                BitField('orientation_mode', 0b00000011, adapter=LookupAdapter({
                    'symmetrical': 0b00,
                    'high_asymmetrical': 0b01,
                    'low_asymmetrical': 0b10,
                    'symmetrical_': 0b11   # TODO LookupAdapter needs list value
                }))
            )),
            Register('Z_BLOCK', 0x2D, fields=(
                BitField('setting', 0b00001111),  # defines the block acc_z between 0g to 0.9375g
            )),
            Register('OFFSET', 0x38, fields=(
                BitField('x', 0x0000FF),          # the offset compensation value for X axis, 1LSB is 3.9mg
                BitField('y', 0x00FF00),          # the offset compensation value for Y axis, 1LSB is 3.9mg
                BitField('z', 0xFF0000),          # the offset compensation value for Z axis, 1LSB is 3.9mg
            ), bit_width=24)
        ))

        res_range = self._msa301.get('RESOLUTION_RANGE')
        self._resolution = res_range.resolution
        self._range = res_range.range