pyxcp 0.25.2__cp314-cp314-win_arm64.whl

pyxcp/cpp_ext/daqlist.hpp

@@ -0,0 +1,374 @@
+
+#if !defined(__DAQ_LIST_HPP)
+    #define __DAQ_LIST_HPP
+
+    #include "bin.hpp"
+    #include "helper.hpp"
+    #include "mcobject.hpp"
+
+using flatten_odts_t = std::vector<std::vector<std::tuple<std::string, std::uint32_t, std::uint8_t, std::uint16_t, std::int16_t>>>;
+
+class Odt {
+   public:
+    using odt_entry_initializer_t = std::tuple<std::string, std::string>;
+
+    Odt(const std::vector<odt_entry_initializer_t>& entries) {
+        for (const auto& entry : entries) {
+            const auto& [name, dt_name] = entry;
+            m_entries.emplace_back(McObject(name, 0, 0, 0, dt_name));
+        }
+    }
+
+    const std::vector<McObject>& get_entries() const {
+        return m_entries;
+    }
+
+    std::string dumps() const {
+        std::stringstream ss;
+        ss << to_binary(m_entries.size());
+        for (const auto& entry : m_entries) {
+            ss << entry.dumps();
+        }
+        return ss.str();
+    }
+
+    std::string to_string() const {
+        std::stringstream ss;
+        ss << "Odt(entries=[";
+        for (std::size_t i = 0; i < m_entries.size(); ++i) {
+            ss << ::to_string(m_entries[i]);
+            if (i + 1 < m_entries.size()) {
+                ss << ", ";
+            }
+        }
+        ss << "])";
+        return ss.str();
+    }
+
+   private:
+    std::vector<McObject> m_entries;
+};
+
+inline std::string to_string(const Odt& odt) {
+    return odt.to_string();
+}
+
+class DaqListBase {
+   public:
+    DaqListBase(std::string_view name, std::uint16_t event_num, bool stim, bool enable_timestamps, std::uint8_t priority, std::uint8_t prescaler) :
+        m_name(name),
+        m_event_num(event_num),
+        m_priority(priority),
+        m_prescaler(prescaler),
+        m_stim(stim),
+        m_enable_timestamps(enable_timestamps),
+        m_odt_count(0),
+        m_total_entries(0),
+        m_total_length(0) {
+    }
+
+    virtual ~DaqListBase() = default;
+
+    virtual std::string dumps() const = 0;
+    virtual std::string to_string() const = 0;
+
+    bool get_enable_timestamps() const {
+        return m_enable_timestamps;
+    }
+
+    const std::string& get_name() const {
+        return m_name;
+    }
+
+    std::uint16_t get_event_num() const {
+        return m_event_num;
+    }
+
+    std::uint8_t get_priority() const {
+        return m_priority;
+    }
+
+    std::uint8_t get_prescaler() const {
+        return m_prescaler;
+    }
+
+    void set_event_num(std::uint16_t event_num) {
+        m_event_num = event_num;
+    }
+
+    bool get_stim() const {
+        return m_stim;
+    }
+
+    const std::vector<Bin>& get_measurements_opt() const {
+        return m_measurements_opt;
+    }
+
+    const std::vector<std::string>& get_header_names() const {
+        return m_header_names;
+    }
+
+    const std::vector<std::tuple<std::string, std::string>>& get_headers() const noexcept {
+        return m_headers;
+    }
+
+    std::uint16_t get_odt_count() const {
+        return m_odt_count;
+    }
+
+    std::uint16_t get_total_entries() const {
+        return m_total_entries;
+    }
+
+    std::uint16_t get_total_length() const {
+        return m_total_length;
+    }
+
+    const flatten_odts_t& get_flatten_odts() const {
+        return m_flatten_odts;
+    }
+
+    void set_measurements_opt(const std::vector<Bin>& measurements_opt) {
+        m_measurements_opt = measurements_opt;
+        m_header_names.clear();
+        m_headers.clear();
+        m_flatten_odts.clear();
+
+        auto odt_count     = 0u;
+        auto total_entries = 0u;
+        auto total_length  = 0u;
+        for (const auto& bin : measurements_opt) {
+            odt_count++;
+            std::vector<std::tuple<std::string, std::uint32_t, std::uint8_t, std::uint16_t, std::int16_t>> flatten_odt{};
+            for (const auto& mc_obj : bin.get_entries()) {
+                const auto& components = mc_obj.get_components();
+                if (!components.empty()) {
+                    for (const auto& component : components) {
+                        m_header_names.emplace_back(component.get_name());
+                        flatten_odt.emplace_back(
+                            component.get_name(), component.get_address(), component.get_ext(), component.get_length(),
+                            component.get_type_index()
+                        );
+                        // TYPE_MAP_REV::at may throw if key is invalid; this indicates a programming error upstream.
+                        m_headers.emplace_back(component.get_name(), TYPE_MAP_REV.at(static_cast<std::uint16_t>(component.get_type_index())));
+                        total_entries++;
+                        total_length += component.get_length();
+                    }
+                } else {
+                    // Treat the McObject itself as an entry when it has no components.
+                    m_header_names.emplace_back(mc_obj.get_name());
+                    flatten_odt.emplace_back(
+                        mc_obj.get_name(), mc_obj.get_address(), mc_obj.get_ext(), mc_obj.get_length(), mc_obj.get_type_index()
+                    );
+                    m_headers.emplace_back(mc_obj.get_name(), TYPE_MAP_REV.at(static_cast<std::uint16_t>(mc_obj.get_type_index())));
+                    total_entries++;
+                    total_length += mc_obj.get_length();
+                }
+            }
+            m_flatten_odts.emplace_back(std::move(flatten_odt));
+        }
+        m_odt_count     = static_cast<std::uint16_t>(odt_count);
+        m_total_entries = static_cast<std::uint16_t>(total_entries);
+        m_total_length  = static_cast<std::uint16_t>(total_length);
+    }
+
+   protected:
+    std::string                                       m_name;
+    std::uint16_t                                     m_event_num;
+    std::uint8_t                                      m_priority;
+    std::uint8_t                                      m_prescaler;
+    bool                                              m_stim;
+    bool                                              m_enable_timestamps;
+    std::vector<Bin>                                  m_measurements_opt;
+    std::vector<std::string>                          m_header_names;
+    std::vector<std::tuple<std::string, std::string>> m_headers;
+    std::uint16_t                                     m_odt_count;
+    std::uint16_t                                     m_total_entries;
+    std::uint16_t                                     m_total_length;
+    flatten_odts_t                                    m_flatten_odts;
+};
+
+class DaqList : public DaqListBase {
+   public:
+
+    using daq_list_initialzer_t = std::tuple<std::string, std::uint32_t, std::uint16_t, std::string>;
+
+    DaqList(
+        std::string_view meas_name, std::uint16_t event_num, bool stim, bool enable_timestamps,
+        const std::vector<daq_list_initialzer_t>& measurements, std::uint8_t priority=0x00, std::uint8_t prescaler=0x01
+    ) :
+        DaqListBase(meas_name, event_num, stim, enable_timestamps, priority, prescaler) {
+        for (const auto& measurement : measurements) {
+            auto const& [name, address, ext, dt_name] = measurement;
+            m_measurements.emplace_back(McObject(name, address, static_cast<std::uint8_t>(ext), 0, dt_name));
+        }
+    }
+
+    const std::vector<McObject>& get_measurements() const {
+        return m_measurements;
+    }
+
+    std::string dumps() const override {
+        std::stringstream ss;
+
+		std::uint8_t discr=1;
+
+        ss << to_binary(discr);
+        ss << to_binary(m_name);
+        ss << to_binary(m_event_num);
+        ss << to_binary(m_stim);
+        ss << to_binary(m_enable_timestamps);
+        ss << to_binary(m_priority);
+        ss << to_binary(m_prescaler);
+
+        ss << to_binary(m_odt_count);
+        ss << to_binary(m_total_entries);
+        ss << to_binary(m_total_length);
+
+        std::size_t meas_size = m_measurements.size();
+        ss << to_binary(meas_size);
+        for (const auto& mc_obj : m_measurements) {
+            ss << mc_obj.dumps();
+        }
+        std::size_t meas_opt_size = m_measurements_opt.size();
+        ss << to_binary(meas_opt_size);
+        for (const auto& mc_obj : m_measurements_opt) {
+            ss << mc_obj.dumps();
+        }
+        std::size_t hname_size = m_header_names.size();
+        ss << to_binary(hname_size);
+        for (const auto& hdr_obj : m_header_names) {
+            ss << to_binary(hdr_obj);
+        }
+        return ss.str();
+    }
+
+    std::string to_string() const override {
+        std::stringstream ss;
+        ss << "DaqList(";
+        ss << "name='" << m_name << "', ";
+        ss << "event_num=" << static_cast<std::uint16_t>(m_event_num) << ", ";
+        ss << "stim=" << bool_to_string(m_stim) << ", ";
+        ss << "enable_timestamps=" << bool_to_string(m_enable_timestamps) << ", ";
+        ss << "priority=" << static_cast<std::uint16_t>(m_priority) << ", ";
+        ss << "prescaler=" << static_cast<std::uint16_t>(m_prescaler) << ", ";
+        ss << "odt_count=" << static_cast<std::uint16_t>(m_odt_count) << ", ";
+        ss << "total_entries=" << static_cast<std::uint16_t>(m_total_entries) << ", ";
+        ss << "total_length=" << static_cast<std::uint16_t>(m_total_length) << ", ";
+        ss << "measurements=[";
+        for (std::size_t i = 0; i < m_measurements.size(); ++i) {
+            ss << ::to_string(m_measurements[i]);
+            if (i + 1 < m_measurements.size()) ss << ", ";
+        }
+        ss << "], ";
+        ss << "measurements_opt=[";
+        for (std::size_t i = 0; i < m_measurements_opt.size(); ++i) {
+            ss << ::to_string(m_measurements_opt[i]);
+            if (i + 1 < m_measurements_opt.size()) ss << ", ";
+        }
+        ss << "], ";
+        ss << "header_names=[";
+        for (std::size_t i = 0; i < m_header_names.size(); ++i) {
+            ss << "'" << m_header_names[i] << "'";
+            if (i + 1 < m_header_names.size()) ss << ", ";
+        }
+        ss << "])";
+        return ss.str();
+    }
+
+    static void loads(std::string_view buffer) {
+    }
+
+   private:
+    std::vector<McObject> m_measurements;
+};
+
+class PredefinedDaqList : public DaqListBase {
+   public:
+    using odt_initializer_t = std::vector<Odt::odt_entry_initializer_t>;
+    using predefined_daq_list_initializer_t = std::vector<odt_initializer_t>;
+
+    PredefinedDaqList(
+        std::string_view name, std::uint16_t event_num, bool stim, bool enable_timestamps,
+        const predefined_daq_list_initializer_t& odts, std::uint8_t priority = 0x00, std::uint8_t prescaler = 0x01) :
+        DaqListBase(name, event_num, stim, enable_timestamps, priority, prescaler) {
+        std::vector<Bin> bins;
+        bins.reserve(odts.size());
+        for (const auto& odt_init : odts) {
+            Bin bin(0);
+            std::uint16_t total_length = 0;
+            for (const auto& entry : odt_init) {
+                const auto& [name, dt_name] = entry;
+                // McObject will validate dt_name and set length accordingly.
+                McObject obj(name, 0, 0, 0, dt_name);
+                total_length = static_cast<std::uint16_t>(total_length + obj.get_length());
+                bin.append(obj);
+            }
+            // Derive Bin size and residual capacity from sum of entry lengths.
+            bin.set_size(total_length);
+            bin.set_residual_capacity(total_length);
+            bins.emplace_back(std::move(bin));
+        }
+        set_measurements_opt(bins);
+    }
+
+    std::string dumps() const override {
+        std::stringstream ss;
+
+		std::uint8_t discr=2;
+
+        ss <<  to_binary(discr);
+
+        ss << to_binary(m_name);
+        ss << to_binary(m_event_num);
+        ss << to_binary(m_stim);
+        ss << to_binary(m_enable_timestamps);
+        ss << to_binary(m_priority);
+        ss << to_binary(m_prescaler);
+
+        ss << to_binary(m_odt_count);
+        ss << to_binary(m_total_entries);
+        ss << to_binary(m_total_length);
+
+        std::size_t meas_opt_size = m_measurements_opt.size();
+        ss << to_binary(meas_opt_size);
+        for (const auto& mc_obj : m_measurements_opt) {
+            ss << mc_obj.dumps();
+        }
+        std::size_t hname_size = m_header_names.size();
+        ss << to_binary(hname_size);
+        for (const auto& hdr_obj : m_header_names) {
+            ss << to_binary(hdr_obj);
+        }
+        return ss.str();
+    }
+
+    std::string to_string() const override {
+        std::stringstream ss;
+        ss << "PredefinedDaqList(";
+        ss << "name='" << m_name << "', ";
+        ss << "event_num=" << static_cast<std::uint16_t>(m_event_num) << ", ";
+        ss << "stim=" << bool_to_string(m_stim) << ", ";
+        ss << "enable_timestamps=" << bool_to_string(m_enable_timestamps) << ", ";
+        ss << "priority=" << static_cast<std::uint16_t>(m_priority) << ", ";
+        ss << "prescaler=" << static_cast<std::uint16_t>(m_prescaler) << ", ";
+        ss << "odt_count=" << static_cast<std::uint16_t>(m_odt_count) << ", ";
+        ss << "total_entries=" << static_cast<std::uint16_t>(m_total_entries) << ", ";
+        ss << "total_length=" << static_cast<std::uint16_t>(m_total_length) << ", ";
+        ss << "measurements_opt=[";
+        for (std::size_t i = 0; i < m_measurements_opt.size(); ++i) {
+            ss << ::to_string(m_measurements_opt[i]);
+            if (i + 1 < m_measurements_opt.size()) ss << ", ";
+        }
+        ss << "], ";
+        ss << "header_names=[";
+        for (std::size_t i = 0; i < m_header_names.size(); ++i) {
+            ss << "'" << m_header_names[i] << "'";
+            if (i + 1 < m_header_names.size()) ss << ", ";
+        }
+        ss << "])";
+        return ss.str();
+    }
+};
+
+#endif  // __DAQ_LIST_HPP

pyxcp/cpp_ext/event.hpp

@@ -0,0 +1,67 @@
+
+#ifndef __EVENT_HPP
+#define __EVENT_HPP
+
+#include <atomic>
+#include <condition_variable>
+#include <mutex>
+
+class Event {
+   public:
+
+    Event(const Event& other) noexcept {
+        std::scoped_lock lock(other.m_mtx);
+        m_flag = other.m_flag;
+    }
+
+    ~Event() = default;
+    Event()  = default;
+
+    void signal() noexcept {
+        std::scoped_lock lock(m_mtx);
+        m_flag = true;
+        m_cond.notify_one();
+    }
+
+    void wait() noexcept {
+        std::unique_lock lock(m_mtx);
+        m_cond.wait(lock, [this] { return m_flag; });
+        m_flag = false;
+    }
+
+    bool state() const noexcept {
+        std::scoped_lock lock(m_mtx);
+        return m_flag;
+    }
+
+   private:
+
+    mutable std::mutex      m_mtx{};
+    bool                    m_flag{ false };
+    std::condition_variable m_cond{};
+};
+
+#if 0
+class Spinlock {
+   public:
+
+    Spinlock() : m_flag(ATOMIC_FLAG_INIT) {
+    }
+
+    ~Spinlock() = default;
+
+    void lock() {
+        while (m_flag.test_and_set()) {
+        }
+    }
+
+    void unlock() {
+        m_flag.clear();
+    }
+
+private:
+    std::atomic_flag m_flag;
+};
+#endif
+
+#endif  // __EVENT_HPP

pyxcp/cpp_ext/extension_wrapper.cpp

@@ -0,0 +1,131 @@
+
+#include <pybind11/chrono.h>
+#include <pybind11/functional.h>
+#include <pybind11/numpy.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <memory>
+
+#include <cstdint>
+
+#include "aligned_buffer.hpp"
+#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_<DaqListBase, std::shared_ptr<DaqListBase>>(m, "DaqListBase")
+        .def_property("name", &DaqListBase::get_name, nullptr)
+        .def_property("event_num", &DaqListBase::get_event_num, &DaqListBase::set_event_num)
+        .def_property("priority", &DaqListBase::get_priority, nullptr)
+        .def_property("prescaler", &DaqListBase::get_prescaler, nullptr)
+        .def_property("stim", &DaqListBase::get_stim, nullptr)
+        .def_property("enable_timestamps", &DaqListBase::get_enable_timestamps, nullptr)
+        .def_property("measurements_opt", &DaqListBase::get_measurements_opt, &DaqListBase::set_measurements_opt)
+        .def_property("headers", &DaqListBase::get_headers, nullptr)
+        .def_property("odt_count", &DaqListBase::get_odt_count, nullptr)
+        .def_property("total_entries", &DaqListBase::get_total_entries, nullptr)
+        .def_property("total_length", &DaqListBase::get_total_length, nullptr);
+
+    py::class_<DaqList, DaqListBase, std::shared_ptr<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("measurements", &DaqList::get_measurements, nullptr);
+
+    py::class_<PredefinedDaqList, DaqListBase, std::shared_ptr<PredefinedDaqList>>(m, "PredefinedDaqList")
+        .def(
+            py::init<std::string_view, std::uint16_t, bool, bool, const PredefinedDaqList::predefined_daq_list_initializer_t&,
+            std::uint8_t, std::uint8_t>(), "name"_a, "event_num"_a, "stim"_a, "enable_timestamps"_a, "odts"_a,
+            "priority"_a=0, "prescaler"_a=1
+        )
+        .def("__repr__", [](const PredefinedDaqList& self) {
+            try {
+                return self.to_string();
+            } catch (const std::exception& e) {
+                return std::string("PredefinedDaqList(<repr error: ") + e.what() + ">)";
+            } catch (...) {
+                return std::string("PredefinedDaqList(<repr error: unknown>)");
+            }
+        })
+		;
+
+    // Aligned buffer utility
+    py::class_<AlignedBuffer>(m, "AlignedBuffer")
+        .def(py::init<std::size_t>(), py::arg("size") = 0xffff)
+        .def("reset", &AlignedBuffer::reset)
+        .def("append", &AlignedBuffer::append, py::arg("value"))
+        .def("extend", py::overload_cast<const py::bytes&>(&AlignedBuffer::extend))
+        .def("extend", py::overload_cast<const std::vector<std::uint8_t>&>(&AlignedBuffer::extend))
+        .def("__len__", [](const AlignedBuffer& self) { return self.size(); })
+        .def("__getitem__", [](const AlignedBuffer& self, py::object index) { return self.get_item(index); });
+
+
+    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);
+
+}