基于分簇拓扑的无线传感器网络的休眠调度算法
文章目录
- 一、基于分簇拓扑节点休眠调度算法
-
- 1、无线传感器网络运行概述
- 2、NDSCT算法设计
-
- （1）簇首的选择
- （2）簇的形成
- （3）调度簇内节点
- 二、仿真分析
-
- 1、仿真环境
- 2、休眠节点数
- 3、存活节点数
- 3、网络剩余总能量
- 4、节点消耗总能量
- 5、MATLAB程序实现
- 三、参考文献
一、基于分簇拓扑节点休眠调度算法
1、无线传感器网络运行概述
无线传感器网络是按照轮数来运行的，在网络的运行过程中，包括网络建立节点和节点稳定工作阶段两部分，如图1所示。
在网络建立阶段，对整个无线传感器网络进行分簇，节点按照某一概率成功获选成为簇头，然后向其邻居节点发送邀请加入簇结构的消息，而邻居节点通过信号的强弱来判断，就近的加入簇结构中并且按照TDMA时间片的传送数据给簇首。然后簇内中的节点进入稳定工作阶段，簇首节点和其他普通节点稳定工作，每个簇内节点将对监测区域覆盖感进行数据采集和数据融合，最后转发给簇首节点，而冗余节点是休眠的，不消耗能量。图2是一个无线传感器网络中一个簇结构的节点状态图，图中的簇首节点、休眠节点以及普通节点分别表示为 C H CH CH节点、白色节点和黑色节点。
2、NDSCT算法设计
（1）簇首的选择
对整个无线传感器网络进行簇首的选取，首先节点会随机生成 ( 0 , 1 ) (0,1) (0,1)之间的一个随机值，若预先设定的阈值是大于该随机值的，则它成功获选为簇首节点，然后将其成功获选为簇首的消息广播给周围其他节点。 T ( n ) T(n) T(n)的计算公式如下： T ( n ) = { p 1 − p × [ r m o d ( 1 p ) ] × E r e s i d u a l E 0 , n ∈ G 0 , e l s e (1) T(n)=\begin{cases}\frac{p}{1-p×\left[rmod(\frac1p)\right]}×\frac{E_{residual}}{E_0},\quad n∈G\\ 0,\quad \quad \quad \quad \quad \quad \quad\quad\quad \quad else\end{cases}\tag{1} T(n)={ 1−p×[rmod(p1)]p×E0Eresidual,n∈G0,else(1)在公式(1)中， p p p为簇首节点占整个网络节点的比列， E 0 E_0 E0为节点初始能量， E r e s i d u a l E_{residual} Eresidual为节点的剩余能量， n n n为当前的轮数， G G G为竞选簇首失败的节点集合。由公式(1)可知，节点剩余能量越多，其阈值就越大，因此就更容易获选成为簇首节点。
（2）簇的形成
当簇首节点向其他节点广播已当选簇首的消息后，那么其他的周围邻居节点将根据簇首广播消息的信号强弱来决定加入距离相对比较近的簇结构中，并向簇首发消息确认。当簇首节点收到请求加入消息后，采用 TDMA 方法将传送数据的时间片分配传送至簇结构中的每一个节点，簇的建立完成。
（3）调度簇内节点
在每一轮簇结构形成后，处于激活状态的所有簇内节点将依次按照自己的 I D ID ID大小来进行一个覆盖冗余的判定，判定冗余覆盖节点的条件为：
① 如果簇内节点的感知覆盖区域内的邻居节点数是小于四个的，那么此节点将继续处于活跃状态，进行工作；
② 如果簇内节点的感知覆盖区域内的邻居节点数是大于或等于四个并且满足如图3中覆盖条件，即该节点的感知覆盖区域被其邻居节点所完全覆盖，那么该节点就为冗余覆盖节点，它所感知到的数据都是邻居节点所感知到的，则使该节点在此轮中进行休眠，下一轮从新进行判定。
NDSCT算法流程图如图4所示。
二、仿真分析
1、仿真环境
通过 M a t l a b Matlab Matlab作为实验仿真平台来对分簇拓扑节点休眠调度算法进行仿真实验，将仿真结果与LEACH算法比较。所有传感器节点在 100 m × 100 m 100m×100m 100m×100m的目标监测区域范围内是随机分布的，汇聚节点即基站是处于整个网络的中间位置，传感器节点的总数取值为100，传感器的通信半径为感知半径的两倍即 R c = 2 R s Rc=2Rs Rc=2Rs， R c Rc Rc为30m， R s Rs Rs为15m。实验的参数设置与文献[1]相同。
2、休眠节点数
NDSCT算法每轮休眠节点数量如图5所示。
3、存活节点数
NDSCT和LEACH算法每轮存活节点数量如图6所示。
3、网络剩余总能量
NDSCT和LEACH算法每轮网络剩余总能量如图7所示。
4、节点消耗总能量
NDSCT和LEACH算法每轮节点消耗总能量如图8所示。
5、MATLAB程序实现
- 主函数
%% 清空环境变量
clear;
clc;
%% 初始化参数
xm = 100; % x轴范围
ym = 100; % y轴范围
sink.x = 50; % 基站x轴 50
sink.y = 50; % 基站y轴 50
n = 100; % 节点总数
p = 0.05; % 簇头概率
Rs = 15; % 感知半径
Rc = 2*Rs; % 通信半径
Eelec = 50*10^(-9);
Efs=10*10^(-12);
Emp=0.0013*10^(-12);
ED=5*10^(-9);
d0 = sqrt(Efs/Emp);
E0 = 0.5; % 初始能量
packetLength = 4000;
ctrPacketLength = 100;
rmax = 6000;
figure;
%% 节点随机分布
for i = 1:n
Node(i).xd = rand(1,1)*xm;
Node(i).yd = rand(1,1)*ym; % 随机产生100个点
Node(i).type = 'N'; % 进行选举簇头前先将所有节点设为普通节点
Node(i).E = E0; % 初始能量
Node(i).CH = 0; % 保存普通节点的簇头节点，-1代表自己是簇头
Node(i).d = sqrt((Node(i).xd-sink.x)^2+(Node(i).yd-sink.y)^2);
Node(i).G = 0; % 候选集标志
Node(i).Nbr = zeros(n, 1); % 邻居节点集
Node(i).NumNbr = 0; % 邻居节点个数
Node(i).status = 1; % 节点的状态：1 激活状态；0 休眠状态
plot(Node(i).xd, Node(i).yd, 'o', sink.x, sink.y, 'p', 'LineWidth', 2);
hold on;
end
legend('节点', '基站');
xlabel 'x'; ylabel 'y'; title 'WSN分布图';
save data1;
%%%%%%%%%%%%%%%%%NDSCT%%%%%%%%%%%%%%%
alive_ndsct = zeros(rmax, 1); % 每轮存活节点数
re_ndsct = zeros(rmax, 1); % 每轮节点总能量
ce_ndsct = zeros(rmax, 1); % 每轮节点消耗总能量
sleep = zeros(rmax, 1); % 每轮休眠节点数
for r = 1:rmax
r
% figure;
if mod(r, round(1/p)) == 0
for i = 1:n
Node(i).G = 0;
end
end
% 初始化
for i = 1:n
if Node(i).E > 0
Node(i).type = 'N';
Node(i).CH = 0;
Node(i).status = 1;
Node(i).NumNbr = 0;
alive_ndsct(r) = alive_ndsct(r)+1;
re_ndsct(r) = re_ndsct(r)+Node(i).E;
end
end
if alive_ndsct(r) == 0
break;
end
% 计算邻居节点
for i = 1:n
if Node(i).E > 0
count = 0;
for j = 1:n
if Node(j).E > 0
dist = sqrt((Node(i).xd-Node(j).xd)^2+(Node(i).yd-Node(j).yd)^2);
if j ~= i && dist < Rs
count = count + 1;
Node(i).Nbr(count) = j;
end
end
if j == n
Node(i).NumNbr = count;
end
end
end
end
%% 簇头选举
cluster = 0;
for i = 1:n
if Node(i).E > 0
temp_rand = rand;
if Node(i).G <= 0 && temp_rand < p/(1-p*mod(r,round(1/p)))*(Node(i).E/E0)
Node(i).type = 'C'; % 节点类型为簇头
Node(i).G = round(1/p)-1;
cluster = cluster + 1;
% 簇头节点存入C数组
C(cluster).xd = Node(i).xd;
C(cluster).yd = Node(i).yd;
C(cluster).dist = Node(i).d;
C(cluster).id = i;
% X(cluster) = Node(i).xd;
% Y(cluster) = Node(i).yd;
% plot(Node(i).xd, Node(i).yd, 'r*');
% hold on;
CH = C;
Node(i).CH = -1;
% 广播自成为簇头
distanceBroad = sqrt(xm*xm+ym*ym);
if distanceBroad > d0
Node(i).E = Node(i).E- (Eelec*ctrPacketLength + Emp*ctrPacketLength*distanceBroad^4);
ce_ndsct(r) = ce_ndsct(r)+Eelec*ctrPacketLength + Emp*ctrPacketLength*distanceBroad^4;
else
Node(i).E = Node(i).E- (Eelec*ctrPacketLength + Efs*ctrPacketLength*distanceBroad^2);
ce_ndsct(r) = ce_ndsct(r)+Eelec*ctrPacketLength + Efs*ctrPacketLength*distanceBroad^2;
end
% 簇头自己发送数据包能量消耗
if Node(i).d > d0
Node(i).E = Node(i).E- ((Eelec+ED)*packetLength+Emp*packetLength*Node(i).d^4);
ce_ndsct(r) = ce_ndsct(r)+(Eelec+ED)*packetLength+Emp*packetLength*Node(i).d^4;
else
Node(i).E = Node(i).E- ((Eelec+ED)*packetLength+Efs*packetLength*Node(i).d^2);
ce_ndsct(r) = ce_ndsct(r)+(Eelec+ED)*packetLength+Efs*packetLength*Node(i).d^2;
end
end
end
end
% 判断最近的簇头结点，如何去判断，采用距离矩阵
for i = 1:n
if Node(i).type == 'N' && Node(i).E > 0
if cluster > 0
Length = zeros(cluster, 1);
for c = 1:cluster
Length(c) = sqrt((Node(i).xd - C(c).xd)^2+(Node(i).yd-C(c).yd)^2);
end
[min_dis, min_dis_cluster] = min(Length); % 找到距离簇头最近的簇成员节点
% 接收簇头发来的广播的消耗
Node(i).E = Node(i).E - Eelec*ctrPacketLength;
ce_ndsct(r) = ce_ndsct(r)+Eelec*ctrPacketLength;
% 加入这个簇
if min_dis < d0
Node(i).E = Node(i).E-(Eelec*ctrPacketLength+Efs*ctrPacketLength*min_dis^2);
ce_ndsct(r) = ce_ndsct(r)+Eelec*ctrPacketLength+Efs*ctrPacketLength*min_dis^2;
else
Node(i).E = Node(i).E-(Eelec*ctrPacketLength+Emp*ctrPacketLength*min_dis^4);
ce_ndsct(r) = ce_ndsct(r)+Eelec*ctrPacketLength+Emp*ctrPacketLength*min_dis^4;
end
Node(i).CH = C(min_dis_cluster).id;
% plot(Node(i).xd, Node(i).yd, 'ko');
% hold on;
% plot([Node(i).xd; Node(C(min_dis_cluster).id).xd], [Node(i).yd; Node(C(min_dis_cluster).id).yd]);
% hold on;
% 簇头接收簇成员接收加入消息
if min_dis > 0
Node(C(min_dis_cluster).id).E = Node(C(min_dis_cluster).id).E - Eelec*ctrPacketLength; %接收加入消息
ce_ndsct(r) = ce_ndsct(r)+Eelec*ctrPacketLength;
end
end
end
end
%% 判断冗余节点，进行休眠调度
for i = 1:n
if Node(i).E > 0 && Node(i).type == 'N' % 非簇头节点
if Node(i).NumNbr >= 4 % 邻居节点个数≥4
if isFullCover(Node, i) == 1
Node(i).status = 0; % 冗余节点，状态调整为休眠状态
sleep(r) = sleep(r)+1;
% plot(Node(i).xd, Node(i).yd, 'go');
% hold on;
end
end
end
end
%% 数据传输
for i = 1:n
if Node(i).E > 0 && Node(i).status ~= 0 % 节点存活且状态为激活态
if Node(i).type == 'N' % 普通节点
if cluster > 0 % 簇头节点存在
dist = sqrt((Node(i).xd-Node(Node(i).CH).xd)^2+(Node(i).yd-Node(Node(i).CH).yd)^2);
% 向簇头发送数据
if dist < d0
Node(i).E = Node(i).E-(Eelec*packetLength+Efs*packetLength*dist^2);
ce_ndsct(r) = ce_ndsct(r)+Eelec*packetLength+Efs*packetLength*dist^2;
else
Node(i).E = Node(i).E-(Eelec*packetLength+Emp*packetLength*dist^4);
ce_ndsct(r) = ce_ndsct(r)+Eelec*packetLength+Emp*packetLength*dist^4;
end
else % 无簇头选出
% 直接发送数据到基站
dist = Node(i).d;
if dist < d0
Node(i).E = Node(i).E-(Eelec*packetLength+Efs*packetLength*dist^2);
ce_ndsct(r) = ce_ndsct(r)+Eelec*packetLength+Efs*packetLength*dist^2;
else
Node(i).E = Node(i).E-(Eelec*packetLength+Emp*packetLength*dist^4);
ce_ndsct(r) = ce_ndsct(r)+Eelec*packetLength+Emp*packetLength*dist^4;
end
end
end
end
end
end
load data1.mat;
%%%%%%%%%%%%%%LEACH%%%%%%%%%%%%%%%
%%
alive_leach = zeros(rmax, 1); % 每轮存活节点数
re_leach = zeros(rmax, 1); % 每轮节点总能量
ce_leach = zeros(rmax, 1); % 每轮节点消耗总能量
for r = 1:rmax
% figure;
if mod(r, round(1/p)) == 0
for i = 1:n
Node(i).G=0;
end
end
for i = 1:n
if Node(i).E > 0
Node(i).type = 'N';
Node(i).CH = 0;
alive_leach(r) = alive_leach(r)+1;
re_leach(r) = re_leach(r)+Node(i).E;
end
end
if alive_leach(r) == 0
break;
end
%% 簇头选举
cluster = 0;
for i = 1:n
if Node(i).E > 0
temp_rand = rand;
if Node(i).G <= 0 && temp_rand < p/(1-p*mod(r,round(1/p)))
Node(i).type = 'C'; % 节点类型为簇头
Node(i).G = round(1/p)-1;
cluster = cluster + 1;
% 簇头节点存入C数组
C(cluster).xd = Node(i).xd;
C(cluster).yd = Node(i).yd;
C(cluster).dist = Node(i).d;
C(cluster).id = i;
X(cluster) = Node(i).xd;
Y(cluster) = Node(i).yd;
CH = C;
Node(i).CH = -1;
% 广播自成为簇头
distanceBroad = sqrt(xm*xm+ym*ym);
if distanceBroad > d0
Node(i).E = Node(i).E- (Eelec*ctrPacketLength + Emp*ctrPacketLength*distanceBroad^4);
ce_leach(r) = ce_leach(r)+Eelec*ctrPacketLength + Emp*ctrPacketLength*distanceBroad^4;
else
Node(i).E = Node(i).E- (Eelec*ctrPacketLength + Efs*ctrPacketLength*distanceBroad^2);
ce_leach(r) = ce_leach(r)+Eelec*ctrPacketLength + Efs*ctrPacketLength*distanceBroad^2;
end
% 簇头自己发送数据包能量消耗
if Node(i).d > d0
Node(i).E = Node(i).E- ((Eelec+ED)*packetLength+Emp*packetLength*Node(i).d^4);
ce_leach(r) = ce_leach(r)+(Eelec+ED)*packetLength+Emp*packetLength*Node(i).d^4;
else
Node(i).E = Node(i).E- ((Eelec+ED)*packetLength+Efs*packetLength*Node(i).d^2);
ce_leach(r) = ce_leach(r)+(Eelec+ED)*packetLength+Efs*packetLength*Node(i).d^2;
end
end
end
end
% 判断最近的簇头结点，如何去判断，采用距离矩阵
for i = 1:n
if Node(i).type == 'N' && Node(i).E > 0
if cluster > 0
Length = zeros(cluster, 1);
for c = 1:cluster
Length(c) = sqrt((Node(i).xd - C(c).xd)^2+(Node(i).yd-C(c).yd)^2);
end
[min_dis, min_dis_cluster] = min(Length); % 找到距离簇头最近的簇成员节点
% 接收簇头发来的广播的消耗
Node(i).E = Node(i).E - Eelec*ctrPacketLength;
ce_leach(r) = ce_leach(r)+Eelec*ctrPacketLength;
% 加入这个簇，并发送数据给簇头
if min_dis < d0
Node(i).E = Node(i).E-(Eelec*(ctrPacketLength+packetLength)+Efs*(ctrPacketLength+packetLength)*min_dis^2);
ce_leach(r) = ce_leach(r)+Eelec*(ctrPacketLength+packetLength)+Efs*(ctrPacketLength+packetLength)*min_dis^2;
else
Node(i).E = Node(i).E-(Eelec*(ctrPacketLength+packetLength)+Emp*(ctrPacketLength+packetLength)*min_dis^4);
ce_leach(r) = ce_leach(r)+Eelec*(ctrPacketLength+packetLength)+Emp*(ctrPacketLength+packetLength)*min_dis^4;
end
Node(i).CH = C(min_dis_cluster).id;
% 簇头接收簇成员数据包消耗能量,接收加入消息
if min_dis > 0
Node(C(min_dis_cluster).id).E = Node(C(min_dis_cluster).id).E - (Eelec+ED)*packetLength; %接受簇成员发来的数据包
Node(C(min_dis_cluster).id).E = Node(C(min_dis_cluster).id).E - Eelec*ctrPacketLength; %接收加入消息
ce_leach(r) = ce_leach(r)+(Eelec+ED)*packetLength+Eelec*ctrPacketLength;
end
else % 无簇头选出，直接发送数据包到基站
if Node(i).d < d0
Node(i).E = Node(i).E-(Eelec*packetLength+Efs*packetLength*Node(i).d^2);
ce_leach(r) = ce_leach(r)+Eelec*packetLength+Efs*packetLength*Node(i).d^2;
else
Node(i).E = Node(i).E-(Eelec*packetLength+Emp*packetLength*Node(i).d^4);
ce_leach(r) = ce_leach(r)+Eelec*packetLength+Emp*packetLength*Node(i).d^4;
end
end
end
% [vx, vy] = voronoi(X, Y);
% plot(X, Y, 'r*', vx, vy, 'g-');
% hold on;
% voronoi(X, Y);
% axis([0 xm 0 ym]);
end
end
%% 绘图显示
figure;
plot(1:rmax, sleep, 'r', 'linewidth', 1);
xlabel '轮数'; ylabel '每轮休眠节点数';
legend('NDSCT');
figure;
plot(1:rmax, alive_ndsct, 'r', 1:rmax, alive_leach, 'g', 'LineWidth', 2);
xlabel '轮数'; ylabel '每轮存活节点数';
legend('NDSCT', 'LEACH');
figure;
plot(1:rmax, re_ndsct, 'r', 1:rmax, re_leach, 'g', 'LineWidth', 2);
xlabel '轮数'; ylabel '每轮剩余总能量';
legend('NDSCT', 'LEACH');
figure;
plot(1:rmax, ce_ndsct, 'r', 1:rmax, ce_leach, 'g', 'LineWidth', 1);
xlabel '轮数'; ylabel '每轮消耗总能量';
legend('NDSCT', 'LEACH');
- 计算节点 i i i是否是冗余节点的函数
function flag = isFullCover(Node, i)
%% 计算节点i是否是冗余节点
flag = 0;
Ixy = [Node(i).xd, Node(i).yd];
for j = 1:Node(i).NumNbr
for k = j+1:Node(i).NumNbr
for p = k+1:Node(i).NumNbr
for q = p+1:Node(i).NumNbr
Jxy = [Node(Node(i).Nbr(j)).xd, Node(Node(i).Nbr(j)).yd];
Kxy = [Node(Node(i).Nbr(k)).xd, Node(Node(i).Nbr(k)).yd];
Pxy = [Node(Node(i).Nbr(p)).xd, Node(Node(i).Nbr(p)).yd];
Qxy = [Node(Node(i).Nbr(q)).xd, Node(Node(i).Nbr(q)).yd];
J = Jxy-Ixy;
K = Kxy-Ixy;
P = Pxy-Ixy;
Q = Qxy-Ixy;
cosjk = dot(J, K)/(norm(J)*norm(K));
cosjp = dot(J, P)/(norm(J)*norm(P));
cosjq = dot(J, Q)/(norm(J)*norm(Q));
coskp = dot(K, P)/(norm(K)*norm(P));
coskq = dot(K, Q)/(norm(K)*norm(Q));
cospq = dot(P, Q)/(norm(P)*norm(Q));
tempjk = acos(cosjk); anglejk = tempjk*180/pi;
tempjp = acos(cosjp); anglejp = tempjp*180/pi;
tempjq = acos(cosjq); anglejq = tempjq*180/pi;
tempkp = acos(coskp); anglekp = tempkp*180/pi;
tempkq = acos(coskq); anglekq = tempkq*180/pi;
temppq = acos(cospq); anglepq = temppq*180/pi;
%% 判断
% jk开头
if (anglejk > 60 && anglejk < 120) && (anglekp > 60 && anglekp < 120) ...
&& (anglepq > 60 && anglepq < 120) && (anglejq > 60 && anglejq < 120)
flag = 1;
break;
end
if (anglejk > 60 && anglejk < 120) && (anglekq > 60 && anglekq < 120) ...
&& (anglepq > 60 && anglepq < 120) && (anglejp > 60 && anglejp < 120)
flag = 1;
break;
end
% jp开头
if (anglejp > 60 && anglejp < 120) && (anglekp > 60 && anglekp < 120) ...
&& (anglekq > 60 && anglekq < 120) && (anglejq > 60 && anglejq < 120)
flag = 1;
break;
end
if (anglejp > 60 && anglejp < 120) && (anglepq > 60 && anglepq < 120) ...
&& (anglekq > 60 && anglekq < 120) && (anglejk > 60 && anglejk < 120)
flag = 1;
break;
end
% jq开头
if (anglejq > 60 && anglejq < 120) && (anglekq > 60 && anglekq < 120) ...
&& (anglekp > 60 && anglekp < 120) && (anglejp > 60 && anglejp < 120)
flag = 1;
break;
end
if (anglejq > 60 && anglejq < 120) && (anglepq > 60 && anglepq < 120) ...
&& (anglekp > 60 && anglekp < 120) && (anglejk > 60 && anglejk < 120)
flag = 1;
break;
end
% kj开头
if (anglejk > 60 && anglejk < 120) && (anglejp > 60 && anglejp < 120) ...
&& (anglepq > 60 && anglepq < 120) && (anglekq > 60 && anglekq < 120)
flag = 1;
break;
end
if (anglejk > 60 && anglejk < 120) && (anglejq > 60 && anglejq < 120) ...
&& (anglepq > 60 && anglepq < 120) && (anglekp > 60 && anglekp < 120)
flag = 1;
break;
end
% kp开头
if (anglekp > 60 && anglekp < 120) && (anglepq > 60 && anglepq < 120) ...
&& (anglejq > 60 && anglejq < 120) && (anglejk > 60 && anglejk < 120)
flag = 1;
break;
end
if (anglekp > 60 && anglekp < 120) && (anglejp > 60 && anglejp < 120) ...
&& (anglejq > 60 && anglejq < 120) && (anglekq > 60 && anglekq < 120)
flag = 1;
break;
end
% kq开头
if (anglekq > 60 && anglekq < 120) && (anglepq > 60 && anglepq < 120) ...
&& (anglejp > 60 && anglejp < 120) && (anglejk > 60 && anglejk < 120)
flag = 1;
break;
end
if (anglekq > 60 && anglekq < 120) && (anglejq > 60 && anglejq < 120) ...
&& (anglejp > 60 && anglejp < 120) && (anglekp > 60 && anglekp < 120)
flag = 1;
break;
end
% pj开头
if (anglejp > 60 && anglejp < 120) && (anglejk > 60 && anglejk < 120) ...
&& (anglekq > 60 && anglekq < 120) && (anglepq > 60 && anglepq < 120)
flag = 1;
break;
end
if (anglejp > 60 && anglejp < 120) && (anglejq > 60 && anglejq < 120) ...
&& (anglekq > 60 && anglekq < 120) && (anglekp > 60 && anglekp < 120)
flag = 1;
break;
end
% pk开头
if (anglekp > 60 && anglekp < 120) && (anglejk > 60 && anglejk < 120) ...
&& (anglejq > 60 && anglejq < 120) && (anglepq > 60 && anglepq < 120)
flag = 1;
break;
end
if (anglekp > 60 && anglekp < 120) && (anglekq > 60 && anglekq < 120) ...
&& (anglejq > 60 && anglejq < 120) && (anglejp > 60 && anglejp < 120)
flag = 1;
break;
end
% pq开头
if (anglepq > 60 && anglepq < 120) && (anglejq > 60 && anglejq < 120) ...
&& (anglejk > 60 && anglejk < 120) && (anglekp > 60 && anglekp < 120)
flag = 1;
break;
end
if (anglepq > 60 && anglepq < 120) && (anglekq > 60 && anglekq < 120) ...
&& (anglejk > 60 && anglejk < 120) && (anglejp > 60 && anglejp < 120)
flag = 1;
break;
end
% qj开头
if (anglejq > 60 && anglejq < 120) && (anglejk > 60 && anglejk < 120) ...
&& (anglekp > 60 && anglekp < 120) && (anglepq > 60 && anglepq < 120)
flag = 1;
break;
end
if (anglejq > 60 && anglejq < 120) && (anglejp > 60 && anglejp < 120) ...
&& (anglekp > 60 && anglekp < 120) && (anglekq > 60 && anglekq < 120)
flag = 1;
break;
end
% qk开头
if (anglekq > 60 && anglekq < 120) && (anglejk > 60 && anglejk < 120) ...
&& (anglejp > 60 && anglejp < 120) && (anglepq > 60 && anglepq < 120)
flag = 1;
break;
end
if (anglekq > 60 && anglekq < 120) && (anglekp > 60 && anglekp < 120) ...
&& (anglejp > 60 && anglejp < 120) && (anglejq > 60 && anglejq < 120)
flag = 1;
break;
end
% qp开头
if (anglepq > 60 && anglepq < 120) && (anglejp > 60 && anglejp < 120) ...
&& (anglejk > 60 && anglejk < 120) && (anglekq > 60 && anglekq < 120)
flag = 1;
break;
end
if (anglepq > 60 && anglepq < 120) && (anglekp > 60 && anglekp < 120) ...
&& (anglejk > 60 && anglejk < 120) && (anglejq > 60 && anglejq < 120)
flag = 1;
break;
end
end
if flag == 1
break;
end
end
if flag == 1
break;
end
end
if flag == 1
break;
end
end
三、参考文献
[1] 张雷. 基于分簇拓扑的无线传感器网络节点休眠调度算法研究[D]. 2019.