def run(protocol: protocol_api.ProtocolContext):
## SETUP
# Load Labware
temp_mod = protocol.load_module('Temperature Module', '9')
tube_rack = protocol.load_labware("opentrons_96_aluminumblock_generic_pcr_strip_200ul", "6", label = "aluminum block")
reservoir_plate = protocol.load_labware("usascientific_12_reservoir_22ml", "8", label = 'reservoir plate')
reaction_plate = temp_mod.load_labware("corning_384_wellplate_112ul_flat", label = "reaction plate")
# Specify tip racks
tiprack1 = protocol.load_labware("opentrons_96_tiprack_10ul", '2')
tiprack2 = protocol.load_labware("opentrons_96_tiprack_300ul", '3')
# Load pipettes
p10 = protocol.load_instrument("p10_multi", "right", tip_racks = [tiprack1])
p50 = protocol.load_instrument('p50_multi', "left", tip_racks = [tiprack2])
p10.flow_rate.aspirate = 8
p10.flow_rate.dispense = 8
## PROCEDURE
# Transfer 20uL detection reagent from reservoir to reaction plate
p50.distribute(20, reservoir_plate.columns_by_name()["1"], reaction_plate.rows_by_name()["B"])
# Distribute 2uL protein from single 1.5mL tube onto odd wells starting with A1
p10.distribute(2, tube_rack.columns_by_name()["1"], [reaction_plate.rows_by_name()[row] for row in rows_reaction], new_tip = 'once')
# in the next protocol ater optimizing this one:
# transfer compounds from library plate to reaction plate
# Transfer 18 uL reaction mix to A1 of reaction plate
p50.distribute(18, reservoir_plate.columns_by_name()["2"], reaction_plate.rows_by_name()["A"])
def run(protocol: protocol_api.ProtocolContext):
# LABWARE
tiprack300 = protocol.load_labware('opentrons_96_filtertiprack_200ul', '8')
tiprack20 = protocol.load_labware('opentrons_96_filtertiprack_20ul', '9')
tempdeck = protocol.load_module(
'tempdeck', '4') #keep this on so I don't have to move it off and on
holder_1 = protocol.load_labware(
'8wstriptubesonfilterracks_96_aluminumblock_250ul', '3')
holder_2 = protocol.load_labware(
'8wstriptubesonfilterracks_96_aluminumblock_250ul', '6')
sample_plate = protocol.load_labware('bioer_96_wellplate_2200ul', '2')
# PIPETTES
p300 = protocol.load_instrument('p300_single_gen2',
'left',
tip_racks=[tiprack300])
p20 = protocol.load_instrument('p20_single_gen2',
'right',
tip_racks=[tiprack20])
# user inputs
holderList = [holder_1, holder_2]
rows = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']
# #### COMMANDS ######
# Transfer 20ul from 96w plate to 96 lyophilized tubes
for row in rows:
# p20.pick_up_tip()
for i in range(12):
j = 0 if i < 6 else 1 # need to move to next holder when columns >6
# source = sample_plate[row+str(i+1)]
print(row, i + 1, holderList[j])
def run(protocol: protocol_api.ProtocolContext):
# modify
source_1_volume = 1 # Volume of master mix to distribute into each well
source_2_volume = 1 # Volume of cDNA sample to distribute into each well
# end modify
# labware
single_tiprack = protocol.load_labware('opentrons_96_tiprack_300ul',
'1') # 300 uL tips
multi_tiprack = protocol.load_labware('opentrons_96_tiprack_300ul',
'2') # 300 uL tips
source_1 = protocol.load_labware(
'opentrons_24_tuberack_eppendorf_1.5ml_safelock_snapcap',
'6') # master mix in 1.5 mL tube rack
source_2 = protocol.load_labware(
'biorad_96_wellplate_200ul_pcr',
'3') # placeholder for 8-tube strip holder containing cDNA samples
destination = protocol.load_labware('biorad_96_wellplate_200ul_pcr',
'5') # 96 well plate
# pipettes
single_pipette = protocol.load_instrument('p300_single',
'left',
tip_racks=[single_tiprack])
multi_pipette = protocol.load_instrument('p300_multi',
'right',
tip_racks=[multi_tiprack])
def run(protocol: protocol_api.ProtocolContext):
# define labware and locations
tips1 = protocol.load_labware('opentrons_96_filtertiprack_20ul', '1') # 20ul filter tips on deck position 1
tips4 = protocol.load_labware('opentrons_96_filtertiprack_20ul', '4') # 20ul filter tips on deck position 4
tips7 = protocol.load_labware('opentrons_96_filtertiprack_20ul', '7') # 20ul filter tips on deck position 7
tips10 = protocol.load_labware('opentrons_96_filtertiprack_20ul', '10') # 20ul filter tips on deck position 10
tips11 = protocol.load_labware('opentrons_96_filtertiprack_20ul', '11') # 20ul filter tips on deck position 11
indexpcr = protocol.load_labware('biorad_96_wellplate_200ul_pcr', '2') # plate to conduct indexing pcr in
indexplate = protocol.load_labware('biorad_96_wellplate_200ul_pcr', '3') # skirted 96 well plate containing arrayed indexes
primarypcr = protocol.load_labware('biorad384pcrplate_384_wellplate_40ul', '6') # skirted 384 well plate of amplicons
dilutionplate = protocol.load_labware('biorad_96_wellplate_200ul_pcr', '5') # a plate to carryout 100x dilutions.
if loadwater or loadmastermix: reservoir = protocol.load_labware('usascientific_12_reservoir_22ml', '8') # reservoir with indexing mastermix (660ul) in A1 (First column) and Water (5 mL)
# define pipettes
left_pipette = protocol.load_instrument('p20_single_gen2', 'left', tip_racks=[tips1, tips4, tips7, tips10, tips11])
right_pipette = protocol.load_instrument('p20_multi_gen2', 'right', tip_racks=[tips1, tips4, tips7, tips10, tips11])
#load water into the dilution plate for a 100x dilution
if loadwater:
right_pipette.pick_up_tip() #use single set of tips
for i in range(1, 13):
for p in range(1, 5): # do 5 times for 100ul total
right_pipette.aspirate(20, reservoir['A2'])
right_pipette.dispense(20, indexpcr['A'+str(i)])
right_pipette.drop_tip()
# transfer 1µL from the cherry picked wells defined in loadings to the corresponding point on the dilution plate
if cherrypick:
loadings_parsed = loadings.splitlines()[1:] # Discard the blank first line.
for load in csv.DictReader(loadings_parsed):
left_pipette.pick_up_tip()
left_pipette.aspirate(1, primarypcr[load['PrimaryPCR_Well']])
left_pipette.dispense(1, dilutionplate[load['gDNA_Well']])
left_pipette.drop_tip()
# load the master mix into the indexing plate.
if loadmastermix:
right_pipette.pick_up_tip() # only using a single set of tips to load mastermix as is same in every well.
for i in range(1, 13):
right_pipette.aspirate(6, reservoir['A1'])
right_pipette.dispense(6, indexpcr['A'+str(i)])
right_pipette.drop_tip()
# load the indexes
if loadindex:
for i in range(1, 13):
right_pipette.pick_up_tip()
right_pipette.aspirate(4, indexplate['A'+str(i)])
right_pipette.dispense(4, indexpcr['A'+str(i)])
right_pipette.drop_tip()
# add the templates
if loadtemplate:
for i in range(1, 13):
right_pipette.pick_up_tip()
right_pipette.mix(3, 20, dilutionplate['A'+str(i)]) # mix 5x by pipetting up and down 20ul
right_pipette.aspirate(10, dilutionplate['A'+str(i)])
right_pipette.dispense(10, indexpcr['A'+str(i)])
right_pipette.drop_tip()
def run(ctx: protocol_api.ProtocolContext):
global robot
robot = ctx
# confirm door is close
if not ctx.is_simulating():
confirm_door_is_closed()
# define tips
tips1000 = [
ctx.load_labware('opentrons_96_filtertiprack_1000ul', slot)
for slot in ['3', '6']
]
tips300 = [ctx.load_labware('opentrons_96_filtertiprack_200ul', '9')]
# define pipettes
p1000 = ctx.load_instrument('p1000_single_gen2',
'left',
tip_racks=tips1000)
p300 = ctx.load_instrument('p300_single_gen2', 'right', tip_racks=tips300)
# check buffer labware type
if BUFFER_LABWARE not in BUFFER_LW_DICT:
raise Exception('Invalid BF_LABWARE. Must be one of the \
following:\nopentrons plastic 50ml tubes')
# load mastermix labware
buffer_rack = ctx.load_labware(BUFFER_LW_DICT[BUFFER_LABWARE], '10',
BUFFER_LABWARE)
# check mastermix tube labware type
if DESTINATION_LABWARE not in DESTINATION_LW_DICT:
raise Exception('Invalid DESTINATION_LABWARE. Must be one of the \
following:\nopentrons plastic 2ml tubes')
# load elution labware
dest_racks = [
ctx.load_labware(DESTINATION_LW_DICT[DESTINATION_LABWARE], slot,
'Destination tubes labware ' + str(i + 1))
for i, slot in enumerate(['4', '1', '5', '2'])
]
# setup sample sources and destinations
bf_tubes = buffer_rack.wells()[:4]
number_racks = math.ceil(NUM_SAMPLES / len(dest_racks[0].wells()))
# dest_sets is a list of lists. Each list is the destination well for each rack
# example: [[tube1,tube2,...tube24](first rack),[tube1,tube2(second rack),...]
dest_sets = [[tube for rack in dest_racks for tube in rack.wells()
][:NUM_SAMPLES][i * len(dest_racks[0].wells()):(i + 1) *
len(dest_racks[0].wells())]
for i in range(number_racks)]
# transfer buffer to tubes
for bf_tube, dests in zip(bf_tubes, dest_sets):
transfer_buffer(bf_tube, dests, VOLUME_BUFFER, p1000, tips1000)
# track final used tip
save_tip_info(p1000)
finish_run()
def run(protocol: protocol_api.ProtocolContext):
#Load Labware
temp_mod = protocol.load_module('Temperature Module', '9')
master_plate = temp_mod.load_labware(
'opentrons_24_aluminumblock_nest_1.5ml_snapcap',
label='Master solutions')
reaction_plate = protocol.load_labware("biorad_384_wellplate_50ul",
"10",
label="reaction plate")
mix_plate = protocol.load_labware("gbo_96_wellplate_323ul", "11")
tiprack1 = protocol.load_labware("opentrons_96_tiprack_20ul", '1')
tiprack2 = protocol.load_labware("opentrons_96_tiprack_20ul", '2')
tiprack3 = protocol.load_labware("opentrons_96_tiprack_20ul", '3')
#### A1 = liver lysate, A2 = Water, A3 = Cell lysate, A4 = Master Mix
##Load pipettes
p20 = protocol.load_instrument('p20_single_gen2',
"right",
tip_racks=[tiprack1])
p10 = protocol.load_instrument("p10_multi",
"left",
tip_racks=[tiprack2, tiprack3])
p20.flow_rate.aspirate = 8
p20.flow_rate.dispense = 8
#Transfer 20 uL liver lysate to A1 of mix plate and make serial dilution
p20.transfer(20,
master_plate.wells_by_name()["A1"],
reaction_plate.wells_by_name()["B1"])
def run(protocol: protocol_api.ProtocolContext):
# labware
reservoir = protocol.load_labware('usascientific_12_reservoir_22ml', '4')
well_plate = protocol.load_labware('appliedbiosystems_96_wellplate_200ul',
'5')
tiprack = protocol.load_labware('opentrons_96_tiprack_300ul', '10')
# pipettes
p300_multi = protocol.load_instrument('p300_multi',
'left',
tip_racks=[tiprack])
p50_multi = protocol.load_instrument('p50_multi', 'right')
# modify
source_well = 0 # Location of source in reservoir, 0-based indexing (left most well is 0)
volume_per_well = 200 # Amount to distribute into each well [uL]
mix_count = 5 # Number of times to mix before aspirating
mix_volume = 100 # Volume to mix before aspirating [uL]
# end modify
# commands
p300_multi.pick_up_tip()
for i in range(12):
p300_multi.distribute(volume_per_well,
reservoir.wells()[source_well],
well_plate.columns()[i],
mix_before=(mix_count, mix_volume),
new_tip='never',
disposal_volume=0)
p300_multi.return_tip()
def run(protocol: protocol_api.ProtocolContext):
#--------------CARGA DE LABWARE-----------------------------
#Definición labware muestras de entrada.
muestras_1 = protocol.load_labware(
'opentrons_24_tuberack_nest_1.5ml_screwcap', 4)
muestras_2 = protocol.load_labware(
'opentrons_24_tuberack_nest_1.5ml_screwcap', 1)
muestras_3 = protocol.load_labware(
'opentrons_24_tuberack_nest_1.5ml_screwcap', 6)
muestras_4 = protocol.load_labware(
'opentrons_24_tuberack_nest_1.5ml_screwcap', 3)
#Definición labware tubos de salida. cobas_96_deepwell_1600 'nest_96_wellplate_2ml_deep para simular'
tubos_salida = protocol.load_labware('nest_96_deepwell_2ml', 2)
#Definicion labware de reactivos !!! Cambiado opentrons_24_aluminumblock_generic_2ml_screwcap
tubos_reactivos = protocol.load_labware(
'opentrons_24_tuberack_nest_2ml_screwcap', 7)
#Definición TipRacks opentrons_96_tiprack_1000ul biotix_96_tiprack_1000ul
tipRack_1000_1 = protocol.load_labware('opentrons_96_tiprack_1000ul', 10)
tipRack_1000_2 = protocol.load_labware('opentrons_96_tiprack_1000ul', 11)
tipRack_20 = protocol.load_labware('opentrons_96_tiprack_20ul', 8)
#CONFIGURACION
configuracion = get_configuracion(
protocol, [tipRack_1000_1, tipRack_1000_2, tipRack_20])
#Definición pipetas
p1000 = protocol.load_instrument(
'p1000_single_gen2',
'left',
tip_racks=[tipRack_1000_1, tipRack_1000_2])
p20 = protocol.load_instrument('p20_single_gen2',
'right',
tip_racks=[tipRack_20])
p20.flow_rate.blow_out = 40 # !!! Configuracion velocidad blow out
#Obtener destinos, tubos de salida.
lista_destinos = get_lista_destinos(configuracion, tubos_salida)
#Obtener origenes, tubos de muestras.
lista_muestras = get_lista_muestras(
configuracion, [muestras_1, muestras_2, muestras_3, muestras_4])
#----- PROCESO ----------------------------------------------------------------------------------------------------
if configuracion['transferir_reactivos']:
for configuracion_reactivo in configuracion['reactivos']:
if configuracion_reactivo['premezclado']:
dispensar_reactivo_premezclado(p20, p1000,
configuracion_reactivo,
tubos_reactivos, lista_destinos)
else:
dispensar_reactivo(p20, configuracion_reactivo,
tubos_reactivos, lista_destinos)
if configuracion['transferir_muestras']:
transferir_muestras(p1000, configuracion, lista_muestras,
lista_destinos)
def run(protocol: protocol_api.ProtocolContext):
# labware
reservoir = protocol.load_labware('usascientific_12_reservoir_22ml', '4')
wellplate_3 = protocol.load_labware('biorad_96_wellplate_200ul_pcr', '5')
tiprack_1 = protocol.load_labware('opentrons_96_tiprack_300ul', '10')
tiprack_2 = protocol.load_labware('opentrons_96_tiprack_300ul', '11')
# pipettes
p300_multi = protocol.load_instrument('p300_multi',
'left',
tip_racks=[tiprack_1, tiprack_2])
p50_multi = protocol.load_instrument('p50_multi',
'right',
tip_racks=[tiprack_1, tiprack_2])
# modify
PBS_BSA_well = 0 # Location of PBS-BSA in reservoir, 0-based indexing (left most well is 0)
antibody_well = 5 # Location of antibody mix in reservoir, 0-based indexing (left most well is 0)
trash_well = 11 # Location of trash in reservoir, 0-based indexing (left most well is 0)
remove_volume = 100 # Volume to remove from each well of plate 3 [uL]
PBS_BSA_volume = 100 # Volume of PBS-BSA to add to each well of plate 3 [uL]
antibody_volume = 10 # Volume of antibody mix to add to each well of plate 3 [uL]
# end modify
# other values
mix_count = 3
mix_volume = 50
wellplate_3_columns = [wellplate_3.columns()[i] for i in range(0, 12)]
wellplate_3_columns_reversed = wellplate_3_columns[::-1]
# commands
# 1. Aspirate 100 uL from each well in plate 3 and discard
p300_multi.pick_up_tip()
p300_multi.transfer(remove_volume,
wellplate_3_columns_reversed,
reservoir.wells()[trash_well],
new_tip='never')
p300_multi.drop_tip()
# 2. Add 100 uL of PBS-BSA into each well of plate 3 and mix 3 times
p300_multi.pick_up_tip()
p300_multi.transfer(PBS_BSA_volume,
reservoir.wells()[PBS_BSA_well],
wellplate_3_columns_reversed,
mix_after=(mix_count, mix_volume),
new_tip='never')
p300_multi.drop_tip()
# 3. Add 10 uL of antibody mix to each well of plate 3
p50_multi.pick_up_tip()
p50_multi.transfer(antibody_volume,
reservoir.wells()[antibody_well],
wellplate_3_columns_reversed,
new_tip='never')
p50_multi.drop_tip()
def setup(protocol: protocol_api.ProtocolContext):
# TODO: figure out how to run with incomplete plates
# Should probably instantiate 3 racks
tiprack300_1 = [protocol.load_labware('opentrons_96_tiprack_300ul', '10')]
tiprack10 = [protocol.load_labware('opentrons_96_tiprack_10ul', '11')]
p50s = protocol.load_instrument('p50_single',
'left',
tip_racks=tiprack300_1)
p10s = protocol.load_instrument('p10_single', 'right', tip_racks=tiprack10)
tuberack = protocol.load_labware('biolegendantibody_24_tuberack_500ul_mm',
'4')
return p50s, p10s, tuberack, tiprack10
def run(protocol: protocol_api.ProtocolContext):
#######################################################################################################################################
## SETUP
# Load Labware
temp_mod = protocol.load_module('Temperature Module', '9')
reaction_plate = temp_mod.load_labware("corning_384_wellplate_112ul_flat", label = "reaction plate") # where the magic happens
library_1 = protocol.load_labware("greiner_96_wellplate_323ul", "8", label = "library 1") # library 'morning'
reagent_plate = protocol.load_labware("greiner_96_wellplate_323ul", "6", label = "reagents")
# Specify tip racks
tiprack1 = protocol.load_labware("opentrons_96_tiprack_10ul", '3')
tiprack2 = protocol.load_labware("opentrons_96_tiprack_300ul", '2')
# Load pipettes and set parameters
p10 = protocol.load_instrument("p10_multi", "right", tip_racks = [tiprack1])
p50 = protocol.load_instrument('p50_multi', "left", tip_racks = [tiprack2])
p10.flow_rate.aspirate = 8
p10.flow_rate.dispense = 8
# 384-well depth is 11.56 mm and max volume is 50 uL
# 20 uL is 2 mm high, tandem (middle) wall is 5.1 mm high
p10.well_bottom_clearance.dispense = 1
p50.well_bottom_clearance.dispense = 3.5
# Specify target wells
reagents = ["3", "4"] # columns on reagent plate for substrate and enzyme
# reaction
cols_reaction = list(range(1, 10)) # destination wells in reaction plate (Bio-Rad hardshell 384-well)
wells_reaction = ['A' + str(i) for i in cols_reaction]
wells_detection = ['B' + str(i) for i in cols_reaction]
# libraries
lib1_cols = [1, 2, 3, 4, 5, 6, 7, 11, 12] # library columns to aspirate compounds from
#######################################################################################################################################
## PROCEDURE
# Distribute 20uL detection reagent from reagent plate to reaction plate onto even rows
p50.distribute(20, reagent_plate.columns_by_name()["5"], [reaction_plate.wells_by_name()[i] for i in wells_detection])
# mix substrate and enzyme
p50.transfer(100, reagent_plate.columns_by_name()[reagents[0]], reagent_plate.columns_by_name()[reagents[1]], mix_after = (3, 40))
# Distribute substrate mixed with fluorescent dye and enzyme
p10.distribute(18, reagent_plate.columns_by_name()[reagents[1]], [reaction_plate.wells_by_name()[i] for i in wells_reaction],
disposal_volume = 1, blow_out = True, new_tip = 'once')
# Distribute compounds from 96-well library
# library 1 in wells A1-A12
for i in range(0, len(cols_reaction)):
p10.transfer(2, library_1.columns_by_name()[str(lib1_cols[i])], reaction_plate.wells_by_name()[wells_reaction[i]])
def run(protocol: protocol_api.ProtocolContext):
# define deck positions and labware
# tips
tiprack_300 = protocol.load_labware('opentrons_96_tiprack_300ul', 1)
tiprack_10f = protocol.load_labware('opentrons_96_filtertiprack_10ul', 2)
# plates
reagents = protocol.load_labware('usascientific_12_reservoir_22ml',
6, 'reagents')
assay = protocol.load_labware('corning_96_wellplate_360ul_flat',
5, 'assay')
samples = protocol.load_labware('biorad_96_wellplate_200ul_pcr',
4, 'samples')
# initialize pipettes
pipette_left = protocol.load_instrument('p300_multi',
'left',
tip_racks=[tiprack_300])
pipette_right = protocol.load_instrument('p10_multi',
'right',
tip_racks=[tiprack_10f])
# # home instrument
# protocol.home()
# distribute 198 µL of quantification reagent into each well of the assay
# plate. Use the same tip for the entirety of these transfers, then
# replace it in the rack.
add_buffer(pipette_left,
[reagents[x] for x in ['A1', 'A2']],
assay,
cols,
198,
13000/8,
tip=None,
tip_vol=300,
remaining=None,
drop_tip=False)
# add 2 µL of each sample to each of the wells. Mix after dispensing.
# Dispose of these tips.
pipette_right.transfer(2,
[samples[x] for x in cols],
[assay[x] for x in cols],
mix_after=(5, 10),
touch_tip=True,
trash=False,
new_tip='always')
def run(ctx: protocol_api.ProtocolContext):
# Turn on rail lights and pause program so user can load robot deck.
# ctx.set_rail_lights(True)
# ctx.pause("Load Labware onto robot deck and click resume when ready to continue")
# ctx.home()
ctx.set_rail_lights(False)
# TSV file location on OT-2
tsv_file_path = "{0}var{0}lib{0}jupyter{0}notebooks{0}ProcedureFile.tsv".format(
os.sep)
if not os.path.isfile(tsv_file_path):
# Temp TSV file location on Win10 Computers for simulation
tsv_file_path = "C:{0}Users{0}{1}{0}Documents{0}TempTSV.tsv".format(
os.sep, os.getlogin())
sample_parameters, args = Utilities.parse_sample_template(tsv_file_path)
labware_dict, left_tiprack_list, right_tiprack_list = Utilities.labware_parsing(
args, ctx)
# Pipettes
left_pipette = ctx.load_instrument(args.LeftPipette,
'left',
tip_racks=left_tiprack_list)
right_pipette = ctx.load_instrument(args.RightPipette,
'right',
tip_racks=right_tiprack_list)
# Set the location of the first tip in box.
left_pipette.starting_tip = left_tiprack_list[0].wells_by_name()[
args.LeftPipetteFirstTip]
right_pipette.starting_tip = right_tiprack_list[0].wells_by_name()[
args.RightPipetteFirstTip]
# Make sample dilutions. Calculate sample and water volumes.
sample_data_dict, aspirated_water_vol = \
process_samples(args, ctx, sample_parameters, labware_dict, left_pipette, right_pipette)
# Dispense Water
aspirated_water_vol = \
dispense_water(args, sample_data_dict, labware_dict, left_pipette, right_pipette, aspirated_water_vol)
# Dispense Samples
aspirated_water_vol = \
dispense_samples(args, sample_data_dict, left_pipette, right_pipette, aspirated_water_vol)
# Dispense PCR Reagents.
dispense_pcr_reagents(args, labware_dict, left_pipette, right_pipette,
aspirated_water_vol, sample_data_dict)
if not ctx.is_simulating():
os.remove(tsv_file_path)
def run(protocol: protocol_api.ProtocolContext):
#######################################################################################################################################
## SETUP
# Load Labware
temp_mod = protocol.load_module('Temperature Module', '9')
reaction_plate = temp_mod.load_labware("corning_384_wellplate_112ul_flat", label = "reaction plate") # where the magic happens
reagent_plate = protocol.load_labware("greiner_96_wellplate_323ul", "6", label = "reagents")
# Specify tip racks
tiprack1 = protocol.load_labware("opentrons_96_tiprack_10ul", '5')
tiprack2 = protocol.load_labware("opentrons_96_tiprack_300ul", '8')
# Load pipettes and set parameters
p10 = protocol.load_instrument("p10_multi", "right", tip_racks = [tiprack1])
p50 = protocol.load_instrument('p50_multi', "left", tip_racks = [tiprack2])
# Aspirate has the default flowrate of 150 ul/s
# p10.flow_rate.aspirate = 8 # in uL/s
# Dispense has the default flowrate of 300 ul/s
# p10.flow_rate.dispense = 8
# 384-well depth is 11.56 mm and max volume is 50 uL
# 20 uL is 2 mm high in Biorad #HSP3841,
# tandem (middle) wall is 5.1 mm high
p10.well_bottom_clearance.dispense = 1
p50.well_bottom_clearance.dispense = 3.5
# Specify source wells
reagents = ["5"] # columns on reagent plate for substrate and enzyme
#######################################################################################################################################
## PROCEDURE
# 9uL
cols_reaction = list(range(1, 5)) # destination wells in reaction plate (Bio-Rad hardshell 384-well)
wells_reaction = ['A' + str(i) for i in cols_reaction] # use the cols_reaction variable to make a new var with wells, e.g. A1, A2...
# Transfer fluorescent dye
p10.transfer(9, reagent_plate.columns_by_name()[reagents[0]], [reaction_plate.wells_by_name()[i] for i in wells_reaction],ibute
disposal_volume = 1, blow_out = True, new_tip = 'once')
# 18uL
cols_reaction = list(range(1, 5)) # destination wells in reaction plate (Bio-Rad hardshell 384-well)
wells_reaction = ['B' + str(i) for i in cols_reaction] # use the cols_reaction variable to make a new var with wells, e.g. A1, A2...
# Transfer fluorescent dye
p10.transfer(9, reagent_plate.columns_by_name()[reagents[0]], [reaction_plate.wells_by_name()[i] for i in wells_reaction],
disposal_volume = 1, blow_out = True, new_tip = 'once')
# Transfer fluorescent dye
p10.transfer(9, reagent_plate.columns_by_name()[reagents[0]], [reaction_plate.wells_by_name()[i] for i in wells_reaction],
disposal_volume = 1, blow_out = True, new_tip = 'once')
def run(ctx: protocol_api.ProtocolContext):
ctx.comment("Begin {}".format(metadata['protocolName']))
# Turn on rail lights and pause program so user can load robot deck.
# ctx.set_rail_lights(True)
# ctx.pause("Load Labware onto robot deck and click resume when ready to continue")
# ctx.home()
ctx.set_rail_lights(False)
# TSV file location on OT-2
tsv_file_path = "{0}var{0}lib{0}jupyter{0}notebooks{0}ProcedureFile.tsv".format(
os.sep)
if not os.path.isfile(tsv_file_path):
# Temp TSV file location on Win10 Computers for simulation
tsv_file_path = "C:{0}Users{0}{1}{0}Documents{0}TempTSV.tsv".format(
os.sep, os.getlogin())
sample_parameters, args = Utilities.parse_sample_template(tsv_file_path)
labware_dict, left_tiprack_list, right_tiprack_list = Utilities.labware_parsing(
args, ctx)
# Pipettes
left_pipette = ctx.load_instrument(args.LeftPipette,
'left',
tip_racks=left_tiprack_list)
right_pipette = ctx.load_instrument(args.RightPipette,
'right',
tip_racks=right_tiprack_list)
# Set the location of the first tip in box.
with suppress(IndexError):
left_pipette.starting_tip = left_tiprack_list[0].wells_by_name()[
args.LeftPipetteFirstTip]
with suppress(IndexError):
right_pipette.starting_tip = right_tiprack_list[0].wells_by_name()[
args.RightPipetteFirstTip]
# Dispense Samples and primers
sample_dest_dict = dispense_samples(args, sample_parameters, labware_dict,
left_pipette, right_pipette)
# Add PCR mix to each destination well.
add_pcr_mix(args, labware_dict, sample_dest_dict, left_pipette,
right_pipette)
if not ctx.is_simulating():
os.remove(tsv_file_path)
ctx.comment("Program End")
def run(protocol: protocol_api.ProtocolContext):
# labware
reservoir = protocol.load_labware('usascientific_12_reservoir_22ml', '4')
wellplate_2 = protocol.load_labware('biorad_96_wellplate_200ul_pcr', '5')
wellplate_3 = protocol.load_labware('biorad_96_wellplate_200ul_pcr', '6')
tiprack_1 = protocol.load_labware('opentrons_96_tiprack_300ul', '10')
tiprack_2 = protocol.load_labware('opentrons_96_tiprack_300ul', '11')
# pipettes
p300_multi = protocol.load_instrument('p300_multi',
'left',
tip_racks=[tiprack_1, tiprack_2])
p50_multi = protocol.load_instrument('p50_multi',
'right',
tip_racks=[tiprack_1, tiprack_2])
# modify
media_well = 0 # Location of media in reservoir, 0-based indexing (left most well is 0)
media_volume = 50 # Volume of media to add to each well of plate 2 [uL]
transfer_volume = 100 # Volume to transfer from wells in plate 2 to corresponing wells in plate 3 [uL]
# end modify
# other values
mix_count = 3
mix_volume = 25
wellplate_2_columns = [wellplate_2.columns()[i] for i in range(0, 12)]
wellplate_3_columns = [wellplate_3.columns()[i] for i in range(0, 12)]
wellplate_2_columns_reversed = wellplate_2_columns[::-1]
wellplate_3_columns_reversed = wellplate_3_columns[::-1]
# commands
# 1. Add 50 uL of media to each well in plate 2
p50_multi.pick_up_tip()
p50_multi.transfer(media_volume,
reservoir.wells()[media_well],
wellplate_2_columns_reversed,
new_tip='never')
p50_multi.drop_tip()
# 2. Mix three times, then transfer 100 uL from plate 2 into the corresponding well of plate 3
p300_multi.pick_up_tip()
for i in range(0, 12):
p300_multi.transfer(transfer_volume,
wellplate_2_columns_reversed[i],
wellplate_3_columns_reversed[i],
new_tip='never',
mix_before=(mix_count, mix_volume))
p300_multi.drop_tip()
def run(protocol: protocol_api.ProtocolContext):
# LABWARE
fuge_rack = protocol.load_labware(
'opentrons_24_tuberack_eppendorf_1.5ml_safelock_snapcap', '4')
tiprack300 = protocol.load_labware('opentrons_96_tiprack_300ul', '8')
tiprack20 = protocol.load_labware('opentrons_96_tiprack_20ul', '9')
tempdeck = protocol.load_module('tempdeck', '10')
sample_plate = tempdeck.load_labware('abi_96_wellplate_250ul')
# PIPETTES
p300 = protocol.load_instrument('p300_single_gen2',
'left',
tip_racks=[tiprack300])
p20 = protocol.load_instrument('p20_single_gen2',
'right',
tip_racks=[tiprack20])
# REAGENTS
water = fuge_rack['C1']
###### COMMANDS ######
# dispense 20ul into A1, checking bottom clearance
p20.pick_up_tip()
p20.well_bottom_clearance.aspirate = 2
p20.aspirate(20, water)
p20.well_bottom_clearance.dispense = 3
p20.dispense(20, sample_plate['A1'])
p20.drop_tip()
# dispense 20ul into B1 using 300ul tip, checking bottom clearance
p300.pick_up_tip()
p300.well_bottom_clearance.aspirate = 2
p300.aspirate(20, water)
p300.well_bottom_clearance.dispense = 0
p300.dispense(20, sample_plate['B1'])
p300.drop_tip()
# dispense 20ul into each well in row A
col = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12']
p300.pick_up_tip()
p300.well_bottom_clearance.aspirate = 2
p300.aspirate(260, water)
for well in col:
pos = 'A' + well
p300.well_bottom_clearance.dispense = 0
p300.dispense(20, sample_plate[pos])
p300.touch_tip()
p300.drop_tip()
def run(protocol: protocol_api.ProtocolContext):
"""
Creates 2 tip racks,1x 15 mL reservoit, 1x 24 position tube, 1x 96 position
Transfer 100 uL
"""
tip_20 = protocol.load_labware('opentrons_96_filtertiprack_20ul', 1)
tip_200 = protocol.load_labware('opentrons_96_filtertiprack_200ul', 2)
reservoir = protocol.load_labware('nest_12_reservoir_15ml', 3)
block_24well = protocol.load_labware(
'opentrons_24_aluminumblock_nest_1.5ml_snapcap', 4)
block_96well = protocol.load_labware(
'opentrons_96_aluminumblock_generic_pcr_strip_200ul', 5)
p20 = protocol.load_instrument('p20_single_gen2',
'left',
tip_racks=[tip_20])
p300_multi = protocol.load_instrument('p300_multi_gen2',
'right',
tip_racks=[tip_200])
#Prepare to fill the PCR tubes, change the offset, and transfer liquid
p300_multi.well_bottom_clearance.dispense = 3 # Raise the tip up slightly from the bottom
p300_multi.well_bottom_clearance.aspirate = 3
cols = [block_96well.columns_by_name()[well_id] for well_id in ['1', '2']]
p300_multi.distribute(20 * 2, reservoir.wells_by_name()['A1'], cols)
#Fill the PCR tubes with samples (create the first sample, then serially dilute from that)
p20.pick_up_tip()
p20.transfer(20,
block_24well.wells_by_name()['A1'],
block_96well.wells_by_name()['A1'],
new_tip='never')
quick_mix(p20, block_96well.wells_by_name()['A1'], 20, 3, 4.0)
p20.drop_tip()
sample_wells = ['A1', 'B1', 'C1', 'D1', 'E1', 'F1', 'G1', 'H1']
for from_well, to_well in zip(sample_wells[:-1], sample_wells[1:]):
p20.pick_up_tip()
p20.aspirate(20, block_96well.wells_by_name()[from_well], rate=2.0)
p20.dispense(20, block_96well.wells_by_name()[to_well], rate=2.0)
quick_mix(p20, block_96well.wells_by_name()[to_well], 20, 3, 5.0)
p20.drop_tip()
return p300_multi
def run(protocol: protocol_api.ProtocolContext):
# labware
trough = protocol.load_labware('axygen_12_reservior_22ml', '8')
tip300_1 = protocol.load_labware('opentrons_96_tiprack_300ul', '7')
tip300_2 = protocol.load_labware('opentrons_96_tiprack_300ul', '10')
plate24_1A = protocol.load_labware('nunc_24_plate', '1')
plate24_2A = protocol.load_labware('nunc_24_plate', '2')
plate24_3A = protocol.load_labware('nunc_24_plate', '4')
plate24_4A = protocol.load_labware('nunc_24_plate', '5')
# pipettes
p300m = protocol.load_instrument('p300_multi',
mount='right',
tip_racks=[tip300_1, tip300_2])
p300m.flow_rate.aspirate = 200
p300m.well_bottom_clearance.aspirate = 2
p300m.well_bottom_clearance.dispense = 2
#Step 1: Create list of trough wells and plate names:
list_plate1 = [(11, plate24_1A), (10, plate24_2A), (9, plate24_3A),
(8, plate24_4A)] # Defines plates to be seeded
# Creates function to seed plates. Variables: x = seed volume, col = start trough column for set of 4 plates, 24platelist = set of plates to use.
for (col, plate24_1), j in product(list_plate1, range(6)):
p300m.pick_up_tip()
for i in range(3):
p300m.aspirate(20, trough.wells()[col].top())
p300m.aspirate(210, trough.wells()[col])
p300m.move_to(trough.wells()[col].top(-20))
protocol.delay(seconds=1.0)
p300m.dispense(220, plate24_1.wells()[4 * j].top())
protocol.delay(seconds=1.0)
p300m.blow_out(plate24_1.wells()[4 * j].top())
p300m.drop_tip()
def run(protocol: protocol_api.ProtocolContext):
# LABWARE
tiprack300 = protocol.load_labware('opentrons_96_filtertiprack_200ul', '8')
tempdeck = protocol.load_module('tempdeck', '10')
reagent_rack = protocol.load_labware(
'opentrons_6_tuberack_nest_50ml_conical', '2')
# PIPETTES
p300 = protocol.load_instrument('p300_single_gen2',
'left',
tip_racks=[tiprack300])
# REAGENTS
rows_on_plate = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']
# ##### COMMANDS #####
fifty_h = fifty_ml_heights(32400, 100, 200)
print(fifty_h)
p300.pick_up_tip()
for i in range(100):
# print ("aspirating height:", fifty_h[i])
p300.aspirate(200, reagent_rack['A1'].bottom(fifty_h[i]))
p300.dispense(200, reagent_rack['B3'].bottom(fifty_h[-i]))
# print ("dispense height:", fifty_h[-i])
p300.drop_tip()
def model(robot, hardware, loop, request):
# Use with pytest.mark.parametrize(’labware’, [some-labware-name])
# to have a different labware loaded as .container. If not passed,
# defaults to the version-appropriate way to do 96 flat
from opentrons.legacy_api.containers import load
from opentrons.legacy_api.instruments.pipette import Pipette
try:
lw_name = request.getfixturevalue('labware')
except Exception:
lw_name = None
if isinstance(hardware, hc.HardwareAPILike):
ctx = ProtocolContext(loop=loop, hardware=hardware)
pip = ctx.load_instrument('p300_single', 'right')
loop.run_until_complete(
hardware.cache_instruments({Mount.RIGHT: 'p300_single'}))
instrument = models.Instrument(pip, context=ctx)
plate = ctx.load_labware(lw_name or 'corning_96_wellplate_360ul_flat',
1)
rob = hardware
container = models.Container(plate, context=ctx)
else:
print("hardware is {}".format(hardware))
pipette = Pipette(robot, ul_per_mm=18.5, max_volume=300, mount='right')
plate = load(robot, lw_name or '96-flat', '1')
rob = robot
instrument = models.Instrument(pipette)
container = models.Container(plate)
return namedtuple('model',
'robot instrument container')(robot=rob,
instrument=instrument,
container=container)
def run(protocol: protocol_api.ProtocolContext):
"""Function to try out utility commands."""
#loading labware (from opentrons labware library)
plate = protocol.load_labware('biorad_96_wellplate_200ul_pcr', 1,
'96plate')
tiprack_1 = protocol.load_labware('opentrons_96_tiprack_300ul', 2,
'300tips')
#load pipette
p300 = protocol.load_instrument('p300_single_gen2',
'right',
tip_racks=[tiprack_1])
p300.pick_up_tip()
#aspirating 50 ul from well A1 of 96plate at 2x default flow rate,
#2mm from bottom
p300.aspirate(50, plate['A1'].bottom(z=2), rate=2.0)
#aspirating 50 ul from current location (= well A1)
p300.aspirate(50)
#move pipette well
p300.move_to(plate['B1'].bottom()) #to bottom of well B1
p300.move_to(plate['B1'].top()) #to top off well B1
p300.move_to(plate['B1'].bottom(2)) #to 2 mm abouve bottom of well B1
p300.move_to(plate['B1'].top(-2)) #to 2 mm below top of well B1
#move DIRECTLY pipette within well (without going up each time)
p300.move_to(plate['C1'].top())
p300.move_to(plate['C1'].bottom(1), force_direct=True)
p300.move_to(plate['C1'].top(-2), force_direct=True)
p300.move_to(plate['C1'].top())
p300.drop_tip()
def run(j5_path: getcwd(), file : 'oligos.feather', protocol: protocol_api.ProtocolContext):
# labware
plate = protocol.load_labware('opentrons_24_tuberack_generic_2ml_screwcap', '2')
tiprack = protocol.load_labware('opentrons_96_tiprack_1000ul', '1')
%%tiprack_disposal = protocol.load_labware('opentrons_96_tiprack_1000ul', '3')
reagent_rack = protocol.load_labware('opentrons_10_tuberack_falcon_4x50ml_6x15ml_conical','4')
mgwater = reagent_rack['A1']
# pipettes
left_pipette = protocol.load_instrument('p1000_single', 'left', tip_racks=[tiprack])
# commands
oligos = feather.read_feather(joinStrings([j5_path,'/',file]))
oligos.insert(9, 'well_label', plate.wells()[oligos.shape[0]-1]) )
for index, row in oligos.iterrrows():
print('Find oligo named:',row['Name'])
oligos.insert(10, 'pimer_moles_nm', input('Input Masses:\n'))
print('Place oligo in well:',row['well_label'])
oligos.insert(11, 'volume_uL', oligos['primer_mass']*10)
oligo_master = feather.write_feather(oligos,joinStrings([j5_path,'/','oligos_master']))
for index, row in oligos.iterrows():
left_pipette.pick_up_tip()
# where to pick up from
# Aspirate, dispense and blow out for primer
left_pipette.aspirate(row['volume_uL'], mgwater, rate=2.0)
left_pipette.dispense(row['volume_uL'], plate[row['well_label']].center(), rate=2.0)
left_pipette.blow_out(plate[row['well_label']],plate[row['well_label']].top())
left_pipette.drop_tip()
def run(protocol: protocol_api.ProtocolContext):
# LABWARE
fuge_rack = protocol.load_labware(
'opentrons_24_tuberack_eppendorf_2ml_safelock_snapcap', '11')
tiprack20 = protocol.load_labware('opentrons_96_filtertiprack_20ul', '9')
tempdeck = protocol.load_module('tempdeck', '10')
pcr_plate = tempdeck.load_labware('abi_96_wellplate_250ul')
ww_plate1 = protocol.load_labware('bioer_96_wellplate_2200ul', '1')
ww_plate2 = protocol.load_labware('bioer_96_wellplate_2200ul', '5')
# PIPETTES
p20 = protocol.load_instrument('p20_single_gen2',
'right',
tip_racks=[tiprack20])
# REAGENTS
LU_Mix = fuge_rack['A1'] # LU MasterMix
# LISTS
rows = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']
tot_ww_plates = [ww_plate1, ww_plate2]
# #### COMMANDS ######
# aspirate mmix to all wells in 96w plate; 15*96 = 1440ul*1.1=1584
h_list = tip_heightsEpp(1584, 96, 15)
well_num = 1
p20.pick_up_tip()
for row in rows: #8 rows
for col in range(1, 13): #12 cols
dest = row + str(col)
p20.aspirate(15, LU_Mix.bottom(h_list[well_num - 1]), rate=0.75)
protocol.delay(seconds=1) #head vol for more accurate pipetting
p20.move_to(LU_Mix.bottom(38))
protocol.delay(seconds=1) #equilibrate
p20.touch_tip(v_offset=-4)
p20.dispense(15, pcr_plate[dest].bottom(1))
p20.blow_out(pcr_plate[dest].bottom(8))
p20.touch_tip()
well_num += 1
p20.drop_tip()
for x, ww_plate in enumerate(tot_ww_plates):
for col in range(0, 2):
for row in rows:
p20.pick_up_tip()
source = row + str(6 * col + 5) #A5, B5, C5
dest1 = row + str(6 * x + 3 * col + 1) #A1, #A2, #A3
dest2 = row + str(6 * x + 3 * col + 2)
dest3 = row + str(6 * x + 3 * col + 3)
p20.aspirate(18, ww_plate[source].bottom(1), rate=0.75)
protocol.delay(seconds=2) #equilibrate
p20.touch_tip()
p20.dispense(5, pcr_plate[dest1].bottom(1))
p20.touch_tip()
p20.dispense(5, pcr_plate[dest2].bottom(1))
p20.touch_tip()
p20.dispense(5, pcr_plate[dest3].bottom(1))
p20.touch_tip()
p20.drop_tip()
def run(ctx: protocol_api.ProtocolContext):
# ------------------------
# Load LabWare
# ------------------------
# Tip racks
tips = [
ctx.load_labware('opentrons_96_filtertiprack_200ul', slot,
'200µl filter tiprack') for slot in ['11']
]
# Pipette
p300 = ctx.load_instrument('p300_single_gen2', 'left', tip_racks=tips)
# Source
source = ctx.load_labware('opentrons_24_tuberack_generic_2ml_screwcap',
'4', 'Tuberack')
source_racks = source.wells()[:sources]
# Destination
dest = ctx.load_labware('opentrons_24_aluminumblock_generic_2ml_screwcap',
'1', 'Aluminum tuberack')
dest_rack = dest.wells()[0]
# ------------------
# Protocol
# ------------------
for s in source_racks:
if not p300.hw_pipette['has_tip']:
common.pick_up(p300)
common.move_vol_multichannel(ctx,
p300,
reagent=buffer,
source=s,
dest=dest_rack,
vol=volume_to_be_moved,
air_gap_vol=air_gap_vol_sample,
pickup_height=pickup_height,
disp_height=dispense_height,
x_offset=x_offset,
blow_out=True,
touch_tip=True)
# Drop pipette tip
p300.drop_tip()
if not p300.hw_pipette['has_tip']:
common.pick_up(p300)
common.custom_mix(p300,
reagent=buffer,
location=dest_rack,
vol=volume_to_be_moved,
rounds=rounds,
blow_out=True,
mix_height=dispense_height,
x_offset=x_offset,
source_height=dispense_height)
p300.drop_tip()
def run(protocol: protocol_api.ProtocolContext):
# LABWARE
# epp_rack = protocol.load_labware('opentrons_24_tuberack_eppendorf_2ml_safelock_snapcap', '5')
tiprack300 = protocol.load_labware('opentrons_96_filtertiprack_200ul', '8')
# tiprack20 = protocol.load_labware('opentrons_96_filtertiprack_20ul', '9')
# tempdeck = protocol.load_module('tempdeck', '10') # leaving on so I don't have to move off
# plate = protocol.load_labware('corning_96_wellplate_360ul_flat', '3')
# reagent_rack = protocol.load_labware('opentrons_6_tuberack_nest_50ml_conical', '6')
# lurb_rack= protocol.load_labware('opentrons_15_tuberack_nest_15ml_conical', '2')
lurb_rack = protocol.load_labware('eppendorf5ml_15_tuberack_5000ul', '2')
# x3_rack= protocol.load_labware('opentrons_15_tuberack_nest_15ml_conical', '6')
# PIPETTES
p300 = protocol.load_instrument('p300_single_gen2',
'left',
tip_racks=[tiprack300])
# REAGENTS
# x3 = x3_rack['A1'] # detergent e.g. Ultralyse 7, Ultralyse X3; 8085.11ul
lurbOne = lurb_rack['A1'] # lurb 1; 15mL tube
### COMMANDS ######
p300.pick_up_tip()
p300.move_to(lurbOne.top())
protocol.delay(seconds=5)
p300.move_to(lurbOne.top(-5))
protocol.delay(seconds=5)
p300.move_to(lurbOne.top(-10))
protocol.delay(seconds=5)
p300.move_to(lurbOne.bottom(10))
protocol.delay(seconds=5)
p300.move_to(lurbOne.bottom(1))
protocol.delay(seconds=5)
def run(protocol: protocol_api.ProtocolContext):
slots_map = {
'1':
'opentrons_6_tuberack_falcon_50ml_conical', # water in 50 mL tube in well A1
'2': 'opentrons_24_tuberack_generic_2ml_screwcap',
'3': 'opentrons_24_tuberack_generic_2ml_screwcap'
}
# Configure tip racks and pipette
pipette_name = 'p300_single'
mount = 'right'
tiprack_slots = ['4']
tiprack_name = 'opentrons_96_tiprack_300ul' # or use 'tipone_96_diytiprack_300ul'
inst_list = [
'251$1_A1->2_A1', '204$1_A1->2_A2', '233$1_A1->2_A3', '218$1_A1->2_A4',
'239$1_A1->2_A5', '309$1_A1->2_A6', '227$1_A1->2_B1', '234$1_A1->2_B2',
'258$1_A1->2_B3', '234$1_A1->2_B4', '276$1_A1->2_B5', '249$1_A1->2_B6',
'205$1_A1->2_C1', '290$1_A1->2_C2', '179$1_A1->2_C3', '172$1_A1->2_C4',
'238$1_A1->2_C5', '199$1_A1->2_C6', '210$1_A1->2_D1', '249$1_A1->2_D2',
'201$1_A1->2_D3', '294$1_A1->2_D4', '212$1_A1->2_D5', '235$1_A1->2_D6',
'239$1_A1->3_A1', '243$1_A1->3_A2', '256$1_A1->3_A3', '274$1_A1->3_A4',
'261$1_A1->3_A5'
]
labware_items = {}
for slot, labware_item in slots_map.items():
labware_items.update({slot: protocol.load_labware(labware_item, slot)})
tip_racks = [
protocol.load_labware(tiprack_name, slot) for slot in tiprack_slots
]
pipette = protocol.load_instrument(instrument_name=pipette_name,
mount=mount,
tip_racks=tip_racks)
pipette.pick_up_tip()
for inst in inst_list:
vol, path = inst.split('$')
vol = int(vol)
source, dest = path.split('->')
source_slot, source_well = source.split('_')
dest_slot, dest_well = dest.split('_')
pipette_times = math.ceil(vol / pipette.max_volume)
for i in range(pipette_times):
pipette.aspirate(
(vol / pipette_times),
labware_items[source_slot].wells_by_name()[source_well])
pipette.dispense(
(vol / pipette_times),
labware_items[dest_slot].wells_by_name()[dest_well].top(-5),
rate=0.5)
pipette.blow_out()
pipette.drop_tip()
def run(protocol: protocol_api.ProtocolContext):
# Create labware
plate_stock = protocol.load_labware('corning_96_wellplate_360ul_flat', 1)
plate_diluted = protocol.load_labware('corning_96_wellplate_360ul_flat', 2)
tiprack_1 = protocol.load_labware('opentrons_96_tiprack_300ul', 3)
tiprack_2 = protocol.load_labware('opentrons_96_tiprack_300ul', 4)
dilutant = protocol.load_labware('usascientific_12_reservoir_22ml', 5)
p300 = protocol.load_instrument('p300_single',
'right',
tip_racks=[tiprack_1, tiprack_2])
# Distribute variable volumes of dilutant from dilutant reservoir to all wells of
# 'plate_diluted' and automatically refill when more dilutant is required. Use one tip.
p300.distribute(dilutant_vol,
dilutant['A12'],
plate_diluted.wells()[:len(dilutant_vol)],
new_tip='once')
# Move variable volumes of stock (pcr product) from 'plate_stock' to 'plate_diluted'.
# Mix with dilutant, get a new tip before each sample and blow out after every
# dispense. Mix with 80% of the total volume.
p300.transfer(stock_vol,
plate_stock.wells()[:len(stock_vol)],
plate_diluted.wells()[:len(dilutant_vol)],
mix_after=(3, V2 * 0.8),
blow_out=True,
new_tip='always')
def run(protocol: protocol_api.ProtocolContext):
# LABWARE
fuge_rack = protocol.load_labware('vwr_24_tuberack_1500ul', '1')
# mix_rack = protocol.load_labware('vwr_24_tuberack_1500ul', '2')
tiprack300 = protocol.load_labware('opentrons_96_filtertiprack_200ul', '8')
# tiprack20 = protocol.load_labware('opentrons_96_filtertiprack_20ul', '9')
tempdeck = protocol.load_module('tempdeck', '10')
stds_plate = tempdeck.load_labware('abi_96_wellplate_250ul')
# PIPETTES
p300 = protocol.load_instrument('p300_single_gen2',
'left',
tip_racks=[tiprack300])
# p20 = protocol.load_instrument(
# 'p20_single_gen2', 'right', tip_racks=[tiprack20]
# )
# REAGENTS
mix = fuge_rack['D5']
testTube = fuge_rack['D1']
# testTube = fuge_rack['D1']
# COMMANDS
p300.pick_up_tip()
p300.aspirate(200, mix.bottom(10))
for volD, heightD in d_dispense(200, 10, 12):
p300.dispense(volD, testTube.bottom(heightD))
p300.drop_tip()
def setup_run(protocol: protocol_api.ProtocolContext):
plate = protocol.load_labware('corning_96_wellplate_360ul_flat', '4')
tiprack300_1 = protocol.load_labware('opentrons_96_tiprack_300ul', '10')
p300 = protocol.load_instrument('p300_multi', 'left', tip_racks=[tiprack300_1])
reservoir = protocol.load_labware('axygen_1_reservoir_90ml', '6')
eppen_rack = protocol.load_labware('tuberack') # define and load tuberack
return plate, tiprack300_1, reservoir, p300, eppen_rack
