def __init__(
self,
name: str,
i2c_lock: threading.RLock,
bus: int,
address: int,
mux: Optional[int] = None,
channel: Optional[int] = None,
simulate: bool = False,
mux_simulator: Optional[MuxSimulator] = None,
Simulator: Optional[PeripheralSimulator] = None,
) -> None:
""" Initializes atlas driver. """
# Initialize parameters
self.simulate = simulate
# Initialize logger
logname = "Driver({})".format(name)
self.logger = Logger(logname, "peripherals")
# Initialize I2C
try:
self.i2c = I2C(
name=name,
i2c_lock=i2c_lock,
bus=bus,
address=address,
mux=mux,
channel=channel,
mux_simulator=mux_simulator,
PeripheralSimulator=Simulator,
)
except I2CError as e:
raise exceptions.InitError(logger=self.logger)
def __init__(
self,
name: str,
i2c_lock: threading.RLock,
) -> None:
"""Initializes ArduinoComms"""
# Initialize logger
logname = "ArduinoComms({})".format(name)
self.logger = Logger(logname, __name__)
self.bus = 2
self.address = 0x08
self.name = name
# Initialize I2C
try:
self.i2c = I2C(name="Arduino-{}".format(name),
i2c_lock=i2c_lock,
bus=self.bus,
address=self.address,
mux=None)
except I2CError as e:
raise exceptions.InitError(logger=self.logger) from e
def test_init():
i2c = I2C(
name="Test",
i2c_lock=threading.RLock(),
bus=2,
address=0x40,
mux=0x77,
channel=4,
mux_simulator=MuxSimulator(),
PeripheralSimulator=PeripheralSimulator,
)
def test_write_register():
i2c = I2C(
name="Test",
i2c_lock=threading.RLock(),
bus=2,
address=0x40,
mux=0x77,
channel=4,
mux_simulator=MuxSimulator(),
PeripheralSimulator=PeripheralSimulator,
)
i2c.write_register(0x01, 0x02)
def test_read_empty_register():
i2c = I2C(
name="Test",
i2c_lock=threading.RLock(),
bus=2,
address=0x40,
mux=0x77,
channel=4,
mux_simulator=MuxSimulator(),
PeripheralSimulator=PeripheralSimulator,
)
with pytest.raises(ReadError):
byte = i2c.read_register(0x01)
def test_write_unknown():
i2c = I2C(
name="Test",
i2c_lock=threading.RLock(),
bus=2,
address=0x40,
mux=0x77,
channel=4,
mux_simulator=MuxSimulator(),
PeripheralSimulator=PeripheralSimulator,
)
with pytest.raises(WriteError):
i2c.write([0x01])
def __init__(
self,
name: str,
i2c_lock: threading.RLock,
bus: int,
address: int,
mux: Optional[int] = None,
channel: Optional[int] = None,
simulate: bool = False,
mux_simulator: Optional[MuxSimulator] = None,
) -> None:
"""Initializes PCA9633."""
# Initialize logger
logname = "PCA9633({})".format(name)
self.logger = logger.Logger(logname, "peripherals")
# Initialize i2c lock
self.i2c_lock = i2c_lock
# Check if simulating
if simulate:
self.logger.info("Simulating driver")
Simulator = PCA9633Simulator
else:
Simulator = None
# Initialize driver parameters
self.name = name
# Initialize data bytes
self.data_bytes = [
0x80, 0x80, 0x21, 0x00, 0x00, 0x00, 0x40, 0x80, 0x02, 0xEA
]
# Initialize I2C
try:
self.i2c = I2C(
name="PCA9633-{}".format(name),
i2c_lock=i2c_lock,
bus=bus,
address=address,
mux=mux,
channel=channel,
mux_simulator=mux_simulator,
PeripheralSimulator=Simulator,
)
self.i2c.write(bytes(self.data_bytes), disable_mux=True)
except I2CError as e:
raise exceptions.InitError(logger=self.logger) from e
def test_read_empty():
i2c = I2C(
name="Test",
i2c_lock=threading.RLock(),
bus=2,
address=0x40,
mux=0x77,
channel=4,
mux_simulator=MuxSimulator(),
PeripheralSimulator=PeripheralSimulator,
)
bytes_ = i2c.read(2)
assert bytes_[0] == 0x00
assert bytes_[1] == 0x00
def __init__(
self,
name: str,
i2c_lock: threading.RLock,
bus: int,
address: int,
mux: Optional[int] = None,
channel: Optional[int] = None,
simulate: bool = False,
mux_simulator: Optional[MuxSimulator] = None,
) -> None:
"""Initializes driver."""
# Initialize logger
logname = "ADT7470({})".format(name)
self.logger = logger.Logger(logname, "peripherals")
# Initialize i2c lock
self.i2c_lock = i2c_lock
# Check if simulating
if simulate:
self.logger.info("Simulating driver")
Simulator = PCA9633Simulator
else:
Simulator = None
# Initialize driver parameters
self.name = name
# Initialize I2C
try:
self.i2c = I2C(
name="ADT7470-{}".format(name),
i2c_lock=i2c_lock,
bus=bus,
address=address,
mux=mux,
channel=channel,
mux_simulator=mux_simulator,
PeripheralSimulator=Simulator,
)
self.hardware_version = self.read_version()
except I2CError as e:
raise exceptions.InitError(logger=self.logger) from e
def test_read_custom_register():
class CustomPeripheralSimulator(PeripheralSimulator):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.registers = {0xE7: 0x00}
i2c = I2C(
name="Test",
i2c_lock=threading.RLock(),
bus=2,
address=0x40,
mux=0x77,
channel=4,
mux_simulator=MuxSimulator(),
PeripheralSimulator=CustomPeripheralSimulator,
)
assert i2c.read_register(0xE7) == 0x00
def __init__(
self,
bus: int = 0,
address: int = PCA9632_I2C_ADDRESS,
mux: Optional[int] = None,
channel: Optional[int] = None,
simulate: bool = False,
mux_simulator: Optional[MuxSimulator] = None,
) -> None:
"""Initializes Grove RGB LCD."""
# Initialize logger
self.logger = Logger('LED', __name__)
# Check if simulating
if simulate:
self.logger.info("Simulating LED")
# Initialize I2C
try:
self.i2c = I2C(
name="LED",
i2c_lock=threading.RLock(),
bus=bus,
address=address,
mux=mux,
channel=channel,
mux_simulator=mux_simulator,
PeripheralSimulator=None,
)
except I2CError as e:
raise LEDError(logger=self.logger) from e
# Initialize the LED
try:
self.init_data = [
0x80, 0x80, 0x21, 0x00, 0x00, 0x00, 0x40, 0x80, 0x02, 0xEA
]
# init and clear any LED values
self.i2c.write(bytes(self.init_data))
except I2CError as e:
raise LEDError(logger=self.logger) from e
def __init__(
self,
name: str,
i2c_lock: threading.RLock,
bus: int,
address: int,
mux: Optional[int] = None,
channel: Optional[int] = None,
simulate: bool = False,
mux_simulator: Optional[MuxSimulator] = None,
) -> None:
# Initialize simulation mode
self.simulate = simulate
# Initialize logger
logname = "Driver({})".format(name)
self.logger = logger.Logger(logname, "peripherals")
self.logger.info("Initializing driver")
# Initialize i2c lock
self.i2c_lock = i2c_lock
# Check if simulating
if simulate:
self.logger.info("Simulating driver")
Simulator = simulator.CCS811Simulator
else:
Simulator = None
# Initialize I2C
try:
self.i2c = I2C(
name=name,
i2c_lock=i2c_lock,
bus=bus,
address=address,
mux=mux,
channel=channel,
mux_simulator=mux_simulator,
PeripheralSimulator=Simulator,
)
except I2CError as e:
raise exceptions.InitError(logger=self.logger) from e
def test_write_read():
class CustomPeripheralSimulator(PeripheralSimulator):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.writes = {byte_str(bytes([0x01])): bytes([0x02])}
i2c = I2C(
name="Test",
i2c_lock=threading.RLock(),
bus=2,
address=0x40,
mux=0x77,
channel=4,
mux_simulator=MuxSimulator(),
PeripheralSimulator=CustomPeripheralSimulator,
)
i2c.write(bytes([0x01]))
bytes_ = i2c.read(1)
assert bytes_[0] == 0x02
def __init__(
self,
name: str,
i2c_lock: threading.RLock,
bus: int,
address: int,
mux: Optional[int] = None,
channel: Optional[int] = None,
simulate: Optional[bool] = False,
mux_simulator: Optional[MuxSimulator] = None,
) -> None:
"""Initializes driver."""
# Initialize logger
logname = "Driver({})".format(name)
self.logger = logger.Logger(logname, "peripherals")
# Check if simulating
if simulate:
self.logger.info("Simulating driver")
Simulator = simulator.SHT25Simulator
else:
Simulator = None
# Initialize I2C
try:
self.i2c = I2C(
name=name,
i2c_lock=i2c_lock,
bus=bus,
address=address,
mux=mux,
channel=channel,
mux_simulator=mux_simulator,
PeripheralSimulator=Simulator,
verify_device=
False, # need to write before device responds to read
)
self.i2c_lock = i2c_lock
self.read_user_register(retry=True)
except I2CError as e:
raise exceptions.InitError(logger=self.logger) from e
def __init__(
self,
name: str,
i2c_lock: threading.RLock,
bus: int,
address: int,
mux: Optional[int] = None,
channel: Optional[int] = None,
simulate: Optional[bool] = False,
mux_simulator: Optional[MuxSimulator] = None,
) -> None:
"""Initializes t6713 driver."""
# Initialize parameters
self.simulate = simulate
self.i2c_lock = i2c_lock
# Initialize logger
logname = "Driver({})".format(name)
self.logger = logger.Logger(logname, "device")
# Check if simulating
if simulate:
self.logger.info("Simulating driver")
Simulator = simulator.T6713Simulator
else:
Simulator = None
# Initialize I2C
try:
self.i2c = I2C(
name=name,
i2c_lock=i2c_lock,
bus=bus,
address=address,
mux=mux,
channel=channel,
mux_simulator=mux_simulator,
PeripheralSimulator=Simulator,
)
except I2CError as e:
raise exceptions.InitError(logger=self.logger) from e
def __init__(
self,
name: str,
i2c_lock: threading.RLock,
bus: int,
address: int,
mux: Optional[int] = None,
channel: Optional[int] = None,
simulate: bool = False,
mux_simulator: Optional[MuxSimulator] = None,
) -> None:
"""Initializes DAC5578."""
# Initialize logger
logname = "DAC5578-({})".format(name)
self.logger = Logger(logname, __name__)
# Check if simulating
if simulate:
self.logger.info("Simulating driver")
Simulator = DAC5578Simulator
else:
Simulator = None
# Initialize I2C
try:
self.i2c = I2C(
name="DAC5578-{}".format(name),
i2c_lock=i2c_lock,
bus=bus,
address=address,
mux=mux,
channel=channel,
mux_simulator=mux_simulator,
PeripheralSimulator=Simulator,
)
except I2CError as e:
raise exceptions.InitError(logger=self.logger) from e
def __init__(
self,
name: str,
i2c_lock: threading.RLock,
bus: int,
rgb_address: int = RGB_ADDRESS,
lcd_address: int = LCD_ADDRESS,
mux: Optional[int] = None,
channel: Optional[int] = None,
simulate: bool = False,
mux_simulator: Optional[MuxSimulator] = None,
) -> None:
"""Initializes Grove RGB LCD."""
# Initialize logger
logname = "GroveRGBLCD({})".format(name)
self.logger = Logger(logname, __name__)
# Check if simulating
if simulate:
self.logger.info("Simulating driver")
Simulator = simulator.GroveRGBLCDSimulator
else:
Simulator = None
# Initialize I2C
try:
self.i2c_rgb = I2C(
name="RGB-{}".format(name),
i2c_lock=i2c_lock,
bus=bus,
address=rgb_address,
mux=mux,
channel=channel,
mux_simulator=mux_simulator,
PeripheralSimulator=Simulator,
)
self.i2c_lcd = I2C(
name="LCD-{}".format(name),
i2c_lock=i2c_lock,
bus=bus,
address=lcd_address,
mux=mux,
channel=channel,
mux_simulator=mux_simulator,
PeripheralSimulator=Simulator,
)
except I2CError as e:
raise exceptions.InitError(logger=self.logger) from e
# Initialize the display
try:
# command: clear display
self.i2c_lcd.write(bytes([self.CMD, self.CLEAR]))
time.sleep(0.05) # Wait for lcd to process
# command: display on, no cursor
self.i2c_lcd.write(bytes([self.CMD, self.DISPLAY_ON_NO_CURSOR]))
# command: 2 lines
self.i2c_lcd.write(bytes([self.CMD, self.TWO_LINES]))
time.sleep(0.05) # Wait for lcd to process
except I2CError as e:
raise exceptions.DriverError(logger=self.logger) from e
