pyxcp 0.21.10__cp312-cp312-win_amd64.whl → 0.22.23__cp312-cp312-win_amd64.whl

pyxcp/transport/candriver/pc_pcan.py

@@ -1,25 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""
-python-can driver for Peak System interfaces.
-"""
-import pyxcp.transport.can as can
-import pyxcp.transport.candriver.python_can as python_can
-
-from can import BusState
-
-
-class PCan(python_can.PythonCAN, can.CanInterfaceBase):
-    """"""
-
-    PARAMETER_MAP = {
-        #                           Type    Req'd   Default
-        "STATE": (BusState, False, BusState.ACTIVE),
-    }
-
-    PARAMETER_TO_KW_ARG_MAP = {
-        "STATE": "state",
-    }
-
-    def __init__(self):
-        super(PCan, self).__init__(bustype="pcan")

pyxcp/transport/candriver/pc_seeed.py

@@ -1,28 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""
-python-can driver for USB-CAN Analyzer by Seeed Studio interfaces.
-"""
-import pyxcp.transport.can as can
-import pyxcp.transport.candriver.python_can as python_can
-
-
-class Seeed(python_can.PythonCAN, can.CanInterfaceBase):
-    """"""
-
-    PARAMETER_MAP = {
-        #        #                           Type    Req'd   Default
-        #        "FD": (bool, False, False),
-        #        "DATA_BITRATE": (int, False, None),
-    }
-
-    PARAMETER_TO_KW_ARG_MAP = {
-        #        "FD": "fd",
-        #        "DATA_BITRATE": "data_bitrate",
-    }
-
-    def __init__(self):
-        super(Seeed, self).__init__(bustype="seeedstudio")
-
-
-# from can.interfaces.seeedstudio import SeeedBus

pyxcp/transport/candriver/pc_serial.py

@@ -1,27 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""
-python-can driver serial port connected interfaces.
-"""
-import pyxcp.transport.can as can
-import pyxcp.transport.candriver.python_can as python_can
-
-
-class Serial(python_can.PythonCAN, can.CanInterfaceBase):
-    """"""
-
-    PARAMETER_MAP = {
-        #                           Type    Req'd   Default
-        "BAUDRATE": (int, False, 115200),
-        "TIMEOUT": (float, False, 0.1),
-        "RTSCTS": (bool, False, False),
-    }
-
-    PARAMETER_TO_KW_ARG_MAP = {
-        "BAUDRATE": "baudrate",
-        "TIMEOUT": "timeout",
-        "RTSCTS": "rtscts",
-    }
-
-    def __init__(self):
-        super(Serial, self).__init__(bustype="serial")

pyxcp/transport/candriver/pc_slcan.py

@@ -1,29 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""
-python-can driver for CAN over Serial (like Lawicel)  interfaces.
-"""
-import pyxcp.transport.can as can
-import pyxcp.transport.candriver.python_can as python_can
-
-
-class SlCan(python_can.PythonCAN, can.CanInterfaceBase):
-    """"""
-
-    PARAMETER_MAP = {
-        #                           Type    Req'd   Default
-        "TTY_BAUDRATE": (int, False, 115200),
-        "POLL_INTERVAL": (float, False, 0.01),
-        "SLEEP_AFTER_OPEN": (float, False, 2.0),
-        "RTSCTS": (bool, False, False),
-    }
-
-    PARAMETER_TO_KW_ARG_MAP = {
-        "TTY_BAUDRATE": "ttyBaudrate",
-        "POLL_INTERVAL": "poll_interval",
-        "SLEEP_AFTER_OPEN": "sleep_after_open",
-        "RTSCTS": "rtscts",
-    }
-
-    def __init__(self):
-        super(SlCan, self).__init__(bustype="slcan")

pyxcp/transport/candriver/pc_socketcan.py

@@ -1,23 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""
-python-can driver for Linux SocketCAN interfaces.
-"""
-import pyxcp.transport.can as can
-import pyxcp.transport.candriver.python_can as python_can
-
-
-class SocketCAN(python_can.PythonCAN, can.CanInterfaceBase):
-    """"""
-
-    PARAMETER_MAP = {
-        #                      Type    Req'd   Default
-        "FD": (bool, False, False),
-    }
-
-    PARAMETER_TO_KW_ARG_MAP = {
-        "FD": "fd",
-    }
-
-    def __init__(self):
-        super(SocketCAN, self).__init__(bustype="socketcan")

pyxcp/transport/candriver/pc_systec.py

@@ -1,29 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""
-python-can driver for Systec interfaces.
-"""
-import pyxcp.transport.can as can
-import pyxcp.transport.candriver.python_can as python_can
-
-
-class Systec(python_can.PythonCAN, can.CanInterfaceBase):
-    """"""
-
-    PARAMETER_MAP = {
-        #                      Type    Req'd   Default
-        "DEVICE_NUMBER": (int, False, 255),
-        "RX_BUFFER_ENTRIES": (int, False, 4096),
-        "TX_BUFFER_ENTRIES": (int, False, 4096),
-        "STATE": (str, False, "ACTIVE"),
-    }
-
-    PARAMETER_TO_KW_ARG_MAP = {
-        "DEVICE_NUMBER": "device_number",
-        "RX_BUFFER_ENTRIES": "rx_buffer_entries",
-        "TX_BUFFER_ENTRIES": "tx_buffer_entries",
-        "STATE": "state",
-    }
-
-    def __init__(self):
-        super(Systec, self).__init__(bustype="systec")

pyxcp/transport/candriver/pc_usb2can.py

@@ -1,30 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""
-python-can driver for 8devices USB2CAN interfaces.
-"""
-import pyxcp.transport.can as can
-import pyxcp.transport.candriver.python_can as python_can
-
-
-class Usb2Can(python_can.PythonCAN, can.CanInterfaceBase):
-    """"""
-
-    PARAMETER_MAP = {
-        #                           Type    Req'd   Default
-        "FLAGS": (int, False, 0),
-    }
-
-    PARAMETER_TO_KW_ARG_MAP = {
-        "FLAGS": "flags",
-    }
-
-    """
-
-    :param int flags:
-        Flags to directly pass to open function of the usb2can abstraction layer.
-
-    """
-
-    def __init__(self):
-        super(Usb2Can, self).__init__(bustype="usb2can")

pyxcp/transport/candriver/pc_vector.py

@@ -1,34 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""
-python-can driver for Vector Informatik interfaces.
-"""
-import pyxcp.transport.can as can
-import pyxcp.transport.candriver.python_can as python_can
-
-
-class Vector(python_can.PythonCAN, can.CanInterfaceBase):
-    """"""
-
-    PARAMETER_MAP = {
-        #                        Type    Req'd   Default
-        "POLL_INTERVAL": (float, False, 0.01),
-        "APP_NAME": (str, False, ""),
-        "SERIAL": (int, False, None),
-        "RX_QUEUE_SIZE": (int, False, 16384),
-        "FD": (bool, False, False),
-        "DATA_BITRATE": (int, False, 0),
-        "DATA_SAMPLE_POINT": (float, False, 0),
-    }
-
-    PARAMETER_TO_KW_ARG_MAP = {
-        "POLL_INTERVAL": "poll_interval",
-        "RX_QUEUE_SIZE": "rx_queue_size",
-        "FD": "fd",
-        "DATA_BITRATE": "data_bitrate",
-        "APP_NAME": "app_name",
-        "SERIAL": "serial",
-    }
-
-    def __init__(self):
-        super(Vector, self).__init__(bustype="vector")

pyxcp/transport/candriver/python_can.py

@@ -1,101 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""
-Support for python-can - github.com/hardbyte/python-can
-"""
-import pyxcp.transport.can as can
-import re
-from collections import OrderedDict
-
-from can import Bus
-from can import CanError
-from can import Message
-
-NUMBER = re.compile(r"(?P<hex>0[x|X])?(?P<number>[0-9]+)", re.VERBOSE)
-
-
-class PythonCAN:
-    """"""
-
-    def __init__(self, bustype):
-        self.bustype = bustype
-        self.connected = False
-
-    def init(self, parent, receive_callback):
-        self.parent = parent
-        self.is_fd = self.config.get("FD")
-
-    def connect(self):
-        if self.connected:
-            return
-
-        self.kwargs = OrderedDict()
-        # Fetch driver keyword arguments.
-        self._fetch_kwargs(False)
-        self._fetch_kwargs(True)
-        can_id = self.parent.can_id_master
-        can_filter = {
-            "can_id": can_id.id,
-            "can_mask": can.MAX_29_BIT_IDENTIFIER if can_id.is_extended else can.MAX_11_BIT_IDENTIFIER,
-            "extended": can_id.is_extended,
-        }
-        self.bus = Bus(bustype=self.bustype, **self.kwargs)
-        self.bus.set_filters([can_filter])
-        self.parent.logger.debug("Python-CAN driver: {} - {}]".format(self.bustype, self.bus))
-        self.connected = True
-
-    def _fetch_kwargs(self, local):
-        if local:
-            base = self
-        else:
-            base = self.parent
-        for param, arg in base.PARAMETER_TO_KW_ARG_MAP.items():
-            value = base.config.get(param)
-            # if param == "CHANNEL":
-            #    value = self._handle_channel(value)
-            self.kwargs[arg] = value
-
-    def _handle_channel(self, value):
-        match = NUMBER.match(value)
-        if match:
-            gd = match.groupdict()
-            base = 16 if not gd["hex"] is None else 10
-            return int(value, base)
-        else:
-            return value
-
-    def close(self):
-        if self.connected:
-            self.bus.shutdown()
-        self.connected = False
-
-    def transmit(self, payload):
-        frame = Message(
-            arbitration_id=self.parent.can_id_slave.id,
-            is_extended_id=True if self.parent.can_id_slave.is_extended else False,
-            is_fd=self.is_fd,
-            data=payload,
-        )
-        self.bus.send(frame)
-
-    def read(self):
-        if not self.connected:
-            return None
-        try:
-            frame = self.bus.recv(5)
-        except CanError:
-            return None
-        else:
-            if frame is None or frame.arbitration_id != self.parent.can_id_master.id or not len(frame.data):
-                return None  # Timeout condition.
-            extended = frame.is_extended_id
-            identifier = can.Identifier.make_identifier(frame.arbitration_id, extended)
-            return can.Frame(
-                id_=identifier,
-                dlc=frame.dlc,
-                data=frame.data,
-                timestamp=frame.timestamp,
-            )
-
-    def getTimestampResolution(self):
-        return 10 * 1000

pyxcp/transport/cxx_ext/CMakeLists.txt

@@ -1,51 +0,0 @@
-cmake_minimum_required(VERSION 3.12)
-project(eth_booster VERSION 0.1.0 LANGUAGES CXX)
-
-set(BUILD_SHARED_LIBS false)
-
-set(BASE_DIR "../../cxx")
-
-if(WIN32)
-    set(_PS "win")
-elseif(UNIX)
-    set(_PS "linux")
-endif(WIN32)
-
-
-add_library(eth
-    ${BASE_DIR}/utils.cpp
-)
-if(WIN32)
-    set(ADD_LIBS ws2_32)
-elseif(UNIX)
-    set(ADD_LIBS pthread rt)
-endif(WIN32)
-
-target_compile_features(eth PRIVATE cxx_std_14)
-target_include_directories(eth PUBLIC ${BASE_DIR} ${BASE_DIR}/${_PS})
-
-add_executable(test_timestamp tests/test_timestamp.cpp)
-target_include_directories(
-    test_timestamp PUBLIC
-    ${eth_booster_SOURCE_DIR}
-    ${eth_booster_SOURCE_DIR}/${_PS}
-)
-target_link_libraries(test_timestamp eth)
-
-
-add_executable(test_pool tests/test_pool.cpp)
-target_include_directories(
-    test_pool PUBLIC
-    ${eth_booster_SOURCE_DIR}
-    ${eth_booster_SOURCE_DIR}/${_PS}
-)
-target_link_libraries(test_pool eth)
-
-add_executable(blocking_client ${BASE_DIR}/blocking_socket.cpp  ${BASE_DIR}/blocking_client.cpp)
-target_include_directories(
-    blocking_client PUBLIC
-    ${eth_booster_SOURCE_DIR}
-#    ${eth_booster_SOURCE_DIR}/${_PS}
-)
-target_link_libraries(blocking_client eth ${ADD_LIBS})
-

pyxcp/transport/cxx_ext/setup.py

@@ -1,49 +0,0 @@
-import os
-import subprocess
-import sys
-
-from distutils.core import Extension
-from distutils.core import setup
-from pybind11.setup_helpers import build_ext
-from pybind11.setup_helpers import Pybind11Extension
-
-try:
-    INCLUDE_DIRS = subprocess.getoutput("pybind11-config --include")
-except Exception as e:
-    print("Error while executing pybind11-config ('{}').\npybind11 probably not installed?".format(str(e)))
-    sys.exit(1)
-
-pf = sys.platform
-if pf.startswith("win32"):
-    LIBS = ["ws2_32"]
-elif pf.startswith("linux"):
-    LIBS = ["pthread", "rt"]
-else:
-    raise RuntimeError("Platform '{}' currently not supported.".format(pf))
-
-
-os.environ["CFLAGS"] = ""
-
-PKG_NAME = "eth_booster"
-EXT_NAMES = ["eth_booster"]
-__version__ = "0.0.1"
-
-ext_modules = [
-    Pybind11Extension(
-        EXT_NAMES[0],
-        include_dirs=[INCLUDE_DIRS],
-        sources=["blocking_socket.cpp", "utils.cpp", "wrap.cpp"],
-        define_macros=[("EXTENSION_NAME", EXT_NAMES[0])],
-        extra_compile_args=["-O3", "-Wall", "-Weffc++", "-std=c++17"],
-        libraries=LIBS,
-    ),
-]
-
-setup(
-    name=PKG_NAME,
-    version="0.0.1",
-    author="Christoph Schueler",
-    description="Example",
-    ext_modules=ext_modules,
-    cmdclass={"build_ext": build_ext},
-)

pyxcp/transport/cxx_ext/tests/test_basic_socket.cpp

@@ -1,39 +0,0 @@
-
-
-#include "eth.hpp"
-#include "socket.hpp"
-#include "asynchiofactory.hpp"
-
-#include <iomanip>
-#include <iostream>
-
-using std::cout;
-using std::endl;
-using std::setw;
-using std::internal;
-using std::fixed;
-using std::setfill;
-
-using namespace std;
-
-std::array<char, 15> hellomsg {"hello world!!!"};
-
-Eth eth;
-
-int main(void)
-{
-
-    CAddress address;
-    auto asio = createAsyncIoService();
-    auto sock = Socket {PF_INET, SOCK_STREAM, IPPROTO_TCP};
-
-    //sock.getaddrinfo(PF_INET, SOCK_STREAM, IPPROTO_TCP, "localhost", 50007, address, 0);
-    sock.getaddrinfo(PF_INET, SOCK_STREAM, IPPROTO_TCP, "192.168.168.100", 50007, address, 0);
-    sock.connect(address);
-    asio->registerSocket(sock);
-    //sock.getaddrinfo(PF_INET, SOCK_STREAM, IPPROTO_TCP, "google.de", 80, address, 0);
-    //printf("addr: %x", address.address);
-
-    sock.write(hellomsg);
-    Sleep(250);
-}

pyxcp/transport/cxx_ext/tests/test_pool.cpp

@@ -1,39 +0,0 @@
-
-#include "memoryblock.hpp"
-#include "pool.hpp"
-
-#include <iostream>
-#include <cassert>
-
-
-typedef Pool<MemoryBlock<char, 64>, 8> Pool_t;
-
-void acquire_memory_blocks(Pool_t& pool)
-{
-	for (int i = 0; i < 8; ++i) {
-		auto obj = pool.acquire();
-        pool.release(obj);
-	}
-	// Blocks should be released.
-}
-
-int main()
-{
-    Pool_t pool;
-
-	acquire_memory_blocks(pool);
-
-    auto p0 = pool.acquire();
-    auto p1 = pool.acquire();
-    auto p2 = pool.acquire();
-    auto p3 = pool.acquire();
-    auto p4 = pool.acquire();
-    auto p5 = pool.acquire();
-    auto p6 = pool.acquire();
-    auto p7 = pool.acquire();
-    try {
-        auto p8 = pool.acquire(); // should throw CapacityExhaustedException.
-    } catch(CapacityExhaustedException) {
-        std::cout << "OK, caught CapacityExhaustedException as expected." << std::endl;
-    }
-}

pyxcp/transport/cxx_ext/tests/test_timestamp.cpp

@@ -1,27 +0,0 @@
-
-#include "timestamp.hpp"
-#include "utils.hpp"
-
-#include <iomanip>
-#include <iostream>
-
-using std::cout;
-using std::endl;
-using namespace std;
-
-
-int main(void)
-{
-    auto ts = Timestamp();
-    double previous = 0.0;
-    double current = 0.0;
-
-    cout << fixed;
-
-    for (uint16_t idx = 0; idx < 100; ++idx) {
-        current = ts.get();
-        cout << "#" << setw(3) << setfill('0') << idx + 1 << " " << current << " diff: " << current -previous << endl;
-        Sleep(100);
-        previous = current;
-    }
-}