pyxcp 0.23.0__cp313-cp313-win_arm64.whl

pyxcp/cpp_ext/extension_wrapper.cpp

@@ -0,0 +1,100 @@
+
+#include <pybind11/chrono.h>
+#include <pybind11/functional.h>
+#include <pybind11/numpy.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include <cstdint>
+
+#include "bin.hpp"
+#include "daqlist.hpp"
+#include "mcobject.hpp"
+
+namespace py = pybind11;
+using namespace pybind11::literals;
+
+class PyTimestampInfo : public TimestampInfo {
+   public:
+
+    using TimestampInfo::TimestampInfo;
+};
+
+PYBIND11_MODULE(cpp_ext, m) {
+    m.doc() = "C++ extensions for pyXCP.";
+
+    //m.def("sleep_ms", &sleep_ms, "milliseconds"_a);
+    //m.def("sleep_ns", &sleep_ns, "nanoseconds"_a);
+
+    py::class_<McObject>(m, "McObject")
+        .def(
+            py::init<
+                std::string_view, std::uint32_t, std::uint8_t, std::uint16_t, const std::string&, const std::vector<McObject>&>(),
+            "name"_a, "address"_a, "ext"_a, "length"_a, "data_type"_a = "", "components"_a = std::vector<McObject>()
+        )
+        .def_property("name", &McObject::get_name, &McObject::set_name)
+        .def_property("address", &McObject::get_address, &McObject::set_address)
+        .def_property("ext", &McObject::get_ext, &McObject::set_ext)
+        .def_property("length", &McObject::get_length, &McObject::set_length)
+        .def_property("data_type", &McObject::get_data_type, &McObject::set_data_type)
+        .def_property_readonly("components", &McObject::get_components)
+
+        .def("add_component", &McObject::add_component, "component"_a)
+        .def("__eq__", [](const McObject& self, const McObject& other) { return self == other; })
+        .def("__repr__", [](const McObject& self) { return to_string(self); })
+        .def("__hash__", [](const McObject& self) { return self.get_hash(); })
+        ;
+
+    py::class_<Bin>(m, "Bin")
+        .def(py::init<std::uint16_t>(), "size"_a)
+        .def_property("size", &Bin::get_size, &Bin::set_size)
+        .def_property("residual_capacity", &Bin::get_residual_capacity, &Bin::set_residual_capacity)
+        .def_property("entries", &Bin::get_entries, nullptr)
+        .def("append", &Bin::append)
+
+        .def("__repr__", [](const Bin& self) { return to_string(self); })
+
+        .def("__eq__", [](const Bin& self, const Bin& other) { return self == other; })
+
+        .def("__len__", [](const Bin& self) { return std::size(self.get_entries()); });
+
+    py::class_<DaqList>(m, "DaqList")
+        .def(
+            py::init<std::string_view, std::uint16_t, bool, bool, const std::vector<DaqList::daq_list_initialzer_t>&,
+            std::uint8_t, std::uint8_t>(), "name"_a, "event_num"_a, "stim"_a, "enable_timestamps"_a, "measurements"_a,
+            "priority"_a=0, "prescaler"_a=1
+        )
+        .def("__repr__", [](const DaqList& self) { return self.to_string(); })
+        .def_property("name", &DaqList::get_name, nullptr)
+        .def_property("event_num", &DaqList::get_event_num, &DaqList::set_event_num)
+        .def_property("priority", &DaqList::get_priority, nullptr)
+        .def_property("prescaler", &DaqList::get_prescaler, nullptr)
+        .def_property("stim", &DaqList::get_stim, nullptr)
+        .def_property("enable_timestamps", &DaqList::get_enable_timestamps, nullptr)
+        .def_property("measurements", &DaqList::get_measurements, nullptr)
+        .def_property("measurements_opt", &DaqList::get_measurements_opt, &DaqList::set_measurements_opt)
+        .def_property("headers", &DaqList::get_headers, nullptr)
+        .def_property("odt_count", &DaqList::get_odt_count, nullptr)
+        .def_property("total_entries", &DaqList::get_total_entries, nullptr)
+        .def_property("total_length", &DaqList::get_total_length, nullptr);
+
+    py::enum_<TimestampType>(m, "TimestampType")
+        .value("ABSOLUTE_TS", TimestampType::ABSOLUTE_TS)
+        .value("RELATIVE_TS", TimestampType::RELATIVE_TS);
+
+    py::class_<Timestamp>(m, "Timestamp")
+        .def(py::init<TimestampType>(), "ts_type"_a)
+        .def_property_readonly("absolute", &Timestamp::absolute)
+        .def_property_readonly("relative", &Timestamp::relative)
+        .def_property_readonly("value", &Timestamp::get_value)
+        .def_property_readonly("initial_value", &Timestamp::get_initial_value);
+
+    py::class_<TimestampInfo, PyTimestampInfo>(m, "TimestampInfo", py::dynamic_attr())
+        .def(py::init<std::uint64_t>())
+        .def(py::init<std::uint64_t, const std::string&, std::int16_t, std::int16_t>())
+
+        .def_property_readonly("timestamp_ns", &TimestampInfo::get_timestamp_ns)
+        .def_property("utc_offset", &TimestampInfo::get_utc_offset, &TimestampInfo::set_utc_offset)
+        .def_property("dst_offset", &TimestampInfo::get_dst_offset, &TimestampInfo::set_dst_offset)
+        .def_property("timezone", &TimestampInfo::get_timezone, &TimestampInfo::set_timezone);
+}

pyxcp/cpp_ext/helper.hpp

@@ -0,0 +1,280 @@
+
+#if !defined(__HELPER_HPP)
+    #define __HELPER_HPP
+
+    #if defined(_WIN32) || defined(_WIN64)
+
+    #else
+        #include <sys/time.h>
+        #include <time.h>
+    #endif
+
+    #include <bit>
+    #include <chrono>
+    #include <iostream>
+    #include <map>
+    #include <utility>
+    #include <variant>
+
+    #if __has_include(<version>)
+        #include <version>  // Needed for feature testing.
+    #endif
+
+    #ifdef __has_include
+        #if __has_include(<stdfloat>)
+            #include <stdfloat>
+        #endif
+        #if defined(__STDCPP_BFLOAT16_T__)
+            #define HAS_BFLOAT16 (1)
+        #else
+            #define HAS_BFLOAT16 (0)
+        #endif
+
+        #if defined(__STDCPP_FLOAT16_T__)
+            #define HAS_FLOAT16 (1)
+        #else
+            #define HAS_FLOAT16 (0)
+        #endif
+    #else
+        #define HAS_FLOAT16  (0)
+        #define HAS_BFLOAT16 (0)
+    #endif
+
+constexpr std::endian target_byteorder() {
+    return std::endian::native;
+}
+
+template<typename... Args>
+constexpr void DBG_PRINTN(Args &&...args) noexcept {
+    ((std::cout << std::forward<Args>(args) << " "), ...);
+}
+
+// NOTE: C++23 has std::byteswap()
+constexpr auto _bswap(std::uint64_t v) noexcept {
+    return ((v & UINT64_C(0x0000'0000'0000'00FF)) << 56) | ((v & UINT64_C(0x0000'0000'0000'FF00)) << 40) |
+           ((v & UINT64_C(0x0000'0000'00FF'0000)) << 24) | ((v & UINT64_C(0x0000'0000'FF00'0000)) << 8) |
+           ((v & UINT64_C(0x0000'00FF'0000'0000)) >> 8) | ((v & UINT64_C(0x0000'FF00'0000'0000)) >> 24) |
+           ((v & UINT64_C(0x00FF'0000'0000'0000)) >> 40) | ((v & UINT64_C(0xFF00'0000'0000'0000)) >> 56);
+}
+
+constexpr auto _bswap(std::uint32_t v) noexcept {
+    return ((v & UINT32_C(0x0000'00FF)) << 24) | ((v & UINT32_C(0x0000'FF00)) << 8) | ((v & UINT32_C(0x00FF'0000)) >> 8) |
+           ((v & UINT32_C(0xFF00'0000)) >> 24);
+}
+
+constexpr auto _bswap(std::uint16_t v) noexcept {
+    return ((v & UINT16_C(0x00FF)) << 8) | ((v & UINT16_C(0xFF00)) >> 8);
+}
+
+template<typename T>
+inline std::string to_binary(const T &value) {
+    std::string result;
+
+    auto ptr = reinterpret_cast<const std::string::value_type *>(&value);
+    for (std::size_t idx = 0; idx < sizeof(T); ++idx) {
+        auto ch = ptr[idx];
+        result.push_back(ch);
+    }
+    return result;
+}
+
+template<>
+inline std::string to_binary<std::string>(const std::string &value) {
+    std::string result;
+
+    auto              ptr    = reinterpret_cast<const std::string::value_type *>(value.c_str());
+    const std::size_t length = std::size(value);
+
+    // We are using Pascal strings as serialization format.
+    auto len_bin = to_binary(length);
+    std::copy(len_bin.begin(), len_bin.end(), std::back_inserter(result));
+    for (std::size_t idx = 0; idx < length; ++idx) {
+        auto ch = ptr[idx];
+        result.push_back(ch);
+    }
+    return result;
+}
+
+inline auto bool_to_string(bool value) {
+    return (value == true) ? "True" : "False";
+}
+
+inline auto byte_order_to_string(int value) {
+    switch (value) {
+        case 0:
+            return "INTEL";
+        case 1:
+            return "MOTOROLA";
+        default:
+            return "<UNKNOWN>";
+    }
+    return "<UNKNOWN>";
+}
+
+template<typename K, typename V>
+static std::map<V, K> reverse_map(const std::map<K, V> &m) {
+    std::map<V, K> result;
+    for (const auto &[k, v] : m) {
+        result[v] = k;
+    }
+    return result;
+}
+
+enum class TimestampType : std::uint8_t {
+    ABSOLUTE_TS,
+    RELATIVE_TS
+};
+
+class TimestampInfo {
+   public:
+
+    TimestampInfo(const TimestampInfo &)            = default;
+    TimestampInfo(TimestampInfo &&)                 = default;
+    TimestampInfo &operator=(const TimestampInfo &) = default;
+    TimestampInfo &operator=(TimestampInfo &&)      = default;
+    virtual ~TimestampInfo() {}
+
+    TimestampInfo() : m_timestamp_ns(0), m_timezone{}, m_utc_offset(0), m_dst_offset(0) {
+    }
+
+    TimestampInfo(std::uint64_t timestamp_ns, const std::string &timezone, std::int16_t utc_offset, std::int16_t dst_offset) :
+        m_timestamp_ns(timestamp_ns), m_timezone(timezone), m_utc_offset(utc_offset), m_dst_offset(dst_offset) {
+    }
+
+    explicit TimestampInfo(std::uint64_t timestamp_ns) : m_timestamp_ns(timestamp_ns) {
+    #if defined(_WIN32) || defined(_WIN64)
+        m_timezone = std::chrono::current_zone()->name();
+    #else
+        tzset();
+        m_timezone = tzname[0];
+
+    #endif  // _WIN32 || _WIN64
+    }
+
+    std::string get_timezone() const noexcept {
+        return m_timezone;
+    }
+
+    void set_timezone(const std::string &value) noexcept {
+        m_timezone = value;
+    }
+
+    std::uint64_t get_timestamp_ns() const noexcept {
+        return m_timestamp_ns;
+    }
+
+    void set_utc_offset(std::int16_t value) noexcept {
+        m_utc_offset = value;
+    }
+
+    std::int16_t get_utc_offset() const noexcept {
+        return m_utc_offset;
+    }
+
+    void set_dst_offset(std::int16_t value) noexcept {
+        m_dst_offset = value;
+    }
+
+    std::int16_t get_dst_offset() const noexcept {
+        return m_dst_offset;
+    }
+
+    std::string to_string() const noexcept {
+        std::stringstream ss;
+        ss << "TimestamInfo(\n";
+        ss << "\ttimestamp_ns=" << m_timestamp_ns << ",\n";
+        ss << "\ttimezone=\"" << m_timezone << "\",\n";
+        ss << "\tutc_offset=" << m_utc_offset << ",\n";
+        ss << "\tdst_offset=" << m_dst_offset << "\n";
+        ss << ");";
+        return ss.str();
+    }
+
+    virtual void dummy() const noexcept {};
+
+   private:
+
+    std::uint64_t m_timestamp_ns;
+    std::string   m_timezone{};
+    std::int16_t  m_utc_offset{ 0 };
+    std::int16_t  m_dst_offset{ 0 };
+};
+
+class Timestamp {
+   public:
+
+    explicit Timestamp(TimestampType ts_type) : m_type(ts_type) {
+        m_initial = absolute();
+    }
+
+    Timestamp(const Timestamp &) = default;
+    Timestamp(Timestamp &&)      = default;
+
+    std::uint64_t get_value() const noexcept {
+        if (m_type == TimestampType::ABSOLUTE_TS) {
+            return absolute();
+        } else if (m_type == TimestampType::RELATIVE_TS) {
+            return relative();
+        }
+    }
+
+    std::uint64_t get_initial_value() const noexcept {
+        return m_initial;
+    }
+
+    std::uint64_t absolute() const noexcept {
+        std::uint64_t current;
+
+    #if defined(_WIN32) || defined(_WIN64)
+        current = std::chrono::duration_cast<std::chrono::nanoseconds>(m_clk.now().time_since_epoch()).count();
+    #else
+        // On MacOS `clock_gettime_nsec_np` could be used.
+        timespec ts;
+        clock_gettime(CLOCK_REALTIME, &ts);
+        current = static_cast<std::uint64_t>(ts.tv_sec) * 1'000'000'000 + ts.tv_nsec;
+    #endif  // _WIN32 || _WIN64
+        return current;
+    }
+
+    std::uint64_t relative() const noexcept {
+        return absolute() - m_initial;
+    }
+
+   private:
+
+    TimestampType m_type;
+    #if defined(_WIN32) || defined(_WIN64)
+    std::chrono::utc_clock m_clk;
+    #else
+
+    #endif  // _WIN32 || _WIN64
+    std::uint64_t m_initial;
+};
+
+template<typename T, typename V>
+T variant_get(V&& value) {
+
+    T result;
+
+    const T* value_ptr = std::get_if<T>(&value);
+    if (value_ptr == nullptr) {
+        result = T{};
+    }
+    else {
+        result = *value_ptr;
+    }
+
+    return result;
+}
+
+#if 0
+inline void sleep_ms(std::uint64_t milliseconds) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds));
+}
+
+inline void sleep_ns(std::uint64_t nanoseconds) {
+    std::this_thread::sleep_for(std::chrono::nanoseconds(nanoseconds));
+}
+#endif
+
+#endif  // __HELPER_HPP

pyxcp/cpp_ext/mcobject.hpp

@@ -0,0 +1,246 @@
+
+#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 (const auto& obj : components) {
+        ss << to_string(obj) << ",\n ";
+    }
+    return ss.str();
+}
+
+#endif  // __MC_OBJECT_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