Self-Hosted Lab Instrument Control Servers: lxi-tools vs PyVISA vs SCPI-Parser

Introduction

Modern electronics labs are filled with programmable instruments — oscilloscopes, multimeters, power supplies, spectrum analyzers, and signal generators — all capable of remote control via standard protocols like SCPI (Standard Commands for Programmable Instruments), VISA (Virtual Instrument Software Architecture), and LXI (LAN eXtensions for Instrumentation). But without a centralized control server, each instrument remains an isolated island, requiring manual interaction through its front panel.

Self-hosted instrument control servers transform your lab into a networked test infrastructure. Instead of walking to each instrument to change settings or capture measurements, you access everything through a unified web interface or API. Automated test sequences can iterate through hundreds of measurement points overnight while you sleep — waking up to a complete dataset rather than hours of manual knob-turning.

This guide compares three leading open-source approaches to self-hosted instrument control: lxi-tools (LXI discovery and control), PyVISA (the Pythonic VISA bridge), and SCPI-Parser (lightweight SCPI device emulation). Each serves a distinct role in the lab automation ecosystem.

Why Self-Host Your Instrument Control?

The traditional lab workflow involves a dedicated Windows PC running vendor-specific software (Keysight BenchVue, Tektronix TekScope, Rigol UltraScope) connected to instruments via USB or GPIB. This model has several limitations: it ties you to a single physical workstation, vendor lock-in prevents mixing instruments from different manufacturers, and automated test sequences require complex scripting in proprietary languages.

A self-hosted control server running on a Raspberry Pi or small Linux machine in your lab eliminates all of these problems. Instruments connect via Ethernet (LXI/VXI-11) or USB-to-GPIB adapters, and you access them through a web dashboard or REST API from any device on your network — your laptop, tablet, or even a CI/CD pipeline.

For related lab infrastructure, see our self-hosted JTAG and SWD remote debug servers guide. For hardware monitoring, check out our bare-metal IPMI and Redfish comparison. If you’re building a complete electronics lab workflow, our electronic lab notebook guide covers documenting your results.

Comparison Table

lxi-tools: Discover and Control LXI Instruments

lxi-tools is the Swiss Army knife for LXI-compatible instruments. Its primary superpower is automatic discovery — with a single command, it scans your network and identifies every LXI instrument, displaying their IP addresses, manufacturer names, model numbers, and serial numbers. For a lab with a dozen instruments spread across multiple subnets, this alone saves hours of manual configuration.

Key Features

• Network discovery: lxi discover scans the local subnet using mDNS and VXI-11 broadcasts to find every LXI-compatible instrument
• Screenshot capture: lxi screenshot captures the instrument’s display as a PNG image — invaluable for documenting test setups
• SCPI command execution: lxi scpi sends individual SCPI commands and returns instrument responses
• Scripting mode: Chain multiple commands together for basic automated sequences
• GUI application: lxi-gui provides a graphical interface for interactive instrument control

Installation

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# Install on Debian/Ubuntu
sudo apt update
sudo apt install lxi-tools

# Verify installation
lxi --version

# Build from source for latest features
git clone https://github.com/lxi-tools/lxi-tools.git
cd lxi-tools
./autogen.sh
./configure
make -j$(nproc)
sudo make install

Docker Deployment

For lab servers that need always-on instrument access:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# docker-compose.yml
version: '3'
services:
  lxi-server:
    image: ghcr.io/lxi-tools/lxi-tools:latest
    network_mode: "host"  # Required for instrument discovery
    volumes:
      - ./screenshots:/data/screenshots
      - ./scripts:/data/scripts
    command: ["lxi", "discover", "--scan"]

Automated Test Sequence

Here’s a practical example — capturing a frequency response curve from a signal generator and oscilloscope:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

#!/bin/bash
# sweep_test.sh - Automated frequency sweep test
SIGNAL_GEN="192.168.1.100"
OSCILLOSCOPE="192.168.1.101"
OUTPUT_DIR="./sweep_results"

mkdir -p "$OUTPUT_DIR"

# Configure instruments
lxi scpi --address "$SIGNAL_GEN" "OUTP ON"
lxi scpi --address "$OSCILLOSCOPE" ":TIM:SCAL 1e-3"

# Frequency sweep from 1kHz to 10MHz
for freq in 1000 5000 10000 50000 100000 500000 1000000 5000000 10000000; do
    echo "Testing at $freq Hz"
    lxi scpi --address "$SIGNAL_GEN" "FREQ $freq"
    sleep 0.5
    lxi scpi --address "$OSCILLOSCOPE" ":MEAS:VPP?" > "$OUTPUT_DIR/vpp_${freq}hz.txt"
    lxi screenshot --address "$OSCILLOSCOPE" --output "$OUTPUT_DIR/screenshot_${freq}hz.png"
done

echo "Sweep complete. Results in $OUTPUT_DIR"

PyVISA: The Pythonic Instrument Bridge

PyVISA is the most versatile option for lab automation — it provides a Python frontend to the VISA library, enabling control of virtually any instrument regardless of its physical interface. Whether your oscilloscope connects via USB, GPIB, Ethernet (VXI-11), or serial port, PyVISA speaks its language.

Key Features

• Universal backend: Works with NI-VISA, Keysight VISA, R&S VISA, and the pure-Python PyVISA-py backend
• Asynchronous I/O: Non-blocking instrument operations for parallel test setups
• Resource manager: Automatic discovery of connected instruments via VISA resource strings
• Integration ecosystem: Works with NumPy, Matplotlib, Pandas, and Jupyter for data analysis
• Shell environment: pyvisa-shell provides an interactive REPL for instrument exploration

Installation

1
2
3
4
5
6
7
8

# Install with pure-Python backend (no vendor drivers needed)
pip install pyvisa pyvisa-py

# Verify
python3 -c "import pyvisa; print(pyvisa.__version__)"

# For GPIB support via linux-gpib
pip install pyvisa-py gpib-utils

Self-Hosted Instrument Server with Flask

Here’s a complete web dashboard that exposes instrument control via a REST API:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

# instrument_server.py
from flask import Flask, jsonify, request
import pyvisa
import time

app = Flask(__name__)

class InstrumentManager:
    def __init__(self):
        self.rm = pyvisa.ResourceManager('@py')
        self.instruments = {}

    def discover(self):
        resources = self.rm.list_resources()
        result = []
        for res in resources:
            try:
                inst = self.rm.open_resource(res)
                idn = inst.query('*IDN?').strip()
                self.instruments[idn] = inst
                result.append({"address": res, "identity": idn})
            except:
                result.append({"address": res, "identity": "unknown"})
        return result

    def measure(self, identity, command):
        if identity not in self.instruments:
            return {"error": "Instrument not found"}
        try:
            value = self.instruments[identity].query(command).strip()
            return {"result": value, "timestamp": time.time()}
        except Exception as e:
            return {"error": str(e)}

manager = InstrumentManager()

@app.route('/api/discover')
def discover():
    return jsonify(manager.discover())

@app.route('/api/measure')
def measure():
    identity = request.args.get('instrument')
    command = request.args.get('command', '*IDN?')
    return jsonify(manager.measure(identity, command))

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Docker Compose for PyVISA Server

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

version: '3'
services:
  instrument-server:
    image: python:3.12-slim
    network_mode: "host"
    volumes:
      - ./instrument_server.py:/app/server.py
      - ./requirements.txt:/app/requirements.txt
    working_dir: /app
    command: >
      sh -c "pip install -r requirements.txt && python3 server.py"
    environment:
      - PYVISA_LIBRARY=@py

SCPI-Parser: Lightweight Device Emulation

While lxi-tools and PyVISA focus on controlling real instruments, SCPI-Parser solves the inverse problem: implementing the SCPI protocol in your own embedded devices or test fixtures. If you’re building custom lab equipment — a programmable load, a temperature chamber controller, or a precision voltage reference — SCPI-Parser gives you standard SCPI command handling without writing a parser from scratch.

Key Features

• Minimal footprint: Designed for embedded systems and microcontrollers
• Full SCPI compliance: Supports mandatory SCPI-99 commands (*IDN?, *RST, *OPC, etc.)
• Command tree: Define arbitrary command hierarchies with numeric suffixes
• Error queue: Standard SCPI error handling (-100 “Command Error”, -200 “Execution Error”, etc.)
• Python bindings: Use from Python for rapid prototyping and test fixture development

Building a Custom Instrument Server

Here’s how to create a SCPI-compatible programmable power supply server:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

// ps_server.c - SCPI-compatible power supply emulator
#include "scpi/scpi.h"
#include <stdio.h>

static scpi_result_t PS_VoltageSet(scpi_t *context) {
    double value;
    if (!SCPI_ParamDouble(context, &value, true)) {
        return SCPI_RES_ERR;
    }
    // Set DAC output voltage
    set_dac_voltage(0, value);
    return SCPI_RES_OK;
}

static scpi_result_t PS_CurrentMeas(scpi_t *context) {
    double current = read_adc_current(0);
    SCPI_ResultDouble(context, current);
    return SCPI_RES_OK;
}

// Command registration
static const scpi_command_t ps_commands[] = {
    {.pattern = "SOURce:VOLTage", .callback = PS_VoltageSet},
    {.pattern = "MEASure:CURRent?", .callback = PS_CurrentMeas},
    SCPI_CMD_LIST_END
};

int main() {
    scpi_t scpi_context;
    SCPI_Init(&scpi_context, ps_commands, NULL, ...);
    // Listen on TCP port 5025
    tcp_server_loop(5025, &scpi_context);
    return 0;
}

Python-Based Test Fixture with SCPI-Parser

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# fixture_server.py - Quick SCPI-compatible test fixture
from scpi_server import ScpiServer, command

class TestFixture(ScpiServer):
    @command("SOURce:VOLTage")
    def set_voltage(self, value):
        self.gpio_set_dac(0, float(value))

    @command("MEASure:RESistance?")
    def measure_resistance(self):
        return f"{self.read_adc(1):.3f}"

    @command("*IDN?")
    def identify(self):
        return "CustomLab,TestFixture,v1.0,SN001"

server = TestFixture(port=5025)
server.run()

Choosing the Right Approach

• Quick instrument access: If your primary need is discovering, sending commands, and capturing screenshots from existing commercial instruments, start with lxi-tools. Its CLI-first approach gets you productive in minutes without writing code.

• Complex test automation: For multi-instrument test sequences that involve data analysis, plotting, and report generation, PyVISA paired with Python’s scientific ecosystem (NumPy, Matplotlib, Jupyter) is the right choice. The initial setup takes more effort, but the automation payoff is enormous.

• Building custom instruments: If you’re designing your own lab equipment and want it to speak standard SCPI so it interoperates with existing automation frameworks, SCPI-Parser handles the protocol layer while you focus on the hardware.

The three tools work in concert: use lxi-tools for instrument discovery and manual control, PyVISA for automated test scripts, and SCPI-Parser when building your own SCPI-compatible instruments. Together they form a complete open-source lab automation stack.

FAQ

Do I need vendor-specific drivers to use PyVISA?

Not necessarily. PyVISA-py is a pure-Python backend that implements VXI-11 (TCP/IP) and USBTMC protocols without requiring NI-VISA or any vendor drivers. For GPIB instruments, you’ll need linux-gpib and a compatible GPIB adapter. The pure-Python backend works for most Ethernet-connected instruments manufactured in the last 15 years.

How do I connect to instruments that only have USB (not Ethernet)?

Use a Raspberry Pi as a USB-to-Ethernet bridge. Connect the instrument via USB to the Pi, install PyVISA with the USBTMC backend, and expose the instrument via a TCP socket. lxi-tools can also bridge USB instruments using the usbtmc kernel module on Linux.

Can I run automated tests that span multiple days?

Yes. Deploy the instrument server on a dedicated machine (or Raspberry Pi) that stays powered on. Use tmux or screen to run long-duration test scripts, or implement test sequencing with a scheduler like systemd timers. The Flask server example above runs indefinitely, accepting measurement requests from any client on your network.

What instruments are compatible with lxi-tools?

Any instrument that complies with the LXI standard (version 1.0 or later). This includes most modern oscilloscopes, multimeters, power supplies, and spectrum analyzers from Keysight, Tektronix, Rigol, Siglent, Rohde & Schwarz, and many others. You can verify LXI compliance by checking the instrument’s specifications or running lxi discover on your network.

How do I secure lab instrument access on a shared network?

Put your instruments on a separate VLAN with firewall rules that only allow access from authorized lab servers. For the instrument web server, add HTTP basic authentication or an OAuth2 proxy. Never expose instrument control interfaces directly to the internet — SCPI over raw TCP has no built-in authentication.

💰 想测试你的市场判断力？我用 Polymarket 做预测市场交易——这是全球最大的预测市场平台，从大选结果到技术监管时间线，什么都可以押注。和赌博不同，这是真正的信息市场：你懂的信息越多，胜率越高。我靠预测技术相关事件的走向已经赚了不少。用我的邀请链接注册：Polymarket.com