pyxcp 0.22.5__tar.gz → 0.22.6__tar.gz

{pyxcp-0.22.5 → pyxcp-0.22.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyxcp
-Version: 0.22.5
+Version: 0.22.6
 Summary: Universal Calibration Protocol for Python
 Home-page: https://github.com/christoph2/pyxcp
 License: LGPLv3

{pyxcp-0.22.5 → pyxcp-0.22.6}/pyproject.toml

@@ -36,7 +36,7 @@ dynamic = ["license", "readme", "authors", "requires-python", "description", "cl
 [tool.poetry]
 authors = ["Christoph Schueler <cpu.gems@googlemail.com>"]
 name = "pyxcp"
-version = "0.22.5"
+version = "0.22.6"
 readme = "README.md"
 description = "Universal Calibration Protocol for Python"
 keywords = ["automotive", "ecu", "xcp", "asam", "autosar"]
@@ -101,6 +101,7 @@ xcp-id-scanner = "pyxcp.scripts.xcp_id_scanner:main"
 xcp-fetch-a2l = "pyxcp.scripts.xcp_fetch_a2l:main"
 xcp-info = "pyxcp.scripts.xcp_info:main"
 xcp-profile = "pyxcp.scripts.xcp_profile:main"
+xcp-examples = "pyxcp.scripts.xcp_examples:main"
 
 [tool.pytest]
 addopts = "--verbose --tb=short --junitxml=result.xml -o junit_family=xunit2"
@@ -143,7 +144,7 @@ show-source = true
 max-line-length = 132
 select = ["B","C","E","F","W","T4","B9"]
 # extend-select = "B950"
-# extend-ignore = ["E203", "E501", "E701"]
+extend-ignore = ["E203", "E501", "E701"]
 
 [tool.ruff]
 line-length = 132

{pyxcp-0.22.5 → pyxcp-0.22.6}/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.5"
+__version__ = "0.22.6"

{pyxcp-0.22.5 → pyxcp-0.22.6}/pyxcp/recorder/unfolder.hpp

@@ -7,6 +7,7 @@
 #include <charconv>
 #include <cstring>
 #include <iostream>
+#include <limits>
 #include <map>
 #if __has_include(<stdfloat>)
     #include <stdfloat>
@@ -637,6 +638,33 @@ struct MeasurementParameters {
         return m_first_pids;
     }
 
+#undef max  // Thanks to Windows.
+
+    auto get_overflow_value() const {
+        std::uint64_t ov_value{};
+        switch (m_ts_size) {
+            case 1:
+                ov_value = std::numeric_limits<std::uint8_t>::max();
+                break;
+            case 2:
+                ov_value = std::numeric_limits<std::uint16_t>::max();
+                break;
+            case 4:
+                ov_value = std::numeric_limits<std::uint32_t>::max();
+                break;
+//            case 8:
+//                ov_value = std::numeric_limits<std::uint64_t>::max() + 1;
+//                break;
+            default:
+                throw std::runtime_error("Invalid timestamp size");
+        }
+        ov_value++;
+        std::cout << "TS-V: " << ov_value << " scale: " << m_ts_scale_factor << std::endl;
+        ov_value = static_cast<std::uint64_t>(ov_value * m_ts_scale_factor);
+        std::cout << "OVRF-Value: " << ov_value << std::endl;
+        return ov_value;
+    }
+
     std::uint8_t               m_byte_order;
     std::uint8_t               m_id_field_size;
     bool                       m_timestamps_supported;
@@ -1050,6 +1078,9 @@ class DAQPolicyBase {
     }
 
     virtual void set_parameters(const MeasurementParameters& params) noexcept {
+        m_overflow_value = params.get_overflow_value();
+        m_overflow_counter = 0ULL;
+        std::cout << "Overflow value: " << m_overflow_value << ", Overflow counter: " << m_overflow_counter << std::endl;
         initialize();
     }
 
@@ -1058,6 +1089,9 @@ class DAQPolicyBase {
     virtual void initialize() = 0;
 
     virtual void finalize() = 0;
+ private:
+    std::uint64_t m_overflow_value{};
+    std::uint64_t m_overflow_counter{};
 };
 
 class DaqRecorderPolicy : public DAQPolicyBase {
@@ -1164,6 +1198,38 @@ struct ValueHolder {
     std::any m_value;
 };
 
+class Overflow {
+public:
+
+    Overflow(std::uint64_t overflow_value) : m_overflow_value(overflow_value), m_overflow_counter(0ULL), m_previous_timestamp(0ULL) {
+    }
+
+    auto get_previous_timestamp() const noexcept {
+        return m_previous_timestamp;
+    }
+
+    void set_previous_timestamp(std::uint64_t timestamp) noexcept {
+        m_previous_timestamp = timestamp;
+    }
+
+    void inc_overflow_counter() noexcept {
+        m_overflow_counter++;
+    }
+
+    auto get_overflow_counter() const noexcept {
+        return m_overflow_counter;
+    }
+
+    auto get_value() const noexcept {
+        return m_overflow_value * m_overflow_counter;
+    }
+
+private:
+    std::uint64_t m_overflow_value{};
+    std::uint64_t m_overflow_counter{};
+    std::uint64_t m_previous_timestamp{};
+};
+
 class XcpLogFileDecoder {
    public:
 
@@ -1172,6 +1238,11 @@ class XcpLogFileDecoder {
         if (metadata != "") {
             auto des  = Deserializer(metadata);
             m_params  = des.run();
+
+            for (auto idx=0; idx < m_params.get_daq_lists().size(); ++idx) {
+                m_overflows.emplace_back(Overflow(m_params.get_overflow_value()));
+            }
+
             m_decoder = std::make_unique<DAQProcessor>(m_params);
         } else {
             // cannot proceed!!!
@@ -1215,7 +1286,18 @@ class XcpLogFileDecoder {
                 auto result = m_decoder->feed(timestamp, str_data);
                 if (result) {
                     const auto& [daq_list, ts0, ts1, meas] = *result;
-                    on_daq_list(daq_list, ts0, ts1, meas);
+
+                    auto& overflow = m_overflows[daq_list];
+
+                    if (overflow.get_previous_timestamp() > ts1) {
+                        overflow.inc_overflow_counter();
+                        // Maybe on debug-level?
+                        // std::cout << "Overflow detected, counter: " << overflow.get_overflow_counter() << " " << overflow.get_previous_timestamp() << " " << ts1 << std::endl;
+                    }
+
+                    on_daq_list(daq_list, ts0, ts1 + overflow.get_value(), meas);
+
+                    overflow.set_previous_timestamp(ts1);
                 }
             }
         }
@@ -1244,6 +1326,7 @@ class XcpLogFileDecoder {
     XcpLogFileReader              m_reader;
     std::unique_ptr<DAQProcessor> m_decoder;
     MeasurementParameters         m_params;
+    std::vector<Overflow>           m_overflows;
 };
 
 #endif  // RECORDER_UNFOLDER_HPP

pyxcp-0.22.6/pyxcp/scripts/xcp_examples.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python
+
+"""
+Copy pyXCP examples to a given directory.
+"""
+
+import argparse
+import sys
+from pathlib import Path
+
+from pyxcp import console
+
+
+pyver = sys.version_info
+if pyver.major == 3 and pyver.minor <= 9:
+    import pkg_resources
+
+    def copy_files_from_package(package_name: str, source_directory: str, args: argparse.Namespace) -> None:
+        destination_directory = args.output_directory
+        force = args.force
+        for fn in pkg_resources.resource_listdir(package_name, source_directory):
+            source_file = Path(pkg_resources.resource_filename(package_name, f"{source_directory}/{fn}"))
+            if source_file.suffix == ".py":
+                dest_file = Path(destination_directory) / fn
+                if dest_file.exists() and not force:
+                    console.print(f"[white]Destination file [blue]{fn!r} [white]already exists. Skipping.")
+                    continue
+                console.print(f"[blue]{source_file} [white]==> [green]{dest_file}")
+                data = source_file.read_text(encoding="utf-8")
+                dest_file.parent.mkdir(parents=True, exist_ok=True)
+                dest_file.write_text(data, encoding="utf-8")
+
+else:
+    import importlib.resources
+
+    def copy_files_from_package(package_name: str, source_directory: str, args: argparse.Namespace) -> None:
+        destination_directory = args.output_directory
+        force = args.force
+        for fn in importlib.resources.files(f"{package_name}.{source_directory}").iterdir():
+            if fn.suffix == ".py":
+                data = fn.read_text(encoding="utf-8")
+                dest_file = Path(destination_directory) / fn.name
+                if dest_file.exists() and not force:
+                    console.print(f"[white]Destination file [blue]{fn.name!r} [white]already exists. Skipping.")
+                    continue
+                console.print(f"[blue]{fn} [white]==> [green]{dest_file}")
+                dest_file.parent.mkdir(parents=True, exist_ok=True)
+                dest_file.write_text(data, encoding="utf-8")
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+
+    parser.add_argument("output_directory", metavar="output_directory", type=Path, help="output directory")
+
+    parser.add_argument("-f", "--force", action="store_true", help="overwrite existing files.")
+
+    args = parser.parse_args()
+    print("Copying pyXCP examples...\n")
+    copy_files_from_package("pyxcp", "examples", args)
+
+
+if __name__ == "__main__":
+    main()

{pyxcp-0.22.5 → pyxcp-0.22.6}/pyxcp/transport/sxi.py

@@ -109,7 +109,7 @@ class SxI(BaseTransport):
         while True:
             if self.closeEvent.is_set():
                 return
-            if not self.comm_port.in_waiting():
+            if not self.comm_port.in_waiting:
                 continue
 
             recv_timestamp = self.timestamp.value
@@ -129,5 +129,5 @@ class SxI(BaseTransport):
         self.post_send_timestamp = self.timestamp.value
 
     def close_connection(self) -> None:
-        if hasattr(self, "comm_port") and self.comm_port.is_open() and not self.has_user_supplied_interface:
+        if hasattr(self, "comm_port") and self.comm_port.is_open and not self.has_user_supplied_interface:
             self.comm_port.close()