예제 #1
0
    def performOpen(self, options={}):
        """Perform the operation of opening the instrument connection"""
        # timeout
        self.timeout_ms = int(1000 * self.dComCfg['Timeout'])
        # get PXI chassis
        self.chassis = int(self.comCfg.address)
        # auto-scan chassis address
        n_unit = keysightSD1.SD_Module.moduleCount()
        all_chassis = [
            keysightSD1.SD_Module.getChassisByIndex(n) for n in range(n_unit)
        ]
        # check if user-given chassis is available
        if n_unit > 0 and self.chassis not in all_chassis:
            # if all units are in the same chassis, override given PXI chassis
            if np.all(np.array(all_chassis) == all_chassis[0]):
                self.chassis = all_chassis[0]

        # number of slots in chassis
        self.n_slot = 18
        # supported AWGs and Digitizers
        self.AWGS = ['M3201', 'M3202', 'M3300', 'M3302']
        self.DIGS = ['M3100', 'M3102']
        # keep track of current PXI configuration
        # 0: None, 1: AWG, 2: Digitizer
        self.units = [0] * self.n_slot
        self.old_trig_period = -1.0
        self.old_dig_delay = -1.0

        # Create HVI object
        self.HVI = keysightSD1.SD_HVI()
예제 #2
0
 def __init__(self, init=1):
     self.SLOT_NUM = {"CHASSIS": 1,
                      "AWG1": 2,          # M3202A AWG1
                      "AWG2": 3,          # M3202A AWG2
                      "DIG": 4,           # M3102A Digitizer
                      "MARK1": 5,         # M3201A Marker1
                      "MARK2": 6}         # M3201A Marker1
                      
     if init == 1:
         self.AWG1 = keysightSD1.SD_AOU()
         AWG1_ID = self.AWG1.openWithSlot("", self.SLOT_NUM["CHASSIS"], 
                                          self.SLOT_NUM["AWG1"])
         if AWG1_ID < 0:
             raise NameError('Cannot find AWG1')
         self.MARK1 =  keysightSD1.SD_AOU()
         MARK1_ID = self.MARK1.openWithSlot("", self.SLOT_NUM["CHASSIS"], 
                                            self.SLOT_NUM["MARK1"])
         if MARK1_ID < 0:
             raise NameError('Cannot find MARK1')           
     else:
         raise NameError('Plz fix the code')
     
     self.Digitizer = keysightSD1.SD_AIN()
     Digitizer_ID = self.Digitizer.openWithSlot("", self.SLOT_NUM["CHASSIS"], 
                                                self.SLOT_NUM["DIG"])    
     if Digitizer_ID < 0:
         raise NameError('Cannot find Digitizer')
     
     self.HVI = keysightSD1.SD_HVI()
def load_HVI_2(AWGs, channel_map, *args,**kwargs):
	"""
	load a HVI file on the AWG.
	Args:
		AWGS (dict <str, QCoDeS Intrument>) : key is AWGname, value awg object. 
		channel_map (dict <str, (tuple <str, int>)) : key is channelname, value is AWGname, channel number
	Returns:
		HVI (SD_HVI) : keyisight HVI object.	
	"""
	for channel, channel_loc in channel_map.items():
		# 6 is the magic number of the arbitary waveform shape.
		AWGs[channel_loc[0]].awg_stop(channel_loc[1])
		AWGs[channel_loc[0]].set_channel_wave_shape(keysightSD1.SD_Waveshapes.AOU_AWG,channel_loc[1])
		AWGs[channel_loc[0]].awg_queue_config(channel_loc[1], 1)

			
	HVI = keysightSD1.SD_HVI()
	error = HVI.open(ct.__file__[:-11] + "HVI_single_shot_2qubit_m6.HVI")
	print(error)

	error = HVI.assignHardwareWithUserNameAndSlot("Module 0",1,2)
	print(error)
	error = HVI.assignHardwareWithUserNameAndSlot("Module 1",1,3)
	print(error)
	error = HVI.assignHardwareWithUserNameAndSlot("Module 2",1,4)
	print(error)
	error = HVI.assignHardwareWithUserNameAndSlot("Module 3",1,5)
	print(error)
	error = HVI.assignHardwareWithUserNameAndSlot("Module 4",1,6)
	print(error)
	error = HVI.assignHardwareWithUserNameAndSlot("Module 5",1,7)
	print(error)
	error = HVI.assignHardwareWithUserNameAndSlot("Module 6",1,8)
	print(error)

	error = HVI.compile()
	print(error)
	error = HVI.load()
	print(error)
	error = HVI.load()
	print(error)
	

	error = HVI.start()
	print(error)

	return HVI
예제 #4
0
def configureHvi():
    config.hvi.handle = key.SD_HVI()
    hvi = config.hvi.handle
    log.info("Opening HVI file: {}".format(config.hvi.file_name))
    hviID = hvi.open(config.hvi.file_name)
    if hviID == key.SD_Error.RESOURCE_NOT_READY:  #Only for old library
        log.debug("No Critical Error - {}: {}".format(
            hviID, key.SD_Error.getErrorMessage(hviID)))
        log.debug("Using old library -> Need to compile HVI...")
    elif hviID == key.SD_Error.DEMO_MODULE:  #Only for old library
        log.debug("No Critical Error - {} {}".format(
            hviID, key.SD_Error.getErrorMessage(hviID)))
        log.debug("Using old library -> need to assigning HW modules...")
    elif hviID < 0:
        log.error("Opening HVI - {}: {}".format(
            hviID, key.SD_Error.getErrorMessage(hviID)))

    for hviModule in config.hvi.hviModules:
        #Find the handle for this module from its slot
        for module in config.modules:
            if module.slot == hviModule.slot:
                hviModule.handle = module.handle
                log.info("Assigning {} to {} in slot {}".format(
                    hviModule.name, module.model, module.slot))
                error = hvi.assignHardwareWithUserNameAndModuleID(
                    hviModule.name, module.handle)
                if error == -8069:
                    log.debug(
                        "Assigning HVI {}, Spurious Error- {}: {}".format(
                            hviModule.name, error,
                            key.SD_Error.getErrorMessage(error)))
                    log.info("HVI HW assigned for {}, {} in slot {}".format(
                        hviModule.name, module.model, module.slot))
                elif error < 0:
                    error_msg = "HVI assign HW AOU Failed for: {} in slot {}, {}: {}".format(
                        hviModule.name, module.model, module.slot,
                        key.SD_Error.getErrorMessage(error))
                    log.error(error_msg)
                else:
                    log.info("HVI HW assigned for {}, {} in slot {}".format(
                        hviModule.name, module.model, module.slot))
    # if the last module assigned has this error then it is more serious
    if error == -8069:
        log.error("Assigning HVI - {}: {}".format(
            error, key.SD_Error.getErrorMessage(error)))
예제 #5
0
 def __init__(self,
              awgs,
              settings,
              name='virtual_awg',
              logger=logging,
              **kwargs):
     super().__init__(awgs, settings, name, logger, **kwargs)
     if not keysightSD1:
         raise ImportError(
             'To use the Keysight SD drivers install the keysightSD1 module '
             '(http://www.keysight.com/main/software.jspx?ckey=2784055)')
     if not all(
             type(awg.fetch_awg).__name__ == KeysightM3601A.__awg_name
             for awg in self.awgs):
         raise VirtualAwgError(
             'Unusable device added! Not a Keysight M3201A AWG.')
     self.hvi = keysightSD1.SD_HVI()
     self.load_hvi_file()
     self.set_hvi_modules()
     self.set_awg_settings()
예제 #6
0
@author: gumcbrid
"""

import logging
import sys
import time
from collections import namedtuple as namedtuple

sys.path.append('C:\Program Files (x86)\Keysight\SD1\Libraries\Python')
import keysightSD1 as key

constant = namedtuple('constant', 'module, name, value, unit')

__log = logging.getLogger(__name__)

__hvi = key.SD_HVI()

class HviError(Exception):
    """Basic exception for errors raised by HVI"""
    _error = None
    _message = None
    def __init__(self, error, msg=None):
        if msg is None:
            msg = "An error occured with HVI: {}".format(key.SD_Error.getErrorMessage(error))
        super(HviError, self).__init__(msg)
        self._error = error
    @property
    def error_message(self):
        return key.SD_Error.getErrorMessage(self._error)
    
예제 #7
0
class Test_HVIexternaltrigger(Test):

    # Dummy attributes
    Amplitude = 1
    wave_id = 1
    prescaler = 0
    start_delay = 0
    cycles = 0

    # Attributes accessible through object initialization
    test_key = "HVI external trigger"
    module_a_slot = None
    module_a_channel = None
    module_b_slot = None
    module_b_channel = None

    # Attributes accessible through class methods
    module_a = keysightSD1.SD_AOU()
    module_b = keysightSD1.SD_AOU()
    waveform = keysightSD1.SD_Wave()
    hvi = keysightSD1.SD_HVI()

    def __init__(self, module_dict, module_a_slot, module_a_channel,
                 module_b_slot, module_b_channel):
        super().__init__(module_dict)
        self.module_a_slot = module_a_slot
        self.module_a_channel = module_a_channel
        self.module_b_slot = module_b_slot
        self.module_b_channel = module_b_channel
        self._associate()

# This private method associates the module modules (publicly accessible) of this test with the modules
# created in the base class

    def _associate(self):
        for module in self._module_instances:
            if module[2][
                    1] == self.module_a_slot:  # if a module was found in master_slot, assign it to master_module
                self.module_a = module[0]
            elif module[2][1] == self.module_b_slot:
                self.module_b = module[0]
            else:
                print(
                    "[ERROR] Associate function: Module found in slot that was not specified as master or slave"
                )

    def send_PXI_trigger_pulse(self, PXI_line_nbr, delay=.2):
        time.sleep(delay)
        self.module.PXItriggerWrite(PXI_line_nbr, 0)
        time.sleep(delay)
        self.module.PXItriggerWrite(PXI_line_nbr, 1)

    def set_waveform(self, filestr):
        self.waveform.newFromFile(filestr)
        print(
            "Loaded {} into HVI Trigger Sync Test's waveform".format(filestr))

    def set_hvi(self, filestr):
        self.hvi.open(filestr)
        self.hvi.compile()
        self.hvi.load()
        print("Loaded {}.HVI into HVI Trigger Sync Test".format(filestr))
예제 #8
0
class Test_FastBranching(Test):

    # Dummy attributes
    Amplitude = 1
    wave_id_array = [0, 1, 2, 3]
    prescaler = 0
    start_delay = 1
    cycles = 1

    # Attributes accessible through object initialization
    test_key = "FastBranching"
    master_slot = None
    slave_slot = None
    master_index = None  #index in HVI sequence (might need this if HVI project is built in simulate mode)
    slave_index = None  #index in HVI sequence (might need this if HVI project is built in simulate mode)
    master_channel = None
    slave_channel = None

    # Attributes accessible through class methods
    master_module = keysightSD1.SD_AOU(
    )  #assigned with call to associate() method
    slave_module = keysightSD1.SD_AOU(
    )  #assigned with call to associate() method
    waveform_array = []
    hvi = keysightSD1.SD_HVI()

    def __init__(self,
                 module_dict,
                 master_slot,
                 slave_slot,
                 master_channel,
                 slave_channel,
                 master_index=0,
                 slave_index=1):
        super().__init__(module_dict)
        self.master_slot = master_slot
        self.slave_slot = slave_slot
        self.master_index = master_index
        self.slave_index = slave_index
        self.master_channel = master_channel
        self.slave_channel = slave_channel
        self._associate()

    # This private method associates the master & slave modules (publicly accessible) of this test with the modules
    # created in the base class
    def _associate(self):
        for module in self._module_instances:
            if module[2][
                    1] == self.master_slot:  # if a module was found in master_slot, assign it to master_module
                self.master_module = module[0]
            elif module[2][
                    1] == self.slave_slot:  # if a module was found in slave_slot, assign it to slave_module
                self.slave_module = module[0]
            else:
                print(
                    "[ERROR] Associate function: Module found in slot that was not specified as master or slave"
                )

    def send_PXI_trigger_pulse(self, PXI_line_nbr, delay=.1):
        time.sleep(delay)
        self.master_module.PXItriggerWrite(PXI_line_nbr, 0)
        time.sleep(delay)
        self.master_module.PXItriggerWrite(PXI_line_nbr, 1)

    def add_waveform(self, filestr):
        wave = keysightSD1.SD_Wave()
        wave.newFromFile(filestr)
        self.waveform_array.append(wave)
        print("Loaded {} into Fast Branching Test's waveform array".format(
            filestr))

    def set_hvi(self, filestr):
        self.hvi.open(filestr)
        self.hvi.compile()
        self.hvi.load()
        print("Loaded {}.HVI into Fast Branching Test".format(filestr))