Timing-sync Protocol for Sensor Networks
Saurabh Ganeriwal Ram Kumar Mani B. Srivastava
Networked and Embedded Systems Lab (NESL), University of California Los Angeles
56-125B Eng. IV, UCLA EE Dept., Los Angeles, CA 90095
{saurabh, ram, mbs}@ee.ucla.edu
ABSTRACT
Wireless ad-hoc sensor networks have emerged as an interesting
and important research area in the last few years. The
applications envisioned for such networks require collaborative
execution of a distributed task amongst a large set of sensor
nodes. This is realized by exchanging messages that are time-
stamped using the local clocks on the nodes. Therefore, time
synchronization becomes an indispensable piece of
infrastructure in such systems. For years, protocols such as NTP
have kept the clocks of networked systems in perfect synchrony.
However, this new class of networks has a large density of
nodes and very limited energy resource at every node; this leads
to scalability requirements while limiting the resources that can
be used to achieve them. A new approach to time
synchronization is needed for sensor networks.
In this paper, we present Timing-sync Protocol for Sensor
Networks (TPSN) that aims at providing network-wide time
synchronization in a sensor network. The algorithm works in
two steps. In the first step, a hierarchical structure is established
in the network and then a pair wise synchronization is
performed along the edges of this structure to establish a global
timescale throughout the network. Eventually all nodes in the
network synchronize their clocks to a reference node. We
implement our algorithm on Berkeley motes and show that it can
synchronize a pair of neighboring motes to an average accuracy
of less than 20µs. We argue that TPSN roughly gives a 2x better
performance as compared to Reference Broadcast
Synchronization (RBS) and verify this by implementing RBS on
motes. We also show the performance of TPSN over small
multihop networks of motes and use simulations to verify its
accuracy over large-scale networks. We show that the
synchronization accuracy does not degrade significantly with the
increase in number of nodes being deployed, making TPSN
completely scalable.
Categories and Subject Descriptors
C.2.2 [Computer Systems Organization]: Computer
Communication Networks – Network Protocols.
General Terms
Algorithms, Experimentation, Performance, Verification.
Keywords
Sensor Networks, Time Synchronization, Packet Delay, Clock
Drift, Medium Access Control.
1. INTRODUCTION
Advances in microelectronics fabrication have allowed the
integration of sensing, processing and wireless communication
capabilities into low-cost and small form-factor embedded
systems called sensor nodes [1], [2]. The need for unobtrusive
and remote monitoring is the main motivation for deploying a
sensing and communication network (sensor network)
consisting of a large number of these battery-powered nodes.
The applications envisioned for sensor networks vary from
monitoring inhospitable habitats and disaster areas to operating
indoors for intrusion detection and equipment monitoring. Most
of these applications require sensor nodes to maintain local
clocks in order to determine the timing of the events. In general,
sensor nodes gather sensor readings, and use several signal
processing techniques to get meaningful results from this raw
data. For example, the target tracking applications use Kalman
filter to estimate the target position [3]. Such signal-processing
techniques require relative synchronization among sensor node
clocks, so that a right chronology of events can be detected. On
the other hand, for sensor network applications such as detecting
brushfires, gas leaks etc.; the time of occurrence of an event is
itself a critical parameter. For such class of applications, the
synchronization of the complete network with every node
maintaining a unique global time scale becomes paramount.
Time synchronization is also indispensable in the
implementation of the commonly used medium access control
(MAC) protocols such as TDMA [4].
Time synchronization problem has been investigated
thoroughly in Internet and LANs. Several technologies such as
GPS, radio ranging etc have been used to provide global
synchronization in networks. Complex protocols such as NTP
[5] have been developed that have kept the Internet’s clocks
ticking in phase. However, the time synchronization
requirements differ drastically in the context of sensor networks.
In general such networks are dense, consisting of a large number
of sensor nodes. To operate in such large network densities, we
need the time synchronization algorithm to be scalable with the
number of nodes being deployed. Also, energy efficiency is a
major concern in these networks due to the limited battery
capacity of the sensor nodes. This eliminates the use of external
energy-hungry equipments, such as GPS. Moreover, time
synchronization requirements are much more stringent, often
requiring synchronization of the order of microseconds among
nodes involved in a task such as tracking a target.
Permission to make digital or hard copies of all or part of this work for
personal or classroom use is granted without fee provided that copies are
not made or distributed for profit or commercial advantage and that
copies bear this notice and the full citation on the first page. To copy
otherwise, or republish, to post on servers or to redistribute to lists,
requires prior specific permission and/or a fee.
SenSys ’03, November 5-7, 2003, Los Angeles, California, USA.
Copyright 2003 ACM 1-58113-707-9/03/0011…$5.00.
1.1 Contributions
We present a Timing-sync Protocol for Sensor Networks
(TPSN) that works on the conventional approach of sender-
receiver synchronization. We argue that for sensor networks, the
classical approach of doing a handshake between a pair of nodes
is a better approach than synchronizing a set of receivers [6].
This observation comes as result of time stamping the packets at
the moment when they are sent i.e., at MAC layer, which is
indeed feasible for these networks. To prove our claim, we
compare the performance of TPSN with Reference Broadcast
Synchronization (RBS) [7], a timing synchronization algorithm
for sensor networks based on receiver-receiver synchronization.
We will show that TPSN gives roughly a 2x better performance
than RBS via implementation on motes. We will show that
TPSN can synchronize a pair of motes to an average accuracy of
less than 20µs and a worst-case accuracy of around 50µs.
In sensor networks, clock synchronization might not be
needed all the times. For such scenarios, TPSN can be combined
with the approach of post-facto synchronization proposed in [8]
to provide time synchronization among a subset of nodes. Post-
facto synchronization is used to synchronize two nodes by
extrapolating backwards to estimate the phase shift at a previous
time. We provide an implementation on motes that integrates
TPSN with post-facto synchronization and gauge its
performance on a multihop network of motes. On the other
hand, to facilitate deployment of MAC protocols such as
TDMA, there might be a need of maintaining a unique and
global timescale throughout the network. In this case, we create
a self-configuring system, suitable for sensor networks, where a
hierarchical structure is established in the network. In our
algorithm, NTP-like daemons self-organize to act as servers to
some nodes while acting as client to another server. In this
paper, we specially consider such scenarios and provide an
integrated algorithm that first establishes the hierarchical
structure and then aims at providing a unique global timescale
throughout the network.
We will show that TPSN provides a simple, scalable and
efficient solution to the problem of timing synchronization in
sensor networks. Moreover, TPSN is completely flexible and
can be easily tuned to meet the desired levels of accuracy as well
as algorithmic overhead. TPSN also comes with an auxiliary
benefit of improving the accuracy of other basic services in
sensor networks such as localization, target tracking,
aggregation.
2. RELATED WORK
Although time synchronization has been the topic of
research for the past many years in a wide spectrum of
applications [5], [6], [9], with regard to sensor networks, a final
solution is yet to be found. In this section we will discuss some
of the algorithms that deal with timing issues in sensor
networks.
In [8], [10], researchers emphasize on a completely
different regime for time synchronization in sensor networks.
They have pointed out notable differences between timing
synchronization requirements in sensor networks as compared to
traditional networks. In general, the problem of time
synchronization can be studied in context of three different
models.
The first and perhaps the simplest type of model
concentrate on just maintaining the relative notion of time
between nodes. Thus the aim here is not synchronize the sensor
node clocks but to generate a right chronology of events. A
scheme for sensor networks based on this model was proposed
in [11]. The algorithm proposed in [11] is only initiated when
events take place in the network. Therefore, such a scheme is
not extendible to scenarios where a notion of sensor node clock
is required. For example, a scenario where the actual time of
occurrence of an event is important or where sensor node clock
is used to successfully run MAC protocols.
A more complex model is of maintaining relative clocks. In
this model, though every node maintains an individual clock,
these clocks are not synchronized with respect to each other.
Instead, every node stores information about the relative drift
between its clock and the clock of any other node in the network
(or with only those nodes with which it desires to maintain a
relative clock). A scheme based on this model is Reference-
Broadcast Synchronization (RBS) [7]. In RBS, sensor nodes
periodically send beacon messages to their neighbors using the
network’s physical layer broadcast. Recipients use the message’s
arrival time as point of reference for comparing their clocks. The
offset between any pair of nodes, receiving the beacon, is
calculated by exchanging the local timestamps. This scheme
successfully removes all possible sources of error except the
variability in processing delay at the receiver.
Perhaps the most complex model (“always-on” model) is
the one where every node maintains a clock that is synchronized
with respect to a reference node in the network. The aim here is
to maintain a global and a unique timescale throughout the
network. Although this model consumes maximum energy, it is
a superset of all the models. Therefore, if the clocks are
absolutely synchronized, they are relatively synchronized too
and a right chronology of events can also be detected. In this
paper, we provide an integrated algorithm where TPSN aims to
provide synchronization following this model. To the best of our
knowledge, this is the first work that tries to provide timing
synchronization in sensor networks on the basis of “always-on”
model. In this model, TPSN will be provided as an API, running
continuously on the backend of a sensor node transparent to the
application writer.
However, we would like to emphasize that TPSN is not an
algorithm restricted to the “always-on” model. To show the
flexibility of TPSN, we provide an example implementation on
motes that integrates TPSN with post-facto synchronization to
synchronize node clocks, lying on a multihop network, relatively
to each other. RBS also uses post-facto synchronization to
provide multihop clock synchronization. In this scenario, the
difference between RBS and TPSN is the way in which they
carry out the handshake to synchronize a pair of motes. TPSN
uses the classical approach of sender-receiver synchronization
whereas RBS uses the approach of receiver-receiver
synchronization. As mentioned earlier, we shall prove that for
sensor networks doing sender-receiver synchronization gives
better results than receiver-receiver synchronization.
We take the motivation from NTP that has been largely
successful in Internet. However, NTP is computationally
intensive. It is completely infeasible to implement NTP on the
energy constrained sensor nodes. Moreover, NTP is a fixed
algorithm that can operate only in the “always-on” model.
Contrary to this, TPSN is flexible to the model used for timing
synchronization and can also be easily tuned to meet the desired
operating point in energy versus accuracy subspace. NTP has
been successfully able to synchronize the clocks in Internet to an
accuracy of the order of milliseconds but the time
synchronization requirements for sensor networks can be much
more stringent than that, ranging into the order of a few
microseconds. Our scheme can be viewed as a practical, more
accurate and a flexible extension of NTP to sensor networks.
3. SYSTEM MODEL
We have N sensor nodes scattered in an area A. Every node
maintains a 16-bit register as a clock that is triggered by a
crystal oscillator. This is the only notion of time that a node has.
In this paper, we provide an integrated algorithm that aims at
providing time synchronization following the always-on model.
Thus, the goal is to establish a common timescale for every node
in the sensor network and therefore, synchronize the 16-bit
clock for every sensor node. We begin by describing the basic
concept of TPSN and proceed to outline the assumptions about
the system.
3.1 Basic Concept
The first step of the algorithm is to create a hierarchical
topology in the network. Every node is assigned a level in this
hierarchical structure. We ensure that a node belonging to level i
can communicate with at least one node belonging to level i-1.
Only one node is assigned to level 0, which we call the “root
node”. We call this stage of our algorithm as the “level
discovery phase”. Once the hierarchical structure has been
established, the root node initiates the second stage of the
algorithm, which is called the “synchronization phase”. In this
phase, a node belonging to level i synchronize to a node
belonging to level i-1. Eventually every node is synchronized to
the root node and we achieve network-wide time
synchronization.
In general, a user node that acts as the gateway between the
sensor network and the external world can act as the root node.
The user node can be equipped with a GPS receiver, in which
case the sensor nodes would be synchronized to the physical
world. In more hostile environments, where it is impossible to
have an external entity, sensor nodes can periodically take over
the functionality of being the root node, using some leader
election algorithm [12]. Also, neither TPSN nor the “always-on”
model restricts the possibility of having multiple root nodes in
the network. In this case, islands of time-synchronized nodes
will be formed in the network. Further, a scheme such as RBS
[7] could be used to maintain a relative clock between the
adjacent nodes that lie on the boundary, providing
synchronization in the whole network. In this paper, we consider
the network to have just one root node.
3.2 Assumptions
We assume that the sensor nodes have unique identifiers. A
link level protocol ensures that each node is aware of the set of
nodes with which it can directly communicate, also termed as
the “neighbor set” of the node. Though there can be uni-
directional links in the network, TPSN uses only bi-directional
links to do pair wise synchronization between a set of nodes. We
also assume that it is possible to create a spanning tree in the
network using just these bi-directional links.
In this paper, we have attributed the creation and
maintenance of the hierarchical structure as the responsibilities
of TPSN. However, many of the sensor network applications
rely on in-network processing and require a similar structure for
their functionality for example the aggregation tree required for
TinyDB [13]. Therefore, creating and maintaining a hierarchical
structure should not be considered as an overhead exclusive to
TPSN.
4. TIMING-SYNC PROTOCOL FOR
SENSOR NETWORKS (TPSN)
4.1 Level Discovery Phase
This phase of the algorithm occurs at the onset, when the
network is deployed. The root node is assigned a level 0 and it
initiates this phase by broadcasting a level_discovery packet.
The level_discovery packet contains the identity and the level of
the sender. The immediate neighbors of the root node receive
this packet and assign themselves a level, one greater than the
level they have received i.e., level 1. After establishing their
own level, they broadcast a new level_discovery packet
containing their own level. This process is continued and
eventually every node in the network is assigned a level. On
being assigned a level, a node neglects any such future packets.
This makes sure that no flooding congestion takes place in this
phase. Thus a hierarchical structure is created with only one
node, root node, at level 0. A node might not receive any
level_discovery packets owing to MAC layer collisions. We
explain how to handle such special cases in Section 4.3. In this
paper, we use a simple flooding mechanism to create the
hierarchical structure. Instead, we could have used more
accurate minimum spanning tree algorithms. We will show that
the choice between the two results in an accuracy versus
complexity tradeoff.
4.2 Synchronization Phase
In this phase, pair wise synchronization is performed along
the edges of the hierarchical structure established in the earlier
phase. We use the classical approach of sender-receiver
synchronization [5] for doing this handshake between a pair of
nodes. We shall show the merits of this approach to the
approach of receiver-receiver synchronization in later sections.
Let us first analyze, how a two-way message exchange
between a pair of nodes can synchronize them. Figure 1 shows
this message-exchange between nodes ‘A’ and ‘B’. Here, T1, T4
represent the time measured by local clock of ‘A’. Similarly T2,
T3 represent the time measured by local clock of ‘B’. At time
T1, ‘A’ sends a synchronization_pulse packet to ‘B’. The
synchronization_pulse packet contains the level number of ‘A’
and the value of T1. Node B receives this packet at T2, where T2
is equal to T1 +
∆
+ d. Here
∆
and d represents the clock drift
between the two nodes and propagation delay respectively. At
time T3, ‘B’ sends back an acknowledgement packet to ‘A’. The
acknowledgement packet contains the level number of ‘B’ and
the values of T1, T2 and T3. Node A receives the packet at T4.
Assuming that the clock drift and the propagation delay do not
change in this small span of time, ‘A’ can calculate the clock
drift and propagation delay as:
)1(
2
)34()12(
;
2
)34()12(
TTTT
d
TTTT
−
+
−
=
−
−
−
=∆
Knowing the drift, node A can correct its clock
accordingly, so that it synchronizes to node B. This is a sender-
initiated approach, where the sender synchronizes its clock to
that of the receiver.
Figure 1: Two-way message exchange between pair of nodes
This message exchange at the network level begins with the
root node initiating the phase by broadcasting a time_sync
packet. On receiving this packet, nodes belonging to level 1 wait
for some random time before they initiate the two-way message
exchange with the root node. This randomization is to avoid the
contention in medium access. On receiving back an
acknowledgment, these nodes adjust their clock to the root node.
The nodes belonging to level 2 will overhear this message
exchange. This is based on the fact that every node in level 2 has
at least one node of level 1 in its neighbor set. On hearing this
message, nodes in level 2 back off for some random time, after
which they initiate the message exchange with nodes in level 1.
This randomization is to ensure that nodes in level 2 start the
synchronization phase after nodes in level 1 have been
synchronized. Note that a node sends back an acknowledgement
to a synchronization_pulse, provided that it has synchronized
itself. This ensures that no multiple levels of synchronization are
formed in the network.
This process is carried out throughout the network and
eventually every node is synchronized to the root node. In a
sensor network packet collisions can take place quite often. To
handle such scenario a node waiting for an acknowledgement,
timeouts after some random time and retransmits the
synchronization_pulse. This process is continued until a
successful two-way message exchange has been done.
4.3 Special Provisions
In a sensor network, the nodes are usually deployed in a
random fashion. So scenarios might exist where a sensor node
joins an already established network i.e., the node might join the
network when the level discovery phase is already over. Even if
the node is present at the onset of the network, it might not
receive any level_discovery packets owing to MAC layer
collisions. In either case it will not be assigned any level in the
hierarchy. However, every node needs to be a part of the
hierarchical topology so that it can be synchronized with the
root node. Thus, when a node is deployed, it waits for some
time to be assigned a level. If it is not assigned a level within
that period, it timeouts and broadcasts a level_request message.
The neighbors reply to this request by sending their own level.
The new node assigns itself a level, one greater then the smallest
level it has received and hence, joins the hierarchy. This could
be seen as a local level discovery phase.
Sensor nodes may also die randomly. A situation may
arise, when a level i node does not have any neighbor at level i-
1. In such scenarios, the node would not get back an
acknowledgement to its synchronization_pulse. Thus, this node
at level i would not be able to synchronize to the root node. It
has already been explained that in order to handle collisions, a
node would retransmit the synchronization_pulse after some
random amount of time. After retransmitting the
synchronization_pulse a fixed number of times, a node assumes
that it has lost all its neighbors on the upper level and broadcasts
a level_ request message. On getting back a reply, the node is
assigned a new level. Assuming the network is still connected,
the node will have at least one node in its neighbor set and thus
it will surely be assigned a new level in the hierarchy. We
consider four retransmissions to be a heuristic for deciding non-
availability of a neighbor in the upper level. The validity of this
heuristic has been verified via simulations. In general, choosing
a large number will increase the time taken for synchronization
whereas a small number will cause unnecessary flooding in the
network, decreasing the synchronization accuracy.
We started with the premise that a node has been
designated as the root node. If an elected root node dies, the
nodes in level 1 would not receive any acknowledgement
packets and hence, they will timeout following the scheme
described above. Instead of broadcasting a level_request packet,
they run a leader election algorithm and the elected leader takes
over the functionality of the root node. This new root node starts
from the beginning and reruns the level discovery phase. Note
that these special provisions are essentially heuristics to take
care of ambiguities in the network. Though we do not claim that
these are indeed the optimal solutions, we have verified their
efficacy via extensive simulations.
5. ERROR ANALYSIS OF TPSN
In this section, we characterize the possible sources of error
and present a detailed mathematically analysis for TPSN. We
concentrate on pair wise synchronization between two nodes.
We compare the performance of our scheme to RBS [7], an
algorithm that synchronizes a set of receivers in sensor
networks. However, as will be clear from our analysis, the
results can be in general extended to make a comparison
between the classical approach of sender-receiver
synchronization and receiver-receiver synchronization.
5.1 Decomposition of Packet Delay
Figure 2 shows the decomposition of packet delay when it
traverses over a wireless link between two sensor nodes. We
designate the node that initiates the packet exchange as the
sender and the node that responds to this message as the
receiver. Although a similar decomposition has also been
presented in [7], we detail the various delay components from a
systems perspective. In this discussion, we will borrow terms
from a typical layered architecture used in traditional computer
networks. We briefly analyze each component shown in Figure
2.
• Send time: When a node decides to transmit a packet,
it is scheduled as a task in a typical sensor node. There
is time spent in actually constructing the packet at the
application layer, after which it is passed to the lower
layers for transmission. This time includes the delay
incurred by the packet to reach the MAC layer from
the application layer. This delay is highly variable due
to the software delays introduced by the underlying
operating system.
• Access time: After reaching the MAC layer, the
packet waits until it can access the channel. This delay
is specific to wireless networks resulting from the
property of common medium for packet transmission.
T2
T3
T1 T4
T2, T3 are
measured in
Node B clock.
T1, T4 are
measured in
Node A clock.
B
A
