pyxcp 0.22.23__tar.gz → 0.22.25__tar.gz

{pyxcp-0.22.23 → pyxcp-0.22.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyxcp
-Version: 0.22.23
+Version: 0.22.25
 Summary: Universal Calibration Protocol for Python
 License: LGPLv3
 Keywords: automotive,ecu,xcp,asam,autosar

{pyxcp-0.22.23 → pyxcp-0.22.25}/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.23"
+version = "0.22.25"
 readme = "README.md"
 description = "Universal Calibration Protocol for Python"
 keywords = ["automotive", "ecu", "xcp", "asam", "autosar"]

{pyxcp-0.22.23 → pyxcp-0.22.25}/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.23"
+__version__ = "0.22.25"

{pyxcp-0.22.23 → pyxcp-0.22.25}/pyxcp/cpp_ext/daqlist.hpp

@@ -15,10 +15,9 @@ class DaqList {
 
     DaqList(
         std::string_view meas_name, std::uint16_t event_num, bool stim, bool enable_timestamps,
-        const std::vector<daq_list_initialzer_t>& measurements
+        const std::vector<daq_list_initialzer_t>& measurements, std::uint8_t priority=0x00, std::uint8_t prescaler=0x01
     ) :
-        m_name(meas_name), m_event_num(event_num), m_stim(stim), m_enable_timestamps(enable_timestamps) {
-        // std::cout << "DAQ-List: " << meas_name << " " << event_num << " " << stim << " " << enable_timestamps << std::endl;
+        m_name(meas_name), m_event_num(event_num), m_priority(priority), m_prescaler(prescaler), m_stim(stim), m_enable_timestamps(enable_timestamps) {
         for (const auto& measurement : measurements) {
             auto const& [name, address, ext, dt_name] = measurement;
             m_measurements.emplace_back(McObject(name, address, static_cast<std::uint8_t>(ext), 0, dt_name));
@@ -37,6 +36,14 @@ class DaqList {
         return m_event_num;
     }
 
+    std::uint8_t get_priority() const {
+        return m_priority;
+    }
+
+    std::uint8_t get_prescaler() const {
+        return m_prescaler;
+    }
+
     void set_event_num(std::uint16_t event_num) {
         m_event_num = event_num;
     }
@@ -171,9 +178,6 @@ class DaqList {
             ss << "\"" << header << "\",";
         }
         ss << "\n]";
-
-        // using flatten_odts_t = std::vector<std::vector<std::tuple<std::string, std::uint32_t, std::uint8_t, std::uint16_t,
-        // std::int16_t>>>;
         ss << ")";
         return ss.str();
     }
@@ -185,6 +189,8 @@ class DaqList {
 
     std::string                                       m_name;
     std::uint16_t                                     m_event_num;
+    std::uint8_t                                      m_priority;
+    std::uint8_t                                      m_prescaler;
     bool                                              m_stim;
     bool                                              m_enable_timestamps;
     std::vector<McObject>                             m_measurements;

{pyxcp-0.22.23 → pyxcp-0.22.25}/pyxcp/cpp_ext/extension_wrapper.cpp

@@ -59,12 +59,15 @@ PYBIND11_MODULE(cpp_ext, m) {
 
     py::class_<DaqList>(m, "DaqList")
         .def(
-            py::init<std::string_view, std::uint16_t, bool, bool, const std::vector<DaqList::daq_list_initialzer_t>&>(), "name"_a,
-            "event_num"_a, "stim"_a, "enable_timestamps"_a, "measurements"_a
+            py::init<std::string_view, std::uint16_t, bool, bool, const std::vector<DaqList::daq_list_initialzer_t>&,
+            std::uint8_t, std::uint8_t>(), "name"_a, "event_num"_a, "stim"_a, "enable_timestamps"_a, "measurements"_a,
+            "priority"_a=0, "prescaler"_a=1
         )
         .def("__repr__", [](const DaqList& self) { return self.to_string(); })
         .def_property("name", &DaqList::get_name, nullptr)
         .def_property("event_num", &DaqList::get_event_num, &DaqList::set_event_num)
+        .def_property("priority", &DaqList::get_priority, nullptr)
+        .def_property("prescaler", &DaqList::get_prescaler, nullptr)
         .def_property("stim", &DaqList::get_stim, nullptr)
         .def_property("enable_timestamps", &DaqList::get_enable_timestamps, nullptr)
         .def_property("measurements", &DaqList::get_measurements, nullptr)

{pyxcp-0.22.23 → pyxcp-0.22.25}/pyxcp/daq_stim/__init__.py

@@ -38,7 +38,7 @@ class DaqProcessor:
     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()
+        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
@@ -134,7 +134,11 @@ class DaqProcessor:
             ## mode |= 0x20
             ###
             self.xcp_master.setDaqListMode(
-                daqListNumber=i, mode=mode, eventChannelNumber=daq_list.event_num, prescaler=1, priority=0xFF
+                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)

{pyxcp-0.22.23 → pyxcp-0.22.25}/pyxcp/daq_stim/stim_wrapper.cpp

@@ -15,7 +15,9 @@ using namespace py::literals;
 
 PYBIND11_MODULE(stim, m) {
     py::class_<DaqEventInfo>(m, "DaqEventInfo")
-        .def(py::init<const std::string&, std::int8_t, std::size_t, std::size_t, std::size_t, std::string_view, bool, bool, bool>()
+        .def(py::init<const std::string&, std::int8_t, std::size_t, std::size_t, std::size_t, std::string_view, bool, bool, bool>(),
+        "name"_a, "type_code"_a, "cycle"_a, "max_daq_lists"_a, "priority"_a, "consistency"_a, "daq_supported"_a,
+        "stim_supported"_a, "packed_supported"_a
         );
 
     py::class_<Stim>(m, "Stim")

{pyxcp-0.22.23 → pyxcp-0.22.25}/pyxcp/examples/run_daq.py

@@ -8,7 +8,7 @@ from pyxcp.daq_stim import DaqList, DaqRecorder, DaqToCsv  # noqa: F401
 
 ap = ArgumentParser(description="DAQ test")
 
-XCP_LITE = True
+XCP_LITE = False
 
 #
 # NOTE: UPDATE TO CORRECT ADDRESSES BEFORE RUNNING!!!
@@ -17,40 +17,44 @@ if XCP_LITE:
     # Vectorgrp XCPlite.
     DAQ_LISTS = [
         DaqList(
-            "part_1",
-            0,
-            False,
-            False,
-            [
+            name="part_1",
+            event_num=0,
+            stim=False,
+            enable_timestamps=False,
+            measurements=[
                 ("byteCounter", 0x00023648, 0, "U8"),
                 ("wordCounter", 0x0002364C, 0, "U16"),
                 ("dwordCounter", 0x00023650, 0, "U32"),
                 ("sbyteCounter", 0x00023649, 0, "I8"),
             ],
+            priority=0,
+            prescaler=1,
         ),
         DaqList(
-            "part_2",
-            7,
-            False,
-            False,
-            [
+            name="part_2",
+            event_num=7,
+            stim=False,
+            enable_timestamps=False,
+            measurements=[
                 ("swordCounter", 0x00023654, 0, "I16"),
                 ("sdwordCounter", 0x00023658, 0, "I32"),
                 ("channel1", 0x00023630, 0, "F64"),
                 ("channel2", 0x00023638, 0, "F64"),
                 ("channel3", 0x00023640, 0, "F64"),
             ],
+            priority=0,
+            prescaler=1,
         ),
     ]
 else:
     # XCPsim from CANape.
     DAQ_LISTS = [
         DaqList(
-            "pwm_stuff",
-            2,
-            False,
-            True,
-            [
+            name="pwm_stuff",
+            event_num=2,
+            stim=False,
+            enable_timestamps=True,
+            measurements=[
                 ("channel1", 0x1BD004, 0, "F32"),
                 ("period", 0x001C0028, 0, "F32"),
                 ("channel2", 0x1BD008, 0, "F32"),
@@ -58,13 +62,15 @@ else:
                 ("PWM", 0x1BDDDF, 0, "U8"),
                 ("Triangle", 0x1BDDDE, 0, "I8"),
             ],
+            priority=0,
+            prescaler=1,
         ),
         DaqList(
-            "bytes",
-            1,
-            False,
-            True,
-            [
+            name="bytes",
+            event_num=1,
+            stim=False,
+            enable_timestamps=True,
+            measurements=[
                 ("TestByte_000", 0x1BE11C, 0, "U8"),
                 ("TestByte_015", 0x1BE158, 0, "U8"),
                 ("TestByte_016", 0x1BE15C, 0, "U8"),
@@ -97,13 +103,15 @@ else:
                 ("TestByte_344", 0x1BE67C, 0, "U8"),
                 ("TestByte_346", 0x1BE684, 0, "U8"),
             ],
+            priority=0,
+            prescaler=1,
         ),
         DaqList(
-            "words",
-            3,
-            False,
-            True,
-            [
+            name="words",
+            event_num=3,
+            stim=False,
+            enable_timestamps=True,
+            measurements=[
                 ("TestWord_001", 0x1BE120, 0, "U16"),
                 ("TestWord_003", 0x1BE128, 0, "U16"),
                 ("TestWord_004", 0x1BE12C, 0, "U16"),
@@ -114,6 +122,8 @@ else:
                 ("TestWord_009", 0x1BE140, 0, "U16"),
                 ("TestWord_011", 0x1BE148, 0, "U16"),
             ],
+            priority=0,
+            prescaler=1,
         ),
     ]