Routing with Renewable Energy Management in Wireless Sensor Networks

. 2021 Jun 26;21(13):4376. doi: 10.3390/s21134376

Algorithm 1: REBORN
▷ Variables:
1: $a T i m e r_{i}$ ;	{Time spent in activity state}
2: $e T i m e r_{i}$ ;	{Time spent in energy-saving state}
3: $d i s c T i m e r_{i}$ ;	{Time spent in the discovery state}
4: $r e m T i m e A c t_{i}$ ;	{Remaining time for the node to exit the active state}
5: state := discovery;	{Current node state}
6: $r o u t e C o n f_{i}$ := false;	{Routing message received}
7: $s i n k D i s t_{i}$ ;	{Distance to the sink}
8: $g r i d I D_{i}$ ;	{Identification of the cell}
9: $m s g_{i}$ ;	{Identifier of incoming data messages}
▷ Input:
10: Sink node sends routing message
Action:
11: $s e n d R o u t e M s g (s i n k P o s_{i})$	{Sink initiates a controlled flooding}
▷ Input:
12: Regular nodes receive routing message (msg $_{R o u t e}$ )
Action:
13: if !routeConf $_{i}$ then	{Was message received?}
14: routeConf $_{i}$ := true;	{Confirmed message}
15: sinkDist $_{i}$ := getDist(msg $_{R o u t e}$ .sinkPos $_{i}$ );	{Compute distance of sink}
16: $s e n d R o u t e M s g (s i n k P o s_{i})$ ;	{Forward the message}
17: gridID := getGrid(nodePos);	{Compute the grid ID}
18: end if
▷ Input:
19: Regular nodes enter in discovery state
Action
20: discTimer $_{i}$ := Constant	{Update discTimer $_{i}$ value}
21: aTimer $_{i}$ := remTimerAct $_{i}$ := getTimeToSend();	{Compute the send time}
22: timer $_{d i s c T i m e r_{i}}$ .trigger()	{Time to node change the state}
23: sendDiscMessage(nodeID, gridID, remTimeAct, state, energyBat);
▷ Input:
24: Regular nodes receive discovery message (msg $_{D i s}$ )
Action
25: if state == discovery and msg $_{D i s}$ .state == active then	{High priority?}
26: eTimer $_{i}$ := msg $_{D i s}$ .remTimeAct; state := sleep;
27: else if state == msg $_{D i s}$ .state then {Are nodes in same state ?}
28: if energyBat < msg $_{D i s}$ .energyBat then	{Is my energy bigger ?}
29: eTimer := msg $_{D i s}$ .remTimeAct; state := sleep;
30: end if
31: end if
▷ Input:
32: Timer $_{d i s c T i m e r_{i}}$ fire
Action
33: state := active	{The elected node changes to active state}
▷ Input:
34: Elected nodes enter in active state
Action
35: discTimer $_{i}$ := aTimer $_{i}$ /6;	{Update discTimer $_{i}$ value}
36: Timer $_{a T i m e r_{i}}$ .trigger();	{Time to node change state}
37: Timer $_{a T i m e r_{i} / 2}$ .trigger();	{Time to node send the data message}
38: Timer $_{D i s c T i m e r_{i}}$ .trigger();	{Time for node to send the discovery message}
▷ Input:
39: Timer $_{D i s c T i m e r_{i}}$ fire
Action:
40: remTimeAct $_{i}$ := timer $_{a T i m e r}$ .remainingTime();	{Update remTimeAct $_{i}$ with rest time of aTimer $_{i}$ }
41: sendDiscMessage(nodeID, gridID, remTimeAct, state, energyBat);
▷ Input:
42: Timer $_{a T i m e r_{i} / 2}$ fire
Action:
43: sendDataMessage(data, msg $_{i}$ , sinkDist);
▷ Input:
44: Nodes in active state receive data message (msg $_{D a t}$ )
Action:
45: if sinkDist $_{i}$ < msg $_{D a t} . s i n k D i s t_{i}$ and !checkID( $m s g ._{D a t} . m s g_{i}$ ) then
46: sendDataMessage(msg $_{D a t}$ .date, msg. $_{D a t}$ .msg $_{i}$ , distSink);
47: msg $_{i}$ .add(msg. $_{D a t}$ . $m s g_{i}$ );	{Storage msg $_{i}$ }
48: end if
▷ Input:
49: Nodes not elected enter in the sleep state
Action:
50: timer $_{e T i m e r_{i}}$ .trigger();	{Time to node change state}
▷ Input:
51: Timer $_{a T i m e r}$ or Timer $_{e T i m e r_{i}}$ fire
Action:
52: state := discovery;	{Restart the process}