能量均衡的无线传感器网络非均匀分簇路由协议

Posted 博主QQ2449341593

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了能量均衡的无线传感器网络非均匀分簇路由协议相关的知识,希望对你有一定的参考价值。

文章目录

 

一、簇的形成

在这里插入图片描述

图2 传感器节点非均匀分簇例子

 

二、仿真分析

MATLAB程序实现DEBUC分簇

网络环境与参数见表2。
在这里插入图片描述

表2 网络环境与参数

 

本次实验仿真10轮,其中4轮的分簇结果如图3~6所示。代码如下:

close all;
clear;
clc;
% Network coverage (0,0)~(400,400)m
xm = 400;
ym = 400;
% Base station location (200,450)m
BS.x = 200;
BS.y = 450;
% Node number 1600
NodeNums = 1600;
% Initial energy 0.3J
Eo = 0.3;
% Data packet size 4000bits
packetLength = 4000;
% Data packet header 100bits
ctrPacketLength = 100;
% Energy dissipation parameter
% Eelec=50nJ/bit
% Efs=10pJ/bit/m^2,Emp=0.0013pJ/bit/m^4
% ED=5nJ/bit,dcrossover=87m
Eelec = 50*10^(-9);
Efs=10*10^(-12);
Emp=0.0013*10^(-12);
ED=5*10^(-9);
dcrossover = 87;
% 参数
T = 0.2;            % 簇头比例
Rcomp = 90;         % 预先定义的最大竞争半径
c = 0.5;            % 0~1的常数
alpha = 0.3;
beta = 0.3;
gamma = 0.4;
delta = 0.4;        % alpha+beta+gamma = 1
do = 246;           % 簇头至基站距离临界值
% 节点距基站的最大和最小距离
dmax = 0;
dmin = 9999;
% 最大轮数
rmax = 10;
% 簇头选择所需时间(s)
TCH = 60;

%% 节点随机分布
figure(1);
for i = 1:NodeNums
    Node(i).x = rand(1,1)*xm;
    Node(i).y = rand(1,1)*ym;
    Node(i).beVolunteerNode = false;    % 候选簇头标志
    Node(i).RE = Eo;                    % 节点剩余能量
    Node(i).flag_final_send = false;    % 最终簇头发送消息标志
    Node(i).flag_final_receive = false; % 接收最终簇头的消息标志
    Node(i).flag_t = false;             % 等待时间的标志
    Node(i).flag_send_BS = false;
    Node(i).flag_send_CH = false;
    Node(i).CH = 0;             % 0 非簇头 -1 自己是最终簇头
    Node(i).ENT = 0;            % 邻居节点的平均剩余能量
    Node(i).List_v_CH = zeros(1, NodeNums);  % 候选簇头邻居节点信息表
    Node(i).List_v_CH_num = 0;               % 候选簇头邻居节点个数
    Node(i).List_n_CH = zeros(1,NodeNums);   % 邻居簇头信息表
    Node(i).List_n_CH_num = 0;               % 邻居簇头个数
    Node(i).member_num = 0;                  % 簇头i的邻居簇头成员节点数
    Node(i).link = i;                        % 中继节点
    % 计算节点和基站的最大和最小距离
    dcurrent = sqrt((Node(i).x-BS.x)^2+(Node(i).y-BS.y)^2);
    if dmax < dcurrent
        dmax = dcurrent;
    end
    if dmin > dcurrent
        dmin = dcurrent;
    end
    hold on;
    plot(Node(i).x, Node(i).y, 'o', BS.x, BS.y,'*r');
    title 'Wireless Sensor Network';
    xlabel 'X-coordinates';
    ylabel 'Y-coordinates';
end

%% 计算节点的竞争半径
for i = 1:NodeNums
    dcurrent = sqrt((Node(i).x-BS.x)^2+(Node(i).y-BS.y)^2);
    Node(i).Rcomp = (1-c*(dmax-dcurrent)/(dmax-dmin))*Rcomp;
end

per_round_CH_num = zeros(1, rmax);
%% 簇头选择
for r = 1:rmax
    alive = 0;
    for i = 1:NodeNums
        if Node(i).RE > 0
            alive = alive + 1;
        end
    end
    ALIVE(r) = alive;
    %% 初始化节点参数
    for i = 1:NodeNums
        Node(i).beVolunteerNode = false;        % 候选簇头标志
        Node(i).flag_final_send = false;        % 最终簇头发送消息标志
        Node(i).flag_final_receive = false;     % 接收邻居节点是最终簇头发来的消息标志
        Node(i).flag_t = false;                 % 等待时间的标志
        Node(i).flag_send_BS = false;
        Node(i).flag_send_CH = false;
        Node(i).cost = zeros(1, NodeNums);      % 节点的代价值
        Node(i).CH = 0;             % 0 非簇头 -1 自己是最终簇头
        Node(i).ENT = 0;            % 邻居节点的平均剩余能量
        Node(i).List_v_CH = zeros(1, NodeNums); % 候选簇头邻居节点信息表
        Node(i).List_v_CH_num = 0;              % 候选簇头邻居节点个数
        Node(i).List_n_CH = zeros(1,NodeNums);  % 邻居簇头信息表
        Node(i).List_n_CH_num = 0;              % 邻居簇头个数
        Node(i).member_num = 0;                 % 簇头i的邻居簇头成员节点数
        Node(i).link = i;                       % 中继节点
    end
    %% 候选簇头的选取
    for i = 1:NodeNums
        u = rand;
        if u < T % && Node(i).RE > 0 && Node(i).CH == 0
            Node(i).beVolunteerNode = true;     % 被选为候选簇头
        end
        % 是候选簇头
        if Node(i).beVolunteerNode == true
            % 广播自己竞选簇头的消息
            if Rcomp < dcrossover
                Node(i).RE = Node(i).RE - (Eelec*ctrPacketLength+Efs*ctrPacketLength*Rcomp^2);
            else
                Node(i).RE = Node(i).RE - (Eelec*ctrPacketLength+Emp*ctrPacketLength*Rcomp^4);
            end
            if Node(i).RE <= 0
                Node(i).RE = 0;
                Node(i).beVolunteerNode = false;
            end
        end
    end
    %% 计算每轮候选簇头邻居节点集
    for i = 1:NodeNums
        count = 0;
        if Node(i).beVolunteerNode == true
            % 通过竞争半径来计算节点的邻居节点集
            for j = 1:NodeNums
                dist = sqrt((Node(i).x-Node(j).x)^2+(Node(i).y-Node(j).y)^2);
                % 如果候选簇头i接收到了来自候选簇头j发来的竞选簇头的消息
                % 也就是说,节点j是候选簇头,且节点i处于节点j的广播范围内
                if j ~= i && Node(j).beVolunteerNode == true && dist <= Rcomp
                    % i接收到了j发来的竞争簇头消息
                    Node(i).RE = Node(i).RE - Eelec*ctrPacketLength;
                    if Node(i).RE <= 0
                        Node(i).RE = 0;
                        Node(i).beVolunteerNode = false;
                    else
                        if dist < max(Node(i).Rcomp, Node(j).Rcomp)
                            % 把节点j加入到候选簇头节点i的邻居节点信息表中
                            count = count + 1;
                            Node(i).List_v_CH(count) = j;
                        end
                    end
                end
                if j == NodeNums
                    Node(i).List_v_CH_num = count;
                end
            end
        end
        % 计算候选簇头的等待时间
        if Node(i).beVolunteerNode == true
            % 计算邻居节点的平均剩余能量
            aver_energy = 0;
            for j = 1:Node(i).List_v_CH_num
                aver_energy = aver_energy + Node(Node(i).List_v_CH(j)).RE;
            end
            if Node(i).List_v_CH_num == 0
                Node(i).ENT = 0;
            else
                Node(i).ENT = aver_energy/Node(i).List_v_CH_num;
            end
            % 计时
            if Node(i).RE >= Node(i).ENT
                k = 0.1*(rand + 9);                                         % k是(0.9,1)之间的随机数
                Node(i).t = k*TCH*Node(i).ENT/Node(i).RE;  % 计算节点i的等待时间
            else
                % 节点i放弃竞争簇头
                Node(i).beVolunteerNode = false;
            end
        end
    end
    %% 计时广播竞争簇头
    for t = 1:TCH
        % 等待时间-1
        for i = 1:NodeNums
            if Node(i).beVolunteerNode == true
                if Node(i).t > 0
                    Node(i).t = Node(i).t - 1;
                end
            end
        end
        % 处理
        for i = 1:NodeNums
            if Node(i).beVolunteerNode == true
                % 未到达等待时间
                if Node(i).t > 0
                    % 收到了来自邻居节点发来的最终簇头消息
                    if Node(i).flag_final_receive == true
                        Node(i).beVolunteerNode = false;   % 放弃竞争簇头
                        Node(i).t = 9999;                              % 停止计时
                    end
                else
                    % 到达等待时间,选为最终簇头
                    if Node(i).t <= 0 && Node(i).flag_t == false   % && Node(i).flag_final_receive == false
                        Node(i).CH = -1;        % 选为最终簇头
                        per_round_CH_num(r) = per_round_CH_num(r)+1;
                        % 广播最终消息
                        if Rcomp < dcrossover
                            Node(i).RE = Node(i).RE - (Eelec*ctrPacketLength+Efs*ctrPacketLength*Rcomp^2);
                        else
                            Node(i).RE = Node(i).RE - (Eelec*ctrPacketLength+Emp*ctrPacketLength*Rcomp^4);
                        end
                        if Node(i).RE <= 0
                            Node(i).RE = 0;
                            Node(i).beVolunteerNode = false;
                        else
                            Node(i).flag_t = true;
                            Node(i).flag_final_send = true;
                            for j = 1:NodeNums
                                dist = sqrt((Node(i).x-Node(j).x)^2+(Node(i).y-Node(j).y)^2);
                                if j ~= i && dist <= Rcomp && Node(j).CH == 0
                                    % j收到了来自i发来的最终簇头消息
                                    Node(j).RE = Node(j).RE - Eelec*ctrPacketLength;
                                    if Node(j).RE <= 0
                                        Node(j).RE = 0;
                                        Node(j).beVolunteerNode = false;
                                    else % 判断i是否为j的邻居节点
                                        for k = 1:Node(j).List_v_CH_num
                                            % 如果i是j的邻居节点
                                            if i == Node(j).List_v_CH(k)
                                                Node(j).flag_final_receive = true;  % j收到了来自邻居节点i的最终簇头消息
                                                break;
                                            end
                                        end
                                    end
                                end
                            end
                        end
                    end
                end
            end
        end
    end
    %% 计算簇头个数
    CH_count = 0;
    for i = 1:NodeNums
        if Node(i).CH == -1
            CH_count = CH_count + 1;
            CH(CH_count) = i;
            final_CH(r, CH_count) = i;
        end
    end
    %% 普通节点选择簇头
    for i = 1:NodeNums
        count = 0;
        if Node(i).RE > 0
            if Node(i).CH == -1
                % 簇头向普通节点广播消息
                distanceBroad = sqrt(xm*xm+ym*ym);
                if distanceBroad < dcrossover
                    Node(i).RE = Node(i).RE - (Eelec*ctrPacketLength+Efs*ctrPacketLength*distanceBroad^2);
                else
                    Node(i).RE = Node(i).RE - (Eelec*ctrPacketLength+Emp*ctrPacketLength*distanceBroad^4);
                end
            end
            if Node(i).CH == 0
                % 普通节点接收所有簇头发来的消息
                Node(i).RE = Node(i).RE - CH_count*Eelec*ctrPacketLength;
                % 普通节点根据接收消息的强度加入最近的簇头
                % 仿真时直接计算和簇头的欧氏距离,加入距离最小的簇头即可
                for j = 1:NodeNums
                    if j ~= i && Node(j).CH == -1
                        % 计算节点i与簇头j之间的距离
                        count = count + 1;
                        dist(count) = sqrt((Node(i).x-Node(j).x)^2+(Node(i).y-Node(j).y)^2);
                        my_CH(count) = j;
                    end
                end
                d = 9999;
                for k = 1:count
                    % 寻找距离普通节点最近的簇头,并加入它
                    if d > dist(k)
                        d = dist(k);
                        Node(i).CH = my_CH(k);
                    end
                end
                if Node(i).CH ~= 0
                    % 加入这个簇,发送加入簇头消息
                    if d < dcrossover
                        Node(i).RE = Node(i).RE - (Eelec*ctrPacketLength+Efs*ctrPacketLength*d^2);
                    else
                        Node(i).RE = Node(i).RE - (Eelec*ctrPacketLength+Emp*ctrPacketLength*d^4);
                    end
                    % 对应簇头接收消息
                    Node(Node(i).CH).RE = Node(Node(i).CH).RE - Eelec*ctrPacketLength;
                end
            end
        end
    end
    %% 分簇图
    figure;
    for i = 1:NodeNums
        if Node(i).RE <= 0
            plot(Node(i).x, Node(i).y , 'k.', 'markersize', 20);
            hold on;
        else
            if Node(i).CH == -1   % 簇头节点
                plot(Node(i).x, Node(i).y, 'r*');
                hold on;
            else
                plot([Node(Node(i).CH).x; Node(i).x], [Node(Node(i).CH).y; Node(i).y],'o-');
                hold on;
            end
        end
    end
    xlabel 'X-coordinates';
    ylabel 'Y-coordinates';
end

在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

图3~6 DEBUC非均匀分簇图

三、参考文献

[1] 蒋畅江,石为人,唐贤伦,等.能量均衡的无线传感器网络非均匀分簇路由协议[J].软件学报,2012(5):1222-1232

以上是关于能量均衡的无线传感器网络非均匀分簇路由协议的主要内容,如果未能解决你的问题,请参考以下文章

LEACH协议基于matlab最佳簇半径的无线传感器网络分簇路由算法含Matlab源码 2087期

LEACH协议基于matlab最佳簇半径的无线传感器网络分簇路由算法含Matlab源码 2087期

matlab实现LEACH协议路由分簇算法

matlab实现LEACH协议路由分簇算法

基于K-means聚类算法实现无线传感器网络分簇路由协议

异构无线传感器网络分布式节能分簇算法的设计(DEEC)