pyxcp 0.23.0__cp313-cp313-win_arm64.whl

pyxcp/transport/eth.py

@@ -0,0 +1,219 @@
+#!/usr/bin/env python
+import selectors
+import socket
+import struct
+import threading
+from collections import deque
+from typing import Optional
+
+from pyxcp.transport.base import BaseTransport
+from pyxcp.utils import short_sleep
+
+
+DEFAULT_XCP_PORT = 5555
+RECV_SIZE = 8196
+
+
+def socket_to_str(sock: socket.socket) -> str:
+    peer = sock.getpeername()
+    local = sock.getsockname()
+    AF = {
+        socket.AF_INET: "AF_INET",
+        socket.AF_INET6: "AF_INET6",
+    }
+    TYPE = {
+        socket.SOCK_DGRAM: "SOCK_DGRAM",
+        socket.SOCK_STREAM: "SOCK_STREAM",
+    }
+    family = AF.get(sock.family, "OTHER")
+    typ = TYPE.get(sock.type, "UNKNOWN")
+    res = f"XCPonEth - Connected to: {peer[0]}:{peer[1]}  local address: {local[0]}:{local[1]} [{family}][{typ}]"
+    return res
+
+
+class Eth(BaseTransport):
+    """"""
+
+    MAX_DATAGRAM_SIZE = 512
+    HEADER = struct.Struct("<HH")
+    HEADER_SIZE = HEADER.size
+
+    def __init__(self, config=None, policy=None, transport_layer_interface: Optional[socket.socket] = None) -> None:
+        super().__init__(config, policy, transport_layer_interface)
+        self.load_config(config)
+        self.host: str = self.config.host
+        self.port: int = self.config.port
+        self.protocol: int = self.config.protocol
+        self.ipv6: bool = self.config.ipv6
+        self.use_tcp_no_delay: bool = self.config.tcp_nodelay
+        address_to_bind: str = self.config.bind_to_address
+        bind_to_port: int = self.config.bind_to_port
+        self._local_address = (address_to_bind, bind_to_port) if address_to_bind else None
+        if self.ipv6 and not socket.has_ipv6:
+            msg = "XCPonEth - IPv6 not supported by your platform."
+            self.logger.critical(msg)
+            raise RuntimeError(msg)
+        else:
+            address_family = socket.AF_INET6 if self.ipv6 else socket.AF_INET
+        proto = socket.SOCK_STREAM if self.protocol == "TCP" else socket.SOCK_DGRAM
+        if self.host.lower() == "localhost":
+            self.host = "::1" if self.ipv6 else "localhost"
+
+        try:
+            addrinfo = socket.getaddrinfo(self.host, self.port, address_family, proto)
+            (
+                self.address_family,
+                self.socktype,
+                self.proto,
+                self.canonname,
+                self.sockaddr,
+            ) = addrinfo[0]
+        except BaseException as ex:  # noqa: B036
+            msg = f"XCPonEth - Failed to resolve address {self.host}:{self.port}"
+            self.logger.critical(msg)
+            raise Exception(msg) from ex
+        self.status: int = 0
+        self.sock = socket.socket(self.address_family, self.socktype, self.proto)
+        self.selector = selectors.DefaultSelector()
+        self.selector.register(self.sock, selectors.EVENT_READ)
+        self.use_tcp = self.protocol == "TCP"
+        self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        if self.use_tcp and self.use_tcp_no_delay:
+            self.sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+        if hasattr(socket, "SO_REUSEPORT"):
+            self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
+        self.sock.settimeout(0.5)
+        if self._local_address:
+            try:
+                self.sock.bind(self._local_address)
+            except BaseException as ex:  # noqa: B036
+                msg = f"XCPonEth - Failed to bind socket to given address {self._local_address}"
+                self.logger.critical(msg)
+                raise Exception(msg) from ex
+        self._packet_listener = threading.Thread(
+            target=self._packet_listen,
+            args=(),
+            kwargs={},
+        )
+        self._packets = deque()
+
+    def connect(self) -> None:
+        if self.status == 0:
+            self.sock.connect(self.sockaddr)
+            self.logger.info(socket_to_str(self.sock))
+            self.start_listener()
+            self.status = 1  # connected
+
+    def start_listener(self) -> None:
+        super().start_listener()
+        if self._packet_listener.is_alive():
+            self._packet_listener.join()
+        self._packet_listener = threading.Thread(target=self._packet_listen)
+        self._packet_listener.start()
+
+    def close(self) -> None:
+        """Close the transport-layer connection and event-loop."""
+        self.finish_listener()
+        if self.listener.is_alive():
+            self.listener.join()
+        if self._packet_listener.is_alive():
+            self._packet_listener.join()
+        self.close_connection()
+
+    def _packet_listen(self) -> None:
+        use_tcp: bool = self.use_tcp
+        EVENT_READ = selectors.EVENT_READ
+        close_event_set = self.closeEvent.is_set
+        socket_fileno = self.sock.fileno
+        select = self.selector.select
+        _packets = self._packets
+        if use_tcp:
+            sock_recv = self.sock.recv
+        else:
+            sock_recv = self.sock.recvfrom
+        while True:
+            try:
+                if close_event_set() or socket_fileno() == -1:
+                    return
+                sel = select(0.02)
+                for _, events in sel:
+                    if events & EVENT_READ:
+                        recv_timestamp = self.timestamp.value
+                        if use_tcp:
+                            response = sock_recv(RECV_SIZE)
+                            if not response:
+                                self.sock.close()
+                                self.status = 0
+                                break
+                            else:
+                                _packets.append((response, recv_timestamp))
+                        else:
+                            response, _ = sock_recv(Eth.MAX_DATAGRAM_SIZE)
+                            if not response:
+                                self.sock.close()
+                                self.status = 0
+                                break
+                            else:
+                                _packets.append((response, recv_timestamp))
+            except BaseException:  # noqa: B036
+                self.status = 0  # disconnected
+                break
+
+    def listen(self) -> None:
+        HEADER_UNPACK_FROM = self.HEADER.unpack_from
+        HEADER_SIZE = self.HEADER_SIZE
+        process_response = self.process_response
+        popleft = self._packets.popleft
+        close_event_set = self.closeEvent.is_set
+        socket_fileno = self.sock.fileno
+        _packets = self._packets
+        length: Optional[int] = None
+        counter: int = 0
+        data: bytearray = bytearray(b"")
+        while True:
+            if close_event_set() or socket_fileno() == -1:
+                return
+            count: int = len(_packets)
+            if not count:
+                short_sleep()
+                continue
+            for _ in range(count):
+                bts, timestamp = popleft()
+                data += bts
+                current_size: int = len(data)
+                current_position: int = 0
+                while True:
+                    if length is None:
+                        if current_size >= HEADER_SIZE:
+                            length, counter = HEADER_UNPACK_FROM(data, current_position)
+                            current_position += HEADER_SIZE
+                            current_size -= HEADER_SIZE
+                        else:
+                            data = data[current_position:]
+                            break
+                    else:
+                        if current_size >= length:
+                            response = data[current_position : current_position + length]
+                            process_response(response, length, counter, timestamp)
+                            current_size -= length
+                            current_position += length
+                            length = None
+                        else:
+                            data = data[current_position:]
+                            break
+
+    def send(self, frame) -> None:
+        self.pre_send_timestamp = self.timestamp.value
+        self.sock.send(frame)
+        self.post_send_timestamp = self.timestamp.value
+
+    def close_connection(self) -> None:
+        if not self.invalidSocket:
+            # Seems to be problematic /w IPv6
+            # if self.status == 1:
+            #     self.sock.shutdown(socket.SHUT_RDWR)
+            self.sock.close()
+
+    @property
+    def invalidSocket(self) -> bool:
+        return not hasattr(self, "sock") or self.sock.fileno() == -1

pyxcp/transport/sxi.py

@@ -0,0 +1,135 @@
+import struct
+from collections import deque
+from dataclasses import dataclass
+from typing import Optional
+
+import serial
+
+import pyxcp.types as types
+from pyxcp.transport.base import BaseTransport
+
+
+@dataclass
+class HeaderValues:
+    length: int = 0
+    counter: int = 0
+    filler: int = 0
+
+
+RECV_SIZE = 16384
+
+
+class SxI(BaseTransport):
+    """"""
+
+    def __init__(self, config=None, policy=None, transport_layer_interface: Optional[serial.Serial] = None) -> None:
+        super().__init__(config, policy, transport_layer_interface)
+        self.load_config(config)
+        self.port_name = self.config.port
+        self.baudrate = self.config.bitrate
+        self.bytesize = self.config.bytesize
+        self.parity = self.config.parity
+        self.stopbits = self.config.stopbits
+        self.mode = self.config.mode
+        self.header_format = self.config.header_format
+        self.tail_format = self.config.tail_format
+        self.framing = self.config.framing
+        self.esc_sync = self.config.esc_sync
+        self.esc_esc = self.config.esc_esc
+        self.make_header()
+        self.comm_port: serial.Serial
+
+        if self.has_user_supplied_interface and transport_layer_interface:
+            self.comm_port = transport_layer_interface
+        else:
+            self.logger.info(f"XCPonSxI - trying to open serial comm_port {self.port_name!r}.")
+            try:
+                self.comm_port = serial.Serial(
+                    port=self.port_name,
+                    baudrate=self.baudrate,
+                    bytesize=self.bytesize,
+                    parity=self.parity,
+                    stopbits=self.stopbits,
+                    timeout=self.timeout,
+                    write_timeout=self.timeout,
+                )
+            except serial.SerialException as e:
+                self.logger.critical(f"XCPonSxI - {e}")
+                raise
+        self._packets = deque()
+
+    def __del__(self) -> None:
+        self.close_connection()
+
+    def make_header(self) -> None:
+        def unpack_len(args):
+            (length,) = args
+            return HeaderValues(length=length)
+
+        def unpack_len_counter(args):
+            length, counter = args
+            return HeaderValues(length=length, counter=counter)
+
+        def unpack_len_filler(args):
+            length, filler = args
+            return HeaderValues(length=length, filler=filler)
+
+        HEADER_FORMATS = {
+            "HEADER_LEN_BYTE": ("B", unpack_len),
+            "HEADER_LEN_CTR_BYTE": ("BB", unpack_len_counter),
+            "HEADER_LEN_FILL_BYTE": ("BB", unpack_len_filler),
+            "HEADER_LEN_WORD": ("H", unpack_len),
+            "HEADER_LEN_CTR_WORD": ("HH", unpack_len_counter),
+            "HEADER_LEN_FILL_WORD": ("HH", unpack_len_filler),
+        }
+        fmt, unpacker = HEADER_FORMATS[self.header_format]
+        self.HEADER = struct.Struct(f"<{fmt}")
+        self.HEADER_SIZE = self.HEADER.size
+        self.unpacker = unpacker
+
+    def connect(self) -> None:
+        self.logger.info(
+            f"XCPonSxI - serial comm_port {self.comm_port.portstr!r} openend [{self.baudrate}/{self.bytesize}-{self.parity}-{self.stopbits}]"
+        )
+        self.start_listener()
+
+    def output(self, enable) -> None:
+        if enable:
+            self.comm_port.rts = False
+            self.comm_port.dtr = False
+        else:
+            self.comm_port.rts = True
+            self.comm_port.dtr = True
+
+    def flush(self) -> None:
+        self.comm_port.flush()
+
+    def start_listener(self) -> None:
+        super().start_listener()
+
+    def listen(self) -> None:
+        while True:
+            if self.closeEvent.is_set():
+                return
+            if not self.comm_port.in_waiting:
+                continue
+
+            recv_timestamp = self.timestamp.value
+            header_values = self.unpacker(self.HEADER.unpack(self.comm_port.read(self.HEADER_SIZE)))
+            length, counter, _ = header_values.length, header_values.counter, header_values.filler
+
+            response = self.comm_port.read(length)
+            self.timing.stop()
+
+            if len(response) != length:
+                raise types.FrameSizeError("Size mismatch.")
+            self.process_response(response, length, counter, recv_timestamp)
+
+    def send(self, frame) -> None:
+        self.pre_send_timestamp = self.timestamp.value
+        self.comm_port.write(frame)
+        self.post_send_timestamp = self.timestamp.value
+
+    def close_connection(self) -> None:
+        if hasattr(self, "comm_port") and self.comm_port.is_open and not self.has_user_supplied_interface:
+            self.comm_port.close()

pyxcp/transport/usb_transport.py

@@ -0,0 +1,213 @@
+#!/usr/bin/env python
+import struct
+import threading
+from array import array
+from collections import deque
+from typing import Optional
+
+import usb.backend.libusb0 as libusb0
+import usb.backend.libusb1 as libusb1
+import usb.backend.openusb as openusb
+import usb.core
+import usb.util
+from usb.core import USBError, USBTimeoutError
+
+from pyxcp.transport.base import BaseTransport
+from pyxcp.utils import short_sleep
+
+
+RECV_SIZE = 16384
+FIVE_MS = 5_000_000  # Five milliseconds in nanoseconds.
+
+
+class Usb(BaseTransport):
+    """"""
+
+    HEADER = struct.Struct("<2H")
+    HEADER_SIZE = HEADER.size
+
+    def __init__(self, config=None, policy=None, transport_layer_interface: Optional[usb.core.Device] = None):
+        super().__init__(config, policy, transport_layer_interface)
+        self.load_config(config)
+        self.serial_number: str = self.config.serial_number
+        self.vendor_id: int = self.config.vendor_id
+        self.product_id: int = self.config.product_id
+        self.configuration_number: int = self.config.configuration_number
+        self.interface_number: int = self.config.interface_number
+        self.library: str = self.config.library
+        self.header_format: str = self.config.header_format
+        self.library = self.config.get("library")
+        self.device = None
+
+        ## IN-EP (RES/ERR, DAQ, and EV/SERV) Parameters.
+        self.in_ep_number: int = self.config.in_ep_number
+        self.in_ep_transfer_type = self.config.in_ep_transfer_type
+        self.in_ep_max_packet_size: int = self.config.in_ep_max_packet_size
+        self.in_ep_polling_interval: int = self.config.in_ep_polling_interval
+        self.in_ep_message_packing = self.config.in_ep_message_packing
+        self.in_ep_alignment = self.config.in_ep_alignment
+        self.in_ep_recommended_host_bufsize: int = self.config.in_ep_recommended_host_bufsize
+
+        ## OUT-EP (CMD and STIM) Parameters.
+        self.out_ep_number: int = self.config.out_ep_number
+
+        self.device: Optional[usb.core.Device] = None
+        self.status = 0
+
+        self._packet_listener = threading.Thread(
+            target=self._packet_listen,
+            args=(),
+            kwargs={},
+        )
+        self._packets = deque()
+
+    def connect(self):
+        if self.library:
+            for backend_provider in (libusb1, libusb0, openusb):
+                backend = backend_provider.get_backend(find_library=lambda x: self.library)
+                if backend:
+                    break
+        else:
+            backend = None
+
+        if self.vendor_id and self.product_id:
+            kwargs = {
+                "find_all": True,
+                "idVendor": self.vendor_id,
+                "idProduct": self.product_id,
+                "backend": backend,
+            }
+        else:
+            kwargs = {
+                "find_all": True,
+                "backend": backend,
+            }
+
+        for device in usb.core.find(**kwargs):
+            try:
+                if device.serial_number.strip().strip("\0").lower() == self.serial_number.lower():
+                    self.device = device
+                    break
+            except (USBError, USBTimeoutError):
+                continue
+        else:
+            raise Exception(f"XCPonUSB - device with serial {self.serial_number!r} not found")
+
+        current_configuration = self.device.get_active_configuration()
+        if current_configuration.bConfigurationValue != self.configuration_number:
+            self.device.set_configuration(self.configuration_number)
+        cfg = self.device.get_active_configuration()
+
+        interface = cfg[(self.interface_number, 0)]
+
+        self.out_ep = interface[self.out_ep_number]
+        self.in_ep = interface[self.in_ep_number]
+
+        self.start_listener()
+        self.status = 1  # connected
+
+    def start_listener(self):
+        super().start_listener()
+        if self._packet_listener.is_alive():
+            self._packet_listener.join()
+        self._packet_listener = threading.Thread(target=self._packet_listen)
+        self._packet_listener.start()
+
+    def close(self):
+        """Close the transport-layer connection and event-loop."""
+        self.finish_listener()
+        if self.listener.is_alive():
+            self.listener.join()
+        if self._packet_listener.is_alive():
+            self._packet_listener.join()
+        self.close_connection()
+
+    def _packet_listen(self):
+        close_event_set = self.closeEvent.is_set
+        _packets = self._packets
+        read = self.in_ep.read
+        buffer = array("B", bytes(RECV_SIZE))
+        buffer_view = memoryview(buffer)
+        while True:
+            try:
+                if close_event_set():
+                    return
+                try:
+                    recv_timestamp = self.timestamp.value
+                    read_count = read(buffer, 100)  # 100ms timeout
+                    if read_count != RECV_SIZE:
+                        _packets.append((buffer_view[:read_count].tobytes(), recv_timestamp))
+                    else:
+                        _packets.append((buffer.tobytes(), recv_timestamp))
+                except (USBError, USBTimeoutError):
+                    # print(format_exc())
+                    short_sleep()
+                    continue
+            except BaseException:  # noqa: B036
+                # Note: catch-all only permitted if the intention is re-raising.
+                self.status = 0  # disconnected
+                break
+
+    def listen(self):
+        HEADER_UNPACK_FROM = self.HEADER.unpack_from
+        HEADER_SIZE = self.HEADER_SIZE
+        popleft = self._packets.popleft
+        process_response = self.process_response
+        close_event_set = self.closeEvent.is_set
+        _packets = self._packets
+        length: Optional[int] = None
+        counter: int = 0
+        data: bytearray = bytearray(b"")
+        last_sleep: int = self.timestamp.value
+
+        while True:
+            if close_event_set():
+                return
+            count: int = len(_packets)
+            if not count:
+                short_sleep()
+                last_sleep = self.timestamp.value
+                continue
+            for _ in range(count):
+                bts, timestamp = popleft()
+                data += bts
+                current_size: int = len(data)
+                current_position: int = 0
+                while True:
+                    if self.timestamp.value - last_sleep >= FIVE_MS:
+                        short_sleep()
+                        last_sleep = self.timestamp.value
+                    if length is None:
+                        if current_size >= HEADER_SIZE:
+                            length, counter = HEADER_UNPACK_FROM(data, current_position)
+                            current_position += HEADER_SIZE
+                            current_size -= HEADER_SIZE
+                        else:
+                            data = data[current_position:]
+                            break
+                    else:
+                        if current_size >= length:
+                            response = data[current_position : current_position + length]
+                            process_response(response, length, counter, timestamp)
+                            current_size -= length
+                            current_position += length
+                            length = None
+                        else:
+                            data = data[current_position:]
+                            break
+
+    def send(self, frame):
+        self.pre_send_timestamp = self.timestamp.value
+        try:
+            self.out_ep.write(frame)
+        except (USBError, USBTimeoutError):
+            # sometimes usb.core.USBError: [Errno 5] Input/Output Error is raised
+            # even though the command is send and a reply is received from the device.
+            # Ignore this here since a Timeout error will be raised anyway if
+            # the device does not respond
+            pass
+        self.post_send_timestamp = self.timestamp.value
+
+    def close_connection(self):
+        if self.device is not None:
+            usb.util.dispose_resources(self.device)