def setUp(self):
self.robot = Robot()
self.robot.connect()
self.trash = containers_load(self.robot, 'point', 'A1', 'trash')
self.tiprack = containers_load(self.robot, 'tiprack-200ul', 'B2',
'p200-rack')
self.trough = containers_load(self.robot, 'trough-12row', 'B2',
'trough')
self.plate = containers_load(self.robot, '96-flat', 'A2', 'magbead')
self.p200 = pipette.Pipette(
self.robot,
name="p200",
trash_container=self.trash,
tip_racks=[self.tiprack],
min_volume=10, # These are variable
axis="b",
channels=1)
self.p1000 = pipette.Pipette(
self.robot,
name="p1000",
trash_container=self.trash,
tip_racks=[self.tiprack],
min_volume=100, # These are variable
axis="a",
channels=1)
def setUp(self):
self.robot = Robot()
self.robot.home()
self.trash = containers_load(self.robot, 'point', '1')
self.tiprack1 = containers_load(self.robot, 'tiprack-10ul', '5')
self.tiprack2 = containers_load(self.robot, 'tiprack-10ul', '8')
self.plate = containers_load(self.robot, '96-flat', '4')
self.p200 = Pipette(
self.robot,
ul_per_mm=18.5,
trash_container=self.trash,
tip_racks=[self.tiprack1, self.tiprack2],
min_volume=10, # These are variable
mount='left',
channels=1,
name='other-pipette-for-transfer-tests'
)
self.p200.max_volume = 200
self.p200.reset()
self.p200.calibrate_plunger(top=0, bottom=10, blow_out=12, drop_tip=13)
self.robot.home()
def test_deck_setup(self):
deck = self.robot.deck
trash = containers_load(self.robot, 'point', 'A1', 'myTrash')
tiprack = containers_load(self.robot, 'tiprack-10ul', 'B2')
self.assertTrue(isinstance(tiprack, Container))
self.assertTrue(isinstance(deck, Deck))
self.assertTrue(deck.has_container(trash))
self.assertTrue(deck.has_container(tiprack))
def setUp(self):
self.robot = Robot()
self.trash_box = containers_load(self.robot, 'trash-box', 'A1')
self.wheaton_vial_rack = containers_load(
self.robot, 'wheaton_vial_rack', 'A2'
)
self.tube_rack_80well = containers_load(
self.robot, 'tube-rack-80well', 'A3'
)
self.T75_flask = containers_load(self.robot, 'T75-flask', 'B1')
self.T25_flask = containers_load(self.robot, 'T25-flask', 'B2')
def protocol(self):
self.robot.get_serial_ports_list()
self.robot.home()
tiprack = containers_load(
self.robot,
'tiprack-200ul', # container type
'A1', # slot
'tiprack' # user-defined name
)
plate = containers_load(
self.robot,
'96-flat',
'B1',
'plate'
)
trash = containers_load(
self.robot,
'point',
'C2',
'trash'
)
trough = containers_load(
self.robot,
'trough-12row',
'B2',
'trough'
)
p200 = pipette.Pipette(
self.robot,
name="p200",
trash_container=trash,
tip_racks=[tiprack],
min_volume=0.5,
axis="b",
channels=1
)
self.robot.clear_commands()
# distribute
p200.pick_up_tip(tiprack[0])
p200.aspirate(96 * 2, trough[0])
for i in range(96):
p200.dispense(2, plate[i]).touch_tip()
p200.drop_tip(tiprack[0])
p200.pick_up_tip(tiprack[1])
for i in range(96):
p200.aspirate(2, plate[95 - i])
p200.dispense(trough[0])
p200.drop_tip(tiprack[1])
def test_protocol_container_setup(self):
plate = containers_load(self.robot, '96-flat', 'A1', 'myPlate')
tiprack = containers_load(self.robot, 'tiprack-10ul', 'B2')
containers_list = self.robot.containers().values()
self.assertEqual(len(containers_list), 2)
self.assertEqual(self.robot._deck['A1']['myPlate'], plate)
self.assertEqual(self.robot._deck['B2']['tiprack-10ul'], tiprack)
self.assertTrue(plate in containers_list)
self.assertTrue(tiprack in containers_list)
def test_trough_move_to():
from opentrons.instruments.pipette_config import Y_OFFSET_MULTI
robot.reset()
tip_rack = containers_load(robot, 'tiprack-200ul', '3')
p300 = instruments.P300_Single(mount='left', tip_racks=[tip_rack])
trough = containers_load(robot, 'trough-12row', '1')
p300.pick_up_tip()
p300.move_to(trough)
current_pos = pose_tracker.absolute(robot.poses, p300)
assert isclose(current_pos, (14.34, 7.75 + 35 + Y_OFFSET_MULTI, 40)).all()
def test_serializing_configured_robot_with_2_instruments(self):
plate = containers_load(self.robot, '96-flat', 'A1')
trash = containers_load(self.robot, 'point', 'A2')
tiprack = containers_load(self.robot, 'tiprack-200ul', 'A3')
p200 = pipette.Pipette(
self.robot,
axis='b',
tip_racks=[tiprack],
trash_container=trash,
max_volume=200
)
p100 = pipette.Pipette(
self.robot,
axis='a',
channels=8,
tip_racks=[tiprack],
trash_container=trash,
max_volume=100
)
self.make_commands(p200, plate, p100, plate)
# original_robot_cmds_txt = self.robot.commands()
original_robot_cmd_cnts = len(self.robot._commands)
robot_as_bytes = dill.dumps(self.robot)
self.assertIsInstance(robot_as_bytes, bytes)
deserialized_robot = dill.loads(robot_as_bytes)
deserialized_robot_cmd_cnts = len(deserialized_robot._commands)
# Check commands are unmarshalled
self.assertEqual(deserialized_robot_cmd_cnts, original_robot_cmd_cnts)
# Check instruments are unmarshalled
original_robot_instruments = self.robot.get_instruments()
deserialized_robot_instruments = self.robot.get_instruments()
self.assertEqual(
len(original_robot_instruments),
len(deserialized_robot_instruments),
)
self.assertEqual(
original_robot_instruments[0][0],
deserialized_robot_instruments[0][0],
)
# Set deserialized robot as the global robot and attempt to
# reconstruct the same commands again
r2_p200 = deserialized_robot_instruments[0][1]
r2_p100 = deserialized_robot_instruments[1][1]
self.make_commands(r2_p200, plate, r2_p100, plate)
def test_containers_create(self):
container_name = 'plate_for_testing_containers_create'
containers_create(
name=container_name,
grid=(8, 12),
spacing=(9, 9),
diameter=4,
depth=8,
volume=1000)
p = containers_load(self.robot, container_name, 'A1')
self.assertEquals(len(p), 96)
self.assertEquals(len(p.rows), 12)
self.assertEquals(len(p.cols), 8)
self.assertEquals(
p.get_parent(), self.robot.deck['A1'])
self.assertEquals(p['C3'], p[18])
self.assertEquals(p['C3'].max_volume(), 1000)
for i, w in enumerate(p):
self.assertEquals(w, p[i])
# remove the file if we only created it for this test
should_delete = False
with open(environment.get_path('CONTAINERS_FILE')) as f:
created_containers = json.load(f)
del created_containers['containers'][p.get_name()]
if not len(created_containers['containers'].keys()):
should_delete = True
if should_delete:
os.remove(environment.get_path('CONTAINERS_FILE'))
def test_create_arc(virtual_smoothie_env):
from opentrons.robot.robot import TIP_CLEARANCE_DECK, TIP_CLEARANCE_LABWARE
robot.reset()
p300 = instruments.P300_Single(mount='left')
plate = containers_load(robot, '96-flat', '1')
plate2 = containers_load(robot, '96-flat', '2')
new_labware_height = 10
robot.poses = p300._move(robot.poses, x=10, y=10, z=new_labware_height)
robot.calibrate_container_with_instrument(plate, p300, save=False)
trash_height = robot.max_placeable_height_on_deck(robot.fixed_trash)
assert robot.max_deck_height() == trash_height
res = robot._create_arc(p300, (0, 0, 0), plate[0])
arc_top = robot.max_deck_height() + TIP_CLEARANCE_DECK
expected = [
{'z': arc_top},
{'x': 0, 'y': 0},
{'z': 0}
]
assert res == expected
res = robot._create_arc(p300, (0, 0, 0), plate[1])
arc_top = robot.max_placeable_height_on_deck(plate) + TIP_CLEARANCE_LABWARE
expected = [
{'z': arc_top},
{'x': 0, 'y': 0},
{'z': 0}
]
assert res == expected
new_labware_height = 200
robot.poses = p300._move(robot.poses, x=10, y=10, z=new_labware_height)
robot.calibrate_container_with_instrument(plate2, p300, save=False)
assert robot.max_deck_height() == new_labware_height
res = robot._create_arc(p300, (0, 0, 0), plate2[0])
arc_top = p300._max_deck_height()
expected = [
{'z': arc_top},
{'x': 0, 'y': 0},
{'z': 0}
]
assert res == expected
def test_container_parse():
robot.reset()
plate = containers_load(robot, '96-flat', '1')
if ff.split_labware_definitions():
expected = {'x': 0, 'y': 0, 'z': 0}
else:
expected = {'x': 14.34, 'y': 11.24, 'z': 10.50}
assert database._parse_container_obj(plate) == expected
def test_protocol_head(self):
trash = containers_load(self.robot, 'point', 'A1', 'myTrash')
tiprack = containers_load(self.robot, 'tiprack-10ul', 'B2')
p200 = pipette.Pipette(
self.robot,
name='myPipette',
trash_container=trash,
tip_racks=[tiprack],
min_volume=10, # These are variable
axis="b",
channels=1)
instruments_list = self.robot.get_instruments()
self.assertEqual(instruments_list[0], ('B', p200))
instruments_list = self.robot.get_instruments('myPipette')
self.assertEqual(instruments_list[0], ('B', p200))
def test_create_arc(self):
p200 = pipette.Pipette(self.robot,
axis='b',
name='my-fancy-pancy-pipette')
plate = containers_load(self.robot, '96-flat', 'A1')
plate2 = containers_load(self.robot, '96-flat', 'B1')
self.robot.move_head(x=10, y=10, z=10)
p200.calibrate_position((plate, Vector(0, 0, 0)))
self.robot.move_head(x=10, y=10, z=100)
p200.calibrate_position((plate2, Vector(0, 0, 0)))
res = self.robot._create_arc((0, 0, 0), plate[0])
expected = [{'z': 100}, {'x': 0, 'y': 0}, {'z': 0}]
self.assertEquals(res, expected)
res = self.robot._create_arc((0, 0, 0), plate[0])
expected = [{'z': 20.5 + 5}, {'x': 0, 'y': 0}, {'z': 0}]
self.assertEquals(res, expected)
def setUp(self):
self.robot = Robot()
self.robot.home()
self.trash = containers_load(self.robot, 'point', 'A1')
self.tiprack1 = containers_load(self.robot, 'tiprack-10ul', 'B2')
self.tiprack2 = containers_load(self.robot, 'tiprack-10ul', 'B3')
self.plate = containers_load(self.robot, '96-flat', 'A2')
self.p200 = pipette.Pipette(
self.robot,
trash_container=self.trash,
tip_racks=[self.tiprack1, self.tiprack2],
max_volume=200,
min_volume=10, # These are variable
axis="a",
channels=1)
self.p200.aspirate(100, self.plate[0]).dispense()
def test_pos_tracker_persistance(virtual_smoothie_env):
robot.reset()
p300 = instruments.P300_Single(mount='left')
plate = containers_load(robot, 'trough-12row', '5')
assert robot.max_placeable_height_on_deck(plate) == 40.0
robot.poses = p300._move(robot.poses, x=10, y=10, z=10)
robot.calibrate_container_with_instrument(plate, p300, save=False)
assert robot.max_placeable_height_on_deck(plate) == 10.0
def test_container_from_container_load():
robot.reset()
plate = containers_load(robot, '96-flat', '1')
if ff.split_labware_definitions():
actual = plate[0]._coordinates + plate[0].top()[1]
expected = Vector(14.34, 74.24, 10.50)
else:
actual = plate._coordinates
expected = Vector(14.34, 11.24, 10.50)
assert plate.get_type() == '96-flat'
assert actual == expected
def test_well_from_container_load():
robot.reset()
plate = containers_load(robot, '96-flat', '1')
assert plate[3].top()[1] == Vector(3.20, 3.20, 10.50)
assert plate[3].properties == {
'depth': 10.5,
'total-liquid-volume': 400,
'diameter': 6.4,
'height': 10.5,
'width': 6.4,
'length': 6.4
}
def test_load_same_slot_force(self):
container_name = '96-flat'
slot = '1'
containers_load(self.robot, container_name, slot)
# 2018-1-30 Incremented number of containers based on fixed trash
self.assertEquals(len(self.robot.get_containers()), 2)
self.assertRaises(RuntimeWarning, containers_load, self.robot,
container_name, slot)
self.assertRaises(RuntimeWarning,
containers_load,
self.robot,
container_name,
slot,
share=True)
self.assertRaises(RuntimeWarning, containers_load, self.robot,
container_name, slot, 'custom-name')
self.assertRaises(RuntimeWarning, containers_load, self.robot,
'trough-12row', slot)
self.assertRaises(RuntimeWarning, containers_load, self.robot,
'trough-12row', slot, 'custom-name')
containers_load(self.robot,
container_name,
slot,
'custom-name',
share=True)
self.assertEquals(len(self.robot.get_containers()), 3)
containers_load(self.robot, 'trough-12row', slot, share=True)
self.assertEquals(len(self.robot.get_containers()), 4)
def test_dispense_move_to():
robot.reset()
tip_rack = containers_load(robot, 'tiprack-200ul', '3')
p300 = instruments.P300_Single(mount='left', tip_racks=[tip_rack])
x, y, z = (161.0, 116.7, 0.0)
plate = containers_load(robot, '96-flat', '1')
well = plate[0]
pos = well.from_center(x=0, y=0, z=-1, reference=plate)
location = (plate, pos)
robot.poses = p300._move(robot.poses, x=x, y=y, z=z)
robot.calibrate_container_with_instrument(plate, p300, False)
p300.pick_up_tip()
p300.aspirate(100, location)
p300.dispense(100, location)
current_pos = pose_tracker.absolute(robot.poses, p300.instrument_actuator)
assert (current_pos == (1.5, 0.0, 0.0)).all()
current_pos = pose_tracker.absolute(robot.poses, p300)
assert isclose(current_pos, (175.34, 127.94, 10.5)).all()
def test_deck_setup(self):
deck = self.robot.deck
pip = pipette.Pipette(self.robot, mount='left')
# Check that the fixed trash has loaded on to the pipette
trash = pip.trash_container
tiprack = containers_load(self.robot, 'tiprack-10ul', '5')
self.assertTrue(isinstance(tiprack, Container))
self.assertTrue(isinstance(deck, Deck))
# Check that well location is the same on the robot as the pipette
self.assertEqual(self.robot._deck['12']['tall-fixed-trash'][0], trash)
self.assertTrue(deck.has_container(tiprack))
def setUp(self):
self.robot = Robot()
options = {
'limit_switches': False
}
self.robot.connect(options=options)
self.robot.home()
self.plate = containers_load(self.robot, '96-flat', 'A2')
self.magbead = magbead.Magbead(
self.robot, mosfet=0, container=self.plate
)
self.robot._driver.set_mosfet = mock.Mock()
self.robot._driver.wait = mock.Mock()
def test_drop_tip_default_trash(virtual_smoothie_env):
robot.reset()
tiprack = containers_load(robot, 'tiprack-200ul', '1')
pip = instruments.P300_Single(mount='right', tip_racks=[tiprack])
trash_loc = vector.Vector([80.00, 80.00, 80.00])
pip.pick_up_tip()
with mock.patch.object(robot, 'move_to') as move_to: # NOQA
pip.drop_tip()
move_to.assert_called_with(
(robot.fixed_trash[0], trash_loc),
instrument=pip,
strategy='arc')
def test_retract():
robot.reset()
plate = containers_load(robot, '96-flat', '1')
p300 = instruments.P300_Single(mount='left')
from opentrons.drivers.smoothie_drivers.driver_3_0 import HOMED_POSITION
p300.move_to(plate[0].top())
assert p300.previous_placeable == plate[0]
current_pos = pose_tracker.absolute(robot.poses, p300)
assert current_pos[2] == plate[0].top()[1][2]
p300.retract()
assert p300.previous_placeable is None
current_pos = pose_tracker.absolute(robot.poses, p300.instrument_mover)
assert current_pos[2] == HOMED_POSITION['A']
def setUp(self):
self.robot = Robot()
self.robot.connect()
self.plate = containers_load(self.robot, '96-flat', 'A1', 'plate')
self.p200 = pipette.Pipette(self.robot, name="p200", axis="b")
self.p200.delete_calibration_data()
well = self.plate[0]
pos = well.from_center(x=0, y=0, z=0, reference=self.plate)
self.location = (self.plate, pos)
well_deck_coordinates = well.center(well.get_deck())
dest = well_deck_coordinates + Vector(1, 2, 3)
self.robot.move_head(x=dest['x'], y=dest['y'], z=dest['z'])
self.p200.calibrate_position(self.location)
def test_calibrated_max_dimension(self):
expected = self.robot._deck.max_dimensions(self.robot._deck)
res = self.robot._calibrated_max_dimension()
self.assertEquals(res, expected)
p200 = pipette.Pipette(self.robot,
axis='b',
name='my-fancy-pancy-pipette')
plate = containers_load(self.robot, '96-flat', 'A1')
self.robot.move_head(x=10, y=10, z=10)
p200.calibrate_position((plate, Vector(0, 0, 0)))
res = self.robot._calibrated_max_dimension()
expected = Vector(plate.max_dimensions(plate)) + Vector(10, 10, 10)
self.assertEquals(res, expected)
def test_new_containers():
robot.reset()
trash_box = containers_load(robot, 'trash-box', '1')
tip_rack = containers_load(robot, 'tiprack-200ul', '3')
wheaton_vial_rack = containers_load(robot, 'wheaton_vial_rack', '4')
tube_rack_80well = containers_load(robot, 'tube-rack-80well', '7')
T75_flask = containers_load(robot, 'T75-flask', '2')
T25_flask = containers_load(robot, 'T25-flask', '5')
p300 = instruments.P300_Single(mount='right', tip_racks=[tip_rack])
p300.pick_up_tip()
p300.aspirate(100, wheaton_vial_rack[0]).dispense(trash_box)
p300.aspirate(100, tube_rack_80well[0]).dispense(trash_box)
p300.aspirate(100, T75_flask[0]).dispense(trash_box)
p300.aspirate(100, T25_flask[0]).dispense(trash_box)
def test_serializing_configured_robot(self):
plate = containers_load(self.robot, '96-flat', 'A1')
p200 = pipette.Pipette(self.robot, axis='b', max_volume=200)
for well in plate:
p200.aspirate(well).delay(5).dispense(well)
original_robot_cmd_cnts = len(self.robot._commands)
robot_as_bytes = dill.dumps(self.robot)
self.assertIsInstance(robot_as_bytes, bytes)
deserialized_robot = dill.loads(robot_as_bytes)
deserialized_robot_cmd_cnts = len(deserialized_robot._commands)
self.assertEqual(deserialized_robot_cmd_cnts, original_robot_cmd_cnts)
original_robot_instruments = self.robot.get_instruments()
deserialized_robot_instruments = self.robot.get_instruments()
self.assertEqual(
len(original_robot_instruments),
len(deserialized_robot_instruments),
)
self.assertEqual(
original_robot_instruments[0][0],
deserialized_robot_instruments[0][0],
)
def setUp(self):
# TODO(Ahmed): Why does this test setup a plate, robot, container
# when it doesnt use them in any test cases?
self.robot = Robot()
self.p200 = pipette.Pipette(self.robot, mount='left')
self.plate = containers_load(self.robot, '96-flat', '3')
def protocol(self):
self.robot.get_serial_ports_list()
self.robot.home()
tiprack = containers_load(
self.robot,
'tiprack-200ul', # container type
'A1', # slot
'tiprack' # user-defined name
)
plate = containers_load(self.robot, '96-flat', 'B1', 'plate')
trash = containers_load(self.robot, 'point', 'C2', 'trash')
trough = containers_load(self.robot, 'trough-12row', 'B2', 'trough')
p200 = pipette.Pipette(self.robot,
name="p200",
trash_container=trash,
tip_racks=[tiprack],
max_volume=200,
min_volume=0.5,
axis="b",
channels=1)
calibration_data = """
{
"b": {
"blowout": 28.0,
"bottom": 26.0,
"droptip": 32.0,
"resting": 0,
"theContainers": {
"plate": {
"rel_x": 181.696,
"rel_y": 0.700999999999965,
"rel_z": 9.600999999999999,
"x": 202.195,
"y": 370.304,
"z": 125.7
},
"tiprack": {
"rel_x": 0.0,
"rel_y": 0.0,
"rel_z": 0.0,
"x": 20.499,
"y": 369.603,
"z": 116.099
},
"trough": {
"rel_x": 0.0,
"rel_y": 0.0,
"rel_z": 0.0,
"x": 20.499,
"y": 269.603,
"z": 116.099
},
"trash": {
"rel_x": 212.701,
"rel_y": -200.801,
"rel_z": -58.399,
"x": 233.2,
"y": 171.305,
"z": 57.7
}
},
"tip_rack_origin": "tiprack",
"tip_racks": [
{
"container": "tiprack"
}
],
"top": 13.0,
"trash_container": {
"container": "trash"
},
"volume": 200
}
}
"""
import_calibration_json(calibration_data, self.robot, True)
self.robot.clear_commands()
# distribute
p200.pick_up_tip(tiprack[0])
p200.aspirate(96 * 2, trough[0])
for i in range(96):
p200.dispense(2, plate[i]).touch_tip()
p200.drop_tip(tiprack[0])
p200.pick_up_tip(tiprack[1])
for i in range(96):
p200.aspirate(2, plate[95 - i])
p200.dispense(trough[0])
p200.drop_tip(tiprack[1])
def test_slot_name(slot_name, expected_name):
self.robot.reset()
p = containers_load(self.robot, '96-flat', slot_name)
slot_name = p.get_parent().get_name()
assert slot_name == expected_name
