Honor --timeout precisely with non-blocking recv polling (#42)

The wait loop polled every rx_stack with recv(block=True, timeout=0.01).
With ~249 stacks per sweep (11bits functional, 29bits broadcast) the
user-supplied --timeout was effectively rounded up to a multiple of
~2.5 seconds; --timeout 1 did not bound the wait at one second.

Switch to recv(block=False) with a 1 ms sleep between sweeps. An empty
sweep over 249 stacks now takes microseconds and the deadline is
honored within ~1 ms granularity. No semantic change to message
handling: recv(block=False) returns exactly the same payloads as the
blocking form when data is available.

Also: time.time() -> time.monotonic() for the duration measurement
(immune to wall-clock adjustments), drop the now-redundant `waiting`
sentinel in favor of `payload is None`, and remove the `# TODO: #42`
marker now that this change resolves it.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: Nakakiyo092

src/reader.py

@@ -267,30 +267,26 @@ def _read_did(did, tx_stack, rx_stacks, addr_type, mode_label,
     tx_stack.send(request.get_payload(), addr_type)
 
     try:
-        # Wait for response
-        waiting = True
-        start_time = time.time()
-        while waiting:
-            # Response timeout
-            if time.time() - start_time > timeout:
-                payload = None
-                break
-
-            # Check response for all stacks
+        # Wait for response.
+        # Non-blocking recv(): a sweep over hundreds of rx_stacks takes microseconds
+        # when empty, so the user-supplied timeout is honored within ~1 ms granularity.
+        # monotonic() is immune to wall-clock adjustments mid-wait.
+        payload = None
+        deadline = time.monotonic() + timeout
+        while payload is None and time.monotonic() < deadline:
             for rx_stack in rx_stacks:
-                # TODO: #42
-                payload = rx_stack.recv(block=True, timeout=0.01)
-                if payload is not None:
-                    # Compare only the header portion of the received payload against
-                    # the expected positive-response bytes. The remainder is data.
-                    if payload[:len(response)] == response.get_payload():
-                        # Positive response
-                        waiting = False
-                        break
-                    else:
-                        # No Negative response handling. See the DESIGN.md.
-                        pass
-
+                received = rx_stack.recv(block=False)
+                if received is None:
+                    continue
+                # Compare only the header portion of the received payload against
+                # the expected positive-response bytes. The remainder is data.
+                if received[:len(response)] == response.get_payload():
+                    # Positive response
+                    payload = received
+                    break
+                # Non-matching payload (e.g., negative response). See DESIGN.md.
+            if payload is None:
+                time.sleep(0.001)
     except Exception as err:
         print(err)
         return None