pySRSLockin

pySRSLockin is a Python library/GUI interface to control lock-in amplifiers made by Stanford Research Systems (SRS). Different models are accessed with the same commands, so the same code can be used with any of the supported models. The package is composed of two parts, a low-level driver to perform basic operations, and a high-level GUI, written with PyQt5, which can be easily embedded into other GUIs.

The interface can work either as a stand-alone application, or as a module of ergastirio.

Currently supported models: SR865A, SR844, SR810, SR510.

Table of Contents

• Installation
• Supported models
• Usage via the low-level driver
  • Creating a driver instance
  • Indexing of time constants and sensitivities
  • Properties
  • Other attributes
  • Methods
  • Examples
• Usage as a stand-alone GUI interface
• Embed the GUI within another GUI

Installation

Use the package manager pip to install,

pip install pySRSLockin

(the SR510 is supported starting from the version after 0.22).

This will install pySRSLockin together with all the libraries listed in the requirements.txt file,

abstract_instrument_interface>=0.9
PyQt5>=5.15.6
pyqtgraph
pyvisa
numpy

Only pyvisa is needed to use the low-level driver. If PyQt5 is not installed, import pySRSLockin still works, but the GUI classes (pySRSLockin.interface, pySRSLockin.gui) are not available.

A VISA backend (e.g. NI-VISA) is required to communicate with the instruments.

Supported models

The driver hides the differences between models (different commands, ranges, and ways of indexing time constants and sensitivities). Features that a model does not provide raise a RuntimeError when accessed; the property supported_outputs and the method supports_property() can be used to check in advance.

Notes on the SR510.

• By default, devices on serial ports are not scanned. An SR510 connected via RS-232 can be connected directly with connect_device(address, model='SR510'). The serial port is configured with 9600 baud, 8 data bits, 2 stop bits, no parity, and the echo mode of the SR510 must be off (rear-panel switches).
• The X output is read from the output display of the SR510 (command Q), after setting the display to X. The value therefore includes the effect of offset and expand, if they are on.
• Upon connection, the SR510 is set to remote mode (front panel locked). It is set back to local mode upon disconnection.

Usage via the low-level driver

pySRSLockin provides a low-level driver, based on the library pyvisa, to directly interface with the lock-in amplifier.

from pySRSLockin.driver import SRS_Lockin
lockin = SRS_Lockin()
available_devices = lockin.list_devices()
print(available_devices)
lockin.connect_device(device_addr = available_devices[0][0])
print(lockin.X)
lockin.disconnect_device()

The method list_devices() returns a list, with each element representing one available device in the format [address,identity,model]. The string address contains the physical address of the device. The line lockin.connect_device(device_addr = available_devices[0][0]) establishes a connection to the first device found. We then print the X output currently read by the lock-in, and finally disconnect from it.

The class SRS_Lockin supports several properties and methods to communicate with the lock-in and to read/change its settings. Some of the properties are read-only, while others can be set. A full list of properties, attributes, and methods is available below. Note: the documentation below was partially compiled with the help of Claude - mistakes are possible.

Creating a driver instance

SRS_Lockin(model=None, only_new_models=False, scan_serial_ports=False, timeout_ms=2000)

Indexing of time constants and sensitivities

The properties time_constants and sensitivities are lists of the values (in seconds and volts) available on the connected device. The properties time_constant and sensitivity are integers, corresponding to the position of the current value in these lists. For the SR865A, SR844 and SR810 the position coincides with the integer code used by the instrument (note that for the SR865A the sensitivities are in decreasing order, 0 = 1 V). For the SR510, whose codes start from 1 (and depend on the presence of the preamplifier), the driver converts between positions and instrument codes internally.

To work directly with physical values, use time_constant_value and sensitivity_value.

Properties

The following are implemented as Python @property, i.e. they are accessed without parentheses (e.g. lockin.X) and, when settable, assigned with = (e.g. lockin.phase = 45). Reading or setting any of these requires a device to be connected, otherwise a RuntimeError is raised. Accessing a property that is not supported by the connected model also raises a RuntimeError.

Other attributes

These are plain instance or class attributes (not @property) that are also useful to read directly.

Methods

Examples

from pySRSLockin.driver import SRS_Lockin
lockin = SRS_Lockin()
available_devices = lockin.list_devices()           # Check which devices are available
print(available_devices)
lockin.connect_device(device_addr = available_devices[0][0])   # Connect to the first available device
print(lockin.model)                                  # Model of the connected device
print(lockin.supported_outputs)                      # Outputs provided by this model

print(lockin.X)                                      # Read a single output
print(lockin.read_outputs(lockin.supported_outputs)) # Read all outputs (simultaneously, if supported)

print(lockin.frequency, lockin.phase)                # Read frequency and phase
lockin.phase = 45                                    # Set the phase
if lockin.supports_property('frequency_SET'):
    lockin.frequency = 1000                          # Set the frequency (internal reference only)

print(lockin.sensitivities)                          # Available sensitivities (V)
print(lockin.sensitivity, lockin.sensitivity_value)  # Current sensitivity (index and value)
lockin.sensitivity_value = 1e-3                      # Select the smallest range >= 1 mV
print(lockin.time_constants)                         # Available time constants (s)
lockin.time_constant = 2                             # Select the 3rd time constant of the list
lockin.time_constant_value = 0.1                     # Select the time constant closest to 100 ms

lockin.set_auto_scale()                              # Auto gain (returns 0 if not supported)
lockin.disconnect_device()                           # Disconnect the device

Connecting directly to a device with a known address and model (no scan, works also on serial ports):

from pySRSLockin.driver import SRS_Lockin
lockin = SRS_Lockin()
msg, ID = lockin.connect_device('GPIB0::23::INSTR', model='SR510')
if ID == 1:
    print(lockin.X)
    lockin.disconnect_device()

Usage as a stand-alone GUI interface

The installation sets up an entry point for the GUI. Just typing

pySRSLockin

in the command prompt will start the GUI (add -s to reduce the verbosity of the logs).

The GUI shows the available devices (refresh button next to the list), and allows to:

• select which outputs are read continuously (checkboxes next to each output), and the refresh time;
• start/pause the continuous reading (button on the left);
• select time constant and sensitivity, run the auto-scale/auto-gain of the instrument, or enable a software-controlled auto-sensitivity, which keeps the signal amplitude (mag, or |X| for the SR510) between 20% and 80% of the full scale;
• read and set the reference frequency and phase (type a value and press Enter), and change the phase by ±1 or ±10 degrees with the buttons next to it.

Frequency and phase are read at most once per second during continuous reading. The settings (refresh time, outputs to read, software auto-sensitivity) are saved in the file config.json when the GUI is closed.

The GUI adapts to the connected model: outputs, functions and settings that are not available are disabled. For example, with an SR510 only X, aux1 and aux2 can be read, the auto-scale button is disabled, and the frequency cannot be edited:

Embed the GUI within another GUI

The GUI controller can also be easily integrated within a larger graphical interface, as shown in the example below.

import PyQt5.QtWidgets as Qt  # QApplication, QWidget, QGridLayout, QLabel, QVBoxLayout
import pySRSLockin

app = Qt.QApplication([])
window = Qt.QWidget()

# The GUI needs to be contained inside a widget object
widget_containing_interface_GUI = Qt.QWidget()
widget_containing_interface_GUI.setStyleSheet(
    ".QWidget {\n"
    "border: 1px solid black;\n"
    "border-radius: 4px;\n"
    "}"
)

# Create the interface object for the lock-in
Interface = pySRSLockin.interface(app=app)
Interface.verbose = False  # set the verbosity of the interface logger to False
# At any time during the software execution, the data read by the instrument can be accessed via Interface.output,
# a dictionary with keys 'X', 'Y', 'mag', 'theta', 'aux1', 'aux2' (outputs not read are nan).
# Moreover, one could also set up a signal to automatically call another function whenever new data are read, by
#
#       Interface.sig_updated_data.connect(foo)
#
# Every time data are read from the instrument, the function foo is called and the dictionary Interface.output is passed as argument

# Create the GUI for the lock-in
view = pySRSLockin.gui(interface=Interface, parent=widget_containing_interface_GUI)

# Create additional GUI
gridlayoutwidget = Qt.QWidget()
gridlayout = Qt.QGridLayout()
gridlayout.addWidget(Qt.QLabel("Additional GUI 1"), 0, 0)
gridlayout.addWidget(Qt.QLabel("Additional GUI 2"), 1, 0)
gridlayout.addWidget(Qt.QLabel("Additional GUI 3"), 0, 1)
gridlayout.addWidget(Qt.QLabel("Additional GUI 4"), 1, 1)
gridlayoutwidget.setLayout(gridlayout)

layout = Qt.QVBoxLayout()
layout.addWidget(widget_containing_interface_GUI)
layout.addWidget(gridlayoutwidget)
layout.addStretch(1)
window.setLayout(layout)

app.aboutToQuit.connect(Interface.close)  # disconnect the device and save the settings when closing
window.show()
app.exec()  # Start the event loop.