def _test_offset(x, y, z):
robot.reset()
robot.config = robot.config._replace(mount_offset=(x, y, z))
left = instruments.P300_Single(mount='left')
right = instruments.P300_Single(mount='right')
robot.home()
left_pos = pose_tracker.absolute(robot.poses, left)
right_pos = pose_tracker.absolute(robot.poses, right)
assert left_pos[0] == right_pos[0] + x
assert left_pos[1] == right_pos[1] + y
assert left_pos[2] == right_pos[2] + z
def run_custom_protocol(
pipette_type: 'StringSelection...' = 'p300-Single',
dilution_factor: float = 2.0,
num_of_dilutions: int = 4,
total_mixing_volume: float = 200.0,
tip_use_strategy: 'StringSelection...' = 'use one tip'):
pip_name = pipette_type.split('-')[1]
if pipette_type == 'p300-Single':
pipette = instruments.P300_Single(mount='right', tip_racks=[tiprack])
else:
raise ValueError('wrong pipette')
transfer_volume = total_mixing_volume / dilution_factor
diluent_volume = total_mixing_volume - transfer_volume
logging.info(pipette)
pipette.pick_up_tip()
for col in []: #liquid_output.cols('2', length=(num_of_dilutions)):
logging.info(col)
pipette.distribute(diluent_volume, liquid_input['A1'], col)
for row in liquid_output.rows():
pipette.transfer(transfer_volume,
row.wells('1', to=(num_of_dilutions - 1)),
row.wells('2', to=(num_of_dilutions)),
mix_after=(3, total_mixing_volume / 2))
pipette.transfer(transfer_volume, row.wells(num_of_dilutions),
liquid_trash)
def test_fixed_trash():
robot.reset()
p300 = instruments.P300_Single(mount='right')
p300.move_to(p300.trash_container)
assert isclose(pose_tracker.absolute(robot.poses, p300),
(345.0, 351.5, 85.0)).all()
def test_use_filter_tips():
# test tips with lower working volume than max volume of pipette used to
# ensure that the pipette never over-aspirates with a smaller pipette tip
tipracks = [
'opentrons_96_filtertiprack_10ul',
'opentrons_96_filtertiprack_200ul',
'opentrons_96_filtertiprack_1000ul'
]
for t in tipracks:
robot.reset()
tip_rack = containers_load(robot, t, '3')
plate = containers_load(robot, '96-flat', '1')
p300 = instruments.P300_Single(
mount='left', tip_racks=[tip_rack])
p300.pick_up_tip()
p300.aspirate(plate[0])
# working volume should be the lesser of the pipette max volume
# and the tip max volume
assert p300.current_volume == p300._working_volume
assert p300.current_volume == min(
tip_rack[0].max_volume(), p300.max_volume)
# working volume should revert back to pipette max volume if no tip
# is attached
p300.return_tip()
assert p300._working_volume == p300.max_volume
def test_aspirate_move_to(old_aspiration):
# TODO: it seems like this test is checking that the aspirate point is
# TODO: *fully* at the bottom of the well, which isn't the expected
# TODO: behavior of aspirate when a location is not specified. This should
# TODO: be split into two tests--one for this behavior (specifying a place)
# TODO: and another one for the default
robot.reset()
tip_rack = containers_load(robot, 'tiprack-200ul', '3')
p300 = instruments.P300_Single(
mount='left', tip_racks=[tip_rack])
p300.pick_up_tip()
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.aspirate(100, location)
current_pos = pose_tracker.absolute(
robot.poses,
p300.instrument_actuator)
assert (current_pos == (6.889964, 0.0, 0.0)).all()
current_pos = pose_tracker.absolute(robot.poses, p300)
assert isclose(current_pos, (161, 116.7, 10.5)).all()
async def test_move_and_home_existing_pipette(async_server, async_client):
hw = async_server['com.opentrons.hardware']
if async_server['api_version'] == 1:
hw.reset()
else:
await hw.reset()
resp = await async_client.post('/robot/home', json={'target': 'robot'})
assert resp.status == 200
if async_server['api_version'] == 1:
from opentrons import instruments
instruments.P300_Single(mount='right')
move_data = {
'target': 'pipette',
'point': [100, 200, 50],
'mount': 'right',
'model': 'p300_single_v1'
}
res = await async_client.post('/robot/move', json=move_data)
assert res.status == 200
move_data = {
'target': 'pipette',
'mount': 'right'
}
res1 = await async_client.post('/robot/home', json=move_data)
assert res1.status == 200
def test_dispense_move_to(old_aspiration):
# TODO: same as for aspirate
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, (161, 116.7, 10.5)).all()
def test_delay_calls(monkeypatch):
from opentrons import robot
from opentrons.legacy_api.instruments import pipette
robot.reset()
p300 = instruments.P300_Single(mount='right')
cmd = []
def mock_pause():
nonlocal cmd
cmd.append('pause')
def mock_resume():
nonlocal cmd
cmd.append('resume')
def mock_sleep(seconds):
cmd.append("sleep {}".format(seconds))
def mock_is_simulating():
return False
monkeypatch.setattr(robot, 'is_simulating', mock_is_simulating)
monkeypatch.setattr(robot, 'pause', mock_pause)
monkeypatch.setattr(robot, 'resume', mock_resume)
monkeypatch.setattr(pipette, '_sleep', mock_sleep)
p300.delay(seconds=4, minutes=1)
assert 'pause' in cmd
assert 'sleep 64.0' in cmd
assert 'resume' in cmd
def run_custom_protocol(
well_volume: float = 1.0,
pipette_type: StringSelection('p300-Single', 'p50-Single', 'p10-Single',
'p300-Multi', 'p50-Multi',
'p10-Multi') = 'p300-Single'):
pip_name = pipette_type.split('-') # Check which pipette type
if pipette_type == 'p300-Single':
pipette = instruments.P300_Single(mount='left', tip_racks=[tiprack])
elif pipette_type == 'p50-Single':
pipette = instruments.P50_Single(mount='left', tip_racks=[tiprack])
elif pipette_type == 'p10-Single':
pipette = instruments.P10_Single(mount='left', tip_racks=[tiprack])
elif pipette_type == 'p300-Multi':
pipette = instruments.P300_Multi(mount='left', tip_racks=[tiprack])
elif pipette_type == 'p50-Multi':
pipette = instruments.P50_Multi(mount='left', tip_racks=[tiprack])
elif pipette_type == 'p10-Multi':
pipette = instruments.P10_Multi(mount='left', tip_racks=[tiprack])
alternating_wells = []
for column in plate.cols():
if pip_name[1] == 'Multi':
alternating_wells.append(column.wells('A'))
alternating_wells.append(column.wells('B'))
else:
alternating_wells.append(column.wells('A', length=8, step=2))
alternating_wells.append(column.wells('B', length=8, step=2))
pipette.distribute(well_volume, trough.wells('A1'), alternating_wells)
def run_custom_protocol(
pipette_type: 'StringSelection...' = 'p300-Single',
dye_labware_type: 'StringSelection...' = 'trough-12row'):
if pipette_type == 'p300-Single':
tiprack = labware.load('tiprack-200ul', '1')
pipette = instruments.P300_Single(mount='right', tip_racks=[tiprack])
elif pipette_type == 'p50-Single':
tiprack = labware.load('tiprack-200ul', '1')
pipette = instruments.P50_Single(mount='right', tip_racks=[tiprack])
elif pipette_type == 'p10-Single':
tiprack = labware.load('tiprack-10ul', '1')
pipette = instruments.P10_Single(mount='right', tip_racks=[tiprack])
if dye_labware_type == 'trough-12row':
dye_container = labware.load('trough-12row', '2')
else:
dye_container = labware.load('tube-rack-2ml', '2')
output = labware.load('96-flat', '3')
# Well Location set-up
dye1_wells = [
'C4', 'B4', 'A3', 'A2', 'B1', 'C1', 'D1', 'D2', 'E2', 'E1', 'F1', 'G1',
'H2', 'H3', 'G4', 'F4'
]
dye2_wells = [
'C5', 'C6', 'C7', 'C8', 'C9', 'B10', 'C11', 'D12', 'E12', 'F11', 'G10',
'E9', 'F9', 'F8', 'F7', 'F6', 'F5', 'G8'
]
dye2 = dye_container.wells('A1')
dye1 = dye_container.wells('A2')
pipette.distribute(50, dye1, output.wells(dye1_wells), new_tip='once')
pipette.distribute(50, dye2, output.wells(dye2_wells), new_tip='once')
def run_custom_protocol(pipette_type: 'StringSelection...'='p300-Single',
source_labware_type: 'StringSelection...'='trough-12row',
destination_labware_type: 'StringSelection...'='96-flat',
micro_liters: 'NumberSelection...'=1,
new_tip_type: 'StringSelection...'='once'):
if pipette_type == 'p300-Single':
tiprack = labware.load('tiprack-200ul', '1')
pipette = instruments.P300_Single(
mount='right',
tip_racks=[tiprack])
elif pipette_type == 'p50-Single':
tiprack = labware.load('tiprack-200ul', '1')
pipette = instruments.P50_Single(
mount='right',
tip_racks=[tiprack])
elif pipette_type == 'p10-Single':
tiprack = labware.load('tiprack-10ul', '1')
pipette = instruments.P10_Single(
mount='right',
tip_racks=[tiprack])
else:
print('Unknown pipette type: ' + pipette_type)
return
source_container = labware.load(source_labware_type, '2')
destination_container = labware.load(destination_labware_type, '3')
source_wells = source_container.wells('A1')
destination_wells = destination_container.wells('A1')
pipette.distribute(
micro_liters,
source_wells,
destination_wells,
new_tip=new_tip_type)
def run_custom_protocol(
total_mixing_volume: float = 10.0,
final_conc: float = 1000,
):
pipette_10 = instruments.P10_Single(mount='left', tip_racks=tiprack_10)
pipette_300 = instruments.P300_Single(mount='right', tip_racks=tiprack_300)
final_conc = final_conc / 2
no_dilutions = 6
dilution_factor = 1 / ((final_conc)**(1 / no_dilutions))
transfer_volume = total_mixing_volume / dilution_factor
diluent_volume = total_mixing_volume - transfer_volume
# Reverse pipette diluent from wells B12 to H12
pipette_300.pick_up_tip()
pipette_300.aspirate(100, tube_rack['A2'])
pipette_300.dispense(90, plate.cols('12').wells()[0])
pipette_300.aspirate(diluent_volume + 10, tube_rack['A2'])
pipette_300.dispense(diluent_volume, plate.cols('12').wells()[1])
for well in plate.cols('12').wells()[2:-1]:
pipette_300.aspirate(diluent_volume, tube_rack['A2'])
pipette_300.dispense(diluent_volume, well)
pipette_300.blow_out(tube_rack['A2'])
pipette_300.aspirate(total_mixing_volume, tube_rack['A2'])
pipette_300.dispense(total_mixing_volume, plate.cols('12').wells()[-1])
pipette_300.drop_tip()
#Add sample to well A12 for dilution
pipette_10.pick_up_tip()
pipette_10.aspirate(10, tube_rack['A1'])
pipette_10.dispense(10, plate.cols('12').wells('A'))
if transfer_volume > 30:
pipette_10.drop_tip()
pipette_300.pick_up_tip()
for row in range(0, 6):
pipette_300.transfer(transfer_volume,
plate.cols('12').wells(row),
plate.cols('12').wells(row + 1),
mix_after=(3, total_mixing_volume / 2),
new_tip='never')
pipette_300.drop_tip()
else:
for row in range(0, 6):
pipette_10.transfer(transfer_volume,
plate.cols('12').wells(row),
plate.cols('12').wells(row + 1),
mix_after=(3, total_mixing_volume / 2),
new_tip='never')
pipette_10.drop_tip()
def setup():
global header, p50, p300, stock_wells, tube_rack, df
df = np.genfromtxt('solutionmaker.csv',
delimiter=',',
skip_header=1,
missing_values='')
with open('solutionmaker.csv') as csvfile:
reader_object = csv.reader(csvfile)
header = [row for i_row, row in enumerate(reader_object) if i_row == 0]
(nrows, ncols) = df.shape
for n_row in range(nrows):
if (df[n_row, :].sum() > 1500):
raise ValueError(
'Individual wells will not tolerate addition of this much volume'
)
"""
The following are constants for instantiation (mm/sec or ul/sec)
-----------------------------------------
"""
XSPEED = 600
YSPEED = 600
ZSPEED = 125
P300_ASPIRATERATE = 150
P50_ASPIRATE = 25
P50_DISPENSERATE = 100
P300_DISPENSERATE = 600
"""
------------------------------------------
"""
# connects robot and sets robot settings
robot.home()
robot.connect()
robot.head_speed(x=XSPEED, y=YSPEED, z=ZSPEED)
# sets up labware and the layout of the experiment
m300rack_1 = containers.load('tiprack-200ul', '10', share='True')
m300rack_2 = containers.load('tiprack-200ul', '11', share='True')
stock_wells = []
slot_plate_wells = ['4', '5']
for slot in slot_plate_wells:
stock_wells.append(containers.load('plate_6_well', slot, share='True'))
stock_wells.append(containers.load('96-flat', '6', share='True'))
tube_rack = []
slots_tube_rack = ['1', '2', '3']
for slot in slots_tube_rack:
tube_rack.append(containers.load('4x6_Tube_rack', slot, share='True'))
# instantiates pipettes
p50 = instruments.P50_Single(mount="right",
tip_racks=[m300rack_1],
aspirate_flow_rate=P50_ASPIRATE,
dispense_flow_rate=P50_DISPENSERATE)
p300 = instruments.P300_Single(mount="left",
tip_racks=[m300rack_2],
aspirate_flow_rate=P300_ASPIRATERATE,
dispense_flow_rate=P300_DISPENSERATE)
def run_custom_protocol():
p300 = instruments.P300_Single(
mount='left',
tip_racks=[p200rack]
)
for color in pixels_by_color:
distribute_to_agar(p300, 0.1, palette_colors[color], pixels_by_color[color], disposal_vol=4)
def run_custom_protocol(pipette_type: 'StringSelection...'='p300-Single',
pipette_mount: 'StringSelection...'='right',
dye_labware_type: 'StringSelection...'='trough-12row'):
if pipette_mount == 'left' or pipette_mount == 'l':
mount_position = 'left'
elif pipette_mount == 'right' or pipette_mount == 'r':
mount_position = 'right'
else:
raise Exception(
"You can only mount the pipette on the 'left' or 'right' mount")
if pipette_type == 'p300-Single':
tiprack = labware.load('tiprack-200ul', '1')
pipette = instruments.P300_Single(
mount=mount_position,
tip_racks=[tiprack])
elif pipette_type == 'p50-Single':
tiprack = labware.load('tiprack-200ul', '1')
pipette = instruments.P50_Single(
mount=mount_position,
tip_racks=[tiprack])
elif pipette_type == 'p10-Single':
tiprack = labware.load('tiprack-10ul', '1')
pipette = instruments.P10_Single(
mount=mount_position,
tip_racks=[tiprack])
if dye_labware_type == 'trough-12row':
dye_container = labware.load('trough-12row', '2')
elif dye_labware_type == '6-well-plate':
dye_container = labware.load('6-well-plate', '2')
else:
dye_container = labware.load('tube-rack-2ml', '2')
output = labware.load('96-flat', '3')
# Well Location set-up
dye1_wells = ['A5', 'A6', 'A8', 'A9', 'B4', 'B10', 'C3', 'C11', 'D3',
'D11', 'E3', 'E11', 'F3', 'F11', 'G4', 'G10',
'H5', 'H6', 'H7', 'H8', 'H9']
dye2_wells = ['C7', 'D6', 'D7', 'D8', 'E5', 'E6', 'E7', 'E8',
'E9', 'F5', 'F6', 'F7', 'F8', 'F9', 'G6', 'G7', 'G8']
dye2 = dye_container.wells('A1')
dye1 = dye_container.wells('A2')
pipette.distribute(
50,
dye1,
output.wells(dye1_wells),
new_tip='once')
pipette.distribute(
50,
dye2,
output.wells(dye2_wells),
new_tip='once')
def run_custom_protocol(
pipette_axis: 'StringSelection...'='left'):
p300 = instruments.P300_Single(
mount=pipette_axis,
tip_racks=[p200rack]
)
for color in pixels_by_color:
distribute_to_agar(p300, 0.1, palette_colors[color], pixels_by_color[color], disposal_vol=1)
def test_pipette_max_deck_height():
robot.reset()
tallest_point = robot._driver.homed_position['Z']
p = instruments.P300_Single(mount='left')
assert p._max_deck_height() == tallest_point
for tip_length in [10, 25, 55, 100]:
p._add_tip(length=tip_length)
assert p._max_deck_height() == tallest_point - tip_length
p._remove_tip(length=tip_length)
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 run_custom_protocol(
volumes_csv: FileInput = example_csv,
pipette_axis: StringSelection('B (left side)',
'A (right side)') = 'B (left side)',
pipette_model: StringSelection('p1000', 'p300', 'p50', 'p10') = 'p300',
source_plate_type: StringSelection('96-flat', '384-plate') = '96-flat',
destination_plate_type: StringSelection('96-flat',
'384-plate') = '96-flat',
tip_reuse: StringSelection('new tip each time',
'reuse tip') = 'new tip each time'):
pipette_max_vol = int(pipette_model[1:])
mount = 'right'
if pipette_axis[0] == 'B':
mount = 'left'
tiprack_slots = ['1', '4', '7', '10']
if pipette_max_vol == 300:
tipracks = [
labware.load('tiprack-200ul', slot) for slot in tiprack_slots
]
pipette = instruments.P300_Single(mount=mount, tip_racks=tipracks)
elif pipette_max_vol == 50:
tipracks = [
labware.load('tiprack-200ul', slot) for slot in tiprack_slots
]
pipette = instruments.P50_Single(mount=mount, tip_racks=tipracks)
elif pipette_max_vol == 10:
tipracks = [
labware.load('tiprack-200ul', slot) for slot in tiprack_slots
]
pipette = instruments.P10_Single(mount=mount, tip_racks=tipracks)
elif pipette_max_vol == 1000:
tipracks = [
labware.load('tiprack-200ul', slot) for slot in tiprack_slots
]
pipette = instruments.P1000_Single(mount=mount, tip_racks=tipracks)
data = [
[well, vol] for well, vol in
[row.split(',') for row in volumes_csv.strip().splitlines() if row]
]
source_plate = labware.load(source_plate_type, '2')
dest_plate = labware.load(destination_plate_type, '3')
tip_strategy = 'always' if tip_reuse == 'new tip each time' else 'once'
for well_idx, (source_well, vol) in enumerate(data):
if source_well and vol:
vol = float(vol)
pipette.transfer(vol,
source_plate.wells(source_well),
dest_plate.wells(well_idx),
new_tip=tip_strategy)
def test_set_flow_rate():
# Test new flow-rate functionality on all pipettes with different max vols
robot.reset()
p10 = instruments.P10_Single(mount='right')
p10.set_flow_rate(aspirate=10)
ul_per_mm = Pipette._p10_single_piecewise(p10, p10.max_volume, 'aspirate')
expected_mm_per_sec = round(10 / ul_per_mm, 6)
assert p10.speeds['aspirate'] == expected_mm_per_sec
p10.set_flow_rate(dispense=20)
ul_per_mm = Pipette._p10_single_piecewise(p10, p10.max_volume, 'dispense')
expected_mm_per_sec = round(20 / ul_per_mm, 6)
assert p10.speeds['dispense'] == expected_mm_per_sec
robot.reset()
p50 = instruments.P50_Single(mount='right')
p50.set_flow_rate(aspirate=50)
ul_per_mm = Pipette._p50_single_piecewise(p50, p50.max_volume, 'aspirate')
expected_mm_per_sec = round(50 / ul_per_mm, 6)
assert p50.speeds['aspirate'] == expected_mm_per_sec
p50.set_flow_rate(dispense=60)
ul_per_mm = Pipette._p50_single_piecewise(p50, p50.max_volume, 'dispense')
expected_mm_per_sec = round(60 / ul_per_mm, 6)
assert p50.speeds['dispense'] == expected_mm_per_sec
robot.reset()
p300 = instruments.P300_Single(mount='right')
p300.set_flow_rate(aspirate=300)
ul_per_mm = Pipette._p300_single_piecewise(p300, p300.max_volume,
'aspirate')
expected_mm_per_sec = round(300 / ul_per_mm, 6)
assert p300.speeds['aspirate'] == expected_mm_per_sec
p300.set_flow_rate(dispense=310)
ul_per_mm = Pipette._p300_single_piecewise(p300, p300.max_volume,
'dispense')
expected_mm_per_sec = round(310 / ul_per_mm, 6)
assert p300.speeds['dispense'] == expected_mm_per_sec
robot.reset()
p1000 = instruments.P1000_Single(mount='right')
p1000.set_flow_rate(aspirate=1000)
ul_per_mm = Pipette._p1000_piecewise(p1000, p1000.max_volume, 'aspirate')
expected_mm_per_sec = round(1000 / ul_per_mm, 6)
assert p1000.speeds['aspirate'] == expected_mm_per_sec
p1000.set_flow_rate(dispense=1100)
ul_per_mm = Pipette._p1000_piecewise(p1000, p1000.max_volume, 'dispense')
expected_mm_per_sec = round(1100 / ul_per_mm, 6)
assert p1000.speeds['dispense'] == expected_mm_per_sec
def test_robot_move_to(virtual_smoothie_env):
robot.reset()
robot.home()
p300 = instruments.P300_Single(mount='right')
robot.move_to((robot._deck, (100, 0, 0)), p300)
assert isclose(
pose_tracker.absolute(
robot.poses,
p300),
(100, 0, 0)
).all()
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 run_custom_protocol(
pipette_axis: StringSelection(
'left', 'right')='left',
pipette_model: StringSelection(
'p10', 'p50', 'p300', 'p1000')='p300',
consolidate_volume: float=20.0,
source_container: StringSelection(
'96-flat', 'tube-rack-2ml')='96-flat',
number_of_source_wells: int=4,
destination_container: StringSelection(
'96-flat', 'tube-rack-2ml')='96-flat',
destination_well: str='A1',
tip_reuse_strategy: StringSelection(
'reuse one tip', 'new tip each time')='reuse one tip'):
pipette_max_vol = int(pipette_model[1:])
new_tip = 'always' if tip_reuse_strategy == 'new tip each time' else 'once'
tip_rack = labware.load(tiprack_from_pipette(pipette_max_vol), '1')
source = labware.load(source_container, '2')
dest = labware.load(destination_container, '3')
try:
dest_well = dest.wells(destination_well)
except ValueError:
raise RuntimeError(
'Invalid destination well "{}". Expected well name like A1, H11, '
.format(destination_well) + 'etc. The destination plate may not ' +
'have a well of that name (eg a 96-well plate has no well "T18")')
if pipette_model == 'p10':
pipette = instruments.P10_Single(
mount=pipette_axis,
tip_racks=[tip_rack])
elif pipette_model == 'p50':
pipette = instruments.P50_Single(
mount=pipette_axis,
tip_racks=[tip_rack])
elif pipette_model == 'p300':
pipette = instruments.P300_Single(
mount=pipette_axis,
tip_racks=[tip_rack])
else:
pipette = instruments.P1000_Single(
mount=pipette_axis,
tip_racks=[tip_rack])
pipette.consolidate(
consolidate_volume,
source[:number_of_source_wells],
dest_well,
new_tip=new_tip)
def test_trough_move_to():
# TODO: new labware system should center multichannel pipettes within wells
# TODO: (correct single-channel position currently corresponds to back-
# TODO: most tip of multi-channel), so calculate against that
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, (0, 0, 38)).all()
def test_robot():
robot.reset()
containers.load('trough-12row', '3', 'trough')
containers.load('96-PCR-flat', '1', 'plate')
# a tip rack for our pipette
p200rack = containers.load('tiprack-200ul', '2', 'tiprack')
# create a p200 pipette on robot axis B
instruments.P300_Single(mount="left", tip_racks=[p200rack])
# Robot tree is pretty big and hard to verify
# Making sure we can serialize it into json
tree, refs = serialize.get_object_tree(robot)
def run_custom_protocol(pipette_type: 'StringSelection...'='p300-Single',
dye_labware_type: 'StringSelection...'='trough-12row'):
if pipette_type == 'p300-Single':
tiprack = labware.load('tiprack-200ul', '1')
pipette = instruments.P300_Single(
mount='left',
tip_racks=[tiprack])
elif pipette_type == 'p50-Single':
tiprack = labware.load('tiprack-200ul', '1')
pipette = instruments.P50_Single(
mount='left',
tip_racks=[tiprack])
elif pipette_type == 'p10-Single':
tiprack = labware.load('tiprack-10ul', '1')
pipette = instruments.P10_Single(
mount='left',
tip_racks=[tiprack])
if dye_labware_type == 'trough-12row':
dye_container = labware.load('trough-12row', '2')
else:
dye_container = labware.load('tube-rack-2ml', '2')
output = labware.load('96-flat', '3')
# Well Location set-up
dye1_wells = ['B2']
dye2_wells = ['A1','A2','A3','A4','A5','A6','A7','A8','A9','A10','A11','A12'
'B1','B6','B7', 'B12',
'C1','C3','C4','C5','C6','C7', 'C9', 'C10','C11','C12'
'D1','D3','D4','D5','D6','D7','D12',
'E1', 'E3', 'E4','E4','E5','E6','E7','E9','E10','E11','E12'
'F1','F3','F4','F5','F6','F7','F9','F10','F11','F12'
'G1','G6','G7','G9','G10','G11','G12'
'H1','H2','H3','H4','H5','H6','H7','H8','H9','H10','H11','H12'
]
dye2 = dye_container.wells('A1')
dye1 = dye_container.wells('A2')
pipette.distribute(
15,
dye1,
output.wells(dye1_wells),
new_tip='once')
pipette.distribute(
15,
dye2,
output.wells(dye2_wells),
new_tip='once')
def run_custom_protocol(
pipette_axis: StringSelection(
'left', 'right')='left'):
p300 = instruments.P300_Single(
mount=pipette_axis,
tip_racks=[p200rack]
)
# macro commands like .distribute() make writing long sequences easier:
# distribute green solution to the body
p300.distribute(50, green, green_wells, disposal_vol=0, blow_out=True)
# distribute blue solution to the dinosaur's back
p300.distribute(50, blue, blue_wells, disposal_vol=0, blow_out=True)
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_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_create_arc(virtual_smoothie_env):
from opentrons.legacy_api.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
