Arbeit

TECHNISCHE UNIVERSITT DRESDEN
FAKULTT ELEKTROTECHNIK UND INFORMATIONSTECHNIK

INSTITUT FR NACHRICHTENTECHNIK

LEHRSTUHL FR TELEKOMMUNIKATION

Analysis of the energy consumption of 3D localization algorithms

Mini Project

Author: Santiago Mio
Betreuer: Dipl. Ing. Jorge Juan Robles
Professor: Prof. Dr. Ing. Ralf Lehnert
Datum: 30.01.2013

SELBSTNDIGKEITERKLRUNG
Hiermit erklare ich, dass ich die am heutigen Tag beim Prufungsausschuss der Fakltat
Elektrotechnik und Informationstechnik eingereichte Mini Project zum Thema:
Analysis of the Energy Consumption of 3D Localization Algorithms
Vollkommen selbstandig von mir verfasst, und keine anderen als die angegebenen Quellen und
Hilfsmittel verwendet sowie Zitate kenntlich gemacht wurden.

Dresden, den 30.01.2013

Santiago Mio.

ABSTRACT
In an indoor scenario it could be necessary to know the position of an object. For this purpose, a
localization system could be implemented in an indoor Wireless Sensor Network. In this kind of
networks, sometimes there are devices that use batteries and therefore the energy consumption
must be reduced in order to extend its lifetime.
In this work, the execution time of nine position algorithms were measured, analyzed and
implemented in an 8-bit microprocessor. Knowing the time required to perform a certain task, it is
possible to estimate the energy consumption of it. Furthermore, in order to reduce the execution
time of the task, some optimizations in the code were carried out minimizing the number of
operations.

SANTIAGO MIO TECHNISCHE UNIVERSITT DRESDEN
1

INDEX
1. INTRODUCTION.2
1.1 MOTIVATION.2
1.2 PROJECT DEFINITION..2
2. BACKGROUND2
2.1 LOCALIZATION ALGORITHMS.2
2.2 HARDWARE RESOURCES..4
2.2.1 RADIO CONTROLLER BOARD RCB231 v4.4......................................................4
2.2.2 SENSOR TERMINAL BOARD................................................................................4
2.3 TIMESTAMPS.......... .5
3. MEASUREMENTS PROCEDURE..5
4. FUTURE WORKS.19
5. CONCLUSIONS.19
6. BIBLIOGRAPHY21

2

1. INTRODUCTION

1.1 MOTIVATION

In many applications of Wireless Sensor Networks (WSN), for example in localization
systems, some devices (nodes) should use batteries. In these cases, it is advisable to
optimize the code in order to reduce the energy consumption of the devices and extend
the lifetime of the batteries.
One of the easiest ways to do this is selecting the functions which consume less time to
perform the same work. Thus, it is necessary to know the execution time of the tasks.
Furthermore, by knowing the execution time of different functions and the power
dissipation of the node when it is processing, it is possible to estimate the total energy
consumption required in the execution of the investigated tasks.

1.2 PROJECT DEFINITION

In this project, nine localization algorithms are implemented and their energy
consumption is analyzed. As described, one way to estimate the energy consumption of a
certain task is by knowing its execution time. This can be done using timestamps at the
beginning and the end of the execution of an algorithm.
The measurements are performed in the microcontroller of the sensor node that,
eventually, can be part of a network. The microcontroller has a timer with a resolution of
one ps, so this is the greater precision that we will obtain in our measurements.

2. BACKGROUND

2.1 LOCALIZATION ALGORITHMS

Localization algorithms require certain data to estimate the position of an unknown node.
For instance, the distance-based localization algorithms use the distance between two
nodes to calculate the coordinates of one node. Each localization algorithm has different
characteristics. Some are more complex and precise but consumes more time; while
others are simpler, but also more imprecise.
In a typical localization system we identify two types of nodes: fixed nodes, called anchors
and mobile nodes. In general, the number of anchors is higher than mobile nodes and its
position is known. Since anchors have a static position, they can have an external supply
and the energy consumption it is not a problem in this case. In the case of mobile nodes,
the energy consumption is a factor to take into account because we are forced to use
batteries and so we have to optimize their behavior.

3

The localization algorithms implemented in this work belong to the group of distance
based algorithms, i.e. that at first, it is necessary to know the distance between fixed and
mobile nodes.
Regardless of the algorithm that we are using, three stages in the estimation system can
be established, and they are:

- Communication or Discovery Phase: here the mobile node detects which
anchors are in transmission range and with which one it can work.
- Ranging: it represents the measurements of distance carried out by the mobile
node. For this purpose, different methods like RSSI (Receive Signal Strength
Indication), POA (Phase of Arrival), etc. can be used.
- Calculation: the calculations can be centralized or distributed. In a centralized
calculation, all the measurements of a node are sent to a central device to its
position estimation. Mobile nodes do not make any calculation and the
network traffic increases. On the other hand (distributed calculation), mobile
nodes estimates its own position reducing the traffic in the network. This is the
case treated in this work.

As already mentioned, nine 3D localization algorithms were implemented in the
microcontroller of a sensor node to estimate their execution time. The algorithms used
are:
- Weighted centroid.
- Standard Min-Max
- Extended Min-Max 1
- Multilateration
- Extended Kalman Filter
- Position Extended Kalman Filter

The number of necessary operations carried out by these algorithms was studied in a
previous work [1]. Here a review is given:

Weighted centroid and Standard Min-Max are perhaps the simplest. They only use basic
functions like addition, subtraction and very few multiplications and divisions.
The group of 4 Extended Min-Max [2] are similar to each other. The only difference is that
they use different weights to calculate the final position. Among them, Extended Min-
Max 1 and Extended Min-Max 2 are the most time-consuming due to the use of functions
like sqrt in the calculation of Euclidean distance. In the other hand (Extended Min-Max 3
and Extended Min-Max 4), Manhattan distances are used instead of Euclidean distance for
4

the calculation of the weights. The number of operations executed by Manhattan distance
is fewer than those necessary for the Euclidean distance.
Slightly more complex is the Multilateration algorithm, but does not consume much time,
since it use only basic functions.
Both Extended and Position Extended Kalman Filter [3] are clearly the most complex of all,
requiring the execution of a lot of operations.

2.2 HARDWARE RESOURCES

2.2.1 RADIO CONTROLLER BOARD - RCB231 v4.4
For the implementation of the code was used the RCB231 v4.4.0 [4]. This board from
Dresden Elektronik Company contains the 802.15.4 transceiver AT86RF231, which
operates at 2.4GHz, and the low-power 8-bit C Atmega2561. This microcontroller also
works with a quartz at 16 MHz.

Figure 1: RCB231 v4.4.0 [4]

2.2.2 SENSOR TERMINAL BOARD

Along with that seen in 2.2.1, in this work we also use a Sensor Terminal Board from
Dresden Elektronik Company [5]. This platform can be used with all radio controller
boards. See figure 2.
5

Figure 2: Sensor Terminal Board [5]

Its main features are:
- On-board temperature sensor
- 32kB memory extension
- Serial interface (UART / 3.3 V digital)
- I2C bus
- External analog reference voltage
- Analog inputs
- Digital inputs/outputs

2.3 TIMESTAMPS

In this case, timestamps are like marks in the time domain. Usually, they are used when
we want to, for example, know the time difference between two events. It is a very
practical tool that served us well during all tests. The used microcontroller has a timer with
a resolution of 1 ps, which allows us to measure the execution time of the algorithms in a
very accurate way.

3. MEASUREMENT PROCEDURE

The measurement procedure is simple: we take a timestamp at the beginning and the end
of the algorithm or function we want to know its duration. Finally we calculate the
difference between these two timestamps:

timcstomp A unknown timc unction timcstomp B

tuta| Junct|un t|me = timcstomp B -timcstomp A
6

After measuring the time, it is sent to a computer via the USB port. The computer uses a
terminal software to show the received information.
It is important to take into account, that timestamps also consumes time and this should
be considered. In a very simple test, this value can be found out:

timcstomp A timcstomp B

tuta| t|mextamp t|me|x] = timcstomp B - timcstomp A = 22|x]

So 22 [ps] is the value obtained.

With the information about the execution time and the power dissipation of the
microcontroller when it is processing, we can estimate the energy consumption of the
executed task. In a previous work [6], the energy consumption of a similar node (RCB230
[7]) was measured in the main operation modes. Table 2 shows that.

Table 2: Energy consumption Node RCB230 v3.2 [7]
As is known, energy consumption is directly proportional to time, so knowing the time
required, it is possible to indirectly estimate it. Considering that our node has a power
dissipation of 30.42 [mW] when it is executing a localization algorithm, the corresponding
energy consumption can be estimated by multiplying this value by the execution time. For
example, for an execution time of 20 [s], the corresponding energy consumption will be:
Iotol cncrgy = 2u. 1u
-6
|s] x Su,42. 1u
-3
|w] = , 84. 1
-7
|]] = 8, 4|n]]
Know the execution time of basic operations in the microcontroller is the first step in the
estimation of the energy consumption. Doing that was possible to identify, for example,
that function pow(X,n) (that allows us to raise a number X to the nth power), consumes
7

more time than only X
1
*X
2
*X
3
**X
n
. In the implementation of the algorithm, the
operations were replaced or optimized considering that.

Figure 3
Average values [us] with a 95%
confidence interval:

Multiplication = 42,392 _ 0,374
Division = 85,562 _ 0,364
Pow = 41,362 _ 0,074
Square = 41,836 _ 0,0699
Sqrt = 84,892 _ 0,243
Fabs = 42,23 _ 0,08
Add = 41,081 _ 0,143
Sub = 39,72 _ 0,119
Table 1
Figure 3 show the time consumed by various functions. As can it see, different functions
use different times. For all cases, random values (X and Y) were used and the format of the
operations is as follows:
- Multiplication: X*X
- Division: X/Y
- Pow: pow(X,2) = X
2

- Square: square(X) = X
2

- Sqrt: sqrt(X) = X
- Fabs: fabs(X*Y) = |X |
0
0,5
1
1,5
2
2,5
3
Mult. Division Pow Square Sqrt Fabs Add Sub
E
n
e
r
g
y

c
o
n
s
u
m
p
t
i
o
n

[
u
J
]
Math functions
8

From here onwards, 500 samples for each position algorithm and for different number of
anchors were taken. Anchors are reference nodes that the mobile node uses for estimate
the position. The standard deviation and average of the taken samples are calculated with
95% confidence intervals. In this case, we have more than 30 samples which are
independent of each other. Thus, the confidence intervals can be estimated as follows:
X -z
u2
Sn < p < X +z
u2
Sn
where: n = number of samples.
X = average value of n samples.
S = standard deviation of n samples.
p = mean value of the population.
z
u2
= value that ensures a 95% confidence interval. In this case, this value is 1,96.

The execution time of the localization algorithms were investigated with different number
of anchors. The next results show this.

9

Figure 4 (a,b)
Average values [us] with a 95% confidence interval for
1 Anchor

Weighted-Centroid = 458,068 _ 0,507
Standard MinMax = 392,262 _ 0,903
Extended-MinMax1 = 2760,632 _ 2,135
Multilateration = 885,476 _ 0,669
ExtendedKalmanFilter = 54971,58 _ 3,289
Pos.ExtendedKalmanFilter = 222359,158 _ 39,611
Table 3
0
500
1000
1500
2000
2500
3000
3500
A
v
e
r
a
g
e

t
i
m
e

[
u
s
]
1 Anchor
0
50000
100000
150000
200000
250000
ExtendedKalmanFilter Pos.ExtendedKalmanFilter
A
v
e
r
a
g
e

t
i
m
e

[
u
s
]
1 Anchor (cont.)
10

Figure 5 (a,b)
2 Anchors

Weighted-Centroid = 691,276 _ 1
Table 4
0
1000
2000
3000
4000
5000
6000
A
v
e
r
a
g
e

t
i
m
e

[
u
s
]
2 Anchors
0
50000
100000
150000
200000
250000
300000
350000
A
v
e
r
a
g
e

t
i
m
e

[
u
s
]
2 Anchors (cont.)
11

Figure 6 (a,b)
3 Anchors

Table 5
0
1000
2000
3000
4000
5000
6000
7000
A
v
e
r
a
g
e

t
i
m
e

[
u
s
]
3 Anchors
0
50000
100000
150000
200000
250000
300000
350000
400000
450000
A
v
e
r
a
g
e

t
i
m
e

[
u
s
]
3 Anchors (cont.)
12

Figure 7 (a,b)
4 Anchors

Table 6
0
1000
2000
3000
4000
5000
6000
7000
8000
9000
A
v
e
r
a
g
e

t
i
m
e

[
u
s
]
4 Anchors
0
100000
200000
300000
400000
500000
600000
700000
800000
A
v
e
r
a
g
e

t
i
m
e

[
u
s
]
4 Anchors (cont.)
13

Figure 8 (a,b)
5 Anchors

Extended-MinMax2 = 10178,926 _ 8,654
Table 7
0
2000
4000
6000
8000
10000
12000
A
v
e
r
a
g
e

t
i
m
e

[
u
s
]
5 Anchors
0
200000
400000
600000
800000
1000000
1200000
A
v
e
r
a
g
e

t
i
m
e

[
u
s
]
5 Anchors (cont.)
14

Figure 9 (a,b)
6 Anchors

Extended-MinMax2 = 12072,028 _ 9,216
Table 8
0
2000
4000
6000
8000
10000
12000
14000
A
v
e
r
a
g
e

t
i
m
e

[
u
s
]
6 Anchors
0
200000
400000
600000
800000
1000000
1200000
1400000
A
v
e
r
a
g
e

t
i
m
e

[
u
s
]
6 Anchors (cont.)
15

Figure 10 (a,b)
7 Anchors

Extended-MinMax1 = 12830,56 _ 10,314
Extended-MinMax2 = 13868,332 _ 10,854
Extended-MinMax4 = 9585,454 _ 10,382
Table 9
0
2000
4000
6000
8000
10000
12000
14000
16000
A
v
e
r
a
g
e

t
i
m
e

[
u
s
]
7 Anchors
0
200000
400000
600000
800000
1000000
1200000
1400000
1600000
1800000
2000000
A
v
e
r
a
g
e

t
i
m
e

[
u
s
]
7 Anchors (cont.)
16

Figure 11 (a,b)
8 Anchors

Extended-MinMax1 = 14489,796 _ 10,057
Extended-MinMax2 = 15673,346 _ 9,974
Extended-MinMax4 = 10779,268 _ 9,236
Table 10
0
2000
4000
6000
8000
10000
12000
14000
16000
18000
A
v
e
r
a
g
e

t
i
m
e

[
u
s
]
8 Anchors
0
500000
1000000
1500000
2000000
2500000
A
v
e
r
a
g
e

t
i
m
e

[
u
s
]
8 Anchors (cont.)
17

Figure 12 (a,b)
9 Anchors

Extended-MinMax1 = 16029,21 _ 11,607
Weighted-MinMax2 = 17347,138 _ 11,268
Weighted-MinMax3 = 9506,028 _ 9,429
Weighted-MinMax4 = 11892,218 _ 10,776
Table 11
0
2000
4000
6000
8000
10000
12000
14000
16000
18000
20000
A
v
e
r
a
g
e

t
i
m
e

[
u
s
]
9 Anchors
0
500000
1000000
1500000
2000000
2500000
3000000
3500000
Pos.ExtendedKalmanFilter
A
v
e
r
a
g
e

t
i
m
e

[
u
s
]
9 Anchors (cont.)
18

Figure 13 (a,b)
10 Anchors

Weighted-MinMax1 = 17668,354 _ 8,912
Weighted-MinMax2 = 19129,076 _ 9,577
Weighted-MinMax3 = 10421,13 _ 8,283
Weighted-MinMax4 = 13069,546 _ 9,829
Table 12
0
5000
10000
15000
20000
25000
A
v
e
r
a
g
e

t
i
m
e

[
u
s
]
10 Anchors
0
500000
1000000
1500000
2000000
2500000
3000000
3500000
4000000
Pos.ExtendedKalmanFilter
A
v
e
r
a
g
e

t
i
m
e

[
u
s
]
10 Anchors (cont.)
19

As can be expected, as the number of anchors increases, so does the time. In all cases, the
error or deviation is very small. Weighted Centroid and Standard Min-Max are the
algorithms that consumes less time. That is because they only use simple functions and
simple algebra to obtain the result.
There is a big difference, between the above mentioned algorithms and the group of
Extended-MinMax. The main reason for this is simple: Extended-Minmax presents a
greater complexity of the code and the addition of functions and operations. In particular,
Extended-MinMax1 and Extended-MinMax2 are bigger than Extended-MinMax3 and
Extended-MinMax4. This is because the inclusion in the first two algorithms of the function
sqrt that, as can be seen in figure 3, consumes more time than the others.
Multilateration is the algorithm which grows faster as the number of anchors increases. At
the beginning, it has a duration similar to Weighted Centroid or Standard MinMax, but
with a greater number of anchors, for example 8, its duration is like Extended-MinMax1 or
Extenden-MinMax2.
Extended Kalman Filter and Position Extended Kalman Filter are certainly the most time
consuming and this is due to the large number of operations that this algorithms performs.
Even with one anchor, they reach levels never reached for the other algorithms. Position
Extended Kalman Filter is an iterative algorithm which executes a certain number of
iterations for calculating position estimation (in the implementation there are 15 iterations
for calculation). Therefore, this algorithm is the most expensive one in terms of time
consuming.
Figure 12 and figure 13 do not show the values for Extended Kalman Filter. During the
execution, these values could not be obtained because the node accused an error and
could not continue with measurements. This is due to an error in the code that should be
investigated in the future in detail.
4. FUTURE WORKS

It would be advantageous to extend these measurements to a greater number of
algorithms, as well as implement it in other nodes with other microcontrollers. Other
alternatives to optimize the code could be investigated and implemented. It could be also
useful, to know the total energy consumption in a position estimation. It means, not only
the consumption due to processing of the algorithm, but also related to the necessary
communication between the nodes.

5. CONCLUSIONS

Measuring the time execution of certain tasks in a microcontroller, it is an option to
indirectly estimate the energy consumption of them. In this work, time measurements
20

was taken and investigated to understand the behavior of different localization algorithms
and its total energy consumption.
Nine localization algorithms were analized with different number of anchors, confirming
that there is a direct relationship between this and the execution time of each algorithm.
We detect that the division and sqrt functions have a longer execution time (about factor
two) than multiplications. Another conclusion was that Weighted centroid and Standard
Min-Max are very low complexity algorithms. On the other hand, Position Extended
Kalman Filter has an execution time of about one second with five Anchors. Therefore,
due to that, it is not recommended to execute this algorithm on a sensor node.

21

6. BIBLIOGRAPHY

[1]. Sergio Edesa: Performance investigation of low-complexity localization algorithms in 3D
scenarios, pages 29-34. Final Project, Chair of Telecommunications, Technische Universitt
Dresden, Germany, 2012.

[2]. Jorge Juan Robles, Javier Superva Pola, Ralf Lehnert: Extended Min-Max Algorithm for
Position Estimation in Sensor Networks, Workshop on Positioning and Navigation 2012
(WPNC 2012), Dresden.

[3]. Jaegeol Yim, Seunghwan Jeong, Kiyoung Gwon, Jaehun Joo: Improvement of Kalman
filters for WLAN based indoor tracking. Published in Journal Expert Systems with Applications,
Volume 37, pages 426-433, 2010.

[4]. Dresden Elektronik: Radio Controller Board RCB231SMA mega256 V4.4.0. Information
webpage available in https://shop.dresden-elektronik.de/referenz-designs/evaluierung-rcb/2-
4-ghz-evaluierung-rcb/radio-controller-board-rcb231sma-
mega256.html?___store=english&___from_store=deutsch. Last access January 2013.

[5]. Dresden Elektronik: Sensor Terminal Board. Information webpage available in
http://www.dresden-elektronik.de/funktechnik/products/boards-and-kits/development-
boards/sensor-terminal-board/. Last access January 2013.

[6]. Jorge Juan Robles, Sebastin Tromer, Mnica Quiroga, Ralf Lehnert: Enabling Low-power
Localization for Mobile Sensor Nodes, Published in International Conference on Indoor
Positioning and Indoor Navigation (IPIN), Zrich, Switzerland, 2010.

[7]. Datasheet available in http://www.dresden-
elektronik.de/funktechnik/uploads/media/RCB230-V3.2-DBT-en.pdf. Last access January 2013.

[8]. Batch Means Method. Information webpage available in
http://www.netlab.tkk.fi/opetus/s38148/s04/luennot/E_statanal_net.pdf. Last access January
2013.

Arbeit

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Arbeit

Uploaded by

Copyright:

Available Formats

TECHNISCHE UNIVERSITT DRESDEN

FAKULTT ELEKTROTECHNIK UND INFORMATIONSTECHNIK

You might also like