pyxcp 0.22.35__cp312-cp312-macosx_11_0_arm64.whl → 0.23.1__cp312-cp312-macosx_11_0_arm64.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,15 +1,15 @@
-pyxcp-0.22.35.dist-info/RECORD,,
-pyxcp-0.22.35.dist-info/LICENSE,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
-pyxcp-0.22.35.dist-info/WHEEL,sha256=HdXaJ5oV0dCHo2ILOORlQC0rLhdm1c_ApHYRuS7PtwE,134
-pyxcp-0.22.35.dist-info/entry_points.txt,sha256=LkHsEwubm30s4oiyCy0cKj6k97ALvQ6KjAVdyEcqu7g,358
-pyxcp-0.22.35.dist-info/METADATA,sha256=1FG4ObUxb7QK7YO8yFEUJioWfGLPbX0gDB5apo2Hz3Q,4085
+pyxcp-0.23.1.dist-info/RECORD,,
+pyxcp-0.23.1.dist-info/LICENSE,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
+pyxcp-0.23.1.dist-info/WHEEL,sha256=HdXaJ5oV0dCHo2ILOORlQC0rLhdm1c_ApHYRuS7PtwE,134
+pyxcp-0.23.1.dist-info/entry_points.txt,sha256=LkHsEwubm30s4oiyCy0cKj6k97ALvQ6KjAVdyEcqu7g,358
+pyxcp-0.23.1.dist-info/METADATA,sha256=SSK24XxtgfqPWfnBC70rkXdY_vWCxI3aI6FfQHGU34k,4084
 pyxcp/dllif.py,sha256=m4e-_dgDLCD6COU5W2LdeYUlib_Xxyxbh977bbS-VAU,3344
 pyxcp/checksum.py,sha256=aveS0z4vthLXABEFhTqELqFNi7LM6ZzDzq7dD5Xe9oo,11167
 pyxcp/asamkeydll.sh,sha256=iema12sub6qNE0xAuzwGtx0FmkdaaOKoXalhrtWVaa8,57
 pyxcp/asamkeydll.c,sha256=l5RHYcEPY_Q07G-W5IjCq0xci8YfUR-3uYt84OOkOJI,2836
 pyxcp/constants.py,sha256=Yemk_Gi_m78EEU0v-sdGCAodb9dv_vqP969IU3izA2M,1113
 pyxcp/cmdline.py,sha256=lNg_wedKShu_37RhuTIGlINGLSMrg6UqJmYpqQnJbQI,1477
-pyxcp/__init__.py,sha256=Syqs7GgVi938EmpSl12H_YqMJl5dUAfsPZfuDDc-HtE,528
+pyxcp/__init__.py,sha256=ZKSl3JNYiFQiF3bEXjWiifj1t0TbnYBzGUeyKok01GY,527
 pyxcp/types.py,sha256=XJxJUh9bK5Urfia8IHVLJ-NFgQACYBd_n73L-AaeZts,25158
 pyxcp/timing.py,sha256=hzeQZ3P7ij_bfskoVMi10Iv5S4i_6TQYfnB8PXTX6c4,1645
 pyxcp/utils.py,sha256=Ax3TNT4OotRdJs_MVz83i7gTinpbOWwPnNVIL9WYTW4,3402
@@ -20,7 +20,7 @@ pyxcp/asam/types.py,sha256=V4wSCGI1pXn0EsBemDyaHTBgY2wkV_BeLShnDIGGgDE,2310
 pyxcp/daq_stim/stim.cpython-312-darwin.so,sha256=L9OoS4MPieqeyB-AkHf-lEp9vAw9sRH7HuVJr-i7sNI,237656
 pyxcp/daq_stim/stim.cpp,sha256=sABgEfbQlt5kXbzAsndyhaDFWRWTJw3jJlNfanIVrRs,164
 pyxcp/daq_stim/__init__.py,sha256=HAfOpn4yeb4DYNZHr6pzpFGHisXbKEytXJ6KUatDMTk,9328
-pyxcp/daq_stim/scheduler.cpp,sha256=6YJV4IfKbIL9MJOVJqqabaeK5apUcFuDpwmoWRfyCSQ,687
+pyxcp/daq_stim/scheduler.cpp,sha256=2XW9PmxrJR8DfYMVszGwBX-KANVviwPcUNBvnjw5MlM,1443
 pyxcp/daq_stim/stim.hpp,sha256=1DwAhkY7XJN14aD2BxLJ4O1j4_a6RvpePIbAG1U8iOA,17904
 pyxcp/daq_stim/stim.cpython-310-darwin.so,sha256=RqFNsPbyPi8oHidN2ACHa6aPRQadF14q068jvjDhGKE,237576
 pyxcp/daq_stim/scheduler.hpp,sha256=H-kwyZBV3S8q6YlCq6OLUbaNXskyCOS4z3SRP32ikPY,1809
@@ -34,10 +34,10 @@ pyxcp/transport/sxi.py,sha256=gbFTOA-O0q0RwZUbRgN3hCdkoutxMt15TgVjVwdvWsY,4625
 pyxcp/transport/base_transport.hpp,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyxcp/transport/__init__.py,sha256=wIeYkGygucYdXEzymJcDvimnwZgqJY8KRv7Mk__aUSU,428
 pyxcp/transport/usb_transport.py,sha256=27c19S67BMq1Eup6ViX-SiYpEq93bMTwe031RsE4Xm0,8130
-pyxcp/transport/can.py,sha256=bzKV9Lh5suKdZ5dm3ZEz1osOqkRZNlxrVAW7vr38JSM,14485
+pyxcp/transport/can.py,sha256=uFPG_Caf1BwIo2pKheZLs0VfPth1KoEPxuKtI2qt9as,18250
 pyxcp/transport/base.py,sha256=i9VdWqGNqx5LMdFkD8SmmMQSRoDDXAjMRS3p6KD1A8E,15912
 pyxcp/config/legacy.py,sha256=Uhu_6bp_W8yGmZ2s3TFzf8-5mGwLdeTss56BMYWpsZY,5100
-pyxcp/config/__init__.py,sha256=vIYPtzzNI4kUmevpOsSFgbfuBXPq7e2bhIIwWcqPcqQ,41835
+pyxcp/config/__init__.py,sha256=hM1eQtllcZeZ4zo9YzscO2Z5EOpV3hWyZgY9GZMiavw,42085
 pyxcp/tests/test_utils.py,sha256=gqv3bhhWfKKdKDkqnELqsOHCfpRRZwlReEy87Ya4Z2w,850
 pyxcp/tests/test_master.py,sha256=a_Q8Fa49y_3vnrp-VFZ-22cHWjq58RC2daF6EcfbhZc,69434
 pyxcp/tests/test_daq.py,sha256=mThMsweEwxzIFRQQ88BNz_60OQ-xmC5OamIxHx9VWis,5358
@@ -71,7 +71,7 @@ pyxcp/examples/conf_nixnet.json,sha256=R-RKw172YhssO_9rud5McxtjesphEadA9Ub2OEKHp
 pyxcp/examples/conf_sxi.json,sha256=rDh7LyaqtvYoYjMaVo1gqEkS_hiTGdXlW4O6ivzGhFo,149
 pyxcp/examples/conf_can_vector.json,sha256=VtGmyt9ORPTo9yirv1fZM_XT9DARFFNwai11RaCNRWo,238
 pyxcp/examples/conf_can_user.toml,sha256=BqCID-GvaNbA6pbqRbyRMuzKAsJaYVube0ql4CvkMoY,298
-pyxcp/examples/xcp_user_supplied_driver.py,sha256=TD8Ggzdb2T9o6Z-VMvuJMREMpzufI5u27ThaadCxhDg,1024
+pyxcp/examples/xcp_user_supplied_driver.py,sha256=Wyep2KhtcFC2GzZuJPj5ikSqWIWYsf5D0mfs1jCtYX0,1104
 pyxcp/examples/xcp_skel.py,sha256=F2g2C79jiYZl0cpRHfzWusfn1ZvodOS_r1Az6aknZL4,1110
 pyxcp/examples/xcp_unlock.py,sha256=vl2Zv7Z6EuBxI2ZxbGQK6-0tZBVqd72FZllsvIfuJ5w,652
 pyxcp/examples/xcphello.py,sha256=yB1YEpxCLuCnjvN5pjZbB3obfSMEEdtfrER57KQ8KE4,2560
@@ -86,7 +86,7 @@ pyxcp/scripts/xmraw_converter.py,sha256=W_Znm5OzBKfcyiUgwHIaLYdc2DEusX6jv2b03KAH
 pyxcp/scripts/xcp_profile.py,sha256=5IoBMv8tV64nxKCVaJ4bBF7dl3_fqqsQ2tr0OoM87Vw,588
 pyxcp/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyxcp/scripts/xcp_fetch_a2l.py,sha256=tLdrU03xmnfz_-FeYSq-TH5ZsDLvpQRBvXpO5NZZohU,1199
-pyxcp/scripts/xcp_info.py,sha256=sslBR_FBXYGG_W-SW1pZvtLBvyGO3jQKko-SqGqR2_0,5565
+pyxcp/scripts/xcp_info.py,sha256=vXGNjO8tFJhiudp9ItZ9946NIRStj4brEpY4nNo9bTo,5505
 pyxcp/scripts/xcp_examples.py,sha256=rsvpb6moMhBxAcP5hBnHug9x-6i65WVwL5Q_tHty59c,2519
 pyxcp/scripts/pyxcp_probe_can_drivers.py,sha256=qnNLYa6hInzNrVyYh7xXYt_SB5b-tgMJHXJwIkz7lbE,547
 pyxcp/recorder/build_gcc_arm.sh,sha256=spqHf6D8Jd4NACYG65SNjb-BLMntELwBDO4PpHUiyYc,238