ber_comparison.m

uising different ICI self-cancellation scheme to see its performance

clear all;
clc;




N=512;
sym_no=1000;
bit_no=N*sym_no;
% bit_sam=[1+j 1-j -1+j -1-j];
Ncp=N/4;
Ns=N+Ncp;
fo=0.1;
T=3.2*10^-6;
Ts=T/N;
% trun_len=100;          % truncation length
% const=[1+j 1-j -1+j -1-j];          % constellation
% art_ch=[1 -2 1]; 



ch_len=10;     % channel length


% setting

win_scmm=winfx(1,N);
err_loca_win1=[];

trun_len=300;          % truncation length
const=[1 -1];          % constellation
art_ch1=[1 -1];        % artificial channel
 

% --- Frequency Drift Generation --- %

t=(0:Ns-1)-(Ncp+1);
freq_drift=exp(j*2*pi*fo*Ts*t/T);

SNR=[0:2:20]; 
N0=10.^(-SNR/10);
L=[];
L_c=[];

% modulation
M=2;                                            % modulation method: 2 for BPSK ; 4 for  QPSK(QAM) ; 16 for 16 QAM
for przt_snr=1:length(SNR)
    current_snr=SNR(przt_snr)
    err=0;
    err_inver=0;
    err_conj=0;
    err_sym_conj=0;
    err_win=0;
    x_inver_f=zeros(1,N);
    x_conj_f=zeros(1,N);
    x_sym_conj_f=zeros(1,N);
    noise=sqrt(N0(przt_snr)/2/N)*(randn(1,Ns)+j*randn(1,Ns));
    
    for s=1:sym_no

        b_1=randint(1,N,2);                 % standard ofdm
        b_1_tx=de2bi(b_1)';
        b=qammod(b_1,2);
        x_t=ifft(b,N);
        x_tx=[x_t(N-Ncp+1:N) x_t];
        
        b_2=randint(1,N,M);                  % self_cancellation_data_conversion
        b_2_tx=de2bi(b_2(:,1:N/2))';
        b_3_tx=de2bi(b_2)';
        b_c=qammod(b_2(1:N/2),M);
        b_c_a=qammod(b_2,M);
        
        
%         b_2=randint(1,N/2,M);                  % self_cancellation_data_conversion
%         b_2_tx=de2bi(b_2)';
%         b_c=qammod(b_2,M);
        
       
        
        x_inver_f(1:2:N-1)=b_c;                  
        x_inver_f(2:2:N)=-(b_c);
        x_inver_t=ifft(x_inver_f,N);
        x_inver_tx=[x_inver_t(N-Ncp+1:N) x_inver_t];
        
        
        x_conj_f(1:2:N-1)=b_c;                 % self_cancellation_conjugate
        x_conj_f(2:2:N)=-conj(b_c);
        x_conj_t=ifft(x_conj_f,N);
        x_conj_tx=[x_conj_t(N-Ncp+1:N) x_conj_t];
        
        x_sym_conj_f(1:1:N/2)=b_c;
        x_sym_conj_f(N:-1:N/2+1)=-conj(b_c);
        x_sym_conj_t=ifft(x_sym_conj_f,N);
        x_sym_conj_tx=[x_sym_conj_t(N-Ncp+1:N) x_sym_conj_t];
        
        
        x_win_t=ifft(b_c_a,N);
        x_win_t_temp=x_win_t.*win_scmm;
        x_win_tx=[x_win_t_temp(N-Ncp+1:N) x_win_t_temp];
        

% channel


         

% Demodulation
         
         y_rx=x_tx.*freq_drift+noise;
         y_inver_rx=x_inver_tx.*freq_drift+noise;
         y_conj_rx=x_conj_tx.*freq_drift+noise;
         y_sym_conj_rx=x_sym_conj_tx.*freq_drift+noise;
         
         % window
         y_win_rx=x_win_tx.*freq_drift+noise;
%           y_conj_rx=x_conj_tx.*freq_drift;
%          
         y_f=fft(y_rx(Ncp+1:N),N);
         y_inver_rx_f=fft(y_inver_rx(Ncp+1:N),N);
         y_conj_rx_f=fft(y_conj_rx(Ncp+1:N),N);
         y_sym_conj_rx_f=fft(y_sym_conj_rx(Ncp+1:N),N);
         
         % window
         y_win_rx_f=fft(y_win_rx(Ncp+1:N),N);

         y_d=de2bi(demapper(y_f,2))';                                     % standard ofdm demod
         
         y_1=y_inver_rx_f(1:2:N-1);                               % data_conversion demod
         y_2=y_inver_rx_f(2:2:N);
         y_inver_d_temp=(y_1-y_2)/2;
         y_inver_d=de2bi(demapper(y_inver_d_temp,M))';
         
         y_conj_1=y_conj_rx_f(1:2:N-1);                           % data_conjugate demod
         y_conj_2=y_conj_rx_f(2:2:N);
         y_conj_d_temp=(y_conj_1-conj(y_conj_2))/2;
         y_conj_d=de2bi(demapper(y_conj_d_temp,M))';
         
         y_sym_conj_1=y_sym_conj_rx_f(1:1:N/2);
         y_sym_conj_2=y_sym_conj_rx_f(N:-1:N/2+1);
         y_sym_conj_d_temp=(y_sym_conj_1-conj(y_sym_conj_2))/2;
         y_sym_conj_d=de2bi(demapper(y_sym_conj_d_temp,M))';
         
         
         y_win_deco=mlseeq(y_win_rx_f,art_ch1,const,trun_len,'rst'); 
         y_win_d=de2bi(demapper(y_win_deco,M))';


       err=err+sum(b_1_tx(:)~=y_d(:));
       err_inver=err_inver+sum(b_2_tx(:)~=y_inver_d(:));
       err_conj=err_conj+sum(b_2_tx(:)~=y_conj_d(:));
       err_sym_conj=err_sym_conj+sum(b_2_tx(:)~=y_sym_conj_d(:));
       err_win=err_win+sum(b_3_tx(:)~=y_win_d(:));
         
        
        
        
    end
   
    ber(przt_snr)=err/bit_no;
    ber_inver(przt_snr)=err_inver/bit_no;
    ber_conj(przt_snr)=err_conj/bit_no;
    ber_sym_conj(przt_snr)=err_sym_conj/bit_no;
    ber_win(przt_snr)=err_win/bit_no;
end

% semilogy(SNR,ber,'-o',SNR,real(ber_inver),'-x');
semilogy(SNR,ber,'-o',SNR,real(ber_inver),'-s',SNR,real(ber_conj),'-+ r',SNR,real(ber_sym_conj),'-d k',SNR,real(ber_win),'- c');

% grid on
legend('Standard OFDM','data inversion','data conjugate','data symmetric conjugate')
% legend('Standard OFDM','data inversion')
% title(['\epsilon = ' num2str(ep)])
xlabel('SNR (dB)')
ylabel('BER')
grid on
% t_end=cputime-t_begin


        
% end