See discussions, stats, and author profiles for this publication at: https://www.researchgate.

net/publication/313720562

A Survey on Wireless Sensor Networks Simulation Tools and Testbeds

Chapter · January 2016

CITATIONS READS

8 3,455

4 authors:

Abdelrahman Abuarqoub Mohammad Hammoudeh

Middle East University Manchester Metropolitan University
32 PUBLICATIONS   661 CITATIONS    169 PUBLICATIONS   2,517 CITATIONS   

SEE PROFILE SEE PROFILE

Fayez Alfayez Omar Aldabbas

Majmaah University Al-Balqa' Applied University
28 PUBLICATIONS   297 CITATIONS    20 PUBLICATIONS   207 CITATIONS   

SEE PROFILE SEE PROFILE

Some of the authors of this publication are also working on these related projects:

The 4th International Conference on Future Networks and Distributed Systems (ICFNDS) View project

Digital Crime Research View project

All content following this page was uploaded by Abdelrahman Abuarqoub on 18 February 2017.

The user has requested enhancement of the downloaded file.

Chapter 14. A Survey on Wireless Sensor Networks Simulation Tools and Testbeds

Chapter 14
A Survey on Wireless Sensor Networks
Simulation Tools and Testbeds

Abdelrahman Abuarqoub, Mohammad Hammoudeh,

Fayez Al-Fayez, Omar Aldabbas 1

Abstract
This chapter presents a comprehensive survey of simulation tools, test-beds and hardware
platforms currently used in assessing a number of different parameters required by a target
Wireless Sensor Network (WSN) application. We describe the main features and
limitations of each assessment methodology. The survey shows that while WSN hardware
platforms become more powerful and cheaper, the number and support to simulation tools
is decreasing. The advanced capabilities of current sensor hardware platforms and their
low cost make large-scale test-beds a feasible option for the design and evaluation of WSN
systems. Accordingly, we advocate testbeds to become the main evaluation methodology
to move the field of WSNs forward. Finally, as an interim solution, we recommend mixed-
mode simulation methodology, which integrates a simulated environment with real WSN
hardware to improve both the accuracy and scalability of results when evaluating different
prototype designs and systems.

14.1. Introduction
A successful large-scale Wireless Sensor Network (WSN) deployment necessitates that
the design concepts are checked before they are optimised for a specific hardware
platform. Developing, testing, and evaluating network protocols and supporting
architectures and services for WSNs can be undertaken through test-beds or simulation.
In a survey on WSN evaluation tools published in 2012 [1], test-beds were found to be
extremely valuable. However, three years ago implementing large-scale test-beds was not
widely viable, because of the substantial cost of deploying and maintaining a large-scale
WSN. Moreover, the time needed for setting up the network for experimental goals made
simulation a favourable tool in developing reliable and portable WSNs applications.

Abdelrahman Abuarqoub
Faculty of Information Technology, Middle East University, Amman, Jordan
283
 Sensors, Transducers, Signal Conditioning and Wireless Sensors Networks

However, nowadays, tens of WSN hardware platforms exist at a very low cost. For
instance, an ESP8266 node costs less than 3 USD [2]. Many of these hardware platforms
are equipped with long-range, up to 1,000 Km in outdoor deployment, ultra-low power
radio devices. They also come with high performance processors and large memory
resources (see Table 14.2). This not only calls for relaxing the strict assumptions that were
made tens of years ago about the capabilities of WSN nodes, but also for considering the
methods used in evaluating exiting and new research in this field. The authors believe that
this is an important step towards translating the huge amount of research in this field to
real life deployments of WSN systems.

In WSNs, simulation provides a cost effective method of assessing the appropriateness of

systems before deployment. It can, for example, help assess the scalability of algorithms
free of the constraints of a hardware platform. Furthermore, simulators can be used to
simplify the software development process for a particular WSN application. For instance,
TOSSIM [3] utilises the component based architecture of TinyOS [4] and provides a
hardware resource abstraction layer that enables the simulation of TinyOS applications,
which can then be ported directly to a hardware platform without further modifications.

Simulation is hence the research tool of choice for the majority of the mobile ad hoc
network community. An examination of research papers published in SENSORCOMM
2011 [5] reveals a significant increase in using real testbeds compared to the study
published by Kurkowski et al. [6]. Yet, 53 % of the authors used simulation in their
research. Apart from the self-developed simulators, there are a few widely used network
simulators including NS-2 [7], OPNET [8], MATLAB [9], IFAS [10], and
OMNet++ [11]. Fig. 14.1 shows the simulator usage following a survey of simulation-
based papers in SENSORCOMM 2011 conference. Simulation of ad hoc wireless
capabilities for WSNs have been addressed by extending existing simulators, or
specifically building new ones, such as NS-3 [12]. The latter class of simulators mostly
focuses on protocols and algorithms for layers of the network stack, but they do not
directly support WSN.

Fig. 14.1. Simulator usage results from a survey of simulation based papers
in SENSORCOMM 2011.

Recently, several simulation tools have appeared to specifically address WSNs, varying
from extensions of existing tools to application specific simulators. Although these tools
have some collective objectives, they obviously differ in design goals, architecture, and

284
Chapter 14. A Survey on Wireless Sensor Networks Simulation Tools and Testbeds

applications abstraction level. In the next section, we review some of the important WSNs
simulation tools and explore their characteristics.

In this chapter we have addressed and discussed sixteen simulation tools, emphasizing the
main features and the major drawbacks. Authors believe that these simulation platforms
are the most widely used in education, research, and industrial purposes. However, some
of these simulators can be useful for one purpose, while other can be adapted to all needs.
For instance, CNET provide good tools for educational matters but it has limitation to
support industrial use, while, for example, NS3 can work in all circumstances, as it could
be simplify for education and go far in research or industrial complexity. The WSNs
simulators tools reviewed in this chapter are SensorSim, TOSSIM, TOSSF, GloMoSim,
Qualnet, OPNET, EmStar, SENS, J-Sim, Dingo, NS-2, NS-3, Shawn, GTSNetS, CNET
and TRMSim-WSN.

The rest of the chapter is organized as follows. In Section 14.2, the most popular WSNs
simulators are described and their strengths and weaknesses are discussed. In Section 14.3,
the largest indoor sensor network testbeds with public remote access are reviewed.
Section 14.4, presents our views about the future of WSNs testing and evaluation methods.
Section 14.5 concludes the chapter.

14.2. WSNs Network Simulation Tools

14.2.1. SensorSim

SensorSim [13] builds on the NS-2 simulator providing additional capabilities for
modelling WSNs. The main features of this platform are: power and communication
protocol models; sensing channel and sensor models; scenario generation; and support for
hybrid simulations. The public release of the SensorSim suite of tools was withdrawn due
to its unfinished nature and the inability of authors to provide the needed level of support.

Georgia Tech SensorSimII [14] is written in a modular style, where sensor nodes are
organized into three components: application, network, and link. The work in SensorSimII
may be divided into two areas: the simulator core and the visualization tools. The
simulator core essentially manages an array of independent sensor nodes throughout time.
The visualization tools provide views of both individual node state and communication
traffic between nodes.

Both SensorSim projects are open source and free to use. However, the simulators are
limited in their realism because (apart from SensorSim's power modules) neither simulator
considers the limited resources of sensor nodes such as memory, and real-time
computational capability. Moreover, it is not always required by the WSN to validate the
functional correctness and/or, to provide performance guarantees. SensorSim simulates
the complete WSN protocol stack, although this can be regarded as overkill and adding
unnecessary complexity as this is not required in order to simulate the expected behaviour.
This makes the SensorSim platform complex and difficult to use.

285
 Sensors, Transducers, Signal Conditioning and Wireless Sensors Networks

14.2.2. TOSSIM

There are platforms specifically designed to simulate WSNs, such as TOSSIM [3] which
is a part of the TinyOS development efforts [4]. TOSSIM is a discrete-event simulator for
TinyOS applications [3]. It aims to assist TinyOS application development and debugging
by compiling applications into the TOSSIM framework, which runs on a PC instead of
compiling them for a mote. Using the TOSSIM framework, programs can be directly
targeted to motes without modification. This gives users a bigger margin to debug, test,
and analyses algorithms in a controlled and repeatable environment. In TOSSIM, all nodes
share the exact same code image, simulated at bit granularity, and assuming static node
connectivity is known in advance. Therefore, TOSSIM is more of a TinyOS emulator than
a general WSN simulator. It focuses on simulating TinyOS rather than simulating the real
world. This has the advantage that the developed algorithms can be tested on a target
platform. However, this may place some restrictions of the target platform on the
simulation. TOSSIM is not always the right simulation solution; like any simulation, it
makes several assumptions about the target hardware platform, focusing on making some
behaviour accurate while simplifying others [3]. TOSSIM can be used as a tool for
absolute evaluation of some causes of the behaviour observed in real-world network
deployments.

14.2.3. TOSSF

TOSSF [15] is a simulation framework that compiles a TinyOS application into the
SWAN [16] simulation framework. It can be viewed as an improvement over TOSSIM
with a primary focus on scalability. It allows simulation of a heterogeneous collection of
sensor nodes and a dynamic network topology. TOSSF suffers from potentially long test-
debug cycles because it does not provide a scripting framework for experimentation.
Although it enables development of custom environmental models, the absence of a
scripting framework requires those models to be compiled into the simulation framework.
Given that both of these simulators are tightly coupled with TinyOS, they may be
unsuitable for early prototyping, or developing portable WSN applications.

14.2.4. GloMoSim

GloMoSim [17] is a scalable simulation environment for wireless and wired network
systems. Its parallel discrete-event design distinguishes it from most other sensor network
simulators. Though it is a general network simulator, GloMoSim currently supports
protocols designed purely for wireless networks. GloMoSim is built using a layered
approach similar to the seven layer network architecture of the OSI model. It uses standard
APIs between different simulation layers to allow rapid integration of models developed
at different layers, possibly by different users.

As in NS-2, GloMoSim uses an object-oriented approach, however for scalability

purposes; each object is responsible for running one layer in the protocol stack of every
node. This design strategy helps to divide the overhead management of a large-scale
network. GloMoSim has been found to be effective for simulating IP networks, but it is
286
Chapter 14. A Survey on Wireless Sensor Networks Simulation Tools and Testbeds

not capable of simulating sensor networks accurately [18]. Moreover, GloMoSim does
not support phenomena occurring outside of the simulation environment, all events must
be gathered from neighbouring nodes in the network. Finally, GloMoSim stopped
releasing updates in 2000 and released a commercial product called QualNet.

14.2.5. Qualnet

Qualnet is a commercial network simulator tool released by Scalable Network

Technologies [19] that is derived from GloMoSim. Qualnet significantly extends the set
of models and protocols supported by GloMoSim. It also provides a comprehensive set of
advanced wireless modules and user-friendly tools for building scenarios and analyzing
simulation results. Qualnet is a discrete-event simulator, as such, it is event driven and
time aware. It uses a layered architecture that is run by each node. When a protocol resides
in a particular layer at one node, the packets are passed down crossing the remaining layers
at the sending node, across the network, and then up to the protocol stack at the receiving
node. Qualnet has a modular design and an intuitive GUI that make it easy to use to learn
and modify.

14.2.6. OPNET

OPNET [20] is a further discrete event, object oriented, general purpose network
simulator. The engine of OPNET is a finite state machine model in combination with an
analytical model. It uses a hierarchical model to define each characteristic of the system.
The top hierarchy level contains the network model, where the topology is designed. The
second level defines the data flow models. The third level is the process editor, which
handles control flow models defined in the second level. Finally, a parameter editor is
included to support the three higher levels. The hierarchical models result in event queues
for a discrete event simulation engine and a set of entities that handle the events. Each
entity represents a node which consists of a finite state machine which processes the
events during simulation.

Unlike NS-2 and GloMoSim, OPNET supports modelling sensor-specific hardware, such
as physical-link transceivers and antennas. It also enables users to define custom packet
formats. An attractive feature of OPNET is its capability of recording a large set of user
defined results. Furthermore, the GUI (Graphical User Interface), along with the
considerable amount of documentation and study cases that come along with the license
are another attractive feature of the simulator. This GUI interface can also be used to
model, graph, and animate the resulting output. The network operator is provided with
editors that are required to simplify the different levels of modelling. Though model
parameters can be changed, the simulation accuracy is influenced because OPNET is not
open source software. Similar to NS-2, the object-oriented design of OPNET causes
scalability problems. It does not have a high number of protocols publicly available
possibly because of source code licensing constraints. Finally, OPNET is only available
in commercial form.

287
 Sensors, Transducers, Signal Conditioning and Wireless Sensors Networks

The second class of simulators are application-oriented simulators, including EmStar [21],
SENS [22], J-Sim [23], Shawn [24], and Dingo [25].

14.2.7. EmStar

EmStar [21] is a component based, discrete-event framework that offers a range of run-
time environments, from pure simulation, distributed deployment on iPAQs [26], to a
hybrid simulation mode similar to SensorSim. Emstar supports the use of simulation in
the early stages of design and development by providing a range of simulated sensor
network components, including radios, which provide the same interfaces as actual
components. It supports hybrid mode with some actual components and some simulated
components, and full native mode with no simulated components. As in TOSSIM, EmStar
uses the same source code that runs at each of these levels to run on actual sensors.
Amongst other simulators, such as TOSSIM, EmStar provides an option to interface with
actual hardware while running a simulation. EmStar is compatible with two different types
of node hardware. It can be used to develop software for Mica2 motes [27] and it also
offers support for developing software for iPAQ based microservers. The development
cycle is the same for both hardware platforms. The next step in the development cycle
following the simulation is data replay. In this model, EmStar uses data collected from
actual sensors in order to run its simulation. Leading directly from this, Emstar uses the
half-simulation methodology similar to SensorSim's, where the software is running on a
host machine and interfacing with a real physical communication channels. The final step
in the development cycle is deployment.

EmStar combines many of the features of other WSNs simulators. Its component based
design allows for fair scalability. Moreover, each aspect of the network can be logically
fine-tuned due to its development cycle design. Because it targets a particular platform,
many protocols are already available to be used. At the deployment step in the
development cycle, only the configuration files have to be designed. This potentially adds
constraints on the user as they must either ensure that the hardware configuration being
used matches the existing configuration file, or they must write their own files.

The main goal of Emstar is to reduce design complexity, enabling work to be shared and
reused, and to simplify and accelerate the design of new sensor network applications.
While not as efficient and fast as other frameworks like TOSSIM, Emstar provides a
simple environmental model and network medium in which to design, develop and deploy
heterogeneous sensor network applications. When used as a migration platform from code
to real sensor environment, the environment model may be sufficient for most developers.
Another drawback of Emstar is that the simulator supports only the code for the types of
nodes that it is designed to work with.

14.2.8. SENS

SENS [22] is a customizable component-based simulator for WSN applications. It

consists of interchangeable and extensible components for applications, network
communication, and the physical environment. In SENS, each node is partitioned into
288
Chapter 14. A Survey on Wireless Sensor Networks Simulation Tools and Testbeds

four main components: application, simulates the software application of the sensor node;
network, handles incoming and outgoing packets; physical, reads sensed information; and
environment, network propagation characteristics. Multiple different component
implementations offer varying degrees of realism. For example, users can choose between
various application-specific environments with different signal propagation
characteristics. As in TOSSIM, SENS source code can be ported directly into actual sensor
nodes, enabling application portability. Moreover, it provides a power module for
development of dependable applications.

SENS defines three network models that can be used. The first successfully forwards
packets to all neighbours, the second delivers with a chance of loss based on a fixed
probability, and the third considers the chance of collision at each node. The physical
component includes the non-network hardware for the sensor such as the power, sensors,
and actuators. At a lower level, the environment component models the physical
phenomena and the layout. The layout model includes different types of surfaces, each
affecting radio and sound propagation in a different way.

SENS is less customizable than many other simulators, providing no chance to alter the
MAC protocol, along with other low level network protocols. SENS uses one of the most
sophisticated environmental models and implements the use of sensors well. However,
the only measurable phenomenon is sound.

14.2.9. J-Sim

J-Sim [23] is a component-based discrete event simulator built in Java and modelled after
NS-2. The design of this simulator aims at solving many of the shortcomings of
comparable object-oriented simulators like NS-2. J-Sim uses the concept of components
instead of the concept of having an object for each individual node. J-Sim uses three top
level components: the target node which produces stimuli, the sensor node that reacts to
the stimuli, and the sink node which is the ultimate destination for stimuli reporting. Each
component is broken into parts and modelled differently within the simulator; this eases
the use of different protocols in different simulation runs.

J-Sim claim has several advantages over NS-2 and other simulators. First its component
based architecture scales better than the object oriented model used by NS-2 and other
simulators. Second, J-Sim has an improved energy model and the ability to simulate the
use of sensors for phenomena detection. Like SensorSim, there is support for using the
simulation code for real hardware sensors. However, J-Sim is comparatively complicated
to use. While no more complicated than NS-2, the latter simulator is more popular and
accepted in the sensor network research community and more community support is
available, therefore, more people are keen to spend the time to learn how to use it.

Though it is scalable, J-Sim has a set of inefficiencies. First, there is unnecessary overhead
in the intercommunication model. The second problem is inherited by most sensor
networks simulators that are built on top of general purpose simulators, 802.11 is the only
MAC protocol that can be used in J-Sim. Finally, Java is possibly less efficient than many
other languages.
289
 Sensors, Transducers, Signal Conditioning and Wireless Sensors Networks

14.2.10. Dingo

Dingo [28] provides a workbench for prototyping algorithms for WSNs taking a top-down
design methodology. Having no target platform means the full functionality of a
programming language can be used. This eases the design process as prototype algorithms
can be tested before optimization for the target platform. Dingo consists of a fixed API,
with customizable internals. It has a simple graphical user interface and a set of base
classes, which are extended by the user to create simulation. Each simulated sensor node
runs in its own thread and communicates using the same protocols that would be deployed
on a physical node. Sensors are modelled using a pool of concurrent, communicating
threads. Individual sensors are able to: (1) Gather and process data from a model
environment; (2) Locate and communicate with their nearest neighbours; (3) Determine
whether they are operating correctly and act accordingly to alter the network topology in
case of faulty nodes being detected. Nodes may be configured differently to simulate a
heterogeneous sensor network. Dingo comes with a set of application level routing
packages including simple multi-hop flooding, MuMHR [29] and LEACH [30].

Dingo features a significant improvement in the simulation performance by giving the

option to split the visualization from the simulation. It provides tools for the simulation
and deployment of high-level, Python code on real sensor networks. For example, Dingo-
boom provides a two-way interface between MoteIV's Boomerang class motes and Dingo.
Dingo-top is another tool which is used to dump network topology data to a text file and
generate a graphical representation of that topology. Furthermore, Dingo has several
features in the form of plugins. These can be activated/deactivated on the plugin menu.

As with SensorSimII, Dingo provides an extensible visualization framework that aims at

easing the life for sensor network debugging, assessment, and understanding of the
software by visualizing the sensor network topology, the individual node state, and the
transmission of the sensed data. Dingo comes with an interface between the simulation
environment and different hardware platforms, for example the Gumstix [31] platform.
Also, Dingo allows mixed-mode simulation using a combination of real and simulated
nodes. In Dingo, nodes have the ability to obtain their sensed data from a database or
graphical objects like maps; this improves the fidelity of simulations as it makes it possible
to check the simulation results against the real data.

Dingo focuses on the protocols and algorithms for higher layers of network state but it
does not directly support sensor networks at the physical layer. It has major drawbacks
which limit its functionality. Most of these drawbacks are due to the incomplete nature of
the tool. These drawbacks are: (1) The lack for Media Access Control or MAC layer,
communications to be handled by point-to-point systems. (2) No collision management
procedure, partly due to the absence of the MAC layer. (3) Dingo is still available to use,
however, it is no longer supported by the owners of the project.

290
Chapter 14. A Survey on Wireless Sensor Networks Simulation Tools and Testbeds

14.2.11. NS-2 and NS-3

NS-2 [32] is an object-oriented discrete event simulator targeted at networking research.

It is an open source network simulator originally designed for wired, IP networks. The
NS-2 simulation environment offered great flexibility in studying the characteristics of
WSNs because it includes flexible extensions for WSNs. NS-2 has a number of
limitations: (1) It puts some restrictions on the customization of packet formats, energy
models, MAC protocols, and the sensing hardware models, which limits its flexibility; (2)
the lack of an application model makes it ineffective in environments that require
interaction between applications and the network protocols; (3) It does not run real
hardware code; (4) It has been built by many developers and contains several inherent
known and unknown bugs. (5) It does not scale well for WSNs due to its object-oriented
design; (6) Using C++ code and oTcl scripts makes it difficult to use.

To overcome the above drawbacks the improved NS-3 simulator [12] was developed.
NS-3 supports simulation and emulation. It is totally written in C++, while users can use
python scripts to define simulations. Hence, transferring NS-2 implementation to NS-3
require manual intervention. Besides the scalability and performance improvements,
simulation nodes have the ability to support multiple radio interfaces and multiple
channels. Furthermore, NS-3 supports a real-time schedule that makes it possible to
interact with a real systems [12]. For example, a real network device can emit and receive
NS-3 generated packets.

14.2.12. Shawn

Shawn is an open source discrete event simulator for WSNs. It is written in C++ and can
be run in Linux/Unix and Windows environments. Shawn aims to simulate large- scale
WSNs, where physically accurate simulations fail. The idea behind Shawn is to use
abstract models to simulate the affects of a phenomenon rather than the phenomenon itself
[24]. Users of Shawn can adapt the simulation to their needs by selecting the application
preferred behaviour. The authors claim that Shawn provides a high abstraction level that
hides a lot of the simulation details. Users are given full access to the communication
graph, which allows them to observe nodes and their data [24]. However, there are some
limitation in Shawn, for instance: Visualization output is not supported, MAC module is
not extent, and also users need to do much programming [33].

14.2.13. GTSNetS

An open-source, written in C++, and it is event-driven simulator for large scale WSNs.
Users can evaluate different strategies and hierarchical options with its effect on lifetime
and performance on particular segments. It can also adapt a new approaches such as
algorithms and protocols. Khan et.al. (2011) claims the it is the only simulator can
simulate network with large number of nodes( up to 200.000) [34].

GTSNetS has been designed in a way to allow users to use any architecture or design to
simulate a particular required WSNs. Alternatives such as: tracing options, different
291
 Sensors, Transducers, Signal Conditioning and Wireless Sensors Networks

energy models, network protocols, and the ease of extended for a specific need; will
provide various implementation for the developers. Other advantages of GTSNetS that
the overall lifetime of the simulated network is trackable, the energy consumption of each
unit can be measured, supporting mobility such as mobile sensor nodes, mobile base
station, and the movement of sensed objects [35]. The serious drawback in this simulation
tools is that not been updating since 2008.

14.2.14. CNET

CNET [36] is an open source network simulator developed at the University of Western
Australia for research and learning purposes. This simulation platform allows various
experimentation at the data-link, the transport and the network layers. It implements both
the IEEE 802.112 and IEEE 802.3 protocols, which makes it capable of simulating mobile
and wireless networks. At the application layer, CNET provides advanced users with the
capability to develop their own applications; however, users must write protocols to fill
in any necessary internal layer to cope with any lost frame that might be introduced by
CNET Physical layer.

CNET comes with a set of tutorials and comprehensive documentation that describes the
process from installation stage up to final stage of simulation. Users can have full
simulation vision and graphical presentation of the network under Tcl/Tk CNET 's comes
with a graphical interface that allow users to relocate nodes by mouse and change nodes
attributes using a simple checkbox interface. The major drawback of CNET is that it can
only run a maximum of few hundreds nodes, which limit its usefulness in studding large-
scale networks. It also does not support Windows operating systems.

14.2.15. TRMSim

Trust and Reputation Models Simulator for WSNs (TRMSim-WSN) is a special purpose
Java-based simulator to study trust and reputation models for a wide range of WSNs.
TRMSim-WSN is a highly optimizable simulator. It allows users to set several simulation
parameters, including, the percentage of malicious nodes, the probability of collusions,
etc. It offers some of the most common trust and reputation models found in the literature.
New models can be easily added using the provided API, which implements a template to
carry out this task. TRMSim checks the correctness and accuracy of trust and reputation
only; it does not allow users to study the performance aspects of their network. For
instance, users of TRMSim-WSN are unable to measure the energy consumption imposed
by trust/reputation models on the network. Another limitation is the inability to choose a
specific node and change its properties, e.g., services offered and goodness. Finally, only
static nodes can be simulated.

14.3. Testbd as a Service

Experimental evaluation have become an essential part of WSN innovations. The WSNs
research community needs networking research “Laboratories” in which to develop and
292
Chapter 14. A Survey on Wireless Sensor Networks Simulation Tools and Testbeds

test novel concepts. Currently, the number of algorithms evaluated through testbeds is
relatively low. This is due to the high deployment cost and application dependence of
WSNs.

Recently, a new class of WSNs testbed facilities, called Testbed as a Service (TaaS) has
emerged to overcome the difficulties in testbed-based evaluation. TaaSprovides online
laboratories to facilitate research in sensor network programming environments,
communication protocols, system design, and applications. It makes the testbed accessible
through a web based user interface (WUI), opening it to users across the globe. Therefore,
TaaS provides reliable and cost effective work environment for the researcher enabling
broad range of innovations. TaaS offers the ability to rapidly prototype new ideas as well
as the ability to duplicate real world scenarios such that research results are realistic
and valid.

Compared to the conventional testbeds, TaaS has many advantages including: First, it
reduces the costs of both deployment and maintenance of a large-scale testbed. Second, a
variety of platforms are available with different capabilities, and hence, the deployment
of heterogeneous sensor nodes becomes feasible. Third, it prevents unexpected or errant
behaviour from interfering with production services or other testing. Fourth, since TaaS
provides easy-to-use testbeds infrastructure, the level of expertise needed to set up
experiments is less compared to that in conventional testbeds. Fifth, developers can focus
development and evaluation efforts on the area of contribution without worrying about
other network tasks. For instance, a variety of MAC and routing protocols may be
available to use saving the developer time and effort to build the entire network stack.
Finally, running large-scale WSN experiments is hard. Programming a single sensor node
can take up to five minutes depending on the size of the binary it is being programmed
with. Without a testbed to streamline the process of programming a large number of sensor
nodes, programming each sensor node individually can quickly become a significant
bottleneck. Furthermore, as programming typically takes place by physically attaching a
sensor node to the local machine, deploying them afterwards also takes a significant
amount of time.

The rest of this section presents some of the largest indoor sensor network testbeds with
public remote access.

INDRIYA[37] is a large-scale, low-cost WSN deployed across three floors of the School
of Computing, at the Singapore. The Testbed comprises of 139 TelosB sensor
"motes"[38] and a cluster of Arduinodevices [39] to support the requirements of the future
Internet of Things (IoT). TelosB nodes in INDRIYA run the TinyOS [40] operating
system and are programmed in the NesC programming language, a component-oriented
variant of C. Typically, users will be able to prototype their application either using
the TOSSIM simulation environment [3] or with a handful of motes on their desktop.
Users then use the INDRIYA's web interface to upload their program to the building-wide
network. In INDRIYA, the wireless connectivity among nodes is three-dimensional,
which allows experimentation of protocols that are sensitive to placement and
connectivity, such as geographical routing protocols. INDRIYA’s heterogeneous nodes
allow the evaluation of various WSN applications. However, INDRIYA has a number of
293
 Sensors, Transducers, Signal Conditioning and Wireless Sensors Networks

limitations: First, the number of nodes is still not sufficient for a very large-scale WSN
(i.e., thousands of nodes). Second, it does not consider nodes mobility, which limits the
deployment of mobile WSN systems. Finally, in terms of heterogeneity of hardware setup,
INDRIYA has only two platforms.

Washington University in St. Louis is currently in the process of deploying a WSN testbed
called The WUSTL WSNs Testbed [41]. It currently consists of 79 wireless sensor nodes
placed throughout several office areas. The testbed deployment is based on the TWIST
architecture [42]. It is hierarchical in nature, consisting of three different levels of
deployment: sensor nodes, microservers, and a desktop class host/server machine. The
entire TWIST architecture is based on cheap, off-the-shelf hardware and uses open-source
software at every tier of its deployment. The testbed software has a client/server
architecture, plus a set of user applications that interact with the wireless testbed. The
client runs on the microservers and manages finding, programming, and communicating
with the attached motes. The server coordinates the clients and the user applications. The
user applications help the user to program, list, and communicate with the motes in the
system. The client, server, and user application software is written mostly in Python, with
some performance-critical sections written in C. In addition, the server application
interacts with a PostgreSQL database, which lists the active microservers and motes. The
PostgreSQL backend is also available for user applications to store experimental data. The
testbed features a localization service where motes in the testbed act as anchor nodes to
help localize a beacon node roaming throughout the network. However, the number of
sensor nodes in the WUSTL testbed is still relatively low and the homogenous hardware
platform does not allow developers to capture some aspect of such complex systems.

The WISEBED project is a consortium of nine academic and research institutes across
Europe. The project aims to build a multi-level infrastructure of interconnected testbeds
for research purposes. Such a testbed allows applying an interdisciplinary approach to
WSNs development by integrating the aspects of hardware, software, algorithms, and
data. It consists of over 1500 wireless sensor nodes spread across the nine sites. A variety
of sensor nodes is available allowing heterogeneous network setup. The testbed has more
than eight platforms including iSense, Pacemate, and TelosB. The nodes can be allocated
various types of mobility and environments. The WISEBED supports nodes mobility by
deploying senor nodes on a robot such as, Roomba [43], and NXT [44]. The Wiselib C++
template-based algorithm library allows WISEBED users to build cross-platform, highly
efficient WSN applications. They can also use the GNU C based on Lorien OS to build
highly dynamic component oriented applications. WISEBED is compatible with Shawn
simulator; therefore, WISEBED can derive models of real-life scenarios for simulations.

IoT-LAB [45] is an open testbed that evolved from SENSLAB testbed. It offers a very
large-scale infrastructure suitable for testing small wireless sensor devices and
heterogeneous communicating objects. IoT-LAB is made of over 2700 wireless sensor
nodes that are distributed across six sites in France. A range of wireless sensor hardware
platforms are available, with different processor architectures (MSP430, STM32 and
Cortex-A8) and different wireless chips (802.15.4 PHY at 800 MHz or 2.4 GHz).
IoT-LAB features an “open node” that can receive custom wireless sensors for inclusion

294
Chapter 14. A Survey on Wireless Sensor Networks Simulation Tools and Testbeds

in IoT-LAB testbed. Nodes are either stationary or mobile and can be organized in
different topologies. IoT-LAB include mobile nodes with either controlled or uncontrolled
mobility. Similar to WISEBED , IoT-LAB controlled mobile nodes are carried on robot,
such asTurtlebot2 [46] or Wifibot [47], which have advanced navigation features. IoT-
LAB allows full control of network nodes and direct access to the gateways to which
nodes are connected. This allows researchers to monitor nodes energy consumption and
network-related metrics, e.g., end-to-end delay, throughput and overhead. This testbed
offers quick experiments deployment, along with easy evaluation, results collection and
analysis. It also allows, implementing testbeds with different node types, topologies and
environments to coverage of a broad range of real-life WSNs applications. IoT-LAB
offers web-based reservation and tooling for applications development, along with direct
command-line access to the platform.

Table 14.1 summarizes the main features of the above reviewed testbed services.
Table 14.2 gives a summary of the hardware and software resources that are commonly
used in WSNs testbed facilities.

Table 14.1. Summary of the reviewed testbed services.

Open Number Mobility

TaaS Heterogeneity (Number of Platforms)
Access of Nodes Support
INDRIYA ✓ 139 2 Platforms: TelosB and Arduino
WUSTL ✓ 79 1 Platform: TelosB
> 8 Platforms: including iSense,
WISEBED ✓ >1500 ✓
Pacemate and TelosB
> 3 Platforms: including Contiki
IoT-LAB ✓ >2700 ✓
WSN430 node, M3 node and A8 node

14.4. Discussion
The high cost of sensor node hardware has significantly delayed the deployment of WSNs.
However, during the past few years, the cost of sensor nodes has decreased rapidly due to
increased production volume and technological advancements. In some cases, e.g. RFID
hardware, sensor costs have declined by as much as 100 times over the past decade. As
the cost of a WSN system plunges, one can expect to see larger systems built and
deployed. The focus then will shift to the availability of scalable networking and software
platforms to support WSN systems deployment.

Generally, real WSNs testbeds provide a more accurate, realistic, and replicable validation
mechanism for algorithms and protocols. However, the wide variety of available sensor
hardware can make it rather difficult to replicate any results produced by real testbeds.
Besides, in some applications, where dangerous conditions are being studied, e.g.
chemical pollution, a real testbed is an unwanted choice. Finally, there is a handful TaaS
environments that can satisfy some complex application needs. Out of these restrictions
came the need for simulation as a tool for validating and testing algorithms/protocols. As

295
 Sensors, Transducers, Signal Conditioning and Wireless Sensors Networks

shown in Section 14.2, simulation tools are widely available and used by WSNs
researchers. However, most of the existing simulators are incomplete and follow different
approaches to investigate different problems. The variety of existing simulation tools has
led to accuracy and authenticity issues that concern even the best simulators available
today. Such issues also make it even more difficult to replicate and compare evaluation
results from competing simulation systems. Simulation drawbacks also include the lack
of visualization tools, GUI's, poor documentation, absence of examples, amongst others.

There are some factors that affect the accuracy of results among different simulators, even
when applying the same scenario in different platforms, according to [34, 48-50]. These
factors including: protocol stack, application’s nature, parameter sitting, simulation
assumption, and traffic generator parameters.

To solve the dilemma of having an accurate but scalable and low-cost prototyping
solution, we suggest the use of mixed-mode simulation as an effective interim solution.
Mixed-mode simulation is the integration of a simulated environment and a real testbed
to improve both the accuracy and scalability of testing results. In other words, the mixed-
mode simulation enables the simulation of algorithms partially in software and partially
in a real hardware WSN testbed. A small number of simulation tools like NS-3 and Dingo
already support this mode of simulation. This simulation mode allows researchers to
compare the results of running the same algorithm in both simulation and on physical
sensor hardware, the comparison allows the inclusion or the modelling of more realistic
conditions in the simulation environment. A flexible mixed-mode simulator should
support integration of heterogeneous sensor devices. Also, the simulation-testbed
interaction remains a challenging task that needs to be addressed. For instance, the authors
of Dingo describe in [51] a new Python library that implements synchronous message-
passing concurrency to improve coordination between many hosts.

Yet, the choice of a suitable simulator is a difficult decision. There is no 'best' simulator,
each simulator has specific features that work well in certain circumstances. The selection
of a simulator depends mostly on the algorithmic feature to be evaluated. High level
simulators like NS-2 gives an estimation about the applications and some middleware
behaviour. Mid-level simulators, e. g. OMNET, provides more information about the
physical layer components that are simulated without giving too much details. Low-level
simulators provide accurate bit level estimations of the hardware as well as software
performance. Regardless of the simulator, any simulations will always have weaknesses
either due to non-realistic assumptions or modelling errors that may be present in the
algorithm itself. Therefore, developing formal methods, e. g. using graph theory [52], to
verify the correctness of new algorithms and protocols is also part of the testing or
evaluation research. Table 14.3 summarizes the main features of the reviewed simulation
tools.

296
 Table 14.2. Summary of WSNs hardware platforms.

Memory
Operating Wireless
Node CPU Flash, Interfaces Sensors
System Interface
(RAM)
32-bit (16 MHz) 128 KB, IEEE 802.15.4 Temperature, Light, PIR,
iSense iSense USB, RS- 232
ARM (96 KB) (2.4 GHz) AMR, Accelerometer
32-bit IEEE 802.15.4 USB, JTAG I2C, 2
32 MB, Accelerometer, Temperature,
iMote2 TinyOS (13-416 MHz) CC2420 x (SPI) 3xUART,
(32 MB) Humidity, Light
Intel PXA271 (2.4 GHz) GPIOs, AC97 etc.
Scatter Node 16-bit(4 MHz) 55 KB, CC1020 Temperature, Humidity,
ScatterWeb JTAG, GPIO
MSB430 MSP 430F1612 (5 KB) (868 MHz) Accelerometer
Temp., Light, Microphone,
8-bit(16 MHz) 128 KB, CC2420
MicaZ Contiki JTAG, USB Accelerometer,
Atmega128L (4 KB) (2.4 GHz)
Magnetometer
CC2420
16-bit (8 MHz) 48 KB, Temperature, Humidity,
Tmote Sky TinyOS IEEE 802.15.4 USB
MSP430F1611 (10 KB) Light
(2.4 GHz)
16-bit (8 MHz) 60 KB, (2 TR1001 Temp., Light, Noise,
ESB ScatterWeb RS232, JTAG
MSP430F149 KB) 868.35 MHz Vibration, Infrared
None 32-bit(180 MHz) 4 MB, IEEE 802.15.4 Accelerometer,
Sun SPOT USB, GPIOs
(JVM) ARM920T (512 KB) (2.4 GHz) Temperature, Light
Scatter Chipcon
32-bit (72 MHz) 512 KB, miniUSB 2.0,
Net Contiki CC1100 Temperature, Humidity
ARM7 (98 KB) GPIOs
MSBA2 (864-970MHz)
32-bit (400 MHz) 16 MB, IEEE 02.11b/g
GumStIx Linux USB, Bluetooth Water Depth
Intel PXA255 (64 MB) (2.4 GHz)
32-bit (60 MHz) 256 KB, Xemnics RF Serial, I2C, Radio
Pacemates iSense Heart rate monitor
LPC2136 (64 KB) (868 MHz) Interface
CC2420
TinyOS/ 16-bit (8 MHz) 48 KB, Temperature, Humidity,
TelosBs IEEE 802.15.4 USB
Octopus MSP430F1611 (10 KB) Light
(2.4 GHz)
 Table 14.3. Summary about reviewed simulation tools.

General or
Programing Open
Simulator GUI Specific Main Features Limitations
Language Source
Simulator
Power and communication protocol Limited in SensorSim project realism.
Specifically
models Sensing channel and sensor Consider limited resources of sensor
SensorSim C++ No designed for Yes
models. Scenario generation. Support for nodes. Simulates the complete WSN
WSNs
hybrid simulations protocol stack
Can be targeted to motes without Makes several assumptions about the
Specifically
modification. Nodes share the exact same target hardware platform. Focusing
TOSSIM C++ Yes designed for Yes
code image. The developed algorithms on making some behaviour accurate
WSNs
can be tested on a target platform. while simplifying others
Specifically Primary focus on scalability. Support
TOSSF C++ Yes designed for Yes heterogeneous nodes and dynamic Long test-debug cycles
WSNs topology
Supports protocols designed purely for Not scalable of simulating sensor
wireless networks .Built using a layered networks accurately. Does not
GloMoSim C/Parsec Yes General Yes
approach. Uses standard APIs between support phenomena occurring outside
different simulation layers. of the simulation environment
Comm- Comprehensive set of advanced wireless
Qualnet C/C++ Yes General The annual license is expensive
ercial modules and user-friendly tools
General or
Programing Open
Simulator GUI Specific Main Features Limitations
Language Source
Simulator
Uses a hierarchical model to define each
Comm- characteristic of the system. Capability of
OPNET C/C++ Yes General Scalability problems
ercial recording a large set of user defined
results.
Supports hybrid mode. Provides an option
Specifically Supports only the code for the types
to interface with actual hardware while
EmStar C Yes designed for Yes of nodes that it is designed to work
running a simulation. Compatible with
WSNs with
two different types of node hardware
Specifically
Multiple different component Less customizable. Only measurable
SENS C++ No designed for Yes
implementations phenomenon is sound
WSNs
 Table 14.3. (Continued).

General or
Programing Open
Simulator GUI Specific Main Features Limitations
Language Source
Simulator
Ability to simulate the use of sensors for
Specifically Comparatively complicated to use.
phenomena detection. Support for using
J-Sim Java Yes designed for Yes Unnecessary overhead in the
the simulation code for real hardware
WSNs intercommunication model
sensors
Does not directly support sensor
Specifically Full functionality of a programming
networks at the physical layer.
Dingo Python Yes designed for Yes language can be used. Option to split the
Incomplete nature of the tool. Not
WSNs visualization from the simulation
supported anymore.
Supports simulation and emulation. Some restrictions on the
Supports a real-time schedule. Ability to customization. Lack of an application
NS-3 C++ No General Yes
support multiple radio interfaces and model. Does not run real hardware
multiple channels. code. Does not scale well for WSNs.
General or
Programing Open
Simulator GUI Specific Main Features Limitations
Language Source
Simulator
Able to simulate large- scale WSNs.
Specifically Does not support visualization output.
Ability of selecting the application
Shawn C++ No designed for Yes MAC module is not extent. Lots of
preferred behaviour. Full access to the
WSNs programing is required
communication graph.
can also adapt a new approaches such as
algorithms and protocols. The only
GTSNetS C++ Yes General Yes No update since 2008
simulator can simulate network with large
number of nodes.
For research and learning purposes.
Allows various experimentation at the It can only run a maximum of few
CNET C Yes General Yes data-link, the transport and the network hundreds nodes. Does not run under
layers. Full simulation vision and Windows
graphical presentation.
Specific for
Check the correctness and accuracy of It cannot simulate mobile networks.
TRMSim- WSNs
Java Yes Yes trust and reputation models. Provide an No support for performance
WSN trust/reputatio
API to add new models. evaluation.
n testing
 Sensors, Transducers, Signal Conditioning and Wireless Sensors Networks

14.5. Conclusion
This chapter provides a comprehensive review of simulation tools that are widely used in
the field of WSNs. The aim is to help researchers choosing the most appropriate
simulation tools to evaluate their work. There are a variety of simulation tools with
different capabilities. However, the authors believe that they are insufficient for testing
and evaluating WSNs algorithms. This is because the simulation results can be unrealistic
due to the incomplete or inaccurate simulation models. An immediate measure is to
develop unified models, e. g. energy, for different simulators. This allows realistic
comparisons between results produced by different simulators to be made. To improve
authenticity and accuracy of simulation results, it is important that researchers make their
simulation code available for download by other researchers. Moreover, researchers
should dedicate more space in their papers to clearly describe their simulation setup. On
the other hand, large-scale real testbeds are still infeasible due to their cost and
complexity. It can be easily observed that the trend in the WSNs field is to use mixed-
mode simulation as an interim solution. Finally, we believe that theoretical validation of
algorithms can serve as a good means for evaluating many WSNs algorithms.

References
[1]. F. Al-Fayez, et al., Wireless Sensor Network Simulation: The Current State and Simulation
Tools, Sensors & Transducers, Vol. 17, Special Issue, December 2012, pp. 145-155.
[2]. E. Systems, (2015, 2 Nov, 2015), ESP8266EX Datasheet, Available:
https://www.adafruit.com/images/product-files/2471/0A-
ESP8266__Datasheet__EN_v4.3.pdf
[3]. P. Levis, et al., TOSSIM: accurate and scalable simulation of entire TinyOS applications, in
Proceedings of the 1st International Conference on Embedded Networked Sensor Systems
(SenSys'03), 2003, pp. 126-137.
[4]. P. Levis, et al., TinyOS: An Operating System for Sensor Networks, in Ambient Intelligence,
Springer, 2005.
[5]. IARIA. (2006-2011, Retrieved 19 April 2015). The 5th International Conference on Sensor
Technologies and Applications, SENSORCOMM 2011. Available: http://www.iaria.
org/conferences2011/SENSORCOMM11.html.
[6]. S. Kurkowski, et al., MANET Simulation Studies: The Current State and New Simulation
Tools, The Colorado School of Mines, February 2005.
[7]. E. Larsen, et al., iOLSR: OLSR for WSNs Using Dynamically Adaptive Intervals, in
Proceedings of the 5th International Conference on Sensor Technologies and Applications
(SENSORCOMM'11), Nice/St. Laurent du Var, France, 2011, p. 18 - 23.
[8]. K. Shi, et al., TinyMQ: A Content-based Publish/Subscribe Middleware for Wireless Sensor
Networks, in Proceedings of the 5th International Conference on Sensor Technologies and
Applications (SENSORCOMM'11), Nice/Saint Laurent du Var, France, 2011, p. 12 - 17.
[9]. R. Behnke, et al., HDLS: Improved Localization via Algorithm Fusion, in Proceedings of the
5th International Conference on Sensor Technologies and Applications (SENSORCOMM'11),
Nice/Saint Laurent du Var, France, 2011, p. 36 - 44.
[10]. S. Feldman and M. Feldman, Tree-Based Organization for Very Large Scale Sensor
Networks, in Proceedings of the 5th International Conference on Sensor Technologies and
Applications (SENSORCOMM'11), Nice/Saint Laurent du Var, France, 2011, p. 45-50.

300
Chapter 14. A Survey on Wireless Sensor Networks Simulation Tools and Testbeds

[11]. F. Derogarian, et al., A Routing Protocol for WSN Based on the Implementation of Source
Routing for Minimum Cost Forwarding Method, in Proceedings of the 5th International
Conference on Sensor Technologies and Applications (SENSORCOMM'11), Nice/Saint
Laurent du Var, France, 2011, p. 85 to 90.
[12]. nsnam, NS-3, Available: from http://www.nsnam.org/(2011, Retrieved 18 April 2015).
[13]. S. Park, et al., SensorSim: a simulation framework for sensor networks, in Proceedings of the
3rd ACM International Workshop on Modeling, Analysis and Simulation of Wireless and
Mobile Systems (MSWIM'00), 2000, pp. 104-111.
[14]. C. Ulmer, 2004, Wireless Sensor Probe Networks-SensorSimII.
[15]. L. F. Perrone and D. M. Nicol, A Scalable Simulator For TinyOS Applications, in
Proceedings of the Winter Simulation Conference, Vol. 1, 2002, pp. 679 - 687.
[16]. A. Gahng-Seop, et al., Supporting Service Differentiation for Real-Time and Best-Effort
Traffic in Stateless Wireless Ad Hoc Networks (SWAN), IEEE Transactions on Mobile
Computing, Vol. 1, 2002, pp. 192-207.
[17]. X. Zeng, et al., GloMoSim: a library for parallel simulation of large-scale wireless networks,
in Proceedings of the 12th Workshop on Parallel and Distributed Simulation (PADS '98),
1998, pp. 154-161.
[18]. D. Curren, 2005, A survey of simulation in sensor networks, https://www.researchgate.net/
publication/228642170_A_survey_of_simulation_in_sensor_networks.
[19]. QualNet Simulator, S. N. Technologies, Available: from http://www.scalable-
networks.com/products/qualnet/, Retrieved 02/01/2015.
[20]. X. Chang, Network simulations with OPNET, in Proceedings of the 31st Conference on
Winter Simulation (WSC '99), 1999, pp. 307-314.
[21]. L. Girod, et al., Emstar: A software environment for developing and deploying heterogeneous
sensor-actuator networks, ACM Trans. Sen. Netw., Vol. 3, p. 13, 2007.
[22]. S. Sundresh, et al., SENS: A Sensor, Environment and Network Simulator, in Proceedings of
the 37th Annual Simulation Symposium (ANSS'37), April 2004.
[23]. A. Sobeih, et al., J-Sim: A Simulation Environment for Wireless Sensor Networks, in
Proceedings of the 38th Annual Symposium on Simulation (ANSS '05), pp. 175-187, 2005.
[24]. S. P. Fekete, et al., Shawn: The fast, highly customizable sensor network simulator, in
Proceedings of the 4th International Conference on Networked Sensing Systems (INSS '07),
2007, pp. 299-299.
[25]. S. Mount, et al., SenSor: an Algorithmic Simulator for Wireless Sensor Networks, in
Proceedings of the Eurosensors XX, Vol. II, 2006, pp. 400-411.
[26]. hp, iPAQs, 2000.
[27]. xbow, Mica Mote, 2012, Retrieved 19-April-2012s.
[28]. S. Mount, Dingo Wireless Sensor Networks Simulator, 2008.
[29]. M. Hammoudeh, et al., MuMHR: Multi-path, Multi-hop Hierarchical Routing, in
Proceedings of the International Conference on Sensor Technologies and Applications
(SENSORCOMM'07), 2007, pp. 140-145.
[30]. W. Heinzelman, et al., Energy-Efficient Communication Protocol for Wireless Microsensor
Networks, in Proceedings of the 33rd International Conference on System Sciences, Vol. 2,
January 2000, p. 10.
[31]. Gumstix.com, Gumstix way small computing, 2007.
[32]. NS-2, The Network Simulator, 2007.
[33]. E. Kolega, et al., Assessment of network simulators for real world WSNs in forest
environments, in Proceedings of the IEEE International Conference on Networking, Sensing
and Control (ICNSC), 2011, pp. 427-432.
[34]. M. Z. Khan, et al., Limitations of Simulation Tools for Large-Scale Wireless Sensor
Networks, in Proceedings of the IEEE Workshops of International Conference on Advanced
Information Networking and Applications (WAINA'11), 2011, pp. 820-825.
301
 Sensors, Transducers, Signal Conditioning and Wireless Sensors Networks

[35]. C. J. Fung and Y. E. Liu, Lifetime Estimation of Large IEEE 802.15.4 Compliant Wireless
Sensor Networks, in Proceedings of the IEEE International Symposium on Modeling,
Analysis and Simulation of Computers and Telecommunication Systems, (MASCOTS'08),
2008, pp. 1-4.
[36]. CNET, An introduction to the cnet network simulator, ed. The University of Western
Australia, 2015.
[37]. M. Doddavenkatappa, et al., Indriya: A Low-Cost 3D Wireless Sensor Network Testbed,
TRIDENTCOM, 2011.
[38]. I.n.c. Crossbow Technology, 2005, 12 Nov 2015, TelosB Mote Platform, Available:
http://www.willow.co.uk/TelosB_Datasheet.pdf.
[39]. Arduino, 2015, 13 Nov 2015, Arduino, Available: https://www.arduino.cc/
[40]. TinyOS, 2015, 12 Nov 2015, TinyOS, Available: http://www.tinyos.net/
[41]. W. U. i. S. Louis, 2015, 13 Nov 2015, The WUSTL Wireless Sensor Network Testbed.
Available:
http://wsn.cse.wustl.edu/index.php/The_WUSTL_Wireless_Sensor_Network_Testbed.
[42]. T. Group, 2015, 13 Nov 2015, TKN WIreless NetworkS Testbed. Available:
https://www.twist.tu-berlin.de/index.html
[43]. iRobot, 2015, 12 Nov 2015, Roomba Robot, Available: http://www.irobot.co.uk/
Store/Robots/roomba
[44]. LEGOengineering, 2014, 12 Nov 2015, NXT sensors, Available:
http://www.legoengineering.com/nxt-sensors/
[45]. T. F. consortium, 2014, 12 Nov 2015, FIT IoT-LAB, Available: https://www.iot-lab.info/
[46]. I. Open Source Robotics Foundation, 2015, 12 Nov 2015, TurtleBot 2. Available:
http://www.turtlebot.com/
[47]. N. Robotics, 2015, 15 Nov 2015, http://www.wifibot.com/. Available:
http://www.wifibot.com/.
[48]. T. R. Andel and A. Yasinsac, On the credibility of manet simulations, Computer, Vol. 39,
2006, pp. 48-54.
[49]. S. Mehta, et al., A Case Study of Networks Simulation Tools for Wireless Networks, in
Proceedings of the 3rd Asia International Conference on Modelling & Simulation (AMS '09),
2009, pp. 661-666.
[50]. M. Korkalainen, et al., Survey of Wireless Sensor Networks Simulation Tools for Demanding
Applications, in Proceedings of the 5th International Conference on Networking and Services
(ICNS '09), 2009, pp. 102-106.
[51]. M. Hammoudeh, Modelling Clustering of Sensor Networks with Synchronised Hyperedge
Replacement, in Proceedings of the 4th international Conference on Graph Transformations
(ICGT '08), 2008, pp. 490-492.
[52]. S. Mount, et al., CSP as a Domain-Specific Language Embedded in Python and Jython, in
Communicating Process Architectures, Eindoven, Netherlands, 2009.

302

View publication stats