HEED: A Hybrid, Energy-Efficient, Distributed Clustering Approach for Ad Hoc Sensor Networks

心️升明月

已于 2022-04-01 15:28:25 修改

阅读量2.1k

点赞数 7

分类专栏： matlab 无线传感器网络文章标签： matlab HEED

于 2021-01-07 17:54:23 首次发布

本文链接：https://blog.csdn.net/weixin_43821559/article/details/112324691

版权

matlab 同时被 2 个专栏收录

332 篇文章 339 订阅

订阅专栏

无线传感器网络

50 篇文章 79 订阅

订阅专栏

本文详细介绍了HEED分簇算法的理论基础，包括其在大规模传感器网络中的应用，以及如何利用主次参数选择簇头。算法通过初始化、迭代等步骤实现分簇，并提供了MATLAB程序实现过程，展示了节点的随机分布和分簇结果。

摘要由CSDN通过智能技术生成

一、理论基础

针对大规模分布式的传感器网络，节点通过一跳直接与基站通信是不现实的，为此，Younis(2004)等人提出了一种使用固定簇半径的分簇协议HEED(A Hybrid，Energy-Efficient Distributed clustering approach)。
作为衡量簇内通信代价的标准，HEED规定簇头的选择主要依据主、次两个参数。其中主参数依赖于剩余能量，具有较高剩余能量的节点将具有较高的概率成为临时簇头，并且其算法收敛的速度也较快；次要参数如节点邻近度或者节点密度。处于相同簇覆盖范围的多个簇头节点则通过次参数平均可达能级 $A M R P$ 来竞争出最终的簇头。对于处于多个簇覆盖范围内的成员节点则根据次参数AMRP来选择最终的簇加入。Younis(2004)给出了AMRP的计算方式，一个簇的平均可达能量可以用公式 $AMRP=\frac{\sum MIN{(p_j)}}{M}$ 计算。其中 $M$ 为该节点的所有邻居节点数， $MIN{(p_j)}$ 为第i个节点能够与簇头通信的射频最小的功率。由于假设传感器节点的发射功率是可以调节的，因此公式如下很好地评估了一个簇的簇内通信代价。

二、分簇过程

HEED分簇算法包括以下几个步骤：
（1）初始化阶段：每个节点计算其包括计算邻居节点的个数，以及自身的 $A M R P$ 的值，并且设定初始成为簇头节点的概率。
（2）迭代阶段：每个节点在每轮的循环中如果发现自身周围有临时簇头节点则进行相应的判断：如果自身也是临时簇头(tentative cluster head)，并且自身的 $A M R P$ 的值最小，且此时自己的 $CH_{prob}=1$ ，则宣布自身为最终簇头，否则进行下一轮分簇；如果邻居节点中没有节点宣布自己为临时簇头，则自身按照一定的概率成为临时簇头。
备选簇头状态： 当节点簇头概率小于1时，节点为备选簇头状态，若之后发现具有通信代价更小的簇头节点，则其改变状态为普通节点，加入该候选簇头。
最终簇头状态： 当节点簇头概率等于1时，节点作为最终簇头状态，并向其邻居节点广播。
（3）在迭代结束后，如果临时簇头的邻居中没有其他的临时簇头或者他们的 $A M R P$ 都比自身小，则该临时簇头宣布自身为最终的簇头(final cluster head)，其他节点周围若没有发现最终的簇头节点也宣布自身为最终的簇头节点。否则加入 $A M R P$ 值最小的临时簇头。

三、MATLAB程序实现

%% 清空环境变量
clear;
clc;
% 传感器节点区域100×100
xm = 100;
ym = 100;
% 基站坐标
sink.x = 0.5*xm;
sink.y = 0.5*ym;
% 节点总数100
NodeNums = 100;
% 节点成为簇头的初始概率和概率阈值
Cprob = 0.05;
pmin = 0.04;
packetLength = 4000;      % 数据包长度
ctrPacketLength = 100;    % 控制包长度
% 初始能量(最大能量) 0.3J
Eo = 0.3;
% 发送能耗RTX = 接收能耗ERX = 50nJ/bit
ETX=50*10^(-9);
ERX=50*10^(-9);
% 发射放大器类型
Efs=10*10^(-12);
Emp=0.0013*10^(-12);
% 数据聚合能量
EDA=5*10^(-9);
% 最大轮数
rmax = 5;
% the time of round
Tr=20;
distanceBroad = sqrt(Tr^2+Tr^2);
% 临界距离
do = sqrt(Efs/Emp);
% 节点类型
NON_CH = 0;         % 普通节点
TENT_CH = 1;        % 临时簇头
FINAL_CH = 2;       % 最终簇头

figure(1);
%% 传感器节点的随机分布
for i = 1:NodeNums
    Node(i).xd = rand(1,1)*xm;
    Node(i).yd = rand(1,1)*ym;
    Node(i).RE = Eo;                  % 节点能量
    Node(i).NumNbr = 0;               % 邻居节点数
    Node(i).AMRP = Node(i).NumNbr;    % 平均可达能级
    Node(i).CH = 0;                   % 簇头
    Node(i).role = NON_CH;            % 节点角色
    plot(Node(i).xd, Node(i).yd, 'o', sink.x, sink.y, '*r');
    hold on;
    title 'Wireless Sensor Network';
    xlabel 'X-coordinates';
    ylabel 'Y-coordinates';
    legend('节点', '基站');
end
hold off;
%% 计算每个节点的邻居节点集
for i = 1:NodeNums
    count = 0;  % 计数器：用于统计每个节点的邻居节点总数
    for j = 1:NodeNums
        if j ~= i
            dist = sqrt((Node(i).xd-Node(j).xd).^2 + (Node(i).yd-Node(j).yd).^2);   % 节点i与节点j距离的平方
            if dist < distanceBroad  % 如果此距离小于广播半径，则可认为j是i的邻居节点
                count = count +1;
                Node(i).Nbr(count) = j; % j是i的一个邻居节点
            end
        end
        if j == NodeNums % 说明循环到了最后一个节点
            Node(i).NumNbr = count;     % 节点i的邻居节点个数count
        end
    end
end

%% 分簇阶段
for r = 1:rmax
%     % 死亡节点总数
%     dead = 0;
%     % 计算节点死亡数目
%     for i = 1:NodeNums
%         if Node(i).RE <= 0  % 统计节点死亡数目
%             dead = dead + 1;
%         end
%     end
%     if dead == NodeNums  % 节点全部死亡退出循环
%         break;
%     end
    s = 0;
    % 第一步：初始化
    for i = 1:NodeNums
        Node(i).RE = Eo;
        Node(i).CHprob = max(Cprob*(Node(i).RE/Eo), pmin);
        Node(i).AMRP = Node(i).NumNbr;    % 平均可达能级
        Node(i).CH = 0;
        Node(i).role = NON_CH;                     % 节点角色
        Node(i).stop = 1;
        s = s + Node(i).stop;
    end
    % 第二步：迭代，直至节点概率为1或节点死亡(能量耗尽)
    while s ~= 0
        s = 0;
        for i = 1:NodeNums
            Node(i).CHprob = max(Cprob*(Node(i).RE/Eo), pmin);
        end
        for i = 1:NodeNums
            if Node(i).RE > 0 && Node(i).CHprob <= 1
                flag0 = 0;
                flag1 = 0;
                for j = 1:Node(i).NumNbr
                    neighbor = Node(i).Nbr(j);
                    if Node(neighbor).role == TENT_CH
                        flag0 = 1;
                        if Node(i).AMRP > Node(neighbor).AMRP
                            flag1 = 1;
                        end
                    end
                end
                % 自身是临时簇头
                if Node(i).role == TENT_CH
                    if flag0 == 1 && flag1 == 0  % 周围有临时簇头且自身的AMRP值最小
                        if Node(i).CHprob == 1      % 概率为1
                            Node(i).CH = -1;
                            Node(i).RE = Node(i).RE-(ETX*ctrPacketLength+Efs*ctrPacketLength*distanceBroad^2);
                            % 邻居节点接收消息
                            for j = 1:Node(i).NumNbr
                                neighbor = Node(i).Nbr(j);
                                Node(neighbor).RE = Node(neighbor).RE-ERX*ctrPacketLength;
                            end
                        end
                    end
                end
                % 邻居节点无临时簇头
                if flag0 == 0
                    if rand <= Node(i).CHprob
                        Node(i).role = TENT_CH;
                        Node(i).RE = Node(i).RE-(ETX*ctrPacketLength+Efs*ctrPacketLength*distanceBroad^2);
                        % 邻居节点接收消息
                        for j = 1:Node(i).NumNbr
                            neighbor = Node(i).Nbr(j);
                            Node(neighbor).RE = Node(neighbor).RE-ERX*ctrPacketLength;
                        end
                    end
                end
                % 备选簇头状态
                if Node(i).CHprob < 1
                    Node(i).role = TENT_CH;
                    Node(i).RE = Node(i).RE-(ETX*ctrPacketLength+Efs*ctrPacketLength*distanceBroad^2);
                    x = Node(i).AMRP;
                    for j = 1:Node(i).NumNbr
                        neighbor = Node(i).Nbr(j);
                        Node(neighbor).RE = Node(neighbor).RE-ERX*ctrPacketLength;
                        if Node(neighbor).role ~= NON_CH    % 簇头节点
                            if Node(i).AMRP > Node(neighbor).AMRP   % AMRP值更小
                                Node(i).role = NON_CH;      % 改为普通节点
                                Node(i).CH = neighbor;       % 加入该候选簇头
                                Node(i).AMRP = Node(neighbor).AMRP;
                            end
                        end
                    end
                    Node(i).AMRP = x;
                else    % 最终簇头状态
                    Node(i).role = FINAL_CH;
                    Node(i).CH = -1;
                    Node(i).RE = Node(i).RE-(ETX*ctrPacketLength+Efs*ctrPacketLength*distanceBroad^2);
                    for j = 1:Node(i).NumNbr
                        neighbor = Node(i).Nbr(j);
                        Node(neighbor).RE = Node(neighbor).RE-ERX*ctrPacketLength;
                    end
                end
            else
                Node(i).stop = 0;
            end
            s = s+Node(i).stop;
            Node(i).CHprob = min(Node(i).CHprob * 2, 1);
        end
    end
    %% 第三，处理孤儿节点
    for i = 1:NodeNums
        if Node(i).RE > 0
            if Node(i).role ~= FINAL_CH
                flag = 0;
                for j = 1:Node(i).NumNbr
                    neighbor = Node(i).Nbr(j);
                    if Node(neighbor).role ~= NON_CH    % 簇头节点
                        flag = 1;
                        y = Node(i).AMRP;
                        if Node(i).AMRP > Node(neighbor).AMRP   % AMRP值更小
                            Node(i).role = NON_CH;      % 改为普通节点
                            Node(i).CH = neighbor;       % 加入该候选簇头
                            Node(i).AMRP = Node(neighbor).AMRP;
                        end
                    end
                end
                if flag == 0
                    Node(i).CH = -1;
                    Node(i).role = FINAL_CH;
                else
                    Node(i).AMRP = y;
                end
            end
        end
    end
    figure(r+1)
    %% 画出分簇图
    for i = 1:NodeNums
        if Node(i).role ~= NON_CH
            plot(Node(i).xd, Node(i).yd, '*'); % 簇头节点以*标记
            hold on
            text(Node(i).xd, Node(i).yd, num2str(i));
        else
            plot(Node(i).xd, Node(i).yd, 'o');   %普通节点以o标记
            text(Node(i).xd, Node(i).yd, num2str(i));
            hold on
            plot([Node(Node(i).CH).xd; Node(i).xd], [Node(Node(i).CH).yd; Node(i).yd]);  % 将节点与簇头连起来，即加入簇头集合
            hold on
        end
    end
end

其中一个分簇如图所示：
在这里插入图片描述

HEED分簇图

四、参考文献

[1] O. Younis, S. Fahmy. HEED: A Hybrid, Energy-Efficient, Distributed Clustering Approach for Ad Hoc Sensor Networks[J]. IEEE Transactions on Mobile Computing, 2004, 3(4): 366-379.

心️升明月

关注

7
点赞
踩
32

收藏

觉得还不错? 一键收藏
打赏
11
评论
HEED: A Hybrid, Energy-Efficient, Distributed Clustering Approach for Ad Hoc Sensor Networks

文章目录一、理论基础一、理论基础针对大规模分布式的传感器网络，节点通过一跳直接与基站通信是不现实的，为此，Younis(2O04)等人提出了一种使用固定簇半径的分簇协议HEED(A Hybrid，Energy-Efficient Distributed clustering approach)。...
复制链接

扫一扫