def test_i2c_sensorXYZ_value(self, mock_robot_init, caplog):
robot = BaseRobot(**mock_robot_init['i2crobot'])
robot.start()
s = robot.sensors['gyro']
d = robot.devices['imu']
exp_x = - d.word_g_x.value
exp_y = d.word_g_y.value + 256
exp_z = - d.word_g_z.value + 1024
assert s.x == exp_x
assert s.y == exp_y
assert s.z == exp_z
assert s.value == (exp_x, exp_y, exp_z)
# byte sensor
s = robot.sensors['accel_byte']
exp_x = d.byte_xl_x.value + 128
exp_y = - d.byte_xl_y.value -128
exp_z = d.byte_xl_z.value + 64
assert s.x == exp_x
assert s.y == exp_y
assert s.z == exp_z
assert s.value == (exp_x, exp_y, exp_z)
assert s.active
# activate w/o register
caplog.clear()
s.active = True
assert len(caplog.records) == 1
assert 'attempted to change activation of sensor' in caplog.text
def test_i2c_sensor(self, mock_robot_init, caplog):
robot = BaseRobot(**mock_robot_init['i2crobot'])
robot.start()
s = robot.sensors['temp']
d = robot.devices['imu']
assert s.device == d
assert s.read_register == d.temp
assert s.activate_register == d.activate_temp
assert not s.active
# removed the masking in sensor
# assert s.bits is None
assert s.offset == 0
assert s.inverse
assert s.auto_activate
s.active = True
assert s.active
assert s.value == -10.0
# masks
assert robot.sensors['status0'].value
assert not robot.sensors['status1'].value
# setting active for register w/o active register
caplog.clear()
robot.sensors['status0'].active = True
assert len(caplog.records) == 1
assert 'attempted to change activation of sensor' in caplog.text
def test_i2c_write2_with_errors(self, mock_robot_init, caplog):
robot = BaseRobot(**mock_robot_init['i2crobot'])
robot.start()
device = robot.devices['imu']
for _ in range(20): # so that we also get some errors
device.word_control_2.value = 0x2121
assert device.word_control_2.value == 0x2121
def test_dynamixel_bus_closed(self, mock_robot_init, caplog):
robot = BaseRobot(**mock_robot_init['dynamixel'])
bus = robot.buses['ttys1']
# ping
caplog.clear()
bus.ping(11)
assert len(caplog.records) == 1
assert 'Ping invoked with a bus not opened' in caplog.text
# scan
caplog.clear()
bus.scan(range(10))
assert len(caplog.records) == 1
assert 'Scan invoked with a bus not opened' in caplog.text
# read
dev = robot.devices['d11']
caplog.clear()
bus.read(dev.return_delay_time)
assert len(caplog.records) == 1
assert 'Attempt to use closed bus "ttys1"' in caplog.text
# write
caplog.clear()
bus.write(dev.return_delay_time, 10)
assert len(caplog.records) == 1
assert 'Attempt to use closed bus "ttys1"' in caplog.text
robot.stop()
def test_dynamixel_register_4Bytes(self, mock_robot_init):
robot = BaseRobot(**mock_robot_init['dynamixel'])
robot.start()
dev = robot.devices['d11']
register = BaseRegister(name='test', device=dev, address=150, size=4,
access='RW')
register.value = 100
assert register.value == 100
def test_incomplete_robot(self, caplog):
# we now allow creating robots with no buses
caplog.clear()
_ = BaseRobot.from_yaml('tests/no_buses.yml')
# we now allow creating robots with no devices
caplog.clear()
_ = BaseRobot.from_yaml('tests/no_devices.yml')
caplog.clear()
_ = BaseRobot.from_yaml('tests/dummy_robot.yml')
assert 'Only the first robot will be considered' in caplog.text
def test_register_with_dynamic_conversion(self, mock_robot_init):
mock_robot_init['i2crobot']['buses']['i2c2']['err'] = 0
robot = BaseRobot(**mock_robot_init['i2crobot'])
robot.start()
d = robot.devices['imu']
# set the control register
d.range_control.value = 0b110000
assert d.range_control_conv.value == 3
assert d.dynamic_register.value == 1024.0 / 10.0 * 3.0
d.range_control_conv.value = 6
assert d.range_control.value == 0b1100000
assert d.dynamic_register.value == 1024.0 / 10.0 * 6.0
def test_protocol1_bulkwrite(self, mock_robot_init):
mock_robot_init['dynamixel']['buses']['ttys1']['protocol'] = 1.0
# we remove the bulkwrite so that the error will refer to syncread
del mock_robot_init['dynamixel']['syncs']['syncread']
with pytest.raises(ValueError) as excinfo:
_ = BaseRobot(**mock_robot_init['dynamixel'])
assert 'BulkWrite only supported for Dynamixel Protocol 2.0' \
in str(excinfo.value)
def test_i2c_robot_bus_error(self, mock_robot_init, caplog):
mock_robot_init['i2crobot']['buses']['i2c2']['mock'] = False
mock_robot_init['i2crobot']['buses']['i2c2']['auto'] = False
mock_robot_init['i2crobot']['buses']['i2c2']['port'] = 42
robot = BaseRobot(**mock_robot_init['i2crobot'])
caplog.clear()
robot.buses['i2c2'].open()
assert len(caplog.records) >= 2
assert 'failed to open I2C bus' in caplog.text
def test_robot_from_yaml(self, mock_robot):
mock_robot.stop() # to avoid conflicts on the bus
new_robot = BaseRobot.from_yaml('tests/dummy_robot.yml')
new_robot.start()
new_robot.syncs['write'].start()
time.sleep(2) # for loops to run
new_robot.stop()
mock_robot.start() # restart for other cases
assert mock_robot.name == 'dummy'
def test_i2c_register_with_sign(self, mock_robot_init):
robot = BaseRobot(**mock_robot_init['i2crobot'])
robot.start()
d = robot.devices['imu']
# no factor
d.word_xl_x.value = 10
assert d.word_xl_x.value == 10
assert d.word_xl_x.int_value == 10
d.word_xl_x.value = -10
assert d.word_xl_x.value == -10
assert d.word_xl_x.int_value == (65536 - 10)
# with factor
d.word_xl_y.value = 100
assert d.word_xl_y.value == 100
assert d.word_xl_y.int_value == 1000
d.word_xl_y.value = -100
assert d.word_xl_y.value == -100
assert d.word_xl_y.int_value == (65536 - 1000)
def test_i2c_loop_failed_acquire(self, mock_robot_init, caplog):
robot = BaseRobot(**mock_robot_init['i2crobot'])
robot.start()
# lock the bus
robot.buses['i2c2'].can_use()
# read
caplog.clear()
robot.syncs['read_g'].start()
time.sleep(1)
assert len(caplog.records) >= 1
assert 'failed to acquire bus' in caplog.text
robot.syncs['read_g'].stop()
# write
caplog.clear()
robot.syncs['write_xl'].start()
time.sleep(1)
assert len(caplog.records) >= 1
assert 'failed to acquire bus' in caplog.text
robot.syncs['read_g'].stop()
def test_manual_device(self, caplog):
rob = BaseRobot()
bus = SharedFileBus(name='busA', port='/tmp/busA.log')
rob.add_bus(bus)
dev = BaseDevice(name='dev1', bus=bus, dev_id=42, model='DUMMY')
rob.add_device(dev)
assert len(rob.devices) == 1
bus.open()
# re-add
caplog.clear()
rob.add_device(dev)
assert len(caplog.records) == 1
assert len(rob.devices) == 1
def test_i2c_sensorXYZ(self, mock_robot_init):
robot = BaseRobot(**mock_robot_init['i2crobot'])
robot.start()
s = robot.sensors['gyro']
d = robot.devices['imu']
assert s.device == d
assert s.x_register == d. word_g_x
assert s.y_register == d. word_g_y
assert s.z_register == d. word_g_z
assert s.activate_register == d.activate_g
assert not s.active
assert s.x_offset == 0
assert s.x_inverse
assert s.y_offset == 256
assert not s.y_inverse
assert s.z_offset == 1024
assert s.z_inverse
assert s.auto_activate
s.active = True
assert s.active
def test_dynamixel_scan(self, mock_robot_init):
robot = BaseRobot(**mock_robot_init['dynamixel'])
robot.start()
ids = robot.buses['ttys1'].scan()
assert 11 in ids
assert 12 in ids
robot.stop()
def test_open_device_with_sync_items(self, mock_robot_init):
robot = BaseRobot(**mock_robot_init['dynamixel'])
robot.start()
dev = robot.devices['d11']
dev.present_position_deg.sync = True
dev.open()
robot.stop()
def test_i2c_bus_closed(self, mock_robot_init, caplog):
robot = BaseRobot(**mock_robot_init['i2crobot'])
dev = robot.devices['imu']
# write to closed bus
caplog.clear()
dev.byte_xl_x.value = 20
assert len(caplog.records) >= 1
assert 'attempted to write to a closed bus' in caplog.text
# read from closed bus
caplog.clear()
_ = dev.byte_xl_x.value
assert len(caplog.records) >= 1
assert 'attempted to read from a closed bus' in caplog.text
def test_dynamixel_register_low_endian(self, mock_robot_init, caplog):
robot = BaseRobot(**mock_robot_init['dynamixel'])
dev = robot.devices['d11']
assert dev.register_low_endian(123, 4) == [123, 0, 0, 0]
num = 12 * 256 + 42
assert dev.register_low_endian(num, 4) == [42, 12, 0, 0]
num = 39 * 65536 + 12 * 256 + 42
assert dev.register_low_endian(num, 4) == [42, 12, 39, 0]
num = 45 * 16777216 + 39 * 65536 + 12 * 256 + 42
assert dev.register_low_endian(num, 4) == [42, 12, 39, 45]
caplog.clear()
_ = dev.register_low_endian(num, 6)
assert len(caplog.records) == 1
assert 'Unexpected register size' in caplog.text
def test_i2c_sharedbus_closed(self, mock_robot_init, caplog):
robot = BaseRobot(**mock_robot_init['i2crobot'])
# we haven't started the bus
# read
caplog.clear()
robot.syncs['read_g'].start()
assert len(caplog.records) == 1
assert 'attempt to start with a bus not open' in caplog.text
robot.syncs['read_g'].stop()
# write
caplog.clear()
robot.syncs['write_xl'].start()
assert len(caplog.records) == 1
assert 'attempt to start with a bus not open' in caplog.text
robot.syncs['read_g'].stop()
def test_dynamixel_write(self, mock_robot_init):
robot = BaseRobot(**mock_robot_init['dynamixel'])
robot.start()
dev = robot.devices['d11']
for _ in range(100): # so that we also hit some comm errors
dev.temperature_limit.value = 85
assert dev.temperature_limit.value == 85
dev.cw_angle_limit_deg.value = 10
assert (dev.cw_angle_limit_deg.value - 10) < 0.2
robot.stop()
def test_manual_bus(self, caplog):
rob = BaseRobot()
bus = SharedFileBus(name='busA', port='/tmp/busA.log')
rob.add_bus(bus)
assert len(rob.buses) == 1
bus.open()
# re-add
caplog.clear()
rob.add_bus(bus)
assert len(caplog.records) == 1
assert len(rob.buses) == 1
def test_i2c_robot(self, mock_robot_init, caplog):
robot = BaseRobot(**mock_robot_init['i2crobot'])
robot.start()
dev = robot.devices['imu']
# 1 Byte registers
for _ in range(5): # to account for possible comm errs
dev.byte_xl_x.value = 20
assert dev.byte_xl_x.value == 20
# word register
dev.word_xl_x.value = 12345
assert dev.word_xl_x.value == 12345
robot.stop()
def test_dynamixel_bus_acquire_bulkread(self, mock_robot_init, caplog):
# syncs
robot = BaseRobot(**mock_robot_init['dynamixel'])
robot.start()
robot.buses['ttys1'].can_use() # lock the bus
caplog.clear()
robot.syncs['bulkread'].start()
time.sleep(1)
assert len(caplog.records) >= 1
assert 'failed to acquire bus ttys1' in caplog.text
robot.syncs['bulkread'].stop()
# release bus
robot.buses['ttys1'].stop_using()
robot.stop()
def test_i2c_closed_bus(self, mock_robot_init, caplog):
robot = BaseRobot(**mock_robot_init['i2crobot'])
device = robot.devices['imu']
caplog.clear()
_ = device.word_control_2.value
assert len(caplog.records) >= 1
assert 'attempted to read from a closed bus' in caplog.text
caplog.clear()
device.word_control_2.value = 0x4242
assert len(caplog.records) >= 1
assert 'attempted to write to a closed bus' in caplog.text
bus = robot.buses['i2c2']
caplog.clear()
_ = bus.read_block(device, 1, 6)
assert len(caplog.records) >= 1
assert 'attempted to read from a closed bus' in caplog.text
caplog.clear()
bus.write_block(device, 1, [1,2,3,4,5,6])
assert len(caplog.records) >= 1
assert 'attempted to write to a closed bus' in caplog.text
def test_dynamixel_bus_acquire(self, mock_robot_init, caplog):
robot = BaseRobot(**mock_robot_init['dynamixel'])
robot.start()
dev = robot.devices['d11']
bus = robot.buses['ttys1']
bus.can_use() # lock the bus
# read
caplog.clear()
bus.read(dev.return_delay_time)
assert len(caplog.records) >= 1
assert 'failed to acquire bus ttys1' in caplog.text
# write
caplog.clear()
bus.write(dev.return_delay_time, 10)
assert len(caplog.records) >= 1
assert 'failed to acquire bus ttys1' in caplog.text
# release bus
bus.stop_using()
robot.stop()
def test_dynamixel_bus_params(self, mock_robot_init):
robot = BaseRobot(**mock_robot_init['dynamixel'])
assert robot.buses['ttys1'].baudrate == 19200
assert not robot.buses['ttys1'].rs485
robot.stop()
def mock_robot(self):
robot = BaseRobot.from_yaml('tests/dummy_robot.yml')
robot.start()
yield robot
robot.stop()
def test_dynamixel_bulkwrite(self, mock_robot_init):
robot = BaseRobot(**mock_robot_init['dynamixel'])
robot.start()
robot.syncs['bulkwrite'].start()
time.sleep(1)
robot.stop()
def test_dynamixel_rangeread(self, mock_robot_init):
robot = BaseRobot(**mock_robot_init['dynamixel'])
robot.start()
robot.syncs['rangeread'].start()
time.sleep(1)
robot.stop()
def test_dynamixel_ping(self, mock_robot_init):
robot = BaseRobot(**mock_robot_init['dynamixel'])
robot.start()
assert robot.buses['ttys1'].ping(11) == True
robot.stop()