def __init__(self, name): Instrument.__init__(self, name, tags=['virtual']) self.add_parameter('temperature', type=float, flags=Instrument.FLAG_GET, units='mK') self.t = tip_client('tip',address='pi-us74') #tip raspberry instance
def __init__(self, name, address='10.22.197.115'): ''' Initialzes the IVVIDIG, and communicates with the Rasbpi Input: name (string) : name of the instrument address (string) : Rasbpi's IP-Adress Output: None ''' logging.info(__name__ + ' : Initializing instrument IVVIDIG') Instrument.__init__(self, name, tags=['physical']) self._address = address self._port = 6543 #FIXME: numdacs is now variable!? self._numdacs = 16 # Add functions #self.add_function('get_dac') #self.add_function('set_dac') self.REQUEST_TIMEOUT = 2500 self.REQUEST_RETRIES = 3 self._open_zmq_connection()
def __init__(self, name, address, reset = False): ''' Initializes the HP 3245A source, and communicates with the wrapper. Input: name (string) : name of the instrument address (string) : GPIB address reset (bool) : resets to default values Output: None ''' # Initialize wrapper functions logging.info(__name__ + ' : Initializing instrument HP_3245A') Instrument.__init__(self, name, tags=['physical']) self._address = address self._visainstrument = visa.instrument(self._address) # Implement parameters self.add_parameter("current", type=float, units='A', flags=Instrument.FLAG_GETSET) self.add_parameter("voltage", type=float, units='V', flags=Instrument.FLAG_GETSET) self.add_function('reset') self.add_function('clear_memory') self.add_function('set_channel') self.add_function('set_terminal') self.add_function('set_output_type') self.add_function('set_impedance') self.add_function('set_resolution') self.add_function('set_autorange') #self.add_function('set_current') #self.add_function('set_voltage') self.reset()
def __init__(self, name, address): ''' Input: name (string) : name of the instrument address (string) : instrument (serial port) address Output: None ''' logging.debug(__name__ + ' : Initializing instrument') Instrument.__init__(self, name, tags=['physical']) self._address = address self._visainstrument = visa.SerialInstrument(self._address, delay=30e-3) self._values = {} self._visainstrument.stop_bits = 1 # This works only using pyvisa 1.4 self.reset() #Add parameters self.add_parameter('b_raw', type=int, flags=Instrument.FLAG_GET) self.add_parameter('counts', type=int, flags=Instrument.FLAG_GETSET) # Add functions self.add_function('get_all') self.get_all()
def __init__(self, name, remote_name, inssrv=None, server=None): Instrument.__init__(self, name, tags=['remote']) self._remote_name = remote_name if inssrv is None: inssrv = objsh.helper.find_object('%s:instrument_server' % server) self._srv = inssrv params = self._srv.get_ins_parameters(remote_name) for name, info in params.iteritems(): if info['flags'] & Instrument.FLAG_GET: info['get_func'] = self._get elif info['flags'] & Instrument.FLAG_SOFTGET: info['flags'] ^= (Instrument.FLAG_SOFTGET | Instrument.FLAG_GET) info['get_func'] = self._get if info['flags'] & Instrument.FLAG_SET: info['set_func'] = self._set info['channel'] = name self.add_parameter(name, **info) funcs = self._srv.get_ins_functions(remote_name) for name, info in funcs.iteritems(): try: func = self.create_lambda(name, info.get('argspec', None)) if 'doc' in info: func.__doc__ = info['doc'] setattr(self, name, func) self.add_function(name, **info) except Exception, e: logging.warning('Failed to create function %s: %s', name, e)
def __init__(self, name, address, reset=False): ''' Initializes the Inficon, and communicates with the wrapper. Input: name (string) : name of the instrument address (string) : GPIB address reset (bool) : resets to default values, default=False ''' logging.info(__name__ + ': Initializing instrument Inficon') Instrument.__init__(self, name, tags=['physical']) #self._address = address if sys.version_info[0] < 3: def enc(string): return string def dec(string): return string else: def enc(string): return string.encode('latin-1') def dec(byte): return byte.decode('latin-1') self._enc = enc self._dec = dec self.setup(address)
def __init__(self, name, address): Instrument.__init__(self, name, tags=['physical']) self._address = address self._visainstrument = visa.instrument(self._address) self.min_freq = self.get_MIN_frequency() self.max_freq = self.get_MAX_frequency() self.min_ampl = self.get_MIN_amplitude() self.max_ampl = self.get_MAX_amplitude() self.min_offs = self.get_MIN_offset() self.max_offs = self.get_MAX_offset() self.set_default() #reset self.add_function('set_default') self.add_function('get_frequency') self.add_function('set_frequency') self.add_function('get_function') self.add_function('set_function') self.add_function('get_amplitude') self.add_function('set_amplitude') self.add_function('get_output') self.add_function('set_output') self.add_function('get_offset') self.add_function('set_offset') self.add_function('get_voltage_units') self.add_function('set_voltage_units') self.add_function('get_output_load') self.add_function('set_output_load')
def __init__(self, name, host='10.22.197.88', port=9988): Instrument.__init__(self, name, tags=['physical']) self.add_parameter('position', type=str, flags=Instrument.FLAG_GETSET) self.HOST, self.PORT = host, port
def __init__(self, name, source=None, channel = 0, stepsize = 2e-9, stepdelay=1): ''' virtual magnet built upon yokogawa source ''' Instrument.__init__(self, name, tags=['virtual']) self._instruments = qkit.instruments.get_instruments() self._source= self._instruments.get(source) self._channel = channel # Add parameters self.add_parameter('current', type=float, flags=Instrument.FLAG_GETSET, units='A') self.add_parameter('stepsize', type=float, flags=Instrument.FLAG_GETSET, units='A') self.add_parameter('range', type=float, flags=Instrument.FLAG_GETSET, units='A') self.add_parameter('stepdelay', type=float, flags=Instrument.FLAG_GETSET, units='ms') self._stepsize = stepsize self._stepdelay = stepdelay getattr(self._source, 'set_ch%d_sweep_mode'%channel)('fix') getattr(self._source, 'set_ch%d_source_mode'%channel)('curr') getattr(self._source, 'set_ch%d_sense_mode'%channel)('curr') self.get_all()
def __init__(self, name): Instrument.__init__(self, name, tags=['virtual']) self.add_parameter('attenuation', type=float, flags=Instrument.FLAG_SET, units='dB')
def __init__(self, name, address, ip=""): Instrument.__init__(self, name, tags=['physical']) self._address = address self._visainstrument = visa.instrument(self._address, ip=ip) self.set_default() #reset self.add_function('set_default') self.add_function('get_bandwidth') self.add_function('set_bandwidth') self.add_function('get_auto_zero') self.add_function('set_auto_zero') self.add_function('get_configuration') self.add_function('get_measurement_mode') self.add_function('get_range') self.add_function('get_resolution') self.add_function('set_measurement_mode') self.add_function('set_range_resolution') self.add_function('get_NPLC') self.add_function('set_NPLC') self.add_function('get_autorange') self.add_function('set_autorange') self.add_function('measure')
def __init__(self, name, address, reset=False): """ Initializes the MKS, and communicates with the wrapper. Args: name (string) : Name of the instrument address (string) : Serial address reset (bool) : Resets to default values, default=False """ logging.info(__name__ + ': Initializing instrument MKS_647C') Instrument.__init__(self, name, tags=['physical']) self.predef_pressure_unit = 13 # 100 ubar, depends on baratron self.predef_channels = {"Ar": 1, "N2": 2, "O2": 3, "ArO": 4} self.predef_gasCorfact = { "Ar": 1.37, "N2": 1.0, "O2": 1.0, "ArO": 1.37 } # Values as they are predefined in MKS self.predef_flowRange = { "Ar": 6, "N2": 6, "O2": 6, "ArO": 3 } # 100sccm, 100sccm, 100sccm, 10sccm self.mutex = Lock() self.setup(address) self.init_controller(reset=reset)
def __init__(self, name, address, number=5): ''' Initializes the Oxford Instruments Kelvinox IGH Dilution Refrigerator. Input: name (string) : name of the instrument address (string) : instrument address number (int) : ISOBUS instrument number Output: None ''' logging.debug(__name__ + ' : Initializing instrument') Instrument.__init__(self, name, tags=['physical']) self._address = address self._number = number self._visainstrument = visa.SerialInstrument(self._address) self._values = {} self._visainstrument.stop_bits = 2 #Add parameters self.add_parameter('1K_pot_temp', type=float, flags=Instrument.FLAG_GET) self.add_parameter('mix_chamber_temp', type=float, flags=Instrument.FLAG_GET) # Add functions self.add_function('get_all') self.get_all()
def __init__(self, name, id): Instrument.__init__(self, name, tags=['physical']) self._id = id for ch_in in self._get_input_channels(): ch_in = _get_channel(ch_in) self.add_parameter(ch_in, flags=Instrument.FLAG_GET, type=float, units='V', tags=['measure'], get_func=self.do_get_input, channel=ch_in) for ch_out in self._get_output_channels(): ch_out = _get_channel(ch_out) self.add_parameter(ch_out, flags=Instrument.FLAG_SET, type=float, units='V', tags=['sweep'], set_func=self.do_set_output, channel=ch_out) for ch_ctr in self._get_counter_channels(): ch_ctr = _get_channel(ch_ctr) self.add_parameter(ch_ctr, flags=Instrument.FLAG_GET, type=int, units='#', tags=['measure'], get_func=self.do_get_counter, channel=ch_ctr) self.add_parameter(ch_ctr + "_src", flags=Instrument.FLAG_SET | Instrument.FLAG_SOFTGET, type=str, set_func=self.do_set_counter_src, channel=ch_ctr) self.add_parameter('chan_config', flags=Instrument.FLAG_SET | Instrument.FLAG_SOFTGET, type=str, option_list=('Default', 'RSE', 'NRSE', 'Diff', 'PseudoDiff')) self.add_parameter('count_time', flags=Instrument.FLAG_SET | Instrument.FLAG_SOFTGET, type=float, units='s') self.add_function('reset') self.add_function('digital_out') self.reset() self.set_chan_config('RSE') self.set_count_time(0.1) self.get_all()
def __init__(self, name, address, reset=False): ''' Initializes the Tektronix_PWS4205, and communicates with the wrapper. Input: name (string) : name of the instrument address (string) : GPIB or USB address reset (bool) : resets to default values, default=False ''' logging.info(__name__ + ' : Initializing instrument Tektronix_PWS4205') Instrument.__init__(self, name, tags=['physical']) # Add some global constants self._address = address self._visainstrument = visa.instrument(self._address) self._name = name self.add_parameter('voltage', flags=Instrument.FLAG_GETSET, units='V', minval=0, maxval=20, type=float) self.add_parameter('setvoltage', flags=Instrument.FLAG_GET, units='V', minval=0, maxval=20, type=float) self.add_parameter('current', flags=Instrument.FLAG_GETSET, units='A', minval=0, maxval=5, type=float) self.add_parameter('setcurrent', flags=Instrument.FLAG_GET, units='A', minval=0, maxval=5, type=float) self.add_parameter('status', flags=Instrument.FLAG_GETSET, type=bool) self.add_function('reset') self.add_function('on') self.add_function('off') self.add_function('ramp_current') # self.add_function('exec_tsl_script') # self.add_function('exec_tsl_script_with_return') # self.add_function('get_tsl_script_return') #self.add_function ('get_all') #self._visainstrument.write('beeper.beep(0.5,1000)') if (reset): self.reset() else: self.get_all()
def __init__(self, name, address="tcp://10.22.197.143:4242"): """ inits the VCA (virtual instrument) :param name: qkit instrument name :param address: IP-address of Raspberry-Pi controlling the VCAs """ Instrument.__init__(self, name, tags=['virtual']) self.add_parameter('attenuation_i_manip', type=float, flags=Instrument.FLAG_SET | Instrument.FLAG_SOFTGET, units='dB', minval=0, maxval=20) self.add_parameter('attenuation_q_manip', type=float, flags=Instrument.FLAG_SET | Instrument.FLAG_SOFTGET, units='dB', minval=0, maxval=20) self.add_parameter('attenuation_i_readout', type=float, flags=Instrument.FLAG_SET | Instrument.FLAG_SOFTGET, units='dB', minval=0, maxval=20) self.add_parameter('attenuation_q_readout', type=float, flags=Instrument.FLAG_SET | Instrument.FLAG_SOFTGET, units='dB', minval=0, maxval=20) self.add_parameter('attenuation_rf_readout', type=float, flags=Instrument.FLAG_SET | Instrument.FLAG_SOFTGET, units='dB', minval=0, maxval=30) self.add_parameter('attenuation_rf_manip', type=float, flags=Instrument.FLAG_SET | Instrument.FLAG_SOFTGET, units='dB', minval=0, maxval=30) self.add_parameter('amplification_i_return', type=float, flags=Instrument.FLAG_SET | Instrument.FLAG_SOFTGET, units='dB', minval=-20, maxval=33) self.add_parameter('amplification_q_return', type=float, flags=Instrument.FLAG_SET | Instrument.FLAG_SOFTGET, units='dB', minval=-20, maxval=33) self._address = address self._dac = zerorpc.Client()
def __init__(self, name, serial=None, port='A', baudrate=115200): ''' discover and initialize Tunnel_DAC hardware Input: serial - serial number of the FTDI converter channel - 2 character channel id the DAC is connected to; the first byte identifies the channel (A..D for current devices) the second byte identifies the bit within that channel (0..7) numdacs - number of DACs daisy-chained on that line delay - communications delay assumed between PC and the USB converter ''' logging.info(__name__ + ': Initializing instrument Tunnel_DAC') Instrument.__init__(self, name, tags=['physical']) self._conn = Ftdi() # VIDs and PIDs of converters used vps = [ (0x0403, 0x6011), # FTDI UM4232H 4ch (0x0403, 0x6014) # FTDI UM232H 1ch ] # explicitly clear device cache of UsbTools #UsbTools.USBDEVICES = [] # find all devices and obtain serial numbers devs = self._conn.find_all(vps) # filter list by serial number if provided if (serial != None): devs = [dev for dev in devs if dev[2] == serial] if (len(devs) == 0): logging.error(__name__ + ': failed to find matching FTDI devices.') elif (len(devs) > 1): logging.error( __name__ + ': more than one converter found and no serial number given.') logging.info(__name__ + ': available devices are: %s.' % str([dev[2] for dev in devs])) vid, pid, self._serial, ports, description = devs[0] self._ports = [chr(ord('A') + i) for i in range(ports)] # open device (self._port, bit) = self._parse_channel_string(port) self._conn.open(vid, pid, interface=ord(self._port) - ord('A') + 1, serial=self._serial) logging.info(__name__ + ': using converter with serial #%s' % self._serial) self._conn.set_bitmode(0xFF, Ftdi.BITMODE_BITBANG) self._set_baudrate(baudrate) # provide user interface self.add_parameter('port', type=str, flags=Instrument.FLAG_GET) #self.add_parameter('aliases', type=types.DictType, flags=Instrument.FLAG_GETSET) self.add_function('digital_out') self.add_function('digital_stream') self.add_function('set_aliases') self.add_function('get_aliases')
def __init__(self, name, address="localhost", port=9999): # logging.info(__name__ + ' : Initializing TIP client') Instrument.__init__(self, name, tags=['physical']) # Add some global constants self._address = address self._port = port self.reconnect(address, port) self.add_function('reconnect') self.add_function('send') self.add_function('recv') self.add_function('r_set_T') self.add_function('r_get_T') self.add_function('new_T') self.add_function('close') self.add_function('autorange') self.add_function('set_interval_scanning') self.add_function('set_interval_base') self.add_function('set_interval_off') self.add_function('measure') self.add_function('get_all') self.add_parameter('T', flags=Instrument.FLAG_GETSET, type=float, units='K' ) self.add_parameter('P', flags=Instrument.FLAG_GETSET, type=float, units='' ) self.add_parameter('I', flags=Instrument.FLAG_GETSET, type=float, units='' ) self.add_parameter('D', flags=Instrument.FLAG_GETSET, type=float, units='' ) self.add_parameter('interval', type=float, flags=Instrument.FLAG_GETSET, units="s", channels=(1, 5), channel_prefix='T%d_') self.add_parameter('range', type=int, flags=Instrument.FLAG_GETSET, channels=(1, 5), channel_prefix='T%d_') self.add_parameter('excitation', type=int, flags=Instrument.FLAG_GETSET, channels=(1, 5), channel_prefix='T%d_') self.add_parameter('temperature', type=float, flags=Instrument.FLAG_GET, units="K", channels=(1, 5), channel_prefix='T%d_') self.T = 0.0
def __init__(self, name): self.__name__ = __name__ Instrument.__init__(self, name, tags=['virtual']) self.predef_channels = {'Ar': 0, 'ArO': 0, 'N': 0, 'O': 0} self.add_function('get_pressure') self.add_function('get_flow')
def __init__(self, name, host='pi-us126', port=9900): Instrument.__init__(self, name, tags=['physical']) self.add_parameter('attenuation', type=float, minval=0, maxval=31.5, units='dB', flags=Instrument.FLAG_GETSET) self.HOST, self.PORT = host, port self.get_attenuation()
def __init__(self, name, address, model='Anritsu'): ''' Initializes the Anritsu_MG37022, and communicates with the wrapper. Input: name (string) : name of the instrument address (string) : GPIB address ''' logging.info(__name__ + ' : Initializing instrument') Instrument.__init__(self, name, tags=['physical']) self._address = address self._model = model self._visainstrument = visa.instrument(self._address) self._slope = None #set _slope to True if frequency dependent power compensation is requested sleep(1) # Implement parameters self.add_parameter('frequency', type=float, flags=Instrument.FLAG_GETSET, minval=0, maxval=20e9, units='Hz', tags=['sweep']) if ("MG3692C" not in self.ask("*IDN?").split(",")): self.add_parameter('phase_offset', type=float, flags=Instrument.FLAG_GETSET, minval=-360, maxval=360, units='deg') self.add_parameter('slope', type=float, flags=Instrument.FLAG_GETSET, minval=0, maxval=100, units='dB@10GHz') self.add_parameter( 'power', type=float, flags=Instrument.FLAG_GETSET, minval=-130, maxval=29, #29dBm possible, this is security JB units='dBm', tags=['sweep']) self.add_parameter('status', type=bool, flags=Instrument.FLAG_GETSET) self.add_parameter('high_power', type=bool, flags=Instrument.FLAG_GETSET) # Implement functions self.add_function('get_all') self.get_all()
def __init__(self, name, interface, ethertype = 0x0003, ip_host = '127.0.0.1', ip_port = 413, ip_filter = ''): ''' Initializes the UDP-to-Ethernet bridge Input: name (string) : name of the instrument interface (string) : raw ethernet network interface ethertype : ethernet frame type to receive ip_host:ip_port : UDP interface address ip_filter : regular expression used to match incoming packets against Output: None ''' logging.debug(__name__ + ' : Initializing instrument') Instrument.__init__(self, name, tags=['physical']) self._interface = interface self._ethertype = int(ethertype) self._ip_host = ip_host self._ip_port = int(ip_port) self.do_set_ip_filter(ip_filter) self._clients = {} # associate MAC addresses with udp clients self._devices = set() # mac addresses seen on the raw interface self._updateLock = threading.Lock() # add parameters self.add_parameter('interface', type=str, flags=Instrument.FLAG_GET) self.add_parameter('MAC', type=str, flags=Instrument.FLAG_GET) self.add_parameter('ethertype', type=int, flags=Instrument.FLAG_GET) self.add_parameter('ip_host', type=str, flags=Instrument.FLAG_GET) self.add_parameter('ip_port', type=int, flags=Instrument.FLAG_GET) self.add_parameter('ip_filter', type=str, flags=Instrument.FLAG_GETSET) self.add_parameter('devices', type=types.ListType, flags=Instrument.FLAG_GET) self.add_parameter('listeners', type=types.ListType, flags=Instrument.FLAG_GET) self.add_parameter('raw_rcvbuf', type=int, flags=Instrument.FLAG_GETSET) self.add_parameter('udp_rcvbuf', type=int, flags=Instrument.FLAG_GETSET) self.add_function('get_all') # open sockets self._init_udp() self._init_raw() # update ui self.get_all() # start daemons self._udp_receiver = self.udp_receiver(self) self._udp_receiver.daemon = True self._udp_receiver.start() self._raw_receiver = self.raw_receiver(self) self._raw_receiver.daemon = True self._raw_receiver.start()
def __init__(self, name, dacs=DAC_ROUT, dacranges=None): """ init virtual instrument object Inputs: - name: qt instrument name - dacs: list of routes of channels in use, e.g. [5] or [5,9,2] - dacranges: list of length len(dacs) indicating the dac ranges set at the device, list entries one of 'bi' for -2000,2000, 'pos' for 0,4000, 'neg' for -4000,0 """ Instrument.__init__(self, name, tags=['virtual']) self.dacs = dacs try: self.channels = len(self.dacs) except TypeError: logging.error( 'Error reading dac ports to be used. Import as list.') if dacranges == None: dacranges = ['bi'] * self.channels else: if len(dacranges) != self.channels: logging.error('dacranges not specified properly') limits_dict = { 'bi': [-2000, 2000], 'pos': [0, 4000], 'neg': [-4000, 0] } self.range_limits = [ limits_dict[dacranges[i]] for i in range(self.channels) ] # print self.range_limits if self.channels == 1: self.add_parameter('current', type=float, flags=Instrument.FLAG_GETSET, units='mA') self.add_parameter('range', type=str, flags=Instrument.FLAG_GETSET) elif self.channels > 1 and self.channels <= 16: self.add_parameter('current', type=float, flags=Instrument.FLAG_GETSET, units='mA', channels=(1, self.channels), channel_prefix='ch%d_') self.add_parameter('range', type=str, flags=Instrument.FLAG_GETSET, channels=(1, self.channels), channel_prefix='ch%d_') else: logging.error('incorrect number of channels specified') self.c_ranges = ['1m'] * self.channels
def __init__(self, name, host='ip-address', port=9931, nchannels = 16): ''' Initialize qkit parameters and connect to the zerorpc server as a client. ''' Instrument.__init__(self, name, tags=['physical']) self.channels = nchannels self.add_parameter('voltage', type=float, flags=Instrument.FLAG_GETSET, units='V', channels=(0, self.channels-1), channel_prefix='ch%d_',minval=-5.,maxval=5) self.voltages = [0]*self.channels self.HOST, self.PORT = host, port self.init_connection()
def __init__(self, name, address, reference='external', model='ERASynth'): logging.info(__name__ + ' : Initializing instrument') Instrument.__init__(self, name) self._address = "tcp://" + address self._model = model self._statusdict = {} self._reference = reference self._rpc = zerorpc.Client() self._rpc.connect(self._address) # Implement parameters self.add_parameter('frequency', type=float, flags=Instrument.FLAG_GETSET, minval=250e3, maxval=15e9, units='Hz') self.add_parameter( 'power', type=float, flags=Instrument.FLAG_GETSET, minval=-60, maxval=20, # 15 dBm Typ, up to 20 depending on F units='dBm') self.add_parameter('status', type=bool, flags=Instrument.FLAG_GETSET) # Initialize parameter values self.get_all(True) # Set 10MHz reference and check for lock if external # (if no reference is attached or quality is bad, it will switch to internal OCXO) lockcount = 0 reference = _reference_class_conversion(reference) self.set_reference(ReferenceSource.OCXO) sleep(1) self.set_reference(reference) if reference == ReferenceSource.EXTERNAL: # Check if PLL has stable lock on external reference for _ in range(10): if self.get_diag()["lock_xtal"] == "1": lockcount += 1 if lockcount == 0: warnings.warn( "No Lock possible. Check your reference. Defaulted to OCXO." ) self.set_reference(ReferenceSource.OCXO) elif lockcount < 10: warnings.warn( "External reference unstable. Check for sufficient amplitude & accuracy. Defaulted to OCXO." ) self.set_reference(ReferenceSource.OCXO)
def __init__(self, name, address, reset=False): ''' Initializes the HP_81110A, and communicates with the wrapper. Input: name (string) : name of the instrument address (string) : GPIB address reset (bool) : resets to default values, default=false Output: None ''' Instrument.__init__(self, name, tags=['physical']) self._address = address self._visainstrument = visa.instrument(self._address) self._channels = self._get_number_of_channels() self.add_parameter('delay', type=float, flags=Instrument.FLAG_GETSET | Instrument.FLAG_GET_AFTER_SET, channels=(1, self._channels), minval=0.0, maxval=999, units='sec',channel_prefix='ch%d_') self.add_parameter('width', type=float, flags=Instrument.FLAG_GETSET | Instrument.FLAG_GET_AFTER_SET, channels=(1, self._channels), minval=-6.25e-9, maxval=999.5, units='sec',channel_prefix='ch%d_') self.add_parameter('high', type=float, flags=Instrument.FLAG_GETSET | Instrument.FLAG_GET_AFTER_SET, channels=(1, self._channels), minval=-9.90, maxval=10.0, units='Volts',channel_prefix='ch%d_') self.add_parameter('low', type=float, flags=Instrument.FLAG_GETSET | Instrument.FLAG_GET_AFTER_SET, channels=(1, self._channels), minval=-10.0, maxval=9.90, units='Volts',channel_prefix='ch%d_') self.add_parameter('status', type=str, channels=(1, self._channels), flags=Instrument.FLAG_GETSET | Instrument.FLAG_GET_AFTER_SET,channel_prefix='ch%d_') self.add_parameter('add_channels', type=str, flags=Instrument.FLAG_GETSET)# | Instrument.FLAG_GET_AFTER_SET) self.add_parameter('display', type=str, flags=Instrument.FLAG_GETSET | Instrument.FLAG_GET_AFTER_SET) self.add_parameter('frequency', type=float, flags=Instrument.FLAG_GETSET, units = 'Hz') self.add_function('reset') self.add_function('get_all') self.add_function('set_mode_triggered') self.add_function('set_mode_continuous') self.add_function('set_mode_gated') if reset: self.reset() else: self.get_all()
def __init__(self, name, address, reset=False): ''' Initializes the Keysight_E8267D, and communicates with the wrapper. Input: name (string) : name of the instrument address (string) : GPIB address reset (bool) : resets to default values, default=False ''' logging.info(__name__ + ' : Initializing instrument Keysight_E8267D') Instrument.__init__(self, name, tags=['physical']) # Add some global constants self._address = address self._visainstrument = visa.instrument(self._address) self.add_parameter('power', flags=Instrument.FLAG_GETSET, units='dBm', minval=-135, maxval=25, type=float) self.add_parameter('phase', flags=Instrument.FLAG_GETSET, units='rad', minval=-numpy.pi, maxval=numpy.pi, type=float) self.add_parameter('frequency', flags=Instrument.FLAG_GETSET, units='Hz', minval=1e5, maxval=13e9, type=float) self.add_parameter('status', flags=Instrument.FLAG_GETSET, type=bool) self.add_function('reset') self.add_function('get_all') if (reset): self.reset() else: self.get_all() print( 'this is a copy of the Agilent E8257D driver, thourough testing of this driver in combination with the Keysight E8267D has NOT been done! proceed with caution!' ) print( 'The max. output power and the frequency range depend on the order option of the Keysight E8267D! ' )
def __init__(self, name, address, port = 10001): ''' Initializes the Caen_fast_ps, and communicates with the wrapper. Input: name (string) : name of the instrument address (string) : GPIB address reset (bool) : resets to default values, default=False ''' logging.info(__name__ + ' : Initializing instrument Caen_fast_ps') Instrument.__init__(self, name, tags=['physical']) self._host = address self._port = port self._soc = socket.socket(socket.AF_INET,socket.SOCK_STREAM) self._soc.connect((self._host, self._port)) self._ak_str = '#AK' self.add_parameter('voltage', flags=Instrument.FLAG_GET, units='V', minval=-20, maxval=20, type=float) self.add_parameter('setvoltage', flags=Instrument.FLAG_GETSET, units='V', minval=-20, maxval=20, type=float) self.add_parameter('current', flags=Instrument.FLAG_GET, units='A', minval=-10, maxval=10, type=float) self.add_parameter('setcurrent', flags=Instrument.FLAG_GETSET, units='A', minval=-10, maxval=10, type=float) self.add_parameter('status', flags=Instrument.FLAG_GET, type=bool) self.add_parameter('output_mode', flags=Instrument.FLAG_GETSET, type=str) self.add_parameter('current_ramp_rate', flags=Instrument.FLAG_GETSET, units='A/s', minval=2e-4, maxval=10, type=float) self.add_parameter('voltage_ramp_rate', flags=Instrument.FLAG_GETSET, units='A/s', minval=-10, maxval=10, type=float) self.add_parameter('floating_mode', flags=Instrument.FLAG_GETSET, type=str) self.add_function('ramp_current') self.add_function('ramp_voltage') self.add_function('on') self.add_function('off')
def __init__(self, name, MAC, ip_host = '127.0.0.1', ip_port = 413, ip_timeout = 10.): ''' Initializes the Oxford Instruments Kelvinox IGH Dilution Refrigerator. Input: name (string) : name of the instrument MAC (string) : MAC address of the target device ip_host:ip_port : UDP interface address of an EthernetServer Output: None ''' logging.debug(__name__ + ' : Initializing instrument') Instrument.__init__(self, name, tags=['physical']) self.do_set_MAC(MAC) self._ip_host = ip_host self._ip_port = int(ip_port) self._ip_timeout = float(ip_timeout) # add parameters self.add_parameter('MAC', type=str, flags=Instrument.FLAG_GETSET) self.add_parameter('ip_host', type=str, flags=Instrument.FLAG_GET) self.add_parameter('ip_port', type=int, flags=Instrument.FLAG_GET) self.add_parameter('ip_timeout', type=float, flags=Instrument.FLAG_GETSET) self.add_parameter('rcvbuf', type=int, flags=Instrument.FLAG_GETSET) self.add_function('get_regfile') self.add_function('set_regfile') self.add_function('set_sram') self.add_function('get_all') self.add_function('seq_start') self.add_function('seq_stop') self.add_function('seq_single') self.add_function('seq_loop') # open sockets self._init_udp() # initialize hardware self._reg = None self.init_pll() self.init_dac(0, signed = True) self.init_dac(1, signed = True) # trigger register readback self._reg = None self.update_regfile() # update ui self.get_all()
def __init__(self, name, host='ip-address', port=9955): Instrument.__init__(self, name, tags=['physical']) self.add_parameter('condenser_pressure', type=types.FloatType, flags=Instrument.FLAG_GET, units='mbar') self.add_parameter('still_pressure', type=types.FloatType, flags=Instrument.FLAG_GET, units='mbar') self.HOST, self.PORT = host, port