def run(protocol: protocol_api.ProtocolContext): """ Run the qPCR Assay. Args: protocol: The Opentrons Protocol Context controlling the execution of the protocol. """ temp_deck_1 = protocol.load_module( TEMP_DECK_1["NAME"], location=TEMP_DECK_1["SLOT"], ) temp_deck_2 = protocol.load_module( TEMP_DECK_2["NAME"], location=TEMP_DECK_2["SLOT"], ) qPCR_plate = temp_deck_1.load_labware( QPCR_PLATE["NAME"], label=QPCR_PLATE["LABEL"], ) rna_plate = protocol.load_labware( RNA_PLATE["NAME"], location=RNA_PLATE["SLOT"], label=RNA_PLATE["LABEL"], ) reagent_plate = temp_deck_2.load_labware( REAGENT_PLATE["NAME"], label=REAGENT_PLATE["LABEL"], ) mastermix = reagent_plate.columns()[0] tip_20 = [ protocol.load_labware(i["NAME"], location=i["SLOT"], label=i["LABEL"]) for i in FILTER_TIP_20 ] p20 = protocol.load_instrument(P10_MULTI["NAME"], P10_MULTI["POSITION"], tip_racks=tip_20) p20.well_bottom_clearance.aspirate = ASPIRATE_DEPTH_BOTTOM p20.well_bottom_clearance.dispense = ASPIRATE_DEPTH_BOTTOM num_cols = len(qPCR_plate.columns()) temp_deck_1.set_temperature(celsius=TEMP) temp_deck_2.set_temperature(celsius=TEMP) aliquot_eluent( num_cols=num_cols, pipette=p20, source_plate=rna_plate.columns(), destination_plate=qPCR_plate.columns(), ) add_master_mix( num_cols=num_cols, pipette=p20, source_plate=mastermix, destination_plate=qPCR_plate.columns(), )
def run(protocol: protocol_api.ProtocolContext ): #for actually running the script in the robot #labware: tiprack1 = protocol.load_labware('opentrons_96_tiprack_300ul', '9') #tiprack2 = protocol.load_labware('opentrons_96_tiprack_300ul','6') #tiprack3 = protocol.load_labware("opentrons_96_tiprack_10ul", '5') #tuberack1 = protocol.load_labware('opentrons_24_tuberack_generic_2ml_screwcap','1') #holds stock primers and templates #watertuberack = protocol.load_labware('opentrons_10_tuberack_falcon_4x50ml_6x15ml_conical','3') #holds molec bio grad H2O tuberack2 = protocol.load_labware( 'opentrons_24_tuberack_nest_1.5ml_snapcap', '2') # holds dilute primers and templates tc_mod = protocol.load_module('Thermocycler Module') pcrplate = tc_mod.load_labware('nest_96_wellplate_100ul_pcr_full_skirt') temp_module = protocol.load_module('temperature module', 1) cold_tuberack = temp_module.load_labware( 'opentrons_24_aluminumblock_generic_2ml_screwcap', label='Temperature-Controlled Tubes') temp_module.set_temperature(20) print(temp_module.temperature) tc_mod.open_lid() #pipettes right_pipette = protocol.load_instrument('p300_single', 'right', tip_racks=[tiprack1]) #left_pipette = protocol.load_instrument('p10_single','left',tip_racks = [tiprack3]) ##################################COMMANDS#################################### #add water to template dilution tubes. ***df is the template description dataframe #Since we are just moving water I will use the same pipette tip to save plastic right_pipette.pick_up_tip() right_pipette.aspirate( volume=2, location=cold_tuberack['A1'], rate=2.0) #total vol dilute template - vol stock template to add right_pipette.dispense(2, tuberack2['A1'], rate=2.0) right_pipette.drop_tip() protocol.pause('explain dilution') #add water to primer dilution tubes right_pipette.pick_up_tip() right_pipette.aspirate( 2, tuberack2['D6'], rate=2.0 ) #need to put 39uL of water into each dilution tube for primers,) #we need to find better way to loop through these commands right_pipette.dispense(2, pcrplate['H12'], rate=2.0) right_pipette.drop_tip() tc_mod.close_lid()
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(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 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 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): # 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 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): mag_mod = protocol.load_module('Magnetic Module Gen2', '1') plate = mag_mod.load_labware('kingfisher_96_wellplate_2000ul', 'KingFisher 96 Well Plate 2mL') for i in range(50): protocol.pause() mag_mod.engage(height=6) protocol.pause() mag_mod.disengage()
def run(protocol: protocol_api.ProtocolContext): temp_module = protocol.load_module('Temperature Module', 5) p10rack = protocol.load_labware('opentrons_96_tiprack_10ul', 9) reagents = protocol.load_labware( 'opentrons_24_tuberack_eppendorf_2ml_safelock_snapcap', 8) prep_plate = temp_module.load_labware('nest_96_wellplate_200ul_flat') # Using 10ul pipette for precision p10 = protocol.load_instrument('p10_single', 'left', tip_racks=[p10rack]) base_recipe = { # reagent name: [postion on tuberack, uls to each sample] '10X_NEBuffer_21': ['A1', 2], 'LbCas12a': ['B1', 1], 'reporter': ['C1', 1], #TODO Need correct volume 'water': ['D1', 15.75] } gRNA_uls_to_pipette = 1.25 gRNA_recipe = { # reagent name: [postion on tuberack, uls to each sample] 'N-gene_gRNA': ['A2', gRNA_uls_to_pipette], 'E-gene_gRNA': ['B2', gRNA_uls_to_pipette], 'RNase_P_gRNA': ['C2', gRNA_uls_to_pipette] } prep_plate_wells = ['A1', 'A2', 'A3'] #1st: N-gene wells, 2nd: E-gene, 3rd: RNase P prep_plate_locations = [ prep_plate.wells(well) for well in prep_plate_wells ] reporter_recipe = base_recipe['reporter'] #move reporter to be used later # print(prep_plate_locations) #Begin Procedure --------------------------------------------------------- for reagent in base_recipe: #TODO Don't need for-loop, can do with .distribute only p10.distribute( base_recipe[reagent][1], #volume reagents.wells(base_recipe[reagent][0]), #source location prep_plate_locations) #dest location for group, gRNA in enumerate(gRNA_recipe): p10.transfer( gRNA_recipe[gRNA][1], #volume reagents.wells(gRNA_recipe[gRNA][0]), #source location prep_plate_locations[group], #dest location mix_after=(2, 10)) #ensure good mixing temp_module.set_temperature(37) #robot pauses until temperature is reached protocol.delay(minutes=30) temp_module.set_temperature(4)
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): ####################################################################################################################################### ## 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(protocol: protocol_api.ProtocolContext): #labware temp_mod = protocol.load_module('Temperature Module', '9') plate = temp_mod.load_labware( "opentrons_96_aluminumblock_generic_pcr_strip_200ul", label='Temp-controlled pcr tubes') #tiprack tiprack1 = protocol.load_labware("opentrons_96_tiprack_20ul", "1") #pipettes p20 = protocol.load_instrument("p20_single_gen2", "right", tip_racks=[tiprack1]) # Move compound stock to start of series p20.transfer(final_vol, plate.wells_by_name()[compound_stock_location], plate.wells_by_name()[starting_location]) # Put buffer in each tube p20.transfer( buffer_vol, plate.wells_by_name()[buffer_location], [plate.wells_by_name()[well_name] for well_name in buffer_wells[1:]]) # Perform serial dilution p20.pick_up_tip() p20.transfer(trans_vol, plate.wells_by_name()[starting_location], plate.wells_by_name()[buffer_wells[0]], mix_after=(3, final_vol / 2), new_tip='never') for num, well in enumerate(buffer_wells[:-1]): source = well destination = buffer_wells[num + 1] p20.transfer(trans_vol, plate.wells_by_name()[source], plate.wells_by_name()[destination], mix_after=(3, final_vol / 2), new_tip='never') # Discard excess from last tube p20.transfer(buffer_vol, plate.wells_by_name()[buffer_wells[-1]], plate.wells_by_name()[liquid_trash_tube], new_tip='never') p20.drop_tip() #add protein to all tubes p20.transfer( buffer_vol, plate.wells_by_name()[protein_location], [plate.wells_by_name()[well_name] for well_name in protein_wells], mix_after=(3, final_vol / 2), new_tip='always')
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(robot: protocol_api.ProtocolContext): # ----------------------------------------------------- # Magnetic module + labware # ----------------------------------------------------- magdeck = robot.load_module('Magnetic Module Gen2', '1') maglab = magdeck.load_labware('nest_96_wellplate_2ml_deep', 'nest_96_wellplate_2ml_deep') #magdeck.engage(height = 7) for i in np.arange(0.0, 25.0, 0.1): magdeck.engage(height=i) robot.comment('Actual height =' + str(i)) robot.pause('Test') magdeck.disengage()
def run(ctx: protocol_api.ProtocolContext): # ------------------------ # Load LabWare # ------------------------ # Tip racks tips = [ctx.load_labware('opentrons_96_filtertiprack_20ul', slot, '20µl filter tiprack') for slot in ['11']] # Pipette p20 = ctx.load_instrument('p20_single_gen2', 'right', tip_racks=tips) # Source rack_num = math.ceil(num_samples / NUM_OF_SOURCES_PER_RACK) if num_samples < MAX_NUM_OF_SOURCES else MIN_NUM_OF_SOURCES source_racks = [ctx.load_labware( 'opentrons_24_tuberack_generic_2ml_screwcap', slot, 'Tuberack 24 tubos normales' + str(i + 1)) for i, slot in enumerate(['8', '9', '5', '6'][:rack_num]) ] reagents = common.generate_source_table(source_racks) sample_sources = reagents[:num_samples] # Destination (in this case 96 well plate) dest_plate = ctx.load_labware('abi_fast_qpcr_96_alum_opentrons_100ul', '3', 'Tubos individuales en placa pcr aluminio') destinations = dest_plate.wells()[:num_destinations] # ------------------ # Protocol # ------------------ if not p20.hw_pipette['has_tip']: common.pick_up(p20) for s, d in zip(sample_sources, destinations): if not p20.hw_pipette['has_tip']: common.pick_up(p20) # Calculate pickup_height based on remaining volume and shape of container common.move_vol_multichannel(ctx, p20, reagent=sample, source=s, dest=d, vol=volume_to_be_transfered, 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 p20.drop_tip() # Modules temp_hot = ctx.load_module('temperature module gen2', '1') temp_hot.set_temperature(98) ctx.pause()
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)] dest = holderList[j][row + str(2 * i + 1)] p20.aspirate(20, source.bottom(1), rate=0.75) p20.move_to(source.bottom( 40)) #move p20 pipette +4cm so no crash into lyo tubes p20.move_to(dest.bottom( 40)) #move p20 pipette +4cm so no crash into lyo tubes p20.dispense(20, dest.bottom(6)) p20.blow_out() p20.touch_tip() p20.move_to(dest.top() ) # centers tip so tip doesn't lift tubes after touch p20.move_to(dest.bottom(40)) p20.drop_tip()
def run(protocol: protocol_api.ProtocolContext): ## SETUP # Load Labware temp_mod = protocol.load_module('Temperature Module', '9') tube_rack = protocol.load_labware("opentrons_24_aluminumblock_nest_1.5ml_snapcap", "4", label = "aluminum block") reservoir_plate = protocol.load_labware("usascientific_12_reservoir_22ml", "6", label = 'reseroir 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", '1') tiprack2 = protocol.load_labware("opentrons_96_tiprack_300ul", '2') # Load pipettes p20 = protocol.load_instrument("p20_single_gen2", "right", tip_racks = [tiprack1]) p50 = protocol.load_instrument('p50_multi', "left", tip_racks = [tiprack2]) p20.flow_rate.aspirate = 8 p20.flow_rate.dispense = 8 ## PROCEDURE # Transfer 20uL detection reagent from reservoir to reaction plate p50.transfer(20, reservoir_plate.columns_by_name()["1"], reaction_plate.wells_by_name()["B1", new_tip = 'once'])
def run(protocol: protocol_api.ProtocolContext): # LABWARE stds_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', '1') plate = tempdeck.load_labware( 'opentrons_96_aluminumblock_generic_pcr_strip_200ul') # holder_1 = protocol.load_labware('8wstriptubesonfilterracks_96_aluminumblock_250ul', '3') # holder_2 = protocol.load_labware('8wstriptubesonfilterracks_96_aluminumblock_250ul', '6') # holder_3 = protocol.load_labware('8wstriptubesonfilterracks_96_aluminumblock_250ul', '7') # PIPETTES p300 = protocol.load_instrument('p300_single_gen2', 'left', tip_racks=[tiprack300]) p20 = protocol.load_instrument('p20_single_gen2', 'right', tip_racks=[tiprack20]) # REAGENTS std_1 = stds_rack['A1'] # 990ul Water std_2 = stds_rack['A2'] # 900ul water std_3 = stds_rack['A3'] # 900ul water std_4 = stds_rack['A4'] # 900ul water # # user inputs # # this is 4 reps on each tube e.g. 16*4 = 64 samples # num_of_sample_reps = 6 # doesn't yet accommodate other ints # holderList = [holder_1, holder_2] # tot_sample_vol = 20 # # lists # all_stds = [std_1, std_2, std_3, std_4, std_5, std_6, std_7, std_8, std_9, std_10, std_11, std_12, std_13, std_14, std_15, water] # dest_rows = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'] # easier to add rows for stds rather than repeat # #### COMMANDS ###### # Distribute stds DNA to strip tubes * # reps p300.transfer(20, std_1, plate.rows_by_name()['A'])
def run(protocol: protocol_api.ProtocolContext): temp_mod = protocol.load_module('Temperature Module', '6') tubes = temp_mod.load_labware( 'opentrons_96_aluminumblock_generic_pcr_strip_200ul', label='aliquot tubes') protein_tubes = protocol.load_labware( "opentrons_24_aluminumblock_nest_2ml_snapcap", '5') tiprack1 = protocol.load_labware("opentrons_96_tiprack_300ul", '4') #tiprack2 = protocol.load_labware("opentrons_96_tiprack_10ul",'2') #tiprack3 = protocol.load_labware("opentrons_96_tiprack_300ul",'4') p50 = protocol.load_instrument('p50_multi', "left", tip_racks=[tiprack1]) # p50.transfer(50, [condition_block.wells_by_name()[well_name].bottom(30) for well_name in source],[cryst_plate.wells_by_name()[well_name] for well_name in res_destination], new_tip ='always') # p20.transfer(1, [cryst_plate.wells_by_name()[well_name].bottom(5) for well_name in res_destination],[cryst_plate.wells_by_name()[well_name].bottom(0.5) for well_name in well_one_destination], new_tip ='always') p50.pick_up_tip() for x in range(0, 12): p50.transfer(40, protein_tubes.wells_by_name()["A1"], tubes.columns()[x], new_tip='never', mix_before=(5, 50)) p50.drop_tip()
def run(protocol: protocol_api.ProtocolContext): # LABWARE fuge_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') sectempdeck = protocol.load_module('tempdeck', '4') plate = tempdeck.load_labware( 'opentrons_96_aluminumblock_generic_pcr_strip_200ul') stds_rack = sectempdeck.load_labware( 'opentrons_24_aluminumblock_generic_2ml_screwcap') # PIPETTES p300 = protocol.load_instrument('p300_single_gen2', 'left', tip_racks=[tiprack300]) p20 = protocol.load_instrument('p20_single_gen2', 'right', tip_racks=[tiprack20]) # REAGENTS b_std_1 = stds_rack['A1'] b_std_2 = stds_rack['A2'] b_std_3 = stds_rack['A3'] b_std_4 = stds_rack['A4'] b_std_5 = stds_rack['A5'] b_std_6 = stds_rack['A6'] b_std_7 = stds_rack['D1'] g_std_1 = stds_rack['B1'] g_std_2 = stds_rack['B2'] g_std_3 = stds_rack['B3'] g_std_4 = stds_rack['B4'] g_std_5 = stds_rack['B5'] g_std_6 = stds_rack['B6'] g_std_7 = stds_rack['D2'] d_std_1 = stds_rack['C1'] d_std_2 = stds_rack['C2'] d_std_3 = stds_rack['C3'] d_std_4 = stds_rack['C4'] d_std_5 = stds_rack['C5'] d_std_6 = stds_rack['C6'] d_std_7 = stds_rack['D3'] BioMix = stds_rack['D5'] # BioSellal MasterMix LU_Mix = stds_rack['D6'] # LU MasterMix water = fuge_rack['D6'] # water BioPositive = fuge_rack['A1'] # BioSellal Positive Control plasmid LUPositive = fuge_rack['A6'] # LU Positive Control plasmid # Lists BioMix_cols = ['1', '3', '5', '7', '9', '11'] beta = [b_std_1, b_std_6, b_std_7] #really gamma beta_wells = [['A1', 'A3', 'A5', 'A7', 'A9', 'A11'], ['B1', 'B3', 'B5', 'B7', 'B9', 'B11'], ['G1', 'G5', 'G9']] # triplicate gamma = [g_std_1, g_std_6, g_std_7] #really kappa gamma_wells = [['C1', 'C3', 'C5', 'C7', 'C9', 'C11'], ['D1', 'D3', 'D5', 'D7', 'D9', 'D11'], ['G3', 'G7', 'G11']] delta = [d_std_1, d_std_6, d_std_7] #really delta delta_wells = [['E1', 'E3', 'E5', 'E7', 'E9', 'E11'], ['F1', 'F3', 'F5', 'F7', 'F9', 'F11'], ['H1', 'H5', 'H9']] # NEG_wells = ['H1', 'H2', 'H3', 'H7', 'H8', 'H9'] # no room BioPositive_wells = ['H3', 'H7', 'H11'] # LUPositive_wells = ['H10', 'H11', 'H12'] # #### COMMANDS ###### # Transfer BioSellal mmix to cols 1-6 for col in BioMix_cols: p20.transfer(15, BioMix.bottom(2), plate.columns_by_name()[col], blow_out=True, blowout_location='destination well', touch_tip=True, new_tip='once') # Add Beta samples to Mix for sample, pos in zip(beta, beta_wells): p20.distribute(5, sample.bottom(2), [plate.wells_by_name()[well_name] for well_name in pos], new_tip='always') # Add Gamma samples to Mix for sample, pos in zip(gamma, gamma_wells): p20.distribute(5, sample.bottom(2), [plate.wells_by_name()[well_name] for well_name in pos], new_tip='always') # Add Delta samples to Mix for sample, pos in zip(delta, delta_wells): p20.distribute(5, sample.bottom(2), [plate.wells_by_name()[well_name] for well_name in pos], new_tip='always') # Add POSITIVE samples to Mix p20.distribute( 5, BioPositive.bottom(2), [plate.wells_by_name()[well_name] for well_name in BioPositive_wells], new_tip='always')
def run(ctx: protocol_api.ProtocolContext): global robot robot = ctx # confirm door is close if not ctx.is_simulating(): confirm_door_is_closed() # load labware and modules ## ELUTION LABWARE if ELUTION_LABWARE not in ELUTION_LW_DICT: raise Exception('Invalid ELUTION_LABWARE. Must be one of the \ following:\nopentrons aluminum biorad plate\nopentrons aluminum nest plate') elution_plate = ctx.load_labware( ELUTION_LW_DICT[ELUTION_LABWARE], '1', 'elution plate') ## MAGNETIC PLATE LABWARE magdeck = ctx.load_module('magdeck', '10') magdeck.disengage() if MAGPLATE_LABWARE not in MAGPLATE_LW_DICT: raise Exception('Invalid MAGPLATE_LABWARE. Must be one of the \ following:\nopentrons deep generic well plate\nnest deep generic well plate\nvwr deep generic well plate') magplate = magdeck.load_labware(MAGPLATE_LW_DICT[MAGPLATE_LABWARE]) ## WASTE LABWARE if WASTE_LABWARE not in WASTE_LW_DICT: raise Exception('Invalid WASTE_LABWARE. Must be one of the \ following:\nnest 1 reservoir plate') waste = ctx.load_labware( WASTE_LW_DICT[WASTE_LABWARE], '11', 'waste reservoir').wells()[0].top(-10) ## REAGENT RESERVOIR if REAGENT_LABWARE not in REAGENT_LW_DICT: raise Exception('Invalid REAGENT_LABWARE. Must be one of the \ following:\nnest 12 reservoir plate') reagent_res = ctx.load_labware( REAGENT_LW_DICT[REAGENT_LABWARE], '7', 'reagent reservoir') ## TIPS # using standard tip definition despite actually using filter tips # so that the tips can accommodate ~220µl per transfer for efficiency tips300 = [ ctx.load_labware( 'opentrons_96_tiprack_300ul', slot, '200µl filter tiprack') for slot in ['2', '3', '5', '6', '9','4'] ] tips1000 = [ ctx.load_labware('opentrons_96_filtertiprack_1000ul', slot, '1000µl filter tiprack') for slot in ['8'] ] # reagents and samples num_cols = math.ceil(NUM_SAMPLES/8) mag_samples_m = magplate.rows()[0][:num_cols] mag_samples_s = magplate.wells()[:NUM_SAMPLES] elution_samples_m = elution_plate.rows()[0][:num_cols] elution_buffer = reagent_res.wells()[0] bead_buffer = reagent_res.wells()[1:5] wash_sets = [reagent_res.wells()[i:i+2] for i in [5, 7, 9]] # pipettes m300 = ctx.load_instrument('p300_multi_gen2', 'left', tip_racks=tips300) p1000 = ctx.load_instrument('p1000_single_gen2', 'right', tip_racks=tips1000) m300.flow_rate.aspirate = 150 m300.flow_rate.dispense = 300 m300.flow_rate.blow_out = 300 p1000.flow_rate.aspirate = 100 p1000.flow_rate.dispense = 1000 p1000.flow_rate.blow_out = 1000 if(DISPENSE_BEADS): # premix, transfer, and mix magnetic beads with sample ## bead dests depending on number of samples bead_dests = bead_buffer[:math.ceil(num_cols/4)] dispense_beads(bead_dests,mag_samples_m,m300,tips300) else: # Mix bead mix_beads(7, mag_samples_m,m300,tips300) # incubate off and on magnet ctx.delay(minutes=5, msg='Incubating off magnet for 5 minutes.') ## First incubate on magnet. magdeck.engage(height_from_base=22) ctx.delay(minutes=5, msg='Incubating on magnet for 5 minutes.') # remove supernatant with P1000 remove_supernatant(mag_samples_s,waste,p1000,tips1000) # 3x washes wash(wash_sets,mag_samples_m,waste,magdeck,m300,tips300) # elute samples magdeck.disengage() elute_samples(mag_samples_m,elution_samples_m,elution_buffer,magdeck,m300,tips300) # track final used tip save_tip_info() magdeck.disengage() finish_run()
def run(ctx: protocol_api.ProtocolContext): from opentrons.drivers.rpi_drivers import gpio gpio.set_rail_lights(False) #Turn off lights (termosensible reagents) ctx.comment('Actual used columns: ' + str(num_cols)) # Define the STEPS of the protocol STEP = 0 STEPS = { # Dictionary with STEP activation, description, and times 1: {'Execute': True, 'description': 'Transfer MMIX'}, 2: {'Execute': True, 'description': 'Transfer elution'} } for s in STEPS: # Create an empty wait_time if 'wait_time' not in STEPS[s]: STEPS[s]['wait_time'] = 0 #Folder and file_path for log time folder_path = '/var/lib/jupyter/notebooks/'+run_id' if not ctx.is_simulating(): if not os.path.isdir(folder_path): os.mkdir(folder_path) file_path = folder_path + '/KC_qPCR_time_log.txt' # Define Reagents as objects with their properties class Reagent: def __init__(self, name, flow_rate_aspirate, flow_rate_dispense, rinse, reagent_reservoir_volume, delay, num_wells, h_cono, v_fondo, tip_recycling = 'none'): self.name = name self.flow_rate_aspirate = flow_rate_aspirate self.flow_rate_dispense = flow_rate_dispense self.rinse = bool(rinse) self.reagent_reservoir_volume = reagent_reservoir_volume self.delay = delay self.num_wells = num_wells self.col = 0 self.vol_well = 0 self.h_cono = h_cono self.v_cono = v_fondo self.unused=[] self.tip_recycling = tip_recycling self.vol_well_original = reagent_reservoir_volume / num_wells # Reagents and their characteristics MMIX = Reagent(name = 'Master Mix', rinse = False, flow_rate_aspirate = 1, flow_rate_dispense = 1, reagent_reservoir_volume = volume_mmix_available, num_wells = 2, #change with num samples delay = 0, h_cono = h_cone, v_fondo = volume_cone # V cono ) Samples = Reagent(name='Samples', rinse=False, flow_rate_aspirate = 1, flow_rate_dispense = 1, reagent_reservoir_volume=50, delay=0, num_wells=num_cols, # num_cols comes from available columns h_cono=0, v_fondo=0 ) MMIX.vol_well = MMIX.vol_well_original Samples.vol_well = Samples.vol_well_original ################## # Custom functions def divide_destinations(l, n): # Divide the list of destinations in size n lists. for i in range(0, len(l), n): yield l[i:i + n] def distribute_custom(pipette, volume, src, dest, waste_pool, pickup_height, extra_dispensal, disp_height=0): # Custom distribute function that allows for blow_out in different location and adjustement of touch_tip pipette.aspirate((len(dest) * volume) + extra_dispensal, src.bottom(pickup_height)) pipette.touch_tip(speed=20, v_offset=-5) pipette.move_to(src.top(z=5)) pipette.aspirate(20) # air gap for d in dest: pipette.dispense(20, d.top()) drop = d.top(z = disp_height) pipette.dispense(volume, drop) pipette.move_to(d.top(z=5)) pipette.aspirate(20) # air gap try: pipette.blow_out(waste_pool.wells()[0].bottom(pickup_height + 3)) except: pipette.blow_out(waste_pool.bottom(pickup_height + 3)) return (len(dest) * volume) def move_vol_multichannel(pipet, reagent, source, dest, vol, air_gap_vol, x_offset, pickup_height, rinse, disp_height, blow_out, touch_tip): ''' x_offset: list with two values. x_offset in source and x_offset in destination i.e. [-1,1] pickup_height: height from bottom where volume rinse: if True it will do 2 rounds of aspirate and dispense before the tranfer disp_height: dispense height; by default it's close to the top (z=-2), but in case it is needed it can be lowered blow_out, touch_tip: if True they will be done after dispensing ''' # Rinse before aspirating if rinse == True: custom_mix(pipet, reagent, location = source, vol = vol, rounds = 2, blow_out = True, mix_height = 0, x_offset = x_offset) # SOURCE s = source.bottom(pickup_height).move(Point(x = x_offset[0])) pipet.aspirate(vol, s, rate = reagent.flow_rate_aspirate) # aspirate liquid if air_gap_vol != 0: # If there is air_gap_vol, switch pipette to slow speed pipet.aspirate(air_gap_vol, source.top(z = -2), rate = reagent.flow_rate_aspirate) # air gap # GO TO DESTINATION drop = dest.top(z = disp_height).move(Point(x = x_offset[1])) pipet.dispense(vol + air_gap_vol, drop, rate = reagent.flow_rate_dispense) # dispense all ctx.delay(seconds = reagent.delay) # pause for x seconds depending on reagent if blow_out == True: pipet.blow_out(dest.top(z = -2)) if touch_tip == True: pipet.touch_tip(speed = 20, v_offset = -5, radius = 0.9) def custom_mix(pipet, reagent, location, vol, rounds, blow_out, mix_height, x_offset, source_height = 3): ''' Function for mixing a given [vol] in the same [location] a x number of [rounds]. blow_out: Blow out optional [True,False] x_offset = [source, destination] source_height: height from bottom to aspirate mix_height: height from bottom to dispense ''' if mix_height == 0: mix_height = 3 pipet.aspirate(1, location=location.bottom( z=source_height).move(Point(x=x_offset[0])), rate=reagent.flow_rate_aspirate) for _ in range(rounds): pipet.aspirate(vol, location=location.bottom( z=source_height).move(Point(x=x_offset[0])), rate=reagent.flow_rate_aspirate) pipet.dispense(vol, location=location.bottom( z=mix_height).move(Point(x=x_offset[1])), rate=reagent.flow_rate_dispense) pipet.dispense(1, location=location.bottom( z=mix_height).move(Point(x=x_offset[1])), rate=reagent.flow_rate_dispense) if blow_out == True: pipet.blow_out(location.top(z=-2)) # Blow out def calc_height(reagent, cross_section_area, aspirate_volume, min_height = 0.5, extra_volume = 50): nonlocal ctx ctx.comment('Remaining volume ' + str(reagent.vol_well) + '< needed volume ' + str(aspirate_volume) + '?') if reagent.vol_well < aspirate_volume + extra_volume: reagent.unused.append(reagent.vol_well) ctx.comment('Next column should be picked') ctx.comment('Previous to change: ' + str(reagent.col)) # column selector position; intialize to required number reagent.col = reagent.col + 1 ctx.comment(str('After change: ' + str(reagent.col))) reagent.vol_well = reagent.vol_well_original ctx.comment('New volume:' + str(reagent.vol_well)) height = (reagent.vol_well - aspirate_volume - reagent.v_cono) / cross_section_area #- reagent.h_cono reagent.vol_well = reagent.vol_well - aspirate_volume ctx.comment('Remaining volume:' + str(reagent.vol_well)) if height < min_height: height = min_height col_change = True else: height = (reagent.vol_well - aspirate_volume - reagent.v_cono) / cross_section_area #- reagent.h_cono reagent.vol_well = reagent.vol_well - aspirate_volume ctx.comment('Calculated height is ' + str(height)) if height < min_height: height = min_height ctx.comment('Used height is ' + str(height)) col_change = False return height, col_change #################################### # load labware and modules # 24 well rack tuberack = ctx.load_labware( 'opentrons_24_aluminumblock_generic_2ml_screwcap', '2', 'Bloque Aluminio opentrons 24 screwcaps 2000 µL ') ############################################ # tempdeck tempdeck = ctx.load_module('tempdeck', '4') tempdeck.set_temperature(temperature) ################################## # qPCR plate - final plate, goes to PCR qpcr_plate = tempdeck.load_labware( 'abi_fast_qpcr_96_alum_opentrons_100ul', 'chilled qPCR final plate') ################################## # Sample plate - comes from B source_plate = ctx.load_labware( "kingfisher_std_96_wellplate_550ul", '1', 'chilled KF plate with elutions (alum opentrons)') samples = source_plate.wells()[:NUM_SAMPLES] ################################## # Load Tipracks tips20 = [ ctx.load_labware('opentrons_96_filtertiprack_20ul', slot) for slot in ['5'] ] tips200 = [ ctx.load_labware('opentrons_96_filtertiprack_200ul', slot) for slot in ['6'] ] ################################################################################ # Declare which reagents are in each reservoir as well as deepwell and elution plate MMIX.reagent_reservoir = tuberack.rows()[0][:MMIX.num_wells] # 1 row, 2 columns (first ones) ctx.comment('Wells in: '+ str(tuberack.rows()[0][:MMIX.num_wells]) + ' element: '+str(MMIX.reagent_reservoir[MMIX.col])) # setup up sample sources and destinations samples = source_plate.wells()[:NUM_SAMPLES] samples_multi = source_plate.rows()[0][:num_cols] pcr_wells = qpcr_plate.wells()[:NUM_SAMPLES] pcr_wells_multi = qpcr_plate.rows()[0][:num_cols] # Divide destination wells in small groups for P300 pipette dests = list(divide_destinations(pcr_wells, size_transfer)) # pipettes m20 = ctx.load_instrument( 'p20_multi_gen2', mount='right', tip_racks=tips20) p300 = ctx.load_instrument( 'p300_single_gen2', mount='left', tip_racks=tips200) # used tip counter and set maximum tips available tip_track = { 'counts': {p300: 0, m20: 0} } ############################################################################ # STEP 1: Transfer Master MIX ############################################################################ STEP += 1 if STEPS[STEP]['Execute'] == True: start = datetime.now() p300.pick_up_tip() used_vol=[] for dest in dests: aspirate_volume=volume_mmix * len(dest) + extra_dispensal [pickup_height,col_change]=calc_height(MMIX, area_section_screwcap, aspirate_volume) used_vol_temp = distribute_custom( p300, volume = volume_mmix, src = MMIX.reagent_reservoir[MMIX.col], dest = dest, waste_pool = MMIX.reagent_reservoir[MMIX.col], pickup_height = pickup_height, extra_dispensal = extra_dispensal) used_vol.append(used_vol_temp) p300.drop_tip() tip_track['counts'][p300]+=1 #MMIX.unused_two = MMIX.vol_well end = datetime.now() time_taken = (end - start) ctx.comment('Step ' + str(STEP) + ': ' + STEPS[STEP]['description'] + ' took ' + str(time_taken)) STEPS[STEP]['Time:'] = str(time_taken) ############################################################################ # STEP 2: TRANSFER Samples ############################################################################ STEP += 1 if STEPS[STEP]['Execute'] == True: start = datetime.now() ctx.comment('pcr_wells') #Loop over defined wells for s, d in zip(samples_multi, pcr_wells_multi): m20.pick_up_tip() #Source samples move_vol_multichannel(m20, reagent = Samples, source = s, dest = d, vol = volume_sample, air_gap_vol = air_gap_sample, x_offset = x_offset, pickup_height = 0.2, disp_height = -10, rinse = False, blow_out=True, touch_tip=False) m20.drop_tip() tip_track['counts'][m20]+=8 end = datetime.now() time_taken = (end - start) ctx.comment('Step ' + str(STEP) + ': ' + STEPS[STEP]['description'] + ' took ' + str(time_taken)) STEPS[STEP]['Time:'] = str(time_taken) # Export the time log to a tsv file if not ctx.is_simulating(): with open(file_path, 'w') as f: f.write('STEP\texecution\tdescription\twait_time\texecution_time\n') for key in STEPS.keys(): row = str(key) for key2 in STEPS[key].keys(): row += '\t' + format(STEPS[key][key2]) f.write(row + '\n') f.close() ############################################################################ # Light flash end of program gpio.set_rail_lights(False) time.sleep(2) #os.system('mpg123 -f -8000 /var/lib/jupyter/notebooks/toreador.mp3 &') for i in range(3): gpio.set_rail_lights(False) gpio.set_button_light(1, 0, 0) time.sleep(0.3) gpio.set_rail_lights(True) gpio.set_button_light(0, 0, 1) time.sleep(0.3) gpio.set_rail_lights(False) gpio.set_button_light(0, 1, 0) ctx.comment('Finished! \nMove plate to PCR') if STEPS[1]['Execute'] == True: total_used_vol = np.sum(used_vol) total_needed_volume = total_used_vol ctx.comment('Total Master Mix used volume is: ' + str(total_used_vol) + '\u03BCl.') ctx.comment('Needed Master Mix volume is ' + str(total_needed_volume + extra_dispensal*len(dests)) +'\u03BCl') ctx.comment('Used Master Mix volumes per run are: ' + str(used_vol) + '\u03BCl.') ctx.comment('Master Mix Volume remaining in tubes is: ' + format(np.sum(MMIX.unused)+extra_dispensal*len(dests)+MMIX.vol_well) + '\u03BCl.') ctx.comment('200 ul Used tips in total: ' + str(tip_track['counts'][p300])) ctx.comment('200 ul Used racks in total: ' + str(tip_track['counts'][p300] / 96)) if STEPS[2]['Execute'] == True: ctx.comment('20 ul Used tips in total: ' + str(tip_track['counts'][m20])) ctx.comment('20 ul Used racks in total: ' + str(tip_track['counts'][m20] / 96))
def run(ctx: protocol_api.ProtocolContext): global MM_TYPE # check source (elution) labware type source_plate = ctx.load_labware( 'opentrons_96_aluminumblock_nest_wellplate_100ul', '1', 'chilled elution plate on block from Station B') tips20 = [ ctx.load_labware('opentrons_96_filtertiprack_20ul', slot) for slot in ['3', '6', '8', '9', '10', '11'] ] tips300 = [ctx.load_labware('opentrons_96_filtertiprack_200ul', '2')] tempdeck = ctx.load_module('Temperature Module Gen2', '4') pcr_plate = tempdeck.load_labware( 'opentrons_96_aluminumblock_nest_wellplate_100ul', 'PCR plate') mm_strips = ctx.load_labware( 'opentrons_96_aluminumblock_nest_wellplate_100ul', '7', 'mastermix strips') tempdeck.set_temperature(4) tube_block = ctx.load_labware( 'opentrons_24_aluminumblock_nest_2ml_screwcap', '5', '2ml screw tube aluminum block for mastermix + controls') # pipette m20 = ctx.load_instrument('p20_multi_gen2', 'right', tip_racks=tips20) p300 = ctx.load_instrument('p300_single_gen2', 'left', tip_racks=tips300) # setup up sample sources and destinations num_cols = math.ceil(NUM_SAMPLES/8) sources = source_plate.rows()[0][:num_cols] sample_dests = pcr_plate.rows()[0][:num_cols] tip_log = {'count': {}} folder_path = '/data/C' tip_file_path = folder_path + '/tip_log.json' if TIP_TRACK and not ctx.is_simulating(): if os.path.isfile(tip_file_path): with open(tip_file_path) as json_file: data = json.load(json_file) if 'tips20' in data: tip_log['count'][m20] = data['tips20'] else: tip_log['count'][m20] = 0 if 'tips300' in data: tip_log['count'][p300] = data['tips300'] else: tip_log['count'][p300] = 0 else: tip_log['count'] = {m20: 0, p300: 0} else: tip_log['count'] = {m20: 0, p300: 0} tip_log['tips'] = { m20: [tip for rack in tips20 for tip in rack.rows()[0]], p300: [tip for rack in tips300 for tip in rack.wells()] } tip_log['max'] = { pip: len(tip_log['tips'][pip]) for pip in [m20, p300] } def pick_up(pip): nonlocal tip_log if tip_log['count'][pip] == tip_log['max'][pip]: ctx.pause('Replace ' + str(pip.max_volume) + 'µl tipracks before \ resuming.') pip.reset_tipracks() tip_log['count'][pip] = 0 pip.pick_up_tip(tip_log['tips'][pip][tip_log['count'][pip]]) tip_log['count'][pip] += 1 """ mastermix component maps """ mm_tube = tube_block.wells()[0] mm_dict = { 'volume': 15, 'components': { tube: vol for tube, vol in zip(tube_block.columns()[1][:3], [6.25, 1.25, 7.5]) } } vol_overage = 1.2 if NUM_SAMPLES > 48 else 1.1 # decrease overage for small sample number total_mm_vol = mm_dict['volume']*(NUM_SAMPLES+2)*vol_overage # translate total mastermix volume to starting height r = mm_tube.diameter/2 mm_height = total_mm_vol/(math.pi*(r**2)) - 5 def h_track(vol): nonlocal mm_height dh = 1.1*vol/(math.pi*(r**2)) # compensate for 10% theoretical volume loss mm_height = mm_height - dh if mm_height - dh > 2 else 2 # stop at 2mm above mm tube bottom return mm_tube.bottom(mm_height) if PREPARE_MASTERMIX: vol_overage = 1.2 if NUM_SAMPLES > 48 else 1.1 for i, (tube, vol) in enumerate(mm_dict['components'].items()): comp_vol = vol*(NUM_SAMPLES)*vol_overage pick_up(p300) num_trans = math.ceil(comp_vol/160) vol_per_trans = comp_vol/num_trans for _ in range(num_trans): p300.air_gap(20) p300.aspirate(vol_per_trans, tube) ctx.delay(seconds=3) p300.touch_tip(tube) p300.air_gap(20) p300.dispense(20, mm_tube.top()) # void air gap p300.dispense(vol_per_trans, mm_tube.bottom(2)) p300.dispense(20, mm_tube.top()) # void pre-loaded air gap p300.blow_out(mm_tube.top()) p300.touch_tip(mm_tube) if i < len(mm_dict['components'].items()) - 1: # only keep tip if last component and p300 in use p300.drop_tip() mm_total_vol = mm_dict['volume']*(NUM_SAMPLES)*vol_overage if not p300.hw_pipette['has_tip']: # pickup tip with P300 if necessary for mixing pick_up(p300) mix_vol = mm_total_vol / 2 if mm_total_vol / 2 <= 200 else 200 # mix volume is 1/2 MM total, maxing at 200µl mix_loc = mm_tube.bottom(20) if NUM_SAMPLES > 48 else mm_tube.bottom(5) p300.mix(7, mix_vol, mix_loc) p300.blow_out(mm_tube.top()) p300.touch_tip() # transfer mastermix to strips mm_strip = mm_strips.columns()[0] if not p300.hw_pipette['has_tip']: pick_up(p300) for i, well in enumerate(mm_strip): if NUM_SAMPLES % 8 == 0 or i < NUM_SAMPLES % 8: vol = num_cols*mm_dict['volume']*((vol_overage-1)/2+1) else: vol = (num_cols-1)*mm_dict['volume']*((vol_overage-1)/2+1) p300.transfer(vol, mm_tube, well, new_tip='never') p300.drop_tip() # transfer mastermix to plate mm_vol = mm_dict['volume'] pick_up(m20) m20.transfer(mm_vol, mm_strip[0].bottom(0.5), sample_dests, new_tip='never') m20.drop_tip() # transfer samples to corresponding locations for s, d in zip(sources, sample_dests): pick_up(m20) m20.transfer(SAMPLE_VOL, s.bottom(2), d.bottom(2), new_tip='never') m20.mix(1, 10, d.bottom(2)) m20.blow_out(d.top(-2)) m20.aspirate(5, d.top(2)) # suck in any remaining droplets on way to trash m20.drop_tip() # track final used tip if TIP_TRACK and not ctx.is_simulating(): if not os.path.isdir(folder_path): os.mkdir(folder_path) data = { 'tips20': tip_log['count'][m20], 'tips300': tip_log['count'][p300] } with open(tip_file_path, 'w') as outfile: json.dump(data, outfile)
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 # tube_rack = protocol.load_labware("opentrons_96_aluminumblock_generic_pcr_strip_200ul", "6", label = "aluminum block") # CBS and substrate stocks sample_plate = protocol.load_labware( "greiner_96_wellplate_323ul", "6", label="sample plate") # CBS and substrate stocks reservoir_plate = protocol.load_labware( "usascientific_12_reservoir_22ml", "8", label='reservoir plate') # DTNB detection reagent library_plate = protocol.load_labware( "greiner_96_wellplate_323ul", "5", label="library plate") # compound library # Specify tip racks tiprack1 = protocol.load_labware("opentrons_96_tiprack_10ul", '2') tiprack2 = protocol.load_labware("opentrons_96_tiprack_300ul", '3') # 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 112 uL # 20 uL is 2 mm high, tandem (middle) wall is 5.1 mm high p50.well_bottom_clearance.dispense = 3.5 # Specify target wells cols_compounds = [6, 7, 8, 9, 10] cols_noSAM = [9, 10, 11, 12, 13] cols_SAM = [14, 15, 16, 17, 18] wells_reaction_noSAM = ['A' + str(i) for i in cols_noSAM] wells_reaction_SAM = ['A' + str(i) for i in cols_SAM] wells_reaction = ['A' + str(i) for i in (cols_noSAM + cols_SAM)] wells_detection = ['B' + str(i) for i in (cols_noSAM + cols_SAM)] ####################################################################################################################################### ## PROCEDURE # Transfer 20uL detection reagent from reservoir to reaction plate p50.distribute( 20, reservoir_plate.columns_by_name()["1"], [reaction_plate.wells_by_name()[i] for i in wells_detection]) # Distribute 2uL compound from 96-well library plate onto odd rows p10.distribute( 2, library_plate.columns_by_name()["6"], [reaction_plate.wells_by_name()[i] for i in ["A9", "A14"]], new_tip='once', touch_tip=True) # each compound is tested w/ and w/o SAM (30 uM) p10.distribute(2, library_plate.columns_by_name()["7"], [reaction_plate.wells_by_name()[i] for i in ["A10", "A15"]], new_tip='once', touch_tip=True) p10.distribute(2, library_plate.columns_by_name()["8"], [reaction_plate.wells_by_name()[i] for i in ["A11", "A16"]], new_tip='once', touch_tip=True) p10.distribute(2, library_plate.columns_by_name()["9"], [reaction_plate.wells_by_name()[i] for i in ["A12", "A17"]], new_tip='once', touch_tip=True) p10.distribute(2, library_plate.columns_by_name()["10"], [reaction_plate.wells_by_name()[i] for i in ["A13", "A18"]], new_tip='once', touch_tip=True) # Distribute 10uL protein onto odd rows p50.distribute(10, sample_plate.columns_by_name()["4"], [reaction_plate.wells_by_name()[i] for i in wells_reaction], new_tip='once') # Transfer 8 uL reaction mix to reaction plate p50.distribute( 8, sample_plate.columns_by_name()["5"], [reaction_plate.wells_by_name()[i] for i in wells_reaction_noSAM], touch_tip=True) # no SAM p50.distribute( 8, sample_plate.columns_by_name()["6"], [reaction_plate.wells_by_name()[i] for i in wells_reaction_SAM], touch_tip=True) # SAM (30uM) # SAMPLE CODE # p20.transfer(20,reservoir_plate.wells_by_name()["A1"],mix_plate.wells_by_name()["A1"]) # p20.distribute(10,reservoir_plate.wells_by_name()["A2"],[mix_plate.wells_by_name()[well_name] for well_name in ["B1","C1","E1","G1","H1"]]) # p20.pick_up_tip() # p20.transfer(10,mix_plate.wells_by_name()["A1"],mix_plate.wells_by_name()["B1"],mix_after=(3,10),new_tip="never") # p20.transfer(10,mix_plate.wells_by_name()["B1"],mix_plate.wells_by_name()["C1"],mix_after=(3,10),new_tip="never") # p20.transfer(10,mix_plate.wells_by_name()["C1"],mix_plate.wells_by_name()["D1"],mix_after=(3,10),new_tip="never") # p20.transfer(10,mix_plate.wells_by_name()["D1"],mix_plate.wells_by_name()["E1"],mix_after=(3,10),new_tip="never") # p20.drop_tip() # p20.transfer(20,reservoir_plate.wells_by_name()["A3"],mix_plate.wells_by_name()["F1"]) # p20.pick_up_tip() # p20.transfer(10,mix_plate.wells_by_name()["F1"],mix_plate.wells_by_name()["G1"],mix_after=(3,10),new_tip="never") # p20.transfer(10,mix_plate.wells_by_name()["G1"],mix_plate.wells_by_name()["H1"],mix_after=(3,10),new_tip="never") # p20.drop_tip() # p10.transfer(4,mix_plate.wells_by_name()["A1"],mix_plate.wells_by_name()["A2"]) # p20.transfer(36,reservoir_plate.wells_by_name()["A4"],mix_plate.columns_by_name()["2"],new_tip='always') # p10.well_bottom_clearance.dispense = 1 # rows=["A","B","C","D","E","F","G","H"] # reaction_row_dest = "B" # p10.transfer(10,mix_plate.columns_by_name()["2"],[reaction_plate.wells_by_name()[well_name] for well_name in ["B2","B3","B4"]]) # # for row in rows: # # p20.distribute(10,mix_plate.wells_by_name()[(row+"2")],[reaction_plate.wells_by_name()[well_name] for well_name in [chr(ord(row)+1)+"2",chr(ord(row)+1)+"3",chr(ord(row)+1)+"4"]]) # p20.transfer(10,reservoir_plate.wells_by_name()["A4"],[reaction_plate.wells_by_name()[well_name] for well_name in ["J2","J3","J4"]])
def run(protocol: protocol_api.ProtocolContext): if debug: print(protocol) tiprack_300 = protocol.load_labware('opentrons_96_tiprack_300ul', labwarePositions.tiprack_300, "tiprack 300ul") if debug: print(tiprack_300) pipette_300 = protocol.load_instrument( 'p300_single_gen2' if pipette_300_GEN == 'GEN2' else 'p300_single', pipette_300_location, tip_racks=[tiprack_300]) # pipette_300 = protocol.load_instrument('p300_single', 'right', tip_racks=[tiprack_300]) pipette_300.flow_rate.dispense = default_flow_rate pipette_300.flow_rate.aspirate = default_flow_rate pipette_300.starting_tip = tiprack_300.wells()[tiprack_300_starting_pos - 1] # pipette_300.starting_tip = tiprack_300.well(tiprack_starting_pos['tiprack_300']) if debug: print(pipette_300) black_96 = protocol.load_labware(type_of_96well_plate, labwarePositions.antibodies_plate, type_of_96well_plate) trough12 = protocol.load_labware('parhelia_12trough', labwarePositions.buffers_reservoir, '12-trough buffers reservoir') if (not retrieval): par2 = protocol.load_labware(omniStainer_type, labwarePositions.par2, omniStainer_type) if retrieval: temp_mod = protocol.load_module('temperature module', labwarePositions.heatmodule) par2 = temp_mod.load_labware(omniStainer_type) wellslist = list(par2.wells_by_name().keys()) wellslist = wellslist[1:num_samples + 1] if debug: print(par2) buffer_wells = trough12.wells_by_name() buffers = Object() buffers.retrieval = buffer_wells['A1'] buffers.TBS_wash = buffer_wells['A2'] buffers.water = buffer_wells['A3'] buffers.storage = buffer_wells['A4'] buffers.eth_70perc_ = buffer_wells['A5'] buffers.eth_80perc = buffer_wells['A6'] buffers.eth_95perc = buffer_wells['A7'] buffers.eth_100perc = buffer_wells['A8'] buffers.hematoxylin = buffer_wells['A12'] preblock_wells = black_96.rows()[0] antibody_wells = black_96.rows()[5] enzymeblock_wells = black_96.rows()[1] hrpsecondaryab_wells = black_96.rows()[2] substrate_wells = black_96.rows()[3] DAB_wells = black_96.rows()[4] sample_chambers = [] for well in wellslist: sample_chambers.append(par2.wells_by_name()[well]) if debug: print(sample_chambers) #################PROTOCOL#################### protocol.home() if lid == 'yes': openPar2(protocol, pipette_300, par2) if retrieval: washSamples(pipette_300, buffers.retrieval, buffers.retrieval, 2, 1, extra_bottom_gap + 18) washSamples(pipette_300, buffers.retrieval, sample_chambers, wash_volume, 2, extra_bottom_gap) if lid == 'yes': closePar2(protocol, pipette_300, par2) temp_mod.set_temperature(95) print("retrieval") protocol.delay(minutes=15) # washSamples(pipette_300, buffers.retrieval, sample_chambers, wash_volume, 1, extra_bottom_gap) protocol.delay(minutes=15) # washSamples(pipette_300, buffers.retrieval, sample_chambers, wash_volume, 1, extra_bottom_gap) protocol.delay(minutes=15) print("cooling down to RT") temp_mod.set_temperature(25) protocol.delay(minutes=20) if lid == 'yes': openPar2(protocol, pipette_300, par2) # WASHING SAMPLES WITH TBS print("washing in TBS") washSamples(pipette_300, buffers.TBS_wash, buffers.TBS_wash, 2, 1, extra_bottom_gap + 18) washSamples(pipette_300, buffers.TBS_wash, sample_chambers, wash_volume, 2, extra_bottom_gap) # Preblocking print("preblocking") print(len(wellslist)) print("puncturing preblock wells") for i in range(len(wellslist)): print(i) washSamples(pipette_300, preblock_wells[i], preblock_wells[i], 2, 1, extra_bottom_gap + 18, keep_tip=True) pipette_300.drop_tip() print("applying the preblock") for i in range(len(wellslist)): print(i) washSamples(pipette_300, preblock_wells[i], sample_chambers[i], ab_volume, 1, extra_bottom_gap) print("preblocking incubation: 15 min") protocol.delay(minutes=15) # APPLYING ANTIBODY COCKTAILS TO SAMPLES print("puncturing and applying abs") for i in range(len(wellslist)): print(i) washSamples(pipette_300, antibody_wells[i], antibody_wells[i], 2, 1, extra_bottom_gap + 18, keep_tip=True) washSamples(pipette_300, antibody_wells[i], sample_chambers[i], ab_volume, 1, extra_bottom_gap) if lid == 'yes': closePar2(protocol, pipette_300, par2) # INCUBATE FOR DESIRED TIME print("staining incubation: " + str(primary_ab_incubation_time_minutes) + "min") protocol.delay(minutes=primary_ab_incubation_time_minutes) if lid == 'yes': openPar2(protocol, pipette_300, par2) # WASHING SAMPLES WITH TBS # three individual repeats below is because they need particular incubation time between them print("washing with TBS") for i in range(5): washSamples(pipette_300, buffers.TBS_wash, sample_chambers, wash_volume, 1, extra_bottom_gap) protocol.delay(minutes=3) # APPLYING enzyme blocking print("puncturing enzyme blocking wells") for i in range(len(wellslist)): washSamples(pipette_300, enzymeblock_wells[i], enzymeblock_wells[i], 2, 1, extra_bottom_gap + 18, keep_tip=True) pipette_300.drop_tip() print("applying enzyme blocking") for i in range(len(wellslist)): washSamples(pipette_300, enzymeblock_wells[i], sample_chambers[i], ab_volume, 1, extra_bottom_gap) # INCUBATE 10 MIN print("hrp blocking incubation: 10min") protocol.delay(minutes=10) washSamples(pipette_300, buffers.TBS_wash, sample_chambers, wash_volume, 3, extra_bottom_gap) # APPLYING HRP SECONDARY ANTIBODY COCKTAILS TO SAMPLES print("puncturing hrpsecondaryab wells") for i in range(len(wellslist)): washSamples(pipette_300, hrpsecondaryab_wells[i], hrpsecondaryab_wells[i], 2, 1, extra_bottom_gap + 18, keep_tip=True) pipette_300.drop_tip() print("applying hrpsecondaryab") for i in range(len(wellslist)): washSamples(pipette_300, hrpsecondaryab_wells[i], sample_chambers[i], ab_volume, 1, extra_bottom_gap) if lid == 'yes': closePar2(protocol, pipette_300, par2) # INCUBATE FOR DESIRED TIME print("staining incubation: " + str(secondary_ab_incubation_time_minutes) + "min") protocol.delay(minutes=secondary_ab_incubation_time_minutes) if lid == 'yes': openPar2(protocol, pipette_300, par2) # three individual repeats below is because they need particular incubation time between them print("washing with TBS") for i in range(3): washSamples(pipette_300, buffers.TBS_wash, sample_chambers, wash_volume, 1, extra_bottom_gap) protocol.delay(minutes=3) # DILUTING AND APPLYING THE DAB print("puncturing the DAB wells") for i in range(len(wellslist)): washSamples(pipette_300, DAB_wells[i], DAB_wells[i], 2, 1, extra_bottom_gap + 18) print("puncturing the substrate wells") for i in range(len(wellslist)): washSamples(pipette_300, substrate_wells[i], substrate_wells[i], 2, 1, extra_bottom_gap + 18, keep_tip=True) pipette_300.drop_tip() print("applying DAB") for i in range(len(wellslist)): dilute_and_apply_fixative(pipette_300, DAB_wells[i], substrate_wells[i], sample_chambers[i], wash_volume) print("developing substrate") protocol.delay(minutes=10) washSamples(pipette_300, buffers.water, buffers.water, 2, 1, extra_bottom_gap + 18) washSamples(pipette_300, buffers.water, sample_chambers, wash_volume, 5, extra_bottom_gap) if lid == 'yes': closePar2(protocol, pipette_300, par2)
def run(protocol: protocol_api.ProtocolContext): # which steps should be run? AddBeads = True AddBindingBuffer = True CaptureBinding = True Wash1 = True Wash2 = True Wash2repeat = True Dry = True Elute = True # set tweakable variables elution_volume = 100 # ul of water to add to final beads elution_to_plate = 70 # ul to transfer to final elution plate capture_depth = -3 # depth below ideal bottom of plate to remove supernatants, this may be required as a function of a poor calibration or labware def capture_min = 2 # number of minutes to capture beads on magnets cols_to_extract = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12] # which columns should be extracted? nmix = 5 # number of times to pipette to mix drying_min = 20 # number of minutes to evaporate residual ethanol !!!! SET TO 20 trash_speed = 1 # the relative speed to discard of liquids into trash, this is an integer multiplier of normal speed, set higher to clear bubbles on outside of tip # define deck layout MagModule = protocol.load_module('magnetic module gen2', 10) BindingPlate = MagModule.load_labware('nest_96_wellplate_2ml_deep') # use the ElutionPlate = protocol.load_labware('biorad_96_wellplate_200ul_pcr', '3') # an empty biorad 96 well plate BeadsAndWater = protocol.load_labware('usascientific_12_reservoir_22ml', '2') # magbeads in A1 (4 mL), water in A2 (10mL), the end columns will be used for waste BindingBuffer = protocol.load_labware('agilent_1_reservoir_290ml', '7') # reservoir with 70 mL binding buffer MagWash1 = protocol.load_labware('agilent_1_reservoir_290ml', '4') # reservoir with 100 mL magwash1 MagWash2 = protocol.load_labware('agilent_1_reservoir_290ml', '1') # reservoir with 200 mL magwash2 tips_binding = protocol.load_labware('opentrons_96_filtertiprack_200ul', '11') tips_wash1 = protocol.load_labware('opentrons_96_filtertiprack_200ul', '8') tips_wash2 = protocol.load_labware('opentrons_96_filtertiprack_200ul', '5') tips_wash2_repeat = protocol.load_labware('opentrons_96_filtertiprack_200ul', '9') tips_elution = protocol.load_labware('opentrons_96_filtertiprack_200ul', '6') fixed_trash = protocol.fixed_trash['A1'] set_rail_lights = True # define pipettes multichannel = protocol.load_instrument('p300_multi_gen2', 'left', tip_racks=[tips_binding, tips_wash1, tips_wash2, tips_wash2_repeat, tips_elution]) #P1000 = protocol.load_instrument('p1000_single_gen2', 'right', tip_racks=[tips_binding, tips_wash1, tips_wash2, tips_wash2rep]) ### Prerun setup ######################################## MagModule.disengage() ### MAG BINDING ###################################### if AddBindingBuffer: protocol.comment('--------->Adding 600 ul binding buffer') multichannel.pick_up_tip(tips_binding['A1']) for i in cols_to_extract: multichannel.aspirate(200, BindingBuffer['A1']) multichannel.dispense(200, BindingPlate['A'+str(i)].top(4)) #multichannel.blow_out() multichannel.aspirate(200, BindingBuffer['A1']) multichannel.dispense(200, BindingPlate['A'+str(i)].top(4)) #multichannel.blow_out() multichannel.aspirate(200, BindingBuffer['A1']) multichannel.dispense(200, BindingPlate['A'+str(i)].top(4)) #multichannel.blow_out() multichannel.return_tip() if AddBeads: protocol.comment('--------->Adding 25ul mag beads') multichannel.pick_up_tip(tips_binding['A2']) multichannel.mix(10, 100, BeadsAndWater['A1'].bottom(3)) # mix beads 20 x by pulling up 100ul for i in cols_to_extract: multichannel.aspirate(25, BeadsAndWater['A1']) multichannel.dispense(25, BindingPlate['A'+str(i)].top(4) multichannel.return_tip() for i in cols_to_extract: multichannel.pick_up_tip(tips_binding['A'+str(i)]) multichannel.mix(10, 200, BeadsAndWater['A1'].bottom(3)) multichannel.return_tip() if CaptureBinding: protocol.comment('--------->Removing Binding Buffer') MagModule.engage() protocol.delay(minutes=capture_min) for i in cols_to_extract: multichannel.pick_up_tip(tips_binding['A'+str(i)]) multichannel.aspirate(200, BindingPlate['A'+str(i)]) multichannel.dispense(200, fixed_trash, rate = trash_speed) #multichannel.blow_out() multichannel.touch_tip() multichannel.aspirate(200, BindingPlate['A'+str(i)]) multichannel.dispense(200, fixed_trash, rate = trash_speed) #multichannel.blow_out() multichannel.touch_tip() multichannel.aspirate(200, BindingPlate['A'+str(i)]) multichannel.dispense(200, fixed_trash, rate = trash_speed) #multichannel.blow_out() multichannel.aspirate(200, BindingPlate['A'+str(i)].bottom(capture_depth), rate=0.2) multichannel.dispense(200, fixed_trash, rate = trash_speed) #multichannel.blow_out() multichannel.return_tip() if Wash1: protocol.comment('--------->Doing Wash 1') MagModule.disengage() multichannel.pick_up_tip(tips_wash1['A1']) for i in cols_to_extract: multichannel.aspirate(200, MagWash1['A1']) multichannel.dispense(200, BindingPlate['A'+str(i)].top(4)) #multichannel.blow_out() multichannel.aspirate(200, MagWash1['A1']) multichannel.dispense(200, BindingPlate['A'+str(i)].top(4)) #multichannel.blow_out() multichannel.aspirate(200, MagWash1['A1']) multichannel.dispense(200, BindingPlate['A'+str(i)].top(4)) #multichannel.blow_out() multichannel.aspirate(200, MagWash1['A1']) multichannel.dispense(200, BindingPlate['A'+str(i)].top(4)) #multichannel.blow_out() multichannel.return_tip() for i in cols_to_extract: multichannel.pick_up_tip(tips_wash1['A'+str(i)]) multichannel.aspirate(100, MagWash1['A1']) multichannel.dispense(100, BindingPlate['A'+str(i)]) multichannel.mix(nmix, 180, BindingPlate['A'+str(i)].bottom(2)) multichannel.blow_out() multichannel.return_tip() MagModule.engage() protocol.delay(minutes=capture_min) for i in cols_to_extract: multichannel.pick_up_tip(tips_wash1['A'+str(i)]) multichannel.aspirate(200, BindingPlate['A'+str(i)]) multichannel.dispense(200, fixed_trash, rate = trash_speed) #multichannel.blow_out() multichannel.aspirate(200, BindingPlate['A'+str(i)]) multichannel.dispense(200, fixed_trash, rate = trash_speed) #multichannel.blow_out() multichannel.aspirate(200, BindingPlate['A'+str(i)]) multichannel.dispense(200, fixed_trash, rate = trash_speed) #multichannel.blow_out() multichannel.aspirate(200, BindingPlate['A'+str(i)]) multichannel.dispense(200, fixed_trash, rate = trash_speed) #multichannel.blow_out() multichannel.aspirate(200, BindingPlate['A'+str(i)].bottom(capture_depth), rate=0.2) multichannel.dispense(200, fixed_trash, rate = trash_speed) multichannel.blow_out() multichannel.return_tip() if Wash2: protocol.comment('--------->Doing Wash 2') MagModule.disengage() multichannel.pick_up_tip(tips_wash2['A1']) for i in cols_to_extract: multichannel.aspirate(200, MagWash2['A1']) multichannel.dispense(200, BindingPlate['A'+str(i)].top(4)) #multichannel.blow_out() multichannel.aspirate(200, MagWash2['A1']) multichannel.dispense(200, BindingPlate['A'+str(i)].top(4)) #multichannel.blow_out() multichannel.aspirate(200, MagWash2['A1']) multichannel.dispense(200, BindingPlate['A'+str(i)].top(4)) #multichannel.blow_out() multichannel.aspirate(200, MagWash2['A1']) multichannel.dispense(200, BindingPlate['A'+str(i)].top(4)) #multichannel.blow_out() multichannel.return_tip() for i in cols_to_extract: multichannel.pick_up_tip(tips_wash2['A'+str(i)]) multichannel.aspirate(100, MagWash2['A1']) multichannel.dispense(100, BindingPlate['A'+str(i)]) multichannel.mix(nmix, 180, BindingPlate['A'+str(i)].bottom(2)) multichannel.blow_out() multichannel.return_tip() MagModule.engage() protocol.delay(minutes=capture_min) for i in cols_to_extract: multichannel.pick_up_tip(tips_wash2['A'+str(i)]) multichannel.aspirate(200, BindingPlate['A'+str(i)]) multichannel.dispense(200, fixed_trash, rate = trash_speed) #multichannel.blow_out() multichannel.aspirate(200, BindingPlate['A'+str(i)]) multichannel.dispense(200, fixed_trash, rate = trash_speed) #multichannel.blow_out() multichannel.aspirate(200, BindingPlate['A'+str(i)]) multichannel.dispense(200, fixed_trash, rate = trash_speed) #multichannel.blow_out() multichannel.aspirate(200, BindingPlate['A'+str(i)]) # is this a calibration issue? multichannel.dispense(200, fixed_trash, rate = trash_speed) #multichannel.blow_out() multichannel.aspirate(200, BindingPlate['A'+str(i)].bottom(capture_depth), rate=0.2) multichannel.dispense(200, fixed_trash, rate = trash_speed) #multichannel.blow_out() multichannel.return_tip() if Wash2repeat: protocol.comment('--------->Repeating Wash 2') MagModule.disengage() multichannel.pick_up_tip(tips_wash2_repeat['A1']) for i in cols_to_extract: multichannel.aspirate(200, MagWash2['A1']) multichannel.dispense(200, BindingPlate['A'+str(i)].top(4)) #multichannel.blow_out() multichannel.aspirate(200, MagWash2['A1']) multichannel.dispense(200, BindingPlate['A'+str(i)].top(4)) #multichannel.blow_out() multichannel.aspirate(200, MagWash2['A1']) multichannel.dispense(200, BindingPlate['A'+str(i)].top(4)) #multichannel.blow_out() multichannel.aspirate(200, MagWash2['A1']) multichannel.dispense(200, BindingPlate['A'+str(i)].top(4)) #multichannel.blow_out() multichannel.return_tip() for i in cols_to_extract: multichannel.pick_up_tip(tips_wash2_repeat['A'+str(i)]) multichannel.aspirate(100, MagWash2['A1']) multichannel.dispense(100, BindingPlate['A'+str(i)]) multichannel.mix(nmix, 180, BindingPlate['A'+str(i)].bottom(5)) multichannel.blow_out() multichannel.return_tip() MagModule.engage() protocol.delay(minutes=capture_min) for i in cols_to_extract: multichannel.pick_up_tip(tips_wash2_repeat['A'+str(i)]) multichannel.aspirate(200, BindingPlate['A'+str(i)]) multichannel.dispense(200, fixed_trash, rate = trash_speed) #multichannel.blow_out() multichannel.aspirate(200, BindingPlate['A'+str(i)]) multichannel.dispense(200, fixed_trash, rate = trash_speed) #multichannel.blow_out() multichannel.aspirate(200, BindingPlate['A'+str(i)]) multichannel.dispense(200, fixed_trash, rate = trash_speed) #multichannel.blow_out() multichannel.aspirate(200, BindingPlate['A'+str(i)]) # is this a calibration issue? multichannel.dispense(200, fixed_trash, rate = trash_speed) #multichannel.blow_out() multichannel.aspirate(200, BindingPlate['A'+str(i)].bottom(capture_depth), rate=0.2) multichannel.dispense(200, fixed_trash, rate = trash_speed) #multichannel.blow_out() multichannel.return_tip() if Dry: protocol.comment('--------->Drying DNA') protocol.delay(minutes=drying_min) if Elute: protocol.comment('--------->Eluting DNA') MagModule.disengage() for i in cols_to_extract: multichannel.pick_up_tip(tips_elution['A'+str(i)]) multichannel.aspirate(elution_volume, BeadsAndWater['A2']) multichannel.dispense(elution_volume, BindingPlate['A'+str(i)]) multichannel.mix(nmix, elution_to_plate, BindingPlate['A'+str(i)].bottom(capture_depth)) #multichannel.blow_out() multichannel.return_tip() MagModule.engage() protocol.delay(minutes=capture_min) for i in cols_to_extract: multichannel.pick_up_tip(tips_elution['A'+str(i)]) multichannel.aspirate(elution_to_plate, BindingPlate['A'+str(i)].bottom(capture_depth+1), rate=0.2) multichannel.dispense(elution_to_plate, ElutionPlate['A'+str(i)]) #multichannel.blow_out() multichannel.return_tip()
def run(protocol: protocol_api.ProtocolContext): ################### SETTING UP ################### ## ## ## ヽ༼ຈل͜ຈ༽ノ LABWARE ヽ༼ຈل͜ຈ༽ノ ## ## ## ################################################## # Positions are: # 10 11 TRASH # 7 8 9 # 4 5 6 # 1 2 3 #Modules, plate and MAGNET HEIGHT magneto = protocol.load_module("magneticModuleV2", 6) deepPlate = magneto.load_labware("eppendorf_96_deepwell_2ml", label="Deep well") magnetHeight = 6.7 ######################################################################################################### ## We have tested appropriate height on GEN1 magdeck for different plates, these are the chosen ones ## ## ## ## Zymoresearch - "zymoresearch_96_deepwell_2.4ml" - 12.5mm ## ## Eppendorf - "eppendorf_96_deepwell_2ml" - 11.8 mm ## ## Starlab - "usascientific_96_wellplate_2.4ml_deep" - E2896-1810 11.4mm ## ## Macherey-Nagel - - 10mm ## ######################################################################################################### #Plates reagents = protocol.load_labware("nest_12_reservoir_15ml", 5, label="Reagents reservoir") waste = protocol.load_labware("nest_12_reservoir_15ml", 9, label="Liquid waste reservoir") outplate = protocol.load_labware("eppendorf96_skirted_150ul", 1, label="Output plate") #Tips - Ordered in the way they are used parkingRack = protocol.load_labware("opentrons_96_filtertiprack_200ul", 3) tiprack1 = protocol.load_labware("opentrons_96_filtertiprack_200ul", 2) tiprack4 = protocol.load_labware("opentrons_96_filtertiprack_200ul", 4) tiprack7 = protocol.load_labware("opentrons_96_filtertiprack_200ul", 7) tiprack8 = protocol.load_labware("opentrons_96_filtertiprack_200ul", 8) tiprack10 = protocol.load_labware("opentrons_96_filtertiprack_200ul", 10) tipracks = [tiprack10, tiprack8, tiprack7, tiprack4, tiprack1] availableTips = [] for rack in tipracks: for i in range(1, 13): availableTips.append(rack["A" + str(i)]) #To take a tip, just use availableTips.pop() and voila! #There are enough tips for 6 samples, and a tiprack will end up half-full #Tips are taken from right to left instead of the normal way #I am using this dictionary method because it makes it easier to modify later the script for 96 samples/ #Pipettes p300 = protocol.load_instrument("p300_multi_gen2", "left") ################### SETTING UP ################### ## ## ## ヽ༼ຈل͜ຈ༽ノ BASIC VARIABLES ヽ༼ຈل͜ຈ༽ノ ## ## ## ################################################## #RUN SETTINGS runColumns = 3 # Range 1-6. Samples should be a multiple of 8, or you will waste reagents. mixRepeats = 15 # Used everytime there is mixing, except when mixing beads. beadsMixRepeats = 10 # Used when mixing beads in reservoir. This happens when pipetting column 1, 3 and 6. waterMixRepeats = 20 # Used when mixing elute. #Mixing settings washMixing = 100 # volume (ul) waterMixing = 25 # volume (ul) bottomHeight = 0.5 # Distance relative to real labware's bottom. Used when removing supernatant and moving elution. bottomMixHeight = 0.8 # Distance relative to real labware's bottom. Used when mixing SamplePlusProteinaseHeight = 3 # For a volume of 260.. SamplePlusProteinasePlusBeadsHeight = 5.75 # For a volume of 465... generalHeight = 4 # Used always except when mixing beads in reservoir - Units relative to well bottom (mm). For a vol of 280... beadsHeight = 10 # Used when mixing beads in reservoir - Units relative to well bottom (mm). When mixing beads in the reagent well - Maybe I should modify this and make it depend on runColumns #Incubation times - Minutes incubationProteinase = 10 incubationBeadsNoMagnet = 5 # After adding the beads, we incubate them for 5 min without magnet. incubationBeadsMagnet = 5 * 2 incubationWash = 3 * 2 incubationDry = 10 # After removing final wash, the beads are left to dry for a while. incubationWater = 5 # After mixing. No magnet. incubationWaterMagnet = 1 * 2 # After incubationWater. #Transference volumes - ul originalVol = 140 #This is not used for transfers, it is here mostly to make volumes clearer to understand proteinaseVol = 112 beadsVol = 143.5 washVol = 280 #Used for WBE and Ethanol1 and Ethanol2 dilutionVol = 50 initialSupernatant = originalVol + proteinaseVol + beadsVol #Reagent position in reservoir - Positions go from A1 to A12 (Left to right) proteinase = reagents["A1"] beads = reagents["A2"] WBE = reagents["A3"] ethanol1 = reagents["A4"] ethanol2 = reagents["A5"] water = reagents["A12"] ######################################################################################################### ## Use these formulae to identify how much volume you need based on number of columns ## ## Each reservoir well has dimensions W=8.20, L=127.76, H=31.40. To make sure there is ## ## a pool of extra content with 0.5mm of height, add 292ul (300) extra (8.20*127.76*0.05) ## ## ## ## Proteinase = (896 * runColumns) + 292 ul ## ## Beads = (1152 * Columns) + 292 ul ## ## WBE = (2240 * Columns) + 292 ul ## ## Ethanol1 = (2240 * Columns) + 292 ul ## ## Ethanol2 = (2240 * Columns) + 292 ul ## ## Water = (640 * Columns) + 292 ul ## ######################################################################################################### ################### SETTING UP ################### ## ## ## ヽ༼ຈل͜ຈ༽ノ ADVANCED VARIABLES ヽ༼ຈل͜ຈ༽ノ ## ## ## ################################################## #Column accesion list - As we wont work in all physically available columns, this list makes it easier to manage columnID = ["A1", "A3", "A5", "A7", "A9", "A11"] # These are the columns that can be used columnID = columnID[: runColumns] # Here we trim the list, to get only the number of columns chosen in runColumns #Pipette settings tipVolume = 180 # max volume to be transported in a single trip. These tips are 200ul, but if we use the entire volumen, it might touch the filter topOffset = -5 # I use this to make sure the tip stays inside the well, to avoid it spilling out while dispensing p300.flow_rate.aspirate = 50 # Flow rate in ul / second p300.flow_rate.dispense = 150 p300.flow_rate.blow_out = 200 #Flows are reduced compared to default values to avoid the production of air or foam during handling. #Volume used when mixing beads (ul) if runColumns == 1: beadsMixing = 140 else: beadsMixing = tipVolume ################### SETTING UP ################### ## ## ##(づ。◕‿‿◕。)づ FUNCTIONS (づ。◕‿‿◕。)づ ## ## ## ################################################## def clock(time, stop=False): """ The uncertainty of not knowing how much time is left in an incubation is horrible. This makes it more bearable. This function takes the duration of the incubation and outputs a message every minute to keep track of the time more easily """ while time > 0: time -= 1 protocol.delay(minutes=1) protocol.comment("Only %s minutes more! Hold in there!" % time) if time == 1 and stop == True: protocol.pause() def meneillo(pipette, pos, reps=10, distance=0.25): pipette.move_to(pos) for _ in range(reps): p300.move_to(pos.move(types.Point(x=distance, y=0, z=0))) p300.move_to(pos.move(types.Point(x=-distance, y=0, z=0))) def remove_tip(pipette, tip): """ Originally, I had a special behaviour to drop the tips, but I stopped using it. I keep this function because it makes it easy to change drop_tip() to return_tip() for test runs """ pipette.drop_tip() def retrieve_tip(pipette, tip): """ Originally, the robot took a tip, went to the top of the well it was going to work with, and aspired 20 ul there, but now we are making it aspire 20 ul after taking the tip """ pipette.pick_up_tip(tip) def well_mix(vol, loc, reps, height=generalHeight, moveSide=0, bottomHeight=bottomMixHeight): """ Aspirates <vol> from bottom of well and dispenses it from <height> <reps> times loc1 is a position at 0.3mm over the bottom of the well loc2 is a position in the same x and y posiiton than loc1, but at <height>mm over the bottom of the well The idea here is to take liquid to the very bottom and pour it from a higher point, to mix things """ p300.flow_rate.aspirate = 1000 p300.flow_rate.dispense = 1000 loc1 = loc.bottom().move( types.Point(x=0 + moveSide, y=0, z=bottomHeight)) loc2 = loc.bottom().move(types.Point(x=0 + moveSide, y=0, z=height)) for _ in range(reps): p300.aspirate(vol, loc1) p300.dispense(vol, loc2) p300.dispense(20, loc.top(topOffset)) p300.flow_rate.aspirate = 50 p300.flow_rate.dispense = 150 def remove_supernatant(vol, columnID, wasteID, reagentName="Something", pipette=p300): """ While <vol> is bigger than <tipVolume>, it divides it in ceilling(<vol>/<tipVolume>) trips. (So, if it is 396ul, we have 2 180ul trips and a 36ul trip) Flow rate is in ul/second In the move() function, positive X means 'move to the right'. With the wells we use (Column 1,3,5,7,9 and 11) pellet is placed to the right, so we use a small offset to the left """ p300.flow_rate.aspirate = 20 # In this case we reduce the flow even more to make sure the precipitate is okay. We don't wanna bother the lad protocol.comment( "\n\nREMOVING STEP: Removing %s ul of supernatant (%s) while magnet is still engaged" % (vol, reagentName)) dump = waste[wasteID] for index, ID in enumerate(columnID): currentip = parkingRack[ID] dump = waste[ID] src = deepPlate[ID] retrieve_tip(pipette, currentip) tvol = vol while tvol > tipVolume: p300.dispense(20, src.top(topOffset)) p300.transfer(tipVolume, src.bottom().move( types.Point(x=-1, y=0, z=bottomHeight)), dump.top(topOffset), new_tip="never") #Slightly to the left meneillo( p300, dump.top(topOffset) ) #In case something is TheOppositeOfDense and just drips down p300.dispense( 20 ) #Make sure we expel everything that must be expelled. We dont want to move droplets around. tvol -= tipVolume p300.dispense(20, src.top(topOffset)) p300.transfer(tvol, src.bottom().move( types.Point(x=-1, y=0, z=bottomHeight)), dump.top(topOffset), new_tip="never") meneillo(p300, dump.top(topOffset)) remove_tip(pipette, currentip) p300.flow_rate.aspirate = 50 def slow_transfer(vol, reagent, columnID, reagentName, mixVol=washMixing, repeats=mixRepeats, mixReagent=False, altura=generalHeight, magnetTime=True, incubationTime=incubationWash, moveSide=0, extraVol=0, pipette=p300, removalStepAfter=True): """ Similar to remove_supernatant, but the other way around. It transfers from point A to point B in <tipVol> ul trips and pours liquid from the top, to avoid contaminating the tip while transfering all the necessary volume. It also includes incubation and magnet """ protocol.comment( "\n\nADDING STEP: Transfering %s ul of %s to samples" % (vol, reagentName)) for index, ID in enumerate(columnID): src = reagent to = deepPlate[ID] currentip = availableTips.pop() retrieve_tip(p300, currentip) if (mixReagent == True) and ( index == 0 or index == 2 or index == 5 ): #If the reagent is to be mixed, and we are in column 1, 3 or 6, mix it. We mix three times to make sure we dont have differences protocol.comment("Mixing %s" % reagentName) well_mix( vol=beadsMixing, loc=beads, reps=beadsMixRepeats, height=beadsHeight, moveSide=0 ) #We only do this with magnetic beads, that's why we use those variable names p300.blow_out(beads.top()) tvol = vol while tvol > tipVolume: p300.dispense(20, src.top()) p300.transfer(tipVolume, src.bottom().move( types.Point(x=0, y=0, z=bottomHeight)), to.top(topOffset), new_tip="never", air_gap=extraVol) protocol.delay(seconds=2) p300.blow_out() tvol -= tipVolume p300.dispense(20, src.top()) p300.transfer(tvol, src.bottom().move( types.Point(x=0, y=0, z=bottomHeight)), to.center(), new_tip="never", air_gap=extraVol) protocol.delay(seconds=2) well_mix(vol=mixVol, loc=to, reps=repeats, moveSide=moveSide, height=altura) if removalStepAfter == True: pipette.drop_tip(parkingRack[ID]) else: remove_tip(pipette, currentip) #Incubation if magnetTime == True: protocol.comment("Engaging magnet") magneto.engage(height=magnetHeight) protocol.comment("Incubating for %s minutes" % incubationTime) clock(time=incubationTime) ################# GO, VASILY, GO ################# ## ## ## ୧༼ಠ益ಠ༽୨ PROTOCOL ୧༼ಠ益ಠ༽୨ ## ## ## ################################################## magneto.disengage() #In case it is engaged from previous protocols. protocol.comment("We are working with column IDs: %s" % columnID) protocol.comment("\n\nSamples should have an initial volume of %s ul" % originalVol) #STEP 1: Add Proteinase K/LBF. slow_transfer(vol=proteinaseVol, reagent=proteinase, reagentName="Proteinase K/LBF", incubationTime=incubationProteinase, columnID=columnID, magnetTime=False, altura=SamplePlusProteinaseHeight, removalStepAfter=False) #INCUBATION 1: 10 min [Total: 10 min] #STEP 2: mix magnetic beads, add them to samples and mix sample well. No slow_transfer function for the same reasons as before. protocol.comment("\n\nEnough incubation, time to do s t u f f") slow_transfer(vol=beadsVol, reagent=beads, reagentName="Magnetic beads", incubationTime=incubationBeadsNoMagnet, columnID=columnID, mixReagent=True, magnetTime=False, extraVol=10, altura=SamplePlusProteinasePlusBeadsHeight) #INCUBATION 2: 5 min without magnet [Total: 15 min] protocol.comment( "Engaging magnet and keeping this incubation going for other %s minutes" % incubationBeadsMagnet) magneto.engage(height=magnetHeight) clock(time=incubationBeadsMagnet, stop=True) #INCUBATION 3: 5 min incubation with magnet [Total: 20 min] #STEP 3: Remove magnetic beads supernatant remove_supernatant(vol=initialSupernatant, wasteID="A1", reagentName="beads and proteinase", columnID=columnID) protocol.comment("Disengaging magnet") magneto.disengage() #STEP 4: Add 280 ul of Wash WBE slow_transfer(vol=washVol, reagent=WBE, reagentName="WBE", incubationTime=incubationWash, columnID=columnID) #INCUBATION 4: 3 min incubaton with magnet [Total: 23 min] #STEP 5: Removing WBE Supernatant remove_supernatant(vol=washVol, wasteID="A2", reagentName="WBE", columnID=columnID) protocol.comment("Disengaging magnet") magneto.disengage() #STEP 6: First wash with Eth, tips_transfer)anol slow_transfer(vol=washVol, reagent=ethanol1, reagentName="Ethanol 70% (First time)", incubationTime=incubationWash, columnID=columnID) #INCUBATION 5: 3 min incubaton with magnet [Total: 26 min] #STEP 7: Removing the supernatant of first wash with Ethanol remove_supernatant(vol=washVol, wasteID="A3", reagentName="Ethanol 70% (First time)", columnID=columnID) protocol.comment("Disengaging magnet") magneto.disengage() #STEP 8: Second wash with Ethanol slow_transfer(vol=washVol, reagent=ethanol2, reagentName="Ethanol 70% (Second time)", incubationTime=incubationWash, columnID=columnID) #INCUBATION 6: 3 min incubaton with magnet [Total: 26 min] #STEP 9: Removing the supernatant of second wash with Ethanol remove_supernatant(vol=washVol, wasteID="A4", reagentName="Ethanol 70% (Second time)", columnID=columnID) #INCUBATION 7: 5 min incubaton with magnet [Total: 31 min] protocol.comment( "This time, I do not disengage the magnet and let the beads dry for %s min" % incubationDry) clock(time=incubationDry) #STEP 10: Diluting samples in 80 ul of RNAse free water protocol.comment("Disengaging magnet") magneto.disengage() protocol.comment("Diluting samples in %s ul of RNAse free water" % dilutionVol) slow_transfer(vol=dilutionVol, reagent=water, reagentName="RNAse-free water", incubationTime=incubationWater, columnID=columnID, mixVol=waterMixing, magnetTime=False, repeats=waterMixRepeats) #Moving tip on top of pellet #INCUBATION 8: 5 min incubaton WITHOUT magnet [Total: 36 min] protocol.comment("Engaging magnet now!") magneto.engage(height=magnetHeight) clock(time=incubationWaterMagnet) #INCUBATION 9: 3 min incubaton WITH magnet [Total: 39 min] #STEP 11: Transfering samples to output plate protocol.comment( "Transfering DNA to output plate while magnet is still engaged") p300.flow_rate.aspirate = 20 for index, ID in enumerate(columnID): currentip = availableTips.pop() retrieve_tip(p300, currentip) src = deepPlate[ID] to = outplate[ID] p300.dispense(20, src.top()) p300.transfer(dilutionVol, src.bottom().move(types.Point(x=-1, y=0, z=bottomHeight)), to.bottom(5), new_tip="never") protocol.delay(seconds=2) p300.dispense(20) remove_tip(p300, currentip) magneto.disengage() protocol.comment("\n\nFecho!")
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') # sectempdeck = protocol.load_module('tempdeck', '4') pcr_plate = tempdeck.load_labware('abi_96_wellplate_250ul') # stds_rack = sectempdeck.load_labware('opentrons_24_aluminumblock_generic_2ml_screwcap') ww_plate1 = protocol.load_labware('bioer_96_wellplate_2200ul', '1') # PIPETTES p20 = protocol.load_instrument( 'p20_single_gen2', 'right', tip_racks=[tiprack20] ) # REAGENTS N2 = fuge_rack['A1'] # LU MasterMix N1 = fuge_rack['B1'] # water LUPositive = fuge_rack['D6'] # LU Positive Control plasmid mixes = [N2, N1] # LISTS rows = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'] N2_cols = [1, 2, 3, 4, 5, 6] N1_cols = [7, 8, 9, 10, 11, 12] # #### COMMANDS ###### # aspirate mmix to all wells in 96w plate; 15*48 = 720ul*1.1=792 h_list = tip_heightsEpp(792, 48, 15) for y, pcrmix in enumerate(mixes): #12 cols p20.pick_up_tip() well_num = 1 for z in range(1,7): for row in rows: #8 rows # print (y) col = 6*y+z dest = row+str(col) # print ("height is: ", h_list[well_num-1]) p20.aspirate(15, pcrmix.bottom(h_list[well_num-1]), rate=0.75) #head vol for more accurate pipetting protocol.delay(seconds=1) #equilibrate p20.move_to(pcrmix.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() tot_ww_plates = [ww_plate1] for x, ww_plate in enumerate(tot_ww_plates): for col in range(0,1): #samples in col 5, 11 for row in rows: p20.pick_up_tip() source = row + str(6*col+5) #A5, B5, C5 dest1 = row + str(6*x+6*col+1) #A1, #A2, #A3 dest2 = row + str(6*x+6*col+2) dest3 = row + str(6*x+6*col+3) dest4 = row + str(6*x+6*col+4) dest5 = row + str(6*x+6*col+5) dest6 = row + str(6*x+6*col+6) dest7 = row + str(6*x+6*col+7) dest8 = row + str(6*x+6*col+8) dest9 = row + str(6*x+6*col+9) dest10 = row + str(6*x+6*col+10) dest11 = row + str(6*x+6*col+11) dest12 = row + str(6*x+6*col+12) p20.aspirate(18, ww_plate[source].bottom(1)) protocol.delay(seconds=2) #equilibrate 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() p20.pick_up_tip() p20.aspirate(18, ww_plate[source].bottom(1)) protocol.delay(seconds=2) #equilibrate p20.dispense(5, pcr_plate[dest4].bottom(1)) p20.touch_tip() p20.dispense(5, pcr_plate[dest5].bottom(1)) p20.touch_tip() p20.dispense(5, pcr_plate[dest6].bottom(1)) p20.touch_tip() p20.drop_tip() p20.pick_up_tip() p20.aspirate(18, ww_plate[source].bottom(1)) protocol.delay(seconds=2) #equilibrate p20.dispense(5, pcr_plate[dest7].bottom(1)) p20.touch_tip() p20.dispense(5, pcr_plate[dest8].bottom(1)) p20.touch_tip() p20.dispense(5, pcr_plate[dest9].bottom(1)) p20.touch_tip() p20.drop_tip() p20.pick_up_tip() p20.aspirate(18, ww_plate[source].bottom(1)) protocol.delay(seconds=2) #equilibrate p20.dispense(5, pcr_plate[dest10].bottom(1)) p20.touch_tip() p20.dispense(5, pcr_plate[dest11].bottom(1)) p20.touch_tip() p20.dispense(5, pcr_plate[dest12].bottom(1)) p20.touch_tip() p20.drop_tip()
def run(protocol: protocol_api.ProtocolContext): if debug: print(protocol) tiprack_300 = protocol.load_labware('opentrons_96_tiprack_300ul', labwarePositions.tiprack_300, "tiprack 300ul") if debug: print(tiprack_300) pipette_300 = protocol.load_instrument('p300_single', 'right', tip_racks=[tiprack_300]) pipette_300.flow_rate.dispense = default_flow_rate pipette_300.flow_rate.aspirate = default_flow_rate pipette_300.starting_tip = tiprack_300.well( tiprack_starting_pos['tiprack_300']) if debug: print(pipette_300) black_96 = protocol.load_labware(type_of_96well_plate, labwarePositions.antibodies_plate, type_of_96well_plate) trough12 = protocol.load_labware('parhelia_12trough', labwarePositions.buffers_reservoir, '12-trough buffers reservoir') if (not retreaval): par2 = protocol.load_labware('par2s_9slides_blue_v2', labwarePositions.par2, 'par2s_9slides_blue_v2') if retreaval: temp_mod = protocol.load_module('temperature module', labwarePositions.heatmodule) par2 = temp_mod.load_labware('par2s_9slides_blue_v2') if debug: print(par2) buffer_wells = trough12.wells_by_name() buffers = Object() buffers.retreaval = buffer_wells['A1'] buffers.TBS_wash = buffer_wells['A2'] buffers.water = buffer_wells['A3'] buffers.storage = buffer_wells['A4'] buffers.eth_70perc_ = buffer_wells['A5'] buffers.eth_80perc = buffer_wells['A6'] buffers.eth_95perc = buffer_wells['A7'] buffers.eth_100perc = buffer_wells['A8'] buffers.hematoxylin = buffer_wells['A12'] preblock_wells = black_96.rows()[0] antibody_wells = black_96.rows()[1] enzymeblock_wells = black_96.rows()[2] hrpsecondaryab_wells = black_96.rows()[3] substrate_wells = black_96.rows()[4] DAB_wells = black_96.rows()[5] sample_chambers = [] for well in wellslist: sample_chambers.append(par2.wells_by_name()[well]) if debug: print(sample_chambers) #################PROTOCOL#################### protocol.home() if retreaval: washSamples(pipette_300, buffers.retreaval, buffers.retreaval, 0, 1, extra_bottom_gap) washSamples(pipette_300, buffers.retreaval, sample_chambers, wash_volume, 2, extra_bottom_gap) temp_mod.set_temperature(95) print("retreaval") protocol.delay(minutes=15) washSamples(pipette_300, buffers.retreaval, sample_chambers, wash_volume, 1, extra_bottom_gap) protocol.delay(minutes=15) washSamples(pipette_300, buffers.retreaval, sample_chambers, wash_volume, 1, extra_bottom_gap) protocol.delay(minutes=15) print("cooling down to RT") temp_mod.set_temperature(25) protocol.delay(minutes=20) # WASHING SAMPLES WITH TBS print("washing in TBS") washSamples(pipette_300, buffers.TBS_wash, buffers.TBS_wash, 0, 1, extra_bottom_gap) washSamples(pipette_300, buffers.TBS_wash, sample_chambers, wash_volume, 2, extra_bottom_gap) # Preblocking print("preblocking") print(len(wellslist)) for i in range(len(wellslist)): print(i) washSamples(pipette_300, preblock_wells[i], sample_chambers[i], wash_volume, 1, extra_bottom_gap) print("preblocking incubation: 15 min") protocol.delay(minutes=15) # APPLYING ANTIBODY COCKTAILS TO SAMPLES print("applying antibodies") for i in range(len(wellslist)): print(i) washSamples(pipette_300, antibody_wells[i], sample_chambers[i], wash_volume, 1, extra_bottom_gap) # INCUBATE FOR DESIRED TIME print("staining incubation: " + str(primary_ab_incubation_time_minutes) + "min") protocol.delay(minutes=primary_ab_incubation_time_minutes) # WASHING SAMPLES WITH TBS # three individual repeats below is because they need particular incubation time between them print("washing with TBS") for i in range(5): washSamples(pipette_300, buffers.TBS_wash, sample_chambers, wash_volume, 1, extra_bottom_gap) protocol.delay(minutes=3) # APPLYING enzyme blocking print("applying enzyme blocking") for i in range(len(wellslist)): washSamples(pipette_300, enzymeblock_wells[i], sample_chambers[i], wash_volume, 1, extra_bottom_gap) # INCUBATE 10 MIN print("hrp blocking incubation: 10min") protocol.delay(minutes=10) washSamples(pipette_300, buffers.TBS_wash, sample_chambers, wash_volume, 3, extra_bottom_gap) # APPLYING HRP SECONDARY ANTIBODY COCKTAILS TO SAMPLES print("applying hrpsecondaryab") for i in range(len(wellslist)): washSamples(pipette_300, hrpsecondaryab_wells[i], sample_chambers[i], wash_volume, 1, extra_bottom_gap) # INCUBATE FOR DESIRED TIME print("staining incubation: " + str(secondary_ab_incubation_time_minutes) + "min") protocol.delay(minutes=secondary_ab_incubation_time_minutes) # three individual repeats below is because they need particular incubation time between them print("washing with TBS") for i in range(3): washSamples(pipette_300, buffers.TBS_wash, sample_chambers, wash_volume, 1, extra_bottom_gap) protocol.delay(minutes=3) # DILUTING AND APPLYING THE DAB for i in range(len(wellslist)): dilute_and_apply_fixative(pipette_300, DAB_wells[i], substrate_wells[i], sample_chambers[i], 200) print("developing substrate") protocol.delay(minutes=10) washSamples(pipette_300, buffers.water, buffers.water, 0, 1, extra_bottom_gap) washSamples(pipette_300, buffers.water, sample_chambers, wash_volume, 5, extra_bottom_gap) # STORAGE, washing samples every hour washSamples(pipette_300, buffers.storage, buffers.storage, 0, 1, extra_bottom_gap) for i in range(48): washSamples(pipette_300, buffers.storage, sample_chambers, wash_volume / 2, 1, extra_bottom_gap, keep_tip=True) protocol.delay(minutes=60) print("total dispensed volume: ", str(stats.volume))