m在VBLAST协作MIMO系统分部使用LDPC,Turbo,卷积三种信道编译码进行误码率matlab仿真

1.算法描述

   从上面的结构可知，整个卷积编码的结构可由CRC校验，卷积编码，打孔组成，其中打孔的作用就是讲卷积编码后的码率变为所需要的码率进行发送。

这里，我们采用如下的数据帧方式进行：

   首先，每次发送的数据长度为：221，进行CRC校验之后为253，然后通过卷积编码之后的长度为512，注意，这里对于213卷积编码，需要将编码前的数据自动加3个0进行补偿。

里，我们使用卷积编码的参数为213系统，编码码率为1/2，所以这里就不需要打孔了。

所以整个卷积编码的结构为校验，编码，译码，校验，四个部分构成。

参数指标：

2.仿真效果预览
matlab2013B仿真结果如下：

3.MATLAB部分代码预览

for kk = 1:length(EbNo)
    disp('当前EbNo：');
    EbNo(kk)
    
    totalNumErr = 0;
    count       = 0;
    SNR         = 10^(EbNo(kk)/10);
    N0          = 2*10^(-EbNo(kk)/10);
    sigma       = 1/(sqrt(SNR)/2);   
    ii          = 0;
    Dsd         = 36;          %db数
    Dsr         = 36;
    Drd         = 36;
    Qsd         = sqrt(10^(Dsd/10));
    Qsr         = sqrt(10^(Dsr/10));
    Qrd         = sqrt(10^(Drd/10));     
    LL          = 2;
     
    while (totalNumErr < Error_Num)
        totalNumErr
       %%
        RandStream.setDefaultStream(RandStream('mt19937ar','seed',sum(count)));
       %%
        %发送端
        %发送端
        %产生数据
        data       = round(rand(1,N-M)); 
        %卷积213编码
        u          = turbo_encode(data) ;
        u          = [u 0 0];
        %交织
        u1         = interlace(u,16,16); 
        %BPSK
        tx         = 2*u1 - 1;    
 
       %%
        %编码协作协议
        %编码协作协议
        %安论文中的卷积编码协作的结构框图进行设计
        %首先对于 发送信息分为两路进行发送
        Trans_N1    = tx;        
        Trans_N2    = tx;
        %ii=1的时候，发送自身的码字，而ii=2的时候发送协作的码字，从而达到时隙的效果
        ii          = ii + 1;        
 
        %将N1发送给目的地
        %将N1发送给目的地
        %作为发送信源
        %进行AF中继
        %信道增益
        Hsd=Qsd*(randn);
        Hsr=Qsr*(randn);
        Hrd=Qrd*(randn);
        %协作节点的放大增益
        B=sqrt(1/(abs(Qsr)^2*1));
        %===============================
        %最大合并比加权因子计算(第i个支路的可变增益加权系数为该分集之路的信号幅度与噪声功率之比)
        %计算增益
        A0=conj(Hsd)/(1/(sqrt(LL)*EbNo(kk)));
        A1=B*conj(Hsr)*conj(Hrd)/((B^2*(abs(Hsr))^2+1)*(1/(sqrt(LL)*EbNo(kk))));           
        %接收
        MIMO_Rx =  Trans_N1/max(abs(Trans_N1))+ 1/(sqrt(SNR))*randn(size(Trans_N1));
        Ysr      = Hsr*MIMO_Rx;
        Yrd      = Hrd*Ysr*B;
        Ysd      = Hsd*MIMO_Rx;
        Y        = A0*Ysd+A1*Yrd; 
        %接收到的二进制信号
        MIMO_Rx1 = Y;    
        Rec_data1= sign(MIMO_Rx1); 
           
        %将N1发送给用户2
        %将N1发送给用户2              
        %接收
        MIMO_Rx2   = Trans_N1/max(max(Trans_N1))+ 1/(sqrt(SNR))*randn(size(Trans_N1));
        Ysr        = Hsr*MIMO_Rx2;
        Yrd        = Hrd*Ysr*B;
        Ysd        = Hsd*MIMO_Rx2;
        Y          = A0*Ysd+A1*Yrd;       
        %接收到的二进制信号
        MIMO_Rx12  = Y;   
        Rec_data12 = sign(MIMO_Rx2);                     
 
        %第二时隙，用户2向目的端发送用户1的第二帧信号，即用户2重新编码得到的关于U1分组的N2比特校验码字对应的调制信号
        %在USER2中，将接收到的N1序列重新进行编码，然后将其中的序列N2发送给目的地
        %译码+校验：
        [Data_CRC2,LQs]         = turbo_decode(Rec_data12(1:end-2),zeros(N-M+3,1),Frame_Length); 
        %编码
        Ldpc_trans_data_user2  = turbo_encode(Data_CRC2) ;
        Ldpc_trans_data_user2  = [Ldpc_trans_data_user2 0 0];
        Trans_N2_user2         = Ldpc_trans_data_user2;%N2序列
        Trans_N2_user3         = 2*Trans_N2_user2-1;
           
        %---------------------协作MIMO----------------------------------
        Hsd=Qsd*(randn);
        Hsr=Qsr*(randn);
        Hrd=Qrd*(randn);
        %协作节点的放大增益
        B=sqrt(1/(abs(Qsr)^2*1));
        %===============================
        %最大合并比加权因子计算(第i个支路的可变增益加权系数为该分集之路的信号幅度与噪声功率之比)
        %计算增益
        A0=conj(Hsd)/(1/(sqrt(LL)*EbNo(kk)));
        A1=B*conj(Hsr)*conj(Hrd)/((B^2*(abs(Hsr))^2+1)*(1/(sqrt(LL)*EbNo(kk))));           
        %接收
        MIMO_Rx =  Trans_N2/max(abs(Trans_N2))+ 1/(sqrt(SNR))*randn(size(Trans_N2));
        Ysr      = Hsr*MIMO_Rx;
        Yrd      = Hrd*Ysr*B;
        Ysd      = Hsd*MIMO_Rx;
        Y        = A0*Ysd+A1*Yrd; 
        %接收到的二进制信号
        MIMO_Rx2 = Y;
        Rec_data2= sign(MIMO_Rx2);   
        YY1 = [MIMO_Rx12,MIMO_Rx2]';               
        YY2 = [Rec_data12]';        
        Tx  = reshape(YY2 - sqrt(-1)*YY2,Nt, Frame_Length/Nt);    
        RayleighMat = (rand(Nr, Nt) + j*rand(Nr, Nt));   
        rr          = size(RayleighMat*Tx,1);
        cc          = size(RayleighMat*Tx,2);
        r           = RayleighMat*Tx;  
        Hs          = RayleighMat;                                    
        HQ          = Hs*Q;         
 
        
        
       %%
        %下面开始联合迭代
        %下面开始联合迭代
        rr = r;     
        %初始半径，这里将搜索的范围变大，就是将系数alpha定为12.
        RR =(12*Nt)*(2/(10^(SNR/10)));                                   
 
        %按英文论文所示转变为实信号
        rev1=[real(rr);imag(rr)];  
        H1  = RayleighMat;
        %按英文论文所示信道转变为实矩阵
        HH=[real(H1(:,:)) -imag(H1(:,:));
            imag(H1(:,:))  real(H1(:,:))];              
 
        LA  = zeros(1,Frame_Length/2);
        LDs = 0;
        LD  = zeros(1,Frame_Length/2);
        LE  = zeros(1,Frame_Length/2);
 
        for Nout = 1:OUT_Iter
            if Nout == 1
               LA = zeros(1,Frame_Length/2);
            else
               LA = LA2; 
            end
            %球形map
            for J=1:Frame_Length/2                                            
                rev          = rev1(:,J);                
                %先计算|r-g*Si|^2
                [y_norm,LDs] = func_FP_MAP(rev,RR,HH,[-1,1],SNR);
                for jj=1:Nt
                    y_2norm(Nt*J+jj-Nt)=y_norm(jj)+j*y_norm(jj+Nt);                  
                end
                %每一个比特的后验似然比信息为
                LD(J) = LDs;
            end   
            %外部迭代主要计算 
            LE = LD - LA;
            %解交织
            LE_itrlac_code = de_interlace(LE,16,16); %用于LDPC译码节点更新
            DM_msg  = reshape(real(y_2norm),log2(P),Nt*Frame_Length/2);
            for ii2 = 1:length(DM_msg)
                if DM_msg(ii2)~=0
                   DM_msg2(ii2) = abs(DM_msg(ii2)+1)/2;
                else
                   DM_msg2(ii2) = 0; 
                end
            end       
            DM_msg3 = de_interlace(DM_msg,16,16); %用于LDPC译码节点更新
            %内部迭代卷积里面
            [z_hat,LQ] = turbo_decode(DM_msg3(1:end-2),LE_itrlac_code',Frame_Length);
            x_hat      = z_hat;
            %交织
            tmp = LQ(1:length(LE_itrlac_code)) - LE_itrlac_code;
            %交织
            LA2 = interlace(tmp,16,16);             
        end
        %===========================================================================
        count       = count + 1;
        totalNumErr = totalNumErr + biterr(round(x_hat), data);
    end
    BERs(kk) = totalNumErr/(count*Frame_Length);
end
01_054_m