Tapper: Scripting Engine for Distributed Embedded Systems

• Introduction

  We present Tapper, a new software architecture for distributed embedded systems. Tapper features a scripting engine built on top of low-level APIs including wired or wireless communication primitives. The script interpreter provides a unified representation of multi-level hardware abstractions in heterogeneous platforms. It supports in-field reconfiguration of system parameters by passing scripts over communication links. In addition, scripts also generalize communication protocols and messages in distributed embedded networks. With Tapper, embedded application can be easily implemented with human readable scripts like Perl or Python. The current Tapper platforms include a variety of embedded prototypes with PIC, AVR and other micro-controllers. We demonstrate three fully-implemented wireless embedded applications: (1) real-time motion monitor, (2) real-time 3-D tilt monitor, and (3) wireless gaming console.

• Proposal

  Emerging applications such as wireless sensing and ambient intelligence are driving the trends towards larger scale, heterogeneous, distributed and networked embedded systems with increasingly dynamic configurations as well as growing computation requirements.  At the same time, embedded systems designers today are still taking the same single-processor, platform-specific approach to the development of embedded systems in ways essentially unchanged for the last several decades. That is, they perform low level manipulation of architecture-dependent registers for configuration and control of interrupts, I/O, and power. This methodology drives up the software development cost and effort and is not scalable. Our approach is to support a lightweight script interpreter that can handle system services including real-time and power control as well as standard, extensible communication primitives.  In fact, scripts represent a generalization of communication messages that all distributed systems must be able to handle. A scripting architecture for embedded systems will have the same modular, dynamic benefits as middleware systems but without the heavy marshalling/demarshalling runtime overhead. More importantly, because scripts are Turing complete, they will enable seamless interoperability among a wide range of systems from the smallest of sensor nodes to large-scale, high-performance, and general-purpose computing clusters that can assist small systems with sophisticated decisions and optimizations.
  
  In Tapper project, we present a scripting-enable software architecture and communication mechanism for distributed embedded systems. It features a light-weight interpreter that parses human readable scripts into calls to system services supported by underlying hardware platforms. The system service primitives include basic GPIO invocations, analog-digital conversions, timer/counter handling routines, external interrupts configuration, as well as communication transactions over wired and wireless links. Although the hardware architecture is different on each platform, Tapper can provide a unified image of all hardware resources over heterogeneous platform with the same set of commands. Current hardware prototypes include AVR and PIC micro-controllers interfaced with RS-232, 2.4GHz wireless modules and sensors. Every Tapper platform behave like a node in a wireless network. Each node features a serial command prompt that acts as the front-end to as the user interface and the host programming interface. Users can set configuration parameters and invoke system services by typing human readable commands interactively with HyperTerminal and any serial terminal programs. The command prompt on one node can be used to control any other nodes through the 2.4GHz wireless link with the same set of commands tagged with network addresses. The serial link also serves as the host programming interface that allows host software to send application code as scripts wirelessly to remote Tapper nodes, without erase and upload the firmware for each individual embedded application.
  
  In addition to the user-friendly serial command console, we currently have implemented three wireless embedded demos with the proposed Tapper architecture.
  

  1. A real-time wireless motion monitor. This is implemented with an AVR Butterfly node interfaced with a 3-D accelerometer that records the 3-D motion in real-time. The 3-D motion is converted by ADC and sent over the RF link to another Tapper node connected to a host PC through the serial link. The host GUI software is able to set the configuration parameters (e.g., sampling rate), start/stop wireless application and display the 3-D motion in real-time. This demo represents a prototype of a variety of wireless embedded applications from patient monitoring in medical research to structural health monitoring in civil engineering.
  2. A real-time tilt monitor. This is similar to the first demo on Tapper nodes. A different host GUI tracks the tilt of a remote object and render its 3-D gesture in real-time with OpenGL. This demo can be extended to many real-time graphics and visualization application that allow to render complicated movements of remote objects with wireless sensors.
  3. A wireless gaming console. This demo reads the AVR Butterfly's joystick wirelessly to control the action of an airplane in a fully-functional shooting game.
     

  All three demos are implemented by Python on the host side, and the extra code to invoke wireless application on the remote Tapper node takes 50 lines or less of scripts..

Image Gallery

The AVR Butterfly interfaced with RF24G module and KXM52 3-D accelerometer	The PIC-40 board with the RF-24G module	The command prompt in a HyperTerminal
Demo 1: wireless motion monitor New! Play video   (10MB AVI)	Demo 2: wireless tilt detection with 3-D rendering New! Play video (10 MB AVI)	Demo 3: wireless console of a fun shooting game New! Play video  (13MB AVI)