def __init__(self): QObject.__init__(self) self._name = '' self._scope = [] self._settings = {} self._daq = None self._sigin = 0 self._sigout = 0 self._scope_time = 1 self._tc = 0 self._freq = 0 self._rate = 0 try: port, apilevel = self._discover() self.server = ziPython.ziDAQServer('localhost', port, apilevel) self.server.connect() msg = self._load_settings() self.server.set(self._settings['server']) self.server.sync() self._get_config() self._daq = self.server.dataAcquisitionModule() self.last_action = 'Lockin found, %s' % (msg) except Exception as e: self.last_action = str(e)
def connect(self): """Established a connection to the data server. Uses the connection details (host, port, api level) specified in the 'connection_details' to open a `zi.ziDAQServer` data server object that is used for all communication to the data server. Raises: ToolkitConnectionError: if connection to the Data Server could not be established """ try: self._daq = zi.ziDAQServer( self._connection_details.host, self._connection_details.port, self._connection_details.api, ) except RuntimeError: raise ToolkitConnectionError( f"No connection could be established with the connection details:" f"{self._connection_details}") if self._daq is not None: print(f"Successfully connected to data server at " f"{self._connection_details.host}:" f"{self._connection_details.port} " f"api version: {self._connection_details.api}") self._awg_module = AWGModuleConnection(self._daq) self._daq_module = DAQModuleConnection(self._daq) self._sweeper_module = SweeperModuleConnection(self._daq) else: raise ToolkitConnectionError( f"No connection could be established with the connection details:" f"{self._connection_details}")
def create_shfqa_sweeper(self) -> tk_modules.SHFQASweeper: """Create an instance of the SHFQASweeper. For now the general sweeper module does not support the SHFQA. However a python based implementation called ``SHFSweeper`` does already provide this functionality. The ``SHFSweeper`` is part of the ``zhinst`` module and can be found in the utils. Toolkit wraps around the ``SHFSweeper`` and exposes a interface that is similar to the LabOne modules, meaning the parameters are exposed in a node tree like structure. In addition a new session is created. This has the benefit that the sweeper implementation does not interfere with the the commands and setups from the user. Returns: Created object """ return tk_modules.SHFQASweeper( ziPython.ziDAQServer( self._server_host, self._server_port, 6, ), self._session, )
def reconnect(self): if not self.server: raise(ziShellServerError()) host, port, api_level = self.server print("Connecting to server on host {0}:{1} using API level {2}".format( host, port, api_level)) self.daq = zi.ziDAQServer(host, port, api_level)
def __init__(self, device_name, ip_address, port=8004): api_level = 6 self.device_name = device_name print(ip_address, port) self.daq_server = zi.ziDAQServer(ip_address, port, api_level) self.data_acq = self.daq_server.dataAcquisitionModule() self.channel_paths = [] # Create a clean configuration zhinst.utils.disable_everything(self.daq_server, self.device_name)
def connect_server(self, host, port=8004, api_level=5): self.server = (host, port, api_level) print("Connecting to server on host {0}:{1} using API level {2}".format( host, port, api_level)) self.daq = zi.ziDAQServer(host, port, api_level) if not self.daq: raise(ziShellDAQError()) # self.daq.setDebugLevel(5) self.connected = False if self.device and self.interface: self.connect_device(self.device, self.interface)
def __init__(self, ip='127.0.0.1', port=8004, api_level=6, device='dev2192', iface='1GbE', settings='PumpUnpumpBoxCar.xml', repRate=1500, timeOut=30): # Create a connection to a Zurich Instruments Data Server self.daq = zh.ziDAQServer(ip, port, api_level) self.device = device self.iface = iface # one could also use utils.autoConnect() instead self.daq.connectDevice(self.device, self.iface) self.daq.connect() # load settings settings_path = path.join(utils.get_default_settings_path(self.daq), settings) utils.load_settings(self.daq, self.device, settings_path) self.timeOut = timeOut self.acqStartTime = None self.acqEndTime = None self.isAcquiring = False # Detect a device #self.device = utils.autoDetect(self.daq) # Find out whether the device is an HF2 or a UHF self.devtype = self.daq.getByte('/%s/features/devtype' % self.device) self.options = self.daq.getByte('/%s/features/options' % self.device) self.clock = self.daq.getDouble('/%s/clockbase' % self.device) if not re.search('BOX', self.options): raise Exception( "This example can only be ran on a UHF with the BOX option enabled." ) if self.daq.getConnectionAPILevel() != 6: warnings.warn("ziDAQServer is using API Level 1, it is strongly recommended " * \ "to use API Level 6 in order to obtain boxcar data with timestamps.") self.daq.sync() self.daq.subscribe('/%s/boxcars/%d/sample' % (self.device, 0)) self.daq.subscribe('/%s/boxcars/%d/sample' % (self.device, 1))
def __init__(self, dev_id=None, port=8005, api_level=1): object.__init__(self) #self.server=ziutils.autoConnect(port,api_level) for _ in range(5): try: self.server=zp.ziDAQServer('localhost',port,api_level) if self._get_server_devices(): break finally: time.sleep(5.) if dev_id is None: devs=self._get_server_devices() if not devs: raise RuntimeError("No devices were detected") dev_id=devs[0] self.dev_id=dev_id self.ref_timestamp=0
def __init__(self, ip='127.0.0.1', port=8004, api_level=6, repRate=1500, timeOut=30): # Create a connection to a Zurich Instruments Data Server print 'connecting ...' self.daq = zh.ziDAQServer(ip, port, api_level) self.daq.connect() self.timeOut = timeOut self.acqStartTime = None self.acqEndTime = None self.isAcquiring = False # Detect a device self.device = utils.autoDetect(self.daq) # Find out whether the device is an HF2 or a UHF self.devtype = self.daq.getByte('/%s/features/devtype' % self.device) self.options = self.daq.getByte('/%s/features/options' % self.device) self.clock = self.daq.getDouble('/%s/clockbase' % self.device) if not re.search('BOX', self.options): raise Exception( "This example can only be ran on a UHF with the BOX option enabled." ) if self.daq.getConnectionAPILevel() != 6: warnings.warn("ziDAQServer is using API Level 1, it is strongly recommended " * \ "to use API Level 6 in order to obtain boxcar data with timestamps.") self.daq.sync() self.daq.subscribe('/%s/boxcars/%d/sample' % (self.device, 0)) self.daq.subscribe('/%s/boxcars/%d/sample' % (self.device, 1)) print 'connected'
def __init__(self, server_address = 'localhost', server_port = 8005 , device_serial = '', in_channel = None, meas_type='V'): ''' Creates the HF2LI object. By choosing server address, can connection to HF2LI on remote (local network) computer. Arguments: server_address (str,optional) = Private IPV4 address of the computer hosting the zurich. Defults to 'localhost', the computer the python kernel is running on. server_port (int, optional) = Port of Zurich HF2LI. For local is always 8005 (default), usually 8006 for remote. device_serial (str, optional) = Serial number of prefered zurich hf2li. If empty string or does not exist, uses first avaliable ZI. in_channel: if None, will use both inputs (TODO). Else, choose input 1 or 2. meas_type: 'I' or 'V'. Choose whether this channel measures current (via transimpedance amplifier) or voltage. ''' super().__init__() self.daq = ziP.ziDAQServer(server_address, server_port) deviceList = utils.devices(self.daq) # Find device if device_serial in deviceList: self.device_id = device_serial elif device_serial != '': print('Requested device not found.') if self.device_id is None: self.device_id = utils.autoDetect(self.daq) # first available print('Using Zurich HF2LI with serial %s' % self.device_id) if in_channel is None: raise Exception() self.in_channel = in_channel self.meas_type = meas_type
def __init__(self, name, device='auto', interface='USB', address='127.0.0.1', port=8004, DIO=True, nr_integration_channels=9, **kw): ''' Input arguments: name: (str) name of the instrument server_name: (str) qcodes instrument server address: (int) the address of the data server e.g. 8006 ''' # self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) # #suggestion W vlothuizen t0 = time.time() super().__init__(name, **kw) self.nr_integration_channels = nr_integration_channels self.DIO = DIO self._daq = zi.ziDAQServer(address, int(port), 5) # self._daq.setDebugLevel(5) if device.lower() == 'auto': self._device = zi_utils.autoDetect(self._daq) else: self._device = device self._daq.connectDevice(self._device, interface) #self._device = zi_utils.autoDetect(self._daq) self._awgModule = self._daq.awgModule() self._awgModule.set('awgModule/device', self._device) self._awgModule.execute() self.acquisition_paths = [] s_node_pars = [] d_node_pars = [] path = os.path.abspath(__file__) dir_path = os.path.dirname(path) self._s_file_name = os.path.join(dir_path, 'zi_parameter_files', 's_node_pars.txt') self._d_file_name = os.path.join(dir_path, 'zi_parameter_files', 'd_node_pars.txt') init = True try: f = open(self._s_file_name).read() s_node_pars = json.loads(f) except: print("parameter file for gettable parameters {} not found".format( self._s_file_name)) init = False try: f = open(self._d_file_name).read() d_node_pars = json.loads(f) except: print("parameter file for settable parameters {} not found".format( self._d_file_name)) init = False self.add_parameter('timeout', unit='s', initial_value=30, parameter_class=ManualParameter) for parameter in s_node_pars: parname = parameter[0].replace("/", "_") parfunc = "/" + self._device + "/" + parameter[0] if parameter[1] == 'float': self.add_parameter( parname, set_cmd=self._gen_set_func(self.setd, parfunc), get_cmd=self._gen_get_func(self.getd, parfunc), vals=vals.Numbers(parameter[2], parameter[3])) elif parameter[1] == 'float_small': self.add_parameter( parname, set_cmd=self._gen_set_func(self.setd, parfunc), get_cmd=self._gen_get_func(self.getd, parfunc), vals=vals.Numbers(parameter[2], parameter[3])) elif parameter[1] == 'int_8bit': self.add_parameter( parname, set_cmd=self._gen_set_func(self.seti, parfunc), get_cmd=self._gen_get_func(self.geti, parfunc), vals=vals.Ints(int(parameter[2]), int(parameter[3]))) elif parameter[1] == 'int': self.add_parameter( parname, set_cmd=self._gen_set_func(self.seti, parfunc), get_cmd=self._gen_get_func(self.geti, parfunc), vals=vals.Ints(int(parameter[2]), int(parameter[3]))) elif parameter[1] == 'int_64': self.add_parameter( parname, set_cmd=self._gen_set_func(self.seti, parfunc), get_cmd=self._gen_get_func(self.geti, parfunc), vals=vals.Ints(int(parameter[2]), int(parameter[3]))) elif parameter[1] == 'bool': self.add_parameter( parname, set_cmd=self._gen_set_func(self.seti, parfunc), get_cmd=self._gen_get_func(self.geti, parfunc), vals=vals.Ints(int(parameter[2]), int(parameter[3]))) else: print( "parameter {} type {} from from s_node_pars not recognized" .format(parname, parameter[1])) for parameter in d_node_pars: parname = parameter[0].replace("/", "_") parfunc = "/" + self._device + "/" + parameter[0] if parameter[1] == 'float': self.add_parameter(parname, get_cmd=self._gen_get_func( self.getd, parfunc)) elif parameter[1] == 'vector_g': self.add_parameter(parname, get_cmd=self._gen_get_func( self.getv, parfunc)) elif parameter[1] == 'vector_s': self.add_parameter(parname, set_cmd=self._gen_set_func( self.setv, parfunc), vals=vals.Anything()) elif parameter[1] == 'vector_gs': self.add_parameter( parname, set_cmd=self._gen_set_func(self.setv, parfunc), get_cmd=self._gen_get_func(self.getv, parfunc), vals=vals.Anything()) else: print("parameter {} type {} from d_node_pars not recognized". format(parname, parameter[1])) self.add_parameter('AWG_file', set_cmd=self._do_set_AWG_file, vals=vals.Anything()) # storing an offset correction parameter for all weight functions, # this allows normalized calibration when performing cross-talk suppressed # readout for i in range(self.nr_integration_channels): self.add_parameter( "quex_trans_offset_weightfunction_{}".format(i), unit='', # unit is adc value label='RO normalization offset', initial_value=0.0, parameter_class=ManualParameter) if init: self.load_default_settings() t1 = time.time() print('Initialized UHFQC', self._device, 'in %.2fs' % (t1 - t0))
#print "inside subprocess" import sys, os sys.path.append(os.path.dirname("/dls_sw/i10/scripts/")) from zhinst import ziPython print "after load zipython" daq = ziPython.ziDAQServer('172.23.110.84', 8004) sample = daq.getSample('/dev4206/demods/0/sample') print sample #print "end of subprocess"
def __init__( self, server_host: str, server_port: int = None, *, hf2: bool = None, connection: ziPython.ziDAQServer = None, ): self._is_hf2_server = bool(hf2) self._server_host = server_host self._server_port = server_port if server_port else 8004 if connection is not None: self._is_hf2_server = "HF2" in connection.getString("/zi/about/dataserver") if hf2 and not self._is_hf2_server: raise RuntimeError( "hf2_server Flag was set but the passed " "DAQServer instance is no HF2 data server." ) if hf2 is False and self._is_hf2_server: raise RuntimeError( "hf2_server Flag was reset but the passed " "DAQServer instance is a HF2 data server." ) self._daq_server = connection else: if self._is_hf2_server and self._server_port == 8004: self._server_port = 8005 try: self._daq_server = ziPython.ziDAQServer( self._server_host, self._server_port, 1 if self._is_hf2_server else 6, ) except RuntimeError as error: if "Unsupported API level" not in error.args[0]: raise if hf2 is None: self._is_hf2_server = True self._daq_server = ziPython.ziDAQServer( self._server_host, self._server_port, 1, ) elif not hf2: raise RuntimeError( "hf2_server Flag was reset but the specified " f"server at {self._server_host}:{self._server_port} is a " "HF2 data server." ) from error if self._is_hf2_server and "HF2" not in self._daq_server.getString( "/zi/about/dataserver" ): raise RuntimeError( "hf2_server Flag was set but the specified " f"server at {self._server_host}:{self._server_port} is not a " "HF2 data server." ) self._devices = HF2Devices(self) if self._is_hf2_server else Devices(self) self._modules = ModuleHandler(self, self._server_host, self._server_port) hf2_node_doc = Path(__file__).parent / "resources/nodedoc_hf2_data_server.json" nodetree = NodeTree( self.daq_server, prefix_hide="zi", list_nodes=["/zi/*"], preloaded_json=json.loads(hf2_node_doc.open("r").read()) if self._is_hf2_server else None, ) super().__init__(nodetree, tuple())
def UHF_init_demod(device_id = 'dev2148', demod_c = 0, out_c = 0): """ Connecting to the device specified by device_id and setting initial parameters through LabOne GUI Arguments: device_id (str): The ID of the device to run the example with. For example, 'dev2148'. demod_c (int): One of {0 - 7} demodulators of UHF LI out_c (int): One of {0,1} output channels of UHF LI Raises: RuntimeError: If the device is not connected to the Data Server. """ global daq # Creating global variable for accesing the UHFLI from other functions global device # Creating global variable for accesing the UHFLI from other functions # Create an instance of the ziDiscovery class. d = ziPython.ziDiscovery() # Determine the device identifier from it's ID. device = d.find(device_id).lower() # Get the device's default connectivity properties. props = d.get(device) # The maximum API level supported by this example. apilevel_example = 5 # The maximum API level supported by the device class, e.g., MF. apilevel_device = props['apilevel'] # Ensure we run the example using a supported API level. apilevel = min(apilevel_device, apilevel_example) # See the LabOne Programming Manual for an explanation of API levels. # Create a connection to a Zurich Instruments Data Server (an API session) # using the device's default connectivity properties. daq = ziPython.ziDAQServer(props['serveraddress'], props['serverport'], apilevel) # Check that the device is visible to the Data Server if device not in utils.devices(daq): raise RuntimeError("The specified device `%s` is not visible to the Data Server, " % device_id + "please ensure the device is connected by using the LabOne User Interface " + "or ziControl (HF2 Instruments).") # find out whether the device is an HF2 or a UHF devtype = daq.getByte('/%s/features/devtype' % device) options = daq.getByte('/%s/features/options' % device) # Create a base configuration: disable all outputs, demods and scopes general_setting = [ ['/%s/demods/*/rate' % device, 0], ['/%s/demods/*/trigger' % device, 0], ['/%s/sigouts/*/enables/*' % device, 0]] if re.match('HF2', devtype): general_setting.append(['/%s/scopes/*/trigchannel' % device, -1]) else: # UHFLI pass #general_setting.append(['/%s/demods/*/enable' % device, 0]) #general_setting.append(['/%s/scopes/*/enable' % device, 0]) daq.set(general_setting) raw_input("Set the UHF LI parameters in user interface dialog! Press enter to continue...") # Wait for user to set the device parametrs from user interface daq.setInt('/%s/demods/%s/enable' % (device, demod_c) , 1) # Enable demodulator daq.setInt('/%s/demods/%s/rate' % (device, demod_c), 100000) # Set the demodulator sampling rate # Unsubscribe any streaming data daq.unsubscribe('*') # Path to UHF LI readout node made globally for using in other functions global path_demod path_demod = '/%s/demods/%d/sample' % (device, demod_c) global path_demod_enable path_demod_enable = '/%s/demods/%d/enable' % (device, demod_c) # Path to UHF LI demodulator trigger node made globally for using in other functions global path_demod_trig path_demod_trig = '/%s/demods/%d/trigger' % (device, demod_c) # Perform a global synchronisation between the device and the data server: # Ensure that 1. the settings have taken effect on the device before issuing # the poll() command and 2. clear the API's data buffers. Note: the sync() # must be issued after waiting for the demodulator filter to settle above. daq.sync() # Subscribe to the demodulator's sample path = path_demod daq.subscribe(path) # Get output amplitude # made globally for using in other functions global out_ampl out_ampl = daq.getDouble('/%s/sigouts/%s/amplitudes/3' % (device, out_c))/np.sqrt(2) # Get sampling rate # made globally for using in other functions global sampling_rate sampling_rate = daq.getDouble('/%s/demods/%s/rate' % (device, demod_c)) # Get time constant in seconds # made globally for using in other functions global TC TC = daq.getDouble('/%s/demods/%s/timeconstant' % (device, demod_c))
def UHF_init_scope(device_id = 'dev2148'): """ Connecting to the device specified by device_id and setting initial parameters through LabOne GUI Arguments: device_id (str): The ID of the device to run the example with. For example, 'dev2148'. Raises: RuntimeError: If the device is not connected to the Data Server. """ global daq # Creating global variable for accesing the UHFLI from other functions global device # Creating global variable for accesing the UHFLI from other functions # Create an instance of the ziDiscovery class. d = ziPython.ziDiscovery() # Determine the device identifier from it's ID. device = d.find(device_id).lower() # Get the device's default connectivity properties. props = d.get(device) # The maximum API level supported by this example. apilevel_example = 5 # The maximum API level supported by the device class, e.g., MF. apilevel_device = props['apilevel'] # Ensure we run the example using a supported API level. apilevel = min(apilevel_device, apilevel_example) # See the LabOne Programming Manual for an explanation of API levels. # Create a connection to a Zurich Instruments Data Server (an API session) # using the device's default connectivity properties. daq = ziPython.ziDAQServer(props['serveraddress'], props['serverport'], apilevel) # Check that the device is visible to the Data Server if device not in utils.devices(daq): raise RuntimeError("The specified device `%s` is not visible to the Data Server, " % device_id + "please ensure the device is connected by using the LabOne User Interface " + "or ziControl (HF2 Instruments).") # find out whether the device is an HF2 or a UHF devtype = daq.getByte('/%s/features/devtype' % device) options = daq.getByte('/%s/features/options' % device) # Create a base configuration: disable all outputs, demods and scopes general_setting = [ ['/%s/demods/*/rate' % device, 0], ['/%s/demods/*/trigger' % device, 0], ['/%s/sigouts/*/enables/*' % device, 0]] if re.match('HF2', devtype): general_setting.append(['/%s/scopes/*/trigchannel' % device, -1]) else: # UHFLI pass #general_setting.append(['/%s/demods/*/enable' % device, 0]) #general_setting.append(['/%s/scopes/*/enable' % device, 0]) daq.set(general_setting) raw_input("Set the UHF LI parameters in user interface dialog! Press enter to continue...") # Wait for user to set the device parametrs from user interface
def __init__(self, name, device='auto', interface='USB', address='127.0.0.1', port=8004, **kw): ''' Input arguments: name: (str) name of the instrument server_name: (str) qcodes instrument server address: (int) the address of the data server e.g. 8006 ''' #self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) #suggestion W vlothuizen t0 = time.time() super().__init__(name, **kw) self._daq = zi.ziDAQServer(address, int(port), 5) if device.lower() == 'auto': self._device = zi_utils.autoDetect(self._daq) else: self._device = device self._daq.connectDevice(self._device, interface) self._device = zi_utils.autoDetect(self._daq) s_node_pars=[] d_node_pars=[] path = os.path.abspath(__file__) dir_path = os.path.dirname(path) self._s_file_name = os.path.join(dir_path, 'zi_parameter_files', 's_node_pars.txt') self._d_file_name = os.path.join(dir_path, 'zi_parameter_files', 'd_node_pars.txt') init = True try: f = open(self._s_file_name).read() s_node_pars = json.loads(f) except: print("parameter file for gettable parameters {} not found".format(self._s_file_name)) init=False try: f = open(self._d_file_name).read() d_node_pars = json.loads(f) except: print("parameter file for settable parameters {} not found".format(self._d_file_name)) init = False for parameter in s_node_pars: parname=parameter[0].replace("/","_") parfunc="/"+device+"/"+parameter[0] if parameter[1] == 'float': self.add_parameter( parname, set_cmd=self._gen_set_func(self.setd, parfunc), get_cmd=self._gen_get_func(self.getd, parfunc), vals=vals.Numbers(parameter[2], parameter[3])) elif parameter[1] == 'float_small': self.add_parameter( parname, set_cmd=self._gen_set_func(self.setd, parfunc), get_cmd=self._gen_get_func(self.getd, parfunc), vals=vals.Numbers(parameter[2], parameter[3])) elif parameter[1] == 'int_8bit': self.add_parameter( parname, set_cmd=self._gen_set_func(self.seti, parfunc), get_cmd=self._gen_get_func(self.geti, parfunc), vals=vals.Ints(int(parameter[2]), int(parameter[3]))) elif parameter[1]=='int': self.add_parameter( parname, set_cmd=self._gen_set_func(self.seti, parfunc), get_cmd=self._gen_get_func(self.geti, parfunc), vals=vals.Ints(int(parameter[2]), int(parameter[3]))) elif parameter[1]=='int_64': self.add_parameter( parname, set_cmd=self._gen_set_func(self.seti, parfunc), get_cmd=self._gen_get_func(self.geti, parfunc), vals=vals.Ints(int(parameter[2]), int(parameter[3]))) elif parameter[1]=='bool': self.add_parameter( parname, set_cmd=self._gen_set_func(self.seti, parfunc), get_cmd=self._gen_get_func(self.geti, parfunc), vals=vals.Ints(int(parameter[2]), int(parameter[3]))) else: print("parameter {} type {} from from s_node_pars not recognized".format(parname,parameter[1])) for parameter in d_node_pars: parname=parameter[0].replace("/","_") parfunc="/"+device+"/"+parameter[0] if parameter[1]=='float': self.add_parameter( parname, get_cmd=self._gen_get_func(self.getd, parfunc)) elif parameter[1]=='vector_g': self.add_parameter( parname, get_cmd=self._gen_get_func(self.getv, parfunc)) elif parameter[1]=='vector_s': self.add_parameter( parname, set_cmd=self._gen_set_func(self.setv, parfunc), vals=vals.Anything()) elif parameter[1]=='vector_gs': self.add_parameter( parname, set_cmd=self._gen_set_func(self.setv, parfunc), get_cmd=self._gen_get_func(self.getv, parfunc), vals=vals.Anything()) else: print("parameter {} type {} from d_node_pars not recognized".format(parname,parameter[1])) self.add_parameter('AWG_file', set_cmd=self._do_set_AWG_file, vals=vals.Anything()) if init: self.load_default_settings() t1 = time.time() print('Initialized UHFQC', self._device, 'in %.2fs' % (t1-t0))
def reset(self, dlts, mfia): self.generate_log("Initializing MFIA...", "blue") self.ziDAQ = [] calcRejectSamples = math.floor( 16 * mfia.time_constant * mfia.sample_rate ) #calculation of hardware recovery, derived from the MFIA user manual sect. 6.4.2 for 99% recovery using 8th order filter extraRejectSamples = mfia.sample_reject #if empirically it is seen that more data points should be rejected beyond the above calculation, add the extra # of points here self.rejectSamples = calcRejectSamples + extraRejectSamples #length of hardware recovery in data points ## Open connection to the ziServer (socket for sync interface) self.ziDAQ = ziPython.ziDAQServer( '127.0.0.1', 8004, 6) # Use local data server for best performance # Get device name automagically (e.g. 'dev234') device = self.autoDetect() self.device = device #TODO Fix this later # or specify manually #device = 'dev3327' # Enable IA module self.ziDAQ.setInt("/{0}/imps/0/enable".format(device), 1) # ziDAQ('setInt', ['/' device '/imps/0/enable'], 1); vrange = 10 irange = mfia.i_range phase_offset = 0 # Setup IA module self.ziDAQ.setInt("/{0}/imps/0/mode".format(device), 1) self.ziDAQ.setInt("/{0}/system/impedance/filter".format(device), 1) self.ziDAQ.setInt("/{0}/imps/0/model".format(device), 0) # ziDAQ('setInt', ['/' device '/imps/0/mode'], 1); # ziDAQ('setInt', ['/' device '/system/impedance/filter'], 1); # ziDAQ('setInt', ['/' device '/imps/0/model'], 0); self.ziDAQ.setInt("/{0}/imps/0/auto/output".format(device), 0) self.ziDAQ.setInt("/{0}/system/impedance/precision".format(device), 0) self.ziDAQ.setDouble("/{0}/imps/0/maxbandwidth".format(device), 1000) self.ziDAQ.setDouble("/{0}/imps/0/omegasuppression".format(device), 60) # ziDAQ('setInt', ['/' device '/imps/0/auto/output'], 0); # ziDAQ('setInt', ['/' device '/system/impedance/precision'], 0); # ziDAQ('setDouble', ['/' device '/imps/0/maxbandwidth'], 1000); # ziDAQ('setDouble', ['/' device '/imps/0/omegasuppression'], 60); self.ziDAQ.setDouble( "/{0}/imps/0/confidence/lowdut2t/ratio".format(device), 1000) # # Input settings, set to current and set range self.ziDAQ.setInt("/{0}/imps/0/auto/inputrange".format(device), 0) self.ziDAQ.setDouble("/{0}/imps/0/current/range".format(device), irange) self.ziDAQ.setDouble("/{0}/imps/0/voltage/range".format(device), vrange) # ziDAQ('setInt', ['/' device '/imps/0/auto/inputrange'], 0); # ziDAQ('setDouble', ['/' device '/imps/0/current/range'], irange); # %ziDAQ('setDouble', ['/' device '/imps/0/voltage/range'], vrange); # # Lock in params & filtering self.ziDAQ.setInt("/{0}/imps/0/demod/sinc".format(device), 1) self.ziDAQ.setInt("/{0}/imps/0/demod/order".format(device), 8) self.ziDAQ.setInt("/{0}/imps/0/auto/bw".format(device), 0) self.ziDAQ.setDouble("/{0}/demods/0/phaseshift".format(device), phase_offset) self.ziDAQ.setDouble("/{0}/imps/0/demod/timeconstant".format(device), mfia.time_constant) self.ziDAQ.setDouble("/{0}/imps/0/demod/harmonic".format(device), 1) # ziDAQ('setInt', ['/' device '/imps/0/demod/sinc'], 1); # ziDAQ('setInt', ['/' device '/imps/0/demod/order'], 8); # ziDAQ('setInt', ['/' device '/imps/0/auto/bw'], 0); # ziDAQ('setDouble', ['/' device '/demods/0/phaseshift'], phase_offset); # ziDAQ('setDouble', ['/' device '/imps/0/demod/timeconstant'], mfia.time_constant); # ziDAQ('setDouble', ['/' device '/imps/0/demod/harmonic'], 1); # # Oscillator settings self.ziDAQ.setDouble("/{0}/imps/0/freq".format(device), mfia.ac_freq) self.ziDAQ.setDouble("/{0}/imps/0/output/amplitude".format(device), mfia.ac_ampl) # ziDAQ('setDouble', ['/' device '/imps/0/freq'], mfia.ac_freq); # ziDAQ('setDouble', ['/' device '/imps/0/output/amplitude'], mfia.ac_ampl); # # Output settings self.ziDAQ.setDouble("/{0}/imps/0/output/range".format(device), vrange) self.ziDAQ.setInt("/{0}/imps/0/output/on".format(device), 1) if dlts.pulse_height: self.ziDAQ.setInt("/{0}/sigouts/0/add".format(device), 1) else: self.ziDAQ.setInt("/{0}/sigouts/0/add".format(device), 0) # ziDAQ('setDouble', ['/' device '/imps/0/output/range'], vrange); # ziDAQ('setInt', ['/' device '/imps/0/output/on'], 1); # if mfia.pulse_height % Check if a pulse bias is set, if so add to ss bias # ziDAQ('setInt', ['/' device '/sigouts/0/add'], 1); # else # ziDAQ('setInt', ['/' device '/sigouts/0/add'], 0); # end self.ziDAQ.setDouble("/{0}/sigouts/0/offset".format(device), dlts.ss_bias) self.ziDAQ.setInt("/{0}/tu/thresholds/0/input".format(device), 59) self.ziDAQ.setInt("/{0}/tu/thresholds/1/input".format(device), 59) self.ziDAQ.setInt("/{0}/tu/thresholds/0/inputchannel".format(device), 0) self.ziDAQ.setInt("/{0}/tu/thresholds/1/inputchannel".format(device), 0) self.ziDAQ.setInt("/{0}/tu/logicunits/0/inputs/0/not".format(device), 1) self.ziDAQ.setInt("/{0}/tu/logicunits/1/inputs/0/not".format(device), 1) # ziDAQ('setDouble', ['/' device '/sigouts/0/offset'], dlts.ss_bias); # ziDAQ('setInt', ['/' device '/tu/thresholds/0/input'], 59); # ziDAQ('setInt', ['/' device '/tu/thresholds/1/input'], 59); # ziDAQ('setInt', ['/' device '/tu/thresholds/0/inputchannel'], 0); # ziDAQ('setInt', ['/' device '/tu/thresholds/1/inputchannel'], 0); # ziDAQ('setInt', ['/' device '/tu/logicunits/0/inputs/0/not'], 1); # ziDAQ('setInt', ['/' device '/tu/logicunits/1/inputs/0/not'], 1); self.ziDAQ.setDouble( "/{0}/tu/thresholds/0/deactivationtime".format(device), dlts.trns_length + 0.001) self.ziDAQ.setDouble( "/{0}/tu/thresholds/0/activationtime".format(device), dlts.pulse_width) self.ziDAQ.setDouble( "/{0}/tu/thresholds/1/deactivationtime".format(device), 0) self.ziDAQ.setDouble( "/{0}/tu/thresholds/1/activationtime".format(device), 0) # ziDAQ('setDouble', ['/' device '/tu/thresholds/0/deactivationtime'], dlts.trns_length+0.001); #add 1ms buffer time # ziDAQ('setDouble', ['/' device '/tu/thresholds/0/activationtime'], dlts.pulse_width); # ziDAQ('setDouble', ['/' device '/tu/thresholds/1/deactivationtime'], 0); # ziDAQ('setDouble', ['/' device '/tu/thresholds/1/activationtime'], 0); self.ziDAQ.setInt("/{0}/auxouts/0/outputselect".format(device), 13) self.ziDAQ.setInt("/{0}/auxouts/1/outputselect".format(device), 13) self.ziDAQ.setInt("/{0}/auxouts/0/demodselect".format(device), 0) self.ziDAQ.setInt("/{0}/auxouts/1/demodselect".format(device), 1) # ziDAQ('setInt', ['/' device '/auxouts/0/outputselect'], 13); # ziDAQ('setInt', ['/' device '/auxouts/1/outputselect'], 13); # ziDAQ('setInt', ['/' device '/auxouts/0/demodselect'], 0); # ziDAQ('setInt', ['/' device '/auxouts/1/demodselect'], 1); self.ziDAQ.setDouble("/{0}/auxouts/0/scale".format(device), dlts.pulse_height) self.ziDAQ.setDouble("/{0}/auxouts/0/offset".format(device), 0) self.ziDAQ.setDouble("/{0}/auxouts/1/scale".format(device), -5.0) self.ziDAQ.setDouble("/{0}/auxouts/1/offset".format(device), 5.0) # ziDAQ('setDouble', ['/' device '/auxouts/0/scale'], dlts.pulse_height); # ziDAQ('setDouble', ['/' device '/auxouts/0/offset'], 0); # ziDAQ('setDouble', ['/' device '/auxouts/1/scale'], -5.0); # ziDAQ('setDouble', ['/' device '/auxouts/1/offset'], 5.0); # # Data stream settings self.ziDAQ.setDouble("/{0}/imps/0/demod/rate".format(device), mfia.sample_rate) # ziDAQ('setDouble', ['/' device '/imps/0/demod/rate'], mfia.sample_rate); self.generate_log("MFIA configure OK.", "green") return True
def connect_device(self, devicename, required_options=None, required_err_msg='', exp_dependencie=False): import zhinst.utils as utils import zhinst.ziPython as ziPython # This function finds and connect the zurich device with serial number : devicename api_level = 6 # dev_type = 'UHFLI' dev_type = 'MFLI' # Create an instance of the ziDiscovery class. d = ziPython.ziDiscovery() # Determine the device identifier from it's ID. device_id = d.find(devicename).lower() # Get the device's connectivity properties. props = d.get(device_id) if not props['discoverable']: messagebox.showinfo( message="The specified device `{}` is not discoverable ". format(devicename) + "from the API. Please ensure the device is powered-on and visible using the LabOne User" + "Interface or ziControl.", title='Information') else: if not re.search(dev_type, props['devicetype']): messagebox.showinfo( message= "Required device type not satisfied. Device type `{}` does not match the" + "required device type:`{}`. {}".format( props['devicetype'], dev_type, required_err_msg)) if required_options: assert isinstance(required_options, list), "The keyword argument must be a list of string each entry" \ "specifying a device option." def regex_option_diff(required_options, device_options): """Return the options in required_options (as regex) that are not found in the device_options list. """ missing_options = [] for option in required_options: if not re.search(option, '/'.join(device_options)): missing_options += required_options return missing_options if props['devicetype'] == 'UHFAWG': # Note(16.12): This maintains backwards compatibility of this function. installed_options = props['options'] + ['AWG'] else: installed_options = props['options'] missing_options = regex_option_diff(required_options, installed_options) if missing_options: raise Exception( "Required option set not satisfied. The specified device `{}` has the `{}` options " "installed but is missing the required options `{}`. {}" .format(device_id, props['options'], missing_options, required_err_msg)) # The maximum API level supported by the device class, e.g., MF. apilevel_device = props['apilevel'] # Ensure that we connect on an compatible API Level (from where create_api_session() was called). apilevel = min(apilevel_device, api_level) # Creating a Daq server for the device with the parameters found daq = ziPython.ziDAQServer(props['serveraddress'], props['serverport'], apilevel) messagebox.showinfo( message='Zurich Instrument device {} is connected'.format( device_id), title='Information') self.info = {'daq': daq, 'device': device_id, 'prop': props} self.default = utils.default_output_mixer_channel( self.info['prop']) self.node_branch = daq.listNodes('/%s/' % device_id, 0) reset_settings = [['/%s/demods/*/enable' % device_id, 0], ['/%s/demods/*/trigger' % device_id, 0], ['/%s/sigout/*/enables/*' % device_id, 0], ['/%s/scopes/*/enable' % device_id, 0]] daq.set(reset_settings) daq.sync() if self.mainf: experiments = self.mainf.Frame[4].experiment_dict for experiment in experiments: experiments[experiment].update_options('Zurich')