def test_simulating(virtual_smoothie_env, monkeypatch):
connected = False
def mock_connect(self, port):
nonlocal connected
connected = True
monkeypatch.setattr(MagDeckDriver, 'connect', mock_connect)
modules.load('magdeck', '3')
assert not connected
def test_load_correct_engage_height():
robot.reset()
md = modules.load('magdeck', '1')
test_container = labware.load('biorad_96_wellplate_200ul_pcr',
'1', share=True)
assert test_container.magdeck_engage_height() == 18
assert md.labware.get_children_list()[1].magdeck_engage_height() == \
test_container.magdeck_engage_height()
def test_load_container_onto_tempdeck():
module_name = 'tempdeck'
slot = '2'
md = modules.load(module_name, slot)
assert md.labware.parent == robot._deck[slot]
test_container = labware.load('96-flat', slot, share=True)
assert test_container.parent == md.labware
def test_run_magdeck_connected(
non_simulating, virtual_smoothie_env, monkeypatch):
connected = False
def mock_connect(self, port):
nonlocal connected
connected = True
def mock_write(command, ack, serial_connection):
return 'ok\n\rok\n\r'
def mock_get_info(self):
return {'serial': 'abc123', 'model': '8675309', 'version': '9001'}
monkeypatch.setattr(MagDeckDriver, 'connect', mock_connect)
monkeypatch.setattr(MagDeckDriver, 'get_device_info', mock_get_info)
monkeypatch.setattr(serial_communication, 'write_and_return', mock_write)
magdeck = modules.MagDeck(port='/dev/modules/tty1_magdeck')
magdeck.connect()
robot._attached_modules = {'tty1_magdeckmagdeck': magdeck}
modules.load('magdeck', '4')
assert connected
def test_run_tempdeck_connected(
non_simulating, virtual_smoothie_env, monkeypatch):
connected = False
def mock_connect(self, port):
nonlocal connected
connected = True
def mock_write(command, ack, serial_connection):
return 'ok\n\rok\n\r'
def mock_get_info(self):
return {'serial': 'abc123', 'model': '8675309', 'version': '9001'}
monkeypatch.setattr(TempDeckDriver, 'connect', mock_connect)
monkeypatch.setattr(TempDeckDriver, 'get_device_info', mock_get_info)
monkeypatch.setattr(serial_communication, 'write_and_return', mock_write)
tempdeck = modules.TempDeck(port='/dev/modules/tty1_tempdeck')
tempdeck.connect()
robot._attached_modules = {'tty1_tempdecktempdeck': tempdeck}
modules.load('tempdeck', '5')
assert connected
tempdeck.disconnect() # Necessary to kill the thread started by connect()
def load(self, name, slot):
self.check_fix()
if self.config.isApiV1:
result = modules.load(name, slot)
else:
result = self.config.protocol_context.load_module(name, slot)
def load_labware_func(theModule,
load_name: str,
label: str = None,
namespace: str = None,
version: int = None):
if self.config.isApiV1:
theModule1 = typing.cast(ModulesTypeV1, theModule)
lw_module: Module = theModule1.labware
slot: Slot = lw_module.parent
location = slot.get_name()
lw = labware_manager.load(name=load_name,
slot=location,
label=label,
share=True,
namespace=namespace,
version=version,
config=self.config)
return lw
else:
theModule2 = typing.cast(ModuleContext, theModule)
location = theModule2.geometry.location
lw = labware_manager.load(name=load_name,
slot=location,
label=label,
share=True,
namespace=namespace,
version=version,
config=self.config)
return theModule2.load_labware_object(lw)
# add for v1, improve what's there for v2
result.__class__.load_labware = load_labware_func
return result
# Author(s): Matt Burridge, Alex Laverick
# Last modified: 11:35, 22/10/18
# Python 3.6.4
# Please keep the author(s) attached to the code segment for traceability, if changes are made please append the authour list and modify the timestamp #
#####################################################################################################################################
# The input from the code must be in list within a list, the sublist must contain the appropriate float type value and no whitespaces
from opentrons import labware, instruments, robot, modules # Import all Opentrons API
from sqlite3 import IntegrityError # Import sqlite3 for custom container support
tiprack200_1 = labware.load('tiprack-200ul', slot='9') # Import labware
tempdeck = modules.load('tempdeck',
slot='7') # Saves the temperature deck as a variable
Compcells1 = labware.load(
'96-flat', slot='7', share=True
) # Declares a 96 well flat container as a variable, share allows a module to share the slot
trash = robot.fixed_trash # Declares the trash container on the fixed trash position of the work surface in the OT2
Culture = labware.load(
'duran_100',
slot='4') # Declares a custom duran_100 container from the Labware
Buffers = labware.load('96-deep-well',
slot='3') # Declares a 96 deep well plate as a variable
P300 = instruments.P300_Single( # Import Pipette, set aspiration/dispense rates and equip with rack
mount='right',
aspirate_flow_rate=200,
dispense_flow_rate=200,
tip_racks=[tiprack200_1],
trash_container=trash)
"96-deep-well", slot='3', share=True
) # Assigns a 96 deep well plate to the variable Buffers, share allows a module in the slot as well, make sure to calibrate the deck accordingly
Compcells1 = labware.load(
'96-flat',
slot='6') # Assigns a 96 well flat plate to the variable Compcells1
Culture = labware.load(
'duran_100',
slot='4') # Assigns a custom container, Duran 100 to the variable Culture
DNA = labware.load(
'tube-rack-2ml',
slot='10') # Assigns a tube rack 2ml container to the variable DNA
SOB = labware.load(
'duran_100',
slot='7') # Assigns a custom duran 100 container to the variable SOB
tempdeck = modules.load(
'tempdeck', slot='3'
) # Connects the Tempdeck module to OT2 into a slot, the slot can be shared (share = True, only needs to be done on one declaration?)
trash = robot.fixed_trash # Standard declaration of the trash area for the OT2
P300 = P300(
200, 200, [tiprack_3001, tiprack_3002]
) # Imports the P300() Function from the script OT2_Functions.py, setting the aspirate and dispense rate as well as tip racks respectively
P10 = P10(
5, 5, tiprack_10
) # Imports the P10() function fromt he script OT2_Functions.py, setting the aspirate and dispense rate as well as tip racks respectively
#########################################################################################
#########################################################################################
reagents1 = [ # Input volumes, ul, in list within a list must have no whitespaces
def final_assembly(final_assembly_dict, tiprack_num, tiprack_type="tiprack-10ul"):
"""Implements final assembly reactions using an opentrons OT-2.
Args:
final_assembly_dict (dict): Dictionary with keys and values corresponding to destination and associated linker-ligated part wells, respectively.
tiprack_num (int): Number of tipracks required during run.
"""
# Constants
CANDIDATE_TIPRACK_SLOTS = ['3', '6', '9', '2', '5', '8', '11']
PIPETTE_MOUNT = 'right'
MAG_PLATE_TYPE = '4ti-0960_FrameStar'
MAG_PLATE_POSITION = '1'
TUBE_RACK_TYPE = 'tube-rack_E1415-1500'
TUBE_RACK_POSITION = '7'
DESTINATION_PLATE_TYPE = 'aluminium-block_4ti-0960_FrameStar'
TEMPDECK_SLOT = '4'
TEMP = 20
TOTAL_VOL = 15
PART_VOL = 1.5
MIX_SETTINGS = (1, 3)
# Errors
sample_number = len(final_assembly_dict.keys())
if sample_number > 96:
raise ValueError('Final assembly nummber cannot exceed 96.')
# Tips and pipette
slots = CANDIDATE_TIPRACK_SLOTS[:tiprack_num]
tipracks = [labware.load(tiprack_type, slot)
for slot in slots]
pipette = instruments.P10_Single(mount=PIPETTE_MOUNT, tip_racks=tipracks)
# Define Labware and set temperature
magbead_plate = labware.load(MAG_PLATE_TYPE, MAG_PLATE_POSITION)
tube_rack = labware.load(TUBE_RACK_TYPE, TUBE_RACK_POSITION)
tempdeck = modules.load('tempdeck', TEMPDECK_SLOT)
destination_plate = labware.load(
DESTINATION_PLATE_TYPE, TEMPDECK_SLOT, share=True)
tempdeck.set_temperature(TEMP)
tempdeck.wait_for_temp()
# Master mix transfers
final_assembly_lens = []
for values in final_assembly_dict.values():
final_assembly_lens.append(len(values))
unique_assemblies_lens = list(set(final_assembly_lens))
master_mix_well_letters = ['A', 'B', 'C', 'D']
for x in unique_assemblies_lens:
master_mix_well = master_mix_well_letters[(x - 1) // 6] + str(x - 1)
destination_inds = [i for i, lens in enumerate(
final_assembly_lens) if lens == x]
destination_wells = np.array(
[key for key, value in list(final_assembly_dict.items())])
destination_wells = list(destination_wells[destination_inds])
pipette.pick_up_tip()
pipette.transfer(TOTAL_VOL - x * PART_VOL, tube_rack.wells(master_mix_well),
destination_plate.wells(destination_wells),
new_tip='never')
pipette.drop_tip()
# Part transfers
for key, values in list(final_assembly_dict.items()):
pipette.transfer(PART_VOL, magbead_plate.wells(values),
destination_plate.wells(key), mix_after=MIX_SETTINGS,
new_tip='always')
tempdeck.deactivate()
spacing=(9, 9),
diameter=5,
depth=15.4,
volume=200)
except:
print("Using existing labware definition for {0}".format(COLD_BLOCK))
'''
num_rxns = len(combinations_to_make)
#num_plates = math.ceil(num_rxns/24) # Amount of agar plates need for plating the transformed cells
'''
For this protocol, the biorad_96_wellplate_200ul_pcr, is placed on the top of the TempDeck alone without the Opentrons 96 well aluminum block.
'''
# Load in Bio-Rad 96 Well Plate on temp deck for moclos, transformation, and outgrowth.
temp_deck = modules.load('tempdeck', '10')
reaction_plate = labware.load('biorad_96_wellplate_200ul_pcr',
'10',
share=True)
temp_deck.set_temperature(10)
# Load in 1 10ul tiprack and 2 300ul tipracks
tr_10 = [labware.load('opentrons_96_tiprack_10ul',
'3')] #, labware.load('opentrons_96_tiprack_10ul', '6')]
tr_300 = [
labware.load('opentrons_96_tiprack_300ul', '6'),
labware.load('opentrons_96_tiprack_300ul', '9')
]
#for i in range(0, 1):
# tr_300.append(labware.load('tipone_96_tiprack_200ul', '9'))
database.delete_container('Thermic_Module')
thermic_name = 'Thermic_Module' #TODO check
if thermic_name not in labware.list():
thermic = labware.create(
thermic_name, # Labware Name
grid = (4, 4), # Amount of (columns, rows)
spacing = (9, 9), # Distances (mm) between each (column, row)
diameter = 2, # Diameter (mm) of each well on the plate
depth = 10, # Depth (mm) of each well on the plate
volume = 50)
plate_samples = labware.load('96-flat', slot ='11') # Samples TODO Eppendorf 1.5
tiprack = labware.load('tiprack-10ul', slot ='6') # Tipracks
magnetic = modules.load('magdeck', slot ='4') # Magnetic Deck
plate_magnet = labware.load('96-flat', slot ='4', share = True) # Magnetic Deck plate
thermocycler = NinjaPCR(slot='10', simulating = robot.is_simulating()) # Ninja-PCR
thermic_module = labware.load(thermic_name, slot ='1') # Auxiliar thermic module
trash = labware.load('trash-box', slot = '12', share = True) # Trash
# [2] Pipettes
pipette_l = instruments.P300_Single(mount = 'left', tip_racks=[tiprack], trash_container = trash)
pipette_r = instruments.P50_Multi(mount = 'right', tip_racks=[tiprack], trash_container = trash)
pipette_l.set_flow_rate(aspirate = 50, dispense = 100)
pipette_r.set_flow_rate(aspirate = 50, dispense = 100)
# [3] Commands
def execute_move(function, args):
from opentrons import labware, instruments, modules
metadata = {
'protocolName': 'SPRI bead cleanups',
'author': 'James Kitson',
}
magdeck = modules.load('magdeck', '7')
tips50 = labware.load('tiprack-starlab-S1120-2810', '1')
pipette = instruments.P50_Single(mount='left', tip_racks=[tips50])
plate = labware.load('starlab-E1403-5200', '7', share=True)
plate2 = labware.load('starlab-E1403-5200', '9')
pipette.pick_up_tip()
pipette.transfer(10, plate2['A1'], plate2['A2'])
pipette.transfer(10, plate2['A1'], plate['A2'])
magdeck.engage(height=18)
pipette.delay(5)
magdeck.disengage()
magdeck.engage(height=16)
pipette.delay(5)
magdeck.disengage()
magdeck.engage(height=17)
pipette.delay(10)
magdeck.disengage()
magdeck.engage(height=18)
# instanciate pre-defined labware
trough = labware.load('trough-12row', '2', 'trough')
fresh_plate = labware.load(plate_name, '3', 'fresh plate')
# instanciate tip rack in remaining slots
tips = [
labware.load('opentrons-tiprack-300ul', str(slot))
for slot in range(5, 10)
]
print('-' * 50)
print('Make sure the `tips` make sense!')
print(tips)
print('-' * 50)
# load additional modules
magdeck = modules.load('magdeck', '1')
sample_plate = labware.load(plate_name, '1', share=True)
tempdeck = modules.load('tempdeck', '4')
tempdeck.set_temperature(25)
# load pipette
m300 = instruments.P300_Multi(mount='right', tip_racks=tips)
# In[6]:
# here some volumes seem to be "capped" to 300 while
# some volumes in the BOMB protocol are larger than 300
# Shall we use the BOMB protocol values ? When using m300.transfer()
# the robot (surprisingly) knows how to split the large volume to
# avoid flooding the pipette.
def load_deck(deck_plan='default', **kwarg):
"""
load deck_plan. create global variables for loaded labwares.
createa global variable deck_plan_: dictionary, slot number '1'/'2' : labware variable
can use deck_plan_['1'] to refer to labware loaded on the deck.
current deck plans:
1).default : 1/3:elisa strip; 2:trough; 4:15-50ml rack; 5:ep rack; 9:trash"
2).default-1ml-plate 1.1mlPPplate 3:elisa strip; 2:trough; 4:15-50ml rack; 5:ep rack; 9:trash"
2).default-5ml : 1/3:elisa strip; 2:trough; *4:5ml-50ml rack*; 5:ep rack; 9:trash"
3).default-mag : *1:magnet*; 2:trough; 3:elisa strip; 4:15-50ml rack; 5:ep rack; 9:trash'
"""
if deck_plan == 'default':
global trough, liquid_trash, tip_rack, single_tip_rack, elisa_strip, ep_rack, tube_rack, multi_pipette, single_pipette, elisa_strip_2
initialize(**kwarg)
elisa_strip_2 = labware.load('elisa_strip', '1')
trough = labware.load('trough-12row', '2')
liquid_trash = labware.load('trough-12row', '9')
tip_rack = [labware.load('tiprack-200ul', slot) for slot in ['7', '8']]
single_tip_rack = [
labware.load('tiprack-200ul', slot) for slot in ['10', '11']
]
elisa_strip = labware.load('elisa_strip', '3')
ep_rack = labware.load('tube-rack-eppendorf', '5')
tube_rack = labware.load('tube-rack-15_50ml_apt', '4')
deck_plan_.update([('5', ep_rack), ('4', tube_rack),
('1', elisa_strip_2), ('2', trough),
('3', elisa_strip), ('9', liquid_trash)])
multi_pipette = instruments.P300_Multi(mount='left',
tip_racks=tip_rack)
single_pipette = instruments.P300_Single(mount='right',
tip_racks=single_tip_rack)
elif deck_plan == 'default-1ml-plate':
initialize(**kwarg)
pp_plate = labware.load('ams_1ml_pp_plate', '1')
trough = labware.load('trough-12row', '2')
liquid_trash = labware.load('trough-12row', '9')
tip_rack = [labware.load('tiprack-200ul', slot) for slot in ['7', '8']]
single_tip_rack = [
labware.load('tiprack-200ul', slot) for slot in ['10', '11']
]
elisa_strip = labware.load('elisa_strip', '3')
ep_rack = labware.load('tube-rack-eppendorf', '5')
tube_rack = labware.load('tube-rack-15_50ml_apt', '4')
deck_plan_.update([('5', ep_rack), ('4', tube_rack), ('1', pp_plate),
('2', trough), ('3', elisa_strip),
('9', liquid_trash)])
multi_pipette = instruments.P300_Multi(mount='left',
tip_racks=tip_rack)
single_pipette = instruments.P300_Single(mount='right',
tip_racks=single_tip_rack)
elif deck_plan == 'default-mag':
kwarg['magnet'] = True
initialize(**kwarg)
global mag_deck, mag_plate
mag_deck = modules.load('magdeck', '1')
mag_plate = labware.load('pp_plate_mag', '1', share=True)
trough = labware.load('trough-12row', '2')
liquid_trash = labware.load('trough-12row', '9')
tip_rack = [labware.load('tiprack-200ul', slot) for slot in ['7', '8']]
single_tip_rack = [
labware.load('tiprack-200ul', slot) for slot in ['10', '11']
]
elisa_strip = labware.load('elisa_strip', '3')
ep_rack = labware.load('tube-rack-eppendorf', '5')
tube_rack = labware.load('tube-rack-15_50ml_apt', '4')
deck_plan_.update([('5', ep_rack), ('4', tube_rack), ('1', mag_plate),
('2', trough), ('3', elisa_strip),
('9', liquid_trash)])
multi_pipette = instruments.P300_Multi(mount='left',
tip_racks=tip_rack)
single_pipette = instruments.P300_Single(mount='right',
tip_racks=single_tip_rack)
elif deck_plan == 'default-5ml':
initialize(**kwarg)
elisa_strip_2 = labware.load('elisa_strip', '1')
trough = labware.load('trough-12row', '2')
liquid_trash = labware.load('trough-12row', '9')
tip_rack = [labware.load('tiprack-200ul', slot) for slot in ['7', '8']]
single_tip_rack = [
labware.load('tiprack-200ul', slot) for slot in ['10', '11']
]
elisa_strip = labware.load('elisa_strip', '3')
ep_rack = labware.load('tube-rack-eppendorf', '5')
tube_rack = labware.load('ep_5ml_tube_rack', '4')
deck_plan_.update([('5', ep_rack), ('4', tube_rack),
('1', elisa_strip_2), ('2', trough),
('3', elisa_strip), ('9', liquid_trash)])
multi_pipette = instruments.P300_Multi(mount='left',
tip_racks=tip_rack)
single_pipette = instruments.P300_Single(mount='right',
tip_racks=single_tip_rack)
else:
pass
return well_list
# In[10]:
coordinates = order_json(coordinates)
# ### Defining labware
# In[11]:
tip_rack = labware.load('opentrons_96_tiprack_300ul', '8')
tip_rack2 = labware.load('opentrons_96_tiprack_300ul', '9')
liquid = labware.load('usascientific_96_wellplate_2.4ml_deep', slot='7')
plate_shake = labware.load('usascientific_96_wellplate_2.4ml_deep', slot='3')
magdeck = modules.load('magdeck', 10)
plate_mag = labware.load('usascientific_96_wellplate_2.4ml_deep',
slot='10',
share=True)
final_plate = labware.load('usascientific_96_wellplate_2.4ml_deep', slot='11')
p300 = instruments.P300_Single(mount='left',
tip_racks=[tip_rack, tip_rack2],
aspirate_flow_rate=75)
# ### Shaker command list
# In[15]:
#########################Activate Shaker Module#######################
import serial
import time
#deepwell = 'deepwell-plate-96'
#if deepwell not in labware.list():
#deepwell = labware.create(
#deepwell,
#grid=(12, 8),
#spacing=(9, 9),
#diameter=5,
#depth=20,
#volume=350,
#)
#module placements
enzrack = labware.load('coolrack-96', 5)
trough = labware.load('trough-12row', 1)
magmodule = modules.load('magdeck', 4)
magplate = labware.load('biorad-hardshell-96-PCR', 4, share=True)
#deepwell = labware.load('deepwell-plate-96', 4, share=True)
p200rack = labware.load('tiprack-200ul', 3)
p200rack2 = labware.load('tiprack-200ul', 6)
p200rack3 = labware.load('tiprack-200ul', 9)
p200rack4 = labware.load('tiprack-200ul', 8)
#enzrack = labware.load('opentrons-aluminum-block-PCR-strips-200ul', 5)
tempmodule = modules.load('tempdeck', 7)
tempplate = labware.load('alum-block-pcr-strips', 7, share=True)
#set spri size selection parameters, set truncated debug times and values
if debug == 1:
spri_incubation_time = 1 #min
spacing=(9, 9),
diameter=5.5,
depth=20.2)
temp_plate_name = 'aluminum-block-framestar-96-semi-skited-PCR'
if temp_plate_name not in labware.list():
labware.create(temp_plate_name,
grid=(12, 8),
spacing=(9, 9),
diameter=5.5,
depth=20.2)
# labware setup
reagent_plate = labware.load('PCR-strip-tall', '1')
trough = labware.load('trough-12row', '2')
mag_module = modules.load('magdeck', '4')
mag_plate = labware.load(mag_plate_name, '4', share=True)
temp_module = modules.load('tempdeck', '7')
temp_plate = labware.load(temp_plate_name, '7', share=True)
tipracks_10 = [labware.load('tiprack-10ul', slot) for slot in ['3', '6', '9']]
tipracks_300 = [
labware.load('tiprack-200ul', slot) for slot in ['5', '8', '10', '11']
]
# instruments setup
m10 = instruments.P10_Multi(mount='left', tip_racks=tipracks_10)
m300 = instruments.P300_Multi(mount='right', tip_racks=tipracks_300)
# reagent setup
ampure_xp_beads = trough.wells('A1')
def run_custom_protocol(number_of_mixing: int = 10, mix_rate: int = 1):
# LABWARE
tempdeck = modules.load('tempdeck', 10)
tube_rack_2ml = labware.load('opentrons-aluminum-block-2ml-eppendorf', '7')
tube_rack_15ml = labware.load('opentrons-tuberack-15_50ml', '3')
small_reagent_plate = labware.load('PCR-strip-tall', '8')
pcr_plate1 = labware.load('96-flat', '4')
pcr_plate2 = labware.load('96-flat', '5')
pcr_plate3 = labware.load('opentrons-aluminum-block-96-PCR-plate',
'10',
share=True)
plates = [pcr_plate1, pcr_plate2, pcr_plate3]
tiprack1 = labware.load('opentrons-tiprack-300ul', '11')
tiprack2 = labware.load('opentrons-tiprack-300ul', '9')
tiprack2_tracker = TipTracker(tiprack=tiprack2)
WELLS = 370
TOTAL_VOL = 20.0
CDNA_VOL = 5.0
WATER_PER_WELL = 12.115 - CDNA_VOL
assert WATER_PER_WELL >= 0, "Water per well is less than 0"
TREH_PER_WELL = 4.0
BUFFER_PER_WELL = 2
FORM_PER_WELL = 0.5
DNTP_PER_WELL = 0.16
SYBR_PER_WELL = 0.1
TAQ_PER_WELL = 0.125
PRIMER_MIX_PER_WELL = 1.0
FORMAMIDE_VOL = FORM_PER_WELL * WELLS
DNTP_VOL = DNTP_PER_WELL * WELLS
SYBR_VOL = SYBR_PER_WELL * WELLS
TAQ_VOL = TAQ_PER_WELL * WELLS
MASTER_MIX_TUBE_WELLS = 38.0
MASTER_MIX_TUBE_VOL = (WATER_PER_WELL + TREH_PER_WELL + BUFFER_PER_WELL +
FORM_PER_WELL + DNTP_PER_WELL + SYBR_PER_WELL +
TAQ_PER_WELL) * MASTER_MIX_TUBE_WELLS
PRIMER_VOL = PRIMER_MIX_PER_WELL * MASTER_MIX_TUBE_WELLS
MASTER_MIX_VOL = TOTAL_VOL - CDNA_VOL
# Define Pipettes
p300_single = instruments.P300_Single(mount='right', tip_racks=[tiprack1])
p50_multi = instruments.P50_Multi(mount='left', tip_racks=[tiprack2])
# Define master mix reagents
formamide = tube_rack_2ml.wells('A1')
dntp = small_reagent_plate.wells('A1')
sybr = small_reagent_plate.wells('B1')
taq = small_reagent_plate.wells('C1')
primers = [
well.bottom() for well in small_reagent_plate.wells(
'A3', 'A4', 'A5', 'C3', 'C4', 'C5', 'E3', 'E4', 'E5')
]
# cDNA
standards = small_reagent_plate.columns('12')
samples = small_reagent_plate.columns('10')
# Initial buffer mix in tube (1413.8 uL)
buffer_mix_tube = tube_rack_15ml.wells(
'A1') # Water, Trehalose, qPCR Buffer
high_vol_buffer_mix_tube = (buffer_mix_tube,
buffer_mix_tube.from_center(x=0, y=0, z=-0.5))
# Separate master mix tubes for each primer
master_mix_tubes = [
well.bottom() for well in tube_rack_2ml.wells(
'A3', 'A4', 'A5', 'B3', 'B4', 'B5', 'C3', 'C4', 'C5')
]
sample_columns = ['1', '2', '3', '5', '6', '7', '9', '10', '11']
standard_columns = ['4', '8', '12']
######################## PROTOCOL ##################################################################################
tempdeck.set_temperature(4)
# Make master mix
p300_single.distribute(FORMAMIDE_VOL,
formamide,
high_vol_buffer_mix_tube,
disposal_vol=0,
blow_out=True)
p300_single.distribute(DNTP_VOL,
dntp,
high_vol_buffer_mix_tube,
disposal_vol=0,
blow_out=True)
p300_single.distribute(SYBR_VOL,
sybr,
high_vol_buffer_mix_tube,
disposal_vol=0,
blow_out=True)
# Add taq last and mix
p300_single.pick_up_tip()
p300_single.transfer(TAQ_VOL,
taq,
high_vol_buffer_mix_tube,
disposal_vol=0,
blow_out=True,
new_tip='never')
p300_single.mix(15, 300, rate=mix_rate, location=high_vol_buffer_mix_tube)
p300_single.drop_tip()
# Distribute master mix to separate master mix tubes
p300_single.distribute(MASTER_MIX_TUBE_VOL,
buffer_mix_tube,
master_mix_tubes,
disposal_vol=0,
blow_out=True)
# Add primers to master mix tubes
for primer, mm_tube in zip(primers, master_mix_tubes):
p50_multi.pick_up_tip(location=tiprack2_tracker.next_tip(), presses=1)
p50_multi.transfer(PRIMER_VOL,
primer,
mm_tube,
disposal_vol=0,
blow_out=True,
new_tip='never')
p50_multi.mix(number_of_mixing, 50, rate=mix_rate)
p50_multi.drop_tip()
def multiwell_location_offset(plates,
x=0.0,
y=0.0,
z=0.0,
start_column=None,
end_column=None,
columns=None):
from opentrons.legacy_api.containers.placeable import Container
if isinstance(plates, Container):
plates = list(plates)
if columns is not None:
return [(col[0], col[0].from_center(x=x, y=y, z=z))
for plate in plates for col in plate.columns(columns)]
elif start_column and end_column:
return [(col[0], col[0].from_center(x=x, y=y, z=z))
for plate in plates
for col in plate.columns(start_column, to=end_column)]
# Mix cDNA samples then distribute to 96-well plates
p50_multi.pick_up_tip(location=tiprack2_tracker.next_tip(n=8))
p50_multi.mix(number_of_mixing, 50, samples, rate=mix_rate)
p50_multi.distribute(CDNA_VOL,
samples,
multiwell_location_offset(x=0,
y=0.03,
z=-1.5,
plates=plates,
columns=sample_columns),
disposal_vol=3,
new_tips='never')
# Mix Standards then distribute to 96-well plates
p50_multi.pick_up_tip(location=tiprack2_tracker.next_tip(n=8))
p50_multi.mix(number_of_mixing, 50, standards, rate=mix_rate)
p50_multi.distribute(CDNA_VOL,
standards,
multiwell_location_offset(x=0,
y=0.03,
z=-1.5,
plates=plates,
columns=standard_columns),
disposal_vol=3,
new_tips='never')
plates = []
plates.extend([pcr_plate1] * 3)
plates.extend([pcr_plate2] * 3)
plates.extend([pcr_plate3] * 3)
for master_mix, column in zip(master_mix_tubes,
list(range(1, 12 + 1, 4)) * 3):
first_column = str(column)
last_column = str(column + 3)
p50_multi.pick_up_tip(location=tiprack2_tracker.next_tip(), presses=1)
p50_multi.distribute(MASTER_MIX_VOL,
master_mix,
multiwell_location_offset(
x=0,
y=0.1,
z=0.5,
plates=plates,
start_column=first_column,
end_column=last_column),
disposal_vol=0,
blow_out=True)
def createMasterMix():
if manually_make_master_mix:
note_liquid(location=master_mix,
name='Master Mix',
initially=master_mix_vol)
log('Creating Master Mix')
info(
pretty.format(
'Master Mix recipe: water={0:n} buffer={1:n} EvaGreen={2:n}',
master_mix_common_water_vol, master_mix_buffer_vol,
master_mix_evagreen_vol))
user_prompt('Ensure master mix manually present and mixed')
else:
# Mostly just for fun, we put the ingredients for the master mix in a nice warm place to help them melt
temp_slot = 11
temp_module = modules.load('tempdeck', slot=temp_slot)
screwcap_rack = labware_manager.load(
'opentrons_24_aluminumblock_generic_2ml_screwcap',
slot=temp_slot,
label='screwcap_rack',
share=True,
well_geometry=IdtTubeWellGeometryV1)
buffers = list(zip(screwcap_rack.rows(0), buffer_volumes))
evagreens = list(zip(screwcap_rack.rows(1), evagreen_volumes))
for buffer in buffers:
note_liquid(location=buffer[0],
name='Buffer',
initially=buffer[1],
concentration='5x')
for evagreen in evagreens:
note_liquid(location=evagreen[0],
name='Evagreen',
initially=evagreen[1],
concentration='20x')
note_liquid(location=master_mix, name='Master Mix')
# Buffer was just unfrozen. Mix to ensure uniformity. EvaGreen doesn't freeze, no need to mix
p50.layered_mix([buffer for buffer, __ in buffers], incr=2)
# transfer from multiple source wells, each with a current defined volume
def transfer_multiple(msg, xfer_vol_remaining, tubes, dest, new_tip,
*args, **kwargs):
tube_index = 0
cur_well = None
cur_vol = 0
min_vol = 0
while xfer_vol_remaining > 0:
if xfer_vol_remaining < p50_min_vol:
warn("remaining transfer volume of %f too small; ignored" %
xfer_vol_remaining)
return
# advance to next tube if there's not enough in this tube
while cur_well is None or cur_vol <= min_vol:
if tube_index >= len(tubes):
fatal('%s: more reagent needed' % msg)
cur_well = tubes[tube_index][0]
cur_vol = tubes[tube_index][1]
min_vol = max(
p50_min_vol,
cur_vol / config.
min_aspirate_factor_hack, # tolerance is proportional to specification of volume. can probably make better guess
cur_well.geometry.min_aspiratable_volume)
tube_index = tube_index + 1
this_vol = min(xfer_vol_remaining, cur_vol - min_vol)
assert this_vol >= p50_min_vol # TODO: is this always the case?
log('%s: xfer %f from %s in %s to %s in %s' %
(msg, this_vol, cur_well, cur_well.parent, dest,
dest.parent))
p50.transfer(this_vol,
cur_well,
dest,
trash=config.trash_control,
new_tip=new_tip,
**kwargs)
xfer_vol_remaining -= this_vol
cur_vol -= this_vol
def mix_master_mix():
log('Mixing Master Mix')
p50.layered_mix(
[master_mix],
incr=2,
initial_turnover=master_mix_evagreen_vol * 1.2,
max_tip_cycles=config.layered_mix.max_tip_cycles_large)
log('Creating Master Mix: Water')
p50.transfer(master_mix_common_water_vol,
waterB,
master_mix,
trash=config.trash_control)
log('Creating Master Mix: Buffer')
transfer_multiple(
'Creating Master Mix: Buffer',
master_mix_buffer_vol,
buffers,
master_mix,
new_tip='once',
keep_last_tip=True
) # 'once' because we've only got water & buffer in context
p50.done_tip() # EvaGreen needs a new tip
log('Creating Master Mix: EvaGreen')
transfer_multiple(
'Creating Master Mix: EvaGreen',
master_mix_evagreen_vol,
evagreens,
master_mix,
new_tip='always',
keep_last_tip=True
) # 'always' to avoid contaminating the Evagreen source w/ buffer
mix_master_mix()
AGAR_PLATE_SLOT = '1'
# Tiprack slots
p10_p300_tiprack_slots = tiprack_slots(spotting_tuples)
p10_slots = CANDIDATE_P10_SLOTS[:p10_p300_tiprack_slots[0]]
p300_slots = CANDIDATE_P300_SLOTS[:p10_p300_tiprack_slots[1]]
# Define labware
p10_tipracks = [labware.load(P10_TIPRACK_TYPE, slot) for slot in p10_slots]
p300_tipracks = [labware.load(P300_TIPRACK_TYPE, slot) for slot in p300_slots]
p10_pipette = instruments.P10_Single(mount=P10_MOUNT, tip_racks=p10_tipracks)
p300_pipette = instruments.P300_Multi(mount=P300_MOUNT,
tip_racks=p300_tipracks)
assembly_plate = labware.load(ASSEMBLY_PLATE_TYPE, ASSEMBLY_PLATE_SLOT)
tempdeck = modules.load('tempdeck', TEMPDECK_SLOT)
transformation_plate = labware.load(TRANSFORMATION_PLATE_TYPE,
TEMPDECK_SLOT,
share=True)
soc_plate = labware.load(SOC_PLATE_TYPE, SOC_PLATE_SLOT)
tube_rack = labware.load(TUBE_RACK_TYPE, TUBE_RACK_SLOT)
spotting_waste = tube_rack.wells(SPOTTING_WASTE_WELL)
agar_plate = labware.load(AGAR_PLATE_TYPE, AGAR_PLATE_SLOT)
# Register agar_plate for calibration
p10_pipette.transfer(1,
agar_plate.wells('A1'),
agar_plate.wells('H12'),
trash=False)
p10_pipette.start_at_tip(p10_tipracks[0][0])
"Mount": "left",
"Rack": "11"
},
"Plate": {
"Position": "9"
},
"Tube_rack": {
"Position": "4"
},
"Temp_module": {
"Position": "8"
},
}
# Labware:
tempdeck = modules.load("tempdeck", master_settings['Temp_module']["Position"])
hotplate = labware.load("opentrons_24_aluminumblock_generic_2ml_screwcap",
master_settings['Temp_module']["Position"],
share=True)
sample_plate = labware.load("4ti-0960_FrameStar",
master_settings["Plate"]["Position"])
p10_tip_rack = labware.load("opentrons_96_tiprack_10ul",
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"],
#Author(s): Matt Burridge
#Last modified: 19:43, 12/10/18
#Python 3.6.4
#Please keep the author(s) attached to the code segment for traceability, if changes are made please append the authour list and modify the timestamp
#####################################################################################################################################
#The input from the code must be in list within a list, the sublist must contain the appropriate float type value and no whitespaces
from opentrons import labware, robot, instruments, modules # Import all opentrons API
from sqlite3 import IntegrityError # Import sqlite3 for custom container support
#####################################################################################################################################
#####################################################################################################################################
# LOADED LABWARE
TempDeck = modules.load('tempdeck', '6') # Loads TempDeck
Tiprack10uL = labware.load('tiprack-10ul', '11')
Tiprack300uL = labware.load('opentrons-tiprack-300ul', '9')
Compcells = labware.load('96-flat', '6', "compcells1",
share=True) # Competent Cells
trash = robot.fixed_trash
DNA = labware.load('tube-rack-2ml', '10') # Plasmid/DNA wanted to transform
SOB = labware.load(
'duran_100',
'7') # Recovery media, SOB strongly recommended for E. coli DH5a
#####################################################################################################################################
#####################################################################################################################################
# LOADED PIPETTES
# CAN CHANGE IF NEEDED
# imports
from opentrons import robot, labware, instruments, modules
# modules
temp_controller = modules.load('tempdeck', '10')
temp_controller.set_temperature(4)
# labware
tiprack_type = 'tiprack-200ul-VWR'
tiprack_p50s = [
labware.load(tiprack_type, slot_p50s)
for slot_p50s in ['1', '2', '3', '6']
]
tiprack_p300s = [
labware.load(tiprack_type, slot_p300s) for slot_p300s in ['9']
]
rxn_plate = labware.load('384-corning-3702BC', '8')
nitrilase_samples = labware.load('opentrons-aluminum-block-2ml-eppendorf',
'10',
share=True)
reagent_rack = labware.load('opentrons-tuberack-15_50ml', '11')
substrate_rack = labware.load('opentrons-tuberack-2ml-eppendorf', '7')
ammonium_chloride = labware.load('opentrons-tuberack-15ml', '4')
liquid_trash = reagent_rack.wells('C1')
liquid_trash_2 = reagent_rack.wells('C2')
# instruments
p50s = instruments.P50_Single(mount="right", tip_racks=tiprack_p50s)
if tiprack_type == 'tiprack-200ul-VWR':
p300s = instruments.P300_Single(mount="left",
tip_racks=tiprack_p300s,
depth = 41,
volume = 1500)
if "eppendorf_rack" not in labware.list():
labware.create(
"eppendorf_rack",
grid=(12,8),
spacing=(9,9),
diameter=5,
depth=30,
volume=50)
modules.magdeck.LABWARE_ENGAGE_HEIGHT[magdeck_plate] = 10
# MagDeck and associated labware
magdeck = modules.load('MagDeck', slot=4)
md_lab = labware.load(magdeck_plate, slot=4, share=True)
# Thermal module. SHOULD REMAIN AT 4ºC DURING THE WHOLE PROTOCOL. TODO
tempdeck = NinjaTempDeck(slot=1, simulating = True)
td_lab = tempdeck.labware
# Thermocycler.
thermocycler = NinjaPCR(slot=10, simulating = robot.is_simulating())
tc_lab = thermocycler.labware
samples = labware.load('Eppendorf_Samples', slot=8)
tiprack = labware.load('opentrons-tiprack-300ul', slot=6)
tiprack2 = labware.load('opentrons-tiprack-300ul', slot=3)
liquid_trash = labware.load('corning_384_wellplate_112ul_flat', slot = 5)
#primers = labware.load('eppendorf_rack', slot=2)
diameter=81, # diameter (mm) of each well on the plate
depth=35, # depth (mm) of each well on the plate
volume=350000)
#### LABWARE SETUP ####
temp_deck_1 = tempdeck.TempDeck()
temp_deck_2 = tempdeck.TempDeck()
temp_deck_1._port = '/dev/ttyACM0'
temp_deck_2._port = '/dev/ttyACM1'
if not robot.is_simulating():
temp_deck_1.connect()
temp_deck_2.connect()
temp_deck1 = modules.load('tempdeck', '4')
Cold_plate = labware.load('biorad-hardshell-96-PCR', '4', share=True)
# trough = labware.load('trough-12row', '2')
# Trash = labware.load('One-Column-reservoir','3')
temp_deck2 = modules.load('tempdeck', '10')
temp_plate = labware.load('1ml_Covaris', '10', share=True)
#mag_deck = modules.load('magdeck', '7')
#mag_plate = labware.load('biorad-hardshell-96-PCR', '7', share=True)
tipracks_10 = [
labware.load('tiprack-10ul', slot, share=True) for slot in ['8', '5']
]
tipracks_200 = [
labware.load('tiprack-200ul', slot, share=True) for slot in ['9', '11']
]
from opentrons import robot, instruments, labware, modules
available_deck_slots = ['1', '2', '3', '4', '5', '6', '8', '9']
tip_racks = [labware.load('tiprack-200ul', available_deck_slots.pop(), 'tiprack-200ul') for x in range(0, 4)]
p300 = instruments.P300_Multi(mount='left', tip_racks=tip_racks)
mag = modules.load("magdeck", "10", share=True)
samples = labware.load('96-deep-well', "10", 'samples', share=True)
dest_plate = labware.load("96-PCR-tall", "11", "destination plate")
buffers = labware.load("trough-12row", "7", "buffers")
etr_mag = [buffers.wells(0), buffers.wells(1)]
etr = [buffers.wells(2), buffers.wells(3)]
vhb = [buffers.wells(4), buffers.wells(5), buffers.wells(6), buffers.wells(7)]
spm = [buffers.wells(8), buffers.wells(9)]
eb = buffers.wells(10)
#Add 500 無 ETR and 20 無 Mag-Bind
p300.transfer(520, etr_mag.bottom(0.5),
#Wait 5 min
#Magnetize and discard supernatant
#Demagnetize and add 500 無 ETR
#Magnetize and discard supernatant
#Demagnetize and add 700 無 VHB
#Magnetize and discard supernatant
#Demagnetize and add 700 無 VHB
#Magnetize and discard supernatant
#Demagnetize and aAdd 700 無 SPM
#Magnetize and discard supernatant
#Wait 1 min
from opentrons import labware, instruments, modules
metadata = {
'protocolName': 'SPRI Bead Normalisation and size selection',
'author': 'Kitson, James J., Byrne, Justin G. D. '
}
mag_deck = modules.load('magdeck', '10')
mag_plate = labware.load('starlab-E1403-5200', '10', share=True)
ethanol_plate = labware.load('starlab-E2896-0220', '4')
elution_buffer = labware.load('starlab-E2896-0220', '1')
#output_plate = labware.load('starlab-E1403-0100', '6')
elution_tube = labware.load('opentrons_24_tuberack_generic_2ml_screwcap', '6')
# add an empty p1000 box as a waste bucket
waste_plate = labware.load('trash-starlab-S1182-1830', '8')
# define a pipetting location for the waste_plate
waste = waste_plate.wells('A6').top(-30)
# Define reagents locations in a loop Or maybe can be done more simply
# Ethanol Location
ethanol = ethanol_plate.wells('A7', 'A8', 'A9')
# Elution buffer needs to be done in the same way
tris = elution_buffer.wells('A11').bottom(4)
metadata = {
'protocolName': 'Extraction_DNA_RNA',
'author': 'Jacob Agerbo Rasmussen <*****@*****.**>',
'version': '1.0',
'date': '2019/03/28',
'description': 'Automation of Zymo Quick DNA protocol for stool samples in SHIELD',
}
#### LABWARE SETUP ####
elution_plate_DNA = labware.load('96-flat', '3')
trough = labware.load('trough-12row', '2')
buffer = labware.load('opentrons-tuberack-50ml', '8')
trash_box = labware.load('trash-box', '1')
mag_deck = modules.load('magdeck', '7')
sample_plate = labware.load('96-deep-well', '7', share=True)
temp_deck = modules.load('tempdeck', '10')
tipracks_200 = [labware.load('tiprack-200ul', slot)
for slot in ['4','5','6','11']]
tipracks_1000 = [labware.load('tiprack-1000ul', slot, share=True)
for slot in ['9']]
#### PIPETTE SETUP ####
s1000 = instruments.P1000_Single(
mount='right',
tip_racks=tipracks_1000)
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()
# Match temp deck with serial number:
# Only two provided serial number are checked, update if more temp modules need to be loaded
for deck in temp_decks:
if deck.device_info == cold_deck_ID:
cold_deck = deck
elif deck.device_info == hot_deck_ID:
hot_deck = deck
else:
print("Fatal error: Unknown serial number. Terminating...")
exit(1)
# Disconnect temp decks if simulating. Otherwise decks will start running when the opentrons app runs simulation to check script integrity
if robot.is_simulating():
cold_deck.disconnect()
hot_deck.disconnect()
# Now you can use hot_deck and cold_deck to control temprature of your deck
# However, you still need to load modules using their standard api:
# This is because the objects constructed by `modules.load('tempdeck')` and 'tempdeck.TempDeck()' belong to two different classes and they each support different part of functions required in this kind of scenario. You have to use hot_deck for any functions related to temp (set, wait, etc) and load hotDeck so that the robot knows there is a module loaded at this position (it will presumably adjust how deep pipettes go down at these locations as plates are elevated by modules)
hotDeck = modules.load('tempdeck', 4)
coldDeck = modules.load(
'tempdeck', 7) # Or the positions they are in respectively on the deck
# Use cold_deck and hot_deck to set temp:
cold_deck.set_temprature(10)
hot_deck.set_temprature(60)
cold_deck.wait_for_temp()
hot_deck.wait_for_temp()
