oep-client-python 0.0.8__tar.gz → 0.0.9__tar.gz

{oep_client_python-0.0.8 → oep_client_python-0.0.9}/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## Unreleased
 
+## 0.0.9
+- (EN) The fake probe has `oep.fixture.capture` (logic, `fake_capture`): one-shot, repeat (a ring and release), streaming (data pushes), level / edge triggers with a pretrigger, events, and a known waveform (sample i = the counter i, channel k = its bit k) in the profile's layout (P4: w 1-16; classic ESP32: w 8). A capture shares pins with other interfaces (it only listens). `Endpoint.pushes()` gives the frames the probe sends by itself; fake_serve sends them on the pty and TCP. `--capture-slipped` sets flags bit2 on every segment.
+- (JA) 偽の probe に `oep.fixture.capture`（ロジック、`fake_capture`）を入れた: ワンショット、リピート（リングと release）、ストリーミング（データの push）、レベル / エッジのトリガとプリトリガ、出来事。取れる波形は決まっている（サンプル i = カウンタ i、チャネル k = そのビット k）。layout は profile のもの（P4: w 1〜16、classic ESP32: w 8）。capture はほかのインターフェースとピンを共有できる（聞くだけ）。`Endpoint.pushes()` が probe の送り出すフレームを返し、fake_serve は pty と TCP に流す。`--capture-slipped` は区画すべてに flags bit2 を立てる。
+- (EN) The fake: an attach without pins joins the wire's one live connection, also on a wire whose pins the host chooses (oep-if-debug §1).
+- (JA) 偽の probe: pins の無い attach は、その線の生きている接続が 1 つならそれに乗る。host がピンを選ぶ線でも同じ（oep-if-debug §1）。
+
 ## 0.0.8
 - (EN) Wires whose pins the host chooses (oep-if-debug §1, role_channels): the fake takes any allowed free pair, skips the pairs whose pins something holds in a count-0 scan, holds a live connection's pins against plans, and has a profile for it (`rp2350-pins`). `Wire.scan()` goes through the whole list (at most 255 pairs a request; count 0 continues with the new skip TLV until tried = 0).
 - (JA) host がピンを選ぶ wire（oep-if-debug §1、role_channels）: 偽の probe は、許された空いている組ならどれでも受け、count = 0 の scan では何かが持っているピンの組を飛ばし、生きている接続のピンを plan から守る。そのための profile（`rp2350-pins`）を足した。`Wire.scan()` は並びを最後まで回る（1 回 255 組まで。count = 0 は新しい skip の TLV で tried = 0 まで続ける）。

{oep_client_python-0.0.8 → oep_client_python-0.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: oep-client-python
-Version: 0.0.8
+Version: 0.0.9
 Summary: Open Embedded Probe (OEP) v1 host: serial / USB / TCP transports, the session rules, the standard interfaces, and a fake probe
 Project-URL: Homepage, https://github.com/Open-Embedded-Probe/oep-client-python
 Project-URL: Repository, https://github.com/Open-Embedded-Probe/oep-client-python
@@ -107,8 +107,15 @@ A run on hardware: ArduinoCore-CH32's `tests/manual/oep_smoke/` (`oep_smoke.py`,
 
 `endpoint.Endpoint` is a fake probe that answers as oep-spec says; ch32rv, this client and the probe firmware are checked
 against it (when the spec changes, this is brought in line before the firmware). `fake` holds example declarations (profiles
-`p4-x035`, `esp32-v003`, `p4-bench` = a made-up jig with three slots and two seats), `fake_serial` the byte side of a serial
-port (COBS candidates, raw bytes and binds, held during a session and resumed after it).
+`p4-x035`, `esp32-v003`, `p4-bench` = a made-up jig with three slots and two seats, `rp2350-pins` = a wire whose pins the host
+chooses), `fake_serial` the byte side of a serial port (COBS candidates, raw bytes and binds, held during a session and
+resumed after it).
+
+`fake_capture` is `oep.fixture.capture` (logic): one-shot, repeat (segments with the clock at the actual rate, a ring,
+release) and streaming (data pushes while subscribed), level / edge triggers with a pretrigger, and events. What it
+captures is known: sample i is the counter i, channel k its bit k (a square wave of period 2^(k+1) samples), in the layout
+the profile allows (`p4-x035`: w 1-16 as the P4's PARLIO, three channels in w 4; `esp32-v003`: w 8 as the classic ESP32's
+sampler, one-shot only). A capture only listens, so it may be planned on pins other interfaces hold.
 
 Other programs' tests run `fake_serve` as a child process:
 
@@ -122,4 +129,5 @@ The pty is a serial port (the host opens it with TIOCEXCL); `--tcp PORT` is `--f
 `--framing length` (the vendor bulk / TCP form). Faults: `--drop N` (the N-th answer is not sent, once; the request did run,
 so a resend gets the remembered result), `--noise TEXT` (noise before every answer), `--corrupt N` (the N-th answer's CRC
 broken once). `--uart-plan` / `--uart-rx` give the first fixture UART a plan and RX bytes, `--run-hook` a host's own model of
-riscv-dm run. The rest: `--help`.
+riscv-dm run, `--capture-slipped` flags bit2 on every capture segment. Events and data pushes go out on the pty and on TCP
+(both framings). The rest: `--help`.

{oep_client_python-0.0.8 → oep_client_python-0.0.9}/README.ja.md

@@ -80,8 +80,14 @@ oep config save <probe>                      # 再起動の後も残す（remove
 
 `endpoint.Endpoint` は oep-spec の規範どおりに答える偽の probe で、ch32rv・この client・probe の firmware を突き合わせる
 「動く spec」として使う（spec が変わったら、probe の firmware より先にここを合わせる）。`fake` は宣言の例（profile:
-`p4-x035`、`esp32-v003`、`p4-bench` = スロット 3 か所と席 2 つの架空の治具）、`fake_serial` はシリアルの口のバイトの側（COBS の
-候補、生のバイトと bind、セッション中の停止と再開）。
+`p4-x035`、`esp32-v003`、`p4-bench` = スロット 3 か所と席 2 つの架空の治具、`rp2350-pins` = host がピンを選ぶ wire）、`fake_serial` は
+シリアルの口のバイトの側（COBS の候補、生のバイトと bind、セッション中の停止と再開）。
+
+`fake_capture` は `oep.fixture.capture`（ロジック）: ワンショット、リピート（実際のレートで時計どおりに区画ができ、リング、release）、
+ストリーミング（購読している間のデータの push）、レベル / エッジのトリガとプリトリガ、出来事。取れるものは決まっている: サンプル i は
+カウンタの値 i で、チャネル k はそのビット k（周期 2^(k+1) サンプルの方形波）。layout は profile が許す形（`p4-x035`: P4 の
+PARLIO と同じ w 1〜16、3 本なら w 4。`esp32-v003`: classic ESP32 の sampler と同じ w 8、ワンショットだけ）。capture は聞くだけ
+なので、ほかのインターフェースが持つピンにも plan できる。
 
 外のプログラムの試験には `fake_serve` を子プロセスで使う:
 
@@ -93,6 +99,7 @@ uv run python -m oep_client.fake_serve --pty --profile p4-bench --slot x035 --bi
 
 pty がシリアルの口（host が TIOCEXCL を掛けて開く）、`--tcp PORT` は `--framing cobs`（シリアルの口）か `--framing length`
 （vendor bulk / TCP の形）。故障の注入は `--drop N`（N 番目の答えを 1 回出さない。要求は実行済みなので送り直しは覚えた答えを
-受ける）、`--noise TEXT`（答えの前に雑音）、`--corrupt N`（N 番目の答えの CRC を 1 回壊す）。ほかは `--help`。
+受ける）、`--noise TEXT`（答えの前に雑音）、`--corrupt N`（N 番目の答えの CRC を 1 回壊す）。`--capture-slipped` は capture の
+区画すべてに flags bit2 を立てる。出来事とデータの push は pty にも TCP（両方の framing）にも出る。ほかは `--help`。
 
 v0 の client（`oep_client.v0`）は 2026-09-26 に消した（git の履歴に残る）。v0 を話す probe はもう無い。

{oep_client_python-0.0.8 → oep_client_python-0.0.9}/README.md

@@ -85,8 +85,15 @@ A run on hardware: ArduinoCore-CH32's `tests/manual/oep_smoke/` (`oep_smoke.py`,
 
 `endpoint.Endpoint` is a fake probe that answers as oep-spec says; ch32rv, this client and the probe firmware are checked
 against it (when the spec changes, this is brought in line before the firmware). `fake` holds example declarations (profiles
-`p4-x035`, `esp32-v003`, `p4-bench` = a made-up jig with three slots and two seats), `fake_serial` the byte side of a serial
-port (COBS candidates, raw bytes and binds, held during a session and resumed after it).
+`p4-x035`, `esp32-v003`, `p4-bench` = a made-up jig with three slots and two seats, `rp2350-pins` = a wire whose pins the host
+chooses), `fake_serial` the byte side of a serial port (COBS candidates, raw bytes and binds, held during a session and
+resumed after it).
+
+`fake_capture` is `oep.fixture.capture` (logic): one-shot, repeat (segments with the clock at the actual rate, a ring,
+release) and streaming (data pushes while subscribed), level / edge triggers with a pretrigger, and events. What it
+captures is known: sample i is the counter i, channel k its bit k (a square wave of period 2^(k+1) samples), in the layout
+the profile allows (`p4-x035`: w 1-16 as the P4's PARLIO, three channels in w 4; `esp32-v003`: w 8 as the classic ESP32's
+sampler, one-shot only). A capture only listens, so it may be planned on pins other interfaces hold.
 
 Other programs' tests run `fake_serve` as a child process:
 
@@ -100,4 +107,5 @@ The pty is a serial port (the host opens it with TIOCEXCL); `--tcp PORT` is `--f
 `--framing length` (the vendor bulk / TCP form). Faults: `--drop N` (the N-th answer is not sent, once; the request did run,
 so a resend gets the remembered result), `--noise TEXT` (noise before every answer), `--corrupt N` (the N-th answer's CRC
 broken once). `--uart-plan` / `--uart-rx` give the first fixture UART a plan and RX bytes, `--run-hook` a host's own model of
-riscv-dm run. The rest: `--help`.
+riscv-dm run, `--capture-slipped` flags bit2 on every capture segment. Events and data pushes go out on the pty and on TCP
+(both framings). The rest: `--help`.

{oep_client_python-0.0.8 → oep_client_python-0.0.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "oep-client-python"
-version = "0.0.8"
+version = "0.0.9"
 description = "Open Embedded Probe (OEP) v1 host: serial / USB / TCP transports, the session rules, the standard interfaces, and a fake probe"
 readme = "README.md"
 license = "MIT"

{oep_client_python-0.0.8 → oep_client_python-0.0.9}/src/oep_client/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.0.8"
+__version__ = "0.0.9"

{oep_client_python-0.0.8 → oep_client_python-0.0.9}/src/oep_client/endpoint.py

@@ -39,7 +39,7 @@ from collections import OrderedDict
 from dataclasses import dataclass, field
 from typing import Callable
 
-from . import catalog, fake, message as m, registry as reg
+from . import catalog, fake, fake_capture, message as m, registry as reg
 
 TOY_WRITE, TOY_READ = 0x01, 0x02
 OK, WAIT, LINE, FAULT, TIMEOUT, STATE = (reg.STATUS[k] for k in ("ok", "wait", "line", "fault", "timeout", "state"))
@@ -275,6 +275,8 @@ class Endpoint:
             first = self._role_pairs(fn)[0]
             self.targets[(fn, first)] = FakeTarget()
         self.target = next(iter(self.targets.values()), FakeTarget())
+        self.captures: dict[int, fake_capture.FakeCapture] = {
+            fn: self._capture_from(self.static[fn]) for fn, name in self.names.items() if name == "oep.fixture.capture"}
         self.mechanisms = set()
         for fn, name in self.names.items():
             if name == "oep.target.console":
@@ -302,6 +304,9 @@ class Endpoint:
         self.dropped = 0                     # requests a v0 endpoint dropped (role 0x81)
         self.requests: list[m.Request] = []
         self.subscribed: set[int] = set()
+        self.push_seq: dict[int, int] = {}              # fn -> the next event / data seq (core §11.2)
+        self.outbox: list[bytes] = []                   # events and data frames waiting to go out (pushes())
+        self.capture_slipped = False                    # every capture segment says flags bit2 (a pace that fell behind)
         self.plan: set[tuple[int, int, int]] = set()   # (fn, role, channel), from plan_apply and the config
         self.plan_from_config: set[int] = set()        # fns whose plan came from the config (not a session's)
         self.resend: OrderedDict[int, tuple[int, int, int, bytes | None]] = OrderedDict()
@@ -340,6 +345,91 @@ class Endpoint:
     def target_id(self, value: int | None) -> None:
         self.target.target_id = value
 
+    @staticmethod
+    def _capture_from(tlvs: list[bytes]) -> fake_capture.FakeCapture:
+        """A capture as its describe declares it (modes, the w allowed, the rate range, max_read, the ring)."""
+        d = reg.FIXTURE_CAPTURE.tlv["describe"]
+        modes, widths, lo, hi, ring, most = set(), {8}, 1, 1_000_000, 1, 1024
+        for t in tlvs:
+            tag, v = t[0], t[2:2 + t[1]]
+            if tag == d["mode"]:
+                modes.add(v[0])
+            elif tag == d["channels"]:
+                widths = {1 << i for i in range(6) if v[1] >> i & 1}
+            elif tag == catalog.MIN_CLOCK_HZ:
+                lo = struct.unpack("<I", v)[0]
+            elif tag == catalog.MAX_CLOCK_HZ:
+                hi = struct.unpack("<I", v)[0]
+            elif tag == d["segment_ring"]:
+                ring = struct.unpack("<H", v)[0]
+            elif tag == d["max_read"]:
+                most = struct.unpack("<I", v)[0]
+        return fake_capture.FakeCapture(modes or {fake_capture.MODE["one_shot"]}, widths, lo, hi, ring, most)
+
+    def _next_seq(self, fn: int) -> int:
+        seq = self.push_seq.get(fn, 0)
+        self.push_seq[fn] = (seq + 1) & 0xFFFF
+        return seq
+
+    def _events(self, fn: int, events: list[bytes]) -> None:
+        """Events (kind(u8) payload) of `fn` to go out while it is subscribed; unsubscribed, they are not sent."""
+        for e in events:
+            if fn in self.subscribed:
+                self.outbox.append(bytes([m.ROLE_EVENT]) + struct.pack("<HH", fn, self._next_seq(fn)) + e)
+
+    def pushes(self) -> list[bytes]:
+        """The frames the probe sends by itself now (core §11): events, and a streaming capture's data. A serving loop
+        frames and sends them; a test takes them from here."""
+        self.tick()
+        for fn, cap in self.captures.items():
+            if fn in self.subscribed:
+                self.outbox += cap.pushes(fn, lambda fn=fn: self._next_seq(fn), self.probe.max_frame)
+        out, self.outbox = self.outbox, []
+        return out
+
+    def _capture(self, fn: int, op: int, t: Take) -> tuple[int, int, bytes]:
+        cap, O = self.captures[fn], fake_capture.OP
+        self._events(fn, cap.tick(self.now()))                     # what the clock captured up to this request
+        roles = sorted(a[1] for a in self.plan if a[0] == fn)
+        budget = self.probe.max_frame - m.RESULT_HEADER
+        try:
+            if op in (O["configure"], O["query"]):
+                got, ignored = t.tail(set(fake_capture.TLV.values()) - {fake_capture.TLV["frontend"]})
+                settled = cap.settle(got, t.critical, len(roles))
+                if op == O["configure"]:
+                    cap.apply(settled)
+                    cap.slipped = self.capture_slipped
+                return self._answer(cap.answer(settled), ignored)
+            if op == O["start"]:
+                t.tail()
+                self._events(fn, cap.start(self.now()))
+                return m.COMPLETED, m.SUCCESS, struct.pack("<I", 0)
+            if op == O["stop"]:
+                t.tail()
+                self._events(fn, cap.stop())
+                return m.COMPLETED, m.SUCCESS, b""
+            if op == O["force"]:
+                t.tail()
+                return m.COMPLETED, m.SUCCESS, b""                  # nothing waits: a trigger is found at start
+            if op == O["status"]:
+                t.tail()
+                return m.COMPLETED, m.SUCCESS, cap.status()
+            if op == O["read"]:
+                position, most = t.take("QI")
+                return m.COMPLETED, m.SUCCESS, cap.read(position, most, budget)
+            if op == O["segments"]:
+                first = t.take("I")
+                t.tail()
+                return m.COMPLETED, m.SUCCESS, cap.segment_list(first, budget)
+            if op == O["release"]:
+                serial = t.take("I")
+                t.tail()
+                cap.release(serial, self.now())
+                return m.COMPLETED, m.SUCCESS, b""
+        except fake_capture.Reject as e:
+            raise Reject(e.reason, e.payload)
+        return m.REJECTED, m.UNKNOWN_OPERATION, b""
+
     def _role_pairs(self, fn: int) -> list[tuple[int, int]]:
         """A role_channels wire's pairs in the count = 0 order (oep-if-debug §1): swdio ascending, then swclk."""
         roles = self.pin_roles[fn]
@@ -361,7 +451,7 @@ class Endpoint:
     def _held(self, fn: int | None = None, pair: tuple[int, int] | None = None) -> set[int]:
         """Channels something holds (core §8.1): the plan, the slots' pairs, the live connections' pairs - except
         wire `fn`'s own connection on `pair` (attaching there again, or scanning through it)."""
-        held = {a[2] for a in self.plan}
+        held = {a[2] for a in self.plan if a[0] not in self.captures}   # a capture only listens
         held |= {p for s in self.slots.values() for p in s.pair if p != 0xFFFF and not (s.wire_fn == fn and s.pair == pair)}
         held |= {p for c in self.conns.values() for p in c.pair if p != 0xFFFF and not (c.fn == fn and c.pair == pair)}
         return held
@@ -613,6 +703,7 @@ class Endpoint:
             if fn != 0 and fn not in self.names:
                 return m.REJECTED, m.UNAVAILABLE, b""
             self.subscribed.add(fn)
+            self.push_seq[fn] = 0                                  # seq from 0 at every subscribe (core §11.2)
             return m.COMPLETED, m.SUCCESS, b""
         if op == m.OP_UNSUBSCRIBE:
             fn = t.take("H")
@@ -644,14 +735,24 @@ class Endpoint:
     def _check_plan(self, got: list[tuple[int, int, int]]) -> None:
         """plan_apply's all-or-nothing check: the roles each fn has, and no pin another fn (or a slot) holds."""
         named = {fn for fn, _, _ in got}
-        kept = {a for a in self.plan if a[0] not in named}
+        # a capture only listens: it shares pins with anything, and nothing is kept from a pin by it (core §8.1)
+        kept = {a for a in self.plan if a[0] not in named and a[0] not in self.captures}
         slot_pins = {p for s in self.slots.values() for p in s.pair if p != 0xFFFF}
         slot_pins |= {p for c in self.conns.values() for p in c.pair if p != 0xFFFF}   # a live connection's pins too
         for fn, role, ch in got:
+            if fn in self.captures:
+                if role not in self._declared_roles(fn, ch):
+                    raise Reject(m.UNAVAILABLE)
+                continue
             roles = {"oep.fixture.gpio": {1}, "oep.fixture.uart": {1, 2}}.get(self.names.get(fn, ""), set())
             if role not in roles or any(k[2] == ch for k in kept) or ch in slot_pins:
                 raise Reject(m.UNAVAILABLE)
 
+    def _declared_roles(self, fn: int, channel: int) -> set[int]:
+        """The roles fn's describe offers on `channel` (role_channels)."""
+        return {t[2] for t in self.static[fn] if t[0] == catalog.ROLE_CHANNELS
+                and channel in catalog.bitmap_to_channels(struct.unpack_from("<H", t, 3)[0], t[5:2 + t[1]])}
+
     def _drop_plan(self, fn: int) -> None:
         for a in [a for a in self.plan if a[0] == fn]:
             self.gpio_modes.pop(a[2], None)
@@ -787,8 +888,11 @@ class Endpoint:
             if not self._allows(fn, pair) or set(pair) & self._held(fn, pair):
                 raise Reject(m.UNAVAILABLE)                        # not allowed here, or its pins are held (§8.1)
             return pair
+        live = [c.pair for c in self.conns.values() if c.fn == fn]
+        if len(live) == 1:
+            return live[0]                                         # no pins: the wire's one live connection
         allowed = self._allowed_pairs(fn)
-        if len(allowed) != 1:
+        if live or len(allowed) != 1:
             raise Reject(m.UNAVAILABLE)                            # the host chooses among several
         return allowed[0]
 
@@ -1399,9 +1503,11 @@ class Endpoint:
                         self.flows[(port, key)] = Flow(sid, 0)
 
     def tick(self) -> None:
-        """Time passes: the lease, at-boot retries, mixed lines closed by quiet."""
+        """Time passes: the lease, at-boot retries, mixed lines closed by quiet, the captures."""
         self._lapse()
         now = self.now()
+        for fn, cap in self.captures.items():
+            self._events(fn, cap.tick(now))
         for n, s in self.slots.items():
             rt = self.slot_rt[n]
             if (s.attach == SLOT_ATTACH["at_boot"] and s.retry_s and not rt.evicted
@@ -1549,4 +1655,4 @@ class Endpoint:
 
 SIMS = {"oep.wire.rvswd": "wire", "oep.wire.swio": "wire", "oep.target.riscv-dm": "dm",
         "oep.target.console": "console", "oep.fixture.gpio": "gpio", "oep.fixture.uart": "uart",
-        "oep.probe.config": "config_op"}
+        "oep.probe.config": "config_op", "oep.fixture.capture": "capture"}

{oep_client_python-0.0.8 → oep_client_python-0.0.9}/src/oep_client/fake.py

@@ -108,6 +108,21 @@ TRANSPORT = reg.CORE.enum["transport_kind"]
 SERIAL_KINDS = {TRANSPORT["uart_bridge"], TRANSPORT["usb_cdc"], TRANSPORT["usb_serial_jtag"]}
 NS = "io.github.ch32-riscv-ug"
 MECHANISMS = reg.TARGET_CONSOLE.tlv["describe"]["mechanisms"]
+_CAPD = reg.FIXTURE_CAPTURE.tlv["describe"]
+_CAPM = reg.FIXTURE_CAPTURE.enum["mode"]
+
+
+def _capture_decl(modes: list[str], max_channels: int, widths: list[int], max_samples: int, ring: int,
+                  max_read: int) -> tuple[bytes, ...]:
+    """oep.fixture.capture's declarations (oep-if-capture §3.5): a mode entry per mode, channels (max, the w allowed as
+    bits: bit i = w 2^i), the trigger types (immediate, level, edge) with the most pretrigger, max_read, segment_ring."""
+    out = tuple(catalog.tlv(_CAPD["mode"], struct.pack("<BBII", _CAPM[k], 1, max_samples, ring if k == "repeat" else 1))
+                for k in modes)
+    bits = sum(1 << (w.bit_length() - 1) for w in widths)
+    return out + (catalog.tlv(_CAPD["channels"], bytes([max_channels, bits])),
+                  catalog.tlv(_CAPD["trigger"], struct.pack("<BI", 0b111, max_samples - 1)),
+                  catalog.u32(_CAPD["max_read"], max_read), catalog.u16(_CAPD["segment_ring"], ring),
+                  catalog.u32(FEATURES, 0b001))
 MAX_CONNECTIONS = reg.WIRE_RVSWD.tlv["describe"]["max_connections"]
 _CFG = reg.PROBE_CONFIG.tlv["describe"]
 
@@ -165,9 +180,11 @@ def p4_x035() -> FakeProbe:
             catalog.u32(MAX_CLOCK_HZ, 3_000_000), catalog.u8(IMPLEMENTATION, 2))),
         Offered(6, 4, "oep.fixture.uart", _roles({1: pins, 2: pins}) + (
             catalog.u32(MAX_CLOCK_HZ, 3_000_000), catalog.u8(IMPLEMENTATION, 2))),
-        Offered(7, 5, "oep.fixture.capture", _roles({k: pins for k in range(8)}) + (
+        # the P4's PARLIO: w 1-16, one-shot / repeat / streaming
+        Offered(7, 5, "oep.fixture.capture", _roles({k: pins for k in range(16)}) + (
             catalog.u32(MAX_CLOCK_HZ, 20_000_000), catalog.u32(MIN_CLOCK_HZ, 1_000),
-            catalog.u16(MAX_LENGTH, 65000), catalog.u8(IMPLEMENTATION, 3))),
+            catalog.u16(MAX_LENGTH, 65000), catalog.u8(IMPLEMENTATION, 3))
+            + _capture_decl(["one_shot", "repeat", "streaming"], 16, [1, 2, 4, 8, 16], 1 << 20, 8, 4096)),
         Offered(8, 6, f"{NS}.esp32.i2c-target", _roles({1: pins, 2: pins}) + (
             catalog.u16(MAX_LENGTH, 128), catalog.u32(MAX_CLOCK_HZ, 1_000_000),
             catalog.u32(FEATURES, 0b11), catalog.u8(IMPLEMENTATION, 2))),
@@ -194,8 +211,10 @@ def esp32_v003() -> FakeProbe:
         Offered(4, 2, "oep.fixture.gpio", _roles({1: wired + [23]})),
         Offered(5, 3, "oep.fixture.uart", _roles({1: wired, 2: wired}) + (
             catalog.u32(MAX_CLOCK_HZ, 115_200), catalog.u8(IMPLEMENTATION, 2))),
+        # the classic ESP32's GPIO sampler: a byte a sample (w 8), one-shot
         Offered(6, 4, "oep.fixture.capture", _roles({k: wired for k in range(4)}) + (
-            catalog.u32(MAX_CLOCK_HZ, 2_000_000), catalog.u32(MIN_CLOCK_HZ, 400_000), catalog.u8(IMPLEMENTATION, 1))),
+            catalog.u32(MAX_CLOCK_HZ, 2_000_000), catalog.u32(MIN_CLOCK_HZ, 400_000), catalog.u8(IMPLEMENTATION, 1))
+            + _capture_decl(["one_shot"], 8, [8], 65536, 1, 480)),
         Offered(7, 5, f"{NS}.esp32.i2c-target", _roles({1: wired, 2: wired}) + (
             catalog.u16(MAX_LENGTH, 16), catalog.u32(MAX_CLOCK_HZ, 100_000), catalog.u8(IMPLEMENTATION, 2))),
         # Two fixed pin sets (an example of channel_group; GPIO23 is the DUT's NRST on this jig).

oep_client_python-0.0.9/src/oep_client/fake_capture.py

@@ -0,0 +1,267 @@
+# SPDX-License-Identifier: MIT
+"""oep.fixture.capture in the fake probe (oep-spec docs/oep-if-capture.ja.md, revision 1, logic).
+
+What it captures is known in advance, so a receiver can check it: sample i of a capture (counted from its start, across
+segments) is the counter i, and channel k is bit k of it - a square wave of period 2^(k+1) samples. The layout is the
+probe's (§1.1): w is the smallest width the describe allows (channels tag 0x44) that holds the channels, pos[k] = k.
+
+Modes: one-shot (the segment is there as soon as start answers), repeat (segments come with the clock at the actual
+rate, up to the ring; a full ring stops the capture, release frees it) and streaming (the bytes come with the clock and
+go out as data pushes while subscribed). Triggers: level and edge on a channel, with a pretrigger. `slipped` sets flags
+bit2 on every segment (a probe whose software pace fell behind).
+"""
+
+from __future__ import annotations
+
+import struct
+from dataclasses import dataclass, field
+from fractions import Fraction
+
+from . import message as m, registry as reg
+
+CAP = reg.FIXTURE_CAPTURE
+OP = CAP.op
+TLV, ANSWER = CAP.tlv["configure"], CAP.tlv["configure_answer"]
+MODE, STATE, TRIGGER = CAP.enum["mode"], CAP.enum["state"], CAP.enum["trigger"]
+STOPPED, FLAG = CAP.enum["stopped_reason"], CAP.enum["segment_flag"]
+EVENT = CAP.event
+NONE = 0xFFFFFFFF
+MAX_SAMPLES = 1 << 20                  # a fake keeps its captures in memory
+SEGMENT = struct.Struct("<IQIQIB")     # serial position samples start_us trigger_index flags (§2)
+
+
+class Reject(Exception):
+    def __init__(self, reason: int, payload: bytes = b""):
+        self.reason, self.payload = reason, payload
+
+
+@dataclass
+class Segment:
+    serial: int
+    position: int
+    samples: int
+    start_us: int
+    trigger_index: int = NONE
+    flags: int = 0
+
+    def pack(self) -> bytes:
+        return SEGMENT.pack(self.serial, self.position, self.samples, self.start_us, self.trigger_index, self.flags)
+
+
+@dataclass
+class FakeCapture:
+    """One capture interface. `now_ms` is the endpoint's clock; `roles()` the channels the plan gives it (role order)."""
+    modes: set[int]                    # the modes the describe declares
+    widths: set[int]                   # the w the describe allows
+    min_hz: int
+    max_hz: int
+    ring: int = 8                      # segment_ring
+    max_read: int = 4096
+    slipped: bool = False
+    state: int = STATE["unconfigured"]
+    mode: int = MODE["one_shot"]
+    rate: Fraction = Fraction(0)
+    samples: int = 0
+    segments_max: int = 0
+    trigger: tuple[int, int, int] | None = None
+    pretrigger: int = 0
+    width: int = 0
+    channels: int = 0
+    data: bytearray = field(default_factory=bytearray)   # the stream from `base` on
+    base: int = 0                                        # the byte position data[0] is at
+    segs: list[Segment] = field(default_factory=list)
+    serial_done: int = 0
+    started_ms: int = 0
+    produced: int = 0                  # samples produced since start (repeat / streaming)
+    sent: int = 0                      # streaming: the byte position pushed so far
+    first_sample: int = 0              # the counter value of the capture's first sample
+    gap_next: bool = False             # repeat: the capture stopped for want of a segment; the next one says so
+
+    # ---- configure ------------------------------------------------------------------------------------------------
+    def settle(self, got: dict[int, bytes], critical: set[int], channels: int) -> dict:
+        """The actual values for a configure / query request (nothing changed)."""
+        mode = got[TLV["mode"]][0] if TLV["mode"] in got else MODE["one_shot"]
+        if mode not in self.modes:
+            raise Reject(m.UNSUPPORTED, bytes([TLV["mode"] | (m.TAG_CRITICAL if TLV["mode"] in critical else 0)]))
+        if TLV["rate"] not in got or len(got[TLV["rate"]]) != 4:
+            raise Reject(m.MALFORMED)
+        asked = struct.unpack("<I", got[TLV["rate"]])[0]
+        if not asked:
+            raise Reject(m.MALFORMED)
+        # the source clock divided by a whole number: the nearest rate at or under the one asked, inside the range
+        div = max(1, -(-self.max_hz // min(max(asked, self.min_hz), self.max_hz)))
+        rate = Fraction(self.max_hz, div)
+        samples = struct.unpack("<I", got[TLV["samples"]])[0] if TLV["samples"] in got else 4096
+        samples = max(1, min(samples, MAX_SAMPLES))
+        segs = struct.unpack("<I", got[TLV["segments"]])[0] if TLV["segments"] in got else self.ring
+        segs = max(1, min(segs, self.ring)) if mode == MODE["repeat"] else 1
+        trigger = None
+        if TLV["trigger"] in got:
+            kind, role, value = struct.unpack("<BBH", got[TLV["trigger"]])
+            if kind not in (TRIGGER["immediate"], TRIGGER["level"], TRIGGER["edge"]) or (kind and role >= channels):
+                raise Reject(m.UNSUPPORTED, bytes([TLV["trigger"] | m.TAG_CRITICAL]))
+            trigger = (kind, role, value) if kind else None
+        pre = struct.unpack("<I", got[TLV["pretrigger"]])[0] if TLV["pretrigger"] in got else 0
+        width = min((w for w in self.widths if w >= max(channels, 1)), default=None)
+        if width is None or not channels:
+            raise Reject(m.UNAVAILABLE)                            # no channels planned, or more than a sample holds
+        if mode != MODE["one_shot"] and width < 8:
+            samples = -(-samples // (8 // width)) * (8 // width)   # segments end on a byte
+        return {"mode": mode, "rate": rate, "samples": samples, "segments": segs, "trigger": trigger,
+                "pretrigger": min(pre, samples - 1), "width": width, "channels": channels}
+
+    def apply(self, s: dict) -> None:
+        self.mode, self.rate, self.samples, self.segments_max = s["mode"], s["rate"], s["samples"], s["segments"]
+        self.trigger, self.pretrigger, self.width, self.channels = s["trigger"], s["pretrigger"], s["width"], s["channels"]
+        self.state = STATE["configured"]
+        self._clear()
+
+    @staticmethod
+    def answer(s: dict) -> bytes:
+        def tlv(tag: int, v: bytes) -> bytes:
+            return bytes([tag, len(v)]) + v
+        return (tlv(ANSWER["actual_rate"], struct.pack("<II", s["rate"].numerator, s["rate"].denominator))
+                + tlv(ANSWER["layout"], bytes([s["width"], s["channels"]]) + bytes(range(s["channels"])))
+                + tlv(ANSWER["actual_samples"], struct.pack("<I", s["samples"]))
+                + tlv(ANSWER["actual_segments"], struct.pack("<I", s["segments"]))
+                + tlv(ANSWER["timing"], struct.pack("<BI", 1 if s["rate"].denominator != 1 else 0, 0))
+                + tlv(ANSWER["blocking_ms"], struct.pack("<I", 0)))
+
+    # ---- the data ---------------------------------------------------------------------------------------------------
+    def _clear(self) -> None:
+        self.data, self.base, self.segs, self.serial_done = bytearray(), 0, [], 0
+        self.produced, self.sent, self.first_sample, self.gap_next = 0, 0, 0, False
+
+    def _pack(self, first: int, n: int) -> bytes:
+        """Samples first .. first+n-1 of the counter in the layout (w bits each, little endian, low samples first)."""
+        w = self.width
+        if w >= 8:
+            per = w // 8
+            mask = (1 << w) - 1
+            return b"".join(((first + i) & mask).to_bytes(per, "little") for i in range(n))
+        out = bytearray((n * w + 7) // 8)
+        mask = (1 << w) - 1
+        for i in range(n):
+            bit = i * w
+            out[bit >> 3] |= ((first + i) & mask) << (bit & 7)
+        return bytes(out)
+
+    def _trigger_at(self) -> int:
+        """The first sample, at or after the pretrigger, where the trigger holds (the counter's bit `role`)."""
+        kind, role, value = self.trigger
+        period = 1 << (role + 1)
+        i = self.pretrigger
+        while True:                                                # within two periods of the channel
+            now, before = (i >> role) & 1, ((i - 1) >> role) & 1 if i else None
+            if kind == TRIGGER["level"] and now == (value & 1):
+                return i
+            if kind == TRIGGER["edge"] and before is not None and now != before:
+                if value == 2 or (value == 0 and now == 1) or (value == 1 and now == 0):
+                    return i
+            i += 1
+            if i > self.pretrigger + 2 * period + 1:
+                return self.pretrigger
+
+    def _segment(self, n: int, now_ms: int, trigger_index: int = NONE, flags: int = 0) -> Segment:
+        if self.gap_next:
+            flags, self.gap_next = flags | FLAG["gap"], False
+        seg = Segment(self.serial_done, self.base + len(self.data), n, now_ms * 1000, trigger_index,
+                      flags | (FLAG["slipped"] if self.slipped else 0))
+        self.data += self._pack(self.first_sample + self.produced, n)
+        self.produced += n
+        self.segs.append(seg)
+        self.serial_done += 1
+        return seg
+
+    # ---- the operations ---------------------------------------------------------------------------------------------
+    def start(self, now_ms: int) -> list[bytes]:
+        """-> the events it raises (kind(u8) payload), for the endpoint to send when subscribed."""
+        if self.state == STATE["unconfigured"]:
+            raise Reject(m.UNAVAILABLE)
+        self._clear()
+        self.started_ms = now_ms
+        events = []
+        if self.mode == MODE["one_shot"]:
+            index = self._trigger_at() if self.trigger else NONE
+            if self.trigger:
+                events.append(bytes([EVENT["triggered"]]) + struct.pack("<II", 0, index))
+            seg = self._segment(self.samples, now_ms, index)
+            self.state = STATE["done"]
+            events += [bytes([EVENT["segment"]]) + seg.pack(), bytes([EVENT["stopped"], STOPPED["complete"]])]
+        else:
+            self.state = STATE["capturing"]
+        return events
+
+    def tick(self, now_ms: int) -> list[bytes]:
+        """Time passes: repeat's segments, streaming's bytes. -> events."""
+        if self.state != STATE["capturing"]:
+            return []
+        due = int((now_ms - self.started_ms) * self.rate / 1000)   # samples the clock has taken since start
+        events = []
+        if self.mode == MODE["repeat"]:
+            while due - self.produced >= self.samples:
+                if len(self.segs) >= self.segments_max:            # no free segment: the capture stops
+                    self.state = STATE["paused"]
+                    events.append(bytes([EVENT["stopped"], STOPPED["no_free_segment"]]))
+                    break
+                seg = self._segment(self.samples, now_ms)
+                events.append(bytes([EVENT["segment"]]) + seg.pack())
+        elif self.mode == MODE["streaming"]:
+            per_byte = 8 // self.width if self.width < 8 else 1       # whole bytes only
+            n = (due - self.produced) // per_byte * per_byte
+            if n > 0:
+                self.data += self._pack(self.first_sample + self.produced, min(n, MAX_SAMPLES))
+                self.produced += min(n, MAX_SAMPLES)
+        return events
+
+    def stop(self) -> list[bytes]:
+        if self.state not in (STATE["capturing"], STATE["waiting"], STATE["paused"]):
+            return []
+        self.state = STATE["done"]
+        return [bytes([EVENT["stopped"], STOPPED["host"]])]
+
+    def status(self) -> bytes:
+        return struct.pack("<BIQB", self.state, self.serial_done, self.base + len(self.data), 0)
+
+    def read(self, position: int, most: int, budget: int) -> bytes:
+        flags = 0
+        if position < self.base:
+            position, flags = self.base, flags | 0x02              # re-used: from what is kept (gap)
+        end = self.base + len(self.data)
+        take = max(0, min(most, self.max_read, budget - 9, end - position))
+        data = bytes(self.data[position - self.base:position - self.base + take])
+        if position + take < end:
+            flags |= 0x01                                          # more
+        return struct.pack("<QB", position, flags) + data
+
+    def segment_list(self, first: int, budget: int) -> bytes:
+        out = [s.pack() for s in self.segs if s.serial >= first]
+        out = out[:max(0, (budget - 1) // SEGMENT.size)][:255]
+        return bytes([len(out)]) + b"".join(out)
+
+    def release(self, serial: int, now_ms: int) -> None:
+        if self.mode != MODE["repeat"]:
+            return                                                 # one-shot: the next start clears; streaming: pushed
+        keep = [s for s in self.segs if s.serial > serial]
+        drop_to = keep[0].position if keep else self.base + len(self.data)
+        del self.data[:drop_to - self.base]
+        self.base = drop_to
+        self.segs = keep
+        if self.state == STATE["paused"]:                          # it goes on from now; the gap shows (flags bit0)
+            self.state, self.gap_next = STATE["capturing"], True
+            self.started_ms = now_ms - int(self.produced * 1000 / self.rate)
+
+    def pushes(self, fn: int, next_seq, budget: int) -> list[bytes]:
+        """Streaming: the bytes not pushed yet, as data frames (position(u64) then data, common §1.5)."""
+        if self.mode != MODE["streaming"]:
+            return []
+        out = []
+        end = self.base + len(self.data)
+        while self.sent < end:
+            n = min(end - self.sent, budget - 13)
+            chunk = bytes(self.data[self.sent - self.base:self.sent - self.base + n])
+            out.append(bytes([m.ROLE_DATA]) + struct.pack("<HHQ", fn, next_seq(), self.sent) + chunk)
+            self.sent += n
+        del self.data[:self.sent - self.base]                      # pushed: the probe re-uses it
+        self.base = self.sent
+        return out

{oep_client_python-0.0.8 → oep_client_python-0.0.9}/src/oep_client/fake_serial.py

@@ -91,6 +91,8 @@ class FakeSerialPort:
     def tick(self) -> None:
         self._gap(self.ep.now())
         self.ep.tick()
+        for f in self.ep.pushes():                   # events and data the probe sends by itself (core §11)
+            self.frames.append(cobs.frame(f))
 
     def output(self, room: int = 4096) -> bytes:
         """What the probe sends now: waiting answers first, then raw bytes by the bind (up to `room` in all)."""

{oep_client_python-0.0.8 → oep_client_python-0.0.9}/src/oep_client/fake_serve.py

@@ -12,7 +12,7 @@ The first line on stdout says where to open: `PTY /dev/pts/N` or `PORT n`. The p
 (so a test's child never stays behind), or with --once when the first TCP connection closes.
 
 Options:
-  --profile NAME        p4-x035 (default), esp32-v003 or p4-bench (p4_x035 style names work too)
+  --profile NAME        p4-x035 (default), esp32-v003, p4-bench or rp2350-pins (p4_x035 style names work too)
   --port-index N        which serial port of the profile the pty / cobs TCP is (default: the first one)
   --noise TEXT          raw bytes written in front of every answer (the host must skip them)
   --drop N              the N-th answer (1-based) is not sent, once (the request did run: a resend gets the
@@ -25,6 +25,7 @@ Options:
   --bind MODE           bind the serial port to every --slot: last-reset, manual or mixed
   --target-id HEX       the target_id every target's attach reports (wch_dmi_7f)
   --absent N            the N-th pin pair of the first wire has no target (repeatable)
+  --capture-slipped     every oep.fixture.capture segment says flags bit2 (slipped: a pace that fell behind)
   --uart-plan           the first oep.fixture.uart gets its RX / TX plan at boot, as if saved (the jig's "DUT TX" /
                         "DUT RX" labels when the profile has them, else the first free channels); configure then works
   --uart-rx TEXT        what arrives on that UART's RX every --every ms once it is configured (%d = a counter)
@@ -70,6 +71,7 @@ def build(a: argparse.Namespace) -> endpoint.Endpoint:
         hook = _load_hook(a.run_hook)
         for tg in ep.targets.values():
             tg.run_hook = (lambda t: lambda pc, regs: hook(t, pc, regs))(tg)
+    ep.capture_slipped = getattr(a, "capture_slipped", False)
     for n in a.absent:
         ep.targets[(wire, ep.pairs[wire][n])].present = False
     items = []
@@ -294,6 +296,10 @@ def _serve_conn(a, ep, console, conn, watch_stdin) -> bool:
                 conn.setblocking(False)
         else:
             ep.tick()
+            for f in ep.pushes():                                  # events and data pushes (core §11)
+                conn.setblocking(True)
+                conn.sendall(struct.pack("<H", len(f)) + f)
+                conn.setblocking(False)
 
 
 def main(argv: list[str] | None = None) -> None:
@@ -317,6 +323,7 @@ def main(argv: list[str] | None = None) -> None:
     ap.add_argument("--uart-rx")
     ap.add_argument("--run-hook")
     ap.add_argument("--once", action="store_true")
+    ap.add_argument("--capture-slipped", action="store_true")
     a = ap.parse_args(argv)
     if a.tcp is None and a.framing == "length":
         ap.error("--framing length is for --tcp")

oep_client_python-0.0.9/tests/test_fake_capture.py

@@ -0,0 +1,182 @@
+"""oep.fixture.capture in the fake probe, through oep_client.capture (oep-if-capture): the counter waveform, the layouts,
+triggers, repeat's ring and release, streaming pushes."""
+
+import struct
+
+import pytest
+
+from oep_client import capture as c, core, endpoint, fake, fake_capture, host as h, message as m
+
+
+class Clock:
+    t = 0
+
+    def __call__(self):
+        return self.t
+
+
+def bench(profile=fake.p4_x035):
+    clock = Clock()
+    ep = endpoint.Endpoint(profile(), clock)
+    hst = h.Host(lambda b: ep.handle(b, 0))
+    hst.open(3000)
+    lc = c.LogicCapture(hst)
+    return ep, hst, lc, clock
+
+
+def counter_ok(lc, data, samples, first=0):
+    """Channel k of sample i is bit k of the counter i."""
+    for k in range(len(lc.config.positions)):
+        assert lc.channel(data, k, samples) == [((first + i) >> k) & 1 for i in range(samples)]
+
+
+def test_one_shot_three_channels_in_four_bit_samples():
+    ep, hst, lc, _ = bench()
+    core.plan_apply(hst, [(lc.fn, 0, 20), (lc.fn, 1, 21), (lc.fn, 2, 22)])
+    cfg = lc.configure(rate=1_000_000, samples=1000)
+    assert (cfg.width, cfg.positions, cfg.samples) == (4, [0, 1, 2], 1000)
+    assert cfg.rate == 1_000_000
+    lc.start()
+    (seg,) = lc.wait()
+    assert (seg.serial, seg.samples, seg.trigger_index) == (0, 1000, None)
+    data = lc.read_segment(seg)
+    assert len(data) == 500
+    counter_ok(lc, data, 1000)
+
+
+def test_the_classic_esp32_sampler_takes_a_byte_a_sample():
+    ep, hst, lc, _ = bench(fake.esp32_v003)
+    core.plan_apply(hst, [(lc.fn, 0, 4), (lc.fn, 1, 5)])
+    cfg = lc.configure(rate=1_000_000, samples=300)
+    assert (cfg.width, cfg.positions) == (8, [0, 1])
+    lc.start()
+    (seg,) = lc.wait()
+    counter_ok(lc, lc.read_segment(seg), 300)
+
+
+def test_a_rate_is_the_source_divided_by_a_whole_number():
+    ep, hst, lc, _ = bench()
+    core.plan_apply(hst, [(lc.fn, 0, 20)])
+    assert lc.configure(rate=3_000_000, query=True).rate == c.Fraction(20_000_000, 7)   # at or under the one asked
+    assert lc.config is None                                        # query changes nothing
+
+
+@pytest.mark.parametrize("kind,role,value,index", [
+    (c.EDGE, 1, 0, 10),    # bit 1 rises at i % 4 == 2: the first at or after the pretrigger 10 is 10
+    (c.EDGE, 2, 1, 16),    # bit 2 falls at i % 8 == 0
+    (c.LEVEL, 3, 1, 10),   # bit 3 is 1 on 8..15
+])
+def test_a_trigger_is_where_the_channel_does_it(kind, role, value, index):
+    ep, hst, lc, _ = bench()
+    core.plan_apply(hst, [(lc.fn, r, 20 + r) for r in range(4)])
+    lc.configure(rate=1_000_000, samples=64, trigger=(kind, role, value), pretrigger=10)
+    lc.start()
+    (seg,) = lc.wait()
+    assert seg.trigger_index == index
+
+
+def test_slipped_segments_say_so():
+    ep, hst, lc, _ = bench()
+    ep.capture_slipped = True
+    core.plan_apply(hst, [(lc.fn, 0, 20)])
+    lc.configure(rate=1_000_000, samples=64)
+    lc.start()
+    (seg,) = lc.wait()
+    assert seg.slipped
+
+
+def test_repeat_fills_its_ring_with_the_clock_and_goes_on_after_release():
+    ep, hst, lc, clock = bench()
+    core.plan_apply(hst, [(lc.fn, 0, 20), (lc.fn, 1, 21)])
+    cfg = lc.configure(rate=1_000_000, mode=c.REPEAT, samples=1000, segments=3)
+    assert cfg.segments == 3
+    lc.start()
+    clock.t = 2                                                     # 2 ms = 2000 samples: two segments
+    assert lc.status()[1] == 2
+    clock.t = 10                                                    # the ring (3) fills and the capture stops
+    state, done, _, _ = lc.status()
+    assert (state, done) == (c.STATE["paused"], 3)
+    segs = lc.segments()
+    assert [s.serial for s in segs] == [0, 1, 2]
+    whole = b"".join(lc.read_segment(s) for s in segs)
+    counter_ok(lc, whole, 3000)                                     # segments follow on without a gap
+    lc.release(2)
+    clock.t = 11
+    (nxt,) = lc.segments(3)
+    assert nxt.flags & fake_capture.FLAG["gap"]                        # it stopped: the next segment says so
+    assert ep.captures[lc.fn].read(0, 8, 64)[8] & 0x02              # released bytes are gone (read: gap)
+
+
+def test_streaming_pushes_the_bytes_while_subscribed():
+    ep, hst, lc, clock = bench()
+    core.plan_apply(hst, [(lc.fn, 0, 20), (lc.fn, 1, 21), (lc.fn, 2, 22)])
+    lc.configure(rate=1_000_000, mode=c.STREAMING)
+    lc.subscribe()
+    lc.start()
+    clock.t = 3                                                     # 3000 samples x 4 bits = 1500 bytes
+    frames = ep.pushes()
+    assert frames and all(f[0] == m.ROLE_DATA for f in frames)
+    seqs = [struct.unpack_from("<H", f, 3)[0] for f in frames]
+    assert seqs == list(range(len(frames)))
+    data = b"".join(f[13:] for f in frames)
+    assert struct.unpack_from("<Q", frames[0], 5)[0] == 0 and len(data) == 1500
+    counter_ok(lc, data, 3000)
+    lc.stop()
+    assert lc.status()[2] == 1500
+
+
+def test_events_go_out_only_while_subscribed():
+    ep, hst, lc, _ = bench()
+    core.plan_apply(hst, [(lc.fn, 0, 20)])
+    lc.configure(rate=1_000_000, samples=64)
+    lc.start()
+    assert ep.pushes() == []
+    lc.subscribe()
+    lc.start()
+    kinds = [f[5] for f in ep.pushes()]
+    assert kinds == [c.EVENT_SEGMENT, c.EVENT_STOPPED] and ep.outbox == []
+
+
+def test_a_capture_listens_on_pins_other_interfaces_hold():
+    ep, hst, lc, _ = bench()
+    uart = core.find(hst, "oep.fixture.uart")
+    core.plan_apply(hst, [(uart, 1, 12), (uart, 2, 6)])
+    core.plan_apply(hst, [(lc.fn, 0, 12)])                          # the UART's RX, captured too
+    gpio = core.find(hst, "oep.fixture.gpio")
+    with pytest.raises(h.Rejected):
+        core.plan_apply(hst, [(gpio, 1, 12)])                       # the UART still holds it against drivers
+
+
+def test_fake_serve_streams_over_tcp_to_the_client():
+    """The whole path wireskein takes: open_host, take, plan, configure, subscribe, start, stream, stop, finish."""
+    import subprocess
+    import sys
+
+    from oep_client import link
+    proc = subprocess.Popen([sys.executable, "-m", "oep_client.fake_serve", "--tcp", "0", "--framing", "length",
+                             "--capture-slipped"],
+                            stdin=subprocess.PIPE, stdout=subprocess.PIPE, text=True)
+    try:
+        port = proc.stdout.readline().split()[1]
+        hst = link.open_host(f"tcp://127.0.0.1:{port}", timeout=2.0)
+        core.take(hst, 5000, owner="test")
+        lc = c.LogicCapture(hst)
+        core.plan_apply(hst, [(lc.fn, 0, 20), (lc.fn, 1, 21)])
+        lc.configure(rate=100_000, samples=500)                    # one-shot first
+        lc.start()
+        (seg,) = lc.wait()
+        assert seg.slipped
+        counter_ok(lc, lc.read_segment(seg), 500)
+        lc.configure(rate=100_000, mode=c.STREAMING)               # then streaming: 25 kB/s at w 2
+        lc.subscribe()
+        lc.start()
+        got = lc.stream(hst.link, nbytes=2000, seconds=3)
+        lc.stop()
+        lc.finish(hst.link, got)
+        assert got.start == 0 and not got.gaps and got.seq_lost == 0 and len(got.data) >= 2000
+        counter_ok(lc, got.data, len(got.data) * 4)
+        hst.end()
+        hst.link.close()
+    finally:
+        proc.stdin.close()
+        proc.wait(timeout=5)

{oep_client_python-0.0.8 → oep_client_python-0.0.9}/tests/test_fake_spec.py

@@ -455,12 +455,14 @@ def test_a_wire_takes_any_free_pair_the_host_names():
     assert h.raw(1, 0x02, b"\x01" + pins(1, 2)).detail == m.UNAVAILABLE    # GP1 is the live connection's
     assert h.raw(0, m.OP_PLAN_APPLY, m.tlv(0x90, struct.pack("<HBH", 4, 1, 0))).detail == m.UNAVAILABLE
     assert m.Reader(h.ok(1, 0x01, b"\x00")).take("B") == 1           # its one seat is taken: the live pair only
+    assert struct.unpack_from("<H", h.ok(1, 0x02, b"\x00"))[0] == conn   # no pins: the one live connection
     assert h.raw(1, 0x01, b"\x01" + struct.pack("<HH", 2, 3)).detail == m.UNAVAILABLE
     h.ok(1, 0x03, struct.pack("<H", conn) + m.tlv(0x01, b""))       # detach (force): the pins go back
     h.ok(0, m.OP_PLAN_APPLY, m.tlv(0x90, struct.pack("<HBH", 4, 1, 5)))
     assert h.raw(1, 0x01, b"\x01" + struct.pack("<HH", 5, 6)).detail == m.UNAVAILABLE   # GP5 is the plan's
     assert h.raw(1, 0x02, b"\x01" + pins(3, 3)).detail == m.UNAVAILABLE                 # one channel twice
     assert h.raw(1, 0x02, b"\x01" + pins(19, 3)).detail == m.UNAVAILABLE                # not offered (PSRAM CS)
+    assert h.raw(1, 0x02, b"\x01").detail == m.UNAVAILABLE          # no pins, no live connection: the host chooses
     r = h.raw(1, 0x02, b"\x01" + pins(7, 8))                        # a free pair nothing answers on
     assert r.resolution == m.COMPLETED and not r.succeeded