subsumption architecture

Table of Contents

_20240203_143653screenshot.png

Subsumption Architecture[1] is a layering robot controll paradigm.

1. Layer of control definition   ATTACH

_20240409_111419screenshot.png system is devided into layers, where higher level layer may take control of the system when they are activated.

Backlinks

(Subsumption architecture)

Subsumption architecture in is implemented with Layer of control definition and trigger-action layer definition.

Behaviour
each behaviour corresponds to a layer in subsumption architecture defined with trigger-action layer definition
single thread state machine
LSMEW uses a single thread to embody each state, in which a sequence of trigger-states with descending priority(each trigger-state suppresses all states after it) is checked one by one on unsatisfaction, until a trigger-state delivers a message of truth(or triggered), when all following triggers would be supressed, and the linked action would be performed for one step. _20240409_122106screenshot.png
Graceful stop
As each behaviour is totally seperated, and there’s no parallel processing, when 2 consecutive actions are from different behvaiours(2 different action state), an additional “graceful stop” method would be performed on the former, so as to keep internal representations of behaviours intact. This extension can also be implemented equivallently with a “stale check” state that reinitializes internal representation when finding internal representation stale in each action.

trigger-action layer definition

(trigger-action layer definition)

_20240409_114733trigger-action.drawio.svg In Layer of control definition, each level of behaviour could be defined with the tuple \([trigger, action]\) in which :

  • when higher level behaviour’s trigger returns true, input to lower level is suppressed
  • when a behaviour’s trigger returns true, it’s action is perfomred

In principle, all layers’ triggers are concurrently monitored, so if any behaviour have been triggered, they may be enacted; an implementation by lejos uses a single thread to enumerate triggers from top priority

2. ASFM definition   ATTACH

_20240409_111841screenshot.png In implementation, Brook uses AFSM, in which the whole system uses 1 giant AFSM with lots of states

With this definition, subsumption architecture adds new syntax supressor connection and inhibitor connection. In this definition using subsumption architecture indicates 2 things to bare in mind in the development process:

  • organize states that represent the same behaviour into the same layer
  • when the lower level layer is done, only addition of inhibitor and supressor connectings to connections are allowed; you cannot rearrange lower layer states, you cannot change the lower layer code.

3. trigger-action layer definition   ATTACH

_20240409_114733trigger-action.drawio.svg In Layer of control definition, each level of behaviour could be defined with the tuple \([trigger, action]\) in which :

  • when higher level behaviour’s trigger returns true, input to lower level is suppressed
  • when a behaviour’s trigger returns true, it’s action is perfomred

In principle, all layers’ triggers are concurrently monitored, so if any behaviour have been triggered, they may be enacted; an implementation by lejos uses a single thread to enumerate triggers from top priority

Backlinks

(Subsumption architecture)

Subsumption architecture in is implemented with Layer of control definition and trigger-action layer definition.

Behaviour
each behaviour corresponds to a layer in subsumption architecture defined with trigger-action layer definition
single thread state machine
LSMEW uses a single thread to embody each state, in which a sequence of trigger-states with descending priority(each trigger-state suppresses all states after it) is checked one by one on unsatisfaction, until a trigger-state delivers a message of truth(or triggered), when all following triggers would be supressed, and the linked action would be performed for one step. _20240409_122106screenshot.png
Graceful stop
As each behaviour is totally seperated, and there’s no parallel processing, when 2 consecutive actions are from different behvaiours(2 different action state), an additional “graceful stop” method would be performed on the former, so as to keep internal representations of behaviours intact. This extension can also be implemented equivallently with a “stale check” state that reinitializes internal representation when finding internal representation stale in each action.

(Subsumption architecture)

Subsumption architecture in is implemented with Layer of control definition and trigger-action layer definition.

Behaviour
each behaviour corresponds to a layer in subsumption architecture defined with trigger-action layer definition
single thread state machine
LSMEW uses a single thread to embody each state, in which a sequence of trigger-states with descending priority(each trigger-state suppresses all states after it) is checked one by one on unsatisfaction, until a trigger-state delivers a message of truth(or triggered), when all following triggers would be supressed, and the linked action would be performed for one step. _20240409_122106screenshot.png
Graceful stop
As each behaviour is totally seperated, and there’s no parallel processing, when 2 consecutive actions are from different behvaiours(2 different action state), an additional “graceful stop” method would be performed on the former, so as to keep internal representations of behaviours intact. This extension can also be implemented equivallently with a “stale check” state that reinitializes internal representation when finding internal representation stale in each action.

4. links

5. another definition

Subsumption architecture is in its core Augmented finite-state machines

Bibliography

[1]
R. Brooks, “A robust layered control system for a mobile robot,” Ieee journal on robotics and automation, vol. 2, no. 1, pp. 14–23, 1986, doi: 10.1109/JRA.1986.1087032.

Backlinks

robot control system specification language

a lisp extension designed and described in [1], to specify a layer in subsumption architecture.

The language assume a model of Definite State Machine of the layer.

Each state is of the following 4 types:

output
an output message -> actuator. (then enter a new state)
side effect
manipulate an internal variable of the layer (then enter a new state)
conditional dispatch
(if predicate stateA stateB). predicate use internal variable or inputs.
event dispatch
(cond predicateA stateA predicateB stateB predicateC stateC …).
(defmodule avoid 1
  :inputs (force heading)
  :outputs (command)
  :instance-vars (resultforce)
  :states
  ((nil (event-dispatch (and force heading) plan))
   (plan (setf resultforce (select-direction force heading))
         go)
   (go (conditional-dispatch (significant-force-p resultforce 1.0)
                             start
                             nil))
   (start (output command (follow-force resultforce))
          nil)))

lifestyle script

(The human processor of lifestyle script: 3 layer model)

The lifestyle script is not executed by a computer program, it is executed by a human, very likely who wrote the script.

A subsumption architecture-like paradigm of human behaviour is assumed: 

level-3 living-essential
level-2 script
level-1 spontaneity

with living-essential oppressing script and spontaneity, and script oppressing spontaneity.

What this means is that with script, you halt only when living-essentials are triggered like being very hungary or dehydrated. Whenever a rule in the script is triggered, and there’s no living emergency (which your body would tell), you halt any act of spontaneity, and do the action in the script.

injection

(projection-induced injection)

projection-induced injection refers to the protocol of doing injection when some tool is required in projection.

An example is like:

  1. try to use subsumption architecture in a project [projection require internel representation of subsumnption architecture]
  2. realize that I don’t really know what subsumption architecture would really look like
  3. inject a whole network of subsumption architecture from some materil I found online into my internel representation(zettelkasten)

Typical characterisitics of this type of injection is that:

  • it is based on the material - you are still injecting the whole concept of subsumption architecture, with a mechnism like BFS. you don’t just get what you need and get off; you get the whole thing, and then you get back to the projection, and only use a subset from it.

zettelkasten activity report

(2024 > 02 - February > <2024-02-17 Sat>)

in 02/17/24 to 02/18/24, created 594 nodes (this is not accurate, I think that probably is the day I move everything from /home/Notes to /home/Dropbox/Notes)

(Subsumption architecture)

Subsumption architecture in is implemented with Layer of control definition and trigger-action layer definition.

Behaviour
each behaviour corresponds to a layer in subsumption architecture defined with trigger-action layer definition
single thread state machine
LSMEW uses a single thread to embody each state, in which a sequence of trigger-states with descending priority(each trigger-state suppresses all states after it) is checked one by one on unsatisfaction, until a trigger-state delivers a message of truth(or triggered), when all following triggers would be supressed, and the linked action would be performed for one step. _20240409_122106screenshot.png
Graceful stop
As each behaviour is totally seperated, and there’s no parallel processing, when 2 consecutive actions are from different behvaiours(2 different action state), an additional “graceful stop” method would be performed on the former, so as to keep internal representations of behaviours intact. This extension can also be implemented equivallently with a “stale check” state that reinitializes internal representation when finding internal representation stale in each action.

Author: Linfeng He

Created: 2024-04-14 Sun 03:25