from opentrons import robot, containers, instruments
robot.head_speed(x=18000, y=18000, z=3000, a=400, b=400)
#containers.create(
# "tiprack-300ul_green", # name of you container
# grid=(8, 12), # specify amount of (columns, rows)
# spacing=(9, 9), # distances (mm) between each (column, row)
# diameter=4, # diameter (mm) of each well on the plate
# depth=60) # depth (mm) of each well on the plate
#containers.create(
# "Starlab_96_Square_2mL", # name of you container
# grid=(8, 12), # specify amount of (columns, rows)
# spacing=(9, 9), # distances (mm) between each (column, row)
# diameter=8, # diameter (mm) of each well on the plate
# depth=60) # depth (mm) of each well on the plate
#Deck setup
tiprack_300 = containers.load("tiprack-300ul", "D3")
#tiprack_300_2 = containers.load("tiprack-300ul", "E2")
source_trough4row = containers.load("trough-12row", "C2")
reaction_rack = containers.load("Starlab_96_Square_2mL", "D1")
destination_QC = containers.load("96-PCR-flat", "B1", "QC")
trash = containers.load("point", "C3")
#Pipettes SetUp
p300_multi = instruments.Pipette(
name='dlab_300multi_no_min',
# GSIS Opentrons Protocol
# Last Updated: September 13th, 2018
from opentrons import robot, containers, instruments
from itertools import chain
# ~~~~~~~~~~~ SET UP ~~~~~~~~~~
#max_speed_per_axis = { # Head Speed
# 'x': 2000, 'y': 1000, 'z':500, 'a':500, 'b':500, 'c':200}
#robot.head_speed(
# combined_speed=max(max_speed_per_axis.values()), **max_speed_per_axis)
robot.head_speed(z=1200)
tipracks = [containers.load('tiprack-200ul', slot) for slot in ['D2', 'E2']]
## Tyler's custom 8-trough container (treated as 4, because of the way BD made them)
containers.create('trough-8row',
grid=(8, 4),
spacing=(9, 30),
diameter=6,
depth=35)
## Very deep 96-well plate (2.5 ml)
containers.create('96-very-deep-well',
grid=(8, 12),
spacing=(9, 9),
diameter=6,
depth=43)
## VWR 1.2-ml sample tubes
containers.create('96-sample-tubes',
'''OT1 -Single channel- Making up of main reagent stock solution (2 maximum) using a defined solvent and transfer onto 3mL fluidx vials'''
from opentrons import robot, containers, instruments
robot.head_speed(x=21000, y=21000, z=5000, a=700, b=700)
class Vector(object):
def tolist(self):
return list(self.input_list)
def astype(self, input_type):
if input_type == int:
return Vector([int(float(x)) for x in self.input_list])
return Vector([input_type(x) for x in self.input_list])
def __init__(self, input_list):
self.input_list = input_list
class DataFrame(object):
def __len__(self):
return self.length
def __getitem__(self, value):
return Vector(self.dict_input[value])
def __init__(self, dict_input, length):
self.dict_input = dict_input
self.length = length
# tip_racks=[p200rack,p200rack2],
# tip_racks=[equipment['p200rack']],
# trash_container=equipment['trash'],
# channels=8)
if CalibrationMode:
# Iterate through all equipment issuing a dummy command to allow calibration
for key in equipment:
if key != "p1000" and key != 'p200x1' and key != 'p200x8':
equipment['p1000'].move_to(equipment[key][0])
#equipment['p200x1'].move_to(equipment[key][0])
equipment['p200x8'].move_to(equipment[key][0])
else:
robot.home()
robot.head_speed(8000)
dbd.row_factory = sqlite3.Row
while 1:
db = dbd.cursor()
a = db.execute(
"SELECT * FROM CommandQueue WHERE doneAt is NULL AND queued= 1 ORDER BY OrderOfEvents LIMIT 1"
)
command = a.fetchone()
db.close()
if (command == None):
time.sleep(0.1)
#print("none")
else:
tiprack = labware.load('opentrons-tiprack-300ul', slot=6)
# Use the regular trash as trash_liquid, but displace the pipette to avoid collisions
trash = robot.fixed_trash().top()
#displacement = Vector(0,30,100)
trash_liquid = trash
#(trash[0], displacement)
# [2] Pipettes
pipette = instruments.P300_Single(mount='left', tip_racks=[tiprack])
# Pipette flow rates: left and right, aspirate and dispense
flow_rate = {'a_l': 300, 'd_l': 300}
max_speed_per_axis = {'x': 600, 'y': 400, 'z': 125, 'a': 125, 'b': 40, 'c': 40}
robot.head_speed(**max_speed_per_axis)
def robot_wait_tiprack():
if not robot.is_simulating():
robot.comment("Waiting...")
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 custom_pick_up_tip(*args, **kwargs):
def set_speed(rate):
robot.head_speed(x=(600 * rate), y=(400 * rate),
z=(125 * rate), a=(125 * rate))
def change_speed(robot):
robot.head_speed(5000)
def gantrydefault():
robot.home()
robot.head_speed(x=70, y=70, z=70, a=70, b=50, c=50)
"""
@author Dhruv
@date July 3, 2018
@version 5
"""
from opentrons import containers, labware, instruments, robot
robot.head_speed(
x=600, y=600, z=125
) # Head speed of the robot in mm/s. Max is 600 for X and Y. 125 for Z
m300rack_1 = containers.load('tiprack-200ul', '1')
m300rack_2 = containers.load('tiprack-200ul', '4')
from sqlite3 import IntegrityError
try:
custom_container = labware.create(
'4x6_Tube_rack', # name of you container
grid=(6, 4), # specify amount of (columns, rows)
spacing=(19.5, 19.5), # distances (mm) between each (column, row)
diameter=3.5, # diameter (mm) of each well on the plate (was 10.6)
depth=40) # depth (mm) of each well on the plate
except IntegrityError:
pass
try:
custom_container = labware.create(
'plate_6_well', # name of you container
grid=(3, 2), # specify amount of (columns, rows)
spacing=(39.12, 39.12), # distances (mm) between each (column, row)
def magbead(sample_number,
ethanol_well,
elution_buffer_well,
sample_volume=30,
bead_ratio=1.8,
elution_buffer_volume=40,
incubation_time=5,
settling_time=2,
drying_time=5,
elution_time=2,
sample_offset=0,
tiprack_type="opentrons_96_tiprack_300ul"):
"""Implements magbead purification reactions for BASIC assembly using an opentrons OT-2.
Selected args:
ethanol_well (str): well in reagent container containing ethanol.
elution_buffer_well (str): well in reagent container containing elution buffer.
sample_offset (int): offset the intial sample column by the specified value.
"""
# Constants
PIPETTE_ASPIRATE_RATE = 25
PIPETTE_DISPENSE_RATE = 150
TIPS_PER_SAMPLE = 9
CANDIDATE_TIPRACK_SLOTS = ['3', '6', '9', '2', '5']
MAGDECK_POSITION = '1'
MIX_PLATE_TYPE = '4ti-0960_FrameStar'
MIX_PLATE_POSITION = '4'
REAGENT_CONTAINER_TYPE = '4ti0131_trough-12'
REAGENT_CONTAINER_POSITION = '7'
BEAD_CONTAINER_TYPE = '4ti0136_96_deep-well'
BEAD_CONTAINER_POSITION = '8'
LIQUID_WASTE_WELL = 'A12'
BEADS_WELL = 'A1'
DEAD_TOTAL_VOL = 5
SLOW_HEAD_SPEEDS = {
'x': 600 // 4,
'y': 400 // 4,
'z': 125 // 10,
'a': 125 // 10
}
DEFAULT_HEAD_SPEEDS = {'x': 400, 'y': 400, 'z': 125, 'a': 100}
IMMOBILISE_MIX_REPS = 10
MAGDECK_HEIGHT = 20
AIR_VOL_COEFF = 0.1
ETHANOL_VOL = 150
WASH_TIME = 0.5
ETHANOL_DEAD_VOL = 50
ELUTION_MIX_REPS = 20
ELUTANT_SEP_TIME = 1
ELUTION_DEAD_VOL = 2
# Errors
if sample_number > 48:
raise ValueError('sample number cannot exceed 48')
# Tips and pipette
total_tips = sample_number * TIPS_PER_SAMPLE
tiprack_num = total_tips // 96 + (1 if total_tips % 96 > 0 else 0)
slots = CANDIDATE_TIPRACK_SLOTS[:tiprack_num]
tipracks = [labware.load(tiprack_type, slot) for slot in slots]
pipette = instruments.P300_Multi(mount="left",
tip_racks=tipracks,
aspirate_flow_rate=PIPETTE_ASPIRATE_RATE,
dispense_flow_rate=PIPETTE_DISPENSE_RATE)
# Define labware
MAGDECK = modules.load('magdeck', MAGDECK_POSITION)
MAGDECK.disengage()
mag_plate = labware.load(MIX_PLATE_TYPE, MAGDECK_POSITION, share=True)
mix_plate = labware.load(MIX_PLATE_TYPE, MIX_PLATE_POSITION)
reagent_container = labware.load(REAGENT_CONTAINER_TYPE,
REAGENT_CONTAINER_POSITION)
bead_container = labware.load(BEAD_CONTAINER_TYPE, BEAD_CONTAINER_POSITION)
col_num = sample_number // 8 + (1 if sample_number % 8 > 0 else 0)
samples = [
col
for col in mag_plate.cols()[0 + sample_offset:col_num + sample_offset]
]
output = [
col for col in mag_plate.cols()[6 + sample_offset:col_num + 6 +
sample_offset]
]
mixing = [
col
for col in mix_plate.cols()[0 + sample_offset:col_num + sample_offset]
]
# Define reagents and liquid waste
liquid_waste = reagent_container.wells(LIQUID_WASTE_WELL)
beads = bead_container.wells(BEADS_WELL)
ethanol = reagent_container.wells(ethanol_well)
elution_buffer = reagent_container.wells(elution_buffer_well)
# Define bead and mix volume
bead_volume = sample_volume * bead_ratio
if bead_volume / 2 > pipette.max_volume:
mix_vol = pipette.max_volume
else:
mix_vol = bead_volume / 2
total_vol = bead_volume + sample_volume + DEAD_TOTAL_VOL
# Mix beads and PCR samples and incubate
for target in range(int(len(samples))):
# Aspirate beads
pipette.pick_up_tip()
pipette.aspirate(bead_volume, beads)
robot.head_speed(**SLOW_HEAD_SPEEDS,
combined_speed=max(SLOW_HEAD_SPEEDS.values()))
# Transfer and mix on mix_plate
pipette.aspirate(sample_volume + DEAD_TOTAL_VOL, samples[target])
pipette.dispense(total_vol, mixing[target])
pipette.mix(IMMOBILISE_MIX_REPS, mix_vol, mixing[target])
pipette.blow_out()
# Dispose of tip
robot.head_speed(**DEFAULT_HEAD_SPEEDS,
combined_speed=max(DEFAULT_HEAD_SPEEDS.values()))
pipette.drop_tip()
# Immobilise sample
pipette.delay(minutes=incubation_time)
# Transfer sample back to magdeck
for target in range(int(len(samples))):
pipette.transfer(total_vol,
mixing[target],
samples[target],
blow_out=True)
# Engagae MagDeck and incubate
MAGDECK.engage(height=MAGDECK_HEIGHT)
pipette.delay(minutes=settling_time)
# Remove supernatant from magnetic beads
for target in samples:
pipette.transfer(total_vol, target, liquid_waste, blow_out=True)
# Wash beads twice with 70% ethanol
air_vol = pipette.max_volume * AIR_VOL_COEFF
for cycle in range(2):
for target in samples:
pipette.transfer(ETHANOL_VOL, ethanol, target, air_gap=air_vol)
pipette.delay(minutes=WASH_TIME)
for target in samples:
pipette.transfer(ETHANOL_VOL + ETHANOL_DEAD_VOL,
target,
liquid_waste,
air_gap=air_vol)
# Dry at RT
pipette.delay(minutes=drying_time)
# Disengage MagDeck
MAGDECK.disengage()
# Mix beads with elution buffer
if elution_buffer_volume / 2 > pipette.max_volume:
mix_vol = pipette.max_volume
else:
mix_vol = elution_buffer_volume / 2
for target in samples:
pipette.transfer(elution_buffer_volume,
elution_buffer,
target,
mix_after=(ELUTION_MIX_REPS, mix_vol))
# Incubate at RT for "elution_time" minutes
pipette.delay(minutes=elution_time)
# Engagae MagDeck for 1 minute and remain engaged for DNA elution
MAGDECK.engage(height=MAGDECK_HEIGHT)
pipette.delay(minutes=ELUTANT_SEP_TIME)
# Transfer clean PCR product to a new well
for target, dest in zip(samples, output):
pipette.transfer(elution_buffer_volume - ELUTION_DEAD_VOL,
target,
dest,
blow_out=False)
# Disengage MagDeck
MAGDECK.disengage()
from opentrons import robot, containers, instruments
robot.head_speed(x=16000, y=16000, z=3000, a=200, b=200)
# Deck setup
tiprack_300 = containers.load("tiprack-300ul", "D3")
source_trough12row = containers.load('trough-12row', "E2")
reaction_rack = containers.load("StarLab_96_tall", "D1")
trash = containers.load("point", "C3")
# Pipettes SetUp
p300_multi = instruments.Pipette(
name='dlab_300multi',
axis="a",
trash_container=trash,
tip_racks=[tiprack_300],
max_volume=300,
min_volume=30,
channels=8,
)
source_base = 'A5'
volume_base = 30.48113208
source_coupling_agent = 'A6'
volume_coupling_agent = 50.00396632
number_rows = 9
p300_multi.distribute(
volume_base, source_trough12row.wells(source_base),
[x.top(-5) for x in reaction_rack.rows(0, to=number_rows)])
p300_multi.distribute(
volume_coupling_agent, source_trough12row.wells(source_coupling_agent),
[x.top(-5) for x in reaction_rack.rows(0, to=number_rows)])
robot.home()
# imports
from opentrons import robot, containers, load, insturments
from intertools import chains
# robot settings
robot.head_speed(z=1000)
# container set up
# set tip racks
tiprack = containers.load('tiprack-200ul', 'A1')
# waste
waste = containers.load('point', 'C2', 'waste')
liquid_waste = containers.load('96-PCR-flat', 'D1', 'liquid waste')
# wash basin
wash_basin = containers.load('trash-box', 'B1', 'wash basin')
# microwell plate
uwell = containers.load('96-PCR-flat', 'C1')
# load pipette
p200_multi = insturments.Pipette(
axis='a'
name='p200_multi',
max_volume=200,
min_volume=20,
channels=8
# imports
from opentrons import robot, containers, instruments
input_plate = containers.load('24-well-plate', 'C1')
output_plate = containers.load('96-deep-well', 'C2')
tiprack = containers.load('tiprack-200ul', 'A1')
trash = containers.load('point', 'A2')
pipette = instruments.Pipette(axis='a',
max_volume=200,
tip_racks=[tiprack],
trash_container=trash)
pipette.transfer(100,
input_plate.wells('A1'),
input_plate.wells('B2'),
new_tip="never")
robot.head_speed(18000, z=4000, a=10000)
#!--- Robot commands will be inserted here after DO NOT change this line!
pipette.pick_up_tip()
robot.move_to(
(input_plate, [34.92765567765568 + 0.2, 19.397310513447433 + -0.5, 2]),
pipette)
pipette.move_to(output_plate.wells('A1').bottom())
pipette.aspirate(50)
pipette.dispense(50)
pipette.drop_tip()
pipette.pick_up_tip()
robot.move_to(
(input_plate, [15.672161172161173 + 0.2, 34.33954767726161 + -0.5, 2]),
pipette)
pipette.move_to(output_plate.wells('B1').bottom())
pipette.aspirate(50)
robot.home() #home robot axes
#set motor speed
slow_speed = {'x': 100, 'y': 100, 'z': 20, 'a': 20, 'b': 10, 'c': 10}
fast_speed = {'x': 500, 'y': 300, 'z': 100, 'a': 100, 'b': 40, 'c': 40}
medium_speed = {'x': 300, 'y': 200, 'z': 75, 'a': 75, 'b': 25, 'c': 25}
speed_conf = int(args.integers[0])
#speed_conf = int(input('set robot speed to fast (Enter 1), medium (Enter 2) or slow (Enter 3)'))
if speed_conf == 0:
speed_set = fast_speed
elif speed_conf == 1:
speed_set = medium_speed
elif speed_conf == 2:
speed_set = slow_speed
robot.head_speed(combined_speed=max(speed_set.values()), **speed_set)
#num of chips
num_chips = int(args.integers[1])
num_wash = int(args.integers[3])
print("number of wash: ", num_wash)
rotate_st = None
#
with open('z_calibration', 'rb') as f:
z_distance = pickle.load(f)
#num_chips = int(input('Number of chips to coat (1,2 or 3)'))
# labware
if 'ax_6' not in locals():
ax_6 = labware.load('ax6_5', '6')
from opentrons import labware, instruments, robot, containers
# metadata
metadata = {
'protocolName': 'Chip_coating_1',
'author': 'Daniel Nakhaee-Zadeh Gutierrez',
'description':
'Protocol used to coat the PDMS membrane of the AX6 LOC chip',
}
#setup config
#set motor speed
slow_speed = {'x': 200, 'y': 200, 'z': 50, 'a': 50, 'b': 20, 'c': 20}
robot.head_speed(combined_speed=max(slow_speed.values()), **slow_speed)
#Connect to Robot
robot.connect()
robot.home() #home robot axes
# labware
plate = labware.load('ax61', '3')
tiprack = labware.load('opentrons-tiprack-300ul', '1')
tuberack = labware.load('opentrons-tuberack-50ml', '6')
ep_rack = labware.load('opentrons-tuberack-2ml-eppendorf', '5')
# pipettes
pipette_300 = instruments.P300_Single(mount='left', tip_racks=[tiprack])
pipette_50 = instruments.P50_Single(mount='right', tip_racks=[tiprack])
#/ /_/ / / /_____/ __/ / /_/ / /| / ___ | (__ ) __/ /_/ /
#\____/ /_/ /____/ /_____/_/ |_/_/ |_| /____/\___/\__, /
# /_/
# Claseek library prep protocol, expects 3-5ug of DNA in 90ul of Tris
#
#
# BEFORE BEGINNING
# Attach correct pipettors (P300 Multi on left mount)
# Set OT-2 to calibrate to the bottom of wells
# Calibrate OT-2
# Fill 12-row trough based on lines 57-59, prepare claseek kit end-conversion and adapter ligation mixes.
from opentrons import labware, instruments, modules, robot
#set robot gantry speed
robot.head_speed(x=50, y=50, z=60, a=60, b=40, c=40)
#To enable debug mode (all wait peroiods run for 1 min only) change debug value to 1
debug = 0
#import custom labware
enzrack = 'coolrack-96'
if enzrack not in labware.list():
enzrack = labware.create(enzrack,
grid=(12, 8),
spacing=(9, 9),
diameter=5,
depth=20,
volume=200)
#deepwell = 'deepwell-plate-96'
from opentrons import robot, containers, instruments
robot.head_speed(x=17000, y=17000, z=5000, a=100, b=300)
#Deck setup
tiprack_300 = containers.load("tiprack-300ul", "D3")
tiprack_300_2 = containers.load("tiprack-300ul", "E2")
source_trough4row = containers.load("trough-12row", "C2")
pwup_rack = containers.load("FluidX_96_small", "D1", "pwup rack")
destination_QC = containers.load("96-PCR-flat", "B1", "QC")
destination_screen = containers.load("Labcyte_384PP", "C1", "384_Screen")
trash = containers.load("point", "C3")
#Pipettes SetUp
p300_multi = instruments.Pipette(
name='dlab_300multi_no_min',
axis="a",
trash_container=trash,
tip_racks=[tiprack_300, tiprack_300_2],
max_volume=300,
min_volume=0,
channels=8,
)
volume_QC = 20
volume_screen = 30
location_QC_solvent = 'A5'
volume_QC_solvent = 100
number_rows = 7
# The protocol itself
for i in range(0, number_rows + 1):
destination_384 = [
def select():
robot.home()
robot.head_speed(x=70, y=70, z=70, a=70, b=50, c=50)
p300.delay(minutes=spri_incubation_time)
magmodule.engage(height=magnet_height)
p300.delay(minutes=spri_settle_time)
from opentrons import robot, labware, instruments
metadata = {
'protocolName':
'Tube Resuspension: Resuspend 384 at 5 millimeters from bottom with 10 microliters',
'author': 'Amhed Vargas <*****@*****.**>',
'source': 'KAUST - OT-2 Protocols'
}
###Robot speed
##Default speeds 'x': 600, 'y': 400, 'z': 125, 'a': 125, 'b': 50, 'c': 50
robot.head_speed(x=300, y=200, z=125, a=125, b=50, c=50)
##Labware
#Tips
#p300rack = labware.load('opentrons_96_tiprack_300ul', '9')
p10rack1 = labware.load('tiprack-10ul', '4')
p10rack2 = labware.load('tiprack-10ul', '1')
#Plates
p384plate = labware.load('384-plate', '3')
#Samples
sample96plate = labware.load('96-PCR-tall', '2')
##Pippetes and tips definition
#p50 = instruments.P50_Single(mount='right', tip_racks=[p300rack])
p10m = instruments.P10_Multi(mount='right', tip_racks=[p10rack1, p10rack2])
"""This protocol transfers the main reactant onto the 96 reaction rack. It takes information from 1 csv, stock_reagents. It takes sequentially the reactant from the 24 fluidx racks to the 96 plate"""
from opentrons import robot, containers, instruments
robot.head_speed(x=18000, y=18000, z=5000, a=250, b=250)
class Vector(object):
def tolist(self):
return list(self.input_list)
def astype(self, input_type):
if input_type == int:
return Vector([int(float(x)) for x in self.input_list])
return Vector([input_type(x) for x in self.input_list])
def __init__(self, input_list):
self.input_list = input_list
class DataFrame(object):
def __len__(self):
return self.length
def __getitem__(self, value):
return Vector(self.dict_input[value])
def __init__(self, dict_input, length):
self.dict_input = dict_input
self.length = length
- petri dish(es)
- 96-PCR flat tray(s)
Instruments:
- Single (200-1000ul) Pipette (set on the b axis)
"""
from opentrons import robot, containers, instruments
from opentrons.util.vector import Vector
from math import cos, sin
# Connect to & Configure Robot ==========================
robot.connect(robot.get_serial_ports_list()[0])
robot.head_speed(20000)
robot.home()
# Define Container Types ==============================
tiprack_type = 'tiprack-200ul'
water_type = 'point'
trash_type = 'point'
tray_type = '96-PCR-flat'
petri_type = 'point'
# Define Container Mapping(s) =========================
from opentrons import robot, containers, instruments
robot.head_speed(x=20000, y=20000, z=4000, a=100, b=700)
#Deck setup
tiprack_300 = containers.load("tiprack-300ul", "D3")
tiprack_300_2 = containers.load("tiprack-300ul", "E2")
source_trough4row = containers.load("trough-12row", "C2")
reaction_rack = containers.load("96-PCR-flat", "B1")
trash = containers.load("point", "B3")
#Pipettes SetUp
p300_multi = instruments.Pipette(
name='dlab_300multi',
axis="a",
trash_container=trash,
tip_racks=[tiprack_300, tiprack_300_2],
max_volume=300,
min_volume=30,
channels=8,
)
source_solvent = 'A8'
volume_solvent = 240
#source_water = 'A2'
#volume_water = 100
#source_aqueous = 'A11'
#volume_aqueous = 200
number_rows = 9
p300_multi.distribute(volume_solvent, source_trough4row.wells(source_solvent), [x.top() for x in reaction_rack.rows(0,to=number_rows-1)], air_gap = 10)
#p300_multi.distribute(volume_water, source_trough4row.wells(source_water), [x.top() for x in reaction_rack.rows(0,to=number_rows-1)])
#Cooldeck Layout:
# A5 - Substrate DAB 0.25mL
# A4 - Empty
# A3 - 20X Detection 0.25mL
# A2 - Empty
# A1 - 20X ConjG 0.25mL
#--------------------------------------------------------------------------------------
#--------------------------------------------------------------------------------------
#Import dependencies
#--------------------------------------------------------------------------------------
from opentrons import robot
from opentrons import containers, instruments
robot.head_speed(x=18000, y=18000, z=5500, a=1100, b=1100)
robot.arc_height = 5
#--------------------------------------------------------------------------------------
#Initialise deck / pipettes
#--------------------------------------------------------------------------------------
tiprack = containers.load('tiprack-200ul', 'E2', 'tiprack')
tiprack2 = containers.load('tiprack-1000ul', 'C3', 'tiprack2')
tiprack3 = containers.load('tiprack-200ul', 'E3', 'tiprack3')
trash = containers.load('trash-box', 'D2', 'trash')
serum = containers.load('96-PCR-tall', 'A1', 'serum')
sampleDil = containers.load('96-PCR-tall', 'B1', 'sampleDil')
cooldeck = containers.load('tube-rack-2ml', 'A3', 'cooldeck')
sample = containers.load('96-PCR-tall', 'C1', 'sample')
tuberack2 = containers.load('tube-rack-15_50ml2', 'C2', 'tuberack2')
plate2 = containers.load('slide_deck2', 'D1', 'plate2')
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)
m300.delay(seconds=10)
mag_deck.engage(height=18)
m300.delay(seconds=10)
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
max_speed_per_axis = {'x': (100), 'y': (100), 'z': (50), 'a': (20), 'b': (20), 'c': (20)}
robot.head_speed(combined_speed=max(max_speed_per_axis.values()),**max_speed_per_axis)
m300.set_flow_rate(aspirate=25, dispense=25)
m300.aspirate(bead_vol, SPRI_beads)
m300.move_to(target.bottom(1))
m300.dispense(bead_vol,target.bottom(6))
m300.set_flow_rate(aspirate=50, dispense=50)
m300.delay(seconds=5)
m300.move_to(target.top(-4))
m300.blow_out()
max_speed_per_axis = {'x': (600), 'y': (400), 'z': (100), 'a': (100), 'b': (40),'c': (40)}
robot.head_speed(combined_speed=max(max_speed_per_axis.values()),**max_speed_per_axis)
m300.drop_tip()
def run_custom_protocol(pipette_type: StringSelection(
'p300_Multi', 'p50_Multi', 'p10_Multi', 'p1000_Single', 'p300_Single',
'p50_Single', 'p10_Single') = 'p300_Multi',
pipette_mount: StringSelection('left',
'right') = 'left',
sample_number: int = 16,
PCR_volume: float = 20,
bead_ratio: float = 1.8,
elution_buffer_volume: float = 20):
incubation_time = 300
settling_time = 50
drying_time = 5
total_tips = sample_number * 8
tiprack_num = total_tips // 96 + (1 if total_tips % 96 > 0 else 0)
slots = ['3', '5', '6', '8', '9', '10', '11'][:tiprack_num]
if pipette_type == 'p1000_Single':
tipracks = [labware.load('tiprack-1000ul', slot) for slot in slots]
pipette = instruments.P1000_Single(mount=pipette_mount,
tip_racks=tipracks)
elif pipette_type == 'p300_Single':
tipracks = [labware.load('tiprack-200ul', slot) for slot in slots]
pipette = instruments.P300_Single(mount=pipette_mount,
tip_racks=tipracks)
elif pipette_type == 'p50_Single':
tipracks = [labware.load('tiprack-200ul', slot) for slot in slots]
pipette = instruments.P50_Single(mount=pipette_mount,
tip_racks=tipracks)
elif pipette_type == 'p10_Single':
tipracks = [labware.load('tiprack-10ul', slot) for slot in slots]
pipette = instruments.P10_Single(mount=pipette_mount,
tip_racks=tipracks)
elif pipette_type == 'p10_Multi':
tipracks = [labware.load('tiprack-10ul', slot) for slot in slots]
pipette = instruments.P10_Multi(mount=pipette_mount,
tip_racks=tipracks)
elif pipette_type == 'p50_Multi':
tipracks = [labware.load('tiprack-200ul', slot) for slot in slots]
pipette = instruments.P50_Multi(mount=pipette_mount,
tip_racks=tipracks)
elif pipette_type == 'p300_Multi':
tipracks = [labware.load('tiprack-200ul', slot) for slot in slots]
pipette = instruments.P300_Multi(mount=pipette_mount,
tip_racks=tipracks)
mode = pipette_type.split('_')[1]
if mode == 'Single':
if sample_number <= 5:
reagent_container = labware.load('opentrons-tuberack-2ml-screwcap',
'7')
liquid_waste = labware.load('trough-12row', '5').wells('A12')
else:
reagent_container = labware.load('trough-12row', '7')
liquid_waste = reagent_container.wells('A12')
samples = [well for well in mag_plate.wells()[:sample_number]]
samples_top = [well.top() for well in samples]
output = [well for well in output_plate.wells()[:sample_number]]
else:
reagent_container = labware.load('trough-12row', '7')
liquid_waste = reagent_container.wells('A12')
col_num = sample_number // 8 + (1 if sample_number % 8 > 0 else 0)
samples = [col for col in mag_plate.cols()[:col_num]]
samples_top = [well.top() for well in mag_plate.rows(0)[:col_num]]
output = [col for col in output_plate.cols()[:col_num]]
# Define reagents and liquid waste
beads = reagent_container.wells(0)
ethanol = reagent_container.wells(1)
elution_buffer = reagent_container.wells(2)
# Define bead and mix volume to resuspend beads
bead_volume = PCR_volume * bead_ratio
if mode == 'Single':
if bead_volume * sample_number > pipette.max_volume:
mix_vol = pipette.max_volume
else:
mix_vol = bead_volume * sample_number
else:
if bead_volume * col_num > pipette.max_volume:
mix_vol = pipette.max_volume
else:
mix_vol = bead_volume * col_num
total_vol = bead_volume + PCR_volume + 15
mix_voltarget = PCR_volume + 10
# Disengage MagDeck
mag_deck.disengage()
# Mix Speed
pipette.set_flow_rate(aspirate=180, dispense=180)
# Mix beads and PCR samples
for target in samples:
pipette.set_flow_rate(aspirate=180, dispense=180)
pipette.pick_up_tip()
# Slow down head speed 0.5X for bead handling
pipette.mix(25, mix_vol, beads)
max_speed_per_axis = {
'x': (50),
'y': (50),
'z': (50),
'a': (10),
'b': (10),
'c': (10)
}
robot.head_speed(combined_speed=max(max_speed_per_axis.values()),
**max_speed_per_axis)
pipette.set_flow_rate(aspirate=10, dispense=10)
pipette.transfer(bead_volume,
beads,
target,
air_gap=0,
new_tip='never')
pipette.set_flow_rate(aspirate=50, dispense=50)
pipette.mix(40, mix_voltarget, target)
pipette.blow_out()
max_speed_per_axis = {
'x': (600),
'y': (400),
'z': (100),
'a': (100),
'b': (40),
'c': (40)
}
robot.head_speed(combined_speed=max(max_speed_per_axis.values()),
**max_speed_per_axis)
pipette.drop_tip()
# Return robot head speed to the defaults for all axes
max_speed_per_axis = {
'x': (600),
'y': (400),
'z': (100),
'a': (100),
'b': (40),
'c': (40)
}
robot.head_speed(combined_speed=max(max_speed_per_axis.values()),
**max_speed_per_axis)
# Incubate beads and PCR product at RT for 5 minutes
robot.comment("Incubating the beads and PCR products at room temperature \
for 5 minutes. Protocol will resume automatically.")
pipette.delay(seconds=incubation_time)
# Engage MagDeck and Magnetize
robot._driver.run_flag.wait()
mag_deck.engage()
robot.comment("Delaying for " + str(settling_time) +
" seconds for beads to \
settle.")
pipette.delay(seconds=settling_time)
# Remove supernatant from magnetic beads
pipette.set_flow_rate(aspirate=25, dispense=120)
for target in samples:
pipette.transfer(total_vol,
target.bottom(0.7),
liquid_waste.top(),
blow_out=True)
# Wash beads twice with 70% ethanol
air_vol = pipette.max_volume * 0.1
for cycle in range(2):
pipette.pick_up_tip()
for target in samples_top:
pipette.transfer(185,
ethanol,
target,
air_gap=air_vol,
new_tip='never')
robot.comment("Delaying for 17 seconds.")
pipette.delay(seconds=17)
for target in samples:
if not pipette.tip_attached:
pipette.pick_up_tip()
pipette.transfer(195,
target.bottom(0.7),
liquid_waste.top(),
air_gap=air_vol,
new_tip='never')
pipette.drop_tip()
# Dry at RT
robot.comment("Drying the beads for " + str(drying_time) +
" minutes. Protocol \
will resume automatically.")
pipette.delay(minutes=drying_time)
# Disengage MagDeck
robot._driver.run_flag.wait()
mag_deck.disengage()
# Mix beads with elution buffer
if elution_buffer_volume / 2 > pipette.max_volume:
mix_vol = pipette.max_volume
else:
mix_vol = elution_buffer_volume / 2
for target in samples:
pipette.pick_up_tip()
pipette.transfer(elution_buffer_volume,
elution_buffer,
target,
new_tip='never')
pipette.mix(45, mix_vol, target)
pipette.drop_tip()
# Incubate at RT for 3 minutes
robot.comment(
"Incubating at room temperature for 3 minutes. Protocol will \
resume automatically.")
pipette.delay(minutes=3)
# Engage MagDeck for 1 minute and remain engaged for DNA elution
robot._driver.run_flag.wait()
mag_deck.engage()
robot.comment("Delaying for " + str(settling_time) +
" seconds for beads to \
settle.")
pipette.delay(seconds=settling_time)
# Transfer clean PCR product to a new well
for target, dest in zip(samples, output):
pipette.transfer(elution_buffer_volume,
target.bottom(1),
dest.top(),
blow_out=True)
# Disengage MagDeck
mag_deck.disengage()
from opentrons import robot, containers, instruments
robot.head_speed(x=16000, y=16000, z=4000, a=700, b=700)
#Deck setup
tiprack_300 = containers.load("tiprack-300ul", "D3")
tiprack_300_2 = containers.load("tiprack-300ul", "E2")
source_trough4row = containers.load("trough-12row", "C2")
reaction_rack = containers.load("StarLab_96_tall", "D1")
trash = containers.load("point", "C3")
#Pipettes SetUp
p300_multi = instruments.Pipette(
name='dlab_300multi',
axis="a",
trash_container=trash,
tip_racks=[tiprack_300, tiprack_300_2],
max_volume=300,
min_volume=30,
channels=8,
)
source_solvent = 'A8'
volume_solvent = 300
source_aqueous = 'A11'
volume_aqueous = 300
number_rows = 11
p300_multi.pick_up_tip()
p300_multi.aspirate(300, source_trough4row.wells(source_solvent))
p300_multi.dispense(source_trough4row.wells(source_solvent))
p300_multi.distribute(volume_solvent, source_trough4row.wells(source_solvent),
[x.top() for x in reaction_rack.rows(0, to=number_rows)])
p300_multi.distribute(volume_aqueous, source_trough4row.wells(source_aqueous),
def homehead(): robot.home() robot.head_speed(x=70, y=70, z=70, a=70, b=50, c=50)
#!/usr/bin/env python
# coding: utf-8
# In[6]:
from opentrons import robot, containers, instruments
robot.head_speed(x=18000, y=18000, z=5000, a=700, b=700)
class Vector(object):
def tolist(self):
return list(self.input_list)
def astype(self, input_type):
if input_type == int:
return Vector([int(float(x)) for x in self.input_list])
return Vector([input_type(x) for x in self.input_list])
def __init__(self, input_list):
self.input_list = input_list
class DataFrame(object):
def __len__(self):
return self.length
def __getitem__(self, value):
return Vector(self.dict_input[value])
def __init__(self, dict_input, length):
self.dict_input = dict_input
from opentrons import robot, labware, instruments
metadata = {
'protocolName': 'Tube Distribution Test: Fill 384 and transfer to 4*96',
'author': 'Amhed Vargas <*****@*****.**>',
'source': 'KAUST - OT-2 Protocols'
}
###Robot speed
robot.head_speed(x=100, y=100, z=100, a=125, b=50, c=50)
##Labware
#Tips
#p300rack = labware.load('opentrons_96_tiprack_300ul', '9')
p10rack1 = labware.load('tiprack-10ul', '1')
p10rack2 = labware.load('tiprack-10ul', '2')
#p10rack3 = labware.load('opentrons_96_tiprack_10ul', '4')
#p10rack4 = labware.load('opentrons_96_tiprack_10ul', '5')
#Plates
p384plate = labware.load('384-plate', '3')
p96plateA = labware.load('96-PCR-tall', '10')
p96plateB = labware.load('96-PCR-tall', '7')
#p96plateC = labware.load('biorad_96_wellplate_200ul_pcr', '11')
#p96plateD = labware.load('biorad_96_wellplate_200ul_pcr', '8')
#Samples
sample_tubes = labware.load('opentrons-tuberack-2ml-eppendorf', '6')
