pyxcp 0.25.4__cp313-cp313-win_amd64.whl

pyxcp/cpp_ext/mcobject.hpp

@@ -0,0 +1,248 @@
+
+#if !defined(__MC_OBJECT_HPP)
+    #define __MC_OBJECT_HPP
+
+    #include <cstdint>
+    #include <map>
+    #include <optional>
+    #include <ranges>
+    #include <string>
+    #include <vector>
+
+    #include "helper.hpp"
+
+const std::map<const std::string, std::tuple<std::uint16_t, std::uint16_t>> TYPE_MAP = {
+    { "U8",   { 0, 1 }  },
+    { "I8",   { 1, 1 }  },
+    { "U16",  { 2, 2 }  },
+    { "I16",  { 3, 2 }  },
+    { "U32",  { 4, 4 }  },
+    { "I32",  { 5, 4 }  },
+    { "U64",  { 6, 8 }  },
+    { "I64",  { 7, 8 }  },
+    { "F32",  { 8, 4 }  },
+    { "F64",  { 9, 8 }  },
+    #if HAS_FLOAT16
+    { "F16",  { 10, 2 } },
+    #endif
+    #if HAS_BFLOAT16
+    { "BF16", { 11, 2 } },
+    #endif
+};
+
+enum class TypeCode : std::uint8_t {
+    U8,
+    I8,
+    U16,
+    I16,
+    U32,
+    I32,
+    U64,
+    I64,
+    F32,
+    F64,
+    F16,
+    BF16,
+};
+
+const std::map<const std::string, TypeCode> TYPE_TO_TYPE_CODE_MAP = {
+    { "U8",   TypeCode::U8   },
+    { "I8",   TypeCode::I8   },
+    { "U16",  TypeCode::U16  },
+    { "I16",  TypeCode::I16  },
+    { "U32",  TypeCode::U32  },
+    { "I32",  TypeCode::I32  },
+    { "U64",  TypeCode::U64  },
+    { "I64",  TypeCode::I64  },
+    { "F32",  TypeCode::F32  },
+    { "F64",  TypeCode::F64  },
+    #if HAS_FLOAT16
+    { "F16",  TypeCode::F16  },
+    #endif
+    #if HAS_BFLOAT16
+    { "BF16", TypeCode::BF16 },
+    #endif
+};
+
+const std::map<std::uint16_t, const std::string> TYPE_MAP_REV = {
+    { 0,  "U8"   },
+    { 1,  "I8"   },
+    { 2,  "U16"  },
+    { 3,  "I16"  },
+    { 4,  "U32"  },
+    { 5,  "I32"  },
+    { 6,  "U64"  },
+    { 7,  "I64"  },
+    { 8,  "F32"  },
+    { 9,  "F64"  },
+    #if HAS_FLOAT16
+    { 10, "F16"  },
+    #endif
+    #if HAS_BFLOAT16
+    { 11, "BF16" },
+    #endif
+};
+
+inline std::vector<std::string> get_data_types() {
+    std::vector<std::string> result;
+
+    for (const auto& [k, v] : TYPE_MAP) {
+        result.emplace_back(k);
+    }
+
+    return result;
+}
+
+class McObject {
+   public:
+
+    explicit McObject(
+        std::string_view name, std::uint32_t address, std::uint8_t ext, std::uint16_t length, const std::string& data_type,
+        const std::vector<McObject>& components = std::vector<McObject>()
+    ) :
+        m_name(name),
+        m_address(address),
+        m_ext(ext),
+        m_length(length),
+        m_data_type(data_type),
+        m_type_index(-1),
+        m_components(components) {
+        if (data_type != "") {
+            std::string dt_toupper;
+
+            dt_toupper.resize(data_type.size());
+
+            std::transform(data_type.begin(), data_type.end(), dt_toupper.begin(), [](unsigned char c) -> unsigned char {
+                return std::toupper(c);
+            });
+
+            if (!TYPE_MAP.contains(dt_toupper)) {
+                throw std::runtime_error("Invalid data type: " + data_type);
+            }
+
+            const auto [ti, len] = TYPE_MAP.at(dt_toupper);
+            m_type_index         = ti;
+            m_length             = len;
+        }
+    }
+
+    McObject(const McObject& obj)        = default;
+    McObject(McObject&& obj)             = default;
+    McObject& operator=(const McObject&) = default;
+    McObject& operator=(McObject&&)      = default;
+
+    const std::string& get_name() const {
+        return m_name;
+    }
+
+    void set_name(std::string_view name) {
+        m_name = name;
+    }
+
+    std::uint32_t get_address() const {
+        return m_address;
+    }
+
+    void set_address(std::uint32_t address) {
+        m_address = address;
+    }
+
+    std::uint8_t get_ext() const {
+        return m_ext;
+    }
+
+    void set_ext(std::uint8_t ext) {
+        m_ext = ext;
+    }
+
+    const std::string& get_data_type() const {
+        return m_data_type;
+    }
+
+    void set_data_type(const std::string& value) {
+        m_data_type = value;
+    }
+
+    std::uint16_t get_length() const {
+        return m_length;
+    }
+
+    void set_length(std::uint16_t length) {
+        m_length = length;
+    }
+
+    std::int32_t get_type_index() const {
+        return m_type_index;
+    }
+
+    const std::vector<McObject>& get_components() const {
+        return m_components;
+    }
+
+    void add_component(const McObject& obj) {
+        m_components.emplace_back(obj);
+    }
+
+    bool operator==(const McObject& other) const {
+        return (m_name == other.m_name) && (m_address == other.m_address) && (m_ext == other.m_ext) &&
+               (m_length == other.m_length) && (m_data_type == other.m_data_type) &&
+               (std::equal(m_components.begin(), m_components.end(), other.m_components.begin(), other.m_components.end()));
+    }
+
+    std::string dumps() const noexcept {
+        std::stringstream ss;
+
+        ss << to_binary(m_name);
+        ss << to_binary(m_address);
+        ss << to_binary(m_ext);
+        ss << to_binary(m_length);
+        ss << to_binary(m_data_type);
+        ss << to_binary(m_type_index);
+
+        std::size_t ccount = m_components.size();
+        ss << to_binary(ccount);
+        for (const auto& obj : m_components) {
+            ss << obj.dumps();
+        }
+        return ss.str();
+    }
+
+    auto get_hash() const noexcept {
+        std::hash<std::string> hash_fn;
+        return hash_fn(dumps());
+    }
+
+   private:
+
+    std::string           m_name;
+    std::uint32_t         m_address;
+    std::uint8_t          m_ext;
+    std::uint16_t         m_length;
+    std::string           m_data_type;
+    std::int16_t          m_type_index;
+    std::vector<McObject> m_components{};
+};
+
+std::string mc_components_to_string(const std::vector<McObject>& components);
+
+std::string to_string(const McObject& obj) {
+    std::stringstream ss;
+
+    ss << "McObject(name='" << obj.get_name() << "', address=" << obj.get_address()
+       << ", ext=" << static_cast<std::uint16_t >(obj.get_ext()) << ", data_type='" << obj.get_data_type()
+       << "', length=" << obj.get_length() << ", components=[" << mc_components_to_string(obj.get_components()) << "])";
+    return ss.str();
+}
+
+std::string mc_components_to_string(const std::vector<McObject>& components) {
+    std::stringstream ss;
+    for (std::size_t i = 0; i < components.size(); ++i) {
+        ss << to_string(components[i]);
+        if (i + 1 < components.size()) {
+            ss << ", ";
+        }
+    }
+    return ss.str();
+}
+
+#endif  // __MC_OBJECT_HPP

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

pyxcp/cpp_ext/tsqueue.hpp

@@ -0,0 +1,46 @@
+
+#ifndef __TSQUEUE_HPP
+#define __TSQUEUE_HPP
+
+#include <condition_variable>
+#include <mutex>
+#include <queue>
+
+template<typename T>
+class TsQueue {
+   public:
+
+    TsQueue() = default;
+
+    TsQueue(const TsQueue& other) noexcept {
+        std::scoped_lock lock(other.m_mtx);
+        m_queue = other.m_queue;
+    }
+
+    void put(T value) noexcept {
+        std::scoped_lock lock(m_mtx);
+        m_queue.push(value);
+        m_cond.notify_one();
+    }
+
+    std::shared_ptr<T> get() noexcept {
+        std::unique_lock lock(m_mtx);
+        m_cond.wait(lock, [this] { return !m_queue.empty(); });
+        std::shared_ptr<T> result(std::make_shared<T>(m_queue.front()));
+        m_queue.pop();
+        return result;
+    }
+
+    bool empty() const noexcept {
+        std::scoped_lock lock(m_mtx);
+        return m_queue.empty();
+    }
+
+   private:
+
+    mutable std::mutex      m_mtx;
+    std::queue<T>           m_queue;
+    std::condition_variable m_cond;
+};
+
+#endif  // __TSQUEUE_HPP