qcodes.instrument.base

Instrument base class.

class qcodes.instrument.base.AbstractInstrument[source]

Bases: abc.ABC

ABC that is useful for defining mixin classes for Instrument class

log: InstrumentLoggerAdapter = ()

abstract ask(cmd: str) → str[source]

class qcodes.instrument.base.Instrument(name: str, metadata: Optional[Mapping[Any, Any]] = None)[source]

Bases: qcodes.instrument.base.InstrumentBase, qcodes.instrument.base.AbstractInstrument

Base class for all QCodes instruments.

Parameters

name – an identifier for this instrument, particularly for attaching it to a Station.
metadata – additional static metadata to add to this instrument’s JSON snapshot.

shared_kwargs = ()

get_idn() → Dict[str, Optional[str]][source]

Parse a standard VISA *IDN? response into an ID dict.

Even though this is the VISA standard, it applies to various other types as well, such as IPInstruments, so it is included here in the Instrument base class.

Override this if your instrument does not support *IDN? or returns a nonstandard IDN string. This string is supposed to be a comma-separated list of vendor, model, serial, and firmware, but semicolon and colon are also common separators so we accept them here as well.

Returns: A dict containing vendor, model, serial, and firmware.

connect_message(idn_param: str = 'IDN', begin_time: Optional[float] = None) → None[source]

Print a standard message on initial connection to an instrument.

Parameters

idn_param – Name of parameter that returns ID dict. Default IDN.
begin_time – time.time() when init started. Default is self._t0, set at start of Instrument.__init__.

__repr__() → str[source]: Simplified repr giving just the class and name.

__del__() → None[source]: Close the instrument and remove its instance record.

close() → None[source]

Irreversibly stop this instrument and free its resources.

Subclasses should override this if they have other specific resources to close.

classmethod close_all() → None[source]

Try to close all instruments registered in _all_instruments This is handy for use with atexit to ensure that all instruments are closed when a python session is closed.

Examples

>>> atexit.register(qc.Instrument.close_all())

classmethod record_instance(instance: qcodes.instrument.base.Instrument) → None[source]

Record (a weak ref to) an instance in a class’s instance list.

Also records the instance in list of all instruments, and verifies that there are no other instruments with the same name.

Parameters: instance – Instance to record.
Raises: KeyError – If another instance with the same name is already present.

classmethod instances() → List[qcodes.instrument.base.Instrument][source]

Get all currently defined instances of this instrument class.

You can use this to get the objects back if you lose track of them, and it’s also used by the test system to find objects to test against.

Returns: A list of instances.

classmethod remove_instance(instance: qcodes.instrument.base.Instrument) → None[source]

Remove a particular instance from the record.

Parameters: instance – The instance to remove

classmethod find_instrument(name: str, instrument_class: Optional[type] = None) → qcodes.instrument.base.Instrument[source]

Find an existing instrument by name.

Parameters

name – Name of the instrument.
instrument_class – The type of instrument you are looking for.

Returns

The instrument found.

Raises

KeyError – If no instrument of that name was found, or if its reference is invalid (dead).
TypeError – If a specific class was requested but a different type was found.

static exist(name: str, instrument_class: Optional[type] = None) → bool[source]

Check if an instrument with a given names exists (i.e. is already instantiated).

Parameters

name – Name of the instrument.
instrument_class – The type of instrument you are looking for.

static is_valid(instr_instance: qcodes.instrument.base.Instrument) → bool[source]

Check if a given instance of an instrument is valid: if an instrument has been closed, its instance is not longer a “valid” instrument.

Parameters: instr_instance – Instance of an Instrument class or its subclass.

write(cmd: str) → None[source]

Write a command string with NO response to the hardware.

Subclasses that transform cmd should override this method, and in it call super().write(new_cmd). Subclasses that define a new hardware communication should instead override write_raw.

Parameters: cmd – The string to send to the instrument.
Raises: Exception – Wraps any underlying exception with extra context, including the command and the instrument.

write_raw(cmd: str) → None[source]

Low level method to write a command string to the hardware.

Subclasses that define a new hardware communication should override this method. Subclasses that transform cmd should instead override write.

Parameters: cmd – The string to send to the instrument.

__getitem__(key: str) → Union[Callable[[...], Any], qcodes.instrument.parameter.Parameter]: Delegate instrument[‘name’] to parameter or function ‘name’.

__getstate__() → None: Prevent pickling instruments, and give a nice error message.

add_function(name: str, **kwargs: Any) → None

Bind one Function to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real function of the instrument.

This functionality is meant for simple cases, principally things that map to simple commands like *RST (reset) or those with just a few arguments. It requires a fixed argument count, and positional args only. If your case is more complicated, you’re probably better off simply making a new method in your Instrument subclass definition.

Parameters

name – How the Function will be stored within instrument.Functions and also how you address it using the shortcut methods: instrument.call(func_name, *args) etc.
**kwargs – constructor kwargs for Function

Raises

KeyError – If this instrument already has a function with this name.

add_parameter(name: str, parameter_class: type = <class 'qcodes.instrument.parameter.Parameter'>, **kwargs: Any) → None

Bind one Parameter to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real parameter of the instrument.

In this sense, parameters are the state variables of the instrument, anything the user can set and/or get.

Parameters

name – How the parameter will be stored within instrument.parameters and also how you address it using the shortcut methods: instrument.set(param_name, value) etc.
parameter_class – You can construct the parameter out of any class. Default parameter.Parameter.
**kwargs – Constructor arguments for parameter_class.

Raises

KeyError – If this instrument already has a parameter with this name and the parameter being replaced is not an abstract parameter.
ValueError – If there is an existing abstract parameter and the unit of the new parameter is inconsistent with the existing one.

add_submodule(name: str, submodule: Union[InstrumentBase, ChannelList]) → None

Bind one submodule to this instrument.

Instrument subclasses can call this repeatedly in their __init__ method for every submodule of the instrument.

Submodules can effectively be considered as instruments within the main instrument, and should at minimum be snapshottable. For example, they can be used to either store logical groupings of parameters, which may or may not be repeated, or channel lists.

Parameters

name – How the submodule will be stored within instrument.submodules and also how it can be addressed.
submodule – The submodule to be stored.

Raises

KeyError – If this instrument already contains a submodule with this name.
TypeError – If the submodule that we are trying to add is not an instance of an Metadatable object.

property ancestors: List[qcodes.instrument.base.InstrumentBase]: Returns a list of instruments, starting from the current instrument and following to the parent instrument and the parents parent instrument until the root instrument is reached.

ask(cmd: str) → str[source]

Write a command string to the hardware and return a response.

Subclasses that transform cmd should override this method, and in it call super().ask(new_cmd). Subclasses that define a new hardware communication should instead override ask_raw.

Parameters: cmd – The string to send to the instrument.
Returns: response
Raises: Exception – Wraps any underlying exception with extra context, including the command and the instrument.

call(func_name: str, *args: Any) → Any

Shortcut for calling a function from its name.

Parameters

func_name – The name of a function of this instrument.
*args – any arguments to the function.

Returns

The return value of the function.

delegate_attr_dicts: List[str] = ['parameters', 'functions', 'submodules']: A list of names (strings) of dictionaries which are (or will be) attributes of self, whose keys should be treated as attributes of self.

delegate_attr_objects: List[str] = []: A list of names (strings) of objects which are (or will be) attributes of self, whose attributes should be passed through to self.

property full_name: str

get(param_name: str) → Any

Shortcut for getting a parameter from its name.

Parameters: param_name – The name of a parameter of this instrument.
Returns: The current value of the parameter.

load_metadata(metadata: Dict[Any, Any]) → None

Load metadata into this classes metadata dictionary.

Parameters: metadata – Metadata to load.

property name: str: Name of the instrument

property name_parts: List[str]

omit_delegate_attrs: List[str] = []: A list of attribute names (strings) to not delegate to any other dictionary or object.

property parent: Optional[qcodes.instrument.base.InstrumentBase]: Returns the parent instrument. By default this is None. Any SubInstrument should subclass this to return the parent instrument.

print_readable_snapshot(update: bool = False, max_chars: int = 80) → None

Prints a readable version of the snapshot. The readable snapshot includes the name, value and unit of each parameter. A convenience function to quickly get an overview of the status of an instrument.

Parameters

update – If True, update the state by querying the instrument. If False, just use the latest values in memory. This argument gets passed to the snapshot function.
max_chars – the maximum number of characters per line. The readable snapshot will be cropped if this value is exceeded. Defaults to 80 to be consistent with default terminal width.

property root_instrument: qcodes.instrument.base.InstrumentBase

set(param_name: str, value: Any) → None

Shortcut for setting a parameter from its name and new value.

Parameters

param_name – The name of a parameter of this instrument.
value – The new value to set.

property short_name: str: Short name of the instrument

snapshot(update: Optional[bool] = False) → Dict[Any, Any]

Decorate a snapshot dictionary with metadata. DO NOT override this method if you want metadata in the snapshot instead, override snapshot_base().

Parameters: update – Passed to snapshot_base.
Returns: Base snapshot.

snapshot_base(update: Optional[bool] = False, params_to_skip_update: Optional[Sequence[str]] = None) → Dict[Any, Any]

State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class qcodes.utils.helpers.NumpyJSONEncoder supports).

Parameters

update – If True, update the state by querying the instrument. If None update the state if known to be invalid. If False, just use the latest values in memory and never update state.
params_to_skip_update – List of parameter names that will be skipped in update even if update is True. This is useful if you have parameters that are slow to update but can be updated in a different way (as in the qdac). If you want to skip the update of certain parameters in all snapshots, use the snapshot_get attribute of those parameters instead.

Returns

base snapshot

Return type

dict

validate_status(verbose: bool = False) → None

Validate the values of all gettable parameters

The validation is done for all parameters that have both a get and set method.

Parameters: verbose – If True, then information about the parameters that are being check is printed.

parameters: Dict[str, _BaseParameter] = {}: All the parameters supported by this instrument. Usually populated via add_parameter().

functions: Dict[str, Function] = {}: All the functions supported by this instrument. Usually populated via add_function().

submodules: Dict[str, Union['InstrumentBase', 'ChannelList']] = {}: All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via add_submodule().

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)

ask_raw(cmd: str) → str[source]

Low level method to write to the hardware and return a response.

Subclasses that define a new hardware communication should override this method. Subclasses that transform cmd should instead override ask.

Parameters: cmd – The string to send to the instrument.

class qcodes.instrument.base.InstrumentBase(name: str, metadata: Optional[Mapping[Any, Any]] = None)[source]

Bases: qcodes.utils.metadata.Metadatable, qcodes.utils.helpers.DelegateAttributes

Base class for all QCodes instruments and instrument channels

Parameters

name – an identifier for this instrument, particularly for attaching it to a Station.
metadata – additional static metadata to add to this instrument’s JSON snapshot.

parameters: Dict[str, qcodes.instrument.parameter._BaseParameter] = {}: All the parameters supported by this instrument. Usually populated via add_parameter().

functions: Dict[str, qcodes.instrument.function.Function] = {}: All the functions supported by this instrument. Usually populated via add_function().

submodules: Dict[str, Union[InstrumentBase, ChannelList]] = {}: All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via add_submodule().

property name: str: Name of the instrument

property short_name: str: Short name of the instrument

add_parameter(name: str, parameter_class: type = <class 'qcodes.instrument.parameter.Parameter'>, **kwargs: Any) → None[source]

Bind one Parameter to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real parameter of the instrument.

In this sense, parameters are the state variables of the instrument, anything the user can set and/or get.

Parameters

name – How the parameter will be stored within instrument.parameters and also how you address it using the shortcut methods: instrument.set(param_name, value) etc.
parameter_class – You can construct the parameter out of any class. Default parameter.Parameter.
**kwargs – Constructor arguments for parameter_class.

Raises

KeyError – If this instrument already has a parameter with this name and the parameter being replaced is not an abstract parameter.
ValueError – If there is an existing abstract parameter and the unit of the new parameter is inconsistent with the existing one.

add_function(name: str, **kwargs: Any) → None[source]

Bind one Function to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real function of the instrument.

This functionality is meant for simple cases, principally things that map to simple commands like *RST (reset) or those with just a few arguments. It requires a fixed argument count, and positional args only. If your case is more complicated, you’re probably better off simply making a new method in your Instrument subclass definition.

Parameters

name – How the Function will be stored within instrument.Functions and also how you address it using the shortcut methods: instrument.call(func_name, *args) etc.
**kwargs – constructor kwargs for Function

Raises

KeyError – If this instrument already has a function with this name.

add_submodule(name: str, submodule: Union[InstrumentBase, ChannelList]) → None[source]

Bind one submodule to this instrument.

Instrument subclasses can call this repeatedly in their __init__ method for every submodule of the instrument.

Submodules can effectively be considered as instruments within the main instrument, and should at minimum be snapshottable. For example, they can be used to either store logical groupings of parameters, which may or may not be repeated, or channel lists.

Parameters

name – How the submodule will be stored within instrument.submodules and also how it can be addressed.
submodule – The submodule to be stored.

Raises

KeyError – If this instrument already contains a submodule with this name.
TypeError – If the submodule that we are trying to add is not an instance of an Metadatable object.

snapshot_base(update: Optional[bool] = False, params_to_skip_update: Optional[Sequence[str]] = None) → Dict[Any, Any][source]

State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class qcodes.utils.helpers.NumpyJSONEncoder supports).

Parameters

update – If True, update the state by querying the instrument. If None update the state if known to be invalid. If False, just use the latest values in memory and never update state.
params_to_skip_update – List of parameter names that will be skipped in update even if update is True. This is useful if you have parameters that are slow to update but can be updated in a different way (as in the qdac). If you want to skip the update of certain parameters in all snapshots, use the snapshot_get attribute of those parameters instead.

Returns

base snapshot

Return type

dict

print_readable_snapshot(update: bool = False, max_chars: int = 80) → None[source]

Prints a readable version of the snapshot. The readable snapshot includes the name, value and unit of each parameter. A convenience function to quickly get an overview of the status of an instrument.

Parameters

update – If True, update the state by querying the instrument. If False, just use the latest values in memory. This argument gets passed to the snapshot function.
max_chars – the maximum number of characters per line. The readable snapshot will be cropped if this value is exceeded. Defaults to 80 to be consistent with default terminal width.

property parent: Optional[qcodes.instrument.base.InstrumentBase]: Returns the parent instrument. By default this is None. Any SubInstrument should subclass this to return the parent instrument.

property ancestors: List[qcodes.instrument.base.InstrumentBase]: Returns a list of instruments, starting from the current instrument and following to the parent instrument and the parents parent instrument until the root instrument is reached.

property root_instrument: qcodes.instrument.base.InstrumentBase

property name_parts: List[str]

property full_name: str

delegate_attr_dicts: List[str] = ['parameters', 'functions', 'submodules']: A list of names (strings) of dictionaries which are (or will be) attributes of self, whose keys should be treated as attributes of self.

__getitem__(key: str) → Union[Callable[[...], Any], qcodes.instrument.parameter.Parameter][source]: Delegate instrument[‘name’] to parameter or function ‘name’.

set(param_name: str, value: Any) → None[source]

Shortcut for setting a parameter from its name and new value.

Parameters

param_name – The name of a parameter of this instrument.
value – The new value to set.

get(param_name: str) → Any[source]

Shortcut for getting a parameter from its name.

Parameters: param_name – The name of a parameter of this instrument.
Returns: The current value of the parameter.

call(func_name: str, *args: Any) → Any[source]

Shortcut for calling a function from its name.

Parameters

func_name – The name of a function of this instrument.
*args – any arguments to the function.

Returns

The return value of the function.

__getstate__() → None[source]: Prevent pickling instruments, and give a nice error message.

validate_status(verbose: bool = False) → None[source]

Validate the values of all gettable parameters

The validation is done for all parameters that have both a get and set method.

Parameters: verbose – If True, then information about the parameters that are being check is printed.

delegate_attr_objects: List[str] = []: A list of names (strings) of objects which are (or will be) attributes of self, whose attributes should be passed through to self.

load_metadata(metadata: Dict[Any, Any]) → None

Load metadata into this classes metadata dictionary.

Parameters: metadata – Metadata to load.

omit_delegate_attrs: List[str] = []: A list of attribute names (strings) to not delegate to any other dictionary or object.

snapshot(update: Optional[bool] = False) → Dict[Any, Any]

Decorate a snapshot dictionary with metadata. DO NOT override this method if you want metadata in the snapshot instead, override snapshot_base().

Parameters: update – Passed to snapshot_base.
Returns: Base snapshot.

qcodes.instrument.base.find_or_create_instrument(instrument_class: Type[qcodes.instrument.base.Instrument], name: str, *args: Any, recreate: bool = False, **kwargs: Any) → qcodes.instrument.base.Instrument[source]

Find an instrument with the given name of a given class, or create one if it is not found. In case the instrument was found, and recreate is True, the instrument will be re-instantiated.

Note that the class of the existing instrument has to be equal to the instrument class of interest. For example, if an instrument with the same name but of a different class exists, the function will raise an exception.

This function is very convenient because it allows not to bother about which instruments are already instantiated and which are not.

If an instrument is found, a connection message is printed, as if the instrument has just been instantiated.

Parameters

instrument_class – Class of the instrument to find or create.
name – Name of the instrument to find or create.
recreate – When True, the instruments gets recreated if it is found.

Returns

The found or created instrument.