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