gmc_16qam_che.m

B3g_phase2_C语言_Matlab程序及说明

                % Channel
                Signal_length=Sampling_factor*(Slot_length-1)+Filter_length+delay(Path_number_mc);                                 % Length of multicarrier baseband signal 
                
                CH_Data = MultiCHannel(Path_Gain,Fc,V,Tc,Signal_length,Time_Begin,Phase);
                Time_Begin = Time_Begin+Signal_length;  
                
%                 CH_Data=zeros(size(CH_Data));
%                 CH_Data(1,:)=ones(1,length(CH_Data));
%                 delay(1)=0;
                
                doas=rand(1,Path_number_mc)*pi*2;
                delayS=delay;
               % delayS(1:2)=delay(1:2)+floor(rand(1,2)*18);
                
                for p=1:Path_number_mc
                    ss(p,:)=[zeros(1,delayS(p)) st zeros(1,delayS(Path_number_mc)-delayS(p))];                            
                end
                
                for na=1:Antenna_number
                    Sm(na,:)=sum(ss.*(diag(exp(-j*(na-1)*doas))*CH_Data));                                                     % The transmitted signal is passed through multipath channel 
                end
                %    Add Gauss noise
                Rm=awgn(Sm,SNR-10*log10(Spread_factor/Code_channel)-10*log10(Sampling_factor/Carrier_number_used),'measured');
                 
%                 Rm=Sm;
%                 
                SNR_tmp=10*log10(sum(sum(abs(Rm.^2)))/sum(sum(abs((Rm-Sm).^2))))
%                 plot(20*log10(abs(fft(Sm(1,:)))))
%                 pause
                
                %    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_Pilot,rcflt3,Path_number);             
                end 
                %    pause
                %    Receiver: Process each subcarrier separately
                
                for nc=1:Carrier_number_used
                     R=reshape(rs(:,nc,:),Antenna_number,length(rs(:,nc,:))); 
                     
%                      plot(20*log10(abs(fft(tmp))))

%                     if Oversampling_factor==1
%                         R=tmp;
%                     else
%                         R=SC_sync(tmp,Slot_length, Subslot_length,Subslot_number,Gaurd_Pilot,rcflt3,Path_number);
%                     end
%                     
                    %    Receiver: Channel estimation 
                    Index_R=Gaurd_length;Fades=zeros(Antenna_number,Path_number*(Subslot_number+1));Index_Fades=0;Noise_variance=[];
                    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:Path_number))=Tmp_Fades(:,1:Path_number);
                        Tmp_Noise = R(:,Index_R+(1:Pilot_length))-Tmp_Fades(:,1:Path_number)*Pilot_matrix;
                        Nv=sum(sum(abs(Tmp_Noise.*Tmp_Noise)))/Pilot_length/Antenna_number;                                    % Estimate of noise variance 
                        Noise_variance=[Noise_variance Nv];
                        Index_R=Index_R+Subslot_length;
                        Index_Fades=Index_Fades+Path_number;
                    end
                    Tmp_Nv=sum(Noise_variance)/(Subslot_number+1);%*(Pilot_length-Path_number)/Pilot_length;
                    
%                     10*log10(sum(abs(R*conj(Fades(1,1))-sb(nc,:)).^2)/sum(abs(sb(nc,:)).^2))
%                     pause                  
%                     
                    for p=1:Path_number
                        tmp_Fades=Fades(:,p:Path_number:end);
                        %  tmp_FadesDFT=fft(tmp_Fades,[],2);
                        %  tmp_FadesDFT(:,Subslot_number/4+(1:Subslot_number/2))=0;
                        for na=1:Antenna_number
                            %tmp_FadesP(na,:)=interp(tmp_Fades(na,:),2);
%                             tmp_FadesP(na,:)=csaps(0:Subslot_number,tmp_Fades(na,:),1,0.5:Subslot_number);
                            tmp_FadesP(na,:)=spline(0:Subslot_number,tmp_Fades(na,:),0.5:Subslot_number);
                        end
                        
                        Fades(:,p:Path_number:length(Fades)-Path_number)=tmp_FadesP;
                        
%                         plot(1:8,abs(tmp_FadesP'), 1:9,abs(tmp_Fades'))
%                         pause
                    end
                    
%                     Fades(abs(Fades)<sqrt(Tmp_Nv)/8)=0;
%                     Fades=(abs(Fades)-sqrt(Tmp_Nv)/8).*sign(Fades);
                    
                    
                    %    Receiver: Equalization in DFT domain
                    Index_R=Pilot_length; Index_Fades=0;R_EQ=[];
                    for kk=1:Subslot_number
                        Tmp_Fades=(Fades(:,Index_Fades+(1:Path_number)));%+Fades(:,Index_Fades+Path_number+(1:Path_number)))/2;
                        %Tmp_Nv=(Noise_variance(kk)+Noise_variance(kk+1))/2;
%                         Tmp_Fades(abs(Tmp_Fades)<sqrt(Tmp_Nv)/8)=0;
%                         Tmp_Fades=(abs(Tmp_Fades)-sqrt(Tmp_Nv)/8).*sign(Tmp_Fades);
                        
                        
                        RM=R(:,Index_R+(1:Subslot_length)); 
                        R_DFT=fft(conj(RM)');
                        H_DFT=fft(conj([Tmp_Fades zeros(Antenna_number,Subslot_length-Path_number)])');
                        Tmp_R_EQ=conj(ifft(sum(R_DFT.*conj(H_DFT),2)./(sum(H_DFT.*conj(H_DFT),2)+Tmp_Nv)))';
                        R_EQ=[R_EQ Tmp_R_EQ(Gaurd_length+(1:SubslotData_length))];
                        Index_Fades=Index_Fades+Path_number;
                        Index_R=Index_R+Subslot_length;
                    end
                    RR=reshape(Walsh'*reshape(R_EQ.*conj(PN),Symbol_number_slot,Spread_factor)',1,SlotData_length);           % with interleaving  
                    %RR=reshape(Walsh'*reshape(R_EQ.*conj(PN),Spread_factor,Symbol_number_slot),1,SlotData_length);             % without interleaving
                    

                    
                    %Dem_signal(nc,sn*code_SlotL+(1:code_SlotL))=reshape([real(RR);imag(RR)],1,code_SlotL);      
                    %Dem_signal(nc,sn*code_SlotL+(1:code_SlotL))=reshape([real(RR); abs(real(RR))-2/sqrt(10);imag(RR); abs(imag(RR))-2/sqrt(10)],1,code_SlotL);
                    [Dem_signal(nc,sn*code_SlotL+(1:code_SlotL))] = -SoftDeMod(RR, 4);
                    
                end   
            end

            Dem_signal(:,int_table)=Dem_signal;        %reshape(reshape(Dem_signal(nc,:),code_L/Intl_length,Intl_length)',1,code_L);  
            Dem_signal=vec2mat(reshape(Dem_signal',1,code_L*Carrier_number_used),Carrier_number_used)';

            for nc=1:Carrier_number_used
                %   [x,qcode]=quantiz(sqrt(2)*DeQpsk_signal(nc,:),[-.75 -.5 -.25 0 .25 .5 .75],[7,6,5,4,3,2,1,0]); 
                %   decoded=vitdec(qcode,trel,tblen,'cont','soft',3);
                decoded=vitdec(Dem_signal(nc,:),trel,tblen,'cont','unquant');
                
                errors=errors+sum(abs(decoded(InputN*tblen+1:end)-msg(nc,1:msg_L)));
%                 if(sum(abs(decoded(InputN*tblen+1:end)-msg(nc,1:msg_L)))>10)
%                     errors
%                     pause
%                 end
                
            end
            errors
            ber(log2(Antenna_number)+1,SNR-SNR1+1)=errors/k/msg_L/Carrier_number_used;
            ber(log2(Antenna_number)+1,1:SNR-SNR1+1)
                        
            if (errors>2000 & k>50) 
                break;
            end
        end
    
        if ber(log2(Antenna_number)+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