pyxcp 0.23.8__cp313-cp313-macosx_11_0_arm64.whl → 0.25.7__cp313-cp313-macosx_11_0_arm64.whl

pyxcp/transport/transport_ext.hpp

@@ -0,0 +1,214 @@
+
+#include <cstdint>
+
+#include <bit>
+#include <optional>
+#include <iostream>
+#include <map>
+#include <set>
+#include <tuple>
+#include <vector>
+
+#include "rekorder.hpp"
+
+const std::map<FrameCategory, std::string> FrameCategoryName {
+	{FrameCategory::META, "METADATA"},
+	{FrameCategory::CMD, "CMD"},
+	{FrameCategory::RES, "RESPONSE"},
+	{FrameCategory::ERR, "ERROR"},
+	{FrameCategory::EV, "EVENT"},
+	{FrameCategory::SERV, "SERV"},
+	{FrameCategory::DAQ, "DAQ"},
+	{FrameCategory::STIM, "STIM"},
+};
+
+/*
+    Base class for all frame acquisition policies.
+
+    Parameters
+    ---------
+    filter_out: set or None
+        A set of frame types to filter out.
+        If None, all frame types are accepted for further processing.
+
+        Example: (FrameType.REQUEST, FrameType.RESPONSE, FrameType.EVENT, FrameType.SERV)
+                  ==> care only about DAQ frames.
+*/
+class FrameAcquisitionPolicy {
+public:
+
+	using payload_t = std::string;
+	using filter_t = std::set<FrameCategory>;
+	using frame_t = std::tuple<std::uint32_t, std::uint64_t, const payload_t>;
+
+
+	FrameAcquisitionPolicy(const std::optional<filter_t>& filter_out) {
+		if (!filter_out) {
+			m_filter_out = filter_t{};
+		} else {
+			m_filter_out = filter_out;
+		}
+	}
+
+	std::optional<filter_t> get_filtered_out() const {
+		return m_filter_out;
+	}
+
+	FrameAcquisitionPolicy(const FrameAcquisitionPolicy&) = delete;
+	FrameAcquisitionPolicy(FrameAcquisitionPolicy&&) = delete;
+	FrameAcquisitionPolicy() = delete;
+
+	virtual ~FrameAcquisitionPolicy() {}
+
+	virtual void feed(FrameCategory frame_category, std::uint32_t counter, std::uint64_t timestamp, const payload_t& payload) = 0;
+
+	virtual void finalize() = 0;
+
+protected:
+
+	std::optional<filter_t> m_filter_out;
+
+};
+
+
+/*
+	No operation / do nothing policy.
+*/
+class NoOpPolicy : public FrameAcquisitionPolicy {
+public:
+
+	NoOpPolicy(const std::optional<filter_t>& filter_out) : FrameAcquisitionPolicy(filter_out) {}
+
+	void feed(FrameCategory frame_category, std::uint32_t counter, std::uint64_t timestamp, const payload_t& payload) override {}
+
+	void finalize() override {}
+};
+
+
+/*
+	Dequeue based frame acquisition policy.
+
+    Deprecated: Use only for compatibility reasons.
+*/
+class LegacyFrameAcquisitionPolicy : public FrameAcquisitionPolicy {
+	public:
+
+		using deque_t = TsQueue<frame_t>;
+
+		LegacyFrameAcquisitionPolicy(const std::optional<filter_t>& filter_out) : FrameAcquisitionPolicy(filter_out) {
+
+			m_queue_map[FrameCategory::CMD] = std::make_shared<deque_t>();
+			m_queue_map[FrameCategory::RES] = std::make_shared<deque_t>();
+			m_queue_map[FrameCategory::EV] = std::make_shared<deque_t>();
+			m_queue_map[FrameCategory::SERV] = std::make_shared<deque_t>();
+			m_queue_map[FrameCategory::DAQ] = std::make_shared<deque_t>();
+			m_queue_map[FrameCategory::META] = std::make_shared<deque_t>();
+			m_queue_map[FrameCategory::ERR] = std::make_shared<deque_t>();
+			m_queue_map[FrameCategory::STIM] = std::make_shared<deque_t>();
+
+		}
+
+		LegacyFrameAcquisitionPolicy() = delete;
+		LegacyFrameAcquisitionPolicy(const LegacyFrameAcquisitionPolicy&) = delete;
+		LegacyFrameAcquisitionPolicy(LegacyFrameAcquisitionPolicy&&) = delete;
+
+		void feed(FrameCategory frame_category, std::uint32_t counter, std::uint64_t timestamp, const payload_t& payload) override {
+			if (m_filter_out && (!(*m_filter_out).contains(frame_category))) {
+				m_queue_map[frame_category]->put({counter, timestamp, payload});
+			}
+		}
+
+		std::shared_ptr<deque_t> get_req_queue() {
+			return m_queue_map.at(FrameCategory::CMD);
+		}
+
+		std::shared_ptr<deque_t> get_res_queue() {
+			return m_queue_map.at(FrameCategory::RES);
+		}
+
+		std::shared_ptr<deque_t> get_daq_queue() {
+			return m_queue_map.at(FrameCategory::DAQ);
+		}
+
+		std::shared_ptr<deque_t> get_ev_queue() {
+			return m_queue_map.at(FrameCategory::EV);
+		}
+
+		std::shared_ptr<deque_t> get_serv_queue() {
+			return m_queue_map.at(FrameCategory::SERV);
+		}
+
+		std::shared_ptr<deque_t> get_meta_queue() {
+			return m_queue_map.at(FrameCategory::META);
+		}
+
+		std::shared_ptr<deque_t> get_error_queue() {
+			return m_queue_map.at(FrameCategory::ERR);
+		}
+
+		std::shared_ptr<deque_t> get_stim_queue() {
+			return m_queue_map.at(FrameCategory::STIM);
+		}
+
+		void finalize() override {}
+
+private:
+
+	std::map<FrameCategory, std::shared_ptr<deque_t>> m_queue_map{};
+};
+
+std::string hex_bytes(std::string_view payload) {
+	std::stringstream ss;
+
+	for (auto ch: payload) {
+		ss << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>(static_cast<unsigned char>(ch))  << " ";
+	}
+	return ss.str();
+}
+
+/*
+	Frame acquisition policy that prints frames to stdout.
+*/
+class StdoutPolicy : public FrameAcquisitionPolicy {
+public:
+	StdoutPolicy(const std::optional<filter_t>& filter_out) : FrameAcquisitionPolicy(filter_out) {}
+
+	StdoutPolicy() = delete;
+	StdoutPolicy(const StdoutPolicy&) = delete;
+	StdoutPolicy(StdoutPolicy&&) = delete;
+
+	void feed(FrameCategory frame_category, std::uint32_t counter, std::uint64_t timestamp, const payload_t& payload) override {
+		if (m_filter_out && (!(*m_filter_out).contains(frame_category))) {
+			std::cout << std::left << std::setw(8) << FrameCategoryName.at(frame_category) << " " << std::right <<
+				std::setw(6) << counter << " " << std::setw(8) << timestamp << " [ " << std::left << hex_bytes(payload) << "]" << std::endl;
+		}
+	}
+
+	void finalize() override { }
+
+};
+
+class FrameRecorderPolicy : public FrameAcquisitionPolicy {
+public:
+
+	FrameRecorderPolicy(const std::string& file_name, const std::optional<filter_t>& filter_out, uint32_t prealloc = 10UL, uint32_t chunk_size = 1) : FrameAcquisitionPolicy(filter_out) {
+		m_writer = std::make_unique<XcpLogFileWriter>(file_name, prealloc, chunk_size);
+	}
+
+	FrameRecorderPolicy() = delete;
+	FrameRecorderPolicy(const FrameRecorderPolicy&) = delete;
+	FrameRecorderPolicy(FrameRecorderPolicy&&) = delete;
+
+	void feed(FrameCategory frame_category, std::uint32_t counter, std::uint64_t timestamp, const payload_t& payload) override {
+		if (m_filter_out && (!(*m_filter_out).contains(frame_category))) {
+			m_writer->add_frame(static_cast<std::uint8_t>(frame_category), counter, timestamp, payload.size(), std::bit_cast<const char *>(payload.data()));
+		}
+	}
+
+	void finalize() override {
+		m_writer->finalize();
+	}
+
+private:
+	std::unique_ptr<XcpLogFileWriter> m_writer;
+};

pyxcp/transport/transport_wrapper.cpp

@@ -0,0 +1,249 @@
+
+
+#include <pybind11/chrono.h>
+#include <pybind11/functional.h>
+#include <pybind11/numpy.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include <cstdint>
+
+#include "transport_ext.hpp"
+#include "framing.hpp"
+#include "sxi_framing.hpp"
+
+
+namespace py = pybind11;
+using namespace pybind11::literals;
+
+using SxiFrLBCN   = SxiReceiver< SxiHeaderFormat::LenByte, SxiChecksumType::None>;
+using SxiFrLBC8   = SxiReceiver< SxiHeaderFormat::LenByte, SxiChecksumType::Sum8>;
+using SxiFrLBC16  = SxiReceiver< SxiHeaderFormat::LenByte, SxiChecksumType::Sum16>;
+
+using SxiFrLCBCN  = SxiReceiver< SxiHeaderFormat::LenCtrByte, SxiChecksumType::None>;
+using SxiFrLCBC8  = SxiReceiver< SxiHeaderFormat::LenCtrByte, SxiChecksumType::Sum8>;
+using SxiFrLCBC16 = SxiReceiver< SxiHeaderFormat::LenCtrByte, SxiChecksumType::Sum16>;
+
+using SxiFrLFBCN  = SxiReceiver< SxiHeaderFormat::LenFillByte, SxiChecksumType::None>;
+using SxiFrLFBC8  = SxiReceiver< SxiHeaderFormat::LenFillByte, SxiChecksumType::Sum8>;
+using SxiFrLFBC16 = SxiReceiver< SxiHeaderFormat::LenFillByte, SxiChecksumType::Sum16>;
+
+using SxiFrLWCN   = SxiReceiver< SxiHeaderFormat::LenWord, SxiChecksumType::None>;
+using SxiFrLWC8   = SxiReceiver< SxiHeaderFormat::LenWord, SxiChecksumType::Sum8>;
+using SxiFrLWC16  = SxiReceiver< SxiHeaderFormat::LenWord, SxiChecksumType::Sum16>;
+
+using SxiFrLCWCN  = SxiReceiver< SxiHeaderFormat::LenCtrWord, SxiChecksumType::None>;
+using SxiFrLCWC8  = SxiReceiver< SxiHeaderFormat::LenCtrWord, SxiChecksumType::Sum8>;
+using SxiFrLCWC16 = SxiReceiver< SxiHeaderFormat::LenCtrWord, SxiChecksumType::Sum16>;
+
+using SxiFrLFWCN  = SxiReceiver< SxiHeaderFormat::LenFillWord, SxiChecksumType::None>;
+using SxiFrLFWC8  = SxiReceiver< SxiHeaderFormat::LenFillWord, SxiChecksumType::Sum8>;
+using SxiFrLFWC16 = SxiReceiver< SxiHeaderFormat::LenFillWord, SxiChecksumType::Sum16>;
+
+
+class PyFrameAcquisitionPolicy : public FrameAcquisitionPolicy {
+   public:
+
+    using FrameAcquisitionPolicy::FrameAcquisitionPolicy;
+
+    void feed(
+        FrameCategory frame_category, std::uint32_t counter, std::uint64_t timestamp, const payload_t& payload
+    ) override {
+        PYBIND11_OVERRIDE_PURE(void, FrameAcquisitionPolicy, feed, frame_category, counter, timestamp, payload);
+    }
+
+
+    void finalize() override {
+        PYBIND11_OVERRIDE_PURE(void, FrameAcquisitionPolicy, finalize);
+    }
+};
+
+
+PYBIND11_MODULE(transport_ext, m) {
+    m.doc() = "pyXCP transport-layer base classes.";
+
+	py::enum_<FrameCategory>(m, "FrameCategory")
+		.value("METADATA", FrameCategory::META)
+		.value("CMD", FrameCategory::CMD)
+		.value("RESPONSE", FrameCategory::RES)
+		.value("ERROR", FrameCategory::ERR)
+		.value("EVENT", FrameCategory::EV)
+		.value("SERV", FrameCategory::SERV)
+		.value("DAQ", FrameCategory::DAQ)
+		.value("STIM", FrameCategory::STIM)
+	;
+
+	py::class_<FrameAcquisitionPolicy, PyFrameAcquisitionPolicy>(m, "FrameAcquisitionPolicy", py::dynamic_attr())
+		.def(py::init<const std::optional<FrameAcquisitionPolicy::filter_t>&>(), py::arg("filtered_out") = std::nullopt)
+		.def("feed", &FrameAcquisitionPolicy::feed)
+		.def("finalize", &FrameAcquisitionPolicy::finalize)
+		.def_property_readonly("filtered_out", &FrameAcquisitionPolicy::get_filtered_out)
+	;
+
+	py::class_<LegacyFrameAcquisitionPolicy>(m, "LegacyFrameAcquisitionPolicy", py::dynamic_attr())
+		.def(py::init<const std::optional<FrameAcquisitionPolicy::filter_t>&>(), py::arg("filtered_out") = std::nullopt)
+		.def("feed", &FrameAcquisitionPolicy::feed)
+		.def("finalize", &FrameAcquisitionPolicy::finalize)
+		.def_property_readonly("reqQueue", &LegacyFrameAcquisitionPolicy::get_req_queue)
+		.def_property_readonly("resQueue", &LegacyFrameAcquisitionPolicy::get_res_queue)
+		.def_property_readonly("daqQueue", &LegacyFrameAcquisitionPolicy::get_daq_queue)
+		.def_property_readonly("evQueue", &LegacyFrameAcquisitionPolicy::get_ev_queue)
+		.def_property_readonly("servQueue", &LegacyFrameAcquisitionPolicy::get_serv_queue)
+		.def_property_readonly("metaQueue", &LegacyFrameAcquisitionPolicy::get_meta_queue)
+		.def_property_readonly("errorQueue", &LegacyFrameAcquisitionPolicy::get_error_queue)
+		.def_property_readonly("stimQueue", &LegacyFrameAcquisitionPolicy::get_stim_queue)
+	;
+
+	py::class_<NoOpPolicy>(m, "NoOpPolicy", py::dynamic_attr())
+		.def(py::init<const std::optional<FrameAcquisitionPolicy::filter_t>&>(), py::arg("filtered_out") = std::nullopt)
+		.def("feed", &FrameAcquisitionPolicy::feed)
+		.def("finalize", &FrameAcquisitionPolicy::finalize)
+	;
+
+	py::class_<StdoutPolicy>(m, "StdoutPolicy", py::dynamic_attr())
+		.def(py::init<const std::optional<FrameAcquisitionPolicy::filter_t>&>(), py::arg("filtered_out") = std::nullopt)
+		.def("feed", &FrameAcquisitionPolicy::feed)
+		.def("finalize", &FrameAcquisitionPolicy::finalize)
+	;
+
+	py::class_<FrameRecorderPolicy>(m, "FrameRecorderPolicy", py::dynamic_attr())
+		.def(py::init<const std::string&, const std::optional<FrameAcquisitionPolicy::filter_t>&, uint32_t, uint32_t>(),
+			py::arg("file_name"), py::arg("filtered_out") = std::nullopt, py::arg("prealloc") = 10UL, py::arg("chunk_size") = 1)
+		.def("feed", &FrameAcquisitionPolicy::feed)
+		.def("finalize", &FrameAcquisitionPolicy::finalize)
+	;
+    // Transport layer type enum
+    py::enum_<XcpTransportLayerType>(m, "XcpTransportLayerType")
+        .value("CAN", XcpTransportLayerType::CAN)
+        .value("ETH", XcpTransportLayerType::ETH)
+        .value("SXI", XcpTransportLayerType::SXI)
+        .value("USB", XcpTransportLayerType::USB);
+
+    // XCP checksum type enum
+    py::enum_<ChecksumType>(m, "ChecksumType")
+        .value("NO_CHECKSUM", ChecksumType::NO_CHECKSUM)
+        .value("BYTE_CHECKSUM", ChecksumType::BYTE_CHECKSUM)
+        .value("WORD_CHECKSUM", ChecksumType::WORD_CHECKSUM);
+
+    // XCP framing configuration and helper
+    py::class_<XcpFramingConfig>(m, "XcpFramingConfig")
+        .def(py::init<>())
+        .def(py::init<XcpTransportLayerType, std::uint8_t, std::uint8_t, std::uint8_t, bool, ChecksumType>(),
+            "transport_layer_type"_a, "header_len"_a, "header_ctr"_a, "header_fill"_a, "tail_fill"_a = false, "tail_cs"_a = ChecksumType::NO_CHECKSUM)
+        .def_property_readonly("transport_layer_type", [](const XcpFramingConfig &self) { return self.transport_layer_type; })
+        .def_property_readonly("header_len", [](const XcpFramingConfig &self) { return self.header_len; })
+        .def_property_readonly("header_ctr", [](const XcpFramingConfig &self) { return self.header_ctr; })
+        .def_property_readonly("header_fill", [](const XcpFramingConfig &self) { return self.header_fill; })
+        .def_property_readonly("tail_fill", [](const XcpFramingConfig &self) { return self.tail_fill; })
+        .def_property_readonly("tail_cs", [](const XcpFramingConfig &self) { return self.tail_cs; });
+
+    py::class_<XcpFraming>(m, "XcpFraming")
+        .def(py::init<const XcpFramingConfig&>())
+        .def("prepare_request", [](XcpFraming &self, std::uint32_t cmd, py::bytes data) {
+            std::string s = data;
+            std::vector<uint8_t> data_vec(s.begin(), s.end());
+            return self.prepare_request(cmd, data_vec);
+        }, "cmd"_a, "data"_a)
+        .def("prepare_request", [](XcpFraming &self, std::uint32_t cmd, py::args data) {
+            std::vector<uint8_t> data_vec;
+            for (auto item : data) {
+                data_vec.push_back(py::cast<uint8_t>(item));
+            }
+            return self.prepare_request(cmd, data_vec);
+        }, "cmd"_a)
+        .def("unpack_header", &XcpFraming::unpack_header, py::arg("data"), py::arg("initial_offset") = 0)
+        .def("verify_checksum", &XcpFraming::verify_checksum)
+        .def_property("counter_send", &XcpFraming::get_counter_send, &XcpFraming::set_counter_send)
+        .def_property_readonly("header_size", &XcpFraming::get_header_size);
+
+    py::class_<SxiFrLBCN>(m, "SxiFrLBCN")
+        .def(py::init<std::function<void(const std::vector<uint8_t>&, uint16_t, uint16_t)>>(), py::arg("dispatch_handler"))
+        .def("feed_bytes", &SxiFrLBCN::feed_bytes, py::arg("data"))
+    ;
+
+    py::class_<SxiFrLBC8>(m, "SxiFrLBC8")
+        .def(py::init<std::function<void(const std::vector<uint8_t>&, uint16_t, uint16_t)>>(), py::arg("dispatch_handler"))
+        .def("feed_bytes", &SxiFrLBC8::feed_bytes, py::arg("data"))
+    ;
+
+    py::class_<SxiFrLBC16>(m, "SxiFrLBC16")
+        .def(py::init<std::function<void(const std::vector<uint8_t>&, uint16_t, uint16_t)>>(), py::arg("dispatch_handler"))
+        .def("feed_bytes", &SxiFrLBC16::feed_bytes, py::arg("data"))
+    ;
+
+    py::class_<SxiFrLCBCN>(m, "SxiFrLCBCN")
+        .def(py::init<std::function<void(const std::vector<uint8_t>&, uint16_t, uint16_t)>>(), py::arg("dispatch_handler"))
+        .def("feed_bytes", &SxiFrLCBCN::feed_bytes, py::arg("data"))
+    ;
+
+    py::class_<SxiFrLCBC8>(m, "SxiFrLCBC8")
+        .def(py::init<std::function<void(const std::vector<uint8_t>&, uint16_t, uint16_t)>>(), py::arg("dispatch_handler"))
+        .def("feed_bytes", &SxiFrLCBC8::feed_bytes, py::arg("data"))
+    ;
+
+    py::class_<SxiFrLCBC16>(m, "SxiFrLCBC16")
+        .def(py::init<std::function<void(const std::vector<uint8_t>&, uint16_t, uint16_t)>>(), py::arg("dispatch_handler"))
+        .def("feed_bytes", &SxiFrLCBC16::feed_bytes, py::arg("data"))
+    ;
+
+    py::class_<SxiFrLFBCN>(m, "SxiFrLFBCN")
+        .def(py::init<std::function<void(const std::vector<uint8_t>&, uint16_t, uint16_t)>>(), py::arg("dispatch_handler"))
+        .def("feed_bytes", &SxiFrLFBCN::feed_bytes, py::arg("data"))
+    ;
+
+    py::class_<SxiFrLFBC8>(m, "SxiFrLFBC8")
+        .def(py::init<std::function<void(const std::vector<uint8_t>&, uint16_t, uint16_t)>>(), py::arg("dispatch_handler"))
+        .def("feed_bytes", &SxiFrLFBC8::feed_bytes, py::arg("data"))
+    ;
+
+    py::class_<SxiFrLFBC16>(m, "SxiFrLFBC16")
+        .def(py::init<std::function<void(const std::vector<uint8_t>&, uint16_t, uint16_t)>>(), py::arg("dispatch_handler"))
+        .def("feed_bytes", &SxiFrLFBC16::feed_bytes, py::arg("data"))
+    ;
+
+    py::class_<SxiFrLWCN>(m, "SxiFrLWCN")
+        .def(py::init<std::function<void(const std::vector<uint8_t>&, uint16_t, uint16_t)>>(), py::arg("dispatch_handler"))
+        .def("feed_bytes", &SxiFrLWCN::feed_bytes, py::arg("data"))
+    ;
+
+    py::class_<SxiFrLWC8>(m, "SxiFrLWC8")
+        .def(py::init<std::function<void(const std::vector<uint8_t>&, uint16_t, uint16_t)>>(), py::arg("dispatch_handler"))
+        .def("feed_bytes", &SxiFrLWC8::feed_bytes, py::arg("data"))
+    ;
+
+    py::class_<SxiFrLWC16>(m, "SxiFrLWC16")
+        .def(py::init<std::function<void(const std::vector<uint8_t>&, uint16_t, uint16_t)>>(), py::arg("dispatch_handler"))
+        .def("feed_bytes", &SxiFrLWC16::feed_bytes, py::arg("data"))
+    ;
+
+    py::class_<SxiFrLCWCN>(m, "SxiFrLCWCN")
+        .def(py::init<std::function<void(const std::vector<uint8_t>&, uint16_t, uint16_t)>>(), py::arg("dispatch_handler"))
+        .def("feed_bytes", &SxiFrLCWCN::feed_bytes, py::arg("data"))
+    ;
+
+    py::class_<SxiFrLCWC8>(m, "SxiFrLCWC8")
+        .def(py::init<std::function<void(const std::vector<uint8_t>&, uint16_t, uint16_t)>>(), py::arg("dispatch_handler"))
+        .def("feed_bytes", &SxiFrLCWC8::feed_bytes, py::arg("data"))
+    ;
+
+    py::class_<SxiFrLCWC16>(m, "SxiFrLCWC16")
+        .def(py::init<std::function<void(const std::vector<uint8_t>&, uint16_t, uint16_t)>>(), py::arg("dispatch_handler"))
+        .def("feed_bytes", &SxiFrLCWC16::feed_bytes, py::arg("data"))
+    ;
+
+    py::class_<SxiFrLFWCN>(m, "SxiFrLFWCN")
+        .def(py::init<std::function<void(const std::vector<uint8_t>&, uint16_t, uint16_t)>>(), py::arg("dispatch_handler"))
+        .def("feed_bytes", &SxiFrLFWCN::feed_bytes, py::arg("data"))
+    ;
+
+    py::class_<SxiFrLFWC8>(m, "SxiFrLFWC8")
+        .def(py::init<std::function<void(const std::vector<uint8_t>&, uint16_t, uint16_t)>>(), py::arg("dispatch_handler"))
+        .def("feed_bytes", &SxiFrLFWC8::feed_bytes, py::arg("data"))
+    ;
+
+    py::class_<SxiFrLFWC16>(m, "SxiFrLFWC16")
+        .def(py::init<std::function<void(const std::vector<uint8_t>&, uint16_t, uint16_t)>>(), py::arg("dispatch_handler"))
+        .def("feed_bytes", &SxiFrLFWC16::feed_bytes, py::arg("data"))
+    ;
+
+}

pyxcp/transport/usb_transport.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-import struct
+
 import threading
 from array import array
 from collections import deque
@@ -12,7 +12,13 @@ import usb.core
 import usb.util
 from usb.core import USBError, USBTimeoutError
 
-from pyxcp.transport.base import BaseTransport
+from pyxcp.transport.base import (
+    BaseTransport,
+    ChecksumType,
+    XcpFramingConfig,
+    XcpTransportLayerType,
+    parse_header_format,
+)
 from pyxcp.utils import short_sleep
 
 
@@ -23,21 +29,26 @@ FIVE_MS = 5_000_000  # Five milliseconds in nanoseconds.
 class Usb(BaseTransport):
     """"""
 
-    HEADER = struct.Struct("<2H")
-    HEADER_SIZE = HEADER.size
-
     def __init__(self, config=None, policy=None, transport_layer_interface: Optional[usb.core.Device] = None):
-        super().__init__(config, policy, transport_layer_interface)
         self.load_config(config)
+        header_len, header_ctr, header_fill = parse_header_format(self.config.header_format)
+        framing_config = XcpFramingConfig(
+            transport_layer_type=XcpTransportLayerType.USB,
+            header_len=header_len,
+            header_ctr=header_ctr,
+            header_fill=header_fill,
+            tail_fill=False,
+            tail_cs=ChecksumType.NO_CHECKSUM,
+        )
         self.serial_number: str = self.config.serial_number
         self.vendor_id: int = self.config.vendor_id
         self.product_id: int = self.config.product_id
         self.configuration_number: int = self.config.configuration_number
         self.interface_number: int = self.config.interface_number
         self.library: str = self.config.library
-        self.header_format: str = self.config.header_format
         self.library = self.config.get("library")
         self.device = None
+        super().__init__(config, framing_config, policy, transport_layer_interface)
 
         ## IN-EP (RES/ERR, DAQ, and EV/SERV) Parameters.
         self.in_ep_number: int = self.config.in_ep_number
@@ -58,6 +69,7 @@ class Usb(BaseTransport):
             target=self._packet_listen,
             args=(),
             kwargs={},
+            daemon=True,
         )
         self._packets = deque()
 
@@ -109,17 +121,23 @@ class Usb(BaseTransport):
     def start_listener(self):
         super().start_listener()
         if self._packet_listener.is_alive():
-            self._packet_listener.join()
-        self._packet_listener = threading.Thread(target=self._packet_listen)
+            self._packet_listener.join(timeout=2.0)
+        self._packet_listener = threading.Thread(target=self._packet_listen, daemon=True)
         self._packet_listener.start()
 
     def close(self):
         """Close the transport-layer connection and event-loop."""
         self.finish_listener()
-        if self.listener.is_alive():
-            self.listener.join()
-        if self._packet_listener.is_alive():
-            self._packet_listener.join()
+        try:
+            if self.listener.is_alive():
+                self.listener.join(timeout=2.0)
+        except Exception:
+            pass
+        try:
+            if self._packet_listener.is_alive():
+                self._packet_listener.join(timeout=2.0)
+        except Exception:
+            pass
         self.close_connection()
 
     def _packet_listen(self):
@@ -148,9 +166,19 @@ class Usb(BaseTransport):
                 self.status = 0  # disconnected
                 break
 
+    def send(self, frame):
+        self.pre_send_timestamp = self.timestamp.value
+        try:
+            self.out_ep.write(frame)
+        except (USBError, USBTimeoutError):
+            # sometimes usb.core.USBError: [Errno 5] Input/Output Error is raised
+            # even though the command is send and a reply is received from the device.
+            # Ignore this here since a Timeout error will be raised anyway if
+            # the device does not respond
+            pass
+        self.post_send_timestamp = self.timestamp.value
+
     def listen(self):
-        HEADER_UNPACK_FROM = self.HEADER.unpack_from
-        HEADER_SIZE = self.HEADER_SIZE
         popleft = self._packets.popleft
         process_response = self.process_response
         close_event_set = self.closeEvent.is_set
@@ -178,10 +206,10 @@ class Usb(BaseTransport):
                         short_sleep()
                         last_sleep = self.timestamp.value
                     if length is None:
-                        if current_size >= HEADER_SIZE:
-                            length, counter = HEADER_UNPACK_FROM(data, current_position)
-                            current_position += HEADER_SIZE
-                            current_size -= HEADER_SIZE
+                        if current_size >= self.framing.header_size:
+                            length, counter = self.framing.unpack_header(bytes(data), initial_offset=current_position)
+                            current_position += self.framing.header_size
+                            current_size -= self.framing.header_size
                         else:
                             data = data[current_position:]
                             break
@@ -196,18 +224,6 @@ class Usb(BaseTransport):
                             data = data[current_position:]
                             break
 
-    def send(self, frame):
-        self.pre_send_timestamp = self.timestamp.value
-        try:
-            self.out_ep.write(frame)
-        except (USBError, USBTimeoutError):
-            # sometimes usb.core.USBError: [Errno 5] Input/Output Error is raised
-            # even though the command is send and a reply is received from the device.
-            # Ignore this here since a Timeout error will be raised anyway if
-            # the device does not respond
-            pass
-        self.post_send_timestamp = self.timestamp.value
-
     def close_connection(self):
         if self.device is not None:
             usb.util.dispose_resources(self.device)

pyxcp/types.py

@@ -978,19 +978,6 @@ class XcpGetSeedMode(enum.IntEnum):
     REMAINING = 1
 
 
-class FrameCategory(enum.IntEnum):
-    """XCP frame categories."""
-
-    METADATA = 0
-    CMD = 1
-    RESPONSE = 2
-    ERROR = 3
-    EVENT = 4
-    SERV = 5
-    DAQ = 6
-    STIM = 7
-
-
 class TryCommandResult(enum.IntEnum):
     """ """
 

pyxcp/{utils.py → utils/__init__.py}

@@ -6,7 +6,7 @@ import sys
 from binascii import hexlify
 from enum import IntEnum
 from time import perf_counter, sleep
-from typing import Any, List, Optional, Union
+from typing import Union
 
 import chardet
 import pytz
@@ -86,7 +86,6 @@ def delay(amount: float):
 
 
 class CurrentDatetime(TimestampInfo):
-
     def __init__(self, timestamp_ns: int):
         TimestampInfo.__init__(self, timestamp_ns)
         timezone = pytz.timezone(self.timezone)