sc_turbodd_2txr.m

B3g_phase2_C语言_Matlab程序及说明

            10*log10(sum(sum(abs(Sm).^2))/sum(sum(abs(Rm-Sm).^2)))
            Noise_variance=sum(sum(abs(Rm-Sm).^2))/length(Sm)/RxAntenna_number;
            
            %    Receiver
            
            for sn=0:Slot_number-1
                R=Rm(:,sn*Slot_length+(1:Slot_length));
                
                %    Receiver: Channel estimation 
                Index_R=Gaurd_length;Fades=zeros(RxAntenna_number,2*Path_number*(Subslot_number+1));Index_Fades=0;
                for kk=1:Subslot_number+1
                    Tmp_RP=R(:,Index_R+(1:Pilot_length));
                    Tmp_Fades=Tmp_RP*Pilot_matrix'/Pilot_length;
                    Fades(:,Index_Fades+(1:2*Path_number))=Tmp_Fades;
                    Index_R=Index_R+Subslot_length;
                    Index_Fades=Index_Fades+2*Path_number;
                end
                
                for p=1:2*Path_number
                    tmp_Fades=Fades(:,p:2*Path_number:end);
                    for na=1:RxAntenna_number
                        [Coefficients,Structure]=polyfit(0:Subslot_number,tmp_Fades(na,:),3);
                        [tmp_FadesP(na,:),delta]=polyval(Coefficients,0:0.5:Subslot_number,Structure);
                    end
                    Fades(:,p:2*Path_number:length(Fades))=tmp_FadesP(:,1:2:end);
                    FadesI(:,p:2*Path_number:length(Fades)-2*Path_number)=tmp_FadesP(:,2:2:end);
                end
                
                Index_R=Gaurd_length;Index_Fades=0;
                for kk=1:Subslot_number+1
                    Tmp_Fades=Fades(:,Index_Fades+(1:2*Path_number));
                    Tmp_Noise = R(:,Index_R+(1:Pilot_length))-Tmp_Fades*Pilot_matrix;
                    Nv(kk)=sum(sum(abs(Tmp_Noise.*Tmp_Noise)))/Pilot_length/RxAntenna_number;                                    % Estimate of noise variance 
                    Index_R=Index_R+Subslot_length;
                    Index_Fades=Index_Fades+2*Path_number;
                end
                Noise_var(sn+1)=sum(Nv)/(Subslot_number+1);
                %    Receiver: Space_time combination
                Index_R=Pilot_length; Index_Fades=0;R_EQ=[];
                for kk=0:Subslot_number-1
                    Tmp_Fades1=FadesI(:,Index_Fades+(1:Path_number));
                    Tmp_Fades2=FadesI(:,Index_Fades+Path_number+(1:Path_number));
                    RM=R(:,Index_R+(1:Subslot_length)); 
                    
                    RMC(1,(sn*Subslot_number+kk)*Subslot_length+(1:Subslot_length))=sum(cyc_cov(RM,Tmp_Fades1),1);
                    RMC(2,(sn*Subslot_number+kk)*Subslot_length+(1:Subslot_length))=sum(cyc_cov(RM,Tmp_Fades2),1);
                    
                    h_half(1,(sn*Subslot_number+kk)*2*Path_number+(1:Path_number))=sum(self_cov(Tmp_Fades1),1);
                    h_half(1,(sn*Subslot_number+kk)*2*Path_number+Path_number+(1:Path_number))=sum(self_cov(Tmp_Fades2),1);
                    h_half(2,(sn*Subslot_number+kk)*2*Path_number+(1:2*Path_number-1))=sum(cross_corr(Tmp_Fades1,Tmp_Fades2),1);
                    
                    Index_Fades=Index_Fades+2*Path_number;
                    Index_R=Index_R+Subslot_length;
                end
            end   
            %    Receiver: Turbo Detection/Decoding
            for n=1:nIterDD            
                for sn=0:Slot_number-1 
%                     Noise_variance=Noise_var(sn+1);
                    for kk=0:Subslot_number-1
                        
                        Tmp_RMC=RMC(:,(sn*Subslot_number+kk)*Subslot_length+(1:Subslot_length));
                        Tmp_h_half=h_half(:,(sn*Subslot_number+kk)*2*Path_number+(1:2*Path_number));
                        
                        Tmp_h11=[conj(Tmp_h_half(1,Path_number:-1:2)) 0 Tmp_h_half(1,2:Path_number)];
                        Tmp_h22=[conj(Tmp_h_half(1,Path_number+(Path_number:-1:2))) 0 Tmp_h_half(1,Path_number+(2:Path_number))];
                        Tmp_h21=[Tmp_h_half(2,1:2*Path_number-1)];
                        Tmp_h12=conj([Tmp_h_half(2,2*Path_number-1:-1:1)]);
                        rou1=Tmp_h_half(1,1);
                        rou2=Tmp_h_half(1,Path_number+1);
                        x_rake=Tmp_RMC(:,Gaurd_length+(1:SubslotData_length));
                     
                        if n==1
                            
                            Tmp_R_EQ=x_rake;

                            x_sigma(1,:)=ones(1,SubslotData_length)*(Noise_variance*rou1+abs(Tmp_h11*Tmp_h11'+Tmp_h12*Tmp_h12'));
                            x_sigma(2,:)=ones(1,SubslotData_length)*(Noise_variance*rou2+abs(Tmp_h21*Tmp_h21'+Tmp_h22*Tmp_h22'));
 
                            for nn=1:5
                                [x_mean0(1,:),x_variance0(1,:)] =Symbol_Decision(Tmp_R_EQ(1,:),rou1,x_sigma(1,:));
                                [x_mean0(2,:),x_variance0(2,:)] =Symbol_Decision(Tmp_R_EQ(2,:),rou2,x_sigma(2,:));
                                
                                x_mean=[Gaurd_Pilot(:,Pilot_length+(Gaurd_length-Path_number+2:Gaurd_length)) x_mean0 Gaurd_Pilot(:,1:Pilot_length)];
                                x_variance=[zeros(2,Path_number-1) x_variance0 zeros(2,Pilot_length)];
                                                            
                                [x_intf, x_sigma]=Intf_Sigma2(x_mean,x_variance,Tmp_h11,Tmp_h12,Tmp_h21,Tmp_h22,SubslotData_length);
                                
                                Tmp_R_EQ=x_rake-x_intf;       
                                
%                                 figure(1)
%                                 plot(abs(x_mean0)')
%                                 figure(2)
%                                 plot(x_variance0')
%                                 pause
                                
                                x_sigma(1,:)=Noise_variance*rou1+x_sigma(1,:);
                                x_sigma(2,:)=Noise_variance*rou2+x_sigma(2,:);

                            end
                            LLR_D1 = Soft_Demod(Tmp_R_EQ(1,:), rou1,x_sigma(1,:) ,zeros(4,SubslotData_length), SubslotData_length);
                            LLR_D2 = Soft_Demod(Tmp_R_EQ(2,:), rou2,x_sigma(2,:) ,zeros(4,SubslotData_length), SubslotData_length);
                           
                        else
                            LLR_P=reshape(LLR_DI((sn*Subslot_number+kk)*SubslotData_length*8+(1:SubslotData_length*8)),4,2*SubslotData_length); 
                            
                            [x_mean0(1,:), x_variance0(1,:)]=Mean_Var(LLR_P(:,1:SubslotData_length));
                            [x_mean0(2,:), x_variance0(2,:)]=Mean_Var(LLR_P(:,SubslotData_length+(1:SubslotData_length)));
                            
                            x_mean=[Gaurd_Pilot(:,Pilot_length+(Gaurd_length-Path_number+2:Gaurd_length)) x_mean0 Gaurd_Pilot(:,1:Pilot_length)];
                            x_variance=[zeros(2,Path_number-1) x_variance0 zeros(2,Pilot_length)];
                                                      
                            [x_intf, x_sigma]=Intf_Sigma2(x_mean,x_variance,Tmp_h11,Tmp_h12,Tmp_h21,Tmp_h22,SubslotData_length);
                            
                            Tmp_R_EQ=x_rake-x_intf;
                            x_sigma(1,:)=Noise_variance*rou1+x_sigma(1,:);
                            x_sigma(2,:)=Noise_variance*rou2+x_sigma(2,:);
                            
                            LLR_D1 = Soft_Demod(Tmp_R_EQ(1,:),rou1,x_sigma(1,:),LLR_P(:,1:SubslotData_length), SubslotData_length);
                            LLR_D2 = Soft_Demod(Tmp_R_EQ(2,:),rou2,x_sigma(2,:),LLR_P(:,SubslotData_length+(1:SubslotData_length)), SubslotData_length);

                        end
                        
                        [Dem_signal((sn*Subslot_number+kk)*SubslotData_length*8+(1:SubslotData_length*8))]=[LLR_D1 LLR_D2];
                    end
                end
                    
                    Dem_signal(Outer_intl_table)=Dem_signal;
                    Dem_signal_p=vec2mat(Dem_signal,Packet_number)';
                    
                    for np=1:Packet_number
                        
                        [decoded, LLR_all(np,:)] = TuDecLogMapNew(Dem_signal_p(np,:), puncture, nIter, Inner_intl_table, 1, 1, poly_g1, poly_g2);
                        errors(n)=errors(n)+sum(abs(decoded(1:Packet_msg_L)-msg(np,1:Packet_msg_L)));
                        
                    end
                    
                    LLR_DI=reshape(LLR_all,1,Packet_code_L*Packet_number);
                    LLR_DI=LLR_DI(Outer_intl_table);
                end
                
                errors
                ber(:,SNR-SNR1+1)=errors'/k/Packet_msg_L/Packet_number
                
                
                if (errors(nIterDD)>300 & k>3) 
                    break;
                end
            end
            
            if ber(1,SNR-SNR1+1)<1.0*10^(-6)
                break;
            end
            
        end 
        save ber_16QAM200v_1 ber
    end
    semilogy(SNR1:SNR2,ber(:,1:SNR2-SNR1+1)')
    grid
    xlabel('SNR of Received Signal(in dB)')
    ylabel('Bit Error Rate')
    pause(0.2)
    save ber_16QAM200v_1 ber