python-can-hirain 0.1.0__py3-none-any.whl

can_hirain/hrcan.py

@@ -0,0 +1,581 @@
+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():
+    driver_config = get_driver_config()
+
+    # 获取设备字典 {HR3230500022: [(i(数组下标), pythoncan_idx(pythoncan通道索引), channel_index(VCI通道索引))]}
+    device_dict = {}
+    pc_idx = 0
+    for i in range(driver_config.nChannelCount):
+        channel = driver_config.h3Channels[i]
+        if channel.ucBusCapabilities == 3: # CAN/CANFD
+            device_name = str(ctypes.string_at(channel.szHwName).decode('gbk'))
+            if  device_name not in device_dict:
+                device_dict[device_name] = [(i, pc_idx, channel.ucChannelIndex)]
+            else:
+                device_dict[device_name].append((i, pc_idx, channel.ucChannelIndex))
+
+    if len(device_dict) == 0:
+        return {}
+
+    # 设备字典转为ToSun字典
+    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, # PythonCAN库不读取无关通道
+            "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():
+    driver_config = get_driver_config()
+
+    # 获取设备字典 {HR3230500022: [(i(数组下标), pythoncan_idx(pythoncan通道索引), channel_index(VCI通道索引))]}
+    device_dict = {}
+    pc_idx = 0
+    for i in range(driver_config.nChannelCount):
+        channel = driver_config.h3Channels[i]
+        if channel.ucBusCapabilities == 3: # CAN/CANFD
+            device_name = str(ctypes.string_at(channel.szHwName).decode('gbk'))
+            if  device_name not in device_dict:
+                device_dict[device_name] = [(i, pc_idx, channel.ucChannelIndex)]
+            else:
+                device_dict[device_name].append((i, pc_idx, channel.ucChannelIndex))
+            pc_idx += 1
+
+    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):
+        driver_config = 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 i in range(driver_config.nChannelCount):
+            if driver_config.h3Channels[i].ucBusCapabilities == 3:
+                if self.channel == 0:
+                    self.channel_index = driver_config.h3Channels[i].ucChannelIndex
+                    channel_mask = driver_config.h3Channels[i].unChannelMask
+                    self.port_handle = open_port(channel_mask)
+
+                    self.series_num = ctypes.string_at(driver_config.h3Channels[i].szHwName)
+                    if self.series_num in HwStartTime:
+                        self.start_time = HwStartTime[self.series_num]
+                    else:
+                        systemTime = time.time()
+                        devTime = get_device_time(self.port_handle)
+                        #float_var = float(c_var.value)
+                        self.start_time = float(devTime.value) - (systemTime - ProjectStartTime) * 1e6
+                        HwStartTime[self.series_num] = self.start_time
+
+                    nRet = active_can_channel(self.port_handle, self.channel_index, ListenFlag=ListenFlag, Baudrate=Baudrate, SamplePoint=SamplePoint)
+                    if nRet != 0:
+                        raise can.CanError(f"Failed to actice 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: " + str(nRet))
+                    nRet = start_stop_trace(self.port_handle, self.channel_index, True)
+                    if nRet != 0:
+                        raise can.CanError(f"Failed to start stop trace, code: " + str(nRet))
+                    print("Device：", driver_config.h3Channels[i].szHwName.decode("utf-8"), "Channel：", self.channel_dex, "is open" )
+                    self.channel_info = driver_config.h3Channels[i].szHwName.decode("utf-8") + "-Can" + str(self.channel_dex)
+                    self._is_shutdown = False
+                    break
+                else:
+                    self.channel -= 1
+
+    def canfd_init(self):
+        driver_config = 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 i in range(driver_config.nChannelCount):
+            if driver_config.h3Channels[i].ucBusCapabilities == 3:
+                if self.channel == 0:
+                    self.channel_index = driver_config.h3Channels[i].ucChannelIndex
+                    channel_mask = driver_config.h3Channels[i].unChannelMask
+                    self.port_handle = open_port(channel_mask)
+
+                    self.series_num = ctypes.string_at(driver_config.h3Channels[i].szHwName)
+                    if self.series_num in HwStartTime:
+                        self.start_time = HwStartTime[self.series_num]
+                    else:
+                        systemTime = time.time()
+                        devTime = get_device_time(self.port_handle)
+                        # float_var = float(c_var.value)
+                        self.start_time = float(devTime.value) - (systemTime - ProjectStartTime) * 1e6
+                        HwStartTime[self.series_num] = self.start_time
+
+                    nRet = active_canfd_channel(self.port_handle, self.channel_index, ListenFlag=ListenFlag, abrBaudrate=abrBaudrate, dbrBaudrate=dbrBaudrate, abrSamplePoint=abrSamplePoint, dbrSamplePoint=dbrSamplePoint)
+                    if nRet != 0:
+                        raise can.CanError(f"Failed to actice 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: " + str(nRet))
+                    nRet = start_stop_trace(self.port_handle, self.channel_index, True)
+                    if nRet != 0:
+                        raise can.CanError(f"Failed to start stop trace, code: " + str(nRet))
+                    print("Device：", driver_config.h3Channels[i].szHwName.decode("utf-8"), "Channel：", self.channel_dex, "is open" )
+                    self.channel_info = driver_config.h3Channels[i].szHwName.decode("utf-8")+ "-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_msg = BasicStructure.GET_CAN_TRACE()
+
+            # 处理参数
+            if msg.is_extended_id:
+                can_msg.unCanId = (1 << 31) + msg.arbitration_id
+            else:
+                can_msg.unCanId = msg.arbitration_id
+            if msg.is_fd:
+                can_msg.ucEDL = 1
+                can_msg.ucBRS = msg.bitrate_switch
+            else:
+                can_msg.ucEDL = 0
+                can_msg.ucBRS = msg.is_remote_frame
+            can_msg.ucData = tuple(msg.data)
+            can_msg.ucDLC = self._len_to_dlc(msg.dlc)
+
+            # 调用公司DLL发送消息
+            ret = can_set_one_tx_msg_no_resp(
+                self.port_handle,
+                self.channel_index,
+                can_msg
+            )
+            if ret != 0:
+                raise can.CanError("Failed to call can_set_one_tx_msg_no_resp.")
+            
+    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_msg = BasicStructure.GET_CAN_TRACE()
+
+            # 处理参数
+            if msgs.is_extended_id and period != 0:
+                can_msg.unCanId = (1 << 31) + msgs.arbitration_id
+            else:
+                can_msg.unCanId = msgs.arbitration_id
+            if msgs.is_fd:
+                can_msg.ucEDL = 1
+                can_msg.ucBRS = msgs.bitrate_switch
+            else:
+                can_msg.ucEDL = 0
+                can_msg.ucBRS = msgs.is_remote_frame
+            can_msg.ucData = tuple(msgs.data)
+            can_msg.ucDLC = self._len_to_dlc(msgs.dlc)
+
+
+            if can_msg.unCanId not in self.canids and period != 0:
+                self.canids.append(can_msg.unCanId)
+                self.len_canids += 1
+                if self.len_canids > 150:
+                    raise can.CanError("Periodic message limit (150) reached.")
+            elif period == 0:
+                if can_msg.unCanId in self.canids:
+                    self.canids.remove(can_msg.unCanId)
+                    self.len_canids -= 1
+                else:
+                    raise can.CanError(f"No active periodic message found with CAN ID {can_msg.unCanId} to delete")
+
+            ptxinfo = BasicStructure.CanPeriodTxInfo()
+            ptxinfo.canMsg = can_msg
+            ptxinfo.usPeriod = ctypes.c_ushort(int(1000 * period))
+            ret = can_set_periodic_tx_msgs(self.port_handle, self.channel_index, ptxinfo)
+
+            if ret != 0:
+                raise can.CanError("Failed to can_set_periodic_tx_msgs")
+
+            task = CyclicSendTask(can_msg, self.port_handle, self.channel_index)
+            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 _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 / 1e6
+
+    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):
+        udsParameter = BasicStructure.CAN_Parameter()
+        udsParameter.ucMType = MType
+        udsParameter.ucParameter = Parameter
+        udsParameter.unValue = Value
+        n_rst = dll.H3CANSetParam15765_2(self.port_handle, self.channel_index, udsParameter)
+        return n_rst
+
+    def can_set_diagnostic_config(self, ReqId, FuncReqID, RespId, DataPadding = 0xCC):
+        # 设置ECU信息
+        ecu_info = (BasicStructure.EcuInfo * 256)()
+        ecu_info[0].unReqID = ReqId
+        ecu_info[0].unUSDTRespID = RespId
+        diagnostic_config = BasicStructure.CAN_DIAGNOSTIC_CONFIG()
+        diagnostic_config.ucDataPadding = DataPadding
+        diagnostic_config.unFuncReqID = FuncReqID
+        diagnostic_config.ucEcuCount = 1
+        diagnostic_config.ecuInfo = ecu_info
+        n_rst = dll.H3CANSetDiagnosticConfig(self.port_handle, self.channel_index, diagnostic_config)
+        return n_rst
+
+    def can_forward_15765_2(self, ReqId, isFd = False, isBrs = False, Dlc = 8,
+                            MType = CANMType.MTYPE_LOCAL, DataLen = 2, data = (0x10, 0x01), WaitResp = False):
+        # 发送报文
+        can_request = BasicStructure.CanRequest()
+        can_request.unReqID = ReqId
+        MValue = (isFd << 6) + (isBrs << 5) + (Dlc << 1) + MType
+        can_request.ucMType = MValue # UDS诊断类型，1-本地 2-远程
+        can_request.usDataLen = DataLen
+        can_request.ucData = data
+        time_out = ctypes.c_ushort(6000)
+
+        # 清空之前的响应状态
+        with self._response_lock:
+            self._current_response_data = None
+            self._response_event.clear()
+        # 发送请求
+        n_rst = dll.H3CANForward15765_2(self.port_handle, self.channel_index, can_request, time_out)
+        if n_rst == 0:
+            if WaitResp == True:
+                # 等待响应（阻塞等待）
+                if self._response_event.wait(timeout=30.0):  # 6秒超时
+                    with self._response_lock:
+                        return n_rst, self._current_response_data
+                else:
+                    return 0x2002, None  # 超时
+            else:
+                return n_rst, None
+        else:
+            return n_rst, None  # 发送失败

demo/Test_Canfd.py

@@ -0,0 +1,112 @@
+import can
+import time
+from can_hirain.config import TestBaseVCI_ChlMode, TestBaseVCI_SAMPLEPOINT # 导入枚举值
+from can_hirain.hrcan import get_hr_hw_devices_info # 导入获取全部设备信息函数
+
+
+def multi_channel():
+
+    # 初始化通道0（发送端）和通道1（接收端）
+    with can.Bus(interface="hrcan", channel=0, # 激活通道0为CANFD通道
+                 configs = [{
+                     'resistance': 1, # 启用终端电阻
+                     'mode' : TestBaseVCI_ChlMode.CANFD, # 设置CANFD通道
+                     'listenFlag' : 0, # 0-正常状态，1-通道为仅监听状态，不给ACK响应
+                     'abrBaudrate': 500_000,
+                     'dbrBaudrate': 2000_000,
+                     'abrSamplePoint': TestBaseVCI_SAMPLEPOINT.SAMPLE_80,
+                     'dbrSamplePoint': TestBaseVCI_SAMPLEPOINT.SAMPLE_80,}]) as bus_tx, \
+    can.Bus(interface="hrcan", channel=4, # 激活通道1为CANFD通道
+            configs=[{
+                'resistance': 1,  # 启用终端电阻
+                'mode': TestBaseVCI_ChlMode.CANFD,  # 设置CANFD通道
+                'listenFlag' : 0, # 0-正常状态，1-通道为仅监听状态，不给ACK响应
+                'abrBaudrate': 500_000,
+                'dbrBaudrate': 2000_000,
+                'abrSamplePoint': TestBaseVCI_SAMPLEPOINT.SAMPLE_80,
+                'dbrSamplePoint': TestBaseVCI_SAMPLEPOINT.SAMPLE_80}]) as bus_rx:
+    # with can.Bus(
+    #         interface="hrcan",
+    #         channel=0,
+    #         rate_baudrate=500,
+    #         data_baudrate=2000,
+    #         enable_120hm=True,
+    #         is_fd=True,
+    #         is_include_tx=True,
+    #         hwserial=b"HRA000020000"  # 使用设备SN作为硬件序列号
+    #     ) as bus_tx,\
+    # can.Bus(
+    #         interface="hrcan",
+    #         channel=1,
+    #         rate_baudrate=500,
+    #         data_baudrate=2000,
+    #         enable_120hm=True,
+    #         is_fd=True,
+    #         is_include_tx=True,
+    #         hwserial=b"HRA000020000"  # 使用设备SN作为硬件序列号
+    #     ) as bus_rx:
+
+        # # 配置接收端监听器（打印+日志）
+        # listeners_rx = [can.Printer(), can.Logger("rx_channel.asc")]
+        # notifier_rx = can.Notifier(bus_rx, listeners_rx)
+        # time.sleep(0.1)  # 确保监听器就绪
+        #
+        # # 配置发送端监听器（打印+日志）
+        # listeners_tx = [can.Printer(), can.Logger("tx_channel.asc")]
+        # notifier_tx = can.Notifier(bus_tx, listeners_tx)
+        # time.sleep(0.1)  # 确保监听器就绪
+
+        # 配置总计监听器（日志）(不配置Printer以降低IO资源占用)
+        listeners = [can.Printer(), can.Logger("rxtx_channel_test.blf")]
+        notifier = can.Notifier([bus_tx,bus_rx], listeners)
+        time.sleep(0.1)  # 确保监听器就绪
+
+        # 发送测试消息（从通道0发送到通道1）
+        test_msg_1 = can.Message(
+            arbitration_id=0x123,
+            data=[0xAA, 0xBB, 0xCC],
+            dlc=3,
+            is_extended_id=True,
+            is_fd=True,
+            bitrate_switch=True
+        )
+
+        # 发送测试消息（从通道0发送到通道1）
+        test_msg_2 = can.Message(
+            arbitration_id=0x1FFFFFFE,
+            data=[i for i in range(8)],
+            dlc=8,
+            is_extended_id=True,
+            is_fd=True,
+            bitrate_switch=True
+        )
+        print(f"发送消息: ID=0x{test_msg_1.arbitration_id:X}, Data={','.join(str(_) for _ in test_msg_1.data)}")
+        bus_tx.send(test_msg_1)
+        print(f"发送消息: ID=0x{test_msg_2.arbitration_id:X}, Data={','.join(str(_) for _ in test_msg_2.data)}")
+        bus_tx.send(test_msg_2)
+
+        time.sleep(2)
+        # canfd_id = [0x85, 0xE0, 0x100, 0x103, 0x122, 0x123, 0x124, 0x125, 0x162, 0x165, 0x1A5, 0x218, 0x220, 0x228, 0x256, 0x26D, 0x288, 0x292, 0x2A1, 0x2A5, 0x2A7, 0x2AC, 0x2E0, 0x2F7, 0x360, 0x380, 0x3D0, 0x3F1, 0x405, 0x744, 0x783, 0x795, 0x7C6, 0x7DF, 0x7E2, 0x1F0, 0x1F1, 0x1F2, 0x283, 0x284]
+        canfd_id = [0x7E2, 0x1F0, 0x1F1, 0x1F2, 0x283, 0x284]
+        # test_msg_2.arbitration_id = 0x1FFFEEEE
+        num = 0
+        test_msg_2.is_extended_id = False
+        for i in canfd_id:
+            test_msg_2.arbitration_id = i
+            bus_tx.send_periodic(test_msg_2, 0.01)
+            print(f"发送周期消息: ID=0x{test_msg_2.arbitration_id:X}")
+            num += 1
+        print(f"共有{num}条周期报文")
+
+        print("等待100s...")
+        time.sleep(100)
+
+        bus_tx.stop_all_periodic_tasks()
+        time.sleep(10)
+        notifier.stop()
+
+if __name__ == "__main__":
+    devices = get_hr_hw_devices_info()
+    print(devices)
+    time.sleep(2)
+    multi_channel()