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 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, 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 __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])