oep-client-python 0.0.25__py3-none-any.whl → 0.0.26__py3-none-any.whl

oep_client/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.0.25"
+__version__ = "0.0.26"

oep_client/__main__.py

@@ -36,6 +36,7 @@ def main(argv=None) -> int:
     sp.add_argument("--baud", type=int, default=link.BASE_BAUD, help="the boot speed (default 115200)")
     sp.add_argument("--verify-bytes", type=int, default=32768)
     sp.add_argument("--verify-s", type=float, default=1.0)
+    sp.add_argument("--duplex-s", type=float, default=1.0, help="both ways at once for this long (default 1)")
     sp.add_argument("--json", action="store_true")
     d = sub.add_parser("dump", help="list and describe every interface a probe offers")
     src = d.add_mutually_exclusive_group(required=True)
@@ -69,7 +70,8 @@ def _speed(args) -> int:
     hst = link.open_host(args.probe, baud=args.baud)
     try:
         core.take(hst, 5000, owner="oep speed")
-        report = link.raise_speed(hst, rates, verify_bytes=args.verify_bytes, verify_s=args.verify_s)
+        report = link.raise_speed(hst, rates, verify_bytes=args.verify_bytes, verify_s=args.verify_s,
+                                   duplex_s=args.duplex_s)
         if args.json:
             sys.stdout.write(json.dumps(dataclasses.asdict(report), indent=2) + "\n")
         else:

oep_client/arm.py

@@ -37,7 +37,7 @@ class SwdWire(WireBase):
         body = bytes([0]) + self._speed_tlv(self._speed_or_default(max_speed)) + self._pins_tlv(pins) + self._reset_tlv(reset)
         if targetsel is not None:
             body += m.tlv(self.TAG_TARGETSEL, struct.pack("<I", targetsel), critical=True)
-        rd = m.Reader(self._call(self.ATTACH, body).payload)
+        rd = m.Reader(self._call(self.ATTACH, body, expect_ms=reset[1] if reset else 0).payload)
         conn, dpidr, self.flags, self.speed_hz = rd.take("HIBI")
         self.existing = bool(self.flags & self.FLAGS["existing"])
         rd.tail()

oep_client/capture.py

@@ -335,7 +335,7 @@ class LogicCapture(Interface):
 
     def start(self) -> int:
         """-> blocking_ms (0: the probe keeps answering while it captures). self.generation: the new capture's."""
-        rd = m.Reader(self._call(self.START).payload)
+        rd = m.Reader(self._call(self.START, expect_ms=self.config.blocking_ms if self.config else 0).payload)
         blocking, self.generation = rd.take("II")
         rd.tail()
         self.armed_s = time.monotonic()
@@ -576,7 +576,8 @@ class CaptureGroup(Interface):
     def start(self, tracks: list[LogicCapture] = ()) -> tuple[int, int]:
         """-> (blocking_ms, the group's start_ns). `tracks`: whose armed_s and generation to set (the answer's TLV
         generations names each track's new generation; self.generations keeps them by fn)."""
-        rd = m.Reader(self._call(self.START).payload)
+        rd = m.Reader(self._call(self.START, expect_ms=max([t.config.blocking_ms for t in tracks if t.config] or [0]))
+                      .payload)
         blocking, start_ns = rd.take("IQ")
         gens = rd.tail().get(GROUP_GENERATIONS) or b""
         self.generations = {fn: g for fn, g in struct.iter_unpack("<HI", gens[:len(gens) // 6 * 6])}

oep_client/config.py

@@ -292,6 +292,8 @@ class State:
     binds: list[BindState] = field(default_factory=list)
 
 
+SAVE_EXPECT_MS = 2000   # a save writes the probe's flash: the link waits at least this (Host.expecting)
+
 class ProbeConfig(Interface):
     NAME = "oep.probe.config"
     REVISION = 1
@@ -346,7 +348,7 @@ class ProbeConfig(Interface):
 
     def save(self) -> int:
         """Save the current settings (a probe with storage; the whole is replaced). -> the hash saved."""
-        return self._hash_answer(self._call(self.SAVE))
+        return self._hash_answer(self._call(self.SAVE, expect_ms=SAVE_EXPECT_MS))
 
     def erase(self) -> None:
         self._call(self.ERASE)

oep_client/core.py

@@ -4,6 +4,8 @@ entry, and calls that raise unless they worked)."""
 
 from __future__ import annotations
 
+import contextlib
+
 import struct
 
 from . import catalog, host as h, message as m, registry as reg
@@ -196,12 +198,20 @@ class Interface:
                 raise UnsupportedRevision(f"{self.name} (fn {self.fn}) is revision {rev} on this probe; this client "
                                           f"speaks revision {self.REVISION} only")
 
-    def _call(self, op: int, body: bytes = b"", *, locked: bool = True) -> m.Result:
-        return self.host.call(self.fn, op, self.prefix + body, locked=locked)
+    def _expecting(self, ms: int):
+        """Host.expecting(ms) when the host has it (a stand-in host may not)."""
+        expecting = getattr(self.host, "expecting", None) if ms else None
+        return expecting(ms) if expecting else contextlib.nullcontext()
+
+    def _call(self, op: int, body: bytes = b"", *, locked: bool = True, expect_ms: int = 0) -> m.Result:
+        with self._expecting(expect_ms):
+            return self.host.call(self.fn, op, self.prefix + body, locked=locked)
 
-    def _request(self, op: int, body: bytes = b"", *, locked: bool = True) -> m.Result:
-        """Rejections raise; completed results of any outcome come back for the caller to decode."""
-        return self.host.request(self.fn, op, self.prefix + body, locked=locked)
+    def _request(self, op: int, body: bytes = b"", *, locked: bool = True, expect_ms: int = 0) -> m.Result:
+        """Rejections raise; completed results of any outcome come back for the caller to decode. expect_ms: how
+        long it may take on the probe (Host.expecting)."""
+        with self._expecting(expect_ms):
+            return self.host.request(self.fn, op, self.prefix + body, locked=locked)
 
     def request(self, op: int, body: bytes = b"") -> tuple[int, int, bytes]:
         """The raw (fn, op, payload) of one operation, for Host.pipeline / pipeline_calls."""

oep_client/endpoint.py

@@ -39,7 +39,8 @@ define:
   verify_ms without a commit or at a broken candidate, a commit after idle_ms (at most port_speed_idle_max_ms, 3000;
   0 and anything longer count as that maximum) with no good frame or 3 broken
   candidates within 1 s, the session's end reverts after its answer. The line itself is modelled by `broken_rates`
-  (rate -> BrokenRate): frames at such a rate break, from a size and in the directions given (`fake_serial` applies it).
+  (rate -> BrokenRate): frames at such a rate break, from a size and in the directions given, only both ways at once
+  (`duplex`), only every Nth (`every`) (`fake_serial` applies it).
 
 Every other non-core fn gets two stand-in operations so the session rules can be exercised - FAKE ONLY, they mean
 nothing on a real probe:  0x01 write(u32) changes state, 0x02 read -> u32 needs no lock.
@@ -317,6 +318,16 @@ class BrokenRate:
     min_size: int = 0
     to_host: bool = True
     to_probe: bool = True
+    duplex: bool = False       # only while both ways carry such frames at once (a request of min_size and more comes in
+                               # while an answer of min_size and more is still unread): the request breaks (to_probe),
+                               # the unread answer breaks (to_host)
+    every: int = 1             # of the frames that would break, only every Nth does (1: all)
+    seen: int = 0              # the frames that would have broken so far (`every` counts these)
+
+    def hit(self) -> bool:
+        """One more frame that would break: True when this one does (`every`)."""
+        self.seen += 1
+        return self.seen % max(1, self.every) == 0
 
 
 PORT_SPEED_TAG = reg.CORE.tlv["describe"]["port_speed"]
@@ -1218,10 +1229,19 @@ class Endpoint:
             return self.speed_rate
         return self.port_speed_base or 115200
 
-    def breaks(self, port: int, size: int, to_host: bool) -> bool:
-        """The line model: a frame of `size` bytes on `port` at its rate now breaks (`broken_rates`)."""
+    def breaks(self, port: int, size: int, to_host: bool, duplex: bool = False) -> bool:
+        """The line model: a frame of `size` bytes on `port` at its rate now breaks (`broken_rates`). duplex: the other
+        way carries a frame of the rate's min_size or more at the same time (a BrokenRate with `duplex` breaks only
+        then)."""
+        b = self.broken_rates.get(self.port_baud(port))
+        if b is None or size < b.min_size or not (b.to_host if to_host else b.to_probe) or (b.duplex and not duplex):
+            return False
+        return b.hit()
+
+    def duplex_rate(self, port: int) -> BrokenRate | None:
+        """The rate `port` runs at now when it breaks only both ways at once (fake_serial checks the unread answers)."""
         b = self.broken_rates.get(self.port_baud(port))
-        return b is not None and size >= b.min_size and (b.to_host if to_host else b.to_probe)
+        return b if b is not None and b.duplex else None
 
     def speed_after_answer(self) -> None:
         """The answer that asked for a switch or a revert is out (at the old speed): now do it."""

oep_client/fake_serial.py

@@ -17,7 +17,8 @@ bytes to send, or None to send nothing (fault injection for tests).
 port_speed (core §3.5): every closed candidate tells the endpoint whether it was a frame (`Endpoint.speed_frame`), a
 switch or revert a request asked for happens once its answer is queued (at the old speed), and the endpoint's
 `broken_rates` break frames at the port's rate now: a candidate from the host is then not a frame, an answer or push
-goes out with a spoiled CRC. `FakeSerialStream` is the port as a pyserial-shaped stream for an in-process host, with
+goes out with a spoiled CRC (a `duplex` one only while a request of its size comes in with such an answer still
+unread: the request, or that answer, breaks). `FakeSerialStream` is the port as a pyserial-shaped stream for an in-process host, with
 the host's own `baudrate`: while it differs from the probe's, every byte either way arrives garbled.
 """
 
@@ -40,6 +41,7 @@ class FakeSerialPort:
         self.frames: list[bytes] = []                # framed answers waiting to go out
         self.answers = 0
         self.garble: Callable[[bytes, int], bytes] | None = None   # (frame, the rate it goes at) -> what arrives
+        self.spoiled: set[int] = set()               # the waiting answers a duplex BrokenRate already broke
 
     def feed(self, data: bytes) -> None:
         now = self.ep.now()
@@ -65,8 +67,10 @@ class FakeSerialPort:
         self.cand = None
         if not body:
             return                                   # 0x00 0x00: an empty frame
+        size = len(body) + 2
+        duplex = self._both_ways(size)
         try:
-            if self.ep.breaks(self.index, len(body) + 2, to_host=False):
+            if self.ep.breaks(self.index, size, to_host=False, duplex=duplex):
                 raise cobs.CorruptFrame("the line's rate breaks this frame")
             msg = cobs.unframe(body)
         except cobs.CorruptFrame:
@@ -90,6 +94,22 @@ class FakeSerialPort:
             self.frames.append(self._line(wire))
         self.ep.speed_after_answer()                 # port_speed: switch (or revert) now the answer is out
 
+    def _both_ways(self, size: int) -> bool:
+        """A request of `size` bytes came in: with a BrokenRate that breaks only both ways at once (`duplex`), whether
+        an answer of its min_size or more is still unread (both ways busy) - and then that answer breaks if the rate
+        breaks frames towards the host."""
+        b = self.ep.duplex_rate(self.index)
+        if b is None or size < b.min_size:
+            return False
+        big = [k for k, f in enumerate(self.frames) if len(f) >= b.min_size]
+        if not big:
+            return False
+        k = big[-1]                                  # the answer on the line now (the latest); never spoiled twice
+        if k not in self.spoiled and self.ep.breaks(self.index, len(self.frames[k]), to_host=True, duplex=True):
+            self.frames[k] = _spoil(self.frames[k])
+            self.spoiled.add(k)
+        return True
+
     def _gap(self, now: int) -> None:
         if self.cand is not None and now - self.last_ms >= GAP_MS:
             raw, self.cand = bytes(self.cand), None
@@ -109,9 +129,7 @@ class FakeSerialPort:
     def _line(self, wire: bytes) -> bytes:
         """A framed message as the line delivers it at the port's rate now (`Endpoint.broken_rates`, `garble`)."""
         if self.ep.breaks(self.index, len(wire), to_host=True):
-            body = bytearray(cobs.decode(wire[1:-1]))
-            body[-1] ^= 0xFF                         # the CRC's high byte
-            wire = b"\x00" + cobs.encode(bytes(body)) + b"\x00"
+            wire = _spoil(wire)
         return self.garble(wire, self.ep.port_baud(self.index)) if self.garble else wire
 
     def output(self, room: int = 4096) -> bytes:
@@ -119,6 +137,7 @@ class FakeSerialPort:
         out = bytearray()
         while self.frames and len(out) + len(self.frames[0]) <= max(room, len(self.frames[0])):
             out += self.frames.pop(0)
+            self.spoiled = {k - 1 for k in self.spoiled if k}
             if len(out) >= room:
                 return bytes(out)
         while len(out) < room:
@@ -129,6 +148,16 @@ class FakeSerialPort:
         return bytes(out)
 
 
+def _spoil(wire: bytes) -> bytes:
+    """A framed message with its CRC's high byte spoiled (a frame the line broke); bytes that are no frame as they are."""
+    try:
+        body = bytearray(cobs.decode(wire[1:-1]))
+    except cobs.CorruptFrame:
+        return wire
+    body[-1] ^= 0xFF
+    return b"\x00" + cobs.encode(bytes(body)) + b"\x00"
+
+
 def _garble(data: bytes) -> bytes:
     """Bytes sent at one rate and read at another: a different byte for every byte, 0x00s among them (so the reader
     sees broken candidates, not silence)."""

oep_client/fake_serve.py

@@ -30,9 +30,10 @@ Options:
                         "DUT RX" labels when the profile has them, else the first free channels); configure then works
   --uart-rx TEXT        what arrives on that UART's RX every --every ms once it is configured (%d = a counter)
   --no-port-speed       the profile's port_speed (core §3.5; esp32-v003 has it) off: the op is unknown_operation
-  --broken-rate SPEC    port_speed's line model: frames at RATE break (repeatable). SPEC is RATE[:MIN_SIZE][:in|out]:
-                        only frames of MIN_SIZE bytes and more on the wire (default every frame), only towards the
-                        host (in) or the probe (out) (default both). The fake cannot see the host's own rate (a pty,
+  --broken-rate SPEC    port_speed's line model: frames at RATE break (repeatable). SPEC is
+                        RATE[:MIN_SIZE][:in|out][:duplex][:everyN]: only frames of MIN_SIZE bytes and more on the wire
+                        (default every frame), only towards the host (in) or the probe (out) (default both), only
+                        while both ways carry such frames at once (duplex), only every Nth of them (everyN). The fake cannot see the host's own rate (a pty,
                         TCP): only the probe's rate decides
   --run-hook SPEC       what riscv-dm run does on every target: SPEC is module:function or path/file.py:function,
                         called as function(target, pc, regs) -> (stopped, dpc, elapsed_us). `target` is the
@@ -83,7 +84,9 @@ def build(a: argparse.Namespace) -> endpoint.Endpoint:
         rate, *rest = spec.split(":")
         size = next((int(x) for x in rest if x.isdigit()), 0)
         way = next((x for x in rest if x in ("in", "out")), None)
-        ep.broken_rates[int(rate)] = endpoint.BrokenRate(size, to_host=way != "out", to_probe=way != "in")
+        every = next((int(x[5:]) for x in rest if x.startswith("every") and x[5:].isdigit()), 1)
+        ep.broken_rates[int(rate)] = endpoint.BrokenRate(size, to_host=way != "out", to_probe=way != "in",
+                                                         duplex="duplex" in rest, every=every)
     for n in a.absent:
         ep.targets[(wire, ep.pairs[wire][n])].present = False
     items = []

oep_client/host.py

@@ -15,6 +15,7 @@ opens again (host guide §2.5).
 
 from __future__ import annotations
 
+import contextlib
 import random
 import struct
 from dataclasses import dataclass, field
@@ -194,14 +195,32 @@ class Host:
     _revisions: dict = field(default_factory=dict)   # fn -> interface revision from list
     _describes: dict = field(default_factory=dict)   # fn -> its describe TLVs (declarations: valid for one boot_id)
     _boot_id: int | None = None
+    expect_ms: int = 0                     # how long the request going out now may take on the probe (`expecting`)
+    # Called before a request takes its corr (the link's keepalive at a raised port_speed rate): what it sends first
+    # must carry the lower corr, or the probe takes the request for an old one (core §4.1)
+    before_request: Callable[[], None] | None = None
+
+    @contextlib.contextmanager
+    def expecting(self, ms: int):
+        """Requests sent inside take up to `ms` on the probe (a run's timeout_ms, a dmi list's waits, an attach's
+        hold_ms, a capture's blocking, a save; core §6.1: the probe does not count the lease meanwhile). The link waits
+        at least that and a margin for each answer - also at a raised port_speed rate, where an ordinary request waits
+        a quarter of the lease. Nested: the longest holds."""
+        saved = self.expect_ms
+        self.expect_ms = max(saved, int(ms or 0))
+        try:
+            yield
+        finally:
+            self.expect_ms = saved
 
     def next_corr(self) -> int:
         self._corr = self._corr % 0xFFFF + 1
         return self._corr
 
-    def call(self, fn: int, op: int, payload: bytes = b"", *, locked: bool = True) -> m.Result:
+    def call(self, fn: int, op: int, payload: bytes = b"", *, locked: bool = True, expect_ms: int = 0) -> m.Result:
         """request() that also raises Failed unless the probe says it worked: what every operation wants."""
-        r = self.request(fn, op, payload, locked=locked)
+        with self.expecting(expect_ms):
+            r = self.request(fn, op, payload, locked=locked)
         if not r.succeeded:
             raise Failed(r)
         return r
@@ -212,11 +231,15 @@ class Host:
         self.require_v1()
         return self.session
 
-    def request(self, fn: int, op: int, payload: bytes = b"", *, locked: bool = True) -> m.Result:
+    def request(self, fn: int, op: int, payload: bytes = b"", *, locked: bool = True, expect_ms: int = 0) -> m.Result:
         """locked=True sends the session id (role 0x81) once a session is open; lock-free requests may leave it off.
-        Rejections raise; any other answer is returned (Result.succeeded / .ran say what it was)."""
+        expect_ms: how long this request may take on the probe (`expecting`). Rejections raise; any other answer is
+        returned (Result.succeeded / .ran say what it was)."""
+        if self.before_request is not None:
+            self.before_request()
         req = m.Request(self.next_corr(), fn, op, payload, self._session_for(locked))
-        result = m.Result.unpack(self.send(req.pack()))
+        with self.expecting(expect_ms):
+            result = m.Result.unpack(self.send(req.pack()))
         if result.corr != req.corr:
             raise ProtocolError(f"result for correlation {result.corr}, expected {req.corr}")
         if result.resolution == m.REJECTED:
@@ -253,6 +276,8 @@ class Host:
         """Several requests in flight (`exchange` keeps the probe's in-flight and window limits); results in
         order, rejects NOT raised - the caller looks at each result. Without `exchange`, one at a time."""
         session = self._session_for(locked)
+        if self.before_request is not None:
+            self.before_request()
         reqs = [m.Request(self.next_corr(), fn, op, payload, session) for fn, op, payload in requests]
         packed = [r.pack() for r in reqs]
         exchange = exchange or self.exchange

oep_client/link.py

@@ -23,9 +23,12 @@ throughput of a UART bridge, oep-spec docs/uart-speed-negotiation.ja.md §3b), w
 port_speed (oep-core §3.5, optional, opt-in): `raise_speed` (or `open_host(..., port_speed=[rates])`) asks a probe that
 declares it for faster rates on the UART bridge this host opened: try a rate, switch the port, verify it with a sized
 transfer both ways (link_source / link_sink with max_frame-sized frames) that counts broken frames and measures the
-throughput, then commit it, or revert and wait the probe out and re-confirm at the boot speed. The report stays on the
+throughput, then both ways at once (the two interleaved, pipelined as the in/out passes did), then commit it, or revert and wait the probe out and re-confirm at the boot speed. The report stays on the
 link (`link.speed`). Once raised, a request whose answer never comes even after its resend sends the link back to the
-boot speed (the probe reverts by itself) and goes once more there: the link never wedges at a rate the probe left.
+boot speed (the probe reverts by itself) and goes once more there: the link never wedges at a rate the probe left;
+while raised each wait is at most a quarter of the lease, so this ends inside it. In use, STRIKE_MAX (3) broken frames
+or resends within STRIKE_WINDOW_S (5 s) step down: port_speed revert at the raised rate, the boot speed, a confirm.
+Either way the rate is not used again in that session (`link.speed.stepped_down`, `down_why`).
 The probe also goes back after port_speed_idle_max_ms (3 s) with no good frame, so while raised the link sends a
 keepalive before a request when it has been quiet for 1 s, and `keep_alive()` does the same for a caller that sits
 idle for long. A host opening a serial port retries its first confirm for that maximum and a little (4 s in all): a
@@ -63,6 +66,11 @@ IDLE_MAX_MS = reg.TIMING["port_speed_idle_max_ms"]   # a committed rate goes bac
 KEEPALIVE_S = 1.0    # raised: a keepalive once the link has been quiet this long (well inside IDLE_MAX_MS)
 OPEN_RETRY_S = IDLE_MAX_MS / 1000 + 1.0   # opening a serial port: confirm retried this long (a raised rate left over)
 OPEN_TRY_S = 0.5     # each of those confirms waits this long (at most the link's timeout)
+STRIKE_MAX, STRIKE_WINDOW_S = 3, 5.0   # raised, in use: this many broken frames / resends within the window step down
+STEP_DOWN_WAIT_S = 0.2   # the step down's revert (step 2) at the raised rate waits this long, never sent again
+RAISED_WAIT_MIN_S = 0.3  # raised, in use: each wait for an answer is a quarter of the lease, at least this
+EXPECT_MARGIN_S = 0.5    # a request that may take long on the probe (Host.expecting): waited that long and this
+LINK_ERRORS = (cobs.CorruptFrame, TimeoutError, FramingLost)
 
 
 def open_serial(port: str, baud: int = BASE_BAUD):
@@ -164,7 +172,16 @@ class SerialLink:
         self.baud = self.base_baud                 # the rate the host side runs at now
         self.speed: SpeedReport | None = None      # port_speed: the last raise_speed's report (rate in force, KB/s)
         self.speed_lost = 0                        # times a raised rate was found gone (back to the boot speed)
-        self.fallback = True                       # a raised rate that stops answering: back to the boot speed
+        self.fallback = True                       # a raised rate in use (not raise_speed's own trial): fall back
+        self.strikes: list[float] = []             # raised, in use: when frames broke / requests went again (window)
+        self.step_due = ""                         # raised, in use: why the link steps down at the next safe point
+        self.speed_port: int | None = None         # the transport index the raised rate is on (the revert names it)
+        self.unusable: dict[int, str] = {}         # rates stepped down from in this session -> why (not tried again)
+        self.unusable_session: int | None = None   # the session `unusable` belongs to
+        self.session_frame = None                  # (op, payload) -> a core request in the session, once bound
+        self.lease_s = lambda: None                # the session's lease, once bound (raised: bounds every wait)
+        self.expected_s = lambda: 0.0              # how long the request going out may take on the probe (Host.expecting)
+        self._own = 0                              # >0: the link's own short requests (confirms, keepalive, revert)
         self.corr_source = self._own_corr          # the host's correlation counter once bound (open_host)
         self.keepalive_frame = None                # raised: a keepalive request in the session, once bound (attach_host)
         self.last_tx = time.monotonic()            # when the link last wrote (raised: quiet for KEEPALIVE_S = keepalive)
@@ -192,11 +209,11 @@ class SerialLink:
 
     def _recv(self) -> bytes:
         if self.framing == "length":
-            reply = self.frames.recv(self.timeout)
+            reply = self.frames.recv(self._wait())
             if reply is None:
                 raise TimeoutError("no result from the probe")
             return reply
-        deadline = time.monotonic() + self.timeout
+        deadline = time.monotonic() + self._wait()
         while True:
             end = self._buf.find(0)
             if end >= 0:
@@ -259,6 +276,7 @@ class SerialLink:
         saved = self.timeout
         deadline = time.monotonic() + timeout
         n = 0
+        self._own += 1                             # its reads wait what it says, whatever a caller expects
         try:
             while True:
                 if self._raised():                 # a long pump at a raised rate keeps the line alive (core §3.5)
@@ -277,8 +295,9 @@ class SerialLink:
                     self.timeout = saved
                     self.resync()
                     return n
-                except cobs.CorruptFrame:
+                except cobs.CorruptFrame as e:
                     self.corrupt += 1
+                    self._strike(e)
                     continue
                 n += 1
                 if not self._route(frame):
@@ -287,6 +306,8 @@ class SerialLink:
                     return n
         finally:
             self.timeout = saved
+            self._own -= 1
+            self._step_down_if_due()
 
     def resync(self, tries: int = 3) -> None:
         """oep-core §5.1: read and discard until the input is quiet for 50 ms, then prove the link with a confirm (a read,
@@ -328,14 +349,15 @@ class SerialLink:
         self._keep_raised()
         try:
             reply = self._send(message)
-        except TimeoutError:
-            if not self._speed_fallback():
+        except LINK_ERRORS as e:
+            if not self._speed_fallback(e):
                 raise
             reply = self._send(message)            # once more at the boot speed (the probe answers a repeat from what it kept)
         if self.baud != self.base_baud and self._reverts(message, reply):
             self.set_baud(self.base_baud)          # the probe went back right after this answer (core §3.5)
             if self.speed is not None:
                 self.speed.rate, self.speed.chosen = self.base_baud, None
+        self._step_down_if_due()
         return reply
 
     @staticmethod
@@ -358,6 +380,7 @@ class SerialLink:
             except (cobs.CorruptFrame, TimeoutError, FramingLost) as e:
                 if isinstance(e, cobs.CorruptFrame):
                     self.corrupt += 1
+                self._strike(e)
                 self._recover()
                 if attempt or not self.resend or (message[0] & m.ROLE_SESSION and self.ended_blind):
                     raise
@@ -377,20 +400,24 @@ class SerialLink:
         self._keep_raised()
         replies: list[bytes] = []
         try:
-            return self._exchange_once(messages, max_inflight, window_bytes, replies)
-        except (cobs.CorruptFrame, TimeoutError, FramingLost):
+            out = self._exchange_once(messages, max_inflight, window_bytes, replies)
+        except LINK_ERRORS as e:
+            self._strike(e)
             if self.ended_blind or not self.resend:
                 raise
             self.retries += 1
             rest = messages[len(replies):]
             more: list[bytes] = []
             try:
-                return replies + self._exchange_once(rest, max_inflight, window_bytes, more)
-            except TimeoutError:
-                if not self._speed_fallback():
+                out = replies + self._exchange_once(rest, max_inflight, window_bytes, more)
+            except LINK_ERRORS as e2:
+                self._strike(e2)
+                if not self._speed_fallback(e2):
                     raise
                 rest = rest[len(more):]
-                return replies + more + self._exchange_once(rest, max_inflight, window_bytes, [])
+                out = replies + more + self._exchange_once(rest, max_inflight, window_bytes, [])
+        self._step_down_if_due()
+        return out
 
     # ---- port_speed (core §3.5) ------------------------------------------------------------------
     def set_baud(self, rate: int) -> None:
@@ -409,6 +436,7 @@ class SerialLink:
         self._write([m.Request(corr, m.CORE_FN, m.OP_CONFIRM, m.CONFIRM_REQUEST + bytes([0, 0xFF])).pack()])
         saved = self.timeout
         self.timeout = timeout
+        self._own += 1
         try:
             self._recv_for(corr)
             return True
@@ -416,6 +444,7 @@ class SerialLink:
             return False
         finally:
             self.timeout = saved
+            self._own -= 1
 
     def _confirm_within(self, wait_s: float, each_s: float) -> bool:
         """Confirms, each waiting `each_s`, until one is answered (True) or `wait_s` has passed (False)."""
@@ -449,7 +478,11 @@ class SerialLink:
         if time.monotonic() - self.last_tx < KEEPALIVE_S:
             return False
         self.last_tx = time.monotonic()            # before sending: send() asks again and must not recurse
-        self.send(self.keepalive_frame())
+        self._own += 1
+        try:
+            self.send(self.keepalive_frame())
+        finally:
+            self._own -= 1
         return True
 
     def _keep_raised(self) -> None:
@@ -459,18 +492,89 @@ class SerialLink:
         except (TimeoutError, cobs.CorruptFrame, FramingLost):
             pass
 
-    def _speed_fallback(self) -> bool:
-        """A request went unanswered (its resend too) while the link ran above the boot speed: the probe went back
-        (idle_ms, broken candidates, a lapse). Back to the boot speed, confirmed: True = send again there."""
-        if not self.fallback or self.base_baud is None or self.baud == self.base_baud:
+    def _in_use(self) -> bool:
+        """A raised rate in force outside raise_speed's own trial (where every failure is handled there)."""
+        return self.fallback and self._raised()
+
+    def _wait(self) -> float:
+        """How long one answer is waited for: the link's timeout; raised and in use, at most a quarter of the
+        session's lease (at least RAISED_WAIT_MIN_S) - a probe that went back by itself (broken candidates, core §3.5
+        item 5) hears nothing at the raised rate, and the fallback (both waits, the confirm at the boot speed, the
+        request again there) must end well inside the lease. A request that may take longer on the probe
+        (Host.expecting: a run's timeout_ms, a dmi list's waits, ...; the probe does not count the lease meanwhile,
+        core §6.1) waits at least that and EXPECT_MARGIN_S, at any rate; the link's own requests never do."""
+        wait = self.timeout
+        if self._in_use():
+            lease = self.lease_s()
+            if lease is not None:
+                wait = min(self.timeout, max(RAISED_WAIT_MIN_S, lease / 4))
+        expected = 0.0 if self._own else self.expected_s()
+        return max(wait, expected + EXPECT_MARGIN_S) if expected > 0 else wait
+
+    def _strike(self, e: Exception) -> None:
+        """Raised and in use: a frame broke or a request is sent again (`e`). STRIKE_MAX within STRIKE_WINDOW_S: the
+        link steps down at the next safe point (core §3.5 item 7)."""
+        if not self._in_use():
+            return
+        now = time.monotonic()
+        self.strikes = [t for t in self.strikes if now - t < STRIKE_WINDOW_S] + [now]
+        if len(self.strikes) >= STRIKE_MAX and not self.step_due:
+            self.step_due = (f"{len(self.strikes)} broken frames / resends within {STRIKE_WINDOW_S:g} s at {self.baud} "
+                             f"(the last: {type(e).__name__})")
+
+    def _step_down_if_due(self) -> None:
+        if self.step_due and self._in_use():
+            self._step_down(self.step_due)
+
+    def _step_down(self, why: str) -> None:
+        """Leave the raised rate for the rest of the session: port_speed step 2 at it (STEP_DOWN_WAIT_S, never sent
+        again: a probe that already went back cannot hear it, and a committed one reverts at the broken candidates
+        the confirms make), the host at the boot speed, a confirm there. ConnectionError when none is answered."""
+        rate = self.baud
+        self.step_due = ""
+        self.strikes.clear()
+        if self.session_frame is not None and self.speed_port is not None:
+            saved = self.timeout, self.resend, self.fallback
+            self.timeout, self.resend, self.fallback = STEP_DOWN_WAIT_S, False, False
+            self._own += 1
+            try:
+                self._send(self.session_frame(OP_PORT_SPEED, struct.pack("<BIBHI", self.speed_port, 0,
+                                                                         SPEED_STEP["revert"], 0, 0)))
+            except LINK_ERRORS:
+                pass
+            finally:
+                self.timeout, self.resend, self.fallback = saved
+                self._own -= 1
+        if not self.back_to_base():
+            raise ConnectionError(f"the probe answers neither at {rate} nor at the boot speed {self.base_baud}")
+        self._stepped(rate, why)
+
+    def _stepped(self, rate: int, why: str) -> None:
+        """`rate` is not used again in this session (raise_speed skips it), and the report says so."""
+        self.unusable[rate] = why
+        if self.speed is not None:
+            self.speed.rate, self.speed.chosen = self.base_baud, None
+            self.speed.stepped_down, self.speed.down_why = True, why
+
+    def _speed_fallback(self, e: Exception | None = None) -> bool:
+        """A request failed (its resend too) while a raised rate was in use. Broken frames (the probe still answers
+        at that rate) or a step down already due: step down (`_step_down`). No answer at all: the probe went back
+        (idle_ms, broken candidates, a lapse) - back to the boot speed, confirmed. Either way the rate is not used
+        again in this session. True = send again there."""
+        if not self._in_use() or self.base_baud is None:
             return False
+        rate = self.baud
+        if self.step_due or not isinstance(e, TimeoutError):
+            self._step_down(self.step_due or f"frames kept breaking at {rate} ({type(e).__name__})")
+            return True
         if not self.back_to_base():
             raise ConnectionError(f"the probe answers neither at {self.baud} nor at the boot speed {self.base_baud}")
         self.speed_lost += 1
+        self.step_due = ""
+        self.strikes.clear()
         if self.speed is not None:
-            self.speed.rate = self.base_baud
-            self.speed.chosen = None
             self.speed.lost = True
+        self._stepped(rate, f"no answer at {rate} (the probe went back by itself)")
         return True
 
     def _exchange_once(self, messages: list[bytes], max_inflight: int, window_bytes: int,
@@ -509,7 +613,11 @@ class SerialLink:
         self.corr_source = hst.next_corr
         self.blind = hst.blind_stop
         self.held = lambda: hst.session is not None
-        self.keepalive_frame = lambda: m.Request(hst.next_corr(), m.CORE_FN, m.OP_KEEPALIVE, b"", hst.session).pack()
+        self.session_frame = lambda op, payload: m.Request(hst.next_corr(), m.CORE_FN, op, payload, hst.session).pack()
+        self.keepalive_frame = lambda: self.session_frame(m.OP_KEEPALIVE, b"")
+        self.lease_s = lambda: hst.lease_ms / 1000 if hst.session is not None and hst.lease_ms else None
+        hst.before_request = self._keep_raised      # the keepalive before the request's corr is taken (core §4.1)
+        self.expected_s = lambda: hst.expect_ms / 1000
         hst.link = self
         if self.framing == "cobs" and getattr(self, "transport", None) == "serial":
             self.wait_boot_speed()
@@ -670,7 +778,7 @@ UART_BRIDGE = reg.CORE.enum["transport_kind"]["uart_bridge"]
 @dataclass
 class SpeedTrial:
     """One rate tried: what the probe said it runs at, the verify's bytes, KB/s (1000 B/s) and broken frames each way
-    (in = probe to host, link_source; out = host to probe, link_sink), and whether it was committed (why not)."""
+    (in = probe to host, link_source; out = host to probe, link_sink; duplex = both at once), and whether it was committed (why not)."""
     rate: int
     actual: int | None = None
     in_bytes: int = 0
@@ -679,6 +787,9 @@ class SpeedTrial:
     out_kb_s: float | None = None
     broken_in: int = 0
     broken_out: int = 0
+    duplex_bytes: int = 0      # both ways at once (link_source and link_sink interleaved), at the in-flight that passed
+    duplex_kb_s: float | None = None
+    broken_duplex: int = 0
     committed: bool = False
     why: str = ""
     inflight: int = 0          # the requests kept in flight the verify passed with (0: none passed)
@@ -688,8 +799,10 @@ class SpeedTrial:
 class SpeedReport:
     """raise_speed's answer, kept as `link.speed`: the boot speed, the rate in force now (`rate`), the committed one
     (`chosen`, None: the boot speed), every trial in order, and why nothing was tried (`supported` False).
-    `lost`: a raised rate was later found gone (the link went back to the boot speed). in_kb_s / out_kb_s: the chosen
-    rate's measured throughput (None at the boot speed) - for budgeting a transfer."""
+    `lost`: a raised rate was later found gone (the link went back to the boot speed). `stepped_down`: in use, the
+    link left the raised rate for the rest of the session (frames kept breaking, or no answer came), `down_why` says
+    why. in_kb_s / out_kb_s / duplex_kb_s: the chosen rate's measured throughput (None at the boot speed) - for
+    budgeting a transfer."""
     base: int
     supported: bool
     rate: int
@@ -697,6 +810,8 @@ class SpeedReport:
     trials: list[SpeedTrial] = field(default_factory=list)
     why: str = ""
     lost: bool = False
+    stepped_down: bool = False     # in use, the raised rate was left for the rest of the session (`down_why`)
+    down_why: str = ""
 
     def _chosen(self) -> SpeedTrial | None:
         return next((t for t in self.trials if t.committed), None) if self.chosen else None
@@ -711,15 +826,23 @@ class SpeedReport:
         t = self._chosen()
         return t.out_kb_s if t else None
 
+    @property
+    def duplex_kb_s(self) -> float | None:
+        t = self._chosen()
+        return t.duplex_kb_s if t else None
+
     def to_text(self) -> str:
         if not self.supported:
             return f"port_speed not supported: {self.why} (stays at {self.rate})\n"
-        lines = [f"{'rate':>9} {'actual':>9} {'in KB/s':>8} {'out KB/s':>8} {'broken in/out':>13}  result"]
+        lines = [f"{'rate':>9} {'actual':>9} {'in KB/s':>8} {'out KB/s':>8} {'duplex KB/s':>11} "
+                 f"{'broken in/out/duplex':>20}  result"]
         for t in self.trials:
-            kb = lambda v: f"{v:8.1f}" if v is not None else f"{'-':>8}"   # noqa: E731
+            kb = lambda v, w=8: f"{v:{w}.1f}" if v is not None else f"{'-':>{w}}"   # noqa: E731
             lines.append(f"{t.rate:>9} {t.actual if t.actual else '-':>9} {kb(t.in_kb_s)} {kb(t.out_kb_s)} "
-                         f"{f'{t.broken_in}/{t.broken_out}':>13}  "
+                         f"{kb(t.duplex_kb_s, 11)} {f'{t.broken_in}/{t.broken_out}/{t.broken_duplex}':>20}  "
                          f"{(f'committed (in flight {t.inflight})' if t.committed else t.why)}")
+        if self.stepped_down:
+            lines.append(f"stepped down: {self.down_why} - the boot speed for the rest of the session")
         lines.append(f"in force: {self.rate}" + (" (raised)" if self.chosen else " (the boot speed)"))
         return "\n".join(lines) + "\n"
 
@@ -737,10 +860,12 @@ def _speed_port(hst) -> tuple[int | None, str]:
 
 
 def _verify(hst, lk: SerialLink, rate: int, trial: SpeedTrial, verify_bytes: int, verify_s: float,
-            inflight: int | None = None) -> bool:
-    """Both ways with max_frame-sized frames, pipelined as `inflight` (default: as the probe allows): up to half of
-    verify_bytes or verify_s each (in first, then out). Stops at the first frame that breaks (lost, or its content
-    wrong)."""
+            inflight: int | None = None, ways: tuple[str, ...] = ("in", "out"), duplex_s: float = 1.0,
+            duplex_frames: int = 64) -> bool:
+    """Max_frame-sized frames, pipelined as `inflight` (default: as the probe allows), for each of `ways`: "in"
+    (link_source) and "out" (link_sink) up to half of verify_bytes or verify_s each; "duplex" both interleaved
+    (link_source, link_sink, ...) for duplex_s and at least duplex_frames, so frames go both ways at once. Stops at
+    the first frame that breaks (lost, or its content wrong)."""
     limits = hst.limits or hst.confirm()
     max_frame, window = limits["max_frame"], limits["window"]
     inflight = max(1, inflight or limits["max_inflight"])
@@ -750,41 +875,48 @@ def _verify(hst, lk: SerialLink, rate: int, trial: SpeedTrial, verify_bytes: int
     saved = lk.timeout, lk.resend
     lk.timeout, lk.resend = max(0.3, 4 * wire * inflight + 0.1), False
     pattern = bytes(k & 0xFF for k in range(n_in))
+    sink_body = bytes((k * 7) & 0xFF for k in range(n_out))
+
+    def request(k: int, way: str) -> tuple[bytes, bool]:
+        source = way == "in" or (way == "duplex" and k % 2 == 0)
+        body, op = (struct.pack("<I", n_in), m.OP_LINK_SOURCE) if source else (sink_body, m.OP_LINK_SINK)
+        return m.Request(hst.next_corr(), m.CORE_FN, op, body).pack(), source
+
+    def more(way: str, moved: int, frames: int, t0: float) -> bool:
+        if way == "duplex":
+            return time.perf_counter() - t0 < duplex_s or frames < duplex_frames
+        return moved < verify_bytes / 2 and time.perf_counter() - t0 < verify_s / 2
+
     try:
-        for way in ("in", "out"):
-            moved, t0 = 0, time.perf_counter()
-            while moved < verify_bytes / 2 and time.perf_counter() - t0 < verify_s / 2:
-                if way == "in":
-                    body, op = struct.pack("<I", n_in), m.OP_LINK_SOURCE
-                else:
-                    body, op = bytes((k * 7) & 0xFF for k in range(n_out)), m.OP_LINK_SINK
-                msgs = [m.Request(hst.next_corr(), m.CORE_FN, op, body).pack() for _ in range(inflight * 2)]
+        for way in ways:
+            moved, frames, broken, t0 = 0, 0, 0, time.perf_counter()
+            while more(way, moved, frames, t0):
+                batch = [request(k, way) for k in range(inflight * 2)]
                 replies: list[bytes] = []
                 try:
-                    lk._exchange_once(msgs, inflight, window, replies)
+                    lk._exchange_once([msg for msg, _ in batch], inflight, window, replies)
                 except (cobs.CorruptFrame, TimeoutError, FramingLost):
                     pass                                  # the frames not answered are the broken ones
                 good = 0
-                for r in replies:
+                for r, (_, source) in zip(replies, batch):
                     res = m.Result.unpack(r)
-                    if not (res.succeeded and (res.payload == pattern if way == "in"
+                    if not (res.succeeded and (res.payload == pattern if source
                                                else res.payload[:4] == struct.pack("<I", n_out))):
                         break
                     good += 1
-                moved += good * (n_in if way == "in" else n_out)
-                if good == len(msgs):
-                    continue
-                if way == "in":
-                    trial.broken_in += len(msgs) - good
-                else:
-                    trial.broken_out += len(msgs) - good
-                break
-            seconds = max(time.perf_counter() - t0, 1e-6)
+                    moved += n_in if source else n_out
+                frames += good
+                if good < len(batch):
+                    broken = len(batch) - good
+                    break
+            kb_s = moved / max(time.perf_counter() - t0, 1e-6) / 1000
             if way == "in":
-                trial.in_bytes, trial.in_kb_s = moved, moved / seconds / 1000
+                trial.in_bytes, trial.in_kb_s, trial.broken_in = moved, kb_s, broken
+            elif way == "out":
+                trial.out_bytes, trial.out_kb_s, trial.broken_out = moved, kb_s, broken
             else:
-                trial.out_bytes, trial.out_kb_s = moved, moved / seconds / 1000
-            if trial.broken_in or trial.broken_out:
+                trial.duplex_bytes, trial.duplex_kb_s, trial.broken_duplex = moved, kb_s, broken
+            if broken:
                 return False
         return True
     finally:
@@ -795,18 +927,23 @@ SWITCH_SETTLE_S = 0.02   # after a baud change, before the first byte at the new
 
 
 def raise_speed(hst, rates: list[int], *, verify_bytes: int = 32768, verify_s: float = 1.0,
-                verify_ms: int | None = None, idle_ms: int = IDLE_MAX_MS, port: int | None = None) -> SpeedReport:
+                verify_ms: int | None = None, idle_ms: int = IDLE_MAX_MS, port: int | None = None,
+                duplex_s: float = 1.0, duplex_frames: int = 64) -> SpeedReport:
     """port_speed (oep-core §3.5), opt-in: try `rates` in order on the UART bridge this host opened, and commit the
     first that passes. Each: try (answered at the speed now) -> the host switches -> verify both ways with
-    max_frame-sized frames for verify_bytes or verify_s in all (broken frames counted, KB/s measured each way) ->
-    commit at the new speed when nothing broke; else revert (step 2, at the new speed) and back to the boot speed,
+    max_frame-sized frames for verify_bytes or verify_s in all (broken frames counted, KB/s measured each way),
+    pipelined as the probe allows and, when that breaks, one at a time -> both ways at once at the in-flight that
+    passed (link_source and link_sink interleaved, duplex_s and at least duplex_frames; a broken frame fails the rate:
+    "broke both ways at once") -> commit at the new speed when nothing broke; else revert (step 2, at the new speed) and back to the boot speed,
     re-confirmed there (waiting out the probe's verify_ms when the revert was lost), and the next rate. A rate the
     probe's UART cannot make is skipped (unsupported). The session must be open (the rate lasts as long as it does).
 
     verify_ms: how long the probe waits for the commit (default: verify_s + 1.5 s, at most 65535). idle_ms: once
     committed, the probe reverts after this long with no good frame (default and at most port_speed_idle_max_ms,
-    3000; 0 and anything longer mean that maximum). The link keeps the line alive meanwhile (`keep_alive`).
-    port: the transport index (default: the probe's first UART bridge). -> the report, also kept as `hst.link.speed`."""
+    3000; 0 and anything longer mean that maximum). The link keeps the line alive meanwhile (`keep_alive`), and
+    steps down to the boot speed for the rest of the session when frames break or requests go again STRIKE_MAX times
+    within STRIKE_WINDOW_S, or an answer does not come at all (`report.stepped_down`); a rate stepped down from in
+    this session is not tried again. port: the transport index (default: the probe's first UART bridge). -> the report, also kept as `hst.link.speed`."""
     lk = getattr(hst, "link", None)
     base = getattr(lk, "base_baud", None)
     report = SpeedReport(base or 0, False, getattr(lk, "baud", None) or 0)
@@ -824,19 +961,26 @@ def raise_speed(hst, rates: list[int], *, verify_bytes: int = 32768, verify_s: f
         raise _host.OepError("raise_speed needs an open session (the rate lasts as long as the session)")
     port = where if port is None else port
     report.supported = True
-    wait = (verify_ms if verify_ms is not None else min(65535, int(verify_s * 1000) + 1500))
+    wait = (verify_ms if verify_ms is not None
+            else min(65535, int((verify_s + duplex_s) * 1000) + 1500))
+    if lk.unusable_session != hst.session:
+        lk.unusable, lk.unusable_session = {}, hst.session
     lk.fallback = False                                     # every failure here is handled here
     idle_ms = idle_ms if 0 < idle_ms <= IDLE_MAX_MS else IDLE_MAX_MS
     try:
-        return _raise(hst, lk, report, rates, port, base, wait, verify_bytes, verify_s, idle_ms)
+        return _raise(hst, lk, report, rates, port, base, wait, verify_bytes, verify_s, idle_ms, duplex_s, duplex_frames)
     finally:
         lk.fallback = True
 
 
-def _raise(hst, lk, report, rates, port, base, wait, verify_bytes, verify_s, idle_ms) -> SpeedReport:
+def _raise(hst, lk, report, rates, port, base, wait, verify_bytes, verify_s, idle_ms, duplex_s,
+           duplex_frames) -> SpeedReport:
     for rate in rates:
         trial = SpeedTrial(rate)
         report.trials.append(trial)
+        if rate in lk.unusable:
+            trial.why = f"stepped down from earlier in this session ({lk.unusable[rate]})"
+            continue
         try:
             r = hst.call(m.CORE_FN, OP_PORT_SPEED, struct.pack("<BIBHI", port, rate, SPEED_STEP["try"], wait, 0))
         except TimeoutError:
@@ -863,24 +1007,35 @@ def _raise(hst, lk, report, rates, port, base, wait, verify_bytes, verify_s, idl
         # 500 kbaud and up behind usbip, 2026-10-01) gets a second verify with one request at a time
         full = max(1, (hst.limits or hst.confirm())["max_inflight"])
         tries = [full] if full == 1 else [full, 1]
+        broke = "frames broke"
         for n in tries if ok else []:
-            trial.broken_in = trial.broken_out = 0
             ok = _verify(hst, lk, rate, trial, verify_bytes, verify_s, n)
             if ok:
                 trial.inflight = n
                 break
             any(lk.confirm_raw(0.2) for _ in range(3))     # the broken frames' leftovers read past
+        if ok:
+            # both ways at once at the in-flight that passed: a line that carries each way alone can still break
+            # under sustained duplex use (a CH340 at 921600 broke a frame every ~0.5 s, 2026-10-01)
+            ok = _verify(hst, lk, rate, trial, verify_bytes, verify_s, trial.inflight, ("duplex",), duplex_s,
+                         duplex_frames)
+            if not ok:
+                broke, trial.inflight = "broke both ways at once", 0
+                any(lk.confirm_raw(0.2) for _ in range(3))
         if ok:
             try:
                 hst.call(m.CORE_FN, OP_PORT_SPEED, struct.pack("<BIBHI", port, rate, SPEED_STEP["commit"], 0, idle_ms))
                 trial.committed = True
                 report.rate, report.chosen = rate, rate
                 lk.inflight_cap = trial.inflight if trial.inflight < full else 0
+                lk.speed_port = port
+                lk.strikes.clear()
+                lk.step_due = ""
                 return report
             except (TimeoutError, _host.Rejected) as e:
                 trial.why = f"the commit failed: {e}"
         else:
-            trial.why = "frames broke" if heard else "no confirm at the new rate"
+            trial.why = broke if heard else "no confirm at the new rate"
             saved = lk.timeout, lk.resend
             lk.timeout, lk.resend = 0.3, False
             try:

oep_client/riscv.py

@@ -238,7 +238,8 @@ class Wire(WireBase):
         low for hold_ms, then attach - halting before the first instruction with halt=True - the way back from firmware
         that turns the debug pins into GPIOs. self.target_id: (scheme, value) of the target's identity when the probe
         could read one."""
-        rd = m.Reader(self._call(self.ATTACH, self.attach_body(halt, max_speed, pins, idle_clock, reset)).payload)
+        rd = m.Reader(self._call(self.ATTACH, self.attach_body(halt, max_speed, pins, idle_clock, reset),
+                                 expect_ms=reset[1] if reset else 0).payload)
         conn, status, self.flags, self.speed_hz = rd.take("HIBI")
         self.had_reset = bool(self.flags & self.FLAGS["havereset_acked"])
         self.existing = bool(self.flags & self.FLAGS["existing"])
@@ -336,6 +337,22 @@ def count_steps(steps: bytes) -> list[int]:
     return kinds
 
 
+def dmi_wait_ms(raw: bytes) -> int:
+    """The time a step list may take by its waits and time-bounded polls (wait_us, poll_us), in ms (rounded up)."""
+    us, at = 0, 0
+    while at < len(raw):
+        kind = raw[at]
+        if kind == STEP_WAIT_US:
+            us += struct.unpack_from("<I", raw, at + 1)[0]
+        elif kind == STEP_POLL_US:
+            us += struct.unpack_from("<I", raw, at + 10)[0]
+        size = STEP_SIZES.get(kind)
+        if size is None:
+            break
+        at += size
+    return -(-us // 1000)
+
+
 def dmi_value_count(kinds: list[int], done: int, status: int) -> int:
     """§5.5: the reads and polls among the first `done` steps, plus the failed step's last value when it is a poll
     that timed out (a poll whose read failed on the line adds nothing)."""
@@ -483,7 +500,7 @@ class RiscvDm(Interface):
         it). timeout_ms None: the probe's max_op_ms (core §7.5), the most it allows. Other statuses raise TargetError."""
         if timeout_ms is None:
             timeout_ms = max_op_ms(self.host)
-        r = self._request(self.RUN, self.run_body(pc, regs, timeout_ms, outs))
+        r = self._request(self.RUN, self.run_body(pc, regs, timeout_ms, outs), expect_ms=timeout_ms)
         res = self.run_result(r)
         if res.status == STATUS["timeout"] and not res.stopped:
             return res
@@ -496,7 +513,7 @@ class RiscvDm(Interface):
         raises StepListError (with what it did read): a caller cannot mistake an unfinished poll for a met one."""
         raw = b"".join(steps) if isinstance(steps, list) else steps
         kinds = count_steps(raw)
-        r = self._request(self.DMI, struct.pack("<H", len(kinds)) + raw)
+        r = self._request(self.DMI, struct.pack("<H", len(kinds)) + raw, expect_ms=dmi_wait_ms(raw))
         rd = ran(r)
         done, status, nvals = rd.take("HBH")
         values = rd.words(nvals)

{oep_client_python-0.0.25.dist-info → oep_client_python-0.0.26.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: oep-client-python
-Version: 0.0.25
+Version: 0.0.26
 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
@@ -122,7 +122,9 @@ print(hst.link.speed.to_text())             # every rate tried: actual, in / out
 
 Each rate in order: `try` (answered at the speed now, then the probe switches) -> the host switches -> a verify both ways
 with max_frame-sized frames (link_source / link_sink, pipelined) for `verify_bytes` or `verify_s`, counting broken frames
-and measuring KB/s each way -> `commit` when nothing broke, else revert and back to the boot speed, confirmed there (a
+and measuring KB/s each way -> both ways at once at the in-flight that passed (link_source and link_sink interleaved,
+about 1 s and at least 64 frames, `duplex_kb_s`; a line that carries each way alone can still break under duplex use - a
+CH340 at 921600 did) -> `commit` when nothing broke, else revert and back to the boot speed, confirmed there (a
 probe whose revert was lost waits out its `verify_ms`). The first rate that passes is kept; a rate the probe's UART cannot
 make is skipped. Which rates pass depends on the bridge chip and its driver (an FTDI took only 3 MHz / n, a CH340 921600
 but not 1500000 towards the host: oep-spec docs/uart-speed-negotiation.ja.md), so the host chooses them. The report
@@ -133,7 +135,10 @@ line goes quiet (`idle_ms`, at most `port_speed_idle_max_ms` = 3 s; a host that
 that): while raised the link sends a keepalive before a request when it has been quiet for 1 s, and `hst.link.keep_alive()`
 does the same for a caller that sits idle for long; opening a serial port retries its first confirm for about 4 s to
 wait out a rate left over. The link follows an `end` at once, and a request that goes unanswered at a raised rate (its
-resend too) takes the link back to the boot speed, confirmed, and goes once more there - it never wedges. A probe
+resend too) takes the link back to the boot speed, confirmed, and goes once more there - it never wedges; while raised
+each wait for an answer is at most a quarter of the lease, so this ends well inside it. In use, 3 broken frames or
+resends within 5 s step the link down: port_speed revert at the raised rate, the boot speed, a confirm, the request
+again there. A rate left either way is not used again in that session (`speed.stepped_down`, `speed.down_why`). A probe
 without the feature answers `not supported` and stays at its speed. Behind a broker (TCP) the broker does this, not the
 client. Serial ports are also opened in the driver's low-latency mode where it has one (an FTDI's latency timer 16 -> 1 ms
 tripled a UART bridge's throughput). `open_host(..., baud=)` names the boot speed when the board's profile is not 115200.

{oep_client_python-0.0.25.dist-info → oep_client_python-0.0.26.dist-info}/RECORD

@@ -1,35 +1,35 @@
-oep_client/__init__.py,sha256=5RMk_SvbzmZ15kSrpyg7dnKWUVbx3F3FFoPTMBCFOUU,164
-oep_client/__main__.py,sha256=xrdBG4uBsJjYF5CLKcYmWdf392S-JUhyDGoOkUsk4R8,19682
-oep_client/arm.py,sha256=JGrevyxH8W-ke33rCv1_zyfekDDZrUv2kJhNRGyKFCA,12708
-oep_client/capture.py,sha256=goD0of-bClOK88PHR0PpWZ_XJqOWhOL9UVtVU0k3NLA,31994
+oep_client/__init__.py,sha256=KqFhyYXLqtEQs_WvY0ZfnJTyG1JZxKIBKfe0wUuglJc,164
+oep_client/__main__.py,sha256=em34bE60p_ut43LFGCRgxsofMOiTRL0wWiC-HGIKLVA,19852
+oep_client/arm.py,sha256=X7xrKDOXkv3lFtc9CG6ls051xZxy8C3XUaGoIrJ2_nM,12744
+oep_client/capture.py,sha256=R3ItIUjE6-Kqe3tjTVfYW8rKO4cYF-d480FAVbWr-SE,32148
 oep_client/catalog.py,sha256=m43MARRSJ5AwzNBMvRJUMAZxZc53t5eN-QaJ9049YHY,7016
 oep_client/ch32_flash.py,sha256=GxlpZY-o7pOjT6Yod9Gk0EflNtVKT_w_fXwkXBq5zrM,12641
 oep_client/cobs.py,sha256=hqddQI_X7rsBvBvcP_MBE3bXPyB13-Azjqp_9JfdQ1g,2288
-oep_client/config.py,sha256=MWzizoZ4qSCADsJaeWAubRm6HsIs6Sq__fO13tsrAuM,17544
+oep_client/config.py,sha256=7KQxMhTklUhT9uzlj4rnT1xyXpJeFFfNNE4oIqeyMy0,17676
 oep_client/console.py,sha256=Srzlbto7-NZmkxUFMy_nUAanf9X0ZW1ib5tl6tX4rXU,9790
-oep_client/core.py,sha256=tbRV2eZNtGtQihNVthZytwVGkXFPAvSKamr2I0Uj3Bc,11525
+oep_client/core.py,sha256=TooBzLBYcZ5-ymNJwcYYFSbbWDqkb7J6ccjedZpKe-0,12008
 oep_client/decode.py,sha256=6pTFVBT0MLAKedZLVKyd5yT8hjrRw4fdDjnoDiE9XRs,2380
 oep_client/dump.py,sha256=GAnmu2abuDmGmbWcbbEfC3EUuPp5Hady9vQVNcQ-724,6743
-oep_client/endpoint.py,sha256=4-o5nDd2bCJsQ-AlqJaedqCoTuzutmRF_kovtlfaKFA,136966
+oep_client/endpoint.py,sha256=k8O_izvyb05jNIyjlE5ILVhpCO0RaH9dhMUlGh6-5GM,138248
 oep_client/fake.py,sha256=LG56WG0RrFtmgfodVZhfLWvbojtNFWnk2lycjR6zhiE,19385
 oep_client/fake_capture.py,sha256=6oo-2byIBuZS0g5hk5KXHkqHNrO9PSRO-5MuetZvk80,26916
-oep_client/fake_serial.py,sha256=bPzQifttzfQ6SedZ11KBI3aiWuKbN2WXuBnVEqYJoQE,8381
-oep_client/fake_serve.py,sha256=n5GIwBDfu3lrxEIg_KN0I4uHIlaYszFUAdc9dO6HUVs,16200
+oep_client/fake_serial.py,sha256=WEh-1WIboot1Z_Mq30S4Ny_ceWt1DTUJTjIl9giUdGQ,9831
+oep_client/fake_serve.py,sha256=pwdJPcB8MnPpzoFWtxmLMpLZLJ3kFkzkWOgA_4fiRic,16524
 oep_client/fixture.py,sha256=sskFYFxI_7SOR_E5AxNf6tSYoUvoJOh0z_VjVdXcp6o,12527
 oep_client/frames.py,sha256=xjgjnXmXUqNJZ5m0h91r4Cy48WoVK1mEMW4gRg-mlMI,3991
 oep_client/hid_stream.py,sha256=99Dsm4Io1keukuETG_UNqjBGiVYZZeb__Pv4ytaKg9k,10695
-oep_client/host.py,sha256=3NiPV5rnruaC6PR48LOCEoMRpC6985PA8VpSnr7gB2A,20296
+oep_client/host.py,sha256=rLSHJhQFgPo5e75Z8dNjDx7zRC8vebAGxbmSiFH0mWU,21700
 oep_client/interfaces.py,sha256=8HXr9iGJASIwBpTHBrCK_0b6NfbclEjCbBCsc62euzg,5693
-oep_client/link.py,sha256=kLigInSw4Ch93MobxW8SjORYSqvwdaOlCIXvxEdfHhs,46609
+oep_client/link.py,sha256=1dlZTEfqV4md4jicl0yd1x1GOG1F67D5UhnmA8lRBbQ,56592
 oep_client/message.py,sha256=eQ-27lxN2Y9JadnUFpEmkEW2X7oucrKFFFs4_nnDClU,12322
 oep_client/names.py,sha256=ztCZFWs__aR-a5G14TnJP-Q4YfLhbyrzvOVOMJuG93k,3653
 oep_client/registry.py,sha256=YEL_iMWFmqAaUY0zTkhs5CqbXBHBx4W8kjm37KPs190,15726
-oep_client/riscv.py,sha256=vqd2aiLf2MaXcsGqh7Hsg51ng_OQi1DgI-vLZvHJ8VQ,29291
+oep_client/riscv.py,sha256=245t-x1qM-wTTxM5OYNJz8c3oH0H8ORH6aexqcUE8oA,29941
 oep_client/rp2350.py,sha256=7OMyj270k3AY1e3-ljicPwOjf9jOlokbT6QNkA0b0yY,4227
 oep_client/uiapduino.py,sha256=kDB8C9GvIPBw94PaCKMzVWNtoQDu_axrz_n_6zbYJGU,6082
 oep_client/usb_stream.py,sha256=_KQvWq906DnQ4EjW1to7d9ufh3pnGkkkbCzti6GYVCY,11131
-oep_client_python-0.0.25.dist-info/METADATA,sha256=NXXpVUcXthoYvn9LFMVhCDziB2oapvAXQ-8bU9Qp2rk,13224
-oep_client_python-0.0.25.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-oep_client_python-0.0.25.dist-info/entry_points.txt,sha256=h6_8QX89Ww1ogALEGG5g4kspT3IOV6O51lwKqf5BWco,49
-oep_client_python-0.0.25.dist-info/licenses/LICENSE,sha256=ntlalztb3L1OaNAxmQdHlubu5fVhjMc9oRZi3PeQhXg,1076
-oep_client_python-0.0.25.dist-info/RECORD,,
+oep_client_python-0.0.26.dist-info/METADATA,sha256=jVnIRVW010EUmGV9-b3drDiPRe84Vi4DZCsR6hswjOQ,13812
+oep_client_python-0.0.26.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+oep_client_python-0.0.26.dist-info/entry_points.txt,sha256=h6_8QX89Ww1ogALEGG5g4kspT3IOV6O51lwKqf5BWco,49
+oep_client_python-0.0.26.dist-info/licenses/LICENSE,sha256=ntlalztb3L1OaNAxmQdHlubu5fVhjMc9oRZi3PeQhXg,1076
+oep_client_python-0.0.26.dist-info/RECORD,,