def labware_setup(hardware):
from opentrons import containers, instruments
tip_racks = \
[containers.load('opentrons-tiprack-300ul', slot, slot)
for slot in ['1', '4']]
plates = \
[containers.load('96-flat', slot, slot) for slot in ['2', '5']]
p50 = instruments.P50_Multi(
mount='right', tip_racks=tip_racks)
p1000 = instruments.P1000_Single(
mount='left', tip_racks=tip_racks)
commands = [
{
'location': plates[0][0],
'instrument': p50
},
{
'location': plates[1]
},
{
'locations': [plates[0][0], plates[1]],
'instrument': p1000
}
]
return (p50, p1000), tip_racks, plates, commands
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 mount_pipette(pipette_type, mount, tiprack_slot):
if pipette_type == 'p10-multi':
tip_rack = [
labware.load('tiprack-10ul', slot) for slot in tiprack_slot
]
pipette = instruments.P10_Multi(mount=mount, tip_racks=tip_rack)
elif pipette_type == 'p50-multi':
tip_rack = [
labware.load('opentrons-tiprack-300ul', slot)
for slot in tiprack_slot
]
pipette = instruments.P50_Multi(mount=mount, tip_racks=tip_rack)
else:
tip_rack = [
labware.load('opentrons-tiprack-300ul', slot)
for slot in tiprack_slot
]
pipette = instruments.P300_Multi(mount=mount, tip_racks=tip_rack)
return pipette
#pipetting dead volumes
small_aspiration_extra = 10 #ul
large_aspiration_extra = 50 #ul
#temporary variable to hold the current reaction volume
#reaction_volume
reaction_volume = sample_volume
#reagent IDs
end_mix = enzrack.wells('A1').bottom()
lig_mix = enzrack.wells('A2').bottom()
#pipettor(s)
p50 = instruments.P50_Multi(
mount='right',
tip_racks=[p200rack, p200rack2],
aspirate_flow_rate=60,
dispense_flow_rate=60)
p300 = instruments.P300_Multi(
mount='left',
tip_racks=[p200rack3, p200rack4],
aspirate_flow_rate=60,
dispense_flow_rate=60)
#TEMPORARY DEF: fix robot gantry speed reset after home() (pending fix from Opentrons)
def homehead():
robot.home()
robot.head_speed(x=70, y=70, z=70, a=70, b=50, c=50)
#magnetic block selection protocol
def run_custom_protocol(pipette_type: StringSelection(
'p300_Multi', 'p50_Multi', 'p10_Multi', 'p1000_Single', 'p300_Single',
'p50_Single', 'p10_Single') = 'p300_Multi',
pipette_mount: StringSelection('left',
'right') = 'left',
sample_number: int = 16,
PCR_volume: float = 20,
bead_ratio: float = 1.8,
elution_buffer_volume: float = 20):
incubation_time = 300
settling_time = 50
drying_time = 5
total_tips = sample_number * 8
tiprack_num = total_tips // 96 + (1 if total_tips % 96 > 0 else 0)
slots = ['3', '5', '6', '8', '9', '10', '11'][:tiprack_num]
if pipette_type == 'p1000_Single':
tipracks = [labware.load('tiprack-1000ul', slot) for slot in slots]
pipette = instruments.P1000_Single(mount=pipette_mount,
tip_racks=tipracks)
elif pipette_type == 'p300_Single':
tipracks = [labware.load('tiprack-200ul', slot) for slot in slots]
pipette = instruments.P300_Single(mount=pipette_mount,
tip_racks=tipracks)
elif pipette_type == 'p50_Single':
tipracks = [labware.load('tiprack-200ul', slot) for slot in slots]
pipette = instruments.P50_Single(mount=pipette_mount,
tip_racks=tipracks)
elif pipette_type == 'p10_Single':
tipracks = [labware.load('tiprack-10ul', slot) for slot in slots]
pipette = instruments.P10_Single(mount=pipette_mount,
tip_racks=tipracks)
elif pipette_type == 'p10_Multi':
tipracks = [labware.load('tiprack-10ul', slot) for slot in slots]
pipette = instruments.P10_Multi(mount=pipette_mount,
tip_racks=tipracks)
elif pipette_type == 'p50_Multi':
tipracks = [labware.load('tiprack-200ul', slot) for slot in slots]
pipette = instruments.P50_Multi(mount=pipette_mount,
tip_racks=tipracks)
elif pipette_type == 'p300_Multi':
tipracks = [labware.load('tiprack-200ul', slot) for slot in slots]
pipette = instruments.P300_Multi(mount=pipette_mount,
tip_racks=tipracks)
mode = pipette_type.split('_')[1]
if mode == 'Single':
if sample_number <= 5:
reagent_container = labware.load('opentrons-tuberack-2ml-screwcap',
'7')
liquid_waste = labware.load('trough-12row', '5').wells('A12')
else:
reagent_container = labware.load('trough-12row', '7')
liquid_waste = reagent_container.wells('A12')
samples = [well for well in mag_plate.wells()[:sample_number]]
samples_top = [well.top() for well in samples]
output = [well for well in output_plate.wells()[:sample_number]]
else:
reagent_container = labware.load('trough-12row', '7')
liquid_waste = reagent_container.wells('A12')
col_num = sample_number // 8 + (1 if sample_number % 8 > 0 else 0)
samples = [col for col in mag_plate.cols()[:col_num]]
samples_top = [well.top() for well in mag_plate.rows(0)[:col_num]]
output = [col for col in output_plate.cols()[:col_num]]
# Define reagents and liquid waste
beads = reagent_container.wells(0)
ethanol = reagent_container.wells(1)
elution_buffer = reagent_container.wells(2)
# Define bead and mix volume to resuspend beads
bead_volume = PCR_volume * bead_ratio
if mode == 'Single':
if bead_volume * sample_number > pipette.max_volume:
mix_vol = pipette.max_volume
else:
mix_vol = bead_volume * sample_number
else:
if bead_volume * col_num > pipette.max_volume:
mix_vol = pipette.max_volume
else:
mix_vol = bead_volume * col_num
total_vol = bead_volume + PCR_volume + 15
mix_voltarget = PCR_volume + 10
# Disengage MagDeck
mag_deck.disengage()
# Mix Speed
pipette.set_flow_rate(aspirate=180, dispense=180)
# Mix beads and PCR samples
for target in samples:
pipette.set_flow_rate(aspirate=180, dispense=180)
pipette.pick_up_tip()
# Slow down head speed 0.5X for bead handling
pipette.mix(25, mix_vol, beads)
max_speed_per_axis = {
'x': (50),
'y': (50),
'z': (50),
'a': (10),
'b': (10),
'c': (10)
}
robot.head_speed(combined_speed=max(max_speed_per_axis.values()),
**max_speed_per_axis)
pipette.set_flow_rate(aspirate=10, dispense=10)
pipette.transfer(bead_volume,
beads,
target,
air_gap=0,
new_tip='never')
pipette.set_flow_rate(aspirate=50, dispense=50)
pipette.mix(40, mix_voltarget, target)
pipette.blow_out()
max_speed_per_axis = {
'x': (600),
'y': (400),
'z': (100),
'a': (100),
'b': (40),
'c': (40)
}
robot.head_speed(combined_speed=max(max_speed_per_axis.values()),
**max_speed_per_axis)
pipette.drop_tip()
# Return robot head speed to the defaults for all axes
max_speed_per_axis = {
'x': (600),
'y': (400),
'z': (100),
'a': (100),
'b': (40),
'c': (40)
}
robot.head_speed(combined_speed=max(max_speed_per_axis.values()),
**max_speed_per_axis)
# Incubate beads and PCR product at RT for 5 minutes
robot.comment("Incubating the beads and PCR products at room temperature \
for 5 minutes. Protocol will resume automatically.")
pipette.delay(seconds=incubation_time)
# Engage MagDeck and Magnetize
robot._driver.run_flag.wait()
mag_deck.engage()
robot.comment("Delaying for " + str(settling_time) +
" seconds for beads to \
settle.")
pipette.delay(seconds=settling_time)
# Remove supernatant from magnetic beads
pipette.set_flow_rate(aspirate=25, dispense=120)
for target in samples:
pipette.transfer(total_vol,
target.bottom(0.7),
liquid_waste.top(),
blow_out=True)
# Wash beads twice with 70% ethanol
air_vol = pipette.max_volume * 0.1
for cycle in range(2):
pipette.pick_up_tip()
for target in samples_top:
pipette.transfer(185,
ethanol,
target,
air_gap=air_vol,
new_tip='never')
robot.comment("Delaying for 17 seconds.")
pipette.delay(seconds=17)
for target in samples:
if not pipette.tip_attached:
pipette.pick_up_tip()
pipette.transfer(195,
target.bottom(0.7),
liquid_waste.top(),
air_gap=air_vol,
new_tip='never')
pipette.drop_tip()
# Dry at RT
robot.comment("Drying the beads for " + str(drying_time) +
" minutes. Protocol \
will resume automatically.")
pipette.delay(minutes=drying_time)
# Disengage MagDeck
robot._driver.run_flag.wait()
mag_deck.disengage()
# Mix beads with elution buffer
if elution_buffer_volume / 2 > pipette.max_volume:
mix_vol = pipette.max_volume
else:
mix_vol = elution_buffer_volume / 2
for target in samples:
pipette.pick_up_tip()
pipette.transfer(elution_buffer_volume,
elution_buffer,
target,
new_tip='never')
pipette.mix(45, mix_vol, target)
pipette.drop_tip()
# Incubate at RT for 3 minutes
robot.comment(
"Incubating at room temperature for 3 minutes. Protocol will \
resume automatically.")
pipette.delay(minutes=3)
# Engage MagDeck for 1 minute and remain engaged for DNA elution
robot._driver.run_flag.wait()
mag_deck.engage()
robot.comment("Delaying for " + str(settling_time) +
" seconds for beads to \
settle.")
pipette.delay(seconds=settling_time)
# Transfer clean PCR product to a new well
for target, dest in zip(samples, output):
pipette.transfer(elution_buffer_volume,
target.bottom(1),
dest.top(),
blow_out=True)
# Disengage MagDeck
mag_deck.disengage()
plate_2 = labware.load('96-flat', '2')
plate_3 = labware.load('96-flat', '4')
plate_4 = labware.load('96-flat', '5')
plate_5 = labware.load('96-flat', '7')
plate_6 = labware.load('96-flat', '8')
"""
All four pipettes are loaded into the program, however the app will only
see pipettes that are currently being used.
"""
if pipette_type == 'p300_multi':
pip = instruments.P300_Multi(mount=mount, tip_racks=[tiprack1, tiprack2])
elif pipette_type == 'p10_multi':
pip = instruments.P10_Multi(mount=mount, tip_racks=[tiprack1, tiprack2])
elif pipette_type == 'p50_multi':
pip = instruments.P50_Multi(mount=mount, tip_racks=[tiprack1, tiprack2])
else:
raise ValueError("Incorrect pipette type.")
plates = [plate_1, plate_2, plate_3, plate_4, plate_5, plate_6]
volumes = [
VOLUME_ONE, VOLUME_TWO, VOLUME_THREE, VOLUME_FOUR, VOLUME_FIVE, VOLUME_SIX
]
"""
Helper functions
"""
def pre_wet(vol, well):
pip.aspirate(vol, well)
depth=10.35, # Depth (mm) of each well on the plate
volume=650) # Volume of well as per specs (not 'working volume')
print('Wells in 96WP Whatman:')
for well in custom_plate.wells():
print(well)
dst_plates = [labware.load(destination_type, dst_slot) for dst_slot in\
destination_slots]
#%% PIPETTES
# Multi-channel pipette + tip rack
if multi_pipette_type == 'p50-Multi':
tipracks_multi = [labware.load(tiprack_type_multi, tiprack_slot)\
for tiprack_slot in tiprack_slots_multi]
pipette_multi = instruments.P50_Multi(mount=multi_pipette_mount,
tip_racks=tipracks_multi)
# pipette_multi.start_at_tip(tipracks_multi[0].well(tip_start_from_multi))
# LF: I changed the syntax here as it was completely ignoring the command (I guess difefrence between single and multichannel?)
pipette_multi.start_at_tip(tipracks_multi[0][tip_start_from_multi])
pipette_multi.plunger_positions['drop_tip'] = -6
#%% COMMANDS
# Safety command - gives warning when no tip is attached
pipette_multi.drop_tip()
count_used_tips() # Should be 0 to begin with
# Each column in source plate is replicated (12 times) into separate destination plates
for src_column, dst_plate in zip(source_active_columns, dst_plates):
def run_custom_protocol(
well_volume: float = 50.0,
reagent_well: StringSelection('A1', 'A2', 'A3', 'A4', 'A5', 'A6', 'A7',
'A8', 'A9', 'A10', 'A11', 'A12') = 'A1',
plate_starting_column: str = '1',
number_of_columns_to_fill: int = 24,
pipette_type: StringSelection('p300-Single', 'p50-Single',
'p10-Single', 'p300-Multi', 'p50-Multi',
'p10-Multi') = 'p50-Multi',
mix_reagent_before_transfer: StringSelection('True',
'False') = 'True'):
if int(plate_starting_column) <= 0 or int(plate_starting_column) > 24:
raise Exception("Plate starting column number must be 1-24.")
if (int(plate_starting_column) + number_of_columns_to_fill) > 25:
raise Exception("Number of columns to fill exceeds plate's limit.")
if mix_reagent_before_transfer == 'False':
mix_times = 0
else:
mix_times = 5
pip_name = pipette_type.split('-') # Check which pipette type
if pip_name[0] == 'p10':
tiprack = labware.load('tiprack-10ul', '1', 'p10rack')
else:
tiprack = labware.load('opentrons-tiprack-300ul', '1', 'p300rack')
if pip_name[0] != 'p10' and well_volume < 5:
raise Exception("Cannot transfer volume this small without p10.")
if pip_name[0] == 'p30' and well_volume < 30:
raise Exception("Cannot transfer volume this small with p300.")
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])
if pip_name[1] == 'Multi':
alternating_wells = []
for column in plate.cols(plate_starting_column, to='24'):
alternating_wells.append(column.wells('A'))
alternating_wells.append(column.wells('B'))
dests = alternating_wells[:number_of_columns_to_fill * 2]
else:
dests = plate.cols(plate_starting_column,
length=number_of_columns_to_fill)
pipette.distribute(well_volume,
trough.wells(reagent_well),
dests,
mix_before=(mix_times, pipette.max_volume))
'y': 40,
'z': 125,
'a': 125,
'b': 50,
'c': 50
}
robot.head_speed(combined_speed=max(max_speed_per_axis.values()), **max_speed_per_axis)
# Labware
tiprack = labware.load('opentrons_96_tiprack_300ul', slot='10')
reservoir = labware.load('usascientific_12_reservoir_22ml', slot='11')
plate = labware.load('corning_96_wellplate_360ul_flat', slot='8')
# Pipette
pipette = instruments.P50_Multi(mount='right', tip_racks=[tiprack])
# 1st print: Letter 'S'
pipette.pick_up_tip(tiprack.wells('A1'))
pipette.aspirate(50, reservoir.cols('1'))
pipette.dispense(5, plate.wells('A1'))
CALIBRATION_CROSS_COORDS = [161.37, 141.0, -2.0]
pipette.move_to((robot.deck, CALIBRATION_CROSS_COORDS))
CALIBRATION_CROSS_COORDS = [159.37, 145.0, -2.0]
pipette.move_to((robot.deck, CALIBRATION_CROSS_COORDS))
CALIBRATION_CROSS_COORDS = [154.37, 147.0, -2.0]
pipette.move_to((robot.deck, CALIBRATION_CROSS_COORDS))
diameter=9,
depth=40,
volume=200000)
Storage = labware.load(storage_name, slot=5)
plate_samples = labware.load('96-flat', slot=2)
plate_buffers = labware.load('96-flat', slot=3)
trash_liquid = labware.load('corning_384_wellplate_112ul_flat', slot=4)
Eppendorf = labware.load('Eppendorf_Samples', slot=10)
tiprack_l = labware.load('opentrons-tiprack-300ul', slot=9)
tiprack_r = labware.load('opentrons-tiprack-10ul', slot=6)
# [2] Pipettes
pipette_l = instruments.P300_Single(mount='left', tip_racks=[tiprack_l])
pipette_r = instruments.P50_Multi(mount='right')
flow_rate = {'a_l': 300, 'd_l': 10, 'a_r': 50, 'd_r': 50}
multi_tip_loc = ['E', 1]
def pick_up_multi():
global multi_tip_loc
pipette_r.pick_up_tip(
location=tiprack_r.wells(''.join(map(str, multi_tip_loc))))
if multi_tip_loc[1] == 12:
if multi_tip_loc[0] == 'A':
'author': 'Opentrons <*****@*****.**>',
'source': 'Protocol Library'
}
tiprack = labware.load('tiprack-200ul', '7')
tiprack2 = labware.load('tiprack-200ul', '11')
trash = robot.fixed_trash
trough = labware.load('trough-12row', '8')
plate = labware.load('96-PCR-flat', '9')
tuberack = labware.load('tube-rack-2ml', '10')
# Needs to have individual constructor
m50 = instruments.P50_Multi(
tip_racks=[tiprack, tiprack2],
mount="left")
p200 = instruments.P300_Single(
tip_racks=[tiprack],
mount="right"
)
# dispense 6 standards from tube racks (A1, B1, C1, D1, A2, B2)
# to first two rows of 96 well plate (duplicates, A1/A2, B1/B2 etc.)
for i in range(6):
p200.distribute(
25, tuberack.wells(i), plate.rows(i)[0:2])
# dispense 4 samples from tube rack (C2, D2, A3, B3)
# to row 3 of 96 well plate (duplicates, A3/B3, C3/D3, E3/F3, G3/H3)
diameter = 2, # Diameter (mm) of each well on the plate
depth = 10, # Depth (mm) of each well on the plate
volume = 50)
plate_samples = labware.load('96-flat', slot ='11') # Samples TODO Eppendorf 1.5
tiprack = labware.load('tiprack-10ul', slot ='6') # Tipracks
magnetic = modules.load('magdeck', slot ='4') # Magnetic Deck
plate_magnet = labware.load('96-flat', slot ='4', share = True) # Magnetic Deck plate
thermocycler = NinjaPCR(slot='10', simulating = robot.is_simulating()) # Ninja-PCR
thermic_module = labware.load(thermic_name, slot ='1') # Auxiliar thermic module
trash = labware.load('trash-box', slot = '12', share = True) # Trash
# [2] Pipettes
pipette_l = instruments.P300_Single(mount = 'left', tip_racks=[tiprack], trash_container = trash)
pipette_r = instruments.P50_Multi(mount = 'right', tip_racks=[tiprack], trash_container = trash)
pipette_l.set_flow_rate(aspirate = 50, dispense = 100)
pipette_r.set_flow_rate(aspirate = 50, dispense = 100)
# [3] Commands
def execute_move(function, args):
# For the simulation
if robot.is_simulating():
function(*args)
return
# When the robot starts moving light goes on and
# button turns red
robot._driver.turn_on_rail_lights()
def run_custom_protocol(number_of_mixing: int = 10, mix_rate: int = 1):
# LABWARE
# Define Pipettes
p300_single = instruments.P300_Single(mount='right', tip_racks=[tiprack1])
p50_multi = instruments.P50_Multi(mount='left', tip_racks=[tiprack2])
# Define master mix reagents
formamide = tube_rack_2ml.wells('A1')
dntp = small_reagent_plate.wells('A1')
sybr = small_reagent_plate.wells('B1')
taq = small_reagent_plate.wells('C1')
primers = [
well.bottom() for well in small_reagent_plate.wells(
'A3', 'A4', 'A5', 'C3', 'C4', 'C5', 'E3', 'E4', 'E5')
]
# cDNA
standards = small_reagent_plate.columns('12')
samples = small_reagent_plate.columns('10')
# Initial buffer mix in tube (1413.8 uL)
buffer_mix_tube = tube_rack_15ml.wells(
'A1') # Water, Trehalose, qPCR Buffer
high_vol_buffer_mix_tube = (buffer_mix_tube,
buffer_mix_tube.from_center(x=0, y=0, z=-0.5))
# Separate master mix tubes for each primer
master_mix_tubes = [
well.bottom() for well in tube_rack_2ml.wells(
'A3', 'A4', 'A5', 'B3', 'B4', 'B5', 'C3', 'C4', 'C5')
]
sample_columns = ['1', '2', '3', '5', '6', '7', '9', '10', '11']
standard_columns = ['4', '8', '12']
######################## PROTOCOL ##################################################################################
# Make master mix
p300_single.distribute(FORMAMIDE_VOL,
formamide,
high_vol_buffer_mix_tube,
disposal_vol=0,
blow_out=True)
p300_single.distribute(DNTP_VOL,
dntp,
high_vol_buffer_mix_tube,
disposal_vol=0,
blow_out=True)
p300_single.distribute(SYBR_VOL,
sybr,
high_vol_buffer_mix_tube,
disposal_vol=0,
blow_out=True)
# Add taq last and mix
p300_single.pick_up_tip()
p300_single.transfer(TAQ_VOL,
taq,
high_vol_buffer_mix_tube,
disposal_vol=0,
blow_out=True,
new_tip='never')
p300_single.mix(15, 300, rate=mix_rate, location=high_vol_buffer_mix_tube)
p300_single.drop_tip()
# Distribute master mix to separate master mix tubes
p300_single.distribute(MASTER_MIX_TUBE_VOL,
buffer_mix_tube,
master_mix_tubes,
disposal_vol=0,
blow_out=True)
# Add primers to master mix tubes
for primer, mm_tube in zip(primers, master_mix_tubes):
p50_multi.pick_up_tip(location=tiprack2_tracker.next_tip(), presses=1)
p50_multi.transfer(PRIMER_VOL,
primer,
mm_tube,
disposal_vol=0,
blow_out=True,
new_tip='never')
p50_multi.mix(number_of_mixing, 50, rate=mix_rate)
p50_multi.drop_tip()
def multiwell_location_offset(plates,
x=0.0,
y=0.0,
z=0.0,
start_column=None,
end_column=None,
columns=None):
from opentrons.legacy_api.containers.placeable import Container
if isinstance(plates, Container):
plates = list(plates)
if columns is not None:
return [(col[0], col[0].from_center(x=x, y=y, z=z))
for plate in plates for col in plate.columns(columns)]
elif start_column and end_column:
return [(col[0], col[0].from_center(x=x, y=y, z=z))
for plate in plates
for col in plate.columns(start_column, to=end_column)]
# Mix cDNA samples then distribute to 96-well plates
p50_multi.pick_up_tip(location=tiprack2_tracker.next_tip(n=8))
p50_multi.mix(number_of_mixing, 50, samples, rate=mix_rate)
p50_multi.distribute(CDNA_VOL,
samples,
multiwell_location_offset(x=0,
y=0.03,
z=-1.5,
plates=plates,
columns=sample_columns),
disposal_vol=3,
new_tips='never')
# Mix Standards then distribute to 96-well plates
p50_multi.pick_up_tip(location=tiprack2_tracker.next_tip(n=8))
p50_multi.mix(number_of_mixing, 50, standards, rate=mix_rate)
p50_multi.distribute(CDNA_VOL,
standards,
multiwell_location_offset(x=0,
y=0.03,
z=-1.5,
plates=plates,
columns=standard_columns),
disposal_vol=3,
new_tips='never')
plates = []
plates.extend([pcr_plate1] * 3)
plates.extend([pcr_plate2] * 3)
plates.extend([pcr_plate3] * 3)
for master_mix, column in zip(master_mix_tubes,
list(range(1, 12 + 1, 4)) * 3):
first_column = str(column)
last_column = str(column + 3)
p50_multi.pick_up_tip(location=tiprack2_tracker.next_tip(), presses=1)
p50_multi.distribute(MASTER_MIX_VOL,
master_mix,
multiwell_location_offset(
x=0,
y=0.1,
z=0.5,
plates=plates,
start_column=first_column,
end_column=last_column),
disposal_vol=0,
blow_out=True)
magdeck = modules.load('MagDeck', slot=4)
md_lab = labware.load(magdeck_plate, slot=4, share=True)
tiprack = labware.load('opentrons-tiprack-300ul', slot=6)
tiprack2 = labware.load('opentrons-tiprack-300ul', slot=11)
tiprack3 = labware.load('opentrons-tiprack-300ul', slot=9)
tiprack_m = labware.load('opentrons-tiprack-10ul', slot=8)
trash_liquid = labware.load('corning_384_wellplate_112ul_flat', slot = 3)
samples = labware.load('Eppendorf_Samples', slot=7)
samples2 = labware.load('96-flat', slot=5)
tempdeck = NinjaTempDeck(slot=1, simulating = True)
td_lab = tempdeck.labware
# Pipette
pipette = instruments.P300_Single(mount='left', tip_racks=[tiprack, tiprack2, tiprack3])
pipette_multi = instruments.P50_Multi(mount='right', tip_racks=[tiprack_m])
modules.magdeck.LABWARE_ENGAGE_HEIGHT[magdeck_plate] = 30
# START RUN ························································································
pipette.set_flow_rate(aspirate=15,dispense=15)
robot._driver.turn_on_rail_lights()
#tempdeck.set_temp(temp=4)
# (-1) Move 100ul from A3 to each of the magdeck
rates={'mix_asp_rate':300, 'mix_dis_rate':300, 'tr_asp_rate':300, 'tr_dis_rate':300}
pipette.pick_up_tip()
custom_pick(100, td_lab.wells('A1'), md_lab.wells('A1'), blow_out=True, reuse_tip=True, mix_before=True, **rates)
custom_pick(100, td_lab.wells('A1'), md_lab.wells('A2'), blow_out=True, reuse_tip=True, mix_before=True, **rates)
def run_custom_protocol(
pipette_type: StringSelection('p300-Single', 'p300-Multi', 'p50-Single',
'p50-Multi') = 'p300-Multi',
dilution_factor: float = 1.5,
num_of_dilutions: int = 10,
total_mixing_volume: float = 200.0,
tip_use_strategy: StringSelection('use one tip',
'new tip each time') = 'use one tip'):
pip_name = pipette_type.split('-')[1]
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 == '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)
new_tip = 'never' if tip_use_strategy == 'use one tip' else 'always'
transfer_volume = total_mixing_volume / dilution_factor
diluent_volume = total_mixing_volume - transfer_volume
if pip_name == 'Multi':
# Distribute diluent across the plate to the the number of samples
# And add diluent to one column after the number of samples for a blank
pipette.distribute(diluent_volume, trough['A1'],
plate.cols('2', length=(num_of_dilutions)))
# Dilution of samples across the 96-well flat bottom plate
pipette.pick_up_tip(presses=3, increment=1)
pipette.transfer(transfer_volume,
plate.columns('1', to=(num_of_dilutions - 1)),
plate.columns('2', to=num_of_dilutions),
mix_after=(3, total_mixing_volume / 2),
new_tip=new_tip)
# Remove transfer volume from the last column of the dilution
pipette.transfer(transfer_volume,
plate.columns(num_of_dilutions),
liquid_trash,
new_tip=new_tip)
if new_tip == 'never':
pipette.drop_tip()
else:
# Distribute diluent across the plate to the the number of samples
# And add diluent to one column after the number of samples for a blank
for col in plate.cols('2', length=(num_of_dilutions)):
pipette.distribute(diluent_volume, trough['A1'], col)
for row in plate.rows():
if new_tip == 'never':
pipette.pick_up_tip()
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),
new_tip=new_tip)
pipette.transfer(transfer_volume,
row.wells(num_of_dilutions),
liquid_trash,
new_tip=new_tip)
if new_tip == 'never':
pipette.drop_tip()
def run_custom_protocol(number_of_mixing: int = 5, mix_rate: int = 6):
# LABWARE
# Define Pipettes
p300_single = instruments.P300_Single(mount='right', tip_racks=[tiprack1])
p50_multi = instruments.P50_Multi(mount='left', tip_racks=[tiprack2])
# Define master mix reagents
formamide = tube_rack_2ml.wells('A1')
dntp = small_reagent_plate.wells('A1')
sybr = small_reagent_plate.wells('B1')
taq = small_reagent_plate.wells('C1')
primers = [
well.bottom() for well in small_reagent_plate.wells(
'A3', 'A4', 'A5', 'A6', 'A7', 'A8')
]
# cDNA
samples = small_reagent_plate.columns('12')
# Initial buffer mix in tube (1413.8 uL)
buffer_mix_tube = tube_rack_2ml.wells(
'A2') # Water, Trehalose, qPCR Buffer
high_vol_buffer_mix_tube = (buffer_mix_tube,
buffer_mix_tube.from_center(x=0, y=0, z=0))
# Separate master mix tubes for each primer
master_mix_tubes = [
well.bottom()
for well in tube_rack_2ml.wells('D1', 'D2', 'D3', 'D4', 'D5', 'C5')
]
# PROTOCOL
# Set temp of tempdeck first
tempdeck.set_temperature(4)
# Make master mix
p300_single.distribute(FORMAMIDE_VOL,
formamide,
high_vol_buffer_mix_tube,
disposal_vol=0,
blow_out=True)
p300_single.distribute(DNTP_VOL,
dntp,
high_vol_buffer_mix_tube,
disposal_vol=0,
blow_out=True)
p300_single.distribute(SYBR_VOL,
sybr,
high_vol_buffer_mix_tube,
disposal_vol=0,
blow_out=True)
# Add taq last and mix
p300_single.pick_up_tip()
p300_single.transfer(TAQ_VOL,
taq,
high_vol_buffer_mix_tube,
disposal_vol=0,
blow_out=True,
new_tip='never')
p300_single.mix(15, 300, rate=mix_rate)
p300_single.drop_tip()
# Distribute master mix to separate master mix tubes
p300_single.distribute(MASTER_MIX_TUBE_VOL,
buffer_mix_tube,
master_mix_tubes,
disposal_vol=0,
blow_out=True)
# Add primers to master mix tubes
for primer, mm_tube in zip(primers, master_mix_tubes):
p50_multi.pick_up_tip(location=tiprack2_tracker.next_tip())
p50_multi.transfer(PRIMER_VOL,
primer,
mm_tube,
disposal_vol=0,
blow_out=True,
new_tip='never')
p50_multi.mix(number_of_mixing, 50, rate=mix_rate)
p50_multi.drop_tip()
def cdna_dispense_location(plate, start_column, end_column):
return [(col[0], col[0].from_center(x=0, y=0.03, z=-1.5))
for col in plate.columns(start_column, to=end_column)]
# Mix cDNA samples then distribute to 96-well plate
p50_multi.pick_up_tip(location=tiprack2_tracker.next_tip(n=8))
p50_multi.mix(number_of_mixing, 50, samples, rate=mix_rate)
p50_multi.distribute(CDNA_VOL,
samples,
cdna_dispense_location(pcr_plate1, '1', '12'),
disposal_vol=3,
blow_out=True)
def master_mix_dispense_location(plate, begin_col, end_col):
return [(well, well.from_center(x=0, y=0.1, z=0.5))
for col in plate.columns(begin_col, to=end_col)
for well in col]
for master_mix, column in zip(master_mix_tubes, list(range(1, 12 + 1, 2))):
first_column = str(column)
second_column = str(column + 1)
p50_multi.pick_up_tip(location=tiprack2_tracker.next_tip())
p50_multi.distribute(MASTER_MIX_VOL,
master_mix,
master_mix_dispense_location(
pcr_plate1, first_column, second_column),
disposal_vol=0,
blow_out=True)
'author': 'Opentrons <*****@*****.**>',
'source': 'Protocol Library'
}
source_slot = '6'
dest_slots = ['1', '2', '3', '4', '5', '7', '8', '9']
# TODO: optimize so that you only use 1 tiprack and can use an extra container,
# when you have 96 well source + dest (384 needs 2x tipracks, 96 needs just 1x)
tip_slots = ['10', '11']
tip_racks = [labware.load('tiprack-200ul', slot) for slot in tip_slots]
# TODO: customizable pipette vol
p50multi = instruments.P50_Multi(mount='right', tip_racks=tip_racks)
container_choices = ['96-flat', '96-PCR-tall', '96-deep-well', '384-plate']
def alternating_wells(plate, row_num):
"""
Returns list of 2 WellSeries for the 2 possible positions of an
8-channel pipette for a row in a 384 well plate.
"""
return [
plate.cols(row_num).wells(start_well, length=8, step=2)
for start_well in ['A', 'B']
]
volume=10000)
PG = labware.load('epMotion_10mL', '11', 'PG')
plate_384 = labware.load('corning_384_wellplate_112ul_flat', '2', 'plate')
sample_1 = labware.load('biorad_96_wellplate_200ul_pcr', '3')
sample_2 = labware.load('biorad_96_wellplate_200ul_pcr', '6')
tiprack_200 = labware.load('tiprack-200ul', '1', 'p200rack')
tiprack_10_1 = labware.load('opentrons_96_tiprack_10ul', '4')
tiprack_10_2 = labware.load('opentrons_96_tiprack_10ul', '7')
P10_8 = instruments.P10_Multi(mount='left',
tip_racks=[tiprack_10_1, tiprack_10_2])
P50_8 = instruments.P50_Multi(mount='right', tip_racks=[tiprack_200])
alternating_wells = []
for column in plate_384.cols():
alternating_wells.append(column.wells('A'))
alternating_wells.append(column.wells('B'))
##Transfer the Picogreen
while assay_start < (assay_end - 6):
P50_8.pick_up_tip()
P50_8.transfer(19,
PG.wells('A1'),
alternating_wells[assay_start:assay_start + 6],
new_tip='never')
P50_8.drop_tip()
assay_start = assay_start + 6
def run_custom_protocol(
number_of_destination_plates: int = 5,
volume_of_mineral_oil_in_ul: float = 15,
distance_from_oil_surface_to_opening_of_trough_in_mm: float = 10):
# check for labware space
if number_of_destination_plates > 5:
raise Exception('Please specify 5 or fewer destination plates.')
# remaining labware
dest_plates = [
labware.load(plate_name, str(slot))
for slot in range(4, 4 + number_of_destination_plates)
]
tips50 = labware.load(tips50_name, str(4 + number_of_destination_plates))
tips10 = [
labware.load(tips10_name, str(slot))
for slot in range(5 + number_of_destination_plates, 12)
]
# pipettes
m10 = instruments.P10_Multi(mount='right', tip_racks=tips10)
m50 = instruments.P50_Multi(mount='left', tip_racks=[tips50])
all_dests = [well for plate in dest_plates for well in plate.rows('A')]
# variables for mineral oil height track
h_oil = -(distance_from_oil_surface_to_opening_of_trough_in_mm + 5)
### length of the trough to work out total volume
length = 71.4
width = dest_plates[0].wells(0).properties['diameter']
def oil_height_track():
nonlocal h_oil
dh = volume_of_mineral_oil_in_ul / (
length * width
) # should this be 8*volume_of_mineral_oil_in_ul for a trough?
h_oil -= dh
# transfer mineral oil
m50.set_flow_rate(aspirate=5, dispense=10)
t_count = 0
m50.pick_up_tip()
for d in all_dests:
# prevent oil buildup in the same tip (replace after each plate fill)
if t_count == 12:
m50.drop_tip()
m50.pick_up_tip()
t_count = 1
oil_height_track()
m50.aspirate(volume_of_mineral_oil_in_ul, mineral_oil.top(h_oil))
m50.delay(seconds=5)
m50.dispense(d.bottom(5))
t_count += 1
m50.blow_out()
m50.drop_tip()
# distribute PCR master mix
m50.set_flow_rate(aspirate=25, dispense=50)
m50.pick_up_tip()
for d in all_dests:
m50.transfer(18, master_mix, d.top(), blow_out=True, new_tip='never')
m50.drop_tip()
# forward primer distribution
for ind, primer in enumerate(forward_primer.rows('A')):
dests = [plate.rows('A')[ind] for plate in dest_plates]
m10.distribute(1, primer, dests)
# reverse primer distribution
for ind, primer in enumerate(reverse_primer.rows('A')):
dests = [plate.rows('A')[ind] for plate in dest_plates]
m10.distribute(1, primer, dests)
def run_custom_protocol(pipette_type: StringSelection(
'p300_Multi', 'p50_Single', 'p300_Single', 'p1000_Single', 'p10_Multi',
'p50_Multi', 'p10_Single') = 'p300_Multi',
pipette_mount: StringSelection('left',
'right') = 'left',
sample_number: int = 24,
sample_volume: float = 20,
bead_ratio: float = 1.8,
elution_buffer_volume: float = 200,
incubation_time: float = 1,
settling_time: float = 1,
drying_time: float = 5):
total_tips = sample_number * 8
tiprack_num = total_tips // 96 + (1 if total_tips % 96 > 0 else 0)
slots = ['3', '5', '6', '7', '8', '9', '10', '11'][:tiprack_num]
if pipette_type == 'p1000_Single':
tipracks = [labware.load('tiprack-1000ul', slot) for slot in slots]
pipette = instruments.P1000_Single(mount=pipette_mount,
tip_racks=tipracks)
elif pipette_type == 'p300_Single':
tipracks = [labware.load('tiprack-200ul', slot) for slot in slots]
pipette = instruments.P300_Single(mount=pipette_mount,
tip_racks=tipracks)
elif pipette_type == 'p50_Single':
tipracks = [labware.load('tiprack-200ul', slot) for slot in slots]
pipette = instruments.P50_Single(mount=pipette_mount,
tip_racks=tipracks)
elif pipette_type == 'p10_Single':
tipracks = [labware.load('tiprack-10ul', slot) for slot in slots]
pipette = instruments.P10_Single(mount=pipette_mount,
tip_racks=tipracks)
elif pipette_type == 'p10_Multi':
tipracks = [labware.load('tiprack-10ul', slot) for slot in slots]
pipette = instruments.P10_Multi(mount=pipette_mount,
tip_racks=tipracks)
elif pipette_type == 'p50_Multi':
tipracks = [labware.load('tiprack-200ul', slot) for slot in slots]
pipette = instruments.P50_Multi(mount=pipette_mount,
tip_racks=tipracks)
elif pipette_type == 'p300_Multi':
tipracks = [labware.load('tiprack-200ul', slot) for slot in slots]
pipette = instruments.P300_Multi(mount=pipette_mount,
tip_racks=tipracks)
mode = pipette_type.split('_')[1]
if mode == 'Single':
if sample_number <= 5:
reagent_container = labware.load('tube-rack-2ml', '4')
liquid_waste = labware.load('trough-12row', '5').wells('A12')
else:
reagent_container = labware.load('trough-12row', '4')
liquid_waste = reagent_container.wells('A12')
samples = [well for well in mag_plate.wells()[:sample_number]]
output = [well for well in output_plate.wells()[:sample_number]]
else:
reagent_container = labware.load('trough-12row', '4')
liquid_waste = reagent_container.wells('A12')
col_num = sample_number // 8 + (1 if sample_number % 8 > 0 else 0)
samples = [col for col in mag_plate.cols()[:col_num]]
output = [col for col in output_plate.cols()[:col_num]]
# Define reagents and liquid waste
beads = reagent_container.wells(0)
ethanol = reagent_container.wells(1)
elution_buffer = reagent_container.wells(2)
# Define bead and mix volume
bead_volume = sample_volume * bead_ratio
if bead_volume / 2 > pipette.max_volume:
mix_vol = pipette.max_volume
else:
mix_vol = bead_volume / 2
total_vol = bead_volume + sample_volume + 5
# Mix beads and PCR samples
for target in samples:
pipette.pick_up_tip()
pipette.mix(5, mix_vol, beads)
pipette.transfer(bead_volume, beads, target, new_tip='never')
pipette.mix(10, mix_vol, target)
pipette.blow_out()
pipette.drop_tip()
# Incubate beads and PCR product at RT for 5 minutes
pipette.delay(minutes=incubation_time)
# Engagae MagDeck and incubate
mag_deck.engage()
pipette.delay(minutes=settling_time)
# Remove supernatant from magnetic beads
pipette.set_flow_rate(aspirate=25, dispense=150)
for target in samples:
pipette.transfer(total_vol, target, liquid_waste, blow_out=True)
# Wash beads twice with 70% ethanol
air_vol = pipette.max_volume * 0.1
for cycle in range(2):
for target in samples:
pipette.transfer(200,
ethanol,
target,
air_gap=air_vol,
new_tip='once')
pipette.delay(minutes=1)
for target in samples:
pipette.transfer(200, target, liquid_waste, air_gap=air_vol)
# Dry at RT
pipette.delay(minutes=drying_time)
# Disengage MagDeck
mag_deck.disengage()
# Mix beads with elution buffer
if elution_buffer_volume / 2 > pipette.max_volume:
mix_vol = pipette.max_volume
else:
mix_vol = elution_buffer_volume / 2
for target in samples:
pipette.pick_up_tip()
pipette.transfer(elution_buffer_volume,
elution_buffer,
target,
new_tip='never')
pipette.mix(20, mix_vol, target)
pipette.drop_tip()
# Incubate at RT for 3 minutes
pipette.delay(minutes=5)
# Engagae MagDeck for 1 minute and remain engaged for DNA elution
mag_deck.engage()
pipette.delay(minutes=settling_time)
# Transfer clean PCR product to a new well
for target, dest in zip(samples, output):
pipette.transfer(elution_buffer_volume, target, dest, blow_out=True)
def run_custom_protocol(number_of_mixing: int = 10, mix_rate: int = 1):
# LABWARE
tempdeck = modules.load('tempdeck', 10)
tube_rack_2ml = labware.load('opentrons-aluminum-block-2ml-eppendorf', '7')
tube_rack_15ml = labware.load('opentrons-tuberack-15_50ml', '3')
small_reagent_plate = labware.load('PCR-strip-tall', '8')
pcr_plate1 = labware.load('96-flat', '4')
pcr_plate2 = labware.load('96-flat', '5')
pcr_plate3 = labware.load('opentrons-aluminum-block-96-PCR-plate',
'10',
share=True)
plates = [pcr_plate1, pcr_plate2, pcr_plate3]
tiprack1 = labware.load('opentrons-tiprack-300ul', '11')
tiprack2 = labware.load('opentrons-tiprack-300ul', '9')
tiprack2_tracker = TipTracker(tiprack=tiprack2)
WELLS = 370
TOTAL_VOL = 20.0
CDNA_VOL = 5.0
WATER_PER_WELL = 12.115 - CDNA_VOL
assert WATER_PER_WELL >= 0, "Water per well is less than 0"
TREH_PER_WELL = 4.0
BUFFER_PER_WELL = 2
FORM_PER_WELL = 0.5
DNTP_PER_WELL = 0.16
SYBR_PER_WELL = 0.1
TAQ_PER_WELL = 0.125
PRIMER_MIX_PER_WELL = 1.0
FORMAMIDE_VOL = FORM_PER_WELL * WELLS
DNTP_VOL = DNTP_PER_WELL * WELLS
SYBR_VOL = SYBR_PER_WELL * WELLS
TAQ_VOL = TAQ_PER_WELL * WELLS
MASTER_MIX_TUBE_WELLS = 38.0
MASTER_MIX_TUBE_VOL = (WATER_PER_WELL + TREH_PER_WELL + BUFFER_PER_WELL +
FORM_PER_WELL + DNTP_PER_WELL + SYBR_PER_WELL +
TAQ_PER_WELL) * MASTER_MIX_TUBE_WELLS
PRIMER_VOL = PRIMER_MIX_PER_WELL * MASTER_MIX_TUBE_WELLS
MASTER_MIX_VOL = TOTAL_VOL - CDNA_VOL
# Define Pipettes
p300_single = instruments.P300_Single(mount='right', tip_racks=[tiprack1])
p50_multi = instruments.P50_Multi(mount='left', tip_racks=[tiprack2])
# Define master mix reagents
formamide = tube_rack_2ml.wells('A1')
dntp = small_reagent_plate.wells('A1')
sybr = small_reagent_plate.wells('B1')
taq = small_reagent_plate.wells('C1')
primers = [
well.bottom() for well in small_reagent_plate.wells(
'A3', 'A4', 'A5', 'C3', 'C4', 'C5', 'E3', 'E4', 'E5')
]
# cDNA
standards = small_reagent_plate.columns('12')
samples = small_reagent_plate.columns('10')
# Initial buffer mix in tube (1413.8 uL)
buffer_mix_tube = tube_rack_15ml.wells(
'A1') # Water, Trehalose, qPCR Buffer
high_vol_buffer_mix_tube = (buffer_mix_tube,
buffer_mix_tube.from_center(x=0, y=0, z=-0.5))
# Separate master mix tubes for each primer
master_mix_tubes = [
well.bottom() for well in tube_rack_2ml.wells(
'A3', 'A4', 'A5', 'B3', 'B4', 'B5', 'C3', 'C4', 'C5')
]
sample_columns = ['1', '2', '3', '5', '6', '7', '9', '10', '11']
standard_columns = ['4', '8', '12']
######################## PROTOCOL ##################################################################################
tempdeck.set_temperature(4)
# Make master mix
p300_single.distribute(FORMAMIDE_VOL,
formamide,
high_vol_buffer_mix_tube,
disposal_vol=0,
blow_out=True)
p300_single.distribute(DNTP_VOL,
dntp,
high_vol_buffer_mix_tube,
disposal_vol=0,
blow_out=True)
p300_single.distribute(SYBR_VOL,
sybr,
high_vol_buffer_mix_tube,
disposal_vol=0,
blow_out=True)
# Add taq last and mix
p300_single.pick_up_tip()
p300_single.transfer(TAQ_VOL,
taq,
high_vol_buffer_mix_tube,
disposal_vol=0,
blow_out=True,
new_tip='never')
p300_single.mix(15, 300, rate=mix_rate, location=high_vol_buffer_mix_tube)
p300_single.drop_tip()
# Distribute master mix to separate master mix tubes
p300_single.distribute(MASTER_MIX_TUBE_VOL,
buffer_mix_tube,
master_mix_tubes,
disposal_vol=0,
blow_out=True)
# Add primers to master mix tubes
for primer, mm_tube in zip(primers, master_mix_tubes):
p50_multi.pick_up_tip(location=tiprack2_tracker.next_tip(), presses=1)
p50_multi.transfer(PRIMER_VOL,
primer,
mm_tube,
disposal_vol=0,
blow_out=True,
new_tip='never')
p50_multi.mix(number_of_mixing, 50, rate=mix_rate)
p50_multi.drop_tip()
def multiwell_location_offset(plates,
x=0.0,
y=0.0,
z=0.0,
start_column=None,
end_column=None,
columns=None):
from opentrons.legacy_api.containers.placeable import Container
if isinstance(plates, Container):
plates = list(plates)
if columns is not None:
return [(col[0], col[0].from_center(x=x, y=y, z=z))
for plate in plates for col in plate.columns(columns)]
elif start_column and end_column:
return [(col[0], col[0].from_center(x=x, y=y, z=z))
for plate in plates
for col in plate.columns(start_column, to=end_column)]
# Mix cDNA samples then distribute to 96-well plates
p50_multi.pick_up_tip(location=tiprack2_tracker.next_tip(n=8))
p50_multi.mix(number_of_mixing, 50, samples, rate=mix_rate)
p50_multi.distribute(CDNA_VOL,
samples,
multiwell_location_offset(x=0,
y=0.03,
z=-1.5,
plates=plates,
columns=sample_columns),
disposal_vol=3,
new_tips='never')
# Mix Standards then distribute to 96-well plates
p50_multi.pick_up_tip(location=tiprack2_tracker.next_tip(n=8))
p50_multi.mix(number_of_mixing, 50, standards, rate=mix_rate)
p50_multi.distribute(CDNA_VOL,
standards,
multiwell_location_offset(x=0,
y=0.03,
z=-1.5,
plates=plates,
columns=standard_columns),
disposal_vol=3,
new_tips='never')
plates = []
plates.extend([pcr_plate1] * 3)
plates.extend([pcr_plate2] * 3)
plates.extend([pcr_plate3] * 3)
for master_mix, column in zip(master_mix_tubes,
list(range(1, 12 + 1, 4)) * 3):
first_column = str(column)
last_column = str(column + 3)
p50_multi.pick_up_tip(location=tiprack2_tracker.next_tip(), presses=1)
p50_multi.distribute(MASTER_MIX_VOL,
master_mix,
multiwell_location_offset(
x=0,
y=0.1,
z=0.5,
plates=plates,
start_column=first_column,
end_column=last_column),
disposal_vol=0,
blow_out=True)
# imports
from opentrons import labware, instruments
# labware
tiprack_type = 'tiprack-200ul-VWR'
rxn_plate = labware.load('384-corning-3702BC', '8')
tiprack_p300m = [labware.load(tiprack_type, slot_p300m)
for slot_p300m in ['9']]
tiprack_p50m = [labware.load(tiprack_type, slot_p50m)
for slot_p50m in ['10','7','4','1']]
reagent_trough = labware.load('trough-12row','11')
# instruments
p50m = instruments.P50_Multi(
mount="right",
tip_racks=tiprack_p50m)
if tiprack_type == 'tiprack-200ul-VWR':
p300m = instruments.P300_Multi(
mount="left",
tip_racks=tiprack_p300m,
min_volume=10,
max_volume=200)
elif tiprack_type == 'opentrons-tiprack-300ul':
p300m = instruments.P300_Multi(
mount="left",
tip_racks=tiprack_p300m,
min_volume=30,
max_volume=300)
def run_custom_protocol(
transfer_volume_nitrilase: float=10,
plate_buffers = labware.load('96-flat', slot=6)
td_lab = labware.load(ninja_name, slot=1)
Eppendorf = labware.load('Eppendorf_Samples', slot=4)
tiprack_l = labware.load('opentrons-tiprack-300ul', slot=9)
tiprack_r = labware.load('opentrons-tiprack-300ul', slot=5)
# Note: tiprack_r is actually an 'opentrons-tiprack-300ul', but its name must be
# different than tiprack_l's to prevent calibration issues
# Use the regular trash as trash_liquid, but displace the pipette to avoid collisions
trash = robot.fixed_trash().top()
trash_liquid = trash
# [2] Pipettes
pipette_l = instruments.P300_Single(mount='left', tip_racks=[tiprack_l])
pipette_r = instruments.P50_Multi(
mount='right',
tip_racks=[tiprack_r]) #, tiprack_r2,tiprack_r3, tiprack_r4])
# Pipette flow rates: left and right, aspirate and dispense
flow_rate = {'a_l': 300, 'd_l': 300, 'a_r': 100, 'd_r': 100}
max_speed_per_axis = {'x': 600, 'y': 400, 'z': 125, 'a': 125, 'b': 40, 'c': 40}
robot.head_speed(**max_speed_per_axis)
def robot_wait_tiprack():
if not robot.is_simulating():
robot.comment("Waiting...")
set_button_light(blue=True, red=True, green=True)
while not robot._driver.read_button():
