• View
• Edit
• History
• Print

ThreeLevel

Three Level Architecture

The fundamentals of the Three Level Architecture have been expressed in a slew of robotic architectures. From the bottom up, there is a reactive layer which essentially runs control loops for hardware. This layer is reactive, and handles sensors and actuation. Above that sits a "sequencer" or "executive" which operates over an abstraction which combines sensor input, knowledge, and possible actuator commands into skills which the system can perform. Finally, at the top, is the deliberative planner, which utilizes the abstraction provided by the executive to create complex plans.

There is a great deal of variation in the abstraction provided by the middle layer and its responsibilities, as well as the representation of knowledge. The overriding goal of this level is to provide a level of sophistication so that the deliberative layer's state space search (planning) problems are tractable.

The clear (on a per-system basis at least) of these layers differentiates Three Level from Subsumption. And the final property, best stated by the 3T paper, is that, "all three tiers must operate concurrently and asynchronously."

TODO: The Three Level Architecture (capitalize Architecture?) sought to merge the deliberative planning of SPA with the reaction speed of Subsumption. It was developed at (JPL?) by researchers such as ? ? ? ? These things should be mentioned.

Navigation Example

At least at a conceptual level, we can see how this architecture could work for a simple navigation problem.

TODO: put a img / diagram here

History

Early robotics research used the simplistic Sense Plan Act(SPA) architecture, in which the robot would sense its environment, plan a sequence of actions, and then execute that plan. This architecture was found to be deficient because by the time the robot finished the planning step, the would would have already changed and the plan was likely now invalid. This would trigger another planning step, and the robot would be paralyzed as it continuously made useless plans. Even in a static environment, the robot would have to re-plan often as the execution of the plan was not perfect; putting the robot into a slightly different state than expected.

To address this problem, the Subsumption architecture was proposed. (perhaps only to supplement SPA). This architecture was not iterative, nor hierarchical. It consisted of a set of modules, each of which took inputs (such as sensor input, or perhaps signals from other modules) and quickly processed them to produce an output signal. This quick processing was accomplished by avoiding the construction of a model of the robot's environment, since, as ? said, "The world is its own best model?".

This lack of an internal model precluded many AI techniques used in the SPA architecture. The Subsumption architecture was able to produce interesting emergent behavior through one important detail: any module could suppress the signal of another, allowing some modules to override others in certain cases. While this allows for some complex behavior, it turns out that it is not scalable to the complex tasks that modern robots are expected to perform ?citation ?.