Python用户收藏Jira数据并收发消息

共7步：
 
1.读取动态链接库
 
2.VCI_OpenDevice 打开设备
 
3.VCI_InitCAN 初始化指定CAN通道
 
4.VCI_StartCAN 打开指定CAN通道
 
5.VCI_Transmit 发送数据
 
6.VCI_Receive 接收数据
 
7.VCI_CloseDevice 关闭设备
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.

from ctypes import *

STATUS_OK = 1
RESERVED = 0  # 保留字段

"""1.读取动态链接库"""
# 依赖的DLL文件(存放在根目录下)
CAN_DLL_PATH = './ControlCAN.dll'
# 读取DLL文件
Can_DLL = windll.LoadLibrary(CAN_DLL_PATH)


"""2.VCI_OpenDevice 打开设备"""
# 打开设备, 一个设备只能打开一次
# return: 1=OK 0=ERROR
def connect(VCI_USB_CAN_2, DEV_INDEX):
    # VCI_USB_CAN_2: 设备类型
    # DEV_INDEX:     设备索引
    # RESERVED:      保留参数
    ret = Can_DLL.VCI_OpenDevice(VCI_USB_CAN_2, DEV_INDEX, RESERVED)
    if ret == STATUS_OK:
        print('VCI_OpenDevice: 设备开启成功')
    else:
        print('VCI_OpenDevice: 设备开启失败')
    return ret


"""3.VCI_InitCAN 初始化指定CAN通道"""
# 通道初始化参数结构
# AccCode:  过滤验收码
# AccMask:  过滤屏蔽码
# Reserved: 保留字段
# Filter:   滤波模式 0/1=接收所有类型 2=只接收标准帧 3=只接收扩展帧
# Timing0:  波特率 T0
# Timing1:  波特率 T1
# Mode:     工作模式 0=正常工作 1=仅监听模式 2=自发自收测试模式
class VCI_CAN_INIT_CONFIG(Structure):
    _fields_ = [
        ("AccCode", c_uint),
        ("AccMask", c_uint),
        ("Reserved", c_uint),
        ("Filter", c_ubyte),
        ("Timing0", c_ubyte),
        ("Timing1", c_ubyte),
        ("Mode", c_ubyte)
    ]

# 过滤验收码
ACC_CODE = 0x80000000

# 过滤屏蔽码
ACC_MASK = 0xFFFFFFFF

# 滤波模式 0/1=接收所有类型
FILTER = 0

# 波特率 T0
TIMING_0 = 0x03

# 波特率 T1
TIMING_1 = 0x1C

# 工作模式 0=正常工作
MODE = 0

# 初始化通道
# return: 1=OK 0=ERROR
def init(VCI_USB_CAN_2, DEV_INDEX, can_index):
    init_config = VCI_CAN_INIT_CONFIG(ACC_CODE, ACC_MASK, RESERVED, FILTER, TIMING_0, TIMING_1, MODE)
    # VCI_USB_CAN_2: 设备类型
    # DEV_INDEX:     设备索引
    # can_index:     CAN通道索引
    # init_config:   请求参数体
    ret = Can_DLL.VCI_InitCAN(VCI_USB_CAN_2, DEV_INDEX, can_index, byref(init_config))
    if ret == STATUS_OK:
        print('VCI_InitCAN: 通道 ' + str(can_index + 1) + ' 初始化成功')
    else:
        print('VCI_InitCAN: 通道 ' + str(can_index + 1) + ' 初始化失败')
    return ret


"""4.VCI_StartCAN 打开指定CAN通道"""
# 打开通道
# return: 1=OK 0=ERROR
def start(VCI_USB_CAN_2, DEV_INDEX, can_index):
    # VCI_USB_CAN_2: 设备类型
    # DEV_INDEX:     设备索引
    # can_index:     CAN通道索引
    ret = Can_DLL.VCI_StartCAN(VCI_USB_CAN_2, DEV_INDEX, can_index)
    if ret == STATUS_OK:
        print('VCI_StartCAN: 通道 ' + str(can_index + 1) + ' 打开成功')
    else:
        print('VCI_StartCAN: 通道 ' + str(can_index + 1) + ' 打开失败')
    return ret


"""5.VCI_Transmit 发送数据"""
# CAN帧结构体
# ID:         帧ID, 32位变量, 数据格式为靠右对齐
# TimeStamp:  设备接收到某一帧的时间标识, 时间标示从CAN卡上电开始计时, 计时单位为0.1ms
# TimeFlag:   是否使用时间标识, 为1时TimeStamp有效, TimeFlag和TimeStamp只在此帧为接收帧时才有意义
# SendType:   发送帧类型 0=正常发送(发送失败会自动重发, 重发时间为4秒, 4秒内没有发出则取消) 1=单次发送(只发送一次, 发送失败不会自动重发, 总线只产生一帧数据)[二次开发, 建议1, 提高发送的响应速度]
# RemoteFlag: 是否是远程帧 0=数据帧 1=远程帧(数据段空)
# ExternFlag: 是否是扩展帧 0=标准帧(11位ID) 1=扩展帧(29位ID)
# DataLen:    数据长度DLC(<=8), 即CAN帧Data有几个字节, 约束了后面Data[8]中的有效字节
# Data:       CAN帧的数据, 由于CAN规定了最大是8个字节, 所以这里预留了8个字节的空间, 受DataLen约束, 如DataLen定义为3, 即Data[0]、Data[1]、Data[2]是有效的
# Reserved:   保留字段
class VCI_CAN_OBJ(Structure):
    _fields_ = [
        ("ID", c_uint),
        ("TimeStamp", c_uint),
        ("TimeFlag", c_ubyte),
        ("SendType", c_ubyte),
        ("RemoteFlag", c_ubyte),
        ("ExternFlag", c_ubyte),
        ("DataLen", c_ubyte),
        ("Data", c_ubyte * 8),
        ("Reserved", c_ubyte * 3)
    ]

# 发送帧ID
TRANSMIT_ID = 0x1

# 接收帧ID
RECEIVE_ID = 0x0

# 时间标识
TIME_STAMP = 0

# 是否使用时间标识
TIME_FLAG = 0

# 发送帧类型
TRANSMIT_SEND_TYPE = 1

# 接收帧类型
RECEIVE_SEND_TYPE = 0

# 是否是远程帧
REMOTE_FLAG = 0

# 是否是扩展帧
EXTERN_FLAG = 0

# 数据长度DLC
DATA_LEN = 8

# 用来接收的帧结构体数组的长度, 适配器中为每个通道设置了2000帧左右的接收缓存区
RECEIVE_LEN = 2500

# 接收保留字段
WAIT_TIME = 0

# 要发送的帧结构体数组的长度(发送的帧数量), 最大为1000, 建议设为1, 每次发送单帧, 以提高发送效率
TRANSMIT_LEN = 1

# 发送数据
# return: 1=OK 0=ERROR
def transmit(VCI_USB_CAN_2, DEV_INDEX, can_index, TRANSMIT_DATA01, TRANSMIT_DATA02, TRANSMIT_DATA03, TRANSMIT_DATA04, TRANSMIT_DATA05, TRANSMIT_DATA06, TRANSMIT_DATA07, TRANSMIT_DATA08):  # TRANSMIT_DATA01~TRANSMIT_DATA08为要发送的8个字节的数据
    ubyte_array_8 = c_ubyte * 8
    DATA = ubyte_array_8(TRANSMIT_DATA01, TRANSMIT_DATA02, TRANSMIT_DATA03, TRANSMIT_DATA04, TRANSMIT_DATA05, TRANSMIT_DATA06, TRANSMIT_DATA07, TRANSMIT_DATA08)
    ubyte_array_3 = c_ubyte * 3
    RESERVED_3 = ubyte_array_3(RESERVED, RESERVED, RESERVED)
    can_obj = VCI_CAN_OBJ(TRANSMIT_ID, TIME_STAMP, TIME_FLAG, TRANSMIT_SEND_TYPE, REMOTE_FLAG, EXTERN_FLAG, DATA_LEN, DATA, RESERVED_3)
    # VCI_USB_CAN_2: 设备类型
    # DEV_INDEX:     设备索引
    # can_index:     CAN通道索引
    # can_obj:       请求参数体
    # TRANSMIT_LEN:  发送的帧数量
    ret = Can_DLL.VCI_Transmit(VCI_USB_CAN_2, DEV_INDEX, can_index, byref(can_obj), TRANSMIT_LEN)
    if ret == STATUS_OK:
        print('VCI_Transmit: 通道 ' + str(can_index + 1) + ' 发送数据成功')
    else:
        print('VCI_Transmit: 通道 ' + str(can_index + 1) + ' 发送数据成功')

"""6.VCI_Receive 接收数据"""
# 接收数据
# return: 1=OK 0=ERROR
def receive(VCI_USB_CAN_2, DEV_INDEX, can_index):
    ubyte_array_8 = c_ubyte * 8
    DATA = ubyte_array_8(RESERVED, RESERVED, RESERVED, RESERVED, RESERVED, RESERVED, RESERVED, RESERVED)
    ubyte_array_3 = c_ubyte * 3
    RESERVED_3 = ubyte_array_3(RESERVED, RESERVED, RESERVED)
    # 参数结构参考122行
    can_obj = VCI_CAN_OBJ(RECEIVE_ID, TIME_STAMP, TIME_FLAG, RECEIVE_SEND_TYPE, REMOTE_FLAG, EXTERN_FLAG, DATA_LEN, DATA, RESERVED_3)
    # VCI_USB_CAN_2: 设备类型
    # DEV_INDEX:     设备索引
    # can_index:     CAN通道索引
    # can_obj:       请求参数体
    # RECEIVE_LEN:   用来接收帧结构体数组的长度
    # WAIT_TIME:     保留参数
    ret = Can_DLL.VCI_Receive(VCI_USB_CAN_2, DEV_INDEX, can_index, byref(can_obj), RECEIVE_LEN, WAIT_TIME)
    while ret != STATUS_OK:
        print('VCI_Receive: 通道 ' + str(can_index + 1) + ' 接收数据失败, 正在重试')
        ret = Can_DLL.VCI_Receive(VCI_USB_CAN_2, DEV_INDEX, can_index, byref(can_obj), RECEIVE_LEN, WAIT_TIME)
    else:
        print('VCI_Receive: 通道 ' + str(can_index + 1) + ' 接收数据成功')
        print('ID: ', can_obj.ID)
        print('DataLen: ', can_obj.DataLen)
        print('Data: ', list(can_obj.Data))
    return ret

"""7.关闭已打开的USB-CAN适配器"""
def close(VCI_USB_CAN_2, DEV_INDEX):
    Can_DLL.VCI_CloseDevice(VCI_USB_CAN_2, DEV_INDEX)
    print("VCI_CloseDevice: 设备关闭成功")

if __name__ == '__main__':
    # CAN卡类别为 USBCAN-2A, USBCAN-2C, CANalyst-II
    VCI_USB_CAN_2 = 4

    # CAN卡下标索引, 比如当只有一个USB-CAN适配器时, 索引号为0, 这时再插入一个USB-CAN适配器那么后面插入的这个设备索引号就是1, 以此类推
    DEV_INDEX = 0

    CAN_INDEX_1 = 0
    CAN_INDEX_2 = 1

    connect(VCI_USB_CAN_2, DEV_INDEX)
    # 初始化CAN1
    init(VCI_USB_CAN_2, DEV_INDEX, CAN_INDEX_1)
    # 启动CAN1
    start(VCI_USB_CAN_2, DEV_INDEX, CAN_INDEX_1)
    # 初始化CAN2
    init(VCI_USB_CAN_2, DEV_INDEX, CAN_INDEX_2)
    # 启动CAN2
    start(VCI_USB_CAN_2, DEV_INDEX, CAN_INDEX_2)
    # CAN1发送数据
    transmit(VCI_USB_CAN_2, DEV_INDEX, CAN_INDEX_1, 0x01, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18)
    transmit(VCI_USB_CAN_2, DEV_INDEX, CAN_INDEX_1, 0x03, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18)
    # CAN2接收数据
    receive(VCI_USB_CAN_2, DEV_INDEX, CAN_INDEX_2)
    receive(VCI_USB_CAN_2, DEV_INDEX, CAN_INDEX_2)
    # 关闭设备
    close(VCI_USB_CAN_2, DEV_INDEX)
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.
110.
111.
112.
113.
114.
115.
116.
117.
118.
119.
120.
121.
122.
123.
124.
125.
126.
127.
128.
129.
130.
131.
132.
133.
134.
135.
136.
137.
138.
139.
140.
141.
142.
143.
144.
145.
146.
147.
148.
149.
150.
151.
152.
153.
154.
155.
156.
157.
158.
159.
160.
161.
162.
163.
164.
165.
166.
167.
168.
169.
170.
171.
172.
173.
174.
175.
176.
177.
178.
179.
180.
181.
182.
183.
184.
185.
186.
187.
188.
189.
190.
191.
192.
193.
194.
195.
196.
197.
198.
199.
200.
201.
202.
203.
204.
205.
206.
207.
208.
209.
210.
211.
212.
213.
214.
215.
216.
217.
218.
219.
220.
221.
222.
223.
224.
225.
226.
227.
228.
229.
230.
231.
232.
233.
234.

def receive(VCI_USB_CAN_2, DEV_INDEX, can_index):
        receive_len = 2500
        vci_can_array = VCI_CAN_OBJ * receive_len
        vci_can_obj = vci_can_array(VCI_CAN_OBJ())
        while True:
            while Can_DLL.VCI_GetReceiveNum(VCI_USB_CAN_2, DEV_INDEX, can_index) == 0:
                continue

            receive_res = Can_DLL.VCI_Receive(VCI_USB_CAN_2, DEV_INDEX, can_index, byref(vci_can_obj), RECEIVE_LEN, WAIT_TIME)
            # print("receive_res",receive_res)
            if receive_res > 0:
                for i in range(receive_res):
                    # print(hex(vci_can_obj[i].ID))
                    # print(list(vci_can_obj[i].Data))
                    yield hex(vci_can_obj[i].ID), list(vci_can_obj[i].Data)
            else:
                print("接收区缓存区为空")
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.