周立功USB-CAN设备开发实战指南

1. 项目概述与开发环境搭建

1.1 硬件选型与驱动准备

周立功USB-CAN设备是工业领域常用的CAN总线通信接口工具，其核心优势在于稳定的驱动支持和跨平台兼容性。在开始开发前，需要准备以下硬件和软件：

• 硬件设备：ZLG USBCAN-II Pro（型号USBCAN-2E-U），支持双通道CAN通信
• 驱动文件：从官网下载最新版驱动包（通常包含ControlCAN.dll、controlcan.h和libcontrolcan.so）
• 开发工具：Visual Studio 2022（社区版即可）

注意：不同型号设备的API接口可能略有差异，务必确认设备型号与驱动版本匹配。我曾遇到过因驱动版本不匹配导致VCI_OpenDevice始终返回0的情况。

1.2 开发环境配置步骤

1.2.1 Windows平台配置

1. 安装官方驱动后，将以下文件复制到项目目录：

   • ControlCAN.dll（主动态库）
   • controlcan.h（头文件，供参考）
   • zlgcan.h（扩展定义）

2. 通过NuGet添加必要依赖：

xml复制<PackageReference Include="System.Management" Version="8.0.0" />
<PackageReference Include="Microsoft.Win32.Registry" Version="5.0.0" />

3. 在项目属性中启用非安全代码：

xml复制<PropertyGroup>
  <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
</PropertyGroup>

1.2.2 Linux平台配置（跨平台方案）

对于需要在Linux下运行的情况，需额外配置：

bash复制# 添加USB设备权限
sudo echo 'SUBSYSTEM=="usb", ATTR{idVendor}=="0403", MODE="0666"' > /etc/udev/rules.d/99-zlg.rules
sudo udevadm control --reload-rules

# 安装依赖库
sudo apt install libusb-1.0-0-dev

1.3 项目结构规划

建议采用分层架构组织代码：

code复制/USBCAN-Demo
│── /Drivers       # 驱动文件存放
│── /Core
│   ├── CanManager.cs  # 设备管理核心
│   ├── CanFrame.cs    # 数据帧结构
│── /Services
│   ├── CanReceiver.cs # 接收服务
│   ├── CanSender.cs   # 发送服务
│── /Utils
│   ├── CanLogger.cs   # 日志记录

2. 设备连接与初始化

2.1 设备连接流程详解

设备连接的核心是通过VCI_OpenDeviceAPI建立通信链路。以下是增强版的设备管理类实现：

csharp复制public class CanDeviceManager : IDisposable
{
    private const int DEVICE_TYPE = 4;  // USBCAN-II设备类型码
    private int _deviceHandle;
    private bool _isConnected;
    
    [DllImport("ControlCAN.dll", CallingConvention = CallingConvention.StdCall)]
    private static extern int VCI_OpenDevice(int deviceType, int deviceIndex, int reserved);
    
    public bool Connect(int deviceIndex = 0, int retryCount = 3)
    {
        for (int i = 0; i < retryCount; i++)
        {
            _deviceHandle = VCI_OpenDevice(DEVICE_TYPE, deviceIndex, 0);
            if (_deviceHandle == 1) 
            {
                _isConnected = true;
                return true;
            }
            Thread.Sleep(500); // 重试间隔
        }
        return false;
    }
}

实战经验：设备索引(deviceIndex)从0开始递增，当连接多台设备时，需要遍历尝试。曾在一个项目中因未处理多设备场景，导致只能识别第一台设备。

2.2 CAN通道初始化配置

初始化配置需要特别注意波特率参数设置，以下是完整的初始化方法：

csharp复制public struct VCI_INIT_CONFIG
{
    public uint AccCode;   // 验收码
    public uint AccMask;   // 屏蔽码
    public byte Filter;    // 滤波方式 0-双滤波 1-单滤波
    public byte Mode;      // 工作模式 0-正常 1-只听
    public byte Timing0;   // 波特率定时器0
    public byte Timing1;   // 波特率定时器1
    public byte Reserved;  // 保留字段
}

public bool InitCanChannel(int channelIndex, int baudRate = 1000)
{
    VCI_INIT_CONFIG config = new VCI_INIT_CONFIG
    {
        AccCode = 0x00000000,  // 接收所有帧
        AccMask = 0xFFFFFFFF,  // 全屏蔽
        Filter = 1,            // 单滤波模式
        Mode = 0,              // 正常模式
        Timing0 = GetTiming0(baudRate),
        Timing1 = GetTiming1(baudRate)
    };
    
    [DllImport("ControlCAN.dll")]
    private static extern int VCI_InitCAN(int deviceType, int deviceIndex, 
                                        int canIndex, ref VCI_INIT_CONFIG config);
                                        
    return VCI_InitCAN(DEVICE_TYPE, 0, channelIndex, ref config) == 1;
}

private byte GetTiming0(int baudRate) => baudRate switch
{
    1000 => 0x00,   // 1Mbps
    500 => 0x01,    // 500kbps
    250 => 0x03,    // 250kbps
    125 => 0x07,    // 125kbps
    100 => 0x43,    // 100kbps
    _ => throw new ArgumentException("不支持的波特率")
};

private byte GetTiming1(int baudRate) => baudRate switch
{
    1000 => 0x1C,
    500 => 0x1C,
    250 => 0x1C,
    125 => 0x1C,
    100 => 0x2F,
    _ => 0x1C
};

3. 数据通信实现

3.1 数据帧结构定义

扩展标准帧结构，支持更多CAN协议特性：

csharp复制[StructLayout(LayoutKind.Sequential)]
public struct VCI_CAN_OBJ
{
    public uint ID;            // 帧ID
    public uint TimeStamp;     // 时间戳(ms)
    public byte TimeFlag;      // 是否使用时间戳
    public byte SendType;      // 发送类型 0-正常 1-单次 2-自发自收
    public byte RemoteFlag;    // 远程帧标志
    public byte ExternFlag;    // 扩展帧标志
    public byte DataLen;       // 数据长度(0-8)
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
    public byte[] Data;        // 数据内容
    public byte Reserved;      // 保留字段
}

public class CanFrame
{
    public uint Id { get; set; }
    public bool IsExtended { get; set; }
    public bool IsRemote { get; set; }
    public byte[] Data { get; set; } = new byte[8];
    public DateTime Timestamp { get; set; }
    
    public override string ToString()
    {
        return $"[{Timestamp:HH:mm:ss.fff}] {(IsExtended ? "EXT" : "STD")} " +
               $"0x{Id:X8} {(IsRemote ? "RTR" : "DAT")}: " +
               BitConverter.ToString(Data, 0, Data.Length);
    }
}

3.2 数据接收实现方案

3.2.1 轮询模式接收

基础接收方法使用API直接轮询：

csharp复制[DllImport("ControlCAN.dll")]
private static extern int VCI_Receive(int deviceType, int deviceIndex, 
                                    int canIndex, [Out] VCI_CAN_OBJ[] receiveBuf, 
                                    int bufLen, int waitTime);

public List<CanFrame> ReceiveFrames(int channelIndex, int maxFrames = 100)
{
    var frames = new List<CanFrame>();
    var buffer = new VCI_CAN_OBJ[maxFrames];
    
    int received = VCI_Receive(DEVICE_TYPE, 0, channelIndex, buffer, maxFrames, 50);
    for (int i = 0; i < received; i++)
    {
        frames.Add(new CanFrame
        {
            Id = buffer[i].ID,
            IsExtended = buffer[i].ExternFlag == 1,
            IsRemote = buffer[i].RemoteFlag == 1,
            Data = buffer[i].Data.Take(buffer[i].DataLen).ToArray(),
            Timestamp = DateTime.Now
        });
    }
    return frames;
}

3.2.2 中断接收模式（推荐）

更高效的中断接收方案：

csharp复制public class CanReceiver : IDisposable
{
    private Thread _receiveThread;
    private bool _isRunning;
    private readonly int _channelIndex;
    private readonly BlockingCollection<CanFrame> _queue = new(1000);
    
    public event EventHandler<CanFrame> FrameReceived;
    
    public CanReceiver(int channelIndex)
    {
        _channelIndex = channelIndex;
    }
    
    public void Start()
    {
        _isRunning = true;
        _receiveThread = new Thread(ReceiveLoop)
        {
            Priority = ThreadPriority.AboveNormal,
            IsBackground = true
        };
        _receiveThread.Start();
    }
    
    private void ReceiveLoop()
    {
        const int BUFFER_SIZE = 100;
        var buffer = new VCI_CAN_OBJ[BUFFER_SIZE];
        
        while (_isRunning)
        {
            int received = VCI_Receive(DEVICE_TYPE, 0, _channelIndex, 
                                     buffer, BUFFER_SIZE, 100);
            if (received > 0)
            {
                for (int i = 0; i < received; i++)
                {
                    var frame = ConvertToFrame(buffer[i]);
                    _queue.TryAdd(frame);
                    FrameReceived?.Invoke(this, frame);
                }
            }
        }
    }
    
    public IEnumerable<CanFrame> GetFrames(CancellationToken token)
    {
        while (!token.IsCancellationRequested)
        {
            if (_queue.TryTake(out var frame, 100, token))
                yield return frame;
        }
    }
}

3.3 数据发送实现

增强版发送方法支持多种发送模式：

csharp复制[DllImport("ControlCAN.dll")]
private static extern int VCI_Transmit(int deviceType, int deviceIndex, 
                                     int canIndex, ref VCI_CAN_OBJ sendBuf, 
                                     int bufLen);

public bool SendFrame(CanFrame frame, int channelIndex, int timeout = 1000)
{
    var canObj = new VCI_CAN_OBJ
    {
        ID = frame.Id,
        SendType = 0,  // 正常发送
        RemoteFlag = (byte)(frame.IsRemote ? 1 : 0),
        ExternFlag = (byte)(frame.IsExtended ? 1 : 0),
        DataLen = (byte)frame.Data.Length,
        Data = frame.Data.Length <= 8 ? frame.Data : frame.Data.Take(8).ToArray()
    };
    
    return VCI_Transmit(DEVICE_TYPE, 0, channelIndex, ref canObj, 1) == 1;
}

// 批量发送优化
public int SendFrames(IEnumerable<CanFrame> frames, int channelIndex)
{
    int successCount = 0;
    var canObjs = frames.Select(f => new VCI_CAN_OBJ
    {
        ID = f.Id,
        DataLen = (byte)f.Data.Length,
        Data = f.Data
    }).ToArray();
    
    for (int i = 0; i < canObjs.Length; i++)
    {
        if (VCI_Transmit(DEVICE_TYPE, 0, channelIndex, ref canObjs[i], 1) == 1)
            successCount++;
        else
            Thread.Sleep(1); // 防止总线过载
    }
    return successCount;
}

4. 高级功能实现

4.1 错误处理与状态监测

csharp复制[StructLayout(LayoutKind.Sequential)]
public struct VCI_ERR_INFO
{
    public uint ErrCode;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
    public byte[] PassiveErr;
    public byte ArLostErr;
}

[DllImport("ControlCAN.dll")]
private static extern int VCI_ReadErrInfo(int deviceType, int deviceIndex, 
                                        int canIndex, ref VCI_ERR_INFO errInfo);

public string GetErrorInfo(int channelIndex)
{
    var errInfo = new VCI_ERR_INFO();
    if (VCI_ReadErrInfo(DEVICE_TYPE, 0, channelIndex, ref errInfo) == 1)
    {
        return $"错误码: 0x{errInfo.ErrCode:X8}\n" +
               $"被动错误: RX[{errInfo.PassiveErr[0]}] TX[{errInfo.PassiveErr[1]}]\n" +
               $"仲裁丢失: {errInfo.ArLostErr}";
    }
    return "获取错误信息失败";
}

// 设备状态监测
[DllImport("ControlCAN.dll")]
private static extern int VCI_ReadCANStatus(int deviceType, int deviceIndex, 
                                          int canIndex, ref VCI_CAN_STATUS status);

public string GetChannelStatus(int channelIndex)
{
    var status = new VCI_CAN_STATUS();
    if (VCI_ReadCANStatus(DEVICE_TYPE, 0, channelIndex, ref status) == 1)
    {
        return $"缓冲区: RX[{status.RecvBufferCount}/{status.RecvBufferSize}] " +
               $"TX[{status.SendBufferCount}/{status.SendBufferSize}]\n" +
               $"错误计数: RX[{status.RecvErrCount}] TX[{status.SendErrCount}]\n" +
               $"总线状态: {(status.CANStatus == 0 ? "正常" : "离线")}";
    }
    return "获取状态失败";
}

4.2 性能优化技巧

4.2.1 双缓冲技术

csharp复制public class DoubleBufferReceiver
{
    private readonly BlockingCollection<CanFrame>[] _buffers = new BlockingCollection<CanFrame>[2];
    private int _activeBufferIndex;
    private readonly Thread _processorThread;
    
    public DoubleBufferReceiver()
    {
        _buffers[0] = new BlockingCollection<CanFrame>(10000);
        _buffers[1] = new BlockingCollection<CanFrame>(10000);
        
        _processorThread = new Thread(ProcessBuffer)
        {
            IsBackground = true,
            Priority = ThreadPriority.Highest
        };
        _processorThread.Start();
    }
    
    public void EnqueueFrame(CanFrame frame)
    {
        _buffers[_activeBufferIndex].Add(frame);
    }
    
    private void ProcessBuffer()
    {
        while (true)
        {
            var currentBuffer = _buffers[1 - _activeBufferIndex];
            _activeBufferIndex = 1 - _activeBufferIndex;
            
            foreach (var frame in currentBuffer.GetConsumingEnumerable())
            {
                // 处理帧数据
            }
            currentBuffer.Dispose();
            _buffers[1 - _activeBufferIndex] = new BlockingCollection<CanFrame>(10000);
        }
    }
}

4.2.2 DMA传输配置

csharp复制[DllImport("ControlCAN.dll")]
private static extern int VCI_SetReference(int deviceType, int deviceIndex, 
                                         int canIndex, int refType, ref byte data);

public bool EnableDma(int channelIndex, bool enable)
{
    byte mode = enable ? (byte)1 : (byte)0;
    return VCI_SetReference(DEVICE_TYPE, 0, channelIndex, 3, ref mode) == 1;
}

5. 调试与测试方案

5.1 数据监控器实现

csharp复制public class CanMonitor : Form
{
    private readonly DataGridView _gridView = new();
    private readonly CanReceiver _receiver;
    private readonly BufferedGraphicsContext _context;
    
    public CanMonitor(CanReceiver receiver)
    {
        _receiver = receiver;
        _context = BufferedGraphicsManager.Current;
        
        InitializeUI();
        _receiver.FrameReceived += OnFrameReceived;
    }
    
    private void InitializeUI()
    {
        _gridView.Dock = DockStyle.Fill;
        _gridView.Columns.AddRange(
            new DataGridViewTextBoxColumn { HeaderText = "时间", DataPropertyName = "Timestamp" },
            new DataGridViewTextBoxColumn { HeaderText = "ID", DataPropertyName = "Id" },
            new DataGridViewTextBoxColumn { HeaderText = "数据", DataPropertyName = "Data" }
        );
        Controls.Add(_gridView);
    }
    
    private void OnFrameReceived(object sender, CanFrame frame)
    {
        if (InvokeRequired)
        {
            Invoke(new Action(() => OnFrameReceived(sender, frame)));
            return;
        }
        
        _gridView.Rows.Add(
            frame.Timestamp.ToString("HH:mm:ss.fff"),
            $"0x{frame.Id:X8}",
            BitConverter.ToString(frame.Data)
        );
        
        // 自动滚动到最后
        _gridView.FirstDisplayedScrollingRowIndex = _gridView.RowCount - 1;
    }
}

5.2 自动化测试框架

csharp复制public class CanBusTester
{
    private readonly CanDeviceManager _manager;
    private readonly CancellationTokenSource _cts = new();
    
    public CanBusTester(CanDeviceManager manager)
    {
        _manager = manager;
    }
    
    public async Task RunStressTest(int channelIndex, int durationSec)
    {
        var testFrame = new CanFrame
        {
            Id = 0x123,
            Data = new byte[] { 0xAA, 0xBB, 0xCC, 0xDD }
        };
        
        var stats = new TestStatistics();
        var tasks = new[]
        {
            Task.Run(() => SendLoop(testFrame, channelIndex, stats, _cts.Token)),
            Task.Run(() => ReceiveLoop(channelIndex, stats, _cts.Token))
        };
        
        await Task.Delay(durationSec * 1000);
        _cts.Cancel();
        await Task.WhenAll(tasks);
        
        Console.WriteLine($"测试结果: 发送{stats.SentCount}帧, 接收{stats.ReceivedCount}帧, " +
                         $"丢失率{stats.LossRate:P2}");
    }
    
    private async Task SendLoop(CanFrame frame, int channelIndex, 
                              TestStatistics stats, CancellationToken token)
    {
        while (!token.IsCancellationRequested)
        {
            if (_manager.SendFrame(frame, channelIndex))
                Interlocked.Increment(ref stats.SentCount);
            await Task.Delay(1);
        }
    }
    
    private void ReceiveLoop(int channelIndex, TestStatistics stats, 
                           CancellationToken token)
    {
        var receiver = new CanReceiver(channelIndex);
        receiver.FrameReceived += (_, _) => Interlocked.Increment(ref stats.ReceivedCount);
        receiver.Start();
        
        try { token.WaitHandle.WaitOne(); }
        finally { receiver.Dispose(); }
    }
    
    private class TestStatistics
    {
        public long SentCount;
        public long ReceivedCount;
        public double LossRate => (SentCount - ReceivedCount) / (double)SentCount;
    }
}

6. 项目部署与维护

6.1 安装包制作（WiX工具集）

xml复制<Wix xmlns="http://schemas.microsoft.com/wix/2006/wi">
  <Product Id="*" Name="CAN通信套件" Language="2052" Version="1.0.0"
           Manufacturer="YourCompany" UpgradeCode="YOUR-GUID-HERE">
    
    <Package InstallerVersion="200" Compressed="yes" />
    <MajorUpgrade DowngradeErrorMessage="已安装更高版本。" />
    
    <Directory Id="TARGETDIR" Name="SourceDir">
      <Directory Id="ProgramFilesFolder">
        <Directory Name="CANSuite" Id="INSTALLDIR">
          <Component Id="MainExecutable" Guid="YOUR-GUID-HERE">
            <File Source="$(var.CanApp.TargetPath)" />
          </Component>
          
          <Component Id="CanDrivers" Guid="YOUR-GUID-HERE">
            <File Source="Drivers\ControlCAN.dll" />
            <File Source="Drivers\zlgcan.dll" />
            <RegistryValue Root="HKLM" Key="SOFTWARE\CANSuite" 
                          Name="InstallDir" Type="string" Value="[INSTALLDIR]" />
          </Component>
        </Directory>
      </Directory>
    </Directory>
    
    <Feature Id="MainFeature" Title="主程序" Level="1">
      <ComponentRef Id="MainExecutable" />
      <ComponentRef Id="CanDrivers" />
    </Feature>
  </Product>
</Wix>

6.2 自动更新机制

csharp复制public class AutoUpdater
{
    private const string UPDATE_URL = "https://your-server.com/update/version.json";
    private readonly string _appPath = AppDomain.CurrentDomain.BaseDirectory;
    
    public async Task CheckUpdateAsync()
    {
        try
        {
            using var http = new HttpClient();
            var remoteVersion = await GetRemoteVersionAsync(http);
            var localVersion = GetLocalVersion();
            
            if (remoteVersion > localVersion)
            {
                if (MessageBox.Show($"发现新版本 {remoteVersion}，是否更新？", 
                    "更新提示", MessageBoxButtons.YesNo) == DialogResult.Yes)
                {
                    await DownloadAndUpdateAsync(http, remoteVersion);
                }
            }
        }
        catch (Exception ex)
        {
            Logger.Error("更新检查失败", ex);
        }
    }
    
    private async Task<Version> GetRemoteVersionAsync(HttpClient http)
    {
        var json = await http.GetStringAsync(UPDATE_URL);
        var info = JsonSerializer.Deserialize<UpdateInfo>(json);
        return Version.Parse(info.LatestVersion);
    }
    
    private Version GetLocalVersion()
    {
        return Assembly.GetExecutingAssembly().GetName().Version;
    }
    
    private async Task DownloadAndUpdateAsync(HttpClient http, Version version)
    {
        string tempFile = Path.GetTempFileName();
        try
        {
            var updateUrl = $"https://your-server.com/update/CANSuite_{version}.zip";
            using var stream = await http.GetStreamAsync(updateUrl);
            using var fileStream = File.Create(tempFile);
            await stream.CopyToAsync(fileStream);
            
            // 执行更新脚本
            Process.Start("updater.exe", $"--source=\"{tempFile}\" --target=\"{_appPath}\"");
            Application.Exit();
        }
        finally
        {
            File.Delete(tempFile);
        }
    }
    
    private class UpdateInfo
    {
        public string LatestVersion { get; set; }
        public string ReleaseNotes { get; set; }
    }
}

7. 典型应用场景扩展

7.1 工业自动化集成

csharp复制public class PlcGateway
{
    private readonly CanDeviceManager _can;
    private readonly Dictionary<int, Action<byte[]>> _handlers = new();
    
    public PlcGateway(CanDeviceManager canManager)
    {
        _can = canManager;
        var receiver = new CanReceiver(0);
        receiver.FrameReceived += OnCanMessage;
        receiver.Start();
    }
    
    public void RegisterHandler(int commandId, Action<byte[]> handler)
    {
        _handlers[commandId] = handler;
    }
    
    private void OnCanMessage(object sender, CanFrame frame)
    {
        if (frame.Data.Length >= 4)
        {
            int cmdId = BitConverter.ToInt32(frame.Data, 0);
            if (_handlers.TryGetValue(cmdId, out var handler))
            {
                var payload = frame.Data.Skip(4).ToArray();
                handler(payload);
            }
        }
    }
    
    public bool SendPlcCommand(int commandId, byte[] data)
    {
        var frameData = new byte[4 + data.Length];
        BitConverter.GetBytes(commandId).CopyTo(frameData, 0);
        data.CopyTo(frameData, 4);
        
        return _can.SendFrame(new CanFrame
        {
            Id = 0x100,
            Data = frameData
        }, 0);
    }
}

7.2 汽车诊断协议实现

csharp复制public class Obd2Diagnostic
{
    private readonly CanDeviceManager _can;
    private readonly AutoResetEvent _responseEvent = new(false);
    private CanFrame _lastResponse;
    
    public Obd2Diagnostic(CanDeviceManager canManager)
    {
        _can = canManager;
        var receiver = new CanReceiver(0);
        receiver.FrameReceived += OnCanMessage;
        receiver.Start();
    }
    
    public byte[] SendRequest(byte[] requestData, int timeout = 1000)
    {
        _lastResponse = null;
        var requestFrame = new CanFrame
        {
            Id = 0x7DF,  // 广播地址
            Data = requestData
        };
        
        if (!_can.SendFrame(requestFrame, 0))
            throw new Exception("发送请求失败");
            
        if (!_responseEvent.WaitOne(timeout))
            throw new TimeoutException("等待响应超时");
            
        return _lastResponse?.Data ?? Array.Empty<byte>();
    }
    
    private void OnCanMessage(object sender, CanFrame frame)
    {
        if (frame.Id >= 0x7E8 && frame.Id <= 0x7EF)  // ECU响应地址范围
        {
            _lastResponse = frame;
            _responseEvent.Set();
        }
    }
    
    // 常用诊断命令封装
    public string ReadDtc()
    {
        var response = SendRequest(new byte[] { 0x03, 0x01 });
        return ParseDtcCodes(response);
    }
    
    private string ParseDtcCodes(byte[] data)
    {
        // DTC解析逻辑实现
        return "P0100,P0201"; // 示例返回值
    }
}

8. 常见问题解决方案

8.1 设备连接问题排查

8.2 数据通信异常处理

帧丢失问题优化方案：

1. 增加接收缓冲区大小：

csharp复制[DllImport("ControlCAN.dll")]
private static extern int VCI_SetReference(int deviceType, int deviceIndex, 
                                         int canIndex, int refType, ref int data);

public bool SetReceiveBufferSize(int channelIndex, int size)
{
    return VCI_SetReference(DEVICE_TYPE, 0, channelIndex, 0, ref size) == 1;
}

2. 优化线程优先级：

csharp复制_receiveThread.Priority = ThreadPriority.Highest;
_processThread.Priority = ThreadPriority.AboveNormal;

3. 启用硬件过滤减少CPU负载：

csharp复制public bool SetAcceptanceFilter(int channelIndex, uint code, uint mask)
{
    VCI_INIT_CONFIG config = new()
    {
        AccCode = code,
        AccMask = mask,
        // 其他参数保持不变
    };
    return VCI_InitCAN(DEVICE_TYPE, 0, channelIndex, ref config) == 1;
}

8.3 性能优化实测数据

以下是在不同配置下的性能测试结果（基于USBCAN-II Pro）：

关键发现：在500kbps波特率下，理论最大帧率为7000帧/秒（标准数据帧）。实际测试中，优化后的方案可以达到理论值的80%以上。