m基于基站休眠的LTE-A异构网络中节能算法matlab仿真

1.算法描述
要求
1.开发一个软件工具，可以直观地演示如何在LTE-A异构网络中通过基站的睡眠模式节约能源
2.需要演示基于用户的移动性如何设置基站的开关(睡眠模式)
3.自己设计基站睡眠模式的直观展示原则
4.在模拟异构网络时展示系统的能量消耗

成果
1.一个软件工具可以直观展示LTE-A异构网中基站的睡眠模式
2.在特定的异构网络布局和特定的时间框架下演示基站的开启和关闭
3.直观展示能源效率基站睡眠模式的性能指标

这里，我们主要设置一个19个基站构造的规则六边形小区，具体的仿真效果如下所示：

    这里，我们模拟了19个基站构成的小区，每个小区中间位置有一个基站，上图中红色区域部分。然后紫色的带内表示用户，这些点是在随机的运动的。蓝色方框是在每个小区内随机分布的PICO微微网络基站。

    另外，这里我们模拟的是一个城市的中心区域的模型，即中间小区用户数量较多，基站基本上处于满负荷状态，而周边几个小区用户数量较少。

    用户在实际中做的运动方程为随机方向的变速运动，因此这里设备的运动方程用如下的式子表示：

这里，假设设备是平面运动的，所以Z一直为0.

   其中速度因子，我考虑是模拟设备的变加速运动，即一个固定的速度V0和每个时刻不同的加速度的情况。角度为一个恒定的值与随机变量的叠加。即：

    这样的情况，可以更加符合实际的设备运动的复杂情况。当a(t)为0的时候，设备做匀速运动。当a(t)为常数的时候，为匀加速运动，当a(t)为变化的值得时候，那么系统就为变加速运动。

      然后这里我简单的接收一下我们这个异构网络的休眠切换算法：

    在异构网络中，由于PICO网络的能耗远远小于MICRO基站的能耗，因此，在实际中，我们需要尽可能多的将设备与PICO基站建立连接，并同时通过系统对没有用户参与连接的MICRO基站进行关闭。

    节点休眠算法的主要含义为：

    当基站关闭以后，可以大大降低能耗，此时的基站失去了发送的能力，被称为休眠基站。而在一个大型的网络中，由于每个单一的基站并不会在每时每刻都处于工作之中，那么会对整个网络产生一定的冗余，在这样一个环境中，完全可以让一部分基站休眠，而让另一部分基站工作。另外，在基站密度较高的区域，此时，在不影响整个小区性能的前提下，通过关闭一部分基站的方法，可以有效降低整个小区的功耗。

    下面讨论在引入基站休眠算法之后，整个小区的功耗。

    假设在某一时刻，整个小区有k0个基站关闭，k-k0个基站在正常工作，那么整个小区的总的功耗为：

先对一个普通的能耗问题进行仿真，即如果检测到对应小区的用户数量为0，则基站自动进入休眠状态，如果出现用户，则基站开始工作。

第二，对比用户和宏基站距离以及和微微基站的距离；

第三，开关判决：

     如果均不在两种基站的有效覆盖范围之内，那么保持原来的状态，

    如果用户在邻近的宏基站的覆盖范围之内，那么当前用户和宏基站建立连接，而关闭对应的微微基站，如果用户在微微基站的覆盖范围之内，那么用户和微微基站建立连接，并关闭宏基站。

    如果用户同时在微微基站和宏基站的有效覆盖范围内，那么选择实际功耗小的基站进行连接，通常情况下，如果微微基站没有饱和，则用户直接和微微基站建立连接。

第四，功耗的计算，即计算处于工作状态的基站，然后计算对应每个基站的用户数量，然后计算总的功耗：

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

3.MATLAB核心程序

%基站坐标
%macrocell
XMBS   = [];
YMBS   = [];
 
%=============用户运动=====================================================
PX  = zeros(NU,TIME);
PY  = zeros(NU,TIME);
figure(1);
ind = 0;
for i=(-1*p):p 
    for j=(-1*q):q 
        %先确定macrocell的拓扑结构
        Xcen = i*1.5*R; 
        Ycen = (j+mod(i,2)/2)*sqrt(3)*R; 
        if sqrt(Xcen^2 + Ycen^2) <= 4*R   
           x = x0 + Xcen; 
           y = y0 + Ycen; 
           XMBS = [XMBS,Xcen];
           YMBS = [YMBS,Ycen];
           plot(x,y,'b');
           hold on;
           plot(Xcen,Ycen,'r*');
           hold on 
        end
    end 
end 
 
 
%然后产生picocell位置
NP    = 2;
XPBS0 = zeros(19,NP);
YPBS0 = zeros(19,NP);
XPBS  = zeros(19*NP,1);
YPBS  = zeros(19*NP,1);
II    = zeros(1,19);
for i=1:19 
    j=1;
    while j<=NP     
          %随机生成横坐标
          XPBS0(i,j) = (1000/sqrt(3)*rand()-500/sqrt(3))+XMBS(i);
          %随机生成纵坐标
          YPBS0(i,j) = (500*rand()-250)+YMBS(i);
          %算pico距离macro的距离
          distance  = sqrt((XPBS0(i,j)-XMBS(i))^2+(YPBS0(i,j)-YMBS(i))^2);
          h         = 1;
          judge     = 0;
          picodis   = 50;
          while h<=i
                l=1;
                while l<j
                      %遍历已经生成的pico，确认pico之间的距离
                      picodis=sqrt((XPBS0(i,j)-XPBS0(h,l))^2+(YPBS0(i,j)-YPBS0(h,l))^2);
                      if picodis<40%如果有距离小于40的，则不满足条件，跳出循环，重新生成pico              
                         judge=1;
                         break;
                      end;
                      l=l+1;
                end;
                if judge==1
                    break;
                end
                h=h+1;
          end;
          if abs(XPBS0(i,j)-XMBS(i)) + abs(YPBS0(i,j)-YMBS(i))/sqrt(3)<= 500/sqrt(3)&&distance>75&&picodis>40 
             j = j+1;
          end
    end 
    II(i)=i;
end
 
for i=1:19 
    for j = 1:NP
        plot(XPBS0(i,j),YPBS0(i,j),'b-s'); 
        hold on;
    end
end
%PICO坐标值的转换
XPBS = reshape(XPBS0,[19*NP,1]);
YPBS = reshape(YPBS0,[19*NP,1]);
 
axis equal; 
hold on;
plot(Xu,Yu,'m.');
hold on;
legend('小区边界','基站BS');
axis([-world-5,world+5,-world-5,world+5]); 
title('模拟场景（红色BS:ON，黑色BS:OFF）');
hold on;
 
 
 
 
 
 
 
 
%假设最匀速运动
for t = 1:TIME
    t
    for i = 1:NU
        if t == 1
           PX(i,t) = Xu(i);
           PY(i,t) = Yu(i);
        else
           V(i)    = 23*(0.5+randn);
           Theta(i)= pi*randn;%确定一个随机的运动方向 
           PX(i,t) = PX(i,t-1) + V(i)*cos(Theta(i));
           PY(i,t) = PY(i,t-1) + V(i)*sin(Theta(i));
        end
    end
end
 
 
%%
%=============智能节点休眠算法==============================================
%基站坐标
XMBS;
YMBS;
%用户移动路线的坐标变化情况
PX;
PY;
 
Power1 = zeros(1,TIME);
Power2 = zeros(1,TIME);
 
%各个小区的用户连接数
USERS1 = zeros(19,TIME);
USERS2 = zeros(19,TIME);
USERS1p= zeros(19*NP,TIME);
USERS2p= zeros(19*NP,TIME);
 
 
for times = 1:TIME
    disp(times);
    for j = 1:NU
        UX(j) = PX(j,times);
        UY(j) = PY(j,times);
    end
    
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    %PART I 计算基站全部正常工作的时候的网络的能耗
    %PART I 计算基站全部正常工作的时候的网络的能耗
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    %计算每个小区内对应的人数
    %用户所在小区的编号
    %先计算MICRO
    UE_BSid1 = zeros(1,NU);
    BS_UEn1  = zeros(1,19);
    Pow_bs1  = zeros(1,19);
    for j1 = 1:NU
        for j2 = 1:19
            dist(j2) = sqrt((UX(j1) - XMBS(j2))^2 + (UY(j1) - YMBS(j2))^2);
        end
        %计算最近的，即其对应的小区位置
        [V,I] = min(dist);
        UE_BSid1(j1) = I;
    end
 
    %再计算PICRO
    UE_BSid1p = zeros(1,NU);
    BS_UEn1p  = zeros(1,19*NP);
    Pow_bs1p  = zeros(1,19*NP);
    for j1 = 1:NU
        for j2 = 1:19*NP
            distP(j2) = sqrt((UX(j1) - XPBS(j2))^2 + (UY(j1) - YPBS(j2))^2);
        end
        %计算最近的，即其对应的小区位置
        [V,I] = min(distP);
        UE_BSid1p(j1) = I;
    end
    
    %根据每个用户和宏小区和微小区之间的距离，判断当然用户和虹小区建立连接，还是和微小区建立连接
    %统计每个用户，其连入情况
    %再计算PICRO
    UE_BSid1P2 = zeros(2,NU);
    for j = 1:NU
        Mind = UE_BSid1(j);
        Pind = UE_BSid1p(j);
        %判断该用户具体连接到哪个基站
        Mdist= sqrt((UX(j) - XMBS(Mind))^2 + (UY(j) - YMBS(Mind))^2);
        Pdist= sqrt((UX(j) - XPBS(Pind))^2 + (UY(j) - YPBS(Pind))^2);
        if Mdist >= 2*Pdist
           UE_BSid1P2(:,j) = [0,Pind];
        else
           UE_BSid1P2(:,j) = [1,Mind];  
        end
    end
    %根据实际情况，计算宏基站功率和微基站功率
    MM = find(UE_BSid1P2(1,:)==1);
    PP = find(UE_BSid1P2(1,:)==0);
    
    %统计每个小区的用户个数
    for j1 = 1:19
        e=find(UE_BSid1P2(2,MM)==j1);  
        BS_UEn1(j1) = length(e);
    end
    for j1 = 1:19
        if BS_UEn1(j1) <= SNU
           Pow_bs1(j1) = 137+57*BS_UEn1(j1)/SNU;
        else
           Pow_bs1(j1) = 137+57; 
        end
    end
    
    for j1 = 1:19*NP
        e=find(UE_BSid1P2(2,PP)==j1);  
        BS_UEn1p(j1) = length(e);
    end
    for j1 = 1:19*NP
        if BS_UEn1p(j1) <= SNUP
           Pow_bs1p(j1) = 12+8*BS_UEn1p(j1)/SNU;
        else
           Pow_bs1p(j1) = 12+8; 
        end
    end
    
    
    
 
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    %PART II 基站休眠算法 
    %PART II 基站休眠算法 
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%    
    %先计算MICRO
    UE_BSid2 = zeros(1,NU);
    BS_UEn2  = zeros(1,19);
    Pow_bs2  = zeros(1,19);
    for j1 = 1:NU
        for j2 = 1:19
            dist2(j2) = sqrt((UX(j1) - XMBS(j2))^2 + (UY(j1) - YMBS(j2))^2);
        end
        %计算最近的，即其对应的小区位置
        [V,I] = min(dist2);
        UE_BSid2(j1) = I;
    end
 
    %再计算PICRO
    UE_BSid2p = zeros(1,NU);
    BS_UEn2p  = zeros(1,19*NP);
    Pow_bs2p  = zeros(1,19*NP);
    for j1 = 1:NU
        for j2 = 1:19*NP
            distP(j2) = sqrt((UX(j1) - XPBS(j2))^2 + (UY(j1) - YPBS(j2))^2);
        end
        %计算最近的，即其对应的小区位置
        [V,I] = min(distP);
        UE_BSid2p(j1) = I;
    end
    
    %根据每个用户和宏小区和微小区之间的距离，判断当然用户和虹小区建立连接，还是和微小区建立连接
    %统计每个用户，其连入情况
    %再计算PICRO
    UE_BSid2P2 = zeros(2,NU);
    for j = 1:NU
        Mind2 = UE_BSid2(j);
        Pind2 = UE_BSid2p(j);
        %判断该用户具体连接到哪个基站
        Mdist2= sqrt((UX(j) - XMBS(Mind2))^2 + (UY(j) - YMBS(Mind2))^2);
        Pdist2= sqrt((UX(j) - XPBS(Pind2))^2 + (UY(j) - YPBS(Pind2))^2);
        if Mdist2 >= 2*Pdist2
           UE_BSid2P2(:,j) = [0,Pind2];
        else
           UE_BSid2P2(:,j) = [1,Mind2];  
        end
    end
    %根据实际情况，计算宏基站功率和微基站功率
    MM2 = find(UE_BSid2P2(1,:)==1);
    PP2 = find(UE_BSid2P2(1,:)==0);
    
    %统计每个小区的用户个数
    for j1 = 1:19
        e2=find(UE_BSid2P2(2,MM2)==j1);  
        BS_UEn2(j1) = length(e2);
    end
 
    [ON_OFF2m,Power2m] = func_sleep(SNU,BS_UEn2,19,NP);
 
    for j1 = 1:19*NP
        e2=find(UE_BSid2P2(2,PP)==j1);  
        BS_UEn2p(j1) = length(e2);
    end
    [ON_OFF2p,Power2p] = func_sleep(SNUP,BS_UEn2p,19*NP,NP);
    
 
    
    %记录能耗_全部打开的能耗
    Power1(times) = sum(Pow_bs1) + sum(Pow_bs1p);
    %普通休眠下的能耗
    Power2(times) = sum(Power2m) + sum(Power2p);
    
    USERS1(:,times)  = BS_UEn1;
    USERS1p(:,times) = BS_UEn1p;
    
    USERS2(:,times)  = BS_UEn2';
    USERS2p(:,times) = BS_UEn2p';
end
 
 
%%
%=============根据基站休眠算法的优化结果，动态的显示基站开关状态===============
%动态显示不同时期的开关状态和对应的能耗对比效果
figure;
plot(1:TIME,Power1,'b','linewidth',2);
hold on
plot(1:TIME,Power2,'g','linewidth',2);
xlabel('仿真时间');
ylabel('小区总功耗');
grid on
legend('未进行基站休眠的网络功耗','进行基站休眠的网络功耗');
 
 
 
 
%动画演示
figure;
for t = 1:TIME
    
    if mod(t,5)==1
    
       subplot(221);
       tmps1 = USERS1(:,t);
       stem(1:19,tmps1);
       title('没有sleep mode的情况下每一个小区连接用户的数目');
       axis([0,20,0,40]);
       
       subplot(222);
       tmps2 = USERS2(:,t);
       IND1  = find(tmps2==0);
       IND2  = find(tmps2>0);
       stem(IND2,tmps2(IND2),'b');
       hold on;
       stem(IND1,tmps2(IND1),'r');
       hold off;
       legend('基站打开','基站关闭');
       title('有sleep mode下各个小区连接用户的数目的动态图');
       axis([0,20,0,40]);
 
       subplot(2,2,[3,4]);
       plot(1:t,Power1(1:t),'b','linewidth',2);
       hold on
       plot(1:t,Power2(1:t),'r','linewidth',2);
       xlabel('仿真时间');
       ylabel('小区总功耗');
       grid on
       legend('未进行基站休眠的网络功耗','进行基站休眠的网络功耗');
       axis([1,TIME,2500,3800]);
    end
    pause(0.0005);
end
01_090_m