基于AODV和leach协议的自组网络平台matlab仿真,对比吞吐量,负荷,丢包率,剩余节点个数,节点消耗能量

1.算法仿真效果
matlab2017b仿真结果如下（完整代码运行后无水印）：

本程序系统是《m基于matlab的AODV,leach自组网网络平台仿真,对比吞吐量,端到端时延,丢包率,剩余节点个数,节点消耗能量》的的升级。

升级前原文章链接

增加了运动节点的路由测试，包括定向运动，随机运动，静止状态，修正了丢包率的统计方式。

动态节点时仿真效果如下：

2.算法涉及理论知识概要
AODV是一种应用于无线网状网络的路由协议。它源节点需要发送数据时才进行路由发现。当没有数据发送请求时并不执行。在路由发现过程中首先检查路由表中是否存在从源节点到目的节点的路由，若存在则直接进行数据转发，若不存在，则广播RREQ分组进行寻找并建立路由。当目的节点收到第一个RREQ分组时，立即回复RREP分组给源节点，当源节点收到RREP分组时，便沿着RREP的路径建立了一条到目的节点的路径，然后通过此路径进行数据的传送。当节点在转发分组失败的时候便广播一个RRER分组，以此来告知源节点路径断开，源节点收到RRER之后将要发送的数据存入缓存，并重新发起路由发现的过程，直到新的路由路径建立起来的时候，才将缓存中的数据依次发送给目的节点。

   AODV是一种按需路由协议，根据业务需求建立和维护路由，它是DSDV (Destination—SequencedDistance-Vector)协议和DSR(Dynamic Source Routing) 协议的结合，使用DSDV协议中的目的节点序列号来防止缓存的路由信息过期以及环路的产生，路由建立则是基于DSR协议中所采用的方法，不同点在于AODV采用的是逐跳路由而不是源路由，可以实现ZigBee节点之间动态的、自发的路由，使节点很快实现到目的节点的通信。ZigBee路由算法中使用的AODVjr算法是对AODV算法的精简和改进，但是仍然保持AODV的原始功能。其特点是路由路径最佳，缺点是单个节点需要路由表，整体路由代价高。       

   AODV路由协议主要可分为初始化、路由的建立及维护、显示、时钟、节点移动模块。总体设计框图所示：

     AODV是一种按需路由协议，根据业务需求建立和维护路由，它是DSDV协议和DSR协议的结合。使用DSDV协议中的目的节点序列号来防止缓存的路由信息过期以及环路的产生，路由建立则是基于DSR协议中所采用的方法，不同点在于AODV采用的是逐跳路由而不是源路由。  

    控制中心主要包括消息收发模块、用户列表（相关节点信息，用户名和IP）、参数设置模块和功能性模块。

 1.参数设置模块：可以实现节点个数、仿真场景大小、仿真时间、信道模型、路由协议、节点初始能量等的输入或者选择。

 2.功能性模块：显示拓扑结构图；计算网络平均吞吐量、平均端到端时延、丢包率、剩余节点个数、节点消耗能量等。

    参数设置模块，是通过GUI界面进行设置，主要实现可设置网络节点，仿真场景大小，仿真时间，信道模型的选择，路由协议的选择，节点初始能量的设置等参数变量，这些变量，我们均通过GUI界面进行参数的输入。功能模块，显示拓扑结构图；计算网络平均吞吐量、丢包率、剩余节点个数、节点消耗能量等。

   整个网络的工作机制如下：       

   通过设置N个网络节点，在设置好大小的场景中，进行随机坐标的分布，并设置整个网络的工作时间，即仿真时间，不同节点之间的信息传递，其信道模型根据设置，选择Free space和 Two-ray ground reflection两种类型的信道，网络工作的MAC协议为IEEE 802.11，而路由协议，则根据选择，设置Leach或者AODV，或AODV改进三种类型。然后，我们根据网络的实际仿真结果，实时的输出六个指标。

3.MATLAB核心程序```%3.网络运行模块
countCHs3 = 0;
cluster3 = 1;
flag_first_dead3 = 0;
flag_teenth_dead3 = 0;
flag_all_dead3 = 0;
%死亡节点数
dead3 = 0;
first_dead3 = 0;
teenth_dead3 = 0;
all_dead3 = 0;
%活动节点数
allive3 = n;
packets_TO_BS3 = 0;
packets_TO_CH3 = 0;

%%%%%%%%%%%%以上参数初始化三个程序都相同%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%以上参数初始化三个程序都相同%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

for r=0:1:rmax
r
Ea = Et;
El3(r+1) = 0;
for i=1:nodes_number
El3(r+1) = S3(i).E + El3(r+1);
end
Ec3(r+1) = Et-El3(r+1);

%死亡节点检查
Dead_time = 0;
for i=1:n
    %节点能量用完，则说明节点死亡
    if S3(i).E <= 0 
       Dead_time = Dead_time + 1; 
    else
       S3(i).type = 'N';
       Dead_time = Dead_time; 
    end
end

STATISTICS.DEAD3(r+1)  = Dead_time;

countCHs3 = 0;
cluster3  = 1;
for i = 1:n
    if Ea > 0 & S3(i).E > 0 & S3(i).G <= 0  
         if rand<= 0.2
            countCHs3             = countCHs3+1;
            packets_TO_BS3        = packets_TO_BS3+1;
            PACKETS_TO_BS3(r+1)   = packets_TO_BS3;
            S3(i).type            = 'C';
            C3(cluster3).xd       = S3(i).xd;
            C3(cluster3).yd       = S3(i).yd;
            if r > 1
               distance              = sqrt((S3(i).xd-(S3(n+1).xd) )^2 + (S3(i).yd-(S3(n+1).yd))^2 );
               Fs                    = LBF3t(r);
               Ps                    = Ec3(r);
               Gs                    = w1*distance+w2*Fs+w3*Ps;
            else
               distance              = sqrt((S3(i).xd-(S3(n+1).xd) )^2 + (S3(i).yd-(S3(n+1).yd))^2 ); 
               Gs                    = distance;
            end
            C3(cluster3).distance = Gs;
            C3(cluster3).id       = i;
            X3(cluster3)          = S3(i).xd;
            Y3(cluster3)          = S3(i).yd;
            cluster3              = cluster3+1;
            %计算簇头发送4000bit数据的能量消耗
            if Gs > do 
               S3(i).E = S3(i).E - ((ETX+EDA)*(PACK) + Emp*PACK*(distance*distance*distance*distance)); 
            end
            if Gs <= do 
               S3(i).E = S3(i).E - ((ETX+EDA)*(PACK) + Efs*PACK*(distance * distance)); 
            end
         end
    end
end
STATISTICS.COUNTCHS3(r+1) = countCHs3;

x3 = zeros(1,cluster3-1);
y3 = 0;
z3 = 0;
Drop_rate0 = zeros(1,n);

%产生不同的路由路径，用来进行综合分析
PATH = [];
Nums = 1:n;
nn   = n;
for js = 1:n/2
    tmps = randperm(nn);
    if js > 1
       I1 = find(tmps == tmps1);
       I2 = find(tmps == tmps2);
       tmps(I1)=0;
       tmps(I2)=0;
       tmps(find(tmps==0)) = [];
    end
    SS   = tmps(1);
    DD   = tmps(2);
    %根据原节点和目标节点进行路由跟新
    [path,hop] = aodv_path_discovery_new(n,nodes_link,SS,DD,Fload,PLest,BREAK);
    PATH     = [PATH,path];
    tmps1    = SS;
    tmps2    = DD;
end
for ind=1:length(PATH)
    i = PATH(ind);
    if S3(i).type=='N' && S3(i).E>0
       if cluster3-1 >= 1
          min_dis         = Inf;
          min_dis_cluster = 0;
          for c=1:cluster3-1
              if r > 1
                 distance              = sqrt((S3(i).xd-C3(c).xd)^2 + (S3(i).yd-C3(c).yd)^2);
                 Fs                    = LBF3t(r);
                 Ps                    = Ec3(r);
                 Gs                    = w1*distance+w2*Fs+w3*Ps;
              else
                 distance              = sqrt((S3(i).xd-C3(c).xd)^2 + (S3(i).yd-C3(c).yd)^2); 
                 Gs                    = distance;
              end
              temp = min(min_dis,Gs);
              if temp < min_dis
                 min_dis         = temp;
                 min_dis_cluster = c;
                 x3(c)           = x3(c)+1;
              end
          end
          %簇内节点能量消耗
          if Gs > do
             S3(i).E=S3(i).E- (ETX*(PACK) + Emp*PACK*( min_dis * min_dis * min_dis * min_dis)); 
          end
          if Gs <= do 
             S3(i).E=S3(i).E- (ETX*(PACK) + Efs*PACK*( min_dis * min_dis)); 
          end
          S3(C3(min_dis_cluster).id).E = S3(C3(min_dis_cluster).id).E- ( (ERX + EDA)*PACK ); 
          packets_TO_CH3               = packets_TO_CH3+1;
          S3(i).min_dis                = Gs;
          S3(i).min_dis_cluster        = min_dis_cluster;
       else
          y3      = y3+1;

          if r > 1
             distance              = sqrt( (S3(i).xd-S3(n+1).xd)^2 + (S3(i).yd-S3(n+1).yd)^2 );
             Fs                    = LBF3t(r);
             Ps                    = Ec3(r);
             Gs                    = w1*distance+w2*Fs+w3*Ps;
          else
             distance              = sqrt( (S3(i).xd-S3(n+1).xd)^2 + (S3(i).yd-S3(n+1).yd)^2 );
             Gs                    = distance;
          end
          min_dis = Gs;
          if min_dis > do 
             S3(i).E=S3(i).E- ( ETX*(PACK) + Emp*PACK*( min_dis * min_dis * min_dis * min_dis)); 
          end
          if min_dis <= do 
             S3(i).E=S3(i).E- ( ETX*(PACK) + Efs*PACK*( min_dis * min_dis)); 
          end
          if rand < 0.2
             packets_TO_BS3=packets_TO_BS3+1;
          end
       end
    end
   %计算丢包率
   if Channel_Sel == 1
      L = 38.5 + 20*log10(distance); 
   else
      R     = 1; 
      dd2   = distance;
      fai   = pi/3;
      dd    = distance;
      lemda = 150;
      ge1   = 1;
      ge2   = 1;
      dr    = 4;
      Cs    = pi/8;
      a     = 6370000*(1-0.04665*exp(0.005577))^(-1);
      D     = (1+2*d1*d2/a/dd2/tan(fai))^(-0.5); 
      Re    = D*R*exp(-0.6*dd*sin(fai)/lemda); 
      Gp    = 23;
      Aa    = 18;
      L     =-10*log10(ge1*ge2*(1+Re^2 - 2*Re*cos(2*pi*dr/lemda-Cs))) + Gp + Aa;
   end
   %统计丢包率  
   %当发生错误的时候，以一定的概率丢包
   if rand < 0.2
      Drop_rate0(i) = 0.5*erfc(sqrt(2*(SNRs+10^(-L/20))));  
   end
end

if countCHs3~=0
    %统计
   for c=1:cluster3-1
       z3=z3+x3(c);
   end
   LBF3(r+1)=z3/countCHs3;
else
   LBF3(r+1)=0;
end


STATISTICS.PACKETS_TO_CH3(r+1) = packets_TO_CH3;
STATISTICS.PACKETS_TO_BS3(r+1) = packets_TO_BS3;
if countCHs3~=0
   Drop_rate(r+1)  = mean(Drop_rate0);
else
   Drop_rate(r+1)  = 0; 
end
if r <= 128
   LBF3t(r+1)      = mean(LBF3(1:r));
   Drop_ratet(r+1) = mean(Drop_rate(1:r));
else
   LBF3t(r+1)      = mean(LBF3(r-127:r));
   Drop_ratet(r+1) = mean(Drop_rate(r-127:r));
end

end
0sj_003m

```