aioebus 0.2.1__tar.gz → 0.2.2__tar.gz

{aioebus-0.2.1 → aioebus-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aioebus
-Version: 0.2.1
+Version: 0.2.2
 Summary: Standalone async eBUS library (decode-first). No ebusd daemon required.
 Author-email: dneprojects <dne.projects.1@gmail.com>
 License-Expression: Apache-2.0

{aioebus-0.2.1 → aioebus-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "aioebus"
-version = "0.2.1"
+version = "0.2.2"
 description = "Standalone async eBUS library (decode-first). No ebusd daemon required."
 readme = "README.md"
 requires-python = ">=3.11"

{aioebus-0.2.1 → aioebus-0.2.2}/src/aioebus/__init__.py

@@ -64,4 +64,4 @@ __all__ = [
     "unescape",
     "value_key",
 ]
-__version__ = "0.2.1"
+__version__ = "0.2.2"

{aioebus-0.2.1 → aioebus-0.2.2}/src/aioebus/active.py

@@ -95,6 +95,7 @@ class _CommandDriver:
         self.done = False
         self.result = None
         self.error: str | None = None
+        self.lost_to: int | None = None  # winning master address when arbitration is lost
 
     def start(self) -> list[bytes]:
         """Initial symbols to send: the arbitration START with QQ."""
@@ -125,6 +126,7 @@ class _CommandDriver:
                 self._state = "cmd"
                 return self._send_next_cmd()
             if code == FAILED:
+                self.lost_to = data  # the master that won the bus (for passive capture)
                 return self._fail(f"arbitration lost to {data:#04x}")
             return []  # ignore SYN/other while waiting to win
 

{aioebus-0.2.1 → aioebus-0.2.2}/src/aioebus/engine.py

@@ -196,6 +196,15 @@ class EbusEngine:
             if act.future is not None and not act.future.done():
                 act.future.set_result(drv.result)
             return
+        # We lost the bus to another master: capture ITS telegram passively instead
+        # of discarding it. The arbitration consumed only the winner's address byte
+        # (reported as drv.lost_to); the rest of its telegram is still arriving, and
+        # now that _active is clear those bytes route to the passive buffer -- so
+        # seed the buffer with the winner's address and the next SYN decodes the
+        # whole telegram (a broadcast, or another master's read incl. the slave part).
+        lost_to = getattr(drv, "lost_to", None)
+        if isinstance(lost_to, int) and not self._buf:
+            self._buf.append(lost_to)
         # error: retry a lost/contended bus (rebuild a fresh driver), else give up
         retryable = "arbitration lost" in drv.error or "collision" in drv.error
         if retryable and act.attempts < self.MAX_ATTEMPTS:
@@ -205,8 +214,8 @@ class EbusEngine:
             act.future.set_exception(ReadError(drv.error))
         elif act.msg is not None and self.scheduler is not None:
             # a poll the device did not answer (NAK/timeout): record the attempt
-            # so it waits its normal interval before retrying. Without this its
-            # timer stays at zero, so it is forever the most-overdue item and the
-            # scheduler keeps handing back the same unanswered register, starving
-            # every other register behind it.
-            self.scheduler.mark_passive(act.msg, time.monotonic())
+            # and back it off. Without recording it, its timer stays at zero so it
+            # is forever the most-overdue item and the scheduler keeps re-handing
+            # the same dead register, starving the rest; the backoff then fades a
+            # persistently unanswered register out of the rotation entirely.
+            self.scheduler.mark_failure(act.msg, time.monotonic())

{aioebus-0.2.1 → aioebus-0.2.2}/src/aioebus/poll.py

@@ -38,10 +38,13 @@ if TYPE_CHECKING:
 class PollItem:
     msg: MessageDef
     priority: int
-    last_update: float = field(default=0.0)  # last value time (poll OR passive)
+    last_update: float = field(default=0.0)  # last attempt time (value OR failed poll)
+    fails: int = 0  # consecutive unanswered polls; backs the interval off
 
 
 class PollScheduler:
+    MAX_BACKOFF: int = 5  # a dead register backs off up to 2**5 = 32x its interval
+
     def __init__(self, messages: list[MessageDef], base_interval: float = 60.0,
                  default_priority: int = 0):
         """``default_priority`` is the priority given to plain ``r`` reads (0 =
@@ -68,17 +71,29 @@ class PollScheduler:
                    default_priority=default_priority)
 
     def interval(self, item: PollItem) -> float:
-        return self.base_interval * item.priority
+        # a register the device keeps not answering is polled exponentially less
+        # often, so dead registers stop stealing bus slots from answering ones
+        return self.base_interval * item.priority * (1 << min(item.fails, self.MAX_BACKOFF))
 
     def mark(self, zz: str, name: str, now: float) -> None:
-        """Record that a fresh value arrived (from a poll or passively)."""
+        """Record that a fresh value arrived (from a poll or passively); clears
+        any backoff."""
         item = self._items.get((zz, name))
         if item is not None:
             item.last_update = now
+            item.fails = 0
 
     def mark_passive(self, msg: MessageDef, now: float) -> None:
         self.mark(msg.zz, msg.name, now)
 
+    def mark_failure(self, msg: MessageDef, now: float) -> None:
+        """Record that a poll went unanswered: keep it from being re-handed
+        immediately, and back its interval off so it fades out of the rotation."""
+        item = self._items.get((msg.zz, msg.name))
+        if item is not None:
+            item.last_update = now
+            item.fails += 1
+
     def next_due(self, now: float) -> PollItem | None:
         """The single most-overdue message to read now, or None if none is due.
         Overdue-ness is measured relative to each item's own interval, so a

{aioebus-0.2.1 → aioebus-0.2.2}/src/aioebus.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aioebus
-Version: 0.2.1
+Version: 0.2.2
 Summary: Standalone async eBUS library (decode-first). No ebusd daemon required.
 Author-email: dneprojects <dne.projects.1@gmail.com>
 License-Expression: Apache-2.0

{aioebus-0.2.1 → aioebus-0.2.2}/tests/test_engine.py

@@ -1,6 +1,7 @@
 """Unified engine: passive decode caches values, and explicit active reads are
 interleaved at bus idle. Driven by a fake async link (no pytest-asyncio)."""
 import asyncio
+import contextlib
 
 from aioebus.active import ACK, SEND, START, build_read_frame
 from aioebus.engine import EbusEngine, _Active, value_key
@@ -9,6 +10,7 @@ from aioebus.messages import parse_csv
 from aioebus.passive import MessageRegistry
 from aioebus.poll import PollScheduler
 from aioebus.transport import (
+    FAILED,
     RECEIVED,
     STARTED,
     SYN,
@@ -22,6 +24,7 @@ type,circuit,level,name,comment,qq,zz,pbsb,id,*name,part,type,divisor/values,uni
 *r,elo,,,,,38
 r1,,,FlowTemp,,,,b509,0d1800,value,,D2C,,°C,,ign,,IGN:1,,,
 r1,,,Statenumber,,,,b509,0dab00,value,,UCH,0=kein_bedarf;31=sommer,,
+u,bc,,Outsidetemp,,,fe,b516,01,value,,D2B,,°C,
 """
 REG = MessageRegistry(parse_csv(CSV))
 BY = {m.name: m for m in parse_csv(CSV)}
@@ -89,6 +92,51 @@ def test_passive_decode_caches():
     asyncio.run(inner())
 
 
+class _ArbLossAdapter:
+    """On our arbitration START, reply FAILED(winner) then the winner's telegram
+    (minus its already-arbitrated first byte) and a closing SYN."""
+
+    def __init__(self, winner: int, rest_hex: str):
+        self.winner, self.rest, self._dec = winner, bytes.fromhex(rest_hex), EnhDecoder()
+        self.fired = False
+
+    def on_send(self, sent: bytes) -> bytes:
+        out = bytearray()
+        for code, _data in self._dec.feed(sent):
+            if code == START and not self.fired:
+                self.fired = True
+                out += encode_symbol(FAILED, self.winner)
+                for b in self.rest:
+                    out += encode_symbol(RECEIVED, b)
+                out += encode_symbol(RECEIVED, SYN)
+        return bytes(out)
+
+
+def test_arbitration_loss_captures_winner_passively():
+    """When our poll loses arbitration, the telegram that won is decoded
+    passively (seeded with the winner's address) instead of being discarded."""
+    async def inner():
+        link = _Link()
+        # real outside-temp broadcast 10 fe b509... -> here b516 01 c0 0d (13.75 C);
+        # winner 0x10, rest is the telegram without its leading (arbitrated) 0x10
+        link.adapter = _ArbLossAdapter(0x10, "feb5160301c00d12")
+        eng = EbusEngine(link.send, link.recv, REG)
+        task = asyncio.create_task(eng.run())
+        rtask = asyncio.create_task(eng.read(BY["Statenumber"], timeout=0.2))
+        await asyncio.sleep(0)
+        link.inject(encode_symbol(RECEIVED, SYN))  # idle -> our read starts -> loses arbitration
+        await asyncio.sleep(0.05)
+        assert eng.cache.get(value_key(BY["Outsidetemp"], "Outsidetemp")) == 13.75
+        rtask.cancel()
+        eng.stop()
+        link.inject(b"")
+        with contextlib.suppress(asyncio.CancelledError, TimeoutError):
+            await asyncio.wait_for(rtask, 0.5)
+        await asyncio.wait_for(task, 1)
+
+    asyncio.run(inner())
+
+
 def test_failed_poll_is_recorded_not_restuck():
     """A poll the device does not answer must update its scheduler timer, so the
     scheduler moves on instead of handing back the same dead register forever

{aioebus-0.2.1 → aioebus-0.2.2}/tests/test_poll.py

@@ -38,6 +38,19 @@ def test_priority_sets_interval():
     assert sch.next_due(60.0).msg.name == "Fast"
 
 
+def test_failed_poll_backoff():
+    sch = PollScheduler(MSGS, base_interval=10.0)
+    fast = next(m for m in MSGS if m.name == "Fast")  # r1 -> base interval 10
+    item = sch._items[("38", "Fast")]
+    assert sch.interval(item) == 10.0
+    sch.mark_failure(fast, now=0.0)
+    assert sch.interval(item) == 20.0          # 2x after one unanswered poll
+    sch.mark_failure(fast, now=0.0)
+    assert sch.interval(item) == 40.0          # 4x
+    sch.mark_passive(fast, now=0.0)            # a value clears the backoff
+    assert sch.interval(item) == 10.0
+
+
 def test_passive_update_suppresses_poll():
     sch = PollScheduler(MSGS, base_interval=10.0)
     assert sch.next_due(12.0).msg.name == "Fast"   # Fast would be polled at t=12