The practical differences between GPIB, USB, LAN, and serial for instrument control, measured in latency and throughput rather than marketing, and a clear recommendation per situation.

For SCPI command traffic, the interface barely matters, because instrument response time dominates. For large waveform transfers and for remote access, LAN wins clearly. That is the short answer, and most interface debates are about the cases where it does not apply.
This post covers the real differences in latency and throughput, the cost and reliability trade-offs, and which to choose for each situation.
| Interface | VISA resource string | Typical use |
|---|---|---|
| LAN (LXI) | TCPIP0::192.168.1.42::inst0::INSTR | Racks, shared instruments, remote access |
| USB (USBTMC) | USB0::0x2A8D::0x1301::MY57200001::INSTR | Single instrument at a desk |
| GPIB (IEEE 488) | GPIB0::22::INSTR | Legacy instruments, established racks |
| Serial (RS-232) | ASRL3::INSTR | Older or simple instruments |
A typical validation script sends thousands of short commands. Each one is a round trip, so per-command latency multiplied by command count is your run time, not bandwidth.
Rough order of magnitude for a short command and response:
| Interface | Typical round trip |
|---|---|
| GPIB | 1 to 3 ms |
| USB (USBTMC) | 1 to 3 ms |
| LAN (TCP) | 1 to 5 ms |
| Serial at 115200 baud | 5 to 20 ms |
The spread between GPIB, USB, and LAN is small and is usually swamped by the instrument's own processing time. A DMM at NPLC 10 takes 200 ms to produce a reading, which makes a 2 ms difference in transport irrelevant.
The practical conclusion: if your script is slow, the cause is almost never the interface. It is settling delays, per-command round trips that could be combined, or ASCII transfers that should be binary. See the speed section in automating a Keysight power supply.
Here the interfaces genuinely differ.
| Interface | Practical throughput |
|---|---|
| GPIB (IEEE 488.1) | ~1 MB/s |
| GPIB (HS488) | up to ~8 MB/s |
| USB 2.0 (USBTMC) | ~10 to 30 MB/s practical |
| LAN gigabit | ~50 to 100 MB/s practical |
| Serial | ~11 KB/s at 115200 |
Transferring a 10 million point waveform record at 2 bytes per point is 20 MB. Over GPIB that is 20 seconds. Over gigabit LAN it is under a second.
Two caveats. Many instruments cannot source data at their interface's rate, so the instrument becomes the limit rather than the cable. And always use binary transfer regardless of interface, because ASCII inflates the same data roughly fivefold.
GPIB
USB
*IDN? rather than hardcoding where you can.LAN
Serial
| Interface | Cost to add to a PC |
|---|---|
| LAN | Free, already present |
| USB | Free, already present |
| GPIB | $300 to $1,000 for an adapter or card |
| Serial | $10 to $50 for a USB adapter |
GPIB is the only one with a real cost, and it is per computer.
Set a static IP or a DHCP reservation. This is the single most important operational detail. An instrument that changes address breaks every script silently, and the symptom looks like a broken instrument.
Discover rather than hardcode the resource string, because it contains the serial number.
This is the part that matters most and takes the least effort. Keep the address in configuration, never in the test.
# instruments.yaml
# psu: TCPIP0::192.168.1.42::inst0::INSTR
# dmm: USB0::0x2A8D::0x1301::MY57200001::INSTR
# load: GPIB0::8::INSTR
import yaml, pyvisa
def open_bench(config_path: str) -> dict:
config = yaml.safe_load(open(config_path))
rm = pyvisa.ResourceManager()
bench = {}
for name, address in config.items():
inst = rm.open_resource(address)
inst.timeout = 10000
idn = inst.query("*IDN?").strip()
print(f"{name}: {idn}")
bench[name] = inst
return benchNow moving an instrument from USB to LAN, or replacing a unit with a different serial number, is a one-line configuration change rather than a search across every script.
Also worth doing: record the *IDN? response of every instrument into the test results. When a result looks wrong six months later, knowing exactly which serial number produced it is the difference between an answer and a guess. See automated test report generation.
There is no requirement to standardise. A typical working bench runs the scope and supply on LAN because they are racked, the DMM on USB because it sits on the desk, and a twenty-year-old source on GPIB because that is all it has.
PyVISA handles all three identically, and with the addresses in configuration the test code cannot tell the difference. That is the correct outcome.
A structured order, fastest checks first. This resolves most problems in under five minutes.
LAN
ping 192.168.1.42. No reply means networking, not instruments.
Open http://192.168.1.42 in a browser. Most LXI instruments serve a page, which confirms the instrument is up and reachable.
Raw socket to port 5025 and send *IDN?. This bypasses VISA entirely, so if it works and PyVISA does not, the problem is your VISA layer.
Check the instrument's front panel for its actual IP. DHCP may have moved it.
USB
Check the operating system sees the device at all. Device Manager on Windows, lsusb on Linux.
Confirm the driver is USBTMC rather than a vendor-specific one. Some vendor software installs a driver that claims the device and blocks VISA.
rm.list_resources() and look for a USB0:: string.
Unplug, wait, replug. USBTMC enumeration genuinely does get stuck, particularly after a sleep cycle.
Try a different port, avoiding hubs.
GPIB
Confirm the adapter appears in NI-MAX or Keysight Connection Expert.
Check the instrument's GPIB address on its front panel, and check no two instruments share it.
Check cabling and termination. GPIB needs devices powered on to pass the bus through.
Scan for instruments from the adapter's utility, which is faster than guessing addresses.
Serial
Confirm the COM port number.
Match baud rate, data bits, parity, and stop bits to the instrument's front panel settings. A mismatch produces silence, not an error.
Set read_termination and write_termination explicitly, usually "\n" or "\r\n".
The single most useful diagnostic across all four is step 3 for LAN: a raw socket. It removes every software layer between you and the instrument, so a working raw socket and a failing PyVISA call localises the fault immediately.
Once instruments are on LAN, they are on a network with other things, and that has consequences worth planning for.
The general answer is LAN. The exceptions are worth knowing, because they are the cases where the general answer costs you.
| Instrument class | Best interface | Why |
|---|---|---|
| DMM in a logging role | LAN | Long runs, remote access, no host dependency |
| Oscilloscope pulling full-depth records | LAN, or USB for a single bench | Throughput dominates, and LAN scales |
| Power supply | LAN | Set-and-forget, and remote power control is genuinely useful |
| Function generator | LAN or USB | Low data volume, either is fine |
| Switch matrix or scanner | LAN | Often lives in a rack, away from the host |
| Legacy instrument, pre-2005 | GPIB | Frequently the only option |
| Anything in a shielded chamber | LAN over fibre, or GPIB | Cable routing and ground isolation |
| A temporary bring-up on a laptop | USB | Zero configuration, plug in and go |
The shielded-chamber row is the one that catches RF teams: a copper LAN cable through a chamber wall is a ground path and an antenna. Fibre media converters solve it and GPIB opto-isolators are the older answer.
The one real disadvantage of LAN is that an instrument can move. Three settings, done once, remove the problem.
Reserve the address by MAC on your DHCP server, or set a static IP outside the DHCP pool. An instrument whose address changes breaks every script that names it.
Set the hostname on the instrument and use it in the resource string. TCPIP0::psu-bench3::inst0::INSTR survives a re-address; a hard-coded IP does not.
Record the mDNS name if the instrument advertises one. Most LXI instruments do, which makes discovery work without any server configuration at all.
import pyvisa
rm = pyvisa.ResourceManager()
for res in rm.list_resources():
try:
with rm.open_resource(res, open_timeout=2000) as inst:
inst.timeout = 2000
print(f"{res:45} {inst.query('*IDN?').strip()}")
except Exception as exc:
print(f"{res:45} unreachable ({type(exc).__name__})")Run that after any bench change and paste the output into your bench README. It takes ten seconds and answers the "which instrument is which" question that otherwise costs an afternoon.
The interface should be an implementation detail. It becomes a project when tests are written against one transport and the bench later changes.
Connect your instruments. Pick the manufacturer and model, paste the VISA address (USB, LAN, GPIB, or serial), and the agent knows what is on your bench. No bench yet? Use a placeholder address, build the full automation, and swap in the real address when you are in the lab.
Tell the agent what to test, in plain English. For example, "run a VI sweep from 1 to 10 V in 1 V steps at 0.5 A load current," or "suggest the tests for a power-management device."
The agent builds the complete workflow in seconds. Instrument-aware automation appears on the canvas, with the generated scripts visible in a code panel you can inspect and edit.
Run it in your lab. Click Run and the status panel streams results step by step, with measured values inline (VOUT = 3.301 V, asserted 3.2 to 3.4 V, PASS). One click exports a structured PDF report, or the raw results as CSV.


The step-by-step walkthrough, VISA address formats, and Test Planner prompts are all in the TestFlow product guide.
Yes, widely, because instruments last decades and a great deal of installed equipment has only GPIB. New instruments almost always offer USB and LAN as well, but GPIB persists in established labs and in racks built around it.
For small SCPI commands both are dominated by instrument response time and the difference is negligible. For large waveform transfers, gigabit LAN typically wins, though many instruments do not saturate either interface.
LAN eXtensions for Instrumentation, a standard defining how instruments behave on Ethernet, including discovery, web interfaces, and triggering. An LXI instrument is a LAN instrument that follows agreed conventions.
You need a GPIB interface on the computer, either a PCIe card or a USB-to-GPIB adapter. Adapters are more common now and work well, though they add a small latency compared with a card.
Technically yes if the instrument is on a wireless network, but it is not recommended for test. Latency varies and packets drop, which produces intermittent timeouts that are extremely difficult to distinguish from instrument faults.
LAN for anything that will be shared, racked, or accessed remotely. USB for a single instrument on a single engineer's desk. GPIB only when the instrument has nothing else.
Connect your instruments, describe a test in plain English, and TestFlow builds and runs it in minutes.
A new way for testing, from specs to automated sequences, capture clean data, and accelerate your validation cycle.