使用纯MATLAB M函数实现的无刷直流电机控制系统仿真

kaikaile19952025-12-23 8:48

使用纯MATLAB M函数（不依赖Simulink）实现的无刷直流电机（BLDC）控制系统仿真框架。这个实现将涵盖电机模型、换相逻辑、PWM控制和速度环调节。

完整的BLDC控制系统仿真代码

1. 主仿真文件：bldc_control_main.m

matlab 复制代码 
%% BLDC电机控制系统仿真 - 主文件
clear; close all; clc;

%% 1. 系统参数设置
% 电机电气参数
params.R = 0.5;                % 相电阻 (Ohm)
params.L = 2e-3;               % 相电感 (H)
params.Ke = 0.05;              % 反电动势常数 (V/(rad/s))
params.Kt = 0.05;              % 转矩常数 (N·m/A)
params.J = 1e-4;               % 转动惯量 (kg·m²)
params.B = 1e-4;               % 阻尼系数 (N·m·s/rad)
params.P = 4;                  % 极对数

% 控制参数
params.Vdc = 24;               % 直流母线电压 (V)
params.I_max = 5;              % 最大相电流 (A)
params.ref_speed = 1000;       % 参考转速 (rpm)
params.PWM_freq = 10000;       % PWM频率 (Hz)
params.PWM_duty = 0.7;         % PWM初始占空比

% 仿真参数
params.Ts = 1e-5;              % 控制周期 (s)
params.T_total = 0.2;          % 总仿真时间 (s)
params.sim_steps = round(params.T_total/params.Ts);

% 初始化换相表 (6步换相，120度导通)
% 顺序: A+ B- | A+ C- | B+ C- | B+ A- | C+ A- | C+ B-
params.comm_table = [
    1, 0, 0, 0, 1, 0;  % 步1: A+, B-
    1, 0, 0, 0, 0, 1;  % 步2: A+, C-
    0, 1, 0, 0, 0, 1;  % 步3: B+, C-
    0, 1, 1, 0, 0, 0;  % 步4: B+, A-
    0, 0, 1, 1, 0, 0;  % 步5: C+, A-
    0, 0, 1, 0, 1, 0;  % 步6: C+, B-
];

%% 2. 初始化状态变量
state.theta_elec = 0;          % 电角度 (rad)
state.theta_mech = 0;          % 机械角度 (rad)
state.speed = 0;               % 机械转速 (rad/s)
state.Ia = 0;                  % A相电流 (A)
state.Ib = 0;                  % B相电流 (A)
state.Ic = 0;                  % C相电流 (A)
state.Ia_dot = 0;              % A相电流导数
state.Ib_dot = 0;              % B相电流导数
state.Ic_dot = 0;              % C相电流导数
state.T_load = 0.1;            % 负载转矩 (N·m)

% PID控制器状态
pid.error_prev = 0;
pid.integral = 0;
pid.Kp = 0.1;
pid.Ki = 5;
pid.Kd = 0.001;

% 数据记录
data.time = zeros(params.sim_steps, 1);
data.speed_rpm = zeros(params.sim_steps, 1);
data.theta_elec = zeros(params.sim_steps, 1);
data.Iabc = zeros(params.sim_steps, 3);
data.Vabc = zeros(params.sim_steps, 3);
data.torque = zeros(params.sim_steps, 1);
data.hall_state = zeros(params.sim_steps, 1);
data.duty_cycle = zeros(params.sim_steps, 1);

%% 3. 主仿真循环
fprintf('开始BLDC控制系统仿真...\n');
progress_interval = round(params.sim_steps/10);

for k = 1:params.sim_steps
    t = (k-1) * params.Ts;
    data.time(k) = t;
    
    % 3.1 速度控制器 (PI控制)
    speed_error = params.ref_speed * (2*pi/60) - state.speed; % 转换为rad/s
    [pid, duty_cycle] = speed_pid_controller(speed_error, pid, params);
    data.duty_cycle(k) = duty_cycle;
    
    % 3.2 获取霍尔传感器信号 (模拟)
    hall_state = get_hall_signal(state.theta_elec);
    data.hall_state(k) = hall_state;
    
    % 3.3 换相逻辑 (根据霍尔信号确定导通状态)
    [S1, S2, S3, S4, S5, S6] = commutation_logic(hall_state, params);
    
    % 3.4 计算三相电压 (基于PWM和换相状态)
    [Va, Vb, Vc] = calculate_phase_voltages(S1, S2, S3, S4, S5, S6, duty_cycle, params);
    data.Vabc(k, :) = [Va, Vb, Vc];
    
    % 3.5 计算反电动势
    [Ea, Eb, Ec] = calculate_back_emf(state.theta_elec, state.speed, params);
    
    % 3.6 更新电机状态 (使用前向欧拉法)
    state = update_motor_state(state, Va, Vb, Vc, Ea, Eb, Ec, params);
    
    % 3.7 计算电磁转矩
    Te = calculate_torque(state.Ia, state.Ib, state.Ic, state.theta_elec, params);
    data.torque(k) = Te;
    
    % 3.8 更新机械系统
    state = update_mechanical_system(state, Te, params);
    
    % 记录数据
    data.speed_rpm(k) = state.speed * 60/(2*pi); % 转换为RPM
    data.theta_elec(k) = mod(state.theta_elec, 2*pi);
    data.Iabc(k, :) = [state.Ia, state.Ib, state.Ic];
    
    % 显示进度
    if mod(k, progress_interval) == 0
        fprintf('进度: %.0f%%\n', k/params.sim_steps*100);
    end
end

fprintf('仿真完成!\n');

%% 4. 结果可视化
plot_simulation_results(data, params);

%% 5. 性能分析
analyze_performance(data, params);

2. 核心函数文件：bldc_functions.m

matlab 复制代码 
%% BLDC控制系统核心函数集

function [pid, duty] = speed_pid_controller(error, pid, params)
    % 速度PI控制器
    % 输入：当前误差，PID状态，参数
    % 输出：更新后的PID状态，PWM占空比
    
    % 积分项
    pid.integral = pid.integral + error * params.Ts;
    
    % 抗积分饱和
    integral_limit = 10;
    if pid.integral > integral_limit
        pid.integral = integral_limit;
    elseif pid.integral < -integral_limit
        pid.integral = -integral_limit;
    end
    
    % 微分项（近似）
    derivative = (error - pid.error_prev) / params.Ts;
    
    % PI计算
    pid_output = pid.Kp * error + pid.Ki * pid.integral + pid.Kd * derivative;
    
    % 输出限幅 (0~1)
    duty = max(0, min(1, pid_output));
    
    % 更新误差
    pid.error_prev = error;
end

function hall_state = get_hall_signal(theta_elec)
    % 模拟霍尔传感器信号 (3个霍尔传感器，60度间隔)
    % 霍尔信号编码: [H3 H2 H1] 二进制
    
    % 将电角度转换为6个扇区 (0-5)
    sector = floor(mod(theta_elec, 2*pi) / (pi/3));
    
    % 标准霍尔编码表 (120度安装)
    hall_table = [5, 1, 3, 2, 6, 4]; % 对应扇区0-5
    
    hall_state = hall_table(sector + 1); % +1因为MATLAB索引从1开始
end

function [S1, S2, S3, S4, S5, S6] = commutation_logic(hall_state, params)
    % 换相逻辑 - 根据霍尔信号确定开关状态
    
    % 霍尔状态到换相步的映射
    hall_to_step = containers.Map({1, 2, 3, 4, 5, 6}, {1, 2, 3, 4, 5, 6});
    
    if isKey(hall_to_step, hall_state)
        step = hall_to_step(hall_state);
        % 从换相表获取开关状态
        S1 = params.comm_table(step, 1);
        S2 = params.comm_table(step, 2);
        S3 = params.comm_table(step, 3);
        S4 = params.comm_table(step, 4);
        S5 = params.comm_table(step, 5);
        S6 = params.comm_table(step, 6);
    else
        % 默认状态（所有开关关断）
        S1 = 0; S2 = 0; S3 = 0; S4 = 0; S5 = 0; S6 = 0;
    end
end

function [Va, Vb, Vc] = calculate_phase_voltages(S1, S2, S3, S4, S5, S6, duty, params)
    % 计算三相电压
    
    % 根据开关状态和PWM计算相电压
    % 假设上管PWM调制，下管常通或常断
    
    % A相电压
    if S1 == 1 && S4 == 0      % A+导通
        Va = duty * params.Vdc/2;
    elseif S1 == 0 && S4 == 1  % A-导通
        Va = -duty * params.Vdc/2;
    else                       % 浮空
        Va = 0;
    end
    
    % B相电压
    if S3 == 1 && S6 == 0      % B+导通
        Vb = duty * params.Vdc/2;
    elseif S3 == 0 && S6 == 1  % B-导通
        Vb = -duty * params.Vdc/2;
    else
        Vb = 0;
    end
    
    % C相电压
    if S5 == 1 && S2 == 0      % C+导通
        Vc = duty * params.Vdc/2;
    elseif S5 == 0 && S2 == 1  % C-导通
        Vc = -duty * params.Vdc/2;
    else
        Vc = 0;
    end
end

function [Ea, Eb, Ec] = calculate_back_emf(theta, speed, params)
    % 计算三相梯形反电动势
    
    % 标准化电角度到[0, 2π)
    theta_norm = mod(theta, 2*pi);
    
    % 梯形反电动势波形（120度平顶）
    % A相反电动势
    if theta_norm < pi/3
        Ea = 1;
    elseif theta_norm < 2*pi/3
        Ea = 1 - 6/pi * (theta_norm - pi/3);
    elseif theta_norm < pi
        Ea = -1;
    elseif theta_norm < 4*pi/3
        Ea = -1 + 6/pi * (theta_norm - pi);
    elseif theta_norm < 5*pi/3
        Ea = 1;
    else
        Ea = 1 - 6/pi * (theta_norm - 5*pi/3);
    end
    
    % B相和C相反电动势（相位差120度和240度）
    Eb_theta = mod(theta + 2*pi/3, 2*pi);
    Ec_theta = mod(theta + 4*pi/3, 2*pi);
    
    % 计算B相
    if Eb_theta < pi/3
        Eb = 1;
    elseif Eb_theta < 2*pi/3
        Eb = 1 - 6/pi * (Eb_theta - pi/3);
    elseif Eb_theta < pi
        Eb = -1;
    elseif Eb_theta < 4*pi/3
        Eb = -1 + 6/pi * (Eb_theta - pi);
    elseif Eb_theta < 5*pi/3
        Eb = 1;
    else
        Eb = 1 - 6/pi * (Eb_theta - 5*pi/3);
    end
    
    % 计算C相
    if Ec_theta < pi/3
        Ec = 1;
    elseif Ec_theta < 2*pi/3
        Ec = 1 - 6/pi * (Ec_theta - pi/3);
    elseif Ec_theta < pi
        Ec = -1;
    elseif Ec_theta < 4*pi/3
        Ec = -1 + 6/pi * (Ec_theta - pi);
    elseif Ec_theta < 5*pi/3
        Ec = 1;
    else
        Ec = 1 - 6/pi * (Ec_theta - 5*pi/3);
    end
    
    % 乘以反电动势常数和转速
    Ea = Ea * params.Ke * state.speed;
    Eb = Eb * params.Ke * state.speed;
    Ec = Ec * params.Ke * state.speed;
end

function state_new = update_motor_state(state, Va, Vb, Vc, Ea, Eb, Ec, params)
    % 更新电机电气状态 (使用欧拉法)
    
    % 计算电流导数 (电压方程: V = R*i + L*di/dt + E)
    state_new = state;
    
    state_new.Ia_dot = (Va - params.R * state.Ia - Ea) / params.L;
    state_new.Ib_dot = (Vb - params.R * state.Ib - Eb) / params.L;
    state_new.Ic_dot = (Vc - params.R * state.Ic - Ec) / params.L;
    
    % 更新电流
    state_new.Ia = state.Ia + state_new.Ia_dot * params.Ts;
    state_new.Ib = state.Ib + state_new.Ib_dot * params.Ts;
    state_new.Ic = state.Ic + state_new.Ic_dot * params.Ts;
    
    % 电流限幅
    current_limit = params.I_max;
    state_new.Ia = max(-current_limit, min(current_limit, state_new.Ia));
    state_new.Ib = max(-current_limit, min(current_limit, state_new.Ib));
    state_new.Ic = max(-current_limit, min(current_limit, state_new.Ic));
end

function Te = calculate_torque(Ia, Ib, Ic, theta, params)
    % 计算电磁转矩
    % Te = Kt * (fa*Ia + fb*Ib + fc*Ic)
    
    % 计算反电动势波形函数值
    [fa, fb, fc] = bemf_waveform(theta);
    
    % 电磁转矩
    Te = params.Kt * (fa*Ia + fb*Ib + fc*Ic);
end

function [fa, fb, fc] = bemf_waveform(theta)
    % 返回反电动势波形函数值（归一化）
    
    theta_norm = mod(theta, 2*pi);
    
    % A相波形函数
    if theta_norm < pi/3
        fa = 1;
    elseif theta_norm < 2*pi/3
        fa = 1 - 6/pi * (theta_norm - pi/3);
    elseif theta_norm < pi
        fa = -1;
    elseif theta_norm < 4*pi/3
        fa = -1 + 6/pi * (theta_norm - pi);
    elseif theta_norm < 5*pi/3
        fa = 1;
    else
        fa = 1 - 6/pi * (theta_norm - 5*pi/3);
    end
    
    % B相和C相 (相位差)
    fb_theta = mod(theta + 2*pi/3, 2*pi);
    fc_theta = mod(theta + 4*pi/3, 2*pi);
    
    % 计算B相
    if fb_theta < pi/3
        fb = 1;
    elseif fb_theta < 2*pi/3
        fb = 1 - 6/pi * (fb_theta - pi/3);
    elseif fb_theta < pi
        fb = -1;
    elseif fb_theta < 4*pi/3
        fb = -1 + 6/pi * (fb_theta - pi);
    elseif fb_theta < 5*pi/3
        fb = 1;
    else
        fb = 1 - 6/pi * (fb_theta - 5*pi/3);
    end
    
    % 计算C相
    if fc_theta < pi/3
        fc = 1;
    elseif fc_theta < 2*pi/3
        fc = 1 - 6/pi * (fc_theta - pi/3);
    elseif fc_theta < pi
        fc = -1;
    elseif fc_theta < 4*pi/3
        fc = -1 + 6/pi * (fc_theta - pi);
    elseif fc_theta < 5*pi/3
        fc = 1;
    else
        fc = 1 - 6/pi * (fc_theta - 5*pi/3);
    end
end

function state_new = update_mechanical_system(state, Te, params)
    % 更新机械系统状态
    
    state_new = state;
    
    % 机械方程: J*dω/dt = Te - T_load - B*ω
    accel = (Te - state.T_load - params.B * state.speed) / params.J;
    
    % 更新转速和角度
    state_new.speed = state.speed + accel * params.Ts;
    state_new.theta_mech = state.theta_mech + state_new.speed * params.Ts;
    state_new.theta_elec = state_new.theta_mech * params.P;
end

3. 可视化与分析函数：plot_and_analyze.m

matlab 复制代码 
function plot_simulation_results(data, params)
    % 绘制仿真结果
    
    figure('Position', [100, 100, 1400, 800]);
    
    % 1. 转速响应
    subplot(3, 3, 1);
    plot(data.time, data.speed_rpm, 'b-', 'LineWidth', 1.5);
    xlabel('时间 (s)'); ylabel('转速 (RPM)');
    title(sprintf('转速响应 (目标: %.0f RPM)', params.ref_speed));
    grid on; hold on;
    plot([0, data.time(end)], [params.ref_speed, params.ref_speed], 'r--');
    legend('实际转速', '目标转速');
    
    % 2. 三相电流
    subplot(3, 3, 2);
    plot(data.time, data.Iabc(:,1), 'r-', 'LineWidth', 1); hold on;
    plot(data.time, data.Iabc(:,2), 'g-', 'LineWidth', 1);
    plot(data.time, data.Iabc(:,3), 'b-', 'LineWidth', 1);
    xlabel('时间 (s)'); ylabel('相电流 (A)');
    title('三相电流波形');
    legend('Ia', 'Ib', 'Ic'); grid on;
    
    % 3. 电磁转矩
    subplot(3, 3, 3);
    plot(data.time, data.torque, 'm-', 'LineWidth', 1.5);
    xlabel('时间 (s)'); ylabel('转矩 (N·m)');
    title('电磁转矩');
    grid on;
    
    % 4. 霍尔信号
    subplot(3, 3, 4);
    stairs(data.time, data.hall_state, 'k-', 'LineWidth', 1.5);
    xlabel('时间 (s)'); ylabel('霍尔状态');
    title('霍尔传感器信号');
    grid on; ylim([0.5, 6.5]);
    
    % 5. PWM占空比
    subplot(3, 3, 5);
    plot(data.time, data.duty_cycle, 'c-', 'LineWidth', 1.5);
    xlabel('时间 (s)'); ylabel('占空比');
    title('PWM占空比变化');
    grid on; ylim([0, 1]);
    
    % 6. 三相电压
    subplot(3, 3, 6);
    plot(data.time, data.Vabc(:,1), 'r-'); hold on;
    plot(data.time, data.Vabc(:,2), 'g-');
    plot(data.time, data.Vabc(:,3), 'b-');
    xlabel('时间 (s)'); ylabel('相电压 (V)');
    title('三相电压');
    legend('Va', 'Vb', 'Vc'); grid on;
    
    % 7. 电流轨迹 (Ia vs Ib)
    subplot(3, 3, 7);
    plot(data.Iabc(:,1), data.Iabc(:,2), 'b.');
    xlabel('Ia (A)'); ylabel('Ib (A)');
    title('电流轨迹 (α-β平面投影)');
    axis equal; grid on;
    
    % 8. 相电流频谱分析
    subplot(3, 3, 8);
    Fs = 1/params.Ts;
    N = length(data.Iabc(:,1));
    Y = fft(data.Iabc(round(N/2):end,1));
    P2 = abs(Y/N);
    P1 = P2(1:floor(N/2)+1);
    P1(2:end-1) = 2*P1(2:end-1);
    f = Fs*(0:(N/2))/N;
    plot(f(1:200), P1(1:200), 'b-', 'LineWidth', 1.5);
    xlabel('频率 (Hz)'); ylabel('幅值');
    title('A相电流频谱');
    grid on;
    
    % 9. 电角度变化
    subplot(3, 3, 9);
    plot(data.time, data.theta_elec/(2*pi), 'b-', 'LineWidth', 1.5);
    xlabel('时间 (s)'); ylabel('电角度 (周期)');
    title('电角度变化');
    grid on;
    
    sgtitle('BLDC电机控制系统仿真结果', 'FontSize', 14, 'FontWeight', 'bold');
end

function analyze_performance(data, params)
    % 性能分析
    
    fprintf('\n=== 性能分析 ===\n');
    
    % 稳态性能
    steady_start = round(0.7 * length(data.time)); % 最后30%作为稳态
    speed_steady = data.speed_rpm(steady_start:end);
    torque_steady = data.torque(steady_start:end);
    
    % 转速统计
    speed_mean = mean(speed_steady);
    speed_std = std(speed_steady);
    speed_ripple = (max(speed_steady) - min(speed_steady)) / speed_mean * 100;
    
    fprintf('稳态转速: %.2f ± %.2f RPM\n', speed_mean, speed_std);
    fprintf('转速脉动: %.2f%%\n', speed_ripple);
    fprintf('转速误差: %.2f%%\n', abs(speed_mean - params.ref_speed)/params.ref_speed*100);
    
    % 转矩统计
    torque_mean = mean(torque_steady);
    torque_ripple = (max(torque_steady) - min(torque_steady)) / torque_mean * 100;
    
    fprintf('平均转矩: %.4f N·m\n', torque_mean);
    fprintf('转矩脉动: %.2f%%\n', torque_ripple);
    
    % 电流THD分析（简化的总谐波畸变估计）
    Ia_steady = data.Iabc(steady_start:end, 1);
    Ia_rms = rms(Ia_steady);
    Ia_fundamental = max(abs(fft(Ia_steady))) / length(Ia_steady) * 2;
    THD_estimate = sqrt(Ia_rms^2 - Ia_fundamental^2) / Ia_fundamental * 100;
    
    fprintf('A相电流RMS: %.3f A\n', Ia_rms);
    fprintf('电流THD估计: %.2f%%\n', THD_estimate);
    
    % 系统效率估计
    % 输入功率估计
    V_phase = params.Vdc * mean(data.duty_cycle(steady_start:end)) / 2;
    I_phase_rms = rms(Ia_steady);
    P_in = 3 * V_phase * I_phase_rms; % 近似
    
    % 输出功率
    P_out = torque_mean * speed_mean * (2*pi/60);
    
    % 效率估计
    efficiency = P_out / P_in * 100;
    fprintf('估计效率: %.1f%%\n', efficiency);
    
    % 动态性能
    % 寻找转速达到90%目标值的时间
    target_90 = 0.9 * params.ref_speed;
    idx_90 = find(data.speed_rpm >= target_90, 1);
    if ~isempty(idx_90)
        rise_time = data.time(idx_90);
        fprintf('上升时间(0-90%%): %.3f s\n', rise_time);
    end
end

仿真实现要点说明

1. 系统架构

复制代码 
BLDC控制系统仿真架构：
    ┌─────────┐    ┌──────────┐    ┌──────────┐    ┌──────────┐
    │ 速度PID  │───>│ 换相逻辑  │───>│ PWM调制   │───>│ 电机模型  │
    │ 控制器   │    │          │    │          │    │          │
    └─────────┘    └──────────┘    └──────────┘    └─────┬────┘
         ↑                                                │
         │                                           ┌────┴────┐
         └───────────────────────────────────────────│ 转速反馈 │
                                                    └─────────┘

2. 关键参数调整建议

参数 典型范围 影响效果 调整建议
速度环 Kp 0.01~1.0 响应速度，过大易超调 从0.1开始，逐渐增加
速度环 Ki 1~50 消除稳态误差，过大易振荡 Kp确定后，从5开始调整
PWM频率 5~20 kHz 电流纹波，开关损耗 10kHz是常用折中选择
仿真步长 1e-6~1e-5 s 精度与计算时间平衡 对于10kHz PWM，1e-5足够

3. 模型特点与扩展方向

当前模型特点：

  • 实现了六步方波驱动（120°导通）
  • 包含梯形反电动势模型
  • 采用前向欧拉法数值求解
  • 包含完整的换相逻辑和PWM调制

可扩展方向：

  1. 高级控制算法：将PID替换为模糊控制、滑模控制
  2. 无传感器控制：添加反电动势观测器或高频注入法
  3. 故障模拟：模拟缺相、霍尔故障等异常情况
  4. 效率优化：添加PWM策略优化（如PWM-ON、ON-PWM模式）
  5. 热模型：添加电机温升模型

参考代码 使用m函数实现无刷直流电机控制系统仿真 www.3dddown.com/csa/95980.html

使用与调试建议

  1. 首次运行 ：直接运行bldc_control_main.m，观察默认参数下的响应
  2. 参数调整 ：修改params.ref_speed测试不同转速，调整PID参数优化响应
  3. 故障注入：在换相逻辑函数中故意引入错误，观察系统响应
  4. 性能评估 ：使用analyze_performance函数量化系统性能
相关推荐
崇山峻岭之间2 小时前
Matlab学习记录09
开发语言·学习·matlab
wjs20242 小时前
Python XML 解析
开发语言
小白学大数据2 小时前
Temu 商品历史价格趋势爬虫与分析
开发语言·javascript·爬虫·python
帮帮志2 小时前
启动phcharm报错：Archived non-system classes are disabled because the java.system.
java·开发语言
秦苒&2 小时前
【C语言指针五】转移表、回调函数、qsort、qsort函数的模拟实现
c语言·开发语言·c#
棒棒的唐2 小时前
Avue2图片上传使用object对象模式时，axios的请求模式用post还是get？
开发语言·前端·javascript·avue
秋邱2 小时前
Java 运算符与流程控制：全类型运算符用法 + 分支 / 循环语句实战
java·开发语言
万邦科技Lafite2 小时前
淘宝开放API批量上架商品操作指南（2025年最新版）
开发语言·数据库·python·开放api·电商开放平台·淘宝开放平台
Chase_______2 小时前
【JAVA基础指南（二）】快速掌握流程控制
java·开发语言
热门推荐
01GitHub 镜像站点02UV安装并设置国内源03Linux下V2Ray安装配置指南04在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）05安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）06Labelme从安装到标注：零基础完整指南07CentOS的ISO镜像下载08BongoCat - 跨平台键盘猫动画工具09jdk21下载、安装（Windows、Linux、macOS）10NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南