m基于自适应门限软切换的3G和Wifi垂直切换算法的matlab仿真

1.算法概述 这里还是考虑位置信息和强度联合切换判决的方法，如果你的设备没法提供具体的位置信息的话，那么就把位置信息的权值设置为0。强度判决的权值设置为1即可。

    需要传输的数据格式如下：

一个字节为8个bit，

因此，一个传输帧，基本格式为：

S | 16bit长度的节点需要 | 8bit长度的数据类型 | 64bit长度的数据内容 | #

其中“S”对应的ASCII码为01010011

“#”对应的ASCII码为0010 0011

这里，我们将数据帧结构的产生做如下的设置，

即每次发送一帧数据，然后每过N帧，发送一帧带有位置信号作为数据的帧数据。

目前的算法流程如下：

    第1，预先设置切换处理延迟时间t和能量强度门限值T；

    第2，分别对3G网络和WIFI网络的信号能量进行计算；

    第3，根据传输得到的数据帧中提取对应的位置信号；

    第4，判决：

    如果计算能量均小于T，那么不进行切换，保持原来的状态；

    如果其中一个超过门限值，一个没有超过没限制，那么切换到对应能量大的网络上；

    如果两个能量值均大于门限值，那么再做如下的判决：

   如果3G网络的信号强度大于WIFI网络的信号强度，系统首先接入到3G网络，然后在时间t之后，即完成3G的连接之后，断开与WIFI的连接，完成从WIFI到3G网络的切换。 

    同样道理，如果WIFI网络的信号强度大于3G网络的信号强度，系统首先接入到WIFI网络，然后在时间t之后，即完成WIFI的连接之后，断开与3G的连接，完成从3G到WIFI网络的切换。当3G网络和WIFI信号强度接近的时候，则维持在原先的网络进行数据的传输，并进行切换处理。由于信号能量强度会出现各种变化的情况，比如当3G信号强度突然大于WIFI的信号强度（假设网络的信号强度是不变，而外部的干扰发生突然改变），并持续一段时间，然后此时，设置距离3G网络更近些，因此当出现这种情况的时候，设备不应该发生突然的切换。

     根据这个问题，本算法加入了位置信号的判决：

2.仿真效果预览 MATLAB2022A仿真结果：

3.核心MATLAB预览

 
%产生信号
%S   |  16bit长度的节点需要   |  8bit长度的数据类型   |  64bit长度的数据内容   |  #
%其中“S”对应的ASCII码为: 01010011
%“#”对应的ASCII码为    : 0010 0011
X     = 0;
Y     = 0;
FRAME = [];
%切换处理延迟时间t
t     = 20;
%能量强度门限值T
T     = 8;
PER   = 10;%每10帧加入I个位置信息
 
 
for i = 1:N
    figure(1);
    plot(X3g,Y3g,'--rs','LineWidth',2,'MarkerEdgeColor','k','MarkerFaceColor','r','MarkerSize',10);
    text(X3g+2,Y3g+2,'3G Device');
    hold on
    plot(Xwf,Ywf,'--rs','LineWidth',2,'MarkerEdgeColor','k','MarkerFaceColor','g','MarkerSize',10);
    text(Xwf+2,Ywf+2,'WIFI Device');
    %S | 16bit长度的节点需要 | 8bit长度的数据类型 | 64bit长度的数据内容 | #
    %S
    S     = [0,1,0,1,0,0,1,1];
    %16bit长度的节点需要
    Index = func_dec2bin(i,16);
    %8bit长度的数据类型
    Type  = [0,0,1,1,0,0,1,1];
    %字节数
    Nums  = [0,0,0,0,1,1,1,1];
    
    %64bit长度的数据内容
    if mod(i,10) == 2
       i
       %模拟简单的运动 
       X    = X + (7 +   rand(1,1))/10;
       Y    = Y + (4 + 6*rand(1,1))/10;
       Xbin = func_dec2bin(X,32);
       Ybin = func_dec2bin(Y,32);
       Data = [Xbin,Ybin];
    else
       Data = (rand(1,64)>=0.5); 
    end
    %#
    J     = [0,0,1,0,0,0,1,1];
    %产生最后发送的帧格式数据
    tmps = [S,Index,Type,Nums,Data,J];
    FRAME= [FRAME,tmps];
    
    plot(X,Y,'--rs','LineWidth',2,'MarkerEdgeColor','k','MarkerFaceColor','y','MarkerSize',10);
    text(X+2,Y+2,'User Device');
    axis([0,120,0,120]);
    drawnow;
    hold off
end
 
X0 =[];
Y0 =[];
X  =[];
Y  =[];
%%
%开始切换算法
f1       = zeros(1,N);
f2       = zeros(1,N);
f        = zeros(1,N);
f0       = zeros(1,N);
CUT      = zeros(1,N);
lemda1   = 0.6;
lemda2   = 1 - lemda1;
%初始状态假设为3G网络
STATE    = zeros(1,N);%1：3G；2：WIFI
STATE(1) = 2;  
count    = 0;
for i = 1:N
    i
    %模拟环境影响损耗，用随机的方式产生
    EnvLoss3g = 15 + randn;
    EnvLosswf = 12 + 4*randn;
    %将接收到的数据保存到寄存器中
    Reg = FRAME(length(tmps)*(i-1)+1:length(tmps)*i);
    %检测S，来识别是否是帧的起始位
    for j = 1:length(Reg)
        if Reg(1) == S(1) && Reg(2) == S(2) && Reg(3) == S(3) && Reg(4) == S(4) &&...
           Reg(5) == S(5) && Reg(6) == S(6) && Reg(7) == S(7) && Reg(8) == S(8)     
           flag = 1;%说明检测到帧了
        else
           flag = 0;%说明没有检测到帧
        end
    end
    %如果检测帧头了，则开始位置信息的计算
    if i > 1
        if flag == 1
            %获得序列序号 
            INDEXbin = Reg(9:9+15);
            INDEXdec = func_bin2dec2(INDEXbin);
            if  mod(INDEXdec,10) == 2
                %转换为十进制
                X0 = Reg(33+8:33+31+8);
                Y0 = Reg(65+8:65+31+8);
                X  = func_bin2dec(X0);
                Y  = func_bin2dec(Y0);
            else
                %转换为十进制
                X0 = X0;
                Y0 = Y0;
                X  = func_bin2dec(X0);
                Y  = func_bin2dec(Y0);
            end
            
            %*****************************************************************************
            %计算3G距离
            L3g= sqrt((X - X3g)^2 + (Y - Y3g)^2);
            %计算WIFI距离
            Lwf= sqrt((X - Xwf)^2 + (Y - Ywf)^2);
            %距离切换
            if Lwf >= L3g & STATE(i-1) == 1
               f2(i) = 0;%3G -> WIFI 
            end
            if Lwf >= L3g & STATE(i-1) == 2
               f2(i) = 1;%WIFI -> WIFI 
            end       
            if Lwf < L3g  & STATE(i-1) == 1
               f2(i) = 1;%3G -> 3G 
            end
            if Lwf < L3g  & STATE(i-1) == 2
               f2(i) = 0;%WIFI -> 3G 
            end      
            %计算3G能量
            %计算当前位置3G信号能量的衰减，慢衰减
            %快衰减,这里暂时不考虑快衰减
            Loss3g = func_Power_Attenuation_3G(Fre_wf,Lwf,EnvLoss3g);
            %计算信号能量
            POWER_3G = Power_3g - Loss3g;
            
            %计算WIFI能量
            %计算当前位置WIFI信号能量的衰减，慢衰减
            %快衰减,这里暂时不考虑快衰减
            Losswf = func_Power_Attenuation_WIFI(Fre_3g,L3g,EnvLosswf);
            %计算信号能量
            POWER_WIFI = Power_wf - Losswf;
 
            %*****************************************************************************
            %切换判决
            %如果计算能量均小于T，那么不进行切换，保持原来的状态；
            if (POWER_3G < T & POWER_WIFI < T)
                f1(i) = 1;%3G->WIFI
            end   
            %如果其中一个超过门限值，一个没有超过没限制，那么切换到对应能量大的网络上；    
            if (POWER_3G < T & POWER_WIFI >= T) & STATE(i-1) == 2 
                f1(i) = 0;%WIFI->WIFI
            end 
            %如果其中一个超过门限值，一个没有超过没限制，那么切换到对应能量大的网络上；    
            if (POWER_3G < T & POWER_WIFI >= T) & STATE(i-1) == 1 
                f1(i) = 1;%3G->WIFI
            end                 
            %如果其中一个超过门限值，一个没有超过没限制，那么切换到对应能量大的网络上；    
            if (POWER_3G >= T & POWER_WIFI < T) & STATE(i-1) == 2 
                f1(i) = 1;%WIFI->3G
            end 
            %如果其中一个超过门限值，一个没有超过没限制，那么切换到对应能量大的网络上；    
            if (POWER_3G >= T & POWER_WIFI < T) & STATE(i-1) == 1 
                f1(i) = 0;%3G->3G
            end            
            %如果其中一个超过门限值，一个没有超过没限制，那么切换到对应能量大的网络上；    
            if (POWER_3G >= T & POWER_WIFI >= T) & (POWER_3G > POWER_WIFI) & STATE(i-1) == 1 
                f1(i) = 0;%3G->3G
            end                 
            %如果其中一个超过门限值，一个没有超过没限制，那么切换到对应能量大的网络上；    
            if (POWER_3G >= T & POWER_WIFI >= T) & (POWER_3G > POWER_WIFI) & STATE(i-1) == 2 
                f1(i) = 1;%WIFI->3G
            end               
            %如果其中一个超过门限值，一个没有超过没限制，那么切换到对应能量大的网络上；    
            if (POWER_3G >= T & POWER_WIFI >= T) & (POWER_3G <= POWER_WIFI) & STATE(i-1) == 1 
                f1(i) = 1;%3G->WIFI
            end                 
            %如果其中一个超过门限值，一个没有超过没限制，那么切换到对应能量大的网络上；    
            if (POWER_3G >= T & POWER_WIFI >= T) & (POWER_3G <= POWER_WIFI) & STATE(i-1) == 2 
                f1(i) = 0;%WIFI->WIFI
            end              
            %计算最后的切换值
            f(i) = lemda1*f1(i) + lemda2*f2(i);
            %引入软切换判决
            if i > t
               Check(i) = mean(f(i-t+1:i)); 
               Check2   = mean(Check(i-t+1:i)); 
               f0(i)    =(sign(Check2-0.3)+1)/2;
            else
               Check(i) = mean(f(1:i));  
               Check2   = mean(Check(1:i));
               f0(i)    =(sign(Check2-0.3)+1)/2;
            end
        else
            %如果没有检测当前的帧头信息，则保持原切换状态 
            f(i)  = f(i-1);  
            f0(i) = f(i);  
        end
        %计算累计切换次数
        if f0(i) ~= f0(i-1)
           count = count + 1;
        end
        Ttmps(i) = 0.5*max(POWER_3G,POWER_WIFI);
        if i > t
           T = mean(Ttmps(i-t+1:i)); 
        else
           T = mean(Ttmps(1:i));  
        end
    end
    %统计累积切换次数
    CUT(i) = count;
end
01_087_m