An Efficient Tree-based Self-Organizing protocol for Internet of Things ...

SPECIAL SECTION ON GREEN COMMUNICATIONS AND NETWORKING FOR 5G WIRELESS

Received May 1, 2016, accepted May 14, 2016, date of publication June 8, 2016, date of current version July 22, 2016. Digital Object Identifier 10.1109/ACCESS.2016.2578298

An Efficient Tree-Based Self-Organizing Protocol for Internet of Things TIE QIU1 , (Senior Member, IEEE), XIZE LIU1 , LIN FENG2 , YU ZHOU2 , AND KAIYU ZHENG1 , (Student Member, IEEE) 1 School 2 School

of Software, Dalian University of Technology, Dalian 116620, China of Innovation and Entrepreneurship, Dalian University of Technology, Dalian 116024, China

Corresponding author: L. Feng ([email protected]) This work was supported in part by the Fundamental Research Funds for the Central Universities under Grant DUT16QY27 and in part by the National Natural Science Foundation of China under Grant 61202443.

ABSTRACT Tree networks are widely applied in sensor networks of Internet of Things (IoTs). This paper proposes an efficient tree-based self-organizing protocol (ETSP) for sensor networks of IoTs. In ETSP, all nodes are divided into two kinds: network nodes and non-network nodes. Network nodes can broadcast packets to their neighboring nodes. Non-network nodes collect the broadcasted packets and determine whether to join the network. During the self-organizing process, we use different metrics, such as number of child nodes, hop, communication distance, and residual energy to reach available sink nodes’ weight; the node with max weight will be selected as a sink node. Non-network nodes can be turned into network nodes when they join the network successfully. Then, a tree-based network can be obtained one layer by one layer. The topology is adjusted dynamically to balance energy consumption and prolong network lifetime. We conduct experiments with NS2 to evaluate ETSP. Simulation results show that our proposed protocol can construct a reliable tree-based network quickly. With the network scale increasing, the self-organization time, average hop, and packet loss ratio will not increase more. Furthermore, the success rate of packet in ETSP is much higher compared with ad hoc on demand distance vector routing and destination sequenced distance vector routing. INDEX TERMS Internet of Things, self-organization, tree-based sensor networks, lifetime.

I. INTRODUCTION

Internet of Things (IoTs) [1], [2] enables objects to collect or exchange data using many network technologies, such as sensor networks, wireless communication, data collection [3]–[5], etc. Among them, sensor network is indispensable to IoTs. It has been widely used in localization [6], industrial automation, environmental monitoring [7] and other applications. Sensor networks consist of a lot of low-cost, low-power tiny sensor nodes which are randomly distributed. These nodes can communicate with each other to collect and forward sensing data. With the scale increasing and devices updating, the network system becomes more and more complex. The memory, energy and ability of computing are limited by network nodes [8], [9]. In order to maximize lifetime, many researchers [10] apply themselves to control network topology [11], build better data transmission route and balance energy consumption of nodes [12]–[14]. Tree network is essentially a combination of bus network and star network, which can prolong the lifetime of network. VOLUME 4, 2016

Therefore, how to build a tree-based network with a maximum lifetime for sensor networks of IoTs has become a critical issue at present. But choosing a real maximum lifetime tree from all extended trees is a NP-complete problem [15]. So in order to meet the requirement of real-time, we need to choose a sub-optimal network. In [16], Zhu et al. have proved that a tree-based network cannot be built within a polynomial time. They construct a spanning tree in polynomial time through subset division. Even in the worst case the tree can be constructed within an exponential time. WSTDO (Weighted Spanning Tree Distributed Optimization) [17] is a distributed data transmission technology based on spanning tree and the network performance depends on density of nodes. It achieves a better performance in sparse networks. Ye et al. in [18] have verified that without data aggregation the upper limit of all one-hop nodes’ energy consumption is 98%. LBT (Load-Balanced and energy-efficient Tree) can maximize the network lifetime. Authors take load-balancing and energy-efficient of one-hop nodes into account to construct

2169-3536 2016 IEEE. Translations and content mining are permitted for academic research only. Personal use is also permitted, but republication/redistribution requires IEEE permission. See http://www.ieee.org/publications_standards/publications/rights/index.html for more information.

3535

T. Qiu et al.: ETSP for IoTs

the tree-based network. Algorithm LBT can preserve that the energy consumption of the tree-based network is close to the upper limit, approximately. Data aggregation technology isn’t used in above literatures. So these methods increase the energy consumption and network load when data aggregation occurs. In this paper we use the data aggregation technology in tree-based network to reduce the energy consumption and network load. In this paper, an Efficient Self-organization Protocol (ETSP) in tree-based network is proposed. The network nodes (the nodes that have joined the network) are classified into three types: root node, sink node, sensor node. In the beginning of ETSP, there is only a root node whose hop is zero. Then, the root node searches child nodes by broadcasting packets. After receiving the broadcast packets, the neighboring non-network nodes record the topology information and use different metrics such as number of child nodes, hop, communication distance and residual energy to reach available sink nodes’ weight. Next, the node with max weight is selected as sink node. When non-network nodes join the network successfully, they can be turned into network nodes at once. Our proposed algorithm can build a treebased network quickly. In addition, we adjust the topology dynamically and remove the farthest child node to balance energy consumption and prolong the whole network lifetime. The rest of this paper is organized as follows: In Section II, we discuss the related work and research problem. The energy-efficient self-organization strategy for tree-based networks is presented in Section III. Section IV gives the implementation of ETSP. The experiments and experimental results are discussed in Section V. Section VI is the conclusion of this paper. II. RELATED WORK AND PROBLEM STATEMENT A. RELATED WORK

The strategies based on topology control can be divided into the three types: Multi-node transmit [19], Connected dominating set [20], Clustering algorithm [21]. Among them, clustering algorithm is widely used. LEACH (Low Energy Adaptive Clustering Hierarchy) [22] is one of clustering algorithms, which creates and maintains clusters to lower the energy of network. Each node uses a stochastic algorithm to determine whether it becomes a cluster head. The node with the maximum energy is selected as the cluster head. HEED (Hybrid Energy-Efficient Distributed Clustering) [23] is also based on clustering topology. Except for residual energy, HEED considers the number of neighboring nodes and degrees in cluster head selection. The network is stabile when there are no hot nodes during a period. However, LEACH and HEED still reelect the clusterheader after a period, which wastes some energy. In [24], Chen et al. propose an improved LEACH. In this algorithm, it consumes more energy consumption than LEACH when there is only one hop between cluster and BS (Base Station). A new algorithm named EEDC (Energy-Efficient Distancebased Clustering) is proposed in [25]. First EEDC builds 3536

a cluster-header candidate set based on the residual energy of nodes and then selects a best cluster-header from the candidate set based on distance. The simulation results show that EEDC outperforms than LEACH and HEED. Different form HEED, new cluster head is reelected when old cluster head needs to balance energy consumption in ECBDA (Energy efficient Cluster Based Data Aggregation) [26]. The selection of cluster-header isn’t periodic. In [27], Jin et al propose a new algorithm to build data transmission routes with multi-path disjoint protocol. The new algorithm improves the energyefficiency of nodes and ensures that the network has a higher QoS (Quality of Service). But each node contains multi-path that increases the complexity of the network management. We extend Energy-efficient Self-organization Routing Strategy (ESRS) [28] for tree-based wireless sensor networks which is proposed in our previous work and address the above problems to construct a reliable tree-based network quickly. B. PROBLEM STATEMENT

At present, there are three kinds of route algorithm of Ad hoc network: (i) Table driven routing algorithm [29]: DSDV (Destination Sequenced Distance Vector Routing) [30], WRP (Wireless Routing Protocol); (ii) Demand driven routing algorithm: AODV (Ad hoc On Demand Distance Vector Routing) [31], DSR (Dynamic Source Routing), ABR (Associativity Based Routing), SSA (Signal Stability Based Adaptive Routing), LBR (Link Life Based Routing); (iii) Layer type of area routing algorithm: CGSR (Clusterhead Gateway Switch Routing) [32], ZRP (Zone Routing Protocol). For AODV and DSDV, the success rate of packet declines significantly with the number of nodes increasing, therefore they are not suitable for large-scale sensor networks and the network performance will decrease rapidly with the increase of node number. Hence, we need a more reliable network model and route algorithm to improve the reliability of communication in large-scale network. Eq. 1 is an energy model [33]. Assuming that the distance between nodei and nodej is d and the packet length is L bits, the energy cost of sending L bits data is Ei,j (L, d) and Er,x (L, d) is the energy cost of receiving L bits data. Ec is the basic energy consumption of send-receive link. dcr is the threshold of communication distance. e1 and e2 are energy units, corresponding to d < dcr and d > dcr . The result of this energy model is determined by d in practical application. So we can select the closest node as sink node, which is good for reducing the energy consumption.
Ei,j (L, d) = Et,x (L, d) + Er,x (L, d) = L 2Ec + ed s ( e1 , S = 2 · · · if d < dcr e= (1) e2 , S = 4 · · · if d > dcr In addition, we also consider the average hop of network when selecting sink node. Figure 1 is a sensor VOLUME 4, 2016

T. Qiu et al.: ETSP for IoTs

between two nodes. The more hops there are, the more transmission times will be. With the increasing of transmission times the total energy consumption will increase. So we need to control the hop of network. If a sink node has more child nodes it will receive more packets and consume more energy during a certain period. So for balancing energy consumption we need to take number of child nodes into account to select sink node. According to Eq. 1, the distance between two nodes is considered and the energy is lower with the distance decreasing. We consider [34, eqs. 5 and 6] and balancing hop, residual energy, number of child nodes and distance between two nodes, and sink nodei ’s weight is given by Eq. (2). Wi =

FIGURE 1. A sensor network topology.

network topology. Node6 can communicate with Node5 and Node1. Node6 is closer to Node5. If Node6 selects Node5 as sink node its hop is (HNode1 + 2), else if Node6 selects Node1 as sink node its hop is (HNode1 +1). We assume that d1 = 6m, d2 = 7m, d = 12m, according to Eq. 1 Node6 selects Node5 as sink node is more energy-efficient. If d1 = 6m, d2 = 7m, d = 8m, Node6 selects Node1 as sink node is more energy-saving. So we need to take distance and hop of nodes into account to select sink node. The sink node selection also needs to take the number of child nodes into account. In Figure 1 we assume that Node6’s sink node can be Node1, Node4 or Node5, but Node1 is the best. Node1 has 4 child nodes and if Node6 selects Node1 that will increase the energy consumption of Node1 and shorten the lifetime of network. If Node6 selects Node5 or Node4 as sink node that can reduce the energy consumption and mitigate packet processing pressure of Node1. Here, we assume that residual energy of Node5 is more than Node4 and Node5 is better than Node4. For prolonging lifetime we choose Node5 as sink node. After a period of time Node6 can reelect Node4 as sink node to balance energy consumption of Node5 and Node4. During the self-organizing process of tree-based network we need to take distance, hop, number of child nodes and residual energy into account. But how to balance these factors and build a better tree-based network are research points of this paper.

β δ α + + λEi + Di Ni + 1 Hi + 1

(2)

Here, Wi is nodei ’s weight. Ei is nodei ’s residual energy. Di is the distance between current node and nodei . Ni is the number of nodei ’s child nodes. We define the hop of root node is 0 and other nodes’ hops are their sink nodes’ hops plus 1. Hi is the hop of nodei . α, β, λ and δ are normalized parameters of these four factors and they are defined as follows: if the maximum transmission distance is 15 m we set α = 15. If the maximum number of child nodes is 5 we set β = 6. The initial energy of node is random and if the maximum initial energy is 20 J we set λ = 1/20. If the maximum hop is 10 we set δ = 11. Nodes of network can be divided into three types: root node, sink node and sensor node. Root node is a special node whose energy is unlimited and it is active all the time. Root node is the first network node and at the beginning root node sends broadcast packets to search child nodes. Non-network node saves the broadcast packets and calculates the weight of sink nodes based on Eq. 2. Finally, non-network node selects the best sink node with maximum weight to join the network. If the best sink node refuses the non-network node to join the network, the non-network node needs to select the suboptimal sink node, third-optimal sink node until it has joined the network successfully. If the non-network node cannot join the network after scanning all available sink nodes, it needs to clear all available sink nodes’ information and then saves other broadcast packets to reelect an available sink node. Non-network node begins to select child nodes after joining the network. Centering on the root node we can construct a tree-based network quickly through broadcast searching and the tree-based network balances the hop, residual energy, number of child nodes and distance of nodes. B. DYNAMICALLY ADJUST TOPOLOGY

III. EFFICIENT TREE-BASED SELF-ORGANIZING PROTOCOL A. NETWORK SELF-ORGANIZATION

During the process of network construction, network nodes search child nodes through sending broadcast packets. Non-network nodes select sink node according to the received broadcast packets. The selection of sink node balances the hop, residual energy, number of child nodes and distance VOLUME 4, 2016

In the following two cases we have to reconstruct the network partially. Case 1 (Energy Consumption): The sink node not only gathers the data of its own sensor but also aggregates data of all its child nodes, so the energy consumption is quicker than sensor nodes. The farthest node will be deleted when the energy of the sink node drops below R%. R% is based on the residual energy of last topology changing, which means 3537

T. Qiu et al.: ETSP for IoTs

the sink node adds or removes a child node. Removing a child node equals sending packets to inform the child nodes to reelect sink node and at the same time delete the information of the child nodes from child node table. It is benefit to balance the energy consumption if the farthest child node joins in other branches of the network. In order to compute using Eq. 3 we have to know the number of child nodes N . A simple example: we assume N = 5 at the moment t0 and residual energy is E0 . After a certain time at t1 the residual energy is E1 and E1 = 5E0 /6. For balancing energy consumption, we delete the farthest child node. Here we assume that the farthest child node joins in other branches of the network and the number of child nodes N = 4. At moment t2 , the residual energy is E2 and E2 = 4E1 /5, we need to adjust the topology again for energy balance. R=

N N +1

(3)

There are 7 nodes as shown in Figure 1. In the beginning Node1 is the sink node of Node2, Node5 and Node6. After a period of time the residual energy of Node1 reduces one fourth and based on Eq. 3 we delete the farthest child node. Here we assume Node6 is the farthest child node. Node1 sends a packet to inform Node6 to reelect sink node. Node6 searches sink node through broadcast. After broadcast searching, Node6 receives the information of Node4, Node5 and Node1. According to Eq. 2, Node6 calculates the weight of following three types of sink nodes. (i) The weight of Node1 is the largest. Node6 keeps the state and other nodes do nothing. (ii) The weight of Node4 or Node5 is the largest. First Node6 sends a packet to Node1 to leave the network, and then sends packets to Node4 or Node5 to request joining the network. (iii) The weights of Node1 and Node5 are same or the weights of Node1 and Node4 are same, we need to compare the hop, ratio of residual energy, number of child nodes and distance. The priority selection standards are: less hop, greater ratio of ((residual energy)/(number of child node + 1)), less distance. So Node1 is better. Node1 is its current sink node so we need not do anything. (iv) The weights of Node4 and Node5 are same, we need to compare the hop, residual energy with child nodes number and distance. Here, we assume all factors of Node4 and Node5 are same, next we need to check their sink nodes. The sink node of Node5 is Node1 and Node1 is the sink node of Node6. Node6 reelects sink node is to balance the energy consumption of Node1. If Node6 reelects Node5 as its sink node, the length of the packet from Node5 to Node1 will increase. Furthermore, it increases the energy consumption of Node1 according to Eq. 1. However, Node4 isn’t in the branch of Node1 and if Node6 joins in the branch of Node4 that can help to balance the energy consumption of Node1. 3538

In Figure 1, we assume that Node6 selects Node5 as its sink node. After a period of time, Node1 cannot work as a sink node. Node5 needs to reelect a sink node and within one hop range there are no other nodes except for child nodes. Node5 broadcasts to inform all child nodes to reelect sink node. All child nodes can get the biggest weight of their available sink nodes based on Eq. 2 and then send the biggest weight to Node5. Node5 selects the biggest value from the received weights of all child nodes and informs the node to reelect sink node. Here we assume that Node6 is the selected node and Node6 reelects Node4 as its sink node. Node5 removes Node6 from its child node table and requests joining in the branch of Node6. During the process of network reorganization, if the hop of the sink node is changed it needs to inform all its child nodes to update their hops. Case 2 (Link Failure): Child node sends data packets to its sink node periodically and sink node also periodically sends response packets to its child nodes to ensure the links are connected. If a sink node has not received any data packet from a child node in a certain period it judges the link is unsuccessful and removes the child node from its child node table. If a child node has not received any response packet from its sink node in a certain period it will judge the link is unsuccessful and re-select sink node. C. NETWORK PERFORMANCE EVALUATE

The nodes of sensor networks are deployed randomly in a test area. All nodes have to construct a network quickly so the self-organizing efficiency is a very important factor [35]. We need to ensure the network is robust and the real-time performance of data transmission is high when sensor networks are collecting data. With the number of hops increasing, the forwarding time increase. Thus, the average hop of network and energy of nodes are important aspects to evaluate performance for a network. The network lifetime is divided into three types [36]: (i) FND (First Node Dies): The time from network starts to the first node dies. (ii) LND (Last Node Dies): The time from network starts to the last node dies. (iii) PND (Percent Nodes Die): The time from network starts to percent nodes die, for example, P% nodes die. The initial values of energy are different for each node. In this paper, we select PND and define the network is unavailable when some key nodes of the network died. IV. ALGORITHM DESIGN A. NETWORK SELF-ORGANIZATION 1) SELECT THE BEST SINK NODE

In the beginning of ETSP, many non-network nodes that are in sleep mode exit in the network. Then, one of the nonnetwork nodes builds a network and turns into a network node. At the same time, the network node sends some broadcast packets and switches into network monitor state. Next, non-network nodes which receive the broadcast packet start a timer and save the node ID of network node which sends the VOLUME 4, 2016

T. Qiu et al.: ETSP for IoTs

Algorithm 1 Select the Best Sink Node 1: i ← 0, max_weight ← 0, sink_index ← 0 2: while i < ava_sink_num do 3: calculate the weight W 4: optional_sink[i].weight ← W 5: i++ 6: if max_weight < W then 7: sink_index ← i 8: max_weight ← W 9: else if max_weight = W then 10: if optional_sink[i] is greater then 11: sink_index ← i 12: max_weight ← W 13: end if 14: end if 15: end while 16: Output:sink_index

broadcast packet in array optional_sink[]. The best sink node in array optional_sink[] is selected based on Eq. 2 until the timer expires. The detail algorithm is shown in Algorithm 3. Variable max_weight is used to record the maximum weight of all available sink nodes. Variable sink_index represents the index of sink node in array optional_sink[]. They are initialize to 0 in Line 1. Variable ava_sink_num records the number of available sink nodes. The node calculates the weight of all available sink nodes base on Eq. 2 and records the results in optional_sink[].weight (Lines 3-4). The node gets the index of the best sink node by comparing weights (Lines 6-8). If more than one nodes have the max weight at the same time, it elects the better one by the standard of less hops, greater ratio of R and less distance (Lines 9-12). Finally, it outputs the results (Line 16). There is one loop in Algorithm 1 to scan array optional_sink[] and the array length is ava_sink_num. ava_sink_num is determined by the limited density of networks, therefore the ava_sink_num is numerable and the complexity of Algorithm 1 is O(n). All nodes can select a best sink node rapidly. 2) NON-NETWORK NODES JOIN IN NETWORK

After selecting the best sink node, non-network nodes request to join the network. The related process is shown in Algorithm 2. Variable sink_index_tmp records the index of sink node in array optional_sink[]. Variable Eava is the residual energy of node. The boolean variable is_net_node identifies whether the node is a network node. According to the results of Algorithm 1, the non-network node sends a PT _JOIN _REQUEST (Packet of non-network node requests to join the network) packet to the best sink node (Line 1). Then the node starts a timer and saves the received packets during the timer (Line 2). When the network node receives the PT _JOIN _REQUEST packet, it checks whether the array child[] (An array to record the ID of current child nodes) VOLUME 4, 2016

is full. If the array child[] is full, the network node sends a PT _DENIED (Packet from sink node to deny the nonnetwork node joins the network) packet to the non-network node where the PT _JOIN _REQUEST packet is from. Otherwise, the network node will send a PT _ACCEPTED (Packet from sink node to accept the non-network node joins the network) packet. Finally, the non-network nodes that receive the reply of network decide whether or not to join the network based on the type of reply packet. When the received packet is PT _ACCEPTED, it becomes a network node (Line 4). If a node receives a PT _DENIED packet (Line 5), it needs to reselect a sub-optimal sink node (Lines 7-20). If max_weight is equal to 0 (Line 21), it means that there is no available sink node and the non-network node can’t join the network. Then it sets ava_sink_num to 0 and waits for other nodes’ searching (Lines 22-23). Otherwise, it updates sink_index and goes to Line 1 to rejoin network (Line 26). There is one loop to scan array optional_sink[] and the array length is ava_sink_num. ava_sink_num is numerable and the complexity of Algorithm 2 is O(n). B. REORGANIZATION OF HOT AREA 1) CHECKING RESIDUAL ENERGY OF SINK NODE

For prolonging the network lifetime and balancing energy consumption, ETSP needs to check the sink nodes’ residual energy. When a sink node adds or deletes a child node it updates Eorg (The residual energy of last topology change) with Eava . The farthest node will be deleted when the energy of the sink node drops below R%. The related algorithm is shown in Algorithm 3. Variable energy_check_timer records the timer value of energy check. Variable ENERGY _CHECK _TIMER records the initialize value of energy check timer. If energy_check_timer expires and the current energy drops below R% (Line 1), the sink node sends a PT _DELETE packet to the farthest child node (Line 2) and updates Eorg (Line 3). Otherwise it exists current procedure (Lines 4-6). If a sink node receives a PT _DELETE_OK packet from the child node (Line 7), it removes the record of farthest child node (Line 8) and updates the number of child nodes (Line 9). If N is equal to 0 (Line 11), it becomes a non-network node (Line 12). Otherwise, it resets the energy_check_timer for next round (Line 14). There is no loop in Algorithm 3, thus the is O(1). However, after sending a PT _DELETE (Packet from sink node to delete a child node) packet the node starts a timer to wait the reply and it will cost some time. If a node receives a PT _DELETE packet or doesn’t receive any reply packet during a period, it needs to reelect sink node. 2) PROCESS OF REORGANIZATION

The node deleted by its sink node due to low energy needs to rejoin the network. The related process is shown in Algorithm 4 and Algorithm 5. After initialization (Line 1), the node broadcasts PT _SINK _SEARCH messages and starts a timer (Line 2). Before the timer expires, if the node receives 3539

T. Qiu et al.: ETSP for IoTs

Algorithm 2 Non-Network Node Requests to Join in Network 1: Send PT _JION _REQUEST to node optional_sink[sink_index] 2: Start a timer. The node receives and saves packets during the timer 3: if the node receives a PT _ACCEPTED packet then 4: is_net_node ← true 5: else if the node received a PT _DENIED packet then 6: i ← 0, max_weight ← 0, sink_index_tmp ← 0; 7: while i < ava_sink_num do 8: if optional_sink[i].weight ≤ optional_sink[sink_index].weight && i 6 = sink_index then 9: if optional_sink[i].weight > max_weight then 10: sink_index_tmp ← i 11: max_weight ← optional_sink[i].weight 12: else if optional_sink[i].weight = max_weight then 13: if optional_sink[i] is greater then 14: sink_index_tmp ← i 15: max_weight ← optional_sink[i].weight 16: end if 17: end if 18: end if 19: i++ 20: end while 21: if max_weight = 0 then 22: ava_sink_num ← 0 23: return 24: else 25: sink_index ← sink_index_tmp 26: go to Line 1 27: end if 28: end if

a reply packet ACK from sink node (Line 5), it saves node ID in array optional_sink[] (Line 6) and updates ava_sink_num (Line 7). After the broadcast searching, if ava_sink_num is equal to 0 (Line 10), it means that there is no available sink node within one hop range. If the node is a non-network node, it goes to Line 1 to keep searching (Line 12). Otherwise, it can select the best sink node from its child nodes by executing Algorithm 5 (Line 14). If ava_sink_num is more than 0 (Line 16), it carries out the procedures in Algorithms 1 and 2 to join the network (Line 17). If the node’s hop is changed after being a network node, it needs to inform its child nodes to update their hops before existing current procedure (Lines 18-19). There is one loop in the Algorithm 4. The total costs are the times of sending PT _SINK _SEARCH (Broadcast packet of non-network node to search available sink node) packets and it is limited. So the complexity of Algorithm 4 is O(n). 3540

Algorithm 3 Check Energy Consumption of Sink Node 1: if energy_check_timer = 0 && (Eava /Eorg ) ≤ (R = N /(N + 1)) then 2: send a PT _DELETE packet to the farthest child node 3: Eorg ← Eava 4: else 5: return 6: end if 7: if sink node receives PT _DELETE_OK then 8: remove the farthest child node’s record 9: N ←N −1 10: end if 11: if N = 0 then 12: is_net_node ← false 13: else 14: energy_check_timer ← ENERGY _CHECK _TIMER 15: end if Algorithm 4 Reorganizing the Hot Area 1: ava_sink_num ← 0, sink_index ← −1, i ← 0, is_sink_node ← false 2: Broadcast PT _SINK _SEARCH and start a timer 3: 4: 5: 6: 7:

Before timer expires if the node receives ACK then update optional_sink[] ava_sink_num++ 8: end if 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21:

if ava_sink_num = 0 then if is_net_node = false then go to Line 1 else execute algorithm 5 end if else execute Algorithm 1 and 2 if node’s hop is changed then inform child nodes to update hop end if end if

But there is a certain time interval between two packets’ sending and it consumes some time. In Algorithm 4, if there is no available sink node within one hop range except for child nodes, the node ought to inform all its child nodes to reorganize. After that it selects a best sink node from its child nodes. The detail information is shown in Algorithm 5. Variable max_child_weight is the max weight of all child nodes. The weight of child node is the maximum weight of its available sink nodes. Variable max_child_weight_index is the index of max_child_weight in array child[]. At first, the sink node needs to clear array VOLUME 4, 2016

T. Qiu et al.: ETSP for IoTs

Algorithm 5 Network for the Child Nodes 1: clear array child[] 2: send PT _REELECT _SINK to the child nodes 3: start a timer 4: if a node receives PT _REELECT _SINK then 5: ava_sink_num ← 0 and clears optional_sink[]; 6: broadcast PT _SINK _SEARCH 7: calculate the weights of sink nodes; 8: send the biggest weight is to the sink node 9: end if 10: the sink node selects the maximum weight from child[] 11: send PT _REJOIN _REQUEST to child[max_child_weight_index] 12: if a child node receives PT _REJOIN _REQUEST then 13: is_net_node ← false 14: execute algorithm 2 15: if is_net_node = true then 16: add the old sink node to its child node table 17: send PT _REJOIN _OK to the old sink node 18: else 19: is_net_node ← true 20: sent PT _REJOIN _FAILED to the old sink node 21: end if 22: end if 23: if sink node receives PT _REJOIN _OK then 24: delete child[max_child_weight_index] 25: is_net_node ← true 26: return 27: else if sink node receives PT _REJOIN _FAILED then 28: i ← 0, max_child_weight ← 0 29: while i ≤ N do 30: if child[i].weight ≤ child[max_child_weight_index].weight && i 6= max_child_weight_index then 31: if child[i].weight > max_child_weight then 32: max_child_weight_index ← i 33: max_child_weight ← child[i].weight 34: else if child[i].weight = max_child_weight then 35: max_child_weight_index ← i 36: max_child_weight ← child[i].weight 37: end if 38: i++ 39: end if 40: end while 41: end if 42: if max_child_weight = 0 then 43: return 44: else 45: sent PT _REJOIN _REQUEST to child[max_child_weight_index] 46: go to Line 12; 47: end if

VOLUME 4, 2016

child[] (Line 1), then it sends a PT _REELECT _SINK packet to all the child nodes for reelecting sink node (Line 2). At the same time, it starts a timer (Line 3). If a node receives a PT _REELECT _SINK packet from its sink node (Line 4), it sets ava_sink_num to 0 and clears optional_sink[] (Line 5). Then it broadcasts PT _SINK _SEARCH messages (Line 6). After that, the child node needs to calculate the weights of all available sink nodes according to Eq. 2 (Line 7) and sends the biggest weight to its sink node (Line 8). The sink node needs to record the received information in array child[] and select the maximum weight when the timer expires (Line 10). Then it sends a PT _REJOIN _REQUEST packet to node child[max_child_weight_index] (Line 11). When the child node receives a PT _REJOIN _REQUEST packet (Line 12), it needs to become a non-network node and join the network by executing Algorithm 2 (Lines 13-14). If the node succeeds in rejoining the network (Line 15), it adds the original sink node to its child node table and sends a PT _REJOIN _OK packet to the original sink node (Lines 16-17). Otherwise it becomes a network node and replays a PT _REJOIN _FAILED packet to the original sink node (Lines 19-20). If the sink node receives a PT _REJOIN _OK packet, go to Line 16 (Line 14), it supposes to delete child node child[max_child_weight_index] from the child node table and sets child[max_child_weight_index] as its sink node (Lines 23-24). It becomes a network node and sends packets to inform its child nodes to update their hops (Line 25). If the sink node receives a PT _REJOIN _FAILED packet it needs to select a sub-optimal child node (Lines 30-41). If max_child_weight is equal to 0 (Line 44), it means there is no available child nodes and the reconstruction fails, it exists current procedure to reelect available child nodes (Line 45). Otherwise it sends a PT _REJOIN _REQUEST packet to child[max_child_weight_index] and goes to Line 12 (Lines 47-49). There are two loops in Algorithm 5, it scans the array optional_sink[] and the array length is ava_sink_num at first, so the complexity is O(n). The times of second loop is the number of child nodes. The number of child nodes is less than the length of array child[]. In conclusion, the maximum algorithm complexity in ETSP is O(n), which is similar to AODV and DSDV. V. SIMULATION AND ANALYSIS

In order to validate our proposed model, we utilized NS2 to simulate. The new ETSP protocol has three functions: self-organize tree-based network, balance energy consumption, reelect sink node. TABLE 1 lists the simulation parameters. Before building a tree-based network we need to set parameters based on TABLE 1. According to TABLE 1, the maximum communication radius is 15 m so α is 15. The maximum number of child nodes is 10 so β is 11. The maximum initenergy is 29 J so λ is 1/29. The maximum hop is 10 so δ is 11.

3541

T. Qiu et al.: ETSP for IoTs

FIGURE 2. Topology of self-organization. (a) Root coordinates: (0,0). (b) Root coordinates: (50,50).

TABLE 1. Simulation parameters.

TABLE 2. Experiment settings.

The topology of ETSP is given in Fig. 2 according to the information of self-organization process. In the simulation, 100 sensor nodes are randomly deployed in the area of 100m*100m. In Fig. 2a, the root rode whose coordinates are (0,0) is in the border of network. While in Fig. 2b, the root node is located at the center of the simulation area. It can be seen that the results of self-organization are different due to the differ of root node’s location, but every node succeeds in joining the network. For the topology in Fig. 2b, the average hop is 4.35, less than 8.02 hops in Fig. 2a. Furthermore, the re-organization time is 3.03 s, faster than 4.62 s in Fig. 2a. The average energy consumption is 0.34J , less than 0.36J in Fig. 2a. Thus, ETSP can achieves a better performance if the root node is in the center of network. In order to verify the efficiency of ETSP, five groups experiments based on the different scales are conducted. The experiment settings are shown in TABLE 2. In each group, we do five experiments whose results are shown in Fig. 3, Fig. 4, Fig. 5, Fig. 6, and Fig. 7. Hop indicates that the

selection of sink node is based on the least hop which between the node and available sink node. Distance indicates that the selection of sink node is based on the least distance between the node and available sink node. Left Energy indicates that the selection of sink node is based on the maximum residual energy of available sink node. Child Number indicates that the selection of sink node is based on the number of each child node’s available sink node. ETSP indicates that the selection of sink node is based on Eq. 2 and takes the four factors into account. It can be observed that they are all linearly increasing with node number increasing in Fig. 3. But the slope of selforganization time in ETSP is smaller. Therefore ETSP can construct a reliable tree-based network quickly in the large scale network. This process will be faster if the root node in the center of network. In Fig. 4, the increasing trends of average hop are similar except for the networks based on Distance and Left Energy. They are lager when the node number is over 500. Thus, they need more transmission times and energy consumption increases. If the root node is located at the center of network, it needs less average hop to construct a network, which speeds up the self-organization process. Network lifetime which illustrated in Fig. 5 is limited by energy consumption. The network based on Hop has the longest lifetime due to sending less packets. While ETSP’s lifetime is a little shorter than others. We can conclude from Fig. 5a and Fig. 5b that the network lifetime is longer when the root node in the center.

3542

VOLUME 4, 2016

T. Qiu et al.: ETSP for IoTs

FIGURE 3. Relationship between Self-organization Time and Number of Nodes. (a) Root Node in the border. (b) Root Node in the center.

FIGURE 4. Relationship between Average Hop and Number of Nodes. (a) Root Node in the border. (b) Root Node in the center.

FIGURE 5. Relationship between Network Lifetime and Number of Nodes. (a) Root Node in the border. (b) Root Node in the center.

FIGURE 6. Relationship between Number of Send Packet and Number of Nodes. (a) Root Node in the border. (b) Root Node in the center.

It can be seen in Fig. 6, for the network based on Hop, the number of send packets is less than others. Thus, it decreases node energy consumption and prolongs the network time.

VOLUME 4, 2016

While ETSP is similar to the network based on Distance, Left Energy and Child Number. Obviously, the location of root node doesn’t affect the number of packets. After constructing

3543

T. Qiu et al.: ETSP for IoTs

FIGURE 7. Relationship between Success Rate of Packet and Number of Nodes. (a) Root Node in the border. (b) Root Node in the center.

FIGURE 8. Performance Comparison of Three Route Algorithms. (a) Network lifetime. (b) Success rate of packet.

a network the nodes begin to send and receive data, packet loss is inevitable in this process. The performance of success rate of packet is one of the most critical indicators for a routing protocol. It can be observed that the network based on Child Number and Hop are lower than ETSP in Fig. 7. With the network scale increasing, the success rate of packet in ETSP doesn’t decline significantly and it’s over 92%. From the simulation results we know that: the network based on Hop can get longer lifetime. However its throughput and success rate of packet is lower. The network based on Distance can get larger throughput and higher success rate of packet, but its self-organization time is longer and average hop is bigger. The network based on Left Energy is worse and its self-organization time is longer and average hop is bigger than the network based on Distance. The network based on Child Number sends less packets and its success rate of packet is lower. The network based on ETSP balance distance, hop, number of child nodes and residual energy. The results in Figure 4 reveal that ETSP can construct a tree-based network quickly. With the network scale increasing, the selforganization time, average hop and packet loss ratio won’t increase repaidly. During the process of simulation experiment, the sink nodes are about 50% of all nodes and key nodes are less than 50%. So we set P = 50 is feasible. Compared with each other between Fig. 3a and Fig. 3b, Fig. 4a and Fig. 4b respectively, we can see that the network is worse when the root node in the border. The network based on Eq. 2 3544

is reasonable. Although the network lifetime is shorter, the self-organization time, network average hop, packet number and success rate of packet are balanced. In Fig. 8, we evaluate the performance of ETSP, AODV and DSDV with different number of sensor nodes. The root node is located in the center of topology. It can be seen that the network lifetime of ETSP is longer than DSDV, because it periodically checks the residual energy of sink node and reorganize the hot area to achieve energy consumption. What’s more, the success rate of packet in ETSP is further higher than AODV and DSDV, it keeps stable with the number of sensor nodes increasing. Thus, the network constructed by ETSP is reliable. VI. CONCLUSION

In this paper, we propose an efficient self-organization protocol named ETSP for sensor networks of IoTs. ETSP saves more energy and has a longer network lifetime by constructing a tree-based network quickly. We use the weight of nodes, including residual energy, hop, number of child nodes and distance between the nodes, to determine whether the node can be a sink node. Thus the depth of tree is optimized by using ETSP. During the process of data transmission, the network topology changes dynamically. Each sink node will be dynamically reselected due to the energy consumption of sink nodes is faster than other nodes. The simulation results show that ETSP is able to build reliable tree-based networks, VOLUME 4, 2016

T. Qiu et al.: ETSP for IoTs

reduces the energy consumption and prolongs the lifetime of sensor networks. REFERENCES [1] D. Zhang, S. Zhao, L. T. Yang, M. Chen, Y. Wang, and H. Liu, ‘‘NextMe: Localization using cellular traces in Internet of Things,’’ IEEE Trans. Ind. Informat., vol. 11, no. 2, pp. 302–312, Apr. 2015. [2] H. Ning, H. Liu, and L. T. Yang, ‘‘Aggregated-proof based hierarchical authentication scheme for the Internet of Things,’’ IEEE Trans. Parallel Distrib. Syst., vol. 26, no. 3, pp. 657–667, Mar. 2015. [3] L. Atzori, A. Iera, and G. Morabito, ‘‘The Internet of Things: A survey,’’ Comput. Netw., vol. 54, no. 15, pp. 2787–2805, Oct. 2010. [4] M. Turkanović, B. Brumen, and M. Hölbl, ‘‘A novel user authentication and key agreement scheme for heterogeneous ad hoc wireless sensor networks, based on the Internet of Things notion,’’ Ad Hoc Netw., vol. 20, pp. 96–112, Sep. 2014. [5] C. W. Tsai, C. F. Lai, and A. V. Vasilakos, ‘‘Future Internet of Things: Open issues and challenges,’’ Wireless Netw., vol. 20, no. 8, pp. 2201–2217, 2014. [6] G. Han, J. Jiang, C. Zhang, T. Duong, M. Guizani, and G. Karagiannidis, ‘‘A survey on mobile anchor node assisted localization in wireless sensor networks,’’ IEEE Commun. Surveys Tuts., to be published. [7] S. Lu, Z. Wang, Z. Wang, and S. Zhou, ‘‘Throughput of underwater wireless ad hoc networks with random access: A physical layer perspective,’’ IEEE Trans. Wireless Commun., vol. 14, no. 11, pp. 6257–6268, Nov. 2015. [8] J. A. Khan, H. K. Qureshi, and A. Iqbal, ‘‘Energy management in wireless sensor networks: A survey,’’ Comput. Elect. Eng., vol. 41, pp. 159–176, Jan. 2015. [9] R. Silva, J. S. Silva, and F. Boavida, ‘‘Mobility in wireless sensor networks—Survey and proposal,’’ Comput. Commun., vol. 52, pp. 1–20, Oct. 2014. [10] G. Han, J. Jiang, N. Bao, L. Wan, and M. Guizani, ‘‘Routing protocols for underwater wireless sensor networks,’’ IEEE Commun. Mag., vol. 53, no. 11, pp. 72–78, Nov. 2015. [11] T. Qiu, L. Chi, W. Guo, and Y. Zhang, ‘‘STETS: A novel energy-efficient time synchronization scheme based on embedded networking devices,’’ Microprocess. Microsyst., vol. 39, no. 8, pp. 1285–1295, 2015. [12] S. Lu, V. H. Nascimento, J. Sun, and Z. Wang, ‘‘Sparsity-aware adaptive link combination approach over distributed networks,’’ Electron. Lett., vol. 50, no. 18, pp. 1285–1287, 2014. [13] G. Han, A. Qian, J. Jiang, N. Sun, and L. Liu, ‘‘A grid-based joint routing and charging algorithm for industrial wireless rechargeable sensor networks,’’ Comput. Netw., vol. 101, pp. 19–28, Jun. 2016. [14] T. Qiu, D. Luo, F. Xia, N. Deonauth, W. Si, and A. Tolb, ‘‘A greedy model with small world for improving the robustness of heterogeneous Internet of Things,’’ Comput. Netw., vol. 101, pp. 127–143, Jun. 2016. [15] Y. Wu, S. Fahmy, and N. B. Shroff, ‘‘On the construction of a maximumlifetime data gathering tree in sensor networks: NP-completeness and approximation algorithm,’’ in Proc. IEEE INFOCOM, 27th Int. Conf. Comput. Commun., Apr. 2008, pp. 1013–1021. [16] X. Zhu, X. Wu, and G. Chen, ‘‘An exact algorithm for maximum lifetime data gathering tree without aggregation in wireless sensor networks,’’ Wireless Netw., vol. 21, no. 1, pp. 281–295, 2015. [17] L. Carr-Motyčková and D. Dryml, ‘‘Distributed energy efficient data gathering without aggregation via spanning tree optimization,’’ in Proc. 12th Int. Conf. Ad-Hoc, Mobile, Wireless Netw., 2013, pp. 87–98. [18] J. Ye et al., ‘‘Lifetime optimization by load-balanced and energy efficient tree in wireless sensor networks,’’ Mobile Netw. Appl., vol. 18, no. 4, pp. 488–499, 2013. [19] O. Liang, A. Sekercioglu, and N. Mani, ‘‘Gateway multipoint relays-an MPR-based broadcast algorithm for ad hoc networks,’’ in Proc. 10th IEEE Singapore Int. Conf. Commun. Syst., Oct./Nov. 2006, pp. 1–6. [20] M. Rai, S. Verma, and S. Tapaswi, ‘‘A power aware minimum connected dominating set for wireless sensor networks,’’ J. Netw., vol. 4, no. 6, pp. 511–519, 2009. [21] O. Dagdeviren, K. Erciyes, and D. Cokuslu, ‘‘A merging clustering algorithm for mobile ad hoc networks,’’ in Proc. Int. Conf. Comput. Sci. Appl., 2006, pp. 681–690. [22] W. B. Heinzelman, A. P. Chandrakasan, and H. Balakrishnan, ‘‘An application-specific protocol architecture for wireless microsensor networks,’’ IEEE Trans. Wireless Commun., vol. 1, no. 4, pp. 660–670, Oct. 2002. VOLUME 4, 2016

[23] O. Younis and S. Fahmy, ‘‘Distributed clustering in ad-hoc sensor networks: A hybrid, energy-efficient approach,’’ in Proc. 23rd Annu. Joint Conf. IEEE Comput. Commun. Soc., Mar. 2004, pp. 629–640. [24] Y. L. Chen, N. C. Wang, Y. N. Shih, and J. S. Lin, ‘‘A novel energy-efficient and distance-based clustering approach for wireless sensor networks,’’ Wireless Pers. Commun., vol. 75, no. 1, pp. 349–368, 2014. [25] O. Younis and S. Fahmy, ‘‘Distributed clustering in ad-hoc sensor networks: A hybrid, energy-efficient approach,’’ in Proc. IEEE INFOCOM, 2004, pp. 629–640. [26] S. S. Ranjani, S. R. Krishnan, C. Thangaraj, and K. V. Devi, ‘‘Achieving energy conservation by cluster based data aggregation in wireless sensor networks,’’ Wireless Pers. Commun., vol. 73, no. 3, pp. 731–751, 2013. [27] R.-C. Jin, T. Gao, J.-Y. Song, J.-Y. Zou, and L.-D. Wang, ‘‘Passive clusterbased multipath routing protocol for wireless sensor networks,’’ Wireless Netw., vol. 19, no. 8, pp. 1851–1866, 2013. [28] L. Feng, Y. Zhou, and T. Qiu, ‘‘An energy-efficient self-organization routing strategy in tree networks,’’ in Proc. 8th Int. Conf. Mobile Multimedia Commun., 2015, pp. 233–236. [29] B. S. Manoj and C. S. R. Murthy, ‘‘On the use of out-of-band signaling in ad hoc wireless networks,’’ Comput. Commun., vol. 26, no. 12, pp. 1405–1414, 2003. [30] E. C. Perkins and P. Bhagwat, ‘‘Highly dynamic destination-sequenced distance-vector routing (DSDV) for mobile computers,’’ ACM SIGCOMM Comput. Commun. Rev., vol. 24, no. 4, pp. 234–244, 1994. [31] C. Perkins, E. Belding-Royer, and S. Das, Ad hoc On-Demand Distance Vector (AODV) Routing, document RFC 3561, 2003. [32] C. C. Chiang, H. K. Wu, W. T. Liu, and M. Gerla, ‘‘Routing in clustered multihop, mobile wireless networks with fading channel,’’ in Proc. IEEE SICON, Apr. 2014, pp. 177–186. [33] K. Khamforoosh, ‘‘Clustered balanced minimum spanning tree for routing and energy reduction in wireless sensor networks,’’ in Proc. IEEE Symp. Wireless Technol. Appl., Sep. 2011, pp. 56–59. [34] H. Zhang, P. Chen, and S. Gong, ‘‘Weighted spanning tree clustering routing algorithm based on LEACH,’’ in Proc. 2nd Int. Conf. Future Comput. Commun., 2010, pp. 2223–2227. [35] C. Santhi and D. A. Sharmila, ‘‘A self-organized location aware energy efficient protocol for wireless sensor networks,’’ Comput. Elect. Eng., vol. 41, pp. 265–274, Jan. 2015. [36] A. Avokh and G. Mirjalily, ‘‘Dynamic balanced spanning tree (DBST) for data aggregation in wireless sensor networks,’’ in Proc. 5th Int. Symp. Telecommun., 2010, pp. 391–396.

TIE QIU (M’12–SM’16) received the B.E. degree from the Inner Mongolia University of Technology, China, in 2003, and the Ph.D. and M.Sc. degrees from the Dalian University of Technology (DUT), in 2005 and 2012, respectively. He is currently an Associate Professor with the School of Software, DUT, China. He was a Visiting Professor of Electrical and Computer Engineering with Iowa State University, USA, from 2014 to 2015. He is as an Editorial Board Member of the Journal of Advanced Computer Science and Technology, a Gest Editor of computers and electrical engineering (Elsevier journal) and ad hoc networks (Elsevier journal), a Program Chair of iThings2016, a TPC Member of Industrial IoT2015 and ICSN16, a Workshop Chair of CISIS13 and ICCMSE15, a Special Session Chair of WCC 2012 and CSA13, and a TPC Member of AIA13, EEC14, EEC15, and EEC16. He has authored or co-authored six books and over 50 scientific papers in international journals and conference proceedings. He has contributed to the development of two copyrighted software systems and invented eight patents. He is a Senior Member of China Computer Federation. 3545

T. Qiu et al.: ETSP for IoTs

XIZE LIU is currently pursuing the bachelor’s degree with the School of Software, Dalian University of Technology (DUT), Dalian, China. He is an outstanding student of DUT and has joined in several technology innovations. His research interests cover embedded system and Internet of Things.

LIN FENG received the B.S. degree in electronic technology, the M.S. degree in power engineering, and the Ph.D. degree in mechanical design and theory from the Dalian University of Technology, China, in 1992, 1995, and 2004, respectively. He is currently a Professor and Doctoral Supervisor with the School of Innovation entrepreneurship, Dalian University of Technology. His research interests include intelligent image processing, robotics, data mining, and embedded systems.

3546

YU ZHOU received the bachelor’s degree in software engineering and the master’s degree in computer application technology from the Dalian University of Technology. He was involved in research on embedded system and wireless sensor networks. He has published three books and three papers. He was with the Software and Service Group, Intela– ŕs Asia-Pacific Research Center, where he was involved in the development of software guard extension and the research on application enclave of the Windows and Linux system. KAIYU ZHENG received the B.E. degree from the Dalian University of Technology (DUT), China, in 2014. He is currently pursuing the master’s degree with the School of Software, DUT, China. He is an Excellent Graduate Student of DUT and has been awarded several scholarships in academic excellence and technology innovation. He participated in Open Source Hardware and Embedded Computing Contest 2012 and won the First Prize. His research interests cover embedded system and Internet of Things.

VOLUME 4, 2016