├── README.md
└── WSN FINAL.m


/README.md:
--------------------------------------------------------------------------------
 1 | <h1 align="center">🌐 Wireless Sensor Network (WSN) Research and Development 🛰️</h1>
 2 | 
 3 | <p align="center">
 4 |   <img src="https://geekflare.com/wp-content/uploads/2023/06/WSN-featured-image.png" alt="WSN Banner">
 5 | </p>
 6 | 
 7 | <p align="center">
 8 |   Welcome to the repository for our Wireless Sensor Network (WSN) research and development project. In this project, we aim to address critical issues related to WSNs, including coverage hole detection, improved node participation, energy-efficient routing, and much more. Below, you'll find a comprehensive overview of our research, objectives, scope, and future directions.
 9 | </p>
10 | 
11 | ## Table of Contents 📜
12 | 
13 | - [Introduction 🚀](#introduction)
14 | - [What is a Wireless Sensor Network (WSN)? 📡](#what-is-a-wireless-sensor-network-wsn)
15 | - [Random Node Distribution 🎲](#random-node-distribution)
16 | - [Delaunay Triangulation 🔺](#delaunay-triangulation)
17 | - [Clustering Protocols 🌐](#clustering-protocols)
18 | - [Proposed System 🌟](#proposed-system)
19 | - [Objectives 🎯](#objectives)
20 | - [Scope 🔍](#scope)
21 | - [Conclusion 🌈](#conclusion)
22 | - [Future Scope 🔮](#future-scope)
23 | 
24 | ## Introduction 🚀
25 | 
26 | In Wireless Sensor Networks (WSNs), battery life is a critical concern. As sensor nodes deplete their batteries, communication holes emerge within the network. This project aims to detect these coverage holes, improve node participation, and develop energy-efficient routing protocols to enhance the overall efficiency and lifespan of WSNs.
27 | 
28 | ## What is a Wireless Sensor Network (WSN)? 📡
29 | 
30 | A WSN is a wireless network comprising distributed, independent sensor devices designed to monitor physical or environmental conditions. These tiny sensor nodes communicate with each other and exchange information, collecting data on various environmental parameters and forwarding it to a base station. WSNs find applications in diverse fields, including navigation systems, quality control, business, networking, and management.
31 | 
32 | ## Random Node Distribution 🎲
33 | 
34 | Randomly deploying sensor nodes within a predefined network area is a common practice. This approach offers scalability, reduced deployment costs, and increased network robustness. However, it also presents challenges such as incomplete coverage, connectivity issues, and inefficient energy consumption. To address these challenges, we propose a system that detects coverage holes and improves node participation to ensure complete coverage and reduced energy consumption.
35 | 
36 | ## Delaunay Triangulation 🔺
37 | 
38 | Delaunay triangulation is a computational geometry technique that optimizes WSN coverage by creating a mesh of triangles covering the deployment area. This technique guarantees that every point in the network is covered by at least one sensor node, reducing the number of active nodes and overall energy consumption. Delaunay triangulation also enhances routing efficiency by defining communication paths between nodes and allows scaling of WSNs for larger coverage areas.
39 | 
40 | ## Clustering Protocols 🌐
41 | 
42 | Clustering protocols are crucial for organizing sensor nodes into groups based on spatial proximity, energy levels, or other factors. These protocols reduce energy consumption by minimizing the number of nodes transmitting data directly to the base station. The LEACH protocol, for example, rotates the role of cluster head among nodes to balance energy consumption and adapt to changing network topologies.
43 | 
44 | ## Proposed System 🌟
45 | 
46 | Our proposed system combines improved node participation by placing mobile nodes strategically within the network and an energy-efficient routing approach using the EQDC Protocol (Equi-Quadrant Division Clustering) and optimized Shortest Path Routing through minimum spanning trees. This combination minimizes distances between nodes, reducing energy consumption and enhancing network efficiency.
47 | 
48 | ## Objectives 🎯
49 | 
50 | - Mitigate coverage hole issues in WSNs.
51 | - Increase node participation in the sensor network.
52 | - Develop an improved energy routing clustering protocol.
53 | - Optimize the LEACH protocol.
54 | - Combine improved energy routing with clustering to enhance network efficiency.
55 | - Find the shortest path from source nodes to the base station.
56 | - Improve energy efficiency within the wireless sensor network using our proposed system.
57 | 
58 | ## Scope 🔍
59 | 
60 | WSNs have a wide range of applications, including:
61 | 
62 | - 🗺️ **Navigation Systems:** Providing indoor positioning and navigation in GPS-challenged environments, among other uses.
63 | - 🏭 **Quality Control Systems:** Monitoring product quality, real-time process control, and predictive maintenance in various industries.
64 | - 📊 **Business:** Supporting supply chain management, inventory control, and environmental monitoring.
65 | - 🌐 **Networking:** Enabling data collection, processing, and communication, as well as network management.
66 | - 🏢 **Management:** Assisting in asset management, facility management, supply chain management, and environmental management.
67 | 
68 | ## Conclusion 🌈
69 | 
70 | Random node distribution in WSNs is essential in remote or challenging environments. We've explored various strategies and techniques to address the inherent challenges, including coverage holes, connectivity issues, and energy consumption. Our proposed system, which combines Delaunay triangulation, clustering protocols, and optimized routing, significantly improves network efficiency.
71 | 
72 | ## Future Scope 🔮
73 | 
74 | Our project opens up several avenues for future research and development, including advanced deployment strategies, dynamic node mobility, energy harvesting and power management, fault tolerance, integration with emerging technologies, and security and privacy considerations. These areas present exciting opportunities to further enhance WSNs for various applications and environments.
75 | 
76 | **We invite you to explore our project and contribute to the exciting world of Wireless Sensor Networks!**
77 | 
78 | 
79 | 


--------------------------------------------------------------------------------
/WSN FINAL.m:
--------------------------------------------------------------------------------
  1 | close all;
  2 | clear;
  3 | clc;
  4 | xm=100;
  5 | ym=100;
  6 | x=0; % added for better display results of the plot
  7 | y=0; % added for better display results of the plot
  8 | p=0.1; % Probability of node transmitting data
  9 | Eo=0.5; % initial energy of node
 10 | ETX=50*0.000000001; %
 11 | ERX=50*0.000000001;
 12 | Efs=10e-12;
 13 | Emp=0.0013e-12;
 14 | EDA=5*0.000000001;
 15 | rmax=2000;
 16 | do=sqrt(Efs/Emp);
 17 | Et=0;
 18 | % Number of Nodes in the field %
 19 | global n;
 20 | n=100;
 21 | global mn;
 22 | mn=10;
 23 | %loop variable to determine the termination of the network
 24 | operatingNodes=n+mn;
 25 | % Number of Dead Nodes in the beggining %
 26 | dead_nodes=0;
 27 | % Coordinates of the Sink (location is predetermined in this simulation) %
 28 | sinkx=50;
 29 | sinky=120;
 30 |  
 31 | %energy details
 32 |  
 33 | % Initial Energy of a Node (in Joules) % 
 34 | % E0=0.05; % units in Joules
 35 | % ME0=0.1;
 36 | % deadNodeThreshold=.000025;
 37 |  
 38 | LeaderNodeThreshold=.03;
 39 | global SN;
 40 | global MN;
 41 | global totalNodes;
 42 | totalNodes=n+mn+1;
 43 |  
 44 |  
 45 |  
 46 |             %%% Creation of the Wireless Sensor Network %%%
 47 |             
 48 | pts=[n,2];
 49 | pts=[rand([n,1])*xm,rand([n,1])*xm];
 50 | disp(pts);
 51 |  
 52 | %%% randomly generating mobile node points
 53 | mnpts=[mn,2];
 54 | mnpts=[rand([mn,1])*xm,rand([mn,1])*xm];
 55 | %disp(pts);
 56 |  
 57 |  
 58 |  
 59 |  
 60 |  
 61 | % X-axis coordinates of sensor node
 62 |  
 63 |  
 64 | for i=1:mn
 65 |     
 66 |     MN(i).x=mnpts(i,1);
 67 |     MN(i).y=mnpts(i,2);
 68 |     MN(i).radius=50; %assuming 20meters
 69 |     MN(i).sel=0;
 70 |     
 71 | end
 72 |  
 73 |  
 74 | %% Adding base station to the sensor node list
 75 |  
 76 |  
 77 |  %adding sink point to pts array
 78 |  
 79 | %aading sink point to pts array
 80 | sink=[sinkx,sinky];
 81 | disp('sink is..');
 82 | disp(sink);
 83 | pts=[sink;pts];
 84 | % pts(end+1,1)=sinkx;
 85 | % pts(end,2)=sinky;
 86 | disp(pts);
 87 |  
 88 |  
 89 |  
 90 |  
 91 |  
 92 |  
 93 |  
 94 |  
 95 |  
 96 |  
 97 |  
 98 | % Plotting the WSN %
 99 | for i=1:n+1
100 |     
101 |     
102 |       SN(i).id=i; % sensor's ID number
103 |      SN(i).radius=20; %assuming 20 meters
104 |    SN(i).x=pts(i,1);
105 |    SN(i).y=pts(i,2);
106 | %    SN(i).chainID=0;
107 | %  
108 | %     SN(i).E=E0;     % nodes energy levels (initially set to be equal to "Eo"
109 | %         
110 | %     SN(i).order=0;
111 | %     SN(i).sel=0;    % states if the node has already operated for this round or not (if 0 then no, if 1 then yes) 
112 | %     SN(i).rop=0;    % number of rounds node was operational
113 | %     SN(i).tel=0;    % states how many times the node was elected as a Cluster Head
114 | %     order(i)=0;
115 | %     SN(i).weight=0;
116 |  
117 |  
118 |        hold on;
119 |     figure(1)
120 |     plot(x,y,xm,ym,SN(i).x,SN(i).y,'ob',sinkx,sinky,'*r');
121 |      
122 |     title 'Wireless Sensor Network';
123 |     xlabel '(m)';
124 |     ylabel '(m)';
125 |     
126 | end
127 |  
128 | %trying to create coordinates array and y coordinates array seperately to
129 | %give coordinates in the grpah
130 | xCoord=(n+1+mn);
131 | yCoord=(n+1+mn);
132 |  
133 | for i=1:n+1
134 |    xCoord(i)=SN(i).x;
135 |    yCoord(i)=SN(i).y;
136 | end
137 | %xCoord(end+1)=sinkx;
138 | %xCoord=[sinkx,xCoord];
139 | %yCoord(end+1)=sinky;
140 | %yCoord=[sinky,yCoord];
141 | % for i=1:mn
142 | %     
143 | %      plot(x,y,xm,ym,MN(i).x,MN(i).y,'+r');
144 | %      
145 | %      
146 | %     
147 | % end
148 |  
149 |  
150 |  
151 |  
152 |  
153 |  
154 |  
155 |    
156 |  
157 |  
158 |  % Calculates Euclidaean Distance Between Each Node and the Sink (Base Station) %
159 |  for i=1:n+1
160 |  
161 |      
162 |     dts(i)=sqrt((sinkx-xCoord(i))^2 + (sinky-yCoord(i))^2);
163 | %    SN(i).Esink=Eelec*k + Eamp*k*(SN(i).dts)^2;
164 |     T(i)=dts(i);
165 |  end
166 | % disp('t of one is..');
167 |  %disp(T(1));
168 |  %sdisp('t of 21 is..')
169 |  %disp(T(21));
170 |  %euclidean distance from each node to the sink node now is stored in T
171 |  %array T   can access by T(i) in for loop
172 |  
173 |  
174 |  
175 | %checking operatingNodes loop
176 |  
177 |  
178 | %Delaunay triangulating all the sensor nodes
179 |  
180 |  
181 |  
182 | DT = delaunayTriangulation(pts); 
183 | figure(2)
184 |  
185 | e=DT.edges;
186 | plot(sinkx, sinky, 'r*', 'markersize', 5);
187 | hold on
188 |  
189 | pl=triplot(DT,'-ob');
190 | hold on
191 | plot(pts(1),pts(2),'-r','LineWidth',2);
192 |  
193 | %nodes to be displayed
194 |  
195 |  
196 |  
197 | %plot(xy(:, 1), xy(:, 2), 'ro', MarkerSize=12, MarkerFaceColor='r');
198 | title 'Delaunay Triangulation of the network with Sink and Static sensor nodes';
199 |  
200 |  
201 |  
202 |  
203 | DT = delaunayTriangulation(pts); 
204 | figure(3)
205 | hold on
206 | for i=1:mn
207 |     
208 |      plot(x,y,xm,ym,MN(i).x,MN(i).y,'+r');
209 |      
210 |      
211 |     
212 | end
213 | pl=triplot(DT,'-ob');
214 | title 'Current positions of mobile sensor nodes'
215 |  
216 | %identifying gaps
217 |  
218 | %identifying edge lengths of DT
219 |  
220 | edgelengths = sqrt(sum((DT.Points(e(:,1),:) - DT.Points(e(:,2),:)).^2,2));
221 | %disp('edge lengths');
222 | disp(edgelengths);
223 | %disp(edgelengths);
224 | noOfEdges=size(edgelengths);
225 |  
226 | %disp(pts);
227 | %disp((DT.Points(e(:,1),:)));
228 | %disp((DT.Points(e(:,2),:)));
229 |  
230 |  
231 | mnx=(mn);
232 | mny=(mn);
233 | pending_edge=(0);
234 | %checking if it is greater than 2*radius of static node
235 |  global k;
236 |  k=0;
237 |  in=1;
238 |  selectedEdge=[];
239 | for i=1:noOfEdges
240 |  
241 |   edgeX1=DT.Points(e(i,1),1);
242 |  
243 |  edgeY1=DT.Points(e(i,1),2);
244 |  edgeX2=DT.Points(e(i,2),1);
245 |  edgeY2=DT.Points(e(i,2),2);
246 |     
247 |     
248 |     if k<=mn
249 |    
250 | if edgelengths(i)> 2*SN(1).radius
251 |   % disp('found a hole');
252 |    %k=k+1;
253 |    
254 |      %check if the found hole is patchable or not   
255 |    if 2*MN(1).radius>abs(edgelengths(i)-2*SN(1).radius)
256 |        
257 |      %  disp('patchable hole found');
258 |        selectedEdge=[selectedEdge,i];
259 |        
260 |        % edgeX1=DT.Points(e(i,1),1);
261 |  
262 |  %edgeY1=DT.Points(e(i,1),2);
263 |  %edgeX2=DT.Points(e(i,2),1);
264 |  %edgeY2=DT.Points(e(i,2),2);
265 |  if k~=mn
266 |   k=k+1;
267 |  end
268 |  
269 |  
270 |  
271 |  mnx(k)=(edgeX1+edgeX2)/2;
272 |  mny(k)=(edgeY1+edgeY2)/2;
273 | % newPoint=[1,2];
274 | %newPoint(1,1)=mnx(k);
275 | %newPoint(1,2)=mny(k);
276 |  
277 |  %DT.Points(end+1,:)=newPoint;
278 |  
279 |  %if not patchable
280 |           
281 |    end
282 |    
283 |    
284 |    
285 |     
286 |    
287 | end
288 | %disp(k);
289 |  
290 |  
291 |  
292 |  
293 |  
294 |  
295 |  
296 |  
297 |  
298 |     end 
299 |    
300 |    MNx=(mn);
301 |    MNy=(mn);
302 |    
303 |      
304 |    
305 |  
306 |  
307 | end
308 | disp(k);
309 |  
310 | if k<mn
311 |     for i=1:length(edgelengths)
312 |         
313 |   edgeX1=DT.Points(e(i,1),1);
314 |  
315 |  edgeY1=DT.Points(e(i,1),2);
316 |  edgeX2=DT.Points(e(i,2),1);
317 |  edgeY2=DT.Points(e(i,2),2);
318 |         if edgelengths(i)>30 && k<mn && ismember(i,selectedEdge)==0
319 |             k=k+1;
320 |             selectedEdge=[selectedEdge,i];
321 |              mnx(k)=(edgeX1+edgeX2)/2;
322 |                mny(k)=(edgeY1+edgeY2)/2;
323 |         end
324 |         
325 |         
326 |         
327 |         
328 |         
329 |     end
330 |    
331 | end
332 |  
333 | %disp('k now is....');
334 | %disp(k);
335 | %disp('selected edges are.....');
336 | %disp(selectedEdge);
337 |  
338 |  
339 |  
340 |  
341 |  %if k<mn
342 |       
343 |     
344 |      
345 |   %   for i=k+1:mn
346 |    %       disp('getting in.......');
347 |          
348 |           
349 |     %      y = randsample(n,1);
350 |          % z = randsample(n,1);
351 |           
352 |      %     edgeX1=DT.Points(e(y,1),1);
353 |  
354 | % edgeY1=DT.Points(e(y,1),2);
355 |  %edgeX2=DT.Points(e(y,2),1);
356 |  %edgeY2=DT.Points(e(y,2),2);
357 |           
358 |           
359 |   %       mnx(i)=(edgeX1+edgeX2)/2;
360 |    %     mny(i)=(edgeY1+edgeY2)/2;
361 |     %     disp(mnx(i));
362 |      %    disp(mny(i));
363 |          
364 |           
365 |     % end
366 |      % k=mn;
367 |    
368 | % end
369 |  
370 |  
371 |  
372 |  
373 |  
374 |  
375 |  
376 |  
377 |  
378 | %replot with mobile nodes moved to the positions according to the
379 | %conditions
380 |  
381 |  
382 | DT = delaunayTriangulation(pts); 
383 | figure(5)
384 |  
385 | %disp(pts);
386 |  
387 | pl=triplot(DT,'-ob');
388 |  title 'Movable sensor nodes placed at the mid points of the longest edges';
389 | hold on;
390 |  
391 | for i=1:k
392 |     
393 |      plot(mnx(i),mny(i),'+r');
394 |      pts(end+1,1)=mnx(i);
395 | pts(end,2)=mny(i);
396 | 
397 |     
398 | end
399 |  disp(pts);
400 |  
401 | %graph is to be created here
402 |  
403 |  
404 |  
405 |  
406 |  
407 |  
408 |  
409 |  
410 |  
411 |  
412 | newDT = delaunayTriangulation(pts);
413 | %calling edges to get this delaunay graph
414 | e=newDT.edges;
415 | %creating grpah object to get graph of DT and minimum spanning tree with
416 | %all mobile nodes placed finally
417 |  
418 | %xCood and yCoord list to be updated with mobile nodes coordinates
419 |  
420 | for i=1:mn
421 |     
422 |     xCoord(n+1+i)=mnx(i);
423 |     yCoord(n+1+i)=mny(i);
424 |     
425 | end
426 |  
427 | %disp('size of points array');
428 | %disp(size(pts));
429 |  
430 |  
431 | for i=1:mn
432 | %     
433 | %     %disp('n+i+1   is..........................................................');
434 | %     %disp(n+i+1);
435 | %     SN(n+1+i).id=n+1+i; % sensor's ID number
436 | %     SN(n+1+i).radius=40; %assuming 20 meters
437 |    SN(n+1+i).x=pts(n+1+i,1);
438 |    SN(n+1+i).y=pts(n+1+i,2);
439 | %  
440 | %     SN(n+1+i).E=ME0;     % nodes energy levels (initially set to be equal to "Eo"
441 | %     SN(n+1+i).cond=1;   % States the current condition of the node. when the node is operational its value is =1 and when dead =0
442 | %     SN(n+1+i).dts=0;    % nodes distance from the sink
443 | %     SN(n+1+i).role=0;   % node acts as normal if the value is '0', if elected as a cluster head it  gets the value '1' (initially all nodes are normal)
444 | %     SN(n+1+i).pos=0;
445 | %     SN(n+1+i).closest=0;
446 | %     SN(n+1+i).prev=0;
447 | %     SN(n+1+i).dis=0;    % distance between two nodes headin towards to the cluster head from position 1
448 | %     SN(n+1+i).dis2=0;   % distance between two nodes headin towards to the cluster head from position 2
449 | %     SN(n+1+i).order=0;
450 | %     SN(n+1+i).sel=0;    % states if the node has already operated for this round or not (if 0 then no, if 1 then yes) 
451 | %     SN(n+1+i).rop=0;    % number of rounds node was operational
452 | %     SN(n+1+i).tel=0;    % states how many times the node was elected as a Cluster Head
453 | %     order(n+1+i)=0;
454 | %      SN(i).chainID=0;
455 | %      SN(i).weight=0;
456 | %  
457 | %  
458 | %     
459 |  end
460 |  
461 |  
462 | newDT = delaunayTriangulation(pts); 
463 | %calling edges to get this delaunay graph
464 | e=newDT.edges;
465 | %creating grpah object to get graph of DT and minimum spanning tree with
466 | %all mobile nodes placed finally
467 |  
468 | %xCood and yCoord list to be updated with mobile nodes coordinates
469 |  
470 | for i=1:mn
471 |     
472 |     xCoord(n+1+i)=mnx(i);
473 |     yCoord(n+1+i)=mny(i);
474 |     
475 | end
476 |  
477 | figure(6)
478 | pl=triplot(newDT,'-ob');
479 | title 'Retriangulating the network with mobile nodes'
480 | hold on;
481 |  
482 | 
483 | figure(7)
484 | hold on
485 | for i=1:n+1+mn
486 |     plot(SN(i).x, SN(i).y, 'ob');
487 | end
488 | 
489 | 
490 | % % Concatenate all points into a single array
491 | % all_x = [];
492 | % all_y = [];
493 | % 
494 | % for i=1:n+1
495 | %     all_x = [all_x; SN(i).x];
496 | %     all_y = [all_y; SN(i).y];
497 | % end
498 | % 
499 | % for i=1:mn
500 | %     all_x = [all_x; xCoord(n+1+i)];
501 | %     all_y = [all_y; yCoord(n+1+i)];
502 | % end
503 | % 
504 | % all_x = [all_x; sinkx];
505 | % all_y = [all_y; sinky];
506 | % 
507 | % figure(8)
508 | % % Plot all points together
509 | % plot(all_x, all_y, '*k');
510 | % 
511 | % % Add legend
512 | % legend('SN points', 'MN points', 'Sink point', 'All points');
513 | 
514 | disp(pts);
515 | % Remove sink coordinates from pts array
516 | pts = pts(pts(:,1) ~= sink(1) | pts(:,2) ~= sink(2), :);
517 | disp(pts);
518 | n=n+mn
519 | sink=[sinkx,sinky];
520 | disp('sink is..');
521 | disp(sink);
522 | % pts=[sink;pts];
523 | pts(end+1,1)=sinkx;
524 | pts(end,2)=sinky;
525 | disp(pts);
526 |  
527 | disp(n);
528 | for i=1:n+1
529 |    S(i).xd=pts(i,1);
530 |    S(i).yd=pts(i,2);
531 |       hold on;
532 | 
533 | end
534 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
535 | %%%%                           LEACH                               %%%%%%%%
536 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%   
537 | for h=1:1
538 |     S(n+1).xd=sinkx;
539 |     S(n+1).yd=sinky;
540 |     Et=0;
541 |     %% composing sensors
542 |     for i=1:1:n
543 |         XR(i)=S(i).xd;
544 |         YR(i)=S(i).yd;
545 |         distance=sqrt( (S(i).xd-(S(n+1).xd) )^2 + (S(i).yd-(S(n+1).yd) )^2 );
546 |         S(i).distance=distance;
547 |         S(i).G=0;
548 |         %initially there are no cluster heads only nodes
549 |         S(i).type='N';
550 |         S(i).E=Eo;
551 |         Et=Et+S(i).E;
552 |         %figure(h*10)
553 |         %  plot(S(i).xd,S(i).yd,'bo');
554 |         %  text(S(i).xd+1,S(i).yd-0.5,num2str(i));
555 |         %  hold on;
556 |     end
557 | 
558 | %plot(S(n+1).xd,S(n+1).yd,'o', 'MarkerSize', 12, 'MarkerFaceColor', 'r');
559 | %text(S(n+1).xd+1,S(n+1).yd-0.5,num2str(n+1));
560 | 
561 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
562 | countCHs=0;  %variable, counts the cluster head
563 | cluster=1;  %cluster is initialized as 1
564 | flag_first_dead=0; %flag tells the first node dead
565 | flag_half_dead=0;  %flag tells the 10th node dead
566 | flag_all_dead=0;  %flag tells all nodes dead
567 | first_dead=0;
568 | half_dead=0;
569 | all_dead=0;
570 | allive=n;
571 | %counter for bit transmitted to Bases Station and to Cluster Heads
572 | packets_TO_BS=0;
573 | packets_TO_CH=0;
574 | packets_TO_BS_per_round=0;
575 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
576 | 
577 | for r=0:1:rmax
578 |     figure(20)
579 |     clf
580 |     r
581 |     title('Normal nodes:Blue||CH:Red||Dead:Empty circle||Round no:'+string(r));
582 |     hold on
583 | 
584 |      line([50,50],[0,120],'color','green')
585 | %      line([0,100],[100,100],'color','green')
586 |     line([100,100],[100,0],'color','green')
587 |     line([0,100],[0,0],'color','green')
588 |     line([0, 100], [60, 60], 'color', 'green');
589 | 
590 |     line([0,0],[0,100],'color','green')
591 |     line([0, 0], [0, 120], 'color', 'green');
592 | %     line([0, 120], [100, 120], 'color', 'green');
593 | %     line([0, 120], [100, 120], 'color', 'green');
594 | line([0, 100], [120, 120], 'color', 'green');
595 | line([100, 100], [0, 120], 'color', 'green');
596 | 
597 | 
598 | 
599 | 
600 | 
601 |     packets_TO_BS_per_round=0;
602 |     %Operations for epochs
603 |     if(mod(r, round(1/p) )==0)
604 |         for i=1:1:n
605 |             S(i).G=0;
606 |             S(i).cl=0;
607 |         end
608 |     end
609 |    
610 |     %Number of dead nodes
611 |     dead=0;
612 |     
613 |     %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
614 |      for i=1:1:n
615 |         %checking if there is a dead node
616 |         if (S(i).E<=0)
617 |             plot(S(i).xd,S(i).yd,'o');            
618 |             dead=dead+1;
619 |             if (dead==1)
620 |               if(flag_first_dead==0)
621 |                  first_dead=r;
622 |                  flag_first_dead=1;
623 |               end
624 |             end
625 |             if(dead==0.5*n)
626 |               if(flag_half_dead==0)
627 |                   half_dead=r;
628 |                   flag_half_dead=1;
629 |               end
630 |             end
631 |             if(dead==n)
632 |               if(flag_all_dead==0)
633 |                   all_dead=r;
634 |                   flag_all_dead=1;
635 |               end
636 |             end
637 |         end
638 |         if S(i).E>0
639 |             S(i).type='N';
640 |         end
641 |     end
642 |     STATISTICS.DEAD(h,r+1)=dead;
643 |     STATISTICS.ALLIVE(h,r+1)=allive-dead;
644 |   %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
645 |     %head finding
646 |     ch1=0;ch2=0;ch3=0;ch4=0;ch=0; 
647 |     countCHs=0;
648 |     cluster=1;
649 |     for i=1:1:n
650 |         if(S(i).E>0)
651 |             temp_rand=rand;
652 |             if ( (S(i).G)<=0)
653 |                 
654 |                 %Election of Cluster Heads for normal nodes
655 |                 if ( temp_rand <= ( p/ ( 1 - p * mod(r,round(1/p)) )) )
656 |                     
657 |                     %countCHs=countCHs+1;
658 |                     %packets_TO_BS=packets_TO_BS+1;
659 |                     %packets_TO_BS_per_round=packets_TO_BS_per_round+1;
660 |                     %PACKETS_TO_BS(r+1)=packets_TO_BS;
661 |                     
662 |                     if(S(i).xd>0 && S(i).xd<=50 && S(i).yd>0 && S(i).yd<=60 && ch1==0)
663 |                         ch1=i;%msgbox('ch1')
664 |                         ch=i;
665 |                         %line([S(i).xd,SN(ch1).x],[S(i).yd,SN(ch1).y])
666 |                         countCHs=countCHs+1;
667 |                         packets_TO_BS=packets_TO_BS+1;
668 |                         packets_TO_BS_per_round=packets_TO_BS_per_round+1;
669 |                         PACKETS_TO_BS(r+1)=packets_TO_BS;
670 |                     end
671 |                     
672 |                     if(S(i).xd>0 && S(i).xd<=50 && S(i).yd>60 && S(i).yd<=120 && ch2==0)
673 |                         %line([S(i).xd,SN(ch2).x],[S(i).yd,SN(ch2).y])
674 |                         ch2=i;%msgbox('ch2')
675 |                         ch=i;
676 |                         countCHs=countCHs+1;
677 |                         packets_TO_BS=packets_TO_BS+1;
678 |                         packets_TO_BS_per_round=packets_TO_BS_per_round+1;
679 |                         PACKETS_TO_BS(r+1)=packets_TO_BS;
680 |                     end
681 |                     
682 |                     if(S(i).xd>50 &&S(i).xd<=100 && S(i).yd>60 &&S(i).yd<=120 && ch3==0)
683 | %                         line([S(i).xd,SN(ch4).x],[S(i).yd,SN(ch4).y])
684 |                         ch3=i;%msgbox('ch3')
685 |                         ch=i;
686 |                         countCHs=countCHs+1;
687 |                         packets_TO_BS=packets_TO_BS+1;
688 |                         packets_TO_BS_per_round=packets_TO_BS_per_round+1;
689 |                         PACKETS_TO_BS(r+1)=packets_TO_BS;
690 |                     end
691 | 
692 |                     if(S(i).xd>50 && S(i).xd<=100 && S(i).yd>0 && S(i).yd<=60&& ch4==0)
693 |                         %line([S(i).xd,SN(ch3).x],[S(i).yd,SN(ch3).y])
694 |                         ch4=i;%msgbox('ch4')
695 |                         ch=i;
696 |                         countCHs=countCHs+1;
697 |                         packets_TO_BS=packets_TO_BS+1;
698 |                         packets_TO_BS_per_round=packets_TO_BS_per_round+1;
699 |                         PACKETS_TO_BS(r+1)=packets_TO_BS;
700 |                     end
701 |                     if (ch>0)
702 |                         S(ch).type='C';
703 |                         S(ch).G=round(1/p)-1;
704 |                         C(cluster).xd=S(ch).xd;
705 |                         C(cluster).yd=S(ch).yd;
706 |                         %plot(S(ch).xd,S(ch).yd,'k*');
707 | 
708 |                         distance=sqrt( (S(ch).xd-(S(n+1).xd) )^2 + (S(ch).yd-(S(n+1).yd) )^2 );
709 |                         C(cluster).distance=distance;
710 |                         C(cluster).id=ch;
711 |                         X(cluster)=S(ch).xd;
712 |                         Y(cluster)=S(ch).yd;
713 |                         cluster=cluster+1;
714 | 
715 |                         %Calculation of Energy dissipated
716 |                         distance;
717 |                         if (distance>do)
718 |                             S(ch).E=S(ch).E- ( (ETX+EDA)*(4000) + Emp*4000*( distance*distance*distance*distance ));
719 |                         end
720 |                         if (distance<=do)
721 |                             S(ch).E=S(ch).E- ( (ETX+EDA)*(4000)  + Efs*4000*( distance * distance ));
722 |                         end
723 |                     end
724 |                     ch=0;
725 |                     if (ch1>0 && ch2>0 && ch3>0 &&ch4>0)
726 |                       % msgbox('break');
727 |                       %x=[ch1,ch2,ch3,ch4, cluster]
728 |                    
729 |                        break;
730 |                     end
731 |                     %x=[ch1,ch2,ch3,ch4, cluster]
732 |                 end
733 |     
734 |             end     
735 |         end
736 |     end
737 |    % Distance matrix initialization
738 | distMatrix = inf(cluster-1, cluster-1);
739 | 
740 | % Calculate distances between cluster heads
741 | for i = 1:cluster-1
742 |     for j = i+1:cluster-1
743 |         distMatrix(i, j) = sqrt((C(i).xd - C(j).xd)^2 + (C(i).yd - C(j).yd)^2);
744 |         distMatrix(j, i) = distMatrix(i, j);
745 |     end
746 | end
747 | 
748 | % Minimum spanning tree algorithm
749 | visited = zeros(1, cluster-1);
750 | visited(1) = 1;
751 | routeMatrix = zeros(cluster-1, cluster-1);
752 | 
753 | while sum(visited) < cluster-1
754 |     minDist = inf;
755 |     minIdx = 0;
756 |     
757 |     for i = 1:cluster-1
758 |         if visited(i)
759 |             % Find the cluster head with the shortest distance to the visited set
760 |             for j = 1:cluster-1
761 |                 if ~visited(j) && distMatrix(i, j) < minDist
762 |                     minDist = distMatrix(i, j);
763 |                     minIdx = j;
764 |                 end
765 |             end
766 |         end
767 |     end
768 |     
769 |     % Connect the cluster head to the visited set
770 |     routeMatrix(minIdx, find(visited == 1, 1)) = 1;
771 |     visited(minIdx) = 1;
772 | end
773 | 
774 | % Plotting the route
775 | for i = 1:cluster-1
776 |     for j = 1:cluster-1
777 |         if routeMatrix(i, j) == 1
778 |              line([C(i).xd, C(j).xd], [C(i).yd, C(j).yd], 'Color', 'r', 'LineStyle', '--');
779 |         end
780 |     end
781 | end
782 | 
783 | 
784 |     %head connection
785 | %     chs=[ch1,ch2,ch3,ch4];
786 | %     for i=1:3
787 | %         if chs(i)==0
788 | %             continue;
789 | %         end
790 | %         for j=i+1:4
791 | %             if(chs(j)==0)
792 | %                 continue;
793 | %             end
794 | %              plot([S(chs(i)).xd,S(chs(j)).xd],[S(chs(i)).yd,S(chs(j)).yd],'r--');break;
795 | %         end
796 | %     end
797 |     STATISTICS.COUNTCHS(h,r+1)=countCHs;
798 |     % or STATISTICS.COUNTCHS(h,r+1)=clster-1;
799 |      %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
800 |     %Election of Associated Cluster Head for Normal Nodes
801 |     plot(S(n+1).xd,S(n+1).yd,'o', 'MarkerSize', 12, 'MarkerFaceColor', 'r');
802 |    for i=1:1:n
803 |        if( S(i).type=='N' && S(i).E>0 )
804 |            if(cluster-1>=1)
805 |                 min_dis=sqrt( (S(i).xd-S(n+1).xd)^2 + (S(i).yd-S(n+1).yd)^2 );
806 |                 min_dis_cluster=0;
807 |                 for c=1:1:cluster-1
808 |                     temp=min(min_dis,sqrt( (S(i).xd-C(c).xd)^2 + (S(i).yd-C(c).yd)^2 ) );
809 |                    if ( temp<min_dis )
810 |                        min_dis=temp;
811 |                        min_dis_cluster=c;
812 |                    end
813 |                 end
814 |                %Calculating the culsterheads%
815 |                if(min_dis_cluster~=0)    
816 |                     min_dis;
817 |                     if (min_dis>do)
818 |                         S(i).E=S(i).E- ( ETX*(4000) + Emp*4000*( min_dis * min_dis * min_dis * min_dis)); 
819 |                     end
820 |                     if (min_dis<=do)
821 |                         S(i).E=S(i).E- ( ETX*(4000) + Efs*4000*( min_dis * min_dis)); 
822 |                     end
823 | 
824 |                     S(C(min_dis_cluster).id).E = S(C(min_dis_cluster).id).E- ( (ERX + EDA)*4000 ); 
825 | 
826 |                     if(S(i).type=='N')
827 |                         plot(S(i).xd,S(i).yd,'o', 'MarkerSize', 5, 'MarkerFaceColor', 'black');      
828 |                         line([S(i).xd,S(C(min_dis_cluster).id).xd],[S(i).yd,S(C(min_dis_cluster).id).yd]);
829 |                     elseif(S(i).type=='C')
830 |                         plot(S(i).xd,S(i).yd,'o', 'MarkerSize', 8, 'MarkerFaceColor', 'r');
831 |                        
832 | 
833 |                     else
834 |                         plot(S(i).xd,S(i).yd,'bo');
835 |                         line([S(i).xd,S(n+1).xd],[S(i).yd,S(n+1).yd]);
836 |                     end
837 |                     packets_TO_CH=packets_TO_CH+1;
838 |                else
839 |                     min_dis;
840 |                     if (min_dis>do)
841 |                         S(i).E=S(i).E- ( ETX*(4000) + Emp*4000*( min_dis * min_dis * min_dis * min_dis)); 
842 |                     end
843 |                     if (min_dis<=do)
844 |                         S(i).E=S(i).E- ( ETX*(4000) + Efs*4000*( min_dis * min_dis)); 
845 |                     end
846 |                     packets_TO_BS=packets_TO_BS+1;
847 |                     packets_TO_BS_per_round=packets_TO_BS_per_round+1;
848 |                     PACKETS_TO_BS(r+1)=packets_TO_BS;
849 |                      % Plot the line to the sink
850 |                 plot([S(i).xd, S(n+1).xd], [S(i).yd, S(n+1).yd], 'g--');
851 |                end
852 |                 S(i).min_dis=min_dis;
853 |                S(i).min_dis_cluster=min_dis_cluster;
854 |         else
855 |             min_dis=sqrt( (S(i).xd-S(n+1).xd)^2 + (S(i).yd-S(n+1).yd)^2 );
856 |             if (min_dis>do)
857 |                 S(i).E=S(i).E- ( ETX*(4000) + Emp*4000*( min_dis * min_dis * min_dis * min_dis)); 
858 |             end
859 |             if (min_dis<=do)
860 |                 S(i).E=S(i).E- ( ETX*(4000) + Efs*4000*( min_dis * min_dis)); 
861 |             end
862 |             packets_TO_BS=packets_TO_BS+1;
863 |             packets_TO_BS_per_round=packets_TO_BS_per_round+1;
864 |             
865 |        end
866 |   end
867 |        
868 |   if(S(i).type=='C'&&S(i).E>0)
869 |         plot(S(i).xd,S(i).yd,'o', 'MarkerSize', 8, 'MarkerFaceColor', 'r');
870 |   elseif(S(i).type~='N'&&S(i).E>0)
871 |         plot(S(i).xd,S(i).yd,'o', 'MarkerSize', 5, 'MarkerFaceColor', 'black');
872 |   elseif S(i).type == 'N' && S(i).E > 0 && S(i).min_dis_cluster == 0
873 |         plot(S(i).xd, S(i).yd, 'o', 'MarkerSize', 5, 'MarkerFaceColor', 'black');
874 |         line([S(i).xd,S(n+1).xd],[S(i).yd,S(n+1).yd],'Color','black');
875 |     
876 |   end
877 | 
878 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
879 | 
880 | %% Connection of Cluster head and Sink
881 |     cl_list=[0 0 0 0];
882 |     cl_sequence=[0 0 0 0];
883 |     cl_number=0;
884 |     for ii=1:n
885 |         if (S(ii).type == 'C' && S(ii).E>0)
886 |             cl_number=cl_number+1;
887 |             cl_list(cl_number)=ii;            
888 |         end
889 |     end
890 |     min_dis_cluster=0;
891 |     min_dis=999999999;
892 |     for c=1:1:cluster-1
893 |         %min_dis=sqrt( (S(cl_list(c)).xd-S(n+1).xd)^2 + (S(cl_list(c)).yd-S(n+1).yd)^2 );   
894 |         if cl_list(c)==0
895 |             break;        
896 |         end
897 |         temp=min(min_dis,sqrt( (S(cl_list(c)).xd-S(n+1).xd)^2 + (S(cl_list(c)).yd-S(n+1).yd)^2 ));
898 |            
899 |            if ( temp<min_dis )
900 |                min_dis=temp;
901 |                min_dis_cluster=c;
902 |            end
903 |            
904 |     end
905 |     cl_sequence(1)=min_dis_cluster;
906 |     if min_dis_cluster==0 
907 |         continue
908 |     end
909 |     plot([S(n+1).xd,S(cl_list(min_dis_cluster)).xd],[S(n+1).yd,S(cl_list(min_dis_cluster)).yd],'r--');
910 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
911 | 
912 | end
913 | STATISTICS.PACKETS_TO_CH(h,r+1)=packets_TO_CH;
914 | STATISTICS.PACKETS_TO_BS(h,r+1)=packets_TO_BS;
915 | STATISTICS.PACKETS_TO_BS_PER_ROUND(h,r+1)=packets_TO_BS_per_round;
916 | STATISTICS.THROUGHPUT(h,r+1)=STATISTICS.PACKETS_TO_BS(h,r+1)+STATISTICS.PACKETS_TO_CH(h,r+1);
917 | 
918 |  En=0;
919 | for i=1:n
920 |     if S(i).E<=0
921 |         continue;
922 |     end
923 |     En=En+S(i).E;
924 | end
925 | ENERGY(r+1)=En;
926 | STATISTICS.ENERGY(h,r+1)=En;
927 | 
928 | 
929 | end
930 | first_dead_LEACH(h)=first_dead
931 | half_dead_LEACH(h)=half_dead
932 | all_dead_LEACH(h)=all_dead
933 | 
934 | 
935 | % cluster head display-------
936 | 
937 | end 
938 | for r=0:rmax
939 |     STATISTICS.DEAD(h+1,r+1)=sum(STATISTICS.DEAD(:,r+1))/h;
940 |     STATISTICS.ALLIVE(h+1,r+1)=sum(STATISTICS.ALLIVE(:,r+1))/h;
941 |     STATISTICS.PACKETS_TO_CH(h+1,r+1)=sum(STATISTICS.PACKETS_TO_CH(:,r+1))/h;
942 |     STATISTICS.PACKETS_TO_BS(h+1,r+1)=sum(STATISTICS.PACKETS_TO_BS(:,r+1))/h;
943 |     STATISTICS.PACKETS_TO_BS_PER_ROUND(h+1,r+1)=sum(STATISTICS.PACKETS_TO_BS_PER_ROUND(:,r+1))/h;
944 |     STATISTICS.THROUGHPUT(h+1,r+1)=sum(STATISTICS.THROUGHPUT(:,r+1))/h;
945 |     STATISTICS.COUNTCHS(h+1,r+1)=sum(STATISTICS.COUNTCHS(:,r+1))/h;
946 |     STATISTICS.ENERGY(h+1,r+1)=sum(STATISTICS.ENERGY(:,r+1))/h;
947 | end
948 | 
949 | first_dead=sum(first_dead_LEACH)/h;
950 | half_dead=sum(half_dead_LEACH)/h;
951 | all_dead=sum(all_dead_LEACH)/h;
952 | 
953 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
954 | r=0:rmax;
955 | figure(21)
956 | plot(r,STATISTICS.DEAD(h+1,r+1));
957 | title('Dead Nodes')
958 | xlabel('No of Rounds')
959 | ylabel('Number of Dead Nodes')
960 | figure(22)
961 | plot(r,STATISTICS.ALLIVE(h+1,r+1));
962 | title('Live Nodes')
963 | xlabel('No of Rounds')
964 | ylabel('Number of live Nodes')
965 | figure(23)
966 | plot(r,STATISTICS.PACKETS_TO_BS(h+1,r+1));
967 | title('pkts to BS')
968 | xlabel('No of Rounds')
969 | ylabel('Number of packets')
970 | figure(24)
971 | plot(r,STATISTICS.PACKETS_TO_BS_PER_ROUND(h+1,r+1));
972 | title('pkts to BS per round')
973 | xlabel('No of Rounds')
974 | ylabel('Number of packets')
975 | figure(25)
976 | plot(r,STATISTICS.PACKETS_TO_CH(h+1,r+1));
977 | title('pkts to CH')
978 | xlabel('No of Rounds')
979 | ylabel('Number of packets')
980 | figure(26)
981 | plot(r,STATISTICS.THROUGHPUT(h+1,r+1));
982 | title('THROUGHPUT')
983 | xlabel('No of Rounds')
984 | ylabel('No of bits')
985 | figure(27)
986 | plot(r,STATISTICS.COUNTCHS(h+1,r+1));
987 | title('COUNTCHS')
988 | xlabel('No of Rounds')
989 | ylabel('Number of cluster head ')
990 | figure(28)
991 | plot(r,STATISTICS.ENERGY(h+1,r+1));
992 | title('Average Residual Energy') 
993 | xlabel('No of Rounds')
994 | ylabel('Energy in joules')


--------------------------------------------------------------------------------