embeddedci 2.1.0__tar.gz → 2.2.0__tar.gz

{embeddedci-2.1.0 → embeddedci-2.2.0}/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 ## Unreleased
 
+## 2.2.0
+
+- Cloud: the session token the SDK mints is renewed shortly before it expires, and once more if the
+  server rejects it (tunnel, command channel and lease heartbeat). A connection held longer than
+  the token's hour used to start failing mid-session. A `cloud_token` you pass is not renewed.
+- Cloud: new `BenchPod(cloud_user_token=callable)` authenticates with a logged-in user's access
+  token (exchanged via `POST /api/auth/token`), between an API key and GitHub Actions OIDC.
+  `cloud_auth.mint_session_token()` returns the token with its expiry; `exchange_user_token()` added.
+  The server API (wiring profile, waveform library) uses that user token too: the device and
+  waveform routes refuse the cloud session token minted from it.
+- Cloud: an offline pod fails with "BenchPod '…' is offline" and an unknown name with
+  `ConnectionConfigError: no cloud BenchPod named '…'`, instead of the raw HTTP error. The lease used
+  to read the server's 404 for an unknown name as "no lease support" and carry on unlocked.
+- Cloud: `DeviceBusyError` says until when the holder's lease runs, and how to wait longer outside
+  pytest (`lease_wait`).
+
+## 2.1.1
+
+- The README, docstrings and examples say 14 LA channels (LA1-LA14); 2.1.0 still said 12.
+  No code changes.
+- New e2e tier `tests/e2e/test_e2e_la13_14.py`: LA13/LA14 in the pin table, GPIO drive and
+  read-back, captures, triggers, step trains and a UART session. The cloud tier also checks
+  LA13/LA14, and it no longer requires every LA word to fit 12 bits.
+
 ## 2.1.0
 
 - BenchPod v3 pods now expose LA13/LA14 (14 LA channels instead of 12): every LA-channel

{embeddedci-2.1.0 → embeddedci-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: embeddedci
-Version: 2.1.0
+Version: 2.2.0
 Summary: BenchPod SDK and pytest plugin for EmbeddedCI hardware-in-the-loop testing
 Project-URL: Homepage, https://embeddedci.com
 Project-URL: Repository, https://github.com/embeddedci-com/embeddedci-python
@@ -47,7 +47,7 @@ can:
 * **flash** firmware over SWD and assert it worked
 * capture the DUT's **UART**, or hold an interactive UART session
 * **emulate an I2C sensor** (BMP280) and decode the bus traffic
-* capture **ADC** (calibrated volts), a 12-channel **logic analyzer**, or both from one trigger
+* capture **ADC** (calibrated volts), a 14-channel **logic analyzer**, or both from one trigger
 * drive the **DAC**: DC levels, generated waveforms, arbitrary replay, fault injection, and an
   in-fabric **control loop**
 * talk **CAN**, including an autonomous ECU simulator
@@ -196,7 +196,7 @@ is selected. You can also call `bp.set_la_voltage(3.3)` later; `bp.get_la_voltag
 `LaVoltage` whose `voltage` is `None` until one is chosen. 1.8 V needs a rev3 pod.
 
 Other constructor arguments: `timeout` (seconds, default 30), `api_key`, `api_base`,
-`cloud_token`, `cloud_audience`, `lease`, `lease_wait`, `lease_ttl` (see [Cloud](#cloud-embeddedcidevice-name))
+`cloud_token`, `cloud_audience`, `cloud_user_token`, `lease`, `lease_wait`, `lease_ttl` (see [Cloud](#cloud-embeddedcidevice-name))
 and `transport` (inject a custom backend).
 
 ### Connection strings
@@ -207,7 +207,7 @@ and `transport` (inject a custom backend).
 | `/dev/ttyACM0`, `COM3`, `\\.\COM10` | USB console, explicit device path |
 | `usb` | USB console, auto-detected by probing the serial ports (`serial` also accepted) |
 | `discover` (or `mdns`, `auto`) | find exactly one pod on the LAN via mDNS (needs `[discovery]`); errors on zero or several |
-| `embeddedci:<device-name>` | a named device through embeddedci.com (needs `[cloud]`; an API key anywhere, or GitHub Actions OIDC) |
+| `embeddedci:<device-name>` | a named device through embeddedci.com (needs `[cloud]`; an API key or a user token anywhere, or GitHub Actions OIDC) |
 
 **Use the network (or the cloud) for testing.** The STM32 pod's USB console is a text shell for
 setup and diagnostics with no JSON mode, so over USB the SDK can only read `status()`, `ping()`,
@@ -253,7 +253,7 @@ automatically.)
   | Concept | Constants | Wire value |
   |---|---|---|
   | Target-power eFuse | `INTERNAL`, `EXTERNAL` (`Efuse`) | 1, 2 |
-  | LA channels | `PIN1` … `PIN12` (`Pin`) | 1 … 12 |
+  | LA channels | `PIN1` … `PIN14` (`Pin`) | 1 … 14 |
   | Emulated sensor | `Sensor.BMP280` | `"bmp280"` |
   | BMP280 addresses | `BMP280_ADDR_PRIMARY`, `BMP280_ADDR_SECONDARY` | 0x76, 0x77 |
   | Gateware image | `FpgaImage.LOOP`, `FpgaImage.DEEP_REPLAY` | 0, 1 |
@@ -371,7 +371,7 @@ benchpod_connection = 192.168.1.213
 | `benchpod_dac` | function | `benchpod`; stops any DAC output (generate, replay, control loop) at teardown |
 | `benchpod_capabilities` | session | `benchpod.capabilities` |
 | `benchpod_waveforms` | function | the cloud `WaveformLibrary`; deletes waveforms saved through it during the test; skips without server access |
-| `benchpod_pins` / `pins` | session | `pin_1` … `pin_12`, `efuse`, and `has_pullup()`, `has_pulldown()`, `pull_ohms()`, `pullup_ohms()`, `pull_direction()` |
+| `benchpod_pins` / `pins` | session | `pin_1` … `pin_14`, `efuse`, and `has_pullup()`, `has_pulldown()`, `pull_ohms()`, `pullup_ohms()`, `pull_direction()` |
 | `firmware` | function | the `--benchpod-firmware` path (skips when unset) |
 | `build_report` | function | a build reporter — see [Build reporting](#build-reporting) |
 
@@ -1046,9 +1046,16 @@ devices you may drive:
 
 1. **An API key** (`eci_…`) via `api_key=`, `--benchpod-api-key` or `BENCHPOD_API_KEY`. Works
    anywhere: your desk, any CI system.
-2. **GitHub Actions OIDC** when no API key is set. No secret is stored — the workflow proves which
+2. **A logged-in user's token** via `cloud_user_token=`, a callable returning the access token (the
+   MCP server passes the `benchpod login` session this way).
+3. **GitHub Actions OIDC** when neither is set. No secret is stored — the workflow proves which
    repo it is, like PyPI Trusted Publishing. Only works inside a GitHub Actions job.
 
+The SDK renews that session token shortly before it expires (and once more if the server rejects
+it), so a connection held for hours keeps working. A token you pass yourself as `cloud_token=` is
+used as is. An offline pod fails with "BenchPod '…' is offline", a wrong name with "no cloud
+BenchPod named '…'", and a busy pod names who holds it and until when.
+
 ```python
 from embeddedci.benchpod import BenchPod
 

{embeddedci-2.1.0 → embeddedci-2.2.0}/README.md

@@ -9,7 +9,7 @@ can:
 * **flash** firmware over SWD and assert it worked
 * capture the DUT's **UART**, or hold an interactive UART session
 * **emulate an I2C sensor** (BMP280) and decode the bus traffic
-* capture **ADC** (calibrated volts), a 12-channel **logic analyzer**, or both from one trigger
+* capture **ADC** (calibrated volts), a 14-channel **logic analyzer**, or both from one trigger
 * drive the **DAC**: DC levels, generated waveforms, arbitrary replay, fault injection, and an
   in-fabric **control loop**
 * talk **CAN**, including an autonomous ECU simulator
@@ -158,7 +158,7 @@ is selected. You can also call `bp.set_la_voltage(3.3)` later; `bp.get_la_voltag
 `LaVoltage` whose `voltage` is `None` until one is chosen. 1.8 V needs a rev3 pod.
 
 Other constructor arguments: `timeout` (seconds, default 30), `api_key`, `api_base`,
-`cloud_token`, `cloud_audience`, `lease`, `lease_wait`, `lease_ttl` (see [Cloud](#cloud-embeddedcidevice-name))
+`cloud_token`, `cloud_audience`, `cloud_user_token`, `lease`, `lease_wait`, `lease_ttl` (see [Cloud](#cloud-embeddedcidevice-name))
 and `transport` (inject a custom backend).
 
 ### Connection strings
@@ -169,7 +169,7 @@ and `transport` (inject a custom backend).
 | `/dev/ttyACM0`, `COM3`, `\\.\COM10` | USB console, explicit device path |
 | `usb` | USB console, auto-detected by probing the serial ports (`serial` also accepted) |
 | `discover` (or `mdns`, `auto`) | find exactly one pod on the LAN via mDNS (needs `[discovery]`); errors on zero or several |
-| `embeddedci:<device-name>` | a named device through embeddedci.com (needs `[cloud]`; an API key anywhere, or GitHub Actions OIDC) |
+| `embeddedci:<device-name>` | a named device through embeddedci.com (needs `[cloud]`; an API key or a user token anywhere, or GitHub Actions OIDC) |
 
 **Use the network (or the cloud) for testing.** The STM32 pod's USB console is a text shell for
 setup and diagnostics with no JSON mode, so over USB the SDK can only read `status()`, `ping()`,
@@ -215,7 +215,7 @@ automatically.)
   | Concept | Constants | Wire value |
   |---|---|---|
   | Target-power eFuse | `INTERNAL`, `EXTERNAL` (`Efuse`) | 1, 2 |
-  | LA channels | `PIN1` … `PIN12` (`Pin`) | 1 … 12 |
+  | LA channels | `PIN1` … `PIN14` (`Pin`) | 1 … 14 |
   | Emulated sensor | `Sensor.BMP280` | `"bmp280"` |
   | BMP280 addresses | `BMP280_ADDR_PRIMARY`, `BMP280_ADDR_SECONDARY` | 0x76, 0x77 |
   | Gateware image | `FpgaImage.LOOP`, `FpgaImage.DEEP_REPLAY` | 0, 1 |
@@ -333,7 +333,7 @@ benchpod_connection = 192.168.1.213
 | `benchpod_dac` | function | `benchpod`; stops any DAC output (generate, replay, control loop) at teardown |
 | `benchpod_capabilities` | session | `benchpod.capabilities` |
 | `benchpod_waveforms` | function | the cloud `WaveformLibrary`; deletes waveforms saved through it during the test; skips without server access |
-| `benchpod_pins` / `pins` | session | `pin_1` … `pin_12`, `efuse`, and `has_pullup()`, `has_pulldown()`, `pull_ohms()`, `pullup_ohms()`, `pull_direction()` |
+| `benchpod_pins` / `pins` | session | `pin_1` … `pin_14`, `efuse`, and `has_pullup()`, `has_pulldown()`, `pull_ohms()`, `pullup_ohms()`, `pull_direction()` |
 | `firmware` | function | the `--benchpod-firmware` path (skips when unset) |
 | `build_report` | function | a build reporter — see [Build reporting](#build-reporting) |
 
@@ -1008,9 +1008,16 @@ devices you may drive:
 
 1. **An API key** (`eci_…`) via `api_key=`, `--benchpod-api-key` or `BENCHPOD_API_KEY`. Works
    anywhere: your desk, any CI system.
-2. **GitHub Actions OIDC** when no API key is set. No secret is stored — the workflow proves which
+2. **A logged-in user's token** via `cloud_user_token=`, a callable returning the access token (the
+   MCP server passes the `benchpod login` session this way).
+3. **GitHub Actions OIDC** when neither is set. No secret is stored — the workflow proves which
    repo it is, like PyPI Trusted Publishing. Only works inside a GitHub Actions job.
 
+The SDK renews that session token shortly before it expires (and once more if the server rejects
+it), so a connection held for hours keeps working. A token you pass yourself as `cloud_token=` is
+used as is. An offline pod fails with "BenchPod '…' is offline", a wrong name with "no cloud
+BenchPod named '…'", and a busy pod names who holds it and until when.
+
 ```python
 from embeddedci.benchpod import BenchPod
 

{embeddedci-2.1.0 → embeddedci-2.2.0}/examples/README.md

@@ -41,8 +41,8 @@ Without a connection or a firmware image the test **skips** (so it's safe in CI)
 
 ### Wiring
 
-The pod has **no dedicated SWD/UART/I2C pins** — it exposes 12 generic LA channels
-(`pins.pin_1` … `pins.pin_12`) and any DUT signal can be on any of them. The example
+The pod has **no dedicated SWD/UART/I2C pins** — it exposes 14 generic LA channels
+(`pins.pin_1` … `pins.pin_14`) and any DUT signal can be on any of them. The example
 maps its own wiring in a `wiring` fixture at the top of `test_bmp280.py`; the table
 below is what that fixture uses — edit it to match your board.
 

{embeddedci-2.1.0 → embeddedci-2.2.0}/examples/test_bmp280.py

@@ -21,7 +21,7 @@
 # (--benchpod-connection also takes "usb", a serial device path, "discover", or
 # "embeddedci:<device-name>" for a pod reached through embeddedci.com.)
 #
-# Wiring — the pod has no dedicated SWD/UART/I2C pins. It exposes 12 generic LA
+# Wiring — the pod has no dedicated SWD/UART/I2C pins. It exposes 14 generic LA
 # channels (pins.pin_1 .. pins.pin_12) and any DUT signal can be on any of them.
 # The `wiring` fixture below is THIS bench's map; edit it to match your board:
 #
@@ -37,7 +37,7 @@
 #   Target 5V power                 eFuse 1 (internal)     --benchpod-efuse
 #
 # Switchable pull-ups exist only on LA1-LA6 (LA1/2 = 4.7k, LA3/4 = 2.2k,
-# LA5/6 = 10k). LA7/LA8 carry 10k pull-DOWNs and LA9-LA12 nothing, so the
+# LA5/6 = 10k). LA7/LA8 carry 10k pull-DOWNs and LA9-LA14 nothing, so the
 # open-drain I2C lines must sit on LA1-LA6. The resistors are referenced to 3V3,
 # which is why this example runs the LA bank at 3.3 V.
 #

{embeddedci-2.1.0 → embeddedci-2.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "embeddedci"
-version = "2.1.0"
+version = "2.2.0"
 description = "BenchPod SDK and pytest plugin for EmbeddedCI hardware-in-the-loop testing"
 readme = "README.md"
 requires-python = ">=3.10"

{embeddedci-2.1.0 → embeddedci-2.2.0}/src/embeddedci/benchpod/client.py

@@ -30,7 +30,7 @@ import logging
 import os
 import time
 from contextlib import contextmanager
-from typing import TYPE_CHECKING, Any, Dict, Iterator, List, Mapping, Optional, Sequence, Tuple, Union
+from typing import TYPE_CHECKING, Any, Callable, Dict, Iterator, List, Mapping, Optional, Sequence, Tuple, Union
 
 from . import can as _can
 from . import capture as _capture
@@ -176,6 +176,7 @@ class BenchPod:
         api_key: Optional[str] = None,
         cloud_token: Optional[str] = None,
         cloud_audience: Optional[str] = None,
+        cloud_user_token: Optional[Callable[[], str]] = None,
         lease: bool = True,
         lease_wait: float = DEFAULT_LEASE_WAIT,
         lease_ttl: int = DEFAULT_LEASE_TTL,
@@ -192,9 +193,12 @@ class BenchPod:
         I/O-bank voltage right after connecting. The pod refuses every LA-bank operation —
         flashing, UART, LA capture, pull resistors, I2C-sensor emulation — until one is selected.
 
-        Cloud options: ``api_key`` (or ``BENCHPOD_API_KEY``) authenticates anywhere; without it the
-        cloud destination uses GitHub Actions OIDC (``cloud_token``/``cloud_audience`` override
-        that). ``api_base`` (or ``BENCHPOD_API_BASE``) points at another embeddedci server. An API
+        Cloud options: ``api_key`` (or ``BENCHPOD_API_KEY``) authenticates anywhere; else
+        ``cloud_user_token``, a callable returning a logged-in user's access token (such as the
+        ``benchpod login`` session), is exchanged for a device session; without either the cloud
+        destination uses GitHub Actions OIDC (``cloud_token``/``cloud_audience`` override that).
+        A session token the SDK mints is renewed before it expires, so a long session keeps
+        working; a ``cloud_token`` you pass is used as is. ``api_base`` (or ``BENCHPOD_API_BASE``) points at another embeddedci server. An API
         key also unlocks the cloud waveform library on a LAN/serial connection.
 
         The cloud device is *shared*, so the client takes an exclusive **lease** on it for the life
@@ -210,6 +214,7 @@ class BenchPod:
         self._lease: Optional[DeviceLease] = None
         self._api_base = api_base or os.environ.get(API_BASE_ENV)
         self._api_key = api_key or os.environ.get(API_KEY_ENV)
+        self._cloud_user_token = cloud_user_token
         self._caps: Optional[Capabilities] = None
         self._server_api: Optional["ServerApi"] = None
         self._waveforms: Optional["WaveformLibrary"] = None
@@ -228,12 +233,14 @@ class BenchPod:
                 token=cloud_token,
                 audience=cloud_audience,
                 api_key=self._api_key,
+                user_token=cloud_user_token,
             )
         try:
             if lease and isinstance(self._transport, CloudTransport):
                 self._lease = DeviceLease(
                     api_base=self._transport.api_base,
                     token_provider=self._transport._session_token,
+                    invalidate_token=self._transport._invalidate_token,
                     device_name=self._transport.device_name,
                     ttl_seconds=lease_ttl,
                 )
@@ -1105,7 +1112,8 @@ class BenchPod:
         return _control_loop.IVPoint(
             i=int(d.get("i", 0)), v=int(d.get("v", 0)),
             input_code=None if raw_in is None else int(raw_in),
-            source=d.get("source"))
+            source=d.get("source"),
+            tripped=None if d.get("tripped") is None else bool(d.get("tripped")))
 
     # -- gateware image -------------------------------------------------------
 
@@ -1389,10 +1397,12 @@ class BenchPod:
     # -- cloud waveform library + server API ----------------------------------
 
     def _try_server_api(self) -> Optional["ServerApi"]:
-        """Build a :class:`ServerApi` if possible (API key or a cloud session token), else None."""
+        """Build a :class:`ServerApi` if possible, else None. Credentials, in order: the API key; the
+        logged-in user's token (the server's device and waveform routes take a user, not a cloud
+        session token minted from one); the cloud transport's session token (API key or OIDC)."""
         if self._server_api is not None:
             return self._server_api
-        token_provider = getattr(self._transport, "_session_token", None)
+        token_provider = self._cloud_user_token or getattr(self._transport, "_session_token", None)
         if not self._api_key and token_provider is None:
             return None
         from .server_api import ServerApi

{embeddedci-2.1.0 → embeddedci-2.2.0}/src/embeddedci/benchpod/cloud_auth.py

@@ -11,17 +11,21 @@ not run the pytest suite over the cloud at all, so the cloud transport went effe
 outside CI while the identical tests ran fine over a direct LAN connection. A **user API key**
 (``BENCHPOD_API_KEY``/``api_key=``) is therefore accepted as an alternative credential and
 exchanged via ``POST /api/auth/token`` — the same endpoint and the same ``ApiKey`` scheme the Go
-hwe2e cloud suite authenticates with. The API key is preferred when present; OIDC remains the
-zero-secret path for GitHub Actions.
+hwe2e cloud suite authenticates with. The API key is preferred when present; a logged-in user's
+access token (``Bearer``, e.g. the ``benchpod login`` session) is exchanged at the same endpoint;
+OIDC remains the zero-secret path for GitHub Actions.
 """
 
 from __future__ import annotations
 
 import json
 import os
+import time
 import urllib.error
 import urllib.parse
 import urllib.request
+from datetime import datetime
+from typing import Callable, Tuple
 
 from .errors import CloudAuthError
 
@@ -30,6 +34,8 @@ from .errors import CloudAuthError
 # embeddedci.com 301-redirects to www, which urllib would mishandle on a POST).
 DEFAULT_AUDIENCE = "https://embeddedci.com"
 DEFAULT_API_BASE = "https://www.embeddedci.com"
+#: Lifetime asked for when exchanging an API key or user token; the cloud transport renews it.
+DEFAULT_SESSION_TTL = 3600
 
 # A real User-Agent is required: the apex/edge (Cloudflare) bans the default "Python-urllib/x.y"
 # signature (HTTP 403, error 1010). Identify the SDK explicitly instead.
@@ -119,19 +125,16 @@ def exchange_token(api_base: str, oidc_token: str) -> dict:
         raise CloudAuthError(f"embeddedci token exchange failed: {exc}") from exc
 
 
-def exchange_api_key(api_base: str, api_key: str, ttl_seconds: int = 3600) -> dict:
-    """Exchange a user API key for a short-lived ``cloud_session`` token via POST /api/auth/token.
-
-    Mirrors the Go hwe2e cloud suite's ``/auth/token`` call: the key authenticates the request
-    (``Authorization: ApiKey eci_…``) and the reply carries a bearer token scoped to the devices
-    that key may drive.
-    """
+def _exchange_for_cloud_session(api_base: str, authorization: str, what: str,
+                                ttl_seconds: int) -> dict:
+    """POST /api/auth/token with ``authorization``: the reply carries a short-lived ``cloud_session``
+    bearer token scoped to the devices that credential may drive."""
     url = api_base.rstrip("/") + "/api/auth/token"
     data = json.dumps({"ttl_seconds": int(ttl_seconds)}).encode("utf-8")
     request = urllib.request.Request(
         url, data=data, method="POST",
         headers={
-            "Authorization": f"ApiKey {api_key}",
+            "Authorization": authorization,
             "Content-Type": "application/json",
             "Accept": "application/json",
             "User-Agent": USER_AGENT,
@@ -146,30 +149,70 @@ def exchange_api_key(api_base: str, api_key: str, ttl_seconds: int = 3600) -> di
             msg = json.loads(msg).get("error", msg)
         except Exception:
             pass
-        raise CloudAuthError(f"embeddedci API-key token exchange failed (HTTP {exc.code}): {msg}") from exc
+        raise CloudAuthError(f"embeddedci {what} token exchange failed (HTTP {exc.code}): {msg}") from exc
     except Exception as exc:
-        raise CloudAuthError(f"embeddedci API-key token exchange failed: {exc}") from exc
+        raise CloudAuthError(f"embeddedci {what} token exchange failed: {exc}") from exc
 
 
-def get_session_token(api_base: str = DEFAULT_API_BASE, audience: str = DEFAULT_AUDIENCE,
-                      api_key: "str | None" = None) -> str:
-    """Mint an embeddedci session token for the cloud destination.
+def exchange_api_key(api_base: str, api_key: str, ttl_seconds: int = DEFAULT_SESSION_TTL) -> dict:
+    """Exchange a user API key for a short-lived ``cloud_session`` token via POST /api/auth/token.
 
-    Prefers an explicit ``api_key`` (or ``BENCHPOD_API_KEY``), which works anywhere; falls back to
-    GitHub Actions OIDC, which works only inside a workflow with ``id-token: write``.
+    Mirrors the Go hwe2e cloud suite's ``/auth/token`` call: the key authenticates the request
+    (``Authorization: ApiKey eci_…``) and the reply carries a bearer token scoped to the devices
+    that key may drive.
+    """
+    return _exchange_for_cloud_session(api_base, f"ApiKey {api_key}", "API-key", ttl_seconds)
+
+
+def exchange_user_token(api_base: str, access_token: str, ttl_seconds: int = DEFAULT_SESSION_TTL) -> dict:
+    """Exchange a logged-in user's access token (e.g. from ``benchpod login``) for a
+    ``cloud_session`` token via the same POST /api/auth/token, authenticated as ``Bearer``."""
+    return _exchange_for_cloud_session(api_base, f"Bearer {access_token}", "user", ttl_seconds)
+
+
+def _expires_at(resp: dict) -> "float | None":
+    """The token's expiry as a ``time.time()`` value, from ``expires_at`` or ``expires_in``."""
+    raw = resp.get("expires_at")
+    if isinstance(raw, str) and raw:
+        try:
+            return datetime.fromisoformat(raw.replace("Z", "+00:00")).timestamp()
+        except ValueError:
+            pass
+    try:
+        return time.time() + float(resp["expires_in"])
+    except (KeyError, TypeError, ValueError):
+        return None
+
+
+def mint_session_token(api_base: str = DEFAULT_API_BASE, audience: str = DEFAULT_AUDIENCE,
+                       api_key: "str | None" = None,
+                       user_token: "Callable[[], str] | None" = None) -> "Tuple[str, float | None]":
+    """Mint an embeddedci session token for the cloud destination, and when it expires.
+
+    Credentials, in order: an explicit ``api_key`` (or ``BENCHPOD_API_KEY``), which works anywhere;
+    ``user_token``, a callable returning a logged-in user's access token; GitHub Actions OIDC, which
+    works only inside a workflow with ``id-token: write``. Returns ``(token, expires_at)`` with
+    ``expires_at`` a ``time.time()`` value, or None when the server did not say.
     """
     key = api_key or os.environ.get("BENCHPOD_API_KEY")
-    if key:
-        resp = exchange_api_key(api_base, key.strip())
+    if key or user_token is not None:
+        resp = (exchange_api_key(api_base, key.strip()) if key
+                else exchange_user_token(api_base, user_token()))  # type: ignore[misc]
         # /auth/token replies {"token": …}; accept access_token too so either shape works.
         token = resp.get("token") or resp.get("access_token")
         if not token:
-            raise CloudAuthError("embeddedci API-key token exchange returned no token")
-        return token
+            raise CloudAuthError("embeddedci token exchange returned no token")
+        return token, _expires_at(resp)
 
     oidc = mint_oidc_token(audience)
     resp = exchange_token(api_base, oidc)
     token = resp.get("access_token")
     if not token:
         raise CloudAuthError("embeddedci token exchange returned no access_token")
-    return token
+    return token, _expires_at(resp)
+
+
+def get_session_token(api_base: str = DEFAULT_API_BASE, audience: str = DEFAULT_AUDIENCE,
+                      api_key: "str | None" = None) -> str:
+    """Mint an embeddedci session token for the cloud destination (see :func:`mint_session_token`)."""
+    return mint_session_token(api_base, audience, api_key)[0]

{embeddedci-2.1.0 → embeddedci-2.2.0}/src/embeddedci/benchpod/control_loop.py

@@ -230,12 +230,15 @@ class IVPoint:
     in a closed-loop run, but in a fixed/sweep run the ADC is not in the path at all and ``i`` is
     a reading of something nothing is using, so plot and assert against ``input_code``.
     ``source`` names the input source the device reports (``None`` on firmware without it).
+    ``tripped`` is True once the loop's over-range trip has latched: the output is parked at vmin
+    until the loop is re-armed (``None`` on firmware that does not report it).
     """
 
     i: int
     v: int
     input_code: Optional[int] = None
     source: Optional[str] = None
+    tripped: Optional[bool] = None
 
     @property
     def loop_input(self) -> int:

{embeddedci-2.1.0 → embeddedci-2.2.0}/src/embeddedci/benchpod/flash.py

@@ -28,6 +28,10 @@ from .errors import FlashError, TargetUnreachableError
 from .transport.base import RawLink, Transport
 
 TARGET_POWER_SETTLE = 0.25  # seconds for the target to boot after power-on
+# After switching the target's rail on, the pod also waits (up to this long) for the target to
+# answer SWD before handing over: an STM32 NUCLEO needs ~2.1 s (its ST-LINK boots first), which a
+# fixed settle cannot cover for every board.  Firmware that predates it ignores the field.
+TARGET_ANSWER_WAIT_MS = 5000
 
 # OpenOCD stderr substrings that mean the probe worked but no target answered.
 _SWD_CONNECT_MARKERS = (b"cannot read IDR", b"Error connecting DP")
@@ -37,7 +41,11 @@ _SWD_CONNECT_MARKERS = (b"cannot read IDR", b"Error connecting DP")
 _DAP_TCP_SIG = b"\x44\x41\x50\x00"  # "DAP\0" little-endian u32 packet signature
 _DAP_TCP_HDR = 8                    # signature(4) + len(2) + type(1) + reserved(1)
 _DAP_PKT_RESPONSE = 0x02            # packet_type OpenOCD expects on device->host frames
-_DAP_MAX_PACKET = 256               # mirrors DAP_PACKET_SIZE in the firmware (dap.h)
+# CMSIS-DAP packets the pod is asked to advertise (dap.h DAP_PACKET_SIZE / DAP_PACKET_COUNT_MAX).
+# Each packet is a host + network round trip, so bigger packets and several in flight cut the
+# waiting between them; firmware that predates the fields keeps 256 x 1.
+_DAP_MAX_PACKET = 1024
+_DAP_PACKET_COUNT = 4
 
 # Empty the target cfg's clock-boost reset events. The just-after-reset PLL/clock
 # writes (`adapter speed`, reset-init) race the still-coming-up core over the SWD
@@ -160,7 +168,7 @@ def flash(
 ) -> FlashResult:
     """Arm the CMSIS-DAP probe and run OpenOCD. Returns a :class:`FlashResult`.
 
-    ``swclk``/``swdio`` are LA channels 1-12 (already coerced by the caller).
+    ``swclk``/``swdio`` are LA channels 1-14 (already coerced by the caller).
     ``target_power`` of 1/2 enables that eFuse first; ``None`` leaves power
     untouched.
 
@@ -207,7 +215,9 @@ def flash(
     attempts = max(1, connect_attempts)
     result: Optional[FlashResult] = None
     for attempt in range(attempts):
-        pod_link = transport.dap_start(swclk, swdio)
+        pod_link = transport.dap_start(
+            swclk, swdio, packet_size=_DAP_MAX_PACKET, packet_count=_DAP_PACKET_COUNT,
+            wait_ms=TARGET_ANSWER_WAIT_MS if (target_power is not None and attempt == 0) else None)
         try:
             result = _run_bridge(bin_path, args, pod_link, timeout=timeout)
         finally:

{embeddedci-2.1.0 → embeddedci-2.2.0}/src/embeddedci/benchpod/gpio.py

@@ -1,6 +1,6 @@
 """GPIO on the LA pins, and which function owns each pin.
 
-Each of the pod's 12 LA channels has exactly one function at a time:
+Each of the pod's 14 LA channels has exactly one function at a time:
 
 * ``none`` — the default "LA mode": high-Z, watched by captures;
 * ``gpio`` — an input, a push-pull output or an open-drain output you control;
@@ -38,7 +38,7 @@ class LaPinState:
     gpio: Optional[str] = None
     #: The commanded level of a GPIO output or open-drain pin.
     level: Optional[int] = None
-    #: ``"up"``, ``"down"`` or ``None`` (LA9-LA12 have no bias resistor).
+    #: ``"up"``, ``"down"`` or ``None`` (LA9-LA14 have no bias resistor).
     pull: Optional[str] = None
     pull_ohms: Optional[str] = None
     pull_on: bool = False

{embeddedci-2.1.0 → embeddedci-2.2.0}/src/embeddedci/benchpod/i2c.py

@@ -161,7 +161,7 @@ def decode(packed: Iterable[int]) -> List[I2CTransaction]:
 
 
 def decode_from_la(words: Iterable[int], sda_ch: int, scl_ch: int) -> List[I2CTransaction]:
-    """Decode I2C from a raw 12-channel LA capture (the unified-capture path).
+    """Decode I2C from a raw 14-channel LA capture (the unified-capture path).
 
     ``words`` are 12-bit LA samples (bit ``n`` = channel ``LA{n+1}``); ``sda_ch`` /
     ``scl_ch`` are 1-based channel numbers.  This is how I2C is decoded now that the

{embeddedci-2.1.0 → embeddedci-2.2.0}/src/embeddedci/benchpod/lease.py

@@ -21,7 +21,7 @@ from typing import Callable, Optional, Tuple
 from urllib.parse import quote
 
 from .cloud_auth import USER_AGENT
-from .errors import CloudAuthError, DeviceBusyError
+from .errors import CloudAuthError, ConnectionConfigError, DeviceBusyError
 
 # Server defaults: lease TTL 120s. Heartbeat at ~TTL/3 keeps it alive through long flashes.
 DEFAULT_LEASE_TTL = 120
@@ -65,9 +65,12 @@ class DeviceLease:
         device_name: str,
         ttl_seconds: int = DEFAULT_LEASE_TTL,
         run_label: Optional[str] = None,
+        invalidate_token: Optional[Callable[[], bool]] = None,
     ) -> None:
         self._api_base = api_base.rstrip("/")
         self._token_provider = token_provider
+        # Drops a token the server rejected (HTTP 401) so the provider mints a fresh one.
+        self._invalidate_token = invalidate_token
         self._device = device_name
         self._ttl = max(15, int(ttl_seconds))
         self._run_label = run_label or _default_run_label()
@@ -108,7 +111,8 @@ class DeviceLease:
             if time.monotonic() >= deadline:
                 raise DeviceBusyError(
                     f"BenchPod {self._device!r} is in use by {holder}; waited {wait_timeout:.0f}s "
-                    "for it to free. Increase the wait (--benchpod-lease-wait) or stagger your runs."
+                    "for it to free. Wait longer (lease_wait, or --benchpod-lease-wait under "
+                    "pytest), try again later, or stagger your runs."
                 )
             if not warned:
                 warnings.warn(
@@ -127,7 +131,7 @@ class DeviceLease:
         if self._held:
             try:
                 self._post("lease/release")
-            except CloudAuthError:
+            except (CloudAuthError, ConnectionConfigError):
                 pass  # best-effort; the lease will expire on its own
             self._held = False
 
@@ -140,7 +144,7 @@ class DeviceLease:
             while not self._stop.wait(interval):
                 try:
                     holder, _ = self._post("lease/renew")
-                except CloudAuthError:
+                except (CloudAuthError, ConnectionConfigError):
                     continue  # transient; try again next tick
                 if holder is not None:
                     warnings.warn(
@@ -154,9 +158,10 @@ class DeviceLease:
         self._thread = threading.Thread(target=loop, name="benchpod-lease", daemon=True)
         self._thread.start()
 
-    def _post(self, path: str) -> Tuple[Optional[str], Optional[dict]]:
+    def _post(self, path: str, *, renewed: bool = False) -> Tuple[Optional[str], Optional[dict]]:
         """POST to /api/cloud/devices/<path>. Returns (None, payload) on success, or
-        (holder, None) when the device is busy (HTTP 409). Raises CloudAuthError on other failures."""
+        (holder, None) when the device is busy (HTTP 409). Raises ConnectionConfigError when the
+        server has no such device, CloudAuthError on other failures."""
         url = f"{self._api_base}/api/cloud/devices/{path}?device={quote(self._device, safe='')}"
         body = json.dumps(
             {"lease_id": self._lease_id, "run_label": self._run_label, "ttl_seconds": self._ttl}
@@ -170,16 +175,33 @@ class DeviceLease:
             with urllib.request.urlopen(request, timeout=_LEASE_HTTP_TIMEOUT) as resp:
                 return None, json.loads(resp.read().decode("utf-8"))
         except urllib.error.HTTPError as exc:
+            detail = exc.read().decode("utf-8", "replace")[:300]
             if exc.code == 409:
                 holder = "another run"
                 try:
-                    holder = json.loads(exc.read().decode("utf-8")).get("holder", holder)
+                    busy = json.loads(detail)
+                    holder = busy.get("holder") or holder
+                    if busy.get("expires_at"):
+                        holder += f" (its lease runs until {busy['expires_at']} unless renewed)"
                 except Exception:
                     pass
                 return holder, None
-            if exc.code in (404, 405, 501):
+            if exc.code == 401 and not renewed and self._invalidate_token and self._invalidate_token():
+                return self._post(path, renewed=True)
+            if exc.code == 404:
+                # A JSON error is the server answering for the device; a bare 404 is an older
+                # server without the lease route.
+                try:
+                    msg = json.loads(detail).get("error")
+                except Exception:
+                    msg = None
+                if msg:
+                    raise ConnectionConfigError(
+                        f"no cloud BenchPod named {self._device!r} in this organization ({msg}); "
+                        "list the devices to see the names") from exc
+                raise _LeaseUnsupported() from exc
+            if exc.code in (405, 501):
                 raise _LeaseUnsupported() from exc
-            detail = exc.read().decode("utf-8", "replace")[:300]
             raise CloudAuthError(f"device lease {path} failed (HTTP {exc.code}): {detail}") from exc
         except Exception as exc:
             raise CloudAuthError(f"device lease {path} failed: {exc}") from exc

{embeddedci-2.1.0 → embeddedci-2.2.0}/src/embeddedci/benchpod/pytest_plugin.py

@@ -26,11 +26,11 @@ _PULLDOWN_CHANNELS = frozenset(PULLDOWN_CHANNELS)
 
 
 class BenchPodPins:
-    """The pod's 12 generic logic-analyzer channels (``pin_1`` .. ``pin_12``)
+    """The pod's 14 generic logic-analyzer channels (``pin_1`` .. ``pin_14``)
     plus the target-power ``efuse``.
 
-    The pod has **no dedicated SWD/UART/I2C pins** — it exposes 12 identical LA
-    channels (LA1..LA12) and any DUT signal can be wired to any of them. So this
+    The pod has **no dedicated SWD/UART/I2C pins** — it exposes 14 identical LA
+    channels (LA1..LA14) and any DUT signal can be wired to any of them. So this
     fixture names the channels by number, not by role: ``pins.pin_11`` is LA
     channel 11, nothing more. A test maps its own bench wiring at the top of the
     file, e.g. ``swclk = pins.pin_11`` — that mapping is bench-specific and lives
@@ -387,7 +387,7 @@ def benchpod_target(benchpod: BenchPod, pytestconfig: "pytest.Config") -> Iterat
 
 @pytest.fixture(scope="session")
 def benchpod_pins(pytestconfig: "pytest.Config") -> BenchPodPins:
-    """The pod's generic LA channels (``pin_1`` .. ``pin_12``) and the eFuse rail.
+    """The pod's generic LA channels (``pin_1`` .. ``pin_14``) and the eFuse rail.
 
     Channels are not roles — map your bench wiring (which signal is on which LA
     channel) in the test itself. The eFuse rail comes from ``--benchpod-efuse`` (default 1).