def test_valid_values(self):
ms = [MultiType(Strings(2, 4), Ints(10, 32)),
MultiType(Ints(), Lists(Ints())),
MultiType(Ints(), MultiType(Lists(Ints()), Ints()))]
for m in ms:
for val in m.valid_values:
m.validate(val)
def test_valid_values():
# combiner == 'OR'
ms = [
MultiType(Strings(2, 4), Ints(10, 32)),
MultiType(Ints(), Lists(Ints())),
MultiType(Ints(), MultiType(Lists(Ints()), Ints()))
]
for m in ms:
for val in m.valid_values:
m.validate(val)
def __init__(self, instrument_name, **kwargs):
super().__init__(instrument_name, **kwargs)
self._output_channels = {
f'ch{k}': Channel(instrument_name=self.instrument_name(),
name=f'ch{k}',
id=k,
output=True)
for k in [1, 2]
}
self._channels = {
**self._output_channels, 'trig_in':
Channel(instrument_name=self.instrument_name(),
name='trig_in',
input_trigger=True)
}
self.pulse_implementations = [
DCPulseImplementation(pulse_requirements=[('amplitude', {
'min': -1,
'max': 1
})]),
SinePulseImplementation(pulse_requirements=[('frequency', {
'max': 500e6
}), ('amplitude', {
'min': -1,
'max': 1
})])
]
self.add_parameter(
'pulse_final_delay',
unit='s',
set_cmd=None,
initial_value=.1e-6,
docstring='Time subtracted from each waveform to ensure '
'that it is finished once next trigger arrives.')
self.add_parameter('trigger_in_duration',
unit='s',
set_cmd=None,
initial_value=.1e-6)
self.add_parameter('active_channels',
set_cmd=None,
vals=Lists(Enum('ch1', 'ch2')))
self.add_parameter('sampling_rate',
unit='1/s',
initial_value=1e9,
set_cmd=None,
vals=Numbers(max_value=1e9))
self.waveforms = {}
self.waveform_filenames = {}
self.sequence = {}
# Create silq folder to place waveforms and sequences in
self.instrument.change_folder('/silq', create_if_necessary=True)
# Delete all files in folder
self.instrument.delete_all_files()
def __init__(
self,
parent: 'Keithley2450',
name: str,
size: Optional[int] = None,
style: str = ''
) -> None:
super().__init__(parent, name)
self.buffer_name = name
self._size = size
self.style = style
if self.buffer_name not in self.default_buffer:
# when making a new buffer, the "size" parameter is required.
if size is None:
raise TypeError(
"buffer() missing 1 required positional argument: 'size'"
)
self.write(
f":TRACe:MAKE '{self.buffer_name}', {self._size}, {self.style}"
)
else:
# when referring to default buffer, "size" parameter is not needed.
if size is not None:
self.log.warning(
f"Please use method 'size()' to resize default buffer "
f"{self.buffer_name} size to {self._size}."
)
self.add_parameter(
"size",
get_cmd=f":TRACe:POINts? '{self.buffer_name}'",
set_cmd=f":TRACe:POINts {{}}, '{self.buffer_name}'",
get_parser=int,
docstring="The number of readings a buffer can store."
)
self.add_parameter(
"number_of_readings",
get_cmd=f":TRACe:ACTual? '{self.buffer_name}'",
get_parser=int,
docstring="To get the number of readings in the reading buffer."
)
self.add_parameter(
"elements",
get_cmd=None,
get_parser=self.from_scpi_to_name,
set_cmd=None,
set_parser=self.from_name_to_scpi,
vals=Lists(Enum(*list(self.buffer_elements.keys()))),
docstring="List of buffer elements to read."
)
def test_type():
l = Lists()
v1 = ['a', 'b', 5]
l.validate(v1)
v2 = 234
with pytest.raises(TypeError):
l.validate(v2)
def test_elt_vals():
l = Lists(Ints(max_value=10))
v1 = [0, 1, 5]
l.validate(v1)
v2 = [0, 1, 11]
with pytest.raises(ValueError):
l.validate(v2)
def test_elt_vals(self):
l = Lists(Ints(max_value=10))
v1 = [0, 1, 5]
l.validate(v1)
v2 = [0, 1, 11]
with self.assertRaises(ValueError):
l.validate(v2)
def test_type(self):
l = Lists()
v1 = ['a', 'b', 5]
l.validate(v1)
v2 = 234
with self.assertRaises(TypeError):
l.validate(v2)
def __init__(
self,
parent: 'Keithley7510',
name: str,
size: Optional[int] = None,
style: str = ''
) -> None:
super().__init__(parent, name)
self._size = size
self.style = style
if self.short_name not in self.default_buffer:
# when making a new buffer, the "size" parameter is required.
if size is None:
raise TypeError(
"buffer() missing 1 required positional argument: 'size'"
)
self.write(
f":TRACe:MAKE '{self.short_name}', {self._size}, {self.style}"
)
else:
# when referring to default buffer, "size" parameter is not needed.
if size is not None:
self.log.warning(
f"Please use method 'size()' to resize default buffer "
f"{self.short_name} size to {self._size}."
)
self.add_parameter(
"size",
get_cmd=f":TRACe:POINts? '{self.short_name}'",
set_cmd=f":TRACe:POINts {{}}, '{self.short_name}'",
get_parser=int,
docstring="The number of readings a buffer can store."
)
self.add_parameter(
"number_of_readings",
get_cmd=f":TRACe:ACTual? '{self.short_name}'",
get_parser=int,
docstring="Get the number of readings in the reading buffer."
)
self.add_parameter(
"last_index",
get_cmd=f":TRACe:ACTual:END? '{self.short_name}'",
get_parser=int,
docstring="Get the last index of readings in the reading buffer."
)
self.add_parameter(
"first_index",
get_cmd=f":TRACe:ACTual:STARt? '{self.short_name}'",
get_parser=int,
docstring="Get the starting index of readings in the reading "
"buffer."
)
self.add_parameter(
"data_start",
initial_value=1,
get_cmd=None,
set_cmd=None,
docstring="First index of the data to be returned."
)
self.add_parameter(
"data_end",
initial_value=1,
get_cmd=None,
set_cmd=None,
docstring="Last index of the data to be returned."
)
self.add_parameter(
"elements",
get_cmd=None,
get_parser=self._from_scpi_to_name,
set_cmd=None,
set_parser=self._from_name_to_scpi,
vals=Lists(Enum(*list(self.buffer_elements.keys()))),
docstring="List of buffer elements to read."
)
self.add_parameter(
"setpoints_start",
label="start value for the setpoints",
source=None,
parameter_class=DelegateParameter
)
self.add_parameter(
"setpoints_stop",
label="stop value for the setpoints",
source=None,
parameter_class=DelegateParameter
)
self.add_parameter(
"n_pts",
label="total n for the setpoints",
get_cmd=self._get_n_pts
)
self.add_parameter(
"setpoints",
parameter_class=GeneratedSetPoints,
start=self.setpoints_start,
stop=self.setpoints_stop,
n_points=self.n_pts,
vals=Arrays(shape=(self.n_pts.get_latest,))
)
self.add_parameter(
"t_start",
label="start time",
unit="s",
initial_value=0,
get_cmd=None,
set_cmd=None,
set_parser=float
)
self.add_parameter(
"t_stop",
label="stop time",
unit="s",
initial_value=1,
get_cmd=None,
set_cmd=None,
set_parser=float
)
self.add_parameter(
"fill_mode",
get_cmd=f":TRACe:FILL:MODE? '{self.short_name}'",
set_cmd=f":TRACe:FILL:MODE {{}}, '{self.short_name}'",
vals=Enum('CONT', 'continuous', 'ONCE', 'once'),
docstring="if a reading buffer is filled continuously or is filled"
" once and stops"
)
def test_valid_values():
val = Lists(Ints(max_value=10))
for vval in val.valid_values:
val.validate(vval)
def __init__(self, name: str, address: str, **kwargs: Any):
super().__init__(name, address, terminator='\n', **kwargs)
self._card = 0
self.add_parameter(name='get_status',
get_cmd='*ESR?',
get_parser=int,
docstring='Queries status register.')
self.add_parameter(name='get_error',
get_cmd=':SYST:ERR?',
docstring='Queries error queue')
self.add_parameter(name='connections',
get_cmd=f':CLOS:CARD? {self._card}',
get_parser=KeysightB220X.parse_channel_list,
docstring='queries currently active connections '
'and returns a set of tuples {(input, '
'output), ...}')
self.add_parameter(
name='connection_rule',
get_cmd=self._get_connection_rule,
set_cmd=self._set_connection_rule,
val_mapping={
'free': 'FREE',
'single': 'SROU'
},
docstring=("specifies connection rule. Parameter "
"one of 'free' (default) or 'single'.\n\n"
"In 'free' mode\n"
" - each input port can be connected to "
"multiple output ports\n"
" - and each output port can be "
"connected to multiple input ports.\n"
" - Caution: If the Free connection rule "
"has been specified, ensure multiple "
"input ports are not connected to the "
"same output port. Such configurations "
"can cause damage\n\n"
"In single route mode:\n"
" - each input port can be connected to "
"only one output port\n"
" - and each output port can be "
"connected to only one input port.\n"
" - existing connection to a port will "
"be disconnected when a new connection "
"is made.\n"))
self.add_parameter(name='connection_sequence',
get_cmd=f':CONN:SEQ? {self._card}',
set_cmd=f':CONN:SEQ {self._card},{{}}',
val_mapping={
'none': 'NSEQ',
'bbm': 'BBM',
'mbb': 'MBBR'
},
docstring="One of 'none', 'bbm' (Break before "
"make) or 'mbb' (make before break)")
self.add_parameter(name='bias_input_port',
get_cmd=f':BIAS:PORT? {self._card}',
set_cmd=f':BIAS:PORT {self._card},{{}}',
vals=MultiType(KeysightB220X._available_input_ports,
Enum(-1)),
get_parser=int,
docstring="Selects the input that will be used as "
"bias input port (default 10). The Bias "
"input port cannot be used on subsequent "
"`connect` or `disconnect` commands if "
"Bias mode is ON")
self.add_parameter(name='bias_mode',
get_cmd=f':BIAS? {self._card}',
set_cmd=f':BIAS {self._card},{{}}',
val_mapping={
True: 1,
False: 0
},
docstring="Param: True for ON, False for OFF")
self.add_parameter(name='gnd_input_port',
get_cmd=f':AGND:PORT? {self._card}',
set_cmd=f':AGND:PORT {self._card},{{}}',
vals=MultiType(KeysightB220X._available_input_ports,
Enum(-1)),
get_parser=int,
docstring="Selects the input that will be used as "
"GND input port (default 12). The GND "
"input port cannot be used on subsequent "
"`connect` or `disconnect` commands if "
"GND mode is ON")
self.add_parameter(name='gnd_mode',
get_cmd=f':AGND? {self._card}',
set_cmd=f':AGND {self._card},{{}}',
val_mapping={
True: 1,
False: 0
})
self.add_parameter(name='unused_inputs',
get_cmd=f':AGND:UNUSED? {self._card}',
set_cmd=f":AGND:UNUSED {self._card},'{{}}'",
get_parser=lambda response: [
int(x) for x in response.strip("'").split(',')
if x.strip().isdigit()
],
set_parser=lambda value: str(value).strip('[]'),
vals=Lists(KeysightB220X._available_input_ports))
self.add_parameter(name='couple_ports',
get_cmd=f':COUP:PORT? {self._card}',
set_cmd=f":COUP:PORT {self._card},'{{}}'",
set_parser=lambda value: str(value).strip('[]()'),
get_parser=lambda response: [
int(x) for x in response.strip("'").split(',')
if x.strip().isdigit()
],
vals=Lists(Enum(1, 3, 5, 7, 9, 11, 13)))
self.add_parameter(name='couple_mode',
get_cmd=f':COUP? {self._card}',
set_cmd=f':COUP {self._card},{{}}',
val_mapping={
True: 1,
False: 0
},
docstring="Param: True for ON, False for OFF")
self.connect_message()
def __init__(self, name, board_number=0, initialize=True, **kwargs):
"""
Initialize the pulseblaster DDS
Args:
name: Name of instrument
**kwargs: Additional keyword arguments passed to Instrument
"""
super().__init__(name, **kwargs)
# Create an empty list of lists of instructions [[], [], ...]
self.instructions = [[] for _ in range(self.N_CHANNELS)]
########################################################################
### Parameters ###
########################################################################
self.add_parameter('core_clock',
label='Core clock',
set_cmd=self.set_core_clock,
vals=Numbers(),
docstring='The core clock of the PulseBlasterDDS')
self.add_parameter('board_number',
set_cmd=None,
initial_value=board_number)
self.output_channels = ChannelList(self,
name='output_channels',
chan_type=InstrumentChannel)
for ch_idx in range(self.N_CHANNELS):
ch_name = f'ch{ch_idx+1}'
output_channel = InstrumentChannel(self, ch_name)
output_channel.idx = ch_idx
self.output_channels.append(output_channel)
output_channel.add_parameter(
'frequencies',
label=f'{ch_name} frequency',
unit='Hz',
# set_cmd=partial(self.set_frequencies, ch_idx),
set_cmd=None,
vals=Lists(Numbers()))
output_channel.add_parameter(
'phases',
label=f'{ch_name} phase',
unit='deg',
# set_cmd=partial(self.set_phases, ch_idx),
set_cmd=None,
vals=Lists(Numbers()))
output_channel.add_parameter(
'amplitudes',
label=f'{ch_name} amplitude',
unit='V',
# set_cmd=partial(self.set_amplitudes, ch_idx),
set_cmd=None,
vals=Lists(Numbers()))
self.add_parameter('instruction_sequence',
set_cmd=None,
initial_value=[],
vals=Lists(),
snapshot_value=False)
# Initialize the DDS
self.setup(initialize=initialize)
def test_valid_values(self):
l = Lists(Ints(max_value=10))
l.validate(l.valid_values[0])
