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

pyxcp/daq_stim/__init__.py

@@ -1,12 +1,14 @@
 #!/usr/bin/env python
 
-# from pprint import pprint
+from contextlib import suppress
+import json
 from time import time_ns
-from typing import Dict, List, Optional, TextIO
+from typing import Any, Dict, List, Optional, TextIO, Tuple, Union
+
+from pyxcp.cpp_ext.cpp_ext import DaqList, PredefinedDaqList
 
 from pyxcp import types
 from pyxcp.config import get_application
-from pyxcp.cpp_ext.cpp_ext import DaqList
 from pyxcp.daq_stim.optimize import make_continuous_blocks
 from pyxcp.daq_stim.optimize.binpacking import first_fit_decreasing
 from pyxcp.recorder import DaqOnlinePolicy as _DaqOnlinePolicy
@@ -14,7 +16,6 @@ from pyxcp.recorder import DaqRecorderPolicy as _DaqRecorderPolicy
 from pyxcp.recorder import MeasurementParameters
 from pyxcp.utils import CurrentDatetime
 
-
 DAQ_ID_FIELD_SIZE = {
     "IDF_ABS_ODT_NUMBER": 1,
     "IDF_REL_ODT_NUMBER_ABS_DAQ_LIST_NUMBER_BYTE": 2,
@@ -29,11 +30,90 @@ DAQ_TIMESTAMP_SIZE = {
 }
 
 
+def load_daq_lists_from_json(file_path: str) -> List[DaqList]:
+    """Load and validate DAQ-list from JSON file."""
+    with open(file_path, "r", encoding="utf-8") as f:
+        config = json.load(f)
+
+    if not isinstance(config, list):
+        raise ValueError("DAQ configuration must be a JSON array (list)")
+
+    daq_lists: List[DaqList] = []
+    for idx, entry in enumerate(config):
+        if not isinstance(entry, dict):
+            raise TypeError(f"Entry {idx} must be an object/dict")
+
+        required = {"name", "event_num", "stim", "enable_timestamps", "measurements", "priority", "prescaler"}
+        missing = required - set(entry.keys())
+        if missing:
+            raise ValueError(f"Entry {idx} missing required keys: {missing}")
+
+        # Basic type conversions / checks
+        name = entry["name"]
+        if not isinstance(name, str):
+            raise TypeError(f"Entry {idx} 'name' must be a string")
+
+        try:
+            event_num = int(entry["event_num"])
+        except Exception as e:
+            raise TypeError(f"Entry {idx} 'event_num' must be an integer") from e
+
+        stim = bool(entry["stim"])
+        enable_timestamps = bool(entry["enable_timestamps"])
+
+        try:
+            priority = int(entry["priority"])
+            prescaler = int(entry["prescaler"])
+        except Exception as e:
+            raise TypeError(f"Entry {idx} 'priority' and 'prescaler' must be integers") from e
+
+        measurements_raw = entry["measurements"]
+        if not isinstance(measurements_raw, list):
+            raise TypeError(f"Entry {idx} 'measurements' must be a list")
+
+        measurements: List[Tuple[str, int, int, str]] = []
+        for m_idx, m in enumerate(measurements_raw):
+            if not (isinstance(m, (list, tuple)) and len(m) == 4):
+                raise ValueError(f"Entry {idx} measurement {m_idx} must be a 4-element list/tuple")
+            m_name, m_addr, m_offset, m_type = m
+
+            if not isinstance(m_name, str):
+                raise TypeError(f"Entry {idx} measurement {m_idx} name must be a string")
+            try:
+                m_addr = int(m_addr)
+            except Exception as e:
+                raise TypeError(f"Entry {idx} measurement {m_idx} address must be an integer") from e
+            try:
+                m_offset = int(m_offset)
+            except Exception as e:
+                raise TypeError(f"Entry {idx} measurement {m_idx} offset must be an integer") from e
+            if not isinstance(m_type, str):
+                raise TypeError(f"Entry {idx} measurement {m_idx} type must be a string")
+
+            measurements.append((m_name, m_addr, m_offset, m_type))
+
+        daq_kwargs: Dict[str, Any] = {
+            "name": name,
+            "event_num": event_num,
+            "stim": stim,
+            "enable_timestamps": enable_timestamps,
+            "measurements": measurements,
+            "priority": priority,
+            "prescaler": prescaler,
+        }
+
+        daq_lists.append(DaqList(**daq_kwargs))
+
+    return daq_lists
+
+
 class DaqProcessor:
-    def __init__(self, daq_lists: List[DaqList]):
-        # super().__init__()
+    def __init__(self, daq_lists: List[Union[DaqList, PredefinedDaqList]]):
         self.daq_lists = daq_lists
+        self.is_predefined = [isinstance(d, PredefinedDaqList) for d in daq_lists]
         self.log = get_application().log
+        # Flag indicating a fatal OS-level error occurred during DAQ (e.g., disk full, out-of-memory)
+        self._fatal_os_error: bool = False
 
     def setup(self, start_datetime: Optional[CurrentDatetime] = None, write_multiple: bool = True):
         if not self.xcp_master.slaveProperties.supportsDaq:
@@ -42,13 +122,14 @@ class DaqProcessor:
         if start_datetime is None:
             start_datetime = CurrentDatetime(time_ns())
         self.start_datetime = start_datetime
-        # print(self.start_datetime)
         try:
             processor = self.daq_info.get("processor")
             properties = processor.get("properties")
             resolution = self.daq_info.get("resolution")
-            if properties["configType"] == "STATIC":
-                raise TypeError("DAQ configuration is static, cannot proceed.")
+            if properties["configType"] == "STATIC" and not all(self.is_predefined):
+                raise TypeError(
+                    "DAQ configuration is static, but in your configuration are only dynamic DAQ lists -- cannot proceed."
+                )
             self.supports_timestampes = properties["timestampSupported"]
             self.supports_prescaler = properties["prescalerSupported"]
             self.supports_pid_off = properties["pidOffSupported"]
@@ -71,22 +152,24 @@ class DaqProcessor:
             max_payload_size = min(max_odt_entry_size, max_dto - header_len)
             # First ODT may contain timestamp.
             self.selectable_timestamps = False
+            max_payload_size_first = max_payload_size
             if not self.supports_timestampes:
-                max_payload_size_first = max_payload_size
-                # print("NO TIMESTAMP SUPPORT")
+                self.log.info("No timestamp support")
             else:
                 if self.ts_fixed:
-                    # print("Fixed timestamp")
+                    self.log.debug("Fixed timestamps")
                     max_payload_size_first = max_payload_size - self.ts_size
                 else:
-                    # print("timestamp variable.")
+                    self.log.debug("Variable timestamps.")
                     self.selectable_timestamps = True
-
         except Exception as e:
             raise TypeError(f"DAQ_INFO corrupted: {e}") from e
 
         # DAQ optimization.
-        for daq_list in self.daq_lists:
+        # For dynamic DaqList instances, compute physical layout; skip for PredefinedDaqList.
+        for idx, daq_list in enumerate(self.daq_lists):
+            if isinstance(daq_list, PredefinedDaqList):
+                continue
             if self.selectable_timestamps:
                 if daq_list.enable_timestamps:
                     max_payload_size_first = max_payload_size - self.ts_size
@@ -97,34 +180,47 @@ class DaqProcessor:
         byte_order = 0 if self.xcp_master.slaveProperties.byteOrder == "INTEL" else 1
         self._first_pids = []
         daq_count = len(self.daq_lists)
-        self.xcp_master.freeDaq()
-
-        # Allocate
-        self.xcp_master.allocDaq(daq_count)
-        measurement_list = []
-        for i, daq_list in enumerate(self.daq_lists, self.min_daq):
-            measurements = daq_list.measurements_opt
-            measurement_list.append((i, measurements))
-            odt_count = len(measurements)
-            self.xcp_master.allocOdt(i, odt_count)
-        # Iterate again over ODT entries -- we need to respect sequencing requirements.
-        for i, measurements in measurement_list:
-            for j, measurement in enumerate(measurements):
-                entry_count = len(measurement.entries)
-                self.xcp_master.allocOdtEntry(i, j, entry_count)
-        # Write DAQs
-        for i, daq_list in enumerate(self.daq_lists, self.min_daq):
-            measurements = daq_list.measurements_opt
-            for j, measurement in enumerate(measurements):
-                if len(measurement.entries) == 0:
-                    continue  # CAN special case: No room for data in first ODT.
-                self.xcp_master.setDaqPtr(i, j, 0)
-                for entry in measurement.entries:
-                    self.xcp_master.writeDaq(0xFF, entry.length, entry.ext, entry.address)
+
+        # Decide whether DAQ allocation must be performed.
+        config_static = self.daq_info.get("processor", {}).get("properties", {}).get("configType") == "STATIC"
+
+        if not config_static:
+            # For dynamic configuration, program only dynamic (non-predefined) DAQ lists.
+            self.xcp_master.freeDaq()
+            # Allocate the number of DAQ lists required.
+            self.xcp_master.allocDaq(daq_count)
+            measurement_list = []
+            for i, daq_list in enumerate(self.daq_lists, self.min_daq):
+                if isinstance(daq_list, PredefinedDaqList):
+                    # Skip allocation for predefined DAQ lists.
+                    continue
+                measurements = daq_list.measurements_opt
+                measurement_list.append((i, measurements))
+                odt_count = len(measurements)
+                self.xcp_master.allocOdt(i, odt_count)
+            # Iterate again over ODT entries -- we need to respect sequencing requirements.
+            for i, measurements in measurement_list:
+                for j, measurement in enumerate(measurements):
+                    entry_count = len(measurement.entries)
+                    self.xcp_master.allocOdtEntry(i, j, entry_count)
+            # Write DAQs (only for dynamic lists)
+            for i, daq_list in enumerate(self.daq_lists, self.min_daq):
+                if isinstance(daq_list, PredefinedDaqList):
+                    continue
+                measurements = daq_list.measurements_opt
+                for j, measurement in enumerate(measurements):
+                    if len(measurement.entries) == 0:
+                        continue  # CAN special case: No room for data in first ODT.
+                    self.xcp_master.setDaqPtr(i, j, 0)
+                    for entry in measurement.entries:
+                        self.xcp_master.writeDaq(0xFF, entry.length, entry.ext, entry.address)
+        else:
+            # STATIC configuration on the slave: skip allocation and programming; lists/ODTs are predefined.
+            pass
 
         # arm DAQ lists -- this is technically a function on its own.
-        for i, daq_list in enumerate(self.daq_lists, self.min_daq):
-            # print(daq_list.name, daq_list.event_num, daq_list.stim)
+        first_daq_list = 0 if config_static else self.min_daq
+        for i, daq_list in enumerate(self.daq_lists, first_daq_list):
             mode = 0x00
             if self.supports_timestampes and (self.ts_fixed or (self.selectable_timestamps and daq_list.enable_timestamps)):
                 mode = 0x10
@@ -142,8 +238,6 @@ class DaqProcessor:
             )
             res = self.xcp_master.startStopDaqList(0x02, i)
             self._first_pids.append(res.firstPid)
-        if start_datetime:
-            pass
         self.measurement_params = MeasurementParameters(
             byte_order,
             header_len,
@@ -164,6 +258,26 @@ class DaqProcessor:
         self.xcp_master.startStopSynch(0x01)
 
     def stop(self):
+        # If a fatal OS error occurred during acquisition, skip sending stop to the slave to avoid
+        # cascading timeouts/unrecoverable errors and shut down transport gracefully instead.
+        if getattr(self, "_fatal_os_error", False):
+            with suppress(Exception):
+                self.log.error(
+                    "DAQ stop skipped due to previous fatal OS error (e.g., disk full or out-of-memory). Closing transport."
+                )
+            try:
+                # Best-effort: stop listener and close transport so threads finish cleanly.
+                if hasattr(self.xcp_master, "transport") and self.xcp_master.transport is not None:
+                    # Signal listeners to stop
+                    with suppress(Exception):
+                        if hasattr(self.xcp_master.transport, "closeEvent"):
+                            self.xcp_master.transport.closeEvent.set()
+
+                    # Close transport connection
+                    with suppress(Exception):
+                        self.xcp_master.transport.close()
+            finally:
+                return
         self.xcp_master.startStopSynch(0x00)
 
     def first_pids(self):
@@ -171,7 +285,6 @@ class DaqProcessor:
 
 
 class DaqRecorder(DaqProcessor, _DaqRecorderPolicy):
-
     def __init__(self, daq_lists: List[DaqList], file_name: str, prealloc: int = 200, chunk_size: int = 1):
         DaqProcessor.__init__(self, daq_lists)
         _DaqRecorderPolicy.__init__(self)
@@ -219,7 +332,31 @@ class DaqToCsv(DaqOnlinePolicy):
             out_file.write(f"{hdr}\n")
 
     def on_daq_list(self, daq_list: int, timestamp0: int, timestamp1: int, payload: list):
-        self.files[daq_list].write(f"{timestamp0},{timestamp1},{', '.join([str(x) for x in payload])}\n")
+        # Guard against hard OS errors (e.g., disk full) during file writes.
+        if getattr(self, "_fatal_os_error", False):
+            return
+        try:
+            self.files[daq_list].write(f"{timestamp0},{timestamp1},{', '.join([str(x) for x in payload])}\n")
+        except (OSError, MemoryError) as ex:
+            # Mark fatal condition to alter shutdown path and avoid further writes/commands.
+            self._fatal_os_error = True
+            with suppress(Exception):
+                self.log.critical(f"DAQ file write failed: {ex.__class__.__name__}: {ex}. Initiating graceful shutdown.")
+
+            # Stop listener to prevent more DAQ traffic and avoid thread crashes.
+            with suppress(Exception):
+                if hasattr(self.xcp_master, "transport") and self.xcp_master.transport is not None:
+                    if hasattr(self.xcp_master.transport, "closeEvent"):
+                        self.xcp_master.transport.closeEvent.set()
+            # Best-effort: close any opened files to flush buffers and release resources.
+            with suppress(Exception):
+                for f in getattr(self, "files", {}).values():
+                    with suppress(Exception):
+                        f.flush()
+                    with suppress(Exception):
+                        f.close()
+            # Do not re-raise; allow the system to continue to a controlled shutdown.
+            return
 
     def finalize(self):
         self.log.debug("DaqCsv::finalize()")

pyxcp/daq_stim/optimize/binpacking.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python
-"""Bin-packing algorithms.
-"""
+"""Bin-packing algorithms."""
+
 from typing import List, Optional
 
 from pyxcp.cpp_ext.cpp_ext import Bin

pyxcp/daq_stim/scheduler.cpp

@@ -10,10 +10,10 @@ VOID CALLBACK TimerRoutine(PVOID lpParam, BOOLEAN TimerOrWaitFired) {
         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 {
@@ -30,10 +30,10 @@ namespace {
 
 #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);
@@ -41,10 +41,10 @@ namespace {
 
 #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);
@@ -54,9 +54,9 @@ namespace {
     // 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
+#endif

pyxcp/errormatrix.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python
-"""Types and structures to support error-handling as specified by XCP.
-"""
+"""Types and structures to support error-handling as specified by XCP."""
+
 import enum
 from collections import namedtuple
 

pyxcp/examples/run_daq.py

@@ -129,8 +129,9 @@ else:
         ),
     ]
 
-daq_parser = DaqToCsv(DAQ_LISTS)  # Record to CSV file(s).
-# daq_parser = DaqRecorder(DAQ_LISTS, "run_daq", 2)  # Record to ".xmraw" file.
+
+# daq_parser = DaqToCsv(DAQ_LISTS)  # Record to CSV file(s).
+daq_parser = DaqRecorder(DAQ_LISTS, "run_daq_21092025_01", 8)  # Record to ".xmraw" file.
 
 with ap.run(policy=daq_parser) as x:
     try:
@@ -149,7 +150,8 @@ with ap.run(policy=daq_parser) as x:
     print("start DAQ lists.")
     daq_parser.start()  # Start DAQ lists.
 
-    time.sleep(5.0 * 60.0)  # Run for 15 minutes.
+    # time.sleep(2.0 * 60.0)
+    time.sleep(0.25 * 60.0 * 60.0)  # Run for 15 minutes.
 
     print("Stop DAQ....")
     daq_parser.stop()  # Stop DAQ lists.

pyxcp/examples/xcp_policy.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python
-"""Demostrates how to use frame recording policies including recorder extension.
-"""
+"""Demostrates how to use frame recording policies including recorder extension."""
+
 from pprint import pprint
 
 from pyxcp.cmdline import ArgumentParser
@@ -11,11 +11,11 @@ ap = ArgumentParser(description="pyXCP frame recording policy example.")
 
 LOG_FILE = "pyxcp"
 
-policy = FrameRecorderPolicy(LOG_FILE)
-use_recorder = True
+# policy = FrameRecorderPolicy(LOG_FILE)
+# use_recorder = True
 
-# policy = StdoutPolicy()  # You may also try this one.
-# use_recorder = False
+policy = StdoutPolicy()  # You may also try this one.
+use_recorder = False
 
 with ap.run(policy=policy) as x:
     x.connect()

pyxcp/examples/xcp_read_benchmark.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python
-"""Very basic hello-world example.
-"""
+"""Very basic hello-world example."""
+
 import time
 
 import matplotlib.pyplot as plt

pyxcp/examples/xcp_skel.py

@@ -1,6 +1,5 @@
 #!/usr/bin/env python
-"""Use this as a copy-and-paste template for your own scripts.
-"""
+"""Use this as a copy-and-paste template for your own scripts."""
 
 from pyxcp.cmdline import ArgumentParser
 

pyxcp/examples/xcp_unlock.py

@@ -1,20 +1,13 @@
 #!/usr/bin/env python
-"""Very basic hello-world example.
-"""
-from pyxcp.cmdline import ArgumentParser
-
-
-"""
-"""
+"""Very basic hello-world example."""
 
+import argparse
 
-def callout(master, args):
-    if args.sk_dll:
-        master.seedNKeyDLL = args.sk_dll
+from pyxcp.cmdline import ArgumentParser
 
 
-ap = ArgumentParser(callout)
-ap.parser.add_argument(
+parser = argparse.ArgumentParser(description="XCP unlock example")
+parser.add_argument(
     "-s",
     "--sk-dll",
     dest="sk_dll",
@@ -23,7 +16,12 @@ ap.parser.add_argument(
     default=None,
 )
 
+ap = ArgumentParser(parser)
+
 with ap.run() as x:
+    if ap.args.sk_dll:
+        x.seedNKeyDLL = ap.args.sk_dll
+
     x.connect()
 
     print("")

pyxcp/examples/xcp_user_supplied_driver.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python
 
-from typing import Dict, List, Optional
+from typing import Optional
 
 import can
 
@@ -9,7 +9,6 @@ from pyxcp.transport.can import CanInterfaceBase
 
 
 class CustomCANInterface(CanInterfaceBase):
-
     def init(self):
         """Initialize the CAN interface here."""
 

pyxcp/examples/xcphello.py

@@ -1,5 +1,6 @@
 #!/usr/bin/env python
 """Very basic hello-world example."""
+
 from pprint import pprint
 
 from pyxcp.cmdline import ArgumentParser
@@ -9,21 +10,7 @@ from pyxcp.utils import decode_bytes
 daq_info = False
 
 
-def callout(master, args):
-    global daq_info
-    if args.daq_info:
-        daq_info = True
-
-
-ap = ArgumentParser(description="pyXCP hello world.", callout=callout)
-ap.parser.add_argument(
-    "-d",
-    "--daq-info",
-    dest="daq_info",
-    help="Display DAQ-info",
-    default=False,
-    action="store_true",
-)
+ap = ArgumentParser(description="pyXCP hello world.")
 
 with ap.run() as x:
     x.connect()

pyxcp/examples/xcphello_recorder.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python
-"""Very basic hello-world example.
-"""
+"""Very basic hello-world example."""
+
 from pprint import pprint
 
 from pyxcp.cmdline import ArgumentParser

pyxcp/master/__init__.py

@@ -6,4 +6,5 @@
 
 .. [1] XCP Specification, Part 2 - Protocol Layer Specification
 """
+
 from .master import Master  # noqa: F401