embeddedci-openhtf 0.1.0__tar.gz

embeddedci_openhtf-0.1.0/.gitignore

@@ -0,0 +1,13 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.pytest_cache/
+
+# Build artifacts
+build/
+dist/
+
+# Virtualenvs
+.venv/
+venv/

embeddedci_openhtf-0.1.0/PKG-INFO

@@ -0,0 +1,170 @@
+Metadata-Version: 2.4
+Name: embeddedci-openhtf
+Version: 0.1.0
+Summary: OpenHTF plug for driving an EmbeddedCI BenchPod directly over TCP or serial (no cloud)
+Project-URL: Homepage, https://embeddedci.com
+Project-URL: Repository, https://github.com/embeddedci-com/embeddedci-python
+Project-URL: Issues, https://github.com/embeddedci-com/embeddedci-python/issues
+Author: EmbeddedCI
+License: Apache-2.0
+Keywords: benchpod,embedded,hardware-in-the-loop,manufacturing-test,openhtf,swd
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Requires-Dist: embeddedci>=0.2
+Requires-Dist: openhtf>=1.6
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# embeddedci-openhtf
+
+> ⚠️ **Experimental.** This package is new and its API may change between
+> releases. Pin a version and expect breaking changes before 1.0.
+
+Drive an **EmbeddedCI BenchPod** from [OpenHTF](https://www.openhtf.com/) —
+Google's open-source hardware test framework — connecting **directly** to the pod
+over a TCP socket or serial port. No EmbeddedCI cloud account, OIDC, or web UI is
+required: this package is for teams who want OpenHTF's test sequencing, limits,
+records, and station GUI while talking straight to a pod on their own bench.
+
+It's a thin wrapper over the [`embeddedci`](../embeddedci) BenchPod SDK: a single
+plug plus a few phase helpers. The dependency direction is strictly
+**`embeddedci-openhtf` → `embeddedci`**.
+
+```bash
+pip install embeddedci-openhtf      # pulls in embeddedci + openhtf
+```
+
+## The plug
+
+`BenchPodPlug` opens a `BenchPod` when a test starts and closes it at teardown.
+Bind the connection inline with `benchpod_plug(...)`, or leave it unbound and
+supply it through OpenHTF config / the `BENCHPOD_CONNECTION` env var.
+
+```python
+import openhtf as htf
+from embeddedci_openhtf import benchpod_plug
+
+bench = benchpod_plug("192.168.1.50:8080")   # TCP — or benchpod_plug("/dev/ttyACM0")
+
+@htf.plug(bench=bench)
+def power_up(test, bench):
+    bench.power_on()                 # methods proxy to the BenchPod SDK client
+    bench.pod.capture_uart(...)      # or reach the full client via .pod
+```
+
+Connection forms (all **direct**, never cloud):
+
+| Form | Example |
+| --- | --- |
+| TCP `host[:port]` | `benchpod_plug("192.168.1.50:8080")` |
+| Serial device path | `benchpod_plug("/dev/ttyACM0")` / `benchpod_plug("COM5")` |
+| `BENCHPOD_CONNECTION` env | `benchpod_plug()` (unbound) |
+| OpenHTF config | `htf.conf.load(benchpod_connection="...")` then `@htf.plug(bench=BenchPodPlug)` |
+
+## Phase helpers
+
+Ready-made, fully-decorated phases for the common steps:
+
+```python
+from embeddedci_openhtf import benchpod_plug, flash_phase, boot_banner_phase
+
+bench = benchpod_plug("192.168.1.50:8080")
+
+test = htf.Test(
+    flash_phase(bench, file="fw.elf", target="target/stm32f4x.cfg",
+                swclk=11, swdio=12, nreset=3),      # records flash_ok, attaches openocd.log
+    boot_banner_phase(bench, rx=1, tx=2, expect="APP_OK"),   # records boot_ok, attaches uart.txt
+)
+test.execute(test_start=lambda: "SN-0001")
+```
+
+LA channels are 1-12 (the pod has 12 generic logic-analyzer channels and no
+fixed-role pins — wire any DUT signal to any channel and name it here).
+
+For anything custom, write a normal phase and use the recorders in
+`embeddedci_openhtf.measurements` (`record_flash`, `record_uart`,
+`record_samples`) to map SDK results onto measurements and attachments.
+
+`flash_phase` needs `openocd` on PATH (the pod is the CMSIS-DAP probe; OpenOCD
+runs the flash algorithm from the `target=` config, so every OpenOCD-supported
+MCU works unchanged).
+
+### Analog steps
+
+The pod's DAC output and ADC input are exposed as analog phases (and low-level
+helpers). **These are TCP-only** — they need the JSON/sample channel that the
+serial console doesn't provide.
+
+```python
+from embeddedci_openhtf import (
+    benchpod_plug, signal_generate_phase, adc_capture_phase, loopback_measure_phase,
+)
+bench = benchpod_plug("192.168.1.50:8080")
+
+test = htf.Test(
+    # drive the DAC and capture the ADC together (loopback), assert the round trip
+    loopback_measure_phase(bench, waveform="sine", freq=10_000, amplitude=120,
+                           pp_range=(180, 255), mean_range=(110, 150)),
+    # or: free-run a waveform, then snapshot the ADC separately
+    signal_generate_phase(bench, waveform="square", freq=1_000, amplitude=100),
+    adc_capture_phase(bench, samples=4096, pp_range=(150, 255)),
+)
+```
+
+Each capture/measure phase records `<prefix>_min` / `_max` / `_mean` / `_pp`
+(peak-to-peak) measurements — pass any as `(low, high)` to make it a limit — and
+attaches the raw samples as `adc.json`. The low-level helpers `signal_generate`,
+`signal_stop`, and `measure` are available for custom phases.
+
+## Station mode (persistent connection)
+
+By default the plug opens a connection per `Test.execute()` and closes it at
+teardown. On a station cycling many DUTs back-to-back, pass `persistent=True` to
+keep **one** connection open across executions (re-checked with a ping each run,
+reconnected if it dropped). Reuse the *same* plug class for every execution, and
+close it once at the end:
+
+```python
+from embeddedci_openhtf import benchpod_plug, close_persistent_benchpods
+from openhtf.plugs import user_input
+
+bench = benchpod_plug("192.168.1.50:8080", persistent=True)
+test = htf.Test(power_phase(bench, on=True), boot_banner_phase(bench, rx=1, tx=2, expect="APP_OK"))
+try:
+    while test.execute(test_start=user_input.prompt_for_test_start()):
+        pass            # next DUT — same pod connection
+finally:
+    close_persistent_benchpods()   # also runs automatically at process exit
+```
+
+## Examples
+
+* [`examples/flash_and_boot.py`](examples/flash_and_boot.py) — flash over SWD then
+  assert the boot banner, over a direct TCP connection.
+* [`examples/serial_smoke.py`](examples/serial_smoke.py) — a no-flash power + UART
+  smoke test with a parsed measurement, over a direct serial connection.
+* [`examples/analog_loopback.py`](examples/analog_loopback.py) — DAC→ADC loopback
+  signal-path self-test, over a direct TCP connection.
+* [`examples/station.py`](examples/station.py) — a station loop testing many DUTs
+  over one **persistent** connection.
+
+## Development
+
+```bash
+# from the repo root
+pip install -e "packages/embeddedci[dev]"
+pip install -e "packages/embeddedci-openhtf[dev]"
+pytest packages/embeddedci-openhtf
+```
+
+The test suite runs the real OpenHTF executor against an in-memory fake transport
+(`tests/_fake.py`), so it needs no pod and no OpenOCD.

embeddedci_openhtf-0.1.0/README.md

@@ -0,0 +1,144 @@
+# embeddedci-openhtf
+
+> ⚠️ **Experimental.** This package is new and its API may change between
+> releases. Pin a version and expect breaking changes before 1.0.
+
+Drive an **EmbeddedCI BenchPod** from [OpenHTF](https://www.openhtf.com/) —
+Google's open-source hardware test framework — connecting **directly** to the pod
+over a TCP socket or serial port. No EmbeddedCI cloud account, OIDC, or web UI is
+required: this package is for teams who want OpenHTF's test sequencing, limits,
+records, and station GUI while talking straight to a pod on their own bench.
+
+It's a thin wrapper over the [`embeddedci`](../embeddedci) BenchPod SDK: a single
+plug plus a few phase helpers. The dependency direction is strictly
+**`embeddedci-openhtf` → `embeddedci`**.
+
+```bash
+pip install embeddedci-openhtf      # pulls in embeddedci + openhtf
+```
+
+## The plug
+
+`BenchPodPlug` opens a `BenchPod` when a test starts and closes it at teardown.
+Bind the connection inline with `benchpod_plug(...)`, or leave it unbound and
+supply it through OpenHTF config / the `BENCHPOD_CONNECTION` env var.
+
+```python
+import openhtf as htf
+from embeddedci_openhtf import benchpod_plug
+
+bench = benchpod_plug("192.168.1.50:8080")   # TCP — or benchpod_plug("/dev/ttyACM0")
+
+@htf.plug(bench=bench)
+def power_up(test, bench):
+    bench.power_on()                 # methods proxy to the BenchPod SDK client
+    bench.pod.capture_uart(...)      # or reach the full client via .pod
+```
+
+Connection forms (all **direct**, never cloud):
+
+| Form | Example |
+| --- | --- |
+| TCP `host[:port]` | `benchpod_plug("192.168.1.50:8080")` |
+| Serial device path | `benchpod_plug("/dev/ttyACM0")` / `benchpod_plug("COM5")` |
+| `BENCHPOD_CONNECTION` env | `benchpod_plug()` (unbound) |
+| OpenHTF config | `htf.conf.load(benchpod_connection="...")` then `@htf.plug(bench=BenchPodPlug)` |
+
+## Phase helpers
+
+Ready-made, fully-decorated phases for the common steps:
+
+```python
+from embeddedci_openhtf import benchpod_plug, flash_phase, boot_banner_phase
+
+bench = benchpod_plug("192.168.1.50:8080")
+
+test = htf.Test(
+    flash_phase(bench, file="fw.elf", target="target/stm32f4x.cfg",
+                swclk=11, swdio=12, nreset=3),      # records flash_ok, attaches openocd.log
+    boot_banner_phase(bench, rx=1, tx=2, expect="APP_OK"),   # records boot_ok, attaches uart.txt
+)
+test.execute(test_start=lambda: "SN-0001")
+```
+
+LA channels are 1-12 (the pod has 12 generic logic-analyzer channels and no
+fixed-role pins — wire any DUT signal to any channel and name it here).
+
+For anything custom, write a normal phase and use the recorders in
+`embeddedci_openhtf.measurements` (`record_flash`, `record_uart`,
+`record_samples`) to map SDK results onto measurements and attachments.
+
+`flash_phase` needs `openocd` on PATH (the pod is the CMSIS-DAP probe; OpenOCD
+runs the flash algorithm from the `target=` config, so every OpenOCD-supported
+MCU works unchanged).
+
+### Analog steps
+
+The pod's DAC output and ADC input are exposed as analog phases (and low-level
+helpers). **These are TCP-only** — they need the JSON/sample channel that the
+serial console doesn't provide.
+
+```python
+from embeddedci_openhtf import (
+    benchpod_plug, signal_generate_phase, adc_capture_phase, loopback_measure_phase,
+)
+bench = benchpod_plug("192.168.1.50:8080")
+
+test = htf.Test(
+    # drive the DAC and capture the ADC together (loopback), assert the round trip
+    loopback_measure_phase(bench, waveform="sine", freq=10_000, amplitude=120,
+                           pp_range=(180, 255), mean_range=(110, 150)),
+    # or: free-run a waveform, then snapshot the ADC separately
+    signal_generate_phase(bench, waveform="square", freq=1_000, amplitude=100),
+    adc_capture_phase(bench, samples=4096, pp_range=(150, 255)),
+)
+```
+
+Each capture/measure phase records `<prefix>_min` / `_max` / `_mean` / `_pp`
+(peak-to-peak) measurements — pass any as `(low, high)` to make it a limit — and
+attaches the raw samples as `adc.json`. The low-level helpers `signal_generate`,
+`signal_stop`, and `measure` are available for custom phases.
+
+## Station mode (persistent connection)
+
+By default the plug opens a connection per `Test.execute()` and closes it at
+teardown. On a station cycling many DUTs back-to-back, pass `persistent=True` to
+keep **one** connection open across executions (re-checked with a ping each run,
+reconnected if it dropped). Reuse the *same* plug class for every execution, and
+close it once at the end:
+
+```python
+from embeddedci_openhtf import benchpod_plug, close_persistent_benchpods
+from openhtf.plugs import user_input
+
+bench = benchpod_plug("192.168.1.50:8080", persistent=True)
+test = htf.Test(power_phase(bench, on=True), boot_banner_phase(bench, rx=1, tx=2, expect="APP_OK"))
+try:
+    while test.execute(test_start=user_input.prompt_for_test_start()):
+        pass            # next DUT — same pod connection
+finally:
+    close_persistent_benchpods()   # also runs automatically at process exit
+```
+
+## Examples
+
+* [`examples/flash_and_boot.py`](examples/flash_and_boot.py) — flash over SWD then
+  assert the boot banner, over a direct TCP connection.
+* [`examples/serial_smoke.py`](examples/serial_smoke.py) — a no-flash power + UART
+  smoke test with a parsed measurement, over a direct serial connection.
+* [`examples/analog_loopback.py`](examples/analog_loopback.py) — DAC→ADC loopback
+  signal-path self-test, over a direct TCP connection.
+* [`examples/station.py`](examples/station.py) — a station loop testing many DUTs
+  over one **persistent** connection.
+
+## Development
+
+```bash
+# from the repo root
+pip install -e "packages/embeddedci[dev]"
+pip install -e "packages/embeddedci-openhtf[dev]"
+pytest packages/embeddedci-openhtf
+```
+
+The test suite runs the real OpenHTF executor against an in-memory fake transport
+(`tests/_fake.py`), so it needs no pod and no OpenOCD.

embeddedci_openhtf-0.1.0/examples/analog_loopback.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+"""OpenHTF test: analog stimulus + acquisition over a **direct TCP** connection
+to the BenchPod (no EmbeddedCI cloud).
+
+The pod has a DAC output and an ADC input on its FPGA. This test drives a known
+waveform and captures the ADC at the same time (``measure`` = synchronized
+DAC+ADC loopback), then asserts the round-trip amplitude — the canonical analog
+signal-path self-test. Wire the pod's DAC output to its ADC input (directly, or
+through a DUT filter/amplifier whose response you want to check).
+
+    pip install embeddedci-openhtf
+    python analog_loopback.py --pod 192.168.1.50:8080
+
+Analog commands are TCP-only (they need the JSON/sample channel), so this example
+uses a TCP address, not a serial path.
+"""
+
+import argparse
+import os
+
+import openhtf as htf
+from openhtf.output.callbacks import console_summary
+
+from embeddedci_openhtf import (
+    adc_capture_phase,
+    benchpod_plug,
+    loopback_measure_phase,
+    signal_generate_phase,
+)
+
+
+def build_test(pod: str) -> htf.Test:
+    bench = benchpod_plug(pod)        # direct TCP, no cloud
+    return htf.Test(
+        # 1) DAC+ADC loopback: drive a 10 kHz sine and assert the round trip.
+        loopback_measure_phase(
+            bench, waveform="sine", freq=10_000, amplitude=120, offset=128,
+            samples=4096, pp_range=(180, 255), mean_range=(110, 150),
+        ),
+        # 2) free-run a waveform, then snapshot the ADC on its own.
+        signal_generate_phase(bench, waveform="square", freq=1_000, amplitude=100),
+        adc_capture_phase(bench, samples=4096, sample_rate_mhz=0.5,
+                          pp_range=(150, 255)),
+        test_name="benchpod_analog_loopback",
+    )
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("--pod", default=os.environ.get("BENCHPOD_CONNECTION"),
+                    help="BenchPod TCP address host[:port] (default: $BENCHPOD_CONNECTION)")
+    ap.add_argument("--sn", default="SN-0001")
+    args = ap.parse_args()
+    if not args.pod:
+        ap.error("no pod connection: pass --pod or set BENCHPOD_CONNECTION")
+
+    test = build_test(args.pod)
+    test.add_output_callbacks(console_summary.ConsoleSummary())
+    test.execute(test_start=lambda: args.sn)
+
+
+if __name__ == "__main__":
+    main()

embeddedci_openhtf-0.1.0/examples/flash_and_boot.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+"""OpenHTF test: flash a DUT over the BenchPod's SWD probe, then assert its boot
+banner — connecting **directly** to the pod over TCP (no EmbeddedCI cloud).
+
+Run it against a pod on your LAN::
+
+    pip install embeddedci-openhtf
+    python flash_and_boot.py --pod 192.168.1.50:8080 --firmware fw.elf
+
+Needs `openocd` on PATH (the pod is the CMSIS-DAP probe; OpenOCD drives the flash
+algorithm). The bench wiring below — which LA channel carries SWCLK/SWDIO/NRST
+and the DUT's UART TX/RX — is specific to your setup; edit the constants.
+
+A JSON test record is written next to this script via OpenHTF's standard
+OutputToJSON callback, and a PASS/FAIL summary is printed to the console.
+"""
+
+import argparse
+import os
+
+import openhtf as htf
+from openhtf.output.callbacks import console_summary, json_factory
+
+from embeddedci_openhtf import benchpod_plug, boot_banner_phase, flash_phase
+
+# --- bench wiring (edit for your setup): LA channels 1-12 -------------------
+SWCLK, SWDIO, NRESET = 11, 12, 3      # SWD probe -> DUT
+UART_RX, UART_TX = 1, 2               # RX = LA channel sampling the DUT's TX
+OPENOCD_TARGET = "target/stm32f4x.cfg"
+BOOT_BANNER = "APP_OK"               # substring the firmware prints when healthy
+
+
+def build_test(pod: str, firmware: str) -> htf.Test:
+    bench = benchpod_plug(pod)        # direct TCP / serial connection, no cloud
+    return htf.Test(
+        flash_phase(bench, file=firmware, target=OPENOCD_TARGET,
+                    swclk=SWCLK, swdio=SWDIO, nreset=NRESET),
+        boot_banner_phase(bench, rx=UART_RX, tx=UART_TX, expect=BOOT_BANNER,
+                          power_cycle=True, duration=6.0),
+        test_name="benchpod_flash_and_boot",
+    )
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("--pod", default=os.environ.get("BENCHPOD_CONNECTION"),
+                    help="BenchPod address: host[:port] or a serial path "
+                         "(default: $BENCHPOD_CONNECTION)")
+    ap.add_argument("--firmware", required=True, help="firmware image to flash")
+    ap.add_argument("--sn", default="SN-0001", help="DUT serial number")
+    args = ap.parse_args()
+    if not args.pod:
+        ap.error("no pod connection: pass --pod or set BENCHPOD_CONNECTION")
+
+    test = build_test(args.pod, args.firmware)
+    test.add_output_callbacks(
+        json_factory.OutputToJSON("./{dut_id}.{start_time_millis}.json", indent=2),
+        console_summary.ConsoleSummary(),
+    )
+    test.execute(test_start=lambda: args.sn)
+
+
+if __name__ == "__main__":
+    main()

embeddedci_openhtf-0.1.0/examples/serial_smoke.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+"""OpenHTF test: a no-flash power + UART smoke test over a **direct serial**
+connection to the BenchPod (no EmbeddedCI cloud, no OpenOCD).
+
+Useful as a first bring-up: power the target, watch its boot output, assert a
+banner, and read back a measured value the firmware prints. Run it with the pod
+on a USB-serial port::
+
+    pip install embeddedci-openhtf
+    python serial_smoke.py --pod /dev/ttyACM0          # or COM5 on Windows
+
+The custom phase shows the general pattern: declare measurements with
+``@htf.measures``, grab the pod with ``@htf.plug``, and call the SDK directly.
+"""
+
+import argparse
+import os
+import re
+
+import openhtf as htf
+from openhtf.output.callbacks import console_summary
+
+from embeddedci import benchpod
+from embeddedci_openhtf import benchpod_plug, record_uart
+
+UART_RX, UART_TX = 1, 2          # edit for your wiring (LA channels 1-12)
+BOOT_BANNER = "APP_OK"
+
+
+def make_smoke_phase(bench: type):
+    @htf.PhaseOptions(name="power_and_read")
+    @htf.measures(
+        htf.Measurement("boot_ok").equals(True).doc("boot banner seen"),
+        htf.Measurement("vbat_mv").in_range(3000, 3600).with_units("mV")
+                                  .doc("battery voltage the firmware reports"),
+    )
+    @htf.plug(bench=bench)
+    def _phase(test, bench):
+        # power-cycle and capture the boot output in one shot
+        cap = bench.power_cycle_and_capture(
+            rx=UART_RX, tx=UART_TX, efuse=benchpod.INTERNAL,
+            delay=1.0, duration=5.0, until=BOOT_BANNER,
+        )
+        record_uart(test, cap, name="boot_ok")     # sets boot_ok + attaches uart.txt
+
+        # parse a value the firmware prints, e.g. "VBAT=3301mV"
+        m = re.search(r"VBAT=(\d+)mV", cap.text)
+        test.measurements.vbat_mv = int(m.group(1)) if m else 0
+
+    return _phase
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("--pod", default=os.environ.get("BENCHPOD_CONNECTION"),
+                    help="serial path (e.g. /dev/ttyACM0 or COM5), or host:port; "
+                         "default: $BENCHPOD_CONNECTION")
+    ap.add_argument("--sn", default="SN-0001")
+    args = ap.parse_args()
+    if not args.pod:
+        ap.error("no pod connection: pass --pod or set BENCHPOD_CONNECTION")
+
+    bench = benchpod_plug(args.pod)          # direct connection, no cloud
+    test = htf.Test(make_smoke_phase(bench), test_name="benchpod_serial_smoke")
+    test.add_output_callbacks(console_summary.ConsoleSummary())
+    test.execute(test_start=lambda: args.sn)
+
+
+if __name__ == "__main__":
+    main()

embeddedci_openhtf-0.1.0/examples/station.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+"""OpenHTF station loop with a **persistent** BenchPod connection over direct TCP
+(no EmbeddedCI cloud).
+
+A manufacturing station tests one DUT after another. Opening a fresh connection
+per DUT adds latency, so this uses ``benchpod_plug(..., persistent=True)``: the
+connection is opened once and reused across every ``test.execute()``, re-checked
+with a ping each run and reconnected if it dropped. It is closed once at the end
+with ``close_persistent_benchpods()``.
+
+    pip install embeddedci-openhtf
+    python station.py --pod 192.168.1.50:8080
+    # enter each board's serial number when prompted; Ctrl-C to stop
+
+The pod connection stays up for the whole session; only the per-DUT test phases
+repeat.
+"""
+
+import argparse
+import os
+
+import openhtf as htf
+from openhtf.output.callbacks import console_summary
+from openhtf.plugs import user_input
+
+from embeddedci_openhtf import (
+    benchpod_plug,
+    boot_banner_phase,
+    close_persistent_benchpods,
+    power_phase,
+)
+
+UART_RX, UART_TX = 1, 2          # edit for your wiring (LA channels 1-12)
+BOOT_BANNER = "APP_OK"
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("--pod", default=os.environ.get("BENCHPOD_CONNECTION"),
+                    help="BenchPod address host[:port] or serial path "
+                         "(default: $BENCHPOD_CONNECTION)")
+    args = ap.parse_args()
+    if not args.pod:
+        ap.error("no pod connection: pass --pod or set BENCHPOD_CONNECTION")
+
+    # persistent=True -> one connection shared across every DUT this session
+    bench = benchpod_plug(args.pod, persistent=True)
+    test = htf.Test(
+        power_phase(bench, on=True),
+        boot_banner_phase(bench, rx=UART_RX, tx=UART_TX, expect=BOOT_BANNER,
+                          power_cycle=True, duration=6.0),
+        power_phase(bench, on=False, name="power_off"),
+        test_name="benchpod_station",
+    )
+    test.add_output_callbacks(console_summary.ConsoleSummary())
+
+    try:
+        # OpenHTF returns from execute() after each DUT; loop for the next one.
+        while test.execute(test_start=user_input.prompt_for_test_start()):
+            pass
+    except KeyboardInterrupt:
+        print("\nstation stopped")
+    finally:
+        close_persistent_benchpods()   # close the shared connection once
+
+
+if __name__ == "__main__":
+    main()

embeddedci_openhtf-0.1.0/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "embeddedci-openhtf"
+version = "0.1.0"
+description = "OpenHTF plug for driving an EmbeddedCI BenchPod directly over TCP or serial (no cloud)"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "Apache-2.0" }
+authors = [{ name = "EmbeddedCI" }]
+keywords = ["embedded", "hardware-in-the-loop", "openhtf", "benchpod", "swd", "manufacturing-test"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Testing",
+]
+dependencies = [
+    "embeddedci>=0.2",
+    "openhtf>=1.6",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0"]
+
+[project.urls]
+Homepage = "https://embeddedci.com"
+Repository = "https://github.com/embeddedci-com/embeddedci-python"
+Issues = "https://github.com/embeddedci-com/embeddedci-python/issues"
+
+# Inside the workspace, resolve embeddedci from the sibling source tree (see the
+# repo-root pyproject.toml [tool.uv.workspace]). On PyPI this is ignored and the
+# published embeddedci is used.
+[tool.uv.sources]
+embeddedci = { workspace = true }
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/embeddedci_openhtf"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]