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