pyxcp 0.23.3__cp312-cp312-win_arm64.whl → 0.25.6__cp312-cp312-win_arm64.whl

pyxcp/cpp_ext/framing.hpp

@@ -0,0 +1,360 @@
+
+#if !defined(__FRAMING_HPP)
+#define __FRAMING_HPP
+
+#include <cstdint>
+
+#include <atomic>
+#include <bit>
+#include <optional>
+#include <iostream>
+#include <map>
+#include <mutex>
+#include <optional>
+#include <set>
+#include <thread>
+#include <tuple>
+#include <variant>
+#include <vector>
+#include <cstring>
+
+namespace py = pybind11;
+
+using FrameType = py::bytes;
+using CommandType = std::variant<std::monostate, std::uint8_t, std::uint16_t, std::uint32_t>;
+
+std::uint8_t find_msb(std::uint32_t val) {
+	std::uint8_t position = 0;
+
+	if (val == 0) {
+		return 1;
+	}
+	while ((val >>= 1)) {
+		++position;
+	}
+
+	return position + 1;
+}
+
+std::uint8_t byte_count(std::uint32_t val) {
+	std::uint8_t count = 1;
+
+	auto high_bit = find_msb(val);
+	if (high_bit > 24) {
+		count = 4;
+	} else if (high_bit > 16) {
+		count = 3;
+	} else if (high_bit > 8) {
+		count = 2;
+	}
+
+	return count;
+}
+
+std::vector<std::uint8_t> serialize_cmd_value(std::uint32_t value) {
+	std::vector<std::uint8_t> result;
+
+	auto bc = byte_count(value);
+	result.reserve(bc);
+
+	switch (bc) {
+		case 4:
+			result.push_back(static_cast<std::uint8_t>(static_cast<std::uint32_t>(((value & 0xff000000UL)) >> 24)));
+			[[fallthrough]];
+		case 3:
+			result.push_back(static_cast<std::uint8_t>(static_cast<std::uint32_t>(((value & 0xff0000UL)) >> 16)));
+			[[fallthrough]];
+		case 2:
+			result.push_back(static_cast<std::uint8_t>(static_cast<std::uint16_t>(((value & 0xff00UL)) >> 8)));
+			[[fallthrough]];
+		case 1:
+			result.push_back(static_cast<std::uint8_t>(value & 0xffUL));
+			break;
+	}
+
+	return result;
+}
+
+std::vector<std::uint8_t> serialize_word_le(std::uint16_t value) {
+	std::vector<std::uint8_t> result;
+	result.reserve(2);
+
+	result.push_back(static_cast<std::uint8_t>(value & 0xffUL));
+	result.push_back(static_cast<std::uint8_t>(static_cast<std::uint16_t>(((value & 0xff00UL)) >> 8)));
+	result.resize(2);
+	return result;
+}
+
+std::string_view bytes_as_string_view(const py::bytes& data) {
+    // Zero-copy view into Python bytes; lifetime is tied to 'data' which
+    // outlives this function call.
+    char* buf = nullptr;
+    Py_ssize_t len = 0;
+    // PyBytes_AsStringAndSize returns 0 on success.
+    if (PyBytes_AsStringAndSize(data.ptr(), &buf, &len) != 0 || buf == nullptr || len < 0) {
+        // Fallback: empty view on error (should be rare)
+        return std::string_view{};
+    }
+    return std::string_view(buf, static_cast<std::size_t>(len));
+}
+
+enum class ChecksumType : std::uint8_t {
+    NO_CHECKSUM = 0,
+    BYTE_CHECKSUM = 1,
+    WORD_CHECKSUM = 2
+};
+
+enum class XcpTransportLayerType : std::uint8_t {
+    CAN,
+    ETH,
+    SXI,
+    USB
+};
+
+struct XcpFramingConfig {
+    XcpTransportLayerType transport_layer_type;
+    std::uint8_t header_len;
+    std::uint8_t header_ctr;
+    std::uint8_t header_fill;
+
+    bool tail_fill;
+    ChecksumType tail_cs;
+
+};
+
+class XcpFraming {
+public:
+
+    XcpFraming(const XcpFramingConfig& framing_type) : m_counter_send(0),
+        m_framing_type(framing_type) {
+
+        m_send_buffer = new std::uint8_t[0xff + 8];
+		reset_send_buffer_pointer();
+    }
+
+    XcpFraming() = delete;
+    XcpFraming(const XcpFraming&) = delete;
+    XcpFraming(XcpFraming&&) = delete;
+
+	FrameType prepare_request(std::uint32_t cmd, py::args data) {
+
+		std::vector<std::uint8_t> command_bytes{};
+		std::uint8_t frame_header_size{0};
+		std::uint8_t frame_tail_size{0};
+
+		reset_send_buffer_pointer();
+
+		command_bytes = serialize_cmd_value(cmd);
+
+		auto xcp_packet_size = data.size() + command_bytes.size();
+
+		if (m_framing_type.header_len > 0) {
+			frame_header_size += m_framing_type.header_len;
+			if (m_framing_type.header_len == 1) {
+				set_send_buffer(static_cast<std::uint8_t>(xcp_packet_size & 0xff));
+			} else {
+				auto packet_size_bytes = serialize_word_le(xcp_packet_size);
+				set_send_buffer(packet_size_bytes);
+			}
+		}
+		if (m_framing_type.header_ctr > 0) {
+			frame_header_size += m_framing_type.header_ctr;
+			if (m_framing_type.header_ctr == 1) {
+				set_send_buffer(static_cast<std::uint8_t>(m_counter_send & 0xff));
+			} else {
+				auto counter_bytes = serialize_word_le(m_counter_send);
+				set_send_buffer(counter_bytes);
+			}
+		}
+		if (m_framing_type.header_fill > 0) {
+			fill_send_buffer(m_framing_type.header_fill);
+			frame_header_size += m_framing_type.header_fill;
+		}
+
+		set_send_buffer(command_bytes);
+		set_send_buffer(data);
+
+		if (m_framing_type.transport_layer_type == XcpTransportLayerType::SXI) {
+			if (m_framing_type.tail_fill == true) {
+				// Align to a word boundary if word checksum is used
+				if (m_framing_type.tail_cs == ChecksumType::WORD_CHECKSUM && (current_send_buffer_pointer() % 2 != 0)) {
+					fill_send_buffer(1);
+				}
+			}
+
+			if (m_framing_type.tail_cs != ChecksumType::NO_CHECKSUM) {
+				if (m_framing_type.tail_cs == ChecksumType::BYTE_CHECKSUM) {
+					auto cs = checksum_byte(0, current_send_buffer_pointer());
+					set_send_buffer(cs);
+					frame_tail_size += 1;
+				}
+				else if (m_framing_type.tail_cs == ChecksumType::WORD_CHECKSUM) {
+					// Align to a word boundary before calculating word checksum
+					if (current_send_buffer_pointer() % 2 != 0) {
+						fill_send_buffer(1);
+					}
+					auto cs = checksum_word(0, current_send_buffer_pointer());
+					auto cs_bytes = serialize_word_le(cs);
+					set_send_buffer(cs_bytes);
+					frame_tail_size += 2;
+				}
+			}
+		}
+
+		m_counter_send++;
+		py::bytes result(reinterpret_cast<const char*>(m_send_buffer), current_send_buffer_pointer());
+		return result;
+	}
+
+	    FrameType prepare_request(std::uint32_t cmd, const std::vector<std::uint8_t>& data_vec) {
+        py::tuple data_tuple(data_vec.size());
+        for (size_t i = 0; i < data_vec.size(); ++i) {
+            data_tuple[i] = py::int_(data_vec[i]);
+        }
+        return prepare_request(cmd, data_tuple);
+    }
+
+    std::optional<std::tuple<std::uint16_t, std::uint16_t>> unpack_header(const py::bytes& data, std::uint16_t initial_offset=0) const noexcept {
+        auto data_view = bytes_as_string_view(data);
+        if (std::size(data_view) >= (get_header_size() + initial_offset)) {
+            auto offset = initial_offset;
+            std::uint16_t length = 0U;
+            std::uint16_t counter = 0U;
+
+            // Read length field starting at current offset (if present)
+            if (m_framing_type.header_len > 0) {
+                if (m_framing_type.header_len == 1) {
+                    length = static_cast<std::uint16_t>(static_cast<std::uint8_t>(data_view[offset]));
+                } else {
+                    auto b0 = static_cast<std::uint8_t>(data_view[offset]);
+                    auto b1 = static_cast<std::uint8_t>(data_view[offset + 1]);
+                    length = static_cast<std::uint16_t>(static_cast<std::uint16_t>(b0) | (static_cast<std::uint16_t>(b1) << 8));
+                }
+                offset += m_framing_type.header_len;
+            }
+            // Read counter field starting after length (if present)
+            if (m_framing_type.header_ctr > 0) {
+                if (m_framing_type.header_ctr == 1) {
+                    counter = static_cast<std::uint16_t>(static_cast<std::uint8_t>(data_view[offset]));
+                } else {
+                    auto c0 = static_cast<std::uint8_t>(data_view[offset]);
+                    auto c1 = static_cast<std::uint8_t>(data_view[offset + 1]);
+                    counter = static_cast<std::uint16_t>(static_cast<std::uint16_t>(c0) | (static_cast<std::uint16_t>(c1) << 8));
+                }
+            }
+            return std::make_tuple(length, counter);
+        }
+        return std::nullopt;
+    }
+
+    bool verify_checksum(const py::bytes& data) const noexcept {
+        if (m_framing_type.transport_layer_type != XcpTransportLayerType::SXI || m_framing_type.tail_cs == ChecksumType::NO_CHECKSUM) {
+            return true; // No checksum verification needed
+        }
+
+        auto data_view = bytes_as_string_view(data);
+        auto data_size = std::size(data_view);
+
+        if (m_framing_type.tail_cs == ChecksumType::BYTE_CHECKSUM) {
+            if (data_size < 1) return false;
+            std::uint8_t received_cs = static_cast<std::uint8_t>(data_view[data_size - 1]);
+            std::uint8_t calculated_cs = 0;
+            for (size_t i = 0; i < data_size - 1; ++i) {
+                calculated_cs += static_cast<std::uint8_t>(data_view[i]);
+            }
+            return received_cs == calculated_cs;
+        }
+        else if (m_framing_type.tail_cs == ChecksumType::WORD_CHECKSUM) {
+            if (data_size < 2 || data_size % 2 != 0) return false; // Must have even length for word checksum
+
+            std::uint16_t received_cs = static_cast<std::uint16_t>(
+                static_cast<std::uint8_t>(data_view[data_size - 2]) |
+                (static_cast<std::uint16_t>(static_cast<std::uint8_t>(data_view[data_size - 1])) << 8)
+            );
+
+            std::uint16_t calculated_cs = 0;
+            for (size_t i = 0; i < data_size - 2; i += 2) {
+                calculated_cs += static_cast<std::uint16_t>(
+                    static_cast<std::uint8_t>(data_view[i]) |
+                    (static_cast<std::uint16_t>(static_cast<std::uint8_t>(data_view[i + 1])) << 8)
+                );
+            }
+            return received_cs == calculated_cs;
+        }
+
+        return true; // Should not be reached if NO_CHECKSUM is handled
+    }
+
+    std::uint16_t get_header_size() const noexcept {
+        return m_framing_type.header_len + m_framing_type.header_ctr + m_framing_type.header_fill;
+    }
+
+    std::uint16_t get_counter_send() const noexcept {
+    	return m_counter_send;
+    }
+
+	void set_counter_send(std::uint16_t counter) noexcept {
+    	m_counter_send = counter;
+    }
+
+
+private:
+	void set_send_buffer(std::uint8_t value) noexcept {
+	    m_send_buffer[m_send_buffer_offset] = value;
+   	   m_send_buffer_offset++;
+	}
+
+	void set_send_buffer(const std::vector<std::uint8_t>& values) noexcept {
+		if (!values.empty()) {
+			std::memcpy(m_send_buffer + m_send_buffer_offset, values.data(), values.size());
+			m_send_buffer_offset += static_cast<std::uint16_t>(values.size());
+		}
+	}
+
+	void set_send_buffer(const py::args& values) noexcept {
+		for (auto idx=0; idx < values.size(); ++idx) {
+			m_send_buffer[m_send_buffer_offset] = values[idx].cast<std::uint8_t>();
+			m_send_buffer_offset++;
+		}
+	}
+
+	void fill_send_buffer(uint16_t n) noexcept {
+		for (auto idx=0; idx < n; ++idx) {
+			m_send_buffer[m_send_buffer_offset] = 0;
+			m_send_buffer_offset++;
+		}
+	}
+
+	void reset_send_buffer_pointer() noexcept {
+		m_send_buffer_offset = 0UL;
+	}
+
+	std::uint16_t current_send_buffer_pointer() const noexcept {
+		return m_send_buffer_offset;
+	}
+
+	std::uint8_t checksum_byte(std::uint16_t begin, std::uint16_t end) const noexcept {
+		uint8_t cs = 0;
+		for (auto idx = begin; idx < end; ++idx) {
+			cs += m_send_buffer[idx];
+		}
+		return cs;
+	}
+
+	std::uint16_t checksum_word(std::uint16_t begin, std::uint16_t end) const noexcept {
+		std::uint16_t cs = 0UL;
+
+		for (auto idx = begin; idx < end; idx+=2) {
+			cs += static_cast<std::uint16_t>(m_send_buffer[idx] | (m_send_buffer[idx + 1] << 8));
+		}
+		return cs;
+	}
+
+private:
+    std::uint16_t m_counter_send;
+    XcpFramingConfig m_framing_type;
+    std::uint8_t * m_send_buffer = nullptr;
+    std::uint16_t m_send_buffer_offset = 0UL;
+};
+
+#endif // __FRAMING_HPP

pyxcp/cpp_ext/mcobject.hpp

@@ -236,9 +236,11 @@ std::string to_string(const McObject& obj) {
 
 std::string mc_components_to_string(const std::vector<McObject>& components) {
     std::stringstream ss;
-
-    for (const auto& obj : components) {
-        ss << to_string(obj) << ",\n ";
+    for (std::size_t i = 0; i < components.size(); ++i) {
+        ss << to_string(components[i]);
+        if (i + 1 < components.size()) {
+            ss << ", ";
+        }
     }
     return ss.str();
 }

pyxcp/cpp_ext/sxi_framing.hpp

@@ -0,0 +1,332 @@
+#if !defined (__SXI_FRAMING_HPP)
+#define __SXI_FRAMING_HPP
+
+#include <array>
+#include <bit>
+#include <chrono>
+#include <condition_variable>
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <thread>
+#include <vector>
+#include <iomanip>
+#include <iostream>
+
+// Header format options
+enum class SxiHeaderFormat {
+    LenByte,
+    LenCtrByte,
+    LenFillByte,
+    LenWord,
+    LenCtrWord,
+    LenFillWord,
+};
+
+// Checksum type options
+enum class SxiChecksumType {
+    None,
+    Sum8,
+    Sum16
+};
+
+namespace detail {
+inline uint16_t make_word_le(const uint8_t* p) {
+    return p[0] | p[1] << 8;
+}
+
+inline void put_word_le(uint8_t* p, uint16_t v) {
+    if constexpr (std::endian::native == std::endian::big) {
+        p[0] = static_cast<uint8_t>(v & 0xFF);
+        p[1] = static_cast<uint8_t>((v >> 8) & 0xFF);
+    } else {
+        std::memcpy(p, &v, sizeof(v));
+    }
+}
+}  // namespace detail
+
+class RestartableTimer {
+   public:
+
+    /**
+     * @brief Constructs the timer.
+     * @param timeout The duration after which the timer expires.
+     * @param on_timeout The function to call upon timeout.
+     */
+    RestartableTimer(std::chrono::milliseconds timeout, std::function<void()> on_timeout) :
+        m_timeout(timeout), m_on_timeout(std::move(on_timeout)), m_running(false) {
+    }
+
+    ~RestartableTimer() {
+        stop();
+        if (m_thread.joinable()) {
+            m_thread.join();
+        }
+    }
+
+    // Disable copy and move semantics
+    RestartableTimer(const RestartableTimer&)            = delete;
+    RestartableTimer& operator=(const RestartableTimer&) = delete;
+    RestartableTimer(RestartableTimer&&)                 = delete;
+    RestartableTimer& operator=(RestartableTimer&&)      = delete;
+
+    /**
+     * @brief Starts the timer. If already running, it resets the countdown.
+     */
+    void start() {
+        if (m_timeout == std::chrono::milliseconds(0)) {
+            return;
+        }
+        std::unique_lock<std::mutex> lock(m_mutex);
+        if (!m_running) {
+            m_running = true;
+            if (m_thread.joinable()) {
+                m_thread.join();  // Ensure previous thread is finished
+            }
+            m_thread = std::thread(&RestartableTimer::run, this);
+        } else {
+            // Already running, just signal a reset
+            m_cv.notify_one();
+        }
+    }
+
+    /**
+     * @brief Stops the timer.
+     */
+    void stop() {
+        if (m_timeout == std::chrono::milliseconds(0)) {
+            return;
+        }
+        std::unique_lock<std::mutex> lock(m_mutex);
+        if (!m_running) {
+            return;
+        }
+        m_running = false;
+        m_cv.notify_one();
+    }
+
+    /**
+     * @brief Resets the timer's countdown.
+     */
+    void reset_timeout() {
+        if (m_timeout == std::chrono::milliseconds(0)) {
+            return;
+        }
+        std::unique_lock<std::mutex> lock(m_mutex);
+        if (m_running) {
+            m_cv.notify_one();
+        }
+    }
+
+   private:
+
+    void run() {
+        std::unique_lock<std::mutex> lock(m_mutex);
+        while (m_running) {
+            // wait_for returns cv_status::timeout if the time expires without a notification
+            if (m_cv.wait_for(lock, m_timeout) == std::cv_status::timeout) {
+                // Timeout occurred. Check m_running again in case stop() was called
+                // while we were waiting for the lock.
+                if (m_running) {
+                    m_on_timeout();
+                    m_running = false;  // Stop the timer thread after firing
+                }
+            }
+        }
+    }
+
+    std::thread               m_thread;
+    std::mutex                m_mutex;
+    std::condition_variable   m_cv;
+    std::chrono::milliseconds m_timeout;
+    std::function<void()>     m_on_timeout;
+    std::atomic<bool>         m_running;
+};
+
+
+template<SxiHeaderFormat Format, SxiChecksumType Checksum>
+class SxiReceiver {
+   public:
+
+    explicit SxiReceiver(
+        std::function<void(const std::vector<uint8_t>&, uint16_t, uint16_t)> dispatch_handler,
+        std::chrono::milliseconds /*timeout*/ = std::chrono::milliseconds(0)
+    ) :
+        dispatch_(std::move(dispatch_handler)) {
+        reset();
+    }
+
+    void feed_bytes(const std::string& data) {
+        for (const auto& c : data) {
+            //feed(static_cast<uint8_t>(c));
+            feed(c);
+        }
+    }
+
+    void feed(uint8_t octet) {
+        if (index_ >= buffer_.size()) {
+            reset();
+            return;
+        }
+        buffer_[index_] = octet;
+        if (state_ == State::Idle) {
+            state_ = State::UntilLength;
+            fill_ = 0;
+        }
+        if (state_ == State::UntilLength) {
+            bool header_complete = false;
+            if constexpr (Format == SxiHeaderFormat::LenByte) {
+                if (index_ == 0) {
+                    dlc_            = buffer_[0];
+                    remaining_      = dlc_;
+                    header_complete = true;
+                }
+            } else if constexpr (Format == SxiHeaderFormat::LenCtrByte || Format == SxiHeaderFormat::LenFillByte) {
+                if (index_ == 1) {
+                    dlc_            = buffer_[0];
+                    if constexpr (Format == SxiHeaderFormat::LenCtrByte) {
+                        ctr_ = buffer_[1];
+                    }
+                    remaining_      = dlc_;
+                    header_complete = true;
+                }
+            } else if constexpr (Format == SxiHeaderFormat::LenWord) {
+                if (index_ == 1) {
+                    dlc_            = detail::make_word_le(&buffer_[0]);
+                    remaining_      = dlc_;
+                    header_complete = true;
+                }
+            } else if constexpr (Format == SxiHeaderFormat::LenCtrWord || Format == SxiHeaderFormat::LenFillWord) {
+                if (index_ == 3) {
+                    dlc_            = detail::make_word_le(&buffer_[0]);
+                    if constexpr (Format == SxiHeaderFormat::LenCtrWord) {
+                        ctr_ = detail::make_word_le(&buffer_[2]);
+                    }
+                    remaining_      = dlc_;
+                    header_complete = true;
+                }
+            }
+            if (header_complete) {
+                if constexpr (Checksum == SxiChecksumType::Sum8) {
+                    remaining_ += 1;
+                } else if constexpr (Checksum == SxiChecksumType::Sum16) {
+                    uint16_t header_size = 0;
+                    if constexpr (Format == SxiHeaderFormat::LenByte) header_size = 1;
+                    else if constexpr (Format == SxiHeaderFormat::LenCtrByte || Format == SxiHeaderFormat::LenFillByte) header_size = 2;
+                    else if constexpr (Format == SxiHeaderFormat::LenWord) header_size = 2;
+                    else if constexpr (Format == SxiHeaderFormat::LenCtrWord || Format == SxiHeaderFormat::LenFillWord) header_size = 4;
+
+                    fill_ = ((header_size + dlc_) % 2 != 0) ? 1u : 0u;
+                    remaining_ += (2 + fill_);
+                }
+                state_ = State::Remaining;
+                if (remaining_ != 0) {
+                    index_++;
+                    return;
+                }
+            }
+        }
+        if (state_ == State::Remaining) {
+            if (remaining_ > 0) {
+                remaining_--;
+            }
+            if (remaining_ == 0) {
+                uint16_t payload_off = 0;
+                if constexpr (Format == SxiHeaderFormat::LenByte) {
+                    payload_off = 1;
+                } else if constexpr (Format == SxiHeaderFormat::LenCtrByte || Format == SxiHeaderFormat::LenFillByte) {
+                    payload_off = 2;
+                } else if constexpr (Format == SxiHeaderFormat::LenWord) {
+                    payload_off = 2;
+                } else if constexpr (Format == SxiHeaderFormat::LenCtrWord || Format == SxiHeaderFormat::LenFillWord) {
+                    payload_off = 4;
+                }
+
+                // verify checksum
+                if constexpr (Checksum == SxiChecksumType::Sum8) {
+                    uint8_t sum = 0;
+                    for (uint16_t i = 0; i < (payload_off + dlc_ + fill_); ++i) {
+                        sum += buffer_[i];
+                    }
+                    uint8_t rx = buffer_[payload_off + dlc_];
+                    if (sum != rx) {
+                        log_checksum_error(sum, rx, payload_off + dlc_ + 1);
+                        reset();
+                        return;
+                    }
+                } else if constexpr (Checksum == SxiChecksumType::Sum16) {
+                    uint16_t           count = (payload_off + dlc_ + fill_);
+                    uint16_t sum      = 0;
+
+                    for (uint16_t idx = 0; idx < count; idx += 2) {
+                        sum = static_cast<uint16_t>(sum + detail::make_word_le(&buffer_[idx]));
+                    }
+                    uint16_t rx = detail::make_word_le(&buffer_[payload_off + dlc_ + fill_]);
+                    if (sum != rx) {
+                        log_checksum_error(sum, rx, payload_off + dlc_ + fill_ + 2);
+                        reset();
+                        return;
+                    }
+                }
+                if (dispatch_) {
+                    dispatch_({ buffer_.data() + payload_off, buffer_.data() + payload_off + dlc_ }, dlc_, ctr_);
+                    #if defined(XCP_TL_TEST_HOOKS)
+                    std::fill(buffer_.begin(), buffer_.end(), 0xcc);
+                    #endif
+                }
+                reset();
+                return;
+            }
+        }
+        index_++;
+    }
+
+   private:
+
+    enum class State {
+        Idle,
+        UntilLength,
+        Remaining
+    };
+
+    template<typename T>
+    void log_checksum_error(T calculated, T received, uint16_t packet_len) {
+        std::cerr << "SXI checksum error: Calculated " << std::hex << "0x" << static_cast<int>(calculated)
+                  << ", but received " << "0x" << static_cast<int>(received) << "." << std::dec << std::endl;
+        std::cerr << "Packet dump (" << packet_len << " bytes):" << std::endl;
+        std::cerr << "[";
+        std::ios_base::fmtflags flags(std::cerr.flags()); // save flags
+        for (uint16_t i = 0; i < packet_len; ++i) {
+            std::cerr << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>(buffer_[i]) << " ";
+            if ((i + 1) % 16 == 0) {
+                std::cerr << std::endl;
+            }
+        }
+        std::cerr << "]" << std::endl;
+        std::cerr.flags(flags); // restore flags
+    }
+
+    void reset() {
+        state_     = State::Idle;
+        index_     = 0;
+        dlc_       = 0;
+        remaining_ = 0;
+        ctr_       = 0;
+        fill_       = 0;
+        #if defined(XCP_TL_TEST_HOOKS)
+        std::fill(buffer_.begin(), buffer_.end(), 0xcc);
+        #endif
+    }
+
+    std::array<uint8_t, 1024>                        buffer_{};
+    State                                            state_{ State::Idle };
+    uint32_t                                         index_{ 0 };
+    uint16_t                                         dlc_{ 0 };
+    uint16_t                                         ctr_{ 0 };
+    uint32_t                                         remaining_{ 0 };
+    uint16_t                                         fill_ {0};
+    std::function<void(const std::vector<uint8_t>&, uint16_t, uint16_t)> dispatch_;
+};
+
+#endif // __SXI_FRAMING_HPP