Chih-Chieh Han

A dynamic operating system for sensor nodes

Sensor network nodes exhibit characteristics of both embedded systems and general-purpose systems. They must use little energy and be robust to environmental conditions, while also providing common services that make it easy to write applications. In TinyOS, the current state of the art in sensor node operating systems, reusable components implement common services, but each node runs a single statically-linked system image, making it hard to run multiple applications or incrementally update applications. We present SOS, a new operating system for mote-class sensor nodes that takes a more dynamic point on the design spectrum. SOS consists of dynamically-loaded modules and a common kernel, which implements messaging, dynamic memory, and module loading and unloading, among other services. Modules are not processes: they are scheduled cooperatively and there is no memory protection. Nevertheless, the system protects against common module bugs using techniques such as typed entry points, watchdog timers, and primitive resource garbage collection. Individual modules can be added and removed with minimal system interruption. We describe SOSs design and implementation, discuss tradeoffs, and compare it with TinyOS and with the Maté virtual machine. Our evaluation shows that despite the dynamic nature of SOS and its higher-level kernel interface, its long term total usage nearly identical to that of systems such as Matè and TinyOS.

Design and implementation of a framework for efficient and programmable sensor networks

Wireless ad hoc sensor networks have emerged as one of the key growth areas for wireless networking and computing technologies. So far these networks/systems have been designed with static and custom architectures for specific tasks, thus providing inflexible operation and interaction capabilities. Our vision is to create sensor networks that are open to multiple transient users with dynamic needs. Working towards this vision, we propose a framework to define and support lightweight and mobile control scripts that allow the computation, communication, and sensing resources at the sensor nodes to be efficiently harnessed in an application-specific fashion. The replication/migration of such scripts in several sensor nodes allows the dynamic deployment of distributed algorithms into the network. Our framework, SensorWare, defines, creates, dynamically deploys, and supports such scripts. Our implementation of SensorWare occupies less than 180Kbytes of code memory and thus easily fits into several sensor node platforms. Extensive delay measurements on our iPAQ-based prototype sensor node platform reveal the small overhead of SensorWare to the algorithms (less than 0.3msec in most high-level operations). In return the programmer of the sensor network receives compactness of code, abstraction services for all of the nodes modules, and in-built multi-user support. SensorWare with its features apart from making dynamic programming possible it also makes it easy and efficient without restricting the expressiveness of the algorithms.

Secure time synchronization service for sensor networks

In this paper, we analyze attacks on existing time synchronization protocols for wireless sensor networks. We propose a secure time synchronization toolbox to counter these attacks. This toolbox includes protocols for secure pairwise and group synchronization of nodes that lie in each others power ranges and of nodes that are separated by multiple hops. We provide an in-depth analysis of security and energy overhead of the proposed protocols.

Multi-level software reconfiguration for sensor networks

In-situ reconfiguration of software is indispensable in embedded networked sensing systems. It is required for re-tasking a deployed network, fixing bugs, introducing new features and tuning the system parameters to the operating environment. We present a system that supports software recon-figuration in embedded sensor networks at multiple levels. The system architecture is based on an operating system consisting of a fixed tiny static kernel and binary modules that can be dynamically inserted, updated or removed. On top of the operating system is a command interpreter, implemented as a dynamically extensible virtual machine, that can execute high-level scripts written in portable byte code. Any binary module dynamically inserted into the operating systems can register custom extensions in the virtual machine interpreter, thus allowing the high-level scripts executed by the virtual machine to efficiently access services exported by a module, such as tuning module parameters. Together these system mechanisms permit the exibility of selecting the most appropriate level of reconfiguration. In addition to detailing the system architecture and the design choices, the paper presents a systematic analysis of exibility versus cost tradeoffs provided by these mechanisms.

SensorWare: Programming sensor networks beyond code update and querying

Wireless ad hoc sensor networks have been largely designed with static and custom architectures for specific tasks, thus providing inflexible operation and interaction capabilities. Efforts to make sensor networks dynamically programmable stumble upon the problems of algorithmic expressiveness, compactness of transferred code, efficiency of executed code, and ease of programming. In short, the problem is the choice of abstraction for the sensor node run-time environment. Our framework, called SensorWare, defines and supports lightweight and mobile control scripts that allow the computation, communication, and sensing resources at the sensor nodes to be efficiently harnessed in an application-specific fashion, through the use of abstraction services. A key feature is that the run-time abstraction can change by dynamically defining new services. Furthermore, by making the scripts autonomously mobile we enable the deployment of the algorithm to be tied to its execution, a feature that reduces the code transferred, compared to conventional code deployment and update approaches. The implementation of SensorWare on an XScale-based prototype sensor node platform occupies less than 240 KB of code memory. The implementation is used to measure the delay and memory overheads, but more importantly, quantitatively highlight the trade-offs involved in run-time abstraction versatility.