主动噪声控制中的 FXLMS 算法研究与 MATLAB 实现

一、FXLMS 算法

FXLMS (Filtered-X Least Mean Square) 是主动噪声控制（ANC）中最经典的算法。其核心思想是：由于次级路径（从次级扬声器到误差麦克风）的存在，直接使用误差信号更新滤波器权值会产生偏差。因此，需要将参考信号先通过次级路径的估计模型进行滤波，然后再用于权值更新。

二、实现

2.1 主程序 (fxlms_active_noise_control.m)

%% 主动噪声控制中的 FXLMS 算法研究
% 功能：实现基于 FXLMS 算法的主动噪声控制系统

clear all; close all; clc;

fprintf('=== 主动噪声控制 FXLMS 算法研究 ===\n\n');

%% 1. 系统参数设置
params = struct();
params.fs = 8000;              % 采样频率 (Hz)
params.T = 2;                 % 仿真时长 (s)
params.N = params.fs * params.T; % 采样点数
params.filter_length = 64;     % 自适应滤波器长度
params.mu = 0.01;             % 步长参数 (学习率)
params.secondary_path_order = 32; % 次级路径模型阶数

fprintf('系统参数设置：\n');
fprintf('  采样频率: %d Hz\n', params.fs);
fprintf('  仿真时长: %d s\n', params.T);
fprintf('  采样点数: %d\n', params.N);
fprintf('  滤波器长度: %d\n', params.filter_length);
fprintf('  步长参数: %.4f\n\n', params.mu);

%% 2. 生成测试噪声信号
fprintf('生成测试噪声信号...\n');
[noise_signals] = generate_noise_signals(params);

fprintf('噪声信号信息：\n');
fprintf('  宽带噪声功率: %.4f\n', var(noise_signals.broadband));
fprintf('  正弦噪声频率: %.1f Hz\n', noise_signals.sine_freq);
fprintf('  信噪比: %.1f dB\n\n', 10*log10(var(noise_signals.primary)/var(noise_signals.broadband)));

%% 3. 建立次级路径模型
fprintf('建立次级路径模型...\n');
[secondary_path, secondary_path_est] = design_secondary_path(params);

fprintf('次级路径模型：\n');
fprintf('  真实路径阶数: %d\n', params.secondary_path_order);
fprintf('  估计路径阶数: %d\n', length(secondary_path_est)-1);
fprintf('  模型匹配误差: %.6f\n\n', norm(secondary_path - secondary_path_est));

%% 4. 初始化 FXLMS 控制器
fprintf('初始化 FXLMS 控制器...\n');
[controller] = initialize_fxlms_controller(params);

fprintf('控制器参数：\n');
fprintf('  滤波器权值初始化: 零向量\n');
fprintf('  步长参数: %.4f\n', params.mu);
fprintf('  收敛判据: 均方误差 < 1e-6\n\n', params.mu);

%% 5. 运行 FXLMS 算法
fprintf('运行 FXLMS 主动噪声控制...\n');
tic;
[results] = run_fxlms_algorithm(controller, noise_signals, secondary_path, secondary_path_est, params);
control_time = toc;

fprintf('控制完成！\n');
fprintf('  运行时间: %.2f 秒\n', control_time);
fprintf('  最终均方误差: %.6f\n', results.final_mse);
fprintf('  噪声衰减量: %.2f dB\n', results.noise_reduction);
fprintf('  收敛迭代次数: %d\n\n', results.convergence_iteration);

%% 6. 性能评估
fprintf('性能评估...\n');
[performance_metrics] = evaluate_fxlms_performance(results, params);

fprintf('性能指标：\n');
fprintf('  噪声衰减率: %.2f%%\n', performance_metrics.attenuation_ratio * 100);
fprintf('  收敛速度: %.2f 秒\n', performance_metrics.convergence_time);
fprintf('  稳态失调: %.6f\n', performance_metrics.steady_state_misadjustment);
fprintf('  计算复杂度: %.2f 次/秒\n\n', params.N / control_time);

%% 7. 结果可视化
fprintf('生成可视化结果...\n');
visualize_fxlms_results(results, noise_signals, params);

%% 8. 保存结果
save('fxlms_results.mat', 'results', 'params', 'performance_metrics');
fprintf('结果已保存到: fxlms_results.mat\n');

fprintf('\n=== FXLMS 算法研究完成 ===\n');

2.2 噪声信号生成模块 (generate_noise_signals.m)

function [noise_signals] = generate_noise_signals(params)
    % 生成各种噪声信号用于主动噪声控制测试
    
    N = params.N;
    fs = params.fs;
    t = (0:N-1)/fs;
    
    % 1. 主噪声信号（需要被消除的噪声）
    % 组合多种噪声类型
    sine_freq = 200;  % 200 Hz 正弦噪声
    sine_noise = 0.5 * sin(2*pi*sine_freq*t);
    
    broadband_noise = 0.3 * randn(1, N);  % 宽带高斯白噪声
    
    % 脉冲噪声（模拟突发噪声）
    impulse_noise = zeros(1, N);
    impulse_positions = [1000, 3000, 5000, 7000];
    for i = 1:length(impulse_positions)
        impulse_noise(impulse_positions(i)) = 2.0;
    end
    
    % 组合噪声
    primary_noise = sine_noise + broadband_noise + impulse_noise;
    
    % 2. 参考信号（用于自适应滤波器的输入）
    % 通常与主噪声相关，这里使用延迟版本
    delay_samples = 10;
    reference_signal = [zeros(1, delay_samples), primary_noise(1:end-delay_samples)];
    
    % 3. 次级噪声（次级路径引入的噪声）
    secondary_noise = 0.1 * randn(1, N);
    
    % 组织数据结构
    noise_signals.primary = primary_noise;
    noise_signals.reference = reference_signal;
    noise_signals.secondary = secondary_noise;
    noise_signals.broadband = broadband_noise;
    noise_signals.sine_freq = sine_freq;
    noise_signals.t = t;
    
    fprintf('  噪声信号生成完成\n');
end

2.3 次级路径设计模块 (design_secondary_path.m)

function [secondary_path, secondary_path_est] = design_secondary_path(params)
    % 设计次级路径模型（从次级扬声器到误差麦克风）
    
    % 真实次级路径（未知，需要被估计）
    % 使用有理分式模型：H(z) = B(z)/A(z)
    B_true = fir1(params.secondary_path_order, 0.3, 'low');  % FIR 滤波器
    A_true = [1, -0.8, 0.2];  % IIR 部分（可选）
    
    % 构建完整的次级路径传递函数
    secondary_path = tf(B_true, A_true, 1/params.fs);
    
    % 估计的次级路径（用于 FXLMS 算法）
    % 通常估计为 FIR 滤波器
    secondary_path_est = fir1(params.secondary_path_order, 0.3, 'low');
    
    % 添加估计误差（模拟实际估计不准确的情况）
    estimation_error = 0.05 * randn(1, length(secondary_path_est));
    secondary_path_est = secondary_path_est + estimation_error;
    
    fprintf('  次级路径设计完成\n');
end

2.4 FXLMS 控制器初始化 (initialize_fxlms_controller.m)

function [controller] = initialize_fxlms_controller(params)
    % 初始化 FXLMS 控制器
    
    % 自适应滤波器权值
    controller.w = zeros(params.filter_length, 1);
    
    % 步长参数
    controller.mu = params.mu;
    
    % 次级路径估计模型
    controller.S_hat = fir1(params.filter_length, 0.3, 'low');
    
    % 延迟缓冲器
    controller.x_buffer = zeros(params.filter_length, 1);
    controller.e_buffer = zeros(params.filter_length, 1);
    
    % 性能指标
    controller.mse_history = zeros(params.N, 1);
    controller.weight_history = zeros(params.N, params.filter_length);
    
    fprintf('  FXLMS 控制器初始化完成\n');
end

2.5 FXLMS 算法核心 (run_fxlms_algorithm.m)

function [results] = run_fxlms_algorithm(controller, noise_signals, secondary_path, secondary_path_est, params)
    % 运行 FXLMS 主动噪声控制算法
    
    N = params.N;
    filter_length = params.filter_length;
    mu = params.mu;
    
    % 初始化结果存储
    results.error_signal = zeros(1, N);
    results.control_signal = zeros(1, N);
    results.primary_noise = noise_signals.primary;
    results.reference_signal = noise_signals.reference;
    
    % 次级路径滤波器
    S_hat = secondary_path_est;
    
    % 初始化权值
    w = controller.w;
    x_buffer = controller.x_buffer;
    
    fprintf('  开始 FXLMS 迭代...\n');
    
    for n = 1:N
        % 1. 获取当前参考信号
        x = noise_signals.reference(n);
        
        % 2. 更新参考信号缓冲区
        x_buffer = [x; x_buffer(1:end-1)];
        
        % 3. 计算自适应滤波器输出（控制信号）
        y = w' * x_buffer;
        results.control_signal(n) = y;
        
        % 4. 通过真实次级路径得到实际抵消信号
        if n == 1
            d = noise_signals.primary(n);
            s_y = 0;
        else
            % 使用真实次级路径
            [s_y, ~] = filter(secondary_path.num{1}, secondary_path.den{1}, ...
                             [y, results.control_signal(max(1,n-filter_length+1):n-1)], ...
                             [], n-1);
        end
        
        % 5. 计算误差信号
        d = noise_signals.primary(n);
        e = d - s_y + noise_signals.secondary(n);
        results.error_signal(n) = e;
        
        % 6. FXLMS 权值更新
        % 关键步骤：将参考信号通过估计的次级路径滤波
        x_filtered = filter(S_hat, 1, x_buffer);
        
        % 更新权值
        w = w + mu * e * x_filtered;
        
        % 7. 存储历史数据
        controller.mse_history(n) = e^2;
        controller.weight_history(n, :) = w';
        
        % 8. 显示进度
        if mod(n, 1000) == 0
            fprintf('    迭代 %d/%d: 当前MSE = %.6f\n', n, N, e^2);
        end
    end
    
    % 整理结果
    results.final_mse = controller.mse_history(end);
    results.final_weights = w;
    results.mse_history = controller.mse_history;
    results.weight_history = controller.weight_history;
    
    % 计算噪声衰减量
    original_power = mean(noise_signals.primary.^2);
    residual_power = mean(results.error_signal.^2);
    results.noise_reduction = 10 * log10(original_power / residual_power);
    
    % 找到收敛迭代次数
    mse_threshold = 0.01;
    convergence_idx = find(controller.mse_history < mse_threshold, 1, 'first');
    if ~isempty(convergence_idx)
        results.convergence_iteration = convergence_idx;
    else
        results.convergence_iteration = N;
    end
    
    fprintf('  FXLMS 算法运行完成\n');
end

2.6 性能评估模块 (evaluate_fxlms_performance.m)

function [performance_metrics] = evaluate_fxlms_performance(results, params)
    % 评估 FXLMS 算法性能
    
    % 1. 噪声衰减率
    original_power = mean(results.primary_noise.^2);
    residual_power = mean(results.error_signal.^2);
    attenuation_ratio = 1 - residual_power / original_power;
    
    % 2. 收敛时间
    mse_threshold = 0.01;  % 收敛阈值
    convergence_idx = find(results.mse_history < mse_threshold, 1, 'first');
    if ~isempty(convergence_idx)
        convergence_time = convergence_idx / params.fs;
    else
        convergence_time = params.T;
    end
    
    % 3. 稳态失调
    steady_state_start = round(0.8 * params.N);
    steady_state_mse = mean(results.mse_history(steady_state_start:end));
    steady_state_misadjustment = steady_state_mse / original_power;
    
    % 4. 计算复杂度
    operations_per_sample = params.filter_length * 2;  % 乘法和加法
    total_operations = operations_per_sample * params.N;
    computational_complexity = total_operations / params.T;
    
    % 5. 频率响应分析
    [freq_response, f] = freqz(results.final_weights, 1, 1024, params.fs);
    magnitude_response = 20 * log10(abs(freq_response));
    
    % 6. 相位响应
    phase_response = unwrap(angle(freq_response)) * 180 / pi;
    
    % 组织性能指标
    performance_metrics.attenuation_ratio = attenuation_ratio;
    performance_metrics.convergence_time = convergence_time;
    performance_metrics.steady_state_misadjustment = steady_state_misadjustment;
    performance_metrics.computational_complexity = computational_complexity;
    performance_metrics.frequency_response = magnitude_response;
    performance_metrics.phase_response = phase_response;
    performance_metrics.frequency_axis = f;
    
    fprintf('  性能评估完成\n');
end

2.7 可视化模块 (visualize_fxlms_results.m)

function visualize_fxlms_results(results, noise_signals, params)
    % 可视化 FXLMS 算法结果
    
    figure('Position', [100, 100, 1400, 900]);
    
    % 1. 时域信号对比
    subplot(3, 4, 1);
    t = noise_signals.t;
    plot(t(1:1000), noise_signals.primary(1:1000), 'b-', 'LineWidth', 1.5);
    hold on;
    plot(t(1:1000), results.error_signal(1:1000), 'r-', 'LineWidth', 1.5);
    xlabel('时间 (s)');
    ylabel('幅度');
    title('原始噪声 vs 残余噪声 (前1秒)');
    legend('原始噪声', '残余噪声');
    grid on;
    
    % 2. 控制信号
    subplot(3, 4, 2);
    plot(t(1:1000), results.control_signal(1:1000), 'g-', 'LineWidth', 1.5);
    xlabel('时间 (s)');
    ylabel('控制信号幅度');
    title('自适应滤波器输出 (控制信号)');
    grid on;
    
    % 3. 误差信号收敛曲线
    subplot(3, 4, 3);
    semilogy(1:params.N, results.mse_history, 'b-', 'LineWidth', 1.5);
    xlabel('迭代次数');
    ylabel('均方误差 (对数尺度)');
    title('FXLMS 收敛曲线');
    grid on;
    
    % 4. 噪声衰减效果
    subplot(3, 4, 4);
    % 计算短时功率谱
    window_length = 256;
    noverlap = 128;
    [S_original, f_original, t_spec] = spectrogram(noise_signals.primary, window_length, noverlap, window_length, params.fs);
    [S_residual, f_residual, ~] = spectrogram(results.error_signal, window_length, noverlap, window_length, params.fs);
    
    % 绘制频谱对比
    subplot(3, 4, 4);
    plot(f_original, 10*log10(abs(S_original(:,1))), 'b-', 'LineWidth', 1.5);
    hold on;
    plot(f_residual, 10*log10(abs(S_residual(:,1))), 'r-', 'LineWidth', 1.5);
    xlabel('频率 (Hz)');
    ylabel('功率谱密度 (dB/Hz)');
    title('噪声频谱衰减效果');
    legend('原始噪声', '残余噪声');
    grid on;
    
    % 5. 自适应滤波器权值
    subplot(3, 4, 5);
    plot(1:params.filter_length, results.final_weights, 'b-', 'LineWidth', 2);
    xlabel('权值索引');
    ylabel('权值大小');
    title('自适应滤波器最终权值');
    grid on;
    
    % 6. 权值收敛过程
    subplot(3, 4, 6);
    imagesc(1:params.filter_length, 1:min(1000, params.N), results.weight_history(1:min(1000, params.N), :)');
    xlabel('权值索引');
    ylabel('迭代次数');
    title('权值收敛过程 (前1000次迭代)');
    colorbar;
    
    % 7. 频率响应
    subplot(3, 4, 7);
    plot(performance_metrics.frequency_axis, performance_metrics.frequency_response, 'b-', 'LineWidth', 2);
    xlabel('频率 (Hz)');
    ylabel('幅度 (dB)');
    title('自适应滤波器频率响应');
    grid on;
    
    % 8. 相位响应
    subplot(3, 4, 8);
    plot(performance_metrics.frequency_axis, performance_metrics.phase_response, 'r-', 'LineWidth', 2);
    xlabel('频率 (Hz)');
    ylabel('相位 (度)');
    title('自适应滤波器相位响应');
    grid on;
    
    % 9. 功率谱密度对比
    subplot(3, 4, 9);
    [pxx_original, f_pxx] = pwelch(noise_signals.primary, window_length, noverlap, window_length, params.fs);
    [pxx_residual, ~] = pwelch(results.error_signal, window_length, noverlap, window_length, params.fs);
    plot(f_pxx, 10*log10(pxx_original), 'b-', 'LineWidth', 1.5);
    hold on;
    plot(f_pxx, 10*log10(pxx_residual), 'r-', 'LineWidth', 1.5);
    xlabel('频率 (Hz)');
    ylabel('功率谱密度 (dB/Hz)');
    title('功率谱密度对比');
    legend('原始噪声', '残余噪声');
    grid on;
    
    % 10. 控制效果统计
    subplot(3, 4, 10);
    axis off;
    
    % 计算统计信息
    original_power = mean(noise_signals.primary.^2);
    residual_power = mean(results.error_signal.^2);
    noise_reduction_db = 10 * log10(original_power / residual_power);
    
    stats_text = sprintf(['FXLMS 主动噪声控制性能统计\n\n', ...
                         '噪声衰减效果:\n', ...
                         '  原始噪声功率: %.4f\n', ...
                         '  残余噪声功率: %.4f\n', ...
                         '  噪声衰减量: %.2f dB\n', ...
                         '  衰减率: %.1f%%\n\n', ...
                         '收敛性能:\n', ...
                         '  收敛迭代次数: %d\n', ...
                         '  收敛时间: %.2f 秒\n', ...
                         '  稳态失调: %.6f\n\n', ...
                         '计算性能:\n', ...
                         '  滤波器长度: %d\n', ...
                         '  步长参数: %.4f\n', ...
                         '  计算复杂度: %.0f 次/秒'],
                         original_power, residual_power, noise_reduction_db, ...
                         (1 - residual_power/original_power)*100, ...
                         results.convergence_iteration, ...
                         results.convergence_iteration/params.fs, ...
                         performance_metrics.steady_state_misadjustment, ...
                         params.filter_length, params.mu, ...
                         performance_metrics.computational_complexity);
    
    text(0.1, 0.5, stats_text, 'FontSize', 10, 'FontWeight', 'bold');
    
    % 11. 实时控制效果
    subplot(3, 4, 11);
    % 显示整个时间段的控制效果
    plot(t, 10*log10(abs(noise_signals.primary).^2), 'b-', 'LineWidth', 1);
    hold on;
    plot(t, 10*log10(abs(results.error_signal).^2), 'r-', 'LineWidth', 1);
    xlabel('时间 (s)');
    ylabel('瞬时功率 (dB)');
    title('实时噪声控制效果');
    legend('原始噪声', '残余噪声');
    grid on;
    
    % 12. 算法稳定性分析
    subplot(3, 4, 12);
    % 检查权值是否发散
    weight_norm = sqrt(sum(results.final_weights.^2));
    plot(1:params.N, sqrt(sum(results.weight_history.^2, 2)), 'g-', 'LineWidth', 1.5);
    xlabel('迭代次数');
    ylabel('权值范数');
    title('算法稳定性分析');
    grid on;
    
    sgtitle('基于 FXLMS 算法的主动噪声控制结果分析');
end

2.8 测试脚本 (test_fxlms_algorithm.m)

%% FXLMS 算法测试脚本
clear all; close all; clc;

fprintf('=== FXLMS 算法测试 ===\n\n');

%% 测试1: 不同步长参数对性能的影响
fprintf('测试1: 步长参数影响分析\n');

step_sizes = [0.001, 0.005, 0.01, 0.05, 0.1];
step_results = zeros(length(step_sizes), 4);

for i = 1:length(step_sizes)
    fprintf('  测试步长参数 μ = %.3f...\n', step_sizes(i));
    
    % 创建配置
    params = struct();
    params.fs = 8000;
    params.T = 1;
    params.N = params.fs * params.T;
    params.filter_length = 32;
    params.mu = step_sizes(i);
    params.secondary_path_order = 16;
    
    % 生成数据
    noise_signals = generate_noise_signals(params);
    [secondary_path, secondary_path_est] = design_secondary_path(params);
    controller = initialize_fxlms_controller(params);
    
    % 运行算法
    results = run_fxlms_algorithm(controller, noise_signals, secondary_path, secondary_path_est, params);
    
    % 计算性能指标
    original_power = mean(noise_signals.primary.^2);
    residual_power = mean(results.error_signal.^2);
    noise_reduction = 10 * log10(original_power / residual_power);
    
    % 找到收敛时间
    mse_threshold = 0.01;
    convergence_idx = find(results.mse_history < mse_threshold, 1, 'first');
    if ~isempty(convergence_idx)
        convergence_time = convergence_idx / params.fs;
    else
        convergence_time = params.T;
    end
    
    step_results(i, :) = [step_sizes(i), noise_reduction, convergence_time, results.final_mse];
end

% 可视化结果
figure('Position', [100, 100, 1200, 400]);
subplot(1, 3, 1);
plot(step_results(:, 1), step_results(:, 2), 'bo-', 'LineWidth', 2, 'MarkerSize', 8);
xlabel('步长参数 μ');
ylabel('噪声衰减量 (dB)');
title('步长参数对噪声衰减的影响');
grid on;

subplot(1, 3, 2);
plot(step_results(:, 1), step_results(:, 3), 'ro-', 'LineWidth', 2, 'MarkerSize', 8);
xlabel('步长参数 μ');
ylabel('收敛时间 (s)');
title('步长参数对收敛速度的影响');
grid on;

subplot(1, 3, 3);
plot(step_results(:, 1), step_results(:, 4), 'go-', 'LineWidth', 2, 'MarkerSize', 8);
xlabel('步长参数 μ');
ylabel('最终均方误差');
title('步长参数对稳态误差的影响');
grid on;

%% 测试2: 不同滤波器长度的影响
fprintf('\n测试2: 滤波器长度影响分析\n');

filter_lengths = [16, 32, 64, 128, 256];
length_results = zeros(length(filter_lengths), 3);

for i = 1:length(filter_lengths)
    fprintf('  测试滤波器长度 L = %d...\n', filter_lengths(i));
    
    % 创建配置
    params = struct();
    params.fs = 8000;
    params.T = 1;
    params.N = params.fs * params.T;
    params.filter_length = filter_lengths(i);
    params.mu = 0.01;
    params.secondary_path_order = 16;
    
    % 生成数据
    noise_signals = generate_noise_signals(params);
    [secondary_path, secondary_path_est] = design_secondary_path(params);
    controller = initialize_fxlms_controller(params);
    
    % 运行算法
    results = run_fxlms_algorithm(controller, noise_signals, secondary_path, secondary_path_est, params);
    
    % 计算性能指标
    original_power = mean(noise_signals.primary.^2);
    residual_power = mean(results.error_signal.^2);
    noise_reduction = 10 * log10(original_power / residual_power);
    
    computation_time = params.N / (params.N * params.filter_length * 2);
    
    length_results(i, :) = [filter_lengths(i), noise_reduction, computation_time];
end

% 可视化结果
figure('Position', [100, 100, 800, 400]);
subplot(1, 2, 1);
plot(length_results(:, 1), length_results(:, 2), 'bo-', 'LineWidth', 2, 'MarkerSize', 8);
xlabel('滤波器长度 L');
ylabel('噪声衰减量 (dB)');
title('滤波器长度对噪声衰减的影响');
grid on;

subplot(1, 2, 2);
plot(length_results(:, 1), length_results(:, 3), 'ro-', 'LineWidth', 2, 'MarkerSize', 8);
xlabel('滤波器长度 L');
ylabel('计算复杂度 (相对值)');
title('滤波器长度对计算复杂度的影响');
grid on;

%% 测试3: 次级路径估计误差的影响
fprintf('\n测试3: 次级路径估计误差影响分析\n');

estimation_errors = [0, 0.01, 0.05, 0.1, 0.2];
error_results = zeros(length(estimation_errors), 3);

for i = 1:length(estimation_errors)
    fprintf('  测试估计误差 %.2f...\n', estimation_errors(i));
    
    % 创建配置
    params = struct();
    params.fs = 8000;
    params.T = 1;
    params.N = params.fs * params.T;
    params.filter_length = 32;
    params.mu = 0.01;
    params.secondary_path_order = 16;
    
    % 生成数据
    noise_signals = generate_noise_signals(params);
    [secondary_path, secondary_path_est] = design_secondary_path(params);
    
    % 添加估计误差
    secondary_path_est = secondary_path_est + estimation_errors(i) * randn(size(secondary_path_est));
    
    controller = initialize_fxlms_controller(params);
    
    % 运行算法
    results = run_fxlms_algorithm(controller, noise_signals, secondary_path, secondary_path_est, params);
    
    % 计算性能指标
    original_power = mean(noise_signals.primary.^2);
    residual_power = mean(results.error_signal.^2);
    noise_reduction = 10 * log10(original_power / residual_power);
    
    error_results(i, :) = [estimation_errors(i), noise_reduction, results.final_mse];
end

% 可视化结果
figure('Position', [100, 100, 800, 400]);
subplot(1, 2, 1);
plot(error_results(:, 1), error_results(:, 2), 'bo-', 'LineWidth', 2, 'MarkerSize', 8);
xlabel('估计误差');
ylabel('噪声衰减量 (dB)');
title('次级路径估计误差对噪声衰减的影响');
grid on;

subplot(1, 2, 2);
plot(error_results(:, 1), error_results(:, 3), 'ro-', 'LineWidth', 2, 'MarkerSize', 8);
xlabel('估计误差');
ylabel('最终均方误差');
title('次级路径估计误差对稳态误差的影响');
grid on;

fprintf('\n所有测试完成！\n');

参考代码 主动噪声控制中的FXLMS算法研究 www.youwenfan.com/contentcsu/63385.html

三、参数

参数

参数	建议值	调整原则
步长参数 μ	0.001-0.1	太小收敛慢，太大不稳定
滤波器长度	32-128	根据噪声频率范围调整
次级路径阶数	16-64	根据物理系统特性调整
采样频率	8000-16000 Hz	至少为目标噪声最高频率的2倍