test_regn2.m

Bit error probability curve for QPSK mimo 2*1

clc;
clear all; 
close all;
a=2;
noofdata=64;
noofblock=2; 
nooftaps=64;
qpskdata=complex(randn(noofblock,noofdata),randn(noofblock,noofdata));
s1=qpskdata(1,:);
s2=qpskdata(2,:);
qpskdata=reshape(qpskdata,noofdata*noofblock,1);
         for i=1:noofdata*noofblock
               if (and(real(qpskdata(i))>0,imag(qpskdata(i)>0)))
                       data1(i)=0;
               elseif(and(real(qpskdata(i))<0,imag(qpskdata(i))>0))
                       data1(i)=1;
               elseif(and(real(qpskdata(i))<0,imag(qpskdata(i))<0))
                       data1(i)=2;
               elseif(and(real(qpskdata(i))>0,imag(qpskdata(i))<0))
                       data1(i)=3;
               end
         end    
s1_sigpwr=sum(abs(s1).^2)/noofdata;
s2_sigpwr=sum(abs(s2).^2)/noofdata;
for snrr=1:30
       count(snrr)=0;count1(snrr)=0;
       noofruns=10;
           for r=1:noofruns
               %2X1
                   h1=complex(0.707*randn(nooftaps,1),0.707*randn(nooftaps,1));
                   convolution_time1_ch1=(h1.'.*s1); 
                   convolution_time2_ch1=(h1.'.*conj(s2));
                   noise_pow_time1=s1_sigpwr*10^(-snrr/10);  
                   noise_time1=sqrt(noise_pow_time1)*0.707*complex(randn(noofdata,1),randn(noofdata,1)); 
                   
                   h2=complex(0.707*randn(nooftaps,1),0.707*randn(nooftaps,1));
                   convolution_time1_ch2=(h2.'.*s2);
                   convolution_time2_ch2=(h2.'.*-conj(s1));
                   noise_pow_time2=s1_sigpwr*10^(-snrr/10);  
                   noise_time2=sqrt(noise_pow_time2)*0.707*complex(randn(noofdata,1),randn(noofdata,1)); 
                   
                   rxx_1=convolution_time1_ch1+convolution_time1_ch2+noise_time1.';
                   rxx_2=convolution_time2_ch1+convolution_time2_ch2+noise_time2.';
                   
                   rx_1=(rxx_1.*conj(h1.')) -(conj(rxx_2).*h2.');
                   cha_noise1=h2.'.*conj(noise_time2.')-conj(h1.').*noise_time1.';
                   
                   rx_2=(rxx_1.*conj(h2.'))+(conj(rxx_2).*h1.');
                   cha_noise2=conj(h2.').*noise_time1.'+h1.'.*conj(noise_time2.');
                   
                   a= (abs(h1).^2 + abs(h2).^2).';
                   rx_data(1,:)=(rx_1)./a;
                   rx_data(2,:)=(rx_2)./a;
                   
                   data2=reshape(rx_data,1,noofdata*2);

                   NGdata2=2*data2;                 % Non Regenerative relay

                   % 1X2 for non regenerative relay
                   ss1=NGdata2;
                   ss1_sigpwr=sum(abs(ss1).^2)/(2*noofdata);
                   
                   sh1=complex(0.707*randn(nooftaps*2,1),0.707*randn(nooftaps*2,1));
                   sh2=complex(0.707*randn(nooftaps*2,1),0.707*randn(nooftaps*2,1));
                   
                   sconvolution_time1_ch1=(sh1.'.*ss1); 
                   sconvolution_time1_ch2=(sh2.'.*ss1);
                   
                   snoise_pow_time1=ss1_sigpwr*10^(-snrr/10);  
                   snoise_time1_ch1=sqrt(snoise_pow_time1)*0.707*complex(randn(noofdata*2,1),randn(noofdata*2,1)); 
                   
                   snoise_pow_time1=ss1_sigpwr*10^(-snrr/10);  
                   snoise_time1_ch2=sqrt(snoise_pow_time1)*0.707*complex(randn(noofdata*2,1),randn(noofdata*2,1)); 
                   
                   srxx_1=sconvolution_time1_ch1+snoise_time1_ch1.';
                   srxx_2=sconvolution_time1_ch2+snoise_time1_ch2.';
                   
                   srx_1=conj(sh1.').*srxx_1+conj(sh2.').*srxx_2;
                   sa= (abs(sh1).^2 + abs(sh2).^2).';
                   srx_data=(srx_1)./sa;
                   sdata2=reshape(srx_data,1,noofdata*2);

                   for i=1:noofdata*noofblock
                           if (and(real(sdata2(i))>0,imag(sdata2(i))>0))
                                  sdata2(i)=0;
                           elseif(and(real(sdata2(i))<0,imag(sdata2(i))>0))
                                  sdata2(i)=1;
                           elseif(and(real(sdata2(i))<0,imag(sdata2(i))<0))
                                  sdata2(i)=2;
                           elseif(and(real(sdata2(i))>0,imag(sdata2(i))<0))
                                  sdata2(i)=3;
                           end
                    end   
                    sdata2;
                    error=data1-sdata2;
                    for i=1:noofdata*noofblock
                          if error(i)==0
                             count(snrr)=count(snrr);
                          else 
                             count(snrr)=count(snrr)+1;
                          end
                    end
                    result(snrr)=count(snrr)/(noofdata*2*noofruns)
                   
%                     Regenerative relay - demod here
                   for i=1:noofdata*noofblock
                           if (and(real(data2(i))>0,imag(data2(i))>0))
                                  data2(i)=0;
                           elseif(and(real(data2(i))<0,imag(data2(i))>0))
                                  data2(i)=1;
                           elseif(and(real(data2(i))<0,imag(data2(i))<0))
                                  data2(i)=2;
                           elseif(and(real(data2(i))>0,imag(data2(i))<0))
                                  data2(i)=3;
                           end
                   end

                   Gdata2=data2;                           % demodulated & amplified
                   
                   for i=1:noofdata*noofblock
                           if Gdata2(i)==0
                               GRdata(i)=1+j;
                           end
                           if Gdata2(i)==1
                               GRdata(i)=-1+j;
                           end
                           if Gdata2(i)==2
                               GRdata(i)=-1-j;
                           end
                           if Gdata2(i)==3;
                               GRdata(i)=1-j;
                           end
                   end
                   % 1X2 for regenerative relay
                   rs1=GRdata;
                   rs1_sigpwr=sum(abs(rs1).^2)/(2*noofdata);
                   
                   rh1=complex(0.707*randn(nooftaps*2,1),0.707*randn(nooftaps*2,1));
                   rh2=complex(0.707*randn(nooftaps*2,1),0.707*randn(nooftaps*2,1));
                   
                   rconvolution_time1_ch1=(rh1.'.*rs1); 
                   rconvolution_time1_ch2=(rh2.'.*rs1);
                   
                   rnoise_pow_time1=rs1_sigpwr*10^(-snrr/10);  
                   rnoise_time1_ch1=sqrt(rnoise_pow_time1)*0.707*complex(randn(noofdata*2,1),randn(noofdata*2,1)); 
                   
                   rnoise_pow_time1=rs1_sigpwr*10^(-snrr/10);  
                   rnoise_time1_ch2=sqrt(rnoise_pow_time1)*0.707*complex(randn(noofdata*2,1),randn(noofdata*2,1)); 
                   
                   rrxx_1=rconvolution_time1_ch1+rnoise_time1_ch1.';
                   rrxx_2=rconvolution_time1_ch2+rnoise_time1_ch2.';
                   
                   rrx_1=conj(rh1.').*rrxx_1+conj(rh2.').*rrxx_2;
                   ra= (abs(rh1).^2 + abs(rh2).^2).';
                   rrx_data=(rrx_1)./ra;
                   rdata2=reshape(rrx_data,1,noofdata*2);
                   
                    for i=1:noofdata*noofblock
                           if (and(real(rdata2(i))>0,imag(rdata2(i))>0))
                                  rdata2(i)=0;
                           elseif(and(real(rdata2(i))<0,imag(rdata2(i))>0))
                                  rdata2(i)=1;
                           elseif(and(real(rdata2(i))<0,imag(rdata2(i))<0))
                                  rdata2(i)=2;
                           elseif(and(real(rdata2(i))>0,imag(rdata2(i))<0))
                                  rdata2(i)=3;
                           end
                   end
                    
%                     rdata2;
%                     if data1(i)~=rdata2(i)
%                         count1=count1+1;
%                     end
                    

                    error1=data1-rdata2;
                    for i=1:noofdata*noofblock
                          if error1(i)==0
                             count1(snrr)=count1(snrr);
                          else 
                             count1(snrr)=count1(snrr)+1;
                          end
                    end
                    result1(snrr)=count1(snrr)/(noofdata*2*noofruns)
%snrratio=sigpwr/noisepwr;

           
           end
%            ber(snrr)=count1/(noofdata*2);
           
end
 snrr=[1:30];   
 semilogy(snrr,result,'bs-')
 hold on;
 semilogy(snrr,result1,'-*')
 
 xlabel('SNR, dB')
 ylabel('Bit Error Rate')
 title('Bit error probability curve for QPSK mimo 2*1')