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

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

@@ -2,6 +2,16 @@
 
 ## 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 まで続ける）。
+
 ## 0.0.7
 - (EN) `oep dump` names the wires' reset role (role 3) and no longer lists riscv-dm's clobbers (gone: the probe puts the registers back itself, oep-if-debug §4.5).
 - (JA) `oep dump` は wire の reset の役（role 3）を名前で出し、riscv-dm の clobbers を出さなくなった（無くなった: probe が自分でレジスタを戻す、oep-if-debug §4.5）。

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: oep-client-python
-Version: 0.0.7
+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.7 → 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.7 → 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.7 → oep_client_python-0.0.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "oep-client-python"
-version = "0.0.7"
+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.7 → oep_client_python-0.0.9}/src/oep_client/__init__.py

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

{oep_client_python-0.0.7 → 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"))
@@ -254,16 +254,29 @@ class Endpoint:
         self.pairs: dict[int, list[tuple[int, int]]] = {}  # wire fn -> allowed (swdio, swclk), declared order
         self.max_connections: dict[int, int] = {}
         self.reset_channels: dict[int, set[int]] = {}     # wire fn -> channels attach_under_reset may take (role 3)
+        self.pin_roles: dict[int, dict[int, set[int]]] = {}   # wire fn -> role -> candidates (role_channels wires)
         for fn, name in self.names.items():
             if name in WIRES:
                 self.pairs[fn] = [self._group_pair(name, t) for t in self.static[fn] if t[0] == catalog.CHANNEL_GROUP]
+                roles: dict[int, set[int]] = {}
+                for t in self.static[fn]:
+                    if t[0] == catalog.ROLE_CHANNELS and t[2] in (1, 2):
+                        roles.setdefault(t[2], set()).update(
+                            catalog.bitmap_to_channels(struct.unpack_from("<H", t, 3)[0], t[5:2 + t[1]]))
+                if roles:
+                    self.pin_roles[fn] = roles
                 self.reset_channels[fn] = {
                     c for t in self.static[fn] if t[0] == catalog.ROLE_CHANNELS and t[2] == PIN_ROLE_RESET
                     for c in catalog.bitmap_to_channels(struct.unpack_from("<H", t, 3)[0], t[5:2 + t[1]])}
                 self.max_connections[fn] = next((t[2] for t in self.static[fn] if t[0] == fake.MAX_CONNECTIONS), 1)
         self.targets: dict[tuple[int, tuple[int, int]], FakeTarget] = {
             (fn, p): FakeTarget() for fn in sorted(self.pairs) for p in self.pairs[fn]}
+        for fn in sorted(self.pin_roles):                          # any pair: one target, on the first pair
+            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":
@@ -291,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()
@@ -329,6 +345,123 @@ 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]
+        if self.names[fn] == "oep.wire.swio":
+            return [(d, 0xFFFF) for d in sorted(roles.get(1, ()))]
+        return [(d, c) for d in sorted(roles.get(1, ())) for c in sorted(roles.get(2, ())) if d != c]
+
+    def _allowed_pairs(self, fn: int) -> list[tuple[int, int]]:
+        return self._role_pairs(fn) if fn in self.pin_roles else self.pairs.get(fn, [])
+
+    def _allows(self, fn: int, pair: tuple[int, int]) -> bool:
+        if fn in self.pin_roles:
+            roles = self.pin_roles[fn]
+            swio = self.names[fn] == "oep.wire.swio"
+            return pair[0] in roles.get(1, ()) and (pair[1] == 0xFFFF if swio else
+                                                    pair[1] in roles.get(2, ()) and pair[1] != pair[0])
+        return pair in self.pairs.get(fn, [])
+
+    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 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
+
+    def _target(self, fn: int, pair: tuple[int, int]) -> FakeTarget:
+        tg = self.targets.get((fn, pair))
+        if tg is None:                                             # a pair nothing is wired to
+            tg = self.targets[(fn, pair)] = FakeTarget(present=False)
+        return tg
+
     @staticmethod
     def _group_pair(name: str, t: bytes) -> tuple[int, int]:
         roles = {t[3 + 3 * i]: struct.unpack_from("<H", t, 4 + 3 * i)[0] for i in range((t[1] - 1) // 3)}
@@ -570,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")
@@ -601,13 +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)
@@ -646,17 +791,24 @@ class Endpoint:
 
     # ---- oep.wire.rvswd / swio ------------------------------------------------------------------
     def _wire(self, fn: int, op: int, t: Take) -> tuple[int, int, bytes]:
-        allowed = self.pairs.get(fn, [])
         if op == 0x01:                                             # scan: count(u8) pairs -> tried count found...
             count = t.take("B")
             pairs = [t.take("HH") for _ in range(count)]
-            t.tail()
-            if any(p not in allowed for p in pairs):
-                raise Reject(m.UNAVAILABLE)
-            pairs = pairs or allowed
+            got, _ = t.tail({0x01})
+            if 0x01 in got and (count or len(got[0x01]) != 2):
+                raise Reject(m.MALFORMED)                          # skip goes with count 0 only
+            live = [c.pair for c in self.conns.values() if c.fn == fn]
+            full = len(live) >= self.max_connections.get(fn, 1)   # every seat taken: the live pairs only
+            if any(not self._allows(fn, p) or set(p) & self._held(fn, p) or (full and p not in live) for p in pairs):
+                raise Reject(m.UNAVAILABLE)                        # not allowed, held (§8.1), or no seat to try it on
+            if not pairs:                                          # the count-0 list, from `skip` on (oep-if-debug §1)
+                skip = struct.unpack("<H", got[0x01])[0] if 0x01 in got else 0
+                pairs = [p for p in self._allowed_pairs(fn)
+                         if not set(p) & self._held(fn, p) and (not full or p in live)][skip:]
+            pairs = pairs[:255]                                    # tried is a u8
             found = []
             for p in pairs:
-                tg = self.targets[(fn, p)]
+                tg = self._target(fn, p)
                 if tg.present:                                     # a live connection's pair: read over it, no restart
                     found.append(struct.pack("<BHHI", 1, *p, tg.dmstatus()))
             return m.COMPLETED, m.SUCCESS, struct.pack("<BB", len(pairs), len(found)) + b"".join(found)
@@ -675,7 +827,7 @@ class Endpoint:
                 raise Reject(m.MALFORMED)
             idle_clock = got[0x04][0] if 0x04 in got else 0
             pair = self._pick_pair(fn, got)
-            tg = self.targets[(fn, pair)]
+            tg = self._target(fn, pair)
             speed = min(4_000_000, struct.unpack("<I", got[0x01])[0]) if 0x01 in got else 4_000_000
             cid = self._conn_at(fn, pair)
             flags = 0
@@ -729,15 +881,18 @@ class Endpoint:
         return m.REJECTED, m.UNKNOWN_OPERATION, b""
 
     def _pick_pair(self, fn: int, got: dict[int, bytes]) -> tuple[int, int]:
-        allowed = self.pairs.get(fn, [])
         if 0x03 in got:
             if len(got[0x03]) != 4:
                 raise Reject(m.MALFORMED)
             pair = struct.unpack("<HH", got[0x03])
-            if pair not in allowed:
-                raise Reject(m.UNAVAILABLE)                        # a pair this probe does not allow
+            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
-        if len(allowed) != 1:
+        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 live or len(allowed) != 1:
             raise Reject(m.UNAVAILABLE)                            # the host chooses among several
         return allowed[0]
 
@@ -779,7 +934,7 @@ class Endpoint:
 
     def _target_of(self, cid: int) -> FakeTarget:
         c = self.conns[cid]
-        return self.targets[(c.fn, c.pair)]
+        return self._target(c.fn, c.pair)
 
     # ---- oep.target.riscv-dm --------------------------------------------------------------------
     @staticmethod
@@ -1181,7 +1336,7 @@ class Endpoint:
         places = [(s.wire_fn, s.pair) for s in slots.values()]
         if len(set(places)) != len(places):
             raise Reject(m.UNAVAILABLE)
-        for fn in self.pairs:
+        for fn in self.pairs:                                      # every wire (pin_roles wires have an empty list)
             if sum(1 for s in slots.values() if s.wire_fn == fn and s.attach == SLOT_ATTACH["at_boot"]) > \
                     self.max_connections.get(fn, 1):
                 raise Reject(m.UNAVAILABLE)
@@ -1244,7 +1399,7 @@ class Endpoint:
             raise Reject(m.MALFORMED)
         if not SLOT_NAME.fullmatch(name.decode("ascii", "replace")):
             raise Reject(m.MALFORMED)
-        if self.names.get(wire_fn) not in WIRES or (swdio, swclk) not in self.pairs.get(wire_fn, []):
+        if self.names.get(wire_fn) not in WIRES or not self._allows(wire_fn, (swdio, swclk)):
             raise Reject(m.UNAVAILABLE)
         if mech not in self.mechanisms:
             raise Reject(m.UNSUPPORTED)
@@ -1301,7 +1456,7 @@ class Endpoint:
         s = self.slots[n]
         rt = self.slot_rt[n]
         rt.last_try_ms = self.now()
-        tg = self.targets[(s.wire_fn, s.pair)]
+        tg = self._target(s.wire_fn, s.pair)
         cid = self._conn_at(s.wire_fn, s.pair)
         if cid is None:
             if not tg.present:
@@ -1348,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
@@ -1498,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.7 → 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"]
 
@@ -139,7 +154,8 @@ def _core(firmware: str, model: str, unit_id: bytes, channels: int, reserved: li
     return Offered(0, 0, "oep.core", (
         catalog.text(CORE_FIRMWARE, firmware), catalog.text(CORE_MODEL, model), catalog.tlv(CORE_UNIT_ID, unit_id),
         catalog.u16(CORE_CHANNELS, channels), catalog.tlv(CORE_RESERVED, struct.pack("<H", base) + bits),
-        catalog.text(CORE_PROFILE, profile)) + tuple(_label(c, n) for c, n in labels.items()) + extra)
+        ) + ((catalog.text(CORE_PROFILE, profile),) if profile else ()) + tuple(_label(c, n) for c, n in labels.items())
+        + extra)
 
 
 def p4_x035() -> FakeProbe:
@@ -164,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))),
@@ -193,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).
@@ -230,4 +250,24 @@ def p4_bench() -> FakeProbe:
     ])
 
 
-PROFILES = {"p4-x035": p4_x035, "esp32-v003": esp32_v003, "p4-bench": p4_bench}
+def rp2350_pins() -> FakeProbe:
+    """A board firmware whose wire takes its pins from the host (oep-if-debug §1, role_channels): any two of GP0-GP29
+    but GP19 (the Pro Micro RP2350's PSRAM CS) are an RVSWD pair, a reset line or fixture pins. USB CDC (serial port 0).
+    The fake target answers on (0, 1), the first pair."""
+    reserved = [19]
+    pins = [p for p in range(30) if p not in reserved]
+    return FakeProbe("rp2350-pins", 1024, [
+        _core("3.0.0", "sparkfun-promicro-rp2350", bytes.fromhex("e66138935f2b1f2c"), 30, reserved, "",
+              {}, _transports([(TRANSPORT["usb_cdc"], 0)])),
+        Offered(1, 1, "oep.wire.rvswd", _roles({1: pins, 2: pins, 3: pins}) + (
+            catalog.u32(MAX_CLOCK_HZ, 5_000_000), catalog.u8(IMPLEMENTATION, 1), catalog.u8(MAX_CONNECTIONS, 1))),
+        Offered(2, 1, "oep.target.riscv-dm", (catalog.u32(FEATURES, 0b1111), catalog.u8(IMPLEMENTATION, 1),
+                                              catalog.u16(MAX_LENGTH, 1000))),
+        Offered(3, 1, "oep.target.console", (catalog.tlv(MECHANISMS, bytes([0, 1, 2])),)),
+        Offered(4, 2, "oep.fixture.gpio", _roles({1: pins})),
+        Offered(5, 3, "oep.fixture.uart", _roles({1: pins, 2: pins}) + (
+            catalog.u32(MAX_CLOCK_HZ, 3_000_000), catalog.u8(IMPLEMENTATION, 2))),
+    ])
+
+
+PROFILES = {"p4-x035": p4_x035, "esp32-v003": esp32_v003, "p4-bench": p4_bench, "rp2350-pins": rp2350_pins}