QPSK/BPSK在多径信道下经过LMS均衡器后的误码率曲线分析

MATLAB仿真，分析QPSK和BPSK在多径信道下经过LMS均衡器后的误码率性能。

系统模型概述

%% QPSK/BPSK在多径信道下经过LMS均衡器的误码率仿真
clear; close all; clc;

% 系统参数设置
system_params = initialize_system_parameters();

% 仿真参数
simulation_params = initialize_simulation_parameters();

% 运行主仿真
[ber_bpsk, ber_qpsk] = run_main_simulation(system_params, simulation_params);

% 绘制结果
plot_ber_results(ber_bpsk, ber_qpsk, system_params.SNR_dB);

核心算法实现

1. 参数初始化函数

function system_params = initialize_system_parameters()
% 初始化系统参数
    system_params = struct();
    
    % 调制参数
    system_params.modulation_types = {'BPSK', 'QPSK'};
    system_params.symbol_rate = 1000;      % 符号速率 (Hz)
    system_params.sampling_rate = 8000;    % 采样率 (Hz)
    system_params.oversampling = 8;        % 过采样率
    
    % 多径信道参数
    system_params.multipath_delays = [0, 2, 4, 6];     % 多径时延 (采样点数)
    system_params.multipath_gains = [1, 0.5, 0.3, 0.2]; % 多径增益
    system_params.doppler_shift = 10;      % 多普勒频移 (Hz)
    
    % LMS均衡器参数
    system_params.equalizer_length = 21;   % 均衡器长度
    system_params.step_size = 0.01;        % LMS步长
    system_params.leakage_factor = 0.001;  % 泄漏因子
    
    % 仿真参数
    system_params.SNR_dB = 0:2:20;         % 信噪比范围 (dB)
    system_params.training_length = 1000;  % 训练序列长度
    system_params.data_length = 10000;     % 数据长度
    
    fprintf('系统参数初始化完成\n');
end

function simulation_params = initialize_simulation_parameters()
% 初始化仿真参数
    simulation_params = struct();
    simulation_params.num_monte_carlo = 100;   % 蒙特卡洛仿真次数
    simulation_params.show_progress = true;    % 显示进度
    simulation_params.plot_intermediate = false; % 绘制中间结果
end

2. 主仿真函数

function [ber_bpsk, ber_qpsk] = run_main_simulation(system_params, simulation_params)
% 运行主仿真
    
    fprintf('开始主仿真...\n');
    
    SNR_dB = system_params.SNR_dB;
    num_snr = length(SNR_dB);
    
    % 初始化误码率数组
    ber_bpsk = zeros(1, num_snr);
    ber_qpsk = zeros(1, num_snr);
    
    % 对每个SNR进行仿真
    for snr_idx = 1:num_snr
        current_snr = SNR_dB(snr_idx);
        fprintf('处理 SNR = %d dB...\n', current_snr);
        
        % 临时存储每次蒙特卡洛仿真的结果
        temp_ber_bpsk = zeros(1, simulation_params.num_monte_carlo);
        temp_ber_qpsk = zeros(1, simulation_params.num_monte_carlo);
        
        parfor mc_iter = 1:simulation_params.num_monte_carlo
            % BPSK仿真
            temp_ber_bpsk(mc_iter) = simulate_bpsk_system(...
                system_params, current_snr);
            
            % QPSK仿真
            temp_ber_qpsk(mc_iter) = simulate_qpsk_system(...
                system_params, current_snr);
        end
        
        % 计算平均误码率
        ber_bpsk(snr_idx) = mean(temp_ber_bpsk);
        ber_qpsk(snr_idx) = mean(temp_ber_qpsk);
        
        fprintf('  BPSK BER: %.2e, QPSK BER: %.2e\n', ...
                ber_bpsk(snr_idx), ber_qpsk(snr_idx));
    end
    
    fprintf('主仿真完成\n');
end

3. BPSK系统仿真

function ber = simulate_bpsk_system(system_params, snr_dB)
% BPSK系统仿真
    
    % 生成BPSK信号
    [tx_signal, original_bits] = generate_bpsk_signal(system_params);
    
    % 多径信道
    [channel_output, channel_state] = multipath_channel(...
        tx_signal, system_params);
    
    % 添加噪声
    received_signal = add_awgn_noise(channel_output, snr_dB, system_params);
    
    % LMS均衡
    [equalized_signal, equalizer_weights, mse_curve] = lms_equalizer(...
        received_signal, tx_signal, system_params);
    
    % 检测和解调
    detected_bits = bpsk_demodulate(equalized_signal);
    
    % 计算误码率（跳过训练序列）
    valid_start = system_params.training_length + 1;
    valid_end = length(original_bits);
    
    if valid_start <= valid_end
        error_bits = sum(original_bits(valid_start:valid_end) ~= ...
                        detected_bits(valid_start:valid_end));
        total_bits = valid_end - valid_start + 1;
        ber = error_bits / total_bits;
    else
        ber = 1;  % 错误情况
    end
end

function [tx_signal, original_bits] = generate_bpsk_signal(system_params)
% 生成BPSK信号
    total_length = system_params.training_length + system_params.data_length;
    
    % 生成随机比特
    original_bits = randi([0, 1], 1, total_length);
    
    % BPSK调制: 0 -> +1, 1 -> -1
    tx_signal = 2 * original_bits - 1;
    
    % 过采样
    tx_signal = upsample(tx_signal, system_params.oversampling);
    
    % 脉冲成形（升余弦滤波器）
    tx_signal = pulse_shaping(tx_signal, system_params);
end

4. QPSK系统仿真

function ber = simulate_qpsk_system(system_params, snr_dB)
% QPSK系统仿真
    
    % 生成QPSK信号
    [tx_signal, original_symbols, original_bits] = generate_qpsk_signal(system_params);
    
    % 多径信道
    [channel_output, channel_state] = multipath_channel(...
        tx_signal, system_params);
    
    % 添加噪声
    received_signal = add_awgn_noise(channel_output, snr_dB, system_params);
    
    % LMS均衡
    [equalized_signal, equalizer_weights, mse_curve] = lms_equalizer(...
        received_signal, tx_signal, system_params);
    
    % QPSK解调
    detected_bits = qpsk_demodulate(equalized_signal);
    
    % 计算误码率
    valid_start = system_params.training_length * 2 + 1; % QPSK每个符号2比特
    valid_end = length(original_bits);
    
    if valid_start <= valid_end
        error_bits = sum(original_bits(valid_start:valid_end) ~= ...
                        detected_bits(valid_start:valid_end));
        total_bits = valid_end - valid_start + 1;
        ber = error_bits / total_bits;
    else
        ber = 1;
    end
end

function [tx_signal, original_symbols, original_bits] = generate_qpsk_signal(system_params)
% 生成QPSK信号
    total_symbols = system_params.training_length + system_params.data_length;
    total_bits = total_symbols * 2;
    
    % 生成随机比特
    original_bits = randi([0, 1], 1, total_bits);
    
    % QPSK调制
    original_symbols = qpsk_modulate(original_bits);
    
    % 过采样
    tx_signal = upsample(original_symbols, system_params.oversampling);
    
    % 脉冲成形
    tx_signal = pulse_shaping(tx_signal, system_params);
end

function modulated_symbols = qpsk_modulate(bits)
% QPSK调制
    % 重新排列比特对
    even_bits = bits(1:2:end);
    odd_bits = bits(2:2:end);
    
    % QPSK映射: 
    % 00 -> +1+j, 01 -> +1-j, 10 -> -1+j, 11 -> -1-j
    I_component = 1 - 2 * even_bits;  % 同相分量
    Q_component = 1 - 2 * odd_bits;   % 正交分量
    
    modulated_symbols = (I_component + 1j * Q_component) / sqrt(2);
end

function detected_bits = qpsk_demodulate(signal)
% QPSK解调
    detected_bits = zeros(1, length(signal) * 2);
    
    for i = 1:length(signal)
        % 判决
        real_part = real(signal(i));
        imag_part = imag(signal(i));
        
        % 解调比特对
        bit1 = (real_part < 0);
        bit2 = (imag_part < 0);
        
        detected_bits(2*i-1) = bit1;
        detected_bits(2*i) = bit2;
    end
end

5. 多径信道模型

function [channel_output, channel_state] = multipath_channel(input_signal, system_params)
% 多径信道模拟
    
    delays = system_params.multipath_delays;
    gains = system_params.multipath_gains;
    
    % 确保延迟为整数
    delays = round(delays);
    max_delay = max(delays);
    
    % 初始化输出信号
    channel_output = zeros(1, length(input_signal) + max_delay);
    
    % 添加每条路径的贡献
    for i = 1:length(delays)
        delay = delays(i);
        gain = gains(i);
        
        delayed_signal = [zeros(1, delay), input_signal, zeros(1, max_delay - delay)];
        channel_output = channel_output + gain * delayed_signal(1:length(channel_output));
    end
    
    % 添加多普勒效应
    if system_params.doppler_shift > 0
        channel_output = add_doppler_effect(channel_output, system_params);
    end
    
    channel_state = struct();
    channel_state.delays = delays;
    channel_state.gains = gains;
end

function output_signal = add_doppler_effect(input_signal, system_params)
% 添加多普勒效应
    t = (0:length(input_signal)-1) / system_params.sampling_rate;
    doppler_phase = 2 * pi * system_params.doppler_shift * t;
    
    % 相位旋转
    output_signal = input_signal .* exp(1j * doppler_phase);
end

6. LMS均衡器实现

function [equalized_signal, weights, mse_curve] = lms_equalizer(...
    received_signal, training_signal, system_params)
% LMS自适应均衡器
    
    equalizer_length = system_params.equalizer_length;
    step_size = system_params.step_size;
    leakage = system_params.leakage_factor;
    
    % 初始化
    weights = zeros(1, equalizer_length);
    weights(ceil(equalizer_length/2)) = 1;  % 中心抽头初始化为1
    
    equalized_signal = zeros(1, length(received_signal));
    mse_curve = zeros(1, length(received_signal));
    
    % 延迟补偿（由于均衡器引入的群延迟）
    delay = floor(equalizer_length / 2);
    
    for n = equalizer_length:length(received_signal)
        % 提取输入向量
        input_vector = received_signal(n:-1:n-equalizer_length+1);
        
        % 均衡器输出
        equalized_output = weights * input_vector';
        equalized_signal(n) = equalized_output;
        
        % 计算误差（仅在训练阶段使用已知序列）
        if n <= length(training_signal)
            desired_output = training_signal(n);
            error = desired_output - equalized_output;
        else
            % 判决导向模式
            if isreal(equalized_output)
                % BPSK判决
                detected = sign(real(equalized_output));
                error = detected - real(equalized_output);
            else
                % QPSK判决
                detected = sign(real(equalized_output)) + 1j * sign(imag(equalized_output));
                detected = detected / sqrt(2);
                error = detected - equalized_output;
            end
        end
        
        % LMS权重更新（带泄漏）
        weights = (1 - step_size * leakage) * weights + ...
                  step_size * error * conj(input_vector);
        
        % 记录MSE
        mse_curve(n) = abs(error)^2;
    end
    
    % 补偿延迟
    equalized_signal = [equalized_signal(delay+1:end), zeros(1, delay)];
end

7. 辅助函数

function shaped_signal = pulse_shaping(input_signal, system_params)
% 升余弦脉冲成形
    rolloff = 0.35;  % 滚降系数
    span = 6;        % 滤波器跨度
    
    % 创建升余弦滤波器
    filter_coeff = rcosdesign(rolloff, span, system_params.oversampling);
    
    % 滤波
    shaped_signal = filter(filter_coeff, 1, input_signal);
end

function noisy_signal = add_awgn_noise(clean_signal, snr_dB, system_params)
% 添加加性高斯白噪声
    snr_linear = 10^(snr_dB/10);
    
    if isreal(clean_signal)
        % 实信号
        signal_power = mean(clean_signal.^2);
        noise_power = signal_power / snr_linear;
        noise = sqrt(noise_power) * randn(size(clean_signal));
        noisy_signal = clean_signal + noise;
    else
        % 复信号
        signal_power = mean(abs(clean_signal).^2);
        noise_power = signal_power / snr_linear;
        noise = sqrt(noise_power/2) * (randn(size(clean_signal)) + ...
                                      1j * randn(size(clean_signal)));
        noisy_signal = clean_signal + noise;
    end
end

function detected_bits = bpsk_demodulate(signal)
% BPSK解调
    detected_bits = real(signal) < 0;
end

8. 结果绘制和分析函数

function plot_ber_results(ber_bpsk, ber_qpsk, SNR_dB)
% 绘制误码率曲线结果
    
    figure('Position', [100, 100, 1200, 800]);
    
    % 理论误码率曲线（AWGN信道，无多径）
    snr_linear = 10.^(SNR_dB/10);
    theory_ber_bpsk_awgn = 0.5 * erfc(sqrt(snr_linear));
    theory_ber_qpsk_awgn = 0.5 * erfc(sqrt(snr_linear));
    
    % 主误码率曲线
    subplot(2, 2, [1, 2]);
    semilogy(SNR_dB, ber_bpsk, 'ro-', 'LineWidth', 2, 'MarkerSize', 8, ...
             'DisplayName', 'BPSK + LMS均衡 (多径)');
    hold on;
    semilogy(SNR_dB, ber_qpsk, 'bs-', 'LineWidth', 2, 'MarkerSize', 8, ...
             'DisplayName', 'QPSK + LMS均衡 (多径)');
    semilogy(SNR_dB, theory_ber_bpsk_awgn, 'r--', 'LineWidth', 1.5, ...
             'DisplayName', 'BPSK理论 (AWGN)');
    semilogy(SNR_dB, theory_ber_qpsk_awgn, 'b--', 'LineWidth', 1.5, ...
             'DisplayName', 'QPSK理论 (AWGN)');
    
    grid on;
    xlabel('信噪比 (dB)');
    ylabel('误码率 (BER)');
    title('QPSK/BPSK在多径信道下经过LMS均衡器后的误码率性能');
    legend('Location', 'southwest');
    ylim([1e-6, 1]);
    
    % 性能增益分析
    subplot(2, 2, 3);
    
    % 计算相对于理论值的性能损失
    perf_loss_bpsk = zeros(size(SNR_dB));
    perf_loss_qpsk = zeros(size(SNR_dB));
    
    for i = 1:length(SNR_dB)
        if ber_bpsk(i) > 0 && theory_ber_bpsk_awgn(i) > 0
            perf_loss_bpsk(i) = 10 * log10(ber_bpsk(i) / theory_ber_bpsk_awgn(i));
        end
        if ber_qpsk(i) > 0 && theory_ber_qpsk_awgn(i) > 0
            perf_loss_qpsk(i) = 10 * log10(ber_qpsk(i) / theory_ber_qpsk_awgn(i));
        end
    end
    
    plot(SNR_dB, perf_loss_bpsk, 'ro-', 'LineWidth', 2, 'DisplayName', 'BPSK性能损失');
    hold on;
    plot(SNR_dB, perf_loss_qpsk, 'bs-', 'LineWidth', 2, 'DisplayName', 'QPSK性能损失');
    grid on;
    xlabel('信噪比 (dB)');
    ylabel('性能损失 (dB)');
    title('相对于AWGN信道的性能损失');
    legend;
    
    % 频谱效率比较
    subplot(2, 2, 4);
    
    % 在相同误码率下的SNR要求
    target_ber = 1e-3;
    snr_req_bpsk = interp1(log10(ber_bpsk), SNR_dB, log10(target_ber), 'linear');
    snr_req_qpsk = interp1(log10(ber_qpsk), SNR_dB, log10(target_ber), 'linear');
    
    efficiency_data = [1, snr_req_bpsk; 2, snr_req_qpsk];
    bar(efficiency_data(:, 1), efficiency_data(:, 2));
    set(gca, 'XTickLabel', {'BPSK', 'QPSK'});
    ylabel('所需SNR (dB)');
    title(sprintf('在BER=10^{-3}时的SNR要求'));
    grid on;
    
    % 添加数值标签
    for i = 1:2
        text(i, efficiency_data(i, 2) + 0.5, ...
             sprintf('%.1f dB', efficiency_data(i, 2)), ...
             'HorizontalAlignment', 'center');
    end
    
    % 显示关键性能指标
    fprintf('\n=== 性能分析结果 ===\n');
    fprintf('在BER=1e-3时:\n');
    fprintf('  BPSK需要 SNR = %.2f dB\n', snr_req_bpsk);
    fprintf('  QPSK需要 SNR = %.2f dB\n', snr_req_qpsk);
    fprintf('  QPSK相对于BPSK的频谱效率增益: 2倍\n');
    fprintf('  QPSK相对于BPSK的SNR损失: %.2f dB\n', snr_req_qpsk - snr_req_bpsk);
end

9. 高级分析功能

function advanced_analysis(system_params)
% 高级分析：均衡器收敛性、信道响应等
    
    fprintf('进行高级分析...\n');
    
    % 生成测试信号
    test_snr = 10;  % dB
    [tx_signal, ~] = generate_bpsk_signal(system_params);
    
    % 多径信道
    [channel_output, channel_state] = multipath_channel(tx_signal, system_params);
    
    % 添加噪声
    received_signal = add_awgn_noise(channel_output, test_snr, system_params);
    
    % LMS均衡
    [equalized_signal, weights, mse_curve] = lms_equalizer(...
        received_signal, tx_signal, system_params);
    
    % 绘制收敛曲线
    figure('Position', [100, 100, 1000, 800]);
    
    subplot(2, 2, 1);
    plot(10*log10(mse_curve(mse_curve > 0)), 'LineWidth', 2);
    grid on;
    xlabel('迭代次数');
    ylabel('MSE (dB)');
    title('LMS均衡器收敛特性');
    
    % 均衡器权重
    subplot(2, 2, 2);
    stem(weights, 'filled', 'LineWidth', 2);
    grid on;
    xlabel('抽头索引');
    ylabel('权重值');
    title('LMS均衡器最终权重');
    
    % 信道频率响应
    subplot(2, 2, 3);
    [h_channel, w] = freqz(system_params.multipath_gains, 1, 1024);
    plot(w/pi, 20*log10(abs(h_channel)), 'LineWidth', 2);
    grid on;
    xlabel('归一化频率 (\times \pi rad/sample)');
    ylabel('幅度 (dB)');
    title('多径信道频率响应');
    
    % 均衡后信道响应
    subplot(2, 2, 4);
    overall_response = conv(system_params.multipath_gains, weights);
    [h_total, w] = freqz(overall_response, 1, 1024);
    plot(w/pi, 20*log10(abs(h_total)), 'LineWidth', 2);
    grid on;
    xlabel('归一化频率 (\times \pi rad/sample)');
    ylabel('幅度 (dB)');
    title('均衡后整体信道响应');
    
    fprintf('高级分析完成\n');
end

完整仿真流程

%% 主运行脚本
clear; close all; clc;

fprintf('=== QPSK/BPSK在多径信道下经过LMS均衡器的误码率仿真 ===\n\n');

% 1. 初始化参数
system_params = initialize_system_parameters();
simulation_params = initialize_simulation_parameters();

% 2. 运行主仿真
[ber_bpsk, ber_qpsk] = run_main_simulation(system_params, simulation_params);

% 3. 绘制结果
plot_ber_results(ber_bpsk, ber_qpsk, system_params.SNR_dB);

% 4. 高级分析
advanced_analysis(system_params);

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

参考代码 QPSK/BPSK在多径信道下经过LMS均衡器之后的误码率曲线 www.youwenfan.com/contentcnk/66148.html

预期结果分析

运行此仿真后，您将获得：

1. 主要误码率曲线：

   • BPSK和QPSK在多径信道下使用LMS均衡器的性能
   • 与理论AWGN信道性能的比较
   • 显示均衡器对多径效应的补偿效果

2. 性能分析：

   • QPSK相对于BPSK的频谱效率增益
   • 多径信道引起的性能损失量化
   • 在不同SNR下的相对性能

3. 均衡器特性：

   • LMS算法的收敛特性
   • 均衡器权重分布
   • 信道频率响应补偿效果

参数调整建议

• 增大simulation_params.num_monte_carlo可获得更平滑的曲线
• 调整system_params.step_size可优化均衡器收敛速度与稳定性
• 修改多径参数可模拟不同的信道环境
• 增加均衡器长度可处理更严重的多径效应