Collaborative Scheduling in Highly Dynamic
Environments Using Error Inference
Qingquan Zhang
†
, Yu Gu
¶
, Lin Gu
‡
, Qing Cao
§
and Tian He
∗
†
Lemko Corporation, Illinois, USA
∗
Department of Computer Science and Engineering, University of Minnesota Twin Cities
‡
Department of Computer Science and Engineering, Hong Kong University of Science and Technology
¶
Information Systems Technology and Design Pillar, Singapore University of Technology and Design
§
Department of Electrical Engineering and Computer Science, University of Tennessee Knoxville
Abstract—Energy constraint is a critical hurdle hindering
the practical deployment of long-term wireless sensor network
applications. Turning off (i.e., duty cycling) sensors could reduce
energy consumption, however at th e cost of low sensing fidelity
due to sensing gaps introduced. Existing techniques have studied
how to collaboratively reduce the sensing gap in space and
time, however none of them provides a rigorous approach to
confine sensing error within desirabl e bounds. In this work,
we propose a collaborative scheme called CIES, based on the
novel concept of error inference between collaborative sensor
pairs. Within a node, we use a sensing probability bound to
control tolerable sensing error. Within a neighborhood, nodes can
trigger additional sensing activities of other nodes wh en inferred
sensing error has aggregately exceed the tolerance. We conducted
simulations to investigate system performance using historical soil
temperature data in Wisconsin-Minnesota area. The simulation
results demonstrate that the system error is confined within the
specified error tolerance bounds and that a maximum of 60
percent of the energy savings can be achieved, when the CIES
is compared to several fixed probability sensing schemes such
as eSense. We further validated th e simulation and algorithms
by constructing a lab test-bench to emulate actual environment
monitoring applications. The results show th at our approach is
effective and efficient in tracking the dramatic temperature shift
in highly dynamic environments.
I. INTRODUCTION
Wireless Sensor Networks (WSNs) have been used in many
monitoring applications. Due to the small form factor and low
cost of sensor nodes (e.g. the Mica series), they are normally
equipped with limited power sources. If working continuously,
a sensor node can typically sustain only a few days. On the
other hand, long-term applications [1] are normally required
to last for weeks or even months. The discrepancy between
limited resources and stringent requirements makes it neces-
sary to develop scheduling protocols to turn on and off (i.e.,
duty cycle) sensors to conserve energy.
Research on collaborative sensing is nothing new [2], [3],
[4], [5], [6]. Most of projects focus on how to efficiently
select or deploy a minimum set of sensor nodes to provide
a full/partial spatiotemporal coverage. We note these work
determines sensing activities of nodes based on coverage
requirements in space and/or time. None of them focuses on
how to schedule sensing activities based on sensing error and
hence failed to provide a rigorous approach to confine data
accuracy within desirable bounds.
In this work, we take a completely different approach. We
schedule sensing activities based on two types of information:
(i) local estimated error and (ii) inferred error from neighboring
nodes. A node turns on its sensors when either error type ex-
ceeds a user specified tolerance. Our design has several major
advantages over existing single-node scheduling methods [7]:
(i) nodes can share sensing error information and process
them with limited resources, (ii) nodes can collectively control
sensing errors through neighborhood coordination, and (iii) a
network can respond to dramatic environmental changes more
quickly, a property that is desirable in environment monitoring
applications.
Specifically, our design exploits neighbor node coordination
to reduce possible violations against sensing fidelity require-
ments. The driving idea of our work is error inference, where
the term error is defined as the difference, in percentage,
between the ground truth environmental data and the corre-
sponding value generated by the predictor of sensor nodes,
which is a direct performance indicator of the sensor system.
Not only is the error information used by the local sensing
scheduler, but it is also shared among neighbors. Nodes can
trigger additional sensing activities of other neighboring nodes
when the inferred error has aggregately exceed the tolerance.
We refer to our proposed approach as Collaborative Inferred
Error Sensing (CIES).
The main contributions of this work are:
• The design of a local error control algorithm to guarantee
a specified error bound;
• The introduction of a distributed inference model of
prediction error for neighboring sensors
• The integration of both local and neighbor error control
into a unified architecture to adjust duty cycles of sensor
nodes.
• The simulated study and test-bed implementation of the
proposed design that conserves as much as 60% of energy
compared to other solutions, while confining sensing error
within specified error tolerance.
The rest of this paper is organized as follows. We present
the overview for our design in Section II. Section III and
IV describe the details of the error control mechanisms. The
performance evaluation is presented in Section V. Section VI
describes the motivation behind our work from an application
perspective. Section VII concludes the paper.
II. OVERVIEW AND OBJECTIVES
This section presents an overview of our Collaborative
Inferred Error System (CIES). We first present the network
model and assumptions of the work, then describe the overall
system design.
A. Network Model
Assume a wireless sensor network is composed of N sensor
nodes. Each sensor node has two states: an active state and a
dormant state. An active node performs all the functionalities,
such as sensing events, transmitting packets, and receiving
packets. A dormant node turns off most functional modules
except the radio for listening to incoming traffic. All nodes
have their own schedules that are controlled by the duty cycle
controller on the nodes. A dormant node wakes up when (i) it is
scheduled to switch to active state, or (ii) it receives triggering
packets from neighbors and decides to change into the active
state.
B. Assumptions
We assume that we use off-the-shelf sensor node prod-
ucts [8]. Without loss of generality, in our design and im-
plementation, sensor nodes are homogeneous and can be
distributed as a random process. We also assume that in our
target sensing platforms, sensing is much more expensive
than communication, so that it is necessary to coordinate
sensing activities among neighboring nodes for better energy
efficiency. Certainly, this assumption does not hold for all
platforms, but it does apply to a few existing ones. For
example, the magnetometers used in the MICA sensor boards
and XSM nodes draw about 90 mA of current, as compared
to 6mA for the ATmega128L micro-controller and 12 mA for
the transceiver [9]. This assumption also holds well in plat-
forms where expensive sensors (e.g. camera and micro-power-
impulse radar (MIR)) and low-power-listening techniques [10]
are used.
C. A Walk-through of the Basic Operating Procedures
In this section, we overview the collaborative scheme of our
design using a walk-through example. The key concept in CIES
is to exploit the neighbors’ resource to infer the conditions of
inactive/sleep sensor nodes. A brief description as illustrated
in Figure 1 presents the collaborative error control process.
Figure 1(a) , Stage I: Each sensor node executes its local
error control procedure (IES) independently. Meanwhile, the
network error control starts to build the neighbor library using
a neighborhood discovery service [11], [12]. In our example,
node 8 detects node 1 to 6 as its neighbors. The local error
control will handle local node error control and duty cycle
management.
Figure 1(b), Stage II: The network error control generates
node-pair weighted graphs to represent the correlation among
sensors. Figure 1(b) lists the edge weight w (i , j) of several
nodes. The higher a weight is, the stronger correlation these
E<8,6>=33%
Dormant
Trigger
Trigger
E<8,2>=40%
E<8,2>=40%
<(4,8),5>
<(6,8),7>
<(5,8),7>
<(2,8),10>
<(1,5),7>
W=<(1,2),6>
1
2
8
4
5
6
1
2
8
3
4
5
6
7
E<8,4>=20%
E<8,5>=20%
2
8
4
5
6
E<8,6>=33%
2
8
4
5
6
8
8
8
Neighbors
(a)
(b)
(c)
Active
(d)
W=<(node i, node j),value>
Error Tollerance (30%)
3
7
Fig. 1. Initial phase of the design
two sensor nodes will have. Previous literature has pointed out
that it is reasonable to assume that this correlation is relatively
stable for a period of time [13].
Figure 1(c), Stage III: Sensor nodes are controlled not only
by the local error control, but also are sharing their resource to
assist the neighbors, a process enabled through the utilization
of the neighbors sensing error inference. For example, a sensor
node (e.g. node 8 in this case) is active in a certain cycle, and
detects an unexplained difference between the real sensing data
and the output of prediction model. Then it calls the network
error control to generate inferred error of adjacent nodes using
the weighted graph shown in Figure 1(c).
Figure 1(d), Stage IV: If the inferred reading of any neighbor
node is larger than a specified bound (e.g. the tolerance
threshold of errors), the network error control will send out
a trigger message to those nodes. In this example, because
the error tolerance configured by the system is 30%, node 8
will send trigger messages to nodes 2 and 6 . After a sensor
node receives such a message, it will process and analyze the
information in the network control. After then, the node can
either remain turned off if the inferred error from network error
control is not large enough to trigger the duty cycle control
process, or be switched on if otherwise.
As illustrated by this walk-through, CIES exploits neigh-
bors collaboration of sensor networks in event detection, thus
showing a unique potential for reducing errors in environment
monitoring applications. Compared to other local error control
schemes [7], CIES extends the error control from local node
level to the network level, setting the foundation for more
complicated applications.
In the following, we describe the design in more detail. One
key objective of this work is to develop a generic error control
mechanism through which collaborative sensors can achieve
error-bounded scheduling control in applications.
III. LOCAL ERROR CONTROL
The design of the local error control is motivated by the
observation that a sensor node should be able to run programs
Local Error Control Layer
Prediction
Local Error Data
Library
Hardware Layer
Sensing and Data Storage
Input Data
Adjust Sensing
Frequency
Local Error Predictor
Duty Cycle Controller
Error Analyzer
Adaptor
Fig. 2. The local error control layer illustration
independently even in isolation. Therefore, the data detected
and stored locally should also be fault-tolerant, a goal that is
achieved by the local error control
For convenience, we refer to the local error control as Non-
collaborative IES, which supports routine applications that
include the duty cycle control and local error predictor as
shown in Figure 2. A sensor uses its local error predictor
to predict the environment status without performing actual
sensing operation. When data is obtained through actual
sensing, a node compares predicted sensing values with the
actual sensing values, and then store the prediction errors
into the local error data library. Based on the accuracy of
the local error predictors, the duty cycle controller adjusts the
sensing frequency through error bound control, which serves
to confine the system prediction error within a user specified
bound.
A. Local Error Predictor
The basic mechanism of local error predictor works as
follows. In order to conserve their limited power supply,
sensors do not continuously sense data. Instead, they operate at
some selective cycles as long as the data quality is acceptable.
The data in the remaining cycles are reconstructed through
appropriate prediction models. If the environment exhibits
cyclic patterns, an empirical model will be used to establish
strong correlations in the data and to organize them in a certain
way so that future data can be extracted from the empirical or
historical ones.
Depending on system lifetime the data fidelity requirement
of an application, the empirical model can be constructed
in different ways. Similar to [14], we developed a cycle-
based empirical model [15], which has been proven to be
efficient for environment monitoring applications. The error
predictor is mainly responsible for generating prediction errors,
defined as e
i
, for each node i. Our preliminary experiments
of temperature measurements, as shown in Figure 3 and
Figure 4, demonstrate that the error predictor can adapt to
the environmental changes sufficiently well.
Since the energy resource on individual sensor nodes is lim-
ited, empirical model in this application domain can simplify
data processing, and thus extend the lifetime of sensor nodes.
However, the model selection can be flexible, and the duty
cycle controller can adapt the system to the relative error
induced by different prediction models. Moreover, the local
Fig. 3. The preliminary temperature measurement experiments
840 850 860 870 880 890 900
−400
−350
−300
−250
−200
−150
−100
−50
0
50
100
Real Data
Prediction Data
Fig. 4. An example of output from predictor (error tolerance 10%, x-axis is
the time-stamp)
error predictor provides a reliable reference for duty cycle
controller to perform further analysis.
B. Duty Cycle Controller
The duty cycle controller receives and analyzes the predic-
tion errors from the local error predictor. The first step in de-
signing the duty cycle controller is modeling sensing behavior
of the system mathematically to derive the relationships among
the local prediction error, the current duty cycle, and system
requirements. In this design, we separate the controller into
the error analyzer and duty cycle adaptor, two processes that
can run collaboratively.
1) Error Analyzer: We determine the error analyzer theoret-
ically as follows. We assume that the sensing baseline consists
of N data cycles, in which k warm-up cycles will be used for
building controller models. In each cycle, the probability that
a sensor node performs actual sensing operation is defined
as sensing probability p
i
. To simplify the description, without
loss of generality, instead of considering energy cost spent on
different components, (e.g., sensing and processing), we use
average energy consumption to represent the total energy cost
of a node to sense, process and communicate in each sensing
period. Let the average energy consumption for sensing be E
a
.
When a sensor is inactive, it does not sample the environment,
instead it uses the local predictor to estimate sensing readings,
which introduces prediction errors. Let the potential prediction
error at each cycle be e
i
. And let the maximum prediction
error tolerance specified by a user be e
t
. Therefore, the goal
of our design is to minimize the energy consumption during
each baseline period:
E =
k
X
i=1
E
a
· t
i
+
N−k
X
i=1
p
i
· E
a
· t
i
(1)
under the constraint that
N
P
i=1
(1 − p
i
) · e
i
N
=
N
P
i=k
(1 − p
i
) · e
i
N
≤ e
t
(2)
where t
i
is the unit cycle length, k is the length of cycles used
to stabilize the scheduling system and N represents the total
length of operational cycles . The constraint will enforce that
the potential statistical error caused by the prediction will be
smaller than the error tolerance. The range of possible values
of p
i
will be bounded to satisfy the constraint equation.
The minimization of energy consumption deals with several
key issues, e.g. the length of the training cycle and the
prediction model used. Now the problem is to determine the
appropriate p
i
for a given error range e
i
obtained from past
data values. To solve for sensing probability p
i
at a specific e
i
requires a joint distribution of a process for e
i
at specific time
instance or period. This would require a heavy computation
and storage overhead on the limited resource of the sensor
node. Obtaining a solution for sensing probability p
i
will be
extremely difficult to calculate during transitions. Instead, we
introduce a lightweight method for computation that allows the
sensor to choose the value within a range. We first determine
the bound for sensing probability p
i
, and the algorithm will
choose one value within that bound.
It should be clear that the higher the value of sensing
probability p
i
, the larger the expected energy consumption.
The lower the value of sensing probability p
i
, the higher the
probability for the error because that prediction will be greater
than the tolerance. Therefore, we need to analyze the bound
of sensing probability p
i
to optimize this trade-off.
2) Determining the Sensing Probability Bound: We use a
bottom-up approach to set a bound for the sensing probability.
That is, if we do not violate the error constraint in every cycle
instance, we are certain that the inequality holds. As noted,
this sets a stricter requirement than the constraint equation
over all sampling instances. By doing so, our probability
constraint problem can be simplified into choosing the p
i
at
each scheduling cycle to satisfy the constraint on (1 − p
i
) · e
i
,
which can be solved as
p
lb
i
=
0 0 ≤ e
i
≤ e
t
1 −
e
t
e
i
e
t
≤ e
i
≤ 1
(3)
The p
lb
i
is the lower bound of p
i
that guarantees data quality
requirement at each sensing cycle instance. Only values higher
than this will assure that the constraint requirement won’t be
violated under any circumstances. We should also be careful
in the selection of p
i
, as a higher p
i
implies more energy
consumption by the sensor node.
We also note in Equation 3 that the lower bound p
lb
i
is
affected by the prediction error e
i
. A large prediction error e
i
imposes a higher bound, leading to high energy consumption.
Network Error Control Layer
Neighbor Error Control
Neighbor Error Predictor
Neighbor Table
Weigh Graph
Local Error Control Layer
Local Error Data
Library
Hardware Layer
Sensing and Data Storage
Input Sensing Data
Adjust Sensing
Frequency
Inferred Error
Adjust Duty Cycle
Neighbor Inferred Error
Communication
Prediction
Local Error Predictor
Duty Cycle Controller
Error Analyzer
Adaptor
Fig. 5. The network error control layer illustration
The critical issue is to reduce this prediction error e
i
. Clearly it
can be achieved with a better prediction model, however when
environment changes quickly and unpredictably, a prediction
model based on historical data is not effective. Therefore we
need online method to improve error control, which is achieved
through the Network Error Control described in next section.
IV. NETWORK ERROR CONTROL
In this section, we present the design of network error
control as shown in Figure 5. Recall in our analysis in
section III-B2, it is essential to predict the neighbors’ model
prediction error accurately and share such information among
them effectively. To ensure the accuracy of such prediction
and information sharing, we assign tasks to two processes:
1) neighbor error predictor, 2) neighbor error controller. The
process running on this network control layer is named col-
laborative IES, which aims to maximize the energy saving and
minimize the prediction error of sensor system.
Before further discussion, we define several terms used to
describe the processes.
Definition 1 (Inferred Error e
ij
): Given a node i and its
neighboring node j, the node-pair inferred error e
ij
is defined
as the inference error at neighbor j from the point view of
node i.
Definition 2 (Node-pair Weight w
ij
): The weight is de-
fined as the extent of a node-pair’s data correlation and
indicates how similar the sensing observation is between two
neighboring sensor nodes i and j.
Definition 3 (Error Probability Density Function ρ (e) ):
The error PDF is a collection of distributions of detection
errors in which the past detection errors for sensors are
stored and processed so that the detection errors can be
directly linked to corresponding occurrence probability. The
neighboring nodes will exchange the error PDF locally. We
can easily derive its statistical accrual error probability mass
function( PMF) once the PDF is given.
A. Design of Neighbor Error Predictor
Since the neighbors can change dynamically, we need to
iteratively estimate the neighbors’ prediction error, given a
certain relationship among neighbors.
Fig. 6. The process of Correlation Calculation
Step 1: Neighbor Recognition
The control process starts with neighborhood discovery.
During this phase, the sensors will acquire the knowledge
that which close sensors around them can build up a “trust”
relationship, which can be characterized as node-pair weights.
The formation of neighborhood may be based on different
requirements such as vicinity, link quality or the displacement
along the routing path of the sensing data. In this stage,
each node recognizes its neighboring nodes and assigns a
table for each neighbor to build the weight graph. Note that
the neighborhood formation is a dynamic stage which will
be refreshed after a defined period. By the end of this sub-
process, sensors will recognize their neighbors and data storage
structures created for neighbors will also be initialized.
Step 2: Weight Graph Construction As pointed in our
earlier assumptions, nodes are synchronized with each other,
and T
train
, the time for initialization, is divided into equal time
durations T
build
, as in Figure 6. Each time duration includes
m equal duration intervals, where an interval is a unit sample
time period set by the user.
For each round, each node N
i
stores its observation vec-
tor {o
i
1
, o
i
2
, ..., o
i
m
} obtained through discrete sampling at
T
i
= {t
i
1
, t
i
2
, ..., t
i
m
}. At the end of each round, each node
exchanges the observation vector, which is used to calculate the
correlation between nodes. This process is repeated until the
end of T
train
, so that the average sensing correlation between
nodes can be estimated.
Specifically, we use the following approach to calculate data
correlation between two observation vectors C(i, j) by node
N
i
and node N
j
.
C(i, j) =
m
P
o
i
k
o
j
k
−
P
o
i
k
P
o
j
k
p
m
P
(o
i
k
)
2
− (
P
o
i
k
)
2
q
m
P
(o
j
k
)
2
− (
P
o
j
k
)
2
(4)
After getting the data correlation C(i, j), we derive w(i, j)
as abs(C(i, j) × R) in which R is a unified constant.
The weight value among nodes, once evaluated, remains
constant throughout each short operation period, and is sub-
jected to subsequent modifications to guarantees the accuracy.
The sensors propagate the information to neighboring sen-
sors while receiving similar information, forming a graph
through a one-to-one linear mapping. Eventually, based on the
outcome from this sub-process, each sensor obtains essential
node-pair weights which set the foundation to differentiate the
status information in the error estimation.
1) Costs and Complexity on Weight Graph Construction:
Here we will study the extra computation cost used for weight
graph construction. With a maximum of N sensor nodes within
a group, there are a maximum of N − 1 neighbors for each
node. The total weight edges between two nodes will be
C
2
N
=
N(N − 1)
2
However, this value can be reduced after neighbor groups
are formed because the total number of weight vectors will
decrease as the nodes out of one-hop communication range are
excluded. This can be expressed as: C
2
N
− C
2
m
=
N(N−1)
2
−
m(m−1)
2
, in which m is the number of nodes that are not
in one-hop range. Therefore the computation costs for weight
graph will be O(N
2
).
Step 3: Achieving the inferred error e
ij
for neighbors
The control of sensing errors in the network is further
guaranteed by the collaboration of neighboring nodes. The
observations that sensor nodes demonstrate spatial correlations
found in [16], [17], [18] are also supported by our pre-
liminary experiments described in Section III. Motivated by
such observations, we can predict error of neighboring nodes
using local prediction error. That is, an active sensing node,
by comparing its real-time sensing values with corresponding
predicted values, can infer the prediction errors of correlated
neighboring nodes. In this way, our neighbor-error inference
scheme ensures real-time tracking and quick response to the
error status change within a sensing group. The process can
be summarized as follows:
• At a sampling cycle m, assuming sensor i is active in
sensing and computation, we can easily calculate the
observation error e
m
i
at source node i based on the
difference between actual sensing data and prediction
values that are generated by our prediction model.
• From its error Probability Density Function ρ (x), node i
evaluates the cumulative distribution function PMF
i
(e
m
i
)
as in Equation 5. From this result, we can infer the
statistical confidence level of the worst error occurrence
at node i as.
P MF
i
(e
m
i
) =
Z
e
m
i
−e
m
i
ρ (x) dx (5)
• Upon obtaining the P MF
i
, the active sensor node i
calculates the inferred error of a neighboring sensor j,
based on PDF information of sensor node j. Given the
neighbors error models, an iterative step is performed:
e
ij
= P M F
j
−1
(P MF
i
(t [k])) (6)
and the variable t [k] is expressed as:
t [k] =
2 · t [k − 1] P MF
j
(t [k − 1]) < P M F
i
(e
m
i
)
t[k−1]+t[k− 2]
2
P MF
j
(t [k − 1]) > P M F
i
(e
m
i
)
(7)
in which P M F
−1
() is the inverse function of P M F and
t [0] = 0, t [1] = e
m
i
. The iterative process will not stop
until P M F
j
(t [k − 1]) = P M F
i
(e
m
i
).
