Google Summer of Code 2013 Organization The Wiselib

The Wiselib

Mailing List: mailto:wiselib@wiselib.org

The Wiselib is an algorithms and protocol library for networked embedded devices, such as microcontroller-based sensor nodes, Internet-of-Things-enabled devices and Android- or iOS-based mobile phones. It contains standard protocols (e.g., 6LowPAN, CoAP), algorithms (e.g., localization, routing, time synchronization, clustering), and data structures (e.g., an external-memory lists and sets, an RDF database), that can be compiled for several different platforms. The supported platforms include TinyOS and Contiki, the two major operating systems for sensor-class devices, as well as several device-specific firmwares (iSense, Feuerwhere, TriSOS, etc). The two major handheld OS (Android and iOS) are supported as well.

The Wiselib is written in C++. It uses templates and template specialization in the same way as Boost, CGAL, and the STL. This makes it possible to write generic and platform-independent code that is very efficiently compiled for the various platforms.

The motivating issue behind the Wiselib is the severe fragmentation of Internet of Things (IoT) devices. For sensor nodes, TinyOS dominates the US, and Contiki Europe, hindering exchange of ideas and code. Many IoT scenarios (say, Smart Cities where people can use their handheld to interact with local city services) require connectivity between mobile phones, infrastructure devices, and battery-powered sensors and actors. This requires either programming against a truly platform-independent API (such as the Wiselib), or porting and maintaining code for 5-10 completely different platforms.

We provide easy-to-use interfaces to the OS, which simplifies the development process and decreases the need for dealing with low-level functionality of specific hardware platforms. Algorithms can even be run in a simulation environment first (for debugging purposes, for example), and then compiled for real hardware platforms without changing a single line of algorithm code.

Algorithms can be directly integrated in applications. For example, when developing an application for iSense that collects sensor data values, a Wiselib routing algorithm can be used to route the data to a sink.

Projects

Completing Arduino Port This project involves adding functionality to the already existing Arduino port for The Wiselib. It mainly includes adding interfaces to XBee modules in API mode like Wifi, Blutooth, zigbee, etc. along with a working timer abstraction module which facilitates mutliple, parallel-running timeouts.
Implement CoAP (Conditional-)Observe in Wiselib CoAP is a RESTful application protocol for constrained nodes and networks. Resources (containing sensor informations) on a CoAP Server can change their state over time. To keep clients updated with the latest values the "CoAP Observe" extension has been proposed. In order to minimize the amount of data sent over the network, a client could also register for notifications of certain changes only (e.g. "notify me whenever the luminance changes drastically" ). For these scenarios, the "conditional observe" extension to CoAP is being developed. My proposal would be to extend the current CoAP implementation for Wiselib to support the "observe" and "conditional observe" extensions. Additionally I would try to implement the upcoming draft of high level states which enables a client to create resources with special names for ranges of values (e.g. "hot" for values between 30°C - 40°C).
IPv6 extension with Distributed Protocol Stacks The IPv6 protocol stack has been already implemented for The Wiselib, but some complicated, heavy parts (eg.: 6LoWPAN, Neighbor Discovery Protocol) need too much program memory and as a result the protocol stack is usable only on less resource constrained devices. The proposed implementation of the Distributed Protocol Stacks (DPS) enables the usage of more resource constrained platforms as well. With this solution a DPS client node has to bear only with the UDP and the basic ICMPv6 layers and it is able to use the rest of the protocol stack on the DPS server via remote procedure calls. Depending on the used testbed/deployment the implementation of the DPS can even multiply the number of IPv6 ready devices with The Wiselib.
Javascript Interface for Remote Controlling WISEBED Nodes "The Wisebed Testbed enables the easy deployment of large scale wireless sensor network experiments without the need to buy the expensive sensor node hardware. However, programmers still have to learn an embedded programming language and put up with the tedious debugging characteristics of a large embedded network. To lower these prerequisites for starting with the development of sensor network applications (e.g., for students), this projects aims at creating a remote control interface for wisebed nodes, which allows the easy programming and debugging of these applications inside a Webbrowser. For this, several wiselib applications need to be implemented for the different sensor node platforms, which expose the fundamental functions of the node hardware (such as: send(), receive(), getSensorValue() or switchOnLed()) to a Control Server, which is connected to all nodes via the testbed infrastructure. The Control Server then exposes these interfaces via a JavaScript interface, which allows the remote development and debugging of a sensor node application inside the browser of the programmer, enabling the interactive reprogramming of the nodes at runtime." - http://www.wiselib.org/gsoc/project_ideas.html
Wiselib Online Editing Service Wiselib supports a variety of target platforms (including different WSN hardware platforms, Android, Linux, iOS, and the Shawn simulator). This requires a very complex, error-prone, and time-consuming installation and configuration of all required tools and components to help developers work productivity. To ease this process, the goal of this project is to implement a cloud service for editing Wiselib code. Users just need to create an account and work on their fork of wiselib (or the original repository) to edit their code and collaborate with their colleagues. The service shall be designed as a RESTful web-based editor and use a remote compilation service for compilation on a subset of Wiselib platforms.
Wiselib: NS-3 Port The goal of this project is to port the Wiselib to ns-3 by implementing the basic Wiselib concepts like os, timer, radio, debug, clock, uart, rand, position, distance, etc for ns-3.