m半分布式JAC联合接纳控制与用户位置信息的垂直切换matlab仿真

1.算法描述 随着无线通信技术的飞速发展，为支持多种不同无线接入技术、不同系统间协作、不同业务类型及终端差异性等需求，未来的无线网络将是一种协作式的异构网络融合架构，这将给系统的无线资源管理带来新的变化与挑战。传统的无线资源管理技术，已不能很好地满足多制式异构蜂窝网络环境下的不同需求。为了解决异构网络间无线资源的协作管理与调度问题，联合接纳控制与垂直切换等技术引起了广泛研究与讨论。

  联合接纳控制是一种集中式的接纳控制，多种RAT在相同的区域进行覆盖，形成了多RAT的网络结构。每一种无线接入技术RAT(Radio Access Technology)由若干个基站BS(Base Station)组成，每个BS根据需要，管理相应的多个小区，每个BS对所属的多个小区进行接纳控制，将网络信息上报到JAC实体，由JAC做出接纳判决。具体系统模型，如下图1所示：

   上图1可知，由于各网络将业务请求转发到JAC控制实体中进行处理，同时JAC需要综合各网络的状况，来决定对该业务请求进行判决，是否能被接纳以及接纳到哪个网络，这种方法虽然能够实现多网络之间的资源优化合理使用，但该方法中每个业务请求向JAC实体进行转发，增加了业务请求的响应和处理时间，降低了用户体验。

   根据终端位置信息，基站向终端提供网络带宽、时延等参数。以QoS最优化为目标确定能代表网络性能的属性量决策，通过选择几个比较重要的属性参数，属性层为影响网络选择的决定性因素：信号强度P、服务速率S、网络延迟D、网络的使用费用C，如图4.2所示，为各网络属性加权示意图：

垂直切换，主要是针对UE连接态时，经过切换测量，切换策略，对UE进行切换执行，切换到目标网络；如果超出则仿真结束，进行UE及小区更新，主要是周期性更新小区负载和UE位置方向、速度等信息；

  仿真流程；如下图3所示：

垂直切换仿真流程说明：

垂直切换：分类统计切换失败次数、乒乓切换和short-stay切换次数，切换完成(切换接入成功)时，判断并统计乒乓。Short-stay切换次数； 2.仿真效果预览 matlab2022a仿真结果如下：

3.MATLAB核心程序

    VP_ms  = [-1000,500;   %A
              -290,105;   %B
               -20, 40;   %C
                 0, 40;   %D
                20, 40;   %E
               250,120;   %F
               1200,800]  ;%G
 
type   = 1;%业务类型：1：语音业务，2：数据业务,3:视频模型
 
%各个网络的接入，断开功率门限值
Rss_gsm_in   = -50;%dbm
Rss_gsm_out  = -65;%dbm
Rss_tds_in   = -55;%dbm
Rss_tds_out  = -70;%dbm
Rss_lte_in   = -50;%dbm
Rss_lte_out  = -65;%dbm
 
%定义用户运动的距离 
Xp           = 0;
Yp           = 0;
%定义仿真时间参数
delta        = 0.01;
Time         = 3;
t            = 0;
%数组计数器
Ind          = 0;
Ind2         = 0;
 
 
%接收功率、最大的传输速率、时延、费用价格
%其中接收功率为实测
POW_gsm  = 0;
Rb_gsm   = 8;
DLY_gsm  = 40;
MNY_gsm  = 0.2;
 
POW_tds  = 0;
Rb_tds   = 1.28;
DLY_tds  = 20;
MNY_tds  = 0.3;
 
POW_lte  = 0;
Rb_lte   = 8;
DLY_lte  = 45;
MNY_lte  = 0.1;
 
 
%接收功率、最大的传输速率、时延、费用价格 
ViewS    = 20;%减小消耗内存，采样显示结果
 
%定义分层矩阵
C        = zeros(4,4);
 
 
%%
%场景的初始化
%X,Y为MB移动的路径，随着时间的变化而X,Y的变化值，用于循环仿真使用
[X,Y] = func_Simu_Scene(P_tds,P_lte,P_gsm,VP_ms,R_tds,R_lte,R_gsm,NUE);
save My_Result\Simu_Scene.mat 
 
%%
%主循环
%定义变量
Len       = min(Time/delta,floor((length(X{UE_Spec})-Sp_ms)/Sp_ms));
%定义网络ID变量
ClK                       = zeros(Len,1); 
IDs                       = zeros(Len,3);
RSS_tdss                  = zeros(Len,1);
RSS_gsms                  = zeros(Len,1);
RSS_ltes                  = zeros(Len,1);
Networkcontribution_tdss  = zeros(Len,1);
Networkcontribution_gsms  = zeros(Len,1);
Networkcontribution_ltes  = zeros(Len,1);
IDs2                      = zeros(Len,1);
USER_SPACE                = zeros(Len,NUE);
%记录指定用户的切换情况
UE_Spec_NET               = zeros(Len,1);
STime                     = 1000;%蒙特卡洛循环次数
%主循环
%定义变量
for iii = 1:length(Sp_ms)
    Len       = (Time/delta);
    %定义网络ID变量
    tmp1 = 0;
    tmp2 = 0;
    for iii2 = 1:STime%各种速度仿真STime次，计算平均
        iii
        iii2
        t            = 0;
        %数组计数器
        Ind          = 0;
        Ind2         = 0;
        RandStream.setDefaultStream(RandStream('mt19937ar','seed',iii2));
        while (t < Time-delta )
            t
           %计算时间
           t    = t    + delta*Sp_ms(iii);
           Ind  = Ind  + Sp_ms(iii);
           Ind2 = Ind2 + 1;
 
           for Nj = 1:NUE
               %根据坐标位置，得到MB的当前区域,在一个小范围内，进行仿真，
               %根据坐标位置，得到MB的当前区域,在一个小范围内，进行仿真，
               if Ind2 == 1
                  Xp  = 100*randn(1,1)-900;
                  Yp  = 0;
               else
                  Xp = Xp + Sp_ms(iii);
                  Yp = 0;
               end
                  ddd = sqrt((Xp - P_tds(1))^2 + (Yp - P_tds(2))^2);
               if ddd >= 800
                  Xp  = 100*randn(1,1)-900;
                  Yp  = 0;
               else
                  Xp  = Xp;
                  Yp  = 0;        
               end
               %根据不同的区域，确定有几个网络
               ID(:,Nj)     = func_NET_ID(Xp,Yp,P_tds,P_lte,P_gsm,R_tds,R_lte,R_gsm);
 
               %计算RSS值
               RSS_tds(Nj)  = func_Rss_cal(Xp,Yp,Sp_ms(iii),P_tds,F_tds,t,Pow_tds,ISFAST);
               RSS_lte(Nj)  = func_Rss_cal(Xp,Yp,Sp_ms(iii),P_lte,F_lte,t,Pow_lte,ISFAST);
               RSS_gsm(Nj)  = func_Rss_cal(Xp,Yp,Sp_ms(iii),P_gsm,F_gsm,t,Pow_gsm,ISFAST);
           end
           %===========================================================================
           %判断每一时刻的备选网络
           %进行分层计算,这个根据业务模型的不同，而不同
           %接收功率、最大的传输速率、时延、费用价格
           %正常情况下，我们假设接收功率时变，而其他三个参数固定，从而进行实时计算网络贡献值
           %这里，分层法的解W，我参考了另外一篇的做法，比较方便
 
           if type == 1%语音业务，我们认为时延最重要
               %接收功率、最大的传输速率、时延、费用价格
               C=[1      5       1/7   3;
                  1/5    1       1/3   1/2;
                  7      3       1     2;
                  1/3    2       1/2   1];
           end 
 
           %计算权值W
           for i = 1:4
               w2(i) = (C(i,1)*C(i,2)* C(i,3)* C(i,4))^0.25;  
           end
           for i = 1:4
               w(i)  = w2(i)/sum(w2);  
           end   
           w1 = w(1);
           w2 = w(2);
           w3 = w(3);
           w4 = w(4);
 
            %注意，这里矩阵C的建立，具有一定的主观性，所以我就不设置了，你改下，就可以换别的业务模型进行仿真了  
            %注意，这里矩阵C的建立，具有一定的主观性，所以我就不设置了，你改下，就可以换别的业务模型进行仿真了      
 
            %计算网络贡献权值由上面的分层法计算得到
            %接收功率、最大的传输速率、时延、费用价格 
 
 
            for Nj = 1:NUE
                %将功率dbm转换为标准功率w
                PP_tds(Nj)  = 10^(RSS_tds(Nj)/20);
                PP_lte(Nj)  = 10^(RSS_lte(Nj)/20);
                PP_gsm(Nj)  = 10^(RSS_gsm(Nj)/20);
 
                %构成矩阵，并规划化
                Rs = [PP_tds(Nj),Rb_tds,DLY_tds,MNY_tds;
                      PP_lte(Nj),Rb_lte,DLY_lte,MNY_lte;
                      PP_gsm(Nj),Rb_gsm,DLY_gsm,MNY_gsm];
 
                [r,c] = size(Rs);
                for j = 1:c
                    Mins = min(Rs(:,j));   
                    Maxs = max(Rs(:,j)); 
                    for i = 1:r
                        R(i,j) = (Rs(i,j)-Mins)/(Maxs); 
                    end
                end
 
                if ID(:,Nj) == [1,0,0]'
                   Networkcontribution_tds(Nj) = w1*R(1,1) + w2*R(1,2) + w3*R(1,3) + w4*R(1,4);
                   Networkcontribution_lte(Nj) = 0;
                   Networkcontribution_gsm(Nj) = 0;
                elseif ID(:,Nj) == [0,2,0]'
                   Networkcontribution_tds(Nj) = 0; 
                   Networkcontribution_lte(Nj) = w1*R(2,1) + w2*R(2,2) + w3*R(2,3) + w4*R(2,4);
                   Networkcontribution_gsm(Nj) = 0;        
                elseif ID(:,Nj) == [0,0,3]'
                   Networkcontribution_tds(Nj) = 0; 
                   Networkcontribution_lte(Nj) = 0; 
                   Networkcontribution_gsm(Nj) = w1*R(3,1) + w2*R(3,2) + w3*R(3,3) + w4*R(3,4);       
                elseif ID(:,Nj) == [1,2,0]'    
                   Networkcontribution_tds(Nj) = w1*R(1,1) + w2*R(1,2) + w3*R(1,3) + w4*R(1,4);
                   Networkcontribution_lte(Nj) = w1*R(2,1) + w2*R(2,2) + w3*R(2,3) + w4*R(2,4);
                   Networkcontribution_gsm(Nj) = 0;   
                elseif ID(:,Nj) == [1,0,3]' 
                   Networkcontribution_tds(Nj) = w1*R(1,1) + w2*R(1,2) + w3*R(1,3) + w4*R(1,4);
                   Networkcontribution_lte(Nj) = 0;    
                   Networkcontribution_gsm(Nj) = w1*R(3,1) + w2*R(3,2) + w3*R(3,3) + w4*R(3,4);    
                elseif ID(:,Nj) == [0,2,3]' 
                   Networkcontribution_tds(Nj) = 0;
                   Networkcontribution_lte(Nj) = w1*R(2,1) + w2*R(2,2) + w3*R(2,3) + w4*R(2,4);   
                   Networkcontribution_gsm(Nj) = w1*R(3,1) + w2*R(3,2) + w3*R(3,3) + w4*R(3,4);
                elseif ID(:,Nj) == [1,2,3]' 
                   Networkcontribution_tds(Nj) = w1*R(1,1) + w2*R(1,2) + w3*R(1,3) + w4*R(1,4);
                   Networkcontribution_lte(Nj) = w1*R(2,1) + w2*R(2,2) + w3*R(2,3) + w4*R(2,4);   
                   Networkcontribution_gsm(Nj) = w1*R(3,1) + w2*R(3,2) + w3*R(3,3) + w4*R(3,4);
                else
                   Networkcontribution_tds(Nj) = 0;
                   Networkcontribution_lte(Nj) = 0;
                   Networkcontribution_gsm(Nj) = 0;
                end
            end
 
            %初始化UE驻留网络，根据RSS值，来初始化驻留小区网络
            if  Ind2 <= 1
                for Nj = 1:NUE
                    [V,I] = max([Networkcontribution_tds(Nj),Networkcontribution_lte(Nj),Networkcontribution_gsm(Nj)]);
                    USER_SPACE(Ind2,Nj) = I;
                end
                UE_Spec_NET(Ind2) = USER_SPACE(Ind2,UE_Spec);
            else
                %===========================================================================
                %接纳控制%接纳控制%接纳控制%接纳控制%接纳控制%接纳控制%接纳控制%接纳控制%接纳控制
                %接纳控制%接纳控制%接纳控制%接纳控制%接纳控制%接纳控制%接纳控制%接纳控制%接纳控制
 
                %STEP1:检查当前网络是否处于重负载状态
                %计算各个网络中用户个数
                tmps    = USER_SPACE(Ind2-1,:);
                Num_tds = length(find(tmps == 1));
                Num_lte = length(find(tmps == 2));
                Num_gsm = length(find(tmps == 3));
 
                %指定分析用户将要切入的网络
                UE_Spec_ID = USER_SPACE(Ind2,UE_Spec);
                isfull     = 0;%初始，小区没有饱和
                %判断该小区是否满负荷
                if UE_Spec_ID == 1
                   if Num_tds >= Nfull_tds;isfull = 1;else;isfull = 0; end;
                end
                if UE_Spec_ID == 2
                   if Num_lte >= Nfull_lte;isfull = 1;else;isfull = 0; end;
                end    
                if UE_Spec_ID == 3
                   if Num_gsm >= Nfull_gsm;isfull = 1;else;isfull = 0; end;
                end    
                %如果否，则接纳该用户,即可以进行接纳其接入，即可以垂直切换
                if isfull == 0
                   [V2,I2]           = max([Networkcontribution_tds(UE_Spec),Networkcontribution_lte(UE_Spec),Networkcontribution_gsm(UE_Spec)]);
                   UE_Spec_NET(Ind2) = I2;
                else
                    %如果是，系统检查当前网络是否有可用容量
                    UE_Spec_ID = USER_SPACE(Ind2-1,UE_Spec);
                    isfull2    = 0;%初始，小区没有饱和
                    %判断该小区是否满负荷
                    if UE_Spec_ID == 1
                       if Num_tds >= Nfull_tds;isfull2 = 1;else;isfull2 = 0; end;
                    end
                    if UE_Spec_ID == 2
                       if Num_lte >= Nfull_lte;isfull2 = 1;else;isfull2 = 0; end;
                    end    
                    if UE_Spec_ID == 3
                       if Num_gsm >= Nfull_gsm;isfull2 = 1;else;isfull2 = 0; end;
                    end
 
                    if isfull2 == 1%如果没有，则拒绝该用户的接入请求
                       UE_Spec_NET(Ind2) = -inf;%负无穷，表示拒绝接入
                    else
                       UE_Spec_NET(Ind2) = UE_Spec_NET(Ind2-1);
                    end
                end        
            end
            %将每次循环的结果进行保存
            ClK(Ind2)                      = t-delta;
            IDs(Ind2,1)                    = ID(1,UE_Spec);
            IDs(Ind2,2)                    = ID(2,UE_Spec);
            IDs(Ind2,3)                    = ID(3,UE_Spec);
            RSS_tdss(Ind2)                 = RSS_tds(UE_Spec);
            RSS_ltes(Ind2)                 = RSS_lte(UE_Spec);
            RSS_gsms(Ind2)                 = RSS_gsm(UE_Spec);
            Networkcontribution_tdss(Ind2) = Networkcontribution_tds(UE_Spec);
            Networkcontribution_ltes(Ind2) = Networkcontribution_lte(UE_Spec);
            Networkcontribution_gsms(Ind2) = Networkcontribution_gsm(UE_Spec);
            IDs2(Ind2)                     = UE_Spec_NET(Ind2);
            %统计直接RSS方法的切换次数
            [Vss,Iss] = max([RSS_tds(UE_Spec),RSS_lte(UE_Spec),RSS_gsm(UE_Spec)]);
            IDs3(Ind2)                      = Iss;
            if Ind2 > 2 & abs(IDs3(Ind2) - IDs3(Ind2-1)) > 0
               tmp1 = tmp1 + 1;
            end
            %统计垂直切换策略的切换次数
            if Ind2 > 2 & abs(IDs2(Ind2) - IDs2(Ind2-1)) > 0
               tmp2 = tmp2 + 1;
            end
        end
    end
    N1(iii) = tmp1/STime;
    N2(iii) = tmp2/STime;
end
 
figure;
plot(Sp_ms,N1,'k-o');
xlabel('Speed');
ylabel('切换次数');
grid on;
hold on
plot(Sp_ms,N2,'k-s');
xlabel('Speed');
ylabel('切换次数');
grid on;
hold on
legend('多属性策略JAC算法','半分布式JAC算法');
01_091_