您现在的位置：首页 >> 通信 >> 内容

m基于多D2D通信对和多蜂窝用户的LTE预编码技术matlab仿真

时间：2022/12/11 21:37:55 点击：

　　核心提示：01_132m含参考文献，仿真操作录像...

1.完整项目描述和程序获取

>面包多安全交易平台:https://mbd.pub/o/bread/Y5mYl5xr

>如果链接失效，可以直接打开本站店铺搜索相关店铺：

点击店铺

>如果链接失效，程序调试报错或者项目合作也可以加微信或者QQ联系。

2.部分仿真图预览




3.算法概述

        LTE网络中采用MIMO技术增加系统容量，提升吞吐率，从理论上来看,多天线的空分复用能成倍增加系统容量。但实际上并非如此,如，22MIMO的容量C（容量）=22MIMO 小于两倍的SISO容量C（容量）=2SISO，这是因为容量增加了，干扰增大了，干扰主要是由于信道矩阵中信道的相关性造成的，为了消除信道相关性造成影响，需要在接收端对H进行评估，并做线性均衡，最大化MIMO信道矩阵H的容量。

       为了获取更高的MIMO容量，接收机侧需要对MIMO的发射矩阵H中的每个信道都进行均衡处理，消除信道间的影响，这样增加接收机的实现复杂度。如SISO模式，接收机需要线性均衡处理一个信道，而对于一个2*2MIMO模式，接收机需要处理评估4个信道；其次，接收端若将H矩阵中的多个信道相关性评估结果反馈给发射机，这会增加系统开销。另一个是，若通过增加天线空间来消除信道间的影响，但天线近处的杂散环境使实现难度增加。于是提出了通过技术改进解决，这个方法就是预编码（Precoding）。

4.部分源码

clc;

clear;

close all;

warning off;

addpath 'func\'

addpath 'func\modulation\'

addpath 'func\estmation\'

addpath 'func\cp\'

addpath 'func\LTEC\'

addpath 'func\precodeing\'

 

 

SNRS      = [0:4:16];

 

for jj = 1:length(SNRS);

    

    Tx_n      = 4;   

    Rx_n      = 4;   

    %整体信噪比

    SNR       = SNRS(jj);  

    Nfft      = 1024;

    Nid       = 17; 

    Sym_Len   = 7;

    CP_length = 144;

    CPNfft    = Nfft+CP_length;

 

    for y=1:100

        y

        SNRS(jj)

        noise     = SNR;

        N0        = 10^(-noise/10);

        %产生信道估计所用的测试信号，功能类似导频

        [subframe,data_v,data_v0,data_v1,data_v2,data_v3] = func_data_gen(Tx_n,Rx_n,Sym_Len,Nid);

        number_length                                     = length(find(subframe == 0));

        %IFFT

        data_ifft1 = zeros(Nfft,2*Sym_Len);

        data_ifft2 = zeros(Nfft,2*Sym_Len);

        data_ifft3 = zeros(Nfft,2*Sym_Len);

        data_ifft4 = zeros(Nfft,2*Sym_Len);

        for i=1:2*Sym_Len

            data_ifft1(:,i) = ifft(data_v0(:,i),Nfft);

            data_ifft2(:,i) = ifft(data_v1(:,i),Nfft);

            data_ifft3(:,i) = ifft(data_v2(:,i),Nfft);

            data_ifft4(:,i) = ifft(data_v3(:,i),Nfft);

        end

        %插入CP

        WithCP_sequence1 = zeros(CPNfft,2*Sym_Len);

        WithCP_sequence2 = zeros(CPNfft,2*Sym_Len);

        WithCP_sequence3 = zeros(CPNfft,2*Sym_Len);

        WithCP_sequence4 = zeros(CPNfft,2*Sym_Len);

 

        for i=1:2*Sym_Len

            WithCP_sequence1(:,i) = func_CP_In(data_ifft1(:,i).',CP_length);

            WithCP_sequence2(:,i) = func_CP_In(data_ifft2(:,i).',CP_length);

            WithCP_sequence3(:,i) = func_CP_In(data_ifft3(:,i).',CP_length);

            WithCP_sequence4(:,i) = func_CP_In(data_ifft4(:,i).',CP_length);

        end

        T1=reshape(WithCP_sequence1,1,CPNfft*2*Sym_Len);

        T2=reshape(WithCP_sequence2,1,CPNfft*2*Sym_Len);

        T3=reshape(WithCP_sequence3,1,CPNfft*2*Sym_Len);

        T4=reshape(WithCP_sequence4,1,CPNfft*2*Sym_Len);

 

        [r1,channel_impulse1,delay_number1,tap_delay1]=func_LTEChan(T1,'EPA');

        [r2,channel_impulse2,delay_number2,tap_delay2]=func_LTEChan(T2,'EPA');

        [r3,channel_impulse3,delay_number3,tap_delay3]=func_LTEChan(T3,'EPA');

        [r4,channel_impulse4,delay_number4,tap_delay4]=func_LTEChan(T4,'EPA');

        [r5,channel_impulse5,delay_number5,tap_delay5]=func_LTEChan(T1,'EPA');

        [r6,channel_impulse6,delay_number6,tap_delay6]=func_LTEChan(T2,'EPA');

        [r7,channel_impulse7,delay_number7,tap_delay7]=func_LTEChan(T3,'EPA');

        [r8,channel_impulse8,delay_number8,tap_delay8]=func_LTEChan(T4,'EPA');

        R1     = (r1+r2+r3+r4);

        R2     = (r5+r6+r7+r8);

        a      = awgn(R1*sqrt(Nfft),noise,'measured');

        b      = awgn(R2*sqrt(Nfft),noise,'measured');

 

        noise1 = a/sqrt(Nfft)-R1;

        noise2 = b/sqrt(Nfft)-R2;

        R1     = a/sqrt(Nfft);

        R2     = b/sqrt(Nfft);

 

        %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

        %去CP

        WithCP_sequence_1 = reshape(R1,CPNfft,2*Sym_Len);

        WithCP_sequence_2 = reshape(R2,CPNfft,2*Sym_Len);

        NoCP_sequence1    = zeros(2*Sym_Len,Nfft);

        NoCP_sequence2    = zeros(2*Sym_Len,Nfft);

        for i=1:2*Sym_Len

            NoCP_sequence1(i,:) = func_CP_del(WithCP_sequence_1(:,i),CP_length); 

            NoCP_sequence2(i,:) = func_CP_del(WithCP_sequence_2(:,i),CP_length); 

        end

        NoCP_sequence1=NoCP_sequence1.';

        NoCP_sequence2=NoCP_sequence2.';

        %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

        %FFT

        FFTed1=zeros(Nfft,2*Sym_Len);

        FFTed2=zeros(Nfft,2*Sym_Len);

        for i=1:2*Sym_Len

            FFTed1(:,i)=fft(NoCP_sequence1(:,i));

            FFTed2(:,i)=fft(NoCP_sequence2(:,i));

        end

        %信道估计

        [MH10,MH11,MH12,MH13] = func_channel_estmation(FFTed1,0,Nid,1,Tx_n,Sym_Len,Rx_n);

        [MH20,MH21,MH22,MH23] = func_channel_estmation(FFTed2,0,Nid,1,Tx_n,Sym_Len,Rx_n);

        %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

        %%信道估计之后开始在正式的链路的仿真%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

        %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

        %产生随机信号

        Din1     = round(rand(1,number_length*2));

        Din2     = round(rand(1,number_length*2));

        %调制

        Din_mod1 = func_QPSK(Din1);

        Din_mod2 = func_QPSK(Din2);

        %码本选择

        for i=1:Tx_n*Rx_n*2*Sym_Len

            H           = [MH10(i) MH11(i) MH12(i) MH13(i);MH20(i) MH21(i) MH22(i) MH23(i)];

            [R,snr]     = func_codebookselect(H,N0);

            r_withRS(i) = R;

        end

        r        = func_rs_del(Tx_n,r_withRS,0,Nid,1,Sym_Len,Rx_n);

        %预编码

        [copreding0,copreding1,copreding2,copreding3] = func_Precoding(Din_mod1,Din_mod2,r);

        %VRB

        k=1;

        for i=1:length(subframe)

            if data_v(i)==0

               data_v0(i)=copreding0(k);

               data_v1(i)=copreding1(k);

               data_v2(i)=copreding2(k);

               data_v3(i)=copreding3(k);

               k=k+1;

            end

        end

       IFFTed0_2nd=zeros(Nfft,2*Sym_Len);

       IFFTed1_2nd=zeros(Nfft,2*Sym_Len);

       IFFTed2_2nd=zeros(Nfft,2*Sym_Len);

       IFFTed3_2nd=zeros(Nfft,2*Sym_Len);

 

       for i=1:2*Sym_Len

           IFFTed0_2nd(:,i)=ifft(data_v0(:,i),Nfft);

           IFFTed1_2nd(:,i)=ifft(data_v1(:,i),Nfft);

           IFFTed2_2nd(:,i)=ifft(data_v2(:,i),Nfft);

           IFFTed3_2nd(:,i)=ifft(data_v3(:,i),Nfft);

       end

       %加CP

       WithCP_sequence0_2nd=zeros(CPNfft,2*Sym_Len);

       WithCP_sequence1_2nd=zeros(CPNfft,2*Sym_Len);

       WithCP_sequence2_2nd=zeros(CPNfft,2*Sym_Len);

       WithCP_sequence3_2nd=zeros(CPNfft,2*Sym_Len);

       for i=1:2*Sym_Len

           WithCP_sequence0_2nd(:,i)=func_CP_In(IFFTed0_2nd(:,i).',CP_length);

           WithCP_sequence1_2nd(:,i)=func_CP_In(IFFTed1_2nd(:,i).',CP_length);

           WithCP_sequence2_2nd(:,i)=func_CP_In(IFFTed2_2nd(:,i).',CP_length);

           WithCP_sequence3_2nd(:,i)=func_CP_In(IFFTed3_2nd(:,i).',CP_length);

       end

       T0_2nd=reshape(WithCP_sequence0_2nd,1,CPNfft*2*Sym_Len);

       T1_2nd=reshape(WithCP_sequence1_2nd,1,CPNfft*2*Sym_Len);

       T2_2nd=reshape(WithCP_sequence2_2nd,1,CPNfft*2*Sym_Len);

       T3_2nd=reshape(WithCP_sequence3_2nd,1,CPNfft*2*Sym_Len);

       [r1_2nd]=func_LTEChannel2(T0_2nd,channel_impulse1,delay_number1,tap_delay1);

       [r2_2nd]=func_LTEChannel2(T1_2nd,channel_impulse2,delay_number2,tap_delay2);

       [r3_2nd]=func_LTEChannel2(T2_2nd,channel_impulse3,delay_number3,tap_delay3);

       [r4_2nd]=func_LTEChannel2(T3_2nd,channel_impulse4,delay_number4,tap_delay4);

       [r5_2nd]=func_LTEChannel2(T0_2nd,channel_impulse5,delay_number5,tap_delay5);

       [r6_2nd]=func_LTEChannel2(T1_2nd,channel_impulse6,delay_number6,tap_delay6);

       [r7_2nd]=func_LTEChannel2(T2_2nd,channel_impulse7,delay_number7,tap_delay7);

       [r8_2nd]=func_LTEChannel2(T3_2nd,channel_impulse8,delay_number8,tap_delay8);

       R1_2nd=r1_2nd+r2_2nd+r3_2nd+r4_2nd;

       R2_2nd=r5_2nd+r6_2nd+r7_2nd+r8_2nd;

       R1_2nd=R1_2nd+noise1;

       R2_2nd=R2_2nd+noise2;

       a=awgn(R1_2nd*sqrt(Nfft),noise);

       b=awgn(R2_2nd*sqrt(Nfft),noise);

       R1_2nd=a/sqrt(Nfft);

       R2_2nd=b/sqrt(Nfft);

       %去CP

       WithCP_sequence_1_2nd=reshape(R1_2nd,CPNfft,2*Sym_Len);

       WithCP_sequence_2_2nd=reshape(R2_2nd,CPNfft,2*Sym_Len);

       NoCP_sequence1_2nd=zeros(14,Nfft);

       NoCP_sequence2_2nd=zeros(14,Nfft);

 

         for i=1:2*Sym_Len

             NoCP_sequence1_2nd(i,:)=func_CP_del(WithCP_sequence_1_2nd(:,i),CP_length); 

             NoCP_sequence2_2nd(i,:)=func_CP_del(WithCP_sequence_2_2nd(:,i),CP_length); 

         end

         NoCP_sequence1_2nd=NoCP_sequence1_2nd.';

         NoCP_sequence2_2nd=NoCP_sequence2_2nd.';

         %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

         %FFT

         FFTed1_2nd=zeros(Nfft,2*Sym_Len);

         FFTed2_2nd=zeros(Nfft,2*Sym_Len);

         for i=1:2*Sym_Len

             FFTed1_2nd(:,i)=fft(NoCP_sequence1_2nd(:,i));

             FFTed2_2nd(:,i)=fft(NoCP_sequence2_2nd(:,i));

         end

         prb1=zeros(Tx_n*Rx_n,2*Sym_Len);

         prb2=zeros(Tx_n*Rx_n,2*Sym_Len);

         for i=1:2*Sym_Len

             for k=1:Tx_n*Rx_n

                 prb1(k,i)=FFTed1_2nd(k,i);

                 prb2(k,i)=FFTed2_2nd(k,i);

             end

         end

        %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

        %均衡

        vrb_1=reshape(prb1,1,Tx_n*Rx_n*2*Sym_Len);

        vrb_2=reshape(prb2,1,Tx_n*Rx_n*2*Sym_Len);

        eqed1=zeros(1,Tx_n*12*2*Sym_Len);

        eqed2=zeros(1,Tx_n*12*2*Sym_Len);

 

        for i=1:length(vrb_1)

            R=r_withRS(i);

            H=[MH10(i) MH11(i) MH12(i) MH13(i);MH20(i) MH21(i) MH22(i) MH23(i)];

            [eqed1(i),eqed2(i)]=func_Equ(vrb_1(i),vrb_2(i),H,N0,R);

        end

 

        Doutf1    = func_rs_del(Tx_n,eqed1,0,Nid,1,Sym_Len,Rx_n);

        Doutf2    = func_rs_del(Tx_n,eqed2,0,Nid,1,Sym_Len,Rx_n);

        %QPSK解调

        out1      = func_DQPSK(Doutf1);

        out2      = func_DQPSK(Doutf2);

        %计算误码

        [En1,En2] = func_error(Din1,Din2,out1,out2);

        err(y)    =(En1+En2)/2;

    end

    BER(jj) = sum(err)/(Tx_n*Rx_n*length(Din1)); 

end

figure;

semilogy(SNRS,BER,'b-s');

grid on

xlabel('SNR');

ylabel('Ber');

axis([0,18,5e-3,1e0]);

01-132m

Tags:多D2D通信对 多蜂窝用户 LTE预编码 
作者：我爱C编程　来源：我爱C编程
本站最新成功开发工程项目案例
  • 上一篇：m基于多用户MIMO系统的分布式可重构注水算法的matlab仿真
  • 下一篇：信道估计算法误码率仿真,对比不同导频长度,对比不同信道估计算法包括CS-OMP,LS,MMSE
    • 相关文章
    • 没有相关文章
    相关评论
    发表我的评论
    • 大名：
    • 内容：
    本类固顶
    • 没有
  • FPGA/MATLAB商业/科研类项目合作(www.store718.com) © 2025 版权所有 All Rights Reserved.
  • Email:1480526168@qq.com 站长QQ: 1480526168