Emergent Control of Self-Reconfigurable Robots - CiteSeerX

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´ e (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˚ ade, modulerne er sat sammen p˚ a 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˚ a 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˚ a en metode til at styre selve omrekonfigureringsprocessen. Metoden best˚ ar 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˚ ar 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´c, 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 (Unsal 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 = t = 0 while(1) if (t=d(r)_1) then endif ... if (t=d(r)_n) then endif if then t=0 endif 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´c, 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 (Unsal 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 (Unsal 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´c use a simulated two-dimensional square lattice of modules (Jones and Matari´c, 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; Unsal 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 (Unsal 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´c, 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 = 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´c (Jones and Matari´c, 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´c, 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´c, 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. ¨ Unsal, 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. ¨ Unsal, 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. ¨ Unsal, 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´c, 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