What Is an Operator Interface for Manufacturing Test
An operator interface is the screen a production floor worker sees when running a test. It handles serial number entry, displays pass/fail results, shows prompts for manual steps, and logs everything without the operator touching code. This guide covers what an operator interface should include, how the major test frameworks handle it, and how to set one up with OpenHTF and TofuPilot.
Why Operators Need a Dedicated Interface
Test engineers write Python scripts. Operators run them. These are different jobs with different needs.
| Test Engineer | Operator |
|---|---|
| Writes and debugs test code | Runs tests hundreds of times per shift |
| Reads terminal output | Needs large pass/fail indicators |
| Knows what each phase does | Needs step-by-step instructions |
| Has Python installed | May not know what Python is |
| Works on one station | May rotate between stations |
Running a test from a terminal works during development. In production, the operator needs a purpose-built screen that removes complexity and prevents mistakes.
What an Operator Interface Should Include
| Feature | Why |
|---|---|
| Serial number input | Barcode scanner or manual entry to identify each DUT |
| Start/stop controls | One button to begin, one to abort |
| Pass/fail display | Large, color-coded result visible from a distance |
| Phase progress | Shows which step is running and how many remain |
| Operator prompts | Asks for manual actions (flip board, connect cable, visual check) |
| Input fields | Captures operator observations (dropdown, checkbox, text, numeric) |
| Measurement display | Shows live readings during the test |
| Error messages | Clear instructions when something goes wrong |
| Test history | Last few results for the current station |
How Test Frameworks Handle Operator Interfaces
NI TestStand
TestStand ships with pre-built operator interfaces in LabVIEW, C#, and VB.NET. The source code is provided so you can customize it. It supports user roles (operator, developer, admin), concurrent test executions, and report generation.
Strengths: Mature, full-featured, customizable. Weaknesses: Requires a TestStand license ($3-5K per seat), Windows only, tied to the NI ecosystem.
OpenTAP
OpenTAP offers an operator panel plugin that provides a simplified view for running test plans. It includes a "focus mode" that minimizes interactions to start/stop and pass/fail.
Strengths: Open source core, cross-platform. Weaknesses: .NET ecosystem, sparse documentation, basic operator UI.
OpenHTF
OpenHTF includes a built-in Station Server that serves a web interface at localhost:12000. It shows test status, phase progress, and handles operator prompts through the browser.
Strengths: Web-based (works on any device with a browser), no installation needed on the operator's machine. Weaknesses: The built-in UI is minimal. For production use, most teams pair OpenHTF with a dedicated frontend.
pytest with HardPy
HardPy adds a browser-based operator panel to pytest. It shows test hierarchy, dialog boxes for operator input, and real-time charts.
Strengths: pytest-native, modern web UI. Weaknesses: New project, limited adoption, basic feature set.
Comparison Table
| Feature | TestStand | OpenTAP | OpenHTF + TofuPilot | HardPy |
|---|---|---|---|---|
| Serial number input | Yes | Yes | Yes | Yes |
| Pass/fail display | Yes | Yes | Yes (streaming) | Yes |
| Operator prompts | Yes | Limited | Yes (15+ input types) | Yes (dialogs) |
| Image-based inputs | No | No | Yes | No |
| Real-time streaming | Yes | Limited | Yes (MQTT) | Yes |
| Role management | Yes | No | Yes | No |
| Web-based | No (desktop) | No (desktop) | Yes | Yes |
| Kiosk mode | Manual setup | No | Yes | No |
| Cost | $3-5K/seat | Free (core) | Free (Lab tier) | Free |
| Platform | Windows | Windows/Linux | Any browser | Any browser |
Prerequisites
- Python 3.10+
- OpenHTF installed (
pip install openhtf) - TofuPilot Python SDK installed (
pip install tofupilot)
Step 1: Add Operator Prompts to Your Test
OpenHTF handles operator interaction through prompts. The operator sees a message and optionally provides input before the test continues.
import openhtf as htf
from openhtf.plugs import user_input
@htf.plug(prompts=user_input.UserInput)
def phase_visual_inspection(test, prompts):
"""Ask the operator to perform a visual check."""
prompts.prompt(
"Inspect the board for solder bridges or missing components. "
"Press Enter when done."
)
@htf.plug(prompts=user_input.UserInput)
@htf.measures(
htf.Measurement("operator_serial").with_args(docstring="Scanned serial number"),
)
def phase_scan_serial(test, prompts):
"""Prompt the operator to scan the DUT serial number."""
serial = prompts.prompt(
"Scan the barcode on the DUT label.",
text_input=True,
)
test.measurements.operator_serial = serialStep 2: Stream to TofuPilot Operator UI
TofuPilot provides a web-based operator interface that streams test progress in real time. The operator sees prompts, measurements, and pass/fail results in a browser. No terminal, no code.
from tofupilot.openhtf import TofuPilot
test = htf.Test(
phase_scan_serial,
phase_visual_inspection,
)
with TofuPilot(test):
test.execute(test_start=lambda: input("Scan serial: "))When the test runs, TofuPilot streams the interface to a URL the operator can open on any device. The console prints the URL automatically.
Step 3: Deploy for Production
For production use, set up the operator station so the browser opens automatically in full-screen mode:
| Setting | Recommendation |
|---|---|
| Browser | Chrome or Edge in kiosk mode (full screen, no address bar) |
| Display | Large monitor or touchscreen at the test station |
| Input | Barcode scanner configured as keyboard input |
| Font size | Browser zoom to 125-150% for readability at arm's length |
| Auto-start | Launch browser on boot, navigate to the TofuPilot streaming URL |
The operator's workflow becomes: scan barcode, follow prompts, see pass/fail. No terminal, no file system, no Python knowledge required.
Choosing the Right Approach
| Situation | Recommendation |
|---|---|
| Already using TestStand | Use the built-in OI unless you're migrating away |
| Python-based tests, need a quick UI | OpenHTF + TofuPilot streaming (no frontend code to write) |
| pytest-based tests | HardPy for basic prompts, or TofuPilot for full operator UI |
| Custom requirements (branded, multi-station dashboard) | Build a custom frontend against the TofuPilot API |
| Budget is zero, needs to work today | OpenHTF Station Server at localhost:12000 |