def __init__(self, parent: 'GS200', name: str, present: bool) -> None:
super().__init__(parent, name)
self.present = present
# Start off with all disabled
self._enabled = False
self._output = False
# Set up mode cache. These will be filled in once the parent
# is fully initialized.
self._range: Union[None, float] = None
self._unit: Union[None, str] = None
# Set up monitoring parameters
if present:
self.add_parameter('enabled',
label='Measurement Enabled',
get_cmd=self.state,
set_cmd=lambda x: self.on()
if x else self.off(),
val_mapping={
'off': 0,
'on': 1,
})
# Note: Measurement will only run if source and
# measurement is enabled.
self.add_parameter('measure',
label='<unset>',
unit='V/I',
get_cmd=self._get_measurement,
snapshot_get=False)
self.add_parameter('NPLC',
label='NPLC',
unit='1/LineFreq',
vals=Ints(1, 25),
set_cmd=':SENS:NPLC {}',
set_parser=int,
get_cmd=':SENS:NPLC?',
get_parser=float_round)
self.add_parameter('delay',
label='Measurement Delay',
unit='ms',
vals=Ints(0, 999999),
set_cmd=':SENS:DEL {}',
set_parser=int,
get_cmd=':SENS:DEL?',
get_parser=float_round)
self.add_parameter('interval',
label='Measurement Interval',
unit='s',
vals=Numbers(0.1, 3600),
set_cmd=':SENS:INT {}',
set_parser=float,
get_cmd=':SENS:INT?',
get_parser=float)
def __init__(self, parent: VisaInstrument, name: str,
proper_function: str) -> None:
super().__init__(parent, name)
self._proper_function = proper_function
range_vals = self.function_modes[self._proper_function]["range_vals"]
unit = self.function_modes[self._proper_function]["unit"]
self.function = self.parent.digi_sense_function
self.add_parameter(
self._proper_function,
get_cmd=self._measure,
unit=unit,
docstring="Make measurements, place them in a reading buffer, and "
"return the last reading.")
self.add_parameter(
"range",
get_cmd=f":SENSe:DIGitize:{self._proper_function}:RANGe?",
set_cmd=f":SENSe:DIGitize:{self._proper_function}:RANGe {{}}",
vals=range_vals,
get_parser=float,
unit=unit,
docstring="Determine the positive full-scale measure range.")
self.add_parameter(
"input_impedance",
get_cmd=":SENSe:DIGitize:VOLTage:INPutimpedance?",
set_cmd=":SENSe:DIGitize:VOLTage:INPutimpedance {}",
vals=Enum("AUTO", "MOHM10"),
docstring="Determine when the 10 MΩ input divider is enabled. "
"'MOHM10' means 10 MΩ for all ranges.")
self.add_parameter(
'acq_rate',
get_cmd=f":SENSe:DIGitize:{self._proper_function}:SRATE?",
set_cmd=f":SENSe:DIGitize:{self._proper_function}:SRATE {{}}",
vals=Ints(1000, 1000000),
docstring="Define the precise acquisition rate at which the "
"digitizing measurements are made.")
self.add_parameter(
"aperture",
get_cmd=f":SENSe:DIGitize:{self._proper_function}:APERture?",
set_cmd=f":SENSe:DIGitize:{self._proper_function}:APERture {{}}",
unit="us",
docstring="Determine the aperture setting.")
self.add_parameter(
"count",
get_cmd="SENSe:DIGitize:COUNt?",
set_cmd="SENSe:DIGitize:COUNt {}",
vals=Ints(1, 55000000),
docstring="Set the number of measurements to digitize when a "
"measurement is requested")
def __init__(self, parent: "AMI430") -> None:
super().__init__(parent, "SwitchHeater")
# Add state parameters
self.add_parameter(
"enabled",
label="Switch Heater Enabled",
get_cmd=self.check_enabled,
set_cmd=lambda x: (self.enable() if x else self.disable()),
vals=Bool(),
)
self.add_parameter(
"state",
label="Switch Heater On",
get_cmd=self.check_state,
set_cmd=lambda x: (self.on() if x else self.off()),
vals=Bool(),
)
self.add_parameter(
"in_persistent_mode",
label="Persistent Mode",
get_cmd="PERS?",
val_mapping={
True: 1,
False: 0
},
)
# Configuration Parameters
self.add_parameter(
"current",
label="Switch Heater Current",
unit="mA",
get_cmd="PS:CURR?",
get_parser=float,
set_cmd="CONF:PS:CURR {}",
vals=Numbers(0, 125),
)
self.add_parameter(
"heat_time",
label="Heating Time",
unit="s",
get_cmd="PS:HTIME?",
get_parser=int,
set_cmd="CONF:PS:HTIME {}",
vals=Ints(5, 120),
)
self.add_parameter(
"cool_time",
label="Cooling Time",
unit="s",
get_cmd="PS:CTIME?",
get_parser=int,
set_cmd="CONF:PS:CTIME {}",
vals=Ints(5, 3600),
)
def __init__(self, parent: "DMC4133Controller", name: str,
**kwargs: Any) -> None:
"""
Initializes the vector mode submodule for the controller
Args:
parent: an instance of DMC4133Controller
name: name of the vector mode plane
"""
super().__init__(parent, name, **kwargs)
self._plane = name
self._vector_position_validator = Ints(min_value=-2147483648,
max_value=2147483647)
self.add_parameter(
"coordinate_system",
get_cmd="CA ?",
get_parser=self._parse_coordinate_system_active,
set_cmd="CA {}",
vals=Enum("S", "T"),
docstring="activates coordinate system for the motion. Two "
" coordinate systems are possible with values "
"'S' and 'T'. All vector mode commands will apply to "
"the active coordinate system.",
)
self.add_parameter(
"vector_acceleration",
get_cmd="VA ?",
get_parser=lambda s: int(float(s)),
set_cmd="VA {}",
vals=Multiples(min_value=1024, max_value=1073740800, divisor=1024),
unit="counts/sec2",
docstring="sets and gets the defined vector's acceleration",
)
self.add_parameter(
"vector_deceleration",
get_cmd="VD ?",
get_parser=lambda s: int(float(s)),
set_cmd="VD {}",
vals=Multiples(min_value=1024, max_value=1073740800, divisor=1024),
unit="counts/sec2",
docstring="sets and gets the defined vector's deceleration",
)
self.add_parameter(
"vector_speed",
get_cmd="VS ?",
get_parser=lambda s: int(float(s)),
set_cmd="VS {}",
vals=Multiples(min_value=2, max_value=15000000, divisor=2),
unit="counts/sec",
docstring="sets and gets defined vector's speed",
)
def test_failed_numbers(self):
with self.assertRaises(TypeError):
Ints(1, 2, 3)
with self.assertRaises(TypeError):
Ints(1, 1) # min >= max
for val in self.not_ints:
with self.assertRaises((TypeError, OverflowError)):
Ints(max_value=val)
with self.assertRaises((TypeError, OverflowError)):
Ints(min_value=val)
def test_failed_numbers():
with pytest.raises(TypeError):
Ints(1, 2, 3)
with pytest.raises(TypeError):
Ints(1, 1) # min >= max
for val in not_ints:
with pytest.raises((TypeError, OverflowError)):
Ints(max_value=val)
with pytest.raises((TypeError, OverflowError)):
Ints(min_value=val)
def __init__(self, name, address, reset=False, **kwargs):
super().__init__(name,
address,
terminator='\r\n',
device_clear=False,
**kwargs)
self.add_parameter(name='voltage',
label='Voltage',
unit='V',
get_cmd='OD',
set_cmd='S{:.5E}\r\nE',
get_parser=voltage_parser,
vals=Numbers(min_value=-30.0, max_value=30.0),
post_delay=0.1)
self.add_parameter(name='voltage_limit',
label='Voltage limit',
unit='V',
set_cmd='LV{:d}',
post_delay=0.1,
vals=Ints(min_value=1, max_value=30))
self.add_parameter(
name='panel_settings',
label='Panel settings',
get_cmd=self._get_panel_settings,
)
self.add_parameter(name='status', label='current status', get_cmd='OC')
self.add_function('enable_output', call_cmd='O1E')
self.add_function('disable_output', call_cmd='O0E')
def __init__(self, name, spi_rack, module, **kwargs):
super().__init__(name, **kwargs)
self.f1d = F1d_module(spi_rack, module)
self.add_parameter('IQ_filter',
label='IQ filter',
set_cmd=self.f1d.set_IQ_filter,
unit='MHz',
vals=Ints(1, 3, 10, 20))
self.add_parameter('I_gain',
label='I gain',
set_cmd=self.f1d.set_I_gain,
vals=Enum('low', 'mid', 'high'))
self.add_parameter('Q_gain',
label='Q gain',
set_cmd=self.f1d.set_Q_gain,
vals=Enum('low', 'mid', 'high'))
self.add_parameter('RF_level',
label='RF level',
set_cmd=self.f1d.get_RF_level,
unit='dBm')
self.add_parameter('LO_level',
label='LO level',
set_cmd=self.f1d.get_LO_level,
unit='dBm')
self.add_function('enable_remote', self.f1d.enable_remote)
self.add_function('is_rf_clipped', self.f1d.rf_clipped)
def test_good():
m = MultiTypeOr(Strings(2, 4), Ints(10, 1000))
for v in [10, 11, 123, 1000, "aa", "mop", "FRED"]:
m.validate(v)
for v in [
9,
1001,
"Q",
"Qcode",
None,
100.0,
b"nice",
[],
{},
a_func,
AClass,
AClass(),
True,
False,
]:
with pytest.raises(ValueError):
m.validate(v)
assert repr(m) == "<MultiTypeOr: Strings 2<=len<=4, Ints 10<=v<=1000>"
assert m.is_numeric
assert not MultiTypeOr(Strings(), Enum(1, 2)).is_numeric
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_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():
l = Sequence(Ints(max_value=10))
v1 = [0, 1, 5]
l.validate(v1)
v2 = [0, 1, 11]
with pytest.raises(ValueError, match="11 is invalid: must be between"):
l.validate(v2)
def test_unlimited():
n = Ints()
n.validate(n.valid_values[0])
for v in ints:
n.validate(v)
for v in not_ints:
with pytest.raises(TypeError):
n.validate(v)
def test_unlimited(self):
n = Ints()
n.validate(n.valid_values[0])
for v in self.ints:
n.validate(v)
for v in self.not_ints:
with self.assertRaises(TypeError):
n.validate(v)
def __init__(self, parent: 'AMI430') -> None:
super().__init__(parent, "SwitchHeater")
# Add state parameters
self.add_parameter('enabled',
label='Switch Heater Enabled',
get_cmd=self.check_enabled,
set_cmd=lambda x: (self.enable()
if x else self.disable()),
vals=Bool())
self.add_parameter('state',
label='Switch Heater On',
get_cmd=self.check_state,
set_cmd=lambda x: (self.on() if x else self.off()),
vals=Bool())
self.add_parameter('in_persistent_mode',
label='Persistent Mode',
get_cmd="PERS?",
val_mapping={
True: 1,
False: 0
})
# Configuration Parameters
self.add_parameter('current',
label='Switch Heater Current',
unit='mA',
get_cmd='PS:CURR?',
get_parser=float,
set_cmd='CONF:PS:CURR {}',
vals=Numbers(0, 125))
self.add_parameter('heat_time',
label='Heating Time',
unit='s',
get_cmd='PS:HTIME?',
get_parser=int,
set_cmd='CONF:PS:HTIME {}',
vals=Ints(5, 120))
self.add_parameter('cool_time',
label='Cooling Time',
unit='s',
get_cmd='PS:CTIME?',
get_parser=int,
set_cmd='CONF:PS:CTIME {}',
vals=Ints(5, 3600))
def __init__(self, parent: 'Keithley2460', name: str,
proper_function: str) -> None:
super().__init__(parent, name)
self._proper_function = proper_function
range_vals = self.function_modes[self._proper_function]["range_vals"]
unit = self.function_modes[self._proper_function]["unit"]
self.function = self.parent.sense_function
self.add_parameter(
"four_wire_measurement",
set_cmd=f":SENSe:{self._proper_function}:RSENse {{}}",
get_cmd=f":SENSe:{self._proper_function}:RSENse?",
val_mapping=create_on_off_val_mapping(on_val="1", off_val="0"))
self.add_parameter(
"range",
set_cmd=f":SENSe:{self._proper_function}:RANGe {{}}",
get_cmd=f":SENSe:{self._proper_function}:RANGe?",
vals=range_vals,
get_parser=float,
unit=unit)
self.add_parameter(
"auto_range",
set_cmd=f":SENSe:{self._proper_function}:RANGe:AUTO {{}}",
get_cmd=f":SENSe:{self._proper_function}:RANGe:AUTO?",
val_mapping=create_on_off_val_mapping(on_val="1", off_val="0"))
self.add_parameter(self._proper_function,
get_cmd=self._measure,
get_parser=float,
unit=unit,
snapshot_value=False)
self.add_parameter("sweep",
label=self._proper_function,
get_cmd=self._measure_sweep,
unit=unit,
vals=Arrays(shape=(self.parent.npts, )),
parameter_class=ParameterWithSetpoints)
self.add_parameter(
"nplc",
get_cmd=f":SENSe:{self._proper_function}:NPLCycles?",
set_cmd=f":SENSe:{self._proper_function}:NPLCycles {{}}",
vals=Numbers(0.001, 10))
self.add_parameter('user_number',
get_cmd=None,
set_cmd=None,
vals=Ints(1, 5))
self.add_parameter("user_delay",
get_cmd=self._get_user_delay,
set_cmd=self._set_user_delay,
vals=Numbers(0, 1e4))
def __init__(self, parent: 'GS200', name: str) -> None:
super().__init__(parent, name)
self._repeat = 1
self._file_name = None
self.add_parameter("interval",
label="the program interval time",
unit='s',
vals=Numbers(0.1, 3600.0),
get_cmd=":PROG:INT?",
set_cmd=":PROG:INT {}")
self.add_parameter("slope",
label="the program slope time",
unit='s',
vals=Numbers(0.1, 3600.0),
get_cmd=":PROG:SLOP?",
set_cmd=":PROG:SLOP {}")
self.add_parameter("save",
set_cmd=":PROG:SAVE '{}'",
docstring="save the program to the system memory "
"(.csv file)")
self.add_parameter("load",
get_cmd=":PROG:LOAD?",
set_cmd=":PROG:LOAD '{}'",
docstring="load the program (.csv file) from the "
"system memory")
self.add_parameter("repeat",
label="program execution repetition",
get_cmd=":PROG:REP?",
set_cmd=":PROG:REP {}",
val_mapping={
'OFF': 0,
'ON': 1
})
self.add_parameter("count",
label="step of the current program",
get_cmd=":PROG:COUN?",
set_cmd=":PROG:COUN {}",
vals=Ints(1, 10000))
self.add_function('start',
call_cmd=":PROG:EDIT:STAR",
docstring="start program editing")
self.add_function('end',
call_cmd=":PROG:EDIT:END",
docstring="end program editing")
self.add_function(
'run',
call_cmd=":PROG:RUN",
docstring="run the program",
)
def test_max(self):
for max_val in self.ints:
n = Ints(max_value=max_val)
for v in self.ints:
if v <= max_val:
n.validate(v)
else:
with self.assertRaises(ValueError):
n.validate(v)
for v in self.not_ints:
with self.assertRaises(TypeError):
n.validate(v)
def test_max():
for max_val in ints:
n = Ints(max_value=max_val)
for v in ints:
if v <= max_val:
n.validate(v)
else:
with pytest.raises(ValueError):
n.validate(v)
for v in not_ints:
with pytest.raises(TypeError):
n.validate(v)
def __init__(self, parent: Instrument, name: str, id: int, **kwargs):
super().__init__(parent=parent, name=name, **kwargs)
self.fpga = self._parent.fpga
self.id = id
self.n_pointer_bits = 9
self.n_op_bits = 10
self.n_phase_bits = 45
self.n_accum_bits = 45
self.n_amp_bits = 16
self.n_timing_bits = 32 # number of bits for pulse to auto-advance
self.clk = 100e6
self.v_max = 1.5
self.f_max = 200e6
self.fpga_port = self.id
self.pulse_timing_offset = 14 # Offset for auto-advancing of pulses
self.add_parameter(
'output_enable',
label=f'ch{self.id} output_enable',
set_cmd=self._set_output_enable,
vals=Bool(),
docstring='Whether the system has an enabled output')
self.add_parameter(
'load_delay',
label=f'ch{self.id} load_delay',
set_cmd=self._set_load_delay,
vals=Ints(0, 15),
docstring='How long the delay should be during loading a new pulse '
'to calculate the new coefficients (delay in samples).')
self.add_parameter(
'pcdds_enable',
label=f'ch{self.id} pcdds_enable',
set_cmd=self._set_pcdds_enable,
vals=Bool(),
docstring='Set the output of the device to use the PCDDS system '
'and not the inbuilt functionality')
self.add_parameter(
'instruction_sequence',
label=f'ch{self.id} instruction sequence of pulses',
initial_value=[],
docstring='The instruction sequence for all pulses sent to the DDS.'
'Gets cleared during clear_memory()')
self.debug_mode = Parameter(initial_value=False,
set_cmd=None,
docstring='Print debug messages')
# Initially set load delay to 10 samples
self.load_delay(10)
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 __init__(self, name: str, address: str,
attenuation: Optional[int] = None,
terminator="\r", **kwargs):
super().__init__(name=name, address=address,
terminator=terminator, **kwargs)
model = self.IDN()['model']
if model in ["J7211A", "J7211B"]:
vals = Ints(0, 120)
elif model in ["J7211C"]:
vals = Ints(0, 100)
else:
raise RuntimeError(f"Model {model} is not supported.")
self.add_parameter('attenuation', unit='dB',
set_cmd='ATT {:03.0f}',
get_cmd='ATT?',
get_parser=int,
vals=vals,
initial_value=attenuation)
self.connect_message()
def __init__(self, parent: 'Newport_AG_UC8_Channel', axis: int) -> None:
assert axis in (1, 2)
super().__init__(parent, "axis_%d" % axis)
self.axis = axis
self.add_parameter("step_delay",
label="Step delay in units of 10 us",
get_cmd="%dDL?" % axis,
set_cmd="%dDL{}" % axis,
get_parser=_make_get_parser("%dDL" % axis),
vals=Ints(0, 200000))
self.add_parameter("step_amplitude_pos",
label="Step amplitude in positive direction",
get_cmd="%dSU+?" % axis,
set_cmd="%dSU+{}" % axis,
get_parser=_make_get_parser("%dSU+" % axis),
vals=Ints(1, 50))
self.add_parameter("step_amplitude_neg",
label="Step amplitude in negative direction",
get_cmd="%dSU-?" % axis,
set_cmd="%dSU-{}" % axis,
get_parser=_make_get_parser("%dSU-" % axis),
vals=Ints(1, 50))
self.add_parameter("steps",
label="Accumulated number of steps since last " +
"reset of the step counter",
get_cmd="%dTP" % axis,
get_parser=_make_get_parser("%dTP" % axis))
self.add_parameter("status",
label="Status of the axis",
get_cmd="%dTS" % axis,
get_parser=_make_get_parser("%dTS" % axis),
val_mapping={
"ready": 0,
"stepping": 1,
"jogging": 2,
"moving_to_limit": 3
})
def test_range(self):
n = Ints(0, 10)
for v in self.ints:
if 0 <= v <= 10:
n.validate(v)
else:
with self.assertRaises(ValueError):
n.validate(v)
for v in self.not_ints:
with self.assertRaises(TypeError):
n.validate(v)
self.assertEqual(repr(n), '<Ints 0<=v<=10>')
self.assertTrue(n.is_numeric)
def test_range():
n = Ints(0, 10)
for v in ints:
if 0 <= v <= 10:
n.validate(v)
else:
with pytest.raises(ValueError):
n.validate(v)
for v in not_ints:
with pytest.raises(TypeError):
n.validate(v)
assert repr(n) == '<Ints 0<=v<=10>'
assert n.is_numeric
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 test_good(self):
m = MultiType(Strings(2, 4), Ints(10, 1000))
for v in [10, 11, 123, 1000, 'aa', 'mop', 'FRED']:
m.validate(v)
for v in [9, 1001, 'Q', 'Qcode', None, 100.0, b'nice', [], {},
a_func, AClass, AClass(), True, False]:
with self.assertRaises(ValueError):
m.validate(v)
self.assertEqual(
repr(m), '<MultiType: Strings 2<=len<=4, Ints 10<=v<=1000>')
self.assertTrue(m.is_numeric)
self.assertFalse(MultiType(Strings(), Enum(1, 2)).is_numeric)
def __init__(self, name: str, address: str, **kwargs: Any) -> None:
"""
Initializes the DMC4133Controller class
Args:
name: name for the instance
address: address of the controller burned in
"""
super().__init__(name=name, address=address, **kwargs)
self.add_parameter(
"position_format_decimals",
get_cmd=None,
set_cmd="PF 10.{}",
vals=Ints(0, 4),
docstring="sets number of decimals in the format "
"of the position",
)
self.add_parameter(
"absolute_position",
get_cmd=self._get_absolute_position,
set_cmd=None,
unit="quadrature counts",
docstring="gets absolute position of the motors "
"from the set origin",
)
self.add_parameter(
"wait",
get_cmd=None,
set_cmd="WT {}",
unit="ms",
vals=Multiples(min_value=2, max_value=2147483646, divisor=2),
docstring="controller will wait for the amount of "
"time specified before executing the next "
"command",
)
self._set_default_update_time()
self.add_submodule("motor_a", Motor(self, "A"))
self.add_submodule("motor_b", Motor(self, "B"))
self.add_submodule("motor_c", Motor(self, "C"))
self.add_submodule("plane_ab", VectorMode(self, "AB"))
self.add_submodule("plane_bc", VectorMode(self, "BC"))
self.add_submodule("plane_ac", VectorMode(self, "AC"))
def test_good_or():
# combiner == 'OR'
m = MultiType(Strings(2, 4), Ints(10, 1000))
for v in [10, 11, 123, 1000, 'aa', 'mop', 'FRED']:
m.validate(v)
for v in [
9, 1001, 'Q', 'Qcode', None, 100.0, b'nice', [], {}, a_func,
AClass,
AClass(), True, False
]:
with pytest.raises(ValueError):
m.validate(v)
assert repr(m) == '<MultiType: Strings 2<=len<=4, Ints 10<=v<=1000>'
assert m.is_numeric
assert not MultiType(Strings(), Enum(1, 2)).is_numeric
def __init__(self, parent, name, channel_letter):
"""
Args:
parent (Instrument): The instrument the channel is a part of
name (str): the name of the channel
channel_letter (str): channel letter ['a', 'b', 'c' or 'd'])
"""
super().__init__(parent, name)
self.channel_letter = channel_letter.upper()
_chanlist = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
self.channel_number = _chanlist.index(channel_letter)
self.add_parameter('switch',
label='switch {}'.format(self.channel_letter),
set_cmd=self._set_switch,
get_cmd=self._get_switch,
vals=Ints(1, 2))
