pyxcp 0.23.0__cp313-cp313-win_arm64.whl

pyxcp/config/legacy.py

@@ -0,0 +1,120 @@
+from collections import defaultdict
+
+from traitlets.config import LoggingConfigurable
+from traitlets.config.loader import Config
+
+
+LEGACY_KEYWORDS = {
+    # General
+    "LOGLEVEL": "General.loglevel",
+    "DISABLE_ERROR_HANDLING": "General.disable_error_handling",
+    "SEED_N_KEY_DLL": "General.seed_n_key_dll",
+    "SEED_N_KEY_DLL_SAME_BIT_WIDTH": "General.seed_n_key_dll_same_bit_width",
+    "DISCONNECT_RESPONSE_OPTIONAL": "General.disconnect_response_optional",
+    # Transport
+    "TRANSPORT": "Transport.layer",
+    "CREATE_DAQ_TIMESTAMPS": "Transport.create_daq_timestamps",
+    "TIMEOUT": "Transport.timeout",
+    "ALIGNMENT": "Transport.alignment",
+    # Eth
+    "HOST": "Transport.Eth.host",
+    "PORT": "Transport.Eth.port",
+    "PROTOCOL": "Transport.Eth.protocol",
+    "IPV6": "Transport.Eth.ipv6",
+    "TCP_NODELAY": "Transport.Eth.tcp_nodelay",
+    # Usb
+    "SERIAL_NUMBER": "Transport.Usb.serial_number",
+    "CONFIGURATION_NUMBER": "Transport.Usb.configuration_number",
+    "INTERFACE_NUMBER": "Transport.Usb.interface_number",
+    "COMMAND_ENDPOINT_NUMBER": "Transport.Usb.out_ep_number",
+    "REPLY_ENDPOINT_NUMBER": "Transport.Usb.in_ep_number",
+    "VENDOR_ID": "Transport.Usb.vendor_id",
+    "PRODUCT_ID": "Transport.Usb.product_id",
+    "LIBRARY": "Transport.Usb.library",
+    # Can
+    "CAN_DRIVER": "Transport.Can.interface",
+    "CHANNEL": "Transport.Can.channel",
+    "MAX_DLC_REQUIRED": "Transport.Can.max_dlc_required",
+    #   "MAX_CAN_FD_DLC": "Transport.Can.max_can_fd_dlc",
+    "PADDING_VALUE": "Transport.Can.padding_value",
+    "CAN_USE_DEFAULT_LISTENER": "Transport.Can.use_default_listener",
+    # Swap master and slave IDs. (s. https://github.com/christoph2/pyxcp/issues/130)
+    "CAN_ID_SLAVE": "Transport.Can.can_id_master",
+    "CAN_ID_MASTER": "Transport.Can.can_id_slave",
+    "CAN_ID_BROADCAST": "Transport.Can.can_id_broadcast",
+    "BITRATE": "Transport.Can.bitrate",
+    "RECEIVE_OWN_MESSAGES": "Transport.Can.receive_own_messages",
+    "POLL_INTERVAL": "Transport.Can.poll_interval",
+    "FD": "Transport.Can.fd",
+    "DATA_BITRATE": "Transport.Can.data_bitrate",
+    "ACCEPT_VIRTUAL": "Transport.Can.Kvaser.accept_virtual",
+    "SJW": "Transport.Can.sjw_abr",
+    "TSEG1": "Transport.Can.tseg1_abr",
+    "TSEG2": "Transport.Can.tseg2_abr",
+    "TTY_BAUDRATE": "Transport.Can.SlCan.ttyBaudrate",
+    "UNIQUE_HARDWARE_ID": "Transport.Can.Ixxat.unique_hardware_id",
+    "RX_FIFO_SIZE": "Transport.Can.Ixxat.rx_fifo_size",
+    "TX_FIFO_SIZE": "Transport.Can.Ixxat.tx_fifo_size",
+    "DRIVER_MODE": "Transport.Can.Kvaser.driver_mode",
+    "NO_SAMP": "Transport.Can.Kvaser.no_samp",
+    "SINGLE_HANDLE": "Transport.Can.Kvaser.single_handle",
+    "USE_SYSTEM_TIMESTAMP": "Transport.Can.Neovi.use_system_timestamp",
+    "OVERRIDE_LIBRARY_NAME": "Transport.Can.Neovi.override_library_name",
+    "BAUDRATE": "Transport.Can.Serial.baudrate",
+    "SLEEP_AFTER_OPEN": "Transport.Can.SlCan.sleep_after_open",
+    "DEVICE_NUMBER": "Transport.Can.Systec.device_number",
+    "RX_BUFFER_ENTRIES": "Transport.Can.Systec.rx_buffer_entries",
+    "TX_BUFFER_ENTRIES": "Transport.Can.Systec.tx_buffer_entries",
+    "FLAGS": "Transport.Can.Usb2Can.flags",
+    "APP_NAME": "Transport.Can.Vector.app_name",
+    "RX_QUEUE_SIZE": "Transport.Can.Vector.rx_queue_size",
+}
+
+
+def nested_dict_update(d: dict, key: str, value) -> None:
+    root, *path, key = key.split(".")
+    sub_dict = d[root]
+    for part in path:
+        if part not in sub_dict:
+            sub_dict[part] = defaultdict(dict)
+        sub_dict = sub_dict[part]
+    sub_dict[key] = value
+
+
+def convert_config(legacy_config: dict, logger: LoggingConfigurable) -> Config:
+    interface_name = None
+    resolv = []
+    d = defaultdict(dict)
+    for key, value in legacy_config.items():
+        key = key.upper()
+        item = LEGACY_KEYWORDS.get(key)
+        if item is None:
+            logger.warning(f"Unknown keyword {key!r} in config file")
+            continue
+        if key == "CAN_DRIVER":
+            value = value.lower()
+            interface_name = value
+        if key in ("SERIAL", "LOG_ERRORS", "STATE", "RTSCTS"):
+            resolv.append((key, value))
+        else:
+            nested_dict_update(d=d, key=item, value=value)
+    for key, value in resolv:
+        if key == "SERIAL":
+            if interface_name == "neovi":
+                d["Transport.Can.Neovi.serial"] = value
+            elif interface_name == "vector":
+                d["Transport.Can.Vector.serial"] = value
+        elif key == "LOG_ERRORS":
+            if interface_name == "nican":
+                d["Transport.Can.NiCan.log_errors"] = value
+        elif key == "STATE":
+            if interface_name == "pcan":
+                d["Transport.Can.PCan.state"] = value
+            elif interface_name == "systec":
+                d["Transport.Can.Systec.state"] = value
+        elif key == "RTSCTS":
+            if interface_name == "serial":
+                d["Transport.Can.Serial.rtscts"] = value
+            elif interface_name == "slcan":
+                d["Transport.Can.SlCan.rtscts"] = value
+    return Config(d)

pyxcp/constants.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python
+import struct
+from typing import Any, Callable
+
+
+PackerType = Callable[[int], bytes]
+UnpackerType = Callable[[bytes], tuple[Any, ...]]
+
+
+def makeBytePacker(byteorder: str = "@") -> PackerType:
+    """"""
+    return struct.Struct(f"{byteorder}B").pack
+
+
+def makeByteUnpacker(byteorder: str = "@") -> UnpackerType:
+    """"""
+    return struct.Struct(f"{byteorder}B").unpack
+
+
+def makeWordPacker(byteorder: str = "@") -> PackerType:
+    """"""
+    return struct.Struct(f"{byteorder}H").pack
+
+
+def makeWordUnpacker(byteorder: str = "@") -> UnpackerType:
+    """"""
+    return struct.Struct(f"{byteorder}H").unpack
+
+
+def makeDWordPacker(byteorder: str = "@") -> PackerType:
+    """"""
+    return struct.Struct(f"{byteorder}I").pack
+
+
+def makeDWordUnpacker(byteorder: str = "@") -> UnpackerType:
+    """"""
+    return struct.Struct(f"{byteorder}I").unpack
+
+
+def makeDLongPacker(byteorder: str = "@") -> PackerType:
+    """"""
+    return struct.Struct(f"{byteorder}Q").pack
+
+
+def makeDLongUnpacker(byteorder: str = "@") -> UnpackerType:
+    """"""
+    return struct.Struct(f"{byteorder}Q").unpack

pyxcp/cpp_ext/bin.hpp

@@ -0,0 +1,104 @@
+
+#if !defined(__BIN_HPP)
+    #define __BIN_HPP
+
+    #include <cstdint>
+    #include <iostream>
+    #include <map>
+    #include <optional>
+    #include <string>
+    #include <vector>
+
+    #include "mcobject.hpp"
+
+class Bin {
+   public:
+
+    Bin(std::uint16_t size) : m_size(size), m_residual_capacity(size) {
+    }
+
+    Bin(std::uint16_t size, uint16_t residual_capacity, const std::vector<McObject>& entries) :
+        m_size(size), m_residual_capacity(residual_capacity), m_entries(entries) {
+    }
+
+    void append(const McObject& bin) {
+        m_entries.emplace_back(bin);
+    }
+
+    void set_entries(std::vector<McObject>&& entries) {
+        m_entries = std::move(entries);
+    }
+
+    std::uint16_t get_size() const {
+        return m_size;
+    }
+
+    void set_size(const std::uint16_t size) {
+        m_size = size;
+    }
+
+    std::uint16_t get_residual_capacity() const {
+        return m_residual_capacity;
+    }
+
+    void set_residual_capacity(const std::uint16_t residual_capacity) {
+        m_residual_capacity = residual_capacity;
+    }
+
+    const std::vector<McObject>& get_entries() const {
+        return m_entries;
+    }
+
+    bool operator==(const Bin& other) const {
+        return (m_size == other.m_size) && (m_residual_capacity == other.m_residual_capacity) && (m_entries == other.m_entries);
+    }
+
+    std::string dumps() const {
+        std::stringstream ss;
+
+        ss << to_binary(m_size);
+        ss << to_binary(m_residual_capacity);
+
+        std::size_t entries_size = m_entries.size();
+        ss << to_binary(entries_size);
+        for (const auto& entry : m_entries) {
+            ss << entry.dumps();
+        }
+
+        return ss.str();
+    }
+
+   private:
+
+    std::uint16_t         m_size;
+    std::uint16_t         m_residual_capacity;
+    std::vector<McObject> m_entries{};
+};
+
+std::string bin_entries_to_string(const std::vector<McObject>& entries);
+
+std::string to_string(const Bin& obj) {
+    std::stringstream ss;
+
+    ss << "Bin(residual_capacity=" << obj.get_residual_capacity() << ", entries=[" << bin_entries_to_string(obj.get_entries())
+       << "])";
+    return ss.str();
+}
+
+std::string bin_entries_to_string(const std::vector<McObject>& entries) {
+    std::stringstream ss;
+
+    for (const auto& entry : entries) {
+        ss << to_string(entry) << ",\n ";
+    }
+    return ss.str();
+}
+
+    #if 0
+
+    @property
+    def __len__(self) -> int:
+        return len(self.entries)
+    #endif
+
+#endif  // __BIN_HPP

pyxcp/cpp_ext/blockmem.hpp

@@ -0,0 +1,58 @@
+
+#ifndef __BLOCKMEM_HPP
+#define __BLOCKMEM_HPP
+
+#include <array>
+#include <cstdint>
+#include <mutex>
+
+/*
+ *
+ * Super simplicistic block memory manager.
+ *
+ */
+template<typename T, int _IS, int _NB>
+class BlockMemory {
+   public:
+
+    using mem_block_t = std::array<T, _IS>;
+
+    constexpr explicit BlockMemory() noexcept : m_memory{ nullptr }, m_allocation_count{ 0 } {
+        m_memory = new T[_IS * _NB];
+    }
+
+    ~BlockMemory() noexcept {
+        if (m_memory) {
+            delete[] m_memory;
+        }
+    }
+
+    BlockMemory(const BlockMemory&) = delete;
+
+    constexpr T* acquire() noexcept {
+        const std::scoped_lock lock(m_mtx);
+
+        if (m_allocation_count >= _NB) {
+            return nullptr;
+        }
+        T* ptr = reinterpret_cast<T*>(m_memory + (m_allocation_count * _IS));
+        m_allocation_count++;
+        return ptr;
+    }
+
+    constexpr void release() noexcept {
+        const std::scoped_lock lock(m_mtx);
+        if (m_allocation_count == 0) {
+            return;
+        }
+        m_allocation_count--;
+    }
+
+   private:
+
+    T*            m_memory;
+    std::uint32_t m_allocation_count;
+    std::mutex    m_mtx;
+};
+
+#endif  // __BLOCKMEM_HPP

pyxcp/cpp_ext/daqlist.hpp

@@ -0,0 +1,206 @@
+
+#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 DaqList {
+   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
+    ) :
+        m_name(meas_name), m_event_num(event_num), m_priority(priority), m_prescaler(prescaler), m_stim(stim), m_enable_timestamps(enable_timestamps) {
+        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));
+        }
+    }
+
+    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<McObject>& get_measurements() const {
+        return m_measurements;
+    }
+
+    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;
+        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()) {
+                for (const auto& component : mc_obj.get_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()
+                    );
+                    m_headers.emplace_back(component.get_name(), TYPE_MAP_REV.at(component.get_type_index()));
+                    total_entries++;
+                    total_length += component.get_length();
+                }
+            }
+            m_flatten_odts.emplace_back(flatten_odt);
+        }
+        m_odt_count     = odt_count;
+        m_total_entries = total_entries;
+        m_total_length  = total_length;
+    }
+
+    std::string dumps() const {
+        std::stringstream ss;
+
+        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_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);
+        }
+        /////
+        std::size_t odt_size = m_flatten_odts.size();
+        ss << to_binary(odt_size);
+        for (const auto& odt : m_flatten_odts) {
+            ss << to_binary(odt.size());
+            for (const auto& odt_entry : odt) {
+                const auto& [name, address, ext, size, type_index] = odt_entry;
+                ss << to_binary(name);
+                ss << to_binary(address);
+                ss << to_binary(ext);
+                ss << to_binary(size);
+                ss << to_binary(type_index);
+            }
+        }
+        return ss.str();
+    }
+
+    std::string to_string() const {
+        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 << "measurements=[\n";
+        for (const auto& meas : m_measurements) {
+            ss << ::to_string(meas) << ",\n";
+        }
+        ss << "],\n";
+        ss << "measurements_opt=[\n";
+        for (const auto& meas : m_measurements_opt) {
+            ss << ::to_string(meas) << ",\n";
+        }
+        ss << "],\n";
+        ss << "header_names=[\n";
+        for (const auto& header : m_header_names) {
+            ss << "\"" << header << "\",";
+        }
+        ss << "\n]";
+        ss << ")";
+        return ss.str();
+    }
+
+    static void loads(std::string_view buffer) {
+    }
+
+   private:
+
+    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<McObject>                             m_measurements;
+    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;
+};
+
+#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