# Hood has no row 3
max_plates_for_hood = len([s for s in dest_slots if s[1] != '3'])
trash = containers.load('trash-box', 'E1')
# TODO: optimize so that you only use 1 tiprack and can use an extra container,
# when you have 96 well source + dest (384 needs 2x tipracks, 96 needs just 1x)
tip_slots = ['D1', 'C1']
tip_racks = [containers.load('tiprack-200ul', slot) for slot in tip_slots]
# TODO: customizable pipette vol
p50multi = instruments.Pipette(
axis='a',
channels=8,
max_volume=50,
min_volume=5,
tip_racks=tip_racks,
trash_container=trash,
)
container_choices = [
'96-flat', '96-PCR-tall', '96-deep-well', '384-plate']
def alternating_wells(plate, row_num):
"""
Returns list of 2 WellSeries for the 2 possible positions of an
8-channel pipette for a row in a 384 well plate.
"""
return [
plate.rows(row_num).wells(start_well, length=8, step=2)
robot.head_speed(x=18000, y=18000, z=3000, a=400, b=400)
#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")
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',
axis="a",
trash_container=trash,
tip_racks=[tiprack_300],
max_volume=300,
min_volume=0,
channels=8,
)
volume_to_dispense = 15
location_QC_solvent = 'A5'
volume_QC_solvent = 100
number_rows = 3
source_location = [
well.bottom(4) for well in reaction_rack.rows(0, to=number_rows)
]
destination_location = [
well.bottom(1) for well in destination_QC.rows(0, to=number_rows)
]
from opentrons import containers, instruments
trough = containers.load('trough-12row', 'D2', 'trough')
plate = containers.load('96-PCR-flat', 'C1', 'plate')
m200rack = containers.load('tiprack-200ul', 'A1', 'm200-rack')
trash = containers.load('trash-box', 'B2')
m200 = instruments.Pipette(name="m200",
trash_container=trash,
tip_racks=[m200rack],
min_volume=20,
max_volume=200,
axis="a",
channels=8)
def run_custom_protocol(final_volume: float = 200):
transfer_volume = final_volume / 10.0
buffer_volume = final_volume - transfer_volume
m200.distribute(buffer_volume, trough['A1'], plate.rows('2', to='7'))
m200.pick_up_tip()
m200.transfer(transfer_volume,
plate.rows('1', to='6'),
plate.rows('2', to='7'),
mix_after=(3, final_volume / 2),
new_tip='never')
# trash for 8-channel in slot C1
H2SO4 = containers.load('trough-15ml', 'E2','H2SO4-trough')
#Fill trough with 15 mL concentrated sulfuric acid in slot D2; you'll use 12
Assay96 = containers.load('96-PCR-flat','C2')
# place the assay plate in slot C2
Glucose = SamplesLeft.wells(7)
# place 0.25 mg/ml glucose stock in a 1.7 ml tube in slot D2 of bay C3
Water = SamplesRight.wells(7)
# place water in a 1.7 ml tube in slot D2 of bay D3
#Pipettes mounted: p200 in axis B, p200-8-channel in axis A
B = instruments.Pipette(
name = "p200",
trash_container = TrashB,
tip_racks = [Tip_rack_1],
max_volume = 200,
min_volume = 20,
axis="b",
aspirate_speed=1000,
dispense_speed=1000
)
A = instruments.Pipette(
name = "p300-8channel",
trash_container = TrashA,
tip_racks= [Tip_rack_8],
max_volume = 250, #the bottom 30 ul on this 300 ul pipette are unusable
min_volume = 30,
channels = 8,
axis = "a",
aspirate_speed=1000,
dispense_speed=1000
from opentrons import containers, instruments
tiprack200 = containers.load('tiprack-200ul', 'A1')
tiprack10 = containers.load('tiprack-10ul', 'B2')
tube_rack = containers.load('tube-rack-2ml', 'D1')
cold_deck = containers.load('tube-rack-2ml', 'D2')
trash = containers.load('trash-box', 'A1')
heat_deck = containers.load('tube-rack-2ml', 'B3')
p200 = instruments.Pipette(name="p200",
trash_container=trash,
tip_racks=[tiprack200],
max_volume=200,
axis="b")
p10 = instruments.Pipette(name="p10",
trash_container=trash,
tip_racks=[tiprack10],
max_volume=10,
axis="a")
# six sample protocol
num_samples = 6
DNA_vol = 2
cell_vol = 25
# add DNA from tube column B to tube column A in cold deck
p10.transfer(DNA_vol,
cold_deck.cols('B').wells('1', length=num_samples),
cold_deck.cols('A').wells('1', length=num_samples),
from opentrons import containers, instruments
# from opentrons import robot
# robot.connect()
# robot.home()
# print('homed')
tipracks = [containers.load('tiprack-200ul', slot) for slot in ('10', '3')]
single = instruments.Pipette(mount='right',
min_volume=10,
name="p200",
tip_racks=tipracks)
for tiprack in tipracks:
for tip in (tiprack[0], tiprack[-1]):
single.pick_up_tip(tip)
single.drop_tip(tip)
#
p10s_tipracks = [containers.load('tiprack-10ul', 'E3')]
p10_tipracks = [containers.load('tiprack-10ul', 'E2')]
p200_tipracks = [containers.load('tiprack-200ul', 'A3')]
source = [containers.load('96-flat', 'D2'), containers.load('96-flat', 'D3')]
dest = containers.load('96-PCR-tall', 'C2')
master = containers.load('PCR-strip-tall', 'C3')
reagents = containers.load('tube-rack-2ml', 'B1')
trash = containers.load('point', 'D1', 'holywastedplasticbatman')
p10s = instruments.Pipette(axis='a',
max_volume=10,
min_volume=0.5,
tip_racks=p10s_tipracks,
trash_container=trash,
channels=1,
name='p10-8s')
p10 = instruments.Pipette(axis='a',
max_volume=10,
min_volume=0.5,
tip_racks=p10_tipracks,
trash_container=trash,
channels=8,
name='p10-8')
p200 = instruments.Pipette(axis='b',
max_volume=200,
min_volume=20,
def Pipette(self, *args, **kwargs):
"""
Deprecated -- do not use this constructor directly. Use the model-
specific constructors available in this module.
"""
return inst.Pipette(self.robot, *args, **kwargs)
from opentrons import containers, instruments
tiprack = containers.load('tiprack-200ul', 'B1')
tiprack2 = containers.load('tiprack-200ul', 'B2')
trash = containers.load('trash-box', 'C2')
trough = containers.load('trough-12row', 'C1')
plate = containers.load('96-PCR-flat', 'D1')
tuberack = containers.load('tube-rack-2ml', 'D2')
m50 = instruments.Pipette(name="p200",
trash_container=trash,
tip_racks=[tiprack, tiprack2],
max_volume=50,
axis="a",
channels=8)
p200 = instruments.Pipette(name="p200S",
trash_container=trash,
tip_racks=[tiprack],
max_volume=200,
axis="b")
# dispense 6 standards from tube racks (A1, B1, C1, D1, A2, B2)
# to first two rows of 96 well plate (duplicates, A1/A2, B1/B2 etc.)
for i in range(6):
p200.distribute(25, tuberack.wells(i), plate.cols(i).wells('1', '2'))
# dispense 4 samples from tube rack (C2, D2, A3, B3)
# to row 3 of 96 well plate (duplicates, A3/B3, C3/D3, E3/F3, G3/H3)
p200.distribute(50, tuberack.wells('C2', 'D2', 'A3', 'B3'), plate.rows('3'))
p20_rack = containers.load('tiprack-200ul-6x12', 'B2', 'p20_rack')
#Create 3x6 2ml tube rack for DNA samples
containers.create('3x6-tube-rack-2ml',
grid=(3, 6),
spacing=(19.5, 19.5),
diameter=9.5,
depth=40)
DNA_rack = containers.load('3x6-tube-rack-2ml', 'C3', 'DNA_rack')
#Specify p20 pipette
p20 = instruments.Pipette(tip_racks=[p20_rack],
trash_container=trash,
min_volume=2,
max_volume=20,
axis="a")
#Define sources
water_source = tube_rack.wells('A1')
GGbuffer = tube_rack.wells('A2')
GGmix = cool_rack.wells('A1')
#Define DNA and water volumes to load
total_volume = 20
DNA_volumes = [2, 3, 3.5, 4, 5, 6, 7, 8]
num_assemblies = len(DNA_volumes)
water_volumes = []
for v in DNA_volumes:
# Define the containers on the deck
p20rack_1 = containers.load('tiprack-200ul', 'A3')
p20rack_2 = containers.load('tiprack-200ul', 'B3')
p20rack_3 = containers.load('tiprack-200ul', 'A2')
p20rack_4 = containers.load('tiprack-200ul', 'C2')
samples_1 = containers.load('96-PCR-flat', 'A1')
samples_2 = containers.load('96-PCR-flat', 'B1')
samples_3 = containers.load('96-PCR-flat', 'C1')
trash = containers.load('point', 'D1')
output = containers.load('tube-rack-2ml', 'D3')
p20 = instruments.Pipette(
axis='b',
min_volume=2,
max_volume=20,
trash_container=trash,
tip_racks=[p20rack_1, p20rack_2, p20rack_3, p20rack_4]
)
for well, plate, vol in sorted_loc_vol:
sample_plate = {1: samples_1 , 2: samples_2, 3: samples_3}
if vol > 20:
p20.transfer(
vol,
sample_plate[plate][well].bottom(),
output['A1'].bottom(),
blow_out='true',
new_tip='always'
# set plates
plate_mapped = containers.load('96-PCR-flat', 'C1', 'plate_mapped')
plate_source = containers.load('tube-rack-2ml', 'C2', 'plate_source')
tube_source = containers.load('tube-rack-15_50ml', 'E1', 'tube_source')
# trash
trash = containers.load('point', 'A2')
# load pipette
p10 = instruments.Pipette(
name="p10", # optional
trash_container=trash,
tip_racks=[p10rack],
min_volume=0.2, # actual minimum volume of the pipette
max_volume=10,
axis="b",
channels=1 #
)
p1000 = instruments.Pipette(
name="p1000", # optional
trash_container=trash,
tip_racks=[p1000rack],
min_volume=50, # actual minimum volume of the pipette
max_volume=1000,
axis="a",
channels=1 #
)
output_plate_1 = containers.load('96-deep-well', 'D1')
output_plate_2 = containers.load('96-deep-well', 'D2')
output_plate_3 = containers.load('96-deep-well', 'D3')
"""
Column E
"""
trash = containers.load('trash-box', 'E1')
tiprack3 = containers.load('tiprack-200ul', 'E2')
tiprack4 = containers.load('tiprack-200ul', 'E3')
p50multi = instruments.Pipette(
axis='a',
name='p300multi',
max_volume=50,
min_volume=5,
channels=8,
tip_racks=[tiprack, tiprack2, tiprack3, tiprack4],
trash_container=trash)
DMSO = trough.wells('A1')
buffer = trough.wells('A2')
all_source_plates = [
source_plate_1, source_plate_2, source_plate_3, source_plate_4
]
all_output_plates = [
output_plate_1, output_plate_2, output_plate_3, output_plate_4
]
def reactants_transfer(reactants, solvent):
# Deck setup
tiprack_1000 = containers.load("tiprack-1000ul-H", "B3")
tiprack_1000_2 = containers.load("tiprack-1000ul-H", "D3")
#tiprack_1000_3 = containers.load("tiprack-1000ul-H", "B1")
source_trough4row = containers.load("trough-12row", "C2")
rack_stock_reactants_1 = containers.load("FluidX_24_5ml", "A1", "R_1")
rack_stock_reactants_2 = containers.load("FluidX_24_5ml", "A2", "R_2")
rack_stock_reactants_3 = containers.load("FluidX_24_5ml", "B1", "R_3")
rack_stock_reactants_4 = containers.load("FluidX_24_5ml", "B2", "R_4")
reaction_rack = containers.load("Starlab_96_Square_2mL", "C1")
trash = containers.load("point", "C3")
# Pipettes SetUp
p1000 = instruments.Pipette(
name='eppendorf1000',
axis='b',
trash_container=trash,
tip_racks=[tiprack_1000, tiprack_1000_2],
max_volume=1000,
min_volume=30,
channels=1,
)
location_header = "Location"
volume_per_reaction_header = "volume_per_vial"
rack_ID_header = "Rack ID"
id_header = "CPD ID"
solvent = "DMA"
rack_1 = "24_rack1"
rack_2 = "24_rack2"
rack_3 = "24_rack3"
rack_4 = "24_rack4"
solvent_location_header = "Location_trough"
solvent_volume_header = "Volume to dispense (uL)"
counter = 0
for i, x in enumerate(reactants_df[rack_ID_header].tolist()):
volume_per_reaction = [
reactants_df[volume_per_reaction_header].tolist()[i]
]
source_location = reactants_df[location_header].tolist()[i]
if x == "":
#print('null')
break
if x == rack_1:
p1000.pick_up_tip()
p1000.transfer(volume_per_reaction,
rack_stock_reactants_1.wells(source_location),
reaction_rack.wells(i + 2).top(-5),
new_tip='never')
p1000.drop_tip()
if x == rack_2:
p1000.pick_up_tip()
p1000.transfer(volume_per_reaction,
rack_stock_reactants_2.wells(source_location),
reaction_rack.wells(i + 2).top(-5),
new_tip='never')
p1000.drop_tip()
if x == rack_3:
p1000.pick_up_tip()
p1000.transfer(volume_per_reaction,
rack_stock_reactants_3.wells(source_location),
reaction_rack.wells(i + 2).top(-5),
new_tip='never')
p1000.drop_tip()
if x == rack_4:
p1000.pick_up_tip()
p1000.transfer(volume_per_reaction,
rack_stock_reactants_4.wells(source_location),
reaction_rack.wells(i + 2).top(-5),
new_tip='never')
p1000.drop_tip()
counter += 1
# p1000.pick_up_tip()
for i, x in enumerate(solvent_df[id_header].tolist()):
if x == solvent:
vol_to_add = [solvent_df[solvent_volume_header].tolist()[i]]
solvent_loc = [solvent_df[solvent_location_header].tolist()[i]]
#p1000.distribute(vol_to_add, source_trough4row.wells(solvent_loc),
# [x.top() for x in reaction_rack.wells(0, to=counter + 1)])
#print(counter)
robot.home()
septum3 = containers.load('septum-plate', 'D1')
septum4 = containers.load('septum-plate', 'D2')
septum5 = containers.load('septum-plate', 'D3')
"""
Column E
"""
septum6 = containers.load('septum-plate', 'E1')
septum7 = containers.load('septum-plate', 'E2')
septum8 = containers.load('septum-plate', 'E3')
"""
Instruments
"""
p50 = instruments.Pipette(axis='a',
name='p50multi',
max_volume=50,
min_volume=5,
channels=8,
tip_racks=[tiprack],
trash_container=trash)
p100 = instruments.Pipette(axis='b',
name='p100single',
max_volume=100,
min_volume=10,
channels=1,
tip_racks=[tiprack],
trash_container=trash)
def run_custom_protocol(plate_number: int = 4):
plates = [
from opentrons import containers, instruments
# add a 2ml tube rack
tuberack = containers.load('tube-rack-2ml', 'C1')
# add a p10 pipette, with tiprack and trash
p10rack = containers.load('tiprack-200ul', 'A1')
trash = containers.load('trash-box', 'B2')
p10 = instruments.Pipette(
axis='b',
max_volume=10,
trash_container=trash,
tip_racks=[p10rack]
)
# single sample volumes
buffer_vol = 1
vector_vol = 1.5
insert_vol = 2
ligase_vol = 1.6
water_vol = 20 - (buffer_vol + vector_vol + insert_vol + ligase_vol)
if water_vol < 0:
raise RuntimeWarning('Volumes add up to more than 20uL')
p10.transfer(water_vol, tuberack.wells('D1'), tuberack.wells('B2'))
p10.transfer(buffer_vol, tuberack.wells('A1'), tuberack.wells('B2'))
p10.transfer(vector_vol, tuberack.wells('B1'), tuberack.wells('B2'))
p10.transfer(insert_vol, tuberack.wells('C1'), tuberack.wells('B2'))
# resuspend and add ligase
trash = containers.load('point', 'D1', 'Tip trash')
washBasin = containers.load('trough-12row', 'A1', 'KRBH low glucose')
reservoirs = containers.load('trough-8row', 'B2', 'Solution reservoirs')
samplePlate = containers.load(
'96-sample-tubes', 'B1', 'Sample plate - place on heater'
) # Deep well plate with samples; hot plate beneath, 37 °C.
collectionPlate = containers.load('384-plate', 'C1',
'384-well collection plate')
p300_multi_high_speed = instruments.Pipette( # high dispense speed, robot max, use for washing columns 7-11
axis='a',
name='P300 Multichannel pipette, high dispense speed',
max_volume=300,
min_volume=30,
channels=8,
tip_racks=tipracks,
trash_container=trash,
aspirate_speed=300,
dispense_speed=540)
p300_multi_low_speed = instruments.Pipette( # Lowest pipette speed, use for washing and columns 0-3
axis='a',
name='P300 Multichannel pipette, low dispense speed',
max_volume=300,
min_volume=30,
channels=8,
tip_racks=tipracks,
trash_container=trash,
aspirate_speed=300,
dispense_speed=120)
def process_head(self):
"""
res example:
{ name: {
'instance': ..,
'settings': {'down-plunger-speed', '
}
}
:return:
"""
head_dict = self.protocol['head']
SUPPORTED_TOOL_OPTIONS = {
'tool', 'tip-racks', 'trash-container', 'multi-channel', 'axis',
'volume', 'down-plunger-speed', 'up-plunger-speed', 'tip-plunge',
'extra-pull-volume', 'extra-pull-delay', 'distribute-percentage',
'points'
}
head_obj = {}
for tool_name, tool_config in head_dict.items():
# Validate tool_config keys
# Create a warning if unknown keys are detected
user_provided_tool_options = set(tool_config.keys())
if not (SUPPORTED_TOOL_OPTIONS >= user_provided_tool_options):
invalid_options = (user_provided_tool_options -
SUPPORTED_TOOL_OPTIONS)
self.warnings.append(
'Encountered unsupported tool options for "{}": {}'.format(
tool_name, ', '.join(invalid_options)))
tool_config.pop('tool')
# robot_containers = robot._deck.containers()
tip_rack_objs = [
self.deck[item['container']]['instance']
for item in tool_config.pop('tip-racks')
]
tool_config['tip-racks'] = tip_rack_objs
trash_obj = self.deck[tool_config.pop('trash-container')
['container']]['instance']
tool_config['trash-container'] = trash_obj
tool_config['points'] = [
dict(i) for i in tool_config.pop('points')
]
tool_instance = instruments.Pipette(
name=tool_name,
axis=tool_config.pop('axis'),
max_volume=tool_config.pop('volume'),
min_volume=0,
channels=(8 if tool_config.pop('multi-channel') else 1),
tip_racks=tip_rack_objs,
trash_container=trash_obj)
head_obj[tool_name] = {
'instance': tool_instance,
'settings': dict(tool_config)
}
self.head = head_obj
def mainReactant_transfer(reactant, reaction):
# Deck setup
tiprack_1000 = containers.load("tiprack-1000ul-H", "B3")
source_trough12row = containers.load("trough-12row", "C1")
location_stock = containers.load("FluidX_24_5ml", "A1", "int")
reaction_rack = containers.load("StarLab_96_tall", "D1")
trash = containers.load("point", "C3")
# Pipettes SetUp
p1000 = instruments.Pipette(
name='eppendorf1000',
axis='b',
trash_container=trash,
tip_racks=[tiprack_1000],
max_volume=1000,
min_volume=30,
channels=1,
)
id_header = "reaction"
reaction_to_start = "Coupling_standard"
main_reactant_volume_header = "main reactant volume to add - per reaction (uL)"
main_reactant_location_header = "Location 24 vial rack"
volume_max_header = "Volume max per vial"
nb_reaction_header = "Number reaction"
for index, value in enumerate(reaction_conditions_df[id_header].tolist()):
if value == reaction_to_start:
volume_per_reaction = float(
reaction_conditions_df[main_reactant_volume_header].tolist()
[index])
nb_reactions = int(
reaction_conditions_df[nb_reaction_header].tolist()[index])
reaction_counter = 0
"""In each well, the volume per reaction of reaction is dispensed, successively in the logical order ("A1", "A2"...). When the maximum amount of reactant in one vial is taken out, the following
vial in the fluidx rack is used. The transfer stops when the reactant is dispensed in all the wells of the 96 plate or all the wells used for the batch."""
for index, value in enumerate(
reaction_df[main_reactant_location_header].tolist()):
if reaction_counter < nb_reactions:
nb_reaction_per_vial = int(
float(reaction_df[volume_max_header].tolist()[index]) //
volume_per_reaction)
source_location = value
if nb_reactions - reaction_counter < nb_reaction_per_vial:
if nb_reactions - reaction_counter == 1:
p1000.distribute(
volume_per_reaction,
location_stock.wells(source_location),
reaction_rack.wells(reaction_counter).top())
nb_reaction_per_vial = 1
else:
p1000.distribute(volume_per_reaction,
location_stock.wells(source_location), [
x.top() for x in reaction_rack.wells(
reaction_counter, to=nb_reactions)
])
else:
p1000.distribute(
volume_per_reaction, location_stock.wells(source_location),
[
x.top()
for x in reaction_rack.wells(reaction_counter,
to=reaction_counter +
nb_reaction_per_vial - 1)
])
reaction_counter = reaction_counter + nb_reaction_per_vial
robot.home()
p10_tiprack_single = containers.load('tiprack-10ul', 'E3')
p200_tiprack = containers.load('tiprack-200ul', 'A3')
tubes_single = containers.load('96-PCR-tall', 'C2')
strip_single = containers.load('PCR-strip-tall', 'C3')
source1_single = containers.load('96-flat', 'D2')
source2_single = containers.load('96-flat', 'B3')
source3_single = containers.load('96-flat', 'D3')
source4_single = containers.load('96-flat', 'B2')
trash = containers.load('point', 'D1', 'holywastedplasticbatman')
p10single = instruments.Pipette(axis='a',
max_volume=10,
min_volume=0.5,
tip_racks=[p10_tiprack_single],
trash_container=trash,
channels=1,
name='p10-8s')
p200 = instruments.Pipette(axis='b',
max_volume=200,
min_volume=20,
tip_racks=[p200_tiprack],
trash_container=trash,
channels=1,
name='p200-1')
p10single.pick_up_tip()
p10single.aspirate(9, strip_single['A1'].bottom())
mag_plate = containers.load('96-PCR-flat', 'C3', 'mag plate')
"""
Column D
"""
gel_plate = containers.load('96-PCR-flat', 'D1', 'gel plate')
trash = containers.load('trash-box', 'D3')
# output plate for library reactions
TE = containers.load('point', 'D2', 'TE')
# p200 (20 - 200 uL) (single)
p200single = instruments.Pipette(axis='b',
name='p200single',
max_volume=200,
min_volume=20,
channels=1,
tip_racks=[tip200_rack])
p300multi = instruments.Pipette(axis='a',
name='p300multi',
max_volume=300,
min_volume=50,
channels=8,
tip_racks=[tip300_rack])
mag_deck = instruments.Magbead(name='mag_deck')
# Helper Functions
def stock_solution_reactant(reactants_df, solvent_df):
# Deck setup
tiprack_1000 = containers.load("tiprack-1000ul-H", "B3")
tiprack_1000_2 = containers.load("tiprack-1000ul-H", "D3")
source_trough4row = containers.load("trough-12row", "C2")
rack_stock_reactants_1 = containers.load("FluidX_24_5ml", "A1", "R_1")
rack_stock_reactants_2 = containers.load("FluidX_24_5ml", "A2", "R_2")
rack_stock_reactants_3 = containers.load("FluidX_24_5ml", "B1", "R_3")
rack_stock_reactants_4 = containers.load("FluidX_24_5ml", "B2", "R_4")
trash = containers.load("point", "B3")
# Pipettes SetUp
p1000 = instruments.Pipette(
name='eppendorf1000',
axis='b',
trash_container=trash,
tip_racks=[tiprack_1000, tiprack_1000_2],
max_volume=1000,
min_volume=30,
channels=1,
)
rack_ID_header = "Rack ID"
id_header = "Reaction parameters type"
solvent = "Reaction solvent"
rack_1 = "24_rack1"
rack_2 = "24_rack2"
rack_3 = "24_rack3"
rack_4 = "24_rack4"
location_header = "Location_trough"
destination_location_header = "Location"
volume_stock_header = "Volume to dispense (exp) at 0.8M"
for i, x in enumerate(solvent_df[id_header].tolist()):
if x == solvent:
solvent_location = solvent_df[location_header].tolist()[i]
p1000.pick_up_tip()
for i, x in enumerate(reactants_df[destination_location_header].tolist()):
destination_location = x
vol_to_dispense = [reactants_df[volume_stock_header].tolist()[i]]
reactants_id = reactants_df[rack_ID_header].tolist()[i]
if reactants_id == "":
print('null')
break
# print (rack_ID_header, reactants_id, vol_to_dispense)
if reactants_id == rack_1:
#print ('rack1')
if vol_to_dispense != 0:
p1000.transfer(
vol_to_dispense,
source_trough4row.wells(solvent_location),
rack_stock_reactants_1.wells(destination_location).top(-5),
new_tip='never',
air_gap=10)
if reactants_id == rack_2:
#print ('rack2')
if vol_to_dispense != 0:
p1000.transfer(
vol_to_dispense,
source_trough4row.wells(solvent_location),
rack_stock_reactants_2.wells(destination_location).top(-5),
new_tip='never',
air_gap=10)
if reactants_id == rack_3:
#print ('rack3')
if vol_to_dispense != 0:
p1000.transfer(
vol_to_dispense,
source_trough4row.wells(solvent_location),
rack_stock_reactants_3.wells(destination_location).top(-5),
new_tip='never',
air_gap=10)
if reactants_id == rack_4:
#print ('rack4')
if vol_to_dispense != 0:
p1000.transfer(
vol_to_dispense,
source_trough4row.wells(solvent_location),
rack_stock_reactants_4.wells(destination_location).top(-5),
new_tip='never',
air_gap=10)
p1000.drop_tip()
robot.home()
from opentrons import robot, containers, instruments
robot.head_speed(x=17000, y=17000, z=5000, a=700, b=700)
#Deck setup
tiprack_1000 = containers.load("tiprack-1000ul-H", "B3")
source_row = containers.load("FluidX_24_5ml", "A1", "acid")
source_col = containers.load("FluidX_24_5ml", "A2", "amine")
reaction_rack = containers.load("StarLab_96_tall", "D1")
trash = containers.load("point", "C3")
#Pipettes SetUp
p1000 = instruments.Pipette(
name='eppendorf1000',
axis='b',
trash_container=trash,
tip_racks=[tiprack_1000],
max_volume=1000,
min_volume=30,
channels=1,
)
row_vol_list = [
91.875, 91.875, 91.875, 91.875, 91.875, 91.875, 91.875, 91.875, 91.875,
91.875, 91.875, 91.875
]
row_loc_list = [
'A1', 'A2', 'A3', 'A4', 'A5', 'A6', 'B1', 'B2', 'B3', 'B4', 'B5', 'B6'
]
col_vol_list = [87.5, 87.5, 87.5, 87.5, 87.5, 87.5, 87.5, 87.5]
col_loc_list = ['A1', 'A2', 'A3', 'A4', 'A5', 'A6', 'B1', 'B2']
number_rows = 11
number_cols = 7
def getEquipment():
equipment = {}
############## DECK LAYOUT BEGINS HERE
#CONTAINER DEFINITIONS:
TransposeTipBox = True
#DECK:
# col A = left-hand side when viewed from front
# row 1 = first row viewed from front
equipment['trash'] = containers.load('point', "D1", "trash")
equipment['p200rack'] = containers.load('tiprack-200ul', 'E2',
'tiprack200')
if TransposeTipBox:
equipment['p1000rack'] = utilities.create_container_instance(
"TR1000-Transposed",
slot="A1",
grid=(8, 12),
spacing=(9.02, -9.02),
diameter=5,
depth=85,
Transposed=True)
else:
equipment['p1000rack'] = utilities.create_container_instance(
"TR1000-Normal",
slot="A1",
grid=(8, 12),
spacing=(9.02, 9.02),
diameter=5,
depth=85)
equipment['CulturePlate96'] = containers.load('96-flat', 'D2')
# create_container_instance in utilities.py does an ad-hoc creation of a custom
# container without the need to save to JSON file. There is a bug in Opentrons code
# that randomises order of wells in JSON definition files for custom containers as
# soon as more than one container is used, which is why containers.create is not an
# option for 2 containers.
equipment['CulturePlate'] = utilities.create_container_instance(
"CulturePlate24",
slot="D2",
grid=(4, 6),
spacing=(19.304, 19.304),
diameter=16.26,
depth=18)
equipment['CulturePlate2'] = utilities.create_container_instance(
"CulturePlate242",
slot="C2",
grid=(4, 6),
spacing=(19.304, 19.304),
diameter=16.26,
depth=18)
equipment['CulturePlate6well'] = utilities.create_container_instance(
"CulturePlate6",
slot="D2",
grid=(2, 3),
spacing=(39.12, 39.12),
diameter=34.80,
depth=11.27)
equipment['AliquotPlate'] = containers.load('96-flat', 'B2',
'AliquotPlate')
equipment['TubBlood'] = utilities.create_container_instance("TubBlood",
slot="C1",
grid=(8, 1),
spacing=(9.02,
9.02),
diameter=0,
depth=55)
equipment['TubMedia'] = utilities.create_container_instance("TubMedia",
slot="C1",
grid=(8, 1),
spacing=(9.02,
9.02),
diameter=0,
depth=55)
equipment['TubSybr'] = utilities.create_container_instance("TubSybr",
slot="C1",
grid=(8, 1),
spacing=(9.02,
9.02),
diameter=0,
depth=55)
#PIPETTE(S)
equipment['p1000'] = instruments.Pipette(
name="P1000",
axis="b",
min_volume=20,
max_volume=1000,
tip_racks=[equipment['p1000rack']],
trash_container=equipment['trash'])
equipment['p200x8'] = instruments.Pipette(
name="p200x8",
axis="a",
min_volume=20,
max_volume=300,
trash_container=equipment['trash'],
channels=8)
return (equipment)
from opentrons import containers, instruments
"""
Media exchange
@Author opentrons
@date October 12th, 2017
@robot OT Hood, Pro, S
"""
pipette = instruments.Pipette(axis='a',
name='1000single',
max_volume=1000,
min_volume=100,
channels=1,
aspirate_speed=200,
dispense_speed=200)
"""
DRG primary neuronal culture media exchange
- We are currently using 24 well plates.
I would like to fit do as many plates as possible each time
- maybe 6 plates, 3 tip boxes, 1 tube holder
with media tube/s and waste tube/s.
Also would like to set the flow rate low to avoid cells coming off the plate.
Since multichannels do not fit 24 wells plates,
we could use two p1000 pipettes.
Step 1: Remove 350uL from each well and deposit into waste
(we could do 2 wells with one tip per p1000 and then get new tips)
Step 2: Add 400uL of media from 50mL conical with media to plates
(we could do 2 wells with one tip per p1000 and then get new tips -
if it is possible to set height slightly
above the media, we could use the same tips)
"""
# plate_type = '24-well-plate'
from opentrons import robot, containers, instruments
# This protocol is a test for the p1000 to make sure the robot runs correctly on axis b
p1000rack = containers.load('tiprack-1000ul', 'C2')
trash = containers.load('point', 'D1')
plate1 = containers.load('96-PCR-flat', 'A2')
plate2 = containers.load('96-PCR-flat', 'A1')
p1000_single = instruments.Pipette(
axis="b",
name='p1000',
max_volume=1000,
min_volume=100,
channels=1,
trash_container=trash,
tip_racks=[p1000rack]
)
# Run of protocol
for i in range(50,91):
p1000_single.pick_up_tip(p1000rack.wells(i))
p1000_single.transfer(300,plate1.wells(i),plate2.wells(i),new_tip='never')
p1000_single.drop_tip(p1000rack.wells(i))
from opentrons import robot, instruments, containers
# Test to see if you can pause the robot from the code and then click to resume its functionality
p200rack = containers.load('tiprack-200ul', 'E2')
trash200 = containers.load('point', 'E1')
Duetz_plate = containers.load('96-deep-well', 'C1')
guava_plate = containers.load('96-PCR-flat', 'A1')
p50_multi = instruments.Pipette(
axis="a",
name='p50multi',
max_volume=50,
min_volume=5,
channels=8,
trash_container=trash200,
tip_racks=[p200rack]
)
for i in range(0, 48, 8): # This indexing is needed for the multichannel pipette
p50_multi.distribute(30,Duetz_plate.wells(i),guava_plate.wells(i))
robot.pause()
for i in range(48,96,8):
p50_multi.distribute(30,Duetz_plate.wells(i),guava_plate.wells(i))
# Pipette Accuracy test for Auguest 7th
#
from opentrons import robot, containers, instruments
from itertools import chain
tiprack = containers.load('tiprack-200ul', 'A2', 'tiprack')
wash_basin = containers.load('point', 'B2', 'wash basin')
cellwell = containers.load('96-PCR-flat', 'C1', 'cells')
p50_multi = instruments.Pipette(axis='a',
name='small volume pipette',
max_volume=50,
min_volume=5,
channels=8)
p50_multi.pick_up_tip(tiprack.wells('A1'))
p50_multi.aspirate(50, wash_basin(0))
p50_multi.dispense(50, cellwell('A1'))
p50_multi.touch_tip()
p50_multi.blow_out()
flat_plate = containers.load('96-PCR-flat', 'C1')
deep_plate = containers.load('96-deep-well', 'C2')
# tip rack for p10 and p50 pipette
tip200_rack = containers.load('tiprack-200ul', 'C3')
tip200_rack2 = containers.load('tiprack-200ul', 'E3')
tip200_rack3 = containers.load('tiprack-200ul', 'E2')
# trash to dispose of tips
trash = containers.load('trash-box', 'A3')
# p200 (20 - 200 uL) (single)
p200single = instruments.Pipette(axis='b',
name='p200',
max_volume=200,
min_volume=20,
channels=1,
trash_container=trash,
tip_racks=[tip200_rack])
# p300 (50 - 300 uL) (multi)
p300multi = instruments.Pipette(axis='a',
name='p300',
max_volume=300,
min_volume=50,
channels=8,
trash_container=trash,
tip_racks=[tip200_rack2, tip200_rack3])
# medium in trough
medium = trough['A1']
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')
p50 = instruments.Pipette(name='p50',
axis='a',
min_volume=5,
max_volume=50,
channels=8,
aspirate_speed=300,
dispense_speed=600,
trash_container=trash,
tip_racks=[tiprack, tiprack3])
p1000 = instruments.Pipette(name='p1000',
axis='b',
max_volume=1000,
min_volume=100,
aspirate_speed=300,
dispense_speed=1000,
trash_container=trash,
tip_racks=[tiprack2])
#Configure Tube Rack