zlgcan 0.2.1b0__cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

zlgcan/__init__.py

@@ -0,0 +1 @@
+from .zlgcan import *

zlgcan/zlgcan.py

@@ -0,0 +1,256 @@
+"""
+The ZLGCAN device supported based on zlgcan-driver-rs.
+See the example `zlgcan_demo.py`
+"""
+import can
+import collections
+import time
+
+from can import CanError, CanInitializationError, Message
+from can.bus import LOG
+
+from typing import Optional, Union, Sequence, Deque, Tuple, List, Dict
+try:
+    from zlgcan_driver import ZCanChlCfgPy, ZCanMessagePy, ZDeriveInfoPy, ZCanDriverWrap, \
+        convert_to_python, convert_from_python, set_message_mode, \
+        zlgcan_device_info, zlgcan_init_can, zlgcan_clear_can_buffer, zlgcan_send, zlgcan_recv, zlgcan_close
+except ModuleNotFoundError:
+    import sys
+    import platform
+    _system_bit, _ = platform.architecture()
+    _platform = sys.platform
+    not_support = CanError(f"The system {_platform}'.'{_system_bit} is not supported!")
+    require_lib = CanError("Please install library `zlgcan-driver`!")
+    raise {
+        "win32": {"32bit": not_support}.get(_system_bit, require_lib),
+        "darwin": not_support,
+        "linux": {"32bit": not_support}.get(_system_bit, require_lib)
+    }.get(_platform, not_support)
+
+
+class ZCanChlType:
+    CAN = 0
+    CANFD_ISO = 1
+    CANFD_NON_ISO = 2
+
+class ZCanChlMode:
+    Normal = 0
+    ListenOnly = 1
+
+class ZCanTxMode:
+    NORMAL = 0  # 正常发送
+    SINGLE = 1  # 单次发送
+    SELF_SR = 2  # 自发自收
+    SINGLE_SELF_SR = 3  # 单次自发自收
+
+
+class ZCANDeviceType:
+    ZCAN_PCI5121 = 1
+    ZCAN_PCI9810 = 2
+    ZCAN_USBCAN1 = 3
+    ZCAN_USBCAN2 = 4
+    ZCAN_PCI9820 = 5
+    ZCAN_CAN232 = 6
+    ZCAN_PCI5110 = 7
+    ZCAN_CANLITE = 8
+    ZCAN_ISA9620 = 9
+    ZCAN_ISA5420 = 10
+    ZCAN_PC104CAN = 11
+    ZCAN_CANETUDP = 12
+    ZCAN_CANETE = 12
+    ZCAN_DNP9810 = 13
+    ZCAN_PCI9840 = 14
+    ZCAN_PC104CAN2 = 15
+    ZCAN_PCI9820I = 16
+    ZCAN_CANETTCP = 17
+    ZCAN_PCIE_9220 = 18
+    ZCAN_PCI5010U = 19
+    ZCAN_USBCAN_E_U = 20
+    ZCAN_USBCAN_2E_U = 21
+    ZCAN_PCI5020U = 22
+    ZCAN_EG20T_CAN = 23
+    ZCAN_PCIE9221 = 24
+    ZCAN_WIFICAN_TCP = 25
+    ZCAN_WIFICAN_UDP = 26
+    ZCAN_PCIe9120 = 27
+    ZCAN_PCIe9110 = 28
+    ZCAN_PCIe9140 = 29
+    ZCAN_USBCAN_4E_U = 31
+    ZCAN_CANDTU_200UR = 32
+    ZCAN_CANDTU_MINI = 33
+    ZCAN_USBCAN_8E_U = 34
+    ZCAN_CANREPLAY = 35
+    ZCAN_CANDTU_NET = 36
+    ZCAN_CANDTU_100UR = 37
+    ZCAN_PCIE_CANFD_100U = 38
+    ZCAN_PCIE_CANFD_200U = 39
+    ZCAN_PCIE_CANFD_400U = 40
+    ZCAN_USBCANFD_200U = 41
+    ZCAN_USBCANFD_100U = 42
+    ZCAN_USBCANFD_MINI = 43
+    ZCAN_CANFDCOM_100IE = 44
+    ZCAN_CANSCOPE = 45
+    ZCAN_CLOUD = 46
+    ZCAN_CANDTU_NET_400 = 47
+    ZCAN_CANFDNET_TCP = 48
+    ZCAN_CANFDNET_200U_TCP = 48
+    ZCAN_CANFDNET_UDP = 49
+    ZCAN_CANFDNET_200U_UDP = 49
+    ZCAN_CANFDWIFI_TCP = 50
+    ZCAN_CANFDWIFI_100U_TCP = 50
+    ZCAN_CANFDWIFI_UDP = 51
+    ZCAN_CANFDWIFI_100U_UDP = 51
+    ZCAN_CANFDNET_400U_TCP = 52
+    ZCAN_CANFDNET_400U_UDP = 53
+    ZCAN_CANFDBLUE_200U = 54
+    ZCAN_CANFDNET_100U_TCP = 55
+    ZCAN_CANFDNET_100U_UDP = 56
+    ZCAN_CANFDNET_800U_TCP = 57
+    ZCAN_CANFDNET_800U_UDP = 58
+    ZCAN_USBCANFD_800U = 59
+    ZCAN_PCIE_CANFD_100U_EX = 60
+    ZCAN_PCIE_CANFD_400U_EX = 61
+    ZCAN_PCIE_CANFD_200U_MINI = 62
+    ZCAN_PCIE_CANFD_200U_M2 = 63
+    ZCAN_CANFDDTU_400_TCP = 64
+    ZCAN_CANFDDTU_400_UDP = 65
+    ZCAN_CANFDWIFI_200U_TCP = 66
+    ZCAN_CANFDWIFI_200U_UDP = 67
+    ZCAN_CANFDDTU_800ER_TCP = 68
+    ZCAN_CANFDDTU_800ER_UDP = 69
+    ZCAN_CANFDDTU_800EWGR_TCP = 70
+    ZCAN_CANFDDTU_800EWGR_UDP = 71
+    ZCAN_CANFDDTU_600EWGR_TCP = 72
+    ZCAN_CANFDDTU_600EWGR_UDP = 73
+
+    ZCAN_OFFLINE_DEVICE = 98
+    ZCAN_VIRTUAL_DEVICE = 99
+
+
+class ZCanBus(can.BusABC):
+
+    def __init__(self,
+                 channel: Union[int, Sequence[int], str] = None, *,
+                 libpath: str = "library/",
+                 device_type: int,
+                 device_index: int = 0,
+                 derive: ZDeriveInfoPy = None,
+                 rx_queue_size: Optional[int] = None,
+                 configs: Union[List[Dict], Tuple[Dict]] = None,
+                 can_filters: Optional[can.typechecking.CanFilters] = None,
+                 **kwargs: object):
+        """
+        Constructor
+
+        :param channel: Not used(from super).
+        :param libpath: The library root path.
+        :param device_type: The device type that your device belongs, see `ZCANDeviceType`.
+        :param device_index: The device index.
+        :param derive: The deriver info for specifying the channels and canfd supported if your device is not official.
+        :param rx_queue_size: The receiving queue size.
+        :param configs: The channel configration. See `zlgcan_demo.py`.
+        :param can_filters: From super.
+        """
+        super().__init__(channel=channel, can_filters=can_filters, **kwargs)
+
+        try:
+            cfg_length = len(configs)
+            if cfg_length == 0:
+                raise CanInitializationError("ZLG-CAN - Configuration list or tuple of dict is required.")
+
+            self.rx_queue = collections.deque(
+                maxlen=rx_queue_size
+            )  # type: Deque[can.Message]               # channel, raw_msg
+            self.channels = []
+
+            cfg_list = []
+            for idx, cfg in enumerate(configs):
+                bitrate = cfg.get("bitrate", None)
+                dbitrate = cfg.get("dbitrate", None)
+                assert bitrate is not None, "bitrate is required!"
+                _cfg = ZCanChlCfgPy(
+                    chl_type=cfg.get("chl_type", ZCanChlType.CANFD_ISO if dbitrate else ZCanChlType.CAN),
+                    chl_mode=cfg.get("chl_mode", 0),
+                    bitrate=bitrate,
+                    filter=cfg.get("filter"),
+                    dbitrate=dbitrate,
+                    resistance=bool(cfg.get("resistance", 1)),
+                    acc_code=cfg.get("acc_code"),
+                    acc_mask=cfg.get("acc_mask"),
+                    brp=cfg.get("brp")
+                )
+                cfg_list.append(_cfg)
+                self.channels.append(idx)
+
+            self.device = zlgcan_init_can(libpath, device_type, device_index, cfg_list, derive)
+
+            self.dev_info = zlgcan_device_info(self.device)
+            if self.dev_info is not None:
+                LOG.info(f"Device: {self.dev_info} has opened")
+        except Exception as e:
+            self.shutdown()
+            raise e
+
+    def send(self, msg: can.Message, timeout: Optional[float] = None, *,
+             tx_mode: ZCanTxMode = ZCanTxMode.NORMAL) -> None:
+        raw_msg = convert_from_python(msg)
+        set_message_mode(raw_msg, tx_mode)
+        zlgcan_send(self.device, raw_msg)
+
+    def shutdown(self) -> None:
+        LOG.debug("ZLG-CAN - shutdown.")
+        super().shutdown()
+        if hasattr(self, "device"):
+            zlgcan_close(self.device)
+
+    def poll_received_messages(self, timeout: Optional[float]):
+        if timeout is not None:
+            timeout = int(1_000 * timeout)
+        for channel in self.channels:
+            raw_msgs: list[ZCanMessagePy] = zlgcan_recv(self.device, channel, timeout)
+            # for raw_msg in raw_msgs:
+            #     self.rx_queue.append(convert_to_python(raw_msg))
+            self.rx_queue.extend(map(lambda raw_msg: convert_to_python(raw_msg), raw_msgs))
+
+    def _recv_from_queue(self) -> Tuple[Message, bool]:
+        """Return a message from the internal receive queue"""
+        msg = self.rx_queue.popleft()
+        return msg, False
+
+    def _recv_internal(
+            self, timeout: Optional[float]
+    ) -> Tuple[Optional[Message], bool]:
+        if self.rx_queue:
+            return self._recv_from_queue()
+
+        deadline = None
+        while deadline is None or time.monotonic() < deadline:
+            if deadline is None and timeout is not None:
+                deadline = time.monotonic() + timeout
+
+            self.poll_received_messages(timeout or 0)
+
+            if self.rx_queue:
+                return self._recv_from_queue()
+
+        return None, False
+
+
+if __name__ == '__main__':
+    with ZCanBus(interface="zlgcan",
+                 libpath="../../../RustProjects/rust-can/zlgcan/library",
+                 device_type=ZCANDeviceType.ZCAN_USBCANFD_200U,
+                 configs=[{'bitrate': 500000, 'dbitrate': 1_000_000, 'resistance': 1}]) as bus:
+        # bus.send(can.Message(
+        #     arbitration_id=0x7DF,
+        #     is_extended_id=False,
+        #     channel=0,
+        #     data=[0x02, 0x10, 0x03, ],
+        #     dlc=3,
+        # ), tx_mode=ZCanTxMode.SELF_SR)
+
+        start = time.monotonic()
+        while time.monotonic() - start < 10:
+            _msg = bus.recv()
+            print(_msg)
+

zlgcan-0.2.1b0.dist-info/METADATA

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: zlgcan
+Version: 0.2.1b0
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Dist: python-can
+License-File: LICENSE.txt
+Summary: Python wrapper for zlgcan driver.
+Author: Jesse Smith
+License: LGPL v3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: homepage, https://github.com/zhuyu4839/zlgcan-driver
+Project-URL: repository, https://github.com/zhuyu4839/zlgcan-driver
+
+![PyPI Downloads](https://static.pepy.tech/badge/zlgcan)
+![PyPI Downloads](https://static.pepy.tech/badge/zlgcan/month)
+
+# ZLGCAN驱动及集成到python-can(不支持32位)
+
+1. 准备
+    * 确保安装相关驱动(USBCAN-I/II驱动得额外安装)
+    * 确保安装相[VC++运行环境](https://manual.zlg.cn/web/#/152?page_id=5332)
+    * 下载[library](https://github.com/zhuyu4839/rust-can/tree/master/zlgcan/library)文件夹(里面包含[bitrate.cfg.yaml](https://github.com/zhuyu4839/rust-can/tree/master/zlgcan/library/bitrate.cfg.yaml))
+    * 库文件示例:
+      ```shell
+      library
+        ├──bitrate.cfg.yaml
+        ├──linux
+        │  └─x86_64
+        └─windows
+           └─x86_64
+      ```
+    * 在初始化can.Bus的时候指定zlgcan库路径(从0.2.0开始移除`zcan.env`配置), 默认为相对工程运行文件同级目录下`library`
+      ```python
+      libpath=r"C:\your\library\path"
+      ```
+
+2. 安装zlgcan(不建议使用低于0.2.0版本)
+
+    ```shell
+    pip install zlgcan >= 0.2.0
+    ```
+
+3. 使用:
+   ```python
+   import can
+   from zlgcan.zlgcan import ZCanTxMode, ZCANDeviceType
+   
+   with can.Bus(interface="zlgcan", device_type=ZCANDeviceType.ZCAN_USBCANFD_200U,
+                libpath="library/",
+                configs=[{'bitrate': 500000, 'resistance': 1}, {'bitrate': 500000, 'resistance': 1}]) as bus:
+       bus.send(can.Message(
+           arbitration_id=0x123,
+           is_extended_id=False,
+           channel=0,
+           data=[0x01, 0x02, 0x03, ],
+           dlc=3,
+       ), tx_mode=ZCanTxMode.SELF_SR)
+   
+       # time.sleep(0.1)
+       _msg = bus.recv()
+       print(_msg)
+   ```
+
+4. CAN测试列表：
+   * USBCAN-I-mini - ZCAN_USBCAN1, ZCAN_USBCAN2
+   * USBCAN-4E-U - ZCAN_USBCAN_4E_U
+   * USBCANFD-100U-mini - ZCAN_USBCANFD_MINI
+   * USBCANFD-100U - ZCAN_USBCANFD_100U
+   * USBCANFD-200U - ZCAN_USBCANFD_200U
+   * USBCANFD-800U - ZCAN_USBCANFD_800U
+
+5. 注意事项:
+   * ZCAN_USBCAN1及ZCAN_USBCAN2类型的设备无论是windows还是Linux, 波特率支持均在`bitrate.cfg.yaml`中配置
+     * 此时计算timing0及timing1请下载[CAN波特率计算软件](https://zlg.cn/can/down/down/id/22.html)
+     * `bitrate.cfg.yaml`文件中USBCANFD设备只配置了500k及1M的波特率, 如需使用其他波特率, 请自行添加
+   * 其他CANFD类型的CAN卡仅仅在Linux上使用时`bitrate.cfg.yaml`中配置
+     * 此时计算相关值可以通过`ZCANPRO`软件
+   * 在Linux上使用ZCAN_USBCAN1衍生CAN卡时, 请在初始化时候设置`ZCanDeriveInfo`信息
+   * 该库主要依赖[rust-can](https://github.com/zhuyu4839/rust-can),如有问题,请提[issue](https://github.com/zhuyu4839/rust-can/issues/new)
+
+6. 官方工具及文档:
+   * [工具下载](https://zlg.cn/can/down/down/id/22.html)
+   * [驱动下载](https://manual.zlg.cn/web/#/146)
+   * [二次开发文档](https://manual.zlg.cn/web/#/42/1710)
+   * [二次开发文档CANFD-Linux](https://manual.zlg.cn/web/#/188/6982)
+   * [二次开发Demo](https://manual.zlg.cn/web/#/152/5332)
+
+

zlgcan-0.2.1b0.dist-info/RECORD

@@ -0,0 +1,9 @@
+zlgcan-0.2.1b0.dist-info/METADATA,sha256=wcQHGAv4Q3Cc8X6ma1Y5YLb3JklQXSAXN3-mSX4jqnY,3737
+zlgcan-0.2.1b0.dist-info/WHEEL,sha256=tKdHtpQgy7A134XkYf-vk3YO_5qw700B_YQRKRVozbA,129
+zlgcan-0.2.1b0.dist-info/entry_points.txt,sha256=1BprfQnq7A25SfDsPk1ZbOgMv_SmYEUWc7Xz-oAf-V4,45
+zlgcan-0.2.1b0.dist-info/licenses/LICENSE.txt,sha256=2n6rt7r999OuXp8iOqW9we7ORaxWncIbOwN1ILRGR2g,7651
+zlgcan/__init__.py,sha256=uspwQytd3RGSaVs6LQADIa9MS_qvzySlfL2S9OhFBQA,21
+zlgcan/zlgcan.py,sha256=5BpwNUZq0d5OZ0YkmbCxUTUef6WicwkZaYGVHVRtcFg,8581
+zlgcan_driver/__init__.py,sha256=JBAj4WkBypBiHIJqXHIJTNHF4kpmhRmKqY48oDAmY3E,135
+zlgcan_driver/zlgcan_driver.cpython-314-x86_64-linux-gnu.so,sha256=VU5GU0J4Fs8HrZCX_Qfa8p39w0deaNVvcE6gEN867jU,1207992
+zlgcan-0.2.1b0.dist-info/RECORD,,

zlgcan-0.2.1b0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.9.0)
+Root-Is-Purelib: false
+Tag: cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64

zlgcan-0.2.1b0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[can.interface]
+zlgcan=zlgcan.zlgcan:ZCanBus

zlgcan-0.2.1b0.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

zlgcan_driver/__init__.py

@@ -0,0 +1,5 @@
+from .zlgcan_driver import *
+
+__doc__ = zlgcan_driver.__doc__
+if hasattr(zlgcan_driver, "__all__"):
+    __all__ = zlgcan_driver.__all__