Python基于周立功盒子的二次开发的封装和调用

已于 2023-05-15 17:07:49 修改
阅读量2.3k 收藏 29
点赞数 4
分类专栏： 基于周立功的使用和二次开发 文章标签： python pycharm 周立功二次开发
于 2023-03-28 17:28:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wsq119/article/details/129820404
版权
本文介绍了如何对Python基于周立功盒子的二次开发进行代码封装，旨在提高可读性和方便维护。通过将ctypes调用C++动态库的接口函数代码封装到zlgcan.py，将业务逻辑代码置于zlg_test.py，实现了代码结构的清晰划分。通过这种方式，开发者只需关注zlg_test.py中的业务逻辑，降低了修改和理解代码的难度。
摘要由CSDN通过智能技术生成

Python基于周立功盒子的二次开发的封装和调用

一、介绍
    前面我们介绍如何拿到官网给的例程并使用起来，但在使用的过程中，我们发现官网给的例子非常的冗长，可读性不好，于是我进行分解和封装，使得程序更容易看明白，如下是我对结构的分解和介绍。

二、分装的依据

  • 将通过ctypes模块调用c++动态库的接口函数的代码形成的python接口的代码全部单独放到了zlgcan.py文件；
  • 将我们自己调用python接口实现的业务逻辑单独放在zlg_test.py；
  • 分离之后，每次就可以根据自己的需求修改对应的业务逻辑代码，也就是修改zlg_test.py文件，而zlgcan.py文件则不需要改动。

三、具体的代码展示

  • zlgcan.py文件

    #!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2023/3/21 17:44
# @Author  : Shiqiang Wang
# @File    : zlccan.py
# @Software: PyCharm
# !/usr/bin/python
# coding=utf-8

# -*- coding:utf-8 -*-
#  zlgcan.py
#
#  ~~~~~~~~~~~~
#
#  ZLGCAN API
#
#  ~~~~~~~~~~~~
#
#  ------------------------------------------------------------------
#  Author : guochuangjian
#  Last change: 21.02.2019
#
#  Language: Python 2.7, 3.6
#  ------------------------------------------------------------------
#
from ctypes import *
import platform


ZCAN_DEVICE_TYPE = c_uint

INVALID_DEVICE_HANDLE = 0
INVALID_CHANNEL_HANDLE = 0

'''
 Device Type
'''
ZCAN_PCI5121 = ZCAN_DEVICE_TYPE(1)
ZCAN_PCI9810 = ZCAN_DEVICE_TYPE(2)
ZCAN_USBCAN1 = ZCAN_DEVICE_TYPE(3)
ZCAN_USBCAN2 = ZCAN_DEVICE_TYPE(4)
ZCAN_PCI9820 = ZCAN_DEVICE_TYPE(5)
ZCAN_CAN232 = ZCAN_DEVICE_TYPE(6)
ZCAN_PCI5110 = ZCAN_DEVICE_TYPE(7)
ZCAN_CANLITE = ZCAN_DEVICE_TYPE(8)
ZCAN_ISA9620 = ZCAN_DEVICE_TYPE(9)
ZCAN_ISA5420 = ZCAN_DEVICE_TYPE(10)
ZCAN_PC104CAN = ZCAN_DEVICE_TYPE(11)
ZCAN_CANETUDP = ZCAN_DEVICE_TYPE(12)
ZCAN_CANETE = ZCAN_DEVICE_TYPE(12)
ZCAN_DNP9810 = ZCAN_DEVICE_TYPE(13)
ZCAN_PCI9840 = ZCAN_DEVICE_TYPE(14)
ZCAN_PC104CAN2 = ZCAN_DEVICE_TYPE(15)
ZCAN_PCI9820I = ZCAN_DEVICE_TYPE(16)
ZCAN_CANETTCP = ZCAN_DEVICE_TYPE(17)
ZCAN_PCIE_9220 = ZCAN_DEVICE_TYPE(18)
ZCAN_PCI5010U = ZCAN_DEVICE_TYPE(19)
ZCAN_USBCAN_E_U = ZCAN_DEVICE_TYPE(20)
ZCAN_USBCAN_2E_U = ZCAN_DEVICE_TYPE(21)
ZCAN_PCI5020U = ZCAN_DEVICE_TYPE(22)
ZCAN_EG20T_CAN = ZCAN_DEVICE_TYPE(23)
ZCAN_PCIE9221 = ZCAN_DEVICE_TYPE(24)
ZCAN_WIFICAN_TCP = ZCAN_DEVICE_TYPE(25)
ZCAN_WIFICAN_UDP = ZCAN_DEVICE_TYPE(26)
ZCAN_PCIe9120 = ZCAN_DEVICE_TYPE(27)
ZCAN_PCIe9110 = ZCAN_DEVICE_TYPE(28)
ZCAN_PCIe9140 = ZCAN_DEVICE_TYPE(29)
ZCAN_USBCAN_4E_U = ZCAN_DEVICE_TYPE(31)
ZCAN_CANDTU_200UR = ZCAN_DEVICE_TYPE(32)
ZCAN_CANDTU_MINI = ZCAN_DEVICE_TYPE(33)
ZCAN_USBCAN_8E_U = ZCAN_DEVICE_TYPE(34)
ZCAN_CANREPLAY = ZCAN_DEVICE_TYPE(35)
ZCAN_CANDTU_NET = ZCAN_DEVICE_TYPE(36)
ZCAN_CANDTU_100UR = ZCAN_DEVICE_TYPE(37)
ZCAN_PCIE_CANFD_100U = ZCAN_DEVICE_TYPE(38)
ZCAN_PCIE_CANFD_200U = ZCAN_DEVICE_TYPE(39)
ZCAN_PCIE_CANFD_400U = ZCAN_DEVICE_TYPE(40)
ZCAN_USBCANFD_200U = ZCAN_DEVICE_TYPE(41)
ZCAN_USBCANFD_100U = ZCAN_DEVICE_TYPE(42)
ZCAN_USBCANFD_MINI = ZCAN_DEVICE_TYPE(43)
ZCAN_CANFDCOM_100IE = ZCAN_DEVICE_TYPE(44)
ZCAN_CANSCOPE = ZCAN_DEVICE_TYPE(45)
ZCAN_CLOUD = ZCAN_DEVICE_TYPE(46)
ZCAN_CANDTU_NET_400 = ZCAN_DEVICE_TYPE(47)
ZCAN_CANFDNET_200U_TCP = ZCAN_DEVICE_TYPE(48)
ZCAN_CANFDNET_200U_UDP = ZCAN_DEVICE_TYPE(49)
ZCAN_CANFDWIFI_100U_TCP = ZCAN_DEVICE_TYPE(50)
ZCAN_CANFDWIFI_100U_UDP = ZCAN_DEVICE_TYPE(51)
ZCAN_CANFDNET_400U_TCP = ZCAN_DEVICE_TYPE(52)
ZCAN_CANFDNET_400U_UDP = ZCAN_DEVICE_TYPE(53)
ZCAN_CANFDBLUE_200U = ZCAN_DEVICE_TYPE(54)
ZCAN_CANFDNET_100U_TCP = ZCAN_DEVICE_TYPE(55)
ZCAN_CANFDNET_100U_UDP = ZCAN_DEVICE_TYPE(56)
ZCAN_CANFDNET_800U_TCP = ZCAN_DEVICE_TYPE(57)
ZCAN_CANFDNET_800U_UDP = ZCAN_DEVICE_TYPE(58)
ZCAN_USBCANFD_800U = ZCAN_DEVICE_TYPE(59)
ZCAN_PCIE_CANFD_100U_EX = ZCAN_DEVICE_TYPE(60)
ZCAN_PCIE_CANFD_400U_EX = ZCAN_DEVICE_TYPE(61)
ZCAN_PCIE_CANFD_200U_MINI = ZCAN_DEVICE_TYPE(62)
ZCAN_PCIE_CANFD_200U_M2 = ZCAN_DEVICE_TYPE(63)
ZCAN_PCIE_CANFD_200U_EX = ZCAN_DEVICE_TYPE(62)
ZCAN_CANFDDTU_400_TCP = ZCAN_DEVICE_TYPE(64)
ZCAN_CANFDDTU_400_UDP = ZCAN_DEVICE_TYPE(65)
ZCAN_CANFDWIFI_200U_TCP = ZCAN_DEVICE_TYPE(66)
ZCAN_CANFDWIFI_200U_UDP = ZCAN_DEVICE_TYPE(67)
ZCAN_CANFDDTU_800ER_TCP = ZCAN_DEVICE_TYPE(68)
ZCAN_CANFDDTU_800ER_UDP = ZCAN_DEVICE_TYPE(69)
ZCAN_CANFDDTU_800EWGR_TCP = ZCAN_DEVICE_TYPE(70)
ZCAN_CANFDDTU_800EWGR_UDP = ZCAN_DEVICE_TYPE(71)
ZCAN_CANFDDTU_600EWGR_TCP = ZCAN_DEVICE_TYPE(72)
ZCAN_CANFDDTU_600EWGR_UDP = ZCAN_DEVICE_TYPE(73)
ZCAN_VIRTUAL_DEVICE = ZCAN_DEVICE_TYPE(99)

'''
 Interface return status
'''
ZCAN_STATUS_ERR = 0
ZCAN_STATUS_OK = 1
ZCAN_STATUS_ONLINE = 2
ZCAN_STATUS_OFFLINE = 3
ZCAN_STATUS_UNSUPPORTED = 4

'''
 CAN type
'''
ZCAN_TYPE_CAN = c_uint(0)
ZCAN_TYPE_CANFD = c_uint(1)

# set auto send obj

'''
 Device information
'''


class ZCAN_DEVICE_INFO(Structure):
    _fields_ = [("hw_Version", c_ushort),
                ("fw_Version", c_ushort),
                ("dr_Version", c_ushort),
                ("in_Version", c_ushort),
                ("irq_Num", c_ushort),
                ("can_Num", c_ubyte),
                ("str_Serial_Num", c_ubyte * 20),
                ("str_hw_Type", c_ubyte * 40),
                ("reserved", c_ushort * 4)]

    def __str__(self):
        return "Hardware Version:%s\nFirmware Version:%s\nDriver Interface:%s\nInterface Interface:%s\nInterrupt Number:%d\nCAN Number:%d\nSerial:%s\nHardware Type:%s\n" % ( \
            self.hw_version, self.fw_version, self.dr_version, self.in_version, self.irq_num, self.can_num, self.serial,
            self.hw_type)

    def _version(self, version):
        return ("V%02x.%02x" if version // 0xFF >= 9 else "V%d.%02x") % (version // 0xFF, version & 0xFF)

    @property
    def hw_version(self):
        return self._version(self.hw_Version)

    @property
    def fw_version(self):
        return self._version(self.fw_Version)

    @property
    def dr_version(self):
        return self._version(self.dr_Version)

    @property
    def in_version(self):
        return self._version(self.in_Version)

    @property
    def irq_num(self):
        return self.irq_Num

    @property
    def can_num(self):
        return self.can_Num

    @property
    def serial(self):
        serial = ''
        for c in self.str_Serial_Num:
            if c > 0:
                serial += chr(c)
            else:
                break
        return serial

    @property
    def hw_type(self):
        hw_type = ''
        for c in self.str_hw_Type:
            if c > 0:
                hw_type += chr(c)
            else:
                break
        return hw_type


class _ZCAN_CHANNEL_CAN_INIT_CONFIG(Structure):
    _fields_ = [("acc_code", c_uint),
                ("acc_mask", c_uint),
                ("reserved", c_uint),
                ("filter", c_ubyte),
                ("timing0", c_ubyte),
                ("timing1", c_ubyte),
                ("mode", c_ubyte)]


class _ZCAN_CHANNEL_CANFD_INIT_CONFIG(Structure):
    _fields_ = [("acc_code", c_uint),
                ("acc_mask", c_uint),
                ("abit_timing", c_uint),
                ("dbit_timing", c_uint),
                ("brp", c_uint),
                ("filter", c_ubyte),
                ("mode", c_ubyte),
                ("pad", c_ushort),
                ("reserved", c_uint)]


class _ZCAN_CHANNEL_INIT_CONFIG(Union):
    _fields_ = [("can", _ZCAN_CHANNEL_CAN_INIT_CONFIG), ("canfd", _ZCAN_CHANNEL_CANFD_INIT_CONFIG)]


class ZCAN_CHANNEL_INIT_CONFIG(Structure):
    _fields_ = [("can_type", c_uint),
                ("config", _ZCAN_CHANNEL_INIT_CONFIG)]


class ZCAN_CHANNEL_ERR_INFO(Structure):
    _fields_ = [("error_code", c_uint),
                ("passive_ErrData", c_ubyte * 3),
                ("arLost_ErrData", c_ubyte)]


class ZCAN_CHANNEL_STATUS(Structure):
    _fields_ = [("errInterrupt", c_ubyte),
                ("regMode", c_ubyte),
                ("regStatus", c_ubyte),
                ("regALCapture", c_ubyte),
                ("regECCapture", c_ubyte),
                ("regEWLimit", c_ubyte),
                ("regRECounter", c_ubyte),
                ("regTECounter", c_ubyte),
                ("Reserved", c_ubyte)]


class ZCAN_CAN_FRAME(Structure):
    _fields_ = [("can_id", c_uint, 29),
                ("err", c_uint, 1),
                ("rtr", c_uint, 1),
                ("eff", c_uint, 1),
                ("can_dlc", c_ubyte),
                ("__pad", c_ubyte),
                ("__res0", c_ubyte),
                ("__res1", c_ubyte),
                ("data", c_ubyte * 8)]


class ZCAN_CANFD_FRAME(Structure):
    _fields_ = [("can_id", c_uint, 29),
                ("err", c_uint, 1),
                ("rtr", c_uint, 1),
                ("eff", c_uint, 1),
                ("len", c_ubyte),
                ("brs", c_ubyte, 1),
                ("esi", c_ubyte, 1),
                ("__pad", c_ubyte, 6),
                ("__res0", c_ubyte),
                ("__res1", c_ubyte),
                ("data", c_ubyte * 64)]


class ZCAN_Transmit_Data(Structure):
    _fields_ = [("frame", ZCAN_CAN_FRAME), ("transmit_type", c_uint)]


class ZCAN_Receive_Data(Structure):
    _fields_ = [("frame", ZCAN_CAN_FRAME), ("timestamp", c_ulonglong)]


class ZCAN_TransmitFD_Data(Structure):
    _fields_ = [("frame", ZCAN_CANFD_FRAME), ("transmit_type", c_uint)]


class ZCAN_ReceiveFD_Data(Structure):
    _fields_ = [("frame", ZCAN_CANFD_FRAME), ("timestamp", c_ulonglong)]


class ZCAN_AUTO_TRANSMIT_OBJ(Structure):
    _fields_ = [("enable", c_ushort),
                ("index", c_ushort),
                ("interval", c_uint),
                ("obj", ZCAN_Transmit_Data)]


class ZCANFD_AUTO_TRANSMIT_OBJ(Structure):
    _fields_ = [("enable", c_ushort),
                ("index", c_ushort),
                ("interval", c_uint),
                ("obj", ZCAN_TransmitFD_Data)]


class ZCANFD_AUTO_TRANSMIT_OBJ_PARAM(Structure):  # auto_send delay
    _fields_ = [("indix", c_ushort),
                ("type", c_ushort),
                ("value", c_uint)]


class IProperty(Structure):
    _fields_ = [("SetValue", c_void_p),
                ("GetValue", c_void_p),
                ("GetPropertys", c_void_p)]


class ZCAN(object):
    def __init__(self):
        if platform.system() == "Windows":
            self.__dll = windll.LoadLibrary("./zlgcan.dll")
        else:
            print("No support now!")
        if self.__dll == None:
            print("DLL couldn't be loaded!")

    def OpenDevice(self, device_type, device_index, reserved):
        try:
            return self.__dll.ZCAN_OpenDevice(device_type, device_index, reserved)
        except:
            print("Exception on OpenDevice!")
            raise

    def CloseDevice(self, device_handle):
        try:
            return self.__dll.ZCAN_CloseDevice(device_handle)
        except:
            print("Exception on CloseDevice!")
            raise

    def GetDeviceInf(self, device_handle):
        try:
            info = ZCAN_DEVICE_INFO()
            ret = self.__dll.ZCAN_GetDeviceInf(device_handle, byref(info))
            return info if ret == ZCAN_STATUS_OK else None
        except:
            print("Exception on ZCAN_GetDeviceInf")
            raise

    def DeviceOnLine(self, device_handle):
        try:
            return self.__dll.ZCAN_IsDeviceOnLine(device_handle)
        except:
            print("Exception on ZCAN_ZCAN_IsDeviceOnLine!")
            raise

    def InitCAN(self, device_handle, can_index, init_config):
        try:
            return self.__dll.ZCAN_InitCAN(device_handle, can_index, byref(init_config))
        except:
            print("Exception on ZCAN_InitCAN!")
            raise

    def StartCAN(self, chn_handle):
        try:
            return self.__dll.ZCAN_StartCAN(chn_handle)
        except:
            print("Exception on ZCAN_StartCAN!")
            raise

    def ResetCAN(self, chn_handle):
        try:
            return self.__dll.ZCAN_ResetCAN(chn_handle)
        except:
            print("Exception on ZCAN_ResetCAN!")
            raise

    def ClearBuffer(self, chn_handle):
        try:
            return self.__dll.ZCAN_ClearBuffer(chn_handle)
        except:
            print("Exception on ZCAN_ClearBuffer!")
            raise

    def ReadChannelErrInfo(self, chn_handle):
        try:
            ErrInfo = ZCAN_CHANNEL_ERR_INFO()
            ret = self.__dll.ZCAN_ReadChannelErrInfo(chn_handle, byref(ErrInfo))
            return ErrInfo if ret == ZCAN_STATUS_OK else None
        except:
            print("Exception on ZCAN_ReadChannelErrInfo!")
            raise

    def ReadChannelStatus(self, chn_handle):
        try:
            status = ZCAN_CHANNEL_STATUS()
            ret = self.__dll.ZCAN_ReadChannelStatus(chn_handle, byref(status))
            return status if ret == ZCAN_STATUS_OK else None
        except:
            print("Exception on ZCAN_ReadChannelStatus!")
            raise

    def GetReceiveNum(self, chn_handle, can_type=ZCAN_TYPE_CAN):
        try:
            return self.__dll.ZCAN_GetReceiveNum(chn_handle, can_type)
        except:
            print("Exception on ZCAN_GetReceiveNum!")
            raise

    def Transmit(self, chn_handle, std_msg, len):
        try:
            return self.__dll.ZCAN_Transmit(chn_handle, byref(std_msg), len)
        except:
            print("Exception on ZCAN_Transmit!")
            raise

    def Receive(self, chn_handle, rcv_num, wait_time=c_int(-1)):
        try:
            rcv_can_msgs = (ZCAN_Receive_Data * rcv_num)()
            ret = self.__dll.ZCAN_Receive(chn_handle, byref(rcv_can_msgs), rcv_num, wait_time)
            return rcv_can_msgs, ret
        except:
            print("Exception on ZCAN_Receive!")
            raise

    def TransmitFD(self, chn_handle, fd_msg, len):
        try:
            return self.__dll.ZCAN_TransmitFD(chn_handle, byref(fd_msg), len)
        except:
            print("Exception on ZCAN_TransmitFD!")
            raise

    def ReceiveFD(self, chn_handle, rcv_num, wait_time=c_int(-1)):
        try:
            rcv_canfd_msgs = (ZCAN_ReceiveFD_Data * rcv_num)()
            ret = self.__dll.ZCAN_ReceiveFD(chn_handle, byref(rcv_canfd_msgs), rcv_num, wait_time)
            return rcv_canfd_msgs, ret
        except:
            print("Exception on ZCAN_ReceiveFD!")
            raise

    def GetIProperty(self, device_handle):
        try:
            self.__dll.GetIProperty.restype = POINTER(IProperty)
            return self.__dll.GetIProperty(device_handle)
        except:
            print("Exception on ZCAN_GetIProperty!")
            raise

    def SetValue(self, iproperty, path, value):
        try:
            func = CFUNCTYPE(c_uint, c_char_p, c_char_p)(iproperty.contents.SetValue)
            return func(c_char_p(path.encode("utf-8")), c_char_p(value.encode("utf-8")))
        except:
            print("Exception on IProperty SetValue")
            raise

    def SetValue1(self, iproperty, path, value):  #############################
        try:
            func = CFUNCTYPE(c_uint, c_char_p, c_char_p)(iproperty.contents.SetValue)
            return func(c_char_p(path.encode("utf-8")), c_void_p(value))
        except:
            print("Exception on IProperty SetValue")
            raise

    def GetValue(self, iproperty, path):
        try:
            func = CFUNCTYPE(c_char_p, c_char_p)(iproperty.contents.GetValue)
            return func(c_char_p(path.encode("utf-8")))
        except:
            print("Exception on IProperty GetValue")
            raise

    def ReleaseIProperty(self, iproperty):
        try:
            return self.__dll.ReleaseIProperty(iproperty)
        except:
            print("Exception on ZCAN_ReleaseIProperty!")
            raise


def canfd_start(zcanlib, device_handle, chn, AutoCAN_A, AutoCAN_B, AutoCAN_B_delay):
    ip = zcanlib.GetIProperty(device_handle)
    ret = zcanlib.SetValue(ip, str(chn) + "/canfd_standard", "0")
    if ret != ZCAN_STATUS_OK:
        print("Set CH%d CANFD standard failed!" % (chn))
        exit(0)
    ret = zcanlib.SetValue(ip, str(chn) + "/initenal_resistance", "1")
    if ret != ZCAN_STATUS_OK:
        print("Open CH%d resistance failed!" % (chn))
        exit(0)
    ret = zcanlib.SetValue(ip, str(chn) + "/canfd_abit_baud_rate", "500000")  # 设置波特率
    ret = zcanlib.SetValue(ip, str(chn) + "/canfd_dbit_baud_rate", "2000000")
    if ret != ZCAN_STATUS_OK:
        print("Set CH%d baud failed!" % (chn))
        exit(0)

    ret = zcanlib.SetValue(ip, "0/set_cn", "A001")
    if ret == ZCAN_STATUS_OK:
        t = zcanlib.GetValue(ip, "0/get_cn/1")
        print(type(t))
        print(str(t))

    chn_init_cfg = ZCAN_CHANNEL_INIT_CONFIG()
    chn_init_cfg.can_type = ZCAN_TYPE_CANFD
    chn_init_cfg.config.canfd.mode = 0
    chn_handle = zcanlib.InitCAN(device_handle, chn, chn_init_cfg)
    if chn_handle == 0:
        print("initCAN failed!" % (chn))
        exit(0)
    ###SET filter
    ret = zcanlib.SetValue(ip, str(chn) + "/filter_clear", "0")
    if ret != ZCAN_STATUS_OK:
        print("Set CH%d  filter_clear failed!" % (chn))
        exit(0)
    ret = zcanlib.SetValue(ip, str(chn) + "/filter_mode", "0")  # 标准帧滤波
    if ret != ZCAN_STATUS_OK:
        print("Set CH%d  filter_mode failed!" % (chn))
        exit(0)
    ret = zcanlib.SetValue(ip, str(chn) + "/filter_start", "0")
    if ret != ZCAN_STATUS_OK:
        print("Set CH%d  filter_start failed!" % (chn))
        exit(0)
    ret = zcanlib.SetValue(ip, str(chn) + "/filter_end", "0x7FF")
    if ret != ZCAN_STATUS_OK:
        print("Set CH%d  filter_end failed!" % (chn))
        exit(0)
    ret = zcanlib.SetValue(ip, str(chn) + "/filter_mode", "1")  # 扩展帧滤波
    if ret != ZCAN_STATUS_OK:
        print("Set CH%d  filter_mode failed!" % (chn))
        exit(0)
    ret = zcanlib.SetValue(ip, str(chn) + "/filter_start", "0")
    if ret != ZCAN_STATUS_OK:
        print("Set CH%d  filter_start failed!" % (chn))
        exit(0)
    ret = zcanlib.SetValue(ip, str(chn) + "/filter_end", "0x1FFFFFFF")
    if ret != ZCAN_STATUS_OK:
        print("Set CH%d  filter_end failed!" % (chn))
        exit(0)
    ret = zcanlib.SetValue(ip, str(chn) + "/filter_ack", "0")
    if ret != ZCAN_STATUS_OK:
        print("Set CH%d  filter_ack failed!" % (chn))
        exit(0)

    ret = zcanlib.StartCAN(chn_handle)
    if ret != ZCAN_STATUS_OK:
        print("startCAN failed!" % (chn))
        exit(0)

    ### Set Auto Transmit
    ret = zcanlib.SetValue(ip, str(chn) + "/clear_auto_send", "0")
    if ret != ZCAN_STATUS_OK:
        print("Clear CH%d USBCANFD AutoSend failed!" % (chn))
        exit(0)

    path = str(chn) + "/auto_send"
    func = CFUNCTYPE(c_uint, c_char_p, c_void_p)(ip.contents.SetValue)
    ret = func(c_char_p(path.encode("utf-8")), cast(byref(AutoCAN_A), c_void_p))
    ret = func(c_char_p(path.encode("utf-8")), cast(byref(AutoCAN_B), c_void_p))
    path = str(chn) + "/auto_send_param"
    ret = func(c_char_p(path.encode("utf-8")), cast(byref(AutoCAN_B_delay), c_void_p))  # delay 100ms
    '''   
    ret = zcanlib.SetValue(ip,str(chn)+"/apply_auto_send","0")  
    if ret != ZCAN_STATUS_OK:
        print("Apply CH%d USBCANFD AutoSend failed!" %(chn))
        exit(0)
    '''

    zcanlib.ReleaseIProperty(ip)
    return chn_handle

  • zlg_test.py

    #!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2023/3/28 16:46
# @Author  : Shiqiang Wang
# @File    : zlg_test.py
# @Software: PyCharm
# !/usr/bin/python 
# coding=utf-8

from zlgcan import *
import threading

# 线程函数
def input_thread():
   input()


# 配置周立功的CAN信息和通道信息并启动CAN驱动
def config_start_zlg(zcanlib):
    testcantype = 1  # 0:CAN; 1:canfd
    handle = zcanlib.OpenDevice(ZCAN_USBCANFD_MINI, 0, 0)
    if handle == INVALID_DEVICE_HANDLE:
        print("Open CANFD Device failed!")
        exit(0)
    print("device handle:%d." % (handle))

    info = zcanlib.GetDeviceInf(handle)
    print("Device Information:\n%s" % (info))

    # set auto send obj
    AutoCAN_A = ZCAN_AUTO_TRANSMIT_OBJ()
    AutoCAN_B = ZCAN_AUTO_TRANSMIT_OBJ()
    AutoCAN_A.enable = 1  # enable
    AutoCAN_A.index = 0
    AutoCAN_A.interval = 200  # ms
    AutoCAN_A.obj.frame.can_id = 0x100
    AutoCAN_A.obj.transmit_type = 0
    AutoCAN_A.obj.frame.eff = 0
    AutoCAN_A.obj.frame.rtr = 0
    AutoCAN_A.obj.frame.can_dlc = 8
    for j in range(AutoCAN_A.obj.frame.can_dlc):
        AutoCAN_A.obj.frame.data[j] = j

    AutoCAN_B.enable = 1  # enable
    AutoCAN_B.index = 1
    AutoCAN_B.interval = 200  # ms
    AutoCAN_B.obj.frame.can_id = 0x300
    AutoCAN_B.obj.transmit_type = 0
    AutoCAN_B.obj.frame.eff = 0
    AutoCAN_B.obj.frame.rtr = 0
    AutoCAN_B.obj.frame.can_dlc = 8
    for j in range(AutoCAN_B.obj.frame.can_dlc):
        AutoCAN_B.obj.frame.data[j] = j

    AutoCAN_B_delay = ZCANFD_AUTO_TRANSMIT_OBJ_PARAM()
    AutoCAN_B_delay.index = AutoCAN_B.index
    AutoCAN_B_delay.type = 1
    AutoCAN_B_delay.value = 100

    # Start CAN
    chn_handle = canfd_start(zcanlib, handle, 0, AutoCAN_A, AutoCAN_B, AutoCAN_B_delay)
    print("channel handle:%d." % (chn_handle))

    return handle, chn_handle


# 关闭周立功CAN驱动
def zlgcan_close(zcanlib, handle, chn_handle):
    # Close CAN
    ret = zcanlib.ResetCAN(chn_handle)
    if ret == 1:
        print("ResetCAN success! ")
    # Close Device
    ret = zcanlib.CloseDevice(handle)
    if ret == 1:
        print("CloseDevice success! ")


# 发送CAN报文
def send_can_msg(zcanlib, transmit_num):
    # Send CAN Messages
    msgs = (ZCAN_Transmit_Data * transmit_num)()
    for i in range(transmit_num):
        msgs[i].transmit_type = 0  # 0-正常发送，2-自发自收
        msgs[i].frame.eff = 0  # 0-标准帧，1-扩展帧
        msgs[i].frame.rtr = 0  # 0-数据帧，1-远程帧
        msgs[i].frame.can_id = i
        msgs[i].frame.can_dlc = 8
        for j in range(msgs[i].frame.can_dlc):
            msgs[i].frame.data[j] = j
    ret = zcanlib.Transmit(chn_handle, msgs, transmit_num)
    print("Tranmit Num: %d." % ret)


# 发送CAN FD报文
def send_canfd_msg(zcanlib, transmit_num):
    # Send CANFD Messages
    transmit_canfd_num = 10
    canfd_msgs = (ZCAN_TransmitFD_Data * transmit_canfd_num)()
    for i in range(transmit_num):
        canfd_msgs[i].transmit_type = 0  # 0-正常发送，2-自发自收
        canfd_msgs[i].frame.eff = 0  # 0-标准帧，1-扩展帧
        canfd_msgs[i].frame.rtr = 0  # 0-数据帧，1-远程帧
        canfd_msgs[i].frame.brs = 1  # BRS 加速标志位：0不加速，1加速
        canfd_msgs[i].frame.can_id = i
        canfd_msgs[i].frame.len = 8
        for j in range(canfd_msgs[i].frame.len):
            canfd_msgs[i].frame.data[j] = j
    ret = zcanlib.TransmitFD(chn_handle, canfd_msgs, transmit_canfd_num)
    print("Tranmit CANFD Num: %d." % ret)


if __name__ == "__main__":
    # 创建zlgcan库句柄
    zcanlib = ZCAN()
    # 创建can和通道的句柄
    handle, chn_handle = config_start_zlg(zcanlib)
    # 设置发送数据次数
    transmit_num = 10
    # 发送CAN报文
    send_can_msg(zcanlib, transmit_num)
    # 发送CANFD报文
    send_canfd_msg(zcanlib, transmit_num)

    # 创建线程
    thread = threading.Thread(target=input_thread)
    thread.start()

    # 接受CAN/CANFD报文
    while True:
        rcv_num = zcanlib.GetReceiveNum(chn_handle, ZCAN_TYPE_CAN)
        rcv_canfd_num = zcanlib.GetReceiveNum(chn_handle, ZCAN_TYPE_CANFD)
        if rcv_num:
            print("Receive CAN message number:%d" % rcv_num)
            rcv_msg, rcv_num = zcanlib.Receive(chn_handle, rcv_num)
            for i in range(rcv_num):
                print("[%d]:timestamps:%d,type:CAN, id:%s, dlc:%d, eff:%d, rtr:%d, data:%s" % (i, rcv_msg[i].timestamp,
                                                                                               hex(rcv_msg[
                                                                                                       i].frame.can_id),
                                                                                               rcv_msg[i].frame.can_dlc,
                                                                                               rcv_msg[i].frame.eff,
                                                                                               rcv_msg[i].frame.rtr,
                                                                                               ''.join(hex(rcv_msg[
                                                                                                               i].frame.data[
                                                                                                               j]) + ' '
                                                                                                       for j in range(
                                                                                                   rcv_msg[
                                                                                                       i].frame.can_dlc))))
        elif rcv_canfd_num:
            print("Receive CANFD message number:%d" % rcv_canfd_num)
            rcv_canfd_msgs, rcv_canfd_num = zcanlib.ReceiveFD(chn_handle, rcv_canfd_num, 1000)
            for i in range(rcv_canfd_num):
                print("[%d]:timestamp:%d,type:canfd, id:%s, len:%d, eff:%d, rtr:%d, esi:%d, brs: %d, data:%s" % (
                    i, rcv_canfd_msgs[i].timestamp, hex(rcv_canfd_msgs[i].frame.can_id), rcv_canfd_msgs[i].frame.len,
                    rcv_canfd_msgs[i].frame.eff, rcv_canfd_msgs[i].frame.rtr,
                    rcv_canfd_msgs[i].frame.esi, rcv_canfd_msgs[i].frame.brs,
                    ''.join(hex(rcv_canfd_msgs[i].frame.data[j]) + ' ' for j in range(rcv_canfd_msgs[i].frame.len))))
        else:
            if not thread.is_alive():
                break

    # 关闭周立功
    zlgcan_close(zcanlib, handle, chn_handle)

五、运行结果

在这里插入图片描述

_长风_
关注
专栏目录
Python基于周立功盒子接收特定报文信号并实时绘制折线图（一）
wsq119的博客
03-28 1651
为了节省成本，最大限度利用资源，放弃了用Vector的盒子，采用周立功盒子来做二次开发，以方便来进行压力测试。是一样的，我们只是新改了业务代码zlg_test.py文件，以下是zlg_test.py文件的实现。
Python基于周立功盒子的二次开发的准备工作
wsq119的博客
03-28 3790
基于周立功的二次开发是python通过调用zlgcan.dll，来实现CAN卡的通讯收发报文的，在python中通过ctypes模块调用c++动态库的接口函数（zlgcan.dll），我们需要根据我的电脑选择相对应版本的dll，比如64位的操作系统安装的64位的Python，那么就需要最新的64位的zlgcan.dll，否则在运行时会报错。三、下载地址和示例的说明。
周立功canfd python API
02-15
周立功canfd api文档和demo
周立功USBCAN-II的Python调用
热门推荐
weifengdq的专栏
06-02 1万+
USBCAN-II USBCAN-II, 或者叫USBCAN2是周立功(致远电子)比较经典的USB接口的CAN卡, 有两路标准CAN, 最高支持到1M波特率, 单用USB就可以供电通信, 无内部终端电阻: 上位机ZCANPRO本身功能强大, 基本的收发报文, 总线负载率, 录包回放, 实时曲线, 脚本, UDS等支持的非常完善, 但本篇还是要写一下Python和USBCAN2的联动. ZLG提供了两种 二次开发函数库与例程: zlgcan, 比较新, 官方推荐, 本篇也用这个 ControlCAN, 旧接
python 控制周立功
最新发布
weixin_40876272的博客
07-28 73
python相关学习资料：https://edu.51cto.com/video/4102.htmlhttps://edu.51cto.com/video/3832.htmlhttps://edu.51cto.com/video/3502.htmlPython 控制周立功：一个简单的自动化示例 在当今的软件开发领域，...
周立功zlgcan二次开发库以及接口函数使用手册
11-27
周立功zlgcan二次开发库以及接口函数使用手册 ；包含64位与32位，需要的可以那走
Python调用周立功CAN接口卡接口库函数
yy123xiang的专栏
03-22 1万+
偶尔会用到周立功CAN接口卡，于是试着使用Python调用其接口函数。查阅CAN测试软件与接口函数使用手册，只讲述了VC和VB的调用方法。在这里通过ctypes模块导入动态链接库并访问动态链接库中的函数。 以USBCAN1接口卡，500k波特率，发送一帧数据为例，代码如下： from ctypes import * class _VCI_INIT_CONFIG(Structure): ...
周立功CAN卡二次开发（Labview）,支持PCI_CAN、USB_CAN、TCP_CAN等多种型号
08-20
周立功CAN卡应用较为广泛，性能稳定，本资源提供一种labview环境下，更为简洁和实用的CAN卡应用案例，支持目前周立功绝大对数主流CAN卡，可通过INI文件进行CAN卡的离线配置，做二次程序开发时更为方便和简洁
周立功can设备驱动 二次开发(收发线程)python
yigedadabing的博客
04-23 722
周立功can设备
基于Python的周立功CAN上位机
如有侵权，请联系作者删除
10-12 1万+
进行开发该上位机可大大节省开发时间。本篇博客主要介绍一下基于。当然，《创芯科技》厂家也提供了上位机和基于。为了节省开发时间，我们选用的源码为。工具具备之后，我们正式开始用。会很麻烦，所以本文主要介绍。《创芯科技》开发的上位机。针对《创芯科技》型号为。
周立功USBCAN二次开发套件——供C#开发使用
04-26
这个是周立功官网给出的USBCAN二次开发套件库。内含文件ControlCAN.dll等
周立功USBCAN二次开发套件库-供vc开发使用
04-26
这个是在vc 环境下使用的周立功USBCAN 二次开发套件库
基于labview的周立功程序开发可二次开发
08-19
此程序是基于labveiw的周立功demo程序，可进行二次开发，接受报文和发送报文数据。
周立功CAN卡 C#二次开发
02-13
周立功CAN卡 C#二次开发 注释与源码
周立功CANFD盒子配套上位机和相关二次开发资料
06-12
资源包括ZCANPRO上位机软件，驱动说明，demo，二次开发库等资料
Python实现Can接收发送 DBC分析报文 周立功ZLG 绘制曲线 支持离线回放.rar
06-12
Python实现Can接收发送 DBC分析报文 绘制曲线 支持离线回放 CAN分析工具 环境：windows & python3 设备：周立功USBCAN-I（可在源码中修改支持更多设备） 多种周立功CAN设备 发送数据 导入DBC文件 数据保存（csv） 数据可视化 模块
【如何学习CAN总线测试】——Python基于周立功ZCANPRO开发刷写脚本
测试领域技术分享
07-09 1万+
ZCANPRO官方版是一款十分出色的配套软件，ZCANPRO官方版界面美观大方，功能强劲实用，可进行原始数据收发、数据回放、高层协议分析等操作，是进行CAN总线测试、监控、诊断、开发的好帮手。功能介绍ZCANPRO官方版主界面分为工具栏、子视图和基本界面操作三大部分，具体如下：1. 工具栏：包括的功能有设备管理、新建视图、发送数据、触发配置、通道利用率、数据统计、数据回放、自动化测试和工具;
QT 周立功 can分析仪 二次开发
dongwu123的专栏
05-19 1883
QT 周立功 can分析仪 二次开发 2 在工程中添加 LIBS += -L"D:\QtProject\V501MCU\ControlCANx86" -lControlCAN 3 测试设备打开 if (VCI_OpenDevice(1, 0, 0) != STATUS_OK) { QMessageBox::information(this, "提示", "打开设备失败", QMessageBox::Ok); return; } 4 遇到的问题 测试...
python基于周立功盒子的二次开发
05-26
周立功盒子是一款基于Python的硬件设备，可以用于物联网、智能家居、机器人等应用领域。它提供了一些基础的硬件接口和Python库，使得开发者可以快速地开发并部署自己的应用程序。 如果你想进行基于周立功盒子的二次开发，你需要先了解周立功盒子的硬件结构和接口，然后使用Python编写自己的应用程序。 周立功盒子提供了一些基础的硬件接口，例如GPIO、PWM、ADC、I2C、SPI等。这些接口可以通过Python库进行控制和操作。同时，周立功盒子还提供了一些传感器和执行器，例如LED灯、温度传感器、舵机等，可以直接与这些硬件进行交互。 在进行二次开发时，你需要使用Python编写自己的应用程序，并调用周立功盒子提供的库进行硬件控制和操作。具体的开发流程可以参考周立功盒子的官方文档，其中包括了详细的硬件接口说明和示例代码。 总之，基于周立功盒子的二次开发需要掌握Python编程和硬件控制相关知识，同时熟悉周立功盒子的硬件结构和接口。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

_长风_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值