# Bundled Plugs
URL: /reference/bundled-plugs

The plugs that ship with OpenHTF — UserInput, ADB and Fastboot over USB (openhtf.plugs.usb), Cambrionix USB hubs, SerialCollectionPlug for serial logging, DeviceWrappingPlug — with install extras, configuration keys and usage.

OpenHTF is not an instrument library, but a handful of plugs ship in `openhtf.plugs`. They cover the operator, Android devices over USB, USB hub control and serial port capture. Anything else — SCPI instruments, PLCs, your own DUT protocol — you write yourself, following the instrument guides.

Plug

Module

Extra

Purpose

`UserInput`

`openhtf.plugs.user_input`

—

Operator prompts (console and Operator UI)

`AdbDevice`

`openhtf.plugs.usb.adb_device`

`usb-plugs`

Android Debug Bridge over USB, no `adb` binary

`FastbootDevice`

`openhtf.plugs.usb.fastboot_device`

`usb-plugs`

Fastboot protocol over USB

`LibUsbHandle`

`openhtf.plugs.usb.local_usb`

`usb-plugs`

Raw USB bulk endpoints via libusb1

`EtherSync`

`openhtf.plugs.cambrionix`

—

Cambrionix USB hub: map port → device serial, open a handle

`SerialCollectionPlug`

`openhtf.plugs.generic.serial_collection`

`serial-collection-plug`

Background capture of a serial port to a file

`DeviceWrappingPlug`

`openhtf.plugs.device_wrapping`

—

Base class that proxies attribute access to a wrapped device object

The one plug every production test uses. Covered on the Plugs page (`prompt`, `text_input`, `timeout_s`, `image_url`) and on Device Under Test (`prompt_for_test_start`).

`pip install "openhtf[usb-plugs]"` pulls in `libusb1` and `M2Crypto`. The plugs speak the ADB and Fastboot wire protocols directly over libusb — no platform `adb` install, no daemon fighting your test for the device.

`command(cmd, raw=False, timeout_ms=None)`, `async_command(...)`, `push(local, remote)`, `pull(remote, local=None)`, `install(apk_path)`, `list(path)`, `reboot(destination='')`, `remount()`, `root()`, `get_serial()`, `get_system_type()`, `close()`. Authentication uses an RSA key via `M2CryptoSigner` when the device requires it.

`connect(usb_handle)`, `get_boot_config(name)`, `set_boot_config(name, value)`, `lock()`, `close()`; flashing helpers live in `fastboot_protocol`.

`open(**filters)` / `iter_open(**filters)` by `serial_number`, `port_path`, interface class/subclass/protocol; `read(length, timeout_ms)`, `write(data, timeout_ms)`, `port_path`, `is_closed()`, `close()`.

`openhtf.plugs.cambrionix.EtherSync(mac_address)` talks to a Cambrionix EtherSync-capable hub and gives `get_usb_serial(port_num)` and `open_usb_handle(port_num)`, so a fixture can address "the DUT on port 3" instead of a serial number that changes with every unit.

Streams everything a serial port emits — a DUT's boot log, a modem trace — to a file while other phases run.

The constructor uses `@CONF.inject_positional_args`, so the two keys must be declared/loaded before the plug is instantiated. Importing the module without `pyserial` installed raises with an explicit hint to install the extra.

A base class for plugs that wrap an existing driver object: set `self._device` and attribute access falls through to it, with logging of each call. Useful to expose a vendor SDK object as a plug without writing pass-through methods.

Everything else is a subclass of `BasePlug` with `__init__`, methods and `tearDown()`. The instrument guides show the three most common transports:

<Card title="PyVISA plug" href="/guides/pyvisa-plug" description="SCPI over USB, GPIB, LAN, serial." />

<Card title="pyserial plug" href="/guides/pyserial-plug" description="Command/response over a UART." />

<Card title="pymodbus plug" href="/guides/pymodbus-plug" description="PLCs, power meters, chambers over Modbus." />