The widespread distribution and availability of small-scale sensors, actuators, and embedded processors is transforming the physical world into a computing platform. Sensor networks that combine physical sensing capabilities such as temperature, light, or seismic sensors with networking and computation capabilities will soon become ubiquitous. Applications range from environmental control, warehouse inventory, and health care to scientific and military scenarios. Existing sensor networks assume that the sensors are preprogrammed and send data to a central frontend where the data is aggregated and stored for offline querying and analysis. This approach has two major drawbacks. First, the user cannot change the behavior of the system dynamically. Second, communication in today's networks is orders of magnitude more expensive than local computation; thus in-network storage and processing can vastly reduce resource usage and extend the lifetime of a sensor network.
The key area of investigation is to reduce energy consumption. While there is a large body of theoretical work in the community, implementations are hard to find. Since production hardware is difficult to use at best, and since we are still investigating the design of our query processing engine we have been developing a test platform to conduct this research.
This platform consists of a flexible, dynamic test architecture which lets us test and demonstrate many network modules as research is done on this code. The two modules, which together form this architecture, we have called GlobalTester and LocalTester. GlobalTester coordinates many nodes in the network (only from a test set up perspective, actual network operation is decentralized). LocalTester performs the other half of the coordination on each node. The Global and Local Testers only provide a simulated environment for nodes to run on and do not actually participate in network query processing. All of the network code we have written is unaware of the testing platform and perform as they would in a production environment.
At this time we have implemented our test platform code, developed a robust testing system and are currently writing our network code. We have divided our network code into several layers. The lowest level is the actual interface that our platform provides. For our test platform we have developed a single threaded simulator and a distributed simulator sitting on top of TCP/IP. On top of this layer sits our link layer which provides a broadcast and reception interface for upper layers to send and receive byte arrays. Above the link layer is our routing layer. The routing layer is divided into a kernel which receives messages, does duplicate elimination, updates shared datastructures (e.g. neighbor table) and chooses a routing module to use. Since this is a platform under constant development we have provided for several routing algorithms to be in operation simultaneously. Currently we've written flooding router and a tree based router. These routing modules choose the next hop for a message and/or dispatch to application code.
Currently we have simple test applications that sit on top of the routing layer to test and investigate the functionality we've implemented. These test applications expose some of the routing interface to the tester which can manipulate our network code and run scripted tests. In the future we plan to have query processing, data storage and sensor modules sit on top of the routing layer. These modules will interact to process external queries on sensor data that nodes throughout the network collect. The important feature these modules will provide, the real area of interest for this research, is coordinating local nodes to minimize network traffic and extend the lifetime of nodes, and thus the lifetime of the network.
Following is a link to a (somewhat out of date) design document detailing some of what is discussed above.
Also is a link to the Cougar research project in the Cornell CS department lead by Professor Johannes Gehrke which has spawned this work.