Emergent Control of
Self-Reconfigurable Robots
Kasper Støy
The Maersk Mc-Kinney Moller Institute for Production Technology
University of Southern Denmark
January 6, 2004
Cover: The CONRO self-reconfigurable robot configured as a hexapod (left) (USC Information Sciences Institute).
A Boeing 747 made from the modules of a simulated self-reconfigurable robot (right).
Abstract
In this thesis we look at control in the context of self-reconfigurable robots.
A self-reconfigurable robot is a robot built from potentially many modules
which are connected to form the robot. Each module has sensors, actuators,
processing power, and means of communicating with connected modules.
The robot autonomously changes shape by changing the way these modules
are connected. Self-reconfigurable robots have a high degree of robustness,
versatility, scale extensibility, and adaptability. This makes these robotic
systems interesting to study.
We introduce role-based control, which is a method used to implement
locomotion gaits in chain-type self-reconfigurable robots. Using this method
we have implemented four different locomotion gaits on the CONRO selfreconfigurable robot. Furthermore, we show how the robot can change between these locomotion patterns when it is dynamically reconfigured. We
show in a series of experiments that role-based control has the following
characteristics. 1) The control is robust to communication errors and module failure. 2) The number of modules can be changed during run-time. 3)
Sensor information can be incorporated into role-based control making it
possible for the robot to adapt the locomotion gait to the environment. 4)
The efficiency of the control after initial synchronization does not depend on
the number of modules. 5) The control system is simple and minimal. 6)
New locomotion patterns can be implemented relatively systematically using
role-based control.
We also introduce a method to control the self-reconfiguration process.
This method consists of two components. The first component takes a CAD
model of a desired shape and generates cellular automata rules which take
the global aspect out of the self-reconfiguration problem. The second component takes these rules and combines them with artificial chemical gradients
to make a control system. The characteristics of this control system are
efficiency and guaranteed convergence to the desired shape.
Overall, this thesis represents significant progress in emergent control of
self-reconfigurable robots.
3
4
Resumé (Danish)
I denne afhandling er problemstillingen, hvordan man kontrollerer selvrekonfigurerende robotter. Selv-rekonfigurerende robotter er robotter bygget
af mange selvstændige moduler, som hver især indeholder aktuatorer, sensorer, computerkraft og kommunikation. Disse robotter kan selv ændre den
måde, modulerne er sat sammen på og derved ændre deres form. Dette
gør selv-rekonfigurerende robotter interessante fordi de kan anvendes i situationer, hvor almindelige robotter ikke kan anvendes.
Vi introducerer rolle-baseret kontrol, som er en metode til at implementere gangarter i selv-rekonfigurerende robotter. Vi viser, at metoden
kan bruges til at implementere fire forskellige gangarter på CONRO robotten. Vi viser yderligere, at robotten kan skifte mellem gangarter afhænigt
af, hvordan modulerne er sat sammen. Vi viser i en række eksperimenter, at
rolle-baseret kontrol har følgende egenskaber. 1) Kontrollen er robust overfor modul- og kommunikationsfejl. 2) Antallet af moduler kan ændres under
programudførelse. 3) Kontrolsystemet kan via sensorer tilpasse gangarten til
omgivelserne. 4) Effektiviten af algoritmen afhænger ikke af antallet af moduler efter en indledende synkroniseringsfase. 5) Kontrolsystemet er minimalt.
6) Nye gangarter kan implementeres relativt systematisk.
Vi introducerer også en metode til at styre selve omrekonfigureringsprocessen. Metoden består af to delelementer. Det ene element genererer ud
fra en CAD model cellulære automat regler, som bruges til at styre rekonfigureringsprocessen. Det andet element kombinerer de genererede cellulære
automat regler med kunstige kemiske gradienter i et kontrolsystem. Denne
metode har de egenskaber, at den er systematisk og effektiv, samt at det er
garanteret, at robotten opnår den ønskede form.
Alt i alt repræsenterer denne afhandling et betydeligt fremskridt i emergent kontrol af selvrekonfigurerende robotter.
5
6
Preface
In 1998, the author entered the research field of robotics. The approach pursued then was highly inspired by work in new artificial intelligence. The goal
was to develop robots capable of handling tasks in complex, dynamic, and
unstructured environments: in other words in realistic real-world environments. Being a computer scientist, the author’s initial drive was to develop
control systems able to handle these kinds of task-environments. This work
resulted in a Master’s thesis entitled “Adaptive Control Systems for Autonomous Robots”(Støy, 1999), the core result of which was a reinforcement
learning algorithm based on neural networks. The reasoning was that learning is fundamental to handling these kinds of task-environments. The only
drawback of this work was that the whole system was tested on the Khepera
robot, a small mobile robot, in a simple, static, and structured environment.
This idea of the key to the problem being the control system was carried
over to the ant-inspired multi-robot coordination algorithms that the author
developed at USC Robotics Labs. However, during this research there was a
growing frustration that the robot never moved out of the simple, static, and
structured environments. The reason was quite obvious: wheel-based robots
were never able to move in a realistic environment. The limited capabilities
of the physical platform seemed more and more to be the problem. Unfortunately, there was little the author could do because of lack of hardware
skills.
The main motivation for entering the field of self-reconfigurable robots
was to work with a more advanced physical platform. This work was carried
out at the Maersk Mc-Kinney Moller Institute for Production Technology
and USC’s Information Sciences Institute. Here, for the first time, it was
possible to work with both the control and the morphology of the robot
at the same time. Maybe, this was the combination needed to move into
realistic environments.
The research field of self-reconfigurable robots is still young and researchers
are still struggling with the formidable challenge of controlling a shapechanging robot composed of distributed sensors, actuators, and processors.
7
It is also this challenge that we will address in this thesis. The idea of this
work is to keep a clear vision of the task-environments and push the basic
research on control of self-reconfigurable robots in this direction.
Kasper Støy
January 6, 2004, Odense, Denmark
8
Acknowledgements
I would first like to thank Henrik Hautop Lund for giving me the opportunity
to undertake this project. I would also like to thank Peter Will and WeiMin Shen from USC’s Information Sciences Institute who always had good
comments and suggestions.
Thanks also go to colleagues and friends at the Maersk Mc-Kinney Moller
Institute for Production Technology who were a great inspiration during the
project. Needless to say, their social support was crucial to the success of this
project. Specifically, the author would like to thank Esben H. Østergaard
with whom he had many useful conversations. Many thanks also go to Vibeke
Nielsen who proof read this thesis.
Finally, I would like to thank my family and friends for their support
especially, my wife Lina S. Støy, who not only accepted that I move to
Denmark to start the Ph.D. program, but also moved here to support me
emotionally. For this I am very grateful.
9
10
Contents
1 Emergent Control of Self-Reconfigurable Robots
1.1 The Grand Vision of Robotics . . . . . . . . . . .
1.2 Adaptive Robots . . . . . . . . . . . . . . . . . .
1.3 Self-Reconfigurable Robots . . . . . . . . . . . . .
1.4 Metrics . . . . . . . . . . . . . . . . . . . . . . . .
1.5 Control Systems for Self-Reconfigurable Robots .
1.6 Contributions . . . . . . . . . . . . . . . . . . . .
1.7 Structure . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
15
15
16
17
18
19
21
22
2 Physical Realizations of Self-Reconfigurable Robots
2.1 A Taxonomy . . . . . . . . . . . . . . . . . . . . . . .
2.1.1 Robots . . . . . . . . . . . . . . . . . . . . . .
2.1.2 Modular Robots . . . . . . . . . . . . . . . . .
2.1.3 Reconfigurable Modular Robots . . . . . . . .
2.1.4 Dynamically Reconfigurable Modular Robots .
2.1.5 Self-Reconfigurable Robots . . . . . . . . . . .
2.2 Morphology . . . . . . . . . . . . . . . . . . . . . . .
2.3 Chain-Type Systems . . . . . . . . . . . . . . . . . .
2.3.1 Polypod . . . . . . . . . . . . . . . . . . . . .
2.3.2 CONRO . . . . . . . . . . . . . . . . . . . . .
2.3.3 Polybot . . . . . . . . . . . . . . . . . . . . .
2.4 Lattice-Type Systems . . . . . . . . . . . . . . . . . .
2.4.1 Metamorphic Robot . . . . . . . . . . . . . .
2.4.2 Crystalline Robot . . . . . . . . . . . . . . . .
2.4.3 Fractum . . . . . . . . . . . . . . . . . . . . .
2.4.4 Micro Unit . . . . . . . . . . . . . . . . . . .
2.4.5 RIKEN Vertical . . . . . . . . . . . . . . . . .
2.4.6 Telecube . . . . . . . . . . . . . . . . . . . . .
2.4.7 MEL 3D Unit . . . . . . . . . . . . . . . . . .
2.4.8 Robotic Molecule . . . . . . . . . . . . . . . .
2.4.9 MTRAN . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
23
23
24
24
24
25
25
25
26
26
26
27
28
28
28
29
29
30
30
31
31
32
11
.
.
.
.
.
.
.
2.5
2.6
2.7
2.8
2.4.10 I-Cubes . . . . . . . . . . . . . . . . .
Summary . . . . . . . . . . . . . . . . . . . .
Evaluation Criteria for Hardware . . . . . . .
Discussion . . . . . . . . . . . . . . . . . . . .
2.7.1 Lattice-Type and Chain-Type Robots .
2.7.2 Sensors and Self-Reconfigurable Robots
2.7.3 Implications for Control . . . . . . . .
Conclusion . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
3 Control of Self-Reconfigurable Robots
3.1 Taxonomy of Control Systems . . . . . . . . . . . . . . .
3.1.1 Centralized Systems . . . . . . . . . . . . . . . .
3.1.2 Distributed Systems Based on Global Information
3.1.3 Emergent Systems . . . . . . . . . . . . . . . . .
3.2 Metrics and Evaluation Criteria . . . . . . . . . . . . . .
3.2.1 Robustness . . . . . . . . . . . . . . . . . . . . .
3.2.2 Adaptability . . . . . . . . . . . . . . . . . . . . .
3.2.3 Versatility . . . . . . . . . . . . . . . . . . . . . .
3.2.4 Scale Extensibility . . . . . . . . . . . . . . . . .
3.2.5 Environment Assumptions . . . . . . . . . . . . .
3.2.6 Scalability . . . . . . . . . . . . . . . . . . . . . .
3.2.7 Minimalism . . . . . . . . . . . . . . . . . . . . .
3.2.8 Systematicness . . . . . . . . . . . . . . . . . . .
3.2.9 Alternative Hardware . . . . . . . . . . . . . . . .
3.3 Discussion . . . . . . . . . . . . . . . . . . . . . . . . . .
3.3.1 Centralized Systems . . . . . . . . . . . . . . . .
3.3.2 Distributed Control Based on Global Information
3.3.3 Emergent Control . . . . . . . . . . . . . . . . . .
3.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . .
4 Locomotion Algorithms
4.1 Taxonomy of Locomotion Algorithms
4.2 Survey of Locomotion Algorithms . .
4.2.1 Fixed-shape locomotion . . .
4.2.2 Cluster-Flow Locomotion . . .
4.3 Discussion . . . . . . . . . . . . . . .
4.3.1 Lattice-Type . . . . . . . . .
4.3.2 Chain-Type . . . . . . . . . .
4.4 Conclusion . . . . . . . . . . . . . . .
12
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
32
34
34
36
36
37
37
38
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
39
39
39
40
40
40
41
41
41
42
42
42
43
43
43
43
44
45
45
46
.
.
.
.
.
.
.
.
47
47
48
48
49
51
51
51
52
5 Role-Based Control
5.1 A Role . . . . . . . . . . . . . . . . . . . . . .
5.2 Playing a Role . . . . . . . . . . . . . . . . . .
5.3 Selecting a Role . . . . . . . . . . . . . . . . .
5.4 Time Complexity of Role Playing . . . . . . .
5.5 Role-Based Control without Role Selection . .
5.5.1 The Caterpillar . . . . . . . . . . . . .
5.5.2 The Sidewinder . . . . . . . . . . . . .
5.6 Role-Based Control with Role Selection . . . .
5.6.1 The Walkers . . . . . . . . . . . . . . .
5.6.2 Walker and Sidewinder Combination .
5.7 Handling a General Configuration . . . . . . .
5.7.1 The Rolling Track . . . . . . . . . . .
5.8 Role Selection Based On Sensor Input . . . .
5.8.1 Related Work on Sensors . . . . . . . .
5.8.2 A Reactive Walker . . . . . . . . . . .
5.8.3 Sensors and Self-Reconfigurable Robots
5.9 Discussion . . . . . . . . . . . . . . . . . . . .
5.10 Conclusion . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
6 Self-Reconfiguration Algorithms
6.1 Problem Definition . . . . . . . . . . . . . . . . . . . . .
6.2 Self-Reconfiguration Specific Metrics . . . . . . . . . . .
6.2.1 Scalability in Self-Reconfiguration . . . . . . . . .
6.2.2 Versatility - Classes of Reconfiguration Problems
6.3 Survey of Self-Reconfiguration Algorithms . . . . . . . .
6.3.1 Chain-Type . . . . . . . . . . . . . . . . . . . . .
6.3.2 Lattice-type . . . . . . . . . . . . . . . . . . . . .
6.4 Discussion . . . . . . . . . . . . . . . . . . . . . . . . . .
6.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
55
57
58
58
61
62
62
65
66
67
74
77
79
79
79
81
86
87
91
.
.
.
.
.
.
.
.
.
93
93
94
94
94
95
95
96
100
102
7 Self-Reconfiguration Based on Gradients and Cellular Automata
105
7.1 Cellular Automata Rule Generator . . . . . . . . . . . . . . . 106
7.1.1 User Interface . . . . . . . . . . . . . . . . . . . . . . . 106
7.1.2 Cellular Automata . . . . . . . . . . . . . . . . . . . . 106
7.1.3 CA Rule Generator . . . . . . . . . . . . . . . . . . . . 109
7.1.4 Scaffolding . . . . . . . . . . . . . . . . . . . . . . . . . 112
7.1.5 Running Time and Termination . . . . . . . . . . . . . 113
7.2 From Local Rules to Desired Configuration . . . . . . . . . . . 113
7.2.1 Vector Gradient . . . . . . . . . . . . . . . . . . . . . . 114
13
7.3
7.4
7.5
7.6
7.2.2 The Connection Problem . . . .
Simulated System . . . . . . . . . . . .
7.3.1 The Module . . . . . . . . . . .
7.3.2 The Simulation . . . . . . . . .
7.3.3 Motion Constraints . . . . . . .
7.3.4 Maintaining the Move Invariant
Experiments . . . . . . . . . . . . . . .
Discussion & Future Directions . . . .
Conclusion . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
116
117
118
118
118
119
120
125
131
8 Conclusion
133
A Statistics
147
14
Chapter 1
Emergent Control of
Self-Reconfigurable Robots
1.1
The Grand Vision of Robotics
According to Buddhist teaching, humans have since the beginning of our time
worked to achieve happiness and reduce suffering. One of the newest tools in
this endeavour is robotics which until now mainly has been used to reduce
suffering: the introduction of robots into mass production environments has
increased efficiency while moving workers away from dirty, dangerous, and
dull jobs.
The mass-production environment is still the primary application area
for robots today. However, in parallel, researchers are also starting to work
on the research problems which prevent robots from moving out of the massproduction environment and into real-world environments. The real-world
environments present a challenge to robots, because, as opposed to controlled
mass-production environments, they are unstructured, dynamic, complex
and often unknown a priori. The benefits of developing robots able to handle
these environments are tremendous, because the possible application areas
for robots will explode. Robots can be introduced to handle dirty, dangerous,
and dull jobs in the real world. This might bring another revolution in the
primary sector, but also in more novel applications such as demining, search
and rescue, planetary exploration, etc. These applications are all along the
lines of reducing suffering, but applications that increase happiness might
also be possible. Edutainment robotics is one of the emerging areas here.
15
CHAPTER 1. EMERGENT CONTROL
1.2
Adaptive Robots
The research challenges involved in moving robots into real-world environments and applications are formidable and largely unsolved. Traditionally,
robots used the sense-think-act cycle of control. The idea was to map sensor
input onto an internal representation of the environment. Using this representation an appropriate action was then planned and finally executed. This
approach was suitable for the simple, static, known, and structured massproduction environments, but had problems with real world environments
at many levels. It was hard to keep the internal model synchronized with
the real world using imperfect, noisy sensors. The planning problem in the
internal model turned out to be more difficult than expected. Even if the
planning was successful and the resulting actions were executed, the result
was not always as planned, because the environment had changed while the
robot was thinking. This line of research is still pursued and the hope is that
the problems will disappear with improved sensor technology and increased
computation power.
Brooks took the consequence of these problems seriously and said: Let
the world be its own model and introduced the subsumption architecture in
(Brooks, 1986), which later matured into behaviour-based robotics as we
know it today (Arkin, 1998; Matarić, 1997). This breakthrough introduced
a new way of structuring the control systems of robots. A behavior-based
control system is composed of many task achieving behaviours. Instead of
mapping sensor input onto an internal representation, simple calculations
were performed to figure out whether a specific response to the environment
is needed. Suddenly, there was significant progress in real-world robotics.
Robots were developed that were capable of obstacle avoidance, exploring,
etc. The notion was that the key to solve real world problems was a matter
of correctly structuring the control system.
Now, seventeen years later, this does not seem to be the only problem,
because little progress has been made since the first behaviour-based robots.
Recently, new ideas started to enter the field of robotics from the area of
embodied artificial intelligence (Pfeifer and Scheier, 1999). The idea is that
in order to make real-world robots we cannot study control systems in isolation. We also have to take their physical embodiment seriously, because
there is a strong interaction between morphology and control. Studying this
interaction, in order to take advantage of it, is difficult, because working with
morphology and hardware is cumbersome and time-consuming.
16
1.3. SELF-RECONFIGURABLE ROBOTS
1.3
Self-Reconfigurable Robots
Reconfigurable robots are robots built from many independent modules.
Each module has actuators, sensors, processing power, memory, and means
of communicating and connecting to neighbors. If a reconfigurable robot is
autonomously able to change the way these modules are connected, the robot
is a self-reconfigurable robot. Through reconfiguration of their modules, selfreconfigurable robots can change their shape and adapt to the specific taskenvironment. Therefore, self-reconfigurable robots hold the promise to be
a powerful robotic platform which enables us to explore the interaction between morphology and control. Insight gained from this process might enable
us to develop robots suited for real world task-environments.
Self-reconfigurable robots are related to multi-robot systems and swarm
robotics in the sense that these systems also consist of groups of more or less
independent robots. The difference is that in multi-robot systems and swarm
robotics the robots do not interact physically. In self-reconfigurable robots,
on the other hand the modules are physically coupled.
Amorphous computing systems (Abelson et al., 2000) are built from a
massive number of small elements which are able to communicate locally,
the communication range being much smaller than the size of the system. In
these computing systems, the elements do not move. However, the idea of
building a complex system from many simpler parts is shared.
Another approach to shape-changing robots is to use deformable sheets.
These sheets are built from many small elements, which can exert forces
locally on the sheet, and by doing this in a specific way the sheet can globally
fold into different shapes.
Self-reconfigurable robots can be divided into two classes: chain-type and
lattice-type systems. In chain-type systems the modules are connected in
chains, which possibly can contain loops. In lattice-type systems modules
are organized in a lattice structure similar to atoms in a crystal.
Self-reconfigurable robots have characteristics which make them interesting in their own right, because these characteristics might push the limit
for which kind of task-environments are suitable for robots. The following
characteristics have been stressed in the literature.
• Versatility. The modules can be combined in different ways making
the same robotic system able to perform a wide range of tasks (Murata
et al., 1998).
• Adaptability. While the self-reconfigurable robot performs its task it
can change its physical shape to adapt to changes in the environment
(Shen et al., 2000a).
17
CHAPTER 1. EMERGENT CONTROL
• Robustness. Self-reconfigurable robots are made from many identical
modules and therefore if a module fails it can be replaced by another
(Murata et al., 1994; Yim et al., 2000a).
• Scale Extensibility. The size of the robot system can be increased
or decreased by adding or removing modules (Tomita et al., 1999;
Kurokawa et al., 2000).
• Cheap production. When the final design for the basic module has
been obtained it can be mass produced, thereby keeping the cost of
an individual module low compared to its complexity. (Murata et al.,
1994; Murata et al., 1998; Yim et al., 2000a).
Self-reconfigurable robots can solve the same tasks as traditional robots,
but as Yim et al point out, it is probably not cost-effective to use a selfreconfigurable robot unless its unique functionalities are needed (Yim et al.,
2000a). The versatility of these robots make them suitable in scenarios where
the robots have to handle a range of tasks. The robots can also handle tasks
in unknown or dynamic environments, because they are able to adapt to
these environments. In tasks where robustness is of importance it might be
desirable to use self-reconfigurable robots. Finally, their scale-extensibility
means that the size of the robot can be adjusted to the size of the problem.
Even though real applications for self-reconfigurable robots still are to
be seen, a number of specific applications have been envisioned (Shen et al.,
2000a; Murata et al., 1998; Yim et al., 2000a): fire fighting, search and
rescue after an earthquake, battlefield reconnaissance, planetary exploration,
undersea mining, and space structure building. Other possible applications
include entertainment and service robotics.
1.4
Metrics
Realizing these tasks is beyond the current state-of-the-art, but currently
researchers are working toward realizing the potential of self-reconfigurable
robots. In order to make systematic progress, we need to evaluate progress
by using metrics and evaluation criteria, which can guide research in the
direction of realizing the full potential of self-reconfigurable robots.
The performance of a self-reconfigurable robot is a combination of the performance of the hardware and the performance of the software. Here we state
the metrics independently for the software making it possible to compare
control systems independent of the hardware on which they run. The metrics below are directly derived from the characteristics of self-reconfigurable
robots and the task-environments we envision for them.
18
1.5. CONTROL SYSTEMS FOR SELF-RECONFIGURABLE ROBOTS
Robustness. The control algorithm should be robust to module failure and
communication errors.
Adaptability. The control system should exploit sensor input to adapt the
robot to the environment.
Versatility. The control system should enable the robot to perform many
different tasks.
Scale Extensibility. The control system should allow for changes in the
number of modules.
Environment assumptions. The control system should make as few assumptions about the environment as possible.
Scalability. The control system should be able to handle systems consisting
of many modules.
Minimalism. A simpler solution to a control problem is preferred, because
it may make it possible to make more, cheaper, and miniaturized modules.
Systematicness. The control method should be systematic in the sense
that given a control problem its solution can be found systematically.
Alternative Hardware. Since the hardware of self-reconfigurable robots
is under constant development, it is important that algorithms can be
applied to a class of hardware platforms and are not tied to a specific
one.
1.5
Control Systems for Self-Reconfigurable
Robots
The proposed control systems for self-reconfigurable robots can be divided
into two main categories: centralized systems and distributed systems. In a
centralized system the modules of the robot are controlled by a centralized
host. In distributed systems a controller is running on each module. Distributed systems can be further sub-categorized into systems based on global
or local information. We refer to distributed control systems based on local
information as emergent control systems.
Centralized control systems are traditionally used to control robots, but
are not suitable for self-reconfigurable robots, the reason being that if changes
19
CHAPTER 1. EMERGENT CONTROL
occur in modules of the robot or the environment a time-consuming replanning process has to take place centrally before the robot can continue. Specifically, this means that centralized control systems do not handle the metrics
of robustness, adaptability, environment assumptions, and scale-extensibility
well. Furthermore, since the centralized host is responsible for controlling all
modules, it will, with an increasing number of modules, be overloaded. This
implies that the efficiency of the centralized system will drop and therefore
it does not scale with an increase in the number of modules.
Distributed control systems are a step forward compared to centralized
solutions. If global information is needed this has to be reliably communicated to the modules. This dependency makes systems dependent on global
information less robust. Furthermore, scalability might also be an issue, because modules in large systems might spend substantial amounts of time
waiting for global information to arrive.
Emergent control systems perform well on most criteria, because of the
local nature of the controllers. One exception is the question of systematicness. In emergent, control modules only interact locally and therefore it can
be difficult to find local rules which make the system converge toward the
desired global behaviour.
The control systems proposed so far are mainly used for either locomotion
or self-reconfiguration. Locomotion in lattice robots is achieved through a
cluster-flow mechanism based on emergent control where modules from the
back of the robot are moved to the front and through this motion produce
locomotion. In chain-type robots the robot does not change shape; instead
it locomotes using the actuators of the modules to produce locomotion gaits.
There exist no emergent control algorithms for the control of locomotion of
chain-type self-reconfigurable robots.
Self-reconfiguration algorithms exist for both chain-type and lattice-type
robots. Chain-type self-reconfiguration is quite well understood, at least
in theory, but this is not the case for lattice-type robots. In lattice-type
self-reconfiguration the use of centralized systems is problematic, because
the planning problem is computationally hard in addition to the general
problems of centralized systems already mentioned. Distributing the problem
does in some cases solve the scalability issue but if global information is used
robustness is still an issue. Emergent solutions do not have these problems
because they are not based on planning, but emergent solutions often have
other problems: emergent solutions are often not systematic, efficient, or
guaranteed to converge.
20
1.6. CONTRIBUTIONS
1.6
Contributions
The first main contribution is role-based control. Role-based control is the
first emergent control method for the control of locomotion of chain selfreconfigurable robots.
The most important contribution of role-based control is the notion of
local synchronization. In related work, synchronization is always achieved
by having a synchronization signal traveling through the entire robot before
each action. This is inefficient and reduces the robustness of the system,
because the synchronization signal might be lost. In role-based control, each
module just synchronizes with its neighbors. This, after a few periods of
locomotion, results in the entire system being synchronized with very limited
communication effort.
The second contribution of role-based control is the notion of delayed
synchronization. Since the system is synchronized over time, this might as
well be exploited to deliberately delay synchronization signals in a way that
makes sense with respect to the locomotion gait. For instance, in a quadruped
walking robot, modules being front left leg and rear left leg need to produce
identical action sequences except that they should be half a period apart.
This delay can be achieved by introducing the needed delay directly into the
synchronization mechanism.
These two contributions have had a big impact on how well the control
system performs on the metrics and, most importantly, how well the robot
performs in experiments. Furthermore, these two contributions have made
a small revolution in the research area and papers have now been published
where competing approaches incorporate these ideas into their framework.
Included in the work on role-based control is, to the best of our knowledge, the first attempt to use sensor feedback in the control of locomotion
of chain-type self-reconfigurable robots. This research effort was awarded
best philosophical paper at the Conference on the Simulation of Adaptive
Behavior 2002.
The second main contribution is in the area of emergent control of selfreconfiguration of lattice-based self-reconfigurable robots. In this area there
existed a limited number of approaches. However, as mentioned above, they
all have problems in terms of efficiency, systematicness, or convergence properties. The contribution is a previously unexplored combination of existing
ideas, which result in a system that addresses all these problems in one system. The result is achieved using a combination of cellular automata rules,
artificial chemical gradients, and local mutual exclusion mechanisms.
Overall these contributions represent a significant step forward in the
control of self-reconfigurable robots.
21
CHAPTER 1. EMERGENT CONTROL
1.7
Structure
The thesis is structured as follows: in Chapter 2 we will give an overview
of self-reconfigurable robots which have been realized in hardware. This will
give the reader an appreciation of the variety of hardware platforms and will
lay the foundation for the discussion on which algorithms are suitable for
which types of robots. In Chapter 3 we provide a taxonomy of control systems and introduce metrics to evaluate control systems. At this abstract level
we discuss which classes of control methods are suitable for self-reconfigurable
robots. In Chapter 4 we present an overview of the previously proposed algorithms for control of locomotion. We evaluate these control systems using
the metrics and point out limitations and shortcomings of this related work.
Motivated by this discussion we will in Chapter 5 describe how our contribution, role-based control, complements the previously proposed methods. We
will through experiments and a metric-based discussion describe how rolebased control is an improvement over existing methods. In Chapter 6, we
look at self-reconfiguration algorithms proposed in the literature. We will
again discuss these methods using the metrics we have developed and point
out shortcomings and potentially useful ideas. In Chapter 7, we will combine the identified ideas into a working system and discuss how this method
complements and improves upon existing methods. Finally, in Chapter 8, we
summarize the thesis and make a conclusion.
22
Chapter 2
Physical Realizations of
Self-Reconfigurable Robots
In order to realize the potential of self-reconfigurable robots progress has to
be made both in hardware and control. This thesis is mainly focused on the
latter, but in this chapter we take a brief look at the physical realization of
self-reconfigurable robots. Designing modules for self-reconfigurable robots
is a significant engineering challenge, because the design space is highly constrained. This means that the hardware rarely meets all desirable requirements. Therefore, we, as control system developers, have to understand the
hardware in order to develop control systems which match the underlying
hardware.
In this chapter we present a brief overview of existing self-reconfigurable
robot prototypes and classify them based on a taxonomy which is also developed1 . We only consider self-reconfigurable robots where the modules
are in direct physical contact with each other. Following the overview, we
present some evaluation criteria which can be used to evaluate the prototypes. Finally, we evaluate the prototypes and point out shortcomings and
their implications for control.
2.1
A Taxonomy
The class hierarchy for modular robots is shown in figure 2.1. This hierarchy
defines the subclasses or is-a relationships of modular robots. Alternative
definitions are of course possible, but this hierarchy is useful in our context.
1
The taxonomy, the overview, and the summarizing Table 2.2, closely follow the survey
of self-reconfigurable robots by E.H. Østergaard (Østergaard, 2002).
23
CHAPTER 2. PHYSICAL REALIZATIONS
Robots
Modular Robots
Reconfigurable Modular Robots
Dynamically Reconfigurable
Modular Robots
Self−reconfigurable Robots
Figure 2.1: A Taxonomy for Modular Robots
2.1.1
Robots
Avoiding a lengthy philosophical discussion about what a robot is, we define
a robot as an artificial entity physically interacting with the real world.
2.1.2
Modular Robots
A modular robot is a robot which consists of several modules. Modular
robots have the potential to be easier to maintain and repair. If a module
breaks it can be identified and replaced in a relatively short time, whereas in
non-modular robots you might have to replace the entire robot.
2.1.3
Reconfigurable Modular Robots
The modules of a reconfigurable modular robot are independent and to a
high degree homogeneous. The reconfigurable modular robot is assumed to
have a fixed shape at run-time, but can off-line be reconfigured into different
shapes and sizes. The possibility of changing the shape and size of the robot
increases the robot’s versatility. However, this increased flexibility also adds
constraints to design of hardware and control software.
24
2.2. MORPHOLOGY
2.1.4
Dynamically Reconfigurable Modular Robots
Dynamically reconfigurable modular robots can be reconfigured at run-time.
This requires that the modules have functionality to detect detachments
and attachments of modules at run-time, and potentially to change behavior
depending on the new configuration. Designing the module morphology and
control software for such a system is challenging.
Dynamically reconfigurable modular robots can be further divided into
Dynamically User-Reconfigurable modular robots and Self-Reconfigurable
modular robots.
2.1.5
Self-Reconfigurable Robots
We define self-reconfigurable robots to be robots which satisfy the following
criteria:
• Modular: The robot is built from modules.
• Reconfigurable: The shape and size of the robot can be changed.
• Dynamically reconfigurable: The shape can be changed on-line.
• Self-reconfigurable: The robot can change its own shape.
2.2
Morphology
In the literature, several different metaphors have been used to describe different classes of self-reconfigurable robots. One division seems to be between
Discrete and Continuous robotic systems. PARC and MEL researchers
divide their systems into Chain-Types and Lattice-Types. On the other
hand Dartmouth College researchers talk about molecules in a Crystal, while
swarms of robots might be regarded as Fluid. In this text we use the terms
chain-type and lattice-type self-reconfigurable robot.
In chain-type self-reconfigurable robots a configuration consists of branching modules, chain modules, and end modules. A branching module is a
module with more than two modules connected, a chain module has two
connected modules, and an end module has one. Modules cannot change
position in the configuration on their own. Self-reconfiguration is achieved in
four ways. 1) A chain of modules can create branching modules by connecting one of its end modules somewhere on the chain itself. 2) Chain modules
can be created by connecting two end modules. 3) Chain modules can also be
created by removing modules from a branching module. 3) An end module
25
CHAPTER 2. PHYSICAL REALIZATIONS
can be created by splitting a chain. A self-reconfiguration sequence consists
of a sequence of these four basic steps.
Lattice-type self-reconfigurable robots change configuration by having
modules move around in the lattice only requiring help from neighbouring
modules. The self-reconfiguration process is then composed of a sequence of
moves of individual modules until the desired configuration is achieved.
The distinction is useful, because these two classes of robots are sufficiently different to require different control strategies. The following two sections list a number of existing self-reconfigurable robot prototypes. The first
section presents three chain-type systems; the second presents ten latticetype systems.
2.3
Chain-Type Systems
The systems are sorted by increasing complexity.
2.3.1
Polypod
The Polypod robot, shown in Figure 2.2, was developed by M. Yim while at
Stanford University (Yim, 1994b; Yim, 1994a). The Polypod consists of two
types of module: segment and node. A segment has two connection plates
at opposite ends and two degrees of freedom . The node modules have no
degrees of freedom, but six connection plates and contain a battery.
Figure 2.2: A Polypod segment module (left). A Polypod node module (right).
2.3.2
CONRO
A CONRO module, its morphology, and the CONRO modules connected to
form a hexapod are shown in Figure 2.3. The CONRO modules have been
developed at USC/ISI (Castano et al., 2000; Khoshnevis et al., 2001). The
modules are roughly shaped as rectangular boxes measuring 10cm x 4.5cm
26
2.3. CHAIN-TYPE SYSTEMS
Figure 2.3: A close-up of a CONRO module (top). A CAD image of a
CONRO module (left). A hexapod built from CONRO modules (right). (USC
Information Sciences Institute.)
x 4.5cm and weigh 100grams. The modules have a female connector at one
end and three male connectors located at the other. Because each module
only has one female connector, the graph representing the configuration of the
robot can have at most one cycle. Each connector has an infra-red transmitter
and receiver used for local communication and sensing. The modules have
two controllable degrees of freedom: pitch (up and down) and yaw (side to
side). Processing is taken care of by an onboard Basic Stamp 2 processor.
The modules have onboard batteries, but these do not supply enough power
for most experiments and therefore the modules are powered through cables.
The CONRO (CONfigurable RObot) self-reconfigurable robot is the robot
we will use for some of the experiments reported in this thesis.
2.3.3
Polybot
The Polybot, shown in Figure 2.4, is a more advanced version of the Polypod
(Yim et al., 2000a).
27
CHAPTER 2. PHYSICAL REALIZATIONS
Figure 2.4: A CAD image of Polybot G2 (left). Polybot G2 in a loop structure
(right).
Figure 2.5: The mechanism of the Crystalline robot (left). Crystalline real
hardware (right).
2.4
Lattice-Type Systems
The systems are sorted from 2D to 3D and roughly sorted by increasing
complexity.
2.4.1
Metamorphic Robot
The “Metamorphic robot” system, from The Johns Hopkins University (JHU)
(Chirikjian, 1994), is a 2D system composed of hexagonal modules, shown in
figure 2.7.
2.4.2
Crystalline Robot
The Crystalline robot, developed at Dartmouth College (Rus and Vona,
2001), takes inspiration from the atom/molecule metaphor. A model “atom”
and its hardware are shown in Figure 2.5. Using these atoms, molecules can
self-reconfigure in 2D as shown in Figure 2.6.
28
2.4. LATTICE-TYPE SYSTEMS
Figure 2.6: Motion of Crystalline robots
Figure 2.7: Picture of three Fracta robots (left). Two metamorphic robot
modules from JHU (right). Each module has three actuated degrees of freedom.
2.4.3
Fractum
Fractum, from MEL, is a 2D system (Murata et al., 1994). Three connected
units are shown in Figure 2.7. Fracta form hexagon-like structures.
2.4.4
Micro Unit
The “Micro unit” from MEL focuses on miniaturization by using shape memory alloy for both actuation and attachments (Yoshida et al., 2002). A sketch
of the system can be seen in Figure 2.8, and Figure 2.9 shows pictures of the
hardware.
Figure 2.8: The Micro unit design
29
CHAPTER 2. PHYSICAL REALIZATIONS
Figure 2.9: The Micro unit (left). Micro units in a structure (right).
Figure 2.10: RIKEN Vertical modules (left). RIKEN Vertical modules in a
stair-structure (right).
2.4.5
RIKEN Vertical
The “RIKEN Vertical” system, from the Institute of Physical and Chemical
Research (RIKEN) (Hosokawa et al., 1998), is a 2D system in the vertical plane. Modules have two degrees of freedom, one to control the extension/extraction of the arm, and one to rotate the arm. In Figure 2.10 is shown
a sketch of the module and the real hardware building a stair-structure to
climb a wall. The bonding faces of each cube are covered with a magnetic
sheet.
2.4.6
Telecube
The Telecube from PARC (Suh et al., 2002), shown in figure 2.11, is a 3D
version of the crystalline robot mentioned above. The Telecube uses shifting
permanent magnets for attachment.
30
2.4. LATTICE-TYPE SYSTEMS
Figure 2.11: The Telecube casing (left). CAD figure of the Telecube in expanded state (right).
Figure 2.12: The MEL 3D unit (left). A structure made from MEL 3D
units(right).
2.4.7
MEL 3D Unit
The MEL 3D unit is developed at MEL (Murata et al., 2000). A module and
the structures that these modules can create are shown in Figure 2.12. Two
real hardware modules are shown in Figure 2.13.
2.4.8
Robotic Molecule
The Robotic Molecule system (Kotay et al., 1998) from Dartmouth College
is made from “atoms” as shown in Figure 2.14. The molecules exist in two
Figure 2.13: Picture of two MEL 3D units
31
CHAPTER 2. PHYSICAL REALIZATIONS
Figure 2.14: The Robotic Molecule
Figure 2.15: Robotic Molecule structure (left).
Molecule hardware (right).
Structure with Robotic
versions, one with all female connectors and one with all male connectors.
Problems with connectors of the same gender trying to connect to each other
are avoided since Molecules partition 3D to the effect that there are two
distinct “flavors” of Molecules, and each flavor can only connect to the other
2
. In Figure 2.15 two structures are shown built from simulated and real
modules.
2.4.9
MTRAN
MTRAN (Modular Transformer) (Murata et al., 2000), by MEL, uses some
of the same ideas to avoid same-gender connector clashes as the Robotic
Molecule mentioned above. It uses homogeneous modules, one of which is
shown in Figure 2.16. The modules have two degrees of freedom, and three
connectors at each end. One end is all female, and the other all male.
2.4.10
I-Cubes
The I-Cubes project (Ünsal and Khosla, 2000), from Carnegie Mellon University, is a bipartite system consisting of cubes, which are passive, and links,
which are active. One link and one cube are shown top left in Figure 2.17.
The links have two male connectors, and can move the cubes around by
attaching to them, as shown to the right in Figure 2.17.
2
Citation from web page:
http://www.cs.dartmouth.edu/~
robotlab/robotlab/robots/molecule/version3.html
32
2.4. LATTICE-TYPE SYSTEMS
Figure 2.16: An MTRAN unit (left). The inside of a MTRAN unit (right).
Robot
USC/ISI, CONRO
Stanford, PolyPod
CPU on-board
power on-board
sensors used for
Communication
Figure 2.17: An I-Cube link with a cube (left). I-Cubes motion with four links
and four cubes (right).
yes
yes
yes
no
inter-unit optical
bus
PARC, PolyBot
yes
no
JHU, Metamorphic
Dartmouth, Crystalline
MEL, fractum
MEL, Micro-unit
yes1
yes
yes
yes
no
yes
no
no
docking aid
force/torque
joint position
joint position
docking aid
n/a
joint position
none
none
CANbus
n/a
inter-unit optical
inter-unit optical
inter-unit electrical &
serial w. host
radio w. host
inter-unit optical
serial w. host
serial bus with IDs2
serial w. host
serial w. host
RIKEN, vertical
no
yes none
PARC, Telecube3
n/a n/a docking
MEL, 3D-Unit
no
no joint position
1
MEL, MTRAN
yes no none
Dartmouth, Molecule
yes1 no not reported
CMU, I-Cubes
yes1 yes 33joint position
1 But controlled off-board.
2 Local communication under development.
3 Only information on mechanical prototypes has been published.
Table 2.1: Characteristics of self-reconfigurable robotic systems.
CHAPTER 2. PHYSICAL REALIZATIONS
2.5
Summary
The characteristics of the self-reconfigurable robots surveyed here are summarized in Tables 2.1 and 2.2. Table 2.1 summarizes the electrical characteristics
and Table 2.2 summarizes the mechanical characteristics.
2.6
Evaluation Criteria for Hardware
In Tables 2.1 and 2.2 we have summarized the characteristics of the physically
realized self-reconfigurable robots. In Table 2.3 we have rated the prototypes
of self-reconfigurable robots based on the evaluation criteria given below. The
evaluation is subjective and cannot be used to compare individual systems;
rather we can talk about general trends.
Mobility. Number of modules needed to achieve autonomy; 2D/3D speed;
turning rate; energy consumption
Reconfigurability. 2D/3D reconfiguration speed; energy consumption; motion constraints
Attachment Mechanism. Energy consumption for attachment, detachment, and maintaining connection; alignment precision needed to attach; reliability; strength; number of attachment points
Communication. Speed; reliability; energy consumption
Computational power. Processor speed, memory, energy consumption
Sensory system. Richness of sensor input from the external and the internal environment
Actuator system. Degrees of freedom; power; mechanical complexity
Energy consumption. Independence of external power sources; battery
life
Physical properties. Size; weight; mechanical complexity
Manufacturing feasibility. Price and time to produce
Most of these criteria are self-explanatory except the motion constraint,
a sub-criterion of reconfigurability. This criterion is a measure of how easy
it is for a module to move from one given position in the configuration to
another.
34
Morphology
Attachment
method
Actuation
Connectors
(Actuated)
System
Actuat. DoF.
Dimension
2.6. EVALUATION CRITERIA FOR HARDWARE
⊥ and
k
Mech., SMA
3D 0/2 6/2
- / ⊥
or k
Mech.
PARC, Polybot
3D 1
2 (2)
⊥
Mech., SMA
JHU, Metamorphic
2D 3
6 (3)
k and
⊥
Mech.
Dartmouth,
Crystalline
2D 1
4 (2)
k
Mech.
MEL,
tum
Frac-
2D 0
3 (3)
⊥
Electro
nets
MEL, Microunit
2D 2
4 (2)
⊥
Mech.
RIKEN, Vertical
2D 2
1 (1)
⊥
Perm.
Mech.
PARC, Telecube
3D 1
6 (6)
k
Switching
Perm. Magn.
MEL,
Unit
3D 6
6 (6)
Mech.
MEL,
MTRAN
3D 2
6 (3)
⊥ or k
or Perm. Magn.;
SMA
Dartmouth,
Molecule
3D 4
10
(10)
or ⊥
Mech.
CMU,
Cubes
3D 3
2 (2)
and
k
Mech.
USC/ISI,
CONRO
3D 2
Stanford,
Polypod
3D-
I-
4 (1)
⊥: Perpendicular to direction of connection
k: Parallel to direction of connection
: Rotation around direction of connection
Mag-
Mag.;
: Male connector
: Female connector
: Unisex or hermaphroditic connector
35
Table 2.2: Characteristics of self-reconfigurable robotic systems.
Reconfigurability
Attachments
Communication
CPU power
Sensory System
Actuation System
Energy
Physical Properties
Manufacturing feasibility
Module
USC/ISI, CONRO
Stanford, Polypod
PARC, Polybot
JHU, Metamorphic
Dartmouth, Crystalline
MEL, Fractum
MEL, Micro-unit
RIKEN, Vertical
PARC, Telecube
MEL, 3D unit
MEL, MTRAN
Dartmouth, Molecule
CMU, I-Cubes
Mobility
CHAPTER 2. PHYSICAL REALIZATIONS
3
3
3
1
1
1
1
2
1
1
3
2
2
1
1
1
1
2
2
2
1
3
2
2
2
2
1
1
2
1
2
2
2
2
2
2
2
2
2
1
2
3
1
3
2
3
1
3
1
3
1
1
1
1
3
1
3
2
2
1
1
3
3
2
1
1
1
1
1
1
1
1
1
1
1
1
2
3
3
1
2
1
2
2
2
2
3
2
2
1
2
3
1
3
1
1
2
1
3
1
2
3
3
2
3
2
2
3
2
2
1
3
2
2
3
3
3
3
3
3
2
3
1
3
2
2
2
Table 2.3: This table shows how the physical realizations perform on the
evaluation criteria. The systems are rated from 1 to 3 where 1 is worst and
3 is best.
2.7
2.7.1
Discussion
Lattice-Type and Chain-Type Robots
Lattice-type robots perform better on the reconfigurability criterion compared to chain-type robots. This can be seen by inspecting Table 2.3. In
chain-type systems a chain of modules has to bend and dock with the chain
itself. This docking process involves several modules and is difficult to control as described in (Shen and Will, 2001; Yim et al., 2002). The advantage
of lattice-type systems is that often only a few modules are involved in the
self-reconfiguration process. However, even though lattice-type systems perform better than chain-type systems on the reconfigurability criterion they
do not perform well. This is maybe surprising, but is due to the difficulty of
36
2.7. DISCUSSION
making an attachment mechanism. One of the most successful attempts is
the MTRAN system. Other promising systems include the Telecube, the
Molecule, and the I-Cubes, but not enough modules have been built to
evaluate these systems at a larger scale. The remaining systems are twodimensional, which makes self-reconfiguration easier, because gravity can be
ignored and the third dimension is not limited in size.
Chain-type self-reconfigurable robots have a higher degree of mobility
than lattice-type systems. The reason is that the degrees of freedom of chaintype robots often are less constrained than those of lattice-type systems. If
we look at the difference between chain-type and lattice-type system we can
see that chain-type self-reconfigurable robots are designed for fixed-shape
locomotion and an occasional self-reconfiguration. Lattice-type robots, on
the other hand, are designed mainly for self-reconfiguration. One exception
is the MTRAN system which is a hybrid of chain-type and lattice-type.
This fundamental difference between chain-type and lattice-type systems
has resulted in two different classes of algorithms. This will also be reflected
later in this thesis where we have developed locomotion algorithms for chaintype systems and self-reconfiguration algorithms for lattice-type systems.
2.7.2
Sensors and Self-Reconfigurable Robots
In the introduction we mentioned that adaptability is one of the advantages
of self-reconfigurable robots. However, this ability has to be supported by
the sensory system of the robot. If the robot is not equipped with sensors
to detect changes in the environment it cannot adapt. Unfortunately, as we
can see in Table 2.3, none of the self-reconfigurable robots has a rich sensory
system. What the sensors are used for is described in more detail in Table
2.1. Here it is obvious that sensors are used to monitor the state of the robot
and not the environment. This is acceptable in this early phase, because
researchers are concerned with studying the internal control mechanisms of
the self-reconfigurable robots. However, in the long term, external sensor
input has to be incorporated. A risk is that if algorithms are developed
without incorporating sensor feedback from the beginning it might be difficult
to introduce later. This, in the end, might result in algorithms which are not
suited for real environments and thus applications.
2.7.3
Implications for Control
None of the self-reconfigurable robots designed so far perform well on all
these criteria, rather the robots represent different trade-offs between the
constraints. These trade-offs have been necessary in order to make it feasible
37
CHAPTER 2. PHYSICAL REALIZATIONS
to build the robot. This also implies that it is important for the control
system developer to understand the limitations of the hardware in order to
develop suitable control systems. For instance, on one hand we cannot normally assume a self-reconfiguration step is efficient and cheap in terms of
energy and time. On the other hand, we can often assume that communication and computation are comparably cheap. This means that in the control
system design we should strive to limit the number of self-reconfiguration
steps even if it requires significantly more communication or computation.
2.8
Conclusion
In this chapter we have introduced the distinction between chain-type and
lattice-type self-reconfigurable robots. We have given a brief survey of existing self-reconfigurable robots. Based on this survey we argue that latticetype robots are primarily built for reconfigurability and chain-type for mobility. Surprisingly, a high degree of reconfigurability is still not achieved by
lattice-type robots due to the complexity of the attachment mechanism or
prohibitive motion constraints.
We have also seen that little attention has been paid to the use of sensors
in self-reconfigurable robots. This is problematic, because sensors are needed
in order for self-reconfigurable robots to interact with the environment. This
interaction is crucial to real world task-environments.
None of the surveyed robots represent an optimal solution with respect to
the evaluation criteria, but represent different trade-offs due to the difficulty
of designing self-reconfigurable robots. This has two implications from the
control point of view. First, we need to make the control system reflect the
trade-offs of the specific robot in order to use it efficiently. Second, we should
strive, through clever control system design, to reduce the number of hardware constraints in order to make it more feasible to build self-reconfigurable
robots.
38
Chapter 3
Control of Self-Reconfigurable
Robots
3.1
Taxonomy of Control Systems
Control systems for self-reconfigurable robots can be classified depending on
the relationship between the control system and the modules of the robot.
If modules are controlled by a monolithic controller in a one-to-many relationship, the control system is classified as a centralized control system.
A distributed control system, on the other hand, is spread out over many
controllers resulting in a many to many relationship between controllers and
modules. Distributed control systems can be further sub-classified depending
on the type of information on which they depend. If a distributed control
system depends on global information we classify the control system as a
distributed system based on global information. However, if the distributed
controllers only depend on local information we classify the control system as
a distributed control system based on local information. We also refer to this
class of control systems as control systems based on emergence or emergent
control systems.
3.1.1
Centralized Systems
In centralized control the modules of a self-reconfigurable robot are controlled
by a centralized host. Centralized control systems consist of two elements: a
planner and a motion controller.
The planner uses a model of the self-reconfigurable robot and possibly its
environment. In this model, the actions of the modules are planned off-line.
In some simple systems the plans are hand-coded.
39
CHAPTER 3. CONTROL OF SELF-RECONFIGURABLE ROBOTS
The centralized motion controller takes the generated plan and uses it to
control the modules of the robot. Motion controllers can also be either openloop or closed-loop. In open-loop control the controller trusts the plan and
executes it blindly. In closed-loop control the controller checks that the state
of the robot and the environment is consistent with the plan. If the plan is
inconsistent the motion controller may be able to handle the inconsistency.
Otherwise, the motion controller has to rely on the planner to generate a
new plan.
3.1.2
Distributed Systems Based on Global Information
In distributed control systems based on global information, the planning
process and the motion control are distributed in the system, often with
both components running on each module. These control systems work by
repeating two steps: first, the planner gathers global state information or
waits for global synchronization information; second, the controller uses this
information to select an action.
3.1.3
Emergent Systems
Emergent systems are distributed systems based on local information. The
idea of emergent systems is that, instead of relying on information about
the global state of the system, the control of each module depends only on
information available locally. The module uses this information to select its
actions in order to make a global solution emerge. These control systems are
reactive and do not contain a planner. Rather, they obtain local information
and immediately decide what action should be taken. In this way the actions
of the modules are decoupled from each other.
3.2
Metrics and Evaluation Criteria
In order to analyse and compare control algorithms we need a measure of
how well each of these self-reconfiguration algorithms performs. Some of the
metrics are derived from the advantages of self-reconfigurable robots. Others
are derived from the tasks we envision for these robots. We touched briefly
on this topic in Section 1.4, but here we will describe each of the metrics and
evaluation criteria in more detail.
40
3.2. METRICS AND EVALUATION CRITERIA
3.2.1
Robustness
An advantage of homogeneous self-reconfigurable robots is their robustness:
if a module fails it can be replaced by another module, because all modules
are physically identical. However, in order to realise this robustness it also
has to be supported by the control system. Therefore, it is desirable for the
control system to be able to handle the following failures.
An obvious element which can fail is a module. In fact, if we move
to larger and larger systems module failure will be more a norm than an
exception. Modules can fail in many ways: connectors to neighbours can be
stuck, motors can fail, the CPU can fail, sensors can fail, and so on. It is
difficult to take all these failures into account at the algorithmic level. What
we can assume is that a lower layer of the control system detects all these
errors and switches the module off if a critical error is encountered. If we use
this assumption, module failure always results in an unresponsive (or dead)
module. The question of how robust the system is now becomes a question
of how many module failures the algorithm can handle. In order to answer
this question we can use an experimental approach that shows how efficiency
drops with the number of malfunctioning modules.
Another cause of failure is communication errors. We do not mean a
complete breakdown of communication, because this would be a module failure, but rather that with a probability communication messages will be lost
in transit. The algorithm’s robustness to these errors can be analysed in a
similar way as the algorithm’s robustness to module failure.
3.2.2
Adaptability
Adaptability is also one of the main claims of self-reconfigurable robots: the
robot can, while solving a task, adapt its shape to fit the task-environment.
This means that the control system somehow has to be able to incorporate
sensor input and map it into a useful behaviour of the self-reconfigurable
robot. Adaptability is difficult to measure, but as a minimum it can be
demonstrated how sensor input can be incorporated into the control system.
3.2.3
Versatility
Another advantage of self-reconfigurable robots is their versatility: the property that the same robotic platform can be used for many different tasks.
This means that the control system should be useful for a range of applications. The versatility can be evaluated by describing the class of problems
to which a control system can be applied. It should also be documented
41
CHAPTER 3. CONTROL OF SELF-RECONFIGURABLE ROBOTS
whether the algorithm can represent solutions to different tasks at the same
time and switch between them. Finally, it should be shown how the system
scales with the number of tasks.
3.2.4
Scale Extensibility
Another property of self-reconfigurable robot which we need to measure is
scale extensibility. That is, can the control algorithm automatically handle
addition and removal of modules? A related question is whether the algorithm can handle dynamic reconfiguration. This is a situation where first
modules are removed from the system and then later added somewhere else.
This can be documented by showing that the algorithm does indeed support
this property.
3.2.5
Environment Assumptions
Control systems can be compared based on the assumptions they make about
the environment. The axes along which an environment can be placed are:
the degree to which it is unknown, complex, dynamic, and unstructured.
The more unknown, complex, dynamic, and unstructured an environment a
control system can handle, the better the control system.
3.2.6
Scalability
In the long term we want to be able to control thousands or even millions
of modules. For this to be possible, we need to make sure that the control algorithms we propose can control systems of these sizes. We call this
property the scalability of the control system. A measure of this is experiments showing how the efficiency of the system correlates with the number
of modules being controlled. How the efficiency is measured depends on the
specific application and hardware platform. In order to be able to compare
across hardware platforms we should optimally specify efficiency in a hardware independent way. We can do this by using the standard rate-of-growth
notation from computational complexity theory (see (Papadimitriou, 1994)).
The constraint which prevents the algorithms from scaling is the hardware of the self-reconfigurable robot and potentially the centralized host.
Specifically, the processing power, communication bandwidth, and memory
are constraining resources. Therefore, we would say when comparing two algorithms that the one that uses the least of these resources while maintaining
the same level of performance is the better algorithm. The metrics we can
use for this again follow the standard complexity theory of computer science.
42
3.3. DISCUSSION
We can use the lower and upper bound notation O(n) and Ω(n) where the
number of modules n in the system is a measure of problem size. Sometimes
we cannot obtain these metrics directly from the algorithm and then we have
to resort to experimentation.
3.2.7
Minimalism
The idea of minimalism is that if a simple system achieves the same performance as a complex system the simple one is the better system. Minimalist
systems might be implemented directly in hardware or be useful if the system is miniaturized to micro-size, because when miniaturized the capabilities
of the hardware are even more limited. Minimalism is mostly a qualitative
measure, but a crude metric might be program size.
3.2.8
Systematicness
We are interested in developing control systems and methods which can be
applied systematically to a class of control problems. That is, given a human
understandable description of the problem how easily do we map this onto
the parameters of the control system? The trade-off here is to make an
algorithm which is general enough to cover a class of problems while not
being so general that it provides no guidance for implementing the solutions
to the problems.
3.2.9
Alternative Hardware
The hardware of self-reconfigurable robots is under constant development
and therefore it is desirable to make algorithms which can be applied to
different hardware platforms. This has to be balanced against the need to
exploit the specific hardware platform for which the control system is made.
3.3
Discussion
In this section we will discuss the different approaches to control at a high
level of abstraction. The idea is to hold the different classes of control systems
up against the metrics and evaluation criteria. Through this analysis we want
to find strengths and weaknesses of the different classes of control systems.
When we have described specific algorithms, this discussion will be used
as the foundation for further discussions. At the level of abstraction we
are considering, in this section, not all evaluation criteria and metrics are
useful. Therefore, we only apply the ones which add meaningful input to the
discussion.
43
CHAPTER 3. CONTROL OF SELF-RECONFIGURABLE ROBOTS
Before we start we would like to point out that a control system does
not have to perform well on all the metrics. In fact, few control systems do.
This is perfectly fine, because in some applications it is desirable to trade-off
robustness for versatility and for other applications it might be the other way
around. However, in order to realize the vision of a self-reconfigurable robot
we need to strive in the direction that the metrics point and then, of course,
be content when our intermediate results are useful.
3.3.1
Centralized Systems
Let us start with centralized control systems and apply the evaluation criterion of robustness. We can see that these algorithms do not show a high
degree of robustness: the system relies on the centralized host for planning
and control. If the centralized host fails, the entire system fails. If instead a
module fails, reprogramming or replanning is needed in order for the central
controller to continue to function. If modules fail rarely, this may not be
a problem. On the other hand, if modules fail often, resulting in frequent
replanning or reprogramming, this approach becomes inefficient. Communication errors can be handled by a communication protocol; however, there
may be situations where the robot gets out of range of the centralized host
(for instance by going down into long tunnels). Centralized solutions also
need to maintain a match between the state of the robot and its internal
model. The centralized host needs to be able to communicate with specific
modules, which most often involves some form of unique module identity for
instance IDs. This solves the problem, but if we mix the modules, it may
be difficult for the host to regenerate the model of the new configuration.
However, different shape-recognition algorithms have been proposed for this
purpose for lattice-based systems (Butler et al., 2002c; Butler et al., 2002a)
and for chain-based systems (Castano and Will, 2001).
Another question is the ability of a centralized controlled robot to adapt
to the environment. In this case we can imagine sensor information flowing
back to the host which processes it and replans accordingly. If all the sensor
information has to be propagated to the centralized host we might start to
require infeasible amounts of communication bandwidth creating a scalability
problem. A way around this is to have the modules filter the sensor data, but
this is difficult to do without some local notion of the task of the system. We
may also be able to limit the information flow between host and modules by
making assumptions about the environment, but this is not desirable either.
Scale extensibility is a problem if planing is costly, because with the
addition or removal of a module the system may have to go through a new
iteration of replanning.
44
3.3. DISCUSSION
Scalability is, in general, a problem for centralized systems, because the
centralized controller has to control all the modules of the system. In the scenario where the central host has to plan and control the actions of thousands
of modules scalability certainly will be a problem.
3.3.2
Distributed Control Based on Global Information
We now turn our attention to distributed control systems based on global information. Let us first consider the robustness of these systems. Distributed
control systems are a step forward in robustness compared to centralized
systems, because they do not rely on a centralized host. However, these
approaches still have robustness issues, because even though actions are selected locally they often depend on global state or synchronization information. This information is obtained through a process based on local message
passing where a module first sends out a request and then waits for replies.
This can create robustness problems if messages are lost or delayed.
Distributed systems are well equipped to adapt to the environment, because sensor input can be processed locally. Therefore, a reaction to the
sensor input can also be initiated locally. The same is true with respect to
scale extensibility, because this can be sensed locally and be handled appropriately.
Distributed systems are an improvement over centralized systems regarding scalability, because the load of planning and control can be distributed
among the modules. However, this distribution of planning and control also
increases the amount of communication in the system which in the end can
limit the scalability of the system.
3.3.3
Emergent Control
In emergent control, modules act based only on local information. This
creates a very robust system, because there is no central host. If a module
fails or a communication error occurs it is not critical to the survival of the
system. The system is also robust to dynamic reconfiguration, because the
system only relies on local information. Systems based on local control scale,
because only local information is used. Furthermore, sensor input can also
be incorporated at the local level. The main problem of local control is
the complexity involved in designing the local rules which make the desired
global behavior emerge. This means that emergent control methods are often
unsystematic.
45
CHAPTER 3. CONTROL OF SELF-RECONFIGURABLE ROBOTS
3.4
Conclusion
The discussion was focused on which classes of control systems hold the
promise to realize the vision of self-reconfigurable robots. In the introduction we motivated the need for self-reconfigurable robots. In that section we
concluded that self-reconfigurable robots are useful because of their robustness, versatility, scale extensibility, and adaptability. In order to realize this
vision it has to be supported by the hardware as well as the underlying control algorithms. In this chapter we have focused on control and introduced
evaluation criteria and metrics which will guide research in the direction of
the vision.
We have seen that the properties of emergent control systems to a high degree match the requirements of control systems for self-reconfigurable robots.
We have also seen that when we use centralized control or control based on
global information and try to make these control systems robust, scalable,
and adaptable, we hit a constraint. It becomes increasingly complex to maintain the global view of the system and this has serious implications for the
robustness and scalability of the system. On the other hand, if we approach
the problem using emergent control we can, in theory, get robust, scalable,
and adaptable systems. However, the trade-off is that it is difficult to maintain a globally coherent system using local rules. The goal of this thesis is to
take a step toward filling this gap. We want to design methods where, in a
systematic way, we move from the global view to the local rules of emergent
control.
46
Chapter 4
Locomotion Algorithms
In this chapter and the next we will look at locomotion in the context of
self-reconfigurable robots. Locomotion is defined in the Merriam-Webster
dictionary as:
Locomotion is an act or the power of moving from place to
place
Locomotion is interesting to study, because it is a fundamental ability
needed in a wide range of applications. Furthermore, self-reconfigurable
robots have an advantage when locomoting through an environment, because they can adapt their shape and change locomotion pattern to fit the
environment. This ability can, for instance, be important in a search and rescue scenario. In this scenario the robot might start in a loop-configuration in
order to achieve high speeds to get to the general area of interest fast. Upon
arrival, the robot right reconfigure into a snake configuration and make a
careful search of the area.
In this chapter, we will first present a taxonomy of locomotion algorithms
for self-reconfigurable robots. We will then survey locomotion algorithms
proposed in literature. Finally, we will discuss these algorithms and through
this discussion motivate the need for role-based control that we will introduce
in the following chapter.
4.1
Taxonomy of Locomotion Algorithms
Locomotion of self-reconfigurable robots can be classified as either selfreconfiguration-based locomotion or fixed-shape locomotion.
In self-reconfiguration-based locomotion, locomotion is achieved through
self-reconfiguration. This type of locomotion is often referred to as clusterflow or water-flow locomotion. The idea is that modules from the back of
47
CHAPTER 4. LOCOMOTION ALGORITHMS
the robot move toward the front. This process is repeated and locomotion
is generated. This mode of locomotion is well suited for lattice-type selfreconfigurable robots.
In fixed-shape locomotion, locomotion is achieved by controlling the joints
of the modules. Locomotion through self-reconfiguration is a very inefficient
way of locomoting, because the locomotion patterns do not reuse momentum
and also the self-reconfiguration process itself requires energy. The alternative is to control the joints of the modules and produce locomotion patterns
inspired by animals. This approach has only been used with chain-type selfreconfigurable robots.
In the following we will divide our survey of locomotion algorithms into
these two categories.
4.2
Survey of Locomotion Algorithms
In the following we will give an overview of existing locomotion algorithms.
In the descriptions we will mention the self-reconfigurable robot used. The
description of the robot will be omitted here, but can be found in Sections
2.3 and 2.4.
4.2.1
Fixed-shape locomotion
Centralized Control
Yim uses gait control tables to control locomotion of the PolyPod selfreconfigurable robot (Yim, 1993; Yim, 1994b; Yim, 1994a). In order to
use gait control tables each module is equipped with simple basic modes.
These modes are able to make the module contract, expand, function as a
spring, etc. The centralized controller controls the transition between the
modes of the modules using a gait control table. Each column in this table
corresponds to the mode changes that a specific module in the configuration
goes through during each cycle of the locomotion pattern. In later work, gait
control tables are also used to control PolyBot (Yim et al., 2001a).
Distributed Systems Based on Global Information
Yim also suggests that gait control tables can be distributed by relying on
synchronized timers in every module (Yim, 1994b). The idea is that each
module gets its column of the gait control table and executes it closed-loop
based on the timers.
48
4.2. SURVEY OF LOCOMOTION ALGORITHMS
Shen, Salemi, and others propose to use artificial hormones to control the
CONRO self-reconfigurable robot. The idea is that a hormone can travel
through the modules of the robot and trigger actions and other hormones as
needed. In the context of locomotion artificial hormones are an extension to
Yim’s work in the sense that the hormones are used to provide synchronization between the modules in order to achieve consistent global locomotion.
In earlier versions of the system a hormone is propagated through the selfreconfigurable system to achieve synchronization (Shen et al., 2000a). In
later work the hormone is also propagated backward making all modules
synchronized before a new action is initiated (Shen et al., 2000b; Salemi
et al., 2001; Shen et al., 2002).
A similar approach is explored by Butler et al. using the Crystalline selfreconfigurable robot (Butler et al., 2002b). In their algorithm, a caterpillar or
inchworm locomotion gait is presented. The algorithm starts by having the
tail module contract. Then the next module in the chain is signaled and starts
contracting while the previous one expands again. This chain of contraction
and expansion travels all the way to the head of the robot. The head then
sends a message back to the tail to start a new series of contractions and
expansions. It is also shown how the robot can be split autonomously and
move in opposite directions. This approach is further explored and analysed
in (Butler et al., 2002a; Butler et al., 2003).
4.2.2
Cluster-Flow Locomotion
Centralized Control
Kurokawa et al. report some experiments with a simulation of the MTRAN
modules (Kurokawa et al., 2000). In this work the sequence of actions is
designed graphically in simulation and the resulting action sequence is then
output to a file. A centralized controller then uses this file to playback the
action sequence. Using this approach, they demonstrate cluster-flow over an
obstacle and fixed-shape walking.
Yoshida et al. use both a simulation of the MTRAN modules and the
physical modules (Yoshida et al., 2001a; Yoshida et al., 2001b). Their approach employs a two-level planner. The global planner plans paths for the
modules to travel from the tail of the robot to its head in order to make
the robot follow a specified three dimensional path. This global plan is then
passed to the motion scheme selector. The motion scheme selector selects
the motion scheme which results in the module following the plan given by
the global planner. The global planner outputs several candidate paths for
each module so the motion scheme selector can pick one that is feasible.
49
CHAPTER 4. LOCOMOTION ALGORITHMS
Distributed Systems Based on Global Information
Kubica et al. use the Telecubes (Kubica et al., 2001). They propose using
the mechanisms of seeds and gradients to control the system. The Telecubes
are assumed to know their initial position, know the goal position of the
robot, and as they move they keep track of their current position. Initially,
the modules form a chain shaped structure. The head (or seed) determines
the direction of growth. This direction is directly toward the goal. However,
if the straight path to the goal is blocked, the growth direction is turned left
until a direct path to the goal is clear.
Emergent Control
Hosokawa et al. use the Riken vertical modules (Hosokawa et al., 1998).
These modules are able to climb onto each other and are therefore well-suited
for cluster-flow. The approach is a cellular automata based approach where
a module decides to move based on its local configuration. It is shown how
these local rules can be used to build stair-like structures and disassemble
them again.
Butler et al. use simulated cubic modules sitting in a three dimensional
grid (Butler et al., 2001b). The modules are able to rotate around each other
and thus are suitable for cluster-flow locomotion. They propose using local
cellular automata rules to control the self-reconfigurable robot. They prove
that the robot can flow in one dimension across an unstructured, uneven
surface without getting into a deadlock. This work is extended to threedimensions in (Butler et al., 2002e). (Butler et al., 2002d) describe how
cellular-automata-based control can also be applied to the MTRAN, Fracta,
and other systems.
Lund et al use a simulation of the MTRAN modules (Lund et al., 2003).
Their implementation of cluster-flow is based on three behaviors: 1) get ready
for walking, 2) walking, 3) return to lattice. The MTRANs are configured
in a chain. The get-ready-for-walking behaviour is activated and creates a
micro-walker on the side of the chain. This triggers the walking behaviour
that makes the micro-walker move along the side of the robot. When the front
of the robot has been reached, the return to lattice behaviour is activated and
a new head is formed. Multiple walkers can be active at the same time. The
modules get a sense of their position in the configuration chain by using two
artificial chemical gradients 1 . The behaviours use only local information and
the synchronization problems are modeled using Petri nets (Petri, 1962).
1
This is referred to as a hormone, but its characteristics are more similar to the gradients
we describe later in this thesis.
50
4.3. DISCUSSION
4.3
Discussion
In this section we continue the general discussion from Section 3.3 where
we argued that emergent control is suited for control of self-reconfigurable
robots. We also pointed out that one of the challenges of emergent control is
to make it systematic. That is, in a systematic way to transform a humanunderstandable description of the problem to the local rules of emergent
control. We will argue through this discussion that these points are also
valid at the level of specific algorithms.
4.3.1
Lattice-Type
If we start by looking at the cluster-flow algorithms, these applications lend
themselves to local control rules, because of the local nature of the task.
However, in the MTRAN robot the physical constraints of movement of the
modules make emergent or even distributed control difficult. This is because self-reconfiguration is not a local process. It involves cooperation of
groups of modules. We see this in the hand-coded approach in (Kurokawa
et al., 2000) and the centralized planning approach in (Yoshida et al., 2001a;
Yoshida et al., 2001b). However, by making the locomotion problem local
— by only allowing locomotion in one dimension and making assumptions
about the starting configuration — Lund et al. showed that it is possible to
make emergent control for the MTRAN modules (Lund et al., 2003). If we
look at the other examples of emergent control, it is applied to robots with
few motion constraints (Hosokawa et al., 1998; Butler et al., 2001b; Butler
et al., 2002e; Butler et al., 2002d). These examples show that — in robots
with few motion constraints — local rules, which generate the desired global
behaviour, can relatively easily be found. In fact, in a few cases it can even be
proved that these local rules actually result in the wanted behaviour. However, in robots with many motion constraints it is difficult to apply emergent
control.
4.3.2
Chain-Type
Turning our attention to chain-type self-reconfigurable robots, we can see
that gait control tables represent centralized control. If we start by looking
at robustness we can see that if one of the synchronization signals from the
host is not received by a module that module may perform a wrong action.
Furthermore, module failure is not handled at any level and the whole system
may fail. Since the system is open-loop it is not adaptable and cannot be
extended at run-time. If modules are added, the gait control table has to be
51
CHAPTER 4. LOCOMOTION ALGORITHMS
extended. The control table has to be changed if the robot is reconfigured
into the same shape with the modules in different positions. The system
may have scalability issues, because of the dependence on the centralized
host. The approach, however, is quite minimalistic, but not systematic. It is
also suggested that each module has its own column of the gait control table
and executes the actions in the table using a timer. This makes the system
a distributed control system based on global information. This solves the
problem of scalability, but not the others.
Hormone-based control is a method which belongs to the class of distributed control based on global information. In the proposed implementation, the modules all depend on each other because a hormone is propagated
through the robot before each step. If a module fails, it will prevent the
hormone from being propagated and therefore the entire robot will come to
a halt. This means that instead of having a single point of failure, like the
centralized approach, this system has n points of failure. A hormone-based
system has a better chance of incorporating sensor information and can be
made scale extensible. The synchronization is performed before each step
and takes time O(n) where n is the number of modules. This slows down the
system considerably and may prevent it from scaling. These arguments also
hold for the cellular automata inspired approach pursued by (Butler et al.,
2002a; Butler et al., 2003).
There are no examples of emergent control for chain-type self-reconfigurable
robots. The reason may be that this task is more global by nature. The
whole robot has to act in a synchronized and coordinated way to produce
the desired locomotion pattern. This idea of making sure that the robot
is synchronized and coordinated globally shows in the work on locomotion.
This can be seen in the work on gait control tables, hormone-based systems,
and cellular-automata-inspired systems. If we want to make an implementation of fixed-configuration locomotion using emergent control we need to
implement local rules which make sure the right action is performed. This
problem is similar to the problem of cluster-flow. However, in addition we
also have to make local rules which ensure that the action is executed at the
right time. The problems of action selection and timing make the construction of local rules difficult, and it is even more difficult to come up with a
systematic way of doing this.
4.4
Conclusion
In this chapter we have looked at locomotion of self-reconfigurable robots. We
have identified two types of locomotion: cluster-flow and fixed-configuration
52
4.4. CONCLUSION
locomotion. We have given an overview of previously proposed locomotion
algorithms. We have pointed out that cluster-flow is easily interpreted as
a local problem and, therefore, that it is relatively easy to make local rules
which result in locomotion. The exception is in the systems whose motion
constraints make self-reconfiguration a non-local problem. We have argued
that fixed-configuration locomotion is a harder control problem. This is
because it is important that all modules in the system both pick the right
action and do it at the right time in order for the desired locomotion pattern
to emerge. This is also indicated by the fact that no local algorithms exist
for fixed-configuration locomotion of self-reconfigurable robots. Furthermore,
coming up with a systematic way to make these local rules is even more
difficult.
53
CHAPTER 4. LOCOMOTION ALGORITHMS
54
Chapter 5
Role-Based Control
In the previous chapter we mentioned that timing is important in control
of fixed-shape locomotion. This makes control of fixed-shape locomotion
a more difficult task compared to control of cluster-flow locomotion. That
timing is important, has led researchers in the field to assume that this implies
that all the modules of the robot should communicate at each time-step to
make sure the robot stays synchronized. Shen, Salemi, et al. let a hormone
travel through the system at each time-step to ensure that the system stays
synchronized (Shen et al., 2000a; Shen et al., 2000b; Salemi et al., 2001;
Shen et al., 2002). This slows down the robot and also has implications for
robustness, because the signal might be lost. Another solution has been to
have the modules rely on internal timers to get the timing right (Yim, 1993;
Yim, 1994b; Yim, 1994a; Yim et al., 2001a). This approach remove the
need to communicate, but does not solve the problems of adaptability and
robustness.
There is a middle path between these two approaches. The first step
toward realizing this is to allow the system to synchronize over time. If
modules keep track of time using local timers and from time to time synchronize their timers with connected modules, the entire system will eventually be synchronized. This assumes that modules can stay synchronized
without communicating for some time. This is achievable, because most processors are equipped with timers. These timers may be too imprecise to keep
modules synchronized infinitely, but are good enough to keep the modules
synchronized for a while.
In order to illustrate this point we made an experiment where four CONRO
modules are controlled by identical controllers. The controller makes one of
the module’s degrees of freedom perform an oscillation with period T=2.37sec.
We then started these modules at the same time and observed how their
synchronization degraded over time. Figure 5.1 shows how the standard de55
CHAPTER 5. ROLE-BASED CONTROL
0.14
Std. Dev. in fractions of a period
0.12
0.1
0.08
0.06
0.04
0.02
0
0
10
20
30
40
50
60
70
80
90
Time (Periods)
Figure 5.1: This graph shows how four modules performing the same movement lose synchronization over time. The modules started at the same time
making an oscillation with period T=2.37sec. The x-axis is the number of
periods. The y-axis is the standard deviation of the position of the modules
measured in fractions of a period. For instance, after 90 periods the modules
have drifted apart on average more than 1/10 of a period.
viation of the position of the modules increases over time. It can be seen how
often a synchronization signal is needed depends on the precision needed in
the system. For instance, it is questionable if a standard deviation of 1%
of a period has any impact on the locomotion pattern. If 1% drift can be
accepted we only need to synchronize the modules every 10 periods.
We can use one of the many algorithms for synchronizing clocks (see
(Ramanathan et al., 1990; Simons et al., 1990) for an overview) and achieve
increased efficiency because the local timer can be relied on for deciding when
to perform a new action. However, this is not the path we will follow here.
The reason is that having a global timer (through a clock synchronization
algorithm) does not help us in deciding which module should do what when.
The timer obtained this way can only help us if we know where a module
is located in the configuration (or sub-configuration), what action it should
perform, and when it should perform it.
Therefore we combine local synchronization, deliberate synchronization
delays, and the actions of the modules in a role. A role contains both information about actions and how they should be synchronized with neighbour
modules.
56
5.1. A ROLE
Yaw
North
West
East
Pitch
South
Figure 5.2: An abstract drawing of the CONRO module showing the compass
direction we have defined and the rotation axes of the motors.
5.1
A Role
First we will introduce some notation. The set of connectors of a module is
referred to as C. Each element in this set corresponds to a connector. One of
these elements is also contained in the singleton set of parent connectors CP .
The remaining connectors are defined to be child connectors CC = C \ CP .
Often we will use a subscript to refer to a set associated with a specific
module e.g. Cn which means the set of connectors of module n.
In the CONRO module we define the female connector pointing south (s)
to be the parent connector CP = {s}. The three male connectors pointing
east (e), west (w), north (n) are then the child connectors CC = {e, w, n}
(refer to Figure 5.2).
CP = {s}
CC = {e, w, n}
C = CP ∪ CC
(5.1)
(5.2)
(5.3)
A child module cm can only attach to a parent module pm by attaching
its parent connector ci ∈ CPcm to one of the parent’s child connectors cj ∈
CCpm . In the CONRO robot, this assumption always holds because of the
physical characteristics of the connectors. Furthermore, we will also assume
that the configuration contains no loops. This means that we have limited
ourselves to tree configurations. Having made these assumptions, we are
ready to define a role.
57
CHAPTER 5. ROLE-BASED CONTROL
Definition 1 (Role Definition) A role consists of three components. The
first component is a function A(t) that specifies the joint angles of a module
given an integer t ∈ [0 : T ], where T (the second component that needs to
be specified) is the period of the motion. The third component is a set of
delays D. A delay dc ∈ D specifies the delay between the child connected to
connector c ∈ CC and its parent module. That is, if the parent is at step
tparent the child is at tchild−c = (tparent − dc ) modulus T .
Below is shown, as an example, the caterpillar role which we will discus
in further detail below.
A(t) =
pitch(t) = 50◦ sin( 2π
t)
T
yaw(t) = 0
T
5
T = 180
dn =
5.2
Playing a Role
The algorithm each module uses for playing a role is outlined in Figure 5.3.
The algorithm starts by setting t = 0 and continues to the main loop. Here
the algorithm first checks if t is equal to a delay dc ∈ D. If t = dc a
synchronization signal is sent through the child connector c ∈ CC. If the
module has received a signal from its parent, t is reset. After that the joints
are moved to the position described by A(t). t is incremented unless a period
has been completed in which case t is reset. Finally, another iteration of the
loop is initiated.
5.3
Selecting a Role
In a tree configuration, it is restrictive if all modules have to play identical
roles. Therefore, we want modules to be able to play different roles. This
raises the question of role selection. How does a module decide which role to
play? In this section we introduce role selection based on information about
the local configuration and the roles being played by connected neighbouring
modules. In section 5.8 we will look at role selection based on sensor input.
The parameters for role-based control are now contained in a set of roles.
We need some mechanism to select between these roles. Which role to play
depends on the one currently being played, the local configuration, and the
58
5.3. SELECTING A ROLE
t=0
t=d i|di in D
Yes
Signal i
No
Yes
Signal
Rcv.?
No
t=0
Perform A(t)
t=(t+1) modulus T
Figure 5.3: Visualization of the role-playing part of the algorithm. See Section
5.2 for an explanation.
roles being played by neighbour modules. The local configuration of a module
is defined as the set of child connectors to which child modules are connected,
and the child connector of the parent to which the module is connected. It
is rare that role selection depends on all parameters. For instance, a module
may select its role based only on its local configuration.
In role-based control with role selection, role and configuration information is exchanged between parent and child as part of the synchronization
signal. This is reasonable, because it does not make sense for the module to
be synchronized before it knows which role to play. Figure 5.4 shows how
the role playing algorithm looks with the added role-selection mechanism.
One feature of this role-selection mechanism is that the role can be decided
as locally as possible. In some situations, it might be enough to decide which
role to play based on information about the parent. This is desirable because
this enables the system to adapt faster. However, it is also possible to make
the role depend on the global configuration and the module’s position in the
global configuration.
59
CHAPTER 5. ROLE-BASED CONTROL
r = <start role>
t = 0
while(1)
if (t=d(r)_1) then
<send message M(r,1) to child connector 1>
<update r>
endif
...
if (t=d(r)_n) then
<send message M(r,n) to child connector n>
<update r>
endif
if <message m received from parent connector> then
t=0
<update r based on m>
endif
<perform action A(r,t)>
t = (t+1) modulus T(r)
endwhile
Figure 5.4: The role-playing algorithm with role selection.
Theorem 1 In the CONRO robot the role-selection algorithm can be used to
specify a unique role for each module depending on its position in the global
configuration tree and the global configuration.
A simple way to do this is to represent the configuration as a directed
graph. A representation of the configuration tree can then be constructed
distributed as the representations of subtrees are combined and propagated
up toward the root module of the configuration (in role based control synchronization goes from root toward leaves, but a child can propagate information
to a parent in response to a synchronization signal). The root will in the
end have a representation of the entire configuration tree. The root can then
propagate this representation down into the configuration tree together with
a pointer which indicates the current module’s position in the representation. This means that each module can select which role to play based on
its position in the global configuration and the global configuration itself. 60
5.4. TIME COMPLEXITY OF ROLE PLAYING
5.4
Time Complexity of Role Playing
In this section we will look at the computational complexity of role playing.
In role-based control each module uses constant time each period to stay
synchronized with its neighbours. The trade-off to this is that it initially takes
time for the entire system to synchronize, because synchronization signals are
only sent once per period. Let’s analyse this in more detail.
A configuration tree can be described as a directed graph G = (V, E)
where V is a set of modules and the set E describes how the modules of
V are connected. E is a set of connections (ni , ci , nj , pj ) where ni , nj ∈ V ,
ci ∈ CC, and cp ∈ CP .
Definition 2 E c is defined to be the set of connections E with the directions
of the connections reversed:
E c = {(nj , pj , ni , ci )|(ni , ci , nj , pj ) ∈ E}
(5.4)
Definition 3 A path P (ni , nj ) ⊆ E∪E c ∧ni , nj ∈ V is defined as the shortest
sequence of edges leading from ni to nj .
Definition 4 A path P is complete C(P ) if it starts at the root of the configuration tree and ends at a leaf.
Definition 5 The length |P | of a path P is defined to be the sum of all the
delays which correspond to the connectors in the path:
|P | = Σdce − Σdcec |(ni , ce , nj , pj ) ∈ P ∩ E ∨ (ni , pi , nj , cec ) ∈ P ∩ E c (5.5)
Theorem 2 The time to synchronize a system in a given configuration G=(V,E)
is given as:
tsync = |P ||C(P ) ∧ ¬∃C(P 0 ) ∈ V : |P 0 | > |P |
(5.6)
Basically, the time to synchronize is the sum of the delays along the shortest path from the root module to the leaf which maximizes the sum of delays.
61
CHAPTER 5. ROLE-BASED CONTROL
5.5
Role-Based Control without Role Selection
In simple configurations, it is not always necessary to have multiple roles in
the system. This removes the need for role selection. In this section we will
present two single-role gaits: the caterpillar and the sidewinder.
5.5.1
The Caterpillar
As the first example of a locomotion pattern we will present a caterpillar-like
locomotion gait in the CONRO robot. We will demonstrate the properties of
the implementation in terms of robustness to loss of communication signals
and reconfiguration. Caterpillar like locomotion has in the context of selfreconfigurable robots previously been described in (Yim, 1993; Chirikjian
and Burdick, 1995; Shen et al., 2000a).
Implementation
We configured eight CONRO modules in a chain and downloaded a program
combining the caterpillar role described above and the role-playing algorithm
into each of them (the source code of the main loop is shown in Figure 5.5).
The first module of the chain is started using an external infra-red signal.
The first module starts its action sequence. After 1/5 of a period (dn ) a
synchronization signal is sent to the child module connected to the northern
child connector. If the signal is received the second module starts to move
and after another 1/5 of a period a synchronization signal is sent to the third
module and so on. When all modules have been started and are synchronized
to be 1/5 of a period apart, they produce a traveling sine wave resulting in
the caterpillar-like locomotion gait shown in Figure 5.6. The robot moves at
a speed of 2.9cm/second. We will refer to the robot in a chain configuration
playing the caterpillar role as the Caterpillar. In a Caterpillar consisting of
n modules the synchronization signal has to be propagated n − 1 time with
the delay dnorth . Using equation 5.6 we find that:
tsync = (n − 1)tnorth
(n − 1)T
=
5
(5.7)
(5.8)
The Caterpillar consists of eight modules and T = 180◦ = 2.37sec. This
implies that it takes tsync = 3.3sec for the caterpillar to synchronize initially.
62
5.5. ROLE-BASED CONTROL WITHOUT ROLE SELECTION
SignalChild:
if t=d then SignalChildOn
SignalChildOff:
low TX_Port
goto HandleSignalFromParent
’turns off the infra red diode
SignalChildOn:
high TX_Port
goto HandleSignalFromParent
’turns on the infra red diode
HandleSignalFromParent:
if IN14=0 then Move
t = 0
’checks if the infra red receiver
’is activated
Move:
pitch = 127+SIN(t*2*128/180)
pitch = ((t*3)/4)+20
pulsout PITCH_MOTOR,(pitch*3)+350
pulsout YAW_MOTOR,(125*3)+350
t=(t+1)//T
goto SignalChild
’pitch is calculated and scaled
’PWMs for motors are generated
’t is incremented
Figure 5.5: The source code for the main loop of the caterpillar controller.
The algorithm is described in Section 5.2.
Figure 5.6: The CONRO robot performing caterpillar like locomotion. The
cables only supply power. (USC Information Sciences Institute.)
63
CHAPTER 5. ROLE-BASED CONTROL
70
Movement time
Start time
60
Time (sec.)
50
40
30
20
10
0
0
10
20
30
40
50
60
70
Probability that synchronization fails (percent)
80
Figure 5.7: This figure shows how long it takes for the robot to start and
to move 87cm as a function of the chance of losing a synchronization signal. Each data point represents the average and standard deviation of ten
experiments.
Robustness to Loss of Communication Signal
In the first series of experiments we examine the robustness of the system
to communication errors. To do this we introduce artificial communication
errors by randomly deciding if a signal is sent or not. We did three separate
series of experiments where the chance of a signal being sent is respectively
25%, 50%, and 100%. We want to find out what impact these communication
errors have on the time it takes for the system to synchronize initially and
the locomotion speed of the robot.
The robot is started using an external infra-red signal and it is recorded
how long it takes for all modules to start. When all the modules have started
we record how long it takes for the robot to move a distance of 87cm (this
distance is chosen to fit the size of the experimentation arena). We repeated
these experiments ten times for each level of signal loss. The results of these
experiments can be seen in Figure 5.7.
It can be observed from Figure 5.7 that as the probability of signal loss
increases the start time increases. This was expected, because if a synchronization signal is lost it takes a full period before the next synchronization
signal is sent. However, the figure also shows that the locomotion time stays
constant. In fact, Student’s t-test shows at the 5% confidence level that the
hypothesis that the times can be assumed to equal in the three experiments
is accepted (see Appendix A for details). This extreme robustness to communication error is not surprising, because Figure 5.1 showed that the modules
64
5.5. ROLE-BASED CONTROL WITHOUT ROLE SELECTION
90
Movement time
80
Time (sec.)
70
60
50
40
30
1
2
3
4
5
6
Number of Modules
7
8
9
Figure 5.8: This figure shows how long it takes for the caterpillar to move
87cm as a function of the number of modules connected. The data points
for 4 and 8 modules represent the average and standard deviation of ten
experiments. The data point for 2 modules represents five experiments.
can stay synchronized for a significant number of periods before they drift so
much apart that the effect is measurable. In fact, the data shown in Figure
5.1 is produced by four unconnected modules playing the caterpillar role.
We made another series of experiments designed to show the scale extensibility and scalability of the algorithm. Particularly, we look at how the
performance of the system changes with the number of modules. We did
experiments with caterpillars made of 2, 4, and 8 modules. We measured
how long it took them to move 87cm. The results of these experiments are
visualized in Figure 5.8. The figure shows that even though the speed decreases with the number of modules the system still works. This is a very
interesting feature, because this is achieved without changing the controller.
The performance decreases, because the caterpillar role is designed to be used
by a chain of more than four modules. In order to produce efficient locomotion the caterpillar needs at least two contact points with the ground at all
times. In the caterpillar role the sine wave repeats itself after four modules.
This means that most of the time the chain with four modules only has one
contact point resulting in less than optimal speed.
5.5.2
The Sidewinder
We will now present an implementation of a gait similar to that of a Sidewinder
snake. This gait has been analysed in detail by Burdick et al. (Burdick et al.,
1995), but here we just use the intuition that if segments of the body moving
65
CHAPTER 5. ROLE-BASED CONTROL
Figure 5.9: The CONRO robot performing sidewinder snake locomotion. The
cables only supply power. (USC Information Sciences Institute.)
in one direction are lifted from the ground and segments moving in the other
touch the ground locomotion is produced. The sidewinder role is as follows.
A(t) =
pitch(t) = 20◦ cos( 2π
t)
T
2π
◦
yaw(t) = 50 sin( T t)
T
5
T = 180
dn =
When all the modules are connected in a chain and synchronized it looks
as shown in Figure 5.9. We refer to this as the Sidewinder. We recorded the
movement of the sidewinder using an overhead camera. We then recorded
the position of the modules every three seconds. The result of this analysis
can be seen in Figure 5.10. We repeated this experiment five times with
similar results. The Sidewinder moves at a speed of 6.7cm/second and has
the same synchronization characteristics as the Caterpillar.
5.6
Role-Based Control with Role Selection
In a more complex configuration it is restrictive only to have one role in the
system and therefore we need to introduce more roles and role selection. In
this section we will look at two examples of a complex locomotion gait, which
are quadruped and hexapod walking shown in Figure 5.11. We will also show
how two gaits can be represented in the same system and see that the system
can select between them depending on the configuration.
66
5.6. ROLE-BASED CONTROL WITH ROLE SELECTION
1.2
1.1
1
Meters
0.9
0.8
0.7
0.6
0.5
0.4
0.3
0.2
0.4
0.6
0.8
1
1.2
1.4
1.6
1.8
2
Meters
Figure 5.10: We recorded the locomotion of the sidewinder using an overhead
camera. This figure shows the position of the modules of the sidewinder
recorded every three seconds.
5.6.1
The Walkers
In order to verify the usability of the role-selection mechanism we implemented a walking gait in the CONRO self-reconfigurable robot. We configured the robot in a quadruped configuration.
Role Definitions
In the quadruped configuration three different roles are needed to make the
robot walk: spine, left leg, and right leg. In this section we will list the roles
and, in the following section, discuss how they were derived in a systematic
way. The spine role is shown below.
A(t, spine) =
pitch(t) = 0◦
t + π)
yaw(t) = 25◦ cos( 2π
T
T
4
2T
dn =
4
3T
dw =
4
T = 180
de =
67
CHAPTER 5. ROLE-BASED CONTROL
Figure 5.11: The CONRO robot configured as a quadruped and hexapod
walker. (USC Information Sciences Institute.)
68
5.6. ROLE-BASED CONTROL WITH ROLE SELECTION
The east legs play the east leg role below and the west legs play the
same role except t is replaced by 2π − t. This gives the same motion, but in
opposite directions.
A(t, east leg) =
pitch(t) = 35◦ cos( 2π
t) − 55◦
T
2π
◦
yaw(t) = 40 sin( T t)
T = 180
Calculation of Delays
The quadruped configuration is relatively simple, but it is getting difficult
to calculate the delays needed to make the locomotion pattern emerge. Fortunately, we can do this in a systematic way by setting up a number of
equations, which specifies the constraints from which we can calculate the
delays. In a quadruped walking robot the following motion constraints can
be observed:
1. The left front leg and the rear right should move in synchrony (or a
whole number of periods apart, which we will ignore unless needed in
this discussion).
2. The same goes for the right front leg and the rear left leg.
3. The two front legs should be half a period apart.
4. The two rear legs should be half a period apart.
5. The two left legs should move half a period apart.
6. The two right legs should move half a period apart.
From these constraints, which are easy to specify we can make the corresponding set of equations from which we can calculate delays. We label the
modules as shown in Figure 5.12: east–1, east–2, spine–1, spine–2, west–1,
west–2. We use definitions 3 and 5 to make the following equations.
69
CHAPTER 5. ROLE-BASED CONTROL
S
Spine−1
E
N East−1
W
0
3T/4
S
E T/4
3T/4 W
S
T/2
N
W
T/4
West−1 N
E
S
Spine−2
E
N East−2
W
T/2
T/4
S
E T/4
3T/4 W S
T/2
N
W
3T/4 West−2 N
E
Figure 5.12: The black boxes represent modules, which are connected to form
a quadruped robot. All the modules are named and labeled with compass directions. The expression next to a connector represents the delay d across
that connector. The delay is expressed in fractions of a period T . For instance, the delay associated with the east connector of the spine module is
deast = T /4. The expressions located in the center of the modules represent
the value of t of that module when the spine module spine-1 is at tspine−1 = 0.
The t value of a child is calculated using tchild−i = tparent − di where i is
the connector to which the child is connected. Note that by using the delays
specified here the top east leg and bottom west legs are synchronized. This
also goes for the top west and bottom east leg.
70
5.6. ROLE-BASED CONTROL WITH ROLE SELECTION
|P (east − 1, west − 2)| = 0
|P (west − 1, east − 2)| = 0
T
|P (east − 1, west − 1)| =
2
T
|P (east − 2, west − 2)| =
2
T
|P (east − 1, east − 2)| =
2
T
|P (west − 1, west − 2)| =
2
(5.9)
(5.10)
(5.11)
(5.12)
(5.13)
(5.14)
The length of paths can be found from Figure 5.12.
−dsp,e + dsp,n + dsp,w = 0
−dsp,w + dsp,n + dsp,e = 0
T
−dsp,e + dsp,w =
2
T
−dsp,w + dsp,e =
2
T
−dsp,e + dsp,n + dsp,e =
2
T
−dsp,w + dsp,n + dsp,w =
2
(5.15)
(5.16)
(5.17)
(5.18)
(5.19)
(5.20)
Using one of the last two equations we find that:
dsp,n =
T
2
(5.21)
The only constraint we have left is that the difference between dsp,e and
dsp,w is half a period. We know a spine module can receive a synchronization
signal at t=0 and we know it has to send a signal at dsp,n = T /2. Therefore,
we choose the following values to spread out the communication over a period.
T
4
3T
=
4
dsp,e =
(5.22)
dsp,w
(5.23)
71
CHAPTER 5. ROLE-BASED CONTROL
Now all the delays are specified, but there is one piece missing. We have
to make sure that the spine also is coordinated. We know from the spine
motion defined in equation 5.9 that the spine is bent most to the east at
tspine−2 = T /2. The east legs are closest together at teast−2 = T /4 (see
equation 5.9). We want the delay such that this difference is maintained.
T
4
T
=
4
|P (spine − 2, east − 2)| =
dsp,e
(5.24)
(5.25)
We can see our choice for dsp,e actually ensures that the spine is making
the robot take longer steps. These results are summarized in Figure 5.12.
We have now calculated the delays for the spine module. If feet-modules
were connected to the legs we would have to calculate delays for the feet as
well. However, we are not planning to connect any modules so for simplicity
we just give the leg modules the same delays as the spine modules.
We can calculate how long a time it will take for a walker of an arbitrary
number of modules n and segments n/3 to synchronize. The longest complete
path in a walker is from the head spine module to the last west leg. We get
the following expression for the synchronization delay.
n
− 1)tn + tw
3
n
T
3T
= ( − 1) +
3
2
4
T (2n + 3)
=
12
tsync = (
(5.26)
(5.27)
(5.28)
Role Selection
In order to combine these roles into a working control system we need to
define when a module should play what role. First, we will define some
functions. Remember that the CONRO modules have the connectors C =
{e, w, n, s} where the parent connector CP = {s}. The function Con :
C → Boolean returns a boolean value that indicates whether a module is
connected to the specified connector. The function N eiCon : C → R returns
the connector of the parent module to which this module is connected. The
function Role : C → R returns the role being played by the module connected
to the specified connector. We make the following role-selection rules for the
walker. A module plays a spine role if it has child modules connected to
72
5.6. ROLE-BASED CONTROL WITH ROLE SELECTION
west leg
east leg
spine
spine
→
→
→
→
spine,
if
spine,
if
west leg, if
east leg, if
Con(e) ∨ Con(w) ∨ Con(n)
Con(e) ∨ Con(w) ∨ Con(n)
Con(s) ∧ N eiCon(s) = w
Con(s) ∧ N eiCon(s) = e
Table 5.1: This table shows the role-selection rules used in the walker. Refer
to Section 5.6.1 for an explanation of the notation.
the east or west child connector or if it has a module connected to the n
connector. A module plays east leg if it is connected to the east connector
of the parent module and a similar rule works for the west leg. These rules
are shown in Table 5.1.
Experiments – Scalability
In order to test this implementation we measured how long it took the
CONRO robot in a quadruped configuration to cover a distance of 150cm.
We found that the average of ten trials was 10.9 seconds and the standard
deviation was 0.57 seconds. This corresponds to a speed of 13.8cm/second.
We now added an extra pair of legs. Note that this does not require any
changes to the controller, because the synchronization mechanism already
implemented will make sure that the third pair of legs are half a period
delayed compared to the second pair of legs.
In order to test the locomotion speed of the hexapod we repeated the
experiments another ten times. We found that the average time was 12.0
seconds (12.5cm/sec.) and the standard deviation was 0.57 seconds.
Initially, we tested the hypothesis that the speed of the robot is independent of the number of modules. Unfortunately, Student’s t-test rejected
this hypothesis. From close observation of the experiments we found that
the quadruped robot takes longer steps, because it slides a little forward
with each step due to its momentum. In the hexapod this is not the case,
because of the friction caused by the extra pair of legs. In order to remove
this difference from our data we returned to the videos of the experiments
and counted the number of steps taken by the robot in each experiment. We
divided the time by the number of steps to produce a time-per-step measure.
We then tested the hypothesis that the time-per-step is the same for both
the quadruped and hexapod walker. This hypothesis was accepted on the
5% confidence level (see Appendix A). This implies that the speed of the
system is identical in the two experiments. This finding and the fact that
role-based control uses constant time to keep the system synchronized lead
us to conclude that it is likely that role-based control scales.
73
CHAPTER 5. ROLE-BASED CONTROL
sw
→ sp,
if
→ wleg , if
→ eleg , if
Con(e) ∨ Con(w)
Con(p) ∧ N eiCon(s) = w
Con(p) ∧ N eiCon(s) = e
sp
→ sw,
→ wleg ,
→ eleg ,
if
if
if
¬(Con(e) ∨ Con(w))
Con(p) ∧ N eiCon(s) = w
Con(p) ∧ N eiCon(s) = e
if
if
(Con(p) ∧ Role(s) = sw) ∨ Con(n)
Con(p) ∧ Role(s) = sp
leg → sw,
→ sp,
Figure 5.13: This figure shows the rules used to decide when to change between
roles. The roles R are sidewinder (sw), spine (sp), east leg (eleg), and
west leg(wleg). The transitions for the west leg and the east leg are the
same and are therefore both represented by leg. Refer to Section 5.6.1 for an
explanation of the notation.
5.6.2
Walker and Sidewinder Combination
In the previous section we introduced role selection. We implemented a walking gait by using role selection to make each module select the appropriate
role to play. However, we only considered one gait. Using role selection, it is
possible to have a self-reconfigurable robot switch between gaits depending
on its configuration. We will demonstrate that the robot can switch from a
sidewinder gait to a walking gait depending on the robot’s configuration.
Role Selection
The rules are as described below and shown in Figure 5.13. A module playing
the sidewinder role changes to the spine role if a module is connected to either
the east or the west connector. If it is connected to the east or west side of
a module, it plays the role of the corresponding leg. The rules for the spine
role are similar to those of the sidewinder role except that if both modules
to the sides are detached the module changes role to a sidewinder role. The
legs decide to change role to sidewinder or spine if they are connected to the
north connector of a module playing one of these roles. Additionally, if a leg
has a module connected on its north connector it changes role to sidewinder.
This last transition is made to make sure that a leg placed at the root of the
configuration tree discovers that and plays an appropriate role.
74
5.6. ROLE-BASED CONTROL WITH ROLE SELECTION
Figure 5.14: The reconfiguration process of experiment 1. The solid lines
represent modules. The robot starts in a chain configuration as shown at the
top. The modules are then manually reconfigured as indicated by the dashed
arrows until the quadruped configuration shown at the bottom is obtained.
Experiments
In order to evaluate this system we conducted a series of experiments with
a self-reconfigurable robot made from seven CONRO modules. The robot
is initially configured into a long chain. The root module is started using
an infra-red signal. The root module signals its child after T /5 and so on.
After 6T /5 corresponding to approximately three seconds all modules are
synchronized and take part in the sidewinder gait. The synchronization time
is increased by one period per synchronization signal missed. However, in
the experiments reported this was not observed.
It was then recorded how long it takes to move 63cm using the sidewinder
gait. The robot is then picked up and dynamically reconfigured into a four
legged walker. In each experiment the reconfiguration sequence is different.
The reconfiguration sequence for experiment 1 can be seen in Figure 5.14.
When the system is synchronized again the robot is allowed to walk 87cm
and this time is also measured. Note that throughout each experiment the
modules are not reset. Three snapshots from an experiment are shown in
Figure 5.15.
We repeated the experiment four times. It took on average 12.3±1.0 seconds to cover 63cm corresponding to 5.1cm/seconds as a sidewinder. It took
36.5±2.4 seconds to walk 87cm corresponding to 2.4cm/seconds. Detailed
75
CHAPTER 5. ROLE-BASED CONTROL
Figure 5.15: The robot first covers a distance of 63cm using a sidewinder gait
(top). The robot is then dynamically reconfigured into a quadruped walker
(middle). Finally, the robot walks 87cm (bottom). Note, that the cables only
provide power. (USC Information Sciences Institute.)
76
5.7. HANDLING A GENERAL CONFIGURATION
experiment sidewinder walker
1
13
25
2
11
30
3
13
28
4
12
30
avg
12.3
36.5
std.dev.
1.0
2.4
Figure 5.16: This figure shows the experimental data for four experiments.
The second column indicates the time (seconds) it took for the robot to synchronize and move 63cm using the sidewinder gait. The third column indicates the time (seconds) it to took to locomote 87cm using the walker gait.
The last two rows indicate the average and standard deviation of these four
experiments, respectively.
data can be found in Figure 5.16. The speeds of these locomotion patterns
are slightly lower than those reported in the previous section. The reason
for this is that it is difficult to manually reconfigure the modules if they are
moving too fast and therefore the period T has been increased.
5.7
Handling a General Configuration
In the previous section we assumed that there were no loops in the configuration. The reason for this assumption is that there is a risk that synchronization signals chase each other around the loop and thus the system may
never converge. In this section we look at an extension of role-based control
which makes it possible to handle loops.
The rolling track is the simplest example of a loop configuration. However, this poses a problem for our algorithm. In the previous experiments
we have exploited the assumption that the modules form a tree to implicitly
find the leader, the leader being the root of the configuration tree. Note
that the leader is not critical to the robustness of the system. If the leader
fails, the child modules of the leader will become leaders. This is a simple
mechanism that guarantees that there is one and only one leader for each
sub-tree. However, in a loop-configuration this is not the case.
One solution to this problem is to introduce IDs. In our implementation
we just make the modules pick a random number and use that as ID. It is
not guaranteed to find a unique leader, but it is a simple solution that works
in most cases. The shortcomings of this approach can easily be avoided if
each module has a unique serial number.
77
CHAPTER 5. ROLE-BASED CONTROL
The role-playing algorithm now works as before, but it is combined with a
simple well-known distributed leader election algorithm (Chang and Roberts,
1979). The signals from parent to child now contain a number, which is the
ID of the module originally sending the signal. Upon receiving a signal, a
module compares the signal’s number to its ID. If it is higher the module is
synchronized and the signal and its ID are propagated along with the synchronization signal. Otherwise, the module considers itself the leader and
ignores the signal. After the system has settled, the module with the highest
ID dictates the rhythm of the locomotion pattern. The leader election algorithm runs continuously, which means that the system quickly synchronizes
if modules are replaced.
Intuitively, the algorithm works from a control point of view by splitting
the loop before the module with the highest ID. Essentially, it is converting
the loop-configuration into a chain configuration with the module with the
highest ID as the leader. Unfortunately, this means that this algorithm cannot be applied directly to a tree configuration, because the synchronization
signal propagated from the root will not make it further than a child with a
higher ID than the root. In order to make an algorithm which can handle
both loops and trees, the modules have to have IDs, and the synchronization
signal has to be propagated both upward and downward in the tree. This is
possible, but increases the complexity of the algorithm. Here we will give an
example of a Rolling Track and then for the remainder of this text assume
that there are no loops in the configuration.
Figure 5.17: A snapshot of the rolling track. (USC Information Sciences
Institute.)
78
5.8. ROLE SELECTION BASED ON SENSOR INPUT
5.7.1
The Rolling Track
We used the loop algorithm to implement the rolling track which can be
seen in Figure 5.17. The rolling track achieves a speed of 13.8 cm/s. The
parameters for the eight-module rolling track is:
T = 180
60◦ (1 − sin( 2π
t)) if t =<
T
pitch(t) =
◦
60
if t > T2
yaw(t) = 0
dnorth = T4
T
2
(5.29)
Unlike the sidewinder and the caterpillar this control algorithm only
works with 8 modules, because of the physical constraint of the loop configuration. It might be possible to make a more general solution by making
pitch(t) and d a function of the number of modules. The number of modules in the loop could be obtained by the leader by including a hop count
in the signal. The leader selection algorithm has no impact on the time to
synchronize and therefore we find that:
tsync = (n − 1)dnorth
T (n − 1)
=
4
2.37s(8 − 1)
=
4
= 4.2s
5.8
(5.30)
(5.31)
(5.32)
(5.33)
Role Selection Based On Sensor Input
In the introduction we mentioned adaptability as one of the advantages of
self-reconfigurable robots. However, in order to be adaptive the robot has to
be able to sense the environment. Therefore, we mounted flex sensors on the
CONRO modules and incorporated the sensor-feedback from these sensors
into role-based control.
5.8.1
Related Work on Sensors
In research on sensor fusion there has been some work on how to combine
and abstract sensor values into logical (Henderson and Shilcrat, 1984) and
virtual sensors (Rowland and Nicholls, 1989). This work has been further
extended with a commanding sensor type (Dekhil et al., 1996). The focus
79
CHAPTER 5. ROLE-BASED CONTROL
was on improving fault-tolerance of sensor systems and aiding development
by making the sensor systems modular (Hardy and Ahmad, 1999). These
ideas are relevant to the use of sensors in self-reconfigurable robots. However,
using sensors in self-reconfigurable robots is different because of the unique
features of self-reconfigurable robots.
In a self-reconfigurable robot it cannot be assumed that the position of
the sensor is fixed. It can be moved through reconfiguration or maybe just
by movement of the modules. This means that we need to understand how
to extract meaningful sensor data from a network of sensors connected in
time-varying ways. The previously proposed approaches also mainly deal
with one consumer of the sensor data. If distributed control is employed
there are many controllers that act on the sensor data. This means that the
system should be able to deal with inconsistent sensor data.
Emergent control is often used to control locomotion in lattice-type selfreconfigurable robots. In emergent control, sensor information can be handled locally, i.e., on the module which receives the sensor input through its
sensors. Butler et al. have made a system in simulation where each module
is a cellular automaton that reacts to its local configuration and surrounding
obstacles (Butler et al., 2001b). Another approach explored by Bojinov et al
is to have the structure of the robot grow from seed modules (Bojinov et al.,
2000a; Bojinov et al., 2000b). The growth is accomplished by having the
seed module attract spare modules to a specific position with respect to itself by using a virtual scent. When a spare module reaches that position, the
old seed module stops being a seed and the newly arrived module becomes
the seed. The behavior of the seed module is controlled based on events it
can sense in the environment. In these emergent approaches the modules
are decoupled in the sense that the modules only interact through stigmergy
(Beckers et al., 1994).
In chain-type self-reconfigurable robots, sensor information cannot always
be handled locally: sensor input may have effects on modules other than the
one in which it originated. For instance, in a walking robot all the modules
have to cooperate to turn the robot away from an obstacle being sensed by
one or more of the modules. This raises a fundamental question: how do
we distribute sensor information in order for it to arrive at the modules that
need it? In this work, sensor information is abstracted and propagated to
all modules in the systems. Each module in the system then independently
decides which action to take, based on these propagated sensor values. Our
use of sensors is inspired by the use of sensors in behaviour-based robotics
(Arkin, 1998; Matarić, 1997) where sensors are used directly to control motors and not to build an internal model. We combine this communication
system with role-based control.
80
5.8. ROLE SELECTION BASED ON SENSOR INPUT
Figure 5.18: The CONRO robot in a walker configuration. The spine is
made from two modules and the legs are made from one module each. (USC
Information Sciences Institute.)
5.8.2
A Reactive Walker
We will incorporate sensor information into the control of the walker presented above and make a reactive walker. At this point, it is uncertain which
way is best to incorporate sensor information into role-based control. Therefore, the implementation we present here should be seen as an example of
how sensor information can be incorporated. The idea is that if we implement many different sensor-based control systems, a pattern might emerge.
This may enable us to say something stronger about sensor information and
role-based control. However, in this work we are limited to one implementation.
Implementation
The CONRO self-reconfigurable robot is now configured into a quadruped
robot as shown in Figure 5.18. Two flex sensors are attached to the front
spine module and one is attached to each of the front legs. We now want to
use feedback from these sensors to make the robot steer away from obstacles.
In general, the direction of locomotion can be changed in two ways. The
motion of the legs can be biased so legs on the side pointing away from the
obstacle take shorter steps and those on the other take longer steps. This
81
CHAPTER 5. ROLE-BASED CONTROL
approach will enable the robot to make soft turns away from obstacles. An
alternative is to have legs on the side pointing away from the obstacle move
backward and thus produce a turning on the spot motion. We found in initial
experiments that the sensor-based bias of the locomotion pattern does not
produce a sharp enough turn to avoid obstacles. Therefore we decided to
implement roles which make it possible for the robot to turn on the spot.
The goal is to make the quadruped robot turn on the spot away from an
obstacle detected using one of the four flex sensors. Below we describe how
this is achieved. A module has up to two flex sensors mounted: the front
legs have one each, the front spine module has two, and the rest zero. The
modules continuously sample these sensors and write the analog value into
a local variable. Which variable depends on the position of the sensor. If
the flex sensor is pointing toward the east, the sensor value is written in a
variable named local east (LE), and if it points west in local west (LW). If
there are no sensors attached, these variables contain zero. Each module has
an additional six variables: northeast (NE), northwest (NW), east (E), west
(W), southeast (SE), southwest (SW). These variables represent the sensor
activity in the direction indicated by the names. For instance, if all the west
variables, including local west, are added up, it will give the sum of the sensor
activity on the west side of the robot. The same is true for the east values.
We will now describe how the sensor values are propagated in the system
to produce the contents of the variables, described informally above. When
a spine module sends sensor information to a module connected to its north
connector, it works as follows. The south module adds up the variables west,
southwest, and local west and sends the sum to the north module. The sum
is received by the north module and is written in the southwest variable.
Note that this satisfies the invariant that the southwest variable of the north
module now contains the sum of the sensor activity to the southwest. This
mechanism is summarized in Figure 5.19. At the same time the sum of the
east variables is propagated and written in the southeast variable of the north
module.
This mechanism will sum up the sensor inputs all along the spine, and
the northernmost module will have information about the sensor activity to
the southeast and southwest. However, we want all the modules to have
information of sensor activity in all directions, therefore a similar, but independent mechanism also propagates sensor activity southward. The sensor
propagation mechanisms are summarized in Figure 5.20.
All the spine modules now have information about sensor activity along
the spine. For instance, the modules can sum the northwest, local west,
and southwest variables to find the sensor activity on the west side of the
robot. This is not enough in our situation, because there are also two legs
82
5.8. ROLE SELECTION BASED ON SENSOR INPUT
NW
W LW
NE
LE E
SW
SE
NW
NE
W LW
SW
LE E
SE
Figure 5.19: This figure shows how sensor values are propagated north from
one spine module to the next. The south module (bottom) sums up the variables in the gray box and sends the sum to the north module (top). The north
module receives this sum and writes it in the variable indicated by the arrow.
NW
NE
W LW
LE E
SW
SE
NW
NE
W LW
LE E
SW
SE
Figure 5.20: This figure shows how sensor values are exchanged between two
spine modules. The modules sum the variables in the gray boxes and send
these two values to the other module. The receiving module then writes these
values in the variables indicated by the arrows.
83
CHAPTER 5. ROLE-BASED CONTROL
NW
W LW
SW
NE
NW
LE E
W LW
SE
SW
NE
LE E
SE
Figure 5.21: This figure show how sensor values are exchanged between a
spine module (left) and an east leg module (right). The modules add up the
numbers in the gray boxes and send these values to the other module. The
receiving module then writes these values in the variables indicated by the
arrows.
attached to the spine modules. Therefore, sensor information should also be
propagated from and to them. In our setup, an east leg can only have one
piece of sensor information that the spine does not have: the value of the
sensor connected to that leg. Therefore the local east value is propagated
from the leg to the spine. The leg on the other hand receives the sum of all
the sensor activity on the west side of the robot and writes it into the west
variable. The sum of the spinal variables northeast, local east, and southeast
is written into the east variable of the leg. This is summarized in Figure
5.21.
In role-based control synchronization information from the parent module
is sent to child modules each period of locomotion. The sensor information is
also exchanged at this time as described above. How the sensor information
is exchanged depends on what role the module plays. This is decided by the
role-playing algorithm. Therefore modules can still be exchanged and the
system will continue to function if the sensors are placed correctly.
All the modules now have access to delayed global sensor information
and can make their decisions based on this information. In order to make
a decision we sum the variables for the west and east sides of the robot to
have a measure of the activity on each side of the robot. A leg then decides
to move backward if the sensor activity on the other side of the robot is
above a small threshold and higher than the sensor activity on the leg’s side.
Otherwise it will move forward.
84
0.6
0.6
0.5
0.5
0.4
0.4
Meters
Meters
5.8. ROLE SELECTION BASED ON SENSOR INPUT
0.3
0.2
0.2
0.1
0
0.3
0.1
Trial 1: Sensors triggered
Trial 1: Sensors not triggered
Obstacle
0
0.1
0.2
0.3
0.4
0.5
0.6
0
0.7
Trial 2: Sensors triggered
Trial 2: Sensors not triggered
Obstacle
0
0.1
0.2
0.3
0.6
0.6
0.5
0.5
0.4
0.4
0.3
0.2
0.5
0.6
0.7
0.3
0.2
0.1
0
0.4
Meters
Meters
Meters
Meters
0.1
Trial 3: Sensors triggered
Trial 3: Sensors not triggered
Obstacle
0
0.1
0.2
0.3
0.4
0.5
0.6
0
0.7
Meters
Trial 4: Sensors triggered
Trial 4: Sensors not triggered
Obstacle
0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
Meters
Figure 5.22: These figures show the robot approaching an obstacle, turning
on the spot, and moving away. The arrows represent the positions of the
front and rear ends of the robot recorded every two seconds. The direction of
the arrow shows the direction of movement. A solid arrow indicates that a
flex sensor was triggered in that time-step. A dashed arrow states that none
were triggered.
Results
First we will note some general properties of the system. One step of the
robot corresponding to one period of locomotion takes two seconds. The step
length is 15cm long. Note, that a step is quite long compared to the length of
a module (10cm). These long steps are achieved by actively using the spine
to make the steps longer. The robot achieves a speed of 7.5cm/second.
We now place the robot so it approaches an obstacle from different angles. We videotaped these motions using an overhead camera, and manually
analysed the tape. For every two seconds, we recorded the position of the
front end of the robot, the rear end, and whether a flex sensor was touching
the obstacle. The results of this analysis for four trials can be seen in Figure
5.22.
The sensor values are exchanged when modules synchronize. We know
the spine synchronizes with the east leg at T /4, the spine module to the south
at 2T /4, and the west leg at 3T /4. We can use this information to calculate
upper and lower bounds on communication delays. In the worst case, where
the sensor change happens just after synchronization, it takes two periods to
85
CHAPTER 5. ROLE-BASED CONTROL
get sensor information from a front leg to the rear leg on the other side. In
the best case where the sensor change happens just before synchronization,
it takes one period. This means that the whole system has a reaction time
between two and four seconds or a reaction distance of 15cm to 30cm. Note,
that the reaction time is much better for the front legs. We can see these
slow reaction times in Figure 5.22. The robot can only successfully avoid
the obstacle when it approaches at an angle. In trial number four where
the robot does not have time to react, it bumps into the obstacle. This also
explains why we decided to implement the turningon-the-spot behaviour.
5.8.3
Sensors and Self-Reconfigurable Robots
If we look at how our approach can be used in general, we note that there
are two things that make our system work. 1) The sensor data is abstracted
based on the sensor’s position in a way that is useful for the action selection
of the receiving modules. 2) The abstracted sensor values are propagated at
a constant slow rate.
In order to keep the amount of communication manageable we abstract
sensor values to maintain an estimate in each module of the sensor activity
to the left and right of the robot. It is possible for all the modules to agree
on left and right, because of the properties of the CONRO hardware. The
modules can only be connected in a tree structure (with one loop) and can
only be connected in four ways: therefore the transformation of direction
from module to module is easy. In general, it seems to be important to
have some relative position information about the sensor with respect to the
acting module. This means that in systems where the relative position of
two connected modules can be found, it is possible to abstract the sensor
information in a useful way. This is also what makes this approach different
from previous work. The position of the sensor is variable and in our case
this is handled by the abstraction mechanism.
Sensor values flow around in our system at a constant slow rate. This rate
could be increased significantly to reduce the reaction time. The problem of
doing this is that our modules have limited resources and therefore if time
is spent on communication, less time can be spent on control of the motors
resulting in a decrease in speed. So, in order to decrease the reaction time of
the system without sacrificing speed we need to use less communication and
achieve a shorter reaction time at the same time. One solution would be to
have the module monitor a sensor and if it goes above a certain threshold
it can be propagated. When the sensor later drops below the threshold
another message can be propagated. This may improve the response time of
the system, because communication only takes place when it is needed.
86
5.9. DISCUSSION
Another orthogonal way to decrease the amount of communication would
be to only propagate sensor information to the modules needing it. For instance, in the walker sensor information from one side could be propagated
to the other side. In this way the sensors on the left control the legs on the
right and the other way around. In general, directed diffusion (Intanagonwiwat et al., 2000) could be used for this. In directed diffusion, information
is propagated from the producer to the consumer through networks with a
time-varying configuration. In this framework, it is possible for the consumer to show interest in a specific kind of data and have that routed from
the producer.
5.9
Discussion
We have now seen role-based control put into play in different contexts. We
have seen how role-based control can handle chain, loop, and tree configurations. We have seen how modules use role selection to decide which role
to play and we have seen how this selection can depend on sensor input.
In this section we will discuss role-based control from different perspectives.
We will hold role-based control up against the metrics and evaluation criteria
introduced in section 3.2. Before doing this, we note that role-based control
is an emergent control method. This means that the general discussion we
had in Section 3.3 about emergent control also applies to role-based control.
Robustness
In role-based control, a module failure will prevent the sub-configurations,
which were connected through the now failed module, from communicating.
This means that these sub configurations are not able to stay synchronized.
How much this impacts the efficiency of the locomotion pattern depends
on the specific configuration, the locomotion pattern, and where the failed
module is located in the configuration.
It is relatively easy from a control point of view to implement a behaviour
which disconnects dead modules. If a module dies, the configuration can then
be split into a number of smaller configurations which can function independently if the appropriate roles and role-selection mechanism are implemented.
This means that the performance of the system degrades gracefully with the
number of module failures.
Another issue is how robust the system is to communication errors. This
question we have addressed with our experiments. In the Caterpillar experiments in Section 5.5.1 we saw that role-based control is highly robust
87
CHAPTER 5. ROLE-BASED CONTROL
to communication errors, because no message is critical and always will be
resent a period later.
Scale Extensibility
The question here is whether modules can be added to and removed from the
system. We saw in the experiment with the Caterpillar and the Walkers that
modules can be added without any changes to the algorithm. In general, the
roles and role selection have to be programmed in such a way that a module
can be added anywhere. This is, in theory, not a problem, but in practice it
becomes cumbersome to implement efficient gaits for all the configurations
into which the user could decide to reconfigure the robot into.
The second issue is whether the system can handle dynamic reconfiguration, i.e., be reconfigured at run-time. This is certainly possible with
role-based control. This was shown, for instance, in the experiments with
the Sidewinder being reconfigured into a Walker.
Versatility
Role-based control is tied to applications where the action cycle of the modules are of a repetitive nature. This means that it is mainly useful for locomotion as shown in this work. There are two main problems, which prevent
the method from being useful in non-repetitive tasks. The first is that a
module can never be sure when the entire system is synchronized, because of
the local nature of the algorithm. The second is that even though a module
could be sure, the initial synchronization time may be prohibitive.
The role-selection mechanism is quite general and can be used to implement a variant of hormone-based control. In hormone based control, hormones travel through the system triggering new hormones and actions. Role
selection is similar except that hormones, or in our case synchronization
signals, trigger a state change which then triggers new synchronization signals or actions. This gives the system an increased robustness, because if a
message is lost the state information is not and can be used to regenerate
the message. We have done some preliminary experiments using the roleselection mechanism for the control of self-reconfiguration of the CONRO
robot. However, the attempts were unsuccessful because of problems with
the connection mechanism of the CONRO module.
88
5.9. DISCUSSION
Adaptability
In this work we have shown how sensor feedback can be incorporated and we
have suggested alternative ways which might be better. In general, it seems
possible to use sensor information in role-based control to produce robots
able to adapt to their task-environment.
Assumptions About The Environment
The locomotion patterns we have presented here require structured environments. However, the algorithms do not require the environment to be static
or known, because the system is purely reactive. We have made preliminary
experiments with the Caterpillar equipped with the flex sensors, which suggest that it may be possible to move through winding tunnels. Using a sensor
rich platform it might be possible to make a system which does not require
the environment to be structured.
Scalability
We have shown that the start-up time is limited by O(T n) where T is the period and n is the number of modules. We have also seen that, after the initial
synchronization, the algorithm uses constant time per module to maintain
synchronization. This means that the algorithm is efficient enough to handle
systems consisting of many modules.
In role-based control, memory consumption grows linearly in the number
of roles. The number of roles directly reflects the different actions of modules
in the system and, therefore, is an efficient representation in terms of memory.
Finally, the communication load is independent of the number of modules. However, as discussed, this may change with the introduction of sensor
feedback.
Minimalism
In this chapter we saw increasingly complex variations of role-based control
as we moved toward more and more complex configurations and locomotion
patterns. However, we will still claim that the system has a high degree
of minimalism in the sense that role based control employs the simplest
possible control structures to solve the task. To the best of our knowledge the
Caterpillar, the Sidewinder, and the Walkers are the simplest implementation
of these locomotion gaits.
89
CHAPTER 5. ROLE-BASED CONTROL
Systematicness
As discussed earlier, it is often a problem in systems based on emergent
control to go from a global human-understandable specification of a task to
the local rules which actually make the solution to the task emerge. We think
that role-based control takes one step in the direction of making this more
systematic.
We saw in role selection that constraints about how different modules
in a configuration should be synchronized can easily be observed. These
constraints can, in a systematic way, be translated into equations which
makes it possible to calculate the local delays.
Given that the system is synchronized in the right way, the action sequence of the individual role can be obtained through experimentation. This
is not as systematic as we could wish, but in practice — for the implementations we have seen — it was a relatively simple task. For instance, it took
about a day’s work to implement the Walker.
Alternative Hardware
Role-based control emerged as a natural way to control locomotion of the
CONRO self-reconfigurable robot. The CONRO modules lend themselves to
role-based control, because the physical design of the connectors ensures that
each module knows locally which connector is connected to the configuration
tree and which are connected to sub-trees. In this section, we will discuss
how role-based control can be implemented on systems where the physical
connections do not give each module direction information regarding the
configuration.
Let us first look at the case where all connectors are hermaphrodite, that
is, a connector can be connected to any other connector on another module. This could for instance be the two-dimensional Crystalline robot. If
the connectors of the module themselves do not contain information about
direction, the only source for direction are external signals sensed using sensors. An easy solution is to assume that the connector through which the
first signal is received is the parent connector. The child connectors are then
always defined relative to the parent connector and not to a physical connector. This could lead to some interesting experiments. For instance, the
caterpillar could be given an infra-red signal at both ends resulting in different directions of locomotion. This is similar to what Butler et al. have
done except their algorithm is a distributed version, because a signal travels
through the length of the robot before a new step is initiated (Butler et al.,
2002a). It is worth noting that Butler, in his paper, cites the papers on which
this thesis is based.
90
5.10. CONCLUSION
An interesting question is what happens if the robot is dynamically reconfigured: for instance, one module of a chain of modules is rotated 180 ◦ .
In this situation synchronization signals may never converge to go in the
same direction. There are a number of ways this can be avoided, but we
have not explored this further. We can assume that a module only can propagate a synchronization signal if it has received one itself or has received
a signal from the environment. This means that transient synchronization
signals, originating from a dynamic reconfiguration of the modules, will die
out. Eventually, the head of the configuration will become leader if it is the
only module who gets stimulated to generate a synchronization signal.
5.10
Conclusion
Role-based control is an emergent approach to the control of self-reconfigurable
robots. This means that the general advantages first put forward in the
general discussion in section 3.3 hold for role-based control. The strong
aspects of role-based control are robustness, scale extensibility, scalability,
minimalism. These claims are supported by experiments with the CONRO
self-reconfigurable robot. Specifically, we have shown the robustness of rolebased control to communication errors in the Caterpillar experiments. We
have seen how the Caterpillar and the Walkers can be extended without reducing performance or needing to change the controller. Scalability is shown
through experiments to the degree it is possible with nine modules. However, we have shown that the algorithm itself synchronizes the robot in time
equal to the longest path in terms of delays in the configuration tree. Furthermore, it keeps the system synchronized, independent of the number of
modules using constant time each period. Minimalism is harder to show, but
to the best of our knowledge role-based control is the most minimal approach
to the control of locomotion of chain-type self-reconfigurable robots. This is
indicated by the program listing in Figure 5.5 in Section 5.5.1.
In the general discussion, we pointed out that the main shortcoming of
emergent control is the difficulty of designing local rules which result in the
desired global behavior. In our description of role based control we have
pointed out there is a systematic way to transfer the global knowledge of
how modules should be synchronized into the local delays which actually
will make this happen. Role selection is, if not systematic, quite simple.
This is due to the fact that we have shown in a constructive proof how roles
can be assigned uniquely to each module in a configuration tree. Finally, the
definition of the action sequences of the roles is more complicated and, in
our implementation, is obtained through a few iterations of experiments.
91
CHAPTER 5. ROLE-BASED CONTROL
Control algorithms for self-reconfigurable robots need to be versatile, because this is one of the features of self-reconfigurable robots. Role-based
control is useful for implementing locomotion patterns and other types of
applications which require repetitive motion. However, the role-selection algorithm on its own is useful for a wider range of tasks.
Most of the experiments reported have been open-loop locomotion. This
is, of course, not acceptable, because we want the robot to act in a dynamic, unknown, and unstructured environment. Therefore, we have taken
some initial steps to incorporate sensor-feedback into role-based control. It
is relatively easy if the sensor-feedback can be handled locally, for instance,
by making the leg sensing an obstacle take longer steps. It becomes more
difficult when the whole robot has to respond in a coordinated way. We
have shown in this work the initial idea of using abstract sensor values and
propagating them through the system. In the current approach the exchange
of sensor values is integrated with role based control, but it may be better
to make that an independent mechanism. Finally, implementing role-based
control on modules which have hermaphrodite connectors is not straightforward and is most likely coupled to the problem of sensor feedback. This is
likely, because when there is no sense of direction given by the morphology
of the robot this direction has to be extracted from the environment.
All this said, role-based control is the first control algorithm for chaintype self-reconfigurable robots which is based on emergence. The locomotion
gaits produced are some of the most visually pleasing demonstrated. Rolebased control has also already had influence on research in the field. For
instance, Shen et al. have, after our work was published, introduced delays as
a powerful mechanism in hormone based control (Shen et al., 2002). Zhang,
Yim et al. have presented a new version of gait control tables called phase
automata (Zhang et al., 2003). The paper has not been published at the time
of writing, but the abstract has. Here is a quote “....A phase automaton is
an event-driven input/output state automaton with an initial phase delay..”.
This definition incorporates the idea of delayed synchronization put forward
in this thesis. In effect, this means that most related approaches to the control
of locomotion of chain-type self-reconfigurable robots have been updated to
include the essential characteristics of role-based control.
92
Chapter 6
Self-Reconfiguration
Algorithms
The ability which sets self-reconfigurable robots apart from traditional robots
is the ability to change shape. Therefore, this shape-changing ability has from
the onset been a focus area for research in self-reconfigurable robots. In this
chapter we will look at the control of self-reconfiguration.
First, the problem of self-reconfiguration will be presented. Then we will
describe some application-specific metrics to evaluate control systems for selfreconfiguration. We will then survey previously proposed algorithms for the
self-reconfiguration problem and classify them. We proceed to compare and
analyse the different classes of control systems. Finally, we discuss advantages
and disadvantages of these systems and, through this discussion, set the stage
for the presentation of control based on gradients and cellular automata in
the following chapter.
6.1
Problem Definition
The problem of controlling the self-reconfiguration process has mainly been
approached in two ways. It has been approached as a planning problem:
given an initial configuration i and a final configuration f find a sequence of
module actions, which reconfigure the robot from i to f . This formulation
of the problem has led to the solutions based on global information that we
will describe in more detail in the next section. The alternative approach is
a multi-robot-coordination-inspired approach: given that each module can
only communicate and sense locally, find a controller for each module whose
execution results in the system reaching the final configuration. This formulation of the problem has led to the emergent solutions described below.
93
CHAPTER 6. SELF-RECONFIGURATION ALGORITHMS
6.2
Self-Reconfiguration Specific Metrics
In Section 3.2 we described some general metrics that can be used to analyse
and compare control systems for self-reconfigurable robots. In the context of
self-reconfiguration we can add more detail to the application specific metrics.
This is what we will do in this section.
6.2.1
Scalability in Self-Reconfiguration
A measure of efficiency of a self-reconfiguration algorithm is the number of
moves and the time to complete the reconfiguration. The number of moves
expresses how much energy is needed to actuate the system. The time to
complete the reconfiguration is a measure of the parallelism of the system.
These properties can also be measured using the complexity notation.
We can find lower bounds on these metrics for a specific configuration.
This is useful, because then we can talk about the difficulty of a reconfiguration task. Furthermore, it can give us an indication about how efficient
an algorithm is compared to the optimal one. Chirikjian and colleagues
(Chirikjian and Pamecha, 1996; Chirikjian et al., 1996) propose to obtain
the lower bound by first finding the optimal assignment between the start
configuration and the final configuration. The distances the modules have
to move, assuming that interference with other modules can be ignored, are
then summed up. This bound can be calculated by treating it as the problem of a perfect matching in a weighted bipartite graph (Gibbons, 1985).
Chirikjian et al. propose an approximation which is given as the distance
between the centroids of the two configurations times the number of modules.
This approximation works well if the centroids are far from each other, but
is useless if they overlap.
6.2.2
Versatility - Classes of Reconfiguration Problems
Some self-reconfiguration problems are difficult to solve for self-reconfiguration
algorithms. Therefore, a measure of the versatility of an self-reconfiguration
algorithm is the class of reconfiguration problems it can solve. In literature
it has been pointed out that the configurations with the problems mentioned
below are difficult for self-reconfiguration algorithms (Yim et al., 2001b).
Local Minima. Can the algorithm successfully assemble structures containing local minima? A local minimum is a situation where a module
cannot go straight toward the goal, which would cause it to become
trapped, but instead has to take a longer path.
94
6.3. SURVEY OF SELF-RECONFIGURATION ALGORITHMS
Solid Configurations. Can the system handle configurations which contain solid sub-configurations? The problem is that if the perimeter of
the object is assembled first, it may be a problem to go through the
perimeter to assemble the unfinished parts inside.
Hollow Configurations. Can the system handle hollow configurations? Here
the problem is that modules may be trapped in the hollow parts of the
configuration.
Motion Constraints. Is the algorithm able to handle the motion constraints
which are often present in real physical self-reconfigurable robots?
In the following we will assume that if the algorithms do not converge, it
is for one of the reasons listed above.
6.3
Survey of Self-Reconfiguration Algorithms
In this section we review the methods proposed in literature for controlling
self-reconfiguration. The methods are categorized according to the taxonomy
of control systems presented in Section 3.1. Also, the methods are categorized
according to robot morphology.
6.3.1
Chain-Type
Distributed Systems Based on Global Information
In (Shen et al., 2002; Shen et al., 2000b; Shen et al., 2000a; Salemi et al.,
2001) artificial hormones are introduced as a control metaphor for selfreconfigurable robots. Hormones are propagated through the modules of
the robot and trigger actions and may also trigger other hormones. In this
work there is no planner; the hormones are hand-coded to solve a specific
self-configuration task in the CONRO chain-type robot.
Emergent Control
Casal and Yim propose a self-reconfiguration planning algorithm for the Polypod chain-type self-reconfigurable robot (Casal and Yim, 1999). In this algorithm, a robot topology is first decomposed into a hierarchy of small substructures (subgraphs of modules) belonging to a finite set. Basic reconfiguration
operations between the substructures in the set are precomputed, optimized
and stored in a lookup table. The entire reconfiguration then consists of an
ordered series of simple, precomputed sub-reconfigurations happening locally
95
CHAPTER 6. SELF-RECONFIGURATION ALGORITHMS
among the substructures. This algorithm is further developed by Yim et al.
and theoretical results regarding its running time and the number of moves
needed to reconfigure are given (Yim et al., 2000b).
6.3.2
Lattice-type
Centralized Systems
Chirikjian presents a simulated two-dimensional hexagonal module providing a 2D space-filling morphology where modules can roll around their neighbours (Chirikjian, 1994). The system is a simulation of the JHU metamorphic
robot. A coordinate system and a distance metric are defined. A centralized
planner able to plan how the robot can envelope an object is proposed. The
heuristic planner works by making modules attracted to the global coordinate of the object. The robot stays connected by using simple local motion
constraints.
This work is extended in (Chirikjian et al., 1996). In this paper, lower
bounds and upper bounds for the minimum number of moves to self-reconfigure
from an initial configuration to a final configuration are given. This metric is
referred to as the optimal assignment metric. Intuitively, the metric is a measure of the similarity of two configurations. A sub-optimal plan is obtained
using heuristics. This plan is then improved using a method of contraction
and filtering. The plan is contracted by looking for a sub-sequence of moves
where the start and ending configurations are identical. This sub-sequence
is then removed. Filtering is achieved by identifying sub-sequences where
the number of moves used to configure from the start configuration to the
final configuration is higher than the upper bound. This sequence is then
improved using heuristics. Ideally, the planner is stopped when the lower
bound and the upper bound are equal in which case the plan is optimal.
However, this is not guaranteed to be the case.
Pamecha (Pamecha et al., 1997) introduces the overlap metric and a
metric which is a linear combination of the optimal assignment metric, the
overlap metric, and a configuration metric. These metrics are used in a
simulated annealing approach to the problem.
Chiang and Chirikjian present a two-dimensional quadratic module providing a 2D space-filling morphology where modules can roll around their
neighbours (Chiang and Chirikjian, 2001). Their planner uses a divide-andconquer strategy. They find an intermediate configuration between the initial
and final configuration. This process is repeated upto three times. The moves
needed to go between these intermediate configurations are then planned using a variant of the simulated annealing approach proposed by Pamecha et
al. (Pamecha et al., 1997).
96
6.3. SURVEY OF SELF-RECONFIGURATION ALGORITHMS
Kotay and Rus (Kotay and Rus, 2000) use the Molecule self-reconfigurable
robot. They propose a three level planner: a trajectory planner, a configuration planner, and a task-level planner. At the lowest level is the trajectory
planner and it is shown that given an initial and a final position and pose
the planner can find a trajectory in O(n) where n is the number of modules.
Two solutions to the reconfiguration planning problem are proposed. One
takes a module in the initial structure, but not in the final, and moves it to
a position in the final configuration. The trajectory from the initial position
to the final position is planned using the trajectory planner. Alternatively,
the reconfiguration planning is based on scaffold planning. The idea is that
the internal structure of the self-reconfigurable robot is engineered to make
it easy for modules to pass through the structure. This implies that there
is no need for the trajectory planner at the cost of bigger granularity of the
system (a section of scaffold uses 54 modules).
Rus and Vona propose the Melt-Grow planner for the Crystalline selfreconfigurable robot running in O(n) (Rus and Vona, 1999). The idea is
that first the initial configuration is melted into an intermediate chain configuration. The final structure is then grown from the intermediate chain
configuration. The advantage is that it is relatively easy to reconfigure into
and out of a chain configuration. This idea is further developed and analysed
in (Rus and Vona, 2001).
Unsal et al. use I-Cubes, a system consisting of links and cubes (Unsal
et al., 2000). They propose a two-level planner. A low level planner finds
solutions for small subproblems. The high-level planner works at the level
of module positions using the low-level planner to check feasible paths. This
approach is further investigated in (Unsal and Khosla, 2000) where the lowerlever consists of solutions to small problems and another one starts with a
small transition diagram and extends it as needed.
In (Ünsal and Khosla, 2001) meta-modules are introduced. The lower
level is then able to move the meta-modules, and the high-level planner can
plan at the meta-module level. This approach is further investigated by
Prevas et al. (Prevas et al., 2002).
In (Ünsal et al., 2001) a three level planner is introduced. At the highest
level it is decided which module to move. The middle layer generates subproblems, which need to be solved to move the module. The bottom layer
then solves these subproblems using heuristic search and returns them to the
middle layer. The middle layer combines them into useful plans.
97
CHAPTER 6. SELF-RECONFIGURATION ALGORITHMS
Distributed Systems Based on Global Information
Yim et al. use a simulation of the Proteo module (Yim et al., 1997). The
Proteo is a rhombic dodecahedron. This shape is three-dimensional with 12
identical sides in the shape of a rhombus. The modules can roll around neighbours. This module has not been realized in hardware. In this algorithm,
all modules know their positions and have a list of positions specifying the
final configuration. Modules move toward the closest unfilled goal position
using Euclidean distance. In order to avoid overcrowding, modules reserve
goal positions, which prevent other modules from moving to the same goal
location. This algorithm is further developed in (Yim et al., 2001b) where
elements of emergence are introduced. However, we will present this in the
following section.
Butler et al. introduce the Pacman algorithm for use in the Crystalline
self-reconfigurable robot (Butler et al., 2001a). The algorithm works in two
phases. In the first phase a virtual “pellet” path is distributed in the robot
identifying a path for a module to follow. In the second phase modules
follow the “pellet” paths to reach the final configuration. This idea is further
developed and analysed in (Butler and Rus, 2002).
A similar approach is investigated by Vassilvitskii et al. using the Telecubes (Vassilvitskii et al., 2002). In this approach, a meta-module is made
from eight Telecubes and it is shown how this meta-module can be controlled
using basic primitives. A variation of the Pacman algorithm is then used to
plan a path through the structure which is converted into a sequence of basic
primitives.
Walter et al. use two dimensional space-filling hexagons (Walter et al.,
2000b). In their approach, modules use simple local connection rules to decide if it is possible to move. Each module knows the final configuration, its
current coordinate, and its orientation. The modules then roll around neighbours until an unoccupied spot in the final configuration has been reached,
in which case the module stops. Using this approach it is shown how to
rotate a chain of modules ninety degrees by self-reconfiguration. The class
of goal configurations is extended in (Walter et al., 2000a) where the selfreconfiguration is from a chain to an admissible configuration. An algorithm
is given that can decide if a configuration is admissible. Intuitively, an admissible configuration is a configuration, whose surface allows the movement
of modules without collision or deadlock.
The class of admissible configurations is extended in (Walter et al., 2002a)
by first having the modules build a substrate path which ensures that the remaining modules are able to move to their final position. The paper presents
an algorithm to calculate the substrate paths and also contains some pre98
6.3. SURVEY OF SELF-RECONFIGURATION ALGORITHMS
liminary ideas about how obstacles in the environment can be incorporated
in the algorithm. All these results are summarized in (Walter et al., 2002b)
where the correctness of the algorithms also is proved.
Emergent Systems
Murata et al. use the Fracta robot (Murata et al., 1994). In their algorithm
the final configuration is represented as a set of connection types and neighbour connection types. A connection type describes a local configuration.
The idea is that when all modules are in a configuration that matches one of
these rules the final structure has been reached. When not in the final configuration, modules decide to move based on fitness. The fitness depends on 1)
how close a module is to a connection configuration that matches one in the
final configuration, 2) how close its neighbours are. This work is extended by
Yoshida et al. where a diffusion process is added so units know the average
fitness in the neighbourhood (Yoshida et al., 1997). Additionally, deadlocks
are broken by adding the concept of irritation (if a module has not moved
for some time it will make a random move). A self-repair function is also
added where several final configurations are represented with changing number of modules. The idea is that if a module fails in a system consisting of n
modules the system will complete the final configuration with n − 1 modules.
These final configurations have priorities to ensure that the one involving
most modules is assembled. In (Yoshida et al., 1998) the representation is
similar except that the connection types have changed, because of new 3D
hardware. Tomita et al extend the representation with logical connection
types, which in effect enforces a building sequence on the system (Tomita
et al., 1999).
Bojinov et al. using the Proteo module suggest to use seeds and gradients
to control the self-reconfiguration process (Bojinov et al., 2000a; Bojinov
et al., 2000b). In this approach, seeds are used to focus growth, and gradients
are used to attract modules to the seeds to speed up the self-reconfiguration
process. Bojinov’s work is one of the few examples where the end result is
not deterministic, rather the final configuration emerges as an interaction
between the modules, the seeds, and the gradients.
Yim et al. (Yim et al., 2001b) extends the approach, described in (Yim
et al., 1997) and mentioned above, with a heat-based approach. In this
system, unfilled unconstrained goals produce heat and modules which have
not reached a final position consume heat. The modules then follow the heat
gradients. A combination of heat gradient and Euclidean distance gives the
best results.
99
CHAPTER 6. SELF-RECONFIGURATION ALGORITHMS
Jones and Matarić use a simulated two-dimensional square lattice of modules (Jones and Matarić, 2003). The modules are four-sided. The selfassembly proceeds in two phases. In the first phase, a goal configuration
is taken as input to a transition rule set compiler. The transition rule set
compiler outputs a set of local rules that specifies local relationships between
modules in the final configuration. In the second phase a module is identified
as a seed, and the growth of the configuration is initiated from this point.
Modules wander around randomly and get fixed in the final configuration
if a transition rule is matched. The transition rules cause the configuration
to be built from the inside out. This insures that the inside of a hollow
sub-configuration is built first.
6.4
Discussion
In the general discussion in Section 3.3 we argued that from the point of view
of robustness, centralized approaches are of limited use. This point is also
valid for self-reconfiguration algorithms. This point is also supported by the
fact that optimal planning of the motion of n robots, or in this case modules,
moving at the same time from one configuration to another, is intractable,
as the search space is exponential in n (Latombe, 1991). Therefore, selfreconfiguration planning and control is open to heuristic-based methods.
One way around the computational explosion is iterative improvement.
The idea is to find some suboptimal sequence of moves which leads from the
initial configuration to the final configuration. This suboptimal sequence of
moves is then optimized using local searches (Chirikjian, 1994; Chirikjian
et al., 1996; Pamecha et al., 1997). The suboptimal subsequences are identified using upper and lower bounds on the number of moves needed to reconfigure from the configuration at the start of the subsequence and to the
one at the end. Ideally, the upper and lower bounds will eventually be equal
which means that the reconfiguration sequence is optimal. The main problem of this idea is how to come up with the first plan and how to make good
metrics.
Chiang and Chirikjian divide the reconfiguration problem into a sequence
of intermediate configurations and use simulated annealing to find the reconfiguration plans between the intermediate configurations (Chiang and
Chirikjian, 2001). The problem of this approach is to identify good intermediate configurations.
The idea of intermediate configuration came from the Melt-Grow planner
proposed by Rus and Vona (Rus and Vona, 1999). In this work they choose
a long chain as the intermediate configuration, because it is relatively easy to
100
6.4. DISCUSSION
reconfigure into and out of a chain. The trade-off is a reduction in efficiency,
because it is not always optimal in terms of number of moves to reconfigure
into a chain.
A third option is to make a hierarchical planner. At the highest level
some of the motion constraints of the underlying hardware are abstracted
away to facilitate efficient planning. Using these high-level plans, the lower
level then produces the sequence of actions (Kotay and Rus, 2000; Unsal
et al., 2000; Unsal and Khosla, 2000; Prevas et al., 2002; Ünsal et al., 2001).
In this approach, again, it is not obvious that the cut between high-level
plans and low-levels actually makes as optimal a reconfiguration sequence as
possible.
Finally, meta modules consisting of more modules can be used. The idea
is that by planning at the meta-module level that there are no or few motion
constraints. This makes the planning tractable. On the other hand the meta
modules consist of several modules making the granularity of the robot bigger
(Kotay and Rus, 2000). A related approach is to make sure that the robot
maintains a uniform structure facilitating easier planning (Ünsal and Khosla,
2001). This is also referred to as scaffolding.
We have now briefly discussed the centralized approaches. What we have
seen is that the approaches all depend on heuristics which often results in
sub-optimal reconfiguration sequences. Furthermore, it appears there may
be little hope in improving these approaches. One option, which provides
hope and in fact makes planning much easier is the use of meta-modules or
a scaffolding structure. However, with the introduction of these restrictions
the problem falls into a category which might make distributed algorithms
feasible. This is the case with the Pacman algorithm, which has been implemented on a meta-module made of Telecubes (Vassilvitskii et al., 2002)
and on the Crystalline robot (Butler et al., 2001a; Butler and Rus, 2002)
which have few motion constraints — making them similar to meta-modules
in functionality.
If, for a moment, we look at self-reconfiguration planning for chain-type
robots, we can see that the problem is to a large degree solved at the planning
level (Casal and Yim, 1999; Yim et al., 2000b). The main problem is the
docking part of the self-reconfiguration sequence, which has been the focus
of (Shen and Will, 2001; Yim et al., 2002). These algorithms may even
be distributed using hormone-based control (Shen et al., 2002; Shen et al.,
2000b; Shen et al., 2000a; Salemi et al., 2001).
Let us return to lattice-type systems and look at the emergent approaches
to self-reconfiguration. In early work, the idea was to use local rules to the
degree it was possible and then add randomness to deal with the problems
which could not be solved using local rules. This is for instance true for
101
CHAPTER 6. SELF-RECONFIGURATION ALGORITHMS
the work on Fracta (Murata et al., 1994; Yoshida et al., 1997) and also later
work on other robots (Yoshida et al., 1998; Tomita et al., 1999). The problem
tended to be that even though the configuration often ended up in the desired
configuration it was not always the case.
This is also true for the work of Yim et al. (Yim et al., 1997; Yim et al.,
2001b). However, the chance of reaching the final configuration is higher,
because local communication is used to get some idea about the global shape
at the local level. This mechanism also makes the reconfiguration sequence
efficient.
The main shortcoming of these two approaches is the lack of guarantee
of convergence to the desired final configuration.
There were two main classes of solutions to these problems. One approach investigated by Bojinov et al. was to not focus on a particular final
configuration (Bojinov et al., 2000a; Bojinov et al., 2000b). Instead, the idea
is to build something with the right functionality. Using this approach it is
acceptable if a few modules are stuck as long as the structure maintains its
functionality. This approach is quite interesting, but there is no systematic
way to get from functionality to local rules. Rather these papers represent
some preliminary work in this direction.
The other class of solutions maintains the requirement that the selfreconfiguration process should end in a specific configuration. One approach
to this problem has been to design the construction rules in such a way that
self-reconfiguration problems will never occur (Jones and Matarić, 2003).
The modules that are not part of the structure will then move around randomly until the structure is complete. The trade-off here is that the algorithm
is guaranteed to reach the desired configuration eventually, but that the selfreconfiguration sequence is far from optimal. However, an interesting aspect
of this approach is the idea of automatically generating these construction
rules and thus having a systematic way of generating local rules based on a
desired configuration.
6.5
Conclusion
In this chapter we have looked at algorithms for self-reconfiguration. We surveyed existing algorithms for controlling self-reconfiguration and introduced
two additional performance metrics for evaluating self-reconfiguration algorithms. In the general discussion about algorithms for self-reconfigurable
robots in section 3.3 we argued that an emergent approach to the control
of self-reconfigurable is desirable. In the survey we saw how the centralized
algorithms use heuristics in different ways to produce as optimal plans as pos102
6.5. CONCLUSION
sible. An interesting idea, which came out of this, was to use meta-modules
and scaffolding structures, which simplified planning significantly. The emergent approaches generated a range of interesting ideas particularly the two
ideas; which we will mention here: 1) The idea of using local communication to obtain some global gradient information 2) progress in systematically
generating local rules based on desired final configurations. The emergence
based systems all have different — often very different — advantages and
disadvantages, and none of them can be said to have solved the problem by
providing a method which is at the same time robust, systematic, efficient,
and provably convergent.
103
CHAPTER 6. SELF-RECONFIGURATION ALGORITHMS
104
Chapter 7
Self-Reconfiguration Based on
Gradients and Cellular
Automata
In the previous chapter, we concluded that the self-reconfiguration algorithms
proposed so far all have their shortcomings in either robustness, systematicness, efficiency, or convergence properties. We also saw that different approaches have different shortcomings so if we look at the problems in isolation
we have some idea how to solve them. The problem is how to solve all four
at the same time. In chapter we combine and adjust the solutions proposed
to make a system which performs well on all four criteria simultaneously.
We insist on making a system based on local information because as we
pointed out in the discussion in Section 3.3, this class of control systems is
suitable for self-reconfigurable robots. Specifically, by insisting on a system
based on local information we ensure that the system is robust, which is one
of the key features of self-reconfigurable robots. We also saw in the general discussion that one of the problems is the problem of systematicness.
The problem is to generate local rules, based on a human-understandable
description of the desired configuration, which result in the desired configuration emerging. In order to address this shortcoming we suggest a method
where the local rules are generated using a three-dimensional model of the
final configuration. The self-reconfiguration process itself is controlled by
gradients, because they appear to be a robust and efficient way of obtaining
global information needed to perform efficient reconfiguration. Finally, we
ensure that the system converges to the desired configuration by insisting
on a specific substructure or scaffold in the configuration, which automatically ensures that the system converges. This means that we can assemble the
class of configurations which can be represented by a closed three-dimensional
shape.
105
CHP. 7. GRADIENT, AUTOMATA, AND SELF-RECONFIGURATION
7.1
Cellular Automata Rule Generator
The functionality of the cellular automata rule generator is to remove the
global aspects of the self-reconfiguration problem and make it possible to use
a local algorithm to control the self-reconfiguration process. This is achieved
by transforming a human-generated global representation of a desired configuration into local rules which will result in the configuration being assembled.
7.1.1
User Interface
It is difficult to directly make local rules which result in a desired configuration being assembled. Therefore, we need a systematic and automatic way
of transforming a human-understandable description of a desired configuration into the local rules which we will use for control. In our system, the
desired configuration is specified using a closed three-dimensional model in
the Wavefront .obj file format. This format is an industry standard and can
be exported from most CAD programs. An example of a three dimensional
model of a Boing 747 can be seen in Figure 7.1. The choice of this model is
inspired by Hoyle’s famous criticism of Darwinism.
A junkyard contains all the bits and pieces of a Boeing-747, dismembered and in disarray. A whirlwind happens to blow through
the yard. What is the chance that after its passage a fully assembled 747, ready to fly, will be found standing there?
Our self-reconfiguration problem is related: the probability that a selfreconfigurable robot self-reconfigure into a Boing-747 by chance is low. Therefore, we need to control the self-reconfiguration process.
7.1.2
Cellular Automata
The three-dimensional model is transformed into cellular automata rules,
which represent relationships between neighbour modules in the desired configuration. However, before we describe this transformation we will introduce
cellular automata.
Cellular automata are arranged in a grid. All grid cells contain identical cellular automata. Cellular automata are an extension of finite-state
automata, which change state depending on the state of cellular automata in
a neighbourhood. The neighbourhood can be defined in different ways, but
in this work we use the von Neumann neighbourhood shown in Figure 7.2.
Cellular automata were pioneered by von Neumann in the context of
self-replicating computational devices (von Neumann, 1966). Von Neumann
106
7.1. CELLULAR AUTOMATA RULE GENERATOR
Figure 7.1: At the top of this figure is shown a CAD model of a Boing 747.
Below is shown a configuration assembled from 9593 modules using our selfreconfiguration algorithms described in the following sections.
107
CHP. 7. GRADIENT, AUTOMATA, AND SELF-RECONFIGURATION
CA
CA
CA
CA
CA
CA
CA
CA
CA
CA
CA
CA
CA
CA
CA
CA
CA
CA
CA
CA
CA
CA
CA
CA
CA
Figure 7.2: This figure shows a grid of cells. In all cells identical cellular automata (CA) are running. Cellular automata can change their state depending on the state of a neighbourhood of cellular automata. The von Neumann
neighbourhood of the dark grey cell consists of the light grey colored cells.
used these to study computational complexity. Cellular automata were later
used in John Conway’s game of life where the focus was to study artificial
life (Gardner, 1970; Gardner, 1971). It was shown how surprisingly simple
cellular automata can lead to surprisingly life like behavior in simulation.
Cellular Automata were also part of the motivation for making the first selfreconfigurable robots. Murata writes: cellular automata lack a real representation in hardware (Murata et al., 1994). This representation in hardware
has been a little harder to come by than initially expected. However, Butler
et al. used cellular automata in their work on cluster flow algorithms (Butler
et al., 2001b).
Here we use cellular automata, because their formulation fits nicely with
the notion of modules in a lattice. The idea is that identical cellular automata run on each module in the lattice. An automaton and therefore its
corresponding module can only react to the state of the cellular automata in
its neighbour modules.
We use a three-dimensional version of a cellular automata where the automata and their modules are placed in a three-dimensional lattice. We use
an extension of the von Neumann neighbourhood of an automaton which includes the automata whose grid cells share a face with the automaton. This
neighbourhood will also be referred to as the neighbours.
108
7.1. CELLULAR AUTOMATA RULE GENERATOR
s=0
while(1) {
if ( s(1,0,0) = 1 ) then s = 2
if ( s(−1,0,0) = 2 ) then s = 1
if ( s(−1,0,0) = 1 ) then s = 5
if ( s(1,0,0) = 5 ) then s = 1
if
if
if
if
(
(
(
(
s(0,1,0) = 1 ) then s = 3
s(0,−1,0) = 3 ) then s = 1
s(0,−1,0) = 1 ) then s = 6
s(0,1,0) = 6 ) then s = 1
if
if
if
if
(
(
(
(
s(0,0,1) = 1 ) then s = 4
s(0,0,−1) = 4 ) then s = 1
s(0,0,−1) = 1 ) then s = 7
s(0,0,1) = 7 ) then s = 1
}
Figure 7.3: An example of a cellular automaton. The functionality of this
automaton is that if an automaton in the three-dimensional grid is assigned
state number 1, its generalized von Neumann neighbourhood and nothing else
will change state.
Let us introduce a little notation. We use direction vectors that refer to
neighbours D = {(1, 0, 0), (−1, 0, 0), (0, 1, 0), (0, −1, 0), (0, 0, 1), (0, 0, −1)}. We
define sd , where d ∈ D, to be the state of the neighbour cellular automaton in
the grid cell in direction d. The cellular automata we will use are simplified
in the sense that all state transition rules (or CA rules) are of the form: if the
cellular automata in direction d ∈ D is in state j then this cellular automata
should change to state k where k, j are integers. Figure 7.3 shows an example
of a cellular automata consisting of 12 such rules. The functionality of this
automaton is that if an automaton in a module is assigned state number 1
the modules contained in its von Neumann neighbourhood will also change
state.
7.1.3
CA Rule Generator
The problem is now how to get from the high-level three-dimensional CAD
model to the local rules which describe the desired configuration. We have
made a CA rule generator, which as input takes a three-dimensional model
109
CHP. 7. GRADIENT, AUTOMATA, AND SELF-RECONFIGURATION
and as output produces the corresponding CA rules. The CA rule generator
takes a closed three-dimensional model and a specified starting point inside
the model. From this starting point the model is, through a process similar
to three-dimensional flood filling, filled up with boxes representing modules.
Each box, whose center is contained within the volume, is given a unique
state number. The algorithm then outputs a set of CA rules, which specify
the neighbour relationships between these states. The algorithm is shown in
Figure 7.4.
In order to use this algorithm we need an algorithm to calculate whether
a given point is inside a model. This is a well-known problem from Computational Geometry. This is done by intersecting the model with a ray starting
at the point and ending outside the model. If this line intersects the triangles
of the model an uneven number of times, the point is inside the model.
Given a model, we are interested in approximating it using different numbers of modules. The number of modules needed to fill the three-dimensional
model depends on its volume and the volume of the boxes. The size of these
boxes can be adjusted using the scale parameter. A lower value indicates a
better approximation of the three-dimensional model, but more modules are
needed. In Figure 7.1 we can see that the 747 with the chosen scale is not
precisely represented, because parts of the wings are missing.
Let us consider an example. We consider a CAD module of a sphere with
radius 1. The starting point is (0, 0, 0). The sphere is filled with boxes of
side length 1. These boxes are given unique IDs. This gives seven boxes
whose centers are {1 : (0, 0, 0), 2 : (−1, 0, 0), 3 : (0, −1, 0), 4 : (0, 0, −1), 5 :
(1, 0, 0), 6 : (0, 1, 0), 7 : (0, 0, 1)}. From this, twelve rules are generated which
specify the relationship between these states. The resulting cellular automaton is shown in Figure 7.3. Now let us consider a scenario where this automaton is running in each module and the space is filled with modules. If we now
assign a state number to one of these modules, the neighbour modules will
then use the appropriate rules to change their state. These state changes
will propagate until all rules are satisfied. This results in all the modules
changing state in the desired configuration.
110
7.1. CELLULAR AUTOMATA RULE GENERATOR
GenerateRules( model, start_position, scale ) {
rules:
a mapping that given a state number and a
direction returns what the state of the neighbour
in that direction should be.
n:
the number of states/modules in the system.
positions:
list of positions that have not been handled yet.
positionToState: a mapping that given a position returns the
number of the state at that position
scale:
the resolution of the approximation. A small
scale means better approximation of the 3d model,
but also means that more modules are needed
positions.append( start_position )
positionToState.add( position, 0 )
n = 1
while( !positions.isEmpty() ) {
position = positions.head();
state = positionToState( position );
foreach <direction a neighbour module can be connected> {
direction = <unit vector pointing in the direction of the
neighbouring module.>
neighbourPos = position + scale*direction
if ( model.insideShape( neighbourPos ) )
if ( !positionToState.contains( neighbourPos ) ) {
neighbourState = n
n++
positions.append( neighbourPos )
positionToState.append( neighbourPos, neighbourState )
}
else {
neighbourState = positionToState( neighbourPos )
}
rules.append( state, direction, neighbourState )
}
}
return( rules );
}
Figure 7.4: Rule generator
111
CHP. 7. GRADIENT, AUTOMATA, AND SELF-RECONFIGURATION
A question that is worth addressing is why each module could not be
given the model instead of these rules. There are several reasons. 1) In order
to find its position in the model all the modules would have to agree on the
same coordinate system. 2) The modules would have to use computation
power to calculate if a module is inside the model or not. We can then see
that the advantage of this transformation is that we get rid of the global
coordinates and each module just has to know the state of its neighbour to
figure out its position in a configuration.
7.1.4
Scaffolding
The output of the rule generator is a list of local rules which describe the
neighbour relationship of modules in the desired configuration. Often, we
are not interested in having a module in each of the positions that the rules
specify. We may want, for instance, to remove modules which do not contribute to the shape or structural strength of the configuration. Here, we
are interested in removing modules from the final configuration in order to
make it easier to build from an algorithmic point of view. Specifically, we described in Section 6.2.2 that structures which contain hollow sub-structures,
solid sub-structures, or local minima, pose problems for self-reconfiguration
algorithms. In order to avoid these problems and reduce the complexity of
our algorithm we use the supporting framework or scaffold shown in Figure
7.5.
Figure 7.5: The cubes represent modules. The scaffold is shown to the left.
A cube built using this scaffold structure is shown to the right. Using this
scaffold makes it easier to self-reconfigure into the configuration.
112
7.2. FROM LOCAL RULES TO DESIRED CONFIGURATION
7.1.5
Running Time and Termination
Definition 6 Given a scale s ∈ R+ the set of coordinates Ps is defined as
{(xs, ys, zs)|x, y, z ∈ Z}.
Definition 7 Given a volume v and a scale s the function Cv,s : Ps →
Boolean returns true if p ∈ Ps is contained in v otherwise false. Cv,s runs
in O(t) where t is the number of triangles of the model.
Theorem 3 Given a scale s, a volume v, and the function Cv,s , and an
initial coordinate p|Cv,s (p) the rule generation algorithm terminates and runs
in O(nt) where n = |{p ∈ Ps |Cv,s (p)}| is the number of modules in the final
configuration and t is number of triangles in the model.
The list of not handled coordinates (referred to as positions in the algorithm listing) can at most contain n coordinates where n = |{p ∈ Ps |Cv,s (p)}|.
This holds because a coordinate p is only added to the list if p ∈ Ps , p has
not already been handled, and Cv,s (p). On each iteration, a coordinate is
removed from the list, which means that the algorithm will terminate after
O(n) iterations. Each iteration requires one execution of Cv,s which takes
O(t). This means that the total running time is O(nt). 7.2
From Local Rules to Desired Configuration
We have now seen how a set of cellular automata rules representing a three
dimensional model automatically can be generated. Starting from a random
configuration the robot needs to self-reconfigure into the desired configuration specified by the rules. The essential parts of the self-reconfiguration
algorithm are summarized below.
• All modules have a copy of the cellular automata rules.
• All modules are connected initially.
• One of the modules is given a state number.
• A module with a state number cannot move and cannot change state
and thus is in its final state and position.
• Modules without a state number are wandering modules.
113
CHP. 7. GRADIENT, AUTOMATA, AND SELF-RECONFIGURATION
• A module in its final state can detect, using the cellular automata
rules and sensors, whether a neighbour which is needed in the desired
configuration is missing.
• If a neighbour is needed, a module tries to attract wandering modules.
• Wandering modules move toward attracting modules while making sure
that modules or groups of modules do not get disconnected from the
robot.
• If a wandering module is in a neighbour position to a module in its
final state and a module is needed at this position in the desired configuration (as specified by the cellular automaton rules), the wandering
module changes state as specified by the appropriate rule.
In the following two sections we describe in more detail how modules
in their final state attract wandering modules and how wandering modules
move toward the attracting module while avoiding disconnection of modules
or groups of modules.
7.2.1
Vector Gradient
In order to attract modules to specific areas of the robot we need a mechanism
which, by using local communication, can give modules a sense of direction.
In this work, we use a mechanism inspired by diffusion of gases or chemicals.
In diffusion a source sends out a chemical, the chemical then slowly diffuses
in the environment, and the concentration at a given location is a function
of time and the distance to the source. In this work, we are interested in
capturing the notion that the concentration is a function of the distance to
the source. However, we are not interested in other elements of the metaphor
for now.
A simple implementation of this concept is the following. A source module sends out an integer representing a concentration to all its neighbours.
A non-source module calculates the concentration of the artificial chemical
at its position by taking the maximum received value and subtracting one.
This value is then propagated to all neighbours. Using this mechanism, we
abstract away the conservation laws of real diffusion and the dependence on
time, but have an identity function from the local concentration to the distance to the source. When wandering modules move around, they can use
the changes in local concentration to calculate a gradient and decide if they
are moving toward the source. We refer to this mechanism as a gradient and,
if it is used to attract modules, as an attraction gradient.
114
7.2. FROM LOCAL RULES TO DESIRED CONFIGURATION
Figure 7.6: The desired configuration with boxes representing modules is
shown to the left. This configuration has almost been built in the figure shown
to the right, but one module is missing in the top left corner. The cones represent modules and show the direction of the gradient vector. The darker a
module is, the higher the concentration. It can be seen that the vectors point
in the direction a wandering module should move in order to reach the source
in the top left corner. This prevents wandering modules from moving into
local minima.
This kind of gradient is used in Amorphous Computing by Abelson et al.
to make computation using a computation substrate made from many local
communicating elements (Abelson et al., 2000). This idea has also been used
by Nagpal et al. to control self-assembly in two dimensions (Nagpal et al.,
2003). The concept was explored in the context of multi-robot systems by
the author (Støy, 2001). Gradients were brought into the context of selfreconfigurable robots by Bojinov et al. (Bojinov et al., 2000b; Bojinov et al.,
2000a). It was also used by Yim et al. (Yim et al., 2001b), but in a more
complex formulation closer to real diffusion.
The simple formulation of gradients poses a problem, because modules
have to move around a while to calculate a good estimate of the gradient.
This is not a serious problem, but we have chosen to implement a more efficient version of the simple gradient, which we call vector gradients. In vector
gradients, the modules now in addition to the concentration also propagate
a gradient vector, which locally indicates the direction of the concentration
gradient. This vector is updated by taking the vector from the neighbour
with the maximum concentration, adding a unit vector in the direction of this
neighbour and normalizing the result. The effect of updating the gradient
vector according to this rule is that it points in the direction a module needs
to move locally in order to move to the source. This means that if wandering
modules follow the gradient vectors, local minima in the configuration are
avoided as shown in Figure 7.6.
115
CHP. 7. GRADIENT, AUTOMATA, AND SELF-RECONFIGURATION
7.2.2
The Connection Problem
We can, using gradients, attract modules to different parts of the robot and
through that control the self-reconfiguration process. However, in order to
make a working system we need to handle the connection problem. The
problem is to keep the configuration connected during self-reconfiguration.
Modules, or groups of modules, which get disconnected will fall down and
may be damaged. There are two general approaches to this problem. 1)
Ignore the problem and rely on disconnected modules being able to return
to the system. This could be feasible in systems where the modules are
underwater vehicles, or in environments where gravity is not an issue. In
gravity it might also be possible to use this idea. However, this requires that
the modules can handle the impact caused by them falling to the ground,
and that they are able to return and to reconnect with the structure. 2)
Insist that modules or collections of modules should never disconnect and
implement a mechanism to avoid it. In this work we take the latter position.
Yim et al. assume that each module has a sensor which can detect if it is
about to disconnect a group of modules (Yim et al., 2001b). We think it may
be hard to realize this sensor and therefore we have developed an algorithmic
solution to this problem.
In our algorithm, a simple gradient is propagated from the modules which
know they are already at their final position in the desired configuration.
We refer to this gradient as the connection gradient — as opposed to the
attraction gradient hill-climbed by wandering modules. In order to avoid
disconnection the module maintains an invariant. The invariant is that a
move is legal if it does not change the concentration of the connection gradient
of any neighbour modules.
Theorem 4 Using the invariant that a module can only move if removing
the module from the configuration does not change the concentration of neighbouring modules ensures that the system stays connected.
If the removal of a module means that none of the gradients of its neighbours change it implies that all neighbours either are closer to the source
or have an alternative path to the source. This again implies that if the
module is removed, the neighbours are connected to the structure through
the alternative paths. In our self-reconfiguration algorithms, connection gradient sources are
added as more and more modules reach their final position in the configuration. Therefore, we need to make sure that the addition of sources does not
cause the system to disconnect.
116
7.3. SIMULATED SYSTEM
99
98
97
99
98
97
97
96
98
97
99
95
94
Figure 7.7: This figure shows a 2D configuration. The boxes represent modules. Modules are connected to modules in neighbouring grid cells. The black
boxes represent gradient sources. The numbers in the boxes represent the gradient concentration in that module. The white boxes represent modules that
cannot move. The grey boxes indicate modules which can move. Note, that
only two of the modules surrounding the module with gradient 96 can move
without invalidating the invariant.
Theorem 5 Adding a source does not invalidate Theorem 4.
The sources are added in such a way that all source modules are always
connected. This implies that when a module makes the transition from
wandering to source it will not be disconnected.
Adding a source can only increase the number of paths to modules. This
means that: 1) before the new connection gradient has reached a module, it
will be connected through the old paths, 2) after the new connection gradient
has reached a module, it will at least be connected using the new connection
gradient. This implies that no non-source modules will be disconnected.
These two proofs imply that Theorem 4 still holds.
Figure 7.7 shows intuitively why this invariant prevents a module or collections of modules from disconnecting from the structure.
Note, that Theorem 4 does not hold if sources can be removed and therefore we cannot use the attraction gradient to keep the system connected.
7.3
Simulated System
In our simulation, we use modules which are more powerful than any existing
hardware platforms, but do fall within the definition of a Proteo module put
forward by Yim et al. (Yim et al., 2001b).
117
CHP. 7. GRADIENT, AUTOMATA, AND SELF-RECONFIGURATION
7.3.1
The Module
The modules are assumed to be cubical and, when connected, they form a
lattice structure. The modules have six hermaphrodite connectors and can
connect to six other modules in the directions: east, west, north, south, up,
and down. The modules directly connected to a module are referred to as
neighbours. A module can sense if there are modules in neighbouring lattice
cells. In this implementation we do not control the actuator of the connection
mechanism, but assume that neighbour modules are connected and disconnected appropriately. A module can only communicate with its neighbours.
A module is able to rotate around neighbours and is able to slide along the
surface of a layer of modules. Finally, we assume that direction vectors can
be uniquely transformed from the coordinate system of a module to the coordinate systems of its neighbours. This is necessary to propagate the vector
gradient and use the cellular automata rules. In the implementation, for
simplicity we assume that this transformation is the identity function.
7.3.2
The Simulation
The simulator is programmed in Java3D. The simulation uses time steps.
In each time step all the modules are picked in a random sequence and are
allowed: 1) to process the messages they have received since last time step,
2) to send messages to neighbours (but not wait for reply), and 3) to move
if possible. Only one module can execute at a time.
7.3.3
Motion Constraints
In order for a module to move it has to satisfy the motion constraints of the
system. This means that in order to move to a new position the new position
has to be free. If using the rotate primitive, the position that the module has
to rotate through to get to the new position has to be free as well. This is all
assumed to be sensed locally. If this is not possible for the rotate primitive,
the neighbour that a module is rotating around could be asked.
Included in satisfying the motion constraints is also the mutual exclusion
problem. This a situation which occur when two (or more) modules are
trying to move into the same position at the same time. See Figure 7.8 for an
example. An algorithmic solution to this problem requires each module to be
involved every time a module moves. This will result in an inefficient system.
Therefore, we argue that this should be sensed locally. That is, a module
initiates a move if the local motion constraints are satisfied. If it is sensed
that more than one module is moving into the same position, a competition
118
7.3. SIMULATED SYSTEM
?
Figure 7.8: This figure shows a 2D configuration. The boxes represent modules. Modules are connected to modules in neighbouring grid cells. The modules represented by the grey boxes both satisfy the motion constraints to move
into the position marked by the question mark. However, if they both do a
collision will occur.
for this position occurs. The simplest is to give priorities depending on
direction. In systems where directions are not global, biologically inspired
competition strategies may be useful. For instance, the modules may pick a
random number and the one with the highest number wins the competition.
If communication is not possible, we have to resort to physical display, for
instance by having modules with higher numbers daring to move closer to
other modules than modules with lower numbers. In some sense this is the
inverted chicken game which we have previously explored in the context of
multi-robot systems (Vaughan et al., 2000).
In our implementation the problem of mutual exclusion is not addressed,
because in the simulation only one module is allowed to move at a time.
However, in a real parallel-running system this problem has to be addressed.
7.3.4
Maintaining the Move Invariant
In order to make sure the move invariant holds, modules communicate with
neighbours before deciding to move. In Figure 7.7 this means that the module
119
CHP. 7. GRADIENT, AUTOMATA, AND SELF-RECONFIGURATION
with gradient 96 has to ensure that at least one of the modules with gradient
97 stays connected to it. This mutual exclusion algorithm is quite complex,
but it is needed to keep the system connected. Fortunately, this part of
the algorithm can be left out if modules are allowed to disconnect from the
structure or this information can be obtained using sensors.
7.4
Experiments
We pick two self-reconfiguration tasks taken from (Yim et al., 2001b). The
two tasks are to reconfigure from a rectangular plane to a disk orthogonal to
the plane and a sphere. The rules for these configurations are automatically
generated using the rule generator based on a mathematical description of
a sphere and a disk. These rules are then downloaded into the modules of
the simulation and the assembly process is started. An example assembly
process is visualized in Figure 7.9 together with the final disk and sphere
configurations.
We repeated the experiments twenty times with changing numbers of
modules. For each experiment we recorded the number of time steps needed,
the total number of moves, and calculated the theoretical lower bound on
the needed number of moves. The bound is the minimum number of moves
needed to reconfigure from the initial configuration to the final configuration
assuming that interference with other modules can be ignored.
The number of time steps needed to reconfigure grow approximately linearly with the number of modules (see Figure 7.10) which is comparable to
the results reported by Yim et al. (Yim et al., 2001b). In Figure 7.11 it can
be seen that the number of moves grows faster than linearly with the number
of modules. However, it can also be seen that the number of moves might
be growing proportionally to the theoretical lower bound. If this is true, it
implies that it is not possible to do significantly better, but more data have
to be available to conclude this. The data that the graphs are based on is
summarized in Table 7.1.
The number of moves and the time to complete a reconfiguration are
important characteristics of an algorithm. However, another aspect is the
amount of communication needed. This information is summarized in Table
7.4 and graphed in Figure 7.13 and 7.12.
120
7.4. EXPERIMENTS
1
2
3
4
5
6
Figure 7.9: This figure visualizes the reconfiguration process from plane to
disk (1-5). It also shows the final disk configuration (5) and the final sphere
configuration (6). The boxes represent modules. Dark grey indicates that
the module is in its final position. Light grey indicates that the module is
wandering.
121
CHP. 7. GRADIENT, AUTOMATA, AND SELF-RECONFIGURATION
500
disk
sphere
450
400
Time steps
350
300
250
200
150
100
50
0
0
50
100
150
200
250
300
Number of modules
350
400
450
500
Figure 7.10: This figure shows how the number of time-steps needed to reconfigure depends on the number of modules. The dependence is shown for both
the disk and the sphere configuration. It can be seen that the dependence is
linear with some indications that it might be sub linear. The results shown
are averaged over twenty trials and the standard deviation is also shown.
10000
disk
disk: theoretical lower bound
sphere
sphere: theoretical lower bound
9000
8000
7000
Moves
6000
5000
4000
3000
2000
1000
0
0
50
100
150
200
250
300
Number of modules
350
400
450
500
Figure 7.11: This figure shows how the number of moves needed to reconfigure
depends on the number of modules. The dependence is shown for both the
disk and the sphere. It can be seen that the dependence is linear with some
indications that it may be above linear. It is also shown how the theoretical
lower bound depends on the number of modules and configuration. The results shown are averaged over twenty trials and the standard deviation is also
shown.
122
7.4. EXPERIMENTS
conf.
D
D
D
D
S
S
S
S
n
69
145
249
437
51
119
257
425
time-steps
142 ±20
254 ±20
355 ±22
481 ±57
105 ±16
156 ±12
254 ±17
309 ±22
moves
bound
475 ±44
288
1676 ±112
922
3824 ±336
2068
8554 ±785
4590
261 ±22
125
893 ±60
461
2753 ±119
1620
5872 ±196
3446
Table 7.1: This table shows the data for the reconfiguration process. The
initial configuration is a rectangular plane and the final configuration is either
a disk perpendicular to the plane (D) or a solid sphere (S) as indicated in
the first column. The second column shows the number of modules. Time
steps indicate how long the reconfiguration took. Moves is the number of
physical moves the modules did during the reconfiguration process. The last
column shows the lower theoretical bound on the number of moves needed
to reconfigure from the initial to the final configuration. The experimental
results are given as an average of 20 trials and the std. dev. is also shown.
250000
Messages
200000
connect
scent
state
move
total
150000
100000
50000
0
100
150
200
250
Modules
300
350
.
Figure 7.12: This figure shows the amount of communication as a function
of the number of modules for the ball configuration. The communication for
the attraction and connection gradients are shown. It is also shown how
many messages are needed to handle the mutual exclusion between neighbour
modules before moving (move). The messages needed to propagate state information are also shown (state). Finally, the total number of messages is
shown (total)
123
CHP. 7. GRADIENT, AUTOMATA, AND SELF-RECONFIGURATION
conf.
D
D
D
D
S
S
S
S
n
69
145
249
437
51
119
257
425
t
142
254
355
481
105
156
254
309
connect
attraction
state
move
total
3973 ±333
6058 ±455
169 ±1 4328 ±356
14528 ±1077
13528 ±923
22277 ±1516 382 ±1 17004 ±1198 53190 ±3420
30407 ±2896 53435 ±4006 678 ±1 40960 ±2720 125479 ±9295
65811 ±7643 126850 ±9635 1217 ±2 96493 ±7903 290372 ±23861
2507 ±239
3648 ±385
62 ±0 1632 ±191
7850 ±767
8234 ±623
11374 ±661
170 ±1 7213 ±501
26990 ±1685
25361 ±1605 37925 ±1996 422 ±0 26541 ±1417 90249 ±4854
53052 ±2288 82959 ±3018 679 ±2 59898 ±2237 196589 ±7068
Table 7.2: This table summarizes the number of messages communicated during the reconfiguration. The initial
configuration is a rectangular plane and the final configuration is either a disk perpendicular to the plane (D) or a
solid sphere (S) as indicated in the first column. The second column is the number of modules n. The third is the
number of time-steps to complete the reconfiguration process (t). The number of messages communicated is divided
into four categories. The tables shows the messages used to: 1) propagate the connection gradient. 2) propagate the
attraction gradient. 3) propagate the state information. 4) coordinating local move operations. The total number of
messages is shown in the last column. The results shown are averaged over 20 trials and the standard deviation is
shown as well.
124
7.5. DISCUSSION & FUTURE DIRECTIONS
350000
300000
Messages
250000
connect
scent
state
move
total
200000
150000
100000
50000
0
100
150
200
250
300
350
400
450
500
Modules
.
Figure 7.13: This figure shows the amount of communication as a function
of the number of modules for the disk configuration. The communication
for the attraction and connection gradients are shown. It is also shown how
many messages are needed to handle the mutual exclusion between neighbour
modules before moving (move). The messages needed to propagate state information are also shown (state). Finally, the total number of messages is
shown (total)
7.5
Discussion & Future Directions
We will now discus cellular automata and gradient based self-reconfiguration
using the general metrics introduced in Section 3.2 and the application specific metrics introduced in Section 6.2. In the design of the algorithm we
have striven to make it as local as possible. This was, for instance, achieved
by using the CA rule generator to transform the global problem into a local
problem. However, it seems impossible to solve the problem of attraction
of modules to unfilled spots without using a global mechanism based on local communication. Fortunately, the modules do not critically depend on
the attraction gradient for achieving the goal; rather, it is an optimization.
However, the connection gradient is of a different nature. This gradient has
to be managed carefully, because the modules rely on this gradient to handle the connectivity problem. This is the weak spot of the algorithm. This
will also be indicated in the discussion below. The system is currently in
an early stage of development, therefore, we will base the discussion on our
experiments as well as possible extensions of the current system.
125
CHP. 7. GRADIENT, AUTOMATA, AND SELF-RECONFIGURATION
Robustness
The connection gradient, as mentioned, might cause problems with respect
to robustness. If a module fails, it is important that the connection gradient
is propagated to reflect this before modules move. Otherwise, modules might
be lost in the transition phase, because they depend on the failed module for
connection. The situation arises when a module has two neighbours closer
to the connection gradient source. If the module using the mutual exclusion
algorithm allows one to move and the other at the same time fails, the module
will be disconnected.
Another issue is when the final configuration has been assembled. In this
configuration a module might be located in a critical position where a failure
will cause the system to split in two. This might be prevented at compile
time, because the rules can be checked to verify that the system, for instance,
requires k failed modules before the structure becomes disconnected.
Communication errors are not a problem for gradient propagation, because the gradients are repropagated often. It might, however, be a problem
for the mutual exclusion algorithm. In the current implementation, modules
wait for replies from their neighbours when they have sent them a message.
This can easily be changed by implementing time-outs and resends.
Scale Extensibility
In the current implementation, the system is not scale extensible at runtime. If a configuration with more modules is needed a new rule set has to
be compiled.
Versatility
The algorithm can be used to build any fixed configuration which can be
described with a closed three-dimensional shape. The framework can be
adapted to produce locomotion. For instance, a finalized module can attract
a module to its east side. When the module has arrived, it is finalized and
can attract another module to its east side. The first module can then change
back into the wandering state. In this way, cluster-flow in a given direction
can be achieved. However, this has not been implemented.
In this work, we suggest using a scaffold to avoid the configuration problems which are traditionally difficult to handle by self-reconfiguration algorithms. The motivation for the scaffold is that we are most likely not going
to use the robot to build air-tight containers. Therefore, we may as well
make the holes in the structure bigger and therefore useful.
126
7.5. DISCUSSION & FUTURE DIRECTIONS
If we insist on a close packed configuration, this can also be achieved
using our system with a simple addition. When the desired configuration
with holes has been assembled, the attraction gradients will die out. This
can be detected by each module and the system can enter a phase where it
collapses. If this idea can be implemented, we can build configurations which
contain local minima, hollow sub configurations, or solid sub-configurations
without increasing the complexity of the algorithm significantly.
If this solution is unacceptable, which might be the case because the
scaffolding structure uses too many modules, we can handle the problem by
introducing a building sequence. The sequence can be introduced by giving
each position in the final configuration a number corresponding to its priority.
At run-time this number will be contained in the gradients, and gradients
with higher priority will suppress gradients with lower priority. In this way,
positions with high priority will be filled before positions with lower priority.
Using this mechanism, we can make sure that: 1) solid sub-configurations
are built from the inside and out, 2) the insides of hollow structures are
assembled first. It may also be possible to build in a sequence, which ensures
that no local minima will occur during construction, but how to do this is
not obvious.
Adaptability
The final configuration cannot be adapted to the environment. A simple
way to incorporate some feedback from the environment is to assume that
finalized modules do not attract modules to positions where they can sense
there is an obstacle. In this way the final configuration can be built to fit
into the environment. How, in general, to adapt the configuration to the
environment is beyond the scope of this work.
Environment Assumptions
The system as it is now assumes that the robot is working in a gravityfree environment with no obstacles. The reason is that during the selfreconfiguration process the system does not take stability of the structure
into account. The framework can be extended in several ways to handle
this. One way is to introduce sequences into the construction sequence, as
described above. However, we may need a new scaffold state for modules.
First, a layer of the final configuration is built and then modules are moved
into place to support the construction of the next layer and change to the
scaffold state. When the second layer has been built, the scaffolding modules
127
CHP. 7. GRADIENT, AUTOMATA, AND SELF-RECONFIGURATION
of layer one are not needed and detect this by detecting a change in gradient,
and then these scaffolding units return to wandering state.
The above-mentioned approach does not take the wandering modules into
account. If they all happen to be on one side of the structure during construction, they might cause the structure to tilt. This problem can be handled
by making a scaffolding structure, which handles the worst configuration of
wandering modules at all times, but this is inefficient. Therefore, another
approach may be to use sensors and an algorithm which gives wandering
modules an idea about how the center of mass of the current configuration
relates to the zero point moment. This information can be used by wandering
modules to ensure they move within the envelope of stability.
Scalability
We saw in the experimentation section that the time to complete a configuration scales less than linearly with the number of modules. Furthermore,
we saw that the number of moves scales slightly faster than linearly in the
number of modules. This is expected since the theoretical lower bound also
grows faster than linearly. This means that the algorithm is quite efficient
and its performance is comparable to that of (Yim et al., 2001b).
The algorithm itself uses constant time each time step. The gradients
are updated based on messages received since the last time step and then
propagated. The state messages are propagated if needed, and upon being
assigned a state number a module looks up its neighbour rules once. The
mutual exclusion algorithm is based on a simple request-reply mechanism
with one message being sent per time step.
Since the algorithm works this way, four messages maximum can be sent
through each connector per time-step and this limits the communication and
ensure that the requirement for communication bandwidth scales. However,
looked upon as a whole the system depends heavily on communication. In
one trial 1.5 messages are sent on average per module per time-step. These
messages originate from propagating two changing gradients, propagating
state information, and negotiations between neighbours for mutual exclusion
and thereby right to move. We can see that the number of messages depends
on the number of modules, but also on the number of moves and time-steps.
This is indicated by the fact that reconfiguration into the disk configuration uses significantly more messages than reconfiguration into the sphere
configuration even though the two configurations contain approximately the
same number of modules. In our current implementation, little is done to
minimize the number of messages, so there is room to improve the performance. The trade-off is the minimality of the algorithm. If we introduce
128
7.5. DISCUSSION & FUTURE DIRECTIONS
complex algorithms to minimize the number of messages, the algorithm is
not simple anymore. The specific implementation can trade these two aspects off to match the specific hardware. One thing worth noting is that if
the modules do not have to prevent disconnection from the structure, only
the attraction and state messages are needed, reducing the communication
load significantly.
Another scalability issue is the amount of memory needed to store the cellular automata rules. In the system, which we have presented here, there are
two rules for each connection in the final configuration. Given that a module
can have a maximum of six neighbours means that the memory requirement
grows as O(n). This is not satisfying. A solution is to use a representation
similar to the one proposed by Nagpal et al. (Nagpal et al., 2003) and also to
some degree explored by Bojinov et al. (Bojinov et al., 2000b; Bojinov et al.,
2000a). The idea is only to represent changes. For instance, a sphere can be
represented as a center and a radius. In our terminology this means that the
center module changes state and acts as gradient source with a concentration
k. All modules within k modules of the center will detect the gradient and be
finalized. This way only memory requirements may be reduced significantly.
Minimalism
We cannot make a strong claim regarding minimalism, because the system is
quite complex. This is not because the components are complicated; rather,
it is the number of them. The propagation of the two gradients is just blind
propagation: every time step a message is sent to each neighbour. The propagation of state only happens once per connection in the final configuration,
because once a module is finalized it does not move. If this was not the
case, it could also have been implemented as simple propagation. The most
complex part of the algorithm is the mutual exclusion negotiation, which is
needed to make sure that the system stays connected.
Compared to related work our approach is simpler. Yim et al (Yim
et al., 2001b) appears simpler, but that is because they assume that the
disconnection problem is handled by sensors. If this were the case, our system
would shrink to gradient and state propagation, making it a very simple
system. This is also the case for Bojinov et al. (Bojinov et al., 2000a;
Bojinov et al., 2000b); additionally, their approach is generative and the
resulting configurations are nondeterministic.
129
CHP. 7. GRADIENT, AUTOMATA, AND SELF-RECONFIGURATION
Systematicness
A strong point of the system is how we automatically get from a threedimensional CAD model to the cellular automata rules. This has previously
been demonstrated only by Jones and matarić (Jones and Matarić, 2003)
and in their case only in a two-dimensional self-assembling system.
Alternative Hardware
The most important question is whether the ideas presented here can be
transferred to physical hardware. We believe this is the case — maybe not
the specific algorithm, but the ideas. We think that the notion of gradients,
scaffolding, and automatic generation of cellular automata rules are useful
concepts when controlling the self-reconfiguration process. This claim also
finds support in literature as described in Chapter 6.
In the simulated self-reconfigurable robot we have presented in this chapter, the modules are autonomous, in the sense that modules only rely on
neighbours for support. This makes it ideal to model the self-reconfiguration
process as a cellular automata. In physical systems, this may not be the case,
because the movement of a module may require the help of neighbours. There
are several strategies to make such a system look like a cellular automaton.
One strategy is to introduce meta-modules. Meta-modules are collections
of modules which act together, because together they have very few motion
constraints and therefore behave like cellular automata. This approach is
problematic, because many modules go into producing one meta-module and
therefore the granularity of the system is low. In the Molecule, 54 modules
are needed to make a meta-module whereas, in the Telecubes, only eight are
needed. The second approach is to use a scaffold structure where movement
becomes easier and more cellular-automata-like. This approach may be explored further. It may be possible to make the scaffold in such a way that
the complexity of the module can be reduced. For instance, in our simulated
system it might not be necessary to use the slide motion, because it is always
possible to rotate instead.
There are some aspects which cannot be captured in the cellular automata
model, for instance, when the system is highly physically coupled. In such
a system many modules are moved at the same time by being attached to
a moving module. Currently, these systems are still to be seen, because the
torque needed to produce this kind of behavior is not available. However, this
may not only be a problem of torque. We may construct systems where some
modules work as counterbalance for other modules. How to self-reconfigure
optimally in these kinds of robots is still unexplored, but holds potential
because forces can be generated which are far beyond what a single module
can produce.
130
7.6. CONCLUSION
7.6
Conclusion
In the general discussion in Section 3.3 we argued that emergent control
systems are most suitable for self-reconfigurable robots. We saw in the survey
that emergent approaches for controlling the self-reconfiguration process all
have a shortcoming in one of the following categories: robustness, systematic
generation of rules, efficiency, or convergence properties. In this chapter we
have shown how our system performs on these criteria. We have presented
the cellular automata rule generator, which efficiently takes care of the first
issue. The experiments indicate that the self-reconfiguration process takes
time linear in the number of modules. This addresses the issue of efficiency.
Finally, through the use of scaffolding, the system is guaranteed to converge.
However, we have also seen that self-reconfiguration is not a purely local
problem and, therefore, we have to implement mechanisms which handle the
disconnection problem.
Another problem of the current implementation is scalability because of
memory requirements. The problem arises because each module has to represent the entire configuration. The size of this representation grows linearly
with the number of modules. This problem is not important for systems
consisting of hundreds or maybe even thousands of modules, but with more
modules the memory requirement becomes a constraint.
In general, we think that the system we have presented here presents an
interesting and new combination of existing ideas in the research field. We
feel that this approach, as we have argued in the discussion, has potential
to solve most of the current problems in self-reconfiguration. The only, and
probably the most important, question — which we leave unanswered —
is how well these ideas transfer to a physically-realized self-reconfigurable
robot.
131
CHP. 7. GRADIENT, AUTOMATA, AND SELF-RECONFIGURATION
132
Chapter 8
Conclusion
Self-reconfigurable robots hold potential to be able to move robotics into
new areas of application. In addition to traditional mass production environments, self-reconfigurable robots may become useful in real-world environments. These environments are characterized by being unstructured,
complex, dynamic, and unknown. Self-reconfigurable robots have an advantage over fixed-shape robots in these environments because of their special
abilities. These abilities include versatility, robustness, adaptability, and
scale extensibility.
In order to realize the potential of self-reconfigurable robots more research
is needed in the areas of hardware and control. The research on control
needs to be focused on real-world task-environments. Therefore, we have
introduced metrics and evaluation criteria with the aim of focusing research in
this direction. The metrics also directly reflect the features which distinguish
self-reconfigurable robots from traditional robots and encourage support of
these features by the control system.
The first challenge which needs to be solved, to move self-reconfigurable
robots into real-world environments, is the question of locomotion. In order to answer this question we have introduced role-based control. We have
through experiments with the CONRO self-reconfigurable robot shown how
well role-based control performs with respect to the metrics and evaluation
criteria.
Robustness. Locomotion gaits implemented using role-based control are
highly robust to communication errors and potential module failures.
Scale Extensibility. The robot can be extended at run-time with more
modules or modules can be removed.
133
CHAPTER 8. CONCLUSION
Versatility. We have shown five different locomotion gaits and even demonstrated that the system can change between two locomotion gaits as it
is dynamically reconfigured.
Adaptability. We have demonstrated that feedback from the environment
can be incorporated into role-based control.
Minimalism. Role-based control is minimal, indicated by the fact that all
control programs presented in this thesis are less than 2K bytes.
Scalability. We have shown how role-based control scales with an increase
in modules. Initial synchronization takes time O(dmax n) where dmax is
the maximum delay introduced into the synchronization signal. After
this initial phase the modules stay synchronized using constant time.
Role-based control uses a constant amount of bandwidth each period
and memory usage is proportional to the number of roles.
Environment Assumptions. The current work on using sensor feedback
in role-based control is preliminary, and therefore the system requires
the environment to be a flat surface.
Systematic. We have seen how the synchronization delays can be calculated systematically based on a description about which parts should
be synchronized. The design of the action sequences requires a trial
and error approach.
The key features which distinguish role-based control from related approaches are the ideas of local synchronization and delayed synchronization.
Instead of keeping the entire system synchronized at all times, modules can
just stay synchronized with neighbouring modules. This ensures that over
time the entire system becomes synchronized. Synchronization can also be
used in an application-specific way. The synchronization signals are purposefully delayed in order to support the locomotion gait. For instance, in the
Caterpillar each module is doing the same motion, but slightly delayed with
respect to the module in front of it. This results in a good implementation
with respect to the metrics of a Caterpillar because of the use of local and
delayed synchronization. This work is validated by the five conference papers
(Støy et al., 2002a; Støy et al., 2002b; Støy et al., 2002c; Støy et al., 2003a)
and two journal papers (Støy et al., 2002d; Støy et al., 2003b). Furthermore,
one of the papers was awarded best philosophical paper at the conference on
Simulation of Adaptive Behavior 2002 (Støy et al., 2002c). Another has been
selected for publication in a special journal issue on the best of Intelligent
Autonomous Systems 7 (Støy et al., 2002a).
134
Another topic we have covered is the control of self-reconfiguration for
lattice-type self-reconfigurable robots. Our solution combines artificial chemical gradients, cellular automata rules, scaffolding, and a local mutual exclusion algorithm. In the general discussion in Section 3.3 we argued that
emergent control systems are most suitable for self-reconfigurable robots.
We saw in the survey that the emergent approaches for controlling the selfreconfiguration process all have a shortcoming in one of the following categories: systematic generation of rules, efficiency, or convergence properties.
We have presented the cellular automata rule generator which efficiently takes
care of the first issue. The experiments indicate that the self-reconfiguration
process takes time linear in the number of modules. This addresses the issue
of efficiency. Finally, through the use of scaffolding the system is guaranteed
to converge. The algorithm has been evaluated using the metrics. Some of
the results are based on simulation, others are derived from the discussion.
Robustness. The gradients and cellular automata rules are robust to communication errors and module failure, but the mutual exclusion algorithm, in its current state it not.
Scale Extensibility. Changing the number of modules requires generation
of a new rule set.
Versatility. We can self-reconfigure into any shape that can be contained
within a closed three-dimensional shape. It can handle all self-reconfiguration
problems because of the scaffold mechanism.
Adaptability. No experiments on adaptability have been made.
Minimalism. The algorithm is comparable in complexity to related approaches.
Scalability. Experiments indicate that the time to complete a configuration scales linearly with the number of modules. The number of moves
grows slightly faster than linearly, but so does the theoretical bound.
The algorithm uses constant time per time-step. In the current simulation, communication load is not limited by the algorithm; rather,
modules are allowed to send four messages per connector per time-step
(one for each sub-component of the algorithm). This means that the
communication load is constant per module per time-step. The memory
requirement scales linearly in the number of modules and is probably
the most limiting constraint of the system in terms of scalability.
Environment Assumptions. There is no interaction with the environment.
135
CHAPTER 8. CONCLUSION
Systematicness. The rule generator can generate rules for any configuration contained within a closed three-dimensional CAD model.
The two approaches we presented in this thesis represent an effort to use
the principles of emergence to improve control systems for self-reconfigurable
robots. In the self-reconfiguration algorithm, we saw that complex shape
emerges from the local interaction of modules. Unfortunately, the connection problem made the algorithm far more complex than initially anticipated.
In role-based control this was not a problem. Therefore, role-based control
shows how powerful the principle of emergence can be: complex locomotion gaits emerge from the interaction of modules making simple oscillations.
Overall, this thesis represents significant progress in emergent control of selfreconfigurable robots.
136
Bibliography
Abelson, H., Allen, D., Coore, D., Hanson, C., Homsy, G., Knight, T., Nagpal,
R., Rauch, E., Sussman, G., and Weiss, R. (2000). Amorphous computing.
Communications of the ACM, 43(5):74–82.
Arkin, R. (1998). Behaviour-Based Robotics. MIT Press.
Beckers, R., Holland, O., and Deneubourg, J. (1994). From action to global task:
Stigmergy and collective robotics. In Proceedings, Artificial Life 4, pages
181–189, Cambridge, Massachusetts, USA.
Bojinov, H., Casal, A., and Hogg, T. (2000a). Emergent structures in modular
self-reconfigurable robots. In Proceedings, IEEE Int. Conf. on Robotics & Automation (ICRA’00), volume 2, pages 1734 –1741, San Francisco, California,
USA.
Bojinov, H., Casal, A., and Hogg, T. (2000b). Multiagent control of selfreconfigurable robots. In Proceedings, Fourth Int. Conf. on MultiAgent Systems, pages 143 –150, Boston, Massachusetts, USA.
Brooks, R. (1986). A robust layered control system for a mobile robot. IEEE
Journal of Robotics and Automation RA-2, pages 14–23.
Burdick, J., Radford, J., and Chirikjian, G. (1995). A sidewinding locomotion gait
for hyper-redundant robots. Advanced Robotics, 13(4):531–545.
Butler, Z., Byrnes, S., and Rus, D. (2001a). Distributed motion planning for
modular robots with unit-compressible modules. In Proceedings, IEEE/RSJ
International Conference on Intelligent Robots and Systems (IROS’01), volume 2, pages 790–796, Maui, Hawaii, USA.
Butler, Z., Fitch, R., and Rus, D. (2002a).
Distributed control for
unit-compressible robots: goal-recognition, locomotion, and splitting.
IEEE/ASME Transactions on Mechatronics, special issues on selfreconfigurable robots, 7(4):418–403.
Butler, Z., Fitch, R., and Rus, D. (2002b). Experiments in locomotion with a
unit-compressible modular robot. In Proceedings, IEEE/RSJ Int. Conf. on
Intelligent Robots and Systems, pages 2813–2818, Lausanne, Switzerland.
137
BIBLIOGRAPHY
Butler, Z., Fitch, R., and Rus, D. (2003). Experiments in distributed control of
modular robots. In Siciliano, B. and Dario, P., editors, Proceedings, Experimental Robotics VIII, volume 5 of Springer Tracts in Advanced Robotics,
page ? Springer.
Butler, Z., Fitch, R., Rus, D., and Wang, Y. (2002c). Distributed goal recognition
algorithms for modular robots. In Proceedings, IEEE International Conference on Robotics and Automation (ICRA’02), volume 1, pages 110–116,
Washington, DC, USA.
Butler, Z., Kotay, K., Rus, D., and Tomita, K. (2001b). Cellular automata for
decentralized control of self-reconfigurable robots. In Proceedings, IEEE Int.
Conf. on Robotics and Automation (ICRA’01), workshop on Modular SelfReconfigurable Robots, Seoul, Korea.
Butler, Z., Kotay, K., Rus, D., and Tomita, K. (2002d). Generic decentralized
control for a class of self-reconfigurable robots. In Proceedings, IEEE Int.
Conf. on Robotics and Automation (ICRA’02), volume 1, pages 809–815,
Washington, DC, USA.
Butler, Z., Murata, S., and Rus, D. (2002e). Distributed replication algorithms for
self-reconfiguring modular robots. In Proceedings, Distributed Autonomous
Robotic Systems 5 (DARS’02), pages 37–48, Fukuoka, Japan.
Butler, Z. and Rus, D. (2002). Distributed motion planning for 3-d modular robots
with unit-compressible modules. In Proceedings, Workshop on the Algorithmic
Foundations of Robotics, page ?, Nice, France.
Casal, A. and Yim, M. (1999). Self-reconfiguration planning for a class of modular
robots. In McKee, G. and Schenker, P., editors, Proceedings, Sensor Fusion
and Decentralized Control in Robotic Systems II, volume 3839, pages 246–257.
SPIE.
Castano, A., Chokkalingam, R., and Will, P. (2000). Autonomous and selfsufficient conro modules for reconfigurable robots. In Proceedings, 5th Int.
Symposium on Distributed Autonomous Robotic Systems (DARS’00), pages
155–164, Knoxville, Texas, USA.
Castano, A. and Will, P. (2001). Representing and discovering the configuration
of conro robots. In Proceedings, Int. Conf. on Robotics & Automation, Seoul,
Korea.
Chang, E. and Roberts, R. (1979). An improved algorithm for decentralized
extrema-finding in circular configurations of processes. Communications of
the ACM, 22(5):281–283.
138
BIBLIOGRAPHY
Chiang, C.-J. and Chirikjian, G. (2001). Modular robot motion planning using
similarity metrics. Autonomous Robots, 10(1):91–106.
Chirikjian, G. (1994). Kinematics of a metamorphic robotic system. In Proceedings, IEEE International Conference on Robotics and Automation(ICRA’94),
volume 1, pages 449–455, San Diego, California, USA.
Chirikjian, G. and Burdick, J. (1995). The kinematics of hyper-redundant robot
locomotion. IEEE transactions on robotics and automation, 11(6):781–793.
Chirikjian, G. and Pamecha, A. (1996). Bounds for self-reconfiguration of metamorphic robots. In Proceedings, IEEE International Conference on Robotics
and Automation (ICRA’96), volume 2, pages 1452–1457, Minneapolis, MN,
USA.
Chirikjian, G., Pamecha, A., and Ebert-Uphoff, I. (1996). Evaluating efficiency of
self-reconfiguration in a class of modular robots. Robotics Systems, 13:317–
338.
Dekhil, M., Sobh, T., and Efros, A. (1996). Commanding sensors and controlling
indoor autonomous mobile robots. In Proceedings, 1996 IEEE Int. Conf. on
Control Applications, pages 199 –204, Dearborn, Michigan, USA.
Gardner, M. (1970). The fantastic combinations of john conway’s new solutaire
game ”life”. Scientific American, 223(4):120–123.
Gardner, M. (1971). On cellular automata, self-reproduction, the gard of eden,
and the game of ”life”. Scientific American, 224(2):112–115.
Gibbons, A. (1985). Algorithmic Graph Theory. Cambridge University Press, New
York.
Hardy, N. and Ahmad, A. (1999). De-coupling for re-use in design and implementation using virtual sensors. Autonomous Robots, 6:265–280.
Henderson, T. and Shilcrat, E. (1984). Logical sensor systems. Robotic Systems,
1(2):169–193.
Hosokawa, K., Tsujimori, T., Fujii, T., Kaetsu, H., Asama, H., Kuroda, Y., and
Endo, I. (1998). Self-organizing collective robots with morphogenesis in a
vertical plane. In Proceedings, IEEE Int. Conf. on Robotics & Automation
(ICRA’98), pages 2858–2863, Leuven, Belgium.
Intanagonwiwat, C., Govindan, R., and Estrin, D. (2000). Directed diffusion: A
scalable and robust communication paradigm for sensor networks. In Proceedings, Sixth Annual Int. Conf. on Mobile Computing and Networking (MobiCOM ’00), pages 56–67, Boston, Massachussetts, USA.
139
BIBLIOGRAPHY
Jones, C. and Matarić, M. J. (2003). From local to global behavior in intelligent self-assembly. In Proceedings of the IEEE International Conference on
Robotics and Automation (ICRA’03), page (to appear), Taipei, Taiwan.
Khoshnevis, B., Kovac, B., Shen, W.-M., and Will, P. (2001). Reconnectable
joints for self-reconfigurable robots. In Proceedings, IEEE/RSJ Int. Conf. on
Intelligent Robots and Systems (IROS’01), volume 1, pages 584–589, Maui,
Hawaii, USA.
Kotay, K. and Rus, D. (2000). Algorithms for self-reconfiguring molecule motion
planning. In Proceedings, IEEE/RSJ International Conference on Intelligent
Robots and Systems (IROS’00, volume 3, pages 2184–2193, Maui, Hawaii,
USA.
Kotay, K., Rus, D., Vona, M., and McGray, C. (1998). The self-reconfiguring
robotic molecule. In Proceedings, IEEE Int. Conf. on Robotics & Automation
(ICRA’98), pages 424–431, Leuven, Belgium.
Kubica, J., Casal, A., and Hogg, T. (2001). Complex behaviors from local rules
in modular self-reconfigurable robots. In Proceedings, IEEE International
Conference on Robotics and Automation (ICRA’01), volume 1, pages 360–
367, Seoul, Korea.
Kurokawa, H., Tomita, K., Yoshida, E., Murata, S., and Kokaji, S. (2000). Motion
simulation of a modular robotic system. In Proceedings, 26th Annual Conference of the IEEEE, Industrial Electronics Society (IECON’00), volume 4,
pages 2473–2478, Nagoya, Aichi, Japan.
Latombe, J.-C. (1991). Robot Motion Planning. Kluwer.
Lund, H., Larsen, R., and Østergaard, E. (2003). Distributed control in selfreconfigurable robots. In Proceedings, 5th International Conference on Evolvable Systems: From Biology to Hardware (ICES’03), pages 296–307, Trondheim, Norway.
Matarić, M. J. (1997). Behavior-based control: Examples from navigation, learning, and group behavior. Journal of Experimental and Theoretical Artificial
Intelligence, 9(2–3):323–336.
Murata, S., Kurokawa, H., and Kokaji, S. (1994). Self-assembling machine. In
Proceedings, IEEE Int. Conf. on Robotics & Automation (ICRA’94), pages
441–448, San Diego, California, USA.
Murata, S., Kurokawa, H., Yoshida, E., Tomita, K., and Kokaji, S. (1998). A 3-d
self-reconfigurable structure. In Proceedings, IEEE Int. Conf. on Robotics &
Automation (ICRA’98), pages 432–439, Leuven, Belgium.
140
BIBLIOGRAPHY
Murata, S., Yoshida, E., Tomita, K., Kurokawa, H., Kamimura, A., and Kokaji,
S. (2000). Hardware design of modular robotic system. In Proceedings,
IEEE/RSJ Int. Conf. on Intelligent Robots and Systems (IROS’00), pages
2210–2217, Takamatsu, Japan.
Nagpal, R., Kondacs, A., and Chang, C. (2003). Programming methodology for
biologically-inspired self-assembling systems. In Proceedings, AAAI Spring
Symposium on Computational Synthesis: From Basic Building Blocks to High
Level Functionality.
Østergaard, E. (2002). Brief survey of morphology and attachment mechanisms of
existing physical self-reconfigurable robots in the centimetre scale. Part of the
HYDRA deliverable: HYDRA: Technology Review and Preliminary Building
Block Design Issues.
Pamecha, A., Ebert-Uphoff, I., and Chirikjian, G. (1997). Useful metrics for modular robot motion planning. IEEE Transactions on Robotics and Automation,
13(4):531–545.
Papadimitriou, C. (1994). Computational Complexity. Addison-Wesley.
Petri, C. (1962). Kommunikation mit Automaten. PhD thesis, University of Bonn.
Pfeifer, R. and Scheier, C. (1999). Understanding Intelligence. The MIT Press.
Prevas, K., Unsal, C., Efe, M., and Khosla, P. (2002). A hierarchical motion
planning strategy for a uniform self-reconfigurable modular robotic system.
In Proceedings, IEEE International Conference on Robotics and Automation
(ICRA’02), volume 1, pages 787–792, Washington, DC, USA.
Ramanathan, P., Shin, K., and Butler, R. (1990). Fault-tolerant clock synchronization in distributed systems. IEEE Computer, 23(10):33–44.
Rowland, J. and Nicholls, H. (1989). A modular approach to sensor integration
in robotic assembly. In Puente, E. and Nemes, L., editors, Information control problems in Manufacturing Technology, pages 371–376. IFAC, Pergamon
Press, Oxford, UK.
Rus, D. and Vona, M. (1999). Self-reconfiguration planning with compressible
unit modules. In Proceedings, IEEE International Conference on Robotics
and Automation (ICRA’99), volume 4, pages 2513–2530, Detroit, Michigan,
USA.
Rus, D. and Vona, M. (2001). Crystalline robots: Self-reconfiguration with compressible unit modules. Autonomous Robots, 10(1):107–124.
Salemi, B., Shen, W., and Will, P. (2001). Hormone controlled metamorphic
robots. In Proceedings, IEEE Int. Conf. on Robotics & Automation, pages
4194–4199, Seoul, Korea.
141
BIBLIOGRAPHY
Shen, W.-M., Salemi, B., and Will, P. (2000a). Hormone-based control for selfreconfigurable robots. In Proceedings, Int. Conf. on Autonomous Agents,
pages 1–8, Barcelona, Spain.
Shen, W.-M., Salemi, B., and Will, P. (2000b). Hormones for self-reconfigurable
robots. In Proceedings, Int. Conf. on Intelligent Autonomous Systems (IAS6), pages 918–925, Venice, Italy.
Shen, W.-M., Salemi, B., and Will, P. (2002). Hormone-inspired adaptive communication and distributed control for conro self-reconfigurable robots. IEEE
Transactions on Robotics and Automation, 18(5):700–712.
Shen, W.-M. and Will, P. (2001). Docking in self-reconfigurable robots. In Proceedings, IEEE/RSJ International Conference on Intelligent Robots and Systems
(IROS’01), volume 2, pages 1049–1054, Maui, Hawaii, USA.
Simons, B., Welch, J., and Lynch, N. (1990). An overview of clock synchronization. In Asilomar Workshop on Fault-tolerant Distributed Computing Conf.,
volume 448 of Lecture Notes in Computer Science, pages 84–96.
Støy, K. (1999). Adaptive control systems for autonomous robots. Master’s thesis,
University of Aarhus.
Støy, K. (2001). Using situated communication in distributed autonomous mobile
robots. In Proceedings, 7th Scandinavian Conf. on Artificial Intelligence,
pages 44–52, Odense, Denmark.
Støy, K., Shen, W.-M., and Will, P. (2002a). Global locomotion from local interaction in self-reconfigurable robots. In Proceedings, 7th Int. Conf. on Intelligent
Autonomous Systems (IAS-7), pages 309–316, Marina del Rey, California,
USA.
Støy, K., Shen, W.-M., and Will, P. (2002b). How to make a self-reconfigurable
robot run. In Proceedings, First Int. Joint Conf. on Autonomous Agents &
Multiagent Systems (AAMAS’02), pages 813–820, Bologna, Italy.
Støy, K., Shen, W.-M., and Will, P. (2002c). On the use of sensors in selfreconfigurable robots. In Proceedings, Seventh Int. Conf. on The Simulation
of Adaptive behavior (SAB’02), pages 48–57, Edinburgh, UK.
Støy, K., Shen, W.-M., and Will, P. (2002d). Using role based control to produce
locomotion in chain-type self-reconfigurable robot. IEEE Transactions on
Mechatronics, special issue on self-reconfigurable robots, 7(4):410–417.
Støy, K., Shen, W.-M., and Will, P. (2003a). Implementing configuration dependent gaits in a self-reconfigurable robot. In Proceedings, IEEE International
Conference on Robotics and Automation (ICRA’03), page (to appear), Taipei,
Taiwan.
142
BIBLIOGRAPHY
Støy, K., Shen, W.-M., and Will, P. (2003b). A simple approach to the control of
locomotion in self-reconfigurable robots. Robotics and Autonomous Systems,
page (to appear).
Suh, J., Homans, S., and Yim, M. (2002). Telecubes: mechanical design of a
module for self-reconfigurable robotics. In Proceedings, IEEE International
Conference on Robotics and Automation (ICRA’02), volume 4, pages 4095–
4101, Washington, DC, USA.
Tomita, K., Murata, S., Kurokawa, H., Yoshida, E., and Kokaji, S. (1999). A selfassembly and self-repair method for a distributed mechanical system. IEEE
Transactions on Robotics and Automation, 15(6):1035–1045.
Ünsal, C. and Khosla, P. (2000). Mechatronic design of a modular self-reconfiguring
robotic system. In Proceedings, IEEE International Conference on Robotics
& Automation (ICRA’00), pages 1742–1747, San Francisco, USA.
Unsal, C. and Khosla, P. (2000). Solutions for 3-d self-reconfiguration in a modular robotic system: Implementation and motion planning. In McKee, G.,
Gerard, T., and Schenker, P., editors, Proceedings, SPIE Sensor Fusion and
Decentralized Control in Robotic Systems III, volume 4196, pages 388–401.
SPIE.
Ünsal, C. and Khosla, P. (2001). A multi-layered planner for self-reconfiguration of
a uniform group of i-cube modules. In Proceedings, IEEE/RSJ International
Conference on Intelligent Robots and Systems (IROS’01), volume 1, pages
598–605, Maui, Hawaii, USA.
Ünsal, C., Kiliccote, H., and Khosla, P. (2001). A modular self-reconfigurable
bipartite robotic system: Implementation and motion planning. Autonomous
Robots, 10(1):23–40.
Unsal, C., Kiliccote, H., Patton, M., and Khosla, P. (2000). Motion planning for a
modular self-reconfiguring robotic system. In Proceedings, 5th International
Symposium on Distributed Autonomous Robotic Systems (DARS’00), page ?,
Knoxville, Tennessee, USA.
Vassilvitskii, S., Yim, M., and Suh, J. (2002). A complete, local and parallel
reconfiguration algorithm for cube style modular robots. In Proceedings, IEEE
International Conference on Robotics and Automation (ICRA’02), volume 1,
pages 117–122, Washington, DC, USA.
Vaughan, R., Støy, K., Sukhatme, G., and Matarić, M. (2000). Go ahead, make my
day: robot conflict resolution by aggressive competition. In Proceedings, 6th
International Conference on the Simulation of Adaptive Behavior (SAB’00),
pages 491–500, Paris, France.
143
BIBLIOGRAPHY
von Neumann, J. (1966). Theory of Self-Reproducing Automata. University of
Illinois Press, Urbana, Illinois, USA. Edited and completed by Authur W.
Burks.
Walter, J., Tsai, B., and Amato, N. (2002a). Choosing good paths for fast distributed reconfiguration of hexagonal metamorphic robots. In Proceedings,
IEEE International Conference on Robotics and Automation (ICRA’02), volume 1, pages 102–109, Washington, DC, USA.
Walter, J., Welch, J., and Amato, N. (2000a). Distributed reconfiguration of
hexagonal metamorphic robots in two dimensions. In McKee, G., Gerard,
T., and Schenker, P., editors, Proceedings, Sensor Fusion and Decentralized
Control in Robotic Systems III, volume 4196, pages 441–453. SPIE.
Walter, J., Welch, J., and Amato, N. (2000b). Distributed reconfiguration of metamorphic robot chains. In Proceedings, the Nineteenth Annual ACM SIGACTSIGOPS Symposium on Principles of Distributed Computing (PODC’00),
pages 171–180, Portland, Oregon, USA.
Walter, J., Welch, J., and Amato, N. (2002b). Concurrent metamorphosis of hexagonal robot chains into simple connected configurations. IEEE Transactions
on Robotics and Automation, 18(6):945–956.
Yim, M. (1993). A reconfigurable modular robot with many modes of locomotion.
In Proceedings of the JSME international conference on advanced mechatronics, pages 283–288, Tokyo, Japan.
Yim, M. (1994a). Locomotion with a unit-modular reconfigurable robot. PhD thesis,
Department of Mechanical Engineering, Stanford University.
Yim, M. (1994b). New locomotion gaits. In Proceedings, International Conference on Robotics & Automation (ICRA’94), pages 2508 –2514, San Diego,
California, USA.
Yim, M., Duff, D., and Roufas, K. (2000a). Polybot: A modular reconfigurable
robot. In Proceedings, IEEE International Conference on Robotics & Automation (ICRA’00), pages 514–520, San Francisco, CA, USA.
Yim, M., Goldberg, D., and Casal, A. (2000b). Connectivity planning for closedchain reconfiguration. In McKee, G., Gerard, T., and Schenker, P., editors,
Proceedings, Sensor Fusion and Decentralized control in Robotic Systems III,
volume 4196, pages 402–412. SPIE.
Yim, M., Homans, S., and Roufas, K. (2001a). Climbing with snake-like robots. In
Proceedings, IFAC Workshop on Mobile Robot Technology, pages –, Jejudo,
Korea.
144
BIBLIOGRAPHY
Yim, M., Lamping, J., Mao, E., and Chase, J. (1997). Rhombic dodecahedron
shape for self-assembling robots. Technical report, Xerox PARC. SPL TechReport P9710777.
Yim, M., Zhang, Y., Lamping, J., and Mao, E. (2001b). Distributed control for
3d metamorphosis. Autonomous Robots, 10(1):41–56.
Yim, M., Zhang, Y., Roufas, K., Duff, D., and Eldershaw, C. (2002). Connecting
and disconnecting for chain self-reconfiguration with polybot. IEEE/ASME
Transactions on Mechatronics, 7(4):442–451.
Yoshida, E., Murata, S., Kamimura, A., Tomita, K., Kurokawa, H., and Kokaji, S.
(2001a). A motion planning method for a self-reconfigurable modular robot.
In Proceedings, IEEE/RSJ International Conference on Intelligent Robots and
Systems (IROS’01), pages 590–597, Maui, Hawaii, USA.
Yoshida, E., Murata, S., Kamimura, A., Tomita, K., Kurokawa, H., and Kokaji,
S. (2001b). Reconfiguration planning for a self-assembling modular robot. In
Proceedings, IEEE International Symposium on Assembly and Task Planning,
pages 276–281, Fukoaka, Japan.
Yoshida, E., Murata, S., Kokaji, S., Kamimura, A., Tomita, K., and Kurokawa, H.
(2002). Get back in shape! a hardware prototype self-reconfigurable modular
microrobot that uses shape memory alloy. IEEE Robotics & Automation
Magazine, 9(4):54–60.
Yoshida, E., Murata, S., Kurokawa, H., Tomita, K., and Kokaji, S. (1998). A distributed reconfiguration method for 3-d homogeneous structure. In Proceedings, IEEE/RSJ International Conference on Intelligent Robots and Systems
(IROS’98), volume 2, pages 852–859, Victoria, B.C., Canada.
Yoshida, E., Murata, S., Tomita, K., Kurokawa, H., and Kokaji, S. (1997). Distributed formation control of a modular mechanical system. In Proceedings,
International Conference on Intelligent Robots and Systems (IROS’97), volume 2, pages 1090–1097, Grenoble, France.
Zhang, Y., Yim, M., Eldershaw, C., Duff, D., and Roufas, K. (2003). Phase
automata: a programming model of locomotion gaits for scalable chain-type
modular robots. In Proceedings, IEEE/RSJ conference on intelligent robots
and systems (IROS’03), Las Vegas, Nevada, USA.
145
BIBLIOGRAPHY
146
Appendix A
Statistics
In the statistical tests we use an F-test to test the hypothesis that the two
data sets have equal variance. Depending on this result we pick the appropriate version of Student’s t-test to test if the hypothesis that the mean value
of the two data sets are equal.
The first three data sets are from the caterpillar experiment where we
test the hypothesis that the caterpillar takes the same time to move 87cm
independent of the chance of signal loss. The table shows that at the 5%-level
the hypothesis is accepted and thus it can be assumed that it takes the same
time for the caterpillar to move independent of the chance of loss of signal.
F-test 50%
25%
100% 0.0027 0.025
50%
0.32
T-test 50%
100% 0.28
50%
-
25%
0.52
0.17
The next series of data is from the walker experiments. First we test the
hypothesis that the time used to walk 150cm is the same for the quadruped
and the hexapod walker. As shown in the table to the left below this hypothesis is rejected. Second we test the hypothesis that the time per step is
equal in the quadruped and hexapod walker. This hypothesis is accepted and
therefore we conclude that the performance of the two systems is independent
of the number of modules.
F-test
1
t-test 3.0 * 10−7
147
F-test 0.37
t-test 0.78