def test_get_register():
bus = MockSMBus(1)
bus.regs[0:3] = [0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF]
device = Device([0x00, 0x01],
i2c_dev=bus,
registers=(
Register('test24',
0x00,
fields=(BitField('test', 0xFFF), ),
bit_width=24),
Register('test32',
0x00,
fields=(BitField('test', 0xFFF), ),
bit_width=32),
Register('test48',
0x00,
fields=(BitField('test', 0xFFF), ),
bit_width=48),
))
assert device.get_register('test24') == 0xAABBCC
assert device.get_register('test32') == 0xAABBCCDD
assert device.get_register('test48') == 0xAABBCCDDEEFF
def __init__(self, i2c_bus):
MockSMBus.__init__(self, i2c_bus)
self.regs[0x86] = 0x09 << 4 # Fake part number
self.regs[0x86] |= 0x02 # Fake revision
self.regs[0x87] = 0x05 # Fake manufacturer ID
self.regs[0x88:0x8C] = [0xff, 0xff, 0xff, 0xff] # ALS CH0 & CH1
self.regs[0x8C] = 0xff # ALS / PS Status
self.regs[0x8D] = 0xf0 # Proximity Data (240)
def __init__(self, i2c_bus):
"""Initialise device mock.
:param i2c_bus: i2c bus ID
"""
MockSMBus.__init__(self, i2c_bus)
self.regs[0x40] = 0b001011 # Fake part number
self.regs[0x92] = 0xE0 # Fake manufacturer ID
colour_data = struct.pack('<HHHH', *BH1745_COLOUR_DATA)
colour_data = [ord(x) if type(x) is str else x for x in colour_data]
self.regs[0x50:0x50 + 8] = list(colour_data)
def test_alarm_hours_24():
import rv3028
device = rv3028.RV3028(i2c_dev=MockSMBus(1, default_registers={
0x08: 0b00100001, # 21 hours
}))
assert device.get_alarm_time().hour == 21
def test_invalid_time_source():
import rv3028
device = rv3028.RV3028(i2c_dev=MockSMBus(1))
with pytest.raises(TypeError):
device.set_alarm_time(None)
with pytest.raises(TypeError):
device.set_alarm_time(None, weekday=1)
def test_register_locking():
bus = MockSMBus(1)
device = Device(0x00,
i2c_dev=bus,
registers=(Register('test',
0x00,
fields=(BitField('test', 0xFF), )), ))
device.test.set_test(77)
device.lock_register('test')
bus.regs[0] = 11
assert device.test.get_test() == 77
device.unlock_register('test')
assert device.test.get_test() == 11
def test_setup_timeout():
from max30105 import MAX30105
max30105 = MAX30105(
i2c_dev=MockSMBus(1, default_registers={0x09: 0b00000111}))
with pytest.raises(RuntimeError):
max30105.setup(timeout=0.5)
def test_unix_time_lsb():
import rv3028
device = rv3028.RV3028(i2c_dev=MockSMBus(1, default_registers={
0x1b: 0xff # Bits 0-7 of UNIX_TIME
}))
assert device.get_unix_time() == 0xff
def test_alert_flags():
import mcp9600
smbus = MockSMBus(1, default_registers={
0x04: 0b00000101,
0x20: 0x40})
device = mcp9600.MCP9600(i2c_dev=smbus)
assert device.check_alerts() == (1, 0, 1, 0)
def test_get_cold_junction_temperature():
import mcp9600
smbus = MockSMBus(1, default_registers={
0x02: 1,
0x03: 96,
0x20: 0x40})
device = mcp9600.MCP9600(i2c_dev=smbus)
assert round(device.get_cold_junction_temperature(), 1) == 22.0
def test_alert_clear():
import mcp9600
smbus = MockSMBus(1, default_registers={0x04: 0b00000101, 0x20: 0x40})
device = mcp9600.MCP9600(i2c_dev=smbus)
device.clear_alert(1)
assert smbus.regs[0x08] & 0b10000000 == 0b10000000
def test_get_hot_junction_temperature():
# Test the junction read and conversion formula
import mcp9600
smbus = MockSMBus(1, default_registers={
0x00: 1,
0x01: 96,
0x20: 0x40})
device = mcp9600.MCP9600(i2c_dev=smbus)
assert round(device.get_hot_junction_temperature(), 1) == 22.0
def test_get_thermocouple_type():
import mcp9600
smbus = MockSMBus(1, default_registers={
0x04: 0b00000101,
0x05: 0b00110000,
0x20: 0x40})
device = mcp9600.MCP9600(i2c_dev=smbus)
assert device.get_thermocouple_type() == 'N'
def test_timer_status():
import rv3028
device = rv3028.RV3028(i2c_dev=MockSMBus(
1,
default_registers={
0x0c: 0xff, # Bits 0-7 of TIMER_STATUS,
0x0d: 0x0f # Bits 11-8 of TIMER_STATUS
}))
assert device.get_periodic_timer_countdown_status() == 0xfff
def test_timer_value():
import rv3028
device = rv3028.RV3028(i2c_dev=MockSMBus(
1,
default_registers={
0x0a: 0xff, # Bits 0-7 of TIMER_VALUE,
0x0b: 0x0f # Bits 11-8 of TIMER_VVALUE
}))
assert device.get_periodic_timer_countdown_value() == 0xfff
def test_set_thermocouple_type():
import mcp9600
smbus = MockSMBus(1, default_registers={
0x04: 0b00000101,
0x05: 0b00000000,
0x20: 0x40})
device = mcp9600.MCP9600(i2c_dev=smbus)
device.set_thermocouple_type('N')
assert (smbus.regs[0x05] >> 4) & 0b111 == 0b011
def test_set_regs():
bus = MockSMBus(1)
device = Device(0x00,
i2c_dev=bus,
registers=(Register('test',
0x00,
fields=(BitField('test', 0xFF), )), ))
device.set('test', test=123)
assert device.get('test').test == 123
assert bus.regs[0] == 123
def test_get_set_field_overflow():
bus = MockSMBus(1)
device = Device([0x00, 0x01],
i2c_dev=bus,
registers=(Register('test',
0x00,
fields=(BitField('test', 0xFF), )), ))
device.set_field('test', 'test', 9999999)
assert device.get_field('test', 'test') == 127
assert bus.regs[0] == 127
def __init__(self, i2c_bus):
"""Initialise the class.
:param i2c_bus: i2c bus ID.
"""
MockSMBus.__init__(self, i2c_bus)
self.status = 0b01 # Fake status register
self.ptr = None # Fake register pointer
# Virtual registers, thes contain the data actually used
self.regs[0x00] = 0x88 # Fake HW type
self.regs[0x01] = 0x77 # Fake HW version
self.regs[0x02] = 0xFE # Fake FW version MSB (Sub, Minor)
self.regs[0x03] = 0xFF # Fake FW version LSB (Minor, Major)
self.regs[0x04] = 0x02 # Control Register
# Prime the Calibrated Data registers with fake data
self.regs[0x14:24] = [
ord(c) if type(c) is str else c
for c in struct.pack('>ffffff', *reversed(CALIBRATED_VALUES))
]
def test_time_and_date():
t = datetime.time(12, 39, 7)
d = datetime.date(2020, 2, 29)
smbus = MockSMBus(1)
import rv3028
device = rv3028.RV3028(i2c_dev=smbus)
device.set_time(t)
device.set_date(d)
assert device.get_time() == t
assert device.get_date() == d
assert smbus.regs[0x02] == 0b00010010
assert smbus.regs[0x05] == 0b00000010
assert smbus.regs[
0x06] == 0b00100000 # 2020, but we have a year offset of +2000 internally so the BCD value is just 20
def test_address_select():
bus = MockSMBus(1)
device = Device([0x00, 0x01],
i2c_dev=bus,
registers=(Register('test',
0x00,
fields=(BitField('test', 0xFF), )), ))
assert device.get_addresses() == [0x00, 0x01]
assert device.select_address(0x01) is True
with pytest.raises(ValueError):
device.select_address(0x02)
assert device.next_address() == 0x00
assert device.next_address() == 0x01
def test_missing_regiser():
bus = MockSMBus(1)
device = Device(
[0x00, 0x01],
i2c_dev=bus,
registers=(
Register(
'test',
0x00,
fields=(
BitFlag('test', 6), # Sixth bit from the right
)), ))
with pytest.raises(KeyError):
device.get_register('foo')
def test_adapters():
bus = MockSMBus(1)
device = Device(0x00,
i2c_dev=bus,
registers=(Register(
'adapter',
0x01,
fields=(BitField('test',
0xFFFF,
adapter=U16ByteSwapAdapter()), )), ))
device.adapter.set_test(0xFF00)
assert device.adapter.get_test() == 0xFF00
assert bus.regs[0:2] == [0x00, 0xFF]
def test_field_name_in_adapter_error():
bus = MockSMBus(1)
device = Device(0x00,
i2c_dev=bus,
registers=(Register('test',
0x00,
fields=(BitField('test',
0xFF00,
adapter=LookupAdapter(
{'x': 1})), ),
bit_width=16), ))
with pytest.raises(ValueError) as e:
reg = device.get('test')
assert 'test' in e
del reg
def test_get_regs():
bus = MockSMBus(1)
device = Device(0x00,
i2c_dev=bus,
registers=(Register('test',
0x00,
fields=(
BitField('test', 0xFF00),
BitField('monkey', 0x00FF),
),
bit_width=16), ))
device.set('test', test=0x66, monkey=0x77)
reg = device.get('test')
reg.test == 0x66
reg.monkey == 0x77
assert bus.regs[0] == 0x66
assert bus.regs[1] == 0x77
def test_bitflag():
bus = MockSMBus(1)
device = Device(
[0x00, 0x01],
i2c_dev=bus,
registers=(
Register(
'test',
0x00,
fields=(
BitFlag('test', 6), # Sixth bit from the right
)), ))
device.test.set_test(True)
assert bus.regs[0] == 0b01000000
device.test.set_test(False)
assert bus.regs[0] == 0b00000000
def test_alert_configure():
import mcp9600
smbus = MockSMBus(1, default_registers={0x04: 0b00000101, 0x20: 0x40})
device = mcp9600.MCP9600(i2c_dev=smbus)
device.configure_alert(
1,
limit=25.25, # Test to 1/4th degree precision
hysteresis=0x99,
clear_interrupt=True,
monitor_junction=0,
rise_fall=1,
state=1,
mode=1,
enable=True)
assert smbus.regs[0x10:0x12] == [1, 148]
assert smbus.regs[0x0C] == 0x99
assert device.get_alert_hysteresis(1) == 0x99
assert device.get_alert_limit(1) == 25.25
def test_register_proxy():
bus = MockSMBus(1)
device = Device(0x00,
i2c_dev=bus,
registers=(Register('test',
0x00,
fields=(BitField('test', 0xFF), )), ))
device.test.set_test(123)
assert device.test.get_test() == 123
assert bus.regs[0] == 123
with device.test as test:
test.set_test(77)
test.write()
assert device.test.get_test() == 77
assert bus.regs[0] == 77
assert device.test.read() == 77
def test_register_proxy():
"""This API pattern has been depricated in favour of set/get."""
bus = MockSMBus(1)
device = Device(0x00, i2c_dev=bus, registers=(
Register('test', 0x00, fields=(
BitField('test', 0xFF),
)),
))
device.test.set_test(123)
assert device.test.get_test() == 123
assert bus.regs[0] == 123
with device.test as test:
test.set_test(77)
test.write()
assert device.test.get_test() == 77
assert bus.regs[0] == 77
assert device.test.read() == 77
"""
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,
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))),
