An Energy Efficient Synchronization Protocol for Target Tracking in Wireless Sensor Array Networks

Abstract

Time synchronization is an important middleware function that supports the Quality of Service (QoS) of systems in wireless sensor array networks. Instead of providing high synchronization accuracy for all application scenarios, we argue that synchronization protocols should be application specific. In this paper, we exploit the synchronization requirements of target-tracking systems in wireless sensor array networks and propose an energy-efficient Sensor Array Synchronization Protocol (SASP), which provides the required synchronization accuracy to guarantee the QoS. Specifically, when no target appears, to guarantee system lifetime, coarse synchronization is achieved with little overhead by piggybacking time information onto periodical network maintenance packets. Once targets appear, SASP achieves high inter-array and relatively higher intra-array synchronization accuracy rather than the traditional network-wide high accuracy on average. In this way, it guarantees reliable communication and accurate data fusion, while reducing energy consumption. Theoretical analysis and extensive evaluations show the effectiveness of the proposed protocol.

1. Introduction

Wireless Sensor Networks (WSNs) [1] have been widely used in many applications, such as environmental monitoring [2,3], localization [4,5], data publishing with privacy [6,7], target tracking [8,9], and healthcare [10,11]. In many cases, WSNs are large-scale and decentralized with thousands of nodes [12]. Time synchronization, which builds a common understanding of time among all nodes, is one of the most important techniques in WSNs [13,14,15] and other wireless scenarios [16,17,18]. However, due to the low quality of crystal oscillations, the limited computation capabilities, the uncertainty in wireless communication, and the limited power supply, time synchronization in WSNs is still a challenging problem.

In recent years, many synchronization protocols for WSNs have been proposed. Most of them focus on achieving high synchronization accuracy, e.g., at tens of µs or even higher clock accuracy level. However, higher accuracy is usually at the cost of larger energy consumption, which significantly reduces the lifetime of sensor nodes and also sensor networks. In practice, different systems have different time synchronization accuracy requirements, and it is not necessary for the sensor network to provide high synchronization accuracy for all the systems. For example, a few systems [19,20] could operate well with millisecond (ms)-level clock accuracy. Moreover, one system may have different synchronization accuracy requirements in different situations. For example, let us consider a target-tracking system that is deployed in the wild to detect non-cooperative targets. When no target appears, the system works in sleep mode, and coarse synchronization is required to wake nodes up simultaneously for periodical network maintenance. However, once a target appears, nodes surrounding the target should sense it and report their sensing results to the sink node for data fusion [21]. In order to realize reliable communication and accurate data fusion, precise synchronization is required. Therefore, instead of designing synchronization protocols with high accuracy, we argue that synchronization protocol design should be application specific.

In this paper, we focus on the synchronization protocol designed for a target-tracking system in wireless sensor array networks. Note that a wireless sensor array network is a special type of WSN that organizes nodes into arrays to finish tasks. We propose an energy-efficient synchronization protocol called the Sensor Array Synchronization Protocol (SASP) to satisfy the different synchronization requirements and also reduce energy consumption. Specifically, we first analyze the effects of synchronization accuracy on the Quality of Service (QoS), like system lifetime, communication delay, and localization accuracy. For each QoS, given the tolerable value, the required (or tolerable) synchronization accuracy is obtained correspondingly. The requirements have two notable features: (a) The required accuracy in the detection mode is higher than that in the sleep mode. (b) The intra-array accuracy is required to be higher than the inter-array accuracy in the detection mode. Thus, SASP achieves different levels of accuracy according to the system mode and the network scope, i.e., coarse synchronization in the sleep mode, and high inter-array and relatively higher intra-array synchronization in the detection mode. In this way, we satisfy the synchronization requirements, while reducing the energy consumption. The contributions of this paper are summarized as follows:

• We propose that time synchronization can (or should) be optimized for the specific application that executes on the wireless sensor network. This idea can be extended to other protocols and systems.
• We thoroughly analyze the synchronization accuracy requirements for a target-tracking system in wireless sensor array networks and study the effects of synchronization accuracy on the QoS of the system.
• We propose an energy-efficient synchronization protocol that satisfies the different synchronization accuracy requirements with the minimum energy consumption.
• We conduct simulations to evaluate the effectiveness of our synchronization protocol.

The rest of the paper is organized as follows. Section 2 discusses the related work for time synchronization. Section 3 briefly introduces our system and presents the problem formulation. In Section 4, we analyze the synchronization accuracy requirements in detail. The design of SASP is presented in Section 5. We evaluate SASP in Section 6. Finally, Section 7 concludes the whole paper and plans the future work.

2. Related Work

In recent years, researchers have proposed many time synchronization protocols for WSNs. TPSN (Timing-Sync Protocol for Sensor Networks) [22] applies the two-way communication scheme, i.e., the sender transmits time information to the receiver, then the receiver transmits information back, to achieve precise pair-wise clock synchronization. RBS (Reference Broadcast Synchronization) [23] uses a receiver-receiver scheme, which broadcasts a synchronization message and compares the message received time of each receiver to eliminate random delays on the sender side. FTSP (Flooding Time Synchronization Protocol) [24] achieves high synchronization accuracy by time-stamping a broadcast message multiple times, on both the sender and receiver. These protocols mainly focus on how to transmit time information to achieve better accuracy, e.g., RBS, TPSN, and FTSP achieve accuracies of 29.1 µs, 16.9 µs, and 1.4 µs, respectively. However, high accuracy is usually at the cost of large energy consumption. Because of the limited power supply in WSNs, time synchronization should be studied together with energy saving. Zhong et al. [25] developed a clock uncertainty-driven mechanism to minimize communication overhead and provide the desired accuracy. Xie et al. [26] proposed a novel algorithm using a fast finite-time average consensus idea. Brunelli et al. [27] presented a low-overhead clock synchronization method based on a temperature compensation algorithm. However, solutions like SASP, which is based on the features and actual requirements of a real system, have rarely been proposed.

At the same time, several well-known systems have been developed on which time synchronization techniques are used. VigilNet [8] uses a method that broadcasts the synchronization beacon frame from base station periodically to guarantee synchronization accuracy. PinPtr [19] employs FTSP to synchronize the nodes’ clocks. Although these systems work well, we argue that the employed synchronization protocols can (or should) be further optimized by the accuracy requirements of the systems. For example, the experiments of PinPtr show that the synchronization accuracy achieved by FTSP (1.4 µs) is much better than the accuracy required by the system (0.5 ms). Since achieving 1.4 µs consumes more energy than achieving 0.5 ms, PinPtr can optimize its synchronization protocol to save energy.

In this paper, we exploit the synchronization requirements of the target-tracking system. Based on the requirements, we propose SASP. SASP does not aim to achieve high accuracy all the time, but to achieve variable accuracies according to the requirements to save energy.

3. System Introduction and Problem Formulation

An acoustic sensor array is a group of sensors, usually deployed in a certain geometric pattern, that collect and process acoustic signals for relevant parameter estimation. Sensors belonging to the same array often receive identical source signals, except with a phase shift due to the time difference of the plane wave-front at different sensors. Thus, the Direction of Arrival (DoA) of sources can be estimated using the time differences within an array. Further, triangulation source localization can be realized by at least two bearing measurements (DoA).

In the traditional sensor array systems [9,28,29,30], sensor nodes are connected by wires to form arrays. There is a local processor in each array to perform DoA estimation. The estimated results (only several bytes) are wirelessly transmitted to the fusion center. However, these systems have the following drawbacks: First, wired connections are costly in deployment and maintenance. Second, the local processors are usually energy consuming and expensive. To address the drawbacks, we execute our target-tracking system on wireless sensor array networks. As shown in Figure 1, the wireless sensor nodes are organized into arrays based on their location information. We have the following definitions:

• Intra-array nodes: nodes in the same array.
• Inter-array nodes: nodes of different arrays.

Each sensor node is equipped with a microphone to detect the acoustic signal. We use compressive sensing [31], a random sampling and deep quantization technique, to reduce the amount of sensing data significantly. All the raw sensing data are sent to the fusion center using wireless communication.

In WSNs, the wireless communication module is one of the most energy-consuming modules, which consumes more than 90 percent of the energy [32]. Hence, to prolong the lifetime of a system, it is necessary to reduce the energy consumption of wireless communication.

In order to guarantee high communication quality with predictable performance, the TDMA (Time Division Multiple Access) protocol is adopted in our system. The network topology of our system is a three-level tree topology. As shown in Figure 1, we have one sink center, several cluster heads, and many sensor nodes. Each sensor node can communicate with its cluster head, and all the cluster heads can communicate with the sink center. Each cluster head manages the TDMA slots of its child sensor nodes. The sink center manages the TDMA slots of all the cluster heads.

When there is no target in the area of interest, the communication module is turned off, and the system works in the sleep mode to prolong the lifetime. However, the network system needs to wake up periodically to transmit packets for network maintenance. If the clocks are not well synchronized, nodes cannot wake up at the same time. In this situation, each node’s awake time is prolonged to guarantee reliable transmission of network maintenance packets, which consumes more energy and reduce the system’s lifetime. Thus, time synchronization is essential for prolonging the system’s lifetime.

When a target appears, the system works in the detection mode. Nodes that detect the target should send their sensing data to the fusion center. However, TDMA requires the nodes to have a common notion of time, otherwise, data collision will occur. Thus, reliable data communication requires time synchronization.

After sensing data are transmitted to the fusion center, data fusion is performed to estimate the location of the target, which contains the following two steps (details are described in Section 4):

• Intra-array fusion: processing the detection data and getting the acoustic arrival time to each sensor node of an array, we can figure out the direction of the target to the array by comparing the arrival time.
• Inter-array fusion: using direction information from several arrays, we can calculate the target’s location.

Since the target is moving all the time, if the clock of each sensor node is not synchronized, the system cannot determine the location of the target because it does not know whether the detections from different sensor nodes are performed at the same time for the same location of the target. Therefore, in order to guarantee accurate intra-array and inter-array fusion, we have:

• Intra-array synchronization: synchronize the nodes in the same array.
• Inter-array synchronization: synchronize the nodes of different arrays.

In short, to guarantee the QoS of the system, e.g., system lifetime, reliable communication and accurate data fusion, time synchronization is required. However, time synchronization brings a negative effect, i.e., extra energy consumption. Furthermore, achieving higher synchronization accuracy consumes more energy. Thus, this demands a tradeoff between synchronization accuracy and energy efficiency. In this paper, we aim to design a synchronization protocol to satisfy the accuracy requirements of the target-tracking system, while minimizing the energy consumption. The problem is formulated as:

$$\begin{array}{cc}\mathrm{minimization}\hfill & E_{syn},\hfill \\ \mathrm{subject}\mathrm{to}\hfill & 0<\delta \le {\delta }_i,i=1,2,\dots ,m.\hfill \end{array}$$

(1)

where $E_{syn}$ is the energy consumption of time synchronization; $\delta$ is the achieved accuracy, where smaller $\delta$ means smaller error between clocks, i.e., higher accuracy; ${\delta }_i$ denotes the required (tolerable) accuracy; and m denotes the number of the accuracy constraints.

$E_{syn}$ mainly contains two parts: communication consumption and computation consumption, the later one being negligible compared with the former one [12]. Thus, we regard $E_{syn}$ as the energy of transmitting synchronization packets. If we synchronize the network more frequently, more packets are transmitted, which consumes more energy, but we can achieve higher synchronization accuracy. Thus, $E_{syn}$ is directly related to the achieved synchronization accuracy $\delta$. We use a function $f(*)$ to denote the relationship between $E_{syn}$ and $\delta$, having $E_{syn}=f(\delta )$, where $f(*)$ is a monotonically-decreasing function [33]. However, the mathematical expression of $f(*)$ is difficult to obtain, since it depends not only on the synchronization scheme, but also on the hardware, the environments, etc.

The purpose of transmitting synchronization packets is to send synchronization information. However, if we can send synchronization information with the data packets, the synchronization packets are not required. This strategy is called piggybacking. Let $I_{pig}$ denote piggybacking; if synchronization information is sent by piggybacking, then $I_{pig}=0$, otherwise, $I_{pig}=1$. Overall, $E_{syn}$ is modeled as follows:

$$E_{syn}=\left\{\begin{array}{c}{f}_1(\delta ),I_{pig}=0\hfill \\ f_2(\delta ),I_{pig}=1\hfill \end{array}\right.,$$

(2)

where $f_1$ denotes the relationship between $E_{syn}$ and $\delta$ when synchronization information is sent by piggybacking, and $f_2$ denotes the relationship between $E_{syn}$ and $\delta$ when synchronization information is not sent by piggybacking.

4. Accuracy Requirements Analysis for the Target-Tracking System

4.1. Demand of Sleep Mode

In order to prolong the network’s lifetime, our system works in the sleep mode when no target appears. However, sensor nodes need to wake up periodically for network maintenance. The duty ratio D is defined as the percentage of awake time every period. Suppose that energy supplied for the sleep mode is $E_s$. Nodes work in the receiving (idle) or sending state when the system is awake. The energy consumption of the receiving and sending state is almost the same in our system, which is denoted by $e_1$. Nodes work in the sleep state when the system is asleep, and the energy consumption is $e_2$. We can calculate node lifetime L as:

$$L=\frac{E_s}{e_{1}D+e_2(1-D)}.$$

(3)

Under ideal situation without clock error, nodes will wake up simultaneously to send and receive network maintenance packets. Therefore, the node’s duty ratio is determined by the operation period P and the time for network maintenance packet transmission $T_{tr\_m}$, and we have:

$$D_{ideal}=\frac{T_{tr\_m}}{P}=\frac{l_m}{rP},$$

(4)

where $l_m$ denotes the length of the network maintenance packet and r denotes the sending rate.

However, clock error between the sender and the receiver exists in real situations. As shown in Figure 2, because of the clock error, it would wake up ${\delta }_1$ earlier and keep listening. Alternatively, the sender node could prolong the sending time window (i.e., re-transmission). Both strategies will consume extra energy. Suppose that the clock error is ${\delta }_s$ (${\delta }_s>0$) and receivers wake up ${\delta }_s$ earlier to guarantee a reliable transmission. Therefore, the duty ratio changes to:

$$D=\frac{T_{tr\_m}+{\delta }_s}{P}=\frac{l_m+r{\delta }_s}{r\mathrm{P}}.$$

(5)

Combining (3) and (5), we get the node’s lifetime with clock error as:

$$L=\frac{r{E}_s\mathrm{P}}{e_1{l}_m+r{e}_1{\delta }_s+r{e}_{2}P-e_2{l}_m-r{e}_2{\delta }_s}.$$

(6)

In many cases, the system lifetime is designed to be greater than the individual sensor’s lifetime by deploying redundant nodes. However, in this paper, the system lifetime is assumed to be equal to the node lifetime for simplicity.

In order to accomplish long-term missions, the system lifetime should be longer than the expected lifetime $L_d$, i.e., $L\ge L_d$, so the synchronization accuracy in the sleep mode should satisfy:

$$0<{\delta }_s\le \frac{r{E}_{s}P-e_1{l}_m{L}_d-r{e}_{2}P{L}_d+e_2{l}_m{L}_d}{r{e}_1{L}_d-r{e}_2{L}_d}$$

(7)

4.2. Demand of the Communication Protocol

When targets appear, a large amount of detection data is transmitted using the TDMA protocol. The detection data are firstly gathered within each array to array heads, and then, the heads send the data to the fusion center. In each array, the head allocates a time slot $T_{slot}$ for every member node.

Under the ideal situation without clock error, data collision is avoided by guaranteeing that every node can complete transmission in its own slot. However, as shown in Figure 3, different nodes have different understandings of the starting time of each slot due to clock errors ${\delta }_{intra}$ (${\delta }_{intra}>0$). For any two nodes with neighboring time slots (for example, Member Nodes 1 and 2 in Figure 3), if no data collision happens, it satisfies:

$$T_{tr\_d}+{\delta }_{intra}\le T_{slot}.$$

(8)

where $T_{tr\_d}$ is the time to transmit a data packet. Let $l_d$ denote the length of every data packet from member nodes and r denote the sending rate; we have $T_{tr\_d}={\displaystyle \frac{l_d}{r}}$.

Besides data collision, communication delay is another important metric of reliable communication. Since the head will forward the data to the fusion center only when it has received all the data from its member nodes, the intra-array communication delay $d_{intra}$ equals the communication delay of member node n. As shown in Figure 3, the communication delay of member node n is:

$$d_{n^{th}}={\delta }_{intra}+(n-1)T_{slot}+T_{tr\_d}\approx n{T}_{slot}.$$

(9)

Given the maximum tolerable intra-array communication delay $d_{max1}$, we have:

$$d_{intra}=n{T}_{slot}\le d_{max1}.$$

(10)

Combining (8) and (10), we get intra-array synchronization accuracy satisfying:

$$0<{\delta }_{intra}\le \frac{d_{max1}}{n}-\frac{l_d}{r}.$$

(11)

After the heads receive all the member nodes’ data, they will forward the data to the fusion center. The length of each head’s data is $n{l}_d$. Suppose that there are m heads in our system, and the maximum tolerable communication delay is set to $d_{max2}$ here, so the synchronization accuracy between heads (inter-array) must satisfy:

$$0<{\delta }_{inter}\le \frac{d_{max2}}{m}-\frac{n{l}_d}{r}.$$

(12)

4.3. Demand of Data Fusion

After the detection data are sent to the sink node, we obtain the target’s position through intra-array fusion and inter-array fusion.

Intra-array fusion: We assume that acoustic wave arrives as a plane wave. As shown in Figure 4, node A and node B are two different nodes in the same array; the wave arrives at them at different times. The time difference of arrival is $t_d$. The acoustic wave propagates at a velocity of v. The distance between the nodes is d. Then, we can get the target’s direction with respect to the array by:

$$cos(\theta )=\frac{v{t}_d}{d}.$$

(13)

In practice, due to the clock error ${\delta }_{intra}$ (${\delta }_{intra}>0$) between the two nodes, the recorded time difference of arrival becomes $t_d+{\delta }_{intra}$. Therefore, the obtained target’s direction is not accurate, and we have:

$$cos(\theta +\widehat{\theta })=\frac{v(t_d+{\delta }_{intra})}{d},$$

(14)

where $\widehat{\theta }$ is the measurement error of the target’s direction.

For simplicity, we assume that $\widehat{\theta }$ is small; thus, we have $cos(\widehat{\theta })\approx 1$ and $sin(\widehat{\theta })\approx \widehat{\theta }$. Then, by (13) and (14), we get:

$$\widehat{\theta }=-\frac{v{\delta }_{intra}}{dsin\theta }<0,$$

(15)

where d is the distance between the nodes.

Given that the maximum tolerable measurement error of the target’s direction is ${\widehat{\theta }}_{max}>0$, we have $\widehat{\theta }\ge -{\widehat{\theta }}_{max}$, i.e.,

$$\frac{v{\delta }_{intra}}{dsin\theta }\le {\widehat{\theta }}_{max}.$$

(16)

Therefore, the intra-array synchronization accuracy satisfies:

$$0<{\delta }_{intra}\le \frac{{\widehat{\theta }}_{max}dsin\theta }{v}.$$

(17)

Inter-array fusion: Using direction information from several arrays, the sink node obtains the target’s position, as shown in Figure 5. The array is considered as a single point since the distance of any two arrays is much larger than the array’s size.

In the system, the detections from different arrays that have the same timestamp are fused to get the position of the target. Array 1, at local time $t_A=T$, detects the target and sends the detection data (containing timestamp T) to the sink node. By intra-array fusion, we obtain the target’s direction to Array 1, which is $\alpha$. At the same time, array 2 also detects the target, but due to clock error ${\delta }_{inter}$ ($t_1-t_2={\delta }_{inter}>0$) between the arrays, Array 2’s local time $t_B\ne T$, so it does not report detection data at this time. Instead, when its local time is $t_B=T$ and the target has moved $u{\delta }_{inter}$ (u is the target’s velocity), Array 2 sends its detection data (containing timestamp T) to the sink node. The target’s direction with respect to Array 2, which is $\beta$, is obtained. As we can see in Figure 5, there exists direction error $\widehat{\beta }$; thus, the fusion position is different from the real position.

In triangle ABC, by the law of sines, we have:

$$sin\widehat{\beta }=\frac{u{\delta }_{inter}sin\gamma }{l},$$

(18)

i.e., the direction error $\widehat{\beta }$ is due to the movement of the target.

In triangle ABD, by the law of sines, we get:

$$\Delta =\frac{lsin\widehat{\beta }}{sin(\alpha -\beta )},$$

(19)

i.e., the direction error $\widehat{\beta }$ results in the localization error $\Delta$.

Combining (18) and (19), we have:

$$\Delta =\frac{u{\delta }_{inter}sin\gamma }{sin(\alpha -\beta )}.$$

(20)

Different from (19), Equation (20) tells us that the localization error is independent of the direction error $\widehat{\beta }$ and the distance l. Because when l is larger, $\widehat{\beta }$ will be smaller, and vice versa, $\widehat{\beta }$ and l cancel each other out.

Given the maximum tolerable localization error ${\Delta }_{max}$, we have $\Delta \le {\Delta }_{max}$. Therefore, the inter-array synchronization accuracy satisfies:

$$0<{\delta }_{inter}\le \frac{{\Delta }_{max}sin(\alpha -\beta )}{usin\gamma }.$$

(21)

In summary, the synchronization accuracy requirements of the target-tracking system are obtained in this section. We observe two notable features: First, the requirements are highly related to the system modes. Second, in the detection mode, the accuracy requirements of intra-array and inter-array synchronization are different. These features make the previous approaches, such as RBS [23] and FTSP [24], which focus on achieving high accuracy, not suitable for our target-tracking system. Therefore, it is necessary to design an energy-efficient synchronization protocol satisfying the different requirements of the target-tracking system.

5. Protocol Design

In this section, we present the design of SASP, an energy-efficient synchronization protocol for the target-tracking system, which mainly consists of three parts: synchronization in the sleep mode, synchronization in the detection mode, and synchronization in the transient state.

5.1. Synchronization in the Sleep Mode

In the sleep mode, the root node (fusion center) will broadcast maintenance packets periodically to other nodes to maintain the network status. Therefore, we can piggyback the synchronization information onto the maintenance packets. With the accuracy requirements in the sleep mode described in Section 4, the synchronization problem is formulated as follows:

$$\begin{array}{cc}\mathrm{minimization}\hfill & E_s=f_1({\delta }_s),\hfill \\ \mathrm{subject}\mathrm{to}\hfill & 0<{\delta }_s\le \frac{rEP-e_1{l}_m{L}_d-r{e}_{2}P{L}_d+e_2{l}_m{L}_d}{r{e}_1{L}_d-r{e}_2{L}_d},\hfill \end{array}$$

(22)

where $E_s$ denotes the energy consumption of the synchronization process in the sleep mode.

We solve (22), the optimal accuracy is:

$${\delta }_s^{*}=\frac{rEP-e_1{l}_m{L}_d-r{e}_{2}P{L}_d+e_2{l}_m{L}_d}{r{e}_1{L}_d-r{e}_2{L}_d}.$$

(23)

In general, the accuracy constraint can be satisfied using piggybacking. The synchronization period is $N\times P$ (N is a positive integer, and P denotes the network maintenance period). In fact, our evaluation results in Section 6 prove it.

5.2. Synchronization in the Detection Mode

We first check whether it is possible to piggyback inter-array or intra-array synchronization information using data packets. When a target appears, nodes surrounding it can detect it and send detection data to their heads, and then, these data are forwarded to the sink node. If we piggyback synchronization information onto these data packets, the head can get the time information from each member node; however, the member nodes cannot get a reference time to be synchronized. For faraway nodes that cannot detect the target, there is not even a data packet that needs to be sent. However, these nodes may also need to be accurately synchronized, since the target may move close to them in the future. Therefore, we can not synchronize the network by piggybacking in the detection mode.

With the accuracy requirements in the detection mode described in Section 4, the synchronization problem for inter-array synchronization is formulated as follows:

$$\begin{array}{cc}\mathrm{Minimize}\hfill & E_{inter}=f_2({\delta }_{inter}),\hfill \\ \mathrm{subject}\mathrm{to}\hfill & 0<{\delta }_{inter}\le \frac{d_{max2}}{m}-\frac{n{l}_d}{r},\hfill \\ & 0<{\delta }_{inter}\le \frac{{\Delta }_{max}sin(\alpha -\beta )}{usin\gamma },\hfill \end{array}$$

(24)

where $E_{inter}$ denotes the energy consumption of the inter-array synchronization process.

The synchronization problem for intra-array synchronization is formulated as follows:

$$\begin{array}{cc}\mathrm{Minimize}\hfill & E_{intra}=f_2({\delta }_{intra}),\hfill \\ \mathrm{subject}\mathrm{to}\hfill & 0<{\delta }_{intra}\le \frac{d_{max1}}{n}-\frac{l_d}{r},\hfill \\ & 0<{\delta }_{intra}\le \frac{{\theta }_{max}dsin\theta }{v},\hfill \end{array}$$

(25)

where $E_{intra}$ denotes the energy consumption of the intra-array synchronization process.

We solve (24) and (25), and the optimal accuracies are:

$${\delta }_{inter}^{*}=min(\frac{d_{max2}}{m}-\frac{n{l}_d}{r},\frac{{\Delta }_{max}sin(\alpha -\beta )}{usin\gamma }),$$

(26)

and:

$${\delta }_{intra}^{*}=min(\frac{d_{max1}}{n}-\frac{l_d}{r},\frac{{\theta }_{max}dsin\theta }{v}).$$

(27)

Note that ${\delta }_{inter}^{*}\ne {\delta }_{intra}^{*}$, and intra-array synchronization accuracy (clock error of nodes in the same array) is independent of inter-array synchronization accuracy (clock error of nodes of different arrays). Therefore, we design intra-array and inter-array synchronization, respectively.

Intra-array synchronization: For each array, the array head broadcasts a synchronization packet to its member nodes at the period of $T_{intra}$. Each member node receiving the packet then can synchronize with its array head.

Inter-array synchronization: Since each array is synchronized by its array head, we just need to synchronize the array heads to synchronize different arrays. Therefore, the sink node broadcasts a synchronization packet to all array heads in the period of $T_{inter}$, and then, each array head synchronizes with the sink node after receiving the synchronization packet.

It is obvious that our protocol is different from previous protocols, like FTSP [24], which synchronizes the whole network in the same period to achieve high network-wide accuracy. SASP saves energy consumption by providing different local and network-wide synchronization accuracy.

5.3. Synchronization in the Transient State

The synchronization accuracy in the sleep mode is lower than that in the detection mode. Thus, when targets appear, the system needs to be synchronized to higher accuracy; however, this takes time. As shown in Figure 6, when a target appears at $T_1$, node A detects it and immediately sends a control message to the sink. Then, node A starts detecting the target. After the sink node gets the control message, it broadcasts a synchronization message immediately to synchronize the network. At $T_3$, node A is synchronized. The time between $T_1$ and $T_3$ is called the transient state. In the transient state, the achieved synchronization accuracy cannot satisfy the requirements of the detection mode; thus, inaccurate localization happens. SASP takes this problem into consideration and solves it in two steps: (1) When node A receives the synchronization message at $T_3$, it calculates the difference between the reference time and its local time (the reference time minus the local time), which is $T_{offset}$. (2) Estimate the real starting time of each detection in the transient state. For example, in Figure 6, the real starting times of Detection 1 and Detection 2 are $T_1+T_{offset}$ and $T_2+T_{offset}$, respectively.

Overall, in the sleep mode, by piggybacking synchronization information onto network maintenance packets, we satisfy the accuracy constraint with low overhead. In the detection mode, we achieve precise network-wide and local synchronization to satisfy the inter-array and intra-array accuracy requirements. Furthermore, SASP eliminates the random delays of transmitting synchronization packets by using MAC-layer timestamping approach as in [22,24]. Moreover, compensation of clock drift [23,24] is employed to improve synchronization accuracy and prolong the synchronization period. Drift compensation in SASP is presented in Algorithm 1. We apply the linear model and use the latest offset value to estimate the drift.

Algorithm 1 Drift compensation in the Sensor Array Synchronization Protocol (SASP).

1: Initialization: Drift compensation value $comp[0]=0$. 2: for$k=1$; $k++$do 3:  Receive the synchronization packet of the $k^{\mathrm{th}}$ round of synchronization; 4:  Calculate the difference (offset) between the reference time and the node’s local time, $T_{offset}[k]$; 5:  $comp[k]=comp[k-1]+{\displaystyle \frac{T_{offset}[k]}{T}}$, where T is the synchronization period. 6: end for

6. Protocol Evaluation

6.1. Clock Model

Before evaluating our protocol, we first introduce the clock model. Nodes’ clocks are obtained from crystal oscillators, which could be significantly influenced by harsh environments, since nodes are deployed in the wild. In this paper, we adopt the WGN (White Gaussian Noise) random walk model [25,34] instead of the commonly-used constant-rate model to characterize the influence of the environment because the former model has higher uncertainty.

The clock model is described as follows:

$$\theta [n]=\sum _{k=1}^n(1+d_r[k])\tau [k]+\theta [0]+w[n].$$

(28)

where k is the sample index, $\theta [n]$ is the node clock at the nth sample, $\tau [k]$ is the sampling period at the kth sample, and $w[n]$ is the measurement noise, which follows a Gaussian random distribution with zero mean and variance ${\sigma }_w^2$. $d_r[k]$ is the clock drift at the kth sample, which is modeled as:

$$d_r[n]=d_r[n-1]+\eta [n],$$

(29)

where $\eta$ is the model noise with zero mean and variance ${\sigma }_{\eta }^2$.

6.2. Evaluation of SASP

We used simulation to evaluate the performance of SASP. The parameters used in the target-tracking system [9,28] are listed in

Table 1. System constants and simulation parameters.

System Parameters
Node’s energy consumption awake $e_1$ (mA)	25
Node’s energy consumption asleep $e_2$ (µA)	0.9
Energy supplied for the sleep mode E (mAh)	100
Operation period in the sleep mode P (s)	120
Length of a network maintenance packet $l_m$ (bytes)	40
Length of piggybacked synchronization bytes $l_{pg}$ (bytes)	2
Sending rate of wireless communication r (Kbps)	250
Expected lifetime of the target-tracking system $L_d$ (year)	5
Length of a detection data packet $l_d$ (bytes)	100
Number of nodes in every array n	5
Tolerable intra-array communication delay $d_{max1}$ (ms)	20
Number of heads in the system m	8
Tolerable inter-array communication delay $d_{max2}$ (ms)	200
Velocity of the acoustic wave in the air v (m/s)	340
Distance between nodes in the same array d (m)	20
Tolerable error of direction measurement ${\widehat{\theta }}_{max}$ (degree)	1
Tolerable localization error ${\Delta }_{max}$ (cm)	10
Target’s velocity u (m/s)	20
Clock model parameters
${\sigma }_w$ (µs)	15
${\sigma }_{\eta }$	10−7
Clock drift $d_r$ (ppm)	−40–40

. In our system, we used the CC2430 nodes. There were one fusion center and 40 sensor nodes, which were organized into eight arrays. In each array, there was one head node and four member nodes. The fusion center, head nodes, and member nodes form a hierarchical topology structure. Each node was powered by two batteries, which provided 1300 mAh of energy in total. Most of the time, there was no target, and the system worked in sleep mode. However, the system woke up every 120 s to maintain the network. The network maintenance packet was 40 bytes, sending at a rate of 250 Kbps. The piggybacked synchronization information was two bytes. The energy consumption of the CC2430 node in receiving, sending, and sleep states was 27 mA, 25 mA, and 0.9 µA, respectively [35]. For simplicity, in our simulation, the energy consumption was assumed to be 25 mA when the node was awake. Since most of the energy was consumed in the detection mode, we assumed that the energy supplied for the sleep mode was less than 10%, which was 100 mAh. A target may not be encountered for several months or even years. Thus, our system may sleep for a long time waiting for the target. The expected lifetime of the target tracking was set to be five years. However, if the target was encountered frequently, the system life would be much shorter. The target’s velocity was set to 20 m/s. Note that the traditional tracking systems [9,28] have a drawback that the tracking results are not good when the target and sensor arrays are in a line ($\theta$ or $\alpha -\beta$ is very small). In our system, this problem was solved because we could freely choose the appropriate nodes to form arrays to detect targets while satisfying $\theta >{10}^{\circ }$ and $\alpha -\beta >{10}^{\circ }$.

According to (7), the synchronization accuracy constraint in the sleep mode is:

$$0<{\delta }_s\le 5.4\mathrm{ms}.$$

(30)

In the detection mode, according to (11) and (17), the accuracy constraints of the intra-array synchronization are:

$$\begin{array}{c}0<{\delta }_{intra}<800\mathsf{\mu }\mathrm{s},\\ 0<{\delta }_{intra}<178\mathsf{\mu }\mathrm{s}.\end{array}$$

(31)

According to (12) and (21), the accuracy constraints of the inter-array synchronization are:

$$\begin{array}{c}0<{\delta }_{inter}<9\mathrm{ms},\\ 0<{\delta }_{inter}<850\mathsf{\mu }\mathrm{s}.\end{array}$$

(32)

From (30)–(32), we can observe that the the accuracy constraints in the detection mode were much stricter than that in the sleep mode, and the constraint of the intra-array accuracy was much stricter than that of the inter-array accuracy. We also found that the accuracy was constrained by the demand of data fusion. However, during its trajectory, when the system network scale became larger, or the data length became longer, the constraints given by the demand of reliable transmission would be stricter, even stricter than the constraint given by data fusion.

According to (23), (26) and (27), the optimal synchronization accuracies are:

$${\delta }_s^{*}=5.4\mathrm{ms},$$

(33)

$${\delta }_{intra}^{*}=min(800\mathsf{\mu }\mathrm{s},178\mathsf{\mu }\mathrm{s})=178\mathsf{\mu }\mathrm{s},$$

(34)

and:

$${\delta }_{inter}^{*}=min(9\mathrm{ms},850\mathsf{\mu }\mathrm{s})=850\mathsf{\mu }\mathrm{s}.$$

(35)

The parameters of our clock model are also listed in Table 1. ${\sigma }_w$ = 15 µs and ${\sigma }_{\eta }$ = 10⁻⁷ were derived from [25,34]. Since we used the CC2430 node, the clock drift $d_r$ ranged from −40 ppm to 40 ppm [35]. The simulation results were statistical clock performances of over 1000-times the synchronization. Our performance evaluation mainly concentrated on two synchronization metrics:

• Accuracy violation probability: The probability of the achieved accuracy cannot satisfy the accuracy constraints (i.e., (30)–(32)). In this paper, the tolerable accuracy violation probability was set to 1%.
• Average synchronization accuracy: The synchronization accuracy averaged over all the runs for every pair of selected nodes (e.g., inter-array nodes, intra-array nodes).

6.2.1. SASP in the Sleep Mode

In the sleep mode, the synchronization bytes were piggybacked onto the network maintenance packets. Since the network maintenance period in the sleep mode was 120 s, and the synchronization period should be $N\times 120$ s (N is a positive integer). The simulation results are shown in Figure 7.

As shown in Figure 7a, when the synchronization period in the sleep mode $T_s$ was 720 s, the accuracy violation probability was about 1%, which is tolerable. Thus, by our simulation results, $T_s$ was set to 720 s in our system, and the corresponding intra-array average synchronization accuracy was 1 ms. Since the length of the piggybacked synchronization bytes was two bytes and the length of a network maintenance packet was 40 bytes, we obtained the overhead of piggybacking, which was $\frac{2}{40}\times \frac{120}{720}$ = 0.8%, which is negligible. Thus, SASP was effective in the sleep mode.

6.2.2. SASP in the Detection Mode

SASP contains two synchronization in the detection mode: intra-array synchronization and inter-array synchronization. We first studied the intra-array synchronization. The simulation results are shown in Figure 8.

As shown in Figure 8a, when $T_{intra}$ was less than 30 s, the accuracy violation probability of intra-array synchronization was zero, i.e., the intra-array accuracy constraints in (31) were completely satisfied. When $T_{intra}$ was 50 s, the accuracy violation probability was about 1%, which is tolerable. However, if $T_{intra}$ became larger, the intra-array accuracy constraints could not be well satisfied. Thus, by our simulation results, the intra-array synchronization period $T_{intra}$ was set to 50 s in our system, and the corresponding intra-array average synchronization accuracy was 25 µs.

After the arrays were synchronized by the array heads, we synchronized the array heads to synchronize different arrays. We set $T_{intra}$ to 50 s and varied $T_{inter}$, and we show the simulation results in Figure 9.

As shown in Figure 9a, when $T_{inter}$ was smaller than 160 s, the accuracy violation probability of inter-array synchronization was less than 1%, i.e., the inter-array accuracy constraints in (32) were satisfied. However, when $T_{inter}$ became larger, the violation probability was intolerable. Thus, the inter-array synchronization period $T_{inter}$ was set to 160 s in our system, and the corresponding inter-array average synchronization accuracy was 100 µs, which is lower than the intra-array one (25 µs).

From Figure 8 and Figure 9, we observe that the accuracy violation probability was more important than the average synchronization accuracy. For example, when $T_{intra}$ = 100 s, although the average synchronization accuracy (48 µs) was higher than the required (optimal) accuracy ${\delta }_{intra}^{*}$ (178 µs), the intra-array accuracy violation probability was 12%, which means the QoS was not guaranteed. Thus, SASP was designed to satisfy the accuracy constraints other than achieving high average accuracy, as in [22,23,24].

To further verify the effectiveness of SASP, we compared it with FTSP, FTSP. The simulation results of FTSP are shown in Figure 10. As shown in Figure 10b, the intra-array and inter-array synchronization accuracy were similar. That is because FTSP synchronized the network in the same period $T_{ftsp}$ and provided on average good synchronization between arbitrary nodes. However, in our system, the accuracy constraints of intra-array synchronization were stricter. Thus, as shown in Figure 10a, the intra-array synchronization accuracy would not satisfy its constraints as $T_{ftsp}$ became larger than 45 s, while the inter-array synchronization accuracy could still satisfy its constraints. Therefore, in order to satisfy both the inter-array and intra-array accuracy constraints, $T_{ftsp}$ should be shorter than 45 s in our system.

To show the energy efficiency of SASP, we compared the energy consumption of SASP and FTSP under different accuracy violation probability. Since the energy consumption of transmitting one synchronization packet was almost the same in the two protocols, we used the number of synchronization packets transmitted per minute to indicate the energy consumption. The results are shown in Figure 11. As shown in Figure 11, SASP required less synchronization packets under all situations, so it was more energy efficient than FTSP. To guarantee the accuracy violation probability to be less than 1% (i.e., both (31) and (32) are satisfied), SASP required 10 synchronization packets per minute, while FTSP required 50. That is to say, using SASP saved 80% of the energy compared to using FTSP.

7. Conclusions

In this paper, we presented an energy-efficient time synchronization protocol for the target-tracking system in wireless sensor array networks, called SASP. To satisfy the synchronization accuracy requirements and save energy, SASP provided different synchronization accuracies according to the system mode and the network scope. Evaluation results demonstrated that: (1) SASP satisfied all the synchronization accuracy requirements; (2) the energy consumption of SASP was negligible in the sleep mode; (3) SASP was more energy efficient than FTSP in the detection mode. As part of our future work, we will apply our work to a few well-known protocols and systems.