ber_comparison_pre_est.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.4;
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

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



% --- Frequency Drift Generation --- %



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

% modulation
M=4;                                            % 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)); 
    
    
    
        pre_symbol_1=randint(1,N);
        pre_symbol_2=pre_symbol_1;
        pre_symbol_1_t=ifft(pre_symbol_1,N);
        pre_symbol_2_t=ifft(pre_symbol_2,N);
        pre_symbol_1_tx=[pre_symbol_1_t(N-Ncp+1:N) pre_symbol_1];
        pre_symbol_2_tx=[pre_symbol_2_t(N-Ncp+1:N) pre_symbol_2];
        pre_symbol_1_rx=pre_symbol_1_tx.*freq_drift+noise;
        pre_symbol_2_rx=pre_symbol_2_tx.*freq_drift+noise;
        pre_symbol_1_f=fft(pre_symbol_1_rx(Ncp+1:Ns),N);  
        pre_symbol_2_f_t=fft(pre_symbol_2_rx(Ncp+1:Ns),2*N);
        pre_symbol_2_f=pre_symbol_2_f_t(N+1:2*N);
        alpha=pre_symbol_2_f.*conj(pre_symbol_1_f);
        fo_est=angle(sum(alpha))/(2*pi)
        
        L=[L fo_est];
        freq_drift_e=exp(j*2*pi*(fo-abs(L(1)))*Ts*t/T);
        L1=[L1
            freq_drift_e];


%         for s=1
%             preamble_half=randint(1,N/2,2);
%             preamble=[preamble_half preamble_half];
%             preamble_t=ifft(preamble,N);
%             preamble_tx=[preamble_t(N-Ncp+1:N) preamble_t];
%             preamble_rx=preamble_tx.*freq_drift+noise;
%             preamble_f=fft(preamble_rx(Ncp+1:Ns),N);
%             preamble_f_b=fft(preamble_rx(Ncp+1:Ns),N)
%     %         fo_est=1/(2*pi)*angle(sum(imag(preamble_f(1:N/2).*conj(preamble_f(N/2+1:N))))/sum(real(preamble_f(1:N/2).*conj(preamble_f(N/2+1:N)))));
%             son=conj(preamble_f(1:N/2)).*preamble_f(N/2+1:N);
%             
%             fo_est=1/(2*pi)*atan(sum(imag(son))/sum(real(son)))

  

        for s=1:sym_no

            b_1=randint(1,N,M);                 % standard ofdm
            b_1_tx=de2bi(b_1)';
            b=qammod(b_1,M);
            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_e+noise;
            y_inver_rx=x_inver_tx.*freq_drift_e+noise;
            y_conj_rx=x_conj_tx.*freq_drift_e+noise;
            y_sym_conj_rx=x_sym_conj_tx.*freq_drift_e+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:Ns),N);
            y_inver_rx_f=fft(y_inver_rx(Ncp+1:Ns),N);
            y_conj_rx_f=fft(y_conj_rx(Ncp+1:Ns),N);
            y_sym_conj_rx_f=fft(y_sym_conj_rx(Ncp+1:Ns),N);

            % window
            y_win_rx_f=fft(y_win_rx(Ncp+1:N),N);

            y_d=de2bi(demapper(y_f,M))';                                     % 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
% 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');

% 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