pyxcp 0.25.4__cp313-cp313-win_amd64.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

@@ -0,0 +1,229 @@
+#!/usr/bin/env python
+
+import threading
+from array import array
+from collections import deque
+from typing import Optional
+
+import usb.backend.libusb0 as libusb0
+import usb.backend.libusb1 as libusb1
+import usb.backend.openusb as openusb
+import usb.core
+import usb.util
+from usb.core import USBError, USBTimeoutError
+
+from pyxcp.transport.base import (
+    BaseTransport,
+    ChecksumType,
+    XcpFramingConfig,
+    XcpTransportLayerType,
+    parse_header_format,
+)
+from pyxcp.utils import short_sleep
+
+
+RECV_SIZE = 16384
+FIVE_MS = 5_000_000  # Five milliseconds in nanoseconds.
+
+
+class Usb(BaseTransport):
+    """"""
+
+    def __init__(self, config=None, policy=None, transport_layer_interface: Optional[usb.core.Device] = None):
+        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.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
+        self.in_ep_transfer_type = self.config.in_ep_transfer_type
+        self.in_ep_max_packet_size: int = self.config.in_ep_max_packet_size
+        self.in_ep_polling_interval: int = self.config.in_ep_polling_interval
+        self.in_ep_message_packing = self.config.in_ep_message_packing
+        self.in_ep_alignment = self.config.in_ep_alignment
+        self.in_ep_recommended_host_bufsize: int = self.config.in_ep_recommended_host_bufsize
+
+        ## OUT-EP (CMD and STIM) Parameters.
+        self.out_ep_number: int = self.config.out_ep_number
+
+        self.device: Optional[usb.core.Device] = None
+        self.status = 0
+
+        self._packet_listener = threading.Thread(
+            target=self._packet_listen,
+            args=(),
+            kwargs={},
+            daemon=True,
+        )
+        self._packets = deque()
+
+    def connect(self):
+        if self.library:
+            for backend_provider in (libusb1, libusb0, openusb):
+                backend = backend_provider.get_backend(find_library=lambda x: self.library)
+                if backend:
+                    break
+        else:
+            backend = None
+
+        if self.vendor_id and self.product_id:
+            kwargs = {
+                "find_all": True,
+                "idVendor": self.vendor_id,
+                "idProduct": self.product_id,
+                "backend": backend,
+            }
+        else:
+            kwargs = {
+                "find_all": True,
+                "backend": backend,
+            }
+
+        for device in usb.core.find(**kwargs):
+            try:
+                if device.serial_number.strip().strip("\0").lower() == self.serial_number.lower():
+                    self.device = device
+                    break
+            except (USBError, USBTimeoutError):
+                continue
+        else:
+            raise Exception(f"XCPonUSB - device with serial {self.serial_number!r} not found")
+
+        current_configuration = self.device.get_active_configuration()
+        if current_configuration.bConfigurationValue != self.configuration_number:
+            self.device.set_configuration(self.configuration_number)
+        cfg = self.device.get_active_configuration()
+
+        interface = cfg[(self.interface_number, 0)]
+
+        self.out_ep = interface[self.out_ep_number]
+        self.in_ep = interface[self.in_ep_number]
+
+        self.start_listener()
+        self.status = 1  # connected
+
+    def start_listener(self):
+        super().start_listener()
+        if self._packet_listener.is_alive():
+            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()
+        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):
+        close_event_set = self.closeEvent.is_set
+        _packets = self._packets
+        read = self.in_ep.read
+        buffer = array("B", bytes(RECV_SIZE))
+        buffer_view = memoryview(buffer)
+        while True:
+            try:
+                if close_event_set():
+                    return
+                try:
+                    recv_timestamp = self.timestamp.value
+                    read_count = read(buffer, 100)  # 100ms timeout
+                    if read_count != RECV_SIZE:
+                        _packets.append((buffer_view[:read_count].tobytes(), recv_timestamp))
+                    else:
+                        _packets.append((buffer.tobytes(), recv_timestamp))
+                except (USBError, USBTimeoutError):
+                    # print(format_exc())
+                    short_sleep()
+                    continue
+            except BaseException:  # noqa: B036
+                # Note: catch-all only permitted if the intention is re-raising.
+                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):
+        popleft = self._packets.popleft
+        process_response = self.process_response
+        close_event_set = self.closeEvent.is_set
+        _packets = self._packets
+        length: Optional[int] = None
+        counter: int = 0
+        data: bytearray = bytearray(b"")
+        last_sleep: int = self.timestamp.value
+
+        while True:
+            if close_event_set():
+                return
+            count: int = len(_packets)
+            if not count:
+                short_sleep()
+                last_sleep = self.timestamp.value
+                continue
+            for _ in range(count):
+                bts, timestamp = popleft()
+                data += bts
+                current_size: int = len(data)
+                current_position: int = 0
+                while True:
+                    if self.timestamp.value - last_sleep >= FIVE_MS:
+                        short_sleep()
+                        last_sleep = self.timestamp.value
+                    if length is None:
+                        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
+                    else:
+                        if current_size >= length:
+                            response = data[current_position : current_position + length]
+                            process_response(response, length, counter, timestamp)
+                            current_size -= length
+                            current_position += length
+                            length = None
+                        else:
+                            data = data[current_position:]
+                            break
+
+    def close_connection(self):
+        if self.device is not None:
+            usb.util.dispose_resources(self.device)