oep-client-python 0.0.9__py3-none-any.whl → 0.0.10__py3-none-any.whl

oep_client/__init__.py

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

oep_client/capture.py

@@ -1,5 +1,9 @@
-"""oep.fixture.capture / oep.fixture.analog revision 1 (oep-spec docs/oep-if-capture.ja.md: §1 layouts, §2 segments,
-§3 operations). Numbers from `registry`.
+"""oep.fixture.capture / oep.fixture.analog / oep.fixture.capture-group revision 1 (oep-spec docs/oep-if-capture.ja.md:
+§1 layouts, §2 segments, §3 operations, §3.8 calibration, §4 groups). Numbers from `registry`.
+
+Times are the probe's one clock (ns since its boot, comparable within one boot_id): estimates with an uncertainty, the
+probe's known corrections applied. Analog values are always raw; the probe's 1st-order scale, its calibration data and
+its reference are for the host to choose from.
 
 configure: a TLV the probe cannot honour is refused (rejected unsupported, 0x0B, payload = the tag) when the host marked
 it critical, and otherwise ignored and listed in the answer's ignored TLV (0x7F, oep-core §2.3)."""
@@ -17,12 +21,17 @@ from .frames import FramingLost
 from .core import Interface, confirm
 
 _CAP = reg.FIXTURE_CAPTURE
+_ANA = reg.FIXTURE_ANALOG
+_GRP = reg.FIXTURE_CAPTURE_GROUP
 # configure TLVs; bit 7 of a tag = critical (the probe must reject what it cannot do)
 MODE, RATE, SAMPLES, SEGMENTS, TRIGGER, PRETRIGGER, FRONTEND = (
     _CAP.tlv["configure"][k] for k in ("mode", "rate", "samples", "segments", "trigger", "pretrigger", "frontend"))
-ACTUAL_RATE, LAYOUT, ACTUAL_SAMPLES, ACTUAL_SEGMENTS, TIMING, SCALE, BLOCKING = (
-    _CAP.tlv["configure_answer"][k] for k in ("actual_rate", "layout", "actual_samples", "actual_segments", "timing",
-                                              "scale", "blocking_ms"))
+ACTUAL_RATE, LAYOUT, ACTUAL_SAMPLES, ACTUAL_SEGMENTS, TIMING, SCALE, BLOCKING, SKEW, FRONTEND_USED, REFERENCE, \
+    RATE_ACCURACY = (_ANA.tlv["configure_answer"][k] for k in (
+        "actual_rate", "layout", "actual_samples", "actual_segments", "timing", "scale", "blocking_ms", "skew",
+        "frontend_used", "reference", "rate_accuracy"))
+FACTORY, VREFINT = _ANA.tlv["calibration_answer"]["factory"], _ANA.tlv["calibration_answer"]["vrefint"]
+REFERENCE_SOURCE = {v: k for k, v in _ANA.enum["reference_source"].items()}
 IGNORED = m.TAG_IGNORED
 CRITICAL = m.TAG_CRITICAL
 ONE_SHOT, REPEAT, STREAMING = (_CAP.enum["mode"][k] for k in ("one_shot", "repeat", "streaming"))
@@ -37,7 +46,8 @@ def tlvs(payload: bytes) -> list[tuple[int, bytes]]:
     return m.split_tlvs(payload)
 
 
-SEGMENT_BYTES = 29   # serial u32, position u64, samples u32, start_us u64, trigger_index u32, flags u8
+SEGMENT_BYTES = 33   # serial u32, position u64, samples u32, start_ns u64, start_uncertainty_ns u32, trigger_index u32,
+                     # flags u8
 
 
 @dataclass
@@ -45,7 +55,8 @@ class Segment:
     serial: int
     position: int
     samples: int
-    start_us: int
+    start_ns: int                    # the first sample's time on the probe's clock (an estimate)
+    start_uncertainty_ns: int        # +- of start_ns (a guide, not a promise)
     trigger_index: int | None
     flags: int
 
@@ -56,8 +67,8 @@ class Segment:
 
     @classmethod
     def unpack(cls, b: bytes) -> "Segment":
-        serial, position, samples, start_us, trig, flags = struct.unpack_from("<IQIQIB", b)
-        return cls(serial, position, samples, start_us, None if trig == 0xFFFFFFFF else trig, flags)
+        serial, position, samples, start_ns, uncertainty, trig, flags = struct.unpack_from("<IQIQIIB", b)
+        return cls(serial, position, samples, start_ns, uncertainty, None if trig == 0xFFFFFFFF else trig, flags)
 
 
 @dataclass
@@ -74,9 +85,13 @@ class Config:
     segments: int = 0
     jitter_kind: int = 0
     jitter_ns: int = 0
-    skew_ns: list[int] = field(default_factory=list)
-    zero: int = 0
-    scale_nv: int = 0
+    rate_measured: bool = False                  # rate_accuracy: the rate was measured (else computed from a divider)
+    rate_ppm: int = 0                            # its uncertainty (0: unknown)
+    skew_ns: dict[int, int] = field(default_factory=dict)      # analog, per channel (role)
+    zero: dict[int, int] = field(default_factory=dict)         # analog, per channel
+    scale_nv: dict[int, int] = field(default_factory=dict)     # analog, nV per value, per channel
+    frontend: dict[int, int] = field(default_factory=dict)     # analog: the frontend each channel took
+    reference: tuple[str, int, bool] | None = None             # analog: (source, mV, measured)
     blocking_ms: int = 0
     ignored: list[int] = field(default_factory=list)
 
@@ -140,9 +155,19 @@ def _config(payload: bytes, analog: bool) -> Config:
             c.segments = struct.unpack("<I", v)[0]
         elif tag == TIMING:
             c.jitter_kind, c.jitter_ns = v[0], struct.unpack_from("<I", v, 1)[0]
-            c.skew_ns = [struct.unpack_from("<I", v, 5 + 4 * i)[0] for i in range((len(v) - 5) // 4)]
-        elif tag == SCALE:
-            c.zero, c.scale_nv = struct.unpack("<II", v)
+        elif tag == RATE_ACCURACY:
+            c.rate_measured, c.rate_ppm = v[0] == 1, struct.unpack_from("<I", v, 1)[0]
+        elif tag == SCALE and analog:
+            role, zero, scale = struct.unpack("<BII", v)
+            c.zero[role], c.scale_nv[role] = zero, scale
+        elif tag == SKEW and analog:
+            role, ns = struct.unpack("<BI", v)
+            c.skew_ns[role] = ns
+        elif tag == FRONTEND_USED and analog:
+            c.frontend[v[0]] = v[1]
+        elif tag == REFERENCE and analog:
+            source, mv, how = struct.unpack("<BIB", v)
+            c.reference = (REFERENCE_SOURCE.get(source, str(source)), mv, how == 1)
         elif tag == BLOCKING:
             c.blocking_ms = struct.unpack("<I", v)[0]
         elif tag == IGNORED:
@@ -165,7 +190,7 @@ class LogicCapture(Interface):
 
     def configure(self, *, rate: int, mode: int = ONE_SHOT, samples: int | None = None, segments: int | None = None,
                   trigger: tuple[int, int, int] | None = None, pretrigger: int | None = None, query: bool = False,
-                  critical: set[int] = frozenset()) -> Config:
+                  critical: set[int] = frozenset(), frontends: dict[int, int] | None = None) -> Config:
         """-> the probe's actual values (Config.ignored: tags the probe ignored). `critical`: tags the probe must honour
         or reject (host.Unsupported, .tag = the one it cannot)."""
         def tlv(tag: int, value: bytes) -> bytes:
@@ -179,6 +204,8 @@ class LogicCapture(Interface):
             body += tlv(TRIGGER, struct.pack("<BBH", *trigger))
         if pretrigger is not None:
             body += tlv(PRETRIGGER, struct.pack("<I", pretrigger))
+        for role, fe in sorted((frontends or {}).items()):   # analog: the input range per channel (describe frontend)
+            body += tlv(FRONTEND, bytes([role, fe]))
         # query is its own operation: the lock is decided per operation, before the payload is looked at
         op = self.QUERY_OP if query else self.CONFIGURE
         c = _config(self._call(op, body, locked=not query).payload, self.ANALOG)
@@ -331,7 +358,8 @@ class LogicCapture(Interface):
         """The segment's bytes; every Host.on_capture callback gets them as a CaptureRecord (a run recorder, e.g.
         pytest-embedded-wireskein, without this package knowing it)."""
         c = self.config
-        data = self.read(segment.position, (segment.samples * c.width + 7) // 8)
+        n = (segment.samples * c.width + 7) // 8 if c.width else segment.samples * len(c.order) * c.slot // 8
+        data = self.read(segment.position, n)
         if self.host.on_capture:
             record = CaptureRecord(self.fn, self.name, c, segment, data, self.armed_s, time.monotonic())
             for callback in list(self.host.on_capture):
@@ -365,3 +393,105 @@ class LogicCapture(Interface):
             z.writestr("version", "2")
             z.writestr("metadata", "\n".join(meta))
             z.writestr("logic-1-1", out)
+
+
+@dataclass
+class Calibration:
+    """What the probe knows for turning an analog value into a voltage (oep-if-capture §3.8), raw: the probe applies
+    none of it. factory: (frontend or None, scheme, raw bytes) - scheme names how to read raw; vrefint: (raw, ns), the
+    internal reference measured after the last start."""
+    factory: list[tuple[int | None, str, bytes]] = field(default_factory=list)
+    vrefint: tuple[int, int] | None = None
+
+
+class AnalogCapture(LogicCapture):
+    """Basic analog capture (oep.fixture.analog): the same operations as the logic one; values are raw (§1.2)."""
+    NAME = "oep.fixture.analog"
+    ANALOG = True
+    CALIBRATION = _ANA.op["calibration"]
+
+    def values(self, data: bytes, k: int, samples: int | None = None) -> list[int]:
+        """Channel k's raw values (§1.2: slot s bits little endian, the value in bits o .. o+b-1, frames in `order`)."""
+        c = self.config
+        width = c.slot // 8
+        frame = width * len(c.order)
+        n = samples if samples is not None else len(data) // frame
+        m_ = c.order.index(k)
+        mask = (1 << c.bits) - 1
+        return [(int.from_bytes(data[i * frame + m_ * width:i * frame + (m_ + 1) * width], "little") >> c.offset) & mask
+                for i in range(n)]
+
+    def millivolts(self, k: int, value: int) -> float:
+        """The probe's own 1st-order reading of a raw value of channel k, (value - zero) x scale_nv (a nominal
+        reference: see reference and calibration() for others)."""
+        c = self.config
+        return (value - c.zero.get(k, 0)) * c.scale_nv.get(k, 0) / 1_000_000
+
+    def calibration(self) -> Calibration:
+        out = Calibration()
+        for tag, v in tlvs(self._call(self.CALIBRATION, locked=False).payload):
+            if tag == FACTORY:
+                n = v[1]
+                out.factory.append((None if v[0] == 0xFF else v[0], v[2:2 + n].decode("utf-8", "replace"), bytes(v[2 + n:])))
+            elif tag == VREFINT:
+                out.vrefint = struct.unpack("<IQ", v)
+        return out
+
+
+@dataclass
+class GroupStatus:
+    state: int
+    start_ns: int | None
+    trigger_ns: int | None
+    trigger_fn: int | None
+
+
+class CaptureGroup(Interface):
+    """oep.fixture.capture-group (§4): tracks (LogicCapture / AnalogCapture, each configured as usual) started together,
+    one of them the trigger. Each track is read as usual; a track's offset is its first segment's start_ns minus the
+    group's start_ns, and every track's segment marks the trigger's instant (trigger_index)."""
+    NAME = "oep.fixture.capture-group"
+    REVISION = 1
+    BIND, START, STOP, FORCE, STATUS = (_GRP.op[k] for k in ("bind", "start", "stop", "force", "status"))
+    TAG_TRIGGER_TRACK = _GRP.tlv["bind"]["trigger_track"]
+    EVENT_TRIGGERED, EVENT_STOPPED = _GRP.event["triggered"], _GRP.event["stopped"]
+    NO_TIME = 0xFFFFFFFFFFFFFFFF
+
+    def bind(self, tracks: list[LogicCapture], trigger: LogicCapture | None = None) -> None:
+        """Bind these (configured) tracks; [] unbinds. `trigger`: the track whose configure trigger starts them all."""
+        body = struct.pack(f"<B{len(tracks)}H", len(tracks), *(t.fn for t in tracks))
+        if trigger is not None:
+            body += m.tlv(self.TAG_TRIGGER_TRACK, struct.pack("<H", trigger.fn), critical=True)
+        self._call(self.BIND, body)
+
+    def start(self, tracks: list[LogicCapture] = ()) -> tuple[int, int]:
+        """-> (blocking_ms, the group's start_ns). `tracks`: whose armed_s to set (for records)."""
+        blocking, start_ns = m.Reader(self._call(self.START).payload).take("IQ")
+        now = time.monotonic()
+        for t in tracks:
+            t.armed_s = now
+        return blocking, start_ns
+
+    def stop(self) -> None:
+        self._call(self.STOP)
+
+    def force(self) -> None:
+        self._call(self.FORCE)
+
+    def status(self) -> GroupStatus:
+        state, start, trig, fn = m.Reader(self._call(self.STATUS, locked=False).payload).take("BQQH")
+        none = self.NO_TIME
+        return GroupStatus(state, None if start == none else start, None if trig == none else trig, fn or None)
+
+    def wait(self, timeout: float = 5.0) -> GroupStatus:
+        """Poll until every track is done (one-shot)."""
+        deadline = time.monotonic() + timeout
+        while time.monotonic() < deadline:
+            st = self.status()
+            if st.state == STATE["done"]:
+                return st
+            if st.state == STATE["error"]:
+                raise h.Failed(None, "the group's capture stopped with an error")
+            time.sleep(0.002)
+        raise TimeoutError("the group's capture did not finish")
+

oep_client/endpoint.py

@@ -276,7 +276,10 @@ class Endpoint:
             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"}
+            fn: self._capture_from(self.static[fn]) for fn, name in self.names.items()
+            if name in ("oep.fixture.capture", "oep.fixture.analog")}
+        self.groups: dict[int, fake_capture.FakeGroup] = {
+            fn: self._group_from(self.static[fn]) for fn, name in self.names.items() if name == "oep.fixture.capture-group"}
         self.mechanisms = set()
         for fn, name in self.names.items():
             if name == "oep.target.console":
@@ -349,10 +352,13 @@ class Endpoint:
     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
+        modes, widths, lo, hi, ring, most, fronts = 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"]:
+            if tag == d["frontend"]:                               # analog: frontend min_mv max_mv attenuation_mdb
+                fe, lo_mv, hi_mv, mdb = struct.unpack("<BiiI", v)
+                fronts[fe] = (lo_mv, hi_mv, mdb)
+            elif tag == d["mode"]:
                 modes.add(v[0])
             elif tag == d["channels"]:
                 widths = {1 << i for i in range(6) if v[1] >> i & 1}
@@ -364,7 +370,21 @@ class Endpoint:
                 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)
+        return fake_capture.FakeCapture(modes or {fake_capture.MODE["one_shot"]}, widths, lo, hi, ring, most, fronts)
+
+    @staticmethod
+    def _group_from(tlvs: list[bytes]) -> fake_capture.FakeGroup:
+        d = reg.FIXTURE_CAPTURE_GROUP.tlv["describe"]
+        tracks, most, budgets = [], 1, []
+        for t in tlvs:
+            tag, v = t[0], t[2:2 + t[1]]
+            if tag == d["tracks"]:
+                tracks = list(struct.unpack(f"<{len(v) // 2}H", v))
+            elif tag == d["max_tracks"]:
+                most = v[0]
+            elif tag == d["budget"]:
+                budgets.append((struct.unpack_from("<I", v)[0], list(struct.unpack_from(f"<{(len(v) - 4) // 2}H", v, 4))))
+        return fake_capture.FakeGroup(tracks, most, budgets)
 
     def _next_seq(self, fn: int) -> int:
         seq = self.push_seq.get(fn, 0)
@@ -394,12 +414,20 @@ class Endpoint:
         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))
+                rest = t.data[t.at:]
+                analog = self.names[fn] == "oep.fixture.analog"
+                known = set(fake_capture.TLV.values()) - (set() if analog else {fake_capture.TLV["frontend"]})
+                got, ignored = t.tail(known)
+                # the frontend TLV comes once per channel: read them all
+                fronts = [tuple(v[:2]) for tag, v in m.split_tlvs(rest) if tag & 0x7F == fake_capture.TLV["frontend"]] \
+                    if analog else []
+                settled = cap.settle(got, t.critical, len(roles), fronts)
                 if op == O["configure"]:
                     cap.apply(settled)
                     cap.slipped = self.capture_slipped
                 return self._answer(cap.answer(settled), ignored)
+            if op in (O["start"], O["stop"], O["force"]) and cap.group is not None:
+                raise Reject(m.UNAVAILABLE)                        # bound: the group starts and stops it
             if op == O["start"]:
                 t.tail()
                 self._events(fn, cap.start(self.now()))
@@ -426,6 +454,45 @@ class Endpoint:
                 t.tail()
                 cap.release(serial, self.now())
                 return m.COMPLETED, m.SUCCESS, b""
+            if op == fake_capture.ANA.op["calibration"] and cap.analog:
+                t.tail()
+                return m.COMPLETED, m.SUCCESS, cap.calibration()
+        except fake_capture.Reject as e:
+            raise Reject(e.reason, e.payload)
+        return m.REJECTED, m.UNKNOWN_OPERATION, b""
+
+    def _group(self, fn: int, op: int, t: Take) -> tuple[int, int, bytes]:
+        grp, O = self.groups[fn], fake_capture.GRP.op
+        try:
+            if op == O["bind"]:
+                n = t.take("B")
+                fns = [t.take("H") for _ in range(n)]
+                got, ignored = t.tail({fake_capture.GRP.tlv["bind"]["trigger_track"]})
+                src = got.get(fake_capture.GRP.tlv["bind"]["trigger_track"])
+                grp.bind(self.captures, fns, struct.unpack("<H", src)[0] if src else 0)
+                return self._answer(b"", ignored)
+            if op == O["start"]:
+                t.tail()
+                per, own = grp.start(self.captures, self.now())
+                for track, events in per:
+                    self._events(track, events)
+                self._events(fn, own)
+                return m.COMPLETED, m.SUCCESS, struct.pack("<IQ", 0, grp.start_ns)
+            if op == O["stop"]:
+                t.tail()
+                per, own = grp.stop(self.captures)
+                for track, events in per:
+                    self._events(track, events)
+                self._events(fn, own)
+                return m.COMPLETED, m.SUCCESS, b""
+            if op == O["force"]:
+                t.tail()
+                return m.COMPLETED, m.SUCCESS, b""
+            if op == O["status"]:
+                t.tail()
+                for track in grp.tracks:
+                    self._events(track, self.captures[track].tick(self.now()))
+                return m.COMPLETED, m.SUCCESS, grp.status(self.captures)
         except fake_capture.Reject as e:
             raise Reject(e.reason, e.payload)
         return m.REJECTED, m.UNKNOWN_OPERATION, b""
@@ -1655,4 +1722,5 @@ 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.fixture.capture": "capture"}
+        "oep.probe.config": "config_op", "oep.fixture.capture": "capture", "oep.fixture.analog": "capture",
+        "oep.fixture.capture-group": "group"}

oep_client/fake.py

@@ -109,6 +109,27 @@ SERIAL_KINDS = {TRANSPORT["uart_bridge"], TRANSPORT["usb_cdc"], TRANSPORT["usb_s
 NS = "io.github.ch32-riscv-ug"
 MECHANISMS = reg.TARGET_CONSOLE.tlv["describe"]["mechanisms"]
 _CAPD = reg.FIXTURE_CAPTURE.tlv["describe"]
+_ANAD = reg.FIXTURE_ANALOG.tlv["describe"]
+_GRPD = reg.FIXTURE_CAPTURE_GROUP.tlv["describe"]
+CORE_CHIP = reg.CORE.tlv["describe"]["chip"]
+
+
+def _analog_decl(frontends: list[tuple[int, int, int, int]], max_samples: int) -> tuple[bytes, ...]:
+    """oep.fixture.analog's declarations: one-shot / repeat / streaming, 4 channels in 16-bit slots, the frontends
+    (number, min_mv, max_mv, attenuation_mdb), triggers cross up / down."""
+    out = tuple(catalog.tlv(_ANAD["mode"], struct.pack("<BBII", _CAPM[k], 1, max_samples, 8 if k == "repeat" else 1))
+                for k in ("one_shot", "repeat", "streaming"))
+    out += tuple(catalog.tlv(_ANAD["frontend"], struct.pack("<BiiI", *f)) for f in frontends)
+    return out + (catalog.tlv(_ANAD["channels"], bytes([4, 0b100])),                   # s 16
+                  catalog.tlv(_ANAD["trigger"], struct.pack("<BI", 0b11001, max_samples - 1)),   # immediate, cross up / down
+                  catalog.u32(_ANAD["max_read"], 4096), catalog.u16(_ANAD["segment_ring"], 8),
+                  catalog.u32(FEATURES, 0b001))
+
+
+def _group_decl(tracks: list[int], budgets: list[tuple[int, list[int]]], skews: dict[int, int]) -> tuple[bytes, ...]:
+    return ((catalog.tlv(_GRPD["tracks"], struct.pack(f"<{len(tracks)}H", *tracks)), catalog.u8(_GRPD["max_tracks"], len(tracks)))
+            + tuple(catalog.tlv(_GRPD["budget"], struct.pack(f"<I{len(f)}H", most, *f)) for most, f in budgets)
+            + tuple(catalog.tlv(_GRPD["start_skew"], struct.pack("<HI", fn, ns)) for fn, ns in skews.items()))
 _CAPM = reg.FIXTURE_CAPTURE.enum["mode"]
 
 
@@ -168,7 +189,8 @@ def p4_x035() -> FakeProbe:
         _core("3.0.0", "esp32-p4-devkit", bytes.fromhex("30eda0e31108"), 55, reserved, f"{NS}.p4-x035",
               {2: "SWDIO", 54: "SWCLK", 51: "LED"},
               _transports([(TRANSPORT["usb_serial_jtag"], 0xFF), (TRANSPORT["vendor_bulk"], 0),
-                           (TRANSPORT["hid"], 1), (TRANSPORT["usb_cdc"], 2)]) + (catalog.u8(CORE_OEP_PID, 1),)),
+                           (TRANSPORT["hid"], 1), (TRANSPORT["usb_cdc"], 2)])
+              + (catalog.u8(CORE_OEP_PID, 1), catalog.text(CORE_CHIP, "esp32p4 v1.0"))),
         Offered(1, 1, "oep.wire.rvswd", (
             catalog.channel_group(1, [(1, 2), (2, 54)]), catalog.u32(MAX_CLOCK_HZ, 5_000_000), catalog.u8(IMPLEMENTATION, 1),
             catalog.u8(MAX_CONNECTIONS, 1))),
@@ -191,6 +213,12 @@ def p4_x035() -> FakeProbe:
         Offered(9, 7, f"{NS}.esp32.spi-target", _roles({1: pins, 2: pins, 3: pins, 4: pins}) + (
             catalog.u16(MAX_LENGTH, 64), catalog.u32(MAX_CLOCK_HZ, 3_000_000), catalog.u8(IMPLEMENTATION, 2))),
         _config(10, 8, slots_max=1),
+        # the P4's ADC1 (GPIO16-23): one ADC for all its channels, 611 Hz - 83.3 kHz in all; ESP32-style attenuations
+        Offered(11, 1, "oep.fixture.analog", _roles({k: list(range(16, 24)) for k in range(4)}) + (
+            catalog.u32(MAX_CLOCK_HZ, 83_333), catalog.u32(MIN_CLOCK_HZ, 611), catalog.u8(IMPLEMENTATION, 3))
+            + _analog_decl([(0, 0, 950, 0), (1, 0, 1250, 2500), (2, 0, 1750, 6000), (3, 0, 3100, 12000)], 65536)),
+        # the logic (fn 7) and the analog (fn 11) together; the ADC's 83.3 kHz is shared by its channels
+        Offered(12, 1, "oep.fixture.capture-group", _group_decl([7, 11], [(83_333, [11])], {11: 5000})),
     ])
 
 

oep_client/fake_capture.py

@@ -1,33 +1,47 @@
 # SPDX-License-Identifier: MIT
-"""oep.fixture.capture in the fake probe (oep-spec docs/oep-if-capture.ja.md, revision 1, logic).
+"""oep.fixture.capture / oep.fixture.analog / oep.fixture.capture-group in the fake probe (oep-spec
+docs/oep-if-capture.ja.md, revision 1).
 
-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.
+What it captures is known in advance, so a receiver can check it (sample i counted from the track's start, across
+segments):
+
+- logic: sample i is the counter i, channel k 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.
+- analog: 12-bit values in 16-bit slots (s 16, o 0, b 12), channels in role order. Channel k's period is
+  P = 64 (k // 2 + 1) samples: an even k is a square wave (4095 for the first half of the period, then 0), an odd k a sine
+  round(2047.5 + 2047 sin(2 pi i / P)). zero 0, scale_nv = the frontend's range / 4095.
+
+Time (the probe's one clock, ns): a track's first sample is at its start (the group's start, or the endpoint's clock
+at start) plus the track's start offset - logic 0 (+-50 ns), analog 5 us (+-2 us), as a probe that corrected what it
+knows and says how sure it is. Later segments follow at the actual rate.
 
 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).
+go out as data pushes while subscribed). Triggers: logic level / edge, analog cross up / down, with a pretrigger.
+`slipped` sets flags bit2 on every segment (a probe whose software pace fell behind).
 """
 
 from __future__ import annotations
 
+import math
 import struct
 from dataclasses import dataclass, field
 from fractions import Fraction
 
 from . import message as m, registry as reg
 
-CAP = reg.FIXTURE_CAPTURE
+CAP, ANA, GRP = reg.FIXTURE_CAPTURE, reg.FIXTURE_ANALOG, reg.FIXTURE_CAPTURE_GROUP
 OP = CAP.op
-TLV, ANSWER = CAP.tlv["configure"], CAP.tlv["configure_answer"]
+TLV, ANSWER = CAP.tlv["configure"], ANA.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
+CALIBRATION = ANA.tlv["calibration_answer"]
 NONE = 0xFFFFFFFF
+NO_TIME = 0xFFFFFFFFFFFFFFFF
 MAX_SAMPLES = 1 << 20                  # a fake keeps its captures in memory
-SEGMENT = struct.Struct("<IQIQIB")     # serial position samples start_us trigger_index flags (§2)
+SEGMENT = struct.Struct("<IQIQIIB")    # serial position samples start_ns start_uncertainty_ns trigger_index flags (§2)
+FULL = 4095                            # the analog value's top (12 bits)
 
 
 class Reject(Exception):
@@ -40,23 +54,35 @@ class Segment:
     serial: int
     position: int
     samples: int
-    start_us: int
+    start_ns: int
+    start_uncertainty_ns: 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)
+        return SEGMENT.pack(self.serial, self.position, self.samples, self.start_ns, self.start_uncertainty_ns,
+                            self.trigger_index, self.flags)
+
+
+def analog_value(k: int, i: int) -> int:
+    """Channel k's value at sample i of the fake analog waveform."""
+    period = 64 * (k // 2 + 1)
+    if k % 2 == 0:
+        return FULL if i % period < period // 2 else 0
+    return round(2047.5 + 2047 * math.sin(2 * math.pi * i / period))
 
 
 @dataclass
 class FakeCapture:
-    """One capture interface. `now_ms` is the endpoint's clock; `roles()` the channels the plan gives it (role order)."""
+    """One capture track (logic, or analog when `frontends` is given). Times: the endpoint's clock in ms, the probe's in
+    ns."""
     modes: set[int]                    # the modes the describe declares
-    widths: set[int]                   # the w the describe allows
+    widths: set[int]                   # logic: the w the describe allows
     min_hz: int
     max_hz: int
     ring: int = 8                      # segment_ring
     max_read: int = 4096
+    frontends: dict[int, tuple[int, int, int]] = field(default_factory=dict)   # analog: n -> (min_mv, max_mv, mdb)
     slipped: bool = False
     state: int = STATE["unconfigured"]
     mode: int = MODE["one_shot"]
@@ -65,31 +91,48 @@ class FakeCapture:
     segments_max: int = 0
     trigger: tuple[int, int, int] | None = None
     pretrigger: int = 0
-    width: int = 0
+    width: int = 0                     # logic: w; analog: the bytes of one sample (C x 2)
     channels: int = 0
-    data: bytearray = field(default_factory=bytearray)   # the stream from `base` on
-    base: int = 0                                        # the byte position data[0] is at
+    frontend_of: dict[int, int] = field(default_factory=dict)   # analog: channel -> frontend
+    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)
+    t0_ns: int = 0                     # the probe-clock time of the track's first sample
+    produced: int = 0                  # samples produced since start
     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
+    group: object | None = None        # the FakeGroup that binds it
+    vrefint_ns: int = NO_TIME
+
+    @property
+    def analog(self) -> bool:
+        return bool(self.frontends)
+
+    @property
+    def start_offset_ns(self) -> int:
+        return 5000 if self.analog else 0
+
+    @property
+    def uncertainty_ns(self) -> int:
+        return 2000 if self.analog else 50
 
     # ---- configure ------------------------------------------------------------------------------------------------
-    def settle(self, got: dict[int, bytes], critical: set[int], channels: int) -> dict:
-        """The actual values for a configure / query request (nothing changed)."""
+    def settle(self, got: dict[int, bytes], critical: set[int], channels: int, frontends: list[tuple[int, int]]) -> dict:
+        """The actual values for a configure / query request (nothing changed). `frontends`: (role, frontend) asked."""
+        if self.group is not None:
+            raise Reject(m.UNAVAILABLE)                            # bound: configure again after unbinding
         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)))
+        if not asked or not channels:
+            raise Reject(m.MALFORMED if not asked else m.UNAVAILABLE)
+        top = self.max_hz // channels if self.analog else self.max_hz   # an ADC's rate is shared by its channels
+        div = max(1, -(-self.max_hz // min(max(asked, self.min_hz), top)))
         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))
@@ -98,94 +141,154 @@ class FakeCapture:
         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):
+            allowed = (TRIGGER["cross_up"], TRIGGER["cross_down"]) if self.analog else (TRIGGER["level"], TRIGGER["edge"])
+            if (kind and kind not in allowed) 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
+        chosen = {}
+        if self.analog:
+            chosen = {k: max(self.frontends) for k in range(channels)}   # the widest range unless asked
+            for role, fe in frontends:
+                if role >= channels or fe not in self.frontends:
+                    raise Reject(m.UNAVAILABLE)
+                chosen[role] = fe
+            width = 2 * channels
+        else:
+            if frontends:
+                raise Reject(m.UNSUPPORTED, bytes([TLV["frontend"] | m.TAG_CRITICAL]))
+            width = min((w for w in self.widths if w >= channels), default=None)
+            if width is None:
+                raise Reject(m.UNAVAILABLE)                        # 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}
+                "pretrigger": min(pre, samples - 1), "width": width, "channels": channels, "frontends": chosen}
 
     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.frontend_of = s["frontends"]
         self.state = STATE["configured"]
         self._clear()
 
-    @staticmethod
-    def answer(s: dict) -> bytes:
+    def answer(self, 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"]))
+        c = s["channels"]
+        out = tlv(ANSWER["actual_rate"], struct.pack("<II", s["rate"].numerator, s["rate"].denominator))
+        if self.analog:
+            out += tlv(ANSWER["layout"], bytes([16, 0, 12, c]) + bytes(range(c)))
+        else:
+            out += tlv(ANSWER["layout"], bytes([s["width"], c]) + bytes(range(c)))
+        out += (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)))
+                + tlv(ANSWER["blocking_ms"], struct.pack("<I", 0))
+                # the logic's rate is the divider's; the ADC's is off by some per mille, as the P4's (+0.15 %)
+                + tlv(ANSWER["rate_accuracy"], struct.pack("<BI", 1, 1500) if self.analog else struct.pack("<BI", 0, 0)))
+        if self.analog:
+            step_ns = int(1e9 / (s["rate"] * c))                   # one ADC, the channels in turn
+            for k in range(c):
+                lo, hi, _ = self.frontends[s["frontends"][k]]
+                out += tlv(ANSWER["scale"], struct.pack("<BII", k, 0, (hi - lo) * 1_000_000 // FULL))
+                out += tlv(ANSWER["skew"], struct.pack("<BI", k, k * step_ns))
+                out += tlv(ANSWER["frontend_used"], bytes([k, s["frontends"][k]]))
+            out += tlv(ANSWER["reference"], struct.pack("<BIB", ANA.enum["reference_source"]["internal"], 1100, 0))
+        return out
+
+    def calibration(self) -> bytes:
+        """The analog's calibration (§3.8): a made-up two-point value per frontend, and the reference measured at start."""
+        if not self.analog:
+            raise Reject(m.UNKNOWN_OPERATION)
+        scheme = b"org.example.fake.two-point"
+        out = b""
+        for fe in sorted(self.frontends):
+            v = bytes([fe, len(scheme)]) + scheme + struct.pack("<HH", 150, 3950)   # raw at the range's 5 % / 95 %
+            out += bytes([CALIBRATION["factory"], len(v)]) + v
+        if self.vrefint_ns != NO_TIME:
+            v = struct.pack("<IQ", 1365, self.vrefint_ns)        # 1100 mV against the 3300 mV full scale
+            out += bytes([CALIBRATION["vrefint"], len(v)]) + v
+        return out
 
     # ---- 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
+        self.produced, self.sent, self.gap_next = 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 self.analog:
+            return b"".join(struct.pack(f"<{self.channels}H", *(analog_value(k, first + i) for k in range(self.channels)))
+                            for i in range(n))
+        w = self.width                                             # logic: the counter, w bits a sample
+        mask = (1 << w) - 1
         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))
+            return b"".join(((first + i) & mask).to_bytes(w // 8, "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`)."""
+    def value(self, k: int, i: int) -> int:
+        return analog_value(k, i) if self.analog else (i >> k) & 1
+
+    def trigger_at(self) -> int:
+        """The first sample, at or after the pretrigger, where the trigger holds (within a few periods)."""
         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
+        span = (1 << (role + 1)) if not self.analog else 64 * (role // 2 + 1)
+        for i in range(max(self.pretrigger, 1), self.pretrigger + 3 * span + 2):
+            now, before = self.value(role, i), self.value(role, i - 1)
             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 kind == TRIGGER["edge"] and now != before and (value == 2 or (value == 0) == (now == 1)):
+                return i
+            if kind == TRIGGER["cross_up"] and before < value <= now:
+                return i
+            if kind == TRIGGER["cross_down"] and before > value >= now:
+                return i
+        return self.pretrigger
+
+    def time_of(self, i: int) -> int:
+        """The probe-clock time of the track's sample i."""
+        return self.t0_ns + int(i * 1_000_000_000 / self.rate)
+
+    def index_at(self, t_ns: int) -> int:
+        """The track's sample nearest the probe-clock time t (NONE when outside the one-shot segment)."""
+        i = round((t_ns - self.t0_ns) * self.rate / 1_000_000_000)
+        return i if 0 <= i < self.samples else NONE
+
+    def _segment(self, n: 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)
+        seg = Segment(self.serial_done, self.base + len(self.data), n, self.time_of(self.produced), self.uncertainty_ns,
+                      trigger_index, flags | (FLAG["slipped"] if self.slipped else 0))
+        self.data += self._pack(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."""
+    def start(self, now_ms: int, group_ns: int | None = None, trigger_ns: int | None = None) -> list[bytes]:
+        """-> the events it raises (kind(u8) payload). In a group: its start and, from the trigger track, the trigger's
+        time to mark on this track."""
         if self.state == STATE["unconfigured"]:
             raise Reject(m.UNAVAILABLE)
         self._clear()
         self.started_ms = now_ms
+        self.t0_ns = (group_ns if group_ns is not None else now_ms * 1_000_000) + self.start_offset_ns
+        self.vrefint_ns = self.t0_ns if self.analog else NO_TIME
         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)
+            if trigger_ns is not None:
+                index = self.index_at(trigger_ns)
+            elif self.trigger:
+                index = self.trigger_at()
+                events.append(bytes([EVENT["triggered"]]) + struct.pack("<IIQ", 0, index, self.time_of(index)))
+            else:
+                index = NONE
+            seg = self._segment(self.samples, index)
             self.state = STATE["done"]
             events += [bytes([EVENT["segment"]]) + seg.pack(), bytes([EVENT["stopped"], STOPPED["complete"]])]
         else:
@@ -204,14 +307,14 @@ class FakeCapture:
                     self.state = STATE["paused"]
                     events.append(bytes([EVENT["stopped"], STOPPED["no_free_segment"]]))
                     break
-                seg = self._segment(self.samples, now_ms)
+                seg = self._segment(self.samples)
                 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
+            per_byte = 8 // self.width if not self.analog and self.width < 8 else 1   # whole bytes only
+            n = min((due - self.produced) // per_byte * per_byte, MAX_SAMPLES)
             if n > 0:
-                self.data += self._pack(self.first_sample + self.produced, min(n, MAX_SAMPLES))
-                self.produced += min(n, MAX_SAMPLES)
+                self.data += self._pack(self.produced, n)
+                self.produced += n
         return events
 
     def stop(self) -> list[bytes]:
@@ -265,3 +368,70 @@ class FakeCapture:
         del self.data[:self.sent - self.base]                      # pushed: the probe re-uses it
         self.base = self.sent
         return out
+
+
+@dataclass
+class FakeGroup:
+    """oep.fixture.capture-group (§4): tracks started together, one of them the trigger."""
+    tracks_allowed: list[int]          # the fns it may bind (describe tracks)
+    max_tracks: int
+    budgets: list[tuple[int, list[int]]]   # (max channel-samples / s, the fns sharing it)
+    tracks: list[int] = field(default_factory=list)
+    trigger_fn: int = 0
+    start_ns: int = NO_TIME
+    trigger_ns: int = NO_TIME
+
+    def bind(self, caps: dict[int, FakeCapture], fns: list[int], trigger_fn: int) -> None:
+        for fn in self.tracks:
+            caps[fn].group = None
+        self.tracks, self.trigger_fn, self.start_ns, self.trigger_ns = [], 0, NO_TIME, NO_TIME
+        if not fns:
+            return
+        chosen = [caps.get(fn) for fn in fns]
+        if (len(set(fns)) != len(fns) or len(fns) > self.max_tracks or any(fn not in self.tracks_allowed for fn in fns)
+                or any(c is None or c.state == STATE["unconfigured"] for c in chosen)
+                or len({c.mode for c in chosen}) != 1 or (trigger_fn and trigger_fn not in fns)
+                or any(c.trigger for fn, c in zip(fns, chosen) if fn != trigger_fn)):
+            raise Reject(m.UNAVAILABLE)
+        for most, shared in self.budgets:
+            if sum(caps[fn].channels * caps[fn].rate for fn in fns if fn in shared) > most:
+                raise Reject(m.UNAVAILABLE)
+        self.tracks, self.trigger_fn = list(fns), trigger_fn
+        for c in chosen:
+            c.group = self
+
+    def start(self, caps: dict[int, FakeCapture], now_ms: int) -> tuple[list[tuple[int, list[bytes]]], list[bytes]]:
+        """-> (each track's events, the group's events)."""
+        if not self.tracks:
+            raise Reject(m.UNAVAILABLE)
+        self.start_ns, self.trigger_ns = now_ms * 1_000_000, NO_TIME
+        per, own = [], []
+        trigger_ns = None
+        src = caps.get(self.trigger_fn)
+        if src is not None and src.trigger and src.mode == MODE["one_shot"]:
+            per.append((self.trigger_fn, src.start(now_ms, self.start_ns)))
+            trigger_ns = self.trigger_ns = src.time_of(src.segs[0].trigger_index)
+            own.append(bytes([GRP.event["triggered"]]) + struct.pack("<HQ", self.trigger_fn, trigger_ns))
+        for fn in self.tracks:
+            if fn != self.trigger_fn or trigger_ns is None:
+                per.append((fn, caps[fn].start(now_ms, self.start_ns, trigger_ns)))
+        if all(caps[fn].state == STATE["done"] for fn in self.tracks):
+            own.append(bytes([GRP.event["stopped"], STOPPED["complete"]]))
+        return per, own
+
+    def stop(self, caps: dict[int, FakeCapture]) -> tuple[list[tuple[int, list[bytes]]], list[bytes]]:
+        per = [(fn, caps[fn].stop()) for fn in self.tracks]
+        return per, [bytes([GRP.event["stopped"], STOPPED["host"]])] if any(e for _, e in per) else []
+
+    def status(self, caps: dict[int, FakeCapture]) -> bytes:
+        states = [caps[fn].state for fn in self.tracks]
+        if not states:
+            state = STATE["unconfigured"]
+        elif all(s == STATE["done"] for s in states):
+            state = STATE["done"]
+        elif any(s in (STATE["capturing"], STATE["paused"]) for s in states):
+            state = STATE["capturing"]
+        else:
+            state = STATE["configured"]
+        return struct.pack("<BQQH", state, self.start_ns, self.trigger_ns,
+                           self.trigger_fn if self.trigger_ns != NO_TIME else 0)

oep_client/registry.py

@@ -2,7 +2,7 @@
 
 from types import SimpleNamespace as _NS
 
-REGISTRY_HASH = "08b7d1656bf59269"
+REGISTRY_HASH = "27f1876a8dfdabb7"
 SCHEMA = 1
 PROTOCOL_REVISION = 1
 CONFIRM_REQUEST_MAGIC = 'OEP?'
@@ -22,7 +22,7 @@ TIMING = {"resync_quiet_ms": 0x32, "probe_frame_gap_ms": 0xC8, "host_frame_pause
 
 INTERFACES = {}
 CORE = _NS(name="oep.core", revision=1, op={"confirm": 0x01, "list": 0x02, "describe": 0x03, "plan_apply": 0x04, "plan_release": 0x05, "open": 0x10, "end": 0x11, "keepalive": 0x12, "lock_state": 0x13, "subscribe": 0x30, "unsubscribe": 0x32, "link_source": 0x40, "link_sink": 0x41}, lock_free={0x01, 0x02, 0x03, 0x10, 0x13, 0x40, 0x41},
-    closed_tail={0x40}, tlv={"plan_apply": {"role_assignment": 0x90}, "open": {"owner": 0x01}, "lock_state_answer": {"owner": 0x01}, "locked_payload": {"owner": 0x01}, "describe": {"firmware": 0x40, "model": 0x41, "unit_id": 0x42, "channels": 0x43, "reserved": 0x44, "profile": 0x45, "label": 0x46, "resets_on_open": 0x47, "transport": 0x49, "oep_pid": 0x4A, "plan_roles": 0x4B}}, event={"heartbeat": 0x01}, enum={"transport_kind": {"uart_bridge": 0x01, "usb_cdc": 0x02, "usb_serial_jtag": 0x03, "vendor_bulk": 0x04, "hid": 0x05, "tcp": 0x06}}, own={})
+    closed_tail={0x40}, tlv={"plan_apply": {"role_assignment": 0x90}, "open": {"owner": 0x01}, "lock_state_answer": {"owner": 0x01}, "locked_payload": {"owner": 0x01}, "describe": {"firmware": 0x40, "model": 0x41, "unit_id": 0x42, "channels": 0x43, "reserved": 0x44, "profile": 0x45, "label": 0x46, "resets_on_open": 0x47, "transport": 0x49, "oep_pid": 0x4A, "plan_roles": 0x4B, "chip": 0x4C}}, event={"heartbeat": 0x01}, enum={"transport_kind": {"uart_bridge": 0x01, "usb_cdc": 0x02, "usb_serial_jtag": 0x03, "vendor_bulk": 0x04, "hid": 0x05, "tcp": 0x06}}, own={})
 INTERFACES["oep.core"] = CORE
 WIRE_RVSWD = _NS(name="oep.wire.rvswd", revision=1, op={"scan": 0x01, "attach": 0x02, "detach": 0x03, "attach_under_reset": 0x04, "connections": 0x05}, lock_free={0x05},
     closed_tail={}, tlv={"describe": {"max_connections": 0x40}, "scan": {"skip": 0x01}, "detach": {"force": 0x01}, "attach": {"max_speed": 0x01, "pins": 0x03, "idle_clock": 0x04}, "attach_under_reset": {"max_speed": 0x01, "pins": 0x03, "idle_clock": 0x04}, "attach_answer": {"target_id": 0x10}}, event={}, enum={"connection_users": {"host_session": 0x01, "slot": 0x02}, "target_id_scheme": {"wch_dmi_7f": 0x01}, "attach_method": {"run": 0x00, "halt": 0x01}, "pin_role": {"swdio": 0x01, "swclk": 0x02, "reset": 0x03}, "idle_clock": {"high": 0x00, "low": 0x01}}, own={})
@@ -49,11 +49,14 @@ FIXTURE_UART = _NS(name="oep.fixture.uart", revision=1, op={"configure": 0x01, "
     closed_tail={0x02}, tlv={"configure": {"format": 0x01}, "describe": {"formats": 0x40}}, event={}, enum={"role": {"rx": 0x01, "tx": 0x02}}, own={})
 INTERFACES["oep.fixture.uart"] = FIXTURE_UART
 FIXTURE_CAPTURE = _NS(name="oep.fixture.capture", revision=1, op={"configure": 0x01, "start": 0x02, "stop": 0x03, "force": 0x04, "status": 0x05, "read": 0x06, "segments": 0x07, "release": 0x08, "query": 0x09}, lock_free={0x05, 0x06, 0x07, 0x09},
-    closed_tail={0x06}, tlv={"configure": {"mode": 0x40, "rate": 0x42, "samples": 0x43, "segments": 0x44, "trigger": 0x45, "pretrigger": 0x46, "frontend": 0x47}, "configure_answer": {"actual_rate": 0x50, "layout": 0x51, "actual_samples": 0x52, "actual_segments": 0x53, "timing": 0x54, "scale": 0x55, "blocking_ms": 0x56, "skew": 0x57}, "describe": {"mode": 0x40, "rate_range": 0x41, "rate_list": 0x42, "rate_limit": 0x43, "channels": 0x44, "trigger": 0x45, "frontend": 0x46, "max_read": 0x47, "segment_ring": 0x48, "frontend_shared": 0x49}}, event={"segment": 0x01, "stopped": 0x02, "triggered": 0x03}, enum={"mode": {"one_shot": 0x01, "repeat": 0x02, "streaming": 0x03}, "trigger": {"immediate": 0x00, "level": 0x01, "edge": 0x02, "cross_up": 0x03, "cross_down": 0x04}, "state": {"unconfigured": 0x00, "configured": 0x01, "waiting": 0x02, "capturing": 0x03, "done": 0x04, "paused": 0x05, "error": 0x06}, "stopped_reason": {"complete": 0x00, "host": 0x01, "no_free_segment": 0x02, "error": 0x03}, "segment_flag": {"gap": 0x01, "short": 0x02, "slipped": 0x04}}, own={})
+    closed_tail={0x06}, tlv={"configure": {"mode": 0x40, "rate": 0x42, "samples": 0x43, "segments": 0x44, "trigger": 0x45, "pretrigger": 0x46, "frontend": 0x47}, "configure_answer": {"actual_rate": 0x50, "layout": 0x51, "actual_samples": 0x52, "actual_segments": 0x53, "timing": 0x54, "scale": 0x55, "blocking_ms": 0x56, "rate_accuracy": 0x5A, "skew": 0x57}, "describe": {"mode": 0x40, "rate_range": 0x41, "rate_list": 0x42, "rate_limit": 0x43, "channels": 0x44, "trigger": 0x45, "frontend": 0x46, "max_read": 0x47, "segment_ring": 0x48, "frontend_shared": 0x49}}, event={"segment": 0x01, "stopped": 0x02, "triggered": 0x03}, enum={"mode": {"one_shot": 0x01, "repeat": 0x02, "streaming": 0x03}, "trigger": {"immediate": 0x00, "level": 0x01, "edge": 0x02, "cross_up": 0x03, "cross_down": 0x04}, "state": {"unconfigured": 0x00, "configured": 0x01, "waiting": 0x02, "capturing": 0x03, "done": 0x04, "paused": 0x05, "error": 0x06}, "stopped_reason": {"complete": 0x00, "host": 0x01, "no_free_segment": 0x02, "error": 0x03}, "segment_flag": {"gap": 0x01, "short": 0x02, "slipped": 0x04}}, own={})
 INTERFACES["oep.fixture.capture"] = FIXTURE_CAPTURE
-FIXTURE_ANALOG = _NS(name="oep.fixture.analog", revision=1, op={"configure": 0x01, "start": 0x02, "stop": 0x03, "force": 0x04, "status": 0x05, "read": 0x06, "segments": 0x07, "release": 0x08, "query": 0x09}, lock_free={0x05, 0x06, 0x07, 0x09},
-    closed_tail={0x06}, tlv={"configure": {"mode": 0x40, "rate": 0x42, "samples": 0x43, "segments": 0x44, "trigger": 0x45, "pretrigger": 0x46, "frontend": 0x47}, "configure_answer": {"actual_rate": 0x50, "layout": 0x51, "actual_samples": 0x52, "actual_segments": 0x53, "timing": 0x54, "scale": 0x55, "blocking_ms": 0x56, "skew": 0x57}, "describe": {"mode": 0x40, "rate_range": 0x41, "rate_list": 0x42, "rate_limit": 0x43, "channels": 0x44, "trigger": 0x45, "frontend": 0x46, "max_read": 0x47, "segment_ring": 0x48, "frontend_shared": 0x49}}, event={"segment": 0x01, "stopped": 0x02, "triggered": 0x03}, enum={"mode": {"one_shot": 0x01, "repeat": 0x02, "streaming": 0x03}, "trigger": {"immediate": 0x00, "level": 0x01, "edge": 0x02, "cross_up": 0x03, "cross_down": 0x04}, "state": {"unconfigured": 0x00, "configured": 0x01, "waiting": 0x02, "capturing": 0x03, "done": 0x04, "paused": 0x05, "error": 0x06}, "stopped_reason": {"complete": 0x00, "host": 0x01, "no_free_segment": 0x02, "error": 0x03}, "segment_flag": {"gap": 0x01, "short": 0x02, "slipped": 0x04}}, own={})
+FIXTURE_ANALOG = _NS(name="oep.fixture.analog", revision=1, op={"configure": 0x01, "start": 0x02, "stop": 0x03, "force": 0x04, "status": 0x05, "read": 0x06, "segments": 0x07, "release": 0x08, "query": 0x09, "calibration": 0x0A}, lock_free={0x05, 0x06, 0x07, 0x09, 0x0A},
+    closed_tail={0x06}, tlv={"configure": {"mode": 0x40, "rate": 0x42, "samples": 0x43, "segments": 0x44, "trigger": 0x45, "pretrigger": 0x46, "frontend": 0x47}, "configure_answer": {"actual_rate": 0x50, "layout": 0x51, "actual_samples": 0x52, "actual_segments": 0x53, "timing": 0x54, "scale": 0x55, "blocking_ms": 0x56, "skew": 0x57, "rate_accuracy": 0x5A, "frontend_used": 0x58, "reference": 0x59}, "calibration_answer": {"factory": 0x01, "vrefint": 0x02}, "describe": {"mode": 0x40, "rate_range": 0x41, "rate_list": 0x42, "rate_limit": 0x43, "channels": 0x44, "trigger": 0x45, "frontend": 0x46, "max_read": 0x47, "segment_ring": 0x48, "frontend_shared": 0x49}}, event={"segment": 0x01, "stopped": 0x02, "triggered": 0x03}, enum={"mode": {"one_shot": 0x01, "repeat": 0x02, "streaming": 0x03}, "trigger": {"immediate": 0x00, "level": 0x01, "edge": 0x02, "cross_up": 0x03, "cross_down": 0x04}, "reference_source": {"supply": 0x00, "internal": 0x01, "external": 0x02}, "state": {"unconfigured": 0x00, "configured": 0x01, "waiting": 0x02, "capturing": 0x03, "done": 0x04, "paused": 0x05, "error": 0x06}, "stopped_reason": {"complete": 0x00, "host": 0x01, "no_free_segment": 0x02, "error": 0x03}, "segment_flag": {"gap": 0x01, "short": 0x02, "slipped": 0x04}}, own={})
 INTERFACES["oep.fixture.analog"] = FIXTURE_ANALOG
+FIXTURE_CAPTURE_GROUP = _NS(name="oep.fixture.capture-group", revision=1, op={"bind": 0x01, "start": 0x02, "stop": 0x03, "force": 0x04, "status": 0x05}, lock_free={0x05},
+    closed_tail={}, tlv={"bind": {"trigger_track": 0x01}, "describe": {"tracks": 0x40, "max_tracks": 0x41, "budget": 0x42, "start_skew": 0x43}}, event={"triggered": 0x01, "stopped": 0x02}, enum={}, own={})
+INTERFACES["oep.fixture.capture-group"] = FIXTURE_CAPTURE_GROUP
 PROBE_CONFIG = _NS(name="oep.probe.config", revision=1, op={"get": 0x01, "set": 0x02, "save": 0x03, "erase": 0x04}, lock_free={0x01},
     closed_tail={}, tlv={"item": {"plan": 0x01, "label": 0x02, "idle": 0x03, "slot": 0x04, "bind": 0x05}, "describe": {"storage": 0x40, "items": 0x41, "slots_max": 0x42, "bind_modes": 0x43, "slot_state": 0x44, "bind_state": 0x45}}, event={}, enum={"idle_mode": {"hi_z": 0x00, "pull_up": 0x01, "pull_down": 0x02}, "slot_attach": {"host": 0x00, "at_boot": 0x01}, "slot_state": {"connected": 0x00, "absent": 0x01, "lock_mismatch": 0x02, "no_target_id": 0x03}, "bind_mode": {"last_reset": 0x00, "manual": 0x01, "mixed": 0x02}, "bind_stream": {"slot_console": 0x01, "fixture_uart": 0x02}, "bind_flow": {"idle": 0x00, "streaming": 0x01, "held": 0x02}, "storage_state": {"none": 0x00, "applied": 0x01, "unreadable": 0x02}}, own={})
 INTERFACES["oep.probe.config"] = PROBE_CONFIG

{oep_client_python-0.0.9.dist-info → oep_client_python-0.0.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: oep-client-python
-Version: 0.0.9
+Version: 0.0.10
 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
@@ -115,7 +115,11 @@ resumed after it).
 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.
+sampler, one-shot only). A capture only listens, so it may be planned on pins other interfaces hold. `p4-x035` also has
+`oep.fixture.analog` (4 channels of the P4's ADC1 on GPIO16-23: an even channel k a square wave, an odd one a sine, of
+period 64 (k // 2 + 1) samples, 12-bit values in 16-bit slots; ESP32-style frontends; a made-up two-point calibration and a
+Vrefint) and `oep.fixture.capture-group` binding the logic and the analog: started together, the analog 5 us later
+(+-2 us), the trigger of one marked on both. Times are ns on the probe's one clock.
 
 Other programs' tests run `fake_serve` as a child process:
 

{oep_client_python-0.0.9.dist-info → oep_client_python-0.0.10.dist-info}/RECORD

@@ -1,7 +1,7 @@
-oep_client/__init__.py,sha256=lMaMtVlHAJo6QrVhc8eg4Rho6TvB_sVCUg-_MvgWC0s,163
+oep_client/__init__.py,sha256=W4Jmi9TS_xd7VSEtxOeaXMp33zr8gXCFqH9a0VwBDy0,164
 oep_client/__main__.py,sha256=qtVGdpAHULBtLY2SedabJf-uwDZZhMf_YmrbqRzM57U,14669
 oep_client/arm.py,sha256=JLyUhLSPcmsk73schZcaJYoOKuHzrvnU8kPmfrEvVuo,12331
-oep_client/capture.py,sha256=hs8mQU1gE1P67GOivxw2C2Ur8wimWqCdhtk1nqGN71Q,18092
+oep_client/capture.py,sha256=mL_C2_5hK9D9nR_F4f4YNN-uaRVegMN-8vnwHR7rQkg,24962
 oep_client/catalog.py,sha256=EqAQnSgHFxGbCO2GQ_Ee-uheJKbBBUUpL1-0qHfNMXU,6574
 oep_client/ch32_flash.py,sha256=Fc-6jEj15cQtMSKmfC5dmDetMXJ8hAdAuJ9d9odwrsA,12651
 oep_client/cobs.py,sha256=hqddQI_X7rsBvBvcP_MBE3bXPyB13-Azjqp_9JfdQ1g,2288
@@ -10,10 +10,10 @@ oep_client/console.py,sha256=YYcuc9Qxe3kihla8wynYbDaLVr7wBLEvswrM-cMK3Tk,6859
 oep_client/core.py,sha256=Cyyaknjipkg6tS76dZe5GMqjmOoQjlfeP0WFtMHkJNs,10403
 oep_client/decode.py,sha256=M-bRARrA2qGZLoJn0BdXeTb4WjL_2Hb2nk_g1IGXIw4,2382
 oep_client/dump.py,sha256=GAnmu2abuDmGmbWcbbEfC3EUuPp5Hady9vQVNcQ-724,6743
-oep_client/endpoint.py,sha256=Qp3oXoQ1K6WBzh7oEzeE72QD3I45oeZC0mgpHPQrPFY,83625
+oep_client/endpoint.py,sha256=aa9znMaedjEnMDNcGsV-4gxTZJSd6IxNyPpcJM2PEzk,87244
 oep_client/esp32_targets.py,sha256=b8tNH-nb2KC-XgNfWg5l3TO0cyhZOF-gJajaVxNVSGQ,4988
-oep_client/fake.py,sha256=SXTQSySxTDWAmUBGMb3jEuaH-O23aT-42NzrwMWBgjw,15846
-oep_client/fake_capture.py,sha256=ZgRZm83ViJir5BD8s4nfG-6uc_UPoOuJuuh54vvQuAo,13789
+oep_client/fake.py,sha256=jTaiii8DtByI_CyUYVRoUnGT05k5OdIerSdQig4HKrk,18096
+oep_client/fake_capture.py,sha256=6BadaybnZ0jRDfxjnkLXttw65rkoPgsIY5FvAWKxMg8,22812
 oep_client/fake_serial.py,sha256=nXpbBuPl9sAh5BdoWSsa5EDYvPC7VLOvaBYrslGlniA,4659
 oep_client/fake_serve.py,sha256=CzJ_TO_gWVNPP0r5ggQ57rgwAgBapunGI0YtyW8MrRM,15133
 oep_client/fixture.py,sha256=653hCD-Iz0Lfs8dT4Hdg3QyubbbOGs1_xjq_3nb8foU,5564
@@ -24,14 +24,14 @@ oep_client/interfaces.py,sha256=TNvof5blyLjO1Mc0OentKcMVBD_5e4riRG18UgEh2ZE,5380
 oep_client/link.py,sha256=J9VtBWfTgNoIgUQuj8SsH9hHesQM2uEN545IoxKVS8E,19406
 oep_client/message.py,sha256=MEM1UT6KFM7AsT56jvBLt_FJK_6SJ7O_nGAiipW0_zo,9912
 oep_client/names.py,sha256=ztCZFWs__aR-a5G14TnJP-Q4YfLhbyrzvOVOMJuG93k,3653
-oep_client/registry.py,sha256=6FVVEs1b6krGygH21zma84mmMB_B65dh8S7PrjYrME0,10056
+oep_client/registry.py,sha256=g6TfTWVPer9M46we6qSjMZqnqDbL6A49rdxM0v67Hx0,10758
 oep_client/riscv.py,sha256=H9kE_oUsnaBzqdTXDAVgDQkDvsrn5ZwsVi8dF1W_BDM,23117
 oep_client/rp2350.py,sha256=7OMyj270k3AY1e3-ljicPwOjf9jOlokbT6QNkA0b0yY,4227
 oep_client/target.py,sha256=R8BvYfFfYNhZF0MysJkNb8b69YgBlmeGXNX8ReZIe5k,1068
 oep_client/uiapduino.py,sha256=IEPG3LbZPksi8g3wmAf6T0CRWSfYKW1_qrH_GBVQdxY,6090
 oep_client/usb_stream.py,sha256=VJMCxsOlQCk005FcS92pqTh33fRSFBizoL__L0VbUMA,10242
-oep_client_python-0.0.9.dist-info/METADATA,sha256=VFcyTZyeXECe3xA8I1CRUnJwog_iXVZQIFM9QHHgcH0,8128
-oep_client_python-0.0.9.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-oep_client_python-0.0.9.dist-info/entry_points.txt,sha256=h6_8QX89Ww1ogALEGG5g4kspT3IOV6O51lwKqf5BWco,49
-oep_client_python-0.0.9.dist-info/licenses/LICENSE,sha256=ntlalztb3L1OaNAxmQdHlubu5fVhjMc9oRZi3PeQhXg,1076
-oep_client_python-0.0.9.dist-info/RECORD,,
+oep_client_python-0.0.10.dist-info/METADATA,sha256=K29Cy_nfBC_19RrkZ_hZQtD9nzLoW1oTWw9rinSp8Hc,8590
+oep_client_python-0.0.10.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+oep_client_python-0.0.10.dist-info/entry_points.txt,sha256=h6_8QX89Ww1ogALEGG5g4kspT3IOV6O51lwKqf5BWco,49
+oep_client_python-0.0.10.dist-info/licenses/LICENSE,sha256=ntlalztb3L1OaNAxmQdHlubu5fVhjMc9oRZi3PeQhXg,1076
+oep_client_python-0.0.10.dist-info/RECORD,,