The Wiselib is an algorithm library for sensor networks. It contains various algorithm classes (for instance, localization or routing) that can be compiled for several sensor network platforms such as iSense or Contiki, or the sensor network simulator Shawn. It is completely written in C++, and uses templates in the same way as Boost and CGAL. This makes it possible to write generic and platform independent code that is very efficiently compiled for the various 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 any line of algorithm code.
Algorithms can be directly integrated in your application. 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. Another scenario are pure Wiselib applications: We provide an own application_main that is called by Wiselib code, and you can integrate algorithm implementations there. The advantage is that these applications can be compiled for any supported platform, without changing any line of code (instead, just makefile targets). Similarly to the own Wiselib application, any algorithm can be compiled as an OpenCom? component, which allows for dynamically loading an algorithm in your application.
There are basically three kinds of folders. First, the Wiselib code in
wiselib.testing (which only contains algorithms,
but no stand-alone applications). Second, examples of how to integrate
Wiselib algorithms in own applications (
shawn_apps). Third, the sandbox with some test code (e.g., comparison
of virtual inheritence with pure template solutions).
Contains stable Wiselib code that was tested for all supported platforms (at least, for all platforms that are part of stable). The code is divided into algorithms (the heart of the Wiselib), external interfaces (connections to the different OSs), internal interfaces (data structures), and util (different useful things such as data serialization, the pSTL, or delegates for efficient callbacl realization).
Contains newly developed Wiselib code that may not be tested on all platforms, or implementations of concepts that may change in the near future. The structure is the same as in wiselib.stable: algorithms, external interfaces, internal interfaces, and util.
Contains examples of standalone Wiselib applications with an own application_main method. These apps can be used to write a whole application once, and compile it for different platforms just by changing the make target.
Examples of Wiselib integration in native iSense applications.
Examples of Wiselib integration in Shawn processors. Note that the Wiselib module in shawn.svn/src/apps must be enabled!
Run Wiselib application on PC - examples for ordinary appplications (with an iSense node attached to the PC, the PC can participate in a iSense sensor network!), and apps where a netbook is attached to a Roomba.
Ctonains compile script to run Wiselib applications on network simulator 3 (NS-3) and source code of NS-3 external interfaces
Main sources for
doxygen documentation. Contains concept descriptions
and main doxygen pages. To create doygen documentation, just run:
in Wiselib's root folder.