oep-client-python 0.0.24__tar.gz → 0.0.25__tar.gz

{oep_client_python-0.0.24 → oep_client_python-0.0.25}/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+## 0.0.25
+- (EN) port_speed's idle limit (oep-spec 877cf01, core §3.5 items 5 and 6; registry synced, `port_speed_idle_max_ms` = 3000): a committed rate goes back after at most 3 s with no good frame, so a host that raised the speed and died leaves it no longer than that. The fake clamps idle_ms the same way (0 and anything longer: the maximum; 0 used to mean never). `raise_speed`'s `idle_ms` defaults to the maximum (0 or more than it: the maximum). While raised, the link sends a keepalive before a request (or a pipelined exchange, or inside a long `pump`) when it has been quiet for 1 s; `SerialLink.keep_alive()` does the same for a caller that sits idle for long (no background thread). `open_host` on a serial port (COBS) retries its first confirm for about 4 s (`OPEN_RETRY_S`, the idle maximum and a second; 0.5 s each) to wait out a rate left over, then raises TimeoutError; other transports keep their timeout.
+- (JA) port_speed の黙りの上限（oep-spec 877cf01、core §3.5 の 5 と 6。registry を写し直した。`port_speed_idle_max_ms` = 3000）: 決めた速さは正しいフレームが来ないまま最長 3 秒で戻るので、速さを上げた host が落ちてもそれより長くは残らない。fake も idle_ms を同じに切り詰める（0 とそれより長い値は最長。0 はこれまで戻らないだった）。`raise_speed` の `idle_ms` の既定は最長（0 と最長より長い値も最長）。上げている間、link は 1 秒黙っていれば要求の前（並べた送り、長い `pump` の中も）に keepalive を送る。長く黙る呼び出し側は `SerialLink.keep_alive()` で同じことをする（裏のスレッドは無い）。シリアルの口（COBS）の `open_host` は最初の confirm を約 4 秒（`OPEN_RETRY_S`、黙りの最長と 1 秒。1 回 0.5 秒）繰り返して残った速さが戻るのを待ち、それでも答えが無ければ TimeoutError。ほかの経路の時間切れは変わらない。
+
 ## 0.0.24
 - (EN) A serial link whose port a session holds sends a request again as soon as a broken frame arrives, instead of after the timeout: the probe sends no raw bytes on a held port (oep-core §3.4), so the broken frame was the reply, and the repeat is answered from the probe's retry table. A 60 KB logic capture read on an M5Stack ATOM went from 4.0 to 8.3 KB/s at 115200 and runs at 76 KB/s at 1.5 Mbaud (dogfooding port_speed, 2026-10-01).
 - (JA) セッションが口を持っているシリアルの経路では、壊れたフレームが来たら時間切れを待たずにすぐ送り直す: 持たれている口には probe が生のバイトを送らない（oep-core §3.4）ので、壊れたフレームは応答で、送り直しには probe の送り直しの表が答える。M5Stack ATOM で 60 KB のロジックのキャプチャの読み出しが 115200 で 4.0 → 8.3 KB/s、1.5 Mbaud で 76 KB/s になった（port_speed のドッグフーディング、2026-10-01）。

{oep_client_python-0.0.24 → oep_client_python-0.0.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: oep-client-python
-Version: 0.0.24
+Version: 0.0.25
 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
@@ -129,7 +129,10 @@ but not 1500000 towards the host: oep-spec docs/uart-speed-negotiation.ja.md), s
 (`link.speed`: `rate`, `chosen`, `in_kb_s` / `out_kb_s`, `trials`) is there to budget a capture or a write.
 
 The probe goes back to the boot speed by itself when the session ends (`end`, a lapse, a force), when frames break or the
-line goes quiet (`idle_ms`): the link follows an `end` at once, and a request that goes unanswered at a raised rate (its
+line goes quiet (`idle_ms`, at most `port_speed_idle_max_ms` = 3 s; a host that died leaves the rate no longer than
+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
 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

{oep_client_python-0.0.24 → oep_client_python-0.0.25}/README.ja.md

@@ -100,8 +100,10 @@ print(hst.link.speed.to_text())             # 試した速さごとに、実際
 3 MHz ÷ n だけ、CH340 は 921600 は通り 1500000 は probe → host が壊れた: oep-spec docs/uart-speed-negotiation.ja.md）ので、速さは
 host が選ぶ。結果（`link.speed`: `rate`、`chosen`、`in_kb_s` / `out_kb_s`、`trials`）はキャプチャや書き込みの予算を立てるのに使う。
 
-probe はセッションが終わったとき（`end`、lease の期限切れ、force）、フレームが壊れたとき、線が黙ったとき（`idle_ms`）に自分で
-起動時の速さに戻る: link は `end` にはすぐ合わせ、上げた速さで応答の来ない要求（送り直しも）があれば、起動時の速さに戻って
+probe はセッションが終わったとき（`end`、lease の期限切れ、force）、フレームが壊れたとき、線が黙ったとき（`idle_ms`、最長
+`port_speed_idle_max_ms` = 3 秒。落ちた host の速さもそれより長くは残らない）に自分で起動時の速さに戻る: 上げている間、link は
+1 秒黙っていれば要求の前に keepalive を送り、長く黙る呼び出し側は `hst.link.keep_alive()` で同じことをする。シリアルの口を開くと
+最初の confirm を約 4 秒繰り返して、残った速さが戻るのを待つ。link は `end` にはすぐ合わせ、上げた速さで応答の来ない要求（送り直しも）があれば、起動時の速さに戻って
 confirm し、そこでもう一度送る（固まらない）。機能の無い probe は `not supported` で、速さは変わらない。ブローカー（TCP）の後ろでは
 client ではなくブローカーが行う。シリアルの口は、ドライバにあれば low-latency のモードで開く（FTDI の latency timer 16 → 1 ms で
 UART bridge の速度が 3 倍になった）。ボードの起動時の速さが 115200 でなければ `open_host(..., baud=)` で渡す。

{oep_client_python-0.0.24 → oep_client_python-0.0.25}/README.md

@@ -107,7 +107,10 @@ but not 1500000 towards the host: oep-spec docs/uart-speed-negotiation.ja.md), s
 (`link.speed`: `rate`, `chosen`, `in_kb_s` / `out_kb_s`, `trials`) is there to budget a capture or a write.
 
 The probe goes back to the boot speed by itself when the session ends (`end`, a lapse, a force), when frames break or the
-line goes quiet (`idle_ms`): the link follows an `end` at once, and a request that goes unanswered at a raised rate (its
+line goes quiet (`idle_ms`, at most `port_speed_idle_max_ms` = 3 s; a host that died leaves the rate no longer than
+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
 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

{oep_client_python-0.0.24 → oep_client_python-0.0.25}/pyproject.toml

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

{oep_client_python-0.0.24 → oep_client_python-0.0.25}/src/oep_client/__init__.py

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

{oep_client_python-0.0.24 → oep_client_python-0.0.25}/src/oep_client/endpoint.py

@@ -36,7 +36,8 @@ define:
 - port_speed (core §3.5, optional): on when the profile's describe declares it (`port_speed_base`, the boot speed;
   None = off: the op is unknown_operation). try / commit / revert on the UART bridge the request came in on (else
   unavailable cause 6), a rate the fake UART cannot make (outside 300..5000000) unsupported; a try reverts after
-  verify_ms without a commit or at a broken candidate, a commit after idle_ms with no good frame or 3 broken
+  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).
 
@@ -321,6 +322,7 @@ class BrokenRate:
 PORT_SPEED_TAG = reg.CORE.tlv["describe"]["port_speed"]
 OP_PORT_SPEED = reg.CORE.op["port_speed"]
 SPEED_STEP = reg.CORE.enum["port_speed_step"]
+SPEED_IDLE_MAX_MS = reg.TIMING["port_speed_idle_max_ms"]   # committed: idle_ms at most this (0 and longer: this)
 SPEED_BAD_MAX, SPEED_BAD_WINDOW_MS = 3, 1000       # committed: this many broken candidates within the window revert
 SPEED_RATES = (300, 5_000_000)                     # what the fake's UART makes (anything between, exactly)
 
@@ -472,7 +474,7 @@ class Endpoint:
         self.speed_rate = 0                            # the rate it runs at
         self.speed_asked = 0                           # the baud the try asked (the commit names it again)
         self.speed_until_ms = 0                        # try: the commit's deadline (verify_ms)
-        self.speed_idle_ms = 0                         # committed: revert after this long with no good frame (0 never)
+        self.speed_idle_ms = 0                         # committed: revert after this long with no good frame
         self.speed_good_ms = 0                         # the last good frame on that port
         self.speed_bad: list[int] = []                 # committed: the times of the recent broken candidates
         self.speed_pending: tuple | None = None        # ("switch", port, baud, verify_ms) / ("revert",): after the answer
@@ -1203,7 +1205,7 @@ class Endpoint:
             if self.speed_state == "base" or port != self.speed_port or baud != self.speed_asked:
                 raise unavailable("wrong_state")                   # nothing tried, or another baud
             self.speed_state = "committed"
-            self.speed_idle_ms = idle_ms
+            self.speed_idle_ms = idle_ms if 0 < idle_ms <= SPEED_IDLE_MAX_MS else SPEED_IDLE_MAX_MS
             self.speed_good_ms = self.now()
             self.speed_bad.clear()
             return self._answer(struct.pack("<I", self.speed_rate), ignored)
@@ -1264,7 +1266,7 @@ class Endpoint:
         now = self.now()
         if self.speed_state == "try" and now >= self.speed_until_ms:
             self._speed_revert()                                   # no commit within verify_ms
-        elif self.speed_state == "committed" and self.speed_idle_ms and now - self.speed_good_ms >= self.speed_idle_ms:
+        elif self.speed_state == "committed" and now - self.speed_good_ms >= self.speed_idle_ms:
             self._speed_revert()
 
     def _page(self, tlvs: list[bytes], first: int) -> bytes:

{oep_client_python-0.0.24 → oep_client_python-0.0.25}/src/oep_client/link.py

@@ -26,6 +26,10 @@ transfer both ways (link_source / link_sink with max_frame-sized frames) that co
 throughput, 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.
+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
+host that raised the speed and died leaves the probe at its rate until then.
 """
 
 from __future__ import annotations
@@ -55,6 +59,10 @@ class PortBusy(OSError):
 
 
 BASE_BAUD = 115200   # the boot speed of every reference UART bridge (the board's profile decides; core §3.5)
+IDLE_MAX_MS = reg.TIMING["port_speed_idle_max_ms"]   # a committed rate goes back after this with no good frame (§3.5)
+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)
 
 
 def open_serial(port: str, baud: int = BASE_BAUD):
@@ -158,6 +166,8 @@ class SerialLink:
         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.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)
         self.held = lambda: False                  # a session holds the port (its raw transfer stopped): broken = resend
         self.blind = lambda: []                    # the host's blind stops (unsubscribe / end) once bound
         self._corr_n = 0x8000
@@ -178,6 +188,7 @@ class SerialLink:
             self.frames.send_many(messages)
         else:
             self.stream.write(b"".join(cobs.frame(msg) for msg in messages))
+        self.last_tx = time.monotonic()
 
     def _recv(self) -> bytes:
         if self.framing == "length":
@@ -250,10 +261,17 @@ class SerialLink:
         n = 0
         try:
             while True:
+                if self._raised():                 # a long pump at a raised rate keeps the line alive (core §3.5)
+                    self.timeout = saved
+                    self._keep_raised()
                 self.timeout = max(0.0, deadline - time.monotonic())
+                if self._raised():
+                    self.timeout = min(self.timeout, KEEPALIVE_S)
                 try:
                     frame = self._recv()
                 except TimeoutError:
+                    if self._raised() and time.monotonic() < deadline:
+                        continue
                     return n
                 except FramingLost:
                     self.timeout = saved
@@ -307,6 +325,7 @@ class SerialLink:
             self.resync()
 
     def send(self, message: bytes) -> bytes:
+        self._keep_raised()
         try:
             reply = self._send(message)
         except TimeoutError:
@@ -355,6 +374,7 @@ class SerialLink:
         answered go once more with the same corr (oep-core §5.2: the probe answers a repeat from what it kept); a second
         failure is raised.
         """
+        self._keep_raised()
         replies: list[bytes] = []
         try:
             return self._exchange_once(messages, max_inflight, window_bytes, replies)
@@ -397,6 +417,15 @@ class SerialLink:
         finally:
             self.timeout = saved
 
+    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)."""
+        deadline = time.monotonic() + wait_s
+        while True:
+            if self.confirm_raw(each_s):
+                return True
+            if time.monotonic() >= deadline:
+                return False
+
     def back_to_base(self, wait_s: float = 3.0) -> bool:
         """The host at the boot speed again, and the probe confirmed there: confirms every 0.25 s up to `wait_s` (a
         probe still trying waits out its verify_ms; one committed reverts at the broken candidates these make)."""
@@ -404,12 +433,31 @@ class SerialLink:
         if self.base_baud is None:
             return False
         self.set_baud(self.base_baud)
-        deadline = time.monotonic() + wait_s
-        while True:
-            if self.confirm_raw(0.25):
-                return True
-            if time.monotonic() >= deadline:
-                return False
+        return self._confirm_within(wait_s, 0.25)
+
+    def _raised(self) -> bool:
+        return self.base_baud is not None and self.baud != self.base_baud
+
+    def keep_alive(self) -> bool:
+        """While a raised rate is in force and a session holds the port: a keepalive when the link has been quiet for
+        KEEPALIVE_S (1 s). The probe goes back to the boot speed after port_speed_idle_max_ms (3 s) with no good frame
+        (core §3.5); every request already does this before it goes out, so only a caller that sits idle for long
+        (waiting on a person, a sleep between requests) calls it - often is fine, it sends nothing otherwise.
+        True when a keepalive went out."""
+        if not self._raised() or self.keepalive_frame is None or not self.held():
+            return False
+        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())
+        return True
+
+    def _keep_raised(self) -> None:
+        """keep_alive before a request; a keepalive that fails is left to the request itself to find out."""
+        try:
+            self.keep_alive()
+        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
@@ -461,12 +509,23 @@ 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()
         hst.link = self
+        if self.framing == "cobs" and getattr(self, "transport", None) == "serial":
+            self.wait_boot_speed()
         limits = hst.confirm()
         hst.exchange = self.bind(limits)
         if self.framing == "length" and limits.get("max_frame"):
             self.frames.max_frame = limits["max_frame"]
 
+    def wait_boot_speed(self, wait_s: float | None = None) -> None:
+        """A serial port just opened: confirm at the boot speed, retried for OPEN_RETRY_S (port_speed_idle_max_ms and
+        a second; at least the link's timeout) - a host that raised the speed and died leaves the probe at that rate
+        until its idle limit runs out (core §3.5 item 6). TimeoutError when none was answered."""
+        wait_s = max(OPEN_RETRY_S, self.timeout) if wait_s is None else wait_s
+        if not self._confirm_within(wait_s, min(self.timeout, OPEN_TRY_S)):
+            raise TimeoutError(f"no answer to confirm at {self.baud} for {wait_s:.1f} s")
+
     def close(self) -> None:
         self.stream.close()
 
@@ -736,7 +795,7 @@ 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 = 0, port: int | None = None) -> SpeedReport:
+                verify_ms: int | None = None, idle_ms: int = IDLE_MAX_MS, port: int | None = None) -> 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) ->
@@ -745,7 +804,8 @@ def raise_speed(hst, rates: list[int], *, verify_bytes: int = 32768, verify_s: f
     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 (0: never; it reverts at the session's end anyway).
+    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`."""
     lk = getattr(hst, "link", None)
     base = getattr(lk, "base_baud", None)
@@ -766,6 +826,7 @@ def raise_speed(hst, rates: list[int], *, verify_bytes: int = 32768, verify_s: f
     report.supported = True
     wait = (verify_ms if verify_ms is not None else min(65535, int(verify_s * 1000) + 1500))
     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)
     finally:

{oep_client_python-0.0.24 → oep_client_python-0.0.25}/src/oep_client/registry.py

@@ -2,7 +2,7 @@
 
 from types import SimpleNamespace as _NS
 
-REGISTRY_HASH = "1043a67bfcb96a43"
+REGISTRY_HASH = "f98b4992f5b8ebe7"
 SCHEMA = 1
 PROTOCOL_REVISION = 1
 CONFIRM_REQUEST_MAGIC = 'OEP?'
@@ -20,7 +20,7 @@ OUTCOMES = {"success": 0x00, "failed": 0x01, "partial": 0x02}
 REJECT_REASONS = {"unknown_function": 0x01, "unknown_operation": 0x02, "malformed": 0x03, "unavailable": 0x04, "busy": 0x05, "window_exceeded": 0x06, "no_session": 0x07, "locked": 0x08, "session_required": 0x09, "no_connection": 0x0A, "unsupported": 0x0B, "result_lost": 0x0C, "corr_reused": 0x0D, "expired": 0x0E}
 STATUS = {"ok": 0x00, "wait": 0x01, "line": 0x02, "fault": 0x03, "timeout": 0x04, "state": 0x05}
 DESCRIBE_COMMON = {"role_channels": 0x01, "max_clock_hz": 0x02, "max_length": 0x03, "min_clock_hz": 0x05, "features": 0x06, "implementation": 0x07, "channel_group": 0x08}
-TIMING = {"resync_quiet_ms": 0x32, "probe_frame_gap_ms": 0xC8, "host_frame_pause_max_ms": 0x64, "heartbeat_default_ms": 0x3E8}
+TIMING = {"resync_quiet_ms": 0x32, "probe_frame_gap_ms": 0xC8, "host_frame_pause_max_ms": 0x64, "heartbeat_default_ms": 0x3E8, "port_speed_idle_max_ms": 0xBB8}
 USB = {"iproduct_prefix": 'OEP', "vendor_bulk_class": 0xFF, "vendor_bulk_subclass": 0x4F, "vendor_bulk_protocol": 0x45, "hid_usage_page": 0xFF4F, "hid_usage": 0x45, "reference_vid": 0x1209, "reference_pid": 0x4F45}
 LIMITS = {"lease_min_ms": 0x3E8, "lease_max_ms": 0xEA60, "owner_max_bytes": 0x20, "unit_id_max_bytes": 0x20, "slot_name_max_bytes": 0x20, "interface_name_max_bytes": 0x40, "max_op_ms_reference": 0x2710}
 COMMON = _NS(enum={"read_from": {"position": 0x00, "oldest": 0x01, "now": 0x02, "last_mark": 0x03}, "read_flags": {"more": 0x01, "gap": 0x02}, "mark_kind": {"reset": 0x01, "restart": 0x02, "attach": 0x03, "detach": 0x04, "lost": 0x05, "clear": 0x06, "host": 0x07, "link_lost": 0x08, "closed": 0x09}, "mark_detail_reset": {"ndmreset": 0x01, "nrst": 0x02, "attach_reset": 0x03}, "mark_detail_restart": {"havereset": 0x01, "resync": 0x02}, "mark_detail_lost": {"overflow": 0x01, "framing": 0x02, "parity": 0x03, "target_timeout": 0x04}, "mark_detail_closed": {"all_released": 0x01, "expired": 0x02, "slot_changed": 0x03, "connection_closed": 0x04}})

{oep_client_python-0.0.24 → oep_client_python-0.0.25}/tests/test_port_speed.py

@@ -87,8 +87,22 @@ def test_try_then_commit_answered_at_the_old_speed():
     assert r.detail == m.UNAVAILABLE and r.payload[:3] == bytes([0x01, 1, 6])
     r = p.send(0, PS, ps(0, 1500000, COMMIT), sid)
     assert r.succeeded and p.ep.speed_state == "committed"
-    p.tick(10_000)                                                              # idle_ms 0: no idle revert
+    p.tick(endpoint.SPEED_IDLE_MAX_MS - 1)                                      # idle_ms 0: the maximum, not never
     assert p.ep.port_baud(0) == 1500000
+    p.tick(1)
+    assert p.ep.port_baud(0) == 115200
+
+
+def test_a_long_idle_ms_is_clamped_to_the_maximum():
+    p = Port()
+    sid = opened(p)
+    p.send(0, PS, ps(0, 500000, TRY), sid)
+    assert p.send(0, PS, ps(0, 500000, COMMIT, 0, 600_000), sid).succeeded
+    assert p.ep.speed_idle_ms == endpoint.SPEED_IDLE_MAX_MS == 3000
+    p.tick(2999)
+    assert p.ep.port_baud(0) == 500000
+    p.tick(1)
+    assert p.ep.port_baud(0) == 115200
 
 
 def test_try_times_out_and_a_late_commit_is_wrong_state():
@@ -235,6 +249,67 @@ def test_a_revert_seen_as_a_timeout_goes_back_to_the_boot_speed():
     assert lk.baud == 115200 and lk.speed_lost == 1 and lk.speed.lost and lk.speed.rate == 115200
 
 
+def test_raise_speed_commits_the_idle_maximum_by_default():
+    ep, hst, lk = in_process()
+    link.raise_speed(hst, [750000], **FAST)
+    assert ep.speed_idle_ms == link.IDLE_MAX_MS == 3000
+    link.raise_speed(hst, [500000], idle_ms=0, **FAST)          # 0: the maximum too
+    assert ep.speed_idle_ms == 3000
+
+
+def test_a_raised_link_keeps_the_line_alive_when_quiet():
+    ep, hst, lk = in_process()
+    link.raise_speed(hst, [750000], **FAST)
+    sent = []
+    frame = lk.keepalive_frame
+    lk.keepalive_frame = lambda: sent.append(1) or frame()
+    assert not lk.keep_alive()                                  # just spoke: nothing to do
+    for _ in range(3):                                          # 3.6 s in all, past the probe's idle limit
+        time.sleep(1.2)
+        assert lk.keep_alive()
+    ep.tick()
+    assert ep.port_baud(0) == 750000 and len(sent) == 3
+    time.sleep(1.2)
+    hst.request(0, m.OP_LOCK_STATE, locked=False)               # a request after 1 s of quiet: a keepalive first
+    assert len(sent) == 4 and lk.baud == 750000 and lk.speed_lost == 0
+    hst.end()
+    time.sleep(1.2)
+    assert not lk.keep_alive()                                  # back at the boot speed: none
+
+
+def second_host(ep):
+    lk = link.SerialLink.on_stream(fake_serial.FakeSerialStream(ep, 0), "cobs", 0.5)
+    lk.transport = "serial"
+    hst = h.Host(lk.send)
+    t0 = time.monotonic()
+    lk.attach_host(hst)
+    return hst, lk, time.monotonic() - t0
+
+
+def test_open_waits_out_a_raised_rate_a_host_that_died_left():
+    ep, hst, lk = in_process()
+    link.raise_speed(hst, [750000], **FAST)                     # this host dies here, its lease long
+    hst2, lk2, took = second_host(ep)                           # the confirms at 115200 are broken candidates: reverts
+    assert ep.port_baud(0) == 115200 and lk2.baud == 115200 and took < link.OPEN_RETRY_S
+    hst2.confirm()
+
+
+def test_open_waits_for_the_idle_limit_when_broken_candidates_do_not_revert():
+    ep, hst, lk = in_process()
+    link.raise_speed(hst, [750000], **FAST)
+    heard = ep.speed_frame
+    ep.speed_frame = lambda port, good: heard(port, good) if good else None   # only the idle limit takes it back
+    hst2, lk2, took = second_host(ep)
+    assert ep.port_baud(0) == 115200 and 2.5 < took < link.OPEN_RETRY_S + 1.5
+    ep2, hst3, lk3 = in_process()
+    link.raise_speed(hst3, [750000], **FAST)
+    ep2._speed_revert = lambda: None                            # never comes back: the open gives up
+    lk4 = link.SerialLink.on_stream(fake_serial.FakeSerialStream(ep2, 0), "cobs", 0.5)
+    lk4.corr_source = lambda: 7
+    with pytest.raises(TimeoutError):
+        lk4.wait_boot_speed(0.6)
+
+
 def test_an_off_probe_is_not_supported_and_stays_at_the_boot_speed(monkeypatch):
     ep, hst, lk = in_process()
     ep.port_speed_base = None