LEACH协议网络性能分析

1.问题描述：

1. 对传感器网内节点进行分簇，由簇头和汇聚节点（Sink节点）进行信息交换，使得网络在进行工作和数据传输时能够节省能量，延长网络生命周期。
2. 在簇内和簇间进行数据融合，整合网内数据。
3. 数据融合后进行数据压缩，首先采用聚类方法消除异常数据点，并把类似数据聚为一类。在每一类中进行差分压缩，差分压缩基础上再进行游程编码进一步提高压缩率。
4. 恶意节点可能导致传感器网工作异常从而影响能量消耗，因此进行安全机制设计。

        是与LEACH算法比较，网络从初始状态直到首个节点因能量耗尽而死亡的持续时间。是与LEACH算法比较，显示了随着时间的变化，一些节点开始死亡，整个网络的可用率下降的趋势情况。实验的终止条件为当网络可用节点下降至 75%时。（随着时间的变化，网内存活节点的比率）是与LEACH算法比较，随时间变化时网络所有节点能量消耗情况。
 

2.部分程序：

 

clc;
clear;
close all;
warning off;
rng(1);

%仿真环境
SCALE = 100; 
%初始参数设定模块
xm    = SCALE;
ym    = SCALE;
%汇聚节坐标给定
sink.x= 2*xm;
sink.y= 1*ym;
%区域内传器节数
Node  = 200;
%簇头优化比例
P     = 0.05;
%初始化能量模型
E0    = 2;
%Eelec=Etx=Erx
Eelec = 50e-9;
ETX   = Eelec;
ERX   = Eelec;
Efs   = 10e-12;    %自由空间信道模型下功率放大所需能量
Emp   = 0.0013e-12;%多径衰减信道模型下功率放大所需能量
%Data Aggregation Energy
EDA   = 5e-9;
%高能量节点超出一节点能量的百分比
Emax  = 1;
%最大循环次数
Imax  = 500;
%算出参数 do
do    = sqrt(Efs/Emp);
Et    = 0;
%发送数据包长度
Byte  = 160000;

%无线传感器网络模型产生模块
for i=1:Node
    Snode(i).xd   = rand*xm;
    Snode(i).yd   = rand*ym;   
    Srx(i)        = Snode(i).xd;
    Sry(i)        = Snode(i).yd;
    Snode(i).G    = 0;
    Snode(i).E    = E0*(1+rand*Emax);
    Energy(i)     = Snode(i).E;
    Et            = Et+Energy(i);
    Snode(i).type ='N';
end

d1               = 0.76*xm/2;
K                = sqrt(Node*do/pi/2)*xm/d1^2;
d2               = xm/sqrt(2*pi*K);
Er               = Byte*(2*Node*ETX+Node*EDA+K*Emp*d1^4+Node*Efs*d2^2);
Snode(Node+1).xd = sink.x;
Snode(Node+1).yd = sink.y;

%网络运行
CH_num        = 0;
Cluster       = 1;
Flag_dead1st  = 0;
Flag_dead10st = 0;
Flag_deadall  = 0;

%死亡节点数
dead          = 0;
dead1st       = 0;
dead10st      = 0;
deadall       = 0;
%活动节点数
all_live      = Node;
bs_packet     = 0;
ch_packet     = 0;

%循环模式设定
for ij=0:Imax
    ij
    if mod(ij,round(1/P)) == 0
       for i=1:Node
           Snode(i).G  = 0;
           Snode(i).CL = 0;
       end
    end
    Ea        = Et*(1-ij/Imax)/Node;
    Egl(ij+1) = 0;
    for i = 1:100
        Egl(ij+1) = Snode(i).E + Egl(ij+1);
    end
    Egc(ij+1) = Et-Egl(ij+1);
    %死亡节点检查模块
    dead = 0;
    for i=1:Node
        %检查有无死亡节点
        if Snode(i).E <= 0
           dead = dead+1; 
           %第一个死亡节点的产生时间
           if dead==1
              if Flag_dead1st == 0
                 dead1st      = ij;
                 Flag_dead1st = 1;
              end
           end
           %25%的节点死亡时间
           if dead==0.25*Node
              if Flag_dead10st==0
                 dead10st      = ij;
                 Flag_dead10st = 1;
              end
           end
           %100%的节点死亡时间
           if dead==Node
              if Flag_deadall==0
                 deadall      = ij;
                 Flag_deadall = 1;
              end
           end
        end
        if Snode(i).E > 0
           Snode(i).type='N';
        end
    end
    STATISTICS.DEAD(ij+1)  = dead;
    STATISTICS.ALLIVE(ij+1)= all_live-dead;
    
    %簇头选举模块
    CH_num  = 0;
    Cluster = 1;
    
    for i=1:Node
        if Ea > 0
           p(i) = P*Node*Snode(i).E*Energy(i)/(Et*Ea);
           if Snode(i).E > 0 
              temp_rand = rand;     
              if Snode(i).G <= 0
                 %簇头的选举，当选的簇头会把各种相关信存入下面程序所给定的变量中
                 if temp_rand<= (p(i)/(1-p(i)*mod(ij,round(1/p(i)))))
                    CH_num              = CH_num+1;
                    bs_packet           = bs_packet+1;
                    PACKETS_TO_BS(ij+1) = bs_packet;
                    Snode(i).type       = 'C';
                    Snode(i).G          = round(1/p(i))-1;
                    C(Cluster).xd       = Snode(i).xd;
                    C(Cluster).yd       = Snode(i).yd;
                    dist                = sqrt((Snode(i).xd-(Snode(Node+1).xd))^2 + (Snode(i).yd-(Snode(Node+1).yd))^2);
                    C(Cluster).dist     = dist;
                    C(Cluster).id       = i;
                    X(Cluster)          = Snode(i).xd;
                    Y(Cluster)          = Snode(i).yd;
                    Cluster             = Cluster+1;
                    %计算簇头发送4000bit数据到基站的能量消耗（这里应是所有节点包括簇头每一轮发送4000bit数据）
                    if dist > do
                       Snode(i).E = Snode(i).E- ((ETX+EDA)*Byte + Emp*Byte*(dist*dist*dist*dist)); 
                    end
                    if dist <= do
                       Snode(i).E = Snode(i).E- ((ETX+EDA)*Byte + Efs*Byte*(dist * dist)); 
                    end
                 end
              end
           end
        end
    end
    STATISTICS.COUNTCHS(ij+1) = CH_num;
    %簇内成员选择簇头模块(即簇的形成模块)
    for c=1:1:Cluster-1
        xr(c)=0;
    end
    yr = 0;
    zr = 0;
    for i=1:1:Node
        if Snode(i).type=='N' && Snode(i).E>0
           if Cluster-1>=1 
              min_dis         = Inf;
              min_dis_cluster = 0;
              for c=1:Cluster-1
                  temp = min(min_dis,sqrt((Snode(i).xd-C(c).xd)^2 + (Snode(i).yd-C(c).yd)^2 ));
                  if temp<min_dis
                     min_dis         = temp;
                     min_dis_cluster = c;
                     xr(c)           = xr(c)+1;
                  end
              end
              %簇内节点（发送4000bit数据）能量消耗
              if min_dis > do
                 Snode(i).E=Snode(i).E - (ETX*(Byte) + Emp*Byte*(min_dis * min_dis * min_dis * min_dis)); 
              end
              if min_dis <= do
                 Snode(i).E=Snode(i).E -  ETX*(Byte) + Efs*Byte*( min_dis * min_dis); 
              end
              %簇头的能量消耗
              Snode(C(min_dis_cluster).id).E = Snode(C(min_dis_cluster).id).E- ( (ERX + EDA)*Byte ); 
              ch_packet                      = ch_packet+1;
              Snode(i).min_dis               = min_dis;
              Snode(i).min_dis_cluster       = min_dis_cluster;
           else
              yr      = yr+1;
              min_dis = sqrt((Snode(i).xd-Snode(Node+1).xd)^2 + (Snode(i).yd-Snode(Node+1).yd)^2);
              if min_dis>do
                 Snode(i).E=Snode(i).E-(ETX*(Byte) + Emp*Byte*( min_dis * min_dis * min_dis * min_dis)); 
              end
              if min_dis<=do
                 Snode(i).E=Snode(i).E-(ETX*(Byte) + Efs*Byte*( min_dis * min_dis)); 
              end
              bs_packet=bs_packet+1;
           end
        end
    end
end
LIVEs = Node - STATISTICS.DEAD;
ind1  = find(abs(LIVEs - 199)<5);%一个死亡节点
ind2  = find(abs(LIVEs - 150)<5);%存活75%节点
T1    = ind1(1);
T2    = ind2(1);

figure
plot(LIVEs,'b');
hold on
plot(T1*ones(1,200),0:199,'r');
hold on
plot(1:T1,199*ones(size([1:T1])),'r');
hold on
plot(T2*ones(1,151),0:150,'r');
hold on
plot(1:T2,150*ones(size([1:T2])),'r');
hold on
xlabel('x(time)');
ylabel('y(live)');
title('首个节点因能量耗尽而死亡的持续时间');
axis([0,500,0,220]);
text(T1,199,['1个死亡节点']);
text(T2,150,['25%死亡节点']);

figure
plot(Egc,'b');
xlabel('x(time)');
ylabel('y(consumption)');
title('LEACH的网络能量消耗对比');
axis([0,500,0,800]);
save R1.mat Egc LIVEs T1 T2

 

3.仿真结论：

A12-31