python-can-hirain-test 0.1.1__py3-none-any.whl

can_hirain/__init__.py

@@ -0,0 +1,3 @@
+from .hrcan import HRCANBus
+
+__all__ = ["HRCANBus"]

can_hirain/hrcan.py

@@ -0,0 +1,655 @@
+import ctypes
+import can
+from can import BusABC, Message
+import threading
+import queue
+import time
+from can.util import load_config
+import warnings
+from can import BusABC, interface
+
+from . import BasicStructure
+from .TestBaseVCI import *
+from .config import *
+
+ProjectStartTime = time.time()
+HwStartTime = dict()
+
+
+# class CyclicSendTask(can.broadcastmanager.CyclicSendTaskABC):
+#     def __init__(self, vci_msg, port_handle, channel_index):
+#         self._vci_msg = vci_msg
+#         self._port = port_handle
+#         self._channel_index = channel_index
+#
+#     def stop(self):
+#         ptxinfo = BasicStructure.CanPeriodTxInfo()
+#         ptxinfo.canMsg = self._vci_msg
+#         ptxinfo.usPeriod = 0
+#         ret = can_set_periodic_tx_msgs(self._port, self._channel_index, ptxinfo)
+
+def get_tosun_hw_devices_info():
+    channels = get_driver_config()  # 现在返回 List[Dict]
+    device_dict = {}  # {设备名: [(数组下标, pythoncan_idx, vci通道索引)]}
+    pc_idx = 0
+
+    for i, ch in enumerate(channels):
+        if ch['bus_capabilities'] == 3:  # CAN/CANFD
+            device_name = ch['hw_name']
+            if device_name not in device_dict:
+                device_dict[device_name] = [(i, pc_idx, ch['channel_index'])]
+            else:
+                device_dict[device_name].append((i, pc_idx, ch['channel_index']))
+            # 原 get_tosun 无 pc_idx 自增，此处保持原逻辑
+
+    if len(device_dict) == 0:
+        return {}
+
+    device_info_list = {}
+    device_idx = 0
+    for device_name in device_dict:
+        device_info = {
+            "manufacturer": "HIRAIN",
+            "product": "TestBaseVCI",
+            "Serial": device_name,
+            "device_type": "TestBaseVCI",
+            "device_name": device_name,
+            "can_counts": len(device_dict[device_name]),
+            "is_canfd": True,
+            "lin_counts": 0,
+            "fr_counts": 0,
+            "eth_counts": 0
+        }
+        device_info_list[device_idx] = device_info
+        device_idx += 1
+    return device_info_list
+
+
+def get_hr_hw_devices_info():
+    channels = get_driver_config()  # List[Dict]
+    device_dict = {}
+    pc_idx = 0
+
+    for i, ch in enumerate(channels):
+        if ch['bus_capabilities'] == 3:  # CAN/CANFD
+            device_name = ch['hw_name']
+            if device_name not in device_dict:
+                device_dict[device_name] = [(i, pc_idx, ch['channel_index'])]
+            else:
+                device_dict[device_name].append((i, pc_idx, ch['channel_index']))
+            pc_idx += 1  # 原 get_hr 中有自增，保留
+
+    if len(device_dict) == 0:
+        return {}
+
+    device_info_list = {}
+    device_idx = 0
+    for device_name in device_dict:
+        device_info = {
+            "manufacturer": "HIRAIN",
+            "product": "TestBaseVCI",
+            "device_name": device_name,
+            "can_counts": len(device_dict[device_name]),
+            "channel": device_dict[device_name]  # [(下标, pythoncan通道号, vci通道号)]
+        }
+        device_info_list[device_idx] = device_info
+        device_idx += 1
+    return device_info_list
+
+
+# 获取通道字典
+# def get_hr_can_canfd_channels():
+#     driver_config = get_driver_config()
+#     channels = {}
+#     for i in range(driver_config.nChannelCount):
+#         channel = driver_config.h3Channels[i]
+#         if channel.ucBusCapabilities == 3: # CAN/FD通道
+#             channels[("")]
+
+class HRCANBus(BusABC):
+    def __init__(self, channel, **kwargs):
+        super().__init__(channel=channel, **kwargs)
+        self._lock = threading.Lock()
+        self.configs = kwargs.get('configs', [{}])[0]
+        self.channel = channel
+        self.ChannelIdx = channel
+        self.channel_dex = channel
+        self.canids = []
+        self.len_canids = 0
+        self.start_time = 0
+        self.series_num = None
+        self.last_msg_time = 0
+        self.time_cycle = 0
+        self.hr_filter = None
+
+        # 15765诊断第二响应
+        self._response_queue = queue.Queue()
+        self._response_event = threading.Event()
+        self._current_response_data = None
+        self._response_lock = threading.Lock()
+
+        # 支持以同星格式下发的参数
+        self.ts_rate_baudrate = kwargs.get('rate_baudrate', None)
+        self.ts_data_baudrate = kwargs.get('data_baudrate', 2000)
+        self.ts_enable_120hm = kwargs.get('enable_120hm', True)
+        self.ts_is_fd = kwargs.get('is_fd', True)
+        self.is_include_tx = kwargs.get('is_include_tx', True)
+        self.ts_hwserial = kwargs.get('hwserial', None)
+        self.ts_hwserial = self.ts_hwserial.decode('gbk') if isinstance(self.ts_hwserial, bytes) else self.ts_hwserial
+        # 设置报文过滤器
+        filters = kwargs.get('filters', None)
+        if filters and len(filters) > 0:
+            dict_filter = filters[0]  # 暂时只支持设置一个过滤器
+            if dict_filter['extend'] == False:
+                self.hr_filter = (dict_filter['min'], dict_filter['max'])
+            elif dict_filter['extend'] == True:
+                self.hr_filter = (dict_filter['min'] + 0x80000000, dict_filter['max'] + 0x80000000)
+            else:
+                self.hr_filter = None
+
+        if self.ts_rate_baudrate != None and self.configs == {}:  # 仅在下发同星参数名且未下发VCI参数时使用同星参数
+            self.ts_rate_baudrate = 500 if self.ts_rate_baudrate == None else self.ts_rate_baudrate
+            if self.ts_is_fd == True:
+                self.configs = {
+                    'resistance': self.ts_enable_120hm,  # 启用终端电阻
+                    'mode': TestBaseVCI_ChlMode.CANFD,  # 设置CANFD通道
+                    'listenFlag': 0,  # 0-正常状态，1-通道为仅监听状态，不给ACK响应
+                    'abrBaudrate': self.ts_rate_baudrate * 1000,
+                    'dbrBaudrate': self.ts_data_baudrate * 1000,
+                    'abrSamplePoint': TestBaseVCI_SAMPLEPOINT.SAMPLE_75,
+                    'dbrSamplePoint': TestBaseVCI_SAMPLEPOINT.SAMPLE_75}
+            else:
+                self.configs = {
+                    'resistance': self.ts_enable_120hm,  # 启用终端电阻
+                    'mode': TestBaseVCI_ChlMode.CAN,  # 设置CAN通道
+                    'listenFlag': 0,  # 0-正常状态，1-通道为仅监听状态，不给ACK响应
+                    'baudrate': self.ts_rate_baudrate * 1000,
+                    'samplePoint': TestBaseVCI_SAMPLEPOINT.SAMPLE_75}
+        # 匹配通道号
+        devices = get_hr_hw_devices_info()
+        b_find_device = False
+        for key, value in devices.items():
+            if value['device_name'] == self.ts_hwserial and self.channel < len(value['channel']):
+                self.channel = value['channel'][self.channel][1]
+                self.channel_dex = self.channel
+                b_find_device = True
+        if self.ts_hwserial != None and not b_find_device:
+            raise can.CanError(f"Failed to find device: {self.ts_hwserial}")
+
+        if self._get_param_with_warning('mode', 0) == 0:
+            self.can_init()
+        else:
+            self.canfd_init()
+
+    def can_init(self):
+        channels = get_driver_config()  # 列表，元素为字典
+        resistance = self._get_param_with_warning('resistance', 1)
+        ListenFlag = self._get_param_with_warning('listenFlag', 0)
+        Baudrate = self._get_param_with_warning('baudrate', 500000)
+        SamplePoint = self._get_param_with_warning('samplePoint', 0)
+
+        for ch in channels:
+            if ch['bus_capabilities'] == 3:
+                if self.channel == 0:
+                    self.channel_index = ch['channel_index']
+                    channel_mask = ch['channel_mask']
+                    self.port_handle = open_port(channel_mask)
+
+                    self.series_num = ch['hw_name']
+                    if self.series_num in HwStartTime:
+                        self.start_time = HwStartTime[self.series_num]
+                    else:
+                        sys_time = time.time()
+                        dev_time = get_device_time_stamp(self.port_handle)  # 新函数返回 int
+                        self.start_time = float(dev_time) - (sys_time - ProjectStartTime) * 1e6
+                        HwStartTime[self.series_num] = self.start_time
+
+                    # active_can_channel 现在返回 bool，参数名改为下划线格式
+                    if not active_can_channel(
+                            self.port_handle,
+                            self.channel_index,
+                            listen_flag=ListenFlag,
+                            baudrate=Baudrate,
+                            sample_point=SamplePoint
+                    ):
+                        raise can.CanError("Failed to activate CAN channel")
+
+                    if resistance == 1:
+                        ret = can_set_resistor(self.port_handle, self.channel_index, True)
+                        if ret != 0:
+                            raise can.CanError(f"Failed to set resistor, code: {ret}")
+
+                    ret = start_stop_trace(self.port_handle, self.channel_index, True)
+                    if ret != 0:
+                        raise can.CanError(f"Failed to start trace, code: {ret}")
+
+                    print(f"Device：{ch['hw_name']} Channel：{self.channel_dex} is open")
+                    self.channel_info = ch['hw_name'] + "-Can" + str(self.channel_dex)
+                    self._is_shutdown = False
+                    break
+                else:
+                    self.channel -= 1
+
+    def canfd_init(self):
+        channels = get_driver_config()
+        resistance = self._get_param_with_warning('resistance', 1)
+        ListenFlag = self._get_param_with_warning('listenFlag', 0)
+        abrBaudrate = self._get_param_with_warning('abrBaudrate', 500000)
+        dbrBaudrate = self._get_param_with_warning('dbrBaudrate', 2000000)
+        abrSamplePoint = self._get_param_with_warning('abrSamplePoint', 0)
+        dbrSamplePoint = self._get_param_with_warning('dbrSamplePoint', 0)
+
+        for ch in channels:
+            if ch['bus_capabilities'] == 3:
+                if self.channel == 0:
+                    self.channel_index = ch['channel_index']
+                    channel_mask = ch['channel_mask']
+                    self.port_handle = open_port(channel_mask)
+
+                    self.series_num = ch['hw_name']
+                    if self.series_num in HwStartTime:
+                        self.start_time = HwStartTime[self.series_num]
+                    else:
+                        sys_time = time.time()
+                        dev_time = get_device_time_stamp(self.port_handle)
+                        self.start_time = float(dev_time) - (sys_time - ProjectStartTime) * 1e6
+                        HwStartTime[self.series_num] = self.start_time
+
+                    nRet = active_canfd_channel(
+                        self.port_handle,
+                        self.channel_index,
+                        listen_flag=ListenFlag,
+                        abr_baudrate=abrBaudrate,
+                        dbr_baudrate=dbrBaudrate,
+                        abr_sample_point=abrSamplePoint,
+                        dbr_sample_point=dbrSamplePoint,
+                    )
+                    if nRet != 0:
+                        raise can.CanError("Failed to activate CANFD channel, code: " + str(nRet))
+
+                    if resistance == 1:
+                        nRet = can_set_resistor(self.port_handle, self.channel_index, True)
+                        if nRet != 0:
+                            raise can.CanError(f"Failed to set resistor, code: {nRet}")
+
+                    nRet = start_stop_trace(self.port_handle, self.channel_index, True)
+                    if nRet != 0:
+                        raise can.CanError(f"Failed to start trace, code: {nRet}")
+
+                    print(f"Device：{ch['hw_name']} Channel：{self.channel_dex} is open")
+                    self.channel_info = ch['hw_name'] + "-Can" + str(self.channel_dex)
+                    self._is_shutdown = False
+                    break
+                else:
+                    self.channel -= 1
+
+    def _get_param_with_warning(self, param_name, default):
+        """统一处理参数获取和警告"""
+        value = self.configs.get(param_name, default)
+        if param_name not in self.configs:
+            warnings.warn(
+                f"配置参数 '{param_name}' 未提供，使用默认值: {default}",
+                UserWarning,
+                stacklevel=2
+            )
+        return value
+
+    def send(self, msg, timeout=None):
+        with self._lock:
+            if not hasattr(self, 'port_handle'):
+                raise can.CanError("Device not initialized")
+
+            # 构建消息并拆解参数调用新接口
+            can_id = (1 << 31) + msg.arbitration_id if msg.is_extended_id else msg.arbitration_id
+            is_fd = msg.is_fd
+            dlc = self._len_to_dlc(msg.dlc)
+            brs = msg.bitrate_switch if is_fd else 0
+            tx_data = tuple(msg.data)
+
+            ret = can_set_one_tx_msgs(
+                self.port_handle,
+                self.channel_index,
+                can_id=can_id,
+                tx_data=tx_data,
+                is_fd=is_fd,
+                dlc=dlc,
+                brs=brs,
+            )
+            if ret != 0:
+                raise can.CanError("Failed to send CAN message")
+
+    def send_periodic(self, msgs: can.Message, period: float):
+        with self._lock:
+            if not hasattr(self, 'port_handle'):
+                raise can.CanError("Device not initialized")
+
+            # 构建消息参数
+            can_id = (1 << 31) + msgs.arbitration_id if msgs.is_extended_id else msgs.arbitration_id
+            is_fd = msgs.is_fd
+            dlc = self._len_to_dlc(msgs.dlc)
+            brs = msgs.bitrate_switch if is_fd else 0
+            tx_data = tuple(msgs.data)
+
+            # 发送周期报文（删除操作由 period==0 控制，还需根据业务处理）
+            ret = can_set_periodic_tx_msgs(
+                self.port_handle,
+                self.channel_index,
+                can_id=can_id,
+                is_fd=is_fd,
+                dlc=dlc,
+                brs=brs,
+                data=tx_data,
+                period=int(1000 * period)  # 单位根据文档调整
+            )
+            if ret != 0:
+                raise can.CanError("Failed to set periodic message")
+
+            # 管理发送列表（保持原有逻辑）
+            if can_id not in self.canids and period != 0:
+                self.canids.append(can_id)
+                self.len_canids += 1
+                if self.len_canids > 150:
+                    raise can.CanError("Periodic message limit (150) reached.")
+            elif period == 0:
+                if can_id in self.canids:
+                    self.canids.remove(can_id)
+                    self.len_canids -= 1
+                else:
+                    raise can.CanError(f"No active periodic message with ID {can_id}")
+
+            # 返回任务对象（传递必要信息以支持停止周期发送）
+            class CyclicSendTask(can.broadcastmanager.CyclicSendTaskABC):
+                def __init__(self, port, ch_idx, can_id, is_fd, dlc, brs, data):
+                    self._port = port
+                    self._ch_idx = ch_idx
+                    self._can_id = can_id
+                    self._is_fd = is_fd
+                    self._dlc = dlc
+                    self._brs = brs
+                    self._data = data
+
+                def stop(self):
+                    can_set_periodic_tx_msgs(
+                        self._port, self._ch_idx,
+                        can_id=self._can_id, is_fd=self._is_fd,
+                        dlc=self._dlc, brs=self._brs,
+                        data=self._data, period=0
+                    )
+
+            task = CyclicSendTask(self.port_handle, self.channel_index,
+                                  can_id, is_fd, dlc, brs, tx_data)
+            task.arbitration_id = msgs.arbitration_id
+            task.messages = msgs
+            task.period = period
+            task.period_ns = int(period * 1e9)
+            return task
+
+    def stop_all_periodic_tasks(self):
+        while (self.len_canids != 0):
+            msg = can.Message(
+                arbitration_id=self.canids[0],
+            )
+            ret = self.send_periodic(msg, 0)
+            if ret != None:
+                raise can.CanError("stop_all_periodic_tasks")
+
+    # def recv(self, timeout=None):
+    #     with self._lock:
+    #         if not hasattr(self, 'port_handle'):
+    #             raise can.CanError("Device not initialized")
+    #
+    #     start_time = time.time()
+    #     while not self._is_shutdown:
+    #         rx_msg = BasicStructure.RX_SERVICE()
+    #         rx_count = ctypes.c_uint(1)
+    #         n_rst = dll.H3GetRxService(self.port_handle, ctypes.byref(rx_msg), ctypes.byref(rx_count))
+    #         rx_count = rx_count.value
+    #         if rx_count > 0:
+    #             if rx_msg.nServiceType == 8: # CAN报文
+    #                 if not self.is_include_tx and rx_msg.service.getCanTrace.ucTag == 0:
+    #                     continue
+    #                 if self.hr_filter != None:
+    #                     if rx_msg.service.getCanTrace.unCanId < self.hr_filter[0] \
+    #                         or rx_msg.service.getCanTrace.unCanId > self.hr_filter[1]:
+    #                         continue
+    #                 parsed_msg = self._parse_raw_msg(rx_msg)
+    #                 if parsed_msg and not self._is_shutdown:
+    #                     return parsed_msg
+    #                 else:
+    #                     pass
+    #             elif rx_msg.nServiceType == 4: # DIAGRESP报文
+    #                 diag_msg = rx_msg.service.get15765_2_RespInd
+    #                 with self._response_lock:
+    #                     # 存储响应数据
+    #                     self._current_response_data = {
+    #                         'data': diag_msg.ucData[:diag_msg.usLength],
+    #                         'data_len': diag_msg.usLength,
+    #                         'req_id': diag_msg.unEcuRespId,
+    #                     }
+    #                     # 触发等待的事件
+    #                     if len(self._current_response_data['data']) != 3 and \
+    #                             self._current_response_data['data'][2] != 0x78:
+    #                         self._response_event.set()
+    #                     else:
+    #                         print("收到78响应，等待中...")
+    #         # 超时处理
+    #         if timeout is not None:
+    #             if timeout == 0:
+    #                 return None
+    #             if time.time() - start_time >= timeout:
+    #                 return None
+    #         time.sleep(0.001)
+
+    def recv(self, timeout=None):
+        if not hasattr(self, 'port_handle'):
+            raise can.CanError("Device not initialized")
+
+        start_time = time.time()
+        while not self._is_shutdown:
+            # 使用原生接口获取一条报文，返回 List[Dict]
+            msgs = fetch_rx_services(self.port_handle, count=1)
+            if msgs:
+                raw = msgs[0]  # 取第一条，是一个字典
+
+                # 处理 CAN 报文
+                if raw['nServiceType'] == 8:
+                    if not self.is_include_tx and raw['tag'] == 0:
+                        continue  # 忽略自己发送的报文
+                    if self.hr_filter is not None:
+                        if raw['can_id'] < self.hr_filter[0] or raw['can_id'] > self.hr_filter[1]:
+                            continue
+                    parsed = self._parse_raw_msg(raw)  # 传入字典
+                    if parsed and not self._is_shutdown:
+                        return parsed
+
+                # 处理诊断响应（保留原有逻辑）
+                elif raw['nServiceType'] == 4:
+                    with self._response_lock:
+                        self._current_response_data = {
+                            'data': raw['data'],
+                            'data_len': raw['data_len'],
+                            'req_id': raw['req_id'],
+                        }
+                        # 如果不是 0x78 多帧等待，则通知等待的线程
+                        if not (len(self._current_response_data['data']) >= 3 and
+                                self._current_response_data['data'][2] == 0x78):
+                            self._response_event.set()
+                        else:
+                            print("收到 0x78 响应，继续等待...")
+
+                # 其他类型（如错误帧）可在此处补充
+
+            # 超时处理
+            if timeout is not None:
+                if timeout == 0:
+                    return None
+                if time.time() - start_time >= timeout:
+                    return None
+            time.sleep(0.001)
+
+    def _parse_raw_msg(self, raw: dict):
+        """将原生字典转换成 can.Message"""
+        if raw['nServiceType'] == 8:  # CAN 或 CANFD
+            can_id = raw['can_id']
+            dlc = raw['dlc']
+            data_len = self._dlc_to_len(dlc)
+            self.last_msg_time = raw['timestamp']
+            return Message(
+                arbitration_id=can_id & 0x7FFFFFFF,
+                data=bytes(raw['data'][:data_len]),
+                dlc=data_len,
+                is_extended_id=raw['is_extended'],
+                is_rx=(raw['tag'] == 1),
+                is_fd=raw['is_fd'],
+                bitrate_switch=raw['brs'] and raw['is_fd'],
+                timestamp=self._normalize_timestamp(raw['timestamp']),
+                channel=self.channel_dex
+            )
+        elif raw['nServiceType'] == 0:  # 错误帧
+            self.last_msg_time = raw['timestamp']
+            return Message(
+                is_error_frame=True,
+                arbitration_id=0,
+                timestamp=self._normalize_timestamp(raw['timestamp']),
+                channel=self.channel_dex
+            )
+        # 其他类型忽略，返回 None
+        return None
+
+    # def _parse_raw_msg(self, rx_msg):
+    #     """解析消息（兼容正常帧和错误帧）"""
+    #     if rx_msg.nServiceType == 0x8:
+    #         Msg = Message(
+    #             arbitration_id=rx_msg.service.getCanTrace.unCanId & 0x7FFFFFFF,
+    #             data=rx_msg.service.getCanTrace.ucData[:self._dlc_to_len(rx_msg.service.getCanTrace.ucDLC)],
+    #             # data = [rx_msg.service.getCanTrace.ucData[i] for i in range(self._dlc_to_len(rx_msg.service.getCanTrace.ucDLC))],
+    #             dlc=self._dlc_to_len(rx_msg.service.getCanTrace.ucDLC),
+    #             is_extended_id=rx_msg.service.getCanTrace.unCanId >> 31,
+    #             is_rx=rx_msg.service.getCanTrace.ucTag,
+    #             is_fd=rx_msg.service.getCanTrace.ucEDL,
+    #             timestamp=self._normalize_timestamp(rx_msg.service.getCanTrace.unTimestamp),
+    #             channel=self.channel_dex,
+    #             bitrate_switch= rx_msg.service.getCanTrace.ucBRS == 1 and rx_msg.service.getCanTrace.ucEDL == 1,
+    #             is_remote_frame= rx_msg.service.getCanTrace.ucBRS == 1 and rx_msg.service.getCanTrace.ucEDL == 0
+    #         )
+    #         self.last_msg_time = rx_msg.service.getCanTrace.unTimestamp
+    #         return Msg
+    #     elif rx_msg.nServiceType == 0x0:
+    #         self.last_msg_time = rx_msg.service.getCanTrace.unTimestamp
+    #         return Message(
+    #             is_error_frame=True,
+    #             arbitration_id=0x00000000,
+    #             timestamp=self._normalize_timestamp(rx_msg.service.getBusError.unTimestamp),
+    #             channel=self.channel_dex
+    #         )
+    #     else:
+    #         return None
+
+    # def _normalize_timestamp(self, ts):
+    #     """处理时间同步"""
+    #     """处理设备时间戳到工程启动时间"""
+    #     if ts > self.last_msg_time:
+    #         _time = ts - self.start_time
+    #     elif ts + 1 < self.last_msg_time:
+    #         self.time_cycle += 1
+    #         _time = (0xFFFFFFFF & 0xFFFFFFFF) * self.time_cycle + (-1) * (ts - self.start_time)
+    #     else:
+    #         _time = ts - self.start_time
+    #     # 将硬件时间戳转换为秒（假设是微秒
+    #     return _time / 1e
+
+    def _normalize_timestamp(self, ts):
+        """处理时间同步：将设备时间戳转换为工程启动后的相对时间（秒）
+
+        假设设备时间戳是32位微秒计数器（范围0-0xFFFFFFFF），会周期性回绕
+        """
+        # 检测时间戳回绕：当前值小于上一次值且差值超过阈值（0x80000000）
+        if ts < self.last_msg_time and (self.last_msg_time - ts) > 0x80000000:
+            self.time_cycle += 1  # 增加回绕周期计数
+
+        # 计算完整时间戳（考虑回绕周期）
+        full_ts = ts + self.time_cycle * 0x100000000  # 0x100000000 = 2^32
+
+        # 计算相对于工程启动的时间差（微秒）
+        time_delta = full_ts - self.start_time
+
+        # 更新记录的上一个有效时间戳
+        self.last_msg_time = ts
+
+        # 转换为秒（假设时间戳单位是微秒）
+        return time_delta / 1e6
+
+    def _len_to_dlc(self, len):
+        if len <= 8:
+            dlc = len
+        elif len <= 12:
+            dlc = 9
+        elif len <= 16:
+            dlc = 10
+        elif len <= 20:
+            dlc = 11
+        elif len <= 24:
+            dlc = 12
+        elif len <= 32:
+            dlc = 13
+        elif len <= 48:
+            dlc = 14
+        elif len <= 64:
+            dlc = 15
+        return dlc
+
+    def _dlc_to_len(self, dlc):
+        if dlc <= 8:
+            len = dlc
+        elif dlc == 9:
+            len = 12
+        elif dlc == 10:
+            len = 16
+        elif dlc == 11:
+            len = 20
+        elif dlc == 12:
+            len = 24
+        elif dlc == 13:
+            len = 32
+        elif dlc == 14:
+            len = 48
+        elif dlc == 15:
+            len = 64
+        return len
+
+    def shutdown(self):
+        self._is_shutdown = True
+        with self._lock:
+            if not hasattr(self, 'port_handle'):  # 检查是否初始化成功
+                raise can.CanError("Device not initialized")
+        ret = start_stop_trace(self.port_handle, self.channel_index, False)
+        ret = close_port(self.port_handle)
+        # if ret != 0:
+        #     print('关闭端口失败！', '错误码', ret)
+
+    def can_set_param_15765_2(self, Value, Parameter=N_Parameter.N_Bs, MType=CANMType.MTYPE_LOCAL):
+        return can_set_param_15765_2(
+            self.port_handle, self.channel_index,
+            Value=Value, Parameter=Parameter, MType=MType
+        )
+
+    def can_set_diagnostic_config(self, ReqId, FuncReqID, RespId, DataPadding=0xCC):
+        return can_set_diagnostic_config(
+            self.port_handle, self.channel_index,
+            ReqId=ReqId, FuncReqID=FuncReqID, RespId=RespId, DataPadding=DataPadding
+        )
+
+    def can_forward_15765_2(self, ReqId, isFd=False, isBrs=False, Dlc=8,
+                            MType=CANMType.MTYPE_LOCAL, DataLen=2, data=(0x10, 0x01), WaitResp=False):
+        ret_code, resp = can_forward_15765_2(
+            self.port_handle, self.channel_index,
+            req_id=ReqId,
+            is_fd=isFd,
+            is_brs=isBrs,
+            dlc=Dlc,
+            m_type=MType,
+            data_len=DataLen,
+            data=data,
+            wait_resp=WaitResp,
+        )
+        return ret_code, resp