pyxcp 0.22.23__cp310-cp310-win_amd64.whl → 0.22.25__cp310-cp310-win_amd64.whl

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/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/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/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/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/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,
         ),
     ]
 

pyxcp/master/master.py

@@ -310,7 +310,7 @@ class Master:
         return result
 
     @wrapped
-    def setRequest(self, mode: int, sessionConfigurationId: int):
+    def setRequest(self, mode: int, session_configuration_id: int):
         """Request to save to non-volatile memory.
 
         Parameters
@@ -326,8 +326,8 @@ class Master:
         return self.transport.request(
             types.Command.SET_REQUEST,
             mode,
-            sessionConfigurationId >> 8,
-            sessionConfigurationId & 0xFF,
+            session_configuration_id >> 8,
+            session_configuration_id & 0xFF,
         )
 
     @wrapped
@@ -394,7 +394,7 @@ class Master:
         return result
 
     @wrapped
-    def setMta(self, address: int, addressExt: int = 0x00):
+    def setMta(self, address: int, address_ext: int = 0x00):
         """Set Memory Transfer Address in slave.
 
         Parameters
@@ -409,9 +409,9 @@ class Master:
         and :meth:`programMax`.
 
         """
-        self.mta = types.MtaType(address, addressExt)  # Keep track of MTA (needed for error-handling).
+        self.mta = types.MtaType(address, address_ext)  # Keep track of MTA (needed for error-handling).
         addr = self.DWORD_pack(address)
-        return self.transport.request(types.Command.SET_MTA, 0, 0, addressExt, *addr)
+        return self.transport.request(types.Command.SET_MTA, 0, 0, address_ext, *addr)
 
     @wrapped
     def upload(self, length: int):
@@ -450,7 +450,7 @@ class Master:
         return response
 
     @wrapped
-    def shortUpload(self, length: int, address: int, addressExt: int = 0x00):
+    def shortUpload(self, length: int, address: int, address_ext: int = 0x00):
         """Transfer data from slave to master.
         As opposed to :meth:`upload` this service also includes address information.
 
@@ -470,7 +470,7 @@ class Master:
         max_byte_count = self.slaveProperties.maxCto - 1
         if byte_count > max_byte_count:
             self.logger.warn(f"SHORT_UPLOAD: {byte_count} bytes exceeds the maximum value of {max_byte_count}.")
-        response = self.transport.request(types.Command.SHORT_UPLOAD, length, 0, addressExt, *addr)
+        response = self.transport.request(types.Command.SHORT_UPLOAD, length, 0, address_ext, *addr)
         return response[:byte_count]
 
     @wrapped
@@ -496,7 +496,7 @@ class Master:
         return types.BuildChecksumResponse.parse(response, byteOrder=self.slaveProperties.byteOrder)
 
     @wrapped
-    def transportLayerCmd(self, subCommand: int, *data: List[bytes]):
+    def transportLayerCmd(self, sub_command: int, *data: List[bytes]):
         """Execute transfer-layer specific command.
 
         Parameters
@@ -508,10 +508,10 @@ class Master:
         ----
         For details refer to XCP specification.
         """
-        return self.transport.request_optional_response(types.Command.TRANSPORT_LAYER_CMD, subCommand, *data)
+        return self.transport.request_optional_response(types.Command.TRANSPORT_LAYER_CMD, sub_command, *data)
 
     @wrapped
-    def userCmd(self, subCommand: int, data: bytes):
+    def userCmd(self, sub_command: int, data: bytes):
         """Execute proprietary command implemented in your XCP client.
 
         Parameters
@@ -523,7 +523,7 @@ class Master:
         .. note:: For details refer to your XCP client vendor.
         """
 
-        response = self.transport.request(types.Command.USER_CMD, subCommand, *data)
+        response = self.transport.request(types.Command.USER_CMD, sub_command, *data)
         return response
 
     @wrapped
@@ -547,7 +547,7 @@ class Master:
         self.slaveProperties.transportMinor = result.transportMinor
         return result
 
-    def fetch(self, length: int, limitPayload: int = None):  # TODO: pull
+    def fetch(self, length: int, limit_payload: int = None):  # TODO: pull
         """Convenience function for data-transfer from slave to master
         (Not part of the XCP Specification).
 
@@ -565,21 +565,21 @@ class Master:
         ----
         address is not included because of services implicitly setting address information like :meth:`getID` .
         """
-        if limitPayload and limitPayload < 8:
-            raise ValueError(f"Payload must be at least 8 bytes - given: {limitPayload}")
+        if limit_payload and limit_payload < 8:
+            raise ValueError(f"Payload must be at least 8 bytes - given: {limit_payload}")
 
-        slaveBlockMode = self.slaveProperties.slaveBlockMode
-        if slaveBlockMode:
-            maxPayload = 255
+        slave_block_mode = self.slaveProperties.slaveBlockMode
+        if slave_block_mode:
+            max_payload = 255
         else:
-            maxPayload = self.slaveProperties.maxCto - 1
-        payload = min(limitPayload, maxPayload) if limitPayload else maxPayload
-        chunkSize = payload
-        chunks = range(length // chunkSize)
-        remaining = length % chunkSize
+            max_payload = self.slaveProperties.maxCto - 1
+        payload = min(limit_payload, max_payload) if limit_payload else max_payload
+        chunk_size = payload
+        chunks = range(length // chunk_size)
+        remaining = length % chunk_size
         result = []
         for _ in chunks:
-            data = self.upload(chunkSize)
+            data = self.upload(chunk_size)
             result.extend(data)
         if remaining:
             data = self.upload(remaining)
@@ -588,7 +588,7 @@ class Master:
 
     pull = fetch  # fetch() may be completely replaced by pull() someday.
 
-    def push(self, address: int, address_ext: int, data: bytes, callback=None):
+    def push(self, address: int, address_ext: int, data: bytes, callback: Optional[Callable] = None):
         """Convenience function for data-transfer from master to slave.
         (Not part of the XCP Specification).
 
@@ -615,7 +615,7 @@ class Master:
             callback=callback,
         )
 
-    def flash_program(self, address: int, data: bytes, callback=None):
+    def flash_program(self, address: int, data: bytes, callback: Optional[Callable] = None):
         """Convenience function for flash programing.
         (Not part of the XCP Specification).
 
@@ -707,7 +707,9 @@ class Master:
                 if callback:
                     callback(percent_complete)
 
-    def _block_downloader(self, data: bytes, dl_func=None, dl_next_func=None, minSt=0):
+    def _block_downloader(
+        self, data: bytes, dl_func: Optional[Callable] = None, dl_next_func: Optional[Callable] = None, minSt: int = 0
+    ):
         """Re-usable block downloader.
 
         Parameters
@@ -751,14 +753,14 @@ class Master:
             delay(minSt)
 
     @wrapped
-    def download(self, data: bytes, blockModeLength=None, last=False):
+    def download(self, data: bytes, block_mode_length: Optional[int] = None, last: bool = False):
         """Transfer data from master to slave.
 
         Parameters
         ----------
         data : bytes
             Data to send to slave.
-        blockModeLength : int or None
+        block_mode_length : int or None
             for block mode, the download request must contain the length of the whole block,
             not just the length in the current packet. The whole block length can be given here for block-mode
             transfers. For normal mode, the length indicates the actual packet's payload length.
@@ -768,20 +770,20 @@ class Master:
         Adress is set via :meth:`setMta`
         """
 
-        if blockModeLength is None or last:
+        if block_mode_length is None or last:
             # standard mode
             length = len(data)
             response = self.transport.request(types.Command.DOWNLOAD, length, *data)
             return response
         else:
             # block mode
-            if not isinstance(blockModeLength, int):
-                raise TypeError("blockModeLength must be int!")
-            self.transport.block_request(types.Command.DOWNLOAD, blockModeLength, *data)
+            if not isinstance(block_mode_length, int):
+                raise TypeError("block_mode_length must be int!")
+            self.transport.block_request(types.Command.DOWNLOAD, block_mode_length, *data)
             return None
 
     @wrapped
-    def downloadNext(self, data: bytes, remainingBlockLength, last=False):
+    def downloadNext(self, data: bytes, remaining_block_length: int, last: bool = False):
         """Transfer data from master to slave (block mode).
 
         Parameters
@@ -796,12 +798,12 @@ class Master:
 
         if last:
             # last DOWNLOAD_NEXT packet in a block: the slave device has to send the response after this.
-            response = self.transport.request(types.Command.DOWNLOAD_NEXT, remainingBlockLength, *data)
+            response = self.transport.request(types.Command.DOWNLOAD_NEXT, remaining_block_length, *data)
             return response
         else:
             # the slave device won't respond to consecutive DOWNLOAD_NEXT packets in block mode,
             # so we must not wait for any response
-            self.transport.block_request(types.Command.DOWNLOAD_NEXT, remainingBlockLength, *data)
+            self.transport.block_request(types.Command.DOWNLOAD_NEXT, remaining_block_length, *data)
             return None
 
     @wrapped
@@ -815,21 +817,21 @@ class Master:
         return self.transport.request(types.Command.DOWNLOAD_MAX, *data)
 
     @wrapped
-    def shortDownload(self, address, addressExt, data):
+    def shortDownload(self, address: int, address_ext: int, data: bytes):
         length = len(data)
         addr = self.DWORD_pack(address)
-        return self.transport.request(types.Command.SHORT_DOWNLOAD, length, 0, addressExt, *addr, *data)
+        return self.transport.request(types.Command.SHORT_DOWNLOAD, length, 0, address_ext, *addr, *data)
 
     @wrapped
-    def modifyBits(self, shiftValue, andMask, xorMask):
+    def modifyBits(self, shift_value: int, and_mask: int, xor_mask: int):
         # A = ( (A) & ((~((dword)(((word)~MA)<<S))) )^((dword)(MX<<S)) )
-        am = self.WORD_pack(andMask)
-        xm = self.WORD_pack(xorMask)
-        return self.transport.request(types.Command.MODIFY_BITS, shiftValue, *am, *xm)
+        am = self.WORD_pack(and_mask)
+        xm = self.WORD_pack(xor_mask)
+        return self.transport.request(types.Command.MODIFY_BITS, shift_value, *am, *xm)
 
     # Page Switching Commands (PAG)
     @wrapped
-    def setCalPage(self, mode: int, logicalDataSegment: int, logicalDataPage: int):
+    def setCalPage(self, mode: int, logical_data_segment: int, logical_data_page: int):
         """Set calibration page.
 
         Parameters
@@ -841,10 +843,10 @@ class Master:
         logicalDataSegment : int
         logicalDataPage : int
         """
-        return self.transport.request(types.Command.SET_CAL_PAGE, mode, logicalDataSegment, logicalDataPage)
+        return self.transport.request(types.Command.SET_CAL_PAGE, mode, logical_data_segment, logical_data_page)
 
     @wrapped
-    def getCalPage(self, mode: int, logicalDataSegment: int):
+    def getCalPage(self, mode: int, logical_data_segment: int):
         """Get calibration page
 
         Parameters
@@ -852,7 +854,7 @@ class Master:
         mode : int
         logicalDataSegment : int
         """
-        response = self.transport.request(types.Command.GET_CAL_PAGE, mode, logicalDataSegment)
+        response = self.transport.request(types.Command.GET_CAL_PAGE, mode, logical_data_segment)
         return response[2]
 
     @wrapped
@@ -867,7 +869,7 @@ class Master:
         return types.GetPagProcessorInfoResponse.parse(response, byteOrder=self.slaveProperties.byteOrder)
 
     @wrapped
-    def getSegmentInfo(self, mode, segmentNumber, segmentInfo, mappingIndex):
+    def getSegmentInfo(self, mode: int, segment_number: int, segment_info: int, mapping_index: int):
         """Get specific information for a segment.
 
         Parameters
@@ -900,9 +902,9 @@ class Master:
         response = self.transport.request(
             types.Command.GET_SEGMENT_INFO,
             mode,
-            segmentNumber,
-            segmentInfo,
-            mappingIndex,
+            segment_number,
+            segment_info,
+            mapping_index,
         )
         if mode == 0:
             return types.GetSegmentInfoMode0Response.parse(response, byteOrder=self.slaveProperties.byteOrder)
@@ -912,7 +914,7 @@ class Master:
             return types.GetSegmentInfoMode2Response.parse(response, byteOrder=self.slaveProperties.byteOrder)
 
     @wrapped
-    def getPageInfo(self, segmentNumber, pageNumber):
+    def getPageInfo(self, segment_number: int, page_number: int):
         """Get specific information for a page.
 
         Parameters
@@ -920,14 +922,14 @@ class Master:
         segmentNumber : int
         pageNumber : int
         """
-        response = self.transport.request(types.Command.GET_PAGE_INFO, 0, segmentNumber, pageNumber)
+        response = self.transport.request(types.Command.GET_PAGE_INFO, 0, segment_number, page_number)
         return (
             types.PageProperties.parse(bytes([response[0]]), byteOrder=self.slaveProperties.byteOrder),
             response[1],
         )
 
     @wrapped
-    def setSegmentMode(self, mode, segmentNumber):
+    def setSegmentMode(self, mode: int, segment_number: int):
         """Set mode for a segment.
 
         Parameters
@@ -936,21 +938,22 @@ class Master:
             1 = enable FREEZE Mode
         segmentNumber : int
         """
-        return self.transport.request(types.Command.SET_SEGMENT_MODE, mode, segmentNumber)
+        return self.transport.request(types.Command.SET_SEGMENT_MODE, mode, segment_number)
 
     @wrapped
-    def getSegmentMode(self, segmentNumber):
+    def getSegmentMode(self, segment_number: int):
         """Get mode for a segment.
 
         Parameters
         ----------
         segmentNumber : int
         """
-        response = self.transport.request(types.Command.GET_SEGMENT_MODE, 0, segmentNumber)
-        return response[1]
+        response = self.transport.request(types.Command.GET_SEGMENT_MODE, 0, segment_number)
+        if response:
+            return response[1]
 
     @wrapped
-    def copyCalPage(self, srcSegment, srcPage, dstSegment, dstPage):
+    def copyCalPage(self, src_segment: int, src_page: int, dst_segment: int, dst_page: int):
         """Copy page.
 
         Parameters
@@ -960,33 +963,33 @@ class Master:
         dstSegment : int
         dstPage : int
         """
-        return self.transport.request(types.Command.COPY_CAL_PAGE, srcSegment, srcPage, dstSegment, dstPage)
+        return self.transport.request(types.Command.COPY_CAL_PAGE, src_segment, src_page, dst_segment, dst_page)
 
     # DAQ
 
     @wrapped
-    def setDaqPtr(self, daqListNumber: int, odtNumber: int, odtEntryNumber: int):
-        self.currentDaqPtr = types.DaqPtr(daqListNumber, odtNumber, odtEntryNumber)  # Needed for errorhandling.
-        daqList = self.WORD_pack(daqListNumber)
-        response = self.transport.request(types.Command.SET_DAQ_PTR, 0, *daqList, odtNumber, odtEntryNumber)
-        self.stim.setDaqPtr(daqListNumber, odtNumber, odtEntryNumber)
+    def setDaqPtr(self, daq_list_number: int, odt_number: int, odt_entry_number: int):
+        self.currentDaqPtr = types.DaqPtr(daq_list_number, odt_number, odt_entry_number)  # Needed for errorhandling.
+        daq_list = self.WORD_pack(daq_list_number)
+        response = self.transport.request(types.Command.SET_DAQ_PTR, 0, *daq_list, odt_number, odt_entry_number)
+        self.stim.setDaqPtr(daq_list_number, odt_number, odt_entry_number)
         return response
 
     @wrapped
-    def clearDaqList(self, daqListNumber: int):
+    def clearDaqList(self, daq_list_number: int):
         """Clear DAQ list configuration.
 
         Parameters
         ----------
         daqListNumber : int
         """
-        daqList = self.WORD_pack(daqListNumber)
-        result = self.transport.request(types.Command.CLEAR_DAQ_LIST, 0, *daqList)
-        self.stim.clearDaqList(daqListNumber)
+        daq_list = self.WORD_pack(daq_list_number)
+        result = self.transport.request(types.Command.CLEAR_DAQ_LIST, 0, *daq_list)
+        self.stim.clearDaqList(daq_list_number)
         return result
 
     @wrapped
-    def writeDaq(self, bitOffset: int, entrySize: int, addressExt: int, address: int):
+    def writeDaq(self, bit_offset: int, entry_size: int, address_ext: int, address: int):
         """Write element in ODT entry.
 
         Parameters
@@ -999,19 +1002,19 @@ class Master:
         address : int
         """
         addr = self.DWORD_pack(address)
-        result = self.transport.request(types.Command.WRITE_DAQ, bitOffset, entrySize, addressExt, *addr)
-        self.stim.writeDaq(bitOffset, entrySize, addressExt, address)
+        result = self.transport.request(types.Command.WRITE_DAQ, bit_offset, entry_size, address_ext, *addr)
+        self.stim.writeDaq(bit_offset, entry_size, address_ext, address)
         return result
 
     @wrapped
-    def setDaqListMode(self, mode, daqListNumber, eventChannelNumber, prescaler, priority):
-        dln = self.WORD_pack(daqListNumber)
-        ecn = self.WORD_pack(eventChannelNumber)
-        self.stim.setDaqListMode(mode, daqListNumber, eventChannelNumber, prescaler, priority)
+    def setDaqListMode(self, mode: int, daq_list_number: int, event_channel_number: int, prescaler: int, priority: int):
+        dln = self.WORD_pack(daq_list_number)
+        ecn = self.WORD_pack(event_channel_number)
+        self.stim.setDaqListMode(mode, daq_list_number, event_channel_number, prescaler, priority)
         return self.transport.request(types.Command.SET_DAQ_LIST_MODE, mode, *dln, *ecn, prescaler, priority)
 
     @wrapped
-    def getDaqListMode(self, daqListNumber):
+    def getDaqListMode(self, daq_list_number: int):
         """Get mode from DAQ list.
 
         Parameters
@@ -1022,12 +1025,12 @@ class Master:
         -------
         `pyxcp.types.GetDaqListModeResponse`
         """
-        dln = self.WORD_pack(daqListNumber)
+        dln = self.WORD_pack(daq_list_number)
         response = self.transport.request(types.Command.GET_DAQ_LIST_MODE, 0, *dln)
         return types.GetDaqListModeResponse.parse(response, byteOrder=self.slaveProperties.byteOrder)
 
     @wrapped
-    def startStopDaqList(self, mode: int, daqListNumber: int):
+    def startStopDaqList(self, mode: int, daq_list_number: int):
         """Start /stop/select DAQ list.
 
         Parameters
@@ -1038,15 +1041,15 @@ class Master:
             2 = select
         daqListNumber : int
         """
-        dln = self.WORD_pack(daqListNumber)
+        dln = self.WORD_pack(daq_list_number)
         response = self.transport.request(types.Command.START_STOP_DAQ_LIST, mode, *dln)
-        self.stim.startStopDaqList(mode, daqListNumber)
-        firstPid = types.StartStopDaqListResponse.parse(response, byteOrder=self.slaveProperties.byteOrder)
-        self.stim.set_first_pid(daqListNumber, firstPid.firstPid)
-        return firstPid
+        self.stim.startStopDaqList(mode, daq_list_number)
+        first_pid = types.StartStopDaqListResponse.parse(response, byteOrder=self.slaveProperties.byteOrder)
+        self.stim.set_first_pid(daq_list_number, first_pid.firstPid)
+        return first_pid
 
     @wrapped
-    def startStopSynch(self, mode):
+    def startStopSynch(self, mode: int):
         """Start/stop DAQ lists (synchronously).
 
         Parameters
@@ -1061,20 +1064,20 @@ class Master:
         return res
 
     @wrapped
-    def writeDaqMultiple(self, daqElements):
+    def writeDaqMultiple(self, daq_elements: dict):
         """Write multiple elements in ODT.
 
         Parameters
         ----------
         daqElements : list of `dict` containing the following keys: *bitOffset*, *size*, *address*, *addressExt*.
         """
-        if len(daqElements) > self.slaveProperties.maxWriteDaqMultipleElements:
+        if len(daq_elements) > self.slaveProperties.maxWriteDaqMultipleElements:
             raise ValueError(f"At most {self.slaveProperties.maxWriteDaqMultipleElements} daqElements are permitted.")
         data = bytearray()
-        data.append(len(daqElements))
+        data.append(len(daq_elements))
 
-        for daqElement in daqElements:
-            data.extend(types.DaqElement.build(daqElement, byteOrder=self.slaveProperties.byteOrder))
+        for daq_element in daq_elements:
+            data.extend(types.DaqElement.build(daq_element, byteOrder=self.slaveProperties.byteOrder))
 
         return self.transport.request(types.Command.WRITE_DAQ_MULTIPLE, *data)
 
@@ -1126,19 +1129,19 @@ class Master:
         return types.GetDaqResolutionInfoResponse.parse(response, byteOrder=self.slaveProperties.byteOrder)
 
     @wrapped
-    def getDaqListInfo(self, daqListNumber):
+    def getDaqListInfo(self, daq_list_number: int):
         """Get specific information for a DAQ list.
 
         Parameters
         ----------
         daqListNumber : int
         """
-        dln = self.WORD_pack(daqListNumber)
+        dln = self.WORD_pack(daq_list_number)
         response = self.transport.request(types.Command.GET_DAQ_LIST_INFO, 0, *dln)
         return types.GetDaqListInfoResponse.parse(response, byteOrder=self.slaveProperties.byteOrder)
 
     @wrapped
-    def getDaqEventInfo(self, eventChannelNumber):
+    def getDaqEventInfo(self, event_channel_number: int):
         """Get specific information for an event channel.
 
         Parameters
@@ -1149,12 +1152,12 @@ class Master:
         -------
         `pyxcp.types.GetEventChannelInfoResponse`
         """
-        ecn = self.WORD_pack(eventChannelNumber)
+        ecn = self.WORD_pack(event_channel_number)
         response = self.transport.request(types.Command.GET_DAQ_EVENT_INFO, 0, *ecn)
         return types.GetEventChannelInfoResponse.parse(response, byteOrder=self.slaveProperties.byteOrder)
 
     @wrapped
-    def dtoCtrProperties(self, modifier, eventChannel, relatedEventChannel, mode):
+    def dtoCtrProperties(self, modifier: int, event_channel: int, related_event_channel: int, mode: int):
         """DTO CTR properties
 
         Parameters
@@ -1170,14 +1173,16 @@ class Master:
         """
         data = bytearray()
         data.append(modifier)
-        data.extend(self.WORD_pack(eventChannel))
-        data.extend(self.WORD_pack(relatedEventChannel))
+        data.extend(self.WORD_pack(event_channel))
+        data.extend(self.WORD_pack(related_event_channel))
         data.append(mode)
         response = self.transport.request(types.Command.DTO_CTR_PROPERTIES, *data)
         return types.DtoCtrPropertiesResponse.parse(response, byteOrder=self.slaveProperties.byteOrder)
 
     @wrapped
-    def setDaqPackedMode(self, daqListNumber, daqPackedMode, dpmTimestampMode=None, dpmSampleCount=None):
+    def setDaqPackedMode(
+        self, daq_list_number: int, daq_packed_mode: int, dpm_timestamp_mode: int = None, dpm_sample_count: int = None
+    ):
         """Set DAQ List Packed Mode.
 
         Parameters
@@ -1186,19 +1191,19 @@ class Master:
         daqPackedMode : int
         """
         params = []
-        dln = self.WORD_pack(daqListNumber)
+        dln = self.WORD_pack(daq_list_number)
         params.extend(dln)
-        params.append(daqPackedMode)
+        params.append(daq_packed_mode)
 
-        if daqPackedMode == 1 or daqPackedMode == 2:
-            params.append(dpmTimestampMode)
-            dsc = self.WORD_pack(dpmSampleCount)
+        if daq_packed_mode == 1 or daq_packed_mode == 2:
+            params.append(dpm_timestamp_mode)
+            dsc = self.WORD_pack(dpm_sample_count)
             params.extend(dsc)
 
         return self.transport.request(types.Command.SET_DAQ_PACKED_MODE, *params)
 
     @wrapped
-    def getDaqPackedMode(self, daqListNumber):
+    def getDaqPackedMode(self, daq_list_number: int):
         """Get DAQ List Packed Mode.
 
         This command returns information of the currently active packed mode of
@@ -1208,7 +1213,7 @@ class Master:
         ----------
         daqListNumber : int
         """
-        dln = self.WORD_pack(daqListNumber)
+        dln = self.WORD_pack(daq_list_number)
         response = self.transport.request(types.Command.GET_DAQ_PACKED_MODE, *dln)
         return types.GetDaqPackedModeResponse.parse(response, byteOrder=self.slaveProperties.byteOrder)
 
@@ -1221,7 +1226,7 @@ class Master:
         return result
 
     @wrapped
-    def allocDaq(self, daqCount: int):
+    def allocDaq(self, daq_count: int):
         """Allocate DAQ lists.
 
         Parameters
@@ -1229,23 +1234,23 @@ class Master:
         daqCount : int
             number of DAQ lists to be allocated
         """
-        dq = self.WORD_pack(daqCount)
+        dq = self.WORD_pack(daq_count)
         result = self.transport.request(types.Command.ALLOC_DAQ, 0, *dq)
-        self.stim.allocDaq(daqCount)
+        self.stim.allocDaq(daq_count)
         return result
 
     @wrapped
-    def allocOdt(self, daqListNumber: int, odtCount: int):
-        dln = self.WORD_pack(daqListNumber)
-        result = self.transport.request(types.Command.ALLOC_ODT, 0, *dln, odtCount)
-        self.stim.allocOdt(daqListNumber, odtCount)
+    def allocOdt(self, daq_list_number: int, odt_count: int):
+        dln = self.WORD_pack(daq_list_number)
+        result = self.transport.request(types.Command.ALLOC_ODT, 0, *dln, odt_count)
+        self.stim.allocOdt(daq_list_number, odt_count)
         return result
 
     @wrapped
-    def allocOdtEntry(self, daqListNumber: int, odtNumber: int, odtEntriesCount: int):
-        dln = self.WORD_pack(daqListNumber)
-        result = self.transport.request(types.Command.ALLOC_ODT_ENTRY, 0, *dln, odtNumber, odtEntriesCount)
-        self.stim.allocOdtEntry(daqListNumber, odtNumber, odtEntriesCount)
+    def allocOdtEntry(self, daq_list_number: int, odt_number: int, odt_entries_count: int):
+        dln = self.WORD_pack(daq_list_number)
+        result = self.transport.request(types.Command.ALLOC_ODT_ENTRY, 0, *dln, odt_number, odt_entries_count)
+        self.stim.allocOdtEntry(daq_list_number, odt_number, odt_entries_count)
         return result
 
     # PGM
@@ -1270,7 +1275,7 @@ class Master:
         return result
 
     @wrapped
-    def programClear(self, mode: int, clearRange: int):
+    def programClear(self, mode: int, clear_range: int):
         """Clear a part of non-volatile memory.
 
         Parameters
@@ -1280,18 +1285,18 @@ class Master:
             0x01 = the functional access mode is active
         clearRange : int
         """
-        cr = self.DWORD_pack(clearRange)
+        cr = self.DWORD_pack(clear_range)
         response = self.transport.request(types.Command.PROGRAM_CLEAR, mode, 0, 0, *cr)
         # ERR_ACCESS_LOCKED
         return response
 
     @wrapped
-    def program(self, data: bytes, blockLength, last=False):
+    def program(self, data: bytes, block_length: int, last: bool = False):
         """Parameters
         ----------
         data : bytes
             Data to send to slave.
-        blockModeLength : int
+        block_mode_length : int
             the program request must contain the length of the whole block, not just the length
             in the current packet.
         last : bool
@@ -1310,12 +1315,12 @@ class Master:
         #    d.extend(self.AG_pack(e))
         if last:
             # last PROGRAM_NEXT packet in a block: the slave device has to send the response after this.
-            response = self.transport.request(types.Command.PROGRAM, blockLength, *data)
+            response = self.transport.request(types.Command.PROGRAM, block_length, *data)
             return response
         else:
             # the slave device won't respond to consecutive PROGRAM_NEXT packets in block mode,
             # so we must not wait for any response
-            self.transport.block_request(types.Command.PROGRAM, blockLength, *data)
+            self.transport.block_request(types.Command.PROGRAM, block_length, *data)
             return None
 
     @wrapped
@@ -1336,9 +1341,9 @@ class Master:
         return result
 
     @wrapped
-    def getSectorInfo(self, mode, sectorNumber):
+    def getSectorInfo(self, mode: int, sector_number: int):
         """Get specific information for a sector."""
-        response = self.transport.request(types.Command.GET_SECTOR_INFO, mode, sectorNumber)
+        response = self.transport.request(types.Command.GET_SECTOR_INFO, mode, sector_number)
         if mode == 0 or mode == 1:
             return types.GetSectorInfoResponseMode01.parse(response, byteOrder=self.slaveProperties.byteOrder)
         elif mode == 2:
@@ -1351,17 +1356,17 @@ class Master:
         return self.transport.request(types.Command.PROGRAM_PREPARE, 0x00, *cs)
 
     @wrapped
-    def programFormat(self, compressionMethod, encryptionMethod, programmingMethod, accessMethod):
+    def programFormat(self, compression_method: int, encryption_method: int, programming_method: int, access_method: int):
         return self.transport.request(
             types.Command.PROGRAM_FORMAT,
-            compressionMethod,
-            encryptionMethod,
-            programmingMethod,
-            accessMethod,
+            compression_method,
+            encryption_method,
+            programming_method,
+            access_method,
         )
 
     @wrapped
-    def programNext(self, data: bytes, remainingBlockLength: int, last: bool = False):
+    def programNext(self, data: bytes, remaining_block_length: int, last: bool = False):
         # d = bytearray()
         # d.append(len(data))
         # if self.slaveProperties.addressGranularity == types.AddressGranularity.DWORD:
@@ -1370,16 +1375,16 @@ class Master:
         #    d.extend(self.AG_pack(e))
         if last:
             # last PROGRAM_NEXT packet in a block: the slave device has to send the response after this.
-            response = self.transport.request(types.Command.PROGRAM_NEXT, remainingBlockLength, *data)
+            response = self.transport.request(types.Command.PROGRAM_NEXT, remaining_block_length, *data)
             return response
         else:
             # the slave device won't respond to consecutive PROGRAM_NEXT packets in block mode,
             # so we must not wait for any response
-            self.transport.block_request(types.Command.PROGRAM_NEXT, remainingBlockLength, *data)
+            self.transport.block_request(types.Command.PROGRAM_NEXT, remaining_block_length, *data)
             return None
 
     @wrapped
-    def programMax(self, data):
+    def programMax(self, data: bytes):
         d = bytearray()
         if self.slaveProperties.addressGranularity == types.AddressGranularity.WORD:
             d.extend(b"\x00")  # alignment bytes
@@ -1390,11 +1395,11 @@ class Master:
         return self.transport.request(types.Command.PROGRAM_MAX, *d)
 
     @wrapped
-    def programVerify(self, verMode, verType, verValue):
+    def programVerify(self, ver_mode: int, ver_type: int, ver_value: int):
         data = bytearray()
-        data.extend(self.WORD_pack(verType))
-        data.extend(self.DWORD_pack(verValue))
-        return self.transport.request(types.Command.PROGRAM_VERIFY, verMode, *data)
+        data.extend(self.WORD_pack(ver_type))
+        data.extend(self.DWORD_pack(ver_value))
+        return self.transport.request(types.Command.PROGRAM_VERIFY, ver_mode, *data)
 
     # DBG
 
@@ -1617,9 +1622,9 @@ class Master:
         return types.DbgLlbtResponse.parse(response, byteOrder=self.slaveProperties.byteOrder)
 
     @wrapped
-    def timeCorrelationProperties(self, setProperties, getPropertiesRequest, clusterId):
+    def timeCorrelationProperties(self, set_properties: int, get_properties_request: int, cluster_id: int):
         response = self.transport.request(
-            types.Command.TIME_CORRELATION_PROPERTIES, setProperties, getPropertiesRequest, 0, *self.WORD_pack(clusterId)
+            types.Command.TIME_CORRELATION_PROPERTIES, set_properties, get_properties_request, 0, *self.WORD_pack(cluster_id)
         )
         return types.TimeCorrelationPropertiesResponse.parse(response, byteOrder=self.slaveProperties.byteOrder)
 
@@ -1631,14 +1636,14 @@ class Master:
         response = self.transportLayerCmd(types.TransportLayerCommands.GET_SLAVE_ID, ord("X"), ord("C"), ord("P"), mode)
         return types.GetSlaveIdResponse.parse(response, byteOrder=self.slaveProperties.byteOrder)
 
-    def getDaqId(self, daqListNumber: int):
-        response = self.transportLayerCmd(types.TransportLayerCommands.GET_DAQ_ID, *self.WORD_pack(daqListNumber))
+    def getDaqId(self, daq_list_number: int):
+        response = self.transportLayerCmd(types.TransportLayerCommands.GET_DAQ_ID, *self.WORD_pack(daq_list_number))
         # if response:
         return types.GetDaqIdResponse.parse(response, byteOrder=self.slaveProperties.byteOrder)
 
-    def setDaqId(self, daqListNumber: int, identifier: int):
+    def setDaqId(self, daq_list_number: int, identifier: int):
         response = self.transportLayerCmd(
-            types.TransportLayerCommands.SET_DAQ_ID, *self.WORD_pack(daqListNumber), *self.DWORD_pack(identifier)
+            types.TransportLayerCommands.SET_DAQ_ID, *self.WORD_pack(daq_list_number), *self.DWORD_pack(identifier)
         )
         return response
 
@@ -1665,7 +1670,7 @@ class Master:
         self.logger.debug(f"Our checksum          : 0x{cc:08X}")
         return cs.checksum == cc
 
-    def getDaqInfo(self):
+    def getDaqInfo(self, include_event_lists=True):
         """Get DAQ information: processor, resolution, events."""
         result = {}
         dpi = self.getDaqProcessorInfo()
@@ -1706,45 +1711,46 @@ class Master:
         result["resolution"] = resolutionInfo
         channels = []
         daq_events = []
-        for ecn in range(dpi.maxEventChannel):
-            eci = self.getDaqEventInfo(ecn)
-            cycle = eci["eventChannelTimeCycle"]
-            maxDaqList = eci["maxDaqList"]
-            priority = eci["eventChannelPriority"]
-            time_unit = eci["eventChannelTimeUnit"]
-            consistency = eci["daqEventProperties"]["consistency"]
-            daq_supported = eci["daqEventProperties"]["daq"]
-            stim_supported = eci["daqEventProperties"]["stim"]
-            packed_supported = eci["daqEventProperties"]["packed"]
-            name = self.fetch(eci.eventChannelNameLength)
-            if name:
-                name = decode_bytes(name)
-            channel = {
-                "name": name,
-                "priority": eci["eventChannelPriority"],
-                "unit": eci["eventChannelTimeUnit"],
-                "cycle": eci["eventChannelTimeCycle"],
-                "maxDaqList": eci["maxDaqList"],
-                "properties": {
-                    "consistency": consistency,
-                    "daq": daq_supported,
-                    "stim": stim_supported,
-                    "packed": packed_supported,
-                },
-            }
-            daq_event_info = DaqEventInfo(
-                name,
-                types.EVENT_CHANNEL_TIME_UNIT_TO_EXP[time_unit],
-                cycle,
-                maxDaqList,
-                priority,
-                consistency,
-                daq_supported,
-                stim_supported,
-                packed_supported,
-            )
-            daq_events.append(daq_event_info)
-            channels.append(channel)
+        if include_event_lists:
+            for ecn in range(dpi.maxEventChannel):
+                eci = self.getDaqEventInfo(ecn)
+                cycle = eci["eventChannelTimeCycle"]
+                maxDaqList = eci["maxDaqList"]
+                priority = eci["eventChannelPriority"]
+                time_unit = eci["eventChannelTimeUnit"]
+                consistency = eci["daqEventProperties"]["consistency"]
+                daq_supported = eci["daqEventProperties"]["daq"]
+                stim_supported = eci["daqEventProperties"]["stim"]
+                packed_supported = eci["daqEventProperties"]["packed"]
+                name = self.fetch(eci.eventChannelNameLength)
+                if name:
+                    name = decode_bytes(name)
+                channel = {
+                    "name": name,
+                    "priority": eci["eventChannelPriority"],
+                    "unit": eci["eventChannelTimeUnit"],
+                    "cycle": eci["eventChannelTimeCycle"],
+                    "maxDaqList": eci["maxDaqList"],
+                    "properties": {
+                        "consistency": consistency,
+                        "daq": daq_supported,
+                        "stim": stim_supported,
+                        "packed": packed_supported,
+                    },
+                }
+                daq_event_info = DaqEventInfo(
+                    name,
+                    types.EVENT_CHANNEL_TIME_UNIT_TO_EXP[time_unit],
+                    cycle,
+                    maxDaqList,
+                    priority,
+                    consistency,
+                    daq_supported,
+                    stim_supported,
+                    packed_supported,
+                )
+                daq_events.append(daq_event_info)
+                channels.append(channel)
         result["channels"] = channels
         self.stim.setDaqEventInfo(daq_events)
         return result
@@ -1970,15 +1976,26 @@ class Master:
             extra_msg: Optional[str] = kws.get("extra_msg")
             if extra_msg:
                 kws.pop("extra_msg")
+            else:
+                extra_msg = ""
+            silent: Optional[bool] = kws.get("silent")
+            if silent:
+                kws.pop("silent")
+            else:
+                silent = False
             res = cmd(*args, **kws)
         except SystemExit as e:
+            # print(f"\tUnexpected error while executing command {cmd.__name__!r}: {e!r}")
             if e.error_code == types.XcpError.ERR_CMD_UNKNOWN:
                 # This is a rather common use-case, so let the user know that there is some functionality missing.
-                if extra_msg:
-                    self.logger.warning(f"Optional command {cmd.__name__!r} not implemented -- {extra_msg!r}")
-                else:
-                    self.logger.warning(f"Optional command {cmd.__name__!r} not implemented.")
-            return (types.TryCommandResult.XCP_ERROR, e)
+                if not silent:
+                    if extra_msg:
+                        self.logger.warning(f"Optional command {cmd.__name__!r} not implemented -- {extra_msg!r}")
+                    else:
+                        self.logger.warning(f"Optional command {cmd.__name__!r} not implemented.")
+                return (types.TryCommandResult.NOT_IMPLEMENTED, e)
+            else:
+                return (types.TryCommandResult.XCP_ERROR, e)
         except Exception as e:
             return (types.TryCommandResult.OTHER_ERROR, e)
         else:

pyxcp/types.py

@@ -990,4 +990,5 @@ class TryCommandResult(enum.IntEnum):
 
     OK = 0
     XCP_ERROR = 1
-    OTHER_ERROR = 2
+    NOT_IMPLEMENTED = 2
+    OTHER_ERROR = 3

{pyxcp-0.22.23.dist-info → pyxcp-0.22.25.dist-info}/METADATA

@@ -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.dist-info → pyxcp-0.22.25.dist-info}/RECORD

@@ -1,4 +1,4 @@
-pyxcp/__init__.py,sha256=V3SXLv-pZNUllrYboyAoZk3eD9vuF4VXt4X0fPnENOw,548
+pyxcp/__init__.py,sha256=NDu785DrhpFkKcUgVKRBeBhp6NC9yp9DVxG_MGx_3Dg,548
 pyxcp/aml/EtasCANMonitoring.a2l,sha256=EJYwe3Z3H24vyWAa6lUgcdKnQY8pwFxjyCN6ZU1ST8w,1509
 pyxcp/aml/EtasCANMonitoring.aml,sha256=xl0DdyeiIaLW0mmmJNAyJS0CQdOLSxt9dxfgrdSlU8Y,2405
 pyxcp/aml/ifdata_CAN.a2l,sha256=NCUnCUEEgRbZYSLGtUGwL2e7zJ8hrp0SbmLHGv8uY58,612
@@ -24,26 +24,26 @@ pyxcp/constants.py,sha256=9yGfujC0ImTYQWfn41wyw8pluJTSrhMGWIVeIZTgsLg,1160
 pyxcp/cpp_ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyxcp/cpp_ext/bin.hpp,sha256=PwJloZek21la-RBSda2Hc0u_6gID0sfTduPeplaAyR4,2561
 pyxcp/cpp_ext/blockmem.hpp,sha256=ysaJwmTWGTfE54Outk3gJYOfAVFd_QaonBMtXLcXwCc,1242
-pyxcp/cpp_ext/cpp_ext.cp310-win_amd64.pyd,sha256=yCj8PLbgIuWiN7UA5rNjNc1qVpVxzks8E-bXUd5QAZ8,279040
-pyxcp/cpp_ext/cpp_ext.cp38-win_amd64.pyd,sha256=cRafRoCE7udgdFWX5Yj_9ZDDaIAG1gfpX2eWumxUgig,279040
-pyxcp/cpp_ext/cpp_ext.cp39-win_amd64.pyd,sha256=diNwWzCQm0i75EsOkLHG0VZ0pqnor3bHcQDyy5_1GhM,260096
-pyxcp/cpp_ext/daqlist.hpp,sha256=5JEYQK96qac4ZsoMVnmVGsrH_4uuqbHwcNGiH4j5FAU,7167
+pyxcp/cpp_ext/cpp_ext.cp310-win_amd64.pyd,sha256=VWNTkyiub_-mX4OXAsEROyUfJz3fOSuyz_clzlwaYTo,279552
+pyxcp/cpp_ext/cpp_ext.cp38-win_amd64.pyd,sha256=FvxLTjwiAyCQBEoqKOZ-fci6t1caxfVchOpwv7ruPzY,279552
+pyxcp/cpp_ext/cpp_ext.cp39-win_amd64.pyd,sha256=Jx5MDTdx6bNKSEvJjd_Wa-TnVHmexbmdjPqQARmVYx8,260096
+pyxcp/cpp_ext/daqlist.hpp,sha256=g2hlxgoQorAGKHedZFZ0c2FQh1APMIA9sVB6M6hD_n8,7277
 pyxcp/cpp_ext/event.hpp,sha256=Z-1yxsEKsr81NnLVEWJ2ANA8FV7YsM7EbNxaw-elheE,1200
-pyxcp/cpp_ext/extension_wrapper.cpp,sha256=-r1YYgJD4dJiiMeA0HEmIQQfsXrzDozLonCrbpKUXiA,4544
+pyxcp/cpp_ext/extension_wrapper.cpp,sha256=FXFjyruBjQYqjCYZZcajdYv6dvNnCggMAbWLqJmfuTM,4756
 pyxcp/cpp_ext/helper.hpp,sha256=ONAsVupIqqmNDp8bgGWS0TfSYeCFkk3kwwZbbqsh0HQ,7813
 pyxcp/cpp_ext/mcobject.hpp,sha256=A5GKcfjYMcfm3hfTQfFuS4JYNFTvfmzAcMXCe01GOs4,6429
 pyxcp/cpp_ext/tsqueue.hpp,sha256=FWMemzXNgV5dQ7gYmTCzC0QYfgl0VI9JCybYelBcCHU,1026
-pyxcp/daq_stim/__init__.py,sha256=OXit9yuI3Aresbnz1yGsOJ6OavL_LkeX8d5bMOMdCag,9404
+pyxcp/daq_stim/__init__.py,sha256=xQNF6MlVnPHtjj5fKEvXnLWxIJs_Fqd5XVMN4lcFaC8,9532
 pyxcp/daq_stim/optimize/__init__.py,sha256=FUWK0GkNpNT-sUlhibp7xa2aSYpm6Flh5yA2w2IOJqg,2520
 pyxcp/daq_stim/optimize/binpacking.py,sha256=Iltho5diKlJG-ltbmx053U2vOFRlCISolXK61T14l_I,1257
 pyxcp/daq_stim/scheduler.cpp,sha256=a7VK7kP2Hs8yMlcDAkXwJ0bH88lr_yz156sphcHS7Z4,715
 pyxcp/daq_stim/scheduler.hpp,sha256=U_6tUbebmzX5vVZS0EFSgTaPsyxMg6yRXHG_aPWA0x4,1884
-pyxcp/daq_stim/stim.cp310-win_amd64.pyd,sha256=TwmMXXgHYOh-aVi-yKGAm8Z3ONjR_v8Y5vYUIcPowtY,186880
-pyxcp/daq_stim/stim.cp38-win_amd64.pyd,sha256=YBtdP7RHlzQ-OwEmVK-VJYRktF5YdASMKGHiqYmhPfY,186880
-pyxcp/daq_stim/stim.cp39-win_amd64.pyd,sha256=N1u0GASMkD4lWjT1q4uKHW8xBxe3rCQ4TGksf06niUE,181248
+pyxcp/daq_stim/stim.cp310-win_amd64.pyd,sha256=DD7ufKxaaRW5DmBBsAe4whg6qoi8GQ62VT7IS7U8KlA,189440
+pyxcp/daq_stim/stim.cp38-win_amd64.pyd,sha256=X_ftCGxwZ4slT40A21gSUwJq8J-vB8Q_VUvZgQkRB2c,189440
+pyxcp/daq_stim/stim.cp39-win_amd64.pyd,sha256=nM37yO0Em1w_FxpT4mL5a8IVkYT5wsKLON1b1lI6C6w,183296
 pyxcp/daq_stim/stim.cpp,sha256=F2OG67W4KKwTTiUCxm-9egIv3TLFdOkRunX6xf7YOtc,177
 pyxcp/daq_stim/stim.hpp,sha256=U-uInRrA6OCdMl1l1SWbQ_KEPpnNYrWut924IvbW6R0,18508
-pyxcp/daq_stim/stim_wrapper.cpp,sha256=5LbWkK86h_4mHd83dnwCU7BRvVYit8ijxBMT7pthtOE,1830
+pyxcp/daq_stim/stim_wrapper.cpp,sha256=iT2yxJ3LRG7HoYC1bwhM3tCAxF9X_HHierBNsLRmTJg,1995
 pyxcp/dllif.py,sha256=nXzD5toh_z9Zjj3x3trigURfwE98fYaL4RmUlI7FaqY,3308
 pyxcp/errormatrix.py,sha256=iY3VlAem7pNfpK4scD_087wxMlLxNuidB7bbpiUiAyc,45464
 pyxcp/examples/conf_can.toml,sha256=4o-M4xmh7pCzuQLfXnIOLIXqx5aZjMAZ6jtjYJ8hLBQ,370
@@ -60,7 +60,7 @@ pyxcp/examples/ex_csv.py,sha256=GNWQ3IatXj3Kg5MUX6p8tzJRUppGreON9dkrNiqdTtk,2461
 pyxcp/examples/ex_excel.py,sha256=VpoqRTv-rHz-MnaFKt5f7MqDrK9OLYyRJvVWzCFsayc,2828
 pyxcp/examples/ex_mdf.py,sha256=zfivlNkbbsfvwqsISttaoQk1R888r7UUtwSqocE60sU,3759
 pyxcp/examples/ex_sqlite.py,sha256=ludD0EIziBhBNnC3MOrQTGs06cl7iNyL2yefwe53zNc,4268
-pyxcp/examples/run_daq.py,sha256=kpy5aFKOFaQnwWmyE_--54NuDeaLEISQX8CKmuQEpHc,5007
+pyxcp/examples/run_daq.py,sha256=KXL9myK3w7RCIgjZblU2i1XOP5l4V0YRQKNRXF7ISIo,5518
 pyxcp/examples/xcp_policy.py,sha256=io9tS2W-7PvR8ZzU203KolFrDp67eorUlwNWvA4kC5k,1921
 pyxcp/examples/xcp_read_benchmark.py,sha256=zOG0Yrji10vA0vhHa27KK7zgc3JDpzXzXsFnIU4C_AM,956
 pyxcp/examples/xcp_skel.py,sha256=YXLQC8nn8aAwYSVuBGhr1dvmdMBjmO1Ee1w3e5sy16s,1159
@@ -70,7 +70,7 @@ pyxcp/examples/xcphello.py,sha256=xbcWq8StRJyUZBLUvknsXv7VkEBD5SU0SJjlZTHsSzs,26
 pyxcp/examples/xcphello_recorder.py,sha256=QHWJsq5h5CI9t5qEmMSorZyzirTpoXz4nzuKTMzbZCA,3409
 pyxcp/master/__init__.py,sha256=QQbkUJM1WQ-5p2MiNFYxLAmHhNsCQLzDp-S4aoOFxoA,318
 pyxcp/master/errorhandler.py,sha256=U5QuvGRDM9kRNwY5kbkTOnthp19RHoXEGCsaBNiFTps,14973
-pyxcp/master/master.py,sha256=mdsktxzkLABj0Rz011qJ3ifxDWiAP3M81cAQ7DN5lXc,76959
+pyxcp/master/master.py,sha256=y5i5HTw5g4HKHW8tXfpNc0hmaQjle-3dsUkVFqPjUXc,78365
 pyxcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyxcp/recorder/__init__.py,sha256=pg-cdOaoj-D-woFxFb2p6SpFTNTdpQEIknHdDaQ9ROE,2695
 pyxcp/recorder/build_clang.cmd,sha256=JvFngSnb28XcBGXxC6MGrcOCGYfahOIvHpgRpqbA6HQ,175
@@ -87,9 +87,9 @@ pyxcp/recorder/mio.hpp,sha256=5ASJLKSEykH0deAQD5uak-_yAgd5p2n8t06315GSGrg,63346
 pyxcp/recorder/reader.hpp,sha256=rr9XZ_ciL6eF2_xEqyt9XYNqTIze9ytAsnf8uYukO9U,5201
 pyxcp/recorder/reco.py,sha256=6N6FIwfCEVMpi5dr3eUOQa1lowcg2LCnS_sy_-b-UiQ,8725
 pyxcp/recorder/recorder.rst,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyxcp/recorder/rekorder.cp310-win_amd64.pyd,sha256=EmaWdZr0m2M5WMRGBCxmdAvODxK4fAnZwmF3XyPnfeY,377856
-pyxcp/recorder/rekorder.cp38-win_amd64.pyd,sha256=KOsfruA8xsAkhHjEUIctg4PAUPpSMhGcMnWTXxvzgh8,377856
-pyxcp/recorder/rekorder.cp39-win_amd64.pyd,sha256=oPeJ5yQrV0-hamFjBBVLUdneZJqxJteGq7E22QqjfbA,364032
+pyxcp/recorder/rekorder.cp310-win_amd64.pyd,sha256=CGdvShmnyjesXbPTQ8rM_bqpftDtXRZ1A7NjsGhkrDc,377856
+pyxcp/recorder/rekorder.cp38-win_amd64.pyd,sha256=_XW8GKdICxi0mzTRHwZ7Fc_afbCMOPrCQpNa-EozKnE,377856
+pyxcp/recorder/rekorder.cp39-win_amd64.pyd,sha256=IlUPHXqh86T7fBmgHC8EE7nTMuCkJMYTggM9u52LSwU,364032
 pyxcp/recorder/rekorder.cpp,sha256=U0LMyk8pZXx9emgS_WPVthvn_9IpgE7JGrh4kg-8CX4,1900
 pyxcp/recorder/rekorder.hpp,sha256=sWvRch9bVt6mmgrFHp5mwWhap7HoFG4geeb7UqEIzio,7638
 pyxcp/recorder/setup.py,sha256=_99XFPQAd5V4LcJaSGJwdnbxgxJ7kl8DEXfHsnKO1Yg,998
@@ -123,12 +123,12 @@ pyxcp/transport/eth.py,sha256=xPzN2oSALoPKJVvZpBljPSV1AxfpjRusOzymO-TD1Rw,8711
 pyxcp/transport/sxi.py,sha256=vM8WZIKuu_dNuqkxZM_1n6iQkQCCzo4ykWpiG6ba8Fk,4695
 pyxcp/transport/transport_wrapper.cpp,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyxcp/transport/usb_transport.py,sha256=JuYrwkWsUdibdVNA57LBEQT3a3ykOgWPdWcfqj96nDE,8343
-pyxcp/types.py,sha256=hY4Bb3qT3ZoabGnSKLY6S84MvVyuOCxwVONfs2skx2Y,26043
+pyxcp/types.py,sha256=wm3tOocuAln4jpH_mDguPRYtIzHSQ_KQBYNATFB2WXc,26068
 pyxcp/utils.py,sha256=unlg0CoNwcWYfd-BE0hZJ93uhlAoW_nryv9tS_R3C44,2969
 pyxcp/vector/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyxcp/vector/map.py,sha256=7Gnhvr79geMeqqGVIJPxODXGwABdNDinnqzhpooN5TE,2306
-pyxcp-0.22.23.dist-info/entry_points.txt,sha256=2JbL-pWn9UxpBrS64aWiFFkq9x2A7y-dkrxYlfQqIJU,307
-pyxcp-0.22.23.dist-info/LICENSE,sha256=fTqV5eBpeAZO0_jit8j4Ref9ikBSlHJ8xwj5TLg7gFk,7817
-pyxcp-0.22.23.dist-info/METADATA,sha256=1E_6DzNfgDYZ1ok-YoAaXZYrhItROse3QrRAJhXSS6c,4088
-pyxcp-0.22.23.dist-info/WHEEL,sha256=GX2ImTsBnuQB1-UeuYbhJUp8NYXMHTQONElBI_kxGe0,98
-pyxcp-0.22.23.dist-info/RECORD,,
+pyxcp-0.22.25.dist-info/entry_points.txt,sha256=2JbL-pWn9UxpBrS64aWiFFkq9x2A7y-dkrxYlfQqIJU,307
+pyxcp-0.22.25.dist-info/LICENSE,sha256=fTqV5eBpeAZO0_jit8j4Ref9ikBSlHJ8xwj5TLg7gFk,7817
+pyxcp-0.22.25.dist-info/METADATA,sha256=oUrQTmW0BB6APl8u-j-RKbfm75jwXGBVnr72VmiaOjo,4088
+pyxcp-0.22.25.dist-info/WHEEL,sha256=GX2ImTsBnuQB1-UeuYbhJUp8NYXMHTQONElBI_kxGe0,98
+pyxcp-0.22.25.dist-info/RECORD,,