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()