fix: support firmware that terminates streaming events with bare CR

Newer DwarfG2 v2 firmware (1.99.5+) terminates +CINV continuous-inventory
events with a bare \r (no LF), while readuntil(b"\n") would block
indefinitely waiting for an LF that never arrives. The watchdog would
then trip after 5s and the reader would never produce inventory events
in practice.

Changes:
- SerialConnection._work: replace fixed \n delimiter with byte-by-byte
  line splitter that accepts \r, \n, or \r\n.
- _send_command: accumulate response lines as a list (each line now
  arrives as its own _recv call instead of one blob to split on \r).
- _send_command (echo path): when a failed command is not echoed,
  drain the trailing ERROR terminator and surface the parsed +ERR:/+CMD:
  error frame instead of leaking it into the next command's buffer.
- start_inventory: default timeout 4.0 -> 5.0.
- _check_connection: poll every 100ms while inventory is active so the
  watchdog deadline is honoured precisely instead of padded by the
  general 1s connection-check interval. Reword reset messages to
  "continuous inventory timeout - self reset" / "connection test
  failed - self reset" so they no longer suggest a hardware fault.

Author: klaasdannen

metratec_rfid/__init__.py

@@ -8,7 +8,7 @@
 # from .connection.serial_connection import SerialConnection
 # from .connection.socket_connection import SocketConnection
 
-__version__ = "1.4.4"
+__version__ = "1.4.5"
 __email__ = "neumann@metratec.com"
 __license__ = "MIT License"
 __author__ = "Matthias Neumann"

metratec_rfid/connection/serial_connection.py

@@ -160,14 +160,28 @@ async def _work(self) -> None:
         while self._is_started:
             if not self._writer:
                 await self._connect()
+            # Accumulate bytes and split on any of \r, \n, or \r\n. Some firmware
+            # versions terminate continuous-inventory events with bare \r (no LF),
+            # so a fixed \n delimiter would block forever waiting for an LF that
+            # never arrives.
+            line_buffer = bytearray()
             while self._writer:
                 # disable Catching too general exception Exception - pylint: disable=W0703
                 try:
                     while self._reader:
-                        msg: bytes = await self._reader.readuntil(self._separator_encoded)
-                        # self._logger.debug("data received (config) %s",
-                        #         msg.decode().replace("\r", "<CR>").replace("\n", "<LF>"))
-                        self.data_received(msg[:-1])
+                        chunk: bytes = await self._reader.read(4096)
+                        if not chunk:
+                            # peer closed; let outer loop reconnect
+                            break
+                        for byte in chunk:
+                            if byte in (0x0d, 0x0a):  # \r or \n -> end of line
+                                if line_buffer:
+                                    # Append \r to keep the legacy contract:
+                                    # downstream handlers strip one trailing byte.
+                                    self.data_received(bytes(line_buffer) + b'\r')
+                                    line_buffer.clear()
+                            else:
+                                line_buffer.append(byte)
                 except serial.SerialException as err:
                     # print("exception consumed")
                     try:

metratec_rfid/reader.py

@@ -456,11 +456,18 @@ def _set_last_inventory_time(self, last_inventory_time: float):
     async def _check_connection(self) -> None:
         """Check the connection - reconnect the device if no messages have been received for a while
         """
+        # Tight polling while continuous inventory is active so the watchdog
+        # fires at the configured deadline (not up to one full check_interval later).
+        inventory_check_interval = 0.1
         while self.get_status()['status'] >= 1:
-            await asyncio.sleep(self._connection_check_interval)
+            sleep_time = (
+                inventory_check_interval if self._continuous_inventory_check_time
+                else self._connection_check_interval
+            )
+            await asyncio.sleep(sleep_time)
             if self._continuous_inventory_check_time:
                 if self._last_inventory_time + self._continuous_inventory_check_time < time():
-                    msg = "continuous inventory problem - reset"
+                    msg = "continuous inventory timeout - self reset"
                     break
             if self._last_message_time + self._connection_check_time >= time():
                 continue
@@ -472,9 +479,9 @@ async def _check_connection(self) -> None:
             # pylint: disable=broad-exception-caught
             except Exception as err:
                 self._logger.debug("connection check fails - %s", err)
-                msg = 'connection lost'
+                msg = 'connection test failed - self reset'
                 break
-        # connection lost or continuous inventory missing
+        # connection test failed or continuous inventory missing
         self._update_status(self.ERROR, msg)
         try:
             # await self.disconnect()

metratec_rfid/reader_at.py

@@ -75,7 +75,7 @@ async def get_antenna(self) -> int:
                 f"Not expected response for command AT+ANT? - {response}") from exc
 
     # @override
-    async def start_inventory(self, timeout: float = 4.0) -> None:
+    async def start_inventory(self, timeout: float = 5.0) -> None:
         """Start a continuous inventory.
 
         This will cause the reader to perform inventories continuously
@@ -305,26 +305,51 @@ async def _send_command(self, command: str, *parameters: Any, timeout: float = 2
                     msg: str = "Reader not " + ("responding" if self.get_status()["status"] >= 1 else "connected")
                     raise RfidReaderException(msg) from err
                 if send_command not in resp:
+                    # Failed commands are not echoed by the firmware - the first
+                    # line is already the error frame ("+CMD: <Error (xx xx xx xx)>"
+                    # or, on newer firmware, "+ERR: <code: message>"). Drain the
+                    # trailing ERROR terminator so it doesn't leak into the buffer
+                    # and raise the actual reader error instead of a generic one.
+                    if resp.startswith('+'):
+                        try:
+                            terminator = await self._recv(timeout=0.5)
+                        except TimeoutError:
+                            terminator = None
+                        if terminator == 'ERROR':
+                            try:
+                                err_msg = resp[resp.rindex("<") + 1:resp.rindex(">")]
+                            except ValueError:
+                                err_msg = f"{command} ERROR"
+                            raise self._parse_error_response(err_msg)
                     raise RfidReaderException(
                         f"Not expected response for {send_command} - {resp}")
             max_time: float = time() + timeout
-            response: str = ""
+            # Accumulate response lines as a list. Earlier code relied on
+            # multi-line responses arriving in a single read (because the serial
+            # layer used \n as the only line delimiter and the firmware separated
+            # internal lines with \r), then split on \r. With the byte-by-byte
+            # line splitter in SerialConnection each line arrives separately, so
+            # we collect them explicitly here.
+            response: List[str] = []
             try:
                 while True:
                     resp = await self._recv(timeout)
                     if resp is None:
                         break
                     if resp == 'OK':
-                        return response.split("\r") if response else []
+                        return response
                     if resp == 'ERROR':
-                        try:
-                            msg = response[response.rindex(
-                                "<")+1:response.rindex(">")]
-                            raise self._parse_error_response(msg)
-                        except ValueError:
+                        msg: str = ""
+                        for line in reversed(response):
+                            try:
+                                msg = line[line.rindex("<") + 1:line.rindex(">")]
+                                break
+                            except ValueError:
+                                continue
+                        if not msg:
                             msg = f"{command} ERROR"
-                        raise RfidReaderException(str(msg))
-                    response = resp
+                        raise self._parse_error_response(msg)
+                    response.append(resp)
                     if max_time <= time():
                         break
             except TimeoutError:
@@ -333,7 +358,7 @@ async def _send_command(self, command: str, *parameters: Any, timeout: float = 2
                 raise RfidReaderException(
                     f"No reader response for command {send_command}")
             raise RfidReaderException(
-                f"Wrong response for command {send_command} - {str(response)}")
+                f"Wrong response for command {send_command} - {response}")
         except AttributeError as err:
             self.get_logger().debug("send command error - %s", err)
             raise RfidReaderException("Reader not connected") from err

setup.py

@@ -16,7 +16,7 @@
 # This call to setup() does all the work
 setup(
     name="metratec_rfid",
-    version="1.4.4",
+    version="1.4.5",
     description="Metratec RFID SDK",
     long_description=long_description,
     long_description_content_type="text/markdown",