def run_custom_protocol( volumes_csv: FileInput = example_csv, pipette_axis: StringSelection('B (left side)', 'A (right side)') = 'B (left side)', pipette_model: StringSelection('p200', 'p100', 'p50', 'p20', 'p10', 'p1000') = 'p200', plate_type: StringSelection('96-flat', '384-plate') = '96-flat', tip_reuse: StringSelection('new tip each time', 'reuse tip') = 'new tip each time'): pipette_max_vol = int(pipette_model[1:]) pipette = instruments.Pipette(axis='b' if pipette_axis[0] == 'B' else 'a', max_volume=pipette_max_vol, min_volume=pipette_max_vol / 10, tip_racks=tipracks, trash_container=trash) plate = containers.load(plate_type, 'A1') volumes = [float(cell) for cell in well_csv_to_list(volumes_csv)] for vol in volumes: if 0 < vol < pipette.min_volume: robot.comment( 'WARNING: volume {} is below pipette\'s minimum volume.'. format(vol)) tip_strategy = 'always' if tip_reuse == 'new tip each time' else 'once' pipette.transfer(volumes, source, plate, new_tip=tip_strategy)
def note_liquid(location, name=None, initially=None, initially_at_least=None, concentration=None, local_config=None): # Must keep in sync with Opentrons-Analyze analyze_liquid_name if local_config is None: local_config = rgatkinson.configuration.config well, __ = well_vector(location) if name is None: name = well.label else: well.label = name liquid = local_config.execution_context.liquids.get_liquid(name) d = {'name': name, 'location': get_location_path(well)} if initially is not None and initially_at_least is not None: raise ValueError # can't use both at once initially = LiquidVolume.fix_initially(initially) if initially is None and initially_at_least is not None: initially = Interval([initially_at_least, well.geometry.well_capacity]) if initially is not None: d['initially'] = initially well.liquid_volume.set_initially(initially) if concentration is not None: concentration = Concentration(concentration) liquid.concentration = concentration d['concentration'] = str(concentration) serialized = json.dumps(d).replace("{", "{{").replace("}", "}}") # runtime calls comment.format(...) on our comment; avoid issues therewith robot.comment('Liquid: %s' % serialized)
def transformation_setup(transformation_wells): """Sets up transformation reactions Args: transformation_wells (list). """ # Constants TEMP = 4 # Incubation temperature. ASSEMBLY_VOL = 5 # Volume of final assembly added to competent cells. MIX_SETTINGS = (4, 5) # Mix after setting during final assembly transfers. INCUBATION_TIME = 20 # Cells and final assembly incubation time. # Set temperature deck to 4 °C and load competent cells tempdeck.set_temperature(TEMP) tempdeck.wait_for_temp() robot.pause() robot.comment('Load competent cells, uncap and resume run') # Transfer final assemblies p10_pipette.transfer(ASSEMBLY_VOL, assembly_plate.wells(transformation_wells), transformation_plate.wells(transformation_wells), new_tip='always', mix_after=(MIX_SETTINGS)) # Incubate for 20 minutes and remove competent cells for heat shock p10_pipette.delay(minutes=INCUBATION_TIME) robot.pause() robot.comment( 'Remove transformation reactions, conduct heatshock and replace.')
def robot_wait(): if not robot.is_simulating(): robot.comment("Waiting...") robot._driver.turn_on_red_button_light() while not robot._driver.read_button(): sleep(0.5) robot._driver.turn_on_blue_button_light()
def phase_switch(comment='Remove final assembly plate. Introduce agar tray and deep well plate containing SOC media. Resume run.'): """Function pauses run enabling addition/removal of labware. Args: comment (str): string to be displayed during run following pause. """ robot.pause() robot.comment(comment)
def robot_wait_tiprack(): if not robot.is_simulating(): robot.comment("Waiting...") set_button_light(blue=True, red=True, green=True) while not robot._driver.read_button(): sleep(0.5) robot._driver.turn_on_blue_button_light()
def robot_wait_tiprack(): if not robot.is_simulating(): robot.comment("Waiting...") os.system('/data/startpwm 1 1 1 16') while not robot._driver.read_button(): sleep(0.5) os.system('/data/stoppwm') robot._driver.turn_on_blue_button_light()
def nonconstant_vol_procedure(small_pipette, large_pipette, small_volume, less_than_crit_well, volume, large_min_volume, sol_pos, well_pos, small_condition): if small_volume == less_than_crit_well: #ie: distribute this this iteration if (volume < large_min_volume) and (volume != 0): allot(small_pipette, volume, sol_pos, well_pos, small_condition) elif (volume == 0): robot.comment("0ul. Nothing is done.") else: allot(large_pipette, volume, sol_pos, well_pos, small_condition)
def run_custom_protocol(): p50_single = instruments.P50_Single(mount='right', tip_racks=[tiprack]) transfer_volume = 50 initial_volume = 2000 # Initial volume held in source tube source_tube = tube_rack_2ml.wells('D3') destination_tube = tube_rack_2ml.wells('D4') remaining_vol = 2000 height = 1 # Initial height within source tube source_height_offset = 0.5 # Offset so that pipette tip is slightly submerged in source tube, not hovering at surface source_height = height - source_height_offset p50_single.pick_up_tip() while remaining_vol > 0: robot.comment( str(source_height)) # Print out the current source_height # This transfer command will start pipetting from the top of the source tube to the bottom of the destination # tube, and will continue "tracking" the height of the two volumes in each tube source = (source_tube, source_tube.from_center(x=0, y=0, z=source_height) ) # locations are tuples destination = (destination_tube, destination_tube.from_center(x=0, y=0, z=-height) ) # locations are tuples p50_single.transfer(transfer_volume, source, destination, disposal_vol=0, blow_out=True, new_tip='never') # Update height by subtracting ratio of transfer_vol:inital_vol, or set to bottom of tube is "below" bottom if height > -1: height -= ( transfer_volume / initial_volume ) * 2 # x2 because tube size is -1 to 1 i.e. a difference of 2 else: height = -1 # Update source_height or set to bottom of tube source_height = height - source_height_offset if source_height < -1: source_height = -1 # Update remaining volume remaining_vol -= transfer_volume
def robot_wait(func=None, timer=None): # You can specify a function to run <timer> minutes after the robot starts waiting if func is not None: if robot.is_simulating(): func() start_time = perf_counter() duration = 60 * timer started = False if not robot.is_simulating(): robot.comment("Waiting...") robot._driver.turn_on_red_button_light() while not robot._driver.read_button(): if func is not None and not started: now = perf_counter() if now - start_time > duration: started = True func() sleep(0.5) robot._driver.turn_on_blue_button_light()
def run_custom_protocol( volumes_csv: FileInput = example_csv, pipette_mount: StringSelection('right', 'left') = 'right', pipette_model: StringSelection('p300-Single', 'p50-Single', 'p10-Single') = 'p300-Single', plate_type: StringSelection('96-flat', '384-plate') = '96-flat', tip_reuse: StringSelection('new tip each time', 'reuse tip') = 'new tip each time'): tipracks = [ labware.load('opentrons-tiprack-300ul', slot) for slot in tiprack_slots ] if pipette_model == 'p300-Single': pipette = instruments.P300_Single(mount=pipette_mount, tip_racks=tipracks) elif pipette_model == 'p50-Single': pipette = instruments.P50_Single(mount=pipette_mount, tip_racks=tipracks) elif pipette_model == 'p10-Single': tipracks = [ labware.load('tiprack-10ul', slot) for slot in tiprack_slots ] pipette = instruments.P10_Single(mount=pipette_mount, tip_racks=tipracks) plate = labware.load(plate_type, '3') volumes = [float(cell) for cell in well_csv_to_list(volumes_csv)] for vol in volumes: if 0 < vol < pipette.min_volume: robot.comment( 'WARNING: volume {} is below pipette\'s minimum volume.'. format(vol)) tip_strategy = 'always' if tip_reuse == 'new tip each time' else 'once' pipette.transfer(volumes, source, plate, new_tip=tip_strategy)
def washSamples(numWashes, volWash): robot.comment("Beginning " + str(numWashes) + " washes, " + str(volWash) + " µl each.") numWashes = 3 volWash = 300 for washing in range(0, numWashes): for row in range(0, sampleRows): p300_multi_default_speed.transfer(volWash, washBasin.rows(row), samplePlate.rows(row), new_tip='never', blow_out=True, touch_tip=False) for row in range(0, sampleRows): p300_multi_default_speed.transfer( volWash, samplePlate.rows(row).bottom(aspHeight), wastePlate.rows(row), new_tip='never', blow_out=True) robot.comment("Finished wash number " + str(washing + 1) + " of " + str(numWashes) + " washes.\n") robot.comment("Finished washing " + str(numWashes) + " times. Adding low glucose solution to wells now.\n")
P10.pick_up_tip() for well_counter, values in enumerate( reagent ): # Specifies the well position and the volume of reagent being if values == float(0): pass elif values < float(30): # transfered in P10.distribute( # If volume below 30, P10 used not p300, if over P300 used values, Buffers2(source).top(-70), well_buffers96(well_counter).top(0.5), blow_out=True, rate=0.5, new_tip='never') P10.touch_tip(well_buffers96(well_counter)) P10.blow_out(well_buffers96(well_counter)) else: P300.distribute(values, Buffers2(source), well_buffers96(well_counter).top(0.5), blow_out=True, rate=0.5, new_tip='never') P300.touch_tip(well_buffers96(well_counter)) P300.blow_out(well_buffers96(well_counter)) P300.drop_tip( ) # Drops tips at end of single reagent run to prevent contamination P10.drop_tip() robot.comment("Protocol finished")
sample_number = 96 col_num = sample_number // 8 + (1 if sample_number % 8 > 0 else 0) samples = [col for col in temp_plate.cols()[:col_num]] ## Volume setup #ER_vol = 5.85 Lig_vol = 6 #Fill_vol = 10 #MM_dist_ER = ER_vol * col_num MM_dist_Lig = Lig_vol * col_num #MM_dist_Fill = Fill_vol * col_num """ Ligase """ robot.comment("Yay! \ Ligase begins.") temp_deck_1.set_temperature(10) temp_deck_2.set_temperature(10) temp_deck_1.wait_for_temp() temp_deck_2.wait_for_temp() ### Addition of Adapters for target in samples: m10.set_flow_rate(aspirate=100, dispense=100) m10.pick_up_tip() # Slow down head speed 0.5X for bead handling m10.move_to(BGI_adapter.bottom()) m10.mix(3, 5, BGI_adapter.bottom(4))
## Sample Setup sample_number = 96 col_num = sample_number // 8 + (1 if sample_number % 8 > 0 else 0) samples = [col for col in temp_plate.cols()[:col_num]] ## Volume setup ER_vol = 5.85 #Lig_vol = 8 #Fill_vol = 10 MM_dist_ER = ER_vol * col_num #MM_dist_Lig = Lig_vol * col_num #MM_dist_Fill = Fill_vol * col_num """ Blund end repair """ robot.comment("Yay! \ Blund-end Repair begins.") temp_deck_1.set_temperature(10) temp_deck_2.set_temperature(10) temp_deck_1.wait_for_temp() temp_deck_2.wait_for_temp() ### Addition of End repair mastermix to enzymes m300.set_flow_rate(aspirate=180, dispense=180) m300.pick_up_tip() # Slow down head speed 0.5X for bead handling m300.move_to(ER_mastermix.bottom()) m300.mix(3, 50, ER_mastermix.bottom(4)) max_speed_per_axis = { 'x': (300),
######################################################################################### # COMPETENT CELLS if not robot.is_simulating(): # If the OT2 is currently not heating something tempdeck.set_temperature( TargetTemp["temp"] ) # Sets the temperature to the value in the TargetTemp dictionary with key temp tempdeck.wait_for_temp( ) # Pauses the protocol until the temperature deck reaches the desired temperature target1 = Compcells1( Even_wells) # Assigns the wells of Compcells1 as the target1 variable robot.home() # Returns the OT2 to the starting position robot.comment( "Make sure that centrifuge has been chilled down to 4*C and all buffers are on ice." ) # Produces a message on the OT2 display to inform the user of what the next step is robot.comment( "All plates should be chilled at the beginning and culture should be incubated on ice for 15 minutes before start." ) # Produces a comment on the OT2 providing information for the next step robot.comment( "Once at set temperature, insert culture into slot 6 and plate onto TempDeck, then resume!" ) # Produces a comment providing guidance to the user robot.pause() # Pauses the OT2 until the user resumes the process via the app # bacterial culture # This is the first step of protocol, 200 uL bacterial culture at OD 0.4-0.6 for i in range( 1 ): # Added to 96 well plate in specified wells, Range 1 means the loop runs once. Why is this a loop???? P300.pick_up_tip() # Forces the OT2 to equip a new pipette tip to the P300 P300.transfer( # Transfers reagents from a well to destination wells
import sys sys.path.append('/root/ot2-covid19-master/ot2/library') from constants import IP from general.rename_robot import rename from general.configure_static_ip import set_static_ip from opentrons import robot if not robot.is_simulating(): rename('sbr1') set_static_ip(IP.replace('x', '54')) robot.comment("Please, reboot")
from opentrons import labware, instruments, modules, robot if '4ti0131_trough-12' not in labware.list(): custom_plate = labware.create('4ti0131_trough-12', grid=(12, 1), spacing=(9, 0), diameter=8.25, depth=39.22, volume=21000) robot.comment('4ti0131_trough-12 added to labware database') else: robot.comment( '4ti0131_trough-12 already exists in the OT2 database and has not been updated. Refer to Opentrons API and Custom_labware.csv' ) if '4ti0136_96_deep-well' not in labware.list(): custom_plate = labware.create('4ti0136_96_deep-well', grid=(12, 8), spacing=(9, 9), diameter=8.2, depth=39.15, volume=2200) robot.comment('4ti0136_96_deep-well added to labware database') else: robot.comment( '4ti0136_96_deep-well already exists in the OT2 database and has not been updated. Refer to Opentrons API and Custom_labware.csv' ) if 'Nunc_Omnitray' not in labware.list(): custom_plate = labware.create('Nunc_Omnitray', grid=(12, 8),
def dispatch_commands(protocol_data, loaded_pipettes, loaded_labware): # noqa: C901 E501 subprocedures = [ p.get('subprocedure', []) for p in protocol_data.get('procedure', []) ] default_values = protocol_data.get('default-values', {}) flat_subs = chain.from_iterable(subprocedures) for command_item in flat_subs: command_type = command_item.get('command') params = command_item.get('params', {}) pipette = _get_pipette(params, loaded_pipettes) protocol_pipette_data = protocol_data\ .get('pipettes', {})\ .get(params.get('pipette'), {}) pipette_name = protocol_pipette_data.get('name') if (not pipette_name): # TODO: Ian 2018-11-06 remove this fallback to 'model' when # backwards-compatability for JSON protocols with versioned # pipettes is dropped (next JSON protocol schema major bump) pipette_name = protocol_pipette_data.get('model') location = _get_location(loaded_labware, command_type, params, default_values) volume = params.get('volume') if pipette: # Aspirate/Dispense flow rate must be set each time for commands # which use pipettes right now. # Flow rate is persisted inside the Pipette object # and is settable but not easily gettable _set_flow_rate(pipette_name, pipette, command_type, params, default_values) if command_type == 'delay': wait = params.get('wait') message = params.get('message') if wait is None: raise ValueError('Delay cannot be null') elif wait is True: message = message or 'Pausing until user resumes' robot.pause(msg=message) else: text = f'Delaying for {datetime.timedelta(seconds=wait)}' if message: text = f"{text}. {message}" robot.comment(text) _sleep(wait) elif command_type == 'blowout': pipette.blow_out(location) elif command_type == 'pick-up-tip': pipette.pick_up_tip(location) elif command_type == 'drop-tip': pipette.drop_tip(location) elif command_type == 'aspirate': pipette.aspirate(volume, location) elif command_type == 'dispense': pipette.dispense(volume, location) elif command_type == 'touch-tip': # NOTE: if touch_tip can take a location tuple, # this can be much simpler (well_object, loc_tuple) = location # Use the offset baked into the well_object. # Do not allow API to apply its v_offset kwarg default value, # and do not apply the JSON protocol's default offset. z_from_bottom = loc_tuple[2] offset_from_top = (well_object.properties['depth'] - z_from_bottom) * -1 pipette.touch_tip(well_object, v_offset=offset_from_top) elif command_type == 'move-to-slot': slot = params.get('slot') if slot not in [str(s + 1) for s in range(12)]: raise ValueError( '"move-to-slot" requires a valid slot, got {}'.format( slot)) x_offset = params.get('offset', {}).get('x', 0) y_offset = params.get('offset', {}).get('y', 0) z_offset = params.get('offset', {}).get('z', 0) slot_placeable = robot.deck[slot] slot_offset = (x_offset, y_offset, z_offset) strategy = 'direct' if params.get('force-direct') else None # NOTE: Robot.move_to subtracts the offset from Slot.top()[1], # so in order not to translate our desired offset, # we have to compensate by adding it here :/ pipette.move_to((slot_placeable, add(slot_offset, tuple(slot_placeable.top()[1]))), strategy=strategy)
master_settings["P10_single"]["Rack"]) P10 = instruments.P10_Single(mount=master_settings["P10_single"]["Mount"], tip_racks=[p10_tip_rack]) P10.start_at_tip(p10_tip_rack.well(P10_first_tip)) p300_tip_rack = labware.load("opentrons_96_tiprack_300ul", master_settings["P300_multi"]["Rack"]) P300 = instruments.P300_Multi(mount=master_settings["P300_multi"]["Mount"], tip_racks=[p300_tip_rack]) P300.start_at_tip(p300_tip_rack.cols(P300_tip_column)) # Main: LB_vols = [target_vol * OD / target_OD for OD in sample_ODs] tempdeck.set_temperature(37) tempdeck.wait_for_temp() robot.comment("Insert sample plate into position: " + master_settings["Plate"]["Position"]) robot.pause() # Resuspend cells: P300.pick_up_tip() P300.mix(10, 100, sample_plate.cols(0).bottom(1)) P300.return_tip() # Pipette LB and passage: for i in range(len(sample_ODs)): P10.pick_up_tip() P10.mix(3, 10, hotplate.well(LB_well)) # Wet tip... P10.transfer( LB_vols[i], hotplate.well(LB_well), sample_plate(sample_destinations[i]), new_tip="never", )
def test_comment(virtual_smoothie_env): robot.reset() robot.clear_commands() robot.comment('hello') assert robot.commands() == ['hello']
s1000.distribute(Wash_2_vol, Wash_2, [well.top() for well in sample_plate.wells()], new_tip='once', blow_out =True) mag_deck.engage() m300.delay(minutes=5) m300.transfer(500, [well.bottom() for well in sample_plate.wells()], Liquid_trash, new_tip='always', blow_out =True) ## Ethanol Wash 1 mag_deck.disengage() s1000.distribute(EtOH_vol, Ethanol_1, [well.top() for well in sample_plate.wells()], new_tip='once', blow_out =True) mag_deck.engage() m300.delay(minutes=5) m300.transfer(500, [well.bottom() for well in sample_plate.wells()], Liquid_trash, new_tip='always', blow_out =True) ## Ethanol Wash 2 mag_deck.disengage() s1000.distribute(EtOH_vol, Ethanol_2, [well.top() for well in sample_plate.wells()], new_tip='once', blow_out =True) mag_deck.engage() m300.delay(minutes=5) m300.transfer(500, [well.bottom() for well in sample_plate.wells()], Liquid_trash, new_tip='always', blow_out =True) ## Dry beads robot.pause("Put the plate on the Temperature Module for 20 minutes at 55°C") ## Elution mag_deck.disengage() m300.distribute(Elution_vol, Elution_buffer, [well.bottom() for well in sample_plate.wells(), new_tip='always', blow_out =True] mag_deck.engage() m300.delay(minutes=5) m300.distribute(Elution_vol, [well.bottom() for well in sample_plate.wells(), [well.bottom() for well in elution_plate_DNA.wells(), new_tip='always', blow_out =True] robot.comment("Job's done")
m300.transfer(85, col, m300.trash_container.top()) # wash plate with 80% EtOH twice for etoh in ethanol_1: m300.pick_up_tip() m300.transfer(200, etoh, [col[0].top() for col in mag_plate.cols()], new_tip='never') m300.delay(seconds=30) for col in mag_plate.cols(): if not m300.tip_attached: m300.pick_up_tip() m300.transfer(230, col, m300.trash_container.top(), new_tip='never') m300.drop_tip() robot.comment("Air dry for 15 minutes. During this time, replenish all of the \ tip racks.") m300.delay(minutes=15) m300.reset() m10.reset() mag_module.disengage() # transfer resuspension buffer for col in mag_plate.cols(): m300.pick_up_tip() m300.transfer(52.5, resuspension_buffer, col, new_tip='never') m300.mix(3, 30, col) m300.blow_out(col) m300.drop_tip() m300.delay(minutes=2)
SA5 = mag_plate.wells('A5') SA6 = mag_plate.wells('A6') SA7 = mag_plate.wells('A7') SA8 = mag_plate.wells('A8') SA9 = mag_plate.wells('A9') SA10 = mag_plate.wells('A10') SA11 = mag_plate.wells('A11') SA12 = mag_plate.wells('A12') sample_vol = 60 bead_vol = 1.5*sample_vol EtOH_vol = 160 EtOH_vol2 = 150 elution_vol = 35 robot.comment("Yay! \ Purification begins!") ### Beads addition mag_deck.engage(height=10) m300.delay(seconds=10) mag_deck.engage(height=12) m300.delay(seconds=10) mag_deck.engage(height=13) m300.delay(seconds=10) mag_deck.engage(height=14) m300.delay(seconds=10) mag_deck.engage(height=15) m300.delay(seconds=10) mag_deck.engage(height=16) m300.delay(seconds=10) mag_deck.engage(height=17)
tip_racks=tipracks, trash_container=trash, aspirate_speed=300, dispense_speed=400) # ~~~~~~~~~~ PROTOCOL RUN ~~~~~~~~~ p300_multi_default_speed.pick_up_tip() # Define number of sample rows, sample volume, height from the bottom of the islet wells sampleRows = 3 sampleVol = 500 aspHeight = 3 #Step 1. Remove existing media robot.comment("Removing existing media from samples.") for row in range(0, sampleRows): p300_multi_default_speed.transfer(sampleVol, samplePlate.rows(row).bottom(aspHeight), wastePlate.rows(row), new_tip='never', blow_out=True) robot.comment("Media removed.") # Step 2. Wash islets def washSamples(numWashes, volWash): robot.comment("Beginning " + str(numWashes) + " washes, " + str(volWash) +
NEW_SERIAL_NUMBER = "SB-R1" from opentrons import robot import os robot.comment(f"Setting serial number to {NEW_SERIAL_NUMBER}.") if not robot.is_simulating(): with open("/var/serial", "w") as serial_number_file: serial_number_file.write(NEW_SERIAL_NUMBER + "\n") with open("/etc/machine-info", "w") as serial_number_file: serial_number_file.write(f"DEPLOYMENT=production\nPRETTY_HOSTNAME={NEW_SERIAL_NUMBER}\n") with open("/etc/hostname", "w") as serial_number_file: serial_number_file.write(NEW_SERIAL_NUMBER + "\n") os.sync() robot.comment("Done.")
def run_custom_protocol( p300_type: 'StringSelection...' = 'single', p300_mount: 'StringSelection...' = 'right', number_of_samples_to_process: int = 24 ): # check: if number_of_samples_to_process > 96 or number_of_samples_to_process < 1: raise Exception('Invalid number of samples to process (must be between \ 1 and 96).') num_cols = math.ceil(number_of_samples_to_process/8) num_300_racks = math.ceil((num_cols*6)/12) slots300 = [str(slot) for slot in range(5, 5+num_300_racks)] tips300 = [ labware.load('opentrons_96_tiprack_300ul', slot) for slot in slots300] # pipettes if p300_type == 'multi': pip300 = instruments.P300_Multi(mount=p300_mount, tip_racks=tips300) samples300 = mag_plate.rows('A')[:num_cols] else: pip300 = instruments.P300_Single(mount=p300_mount, tip_racks=tips300) samples300 = mag_plate.wells()[:number_of_samples_to_process] pip300.set_flow_rate(aspirate=75, dispense=90) magdeck.engage(height=18) robot.comment('Incubating beads on magnet for 3 minutes.') pip300.delay(minutes=3) # remove and discard supernatant for s in samples300: pip300.pick_up_tip() pip300.transfer(65, s.bottom(1), liquid_waste[0], new_tip='never') pip300.blow_out() pip300.drop_tip() # TWB washes 3x count = 0 total_twb = 96*3 for wash in range(3): magdeck.disengage() # resuspend beads in TWB for i, s in enumerate(samples300): ind = (count*len(twb))//total_twb count += 1 side = i % 2 if p300_type == 'multi' else math.floor(i/8) % 2 angle = 0 if side == 0 else math.pi disp_loc = (s, s.from_center(r=0.85, h=-0.6, theta=angle)) pip300.pick_up_tip() pip300.aspirate(100, twb[ind]) pip300.move_to(s.bottom(5)) pip300.dispense(100, disp_loc) pip300.mix(10, 80, disp_loc) pip300.drop_tip() magdeck.engage(height=18) if wash < 2: robot.comment('Incubating beads on magnet for 3 minutes') pip300.delay(minutes=3) # remove and discard supernatant for s in samples300: pip300.pick_up_tip() pip300.transfer( 120, s.bottom(1), liquid_waste[wash], new_tip='never') pip300.blow_out() pip300.drop_tip() robot.comment('Seal the plate, and keep on the magnetic module. The TWB \ remains in the wells to prevent overdrying of the beads')
SA5 = mag_plate.wells('A5') SA6 = mag_plate.wells('A6') SA7 = mag_plate.wells('A7') SA8 = mag_plate.wells('A8') SA9 = mag_plate.wells('A9') SA10 = mag_plate.wells('A10') SA11 = mag_plate.wells('A11') SA12 = mag_plate.wells('A12') sample_vol = 50 bead_vol = 1.5 * sample_vol EtOH_vol = 160 EtOH_vol2 = 150 elution_vol = 35 robot.comment("Yay! \ Purification begins!") ### Beads addition mag_deck.disengage() for target in samples: m300.set_flow_rate(aspirate=180, dispense=180) m300.pick_up_tip() # Slow down head speed 0.5X for bead handling m300.mix(3, 200, SPRI_beads) max_speed_per_axis = { 'x': (100), 'y': (100), 'z': (50), 'a': (20), 'b': (20), 'c': (20)
autoconnect-priority=20 interface-name=eth0 permissions= [ethernet] cloned-mac-address=permanent mac-address-blacklist= [ipv4] dns-search= method=manual addresses={STATIC_IP} """ from opentrons import robot import os robot.comment( f"Run this protocol to permanently set the wired IP address of your OT-2 to {STATIC_IP}." ) if not robot.is_simulating(): with open( "/var/lib/NetworkManager/system-connections/support-team-wired-static-ip", "w") as keyfile: keyfile.write(keyfile_contents) os.sync() robot.comment("Done.") robot.comment("Restart your OT-2 to apply the changes.")
1, # Sets the dispensing rate of the pipette, set this to 0.5 if using a viscous fluid new_tip='never' ) # With this option declared the Opentron will not pick up a new pipette until explicitly instructed P300.touch_tip( well_buffers96(y) ) # With this option declared the pipette tip will be touched to the top of the wells after pipetting P300.blow_out( well_buffers96(y) ) # assigns another blow out, dispensing a gust of air after dispensing to clear the pipette tip of fluid if y == len( z ) - 1: # Checks if the end of the reagent list has been reached, Python lists start at 0 so y will only ever reach 5 in a list fo 6 elements len(z) needs to have 1 subtracted P300.drop_tip() # Disposes of the tip on the P300 P10.drop_tip() # Disposes of the tip on the P10 robot.home() # Returns the Opentron pipette to the starting location source = 0 # Source is declared as an empty variable so it can track reagent position from the sort() function [ [ sort(values, well_counter, reagent, counter) for well_counter, values in enumerate(reagent) ] for counter, reagent in enumerate(reagents1, 0) ] # Unless you change the name of reagents1, you will never need to alter this line # The line above executes the entire protocol, iterating through the reagent lists and destinations, as such it shouldn't need to be adjusted unless the reagent list names change robot.comment( "Protocol finished" ) # Informs the user that the protocol is complete via comment on the Opentrons