asp project.m

Adaptive Signal Processing tutorial project

% Alamouti Scheme
% Muryong Kim
% Wireless Communications Lab.
% Dept. of EECS, KAIST

% Parameters
number_of_symbols = 10000;  % number of total symbols transmitted  
Es = 1;                     % transmitted energy from two Tx antennas per symbol duration
bits = 2;                   % number of bits per symbol
Eb = Es/bits;               % energy per bit

% Signal Constellation: Gray-coded QPSK
s00 = complex(sqrt(Es/2),0);    % signal power divided by the number of Tx antennas
s01 = complex(0,sqrt(Es/2));
s11 = complex(-sqrt(Es/2),0);
s10 = complex(0,-sqrt(Es/2));
% scatterplot([s00 s01 s11 s10]);

% Binary Data Source Generation & QPSK Mapper
rand('state',sum(100*clock));

for index=1:number_of_symbols,
    temp=rand;			  	% uniformly distributed between 0 and 1
  if (temp<0.25),
    dsource1(index)=0;
    dsource2(index)=0;
    symbol(index)=s00;
  elseif (temp<0.5),
    dsource1(index)=0;
    dsource2(index)=1;
    symbol(index)=s01;
  elseif (temp<0.75),
    dsource1(index)=1;
    dsource2(index)=0;
    symbol(index)=s10;
  else,
    dsource1(index)=1;
    dsource2(index)=1;
    symbol(index)=s11;
  end;
end;

% Fading Channel Generation
randn('state',sum(100*clock));
h_vector = complex(randn(1,number_of_symbols),randn(1,number_of_symbols));

% Alamouti Encoding Scheme
for index=1:2:number_of_symbols-3,
    symbol_faded(index)   =  h_vector(index)*symbol(index)         + h_vector(index+1)*symbol(index+1);
    symbol_faded(index+1) = -h_vector(index)*conj(symbol(index+1)) + h_vector(index+1)*conj(symbol(index));
end;
    symbol_faded(number_of_symbols)=0;
% Additive Noise Generation
noise_complex=complex(randn(1,number_of_symbols),randn(1,number_of_symbols));

SNR_in_dB=2:2:30;
for SNR_index=1:length(SNR_in_dB),
    % scaling noise variance  
    snr = 10^(SNR_in_dB(SNR_index)/10);	  % signal-to-noise ratio
    sgma = sqrt(Es/(bits*snr));	  	  % noise variance
    noise_scaled = sgma*noise_complex;
    
    symbol_received = symbol_faded + noise_scaled; % adding white gaussian noise
    
    % Combing Scheme at the Receiver
    for index=1:2:number_of_symbols,
        symbol_combined(index)   = (1/(conj(h_vector(index))*h_vector(index)+conj(h_vector(index+1))*h_vector(index+1)))*(conj(h_vector(index))*symbol_received(index)  + h_vector(index+1)*conj(symbol_received(index+1)));
        symbol_combined(index+1) = (1/(conj(h_vector(index))*h_vector(index)+conj(h_vector(index+1))*h_vector(index+1)))*(conj(h_vector(index+1))*symbol_received(index)-h_vector(index)*conj(symbol_received(index+1)));
    end;
    
        symbol_faded(number_of_symbols)=0;
    % Symbol Detection
    number_of_symbol_errors=0;
    number_of_bit_errors=0;
    for index=1:number_of_symbols,
        % metrics for ML symbol decision (for equal energy constellation)
        c00=dot([real(symbol_combined(index)) imag(symbol_combined(index))], [real(s00) imag(s00)]);
        c01=dot([real(symbol_combined(index)) imag(symbol_combined(index))], [real(s01) imag(s01)]);
        c10=dot([real(symbol_combined(index)) imag(symbol_combined(index))], [real(s10) imag(s10)]);
        c11=dot([real(symbol_combined(index)) imag(symbol_combined(index))], [real(s11) imag(s11)]);

        % ML symbol decision
        c_max=max([c00 c01 c10 c11]);
        if(c00==c_max),
            decision1=0; decision2=0;
        elseif(c01==c_max),
            decision1=0; decision2=1;
        elseif(c10==c_max),
            decision1=1; decision2=0;
        else,
            decision1=1; decision2=1;
        end;

        % bit & symbol error count
        symbol_error_flag=0;
        if(decision1~=dsource1(index)),
            number_of_bit_errors = number_of_bit_errors+1;
            symbol_error_flag=1;
        end;
        if(decision2~=dsource2(index)),
            number_of_bit_errors = number_of_bit_errors+1;
            symbol_error_flag=1;
        end;
        if(symbol_error_flag==1),
            number_of_symbol_errors = number_of_symbol_errors+1;
        end;
    end;
    SNR_in_dB(SNR_index)
    % Ps(SNR_index) = number_of_symbol_errors/number_of_symbols
    Pb(SNR_index) = number_of_bit_errors/(bits*number_of_symbols)
end;

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
figure;
semilogy(2:2:30,Pb,'d-');
grid;
legend('Alamouti : 2 Tx, 1 Rx');
ylabel('Error Rate');
xlabel('Eb/No');