%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
descrição do arquivo
descrição da função%: este é um Para uma OFDM mais completa sistema, fiz um mapeamento de modulação QPSK relativamente simples no transmissor para gerar símbolos OFDM,
% após a conversão serial para paralelo, inserir o piloto piloto e o prefixo cíclico CP e, em seguida, executar a conversão paralelo para serial mais ruído e enviá-lo para o canal multipath Rayleigh.
% Na extremidade de recepção, primeiro execute a conversão serial para paralelo; em seguida, remova o prefixo cíclico, extraia as informações do piloto para a estimativa LS e, finalmente
, passe pela conversão% paralela para serial e QPSK decodifica e restaura as informações
%%% %%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%
% Descrição do parâmetro
% X: O fluxo de bits binários a ser
enviado %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Limpar tudo ;
clc;
IFFT_bin_length = 64;% IFFT e pontos FFT 128
carrier_count = 50;% número de subportadoras 100
bits_per_symbol = 2;% número de bits por símbolo 2
symbols_per_carrier = 12;% OFDM por frame Símbolo número 12
LI = 8;% de intervalo entre os pilotos
Np = ceil (carrier_count / LI) +1;% do número piloto mais 1 para tornar a última coluna também piloto, ou seja, existem 16 subcanais piloto
N_number = carrier_count * symbols_per_carrier * bits_per_symbol;% Número total de bits de informação enviados
% 100 * 12 * 2 = 2400
carrier = 1: carrier_count + Np;
GI = 8;% comprimento do intervalo de guarda
N_snr = 40;% razão sinal-ruído por bit de informação
snr = 8;% intervalo de razão sinal-ruído
%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Inicialização de variáveis no remetente
X = zeros (1, N_number);% X: o fluxo de bits binário a ser enviado
X1 = [];% O fluxo de dados binários original é mapeado em QPSK e codificado em um grupo de 2 para obter X1
X2 = [];% X1 conversão serial-paralela para obter X2
X3 = [];% X2 insere piloto para obter X3
X4 = [];% transformações IFFT para obter X4
X5 = [];
X6 = [];% Adiciona cíclico prefixo para obter X6
X7 = [];% X7 é obtido após a conversão paralela para serial
% De inicialização de variáveis na extremidade receptora
Y1 = [];% valor estimado de X1
Y2 = [];% Extraia as informações no canal de dados
Y3 = [];
Y4 = [];% Y5 é transformado por FFT para obter Y4
Y5 = [];% Y6 obtém Y5 após remover o prefixo cíclico.
Y6 = [];% Y7 obtém Y6 após a conversão serial-paralela.
Y7 = [];% O sinal obtido pela extremidade receptora do canal, ou seja, o saída do canal Y7
XX = zeros (1, N_number);
dif_bit = zeros (1, N_number);
dif_bit1 = zeros (1, N_number);
dif_bit2 = zeros (1, N_number);
dif_bit3 = zeros (1, N_number);
X = randint (1, N_number);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%
QPSK 调制 ： (1 1) -> pi / 4; (0 1) -> 3 * pi / 4; (0 0) -> - 3 * pi / 4; (1,0) -> - pi / 4;
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%
s = (X. * 2-1) / sqrt (2);
sreal = s (1: 2: N_number);% O fluxo de bits de informação original é codificado em um grupo de dois
simage = s (2: 2: N_number) ;% Os bits antes e depois são respectivamente codificados como a parte real e imaginária do símbolo OFDM
X1 = sreal + j. * Simage;% para codificação de mapeamento QPSK (forma complexa)
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%% %%%%%%%%%%%%%%%%
Gerar sinal piloto aleatório
%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
train_sym = randint (1,2 * symbols_per_carrier);
t = (train_sym. * 2-1 ) / sqrt (2); o mapeamento de modulação% QPSK também é executado na sequência piloto
treal = t (1: 2: 2 * symbols_per_carrier);
timage = t (2: 2: 2 * symbols_per_carrier);
training_symbols1 = treal + j. * timage;% form two
training_symbols2 = training_symbols1. ';% sequência de treinamento é usada para estimativa de canal
training_symbols = repmat (training_symbols2,1, Np);
% usa training_symbols2 como uma submatriz para gerar 12 linhas, Np = 16 colunas grandes matriz
disp (training_symbols)% Exibe o conteúdo da sequência de treinamento, um total de 16 colunas
pilot = 1: (LI + 1) :( carrier_count + Np);
% Use LI + 1 = 8 como o intervalo para marcar as subportadoras piloto, isto é, a cada 8 subportadoras portadoras, a primeira frequência de condução, as 7 restantes transmitem dados
se comprimento (piloto) ~ = Np
piloto = [piloto, portadora_contagem + Np];
fim
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%% %%%%%%%%%%%%%%% Conversão
serial para paralela
X2 = remodelar (X1, carrier_count, symbols_per_carrier). ';
%%%%%%%%%%%%%%%%% %% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%% %%%%%%%%%%%%%%%%%
Inserir frequência piloto
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
sinal = 1: carrier_count + Np;
sinal (piloto) = [];
X3 (:, piloto ) = training_symbols;% preencher os símbolos piloto na subportadora piloto
X3 (:, sinal) = X2;% preencher os dados na subportadora de dados
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%
OFDM 调制
IFFT_modulation = zeros (symbols_per_carrier, IFFT_bin_length);
IFFT_modulação (:, portadoras) = X3;
X4 = ifft (IFFT_modulação, IFFT_bin_length, 2);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Mais intervalo de guarda (prefixo cíclico)
para k = 1: symbols_per_carrier;
para i = 1: IFFT_bin_length;
X6 (k, i + GI) = X4 (k, i);
fim
para i = 1: GI;
X6 (k, i) = X4 (k, i + IFFT_bin_length-GI);% adicionar CP: alterar o último bit de cada símbolo GI copiado para o front
End
End
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Parallel-
serial conversion
X7 = remodelar (X6. ' , 1, symbols_per_carrier * (IFFT_bin_length + GI));
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Modelo de canal%: canal de desvanecimento Rayleigh com mudança de frequência Doppler
fd = 100;% mudança de frequência Doppler
r = 6;% número de caminhos múltiplos
a = [0,12 0,3 0,4 0,5 0,7 0,8];% amplitude de desvanecimento de caminhos múltiplos
d = [2 3 4 5 7 6];% de cada caminho Atraso
T = 1;% período de amostragem do sistema
th = [90 0 72 144 216 288] * pi. / 180;% mudança de fase de cada caminho
h = zeros (1, contagem_de_portadora);
hh = [];
para k = 1: r
h1 = a (k) * exp (j * ((2 * pi * T * fd * d (k) / contagem_de_portadora))) ;% Função de resposta de cada caminho
hh = [hh, h1];
fim
h (d + 1) = hh;
% 6 条 信 道 模拟 多 径 canal1
= zeros (tamanho (X7));
canal1 (1 + d (1): comprimento (X7)) = hh (1) * X7 (1: comprimento (X7) -d (1));
canal2 = zeros (tamanho (X7));
canal2 (1 + d (2): comprimento (X7)) = hh (2) * X7 (1: comprimento (X7) -d (2));
canal3 = zeros (tamanho (X7));
canal3 (1 + d (3): comprimento (X7)) = hh (3) * X7 (1: comprimento (X7) -d (3));
canal4 = zeros (tamanho (X7));
canal4 (1 + d (4): comprimento (X7)) = hh (4) * X7 (1: comprimento (X7) -d (4));
canal5 = zeros (tamanho (X7));
canal5 (1 + d (5): comprimento (X7)) = hh (5) * X7 (1: comprimento (X7) -d (5));
canal6 = zeros (tamanho (X7));
canal6 (1 + d (6): comprimento (X7)) = hh (6) * X7 (1: comprimento (X7) -d (6));
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%% %%%%%%%%%%%%%%
Tx_data = X7 + channel1 + channel2 + channel3 + channel4 + channel5 + channel6;% O símbolo enviado pelo remetente ao canal, ou seja, a entrada do canal
%%%%% %% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%
% Adicionar ruído branco gaussiano
Error_ber = [];% Taxa de erro de bit
Error_ber1 = [];
Error_ber2 = [];
Error_ber3 = [];
para snr_db = 0: snr: N_snr% Adicionar ruído a cada bit de dados
code_power = 0;
code_power = [norm (Tx_data)] ^ 2 / (length (Tx_data));% poder do símbolo
bit_power = code_power / bits_per_symbol;% bit power
noise_power = 10 * log10 ((bit_power / (10 ^ (snr_db / 10) ))));% ruído de ruído de potência
= wgn (1, comprimento (Tx_data), noise_power, 'complexo');% produz ruído branco gaussiano
Y7 = Tx_data + ruído;% a informação obtida pelo receptor do canal, isto é , a saída do canal
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%
Recebendo final
% serial e transformação paralela
Y6 = remodelar (Y7, IFFT_bin_length + GI, symbols_per_carrier). ';
%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%% %%%%%%%%%%%%%%%%%%%%%%%%
Intervalo Deguard (CP)
para k = 1: symbols_per_carrier;
para i = 1: IFFT_bin_length;
Y5 (k, i) = Y6 (k , i + GI);
end
end
Y4 = fft (Y5, IFFT_bin_length, 2);
Y3 = Y4 (:, transportadoras);
%%%%%%%%%%%%%%%%%% %%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%% %%
% LS estimativa do canal
H = [];
Y2 = Y3 (:, sinal);% Extrair informações de dados
Rx_training_symbols = Y3 (:, piloto);% Extrair informações do piloto no canal piloto
Rx_training_symbols0 = remodelar (Rx_training_symbols, symbols_per_carrier * Np, 1 );
training_symbol0 = remodelagem (training_symbols, 1, symbols_per_carrier * Np);
training_symbol1 = diag (training_symbol0);
training_symbol2 = inv (training_symbol1);
Hls = training_symbol2 * LS'symbol de fórmula Rx_symbol1 =;% X
LS'symbol Estimativa remodelagem (Hls, símbolos_per_carrier, Np);
HLs = [];
HLs1 = [];
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
if ceil (carrier_count / LI) == carrier_count / LI
for k = 1 : Np-1% De acordo com isso, a estimativa de resposta em cada canal é obtida
HLs2 = [];
para t = 1: LI
HLs1 (:, 1) = (Hls1 (:, k + 1) -Hls1 (:, k)) * (t-1) ./ LI + Hls1 (:, k);
HLs2 = [HLs2, HLs1];
end
HLs = [HLs, HLs2]; outra
extremidade para k = 1: Np-2 HLs2 = []; para t = 1: LI HLs1 (:, 1) = (Hls1 (:, k + 1) -Hls1 (:, k)) * (t-1) ./ LI + Hls1 (:, k); HLs2 = [HLs2, HLs1]; end HLs = [HLs, HLs2]; fim HLs3 = []; para t = 1: mod (carrier_count, LI)
HLs1 (:, 1) = (Hls1 (:, Np) -Hls1 (:, Np-1)) * (t-1) ./ LI + Hls1 (:, Np-1);
HLs3 = [HLs3, HLs1];
fim;
HLs = [HLs, HLs3];
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%
Y1 = Y2. / HLs;
% Hls é a estimativa de resposta do canal obtida na posição piloto. Como o canal de mudança lenta é usado, também é considerado como a
estimativa de resposta do subcanal% de dados . Use esta estimativa para estimar o sinal Y1 recebido e transmitido real, que é, Y1 é o valor estimado de X1
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%% Parallel-
conversão de série
% a utilização de estimativa de canal pode melhorar a qualidade de comunicao do sistema OFDM.
YY = remodelar (Y2. ', 1, N_number / bits_per_symbol);% Não usar símbolos não decodificados de estimativa de canal
YY1 = remodelar (Y1.', 1, N_number / bits_per_symbol);% Usando símbolos de estimativa LS não
decodificados %%%% %%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%% %%%%%%%%%%%%%
QPSK decoding
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
y_real = sign (real (YY));% Decoding by sign function
y_image = sign (imag (YY));
y_re = y_real. / Sqrt (2);
y_im = y_image. / Sqrt (2);%
y_real1 = sinal (real (YY1));
y_image1 = sinal (imag (YY1));
y_re1 = y_real1. / sqrt (2);
y_im1 = y_image1. / sqrt (2);%
r00 = [];
r01 = [];
r10 = [];
r11 = [] ;
%
Anti-mapeamento restaurar fluxo de bits de informação para k = 1: comprimento (y_re);
R01 = [r01, [y_re (k), y_im (k)]];
final;
para k = 1: comprimento (y_re1);
r11 = [r11, [y_re1 (k), y_im1 (k)]];
end;
%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Calcular a taxa de erro de bit sob diferentes relações sinal-ruído
% %%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%
dif_bit = s-r01;% s é o símbolo obtido pela codificação do fluxo de bits de entrada do
remetente dif_bit1 = s-r11;% r01 é o símbolo obtido por decodificação sem estimativa
% r11 é o símbolo decodificado após estimativa.
Eles são comparados para julgar o bit de erro
ber_snr = 0; % 记录 误 比特 数
para k = 1: N_number;
se dif_bit (k) ~ = 0;
ber_snr = ber_snr + 1;
fim
fim;
ber_snr1 = 0; % 记录 误 比特 数
para k = 1: N_number;
se dif_bit1 (k) ~ = 0;
ber_snr1 = ber_snr1 + 1;
end
end
Error_ber = [Error_ber, ber_snr];
Error_ber1 = [Error_ber1, ber_snr1];
que
BER = zeros (1, comprimento (0: snr: N_snr));
BER1 = zeros (1, comprimento (0: snr: N_snr));
BER = Error_ber. / N_number;% BER não estimado
BER1 = Error_ber1. / N_number;% BER estimado por LS
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%% %%%%%%%%%%%
O mapeamento comparativo para estimativa de canal não é realizado e o LS estima um erro de bit (BER) performance
%%%%%%%%%%%%%%%%%% %%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
i = 0: snr: N_snr;
semilogy (i, BER, '- * r');
grade
ativada ; xlabel ('SNR em dB');
ylabel ('Taxa de erro de bit');
aguentar;
semilogia (i, BER1, '- ob');
grade ligada;
xlabel ('SNR em dB');
ylabel ('Taxa de erro de bit');
título ('BER 性能 比较');
legenda ('Sem estimativa de canal', 'Estimativa de canal LS');