pyxcp 0.22.35__tar.gz → 0.23.1__tar.gz

{pyxcp-0.22.35 → pyxcp-0.23.1}/PKG-INFO

@@ -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 → pyxcp-0.23.1}/pyproject.toml

@@ -37,7 +37,7 @@ dynamic = ["license", "readme", "authors", "requires-python", "description", "cl
 [tool.poetry]
 authors = ["Christoph Schueler <cpu.gems@googlemail.com>"]
 name = "pyxcp"
-version = "0.22.35"
+version = "0.23.1"
 readme = "README.md"
 description = "Universal Calibration Protocol for Python"
 keywords = ["automotive", "ecu", "xcp", "asam", "autosar"]
@@ -173,9 +173,6 @@ build = "cp3{10,11,12,13,14}-*"
 skip = ["*_i686", "*-musllinux*"]
 build-frontend = "build"
 
-[tool.cibuildwheel.windows]
-archs = ["AMD64"]
-
 [tool.pyright]
 include = ["pyxcp", "build_ext.py"]
 ignore = ["pyxcp/recorder/converter/**", "pyxcp/recorder/simdjson/**","pyxcp/recorder/mio/**", "pyxcp/recorder/lz4/**"]

{pyxcp-0.22.35 → pyxcp-0.23.1}/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-0.22.35 → pyxcp-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-0.23.1/pyxcp/daq_stim/scheduler.cpp

@@ -0,0 +1,62 @@
+#include "scheduler.hpp"
+
+#if defined(_WIN32)
+
+#include <cstdio>
+#include <cstdint>
+
+VOID CALLBACK TimerRoutine(PVOID lpParam, BOOLEAN TimerOrWaitFired) {
+    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 {
+        std::printf("The wait event was signaled.\n");
+    }
+}
+
+#endif // _WIN32
+
+// Vectorized multiply implementation with bounds checking
+namespace {
+    constexpr size_t VECTOR_SIZE = 4;
+}
+
+#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-0.23.1/pyxcp/examples/xcp_user_supplied_driver.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python
+
+from typing import Dict, List, Optional
+
+import can
+
+from pyxcp.cmdline import ArgumentParser
+from pyxcp.transport.can import CanInterfaceBase
+
+
+class CustomCANInterface(CanInterfaceBase):
+
+    def init(self):
+        """Initialize the CAN interface here."""
+
+    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 send(self, msg: can.message.Message):
+        """Send CAN frames."""
+        print(f"send({msg})")
+
+    @property
+    def filters(self):
+        """Return the current CAN filters."""
+        return self._filters
+
+    @property
+    def state(self):
+        """Return the current state of the CAN interface."""
+        return can.BusState.ACTIVE
+
+
+custom_interface = CustomCANInterface()
+
+ap = ArgumentParser(description="User supplied CAN driver.")
+with ap.run(transport_layer_interface=custom_interface) as x:
+    x.connect()
+    x.disconnect()

{pyxcp-0.22.35 → pyxcp-0.23.1}/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-0.22.35 → pyxcp-0.23.1}/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/pyxcp/daq_stim/scheduler.cpp

@@ -1,28 +0,0 @@
-
-#include "scheduler.hpp"
-
-#if defined(_WIN32)
-
-VOID CALLBACK TimerRoutine(PVOID lpParam, BOOLEAN TimerOrWaitFired) {
-    if (lpParam == NULL) {
-        printf("TimerRoutine lpParam is NULL\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");
-        }
-    }
-}
-
-    #include <xmmintrin.h>
-
-void mul4_vectorized(float* ptr) {
-    __m128 f = _mm_loadu_ps(ptr);
-    f        = _mm_mul_ps(f, f);
-    _mm_storeu_ps(ptr, f);
-}
-#endif

pyxcp-0.22.35/pyxcp/examples/xcp_user_supplied_driver.py

@@ -1,54 +0,0 @@
-#!/usr/bin/env python
-"""User supplied CAN driver.
-
-Run as:
-
-.. code-block:: shell
-
-    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):
-    """
-
-    Relevant options in your configuration file (e.g. conf_can_user.toml):
-
-    TRANSPORT = "CAN"
-    CAN_DRIVER = "MyCI"     # The name of your custom driver class.
-
-    """
-
-    def init(self, parent, receive_callback):
-        self.parent = parent
-
-    def connect(self):
-        pass
-
-    def close(self):
-        pass
-
-    def get_timestamp_resolution(self):
-        pass
-
-    def read(self):
-        pass
-
-    def transmit(self, payload: bytes):
-        print("\tTX-PAYLOAD", payload)
-
-
-ap = ArgumentParser(description="User supplied CAN driver.")
-with ap.run() 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).
-"""