Automating EXFO Instruments with SCPI: A Practical Guide

In today's fast-paced world of telecom, datacom, and optical network testing, automation is no longer a luxury — it's essential. If you're using EXFO instruments like the NetBlazer, Power Blazer, or iOLM modules, mastering SCPI (Standard Commands for Programmable Instruments) can save you countless hours and unlock powerful test workflows.

In this blog post, we'll dive into:

What SCPI is
How EXFO instruments use SCPI
Key SCPI commands for EXFO
How to build simple Python scripts to automate your testing

Let's get started!

🌟 What is SCPI?

SCPI (pronounced "skippy") is an industry-standard language for controlling test instruments. It's a set of human-readable text commands that allow you to remotely:

Configure settings
Start and stop measurements
Fetch test results
Handle errors and statuses

If you've ever typed *IDN? to query a device's identity, you've used SCPI!

📊 How EXFO Instruments Use SCPI

EXFO platforms like the FTB-1 Pro, FTB-2 Pro, and FTB-4 Pro, along with modular instruments like the FTBx-88480 (Power Blazer) or FTBx-8880 (NetBlazer), support SCPI over TCP/IP or Telnet sessions.

Each inserted module (called a "slot") is addressed logically using a LINSx ID, like LINS0, LINS2, etc. This allows you to direct SCPI commands specifically to the correct module, even if multiple instruments are present.

Before sending any commands, you should:

Discover available modules using STATUS MODULE
Connect to the desired LINS if needed using CONNECT LINSx

🌐 Basic SCPI Commands for EXFO

Here are some of the most important SCPI commands you need to know:

Command	Purpose
`*IDN?`	Query the instrument identification
`*RST`	Reset the module to factory default settings
`*CLS`	Clear the event and error queues
`STATUS MODULE`	List all available modules and their LINS IDs
`CONNECT LINSx`	Connect to a specific module
`LINSx:SOUR:DATA:TELecom:TEST:TYPE RFC2544`	Configure a test type
`LINSx:SOUR:DATA:TELecom:TEST`	Start the test
`LINSx:SOUR:DATA:TELecom:TEST:STOP`	Stop a running test
`FETCh:DATA:TELecom:RFC2544:SUMMary?`	Fetch RFC 2544 summary results

These basic commands let you fully automate test cycles from initialization to result collection.

🚀 Simple Python Automation Example

Controlling EXFO devices from Python is easy using raw TCP sockets. Here's a basic example:

import socket

def send_scpi_command(command):
    ip = "192.168.1.100"
    port = 5025
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
        s.connect((ip, port))
        s.sendall((command + "\r\n").encode())
        response = s.recv(4096).decode()
        return response.strip()

# Example usage
print(send_scpi_command("*IDN?"))
print(send_scpi_command("STATUS MODULE"))

For production-grade scripts, you'd want to handle timeouts, retries, and errors more gracefully, but this gives you a functional starting point.

🎓 Pro Tips for SCPI with EXFO

Always use STATUS MODULE before sending commands to ensure your LINS exists.
Use *CLS before starting new tests to avoid unexpected errors.
After starting a test, poll LINSx:SOUR:DATA:TELecom:TEST? until it reports "COMPLETED" before fetching results.
Handle error messages like "Index out of bounds" carefully — it usually means you sent a command to a non-existent object.

🌍 Conclusion

SCPI opens the door to powerful automation with EXFO's field-proven instruments. Whether you're validating metro Ethernet networks, mobile backhaul links, or datacenter fiber, automating your test setups can drastically improve efficiency and consistency.

Mastering just a handful of SCPI commands gives you full control over test configuration, execution, and reporting.

Stay tuned for the next post where we'll build a complete Python SCPI test controller for EXFO platforms!

Happy testing! 🚀