pyxcp 0.23.3__cp312-cp312-win_arm64.whl → 0.25.6__cp312-cp312-win_arm64.whl

pyxcp/transport/base.py

@@ -3,127 +3,50 @@ import abc
 import logging
 import threading
 from collections import deque
-from typing import Any, Dict, Optional, Set, Type
-
+from typing import Any, Dict, Optional, Type
+from pyxcp.timing import Timing
 import pyxcp.types as types
+
 from pyxcp.cpp_ext.cpp_ext import Timestamp, TimestampType
-from pyxcp.recorder import XcpLogFileWriter
-from pyxcp.timing import Timing
+from pyxcp.transport.transport_ext import (
+    FrameCategory,
+    FrameAcquisitionPolicy,
+    LegacyFrameAcquisitionPolicy,
+    XcpFraming,
+    XcpFramingConfig,
+    XcpTransportLayerType,  # noqa: F401
+    ChecksumType,  # noqa: F401
+)
 from pyxcp.utils import (
     CurrentDatetime,
-    flatten,
     hexDump,
     seconds_to_nanoseconds,
     short_sleep,
 )
 
 
-class FrameAcquisitionPolicy:
-    """
-    Base class for all frame acquisition policies.
-
-    Parameters
-    ---------
-    filter_out: set or None
-        A set of frame types to filter out.
-        If None, all frame types are accepted for further processing.
-
-        Example: (FrameType.REQUEST, FrameType.RESPONSE, FrameType.EVENT, FrameType.SERV)
-                  ==> care only about DAQ frames.
-    """
-
-    def __init__(self, filter_out: Optional[Set[types.FrameCategory]] = None):
-        self._frame_types_to_filter_out = filter_out or set()
-
-    @property
-    def filtered_out(self) -> Set[types.FrameCategory]:
-        return self._frame_types_to_filter_out
-
-    def feed(self, frame_type: types.FrameCategory, counter: int, timestamp: int, payload: bytes) -> None: ...  # noqa: E704
-
-    def finalize(self) -> None:
-        """
-        Finalize the frame acquisition policy (if required).
-        """
-        ...
-
-
-class NoOpPolicy(FrameAcquisitionPolicy):
-    """
-    No operation / do nothing policy.
-    """
-
-
-class LegacyFrameAcquisitionPolicy(FrameAcquisitionPolicy):
-    """Dequeue based frame acquisition policy.
-
-    Deprecated: Use only for compatibility reasons.
-    """
-
-    def __init__(self, filter_out: Optional[Set[types.FrameCategory]] = None) -> None:
-        super().__init__(filter_out)
-        self.reqQueue = deque()
-        self.resQueue = deque()
-        self.daqQueue = deque()
-        self.evQueue = deque()
-        self.servQueue = deque()
-        self.metaQueue = deque()
-        self.errorQueue = deque()
-        self.stimQueue = deque()
-        self.QUEUE_MAP = {
-            types.FrameCategory.CMD: self.reqQueue,
-            types.FrameCategory.RESPONSE: self.resQueue,
-            types.FrameCategory.EVENT: self.evQueue,
-            types.FrameCategory.SERV: self.servQueue,
-            types.FrameCategory.DAQ: self.daqQueue,
-            types.FrameCategory.METADATA: self.metaQueue,
-            types.FrameCategory.ERROR: self.errorQueue,
-            types.FrameCategory.STIM: self.stimQueue,
-        }
-
-    def feed(self, frame_type: types.FrameCategory, counter: int, timestamp: int, payload: bytes) -> None:
-        if frame_type not in self.filtered_out:
-            queue = self.QUEUE_MAP.get(frame_type)
-            if queue is not None:
-                queue.append((counter, timestamp, payload))
-
-
-class FrameRecorderPolicy(FrameAcquisitionPolicy):
-    """Frame acquisition policy that records frames."""
-
-    def __init__(
-        self,
-        file_name: str,
-        filter_out: Optional[Set[types.FrameCategory]] = None,
-        prealloc: int = 10,
-        chunk_size: int = 1,
-    ) -> None:
-        super().__init__(filter_out)
-        self.recorder = XcpLogFileWriter(file_name, prealloc=prealloc, chunk_size=chunk_size)
-
-    def feed(self, frame_type: types.FrameCategory, counter: int, timestamp: int, payload: bytes) -> None:
-        if frame_type not in self.filtered_out:
-            self.recorder.add_frame(frame_type, counter, timestamp, payload)
-
-    def finalize(self) -> None:
-        self.recorder.finalize()
-
-
-class StdoutPolicy(FrameAcquisitionPolicy):
-    """Frame acquisition policy that prints frames to stdout."""
-
-    def __init__(self, filter_out: Optional[Set[types.FrameCategory]] = None) -> None:
-        super().__init__(filter_out)
-
-    def feed(self, frame_type: types.FrameCategory, counter: int, timestamp: int, payload: bytes) -> None:
-        if frame_type not in self.filtered_out:
-            print(f"{frame_type.name:8} {counter:6}  {timestamp:8d} {hexDump(payload)}")
-
-
 class EmptyFrameError(Exception):
     """Raised when an empty frame is received."""
 
 
+def parse_header_format(header_format: str) -> tuple:
+    """SxI and USB framing is configurable."""
+    if header_format == "HEADER_LEN_BYTE":
+        return 1, 0, 0
+    elif header_format == "HEADER_LEN_CTR_BYTE":
+        return 1, 1, 0
+    elif header_format == "HEADER_LEN_FILL_BYTE":
+        return 1, 0, 1
+    elif header_format == "HEADER_LEN_WORD":
+        return 2, 0, 0
+    elif header_format == "HEADER_LEN_CTR_WORD":
+        return 2, 2, 0
+    elif header_format == "HEADER_LEN_FILL_WORD":
+        return 2, 0, 2
+    else:
+        raise ValueError(f"Invalid header format: {header_format}")
+
+
 class BaseTransport(metaclass=abc.ABCMeta):
     """Base class for transport-layers (Can, Eth, Sxi).
 
@@ -136,10 +59,17 @@ class BaseTransport(metaclass=abc.ABCMeta):
 
     """
 
-    def __init__(self, config, policy: Optional[FrameAcquisitionPolicy] = None, transport_layer_interface: Optional[Any] = None):
+    def __init__(
+        self,
+        config,
+        framing_config: XcpFramingConfig,
+        policy: Optional[FrameAcquisitionPolicy] = None,
+        transport_layer_interface: Optional[Any] = None,
+    ):
         self.has_user_supplied_interface: bool = transport_layer_interface is not None
         self.transport_layer_interface: Optional[Any] = transport_layer_interface
         self.parent = None
+        self.framing = XcpFraming(framing_config)
         self.policy: FrameAcquisitionPolicy = policy or LegacyFrameAcquisitionPolicy()
         self.closeEvent: threading.Event = threading.Event()
 
@@ -150,7 +80,6 @@ class BaseTransport(metaclass=abc.ABCMeta):
         self._debug: bool = self.logger.level == 10
         if transport_layer_interface:
             self.logger.info(f"Transport - User Supplied Transport-Layer Interface: '{transport_layer_interface!s}'")
-        self.counter_send: int = 0
         self.counter_received: int = -1
         self.create_daq_timestamps: bool = config.create_daq_timestamps
         self.timestamp = Timestamp(TimestampType.ABSOLUTE_TS)
@@ -164,6 +93,7 @@ class BaseTransport(metaclass=abc.ABCMeta):
             target=self.listen,
             args=(),
             kwargs={},
+            daemon=True,
         )
 
         self.first_daq_timestamp: Optional[int] = None
@@ -172,6 +102,13 @@ class BaseTransport(metaclass=abc.ABCMeta):
         self.pre_send_timestamp: int = self.timestamp.value
         self.post_send_timestamp: int = self.timestamp.value
         self.recv_timestamp: int = self.timestamp.value
+        # Ring buffer for last PDUs to aid diagnostics on failures
+        try:
+            from collections import deque as _dq
+
+            self._last_pdus = _dq(maxlen=200)
+        except Exception:
+            self._last_pdus = []
 
     def __del__(self) -> None:
         self.finish_listener()
@@ -185,8 +122,12 @@ class BaseTransport(metaclass=abc.ABCMeta):
     def close(self) -> None:
         """Close the transport-layer connection and event-loop."""
         self.finish_listener()
-        if self.listener.is_alive():
-            self.listener.join()
+        # Avoid indefinite blocking on buggy threads
+        try:
+            if self.listener.is_alive():
+                self.listener.join(timeout=2.0)
+        except Exception:
+            pass
         self.close_connection()
 
     @abc.abstractmethod
@@ -204,7 +145,6 @@ class BaseTransport(metaclass=abc.ABCMeta):
                 raise EmptyFrameError
             short_sleep()
         item = self.resQueue.popleft()
-        # print("Q", item)
         return item
 
     @property
@@ -220,9 +160,14 @@ class BaseTransport(metaclass=abc.ABCMeta):
     def start_listener(self):
         if self.listener.is_alive():
             self.finish_listener()
-            self.listener.join()
+            # Avoid indefinite blocking on buggy threads
+            self.listener.join(timeout=2.0)
+
+        # Ensure the close event is cleared before starting a new listener thread.
+        if hasattr(self, "closeEvent"):
+            self.closeEvent.clear()
 
-        self.listener = threading.Thread(target=self.listen)
+        self.listener = threading.Thread(target=self.listen, daemon=True)
         self.listener.start()
 
     def finish_listener(self):
@@ -234,7 +179,7 @@ class BaseTransport(metaclass=abc.ABCMeta):
             frame = self._prepare_request(cmd, *data)
             self.timing.start()
             with self.policy_lock:
-                self.policy.feed(types.FrameCategory.CMD, self.counter_send, self.timestamp.value, frame)
+                self.policy.feed(FrameCategory.CMD, self.framing.counter_send, self.timestamp.value, frame)
             self.send(frame)
             try:
                 xcpPDU = self.get()
@@ -242,7 +187,10 @@ class BaseTransport(metaclass=abc.ABCMeta):
                 if not ignore_timeout:
                     MSG = f"Response timed out (timeout={self.timeout / 1_000_000_000}s)"
                     with self.policy_lock:
-                        self.policy.feed(types.FrameCategory.METADATA, self.counter_send, self.timestamp.value, bytes(MSG, "ascii"))
+                        self.policy.feed(
+                            FrameCategory.METADATA, self.framing.counter_send, self.timestamp.value, bytes(MSG, "ascii")
+                        ) if self._diagnostics_enabled() else ""
+                    self.logger.debug("XCP request timeout", extra={"event": "timeout", "command": cmd.name})
                     raise types.XcpTimeoutError(MSG) from None
                 else:
                     self.timing.stop()
@@ -251,7 +199,7 @@ class BaseTransport(metaclass=abc.ABCMeta):
             pid = types.Response.parse(xcpPDU).type
             if pid == "ERR" and cmd.name != "SYNCH":
                 with self.policy_lock:
-                    self.policy.feed(types.FrameCategory.ERROR, self.counter_received, self.timestamp.value, xcpPDU[1:])
+                    self.policy.feed(FrameCategory.ERROR, self.counter_received, self.timestamp.value, xcpPDU[1:])
                 err = types.XcpError.parse(xcpPDU[1:])
                 raise types.XcpResponseError(err)
             return xcpPDU[1:]
@@ -283,8 +231,8 @@ class BaseTransport(metaclass=abc.ABCMeta):
             frame = self._prepare_request(cmd, *data)
             with self.policy_lock:
                 self.policy.feed(
-                    types.FrameCategory.CMD if int(cmd) >= 0xC0 else types.FrameCategory.STIM,
-                    self.counter_send,
+                    FrameCategory.CMD if int(cmd) >= 0xC0 else FrameCategory.STIM,
+                    self.framing.counter_send,
                     self.timestamp.value,
                     frame,
                 )
@@ -297,19 +245,7 @@ class BaseTransport(metaclass=abc.ABCMeta):
         if self._debug:
             self.logger.debug(cmd.name)
         self.parent._setService(cmd)
-
-        cmd_len = cmd.bit_length() // 8  # calculate bytes needed for cmd
-        packet = bytes(flatten(cmd.to_bytes(cmd_len, "big"), data))
-
-        header = self.HEADER.pack(len(packet), self.counter_send)
-        self.counter_send = (self.counter_send + 1) & 0xFFFF
-
-        frame = header + packet
-
-        remainder = len(frame) % self.alignment
-        if remainder:
-            frame += b"\0" * (self.alignment - remainder)
-
+        frame = self.framing.prepare_request(cmd, *data)
         if self._debug:
             self.logger.debug(f"-> {hexDump(frame)}")
         return frame
@@ -341,7 +277,14 @@ class BaseTransport(metaclass=abc.ABCMeta):
                 block_response += partial_response[1:]
             else:
                 if self.timestamp.value - start > self.timeout:
-                    raise types.XcpTimeoutError("Response timed out [block_receive].") from None
+                    waited = (self.timestamp.value - start) / 1e9 if hasattr(self.timestamp, "value") else None
+                    msg = f"Response timed out [block_receive]: received {len(block_response)} of {length_required} bytes"
+                    if waited is not None:
+                        msg += f" after {waited:.3f}s"
+                    # Attach diagnostics
+                    # diag = self._build_diagnostics_dump() if self._diagnostics_enabled() else ""
+                    self.logger.debug("XCP block_receive timeout", extra={"event": "timeout"})
+                    raise types.XcpTimeoutError(msg) from None
                 short_sleep()
         return block_response
 
@@ -368,29 +311,47 @@ class BaseTransport(metaclass=abc.ABCMeta):
             self.timer_restart_event.set()
 
     def process_response(self, response: bytes, length: int, counter: int, recv_timestamp: int) -> None:
-        if counter == self.counter_received:
-            self.logger.warning(f"Duplicate message counter {counter} received from the XCP slave")
-            if self._debug:
-                self.logger.debug(f"<- L{length} C{counter} {hexDump(response[:512])}")
-            return
-        self.counter_received = counter
+        # Important: determine PID first so duplicate counter handling can be applied selectively.
         pid = response[0]
+
         if pid >= 0xFC:
+            # Do not drop RESPONSE/EVENT/SERV frames even if the transport counter repeats.
+            # Some slaves may reuse the counter while DAQ traffic is active, and we must not lose
+            # command responses; otherwise request() can stall until timeout.
             if self._debug:
                 self.logger.debug(f"<- L{length} C{counter} {hexDump(response)}")
+            self.counter_received = counter
+            # Record incoming non-DAQ frames for diagnostics
+            self._record_pdu(
+                "in",
+                (FrameCategory.RESPONSE if pid >= 0xFE else FrameCategory.SERV if pid == 0xFC else FrameCategory.EVENT),
+                counter,
+                recv_timestamp,
+                response,
+                length,
+            )
             if pid >= 0xFE:
                 self.resQueue.append(response)
                 with self.policy_lock:
-                    self.policy.feed(types.FrameCategory.RESPONSE, self.counter_received, self.timestamp.value, response)
+                    self.policy.feed(FrameCategory.RESPONSE, self.counter_received, self.timestamp.value, response)
                 self.recv_timestamp = recv_timestamp
             elif pid == 0xFD:
                 self.process_event_packet(response)
                 with self.policy_lock:
-                    self.policy.feed(types.FrameCategory.EVENT, self.counter_received, self.timestamp.value, response)
+                    self.policy.feed(FrameCategory.EVENT, self.counter_received, self.timestamp.value, response)
             elif pid == 0xFC:
                 with self.policy_lock:
-                    self.policy.feed(types.FrameCategory.SERV, self.counter_received, self.timestamp.value, response)
+                    self.policy.feed(FrameCategory.SERV, self.counter_received, self.timestamp.value, response)
         else:
+            # DAQ traffic: Some transports reuse or do not advance the counter for DAQ frames.
+            # Do not drop DAQ frames on duplicate counters to avoid losing measurements.
+            if counter == self.counter_received:
+                self.logger.debug(f"Duplicate message counter {counter} received (DAQ) - not dropping")
+                # DAQ still flowing – reset request timeout window to avoid false timeouts while
+                # the slave is busy but has not yet responded to a command.
+                self.timer_restart_event.set()
+                # Fall through and process the frame as usual.
+            self.counter_received = counter
             if self._debug:
                 self.logger.debug(f"<- L{length} C{counter} ODT_Data[0:8] {hexDump(response[:8])}")
             if self.first_daq_timestamp is None:
@@ -399,8 +360,91 @@ class BaseTransport(metaclass=abc.ABCMeta):
                 timestamp = recv_timestamp
             else:
                 timestamp = 0
+            # Record DAQ frame (only keep small prefix in payload string later)
+            self._record_pdu("in", FrameCategory.DAQ, counter, timestamp, response, length)
+            # DAQ activity indicates the slave is alive/busy; keep extending the wait window for any
+            # outstanding request, similar to EV_CMD_PENDING behavior on stacks that don't emit it.
+            self.timer_restart_event.set()
             with self.policy_lock:
-                self.policy.feed(types.FrameCategory.DAQ, self.counter_received, timestamp, response)
+                self.policy.feed(FrameCategory.DAQ, self.counter_received, timestamp, response)
+
+    def _record_pdu(
+        self,
+        direction: str,
+        category: FrameCategory,
+        counter: int,
+        timestamp: int,
+        payload: bytes,
+        length: Optional[int] = None,
+    ) -> None:
+        try:
+            entry = {
+                "dir": direction,
+                "cat": category.name,
+                "ctr": int(counter),
+                "ts": int(timestamp),
+                "len": int(length if length is not None else len(payload)),
+                "data": hexDump(payload if category != FrameCategory.DAQ else payload[:8])[:512],
+            }
+            self._last_pdus.append(entry)
+        except Exception:
+            pass  # nosec
+
+    def _build_diagnostics_dump(self) -> str:
+        import json as _json
+
+        # transport params
+        tp = {"transport": self.__class__.__name__}
+        cfg = getattr(self, "config", None)
+        # Extract common Eth/Can fields when available
+        for key in (
+            "host",
+            "port",
+            "protocol",
+            "ipv6",
+            "bind_to_address",
+            "bind_to_port",
+            "fd",
+            "bitrate",
+            "data_bitrate",
+            "can_id_master",
+            "can_id_slave",
+        ):
+            if cfg is not None and hasattr(cfg, key):
+                try:
+                    tp[key] = getattr(cfg, key)
+                except Exception:
+                    pass  # nosec
+        last_n = 20
+        try:
+            app = getattr(self.config, "parent", None)
+            app = getattr(app, "parent", None)
+            if app is not None and hasattr(app, "general") and hasattr(app.general, "diagnostics_last_pdus"):
+                last_n = int(app.general.diagnostics_last_pdus or last_n)
+        except Exception:
+            pass  # nosec
+        pdus = list(self._last_pdus)[-last_n:]
+        payload = {
+            "transport_params": tp,
+            "last_pdus": pdus,
+        }
+        try:
+            body = _json.dumps(payload, ensure_ascii=False, default=str, indent=2)
+        except Exception:
+            body = str(payload)
+        # Add a small header to explain what follows
+        header = "--- Diagnostics (for troubleshooting) ---"
+        return f"{header}\n{body}"
+
+    def _diagnostics_enabled(self) -> bool:
+        try:
+            app = getattr(self.config, "parent", None)
+            app = getattr(app, "parent", None)
+            if app is not None and hasattr(app, "general"):
+                return bool(getattr(app.general, "diagnostics_on_failure", True))
+        except Exception:
+            return True
+        return True
 
     # @abc.abstractproperty
     # @property

pyxcp/transport/can.py

@@ -20,9 +20,14 @@ from can.interface import _get_class_for_interface
 from rich.console import Console
 
 from pyxcp.config import CAN_INTERFACE_MAP
-from pyxcp.transport.base import BaseTransport
+from pyxcp.transport.base import (
+    BaseTransport,
+    ChecksumType,
+    XcpFramingConfig,
+    XcpTransportLayerType,
+)
 
-from ..utils import seconds_to_nanoseconds
+from ..utils import seconds_to_nanoseconds, short_sleep
 
 
 console = Console()
@@ -292,7 +297,13 @@ class PythonCanWrapper:
         self.timeout: int = timeout
         self.parameters = parameters
         if not self.parent.has_user_supplied_interface:
-            self.can_interface_class = _get_class_for_interface(self.interface_name)
+            try:
+                self.can_interface_class = _get_class_for_interface(self.interface_name)
+            except Exception as ex:
+                # Provide clearer message if interface not supported by python-can on this platform
+                raise CanInitializationError(
+                    f"Unsupported or unavailable CAN interface {self.interface_name!r}: {ex.__class__.__name__}: {ex}"
+                ) from ex
         else:
             self.can_interface_class = None
         self.can_interface: BusABC
@@ -320,7 +331,15 @@ class PythonCanWrapper:
             self.can_interface.set_filters(merged_filters)
             self.software_filter.set_filters(can_filters)  # Filter unwanted traffic.
         else:
-            self.can_interface = self.can_interface_class(interface=self.interface_name, can_filters=can_filters, **self.parameters)
+            try:
+                self.can_interface = self.can_interface_class(
+                    interface=self.interface_name, can_filters=can_filters, **self.parameters
+                )
+            except OSError as ex:
+                # Typical when selecting socketcan on unsupported OS (e.g., Windows)
+                raise CanInitializationError(
+                    f"OS error while creating CAN interface {self.interface_name!r}: {ex.__class__.__name__}: {ex}"
+                ) from ex
             self.software_filter.accept_all()
         self.parent.logger.info(f"XCPonCAN - Using Interface: '{self.can_interface!s}'")
         self.parent.logger.info(f"XCPonCAN - Filters used: {self.can_interface.filters}")
@@ -383,7 +402,15 @@ class Can(BaseTransport):
     HEADER_SIZE = 0
 
     def __init__(self, config, policy=None, transport_layer_interface: Optional[BusABC] = None):
-        super().__init__(config, policy, transport_layer_interface)
+        framing_config = XcpFramingConfig(
+            transport_layer_type=XcpTransportLayerType.CAN,
+            header_len=0,
+            header_ctr=0,
+            header_fill=0,
+            tail_fill=False,
+            tail_cs=ChecksumType.NO_CHECKSUM,
+        )
+        super().__init__(config, framing_config, policy, transport_layer_interface)
         self.load_config(config)
         self.useDefaultListener = self.config.use_default_listener
         self.can_id_master = Identifier(self.config.can_id_master)
@@ -401,13 +428,33 @@ class Can(BaseTransport):
         self.padding_value = self.config.padding_value
         if transport_layer_interface is None:
             self.interface_name = self.config.interface
-            self.interface_configuration = detect_available_configs(interfaces=[self.interface_name])
+            # On platforms that do not support certain backends (e.g., SocketCAN on Windows),
+            # python-can may raise OSError deep inside interface initialization. We want to
+            # fail fast with a clearer hint and avoid unhandled low-level errors.
+            try:
+                self.interface_configuration = detect_available_configs(interfaces=[self.interface_name])
+            except Exception as ex:
+                # Best-effort graceful message; keep original exception context
+                self.logger.critical(
+                    f"XCPonCAN - Failed to query available configs for interface {self.interface_name!r}: {ex.__class__.__name__}: {ex}"
+                )
+                self.interface_configuration = []
             parameters = self.get_interface_parameters()
         else:
             self.interface_name = "custom"
             # print("TRY GET PARAMs", self.get_interface_parameters())
             parameters = {}
-        self.can_interface = PythonCanWrapper(self, self.interface_name, config.timeout, **parameters)
+        try:
+            self.can_interface = PythonCanWrapper(self, self.interface_name, config.timeout, **parameters)
+        except OSError as ex:
+            # Catch platform-specific socket errors early (e.g., SocketCAN on Windows)
+            msg = (
+                f"XCPonCAN - Failed to initialize CAN interface {self.interface_name!r}: "
+                f"{ex.__class__.__name__}: {ex}.\n"
+                f"Hint: Interface may be unsupported on this OS or missing drivers."
+            )
+            self.logger.critical(msg)
+            raise CanInitializationError(msg) from ex
         self.logger.info(f"XCPonCAN - Interface-Type: {self.interface_name!r} Parameters: {list(parameters.items())}")
         self.logger.info(
             f"XCPonCAN - Master-ID (Tx): 0x{self.can_id_master.id:08X}{self.can_id_master.type_str} -- "
@@ -451,23 +498,80 @@ class Can(BaseTransport):
         )
 
     def listen(self):
+        """Process CAN frames received from the interface.
+
+        This method runs in a separate thread and continuously polls the CAN interface
+        for new frames. When a frame is received, it extracts the data and timestamp
+        and passes them to the data_received method for further processing.
+
+        The method includes periodic sleep to prevent CPU hogging and error handling
+        to ensure the listener thread doesn't crash on exceptions.
+        """
+        # Cache frequently used methods and attributes for better performance
+        close_event_set = self.closeEvent.is_set
+        can_interface_read = self.can_interface.read
+        data_received = self.data_received
+
+        # State variables for processing
+        last_sleep = self.timestamp.value
+        FIVE_MS = 5_000_000  # Five milliseconds in nanoseconds
+
         while True:
-            if self.closeEvent.is_set():
+            # Check if we should exit the loop
+            if close_event_set():
                 return
-            frame = self.can_interface.read()
-            if frame:
-                self.data_received(frame.data, frame.timestamp)
+
+            # Periodically sleep to prevent CPU hogging
+            if self.timestamp.value - last_sleep >= FIVE_MS:
+                short_sleep()
+                last_sleep = self.timestamp.value
+
+            try:
+                # Try to read a frame from the CAN interface
+                frame = can_interface_read()
+                if frame:
+                    # Process the frame if one was received
+                    data_received(frame.data, frame.timestamp)
+                else:
+                    # No frame available, sleep briefly to avoid busy waiting
+                    short_sleep()
+                    last_sleep = self.timestamp.value
+            except Exception as e:
+                # Log any exceptions but continue processing
+                self.logger.error(f"Error in CAN listen thread: {e}")
+                # Sleep briefly to avoid tight error loops
+                short_sleep()
+                last_sleep = self.timestamp.value
 
     def connect(self):
-        if self.useDefaultListener:
-            self.start_listener()
+        # Start listener lazily after a successful interface connection to avoid a dangling
+        # thread waiting on a not-yet-connected interface if initialization fails.
         try:
             self.can_interface.connect()
         except CanInitializationError:
+            # Ensure any previously-started listener is stopped to prevent hangs.
+            self.finish_listener()
             console.print("[red]\nThere may be a problem with the configuration of your CAN-interface.\n")
             console.print(f"[grey]Current configuration of interface {self.interface_name!r}:")
             console.print(self.interface_configuration)
             raise
+        except OSError as ex:
+            # Ensure any previously-started listener is stopped to prevent hangs.
+            self.finish_listener()
+            # E.g., attempting to instantiate SocketCAN on Windows raises an OSError from socket layer.
+            # Provide a clearer, actionable message and keep the original exception.
+            msg = (
+                f"XCPonCAN - OS error while initializing interface {self.interface_name!r}: "
+                f"{ex.__class__.__name__}: {ex}.\n"
+                f"Hint: This interface may not be supported on your platform. "
+                f"On Windows, use e.g. 'vector', 'kvaser', 'pcan', or other vendor backends instead of 'socketcan'."
+            )
+            self.logger.critical(msg)
+            raise CanInitializationError(msg) from ex
+        else:
+            # Only now start the default listener if requested.
+            if self.useDefaultListener:
+                self.start_listener()
         self.status = 1  # connected
 
     def send(self, frame: bytes) -> None: