gmc_16qam_turbodd.m

B3g_phase2_C语言_Matlab程序及说明

                
                for p=1:Path_number_mc
                    ss(p,:)=[zeros(1,delay(p)) st zeros(1,delay(Path_number_mc)-delay(p))];                            
                end
                
                for na=1:Antenna_number
                    CH_Data = MultiCHannel(Path_Gain,Fc,V,Tc,Signal_length,Time_Begin,Phase(na,:));
                    Sm(na,:)=sum(ss.*CH_Data);                                                     % The transmitted signal is passed through multipath channel 
                end 
                
                
                
                Time_Begin = Time_Begin+Signal_length; 
                
                %    Add Gauss noise
                Rm=awgn(Sm,SNR);%-10*log10(Spread_factor/Code_channel)-10*log10(Sampling_factor/Carrier_number_used),'measured');
                
                Noise_variance=sum(sum(abs(Rm-Sm).^2))/length(Sm)/Antenna_number;
                %    Receiver
                %    Receiver:Separate the received mulicarrier signal into subcarrier signals
                for na=1:Antenna_number
                    %                     rs(na,:,:)=mc_afb(Rm(na,:),Slot_length,prototype_filter,Carrier_number,SubCarrier_first,SubCarrier_last,Sampling_factor,Oversampling_factor,Filter_length);
                    tmp=mc_afb(Rm(na,:),Slot_length,prototype_filter,Carrier_number,SubCarrier_first,SubCarrier_last,Sampling_factor,Oversampling_factor,Filter_length);
                    rs(na,:,:)=SC_sync(tmp,Slot_length,Subslot_length,Subslot_number,Gaurd_Pilot1,Interp_factor,rcflt,Path_number);             
                end 
                %    pause
                %    Receiver: Process each subcarrier separately
                
                for nc=1:Carrier_number_used
                    R=reshape(rs(:,nc,:),Antenna_number,length(rs(:,nc,:))); 
                    
                    %    Receiver: Channel estimation 
                    Index_R=Gaurd_length;Fades=zeros(Antenna_number,Path_number*(Subslot_number+1));Index_Fades=0;
                    for kk=1:Subslot_number+1
                        Tmp_RP=R(:,Index_R+(1:Pilot_length));
                        Tmp_Fades=conj(Gaurd_Pilot(nc))*Tmp_RP*Pilot_matrix'/Pilot_length;
                        Fades(:,Index_Fades+(1:Path_number))=Tmp_Fades;
                        Index_R=Index_R+Subslot_length;
                        Index_Fades=Index_Fades+Path_number;
                    end
                    
                    for p=1:Path_number
                        tmp_Fades=Fades(:,p:Path_number:end);
                        for na=1:Antenna_number
                            %tmp_FadesP(na,:)=interp(tmp_Fades(na,:),2);
                            [Coefficients,Structure]=polyfit(0:Subslot_number,tmp_Fades(na,:),3);
                            [tmp_FadesP(na,:),delta]=polyval(Coefficients,0:0.5:Subslot_number,Structure);
                            %tmp_FadesP(na,:)=spline(0:Subslot_number,tmp_Fades(na,:),0:Subslot_number);
                        end
                        Fades(:,p:Path_number:length(Fades))=tmp_FadesP(:,1:2:end);
                        FadesI(:,p:Path_number:length(Fades)-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:Path_number));
                        Tmp_Noise = R(:,Index_R+(1:Pilot_length))-Tmp_Fades(:,1:Path_number)*Pilot_matrix*Gaurd_Pilot(nc);
                        Nv(kk)=sum(sum(abs(Tmp_Noise.*Tmp_Noise)))/Pilot_length/Antenna_number;                                    % Estimate of noise variance 
                        Index_R=Index_R+Subslot_length;
                        Index_Fades=Index_Fades+Path_number;
                    end
                    Tmp_Nv=sum(Nv)/(Subslot_number+1);
                    %        Tmn_Nv=0;
                    %    Receiver: Equalization in DFT domain
                    Index_R=Pilot_length; Index_Fades=0;R_EQ=[];
                    for kk=0:Subslot_number-1
                        Tmp_Fades=(FadesI(:,Index_Fades+(1:Path_number)));
                        RM=R(:,Index_R+(1:Subslot_length)); 
                       
                        RMC(nc,(sn*Subslot_number+kk)*Subslot_length+(1:Subslot_length))=sum(cyc_cov(RM,Tmp_Fades),1);
                        
                        h_half(nc,(sn*Subslot_number+kk)*Path_number+(1:Path_number))=sum(self_cov(Tmp_Fades),1);
                       
                        Index_Fades=Index_Fades+Path_number;
                        Index_R=Index_R+Subslot_length;
                    end
                end   
            end
            
     
 %           LLR_DI=zeros(Carrier_number_used,Slot_number*Subslot_number*SubslotData_length*4);
            for n=1:nIterDD            
                for nc=1:Carrier_number_used
                    for sn=0:Slot_number-1
                        
                        for kk=0:Subslot_number-1
                            
                            Tmp_RMC=RMC(nc,(sn*Subslot_number+kk)*Subslot_length+(1:Subslot_length));
                            
                            Tmp_h_half=h_half(nc,(sn*Subslot_number+kk)*Path_number+(1:Path_number));                        
                            Tmp_h=[conj(Tmp_h_half(end:-1:2)) 0 Tmp_h_half(2:end)];
                            
                            if n==1
                                
                                LLR_D=zeros(1,4*SubslotData_length);
                                for nn=1:4
                                    
                                    LLR_P=reshape(LLR_D,4,SubslotData_length);
                                    
                                    [x_mean0, x_variance]=Mean_Var(LLR_P);
                                    
                                    x_mean=[Gaurd_Pilot(Pilot_length+(Gaurd_length-Path_number+2:Gaurd_length)) x_mean0 Gaurd_Pilot(1:Pilot_length)];
                                    x_variance=[zeros(1,Path_number-1) x_variance zeros(1,Pilot_length)];
                                    rou =Tmp_h_half(1);
                                    
                                    [x_intf, x_sigma]=Intf_Sigma(x_mean,x_variance,Tmp_h,SubslotData_length);
                                    
                                   
                                    x_rake=Tmp_RMC(Gaurd_length+(1:SubslotData_length));
                                    
%                                     x_rec=x_intf+rou*x_mean0; 
%                                     alpha=abs((x_rake*x_rec')/(x_rake*x_rake'));
                                    alpha=1;
                                    Tmp_R_EQ=x_rake-alpha*x_intf;
                                    
                                    x_sigma=Noise_variance*rou+alpha^2*x_sigma;
                                    
                                    LLR_D = Soft_Demod(Tmp_R_EQ, rou,x_sigma ,LLR_P, SubslotData_length);
                  
                                end
                            else
                                LLR_P=reshape(LLR_DI(nc,(sn*Subslot_number+kk)*SubslotData_length*4+(1:SubslotData_length*4)),4,SubslotData_length); 
                                
                                [x_mean0, x_variance]=Mean_Var(LLR_P);
                                
                                x_mean=[Gaurd_Pilot(Pilot_length+(Gaurd_length-Path_number+2:Gaurd_length)) x_mean0 Gaurd_Pilot(1:Pilot_length)];
                                x_variance=[zeros(1,Path_number-1) x_variance zeros(1,Pilot_length)];
                                rou =Tmp_h_half(1);
                                
                                [x_intf, x_sigma]=Intf_Sigma(x_mean,x_variance,Tmp_h,SubslotData_length);
                                
                                x_rake=Tmp_RMC(Gaurd_length+(1:SubslotData_length));
                                x_rec=x_intf+rou*x_mean0;
                                alpha=abs((x_rake*x_rec')/(x_rake*x_rake'));
                                
                                Tmp_R_EQ=x_rake-alpha*x_intf;
                                
                                x_sigma=Noise_variance*rou+alpha^2*x_sigma;
                                
                                LLR_D = Soft_Demod(Tmp_R_EQ, rou,x_sigma ,LLR_P, SubslotData_length);

                            end
                            
                            [Dem_signal(nc,(sn*Subslot_number+kk)*SubslotData_length*4+(1:SubslotData_length*4))]=LLR_D;
                        end
                    end
                end
                
                
                Dem_signal_s=reshape(Dem_signal',1,code_L*packet_N);
                Dem_signal_s(int_table)=Dem_signal_s;
                Dem_signal_p=vec2mat(Dem_signal_s,packet_N)';


                
                for np=1:packet_N
                    
                    [decoded, LLR_all(np,:)] = TuDecLogMapNew(Dem_signal_p(np,:), puncture, nIter, int_table0, 1, 1, poly_g1, poly_g2);
                    %[decoded] = TuDecSova(Dem_signal_p(np,:), puncture, nIter, int_table0, 1, 1, poly_g1, poly_g2);
                    errors(n)=errors(n)+sum(abs(decoded(1:msg_L)-msg(np,1:msg_L)));
                
                end
                

                LLR_DI=reshape(LLR_all,1,code_L*packet_N);
                LLR_DI=vec2mat(LLR_DI(int_table),code_L*packet_N/Carrier_number_used);
                
            end 
            
            errors
            ber(:,SNR-SNR1+1)=errors'/k/msg_L/packet_N

            
            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