This paper presents a time division multiple access medium access control protocol for wireless sensor/actuator networks implemented with a contention-free message scheduler. A message scheduler is used to determine which message has access to the medium at any time. A set of messages is contention-free if only one message is ready at a time. Otherwise, some other criterion such as priority must be used to resolve contention. In this case, the message scheduler at each node in the network must schedule all messages in order to resolve contention. If the schedule is contention-free however, then each node only schedules the messages that interest it. The key contribution of our contention-free scheduler protocol is scalability. Large wireless sensor/actuator networks may contain hundreds of nodes exchanging thousands of messages. Due to resource constraints it is infeasible that each node schedule every message. Our protocol scales by optimizing each node to schedule only the messages it is interested in.

This paper describes a computer-aided software engineering (CASE) tool that helps designers analyze and fine-tune the timing properties of their embedded real-time software. Existing CASE tools focus on the software specification and design of embedded systems. However, they provide little, if any, support after the software has been implemented. Even if the developer used a CASE tool to design the system, their system most likely does not meet the specifications on the first try. This paper includes guidelines for implementing analyzable code, profiling a real-time system, filtering and extracting measured data, analyzing the data, and interactively predicting the effect of changes to the real-time system. The tool is a necessary first step towards automating the debugging and fine tuning of an embedded system's temporal properties.

We have designed a hardware-assisted interprocessor communication (IPC) mechanism that can reduce the communication overhead of embedded microcontrollers by a factor of 30 or more. The real-time communication mechanism allows processes to exchange data in a predictable and timely manner, with minimum overhead, in both single and multiprocessor environments. The hardware assist is a modified DMA (direct memory access) architecture. We combined it with an existing software-based real-time communication mechanism that takes advantage of the fact that, in control systems, IPC requirements for most processes in the system are small and known a priori. The mechanism is designed especially for digital control systems that can be defined as a collection of software components that follow the port automaton model, for which it is more important to always obtain the most recent data, rather than always needing to process every data item.

This study focuses on the current state of error-handling technology and concludes with recommendations for further research in error handling for component-based real-time software. With real-time programs growing in size and complexity, the quality and cost of developing and maintaining them are still deep concerns to embedded software industries. Component-based software is a promising approach in reducing development cost while increasing quality and reliability. As with any other real-time software, component-based software needs exception detection and handling mechanisms to satisfy reliability requirements. The current lack of suitable error-handling techniques can make an application composed of reusable software nondeterministic and difficult to understand in the presence of errors.

The port-based object is a new software abstraction for designing and implementing dynamically reconfigurable real-time software. It forms the basis of a programming model that uses domain-specific elemental units to provide specific, yet flexible, guidelines to control engineers for creating and integrating software components. We use a port-based object abstraction, based on combining the notion of an object with the port-automaton algebraic model of concurrent processes. It is supported by an implementation using domain-specific communication mechanisms and templates that have been incorporated into the Chimera real-time operating system and applied to several robotic applications. This paper describes the port-based object abstraction, provides a detailed analysis of communication and synchronization based on distributed shared memory, and describes a programming paradigm based on a framework process and code templates for quickly implementing applications.

A dynamically reconfigurable real-time software (DRRTS) paradigm can be used effectively in the design of embedded systems to provide many major advantages over conventional software development techniques. The benefits include rapid development which reduces development time and cost, ability to easily upgrade and maintain embedded software, and both analytic and practical tools for automated analysis and systematic fine tuning of the embedded system. Our current research is founded upon the Chimera Methodology, which demonstrated the feasibility of using dynamically reconfigurable software to control robots. However, there are still many design challenges in order to use it in an embedded system, which has less flexibility, severe limits on memory and CPU bandwidth, and more rigid timing constraints and reliability specifications. We have several ongoing projects which address some of the issues, in a strive towards the overall objective of creating a software infrastructure for developing dynamically reconfigurable embedded software.

The Chimera Methodology is a software engineering paradigm that enables rapid development of real-time applications through use of dynamically reconfigurable and reusable software. It is targeted towards a distributed shared memory computing environment. The primary contribution of this research is the port-based object model of a real-time software component. The model is obtained by applying the port-automaton formal computational theory to object-based design. A finite state machine, detailed interface specifications, and a C-language template are used to define the port-based object. Tools to support the in-tegration, scheduling, and state variable communication between the objects have been developed and incorporated into the Chimera Real-Time Operating System. Techniques for verifying correctness and analyzing performance are also provided for configuration managers that integrate software designed using the port-based object model.

Component-based real-time software speeds development and lowers cost of robotics applications. It enables the use of rapid prototyping or incremental software process models. The Chimera Methodology is a software engineering paradigm targeted at developing and integrating dynamically reconfigurable and reusable real-time software components. It is founded upon the notion of port-based objects. The focus of this paper is how to apply the Chimera Methodology specifically to the development of robotic applications.

Abstract—In this paper we develop a framework for integrating real-time software modules that comprise a reconfigurable multisensor based system. Our framework is based on the proposed concept of a global database of state information through which realtime software modules exchange information. This methodology allows the development and integration of reusable software in a complex multiprocessing environment. A reconfigurable sensor-based control system consists of many software modules, each of which can be modelled using a simplified version of a port automaton. Our new state variable table mechanism can be used in both statically and dynamically reconfigurable systems, and it is completely processor independent. Individual modules may also be combined into larger modules to aid in building large systems, and to reduce bus and CPU utilization. An efficient implementation of the state variable table mechanism, which has been integrated into the Chimera II Real-Time Operating System, is also described. 1 Keywords—reconfigurable sensor-based control systems, reusable software, real-time operating systems, interprocessor communication, spin-locks, real-time software modelling. I.

The Chimera II has been designed as a local operating system, to be used in conjunction with a global operating system. It executes on one or more single board computers in a VMEbus-based system. Advanced sensor-based control systems are both statistically and dynamically reconfigurable. As a result, they require many special features, which are currently not found in commercial real-time operating systems. Several design issues for such systems are presented as well as the features the authors have developed and implemented as part of Chimera II. These features include: a real-time kernel with dynamic scheduling, global error handling, user signals, and two levels of device drivers; an enhanced collection of interprocessor communication mechanisms, including global shared memory, spin-locks, remote semaphores, priority message passing, global state variable tables, multiprocessor servo task control, and host workstation integration; and several support utilities, including a UNIX C and math libraries, a matrix library, a command interpreter library, and a configuration file library.>

A description is given of the CHIMERA II programming environment and operating system, which was developed for implementing real-time robotic systems. Sensor-based robotic systems contain both general- and special-purpose hardware, and thus the development of applications tends to be a time-consuming task. The CHIMERA II environment is designed to reduce the development time by providing a convenient software interface between the hardware and the user. CHIMERA II supports flexible hardware configurations which are based on one or more VME-backplanes. All communication across multiple processors is transparent to the user through an extensive set of interprocessor communication primitives. CHIMERA II also provides a high-performance real-time kernel which supports both deadline and highest-priority-first scheduling. The flexibility of CHIMERA II allows hierarchical models for robot control, such as NASREM, to be implemented with minimal programming time and effort.>