IRIS1 is an integrated and flexible solution for experiment management and data analysis for Wireless Sensor Networks. For an end user, IRIS provides routines for automated installation of TinyOS applications, options for collecting data from various sources and options for processing, visualization and logging such data. For a developer, it provides a rich set of libraries to assemble a user interface customized for arbitrary applications.

IRIS is written in Java which makes it platform independent. However, it depends on some external libraries like TinyOS which some might find to be installed under Linux. This tool and all of its components are developed by the NES group of the University of Duisburg-Essen. It was developed as part of the EU project PLANET.

The following paragraphs describe:


IRIS can be downloaded as a Maven project at GitHub.

Installation Steps

Thats it. Now you should be able to see the user interface of IRIS!

Usage Guidelines

Automated Application Installation

IRIS Application Installation
To automate application installation, the user needs to provide two configuration files which specify a list of application node IDs with the TinyOS applications to be installed, and a list of the IDs with their hardware addresses, respectively. IRIS also provides utilities to generate these lists easily. Once both lists are available, the user can attach any number of nodes to the USB ports and start an automated application installation. IRIS installs intended applications on all attached nodes automatically.


IRIS Function LMS
IRIS provides an innovative way for extending its processing capabilities by flexibly defining application-specific functions for processing data at the packet level. These functions can be applied to collected data during runtime or a posteriori. Such feature is especially useful for runtime data analysis, application debugging and customized logging.
The user can initiate a function instance by wiring the target attributes to the input ports and deciding on the constant values during/after the experiment. Currently, IRIS provides a rich set of function templates for data processing. However, the user can easily extend it with user-defined templates written in Java (see Extending IRIS).
Functions are composable, meaning that the a function instance can take the output of another instance as input. With composable function templates, the user can implement a variety of data processing algorithms that directly access the data without redundant storing and retrieving for further processing, and thus can obtain the experiment result with less storage resources and significantly reduced time.
IRIS provides a large number of mathematical and WSN specific function templates that can be customized for WSN monitoring and controlling. The predefined set of templates include simple arithmetic functions like addition and subtraction, as well as more complex function templates like a customizable least mean square algorithm for value prediction.

WSN interaction

To collect data from traditional WSNs, IRIS can be connected to one or several base stations via serial ports. Every base station collects messages converts the message fields into IRIS attributes and stores it in the IRIS data model.

IRIS Function LMS
System Interaction IRIS allows the user to control the experiment flow and to interact with the deployed WSN by dispatching the arbitrary user-defined AM messages. Such feature is advantageous for adjusting experiment parameters and for program debugging. To send a message to the WSN, the user needs to connect IRIS with one or more base stations, and to specify three parameters: the message template (type), the attribute values and the base station responsible for sending the message.

To extend the set of TinyOS messages, the user has to create a mig template that represents the message structure. This can be done by the following command

mig java -target=null -java-classname=$structName $fileName $structName -o $javaName.

The resulting file must be placed under the IRIS directories mote/receiving or more/sending respectively.

Incoming and outgoing messages are logged automatically. The user can define application-specific format for every incoming or outgoing message. Together with the IRIS Functions it is possible to define functions to directly manipulate collected raw data and to store the end result to a log file freely. This bypasses the step of raw data storing and therefore greatly increases the efficiency.


IRIS Function LMS
The visualization and user control interfaces are basic and yet important features for a tool like IRIS. The provided base user interface of IRIS consists of several parts for the user input and for visualizing the experiment data. Through the IRIS’ GUI, the user can perform experiment management, including creating an experiment profile, initiating data collection, sending control messages, store/load the experiment data, defining the function instances for data processing, etc. For each measurement, IRIS first displays general information about the measurement. When the data is available, the Packet View displays the content of the messages based on their attributes and can be customized to only show required attributes. Additionally, IRIS is integrated with JFreeChart, a library for generating line charts or bar charts in a graph view. It allows the user to zoom into the chart, to save pictures of generated charts and to change the scale of the view for a better visualization of any attribute. Moreover, IRIS provides a map view based on the Worldwind Java SDK for the visualization of spatial data. Like the graph view, the map view allows zooming and saving pictures of the displayed area. Finally, different data views can be arbitrary combined together to produce an interface for the final user, which is customized with respect to the specific application requirements.

Customizing the IRIS User Interface

IRIS aims to be as customizable as possible to fit the user’s requirements. Therefore the whole GUI was designed in a modular way, allowing to use only the components necessary for the intended tasks. Besides the (de-)activation of (un-)required modules, it is further possible to control how they should be displayed (e.g. integrated within the main window or in separate windows) for even more customization and how they are updated in case certain events occur to maximize the performance and to avoid slowdowns if for example large amounts of incoming data would continuously trigger computationally intensive functions which are not necessary for any received packet.
IRIS provides several views, fulfilling different tasks like a packet view to inspect the content of received messages, a communication panel to handle network related tasks, a visualization component and even a map view to inspect a node’s position on the globe (if geographic information are available). All of them can be combined in any way to achieve high flexibility and an efficient workflow when working with IRIS.

Extending IRIS

Extending Functions

In IRIS, a function is created via the definition of a function template, which specifies the number of input attributes (ports) and the number of static configuration values.

IRIS allows the user to process the experiment data by defining customized function templates, which can be categorized into three types. The first type is the monitoring function, which produces no output value but only examines the attribute values of incoming messages. They can be used, e.g., for implementing an alarm function, which displays a warning message when an attribute value reaches a certain threshold. The second type is the scalar function, which only outputs a scalar value. This function is normally used to generate an aggregated result such as Packet Reception Rate (PRR). The last type of functions outputs a new attribute. Most data processing functions fall into this category. Such functions are normally defined to process the original message values in order to generate a new value, e.g., filtering functions and transformation functions. Please note that the size of the output attribute (the number of messages it includes) can outnumber the size of the input attributes. Through this its possible defining functions can be used for prediction and future value estimation as it it necessary for some algorithms related to model driven data acquisition. The newly defined function template must be implemented in Java and the compiled class must be placed in modules.functions so that it is available to IRIS. The user defines the function logic by overriding the method computeData(), which is invoked every time a new packet is received. The following shows an example of a snipped definition of a CC2420 RSSI conversion function template.

  public float[] computeData(float[][] val, float[] set) {
    float[] res = new float [val[0].length];
    for(int i=0; i<val[0].length; i++)
      res [i] = val[0][i]-45;
    return res;

Extending the IRIS Views

Since IRIS was designed to allow for an easy extension of new features, the idea of interface-based components was also applied to the integration of GUI related elements. In order to enable the usage of new views for different ways to display and access information (e.g. custom deploy maps or other chart types), they only have to be connected to IRIS by implementing the “GUIModule” interface class which then acts as a bridge between the (possibly completely independent) GUI component and IRIS. For basic integration, it is sufficient to provide a name for the module and the component to be added to IRIS. To optionally gain access to further functionalities and increase the effectiveness of the correspondent module, a handler for pre-defined IRIS events can be implemented as well as entries for a menu bar and module related information.

The following shows the code, necessary for including a new debugging view into IRIS:

  public class GUI_TestPacketInsertion extends IRIS_GUIModule {
    private PanelTestBarPacketInsertion panelTestbar;
    public GUI_TestPacketInsertion(Model m) {
      panelTestbar = new PanelTestBarPacketInsertion(m);

    public String getModuleName() {
     return "(Test) Packet Insertion";

    public String getModuleDescription() {
      return "create random packets for debugging";

    public JPanel getGUIPanel() {
      return panelTestbar;

Extending Middleware Adapter

IRIS provides interfaces to read/send data from/to arbitrary sources, which allows the user to decide on incoming/outgoing port (e.g. “/dev/ttyUSB0”) during runtime. For this IRIS provides two classes, the Datacollectors and the SendingManager for receiving and sending messages respectively. I either way, IRIS distinguishes between the decoding/encoding process and the actual transmission of data.


To receive and parse messages, IRIS offers a base class for a collecting and a decoding respectively. Collectors are responsible for creating events once data is received over the specified port. The collector then hands the data to a decoder, which is capable of reading the messages content and parse it into a format suitable for the datamodel of IRIS. To implement your own receiving system for your desired datamodel, one has to:


In a similar way, IRIS provides two abstractions for sending and encoding. First, the encoder has to be specified which then creates a message object. This message object is then given to a sender, responsible for sending it on a specified port. To implement your own sending system, one has to:

To demonstrate this feature, IRIS comes with an already built in TinyOS receiving/sending system.

Contributing to IRIS

We are trying our best to make IRIS a good experience to you. However, we are not perfect and so is our code. If you find any problems when running IRIS, please let us know by open a ticket in our bug tracker. When writing a new ticket, please describe the problem as specific as possible. Every minute that you spend in describing the problem might save us hours in finding a solution.
Of course we are also happy for any code contribution. If you are interested in contributing a patch or a new feature, please contact one of the following active developers:

Similar Programs

Of course we are trying to make IRIS the perfect candidate for experiment management, data analysis and visualization. To the best of our knowledge, IRIS is the first tool that provides an integrated solution for the above issues and offers a flexible mechanism for the user to define application-specific processing functions to meet the specific requirements of various applications and deployments.
However everybody has its own requirements on the toolset he uses and sometimes IRIS might not provide the right capabilities to meet those requirements. The following provides a list of programs, that we find interesting. Each of those programs is unique in the features it provides. For each category of programs, we add a list of differences to IRIS.

Similar to IRIS, these tools offer a user interface allowing users to interact with the testing nodes that gather network parameters, to visualize the data packets and to process/analyse the data. The difference is that these tools gather raw data packet statistics such as received signal strength (RSSI), link quality indicator (LQI), noise floor, and define a fixed set of performance metrics, e.g., packet delivery, temporal and spatial correlations and link asymmetries. IRIS does not limit the processing data type and allows the user to define application-specific processing functions. We note that IRIS can share similar functionality if the same metrics are defined as IRIS functions. Both are available as open source.

Languages for Efficient Data Processing

The following provides a list of notable technical languages and toolsets for performance analysis, algorithm development and model design. They also provide a rich set of built-in mathematical functions for a wide range of applications such as communication, signal processing, computational biology, etc. However they do not provide any integration for wireless sensor networks nor the flexibility of IRIS to integrate other data sources.

Open Source:


Spatial Data Analysis

Spatial analysis can be supported by programs like the following. While these tools are powerful for data processing, they cannot be used for run-time WSN data analysis.

Open Source


WSN Data Collection and Analysis

Commonly used for WSN data collection and visualization. However, they have limited capabilities for data processing. Some of the tools are not available for downloading, in this case we refer to the corresponding research article.

License information

The IRIS source code is subject to the terms of the Mozilla Public License, v.2.0. If a copy of the MPL was not distributed with one of the files, You can obtain one at

Richard Figura, Matteo Ceriotti, Chia-Yen Shih, Margarita Mulero-Pázmány, Songwei Fu, Roberta Daidone, Sascha Jungen, Juanjo José Negro and Pedro José Marrón. IRIS: Efficient Visualization, Data Analysis and Experiment Management for Wireless Sensor Networks. In EAI Endorsed Transactions on Ubiquitous Environments (to appear), 2014.

Richard Figura, Chia-Yen Shih, Songwei Fu, Roberta Daidone, Sascha Jungen and Pedro José Marrón. IRIS: A Flexible and Extensible Experiment Management and Data Analysis Tool for Wireless Sensor Networks. In 4th International Conference on Sensor Systems and Software (S-CUBE), June 2013.

Richard Figura, Sascha Jungen, Ramin Soleymani, Chia-Yen Shih and Pedro José Marrón. Demo Abstract: IMAC, Enabling Flexible Configuration and Result Analysis for Diverse Wireless Sensor Network Experiments. In 9th European Conference on Wireless Sensor Networks, February 2012 (EWSN).

  1. After the Greek goddess IRIS for the meaning for messaging and communication.