Important Note:

This information is now rather out of date. My research notes are now kept on a wiki, a static version of which is located here.

Software Architectures for Embedded Systems


The embedded systems that we are interesting in are those that must react to their environment, and as such are almost synonymous with robots. To gain background knowledge, it is useful to take a look at current robot programming methods.

Current methods for robotic programming systems can be divided into two broad categories:
  • Manual: includes text based and graphical languages. Text based languages include controller specific (assembly-like) languages, generic procedural languages, and behavior-based languages. Each of the robot's actions has to be explicitly described by the programmer.
  • Automatic: Spans the range from simplistic demonstration systems to complex machine learning. Robot behavior is not specifically described initially, but emerges from training and learning.

Overview of Problem

The increasing complexity of embedded systems and the need for them to deal with uncertain information from sensors and failures have exposed the shortcomings of manual approaches to programming. There are simply too many possible system interactions for the programmer to enumerate, and too many unpredictable failure modes for the programmer to provide contingency plans for.

Automatic methods, on the other hand, are either too resource intensive or not robust enough to handle novel situations, such as an unpredicted sensor failure.

The ideal solution would be one that allows a programmer to specify system behavior without needing to reason about how to determine state or recognize component failures. State can be determined probabilistically from sensor input (which may be noisy and even faulty), and component failures should automatically detected and if possible recovered automatically. Furthermore, this must all be done within tight time and resource constraints common among embedded systems.

Model Based Programming

A possible solution is being investigated by the Model-based Embedded & Robotic Systems (MERS) group at MIT.

Model Based Programming allows a programmer to describe the behavior of a system as a progression of desired states. A "plant model" describes the system in terms of possible states and transitions (include failure states), as well as observable variables and control variables. State is estimated using the observable variables (such as sensors), and transitions are initiated by control variables (such as command signals). A generic deductive controller is responsible for moving the system to the state specified by the programmer.

Introduction to work by the MERS group:

Real Application... In Space!

The MERS work is rooted in the Remote Agent / Livingstone experiments performed on the Deep Space 1 satellite (DS1). For a short period of time, DS1 was under the direct control of Remote Agent, which successfully planned and executed several actions, such as rotating the satellite and photographing targets. There were also several simulated component failures, which were resolved with the Livingstone mode identification and reconfiguration module.


The Software Architecture proposed by the MERS group differs from the Remote Agent / Livingstone approach. The MERS architecture is focused around the Titan Executive, which takes as input a Control Program and a Plant Model, deduces the correct course of action, and manipulates the system through a low level interface to achieve the goal state.

Basic Examples

In order to get a more grounded idea of just how the Titan architecture works, I made a presentation that explores several simple examples. The main intention was to gain a firm understanding of the level of abstraction that each component is written at. For example, what are a plant's control variables, and how do we decide if something should be in the control program or incorporated into the plant model? Also, what should go into a Plant Model, and how does one go about writting it?

    Examples (from "Model-Based Autonomy for the Next Generation of Robotic Spacecraft")
  • My slides: example.pdf