pyxcp 0.25.2__cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl

pyxcp/daq_stim/__init__.py

@@ -0,0 +1,306 @@
+#!/usr/bin/env python
+
+from time import time_ns
+from typing import Dict, List, Optional, TextIO, Union
+
+from pyxcp import types
+from pyxcp.config import get_application
+from pyxcp.cpp_ext.cpp_ext import DaqList, PredefinedDaqList
+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
+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,
+    "IDF_REL_ODT_NUMBER_ABS_DAQ_LIST_NUMBER_WORD": 3,
+    "IDF_REL_ODT_NUMBER_ABS_DAQ_LIST_NUMBER_WORD_ALIGNED": 4,
+}
+
+DAQ_TIMESTAMP_SIZE = {
+    "S1": 1,
+    "S2": 2,
+    "S4": 4,
+}
+
+
+class DaqProcessor:
+    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:
+            raise RuntimeError("DAQ functionality is not supported.")
+        self.daq_info = self.xcp_master.getDaqInfo(include_event_lists=False)
+        if start_datetime is None:
+            start_datetime = CurrentDatetime(time_ns())
+        self.start_datetime = start_datetime
+        try:
+            processor = self.daq_info.get("processor")
+            properties = processor.get("properties")
+            resolution = self.daq_info.get("resolution")
+            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"]
+            if self.supports_timestampes:
+                mode = resolution.get("timestampMode")
+                self.ts_fixed = mode.get("fixed")
+                self.ts_size = DAQ_TIMESTAMP_SIZE[mode.get("size")]
+                ts_factor = types.DAQ_TIMESTAMP_UNIT_TO_NS[mode.get("unit")]
+                ts_ticks = resolution.get("timestampTicks")
+                self.ts_scale_factor = ts_factor * ts_ticks
+            else:
+                self.ts_size = 0
+                self.ts_fixed = False
+                self.ts_scale_factor = 0.0
+            key_byte = processor.get("keyByte")
+            header_len = DAQ_ID_FIELD_SIZE[key_byte["identificationField"]]
+            max_dto = self.xcp_master.slaveProperties.maxDto
+            self.min_daq = processor.get("minDaq")
+            max_odt_entry_size = resolution.get("maxOdtEntrySizeDaq")
+            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:
+                # print("NO TIMESTAMP SUPPORT")
+                pass
+            else:
+                if self.ts_fixed:
+                    # print("Fixed timestamp")
+                    max_payload_size_first = max_payload_size - self.ts_size
+                else:
+                    # print("timestamp variable.")
+                    self.selectable_timestamps = True
+        except Exception as e:
+            raise TypeError(f"DAQ_INFO corrupted: {e}") from e
+
+        # DAQ optimization.
+        # 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
+                else:
+                    max_payload_size_first = max_payload_size
+            ttt = make_continuous_blocks(daq_list.measurements, max_payload_size, max_payload_size_first)
+            daq_list.measurements_opt = first_fit_decreasing(ttt, max_payload_size, max_payload_size_first)
+        byte_order = 0 if self.xcp_master.slaveProperties.byteOrder == "INTEL" else 1
+        self._first_pids = []
+        daq_count = len(self.daq_lists)
+
+        # 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.
+        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
+            if daq_list.stim:
+                mode |= 0x02
+            ###
+            ## mode |= 0x20
+            ###
+            self.xcp_master.setDaqListMode(
+                daq_list_number=i,
+                mode=mode,
+                event_channel_number=daq_list.event_num,
+                prescaler=daq_list.prescaler,
+                priority=daq_list.priority,
+            )
+            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,
+            self.supports_timestampes,
+            self.ts_fixed,
+            self.supports_prescaler,
+            self.selectable_timestamps,
+            self.ts_scale_factor,
+            self.ts_size,
+            self.min_daq,
+            self.start_datetime,
+            self.daq_lists,
+            self._first_pids,
+        )
+        self.set_parameters(self.measurement_params)
+
+    def start(self):
+        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):
+            try:
+                self.log.error(
+                    "DAQ stop skipped due to previous fatal OS error (e.g., disk full or out-of-memory). Closing transport."
+                )
+            except Exception:
+                pass  # nosec
+            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
+                    try:
+                        if hasattr(self.xcp_master.transport, "closeEvent"):
+                            self.xcp_master.transport.closeEvent.set()
+                    except Exception:
+                        pass  # nosec
+                    # Close transport connection
+                    try:
+                        self.xcp_master.transport.close()
+                    except Exception:
+                        pass  # nosec
+            finally:
+                return
+        self.xcp_master.startStopSynch(0x00)
+
+    def first_pids(self):
+        return self._first_pids
+
+
+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)
+        self.file_name = file_name
+        self.prealloc = prealloc
+        self.chunk_size = chunk_size
+
+    def initialize(self):
+        metadata = self.measurement_params.dumps()
+        _DaqRecorderPolicy.create_writer(self, self.file_name, self.prealloc, self.chunk_size, metadata)
+        _DaqRecorderPolicy.initialize(self)
+
+    def finalize(self):
+        _DaqRecorderPolicy.finalize(self)
+
+    def start(self):
+        DaqProcessor.start(self)
+
+
+class DaqOnlinePolicy(DaqProcessor, _DaqOnlinePolicy):
+    """Base class for on-line measurements.
+    Handles multiple inheritence.
+    """
+
+    def __init__(self, daq_lists: List[DaqList]):
+        DaqProcessor.__init__(self, daq_lists)
+        _DaqOnlinePolicy.__init__(self)
+
+    def start(self):
+        DaqProcessor.start(self)
+
+
+class DaqToCsv(DaqOnlinePolicy):
+    """Save a measurement as CSV files (one per DAQ-list)."""
+
+    def initialize(self):
+        self.log.debug("DaqCsv::Initialize()")
+        self.files: Dict[int, TextIO] = {}
+        for num, daq_list in enumerate(self.daq_lists):
+            if daq_list.stim:
+                continue
+            out_file = open(f"{daq_list.name}.csv", "w")
+            self.files[num] = out_file
+            hdr = ",".join(["timestamp0", "timestamp1"] + [h[0] for h in daq_list.headers])
+            out_file.write(f"{hdr}\n")
+
+    def on_daq_list(self, daq_list: int, timestamp0: int, timestamp1: int, payload: list):
+        # 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
+            try:
+                self.log.critical(f"DAQ file write failed: {ex.__class__.__name__}: {ex}. Initiating graceful shutdown.")
+            except Exception:
+                pass  # nosec
+            # Stop listener to prevent more DAQ traffic and avoid thread crashes.
+            try:
+                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()
+            except Exception:
+                pass  # nosec
+            # Best-effort: close any opened files to flush buffers and release resources.
+            try:
+                for f in getattr(self, "files", {}).values():
+                    try:
+                        f.flush()
+                    except Exception:
+                        pass  # nosec
+                    try:
+                        f.close()
+                    except Exception:
+                        pass  # nosec
+            except Exception:
+                pass  # nosec
+            # Do not re-raise; allow the system to continue to a controlled shutdown.
+            return
+
+    def finalize(self):
+        self.log.debug("DaqCsv::finalize()")
+        ##
+        ## NOTE: `finalize` is guaranteed to be called, but `Initialize` may fail for reasons.
+        ##       So if you allocate resources in `Initialize` check if this really happened.
+        ##
+        if hasattr(self, "files"):
+            for f in self.files.values():
+                f.close()

pyxcp/daq_stim/optimize/__init__.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python
+"""Optimize data-structures like memory sections."""
+
+from itertools import groupby
+from operator import attrgetter
+from typing import List
+
+from pyxcp.cpp_ext.cpp_ext import McObject
+
+
+def make_continuous_blocks(chunks: List[McObject], upper_bound=None, upper_bound_initial=None) -> List[McObject]:
+    """Try to make continous blocks from a list of small, unordered `chunks`.
+
+    Parameters
+    ----------
+    chunks: list of `McObject`
+
+    Returns
+    -------
+    sorted list of `McObject`
+    """
+
+    def key_func(x):
+        return (x.ext, x.address)
+
+    values = []
+    # 1. Groupy by address.
+    for _key, value in groupby(sorted(chunks, key=key_func), key=key_func):
+        # 2. Pick the largest one.
+        values.append(max(value, key=attrgetter("length")))
+    result_sections = []
+    last_section = None
+    last_ext = None
+    first_section = True
+    if upper_bound_initial is None:
+        upper_bound_initial = upper_bound
+    while values:
+        section = values.pop(0)
+        if (last_section and section.address <= last_section.address + last_section.length) and not (section.ext != last_ext):
+            last_end = last_section.address + last_section.length - 1
+            current_end = section.address + section.length - 1
+            if last_end > section.address:
+                pass
+            else:
+                offset = current_end - last_end
+                if upper_bound:
+                    if first_section:
+                        upper_bound = upper_bound_initial
+                        first_section = False
+                    if last_section.length + offset <= upper_bound:
+                        last_section.length += offset
+                        last_section.add_component(section)
+                    else:
+                        result_sections.append(
+                            McObject(name="", address=section.address, ext=section.ext, length=section.length, components=[section])
+                        )
+                else:
+                    last_section.length += offset
+                    last_section.add_component(section)
+        else:
+            # Create a new section.
+            result_sections.append(
+                McObject(name="", address=section.address, ext=section.ext, length=section.length, components=[section])
+            )
+        last_section = result_sections[-1]
+        last_ext = last_section.ext
+    return result_sections

pyxcp/daq_stim/optimize/binpacking.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python
+"""Bin-packing algorithms."""
+
+from typing import List, Optional
+
+from pyxcp.cpp_ext.cpp_ext import Bin
+
+
+def first_fit_decreasing(items, bin_size: int, initial_bin_size: Optional[int] = None) -> List[Bin]:
+    """bin-packing with first-fit-decreasing algorithm.
+
+    Parameters
+    ----------
+    items: list
+        items that need to be stored/allocated.
+
+    bin_size: int
+
+    Returns
+    -------
+    list
+        Resulting bins
+    """
+    if initial_bin_size is None:
+        initial_bin_size = bin_size
+    # bin_size = max(bin_size, initial_bin_size)
+    bins = [Bin(size=initial_bin_size)]  # Initial bin
+    for item in sorted(items, key=lambda x: x.length, reverse=True):
+        if item.length > bin_size:
+            raise ValueError(f"Item {item!r} is too large to fit in a {bin_size} byte sized bin.")
+        for bin in bins:
+            if bin.residual_capacity >= item.length:
+                bin.append(item)
+                bin.residual_capacity -= item.length
+                break
+        else:
+            new_bin = Bin(size=bin_size)
+            bins.append(new_bin)
+            new_bin.append(item)
+            new_bin.residual_capacity -= item.length
+    return bins

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/daq_stim/scheduler.hpp

@@ -0,0 +1,75 @@
+
+
+#ifndef STIM_SCHEDULER_HPP
+#define STIM_SCHEDULER_HPP
+
+#if !defined(_CRT_SECURE_NO_WARNINGS)
+    #define _CRT_SECURE_NO_WARNINGS (1)
+#endif
+
+#include <stdio.h>
+
+#if defined(_WIN32)
+    #include <windows.h>
+
+    #include <thread>
+
+VOID CALLBACK TimerRoutine(PVOID lpParam, BOOLEAN TimerOrWaitFired);
+
+struct Scheduler {
+    Scheduler()  = default;
+    ~Scheduler() = default;
+
+    bool start_thread() noexcept {
+        if (timer_thread.joinable()) {
+            return false;
+        }
+
+        m_TimerQueue = CreateTimerQueue();
+        if (NULL == m_TimerQueue) {
+            printf("CreateTimerQueue failed (%d)\n", GetLastError());
+            return false;
+        }
+
+        // Set a timer to call the timer routine in 10 seconds.
+        if (!CreateTimerQueueTimer(&m_timer, m_TimerQueue, (WAITORTIMERCALLBACK)TimerRoutine, nullptr, 1, 500, 0)) {
+            printf("CreateTimerQueueTimer failed (%d)\n", GetLastError());
+            return false;
+        }
+
+        stop_timer_thread_flag = false;
+        timer_thread           = std::jthread([this]() {
+            while (!stop_timer_thread_flag) {
+                printf("ENTER SLEEP loop!!!\n");
+                SleepEx(INFINITE, TRUE);
+                stop_timer_thread_flag = TRUE;
+            }
+        });
+        return true;
+    }
+
+    bool stop_thread() noexcept {
+        if (!timer_thread.joinable()) {
+            return false;
+        }
+        stop_timer_thread_flag = true;
+        // my_queue.put(std::nullopt);
+        timer_thread.join();
+        return true;
+    }
+
+    std::jthread timer_thread{};
+    bool         stop_timer_thread_flag{};
+    HANDLE       m_timer{};
+    HANDLE       m_TimerQueue;
+};
+#else
+
+struct Scheduler {
+    Scheduler()  = default;
+    ~Scheduler() = default;
+};
+
+#endif
+
+#endif  // STIM_SCHEDULER_HPP

pyxcp/daq_stim/stim.cpp

@@ -0,0 +1,13 @@
+
+#if defined(_MSC_VER)
+    #pragma comment(lib, "Winmm.lib")
+    #pragma comment(lib, "Avrt.lib")
+#endif
+
+#include "stim.hpp"
+
+void make_dto() {
+}
+
+void init() {
+}