def __init__(self, name, address, **kwargs): super().__init__(name, address, **kwargs) self.add_parameter('ref_osc_source', label='Reference oscillator source', get_cmd='SOUR:ROSC:SOUR?', set_cmd='SOUR:ROSC:SOUR {}', vals=vals.Enum('INT', 'EXT')) # Frequency mw_source outputs when used as a reference self.add_parameter('ref_osc_output_freq', label='Reference oscillator output frequency', get_cmd='SOUR:ROSC:OUTP:FREQ?', set_cmd='SOUR:ROSC:OUTP:FREQ {}', vals=vals.Enum('10MHz', '100MHz', '1000MHz')) # Frequency of the external reference mw_source uses self.add_parameter('ref_osc_external_freq', label='Reference oscillator external frequency', get_cmd='SOUR:ROSC:EXT:FREQ?', set_cmd='SOUR:ROSC:EXT:FREQ {}', vals=vals.Enum('10MHz', '100MHz', '1000MHz')) self.add_parameter('alc', get_cmd='POW:ALC?', set_cmd='POW:ALC {}', vals=vals.Enum('ON', 'OFF', 'AUTO')) # Output channels added to both the module for snapshots and internal output sources for use in queries self._source_outputs = {} for ch_name in ['RFOUT']: cur_channel = MWS_SGS100A_Channel(self, ch_name) self.add_submodule(ch_name, cur_channel) self._source_outputs[ch_name] = cur_channel
def __init__(self, parent, name): super().__init__(parent, name) self.add_parameter('output', label='Sync output state', set_cmd='OUTPut:SYNC {}', get_cmd='OUTPut:SYNC?', val_mapping={ 'ON': 1, 'OFF': 0 }, vals=vals.Enum('ON', 'OFF')) if parent.num_channels == 2: self.add_parameter('source', label='Source of sync function', set_cmd='OUTPut:SYNC:SOURce {}', get_cmd='OUTPut:SYNC:SOURce?', val_mapping={ 1: 'CH1', 2: 'CH2' }, vals=vals.Enum(1, 2))
def __init__(self, parent, name, portmap): ''' A microwave switch. Arguments: portmap: `dict` with `str`:`SwitchPort` items Port names and state objects of the switch. ''' super().__init__(parent, name) self.add_parameter('settle_time', ManualParameter, initial_value=10e-3, vals=vals.Numbers(0.5e-6, 1.), unit='s') self.add_parameter('route', docstring=''' Set a point-to-point connection on the switch. Route can be set to ROUTE_NONE or any port name to reset all ports but one and may return ROUTE_NONE, ROUTE_MULTIPLE or any port name. ''', get_cmd=self._get_route, set_cmd=self._set_route, vals=vals.Enum(None, self.ROUTE_NONE, *portmap.keys())) for port, pins in portmap.items(): self.add_parameter('{}_state'.format(port), SwitchPort, port=port, reset_pin=pins[0], set_pin=pins[1], vals=vals.Enum(True, False, None))
def add_marker_parameters(self): # Each (module, channel) separately for mod in self.modules: mod_name = 'mod{m}'.format(m=mod) mod_scpi = 'MODULE{m}'.format(m=mod) doc_source = 'Marker source of module {m}.'.format(m=mod) self.add_parameter(mod_name + '_marker_source', docstring=doc_source, get_cmd='MARKER:' + mod_scpi + ':SOURCE?', set_cmd='MARKER:' + mod_scpi + ':SOURCE {}', vals=validators.Enum('int', 'ext')) for channel in self.channels: mod_ch_name = 'mod{m}_ch{c}'.format(m=mod, c=channel) mod_ch_scpi = 'MODULE{m}:CHANNEL{c}'.format(m=mod, c=channel) doc_state = 'Marker state of module {m}, ' \ 'channel {c}.'.format(m=mod, c=channel) self.add_parameter(mod_ch_name + '_marker_state', docstring=doc_state, get_cmd='MARKER:' + mod_ch_scpi + ':STATE?', set_cmd='MARKER:' + mod_ch_scpi + ':STATE {}', vals=validators.OnOff()) # Marker breakout board self.add_parameter('mbbc_state', docstring='Whether the _marker breakout board_ is ' 'connected to the VSM.', get_cmd='MBBC?', vals=validators.Enum('connected', 'disconnected'))
def __init__(self, name, address, **kwargs): super().__init__(name, address, **kwargs) self.add_parameter(name='frequency', label='Frequency', unit='Hz', get_cmd='SOUR:FREQ' + '?', set_cmd='SOUR:FREQ' + ' {:.2f}', get_parser=float, vals=vals.Numbers(1e9, 20e9)) self.add_parameter(name='phase', label='Phase', unit='deg', get_cmd='SOUR:PHAS' + '?', set_cmd='SOUR:PHAS' + ' {:.2f}', get_parser=float, vals=vals.Numbers(0, 360)) self.add_parameter(name='power', label='Power', unit='dBm', get_cmd='SOUR:POW' + '?', set_cmd='SOUR:POW' + ' {:.2f}', get_parser=float, vals=vals.Numbers(-120, 25)) self.add_parameter('status', get_cmd=':OUTP:STAT?', set_cmd=self.set_status, get_parser=self.parse_on_off, vals=vals.Strings()) self.add_parameter('pulsemod_state', get_cmd=':SOUR:PULM:STAT?', set_cmd=self.set_pulsemod_state, get_parser=self.parse_on_off, vals=vals.Strings()) self.add_parameter('pulsemod_source', get_cmd='SOUR:PULM:SOUR?', set_cmd=self.set_pulsemod_source, vals=vals.Strings()) self.add_parameter('ref_osc_source', label='Reference oscillator source', get_cmd='SOUR:ROSC:SOUR?', set_cmd='SOUR:ROSC:SOUR {}', vals=vals.Enum('INT', 'EXT')) # Frequency mw_source outputs when used as a reference self.add_parameter('ref_osc_output_freq', label='Reference oscillator output frequency', get_cmd='SOUR:ROSC:OUTP:FREQ?', set_cmd='SOUR:ROSC:OUTP:FREQ {}', vals=vals.Enum('10MHz', '100MHz', '1000MHz')) # Frequency of the external reference mw_source uses self.add_parameter('ref_osc_external_freq', label='Reference oscillator external frequency', get_cmd='SOUR:ROSC:EXT:FREQ?', set_cmd='SOUR:ROSC:EXT:FREQ {}', vals=vals.Enum('10MHz', '100MHz', '1000MHz')) self.add_function('reset', call_cmd='*RST') self.add_function('run_self_tests', call_cmd='*TST?') self.connect_message()
def __init__(self, name, address, **kwargs): # supplying the terminator means you don't need to remove it from every response super().__init__(name, address, terminator='\r\n', **kwargs) self.add_parameter(name='status', label='Staus of supply(keep on to avoid offset)', vals=vals.Enum('on', 'off'), unit='NA', set_cmd='OP1 ' + '{:.12f}', get_cmd='OP1?', set_parser=self.easy_read_status, get_parser=self.easy_read_status_read) self.add_parameter( name='current_range', label= 'The output range; Low (500mA) range / High range. Note: Output needs to be switched off before changing ranges.', vals=vals.Enum('low', 'high'), unit='NA', set_cmd='IRANGE1 ' + '{:.12f}', get_cmd='IRANGE1?', set_parser=self.easy_read_Irange, get_parser=self.easy_read_Irange_read) self.add_parameter(name='current_step', label='Output current step size.', vals=vals.Numbers(0.1, 10), unit='mA', set_cmd='DELTAI1 ' + '{:.12f}', get_cmd='DELTAI1?', set_parser=self.mA_to_A, get_parser=self.A_to_mA) self.add_parameter(name='current_change', label='Increase/decrease current by one step size.', vals=vals.Enum('up', 'down'), unit='int', set_cmd='{}', set_parser=self.current_up_down) self.add_parameter(name='current', label='Set output currents in mA.', vals=vals.Numbers(-100, 100), unit='mA', set_cmd='I1 ' + '{:.12f}', get_cmd='I1?', set_parser=self.mA_to_A, get_parser=self.A_to_mA_with_parity) # good idea to call connect_message at the end of your constructor. # this calls the 'IDN' parameter that the base Instrument class creates # for every instrument which serves two purposes: # 1) verifies that you are connected to the instrument # 2) gets the ID info so it will be included with metadata snapshots later. self.connect_message()
def __init__(self, name, address, silent=False, **kwargs): """ Args: name (string): The name of the instrument used internally by QCoDeS. Must be unique. address (string): The VISA resource name. silent (Optional[bool]): If True, no connect message is printed. """ warnings.warn( "This driver is old and will be removed " "from QCoDeS soon. Please use the " "WaveformGenerator_33XXX from the file " "instrument_drivers/Keysight/KeysightAgilent_33XXX" " instead.", UserWarning) super().__init__(name, address, **kwargs) channels = ChannelList(self, "Channels", KeysightChannel, snapshotable=False) for i in range(1, 3): channel = KeysightChannel(self, 'ch{}'.format(i), i) channels.append(channel) channels.lock() self.add_submodule('channels', channels) self.add_parameter('sync_source', label='Source of sync function', set_cmd='OUTPut:SYNC:SOURce {}', get_cmd='OUTPut:SYNC:SOURce?', val_mapping={ 1: 'CH1', 2: 'CH2' }, vals=vals.Enum(1, 2)) self.add_parameter('sync_output', label='Sync output state', set_cmd='OUTPut:SYNC {}', get_cmd='OUTPut:SYNC?', val_mapping={ 'ON': 1, 'OFF': 0 }, vals=vals.Enum('ON', 'OFF')) self.add_function('force_trigger', call_cmd='*TRG') self.add_function('sync_channel_phases', call_cmd='PHAS:SYNC') if not silent: self.connect_message()
def __init__(self, name, address, step_attenuator=False, **kwargs): super().__init__(name, address, **kwargs) self.add_parameter(name='frequency', label='Frequency', unit='Hz', get_cmd='FREQ:CW?', set_cmd='FREQ:CW' + ' {:.4f}', get_parser=float, set_parser=float, vals=vals.Numbers(1e5, 20e9)) self.add_parameter(name='phase', label='Phase', unit='deg', get_cmd='PHASE?', set_cmd='PHASE' + ' {:.8f}', get_parser=self.rad_to_deg, set_parser=self.deg_to_rad, vals=vals.Numbers(-180, 180)) min_power = -135 if step_attenuator else -20 self.add_parameter(name='power', label='Power', unit='dBm', get_cmd='POW:AMPL?', set_cmd='POW:AMPL' + ' {:.4f}', get_parser=float, set_parser=float, vals=vals.Numbers(min_power, 16)) self.add_parameter( 'status', get_cmd=':OUTP?', set_cmd='OUTP {}', get_parser=self.parse_on_off, # Only listed most common spellings idealy want a # .upper val for Enum or string vals=vals.Enum('on', 'On', 'ON', 'off', 'Off', 'OFF')) self.add_parameter( 'pulsemod_state', get_cmd=':OUTP:MOD?', set_cmd='OUTP:MOD {}', get_parser=self.parse_on_off, # Only listed most common spellings idealy want a # .upper val for Enum or string vals=vals.Enum('on', 'On', 'ON', 'off', 'Off', 'OFF')) self.add_parameter('pulsemod_source', get_cmd=':PULM:SOURce?', set_cmd='PULM:SOURce {}', get_parser=self.pulsemod_source_parser, vals=vals.Enum('ext', 'Ext', 'EXT', 'int', 'Int', 'INT', 'scal', 'Scal', 'SCAL')) self.connect_message()
def __init__(self, name, address, **kwargs): super().__init__(name, **kwargs) self.add_parameter(name='frequency', label='Frequency', unit='Hz', parameter_class=ManualParameter, get_parser=float, vals=vals.Numbers(1e6, 20e9)) self.add_parameter(name='phase', label='Phase', unit='deg', parameter_class=ManualParameter, get_parser=float, vals=vals.Numbers(0, 360)) self.add_parameter(name='power', label='Power', unit='dBm', parameter_class=ManualParameter, get_parser=float, vals=vals.Numbers(-120, 25)) self.add_parameter('status', parameter_class=ManualParameter, get_parser=self.parse_on_off, vals=vals.Strings()) self.add_parameter('pulsemod_state', parameter_class=ManualParameter, get_parser=self.parse_on_off, vals=vals.Strings()) self.add_parameter('pulsemod_source', parameter_class=ManualParameter, vals=vals.Strings()) self.add_parameter('ref_osc_source', label='Reference oscillator source', parameter_class=ManualParameter, vals=vals.Enum('INT', 'EXT')) # Frequency mw_source outputs when used as a reference self.add_parameter('ref_osc_output_freq', label='Reference oscillator output frequency', parameter_class=ManualParameter, vals=vals.Enum('10MHz', '100MHz', '1000MHz')) # Frequency of the external reference mw_source uses self.add_parameter('ref_osc_external_freq', label='Reference oscillator external frequency', parameter_class=ManualParameter, vals=vals.Enum('10MHz', '100MHz', '1000MHz')) self.add_function('reset', call_cmd='*RST') self.add_function('run_self_tests', call_cmd='*TST?') self.connect_message()
def __init__(self, name, address, num_channels, **kwargs): super().__init__(name, address, **kwargs) self.max_current = _RohdeSchwarzHMC804x._max_currents[num_channels] self.add_parameter('state', label='Output enabled', set_cmd='OUTPut:MASTer:STATe {}', get_cmd='OUTPut:MASTer:STATe?', val_mapping={ 'ON': 1, 'OFF': 0 }, vals=vals.Enum('ON', 'OFF')) # channel-specific parameters channels = ChannelList(self, "SupplyChannel", RohdeSchwarzHMC804xChannel, snapshotable=False) for ch_num in range(1, num_channels + 1): ch_name = "ch{}".format(ch_num) channel = RohdeSchwarzHMC804xChannel(self, ch_name, ch_num) channels.append(channel) self.add_submodule(ch_name, channel) channels.lock() self.add_submodule("channels", channels) # add bipolar virtual channel 1/2 bip = RohdeSchwarzHMC804xBIP(self, 'bip', self.ch1, self.ch2) self.add_submodule("bip", bip) self.connect_message()
def __init__(self, parent, name, cs, rs, fault, portmap): ''' Arguments: cs: `int` H-bridge chip select pin rs: `int` H-bridge reset pin fault: `tuple` of `int` H-bridge fault pin(s) portmap: `dict` with `str`:(`BridgeChannel`, `BridgeChannel`) items H-bridge input and enable pins for the anode and cathode of each switch channel. ''' super().__init__(parent, name) self.pin_rs = rs self.pin_cs = cs self.pins_fault = fault self.portmap = portmap self.add_parameter('settle_time', ManualParameter, initial_value=10e-3, vals=vals.Numbers(0.5e-6, 1.), unit='s') for port in self.portmap.keys(): self.add_parameter('{}_state'.format(port), CryoSwitchPort, port=port, vals=vals.Enum(True, False, None)) self.initialize()
def __init__(self, name: str, address: str, num_channels: int, **kwargs: Any) -> None: super().__init__(name, address, **kwargs) self.max_current = _RohdeSchwarzHMC804x._max_currents[num_channels] self.add_parameter('state', label='Output enabled', set_cmd='OUTPut:MASTer:STATe {}', get_cmd='OUTPut:MASTer:STATe?', val_mapping={ 'ON': 1, 'OFF': 0 }, vals=vals.Enum('ON', 'OFF')) # channel-specific parameters channels = ChannelList(self, "SupplyChannel", RohdeSchwarzHMC804xChannel, snapshotable=False) for ch_num in range(1, num_channels + 1): ch_name = f"ch{ch_num}" channel = RohdeSchwarzHMC804xChannel(self, ch_name, ch_num) channels.append(channel) self.add_submodule(ch_name, channel) self.add_submodule("channels", channels.to_channel_tuple()) self.connect_message()
def __init__(self, parent: Instrument, name: str, **kwargs): super().__init__(parent, name, **kwargs) self.add_parameter( 'decimation', ManualParameter, vals=vals.Ints(1), initial_value=1, docstring='The sample rate is reduced by the decimation factor ' 'after filtering.') self.add_parameter('coefficients', ManualParameter, vals=vals.Arrays(), docstring='FIR filter coefficients') self.add_parameter('description', ManualParameter, vals=vals.Strings(), docstring='FIR filter description') self.add_parameter( 'mode', ManualParameter, vals=vals.Enum('full', 'valid'), initial_value='full', docstring='Convolution mode. If `valid`, only points where the ' 'filter and signal overlap completely are returned.') self.coefficients.set(np.array([1.]))
def __init__(self, name, address, **kwargs): super().__init__(name, address, terminator='', **kwargs) # Turns low frequency signal on/off (expects either 1 (on) or 0 (off)) self.add_parameter('LFOutputState', set_cmd='LFO:STAT {:1.0f}', get_cmd='LFO:STAT?', vals=vals.Enum(*np.arange(0, 1.1, 1).tolist()), get_parser=int) # Sets the low frequency output frequency self.add_parameter('LFOutputFrequency', unit='Hz', set_cmd='LFO:FREQ {:.1f} Hz', get_cmd='LFO:FREQ?', get_parser=float) # Sets the low frequency output amplitude self.add_parameter('LFOutputAmplitude', unit='V', set_cmd='LFO:AMPL {:.3f} V', get_cmd='LFO:AMPL?', get_parser=float) # Connect to the instrument and get an IDN self.connect_message()
def __init__(self, name, address, model_no, **kwargs): super().__init__(name, address, terminator="\n", **kwargs) self.model_no = model_no self.add_parameter('state', label='Output enabled', set_cmd='OUTPut:GENeral {}', get_cmd='OUTPut:GENeral?', val_mapping={ 'ON': 1, 'OFF': 0 }, vals=vals.Enum('ON', 'OFF')) # number of channels can be calculated from model number num_channels = (self.model_no % 100) // 10 # channel-specific parameters channels = ChannelList(self, "SupplyChannel", RohdeSchwarzHMPChannel, snapshotable=False) for ch_num in range(1, num_channels + 1): ch_name = "ch{}".format(ch_num) channel = RohdeSchwarzHMPChannel(self, ch_name, ch_num) channels.append(channel) self.add_submodule(ch_name, channel) channels.lock() self.add_submodule("channels", channels) self.connect_message()
def __init__(self, parent: 'ANC300', name: str, num: int) -> None: """The Attocube ANC300 piezo controller has three trigger outputs. This function cannot be tested because this function belongs to a specific controller feature code. This code was not available during the tests. Args: parent: the internal QCoDeS name of the instrument this output belongs to name: the internal QCoDeS name of the output itself num: the Index of the trigger output Attributes: state: Set / get the state of the output """ super().__init__(parent, name) self.add_parameter('state', label='Set/get trigger output level', get_cmd='getto {}'.format(num), set_cmd='setto {}'.format(num) + ' {}', val_mapping={ 'off': 0, 'on': 1 }, vals=vals.Enum('off', 'on'), docstring="Sets the trigger output signal")
def __init__(self, parent: Union[VisaInstrument, InstrumentChannel], name: str, slot: int) -> None: super().__init__(parent, name, slot) self.add_parameter(name='protection_mode', get_cmd=self._get_relay_protection_mode, set_cmd=self._set_relay_protection_mode, vals=validators.Enum('AUTO100', 'AUTO0', 'FIX', 'ISO'), docstring='get and set the relay protection mode.' 'The fastest switching speeds for relays' 'in a given signal path are achieved using' 'the FIXed or ISOlated modes, followed' 'by the AUTO100 and AUTO0 modes.' 'There may be a maximum of 200 Ohm of' 'resistance, which can only be bypassed' 'by "AUTO0" mode. See manual and' 'programmer' 's reference for detail.') layout = self.ask(f'SYSTEM:MODule:TERMinal:TYPE? {self.slot}') self._is_locked = (layout == 'NONE') if self._is_locked: logging.warning(f'For slot {slot}, no configuration module' f'connected, or safety interlock jumper removed. ' "Making any connection is not allowed") config = self.ask(f'SYST:CTYP? {slot}').strip('"').split(',')[1] layout = config.split('-')[1] self.row, self.column = [ int(num) for num in re.findall(r'\d+', layout) ]
def __init__(self, parent, name, channel): super().__init__(parent, name) self.add_parameter('scale', label='Channel {} Scale'.format(channel), unit='V/div', get_cmd='CH{}:SCAle?'.format(channel), set_cmd='CH{}:SCAle {}'.format(channel, '{}'), get_parser=float) self.add_parameter('position', label='Channel {} Position'.format(channel), unit='div', get_cmd='CH{}:POSition?'.format(channel), set_cmd='CH{}:POSition {}'.format(channel, '{}'), get_parser=float) self.add_parameter( 'curvedata', channel=channel, parameter_class=ScopeArray, ) self.add_parameter('state', label='Channel {} display state'.format(channel), set_cmd='SELect:CH{} {}'.format(channel, '{}'), get_cmd=partial(self._get_state, channel), val_mapping={ 'ON': 1, 'OFF': 0 }, vals=vals.Enum('ON', 'OFF'))
def __init__(self, instrument_name, **kwargs): super().__init__(instrument_name, **kwargs) self._output_channels = { f'ch{ch}': Channel(instrument_name=self.instrument_name(), name=f'ch{ch}', id=ch, output=True) for ch in self.instrument.channel_idxs} self._pxi_channels = { f'pxi{k}': Channel(instrument_name=self.instrument_name(), name=f'pxi{k}', id=4000 + k, input_trigger=True, output=True, input=True) for k in range(self.instrument.n_triggers)} self._channels = { **self._output_channels, **self._pxi_channels, 'trig_in': Channel(instrument_name=self.instrument_name(), name='trig_in', input_trigger=True, input_TTL=(0, 5.0)), 'trig_out': Channel(instrument_name=self.instrument_name(), name='trig_out', output_TTL=(0, 3.3))} self.pulse_implementations = [ # TODO fix sinepulseimplementation by using pulse_to_waveform_sequence SinePulseImplementation( pulse_requirements=[('frequency', {'min': 0, 'max': 200e6}), ('amplitude', {'max': 1.5})]), AWGPulseImplementation( pulse_requirements=[]), CombinationPulseImplementation( pulse_requirements=[]), DCPulseImplementation( pulse_requirements=[('amplitude', {'min': -1.5, 'max': 1.5})]), DCRampPulseImplementation( pulse_requirements=[]), TriggerPulseImplementation( pulse_requirements=[]), MarkerPulseImplementation( pulse_requirements=[]) ] self.add_parameter('channel_selection', vals=vals.Lists(), get_cmd=self._get_active_channel_names) self.add_parameter('default_sampling_rates', set_cmd=None, initial_value=[500e6] * len(self.instrument.channel_idxs)) self.add_parameter('trigger_mode', set_cmd=None, initial_value='software', vals=vals.Enum('none', 'hardware', 'software'), docstring='Selects the method to run through the AWG queue.') self.trigger_thread = None self.waveforms = None self.waveform_queue = None self.started = False
def __init__(self, parent, name, channel): super().__init__(parent, name) self.channel = channel self.max_current = self.get_max_current() self._scpi_commands = { "set_voltage": "SOURce:VOLTage:LEVel:IMMediate:AMPLitude", "set_current": "SOURce:CURRent:LEVel:IMMediate:AMPLitude", "state": "OUTPut:STATe", "voltage": "MEASure:SCALar:VOLTage:DC", "current": "MEASure:SCALar:CURRent:DC" } self.add_parameter("set_voltage", label='Target voltage output', set_cmd=partial(self.send_cmd, "set_voltage"), get_cmd=partial(self.send_cmd, "set_voltage", None), get_parser=float, unit='V', vals=vals.Numbers(0, 32.050)) self.add_parameter("set_current", label='Target current output', set_cmd=partial(self.send_cmd, "set_current"), get_cmd=partial(self.send_cmd, "set_current", None), get_parser=float, unit='A', vals=vals.Numbers(0.5e-3, self.max_current)) self.add_parameter('state', label='Output enabled', set_cmd=partial(self.send_cmd, "state"), get_cmd=partial(self.send_cmd, "state", None), val_mapping={ 'ON': 1, 'OFF': 0 }, vals=vals.Enum('ON', 'OFF')) self.add_parameter( "voltage", label='Measured voltage', get_cmd=partial(self.send_cmd, "voltage", None), get_parser=float, unit='V', ) self.add_parameter( "current", label='Measured current', get_cmd=partial(self.send_cmd, "current", None), get_parser=float, unit='A', ) self.add_parameter( "power", label='Measured power', get_cmd=self._get_power, get_parser=float, unit='W', )
def __init__(self, name: str, transport: Transport) -> None: super().__init__(name, transport) # calls CCCore Instrument.__init__(self, name) # calls Instrument # validator values self._dev_desc.mvals_trigger_impedance = vals.Enum(50), self._dev_desc.mvals_trigger_level = vals.Numbers(0, 5.0) self._add_parameters()
def __init__(self, parent: 'DG1062', name: str, channel: int) -> None: super().__init__(parent, name) self.channel = channel self.add_parameter("on", get_cmd=f":SOUR{channel}:BURS?", set_cmd=f":SOUR{channel}:BURS {{}}", vals=vals.Enum(0, 1, "ON", "OFF")) self.add_parameter("polarity", get_cmd=f":SOUR{channel}:BURS:GATE:POL?", set_cmd=f":SOUR{channel}:BURS:GATE:POL {{}}", vals=vals.Enum("NORM", "INV")) self.add_parameter("period", get_cmd=f":SOUR{channel}:BURS:INT:PER?", set_cmd=f":SOUR{channel}:BURS:INT:PER {{}}", vals=vals.MultiType( vals.Numbers(min_value=3E-6, max_value=500), vals.Enum("MIN", "MAX"))) self.add_parameter("mode", get_cmd=f":SOUR{channel}:BURS:MODE?", set_cmd=f":SOUR{channel}:BURS:MODE {{}}", vals=vals.Enum("TRIG", "INF", "GAT")) self.add_parameter("ncycles", get_cmd=f":SOUR{channel}:BURS:NCYC?", set_cmd=f":SOUR{channel}:BURS:NCYC {{}}", vals=vals.Numbers(min_value=1, max_value=500000)) self.add_parameter("phase", get_cmd=f":SOUR{channel}:BURS:PHAS?", set_cmd=f":SOUR{channel}:BURS:PHAS {{}}", vals=vals.Numbers(min_value=0, max_value=360)) self.add_parameter("time_delay", get_cmd=f":SOUR{channel}:BURS:TDEL?", set_cmd=f":SOUR{channel}:BURS:TDEL {{}}", vals=vals.Numbers(min_value=0)) self.add_parameter("trigger_slope", get_cmd=f":SOUR{channel}:BURS:TRIG:SLOP?", set_cmd=f":SOUR{channel}:BURS:TRIG:SLOP {{}}", vals=vals.Enum("POS", "NEG")) self.add_parameter("source", get_cmd=f":SOUR{channel}:BURS:TRIG:SOUR?", set_cmd=f":SOUR{channel}:BURS:TRIG:SOUR {{}}", vals=vals.Enum("INT", "EXT", "MAN")) self.add_parameter( "idle", get_cmd=f":SOUR{channel}:BURST:IDLE?", set_cmd=f":SOUR{channel}:BURST:IDLE {{}}", vals=vals.MultiType( vals.Enum("FPT", "TOP", "BOTTOM", "CENTER"), vals.Numbers() # DIY ))
def __init__(self, name, address=None, **kwargs): super().__init__(name, **kwargs) self.add_parameter(name='frequency', label='Frequency', unit='Hz', parameter_class=ManualParameter, vals=vals.Numbers(1e6, 20e9)) self.add_parameter(name='phase', label='Phase', unit='deg', parameter_class=ManualParameter, vals=vals.Numbers(0, 360)) self.add_parameter(name='power', label='Power', unit='dBm', parameter_class=ManualParameter, vals=vals.Numbers(-120, 25)) self.add_parameter('status', parameter_class=ManualParameter, vals=vals.Strings()) self.add_parameter('pulsemod_state', parameter_class=ManualParameter, vals=vals.Strings()) self.add_parameter('pulsemod_source', parameter_class=ManualParameter, vals=vals.Strings()) self.add_parameter('ref_osc_source', label='Reference oscillator source', parameter_class=ManualParameter, vals=vals.Enum('INT', 'EXT')) # Frequency it outputs when used as a reference self.add_parameter('ref_osc_output_freq', label='Reference oscillator output frequency', parameter_class=ManualParameter, vals=vals.Enum('10MHz', '100MHz', '1000MHz')) # Frequency of the external reference it uses self.add_parameter('ref_osc_external_freq', label='Reference oscillator external frequency', parameter_class=ManualParameter, vals=vals.Enum('10MHz', '100MHz', '1000MHz')) self.connect_message()
def __init__(self, parent, name, channel): super().__init__(parent, name) select_cmd = ":INSTrument:NSELect {};".format(channel) self.add_parameter("set_voltage", label='Target voltage output', set_cmd="{} :SOURce:VOLTage:LEVel:IMMediate:AMPLitude {}".format( select_cmd, '{}'), get_cmd="{} :SOURce:VOLTage:LEVel:IMMediate:AMPLitude?".format( select_cmd), get_parser=float, unit='V', vals=vals.Numbers(0, 32.050) ) self.add_parameter("set_current", label='Target current output', set_cmd="{} :SOURce:CURRent:LEVel:IMMediate:AMPLitude {}".format( select_cmd, '{}'), get_cmd="{} :SOURce:CURRent:LEVel:IMMediate:AMPLitude?".format( select_cmd), get_parser=float, unit='A', vals=vals.Numbers(0.5e-3, self._parent.max_current) ) self.add_parameter('state', label='Output enabled', set_cmd='{} :OUTPut:CHANnel:STATe {}'.format(select_cmd, '{}'), get_cmd='{} :OUTPut:CHANnel:STATe?'.format(select_cmd), val_mapping={'ON': 1, 'OFF': 0}, vals=vals.Enum('ON', 'OFF') ) self.add_parameter("voltage", label='Measured voltage', get_cmd="{} :MEASure:SCALar:VOLTage:DC?".format( select_cmd), get_parser=float, unit='V', ) self.add_parameter("current", label='Measured current', get_cmd="{} :MEASure:SCALar:CURRent:DC?".format( select_cmd), get_parser=float, unit='A', ) self.add_parameter("power", label='Measured power', get_cmd="{} :MEASure:SCALar:POWer?".format( select_cmd), get_parser=float, unit='W', )
def __init__(self, name, address, **kwargs): super().__init__(name, address, terminator="\r\n", **kwargs) self._MODES = { 'dc_volts': 1, 'ac_volts': 2, '2_wire_res': 3, '4_wire_res': 4, 'dc_current': 5, 'ac_current': 6, 'extended_res': 7, } self._RANGES = [-2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 'A'] self._NPLC = { 0.1: 1, 1: 2, 10: 3, } self.add_parameter( 'mode', # get_cmd=None, set_cmd=self._set_mode, val_mapping=self._MODES, docstring='Selects the input mode') self.add_parameter( 'range', # get_cmd=None, set_cmd=self._set_range, vals=vals.Enum(*self._RANGES), docstring=('Sets the measurement range.\n' 'Note that not only a discrete set of ' 'ranges can be set (see the manual for ' 'details).')) self.add_parameter( 'nplc', # get_cmd=None, set_cmd='N{:d}', val_mapping=self._NPLC, unit='APER', docstring=('Get integration time in Number of ' 'PowerLine Cycles.\n' 'To get the integrationtime in seconds, ' 'use get_integrationtime().')) self.add_parameter( 'fetch', get_cmd=self._get_reading, docstring=('Get most recent reading. Try to get the units right.'))
def __init__(self, name, address, **kwargs): super().__init__(name, address, terminator="\r\n", **kwargs) # self._MODES = { # 'dc_volts': 1, # 'dc_current': 5, # } self._VOLT_RANGES = { '10mV': 2, '100mV': 3, '1V': 4, '10V': 5, '100V': 6, } self._CURR_RANGES = { '1mA': 4, '10mA': 5, '100mA': 6, } self._ranges = list(self._VOLT_RANGES.keys()) + list( self._CURR_RANGES.keys()) # self.add_parameter( # 'mode', # get_cmd=self._get_mode, # set_cmd=self._set_mode, # val_mapping=self._MODES, # docstring='Selects the input mode' # ) self.add_parameter('range', get_cmd=self._get_range, set_cmd=self._set_range, vals=vals.Enum(*self._ranges), docstring=('Sets the measurement range.\n' 'Note that not only a discrete set of ' 'ranges can be set (see the manual for ' 'details).')) self.add_parameter('output', get_cmd=self._get_output, set_cmd=self._set_output, val_mapping=create_on_off_val_mapping(on_val=1, off_val=0)) self.add_parameter( 'source', set_cmd=self._set_value, get_cmd=self._get_value, )
def __init__(self, parent: Instrument, name: str, channel: Union[str, int]) -> None: super().__init__(parent, name) select_cmd = f":INSTrument:NSELect {channel};" voltage_amp = ":SOURce:VOLTage:LEVel:IMMediate:AMPLitude" current_amp = ":SOURce:CURRent:LEVel:IMMediate:AMPLitude" self.add_parameter("set_voltage", label='Target voltage output', set_cmd=f"{select_cmd} {voltage_amp} {{}}", get_cmd=f"{select_cmd} {voltage_amp}?", get_parser=float, unit='V', vals=vals.Numbers(0, 32.050)) self.add_parameter("set_current", label='Target current output', set_cmd=f"{select_cmd} {current_amp} {{}}", get_cmd=f"{select_cmd} {current_amp}?", get_parser=float, unit='A', vals=vals.Numbers(0.5e-3, self._parent.max_current)) self.add_parameter('state', label='Output enabled', set_cmd=f'{select_cmd} :OUTPut:CHANnel:STATe {{}}', get_cmd=f'{select_cmd} :OUTPut:CHANnel:STATe?', val_mapping={ 'ON': 1, 'OFF': 0 }, vals=vals.Enum('ON', 'OFF')) self.add_parameter( "voltage", label='Measured voltage', get_cmd=f"{select_cmd} :MEASure:SCALar:VOLTage:DC?", get_parser=float, unit='V', ) self.add_parameter( "current", label='Measured current', get_cmd=f"{select_cmd} :MEASure:SCALar:CURRent:DC?", get_parser=float, unit='A', ) self.add_parameter( "power", label='Measured power', get_cmd=f"{select_cmd} :MEASure:SCALar:POWer?", get_parser=float, unit='W', )
def __init__(self, name, address, **kwargs): super().__init__(name, address, **kwargs) # #A 10ns output SYNC # self.add_submodule('SYNC', SyncTriggerPulse(10e-9, lambda : True, lambda x:x)) self._num_samples = 10 self._sample_rate = 10e9 self._trigger_edge = 1 self.add_parameter('AWG_run_state', label='Output state', docstring='State of the output (ON or OFF).', get_cmd='AWGControl:RSTate?', set_parser=int, val_mapping={'AWG has stopped': 0, 'AWG is waiting for trigger': 1, 'AWG is running' : 2}) self.add_parameter('run_mode', get_cmd='AWGControl:RMODe?', set_cmd='AWGControl:RMODe {}', vals=vals.Enum('CONT', 'TRIG', 'SEQ', 'GAT')) self.add_parameter('clock_source', label='Clock source', get_cmd='AWGControl:CLOCk:SOURce?', set_cmd='AWGControl:CLOCk:SOURce {}', vals=vals.Enum('INT', 'EXT')) self.add_parameter('ref_clock_source', label='Reference clock source', get_cmd='SOURce1:ROSCillator:SOURce?', set_cmd='SOURce1:ROSCillator:SOURce ' + '{}', vals=vals.Enum('INT', 'EXT')) # Output channels added to both the module for snapshots and internal Trigger Sources for the DDG HAL... self._ch_list = ['CH1', 'CH2', 'CH3', 'CH4'] for ch_ind, ch_name in enumerate(self._ch_list): cur_channel = AWG5014Cchannel(self, ch_name, ch_ind+1) self.add_submodule(ch_name, cur_channel)
def __init__(self, parent: Instrument, name: str, **kwargs): super().__init__(parent, name, **kwargs) self.add_parameter( 'markers', ManualParameter, vals=vals.Ints(0, 2), default_value=0, docstring='Number of bits of digital data per sample.') self.add_parameter( 'out_dtype', ManualParameter, default_value=np.float32, vals=vals.Enum(np.float16, np.float32, np.float64), docstring='Output floating point type for analog data.') self.markers.set(0) self.out_dtype.set(np.float32)
def __init__(self, name, address, port, **kwargs): super().__init__(name, address, port, **kwargs) # AWG properties self.device_descriptor = type('', (), {})() self.device_descriptor.model = 'QWG' self.device_descriptor.numChannels = 4 self.device_descriptor.numDacBits = 12 self.device_descriptor.numMarkersPerChannel = 2 self.device_descriptor.numMarkers = 8 self.device_descriptor.numTriggers = 14 self._nr_cw_bits_cmd = "SYSTem:CODEwords:BITs?" self.device_descriptor.numMaxCwBits = int( self.ask(self._nr_cw_bits_cmd)) self._nr_cw_inp_cmd = "SYSTem:CODEwords:SELect?" self.device_descriptor.numSelectCwInputs = int( self.ask(self._nr_cw_inp_cmd)) self.device_descriptor.numCodewords = pow( 2, self.device_descriptor.numSelectCwInputs) # valid values self.device_descriptor.mvals_trigger_impedance = vals.Enum(50), self.device_descriptor.mvals_trigger_level = vals.Numbers(0, 5.0) cw_protocol_mt = { # Name Ch1, Ch2, Ch3, Ch4 'FLUX': [0x5F, 0x5F, 0x5F, 0x5F], 'MICROWAVE': [0x5F, 0x5F, 0x5F, 0x5F] } cw_protocol_dio = { # Name Ch1, Ch2, Ch3, Ch4 'FLUX': [0x07, 0x38, 0x1C0, 0xE00], 'MICROWAVE': [0x3FF, 0x3FF, 0x3FF, 0x3FF] } if self.device_descriptor.numMaxCwBits <= 7: self.codeword_protocols = cw_protocol_mt else: self.codeword_protocols = cw_protocol_dio # FIXME: not in [V] self.add_parameters() self.connect_message()