pyxcp 0.22.35__cp313-cp313-win_amd64.whl → 0.23.1__cp313-cp313-win_amd64.whl

pyxcp/__init__.py

@@ -17,4 +17,4 @@ tb_install(show_locals=True, max_frames=3)  # Install custom exception handler.
 
 # if you update this manually, do not forget to update
 # .bumpversion.cfg and pyproject.toml.
-__version__ = "0.22.35"
+__version__ = "0.23.1"

pyxcp/config/__init__.py

@@ -490,6 +490,12 @@ If set, the `app_name` does not have to be previously defined in
     )
 
 
+class CanCustom(Configurable, CanBase):
+    """ """
+
+    interface_name = "custom"
+
+
 class Virtual(Configurable, CanBase):
     """ """
 
@@ -542,11 +548,13 @@ CAN_INTERFACE_MAP = {
     "usb2can": Usb2Can,
     "vector": Vector,
     "virtual": Virtual,
+    "custom": CanCustom,
 }
 
 
 class Can(Configurable):
-    VALID_INTERFACES = can.interfaces.VALID_INTERFACES
+    VALID_INTERFACES = set(can.interfaces.VALID_INTERFACES)
+    VALID_INTERFACES.add("custom")
 
     interface = Enum(
         values=VALID_INTERFACES, default_value=None, allow_none=True, help="CAN interface supported by python-can"
@@ -605,6 +613,7 @@ timing-related parameters.
     classes = List(
         [
             CanAlystii,
+            CanCustom,
             CanTact,
             Etas,
             Gs_Usb,
@@ -640,6 +649,7 @@ timing-related parameters.
                     " {type(self.interface).__name__} {self.interface}."
                 )
         self.canalystii = CanAlystii(config=self.config, parent=self)
+        self.cancustom = CanCustom(config=self.config, parent=self)
         self.cantact = CanTact(config=self.config, parent=self)
         self.etas = Etas(config=self.config, parent=self)
         self.gs_usb = Gs_Usb(config=self.config, parent=self)
@@ -798,7 +808,7 @@ class Transport(Configurable):
         allow_none=True,
         help="Choose one of the supported XCP transport layers.",
     ).tag(config=True)
-    create_daq_timestamps = Bool(False, help="Record time of frame reception or set timestamp to 0.").tag(config=True)
+    create_daq_timestamps = Bool(True, help="Record time of frame reception or set timestamp to 0.").tag(config=True)
     timeout = Float(
         2.0,
         help="""raise `XcpTimeoutError` after `timeout` seconds

pyxcp/daq_stim/scheduler.cpp

@@ -1,28 +1,62 @@
-
 #include "scheduler.hpp"
 
 #if defined(_WIN32)
 
+#include <cstdio>
+#include <cstdint>
+
 VOID CALLBACK TimerRoutine(PVOID lpParam, BOOLEAN TimerOrWaitFired) {
-    if (lpParam == NULL) {
-        printf("TimerRoutine lpParam is NULL\n");
+    if (lpParam == nullptr) {
+        std::printf("TimerRoutine lpParam is NULL\n");
+        return;
+    }
+    
+    const auto* param = static_cast<const int*>(lpParam);
+    std::printf("Timer routine called. Parameter is %d.\n", *param);
+    
+    if (TimerOrWaitFired) {
+        std::printf("The wait timed out.\n");
     } else {
-        // lpParam points to the argument; in this case it is an int
-
-        printf("Timer routine called. Parameter is %d.\n", *(int*)lpParam);
-        if (TimerOrWaitFired) {
-            printf("The wait timed out.\n");
-        } else {
-            printf("The wait event was signaled.\n");
-        }
+        std::printf("The wait event was signaled.\n");
     }
 }
 
-    #include <xmmintrin.h>
+#endif // _WIN32
 
-void mul4_vectorized(float* ptr) {
-    __m128 f = _mm_loadu_ps(ptr);
-    f        = _mm_mul_ps(f, f);
-    _mm_storeu_ps(ptr, f);
+// Vectorized multiply implementation with bounds checking
+namespace {
+    constexpr size_t VECTOR_SIZE = 4;
 }
-#endif
+
+#if defined(_M_X64) || defined(_M_IX86) || defined(__SSE__)
+    #include <xmmintrin.h>
+    
+    void mul4_vectorized(float* ptr) {
+        if (ptr == nullptr) return;
+        
+        __m128 f = _mm_loadu_ps(ptr);
+        f = _mm_mul_ps(f, f);
+        _mm_storeu_ps(ptr, f);
+    }
+
+#elif defined(_M_ARM64) || defined(__ARM_NEON)
+    #include <arm_neon.h>
+    
+    void mul4_vectorized(float* ptr) {
+        if (ptr == nullptr) return;
+        
+        float32x4_t f = vld1q_f32(ptr);
+        f = vmulq_f32(f, f);
+        vst1q_f32(ptr, f);
+    }
+
+#else
+    // Scalar fallback
+    void mul4_vectorized(float* ptr) {
+        if (ptr == nullptr) return;
+        
+        for (size_t i = 0; i < VECTOR_SIZE; ++i) {
+            ptr[i] *= ptr[i];
+        }
+    }
+#endif

pyxcp/examples/xcp_user_supplied_driver.py

@@ -1,54 +1,44 @@
 #!/usr/bin/env python
-"""User supplied CAN driver.
 
-Run as:
+from typing import Dict, List, Optional
 
-.. code-block:: shell
+import can
 
-    python xcp_user_supplied_driver.py -c conf_can_user.toml
-"""
 from pyxcp.cmdline import ArgumentParser
 from pyxcp.transport.can import CanInterfaceBase
 
 
-class MyCI(CanInterfaceBase):
-    """
+class CustomCANInterface(CanInterfaceBase):
 
-    Relevant options in your configuration file (e.g. conf_can_user.toml):
+    def init(self):
+        """Initialize the CAN interface here."""
 
-    TRANSPORT = "CAN"
-    CAN_DRIVER = "MyCI"     # The name of your custom driver class.
+    def set_filters(self, filters):
+        print(f"set_filters({filters})")
+        self._filters = filters
 
-    """
+    def recv(self, timeout: Optional[float] = None) -> Optional[can.message.Message]:
+        """Receive CAN frames."""
+        return can.message.Message()
 
-    def init(self, parent, receive_callback):
-        self.parent = parent
+    def send(self, msg: can.message.Message):
+        """Send CAN frames."""
+        print(f"send({msg})")
 
-    def connect(self):
-        pass
+    @property
+    def filters(self):
+        """Return the current CAN filters."""
+        return self._filters
 
-    def close(self):
-        pass
+    @property
+    def state(self):
+        """Return the current state of the CAN interface."""
+        return can.BusState.ACTIVE
 
-    def get_timestamp_resolution(self):
-        pass
-
-    def read(self):
-        pass
-
-    def transmit(self, payload: bytes):
-        print("\tTX-PAYLOAD", payload)
 
+custom_interface = CustomCANInterface()
 
 ap = ArgumentParser(description="User supplied CAN driver.")
-with ap.run() as x:
+with ap.run(transport_layer_interface=custom_interface) as x:
     x.connect()
     x.disconnect()
-
-"""
-This do-nothing example will output
-
-    TX-PAYLOAD b'\xff\x00'
-
-and then timeout (0xff is the service code for CONNECT_REQ).
-"""

pyxcp/scripts/xcp_info.py

@@ -1,7 +1,6 @@
 #!/usr/bin/env python
 
-"""XCP info/exploration tool.
-"""
+"""XCP info/exploration tool."""
 
 from pprint import pprint
 
@@ -21,7 +20,6 @@ def getPagInfo(x):
             for i in range(pag.maxSegments):
                 segment = {}
                 status, std_info = x.try_command(x.getSegmentInfo, 0x01, i, 0, 0)
-                std_info = x.getSegmentInfo(0x01, i, 2, 0)
                 if status == TryCommandResult.OK:
                     segment["maxPages"] = std_info.maxPages
                     segment["addressExtension"] = std_info.addressExtension

pyxcp/transport/can.py

@@ -1,13 +1,20 @@
 #!/usr/bin/env python
-"""
-"""
+""" """
 
 import functools
 import operator
+from abc import ABC, abstractmethod
 from bisect import bisect_left
-from typing import Any, Dict, Optional, Type
-
-from can import CanError, CanInitializationError, Message, detect_available_configs
+from enum import IntEnum
+from typing import Any, Dict, List, Optional, Union
+
+from can import (
+    BusState,
+    CanError,
+    CanInitializationError,
+    Message,
+    detect_available_configs,
+)
 from can.bus import BusABC
 from can.interface import _get_class_for_interface
 from rich.console import Console
@@ -27,6 +34,55 @@ MAX_DLC_CLASSIC = 8
 CAN_FD_DLCS = (12, 16, 20, 24, 32, 48, 64)  # Discrete CAN-FD DLCs in case DLC > 8.
 
 
+class FilterState(IntEnum):
+    REJECT_ALL = 0
+    ACCEPT_ALL = 1
+    FILTERING = 2
+
+
+class SoftwareFilter:
+    """Additional CAN filters in software."""
+
+    def __init__(self) -> None:
+        self.filters = None
+        self.reject_all()
+
+    def set_filters(self, filters: List[Dict]) -> None:
+        self.filters = filters
+        self.filtering()
+
+    def reject_all(self) -> None:
+        self.filter_state = FilterState.REJECT_ALL
+
+    def accept_all(self) -> None:
+        self.filter_state = FilterState.ACCEPT_ALL
+
+    def filtering(self) -> None:
+        self.filter_state = FilterState.FILTERING
+
+    @property
+    def state(self) -> FilterState:
+        return self.filter_state
+
+    def accept(self, msg: Message) -> bool:
+        """
+        Based on: https://github.com/hardbyte/python-can/blob/bc248e8aaf96280a574c06e8e7d2778a67f091e3/can/bus.py#L430
+        """
+        if self.filter_state == FilterState.REJECT_ALL:
+            return False
+        elif self.filter_state == FilterState.ACCEPT_ALL or self.filters is None:
+            return True
+        for filter in self.filters:
+            if "extended" in filter:
+                if filter["extended"] != msg.is_extended_id:
+                    continue
+            can_id = filter["can_id"]
+            can_mask = filter["can_mask"]
+            if (can_id ^ msg.arbitration_id) & can_mask == 0:
+                return True
+        return False
+
+
 class IdentifierOutOfRangeError(Exception):
     """Signals an identifier greater then :obj:`MAX_11_BIT_IDENTIFIER` or :obj:`MAX_29_BIT_IDENTIFIER`."""
 
@@ -235,32 +291,47 @@ class PythonCanWrapper:
         self.interface_name: str = interface_name
         self.timeout: int = timeout
         self.parameters = parameters
-        self.can_interface_class: Type[BusABC] = _get_class_for_interface(self.interface_name)
+        if not self.parent.has_user_supplied_interface:
+            self.can_interface_class = _get_class_for_interface(self.interface_name)
+        else:
+            self.can_interface_class = None
         self.can_interface: BusABC
         self.connected: bool = False
+        self.software_filter = SoftwareFilter()
+        self.saved_filters = []
 
-    def connect(self):
+    def connect(self) -> None:
         if self.connected:
             return
         can_filters = []
         can_filters.append(self.parent.can_id_slave.create_filter_from_id())  # Primary CAN filter.
-        if self.parent.has_user_supplied_interface:
-            self.can_interface = self.parent.transport_layer_interface
-        else:
-            self.can_interface = self.can_interface_class(interface=self.interface_name, **self.parameters)
         if self.parent.daq_identifier:
             # Add filters for DAQ identifiers.
             for daq_id in self.parent.daq_identifier:
                 can_filters.append(daq_id.create_filter_from_id())
-        self.can_interface.set_filters(can_filters)
+        if self.parent.has_user_supplied_interface:
+            self.saved_filters = self.parent.transport_layer_interface.filters
+            if self.saved_filters:
+                merged_filters = can_filters[::]
+                for fltr in self.saved_filters:
+                    if fltr not in merged_filters:
+                        merged_filters.append(fltr)
+            self.can_interface = self.parent.transport_layer_interface
+            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)
+            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}")
         self.parent.logger.info(f"XCPonCAN - State: {self.can_interface.state!s}")
         self.connected = True
 
-    def close(self):
+    def close(self) -> None:
         if self.connected and not self.parent.has_user_supplied_interface:
             self.can_interface.shutdown()
+        if self.saved_filters:
+            self.can_interface.set_filters(self.saved_filters)
         self.connected = False
 
     def transmit(self, payload: bytes) -> None:
@@ -282,6 +353,8 @@ class PythonCanWrapper:
         else:
             if frame is None or not len(frame.data):
                 return None  # Timeout condition.
+            if not self.software_filter.accept(frame):
+                return None  # Filter out unwanted traffic.
             extended = frame.is_extended_id
             identifier = Identifier.make_identifier(frame.arbitration_id, extended)
             return Frame(
@@ -326,9 +399,14 @@ class Can(BaseTransport):
                 self.daq_identifier.append(Identifier(daq_id))
         self.max_dlc_required = self.config.max_dlc_required
         self.padding_value = self.config.padding_value
-        self.interface_name = self.config.interface
-        self.interface_configuration = detect_available_configs(interfaces=[self.interface_name])
-        parameters = self.get_interface_parameters()
+        if transport_layer_interface is None:
+            self.interface_name = self.config.interface
+            self.interface_configuration = detect_available_configs(interfaces=[self.interface_name])
+            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)
         self.logger.info(f"XCPonCAN - Interface-Type: {self.interface_name!r} Parameters: {list(parameters.items())}")
         self.logger.info(
@@ -439,3 +517,40 @@ def calculate_filter(ids: list):
     cmask = functools.reduce(operator.or_, raw_ids) ^ cfilter
     cmask ^= 0x1FFFFFFF if any_extended_ids else 0x7FF
     return (cfilter, cmask)
+
+
+class CanInterfaceBase(ABC):
+    """
+    Base class for custom CAN interfaces.
+    This is basically a subset of python-CANs `BusABC`.
+    """
+
+    @abstractmethod
+    def set_filters(self, filters: Optional[List[Dict[str, Union[int, bool]]]] = None) -> None:
+        """Apply filtering to all messages received by this Bus.
+
+        filters:
+            A list of dictionaries, each containing a 'can_id', 'can_mask', and 'extended' field, e.g.:
+            [{"can_id": 0x11, "can_mask": 0x21, "extended": False}]
+        """
+
+    @abstractmethod
+    def recv(self, timeout: Optional[float] = None) -> Optional[Message]:
+        """Block waiting for a message from the Bus."""
+
+    @abstractmethod
+    def send(self, msg: Message) -> None:
+        """Transmit a message to the CAN bus."""
+
+    @property
+    @abstractmethod
+    def filters(self) -> Optional[List[Dict[str, Union[int, bool]]]]:
+        """Modify the filters of this bus."""
+
+    @property
+    @abstractmethod
+    def state(self) -> BusState:
+        """Return the current state of the hardware."""
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}"

{pyxcp-0.22.35.dist-info → pyxcp-0.23.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyxcp
-Version: 0.22.35
+Version: 0.23.1
 Summary: Universal Calibration Protocol for Python
 License: LGPLv3
 Keywords: automotive,ecu,xcp,asam,autosar

{pyxcp-0.22.35.dist-info → pyxcp-0.23.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-pyxcp/__init__.py,sha256=cCzCFYz2VXdbLl-oeEcA066T-ZfWBKS32tHhx2YcVag,548
+pyxcp/__init__.py,sha256=HQBiOPfZK2f7NGrXX2R-3kzx2bnjcg1nj3e6BhJPCrw,547
 pyxcp/aml/EtasCANMonitoring.a2l,sha256=EJYwe3Z3H24vyWAa6lUgcdKnQY8pwFxjyCN6ZU1ST8w,1509
 pyxcp/aml/EtasCANMonitoring.aml,sha256=xl0DdyeiIaLW0mmmJNAyJS0CQdOLSxt9dxfgrdSlU8Y,2405
 pyxcp/aml/ifdata_CAN.a2l,sha256=NCUnCUEEgRbZYSLGtUGwL2e7zJ8hrp0SbmLHGv8uY58,612
@@ -18,16 +18,16 @@ pyxcp/asamkeydll.c,sha256=dVEvU0S1kgIo62S0La-T8xHSw668LM_DYc_fiQ0No6g,2952
 pyxcp/asamkeydll.sh,sha256=DC2NKUMwvi39OQgJ6514Chr4wc1LYbTmQHmMq9jAHHs,59
 pyxcp/checksum.py,sha256=hO2JW_eiO9I0A4eiqovMV9d_y5oidq_w8jKdAE4FeOo,11899
 pyxcp/cmdline.py,sha256=na3ZbWQ-5ezsi1MrkuxMTCAXonUF3X6-LutoneyE3dU,1529
-pyxcp/config/__init__.py,sha256=vIYPtzzNI4kUmevpOsSFgbfuBXPq7e2bhIIwWcqPcqQ,41835
+pyxcp/config/__init__.py,sha256=hM1eQtllcZeZ4zo9YzscO2Z5EOpV3hWyZgY9GZMiavw,42085
 pyxcp/config/legacy.py,sha256=4QdDheX8DbBKv5JVT72_C_cjCgKvZmhN3tJ6hsvBEtI,5220
 pyxcp/constants.py,sha256=9yGfujC0ImTYQWfn41wyw8pluJTSrhMGWIVeIZTgsLg,1160
 pyxcp/cpp_ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyxcp/cpp_ext/bin.hpp,sha256=PwJloZek21la-RBSda2Hc0u_6gID0sfTduPeplaAyR4,2561
 pyxcp/cpp_ext/blockmem.hpp,sha256=ysaJwmTWGTfE54Outk3gJYOfAVFd_QaonBMtXLcXwCc,1242
-pyxcp/cpp_ext/cpp_ext.cp310-win_amd64.pyd,sha256=X1rZXoHpHAprFWKGpSA55a-diCAzV1hCDxulqR5BtOE,285184
-pyxcp/cpp_ext/cpp_ext.cp311-win_amd64.pyd,sha256=FGLv2Mk_VY7IX8Ekrc1pei465rcClJ6FCq383yxHRlQ,286720
-pyxcp/cpp_ext/cpp_ext.cp312-win_amd64.pyd,sha256=EYY4A_4gx1ZiIBBeGCSkIzvPyeUCAT2Rr98hwv7TJpk,291840
-pyxcp/cpp_ext/cpp_ext.cp313-win_amd64.pyd,sha256=zctyoJArDAmRM7cdMxp8eTLjgvGZNltHsccXp1X-7OU,291328
+pyxcp/cpp_ext/cpp_ext.cp310-win_amd64.pyd,sha256=06wlmKXUq518IN8Pqp6z37nfjhBeZmiyEu1EmPZXQeg,285184
+pyxcp/cpp_ext/cpp_ext.cp311-win_amd64.pyd,sha256=0OnABdaqJW_BSavyeIdDfVTv3jFIETJkooMERA5jFPo,286720
+pyxcp/cpp_ext/cpp_ext.cp312-win_amd64.pyd,sha256=PTdXxjZYSuYuCu00VhwQm2axTKC2qNF14Tt_D9LVLfg,291840
+pyxcp/cpp_ext/cpp_ext.cp313-win_amd64.pyd,sha256=w2H0qj9JYsWkP10d1CU2-cz6PbNzH7z6JvYBHaKlhUM,291328
 pyxcp/cpp_ext/daqlist.hpp,sha256=g2hlxgoQorAGKHedZFZ0c2FQh1APMIA9sVB6M6hD_n8,7277
 pyxcp/cpp_ext/event.hpp,sha256=Z-1yxsEKsr81NnLVEWJ2ANA8FV7YsM7EbNxaw-elheE,1200
 pyxcp/cpp_ext/extension_wrapper.cpp,sha256=xFs3IcrvHPHA82-n11WPzt8HATGqcks02p84SjQ2BKM,4855
@@ -37,12 +37,12 @@ pyxcp/cpp_ext/tsqueue.hpp,sha256=FWMemzXNgV5dQ7gYmTCzC0QYfgl0VI9JCybYelBcCHU,102
 pyxcp/daq_stim/__init__.py,sha256=2KsvP9RUV5gwFKTA1BBgsppAegR13ykrqjRtgY0zAx4,9560
 pyxcp/daq_stim/optimize/__init__.py,sha256=FUWK0GkNpNT-sUlhibp7xa2aSYpm6Flh5yA2w2IOJqg,2520
 pyxcp/daq_stim/optimize/binpacking.py,sha256=Iltho5diKlJG-ltbmx053U2vOFRlCISolXK61T14l_I,1257
-pyxcp/daq_stim/scheduler.cpp,sha256=a7VK7kP2Hs8yMlcDAkXwJ0bH88lr_yz156sphcHS7Z4,715
+pyxcp/daq_stim/scheduler.cpp,sha256=NuNkAz3Dv849f51_T36YPck2dl-YsdDdG-cozc7XN9U,1504
 pyxcp/daq_stim/scheduler.hpp,sha256=U_6tUbebmzX5vVZS0EFSgTaPsyxMg6yRXHG_aPWA0x4,1884
-pyxcp/daq_stim/stim.cp310-win_amd64.pyd,sha256=AI-gVCR1lauZUYplnGqeX-c7oX9pHa8liWW7nKeVYOo,204288
-pyxcp/daq_stim/stim.cp311-win_amd64.pyd,sha256=RPq8Bl43UcgT0qWluCMMfGEdLjZAZRngHVZYYDAI1ww,205824
-pyxcp/daq_stim/stim.cp312-win_amd64.pyd,sha256=Mg8gSsRiidGBa2MdEIOjI9AD2uYsxD32y-LwHMUfRa8,209920
-pyxcp/daq_stim/stim.cp313-win_amd64.pyd,sha256=c7TLkUgw05kVUxh7wCEQ2sKZ8jYNgK1HMjXc8ka05b0,209920
+pyxcp/daq_stim/stim.cp310-win_amd64.pyd,sha256=F0tp7tDp0H06jcSnnWizOKIEakeNwl0IPhFsT9dBYvY,204288
+pyxcp/daq_stim/stim.cp311-win_amd64.pyd,sha256=vKADm1t9UviD7Yg6OTK0ht0zyAxxH_xvHJcfzyhaFTA,205824
+pyxcp/daq_stim/stim.cp312-win_amd64.pyd,sha256=W0iiXJ_s5nju8trqorOuLIwMoF2bQm06kC1G2h6XZds,209920
+pyxcp/daq_stim/stim.cp313-win_amd64.pyd,sha256=9AkQtgVGyB2Q7iW-YWo-8Vf7V97LWw9iBit8JKNnT7E,209920
 pyxcp/daq_stim/stim.cpp,sha256=F2OG67W4KKwTTiUCxm-9egIv3TLFdOkRunX6xf7YOtc,177
 pyxcp/daq_stim/stim.hpp,sha256=U-uInRrA6OCdMl1l1SWbQ_KEPpnNYrWut924IvbW6R0,18508
 pyxcp/daq_stim/stim_wrapper.cpp,sha256=iT2yxJ3LRG7HoYC1bwhM3tCAxF9X_HHierBNsLRmTJg,1995
@@ -62,7 +62,7 @@ pyxcp/examples/xcp_policy.py,sha256=io9tS2W-7PvR8ZzU203KolFrDp67eorUlwNWvA4kC5k,
 pyxcp/examples/xcp_read_benchmark.py,sha256=zOG0Yrji10vA0vhHa27KK7zgc3JDpzXzXsFnIU4C_AM,956
 pyxcp/examples/xcp_skel.py,sha256=YXLQC8nn8aAwYSVuBGhr1dvmdMBjmO1Ee1w3e5sy16s,1159
 pyxcp/examples/xcp_unlock.py,sha256=5F7oW17MboxKO3REYrGyhYX4Oc0Dg1oD3EQ3fQXB2Is,690
-pyxcp/examples/xcp_user_supplied_driver.py,sha256=bL-6HDvPjgRErvYVdaRL_Pg1GDxu02Jt_GG9LpXXP4c,1078
+pyxcp/examples/xcp_user_supplied_driver.py,sha256=9fFiud6sbjkBjxmcdGwIO6yBc83sUykY388gvI5EcXU,1148
 pyxcp/examples/xcphello.py,sha256=ZNfnk0nyz6qiY2i5L0lFFng42RwZdREwevIJW7C5QCA,2638
 pyxcp/examples/xcphello_recorder.py,sha256=QHWJsq5h5CI9t5qEmMSorZyzirTpoXz4nzuKTMzbZCA,3409
 pyxcp/master/__init__.py,sha256=QQbkUJM1WQ-5p2MiNFYxLAmHhNsCQLzDp-S4aoOFxoA,318
@@ -84,10 +84,10 @@ pyxcp/recorder/mio.hpp,sha256=5ASJLKSEykH0deAQD5uak-_yAgd5p2n8t06315GSGrg,63346
 pyxcp/recorder/reader.hpp,sha256=rr9XZ_ciL6eF2_xEqyt9XYNqTIze9ytAsnf8uYukO9U,5201
 pyxcp/recorder/reco.py,sha256=6N6FIwfCEVMpi5dr3eUOQa1lowcg2LCnS_sy_-b-UiQ,8725
 pyxcp/recorder/recorder.rst,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyxcp/recorder/rekorder.cp310-win_amd64.pyd,sha256=1epHArm46oNuEuUM_PqKtjEBjRCRsYVP-HO-b91juK0,385536
-pyxcp/recorder/rekorder.cp311-win_amd64.pyd,sha256=pIQrKREnVtqExyjN1Y-qquSuJvKhYcXPRFCeMpzo7yQ,387584
-pyxcp/recorder/rekorder.cp312-win_amd64.pyd,sha256=WUVGJBGkmki2yRs96OKk_lSvujGcYJQxWWQhAIJoP7A,392192
-pyxcp/recorder/rekorder.cp313-win_amd64.pyd,sha256=tILwhFb0_u4DJx9CMGeg-MFjsx9tSOpBYtbIGgO3auk,392192
+pyxcp/recorder/rekorder.cp310-win_amd64.pyd,sha256=yqeVlyQA8MQ2zPxt9-JXyyEvc94gJ1QkBA7N6KImFeo,385536
+pyxcp/recorder/rekorder.cp311-win_amd64.pyd,sha256=8Ix-n8z4PWJkEeZ4kDYtz1DCSrWSFVPs4FbYF4DTWo0,387584
+pyxcp/recorder/rekorder.cp312-win_amd64.pyd,sha256=Rb_F4sqPANQx8SR_uP-aVmoL6TD6t4CZYA0pYfahR7Q,392192
+pyxcp/recorder/rekorder.cp313-win_amd64.pyd,sha256=l_XH-sb9qFqHD0tVfLbwWfC2w6rZJOqoVS4lRuSGj2I,392192
 pyxcp/recorder/rekorder.cpp,sha256=U0LMyk8pZXx9emgS_WPVthvn_9IpgE7JGrh4kg-8CX4,1900
 pyxcp/recorder/rekorder.hpp,sha256=sWvRch9bVt6mmgrFHp5mwWhap7HoFG4geeb7UqEIzio,7638
 pyxcp/recorder/setup.py,sha256=_99XFPQAd5V4LcJaSGJwdnbxgxJ7kl8DEXfHsnKO1Yg,998
@@ -100,7 +100,7 @@ pyxcp/scripts/pyxcp_probe_can_drivers.py,sha256=P_gscDTAofbSVA_Wd1GATrnyWGTf1-Dz
 pyxcp/scripts/xcp_examples.py,sha256=q2wNXHVZu4GjcIlZwp2j9Sqm5QH39Olro4BQaLoIqiM,2583
 pyxcp/scripts/xcp_fetch_a2l.py,sha256=72818jdJiLsDuWWfkAPxekZ7fzRRz_A4RVSy06LQNe4,1239
 pyxcp/scripts/xcp_id_scanner.py,sha256=2P53qrvM-rYFTBbbm7eAKyOxESkKrorieND-KoZZ9mo,421
-pyxcp/scripts/xcp_info.py,sha256=H4bDcJilgkzHWapuCT49A3dq04CAwrp7z0zv1ibwkZQ,5711
+pyxcp/scripts/xcp_info.py,sha256=ZRwXIfQNw4KSrAw-9VlNMpzKzGPwkUasUiZ1SGBs8Hc,5649
 pyxcp/scripts/xcp_profile.py,sha256=ryJnx7cqQ40O05F3beuUEOthsiW_k9d_2wMf4Z9CWkc,615
 pyxcp/scripts/xmraw_converter.py,sha256=LvjiKAWHUKs5QZNiIDT-vdNgPG0Gioas2MzLJOo62-Y,684
 pyxcp/stim/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -118,7 +118,7 @@ pyxcp/timing.py,sha256=zE6qPqOuidg6saNt7_zmbQgufxL9Id6akVYhAtpweQc,1705
 pyxcp/transport/__init__.py,sha256=31PaQLj76n5pXr68aJRWcYfrxEYWWgYoe9f_w3jZxsc,438
 pyxcp/transport/base.py,sha256=n_tCkebmpq3WXRZncOP5XWgUnSavaBBm3oGZhpeCF9U,16352
 pyxcp/transport/base_transport.hpp,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyxcp/transport/can.py,sha256=pypHU1k5lZODrZpNLsC3IEJ5pPi58OZU_zryd9twr_M,14926
+pyxcp/transport/can.py,sha256=Sm2qu5JOSZ-f-PdgHVknTm1JTAH_L2DNxTxb5OJUCpI,18806
 pyxcp/transport/eth.py,sha256=xPzN2oSALoPKJVvZpBljPSV1AxfpjRusOzymO-TD1Rw,8711
 pyxcp/transport/sxi.py,sha256=kWB9x5M1pS7GBtBW6R65KBX7zDI9zcRRZhFM8frmzU0,4760
 pyxcp/transport/transport_wrapper.cpp,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -127,8 +127,8 @@ pyxcp/types.py,sha256=mjp3FhsTTbS3D5VuC-dfdbMql0lJwEfbZjf8a2pHi1o,26158
 pyxcp/utils.py,sha256=_ag2QMt0IxVhiCLG5BIO8JzIGt-rdqYrY7DRAPQ4AtA,3530
 pyxcp/vector/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyxcp/vector/map.py,sha256=7Gnhvr79geMeqqGVIJPxODXGwABdNDinnqzhpooN5TE,2306
-pyxcp-0.22.35.dist-info/entry_points.txt,sha256=LkHsEwubm30s4oiyCy0cKj6k97ALvQ6KjAVdyEcqu7g,358
-pyxcp-0.22.35.dist-info/LICENSE,sha256=fTqV5eBpeAZO0_jit8j4Ref9ikBSlHJ8xwj5TLg7gFk,7817
-pyxcp-0.22.35.dist-info/METADATA,sha256=1FG4ObUxb7QK7YO8yFEUJioWfGLPbX0gDB5apo2Hz3Q,4085
-pyxcp-0.22.35.dist-info/WHEEL,sha256=mALHoYUTvmSuUvATXVCIUbSdKauf2WkQvaEK6Gk1YTE,98
-pyxcp-0.22.35.dist-info/RECORD,,
+pyxcp-0.23.1.dist-info/entry_points.txt,sha256=LkHsEwubm30s4oiyCy0cKj6k97ALvQ6KjAVdyEcqu7g,358
+pyxcp-0.23.1.dist-info/LICENSE,sha256=fTqV5eBpeAZO0_jit8j4Ref9ikBSlHJ8xwj5TLg7gFk,7817
+pyxcp-0.23.1.dist-info/METADATA,sha256=SSK24XxtgfqPWfnBC70rkXdY_vWCxI3aI6FfQHGU34k,4084
+pyxcp-0.23.1.dist-info/WHEEL,sha256=mALHoYUTvmSuUvATXVCIUbSdKauf2WkQvaEK6Gk1YTE,98
+pyxcp-0.23.1.dist-info/RECORD,,